首先，配置OpenGL开发环境，请参考OpenGL环境配置

使用到的文件及说明

//包含C语言的独立函数
#include "GLTools.h"

//MAC系统下使用#include <glut/glut.h>,在windows和linux上，使用 #include <GL/glut.h>，并添加宏FREEGLUT_STATIC
#ifdef __APPLE__
#include <glut/glut.h>
#else
#define FREEGLUT_STATIC
#include <GL/glut.h>
#endif
//矩阵工具类，用来快速设置正投影和透视投影。完成坐标3D到2D的转换
#include "GLFrustum.h"
//矩阵的工具类，可以利用它加载单元矩阵/矩阵/矩阵相乘/压栈/出栈/缩放/平移/旋转
#include "GLMatrixStack.h"
//变换管道类，用来快速在代码中传输视图矩阵/投影矩阵/视图投影变换矩阵
#include "GLGeometryTransform.h"
//矩阵工具，表示位置
#include "GLFrame.h"
//三角形批次类，帮助类，利用它可以传输顶点/光照/纹理/颜色数据到存储着色器中
#include "GLBatch.h"

#include "math3d.h"

创建全局的类

GLMatrixStack projectionMatrix;//投影矩阵
GLMatrixStack modelViewMatrix;//模型视图矩阵
GLShaderManager shareManager;//固定管线管理类
GLGeometryTransform transformPipeline;//变换管道，存储模型视图/投影/模型视图投影矩阵
GLFrame cameraFrame;//观察者的位置
GLFrame objectFrame;

//投影矩阵
GLFrustum viewFrustum;//设置图元绘制时的投影方式
//容器类
GLBatch pointBatch;//画点
GLBatch lineBatch;//线
GLBatch lineStripBatch;//点连线
GLBatch lineLoopBatch;//环线
GLBatch triangleBatch;//每三个顶点连成一个三角形
GLBatch triangleFanBatch;//
GLBatch triangleStripBatch;

GLfloat vBlack[] = { 0.0f, 0.0f, 0.0f, 1.0f };
GLfloat vGreen[] = { 0.0f, 1.0f, 0.0f, 1.0f };

// 跟踪空格的输入
int nStep = 0;

函数入口main函数

int main(int argc, char* argv[])
{
    //开辟一个工作空间
    gltSetWorkingDirectory(argv[0]);
    //初始化
    glutInit(&argc, argv);
    //申请一个颜色缓存区、双缓存区、深度缓存区、模型缓存区
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH | GLUT_STENCIL);
    //初始化window的尺寸
    glutInitWindowSize(800, 600);
    //创建window的名称
    glutCreateWindow("GL_POINTS");
    //注册回调函数
    //改变window尺寸的函数
    glutReshapeFunc(ChangeSize);
    //点击空格回调的函数
    glutKeyboardFunc(KeyPressFunc);
    //特殊键位函数(上下左右)
    glutSpecialFunc(SpecialKeys);
    //渲染界面显示函数
    glutDisplayFunc(RenderScene);
    
    
    //判断一下是否能初始化glew库，确保项目能正常使用OpenGL 框架
    GLenum err = glewInit();
    if (GLEW_OK != err) {
        fprintf(stderr, "GLEW Error:%s\n",glewGetErrorString(err));
        return 1;
    }
    //初始化OpenGL固定着色器
    SetupRC();
    
    //启动runloop
    glutMainLoop();
    return 0;
}

改变window尺寸的函数

//触发条件
//1.新建窗口
//2.窗口大小调整
//处理业务
//1.设置OpenGL视口
//2.设置OpenGL投影方式

void ChangeSize(int w,int h){
    //设置窗口大小
    glViewport(0, 0, w, h);
    //创建透视投影矩阵，
    viewFrustum.SetPerspective(35.0f, float(w)/float(h), 1.0f, 500.0f);
    //并将它载入投影矩阵堆栈中
    projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix());
    //调用顶部载入单元矩阵
    modelViewMatrix.LoadIdentity();
    
}

点击空格回调的函数

