void DebugDrawing3D::draw2() { glPushAttrib(GL_ENABLE_BIT | GL_LIGHTING_BIT); glPushMatrix(); if(flip) glRotated(180.f, 0, 0, 1); // Convert mm to m. glScaled(0.001, 0.001, 0.001); // Custom scaling. glScaled(scaleX, scaleY, scaleZ); // Custom rotation. if(rotateX != 0) glRotated(toDegrees(rotateX), 1, 0, 0); if(rotateY != 0) glRotated(toDegrees(rotateY), 0, 1, 0); if(rotateZ != 0) glRotated(toDegrees(rotateZ), 0, 0, 1); // Custom translation. glTranslated(transX, transY, transZ); // //glDisable(GL_LIGHTING); glEnable(GL_NORMALIZE); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Draw all polygons/triangles. std::vector<Polygon>::iterator p; for(p = polygons.begin(); p != polygons.end(); ++p) { glColor4ub(p->color.r, p->color.g, p->color.b, p->color.a); glBegin(GL_TRIANGLES); glVertex3d(p->points[0].x, p->points[0].y, p->points[0].z); glVertex3d(p->points[1].x, p->points[1].y, p->points[1].z); glVertex3d(p->points[2].x, p->points[2].y, p->points[2].z); glEnd(); } // Draw all lines. if(!lines.empty()) { glPushAttrib(GL_LINE_BIT); std::vector<Line>::iterator l; for(l = lines.begin(); l != lines.end(); ++l) { glLineWidth(l->width); glColor4ub(l->color.r, l->color.g, l->color.b, l->color.a); glBegin(GL_LINES); glVertex3d(l->points[0].x, l->points[0].y, l->points[0].z); glVertex3d(l->points[1].x, l->points[1].y, l->points[1].z); glEnd(); } glPopAttrib(); } // Draw all points. if(!dots.empty()) { glPushAttrib(GL_POINT_BIT); std::vector<Dot>::iterator d; for(d = dots.begin(); d != dots.end(); ++d) { // Since each point may have a different size we can't handle all // points in a single glBegin(GL_POINTS). // ( glPointSize is not allowed in a glBegin(...). ) glPointSize(d->width); glColor4ub(d->color.r, d->color.g, d->color.b, d->color.a); glBegin(GL_POINTS); glVertex3d(d->point.x, d->point.y, d->point.z); glEnd(); } glPopAttrib(); } // draw spheres std::vector<Sphere>::iterator s; for(s = spheres.begin(); s != spheres.end(); ++s) { glColor4ub(s->color.r, s->color.g, s->color.b, s->color.a); glPushMatrix(); glTranslated(s->point.x, s->point.y, s->point.z); GLUquadric* q = gluNewQuadric(); gluSphere(q, s->radius, 16, 16); gluDeleteQuadric(q); glPopMatrix(); } // Draw all quads. std::vector<Quad>::iterator q; for(q = quads.begin(); q != quads.end(); ++q) { glColor4ub(q->color.r, q->color.g, q->color.b, q->color.a); glBegin(GL_QUADS); const Vector3<>& p1 = q->points[0]; const Vector3<>& p2 = q->points[1]; const Vector3<>& p3 = q->points[2]; const Vector3<>& p4 = q->points[3]; Vector3<> u(p2.x - p1.x, p2.y - p1.y, p2.z - p1.z); Vector3<> v(p3.x - p1.x, p3.y - p1.y, p3.z - p1.z); Vector3<> n(u.y * v.z - u.z * v.y, u.z * v.x - u.x * v.z, u.x * v.y - u.y * v.x); n.normalize(); glNormal3fv(&n.x); glVertex3fv(&p1.x); glVertex3fv(&p2.x); glVertex3fv(&p3.x); glVertex3fv(&p4.x); glEnd(); } // draw cylinders std::vector<Cylinder>::iterator c; for(c = cylinders.begin(); c != cylinders.end(); ++c) { glColor4ub(c->color.r, c->color.g, c->color.b, c->color.a); glPushMatrix(); glTranslated(c->point.x, c->point.y, c->point.z); if(c->rotation.x != 0) glRotated(toDegrees(c->rotation.x), 1, 0, 0); if(c->rotation.y != 0) glRotated(toDegrees(c->rotation.y), 0, 1, 0); if(c->rotation.z != 0) glRotated(toDegrees(c->rotation.z), 0, 0, 1); glTranslated(0, 0, -c->height / 2); GLUquadric* q = gluNewQuadric(); gluCylinder(q, c->baseRadius, c->topRadius, c->height, 16, 1); glRotated(180, 0, 1, 0); if(c->baseRadius > 0.f) gluDisk(q, 0, c->baseRadius, 16, 1); glRotated(180, 0, 1, 0); glTranslated(0, 0, c->height); if(c->topRadius > 0.f) gluDisk(q, 0, c->topRadius, 16, 1); gluDeleteQuadric(q); glPopMatrix(); } // draw 3d images if(!images.empty()) { glPushAttrib(GL_TEXTURE_BIT); glDisable(GL_CULL_FACE); glEnable(GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); std::vector<Image3D>::iterator i; for(i = images.begin(); i != images.end(); ++i) { GLuint t; glGenTextures(1, &t); glBindTexture(GL_TEXTURE_2D, t); int width, height; char* imageData = copyImage(*i->image, width, height); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, imageData); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); delete [] imageData; glPushMatrix(); glTranslated(i->point.x, i->point.y, i->point.z); if(i->rotation.x != 0) glRotated(toDegrees(i->rotation.x), 1, 0, 0); if(i->rotation.y != 0) glRotated(toDegrees(i->rotation.y), 0, 1, 0); if(i->rotation.z != 0) glRotated(toDegrees(i->rotation.z), 0, 0, 1); glBegin(GL_QUADS); float right = (float) i->image->width / width; float top = (float) i->image->height / height; glTexCoord2d(right, top); glVertex3d(0, -i->width / 2, i->height / 2); glTexCoord2d(0, top); glVertex3d(0, i->width / 2, i->height / 2); glTexCoord2d(0, 0); glVertex3d(0, i->width / 2, -i->height / 2); glTexCoord2d(right, 0); glVertex3d(0, -i->width / 2, -i->height / 2); glEnd(); glPopMatrix(); glDeleteTextures(1, &t); } glPopAttrib(); } // glPopAttrib(); glPopMatrix(); }
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); }
static void contrast(V2fT2f *quad, float t) // t [0..2] { GLfloat h = t*0.5f; // One pass using two units: // contrast < 1.0 interpolates towards grey // contrast > 1.0 extrapolates away from grey // // Here, the general extrapolation 2*(Src*t + Dst*(0.5-t)) // can be simplified, because Dst is a constant (grey). // That results in: 2*(Src*t + 0.25 - 0.5*t) // // Unit0 calculates Src*t // Unit1 adds 0.25 - 0.5*t // Since 0.5*t will be in [0..0.5], it can be biased up and the addition done in signed space. glVertexPointer (2, GL_FLOAT, sizeof(V2fT2f), &quad[0].x); glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &quad[0].s); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE); glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_PRIMARY_COLOR); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE); glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_TEXTURE); glActiveTexture(GL_TEXTURE1); glEnable(GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_ADD_SIGNED); glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PREVIOUS); glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_PRIMARY_COLOR); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_ALPHA); glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE, 2); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE); glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_PREVIOUS); glColor4f(h, h, h, 0.75 - 0.5 * h); // 2x extrapolation validateTexEnv(); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); // Restore state glDisable(GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR); glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE, 1); glActiveTexture(GL_TEXTURE0); }
//-------------------------------------------------------------------- // LLViewerJointMesh::drawShape() //-------------------------------------------------------------------- U32 LLViewerJointMesh::drawShape( F32 pixelArea, BOOL first_pass) { if (!mValid || !mMesh || !mFace || !mVisible || mFace->mVertexBuffer.isNull() || mMesh->getNumFaces() == 0) { return 0; } U32 triangle_count = 0; stop_glerror(); //---------------------------------------------------------------- // setup current color //---------------------------------------------------------------- if (!gRenderForSelect) { if ((mFace->getPool()->getVertexShaderLevel() > 0)) { glColor4f(0,0,0,1); if (gMaterialIndex > 0) { glVertexAttrib4fvARB(gMaterialIndex, mColor.mV); } if (mShiny && gSpecularIndex > 0) { glVertexAttrib4fARB(gSpecularIndex, 1,1,1,1); } } else { glColor4fv(mColor.mV); } } stop_glerror(); LLGLSSpecular specular(LLColor4(1.f,1.f,1.f,1.f), gRenderForSelect ? 0.0f : mShiny && !(mFace->getPool()->getVertexShaderLevel() > 0)); LLGLEnable texture_2d((gRenderForSelect && isTransparent()) ? GL_TEXTURE_2D : 0); //---------------------------------------------------------------- // setup current texture //---------------------------------------------------------------- llassert( !(mTexture.notNull() && mLayerSet) ); // mutually exclusive if (mTestImageName) { LLImageGL::bindExternalTexture( mTestImageName, 0, GL_TEXTURE_2D ); if (mIsTransparent) { glColor4f(1.f, 1.f, 1.f, 1.f); } else { glColor4f(0.7f, 0.6f, 0.3f, 1.f); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_INTERPOLATE_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_ONE_MINUS_SRC_ALPHA); } } else if( mLayerSet ) { if( mLayerSet->hasComposite() ) { mLayerSet->getComposite()->bindTexture(); } else { llwarns << "Layerset without composite" << llendl; gImageList.getImage(IMG_DEFAULT)->bind(); } } else if ( mTexture.notNull() ) { mTexture->bind(); if (!mTexture->getClampS()) { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); } if (!mTexture->getClampT()) { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); } } else { gImageList.getImage(IMG_DEFAULT_AVATAR)->bind(); } LLGLDisable tex(gRenderForSelect && !isTransparent() ? GL_TEXTURE_2D : 0); if (gRenderForSelect) { if (isTransparent()) { glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE); // GL_TEXTURE_ENV_COLOR is set in renderPass1 glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA); } } else { //---------------------------------------------------------------- // by default, backface culling is enabled //---------------------------------------------------------------- /*if (sRenderPass == AVATAR_RENDER_PASS_CLOTHING_INNER) { LLImageGL::bindExternalTexture( sClothingMaskImageName, 1, GL_TEXTURE_2D ); glClientActiveTextureARB(GL_TEXTURE0_ARB); glActiveTextureARB(GL_TEXTURE0_ARB); 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_COMBINE_ALPHA_ARB, GL_REPLACE); 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_SOURCE0_ALPHA_ARB, GL_PRIMARY_COLOR_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PRIMARY_COLOR_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); glClientActiveTextureARB(GL_TEXTURE1_ARB); glEnable(GL_TEXTURE_2D); // Texture unit 1 glActiveTextureARB(GL_TEXTURE1_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, sClothingInnerColor.mV); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_INTERPOLATE_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_CONSTANT_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_ALPHA); } else if (sRenderPass == AVATAR_RENDER_PASS_CLOTHING_OUTER) { glAlphaFunc(GL_GREATER, 0.1f); LLImageGL::bindExternalTexture( sClothingMaskImageName, 1, GL_TEXTURE_2D ); glClientActiveTextureARB(GL_TEXTURE0_ARB); glActiveTextureARB(GL_TEXTURE0_ARB); 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_COMBINE_ALPHA_ARB, GL_REPLACE); 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_SOURCE0_ALPHA_ARB, GL_PRIMARY_COLOR_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PRIMARY_COLOR_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); glClientActiveTextureARB(GL_TEXTURE1_ARB); glEnable(GL_TEXTURE_2D); // Texture unit 1 glActiveTextureARB(GL_TEXTURE1_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA); }*/ } mFace->mVertexBuffer->setBuffer(sRenderMask); U32 start = mMesh->mFaceVertexOffset; U32 end = start + mMesh->mFaceVertexCount - 1; U32 count = mMesh->mFaceIndexCount; U32* indicesp = ((U32*) mFace->mVertexBuffer->getIndicesPointer()) + mMesh->mFaceIndexOffset; if (mMesh->hasWeights()) { if ((mFace->getPool()->getVertexShaderLevel() > 0)) { if (first_pass) { uploadJointMatrices(); } llDrawRangeElements(GL_TRIANGLES, start, end, count, GL_UNSIGNED_INT, indicesp); } else { llDrawRangeElements(GL_TRIANGLES, start, end, count, GL_UNSIGNED_INT, indicesp); } } else { glPushMatrix(); LLMatrix4 jointToWorld = getWorldMatrix(); glMultMatrixf((GLfloat*)jointToWorld.mMatrix); llDrawRangeElements(GL_TRIANGLES, start, end, count, GL_UNSIGNED_INT, indicesp); glPopMatrix(); } triangle_count += mMesh->mFaceIndexCount; if (mTestImageName) { glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); } /*if (sRenderPass != AVATAR_RENDER_PASS_SINGLE) { LLImageGL::unbindTexture(1, GL_TEXTURE_2D); glActiveTextureARB(GL_TEXTURE1_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE); // Return to the default texture. LLImageGL::unbindTexture(0, GL_TEXTURE_2D); glClientActiveTextureARB(GL_TEXTURE0_ARB); glActiveTextureARB(GL_TEXTURE0_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE); glAlphaFunc(GL_GREATER, 0.01f); }*/ if (mTexture.notNull()) { if (!mTexture->getClampS()) { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); } if (!mTexture->getClampT()) { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); } } return triangle_count; }
void CAdvTreeDrawer::Draw(float treeDistance, bool drawReflection) { const int activeFarTex = (camera->forward.z < 0.0f)? treeGen->farTex[0]: treeGen->farTex[1]; const bool drawDetailed = ((treeDistance >= 4.0f) || drawReflection); CBaseGroundDrawer* gd = readmap->GetGroundDrawer(); Shader::IProgramObject* treeShader = NULL; const CMapInfo::light_t& light = mapInfo->light; glEnable(GL_ALPHA_TEST); glEnable(GL_TEXTURE_2D); ISky::SetupFog(); if (shadowHandler->shadowsLoaded && !gd->DrawExtraTex()) { glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, activeFarTex); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, shadowHandler->shadowTexture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL); glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_ALPHA); treeShader = treeShaders[TREE_PROGRAM_DIST_SHADOW]; treeShader->Enable(); if (globalRendering->haveGLSL) { treeShader->SetUniformMatrix4fv(7, false, &shadowHandler->shadowMatrix.m[0]); treeShader->SetUniform4fv(8, &(shadowHandler->GetShadowParams().x)); } else { treeShader->SetUniformTarget(GL_FRAGMENT_PROGRAM_ARB); treeShader->SetUniform4f(10, light.groundAmbientColor.x, light.groundAmbientColor.y, light.groundAmbientColor.z, 1.0f); treeShader->SetUniform4f(11, 0.0f, 0.0f, 0.0f, 1.0f - (sky->GetLight()->GetGroundShadowDensity() * 0.5f)); treeShader->SetUniformTarget(GL_VERTEX_PROGRAM_ARB); glMatrixMode(GL_MATRIX0_ARB); glLoadMatrixf(shadowHandler->shadowMatrix.m); glMatrixMode(GL_MODELVIEW); } } else { glBindTexture(GL_TEXTURE_2D, activeFarTex); } const int cx = int(camera->pos.x / (SQUARE_SIZE * TREE_SQUARE_SIZE)); const int cy = int(camera->pos.z / (SQUARE_SIZE * TREE_SQUARE_SIZE)); CAdvTreeSquareDrawer drawer(this, cx, cy, treeDistance * SQUARE_SIZE * TREE_SQUARE_SIZE, drawDetailed); GML_STDMUTEX_LOCK(tree); // Draw oldTreeDistance = treeDistance; // draw far-trees using map-dependent grid-visibility readmap->GridVisibility(camera, TREE_SQUARE_SIZE, drawer.treeDistance * 2.0f, &drawer); if (drawDetailed) { // draw near-trees const int xstart = std::max( 0, cx - 2); const int xend = std::min(gs->mapx / TREE_SQUARE_SIZE - 1, cx + 2); const int ystart = std::max( 0, cy - 2); const int yend = std::min(gs->mapy / TREE_SQUARE_SIZE - 1, cy + 2); if (shadowHandler->shadowsLoaded && !gd->DrawExtraTex()) { treeShader->Disable(); treeShader = treeShaders[TREE_PROGRAM_NEAR_SHADOW]; treeShader->Enable(); if (globalRendering->haveGLSL) { treeShader->SetUniformMatrix4fv(7, false, &shadowHandler->shadowMatrix.m[0]); treeShader->SetUniform4fv(8, &(shadowHandler->GetShadowParams().x)); } glActiveTexture(GL_TEXTURE1); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, treeGen->barkTex); glActiveTexture(GL_TEXTURE0); } else { glBindTexture(GL_TEXTURE_2D, treeGen->barkTex); treeShader = treeShaders[TREE_PROGRAM_NEAR_BASIC]; treeShader->Enable(); if (!globalRendering->haveGLSL) { const int mx = gs->pwr2mapx * SQUARE_SIZE; const int my = gs->pwr2mapy * SQUARE_SIZE; treeShader->SetUniformTarget(GL_VERTEX_PROGRAM_ARB); treeShader->SetUniform4f(15, 1.0f / mx, 1.0f / my, 1.0f / mx, 1.0f); } } if (globalRendering->haveGLSL) { treeShader->SetUniform3fv(0, &camera->right[0]); treeShader->SetUniform3fv(1, &camera->up[0]); treeShader->SetUniform2f(5, 0.20f * (1.0f / MAX_TREE_HEIGHT), 0.85f); } else { treeShader->SetUniformTarget(GL_VERTEX_PROGRAM_ARB); treeShader->SetUniform3f(13, camera->right.x, camera->right.y, camera->right.z); treeShader->SetUniform3f( 9, camera->up.x, camera->up.y, camera->up.z ); treeShader->SetUniform4f(11, light.groundSunColor.x, light.groundSunColor.y, light.groundSunColor.z, 0.85f); treeShader->SetUniform4f(14, light.groundAmbientColor.x, light.groundAmbientColor.y, light.groundAmbientColor.z, 0.85f); treeShader->SetUniform4f(12, 0.0f, 0.0f, 0.0f, 0.20f * (1.0f / MAX_TREE_HEIGHT)); // w = alpha/height modifier } glAlphaFunc(GL_GREATER, 0.5f); glDisable(GL_BLEND); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); CVertexArray* va = GetVertexArray(); va->Initialize(); static FadeTree fadeTrees[3000]; FadeTree* pFT = fadeTrees; for (TreeSquareStruct* pTSS = trees + (ystart * treesX); pTSS <= trees + (yend * treesX); pTSS += treesX) { for (TreeSquareStruct* tss = pTSS + xstart; tss <= (pTSS + xend); ++tss) { tss->lastSeen = gs->frameNum; va->EnlargeArrays(12 * tss->trees.size(), 0, VA_SIZE_T); //!alloc room for all tree vertexes for (std::map<int, TreeStruct>::iterator ti = tss->trees.begin(); ti != tss->trees.end(); ++ti) { const TreeStruct* ts = &ti->second; const float3 pos(ts->pos); if (!camera->InView(pos + float3(0.0f, MAX_TREE_HEIGHT / 2.0f, 0.0f), MAX_TREE_HEIGHT / 2.0f)) { continue; } const float camDist = (pos - camera->pos).SqLength(); int type = ts->type; float dy = 0.0f; unsigned int dispList; if (type < 8) { dy = 0.5f; dispList = treeGen->pineDL + type; } else { type -= 8; dy = 0.0f; dispList = treeGen->leafDL + type; } if (camDist < (SQUARE_SIZE * SQUARE_SIZE * 110 * 110)) { // draw detailed near-distance tree (same as mid-distance trees without alpha) treeShader->SetUniform3f(((globalRendering->haveGLSL)? 2: 10), pos.x, pos.y, pos.z); glCallList(dispList); } else if (camDist < (SQUARE_SIZE * SQUARE_SIZE * 125 * 125)) { // draw mid-distance tree const float relDist = (pos.distance(camera->pos) - SQUARE_SIZE * 110) / (SQUARE_SIZE * 15); treeShader->SetUniform3f(((globalRendering->haveGLSL)? 2: 10), pos.x, pos.y, pos.z); glAlphaFunc(GL_GREATER, 0.8f + relDist * 0.2f); glCallList(dispList); glAlphaFunc(GL_GREATER, 0.5f); // save for second pass pFT->pos = pos; pFT->deltaY = dy; pFT->type = type; pFT->relDist = relDist; ++pFT; } else { // draw far-distance tree CAdvTreeDrawer::DrawTreeVertex(va, pos, type * 0.125f, dy, false); } } } } // reset the world-offset treeShader->SetUniform3f(((globalRendering->haveGLSL)? 2: 10), 0.0f, 0.0f, 0.0f); // draw trees that have been marked as falling for (std::list<FallingTree>::iterator fti = fallingTrees.begin(); fti != fallingTrees.end(); ++fti) { const float3 pos = fti->pos - UpVector * (fti->fallPos * 20); if (camera->InView(pos + float3(0.0f, MAX_TREE_HEIGHT / 2, 0.0f), MAX_TREE_HEIGHT / 2.0f)) { const float ang = fti->fallPos * PI; const float3 yvec(fti->dir.x * sin(ang), cos(ang), fti->dir.z * sin(ang)); const float3 zvec((yvec.cross(float3(-1.0f, 0.0f, 0.0f))).ANormalize()); const float3 xvec(yvec.cross(zvec)); CMatrix44f transMatrix(pos, xvec, yvec, zvec); glPushMatrix(); glMultMatrixf(&transMatrix[0]); int type = fti->type; int dispList = 0; if (type < 8) { dispList = treeGen->pineDL + type; } else { type -= 8; dispList = treeGen->leafDL + type; } glCallList(dispList); glPopMatrix(); } } if (shadowHandler->shadowsLoaded && !gd->DrawExtraTex()) { treeShader->Disable(); treeShader = treeShaders[TREE_PROGRAM_DIST_SHADOW]; treeShader->Enable(); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, activeFarTex); glActiveTexture(GL_TEXTURE0); } else { treeShader->Disable(); glBindTexture(GL_TEXTURE_2D, activeFarTex); } // draw far-distance trees va->DrawArrayT(GL_QUADS); // draw faded mid-distance trees for (FadeTree* pFTree = fadeTrees; pFTree < pFT; ++pFTree) { va = GetVertexArray(); va->Initialize(); va->CheckInitSize(12 * VA_SIZE_T); CAdvTreeDrawer::DrawTreeVertex(va, pFTree->pos, pFTree->type * 0.125f, pFTree->deltaY, false); glAlphaFunc(GL_GREATER, 1.0f - (pFTree->relDist * 0.5f)); va->DrawArrayT(GL_QUADS); } } if (shadowHandler->shadowsLoaded && !gd->DrawExtraTex()) { treeShader->Disable(); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, 0); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, 0); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_NONE); glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_LUMINANCE); } else { glBindTexture(GL_TEXTURE_2D, 0); } glDisable(GL_TEXTURE_2D); glDisable(GL_FOG); glDisable(GL_ALPHA_TEST); // clean out squares from memory that are no longer visible const int startClean = lastListClean * 20 % (nTrees); const int endClean = gs->frameNum * 20 % (nTrees); lastListClean = gs->frameNum; if (startClean > endClean) { for (TreeSquareStruct* pTSS = trees + startClean; pTSS < (trees + nTrees); ++pTSS) { if ((pTSS->lastSeen < gs->frameNum - 50) && pTSS->dispList) { glDeleteLists(pTSS->dispList, 1); pTSS->dispList = 0; } if ((pTSS->lastSeenFar < (gs->frameNum - 50)) && pTSS->farDispList) { glDeleteLists(pTSS->farDispList, 1); pTSS->farDispList = 0; } } for (TreeSquareStruct* pTSS = trees; pTSS < (trees + endClean); ++pTSS) { if ((pTSS->lastSeen < (gs->frameNum - 50)) && pTSS->dispList) { glDeleteLists(pTSS->dispList, 1); pTSS->dispList = 0; } if ((pTSS->lastSeenFar < (gs->frameNum - 50)) && pTSS->farDispList) { glDeleteLists(pTSS->farDispList, 1); pTSS->farDispList = 0; } } } else { for (TreeSquareStruct* pTSS = trees + startClean; pTSS < (trees + endClean); ++pTSS) { if ((pTSS->lastSeen < (gs->frameNum - 50)) && pTSS->dispList) { glDeleteLists(pTSS->dispList, 1); pTSS->dispList = 0; } if ((pTSS->lastSeenFar < (gs->frameNum - 50)) && pTSS->farDispList) { glDeleteLists(pTSS->farDispList, 1); pTSS->farDispList = 0; } } } }
/** * Renders the scene in stereogram mode. * * This will make the maze be displayed as an animated stereogram. * * @param context * The context. */ static void context_render_stereo(Context *context) { /* Determine the size of the texture */ GLsizei width, height; width = context->stereo.zbuffer->width; height = context->stereo.zbuffer->height; /* Bind the frame buffer and the render buffer */ GLuint framebuffer = context->gl.framebuffers[0]; glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); GLuint renderbuffer = context->gl.renderbuffers[0]; glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer); /* Clear the buffer */ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); /* Store the old viewport and set one the size of the texture */ GLint old_viewport[4]; glGetIntegerv(GL_VIEWPORT, old_viewport); glViewport(0, 0, width, height); /* Draw the maze with a floor */ maze_render_gl(context->maze.data, ARGUMENT_VALUE(wall_width), ARGUMENT_VALUE(slope_width), 0.1, (int)context->camera.x, (int)context->camera.y, 5, MAZE_RENDER_GL_WALLS | MAZE_RENDER_GL_FLOOR | MAZE_RENDER_GL_TOP); context_object_render(context); /* Retrieve the depth data to the z-buffer */ glPixelStorei(GL_PACK_ROW_LENGTH, context->stereo.zbuffer->rowoffset); glReadPixels(0, 0, width, height, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, context->stereo.zbuffer->data); glBindRenderbuffer(GL_RENDERBUFFER, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0); /* Regenerate the stereogram from the depth data generated by OpenGL */ stereo_image_apply(context->stereo.image, context->stereo.zbuffer, 0); /* Clear the depth buffer to enable the texture to be displayed */ glClear(GL_DEPTH_BUFFER_BIT); /* Activate the stereogram texture */ glEnable(GL_TEXTURE_2D); GLuint stereogram_texture = context->gl.textures[0]; glBindTexture(GL_TEXTURE_2D, stereogram_texture); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, context->stereo.image->image->pixels); /* Restore the matrix and the viewport */ glLoadIdentity(); glViewport(old_viewport[0], old_viewport[1], old_viewport[2], old_viewport[3]); /* Draw a rectangle with the stereogram as texture */ glBegin(GL_QUADS); glTexCoord2f(0.0, 0.0); glVertex2f(-1.0, -1.0); glTexCoord2f(1.0, 0.0); glVertex2f(1.0, -1.0); glTexCoord2f(1.0, 1.0); glVertex2f(1.0, 1.0); glTexCoord2f(0.0, 1.0); glVertex2f(-1.0, 1.0); glEnd(); }
// Test all possible image formats, types and internal texture formats. // Result will indicate number of passes and failures. void PixelFormatsTest::runOne(MultiTestResult &r, Window &w) { int testNum = 0; (void) w; // silence warning setup(); const unsigned numEnvModes = haveCombine ? 2 : 1; for (unsigned envMode = 0; envMode < numEnvModes; envMode++) { if (envMode == 0) { glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); // When the texture internal format is GL_LUMINANCE or GL_RGB, // GL_REPLACE takes alpha from the fragment, which we set to zero // with glColor4f(0,0,0,0). #if USE_FRAG_PROG defaultAlpha = 255; #else defaultAlpha = 0; #endif } else { assert(haveCombine); #if GL_ARB_texture_env_combine glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA); #endif // For this GL_COMBINE mode, when sampling a texture that does // not have an alpha channel, alpha is effectively 1.0. defaultAlpha = 255; } for (unsigned formatIndex = 0; formatIndex < NUM_FORMATS; formatIndex++) { for (unsigned typeIndex = 0; typeIndex < NUM_TYPES; typeIndex++) { if (CompatibleFormatAndType(Formats[formatIndex].Token, Types[typeIndex].Token)) { for (unsigned intFormat = 0; intFormat < NUM_INT_FORMATS; intFormat++) { if (!SupportedIntFormat(InternalFormats[intFormat].Token)) continue; #if DEBUG env->log << "testing " << testNum << ":\n"; env->log << " Format: " << Formats[formatIndex].Name << "\n"; env->log << " Type: " << Types[typeIndex].Name << "\n"; env->log << " IntFormat: " << InternalFormats[intFormat].Name << "\n"; #endif bool ok = TestCombination(Formats[formatIndex].Token, Types[typeIndex].Token, InternalFormats[intFormat].Token); if (!ok) { // error was reported to log, add format info here: env->log << " Format: " << Formats[formatIndex].Name << "\n"; env->log << " Type: " << Types[typeIndex].Name << "\n"; env->log << " Internal Format: " << InternalFormats[intFormat].Name << "\n"; env->log << " EnvMode: " << EnvModes[envMode] << "\n"; r.numFailed++; } else { r.numPassed++; } testNum++; } } } } } r.pass = (r.numFailed == 0); }
void particles_render(void) { extern int lights_on; int i; float diffuse[4] = { 1, 1, 1, 0 }; float mag; sort_particles(); #ifdef NO_SMOKELIGHT glDisable(GL_LIGHTING); #else if ( lights_on ) { glDisable(GL_LIGHT0); glEnable(GL_LIGHT3); } apply_mat(MAT_SMOKE); #endif glEnable(GL_BLEND); glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, texid); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glBegin(GL_QUADS); for(i=0; i<PARTICLE_COUNT; i++) { if ( particles[i].lifespan <= 0 ) continue; #ifndef NO_SMOKELIGHT mag = sqrt( particles[i].pos.x*particles[i].pos.x + particles[i].pos.y*particles[i].pos.y + particles[i].pos.z*particles[i].pos.z); mag /= 2; glNormal3f( -particles[i].pos.x/mag, -particles[i].pos.y/mag, -particles[i].pos.z/mag ); diffuse[0] = colors[sm_color][0]; diffuse[1] = colors[sm_color][1]; diffuse[2] = colors[sm_color][2]; diffuse[3] = 0.5 * (float)particles[i].lifespan / ((float)MAX_LIFESPAN); glMaterialfv(GL_FRONT, GL_AMBIENT, diffuse); glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse); #else glColor4f( colors[sm_color][0], colors[sm_color][1], colors[sm_color][2], 0.5 * (float)particles[i].lifespan / ((float)MAX_LIFESPAN) ); #endif glTexCoord2f(0,1); glVertex3f( particles[i].pos.x - PARTICLE_WIDTH, particles[i].pos.y + PARTICLE_WIDTH, particles[i].pos.z ); glTexCoord2f(0,0); glVertex3f( particles[i].pos.x -PARTICLE_WIDTH, particles[i].pos.y - PARTICLE_WIDTH, particles[i].pos.z ); glTexCoord2f(1,0); glVertex3f( particles[i].pos.x + PARTICLE_WIDTH, particles[i].pos.y - PARTICLE_WIDTH, particles[i].pos.z ); glTexCoord2f(1,1); glVertex3f( particles[i].pos.x + PARTICLE_WIDTH, particles[i].pos.y + PARTICLE_WIDTH, particles[i].pos.z ); } glEnd(); glDisable(GL_COLOR_MATERIAL); glDisable(GL_TEXTURE_2D); glDisable(GL_BLEND); if ( lights_on ) { glEnable(GL_LIGHT0); glDisable(GL_LIGHT3); } }
void GLWidget::paintGL() { //qDebug("Frame"); world->setToIdentity(); //double seconds = GameTime::instance()->getTime(); world->translate(0,-2048.0,0); world->rotate(45, 0.0f, 0.0f, 1.0f); //world->rotate(seconds * 3.60, 1.0, 0.0, 0.0); //world->rotate(seconds * 4.60, 0.0, 0.0, 1.0); glLoadMatrixf(world->data()); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); if (map != NULL) { //RENDER ALL FACES int faceCount = map->countOfFaces(); BSPFace *faces = map->getFaces(); int *faceEdges = map->getEdgeList(); BSPEdge *edges = map->getEdges(); Vec3 *vertices = map->getVertices(); BSPTextureInfo *textureInfos = map->getTextureInfos(); int lastId = 0, thisId = 0; Vec3 fan[3]; glActiveTexture(GL_TEXTURE0); 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_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); for (int i=0; i<faceCount; i++) { BSPFace *face = &faces[i]; BSPTextureInfo textInfo = textureInfos[face->textureInfo]; if (first) { // qDebug("Texture Info Id: %u", face->textureInfo); // qDebug("MipTexture Id: %u", textInfo.textureId); // qDebug("MipTexture name: %s", map->getMipTexture(textInfo.textureId)->name); } // GLuint texId = this->mapTextures[textureInfos[face->textureInfo].textureId]; short firstEdge = face->firstEdge; int edgeCount = face->countOfEdges; glEnable(GL_TEXTURE_2D); thisId = this->mapTextures[textInfo.textureId]; // if (thisId != lastId) { glBindTexture(GL_TEXTURE_2D, thisId); // lastId = thisId; // } glBegin(GL_TRIANGLES); for (int j=0; j<edgeCount; j++) { int edgeIndex = faceEdges[firstEdge + j]; BSPEdge *edge; Vec3 *vertex1; if (0 > edgeIndex) { edge = &edges[-edgeIndex]; vertex1 = &vertices[edge->vertex2]; } else { edge = &edges[edgeIndex]; vertex1 = &vertices[edge->vertex1]; } if (j < 2) { fan[j].set(vertex1); } else { if (j > 2) { fan[1].set(&fan[2]); } fan[2].set(vertex1); for (int k=0; k<3; k++) { float *vertex = fan[k].values; float green = vertex[0] / 1024.0f; float blue = vertex[1] / 1024.0f; scalar s = Vec3::dot(&fan[k], &textInfo.vectorS) + textInfo.distS; s /= map->getMipTexture(textInfo.textureId)->width; scalar t = Vec3::dot(&fan[k], &textInfo.vectorT) + textInfo.distT; t /= map->getMipTexture(textInfo.textureId)->height; glColor4f(1.0f,green,blue,1.0f); glTexCoord2f(s, t); glVertex3fv(vertex); } } } glEnd(); glDisable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, 0); } } first = false; }
void CGrassDrawer::SetupGlStateNear() { CBaseGroundDrawer* gd = readMap->GetGroundDrawer(); // bind textures { glActiveTextureARB(GL_TEXTURE0_ARB); glBindTexture(GL_TEXTURE_2D, grassBladeTex); glActiveTextureARB(GL_TEXTURE1_ARB); glBindTexture(GL_TEXTURE_2D, readMap->GetGrassShadingTexture()); glActiveTextureARB(GL_TEXTURE2_ARB); glBindTexture(GL_TEXTURE_2D, readMap->GetShadingTexture()); if (gd->DrawExtraTex()) { glActiveTextureARB(GL_TEXTURE3_ARB); glBindTexture(GL_TEXTURE_2D, gd->GetActiveInfoTexture()); } glActiveTextureARB(GL_TEXTURE5_ARB); glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, cubeMapHandler->GetSpecularTextureID()); } // bind shader if (globalRendering->haveGLSL) { EnableShader(GRASS_PROGRAM_NEAR); if (shadowHandler->shadowsLoaded) { glActiveTextureARB(GL_TEXTURE4_ARB); glBindTexture(GL_TEXTURE_2D, shadowHandler->shadowTexture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL); glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_ALPHA); } glMatrixMode(GL_PROJECTION); glPushMatrix(); glMultMatrixf(camera->GetViewMatrix()); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); } else { // FPP enable textures glActiveTextureARB(GL_TEXTURE0_ARB); glEnable(GL_TEXTURE_2D); glActiveTextureARB(GL_TEXTURE1_ARB); glEnable(GL_TEXTURE_2D); glMultiTexCoord4f(GL_TEXTURE1_ARB, 1.0f,1.0f,1.0f,1.0f); // workaround a nvidia bug with TexGen SetTexGen(1.0f / (gs->mapx * SQUARE_SIZE), 1.0f / (gs->mapy * SQUARE_SIZE), 0.0f, 0.0f); glActiveTextureARB(GL_TEXTURE2_ARB); glEnable(GL_TEXTURE_2D); glMultiTexCoord4f(GL_TEXTURE2_ARB, 1.0f,1.0f,1.0f,1.0f); // workaround a nvidia bug with TexGen SetTexGen(1.0f / (gs->pwr2mapx * SQUARE_SIZE), 1.0f / (gs->pwr2mapy * SQUARE_SIZE), 0.0f, 0.0f); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE); glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 2); if (gd->DrawExtraTex()) { glActiveTextureARB(GL_TEXTURE3_ARB); glEnable(GL_TEXTURE_2D); glMultiTexCoord4f(GL_TEXTURE3_ARB, 1.0f,1.0f,1.0f,1.0f); // workaround a nvidia bug with TexGen SetTexGen(1.0f / (gs->pwr2mapx * SQUARE_SIZE), 1.0f / (gs->pwr2mapy * SQUARE_SIZE), 0.0f, 0.0f); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_ADD_SIGNED_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); } } glActiveTextureARB(GL_TEXTURE0_ARB); glDisable(GL_BLEND); glDisable(GL_ALPHA_TEST); glDepthMask(GL_TRUE); ISky::SetupFog(); }
static GLboolean glgdGraphNodeDrawLabel(glgdGraph *graph, glgdNode *node) { int i; GLint width; GLuint texture; GLfloat s0, s1, t0, t1; GLfloat a; guint32 alpha, rgb, *t; guint8 *row, *row_end; PangoContext *pangoContext; PangoFontDescription *fontDesc; PangoLayout *layout; PangoRectangle extents; FT_Bitmap bitmap; glgdVec2 center, pnt[2]; glgdStroke *stroke; glgdTexture *tex; if (graph && graph->pangoFT2Context) { stroke = &graph->stroke; tex = &graph->textTexture; if (tex->width <= 0 || tex->height <= 0) { glgdTrace(1, "Invalid texture dimension (%d,%d)\n", tex->width, tex->height); return GL_FALSE; } /* Pango font description */ width = 10 * _PANGO_SCALE; pangoContext = gtk_widget_get_pango_context(graph->gtkWindow); fontDesc = pango_context_get_font_description(pangoContext); pango_font_description_set_size(fontDesc, PANGO_SCALE * width); pango_font_description_set_weight(fontDesc, PANGO_WEIGHT_NORMAL); pango_context_set_font_description(graph->pangoFT2Context, fontDesc); /* Text layout */ width = (int)graph->dim[0] * _PANGO_SCALE; layout = graph->layout; pango_layout_set_width(layout, PANGO_SCALE * width); pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER); pango_layout_set_text(layout, node->label, -1); pango_layout_get_extents(layout, NULL, &extents); if (extents.width == 0 || extents.height == 0) { glgdTrace(1, "Invalid extents (%d,%d)\n", extents.width, extents.height); return GL_FALSE; } /* Bitmap creation */ bitmap.rows = PANGO_PIXELS(extents.height); bitmap.width = PANGO_PIXELS(extents.width); if (bitmap.width > tex->width || bitmap.rows > tex->height) { return GL_FALSE; } bitmap.pitch = bitmap.width; bitmap.buffer = GLGD_MALLOC(bitmap.rows * bitmap.width); bitmap.num_grays = 256; bitmap.pixel_mode = ft_pixel_mode_grays; memset(bitmap.buffer, 0, bitmap.rows * bitmap.width); pango_ft2_render_layout(&bitmap, layout, PANGO_PIXELS(-extents.x), 0); #if !defined(GL_VERSION_1_2) && G_BYTE_ORDER == G_LITTLE_ENDIAN rgb =((guint32)(stroke->col[0] * 255.0)) | (((guint32)(stroke->col[1] * 255.0)) << 8) | (((guint32)(stroke->col[2] * 255.0)) << 16); #else rgb =(((guint32)(stroke->col[0] * 255.0)) << 24) | (((guint32)(stroke->col[1] * 255.0)) << 16) | (((guint32)(stroke->col[2] * 255.0)) << 8); #endif /* Bitmap transfer to <glgdTexture> */ a = stroke->col[3]; alpha = (guint32)(255.0 * a); row = bitmap.buffer + bitmap.rows * bitmap.width; row_end = bitmap.buffer; t = (guint32 *)tex->texels; if (graph->flags & GLGDGRAPH_FLAG_PANGOBOLD) { do { row -= bitmap.width; for (i=0; i<bitmap.width; i++) { #if !defined(GL_VERSION_1_2) && G_BYTE_ORDER == G_LITTLE_ENDIAN if (row[i] > 0) *t++ = rgb | (alpha << 24); else *t++ = rgb; #else if (row[i] > 0) *t++ = rgb | alpha; else *t++ = rgb; #endif } } while (row != row_end); } else { do { row -= bitmap.width; for (i=0; i<bitmap.width; i++) { #if !defined(GL_VERSION_1_2) && G_BYTE_ORDER == G_LITTLE_ENDIAN *t++ = rgb | ((guint32)(a * row[i]) << 24); #else *t++ = rgb | (guint32)(a * row[i]); #endif } } while (row != row_end); } glPixelStorei(GL_UNPACK_ALIGNMENT, 4); glBindTexture(GL_TEXTURE_2D, tex->name); #if !defined(GL_VERSION_1_2) glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, bitmap.width, bitmap.rows, GL_RGBA, GL_UNSIGNED_BYTE, tex->texels); #else glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, bitmap.width, bitmap.rows, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, tex->texels); #endif /* <glgdTexture> render */ s0 = 0.0; s1 = (GLdouble)bitmap.width / (GLdouble)tex->width; t0 = 0.0; t1 = (GLdouble)bitmap.rows / (GLdouble)tex->height; center[0] = node->pos[0] + GLGD_HALF(graph->dim[0]); center[1] = node->pos[1] + GLGD_HALF(graph->dim[1]); pnt[0][0] = center[0] - GLGD_HALF(bitmap.width / _PANGO_SCALE); pnt[0][1] = center[1] - GLGD_HALF(bitmap.rows / _PANGO_SCALE); pnt[1][0] = center[0] + GLGD_HALF(bitmap.width / _PANGO_SCALE); pnt[1][1] = center[1] + GLGD_HALF(bitmap.rows / _PANGO_SCALE); GLGD_FREE(bitmap.buffer); glColor3d(stroke->col[0], stroke->col[1], stroke->col[2]); glEnable(GL_TEXTURE_2D); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBindTexture(GL_TEXTURE_2D, tex->name); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glBegin(GL_QUADS); glTexCoord2f(s0, t0); glVertex3f(pnt[0][0], pnt[0][1], 0.0); glTexCoord2f(s0, t1); glVertex3f(pnt[0][0], pnt[1][1], 0.0); glTexCoord2f(s1, t1); glVertex3f(pnt[1][0], pnt[1][1], 0.0); glTexCoord2f(s1, t0); glVertex3f(pnt[1][0], pnt[0][1], 0.0); glEnd(); glDisable(GL_BLEND); glDisable(GL_TEXTURE_2D); return GL_TRUE; } return GL_FALSE; }
void GL11Renderer::Initialize( int width, int height ) { // // Buffer Setup... // // Create the depth buffer. glGenRenderbuffersOES( 1, &m_depthRenderbuffer ); glBindRenderbufferOES( GL_RENDERBUFFER_OES, m_depthRenderbuffer ); glRenderbufferStorageOES( GL_RENDERBUFFER_OES, GL_DEPTH_COMPONENT16_OES, width, height ); // Create the framebuffer object; attach the depth and color buffers. glGenFramebuffersOES( 1, &m_framebuffer ); glBindFramebufferOES( GL_FRAMEBUFFER_OES, m_framebuffer ); glFramebufferRenderbufferOES( GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, m_colorRenderbuffer ); glFramebufferRenderbufferOES( GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES, GL_RENDERBUFFER_OES, m_depthRenderbuffer ); // Bind the color buffer for rendering. glBindRenderbufferOES( GL_RENDERBUFFER_OES, m_colorRenderbuffer ); // // General Setup... // glEnable( GL_TEXTURE_2D ); glDisable( GL_LIGHTING ); // // Point Sprites... // glEnable( GL_POINT_SPRITE_OES ); glTexEnvi( GL_POINT_SPRITE_OES, GL_COORD_REPLACE_OES, GL_TRUE ); glTexEnvi( GL_POINT_SPRITE_OES, GL_COORD_REPLACE_OES, GL_FALSE ); //glPointSize( 10.0f ); // This helps as a work around for order-dependency artifacts that can occur when sprites overlap. glBlendFunc( GL_SRC_ALPHA, GL_ONE ); // // Texture Setup... // glGenTextures( 1, &m_snowTextureId ); glBindTexture( GL_TEXTURE_2D, m_snowTextureId ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); TextureDescription desc = m_resourceLoader->LoadPngImage( "snow.png" ); GLvoid* pixels = m_resourceLoader->GetImageData(); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, desc.Width, desc.Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels ); m_resourceLoader->UnloadImage(); // // VBO Setup for Snow Flakes... // for( int i = 0; i < MaxSnowFlakes; ++i ) { m_pos[i][0] = RandomFloat( -ViewMaxX, ViewMaxX ); m_pos[i][1] = RandomFloat( -ViewMaxY, ViewMaxY ); m_vel[i][0] = RandomFloat( -0.004f, 0.004f ); // Flakes move side to side m_vel[i][1] = RandomFloat( -0.01f, -0.008f ); // Flakes fall down m_col[i][0] = 1.0f; m_col[i][1] = 1.0f; m_col[i][2] = 1.0f; m_col[i][3] = 1.0f; //RandomFloat( 0.6f, 1.0f ); // It seems that Doodle Jump snow does not use alpha. m_size[i] = RandomFloat( 3.0, 6.0f ); // It looks strange if the flakes all turn at the same time, so // lets vary their turn times with a random negative value. m_timeSinceLastTurn[i] = RandomFloat( -5.0, 0.0f ); } // VBO for vertex positions. glGenBuffers( 1, &m_vertexBufferId ); glBindBuffer( GL_ARRAY_BUFFER, m_vertexBufferId ); glBufferData( GL_ARRAY_BUFFER, sizeof(m_pos), m_pos, GL_DYNAMIC_DRAW ); glBindBuffer( GL_ARRAY_BUFFER, 0 ); // TODO: Due to the possibility of cache misses, it might be a little faster to // combine the colors and point sizes into an interleaved array, but it // seems that this optimization makes less sense on newer CPUs. // VBO for vertex colors. glGenBuffers( 1, &m_colorBufferId ); glBindBuffer( GL_ARRAY_BUFFER, m_colorBufferId ); glBufferData( GL_ARRAY_BUFFER, sizeof(m_col), m_col, GL_STATIC_DRAW ); glBindBuffer( GL_ARRAY_BUFFER, 0 ); // VBO for point sizes of point sprites. glGenBuffers( 1, &m_pointSizeBufferId ); glBindBuffer( GL_ARRAY_BUFFER, m_pointSizeBufferId ); glBufferData( GL_ARRAY_BUFFER, sizeof(m_size), m_size, GL_STATIC_DRAW ); glBindBuffer( GL_ARRAY_BUFFER, 0 ); // // View Settings... // glViewport( 0, 0, width, height ); // Initialize the projection matrix to orthogrpahic and create // a flat 2D game space that is 2 units wide and 3 units high. glMatrixMode( GL_PROJECTION ); glOrthof( -ViewMaxX, +ViewMaxX, -ViewMaxY, +ViewMaxY, -1, 1 ); }
bool MenuMgr::loadTextures(string main, string gameover, string win, string help, vector<string> menuItems) { mainMenuTexFilename = main; gameoverTexFilename = gameover; winTexFilename = win; helpTexFilename = help; logFile << "MenuMgr::loadTextures(f1,f2,f3)..."; /* load an image file directly as a new OpenGL texture */ mainMenuTex = SOIL_load_OGL_texture ( mainMenuTexFilename.c_str(), SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, NULL ); gameoverTex = SOIL_load_OGL_texture ( gameoverTexFilename.c_str(), SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, NULL ); winTex = SOIL_load_OGL_texture ( winTexFilename.c_str(), SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, NULL /*SOIL_FLAG_INVERT_Y*/ ); helpTex = SOIL_load_OGL_texture ( helpTexFilename.c_str(), SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, NULL /*SOIL_FLAG_INVERT_Y*/ ); if (mainMenuTex == 0 || gameoverTex == 0 || winTex == 0 || helpTex == 0) { logFile << "MenuMgr::loadTextures(f1,f2,f3,f4,vector<string>): Impossibile caricare uno degli sfondi dei menu!" << endl; MessageBox(NULL, "MenuMgr::loadTextures(): uno o piu degli sfondi menu non caricato!", "Errore", MB_ICONWARNING); } //caricoc tex. menuitems, i = scritta, i+1 = scritta HOVER for (int i = 0; i < menuItems.size(); i++) { mainMenuItemsTex[i] = SOIL_load_OGL_texture ( menuItems.at(i).c_str(), SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, NULL /*SOIL_FLAG_INVERT_Y*/ ); if (mainMenuItemsTex[i] == 0) { logFile << "MenuMgr::loadTextures(): impossibile caricare uno o piu menu items!" << endl; MessageBox(NULL, "MenuMgr::loadTextures(): impossibile caricare elementi menu", "Errore", MB_ICONWARNING); } } // Typical Texture Generation Using Data From The Bitmap glBindTexture(GL_TEXTURE_2D, mainMenuTex); glBindTexture(GL_TEXTURE_2D, gameoverTex); glBindTexture(GL_TEXTURE_2D, winTex); for (int i = 0; i < menuItems.size(); i++) { glBindTexture(GL_TEXTURE_2D, mainMenuItemsTex[i]); } glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); logFile << "OK" << endl; return true; }
/* ================= R_DrawAliasModel -- johnfitz -- almost completely rewritten ================= */ void R_DrawAliasModel (entity_t *e) { aliashdr_t *paliashdr; int i, anim; gltexture_t *tx, *fb; lerpdata_t lerpdata; // // setup pose/lerp data -- do it first so we don't miss updates due to culling // paliashdr = (aliashdr_t *)Mod_Extradata (e->model); R_SetupAliasFrame (paliashdr, e->frame, &lerpdata); R_SetupEntityTransform (e, &lerpdata); // // cull it // if (R_CullModelForEntity(e)) return; // // transform it // glPushMatrix (); R_RotateForEntity (lerpdata.origin, lerpdata.angles); glTranslatef (paliashdr->scale_origin[0], paliashdr->scale_origin[1], paliashdr->scale_origin[2]); glScalef (paliashdr->scale[0], paliashdr->scale[1], paliashdr->scale[2]); // // random stuff // if (gl_smoothmodels.value && !r_drawflat_cheatsafe) glShadeModel (GL_SMOOTH); if (gl_affinemodels.value) glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST); overbright = gl_overbright_models.value; shading = true; // // set up for alpha blending // if (r_drawflat_cheatsafe || r_lightmap_cheatsafe) //no alpha in drawflat or lightmap mode entalpha = 1; else entalpha = ENTALPHA_DECODE(e->alpha); if (entalpha == 0) goto cleanup; if (entalpha < 1) { if (!gl_texture_env_combine) overbright = false; //overbright can't be done in a single pass without combiners glDepthMask(GL_FALSE); glEnable(GL_BLEND); } // // set up lighting // rs_aliaspolys += paliashdr->numtris; R_SetupAliasLighting (e); // // set up textures // GL_DisableMultitexture(); anim = (int)(cl.time*10) & 3; tx = paliashdr->gltextures[e->skinnum][anim]; fb = paliashdr->fbtextures[e->skinnum][anim]; if (e->colormap != vid.colormap && !gl_nocolors.value) { i = e - cl_entities; if (i >= 1 && i<=cl.maxclients /* && !strcmp (currententity->model->name, "progs/player.mdl") */) tx = playertextures[i - 1]; } if (!gl_fullbrights.value) fb = NULL; // // draw it // if (r_drawflat_cheatsafe) { glDisable (GL_TEXTURE_2D); GL_DrawAliasFrame (paliashdr, lerpdata); glEnable (GL_TEXTURE_2D); srand((int) (cl.time * 1000)); //restore randomness } else if (r_fullbright_cheatsafe) { GL_Bind (tx); shading = false; glColor4f(1,1,1,entalpha); GL_DrawAliasFrame (paliashdr, lerpdata); if (fb) { glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); GL_Bind(fb); glEnable(GL_BLEND); glBlendFunc (GL_ONE, GL_ONE); glDepthMask(GL_FALSE); glColor3f(entalpha,entalpha,entalpha); Fog_StartAdditive (); GL_DrawAliasFrame (paliashdr, lerpdata); Fog_StopAdditive (); glDepthMask(GL_TRUE); glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_BLEND); } } else if (r_lightmap_cheatsafe) { glDisable (GL_TEXTURE_2D); shading = false; glColor3f(1,1,1); GL_DrawAliasFrame (paliashdr, lerpdata); glEnable (GL_TEXTURE_2D); } else if (overbright) { if (gl_texture_env_combine && gl_mtexable && gl_texture_env_add && fb) //case 1: everything in one pass { GL_Bind (tx); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PRIMARY_COLOR_EXT); glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, 2.0f); GL_EnableMultitexture(); // selects TEXTURE1 GL_Bind (fb); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD); glEnable(GL_BLEND); GL_DrawAliasFrame (paliashdr, lerpdata); glDisable(GL_BLEND); GL_DisableMultitexture(); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); } else if (gl_texture_env_combine) //case 2: overbright in one pass, then fullbright pass { // first pass GL_Bind(tx); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PRIMARY_COLOR_EXT); glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, 2.0f); GL_DrawAliasFrame (paliashdr, lerpdata); glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, 1.0f); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); // second pass if (fb) { glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); GL_Bind(fb); glEnable(GL_BLEND); glBlendFunc (GL_ONE, GL_ONE); glDepthMask(GL_FALSE); shading = false; glColor3f(entalpha,entalpha,entalpha); Fog_StartAdditive (); GL_DrawAliasFrame (paliashdr, lerpdata); Fog_StopAdditive (); glDepthMask(GL_TRUE); glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_BLEND); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); } } else //case 3: overbright in two passes, then fullbright pass { // first pass GL_Bind(tx); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); GL_DrawAliasFrame (paliashdr, lerpdata); // second pass -- additive with black fog, to double the object colors but not the fog color glEnable(GL_BLEND); glBlendFunc (GL_ONE, GL_ONE); glDepthMask(GL_FALSE); Fog_StartAdditive (); GL_DrawAliasFrame (paliashdr, lerpdata); Fog_StopAdditive (); glDepthMask(GL_TRUE); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_BLEND); // third pass if (fb) { glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); GL_Bind(fb); glEnable(GL_BLEND); glBlendFunc (GL_ONE, GL_ONE); glDepthMask(GL_FALSE); shading = false; glColor3f(entalpha,entalpha,entalpha); Fog_StartAdditive (); GL_DrawAliasFrame (paliashdr, lerpdata); Fog_StopAdditive (); glDepthMask(GL_TRUE); glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_BLEND); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); } } } else { if (gl_mtexable && gl_texture_env_add && fb) //case 4: fullbright mask using multitexture { GL_DisableMultitexture(); // selects TEXTURE0 GL_Bind (tx); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); GL_EnableMultitexture(); // selects TEXTURE1 GL_Bind (fb); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD); glEnable(GL_BLEND); GL_DrawAliasFrame (paliashdr, lerpdata); glDisable(GL_BLEND); GL_DisableMultitexture(); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); } else //case 5: fullbright mask without multitexture { // first pass GL_Bind(tx); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); GL_DrawAliasFrame (paliashdr, lerpdata); // second pass if (fb) { GL_Bind(fb); glEnable(GL_BLEND); glBlendFunc (GL_ONE, GL_ONE); glDepthMask(GL_FALSE); shading = false; glColor3f(entalpha,entalpha,entalpha); Fog_StartAdditive (); GL_DrawAliasFrame (paliashdr, lerpdata); Fog_StopAdditive (); glDepthMask(GL_TRUE); glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_BLEND); } } } cleanup: glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glShadeModel (GL_FLAT); glDepthMask(GL_TRUE); glDisable(GL_BLEND); glColor3f(1,1,1); glPopMatrix (); }
bool CFXTransExplodingCubes::DoFrame(CDemo* pDemo, float fEffectTime, float fDemoTime) { assert(pDemo); CVarFloat::CValueFloat valueTime; CVarFloat::CValueFloat valueScaleX; CVarFloat::CValueFloat valueScaleY; CVarCombo::CValueCombo valueFiltering; CVarColor::CValueColor valueColor; EvaluateVar("Time (0-1)", fEffectTime, &valueTime); EvaluateVar("Tex Scale X", fEffectTime, &valueScaleX); EvaluateVar("Tex Scale Y", fEffectTime, &valueScaleY); EvaluateVar("Filtering", fEffectTime, &valueFiltering); EvaluateVar("Flat Color", fEffectTime, &valueColor); m_v4FlatColor = valueColor.GetValue(); // Change filter mode GLint minFilter, magFilter; UtilGL::States::Set(UtilGL::States::TEXTURE2D, UtilGL::States::ENABLED); m_textureRTT.SetActive(); glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, &minFilter); glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &magFilter); if(valueFiltering.GetValue() == "Yes") { // If it's point filtering, change it to linear, otherwise leave it as it is if(minFilter == GL_NEAREST) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); if(magFilter == GL_NEAREST) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); } else { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); } glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); // Framebuffer to texture m_textureRTT.CopyFromFramebuffer(0, 0, 0, 0, m_textureRTT.GetWidth(), m_textureRTT.GetHeight()); // Restore demo viewport pDemo->SetDemoViewport(); // Clear framebuffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); // States UtilGL::States::Set(UtilGL::States::LIGHTING, UtilGL::States::DISABLED); UtilGL::States::Set(UtilGL::States::BLENDING, UtilGL::States::DISABLED); UtilGL::States::Set (UtilGL::States::STENCILBUFFER, UtilGL::States::ENABLED); glStencilFunc(GL_ALWAYS, 1, 1); glStencilOp (GL_REPLACE, GL_REPLACE, GL_REPLACE); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(60.0f, 1.33f, 1.0f, 100.0f); UtilGL::Transforming::ClearMatrix(UtilGL::Transforming::MATRIX_WORLD); UtilGL::Transforming::ClearMatrix(UtilGL::Transforming::MATRIX_VIEW); CMatrix mtxTex; mtxTex.BuildScaling(valueScaleX.GetValue(), valueScaleY.GetValue(), 1.0f); UtilGL::Transforming::SetMatrix(UtilGL::Transforming::MATRIX_TEXTURE, mtxTex); // Render: VECCUBES::iterator it; for(it = m_vecCubes.begin(); it != m_vecCubes.end(); ++it) { float fTime = valueTime.GetValue() - it->fStartTime; if(fTime < 0.0f) fTime = 0.0f; DrawCube(*it, fTime); } glStencilFunc(GL_NOTEQUAL, 1, 1); glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP); // Restore UtilGL::States::Set(UtilGL::States::TEXTURE2D, UtilGL::States::DISABLED); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter); UtilGL::Transforming::ClearMatrix(UtilGL::Transforming::MATRIX_TEXTURE); return true; }
void Map::draw(Gosu::Graphics &graphics) { //this->drawGeometry(); //return; Gosu::PostProcessing local(graphics); static Gosu::ShaderProgram shadowMapProgram = local.compile(L"data/shader/shadowMap.frag"); static Gosu::ShaderProgram shadowProgram = local.compile(L"data/shader/shadow.frag", L"data/shader/shadow.vert"); glEnable(GL_TEXTURE_2D); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, 0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, 0); glActiveTexture(GL_TEXTURE0); // render from the light pov to the shadow fbo glBindFramebuffer(GL_FRAMEBUFFER, fboId); glClear(GL_DEPTH_BUFFER_BIT); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glViewport(0, 0, shadowMapWidth, shadowMapHeight); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); gluPerspective(45.0f, shadowMapWidth/shadowMapHeight, 200.0f, 1000.0f); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); gluLookAt(0, 0, 250, 128, -128, 0, 0, 0, 1); glUseProgram(shadowMapProgram.program); glUniform1i(glGetUniformLocation(shadowMapProgram.program, "colorTexture"), 0); // Save matrix to texture float modelView[16]; float projection[16]; glGetFloatv(GL_MODELVIEW_MATRIX, modelView); glGetFloatv(GL_PROJECTION_MATRIX, projection); glMatrixMode(GL_TEXTURE); glActiveTexture(GL_TEXTURE7); glLoadIdentity(); //gluLookAt(0, 0, 250, 128, -128, 0, 0, 0, 1); glMultMatrixf(projection); glMultMatrixf(modelView); glMatrixMode(GL_MODELVIEW); this->drawGeometry(); glUseProgram(0); glBindFramebuffer(GL_FRAMEBUFFER, 0); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); //gluPerspective(45.0f, (Gosu::realWidth(graphics)/Gosu::realHeight(graphics)), 200.0f, 1000.0f); // render normal camera view glViewport(0, 0, Gosu::realWidth(graphics), Gosu::realHeight(graphics)); glUseProgram(shadowProgram.program); glUniformMatrix4fv(glGetUniformLocation(shadowProgram.program, "test"), 16, false, projection); glUniform1i(glGetUniformLocation(shadowProgram.program, "colorTexture"), 0); glActiveTexture(GL_TEXTURE7); glBindTexture(GL_TEXTURE_2D, depthTextureId); glUniform1i(glGetUniformLocation(shadowProgram.program, "shadowMap"), 7); //setTextureMatrix(); this->drawGeometry(); glUseProgram(0); // Debug code to visualise depth buffer onscreen glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrtho(-1280/2,1280/2,-1024/2,1024/2,1,20); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glColor4f(1,1,1,1); glActiveTextureARB(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, depthTextureId); glEnable(GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE); glTranslated(0,0,-1); glBegin(GL_QUADS); glTexCoord2d(0,0); glVertex3f(0,0,0); glTexCoord2d(1,0); glVertex3f(1280/2,0,0); glTexCoord2d(1,1); glVertex3f(1280/2,1024/2,0); glTexCoord2d(0,1); glVertex3f(0,1024/2,0); glEnd(); glDisable(GL_TEXTURE_2D); glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); }
PIGLIT_GL_TEST_CONFIG_END enum piglit_result piglit_display(void) { GLboolean pass = GL_TRUE; int y, size; GLuint tex, fb; const float red[] = {1, 0, 0, 0}; const float green[] = {0, 1, 0, 0}; glClearColor(0.5, 0.5, 0.5, 0.5); glClear(GL_COLOR_BUFFER_BIT); glGenTextures(1, &tex); glBindTexture(GL_TEXTURE_2D, tex); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEX_WIDTH, TEX_HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, tex, 0); assert(glGetError() == 0); assert(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) == GL_FRAMEBUFFER_COMPLETE_EXT); /* For each power of two size we test, draw red to it, draw it to * the framebuffer, then draw green to it and draw it to the * framebuffer. * * Hopefully between these we'll catch any flushing fail. */ y = 0; for (size = TEX_WIDTH; size > 0; size /= 2) { glDisable(GL_TEXTURE_2D); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); glColor4fv(red); piglit_ortho_projection(TEX_WIDTH, TEX_HEIGHT, GL_FALSE); piglit_draw_rect(0, y, size, size); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo); glEnable(GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); piglit_draw_rect_tex(0, y, size, size, 0, 0, 1, 1); glDisable(GL_TEXTURE_2D); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); glColor4fv(green); piglit_ortho_projection(TEX_WIDTH, TEX_HEIGHT, GL_FALSE); piglit_draw_rect(0, y, size, size); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo); glEnable(GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); piglit_draw_rect_tex(0, y, size, size, 0, 0, 1, 1); y += size + 5; } glDeleteFramebuffersEXT(1, &fb); glDeleteTextures(1, &tex); y = 0; for (size = TEX_WIDTH; size > 0; size /= 2) { pass = pass && piglit_probe_rect_rgb(0, y, size, size, green); y += size + 5; } piglit_present_results(); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
void Cockpit::drawRadar () { int i; float yf = -4.2, zf = -7.0; gl->enableAlphaBlending (); glEnable (GL_ALPHA_TEST); glAlphaFunc (GL_GEQUAL, 0.1); glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); setColor (150); float xl, yl; int type; if (fplayer->o == &model_fig || fplayer->o == &model_figg) { gl->enableTextures (texradar2->textureID); xl = 1.4; yl = 1.3; type = 0; } else { gl->enableTextures (texradar1->textureID); xl = 1.3; yl = 1.2; type = 1; } glBegin (GL_QUADS); glTexCoord2d (0, 0); glVertex3f (-xl, yf - yl, zf); glTexCoord2d (0, 1); glVertex3f (-xl, yf + yl, zf); glTexCoord2d (1, 1); glVertex3f (xl, yf + yl, zf); glTexCoord2d (1, 0); glVertex3f (xl, yf - yl, zf); glEnd (); glDisable (GL_ALPHA_TEST); glDisable (GL_TEXTURE_2D); glLineWidth (LINEWIDTH(1.0F)); glBegin (GL_LINES); glVertex3f (0, yf - yl * 0.9, zf); glVertex3f (0, yf + yl * 0.9, zf); glVertex3f (-xl * 0.9, yf, zf); glVertex3f (xl * 0.9, yf, zf); glEnd (); int radarzoom = 1; if (fplayer->disttarget < 40) radarzoom = 2; for (i = 0; i < maxfighter; i ++) if (fighter [i] != fplayer && fighter [i]->active) { int aw = fplayer->getAngle (fighter [i]); if (aw < 0) aw += 360; float d = fplayer->distanceXZ (fighter [i]) / 100.0 * radarzoom; float px = -d * sine [aw]; float py = yf + d * cosi [aw]; if ((type == 0 && d < 1.2) || (type == 1 && px >= -1.2 && px <= 1.2 && py >= yf - 1.1 && py <= yf + 1.1)) { if (fighter [i] == fplayer->target) { drawBlip(SQUARE_BLIP, px, py, zf, 255, 200, 0); } else if (fighter [i]->party != fplayer->party) { drawBlip(SQUARE_BLIP, px, py, zf, 255, 0, 0); } else { drawBlip(SQUARE_BLIP, px, py, zf, 0, 0, 255); } } } for (i = 0; i < maxmissile; i ++) { if (missile [i]->target == fplayer && missile [i]->active) { int aw = fplayer->getAngle (missile [i]); if (aw < 0) aw += 360; float d = fplayer->distance (missile [i]) / 100.0 * radarzoom; float px = -d * sine [aw]; float py = yf + d * cosi [aw]; if ((type == 0 && d < 1.2) || (type == 1 && px >= -1.2 && px <= 1.2 && py >= yf - 1.1 && py <= yf + 1.1)) { drawBlip(TRIANGLE_BLIP, px, py, zf, 255, 255, 255); } } } gl->disableAlphaBlending (); }
static void generate_and_display_drawbuffers(int count) { GLuint tex[MAX_TARGETS], fb, fs, vs, prog; GLenum attachments[MAX_TARGETS], status; char *fs_count_source; int i; int colors_uniform; glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); for (i = 0; i < count; i++) { tex[i] = attach_texture(i); attachments[i] = GL_COLOR_ATTACHMENT0 + i; } status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { fprintf(stderr, "fbo incomplete (status = 0x%04x)\n", status); piglit_report_result(PIGLIT_SKIP); } glDrawBuffersARB(count, attachments); /* Clear all to red so we see if the shader rendering happens. */ glClearColor(1.0, 0.0, 0.0, 0.0); glClear(GL_COLOR_BUFFER_BIT); /* Build the shader that writes different color to each buffer. */ vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_source); fs_count_source = malloc(strlen(fs_source) + 5); sprintf(fs_count_source, fs_source, count); fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_count_source); free(fs_count_source); prog = piglit_link_simple_program(vs, fs); glUseProgram(prog); if (!piglit_check_gl_error(GL_NO_ERROR)) piglit_report_result(PIGLIT_FAIL); colors_uniform = glGetUniformLocation(prog, "colors"); glUniform4fv(colors_uniform, MAX_TARGETS, (GLfloat *) colors); /* Now render to all the color buffers. */ piglit_draw_rect(-1, -1, 2, 2); /* OK, now draw each of these textures to the winsys framebuffer. */ glUseProgram(0); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo); piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glEnable(GL_TEXTURE_2D); /* draw row of boxes, each with the color from texture/target[i] */ for (i = 0; i < count; i++) { glBindTexture(GL_TEXTURE_2D, tex[i]); piglit_draw_rect_tex(16 * i, 16 * (count - 1), 16, 16, 0, 0, 1, 1); } glDisable(GL_TEXTURE_2D); for (i = 0; i < count; i++) { glDeleteTextures(1, &tex[i]); } glDeleteFramebuffersEXT(1, &fb); }
GLuint LoadTextureRaw (char const * const szFilename, int const nWidth, int const nHeight, bool boAlpha, TexPersist * psTexData) { GLuint unTextureName = 0; void * cData; FILE * hFile; int nComponents; int uFormat; unsigned int uRead; if (psTexData->nTextures < psTexData->nMaxTextures) { if (boAlpha) { nComponents = 4; uFormat = GL_RGBA; } else { nComponents = 3; uFormat = GL_RGB; } hFile = fopen (szFilename, "rb"); if (hFile) { cData = g_malloc (nWidth * nHeight * nComponents); if (cData) { uRead = fread (cData, nWidth * nHeight * nComponents, 1, hFile); fclose (hFile); if (uRead == 1) { glGenTextures (1, & unTextureName); glBindTexture (GL_TEXTURE_2D, unTextureName); //glTexImage2D (GL_TEXTURE_2D, 0, uFormat, nWidth, nHeight, 0, uFormat, GL_UNSIGNED_BYTE, cData); gluBuild2DMipmaps (GL_TEXTURE_2D, nComponents, nWidth, nHeight, uFormat, GL_UNSIGNED_BYTE, cData); glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 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); /* glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); 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_MIN_FILTER, GL_NEAREST); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); gluBuild2DMipmaps (GL_TEXTURE_2D, nComponents, nWidth, nHeight, uFormat, GL_UNSIGNED_BYTE, cData); */ } else { fprintf (stderr, "Error: Failed to fully load texture %s\n", szFilename); } g_free (cData); } } else { fprintf (stderr, "Error: Could not open texture %s\n", szFilename); } psTexData->aunTextureName[psTexData->nTextures] = unTextureName; psTexData->nTextures++; } return unTextureName; }
void GLES11RenderEngine::setupLayerBlending( bool premultipliedAlpha, bool opaque, int alpha) { GLenum combineRGB; GLenum combineAlpha; GLenum src0Alpha; GLfloat envColor[4]; if (CC_UNLIKELY(alpha < 0xFF)) { // Cv = premultiplied ? Cs*alpha : Cs // Av = !opaque ? As*alpha : As combineRGB = premultipliedAlpha ? GL_MODULATE : GL_REPLACE; combineAlpha = !opaque ? GL_MODULATE : GL_REPLACE; src0Alpha = GL_CONSTANT; envColor[0] = alpha * (1.0f / 255.0f); } else { // Cv = Cs // Av = opaque ? 1.0 : As combineRGB = GL_REPLACE; combineAlpha = GL_REPLACE; src0Alpha = opaque ? GL_CONSTANT : GL_TEXTURE; envColor[0] = 1.0f; } glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, combineRGB); glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR); if (combineRGB == GL_MODULATE) { glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_CONSTANT); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR); } glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, combineAlpha); glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, src0Alpha); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA); if (combineAlpha == GL_MODULATE) { glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA); } if (combineRGB == GL_MODULATE || src0Alpha == GL_CONSTANT) { envColor[1] = envColor[0]; envColor[2] = envColor[0]; envColor[3] = envColor[0]; glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, envColor); } if (alpha < 0xFF || !opaque) { glEnable(GL_BLEND); glBlendFunc(premultipliedAlpha ? GL_ONE : GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); } else { glDisable(GL_BLEND); } }
static void generate_and_display_drawbuffers(int count) { GLuint tex[16], fb, fs, vs, prog; GLenum attachments[16], status; int i; char fs_output_line[256]; char fs_full_source[1024]; glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); for (i = 0; i < count; i++) { tex[i] = attach_texture(i); attachments[i] = GL_COLOR_ATTACHMENT0 + i; } status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { fprintf(stderr, "fbo incomplete (status = 0x%04x)\n", status); piglit_report_result(PIGLIT_SKIP); } glDrawBuffersARB(count, attachments); /* Clear all to 0.25 so we see if the shader rendering happens. */ glClearColor(clear_value, clear_value, clear_value, clear_value); glClear(GL_COLOR_BUFFER_BIT); /* Build the shader that spams green to all outputs. */ vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_source); strcpy(fs_full_source, fs_source_start); for (i = 0; i < count; i++) { sprintf(fs_output_line, fs_source_output, i, output_values[i * 4], output_values[(i * 4) + 1], output_values[(i * 4) + 2], output_values[(i * 4) + 3]); strcat(fs_full_source, fs_output_line); } strcat(fs_full_source, fs_source_end); assert(strlen(fs_full_source) + 1 < sizeof(fs_full_source) / sizeof(fs_full_source[0])); fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_full_source); prog = piglit_link_simple_program(vs, fs); glUseProgram(prog); glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_FUNC_ADD); /* Now render to all the color buffers. */ piglit_draw_rect(-1, -1, 2, 2); glDisable(GL_BLEND); /* OK, now draw each of these textures to the winsys framebuffer. */ glUseProgram(0); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glEnable(GL_TEXTURE_2D); for (i = 0; i < count; i++) { glBindTexture(GL_TEXTURE_2D, tex[i]); piglit_draw_rect_tex(16 * i, 16 * (count - 1), 16, 16, 0, 0, 1, 1); } glDisable(GL_TEXTURE_2D); for (i = 0; i < count; i++) { glDeleteTextures(1, &tex[i]); } glDeleteFramebuffersEXT(1, &fb); }
void CAdvTreeDrawer::Draw(float treeDistance,bool drawReflection) { int activeFarTex=camera->forward.z<0 ? treeGen->farTex[0] : treeGen->farTex[1]; bool drawDetailed=true; if(treeDistance<4) drawDetailed=false; if(drawReflection) drawDetailed=false; CBaseGroundDrawer *gd = readmap->GetGroundDrawer (); glEnable(GL_ALPHA_TEST); if(shadowHandler->drawShadows && !gd->DrawExtraTex()) { glBindProgramARB( GL_VERTEX_PROGRAM_ARB, treeGen->treeFarVP ); glEnable(GL_VERTEX_PROGRAM_ARB); glBindTexture(GL_TEXTURE_2D,shadowHandler->shadowTexture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL); glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_ALPHA); if(shadowHandler->useFPShadows) { glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, treeGen->treeFPShadow ); glEnable( GL_FRAGMENT_PROGRAM_ARB ); glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,10, mapInfo->light.groundAmbientColor.x,mapInfo->light.groundAmbientColor.y,mapInfo->light.groundAmbientColor.z,1); glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,11, 0,0,0,1-mapInfo->light.groundShadowDensity*0.5f); glActiveTextureARB(GL_TEXTURE1_ARB); glBindTexture(GL_TEXTURE_2D, activeFarTex); } else { glEnable(GL_TEXTURE_2D); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FAIL_VALUE_ARB, 1-mapInfo->light.groundShadowDensity*0.5f); float texConstant[]= {mapInfo->light.groundAmbientColor.x,mapInfo->light.groundAmbientColor.y,mapInfo->light.groundAmbientColor.z,0.0f}; glTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_COLOR,texConstant); glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE0_RGB_ARB,GL_PREVIOUS_ARB); glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE1_RGB_ARB,GL_CONSTANT); glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE2_RGB_ARB,GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV,GL_OPERAND2_RGB_ARB,GL_SRC_ALPHA); glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_RGB_ARB,GL_INTERPOLATE_ARB); glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE0_ALPHA_ARB,GL_PREVIOUS_ARB); glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE1_ALPHA_ARB,GL_CONSTANT); glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_ALPHA_ARB,GL_ADD); glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_COMBINE_ARB); glActiveTextureARB(GL_TEXTURE1_ARB); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, activeFarTex); } glActiveTextureARB(GL_TEXTURE0_ARB); glMatrixMode(GL_MATRIX0_ARB); glLoadMatrixf(shadowHandler->shadowMatrix.m); glMatrixMode(GL_MODELVIEW); } else { glBindTexture(GL_TEXTURE_2D, activeFarTex); } glEnable(GL_TEXTURE_2D); int cx=(int)(camera->pos.x/(SQUARE_SIZE*TREE_SQUARE_SIZE)); int cy=(int)(camera->pos.z/(SQUARE_SIZE*TREE_SQUARE_SIZE)); CAdvTreeSquareDrawer drawer; drawer.td = this; drawer.cx = cx; drawer.cy = cy; drawer.treeDistance = treeDistance; drawer.drawDetailed = drawDetailed; GML_STDMUTEX_LOCK(tree); // Draw // draw far away trees using the map dependent grid visibility oldTreeDistance=treeDistance; readmap->GridVisibility (camera, TREE_SQUARE_SIZE, treeDistance*2*SQUARE_SIZE*TREE_SQUARE_SIZE, &drawer); if(drawDetailed) { int xstart=std::max(0,cx-2); int xend=std::min(gs->mapx/TREE_SQUARE_SIZE-1,cx+2); int ystart=std::max(0,cy-2); int yend=std::min(gs->mapy/TREE_SQUARE_SIZE-1,cy+2); if(shadowHandler->drawShadows && !gd->DrawExtraTex()) { glBindProgramARB( GL_VERTEX_PROGRAM_ARB, treeGen->treeVP ); glActiveTextureARB(GL_TEXTURE1_ARB); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, treeGen->barkTex); glActiveTextureARB(GL_TEXTURE0_ARB); } else { glBindTexture(GL_TEXTURE_2D, treeGen->barkTex); glBindProgramARB( GL_VERTEX_PROGRAM_ARB, treeGen->treeNSVP ); glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,15, 1.0f/(gs->pwr2mapx*SQUARE_SIZE),1.0f/(gs->pwr2mapy*SQUARE_SIZE),1.0f/(gs->pwr2mapx*SQUARE_SIZE),1); } glEnable( GL_VERTEX_PROGRAM_ARB ); glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,13, camera->right.x,camera->right.y,camera->right.z,0); glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,9, camera->up.x,camera->up.y,camera->up.z,0); glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,11, mapInfo->light.groundSunColor.x,mapInfo->light.groundSunColor.y,mapInfo->light.groundSunColor.z,0.85f); glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,14, mapInfo->light.groundAmbientColor.x,mapInfo->light.groundAmbientColor.y,mapInfo->light.groundAmbientColor.z,0.85f); glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,12, 0,0,0,0.20f*(1.0f/MAX_TREE_HEIGHT)); //w=alpha/height modifier glAlphaFunc(GL_GREATER,0.5f); glDisable(GL_BLEND); glColor4f(1,1,1,1); va=GetVertexArray(); va->Initialize(); struct FadeTree { float3 pos; float relDist; float deltaY; int type; }; static FadeTree fadeTrees[3000]; FadeTree *pFT=fadeTrees; for(TreeSquareStruct* pTSS=trees+ystart*treesX; pTSS<=trees+yend*treesX; pTSS+=treesX) { for(TreeSquareStruct* tss=pTSS+xstart; tss<=pTSS+xend; ++tss) { tss->lastSeen=gs->frameNum; va->EnlargeArrays(12*tss->trees.size(),0,VA_SIZE_T); //!alloc room for all tree vertexes for(std::map<int,TreeStruct>::iterator ti=tss->trees.begin(); ti!=tss->trees.end(); ++ti) { TreeStruct* ts=&ti->second; float3 pos(ts->pos); int type=ts->type; float dy; unsigned int displist; if(type<8) { dy=0.5f; displist=treeGen->pineDL+type; } else { type-=8; dy=0; displist=treeGen->leafDL+type; } if(camera->InView(pos+float3(0,MAX_TREE_HEIGHT/2,0),MAX_TREE_HEIGHT/2)) { float camDist=(pos-camera->pos).SqLength(); if(camDist<SQUARE_SIZE*SQUARE_SIZE*110*110) { //draw detailed tree glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,10,pos.x,pos.y,pos.z,0); glCallList(displist); } else if(camDist<SQUARE_SIZE*SQUARE_SIZE*125*125) { //draw fading tree float relDist=(pos.distance(camera->pos)-SQUARE_SIZE*110)/(SQUARE_SIZE*15); glAlphaFunc(GL_GREATER,0.8f+relDist*0.2f); glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,10,pos.x,pos.y,pos.z,0); glCallList(displist); glAlphaFunc(GL_GREATER,0.5f); pFT->pos=pos; pFT->deltaY=dy; pFT->type=type; pFT->relDist=relDist; ++pFT; } else { //draw undetailed tree DrawTreeVertex(pos, type*0.125f, dy, false); } } } } } //draw trees that has been marked as falling glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,10,0,0,0,0); glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,13, camera->right.x,camera->right.y,camera->right.z,0); glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,9, camera->up.x,camera->up.y,camera->up.z,0); for(std::list<FallingTree>::iterator fti=fallingTrees.begin(); fti!=fallingTrees.end(); ++fti) { float3 pos=fti->pos-UpVector*(fti->fallPos*20); if(camera->InView(pos+float3(0,MAX_TREE_HEIGHT/2,0),MAX_TREE_HEIGHT/2)) { float ang=fti->fallPos*PI; float3 up(fti->dir.x*sin(ang),cos(ang),fti->dir.z*sin(ang)); float3 z(up.cross(float3(-1,0,0))); z.ANormalize(); float3 x(up.cross(z)); CMatrix44f transMatrix(pos,x,up,z); glPushMatrix(); glMultMatrixf(&transMatrix[0]); int type=fti->type; int displist; if(type<8) { displist=treeGen->pineDL+type; } else { type-=8; displist=treeGen->leafDL+type; } glCallList(displist); glPopMatrix(); } } glDisable( GL_VERTEX_PROGRAM_ARB ); if(shadowHandler->drawShadows && !gd->DrawExtraTex()) { glBindProgramARB( GL_VERTEX_PROGRAM_ARB, treeGen->treeFarVP ); glEnable(GL_VERTEX_PROGRAM_ARB); glActiveTextureARB(GL_TEXTURE1_ARB); glBindTexture(GL_TEXTURE_2D, activeFarTex); glActiveTextureARB(GL_TEXTURE0_ARB); } else { glBindTexture(GL_TEXTURE_2D, activeFarTex); } va->DrawArrayT(GL_QUADS); for(FadeTree *pFTree=fadeTrees; pFTree<pFT; ++pFTree) { //faded close trees va=GetVertexArray(); va->Initialize(); va->CheckInitSize(12*VA_SIZE_T); DrawTreeVertex(pFTree->pos, pFTree->type*0.125f, pFTree->deltaY, false); glAlphaFunc(GL_GREATER,1-pFTree->relDist*0.5f); va->DrawArrayT(GL_QUADS); } } if(shadowHandler->drawShadows && !gd->DrawExtraTex()) { glDisable( GL_VERTEX_PROGRAM_ARB ); if(shadowHandler->useFPShadows) { glDisable(GL_FRAGMENT_PROGRAM_ARB); } glActiveTextureARB(GL_TEXTURE1_ARB); glDisable(GL_TEXTURE_2D); glActiveTextureARB(GL_TEXTURE0_ARB); glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_NONE); glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_LUMINANCE); } glDisable(GL_ALPHA_TEST); //clean out squares from memory that are no longer visible int startClean=lastListClean*20%(nTrees); lastListClean=gs->frameNum; int endClean=gs->frameNum*20%(nTrees); if(startClean>endClean) { for(TreeSquareStruct *pTSS=trees+startClean; pTSS<trees+nTrees; ++pTSS) { if(pTSS->lastSeen<gs->frameNum-50 && pTSS->displist) { glDeleteLists(pTSS->displist,1); pTSS->displist=0; } if(pTSS->lastSeenFar<gs->frameNum-50 && pTSS->farDisplist) { glDeleteLists(pTSS->farDisplist,1); pTSS->farDisplist=0; } } for(TreeSquareStruct *pTSS=trees; pTSS<trees+endClean; ++pTSS) { if(pTSS->lastSeen<gs->frameNum-50 && pTSS->displist) { glDeleteLists(pTSS->displist,1); pTSS->displist=0; } if(pTSS->lastSeenFar<gs->frameNum-50 && pTSS->farDisplist) { glDeleteLists(pTSS->farDisplist,1); pTSS->farDisplist=0; } } } else { for(TreeSquareStruct *pTSS=trees+startClean; pTSS<trees+endClean; ++pTSS) { if(pTSS->lastSeen<gs->frameNum-50 && pTSS->displist) { glDeleteLists(pTSS->displist,1); pTSS->displist=0; } if(pTSS->lastSeenFar<gs->frameNum-50 && pTSS->farDisplist) { glDeleteLists(pTSS->farDisplist,1); pTSS->farDisplist=0; } } } }
// Load PNG for texture int LoadPNG (char *filename) // Loads A PNG File Into Memory { char header[8]; GLuint bytesPerPixel; // Holds Number Of Bytes Per Pixel Used In The TGA File GLuint imageSize; // Used To Store The Image Size When Setting Aside Ram GLuint temp; // Temporary Variable GLuint type = GL_RGBA; // Set The Default GL Mode To RBGA (32 BPP) GLuint i; GLuint pos = 0; unsigned char value[4]; FILE *file = fopen(filename, "rb"); // Open The TGA File if ( file==NULL ) return 0; // Check if this is indeed a PNG file fread(header, 1, 8, file); if (png_sig_cmp(header, 0, 8)) { fclose(file); return 0; } // Initialise PNG structures png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); if (!png_ptr) { fclose(file); return 0; } png_infop info_ptr = png_create_info_struct(png_ptr); if (!info_ptr) { fclose(file); png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL); return 0; } png_infop end_info = png_create_info_struct(png_ptr); if (!end_info) { fclose(file); png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL); return 0; } // Init PNG file i/o png_init_io(png_ptr, file); // We've already read the header (8 bytes) png_set_sig_bytes(png_ptr, 8); // Read the image into memory png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL); g_overlay.width = png_ptr->width; // Determine The PNG Width g_overlay.height = png_ptr->height; // Determine The PNG Height if( g_overlay.width <=0 || // Is The Width Less Than Or Equal To Zero g_overlay.height <=0) // Is The Height Less Than Or Equal To Zero { fclose(file); // If Anything Failed, Close The File return 0; // Return False } g_overlay.bpp = png_ptr->bit_depth * png_ptr->channels; // Bits per pixel (24 or 32) bytesPerPixel = g_overlay.bpp/8; // Divide By 8 To Get The Bytes Per Pixel imageSize = g_overlay.width*g_overlay.height*bytesPerPixel; // Calculate The Memory Required For The TGA Data //g_overlay.upsideDown = (header[17] & 0x20) ? 0 : 1; // If TGA origin is bottom-left g_overlay.imageData = (GLubyte *)png_ptr->row_buf[0]; // Reserve Memory To Hold The TGA Data //if ( 2 == tgaType ) //{ // // uncompressed RGB (24 or 32-bit) // g_overlay.imageData=(GLubyte *)malloc(imageSize); // Reserve Memory To Hold The TGA Data // if( g_overlay.imageData==NULL || // Does The Storage Memory Exist? // fread(g_overlay.imageData, 1, imageSize, file)!=imageSize) // Does The Image Size Match The Memory Reserved? // { // if(g_overlay.imageData!=NULL) // Was Image Data Loaded // free(g_overlay.imageData); // If So, Release The Image Data // fclose(file); // Close The File // return 0; // Return False // } // for (i=0; i < imageSize; i += bytesPerPixel) // { // temp = g_overlay.imageData[i]; // Temporarily Store The Value At Image Data 'i' // g_overlay.imageData[i] = g_overlay.imageData[i + 2]; // Set The 1st Byte To The Value Of The 3rd Byte // g_overlay.imageData[i + 2] = temp; // Set The 3rd Byte To The Value In 'temp' (1st Byte Value) // } //} //else if (10 == tgaType) //{ // // RLE compressed RGB (24 or 32-bit) // g_overlay.imageData=(GLubyte *)malloc(imageSize); // Reserve Memory To Hold The TGA Data // pos = 0; // while(1) // { // // read packet header // unsigned char ph; // = fgetc(file); // if (fread(&ph, 1, 1, file)!=1) // { // fclose(file); // return 0; // } // // packet type // if (ph & 0x80) // { // // run-length packet // unsigned int len = (ph & 0x7F) + 1; // fread(value, 1, bytesPerPixel, file); // for (i=0; i<len; i++) // { // g_overlay.imageData[pos] = value[2]; // g_overlay.imageData[pos+1] = value[1]; // g_overlay.imageData[pos+2] = value[0]; // pos += bytesPerPixel; // } // } // else // { // // "raw" packet // unsigned int len = (ph & 0x7F) + 1; // for (i=0; i<len; i++) // { // fread(value, 1, bytesPerPixel, file); // g_overlay.imageData[pos] = value[2]; // g_overlay.imageData[pos+1] = value[1]; // g_overlay.imageData[pos+2] = value[0]; // pos += bytesPerPixel; // } // } // if (pos >= imageSize) // break; // } //} fclose (file); // Close The File // resize if neccessary if (g_overlay.width != 512 || g_overlay.height != 512) { GLubyte* newImageData = (GLubyte *)malloc(512*512*bytesPerPixel); // Reserve Memory To Hold The RGB Data gluScaleImage(GL_RGB, g_overlay.width, g_overlay.height, GL_UNSIGNED_BYTE, g_overlay.imageData, 512, 512, GL_UNSIGNED_BYTE, newImageData); free(g_overlay.imageData); g_overlay.imageData = newImageData; g_overlay.width = 512; g_overlay.height = 512; } // Build A Texture From The Data glGenTextures(1, &g_overlay.texID); // Generate OpenGL texture IDs glBindTexture(GL_TEXTURE_2D, g_overlay.texID); // Bind Our Texture glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // Linear Filtered glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Linear Filtered glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); if (g_overlay.bpp==24) // Was The TGA 24 Bits { type=GL_RGB; // If So Set The 'type' To GL_RGB } glTexImage2D(GL_TEXTURE_2D, 0, type, g_overlay.width, g_overlay.height, 0, type, GL_UNSIGNED_BYTE, g_overlay.imageData); return 1; // Texture Building Went Ok, Return True }
/* * Adapted from Example 7 given on Moodle * Draw a cylinder * at (x,y,z) * dimentions (dx,dy,dz) * rotated th about the z axis * given top & bottom color * given side color */ void drawCylinder(double x,double y,double z, double dx,double dy,double dz, double th, char lcol, char scol) { double radius = 0.3, height = 0.2; // Set specular color to white float white[] = {1,1,1,1}; float black[] = {0,0,0,1}; glMaterialfv(GL_FRONT_AND_BACK,GL_SHININESS,shinyvec); glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,white); glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,black); glPushMatrix(); // Transform cylinder glTranslated(x,y,z); glRotated(th,0,0,1); glScaled(dx,dy,dz); // Enable textures glEnable(GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE); //Set colors if (scol == 'r'){ glColor3f(1.0, 0.0, 0.0); //Set color to red } else if (scol == 'g') { glColor3f(0.0, 1.0, 0.0); //Set color to green } else if (scol == 'b') { glColor3f(0.0, 0.0, 1.0); //Set color to blue } else if (scol == 'w') { glColor3f(1.0, 1.0, 1.0); //Set color to white } else { glColor3f(0.8, 0.8, 0.8); //Default color to gray } glBindTexture(GL_TEXTURE_2D,texture[0]); double j; glBegin(GL_QUAD_STRIP); for (j = 0; j <= 360; j+=.125) { const float tc = (j / (float) 360); double x = radius * Cos(j); double y = height; double z = radius * Sin(j); glNormal3d(Cos(j), 0, Sin(j)); glTexCoord2f(-tc, 0.0); glVertex3d(x, -y, z); glTexCoord2f(-tc, 1.0); glVertex3d(x, y, z); } glEnd(); //Set colors if (lcol == 'r'){ glColor3f(1.0, 0.0, 0.0); //Set color to red } else if (lcol == 'g') { glColor3f(0.0, 1.0, 0.0); //Set color to green } else if (lcol == 'b') { glColor3f(0.0, 0.0, 1.0); //Set color to blue } else if (lcol == 'w') { glColor3f(1.0, 1.0, 1.0); //Set color to white } else { glColor3f(0.8, 0.8, 0.8); //Default color to gray } double i; glBindTexture(GL_TEXTURE_2D,texture[1]); glNormal3d(0,1,0); /* Top of Cylinder */ glBegin(GL_TRIANGLE_FAN); glTexCoord2f(0.5,0.5); glVertex3d(0.0, height, 0.0); for(i = 0.0; i <= 360; i+=10) { glTexCoord2f(-0.5*Cos(i)+0.5, 0.5*Sin(i)+0.5); glVertex3d(radius * Cos(i), height, radius * Sin(i)); } glEnd(); glBindTexture(GL_TEXTURE_2D,texture[2]); glNormal3d(0,-1,0); /* Bottom of Cylinder */ glBegin(GL_TRIANGLE_FAN); glTexCoord2f(0.5,0.5); glVertex3d(0.0, -height, 0.0); for(i = 0.0; i <= 360; i+=10) { glTexCoord2f(0.5*Cos(i)+0.5, 0.5*Sin(i)+0.5); glVertex3d(radius * Cos(i), -height, radius * Sin(i)); } glEnd(); glPopMatrix(); glDisable(GL_TEXTURE_2D); }
bool GLSink::createDownStream(unsigned int w, unsigned int h, int nIntFormat, int nExtFormat, int nType) { m_uiTextureWidth = w; m_uiTextureHeight = h; m_nIntFormat = nIntFormat; m_nExtFormat = nExtFormat; m_nType = nType; m_fAspectRatio = (float)w/(float)h; m_uiBufferSize = FormatInfo::getInternalFormatSize(m_nIntFormat) * m_uiTextureWidth * m_uiTextureHeight; if (m_uiBufferSize == 0) return false; // check if format is supported if (FormatInfo::getExternalFormatSize(m_nExtFormat, m_nType) == 0) return false; glBindBuffer(GL_BUS_ADDRESSABLE_MEMORY_AMD, 0); // Create texture that will be used to store frames from remote device glGenTextures(1, &m_uiTexture); glBindTexture(GL_TEXTURE_2D, m_uiTexture); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); 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_BORDER); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); glTexImage2D(GL_TEXTURE_2D, 0, m_nIntFormat, m_uiTextureWidth, m_uiTextureHeight, 0, m_nExtFormat, m_nType, NULL); glBindTexture(GL_TEXTURE_2D, 0); m_uiTextureSize = m_uiTextureWidth*m_uiTextureHeight*FormatInfo::getExternalFormatSize(m_nExtFormat, m_nType); m_pUnPackBuffer = new unsigned int[NUM_BUFFERS]; m_pBufferBusAddress = new unsigned long long[NUM_BUFFERS]; m_pMarkerBusAddress = new unsigned long long[NUM_BUFFERS]; glGenBuffers(NUM_BUFFERS, m_pUnPackBuffer); // Create buffers for (unsigned int i = 0; i < NUM_BUFFERS; i++) { glBindBuffer(GL_BUS_ADDRESSABLE_MEMORY_AMD, m_pUnPackBuffer[i]); glBufferData(GL_BUS_ADDRESSABLE_MEMORY_AMD, m_uiBufferSize, 0, GL_DYNAMIC_DRAW); } // Call makeResident when all BufferData calls were submitted. This call will make the // buffers resident in local visible memory. glMakeBuffersResidentAMD(NUM_BUFFERS, m_pUnPackBuffer, m_pBufferBusAddress, m_pMarkerBusAddress); // Create synchronization buffers m_pInputBuffer = new SyncedBuffer; m_pInputBuffer->createSyncedBuffer(NUM_BUFFERS); for (unsigned int i = 0; i < NUM_BUFFERS; i++) { FrameData* pFrameData = new FrameData; pFrameData->uiTransferId = 0; pFrameData->ullBufferBusAddress = m_pBufferBusAddress[i]; pFrameData->ullMarkerBusAddress = m_pMarkerBusAddress[i]; m_pInputBuffer->setBufferMemory(i, (void*)pFrameData); } return true; }
bool PinnedUnPackBuffer::init(sv_handle * sv, sv_direct_handle * dh_in, sv_direct_handle * dh_out, int buffercount) { float quad[] = { -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f }; float rquad[]= { -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f }; int res = SV_OK; if((buffercount > 2) || (buffercount < 1)) { return false; } glClearColor(0.3f, 0.3f, 0.3f, 1.0f); glEnable(GL_DEPTH_TEST); glEnable(GL_TEXTURE_2D); glShadeModel(GL_SMOOTH); glPolygonMode(GL_FRONT, GL_FILL); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glGenBuffers(1, &mUIQuad); glBindBuffer(GL_ARRAY_BUFFER, mUIQuad); glBufferData(GL_ARRAY_BUFFER, 20 * sizeof(float), quad, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); glGenBuffers(1, &mUIRQuad); glBindBuffer(GL_ARRAY_BUFFER, mUIRQuad); glBufferData(GL_ARRAY_BUFFER, 20 * sizeof(float), rquad, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glViewport(0, 0, mWidth, mHeight); glOrtho(-1.0f, 1.0f, 1.0f, -1.0f, 0, 128); glGenBuffers(buffercount, mTextureInput); glGenBuffers(buffercount, mTextureOutput); for(int i = 0; i < buffercount; i++) { res = sv_direct_bind_opengl(sv, dh_in, i, mTextureInput[i]); if(res != SV_OK) { return false; } res = sv_direct_bind_opengl(sv, dh_out, i, mTextureOutput[i]); if(res != SV_OK) { return false; } } // Generate a texture into which tha data from teh buffer is dpwnloaded glGenTextures(1, &mUITexture); glBindTexture(GL_TEXTURE_2D, mUITexture); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, mWidth, mHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glBindTexture(GL_TEXTURE_2D, 0); mRenderTarget = new RenderTarget; mRenderTarget->createBuffer(mWidth, mHeight, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE); return true; }
void COGLColorCombiner::InitCombinerCycle12(void) { m_pOGLRender->DisableMultiTexture(); if( !m_bTexelsEnable ) { glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); OPENGL_CHECK_ERRORS; m_pOGLRender->EnableTexUnit(0,FALSE); return; } #ifndef USE_GLES uint32 mask = 0x1f; COGLTexture* pTexture = g_textures[gRSP.curTile].m_pCOGLTexture; if( pTexture ) { m_pOGLRender->EnableTexUnit(0,TRUE); m_pOGLRender->BindTexture(pTexture->m_dwTextureName, 0); m_pOGLRender->SetAllTexelRepeatFlag(); } #ifdef DEBUGGER else { DebuggerAppendMsg("Check me, texture is NULL"); } #endif bool texIsUsed = m_pDecodedMux->isUsed(MUX_TEXEL0); bool shadeIsUsedInColor = m_pDecodedMux->isUsedInCycle(MUX_SHADE, 0, COLOR_CHANNEL); bool texIsUsedInColor = m_pDecodedMux->isUsedInCycle(MUX_TEXEL0, 0, COLOR_CHANNEL); if( texIsUsed ) { // Parse the simplified the mux, because the OGL 1.1 combiner function is so much // limited, we only parse the 1st N64 combiner setting and only the RGB part N64CombinerType & comb = m_pDecodedMux->m_n64Combiners[0]; switch( m_pDecodedMux->mType ) { case CM_FMT_TYPE_NOT_USED: case CM_FMT_TYPE_D: // = A glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); OPENGL_CHECK_ERRORS; break; case CM_FMT_TYPE_A_ADD_D: // = A+D if( shadeIsUsedInColor && texIsUsedInColor ) { if( m_bSupportAdd ) glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD); else glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND); } else if( texIsUsedInColor ) { glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); } else glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); OPENGL_CHECK_ERRORS; break; case CM_FMT_TYPE_A_SUB_B: // = A-B if( shadeIsUsedInColor && texIsUsedInColor ) { if( m_bSupportSubtract ) glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_SUBTRACT); else glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND); } else if( texIsUsedInColor ) { glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); } else glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); OPENGL_CHECK_ERRORS; break; case CM_FMT_TYPE_A_MOD_C: // = A*C case CM_FMT_TYPE_A_MOD_C_ADD_D: // = A*C+D if( shadeIsUsedInColor && texIsUsedInColor ) { if( ((comb.c & mask) == MUX_SHADE && !(comb.c&MUX_COMPLEMENT)) || ((comb.a & mask) == MUX_SHADE && !(comb.a&MUX_COMPLEMENT)) ) glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); else glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); } else if( texIsUsedInColor ) { glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); } else glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); OPENGL_CHECK_ERRORS; break; case CM_FMT_TYPE_A_LERP_B_C: // = A*C+D if( (comb.b&mask) == MUX_SHADE && (comb.c&mask)==MUX_TEXEL0 && ((comb.a&mask)==MUX_PRIM||(comb.a&mask)==MUX_ENV)) { float *fv; if( (comb.a&mask)==MUX_PRIM ) { fv = GetPrimitiveColorfv(); } else { fv = GetEnvColorfv(); } glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,fv); OPENGL_CHECK_ERRORS; glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND); OPENGL_CHECK_ERRORS; break; } default: // = (A-B)*C+D if( shadeIsUsedInColor ) { if( ((comb.c & mask) == MUX_SHADE && !(comb.c&MUX_COMPLEMENT)) || ((comb.a & mask) == MUX_SHADE && !(comb.a&MUX_COMPLEMENT)) ) glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); else glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); } else { glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); } OPENGL_CHECK_ERRORS; break; } } else { glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); OPENGL_CHECK_ERRORS; } #endif }
static void greyscale(V2fT2f *quad, float t) // t = 1 for standard perceptual weighting { GLfloat lerp[4] = { 1.0, 1.0, 1.0, 0.5 }; GLfloat avrg[4] = { .667, .667, .667, 0.5 }; // average GLfloat prcp[4] = { .646, .794, .557, 0.5 }; // perceptual NTSC GLfloat dot3[4] = { prcp[0]*t+avrg[0]*(1-t), prcp[1]*t+avrg[1]*(1-t), prcp[2]*t+avrg[2]*(1-t), 0.5 }; // One pass using two units: // Unit 0 scales and biases into [0.5..1.0] // Unit 1 dot products with perceptual weights glVertexPointer (2, GL_FLOAT, sizeof(V2fT2f), &quad[0].x); glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &quad[0].s); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE); glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_CONSTANT); glTexEnvi(GL_TEXTURE_ENV, GL_SRC2_RGB, GL_CONSTANT); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE); glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_TEXTURE); glTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_COLOR, lerp); // Note: we prefer to dot product with primary color, because // the constant color is stored in limited precision on MBX glActiveTexture(GL_TEXTURE1); glEnable(GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_DOT3_RGB); glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PREVIOUS); glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_PRIMARY_COLOR); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE); glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_PREVIOUS); glColor4f(dot3[0], dot3[1], dot3[2], dot3[3]); validateTexEnv(); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); // Restore state glDisable(GL_TEXTURE_2D); glActiveTexture(GL_TEXTURE0); }
static cairo_status_t _render_glyphs (cairo_gl_surface_t *dst, int dst_x, int dst_y, cairo_operator_t op, const cairo_pattern_t *source, cairo_glyph_t *glyphs, int num_glyphs, const cairo_rectangle_int_t *glyph_extents, cairo_scaled_font_t *scaled_font, cairo_region_t *clip_region, int *remaining_glyphs) { cairo_format_t last_format = (cairo_format_t) -1; cairo_gl_glyph_cache_t *cache = NULL; cairo_gl_context_t *ctx; cairo_gl_glyphs_setup_t setup; cairo_gl_composite_setup_t composite_setup; cairo_status_t status; int i = 0; GLuint vbo = 0; status = _cairo_gl_operand_init (&composite_setup.src, source, dst, glyph_extents->x, glyph_extents->y, dst_x, dst_y, glyph_extents->width, glyph_extents->height); if (unlikely (status)) return status; ctx = _cairo_gl_context_acquire (dst->ctx); /* Set up the mask to source from the incoming vertex color. */ glActiveTexture (GL_TEXTURE1); glEnable (GL_TEXTURE_2D); /* IN: dst.argb = src.argb * mask.aaaa */ glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE); glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE); glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE); glTexEnvi (GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PREVIOUS); glTexEnvi (GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_PREVIOUS); glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR); glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA); glTexEnvi (GL_TEXTURE_ENV, GL_SRC1_RGB, GL_TEXTURE1); glTexEnvi (GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_TEXTURE1); glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_ALPHA); glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA); _cairo_gl_set_destination (dst); _cairo_gl_set_operator (dst, op); _cairo_gl_set_src_operand (ctx, &composite_setup); _cairo_scaled_font_freeze_cache (scaled_font); if (! _cairo_gl_surface_owns_font (dst, scaled_font)) { status = CAIRO_INT_STATUS_UNSUPPORTED; goto CLEANUP_FONT; } if (scaled_font->surface_private == NULL) { /* XXX couple into list to remove on context destruction */ scaled_font->surface_private = ctx; scaled_font->surface_backend = &_cairo_gl_surface_backend; } /* Create our VBO so that we can accumulate a bunch of glyph primitives * into one giant DrawArrays. */ memset(&setup, 0, sizeof(setup)); setup.composite = &composite_setup; setup.clip = clip_region; setup.dst = dst; setup.vertex_size = 4; if (composite_setup.src.type == OPERAND_TEXTURE) setup.vertex_size += 2; setup.vbo_size = num_glyphs * 4 * setup.vertex_size; if (setup.vbo_size > 4096) setup.vbo_size = 4096; glGenBuffersARB (1, &vbo); glBindBufferARB (GL_ARRAY_BUFFER_ARB, vbo); glVertexPointer (2, GL_FLOAT, setup.vertex_size * sizeof (GLfloat), (void *)(uintptr_t)(0)); glEnableClientState (GL_VERTEX_ARRAY); if (composite_setup.src.type == OPERAND_TEXTURE) { /* Note that we're packing texcoord 0 after texcoord 1, for * convenience. */ glClientActiveTexture (GL_TEXTURE0); glTexCoordPointer (2, GL_FLOAT, setup.vertex_size * sizeof (GLfloat), (void *)(uintptr_t)(4 * sizeof (GLfloat))); glEnableClientState (GL_TEXTURE_COORD_ARRAY); } glClientActiveTexture (GL_TEXTURE1); glTexCoordPointer (2, GL_FLOAT, setup.vertex_size * sizeof (GLfloat), (void *)(uintptr_t)(2 * sizeof (GLfloat))); glEnableClientState (GL_TEXTURE_COORD_ARRAY); for (i = 0; i < num_glyphs; i++) { cairo_scaled_glyph_t *scaled_glyph; double x_offset, y_offset; double x1, x2, y1, y2; status = _cairo_scaled_glyph_lookup (scaled_font, glyphs[i].index, CAIRO_SCALED_GLYPH_INFO_SURFACE, &scaled_glyph); if (unlikely (status)) goto FINISH; if (scaled_glyph->surface->width == 0 || scaled_glyph->surface->height == 0) { continue; } if (scaled_glyph->surface->width > GLYPH_CACHE_MAX_SIZE || scaled_glyph->surface->height > GLYPH_CACHE_MAX_SIZE) { status = CAIRO_INT_STATUS_UNSUPPORTED; goto FINISH; } if (scaled_glyph->surface->format != last_format) { /* Switching textures, so flush any queued prims. */ _cairo_gl_flush_glyphs (ctx, &setup); glActiveTexture (GL_TEXTURE1); cache = cairo_gl_context_get_glyph_cache (ctx, scaled_glyph->surface->format); glBindTexture (GL_TEXTURE_2D, cache->tex); last_format = scaled_glyph->surface->format; } if (scaled_glyph->surface_private == NULL) { status = _cairo_gl_glyph_cache_add_glyph (cache, scaled_glyph); if (unlikely (_cairo_status_is_error (status))) goto FINISH; if (status == CAIRO_INT_STATUS_UNSUPPORTED) { /* Cache is full, so flush existing prims and try again. */ _cairo_gl_flush_glyphs (ctx, &setup); _cairo_gl_glyph_cache_unlock (cache); } status = _cairo_gl_glyph_cache_add_glyph (cache, scaled_glyph); if (unlikely (status)) goto FINISH; } x_offset = scaled_glyph->surface->base.device_transform.x0; y_offset = scaled_glyph->surface->base.device_transform.y0; x1 = _cairo_lround (glyphs[i].x - x_offset); y1 = _cairo_lround (glyphs[i].y - y_offset); x2 = x1 + scaled_glyph->surface->width; y2 = y1 + scaled_glyph->surface->height; _cairo_gl_emit_glyph_rectangle (ctx, &setup, x1, y1, x2, y2, _cairo_gl_glyph_cache_lock (cache, scaled_glyph)); } status = CAIRO_STATUS_SUCCESS; FINISH: _cairo_gl_flush_glyphs (ctx, &setup); CLEANUP_FONT: _cairo_scaled_font_thaw_cache (scaled_font); glDisable (GL_BLEND); glDisable (GL_SCISSOR_TEST); glDisableClientState (GL_VERTEX_ARRAY); glClientActiveTexture (GL_TEXTURE0); glDisableClientState (GL_TEXTURE_COORD_ARRAY); glActiveTexture (GL_TEXTURE0); glDisable (GL_TEXTURE_2D); glClientActiveTexture (GL_TEXTURE1); glDisableClientState (GL_TEXTURE_COORD_ARRAY); glActiveTexture (GL_TEXTURE1); glDisable (GL_TEXTURE_2D); if (vbo != 0) { glBindBufferARB (GL_ARRAY_BUFFER_ARB, 0); glDeleteBuffersARB (1, &vbo); } _cairo_gl_context_release (ctx); _cairo_gl_operand_destroy (&composite_setup.src); *remaining_glyphs = num_glyphs - i; return status; }