Пример #1
0
        protected virtual void RenderSceneForCamera(Scene scene, Camera camera, int eye)
        {
            _graphicsDevice.SetRenderTargets(m_ColorTarget, m_NormalTarget, m_DepthTarget);

            foreach (var pass in m_ClearEffect.Techniques[0].Passes)
            {
                pass.Apply();
                m_QuadRenderer.RenderFullscreenQuad();
            }

            using (_graphicsDevice.GeometryState())
                RenderObjects(scene, camera);

            using (_graphicsDevice.LightState())
                RenderLights(scene, camera, eye);

            _graphicsDevice.SetRenderTarget(_sceneRenderTargets[eye]);
            _graphicsDevice.Clear(Color.Black);

            using (_graphicsDevice.PostProcessState())
            {
                foreach (var pass in m_CombineEffect.Techniques[0].Passes)
                {
                    m_CombineEffect.Parameters["ColorMap"].SetValue(m_ColorTarget);
                    m_CombineEffect.Parameters["LightMap"].SetValue(m_LightTarget);
                    pass.Apply();
                    m_QuadRenderer.RenderFullscreenQuad();
                }

                RenderPostProcess(scene.postProcessPasses, _sceneRenderTargets[eye]);

                if (!m_VREnabled)
                {
                    RenderToBackBuffer();
                    RenderUI(scene.Behaviours);
                }
            }
        }
Пример #2
0
        public override void Render(Scene scene)
        {
            var camera = scene.cameras[0];

            RebuildRenderTargets();

            RenderShadowMaps(scene);

            m_graphicsDevice.SetRenderTargets(m_ColorTarget, m_NormalTarget, m_DepthTarget);

            foreach (var pass in m_ClearEffect.Techniques[0].Passes)
            {
                pass.Apply();
                m_QuadRenderer.RenderFullscreenQuad(m_graphicsDevice);
            }

            if (scene.RenderSettings.Skybox.Enabled)
            {
                scene.RenderSettings.Skybox.DrawDeferred(m_graphicsDevice, camera);
            }

            using (m_graphicsDevice.GeometryState())
            {
                foreach (var renderer in scene.renderList)
                {
                    // FIXME: Materials have to be updated.
                    m_TempRenderEffect.Parameters["World"].SetValue(renderer.m_Transform.m_WorldMatrix);
                    m_TempRenderEffect.Parameters["View"].SetValue(camera.m_ViewMatrix);
                    m_TempRenderEffect.Parameters["Projection"].SetValue(camera.m_ProjectionMatrix);
                    m_TempRenderEffect.Parameters["Texture"].SetValue(renderer.material.MainTexture);
                    m_TempRenderEffect.CurrentTechnique.Passes[0].Apply();
                    renderer.Draw(m_graphicsDevice);
                }
            }

            m_graphicsDevice.SetRenderTargets(null);
            m_graphicsDevice.SetRenderTarget(m_LightTarget);
            m_graphicsDevice.Clear(Color.Transparent);

            using (m_graphicsDevice.LightState())
            {
                foreach (var light in scene.lights)
                {
                    light.RenderDeferred(m_ColorTarget, m_NormalTarget, m_DepthTarget, camera);
                }
            }

            m_graphicsDevice.SetRenderTargets(null);

            using (m_graphicsDevice.PostProcessState())
            {
                foreach (var pass in m_CombineEffect.Techniques[0].Passes)
                {
                    m_CombineEffect.Parameters["ColorMap"].SetValue(m_ColorTarget);
                    m_CombineEffect.Parameters["LightMap"].SetValue(m_LightTarget);
                    pass.Apply();
                    m_QuadRenderer.RenderFullscreenQuad(m_graphicsDevice);
                }
            }

            RenderUI(scene.Behaviours);
        }