コード例 #1
0
        public void OnEndRender()
        {
            if (_frameBuffer == null)
            {
                return;
            }
            _platform.LoadFrameBuffer(EnumFrameBuffer.Primary);
            GL.ClearBuffer(ClearBuffer.Color, 0, new [] { 0f, 0f, 0f, 1f });
            GL.ClearBuffer(ClearBuffer.Color, 1, new [] { 0f, 0f, 0f, 1f });

            var ambient    = _mod.CApi.Ambient;
            var uniforms   = _mod.CApi.Render.ShaderUniforms;
            var myUniforms = _mod.Uniforms;

            var fb        = _frameBuffer;
            var fbPrimary = _platform.FrameBuffers[(int)EnumFrameBuffer.Primary];

            _platform.GlDisableDepthTest();
            _platform.GlToggleBlend(false);
            GL.DrawBuffers(2, new [] { DrawBuffersEnum.ColorAttachment0, DrawBuffersEnum.ColorAttachment1 });

            var s = _shader;

            s.Use();

            s.BindTexture2D("gDepth", fbPrimary.DepthTextureId);
            s.BindTexture2D("gNormal", fbPrimary.ColorTextureIds[2]);
            s.BindTexture2D("inColor", fb.ColorTextureIds[0]);
            s.BindTexture2D("inGlow", fb.ColorTextureIds[1]);
            s.UniformMatrix("invProjectionMatrix", myUniforms.InvProjectionMatrix);
            s.UniformMatrix("invModelViewMatrix", myUniforms.InvModelViewMatrix);
            s.Uniform("dayLight", myUniforms.DayLight);
            s.Uniform("playerPos", uniforms.PlayerPos);
            s.Uniform("sunPosition", uniforms.SunPosition3D);


            if (ShaderProgramBase.shadowmapQuality > 0)
            {
                s.Uniform("shadowRangeFar", uniforms.ShadowRangeFar);
                s.Uniform("shadowRangeNear", uniforms.ShadowRangeNear);
                s.UniformMatrix("toShadowMapSpaceMatrixFar", uniforms.ToShadowMapSpaceMatrixFar);
                s.UniformMatrix("toShadowMapSpaceMatrixNear", uniforms.ToShadowMapSpaceMatrixNear);
            }

            s.Uniform("fogDensityIn", ambient.BlendedFogDensity);
            s.Uniform("fogMinIn", ambient.BlendedFogMin);
            s.Uniform("rgbaFog", ambient.BlendedFogColor);

            _platform.RenderFullscreenTriangle(_screenQuad);
            s.Stop();
            _platform.CheckGlError("Error while calculating deferred lighting");

            GL.DrawBuffers(4, new []
            {
                DrawBuffersEnum.ColorAttachment0, DrawBuffersEnum.ColorAttachment1,
                DrawBuffersEnum.ColorAttachment2, DrawBuffersEnum.ColorAttachment3
            });
            _platform.GlEnableDepthTest();
        }
コード例 #2
0
        public static void Blit(this ClientPlatformWindows platform, MeshRef quad, int source)
        {
            var blit = ShaderPrograms.Blit;

            blit.Use();
            blit.Scene2D = source;
            platform.RenderFullscreenTriangle(quad);
            blit.Stop();
        }
