CSharpGL(1)从最简单的例子开始使用CSharpGL

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"事件代码。编写下面所述的代码。

        private void glCanvas1_OpenGLDraw(object sender, PaintEventArgs e)
        {
            //  Clear the color and depth buffer.
            GL.Clear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);

            DrawPyramid();
        }

        public static void DrawPyramid()
        {
            //  Load the identity matrix.
            GL.LoadIdentity();

            //  Rotate around the Y axis.
            GL.Rotate(rotation, 0.0f, 1.0f, 0.0f);

            //  Draw a coloured pyramid.
            GL.Begin(GL.GL_TRIANGLES);
            GL.Color(1.0f, 0.0f, 0.0f);
            GL.Vertex(0.0f, 1.0f, 0.0f);
            GL.Color(0.0f, 1.0f, 0.0f);
            GL.Vertex(-1.0f, -1.0f, 1.0f);
            GL.Color(0.0f, 0.0f, 1.0f);
            GL.Vertex(1.0f, -1.0f, 1.0f);
            GL.Color(1.0f, 0.0f, 0.0f);
            GL.Vertex(0.0f, 1.0f, 0.0f);
            GL.Color(0.0f, 0.0f, 1.0f);
            GL.Vertex(1.0f, -1.0f, 1.0f);
            GL.Color(0.0f, 1.0f, 0.0f);
            GL.Vertex(1.0f, -1.0f, -1.0f);
            GL.Color(1.0f, 0.0f, 0.0f);
            GL.Vertex(0.0f, 1.0f, 0.0f);
            GL.Color(0.0f, 1.0f, 0.0f);
            GL.Vertex(1.0f, -1.0f, -1.0f);
            GL.Color(0.0f, 0.0f, 1.0f);
            GL.Vertex(-1.0f, -1.0f, -1.0f);
            GL.Color(1.0f, 0.0f, 0.0f);
            GL.Vertex(0.0f, 1.0f, 0.0f);
            GL.Color(0.0f, 0.0f, 1.0f);
            GL.Vertex(-1.0f, -1.0f, -1.0f);
            GL.Color(0.0f, 1.0f, 0.0f);
            GL.Vertex(-1.0f, -1.0f, 1.0f);
            GL.End();

            rotation += 3.0f;
        }

        private double rotation;

 

查看效果

我们已经添加了用legacy OpenGL绘制四面体的代码，现在就编译运行起来看看效果。

可以看到，确实绘制出了一个四面体。不过它距离窗口太近了，以至于一部分内容被削去了。下面我们把它放到合适的位置去。更准确地说，是把Camera移动到合适的位置去。

添加代码：设定投影矩阵和视图矩阵

为GLCanvas控件的Resize事件添加代码。

在GLCanvas调整大小时，就会自动调用Resize事件，所以在这里调整投影矩阵和视图矩阵是最合适的。

视图矩阵指定了Camera的位置、朝向和上方。投影矩阵指定了Camera的透视模式和拍摄范围。

        private void glCanvas1_Resize(object sender, EventArgs e)
        {
            ResizeGL(glCanvas1.Width, glCanvas1.Height);
        }
        void ResizeGL(double width, double height)
        {
            //  Set the projection matrix.
            GL.MatrixMode(GL.GL_PROJECTION);

            //  Load the identity.
            GL.LoadIdentity();

            //  Create a perspective transformation.
            GL.gluPerspective(60.0f, width / height, 0.01, 100.0);

            //  Use the 'look at' helper function to position and aim the camera.
            GL.gluLookAt(-5, 5, -5, 0, 0, 0, 0, 1, 0);

            //  Set the modelview matrix.
            GL.MatrixMode(GL.GL_MODELVIEW);
        }

 

查看效果

现在再次编译运行，可以看到效果如下。

 

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内容如下：

#version 150 core

in vec3 in_Position;
in vec3 in_Color;  
out vec4 pass_Color;

uniform mat4 MVP;

void main(void) 
{
    gl_Position = MVP * vec4(in_Position, 1.0);// setup vertex's position

    pass_Color = vec4(in_Color, 1.0);// pass color to fragment shader
}

注意：shader里即使是注释也不能有中文字符，否则会出现编译错误。也许以后的OpenGL版本会改善这一点。

准备fragment shader

同理准备fragment shader。

Fragment shader内容如下：

#version 150 core

in vec4 pass_Color;
out vec4 out_Color;// any name for 'out_Color' is OK, but make sure it's a 'out vec4'

