Example #1
0
GL::Boolean GL::isEnabled(Enum cap)
{
	Boolean flag = glIsEnabled(cap);
	CHECK_GL_ERROR1(glIsEnabled, cap);
	return flag;
}
Example #2
0
void Set_Light()
{
   glLoadIdentity();

   switch (Current_Material)
   {
      case 0:
      {
         GLfloat light[] = { 1.0, 1.0, 1.0, 0.0 };
         glLightfv(GL_LIGHT0, GL_POSITION, light);

         GLfloat ambvals[]  = { 0.1f, 0.1f, 0.1f, 1.0f };
         GLfloat diffvals[] = { 0.9f, 0.9f, 0.9f, 1.0f };
         GLfloat specvals[] = { 0.8f, 0.8f, 0.8f, 1.0f };
         glLightfv(GL_LIGHT0, GL_AMBIENT, ambvals);
         glLightfv(GL_LIGHT0, GL_DIFFUSE, diffvals);
         glLightfv(GL_LIGHT0, GL_SPECULAR, specvals);
         GLfloat lmodel_ambient[] = { 0.2, 0.2, 0.2, 1.0 };
         glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
         glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);

         if (glIsEnabled (GL_LIGHT1))
         {
            glDisable(GL_LIGHT1);
         }
         if (glIsEnabled (GL_LIGHT2))
         {
            glDisable(GL_LIGHT2);
         }
      }
      break;

      case 1:
      {
         GLfloat light[] = { 0.5, 0.5, 1.0, 0.0 };
         glLightfv(GL_LIGHT0, GL_POSITION, light);

         GLfloat ambvals[]  = { 0.0f, 0.0f, 0.0f, 1.0f };
         GLfloat diffvals[] = { 0.5f, 0.5f, 0.5f, 1.0f };
         GLfloat specvals[] = { 1.0f, 1.0f, 1.0f, 1.0f };
         glLightfv(GL_LIGHT0, GL_AMBIENT, ambvals);
         glLightfv(GL_LIGHT0, GL_DIFFUSE, diffvals);
         glLightfv(GL_LIGHT0, GL_SPECULAR, specvals);
         GLfloat lmodel_ambient[] = { 0.5, 0.5, 0.5, 1.0 };
         glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
         glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);

         if (glIsEnabled (GL_LIGHT1))
         {
            glDisable(GL_LIGHT1);
         }
         if (glIsEnabled (GL_LIGHT2))
         {
            glDisable(GL_LIGHT2);
         }
      }
      break;

      case 2:
      {
         GLfloat light[] = { 0.0, 0.0, 1.0, 0.0 };
         glLightfv(GL_LIGHT0, GL_POSITION, light);

         GLfloat ambvals[]  = { 0.0f, 0.0f, 0.0f, 1.0f };
         GLfloat diffvals[] = { 0.5f, 0.5f, 0.5f, 1.0f };
         GLfloat specvals[] = { 0.0f, 0.0f, 0.0f, 1.0f };
         glLightfv(GL_LIGHT0, GL_AMBIENT, ambvals);
         glLightfv(GL_LIGHT0, GL_DIFFUSE, diffvals);
         glLightfv(GL_LIGHT0, GL_SPECULAR, specvals);
         GLfloat lmodel_ambient[] = { 0.5, 0.5, 0.5, 1.0 };
         glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
         glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);

         if (glIsEnabled (GL_LIGHT1))
         {
            glDisable(GL_LIGHT1);
         }
         if (glIsEnabled (GL_LIGHT2))
         {
            glDisable(GL_LIGHT2);
         }
      }
      break;

      case 3:
      {
         GLfloat light[] = { 0.0, 0.0, 1.0, 0.0 };
         glLightfv(GL_LIGHT0, GL_POSITION, light);

         GLfloat ambvals[]  = { 0.0f, 0.0f, 0.0f, 1.0f };
         GLfloat diffvals[] = { 0.7f, 0.7f, 0.7f, 1.0f };
         GLfloat specvals[] = { 0.6f, 0.6f, 0.6f, 1.0f };
         glLightfv(GL_LIGHT0, GL_AMBIENT, ambvals);
         glLightfv(GL_LIGHT0, GL_DIFFUSE, diffvals);
         glLightfv(GL_LIGHT0, GL_SPECULAR, specvals);
         GLfloat lmodel_ambient[] = { 0.5, 0.5, 0.5, 1.0 };
         glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
         glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);

         if (glIsEnabled (GL_LIGHT1))
         {
            glDisable(GL_LIGHT1);
         }
         if (glIsEnabled (GL_LIGHT2))
         {
            glDisable(GL_LIGHT2);
         }
      }
      break;

      case 4:
      {
         GLfloat light[] = { 1.0, 0.0, 1.0, 0.0 };
         glLightfv(GL_LIGHT0, GL_POSITION, light);
         GLfloat light1[] = { 1.0, 1.0, 1.0, 0.0 };
         glLightfv(GL_LIGHT1, GL_POSITION, light1);
         GLfloat light2[] = { 0.0, 1.0, 1.0, 0.0 };
         glLightfv(GL_LIGHT2, GL_POSITION, light2);

         GLfloat specvals[] = { 0.3f, 0.3f, 0.3f, 1.0f };

         GLfloat diffvals[] = { 0.4f, 0.0f, 0.0f, 0.0f };
         glLightfv(GL_LIGHT0, GL_DIFFUSE, diffvals);
         glLightfv(GL_LIGHT0, GL_SPECULAR, specvals);

         GLfloat diffvals1[] = { 0.0f, 0.4f, 0.0f, 0.0f };
         glLightfv(GL_LIGHT1, GL_DIFFUSE, diffvals1);
         glLightfv(GL_LIGHT1, GL_SPECULAR, specvals);

         GLfloat diffvals2[] = { 0.0f, 0.0f, 0.4f, 0.0f };
         glLightfv(GL_LIGHT2, GL_DIFFUSE, diffvals2);
         glLightfv(GL_LIGHT2, GL_SPECULAR, specvals);

         glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);

         glEnable(GL_LIGHT0);
         glEnable(GL_LIGHT1);
         glEnable(GL_LIGHT2);
      }
      break;

   }

   // Enable textures with specular color
   glLightModeli (GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
}
Example #3
0
/**
 * @brief Dumps OpenGL state for debugging - typically every capability set with glEnable().
 */
