CSharpGL(33)使用uniform块来优化对uniform变量的读写

CSharpGL(33)使用uniform块来优化对uniform变量的读写

+BIT祝威+悄悄在此留下版了个权的信息说：

Uniform块

如果shader程序变得比较复杂，那么其中用到的uniform变量数量也会上升。通常会在多个shader程序中用到同一个uniform变量。而uniform buffer object就是一种优化uniform变量访问，以及在不同的shader程序间共享uniform数据的方法。

写法

首先了解一下uniform块的写法。

 uniform b { // ‘b’ 对应于外部访问时的名称
     vec4 v1;// 块中的变量列表
     bool v2;// …
 }; // 访问成员时使用v1、v2

或者

 uniform b { // ‘b’ 对应于外部访问时的名称
     vec4 v1;// 块中的变量列表
     bool v2;// …
 } name; // 访问成员时使用name.v1、name.v2

注意，shader程序中的数据类型有两种：不透明的和透明的；其中不透明的包括sampler、image和atomic counter。一个uniform块中只能包含透明类型的变量。

另外，在同一个shader程序里的两个uniform块，里面的变量名都不能相同。

下面我们以具体例子的编写过程来说明在如何使用uniform块，顺便了解一下CSharpGL是如何简化对uniform块的使用的。

+BIT祝威+悄悄在此留下版了个权的信息说：

Shader

我认为用Modern OpenGL渲染，首先要写shader。我们先看一个简单的vertex shader。

 #version  core

 uniform mat4 projectionMatrix;
 uniform mat4 viewMatrix;
 uniform mat4 modelMatrix;

 in vec3 vPos;
 in vec3 vColor;
 out vec3 fColor;

 void main(void) {

     gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(vPos, 1.0);

     fColor = vColor;
 }

我们就把这里面的uniform变量换作块，如下，只是把原来的uniform变量包了起来，并命名为“Uniforms”。

 #version  core

 uniform Uniforms {
     mat4 projectionMatrix;
     mat4 viewMatrix;
     mat4 modelMatrix;
 };

 in vec3 vPos;
 in vec3 vColor;
 out vec3 fColor;

 void main(void) {

     gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(vPos, 1.0);

     fColor = vColor;
 }

而fragment shader则更简单：

 #version  core

 in vec3 fColor;

 out vec4 out_Color;

 void main(void) {
     out_Color = vec4(fColor, 1.0f);
 }

+BIT祝威+悄悄在此留下版了个权的信息说：

准备工作

传送一个自定义的struct

Uniform块，实际上对应一个在应用程序客户端的struct类型。对于示例中的‘Uniforms’块，我们可以定义如下的结构体。为了方便对照，我们也用‘Uniforms’作为 struct 名，其实你可以用任意你喜欢的名字。

     struct Uniforms : IEquatable<Uniforms>
     {
         public mat4 projection;
         public mat4 view;
         public mat4 model;

         public Uniforms(mat4 projection, mat4 view, mat4 model)
         {
             this.projection = projection;
             this.view = view;
             this.model = model;
         }

         public bool Equals(Uniforms other)
         {
             return this.projection == other.projection
                 && this.view == other.view
                 && this.model == other.model;
         }
     }

今后我们就将数据准备好后保存到一个 Uniforms 对象，最终传送到shader。

uniform块结构

这里是重点了。传送float类型的uniform变量，我们有 UniformFloat ；传送vec3类型的uniform变量，我们有 UniformVec3 。但是uniform块传送的是一个个可以任意自定义的不同的结构体（例如上面的struct Uniforms），因此最好用一个泛型的 UniformBlock<T> 。

     public class UniformBlock<T> : UniformSingleVariableBase where T : struct, IEquatable<T>
     {
         protected T value;

         public T Value
         {
             get { return this.value; }
             set
             {
                 if (!value.Equals(this.value))
                 {
                     this.value = value;
                     this.Updated = true;
                 }
             }
         }

         public UniformBlock(string blockName) : base(blockName) { }

         public UniformBlock(string blockName, T value) : base(blockName) { this.Value = value; }

         protected override void DoSetUniform(ShaderProgram program)
         {
             // ...
         }
     }

