C++ checkGLError函数代码示例

GLuint esLoadShader(GLenum shader_type, std::string src)
{
  GLint succeeded;
  GLuint sid;

  sid = glCreateShader(shader_type);
  // glShaderSource(sid, 1, (const GLchar **) &src, NULL);
  char const * shaderCodePointer = src.c_str();
  glShaderSource(sid, 1, &shaderCodePointer, NULL);
  glCompileShader(sid);
  glGetShaderiv(sid, GL_COMPILE_STATUS, &succeeded);

  GLint log_length;
  glGetShaderiv(sid, GL_INFO_LOG_LENGTH, &log_length);

  if (log_length > 1) {
    char *log =  (char *) malloc(sizeof(char) * log_length);
    GLint chars_written;
    glGetShaderInfoLog(sid, log_length, &chars_written, log);
    checkGLError(" *********    Error esLoadShader: Loading and compiling a shader.");
    printf("%s\n", log);
    free(log);
  }
  checkGLError(" *********** Error esLoadShader: Something went wrong with the shader.");
  return sid;
}

void CVertexBuffer::allocate(U32 size, eUsageType usage, bool system, void *data) {
    mSize = size;
    mUsage = usage;
    mLocked = false;
    //GLEW_ARB_vertex_buffer_object = false;
    if(GLEW_ARB_vertex_buffer_object && !system){
        mSystemMemory = false;
        checkGLError();
        glGenBuffersARB(1, &mBufferId);
        checkGLError();
        GLenum use;
        switch (usage) {
            case STATIC:
                use = GL_STATIC_DRAW_ARB;
                break;
            case DYNAMIC:
                use = GL_STREAM_DRAW_ARB;
                break;
        }
        activate();
        glBufferDataARB(GL_ARRAY_BUFFER_ARB, mSize, data, use);
        checkGLError();
        deactivate();
    } else {
        mSystemMemory = true;
        mSysAddr = malloc(mSize);
        if(data){
            memcpy(mSysAddr, data, mSize);
        }
    }
}

//Creates the Vertex Array Object, and Vertex Buffer Objects for the mesh
void Mesh::createBuffers() {
	
	//Generate and fill vertex buffer object
	glGenBuffers(1, &this->vertexBufferID);
	glBindBuffer(GL_ARRAY_BUFFER, this->vertexBufferID);
	checkGLError("Could not generate the VertexBuffer");
	glBufferData(GL_ARRAY_BUFFER, (sizeof(this->vertices[0])*this->vertices.size()), (GLvoid*)&this->vertices[0], GL_STATIC_DRAW);
	checkGLError("Could not fill VertexBuffer");

	//Generate and fill the vertex index buffer
	glGenBuffers(1, &this->vertexIndexID);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->vertexIndexID);
	checkGLError("Could not generate the VertexIndexBuffer");
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, (sizeof(GLuint)*this->vertexIndices.size()), (GLvoid*)&this->vertexIndices[0], GL_STATIC_DRAW);
	checkGLError("Could not fill the VertexIndexBuffer");

	//Generate Vertex Array Object
	glGenVertexArrays(1, &this->vertexArrayID);
	glBindVertexArray(this->vertexArrayID);
	checkGLError("Could not generate and bind VertexArray");

	glBindBuffer(GL_ARRAY_BUFFER, this->vertexBufferID);
	this->shader->linkVertexAttributes();
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->vertexIndexID);

	//Unbind the buffers
	glBindBuffer(GL_ARRAY_BUFFER,0);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
	glBindVertexArray(0);
}

	void MenuRenderer::render() {
		checkGLError("MenuRenderer Start");
		// set the menu projection
		glDisable(GL_CULL_FACE);
		glDisable(GL_DEPTH_TEST);
		glEnable(GL_BLEND);
		glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
		glViewport(0, 0, context->gConfig->viewportWidth, context->gConfig->viewportHeight);
		if (context->gConfig->useShaders) {
			context->renderContext->projMatrix.identity();
			context->renderContext->projMatrix.ortho(0, context->gConfig->width, context->gConfig->height, 0, -1, 1);
			context->renderContext->mvMatrix.identity();
		} else {
			glMatrixMode(GL_PROJECTION);
			glLoadIdentity();
			// top left is 0,0, so scissor will be inverted y
			glOrthof(0, context->gConfig->width, context->gConfig->height, 0, -1, 1);
			glMatrixMode(GL_MODELVIEW);
			glColor4f(1, 1, 1, 1);
		}
		S32 i = 0;
		for (i = 0; i < context->uiManager->activeMenuStack->getSize(); i++) {
			Menu *menu = context->uiManager->activeMenuStack->array[i];
			UIComponent *root = menu->getRootComponent();
			activeResourceId = -1;
			render(root);
		}
		glDisable(GL_BLEND);
		checkGLError("MenuRenderer End");
	}

