OGLES 程序和着色器间的数据传递

一、通过顶点属性下标传递的顶点和索引数据

1.Shader端设置：

(1) 着色器输入输出等限定符

in(默认类型),out,inout, const, invariant。

GLSL 1.4版本中attribute和varying字段都删除了，都统一使用in out或inout关键字。

顶点着色器的输入数据有：位置，颜色，法向量，纹理坐标，雾坐标，实例id等，例如：

gl_Vertex, gl_Color, gl_Normal, gl_TexCoord[n],, gl_SecondaryColor, gl_FogCoord,

gl_MultiTexCoord[n], gl_VertexID, gl_InstanceID .

(2)顶点属性和布局限定符： 本质上shader program将为每个顶点创建一个顶点数组，该数组包含了一个完整顶点数据（例如下面是pos,color)， 每个顶点属性下标其实就是顶点数组的下标 ，GPU会根据VAO指定从离散的VBO位置索引到一个完整的顶点，然后每个完整的顶点是并行处理的。 所以每个顶点的顶点数组属性数量是有限制的，OES3.0上是16个，可以用：

GLint maxVertexAttr = 0;

glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttr);查询。

布局限定符是用于建立映射的，例如顶点数组属性和shader中变量之间的映射，片段输出和MRT之间的映射,使用布局限定符比glBindAttribLocation (GLuint program, GLuint index, const GLchar *name)简洁。 顶点着色器输出和片段着色器输入不能使用布局限定符(顶点输入和片段输出中才有，输出的index是用于MRT指定的，默认是0），且他们输入输出的变量数量也是有限制的，OES3.0上顶点着色器输出变量最大为16，片段着色器输入为15。

shader中写法实例：

uniform mat4 u_matViewProjection;

//in声明输入的顶点属性变量，不能声明为结构或数组，且是只读变量不能修改。

// 不会进行打包，小于vec4的属性将会作为vec4输入，因此如果几个vec2,vec1可以合并为一个vec4

// 合并后有更好的效率。没有指定布局限定符的话要程序链接成功查询当前活动的属性变量。

layout(location = 0)in vec4 a_position

layout(location = 1)in vec3 a_color;

out vec3 v_color;

void main(void)

{

gl_Position = u_matViewProjection * a_position;

v_color = a_color;

}

2.app端设置：

顶点着色器的输入用：

1）常量顶点属性

常量顶点属性，对图元中的所有顶点传入值都一样，指定一次即可，所用函数是：

glVertexAttriblf(attrIdx, xValue);

glVertexAttrib4f(attrIdx, xValue, yValue, zValue, wValue);

常量顶点属性较少使用，直接用顶点数组即可。

2）顶点数组（VA)

非缓冲区对象中的VAO,而是vertexShader输入的单个顶点对应的顶点数组，OES2.0是使用顶点数组传递数据，OES3.0总是建议用顶点缓冲区对象传递数据，已获得更好的性能。

对于一个顶点的顶点数组数据的单个属性下标进行数据指定：

void  glVertexAttribPointer ( GLuint  index , GLint  size , GLenum  type , GLboolean  normalized , GLsizei  stride , const GLvoid *  pointer );

// 函数说明：说明数组类型下标, 顶点属性成员数量，成员类型，成员类型很影响带宽，建议位置为GL_FLOAT,法向量,uv等为GL_HALF_FLOAT,颜色为GL_UNSIGNED_BYTE。

normalized 非浮点数转换浮点格式时是否规范化[-1,1]一般是否。

stride为0则该顶点属性是顺序存储的，不为0则用该跨距作为当前到下一个该属性数据之间的跨距，跨距与自己存放的顶点数据是结构数组，数组结构紧密关联 。

pointer 数据块中该属性字节首地址，如果在顶点缓冲区VBO对象中，那么首地址用NULL,因为绑定VBO时已经有指针，偏移是NULL上的偏移。

