登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›纯C#软实现openGL(V0.1)，黑盒变白盒

纯C#软实现openGL(V0.1)，黑盒变白盒

僚娥 2025-6-21 15:54:54
纯C#软实现openGL(V0.1)，黑盒变白盒

为了彻底掌握openGL，做一个openGL的软实现(命名为SoftGLImpl)是必要的。（而非仅仅调用opengl32.dll）
openGL API的每个函数，都是在按下述方式执行3D渲染算法：
  1. using GLsizei = System.Int32;
  2. using GLuint = System.UInt32;
  3. using GLenum = System.UInt32;
  5. public unsafe partial class SoftGL { // class for openGL API
  6.     // 以glGenBuffers为例
  7.     static void glGenBuffers(GLsizei n, GLuint[] names) {
  8.         RenderContext? context = SoftGLImpl.SoftGL.GetCurrentContextObj();
  9.         if (context == null) { return; }// 若不先创建openGL上下文，则直接调用此API是无效的。
  11.         context.GenBuffers(n, names);// 安排数据，保存到openGL上下文中。
  12.     }
  13.     // 以glDrawElements为例
  14.     public static void glDrawElements(GLenum mode, GLsizei count, GLenum type, IntPtr indices) {
  15.         RenderContext? context = SoftGLImpl.SoftGL.GetCurrentContextObj();
  16.         if (context == null) { return; }// 若不先创建openGL上下文，则直接调用此API是无效的。
  18.         context.DrawElements(mode, count, type, indices);// 执行渲染过程，结果将被保存到openGL上下文中。
  19.     }
  20. }
复制代码
这些函数的作用，要么是安排buffer/shader/texture数据、各种选项，要么是执行渲染过程。整个渲染过程(pipeline)如下图所示：

实现openGL就是要实现图中的全部过程。本文重点介绍下列问题：

  • 如何让shader运行起来
  • 如何实现pipeline各步骤中的算法
  • 如何提升纯C#软实现的效率
如何让shader运行起来

所谓modern openGL，其核心特点是利用shader并行计算的办法来提高3D图形渲染的效率和效果。shader是一段GLSL代码，类似C语言，所以我必须做一个简单的编译器。https://www.cnblogs.com/bitzhuwei/p/18631231是我做好的GLSL编译器前端。这样，我就可以用下面的思路解决“如何让shader运行起来”的问题：
  1. // 1. 解析shader字符串，得到其语义信息
  2. var parser = new ShaderParser();
  3. string source = File.ReadAllText("blinnphong.vert");
  4. List<Token> tokens = parser.Analyze(source);
  5. SyntaxTree tree = parser.Parse(tokens);
  6. var translation_unit = parser.Extract(tree, tokens, source);
  8. // 2. 将语义信息转换为C#代码
  9. var builder = new StringBuilder();
  10. using (var writer = new StringWriter(builder)) {
  11.     var config = new BlankConfig(inlineBlank: 0, forceNewline: false);
  12.     var context = new FormatContext(tabUnit: 4, tabCount: 0, tokens);
  13.     translation_unit.Transform(config, writer, context);
  14. }
  15. var csCode = builder.ToString();
  17. // 3. 动态编译C#代码并调用，即模拟GPU运行shader的过程
  18. var script = CSharpScript.Create<VertexShaderCode>(csCode);
  19. var result = await script.RunAsync();
复制代码
主要的工作量在于：

  • 编写GLSL编译器前端
    详情可参考https://www.cnblogs.com/bitzhuwei/p/18683262/my-own-parsers。
  • 根据语法树生成C#版的shader代码。由于GLSL和C#的语法书写差异，需要处理下列差异：
点击查看代码
  1. // from GLSL
  2. struct { mat4 model; mat4 view; mat4 projection; }  va[3], vb;
  3. // to C#
  4. struct struct0 { mat4 model; mat4 view; mat4 projection; }
  5. struct0[] va = new struct0[3]; struct0 vb;
  7. // from GLSL
  8. layout(origin_upper_left, pixel_center_integer) in vec4 gl_FragCoord;
  9. // to C#
  10. [layout(values = [origin_upper_left, pixel_center_integer])]
  11. [In]
  12. vec4 gl_FragCoord;
  14. // from GLSL
  15. layout(std140, binding = 2) uniform Camera {
  16.     mat4 view;
  17.     mat4 projection;
  18. };
  19. // to C#
  20. [layout(binding = 2, values = [std140])]
  21. [uniform]
  22. struct Camera字 {
  23.     mat4 view;
  24.     mat4 projection;
  25. }
  26. Camera字 Camera;
复制代码

  • 为C#版的shader代码提供底层支持，这包括实现GLSL内置的变量（gl_VertexID、gl_FragCoord等）、类型（vec4、mat4等）、函数（max、pow、mix）。
pipeline各步骤中的算法