Glyph Font::renderGlyph(char glyph, float font_size)
{
    if(m_rendered_symbols[(int)glyph].find(font_size) != m_rendered_symbols[(int)glyph].end()) {
        return m_rendered_symbols[(int)glyph].at(font_size);
    }
    Glyph new_glyph;

    FT_UInt char_index = FT_Get_Char_Index(m_font_face, glyph);

    if(FT_Load_Glyph(m_font_face, char_index, FT_LOAD_DEFAULT) || FT_Render_Glyph(m_font_face->glyph, FT_RENDER_MODE_NORMAL))
        return new_glyph;

    FT_Bitmap& bitmap   = m_font_face->glyph->bitmap;
    new_glyph.bearing.x = m_font_face->glyph->metrics.horiBearingX / 64;
    new_glyph.bearing.y = m_font_face->glyph->metrics.horiBearingY / 128;
    new_glyph.advance   = m_font_face->glyph->metrics.horiAdvance / 64;

    glGenTextures(1, &new_glyph.texture);
    glBindTexture(GL_TEXTURE_2D, new_glyph.texture);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    checkGLError();

    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bitmap.width, bitmap.rows, 0, GL_RED, GL_UNSIGNED_BYTE, bitmap.buffer);
    checkGLError();
    new_glyph.id = glyph;
    new_glyph.dimensions = glm::vec2(bitmap.width, bitmap.rows);
    m_rendered_symbols[(int)glyph][font_size] = new_glyph;

    return new_glyph;
}

bool HeightMap::appMain() {
    if (!running) {
        return false;
    }
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glUseProgram(program.programID());
    running &= checkGLError("Error encountered enabling Shader Program\n", Logger::LOG_ERROR);

    _xform = Matrix4::translate(0.0f, -1.0f, _zPlane) 
           * Matrix4::rotate(40.0f, 0.0f, 0.0f)
           * Matrix4::rotate(0.0f, _angle, 0.0f);

    glUniformMatrix4fv(_xformLoc, 1, false, _xform.buffer());
    running &= checkGLError("Error encountered enabling loading Transform matrix: %s\n", Logger::LOG_ERROR);

    glDrawArrays(_drawMode, 0, _totalVerts);
    running &= checkGLError("Error encountered calling glDrawArrays: %s\n", Logger::LOG_ERROR);

    display->swapBuffers();
    display->mainLoop(*this);

    _angle += 0.5f;
    if (_angle >= 360.0f) {
        _angle -= 360.0f;
    };

    return true;
}

// private
void CGLvbo::Init(const int nElements, const void *pVertexBuf, const void *pNormalBuf, const void *pUVBuf, GLenum nUsage)
{
	assert(nullptr!=pVertexBuf);
	assert(0<nElements);
	assert( nUsage>=0x88E0 && nUsage<=0x88EA );

	Cleanup();
	checkGLError();

	glGenVertexArrays(1, &mVAO);
	glBindVertexArray(mVAO);

	// the vertex buffer is NOT optional
	glGenBuffers(1, &mVertObjId);
	glBindBuffer(GL_ARRAY_BUFFER, mVertObjId);
	glBufferData(GL_ARRAY_BUFFER, nElements * sizeof(glm::vec3), pVertexBuf, nUsage);
	checkGLError();

	if(pNormalBuf) {
		glGenBuffers(1, &mNormObjId);
		glBindBuffer(GL_ARRAY_BUFFER, mNormObjId);
		glBufferData(GL_ARRAY_BUFFER, nElements * sizeof(glm::vec3), pNormalBuf, nUsage);
		checkGLError();
	}

	if(pUVBuf) {
		glGenBuffers(1, &mUVObjId);
		glBindBuffer(GL_ARRAY_BUFFER, mUVObjId);
		glBufferData(GL_ARRAY_BUFFER, nElements * sizeof(glm::vec2), pUVBuf, nUsage);
		checkGLError();
	}

	// LOG_GLERROR();
}

void SDLFontGL::updateDimensions() {
	if (!m_openglActive || 0 == nWidth || 0 == nHeight) return;

	unsigned int oldCols = m_cols, oldRows = m_rows;

	m_cols = m_dimW / nWidth;
	m_rows = m_dimH / nHeight;

	m_curdimW = m_cols * nWidth;
	m_curdimH = m_rows * nHeight;
	m_curdimX = m_dimX + (m_dimW - m_curdimW) / 2;
	m_curdimY = m_dimY + (m_dimH - m_curdimH) / 2;

	if (oldCols != m_cols || oldRows != m_rows || !m_cellsTex) {
		updateCells();
	}

	if (m_charShader.program) {
		glUseProgram(m_charShader.program);
		checkGLError();

		glUniform2f(m_charShader.aDim, m_cols, m_rows);
		checkGLError();
	}

	if (m_cursorShader.program) {
		glUseProgram(m_cursorShader.program);
		checkGLError();

		glUniform2f(m_cursorShader.aDim, m_cols, m_rows);
		checkGLError();
	}
}

