自学教程：C++ CHECK_GL_ERROR函数代码示例

//applying the light at the "stencil-approved" areasvoid DefRenderer::LightPass(Camera *cam, Renderer *r){	//setting to pass the stencil test when != 0	glStencilFunc(GL_NOTEQUAL, 0, 0xFF);	//writing only on top of the colors from geometry pass	glDrawBuffer(GL_COLOR_ATTACHMENT0);		glDisable(GL_DEPTH_TEST);		//using additive blending to mix the light and scene fragments	glEnable(GL_BLEND);	glBlendFunc(GL_ONE, GL_ONE);	//try to render from the back to preserve depth information	glEnable(GL_CULL_FACE);	glCullFace(GL_FRONT);	r->Ready();	mat4 model = r->GetParentGO()->GetModelMatrix();	mat4 mvp = cam->Get() * model;	r->GetProgram()->SetUniform("Model", value_ptr(model));	r->GetProgram()->SetUniform("MVP", value_ptr(mvp));	vec4 deviceCenter = vec4(mvp * vec4(0, 0, 0, 1)); //center in device coords	vec3 center(deviceCenter.x, deviceCenter.y, deviceCenter.z);	r->GetProgram()->SetUniform("Center", &center);	Light *l = r->GetParentGO()->GetLight();	float intensity = l->GetIntensity();	r->GetProgram()->SetUniform("Intensity", &intensity);	vec4 color = l->GetColor();	r->GetProgram()->SetUniform("Color", &color);	r->Render();	glCullFace(GL_BACK);	glDisable(GL_BLEND);	CHECK_GL_ERROR();}