pipeline很长，里面涉及的算法很多。每次调用glDrawElements()都是在执行pipeline。下面我们详细解释这里的各个步骤。
  1. public static void glDrawElements(GLenum mode, GLsizei count, GLenum type, IntPtr indices) {
  2.     var context = SoftGL.GetCurrentContextObj();
  3.     if (context == null) { return; }
  5.     if (!Enum.IsDefined(typeof(DrawTarget), mode) || !Enum.IsDefined(typeof(DrawElementsType), type))
  6.     { context.lastErrorCode = (uint)(ErrorCode.InvalidEnum); return; }
  7.     if (count < 0) { context.lastErrorCode = (uint)(ErrorCode.InvalidValue); return; }
  8.     // TODO: GL_INVALID_OPERATION is generated if a geometry shader is active
  9.     // and mode is incompatible with the input primitive type of the geometry shader in the currently installed program object.
  10.     // TODO: GL_INVALID_OPERATION is generated
  11.     // if a non-zero buffer object name is bound to an enabled array
  12.     // or the element array and the buffer object's data store is currently mapped.
  14.     var vao = context.currentVertexArrayObject; // data structure.
  15.     if (vao == null) { return; }
  16.     var program = context.currentShaderProgram; // algorithm.
  17.     if (program == null) { return; }
  18.     var indexBuffer = context.target2CurrentBuffer[(GLenum)BindBufferTarget.ElementArrayBuffer];
  19.     if (indexBuffer == null) { return; }
  21.     // execute vertex shader for each vertex!
  22.     Dictionary<uint, VertexCodeBase> vertexID2Shader = VertexShaderStage(
  23.         count, (DrawElementsType)type, indices, vao, program, indexBuffer);
  25.     var framebuffer = context.target2CurrentFramebuffer[(GLenum)BindFramebufferTarget.Framebuffer];
  27.     ClipSpace2NormalDeviceSpace(vertexID2Shader);
  29.     // linear interpolation.
  30.     ConcurrentBag<Fragment> fragmentList = LinearInterpolation(
  31.         context, (DrawTarget)mode, count, (DrawElementsType)type, indices, vao, program, indexBuffer, vertexID2Shader);
  33.     // execute fargment shader for each fragment!
  34.     FragmentShaderStage(program, fragmentList);
  36.     // TODO: Scissor test
  38.     // TODO: Multisampel fragment operations
  40.     // TODO: Stencil test
  42.     DepthTest(context, fragmentList);
  44.     // TODO: Blending
  46.     // TODO: Dithering
  48.     // TODO: Logical operations
  50.     // write fragments to framebuffer's colorbuffer attachment(s).
  51.     WriteFragments2Framebuffer(context, framebuffer, fragmentList);
  52. }
  54. private static void WriteFragments2Framebuffer(RenderContext context, GLFramebuffer framebuffer, ConcurrentBag<Fragment> fragmentList) {
  55.     if (framebuffer.ColorbufferAttachments == null) { return; }
  56.     uint[] drawBufferIndexes = framebuffer.DrawBuffers.ToArray();
  57.     Func<int, IntPtr, Fragment, bool> hasValidDepth;
  58.     var depthBuffer = framebuffer.DepthbufferAttachment;
  59.     GCHandle pin = new GCHandle(); IntPtr pDepthBuffer = IntPtr.Zero;
  60.     if (depthBuffer == null) { hasValidDepth = alwaysHasValidDepth; }
  61.     else {
  62.         switch (depthBuffer.Format) {
  63.         case GL.GL_DEPTH_COMPONENT: hasValidDepth = hasValidDepth32float; break;
  64.         case GL.GL_DEPTH_COMPONENT24: hasValidDepth = hasValidDepth24uint; break;
  65.         case GL.GL_DEPTH_COMPONENT32: hasValidDepth = hasValidDepth32float; break;
  66.         default: throw new Exception("bug, fix this!");
  67.         }
  68.         pin = GCHandle.Alloc(depthBuffer.DataStore, GCHandleType.Pinned);
  69.         pDepthBuffer = pin.AddrOfPinnedObject();
  70.     }
  71.     int width = context.viewport.w;
  72.     foreach (var fragment in fragmentList) {
  73.         if (fragment.discard) { continue; }
  74.         if (fragment.outVariables == null) { continue; }
  75.         if (!hasValidDepth(width, pDepthBuffer, fragment)) { continue; }
  77.         for (int i = 0; i < fragment.outVariables.Length && i < drawBufferIndexes.Length; i++) {
  78.             PassBuffer outVar = fragment.outVariables[i];
  79.             var attachment = framebuffer.ColorbufferAttachments[drawBufferIndexes[i].ToIndex()];
  80.             if (attachment != null) {
  81.                 attachment.Set((int)fragment.gl_FragCoord.x, (int)fragment.gl_FragCoord.y, outVar);
  82.             }
  83.         }
  84.     }
  85. }
  86. private static int ByteLength(DrawElementsType type) {
  87.     int result = 0;
  88.     switch (type) {
  89.     case DrawElementsType.UnsignedByte: result = sizeof(byte); break;
  90.     case DrawElementsType.UnsignedShort: result = sizeof(ushort); break;
  91.     case DrawElementsType.UnsignedInt: result = sizeof(uint); break;
  92.     default: throw new NotDealWithNewEnumItemException(typeof(DrawElementsType));
  93.     }
  95.     return result;
  96. }
复制代码
vertex processing

