GLES3.0中文API-glGetActiveUniform详解

前言

         glGetActiveUniform()函数看了官方的解释，也看了别人的一些帖子，但是基本上都没有实际的代码，没有实操总觉得隔了一层，雾里看花理解不了。下面亲自写段代码验证下这个函数。

官方文档

Name

glGetActiveUniform — Returns information about an active uniform variable for the specified program object

C Specification

Parameters

​​program​​

Specifies the program object to be queried.

​​index​​

Specifies the index of the uniform variable to be queried.

​​bufSize​​

Specifies the maximum number of characters OpenGL is allowed to write in the character buffer indicated by ​​name​​.

​​length​​

Returns the number of characters actually written by OpenGL in the string indicated by ​​name​​​ (excluding the null terminator) if a value other than ​​NULL​​ is passed.

​​size​​

Returns the size of the uniform variable.

​​type​​

Returns the data type of the uniform variable.

​​name​​

Returns a null terminated string containing the name of the uniform variable.

Description

​​glGetActiveUniform​​​ returns information about an active uniform variable in the program object specified by ​​program​​​. The number of active uniform variables can be obtained by calling ​​glGetProgramiv​​​ with the value ​​GL_ACTIVE_UNIFORMS​​​. A value of zero for ​​index​​​ selects the first active uniform variable. Permissible values for ​​index​​

Shaders may use either built-in uniform variables, user-defined uniform variables, or both. Built-in uniform variables have a prefix of "gl_" and reference existing OpenGL state or values derived from such state (e.g., ​​gl_DepthRange​​​, see the OpenGL Shading Language specification for a complete list.) User-defined uniform variables have arbitrary names and obtain their values from the application through calls to ​​glUniform​​​. A uniform variable (either built-in or user-defined) is considered active if it is determined during the link operation that it may be accessed during program execution. Therefore, ​​program​​​ should have previously been the target of a call to ​​glLinkProgram​​, but it is not necessary for it to have been linked successfully.

The size of the character buffer required to store the longest uniform variable name in ​​program​​​ can be obtained by calling ​​glGetProgramiv​​​ with the value ​​GL_ACTIVE_UNIFORM_MAX_LENGTH​​​. This value should be used to allocate a buffer of sufficient size to store the returned uniform variable name. The size of this character buffer is passed in ​​bufSize​​​, and a pointer to this character buffer is passed in ​​name.​​

​​glGetActiveUniform​​​ returns the name of the uniform variable indicated by ​​index​​​, storing it in the character buffer specified by ​​name​​​. The string returned will be null terminated. The actual number of characters written into this buffer is returned in ​​length​​​, and this count does not include the null termination character. If the length of the returned string is not required, a value of ​​NULL​​​ can be passed in the ​​length​​

The ​​type​​

If one or more elements of an array are active, the name of the array is returned in ​​name​​​, the type is returned in ​​type​​​, and the ​​size​​​ parameter returns the highest array element index used, plus one, as determined by the compiler and/or linker. Only one active uniform variable will be reported for a uniform array. If the active uniform is an array, the uniform name returned in ​​name​​

Uniform variables that are declared as structures or arrays of structures will not be returned directly by this function. Instead, each of these uniform variables will be reduced to its fundamental components containing the "." and "[]" operators such that each of the names is valid as an argument to ​​glGetUniformLocation​​. Each of these reduced uniform variables is counted as one active uniform variable and is assigned an index. A valid name cannot be a structure, an array of structures, or a subcomponent of a vector or matrix.

The size of the uniform variable will be returned in ​​size​​. Uniform variables other than arrays will have a size of 1. Structures and arrays of structures will be reduced as described earlier, such that each of the names returned will be a data type in the earlier list. If this reduction results in an array, the size returned will be as described for uniform arrays; otherwise, the size returned will be 1.

The list of active uniform variables may include both built-in uniform variables (which begin with the prefix "gl_") as well as user-defined uniform variable names.

This function will return as much information as it can about the specified active uniform variable. If no information is available, ​​length​​​ will be 0, and ​​name​​​ will be an empty string. This situation could occur if this function is called after a link operation that failed. If an error occurs, the return values ​​length​​​, ​​size​​​, ​​type​​​, and ​​name​​

Errors

​​GL_INVALID_VALUE​​​ is generated if ​​program​​

​​GL_INVALID_OPERATION​​​ is generated if ​​program​​