顶点数据存储结构的指定，有两种：一种是结构数组(顶点pos,color, normal,uv等先组成一个结构，有元素个数为numVertexs的数组），另一种是数组结构(顶点每个元素组成一个数组如pos，这些数组并列着组成一个结构）,具体用那种自己定义，因为glVertexAttribPointer也是自己定义的。用结构数组更加高效，因为渲染时候传入shader的信息是逐个顶点处理的，方便顺序访问，但是如果有更改需要重新加载整个顶点属性缓冲区，通过将动态改变的属性保存在单独的缓冲区可以改善性能。

例如：

/顶点位置和颜色数据

const GLfloat vertexData[] = {

-0.5f, 0.0f, 0.0f, 1.0f,

0.5f, 0.0f, 0.0f, 1.0f,

0.0f, 0.5f, 0.0f, 1.0f,

1.0f, 0.0f, 0.0f, 1.0f,

0.0f, 1.0f, 0.0f, 1.0f,

0.0f, 0.0f, 1.0f, 1.0f

};

glGenVertexArrays(1, &vaoId);

glBindVertexArray(vaoId);

//创建vertex buffer object对象

glGenBuffers(1, &vboId);

glBindBuffer(GL_ARRAY_BUFFER, vboId);

// GL_STATIC_DRAW，GL_DYNAMIC_DRAW是GL_BUFFER_USAGE是一个使用标志类似DX的使用标志但是更加

// 宽松。例如指定为GL_STATIC_DRAW也可以频繁修改。

glBufferData(GL_ARRAY_BUFFER, sizeof(vertexData), vertexData, GL_STATIC_DRAW);

// 指定VAO如何去解析VBO数据块中的数据。

// 在Shader创建之前或创建之后指定都是可以的，因为glDrawXXX时候才真正去处理Opengl状态机中的设置。

//启用顶点位置属性索引,要在display中指定的(vao包装了切换vao即可)，因为需要开启顶点属性索引才能绘制，特别是绘制物体多的时候，需要切换才能正确绘制。

// 也可以封装在VAO中，只负责启用glEnableVertexAttribArray不关闭即可。

glEnableVertexAttribArray(0); // 激活顶点属性数组，否则是用常量顶点属性

glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0); //指定Position顶点属性数据格式，大小会根据glDrawArrays截断。

//启用顶点颜色属性索引

glEnableVertexAttribArray(1);

//48是4*3*4 = 48, 指定Color顶点属性数据格式，大小会根据glDrawArrays截断。

// 输入到Shader中的时候会并行的从顶点取得一个数据，从颜色取得一个数据作为整个顶点的输入.再进行下一个顶点的输入。

glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, (void*)48);

3)开始顶点数组属性下标（不开启是用常量顶点属性的输入)

// 输入参数对应顶点输入的类型下标，默认下标从0开始

glEnableVertexAttribArray (0);

4)顶点缓冲区对象(VBO)

顶点数组是将数据保存在CPU中，每次drawcall都要传输到GPU中，使用顶点缓冲区VBO在初始化或改变时候才传递。这种方式能显著改善渲染性能，CPU内存开销，IO传输压力和电力开销。

VBO有两种，一种是GL_ARRAY_BUFFER用于保存顶点数据，一种是GL_ELEMENT_ARRAY_BUFFER用于创建保存图元索引的缓冲区对象(类似DX中的索引缓存)。

顶点缓冲区对象的创建：

glGenBuffers(1, &vboId);// 只是一个可用标志间接地址

glBindBuffer(GL_ARRAY_BUFFER, vboId);// 将全局活动GL_ARRAY_BUFFER指针指向当前缓冲区对象

// GL_STATIC_DRAW，GL_DYNAMIC_DRAW是GL_BUFFER_USAGE是一个使用标志类似DX的使用标志但是更加

// 宽松。例如指定为GL_STATIC_DRAW也可以频繁修改。

// 缓冲区数据用glBufferData创建和初始化

glBufferData(GL_ARRAY_BUFFER, sizeof(vertexData), vertexData, GL_STATIC_DRAW);

// 缓冲区数据用glBufferSubData更新

glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const void *data);

删除缓冲区对象用：

glDeleteBuffers(GLsizei n, const GLunit *buffers)；

同一种类型缓冲区可以有多个，当前该类型全局指针指向一个进行操作即可，所以顶点数据可以用多个独立的顶点缓冲区处理，区分经常更新的缓冲区，避免全部数据的更新，提高性能。

例如：位置一个缓冲区，颜色一个缓冲区，顶点具体的数据需要 glVertexAttribPointer来解析，但是索引缓冲区仅绑定即可。

实例：

#include "esUtil.h"

typedef struct

{

// Handle to a program object

GLuint programObject;

// VertexBufferObject Ids

GLuint vboIds[3];

} UserData;

#define VERTEX_POS_SIZE 3 // x, y and z

#define VERTEX_COLOR_SIZE 4 // r, g, b, and a

#define VERTEX_POS_INDX 0

#define VERTEX_COLOR_INDX 1

int Init ( ESContext *esContext )

