Exemplo n.º 1
0
        /// <summary>
        /// Allows the game component to draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {
            fSpriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
            fBasicEffect.View                = fCamera.Camera.ViewMatrix;
            fBasicEffect.Projection          = fCamera.Camera.ProjectionMatrix;
            GraphicsDevice.DepthStencilState = fStateDepth;

            Matrix planeMatrix = fCamera.Camera.WorldMatrix;

            if (!fHalted)
            {
                double seconds = gameTime.TotalGameTime.TotalSeconds;
                float  angle   = (float)seconds / 3;
                Matrix matrix  = Matrix.CreateRotationY(angle);
                planeMatrix = matrix;
            }


            Effect effect = fBasicEffect;

            if (fDrawMode == DrawMode.WireFrame)
            {
                GraphicsDevice.RasterizerState = fStateWire;
            }
            else
            {
                GraphicsDevice.RasterizerState = fStateSolid;
            }

            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                fBasicEffect.World = planeMatrix;
                pass.Apply();

                switch (fDrawMode)
                {
                case DrawMode.Grid:
                    fPlane.RenderLines(fSpriteBatch);
                    break;

                case DrawMode.Solid:
                case DrawMode.WireFrame:
                    fPlane.RenderTriangles(fSpriteBatch);
                    break;
                }
            }
            //GraphicsDevice.RasterizerState.FillMode = FillMode.Solid;
            fSpriteBatch.End();
            base.Draw(gameTime);
        }
Exemplo n.º 2
0
        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.Black);

            fSpriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);

            GraphicsDevice.DepthStencilState = fStateDepth;

            Matrix planeMatrix = fCamera.Camera.WorldMatrix;
            //if (!fHalted)
            double seconds = gameTime.TotalGameTime.TotalSeconds;
            float  angle   = (float)seconds / 200;
            Matrix matrix  = Matrix.CreateRotationY(angle);

            planeMatrix = matrix;


            Matrix objectMatrix;

            angle        = (float)seconds * 1.3f * 0.01f;
            matrix       = Matrix.CreateRotationY(angle) * Matrix.CreateRotationX(angle * 0.04f);
            objectMatrix = matrix;

            angle = (float)seconds * 0.8f;
            Vector3 lightPos1 = new Vector3(Convert.ToSingle(00000 + 2500 * Math.Sin(angle)), Convert.ToSingle(2500 * Math.Sin(angle * 0.3f)), 00000 + Convert.ToSingle(2500 * Math.Cos(angle)));
            Vector3 lightPos3 = new Vector3(Convert.ToSingle(10000 + 2500 * Math.Sin(angle)), 500, 10000 + Convert.ToSingle(2500 * Math.Cos(angle)));
            Vector3 lightPos2 = new Vector3(Convert.ToSingle(00000 + 2500 * Math.Sin(angle + Math.PI)), 500, 00000 + Convert.ToSingle(2500 * Math.Cos(angle + Math.PI)));
            Vector3 lightPos4 = new Vector3(Convert.ToSingle(10000 + 2500 * Math.Sin(angle + Math.PI)), 500, Convert.ToSingle(10000 + 2500 * Math.Cos(angle + Math.PI)));

            Effect effect;

            if (fShaderMode == ShaderMode.Basic)
            {
                effect                  = fBasicEffect;
                fBasicEffect.View       = fCamera.Camera.ViewMatrix;
                fBasicEffect.Projection = fCamera.Camera.ProjectionMatrix;
                fBasicEffect.World      = planeMatrix;
            }
            else
            {
                effect = fPointLightEffect;
                effect.CurrentTechnique = effect.Techniques[fShaderMode.ToString()];
                effect.Parameters["World"].SetValue(planeMatrix);
                effect.Parameters["View"].SetValue(fCamera.Camera.ViewMatrix);
                effect.Parameters["Projection"].SetValue(fCamera.Camera.ProjectionMatrix);
                var worldInverseTransposeMatrix = Matrix.Transpose(Matrix.Invert(planeMatrix));
                effect.Parameters["WorldInverseTranspose"].SetValue(worldInverseTransposeMatrix);
                effect.Parameters["LightPos1"].SetValue(lightPos1);
                effect.Parameters["LightPos2"].SetValue(lightPos2);
                effect.Parameters["LightPos3"].SetValue(lightPos3);
                effect.Parameters["LightPos4"].SetValue(lightPos4);
                //effect.Parameters["xWorldViewProjection"].SetValue(Matrix.Identity * viewMatrix * projectionMatrix);
                //effect.Parameters["xTexture"].SetValue(streetTexture);

                //effect.Parameters["xWorld"].SetValue(Matrix.Identity);
                //effect.Parameters["xLightPos"].SetValue(lightPos);
                //effect.Parameters["xLightPower"].SetValue(lightPower);
                //effect.Parameters["xAmbient"].SetValue(ambientPower);
            }

            if (fDrawMode == DrawMode.WireFrame)
            {
                GraphicsDevice.RasterizerState = fRenderWireFrame;
            }
            else
            {
                GraphicsDevice.RasterizerState = fRenderSolid;
            }

            bool renderPlanes  = false;
            bool renderObjects = false;

            switch (fRenderObjects)
            {
            case RenderObjects.All:
                renderPlanes  = true;
                renderObjects = true;
                break;

            case RenderObjects.ObjectsOnly:
                renderObjects = true;
                break;

            case RenderObjects.PlaneOnly:
                renderPlanes = true;
                break;
            }
            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();
                if (renderPlanes)
                {
                    fPlane.RenderTriangles(fSpriteBatch);
                    foreach (var plane in fPlanes)
                    {
                        plane.RenderTriangles(fSpriteBatch);
                    }
                }
                if (renderObjects)
                {
                    fObject1.RenderTriangles(fSpriteBatch);
                }
            }
            fSpriteBatch.End();


            base.Draw(gameTime);
        }