void SDLFontGL::createTexture() {
	// Create Big GL texture:
	glGenTextures(1,&GlyphCache);
	glBindTexture(GL_TEXTURE_2D, GlyphCache);

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

	// Set size of the texture, but no data.
	// We want 1 extra row of pixel data
	// so we can draw solid colors as part
	// of the same operations.
	texW = nextPowerOfTwo(nChars*nWidth);
	texH = nextPowerOfTwo(nFonts*MAX_CHARSETS*nHeight + 1);
	int nMode = getGLFormat();
	glTexImage2D(GL_TEXTURE_2D,
			0, nMode,
			texW, texH,
			0, nMode,
			GL_UNSIGNED_BYTE, NULL);
	checkGLError();


	// Put a single white pixel at bottom of texture.
	// We use this as the 'texture' data for blitting
	// solid backgrounds.
	char whitepixel[] = { 255, 255, 255, 255 };
	assert(nFonts && nHeight);
	glTexSubImage2D(GL_TEXTURE_2D, 0,
			0,nFonts*MAX_CHARSETS*nHeight,
			1, 1,
			GL_RGBA, GL_UNSIGNED_BYTE, whitepixel);
	checkGLError();
}

void Font::draw(IScene* scene, const char* text, glm::mat4 transform, float font_size, glm::vec3 color)
{
	FT_Set_Pixel_Sizes(m_font_face, font_size, font_size);
    glUseProgram(TEXT_PROGRAM);
    checkGLError();

    glm::vec3 pen(0, 0, 0);
    char prev = 0;
    bool kern = FT_HAS_KERNING(m_font_face);
    for(const char* i = text; i[0]; ++i) {
        FT_UInt index = FT_Get_Char_Index(m_font_face, i[0]);
        Glyph glyph = renderGlyph(i[0], font_size);

        if(prev && kern && i) {
            FT_Vector delta;
            FT_Get_Kerning(m_font_face, prev, index, FT_KERNING_DEFAULT, &delta);
            pen.x += delta.x * scene->getDPU();
            //fprintf(stderr, "%ld\n", delta.x);
        }

        if(i[0] == '\n') {
            pen.x = 0;
            pen.y += font_size;
            prev = 0;
            continue;
        } else if(i[0] == ' ' || glyph.id == 0) {
            pen.x += font_size;
            prev = 0;
            continue;
        }

        glUniform3f(m_color_uniform, color.x, color.y, color.z);
        glm::vec3 offset(glyph.bearing.x, -glyph.bearing.y, 0.0f);

        glm::mat4 mvp = scene->getActiveProjectionMatrix() *
                        scene->getActiveViewMatrix() *
                        transform *
                        glm::translate(glm::mat4(1), -(pen + offset) * scene->getDPU()) *
                        glm::scale(glm::mat4(1), glm::vec3(glyph.dimensions.x * scene->getDPU(), glyph.dimensions.y * scene->getDPU(), 1.0f));
        //fprintf(stderr, "Result: %f, %f, %f, %f\n", glyph.dimensions.x, glyph.dimensions.y, glyph.dimensions.x * scene->getDPU(), glyph.dimensions.y * scene->getDPU());
        glUniformMatrix4fv(m_transform_uniform, 1, GL_FALSE, &mvp[0][0]);
        glEnableVertexAttribArray(m_vertex_position);
        glBindBuffer(GL_ARRAY_BUFFER, QUAD_BUFFER);
        glVertexAttribPointer(m_vertex_position, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);

        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, glyph.texture);
        glUniform1i(m_texture_uniform, 0);
        checkGLError();

        glDrawArrays(GL_TRIANGLES, 0, 6);
        checkGLError();

        glDisableVertexAttribArray(m_vertex_position);
        pen.x += glyph.advance;
        //fprintf(stderr, "(%d)\n", (int)glyph.advance);
        prev = index;
    }
}

    void
    PhysicsDebugDrawer::drawAll
    ()
    {
        #ifdef DREAM_LOG
        auto log = getLog();
        log->debug( "Drawing {} lines" , mVertexBuffer.size()/2 );
        #endif
        preRender();

        // Enable shader program
        glUseProgram(mShaderProgram);

        glBindVertexArray(mVAO);
        ShaderRuntime::CurrentShaderProgram = mShaderProgram;

        // Set the projection matrix
        GLint projUniform = glGetUniformLocation(mShaderProgram, "projection");
        if (projUniform == -1)
        {
            #ifdef DREAM_LOG
            log->error( "Unable to find Uniform Location for projection" );
            checkGLError();
            #endif
            return;
        }
        else
        {
            mat4 projectionMatrix = mCamera->getProjectionMatrix();
            glUniformMatrix4fv(projUniform, 1, GL_FALSE, glm::value_ptr(projectionMatrix));
        }

        // Set the view matrix
        GLint viewUniform = glGetUniformLocation(mShaderProgram, "view");
        if (viewUniform == -1)
        {
            #ifdef DREAM_LOG
            log->error( "Unable to find Uniform Location for view" );
            checkGLError();
            #endif
            return;
        }
        else
        {
            mat4 viewMatrix = mCamera->getViewMatrix();
            glUniformMatrix4fv(viewUniform, 1, GL_FALSE, glm::value_ptr(viewMatrix));
        }

        glBindBuffer(GL_ARRAY_BUFFER, mVBO);
        glBufferData(GL_ARRAY_BUFFER, static_cast<GLint>(mVertexBuffer.size() * sizeof(PhysicsDebugVertex)), &mVertexBuffer[0], GL_STATIC_DRAW);

        // Draw
        glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(mVertexBuffer.size()));
        // Unbind
        postRender();
        // Clear old buffer
        mVertexBuffer.clear();
    }