{

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"

"out vec4 v_color; \n"

"void main() \n"

"{ \n"

" v_color = a_color; \n"

" gl_Position = a_position; \n"

"}";

const char fShaderStr[] =

"#version 300 es \n"

"precision mediump float; \n"

"in vec4 v_color; \n"

"out vec4 o_fragColor; \n"

"void main() \n"

"{ \n"

" o_fragColor = v_color; \n"

"}" ;

GLuint programObject;

// Create the program object

programObject = esLoadProgram ( vShaderStr, fShaderStr );

if ( programObject == 0 )

{

return GL_FALSE;

}

// Store the program object

userData->programObject = programObject;

userData->vboIds[0] = 0;

userData->vboIds[1] = 0;

userData->vboIds[2] = 0;

glClearColor ( 1.0f, 1.0f, 1.0f, 0.0f );

return GL_TRUE;

}

void DrawPrimitiveWithVBOs ( ESContext *esContext,

GLint numVertices, GLfloat **vtxBuf,

GLint *vtxStrides, GLint numIndices,

GLushort *indices )

{

UserData *userData = esContext->userData;

// vboIds[0] - used to store vertex position

// vboIds[1] - used to store vertex color

// vboIds[2] - used to store element indices

if ( userData->vboIds[0] == 0 && userData->vboIds[1] == 0 &&

userData->vboIds[2] == 0 )

{

// Only allocate on the first draw

glGenBuffers ( 3, userData->vboIds );

glBindBuffer ( GL_ARRAY_BUFFER, userData->vboIds[0] );

glBufferData ( GL_ARRAY_BUFFER, vtxStrides[0] * numVertices,

vtxBuf[0], GL_STATIC_DRAW );

glBindBuffer ( GL_ARRAY_BUFFER, userData->vboIds[1] );

glBufferData ( GL_ARRAY_BUFFER, vtxStrides[1] * numVertices,

vtxBuf[1], GL_STATIC_DRAW );

glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER, userData->vboIds[2] );

glBufferData ( GL_ELEMENT_ARRAY_BUFFER,

sizeof ( GLushort ) * numIndices,

indices, GL_STATIC_DRAW );

}

glBindBuffer ( GL_ARRAY_BUFFER, userData->vboIds[0] );

glEnableVertexAttribArray ( VERTEX_POS_INDX );

glVertexAttribPointer ( VERTEX_POS_INDX, VERTEX_POS_SIZE,

GL_FLOAT, GL_FALSE, vtxStrides[0], 0 );

glBindBuffer ( GL_ARRAY_BUFFER, userData->vboIds[1] );

glEnableVertexAttribArray ( VERTEX_COLOR_INDX );

glVertexAttribPointer ( VERTEX_COLOR_INDX,

VERTEX_COLOR_SIZE,

GL_FLOAT, GL_FALSE, vtxStrides[1], 0 );

glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER, userData->vboIds[2] );

glDrawElements ( GL_TRIANGLES, numIndices,

GL_UNSIGNED_SHORT, 0 );

glDisableVertexAttribArray ( VERTEX_POS_INDX );

glDisableVertexAttribArray ( VERTEX_COLOR_INDX );

glBindBuffer ( GL_ARRAY_BUFFER, 0 );

glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER, 0 );

}

void Draw ( ESContext *esContext )

{

UserData *userData = esContext->userData;

// 3 vertices, with (x,y,z) ,(r, g, b, a) per-vertex

GLfloat vertexPos[3 * VERTEX_POS_SIZE] =

{

0.0f, 0.5f, 0.0f, // v0

-0.5f, -0.5f, 0.0f, // v1

0.5f, -0.5f, 0.0f // v2

};

GLfloat color[4 * VERTEX_COLOR_SIZE] =

{

1.0f, 0.0f, 0.0f, 1.0f, // c0

0.0f, 1.0f, 0.0f, 1.0f, // c1

0.0f, 0.0f, 1.0f, 1.0f // c2

};

GLint vtxStrides[2] =

{

VERTEX_POS_SIZE * sizeof ( GLfloat ),

VERTEX_COLOR_SIZE * sizeof ( GLfloat )

};

// Index buffer data

GLushort indices[3] = { 0, 1, 2 };

GLfloat *vtxBuf[2] = { vertexPos, color };

glViewport ( 0, 0, esContext->width, esContext->height );

glClear ( GL_COLOR_BUFFER_BIT );

glUseProgram ( userData->programObject );

DrawPrimitiveWithVBOs ( esContext, 3, vtxBuf,

vtxStrides, 3, indices );

}

void Shutdown ( ESContext *esContext )

{

UserData *userData = esContext->userData;

glDeleteProgram ( userData->programObject );

glDeleteBuffers ( 3, userData->vboIds );

}

int esMain ( ESContext *esContext )

{

esContext->userData = malloc ( sizeof ( UserData ) );

esCreateWindow ( esContext, "Example 6-6", 320, 240, ES_WINDOW_RGB );

if ( !Init ( esContext ) )

{

return GL_FALSE;

}

esRegisterShutdownFunc ( esContext, Shutdown );

esRegisterDrawFunc ( esContext, Draw );

return GL_TRUE;

}

5)顶点数组对象(VAO)

VAO是OES2.0不存在，3.0引入的。可以将VBO的当前缓冲区绑定，索引缓冲区绑定，和缓冲区数据块解析的glVertexAttribPointer 格式，启动顶点数组属性索引等信息绑定，绘制时候只需要一个glBindVertexArray调用就可以了减少API调用提高性能，但是初始化VBO和填充VBO的glBufferData却不能封装。删除用glDeleteVertexArrays()。例如：

#include "esUtil.h"

typedef struct

{

// Handle to a program object

GLuint programObject;

// VertexBufferObject Ids

GLuint vboIds[2];

// VertexArrayObject Id

GLuint vaoId;

} UserData;

#define VERTEX_POS_SIZE 3 // x, y and z

#define VERTEX_COLOR_SIZE 4 // r, g, b, and a

#define VERTEX_POS_INDX 0

#define VERTEX_COLOR_INDX 1

#define VERTEX_STRIDE ( sizeof(GLfloat) * \

( VERTEX_POS_SIZE + \

VERTEX_COLOR_SIZE ) )

int Init ( ESContext *esContext )

{

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"

"out vec4 v_color; \n"

"void main() \n"

"{ \n"

" v_color = a_color; \n"

" gl_Position = a_position; \n"

"}";

const char fShaderStr[] =

"#version 300 es \n"

"precision mediump float; \n"

"in vec4 v_color; \n"

"out vec4 o_fragColor; \n"

"void main() \n"

"{ \n"

" o_fragColor = v_color; \n"

"}" ;

GLuint programObject;

// 3 vertices, with (x,y,z) ,(r, g, b, a) per-vertex

GLfloat vertices[3 * ( VERTEX_POS_SIZE + VERTEX_COLOR_SIZE )] =

{

0.0f, 0.5f, 0.0f, // v0

1.0f, 0.0f, 0.0f, 1.0f, // c0

-0.5f, -0.5f, 0.0f, // v1

0.0f, 1.0f, 0.0f, 1.0f, // c1

0.5f, -0.5f, 0.0f, // v2

0.0f, 0.0f, 1.0f, 1.0f, // c2

};

// Index buffer data

GLushort indices[3] = { 0, 1, 2 };

// Create the program object

programObject = esLoadProgram ( vShaderStr, fShaderStr );

if ( programObject == 0 )

{

return GL_FALSE;

}

// Store the program object

userData->programObject = programObject;

// Generate VBO Ids and load the VBOs with data

glGenBuffers ( 2, userData->vboIds );

glBindBuffer ( GL_ARRAY_BUFFER, userData->vboIds[0] );

glBufferData ( GL_ARRAY_BUFFER, sizeof ( vertices ),

vertices, GL_STATIC_DRAW );

glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER, userData->vboIds[1] );

glBufferData ( GL_ELEMENT_ARRAY_BUFFER, sizeof ( indices ),

indices, GL_STATIC_DRAW );

// Generate VAO Id

glGenVertexArrays ( 1, &userData->vaoId );

// Bind the VAO and then setup the vertex

// attributes

glBindVertexArray ( userData->vaoId );

glBindBuffer ( GL_ARRAY_BUFFER, userData->vboIds[0] );

glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER, userData->vboIds[1] );

glEnableVertexAttribArray ( VERTEX_POS_INDX );

glEnableVertexAttribArray ( VERTEX_COLOR_INDX );

glVertexAttribPointer ( VERTEX_POS_INDX, VERTEX_POS_SIZE,

GL_FLOAT, GL_FALSE, VERTEX_STRIDE, ( const void * ) 0 );

glVertexAttribPointer ( VERTEX_COLOR_INDX, VERTEX_COLOR_SIZE,

GL_FLOAT, GL_FALSE, VERTEX_STRIDE,

( const void * ) ( VERTEX_POS_SIZE * sizeof ( GLfloat ) ) );

// Reset to the default VAO

glBindVertexArray ( 0 );

glClearColor ( 1.0f, 1.0f, 1.0f, 0.0f );

return GL_TRUE;

}

void Draw ( ESContext *esContext )

{

UserData *userData = esContext->userData;

glViewport ( 0, 0, esContext->width, esContext->height );

glClear ( GL_COLOR_BUFFER_BIT );

glUseProgram ( userData->programObject );

// Bind the VAO

glBindVertexArray ( userData->vaoId );

// Draw with the VAO settings

glDrawElements ( GL_TRIANGLES, 3, GL_UNSIGNED_SHORT, ( const void * ) 0 );

// Return to the default VAO

glBindVertexArray ( 0 );

}

void Shutdown ( ESContext *esContext )

{

UserData *userData = esContext->userData;

glDeleteProgram ( userData->programObject );

glDeleteBuffers ( 2, userData->vboIds );

glDeleteVertexArrays ( 1, &userData->vaoId );

}

int esMain ( ESContext *esContext )

{

esContext->userData = malloc ( sizeof ( UserData ) );

esCreateWindow ( esContext, "VertexArrayObjects", 320, 240, ES_WINDOW_RGB );

if ( !Init ( esContext ) )

{

return GL_FALSE;

}

esRegisterShutdownFunc ( esContext, Shutdown );

esRegisterDrawFunc ( esContext, Draw );

return GL_TRUE;

}

6）映射缓冲区对象

CPU中数据 可以用glBufferData,更新用glBufferSubData将数据传递到GPU内存中。也可以用glMapBufferRange (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)通过内存共享的方式获取GPU内存中数据地址(获取或写入全部或部分)，用共享内存相比glBufferData, glBufferSubData更加高效，例如：

GLfloat * vtxMappedBuf = ( GLfloat * )

glMapBufferRange ( GL_ARRAY_BUFFER, 0, vtxStride * numVertices,

GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT );

使用标志:#define GL_MAP_READ_BIT 0x0001 读取返回指针数据

#define GL_MAP_WRITE_BIT 0x0002 写入数据到返回指针内存

glUnmapBuffer用于完成缓冲区数据的更新(会刷新整个缓冲区）和释放映射指针：

glUnmapBuffer ( GL_ARRAY_BUFFER ) == GL_FALSE

可以用glFlushMappedBufferRange (GLenum target, GLintptr offset, GLsizeiptr length);来刷新一个子区域，提高性能，前提是创建缓冲区映射时候用#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 标志创建缓冲区映射对象指针。顶点和索引缓冲区都可以使用，例如如下：

#include "esUtil.h"

#include <string.h>

typedef struct

{

// Handle to a program object

GLuint programObject;

// VertexBufferObject Ids

GLuint vboIds[2];

} UserData;

#define VERTEX_POS_SIZE 3 // x, y and z

#define VERTEX_COLOR_SIZE 4 // r, g, b, and a

#define VERTEX_POS_INDX 0

#define VERTEX_COLOR_INDX 1

int Init ( ESContext *esContext )

{

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"

"out vec4 v_color; \n"

"void main() \n"

"{ \n"

" v_color = a_color; \n"

" gl_Position = a_position; \n"

"}";

const char fShaderStr[] =

"#version 300 es \n"

"precision mediump float; \n"

"in vec4 v_color; \n"

"out vec4 o_fragColor; \n"

"void main() \n"

"{ \n"

" o_fragColor = v_color; \n"

"}" ;

GLuint programObject;

// Create the program object

programObject = esLoadProgram ( vShaderStr, fShaderStr );

if ( programObject == 0 )

{

return GL_FALSE;

}

// Store the program object

userData->programObject = programObject;

userData->vboIds[0] = 0;

userData->vboIds[1] = 0;

glClearColor ( 1.0f, 1.0f, 1.0f, 0.0f );

return GL_TRUE;

}

void DrawPrimitiveWithVBOsMapBuffers ( ESContext *esContext,

GLint numVertices, GLfloat *vtxBuf,

GLint vtxStride, GLint numIndices,

GLushort *indices )

{

UserData *userData = esContext->userData;

GLuint offset = 0;

// vboIds[0] - used to store vertex attribute data

// vboIds[l] - used to store element indices

if ( userData->vboIds[0] == 0 && userData->vboIds[1] == 0 )

{

GLfloat *vtxMappedBuf;

GLushort *idxMappedBuf;

// Only allocate on the first draw

glGenBuffers ( 2, userData->vboIds );

glBindBuffer ( GL_ARRAY_BUFFER, userData->vboIds[0] );

glBufferData ( GL_ARRAY_BUFFER, vtxStride * numVertices,

NULL, GL_STATIC_DRAW );

vtxMappedBuf = ( GLfloat * )

glMapBufferRange ( GL_ARRAY_BUFFER, 0, vtxStride * numVertices,

GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT );

if ( vtxMappedBuf == NULL )

{

esLogMessage ( "Error mapping vertex buffer object." );

return;

}

// Copy the data into the mapped buffer

memcpy ( vtxMappedBuf, vtxBuf, vtxStride * numVertices );

// Unmap the buffer

if ( glUnmapBuffer ( GL_ARRAY_BUFFER ) == GL_FALSE )

{

esLogMessage ( "Error unmapping array buffer object." );

return;

}

// Map the index buffer

glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER, userData->vboIds[1] );

glBufferData ( GL_ELEMENT_ARRAY_BUFFER,

sizeof ( GLushort ) * numIndices,

NULL, GL_STATIC_DRAW );

idxMappedBuf = ( GLushort * )

glMapBufferRange ( GL_ELEMENT_ARRAY_BUFFER, 0, sizeof ( GLushort ) * numIndices,

GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT );

if ( idxMappedBuf == NULL )

{

esLogMessage ( "Error mapping element array buffer object." );

return;

}

// Copy the data into the mapped buffer

memcpy ( idxMappedBuf, indices, sizeof ( GLushort ) * numIndices );

// Unmap the buffer

if ( glUnmapBuffer ( GL_ELEMENT_ARRAY_BUFFER ) == GL_FALSE )

{

esLogMessage ( "Error unmapping element array buffer object." );

return;

}

}

glBindBuffer ( GL_ARRAY_BUFFER, userData->vboIds[0] );

glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER, userData->vboIds[1] );

glEnableVertexAttribArray ( VERTEX_POS_INDX );

glEnableVertexAttribArray ( VERTEX_COLOR_INDX );

glVertexAttribPointer ( VERTEX_POS_INDX, VERTEX_POS_SIZE,

GL_FLOAT, GL_FALSE, vtxStride,

( const void * ) offset );

offset += VERTEX_POS_SIZE * sizeof ( GLfloat );

glVertexAttribPointer ( VERTEX_COLOR_INDX,

VERTEX_COLOR_SIZE,

GL_FLOAT, GL_FALSE, vtxStride,

( const void * ) offset );

glDrawElements ( GL_TRIANGLES, numIndices, GL_UNSIGNED_SHORT,

0 );

glDisableVertexAttribArray ( VERTEX_POS_INDX );

glDisableVertexAttribArray ( VERTEX_COLOR_INDX );

glBindBuffer ( GL_ARRAY_BUFFER, 0 );

glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER, 0 );

}

void Draw ( ESContext *esContext )

{

UserData *userData = esContext->userData;

// 3 vertices, with (x,y,z) ,(r, g, b, a) per-vertex

GLfloat vertices[3 * ( VERTEX_POS_SIZE + VERTEX_COLOR_SIZE )] =

{

0.0f, 0.5f, 0.0f, // v0

1.0f, 0.0f, 0.0f, 1.0f, // c0

-0.5f, -0.5f, 0.0f, // v1

0.0f, 1.0f, 0.0f, 1.0f, // c1

0.5f, -0.5f, 0.0f, // v2

0.0f, 0.0f, 1.0f, 1.0f, // c2

};

// Index buffer data

GLushort indices[3] = { 0, 1, 2 };

glViewport ( 0, 0, esContext->width, esContext->height );

glClear ( GL_COLOR_BUFFER_BIT );

glUseProgram ( userData->programObject );

DrawPrimitiveWithVBOsMapBuffers ( esContext, 3, vertices,

sizeof ( GLfloat ) * ( VERTEX_POS_SIZE + VERTEX_COLOR_SIZE ),

3, indices );

}

void Shutdown ( ESContext *esContext )

{

UserData *userData = esContext->userData;

glDeleteProgram ( userData->programObject );

glDeleteBuffers ( 2, userData->vboIds );

}

int esMain ( ESContext *esContext )

{

esContext->userData = malloc ( sizeof ( UserData ) );

esCreateWindow ( esContext, "MapBuffers", 320, 240, ES_WINDOW_RGB );

if ( !Init ( esContext ) )

{

return GL_FALSE;

}

esRegisterShutdownFunc ( esContext, Shutdown );

esRegisterDrawFunc ( esContext, Draw );

return GL_TRUE;

}

7)缓冲区间数据的复制

除了CPU传递更新数据到GPU渲染缓冲区，也可以复制GPU中的数据重复利用，可以使用：

glCopyBufferSubData (GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)实现，readTarget和writeTarget是以下标志，具体是哪个缓冲区实例是最近绑定的一个：

GL_ARRAY_BUFFER

GL_ELEMENT_ARRAY_BUFFER

GL_COPY_READ_BUFFER

GL_COPY_WRITE_BUFFER

GL_PIXEL_PACK_BUFFER

GL_PIXEL_UNPACK_BUFFER

GL_TRANSFORM_FEEDBACK_BUFFER

GL_UNIFORM_BUFFER

上面的任何缓冲区数据都可以不改变格式复制到GL_COPY_READ_BUFFER和GL_COPY_WRITE_BUFFER中，这两个类型的缓冲区也可以有很多个实例，具体哪个就是最近绑定的。

