CSharpGL(37)创建和使用VBO的最佳方式

CSharpGL(37)创建和使用VBO的最佳方式

开始

近日在OpenGL红宝书上看到这样的讲解。

其核心意思是，在创建VBO时用

glBufferData(GL_ARRAY_BUFFER, length, NULL, GL_STATIC_DRAW);

来初始化buffer占用的内存（此内存在GPU端），其中的 NULL 表示并未初始化数据（即此buffer中的数据是随机值，类似在C语言中刚刚创建一个数组 int x[]; 的情况）。

这样，就不必在CPU端申请大量内存了。接下来需要初始化buffer数据时，用

     IntPtr pointer = buffer.MapBuffer(MapBufferAccess.WriteOnly);
     var array = (vec3*)pointer.ToPointer();
     for (int i = ; i < length; i++)
     {
         array[i] = this.model.positions[i];
     }
     ptr.UnmapBuffer();

来直接操作GPU上的数据即可。

使用这种方式，省去了在CPU端创建大规模非托管数组并上传到GPU端的步骤，直接在GPU端创建了buffer，且所需代码更少，可以说是目前我找到的最佳方式。

因此我在CSharpGL中集成并使用了这种方式。

顶点属性buffer

CSharpGL中，用于描述顶点属性数组（Vertex Buffer Object）的类型是 VertexAttributeBufferPtr 。以前，我们可以通过如下的方式创建 VertexAttributeBufferPtr 。

     // 先在CPU端创建非托管数组VertexAttributeBuffer<vec3>对象
 using (var buffer = new VertexAttributeBuffer<vec3>(
         varNameInShader, VertexAttributeConfig.Vec3, BufferUsage.StaticDraw))
     {
         buffer.Alloc(this.model.positions.Length);// 在CPU端申请内存
         unsafe// 使用指针快速初始化
         {
             var array = (vec3*)buffer.Header.ToPointer();
             for (int i = ; i < this.model.positions.Length; i++)
             {
                 array[i] = this.model.positions[i];
             }
         }
         // 将CPU端的VertexAttributeBuffer<vec3>上传到GPU，获得我们需要的buffer对象。
         positionBufferPtr = buffer.GetBufferPtr();
     }// using结束，释放VertexAttributeBuffer<vec3>申请的非托管内存。
     return positionBufferPtr;

可见，这种方式实际上是按下面的步骤创建VBO的。注意其中的data不是 NULL 。

     uint[] buffers = new uint[];
     glGenBuffers(, buffers);
     const uint target = OpenGL.GL_ARRAY_BUFFER;
     glBindBuffer(target, buffers[]);
     glBufferData(target, length, data, usage);
     glBindBuffer(target, );

这种方式需要先在CPU端申请一块内存，初始化数据，之后才能上传到GPU端。现在我们用新的方式创建buffer，就不需要在CPU端申请内存了。

下面是创建buffer的方法。

     /// <summary>
     /// Creates a <see cref="VertexAttributeBufferPtr"/> object(actually an array) directly in server side(GPU) without initializing its value.
     /// </summary>
     /// <param name="elementType">element's type of this 'array'.</param>
     /// <param name="length">How many elements are there?</param>
     /// <param name="config">mapping to vertex shader's 'in' type.</param>
     /// <param name="usage"></param>
     /// <param name="varNameInVertexShader">mapping to vertex shader's 'in' name.</param>
     /// <param name="instanceDivisor"></param>
     /// <param name="patchVertexes"></param>
     /// <returns></returns>
     public static VertexAttributeBufferPtr Create(Type elementType, int length, VertexAttributeConfig config, BufferUsage usage, string varNameInVertexShader, uint instanceDivisor = , int patchVertexes = )
     {
         if (!elementType.IsValueType) { throw new ArgumentException(string.Format("{0} must be a value type!", elementType)); }
 
         int byteLength = Marshal.SizeOf(elementType) * length;
         uint[] buffers = new uint[];
         glGenBuffers(, buffers);
         const uint target = OpenGL.GL_ARRAY_BUFFER;
         glBindBuffer(target, buffers[]);
         glBufferData(target, byteLength, IntPtr.Zero, (uint)usage);
         glBindBuffer(target, );
 
         var bufferPtr = new VertexAttributeBufferPtr(
             varNameInVertexShader, buffers[], config, length, byteLength, instanceDivisor, patchVertexes);
 
         return bufferPtr;
     }

使用这样的方式创建了buffer，之后在初始化数据时，就得用glMapBuffer/glUnmapBuffer了。

     int length = this.model.positions.Length;
     // 创建buffer
     VertexAttributeBufferPtr buffer = VertexAttributeBufferPtr.Create(typeof(vec3), length, VertexAttributeConfig.Vec3, BufferUsage.StaticDraw, varNameInShader);
     unsafe
     {
         IntPtr pointer = buffer.MapBuffer(MapBufferAccess.WriteOnly);// 获取指针
         var array = (vec3*)pointer.ToPointer();// 强制类型转换
         // 初始化数据
         for (int i = ; i < length; i++)
         {
             array[i] = this.model.positions[i];
         }
         buffer.UnmapBuffer();// 完成，上传到GPU端。
     }

对比来看，在内存上，新的方式省略了在CPU端申请非托管数组的开销；在代码上，新的方式也省去了对 VertexAttributeBuffer<vec3> 对象的使用（ VertexAttributeBuffer<vec3> 类型完全可以不用了）。