コード例 #3
0
        private void OnRenderSsrOut()
        {
            var ssrOutFB      = _framebuffers[(int)EnumSSRFB.Out];
            var ssrCausticsFB = _framebuffers[(int)EnumSSRFB.Caustics];
            var ssrFB         = _framebuffers[(int)EnumSSRFB.SSR];

            var ssrOutShader      = _shaders[(int)EnumSSRShaders.Out];
            var ssrCausticsShader = _shaders[(int)EnumSSRShaders.Caustics];

            if (ssrOutFB == null)
            {
                return;
            }
            if (ssrOutShader == null)
            {
                return;
            }

            GL.Disable(EnableCap.Blend);

            _platform.LoadFrameBuffer(ssrOutFB);

            GL.ClearBuffer(ClearBuffer.Color, 0, new[] { 0f, 0f, 0f, 1f });

            var myUniforms = _mod.Uniforms;
            var uniforms   = _mod.CApi.Render.ShaderUniforms;
            var ambient    = _mod.CApi.Ambient;

            var shader = ssrOutShader;

            shader.Use();

            shader.BindTexture2D("primaryScene",
                                 _platform.FrameBuffers[(int)EnumFrameBuffer.Primary].ColorTextureIds[0], 0);
            shader.BindTexture2D("gPosition", ssrFB.ColorTextureIds[0], 1);
            shader.BindTexture2D("gNormal", ssrFB.ColorTextureIds[1], 2);
            shader.BindTexture2D("gDepth", _platform.FrameBuffers[(int)EnumFrameBuffer.Primary].DepthTextureId, 3);
            shader.BindTexture2D("gTint", ssrFB.ColorTextureIds[2], 4);
            shader.UniformMatrix("projectionMatrix", _mod.CApi.Render.CurrentProjectionMatrix);
            shader.UniformMatrix("invProjectionMatrix", myUniforms.InvProjectionMatrix);
            shader.UniformMatrix("invModelViewMatrix", myUniforms.InvModelViewMatrix);
            shader.Uniform("zNear", uniforms.ZNear);
            shader.Uniform("zFar", uniforms.ZNear);
            shader.Uniform("sunPosition", _mod.CApi.World.Calendar.SunPositionNormalized);
            shader.Uniform("dayLight", myUniforms.DayLight);
            shader.Uniform("horizonFog", ambient.BlendedCloudDensity);
            shader.Uniform("fogDensityIn", ambient.BlendedFogDensity);
            shader.Uniform("fogMinIn", ambient.BlendedFogMin);
            shader.Uniform("rgbaFog", ambient.BlendedFogColor);

            _platform.RenderFullscreenTriangle(_screenQuad);
            shader.Stop();
            _platform.CheckGlError("Error while calculating SSR");

            if (_causticsEnabled && ssrCausticsFB != null && ssrCausticsShader != null)
            {
                _platform.LoadFrameBuffer(ssrCausticsFB);

                GL.ClearBuffer(ClearBuffer.Color, 0, new[] { 0.5f });

                shader = ssrCausticsShader;
                shader.Use();

                shader.BindTexture2D("gDepth", _platform.FrameBuffers[(int)EnumFrameBuffer.Primary].DepthTextureId, 0);
                shader.BindTexture2D("gNormal", ssrFB.ColorTextureIds[1], 1);
                shader.UniformMatrix("invProjectionMatrix", myUniforms.InvProjectionMatrix);
                shader.UniformMatrix("invModelViewMatrix", myUniforms.InvModelViewMatrix);
                shader.Uniform("dayLight", myUniforms.DayLight);
                shader.Uniform("playerPos", uniforms.PlayerPos);
                shader.Uniform("sunPosition", uniforms.SunPosition3D);
                shader.Uniform("waterFlowCounter", uniforms.WaterFlowCounter);

                if (ShaderProgramBase.shadowmapQuality > 0)
                {
                    var fbShadowFar = _platform.FrameBuffers[(int)EnumFrameBuffer.ShadowmapFar];
                    shader.BindTexture2D("shadowMapFar", fbShadowFar.DepthTextureId, 2);
                    shader.BindTexture2D("shadowMapNear", _platform.FrameBuffers[(int)EnumFrameBuffer.ShadowmapNear].DepthTextureId, 3);
                    shader.Uniform("shadowMapWidthInv", 1f / fbShadowFar.Width);
                    shader.Uniform("shadowMapHeightInv", 1f / fbShadowFar.Height);

                    shader.Uniform("shadowRangeFar", uniforms.ShadowRangeFar);
                    shader.Uniform("shadowRangeNear", uniforms.ShadowRangeNear);
                    shader.UniformMatrix("toShadowMapSpaceMatrixFar", uniforms.ToShadowMapSpaceMatrixFar);
                    shader.UniformMatrix("toShadowMapSpaceMatrixNear", uniforms.ToShadowMapSpaceMatrixNear);
                }

                shader.Uniform("fogDensityIn", ambient.BlendedFogDensity);
                shader.Uniform("fogMinIn", ambient.BlendedFogMin);
                shader.Uniform("rgbaFog", ambient.BlendedFogColor);

                _platform.RenderFullscreenTriangle(_screenQuad);
                shader.Stop();
                _platform.CheckGlError("Error while calculating caustics");
            }

            _platform.LoadFrameBuffer(EnumFrameBuffer.Primary);

            GL.Enable(EnableCap.Blend);
        }