void CGLfbo::CopyTexture(const uint32_t target) const
{
	glBindTexture(GL_TEXTURE_2D, target);
	checkGLError();
	glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, 0, 0, mWidth, mHeight, 0);
	checkGLError();
	glBindTexture(GL_TEXTURE_2D, 0);
	checkGLError();
}

void CBitmapFont::generateGlyph(U32 ch){
	S32 pad = 3;
	FT_GlyphSlot  slot = mFace->glyph;
	FT_Glyph glyph;
    FT_UInt glyph_index;

	glyph_index = FT_Get_Char_Index( mFace, (FT_ULong)ch );

	FT_Load_Glyph( mFace, glyph_index, FT_LOAD_DEFAULT);
	FT_Get_Glyph( slot, &glyph);

	FT_Glyph_To_Bitmap(&glyph, ft_render_mode_normal, 0 ,1);

	FT_BitmapGlyph bitmap = (FT_BitmapGlyph)glyph;
	FT_Bitmap* source = &bitmap->bitmap;


	S32 srcWidth = source->width;
	S32 srcHeight = source->rows;
	S32 srcPitch = source->pitch;

	S32 dstWidth = srcWidth;
	S32 dstHeight = srcHeight;
	S32 dstPitch = srcPitch;

	FT_BBox bbox;
	FT_Glyph_Get_CBox( glyph, ft_glyph_bbox_pixels, &bbox);

	unsigned char *src = source->buffer;

	if(pen.x + srcWidth >= mTextureSize){
		pen.x = 0;
		pen.y += (getFontSize() * 64.0f / dpi) + pad;
	}

	glBindTexture(GL_TEXTURE_2D, curTex);checkGLError();
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);checkGLError();
	glTexSubImage2D(GL_TEXTURE_2D, 0, 
		pen.x, pen.y,
		srcWidth, srcHeight,
		GL_ALPHA, GL_UNSIGNED_BYTE, src); checkGLError();

	CTexCoord start(pen);
	start /= mTextureSize;
	CTexCoord end(pen.x + srcWidth, pen.y + srcHeight);
	end /= mTextureSize;
	//CVector2 pos(slot->bitmap_left, slot->bitmap_top);
	CVector2 pos(bitmap->left, srcHeight - bitmap->top);
	CVector2 size(srcWidth, srcHeight);
	CVector2 advance(slot->advance.x >> 6, slot->advance.y >> 6);
	
	mGlyphs[glyph_index] = new CBitmapGlyph(curTex, start, end, pos, size, advance);

	pen.x += srcWidth + pad;

	FT_Done_Glyph(glyph);
}

  void Render::drawVertices(const std::vector<inputData> &vertices)
{
   assert(initialized);
   glBufferSubData(GL_ARRAY_BUFFER,0, vertices.size() * sizeof(inputData),&vertices[0]);
   checkGLError();

   glDrawElements(GL_TRIANGLES,6 * vertices.size()/4,GL_UNSIGNED_SHORT,0);
   checkGLError();
}

CGLfbo::~CGLfbo() {
	if(glIsTexture(mTexture)==GL_TRUE) {
		glDeleteTextures(1, &mTexture);
		checkGLError();
	}
	if(glIsFramebuffer(mFBO)==GL_TRUE) {
		glDeleteFramebuffers(1, &mFBO);
		checkGLError();
	}
}