Question

我已经使用FrameBuffer和Texture实现了一个简单的延迟渲染器。
绘图看起来像这样：

第一阶段
- 绑定帧缓冲区
- 创建颜色纹理并将其附加到帧缓冲区
- 清除颜色位并将 glClearColor 设置为该深蓝色/灰色
- 绘制具有变化颜色的四边形（内部绿色四边形）
第二阶段
- 设置默认帧缓冲
- 清除颜色位并将 glClearColor 设置为洋红色
- 绘制（几乎）全屏四边形并使用颜色纹理

代码（C＃）：

        private void Setup()
        {
            {
                _shader = new Shader();
                _shader.AddShader( ShaderType.VertexShader , vertShaderSource );
                _shader.AddShader( ShaderType.FragmentShader , fragShaderSource );
                _shader.CompileAndLink();

                _vertexArray = new VertexArray();
                _vertexArray.Bind();

                _vertexBuffer = new VertexBuffer();
                _vertexBuffer.SetLayout<float>();
                _vertexBuffer.Bind();
                _vertexBuffer.Update( ObjectData );

                _indexBuffer = new IndexBuffer();
                _indexBuffer.SetLayout<int>();
                _indexBuffer.Bind();
                _indexBuffer.Update( ObjectIndices );

                GL.VertexAttribPointer( index: 0 , size: 3 , VertexAttribPointerType.Float , normalized: false ,
                    stride: sizeof( float ) * 3 , offset: 0 );
                GL.EnableVertexAttribArray( 0 );

                _uniformBuffer = new UniformBuffer();
                _uniformBuffer.SetLayout<uUniformBlock>();
                _uniformBuffer.Bind();
                _uniformBuffer.Reserve( 1 );

                _shader.BindUniformBuffer( _uniformBuffer , nameof( uUniformBlock ) , UNIFORM_BLOCK_BINDING_uUniformBlock );

                _vertexArray.Unbind();
                _vertexBuffer.Unbind();
                _uniformBuffer.Unbind();
            }

            // Quad
            {
                _frameBuffer = new FrameBuffer();
                _frameBuffer.Bind();

                _quadTexture = new Texture( TextureTarget.Texture2D , this.Width , this.Height );
                _quadTexture.Bind();

                GL.GenerateMipmap( GenerateMipmapTarget.Texture2D );

                _frameBuffer.Attach( FramebufferAttachment.ColorAttachment0 , _quadTexture );
                _frameBuffer.CheckStatus();

                _quadShader = new Shader();
                _quadShader.AddShader( ShaderType.VertexShader , quadVertShaderSource );
                _quadShader.AddShader( ShaderType.FragmentShader , quadFragShaderSource );
                _quadShader.CompileAndLink();

                _quadVertexArray = new VertexArray();
                _quadVertexArray.Bind();

                _quadVertexBuffer = new VertexBuffer();
                _quadVertexBuffer.SetLayout<float>();
                _quadVertexBuffer.Bind();
                _quadVertexBuffer.Update( QuadData );

                // Pos X Y
                GL.VertexAttribPointer( index: 0 , size: 2 , VertexAttribPointerType.Float , normalized: false ,
                    stride: sizeof( float ) * 4 , offset: sizeof( float ) * 0 );
                GL.EnableVertexAttribArray( 0 );
                // TexCoord U V
                GL.VertexAttribPointer( index: 1 , size: 2 , VertexAttribPointerType.Float , normalized: false ,
                    stride: sizeof( float ) * 4 , offset: sizeof( float ) * 2 );
                GL.EnableVertexAttribArray( 1 );

                _quadVertexArray.Unbind();
                _quadVertexBuffer.Unbind();
                _quadTexture.Unbind();
            }
        }

        private double _totalTime = 0.0;

        protected override void OnRenderFrame( FrameEventArgs args )
        {
            base.OnRenderFrame( args );

            GL.Clear( ClearBufferMask.ColorBufferBit );

            _totalTime += args.Time;

            var color = new Vector3( (float)Math.Sin( _totalTime * 2.0 ) ,
                                     (float)Math.Cos( _totalTime * 3.0 ) ,
                                     (float)Math.Tan( _totalTime * 1.0 ) );

            var uniformBlackData = new uUniformBlock() {
                uR = color.X ,
                uG = color.Y ,
                uB = color.Z ,
            };

            // first pass
            {
                _frameBuffer.Bind();

                GL.Clear( ClearBufferMask.ColorBufferBit );
                GL.ClearColor( 0.2f , 0.3f , 0.3f , 1.0f );

                _shader.Activate();
                // _shader.SetUniform( "uColor" , color );

                _vertexArray.Bind();
                _uniformBuffer.Bind(); // TODO: is this needed?
                _uniformBuffer.Update( uniformBlackData );

                GL.DrawElements( PrimitiveType.Triangles , count: ObjectIndices.Length ,
                    DrawElementsType.UnsignedInt , IntPtr.Zero );

                _vertexArray.Unbind();
            }

            // second pass
            {
                FrameBuffer.BindDefaultFrameBuffer();

                GL.Clear( ClearBufferMask.ColorBufferBit );
                GL.ClearColor( 1.0f , 0.0f , 1.0f , 1.0f );

                _quadShader.Activate();
                GL.ActiveTexture( TextureUnit.Texture0 + 0 );
                _quadShader.SetUniform( "uTexture0" , 0 );

                _quadVertexArray.Bind();
                _quadTexture.Bind();

                GL.DrawArrays( PrimitiveType.Triangles , 0 , 6 );

                _quadVertexArray.Unbind();
            }

            base.SwapBuffers();
        }

它看起来像这样：

但是，我希望结果是相反的-互换了灰色和洋红色的颜色。被渲染为具有灰色背景的纹理和第二相四边形纹理是否不应该被洋红色包围（因为其略小于窗口大小）？
这幅图片是正确的还是我的理解不够准确？

Answer 1

在清除缓冲区之前，您必须设置清除颜色：

~~GL.Clear( ClearBufferMask.ColorBufferBit );~~
~~GL.ClearColor( 0.2f , 0.3f , 0.3f , 1.0f );~~

GL.ClearColor( 0.2f , 0.3f , 0.3f , 1.0f );
GL.Clear( ClearBufferMask.ColorBufferBit );

GL.ClearColor指定GL.Clear( ClearBufferMask.ColorBufferBit )用于填充帧缓冲区中像素的颜色。

请参见OpenGL Wiki页面glClear：

glClear将窗口的位平面区域设置为先前由glClearColor，glClearDepth和glClearStencil选择的值。 [...]

OpenGL：帧缓冲区-绘制纹理-glClearColor

1 个答案: