void draw_ingame_interface() { #ifdef OPENGL_TRACE CHECK_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_TRACE CHECK_GL_ERRORS(); #endif //OPENGL_TRACE }
void Enter2DModeExtended(int width, int height) { #ifdef OPENGL_TRACE CHECK_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_TRACE CHECK_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_TRACE CHECK_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_TRACE CHECK_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_TRACE CHECK_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_TRACE CHECK_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_TRACE CHECK_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_TRACE CHECK_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_TRACE CHECK_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 OpenGL3Driver::set_default_render_target() { if (current_render_target_ != nullptr) { current_render_target_->disable(); CHECK_GL_ERRORS(); } current_render_target_ = nullptr; }
void switch_from_game_map() { #ifndef NEW_TEXTURES glDeleteTextures(1,&map_text); #ifdef OPENGL_TRACE CHECK_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_TRACE CHECK_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_TRACE CHECK_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_TRACE CHECK_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_TRACE CHECK_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_TRACE CHECK_GL_ERRORS(); #endif //OPENGL_TRACE return 1; }