二、通过uniform，程序传递到Shader中，Shader中只读的数据(顶点和片段均可访问)

Shader一些频繁变换的变量，或者纹理光照材质信息的传入，一般都是通过uniform变量或块。

1)默认的统一变量类型，不可以程序对象间共享

统一变量被存储在GPU硬件中，这个区域被称作“常量存储区”，所以数量有限制，OES3.0中顶点是256个向量，片段是224个向量。

Shader全局变量用uniform关键字修饰，uniform只能在app中修改，vertex和fragment shader只可以使用，GLSL1.3和1.4都一样 ， 如果uniform变量在vertex和fragment两者之间声明方式完全一样，则它可以在vertex和fragment共享使用，uniform变量一般用来表示：变换矩阵，材质光照参数和颜色等信息 。

查询当前活动的uniform变量： glGetProgramiv (programObject, GL_ACTIVE_UNIFORMS, &numUniforms); glGetActiveUniform (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);

获取unitform变量： glGetUniformLocation (programId, "offset");

设置app中设置的值： glUniform2f (offsetLocationId, fXOffset, fYOffset);这里不使用programId是因为在glUseProgram下工作，前面已经指定了当前的活动program指针对象。

2)统一变量块，由统一变量缓冲区对象支持，程序间可共享

所有类型，除了采样器，都允许放到一个uniform块中。此外，uniform块必须声明为全局作用域 。

Uniform块支持更多的顶点和片段数量，在统一缓冲区对象间切换，比单独加载一个个Uniform变量更加高效。

uniform块的布局限定符

shared 指定uniform块在多个程序对象之间共享(默认的共享设置）。

packed 布局uniform块使得使用的内存最小化，通常不允许跨程序共享。

std140 使用opengl规范中默认的布局。

row_major 使得uniform块中的矩阵按照行主序的方式存储。

column_major 指定矩阵应该按照列主序的方式存储(这是默认的排序)。

(1)uniform块的布局应用：

layout(shared, row_major) uniform uniformBlockName {...}; // 只是声明该uniform块的布局

(2)影响所有后续的uniform布局可以使用：

layout(shared, row_major) uniform；该行之后声明的所有uniform都会使用该布局，直到修改或覆盖uniform声明位置。

(3)layout也 可以在内部成员重载外部uniform块的布局例如：

layout(std140) uniform TransformBlock

{

mat4 matViewProj;

layout(row_major) mat3 matNormal;

mat3 matTexGen;

}

shader内部访问uniform块变量：

访问uniform块中的变量，uniform块的uniform符号并不作为变量作用域，所以两个相同的Uniform块中声明相同的uniform变量将会导致错误， 故Shader内部访问uniform变量的时候没有必要使用uniform块的名字 。

程序app访问Shader中的uniform块变量：

uniform块，通过块标识和查询到成员的，indice, offset, type, size信息，并进行memcpy赋值操作。

1） glGetUniformBlockIndex 获取uniform块索引号。

2)用 glGetActiveUniformBlockiv ()使用GL_UNIFORM_BLOCK_DATA_SIZE返回编译生成的uniform block 大小。

3)用malloc申请内存块，获取uniform块中的各个成员类型和大小，程序中的值填写malloc内存块

glGetUniformIndices (GLuint program,

GLsizei uniformCount, // 输入的个数

const GLchar **uniformNames, // 输入的名字

GLuint *uniformIndices); // 输出的索引号

获取这个特定的索引的offset，size，type（或者每个成员的该值调用一次)：

glGetActiveUniformsiv — Returns information about several active uniform variables for the specified program object

void glGetActiveUniformsiv( GLuint program,

GLsizei uniformCount,

const GLuint *uniformIndices,

GLenum pname,

GLint *params);

4) 使用glGenBuffers/glBindBuffer/glBufferData填充到缓冲区

5）调用glBindBufferRange/glBindBufferBase将unform块和帧缓冲区对象联系起来

6）如果有多个着色器程序共享一个uniform块，为了避免它为每个程序分配一个不同的块索引，在调用glLinkProgram之前要调用 glUniformBlockBinding ()来绑定块。

实例：

"uniform MyUniforms = {

vec3 translation; // 平移

float scale; // 缩放

vec4 rotation; //四元数

bool enabled;

}

// 顶点或片段着色器中直接应用translation即可，不需要MyUniforms限制。

"

uboIndex = glGetUniformBlockIndex (program, "Uniforms");

glGetActiveUniformBlockiv (program, uboIndex, GL_UNIFORM_BLOCK_DATA_SIZE, &uboSize);

