图元装配和光栅化

void glLineWidth(GLfloat width)

width : 指定线宽，以像素表示 

GLfloat lineWidthRange[2];
glGetFloatv(GL_ALIASED_LINE_WIDTH_SIZE, lineWidthRange);

GLfloat pointSizeRange[2];
glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, pointSizeRange);

#version 300 es
percision mediump float;
uniform sampler2D s_texSprite;
layout(location = 0) out vec4 outColor;
void main()
{
  outColor = texture(s_texSprite, gl_PointCoord);
}

void glDrawArrays(Glenum mode,GLint first, GLsizei count)

mode :  三角行、直线、点精灵对应的7种模式
first : 绘制的第一个顶点的索引
count : 一共绘制的顶点数量

void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)

mode :  三角行、直线、点精灵对应的7种模式
start : 指定indices最小的数组索引
end : 指定indices最大 的数组索引
count : 指定要绘制的索引数量
type : GL_UNSIGNED_BYTE、GL_UNSIGNED_SHORT、GL_UNSIGNED_INT
indices : 指向元素索引储存位置的指针

#version 300 es
#define VERTEX_POS_INDX  0
#define NUM_FACES  6

GLfloat vertices[] = {...}; // 顶点坐标
glEnableVertexAttribArray(VERTEX_POS_INDX);
glVertexAttribPointer(VERTEX_POS_INDX, 3, GL_FLOAT, GL_FLASE, 0, vertices);
for(int i = 0; i < NUM_FACES; i++){
  glDrawArrays(GL_TRIANGLES, i * 4, 4);  
}

 #version 300 es
 #define VERTEX_POS_INDX  0

 GLfloat vertices[] = {...}; // 顶点坐标
 GLubyte indices[36] = {0, 1, 2, 0, 2, 3
                        0, 3, 4, 0, 4, 5,
                        0, 5, 6, 0, 6, 1,
                        7, 1, 6, 7, 2, 1,
                        7, 5, 4, 7, 6, 5,
                        7, 3, 2, 7, 4, 3 };
 glEnableVertexAttribArray(VERTEX_POS_INDX);
 glVertexAttribPointer(VERTEX_POS_INDX, 3, GL_FLOAT, GL_FLASE, 0, vertices);
 glDrawElements(GL_TRIANGLES, sizeof(indices) / sizeof(GLubyte), GL_UNSIGNED_BYTE, indices);

glEnable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
...
glDisable(GL_PRIMITIVE_RESTART_FIXED_INDEX);

void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount)
void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instanceCount)

mode : 三角形、直线、点精灵对应的七种模式
first : 启用的点点数组中的起始顶点索引
count : 绘制的索引数量
type : 指定保存在indices中的元素索引类型（GL_UNSIGNED_BYTE，GL_UNSIGNED_SHORT，GL_UNSIGNED_INT）
indices : 元素索引储存位置的一个指针
instaceCount : 绘制的图元实例数量

void glVertexAttribDivisor(GLuint index，GLuint divisior)

index : 通用顶点属性索引
dicisior : index位置的通用属性更新之间传递的实例数量

#include "esUtil.h"
#include<stdlib.h>
#include<math.h>

#ifdef _WIN32
#define srandom srand
#define random rand
#endif // _WIN32

#define NUM_INSTANCES  100
#define POSITION_LOC  0
#define COLOR_LOC  1
#define MVP_LOC  2

typedef struct
{
	//着色器程序
	GLuint programObject;

	//顶点缓冲区对象
	GLuint positionVBO;
	GLuint colorVBO;
	GLuint mvpVBO;
	GLuint indicesIBO;

	//索引数量
	int numIndices;

	//旋转角度
	GLfloat  angle[NUM_INSTANCES];

} UserData;