void main(void) 
{
    out_Color = pass_Color;// setup color for this fragment
}

 

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

设置shader文件属性

为了使用shader文件，我们需要设置一下shader文件的属性。

设置"复制到输出目录"属性为"如果较新则复制"。

Shader类和ShaderProgram类

有了shader的源代码，现在我们来加载shader。这就需要添加一个Shader类和一个ShaderProgram类。

Shader类用于加载一个Shader（vertex shader或fragment shader）

    /// <summary>
    /// This is the base class for all shaders (vertex and fragment). It offers functionality
    /// which is core to all shaders, such as file loading and binding.
    /// </summary>
    public class Shader
    {
        public void Create(uint shaderType, string source)
        {
            //  Create the OpenGL shader object.
            ShaderObject = GL.CreateShader(shaderType);

            //  Set the shader source.
            GL.ShaderSource(ShaderObject, source);

            //  Compile the shader object.
            GL.CompileShader(ShaderObject);

            //  Now that we've compiled the shader, check it's compilation status. If it's not compiled properly, we're
            //  going to throw an exception.
            if (GetCompileStatus() == false)
            {
                string log = GetInfoLog();
                throw new ShaderCompilationException(string.Format("Failed to compile shader with ID {0}.", ShaderObject), log);
            }
        }

        public void Delete()
        {
            GL.DeleteShader(ShaderObject);
            ShaderObject = 0;
        }

        public bool GetCompileStatus()
        {
            int[] parameters = new int[] { 0 };
            GL.GetShader(ShaderObject, GL.GL_COMPILE_STATUS, parameters);
            return parameters[0] == GL.GL_TRUE;
        }

        public string GetInfoLog()
        {
            //  Get the info log length.
            int[] infoLength = new int[] { 0 };
            GL.GetShader(ShaderObject,
                GL.GL_INFO_LOG_LENGTH, infoLength);
            int bufSize = infoLength[0];

            //  Get the compile info.
            StringBuilder il = new StringBuilder(bufSize);
            GL.GetShaderInfoLog(ShaderObject, bufSize, IntPtr.Zero, il);

            string log = il.ToString();
            return log;
        }

        /// <summary>
        /// Gets the shader object.
        /// </summary>
        public uint ShaderObject { get; protected set; }
    }

 