void R_DumpOpenGlState (void)
{
#define CAPABILITY( X ) {GL_ ## X, # X}
	/* List taken from here: http://www.khronos.org/opengles/sdk/1.1/docs/man/glIsEnabled.xml */
	const struct { GLenum idx; const char * text; } openGLCaps[] = {
		CAPABILITY(ALPHA_TEST),
		CAPABILITY(BLEND),
		CAPABILITY(COLOR_ARRAY),
		CAPABILITY(COLOR_LOGIC_OP),
		CAPABILITY(COLOR_MATERIAL),
		CAPABILITY(CULL_FACE),
		CAPABILITY(DEPTH_TEST),
		CAPABILITY(DITHER),
		CAPABILITY(FOG),
		CAPABILITY(LIGHTING),
		CAPABILITY(LINE_SMOOTH),
		CAPABILITY(MULTISAMPLE),
		CAPABILITY(NORMAL_ARRAY),
		CAPABILITY(NORMALIZE),
		CAPABILITY(POINT_SMOOTH),
		CAPABILITY(POLYGON_OFFSET_FILL),
		CAPABILITY(RESCALE_NORMAL),
		CAPABILITY(SAMPLE_ALPHA_TO_COVERAGE),
		CAPABILITY(SAMPLE_ALPHA_TO_ONE),
		CAPABILITY(SAMPLE_COVERAGE),
		CAPABILITY(SCISSOR_TEST),
		CAPABILITY(STENCIL_TEST),
		CAPABILITY(VERTEX_ARRAY)
	};
#undef CAPABILITY

	char s[1024] = "";
	GLint i;
	GLint maxTexUnits = 0;
	GLint activeTexUnit = 0;
	GLint activeClientTexUnit = 0;
	GLint activeTexId = 0;
	GLfloat texEnvMode = 0;
	const char * texEnvModeStr = "UNKNOWN";
	GLfloat color[4];

	for (i = 0; i < sizeof(openGLCaps)/sizeof(openGLCaps[0]); i++) {
		if (glIsEnabled(openGLCaps[i].idx)) {
			Q_strcat(s, sizeof(s), openGLCaps[i].text);
			Q_strcat(s, sizeof(s), " ");
		}
	}
	glGetFloatv(GL_CURRENT_COLOR, color);

	Com_Printf("OpenGL enabled caps: %s color %f %f %f %f \n", s, color[0], color[1], color[2], color[3]);

	glGetIntegerv(GL_ACTIVE_TEXTURE, &activeTexUnit);
	glGetIntegerv(GL_CLIENT_ACTIVE_TEXTURE, &activeClientTexUnit);

	glGetIntegerv(GL_MAX_TEXTURE_UNITS, &maxTexUnits);
	for (i = GL_TEXTURE0; i < GL_TEXTURE0 + maxTexUnits; i++) {
		glActiveTexture(i);
		glClientActiveTexture(i);

		strcpy(s, "");
		if (glIsEnabled (GL_TEXTURE_2D))
			strcat(s, "enabled, ");
		if (glIsEnabled (GL_TEXTURE_COORD_ARRAY))
			strcat(s, "with texcoord array, ");
		if (i == activeTexUnit)
			strcat(s, "active, ");
		if (i == activeClientTexUnit)
			strcat(s, "client active, ");

		glGetIntegerv(GL_TEXTURE_BINDING_2D, &activeTexId);
		glGetTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, &texEnvMode);
		if (fabs(texEnvMode - GL_ADD) < 0.1f)
			texEnvModeStr = "ADD";
		if (fabs(texEnvMode - GL_MODULATE) < 0.1f)
			texEnvModeStr = "MODULATE";
		if (fabs(texEnvMode - GL_DECAL) < 0.1f)
			texEnvModeStr = "DECAL";
		if (fabs(texEnvMode - GL_BLEND) < 0.1f)
			texEnvModeStr = "BLEND";
		if (fabs(texEnvMode - GL_REPLACE) < 0.1f)
			texEnvModeStr = "REPLACE";
		if (fabs(texEnvMode - GL_COMBINE) < 0.1f)
			texEnvModeStr = "COMBINE";

		Com_Printf("Texunit: %d texID %d %s texEnv mode %s\n", i - GL_TEXTURE0, activeTexId, s, texEnvModeStr);
	}

	glActiveTexture(activeTexUnit);
	glClientActiveTexture(activeClientTexUnit);
}
Example #4
0
bool CCEGLViewProtocol::isScissorEnabled()
{
	return (GL_FALSE == glIsEnabled(GL_SCISSOR_TEST)) ? false : true;
}
Example #5
0
void Draw_SV_Hitboxes(void)
{
	if(!draw_sv_hitboxes_enable->value) return;

	GLint activeTextureARB = GL_TEXTURE0_ARB;
	GLboolean arbActive;
	if(g_Has_GL_ARB_multitexture)
	{
		glGetIntegerv(GL_ACTIVE_TEXTURE_ARB, &activeTextureARB);
	}
	if(GL_TEXTURE1_ARB == activeTextureARB)
	{
		arbActive = glIsEnabled(GL_TEXTURE_2D);
		glDisable(GL_TEXTURE_2D);
		glActiveTextureARB(GL_TEXTURE0_ARB);
	}

	GLfloat lineWidth;
	GLboolean depth = glIsEnabled(GL_DEPTH_TEST);
	GLboolean text = glIsEnabled(GL_TEXTURE_2D);
	glGetFloatv(GL_LINE_WIDTH, &lineWidth);

	glEnable(GL_DEPTH_TEST);
	glDisable(GL_TEXTURE_2D);


	glLineWidth(draw_sv_hitboxes_width->value);

	for(std::map<int, temp_edictboxes_t>::iterator it = tempEdicts.begin(); it != tempEdicts.end(); it++)
	{
		if(draw_sv_hitboxes_ignore1->value && 1 == it->first) {
			continue;
		}

		double red, green, blue;
		temp_edictboxes_t & tempEdict = it->second;

		if(tempEdict.isFresh)
		{
			red = hitboxesColorU[0];
			green = hitboxesColorU[1];
			blue = hitboxesColorU[2];
		}
		else
		{
			red = hitboxesColor[0];
			green = hitboxesColor[1];
			blue = hitboxesColor[2];
		}

		tempEdict.isFresh = false;

		for(std::list<temp_box_t>::iterator it2 = tempEdict.tempBoxes.begin(); it2 != tempEdict.tempBoxes.end(); it2++)
		{
			DrawBox(*it2, red, green, blue);
		}

	}

	glLineWidth(lineWidth);

	if(text) glEnable(GL_TEXTURE_2D);
	if(!depth) glDisable(GL_DEPTH_TEST);

	if(GL_TEXTURE1_ARB == activeTextureARB)
	{
		glActiveTextureARB(GL_TEXTURE1_ARB);
		if(arbActive) glEnable(GL_TEXTURE_2D);
	}
}
Example #6
0
void mesh3DS::draw(int textureID, bool pregenetateList){
		
	if (m_specialTransform){
		++m_specialTransformTick;
	}
	assert(getNumFaces()!=0);
	if (!pregenetateList && !m_specialTransform)
		glCallList(glutGetWindow()==1?getListLeft():getListRight());  // uruchomienie rysowania ze swap'a
	else 
		//currentMaterial.setList(glGenLists(1));// wygenerowanie miejsca dla jednej listy i zwr�cenie do niej uchwytu - mozliwe jest generowanie szeregu list, pod kolejnymi (+1) wartosciami uchwytow, wtedy metoda zwraca uchwyt do pierwszej z nich
		for (int window=1;window < (m_parentModel->getStereo()?3:2);window++){
			if (m_parentModel->getStereo()) glutSetWindow(window);
			if (!m_specialTransform) {
				if (window==1)setListLeft(glGenLists(1)); else setListRight(glGenLists(1));
				glNewList(window==1?getListLeft():getListRight(),GL_COMPILE); //definicja zawarto�ci listy("cube")
			}
			int face, numFaces, vertexIndex, texcoordIndex;
			GLuint materialFaces; //GL_FRONT or GL_FRONT_AND_BACK

			std::map<std::string, std::vector<ushort> >::iterator materialsIter;
			for(materialsIter=m_materialFaces.begin(); materialsIter!=m_materialFaces.end(); ++materialsIter){
				const material3DS& currentMaterial = m_parentModel->getMaterial(materialsIter->first);

				// Bind texture map (if any)
				bool hasTextureMap = currentMaterial.hasTextureMap();
				if (textureID) glBindTexture(GL_TEXTURE_2D, textureID);
				else if(hasTextureMap) glBindTexture(GL_TEXTURE_2D, currentMaterial.getTextureMapId());
				else glBindTexture(GL_TEXTURE_2D, 0);

				const GLfloat *specular = currentMaterial.getSpecularColor();
				float shininess = currentMaterial.getShininess();
				float adjustedSpecular[4] = {specular[0]*shininess, specular[1]*shininess, specular[2]*shininess, 1};

				glPushAttrib(GL_LIGHTING_BIT);
				if(currentMaterial.isTwoSided()){
					glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,1);
					materialFaces = GL_FRONT_AND_BACK;
				}
				else{
					glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,0);
					materialFaces = GL_FRONT;
				}
				
				// Apply material colors
				if(glIsEnabled(GL_LIGHTING)){
					 GLfloat matOne[4]={1,1,1,1};
					 GLfloat matLow[4]={0.20,0.20,0.20,0.20};
					 GLfloat matDiffuse[4]; // tworzenie diffuseColor z parametrem alfa pochodzacym z opacity
					 memcpy(matDiffuse,currentMaterial.getDiffuseColor(),sizeof(float)*3);
					 matDiffuse[3] = 1 - currentMaterial.getOpacity();
					if(hasTextureMap){ //replace only color with texture, but keep lighting contribution
						glMaterialfv(materialFaces, GL_DIFFUSE, matOne); 
					}
					else glMaterialfv(materialFaces, GL_DIFFUSE, matDiffuse);
					glMaterialfv(materialFaces, GL_AMBIENT, matLow);
					glMaterialfv(materialFaces, GL_SPECULAR, matLow);
					glMaterialf(materialFaces, GL_SHININESS, 2.0f);
				}
				else glColor3fv(currentMaterial.getDiffuseColor());
			
				if (currentMaterial.getOpacity() < 1){
					glEnable(GL_BLEND);
					glDepthMask(GL_FALSE);
					glBlendFunc(GL_SRC_COLOR, GL_ONE_MINUS_SRC_ALPHA);
					//glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA);
				}

				std::vector<ushort> *currentMatFaces = &(materialsIter->second);
				numFaces = (int)currentMatFaces->size(); //number of faces in this material

				switch(m_drawMode){
					case DRAW_IMMEDIATE_MODE:

						glBegin(GL_TRIANGLES);
						for(face=0; face<numFaces; face+=3){
							if(hasTextureMap){
								texcoordIndex = (*currentMatFaces)[face]*2;
								glTexCoord2f(m_texcoords[texcoordIndex], m_texcoords[texcoordIndex+1]);
							}
							vertexIndex = (*currentMatFaces)[face]*3;
							glNormal3f(m_normals[vertexIndex], m_normals[vertexIndex+1], m_normals[vertexIndex+2]);
							glVertex3f(m_vertices[vertexIndex]+calculateSpecialTransformX(vertexIndex), m_vertices[vertexIndex+1]+calculateSpecialTransformY(vertexIndex), m_vertices[vertexIndex+2]+calculateSpecialTransformZ(vertexIndex));
							if(hasTextureMap){
								texcoordIndex = (*currentMatFaces)[face+1]*2;
								glTexCoord2f(m_texcoords[texcoordIndex], m_texcoords[texcoordIndex+1]);
							}
							vertexIndex = (*currentMatFaces)[face+1]*3;
							glNormal3f(m_normals[vertexIndex], m_normals[vertexIndex+1], m_normals[vertexIndex+2]);
							glVertex3f(m_vertices[vertexIndex]+calculateSpecialTransformX(vertexIndex), m_vertices[vertexIndex+1]+calculateSpecialTransformY(vertexIndex), m_vertices[vertexIndex+2]+calculateSpecialTransformZ(vertexIndex));
							if(hasTextureMap){
								texcoordIndex = (*currentMatFaces)[face+2]*2;
								glTexCoord2f(m_texcoords[texcoordIndex], m_texcoords[texcoordIndex+1]);
							}
							vertexIndex = (*currentMatFaces)[face+2]*3;
							glNormal3f(m_normals[vertexIndex], m_normals[vertexIndex+1], m_normals[vertexIndex+2]);
							glVertex3f(m_vertices[vertexIndex]+calculateSpecialTransformX(vertexIndex), m_vertices[vertexIndex+1]+calculateSpecialTransformY(vertexIndex), m_vertices[vertexIndex+2]+calculateSpecialTransformZ(vertexIndex));

						}
						glEnd();

						break;
					
					case DRAW_VERTEX_ARRAY:
						
						glEnableClientState( GL_VERTEX_ARRAY );
						glEnableClientState( GL_NORMAL_ARRAY );
						
						if(hasTextureMap){
							glTexCoordPointer( 2, GL_FLOAT, 0, &m_texcoords[0] );
							glEnableClientState( GL_TEXTURE_COORD_ARRAY );
						}

						glVertexPointer( 3, GL_FLOAT, 0, &m_vertices[0] );
						glNormalPointer(GL_FLOAT, 0, &m_normals[0] );
						glDrawElements(GL_TRIANGLES, numFaces, GL_UNSIGNED_SHORT, &(materialsIter->second[0]));

						glDisableClientState( GL_VERTEX_ARRAY );
						glDisableClientState( GL_NORMAL_ARRAY );
						if(hasTextureMap){
							glDisableClientState( GL_TEXTURE_COORD_ARRAY );
						}

						break;

					case DRAW_VBO:

						break;
					
					default:
						std::cout<<"[3DS] ERROR: Invalid mesh draw mode specified"<<std::endl;
						break;
				} // switch
				if (currentMaterial.getOpacity() <1){
					glDepthMask(GL_TRUE);
					glDisable(GL_BLEND);
				}
				glPopAttrib(); // GL_LIGHTING_BIT
			}
			if (!m_specialTransform) glEndList(); //koniec definicji zawarto�ci listy
		}//for po window
}
Example #7
0
void drawSkybox(float size)
{
	bool b1=glIsEnabled(GL_TEXTURE_2D);	//new, we left the textures turned on, if it was turned on
	glDisable(GL_LIGHTING);	//turn off lighting, when making the skybox
	//glDisable(GL_DEPTH_TEST);	//turn off depth texting
	glEnable(GL_TEXTURE_2D);	//and turn on texturing
	glBindTexture(GL_TEXTURE_2D,skybox[SKY_BACK]);	//use the texture we want
	glColor3f(1.0,1.0,1.0);
	glBegin(GL_QUADS);	//and draw a face
		//back face
		glTexCoord2f(0,0);	//use the correct texture vector3d
		glVertex3f(size/2,size/2,size/2);	//and a vertex
		glTexCoord2f(1,0);	//and repeat it...
		glVertex3f(-size/2,size/2,size/2);
		glTexCoord2f(1,1);
		glVertex3f(-size/2,-size/2,size/2);
		glTexCoord2f(0,1);
		glVertex3f(size/2,-size/2,size/2);
	glEnd();
	glBindTexture(GL_TEXTURE_2D,skybox[SKY_LEFT]);
	glBegin(GL_QUADS);	
		//left face
		glTexCoord2f(0,0);
		glVertex3f(-size/2,size/2,size/2);
		glTexCoord2f(1,0);
		glVertex3f(-size/2,size/2,-size/2);
		glTexCoord2f(1,1);
		glVertex3f(-size/2,-size/2,-size/2);
		glTexCoord2f(0,1);
		glVertex3f(-size/2,-size/2,size/2);
	glEnd();
	glBindTexture(GL_TEXTURE_2D,skybox[SKY_FRONT]);
	glBegin(GL_QUADS);	
		//front face
		glTexCoord2f(1,0);
		glVertex3f(size/2,size/2,-size/2);
		glTexCoord2f(0,0);
		glVertex3f(-size/2,size/2,-size/2);
		glTexCoord2f(0,1);
		glVertex3f(-size/2,-size/2,-size/2);
		glTexCoord2f(1,1);
		glVertex3f(size/2,-size/2,-size/2);
	glEnd();
	glBindTexture(GL_TEXTURE_2D,skybox[SKY_RIGHT]);	
	glBegin(GL_QUADS);	
		//right face
		glTexCoord2f(0,0);
		glVertex3f(size/2,size/2,-size/2);
		glTexCoord2f(1,0);
		glVertex3f(size/2,size/2,size/2);
		glTexCoord2f(1,1);
		glVertex3f(size/2,-size/2,size/2);
		glTexCoord2f(0,1);
		glVertex3f(size/2,-size/2,-size/2);
	glEnd();
	glBindTexture(GL_TEXTURE_2D,skybox[SKY_TOP]);		
	glBegin(GL_QUADS);			//top face
		glTexCoord2f(1,0);
		glVertex3f(size/2,size/2,size/2);
		glTexCoord2f(0,0);
		glVertex3f(-size/2,size/2,size/2);
		glTexCoord2f(0,1);
		glVertex3f(-size/2,size/2,-size/2);
		glTexCoord2f(1,1);
		glVertex3f(size/2,size/2,-size/2);
	glEnd();
	glBindTexture(GL_TEXTURE_2D,skybox[SKY_BOTTOM]);		
	glBegin(GL_QUADS);	
		//bottom face
		glTexCoord2f(1,1);
		glVertex3f(size/2,-size/2,size/2);
		glTexCoord2f(0,1);
		glVertex3f(-size/2,-size/2,size/2);
		glTexCoord2f(0,0);
		glVertex3f(-size/2,-size/2,-size/2);
		glTexCoord2f(1,0);
		glVertex3f(size/2,-size/2,-size/2);
	glEnd();
	//glEnable(GL_LIGHTING);	//turn everything back, which we turned on, and turn everything off, which we have turned on.
	//glEnable(GL_DEPTH_TEST);
	if(!b1)
		glDisable(GL_TEXTURE_2D);
}
void drawConstraint(TransInfo *t)
{
	TransCon *tc = &(t->con);

	if (!ELEM(t->spacetype, SPACE_VIEW3D, SPACE_IMAGE))
		return;
	if (!(tc->mode & CON_APPLY))
		return;
	if (t->flag & T_USES_MANIPULATOR)
		return;
	if (t->flag & T_NO_CONSTRAINT)
		return;

	/* nasty exception for Z constraint in camera view */
	// TRANSFORM_FIX_ME
//	if((t->flag & T_OBJECT) && G.vd->camera==OBACT && G.vd->persp==V3D_CAMOB)
//		return;

	if (tc->drawExtra) {
		tc->drawExtra(t);
	}
	else {
		if (tc->mode & CON_SELECT) {
			float vec[3];
			char col2[3] = {255,255,255};
			int depth_test_enabled;

			convertViewVec(t, vec, (t->mval[0] - t->con.imval[0]), (t->mval[1] - t->con.imval[1]));
			add_v3_v3(vec, tc->center);

			drawLine(t, tc->center, tc->mtx[0], 'X', 0);
			drawLine(t, tc->center, tc->mtx[1], 'Y', 0);
			drawLine(t, tc->center, tc->mtx[2], 'Z', 0);

			glColor3ubv((GLubyte *)col2);

			depth_test_enabled = glIsEnabled(GL_DEPTH_TEST);
			if(depth_test_enabled)
				glDisable(GL_DEPTH_TEST);

			setlinestyle(1);
			glBegin(GL_LINE_STRIP);
				glVertex3fv(tc->center);
				glVertex3fv(vec);
			glEnd();
			setlinestyle(0);

			if(depth_test_enabled)
				glEnable(GL_DEPTH_TEST);
		}

		if (tc->mode & CON_AXIS0) {
			drawLine(t, tc->center, tc->mtx[0], 'X', DRAWLIGHT);
		}
		if (tc->mode & CON_AXIS1) {
			drawLine(t, tc->center, tc->mtx[1], 'Y', DRAWLIGHT);
		}
		if (tc->mode & CON_AXIS2) {
			drawLine(t, tc->center, tc->mtx[2], 'Z', DRAWLIGHT);
		}
	}
}
void LHBezierNode::draw(void)
{
    
    float scale = CCDirector::sharedDirector()->getContentScaleFactor();
    
	if(0.0f != LHSettings::sharedInstance()->customAlpha())
	{
		glColor4f(color.origin.x, 
				  color.origin.y, 
				  color.size.width, 
				  color.size.height*LHSettings::sharedInstance()->customAlpha());
		glPushMatrix();
		
        glDisableClientState(GL_COLOR_ARRAY);
        
        if(NULL != texture)
        {
            glEnable(GL_TEXTURE_2D);		            
            glBindTexture(GL_TEXTURE_2D, texture->getName());
		
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
            
            int size = (int)trianglesHolder.size();
            CCPoint* verts = new CCPoint[size* 3];
            CCPoint* texcoords = new CCPoint[size* 3];
            
            for(int k = 0; k < (int)trianglesHolder.size();++k)
            {
                std::vector<CCPoint> fix = trianglesHolder[k];
                
                for(int j = 0; j < 3; ++j)
                {
                    CCPoint pt = fix[j];
                
                    pt.x *= scale;
                    pt.y *= scale;
                    
                    verts[k*3 + j] = pt;
                    texcoords[k*3 + j].x = pt.x/imageSize.width;
                    texcoords[k*3 + j].y = (winSize.height - pt.y)/imageSize.height;
                }
            }
                                
            glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
            glVertexPointer(2, GL_FLOAT, 0, verts);
            glDrawArrays(GL_TRIANGLES, 0, 3*size);
            
            bool wasBlend = glIsEnabled(GL_BLEND);
            glEnable(GL_BLEND);            
            int oldBlendDST = 0;
            glGetIntegerv(GL_BLEND_DST, &oldBlendDST);
            int oldBlendSRC = 0;
            glGetIntegerv(GL_BLEND_SRC, &oldBlendSRC);

            for(int i = 0; i < blendingTextures.size(); ++i)
            {
                CCTexture2D* tex = blendingTextures[i].texture;
                if(NULL != tex)
                {
                    glBlendFunc(blendingTextures[i].blendSource, blendingTextures[i].blendDestination);
                    glBindTexture(GL_TEXTURE_2D, tex->getName());
                    
                    if(blendingTextures[i].tile){
                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
                    }

                    glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
                    glVertexPointer(2, GL_FLOAT, 0, verts);
                    glDrawArrays(GL_TRIANGLES, 0, 3*size);                
                }
            }
            
            glBlendFunc(oldBlendSRC, oldBlendDST);
            if(!wasBlend)
                glDisable(GL_BLEND);
            
            delete [] verts;
            delete [] texcoords;
		}
        
		float oldLineWidth = 1.0f;
		glGetFloatv(GL_LINE_WIDTH, &oldLineWidth); 
		
		glLineWidth(lineWidth);
		
		glDisable(GL_TEXTURE_2D);
        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
		glColor4f(lineColor.origin.x, 
				  lineColor.origin.y, 
				  lineColor.size.width, 
				  lineColor.size.height*LHSettings::sharedInstance()->customAlpha());
		
        CCPoint* line_verts = new CCPoint[linesHolder.size()];
        for(int i = 0; i < (int)linesHolder.size(); i+=2)
		{
			CCPoint pt1 = linesHolder[i];
			CCPoint pt2 = linesHolder[i+1];
            line_verts[i] = pt1;
            line_verts[i+1] = pt2;            
		}
        
        glVertexPointer(2, GL_FLOAT, 0, line_verts);
        glDrawArrays(GL_LINES, 0, linesHolder.size());
        delete[] line_verts;
        
        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
        glEnableClientState(GL_COLOR_ARRAY);
		glLineWidth(oldLineWidth);
		glEnable(GL_TEXTURE_2D);	
		glPopMatrix();
	}	
}
Example #10
0
void
ParticleSystem::drawParticles(const GLMatrix &transform)
{
    int i, j, k, l;

    /* Check that the cache is big enough */
    if (vertices_cache.size () < particles.size () * VERTEX_COMPONENTS)
	vertices_cache.resize (particles.size () * VERTEX_COMPONENTS);

    if (coords_cache.size () < particles.size () * COORD_COMPONENTS)
	coords_cache.resize (particles.size () * COORD_COMPONENTS);

    if (colors_cache.size () < particles.size () * COLOR_COMPONENTS)
	colors_cache.resize (particles.size () * COLOR_COMPONENTS);

    if (darken > 0)
	if (dcolors_cache.size () < particles.size () * COLOR_COMPONENTS)
	    dcolors_cache.resize (particles.size () * COLOR_COMPONENTS);

    GLboolean glBlendEnabled = glIsEnabled (GL_BLEND);

    if (!glBlendEnabled)
	glEnable (GL_BLEND);

    if (tex)
    {
	glBindTexture (GL_TEXTURE_2D, tex);
	glEnable (GL_TEXTURE_2D);
    }

    i = j = k = l = 0;

    GLfloat w, h;
    GLfloat xMinusW, xPlusW, yMinusH, yPlusH;
    GLushort r, g, b, a, dark_a;

    /* for each particle, use two triangles to display it */
    foreach (Particle &part, particles) 
    {
	if (part.life > 0.0f)
	{
	    w = part.width  / 2.0f;
	    h = part.height / 2.0f;

	    r = part.r * 65535.0f;
	    g = part.g * 65535.0f;
	    b = part.b * 65535.0f;
	    a      = part.life * part.a * 65535.0f;
	    dark_a = part.life * part.a * 65535.0f * darken;

	    w += w * part.w_mod * part.life;
	    h += h * part.h_mod * part.life;

	    xMinusW = part.x - w;
	    xPlusW  = part.x + w;

	    yMinusH = part.y - h;
	    yPlusH  = part.y + h;

	    //first triangle
	    vertices_cache[i + 0] = xMinusW;
	    vertices_cache[i + 1] = yMinusH;
	    vertices_cache[i + 2] = part.z;

	    vertices_cache[i + 3] = xMinusW;
	    vertices_cache[i + 4] = yPlusH;
	    vertices_cache[i + 5] = part.z;

	    vertices_cache[i + 6] = xPlusW;
	    vertices_cache[i + 7] = yPlusH;
	    vertices_cache[i + 8] = part.z;

	    //second triangle
	    vertices_cache[i + 9]  = xPlusW;
	    vertices_cache[i + 10] = yPlusH;
	    vertices_cache[i + 11] = part.z;

	    vertices_cache[i + 12] = xPlusW;
	    vertices_cache[i + 13] = yMinusH;
	    vertices_cache[i + 14] = part.z;

	    vertices_cache[i + 15] = xMinusW;
	    vertices_cache[i + 16] = yMinusH;
	    vertices_cache[i + 17] = part.z;

	    i += 18;

	    coords_cache[j + 0] = 0.0;
	    coords_cache[j + 1] = 0.0;

	    coords_cache[j + 2] = 0.0;
	    coords_cache[j + 3] = 1.0;

	    coords_cache[j + 4] = 1.0;
	    coords_cache[j + 5] = 1.0;

	    //second
	    coords_cache[j + 6] = 1.0;
	    coords_cache[j + 7] = 1.0;

	    coords_cache[j + 8] = 1.0;
	    coords_cache[j + 9] = 0.0;
	    
	    coords_cache[j + 10] = 0.0;
	    coords_cache[j + 11] = 0.0;

	    j += 12;

	    colors_cache[k + 0] = r;
	    colors_cache[k + 1] = g;
	    colors_cache[k + 2] = b;
	    colors_cache[k + 3] = a;

	    colors_cache[k + 4] = r;
	    colors_cache[k + 5] = g;
	    colors_cache[k + 6] = b;
	    colors_cache[k + 7] = a;

	    colors_cache[k + 8]  = r;
	    colors_cache[k + 9]  = g;
	    colors_cache[k + 10] = b;
	    colors_cache[k + 11] = a;

	    //second
	    colors_cache[k + 12] = r;
	    colors_cache[k + 13] = g;
	    colors_cache[k + 14] = b;
	    colors_cache[k + 15] = a;

	    colors_cache[k + 16] = r;
	    colors_cache[k + 17] = g;
	    colors_cache[k + 18] = b;
	    colors_cache[k + 19] = a;

	    colors_cache[k + 20] = r;
	    colors_cache[k + 21] = g;
	    colors_cache[k + 22] = b;
	    colors_cache[k + 23] = a;

	    k += 24;

	    if (darken > 0)
	    {
		dcolors_cache[l + 0] = r;
		dcolors_cache[l + 1] = g;
		dcolors_cache[l + 2] = b;
		dcolors_cache[l + 3] = dark_a;

		dcolors_cache[l + 4] = r;
		dcolors_cache[l + 5] = g;
		dcolors_cache[l + 6] = b;
		dcolors_cache[l + 7] = dark_a;

		dcolors_cache[l + 8]  = r;
		dcolors_cache[l + 9]  = g;
		dcolors_cache[l + 10] = b;
		dcolors_cache[l + 11] = dark_a;

		//second
		dcolors_cache[l + 12] = r;
		dcolors_cache[l + 13] = g;
		dcolors_cache[l + 14] = b;
		dcolors_cache[l + 15] = dark_a;

		dcolors_cache[l + 16] = r;
		dcolors_cache[l + 17] = g;
		dcolors_cache[l + 18] = b;
		dcolors_cache[l + 19] = dark_a;

		dcolors_cache[l + 20] = r;
		dcolors_cache[l + 21] = g;
		dcolors_cache[l + 22] = b;
		dcolors_cache[l + 23] = dark_a;

		l += 24;
	    }
	}
    }

    GLVertexBuffer *stream = GLVertexBuffer::streamingBuffer ();

    if (darken > 0)
    {
	glBlendFunc (GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
	stream->begin (GL_TRIANGLES);
	stream->addVertices (i / 3, &vertices_cache[0]);
	stream->addTexCoords (0, j / 2, &coords_cache[0]);
	stream->addColors (l / 4, &dcolors_cache[0]);

	if (stream->end ())
	    stream->render (transform);
    }

    /* draw particles */
    glBlendFunc (GL_SRC_ALPHA, blendMode);
    stream->begin (GL_TRIANGLES);

    stream->addVertices (i / 3, &vertices_cache[0]);
    stream->addTexCoords (0, j / 2, &coords_cache[0]);
    stream->addColors (k / 4, &colors_cache[0]);

    if (stream->end ())
	stream->render (transform);

    glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
    glDisable (GL_TEXTURE_2D);

    /* only disable blending if it was disabled before */
    if (!glBlendEnabled)
	glDisable (GL_BLEND);
}
Example #11
0
bool
FireScreen::glPaintOutput (const GLScreenPaintAttrib &attrib,
			   const GLMatrix            &transform,
			   const CompRegion          &region,
			   CompOutput                *output,
			   unsigned int              mask)
{
    bool status = gScreen->glPaintOutput (attrib, transform, region, output, mask);

    if ((!init && ps.active) || brightness < 1.0)
    {
	GLMatrix sTransform = transform;

	sTransform.toScreenSpace (output, -DEFAULT_Z_CAMERA);

	if (brightness < 1.0)
	{
	    /* cover the screen with a rectangle and darken it
	     * (coded as two GL_TRIANGLES for GLES compatibility)
	     */
	    GLfloat vertices[18];
	    GLushort colors[24];

	    vertices[0] = (GLfloat)output->region ()->extents.x1;
	    vertices[1] = (GLfloat)output->region ()->extents.y1;
	    vertices[2] = 0.0f;

	    vertices[3] = (GLfloat)output->region ()->extents.x1;
	    vertices[4] = (GLfloat)output->region ()->extents.y2;
	    vertices[5] = 0.0f;

	    vertices[6] = (GLfloat)output->region ()->extents.x2;
	    vertices[7] = (GLfloat)output->region ()->extents.y2;
	    vertices[8] = 0.0f;

	    vertices[9]  = (GLfloat)output->region ()->extents.x2;
	    vertices[10] = (GLfloat)output->region ()->extents.y2;
	    vertices[11] = 0.0f;

	    vertices[12] = (GLfloat)output->region ()->extents.x2;
	    vertices[13] = (GLfloat)output->region ()->extents.y1;
	    vertices[14] = 0.0f;

	    vertices[15] = (GLfloat)output->region ()->extents.x1;
	    vertices[16] = (GLfloat)output->region ()->extents.y1;
	    vertices[17] = 0.0f;

	    for (int i = 0; i <= 5; ++i)
	    {
		colors[i*4+0] = 0;
		colors[i*4+1] = 0;
		colors[i*4+2] = 0;
		colors[i*4+3] = (1.0 - brightness) * 65535.0f;
	    }

	    GLVertexBuffer *stream        = GLVertexBuffer::streamingBuffer ();
	    GLboolean      glBlendEnabled = glIsEnabled (GL_BLEND);

	    if (!glBlendEnabled)
		glEnable (GL_BLEND);

	    stream->begin (GL_TRIANGLES);
	    stream->addVertices (6, vertices);
	    stream->addColors (6, colors);

	    if (stream->end ())
		stream->render (sTransform);

	    /* only disable blending if it was already disabled */
	    if (!glBlendEnabled)
		glDisable (GL_BLEND);
	}

	if (!init && ps.active)
	    ps.drawParticles (sTransform);
    }

    return status;
}
Example #12
0
static int
create_texture(void)
{
	GLuint tex;
	float *ptr;

	/* Generate mipmap level 0 */
	tex = piglit_rgbw_texture(GL_RGBA, TEX_WIDTH, TEX_WIDTH, GL_FALSE,
				  GL_TRUE, GL_FLOAT);
	glBindTexture(GL_TEXTURE_2D, tex);

	if (!piglit_check_gl_error(GL_NO_ERROR))
		piglit_report_result(PIGLIT_FAIL);

	/* Go into appropriate transform feedback or discard state */
	if (discard)
		glEnable(GL_RASTERIZER_DISCARD);
	if (buffer || prims_written) {
		float buffer[4096];
		buffer[0] = 12345.0;
		glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, xfb_buf);
		glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, sizeof(buffer),
			     buffer, GL_STREAM_READ);
		glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, xfb_buf);
		glUseProgram(xfb_prog);
		glBeginTransformFeedback(GL_POINTS);
	}
	if (prims_written) {
		glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN,
			     prims_written_query);
	}
	if (prims_generated) {
		glBeginQuery(GL_PRIMITIVES_GENERATED, prims_generated_query);
	}

	/* Ask the implementation to generate the remaining mipmap levels. */
	glGenerateMipmapEXT(GL_TEXTURE_2D);
	if (!piglit_check_gl_error(0))
		piglit_report_result(PIGLIT_FAIL);

	/* Check state */
	if (discard) {
		if (!glIsEnabled(GL_RASTERIZER_DISCARD)) {
			printf("GL_RASTERIZER_DISCARD state not restored "
			       "after glGenerateMipmapEXT\n");
			piglit_report_result(PIGLIT_FAIL);
		}
		glDisable(GL_RASTERIZER_DISCARD);
	}
	if (buffer || prims_written) {
		glEndTransformFeedback();
		glUseProgram(0);
	}
	if (buffer) {
		ptr = glMapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT,
				  GL_READ_ONLY);
		if (ptr[0] != 12345.0) {
			printf("Transform feedback buffer was overwritten "
			       "during glGenerateMipmapEXT\n");
			piglit_report_result(PIGLIT_FAIL);
		}
	}
	if (prims_written) {
		GLuint result;
		glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
		glGetQueryObjectuiv(prims_written_query,
				    GL_QUERY_RESULT, &result);
		if (result != 0) {
			printf("PRIMITIVES_WRITTEN counter was incremented "
			       "during glGenerateMipmapEXT\n");
			piglit_report_result(PIGLIT_FAIL);
		}
	}
	if (prims_generated) {
		GLuint result;
		glEndQuery(GL_PRIMITIVES_GENERATED);
		glGetQueryObjectuiv(prims_generated_query,
				    GL_QUERY_RESULT, &result);
		if (result != 0) {
			printf("PRIMITIVES_GENERATED counter was incremented "
			       "during glGenerateMipmapEXT\n");
			piglit_report_result(PIGLIT_FAIL);
		}
	}

	return tex;
}
Example #13
0
/*!
 * \qmlmethod string GLStateDumpExt::getGLStateDump(stateDumpEnums options)
 * \return OpenGL driver state with given options as a human readable string that can be printed.
 * Optional paremeter \a options may contain bitfields masked together from following options:
 * \list
 * \li \c{GLStateDumpExt.DUMP_BASIC_ONLY} Includes only very basic OpenGL state information.
 * \li \c{GLStateDumpExt.DUMP_VERTEX_ATTRIB_ARRAYS_BIT} Includes all vertex attribute array
 * information.
 * \li \c{GLStateDumpExt.DUMP_VERTEX_ATTRIB_ARRAYS_BUFFERS_BIT} Includes size and type
 * from all currently active vertex attribute arrays (including the currently bound element array)
 * to verify that there are actual values in the array.
 * \li \c{GLStateDumpExt.DUMP_FULL} Includes everything.
 * \endlist
 */