这一步的任务：
①预备：找到要处理的vertex，为其挨个编号；
②计算：为每个vertex分别调用vertex shader的main()函数；
③持有：保存②的计算结果，供下一步使用。
点击查看代码 vertex processing
  1. // vertex processing
  2. private static unsafe Dictionary<uint, VertexCodeBase> VertexShaderStage(
  3.     int count, // how many elements to be rendered
  4.     DrawElementsType type,
  5.     IntPtr indices, // an offset of the first index in the buffer currently bound to GL_ELEMENT_ARRAY_BUFFER
  6.     GLVertexArrayObject vao, GLProgram program, GLBuffer indexBuffer) {
  7.     var vs = program.VertexShader;
  9.     uint vertexCount = GetVertexCount(vao, indexBuffer, type);
  10.     // gl_VertexID -> shader object
  11.     var vertexID2Shader = new Dictionary<uint, VertexCodeBase>((int)vertexCount);
  13.     // execute vertex shader for each vertex.
  14.     byte[] indexData = indexBuffer.Data;
  15.     int indexLength = indexData.Length / ByteLength(type);
  16.     GCHandle pin = GCHandle.Alloc(indexData, GCHandleType.Pinned);
  17.     IntPtr pointer = pin.AddrOfPinnedObject();
  18.     int indexID = indices.ToInt32() / ByteLength(type);
  19.     for (var c = 0; c < count && indexID < indexLength; indexID++, c++) {
  20.         uint gl_VertexID = GetVertexID(pointer, type, indexID);
  21.         var instance = vs.CreateCodeInstance() as VertexCodeBase; // an executable vertex shader.
  22.         vertexID2Shader.Add(gl_VertexID, instance);
  23.         instance.gl_VertexID = (int)gl_VertexID; // setup gl_VertexID.
  24.         // setup "in SomeType varName;" vertex attributes.
  25.         Dictionary<uint, VertexAttribDesc> locVertexAttribDict = vao.LocVertexAttribDict;
  26.         foreach (PassVariable inVar in vs.name2inVar.Values) {
  27.             if (locVertexAttribDict.TryGetValue(inVar.location, out var desc)) {
  28.                 byte[] dataStore = desc.vbo.Data;
  29.                 int byteIndex = desc.GetDataIndex(gl_VertexID);
  30.                 VertexAttribType vertexAttribType = (VertexAttribType)desc.dataType;
  31.                 var value = dataStore.ToStruct(inVar.fieldInfo.FieldType, byteIndex);
  32.                 inVar.fieldInfo.SetValue(instance, value);
  33.             }
  34.         }
  35.         // setup "uniform SomeType varName;" in vertex shader.
  36.         Dictionary<string, UniformValue> nameUniformDict = program.name2Uniform;
  37.         foreach (UniformVariable uniformVar in vs.Name2uniformVar.Values) {
  38.             string name = uniformVar.fieldInfo.Name;
  39.             if (nameUniformDict.TryGetValue(name, out var obj)) {
  40.                 if (obj.value != null) {
  41.                     uniformVar.fieldInfo.SetValue(instance, obj.value);
  42.                 }
  43.             }
  44.         }
  46.         instance.main(); // execute vertex shader code.
  47.     }
  48.     pin.Free();
  50.     return vertexID2Shader;
  51. }
  53. // Get the vertex id at specified <paramref name="indexID"/> of the array represented by <paramref name="pointer"/>.
  54. // The <paramref name="type"/> indicates the type of the array(byte[], ushort[] or uint[]).
  55. private static unsafe uint GetVertexID(IntPtr pointer, DrawElementsType type, int indexID) {
  56.     uint gl_VertexID = uint.MaxValue;
  57.     switch (type) {
  58.     case DrawElementsType.UnsignedByte: {
  59.         byte* array = (byte*)pointer;
  60.         gl_VertexID = array[indexID];
  61.     }
  62.     break;
  63.     case DrawElementsType.UnsignedShort: {
  64.         ushort* array = (ushort*)pointer;
  65.         gl_VertexID = array[indexID];
  66.     }
  67.     break;
  68.     case DrawElementsType.UnsignedInt: {
  69.         uint* array = (uint*)pointer;
  70.         gl_VertexID = array[indexID];
  71.     }
  72.     break;
  73.     default: throw new NotDealWithNewEnumItemException(typeof(DrawElementsType));
  74.     }
  76.     return gl_VertexID;
  77. }
  79. // How many vertexIDs are there in the specified <paramref name="byteArray"/>.
  80. private static uint GetVertexIDCount(byte[] byteArray, DrawElementsType type) {
  81.     uint result = 0;
  82.     uint byteLength = (uint)byteArray.Length;
  83.     switch (type) {
  84.     case DrawElementsType.UnsignedByte: result = byteLength; break;
  85.     case DrawElementsType.UnsignedShort: result = byteLength / 2; break;
  86.     case DrawElementsType.UnsignedInt: result = byteLength / 4; break;
  87.     default: throw new NotDealWithNewEnumItemException(typeof(DrawElementsType));
  88.     }
  90.     return result;
  91. }
  93. // Gets the maximum vertexID in the specified <paramref name="byteArray"/>.
  94. private static unsafe uint GetMaxVertexID(byte[] byteArray, DrawElementsType type) {
  95.     int byteLength = byteArray.Length;
  96.     GCHandle pin = GCHandle.Alloc(byteArray, GCHandleType.Pinned);
  97.     IntPtr pointer = pin.AddrOfPinnedObject();
  98.     uint gl_VertexID = 0;
  99.     switch (type) {
  100.     case DrawElementsType.UnsignedByte: {
  101.         byte* array = (byte*)pointer;
  102.         for (int i = 0; i < byteLength; i++) {
  103.             if (gl_VertexID < array[i]) { gl_VertexID = array[i]; }
  104.         }
  105.     }
  106.     break;
  107.     case DrawElementsType.UnsignedShort: {
  108.         ushort* array = (ushort*)pointer;
  109.         int length = byteLength / 2;
  110.         for (int i = 0; i < length; i++) {
  111.             if (gl_VertexID < array[i]) { gl_VertexID = array[i]; }
  112.         }
  113.     }
  114.     break;
  115.     case DrawElementsType.UnsignedInt: {
  116.         uint* array = (uint*)pointer;
  117.         int length = byteLength / 4;
  118.         for (int i = 0; i < length; i++) {
  119.             if (gl_VertexID < array[i]) { gl_VertexID = array[i]; }
  120.         }
  121.     }
  122.     break;
  123.     default: throw new NotDealWithNewEnumItemException(typeof(DrawElementsType));
  124.     }
  125.     pin.Free();
  127.     return gl_VertexID;
  128. }
  130. private static uint GetVertexCount(GLVertexArrayObject vao, GLBuffer indexBuffer, DrawElementsType type) {
  131.     uint vertexCount = 0;
  132.     VertexAttribDesc[] descs = vao.LocVertexAttribDict.Values.ToArray();
  133.     if (descs.Length > 0) {
  134.         int c = descs[0].GetVertexCount();
  135.         if (c >= 0) { vertexCount = (uint)c; }
  136.     }
  137.     else {
  138.         uint maxvertexID = GetMaxVertexID(indexBuffer.Data, type);
  139.         uint vertexIDCount = GetVertexIDCount(indexBuffer.Data, type);
  140.         vertexCount = Math.Min(maxvertexID, vertexIDCount);
  141.     }
  143.     return vertexCount;
  144. }
复制代码
tessellation

primitive processing

transform feedback processing

rasterization

上一步得到了用vertex和其他参数描述的POINTS、LINES、TRIANGLES、QUADS，这一步要计算出它们会出现在哪些像素点上。
POINTS的光栅化

POINTS的光栅化过程最简单，因为不需要插值。
  1. private static unsafe ConcurrentBag<Fragment> LinearInterpolationPoints(RenderContext context, int count, DrawElementsType type, IntPtr indices, GLVertexArrayObject vao, GLProgram program, GLBuffer indexBuffer, Dictionary<uint, VertexCodeBase> vertexID2Shader) {
  2.     var result = new System.Collections.Concurrent.ConcurrentBag<Fragment>();
  4.     byte[] indexData = indexBuffer.Data;
  5.     int indexLength = indexData.Length / ByteLength(type);
  6.     GCHandle pin = GCHandle.Alloc(indexData, GCHandleType.Pinned);
  7.     IntPtr pointer = pin.AddrOfPinnedObject();
  8.     ivec4 viewport = context.viewport;
  9.     int indexID = indices.ToInt32() / ByteLength(type);
  10.     for (var c = 0; c < count && indexID < indexLength; indexID++, c++) {
  11.         uint gl_VertexID = GetVertexID(pointer, type, indexID);
  12.         var shaderObj = vertexID2Shader[gl_VertexID];
  13.         var fragCoord = new vec3(
  14.             (shaderObj.gl_Position.x + 1) / 2.0f * viewport.z + viewport.x,
  15.             (shaderObj.gl_Position.y + 1) / 2.0f * viewport.w + viewport.y,
  16.             (shaderObj.gl_Position.z + 1) / 2.0f * (float)(context.depthRangeFar - context.depthRangeNear)
  17.                 + (float)context.depthRangeNear);
  18.         var fragment = new Fragment(fragCoord, shaderObj);
  19.         result.Add(fragment);
  20.     }
  21.     pin.Free();
  23.     return result;
  24. }
复制代码
LINES的光栅化

上一步得到的是LINE的两个端点的位置，现在需要通过插值确定LINE会出现在哪些像素Fragment上。
这用到了Bresenham算法。本项目提供了一个展示此算法效果的demo，如下图所示：
2.png

点击查看代码 Bresenham算法对LINE插值
  1. private static void FindPixelsAtLine(vec3 start, vec3 end, List<Pixel3> pixels) {
  2.     if (start.x < end.x) { DoFindPixelsAtLine(start, end, pixels); }
  3.     else { DoFindPixelsAtLine(end, start, pixels); }
  4. }
  6. // from left(start) to right(end)
  7. private static void DoFindPixelsAtLine(vec3 start, vec3 end, List<Pixel3> pixels) {
  8.     // now start.X <= end.X
  9.     if (start.y < end.y) { FindPixelsAtLine1(start, end, pixels); }
  10.     else { FindPixelsAtLine2(start, end, pixels); }
  11. }
  13. // from (0, height - 1)(start) to (width - 1, 0)(end)
  14. private static void FindPixelsAtLine2(vec3 start, vec3 end, List<Pixel3> pixels) {
  15.     var x0 = (int)start.x; var y0 = (int)start.y;
  16.     var x1 = (int)end.x; var y1 = (int)end.y;
  17.     float dx = x1 - x0, dy = y0 - y1;
  18.     if (dx >= dy) {
  19.         float p = dy + dy - dx;
  20.         for (; x0 <= x1; x0++) {
  21.             var a = (x0 + 0.5f - start.x) / (end.x - start.x);
  22.             if (x0 == x1) { y0 = y1; }
  23.             pixels.Add(new Pixel3(x0, y0, start.z + a * (end.z - start.z)));
  24.             if (p > 0) {
  25.                 y0 -= 1;
  26.                 p = p + dy + dy - dx - dx;
  27.             }
  28.             else {
  29.                 p = p + dy + dy;
  30.             }
  31.         }
  32.     }
  33.     else {
  34.         float p = dx + dx - dy;
  35.         for (; y0 >= y1; y0--) {
  36.             var a = (y0 + 0.5f - end.y) / (start.y - end.y);
  37.             if (y0 == y1) { x0 = x1; }
  38.             pixels.Add(new Pixel3(x0, y0, end.z + a * (start.z - end.z)));
  39.             if (p >= 0) {
  40.                 x0 += 1;
  41.                 p = p + dx + dx - dy - dy;
  42.             }
  43.             else {
  44.                 p = p + dx + dx;
  45.             }
  46.         }
  47.     }
  48. }
  50. // from (0, 0)(start) to (width - 1, height - 1)(end)
  51. private static void FindPixelsAtLine1(vec3 start, vec3 end, List<Pixel3> pixels) {
  52.     var x0 = (int)start.x; var y0 = (int)start.y;
  53.     var x1 = (int)end.x; var y1 = (int)end.y;
  54.     float dx = x1 - x0, dy = y1 - y0;
  55.     if (dx >= dy) {
  56.         float p = dy + dy - dx;
  57.         for (; x0 <= x1; x0++) {
  58.             var a = (x0 + 0.5f - start.x) / (end.x - start.x);
  59.             if (x0 == x1) { y0 = y1; }
  60.             pixels.Add(new Pixel3(x0, y0, start.z + a * (end.z - start.z)));
  61.             if (p >= 0) {
  62.                 y0 += 1;
  63.                 p = p + dy + dy - dx - dx;
  64.             }
  65.             else {
  66.                 p = p + dy + dy;
  67.             }
  68.         }
  69.     }
  70.     else {
  71.         float p = dx + dx - dy;
  72.         for (; y0 <= y1; y0++) {
  73.             var a = (y0 + 0.5f - start.y) / (end.y - start.y);
  74.             if (y0 == y1) { x0 = x1; }// the last pixel
  75.             pixels.Add(new Pixel3(x0, y0, start.z + a * (end.z - start.z)));
  76.             if (p >= 0) {
  77.                 x0 += 1;
  78.                 p = p + dx + dx - dy - dy;
  79.             }
  80.             else {
  81.                 p = p + dx + dx;
  82.             }
  83.         }
  84.     }
  85. }