//监听空格键的输入，切换不同的“窗口名称”
void KeyPressFunc(unsigned char key,int x,int y){
    //32是空格的ASCI码值
    if (key == 32) {
        nStep++;
        if (nStep>6) {
            nStep = 0;
        }

    }
    switch (nStep) {
        case 0:
        {
            //设置窗口标题
            glutSetWindowTitle("GL_POINTS");
        }
            break;
        case 1:
        {
            glutSetWindowTitle("GL_LINES");
        }
            break;
        case 2:
            glutSetWindowTitle("GL_LINE_STRIP");
            break;
        case 3:
            glutSetWindowTitle("GL_LINE_LOOP");
            break;
        case 4:
            glutSetWindowTitle("GL_TRIANGLES");
            break;
        case 5:
            glutSetWindowTitle("GL_TRIANGLE_STRIP");
            break;
        case 6:
            glutSetWindowTitle("GL_TRIANGLE_FAN");
            break;
    }
    //提交重绘
    glutPostRedisplay();
}

特殊键位函数(上下左右)

//监听特殊键位（键盘上的上、下、左、右键）
void SpecialKeys(int key,int x,int y){
    //围绕一个指定的X,Y,Z轴旋转。
    if (key == GLUT_KEY_UP) {
        //上
        objectFrame.RotateWorld(m3dDegToRad(-5.0f), 1.0f, 0.0f, 0.0f);
    }
    if (key == GLUT_KEY_DOWN){
        //下
        objectFrame.RotateWorld(m3dDegToRad(5.0f), 1.0f, 0.0f, 0.0f);
    }
    if (key == GLUT_KEY_LEFT){
        //左
        objectFrame.RotateWorld(m3dDegToRad(-5.0f), 0.0f, 1.0f, 0.0f);
    }
    if (key == GLUT_KEY_RIGHT) {
        //右
        objectFrame.RotateWorld(m3dDegToRad(5.0f), 0.0f, 1.0f, 0.0f);
    }
    //重新渲染
    glutPostRedisplay();

}

渲染界面显示函数

//场景渲染
void RenderScene(){
    glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    
    //压栈
    modelViewMatrix.PushMatrix();
    M3DMatrix44f mCamera;
    cameraFrame.GetCameraMatrix(mCamera);
    
    //矩阵乘以矩阵堆栈的顶部矩阵，相乘的结果随后存储在堆栈的顶部
    modelViewMatrix.MultMatrix(mCamera);
    
    M3DMatrix44f mObjectFrame;
    //
    objectFrame.GetMatrix(mObjectFrame);
    
    modelViewMatrix.MultMatrix(mObjectFrame);
    
    shareManager.UseStockShader(GLT_SHADER_FLAT,transformPipeline.GetModelViewProjectionMatrix()
                                ,vBlack);
    
    switch (nStep) {
        case 0:
        {
            //设置点的大小
            glPointSize(18.0f);
            pointBatch.Draw();
            glPointSize(1.0f);
        }
            break;
        case 1:
        {
            //设置线的宽度
            glLineWidth(4.0f);
            lineBatch.Draw();
            glLineWidth(1.0f);
            
        }
            break;
        case 2:
        {
            glLineWidth(4.0f);
            lineStripBatch.Draw();
            glLineWidth(1.0f);
        }
            break;
        case 3:
        {
            glLineWidth(4.0f);
            lineLoopBatch.Draw();
            glLineWidth(1.0f);
        }
            break;
        case 4:
        {
            DrawWireFramedBatch(&triangleBatch);
        }
            break;
        case 5:
        {
            DrawWireFramedBatch(&triangleFanBatch);
        }
            break;
        case 6:
        {
            DrawWireFramedBatch(&triangleStripBatch);
        }
            break;
        
    }
    //还原到以前的模型视图矩阵(单元矩阵)
    modelViewMatrix.PopMatrix();
    //进行缓冲区交换
    glutSwapBuffers();
}

初始化OpenGL固定着色器