​​GL_INVALID_VALUE​​​ is generated if ​​index​​​ is greater than or equal to the number of active uniform variables in ​​program​​.

​​GL_INVALID_VALUE​​​ is generated if ​​bufSize​​

Associated Gets

​​glGet​​​ with argument ​​GL_MAX_VERTEX_UNIFORM_COMPONENTS​​​, ​​GL_MAX_FRAGMENT_UNIFORM_COMPONENTS​​​, ​​GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS​​​, or ​​GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS​​.

​​glGetProgramiv​​​ with argument ​​GL_ACTIVE_UNIFORMS​​​ or ​​GL_ACTIVE_UNIFORM_MAX_LENGTH​​.

​​glIsProgram​​

API Version Support

See Also

​​glGetUniform​​​, ​​glGetUniformLocation​​​, ​​glLinkProgram​​​, ​​glUniform​​​, ​​glUseProgram​​

Copyright

Copyright © 2003-2005 3Dlabs Inc. Ltd. Copyright © 2010-2015 Khronos Group This material may be distributed subject to the terms and conditions set forth in the Open Publication License, v 1.0, 8 June 1999. ​​http://opencontent.org/openpub/​​.

中文翻译

    这里感谢

​​flycatdeng​​

​​flycatdeng的翻译​​

名称

glGetActiveUniform - 返回有关活动统一变量的信息

C规范

void glGetActiveUniform（GLuint program,

                                                 GLuint index,

                                                 GLsizei bufSize,

                                                 GLsizei *length,

                                                 GLint *size,

                                                 GLenum *type,

                                                 GLchar *name）;

参数

program

指定要查询的程序对象。

index

指定要查询的统一变量的索引。

bufSize

指定允许OpenGL在由name指示的字符缓冲区中写入的最大字符数。

length

如果传递NULL以外的值，则返回由name指示的字符串中的OpenGL实际写入的字符数（不包括空终止符）。

size

返回统一变量的大小。

type

返回统一变量的数据类型。

name

返回包含统一变量名称的以null结尾的字符串。

描述

glGetActiveUniform返回有关程序指定的程序对象中的活动统一变量的信息。可以通过使用值GL_ACTIVE_UNIFORMS调用​​glGetProgramiv​​来获得活动的统一变量的数量。索引的值为0的是选择第一个活动的统一变量。索引的允许值范围从0到活动统一变量的数量减1。

着色器可以使用内置的统一变量，用户定义的统一变量或两者。内置的统一变量具有前缀“gl_”并且引用现有的OpenGL状态或从这种状态导出的值（例如，gl_DepthRange）。用户定义的统一变量具有任意名称，并通过调用​​glUniform​​从应用程序获取它们的值。如果在链接操作期间确定可以在程序执行期间访问它，则统一变量（内置或用户定义）被认为是活动的。因此，程序之前应该是调用​​glLinkProgram​​的目标，但它没有必要成功链接。

在程序中存储最长的统一变量名所需的字符缓冲区的大小可以通过调用值为GL_ACTIVE_UNIFORM_MAX_LENGTH的​​glGetProgramiv​​来获得。此值应用于分配足够大小的缓冲区来存储返回的统一变量名称。该字符缓冲区的大小在bufSize中传递，并且在该名称中传递指向该字符缓冲区的指针。

glGetActiveUniform返回由index指示的统一变量的名称，将其存储在name指定的字符缓冲区中。返回的字符串将以null结尾。写入此缓冲区的实际字符数以长度形式返回，并且此计数不包括空终止字符。如果不需要返回字符串的长度，则可以在length参数中传递NULL值。

type参数将返回指向统一变量数据类型的指针。可以返回符号常数GL_FLOAT，GL_FLOAT_VEC2，GL_FLOAT_VEC3，GL_FLOAT_VEC4，GL_INT_GLEC_VEC2，GL_INT_VEC3，GL_INT_VEC4，GL_BOOL，GL_BOOL_VEC2，GL_BOOL_VEC3，GL_BOOL_VEC4，GL_FLOAT_MAT2，GL_FLOAT_MAT3，GL_FLOAT_MAT4，GL_SAMPLER_2D或GL_SAMPLER_CUBE。

如果数组的一个或多个元素处于活动状态，则在name中返回数组的名称，类型以type返回，并且size参数返回使用的最高数组元素索引加上1，具体由编译器确定和/或链接器。对于统一阵列，仅报告一个活动的统一变量。