复制代码
TRIANGLES的光栅化

上一步得到的是TRIANGLE的三个端点的位置，现在需要通过插值确定TRIANGLE会出现在哪些像素Fragment上。
用Bresenham算法确定每一列里最上一个和最下一个像素的位置，就可以逐列确定全部Fragment，且便于并行计算。当然，也可以逐行扫描。
本项目提供了一个展示此算法效果的demo，如下图所示：
3.png

点击查看代码 借助Bresenham算法逐列扫描Fragment
  1. unsafe private static void FindFragmentsInTriangle(
  2.     vec3 fragCoord0, vec3 fragCoord1, vec3 fragCoord2,
  3.     VertexCodeBase endpoints0, VertexCodeBase endpoints1, VertexCodeBase endpoints2,
  4.     ConcurrentBag<Fragment> result) {
  5.     int left = (int)fragCoord0.x, right = left;
  6.     if (left > (int)fragCoord1.x) { left = (int)fragCoord1.x; }
  7.     if (left > (int)fragCoord2.x) { left = (int)fragCoord2.x; }
  8.     if (right < (int)fragCoord1.x) { right = (int)fragCoord1.x; }
  9.     if (right < (int)fragCoord2.x) { right = (int)fragCoord2.x; }
  11.     var scanlines = new Scanline[right - left + 1];// we'll find the vertial scanlines
  12.     LocateScanlines(fragCoord0, fragCoord1, left, scanlines);
  13.     LocateScanlines(fragCoord1, fragCoord2, left, scanlines);
  14.     LocateScanlines(fragCoord2, fragCoord0, left, scanlines);
  15.     var matrix = new mat3(fragCoord0, fragCoord1, fragCoord2);
  16.     var inverseMat = CodeBase.inverse(matrix);
  17.     // way #1
  18.     for (int i = 0; i < scanlines.Length; i++) {
  19.         var scanline = scanlines[i];
  20.         var min = scanline.start; var max = scanline.end;
  21.         for (int y = min.y; y <= max.y; y++) {
  22.             float a = (min.y != max.y) ? (y + 0.5f - min.y) / (max.y - min.y) : (0);
  23.             float z = min.depth + a * (max.depth - min.depth);
  24.             var pixel = new vec3(min.x + 0.5f, y + 0.5f, z);// pixel.x += 0.5f; pixel.y += 0.5f;
  25.             vec3 p012 = inverseMat * pixel;
  26.             var fragment = new Fragment(pixel, endpoints0, endpoints1, endpoints2, p012.x, p012.y, p012.z);
  27.             result.Add(fragment);
  28.         }
  29.     }
  30. }
  32. private static void LocateScanlines(vec3 start, vec3 end,
  33.     int left, Scanline[] scanlines) {
  34.     if (start.x < end.x) { DoLocateScanlines(start, end, left, scanlines); }
  35.     else { DoLocateScanlines(end, start, left, scanlines); }
  36. }
  38. private static void DoLocateScanlines(vec3 start, vec3 end, int left, Scanline[] scanlines) {
  39.     // now start.x <= end.x
  40.     if (start.y < end.y) { LocateScanlines1(start, end, left, scanlines); }
  41.     else { LocateScanlines2(start, end, left, scanlines); }
  42. }
  45. // from (0, height - 1)(start) to (width - 1, 0)(end)
  46. private static void LocateScanlines2(vec3 start, vec3 end, int left, Scanline[] scanlines) {
  47.     var x0 = (int)start.x; var y0 = (int)start.y;
  48.     var x1 = (int)end.x; var y1 = (int)end.y;
  49.     float dx = x1 - x0, dy = y0 - y1;
  50.     if (dx >= dy) {
  51.         float p = dy + dy - dx;
  52.         for (; x0 <= x1; x0++) {
  53.             var a = (x0 + 0.5f - start.x) / (end.x - start.x);
  54.             if (x0 == x1) { y0 = y1; }
  55.             {
  56.                 var index = x0 - left;
  57.                 scanlines[index].TryExtend(x0, y0, start.z + a * (end.z - start.z));
  58.             }
  59.             if (p > 0) {
  60.                 y0 -= 1;
  61.                 p = p + dy + dy - dx - dx;
  62.             }
  63.             else {
  64.                 p = p + dy + dy;
  65.             }
  66.         }
  67.     }
  68.     else {
  69.         float p = dx + dx - dy;
  70.         for (; y0 >= y1; y0--) {
  71.             var a = (y0 + 0.5f - end.y) / (start.y - end.y);
  72.             if (y0 == y1) { x0 = x1; }
  73.             {
  74.                 var index = x0 - left;
  75.                 scanlines[index].TryExtend(x0, y0, end.z + a * (start.z - end.z));
  76.             }
  77.             if (p >= 0) {
  78.                 x0 += 1;
  79.                 p = p + dx + dx - dy - dy;
  80.             }
  81.             else {
  82.                 p = p + dx + dx;
  83.             }
  84.         }
  85.     }
  86. }
  88. // from (0, 0)(start) to (width - 1, height - 1)(end)
  89. private static void LocateScanlines1(vec3 start, vec3 end, int left, Scanline[] scanlines) {
  90.     var x0 = (int)start.x; var y0 = (int)start.y;
  91.     var x1 = (int)end.x; var y1 = (int)end.y;
  92.     float dx = x1 - x0, dy = y1 - y0;
  93.     if (dx >= dy) {
  94.         float p = dy + dy - dx;
  95.         for (; x0 <= x1; x0++) {
  96.             var a = (x0 + 0.5f - start.x) / (end.x - start.x);
  97.             if (x0 == x1) { y0 = y1; }
  98.             {
  99.                 var index = x0 - left;
  100.                 scanlines[index].TryExtend(x0, y0, start.z + a * (end.z - start.z));
  101.             }
  102.             if (p >= 0) {
  103.                 y0 += 1;
  104.                 p = p + dy + dy - dx - dx;
  105.             }
  106.             else {
  107.                 p = p + dy + dy;
  108.             }
  109.         }
  110.     }
  111.     else {
  112.         float p = dx + dx - dy;
  113.         for (; y0 <= y1; y0++) {
  114.             var a = (y0 + 0.5f - start.y) / (end.y - start.y);
  115.             if (y0 == y1) { x0 = x1; }// the last pixel
  116.             {
  117.                 var index = x0 - left;
  118.                 scanlines[index].TryExtend(x0, y0, start.z + a * (end.z - start.z));
  119.             }
  120.             if (p >= 0) {
  121.                 x0 += 1;
  122.                 p = p + dx + dx - dy - dy;
  123.             }
  124.             else {
  125.                 p = p + dx + dx;
  126.             }
  127.         }
  128.     }
  129. }