ShaderProgram类用于加载ShaderProgram。

    public class ShaderProgram
    {
        private readonly Shader vertexShader = new Shader();
        private readonly Shader fragmentShader = new Shader();

        /// <summary>
        /// Creates the shader program.
        /// </summary>
        /// <param name="vertexShaderSource">The vertex shader source.</param>
        /// <param name="fragmentShaderSource">The fragment shader source.</param>
        /// <param name="attributeLocations">The attribute locations. This is an optional array of
        /// uint attribute locations to their names.</param>
        /// <exception cref="ShaderCompilationException"></exception>
        public void Create(string vertexShaderSource, string fragmentShaderSource,
            Dictionary<uint, string> attributeLocations)
        {
            //  Create the shaders.
            vertexShader.Create(GL.GL_VERTEX_SHADER, vertexShaderSource);
            fragmentShader.Create(GL.GL_FRAGMENT_SHADER, fragmentShaderSource);

            //  Create the program, attach the shaders.
            ShaderProgramObject = GL.CreateProgram();
            GL.AttachShader(ShaderProgramObject, vertexShader.ShaderObject);
            GL.AttachShader(ShaderProgramObject, fragmentShader.ShaderObject);

            //  Before we link, bind any vertex attribute locations.
            if (attributeLocations != null)
            {
                foreach (var vertexAttributeLocation in attributeLocations)
                    GL.BindAttribLocation(ShaderProgramObject, vertexAttributeLocation.Key, vertexAttributeLocation.Value);
            }

            //  Now we can link the program.
            GL.LinkProgram(ShaderProgramObject);

            //  Now that we've compiled and linked the shader, check it's link status. If it's not linked properly, we're
            //  going to throw an exception.
            if (GetLinkStatus() == false)
            {
                throw new ShaderCompilationException(string.Format("Failed to link shader program with ID {0}.", ShaderProgramObject), GetInfoLog());
            }
        }

        public void Delete()
        {
            GL.DetachShader(ShaderProgramObject, vertexShader.ShaderObject);
            GL.DetachShader(ShaderProgramObject, fragmentShader.ShaderObject);
            vertexShader.Delete();
            fragmentShader.Delete();
            GL.DeleteProgram(ShaderProgramObject);
            ShaderProgramObject = 0;
        }

        public uint GetAttributeLocation(string attributeName)
        {
            //  If we don't have the attribute name in the dictionary, get it's
            //  location and add it.
            if (attributeNamesToLocations.ContainsKey(attributeName) == false)
            {
                int location = GL.GetAttribLocation(ShaderProgramObject, attributeName);
                if (location < 0) { throw new Exception(); }

                attributeNamesToLocations[attributeName] = (uint)location;
            }

            //  Return the attribute location.
            return attributeNamesToLocations[attributeName];
        }

        public void BindAttributeLocation(uint location, string attribute)
        {
            GL.BindAttribLocation(ShaderProgramObject, location, attribute);
        }

        public void Bind()
        {
            GL.UseProgram(ShaderProgramObject);
        }

        public void Unbind()
        {
            GL.UseProgram(0);
        }

        public bool GetLinkStatus()
        {
            int[] parameters = new int[] { 0 };
            GL.GetProgram(ShaderProgramObject, GL.GL_LINK_STATUS, parameters);
            return parameters[0] == GL.GL_TRUE;
        }

        public string GetInfoLog()
        {
            //  Get the info log length.
            int[] infoLength = new int[] { 0 };
            GL.GetProgram(ShaderProgramObject, GL.GL_INFO_LOG_LENGTH, infoLength);
            int bufSize = infoLength[0];

            //  Get the compile info.
            StringBuilder il = new StringBuilder(bufSize);
            GL.GetProgramInfoLog(ShaderProgramObject, bufSize, IntPtr.Zero, il);

            string log = il.ToString();
            return log;
        }

        public void AssertValid()
        {
            if (vertexShader.GetCompileStatus() == false)
            {
                string log = vertexShader.GetInfoLog();
                throw new Exception(log);
            }
            if (fragmentShader.GetCompileStatus() == false)
            {
                string log = fragmentShader.GetInfoLog();
                throw new Exception(log);
            }
            if (GetLinkStatus() == false)
            {
                string log = GetInfoLog();
                throw new Exception(log);
            }
        }

        /// <summary>
        /// 请注意你的数据类型最终将转换为int还是float
        /// </summary>
        /// <param name="uniformName"></param>
        /// <param name="v1"></param>
        public void SetUniform(string uniformName, int v1)
        {
            GL.Uniform1(GetUniformLocation(uniformName), v1);
        }

        /// <summary>
        /// 请注意你的数据类型最终将转换为int还是float
        /// </summary>
        /// <param name="uniformName"></param>
        /// <param name="v1"></param>
        /// <param name="v2"></param>
        public void SetUniform(string uniformName, int v1, int v2)
        {
            GL.Uniform2(GetUniformLocation(uniformName), v1, v2);
        }

        /// <summary>
        /// 请注意你的数据类型最终将转换为int还是float
        /// </summary>
        /// <param name="uniformName"></param>
        /// <param name="v1"></param>
        /// <param name="v2"></param>
        /// <param name="v3"></param>
        public void SetUniform(string uniformName, int v1, int v2, int v3)
        {
            GL.Uniform3(GetUniformLocation(uniformName), v1, v2, v3);
        }

        /// <summary>
        /// 请注意你的数据类型最终将转换为int还是float
        /// </summary>
        /// <param name="uniformName"></param>
        /// <param name="v1"></param>
        /// <param name="v2"></param>
        /// <param name="v3"></param>
        /// <param name="v4"></param>
        public void SetUniform(string uniformName, int v1, int v2, int v3, int v4)
        {
            GL.Uniform4(GetUniformLocation(uniformName), v1, v2, v3, v4);
        }

        /// <summary>
        /// 请注意你的数据类型最终将转换为int还是float
        /// </summary>
        /// <param name="uniformName"></param>
        /// <param name="v1"></param>
        public void SetUniform(string uniformName, float v1)
        {
            GL.Uniform1(GetUniformLocation(uniformName), v1);
        }

        /// <summary>
        /// 请注意你的数据类型最终将转换为int还是float
        /// </summary>
        /// <param name="uniformName"></param>
        /// <param name="v1"></param>
        /// <param name="v2"></param>
        public void SetUniform(string uniformName, float v1, float v2)
        {
            GL.Uniform2(GetUniformLocation(uniformName), v1, v2);
        }

        /// <summary>
        /// 请注意你的数据类型最终将转换为int还是float
        /// </summary>
        /// <param name="uniformName"></param>
        /// <param name="v1"></param>
        /// <param name="v2"></param>
        /// <param name="v3"></param>
        public void SetUniform(string uniformName, float v1, float v2, float v3)
        {
            GL.Uniform3(GetUniformLocation(uniformName), v1, v2, v3);
        }

        /// <summary>
        /// 请注意你的数据类型最终将转换为int还是float
        /// </summary>
        /// <param name="uniformName"></param>
        /// <param name="v1"></param>
        /// <param name="v2"></param>
        /// <param name="v3"></param>
        /// <param name="v4"></param>
        public void SetUniform(string uniformName, float v1, float v2, float v3, float v4)
        {
            GL.Uniform4(GetUniformLocation(uniformName), v1, v2, v3, v4);
        }

        /// <summary>
        /// 请注意你的数据类型最终将转换为int还是float
        /// </summary>
        /// <param name="uniformName"></param>
        /// <param name="m"></param>
        public void SetUniformMatrix3(string uniformName, float[] m)
        {
            GL.UniformMatrix3(GetUniformLocation(uniformName), 1, false, m);
        }

        /// <summary>
        /// 请注意你的数据类型最终将转换为int还是float
        /// </summary>
        /// <param name="uniformName"></param>
        /// <param name="m"></param>
        public void SetUniformMatrix4(string uniformName, float[] m)
        {
            GL.UniformMatrix4(GetUniformLocation(uniformName), 1, false, m);
        }

        public int GetUniformLocation(string uniformName)
        {
            //  If we don't have the uniform name in the dictionary, get it's
            //  location and add it.
            if (uniformNamesToLocations.ContainsKey(uniformName) == false)
            {
                uniformNamesToLocations[uniformName] = GL.GetUniformLocation(ShaderProgramObject, uniformName);
                //  TODO: if it's not found, we should probably throw an exception.
            }

            //  Return the uniform location.
            return uniformNamesToLocations[uniformName];
        }

        /// <summary>
        /// Gets the shader program object.
        /// </summary>
        /// <value>
        /// The shader program object.
        /// </value>
        public uint ShaderProgramObject { get; protected set; }


        /// <summary>
        /// A mapping of uniform names to locations. This allows us to very easily specify
        /// uniform data by name, quickly looking up the location first if needed.
        /// </summary>
        private readonly Dictionary<string, int> uniformNamesToLocations = new Dictionary<string, int>();

        /// <summary>
        /// A mapping of attribute names to locations. This allows us to very easily specify
        /// attribute data by name, quickly looking up the location first if needed.
        /// </summary>
        private readonly Dictionary<string, uint> attributeNamesToLocations = new Dictionary<string, uint>();
    }

 

