C# Camera.SetDeviceViewAndProjection方法代码示例

        private static void DrawIndividualLayer(Camera camera, RenderMode renderMode, Layer layer, Section section)
        {
            bool hasLayerModifiedCamera = false;

            if (layer.Visible)
            {
                Renderer.CurrentLayer = layer;

                if (section != null)
                {
                    string layerName = "No Layer";
                    if(layer != null)
                    {
                        layerName = layer.Name;
                    }
                    Section.GetAndStartContextAndTime("Layer: " + layerName);
                }
                ClearBackgroundForLayer(camera);


                #region Set View and Projection
                // Store the camera's FieldOfView in the oldFieldOfView and
                // set the camera's FieldOfView to the layer's OverridingFieldOfView
                // if necessary.
                mOldCameraLayerSettings.SetFromCamera(camera);

                Vector3 oldPosition = camera.Position;

                if (layer.LayerCameraSettings != null)
                {
                    layer.LayerCameraSettings.ApplyValuesToCamera(camera, SetCameraOptions.PerformZRotation, null);
                    hasLayerModifiedCamera = true;
                }

                camera.SetDeviceViewAndProjection(mCurrentEffect, layer.RelativeToCamera);
                #endregion


                if (renderMode == RenderMode.Default)
                {
                    if (layer.mZBufferedSprites.Count > 0)
                    {
                        DrawZBufferedSprites(camera, layer.mZBufferedSprites);
                    }

                    // Draw the camera's layer
                    DrawMixed(layer.mSprites, layer.mSortType,
                        layer.mTexts, layer.mBatches, layer.RelativeToCamera, camera, section);

                    #region Draw Shapes

                    DrawShapes(camera,
                        layer.mSpheres,
                        layer.mCubes,
                        layer.mRectangles,
                        layer.mCircles,
                        layer.mPolygons,
                        layer.mLines,
                        layer.mCapsule2Ds,
                        layer);

                    #endregion
                }

                // Set the Camera's FieldOfView back
                // Vic asks:  What if the user wants to have a wacky field of view?
                // Does that mean that this will regulate it on layers?  This is something
                // that may need to be fixed in the future, but it seems rare and will bloat
                // the visible property list considerably.  Let's leave it like this for now
                // to establish a pattern then if the time comes to change this we'll be comfortable
                // with the overriding field of view pattern so a better decision can be made.
                if (hasLayerModifiedCamera)
                {
                    mOldCameraLayerSettings.ApplyValuesToCamera(camera, SetCameraOptions.ApplyMatrix, layer.LayerCameraSettings);
                    camera.Position = oldPosition;
                }
                if (section != null)
                {
                    Section.EndContextAndTime();
                }
            }
        }

        /// <summary>
        /// Custom drawing technique - sets graphics states and
        /// draws the custom shape
        /// </summary>
        /// <param name="camera">The currently drawing camera</param>
        #endregion
        public void Draw(Camera camera)
        {
            if (Visible)
            {
                // Set graphics states
                FlatRedBallServices.GraphicsDevice.RenderState.FillMode = FillMode.Solid;
                FlatRedBallServices.GraphicsDevice.RenderState.CullMode = CullMode.None;

                // Set the vertex declaration
                FlatRedBallServices.GraphicsDevice.VertexDeclaration = mVertexDeclaration;

                // Have the current camera set our current view/projection variables
                camera.SetDeviceViewAndProjection(mEffect, false);

                // Here we get the positioned object's transformation (position / rotation)
                mEffect.World = base.TransformationMatrix;

                if (mPositionColorVertices != null)
                {
                    mEffect.VertexColorEnabled = true;
                    mEffect.TextureEnabled = false;
                }
                else
                {
                    mEffect.VertexColorEnabled = false;
                    mEffect.TextureEnabled = true;
                    mEffect.Texture = Texture;
                }


                // Start the effect
                mEffect.Begin();
                foreach (EffectPass pass in mEffect.CurrentTechnique.Passes)
                {
                    // Start each pass

                    pass.Begin();
                    if (mPositionColorVertices != null)
                    {
                        // Draw the shape
                        FlatRedBallServices.GraphicsDevice.DrawUserIndexedPrimitives<VertexPositionColor>(
                            PrimitiveType.TriangleList,
                            mPositionColorVertices, 0, mPositionColorVertices.Length,
                            mIndices, 0, mIndices.Length / 3);
                    }
                    else
                    {
                        // Draw the shape
                        FlatRedBallServices.GraphicsDevice.DrawUserIndexedPrimitives<VertexPositionTexture>(
                            PrimitiveType.TriangleList,
                            mPositionTextureVertices, 0, mPositionTextureVertices.Length,
                            mIndices, 0, mIndices.Length / 3);
                    }

                    // End each pass
                    pass.End();
                }
                // End the effect
                mEffect.End();
            }
        }