int _Init(ESContext *esContext)
{
	GLfloat *positions;
	GLuint *indices;

	UserData *userData = esContext->userData;

	//顶点着色器源代码
	const char vShaderStr[] = "#version 300 es  \n"
		"layout(location = 0) in vec4 a_position; \n"
		"layout(location = 1) in vec4 a_color; \n"
		"layout(location = 2) in mat4 a_mvpMatix; \n"
		"out vec4 v_color; \n"
		"void main() \n"
		"{ \n"
		"	v_color = a_color; \n"
		"	gl_Postion = a_postion * a_mvpMatrix; \n"
		"}  \n";

	const char fShaderStr[] = "#version 300 es \n"
		"precision mediump float; \n"
		"in vec4 v_color; \n"
		"layout(location = 0)  out vec4 outColor; \n"
		"void main()  \n"
		"{  \n"
		"		outColot = v_color; \n"
		"}";

	//编译着色器代码并链接到着色器程序
	userData->programObject = esLoadProgram(vShaderStr, fShaderStr);

	//生成数组数据
	userData->numIndices = esGenCube(0.1f, &positions, NULL, NULL, &indices);

	//索引缓冲区对象
	glGenBuffers(1, userData->indicesIBO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, userData->indicesIBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * userData->numIndices, indices, GL_STATIC_DRAW);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
	free(indices);

	//位置缓冲区对象
	glGenBuffers(1, userData->positionVBO);
	glBindBuffer(GL_ARRAY_BUFFER, userData->positionVBO);
	glBufferData(GL_ARRAY_BUFFER, 24 * sizeof(GLfloat) * 3, positions, GL_STATIC_DRAW);
	free(positions);

	//对每个实例生成随机颜色
	{
		GLubyte colors[NUM_INSTANCES][4];
		int instace;

		srand(0);

		for (instace = 0; instace < NUM_INSTANCES; instace++)
		{
			colors[instace][0] = random() % 255;
			colors[instace][1] = random() % 255;
			colors[instace][2] = random() % 255;
			colors[instace][3] = 0;
		}

		glGenBuffers(1, userData->colorVBO);
		glBindBuffer(GL_ARRAY_BUFFER, userData->colorVBO);
		glBufferData(GL_ARRAY_BUFFER, NUM_INSTANCES * 4, colors, GL_STATIC_DRAW);
	}

	//分配储存空间保存每个 变换矩阵 实例
	{
		int instace;

		for (instace = 0; instace < NUM_INSTANCES; instace++)
		{
			userData->angle[instace] = (float)(random() % 32768) / 32767.0f * 360.0f;
		}

		glGenBuffers(1, userData->mvpVBO);
		glBindBuffer(GL_ARRAY_BUFFER, userData->mvpVBO);
		glBufferData(GL_ARRAY_BUFFER, NUM_INSTANCES * sizeof(ESMatrix), NULL, GL_DYNAMIC_DRAW);
	}
	glBindBuffer(GL_ARRAY_BUFFER, 0);

	glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
	return GL_TRUE;
}

//根据时间增量更新 变换矩阵
void Update(ESContext *esContext, float deltaTime)
{
	UserData *userData = esContext->userData;
	ESMatrix *matrixBuf;
	ESMatrix perspective;
	float aspect;
	int instance = 0;
	int numRows;
	int numColumn;

	//计算窗口的宽高比
	aspect = (GLfloat)esContext->width / (GLfloat)esContext->height;

	esMatrixLoadIdentity(&perspective);
	esPerspective(&perspective, 60.0f, aspect, 1.0f, 20.0f);

	glBindBuffer(GL_ARRAY_BUFFER, userData->mvpVBO);
	matrixBuf = (ESMatrix *)glMapBufferRange(GL_ARRAY_BUFFER, 0, sizeof(ESMatrix) * NUM_INSTANCES, GL_MAP_WRITE_BIT);

	numRows = (int)sqrtf(NUM_INSTANCES);
	numColumn = numRows;

	for (instance = 0; instance < NUM_INSTANCES; instance++)
	{
		ESMatrix modelview;
		float translateX = ((float)(instance % numRows) / (float)numRows)*2.0f - 1.0f;
		float translateY = ((float)(instance / numColumn) / (float)numColumn) * 2.0f - 1.0f;

		esMatrixLoadIdentity(&modelview);

		esTranslate(&modelview, translateX, translateY, -2.0f);

		userData->angle[instance] += (deltaTime * 40.0f);

		if (userData->angle[instance] >= 360.0f)
		{
			userData->angle[instance] -= 360.0f;
		}

		//旋转立方体
		esRotate(&modelview, userData->angle[instance], 1.0, 0.0, 1.0);

		esMatrixMultiply(&matrixBuf[instance], &modelview, &perspective);
	}

	glUnmapBuffer(GL_ARRAY_BUFFER);
}