另外，添加一个辅助类ShaderCompilationException。

    [Serializable]
    public class ShaderCompilationException : Exception
    {
        private readonly string compilerOutput;

        public ShaderCompilationException(string compilerOutput)
        {
            this.compilerOutput = compilerOutput;
        }
        public ShaderCompilationException(string message, string compilerOutput)
            : base(message)
        {
            this.compilerOutput = compilerOutput;
        }
        public ShaderCompilationException(string message, Exception inner, string compilerOutput)
            : base(message, inner)
        {
            this.compilerOutput = compilerOutput;
        }
        protected ShaderCompilationException(
          System.Runtime.Serialization.SerializationInfo info,
          System.Runtime.Serialization.StreamingContext context)
            : base(info, context) { }

        public string CompilerOutput { get { return compilerOutput; } }
    }

 

实现PyramidDemo

加载shader，设置shader program

在PyramidDemo里实现。

        private ShaderProgram shaderProgram;

        public void Initilize()
        {
            InitShaderProgram();
        }

        private void InitShaderProgram()
        {
            var vertexShaderSource = File.ReadAllText(@"PyramidDemo.vert");
            var fragmentShaderSource = File.ReadAllText(@"PyramidDemo.frag");

            this.shaderProgram = new ShaderProgram();

            this.shaderProgram.Create(vertexShaderSource, fragmentShaderSource, null);
            this.shaderProgram.AssertValid();

        }

 

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

用VAO/VBO设置四面体模型