void Game::LoadResources(){	resourceManager = new ResourceManager();	currentScene = new Scene(resourceManager);	sceneManager = new SceneManager(resourceManager);	DefRenderer::Init();	PostProcessing::Init();	CHECK_GL_ERROR();	//======================== TEXTURES ========================	//HIDE THIS AWAY IN TO SCENE MANAGER LOADER AT SOME POINT!	Texture* skyTexture = new Texture(TEXTURE_PATH + "right.jpg", TEXTURE_PATH + "left.jpg", TEXTURE_PATH + "top.jpg", TEXTURE_PATH + "bottom.jpg", TEXTURE_PATH + "back.jpg", TEXTURE_PATH + "front.jpg");	resourceManager->AddTexture("skyTexture", skyTexture);	Texture* skyNightTexture = new Texture(TEXTURE_PATH + "night_right.jpg", TEXTURE_PATH + "night_left.jpg", TEXTURE_PATH + "night_top.jpg", TEXTURE_PATH + "night_bottom.jpg", TEXTURE_PATH + "night_back.jpg", TEXTURE_PATH + "night_front.jpg");	resourceManager->AddTexture("skyNightTexture", skyNightTexture);	//========================  MODELS  ========================	Model *terrainModel = new Model();	terrainModel->SetUpAttrib(0, 3, GL_FLOAT, 0); //pos	terrainModel->SetUpAttrib(1, 4, GL_FLOAT, sizeof(vec3)); //coeffs	terrainModel->SetUpAttrib(2, 2, GL_FLOAT, sizeof(vec3) + sizeof(vec4)); //uv	terrainModel->SetUpAttrib(3, 3, GL_FLOAT, sizeof(vec3) + sizeof(vec4) + sizeof(vec2)); //normals	resourceManager->AddModel("Terrain", terrainModel);	Model *skyModel = new Model();	vector<Vertex> *verts = new vector<Vertex>(skyBoxverts);	vector<int> *indcs = new vector<int>(skyBoxIndices);	skyModel->SetVertices(verts, GL_STATIC_DRAW, true);	skyModel->SetIndices(indcs, GL_STATIC_DRAW, true);	skyModel->FlushBuffers();	skyModel->SetUpAttrib(0, 3, GL_FLOAT, 0);	resourceManager->AddModel("skyModel", skyModel);	//======================== SCENEMANAGEMENT  ====================	sceneManager->LoadSceneDirectories();	sceneManager->LoadScene(0, currentScene);}

void ComputeBasicGLSL::drawImage(GLuint texture){    float const vertexPosition[] = {        m_aspectRatio, -1.0f,        -m_aspectRatio, -1.0f,        m_aspectRatio, 1.0f,        -m_aspectRatio, 1.0f    };    float const textureCoord[] = {        1.0f, 0.0f,        0.0f, 0.0f,        1.0f, 1.0f,        0.0f, 1.0f    };    glClearColor(0.2f, 0.0f, 0.2f, 1.0f);    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);    glUseProgram(m_blitProg->getProgram());    glActiveTexture(GL_TEXTURE0);    glBindTexture(GL_TEXTURE_2D, texture);    glUniform1i(m_blitProg->getUniformLocation("uSourceTex"), 0);    int aPosCoord = m_blitProg->getAttribLocation("aPosition");    int aTexCoord = m_blitProg->getAttribLocation("aTexCoord");    glVertexAttribPointer(aPosCoord, 2, GL_FLOAT, GL_FALSE, 0, vertexPosition);    glVertexAttribPointer(aTexCoord, 2, GL_FLOAT, GL_FALSE, 0, textureCoord);    glEnableVertexAttribArray(aPosCoord);    glEnableVertexAttribArray(aTexCoord);    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);    CHECK_GL_ERROR();}

    MotionBlurShader(void) :        BaseProjNormalShader("shaders/motionblur.vert",                             "shaders/motionblur.frag"),        viewMatUHandle(-1),        currentModelMatUHandle(-1),        previousModelMatUHandle(-1),        stretchScaleUHandle(-1),        colorTexUHandle(-1)    {        // uniforms        viewMatUHandle =            getUniformLocation("u_mViewMat");        currentModelMatUHandle =            getUniformLocation("u_mCurrentModelMat");        previousModelMatUHandle =            getUniformLocation("u_mPreviousModelMat");        stretchScaleUHandle =            getUniformLocation("u_fStretchScale");        colorTexUHandle =            getUniformLocation("u_tColorTex");        CHECK_GL_ERROR();    }

void CascadedShadowMapping::initRendering(void) {    printGLString("Version", GL_VERSION);    printGLString("Vendor", GL_VENDOR);    printGLString("Renderer", GL_RENDERER);    printGLString("Extensions", GL_EXTENSIONS);    GLint depthBits;    glGetIntegerv(GL_DEPTH_BITS, &depthBits);    LOGI("depth bits = %d/n", depthBits);    if (!requireMinAPIVersion(NvGfxAPIVersionGL4_3()))        return;    if (!requireExtension("GL_NV_viewport_array2"))        return;    if (!requireExtension("GL_NV_geometry_shader_passthrough"))        return;    m_renderer->initRendering();    CHECK_GL_ERROR();}

void Mercury::reshape(int32_t width, int32_t height){    glViewport( 0, 0, (GLint) width, (GLint) height );	// Rescale FBO and RBO as well	glBindTexture(GL_TEXTURE_2D, gbuffer_tex[0]);	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, width, height, 0, GL_RGBA, GL_FLOAT, NULL);	glBindTexture(GL_TEXTURE_2D, 0);	glBindTexture(GL_TEXTURE_2D, gbuffer_tex[1]);	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, width, height, 0, GL_RGBA, GL_FLOAT, NULL);	glBindTexture(GL_TEXTURE_2D, 0);	glBindTexture(GL_TEXTURE_2D, gbuffer_tex[2]);	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, width, height, 0, GL_RGBA, GL_FLOAT, NULL);	glBindTexture(GL_TEXTURE_2D, 0);	glBindRenderbuffer(GL_RENDERBUFFER, rbo_depth);	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height);	glBindRenderbuffer(GL_RENDERBUFFER, 0);	    CHECK_GL_ERROR();}

void OptimizationApp::initRendering(void) {    glClearColor(0.0f, 0.0f, 1.0f, 1.0f);    NvAssetLoaderAddSearchPath("es2-aurora/OptimizationApp");#ifdef GL_OES_texture_3D    if (requireExtension("GL_EXT_framebuffer_blit", false)) {        glBlitFramebufferFunc = (void (KHRONOS_APIENTRY *) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter))                                getGLContext()->getGLProcAddress("glBlitFramebufferEXT");    } else if (getGLContext()->getConfiguration().apiVer != NvGfxAPIVersionES2()) {        glBlitFramebufferFunc = (void (KHRONOS_APIENTRY *) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter))                                getGLContext()->getGLProcAddress("glBlitFramebuffer");    } else {        glBlitFramebufferFunc = NULL;    }#else    glBlitFramebufferFunc = glBlitFramebuffer;#endif    if (getGLContext()->getConfiguration().apiVer == NvGfxAPIVersionES2()) {        gFloatTypeEnum = 0x8D61; // GL_HALF_FLOAT_OES, not declared in GL        gLumaTypeEnum = GL_LUMINANCE;    } else {        gFloatTypeEnum = GL_FLOAT;        gLumaTypeEnum = 0x1903; // GL_RED, not declared in ES    }    m_sceneRenderer = new SceneRenderer(        getGLContext()->getConfiguration().apiVer == NvGfxAPIVersionES2());    CHECK_GL_ERROR();    glEnable(GL_DEPTH_TEST);    glEnable(GL_CULL_FACE);    glCullFace(GL_BACK);    glClearColor(0.0, 0.0, 1.0, 1.0);}

GLuint ParticleSystem::createShaderPipelineProgram(GLuint target, const char* src){    GLuint object;    GLint status;    const GLchar* fullSrc[2] = { m_shaderPrefix, src };    object = glCreateShaderProgramv( target, 2, fullSrc);    {        GLint logLength;        glGetProgramiv(object, GL_INFO_LOG_LENGTH, &logLength);        char *log = new char [logLength];        glGetProgramInfoLog(object, logLength, 0, log);        LOGI("Shader pipeline program not valid:/n%s/n", log);        delete [] log;    }    glBindProgramPipeline(m_programPipeline);    glUseProgramStages(m_programPipeline, GL_COMPUTE_SHADER_BIT, object);    glValidateProgramPipeline(m_programPipeline);    glGetProgramPipelineiv(m_programPipeline, GL_VALIDATE_STATUS, &status);    if (status != GL_TRUE) {        GLint logLength;        glGetProgramPipelineiv(m_programPipeline, GL_INFO_LOG_LENGTH, &logLength);        char *log = new char [logLength];        glGetProgramPipelineInfoLog(m_programPipeline, logLength, 0, log);        LOGI("Shader pipeline not valid:/n%s/n", log);        delete [] log;    }    glBindProgramPipeline(0);    CHECK_GL_ERROR();    return object;}

void GLTexture::allocBuffer(GLuint w, GLuint h) {	_realWidth = w;	_realHeight = h;	if (!_refresh) {		if (npot_supported && _filter == GL_LINEAR) {			// Check if we already allocated a correctly-sized buffer			// This is so we don't need to duplicate the last row/column			if (w == _textureWidth && h == _textureHeight)				return;		} else {			// Check if we already have a large enough buffer			if (w <= _textureWidth && h <= _textureHeight)				return;		}	}	if (npot_supported) {		_textureWidth = w;		_textureHeight = h;	} else {		_textureWidth = nextHigher2(w);		_textureHeight = nextHigher2(h);	}	// Select this OpenGL texture	glBindTexture(GL_TEXTURE_2D, _textureName); CHECK_GL_ERROR();	// Set the texture parameters	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, _filter); CHECK_GL_ERROR();	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, _filter); CHECK_GL_ERROR();	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); CHECK_GL_ERROR();	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); CHECK_GL_ERROR();	// Allocate room for the texture	glTexImage2D(GL_TEXTURE_2D, 0, _internalFormat,	             _textureWidth, _textureHeight, 0, _glFormat, _glType, NULL); CHECK_GL_ERROR();	_refresh = false;}

static void bind_texture(texture_asset* texture) {	Assert(texture->resource_handle != 0);	glBindTexture(GL_TEXTURE_2D, texture->resource_handle);	CHECK_GL_ERROR();	current_texture_asset = texture->handle;}

static uint32 create_texture() {	uint32 id = 0;	glGenTextures(1, &id);	CHECK_GL_ERROR();	return id;}

static void set_uniform_int(int32 location, int32 value) {	glUniform1i(location, value);	CHECK_GL_ERROR();}

static void set_uniform_matrix4(int32 location, const glm::mat4& matrix) {	glUniformMatrix4fv(location, 1, false, glm::value_ptr(matrix));	CHECK_GL_ERROR();}

static void set_vertex_attribute(vertex_attribute index, int components, int stride, void* pointer) {	glVertexAttribPointer((GLuint) index, components, GL_FLOAT, GL_FALSE, stride, pointer);	CHECK_GL_ERROR();	glEnableVertexAttribArray((GLuint) index);	CHECK_GL_ERROR();}

static void draw_vertex_array(gl_vertex_array* vertex_array) {	glDrawElements(vertex_array->mode, vertex_array->index_count, GL_UNSIGNED_INT, vertex_array->index_buffer.memory);	CHECK_GL_ERROR();}

static void create_vertex_array(gl_vertex_array* vertex_array) {	glGenVertexArrays(1, &vertex_array->id);	CHECK_GL_ERROR();	vertex_array->mode = GL_TRIANGLES;	vertex_array->index_buffer.target = GL_ELEMENT_ARRAY_BUFFER;}

static void destroy_vertex_array(gl_vertex_array* vertex_array) {	glDeleteVertexArrays(1, &vertex_array->id);	CHECK_GL_ERROR();}

voidOpenSubdivPtexShader::draw(const MHWRender::MDrawContext &mDrawContext,                           OsdPtexMeshData *data){    MStatus status;    glPushAttrib(GL_POLYGON_BIT|GL_ENABLE_BIT);    // in ptexviewer, cull back face even in wireframe mode (for performance)    glEnable(GL_CULL_FACE);    glCullFace(GL_BACK);    if (_wireframe) {        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);    } else {        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);    }    CHECK_GL_ERROR("draw begin/n");    // If shader source attribute has changed, update effectRegistry    updateRegistry();    GLuint bPosition = data->bindPositionVBO();    GLuint bNormal = data->bindNormalVBO();    OpenSubdiv::OsdGLDrawContext *osdDrawContext = data->getDrawContext();    glBindBuffer(GL_ARRAY_BUFFER, bPosition);    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 3, 0);    glEnableVertexAttribArray(0);    if (not _adaptive) {        glBindBuffer(GL_ARRAY_BUFFER, bNormal);        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 3, 0);        glEnableVertexAttribArray(1);    }    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, osdDrawContext->patchIndexBuffer);    OpenSubdiv::OsdPatchArrayVector const & patches =        osdDrawContext->patchArrays;    for (size_t i = 0; i < patches.size(); ++i) {        OpenSubdiv::OsdPatchArray const & patch = patches[i];        GLint surfaceProgram = bindProgram(mDrawContext, osdDrawContext, patch);        if (patch.desc.type != OpenSubdiv::kNonPatch) {            glPatchParameteri(GL_PATCH_VERTICES, patch.desc.GetPatchSize());            if (osdDrawContext->GetVertexTextureBuffer()) {                glActiveTexture(GL_TEXTURE0);                glBindTexture(GL_TEXTURE_BUFFER,                              osdDrawContext->GetVertexTextureBuffer());                glTexBuffer(GL_TEXTURE_BUFFER, GL_R32F, bPosition);            }            if (osdDrawContext->GetVertexValenceTextureBuffer()) {                glActiveTexture(GL_TEXTURE1);                glBindTexture(GL_TEXTURE_BUFFER,                              osdDrawContext->GetVertexValenceTextureBuffer());            }            if (osdDrawContext->GetQuadOffsetsTextureBuffer()) {                glActiveTexture(GL_TEXTURE2);                glBindTexture(GL_TEXTURE_BUFFER,                              osdDrawContext->GetQuadOffsetsTextureBuffer());            }            if (osdDrawContext->GetPatchParamTextureBuffer()) {                glActiveTexture(GL_TEXTURE3);                glBindTexture(GL_TEXTURE_BUFFER,                              osdDrawContext->GetPatchParamTextureBuffer());            }            glActiveTexture(GL_TEXTURE0);            glDrawElements(GL_PATCHES,                           patch.numIndices, GL_UNSIGNED_INT,                           reinterpret_cast<void *>(patch.firstIndex *                                                    sizeof(unsigned int)));        } else {            GLint nonAdaptiveLevel = glGetUniformLocation(surfaceProgram,                                     "nonAdaptiveLevel");            if (nonAdaptiveLevel != -1) {                glProgramUniform1i(surfaceProgram, nonAdaptiveLevel, _level);            }            glDrawElements(_scheme == OsdPtexMeshData::kLoop ? GL_TRIANGLES : GL_LINES_ADJACENCY,                           patch.numIndices, GL_UNSIGNED_INT,                           reinterpret_cast<void *>(patch.firstIndex *                                                    sizeof(unsigned int)));        }        CHECK_GL_ERROR("post draw/n");    }    glUseProgram(0);    glDisableVertexAttribArray(0);    if (not _adaptive)        glDisableVertexAttribArray(1);    glBindBuffer(GL_ARRAY_BUFFER, 0);    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);//.........这里部分代码省略.........

static void bind_vertex_array(gl_vertex_array* vertex_array) {	glBindVertexArray(vertex_array->id);	CHECK_GL_ERROR();	bind_gl_buffer(&vertex_array->index_buffer);	bind_gl_buffer(&vertex_array->vertex_buffer);}

GLuintOpenSubdivPtexShader::bindProgram(const MHWRender::MDrawContext &     mDrawContext,                                  OpenSubdiv::OsdGLDrawContext *osdDrawContext,                                  const OpenSubdiv::OsdPatchArray &   patch){    CHECK_GL_ERROR("bindProgram begin/n");    // Build shader    Effect effect;    effect.color = _enableColor;    effect.occlusion = _enableOcclusion;    effect.displacement = _enableDisplacement;    effect.normal = _enableNormal;    EffectDesc effectDesc( patch.desc, effect );    EffectDrawRegistry::ConfigType *    config = effectRegistry.GetDrawConfig(effectDesc);    // Install shader    GLuint program = config->program;    glUseProgram(program);    // Update and bind transform state    struct Transform {        float ModelViewMatrix[16];        float ProjectionMatrix[16];        float ModelViewProjectionMatrix[16];    } transformData;    setMatrix(mDrawContext.getMatrix(MHWRender::MDrawContext::kWorldViewMtx),              transformData.ModelViewMatrix);    setMatrix(mDrawContext.getMatrix(MHWRender::MDrawContext::kProjectionMtx),              transformData.ProjectionMatrix);    setMatrix(mDrawContext.getMatrix(MHWRender::MDrawContext::kWorldViewProjMtx),              transformData.ModelViewProjectionMatrix);    if (!g_transformUB) {        glGenBuffers(1, &g_transformUB);        glBindBuffer(GL_UNIFORM_BUFFER, g_transformUB);        glBufferData(GL_UNIFORM_BUFFER,                     sizeof(transformData), NULL, GL_STATIC_DRAW);    };    glBindBuffer(GL_UNIFORM_BUFFER, g_transformUB);    glBufferSubData(GL_UNIFORM_BUFFER,                    0, sizeof(transformData), &transformData);    glBindBuffer(GL_UNIFORM_BUFFER, 0);    glBindBufferBase(GL_UNIFORM_BUFFER, g_transformBinding, g_transformUB);    // Update and bind tessellation state    struct Tessellation {        float TessLevel;        int GregoryQuadOffsetBase;        int PrimitiveIdBase;    } tessellationData;    tessellationData.TessLevel = static_cast<float>(1 << _tessFactor);    tessellationData.GregoryQuadOffsetBase = patch.GetQuadOffsetBase;    tessellationData.PrimitiveIdBase = patch.GetPatchIndex();;    if (!g_tessellationUB) {        glGenBuffers(1, &g_tessellationUB);        glBindBuffer(GL_UNIFORM_BUFFER, g_tessellationUB);        glBufferData(GL_UNIFORM_BUFFER,                     sizeof(tessellationData), NULL, GL_STATIC_DRAW);    };    glBindBuffer(GL_UNIFORM_BUFFER, g_tessellationUB);    glBufferSubData(GL_UNIFORM_BUFFER,                    0, sizeof(tessellationData), &tessellationData);    glBindBuffer(GL_UNIFORM_BUFFER, 0);    glBindBufferBase(GL_UNIFORM_BUFFER,                     g_tessellationBinding,                     g_tessellationUB);#ifdef USE_NON_IMAGE_BASED_LIGHTING    // Update and bind lighting state    int numLights = mDrawContext.numberOfActiveLights();    struct Lighting {        struct Light {            float position[4];            float diffuse[4];            float ambient[4];            float specular[4];        } lightSource[2];    } lightingData;    memset(&lightingData, 0, sizeof(lightingData));    for (int i = 0; i < numLights && i < 1; ++i) {        MFloatPointArray positions;        MFloatVector direction;        float intensity;        MColor color;        bool hasDirection, hasPosition;        mDrawContext.getLightInformation(i, positions, direction, intensity,                                         color, hasDirection, hasPosition);        Lighting::Light &light = lightingData.lightSource[i];        if (hasDirection) {            light.position[0] = -direction[0];//.........这里部分代码省略.........

static void set_uniform_vector4f(int32 location, vector4f vector) {	glUniform4fv(location, 1, &vector.x);	CHECK_GL_ERROR();}

static uint32 create_shader(uint32 type) {	uint32 id = glCreateShader(type);	CHECK_GL_ERROR();	return id;}

static void set_uniform_float(int32 location, float value) {	glUniform1f(location, value);	CHECK_GL_ERROR();}

static void destroy_shader(uint32 id) {	Assert(id != 0);	glDeleteShader(id);	CHECK_GL_ERROR();}

static void bind_shader_program(shader_asset* shader) {	Assert(shader->program_id != 0);	current_shader_asset = shader->handle;	glUseProgram(shader->program_id);	CHECK_GL_ERROR();}

static void attach_fragment_shader(uint32 shader_program, uint32 fragment_shader) {	glAttachShader(shader_program, fragment_shader);	CHECK_GL_ERROR();}

static void destroy_texture(uint32 id) {	Assert(id != 0);	glDeleteTextures(1, &id);	CHECK_GL_ERROR();}

static void bind_gl_buffer(gl_buffer* buffer) {	Assert(buffer->id != 0);	glBindBuffer(buffer->target, buffer->id);	CHECK_GL_ERROR();}

//.........这里部分代码省略.........        if (!arglGLCompileShaderFromString(&vertShader, GL_VERTEX_SHADER, vertShaderString)) {            ARLOGe("drawCube: Error compiling vertex shader./n");            arglGLDestroyShaders(vertShader, fragShader, program);            return;        }        if (!arglGLCompileShaderFromString(&fragShader, GL_FRAGMENT_SHADER, fragShaderString)) {            ARLOGe("drawCube: Error compiling fragment shader./n");            arglGLDestroyShaders(vertShader, fragShader, program);            return;        }        glAttachShader(program, vertShader);        glAttachShader(program, fragShader);        glBindAttribLocation(program, ATTRIBUTE_VERTEX, "position");        glBindAttribLocation(program, ATTRIBUTE_COLOUR, "colour");        if (!arglGLLinkProgram(program)) {            ARLOGe("drawCube: Error linking shader program./n");            arglGLDestroyShaders(vertShader, fragShader, program);            return;        }        arglGLDestroyShaders(vertShader, fragShader, 0); // After linking, shader objects can be deleted.        // Retrieve linked uniform locations.        uniforms[UNIFORM_MODELVIEW_PROJECTION_MATRIX] = glGetUniformLocation(program, "modelViewProjectionMatrix");    }    glUseProgram(program);    // Set up 3D mode.    mtxLoadIdentityf(viewProjection);    mtxMultMatrixf(viewProjection, cameraLens);    glStateCacheEnableDepthTest();    // Set any initial per-frame GL state you require here.    // --->    // Lighting and geometry that moves with the camera should be added here.    // (I.e. should be specified before camera pose transform.)    // --->    // Draw an object on all valid markers.    for (int i = 0; i < markersSquareCount; i++) {        if (markersSquare[i].valid) {        	float viewProjection2[16];        	mtxLoadMatrixf(viewProjection2, viewProjection);            mtxMultMatrixf(viewProjection2, markersSquare[i].pose.T);            drawCube(viewProjection2, 40.0f, 0.0f, 0.0f, 20.0f);        }    }    if (cameraPoseValid) {        mtxMultMatrixf(viewProjection, cameraPose);        // All lighting and geometry to be drawn in world coordinates goes here.        // --->    }    // If you added external OpenGL code above, and that code doesn't use the glStateCache routines,    // then uncomment the line below.    //glStateCacheFlush();        // Set up 2D mode.    mtxLoadIdentityf(viewProjection);	width = (float)viewPort[viewPortIndexWidth];	height = (float)viewPort[viewPortIndexHeight];	mtxOrthof(viewProjection, 0.0f, width, 0.0f, height, -1.0f, 1.0f);    glStateCacheDisableDepthTest();    // Add your own 2D overlays here.    // --->    // If you added external OpenGL code above, and that code doesn't use the glStateCache routines,    // then uncomment the line below.    //glStateCacheFlush();#ifdef DEBUG    // Example of 2D drawing. It just draws a white border line. Change the 0 to 1 to enable.    const GLfloat square_vertices [4][3] = { {0.5f, 0.5f, 0.0f}, {0.5f, height - 0.5f, 0.0f}, {width - 0.5f, height - 0.5f, 0.0f}, {width - 0.5f, 0.5f, 0.0f} };    const GLubyte square_vertex_colors_white [4][4] = {        {255, 255, 255, 255}, {255, 255, 255, 255}, {255, 255, 255, 255}, {255, 255, 255, 255}};    glUniformMatrix4fv(uniforms[UNIFORM_MODELVIEW_PROJECTION_MATRIX], 1, GL_FALSE, viewProjection); 	glVertexAttribPointer(ATTRIBUTE_VERTEX, 3, GL_FLOAT, GL_FALSE, 0, square_vertices);	glEnableVertexAttribArray(ATTRIBUTE_VERTEX);	glVertexAttribPointer(ATTRIBUTE_COLOUR, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, square_vertex_colors_white);    glEnableVertexAttribArray(ATTRIBUTE_COLOUR);    if (!arglGLValidateProgram(program)) {        ARLOGe("Error: shader program %d validation failed./n", program);        return;    }    glDrawArrays(GL_LINE_LOOP, 0, 4);#endif#ifdef DEBUG    CHECK_GL_ERROR();#endif}

static void upload_gl_buffer_data(gl_buffer* buffer) {	Assert(buffer->memory && buffer->id != 0 && buffer->size != 0);	bind_gl_buffer(buffer);	glBufferData(buffer->target, buffer->size, buffer->memory, buffer->usage);	CHECK_GL_ERROR();}