//初始化
void SetupRC(){
    //设置背景颜色
    glClearColor(0.7f, 0.7f, 0.7f, 1.0f);
    //初始化固定管线管理类
    shareManager.InitializeStockShaders();
    //?
    glEnable(GL_DEPTH_TEST);
    //设置变换管线来使用两个矩阵堆栈
    transformPipeline.SetMatrixStacks(modelViewMatrix, projectionMatrix);
    //设置观察者后移30
    cameraFrame.MoveForward(-30.0f);
    //定义一些点，三角形形状
    GLfloat vCoast[9] = {
        3,3,0,
        0,3,0,
        3,0,0
    };
    
    //用点的形式连接三个点
    pointBatch.Begin(GL_POINTS, 3);
    pointBatch.CopyVertexData3f(vCoast);
    pointBatch.End();
    //通过线的形式
    lineBatch.Begin(GL_LINES, 3);
    lineBatch.CopyVertexData3f(vCoast);
    lineBatch.End();
    //通过点连线的形式
    lineStripBatch.Begin(GL_LINE_STRIP, 3);
    lineStripBatch.CopyVertexData3f(vCoast);
    lineStripBatch.End();
    //通过环线的形式
    lineLoopBatch.Begin(GL_LINE_LOOP, 3);
    lineLoopBatch.CopyVertexData3f(vCoast);
    lineLoopBatch.End();
    
    //通过三角形创建金字塔(4个三角形)
    GLfloat vPyramid[12][3] = {
        -2.0f, 0.0f, -2.0f,
        2.0f, 0.0f, -2.0f,
        0.0f, 4.0f, 0.0f,

        2.0f, 0.0f, -2.0f,
        2.0f, 0.0f, 2.0f,
        0.0f, 4.0f, 0.0f,

        2.0f, 0.0f, 2.0f,
        -2.0f, 0.0f, 2.0f,
        0.0f, 4.0f, 0.0f,

        -2.0f, 0.0f, 2.0f,
        -2.0f, 0.0f, -2.0f,
        0.0f, 4.0f, 0.0f
        
    };
    //每3个顶点定义一个新的三角形
    triangleBatch.Begin(GL_TRIANGLES, 12);
    triangleBatch.CopyVertexData3f(vPyramid);
    triangleBatch.End();
    
    //三角形扇形--六边形
    GLfloat vPoints[100][3];
    int nVerts = 0;
    //半径
    GLfloat r = 3.0f;
    //原点(x,y,z) = (0,0,0);
    vPoints[nVerts][0] = 0.0f;
    vPoints[nVerts][1] = 0.0f;
    vPoints[nVerts][2] = 0.0f;
    
    
    //M3D_2PI 就是2Pi 的意思，就一个圆的意思。 绘制圆形
    for(GLfloat angle = 0; angle < M3D_2PI; angle += M3D_2PI / 6.0f) {
        
        //数组下标自增（每自增1次就表示一个顶点）
        nVerts++;
        /*
         弧长=半径*角度,这里的角度是弧度制,不是平时的角度制
         既然知道了cos值,那么角度=arccos,求一个反三角函数就行了
         */
        //x点坐标 cos(angle) * 半径
        vPoints[nVerts][0] = float(cos(angle)) * r;
        //y点坐标 sin(angle) * 半径
        vPoints[nVerts][1] = float(sin(angle)) * r;
        //z点的坐标
        vPoints[nVerts][2] = -0.5f;
    }
    // 结束扇形 前面一共绘制7个顶点（包括圆心）
    //添加闭合的终点
    //课程添加演示：屏蔽177-180行代码，并把绘制节点改为7.则三角形扇形是无法闭合的。
    nVerts++;
    vPoints[nVerts][0] = r;
    vPoints[nVerts][1] = 0;
    vPoints[nVerts][2] = 0.0f;
    //GL_TRIANGLE_FAN 以一个圆心为中心呈扇形排列，共用相邻顶点的一组三角形
    triangleFanBatch.Begin(GL_TRIANGLE_FAN, 8);
    triangleFanBatch.CopyVertexData3f(vPoints);
    triangleFanBatch.End();
    
    //三角形条带，一个小环或圆柱段
    //顶点下标
    int iCounter = 0;
    //半径
    GLfloat radius = 3.0f;
    //从0度~360度，以0.3弧度为步长
    for(GLfloat angle = 0.0f; angle <= (2.0f*M3D_PI); angle += 0.3f)
    {
        //或许圆形的顶点的X,Y
        GLfloat x = radius * sin(angle);
        GLfloat y = radius * cos(angle);
        
        //绘制2个三角形（他们的x,y顶点一样，只是z点不一样）
        vPoints[iCounter][0] = x;
        vPoints[iCounter][1] = y;
        vPoints[iCounter][2] = -0.5;
        iCounter++;
        
        vPoints[iCounter][0] = x;
        vPoints[iCounter][1] = y;
        vPoints[iCounter][2] = 0.5;
        iCounter++;
    }
    
    // 关闭循环
    printf("三角形带的顶点数：%d\n",iCounter);
    //结束循环，在循环位置生成2个三角形
    vPoints[iCounter][0] = vPoints[0][0];
    vPoints[iCounter][1] = vPoints[0][1];
    vPoints[iCounter][2] = -0.5;
    iCounter++;
    
    vPoints[iCounter][0] = vPoints[1][0];
    vPoints[iCounter][1] = vPoints[1][1];
    vPoints[iCounter][2] = 0.5;
    iCounter++;
    
    // GL_TRIANGLE_STRIP 共用一个条带（strip）上的顶点的一组三角形
    triangleStripBatch.Begin(GL_TRIANGLE_STRIP, iCounter);
    triangleStripBatch.CopyVertexData3f(vPoints);
    triangleStripBatch.End();
}