复制代码
fragment processing

这一步为每个Fragment分别调用fragment shader的main()函数。在此之前，要将每个Fragment的数据传递给fragment shader的各个in变量。在此之后，要将fragment shader的各个out变量（通常只有1个）传递给Fragment。通过反射机制，这很好实现。
点击查看代码 为每个Fragment执行fragment shader
  1. private static unsafe void FragmentShaderStage(GLProgram program, ConcurrentBag<Fragment> fragmentList) {
  2.     var fs = program.FragmentShader;
  4.     const BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static;
  5.     var inFieldInfos = (from item in fs.codeType.GetFields(flags)
  6.                         where item.IsDefined(typeof(InAttribute), true)
  7.                         select item).ToArray();
  8.     var name2fielfInfo = new Dictionary<string, FieldInfo>();
  9.     foreach (var item in fragmentList.ElementAt(0).endpoints0.GetType().GetFields(flags)) {
  10.         name2fielfInfo.Add(item.Name, item);
  11.     }
  12.     foreach (var fragment in fragmentList) {
  13.         var instance = fs.CreateCodeInstance() as FragmentCodeBase; // an executable fragment shader.
  14.         Debug.Assert(instance != null);
  15.         instance.gl_FragCoord = fragment.gl_FragCoord; // setup fragment coordinate in window/screen space.
  16.         // setup "in SomeType varName;" vertex attributes.
  17.         foreach (var field in inFieldInfos) {
  18.             if (name2fielfInfo.TryGetValue(field.Name, out var endpointField)) {
  19.                 var type = endpointField.FieldType; object value;
  20.                 if (false) { }
  21.                 else if (type == typeof(float)) { value = fragment.GetValue(endpointField, PassType.Float); }
  22.                 else if (type == typeof(vec2)) { value = fragment.GetValue(endpointField, PassType.Vec2); }
  23.                 else if (type == typeof(vec3)) { value = fragment.GetValue(endpointField, PassType.Vec3); }
  24.                 else if (type == typeof(vec4)) { value = fragment.GetValue(endpointField, PassType.Vec4); }
  25.                 else if (type == typeof(mat2)) { value = fragment.GetValue(endpointField, PassType.Mat2); }
  26.                 else if (type == typeof(mat3)) { value = fragment.GetValue(endpointField, PassType.Mat3); }
  27.                 else if (type == typeof(mat4)) { value = fragment.GetValue(endpointField, PassType.Mat4); }
  28.                 else { throw new NotDealWithNewEnumItemException(type); }
  29.                 field.SetValue(instance, value);
  30.             }
  31.         }
  33.         // setup "uniform SomeType varName;" in fragment shader.
  34.         Dictionary<string, UniformValue> nameUniformDict = program.name2Uniform;
  35.         foreach (UniformVariable uniformVar in fs.Name2uniformVar.Values) {
  36.             string name = uniformVar.fieldInfo.Name;
  37.             if (nameUniformDict.TryGetValue(name, out var obj)) {
  38.                 uniformVar.fieldInfo.SetValue(instance, obj.value);
  39.             }
  40.         }
  42.         instance.main(); // execute fragment shader code.
  43.         fragment.discard = instance.discard;
  44.         if (!instance.discard) {// if this fragment is not discarded.
  45.             PassVariable[] outVariables = fs.name2outVar.Values.ToArray();
  46.             var outBuffers = new PassBuffer[outVariables.Length];
  47.             for (int index = 0; index < outVariables.Length; index++) {
  48.                 PassVariable outVar = outVariables[index];
  49.                 var outBuffer = new PassBuffer(outVar.fieldInfo.FieldType.GetPassType(), 1);
  50.                 var pointer = outBuffer.Mapbuffer();
  51.                 var value = outVar.fieldInfo.GetValue(instance);
  52.                 Debug.Assert(value != null);
  53.                 switch (outBuffer.elementType) {
  54.                 case PassType.Float: {// make sure no negtive values
  55.                     var v = (float)value;
  56.                     if (v < 0) { v = 0; } else if (v > 1) { v = 1; }
  57.                     ((float*)pointer)[0] = v >= 0 ? v : 0;
  58.                 }
  59.                 break;
  60.                 case PassType.Vec2: {// make sure no negtive values
  61.                     var v = (vec2)value;
  62.                     if (v.x < 0) { v.x = 0; } else if (v.x > 1) { v.x = 1; }
  63.                     if (v.y < 0) { v.y = 0; } else if (v.y > 1) { v.y = 1; }
  64.                     ((vec2*)pointer)[0] = v;
  65.                 }
  66.                 break;
  67.                 case PassType.Vec3: {// make sure no negtive values
  68.                     var v = (vec3)value;
  69.                     if (v.x < 0) { v.x = 0; } else if (v.x > 1) { v.x = 1; }
  70.                     if (v.y < 0) { v.y = 0; } else if (v.y > 1) { v.y = 1; }
  71.                     if (v.z < 0) { v.z = 0; } else if (v.z > 1) { v.z = 1; }
  72.                     ((vec3*)pointer)[0] = v;
  73.                 }
  74.                 break;
  75.                 case PassType.Vec4: {// make sure no negtive values
  76.                     var v = (vec4)value;
  77.                     if (v.x < 0) { v.x = 0; } else if (v.x > 1) { v.x = 1; }
  78.                     if (v.y < 0) { v.y = 0; } else if (v.y > 1) { v.y = 1; }
  79.                     if (v.z < 0) { v.z = 0; } else if (v.z > 1) { v.z = 1; }
  80.                     if (v.w < 0) { v.w = 0; } else if (v.w > 1) { v.w = 1; }
  81.                     ((vec4*)pointer)[0] = v;
  82.                 }
  83.                 break;
  84.                 case PassType.Mat2: ((mat2*)pointer)[0] = (mat2)value; break;
  85.                 case PassType.Mat3: ((mat3*)pointer)[0] = (mat3)value; break;
  86.                 case PassType.Mat4: ((mat4*)pointer)[0] = (mat4)value; break;
  87.                 default: throw new NotDealWithNewEnumItemException(typeof(PassType));
  88.                 }
  89.                 outBuffer.Unmapbuffer();
  90.                 outBuffers[index] = outBuffer;
  91.             }
  92.             fragment.outVariables = outBuffers;
  93.         }
  94.     }
  95. }
