Exemplo n.º 1
0
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);
}
Exemplo n.º 3
0
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);
}
Exemplo n.º 4
0
//--------------------------------------------------------------------
// 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;
}
Exemplo n.º 5
0
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;
			}
		}
	}
}
Exemplo n.º 6
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();
}
Exemplo n.º 7
0
// 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);
}
Exemplo n.º 8
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);
	}
}
Exemplo n.º 9
0
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;
}
Exemplo n.º 10
0
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();
}
Exemplo n.º 11
0
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;
}
Exemplo n.º 12
0
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 );
}
Exemplo n.º 13
0
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;
}
Exemplo n.º 14
0
/*
=================
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;
}
Exemplo n.º 16
0
Arquivo: map.cpp Projeto: psde/GBH
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();



}
Exemplo n.º 17
0
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;
}
Exemplo n.º 18
0
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);
}
Exemplo n.º 20
0
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);
    }
}
Exemplo n.º 22
0
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);
}
Exemplo n.º 23
0
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;
            }
        }
    }
}
Exemplo n.º 24
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
}
Exemplo n.º 25
0
/*
 *  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); 
}
Exemplo n.º 26
0
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;
}
Exemplo n.º 28
0
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
}
Exemplo n.º 29
0
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;
}