void Draw(ESContext *esContext)
{
	UserData *userData = esContext->userData;

	//设置窗口
	glViewport(0, 0, esContext->width, esContext->height);

	//清空颜色
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	
	//链接着色器程序
	glUseProgram(userData->programObject);

	//加载顶点坐标
	glBindBuffer(GL_ARRAY_BUFFER, userData->positionVBO);
	glVertexAttribPointer(POSITION_LOC, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (const void *)NULL);
	glEnableVertexAttribArray(POSITION_LOC);

	//加载实例颜色缓冲区
	glBindBuffer(GL_ARRAY_BUFFER, userData->colorVBO);
	glVertexAttribPointer(COLOR_LOC, 4, GL_UNSIGNED_BYTE, GL_TRUE, 4 * sizeof(GLubyte), (const void *)NULL);
	glEnableVertexAttribArray(COLOR_LOC);
	glVertexAttribDivisor(COLOR_LOC, 1);

	//加载实例 变换矩阵 缓冲区
	glBindBuffer(GL_ARRAY_BUFFER, userData->mvpVBO);

	//加载矩阵的每一行
	glVertexAttribPointer(MVP_LOC + 0, 4, GL_FLOAT, GL_FALSE, sizeof(ESMatrix), (const void *)NULL);
	glVertexAttribPointer(MVP_LOC + 1, 4, GL_FLOAT, GL_FALSE, sizeof(ESMatrix), (const void *)(sizeof(GLfloat) * 4));
	glVertexAttribPointer(MVP_LOC + 1, 4, GL_FLOAT, GL_FALSE, sizeof(ESMatrix), (const void *)(sizeof(GLfloat) * 8));
	glVertexAttribPointer(MVP_LOC + 1, 4, GL_FLOAT, GL_FALSE, sizeof(ESMatrix), (const void *)(sizeof(GLfloat) * 12));

	glEnableVertexAttribArray(MVP_LOC + 0);
	glEnableVertexAttribArray(MVP_LOC + 1);
	glEnableVertexAttribArray(MVP_LOC + 2);
	glEnableVertexAttribArray(MVP_LOC + 3);

	glVertexAttribDivisor(MVP_LOC + 0, 1);
	glVertexAttribDivisor(MVP_LOC + 1, 1);
	glVertexAttribDivisor(MVP_LOC + 2, 1);
	glVertexAttribDivisor(MVP_LOC + 3, 1);

	//绑定索引缓冲数据
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, userData->indicesIBO);

	//绘制立方体
	glDrawElementsInstanced(GL_TRIANGLES, userData->numIndices, GL_UNSIGNED_INT, (const void *)NULL, NUM_INSTANCES);
}

void Shutdown(ESContext *esContext)
{
	UserData *userData = esContext->userData;

	glDeleteBuffers(1, userData->positionVBO);
	glDeleteBuffers(1, userData->colorVBO);
	glDeleteBuffers(1, userData->mvpVBO);
	glDeleteBuffers(1, userData->indicesIBO);

	//删除着色器程序
	glDeleteProgram(userData->programObject);
}

int esMain(ESContext *esContext)
{
	esContext->userData = malloc(sizeof(UserData));

	esCreateWindow(esContext, "Instancing", 640, 480, ES_WINDOW_RGB | ES_WINDOW_DEPTH);

	if (!_Init(esContext))
	{
		return GL_FALSE;
	}

	esRegisterShutdownFunc(esContext, Shutdown);
	esRegisterUpdateFunc(esContext, Update);
	esRegisterDrawFunc(esContext, Draw);

	return GL_TRUE;
}

void glViewport(GLint x, GLint y, GLsizei w, GLsizei h)

x,y : 指定视口左下角的窗口坐标，以像素数表示
w,h : 指定视口的宽度和高度，值必须大于0

void glDepthRangef(GLclampf n, GLclampf f)

n，f  指定所需的深度范围。 n，f的默认值为 0.0 和 1.0，两值的范围为`[0.0 ,1.0]`。

void glFronntFace(GLenum dir)

dir : 指定正面三角形的方向。  有效值为GL_CW、GL_CCW，默认值为GL_CCW

void glCullFace(GLenum mode)

mode : 指定要被剔除的三角形的面。  有效值为GL_FRONT，GL_BACK、GL_FRONT_AND_BACK，默认为GL_BACK。

void glEnable(GLenum cap)
void glDisable(GLenum cap)

cap : 设置为GL_CULL_FACE，默认情况下剔除被禁用

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

//设置顶点属性状态
...

glDrawArrays(GL_TRIANGLE_FAN, 0, 4);

glDepthFunc(GL_LEQUAL);

//设置顶点属性状态
...

glDrawArrays(GL_TRIANGLE_FAN, 0, 4);

void glPolygonOffset(GLfloat factor, GLfloat units)

const float polygonOffsetFactor =  -1.0f;
const float polygonOffsetUnits =  -2.0f;

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//加载顶点着色器
...

glDrawArrays(GL_TRIANGLE_FAN, 0, 4);

glDepthFunc(GL_LEQUAL);

glEnable(GL_POLYGON_OFFSET_FILL);

glPolygonOffset(polygonOffsetFactor, polygonOffsetUnits);

glDrawArrays(GL_TRIANFLE_FAN,0, 4);

void glBeginQuery(GLenum target, GLuint id)
void glEndQuery(GLenum target)

target : 指定查询对象的目标类型：
`GL_ANY_SAMPLES_PASSED` : 返回是否有样本通过深度测试的精度布尔状态
`GL_ANY_SAMPLES_PASSED_CONSERVATIVR` : 提供更好的性能，但是精确度较低
`GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN` : 在没有样本通过进度测试时返回 GL_TRUE

id : 指定查询对象的名称. 用 `glGenQueries` 创建，用 `glDeleteQueries` 删除。