工具方法

void DrawWireFramedBatch(GLBatch* pBatch)
{
    /*------------画绿色部分----------------*/
    /* GLShaderManager 中的Uniform 值——平面着色器
     参数1：平面着色器
     参数2：运行为几何图形变换指定一个 4 * 4变换矩阵
          --transformPipeline 变换管线（指定了2个矩阵堆栈）
     参数3：颜色值
    */
    shareManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(), vGreen);
    pBatch->Draw();
    
    /*-----------边框部分-------------------*/
    /*
        glEnable(GLenum mode); 用于启用各种功能。功能由参数决定
        参数列表：http://blog.csdn.net/augusdi/article/details/23747081
        注意：glEnable() 不能写在glBegin() 和 glEnd()中间
        GL_POLYGON_OFFSET_LINE  根据函数glPolygonOffset的设置，启用线的深度偏移
        GL_LINE_SMOOTH          执行后，过虑线点的锯齿
        GL_BLEND                启用颜色混合。例如实现半透明效果
        GL_DEPTH_TEST           启用深度测试 根据坐标的远近自动隐藏被遮住的图形（材料
     
     
        glDisable(GLenum mode); 用于关闭指定的功能 功能由参数决定
     
     */
    
    //画黑色边框
    glPolygonOffset(-1.0f, -1.0f);// 偏移深度，在同一位置要绘制填充和边线，会产生z冲突，所以要偏移
    glEnable(GL_POLYGON_OFFSET_LINE);
    
    // 画反锯齿，让黑边好看些
    glEnable(GL_LINE_SMOOTH);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    
    //绘制线框几何黑色版 三种模式，实心，边框，点，可以作用在正面，背面，或者两面
    //通过调用glPolygonMode将多边形正面或者背面设为线框模式，实现线框渲染
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    //设置线条宽度
    glLineWidth(2.5f);
    
    /* GLShaderManager 中的Uniform 值——平面着色器
     参数1：平面着色器
     参数2：运行为几何图形变换指定一个 4 * 4变换矩阵
         --transformPipeline.GetModelViewProjectionMatrix() 获取的
          GetMatrix函数就可以获得矩阵堆栈顶部的值
     参数3：颜色值（黑色）
     */
    
    shareManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(), vBlack);
    pBatch->Draw();

    // 复原原本的设置
    //通过调用glPolygonMode将多边形正面或者背面设为全部填充模式
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    glDisable(GL_POLYGON_OFFSET_LINE);
    glLineWidth(1.0f);
    glDisable(GL_BLEND);
    glDisable(GL_LINE_SMOOTH);
    
    
}