//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);
}