复制代码
pixel processing

暂时只实现了深度测试功能。
点击查看代码 DepthTest
  1. private static void DepthTest(RenderContext context, ConcurrentBag<Fragment> fragmentList) {
  2.     var framebuffer = context.target2CurrentFramebuffer[(GLenum)BindFramebufferTarget.DrawFramebuffer];
  3.     var depthBuffer = framebuffer.DepthbufferAttachment;
  4.     ivec4 viewport = context.viewport;
  5.     switch (depthBuffer.Format) {
  6.     case GL.GL_DEPTH_COMPONENT: {// 32 bit -> float
  7.         DepthTest32float(viewport.w, depthBuffer, fragmentList);
  8.     }
  9.     break; // TODO: what should this be? ok, uint it is.
  10.     case GL.GL_DEPTH_COMPONENT24: {// 24 bit -> uint
  11.         DepthTest24uint(viewport.w, depthBuffer, fragmentList);
  12.     }
  13.     break;
  14.     case GL.GL_DEPTH_COMPONENT32: {// 32 bit -> float
  15.         DepthTest32float(viewport.w, depthBuffer, fragmentList);
  16.     }
  17.     break;
  18.     default: throw new Exception("invalid depth format!");
  19.     }
  20. }
  22. private static void DepthTest24uint(int width, IGLAttachable depthBuffer, ConcurrentBag<Fragment> fragmentList) {
  23.     GCHandle pin = GCHandle.Alloc(depthBuffer.DataStore, GCHandleType.Pinned);
  24.     IntPtr pointer = pin.AddrOfPinnedObject();
  25.     var depthTestPlatform = (byte*)pointer;// [viewport.z, viewport.w];
  26.     foreach (var post in fragmentList) {
  27.         var x = (int)post.gl_FragCoord.x;
  28.         var y = (int)post.gl_FragCoord.y;
  29.         var coord = (y * width + x) * 3;
  30.         uint preDepth = 0;
  31.         for (int i = 0; i < 3; i++) { preDepth += (uint)(depthTestPlatform[coord + i] << i); }
  32.         var postDepth = (uint)post.gl_FragCoord.z * (1 << 24);
  33.         // TODO: switch (depthfunc(..)) { .. }
  34.         if (postDepth < preDepth) {// fragment is nearer.
  35.             for (int i = 0; i < 3; i++) {
  36.                 depthTestPlatform[coord + i] = (byte)(postDepth >> i);
  37.             }
  38.         }
  39.     }
  40.     pin.Free();
  41. }
  43. private static void DepthTest32float(int width, IGLAttachable depthBuffer, ConcurrentBag<Fragment> fragmentList) {
  44.     GCHandle pin = GCHandle.Alloc(depthBuffer.DataStore, GCHandleType.Pinned);
  45.     IntPtr pointer = pin.AddrOfPinnedObject();
  46.     var depthTestPlatform = (float*)pointer;// [viewport.z, viewport.w];
  47.     foreach (var post in fragmentList) {
  48.         var x = (int)post.gl_FragCoord.x;
  49.         var y = (int)post.gl_FragCoord.y;
  50.         var coord = y * width + x;
  51.         var preDepth = depthTestPlatform[coord];
  52.         // TODO: switch (depthfunc(..)) { .. }
  53.         if (post.gl_FragCoord.z < preDepth) {// fragment is nearer.
  54.             depthTestPlatform[coord] = post.gl_FragCoord.z;
  55.         }
  56.     }
  57.     pin.Free();
  58. }