QString CanvasGLStateDump::getGLStateDump(CanvasGLStateDump::stateDumpEnums options)
{
#if !defined(QT_OPENGL_ES_2)
    GLint drawFramebuffer;
    GLint readFramebuffer;
    GLboolean polygonOffsetLineEnabled;
    GLboolean polygonOffsetPointEnabled;
    GLint boundVertexArray;
#endif

    QString stateDumpStr;
    GLint renderbuffer;
    GLfloat clearColor[4];
    GLfloat clearDepth;
    GLboolean isBlendingEnabled = glIsEnabled(GL_BLEND);
    GLboolean isDepthTestEnabled = glIsEnabled(GL_DEPTH_TEST);
    GLint depthFunc;
    GLboolean isDepthWriteEnabled;
    GLint currentProgram;
    GLint *vertexAttribArrayEnabledStates = new GLint[m_maxVertexAttribs];
    GLint *vertexAttribArrayBoundBuffers = new GLint[m_maxVertexAttribs];
    GLint *vertexAttribArraySizes = new GLint[m_maxVertexAttribs];
    GLint *vertexAttribArrayTypes = new GLint[m_maxVertexAttribs];
    GLint *vertexAttribArrayNormalized = new GLint[m_maxVertexAttribs];
    GLint *vertexAttribArrayStrides = new GLint[m_maxVertexAttribs];
    GLint activeTexture;
    GLint texBinding2D;
    GLint arrayBufferBinding;
    GLint frontFace;
    GLboolean isCullFaceEnabled = glIsEnabled(GL_CULL_FACE);
    GLint cullFaceMode;
    GLint blendEquationRGB;
    GLint blendEquationAlpha;

    GLint blendDestAlpha;
    GLint blendDestRGB;
    GLint blendSrcAlpha;
    GLint blendSrcRGB;
    GLint scissorBox[4];
    GLboolean isScissorTestEnabled = glIsEnabled(GL_SCISSOR_TEST);
    GLint boundElementArrayBuffer;
    GLboolean polygonOffsetFillEnabled;
    GLfloat polygonOffsetFactor;
    GLfloat polygonOffsetUnits;

#if !defined(QT_OPENGL_ES_2)
    if (!m_isOpenGLES2) {
        glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &drawFramebuffer);
        glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &readFramebuffer);
        glGetBooleanv(GL_POLYGON_OFFSET_LINE, &polygonOffsetLineEnabled);
        glGetBooleanv(GL_POLYGON_OFFSET_POINT, &polygonOffsetPointEnabled);
        glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &boundVertexArray);
    }
#endif

    glGetBooleanv(GL_DEPTH_WRITEMASK, &isDepthWriteEnabled);
    glGetIntegerv(GL_RENDERBUFFER_BINDING, &renderbuffer);
    glGetFloatv(GL_COLOR_CLEAR_VALUE, clearColor);
    glGetFloatv(GL_DEPTH_CLEAR_VALUE, &clearDepth);
    glGetIntegerv(GL_DEPTH_FUNC, &depthFunc);
    glGetBooleanv(GL_POLYGON_OFFSET_FILL, &polygonOffsetFillEnabled);
    glGetFloatv(GL_POLYGON_OFFSET_FACTOR, &polygonOffsetFactor);
    glGetFloatv(GL_POLYGON_OFFSET_UNITS, &polygonOffsetUnits);

    glGetIntegerv(GL_CURRENT_PROGRAM, &currentProgram);
    glGetIntegerv(GL_ACTIVE_TEXTURE, &activeTexture);
    glGetIntegerv(GL_TEXTURE_BINDING_2D, &texBinding2D );
    glGetIntegerv(GL_FRONT_FACE, &frontFace);
    glGetIntegerv(GL_CULL_FACE_MODE, &cullFaceMode);
    glGetIntegerv(GL_BLEND_EQUATION_RGB, &blendEquationRGB);
    glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &blendEquationAlpha);
    glGetIntegerv(GL_BLEND_DST_ALPHA, &blendDestAlpha);
    glGetIntegerv(GL_BLEND_DST_RGB, &blendDestRGB);
    glGetIntegerv(GL_BLEND_SRC_ALPHA, &blendSrcAlpha);
    glGetIntegerv(GL_BLEND_SRC_RGB, &blendSrcRGB);
    glGetIntegerv(GL_SCISSOR_BOX, scissorBox);
    glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &boundElementArrayBuffer);
    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &arrayBufferBinding);

#if !defined(QT_OPENGL_ES_2)
    if (!m_isOpenGLES2) {
        stateDumpStr.append("GL_DRAW_FRAMEBUFFER_BINDING.....");
        stateDumpStr.append(QString::number(drawFramebuffer));
        stateDumpStr.append("\n");

        stateDumpStr.append("GL_READ_FRAMEBUFFER_BINDING.....");
        stateDumpStr.append(QString::number(readFramebuffer));
        stateDumpStr.append("\n");
    }
#endif

    stateDumpStr.append("GL_RENDERBUFFER_BINDING.........");
    stateDumpStr.append(QString::number(renderbuffer));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_SCISSOR_TEST.................");
    stateDumpStr.append(BOOL_TO_STR(isScissorTestEnabled));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_SCISSOR_BOX..................");
    stateDumpStr.append(QString::number(scissorBox[0]));
    stateDumpStr.append(", ");
    stateDumpStr.append(QString::number(scissorBox[1]));
    stateDumpStr.append(", ");
    stateDumpStr.append(QString::number(scissorBox[2]));
    stateDumpStr.append(", ");
    stateDumpStr.append(QString::number(scissorBox[3]));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_COLOR_CLEAR_VALUE............");
    stateDumpStr.append("r:");
    stateDumpStr.append(QString::number(clearColor[0]));
    stateDumpStr.append(" g:");
    stateDumpStr.append(QString::number(clearColor[1]));
    stateDumpStr.append(" b:");
    stateDumpStr.append(QString::number(clearColor[2]));
    stateDumpStr.append(" a:");
    stateDumpStr.append(QString::number(clearColor[3]));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_DEPTH_CLEAR_VALUE............");
    stateDumpStr.append(QString::number(clearDepth));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_BLEND........................");
    stateDumpStr.append(BOOL_TO_STR(isBlendingEnabled));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_BLEND_EQUATION_RGB...........");
    stateDumpStr.append(m_map->lookUp(blendEquationRGB));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_BLEND_EQUATION_ALPHA.........");
    stateDumpStr.append(m_map->lookUp(blendEquationAlpha));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_DEPTH_TEST...................");
    stateDumpStr.append(BOOL_TO_STR(isDepthTestEnabled));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_DEPTH_FUNC...................");
    stateDumpStr.append(m_map->lookUp(depthFunc));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_DEPTH_WRITEMASK..............");
    stateDumpStr.append(BOOL_TO_STR(isDepthWriteEnabled));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_POLYGON_OFFSET_FILL..........");
    stateDumpStr.append(BOOL_TO_STR(polygonOffsetFillEnabled));
    stateDumpStr.append("\n");

#if !defined(QT_OPENGL_ES_2)
    if (!m_isOpenGLES2) {
        stateDumpStr.append("GL_POLYGON_OFFSET_LINE..........");
        stateDumpStr.append(BOOL_TO_STR(polygonOffsetLineEnabled));
        stateDumpStr.append("\n");

        stateDumpStr.append("GL_POLYGON_OFFSET_POINT.........");
        stateDumpStr.append(BOOL_TO_STR(polygonOffsetPointEnabled));
        stateDumpStr.append("\n");
    }
#endif

    stateDumpStr.append("GL_POLYGON_OFFSET_FACTOR........");
    stateDumpStr.append(QString::number(polygonOffsetFactor));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_POLYGON_OFFSET_UNITS.........");
    stateDumpStr.append(QString::number(polygonOffsetUnits));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_CULL_FACE....................");
    stateDumpStr.append(BOOL_TO_STR(isCullFaceEnabled));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_CULL_FACE_MODE...............");
    stateDumpStr.append(m_map->lookUp(cullFaceMode));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_FRONT_FACE...................");
    stateDumpStr.append(m_map->lookUp(frontFace));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_CURRENT_PROGRAM..............");
    stateDumpStr.append(QString::number(currentProgram));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_ACTIVE_TEXTURE...............");
    stateDumpStr.append(m_map->lookUp(activeTexture));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_TEXTURE_BINDING_2D...........");
    stateDumpStr.append(QString::number(texBinding2D));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_ELEMENT_ARRAY_BUFFER_BINDING.");
    stateDumpStr.append(QString::number(boundElementArrayBuffer));
    stateDumpStr.append("\n");

    stateDumpStr.append("GL_ARRAY_BUFFER_BINDING.........");
    stateDumpStr.append(QString::number(arrayBufferBinding));
    stateDumpStr.append("\n");

#if !defined(QT_OPENGL_ES_2)
    if (!m_isOpenGLES2) {
        stateDumpStr.append("GL_VERTEX_ARRAY_BINDING.........");
        stateDumpStr.append(QString::number(boundVertexArray));
        stateDumpStr.append("\n");
    }