四面体模型的数据还是legacy OpenGL里的数据，但是不再用glVertex设置，而是用VAO/VBO来指定。

        const int vertexCount = 12;
        private uint[] vertexArrayObject;

        public void Initilize()
        {
            InitShaderProgram();

            InitVAO();
        }

        private void InitVAO()
        {
            // reserve a vertex array object(VAO) 预约一个VAO
            this.vertexArrayObject = new uint[1];
            GL.GenVertexArrays(1, this.vertexArrayObject);

            // prepare vertex buffer object(VBO) for vertexes' positions 为顶点位置准备VBO
            uint[] positionBufferObject = new uint[1];
            {
                // specify position array
                var positionArray = new UnmanagedArray<vec3>(vertexCount);
                positionArray[0] = new vec3(0.0f, 1.0f, 0.0f);
                positionArray[1] = new vec3(-1.0f, -1.0f, 1.0f);
                positionArray[2] = new vec3(1.0f, -1.0f, 1.0f);
                positionArray[3] = new vec3(0.0f, 1.0f, 0.0f);
                positionArray[4] = new vec3(1.0f, -1.0f, 1.0f);
                positionArray[5] = new vec3(1.0f, -1.0f, -1.0f);
                positionArray[6] = new vec3(0.0f, 1.0f, 0.0f);
                positionArray[7] = new vec3(1.0f, -1.0f, -1.0f);
                positionArray[8] = new vec3(-1.0f, -1.0f, -1.0f);
                positionArray[9] = new vec3(0.0f, 1.0f, 0.0f);
                positionArray[10] = new vec3(-1.0f, -1.0f, -1.0f);
                positionArray[11] = new vec3(-1.0f, -1.0f, 1.0f);

                // put positions into VBO
                GL.GenBuffers(1, positionBufferObject);
                GL.BindBuffer(BufferTarget.ArrayBuffer, positionBufferObject[0]);
                GL.BufferData(BufferTarget.ArrayBuffer, positionArray, BufferUsage.StaticDraw);

                positionArray.Dispose();
            }

            // prepare vertex buffer object(VBO) for vertexes' colors
            uint[] colorBufferObject = new uint[1];
            {
                // specify color array
                UnmanagedArray<vec3> colorArray = new UnmanagedArray<vec3>(vertexCount);
                colorArray[0] = new vec3(1.0f, 0.0f, 0.0f);
                colorArray[1] = new vec3(0.0f, 1.0f, 0.0f);
                colorArray[2] = new vec3(0.0f, 0.0f, 1.0f);
                colorArray[3] = new vec3(1.0f, 0.0f, 0.0f);
                colorArray[4] = new vec3(0.0f, 0.0f, 1.0f);
                colorArray[5] = new vec3(0.0f, 1.0f, 0.0f);
                colorArray[6] = new vec3(1.0f, 0.0f, 0.0f);
                colorArray[7] = new vec3(0.0f, 1.0f, 0.0f);
                colorArray[8] = new vec3(0.0f, 0.0f, 1.0f);
                colorArray[9] = new vec3(1.0f, 0.0f, 0.0f);
                colorArray[10] = new vec3(0.0f, 0.0f, 1.0f);
                colorArray[11] = new vec3(0.0f, 1.0f, 0.0f);

                // put colors into VBO
                GL.GenBuffers(1, colorBufferObject);
                GL.BindBuffer(BufferTarget.ArrayBuffer, colorBufferObject[0]);
                GL.BufferData(BufferTarget.ArrayBuffer, colorArray, BufferUsage.StaticDraw);

                colorArray.Dispose();
            }

            uint positionLocation = shaderProgram.GetAttributeLocation("in_Position");
            uint colorLocation = shaderProgram.GetAttributeLocation("in_Color");

            {
                // bind the vertex array object(VAO), we are going to specify data for it.
                GL.BindVertexArray(vertexArrayObject[0]);

                // specify vertexes' positions
                GL.BindBuffer(BufferTarget.ArrayBuffer, positionBufferObject[0]);
                GL.VertexAttribPointer(positionLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
                GL.EnableVertexAttribArray(positionLocation);

                // specify vertexes' colors
                GL.BindBuffer(BufferTarget.ArrayBuffer, colorBufferObject[0]);
                GL.VertexAttribPointer(colorLocation, 3, GL.GL_FLOAT, false, 0, IntPtr.Zero);
                GL.EnableVertexAttribArray(colorLocation);

                //  Unbind the vertex array object(VAO), we've finished specifying data for it.
                GL.BindVertexArray(0);
            }
        }

 

关于这里的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渲染的整个编码过程。今后我们的工作都是基于这个基本流程进行的，只不过在各个方面进行强化，增加新的功能。