//Draw a biquadratic patch void BSP_BIQUADRATIC_PATCH::Draw() { //set array pointers glVertexPointer(3, GL_FLOAT, sizeof(BSP_VERTEX), &vertices[0].position); glTexCoordPointer(2, GL_FLOAT, sizeof(BSP_VERTEX), &vertices[0].decalS); glClientActiveTextureARB(GL_TEXTURE1_ARB); glTexCoordPointer(2, GL_FLOAT, sizeof(BSP_VERTEX), &vertices[0].lightmapS); glClientActiveTextureARB(GL_TEXTURE0_ARB); //Draw a triangle strip for each row if(!EXT_multi_draw_arrays_supported) { for(int row=0; row<tesselation; ++row) { glDrawElements( GL_TRIANGLE_STRIP, 2*(tesselation+1), GL_UNSIGNED_INT, &indices[row*2*(tesselation+1)]); } } else { glMultiDrawElementsEXT( GL_TRIANGLE_STRIP, trianglesPerRow, GL_UNSIGNED_INT, (const void **)rowIndexPointers, tesselation); } }
//Draw a polygon face void BSP::DrawPolygonFace(int polygonFaceNumber) { //skip this face if its texture was not loaded if(isTextureLoaded[polygonFaces[polygonFaceNumber].textureIndex]==false) return; //set array pointers glVertexPointer( 3, GL_FLOAT, sizeof(BSP_VERTEX), &vertices[0].position); //Unit 0 - decal textures glTexCoordPointer( 2, GL_FLOAT, sizeof(BSP_VERTEX), &vertices[0].decalS); //Unit 1 - Lightmaps glClientActiveTextureARB(GL_TEXTURE1_ARB); glTexCoordPointer(2, GL_FLOAT, sizeof(BSP_VERTEX), &vertices[0].lightmapS); glClientActiveTextureARB(GL_TEXTURE0_ARB); //bind textures //unit 0 - decal texture glBindTexture(GL_TEXTURE_2D, decalTextures[polygonFaces[polygonFaceNumber].textureIndex]); //unit 1 - lightmap glActiveTextureARB(GL_TEXTURE1_ARB); if(polygonFaces[polygonFaceNumber].lightmapIndex>=0) //only bind a lightmap if one exists glBindTexture( GL_TEXTURE_2D, lightmapTextures[polygonFaces[polygonFaceNumber].lightmapIndex]); else glBindTexture(GL_TEXTURE_2D, whiteTexture); glActiveTextureARB(GL_TEXTURE0_ARB); //Draw face glDrawArrays( GL_TRIANGLE_FAN, polygonFaces[polygonFaceNumber].firstVertexIndex, polygonFaces[polygonFaceNumber].numVertices); }
//DRAWING FUNCTIONS //Draw all faces marked as visible void BSP::Draw() { glFrontFace(GL_CW); //enable vertex arrays glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTextureARB(GL_TEXTURE1_ARB); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTextureARB(GL_TEXTURE0_ARB); //loop through faces for(int i=0; i<numTotalFaces; ++i) { //if this face is to be drawn, draw it if(facesToDraw.IsSet(i)) DrawFace(i); } //disable vertex arrays glClientActiveTextureARB(GL_TEXTURE1_ARB); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTextureARB(GL_TEXTURE0_ARB); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); glFrontFace(GL_CCW); }
/** * @brief Render a face. * @param face_index The index of the face to render */ inline void EQ3Map::render_face(int face_index) { struct q3bsp_face_t* face = (faces + face_index); /* bind the texture */ glActiveTextureARB(GL_TEXTURE0_ARB); glClientActiveTextureARB(GL_TEXTURE0_ARB); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(2, GL_FLOAT, sizeof(struct q3bsp_vertex_t), vertexes[face->vertex].texcoord); glClientActiveTextureARB(GL_TEXTURE0_ARB); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, textures[face->texture].gl_text_id); /* bind the light map */ glActiveTextureARB(GL_TEXTURE1_ARB); glClientActiveTextureARB(GL_TEXTURE1_ARB); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(2, GL_FLOAT, sizeof(struct q3bsp_vertex_t), vertexes[face->vertex].lightmapcoord); glClientActiveTextureARB(GL_TEXTURE1_ARB); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, lightmaps[face->lm_index].gl_text_id); /* draw everything */ glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); //glEnableClientState(GL_COLOR_ARRAY); glVertexPointer(3, GL_FLOAT, sizeof(struct q3bsp_vertex_t), vertexes[face->vertex].position); glNormalPointer(GL_FLOAT, sizeof(struct q3bsp_vertex_t), vertexes[face->vertex].normal); //glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(struct q3bsp_vertex_t), vertexes[face->vertex].color); glDrawRangeElements(GL_TRIANGLES, 0, face->num_meshverts - 1, face->num_meshverts, GL_UNSIGNED_INT, &meshverts[face->meshvert]); }
void OpenGL_Engine::drawBump(GraphShadow &e, const TexCoords *coords, matrix34 const matrix, v3 const light, uid bufId, int curTexArb, Image *img) { glActiveTextureARB(GL_TEXTURE0_ARB + curTexArb); glClientActiveTextureARB(GL_TEXTURE0_ARB + curTexArb); //Bind normalisation cube map to texture unit 1 glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, normalisationCubeMap); glEnable(GL_TEXTURE_CUBE_MAP_ARB); //Send tangent space light vectors for normalisation to unit 1 tangentSpaceLightBufferedArray tangentSpaceLight; tangentSpaceLight.changed = true; tangentSpaceLight.id = bufId; tangentSpaceLight.resize(e.vertexes->size()); TexCoords3f *sTangent, *tTangent; getTangentSpace(e.vertexes, coords, e.faceMaterials, e.normals, &sTangent, &tTangent); genTangentSpaceLight(*sTangent, *tTangent, *e.vertexes, *e.normals, matrix, light, tangentSpaceLight); if(BindTexCoords3f) (this->*BindTexCoords3f)(&tangentSpaceLight); glActiveTextureARB(GL_TEXTURE0_ARB + curTexArb + 1); glClientActiveTextureARB(GL_TEXTURE0_ARB + curTexArb + 1); (this->*BindTexture)(*img, true); if(BindTexCoords) (this->*BindTexCoords)(coords, NULL); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_DOT3_RGB_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB); }
/* ** GL_SelectTexture */ void GL_SelectTexture( int unit ) { if ( glState.currenttmu == unit ) { return; } if ( unit == 0 ) { glActiveTextureARB( GL_TEXTURE0_ARB ); GLimp_LogComment( "glActiveTextureARB( GL_TEXTURE0_ARB )\n" ); glClientActiveTextureARB( GL_TEXTURE0_ARB ); GLimp_LogComment( "glClientActiveTextureARB( GL_TEXTURE0_ARB )\n" ); } else if ( unit == 1 ) { glActiveTextureARB( GL_TEXTURE1_ARB ); GLimp_LogComment( "glActiveTextureARB( GL_TEXTURE1_ARB )\n" ); glClientActiveTextureARB( GL_TEXTURE1_ARB ); GLimp_LogComment( "glClientActiveTextureARB( GL_TEXTURE1_ARB )\n" ); } else { ri.Error( ERR_DROP, "GL_SelectTexture: unit = %i", unit ); } glState.currenttmu = unit; }
// Renders the requested list of faces // Normal faces are rendered with vertex arrays and multitexturing. The first TMU handles the // lightmap, while the second TMU handles the surface texture itself. int GLDriver::drawGeometryList(GeometryList* l) { Assert(l != NULL); if(lastTime == 0) lastTime = timeGetTime(); renderTime = timeGetTime(); qmap = l->mapData; ShaderUtils::renderTime = renderTime; ShaderUtils::qmap = qmap; ShaderUtils::textureFactory = textureFactory; qsort(l->faces, l->faceCount, sizeof(int), TransSort); glActiveTextureARB(GL_TEXTURE1_ARB); glDisable(GL_TEXTURE_2D); glClientActiveTextureARB(GL_TEXTURE1_ARB); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glActiveTextureARB(GL_TEXTURE0_ARB); glEnable(GL_TEXTURE_2D); glClientActiveTextureARB(GL_TEXTURE0_ARB); glDepthFunc(GL_LEQUAL); float timeDiff = renderTime - lastTime; drawSky(l, timeDiff); drawFaces(l, timeDiff); drawMeshes(l, timeDiff); drawPatches(l); //drawFog(l); lastTime = renderTime; return 0; }
void CVertexArrayRange::DrawArrayT2(int drawType,int stride) { if(stripIndex==0 || stripArray[stripIndex-1]!=drawIndex) EndStrip(); glEnableClientState(GL_VERTEX_ARRAY_RANGE_NV); glVertexPointer(3,GL_FLOAT,stride,&drawArray[0]); glTexCoordPointer(2,GL_FLOAT,stride,&drawArray[3]); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_VERTEX_ARRAY); if(multiTextureEnabled){ glClientActiveTextureARB(GL_TEXTURE1_ARB); glTexCoordPointer(2,GL_FLOAT,stride,&drawArray[5]); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTextureARB(GL_TEXTURE0_ARB); } int oldIndex=0; for(int a=0;a<stripIndex;a++){ glDrawArrays(drawType,oldIndex*4/stride,stripArray[a]*4/stride-oldIndex*4/stride); oldIndex=stripArray[a]; } if(multiTextureEnabled){ glClientActiveTextureARB(GL_TEXTURE1_ARB); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTextureARB(GL_TEXTURE0_ARB); } glSetFenceNV(fence, GL_ALL_COMPLETED_NV); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_VERTEX_ARRAY_RANGE_NV); }
/* Multi-Texture Example using Open GL Vertex Buffer Submission. */ void RenderCallback(GLuint texID0, GLuint texID1) { glLoadIdentity(); glTranslatef(0.0f, 0.0f, -3.0f); /* Enable Client States for OpenGL Arrays Submission */ glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glEnableClientState(GL_INDEX_ARRAY); /* Bind texture to GL_TEXTURE0_ARB and set texture parameters */ glActiveTextureARB(GL_TEXTURE0_ARB); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, texID0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_FILTER, GL_LINEAR); /* Bind multi-texture to GL_TEXTURE1_ARB and set texture parameters */ glActiveTextureARB(GL_TEXTURE1_ARB); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, texID1); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_FILTER, GL_LINEAR); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); /* Set Blending Mode */ glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA); /* Bind texture coordinates to GL_TEXTURE0_ARB */ glTexCoordPointer(2, GL_FLOAT, 0, TEXCOORD_ARRAY); /* Bind texture coordinates to GL_TEXTURE1_ARB */ glClientActiveTextureARB(GL_TEXTURE1_ARB); glTexCoordPointer(2, GL_FLOAT, 0, TEXCOORD_ARRAY); glClientActiveTextureARB(GL_TEXTURE0_ARB); /* Bind the Color Array */ glColorPointer(1, GL_UNSIGNED_INT, 0, ARGB_ARRAY); /* Bind the Vertex Array */ glVertexPointer(3, GL_FLOAT, 0, VERTEX_ARRAY); /* Render the Vertices as Indexed Arrays using glDrawElements */ glDrawElements(GL_TRIANGLE_STRIP, 4 * 1, GL_UNSIGNED_BYTE, INDEX_ARRAY); /* Disable GL_TEXTURE1 */ glActiveTextureARB(GL_TEXTURE1_ARB); glBindTexture(GL_TEXTURE_2D, 0); glDisable(GL_TEXTURE_2D); /* Make sure to set glActiveTexture back to GL_TEXTURE0_ARB when finished */ glActiveTextureARB(GL_TEXTURE0_ARB); glBindTexture(GL_TEXTURE_2D, 0); glDisable(GL_TEXTURE_2D); /* Disable Vertex, Color and Texture Coord Arrays */ glDisableClientState(GL_INDEX_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); }
void LLDrawPoolTerrain::renderSimple() { glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); LLVector4 tp0, tp1; //---------------------------------------------------------------------------- // Pass 1/1 // Stage 0: Base terrain texture pass mTexturep->addTextureStats(1024.f*1024.f); mTexturep->bind(0); glActiveTextureARB(GL_TEXTURE0_ARB); glEnable(GL_TEXTURE_2D); // Texture unit 2 glClientActiveTextureARB(GL_TEXTURE0_ARB); LLVector3 origin_agent = mDrawFace[0]->getDrawable()->getVObj()->getRegion()->getOriginAgent(); F32 tscale = 1.f/256.f; tp0.setVec(tscale, 0.f, 0.0f, -1.f*(origin_agent.mV[0]/256.f)); tp1.setVec(0.f, tscale, 0.0f, -1.f*(origin_agent.mV[1]/256.f)); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); glTexGenfv(GL_S, GL_OBJECT_PLANE, tp0.mV); glTexGenfv(GL_T, GL_OBJECT_PLANE, tp1.mV); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PRIMARY_COLOR_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); drawLoop(); //---------------------------------------------------------------------------- // Restore Texture Unit 0 defaults LLImageGL::unbindTexture(0, GL_TEXTURE_2D); glClientActiveTextureARB(GL_TEXTURE0_ARB); glActiveTextureARB(GL_TEXTURE0_ARB); glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); glMatrixMode(GL_TEXTURE); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); // Restore non Texture Unit specific defaults glDisableClientState(GL_NORMAL_ARRAY); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); }
void CQuake3BSP::RenderFace(int faceIndex) { // Here we grab the face from the index passed in tBSPFace *pFace = &m_pFaces[faceIndex]; // Assign our array of face vertices for our vertex arrays and enable vertex arrays glVertexPointer(3, GL_FLOAT, sizeof(tBSPVertex), &(m_pVerts[pFace->startVertIndex].vPosition)); glEnableClientState(GL_VERTEX_ARRAY); // If we want to render the textures if(g_bTextures) { // Set the current pass as the first texture (For multi-texturing) glActiveTextureARB(GL_TEXTURE0_ARB); // Give OpenGL the texture coordinates for the first texture, and enable that texture glClientActiveTextureARB(GL_TEXTURE0_ARB); glTexCoordPointer(2, GL_FLOAT, sizeof(tBSPVertex), &(m_pVerts[pFace->startVertIndex].vTextureCoord)); // Set our vertex array client states for allowing texture coordinates glEnableClientState(GL_TEXTURE_COORD_ARRAY); // Turn on texture arrays for the first pass glClientActiveTextureARB(GL_TEXTURE0_ARB); // Turn on texture mapping and bind the face's texture map glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, m_textures[pFace->textureID]); } if(g_bLightmaps) { // Set the current pass as the second lightmap texture_ glActiveTextureARB(GL_TEXTURE1_ARB); // Turn on texture arrays for the second lightmap pass glClientActiveTextureARB(GL_TEXTURE1_ARB); glEnableClientState(GL_TEXTURE_COORD_ARRAY); // Next, we need to specify the UV coordinates for our lightmaps. This is done // by switching to the second texture and giving OpenGL our lightmap array. glClientActiveTextureARB(GL_TEXTURE1_ARB); glTexCoordPointer(2, GL_FLOAT, sizeof(tBSPVertex), &(m_pVerts[pFace->startVertIndex].vLightmapCoord)); // Turn on texture mapping and bind the face's lightmap over the texture glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, m_lightmaps[pFace->lightmapID]); } // Render our current face to the screen with vertex arrays glDrawElements(GL_TRIANGLES, pFace->numOfIndices, GL_UNSIGNED_INT, &(m_pIndices[pFace->startIndex]) ); }
void OpenGLBatch::draw(){ unsigned int i, nFormats = formats.getCount(); if (GL_ARB_vertex_buffer_object_supported && vertexBuffer != 0){ glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertexBuffer); } for (i = 0; i < nFormats; i++){ Format format = formats[i]; GLenum type = getGLType(format.attFormat); GLenum array = arrayType[format.attType]; char *basePointer = (vertexBuffer != 0)? NULL : vertices; switch (format.attType){ case ATT_VERTEX: glVertexPointer(format.size, type, vertexSize, basePointer + format.offset); break; case ATT_NORMAL: glNormalPointer(type, vertexSize, basePointer + format.offset); break; case ATT_TEXCOORD: glClientActiveTextureARB(GL_TEXTURE0_ARB + format.index); glTexCoordPointer(format.size, type, vertexSize, basePointer + format.offset); break; case ATT_COLOR: glColorPointer(format.size, type, vertexSize, basePointer + format.offset); break; } glEnableClientState(array); } if (nIndices == 0){ glDrawArrays(getGLPrimitive(primitiveType), 0, nVertices); } else { if (indexBuffer != 0) glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, indexBuffer); glDrawElements(getGLPrimitive(primitiveType), nIndices, indexSize == 2? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, (indexBuffer != 0)? NULL : indices); if (indexBuffer != 0) glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0); } for (i = 0; i < nFormats; i++){ if (formats[i].attType == ATT_TEXCOORD){ glClientActiveTextureARB(GL_TEXTURE0_ARB + formats[i].index); } glDisableClientState(arrayType[formats[i].attType]); } if (GL_ARB_vertex_buffer_object_supported && vertexBuffer != 0){ glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); } }
static void init_arrays(void) { glVertexPointer(2, GL_FLOAT, 0, VertArray); glEnableClientState(GL_VERTEX_ARRAY); glClientActiveTextureARB(GL_TEXTURE0_ARB); glTexCoordPointer(2, GL_FLOAT, 0, Tex0Array); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTextureARB(GL_TEXTURE1_ARB); glTexCoordPointer(2, GL_FLOAT, 0, Tex1Array); glEnableClientState(GL_TEXTURE_COORD_ARRAY); }
// virtual void setupVertexBuffer(U32 data_mask) { if (LLGLSLShader::sNoFixedFunction) { //just use default if shaders are in play LLVertexBuffer::setupVertexBuffer(data_mask & ~(MAP_TEXCOORD2 | MAP_TEXCOORD3)); return; } volatile U8* base = useVBOs() ? (U8*) mAlignedOffset : mMappedData; //assume tex coords 2 and 3 are present U32 type_mask = mTypeMask | MAP_TEXCOORD2 | MAP_TEXCOORD3; if ((data_mask & type_mask) != data_mask) { llerrs << "LLVertexBuffer::setupVertexBuffer missing required components for supplied data mask." << llendl; } if (data_mask & MAP_NORMAL) { glNormalPointer(GL_FLOAT, LLVertexBuffer::sTypeSize[TYPE_NORMAL], (void*)(base + mOffsets[TYPE_NORMAL])); } if (data_mask & MAP_TEXCOORD3) { //substitute tex coord 1 for tex coord 3 glClientActiveTextureARB(GL_TEXTURE3_ARB); glTexCoordPointer(2,GL_FLOAT, LLVertexBuffer::sTypeSize[TYPE_TEXCOORD1], (void*)(base + mOffsets[TYPE_TEXCOORD1])); glClientActiveTextureARB(GL_TEXTURE0_ARB); } if (data_mask & MAP_TEXCOORD2) { //substitute tex coord 0 for tex coord 2 glClientActiveTextureARB(GL_TEXTURE2_ARB); glTexCoordPointer(2,GL_FLOAT, LLVertexBuffer::sTypeSize[TYPE_TEXCOORD0], (void*)(base + mOffsets[TYPE_TEXCOORD0])); glClientActiveTextureARB(GL_TEXTURE0_ARB); } if (data_mask & MAP_TEXCOORD1) { glClientActiveTextureARB(GL_TEXTURE1_ARB); glTexCoordPointer(2,GL_FLOAT, LLVertexBuffer::sTypeSize[TYPE_TEXCOORD1], (void*)(base + mOffsets[TYPE_TEXCOORD1])); glClientActiveTextureARB(GL_TEXTURE0_ARB); } if (data_mask & MAP_TANGENT) { glClientActiveTextureARB(GL_TEXTURE2_ARB); glTexCoordPointer(3,GL_FLOAT, LLVertexBuffer::sTypeSize[TYPE_TANGENT], (void*)(base + mOffsets[TYPE_TANGENT])); glClientActiveTextureARB(GL_TEXTURE0_ARB); } if (data_mask & MAP_TEXCOORD0) { glTexCoordPointer(2,GL_FLOAT, LLVertexBuffer::sTypeSize[TYPE_TEXCOORD0], (void*)(base + mOffsets[TYPE_TEXCOORD0])); } if (data_mask & MAP_COLOR) { glColorPointer(4, GL_UNSIGNED_BYTE, LLVertexBuffer::sTypeSize[TYPE_COLOR], (void*)(base + mOffsets[TYPE_COLOR])); } if (data_mask & MAP_VERTEX) { glVertexPointer(3,GL_FLOAT, LLVertexBuffer::sTypeSize[TYPE_VERTEX], (void*)(base + 0)); } }
// virtual (default) void LLVertexBuffer::setupVertexBuffer(U32 data_mask) const { LLMemType mt(LLMemType::MTYPE_VERTEX_DATA); stop_glerror(); 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_VERTEX) { glVertexPointer(3,GL_FLOAT, stride, (void*)(base + 0)); } if (data_mask & MAP_NORMAL) { glNormalPointer(GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_NORMAL])); } if (data_mask & MAP_TEXCOORD2) { glClientActiveTextureARB(GL_TEXTURE1_ARB); glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD2])); } if (data_mask & MAP_TEXCOORD) { glClientActiveTextureARB(GL_TEXTURE0_ARB); glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD])); } if (data_mask & MAP_COLOR) { glColorPointer(4, GL_UNSIGNED_BYTE, stride, (void*)(base + mOffsets[TYPE_COLOR])); } if (data_mask & MAP_BINORMAL) { glVertexAttribPointerARB(6, 3, GL_FLOAT, FALSE, stride, (void*)(base + mOffsets[TYPE_BINORMAL])); } 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])); } llglassertok(); }
void fge_mesh_render(struct fge_mesh mesh, struct fge_glsl *prog, void (*prog_exec)(struct fge_glsl *prog, struct fge_mesh *mesh)) { int32 stride; stride = sizeof(struct fge_vertex); if ((!glIsBufferARB(mesh.vertex_buffer)) || (!glIsBufferARB(mesh.index_buffer))){ return; } glPushAttrib(GL_ALL_ATTRIB_BITS); glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS); glEnableClientState(GL_VERTEX_ARRAY); glBindBufferARB(GL_ARRAY_BUFFER_ARB, mesh.vertex_buffer); glVertexPointer(3, GL_FLOAT, stride, (void *)0); glEnableClientState(GL_NORMAL_ARRAY); glNormalPointer(GL_FLOAT, stride, (void*)off_sets[FGE_OFFSET_N]); glClientActiveTextureARB(GL_TEXTURE0_ARB); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(2, GL_FLOAT, stride, (void*)off_sets[FGE_OFFSET_TEX]); glClientActiveTextureARB(GL_TEXTURE1_ARB); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(3, GL_FLOAT, stride, (void*)off_sets[FGE_OFFSET_T]); glClientActiveTextureARB(GL_TEXTURE2_ARB); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(3, GL_FLOAT, stride, (void*)off_sets[FGE_OFFSET_B]); if (prog_exec != NULL){ prog_exec(prog, &mesh); } glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, mesh.index_buffer); glDrawElements(GL_TRIANGLES, 3 * mesh.count_faces, GL_UNSIGNED_INT, 0); glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0); glPopAttrib(); glPopClientAttrib(); }
void finishMultiTexturing() { glActiveTextureARB(GL_TEXTURE1_ARB); glDisable(GL_TEXTURE_2D); glActiveTextureARB(GL_TEXTURE0_ARB); glClientActiveTextureARB(GL_TEXTURE1_ARB); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTextureARB(GL_TEXTURE0_ARB); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glPopAttrib(); }
void GL_SelectTexture(int tmu) { if (gl_state.locked) { gl_state.newTmu = tmu; return; } if (tmu == gl_state.currentTmu) return; int tex; if (GL_SUPPORT(QGL_ARB_MULTITEXTURE)) { // ARB_multitexture tex = GL_TEXTURE0_ARB + tmu; glActiveTextureARB(tex); glClientActiveTextureARB(tex); // affects gl[Enable|Disable]ClientState(GL_TEXTURE_COORD_ARRAY) and glTexCoordPointer() only } else { // SGIS_multitexture tex = GL_TEXTURE0_SGIS + tmu; glSelectTextureSGIS(tex); glSelectTextureCoordSetSGIS(tex); } gl_state.currentTmu = tmu; }
void Mesh::renderUnbind() { if (GfxMan.isGL3()) { // So long as each mesh rebinds what it needs, there's actually no need to bind 0 here. glBindVertexArray(0); } else { const VertexDecl &decl = _vertexBuffer.getVertexDecl(); for (size_t i = 0; i < decl.size(); ++i) { switch (decl[i].index) { case VPOSITION: glDisableClientState(GL_VERTEX_ARRAY); break; case VNORMAL: glDisableClientState(GL_NORMAL_ARRAY); break; case VCOLOR: glDisableClientState(GL_COLOR_ARRAY); break; default: // VTCOORD glClientActiveTextureARB(GL_TEXTURE0 + decl[i].index - VTCOORD); glDisableClientState(GL_TEXTURE_COORD_ARRAY); break; } } glBindBuffer(GL_ARRAY_BUFFER, 0); } }
void Mesh::renderBind() { if (GfxMan.isGL3()) { glBindVertexArray(_vao); } else { const VertexDecl &decl = _vertexBuffer.getVertexDecl(); glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer.getVBO()); for (size_t i = 0; i < decl.size(); ++i) { intptr_t offset = (intptr_t) (decl[i].pointer); offset -= (intptr_t) (_vertexBuffer.getData()); switch (decl[i].index) { case VPOSITION: glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(decl[i].size, decl[i].type, decl[i].stride, (GLvoid *)(offset)); break; case VNORMAL: glEnableClientState(GL_NORMAL_ARRAY); glNormalPointer(decl[i].type, decl[i].stride, (GLvoid *)(offset)); break; case VCOLOR: glEnableClientState(GL_COLOR_ARRAY); glColorPointer(decl[i].size, decl[i].type, decl[i].stride, (GLvoid *)(offset)); break; default: // VTCOORD glClientActiveTextureARB(GL_TEXTURE0 + decl[i].index - VTCOORD); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(decl[i].size, decl[i].type, decl[i].stride, (GLvoid *)(offset)); break; } } } }
void Sector::drawParticles(Renderer *renderer, TextureID particle){ if (hasBeenDrawn){ renderer->setTextures(particle); renderer->setBlending(ONE, ONE); renderer->setMask(COLOR); renderer->apply(); glClientActiveTextureARB(GL_TEXTURE0_ARB); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_COLOR_ARRAY); for (unsigned int j = 0; j < lights.getCount(); j++){ glVertexPointer (3, GL_FLOAT, sizeof(vec3) + sizeof(vec2) + sizeof(vec4), lights[j].vertexArray); glTexCoordPointer(2, GL_FLOAT, sizeof(vec3) + sizeof(vec2) + sizeof(vec4), lights[j].vertexArray + sizeof(vec3)); glColorPointer (4, GL_FLOAT, sizeof(vec3) + sizeof(vec2) + sizeof(vec4), lights[j].vertexArray + sizeof(vec3) + sizeof(vec2)); glDrawArrays(GL_QUADS, 0, lights[j].particles->getParticleCount() * 4); } glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_COLOR_ARRAY); } else { for (unsigned int j = 0; j < lights.getCount(); j++){ lights[j].particles->updateTime(time); } } }
void GLES2RendererVertexBuffer::unbind(PxU32 streamID) { GLES2RendererMaterial *mat = g_hackCurrentMat; for(PxU32 i=0; i<NUM_SEMANTICS; i++) { Semantic semantic = (Semantic)i; const SemanticDesc &sm = m_semanticDescs[semantic]; if(sm.format < NUM_FORMATS) { switch (semantic) { case SEMANTIC_POSITION: unbindGL(mat->m_program[mat->m_currentPass].positionAttr); break; case SEMANTIC_COLOR: unbindGL(mat->m_program[mat->m_currentPass].positionAttr); break; case SEMANTIC_NORMAL: unbindGL(mat->m_program[mat->m_currentPass].normalAttr); break; case SEMANTIC_TANGENT: unbindGL(mat->m_program[mat->m_currentPass].tangentAttr); break; case SEMANTIC_BONEINDEX: unbindGL(mat->m_program[mat->m_currentPass].boneIndexAttr); break; case SEMANTIC_BONEWEIGHT: unbindGL(mat->m_program[mat->m_currentPass].boneWeightAttr); break; default: /* __android_log_print(ANDROID_LOG_DEBUG, "GLES2RendererVertexBuffer", "semantic: %d", i); RENDERER_ASSERT(0, "Unable to unbind Vertex Buffer Semantic."); */ break; } } } for(PxU32 i=0; i<8; i++) { glActiveTextureARB((GLenum)(GL_TEXTURE0_ARB + i)); glClientActiveTextureARB((GLenum)(GL_TEXTURE0_ARB + i)); unbindGL(mat->m_program[mat->m_currentPass].texcoordAttr[i]); } }
void VAR::texCoordPointer(uint unit) const { debugAssert(valid()); debugAssertM(GLCaps::supports_GL_ARB_multitexture() || (unit == 0), "Graphics card does not support multitexture"); if (GLCaps::supports_GL_ARB_multitexture()) { glClientActiveTextureARB(GL_TEXTURE0_ARB + unit); } glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(elementSize / sizeOfGLFormat(underlyingRepresentation), underlyingRepresentation, elementSize, _pointer); if (GLCaps::supports_GL_ARB_multitexture()) { glClientActiveTextureARB(GL_TEXTURE0_ARB); } }
void TestApp::render() { if(getFPS()>1.0f) speedFactor = SPEEDCONST/getFPS(); glDisable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glDisable(GL_TEXTURE_2D); glDisable(GL_LIGHTING); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); cam->toOpenGL(); /* glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(800, 0, 600, 0, 0, 1.); glMatrixMode(GL_MODELVIEW); glLoadIdentity();*/ glEnable(GL_FRAGMENT_PROGRAM_ARB); progFp->bind(); //shader->setUniform("heightfield", 0); glClientActiveTextureARB(GL_TEXTURE0); tex->bind(); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 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); glColor3f(1, 1, 0); glBegin(GL_QUADS); for(int i = 0; i < 1; i++) { glTexCoord2f(0, 1); glVertex3f(-0.01, 0.01, i*0.01); glTexCoord2f(0, 0); glVertex3f(-0.01, -0.01, i*0.01); glTexCoord2f(1, 0); glVertex3f(0.01, -.01, i*0.01); glTexCoord2f(1, 1); glVertex3f(.01, .01, i*0.01); } glEnd(); /* glBegin(GL_QUADS); glTexCoord2f(0, 1); glVertex2f(0, 0); glTexCoord2f(0, 0); glVertex2f(256, 0); glTexCoord2f(1, 0); glVertex2f(256, 256); glTexCoord2f(1, 1); glVertex2f(0, 256); glEnd(); */ glDisable(GL_FRAGMENT_PROGRAM_ARB); Shader::useFixedPipeline(); printInfos(); }
void client_active_texture(int stage) // Set the currently active texture stage for vertex array // setup; use GL_TEXTUREx_ARB. { if (glClientActiveTextureARB) { glClientActiveTextureARB(stage); } }
void redraw() { // Clear the screen and the depth buffer glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); // Set matrices glMatrixMode( GL_PROJECTION ); glLoadIdentity(); glOrtho(0, 640, 0, 480, -1, 1); glViewport(0, 0, 640, 480); glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); // STAGE 0 glClientActiveTextureARB( GL_TEXTURE0_ARB ); glActiveTextureARB( GL_TEXTURE0_ARB ); glBindTexture( GL_TEXTURE_2D, datatexID ); glEnable( GL_TEXTURE_2D ); glColor3f( 1.0, 1.0, 1.0 ); GLdouble plane[4] = {1.0, 0.0, 0.0, 0.0}; glClipPlane (GL_CLIP_PLANE0, plane); glEnable (GL_CLIP_PLANE0); if(enabled) { glUseProgramObjectARB( g_programObj ); GLint texture = glGetUniformLocationARB( g_programObj, "OGL2Texture" ); GLfloat param = glGetUniformLocationARB( g_programObj, "OGL2Param" ); glUniform1iARB( texture, 0 ); glUniform4fARB( param, 0, 0, brightness, 0 ); } // Draw glBegin( GL_QUADS ); glTexCoord2f( 0.0f, 0.0f ); glVertex3f( 0.0f, 0.0f, 0.0f ); glTexCoord2f( 1.0f, 0.0f ); glVertex3f( 640.0f, 0.0f, 0.0f ); glTexCoord2f( 1.0f, 1.0f ); glVertex3f( 640.0f, 480.0f, 0.0f ); glTexCoord2f( 0.0f, 1.0f ); glVertex3f( 0.0f, 480.0f, 0.0f ); glEnd(); if(enabled) { glUseProgramObjectARB( NULL ); } glDisable (GL_CLIP_PLANE0); glXSwapBuffers( dpy, win ); }
//Draw a mesh face void BSP::DrawMeshFace(int meshFaceNumber) { //skip this face if its texture was not loaded if(isTextureLoaded[meshFaces[meshFaceNumber].textureIndex]==false) return; //set array pointers glVertexPointer( 3, GL_FLOAT, sizeof(BSP_VERTEX), &vertices[meshFaces[meshFaceNumber].firstVertexIndex].position); glTexCoordPointer( 2, GL_FLOAT, sizeof(BSP_VERTEX), &vertices[meshFaces[meshFaceNumber].firstVertexIndex].decalS); glClientActiveTextureARB(GL_TEXTURE1_ARB); glTexCoordPointer( 2, GL_FLOAT, sizeof(BSP_VERTEX), &vertices[meshFaces[meshFaceNumber].firstVertexIndex].lightmapS); glClientActiveTextureARB(GL_TEXTURE0_ARB); //bind textures //unit 0 - decal texture glBindTexture(GL_TEXTURE_2D, decalTextures[meshFaces[meshFaceNumber].textureIndex]); //unit 1 - lightmap glActiveTextureARB(GL_TEXTURE1_ARB); if(meshFaces[meshFaceNumber].lightmapIndex>=0) //only bind a lightmap if one exists glBindTexture(GL_TEXTURE_2D, lightmapTextures[meshFaces[meshFaceNumber].lightmapIndex]); else glBindTexture(GL_TEXTURE_2D, whiteTexture); glActiveTextureARB(GL_TEXTURE0_ARB); //draw the face, using meshIndices if(!EXT_draw_range_elements_supported) { glDrawElements( GL_TRIANGLES, meshFaces[meshFaceNumber].numMeshIndices, GL_UNSIGNED_INT, &meshIndices[meshFaces[meshFaceNumber].firstMeshIndex]); } else { glDrawRangeElementsEXT( GL_TRIANGLES, 0, meshFaces[meshFaceNumber].numVertices, meshFaces[meshFaceNumber].numMeshIndices, GL_UNSIGNED_INT, &meshIndices[meshFaces[meshFaceNumber].firstMeshIndex]); } }
void enableMultiTexturing() { glPushAttrib(GL_ALL_ATTRIB_BITS); /* Unit 0 */ glActiveTextureARB(GL_TEXTURE0_ARB); glEnable(GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); /* Unit 1 */ glActiveTextureARB(GL_TEXTURE1_ARB); glEnable(GL_TEXTURE_2D); /* Set up environment to draw textures, lightmaps etc. */ glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_PREVIOUS_EXT); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR); glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, 2.0f); /* Set back to unit 0 */ glActiveTextureARB(GL_TEXTURE0_ARB); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTextureARB(GL_TEXTURE1_ARB); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTextureARB(GL_TEXTURE0_ARB); }
void CVertexArray::DrawArrayT2(const int drawType,int stride) { CheckEndStrip(); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(3,GL_FLOAT,stride,drawArray); glTexCoordPointer(2,GL_FLOAT,stride,drawArray+3); glClientActiveTextureARB(GL_TEXTURE1_ARB); glTexCoordPointer(2,GL_FLOAT,stride,drawArray+5); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTextureARB(GL_TEXTURE0_ARB); DrawArrays(drawType, stride); glClientActiveTextureARB(GL_TEXTURE1_ARB); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glClientActiveTextureARB(GL_TEXTURE0_ARB); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); }
void VertexBufferGL::ClearDrawStates() { glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); glBindBufferARB(GL_ARRAY_BUFFER_ARB,0); glActiveTextureARB(GL_TEXTURE0_ARB); glBindTexture(GL_TEXTURE_2D,0); glClientActiveTextureARB(GL_TEXTURE0_ARB); glDisable(GL_TEXTURE_2D); }