UniformBlock<T> 更新uniform块的操作比较复杂：它要创建一个uniform buffer object，并与之绑定；以后它只需更新这个buffer里的数据，就可以实现对uniform块的更新。

        protected override void DoSetUniform(ShaderProgram program)
         {
             if (uniformBufferPtr == null)
             {
                 uniformBufferPtr = Initialize(program);
             }
             else
             {
                 IntPtr pointer = uniformBufferPtr.MapBuffer(MapBufferAccess.WriteOnly, bind: true);
                 unsafe
                 {
                     var array = (byte*)pointer.ToPointer();
                     byte[] bytes = this.value.ToBytes();
                     for (int i = ; i < bytes.Length; i++)
                     {
                         array[i] = bytes[i];
                     }
                 }
                 uniformBufferPtr.UnmapBuffer(unbind: true);
             }

             this.Updated = false;
         }

         /// <summary>
         /// Initialize and setup uniform block's value.
         /// </summary>
         /// <param name="program"></param>
         /// <returns></returns>
         private UniformBufferPtr Initialize(ShaderProgram program)
         {
             uint uboIndex = glGetUniformBlockIndex(program.ProgramId, this.VarName);
             var uboSize = new uint[];
             glGetActiveUniformBlockiv(program.ProgramId, uboIndex, OpenGL.GL_UNIFORM_BLOCK_DATA_SIZE, uboSize);
             UniformBufferPtr result = null;
             using (var buffer = new UniformBuffer<byte>(BufferUsage.StaticDraw, noDataCopyed: false))
             {
                 byte[] bytes = this.value.ToBytes();
                 buffer.Create(bytes.Length);
                 unsafe
                 {
                     var array = (byte*)buffer.Header.ToPointer();
                     for (int i = ; i < bytes.Length; i++)
                     {
                         array[i] = bytes[i];
                     }
                 }

                 result = buffer.GetBufferPtr() as UniformBufferPtr;
             }

             // 将此uniform块与此uniform buffer object绑定。
             glBindBufferBase(OpenGL.GL_UNIFORM_BUFFER, uboIndex, result.BufferId);

             return result;
         }

         private UniformBufferPtr uniformBufferPtr = null;

DoSetUniform

SetUniform()

对于普通的uniform变量，CSharpGL用 Renderer.SetUniform(string varName, T value) where T : struct 即可（无论是什么类型的uniform都可以处理）。对于Uniform块，也可以用这个方法！

+BIT祝威+悄悄在此留下版了个权的信息说：

UniformBlockRenderer

有了上述准备，我们就可以使用uniform块了。

创建渲染器

按照CSharpGL的传统，下面来创建一个UniformBlockRenderer，负责加载shader、模型数据和渲染工作。

     class UniformBlockRenderer : Renderer
     {
         public static UniformBlockRenderer Create()
         {
             var model = new Teapot();// model
             var shaderCodes = new ShaderCode[];// shaders
             shaderCodes[] = new ShaderCode(File.ReadAllText(@"shaders \UniformBlock.vert"), ShaderType.VertexShader);
             shaderCodes[] = new ShaderCode(File.ReadAllText(@"shaders \UniformBlock.frag"), ShaderType.FragmentShader);
             var map = new AttributeNameMap();// mapping relation between model and shaders
             map.Add("vPos", Teapot.strPosition);
             map.Add("vColor", Teapot.strColor);
             var renderer = new UniformBlockRenderer(model, shaderCodes, map);// renderer

             return renderer;
         }
     }

设置uniform块的值

就像普通的uniform变量一样，我们也在 Renderer.DoRender() 方法里更新uniform块。

         protected override void DoRender(RenderEventArgs arg)
         {
             mat4 projection = arg.Camera.GetProjectionMatrix();
             mat4 view = arg.Camera.GetViewMatrix();
             mat4 model = this.GetModelMatrix();
             // 设置uniform块，只需这一行。
             this.SetUniform("Uniforms", new Uniforms(projection, view, model));

             base.DoRender(arg);
         }

完成的效果如图，能够正常渲染，说明我们成功地更新了uniform块里的数据。

+BIT祝威+悄悄在此留下版了个权的信息说：

下载

CSharpGL已在GitHub开源，欢迎对OpenGL有兴趣的同学加入（https://github.com/bitzhuwei/CSharpGL）

+BIT祝威+悄悄在此留下版了个权的信息说：

总结

借助C#的struct与byte[]的相互转换，加上CSharpGL对Modern Rendering的封装，实际上我们不需要调用 glGetUniformIndices 、 glGetActiveUniformsiv （用于获取shader中uniform块里的各个变量的偏移量）这些接口，就可以使用uniform块了。

当shader中写了一个uniform块时，你只需在应用程序客户端也写一个对应的 struct ，然后用 Renderer.SetUniform(blockName, structObj); 一行即可实现对uniform块数据的更新。

PS：测试过程中发现对于vec3结果正常，但是vec4却有诡异的情况，后来想到应用程序客户端里的vec4与shader里的vec4的xyzw布局不一样，可能因此导致原本属于w的数据最终传送到了shader里的y上。于是在调整了CSharpGL里的vec4的字段顺序后就一切正常了。为了避免以后我或者其他人在忘记\不知情的情况下擅自改动了vec4的字段顺序，我用 [FieldOffset(...)] 特性标注了vec4的各个字段。这真是一个很深的bug。多亏我对C#的struct布局也是有所了解。

。