索引buffer

OneIndexBufferPtr

对于使用 glDrawElements() 的索引对象，创建索引buffer就与上面雷同了。

     /// <summary>
     /// Creates a <see cref="OneIndexBufferPtr"/> object directly in server side(GPU) without initializing its value.
     /// </summary>
     /// <param name="byteLength"></param>
     /// <param name="usage"></param>
     /// <param name="mode"></param>
     /// <param name="type"></param>
     /// <param name="length"></param>
     /// <returns></returns>
     public static OneIndexBufferPtr Create(int byteLength, BufferUsage usage, DrawMode mode, IndexElementType type, int length)
     {
         uint[] buffers = new uint[];
         glGenBuffers(, buffers);
         const uint target = OpenGL.GL_ELEMENT_ARRAY_BUFFER;
         glBindBuffer(target, buffers[]);
         glBufferData(target, byteLength, IntPtr.Zero, (uint)usage);
         glBindBuffer(target, );
 
         var bufferPtr = new OneIndexBufferPtr(
              buffers[], mode, type, length, byteLength);
 
         return bufferPtr;
     }

ZeroIndexBufferPtr

对于使用 glDrawArrays() 的索引，则更简单。

     /// <summary>
     /// Creates a <see cref="ZeroIndexBufferPtr"/> object directly in server side(GPU) without initializing its value.
     /// </summary>
     /// <param name="mode"></param>
     /// <param name="firstVertex"></param>
     /// <param name="vertexCount"></param>
     /// <returns></returns>
     public static ZeroIndexBufferPtr Create(DrawMode mode, int firstVertex, int vertexCount)
     {
         ZeroIndexBufferPtr bufferPtr = new ZeroIndexBufferPtr(
          mode, firstVertex, vertexCount);
 
         return bufferPtr;
     }

使用方法也与上面雷同。

独立buffer

对于AtomicCounterBuffer、PixelPackBuffer、PixelUnpackBuffer、ShaderStorageBuffer、TextureBuffer、UniformBuffer这些，我统称为IndependentBuffer。他们当然也可以用新方法创建和使用。

     /// <summary>
     /// Creates a sub-type of <see cref="IndependentBufferPtr"/> object directly in server side(GPU) without initializing its value.
     /// </summary>
     /// <param name="target"></param>
     /// <param name="byteLength"></param>
     /// <param name="usage"></param>
     /// <param name="length"></param>
     /// <returns></returns>
     public static IndependentBufferPtr Create(IndependentBufferTarget target, int byteLength, BufferUsage usage, int length)
     {
         uint bufferTarget = ;
         switch (target)
         {
             case IndependentBufferTarget.AtomicCounterBuffer:
                 bufferTarget = OpenGL.GL_ATOMIC_COUNTER_BUFFER;
                 break;
 
             case IndependentBufferTarget.PixelPackBuffer:
                 bufferTarget = OpenGL.GL_PIXEL_PACK_BUFFER;
                 break;
 
             case IndependentBufferTarget.PixelUnpackBuffer:
                 bufferTarget = OpenGL.GL_PIXEL_UNPACK_BUFFER;
                 break;
 
             case IndependentBufferTarget.ShaderStorageBuffer:
                 bufferTarget = OpenGL.GL_SHADER_STORAGE_BUFFER;
                 break;
 
             case IndependentBufferTarget.TextureBuffer:
                 bufferTarget = OpenGL.GL_TEXTURE_BUFFER;
                 break;
 
             case IndependentBufferTarget.UniformBuffer:
                 bufferTarget = OpenGL.GL_UNIFORM_BUFFER;
                 break;
 
             default:
                 throw new NotImplementedException();
         }
 
         uint[] buffers = new uint[];
         glGenBuffers(, buffers);
         glBindBuffer(bufferTarget, buffers[]);
         glBufferData(bufferTarget, byteLength, IntPtr.Zero, (uint)usage);
         glBindBuffer(bufferTarget, );
 
         IndependentBufferPtr bufferPtr;
         switch (target)
         {
             case IndependentBufferTarget.AtomicCounterBuffer:
                 bufferPtr = new AtomicCounterBufferPtr(buffers[], length, byteLength);
                 break;
 
             case IndependentBufferTarget.PixelPackBuffer:
                 bufferPtr = new PixelPackBufferPtr(buffers[], length, byteLength);
                 break;
 
             case IndependentBufferTarget.PixelUnpackBuffer:
                 bufferPtr = new PixelUnpackBufferPtr(buffers[], length, byteLength);
                 break;
 
             case IndependentBufferTarget.ShaderStorageBuffer:
                 bufferPtr = new ShaderStorageBufferPtr(buffers[], length, byteLength);
                 break;
 
             case IndependentBufferTarget.TextureBuffer:
                 bufferPtr = new TextureBufferPtr(buffers[], length, byteLength);
                 break;
 
             case IndependentBufferTarget.UniformBuffer:
                 bufferPtr = new UniformBufferPtr(buffers[], length, byteLength);
                 break;
 
             default:
                 throw new NotImplementedException();
         }
 
         return bufferPtr;
     }

public static IndependentBufferPtr Create(IndependentBufferTarget target, int byteLength, BufferUsage usage, int length)

总结

现在CSharpGL已经有点深度，所以笔记很难写出让人直接就能眼前一亮的感觉了。

目前CSharpGL中已经涵盖了我所知的所有OpenGL知识点。下一步就是精心读书，继续深挖。