#endif

    if (options && DUMP_VERTEX_ATTRIB_ARRAYS_BIT) {
        for (int i = 0; i < m_maxVertexAttribs; i++) {
            glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &vertexAttribArrayEnabledStates[i]);
            glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &vertexAttribArrayBoundBuffers[i]);
            glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_SIZE, &vertexAttribArraySizes[i]);
            glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_TYPE, &vertexAttribArrayTypes[i]);
            glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, &vertexAttribArrayNormalized[i]);
            glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_STRIDE, &vertexAttribArrayStrides[i]);
        }


        for (int i = 0; i < m_maxVertexAttribs; i++) {
            stateDumpStr.append("GL_VERTEX_ATTRIB_ARRAY_");
            stateDumpStr.append(QString::number(i));
            stateDumpStr.append("\n");

            stateDumpStr.append("GL_VERTEX_ATTRIB_ARRAY_ENABLED.........");
            stateDumpStr.append(BOOL_TO_STR(vertexAttribArrayEnabledStates[i]));
            stateDumpStr.append("\n");

            stateDumpStr.append("GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING..");
            stateDumpStr.append(QString::number(vertexAttribArrayBoundBuffers[i]));
            stateDumpStr.append("\n");

            stateDumpStr.append("GL_VERTEX_ATTRIB_ARRAY_SIZE............");
            stateDumpStr.append(QString::number(vertexAttribArraySizes[i]));
            stateDumpStr.append("\n");

            stateDumpStr.append("GL_VERTEX_ATTRIB_ARRAY_TYPE............");
            stateDumpStr.append(m_map->lookUp(vertexAttribArrayTypes[i]));
            stateDumpStr.append("\n");

            stateDumpStr.append("GL_VERTEX_ATTRIB_ARRAY_NORMALIZED......");
            stateDumpStr.append(QString::number(vertexAttribArrayNormalized[i]));
            stateDumpStr.append("\n");

            stateDumpStr.append("GL_VERTEX_ATTRIB_ARRAY_STRIDE..........");
            stateDumpStr.append(QString::number(vertexAttribArrayStrides[i]));
            stateDumpStr.append("\n");
        }
    }

    if (options && DUMP_VERTEX_ATTRIB_ARRAYS_BUFFERS_BIT) {
        if (boundElementArrayBuffer != 0) {
            stateDumpStr.append("GL_ELEMENT_ARRAY_BUFFER................");
            stateDumpStr.append(QString::number(boundElementArrayBuffer));
            stateDumpStr.append("\n");

            stateDumpStr.append(getGLArrayObjectDump(GL_ELEMENT_ARRAY_BUFFER,
                                boundElementArrayBuffer,
                                GL_UNSIGNED_SHORT));
        }

        for (int i = 0; i < m_maxVertexAttribs; i++) {
            if (vertexAttribArrayEnabledStates[i]) {
                stateDumpStr.append("GL_ARRAY_BUFFER........................");
                stateDumpStr.append(QString::number(vertexAttribArrayBoundBuffers[i]));
                stateDumpStr.append("\n");

                stateDumpStr.append(getGLArrayObjectDump(GL_ARRAY_BUFFER,
                                    vertexAttribArrayBoundBuffers[i],
                                    vertexAttribArrayTypes[i]));
            }
        }
    }


    delete[] vertexAttribArrayEnabledStates;
    delete[] vertexAttribArrayBoundBuffers;
    delete[] vertexAttribArraySizes;
    delete[] vertexAttribArrayTypes;
    delete[] vertexAttribArrayNormalized;
    delete[] vertexAttribArrayStrides;

    return stateDumpStr;
}
Example #14
0
/*-----------------------------------------------------------------------------
    Name        : btgRender
    Description : renders the background.  assumes modelview already set
    Inputs      :
    Outputs     :
    Return      :
----------------------------------------------------------------------------*/
void btgRender()
{
    udword nStar;
    sdword lightOn, index;
    GLboolean texOn, blendOn, depthOn;
    udword* dlast;
    udword* dnext;
    static sdword lastFade = 255;

#if MR_KEYBOARD_CHEATS
    extern bool gMosaic;
#endif

    if (btgHead == NULL)
    {
#ifdef _WIN32
        btgLoad("BTG\\default.btg");
#else
        btgLoad("BTG/default.btg");
#endif
    }

#if MR_KEYBOARD_CHEATS
    glShadeModel(gMosaic ? GL_FLAT : GL_SMOOTH);
#else
    glShadeModel(GL_SMOOTH);
#endif
    glGetFloatv(GL_COLOR_CLEAR_VALUE, _bgColor);
    for (index = 0; index < 4; index++)
    {
        _bgByte[index] = (GLubyte)(_bgColor[index] * 255.0f);
    }

    dnext = (udword*)_bgByte;
    dlast = (udword*)lastbg;

    depthOn = glIsEnabled(GL_DEPTH_TEST);
    lightOn = rndLightingEnable(FALSE);
    texOn = glIsEnabled(GL_TEXTURE_2D);
    blendOn = glIsEnabled(GL_BLEND);
    glDisable(GL_DEPTH_TEST);
    glDisable(GL_CULL_FACE);
    glDisable(GL_TEXTURE_2D);
    glEnable(GL_BLEND);
    rndAdditiveBlends(FALSE);

    if (useVBO) glBindBuffer(GL_ARRAY_BUFFER, vboTransVerts);

    //polys
    if (btgFade != lastFade || *dnext != *dlast)
    {
        if (btgFade < 0)
        {
            btgFade = 255;
        }
#ifndef _WIN32_FIXME
        btgColorVertices();
#endif
        if (useVBO) glBufferData(GL_ARRAY_BUFFER, btgHead->numVerts * sizeof(btgTransVertex), btgTransVerts, GL_STATIC_DRAW);
        *dlast = *dnext;
        lastFade = btgFade;
    }

    //use DrawElements to render the bg polys
    glEnableClientState(GL_COLOR_ARRAY);
    glEnableClientState(GL_VERTEX_ARRAY);
    if (useVBO) {
        glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(btgTransVertex), 0);
        glVertexPointer(3, GL_FLOAT, sizeof(btgTransVertex), (GLvoid*)4);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIndices);
        glDrawElements(GL_TRIANGLES, 3 * btgHead->numPolys, GL_UNSIGNED_SHORT, 0);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    } else {
        glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(btgTransVertex), (GLubyte*)btgTransVerts);
        glVertexPointer(3, GL_FLOAT, sizeof(btgTransVertex), ((GLubyte*)btgTransVerts) + 4);
        glDrawElements(GL_TRIANGLES, 3 * btgHead->numPolys, GL_UNSIGNED_SHORT, btgIndices);
    }
    glDisableClientState(GL_COLOR_ARRAY);

    //stars
    rndPerspectiveCorrection(FALSE);
    rndAdditiveBlends(TRUE);

    trClearCurrent();
    glEnable(GL_TEXTURE_2D);
    rndTextureEnvironment(RTE_Modulate);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    if (useVBO) {
        glBindBuffer(GL_ARRAY_BUFFER, vboTransStars);
        glVertexPointer(3, GL_FLOAT, sizeof(GLfloat) * 5, 0);
        glTexCoordPointer(2, GL_FLOAT, sizeof(GLfloat) * 5, (GLubyte*)sizeof(vector));
        glBindBuffer(GL_ARRAY_BUFFER, 0);
    } else {
        glVertexPointer(3, GL_FLOAT, sizeof(GLfloat) * 5, (GLubyte*)btgTransStars);
        glTexCoordPointer(2, GL_FLOAT, sizeof(GLfloat) * 5, ((GLubyte*)btgTransStars) + sizeof(vector));
    }

    for (nStar = 0; nStar < btgHead->numStars; nStar++) {
        if (btgStars[nStar].glhandle) {
            glColor4ub((GLubyte)btgStars[nStar].red, (GLubyte)btgStars[nStar].green, (GLubyte)btgStars[nStar].blue, (GLubyte)btgStars[nStar].alpha);
            glBindTexture(GL_TEXTURE_2D, btgStars[nStar].glhandle);
            glDrawArrays(GL_TRIANGLE_STRIP, nStar * 4, 4);
         }
    }

    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    glDisableClientState(GL_VERTEX_ARRAY);

    glDisable(GL_BLEND);

    rndAdditiveBlends(FALSE);

    rndLightingEnable(lightOn);
    if (texOn) glEnable(GL_TEXTURE_2D);
    if (blendOn)
    {
        glEnable(GL_BLEND);
    }
    else
    {
        glDisable(GL_BLEND);
    }
    glEnable(GL_CULL_FACE);
    if (depthOn)
    {
        glEnable(GL_DEPTH_TEST);
    }
    else
    {
        glDisable(GL_DEPTH_TEST);
    }
}
Example #15
0
void GLLabel::DeferredRenderer::draw(void)
	{
	/* Bail out if no labels were gathered: */
	if(gatheredLabels.empty())
		return;
	
	/* Save and set up OpenGL state: */
	GLbitfield attribPushMask=GL_TEXTURE_BIT;
	bool lightingOn=glIsEnabled(GL_LIGHTING);
	if(lightingOn)
		attribPushMask|=GL_LIGHTING_BIT;
	glPushAttrib(attribPushMask);
	glEnable(GL_TEXTURE_2D);
	if(lightingOn)
		{
		glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR);
		glTexEnvMode(GLTexEnvEnums::TEXTURE_ENV,GLTexEnvEnums::MODULATE);
		}
	else
		glTexEnvMode(GLTexEnvEnums::TEXTURE_ENV,GLTexEnvEnums::REPLACE);
	
	/* Draw each gathered label: */
	for(std::vector<const GLLabel*>::iterator lIt=gatheredLabels.begin();lIt!=gatheredLabels.end();++lIt)
		{
		const GLLabel* l=*lIt;
		
		/* Retrieve the context data item: */
		GLLabel::DataItem* dataItem=contextData.retrieveDataItem<GLLabel::DataItem>(*lIt);
		
		/* Bind the label texture: */
		glBindTexture(GL_TEXTURE_2D,dataItem->textureObjectId);
		
		/* Check if the texture object needs to be updated: */
		if(dataItem->version!=l->version)
			{
			/* Upload the string's texture image: */
			l->font->uploadStringTexture(*l,l->background,l->foreground);
			
			/* Update the texture version number: */
			dataItem->version=l->version;
			}
		
		/* Draw a textured quad: */
		glColor4f(1.0f,1.0f,1.0f,l->background[3]);
		glBegin(GL_QUADS);
		glNormal3f(0.0f,0.0f,1.0f);
		glTexCoord(l->textureBox.getCorner(0));
		glVertex(l->labelBox.getCorner(0));
		glTexCoord(l->textureBox.getCorner(1));
		glVertex(l->labelBox.getCorner(1));
		glTexCoord(l->textureBox.getCorner(3));
		glVertex(l->labelBox.getCorner(3));
		glTexCoord(l->textureBox.getCorner(2));
		glVertex(l->labelBox.getCorner(2));
		glEnd();
		}
	
	/* Reset OpenGL state: */
	glBindTexture(GL_TEXTURE_2D,0);
	glPopAttrib();
	
	/* Clear the list of labels: */
	gatheredLabels.clear();
	}
