/* ============= RB_ARB2_CreateDrawInteractions ============= */ void RB_ARB2_CreateDrawInteractions( const drawSurf_t *surf ) { #if !defined(GL_ES_VERSION_2_0) if ( !surf ) { return; } // perform setup here that will be constant for all interactions GL_State( GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE | GLS_DEPTHMASK | backEnd.depthFunc ); // bind the vertex program if ( r_testARBProgram.GetBool() ) { glBindProgramARB( GL_VERTEX_PROGRAM_ARB, VPROG_TEST ); glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, FPROG_TEST ); } else { glBindProgramARB( GL_VERTEX_PROGRAM_ARB, VPROG_INTERACTION ); glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, FPROG_INTERACTION ); } glEnable(GL_VERTEX_PROGRAM_ARB); glEnable(GL_FRAGMENT_PROGRAM_ARB); // enable the vertex arrays glEnableVertexAttribArrayARB( 8 ); glEnableVertexAttribArrayARB( 9 ); glEnableVertexAttribArrayARB( 10 ); glEnableVertexAttribArrayARB( 11 ); glEnableClientState( GL_COLOR_ARRAY ); // texture 0 is the normalization cube map for the vector towards the light GL_SelectTextureNoClient( 0 ); if ( backEnd.vLight->lightShader->IsAmbientLight() ) { globalImages->ambientNormalMap->Bind(); } else { globalImages->normalCubeMapImage->Bind(); } // texture 6 is the specular lookup table GL_SelectTextureNoClient( 6 ); if ( r_testARBProgram.GetBool() ) { globalImages->specular2DTableImage->Bind(); // variable specularity in alpha channel } else { globalImages->specularTableImage->Bind(); } for ( ; surf ; surf=surf->nextOnLight ) { // perform setup here that will not change over multiple interaction passes // set the vertex pointers idDrawVert *ac = (idDrawVert *)vertexCache.Position( surf->geo->ambientCache ); glColorPointer( 4, GL_UNSIGNED_BYTE, sizeof( idDrawVert ), ac->color ); glVertexAttribPointerARB( 11, 3, GL_FLOAT, false, sizeof( idDrawVert ), ac->normal.ToFloatPtr() ); glVertexAttribPointerARB( 10, 3, GL_FLOAT, false, sizeof( idDrawVert ), ac->tangents[1].ToFloatPtr() ); glVertexAttribPointerARB( 9, 3, GL_FLOAT, false, sizeof( idDrawVert ), ac->tangents[0].ToFloatPtr() ); glVertexAttribPointerARB( 8, 2, GL_FLOAT, false, sizeof( idDrawVert ), ac->st.ToFloatPtr() ); glVertexPointer( 3, GL_FLOAT, sizeof( idDrawVert ), ac->xyz.ToFloatPtr() ); // this may cause RB_ARB2_DrawInteraction to be exacuted multiple // times with different colors and images if the surface or light have multiple layers RB_CreateSingleDrawInteractions( surf, RB_ARB2_DrawInteraction ); } glDisableVertexAttribArrayARB( 8 ); glDisableVertexAttribArrayARB( 9 ); glDisableVertexAttribArrayARB( 10 ); glDisableVertexAttribArrayARB( 11 ); glDisableClientState( GL_COLOR_ARRAY ); // disable features GL_SelectTextureNoClient( 6 ); globalImages->BindNull(); GL_SelectTextureNoClient( 5 ); globalImages->BindNull(); GL_SelectTextureNoClient( 4 ); globalImages->BindNull(); GL_SelectTextureNoClient( 3 ); globalImages->BindNull(); GL_SelectTextureNoClient( 2 ); globalImages->BindNull(); GL_SelectTextureNoClient( 1 ); globalImages->BindNull(); backEnd.glState.currenttmu = -1; GL_SelectTexture( 0 ); glDisable(GL_VERTEX_PROGRAM_ARB); glDisable(GL_FRAGMENT_PROGRAM_ARB); #endif }
void Mesh::Render() const { #ifdef IPHONE ASSERT(0); #else // Rebuild rendering data if necessary if (num_groups_ == -1) { short group_v0; bool need_new_group = true; num_groups_ = 0; // Loop through each triangle for (int i = 0; i < num_triangles_; i++) { // Begin a new rendering group if appropriate if (need_new_group) { // Allocate data if necessary if (num_groups_allocated_ <= num_groups_) { num_groups_allocated_ = 3 + num_groups_allocated_*2; group_start_ = (short*)realloc(group_start_, num_groups_allocated_*sizeof(short)); group_size_ = (short*)realloc(group_size_, num_groups_allocated_*sizeof(short)); if (colors_ != 0) { group_is_fixed_color_ = (bool*)realloc(group_is_fixed_color_, num_groups_allocated_*sizeof(bool)); } if (normals_ != 0) { group_is_fixed_normal_ = (bool*)realloc(group_is_fixed_normal_, num_groups_allocated_*sizeof(bool)); } } // Begin the new group group_start_[num_groups_] = i; if (group_is_fixed_color_ != 0) group_is_fixed_color_[num_groups_] = true; if (group_is_fixed_normal_ != 0) group_is_fixed_normal_[num_groups_] = true; group_v0 = vertex_indices_[3*i]; need_new_group = false; } // Process each vertex in this triangle for (int j = 0; j < 3; j++) { int v = vertex_indices_[3*i+j]; if (colors_ != 0 && colors_[v] != colors_[group_v0]) group_is_fixed_color_[num_groups_] = false; if (normals_ != 0 && normals_[v] != normals_[group_v0]) group_is_fixed_normal_[num_groups_] = false; } // End this group if appropriate if (i == num_triangles_-1 || (textures_ != 0 && textures_[i+1] != textures_[i])) { group_size_[num_groups_] = (i+1) - group_start_[num_groups_]; num_groups_++; need_new_group = true; } } } // Render the mesh. First specific the vertex array pointers. glVertexPointer(3, GL_FLOAT, 0, points_); if (normals_ != 0) glNormalPointer(GL_FLOAT, 0, normals_); if (colors_ != 0) glColorPointer(4, GL_FLOAT, 0, colors_); if (texture_coords_ != 0) glTexCoordPointer(2, GL_FLOAT, 0, texture_coords_); // Loop through each rendering group for (int i = 0; i < num_groups_; i++) { int start = group_start_[i], v0 = vertex_indices_[3*start]; // Set the texture if (textures_ != 0 && textures_[start] != 0) { glEnableClientState(GL_TEXTURE_COORD_ARRAY); GlUtils::SetTexture(textures_[start]); } else { glDisableClientState(GL_TEXTURE_COORD_ARRAY); GlUtils::SetNoTexture(); } // Set the normal if (normals_ != 0 && !group_is_fixed_normal_[i]) { glEnableClientState(GL_NORMAL_ARRAY); } else { glDisableClientState(GL_NORMAL_ARRAY); if (normals_ != 0) glNormal3fv(&normals_[3*v0]); } // Set the color if (colors_ != 0 && !group_is_fixed_color_[i]) { glEnableClientState(GL_COLOR_ARRAY); } else { glDisableClientState(GL_COLOR_ARRAY); if (colors_ != 0) glColor4fv(&colors_[4*v0]); } // Render the group glDrawElements(GL_TRIANGLES, 3*group_size_[i], GL_UNSIGNED_SHORT, vertex_indices_ + 3*group_start_[i]); } GlUtils::SetNoTexture(); #endif }
static void APIENTRY logColorPointer( GLint size, GLenum type, GLsizei stride, const void* pointer ) { QGL_Log( "glColorPointer( %d, %s, %d, MEM )\n", size, TypeToString( type ), stride ); glColorPointer( size, type, stride, pointer ); }
void Texture2D::draw() { #if USE_OPENGL1 glDisable(GL_LIGHTING); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnable(GL_TEXTURE_2D); // texture transparency glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); #endif glVertexPointer(2, GL_FLOAT, 0, _vertices); glColorPointer(4, GL_UNSIGNED_BYTE, 0, _colors); #if USE_OPENGL1 // Render using the appropriate version of OpenGL // glScalef(kObjectScale, kObjectScale, kObjectScale); // Draw object glTranslatef(_position[0], _position[1], 0.0); //glRotatef(-obj3D.rotation, 0, 0, 1); //glScalef(obj3D.scale, obj3D.scale, 1.0); glBindTexture(GL_TEXTURE_2D, _textureID); glVertexPointer(2, GL_FLOAT, 0, (const GLvoid*)vertices); glTexCoordPointer(2, GL_FLOAT, 0, (const GLvoid*)texCoords); // glNormalPointer(GL_FLOAT, 0, (const GLvoid*)obj3D.normals); glDrawElements(GL_TRIANGLES, obj3D.numIndices, GL_UNSIGNED_SHORT, (const GLvoid*)obj3D.indices); #else // OpenGL 2 glUseProgram(_shaderProgramID); glVertexAttribPointer(_vertexHandle, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid*)_vertices); // glVertexAttribPointer(_normalHandle, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid*)_normals); glVertexAttribPointer(_textureCoordHandle, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid*)_indices); glEnableVertexAttribArray(_vertexHandle); // glEnableVertexAttribArray(_normalHandle); glEnableVertexAttribArray(_textureCoordHandle); /* TODO glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, _textureID); // TODO glUniformMatrix4fv(mvpMatrixHandle, 1, GL_FALSE, (const GLfloat*)&modelViewProjection.data[0]); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (const GLvoid*)squareIndices); */ #endif glDisable(GL_BLEND); glDisable(GL_DEPTH_TEST); glDisable(GL_CULL_FACE); #if USE_OPENGL1 glDisable(GL_TEXTURE_2D); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); #else glDisableVertexAttribArray( _vertexHandle ); glDisableVertexAttribArray( _normalHandle ); glDisableVertexAttribArray( _textureCoordHandle ); #endif }
bool cgfxVaryingParameter::bind(const sourceStreamInfo& source) const { // should assert(dataBufferId > 0) here // ... static MGLFunctionTable *gGLFT = 0; if ( 0 == gGLFT ) gGLFT = MHardwareRenderer::theRenderer()->glFunctionTable(); const unsigned int stride = source.fStride; const unsigned int offset = source.fOffset; const unsigned int dimension = source.fDimension; const unsigned int elementSize = source.fElementSize; const GLuint bufferId = source.fDataBufferId; gGLFT->glBindBufferARB(MGL_ARRAY_BUFFER_ARB, bufferId); #define GLOBJECT_BUFFER_OFFSET(i) ((char *)NULL + (i)) // For GLObject offsets switch( fGLType) { case glRegister::kPosition: glStateCache::instance().enablePosition(); glVertexPointer(dimension, GL_FLOAT, stride*elementSize, GLOBJECT_BUFFER_OFFSET(offset)); break; case glRegister::kNormal: glStateCache::instance().enableNormal(); glNormalPointer(GL_FLOAT, stride*elementSize, GLOBJECT_BUFFER_OFFSET(offset)); break; case glRegister::kTexCoord: if( fGLIndex < glStateCache::sMaxTextureUnits) { glStateCache::instance().enableAndActivateTexCoord( fGLIndex); glTexCoordPointer(dimension, GL_FLOAT, stride*elementSize, GLOBJECT_BUFFER_OFFSET(offset)); } break; case glRegister::kColor: glStateCache::instance().enableColor(); glColorPointer(dimension, GL_FLOAT, stride*elementSize, GLOBJECT_BUFFER_OFFSET(offset)); break; case glRegister::kSecondaryColor: glStateCache::instance().enableSecondaryColor(); if( glStateCache::glVertexAttribPointer) glStateCache::glSecondaryColorPointer(dimension, GL_FLOAT, stride*elementSize, GLOBJECT_BUFFER_OFFSET(offset)); break; case glRegister::kVertexAttrib: glStateCache::instance().enableVertexAttrib( fGLIndex); if( glStateCache::glVertexAttribPointer) glStateCache::glVertexAttribPointer( fGLIndex, dimension, GL_FLOAT, GL_FALSE, stride*elementSize, GLOBJECT_BUFFER_OFFSET(offset)); if(source.fSourceType == cgfxVertexAttribute::kPosition) { glStateCache::instance().enablePosition(); glVertexPointer(dimension, GL_FLOAT, stride*elementSize, GLOBJECT_BUFFER_OFFSET(offset)); } break; /// TODO add secondaryColor, vertexWeight, vertexAttrib, fog default: return false; //these we don't support yet } return true; }
// virtual (default) void LLVertexBuffer::setupVertexBuffer(U32 data_mask) const { LLMemType mt(LLMemType::MTYPE_VERTEX_DATA); stop_glerror(); volatile U8* base = useVBOs() ? NULL : mMappedData; S32 stride = mStride; if ((data_mask & mTypeMask) != data_mask) { llerrs << "LLVertexBuffer::setupVertexBuffer missing required components for supplied data mask." << llendl; } if (data_mask & MAP_NORMAL) { glNormalPointer(GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_NORMAL])); } if (data_mask & MAP_TEXCOORD3) { glClientActiveTextureARB(GL_TEXTURE3_ARB); glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD3])); glClientActiveTextureARB(GL_TEXTURE0_ARB); } if (data_mask & MAP_TEXCOORD2) { glClientActiveTextureARB(GL_TEXTURE2_ARB); glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD2])); glClientActiveTextureARB(GL_TEXTURE0_ARB); } if (data_mask & MAP_TEXCOORD1) { glClientActiveTextureARB(GL_TEXTURE1_ARB); glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD1])); glClientActiveTextureARB(GL_TEXTURE0_ARB); } if (data_mask & MAP_BINORMAL) { glClientActiveTextureARB(GL_TEXTURE2_ARB); glTexCoordPointer(3,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_BINORMAL])); glClientActiveTextureARB(GL_TEXTURE0_ARB); } if (data_mask & MAP_TEXCOORD0) { glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD0])); } if (data_mask & MAP_COLOR) { glColorPointer(4, GL_UNSIGNED_BYTE, stride, (void*)(base + mOffsets[TYPE_COLOR])); } if (data_mask & MAP_WEIGHT) { glVertexAttribPointerARB(1, 1, GL_FLOAT, FALSE, stride, (void*)(base + mOffsets[TYPE_WEIGHT])); } if (data_mask & MAP_CLOTHWEIGHT) { glVertexAttribPointerARB(4, 4, GL_FLOAT, TRUE, stride, (void*)(base + mOffsets[TYPE_CLOTHWEIGHT])); } if (data_mask & MAP_VERTEX) { glVertexPointer(3,GL_FLOAT, stride, (void*)(base + 0)); } llglassertok(); }
void drawContext::drawView() { OrthofFromGModel(); glMatrixMode(GL_MODELVIEW); // fill the background glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); if(CTX::instance()->bgGradient){ glPushMatrix(); glLoadIdentity(); const GLfloat squareVertices[] = { (GLfloat)_top, (GLfloat)_left, 2*_far, (GLfloat)_top, (GLfloat)_right, 2*_far, (GLfloat)_bottom, (GLfloat)_left, 2*_far, (GLfloat)_bottom, (GLfloat)_right, 2*_far, }; const GLubyte squareColors[] = { 255, 255, 255, 255, 255, 255, 255, 255, 190, 200, 255, 255, 190, 200, 255, 255, }; glVertexPointer(3, GL_FLOAT, 0, squareVertices); glEnableClientState(GL_VERTEX_ARRAY); glColorPointer(4, GL_UNSIGNED_BYTE, 0, squareColors); glEnableClientState(GL_COLOR_ARRAY); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); glPopMatrix(); } checkGlError("Draw background"); glLoadIdentity(); glScalef(_scale[0], _scale[1], _scale[2]); glTranslatef(_translate[0], _translate[1], _translate[2]); if(CTX::instance()->rotationCenterCg) glTranslatef(CTX::instance()->cg[0], CTX::instance()->cg[1], CTX::instance()->cg[2]); else glTranslatef(CTX::instance()->rotationCenter[0], CTX::instance()->rotationCenter[1], CTX::instance()->rotationCenter[2]); buildRotationMatrix(); glMultMatrixf(_rotatef); if(CTX::instance()->rotationCenterCg) glTranslatef(-CTX::instance()->cg[0], -CTX::instance()->cg[1], -CTX::instance()->cg[2]); else glTranslatef(-CTX::instance()->rotationCenter[0], -CTX::instance()->rotationCenter[1], -CTX::instance()->rotationCenter[2]); checkGlError("Initialize position"); glEnable(GL_DEPTH_TEST); drawMesh(); checkGlError("Draw mesh"); drawGeom(); checkGlError("Draw geometry"); drawPost(); checkGlError("Draw post-pro"); glDisable(GL_DEPTH_TEST); drawScale(); checkGlError("Draw scales"); drawAxes(); checkGlError("Draw axes"); }
//---------------------------------------------------------- void ofGLRenderer::draw(ofMesh & vertexData, ofPolyRenderMode renderType, bool useColors, bool useTextures, bool useNormals){ if (bSmoothHinted) startSmoothing(); #ifndef TARGET_OPENGLES glPushAttrib(GL_POLYGON_BIT); glPolygonMode(GL_FRONT_AND_BACK, ofGetGLPolyMode(renderType)); draw(vertexData,useColors,useTextures,useNormals); glPopAttrib(); //TODO: GLES doesnt support polygon mode, add renderType to gl renderer? #else if(vertexData.getNumVertices()){ glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(3, GL_FLOAT, sizeof(ofVec3f), vertexData.getVerticesPointer()); } if(vertexData.getNumNormals() && useNormals){ glEnableClientState(GL_NORMAL_ARRAY); glNormalPointer(GL_FLOAT, 0, vertexData.getNormalsPointer()); } if(vertexData.getNumColors() && useColors){ glEnableClientState(GL_COLOR_ARRAY); glColorPointer(4,GL_FLOAT, sizeof(ofFloatColor), vertexData.getColorsPointer()); } if(vertexData.getNumTexCoords() && useTextures){ set<int>::iterator textureLocation = textureLocationsEnabled.begin(); for(;textureLocation!=textureLocationsEnabled.end();textureLocation++){ glActiveTexture(GL_TEXTURE0+*textureLocation); glClientActiveTexture(GL_TEXTURE0+*textureLocation); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(2, GL_FLOAT, sizeof(ofVec2f), &vertexData.getTexCoordsPointer()->x); } glActiveTexture(GL_TEXTURE0); glClientActiveTexture(GL_TEXTURE0); } GLenum drawMode; switch(renderType){ case OF_MESH_POINTS: drawMode = GL_POINTS; break; case OF_MESH_WIREFRAME: drawMode = GL_LINES; break; case OF_MESH_FILL: drawMode = ofGetGLPrimitiveMode(vertexData.getMode()); break; default: drawMode = ofGetGLPrimitiveMode(vertexData.getMode()); break; } if(vertexData.getNumIndices()){ glDrawElements(drawMode, vertexData.getNumIndices(),GL_UNSIGNED_SHORT,vertexData.getIndexPointer()); }else{ glDrawArrays(drawMode, 0, vertexData.getNumVertices()); } if(vertexData.getNumColors() && useColors){ glDisableClientState(GL_COLOR_ARRAY); } if(vertexData.getNumNormals() && useNormals){ glDisableClientState(GL_NORMAL_ARRAY); } if(vertexData.getNumTexCoords() && useTextures){ glDisableClientState(GL_TEXTURE_COORD_ARRAY); } #endif if (bSmoothHinted) endSmoothing(); }
// This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure) // If text or lines are blurry when integrating ImGui in your engine: // - in your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f) void ImGui_ImplSdl_RenderDrawLists(ImDrawData* draw_data) { // We are using the OpenGL fixed pipeline to make the example code simpler to read! // A probable faster way to render would be to collate all vertices from all cmd_lists into a single vertex buffer. // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers. glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TRANSFORM_BIT); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glEnable(GL_SCISSOR_TEST); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glEnable(GL_TEXTURE_2D); //glUseProgram(0); // You may want this if using this code in an OpenGL 3+ context // Setup orthographic projection matrix const float width = ImGui::GetIO().DisplaySize.x; const float height = ImGui::GetIO().DisplaySize.y; glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrtho(0.0f, width, height, 0.0f, -1.0f, +1.0f); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); // Render command lists #define OFFSETOF(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT)) for (int n = 0; n < draw_data->CmdListsCount; n++) { const ImDrawList* cmd_list = draw_data->CmdLists[n]; const unsigned char* vtx_buffer = (const unsigned char*)&cmd_list->VtxBuffer.front(); const ImDrawIdx* idx_buffer = &cmd_list->IdxBuffer.front(); glVertexPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, pos))); glTexCoordPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, uv))); glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, col))); for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.size(); cmd_i++) { const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i]; if (pcmd->UserCallback) { pcmd->UserCallback(cmd_list, pcmd); } else { glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId); glScissor((int)pcmd->ClipRect.x, (int)(height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y)); glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, GL_UNSIGNED_SHORT, idx_buffer); } idx_buffer += pcmd->ElemCount; } } #undef OFFSETOF // Restore modified state glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); glBindTexture(GL_TEXTURE_2D, 0); glMatrixMode(GL_MODELVIEW); glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); glPopAttrib(); }
int main(int argc, char *argv[]) { SDL_Init(SDL_INIT_VIDEO); displayWindow = SDL_CreateWindow("My Game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, SDL_WINDOW_OPENGL); SDL_GLContext context = SDL_GL_CreateContext(displayWindow); SDL_GL_MakeCurrent(displayWindow, context); bool done = false; SDL_Event event; glViewport(0, 0, 800, 600); glMatrixMode(GL_PROJECTION); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(0.0, 0.0, 0.0); glOrtho(-1.33, 1.33, -1.0, 1.0, -1.0, 1.0); //multiplies current matrix GLuint texture; GLuint texture2; GLuint texture3; texture = LoadTexture("gear.png"); texture2 = LoadTexture("shocked.png"); texture3 = LoadTexture("rocket.png"); float lastFrameTicks = 0.0f; float increment = 0.0f; while (!done) { while (SDL_PollEvent(&event)) { if (event.type == SDL_QUIT || event.type == SDL_WINDOWEVENT_CLOSE) { done = true; } } glClearColor(1.0, 1.0, 1.0, 0.0); glClear(GL_COLOR_BUFFER_BIT); glDrawArrays(GL_QUADS, 0, 4); float ticks = (float)SDL_GetTicks() / 1000.0f; float elapsed = ticks - lastFrameTicks; lastFrameTicks = ticks; increment += ticks; DrawSprite(texture, -0.1, 0.4, lastFrameTicks * 100.0); DrawSprite(texture, -0.7, -0.4, -lastFrameTicks * 100.0); DrawSprite2(texture2, (increment/200)-0.9, 0.0, 0.0); DrawSprite(texture3, (increment/200)-1.3, 0.0, 0.0); glLoadIdentity(); GLfloat redblock[] = { 0.25f, 0.25f, -0.25f, 0.25f, -0.25f, 0.1f, 0.25f, 0.1f }; glVertexPointer(2, GL_FLOAT, 0, redblock); glEnableClientState(GL_VERTEX_ARRAY); GLfloat blockColor[] = { 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f }; glColorPointer(3, GL_FLOAT, 0, blockColor); glEnableClientState(GL_COLOR_ARRAY); glTranslated(1.0, 0.0, 0.0); glRotatef(90.0f, 0.0f, 0.0f, 1.0f); glDrawArrays(GL_QUADS,0,4); glDisableClientState(GL_COLOR_ARRAY); SDL_GL_SwapWindow(displayWindow); } SDL_Quit(); return 0; }
// OpenGL2 Render function. // (this used to be set in io.RenderDrawListsFn and called by ImGui::Render(), but you can now call this directly from your main loop) // Note that this implementation is little overcomplicated because we are saving/setting up/restoring every OpenGL state explicitly, in order to be able to run within any OpenGL engine that doesn't do so. void ImGui_ImplGlfwGL2_RenderDrawData(ImDrawData* draw_data) { // Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates) ImGuiIO& io = ImGui::GetIO(); int fb_width = (int)(io.DisplaySize.x * io.DisplayFramebufferScale.x); int fb_height = (int)(io.DisplaySize.y * io.DisplayFramebufferScale.y); if (fb_width == 0 || fb_height == 0) return; draw_data->ScaleClipRects(io.DisplayFramebufferScale); // We are using the OpenGL fixed pipeline to make the example code simpler to read! // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers, polygon fill. GLint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture); GLint last_polygon_mode[2]; glGetIntegerv(GL_POLYGON_MODE, last_polygon_mode); GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport); GLint last_scissor_box[4]; glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box); glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TRANSFORM_BIT); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glEnable(GL_SCISSOR_TEST); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glEnable(GL_TEXTURE_2D); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); //glUseProgram(0); // You may want this if using this code in an OpenGL 3+ context where shaders may be bound // Setup viewport, orthographic projection matrix glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrtho(0.0f, io.DisplaySize.x, io.DisplaySize.y, 0.0f, -1.0f, +1.0f); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); // Render command lists for (int n = 0; n < draw_data->CmdListsCount; n++) { const ImDrawList* cmd_list = draw_data->CmdLists[n]; const ImDrawVert* vtx_buffer = cmd_list->VtxBuffer.Data; const ImDrawIdx* idx_buffer = cmd_list->IdxBuffer.Data; glVertexPointer(2, GL_FLOAT, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + IM_OFFSETOF(ImDrawVert, pos))); glTexCoordPointer(2, GL_FLOAT, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + IM_OFFSETOF(ImDrawVert, uv))); glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + IM_OFFSETOF(ImDrawVert, col))); for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++) { const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i]; if (pcmd->UserCallback) { pcmd->UserCallback(cmd_list, pcmd); } else { glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId); glScissor((int)pcmd->ClipRect.x, (int)(fb_height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y)); glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer); } idx_buffer += pcmd->ElemCount; } } // Restore modified state glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); glBindTexture(GL_TEXTURE_2D, (GLuint)last_texture); glMatrixMode(GL_MODELVIEW); glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); glPopAttrib(); glPolygonMode(GL_FRONT, (GLenum)last_polygon_mode[0]); glPolygonMode(GL_BACK, (GLenum)last_polygon_mode[1]); glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]); glScissor(last_scissor_box[0], last_scissor_box[1], (GLsizei)last_scissor_box[2], (GLsizei)last_scissor_box[3]); }
void MeshRenderer :: renderToImage(cv::Mat4b& image, int flags) { ntk_assert(m_vertex_buffer_object.initialized, "Renderer not initialized! Call setPose and setMesh."); ntk::TimeCount tc_gl_current("make_current", 2); m_pbuffer->makeCurrent(); tc_gl_current.stop(); ntk::TimeCount tc_gl_render("gl_render", 2); if (flags & WIREFRAME) glPolygonMode( GL_FRONT_AND_BACK, GL_LINE ); VertexBufferObject& vbo = m_vertex_buffer_object; glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo.vertex_id); if (vbo.has_texcoords) { glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, vbo.texture_id); } else { glDisable(GL_TEXTURE_2D); } if (vbo.has_texcoords) glEnableClientState(GL_TEXTURE_COORD_ARRAY); if (vbo.has_color) glEnableClientState(GL_COLOR_ARRAY); else glColor3f(1.0f,0.f,0.f); glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(3, GL_FLOAT, 0, 0); if (vbo.has_color) glColorPointer(3, GL_UNSIGNED_BYTE, 0, ((char*) NULL) + vbo.color_offset); if (vbo.has_texcoords) glTexCoordPointer(2, GL_FLOAT, 0, ((char*) NULL) + vbo.texture_offset); if (vbo.has_faces) { glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, vbo.faces_id); glNormal3f(0, 0, 1); glDrawElements(GL_TRIANGLES, vbo.nb_faces*3, GL_UNSIGNED_INT, 0); } else { glDrawArrays(GL_POINTS, 0, vbo.nb_vertices); } glDisableClientState(GL_VERTEX_ARRAY); if (vbo.has_color) glDisableClientState(GL_COLOR_ARRAY); if (vbo.has_texcoords) glDisableClientState(GL_TEXTURE_COORD_ARRAY); // bind with 0, so, switch back to normal pointer operation glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); if (vbo.has_faces) { glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0); } glFinish(); tc_gl_render.stop(); ntk::TimeCount tc_image("to_image", 2); QImage qimage = m_pbuffer->toImage(); tc_image.stop(); ntk::TimeCount tc_depth_buffer("compute_depth_buffer", 2); computeDepthBuffer(); tc_depth_buffer.stop(); ntk::TimeCount tc_convert("convert_to_cv", 2); for (int r = 0; r < qimage.height(); ++r) for (int c = 0; c < qimage.width(); ++c) { QRgb pixel = qimage.pixel(c,r); Vec4b color (qBlue(pixel), qGreen(pixel), qRed(pixel), qAlpha(pixel)); m_color_buffer(r,c) = color; float a = qAlpha(pixel)/255.f; if (a > 0) { Vec4b old_color = image(r,c); image(r,c) = Vec4b(old_color[0]*(1-a) + color[0]*a, old_color[1]*(1-a) + color[1]*a, old_color[2]*(1-a) + color[2]*a, 255); } } tc_convert.stop(); }
static void drawArrays(drawContext *ctx, GEntity *e, VertexArray *va, GLint type, bool useNormalArray, int forceColor=0, unsigned int color=0) { if(!va || !va->getNumVertices()) return; // If we want to be enable picking of individual elements we need to // draw each one separately bool select = (ctx->render_mode == drawContext::GMSH_SELECT && CTX::instance()->pickElements && e->model() == GModel::current()); if(select) { if(va->getNumElementPointers() == va->getNumVertices()){ for(int i = 0; i < va->getNumVertices(); i += va->getNumVerticesPerElement()){ glPushName(va->getNumVerticesPerElement()); glPushName(i); glBegin(type); for(int j = 0; j < va->getNumVerticesPerElement(); j++) glVertex3fv(va->getVertexArray(3 * (i + j))); glEnd(); glPopName(); glPopName(); } return; } } glVertexPointer(3, GL_FLOAT, 0, va->getVertexArray()); glEnableClientState(GL_VERTEX_ARRAY); if(useNormalArray){ glEnable(GL_LIGHTING); glNormalPointer(GL_BYTE, 0, va->getNormalArray()); glEnableClientState(GL_NORMAL_ARRAY); } else glDisableClientState(GL_NORMAL_ARRAY); if(forceColor){ glDisableClientState(GL_COLOR_ARRAY); glColor4ubv((GLubyte *) & color); } else if(CTX::instance()->pickElements || (!e->getSelection() && (CTX::instance()->mesh.colorCarousel == 0 || CTX::instance()->mesh.colorCarousel == 3))){ glColorPointer(4, GL_UNSIGNED_BYTE, 0, va->getColorArray()); glEnableClientState(GL_COLOR_ARRAY); } else{ glDisableClientState(GL_COLOR_ARRAY); color = getColorByEntity(e); glColor4ubv((GLubyte *) & color); } if(va->getNumVerticesPerElement() > 2 && CTX::instance()->polygonOffset) glEnable(GL_POLYGON_OFFSET_FILL); glDrawArrays(type, 0, va->getNumVertices()); glDisable(GL_POLYGON_OFFSET_FILL); glDisable(GL_LIGHTING); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); glDisableClientState(GL_COLOR_ARRAY); }
void CCParticleSystemPoint::draw() { if (m_nParticleIdx==0) { return; } // Default GL states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY // Needed states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY // Unneeded states: GL_TEXTURE_COORD_ARRAY glDisableClientState(GL_TEXTURE_COORD_ARRAY); glBindTexture(GL_TEXTURE_2D, m_pTexture->getName()); glEnable(GL_POINT_SPRITE_OES); glTexEnvi( GL_POINT_SPRITE_OES, GL_COORD_REPLACE_OES, GL_TRUE ); #define kPointSize sizeof(m_pVertices[0]) #if CC_USES_VBO glBindBuffer(GL_ARRAY_BUFFER, m_uVerticesID); #if CC_ENABLE_CACHE_TEXTTURE_DATA glBufferData(GL_ARRAY_BUFFER, sizeof(ccPointSprite)*m_nTotalParticles, m_pVertices, GL_DYNAMIC_DRAW); #endif glVertexPointer(2,GL_FLOAT,kPointSize,0); glColorPointer(4, GL_FLOAT, kPointSize,(GLvoid*) offsetof(ccPointSprite,colors) ); glEnableClientState(GL_POINT_SIZE_ARRAY_OES); glPointSizePointerOES(GL_FLOAT,kPointSize,(GLvoid*) offsetof(ccPointSprite,size) ); #else // Uses Vertex Array List int offset = (int)m_pVertices; glVertexPointer(2,GL_FLOAT, kPointSize, (GLvoid*) offset); int diff = offsetof(ccPointSprite, colors); glColorPointer(4, GL_FLOAT, kPointSize, (GLvoid*) (offset+diff)); glEnableClientState(GL_POINT_SIZE_ARRAY_OES); diff = offsetof(ccPointSprite, size); glPointSizePointerOES(GL_FLOAT, kPointSize, (GLvoid*) (offset+diff)); #endif bool newBlend = (m_tBlendFunc.src != CC_BLEND_SRC || m_tBlendFunc.dst != CC_BLEND_DST) ? true : false; if( newBlend ) { glBlendFunc( m_tBlendFunc.src, m_tBlendFunc.dst ); } glDrawArrays(GL_POINTS, 0, m_nParticleIdx); // restore blend state if( newBlend ) glBlendFunc( CC_BLEND_SRC, CC_BLEND_DST); #if CC_USES_VBO // unbind VBO buffer glBindBuffer(GL_ARRAY_BUFFER, 0); #endif glDisableClientState(GL_POINT_SIZE_ARRAY_OES); glDisable(GL_POINT_SPRITE_OES); // restore GL default state glEnableClientState(GL_TEXTURE_COORD_ARRAY); }
void RudeSkinnedMesh::Render() { RUDE_PERF_START(kPerfRudeSkinMeshRender); //int numbonemats; //glGetIntegerv(GL_MAX_PALETTE_MATRICES_OES, &numbonemats); //printf("bonemats %d\n", numbonemats); glMatrixMode(GL_MODELVIEW); PVRTMATRIX viewmat; glGetFloatv(GL_MODELVIEW_MATRIX, viewmat.f); RGL.Enable(kBackfaceCull, true); glCullFace(GL_FRONT); glFrontFace(GL_CW); //glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); //glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); RGL.EnableClient(kVertexArray, true); RGL.EnableClient(kTextureCoordArray, true); //glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE); if(m_animate) { glEnable(GL_MATRIX_PALETTE_OES); glEnableClientState(GL_MATRIX_INDEX_ARRAY_OES); glEnableClientState(GL_WEIGHT_ARRAY_OES); } //glScalef(m_scale.x(), m_scale.y(), m_scale.z()); for(int i = 0; i < m_model.nNumNode; i++) { SPODNode *node = &m_model.pNode[i]; if(!node->pszName) continue; if(node->pszName[0] != 'M') continue; SPODMaterial *material = &m_model.pMaterial[node->nIdxMaterial]; SPODMesh *mesh = &m_model.pMesh[node->nIdx]; if(m_animate) { glMatrixIndexPointerOES(mesh->sBoneIdx.n, GL_UNSIGNED_BYTE, mesh->sBoneIdx.nStride, mesh->pInterleaved + (long) mesh->sBoneIdx.pData); glWeightPointerOES(mesh->sBoneWeight.n, GL_FLOAT, mesh->sBoneWeight.nStride, mesh->pInterleaved + (long) mesh->sBoneWeight.pData); } int textureid = material->nIdxTexDiffuse; if(textureid >= 0) RudeTextureManager::GetInstance()->SetTexture(m_textures[textureid]); unsigned short *indices = (unsigned short*) mesh->sFaces.pData; glVertexPointer(3, GL_FLOAT, mesh->sVertex.nStride, mesh->pInterleaved + (long)mesh->sVertex.pData); glTexCoordPointer(2, GL_FLOAT, mesh->psUVW->nStride, mesh->pInterleaved + (long)mesh->psUVW->pData); if((mesh->sVtxColours.n > 0) && (mesh->sVtxColours.eType == EPODDataRGBA)) { RGL.EnableClient(kColorArray, true); glColorPointer(4, GL_UNSIGNED_BYTE, mesh->sVtxColours.nStride, mesh->pInterleaved + (long)mesh->sVtxColours.pData); } else RGL.EnableClient(kColorArray, false); int totalbatchcnt = 0; for(int b = 0; b < mesh->sBoneBatches.nBatchCnt; b++) { int batchcnt = mesh->sBoneBatches.pnBatchBoneCnt[b]; if(m_animate) { glMatrixMode(GL_MATRIX_PALETTE_OES); for(int j = 0; j < batchcnt; ++j) { glCurrentPaletteMatrixOES(j); // Generates the world matrix for the given bone in this batch. PVRTMATRIX mBoneWorld; int i32NodeID = mesh->sBoneBatches.pnBatches[j + totalbatchcnt]; m_model.GetBoneWorldMatrix(mBoneWorld, *node, m_model.pNode[i32NodeID]); // Multiply the bone's world matrix by the view matrix to put it in view space PVRTMatrixMultiply(mBoneWorld, mBoneWorld, viewmat); // Load the bone matrix into the current palette matrix. glLoadMatrixf(mBoneWorld.f); } } totalbatchcnt += batchcnt; int offset = mesh->sBoneBatches.pnBatchOffset[b] * 3; int end = mesh->sBoneBatches.pnBatchOffset[b+1] * 3; if(b == (mesh->sBoneBatches.nBatchCnt - 1)) end = mesh->nNumFaces*3; int numidx = (end - offset); glDrawElements(GL_TRIANGLES, numidx, GL_UNSIGNED_SHORT, &indices[offset]); } } glDisable(GL_MATRIX_PALETTE_OES); glDisableClientState(GL_MATRIX_INDEX_ARRAY_OES); glDisableClientState(GL_WEIGHT_ARRAY_OES); RUDE_PERF_STOP(kPerfRudeSkinMeshRender); }
void VertexArrayRenderer::DisplayImpl() const { if( m_alpha_threshold > 0.f ) { glAlphaFunc( GL_GREATER, m_alpha_threshold ); glEnable( GL_ALPHA_TEST ); } if( m_dirty ) { // Disclaimer: // const_cast IS safe to use in ANY non-static method of // Renderer. Because we make sure that the only instance // that can be constructed is the singleton instance and // that the singleton instance is non-const, we don't have // to fear that some member variable is non-mutable. This // is a nice hack to please certain people who require const // methods in the most exotic places without having to declare // half the member variables and methods as mutable. Then // again this might be all wrong... // Refresh array data if out of sync const_cast<VertexArrayRenderer*>( this )->RefreshArray(); } glVertexPointer( 2, GL_FLOAT, 0, &m_vertex_data[0] ); glColorPointer( 4, GL_UNSIGNED_BYTE, 0, &m_color_data[0] ); glTexCoordPointer( 2, GL_FLOAT, 0, &m_texture_data[0] ); // Not needed, constantly kept enabled by SFML... -_- //glEnableClientState( GL_VERTEX_ARRAY ); //glEnableClientState( GL_COLOR_ARRAY ); //glEnableClientState( GL_TEXTURE_COORD_ARRAY ); glEnable( GL_SCISSOR_TEST ); std::size_t current_atlas_page = 0; sf::Texture::bind( m_texture_atlas[0].get() ); for( const auto& batch : m_batches ) { auto viewport = batch.viewport; if( batch.custom_draw ) { sf::Vector2i destination( viewport->GetDestinationOrigin() ); sf::Vector2u size( viewport->GetSize() ); glViewport( destination.x, m_window_size.y - destination.y - size.y, size.x, size.y ); // Draw canvas. ( *batch.custom_draw_callback )(); glViewport( 0, 0, m_window_size.x, m_window_size.y ); sf::Texture::bind( m_texture_atlas[current_atlas_page].get() ); } else { if( viewport && ( ( *viewport ) != ( *m_default_viewport ) ) ) { auto destination_origin = viewport->GetDestinationOrigin(); auto size = viewport->GetSize(); glScissor( static_cast<int>( destination_origin.x ), m_window_size.y - static_cast<int>( destination_origin.y + size.y ), static_cast<int>( size.x ), static_cast<int>( size.y ) ); } else { glScissor( 0, 0, m_window_size.x, m_window_size.y ); } if( batch.index_count ) { if( batch.atlas_page != current_atlas_page ) { current_atlas_page = batch.atlas_page; sf::Texture::bind( m_texture_atlas[current_atlas_page].get() ); } glDrawElements( GL_TRIANGLES, batch.index_count, GL_UNSIGNED_INT, reinterpret_cast<const char*>( &m_index_data[0] ) + ( batch.start_index * sizeof( GLuint ) ) ); } } } glDisable( GL_SCISSOR_TEST ); //glDisableClientState( GL_TEXTURE_COORD_ARRAY ); //glDisableClientState( GL_COLOR_ARRAY ); //glDisableClientState( GL_VERTEX_ARRAY ); m_dirty = false; if( m_alpha_threshold > 0.f ) { glDisable( GL_ALPHA_TEST ); glAlphaFunc( GL_GREATER, 0.f ); } }
static void draw(void) { if ( use_ztrick ) { static GLboolean flip = GL_FALSE; static const GLfloat vert[4][3] = { { -1, -1, -0.999 }, { 1, -1, -0.999 }, { 1, 1, -0.999 }, { -1, 1, -0.999 } }; static const GLfloat col[4][3] = { { 1.0, 0.6, 0.0 }, { 1.0, 0.6, 0.0 }, { 0.0, 0.0, 0.0 }, { 0.0, 0.0, 0.0 }, }; if ( flip ) { glDepthRange(0, 0.5); glDepthFunc(GL_LEQUAL); } else { glDepthRange(1.0, 0.4999); glDepthFunc(GL_GEQUAL); } flip = !flip; /* The famous Quake "Z trick" only works when the whole screen is * re-drawn each frame. */ glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-1, 1, -1, 1, -1, 1); glDisable(GL_LIGHTING); glShadeModel(GL_SMOOTH); glEnableClientState( GL_VERTEX_ARRAY ); glEnableClientState( GL_COLOR_ARRAY ); glVertexPointer( 3, GL_FLOAT, 0, vert ); glColorPointer( 3, GL_FLOAT, 0, col ); glDrawArrays( GL_POLYGON, 0, 4 ); glDisableClientState( GL_COLOR_ARRAY ); glDisableClientState( GL_VERTEX_ARRAY ); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glFrustum(-aspectX, aspectX, -aspectY, aspectY, 5.0, 60.0); glEnable(GL_LIGHTING); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(0.0, 0.0, -45.0); } else { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); } glPushMatrix(); glRotatef(view_rotx, 1.0, 0.0, 0.0); glRotatef(view_roty, 0.0, 1.0, 0.0); glRotatef(view_rotz, 0.0, 0.0, 1.0); glPushMatrix(); glTranslatef(-3.0, -2.0, 0.0); glRotatef(angle, 0.0, 0.0, 1.0); glCallList(gear1); glPopMatrix(); glPushMatrix(); glTranslatef(3.1, -2.0, 0.0); glRotatef(-2.0 * angle - 9.0, 0.0, 0.0, 1.0); glCallList(gear2); glPopMatrix(); glPushMatrix(); glTranslatef(-3.1, 4.2, 0.0); glRotatef(-2.0 * angle - 25.0, 0.0, 0.0, 1.0); glCallList(gear3); glPopMatrix(); glPopMatrix(); }
void WoodInit(void) { glClearColor( 0.0f, 0.0f, 0.0f, 0.0f ) ; //set the clear back ground color; glShadeModel(GL_SMOOTH); //GL_FLAT | GL_SMOOTH WoodInitLight(); glEnable(GL_DEPTH_TEST); //start init for tex { //glEnable( GL_TEXTURE_2D ); //glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE ); MakeCheckImage(); glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); glGenTextures( 1, &g_uTexName ); glBindTexture( GL_TEXTURE_2D, g_uTexName ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); glTexImage2D( GL_TEXTURE_2D, 0 , GL_RGBA, G_IMG_TEX_WIDTH,G_IMG_TEX_HEIGHT,0, GL_RGBA, GL_UNSIGNED_BYTE,g_ImgTex ); } //glEnable(GL_MULTISAMPLE_ARB); //glEnable(GL_MULTISAMPLE); //glEnable(GL_POLYGON_SMOOTH); //glEnable(GL_LINE_SMOOTH); //glEnable ( GL_POLYGON_SMOOTH ); //GL_POLYGON_SMOOTH | GL_LINE_SMOOTH //glEnable ( GL_LINE_SMOOTH ); //glHint ( GL_LINE_SMOOTH, GL_DONT_CARE ); //glHint ( GL_POLYGON_SMOOTH, GL_DONT_CARE ); //glEnable ( GL_BLEND ); //glBlendFunc ( GL_SRC_ALPHA_SATURATE, GL_ONE); /* glMatrixMode(GL_PROJECTION); //initialize viewing values... glLoadIdentity(); //?? glOrtho(0.0,1.0,0.0,1.0,-1.0,1.0); //?? */ glLineWidth(2.0); glEnableClientState(GL_COLOR_ARRAY); glEnableClientState(GL_VERTEX_ARRAY); glColorPointer( 4,GL_FLOAT,0,g_colors ); glVertexPointer( 3,GL_FLOAT,0,g_vertices ); //glList Start { g_iCacheList = glGenLists( 1 ); glNewList( g_iCacheList,GL_COMPILE ); //glTexCoord2f(0.0,0.0); glEnable(GL_TEXTURE_2D); glBindTexture( GL_TEXTURE_2D, g_uTexName ); glNormal3f( 0.0f, 0.0f, 1.0f); glDrawElements (GL_POLYGON, 4, GL_UNSIGNED_BYTE, g_indices[0]); //前 glNormal3f( 0.0f, -1.0f, 0.0f); glDrawElements (GL_POLYGON, 4, GL_UNSIGNED_BYTE, g_indices[1]); //下 glNormal3f( 1.0f, 0.0f, 0.0f); glDrawElements (GL_POLYGON, 4, GL_UNSIGNED_BYTE, g_indices[2]); //右 glNormal3f( 0.0f, 1.0f, 0.0f); glDrawElements (GL_POLYGON, 4, GL_UNSIGNED_BYTE, g_indices[3]); //上 glNormal3f( -1.0f, 0.0f, 0.0f); glDrawElements (GL_POLYGON, 4, GL_UNSIGNED_BYTE, g_indices[4]); //左 glNormal3f( 0.0f, 0.0f, -1.0f); glDrawElements (GL_POLYGON, 4, GL_UNSIGNED_BYTE, g_indices[5]); //后 glDisable(GL_TEXTURE_2D); /* //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); glBindTexture( GL_TEXTURE_2D, g_uTexName ); GLUquadricObj * sphere = gluNewQuadric(); gluQuadricOrientation(sphere, GLU_OUTSIDE); gluQuadricNormals(sphere,GLU_SMOOTH); gluQuadricTexture(sphere,GL_TRUE); gluSphere(sphere,1.0,50,50); //glutSolidSphere(1.0,50,50); */ glEndList(); } }
void drawContext::drawScale() { glPushMatrix(); glLoadIdentity(); double size = std::max(_right -_left, _top - _bottom); double width = size / 3.5; double height = size / 10.; double dh = height / 5; // Draw the scale bar int nPview = 0; for(int i=0; i<PView::list.size();i++){ PView *p = PView::list[i]; PViewOptions *opt = p->getOptions(); if(!opt->visible) continue; PViewData *data = p->getData(); double box = width / (opt->nbIso ? opt->nbIso : 1); double xmin = _left + (_right - _left - width)/2.; double ymin = _bottom + 0.7 * height + height * nPview; std::vector<GLfloat> vertex(opt->nbIso*3*4); std::vector<GLubyte> color(opt->nbIso*4*4); for(int i = 0; i < opt->nbIso; i++){ if(opt->intervalsType == PViewOptions::Discrete || opt->intervalsType == PViewOptions::Numeric){ unsigned int col = opt->getColor(i, opt->nbIso); color[i*4*4+0] = color[i*4*4+4] = color[i*4*4+8] = color[i*4*4+12] = (GLubyte)CTX::instance()->unpackRed(col); color[i*4*4+1] = color[i*4*4+5] = color[i*4*4+9] = color[i*4*4+13] = (GLubyte)CTX::instance()->unpackGreen(col); color[i*4*4+2] = color[i*4*4+6] = color[i*4*4+10] = color[i*4*4+14] = (GLubyte)CTX::instance()->unpackBlue(col); color[i*4*4+3] = color[i*4*4+7] = color[i*4*4+11] = color[i*4*4+15] = (GLubyte)CTX::instance()->unpackAlpha(col); vertex[i*3*4+0] = xmin + i * box; vertex[i*3*4+1] = ymin; vertex[i*3*4+2] = 0.; vertex[i*3*4+3] = xmin + i * box; vertex[i*3*4+4] = ymin + dh; vertex[i*3*4+5] = 0.; vertex[i*3*4+6] = xmin + (i + 1) * box; vertex[i*3*4+7] = ymin; vertex[i*3*4+8] = 0.; vertex[i*3*4+9] = xmin + (i + 1) * box; vertex[i*3*4+10] = ymin + dh; vertex[i*3*4+11] = 0.; } else if(opt->intervalsType == PViewOptions::Continuous){ double dv = (opt->tmpMax - opt->tmpMin) / (opt->nbIso ? opt->nbIso : 1); double v1 = opt->tmpMin + i * dv; unsigned int col1 = opt->getColor(v1, opt->tmpMin, opt->tmpMax, true); color[i*4*4+0] = color[i*4*4+4] = (GLubyte)CTX::instance()->unpackRed(col1); color[i*4*4+1] = color[i*4*4+5] = (GLubyte)CTX::instance()->unpackGreen(col1); color[i*4*4+2] = color[i*4*4+6] = (GLubyte)CTX::instance()->unpackBlue(col1); color[i*4*4+3] = color[i*4*4+7] = (GLubyte)CTX::instance()->unpackAlpha(col1); vertex[i*3*4+0] = xmin + i * box; vertex[i*3*4+1] = ymin; vertex[i*3*4+2] = 0.; vertex[i*3*4+3] = xmin + i * box; vertex[i*3*4+4] = ymin + dh; vertex[i*3*4+5] = 0.; double v2 = opt->tmpMin + (i + 1) * dv; unsigned int col2 = opt->getColor(v2, opt->tmpMin, opt->tmpMax, true); color[i*4*4+8] = color[i*4*4+12] = (GLubyte)CTX::instance()->unpackRed(col2); color[i*4*4+9] = color[i*4*4+13] = (GLubyte)CTX::instance()->unpackGreen(col2); color[i*4*4+10] = color[i*4*4+14] = (GLubyte)CTX::instance()->unpackBlue(col2); color[i*4*4+11] = color[i*4*4+15] = (GLubyte)CTX::instance()->unpackAlpha(col2); vertex[i*3*4+6] = xmin + (i + 1) * box; vertex[i*3*4+7] = ymin; vertex[i*3*4+8] = 0.; vertex[i*3*4+9] = xmin + (i + 1) * box; vertex[i*3*4+10] = ymin + dh; vertex[i*3*4+11] = 0.; } else{ unsigned int col = opt->getColor(i, opt->nbIso); color[i*4*4+0] = color[i*4*4+4] = color[i*4*4+8] = color[i*4*4+12] = (GLubyte)CTX::instance()->unpackRed(col); color[i*4*4+1] = color[i*4*4+5] = color[i*4*4+9] = color[i*4*4+13] = (GLubyte)CTX::instance()->unpackGreen(col); color[i*4*4+2] = color[i*4*4+6] = color[i*4*4+10] = color[i*4*4+14] = (GLubyte)CTX::instance()->unpackBlue(col); color[i*4*4+3] = color[i*4*4+7] = color[i*4*4+11] = color[i*4*4+15] = (GLubyte)CTX::instance()->unpackAlpha(col); vertex[i*3*4+0] = xmin + i * box; vertex[i*3*4+1] = ymin; vertex[i*3*4+2] = 0.; vertex[i*3*4+3] = xmin + i * box; vertex[i*3*4+4] = ymin + dh; vertex[i*3*4+5] = 0.; vertex[i*3*4+6] = xmin + (i + 1) * box; vertex[i*3*4+7] = ymin; vertex[i*3*4+8] = 0.; vertex[i*3*4+9] = xmin + (i + 1) * box; vertex[i*3*4+10] = ymin + dh; vertex[i*3*4+11] = 0.; } } glVertexPointer(3, GL_FLOAT, 0, &vertex[0]); glEnableClientState(GL_VERTEX_ARRAY); glColorPointer(4, GL_UNSIGNED_BYTE, 0, &color[0]); glEnableClientState(GL_COLOR_ARRAY); if(opt->intervalsType == PViewOptions::Discrete || opt->intervalsType == PViewOptions::Numeric || opt->intervalsType == PViewOptions::Continuous) glDrawArrays(GL_TRIANGLE_STRIP, 0, opt->nbIso*4); else glDrawArrays(GL_LINES, 0, opt->nbIso*4); glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); char label[1024]; int nt = data->getNumTimeSteps(); if((opt->showTime == 1 && nt > 1) || opt->showTime == 2){ char tmp[256]; sprintf(tmp, opt->format.c_str(), data->getTime(opt->timeStep)); sprintf(label, "%s (%s)", data->getName().c_str(), tmp); } else if((opt->showTime == 3 && nt > 1) || opt->showTime == 4){ sprintf(label, "%s (%d/%d)", data->getName().c_str(), opt->timeStep, data->getNumTimeSteps() - 1); } else{ sprintf(label, "%s", data->getName().c_str()); } drawString lbl(label, 20 * _fontFactor); lbl.draw(xmin + width / 2, ymin + 2.8 * dh, 0., _width/(_right-_left), _height/(_top-_bottom)); drawString val(data->getName().c_str(), 15 * _fontFactor); for(int i = 0; i < 3; i++) { double v = opt->getScaleValue(i, 3, opt->tmpMin, opt->tmpMax); sprintf(label, opt->format.c_str(), v); val.setText(label); val.draw(xmin + i * width/ 2, ymin + 1.5 * dh, 0., _width/(_right-_left), _height/(_top-_bottom)); } nPview++; } glPopMatrix(); }
void OGLRender::Initialize(void) { glMatrixMode(GL_MODELVIEW); OPENGL_CHECK_ERRORS; glLoadIdentity(); OPENGL_CHECK_ERRORS; glViewportWrapper(0, windowSetting.statusBarHeightToUse, windowSetting.uDisplayWidth, windowSetting.uDisplayHeight); OPENGL_CHECK_ERRORS; #if SDL_VIDEO_OPENGL COGLGraphicsContext *pcontext = (COGLGraphicsContext *)(CGraphicsContext::g_pGraphicsContext); if( pcontext->IsExtensionSupported("GL_IBM_texture_mirrored_repeat") ) { OGLXUVFlagMaps[TEXTURE_UV_FLAG_MIRROR].realFlag = GL_MIRRORED_REPEAT_IBM; } else if( pcontext->IsExtensionSupported("ARB_texture_mirrored_repeat") ) { OGLXUVFlagMaps[TEXTURE_UV_FLAG_MIRROR].realFlag = GL_MIRRORED_REPEAT_ARB; } else { OGLXUVFlagMaps[TEXTURE_UV_FLAG_MIRROR].realFlag = GL_REPEAT; } if( pcontext->IsExtensionSupported("GL_ARB_texture_border_clamp") || pcontext->IsExtensionSupported("GL_EXT_texture_edge_clamp") ) { m_bSupportClampToEdge = true; OGLXUVFlagMaps[TEXTURE_UV_FLAG_CLAMP].realFlag = GL_CLAMP_TO_EDGE; } else { m_bSupportClampToEdge = false; OGLXUVFlagMaps[TEXTURE_UV_FLAG_CLAMP].realFlag = GL_CLAMP; } glVertexPointer( 4, GL_FLOAT, sizeof(float)*5, &(g_vtxProjected5[0][0]) ); OPENGL_CHECK_ERRORS; glEnableClientState( GL_VERTEX_ARRAY ); OPENGL_CHECK_ERRORS; if( m_bMultiTexture ) { pglClientActiveTextureARB( GL_TEXTURE0_ARB ); OPENGL_CHECK_ERRORS; glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[0].u) ); OPENGL_CHECK_ERRORS; glEnableClientState( GL_TEXTURE_COORD_ARRAY ); OPENGL_CHECK_ERRORS; pglClientActiveTextureARB( GL_TEXTURE1_ARB ); OPENGL_CHECK_ERRORS; glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[1].u) ); OPENGL_CHECK_ERRORS; glEnableClientState( GL_TEXTURE_COORD_ARRAY ); OPENGL_CHECK_ERRORS; } else { glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[0].u) ); OPENGL_CHECK_ERRORS; glEnableClientState( GL_TEXTURE_COORD_ARRAY ); OPENGL_CHECK_ERRORS; } if (m_bSupportFogCoordExt) { pglFogCoordPointerEXT( GL_FLOAT, sizeof(float)*5, &(g_vtxProjected5[0][4]) ); OPENGL_CHECK_ERRORS; glEnableClientState( GL_FOG_COORDINATE_ARRAY_EXT ); OPENGL_CHECK_ERRORS; glFogi( GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT ); OPENGL_CHECK_ERRORS; glFogi(GL_FOG_MODE, GL_LINEAR); // Fog Mode OPENGL_CHECK_ERRORS; glFogf(GL_FOG_DENSITY, 1.0f); // How Dense Will The Fog Be OPENGL_CHECK_ERRORS; glHint(GL_FOG_HINT, GL_FASTEST); // Fog Hint Value OPENGL_CHECK_ERRORS; glFogi( GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT ); OPENGL_CHECK_ERRORS; glFogf( GL_FOG_START, 0.0f ); OPENGL_CHECK_ERRORS; glFogf( GL_FOG_END, 1.0f ); OPENGL_CHECK_ERRORS; } //glColorPointer( 1, GL_UNSIGNED_BYTE, sizeof(TLITVERTEX), &g_vtxBuffer[0].r); glColorPointer( 4, GL_UNSIGNED_BYTE, sizeof(uint8)*4, &(g_oglVtxColors[0][0]) ); OPENGL_CHECK_ERRORS; glEnableClientState( GL_COLOR_ARRAY ); OPENGL_CHECK_ERRORS; if( pcontext->IsExtensionSupported("GL_NV_depth_clamp") ) { glEnable(GL_DEPTH_CLAMP_NV); OPENGL_CHECK_ERRORS; } #elif SDL_VIDEO_OPENGL_ES2 OGLXUVFlagMaps[TEXTURE_UV_FLAG_MIRROR].realFlag = GL_MIRRORED_REPEAT; m_bSupportClampToEdge = true; OGLXUVFlagMaps[TEXTURE_UV_FLAG_CLAMP].realFlag = GL_CLAMP_TO_EDGE; glVertexAttribPointer(VS_POSITION,4,GL_FLOAT,GL_FALSE,sizeof(float)*5,&(g_vtxProjected5[0][0])); OPENGL_CHECK_ERRORS; if( m_bMultiTexture ) { glVertexAttribPointer(VS_TEXCOORD0,2,GL_FLOAT,GL_FALSE, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[0].u)); OPENGL_CHECK_ERRORS; glVertexAttribPointer(VS_TEXCOORD1,2,GL_FLOAT,GL_FALSE, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[1].u)); OPENGL_CHECK_ERRORS; } else { glVertexAttribPointer(VS_TEXCOORD0,2,GL_FLOAT,GL_FALSE, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[0].u)); OPENGL_CHECK_ERRORS; } if (m_bSupportFogCoordExt) { glVertexAttribPointer(VS_FOG,1,GL_FLOAT,GL_FALSE,sizeof(float)*5,&(g_vtxProjected5[0][4])); OPENGL_CHECK_ERRORS; } glVertexAttribPointer(VS_COLOR, 4, GL_UNSIGNED_BYTE,GL_TRUE, sizeof(uint8)*4, &(g_oglVtxColors[0][0]) ); OPENGL_CHECK_ERRORS; #endif #ifdef PAULSCODE // hardwareType = Android_JNI_GetHardwareType(); #endif }
void output(vsx_module_param_abs* param) { VSX_UNUSED(param); //printf("mesh_out\n"); glGetFloatv(GL_LINE_WIDTH,&prev_width); glLineWidth(line_width->get()); #ifndef VSXU_OPENGL_ES glEnable(GL_LINE_SMOOTH); #endif mesh = mesh_in->get_addr(); if (mesh) { if (center->get()) { vsx_color l_center_color = vsx_color__(center_color->get(0)+center_color_add->get(0),center_color->get(1)+center_color_add->get(1),center_color->get(2)+center_color_add->get(2),center_color->get(3)+center_color_add->get(3)); vsx_color main_color = vsx_color__(base_color->get(0)+base_color_add->get(0),base_color->get(1)+base_color_add->get(1),base_color->get(2)+base_color_add->get(2),base_color->get(3)+base_color_add->get(3)); #ifdef VSXU_OPENGL_ES_1_0 GLfloat fan_vertices[] = { 0,0,0, 0,0,0, }; GLfloat fan_colors[] = { l_center_color.r,l_center_color.g,l_center_color.b,l_center_color.a, main_color.r,main_color.g,main_color.b,main_color.a, }; glDisableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glVertexPointer(3, GL_FLOAT, 0, fan_vertices); glColorPointer(4, GL_FLOAT, 0, fan_colors); #endif #ifdef VSXU_OPENGL_ES_2_0 //TODO #endif #ifndef VSXU_OPENGL_ES glBegin(GL_LINES); #endif if (override_base_color->get()) { for (unsigned long i = 0; i < (*mesh)->data->vertices.size(); ++i) { #ifdef VSXU_OPENGL_ES_1_0 fan_vertices[3] = (*mesh)->data->vertices[i].x; fan_vertices[4] = (*mesh)->data->vertices[i].y; fan_vertices[5] = (*mesh)->data->vertices[i].z; glDrawArrays(GL_LINES, 0, 2); #endif #ifdef VSXU_OPENGL_ES_2_0 //TODO #endif #ifndef VSXU_OPENGL_ES l_center_color.gl_color(); glVertex3f(0.0f,0.0f,0.0f); main_color.gl_color(); glVertex3f((*mesh)->data->vertices[i].x,(*mesh)->data->vertices[i].y,(*mesh)->data->vertices[i].z); #endif } } else { for (unsigned long i = 0; i < (*mesh)->data->vertices.size(); ++i) { #ifdef VSXU_OPENGL_ES_1_0 fan_vertices[3] = (*mesh)->data->vertices[i].x; fan_vertices[4] = (*mesh)->data->vertices[i].y; fan_vertices[5] = (*mesh)->data->vertices[i].z; fan_colors[4] = (*mesh)->data->vertex_colors[i].r; fan_colors[5] = (*mesh)->data->vertex_colors[i].g; fan_colors[6] = (*mesh)->data->vertex_colors[i].b; fan_colors[7] = (*mesh)->data->vertex_colors[i].a; glDrawArrays(GL_LINES, 0, 2); #endif #ifdef VSXU_OPENGL_ES_2_0 #endif #ifndef VSXU_OPENGL_ES l_center_color.gl_color(); glVertex3f(0.0f,0.0f,0.0f); (*mesh)->data->vertex_colors[i].gl_color(); glVertex3f((*mesh)->data->vertices[i].x,(*mesh)->data->vertices[i].y,(*mesh)->data->vertices[i].z); #endif } } } // center->get() else { #ifndef VSXU_OPENGL_ES glBegin(GL_LINE_STRIP); #endif #ifdef VSXU_OPENGL_ES_1_0 glDisableClientState(GL_TEXTURE_COORD_ARRAY); if (override_base_color->get()) { glColor4f(base_color->get(0)+base_color_add->get(0),base_color->get(1)+base_color_add->get(1),base_color->get(2)+base_color_add->get(2),base_color->get(3)+base_color_add->get(3)); glDisableClientState(GL_COLOR_ARRAY); } else { glEnableClientState(GL_COLOR_ARRAY); glColorPointer(4, GL_FLOAT, 0, mesh->data->vertex_colors.get_pointer()); } glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(3, GL_FLOAT, 0, mesh->data->vertices.get_pointer()); glDrawArrays(GL_LINE_STRIP,0,mesh->data->vertices.size()); #endif #ifdef VSXU_OPENGL_ES_2_0 //TODO #endif #ifndef VSXU_OPENGL_ES if (override_base_color->get()) { glColor4f(base_color->get(0)+base_color_add->get(0),base_color->get(1)+base_color_add->get(1),base_color->get(2)+base_color_add->get(2),base_color->get(3)+base_color_add->get(3)); for (unsigned long i = 0; i < (*mesh)->data->vertices.size(); ++i) { glVertex3f((*mesh)->data->vertices[i].x,(*mesh)->data->vertices[i].y,(*mesh)->data->vertices[i].z); } } else { for (unsigned long i = 0; i < (*mesh)->data->vertices.size(); ++i) { if ((*mesh)->data->vertex_colors.size()) (*mesh)->data->vertex_colors[i].gl_color(); glVertex3f((*mesh)->data->vertices[i].x,(*mesh)->data->vertices[i].y,(*mesh)->data->vertices[i].z); } } #endif } #ifndef VSXU_OPENGL_ES_2_0 glEnd(); #endif render_out->set(1); } else render_out->set(0); }
void CGutModel_OpenGL::RenderMesh(bool bSubmitMaterial) { glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT); for ( int i=0; i<m_iNumMeshes; i++ ) { sModelMesh_OpenGL *pMesh = m_pMeshArray + i; for ( int j=0; j<pMesh->m_iNumVertexChunks; j++ ) { sModelVertexChunk_OpenGL *pVertexChunk = pMesh->m_pVertexChunk + j; sVertexDecl *pVertexDecl = &pVertexChunk->m_VertexDecl; glBindBuffer(GL_ARRAY_BUFFER, pVertexChunk->m_VertexBufferID); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, pVertexChunk->m_IndexBufferID); if ( pVertexDecl->m_iPositionOffset >= 0 ) { glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(pVertexDecl->m_iNumPositionElements, GL_FLOAT, pVertexDecl->m_iVertexSize, (GLvoid *) pVertexDecl->m_iPositionOffset); } else { glDisableClientState(GL_VERTEX_ARRAY); } if ( pVertexDecl->m_iNormalOffset >= 0 ) { glEnableClientState(GL_NORMAL_ARRAY); glNormalPointer(GL_FLOAT, pVertexDecl->m_iVertexSize, (GLvoid *) pVertexDecl->m_iNormalOffset); } else { glDisableClientState(GL_NORMAL_ARRAY); } if ( pVertexDecl->m_iColorOffset >= 0 ) { glEnableClientState(GL_COLOR_ARRAY); glColorPointer(pVertexDecl->m_iNumColorElements, GL_UNSIGNED_BYTE, pVertexDecl->m_iVertexSize, (GLvoid *) pVertexDecl->m_iColorOffset); } else { glDisableClientState(GL_COLOR_ARRAY); } for (int l=0; l<pVertexChunk->m_iNumBatches; l++ ) { sModelBatch *pBatch = pVertexChunk->m_pBatchArray + l; if ( bSubmitMaterial && pBatch->m_iMaterialID >= 0 ) { m_pMaterialArray[pBatch->m_iMaterialID].Submit(pVertexChunk); } // OpenGL 1.1+ //int *ip = (int *) (pBatch->m_iIndexArrayBegin * 2); //glDrawElements(GL_TRIANGLES, pBatch->m_iNumPrimitives * 3, GL_UNSIGNED_SHORT, ip); // OpenGL 1.2+ glDrawRangeElements(GL_TRIANGLES, pBatch->m_iIndexArrayBegin, pBatch->m_iIndexArrayEnd, pBatch->m_iNumIndices, GL_UNSIGNED_SHORT, 0); } } } glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glPopClientAttrib(); }
// // Bind data to GL // bool cgfxVaryingParameter::bind( const float* data, int stride) const { bool result = false; switch( fGLType) { case glRegister::kPosition: glStateCache::instance().enablePosition(); glVertexPointer( stride, GL_FLOAT, 0, data); result = true; break; case glRegister::kNormal: if( stride == 3) { glStateCache::instance().enableNormal(); glNormalPointer( GL_FLOAT, 0, data); result = true; } break; case glRegister::kTexCoord: if( fGLIndex < glStateCache::sMaxTextureUnits) { glStateCache::instance().enableAndActivateTexCoord( fGLIndex); glTexCoordPointer( stride, GL_FLOAT, 0, data); result = true; } break; case glRegister::kColor: if( stride > 2) { glStateCache::instance().enableColor(); glColorPointer( stride, GL_FLOAT, 0, data); result = true; } break; case glRegister::kSecondaryColor: if( stride > 2) { glStateCache::instance().enableSecondaryColor(); if( glStateCache::glVertexAttribPointer) glStateCache::glSecondaryColorPointer( stride, GL_FLOAT, 0, (GLvoid*)data); result = true; } break; case glRegister::kVertexAttrib: glStateCache::instance().enableVertexAttrib( fGLIndex); if( glStateCache::glVertexAttribPointer) glStateCache::glVertexAttribPointer( fGLIndex, stride, GL_FLOAT, GL_FALSE, 0, data); result = true; break; /// TODO add secondaryColor, vertexWeight, vertexAttrib, fog default: break; } return result; }
void RenderTarget::draw(const Vertex* vertices, unsigned int vertexCount, PrimitiveType type, const RenderStates& states) { // Nothing to draw? if (!vertices || (vertexCount == 0)) return; if (activate(true)) { // First set the persistent OpenGL states if it's the very first call if (!m_cache.glStatesSet) resetGLStates(); // Check if the vertex count is low enough so that we can pre-transform them bool useVertexCache = (vertexCount <= StatesCache::VertexCacheSize); if (useVertexCache) { // Pre-transform the vertices and store them into the vertex cache for (unsigned int i = 0; i < vertexCount; ++i) { Vertex& vertex = m_cache.vertexCache[i]; vertex.position = states.transform * vertices[i].position; vertex.color = vertices[i].color; vertex.texCoords = vertices[i].texCoords; } // Since vertices are transformed, we must use an identity transform to render them if (!m_cache.useVertexCache) applyTransform(Transform::Identity); } else { applyTransform(states.transform); } // Apply the view if (m_cache.viewChanged) applyCurrentView(); // Apply the blend mode if (states.blendMode != m_cache.lastBlendMode) applyBlendMode(states.blendMode); // Apply the texture Uint64 textureId = states.texture ? states.texture->m_cacheId : 0; if (textureId != m_cache.lastTextureId) applyTexture(states.texture); // Apply the shader if (states.shader) applyShader(states.shader); // If we pre-transform the vertices, we must use our internal vertex cache if (useVertexCache) { // ... and if we already used it previously, we don't need to set the pointers again if (!m_cache.useVertexCache) vertices = m_cache.vertexCache; else vertices = NULL; } // Setup the pointers to the vertices' components if (vertices) { const char* data = reinterpret_cast<const char*>(vertices); glCheck(glVertexPointer(2, GL_FLOAT, sizeof(Vertex), data + 0)); glCheck(glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex), data + 8)); glCheck(glTexCoordPointer(2, GL_FLOAT, sizeof(Vertex), data + 12)); } // Find the OpenGL primitive type static const GLenum modes[] = {GL_POINTS, GL_LINES, GL_LINE_STRIP, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS }; GLenum mode = modes[type]; // Draw the primitives glCheck(glDrawArrays(mode, 0, vertexCount)); // Unbind the shader, if any if (states.shader) applyShader(NULL); // Update the cache m_cache.useVertexCache = useVertexCache; } }
int main() { Parms_t input; /* input.width = 10; input.height = 10; input.fullscreen = 0;//SDL_WINDOW_FULLSCREEN; input.windowH = 200; input.windowW = 200; input.animationDelay = 0; input.framesDrop = 1; input.startPoint.x = 1; input.startPoint.y = 1; input.exitPoint.x = 7; input.exitPoint.y = 7; */ Parms_t last; bool quit = false; Data_t d; RenderData_t rd; srand(clock()); //инициализация SDL2 SDL_Init(SDL_INIT_VIDEO); input = getInput(1, ALL, input); SDL_Window *window = SDL_CreateWindow("Labytinth", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, input.windowW, input.windowH, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | input.fullscreen | SDL_WINDOW_BORDERLESS); SDL_GL_CreateContext(window); SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1); SDL_Event event; //OpenGL 4.1 glMatrixMode(GL_PROJECTION|GL_MODELVIEW); glLoadIdentity(); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glOrtho(-input.windowW/2,input.windowW/2,input.windowH/2,-input.windowH/2,0,1); glClearColor( 1, 1, 1, 0 ); SDL_GL_SetSwapInterval( 1 ); //vsync uint8_t *data; bool flagChanged = 0; Action_t flagAction = NOTHING; bool flagGenerated = 0; bool flagGeneratorData = 0; bool flagSolverData = 0; uint16_t i = 0; glClear(GL_COLOR_BUFFER_BIT); SDL_GL_SwapWindow(window); while(!quit){ while(SDL_PollEvent(&event)){ if(event.type == SDL_QUIT) quit = true; else if (event.type == SDL_KEYDOWN){ switch (event.key.keysym.sym){ case SDLK_g: flagAction = GENERATE; break; case SDLK_s: flagAction = SOLVE; break; case SDLK_TAB: flagAction = STOP; break; case SDLK_ESCAPE: quit = 1; break; case SDLK_UP: input.framesDrop++; break; case SDLK_RIGHT: input.animationDelay++; case SDLK_DOWN: input.framesDrop = (input.framesDrop - 1 > 0) ? input.framesDrop - 1 : 1; break; case SDLK_LEFT: input.animationDelay = (input.animationDelay - 1 >= 0) ? input.animationDelay - 1 : 0; break; } } } if(flagAction == GENERATE){ if(!flagGeneratorData){ d = initGeneratorData(input.width, input.height, input.startPoint); rd = initRenderData(d, input.windowW, input.windowH); flagGeneratorData = true; flagGenerated = false; flagSolverData = false; glVertexPointer(2, GL_FLOAT, sizeof(Vertex_t), rd.vertices); glColorPointer(3, GL_UNSIGNED_BYTE, sizeof(VertexColor_t), rd.verticesColor); } for(i = 0; i < input.framesDrop; i++){ if(d.unvisitedNum != 0){ generateStep(&d); } else{ flagGeneratorData = false; flagGenerated = true; flagAction = NOTHING; break; } } d.maze[d.startPoint.y][d.startPoint.x] = CURRENT; renderMatrix(d.maze, rd, GENERATE); d.maze[d.startPoint.y][d.startPoint.x] = GENVISITED; flagChanged = true; } else if(flagAction == SOLVE && flagGenerated){ if(!flagSolverData){ d = initSeekerData(d, input.startPoint, input.exitPoint); rd = clearSeekerColorArray(d.maze, rd); flagSolverData = true; } for(i = 0; i < input.framesDrop; i++){ if((d.startPoint.x != d.exitPoint.x || d.startPoint.y != d.exitPoint.y) && d.error != 1){ seekStep(&d); } else if(d.error){ printf("ERROR: Lanyrinth cannot be solved! :C\n"); } else{ flagSolverData = false; flagAction = NOTHING; setMode(d.exitPoint, d.maze, WAY); break; } } setMode(d.startPoint, d.maze, CURRENT); renderMatrix(d.maze, rd, SOLVE); setMode(d.startPoint, d.maze, WAY); flagChanged = true; } else if(flagAction == STOP){ last = input; input = getInput(0, GENERATE, last); if((last.width != input.width) || (last.height != input.height)){ flagGenerated = false; flagGeneratorData = false; flagSolverData = false; } flagAction = NOTHING; flagChanged = true; } else if(flagAction == OUTPUT){ data = malloc(input.windowW * input.windowH * 4 * sizeof(uint8_t)); glReadBuffer(GL_FRONT); glReadPixels(0, 0, input.windowW , input.windowH, GL_RGBA, GL_UNSIGNED_BYTE, data); flagAction = NOTHING; } if(flagAction != NOTHING || flagChanged){ SDL_Delay(input.animationDelay); SDL_GL_SwapWindow(window); flagChanged = false; } } //cleanup wipe(d.stack); return 0; }
/* * OpenGL (GLUT) calls this routine to display the scene */ void display() { const double len=2.5; // Length of axes double Ex = -2*dim*Sin(th)*Cos(ph); double Ey = +2*dim *Sin(ph); double Ez = +2*dim*Cos(th)*Cos(ph); // Erase the window and the depth buffer glClear(GL_COLOR_BUFFER_BIT); // Undo previous transformations glLoadIdentity(); // Perspective - set eye position gluLookAt(Ex,Ey,Ez , 0,0,0 , 0,Cos(ph),0); // Integrate Step(); // Set shader glUseProgram(shader); int id = glGetUniformLocation(shader,"star"); if (id>=0) glUniform1i(id,0); id = glGetUniformLocation(shader,"size"); if (id>=0) glUniform1f(id,0.1); glBlendFunc(GL_ONE,GL_ONE); glEnable(GL_BLEND); // Draw stars using vertex arrays glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glVertexPointer(3,GL_FLOAT,sizeof(float3),pos[src]); glColorPointer(3,GL_FLOAT,sizeof(Color),col); // Draw all stars glDrawArrays(GL_POINTS,0,N); // Disable vertex arrays glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_COLOR_ARRAY); // Unset shader glUseProgram(0); glDisable(GL_BLEND); // Draw axes glDisable(GL_LIGHTING); glColor3f(1,1,1); if (axes) { glBegin(GL_LINES); glVertex3d(0.0,0.0,0.0); glVertex3d(len,0.0,0.0); glVertex3d(0.0,0.0,0.0); glVertex3d(0.0,len,0.0); glVertex3d(0.0,0.0,0.0); glVertex3d(0.0,0.0,len); glEnd(); // Label axes glRasterPos3d(len,0.0,0.0); Print("X"); glRasterPos3d(0.0,len,0.0); Print("Y"); glRasterPos3d(0.0,0.0,len); Print("Z"); } // Display parameters glWindowPos2i(5,5); Print("FPS=%d Angle=%d,%d Mode=%s", FramesPerSecond(),th,ph,text[mode]); // Render the scene and make it visible ErrCheck("display"); glFlush(); glutSwapBuffers(); }
void __glXDisp_DrawArrays(GLbyte * pc) { __GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *) pc; __GLXdispatchDrawArraysComponentHeader *compHeader; GLint numVertexes = hdr->numVertexes; GLint numComponents = hdr->numComponents; GLenum primType = hdr->primType; GLint stride = 0; int i; pc += sizeof(__GLXdispatchDrawArraysHeader); compHeader = (__GLXdispatchDrawArraysComponentHeader *) pc; /* compute stride (same for all component arrays) */ for (i = 0; i < numComponents; i++) { GLenum datatype = compHeader[i].datatype; GLint numVals = compHeader[i].numVals; stride += __GLX_PAD(numVals * __glXTypeSize(datatype)); } pc += numComponents * sizeof(__GLXdispatchDrawArraysComponentHeader); /* set up component arrays */ for (i = 0; i < numComponents; i++) { GLenum datatype = compHeader[i].datatype; GLint numVals = compHeader[i].numVals; GLenum component = compHeader[i].component; switch (component) { case GL_VERTEX_ARRAY: glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(numVals, datatype, stride, pc); break; case GL_NORMAL_ARRAY: glEnableClientState(GL_NORMAL_ARRAY); glNormalPointer(datatype, stride, pc); break; case GL_COLOR_ARRAY: glEnableClientState(GL_COLOR_ARRAY); glColorPointer(numVals, datatype, stride, pc); break; case GL_INDEX_ARRAY: glEnableClientState(GL_INDEX_ARRAY); glIndexPointer(datatype, stride, pc); break; case GL_TEXTURE_COORD_ARRAY: glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(numVals, datatype, stride, pc); break; case GL_EDGE_FLAG_ARRAY: glEnableClientState(GL_EDGE_FLAG_ARRAY); glEdgeFlagPointer(stride, (const GLboolean *) pc); break; case GL_SECONDARY_COLOR_ARRAY: { PFNGLSECONDARYCOLORPOINTERPROC SecondaryColorPointerEXT = __glGetProcAddress("glSecondaryColorPointerEXT"); glEnableClientState(GL_SECONDARY_COLOR_ARRAY); SecondaryColorPointerEXT(numVals, datatype, stride, pc); break; } case GL_FOG_COORD_ARRAY: { PFNGLFOGCOORDPOINTERPROC FogCoordPointerEXT = __glGetProcAddress("glFogCoordPointerEXT"); glEnableClientState(GL_FOG_COORD_ARRAY); FogCoordPointerEXT(datatype, stride, pc); break; } default: break; } pc += __GLX_PAD(numVals * __glXTypeSize(datatype)); } glDrawArrays(primType, 0, numVertexes); /* turn off anything we might have turned on */ glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_INDEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_EDGE_FLAG_ARRAY); glDisableClientState(GL_SECONDARY_COLOR_ARRAY); glDisableClientState(GL_FOG_COORD_ARRAY); }
int main(int argc, char *argv[]) { SDL_Surface *screen; if ( SDL_Init(SDL_INIT_VIDEO) != 0 ) { printf("Unable to initialize SDL: %s\n", SDL_GetError()); return 1; } SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); screen = SDL_SetVideoMode( 640, 480, 24, SDL_OPENGL ); if ( !screen ) { printf("Unable to set video mode: %s\n", SDL_GetError()); return 1; } glClearColor( 0, 0, 0, 0 ); glClear( GL_COLOR_BUFFER_BIT ); // Create a texture GLuint texture; glGenTextures( 1, &texture ); glBindTexture( GL_TEXTURE_2D, texture ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); GLubyte textureData[16*16*4]; for (int x = 0; x < 16; x++) { for (int y = 0; y < 16; y++) { *((int*)&textureData[(x*16 + y) * 4]) = x*16 + ((y*16) << 8); } } glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, textureData ); // Create a second texture GLuint texture2; glGenTextures( 1, &texture2 ); glBindTexture( GL_TEXTURE_2D, texture2 ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); GLubyte texture2Data[] = { 0xff, 0, 0, 0xff, 0, 0xff, 0, 0xaa, 0, 0, 0xff, 0x55, 0x80, 0x90, 0x70, 0 }; glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture2Data ); // BEGIN #if USE_GLEW glewInit(); #endif glMatrixMode(GL_PROJECTION); glLoadIdentity(); // original: glFrustum(-0.6435469817188064, 0.6435469817188064 ,-0.48266022190470925, 0.48266022190470925 ,0.5400000214576721, 2048); glFrustum(-0.6435469817188064, 0.1435469817188064 ,-0.48266022190470925, 0.88266022190470925 ,0.5400000214576721, 2048); glRotatef(-30, 1, 1, 1); //GLfloat pm[] = { 1.372136116027832, 0, 0, 0, 0, 0.7910231351852417, 0, 0, -0.6352481842041016, 0.29297152161598206, -1.0005275011062622, -1, 0, 0, -1.080284833908081, 0 }; //glLoadMatrixf(pm); glMatrixMode(GL_MODELVIEW); GLfloat matrixData[] = { -1, 0, 0, 0, 0, 0,-1, 0, 0, 1, 0, 0, 0, 0, 0, 1 }; glLoadMatrixf(matrixData); //glTranslated(-512,-512,-527); // XXX this should be uncommented, but if it is then nothing is shown glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glClear(GL_DEPTH_BUFFER_BIT); glEnableClientState(GL_NORMAL_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glActiveTexture(GL_TEXTURE0); glEnableClientState(GL_VERTEX_ARRAY); GLuint arrayBuffer, elementBuffer; glGenBuffers(1, &arrayBuffer); glGenBuffers(1, &elementBuffer); GLubyte arrayData[] = { /* [0, 0, 0, 67] ==> 128 float [0, 0, 128, 67] ==> 256 float [0, 0, 0, 68] ==> 512 float [0, 0, 128, 68] ==> 1024 float [vertex x ] [vertex y ] [vertex z ] [nr] [texture u ] [texture v ] [lm u ] [lm v ] [color r,g,b,a ] */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68, 11, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 0 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 23, 20, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 1 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 35, 30, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 2 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 47, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 3 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 51, 50, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 4 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 68, 64, 60, 0, 0, 0, 0, 128, 67, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 5 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 70, 70, 0, 0, 0, 0, 128, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 6 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 89, 80, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 7 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 94, 90, 0, 0, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 8 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 20, 10, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 9 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 31, 20, 0, 0, 0, 0, 0, 67, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 10 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 68, 42, 30, 0, 0, 0, 0, 0, 0, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 11 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 53, 40, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 12 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 64, 50, 0, 0, 0, 0, 128, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 13 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 68, 75, 60, 0, 0, 0, 0, 128, 67, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 14 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 86, 70, 0, 0, 0, 0, 0, 67, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 15 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128 }; assert(sizeof(arrayData) == 1408); glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(arrayData), arrayData, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); GLushort elementData[] = { 1, 2, 0, 2, 3, 0, 5, 6, 4, 6, 7, 4, 9, 10, 8, 10, 11, 8, 13, 14, 12, 14, 15, 12 }; assert(sizeof(elementData) == 48); glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer); // sauer vertex data is apparently 0-12: V3F, 12: N1B, 16-24: T2F, 24-28: T2S, 28-32: C4B glVertexPointer(3, GL_FLOAT, 32, (void*)0); // all these apply to the ARRAY_BUFFER that is bound glTexCoordPointer(2, GL_FLOAT, 32, (void*)16); glClientActiveTexture(GL_TEXTURE1); // XXX seems to be ignored in native build glTexCoordPointer(2, GL_SHORT, 32, (void*)24); glClientActiveTexture(GL_TEXTURE0); // likely not needed, it is a cleanup glNormalPointer(GL_BYTE, 32, (void*)12); glColorPointer(4, GL_UNSIGNED_BYTE, 32, (void*)28); glBindTexture(GL_TEXTURE_2D, texture); // diffuse? glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, texture2); // lightmap? glActiveTexture(GL_TEXTURE0); GLint ok; const char *vertexShader = "uniform vec4 texgenscroll;\n" "void main(void)\n" "{\n" " gl_Position = ftransform();\n" " gl_TexCoord[0].xy = gl_MultiTexCoord0.xy/10000.0 + (0.001*texgenscroll.xy) + gl_Normal.xy;\n" // added /100 here " gl_TexCoord[1].xy = gl_MultiTexCoord1.xy/100.0 * 3.051851e-05;\n" "}\n"; const char *fragmentShader = "uniform vec4 colorparams;\n" "uniform sampler2D diffusemap, lightmap;\n" "void main(void)\n" "{\n" " vec4 diffuse = texture2D(diffusemap, gl_TexCoord[0].xy);\n" " vec4 lm = texture2D(lightmap, gl_TexCoord[1].xy);\n" " diffuse *= colorparams;\n" " gl_FragColor = diffuse * lm;\n" "}\n"; GLuint vs = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vs, 1, &vertexShader, NULL); glCompileShader(vs); glGetShaderiv(vs, GL_COMPILE_STATUS, &ok); assert(ok); GLuint fs = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fs, 1, &fragmentShader, NULL); glCompileShader(fs); glGetShaderiv(fs, GL_COMPILE_STATUS, &ok); assert(ok); GLuint program = glCreateProgram(); glAttachShader(program, vs); glAttachShader(program, fs); glLinkProgram(program); glGetProgramiv(program, GL_LINK_STATUS, &ok); assert(ok); glUseProgram(program); GLint lightmapLocation = glGetUniformLocation(program, "lightmap"); assert(lightmapLocation >= 0); glUniform1i(lightmapLocation, 1); // sampler2D? Is it the texture unit? GLint diffusemapLocation = glGetUniformLocation(program, "diffusemap"); assert(diffusemapLocation >= 0); glUniform1i(diffusemapLocation, 0); GLint texgenscrollLocation = glGetUniformLocation(program, "texgenscroll"); assert(texgenscrollLocation >= 0); GLint colorparamsLocation = glGetUniformLocation(program, "colorparams"); assert(colorparamsLocation >= 0); GLfloat texgenscrollData[] = { 0, 0, 0, 0 }; glUniform4fv(texgenscrollLocation, 1, texgenscrollData); GLfloat colorparamsData[] = { 2, 2, 2, 1 }; glUniform4fv(colorparamsLocation, 1, colorparamsData); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)&elementData[12/sizeof(GLushort)]); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)&elementData[ 0/sizeof(GLushort)]); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)&elementData[24/sizeof(GLushort)]); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)&elementData[36/sizeof(GLushort)]); // END SDL_GL_SwapBuffers(); #ifndef __EMSCRIPTEN__ SDL_Delay(1500); #endif SDL_Quit(); return 0; }
// overriding draw method void CCParticleSystemQuad::draw() { CCParticleSystem::draw(); // Default GL states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY // Needed states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY // Unneeded states: - glBindTexture(GL_TEXTURE_2D, m_pTexture->getName()); #define kQuadSize sizeof(m_pQuads[0].bl) #if CC_USES_VBO ccglBindBuffer(GL_ARRAY_BUFFER, m_uQuadsID); #if CC_ENABLE_CACHE_TEXTTURE_DATA ccglBufferData(GL_ARRAY_BUFFER, sizeof(m_pQuads[0])*m_uTotalParticles, m_pQuads, GL_DYNAMIC_DRAW); #endif glVertexPointer(2,GL_FLOAT, kQuadSize, 0); glColorPointer(4, GL_UNSIGNED_BYTE, kQuadSize, (GLvoid*) offsetof(ccV2F_C4B_T2F,colors) ); glTexCoordPointer(2, GL_FLOAT, kQuadSize, (GLvoid*) offsetof(ccV2F_C4B_T2F,texCoords) ); #else // vertex array list int offset = (int) m_pQuads; // vertex int diff = offsetof( ccV2F_C4B_T2F, vertices); glVertexPointer(2,GL_FLOAT, kQuadSize, (GLvoid*) (offset+diff) ); // color diff = offsetof( ccV2F_C4B_T2F, colors); glColorPointer(4, GL_UNSIGNED_BYTE, kQuadSize, (GLvoid*)(offset + diff)); // tex coords diff = offsetof( ccV2F_C4B_T2F, texCoords); glTexCoordPointer(2, GL_FLOAT, kQuadSize, (GLvoid*)(offset + diff)); #endif // ! CC_USES_VBO bool newBlend = (m_tBlendFunc.src != CC_BLEND_SRC || m_tBlendFunc.dst != CC_BLEND_DST) ? true : false; if( newBlend ) { glBlendFunc( m_tBlendFunc.src, m_tBlendFunc.dst ); } CCAssert( m_uParticleIdx == m_uParticleCount, "Abnormal error in particle quad"); glDrawElements(GL_TRIANGLES, (GLsizei)(m_uParticleIdx*6), GL_UNSIGNED_SHORT, m_pIndices); // restore blend state if( newBlend ) glBlendFunc( CC_BLEND_SRC, CC_BLEND_DST ); #if CC_USES_VBO ccglBindBuffer(GL_ARRAY_BUFFER, 0); #endif // restore GL default state // - }
void TriangleMeshViewerDisplay::paintGL() { assert(isValid()); const FloatRGBA bg=background_colour(); glClearColor(bg.r,bg.g,bg.b,1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); const float a=parameters->ambient; GLfloat global_ambient[]={a,a,a,1.0}; glLightModelfv(GL_LIGHT_MODEL_AMBIENT,global_ambient); GLfloat light_diffuse[]={1.0f-a,1.0f-a,1.0f-a,1.0}; glLightfv(GL_LIGHT0,GL_DIFFUSE,light_diffuse); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt( camera_position.x,camera_position.y,camera_position.z, camera_lookat.x ,camera_lookat.y ,camera_lookat.z, camera_up.x ,camera_up.y ,camera_up.z ); const XYZ light_direction(parameters->illumination_direction()); GLfloat light_position[]= { light_direction.x, light_direction.y, light_direction.z, 0.0f // w=0 implies directional light }; glLightfv(GL_LIGHT0,GL_POSITION,light_position); glRotatef((180.0/M_PI)*object_tilt,1.0,0.0,0.0); glRotatef((180.0/M_PI)*object_rotation,0.0,0.0,1.0); glPolygonMode(GL_FRONT_AND_BACK,(parameters->wireframe ? GL_LINE : GL_FILL)); glEnable(GL_CULL_FACE); glFrontFace(GL_CCW); if (parameters->display_list && gl_display_list_index!=0) { glCallList(gl_display_list_index); } else { bool building_display_list=(parameters->display_list && gl_display_list_index==0); if (building_display_list) { gl_display_list_index=glGenLists(1); assert(gl_display_list_index!=0); glNewList(gl_display_list_index,GL_COMPILE_AND_EXECUTE); if (_verbose) std::cerr << "Building display list..."; } GLfloat default_material_white[3]={1.0f,1.0f,1.0f}; GLfloat default_material_black[3]={0.0f,0.0f,0.0f}; glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,default_material_white); glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,default_material_black); for (uint m=0;m<mesh.size();m++) { const TriangleMesh*const it=mesh[m]; if (it==0) continue; // Meshes after the first are rendered twice: first the backfacing polys then the front facing. // This solves the problem of either clouds disappearing when we're under them (with backface culling) // or weird stuff around the periphery when culling is on. // It's quite an expensive solution! const uint passes=(m==0 ? 1 : 2); for (uint pass=0;pass<passes;pass++) { if (passes==2 && pass==0) { glCullFace(GL_FRONT); } else { glCullFace(GL_BACK); } if (it->emissive()==0.0f) { if (m) // Switch blending on for non-emissive meshes after the first { glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); } else { glDisable(GL_BLEND); } // Use "Color Material" mode 'cos everything is the same material.... just change the colour glEnable(GL_COLOR_MATERIAL); glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE); // Point GL at arrays of data glVertexPointer(3,GL_FLOAT,sizeof(Vertex),&(it->vertex(0).position().x)); glNormalPointer(GL_FLOAT,sizeof(Vertex),&(it->vertex(0).normal().x)); // For a second mesh, use alpha (actually could use it for the first mesh but maybe it's more efficient not to). glColorPointer((m==0 ? 3 : 4),GL_UNSIGNED_BYTE,sizeof(Vertex),&(it->vertex(0).colour(0).r)); // Builds on some platforms (ie Ubuntu) seem to get in a mess if you render >1k primitives // (3k vertices). NB This is a problem in the client; not the xserver. // Debian (Sarge or Etch) has no problems with unlimited batches. // Note it's simply the batch size; there doesn't seem to be any problem with the 10Ks of vertices. // Since the limited batch size doesn't seem to hurt working implementations we just use it everywhere. const uint batch_size=1000; // Draw the colour-zero triangles for (uint t=0;t<it->triangles_of_colour0();t+=batch_size) { glDrawRangeElements ( GL_TRIANGLES, 0, it->vertices()-1, 3*std::min(batch_size,static_cast<uint>(it->triangles_of_colour0()-t)), GL_UNSIGNED_INT, &(it->triangle(t).vertex(0)) ); if (_verbose && building_display_list) { std::cerr << "."; } } // Switch to alternate colour and draw the colour-one triangles glColorPointer(3,GL_UNSIGNED_BYTE,sizeof(Vertex),&(it->vertex(0).colour(1).r)); for (uint t=it->triangles_of_colour0();t<it->triangles();t+=batch_size) { glDrawRangeElements ( GL_TRIANGLES, 0, it->vertices()-1, 3*std::min(batch_size,static_cast<uint>(it->triangles()-t)), GL_UNSIGNED_INT, &(it->triangle(t).vertex(0)) ); if (_verbose && building_display_list) { std::cerr << "."; } } glDisable(GL_COLOR_MATERIAL); } else // implies mesh[m]->emissive()>0.0 { // We abuse alpha for emission, so no blending glDisable(GL_BLEND); // If there could be emissive vertices, we need to do things the hard way // using immediate mode. Maybe the display list capture will help. const float k=1.0f/255.0f; const float em=k*( it->emissive()); const float ad=k*(1.0f-it->emissive()); glBegin(GL_TRIANGLES); for (unsigned int t=0;t<it->triangles();t++) { if (_verbose && building_display_list && (t&0x3ff) == 0) { std::cerr << "."; } const uint c=(t<it->triangles_of_colour0() ? 0 : 1); for (uint i=0;i<3;i++) { const uint vn=it->triangle(t).vertex(i); const Vertex& v=it->vertex(vn); GLfloat c_ad[3]; GLfloat c_em[3]; if (v.colour(c).a==0) // Zero alpha used to imply emissive vertex colour { c_ad[0]=v.colour(c).r*ad; c_ad[1]=v.colour(c).g*ad; c_ad[2]=v.colour(c).b*ad; c_em[0]=v.colour(c).r*em; c_em[1]=v.colour(c).g*em; c_em[2]=v.colour(c).b*em; } else { c_ad[0]=v.colour(c).r*k; c_ad[1]=v.colour(c).g*k; c_ad[2]=v.colour(c).b*k; c_em[0]=0.0f; c_em[1]=0.0f; c_em[2]=0.0f; } glNormal3fv(&(v.normal().x)); glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,c_ad); glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,c_em); glVertex3fv(&(v.position().x)); } } glEnd(); } } } if (building_display_list) { glEndList(); if (_verbose) { std::cerr << "\n...built display list\n"; } } } if (_verbose) check_for_gl_errors(__PRETTY_FUNCTION__); // Get time taken since last frame const uint dt=frame_time.restart(); // Save it in the queue frame_times.push_back(dt); // Keep last 30 frame times while (frame_times.size()>30) frame_times.pop_front(); // Only update frame time a couple of times a second to reduce flashing if (frame_time_reported.elapsed()>500) { //! \todo Frame time calculation is wrong... need -1 correction to number of frames const float average_time=std::accumulate ( frame_times.begin(), frame_times.end(), 0 )/static_cast<float>(frame_times.size()); const float fps=1000.0/average_time; std::ostringstream report; report.setf(std::ios::fixed); report.precision(1); uint n_triangles=0; uint n_vertices=0; for (uint m=0;m<mesh.size();m++) { if (mesh[m]) { n_triangles+=mesh[m]->triangles(); n_vertices+=mesh[m]->vertices(); } } report << "Triangles: " << n_triangles << ", " << "Vertices: " << n_vertices << ", " << "FPS: " << fps << "\n"; _notify.notify(report.str()); frame_time_reported.restart(); } }