示例#1
0
        protected override void OnRenderPre(IRenderer renderer)
        {
            base.OnRenderPre(renderer);

            ICamera oldCam = renderer.CurrentCamera;

            lightCam.Viewport = new Viewport(0, 0, shadowMap.Width, shadowMap.Height);// oldCam.Viewport;
            lightCam.SetFrame(sl.Position, Matrix.LookAt(sl.Position, Vector3.Zero, Vector3.Up));
            lightCam.SetProjection(ProjectionMode.Orthographic, 400, 400, 1.0f, 1000.0f);
            // lightCam.SetProjection(45f, 1f, 500f);
            lightCam.Update();

            Viewport viewport  = lightCam.Viewport;
            float    invWidth  = (viewport.Width > 0) ? (1f / ((float)viewport.Width)) : 0f;
            float    invHeight = (viewport.Height > 0) ? (-1f / ((float)viewport.Height)) : 0f;
            Matrix   matrix    = new Matrix();

            matrix.M11 = invWidth * 2f;
            matrix.M22 = invHeight * 2f;
            matrix.M33 = 1f;
            matrix.M44 = 1f;
            matrix.M41 = -1f;
            matrix.M42 = 1f;
            matrix.M41 = matrix.M41 - invWidth;
            matrix.M42 = matrix.M42 - invHeight;

            Matrix projection = Matrix.CreateOrthoMatrix(0, viewport.Width, viewport.Height, 0, 0, 1);

            blurEffect.Parameters["SpriteTransform"].SetValue(projection);

            Matrix ortho       = Matrix.CreateOrthoMatrix(30, 30, 1.0f, 200f);
            Matrix view        = Matrix.CreateViewMatrix(sl.Position, Vector3.Zero, Vector3.Up);//Matrix.LookAt(sl.Position, Vector3.Zero, Vector3.Up);
            Matrix viewproj    = view * ortho;
            Matrix viewprojcam = lightCam.ViewProjectionMatrix;

            renderer.CurrentCamera = lightCam;

            renderer.SetRenderTarget(shadowMap);
            renderer.Clear(Color.White);

            renderer.EnforcedMaterial          = shadowMat;
            renderer.EnforcedDepthStencilState = dss;
            if (cullFront)
            {
                renderer.EnforcedRasterizerState = rs;
            }
            mesh.Render(renderer);
            renderer.ClearEnforcedStates();
            renderer.EnforcedMaterial = null;

            /*
             * //Pass 2 - Draw from shadow to blur rt blur horizontally
             * renderer.EnforcedRasterizerState = RasterizerState.CullNone;
             * renderer.SetRenderTarget(blurRT);
             * SetBlurEffectParameters(1.0f / (float) blurRT.Width, 0);
             * DrawFullScreenQuad(shadowMap, BlendState.Opaque, blurRT.Width, blurRT.Height, blurEffect);
             *
             * //Pass 3 - Draw from blurRT to shadowmap, blur vertically
             * renderer.SetRenderTarget(shadowMap);
             * SetBlurEffectParameters(0, 1.0f / (float) shadowMap.Height);
             * DrawFullScreenQuad(blurRT, BlendState.Opaque, shadowMap.Width, shadowMap.Height, blurEffect);
             */
            renderer.CurrentCamera = oldCam;
            renderer.SetRenderTarget(null);

            receiverMat.SetParameter("LightVP", lightCam.ViewProjectionMatrix);
            receiverMat.SetParameter("LightDirection", sl.Direction);
            receiverMat.SetParameter("ShadowMap", shadowMap);
        }
示例#2
0
        protected virtual void Render(IRenderer renderer)
        {
            //Get the window's swap chain
            SwapChain swapChain = _window.SwapChain;

            //Primary drawing to the window, sets the backbuffer render targets and clears them
            swapChain.Clear(_clearColor);

            if (_wireFrame)
            {
                renderer.EnforcedRasterizerState = RasterizerState.CullNoneWireframe;
            }

            OnRenderPre(renderer);

            //Draw the scenegraph
            _rootNode.Draw(renderer);

            //Debbuging for bounding volumes
            if (_debugBounds)
            {
                GeometryDebugger.DrawBounds(_rootNode, renderer);
            }

            //Debugging for normals and tangents/binormals if they exist for the mesh
            if (_debugNormals)
            {
                GeometryDebugger.DrawTangentBasis(_rootNode, renderer);
            }

            if (_wireFrameSolid)
            {
                renderer.RenderQueue.SortAndRender();
                //renderer.EnforcedRasterizerState = RasterizerState.CullNoneWireframe;
                RasterizerState rs = new RasterizerState();
                rs.Cull                          = CullMode.None;
                rs.DepthBias                     = -100;
                rs.SlopeScaledDepthBias          = 5f;
                rs.Fill                          = FillMode.WireFrame;
                renderer.EnforcedRasterizerState = rs;
                renderer.EnforcedMaterial        = _wireFrameSolidMat;
                renderer.RenderQueue.RenderBuckets();
                renderer.RenderQueue.ClearBuckets();

                renderer.ClearEnforcedStates();
                renderer.EnforcedMaterial = null;
            }
            else
            {
                //Finally sort the render queue and draw remaining elements
                renderer.RenderQueue.SortRenderClear();
            }

            //Any extra rendering
            OnRenderPost(renderer);

            if (_wireFrame || _wireFrameSolid)
            {
                renderer.ClearEnforcedState(RenderStateType.RasterizerState);
            }

            //Lastly, draw GUI - we do this via a spritebatch and do it last
            //so it's rendered over everything (including anything from OnRender()
            DrawInstructions(renderer);

            //Present to the window
            swapChain.Present();

            //Count the frame for FPS display
            CountFrame();
        }