Example #16
0
void TheGooniesApp::titleanimation_draw(void)
{
    glClearColor(0, 0, 0, 1);
    glClear(GL_COLOR_BUFFER_BIT);

	m_titleanimation_shift -= m_titleanimation_speed;
	m_titleanimation_shift += 40;
	m_titleanimation_shift = (m_titleanimation_shift%40)-40;
	if ((m_state_cycle%8)==0) {
		if (m_titleanimation_state==0 || m_titleanimation_state==1) {
			if (m_titleanimation_speed<4) m_titleanimation_speed++;
		} else {
			if (m_titleanimation_speed>0) m_titleanimation_speed--;
		}
	} 

    m_GLTM->get
    ("bg_copyright")->draw(0, 0, 0, 0, 1);
    m_GLTM->get_smooth("title_logo")->draw(46, 17, 0, 0, 1);

    switch (m_titleanimation_state) {
        case 0: {
                float f = float(m_state_cycle) / 50;

                glColor4f(0, 0, 0, f);
#ifndef HAVE_GLES
                glBegin(GL_QUADS);
                glVertex3f(0, 256, 0);
                glVertex3f(0, 400, 0);
                glVertex3f(640, 400, 0);
                glVertex3f(640, 256, 0);
                glEnd();
#else
		GLfloat vtx1[] = {
		0, 256, 0,
		0, 400, 0,
		640, 400, 0,
		640, 256, 0
		};

      glEnableClientState(GL_VERTEX_ARRAY);
 
      glVertexPointer(3, GL_FLOAT, 0, vtx1);
      glDrawArrays(GL_TRIANGLE_FAN,0,4);
 
      glDisableClientState(GL_VERTEX_ARRAY);
#endif

				// film strip
				{
					GLTile *strip = m_GLTM->get("intro-film-strip");
					for (int x = m_titleanimation_shift; x < 640; x+= 40)
					{
						strip->draw(1, 1, 1, f, float(x), 236, 0, 0, 1);
						strip->draw(1, 1, 1, f, float(x), 400, 0, 0, 1);
					}
				}
            }
            break;
        case 1:
        case 2: {
                float f = 1;
                bool scissor_state = (glIsEnabled(GL_SCISSOR_TEST) ? true : false);
                int scissor_window[4];

                if (m_titleanimation_state == 1)
                    f = 1;
                if (m_titleanimation_state == 2)
                    f = float(50 - m_state_cycle) / 50;
                glEnable(GL_SCISSOR_TEST);
                if (scissor_state)
                    glGetIntegerv(GL_SCISSOR_BOX, scissor_window);
                glScissor(screen_x(0), screen_y(60), screen_x(640), screen_y(184));

                glColor4f(0, 0, 0, f);
#ifndef HAVE_GLES
                glBegin(GL_QUADS);
                glVertex3f(0, 0, 0);
                glVertex3f(0, 480, 0);
                glVertex3f(640, 480, 0);
                glVertex3f(640, 0, 0);
                glEnd();
#else
		GLfloat vtx2[] = {
		0, 0, 0,
		0, 480, 0,
		640, 480, 0,
		640, 0, 0
		};

      glEnableClientState(GL_VERTEX_ARRAY);
 
      glVertexPointer(3, GL_FLOAT, 0, vtx2);
      glDrawArrays(GL_TRIANGLE_FAN,0,4);
 
      glDisableClientState(GL_VERTEX_ARRAY);
#endif

				// film strip
				{
//					int shift = -(m_titleanimation_cycle % 20) * 2;
					GLTile *strip = m_GLTM->get("intro-film-strip");
					for (int x = m_titleanimation_shift; x < 640; x+= 40)
					{
						strip->draw(1, 1, 1, f, float(x), 236, 0, 0, 1);
						strip->draw(1, 1, 1, f, float(x), 400, 0, 0, 1);
					}
				}

                // character:
                if (m_titleanimation_cycle > 50 &&
                        m_titleanimation_cycle <= 300) {
                    // running right:
                    int sp = (m_titleanimation_cycle / 8) % 4;
                    if (sp == 0)
                        m_GLTM->get
                        ("intro-character-r1")->draw(1, 1, 1, f, 512 - (300 - m_titleanimation_cycle)*2.5f, 296, 0, 0, 1);
                    if (sp == 1)
                        m_GLTM->get
                        ("intro-character-r2")->draw(1, 1, 1, f, 512 - (300 - m_titleanimation_cycle)*2.5f, 296, 0, 0, 1);
                    if (sp == 2)
                        m_GLTM->get
                        ("intro-character-r1")->draw(1, 1, 1, f, 512 - (300 - m_titleanimation_cycle)*2.5f, 296, 0, 0, 1);
                    if (sp == 3)
                        m_GLTM->get
                        ("intro-character-r3")->draw(1, 1, 1, f, 512 - (300 - m_titleanimation_cycle)*2.5f, 296, 0, 0, 1);
                } // if
				if (m_titleanimation_cycle > 300 &&
						m_titleanimation_cycle <= 312) {
					// turning:
					int sp = (m_titleanimation_cycle - 301) / 4;
					if (sp == 0)
						m_GLTM->get ("intro-character-turning_rl_1")->draw(1, 1, 1, f, 512, 296, 0, 0, 1);
					if (sp == 1)
						m_GLTM->get ("intro-character-turning_rl_2")->draw(1, 1, 1, f, 512, 296, 0, 0, 1);
					if (sp == 2)
						m_GLTM->get ("intro-character-turning_rl_3")->draw(1, 1, 1, f, 512, 296, 0, 0, 1);
				}
                if (m_titleanimation_cycle > 312 &&
                        m_titleanimation_cycle <= 1500) {
                    // standing left:
					int sp = (m_titleanimation_cycle / 8) % 4;
					if (sp == 0)
						m_GLTM->get
						("intro-character-standing-l1")->draw(1, 1, 1, f, 512, 296, 0, 0, 1);
					if (sp == 1)
						m_GLTM->get
						("intro-character-standing-l2")->draw(1, 1, 1, f, 512, 296, 0, 0, 1);
					if (sp == 2)
						m_GLTM->get
						("intro-character-standing-l3")->draw(1, 1, 1, f, 512, 296, 0, 0, 1);
					if (sp == 3)
						m_GLTM->get
						("intro-character-standing-l2")->draw(1, 1, 1, f, 512, 296, 0, 0, 1);
                } // if
                if (m_titleanimation_cycle > 1500 &&
                        m_titleanimation_cycle <= 1850) {
                    int sp = (m_titleanimation_cycle / 8) % 2;
					int s2 = (m_titleanimation_cycle / 5) % 3;
                    // knocked:
					if (s2 == 0) m_GLTM->get("intro-character-stars1")->draw(1, 1, 1, f, 532, 334, 0, 0, 1);
					if (s2 == 1) m_GLTM->get("intro-character-stars2")->draw(1, 1, 1, f, 532, 334, 0, 0, 1);
					if (s2 == 2) m_GLTM->get("intro-character-stars3")->draw(1, 1, 1, f, 532, 334, 0, 0, 1);

                    if (sp == 0)
                        m_GLTM->get
                        ("intro-character-knocked1")->draw(1, 1, 1, f, 512, 296, 0, 0, 1);
                    if (sp == 1)
                        m_GLTM->get
                        ("intro-character-knocked2")->draw(1, 1, 1, f, 512, 296, 0, 0, 1);

                } // if
                if (m_titleanimation_cycle > 1850 &&
                        m_titleanimation_cycle <= 1900) {
                    // standing left:
					int sp = (m_titleanimation_cycle / 8) % 4;
					if (sp == 0)
						m_GLTM->get
						("intro-character-standing-l1")->draw(1, 1, 1, f, 512, 296, 0, 0, 1);
					if (sp == 1)
						m_GLTM->get
						("intro-character-standing-l2")->draw(1, 1, 1, f, 512, 296, 0, 0, 1);
					if (sp == 2)
						m_GLTM->get
						("intro-character-standing-l3")->draw(1, 1, 1, f, 512, 296, 0, 0, 1);
					if (sp == 3)
						m_GLTM->get
						("intro-character-standing-l2")->draw(1, 1, 1, f, 512, 296, 0, 0, 1);
                } // if
                if (m_titleanimation_cycle > 1900 &&
                        m_titleanimation_cycle <= 2200) {
                    // running right:
                    int sp = (m_titleanimation_cycle / 8) % 4;
                    if (sp == 0)
                        m_GLTM->get
                        ("intro-character-l1")->draw(1, 1, 1, f, 512 - (m_titleanimation_cycle - 1900)*2.5f, 296, 0, 0, 1);
                    if (sp == 1)
                        m_GLTM->get
                        ("intro-character-l2")->draw(1, 1, 1, f, 512 - (m_titleanimation_cycle - 1900)*2.5f, 296, 0, 0, 1);
                    if (sp == 2)
                        m_GLTM->get
                        ("intro-character-l1")->draw(1, 1, 1, f, 512 - (m_titleanimation_cycle - 1900)*2.5f, 296, 0, 0, 1);
                    if (sp == 3)
                        m_GLTM->get
                        ("intro-character-l3")->draw(1, 1, 1, f, 512 - (m_titleanimation_cycle - 1900)*2.5f, 296, 0, 0, 1);
                } // if

                // Mike
				if (m_titleanimation_cycle > 300 + 0*150 &&
						m_titleanimation_cycle <= 500 + 0*150) {
					// running right:
					int sp = (m_titleanimation_cycle / 8) % 4;
					if (sp == 0)
						m_GLTM->get
							("intro-mike-r1")->draw(1, 1, 1, f, (464 - 0*60) - (500 + 0*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
					if (sp == 1)
						m_GLTM->get
							("intro-mike-r2")->draw(1, 1, 1, f, (464 - 0*60) - (500 + 0*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
					if (sp == 2)
						m_GLTM->get
							("intro-mike-r3")->draw(1, 1, 1, f, (464 - 0*60) - (500 + 0*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
					if (sp == 3)
						m_GLTM->get
							("intro-mike-r2")->draw(1, 1, 1, f, (464 - 0*60) - (500 + 0*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
				}
				if (m_titleanimation_cycle > 500 + 0*150 &&
						m_titleanimation_cycle <= 1624 + 0*24) {
					// standing:
					int sp = (m_titleanimation_cycle / 16) % 2;
					if (sp == 0)
						m_GLTM->get
							("intro-mike-standing1")->draw(1, 1, 1, f, float(464 - 0*60), 312, 0, 0, 1);
					if (sp == 1)
						m_GLTM->get
							("intro-mike-standing2")->draw(1, 1, 1, f, float(464 - 0*60), 312, 0, 0, 1);
				}

				// Mouth
				if (m_titleanimation_cycle > 300 + 1*150 &&
						m_titleanimation_cycle <= 500 + 1*150) {
					// running right:
					int sp = (m_titleanimation_cycle / 8) % 4;
					if (sp == 0)
						m_GLTM->get
							("intro-mouth-r1")->draw(1, 1, 1, f, (464 - 1*60) - (500 + 1*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
					if (sp == 1)
						m_GLTM->get
							("intro-mouth-r2")->draw(1, 1, 1, f, (464 - 1*60) - (500 + 1*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
					if (sp == 2)
						m_GLTM->get
							("intro-mouth-r3")->draw(1, 1, 1, f, (464 - 1*60) - (500 + 1*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
					if (sp == 3)
						m_GLTM->get
							("intro-mouth-r2")->draw(1, 1, 1, f, (464 - 1*60) - (500 + 1*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
				}
				if (m_titleanimation_cycle > 500 + 1*150 &&
						m_titleanimation_cycle <= 1624 + 1*24) {
					// standing:
					int sp = (m_titleanimation_cycle / 16) % 2;
					if (sp == 0)
						m_GLTM->get
							("intro-mouth-standing1")->draw(1, 1, 1, f, float(464 - 1*60), 312, 0, 0, 1);
					if (sp == 1)
						m_GLTM->get
							("intro-mouth-standing2")->draw(1, 1, 1, f, float(464 - 1*60), 312, 0, 0, 1);
				}

				//
				// Data
				//
				//		Added some variables to look for best values in the rope effect. Enjoy ^o^.
				//		Should be replaced by constants or something once we feel happy with the values.
				//		Ps: yes, I know Bresenham's algorithm to draw lines. But mee too lazy, too tired, too late :-).
				//
				float wave_amplitude = 1.0;		// Wave amplitude when launching the rope
				float wave_lenght = 120.0;		// Wave lenght when launching the rope
				int rope_cycles = 100;			// Cycles to reach the other side of the screen
				float rope_y = 260;				// Y coordinate for the left side of the rope
				float rope_y_delta = 10;		// Hight delta between left and right sides
				float data_weight = 10;			// "weight" of Data using the rope
				float data_shift = -30;			// Data shift to adjust Data graphic to the rope :-P

				int rope_start_cycle = 500 + 1*150 - rope_cycles;
				GLTile *rope = m_GLTM->get("intro-data-rope");

				// Throwing rope
				if (m_titleanimation_cycle > rope_start_cycle &&
						m_titleanimation_cycle <= rope_start_cycle + rope_cycles) {
					int fragments = (m_titleanimation_cycle - rope_start_cycle)*64 / rope_cycles;
					for (int i = 0; i < fragments; ++i)
						rope->draw(1, 1, 1, f, float(i * 10), float(rope_y + i*10*rope_y_delta/640 + wave_amplitude * sin(i*10 * 2*M_PI/wave_lenght)), 0, 0, 1);
				}

				// Data descending
				if (m_titleanimation_cycle > 300 + 2*150 &&
						m_titleanimation_cycle <= 500 + 2*150) {
					float x = (464 - 2*60) - (500 + 2*150 - m_titleanimation_cycle)*2.5f;
					float y = rope_y + data_weight + x*rope_y_delta/640.0f;

					// The Rope
					if (x >= 0 && x < 640) {
						int i;
						float fst_y_delta = data_weight + x*rope_y_delta/640;
						float snd_y_delta = rope_y_delta - fst_y_delta;

						for (i = 0; i < x; i+=10)
							rope->draw(1, 1, 1, f, float(i), rope_y + (i)*fst_y_delta/x, 0, 0, 1);

						for (i = 0; i < (640 - x); i+=10)
							rope->draw(1, 1, 1, f, float(i+x), rope_y + fst_y_delta + (i)*snd_y_delta/(640-x), 0, 0, 1);
					}
					else if (m_titleanimation_cycle > rope_start_cycle + rope_cycles) {
						int i;
						for (i = 0; i < 640; i+=10)
							rope->draw(1, 1, 1, f, float(i), rope_y + i*rope_y_delta/640, 0, 0, 1);
					}

					// The kiddo
					int sp = (m_titleanimation_cycle / 8) % 4;
					if (sp == 0)
						m_GLTM->get
							("intro-data-hang1")->draw(1, 1, 1, f, x+data_shift, y, 0, 0, 1);
					if (sp == 1)
						m_GLTM->get
							("intro-data-hang2")->draw(1, 1, 1, f, x+data_shift, y, 0, 0, 1);
					if (sp == 2)
						m_GLTM->get
							("intro-data-hang3")->draw(1, 1, 1, f, x+data_shift, y, 0, 0, 1);
					if (sp == 3)
						m_GLTM->get
							("intro-data-hang2")->draw(1, 1, 1, f, x+data_shift, y, 0, 0, 1);
				}
				else if (m_titleanimation_cycle > rope_start_cycle + rope_cycles) {
					// Rope dissapearing
					float rf;
					if (m_titleanimation_cycle < 900)
						rf = 1.0;
					else if (m_titleanimation_cycle > 1000)
						rf = 0.0;
					else
						rf = (1000 - m_titleanimation_cycle) / 100.0f;

					for (int i = 0; i < 640; i+=10)
						rope->draw(1, 1, 1, rf, float(i), rope_y + i*rope_y_delta/640, 0, 0, 1);
				}

				if (m_titleanimation_cycle > 500 + 2*150 &&
						m_titleanimation_cycle <= 1624 + 2*24) {
					// standing:
					int sp = (m_titleanimation_cycle / 16) % 2;
					if (sp == 0)
						m_GLTM->get
							("intro-data-standing1")->draw(1, 1, 1, f, float(464 - 2*60), 312, 0, 0, 1);
					if (sp == 1)
						m_GLTM->get
							("intro-data-standing2")->draw(1, 1, 1, f, float(464 - 2*60), 312, 0, 0, 1);
				}

				// Chunk
				if (m_titleanimation_cycle > 300 + 3*150 &&
						m_titleanimation_cycle <= 500 + 3*150) {
					// running right:
					int sp = (m_titleanimation_cycle / 8) % 4;
					if (sp == 0)
						m_GLTM->get
							("intro-chunk-r1")->draw(1, 1, 1, f, (464 - 3*60) - (500 + 3*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
					if (sp == 1)
						m_GLTM->get
							("intro-chunk-r2")->draw(1, 1, 1, f, (464 - 3*60) - (500 + 3*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
					if (sp == 2)
						m_GLTM->get
							("intro-chunk-r3")->draw(1, 1, 1, f, (464 - 3*60) - (500 + 3*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
					if (sp == 3)
						m_GLTM->get
							("intro-chunk-r2")->draw(1, 1, 1, f, (464 - 3*60) - (500 + 3*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
				}
				if (m_titleanimation_cycle > 500 + 3*150 &&
						m_titleanimation_cycle <= 1624 + 3*24) {
					// standing:
					int sp = (m_titleanimation_cycle / 16) % 2;
					if (sp == 0)
						m_GLTM->get
							("intro-chunk-standing1")->draw(1, 1, 1, f, float(464 - 3*60), 312, 0, 0, 1);
					if (sp == 1)
						m_GLTM->get
							("intro-chunk-standing2")->draw(1, 1, 1, f, float(464 - 3*60), 312, 0, 0, 1);
				}

				// Brand
				if (m_titleanimation_cycle > 300 + 4*150 &&
						m_titleanimation_cycle <= 500 + 4*150) {
					// running right:
					int sp = (m_titleanimation_cycle / 8) % 4;
					if (sp == 0)
						m_GLTM->get
							("intro-brand-r1")->draw(1, 1, 1, f, (464 - 4*60) - (500 + 4*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
					if (sp == 1)
						m_GLTM->get
							("intro-brand-r2")->draw(1, 1, 1, f, (464 - 4*60) - (500 + 4*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
					if (sp == 2)
						m_GLTM->get
							("intro-brand-r3")->draw(1, 1, 1, f, (464 - 4*60) - (500 + 4*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
					if (sp == 3)
						m_GLTM->get
							("intro-brand-r2")->draw(1, 1, 1, f, (464 - 4*60) - (500 + 4*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
				}
				if (m_titleanimation_cycle > 500 + 4*150 &&
						m_titleanimation_cycle <= 1624 + 4*24) {
					// standing:
					int sp = (m_titleanimation_cycle / 16) % 2;
					if (sp == 0)
						m_GLTM->get
							("intro-brand-standing1")->draw(1, 1, 1, f, float(464 - 4*60), 312, 0, 0, 1);
					if (sp == 1)
						m_GLTM->get
							("intro-brand-standing2")->draw(1, 1, 1, f, float(464 - 4*60), 312, 0, 0, 1);
				}

				// Andy
				if (m_titleanimation_cycle > 300 + 5*150 &&
						m_titleanimation_cycle <= 500 + 5*150) {
					// running right:
					int sp = (m_titleanimation_cycle / 8) % 4;
					if (sp == 0)
						m_GLTM->get
							("intro-andy-r1")->draw(1, 1, 1, f, (464 - 5*60) - (500 + 5*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
					if (sp == 1)
						m_GLTM->get
							("intro-andy-r2")->draw(1, 1, 1, f, (464 - 5*60) - (500 + 5*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
					if (sp == 2)
						m_GLTM->get
							("intro-andy-r3")->draw(1, 1, 1, f, (464 - 5*60) - (500 + 5*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
					if (sp == 3)
						m_GLTM->get
							("intro-andy-r2")->draw(1, 1, 1, f, (464 - 5*60) - (500 + 5*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
				}
				if (m_titleanimation_cycle > 500 + 5*150 &&
						m_titleanimation_cycle <= 1624 + 5*24) {
					// standing:
					int sp = (m_titleanimation_cycle / 16) % 2;
					if (sp == 0)
						m_GLTM->get
							("intro-andy-standing1")->draw(1, 1, 1, f, float(464 - 5*60), 312, 0, 0, 1);
					if (sp == 1)
						m_GLTM->get
							("intro-andy-standing2")->draw(1, 1, 1, f, float(464 - 5*60), 312, 0, 0, 1);
				}

				// Steff
				if (m_titleanimation_cycle > 300 + 6*150 &&
						m_titleanimation_cycle <= 500 + 6*150) {
					// running right:
					int sp = (m_titleanimation_cycle / 8) % 4;
					if (sp == 0)
						m_GLTM->get
							("intro-steff-r1")->draw(1, 1, 1, f, (464 - 6*60) - (500 + 6*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
					if (sp == 1)
						m_GLTM->get
							("intro-steff-r2")->draw(1, 1, 1, f, (464 - 6*60) - (500 + 6*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
					if (sp == 2)
						m_GLTM->get
							("intro-steff-r3")->draw(1, 1, 1, f, (464 - 6*60) - (500 + 6*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
					if (sp == 3)
						m_GLTM->get
							("intro-steff-r2")->draw(1, 1, 1, f, (464 - 6*60) - (500 + 6*150 - m_titleanimation_cycle)*2.5f, 312, 0, 0, 1);
				}
				if (m_titleanimation_cycle > 500 + 6*150 &&
						m_titleanimation_cycle <= 1624 + 6*24) {
					// standing:
					int sp = (m_titleanimation_cycle / 16) % 2;
					if (sp == 0)
						m_GLTM->get
							("intro-steff-standing1")->draw(1, 1, 1, f, float(464 - 6*60), 312, 0, 0, 1);
					if (sp == 1)
						m_GLTM->get
							("intro-steff-standing2")->draw(1, 1, 1, f, float(464 - 6*60), 312, 0, 0, 1);
				}

                // Fratelli:
                if (m_titleanimation_cycle > 1400 &&
                        m_titleanimation_cycle <= 1500) {
                    // wlking left:
                    int sp = (m_titleanimation_cycle / 8) % 2;
                    if (sp == 0)
                        m_GLTM->get
                        ("intro-fratelli-l1")->draw(1, 1, 1, f, 544 + (1500 - m_titleanimation_cycle)*2.5f, 296, 0, 0, 1);
                    if (sp == 1)
                        m_GLTM->get
                        ("intro-fratelli-l2")->draw(1, 1, 1, f, 544 + (1500 - m_titleanimation_cycle)*2.5f, 296, 0, 0, 1);
                } // if
                if (m_titleanimation_cycle > 1500 &&
                        m_titleanimation_cycle <= 1600) {
                    // standing left:
                    m_GLTM->get
                    ("intro-fratelli-l1")->draw(1, 1, 1, f, 544, 296, 0, 0, 1);
                } // if
                if (m_titleanimation_cycle > 1600 &&
                        m_titleanimation_cycle <= 1780) {
                    // wlking left:
                    int sp = (m_titleanimation_cycle / 8) % 2;
                    if (sp == 0)
                        m_GLTM->get
                        ("intro-fratelli-l1")->draw(1, 1, 1, f, 544 - (m_titleanimation_cycle - 1600)*2.5f, 296, 0, 0, 1);
                    if (sp == 1)
                        m_GLTM->get
                        ("intro-fratelli-l2")->draw(1, 1, 1, f, 544 - (m_titleanimation_cycle - 1600)*2.5f, 296, 0, 0, 1);
                } // if
                if (m_titleanimation_cycle > 1780 &&
                        m_titleanimation_cycle <= 1900) {
                    // laughting:
                    int sp = (m_titleanimation_cycle / 8) % 2;
                    if (sp == 0) m_GLTM->get("intro-fratelli-laught-r1")->draw(1, 1, 1, f, 94, 296, 0, 0, 1);
                    if (sp == 1) m_GLTM->get("intro-fratelli-laught-r2")->draw(1, 1, 1, f, 94, 296, 0, 0, 1);
                } // if
                if (m_titleanimation_cycle > 1900 &&
                        m_titleanimation_cycle <= 2000) {
                    // wlking left:
                    int sp = (m_titleanimation_cycle / 8) % 2;
                    if (sp == 0)
                        m_GLTM->get
                        ("intro-fratelli-l1")->draw(1, 1, 1, f, 94 - (m_titleanimation_cycle - 1900)*2.5f, 296, 0, 0, 1);
                    if (sp == 1)
                        m_GLTM->get
                        ("intro-fratelli-l2")->draw(1, 1, 1, f, 94 - (m_titleanimation_cycle - 1900)*2.5f, 296, 0, 0, 1);
                } // if

                if (!scissor_state)
                    glDisable(GL_SCISSOR_TEST);
                if (scissor_state)
                    glScissor(scissor_window[0], scissor_window[1], scissor_window[2], scissor_window[3]);

            }
            break;
    } // switch

} /* TheGooniesApp::titleanimation_draw */
Example #17
0
bool OGLRender::RenderTexRect()
{
    glViewportWrapper(0, windowSetting.statusBarHeightToUse, windowSetting.uDisplayWidth, windowSetting.uDisplayHeight);
    OPENGL_CHECK_ERRORS;

    GLboolean cullface = glIsEnabled(GL_CULL_FACE);
    glDisable(GL_CULL_FACE);
    OPENGL_CHECK_ERRORS;

    float depth = -(g_texRectTVtx[3].z*2-1);

#if SDL_VIDEO_OPENGL

    glBegin(GL_TRIANGLE_FAN);

    glColor4f(g_texRectTVtx[3].r, g_texRectTVtx[3].g, g_texRectTVtx[3].b, g_texRectTVtx[3].a);
    TexCoord(g_texRectTVtx[3]);
    glVertex3f(g_texRectTVtx[3].x, g_texRectTVtx[3].y, depth);
    
    glColor4f(g_texRectTVtx[2].r, g_texRectTVtx[2].g, g_texRectTVtx[2].b, g_texRectTVtx[2].a);
    TexCoord(g_texRectTVtx[2]);
    glVertex3f(g_texRectTVtx[2].x, g_texRectTVtx[2].y, depth);

    glColor4f(g_texRectTVtx[1].r, g_texRectTVtx[1].g, g_texRectTVtx[1].b, g_texRectTVtx[1].a);
    TexCoord(g_texRectTVtx[1]);
    glVertex3f(g_texRectTVtx[1].x, g_texRectTVtx[1].y, depth);

    glColor4f(g_texRectTVtx[0].r, g_texRectTVtx[0].g, g_texRectTVtx[0].b, g_texRectTVtx[0].a);
    TexCoord(g_texRectTVtx[0]);
    glVertex3f(g_texRectTVtx[0].x, g_texRectTVtx[0].y, depth);

    glEnd();
    OPENGL_CHECK_ERRORS;

#elif SDL_VIDEO_OPENGL_ES2

    GLfloat colour[] = {
            g_texRectTVtx[3].r, g_texRectTVtx[3].g, g_texRectTVtx[3].b, g_texRectTVtx[3].a,
            g_texRectTVtx[2].r, g_texRectTVtx[2].g, g_texRectTVtx[2].b, g_texRectTVtx[2].a,
            g_texRectTVtx[1].r, g_texRectTVtx[1].g, g_texRectTVtx[1].b, g_texRectTVtx[1].a,
            g_texRectTVtx[0].r, g_texRectTVtx[0].g, g_texRectTVtx[0].b, g_texRectTVtx[0].a
    };

    GLfloat tex[] = {
            g_texRectTVtx[3].tcord[0].u,g_texRectTVtx[3].tcord[0].v,
            g_texRectTVtx[2].tcord[0].u,g_texRectTVtx[2].tcord[0].v,
            g_texRectTVtx[1].tcord[0].u,g_texRectTVtx[1].tcord[0].v,
            g_texRectTVtx[0].tcord[0].u,g_texRectTVtx[0].tcord[0].v
    };

    float w = windowSetting.uDisplayWidth / 2.0f, h = windowSetting.uDisplayHeight / 2.0f, inv = 1.0f;

    GLfloat vertices[] = {
            -inv + g_texRectTVtx[3].x / w, inv - g_texRectTVtx[3].y / h, depth, 1,
            -inv + g_texRectTVtx[2].x / w, inv - g_texRectTVtx[2].y / h, depth, 1,
            -inv + g_texRectTVtx[1].x / w, inv - g_texRectTVtx[1].y / h, depth, 1,
            -inv + g_texRectTVtx[0].x / w, inv - g_texRectTVtx[0].y / h, depth, 1
    };

    glVertexAttribPointer(VS_COLOR, 4, GL_FLOAT,GL_TRUE, 0, &colour );
    glVertexAttribPointer(VS_POSITION,4,GL_FLOAT,GL_FALSE,0,&vertices);
    glVertexAttribPointer(VS_TEXCOORD0,2,GL_FLOAT,GL_FALSE, 0, &tex);
    OPENGL_CHECK_ERRORS;
    glDrawArrays(GL_TRIANGLE_FAN,0,4);
    OPENGL_CHECK_ERRORS;

    //Restore old pointers
    glVertexAttribPointer(VS_COLOR, 4, GL_UNSIGNED_BYTE,GL_TRUE, sizeof(uint8)*4, &(g_oglVtxColors[0][0]) );
    glVertexAttribPointer(VS_POSITION,4,GL_FLOAT,GL_FALSE,sizeof(float)*5,&(g_vtxProjected5[0][0]));
    glVertexAttribPointer(VS_TEXCOORD0,2,GL_FLOAT,GL_FALSE, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[0].u));

#endif

    if( cullface ) glEnable(GL_CULL_FACE);
    OPENGL_CHECK_ERRORS;

    return true;
}
Example #18
0
void ui_draw_but_NORMAL(uiBut *but, uiWidgetColors *wcol, rcti *rect)
{
	static GLuint displist = 0;
	int a, old[8];
	GLfloat diff[4], diffn[4] = {1.0f, 1.0f, 1.0f, 1.0f};
	float vec0[4] = {0.0f, 0.0f, 0.0f, 0.0f};
	float dir[4], size;
	
	/* store stuff */
	glGetMaterialfv(GL_FRONT, GL_DIFFUSE, diff);
		
	/* backdrop */
	glColor3ubv((unsigned char *)wcol->inner);
	uiSetRoundBox(UI_CNR_ALL);
	uiDrawBox(GL_POLYGON, rect->xmin, rect->ymin, rect->xmax, rect->ymax, 5.0f);
	
	/* sphere color */
	glMaterialfv(GL_FRONT, GL_DIFFUSE, diffn);
	glCullFace(GL_BACK);
	glEnable(GL_CULL_FACE);
	
	/* disable blender light */
	for (a = 0; a < 8; a++) {
		old[a] = glIsEnabled(GL_LIGHT0 + a);
		glDisable(GL_LIGHT0 + a);
	}
	
	/* own light */
	glEnable(GL_LIGHT7);
	glEnable(GL_LIGHTING);
	
	ui_get_but_vectorf(but, dir);

	dir[3] = 0.0f;   /* glLightfv needs 4 args, 0.0 is sun */
	glLightfv(GL_LIGHT7, GL_POSITION, dir); 
	glLightfv(GL_LIGHT7, GL_DIFFUSE, diffn); 
	glLightfv(GL_LIGHT7, GL_SPECULAR, vec0); 
	glLightf(GL_LIGHT7, GL_CONSTANT_ATTENUATION, 1.0f);
	glLightf(GL_LIGHT7, GL_LINEAR_ATTENUATION, 0.0f);
	
	/* transform to button */
	glPushMatrix();
	glTranslatef(rect->xmin + 0.5f * BLI_rcti_size_x(rect), rect->ymin + 0.5f * BLI_rcti_size_y(rect), 0.0f);
	
	if (BLI_rcti_size_x(rect) < BLI_rcti_size_y(rect))
		size = BLI_rcti_size_x(rect) / 200.f;
	else
		size = BLI_rcti_size_y(rect) / 200.f;
	
	glScalef(size, size, size);

	if (displist == 0) {
		GLUquadricObj *qobj;

		displist = glGenLists(1);
		glNewList(displist, GL_COMPILE);
		
		qobj = gluNewQuadric();
		gluQuadricDrawStyle(qobj, GLU_FILL);
		glShadeModel(GL_SMOOTH);
		gluSphere(qobj, 100.0, 32, 24);
		glShadeModel(GL_FLAT);
		gluDeleteQuadric(qobj);
		
		glEndList();
	}

	glCallList(displist);

	/* restore */
	glDisable(GL_LIGHTING);
	glDisable(GL_CULL_FACE);
	glMaterialfv(GL_FRONT, GL_DIFFUSE, diff); 
	glDisable(GL_LIGHT7);
	
	/* AA circle */
	glEnable(GL_BLEND);
	glEnable(GL_LINE_SMOOTH);
	glColor3ubv((unsigned char *)wcol->inner);
	glutil_draw_lined_arc(0.0f, M_PI * 2.0, 100.0f, 32);
	glDisable(GL_BLEND);
	glDisable(GL_LINE_SMOOTH);

	/* matrix after circle */
	glPopMatrix();

	/* enable blender light */
	for (a = 0; a < 8; a++) {
		if (old[a])
			glEnable(GL_LIGHT0 + a);
	}
}
Example #19
0
void keyboard(unsigned char key, int x, int y)
{
	vec3 look = (at-eye) * 0.1;
	vec3 right = calcCrossProduct(at-eye, up) * 0.05;
	
	switch(key) {
		case '1':
			if(glIsEnabled(GL_LIGHT1))
				glDisable(GL_LIGHT1);
			else
				glEnable(GL_LIGHT1);
			break;
		case '2':
			if(glIsEnabled(GL_LIGHT0))
				glDisable(GL_LIGHT0);
			else
				glEnable(GL_LIGHT0);
			break;
		case 'c':
		case 'C':
			circles = !circles;
			break;
		case 'r':
		case 'R':
			rotate = !rotate;
			break;
		case 'o':
		case 'O':
			orbits = !orbits;
			break;
		case '+':
			speed += 0.01;
			break;
		case '-':
			speed -= 0.01;
			break;
		case 'w':
		case 'W':
			eye = eye + look;
			at = at + look;
			//eye_speed += 0.01; // schubregelung
			break;
		case 's':
		case 'S':
			eye = eye - look;
			at = at - look;
			//eye_speed -= 0.01; // schubregelung
			break;
		case 'a':
		case 'A':
			eye = eye - right;
			at = at - right;
			break;
		case 'd':
		case 'D':
			eye = eye + right;
			at = at + right;
			break;
		case 'q':
		case 'Q':
			up = rotMat3x3(at-eye, -3) * up;
			break;
		case 'e':
		case 'E':
			up = rotMat3x3(at-eye, 3) * up;
			break;
		case 27:
			exit(0);
	}
}
Example #20
0
void ClippingNode::onBeforeVisit()
{
    ///////////////////////////////////
    // INIT

    // increment the current layer
    s_layer++;

    // mask of the current layer (ie: for layer 3: 00000100)
    GLint mask_layer = 0x1 << s_layer;
    // mask of all layers less than the current (ie: for layer 3: 00000011)
    GLint mask_layer_l = mask_layer - 1;
    // mask of all layers less than or equal to the current (ie: for layer 3: 00000111)
    _mask_layer_le = mask_layer | mask_layer_l;

    // manually save the stencil state

    _currentStencilEnabled = glIsEnabled(GL_STENCIL_TEST);
    glGetIntegerv(GL_STENCIL_WRITEMASK, (GLint *)&_currentStencilWriteMask);
    glGetIntegerv(GL_STENCIL_FUNC, (GLint *)&_currentStencilFunc);
    glGetIntegerv(GL_STENCIL_REF, &_currentStencilRef);
    glGetIntegerv(GL_STENCIL_VALUE_MASK, (GLint *)&_currentStencilValueMask);
    glGetIntegerv(GL_STENCIL_FAIL, (GLint *)&_currentStencilFail);
    glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, (GLint *)&_currentStencilPassDepthFail);
    glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, (GLint *)&_currentStencilPassDepthPass);

    // enable stencil use
    glEnable(GL_STENCIL_TEST);
    // check for OpenGL error while enabling stencil test
    CHECK_GL_ERROR_DEBUG();

    // all bits on the stencil buffer are readonly, except the current layer bit,
    // this means that operation like glClear or glStencilOp will be masked with this value
    glStencilMask(mask_layer);

    // manually save the depth test state

    glGetBooleanv(GL_DEPTH_WRITEMASK, &_currentDepthWriteMask);

    // disable depth test while drawing the stencil
    //glDisable(GL_DEPTH_TEST);
    // disable update to the depth buffer while drawing the stencil,
    // as the stencil is not meant to be rendered in the real scene,
    // it should never prevent something else to be drawn,
    // only disabling depth buffer update should do
    glDepthMask(GL_FALSE);

    ///////////////////////////////////
    // CLEAR STENCIL BUFFER

    // manually clear the stencil buffer by drawing a fullscreen rectangle on it
    // setup the stencil test func like this:
    // for each pixel in the fullscreen rectangle
    //     never draw it into the frame buffer
    //     if not in inverted mode: set the current layer value to 0 in the stencil buffer
    //     if in inverted mode: set the current layer value to 1 in the stencil buffer
    glStencilFunc(GL_NEVER, mask_layer, mask_layer);
    glStencilOp(!_inverted ? GL_ZERO : GL_REPLACE, GL_KEEP, GL_KEEP);

    // draw a fullscreen solid rectangle to clear the stencil buffer
    //ccDrawSolidRect(Vec2::ZERO, ccpFromSize([[Director sharedDirector] winSize]), Color4F(1, 1, 1, 1));
    drawFullScreenQuadClearStencil();

    ///////////////////////////////////
    // DRAW CLIPPING STENCIL

    // setup the stencil test func like this:
    // for each pixel in the stencil node
    //     never draw it into the frame buffer
    //     if not in inverted mode: set the current layer value to 1 in the stencil buffer
    //     if in inverted mode: set the current layer value to 0 in the stencil buffer
    glStencilFunc(GL_NEVER, mask_layer, mask_layer);
    glStencilOp(!_inverted ? GL_REPLACE : GL_ZERO, GL_KEEP, GL_KEEP);

    // enable alpha test only if the alpha threshold < 1,
    // indeed if alpha threshold == 1, every pixel will be drawn anyways
    if (_alphaThreshold < 1) {
#if (CC_TARGET_PLATFORM == CC_PLATFORM_MAC || CC_TARGET_PLATFORM == CC_PLATFORM_WINDOWS || CC_TARGET_PLATFORM == CC_PLATFORM_LINUX)
        // manually save the alpha test state
        _currentAlphaTestEnabled = glIsEnabled(GL_ALPHA_TEST);
        glGetIntegerv(GL_ALPHA_TEST_FUNC, (GLint *)&_currentAlphaTestFunc);
        glGetFloatv(GL_ALPHA_TEST_REF, &_currentAlphaTestRef);
        // enable alpha testing
        glEnable(GL_ALPHA_TEST);
        // check for OpenGL error while enabling alpha test
        CHECK_GL_ERROR_DEBUG();
        // pixel will be drawn only if greater than an alpha threshold
        glAlphaFunc(GL_GREATER, _alphaThreshold);
#else
        
#endif
    }

    //Draw _stencil
}
Example #21
0
void GearsScreen::cubePaintInside (const GLScreenPaintAttrib &sAttrib,
                                   const GLMatrix            &transform,
                                   CompOutput                *output,
                                   int                       size,
                                   const GLVector            &normal)
{
//    CUBE_SCREEN (screen);

    static GLfloat white[4] = { 1.0, 1.0, 1.0, 1.0 };

    GLScreenPaintAttrib sA = sAttrib;

    sA.yRotate += csScreen->invert () * (360.0f / size) *
                  (csScreen->xRotations () - (screen->vp ().x () * csScreen->nOutput ()));

    //CompTransform mT = *transform;
    GLMatrix mT = transform;

    gScreen->glApplyTransform (sA, output, &mT);
//    (*s->applyScreenTransform) (s, &sA, output, &mT);

    glPushMatrix();
    glLoadMatrixf (mT.getMatrix ());
    glTranslatef (csScreen->outputXOffset (), -csScreen->outputYOffset (), 0.0f);
    glScalef (csScreen->outputXScale (), csScreen->outputYScale (), 1.0f);

    bool enabledCull = false;

    glPushAttrib (GL_COLOR_BUFFER_BIT | GL_TEXTURE_BIT);

    glDisable (GL_BLEND);

    if (!glIsEnabled (GL_CULL_FACE) )
    {
        enabledCull = true;
        glEnable (GL_CULL_FACE);
    }

    glPushMatrix();

    glRotatef (contentRotation, 0.0, 1.0, 0.0);

    glScalef (0.05, 0.05, 0.05);
    glColor4usv (defaultColor);

    glEnable (GL_NORMALIZE);
    glEnable (GL_LIGHTING);
    glEnable (GL_LIGHT1);
    glDisable (GL_COLOR_MATERIAL);

    glEnable (GL_DEPTH_TEST);
    glDepthMask (GL_TRUE);
    glDepthFunc (GL_LESS);
    glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

    glPushMatrix();
    glTranslatef (-3.0, -2.0, 0.0);
    glRotatef (angle, 0.0, 0.0, 1.0);
    glCallList (gear1);
    glPopMatrix();

    glPushMatrix();
    glTranslatef (3.1, -2.0, 0.0);
    glRotatef (-2.0 * angle - 9.0, 0.0, 0.0, 1.0);
    glCallList (gear2);
    glPopMatrix();

    glPushMatrix();
    glTranslatef (-3.1, 4.2, 0.0);
    glRotatef (-2.0 * angle - 25.0, 0.0, 0.0, 1.0);
    glCallList (gear3);
    glPopMatrix();

    glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, white);

    glPopMatrix();

    glDisable (GL_LIGHT1);
    glDisable (GL_NORMALIZE);
    glEnable (GL_COLOR_MATERIAL);

    if (!gScreen->lighting ())
        glDisable (GL_LIGHTING);

    glDisable (GL_DEPTH_TEST);

    if (enabledCull)
        glDisable (GL_CULL_FACE);

    glPopMatrix();
    glPopAttrib();

    damage = true;

    csScreen->cubePaintInside (sAttrib, transform, output, size, normal);
}
Example #22
0
//----------------------------------------
bool ofGetLightingEnabled() {
	return glIsEnabled(GL_LIGHTING);
}
Example #23
0
void
R_DrawParticles ( void )
{
	particle_t		*p, *kill;
	float			grav;
	int				i;
	float			time2, time3;
	float			time1;
	float			dvel;
	float			frametime;
	unsigned char	*at;
	unsigned char	theAlpha;
	vec3_t			up, right;
	float			scale;
	qboolean		alphaTestEnabled;

	if (gl_particles->value)
	{
		GL_Bind(particletexture);
		alphaTestEnabled = glIsEnabled(GL_ALPHA_TEST);

		if (alphaTestEnabled)
			glDisable(GL_ALPHA_TEST);
		glEnable (GL_BLEND);
		glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
		glBegin (GL_TRIANGLES);

		VectorScale (vup, 1.5, up);
		VectorScale (vright, 1.5, right);
#ifdef 	UQUAKE
		frametime = cl.time - cl.oldtime;
#else
		frametime = host_frametime;
#endif
		time3 = frametime * 15;
		time2 = frametime * 10;		// 15;
		time1 = frametime * 5;
#ifdef UQUAKE
		grav = frametime * sv_gravity->value * 0.05;
#else
		grav = frametime * 800 * 0.05;
#endif
		dvel = 4*frametime;

		for ( ;; )
		{
			kill = active_particles;
			if (kill && kill->die < cl.time)
			{
				active_particles = kill->next;
				kill->next = free_particles;
				free_particles = kill;
				continue;
			}
			break;
		}

		for (p=active_particles ; p ; p=p->next)
		{
			for ( ;; )
			{
				kill = p->next;
				if (kill && kill->die < cl.time)
				{
					p->next = kill->next;
					kill->next = free_particles;
					free_particles = kill;
					continue;
				}
				break;
			}

			// hack a scale up to keep particles from disapearing
			scale = (p->org[0] - r_origin[0])*vpn[0]
				+ (p->org[1] - r_origin[1])*vpn[1]
				+ (p->org[2] - r_origin[2])*vpn[2];
			if (scale < 20)
				scale = gl_particles->value;
			else
				scale = gl_particles->value + scale * 0.004;
#if 0	// was in uquake, but give it a go
			glColor3ubv ((byte *)&d_8to24table[(int)p->color]);
#else
			at = (byte *)&d_8to24table[(int)p->color];
			if (p->type==pt_fire)
				theAlpha = 255*(6-p->ramp)/6;
//				theAlpha = 192;
//			else if (p->type==pt_explode || p->type==pt_explode2)
//				theAlpha = 255*(8-p->ramp)/8;
			else
				theAlpha = 255;
			glColor4ub (*at, *(at+1), *(at+2), theAlpha);
//			glColor3ubv (at);
//			glColor3ubv ((byte *)&d_8to24table[(int)p->color]);
#endif
			glTexCoord2f (0,0);
			glVertex3fv (p->org);
			glTexCoord2f (1,0);
			glVertex3f (p->org[0] + up[0]*scale, p->org[1] + up[1]*scale, p->org[2] + up[2]*scale);
			glTexCoord2f (0,1);
			glVertex3f (p->org[0] + right[0]*scale, p->org[1] + right[1]*scale, p->org[2] + right[2]*scale);

			p->org[0] += p->vel[0]*frametime;
			p->org[1] += p->vel[1]*frametime;
			p->org[2] += p->vel[2]*frametime;

			switch (p->type)
			{
			case pt_static:
				break;
			case pt_fire:
				p->ramp += time1;
				if (p->ramp >= 6)
					p->die = -1;
				else
					p->color = ramp3[(int)p->ramp];
				p->vel[2] += grav;
				break;

			case pt_explode:
				p->ramp += time2;
				if (p->ramp >=8)
					p->die = -1;
				else
					p->color = ramp1[(int)p->ramp];
				for (i=0 ; i<3 ; i++)
					p->vel[i] += p->vel[i]*dvel;
				p->vel[2] -= grav;
				break;

			case pt_explode2:
				p->ramp += time3;
				if (p->ramp >=8)
					p->die = -1;
				else
					p->color = ramp2[(int)p->ramp];
				for (i=0 ; i<3 ; i++)
					p->vel[i] -= p->vel[i]*frametime;
				p->vel[2] -= grav;
				break;

			case pt_blob:
				for (i=0 ; i<3 ; i++)
					p->vel[i] += p->vel[i]*dvel;
				p->vel[2] -= grav;
				break;

			case pt_blob2:
				for (i=0 ; i<2 ; i++)
					p->vel[i] -= p->vel[i]*dvel;
				p->vel[2] -= grav;
				break;
			case pt_grav:
				// This causes some particles to fall to the
				// ground.  It's been reported as a bug,
				// so for now it's being fixed.
				// We can implement it as a feature, but it's
				// not all that cool.
//				p->vel[2] -= grav * 20;
//				break;
			case pt_slowgrav:
				p->vel[2] -= grav;
				break;
			}
		}

		glEnd ();
		glDisable (GL_BLEND);
		if (alphaTestEnabled)
			glEnable(GL_ALPHA_TEST);
		glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
	}	// if (gl_particles->value)
}
Example #24
0
// This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure)
// If text or lines are blurry when integrating ImGui in your engine:
// - in your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f)
void ImGui_ImplGlfwGL3_RenderDrawLists(ImDrawData* draw_data)
{
    // Backup GL state
    GLint last_program, last_texture, last_array_buffer, last_element_array_buffer, last_vertex_array;
    glGetIntegerv(GL_CURRENT_PROGRAM, &last_program);
    glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
    glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &last_element_array_buffer);
    glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
    GLboolean last_enable_blend = glIsEnabled(GL_BLEND);
    GLboolean last_enable_cull_face = glIsEnabled(GL_CULL_FACE);
    GLboolean last_enable_depth_test = glIsEnabled(GL_DEPTH_TEST);
    GLboolean last_enable_scissor_test = glIsEnabled(GL_SCISSOR_TEST);

    // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled
    glEnable(GL_BLEND);
    glBlendEquation(GL_FUNC_ADD);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glDisable(GL_CULL_FACE);
    glDisable(GL_DEPTH_TEST);
    glEnable(GL_SCISSOR_TEST);
    glActiveTexture(GL_TEXTURE0);

    // Handle cases of screen coordinates != from framebuffer coordinates (e.g. retina displays)
    ImGuiIO& io = ImGui::GetIO();
    float fb_height = io.DisplaySize.y * io.DisplayFramebufferScale.y;
    draw_data->ScaleClipRects(io.DisplayFramebufferScale);

    // Setup orthographic projection matrix
    const float ortho_projection[4][4] =
    {
        { 2.0f/io.DisplaySize.x, 0.0f,                   0.0f, 0.0f },
        { 0.0f,                  2.0f/-io.DisplaySize.y, 0.0f, 0.0f },
        { 0.0f,                  0.0f,                  -1.0f, 0.0f },
        {-1.0f,                  1.0f,                   0.0f, 1.0f },
    };
    glUseProgram(g_ShaderHandle);
    glUniform1i(g_AttribLocationTex, 0);
    glUniformMatrix4fv(g_AttribLocationProjMtx, 1, GL_FALSE, &ortho_projection[0][0]);
    glBindVertexArray(g_VaoHandle);

    for (int n = 0; n < draw_data->CmdListsCount; n++)
    {
        const ImDrawList* cmd_list = draw_data->CmdLists[n];
        const ImDrawIdx* idx_buffer_offset = 0;

        glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle);
        glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)cmd_list->VtxBuffer.size() * sizeof(ImDrawVert), (GLvoid*)&cmd_list->VtxBuffer.front(), GL_STREAM_DRAW);

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_ElementsHandle);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx), (GLvoid*)&cmd_list->IdxBuffer.front(), GL_STREAM_DRAW);

        for (const ImDrawCmd* pcmd = cmd_list->CmdBuffer.begin(); pcmd != cmd_list->CmdBuffer.end(); pcmd++)
        {
            if (pcmd->UserCallback)
            {
                pcmd->UserCallback(cmd_list, pcmd);
            }
            else
            {
                glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId);
                glScissor((int)pcmd->ClipRect.x, (int)(fb_height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y));
                glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, GL_UNSIGNED_SHORT, idx_buffer_offset);
            }
            idx_buffer_offset += pcmd->ElemCount;
        }
    }

    // Restore modified GL state
    glUseProgram(last_program);
    glBindTexture(GL_TEXTURE_2D, last_texture);
    glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, last_element_array_buffer);
    glBindVertexArray(last_vertex_array);
    if (last_enable_blend) glEnable(GL_BLEND);
    else glDisable(GL_BLEND);
    if (last_enable_cull_face) glEnable(GL_CULL_FACE);
    else glDisable(GL_CULL_FACE);
    if (last_enable_depth_test) glEnable(GL_DEPTH_TEST);
    else glDisable(GL_DEPTH_TEST);
    if (last_enable_scissor_test) glEnable(GL_SCISSOR_TEST);
    else glDisable(GL_SCISSOR_TEST);
}
GLboolean glIsEnabledLogged(GLenum cap) {
	printf("glIsEnabled(%s)\n", GLEnumName(cap));
	return glIsEnabled(cap);
}
Example #26
0
int main(int argc, char *argv[])
{
    SDL_Window *window;
    SDL_GLContext context;

    // Slightly different SDL initialization
    if ( SDL_Init(SDL_INIT_VIDEO) != 0 ) {
        printf("Unable to initialize SDL: %s\n", SDL_GetError());
        return 1;
    }

    SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); // *new*

    window = SDL_CreateWindow("sdl_fog_density", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 640, 480, SDL_WINDOW_OPENGL);
    if ( !window ) {
        printf("Unable to create window: %s\n", SDL_GetError());
        return 1;
    }

    context = SDL_GL_CreateContext(window);

    // Set the OpenGL state after creating the context with SDL_SetVideoMode

    glClearColor( 0, 0, 0, 0 );

    glEnable( GL_TEXTURE_2D ); // Needed when we're using the fixed-function pipeline.

    glViewport( 0, 0, 640, 480 );

    glMatrixMode( GL_PROJECTION );
    glPushMatrix(); // just for testing
    glLoadIdentity();

    glOrtho( 0, 640, 480, 0, -1000, 1000 );

    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();

    // Load the OpenGL texture

    GLuint texture; // Texture object handle
    SDL_Surface *surface; // Gives us the information to make the texture

    if ( (surface = IMG_Load("screenshot.png")) ) {

        // Check that the image's width is a power of 2
        if ( (surface->w & (surface->w - 1)) != 0 ) {
            printf("warning: image.bmp's width is not a power of 2\n");
        }

        // Also check if the height is a power of 2
        if ( (surface->h & (surface->h - 1)) != 0 ) {
            printf("warning: image.bmp's height is not a power of 2\n");
        }

        // Have OpenGL generate a texture object handle for us
        glGenTextures( 1, &texture );

        // Bind the texture object
        glBindTexture( GL_TEXTURE_2D, texture );

        // Set the texture's stretching properties
        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );

        //SDL_LockSurface(surface);

        // Add some greyness
        memset(surface->pixels, 0x66, surface->w*surface->h);

        // Edit the texture object's image data using the information SDL_Surface gives us
        glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, surface->w, surface->h, 0,
                      GL_RGBA, GL_UNSIGNED_BYTE, surface->pixels );

        //SDL_UnlockSurface(surface);
    }
    else {
        printf("SDL could not load image.bmp: %s\n", SDL_GetError());
        SDL_Quit();
        return 1;
    }

    // Free the SDL_Surface only if it was successfully created
    if ( surface ) {
        SDL_FreeSurface( surface );
    }

    // Clear the screen before drawing
    glClear( GL_COLOR_BUFFER_BIT );

    // Bind the texture to which subsequent calls refer to
    glBindTexture( GL_TEXTURE_2D, texture );

    glEnable(GL_FOG);
    GLfloat fogColor[] = { 1.0, 0.5, 0.5, 0.05 };
    glFogfv(GL_FOG_COLOR, fogColor);
    glFogf(GL_FOG_DENSITY, 0.2);
    glFogi(GL_FOG_MODE, GL_EXP2);

    assert(glIsEnabled(GL_FOG));

    glBegin( GL_QUADS );
        glTexCoord2i( 0, 0 ); glVertex3f( 10, 10, 10 );
        glTexCoord2i( 1, 0 ); glVertex3f( 300, 10, 10 );
        glTexCoord2i( 1, 1 ); glVertex3f( 300, 128, 10 );
        glTexCoord2i( 0, 1 ); glVertex3f( 10, 128, 10 );

        glTexCoord2f( 0, 0.5 ); glVertex3f( 410, 10, 5 );
        glTexCoord2f( 1, 0.5 ); glVertex3f( 600, 10, 6 );
        glTexCoord2f( 1, 1   ); glVertex3f( 630, 200, 7 );
        glTexCoord2f( 0.5, 1 ); glVertex3f( 310, 250, 8 );
    glEnd();

    glBegin( GL_TRIANGLE_STRIP );
        glTexCoord2i( 0, 0 ); glVertex3f( 100, 300, 1 );
        glTexCoord2i( 1, 0 ); glVertex3f( 300, 300, 1 );
        glTexCoord2i( 1, 1 ); glVertex3f( 300, 400, 1 );
        glTexCoord2i( 0, 1 ); glVertex3f( 500, 410, 1 );
    glEnd();

    glDisable(GL_TEXTURE_2D);

    glColor3ub(90, 255, 255);
    glBegin( GL_QUADS );
        glVertex3f( 10, 410, 5 );
        glVertex3f( 300, 410, 50 );
        glVertex3f( 300, 480, 100 );
        glVertex3f( 10, 470, 5 );
    glEnd();

    glBegin( GL_QUADS );
        glColor3f(1.0, 0, 1.0);   glVertex3f( 410, 410, 10 );
        glColor3f(0, 1.0, 0);     glVertex3f( 600, 410, 10 );
        glColor3f(0, 0, 1.0);     glVertex3f( 600, 480, 10 );
        glColor3f(1.0, 1.0, 1.0); glVertex3f( 410, 470, 10 );
    glEnd();

    SDL_GL_SwapWindow(window);

#if !defined(__EMSCRIPTEN__)
    // Wait for 3 seconds to give us a chance to see the image
    SDL_Delay(30000);
#endif

    // Now we can delete the OpenGL texture and close down SDL
    glDeleteTextures( 1, &texture );

    SDL_Quit();

    return 0;
}
// This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure)
// If text or lines are blurry when integrating ImGui in your engine:
// - in your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f)
void ImGui_ImplSdlGL3_RenderDrawLists(ImDrawData* draw_data)
{
    // Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
    ImGuiIO& io = ImGui::GetIO();
    int fb_width = (int)(io.DisplaySize.x * io.DisplayFramebufferScale.x);
    int fb_height = (int)(io.DisplaySize.y * io.DisplayFramebufferScale.y);
    if (fb_width == 0 || fb_height == 0)
        return;
    draw_data->ScaleClipRects(io.DisplayFramebufferScale);

    // Backup GL state
    GLint last_program; glGetIntegerv(GL_CURRENT_PROGRAM, &last_program);
    GLint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
    GLint last_active_texture; glGetIntegerv(GL_ACTIVE_TEXTURE, &last_active_texture);
    GLint last_array_buffer; glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
    GLint last_element_array_buffer; glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &last_element_array_buffer);
    GLint last_vertex_array; glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
    GLint last_blend_src; glGetIntegerv(GL_BLEND_SRC, &last_blend_src);
    GLint last_blend_dst; glGetIntegerv(GL_BLEND_DST, &last_blend_dst);
    GLint last_blend_equation_rgb; glGetIntegerv(GL_BLEND_EQUATION_RGB, &last_blend_equation_rgb);
    GLint last_blend_equation_alpha; glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &last_blend_equation_alpha);
    GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport);
    GLint last_scissor_box[4]; glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box); 
    GLboolean last_enable_blend = glIsEnabled(GL_BLEND);
    GLboolean last_enable_cull_face = glIsEnabled(GL_CULL_FACE);
    GLboolean last_enable_depth_test = glIsEnabled(GL_DEPTH_TEST);
    GLboolean last_enable_scissor_test = glIsEnabled(GL_SCISSOR_TEST);

    // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled
    glEnable(GL_BLEND);
    glBlendEquation(GL_FUNC_ADD);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glDisable(GL_CULL_FACE);
    glDisable(GL_DEPTH_TEST);
    glEnable(GL_SCISSOR_TEST);
    glActiveTexture(GL_TEXTURE0);

    // Setup orthographic projection matrix
    glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height);
    const float ortho_projection[4][4] =
    {
        { 2.0f/io.DisplaySize.x, 0.0f,                   0.0f, 0.0f },
        { 0.0f,                  2.0f/-io.DisplaySize.y, 0.0f, 0.0f },
        { 0.0f,                  0.0f,                  -1.0f, 0.0f },
        {-1.0f,                  1.0f,                   0.0f, 1.0f },
    };
    glUseProgram(g_ShaderHandle);
    glUniform1i(g_AttribLocationTex, 0);
    glUniformMatrix4fv(g_AttribLocationProjMtx, 1, GL_FALSE, &ortho_projection[0][0]);
    glBindVertexArray(g_VaoHandle);

    for (int n = 0; n < draw_data->CmdListsCount; n++)
    {
        const ImDrawList* cmd_list = draw_data->CmdLists[n];
        const ImDrawIdx* idx_buffer_offset = 0;

        glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle);
        glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)cmd_list->VtxBuffer.Size * sizeof(ImDrawVert), (GLvoid*)cmd_list->VtxBuffer.Data, GL_STREAM_DRAW);

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_ElementsHandle);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)cmd_list->IdxBuffer.Size * sizeof(ImDrawIdx), (GLvoid*)cmd_list->IdxBuffer.Data, GL_STREAM_DRAW);

        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
        {
            const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
            if (pcmd->UserCallback)
            {
                pcmd->UserCallback(cmd_list, pcmd);
            }
            else
            {
                glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId);
                glScissor((int)pcmd->ClipRect.x, (int)(fb_height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y));
                glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer_offset);
            }
            idx_buffer_offset += pcmd->ElemCount;
        }
    }

    // Restore modified GL state
    glUseProgram(last_program);
    glActiveTexture(last_active_texture);
    glBindTexture(GL_TEXTURE_2D, last_texture);
    glBindVertexArray(last_vertex_array);
    glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, last_element_array_buffer);
    glBlendEquationSeparate(last_blend_equation_rgb, last_blend_equation_alpha);
    glBlendFunc(last_blend_src, last_blend_dst);
    if (last_enable_blend) glEnable(GL_BLEND); else glDisable(GL_BLEND);
    if (last_enable_cull_face) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE);
    if (last_enable_depth_test) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
    if (last_enable_scissor_test) glEnable(GL_SCISSOR_TEST); else glDisable(GL_SCISSOR_TEST);
    glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]);
    glScissor(last_scissor_box[0], last_scissor_box[1], (GLsizei)last_scissor_box[2], (GLsizei)last_scissor_box[3]);
}
Example #28
0
void CWell::DrawGL(void)
{
	if( m_data.IsEmpty() || !m_bVisible ) return;

	int n;
	int lit;
	int	ipl;
	double* wd;
	WELLIT* wl;

	n = m_data.GetSize();
	wd = m_data.GetData();

	BOOL bLighht =  glIsEnabled(GL_LIGHTING);
	glDisable(GL_LIGHTING);
	if(m_bSolidLog3D)		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	else	{
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	}

	
	for(int i=m_nFormat*3, ip=m_nFormat*2; i<n; i += m_nFormat, ip += m_nFormat) {
		lit = (int) wd[i+m_nFormat-1];
		wl = &m_welLit.GetAt(lit);
		glColor3d(wl->rd, wl->gd, wl->bd);
		glLineWidth( 5 );
		glBegin(GL_LINES);
			glVertex3d(	wd[ip+0], wd[ip+2], -wd[ip+1]);
			glVertex3d(	wd[i+0],  wd[i+2],  -wd[i+1]);
		glEnd();

		// Draw current layer
		glLineWidth(1.0f);
		if( (i % m_nSamplingLog) == 0) {
			for(int j=4; j<m_nFormat-1; j++) {
				if(m_showChannel[j] == TRUE) {
					ipl = i - m_nFormat*m_nSamplingLog;
					if(ipl < m_nFormat*2) ipl = m_nFormat*2;
					double u=m_dLogPieStart*PI/180.0;
					double dU = 2*PI/m_nSamplingRing;	

					//glColor3f(1.0f, 0.0f, 0.0f);
					CPen* pPen = &m_penArray.GetAt(j);
					LOGPEN lp;
					double clr[3];
					pPen->GetLogPen(&lp);
					clr[0] = GetRValue(lp.lopnColor)/255.0;
					clr[1] = GetGValue(lp.lopnColor)/255.0;
					clr[2] = GetBValue(lp.lopnColor)/255.0;
					glColor3dv(clr);
					while (u<(m_dLogPieEnd*PI/180.0)) {
						double	P00[3],P01[3],P10[3],P11[3];
						double dRadip, dRadi;
						dRadi = m_dRadiusLog3D * (wd[i+j] - wd[0+j])/(wd[m_nFormat+j] - wd[0+j]);
						dRadip = m_dRadiusLog3D * (wd[ipl+j] - wd[0+j])/(wd[m_nFormat+j] - wd[0+j]);

						P00[0] = wd[ipl+0] + cos(u)*(dRadip);
						P00[1] = wd[ipl+2];
						P00[2] = -wd[ipl+1] + sin(u)*(dRadip);

						P01[0] = wd[ipl+0] + cos(u+dU)*(dRadip);
						P01[1] = wd[ipl+2];
						P01[2] = -wd[ipl+1] + sin(u+dU)*(dRadip);

						P11[0] = wd[i+0] + cos(u+dU)*(dRadi);
						P11[1] = wd[i+2];
						P11[2] = -wd[i+1] + sin(u+dU)*(dRadi);

						P10[0] = wd[i+0] + cos(u)*(dRadi);
						P10[1] = wd[i+2];
						P10[2] = -wd[i+1] + sin(u)*(dRadi);

						glBegin(GL_QUADS);
							glVertex3dv(P00);
							glVertex3dv(P01);
							glVertex3dv(P11);
							glVertex3dv(P10);
						glEnd();

						u+=dU;
					};
				}
			}
		}
	}
	if(bLighht)		glEnable(GL_LIGHTING);
	else			glDisable(GL_LIGHTING);
}
Example #29
0
void CachedSvgItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
#if defined(Q_OS_WIN)
    // Disable this on windows because the default Qt5 doesn't ship with full OpenGL support
    // https://bugreports.qt-project.org/browse/QTBUG-28715
    // since this is only used for the PFD and the QML PFD is accelerated this is probably
    // a non issue
    QGraphicsSvgItem::paint(painter, option, widget);
#else
    if (painter->paintEngine()->type() != QPaintEngine::OpenGL &&
            painter->paintEngine()->type() != QPaintEngine::OpenGL2) {
        //Fallback to direct painting
        QGraphicsSvgItem::paint(painter, option, widget);
        return;
    }

    QRectF br = boundingRect();
    QTransform transform = painter->worldTransform();
    qreal sceneScale = transform.map(QLineF(0,0,1,0)).length();

    bool stencilTestEnabled = glIsEnabled(GL_STENCIL_TEST);
    bool scissorTestEnabled = glIsEnabled(GL_SCISSOR_TEST);

    painter->beginNativePainting();

    if (stencilTestEnabled)
        glEnable(GL_STENCIL_TEST);
    if (scissorTestEnabled)
        glEnable(GL_SCISSOR_TEST);

    bool dirty = false;
    if (!m_texture) {
        glGenTextures(1, &m_texture);
        m_context = const_cast<QGLContext*>(QGLContext::currentContext());

        dirty = true;
    }

    if (!qFuzzyCompare(sceneScale, m_scale)) {
        m_scale = sceneScale;
        dirty = true;
    }

    int textureWidth = (int(br.width()*m_scale) + 3) & ~3;
    int textureHeight = (int(br.height()*m_scale) + 3) & ~3;

    if (dirty) {
        //qDebug() << "re-render image";

        QImage img(textureWidth, textureHeight, QImage::Format_ARGB32);
        {
            img.fill(Qt::transparent);
            QPainter p;
            p.begin(&img);
            p.setRenderHints(painter->renderHints());
            p.translate(br.topLeft());
            p.scale(m_scale, m_scale);
            QGraphicsSvgItem::paint(&p, option, 0);
            p.end();

            img = img.rgbSwapped();
        }

        glEnable(GL_TEXTURE_2D);

        glBindTexture(GL_TEXTURE_2D, m_texture);
        glTexImage2D(
                GL_TEXTURE_2D,
                0,
                GL_RGBA,
                textureWidth,
                textureHeight,
                0,
                GL_RGBA,
                GL_UNSIGNED_BYTE,
                img.bits());

        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

        glDisable(GL_TEXTURE_2D);

        dirty = false;
    }

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_TEXTURE_2D);

    glBindTexture(GL_TEXTURE_2D, m_texture);

    //texture may be slightly large than svn image, ensure only used area is rendered
    qreal tw = br.width()*m_scale/textureWidth;
    qreal th = br.height()*m_scale/textureHeight;

    glBegin(GL_QUADS);
    glTexCoord2d(0,  0 ); glVertex3d(br.left(), br.top(), -1);
    glTexCoord2d(tw, 0 ); glVertex3d(br.right(), br.top(), -1);
    glTexCoord2d(tw, th); glVertex3d(br.right(), br.bottom(), -1);
    glTexCoord2d(0,  th); glVertex3d(br.left(), br.bottom(), -1);
    glEnd();
    glDisable(GL_TEXTURE_2D);

    painter->endNativePainting();
#endif
}
Example #30
0
void csGLStateCacheContext::InitCache()
{
  int i;
  glGetIntegerv (GL_ALPHA_TEST_FUNC, (GLint*)&parameter_alpha_func);
  glGetFloatv (GL_ALPHA_TEST_REF, &parameter_alpha_ref);
  if (extmgr->CS_GL_EXT_blend_func_separate)
  {
    glGetIntegerv (GL_BLEND_SRC_RGB_EXT, (GLint*)&blend_sourceRGB);
    glGetIntegerv (GL_BLEND_SRC_ALPHA_EXT, (GLint*)&blend_sourceA);
    glGetIntegerv (GL_BLEND_DST_RGB_EXT, (GLint*)&blend_destinationRGB);
    glGetIntegerv (GL_BLEND_DST_ALPHA_EXT, (GLint*)&blend_destinationA);
  }
  else
  {
    glGetIntegerv (GL_BLEND_SRC, (GLint*)&blend_sourceRGB);
    blend_sourceA = blend_sourceRGB;
    glGetIntegerv (GL_BLEND_DST, (GLint*)&blend_destinationRGB);
    blend_destinationA = blend_destinationRGB;
  }
  glGetIntegerv (GL_CULL_FACE_MODE, (GLint*)&parameter_cull_mode);
  glGetIntegerv (GL_DEPTH_FUNC, (GLint*)&parameter_depth_func);
  glGetBooleanv (GL_DEPTH_WRITEMASK, &parameter_depth_mask);
  glGetIntegerv (GL_SHADE_MODEL, (GLint*)&parameter_shade_model);
  glGetIntegerv (GL_STENCIL_BITS, (GLint*)&parameter_maskl);
  glGetIntegerv (GL_STENCIL_FUNC, (GLint*)&parameter_stencil_func);
  glGetIntegerv (GL_STENCIL_VALUE_MASK, (GLint*)&parameter_stencil_mask);
  glGetIntegerv (GL_STENCIL_REF, &parameter_stencil_ref);
  glGetIntegerv (GL_STENCIL_FAIL, (GLint*)&parameter_stencil_fail);
  glGetIntegerv (GL_STENCIL_PASS_DEPTH_FAIL, (GLint*)&parameter_stencil_zfail);
  glGetIntegerv (GL_STENCIL_PASS_DEPTH_PASS, (GLint*)&parameter_stencil_zpass);
  glGetIntegerv (GL_MATRIX_MODE, (GLint*)&parameter_matrixMode);
  GLboolean writemask[4];
  glGetBooleanv (GL_COLOR_WRITEMASK, writemask);
  parameter_wmRed = writemask[0];
  parameter_wmGreen = writemask[1];
  parameter_wmBlue = writemask[2];
  parameter_wmAlpha = writemask[3];
  enabled_GL_DEPTH_TEST = (glIsEnabled (GL_DEPTH_TEST) == GL_TRUE);
  enabled_GL_BLEND = (glIsEnabled (GL_BLEND) == GL_TRUE);
  enabled_GL_DITHER = (glIsEnabled (GL_DITHER) == GL_TRUE);
  enabled_GL_STENCIL_TEST = (glIsEnabled (GL_STENCIL_TEST) == GL_TRUE);
  enabled_GL_CULL_FACE = (glIsEnabled (GL_CULL_FACE) == GL_TRUE);
  enabled_GL_POLYGON_OFFSET_FILL = (glIsEnabled (GL_POLYGON_OFFSET_FILL) == GL_TRUE);
  enabled_GL_LIGHTING = (glIsEnabled (GL_LIGHTING) == GL_TRUE);
  enabled_GL_ALPHA_TEST = (glIsEnabled (GL_ALPHA_TEST) == GL_TRUE);
  enabled_GL_TEXTURE_GEN_S = (glIsEnabled (GL_TEXTURE_GEN_S) == GL_TRUE);
  enabled_GL_TEXTURE_GEN_T = (glIsEnabled (GL_TEXTURE_GEN_T) == GL_TRUE);
  enabled_GL_TEXTURE_GEN_R = (glIsEnabled (GL_TEXTURE_GEN_R) == GL_TRUE);
  enabled_GL_TEXTURE_GEN_Q = (glIsEnabled (GL_TEXTURE_GEN_Q) == GL_TRUE);
  enabled_GL_FOG = (glIsEnabled (GL_FOG) == GL_TRUE);

  memset (boundtexture.p, 0, numImageUnits * sizeof (GLuint));
  currentImageUnit = 0;
  currentTCUnit = 0;
  memset (activeUnit, 0, sizeof (activeUnit));
  if (extmgr->CS_GL_ARB_multitexture)
  {
    for (i = numImageUnits; i-- > 0; )
    {
      extmgr->glActiveTextureARB (GL_TEXTURE0_ARB + i);
      enabled_GL_TEXTURE_1D[i] = (glIsEnabled (GL_TEXTURE_1D) == GL_TRUE);
      enabled_GL_TEXTURE_2D[i] = (glIsEnabled (GL_TEXTURE_2D) == GL_TRUE);
      enabled_GL_TEXTURE_3D[i] = (glIsEnabled (GL_TEXTURE_3D) == GL_TRUE);
      enabled_GL_TEXTURE_CUBE_MAP[i] = (glIsEnabled (GL_TEXTURE_CUBE_MAP) == GL_TRUE);
	if (extmgr->CS_GL_ARB_texture_rectangle
	  || extmgr->CS_GL_EXT_texture_rectangle
	  || extmgr->CS_GL_NV_texture_rectangle)
	  enabled_GL_TEXTURE_RECTANGLE_ARB[i] = (glIsEnabled (GL_TEXTURE_RECTANGLE_ARB) == GL_TRUE);
	else
	  enabled_GL_TEXTURE_RECTANGLE_ARB[i] = false;
    }
    for (i = numTexCoords; i-- > 0; )
    {
      extmgr->glClientActiveTextureARB (GL_TEXTURE0_ARB + i);
      enabled_GL_TEXTURE_COORD_ARRAY[i] = (glIsEnabled (GL_TEXTURE_COORD_ARRAY) == GL_TRUE);
      glGetIntegerv (GL_TEXTURE_COORD_ARRAY_SIZE, (GLint*)&parameter_tsize[i]);
      glGetIntegerv (GL_TEXTURE_COORD_ARRAY_STRIDE, (GLint*)&parameter_tstride[i]);
      glGetIntegerv (GL_TEXTURE_COORD_ARRAY_TYPE, (GLint*)&parameter_ttype[i]);
      glGetPointerv (GL_TEXTURE_COORD_ARRAY_POINTER, &parameter_tpointer[i]);
	if (extmgr->CS_GL_ARB_vertex_buffer_object)
	  glGetIntegerv (GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB,
	    (GLint*)&parameter_tvbo[i]);
    }
  } 
  else 
  {
    enabled_GL_TEXTURE_1D[0] = (glIsEnabled (GL_TEXTURE_1D) == GL_TRUE);
    enabled_GL_TEXTURE_2D[0] = (glIsEnabled (GL_TEXTURE_2D) == GL_TRUE);
    enabled_GL_TEXTURE_3D[0] = (glIsEnabled (GL_TEXTURE_3D) == GL_TRUE);
    enabled_GL_TEXTURE_CUBE_MAP[0] = (glIsEnabled (GL_TEXTURE_CUBE_MAP) == GL_TRUE);
    enabled_GL_TEXTURE_COORD_ARRAY[0] = (glIsEnabled (GL_TEXTURE_COORD_ARRAY) == GL_TRUE);
	if (extmgr->CS_GL_ARB_texture_rectangle
	  || extmgr->CS_GL_EXT_texture_rectangle
	  || extmgr->CS_GL_NV_texture_rectangle)
	  enabled_GL_TEXTURE_RECTANGLE_ARB[0] = (glIsEnabled (GL_TEXTURE_RECTANGLE_ARB) == GL_TRUE);
	else
	  enabled_GL_TEXTURE_RECTANGLE_ARB[0] = false;
    glGetIntegerv (GL_TEXTURE_COORD_ARRAY_SIZE, (GLint*)&parameter_tsize[0]);
    glGetIntegerv (GL_TEXTURE_COORD_ARRAY_STRIDE, (GLint*)&parameter_tstride[0]);
    glGetIntegerv (GL_TEXTURE_COORD_ARRAY_TYPE, (GLint*)&parameter_ttype[0]);
    glGetPointerv (GL_TEXTURE_COORD_ARRAY_POINTER, &parameter_tpointer[0]);
    if (extmgr->CS_GL_ARB_vertex_buffer_object)
	glGetIntegerv (GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB,
	  (GLint*)&parameter_tvbo[0]);
    for (i = 1 ; i < numImageUnits; i++)
    {
      enabled_GL_TEXTURE_1D[i] = enabled_GL_TEXTURE_1D[0];
      enabled_GL_TEXTURE_2D[i] = enabled_GL_TEXTURE_2D[0];
      enabled_GL_TEXTURE_3D[i] = enabled_GL_TEXTURE_3D[0];
      enabled_GL_TEXTURE_CUBE_MAP[i] = enabled_GL_TEXTURE_CUBE_MAP[0];
      enabled_GL_TEXTURE_COORD_ARRAY[i] = enabled_GL_TEXTURE_COORD_ARRAY[0];
	enabled_GL_TEXTURE_RECTANGLE_ARB[i] = enabled_GL_TEXTURE_RECTANGLE_ARB[0];
	parameter_tsize[i] = parameter_tsize[0];
	parameter_tstride[i] = parameter_tstride[0];
	parameter_ttype[i] = parameter_ttype[0];
	parameter_tpointer[i] = parameter_tpointer[0];
    }
  }
  enabled_GL_SCISSOR_TEST = (glIsEnabled (GL_SCISSOR_TEST) == GL_TRUE);
  enabled_GL_VERTEX_ARRAY = (glIsEnabled (GL_VERTEX_ARRAY) == GL_TRUE);
  enabled_GL_COLOR_ARRAY = (glIsEnabled (GL_COLOR_ARRAY) == GL_TRUE);
  if (extmgr->CS_GL_EXT_secondary_color)
    enabled_GL_SECONDARY_COLOR_ARRAY_EXT = 
      (glIsEnabled (GL_SECONDARY_COLOR_ARRAY_EXT) == GL_TRUE);
  else
    enabled_GL_SECONDARY_COLOR_ARRAY_EXT = false;
  enabled_GL_NORMAL_ARRAY = (glIsEnabled (GL_NORMAL_ARRAY) == GL_TRUE);
  
  if (extmgr->CS_GL_ARB_vertex_program)
    enabled_GL_VERTEX_PROGRAM_POINT_SIZE_ARB =
      (glIsEnabled (GL_VERTEX_PROGRAM_POINT_SIZE_ARB) == GL_TRUE);
  else
    enabled_GL_VERTEX_PROGRAM_POINT_SIZE_ARB = false;
  if (extmgr->CS_GL_ARB_point_sprite)
    enabled_GL_POINT_SPRITE_ARB =
      (glIsEnabled (GL_POINT_SPRITE_ARB) == GL_TRUE);
  else
    enabled_GL_POINT_SPRITE_ARB = false;

  memset (currentBufferID, 0, sizeof (currentBufferID));
  {
    enum { extVBO = 1, extPBO = 2 };
    static const GLenum requiredExt[boCount] =
    { extVBO, extVBO, extPBO, extPBO };
    
    int boExt = 0;
    if (extmgr->CS_GL_ARB_vertex_buffer_object) boExt |= extVBO;
    if (extmgr->CS_GL_ARB_pixel_buffer_object) boExt |= extPBO;
    for (int b = 0; b < boCount; b++)
    {
	if (requiredExt[b] & boExt)
	{
	  static const GLenum localIndexToGLBufferBinding[boCount] =
	  { GL_ARRAY_BUFFER_BINDING_ARB, GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB, 
	    GL_PIXEL_PACK_BUFFER_BINDING_ARB, GL_PIXEL_UNPACK_BUFFER_BINDING_ARB };
	  glGetIntegerv (localIndexToGLBufferBinding[b], 
	    (GLint*)&activeBufferID[b]);
	}
    }
  }

  memset (currentBufferID, 0, sizeof (currentBufferID));
  {
    static const GLenum localIndexToGLBufferBinding[boCount] =
    { GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB, GL_ARRAY_BUFFER_BINDING_ARB, 
	GL_PIXEL_PACK_BUFFER_BINDING_ARB, GL_PIXEL_UNPACK_BUFFER_BINDING_ARB };

    enum { extVBO = 1, extPBO = 2 };
    static const GLenum requiredExt[boCount] =
    { extVBO, extVBO, extPBO, extPBO };
    
    int boExt = 0;
    if (extmgr->CS_GL_ARB_vertex_buffer_object) boExt |= extVBO;
    if (extmgr->CS_GL_ARB_pixel_buffer_object) boExt |= extPBO;
    for (int b = 0; b < boCount; b++)
    {
	if (requiredExt[b] & boExt)
	{
	  glGetIntegerv (localIndexToGLBufferBinding[b], 
	    (GLint*)&currentBufferID[b]);
	}
    }
  }

  glGetIntegerv (GL_VERTEX_ARRAY_SIZE, (GLint*)&parameter_vsize);
  glGetIntegerv (GL_VERTEX_ARRAY_STRIDE, (GLint*)&parameter_vstride);
  glGetIntegerv (GL_VERTEX_ARRAY_TYPE, (GLint*)&parameter_vtype);
  glGetPointerv (GL_VERTEX_ARRAY_POINTER, &parameter_vpointer);
  if (extmgr->CS_GL_ARB_vertex_buffer_object)
    glGetIntegerv (GL_VERTEX_ARRAY_BUFFER_BINDING_ARB, (GLint*)&parameter_vvbo);

  glGetIntegerv (GL_NORMAL_ARRAY_STRIDE, (GLint*)&parameter_nstride);
  glGetIntegerv (GL_NORMAL_ARRAY_TYPE, (GLint*)&parameter_ntype);
  glGetPointerv (GL_NORMAL_ARRAY_POINTER, &parameter_npointer);
  if (extmgr->CS_GL_ARB_vertex_buffer_object)
    glGetIntegerv (GL_NORMAL_ARRAY_BUFFER_BINDING_ARB, (GLint*)&parameter_nvbo);

  glGetIntegerv (GL_COLOR_ARRAY_SIZE, (GLint*)&parameter_csize);
  glGetIntegerv (GL_COLOR_ARRAY_STRIDE, (GLint*)&parameter_cstride);
  glGetIntegerv (GL_COLOR_ARRAY_TYPE, (GLint*)&parameter_ctype);
  glGetPointerv (GL_COLOR_ARRAY_POINTER, &parameter_cpointer);
  if (extmgr->CS_GL_ARB_vertex_buffer_object)
    glGetIntegerv (GL_COLOR_ARRAY_BUFFER_BINDING_ARB, (GLint*)&parameter_cvbo);
  
  if (extmgr->CS_GL_EXT_secondary_color)
  {
    glGetIntegerv (GL_SECONDARY_COLOR_ARRAY_SIZE_EXT, 
      (GLint*)&parameter_scsize);
    glGetIntegerv (GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT, 
      (GLint*)&parameter_scstride);
    glGetIntegerv (GL_SECONDARY_COLOR_ARRAY_TYPE_EXT, 
      (GLint*)&parameter_sctype);
    glGetPointerv (GL_SECONDARY_COLOR_ARRAY_POINTER_EXT, 
      &parameter_scpointer);
    if (extmgr->CS_GL_ARB_vertex_buffer_object)
	glGetIntegerv (GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB,
	  (GLint*)&parameter_scvbo);
    enabled_GL_COLOR_SUM_EXT = glIsEnabled (GL_COLOR_SUM_EXT) != GL_FALSE;
  }
  else
  {
    parameter_scsize = 0;
    parameter_scstride = 0;
    parameter_sctype = 0;
    parameter_scpointer = 0;
    enabled_GL_COLOR_SUM_EXT = false;
  }
  
  glGetIntegerv (GL_UNPACK_ALIGNMENT, &pixelUnpackAlignment);
  GLint v;
  glGetIntegerv (GL_UNPACK_SWAP_BYTES, &v);
  pixelUnpackSwapBytes = v != 0;
  
  if (extmgr->CS_GL_ARB_color_buffer_float)
  {
    GLint clampState;
    glGetIntegerv (GL_CLAMP_VERTEX_COLOR_ARB, &clampState);
    this->clampState[clampVertex] = (GLenum)clampState;
    glGetIntegerv (GL_CLAMP_FRAGMENT_COLOR_ARB, &clampState);
    this->clampState[clampFragment] = (GLenum)clampState;
    glGetIntegerv (GL_CLAMP_READ_COLOR_ARB, &clampState);
    this->clampState[clampRead] = (GLenum)clampState;
  }
}