GLvoid *buffer = malloc(uboSize);

const char *names[NumUniformMembers] = {

"translation",

"scale",

"rotation",

"enabled",

};

enum {

Translation,

Scale,

Rotation,

Enabled,

NumUniformMembers

}

// 得到每个成员的indices,size,offset, type;用于填充CPU中的memory buffer数据，然后用 glBufferData传输 到GPU VBO中。

GLuint indices[NumUniformMembers];

GLuint size[NumUniformMembers];

GLuint offset[NumUniformMembers];

GLuint type[NumUniformMembers];

glGetUniformIndices (program, NumUniformMembers, names, indices);

glGetActiveUniformsiv (program, NumUniformMembers, indices, GL_UNIFORM_OFFSET, offset);

glGetActiveUniformsiv(program, NumUniformMembers, indices, GL_UNIFORM_SIZE, offset);

glGetActiveUniformsiv(program, NumUniformMembers, indices, GL_UNIFORM_TYPE, offset);

使用memcpy将CPU应用程序中的具体变量值通过size,type字节数赋值给buffer中。

void *memcpy(void *dest, const void *src, size_t n);

memcpy(buffer + offset[Scale], &scale, size[Scale] * TypeSize(type[Scale]));

memcpy(buffer + offset[Translation], &scale, size[Translation] * TypeSize(type[Translation]));

memcpy(buffer+ offset[Rotation], &scale, size[Rotation] * TypeSize(type[Rotation]));

memcpy(buffer+ offset[Enabled], &scale, size[Enabled] * TypeSize(type[Enabled]));

填充满buffer后。

glGenBuffers(1,&ubo);

glBindBuffer(GL_UNIFORM_BUFFER, ubo);

glBufferData(GL_UNIFORM_BUFFER, uboSize, buffer, GL_STATIC_RAW);

glBindBufferBase(GL_UNIFORM_BUFFER, uboIndex, ubo);

三、如何设置顶点，纹理以外的数据到Shader中

例如光源信息（类型，位置，光照颜色，镜面反色顶点光泽度，衰减属性），雾信息(颜色，衰减距离，衰减模型)，阴影需要的深度纹理或投影计算信息。除了计算出来的以外，光源和雾的信息CPU如何设置到Shader中？

答案：用Uniform变量传输，HLSL中也是通过常量表来传输，包括投影矩阵；光照的开启，雾开启关闭等OGL渲染状态信息直接写在CG/HLSL/GLSL中即可；阴影数据也是类似的uniform传输变量，主要是对顶点数据进行投影运算或用深度纹理处理，CG中有实现阴影算法直接在shader中开启。

例如：

光照的类型通过位置是否为w==0来判断是否为平行光，光源的diffuseColor, specularColor, ambientColor都通过颜色传递到Shader中，衰减系数，镜面反色光泽度都是通过常量表设置到Shader中的。

例如DX中：

ToonWorldViewHandle     = ToonConstTable->GetConstantByName(0, "WorldViewMatrix");
ToonWorldViewProjHandle = ToonConstTable->GetConstantByName(0, "WorldViewProjMatrix");
ToonColorHandle         = ToonConstTable->GetConstantByName(0, "Color");
ToonLightDirHandle      = ToonConstTable->GetConstantByName(0, "LightDirection");
OutlineWorldViewHandle = OutlineConstTable->GetConstantByName(0, "WorldViewMatrix");
OutlineProjHandle      = OutlineConstTable->GetConstantByName(0, "ProjMatrix");
//
// Set shader constants:
//
// Light direction:
D3DXVECTOR4 directionToLight(-0.57f, 0.57f, -0.57f, 0.0f);
ToonConstTable->SetVector(
Device, 
ToonLightDirHandle,
&directionToLight);

固定管线中雾设置：

glEnable(GL_FOG);
   {
      GLfloat fogColor[4] = {0.5, 0.5, 0.5, 1.0};


      fogMode = GL_EXP;
      glFogi (GL_FOG_MODE, fogMode);
      glFogfv (GL_FOG_COLOR, fogColor);
      glFogf (GL_FOG_DENSITY, 0.35);
      glHint (GL_FOG_HINT, GL_DONT_CARE);
      glFogf (GL_FOG_START, 1.0);
      glFogf (GL_FOG_END, 5.0);
   }

Shader中雾的设置，绘制物体时候进行该设置即可，直到覆盖定义为止：

FogVertexMode = LINEAR; // linear fog function
        FogStart      = 50.0f;  // fog starts 50 units away from viewpoint
        FogEnd        = 300.0f; // fog ends 300 units away from viewpoint

        FogColor      = 0x00CCCCCC; // gray
        FogEnable     = true;       // enable