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

void draw_ingame_interface(){#ifdef OPENGL_TRACECHECK_GL_ERRORS();#endif //OPENGL_TRACE#ifdef	OLD_CLOSE_BAG	// watch for closing a bag	if(ground_items_win >= 0)		{			int	old_view= view_ground_items;			view_ground_items= get_show_window(ground_items_win);			// watch for telling the server we need to close the bag			if(old_view && !view_ground_items)				{					unsigned char protocol_name;					protocol_name= S_CLOSE_BAG;					my_tcp_send(my_socket,&protocol_name,1);				}		}#endif	//OLD_CLOSE_BAG	glColor3f(1.0f, 1.0f, 1.0f);	draw_hud_frame();	//draw_hud_interface();	display_spells_we_have();#ifdef OPENGL_TRACECHECK_GL_ERRORS();#endif //OPENGL_TRACE}

void Enter2DModeExtended(int width, int height){#ifdef OPENGL_TRACECHECK_GL_ERRORS();#endif //OPENGL_TRACE	if (use_fog) glDisable(GL_FOG);	glPushAttrib(GL_LIGHTING_BIT|GL_DEPTH_BUFFER_BIT);	glDisable(GL_LIGHTING);	glDisable(GL_DEPTH_TEST);	glViewport(0, 0, width, height);#ifdef OPENGL_TRACE	CHECK_GL_ERRORS();#endif //OPENGL_TRACE	glMatrixMode(GL_PROJECTION);	glPushMatrix();	glLoadIdentity();	glOrtho(0.0, (GLdouble)width, (GLdouble)height, 0.0, -1.0, 1.0);	glMatrixMode(GL_MODELVIEW);	glPushMatrix();	glLoadIdentity();#ifdef OPENGL_TRACE	CHECK_GL_ERRORS();#endif //OPENGL_TRACE}

texture_t::texture_t(aasset_buffer_t& buffer)        : _alpha(false){    raw_bitmap_t bitmap;    png_load_from_memory(buffer, &bitmap);    //Now generate the OpenGL texture object    glGenTextures(1, &_id);    glBindTexture(GL_TEXTURE_2D, _id);    CHECK_GL_ERRORS("Error texture bind");    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);//  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);//  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);    CHECK_GL_ERRORS("Error texture parameter setting");    glTexImage2D(GL_TEXTURE_2D, 0, bitmap.format(), bitmap.width(), bitmap.height(), 0, bitmap.format(),    GL_UNSIGNED_BYTE, (GLvoid*) bitmap.data());    CHECK_GL_ERRORS("Error texture createing");    glBindTexture(GL_TEXTURE_2D, 0);    CHECK_GL_ERRORS("Couldn't load texture");    if (bitmap.alpha()) _alpha = true;}

TextureFBO::TextureFBO(unsigned int width, unsigned int height, int targets, bool storeDepth, int format) {	this->width = width;	this->height = height;    texture.resize(targets);   	// Initialize Texture    glGenTextures(targets, &texture[0]);    for (size_t i = 0; i < targets; i++) {        glBindTexture(GL_TEXTURE_2D, texture[i]);        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);        glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, GL_RGBA, GL_FLOAT, NULL);    }        if(!storeDepth){        //Create depth bufferGLuint rboId;        glGenRenderbuffers(1, &depth);        glBindRenderbuffer(GL_RENDERBUFFER_EXT, depth);        glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, width, height);        glBindRenderbuffer(GL_RENDERBUFFER, 0);    }else{        glGenTextures(1, &depth);        glBindTexture(GL_TEXTURE_2D, depth);        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);        //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);        //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);        glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, width, height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);    }    CHECK_GL_ERRORS();	// Create FBO and attach buffers	glGenFramebuffers(1, &fbo);	glBindFramebuffer(GL_FRAMEBUFFER, fbo);        std::vector<GLenum> attachments;	for (uint i = 0; i < targets; i++) {        attachments.push_back(GL_COLOR_ATTACHMENT0+i);        glFramebufferTexture2D(GL_FRAMEBUFFER, attachments[i], GL_TEXTURE_2D, texture[i], 0);    }    glDrawBuffers(targets, attachments.data());        if (!storeDepth) {        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth);    }else{        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depth, 0);    }    		CHECK_GL_ERRORS();	CHECK_GL_FBO_COMPLETENESS();        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	glBindFramebuffer(GL_FRAMEBUFFER, 0);}

int draw_string_zoomed_width (int x, int y, const unsigned char * our_string, int max_width, int max_lines, float text_zoom){	float displayed_font_x_size= DEFAULT_FONT_X_LEN*text_zoom;	float displayed_font_y_size= DEFAULT_FONT_Y_LEN*text_zoom;	unsigned char cur_char;	int i;	int cur_x,cur_y;	int current_lines= 1;#ifdef OPENGL_TRACECHECK_GL_ERRORS();#endif //OPENGL_TRACE	glEnable(GL_ALPHA_TEST);//enable alpha filtering, so we have some alpha key	glAlphaFunc(GL_GREATER,0.1f);	bind_texture(font_text);	i=0;	cur_x=x;	cur_y=y;	glBegin(GL_QUADS);	while(1)		{			cur_char=our_string[i];			// watch for special characters			if(!cur_char)	// end of line				{					break;				}			else if (cur_char == '/n' || cur_char == '/r')	// newline				{					cur_y+=displayed_font_y_size;					cur_x=x;					i++;					current_lines++;					if(current_lines>max_lines)break;					continue;				}			else if (cur_x+displayed_font_x_size-x>=max_width){				cur_y+=displayed_font_y_size;				cur_x=x;				current_lines++;				if(current_lines>max_lines)break;			}			cur_x+=draw_char_scaled(cur_char, cur_x, cur_y, displayed_font_x_size, displayed_font_y_size);			i++;		}	glEnd();	glDisable(GL_ALPHA_TEST);#ifdef OPENGL_TRACECHECK_GL_ERRORS();#endif //OPENGL_TRACE	return current_lines;}

void draw_scene(){	CHECK_GL_ERRORS();	glClearColor(skybox_fog_color[0], skybox_fog_color[1], skybox_fog_color[2], 0.0);	if(!shadows_on || !have_stencil)glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);	else glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);	if (!have_display)	{		new_zoom_level = zoom_level;	// No scrolling when switching modes...		if (quickbar_relocatable && quickbar_win >= 0) // Hack 		{			if (get_show_window (quickbar_win) && windows_list.window[quickbar_win].cur_x < window_width - hud_x && window_height - windows_list.window[quickbar_win].cur_y > hud_y)				hide_window (quickbar_win);		}	}	glLoadIdentity ();	// Reset The Matrix		Enter2DMode ();	display_windows (1);	// Have to draw the dragged item *after* all windows		glColor3f(1.0f,1.0f,1.0f);	if (item_dragged != -1)		drag_item (item_dragged, 0, 0);	else if (use_item != -1 && current_cursor == CURSOR_USE_WITEM)		drag_item (use_item, 0, 1);	else if (storage_item_dragged != -1) 		drag_item (storage_item_dragged, 1, 0);	draw_special_cursors();	Leave2DMode ();	if(elwin_mouse >= 0)	{		if (current_cursor != elwin_mouse) change_cursor(elwin_mouse);		elwin_mouse = -1;	}		SDL_GL_SwapBuffers();	CHECK_GL_ERRORS();		/* start or stop the harvesting effect depending on harvesting state */	check_harvesting_effect();		if (draw_delay > 0)	{		SDL_Delay (draw_delay);		draw_delay = 0;	}}

void draw_string_small(int x, int y,const unsigned char * our_string,int max_lines){	//int displayed_font_x_size=SMALL_FONT_X_LEN;	//int displayed_font_y_size=SMALL_FONT_Y_LEN;	unsigned char cur_char;	int i;	int cur_x,cur_y;	int current_lines=0;#ifdef OPENGL_TRACECHECK_GL_ERRORS();#endif //OPENGL_TRACE	glEnable(GL_ALPHA_TEST);//enable alpha filtering, so we have some alpha key	glAlphaFunc(GL_GREATER,0.1f);#ifdef	NEW_TEXTURES	bind_texture(font_text);#else	/* NEW_TEXTURES */	get_and_set_texture_id(font_text);#endif	/* NEW_TEXTURES */	i=0;	cur_x=x;	cur_y=y;	glBegin(GL_QUADS);	while(1)		{			cur_char=our_string[i];			if(!cur_char)				{					break;				}			else if(cur_char=='/n')				{					cur_y+=SMALL_FONT_Y_LEN;					cur_x=x;					i++;					current_lines++;					if(current_lines>=max_lines)break;					continue;				}			cur_x+=draw_char_scaled(cur_char, cur_x, cur_y, SMALL_FONT_X_LEN, SMALL_FONT_Y_LEN);			i++;		}	glEnd();	glDisable(GL_ALPHA_TEST);#ifdef OPENGL_TRACECHECK_GL_ERRORS();#endif //OPENGL_TRACE}

void AppManager::runKernel(double dt){    kernel1->bind();    glViewport(0, 0, Nx, Ny);        lax_f->use();        float rx = (float)dt/(1.0f/(float)Nx);    float ry = (float)dt/(1.0f/(float)Ny);        //set uniforms    glUniform1f(lax_f->getUniform("rx"), rx);    glUniform1f(lax_f->getUniform("ry"), ry);    glUniform1f(lax_f->getUniform("gamma"), gamma);    glUniform1i(lax_f->getUniform("QTex"), 0);        glActiveTexture(GL_TEXTURE0);    glBindTexture(GL_TEXTURE_2D, kernel0->getTexture());        glBindVertexArray(vao);    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, NULL);    glBindVertexArray(0);        lax_f->disuse();    kernel1->unbind();      // Flip kernels for next iteration    TextureFBO* temp = kernel0;    kernel0 = kernel1;    kernel1 = temp;       CHECK_GL_ERRORS();        /* DOWNLOAD RESULTS */        glBindTexture(GL_TEXTURE_2D, kernel0->getTexture());        std::vector<GLfloat> data(Nx*Ny*4);    glGetTexImage(GL_TEXTURE_2D,0,GL_RGBA,GL_FLOAT,&data[0]);    glBindTexture(GL_TEXTURE_2D, 0);        float max = 0.0;    for (size_t x = 0; x < Nx; x++) {        for (size_t y = 0; y < Ny; y++) {            max = glm::max(max,data[(Nx * y + x)*4]);        }    }        std::cout << max << std::endl;        /* DOWNLOAD END */        CHECK_GL_ERRORS();}

GLuint compileShader(const char *shaderFilename, ShaderType shaderType) {    GLchar *shaderSource;    GLuint shader;        shaderSource = fileToCharArray(shaderFilename);        switch (shaderType) {        case ShaderTypeVertex:        shader = glCreateShader(GL_VERTEX_SHADER);        break;                case ShaderTypeFragment:        shader = glCreateShader(GL_FRAGMENT_SHADER);        break;                case ShaderTypeGeometry:        shader = glCreateShader(GL_GEOMETRY_SHADER);        break;                default:        return 0;    }    CHECK_GL_ERRORS();        glShaderSource(shader, 1, (const GLchar**)&shaderSource, 0);    CHECK_GL_ERRORS();    glCompileShader(shader);    CHECK_GL_ERRORS();        free(shaderSource);        int isShaderCompiled;    glGetShaderiv(shader, GL_COMPILE_STATUS, &isShaderCompiled);        if (isShaderCompiled == FALSE) {        int maxLength;                glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);        char *infoLog = (char *)malloc(maxLength);                glGetShaderInfoLog(shader, maxLength, &maxLength, infoLog);                printf("Error compiling shader: %s/n", shaderFilename);        printf("Error: %s/n", infoLog);        free(infoLog);        return 0;    }        return shader;}

void OpenGL3RenderState::set_scissor(OpenGL3ContextState& state, const ScissorDesc& scissor_desc) const{    if (state.scissor_test == scissor_desc.enabled && state.scissor == scissor_desc.scissor_rect)        return;    if (scissor_desc.enabled)        glEnable(GL_SCISSOR_TEST);    else        glDisable(GL_SCISSOR_TEST);    CHECK_GL_ERRORS();    glScissor(scissor_desc.scissor_rect.ll().x(), scissor_desc.scissor_rect.ll().y(),        scissor_desc.scissor_rect.width(), scissor_desc.scissor_rect.height());    CHECK_GL_ERRORS();    state.scissor = scissor_desc.scissor_rect;    state.scissor_test = scissor_desc.enabled;}

void reload_fonts(){	int i;	int poor_man_save=poor_man;	int use_mipmaps_save=use_mipmaps;	poor_man=0;	use_mipmaps=0;	for(i=0;i < FONTS_ARRAY_SIZE; i++){		if(fonts[i] != NULL){			if(fonts[i]->texture_id>=0){				glDeleteTextures(1, (GLuint*)&texture_cache[fonts[i]->texture_id].texture_id);				texture_cache[fonts[i]->texture_id].texture_id=0;				get_texture_id(fonts[i]->texture_id);			}		}	}	poor_man=poor_man_save;	use_mipmaps=use_mipmaps_save;#ifdef OPENGL_TRACECHECK_GL_ERRORS();#endif //OPENGL_TRACE}

void HZMap::build(){    glBindFramebuffer(GL_FRAMEBUFFER, fbo);    glBindTexture(GL_TEXTURE_2D, texture);    int numLevels = 1 + (int)glm::floor(glm::log2(glm::max((float)width, (float)height)));        int cWidth = width;    int cHeight = height;    for (int i = 1; i < numLevels; i++) {        HZMbuilder->use();        glUniform2iv(HZMbuilder->getUniform("lastMipSize"),1,                     glm::value_ptr(glm::ivec2(cWidth,cHeight)));        cWidth /= 2;        cHeight /= 2;        cWidth = (cWidth > 0) ? cWidth : 1;        cHeight = (cHeight > 0) ? cHeight : 1;                glViewport(0,0,cWidth,cHeight);        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, i-1);        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, i-1);        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, texture, i);                glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);                CHECK_GL_ERRORS();        CHECK_GL_FBO_COMPLETENESS();                // Render full screen quad        quad->render(HZMbuilder);    }    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, numLevels-1);    glBindFramebuffer(GL_FRAMEBUFFER, 0);}

void display_book(book * b, int type){	page ** p=&b->pages[b->active_page];	int x=0;	switch(type){		case 2:			glPushMatrix();			glTranslatef(x,0,0);			display_page(b,*p);			glPopMatrix();			if(b->no_pages<=b->active_page)				break;			p++;			x+=250;		case 1:		default:			glPushMatrix();			glTranslatef(x,0,0);			display_page(b,*p);			glPopMatrix();			break;	}#ifdef OPENGL_TRACECHECK_GL_ERRORS();#endif //OPENGL_TRACE}

void AppManager::createVAO(){    GLfloat quad_vertices[] =  {		-1.0f, -1.0f,        1.0f, -1.0f,        1.0f,  1.0f,		-1.0f,  1.0f,	};    vert = new BO<GL_ARRAY_BUFFER>(quad_vertices, sizeof(quad_vertices));    	GLubyte quad_indices[] = {		0, 1, 2, //triangle 1		2, 3, 0, //triangle 2	};    ind = new BO<GL_ELEMENT_ARRAY_BUFFER>(quad_indices, sizeof(quad_indices));        glGenVertexArrays(1, &vao);    glBindVertexArray(vao);    visualize->use();    vert->bind();    visualize->setAttributePointer("position", 2);    ind->bind();    glBindVertexArray(0);        CHECK_GL_ERRORS();}

void OpenGL3Driver::bind_uniform(const UniformBuffer& uniform, size_t unit){    const OpenGL3UniformBuffer* buffer = static_cast<const OpenGL3UniformBuffer*>(uniform.impl());    // TODO: need to add state checks    buffer->bind(current_shader_program_, unit);    CHECK_GL_ERRORS();}

void AppManager::render(){    double dt = 1e-45f;//timer.elapsedAndRestart();    runKernel(dt);        glViewport(0, 0, window_width*2, window_height*2);    visualize->use();        float rx = (1.0f/(float)Nx);    float ry = (1.0f/(float)Ny);        glUniform1f(visualize->getUniform("rx"), rx);    glUniform1f(visualize->getUniform("ry"), ry);        glUniform1i(visualize->getUniform("QTex"), 0);    glActiveTexture(GL_TEXTURE0);    glBindTexture(GL_TEXTURE_2D, kernel0->getTexture());        glBindVertexArray(vao);    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, NULL);    glBindVertexArray(0);        visualize->disuse();        CHECK_GL_ERRORS();}

void display_highlight_markers() {	int i;	if (!highlighting_enabled) return;		glDisable(GL_TEXTURE_2D);	glDisable(GL_LIGHTING);	glEnable(GL_BLEND);	glBlendFunc(GL_SRC_ALPHA, GL_ONE);	glEnable(GL_ALPHA_TEST);	for(i = 0; i < NUMBER_OF_HIGHLIGHT_MARKERS; i++) {		if (markers[i].active) {			markers[i].timeleft -= (cur_time - last_time);			if (markers[i].timeleft > 0) {				display_highlight_marker(&markers[i]);			} else {				// This marker has lived long enough now.				markers[i].active = 0;			}		}	}	glDisable(GL_ALPHA_TEST);	glEnable(GL_LIGHTING);	glDisable(GL_BLEND);#ifdef OPENGL_TRACECHECK_GL_ERRORS();#endif //OPENGL_TRACE}

static __inline__ void render_submesh(int meshId, int submeshCount, struct CalRenderer * pCalRenderer, float meshVertices[30000][3], float meshNormals[30000][3], float meshTextureCoordinates[30000][2], CalIndex meshFaces[50000][3], Uint32 use_lightning, Uint32 use_textures){	int submeshId;	int faceCount=0;	for(submeshId = 0; submeshId < submeshCount; submeshId++) {		// select mesh and submesh for further data access		if(CalRenderer_SelectMeshSubmesh(pCalRenderer,meshId, submeshId)) {			// get the transformed vertices of the submesh			CalRenderer_GetVertices(pCalRenderer,&meshVertices[0][0]);			// get the transformed normals of the submesh			if (use_lightning)			{				CalRenderer_GetNormals(pCalRenderer,&meshNormals[0][0]);			}			// get the texture coordinates of the submesh			if (use_textures)			{				CalRenderer_GetTextureCoordinates(pCalRenderer,0,&meshTextureCoordinates[0][0]);			}			// get the faces of the submesh			faceCount = CalRenderer_GetFaces(pCalRenderer, &meshFaces[0][0]);			// set the vertex and normal buffers			glVertexPointer(3, GL_FLOAT, 0, &meshVertices[0][0]);			if (use_lightning)			{				glEnableClientState(GL_NORMAL_ARRAY);				glNormalPointer(GL_FLOAT, 0, &meshNormals[0][0]);			}			else			{				glDisableClientState(GL_NORMAL_ARRAY);			}			// draw the submesh			if (use_textures)			{				glEnableClientState(GL_TEXTURE_COORD_ARRAY);				glTexCoordPointer(2, GL_FLOAT, 0, &meshTextureCoordinates[0][0]);			}			else			{				glDisableClientState(GL_TEXTURE_COORD_ARRAY);			}			if(sizeof(CalIndex)==2)				glDrawElements(GL_TRIANGLES, faceCount * 3, GL_UNSIGNED_SHORT, &meshFaces[0][0]);			else				glDrawElements(GL_TRIANGLES, faceCount * 3, GL_UNSIGNED_INT, &meshFaces[0][0]);		}	}#ifdef OPENGL_TRACECHECK_GL_ERRORS();#endif //OPENGL_TRACE}

void load_exploration_map (){	FILE *fp = NULL;	char exploration_map_filename[256];	if(!minimap_texture)		return;	my_strcp (exploration_map_filename, map_file_name);	exploration_map_filename[strlen(exploration_map_filename)-4] = 0;	strcat (exploration_map_filename, ".xm");	safe_strncpy (current_exploration_map_filename, exploration_map_filename, sizeof (current_exploration_map_filename));	fp = open_file_config (exploration_map_filename, "rb");	if(fp)	{		if (fread(exploration_map, sizeof(GLubyte), 256 * 256, fp) != 256 * 256)		{			memset(exploration_map, 0, 256 * 256 * sizeof(GLubyte));			LOG_ERROR("%s() read failed for file [%s]/n", __FUNCTION__, exploration_map_filename);		}		fclose(fp);	}	else	{		memset(exploration_map, 0, 256 * 256 * sizeof(GLubyte));	}		if(poor_man)	{		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);	}	else if(use_mipmaps)	{		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);		glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);	}	else	{		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);	}	if(have_extension(arb_texture_compression))	{		if(have_extension(ext_texture_compression_s3tc))			glTexImage2D(GL_TEXTURE_2D,0,GL_COMPRESSED_RGB_S3TC_DXT1_EXT, minimap_size, minimap_size,0,GL_LUMINANCE,GL_UNSIGNED_BYTE,&exploration_map);		else			glTexImage2D(GL_TEXTURE_2D,0,GL_COMPRESSED_LUMINANCE, minimap_size, minimap_size,0,GL_ALPHA,GL_UNSIGNED_BYTE,&exploration_map);			}	else		glTexImage2D(GL_TEXTURE_2D,0,GL_LUMINANCE, minimap_size, minimap_size,0,GL_LUMINANCE,GL_UNSIGNED_BYTE,&exploration_map);		CHECK_GL_ERRORS();	}

void GLDraw::DrawRect(	const Rect &r, 	const Rect *clip,	const Vec3 &zRot, // (X, Y) is rotation center, Z is rotation in degrees	r::Material &m,	asset::MaterialLoader *l,	bool sampleMaterialColor,	const Vec4 &rgba) {	int flags = 0;	if (clip) {		flags |= kScissorTest_Enable;		float x = ((clip->x - m_srcvp[0]) * m_todst[0]) + m_dstvp[0];		float y = ((clip->y - m_srcvp[1]) * m_todst[1]) + m_dstvp[1];		float w = clip->w * m_todst[0];		float h = clip->h * m_todst[1];				gls.Scissor(			FloorFastInt(x),			FloorFastInt(m_dstvp[3]-(y+h)),			FloorFastInt(w),			FloorFastInt(h)		);	} else {		flags |= kScissorTest_Disable;	}	gl.MatrixMode(GL_MODELVIEW);	gl.PushMatrix();	gl.Translatef((float)r.x, (float)r.y, 0.f);	if (zRot[2] != 0.f) {		float cx = zRot[0]-r.x;		float cy = zRot[1]-r.y;		gl.Translatef(cx, cy, 0.f);		gl.Rotatef(zRot[2], 0.f, 0.f, 1.f);		gl.Translatef(-cx, -cy, 0.f);	}	gl.Scalef(r.w / kBaseRectSize, r.h / kBaseRectSize, 1.f);	m.BindStates(flags);	m.BindTextures(l);	m.shader->Begin(r::Shader::kPass_Default, m);	m_rect->BindAll(m.shader.get().get());	Shader::Uniforms u(rgba);	m.shader->BindStates(u, sampleMaterialColor);	gls.Commit();	m_rect->CompileArrayStates(*m.shader.get());	m_rect->Draw();	CHECK_GL_ERRORS();	m.shader->End();	gl.PopMatrix();}

 void draw() {     glBindVertexArray(vao);     CHECK_GL_ERRORS();          glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer[0]);     glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer[1]);     glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer[2]);     glBindBuffer(GL_ARRAY_BUFFER, indexBuffer);     CHECK_GL_ERRORS();          glEnableVertexAttribArray(0);     glEnableVertexAttribArray(1);     glEnableVertexAttribArray(2);     CHECK_GL_ERRORS();          glDrawElements(GL_TRIANGLE_STRIP, numIndices, GL_UNSIGNED_SHORT, 0);     CHECK_GL_ERRORS(); }

void switch_from_game_map(){#ifndef	NEW_TEXTURES	glDeleteTextures(1,&map_text);#ifdef OPENGL_TRACECHECK_GL_ERRORS();#endif //OPENGL_TRACE#endif	/* NEW_TEXTURES */}

void AppManager::createProgram(){    lax_f       = new Program("kernel.vert","lax-f.frag");    visualize   = new Program("kernel.vert","visualize.frag");    copy        = new Program("kernel.vert","copy.frag");        //Set uniforms    CHECK_GL_ERRORS();}

        void display::draw_rect_2d(float x1, float y1, float x2, float y2,                                   float s1, float t1, float s2, float t2)        {#if 0            glBegin(GL_QUADS);            // lower left            glNormal3f(0, 0, 1);            glTexCoord2f(s1, t1);            glVertex2f(x1, y1);            // lower right            glNormal3f(0, 0, 1);            glTexCoord2f(s2, t1);            glVertex2f(x2, y1);            // upper right            glNormal3f(0, 0, 1);            glTexCoord2f(s2, t2);            glVertex2f(x2, y2);            // upper left            glNormal3f(0, 0, 1);            glTexCoord2f(s1, t2);            glVertex2f(x1, y2);            glEnd();            CHECK_GL_ERRORS();#else            glPolygonMode(GL_FRONT, GL_FILL);            glBegin(GL_TRIANGLE_STRIP);            // upper left            //glNormal3f(0, 0, 1);            glTexCoord2f(s1, t2);            glVertex2f(x1, y2);            // lower left            //glNormal3f(0, 0, 1);            glTexCoord2f(s1, t1);            glVertex2f(x1, y1);            // upper right            //glNormal3f(0, 0, 1);            glTexCoord2f(s2, t2);            glVertex2f(x2, y2);            // lower right            //glNormal3f(0, 0, 1);            glTexCoord2f(s2, t1);            glVertex2f(x2, y1);            glEnd();                                                                                                CHECK_GL_ERRORS();#endif        } // display::draw_rectangle()

void CubeTextureFBO::setTarget(GLuint cubemap_side) {    for (size_t i = 0; i < texture.size(); i++) {        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0+(uint)i, cubemap_side, texture[i], 0);    }    if (store_depths) {        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, cubemap_side, depth, 0);    }    CHECK_GL_ERRORS();    CHECK_GL_FBO_COMPLETENESS();}

void AppManager::setOpenGLStates(){    //glEnable(GL_DEPTH_TEST);	//glDepthFunc(GL_LEQUAL);	glEnable(GL_CULL_FACE);        glViewport(0, 0, window_width, window_height);	glClearColor(0.0, 0.0, 0.0, 1.0);        CHECK_GL_ERRORS();}

void Leave2DMode(){#ifdef OPENGL_TRACECHECK_GL_ERRORS();#endif //OPENGL_TRACE	glMatrixMode(GL_MODELVIEW);	glPopMatrix();	glMatrixMode(GL_PROJECTION);	glPopMatrix();	glMatrixMode(GL_MODELVIEW);	glPopAttrib();	glViewport(0, hud_y, window_width-hud_x, window_height-hud_y);	if (use_fog) glEnable(GL_FOG);	else glDisable(GL_FOG);	//glViewport(0, 0, window_width-hud_x, window_height-hud_y);	// Reset The Current Viewport#ifdef OPENGL_TRACECHECK_GL_ERRORS();#endif //OPENGL_TRACE}

static void draw_side_stats_bar(window_info *win, const int x, const int y, const int baselev, const int cur_exp, const int nl_exp, size_t colour){	const int max_len = win->len_x - x - 1;	const int bar_height = win->small_font_len_y - (int)(0.5 + win->current_scale * 2);	int len = max_len - (float)max_len/(float)((float)(nl_exp-exp_lev[baselev])/(float)(nl_exp-cur_exp));	GLfloat colours[2][2][3] = { { {0.11f, 0.11f, 0.11f}, {0.3f, 0.5f, 0.2f} },								 { {0.10f,0.10f,0.80f}, {0.40f,0.40f,1.00f} } };	if (colour > 1)		colour = 0;#ifdef OPENGL_TRACECHECK_GL_ERRORS();#endif //OPENGL_TRACE	glDisable(GL_TEXTURE_2D);	if(len >= 0){		glBegin(GL_QUADS);		//draw the colored section		glColor3fv(colours[colour][0]);		glVertex3i(x, y+bar_height, 0);		glColor3fv(colours[colour][1]);		glVertex3i(x, y, 0);		glColor3fv(colours[colour][1]);		glVertex3i(x+len, y, 0);		glColor3fv(colours[colour][0]);		glVertex3i(x+len, y+bar_height, 0);		glEnd();	}		// draw the bar frame	glColor3f(0.77f, 0.57f, 0.39f);	glBegin(GL_LINE_LOOP);	glVertex3i(x, y, 0);	glVertex3i(x+max_len, y, 0);	glVertex3i(x+max_len, y+bar_height, 0);	glVertex3i(x, y+bar_height, 0);	glEnd();	glEnable(GL_TEXTURE_2D);#ifdef OPENGL_TRACECHECK_GL_ERRORS();#endif //OPENGL_TRACE}

int display_emotes_handler(window_info *win){	int i,pos;	actor *act = get_actor_ptr_from_id(yourself);	static int last_pos=0;	//check if vbar has been moved	pos=vscrollbar_get_pos(emotes_win, EMOTES_SCROLLBAR_ITEMS);	if(pos!=last_pos){		last_pos=pos;		update_selectables();	}	//draw texts	glEnable(GL_TEXTURE_2D);		SET_COLOR(c_orange1);	draw_string_small(20, 15, (unsigned char*)"Categories",1);	draw_string_small(20, emotes_rect_y+30+5, (unsigned char*)"Emotes",1);	for(i=0;i<EMOTES_CATEGORIES;i++){		if(cur_cat==i) SET_COLOR(c_blue2);		else glColor3f(1.0f, 1.0f, 1.0f);		draw_string_small(23, 32+13*i, (unsigned char*)emote_cats[i],1);	}	for(i=0;i<EMOTES_SHOWN;i++){		if(emote_sel[cur_cat]==selectables[i]) SET_COLOR(c_blue2);		else glColor3f(1.0f, 1.0f, 1.0f);		if(cur_cat&&act&&selectables[i]==act->poses[cur_cat-1]) SET_COLOR(c_green1);		if(selectables[i])			draw_string_small(23, 30+emotes_rect_y+20+1+13*i, (unsigned char*)selectables[i]->name,1);	}	glColor3f(0.77f, 0.57f, 0.39f);	//do grids	glDisable(GL_TEXTURE_2D);			rendergrid(1, 1, 20, 30, emotes_rect_x, emotes_rect_y);	rendergrid(1, 1, 20, 30+emotes_rect_y+20, emotes_rect_x2, emotes_rect_y2);	glEnable(GL_TEXTURE_2D);	//draw description	if(emote_sel[cur_cat]){		draw_string_small(20, emotes_menu_y_len-36, emote_str1,2);		draw_string_small(20, emotes_menu_y_len-36+16, emote_str2,1);	}#ifdef OPENGL_TRACECHECK_GL_ERRORS();#endif //OPENGL_TRACE	return 1;	}