声明为结构或结构数组的统一变量不会由此函数直接返回。相反，这些统一变量中的每一个都将被简化为包含“.”和“[]”运算符的基本组成部分，使得每个名称作为​​glGetUniformLocation​​的参数有效。

统一变量的大小将以size返回。除数组之外的统一变量将具有1的维度大小。结构和结构数组将如前所述减少，使得返回的每个名称将是先前列表中的数据类型。

活动统一变量列表可以包括内置的统一变量（以前缀“gl_”开头）以及用户定义的统一变量名称。

此函数将返回尽可能多的有关指定的活动统一变量的信息。如果没有可用信息，则length为0，name为空字符串（如果在失败的链接操作后调用此函数，则可能发生这种情况）。如果发生错误，则返回值length，size，type和name将不会被修改。

错误

GL_INVALID_VALUE：program不是OpenGL生成的值。

GL_INVALID_OPERATION：program不是程序对象。

GL_INVALID_VALUE：index>=程序中活动统一变量的数量。

GL_INVALID_VALUE：bufSize<0

相关Gets

​​glGet​​ 参数GL_MAX_VERTEX_UNIFORM_VECTORS或GL_MAX_FRAGMENT_UNIFORM_VECTORS

​​glGetProgramiv​​ 参数GL_ACTIVE_UNIFORMS或GL_ACTIVE_UNIFORM_MAX_LENGTH

​​glIsProgram​​

另见

​​glGetActiveAttrib​​，​​glGetUniform​​，​​glGetUniformLocation​​，​​glLinkProgram​​，​​glUniform​​，​​glUseProgram​​

版权

​​https://www.khronos.org/registry/OpenGL-Refpages/es2.0/xhtml/glGetActiveUniform.xml​​

​​javascript:void(0)​​

Copyright © 1991-2006 Silicon Graphics, Inc.本文档的许可是根据SGI Free Software B License.详见​​http://oss.sgi.com/projects/FreeB/​​.

代码

//
//    Demonstrates drawing multiple objects in a single draw call with
//    geometry instancing
//

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

//随机种子
#ifdef _WIN32
#define srandom srand
#define random  rand
#endif

//函数功能：找到uniform统一变量的位置
//glGetUniformLocation()

//函数功能：加载uniform统一变量值
//glUniform1f()
//glUniformMatrix4fv()





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

typedef struct
{
  // Handle to a program object
  GLuint programObject;

  // VBOs
  GLuint positionVBO;
  GLuint colorVBO;
  GLuint mvpVBO;
  GLuint indicesIBO;

  // Number of indices
  int    numIndices;

  // Rotation angle
  GLfloat angle[NUM_INSTANCES];
}UserData;


void test(ESContext* esContext)
{
  UserData* userData = esContext->userData;
  GLint maxUniformLen;
  GLint numUniforms;
  char* uniformName;
  GLint index;
  glGetProgramiv(userData->programObject, GL_ACTIVE_UNIFORMS, &numUniforms);
  glGetProgramiv(userData->programObject, GL_ACTIVE_UNIFORM_MAX_LENGTH,
    &maxUniformLen);
  uniformName = malloc(sizeof(char) * maxUniformLen);
  for (index = 0; index < numUniforms; index++)
  {
    GLint size;
    GLenum type;
    GLint location;
    // Get the uniform info
    glGetActiveUniform(userData->programObject, index, maxUniformLen, NULL,
      &size, &type, uniformName);
    // Get the uniform location
    location = glGetUniformLocation(userData->programObject, uniformName);
    switch (type)
    {
    case GL_FLOAT:
      //
      break;
    case GL_FLOAT_VEC2:
      //
      break;
    case GL_FLOAT_VEC3:
      //
      break;
    case GL_FLOAT_VEC4:
      //
      break;
    case GL_INT:
      //
      break;
      // ... Check for all the types ...
    default:
      // Unknown type

      break;
    }
  }
}


// 打印日志信息
void PrintLogMessage(ESContext* esContext, const char* msg)
{
  UserData* userData = esContext->userData;
  //GLint infoLen = GL_INFO_LOG_LENGTH;
  GLint infoLen = 512;
  char* infoLog = malloc(sizeof(char) * 512);
  glGetProgramInfoLog(userData->programObject, infoLen, &infoLen, infoLog);
  GLint headLen = strlen("Invoke ");
  strcpy_s(infoLog, headLen + 3, "Invoke ");  //这里长度必须+1，要覆盖'\0',否则越界，vs2019边界检查更严格
  /********* (1）src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
  /*********（2）strcat返回值有什么作用？ 链式传递：strcat(a, strcat(b, c));
  /********* 最重要的是，strcat函数不检查这些。*********/
  //strcat(infoLog, "Invoke ");
                        //strcat_s(infoLog, msg, strlen(msg)+1);
  int strMsgSize = strlen(msg);
  int strInfoSize = strlen(infoLog);
  //注意！！！strcat_s()第二个参数的大小是 src+des+1总和大小，+1是'\0'的大小
  int retStatue = strcat_s(infoLog, strMsgSize + strInfoSize + 1, msg);
  esLogMessage(" failed:Error message:%s\n", infoLog);

  free(infoLog);
}

///
// Initialize the shader and program object
//
int Init(ESContext* esContext)
{
  GLfloat* positions = NULL;
  GLuint* indices = NULL;

  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_mvpMatrix;   \n"
    "out vec4 v_color;                           \n"
    "void main()                                 \n"
    "{                                           \n"
    "   v_color = a_color;                       \n"
    "   gl_Position = a_mvpMatrix * a_position;  \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"
    "  outColor = v_color;                          \n"
    "}                                              \n";

  // Load the shaders and get a linked program object
  userData->programObject = esLoadProgram(vShaderStr, fShaderStr);

  // Generate the vertex data
  //这里暂时没有用到法线和纹理坐标这2个参数：所以第一个normal是NULL,第二个texCoords是NULL
  userData->numIndices = esGenCube(0.1f, &positions, NULL, NULL, &indices);

  // Index buffer object
  glGenBuffers(1, &userData->indicesIBO);
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, userData->indicesIBO);

  //glGetActiveUniform(userData->programObject, 0, NULL, NULL, )
    /****** 功能：更新/修改uniform统一变量缓冲区中的统一变量数据
    * **************/
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * userData->numIndices,
      indices, GL_STATIC_DRAW);
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
  //这里为什么要释放局部指针变量，函数调用完成会释放2次？
  free(indices);

  // Position VBO for cube model
  glGenBuffers(1, &userData->positionVBO);
  glBindBuffer(GL_ARRAY_BUFFER, userData->positionVBO);
  //立方体是6个面，每个面4个顶点，所以是6*4=24，为什么还要*3 ？？？？
  glBufferData(GL_ARRAY_BUFFER, 24 * sizeof(GLfloat) * 3, positions, GL_STATIC_DRAW);
  //这里没有恢复到默认绑定状态
  //glBindBuffer(GL_ARRAY_BUFFER, 0);
  free(positions);

  // Random color for each instance
  {
    GLubyte colors[NUM_INSTANCES][4];
    int instance;

    srandom(0);

    for (instance = 0; instance < NUM_INSTANCES; instance++)
    {
      colors[instance][0] = random() % 255;
      //colors[NUM_INSTANCES][0] = random() % 255;

      colors[instance][1] = random() % 255;
      //colors[NUM_INSTANCES][1] = random() % 255;

      colors[instance][2] = random() % 255;
      //colors[NUM_INSTANCES][2] = random() % 255;

      //最后一个alpha值
      colors[instance][3] = 0;
      //colors[instance][3] = 0;
      //colors[NUM_INSTANCES][3] = random() % 255;
    }

    glGenBuffers(1, &userData->colorVBO);
    glBindBuffer(GL_ARRAY_BUFFER, userData->colorVBO);
    //glBufferData(GL_ARRAY_BUFFER, sizeof(GLubyte) * NUM_INSTANCES * 4, colors, GL_STATIC_DRAW);
    GLint gluByteSize = sizeof(GLubyte);
    glBufferData(GL_ARRAY_BUFFER, sizeof(GLubyte) * NUM_INSTANCES * 4, colors, GL_STATIC_DRAW);
  }

  // Allocate storage to store MVP per instance
  {
    int instance;

    // Random angle for each instance, compute the MVP later
    for (instance = 0; instance < NUM_INSTANCES; instance++)
    {
      userData->angle[instance] = (float)(random() % 32768) / 32767.0f * 360;
    }

    glGenBuffers(1, &userData->mvpVBO);
    glBindBuffer(GL_ARRAY_BUFFER, userData->mvpVBO);
    //这里参数为什么是NULL:为实例化存储数据到存储区的指针，如果为NULL，说明不需要拷贝数据
    glBufferData(GL_ARRAY_BUFFER, sizeof(ESMatrix) * NUM_INSTANCES, NULL, GL_DYNAMIC_DRAW);
  }

  //恢复到默认绑定状态
  glBindBuffer(GL_ARRAY_BUFFER, 0);

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

  return GL_TRUE;
}