复制代码
如何提升纯C#软实现的效率

软实现本来就不把效率放在第一位，但完全忽视效率也是不行的。下面是我为提升SoftGLImpl运行效率采取的一些措施。
高效的IntPtr GetProcAddress(string procName)

对应Windows的wglGetProcAddress和GetProcAddress，SoftGLImpl也要实现一个IntPtr GetProcAddress(string procName)函数供openGL程序员获取openGL函数指针。下面利用反射机制获取openGL全部函数指针并缓存之，避免了：
①使用笨重的Delegate委托；
②重复创建函数指针；
③way #2中千百次设置造成的冗长代码；
④更新openGL版本时遗忘了更新way #2中的缓存。
这里的“高效”，包含着使用者高速(①②)、代码量低(③)、开发者省事(④)三个意思。
  1. public unsafe partial class SoftGL {
  2.     // 缓存全部openGL函数指针
  3.     private static readonly Dictionary<string, IntPtr> procName2Address = new();
  4.     public static IntPtr GetProcAddress(string procName) {
  5.         if (SoftGL.procName2Address.TryGetValue(procName, out var address)) {
  6.             return address;
  7.         }
  8.         else { return IntPtr.Zero; }
  9.     }
  10.     static SoftGL() { // 在SoftGL加载时，初始化openGL函数指针的缓存dict
  11.         // way #1 - 利用反射机制
  12.         Type type = typeof(SoftGLImpl.SoftGL);
  13.         var methodInfos = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
  14.         foreach (var methodInfo in methodInfos) {
  15.             var procName = methodInfo.Name;
  16.             if (procName.StartsWith("gl")) { // SoftGL中以gl开头的static函数
  17.                 var pointer = methodInfo.MethodHandle.GetFunctionPointer();
  18.                 procName2Address.Add(procName, pointer);
  19.             }
  20.         }
  21.         // way #2 - 一个一个设置
  22.         //var pglGenBuffers = (delegate* managed<GLsizei, GLuint[], void>)(&SoftGLImpl.SoftGL.glGenBuffers);
  23.         //procName2Address.Add("glGenBuffers", (IntPtr)pglGenBuffers);
  24.         //var pglDrawElements = (delegate* managed<GLenum, GLsizei, GLenum, IntPtr>)(&SoftGLImpl.SoftGL.glDrawElements);
  25.         //procName2Address.Add("glDrawElements", (IntPtr)pglDrawElements);
  26.         // other function pointers ...
  27.     }
  28. }
复制代码
运用C#中的并行计算

pipeline中的某些环节可以用Parallel或ThreadPool施展并行计算，以提高软实现的运行效率。
例如，在渲染GL_TRIANGLES时，可以并行处理各个TRIANGLE。
  1. private static unsafe ConcurrentBag<Fragment> LinearInterpolationTriangles(RenderContext context, int count, DrawElementsType type, IntPtr indices, GLVertexArrayObject vao, GLProgram program, GLBuffer indexBuffer, Dictionary<uint, VertexCodeBase> vertexID2Shader) {
  2.     var result = new System.Collections.Concurrent.ConcurrentBag<Fragment>();
  4.     byte[] indexData = indexBuffer.Data; int elementBytes = ByteLength(type);
  5.     int indexLength = indexData.Length / elementBytes;
  6.     GCHandle pin = GCHandle.Alloc(indexData, GCHandleType.Pinned);
  7.     IntPtr pointer = pin.AddrOfPinnedObject();
  8.     ivec4 viewport = context.viewport;  // ivec4(x, y, width, height)
  9.     count = (count - count % 3);
  10.     const int fromInclusive = 0; int toExclusive = count / 3;
  11.     int start = indices.ToInt32() / elementBytes;
  12.     int to2 = (indexLength - start) / 3;
  13.     if (to2 < toExclusive) { toExclusive = to2; }
  14.     Parallel.For(fromInclusive, toExclusive, t => {
  15.         int indexID = t * 3 + start;
  16.         var endpoints = new VertexCodeBase[3];
  17.         var fragCoords = stackalloc vec3[3];
  18.         for (int i = 0; i < 3; i++) {
  19.             uint gl_VertexID = GetVertexID(pointer, type, indexID + i);
  20.             System.Diagnostics.Debug.Assert(vertexID2Shader.ContainsKey(gl_VertexID));
  21.             var shaderObj = vertexID2Shader[gl_VertexID];
  22.             endpoints[i] = shaderObj;
  23.             vec4 gl_Position = shaderObj.gl_Position;
  24.             vec3 fragCoord = new vec3((gl_Position.x + 1) / 2.0f * viewport.z + viewport.x,
  25.                 (gl_Position.y + 1) / 2.0f * viewport.w + viewport.y,
  26.                 (gl_Position.z + 1) / 2.0f * (float)(context.depthRangeFar - context.depthRangeNear) + (float)context.depthRangeNear);
  27.             fragCoords[i] = fragCoord;
  28.         }
  30.         FindFragmentsInTriangle(
  31.             fragCoords[0], fragCoords[1], fragCoords[2],
  32.             endpoints[0], endpoints[1], endpoints[2], result);
  33.     });
  34.     pin.Free();
  36.     return result;
  37. }
复制代码
其他可以并行计算的过程包括：

  • 并行执行vertex shader。
  • 在两个顶点之间进行线性插值。
  • 并行执行fragment shader。
开源地址

开源地址在https://gitee.com/bitzhuwei/glTF2。github我已无法登陆了，它新要求的什么狗屁验证措施，让我很不安。我已经把github上我的所有项目都转移到gitee了。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
僚娥
2025-6-21 15:54:54

0

粉丝关注

12

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