CSharpGL(1)从最简单的例子开始使用CSharpGL
2016-08-13
由于CSharpGL一直在更新，现在这个教程已经不适用最新的代码了。CSharpGL源码中包含20多个独立的Demo，更适合入门参考。
为了尽可能提升渲染效率，CSharpGL是面向Shader的，因此稍有难度。
主要内容
在VS2013中使用设计好的控件GLCanvas。
借助GLCanvas，用legacy OpenGL绘制一个四面体。
借助GLCanvas，用modern OpenGL绘制一个四面体。
+BIT祝威+悄悄在此留下版了个权的信说：
下载
您可以在（https://github.com/bitzhuwei/CSharpGL）找到最新的源码。欢迎感兴趣的同学fork之。
如果您不会用GitHub，可以点此（https://github.com/bitzhuwei/CSharpGL/archive/master.zip）下载zip包。
使用GLCanvas
打开CSharpGL
万事开头难，你在下载打开CSharpGL后，应该能看到下图所示的解决方案。打开CSharpGL.Winforms.Demo项目下的FormPyramidVAOElement，会看到一个窗口里的四面体在慢慢旋转。这就是用OpenGL绘制的。
新建Winform项目
为了演示全部过程，我们新建一个项目"HelloCSharpGL"。
刚刚新建的项目如下图所示。
添加引用
我们需要添加对CSharpGL各个类库的引用，如下图所示。
如下图所示，添加这么几个类库：
Utilities：含有一些辅助类型。
CSharpGL：封装了OpenGL指令。
CSharpGL.Maths：封装了对矩阵和向量的操作。
CSharpGL.Objects：含有Camera、RenderContext、Shader、SceneElement、Picking、UI等类型。
CSharpGL.Winforms：含有GLCanvas控件。
这几个库都是必须的。
使用GLCanvas控件
此时，打开"工具箱"，就会看到GLCanvas控件。
把GLCanvas控件拖拽到Form1窗体上，并设置其Anchor属性。
下面，我们先编译一下。
编译成功之后，关闭Form1，然后再次打开Form1，你会看到本篇最开头所示的GLCanvas控件中出现一个旋转的四面体。
注意，这只是在设计阶段的效果，在运行时并不会显示任何内容。不信的话，现在我们把HelloCSharpGL项目设为启动项。
然后，点击"启动"，我们来看看启动后的程序是什么效果。
你会看到一个漆黑的窗口。此时GLCanvas并没有绘制任何内容。
这样，GLCanvas就成功添加到窗口中了。
下面我们分别说明如何用legacy OpenGL和modern OpenGL绘图。
+BIT祝威+悄悄在此留下版了个权的信说：
用legacy OpenGL绘制一个四面体
添加代码：绘制四面体
继续上文所述，双击Form1中的GLCanvas控件，进入"OpenGLDraw"事件代码。编写下面所述的代码。
1 private void glCanvas1_OpenGLDraw(object sender, PaintEventArgs e)
2 {
3 // Clear the color and depth buffer.
4 GL.Clear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
5
6 DrawPyramid();
7 }
8
9 public static void DrawPyramid()
10 {
11 // Load the identity matrix.
12 GL.LoadIdentity();
13
14 // Rotate around the Y axis.
15 GL.Rotate(rotation, 0.0f, 1.0f, 0.0f);
16
17 // Draw a coloured pyramid.
18 GL.Begin(GL.GL_TRIANGLES);
19 GL.Color(1.0f, 0.0f, 0.0f);
20 GL.Vertex(0.0f, 1.0f, 0.0f);
21 GL.Color(0.0f, 1.0f, 0.0f);
22 GL.Vertex(-1.0f, -1.0f, 1.0f);
23 GL.Color(0.0f, 0.0f, 1.0f);
24 GL.Vertex(1.0f, -1.0f, 1.0f);
25 GL.Color(1.0f, 0.0f, 0.0f);
26 GL.Vertex(0.0f, 1.0f, 0.0f);
27 GL.Color(0.0f, 0.0f, 1.0f);
28 GL.Vertex(1.0f, -1.0f, 1.0f);
29 GL.Color(0.0f, 1.0f, 0.0f);
30 GL.Vertex(1.0f, -1.0f, -1.0f);
31 GL.Color(1.0f, 0.0f, 0.0f);
32 GL.Vertex(0.0f, 1.0f, 0.0f);
33 GL.Color(0.0f, 1.0f, 0.0f);
34 GL.Vertex(1.0f, -1.0f, -1.0f);
35 GL.Color(0.0f, 0.0f, 1.0f);
36 GL.Vertex(-1.0f, -1.0f, -1.0f);
37 GL.Color(1.0f, 0.0f, 0.0f);
38 GL.Vertex(0.0f, 1.0f, 0.0f);
39 GL.Color(0.0f, 0.0f, 1.0f);
40 GL.Vertex(-1.0f, -1.0f, -1.0f);
41 GL.Color(0.0f, 1.0f, 0.0f);
42 GL.Vertex(-1.0f, -1.0f, 1.0f);
43 GL.End();
44
45 rotation += 3.0f;
46 }
47
48 private double rotation;
查看效果
我们已经添加了用legacy OpenGL绘制四面体的代码，现在就编译运行起来看看效果。
可以看到，确实绘制出了一个四面体。不过它距离窗口太近了，以至于一部分内容被削去了。下面我们把它放到合适的位置去。更准确地说，是把Camera移动到合适的位置去。
添加代码：设定投影矩阵和视图矩阵
为GLCanvas控件的Resize事件添加代码。
在GLCanvas调整大小时，就会自动调用Resize事件，所以在这里调整投影矩阵和视图矩阵是最合适的。
视图矩阵指定了Camera的位置、朝向和上方。投影矩阵指定了Camera的透视模式和拍摄范围。
1 private void glCanvas1_Resize(object sender, EventArgs e)
2 {
3 ResizeGL(glCanvas1.Width, glCanvas1.Height);
4 }
5 void ResizeGL(double width, double height)
6 {
7 // Set the projection matrix.
8 GL.MatrixMode(GL.GL_PROJECTION);
9
10 // Load the identity.
11 GL.LoadIdentity();
12
13 // Create a perspective transformation.
14 GL.gluPerspective(60.0f, width / height, 0.01, 100.0);
15
16 // Use the 'look at' helper function to position and aim the camera.
17 GL.gluLookAt(-5, 5, -5, 0, 0, 0, 0, 1, 0);
18
19 // Set the modelview matrix.
20 GL.MatrixMode(GL.GL_MODELVIEW);
21 }
查看效果
现在再次编译运行，可以看到效果如下。
Legacy OpenGL绘制四面体到此就成功完成了。可以看到这是十分简单的，拖拽一个GLCanvas控件，在"OpenGLDraw"事件里绘制模型，在"Resize"事件里调整Camera。就这么点事。
Legacy OpenGL的缺点是，当模型的顶点很多时，需要频繁调用glVertex（还有glColor、glTexCoord等），这样的执行效率是很低的。下面要讲的modern OpenGL就可以大幅提升渲染效率。
+BIT祝威+悄悄在此留下版了个权的信说：
用modern OpenGL绘制一个四面体
用modern OpenGL需要准备的东西比较多，我们一个一个来。
准备一个窗体
我们新建一个窗体来演示modern OpenGL的写法。
新建的窗体名就叫做"FormModernOpenGL"。
然后也拖拽一个GLCanvas给FormModernOpenGL。也设置好Anchor属性。
准备PyramidDemo
我们添加一个PyramidDemo类，用于加载shader、四面体模型和渲染操作。
我们暂时先不实现PyramidDemo，就让它占个坑位。
准备vertex shader
Modern OpenGL需要用GLSL编写的shader进行渲染。其中必不可少的是vertex shader和fragment shader。现在来准备vertex shader。
shader本质是一个供GPU使用的源代码，所以用"文本文件"即可。Vertex shader命名为"PyramidDemo.vert"。
PyramidDemo.vert内容如下：
1 #version 150 core
2
3 in vec3 in_Position;
4 in vec3 in_Color;
5 out vec4 pass_Color;
6
7 uniform mat4 MVP;
8
9 void main(void)
10 {
11 gl_Position = MVP * vec4(in_Position, 1.0);// setup vertex's position
12
13 pass_Color = vec4(in_Color, 1.0);// pass color to fragment shader
14 }
注意：shader里即使是注释也不能有中文字符，否则会出现编译错误。也许以后的OpenGL版本会改善这一点。
准备fragment shader
同理准备fragment shader。
Fragment shader内容如下：
1 #version 150 core
2
3 in vec4 pass_Color;
4 out vec4 out_Color;// any name for 'out_Color' is OK, but make sure it's a 'out vec4'
5
6 void main(void)
7 {
8 out_Color = pass_Color;// setup color for this fragment
9 }
+BIT祝威+悄悄在此留下版了个权的信说：
设置shader文件属性
为了使用shader文件，我们需要设置一下shader文件的属性。
设置"复制到输出目录"属性为"如果较新则复制"。
Shader类和ShaderProgram类
有了shader的源代码，现在我们来加载shader。这就需要添加一个Shader类和一个ShaderProgram类。
Shader类用于加载一个Shader（vertex shader或fragment shader）
1 /// <summary>
2 /// This is the base class for all shaders (vertex and fragment). It offers functionality
3 /// which is core to all shaders, such as file loading and binding.
4 /// </summary>
5 public class Shader
6 {
7 public void Create(uint shaderType, string source)
8 {
9 // Create the OpenGL shader object.
10 ShaderObject = GL.CreateShader(shaderType);
11
12 // Set the shader source.
13 GL.ShaderSource(ShaderObject, source);
14
15 // Compile the shader object.
16 GL.CompileShader(ShaderObject);
17
18 // Now that we've compiled the shader, check it's compilation status. If it's not compiled properly, we're
19 // going to throw an exception.
20 if (GetCompileStatus() == false)
21 {
22 string log = GetInfoLog();
23 throw new ShaderCompilationException(string.Format("Failed to compile shader with ID {0}.", ShaderObject), log);
24 }
25 }
26
27 public void Delete()
28 {
29 GL.DeleteShader(ShaderObject);
30 ShaderObject = 0;
31 }
32
33 public bool GetCompileStatus()
34 {
35 int[] parameters = new int[] { 0 };
36 GL.GetShader(ShaderObject, GL.GL_COMPILE_STATUS, parameters);
37 return parameters[0] == GL.GL_TRUE;
38 }
39
40 public string GetInfoLog()
41 {
42 // Get the info log length.
43 int[] infoLength = new int[] { 0 };
44 GL.GetShader(ShaderObject,
45 GL.GL_INFO_LOG_LENGTH, infoLength);
46 int bufSize = infoLength[0];
47
48 // Get the compile info.
49 StringBuilder il = new StringBuilder(bufSize);
50 GL.GetShaderInfoLog(ShaderObject, bufSize, IntPtr.Zero, il);
51
52 string log = il.ToString();
53 return log;
54 }
55
56 /// <summary>
57 /// Gets the shader object.
58 /// </summary>
59 public uint ShaderObject { get; protected set; }
60 }
ShaderProgram类用于加载ShaderProgram。
1 public class ShaderProgram
2 {
3 private readonly Shader vertexShader = new Shader();
4 private readonly Shader fragmentShader = new Shader();
5
6 /// <summary>
7 /// Creates the shader program.
8 /// </summary>
9 /// <param name="vertexShaderSource">The vertex shader source.</param>
10 /// <param name="fragmentShaderSource">The fragment shader source.</param>
11 /// <param name="attributeLocations">The attribute locations. This is an optional array of
12 /// uint attribute locations to their names.</param>
13 /// <exception cref="ShaderCompilationException"></exception>
14 public void Create(string vertexShaderSource, string fragmentShaderSource,
15 Dictionary<uint, string> attributeLocations)
16 {
17 // Create the shaders.
18 vertexShader.Create(GL.GL_VERTEX_SHADER, vertexShaderSource);
19 fragmentShader.Create(GL.GL_FRAGMENT_SHADER, fragmentShaderSource);
20
21 // Create the program, attach the shaders.
22 ShaderProgramObject = GL.CreateProgram();
23 GL.AttachShader(ShaderProgramObject, vertexShader.ShaderObject);
24 GL.AttachShader(ShaderProgramObject, fragmentShader.ShaderObject);
25
26 // Before we link, bind any vertex attribute locations.
27 if (attributeLocations != null)
28 {
29 foreach (var vertexAttributeLocation in attributeLocations)
30 GL.BindAttribLocation(ShaderProgramObject, vertexAttributeLocation.Key, vertexAttributeLocation.Value);
31 }
32
33 // Now we can link the program.
34 GL.LinkProgram(ShaderProgramObject);
35
36 // Now that we've compiled and linked the shader, check it's link status. If it's not linked properly, we're
37 // going to throw an exception.
38 if (GetLinkStatus() == false)
39 {
40 throw new ShaderCompilationException(string.Format("Failed to link shader program with ID {0}.", ShaderProgramObject), GetInfoLog());
41 }
42 }
43
44 public void Delete()
45 {
46 GL.DetachShader(ShaderProgramObject, vertexShader.ShaderObject);
47 GL.DetachShader(ShaderProgramObject, fragmentShader.ShaderObject);
48 vertexShader.Delete();
49 fragmentShader.Delete();
50 GL.DeleteProgram(ShaderProgramObject);
51 ShaderProgramObject = 0;
52 }
53
54 public uint GetAttributeLocation(string attributeName)
55 {
56 // If we don't have the attribute name in the dictionary, get it's
57 // location and add it.
58 if (attributeNamesToLocations.ContainsKey(attributeName) == false)
59 {
60 int location = GL.GetAttribLocation(ShaderProgramObject, attributeName);
61 if (location < 0) { throw new Exception(); }
62
63 attributeNamesToLocations[attributeName] = (uint)location;
64 }
65
66 // Return the attribute location.
67 return attributeNamesToLocations[attributeName];
68 }
69
70 public void BindAttributeLocation(uint location, string attribute)
71 {
72 GL.BindAttribLocation(ShaderProgramObject, location, attribute);
73 }
74
75 public void Bind()
76 {
77 GL.UseProgram(ShaderProgramObject);
78 }
79
80 public void Unbind()
81 {
82 GL.UseProgram(0);
83 }
84
85 public bool GetLinkStatus()
86 {
87 int[] parameters = new int[] { 0 };
88 GL.GetProgram(ShaderProgramObject, GL.GL_LINK_STATUS, parameters);
89 return parameters[0] == GL.GL_TRUE;
90 }
91
92 public string GetInfoLog()
93 {
94 // Get the info log length.
95 int[] infoLength = new int[] { 0 };
96 GL.GetProgram(ShaderProgramObject, GL.GL_INFO_LOG_LENGTH, infoLength);
97 int bufSize = infoLength[0];
98
99 // Get the compile info.
100 StringBuilder il = new StringBuilder(bufSize);
101 GL.GetProgramInfoLog(ShaderProgramObject, bufSize, IntPtr.Zero, il);
102
103 string log = il.ToString();
104 return log;
105 }
106
107 public void AssertValid()
108 {
109 if (vertexShader.GetCompileStatus() == false)
110 {
111 string log = vertexShader.GetInfoLog();
112 throw new Exception(log);
113 }
114 if (fragmentShader.GetCompileStatus() == false)
115 {
116 string log = fragmentShader.GetInfoLog();
117 throw new Exception(log);
118 }
119 if (GetLinkStatus() == false)
120 {
121 string log = GetInfoLog();
122 throw new Exception(log);
123 }
124 }
125
126 /// <summary>
127 /// 请注意你的数据类型最终将转换为int还是float
128 /// </summary>
129 /// <param name="uniformName"></param>
130 /// <param name="v1"></param>
131 public void SetUniform(string uniformName, int v1)
132 {
133 GL.Uniform1(GetUniformLocation(uniformName), v1);
134 }
135
136 /// <summary>
137 /// 请注意你的数据类型最终将转换为int还是float
138 /// </summary>
139 /// <param name="uniformName"></param>
140 /// <param name="v1"></param>
141 /// <param name="v2"></param>
142 public void SetUniform(string uniformName, int v1, int v2)
143 {
144 GL.Uniform2(GetUniformLocation(uniformName), v1, v2);
145 }
146
147 /// <summary>
148 /// 请注意你的数据类型最终将转换为int还是float
149 /// </summary>
150 /// <param name="uniformName"></param>
151 /// <param name="v1"></param>
152 /// <param name="v2"></param>
153 /// <param name="v3"></param>
154 public void SetUniform(string uniformName, int v1, int v2, int v3)
155 {
156 GL.Uniform3(GetUniformLocation(uniformName), v1, v2, v3);
157 }
158
159 /// <summary>
160 /// 请注意你的数据类型最终将转换为int还是float
161 /// </summary>
162 /// <param name="uniformName"></param>
163 /// <param name="v1"></param>
164 /// <param name="v2"></param>
165 /// <param name="v3"></param>
166 /// <param name="v4"></param>
167 public void SetUniform(string uniformName, int v1, int v2, int v3, int v4)
168 {
169 GL.Uniform4(GetUniformLocation(uniformName), v1, v2, v3, v4);
170 }
171
172 /// <summary>
173 /// 请注意你的数据类型最终将转换为int还是float
174 /// </summary>
175 /// <param name="uniformName"></param>
176 /// <param name="v1"></param>
177 public void SetUniform(string uniformName, float v1)
178 {
179 GL.Uniform1(GetUniformLocation(uniformName), v1);
180 }
181
182 /// <summary>
183 /// 请注意你的数据类型最终将转换为int还是float
184 /// </summary>
185 /// <param name="uniformName"></param>
186 /// <param name="v1"></param>
187 /// <param name="v2"></param>
188 public void SetUniform(string uniformName, float v1, float v2)
189 {
190 GL.Uniform2(GetUniformLocation(uniformName), v1, v2);
191 }
192
193 /// <summary>
194 /// 请注意你的数据类型最终将转换为int还是float
195 /// </summary>
196 /// <param name="uniformName"></param>
197 /// <param name="v1"></param>
198 /// <param name="v2"></param>
199 /// <param name="v3"></param>
200 public void SetUniform(string uniformName, float v1, float v2, float v3)
201 {
202 GL.Uniform3(GetUniformLocation(uniformName), v1, v2, v3);
203 }
204
205 /// <summary>
206 /// 请注意你的数据类型最终将转换为int还是float
207 /// </summary>
208 /// <param name="uniformName"></param>
209 /// <param name="v1"></param>
210 /// <param name="v2"></param>
211 /// <param name="v3"></param>
212 /// <param name="v4"></param>
213 public void SetUniform(string uniformName, float v1, float v2, float v3, float v4)
214 {
215 GL.Uniform4(GetUniformLocation(uniformName), v1, v2, v3, v4);
216 }
217
218 /// <summary>
219 /// 请注意你的数据类型最终将转换为int还是float
220 /// </summary>
221 /// <param name="uniformName"></param>
222 /// <param name="m"></param>
223 public void SetUniformMatrix3(string uniformName, float[] m)
224 {
225 GL.UniformMatrix3(GetUniformLocation(uniformName), 1, false, m);
226 }
227
228 /// <summary>
229 /// 请注意你的数据类型最终将转换为int还是float
230 /// </summary>
231 /// <param name="uniformName"></param>
232 /// <param name="m"></param>
233 public void SetUniformMatrix4(string uniformName, float[] m)
234 {
235 GL.UniformMatrix4(GetUniformLocation(uniformName), 1, false, m);
236 }
237
238 public int GetUniformLocation(string uniformName)
239 {
240 // If we don't have the uniform name in the dictionary, get it's
241 // location and add it.
242 if (uniformNamesToLocations.ContainsKey(uniformName) == false)
243 {
244 uniformNamesToLocations[uniformName] = GL.GetUniformLocation(ShaderProgramObject, uniformName);
245 // TODO: if it's not found, we should probably throw an exception.
246 }
247
248 // Return the uniform location.
249 return uniformNamesToLocations[uniformName];
250 }
251
252 /// <summary>
253 /// Gets the shader program object.
254 /// </summary>
255 /// <value>
256 /// The shader program object.
257 /// </value>
258 public uint ShaderProgramObject { get; protected set; }
259
260
261 /// <summary>
262 /// A mapping of uniform names to locations. This allows us to very easily specify
263 /// uniform data by name, quickly looking up the location first if needed.
264 /// </summary>
265 private readonly Dictionary<string, int> uniformNamesToLocations = new Dictionary<string, int>();
266
267 /// <summary>
268 /// A mapping of attribute names to locations. This allows us to very easily specify
269 /// attribute data by name, quickly looking up the location first if needed.
270 /// </summary>
271 private readonly Dictionary<string, uint> attributeNamesToLocations = new Dictionary<string, uint>();
272 }
另外，添加一个辅助类ShaderCompilationException。
1 [Serializable]
2 public class ShaderCompilationException : Exception
3 {
4 private readonly string compilerOutput;
5
6 public ShaderCompilationException(string compilerOutput)
7 {
8 this.compilerOutput = compilerOutput;
9 }
10 public ShaderCompilationException(string message, string compilerOutput)
11 : base(message)
12 {
13 this.compilerOutput = compilerOutput;
14 }
15 public ShaderCompilationException(string message, Exception inner, string compilerOutput)
16 : base(message, inner)
17 {
18 this.compilerOutput = compilerOutput;
19 }
20 protected ShaderCompilationException(
21 System.Runtime.Serialization.SerializationInfo info,
22 System.Runtime.Serialization.StreamingContext context)
23 : base(info, context) { }
24
25 public string CompilerOutput { get { return compilerOutput; } }
26 }
实现PyramidDemo
加载shader，设置shader program
在PyramidDemo里实现。
1 private ShaderProgram shaderProgram;
2
3 public void Initilize()
4 {
5 InitShaderProgram();
6 }
7
8 private void InitShaderProgram()
9 {
10 var vertexShaderSource = File.ReadAllText(@"PyramidDemo.vert");
11 var fragmentShaderSource = File.ReadAllText(@"PyramidDemo.frag");
12
13 this.shaderProgram = new ShaderProgram();
14
15 this.shaderProgram.Create(vertexShaderSource, fragmentShaderSource, null);
16 this.shaderProgram.AssertValid();
17
18 }
+BIT祝威+悄悄在此留下版了个权的信说：
用VAO/VBO设置四面体模型
四面体模型的数据还是legacy OpenGL里的数据，但是不再用glVertex设置，而是用VAO/VBO来指定。
1 const int vertexCount = 12;
2 private uint[] vertexArrayObject;
3
4 public void Initilize()
5 {
6 InitShaderProgram();
7
8 InitVAO();
9 }
10
11 private void InitVAO()
12 {
13 // reserve a vertex array object(VAO) 预约一个VAO
14 this.vertexArrayObject = new uint[1];
15 GL.GenVertexArrays(1, this.vertexArrayObject);
16
17 // prepare vertex buffer object(VBO) for vertexes' positions 为顶点位置准备VBO
18 uint[] positionBufferObject = new uint[1];
19 {
20 // specify position array
21 var positionArray = new UnmanagedArray<vec3>(vertexCount);
22 positionArray[0] = new vec3(0.0f, 1.0f, 0.0f);
23 positionArray[1] = new vec3(-1.0f, -1.0f, 1.0f);
24 positionArray[2] = new vec3(1.0f, -1.0f, 1.0f);
25 positionArray[3] = new vec3(0.0f, 1.0f, 0.0f);
26 positionArray[4] = new vec3(1.0f, -1.0f, 1.0f);
27 positionArray[5] = new vec3(1.0f, -1.0f, -1.0f);
28 positionArray[6] = new vec3(0.0f, 1.0f, 0.0f);
29 positionArray[7] = new vec3(1.0f, -1.0f, -1.0f);
30 positionArray[8] = new vec3(-1.0f, -1.0f, -1.0f);
31 positionArray[9] = new vec3(0.0f, 1.0f, 0.0f);
32 positionArray[10] = new vec3(-1.0f, -1.0f, -1.0f);
33 positionArray[11] = new vec3(-1.0f, -1.0f, 1.0f);
34
35 // put positions into VBO
36 GL.GenBuffers(1, positionBufferObject);
37 GL.BindBuffer(BufferTarget.ArrayBuffer, positionBufferObject[0]);
38 GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);
39
40 positionArray.Dispose();
41 }
42
43 // prepare vertex buffer object(VBO) for vertexes' colors
44 uint[] colorBufferObject = new uint[1];
45 {
46 // specify color array
47 UnmanagedArray<vec3> colorArray = new UnmanagedArray<vec3>(vertexCount);
48 colorArray[0] = new vec3(1.0f, 0.0f, 0.0f);
49 colorArray[1] = new vec3(0.0f, 1.0f, 0.0f);
50 colorArray[2] = new vec3(0.0f, 0.0f, 1.0f);
51 colorArray[3] = new vec3(1.0f, 0.0f, 0.0f);
52 colorArray[4] = new vec3(0.0f, 0.0f, 1.0f);
53 colorArray[5] = new vec3(0.0f, 1.0f, 0.0f);
54 colorArray[6] = new vec3(1.0f, 0.0f, 0.0f);
55 colorArray[7] = new vec3(0.0f, 1.0f, 0.0f);
56 colorArray[8] = new vec3(0.0f, 0.0f, 1.0f);
57 colorArray[9] = new vec3(1.0f, 0.0f, 0.0f);
58 colorArray[10] = new vec3(0.0f, 0.0f, 1.0f);
59 colorArray[11] = new vec3(0.0f, 1.0f, 0.0f);
60
61 // put colors into VBO
62 GL.GenBuffers(1, colorBufferObject);
63 GL.BindBuffer(BufferTarget.ArrayBuffer, colorBufferObject[0]);
64 GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);
65
66 colorArray.Dispose();
67 }
68
69 uint positionLocation = shaderProgram.GetAttributeLocation("in_Position");
70 uint colorLocation = shaderProgram.GetAttributeLocation("in_Color");
71
72 {
73 // bind the vertex array object(VAO), we are going to specify data for it.
74 GL.BindVertexArray(vertexArrayObject[0]);
75
76 // specify vertexes' positions
77 GL.BindBuffer(BufferTarget.ArrayBuffer, positionBufferObject[0]);
78 GL.VertexAttribPointer(positionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
79 GL.EnableVertexAttribArray(positionLocation);
80
81 // specify vertexes' colors
82 GL.BindBuffer(BufferTarget.ArrayBuffer, colorBufferObject[0]);
83 GL.VertexAttribPointer(colorLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
84 GL.EnableVertexAttribArray(colorLocation);
85
86 // Unbind the vertex array object(VAO), we've finished specifying data for it.
87 GL.BindVertexArray(0);
88 }
89 }
关于这里的UnmanagedArray<vec3>类型，您可以在这里找到详细介绍（C#+无unsafe的非托管大数组(large unmanaged array in c# without 'unsafe' keyword)）。
用VAO进行渲染
现在shader已加载，VAO/VBO已准备好了模型数据（位置和颜色），就差渲染这一步了。
public void Render()
{
mat4 mvp;
{
// model rotates
mat4 modelMatrix = glm.rotate(rotation, new vec3(0, 1, 0));
// same as gluLookAt()
mat4 viewMatrix = glm.lookAt(new vec3(-5, 5, -5), new vec3(0, 0, 0), new vec3(0, 1, 0));
// same as gluPerspective()
int[] viewport = new int[4];
GL.GetInteger(GetTarget.Viewport, viewport);
float width = viewport[2];
float height = viewport[3];
mat4 projectionMatrix = glm.perspective((float)(60.0f * Math.PI / 180.0f), width / height, 0.01f, 100.0f);
// get MVP in "uniform mat4 MVP;" in the vertex shader
mvp = projectionMatrix * viewMatrix * modelMatrix;
}
// bind the shader program to setup uniforms
this.shaderProgram.Bind();
// setup MVP
this.shaderProgram.SetUniformMatrix4("MVP", mvp.to_array());
{
// bind vertex array object(VAO)
GL.BindVertexArray(this.vertexArrayObject[0]);
// draw the model: in GL_TRIANGLES mode, there are 'vertexCount' vertexes
GL.DrawArrays(GL.GL_TRIANGLES, 0, vertexCount);
// unbind vertex array object(VAO)
GL.BindVertexArray(0);
}
// unbind the shader program
this.shaderProgram.Unbind();
rotation += 3.0f;
}
private float rotation;
查看效果
Modern OpenGL渲染的效果与legacy OpenGL并没有差别。
+BIT祝威+悄悄在此留下版了个权的信说：
对比
可以看到，用legacy OpenGL的步骤相对modern OpenGL而言是十分简单的。而想用modern OpenGL渲染时，我们编写了Shader、ShaderProgram、mat4、vec3、UnmanagedArray<T>等大量的类型，到此才完成了modern OpenGL的一个简单示例的代码。这其中任何一个步骤出一点错误都可能导致最终无法正常渲染，且调试难度很大。OpenGL难学大概就在这里了。
但是legacy OpenGL在渲染时调用的OpenGL指令比modern OpenGL多得多。另外，modern OpenGL用VAO/VBO会把模型数据上传到显卡内存，这也大大加速的渲染过程。再者，modern OpenGL用shader代替了固定管线，shader比固定管线灵活得多，用惯了会觉得既好用又强大。所以我们还是要坚持学用modern OpenGL。
+BIT祝威+悄悄在此留下版了个权的信说：
CSharpGL.vsix
我制作了一个CSharpGL.vsix插件，安装后可以使用模板项目来体会CSharpGL的用法。
详情在此（http://www.cnblogs.com/bitzhuwei/p/install-and-use-CSharpGL-vsix.html）。
总结
本篇分别用legacy OpenGL和modern OpenGL实现了一个渲染四面体的例子。例子虽简单，但是包含了OpenGL渲染的整个编码过程。今后我们的工作都是基于这个基本流程进行的，只不过在各个方面进行强化，增加新的功能。