///
// Update MVP matrix based on time
//
void Updata(ESContext* esContext, float deltaTime)
{
  UserData* userData = esContext->userData;
  ESMatrix* matrixBuf;
  ESMatrix  perspective;
  float     aspect;
  int     instance = 0;
  int     numRows = 0;
  int     numColumns = 0;

  // Compute the window aspect ratio
  aspect = (GLfloat)esContext->width / (float)esContext->height;

  // Generate a perspective matrix with a 60 degree FOV
  //esMatrixLoadIdentity(matrixBuf);
  esMatrixLoadIdentity(&perspective);
  esPerspective(&perspective, 45.0f, aspect, 1.0f, 20.0f);

  glBindBuffer(GL_ARRAY_BUFFER, userData->mvpVBO);
  /****** 功能：将缓冲区对象数据存储映射到应用程序的地址空间，这个指针供应用程序使用，
  /****** 以读取和更新缓冲区对象的内容。他可以代替**************/
  /****** glBufferData或者glBufferSubData函数，以减少程序内存占用     ********/
  /****** 返回值：返回请求的缓冲区数据存储范围的指针    ********/
  /****** GL_MAP_READ_BIT:表示返回的指针可用于读取缓冲区对象数据。
  *       如果指针用于查询排除此标志的映射，则不会产生GL错误，
  *       但结果是未定义的，并且可能发生系统错误(可能包括程序终止)。
  /****** GL_MAP_WRITE_BIT:表示返回的指针可用于修改缓冲区对象数据。
  /*      如果指针用于修改一个排除此标志的映射，则不会产生GL错误，
  /*      但结果是未定义的，并且可能发生系统错误(可能包括程序终止)。
  * ********/
  matrixBuf = glMapBufferRange(GL_ARRAY_BUFFER, 0,
    sizeof(ESMatrix) * NUM_INSTANCES,
    GL_MAP_WRITE_BIT);

  // Compute a per-instance MVP that translates and rotates each instance differently
  numRows = (int)sqrtf(NUM_INSTANCES);
  numColumns = 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 / numColumns) / (float)(numColumns)) * 2.0f - 1.0f;

    // Generate a model view matrix to rotate/translate the cube
    esMatrixLoadIdentity(&modelView);

    // Per-instance translation
    esTranslate(&modelView, translateX, translateY, -2.0f);

    // Compute a rotation angle based on time to rotate the cube
    userData->angle[instance] += (deltaTime * 40.0f);

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

    // Rotate the cube
    esRotate(&modelView, userData->angle[instance], 1.0f, 0.0f, 1.0f);

    // Compute the final MVP by multiplying the
    // modeler's and perspective matrices together
    //matrixBuf[instance]:乘积，modelView：被乘数，perspective：乘数
    esMatrixMultiply(&matrixBuf[instance], &modelView, &perspective);
  }

  // 指示更新已经完成和释放映射的指针
  glUnmapBuffer(GL_ARRAY_BUFFER);
}

///
// Draw a triangle using the shader pair created in Init()
//
void Draw(ESContext* esContext)
{
  UserData* userData = esContext->userData;
  GLfloat* indices;

  // Set the viewport
  glViewport(0, 0, esContext->width, esContext->height);

  // Clear the color buffer
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  // Use the program object
  glUseProgram(userData->programObject);

  // Load the vertex position
  glBindBuffer(GL_ARRAY_BUFFER, userData->positionVBO);
  glVertexAttribPointer(POSITION_LOC, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat),
    (GLvoid*)NULL);
  glEnableVertexAttribArray(POSITION_LOC);

  // Load the instance color buffer
  glBindBuffer(GL_ARRAY_BUFFER, userData->colorVBO);
  //为什么不用glBufferData(),因为在Init()初始化时调用过了
  //glBufferData(GL_ARRAY_BUFFER, 4 * sizeof(GLfloat) * NUM_INSTANCES, indices, GL_DYNAMIC_DRAW);
  //把最后一个参数变成(GLvoid*)(3 * sizeof(GLint)颜色更好看
  glVertexAttribPointer(COLOR_LOC, 4, GL_UNSIGNED_BYTE, GL_TRUE,
    4 * sizeof(GLubyte),
    (GLvoid*)(3 * sizeof(GLint)));
  //最后一个参数为什么是NULL
  /*glVertexAttribPointer(COLOR_LOC, 4, GL_UNSIGNED_BYTE, GL_FLOAT, GL_FALSE,
              4 * sizeof(GLubyte), (GLvoid*)(NULL));*/
  glEnableVertexAttribArray(COLOR_LOC);

  /****** 功能：访问每个实例的颜色数据
  /****** 参数:COLOR_LOC:指定顶点颜色属性索引
  /****** 参数:1:指定COLOR_LOC索引位置的通用颜色属性更新之间传递的是实例数量
  *       如果divisor=0：默认情况下，如果没有指定，或者顶点属性的divisor等于0，
  *       对每个顶点将读取一次顶点属性；
  *       如果divisor=1：则每个图元实例颜色属性读取一次顶点属性
  ******/
  glVertexAttribDivisor(COLOR_LOC, 1);

  // Load the instance MVP buffer
  glBindBuffer(GL_ARRAY_BUFFER, userData->mvpVBO);

  // Load each matrix row of the MVP.  Each row gets an increasing attribute location.
  glVertexAttribPointer(MVP_LOC + 0, 4, GL_FLOAT, GL_FALSE,
    sizeof(ESMatrix), (GLvoid*)NULL);
  glVertexAttribPointer(MVP_LOC + 1, 4, GL_FLOAT, GL_FALSE,
    sizeof(ESMatrix), (GLvoid*)(4 * sizeof(GLfloat)));
  glVertexAttribPointer(MVP_LOC + 2, 4, GL_FLOAT, GL_FALSE,
    sizeof(ESMatrix), (GLvoid*)(8 * sizeof(float)));
  glVertexAttribPointer(MVP_LOC + 3, 4, GL_FLOAT, GL_FALSE,
    sizeof(ESMatrix), (GLvoid*)(12 * sizeof(GLfloat)));
  glEnableVertexAttribArray(MVP_LOC + 0);
  glEnableVertexAttribArray(MVP_LOC + 1);
  glEnableVertexAttribArray(MVP_LOC + 2);
  glEnableVertexAttribArray(MVP_LOC + 3);

  /****** 功能：访问每个实例的颜色数据
  /****** 参数:MVP_LOC:指定模型视图投影矩阵（modelViewProjectionMatrix）位置属性索引
  /****** 参数:1:指定MVP_LOC索引位置的通用颜色属性更新之间传递的是实例数量
  *       如果divisor=0：默认情况下，如果没有指定，或者顶点属性的divisor等于0，
  *       对每个顶点将读取一次顶点属性；
  *       如果divisor=1：则每个图元实例颜色属性读取一次顶点属性
  *       One MVP per instance
  ******/
  glVertexAttribDivisor(MVP_LOC + 0, 1);
  glVertexAttribDivisor(MVP_LOC + 1, 1);
  glVertexAttribDivisor(MVP_LOC + 2, 1);
  glVertexAttribDivisor(MVP_LOC + 3, 1);

  // Bind the index buffer  索引缓冲区对象
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, userData->indicesIBO);

  // Draw the cubes
  glDrawElementsInstanced(GL_TRIANGLES, userData->numIndices, GL_UNSIGNED_INT,
    NULL, NUM_INSTANCES);
}

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

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

  // Delete program object
  glDeleteProgram(userData->programObject);
}

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

  GLboolean createWindowStatue = esCreateWindow(esContext, "openGLESExample_7_Instancing", 800, 600, ES_WINDOW_RGB);
  if (GL_FALSE == createWindowStatue)
  {
    PrintLogMessage(esContext, "esCreateWindow");
    return GL_FALSE;
  }

  if (!Init(esContext))
  {
    PrintLogMessage(esContext, "Init");
    return GL_FALSE;
  }

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

  return GL_TRUE;
}

程序运行效果

 稍微修改202行的代码，让透明度也随机

 运行效果如下

​​工程源码下载​​