Exemple #1
0
int
main(int argc, char *argv[])
{
    unsigned *cloud;
    int texcomps, texwid, texht;

    GLUquadricObj *sphere;

    /* start and end of particles */
    static GLfloat begin[] = {0.f, -25.f, 0.f};
    static GLfloat   end[] = {0.f,-100.f, 0.f};
    static GLfloat fogcolor[] = {.4f, .4f, .4f, 1.f};

    glutInitWindowSize(winwid, winht);
    glutInit(&argc, argv);
    if(argc > 1)
    {
	char *args = argv[1];
	int done = GL_FALSE;
	while(!done)
	{
	    switch(*args)
	    {
	    case 's': /* single buffer */
		printf("Single Buffered\n");
		dblbuf = GL_FALSE;
		break;
	    case '-': /* do nothing */
		break;
	    case 0:
		done = GL_TRUE;
		break;
	    }
	    args++;
	}
    }
    if(dblbuf)
	glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_STENCIL|GLUT_DOUBLE);
    else
	glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_STENCIL);

    (void)glutCreateWindow("snow demo");

    glutDisplayFunc(redraw);
    glutReshapeFunc(reshape);
    glutMouseFunc(mouse);
    glutMotionFunc(motion);
    glutKeyboardFunc(key);
    glutIdleFunc(idle);

    glutCreateMenu(menu);
    glutAddMenuEntry("Toggle Overcast (o, O)", OVERCAST);
    glutAddMenuEntry("Toggle Fog (f, F)", FOG);
    glutAddMenuEntry("Toggle Snow (s, S)", SNOW);
    glutAddMenuEntry("Bigger Flakes (+)", BIGGER);
    glutAddMenuEntry("Smaller Flakes (-)", SMALLER);
    glutAddMenuEntry("Reset Flake Size to One (r, R)", RESETSIZE);
    glutAddMenuEntry("Toggle Point Antialiasing (a, A)", ANTIALIAS);
    glutAddMenuEntry("Snow Blending (b, B)", BLEND);
    glutAddMenuEntry("Exit Program", EXIT);
    glutAttachMenu(GLUT_RIGHT_BUTTON);

    printf("OpenGL Version %s\n", glGetString(GL_VERSION));

    /* draw a perspective scene */
    glMatrixMode(GL_PROJECTION);
    glFrustum(-5., 5., -5., 5., 10., 1000.); 
    glMatrixMode(GL_MODELVIEW);
    updateMV();

    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    /* turn on features */
    glEnable(GL_DEPTH_TEST);

    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);

    /* place light 0 in the right place */
    glLightfv(GL_LIGHT0, GL_POSITION, lightpos);

    glClearColor(0.f, 0.f, 1.f, 1.f);
    glFogfv(GL_FOG_COLOR, fogcolor);
    glFogi(GL_FOG_MODE, GL_LINEAR);
    glFogf(GL_FOG_START, -200.f);
    glFogf(GL_FOG_END, 200.f);
    glHint(GL_FOG_HINT, GL_NICEST);


    glEnable(GL_COLOR_MATERIAL);
    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);

    /* makes texturing faster, and looks better than GL_LINEAR */
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

    glNewList(LIGHT, GL_COMPILE);
    glDisable(GL_LIGHTING);
    sphere = gluNewQuadric();
    glColor3f(.7f, .2f, .7f);
    gluSphere(sphere, 5.f, 10, 10);
    gluDeleteQuadric(sphere);
    glEnable(GL_LIGHTING);
    glEndList();

    

    /* 10 X 20; vary size with transforms */
    /* one corner of house on origin; bottom on xz plane */
    glNewList(HOUSE, GL_COMPILE);
    glBegin(GL_QUADS);
    /* walls of house */
    glColor3f(1.f, 1.f, 0.f);
    /* front */
    glNormal3f( 0.f, 0.f, 1.f);
    glVertex3i( 0, 0, 0);
    glVertex3i(10, 0, 0);
    glVertex3i(10,10, 0);
    glVertex3i( 0,10, 0);
    /* back */
    glNormal3f( 0.f, 0.f, -1.f);
    glVertex3i( 0, 0, -20);
    glVertex3i( 0,10, -20);
    glVertex3i(10,10, -20);
    glVertex3i(10, 0, -20);
    /* left */
    glNormal3f(-1,  0.f,   0.f);
    glVertex3i( 0,  0,   0);
    glVertex3i( 0, 10,   0);
    glVertex3i( 0, 10, -20);
    glVertex3i( 0,  0, -20);
    /* right */
    glNormal3f( 1.f,  0.f,   0.f);
    glVertex3i(10,  0,   0);
    glVertex3i(10,  0, -20);
    glVertex3i(10, 10, -20);
    glVertex3i(10, 10,   0);
    /* roof of house */
    glColor3f(.8f, .1f, .1f);
    /* left top */
    glNormal3f(-.707f, .707f, 0.f);
    glVertex3i( 0, 10,   0);
    glVertex3i( 5, 15,   0);
    glVertex3i( 5, 15, -20);
    glVertex3i( 0, 10, -20);
    /* right top */
    glNormal3f( .707f, .707f, 0.f);
    glVertex3i(10, 10,   0);
    glVertex3i(10, 10, -20);
    glVertex3i( 5, 15, -20);
    glVertex3i( 5, 15,   0);
    glEnd();

    glBegin(GL_TRIANGLES);
    /* front */
    glNormal3f( 0.f,  0.f, 1.f);
    glVertex3i( 0, 10, 0);
    glVertex3i(10, 10, 0);
    glVertex3i( 5, 15, 0);
    /* back */
    glNormal3f( 0.f,  0.f,  -1.f);
    glVertex3i( 0, 10, -20);
    glVertex3i( 5, 15, -20);
    glVertex3i(10, 10, -20);
    glEnd();
    glEndList();

    glEnable(GL_CULL_FACE);
    /* load pattern for current 2d texture */

    cloud = read_texture("../../data/clouds.bw",
			    &texwid, &texht, &texcomps);

    gluBuild2DMipmaps(GL_TEXTURE_2D, GL_LUMINANCE, texwid, texht, GL_RGBA,
		      GL_UNSIGNED_BYTE, cloud);

    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);

    free(cloud);
    initpart(&psys, begin, end, 200, 6000);
    updateptr = updatepart0;

    CHECK_ERROR("main()");
    glutMainLoop();

    return 0;
}
Exemple #2
0
/* Initialize broad parameters for OpenGL */
void EDA_3D_CANVAS::InitGL()
{
    wxSize size = GetClientSize();

    if( !m_init )
    {
        m_init = true;
        g_Parm_3D_Visu.m_Zoom = 1.0;
        m_ZBottom = 1.0;
        m_ZTop = 10.0;

        glDisable( GL_CULL_FACE );      // show back faces

        glEnable( GL_DEPTH_TEST );      // Enable z-buferring

        glEnable( GL_LINE_SMOOTH );
        glEnable( GL_COLOR_MATERIAL );
        glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );

        /* speedups */
        glEnable( GL_DITHER );
        glShadeModel( GL_SMOOTH );
        glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_DONT_CARE );
        glHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
        glHint( GL_POLYGON_SMOOTH_HINT, GL_NICEST );    // can be GL_FASTEST

        /* blend */
        glEnable( GL_BLEND );
        glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
    }

    // set viewing projection

    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();

#define MAX_VIEW_ANGLE 160.0 / 45.0
    if( g_Parm_3D_Visu.m_Zoom > MAX_VIEW_ANGLE )
        g_Parm_3D_Visu.m_Zoom = MAX_VIEW_ANGLE;

     if( Parent()->ModeIsOrtho() )
     {
         // OrthoReductionFactor is chosen so as to provide roughly the same size as
         // Perspective View
         const double orthoReductionFactor = 400 / g_Parm_3D_Visu.m_Zoom;

         // Initialize Projection Matrix for Ortographic View
         glOrtho( -size.x / orthoReductionFactor, size.x / orthoReductionFactor,
                  -size.y / orthoReductionFactor, size.y / orthoReductionFactor, 1, 10 );
     }
     else
     {
         // Ratio width / height of the window display
         double ratio_HV = (double) size.x / size.y;

         // Initialize Projection Matrix for Perspective View
         gluPerspective( 45.0 * g_Parm_3D_Visu.m_Zoom, ratio_HV, 1, 10 );
     }


    // position viewer
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();
    glTranslatef( 0.0F, 0.0F, -( m_ZBottom + m_ZTop) / 2 );

    // clear color and depth buffers
    glClearColor( g_Parm_3D_Visu.m_BgColor.m_Red,
                  g_Parm_3D_Visu.m_BgColor.m_Green,
                  g_Parm_3D_Visu.m_BgColor.m_Blue, 1 );
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    // Setup light sources:
    SetLights();

    CheckGLError();
}
Exemple #3
0
void ccGenericMesh::drawMeOnly(CC_DRAW_CONTEXT& context)
{
	ccGenericPointCloud* vertices = getAssociatedCloud();
	if (!vertices)
		return;

	handleColorRamp(context);

	//3D pass
	if (MACRO_Draw3D(context))
	{
		//any triangle?
		unsigned triNum = size();
		if (triNum == 0)
			return;

		//L.O.D.
		bool lodEnabled = (triNum > GET_MAX_LOD_FACES_NUMBER() && context.decimateMeshOnMove && MACRO_LODActivated(context));
		unsigned decimStep = (lodEnabled ? (unsigned)ceil((float)triNum*3 / (float)GET_MAX_LOD_FACES_NUMBER()) : 1);
		unsigned displayedTriNum = triNum / decimStep;

		//display parameters
		glDrawParams glParams;
		getDrawingParameters(glParams);
		glParams.showNorms &= bool(MACRO_LightIsEnabled(context));

		//vertices visibility
		const ccGenericPointCloud::VisibilityTableType* verticesVisibility = vertices->getTheVisibilityArray();
		bool visFiltering = (verticesVisibility && verticesVisibility->isAllocated());

		//wireframe ? (not compatible with LOD)
		bool showWired = isShownAsWire() && !lodEnabled;

		//per-triangle normals?
		bool showTriNormals = (hasTriNormals() && triNormsShown());
		//fix 'showNorms'
        glParams.showNorms = showTriNormals || (vertices->hasNormals() && m_normalsDisplayed);

		//materials & textures
		bool applyMaterials = (hasMaterials() && materialsShown());
		bool showTextures = (hasTextures() && materialsShown() && !lodEnabled);

		//GL name pushing
		bool pushName = MACRO_DrawEntityNames(context);
		//special case: triangle names pushing (for picking)
		bool pushTriangleNames = MACRO_DrawTriangleNames(context);
		pushName |= pushTriangleNames;

		if (pushName)
		{
			//not fast at all!
			if (MACRO_DrawFastNamesOnly(context))
				return;
			glPushName(getUniqueIDForDisplay());
			//minimal display for picking mode!
			glParams.showNorms = false;
			glParams.showColors = false;
			//glParams.showSF --> we keep it only if SF 'NaN' values are hidden
			showTriNormals = false;
			applyMaterials = false;
			showTextures = false;
		}

		//in the case we need to display scalar field colors
		ccScalarField* currentDisplayedScalarField = 0;
		bool greyForNanScalarValues = true;
		unsigned colorRampSteps = 0;
		ccColorScale::Shared colorScale(0);

		if (glParams.showSF)
		{
			assert(vertices->isA(CC_POINT_CLOUD));
			ccPointCloud* cloud = static_cast<ccPointCloud*>(vertices);

			greyForNanScalarValues = (cloud->getCurrentDisplayedScalarField() && cloud->getCurrentDisplayedScalarField()->areNaNValuesShownInGrey());
			if (greyForNanScalarValues && pushName)
			{
				//in picking mode, no need to take SF into account if we don't hide any points!
				glParams.showSF = false;
			}
			else
			{
				currentDisplayedScalarField = cloud->getCurrentDisplayedScalarField();
				colorScale = currentDisplayedScalarField->getColorScale();
				colorRampSteps = currentDisplayedScalarField->getColorRampSteps();

				assert(colorScale);
				//get default color ramp if cloud has no scale associated?!
				if (!colorScale)
					colorScale = ccColorScalesManager::GetUniqueInstance()->getDefaultScale(ccColorScalesManager::BGYR);
			}
		}

		//materials or color?
		bool colorMaterial = false;
		if (glParams.showSF || glParams.showColors)
		{
			applyMaterials = false;
			colorMaterial = true;
			glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
			glEnable(GL_COLOR_MATERIAL);
		}

		//in the case we need to display vertex colors
		ColorsTableType* rgbColorsTable = 0;
		if (glParams.showColors)
		{
			if (isColorOverriden())
			{
				glColor3ubv(m_tempColor);
				glParams.showColors = false;
			}
			else
			{
				assert(vertices->isA(CC_POINT_CLOUD));
				rgbColorsTable = static_cast<ccPointCloud*>(vertices)->rgbColors();
			}
		}
		else
		{
			glColor3fv(context.defaultMat.diffuseFront);
		}

		if (glParams.showNorms)
		{
			//DGM: Strangely, when Qt::renderPixmap is called, the OpenGL version can fall to 1.0!
			glEnable((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2 ? GL_RESCALE_NORMAL : GL_NORMALIZE));
			glEnable(GL_LIGHTING);
			context.defaultMat.applyGL(true,colorMaterial);
		}

		//in the case we need normals (i.e. lighting)
		NormsIndexesTableType* normalsIndexesTable = 0;
		ccNormalVectors* compressedNormals = 0;
		if (glParams.showNorms)
		{
			assert(vertices->isA(CC_POINT_CLOUD));
			normalsIndexesTable = static_cast<ccPointCloud*>(vertices)->normals();
			compressedNormals = ccNormalVectors::GetUniqueInstance();
		}

		//stipple mask
		if (stipplingEnabled())
			EnableGLStippleMask(true);

		if (!pushTriangleNames && !visFiltering && !(applyMaterials || showTextures) && (!glParams.showSF || greyForNanScalarValues))
		{
			//the GL type depends on the PointCoordinateType 'size' (float or double)
			GLenum GL_COORD_TYPE = sizeof(PointCoordinateType) == 4 ? GL_FLOAT : GL_DOUBLE;
			
			glEnableClientState(GL_VERTEX_ARRAY);
			glVertexPointer(3,GL_COORD_TYPE,0,GetVertexBuffer());

			if (glParams.showNorms)
			{
				glEnableClientState(GL_NORMAL_ARRAY);
				glNormalPointer(GL_COORD_TYPE,0,GetNormalsBuffer());
			}
			if (glParams.showSF || glParams.showColors)
			{
				glEnableClientState(GL_COLOR_ARRAY);
				glColorPointer(3,GL_UNSIGNED_BYTE,0,GetColorsBuffer());
			}

			//we can scan and process each chunk separately in an optimized way
			//we mimic the way ccMesh beahves by using virtual chunks!
			unsigned chunks = static_cast<unsigned>(ceil((double)displayedTriNum/(double)MAX_NUMBER_OF_ELEMENTS_PER_CHUNK));
			unsigned chunkStart = 0;
			const colorType* col = 0;
			for (unsigned k=0; k<chunks; ++k, chunkStart += MAX_NUMBER_OF_ELEMENTS_PER_CHUNK)
			{
				//virtual chunk size
				const unsigned chunkSize = k+1 < chunks ? MAX_NUMBER_OF_ELEMENTS_PER_CHUNK : (displayedTriNum % MAX_NUMBER_OF_ELEMENTS_PER_CHUNK);

				//vertices
				PointCoordinateType* _vertices = GetVertexBuffer();
				for (unsigned n=0; n<chunkSize; n+=decimStep)
				{
					const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n);
					memcpy(_vertices,vertices->getPoint(ti->i1)->u,sizeof(PointCoordinateType)*3);
					_vertices+=3;
					memcpy(_vertices,vertices->getPoint(ti->i2)->u,sizeof(PointCoordinateType)*3);
					_vertices+=3;
					memcpy(_vertices,vertices->getPoint(ti->i3)->u,sizeof(PointCoordinateType)*3);
					_vertices+=3;
				}

				//scalar field
				if (glParams.showSF)
				{
					colorType* _rgbColors = GetColorsBuffer();
					assert(colorScale);
					for (unsigned n=0; n<chunkSize; n+=decimStep)
					{
						const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n);
						col = currentDisplayedScalarField->getValueColor(ti->i1);
						memcpy(_rgbColors,col,sizeof(colorType)*3);
						_rgbColors += 3;
						col = currentDisplayedScalarField->getValueColor(ti->i2);
						memcpy(_rgbColors,col,sizeof(colorType)*3);
						_rgbColors += 3;
						col = currentDisplayedScalarField->getValueColor(ti->i3);
						memcpy(_rgbColors,col,sizeof(colorType)*3);
						_rgbColors += 3;
					}
				}
				//colors
				else if (glParams.showColors)
				{
					colorType* _rgbColors = GetColorsBuffer();

					for (unsigned n=0; n<chunkSize; n+=decimStep)
					{
						const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n);
						memcpy(_rgbColors,rgbColorsTable->getValue(ti->i1),sizeof(colorType)*3);
						_rgbColors += 3;
						memcpy(_rgbColors,rgbColorsTable->getValue(ti->i2),sizeof(colorType)*3);
						_rgbColors += 3;
						memcpy(_rgbColors,rgbColorsTable->getValue(ti->i3),sizeof(colorType)*3);
						_rgbColors += 3;
					}
				}

				//normals
				if (glParams.showNorms)
				{
					PointCoordinateType* _normals = GetNormalsBuffer();
					if (showTriNormals)
					{
						for (unsigned n=0; n<chunkSize; n+=decimStep)
						{
							CCVector3 Na, Nb, Nc;
							getTriangleNormals(chunkStart + n, Na, Nb, Nc);
							memcpy(_normals,Na.u,sizeof(PointCoordinateType)*3);
							_normals+=3;
							memcpy(_normals,Nb.u,sizeof(PointCoordinateType)*3);
							_normals+=3;
							memcpy(_normals,Nc.u,sizeof(PointCoordinateType)*3);
							_normals+=3;
						}
					}
					else
					{
						for (unsigned n=0; n<chunkSize; n+=decimStep)
						{
							const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n);
							memcpy(_normals,vertices->getPointNormal(ti->i1),sizeof(PointCoordinateType)*3);
							_normals+=3;
							memcpy(_normals,vertices->getPointNormal(ti->i2),sizeof(PointCoordinateType)*3);
							_normals+=3;
							memcpy(_normals,vertices->getPointNormal(ti->i3),sizeof(PointCoordinateType)*3);
							_normals+=3;
						}
					}
				}

				if (!showWired)
				{
					glDrawArrays(lodEnabled ? GL_POINTS : GL_TRIANGLES,0,(chunkSize/decimStep)*3);
				}
				else
				{
					glDrawElements(GL_LINES,(chunkSize/decimStep)*6,GL_UNSIGNED_INT,GetWireVertexIndexes());
				}
			}

			//disable arrays
			glDisableClientState(GL_VERTEX_ARRAY);
			if (glParams.showNorms)
				glDisableClientState(GL_NORMAL_ARRAY);
			if (glParams.showSF || glParams.showColors)
				glDisableClientState(GL_COLOR_ARRAY);
		}
		else
		{
			//current vertex color
			const colorType *col1=0,*col2=0,*col3=0;
			//current vertex normal
			const PointCoordinateType *N1=0,*N2=0,*N3=0;
			//current vertex texture coordinates
			float *Tx1=0,*Tx2=0,*Tx3=0;

			//loop on all triangles
			int lasMtlIndex = -1;

			if (showTextures)
			{
				//#define TEST_TEXTURED_BUNDLER_IMPORT
#ifdef TEST_TEXTURED_BUNDLER_IMPORT
				glPushAttrib(GL_COLOR_BUFFER_BIT);
				glEnable(GL_BLEND);
				glBlendFunc(context.sourceBlend, context.destBlend);
#endif

				glEnable(GL_TEXTURE_2D);
			}

			if (pushTriangleNames)
				glPushName(0);

			GLenum triangleDisplayType = lodEnabled ? GL_POINTS : showWired ? GL_LINE_LOOP : GL_TRIANGLES;
			glBegin(triangleDisplayType);

			//per-triangle normals
			const NormsIndexesTableType* triNormals = getTriNormsTable();
			//materials
			const ccMaterialSet* materials = getMaterialSet();

			for (unsigned n=0; n<triNum; ++n)
			{
				//current triangle vertices
				const CCLib::TriangleSummitsIndexes* tsi = getTriangleIndexes(n);

				//LOD: shall we display this triangle?
				if (n % decimStep)
					continue;

				if (visFiltering)
				{
					//we skip the triangle if at least one vertex is hidden
					if ((verticesVisibility->getValue(tsi->i1) != POINT_VISIBLE) ||
						(verticesVisibility->getValue(tsi->i2) != POINT_VISIBLE) ||
						(verticesVisibility->getValue(tsi->i3) != POINT_VISIBLE))
						continue;
				}

				if (glParams.showSF)
				{
					assert(colorScale);
					col1 = currentDisplayedScalarField->getValueColor(tsi->i1);
					if (!col1)
						continue;
					col2 = currentDisplayedScalarField->getValueColor(tsi->i2);
					if (!col2)
						continue;
					col3 = currentDisplayedScalarField->getValueColor(tsi->i3);
					if (!col3)
						continue;
				}
				else if (glParams.showColors)
				{
					col1 = rgbColorsTable->getValue(tsi->i1);
					col2 = rgbColorsTable->getValue(tsi->i2);
					col3 = rgbColorsTable->getValue(tsi->i3);
				}

				if (glParams.showNorms)
				{
					if (showTriNormals)
					{
						assert(triNormals);
						int n1,n2,n3;
						getTriangleNormalIndexes(n,n1,n2,n3);
						N1 = (n1>=0 ? ccNormalVectors::GetNormal(triNormals->getValue(n1)) : 0);
						N2 = (n1==n2 ? N1 : n1>=0 ? ccNormalVectors::GetNormal(triNormals->getValue(n2)) : 0);
						N3 = (n1==n3 ? N1 : n3>=0 ? ccNormalVectors::GetNormal(triNormals->getValue(n3)) : 0);

					}
					else
					{
						N1 = compressedNormals->getNormal(normalsIndexesTable->getValue(tsi->i1));
						N2 = compressedNormals->getNormal(normalsIndexesTable->getValue(tsi->i2));
						N3 = compressedNormals->getNormal(normalsIndexesTable->getValue(tsi->i3));
					}
				}

				if (applyMaterials || showTextures)
				{
					assert(materials);
					int newMatlIndex = this->getTriangleMtlIndex(n);

					//do we need to change material?
					if (lasMtlIndex != newMatlIndex)
					{
						assert(newMatlIndex<(int)materials->size());
						glEnd();
						if (showTextures)
						{
							GLuint texID = (newMatlIndex>=0 ? (*materials)[newMatlIndex].texID : 0);
							if (texID>0)
								assert(glIsTexture(texID));
							glBindTexture(GL_TEXTURE_2D, texID);
						}

						//if we don't have any current material, we apply default one
						(newMatlIndex>=0 ? (*materials)[newMatlIndex] : context.defaultMat).applyGL(glParams.showNorms,false);
						glBegin(triangleDisplayType);
						lasMtlIndex=newMatlIndex;
					}

					if (showTextures)
					{
						getTriangleTexCoordinates(n,Tx1,Tx2,Tx3);
					}
				}

				if (pushTriangleNames)
				{
					glEnd();
					glLoadName(n);
					glBegin(triangleDisplayType);
				}
				else if (showWired)
				{
					glEnd();
					glBegin(triangleDisplayType);
				}

				//vertex 1
				if (N1)
					ccGL::Normal3v(N1);
				if (col1)
					glColor3ubv(col1);
				if (Tx1)
					glTexCoord2fv(Tx1);
				ccGL::Vertex3v(vertices->getPoint(tsi->i1)->u);

				//vertex 2
				if (N2)
					ccGL::Normal3v(N2);
				if (col2)
					glColor3ubv(col2);
				if (Tx2)
					glTexCoord2fv(Tx2);
				ccGL::Vertex3v(vertices->getPoint(tsi->i2)->u);

				//vertex 3
				if (N3)
					ccGL::Normal3v(N3);
				if (col3)
					glColor3ubv(col3);
				if (Tx3)
					glTexCoord2fv(Tx3);
				ccGL::Vertex3v(vertices->getPoint(tsi->i3)->u);
			}

			glEnd();

			if (pushTriangleNames)
				glPopName();

			if (showTextures)
			{
#ifdef TEST_TEXTURED_BUNDLER_IMPORT
				glPopAttrib(); //GL_COLOR_BUFFER_BIT 
#endif
				glBindTexture(GL_TEXTURE_2D, 0);
				glDisable(GL_TEXTURE_2D);
			}
		}

		if (stipplingEnabled())
			EnableGLStippleMask(false);

		if (colorMaterial)
			glDisable(GL_COLOR_MATERIAL);

		if (glParams.showNorms)
		{
			glDisable(GL_LIGHTING);
			glDisable((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2 ? GL_RESCALE_NORMAL : GL_NORMALIZE));
		}

		if (pushName)
			glPopName();
	}
}
Exemple #4
0
/** initialization handler */
ENTRYPOINT void init_chess(ModeInfo *mi) 
{
  Chesscreen *cs;
  int screen = MI_SCREEN(mi);

  if(!qs && 
     !(qs = (Chesscreen *) calloc(MI_NUM_SCREENS(mi), sizeof(Chesscreen))))
    return;
  
  cs = &qs[screen];
  cs->window = MI_WINDOW(mi);
  cs->wire = MI_IS_WIREFRAME(mi);
  cs->trackball = gltrackball_init ();
  
  cs->oldwhite = -1;

  cs->colors[0][0] = 1.0;
  cs->colors[0][1] = 0.5;
  cs->colors[0][2] = 0.0;

  cs->colors[1][0] = 0.6;
  cs->colors[1][1] = 0.6;
  cs->colors[1][2] = 0.6;

  cs->done = 1;
  cs->count = 99;
  cs->mod = 1.4;

/*   cs->position[0] = 0.0; */
/*   cs->position[1] = 5.0; */
/*   cs->position[2] = 5.0; */
/*   cs->position[3] = 1.0; */

  cs->position[0] = 0.0;
  cs->position[1] = 24.0;
  cs->position[2] = 2.0;
  cs->position[3] = 1.0;


  cs->position2[0] = 5.0;
  cs->position2[1] = 5.0;
  cs->position2[2] = 5.0;
  cs->position2[3] = 1.0;

  cs->ground[0] = 0.0;
  cs->ground[1] = 1.0;
  cs->ground[2] = 0.0;
  cs->ground[3] = -0.00001;

  cs->oldgame = -1;


  if((cs->glx_context = init_GL(mi)))
    reshape_chess(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
  else
    MI_CLEARWINDOW(mi);

  if (!cs->wire) {
    glDepthFunc(GL_LEQUAL);
    glClearStencil(0);
    glEnable(GL_CULL_FACE);
    glCullFace(GL_BACK);

    make_piece_texture(cs);
    make_board_texture(cs);
  }
  gen_model_lists( classic, cs->poly_counts);

  if(!cs->wire) {
    setup_lights(cs);
    glColorMaterial(GL_FRONT, GL_DIFFUSE);
    glShadeModel(smooth ? GL_SMOOTH : GL_FLAT);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_DEPTH_TEST);
  }
  else
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
/* Initialises texturing, lighting, display lists, and everything else
   associated with the model. */
void
init_opengl_cinetheodolite(struct_opengl_cinetheodolite * s) {
    s->SIZE_ARTICULATION = 0.5;// for drawing articulations
    //-----------------------------------
    // denavit hartenberg parameters
    //-----------------------------------
    s->type1 = ROTOIDE;
    s->th1 = 0;
    s->d1 = 0.5;
    s->a1 = 0;
    s->alpha1 = -90;
    s->type2 = ROTOIDE;
    s->th2 = 0;
    s->d2 = 0;
    s->a2 = 1;
    s->alpha2 = 0;

    /*--------------------------------------------
     *  pour trace du sol [ largeur et epaisseur ]
     * -------------------------------------------*/
    s->draw_sol = FALSE;
    s->width_sol = 10;
    s->depth_sol = 0.1;
    s->SCALE = 10;

    /*----------------------------------------------------
     *  angles de rotation et  point de vue initial
     * (ne pas modifier sans )
     * --------------------------------------------------- */
    s->view_point_z = -5; // distance of view point = 5m , on z axis of camera
    s->view_y = 180;
    s->view_x = 245;
    s->view_point_x = 0; // distance of view point = 10m , on z axis of camera
    s->view_point_y = 0; // distance of view point = 10m , on z axis of camera

    /*-----------------------------------------------------
     - switches d'affichage
     -----------------------------------------------------*/
    s->shaded = TRUE;
    s->context = _NOANIMATION;
    s->texture = TRUE;
    s->transparent = TRUE;
    s->light1 = TRUE;
    s->light2 = TRUE;




    /*-------------------------------------------------------
     - NE PAS MODIFIER :initialisations  lumieres, textures , images
     --------------------------------------------------------*/
    GLfloat mat_specular[] = {1.0, 1.0, 1.0, 1.0};
    GLfloat mat_shininess[] = {50.0};
    GLfloat light_position1[] = {10.0, 10.0, 10.0, 0.0};
    GLfloat light_position2[] = {-1.0, 1.0, 1.0, 0.0};
    GLfloat mat_emission[] = {0.2, 0.2, 0.2, 0.2};

    glClearColor(0.0, 0.0, 0.0, 0.0);

    s->obj = gluNewQuadric();
    make_image_opengl_cinetheodolite(s);

    /* Set up Texturing */
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glTexImage2D(GL_TEXTURE_2D, 0, 3, IMAGE_WIDTH,
            IMAGE_HEIGHT, 0, GL_RGB, GL_UNSIGNED_BYTE,
            s->image);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

    /* Set up Lighting */
    // glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
    // glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
    glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission);

    //  glLightfv(GL_LIGHT0, GL_POSITION, light_position1);
    //  glLightfv(GL_LIGHT1, GL_POSITION, light_position2);

    /* Initial render mode is with full shading and LIGHT 0
       enabled. */
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    //glEnable(GL_LIGHT1);

    glDepthFunc(GL_LEQUAL);
    glEnable(GL_DEPTH_TEST);
    glDisable(GL_ALPHA_TEST);

    glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
    glEnable(GL_COLOR_MATERIAL);
    glShadeModel(GL_SMOOTH);
    // light gray for background color
    glClearColor(0.6, 0.6, 0.6, 0.0);

    /* Initialise display lists */
    s->params = NULL;
    s->context = _NOANIMATION;

}
Exemple #6
0
int main(int argc, char **argv)
{
    if(cnt<1){
            std::cout<<"main"<<'\n';

            //findAdjustway(MODEL);

            cnt+=1;
    }
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(1000, 500);
    glutCreateWindow("Xshading");

    glutReshapeFunc(myReshape);
    glutDisplayFunc(display);
    glutIdleFunc(spinCube);
    glutMouseFunc(mouseButton);
    glutMotionFunc(mouseMotion);
	glutKeyboardFunc(myKeys);
	glutTimerFunc(33, update, 0);

	glEnable(GL_DEPTH_TEST);
	//Font = FontCreate(wglGetCurrentDC(), "Times", 32, 0, 1);



	//Read model
	MODEL = glmReadOBJ("bunny.obj");//Millennium_Falcon
	glmUnitize(MODEL);
	glmFacetNormals(MODEL);
	glmVertexNormals(MODEL, 60);

    // Light values and coordinates
    GLfloat  ambientLight[] = { 0.1f, 0.1f, 0.1f, 1.0f };
    GLfloat  diffuseLight[] = { 0.7f, 0.7f, 0.7f, 1.0f };
    GLfloat  specular[] = { 5.0f, 0.7f, 0.7f, 1.0f };


    GLfloat  specref[] = { 1.0f, 1.0f, 1.0f, 1.0f };
	GLfloat  shininess = 32.0f;

    // Enable lighting
    glEnable(GL_LIGHTING);

    // Setup and enable light 0
    glLightfv(GL_LIGHT0,GL_AMBIENT,ambientLight);
    glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseLight);
    glLightfv(GL_LIGHT0,GL_SPECULAR, specular);
    glEnable(GL_LIGHT0);

    // Enable color tracking
    glEnable(GL_COLOR_MATERIAL);
    // Set Material properties to follow glColor values
    glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);

	// All materials hereafter have full specular reflectivity with a high shine
    glMaterialfv(GL_FRONT, GL_SPECULAR, specref);
    glMateriali(GL_FRONT, GL_SHININESS, shininess);

	// BackgroundColor
	glClearColor(0.7,0.7,0.7,0);

	//
	/*
	swLightfv(GL_LIGHT0,GL_AMBIENT,ambientLight);
    swLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseLight);
    swLightfv(GL_LIGHT0,GL_SPECULAR, specular);

    swMaterialfv(GL_FRONT, GL_SPECULAR, specref);
    swMateriali(GL_FRONT, GL_SHININESS, shininess);
*/

    glutMainLoop();

	return 0;
}
Exemple #7
0
//on/off
void ofxLightsOn(){
	glEnable(GL_LIGHTING);
	glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
	glEnable(GL_COLOR_MATERIAL);
}
Exemple #8
0
void SetupGL()
{
    //Parameter handling
    glShadeModel (GL_SMOOTH);

    // Accept fragment if it closer to the camera than the former one
    glDepthFunc(GL_LESS);
    // polygon rendering mode
    glEnable(GL_COLOR_MATERIAL);
    glColorMaterial( GL_FRONT, GL_AMBIENT_AND_DIFFUSE );

    //Set up light source
    //GLfloat light_position[] = { 0.0, 30.0,-50.0,0.0 };
    GLfloat light_position[] = { 5.0, 5.0, 0.0, 1.0 };

    glLightfv(GL_LIGHT0, GL_POSITION, light_position);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);

    // Background
    glClearColor( 0.1f, 0.1f, 0.1f, 1.0f );

    // Register GLUT callbacks
    glutDisplayFunc(DisplayGL);
    glutKeyboardFunc(KeyboardGL);
    glutSpecialFunc(Specialkey);
    glutReshapeFunc(ReshapeGL);
    glutMouseFunc(MouseGL);
    glutMotionFunc(Mouse_active);

    //Call to the drawing function
    glutIdleFunc(Idle);
    last_time = glutGet(GLUT_ELAPSED_TIME);

    // Setup initial GL State
    glClearDepth( 1.0f );

    //
    // Init GLEW
    if ( glewInit() != GLEW_OK )
    {
        std::cerr << "Failed to initialize GLEW." << std::endl;
        exit(-1);
    }

    // Setup initial GL State
    glClearDepth( 1.0f );

    std::cout << "Initialise OpenGL: Success!" << std::endl;

    //VAO
    //glGenVertexArrays(1, &VertexArrayID);
    //glBindVertexArray(VertexArrayID);

    // Create and compile our GLSL program from the shaders
    programID_1 = LoadShaders( "TransformVertexShader.vertexshader", "ColorFragmentShader.fragmentshader" );

    glEnable(GL_CULL_FACE);
    glEnable(GL_DEPTH_TEST);
    Projection = glm::perspective(initialFoV, (float)WINDOW_WIDTH / WINDOW_HEIGHT, 0.1f, 100.0f);

    //VBO -- Vertex Buffer Object
    static const GLfloat g_vertex_buffer_data[] = {
        -1.0f,-1.0f,-1.0f, // triangle 1 : begin
        -1.0f,-1.0f, 1.0f,
        -1.0f, 1.0f, 1.0f, // triangle 1 : end
        1.0f, 1.0f,-1.0f, // triangle 2 : begin
        -1.0f,-1.0f,-1.0f,
        -1.0f, 1.0f,-1.0f, // triangle 2 : end
        1.0f,-1.0f, 1.0f,
        -1.0f,-1.0f,-1.0f,
        1.0f,-1.0f,-1.0f,
        1.0f, 1.0f,-1.0f,
        1.0f,-1.0f,-1.0f,
        -1.0f,-1.0f,-1.0f,
        -1.0f,-1.0f,-1.0f,
        -1.0f, 1.0f, 1.0f,
        -1.0f, 1.0f,-1.0f,
        1.0f,-1.0f, 1.0f,
        -1.0f,-1.0f, 1.0f,
        -1.0f,-1.0f,-1.0f,
        -1.0f, 1.0f, 1.0f,
        -1.0f,-1.0f, 1.0f,
        1.0f,-1.0f, 1.0f,
        1.0f, 1.0f, 1.0f,
        1.0f,-1.0f,-1.0f,
        1.0f, 1.0f,-1.0f,
        1.0f,-1.0f,-1.0f,
        1.0f, 1.0f, 1.0f,
        1.0f,-1.0f, 1.0f,
        1.0f, 1.0f, 1.0f,
        1.0f, 1.0f,-1.0f,
        -1.0f, 1.0f,-1.0f,
        1.0f, 1.0f, 1.0f,
        -1.0f, 1.0f,-1.0f,
        -1.0f, 1.0f, 1.0f,
        1.0f, 1.0f, 1.0f,
        -1.0f, 1.0f, 1.0f,
        1.0f,-1.0f, 1.0f
    };

    static GLfloat cube_red_buffer_data[12*3*3];
    static GLfloat cube_blue_buffer_data[12*3*3];

    for (int i = 0; i < 12*3; i++) {
        cube_red_buffer_data[i*3+0] = 1.0;
        cube_red_buffer_data[i*3+1] = 0.1;
        cube_red_buffer_data[i*3+2] = 0.1;

        cube_blue_buffer_data[i*3+0] = 0.1;
        cube_blue_buffer_data[i*3+1] = 0.1;
        cube_blue_buffer_data[i*3+2] = 1.0;
    }

    static const GLfloat cylVertexArray[] = {
        -1.000, 0.000, 0.000,
        -0.866, 0.500, 0.000,
        -0.500, 0.866, 0.000,
        -0.000, 1.000, 0.000,
        0.500, 0.866, 0.000,
        0.866, 0.500, 0.000,
        1.000, -0.000, 0.000,
        0.866, -0.500, 0.000,
        0.500, -0.866, 0.000,
        0.000, -1.000, 0.000,
        -0.500, -0.866, 0.000,
        -0.866, -0.500, 0.000,
        1.000, 0.000, 1.000,
        0.866, 0.500, 1.000,
        0.500, 0.866, 1.000,
        0.000, 1.000, 1.000,
        -0.500, 0.866, 1.000,
        -0.866, 0.500, 1.000,
        -1.000, -0.000, 1.000,
        -0.866, -0.500, 1.000,
        -0.500, -0.866, 1.000,
        -0.000, -1.000, 1.000,
        0.500, -0.866, 1.000,
        0.866, -0.500, 1.000,
    };
    static const GLfloat cylIndexArray[] = {
        1, 2, 3,
        1, 3, 4,
        1, 4, 5,
        1, 5, 6,
        1, 6, 7,
        1, 7, 8,
        1, 8, 9,
        1, 9, 10,
        1, 10, 11,
        1, 11, 12,
        13, 14, 15,
        13, 15, 16,
        13, 16, 17,
        13, 17, 18,
        13, 18, 19,
        13, 19, 20,
        13, 20, 21,
        13, 21, 22,
        13, 22, 23,
        13, 23, 24,
        24, 8, 7,
        24, 7, 13,
        21, 11, 10,
        21, 10, 22,
        23, 9, 8,
        23, 8, 24,
        20, 12, 11,
        20, 11, 21,
        22, 10, 9,
        22, 9, 23,
        19, 1, 12,
        19, 12, 20,
        18, 2, 1,
        18, 1, 19,
        14, 13, 7,
        14, 7, 6,
        15, 5, 4,
        15, 4, 16,
        17, 3, 2,
        17, 2, 18,
        15, 14, 6,
        15, 6, 5,
        16, 4, 3,
        16, 3, 17,
    };

    const int cylSize = 44*3*3;
    static GLfloat cyl_vertex_buffer_data[cylSize];

    int index;
    for (int i = 0; i < cylSize/3; i++) {
        index = cylIndexArray[i];
        cyl_vertex_buffer_data[i*3+0] = cylVertexArray[(index-1)*3+0];
        cyl_vertex_buffer_data[i*3+1] = cylVertexArray[(index-1)*3+1];
        cyl_vertex_buffer_data[i*3+2] = cylVertexArray[(index-1)*3+2];
    }

    static GLfloat cyl_red_color_buffer_data[cylSize];
    for (int i = 0; i < cylSize/3; i++) {
        cyl_red_color_buffer_data[i*3+0] = 0.8; //red
        cyl_red_color_buffer_data[i*3+1] = 0.1; //green
        cyl_red_color_buffer_data[i*3+2] = 0.1; //blue
    }

    static GLfloat cyl_white_color_buffer_data[cylSize];
    for (int i = 0; i < cylSize/3; i++) {
        cyl_white_color_buffer_data[i*3+0] = 0.9; //red
        cyl_white_color_buffer_data[i*3+1] = 0.9; //green
        cyl_white_color_buffer_data[i*3+2] = 0.9; //blue
    }



    // Generate 1 buffer, put the resulting identifier in vertexBuffer
    glGenBuffers(1, &vertexBuffer);
    // The following commands will talk about our 'vertexBuffer' buffer
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    // Give our vertices to OpenGL.
    glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);

    glGenBuffers(1, &cubeRedBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, cubeRedBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(cube_red_buffer_data), cube_red_buffer_data, GL_STATIC_DRAW);

    glGenBuffers(1, &cubeBlueBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, cubeBlueBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(cube_blue_buffer_data), cube_blue_buffer_data, GL_STATIC_DRAW);

    glGenBuffers(1, &cylinderBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, cylinderBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(cyl_vertex_buffer_data), cyl_vertex_buffer_data, GL_STATIC_DRAW);

    glGenBuffers(1, &cylRedColorBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, cylRedColorBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(cyl_red_color_buffer_data), cyl_red_color_buffer_data, GL_STATIC_DRAW);

    glGenBuffers(1, &cylWhiteColorBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, cylWhiteColorBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(cyl_white_color_buffer_data), cyl_white_color_buffer_data, GL_STATIC_DRAW);


}
Exemple #9
0
void display(){
    //setup of material values for light
    float m_amb[] = {0.23, 0.22, 0.23, 1.0};
    float m_dif[] = {0.9, 0.9, 0.9, 1.0};
    float m_spec[] = {0.1, 0.1, 0.1, 1.0};
    float shiny = 1;

    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, m_amb);
    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, m_dif);
    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, m_spec);
    glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shiny);
    glColorMaterial(GL_AMBIENT, GL_DIFFUSE);
    
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
    
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    
    if(firstPersonMode==OFF && gamestatus==1){
        gluLookAt(camPos[0], camPos[1], camPos[2], 0,10,0, 0,1,0);
        mainGame->draw();
    }else if(gamestatus==1){
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluPerspective(450, 1, 1, 1000);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        mainGame->setFPLook();
        mainGame->draw();
        
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadIdentity();
        mainGame->drawStrokeText((char*)"Score:", 400-180, 555);
        char* score = (char*)mainGame->setScore().c_str();
        mainGame->drawStrokeText(score, 500-180, 555);
        mainGame->drawStrokeText((char*)"Balls Left:", 400-180, 525);
        char* ballLeft = (char*)mainGame->setBallsLeft().c_str();
        mainGame->drawStrokeText(ballLeft, 550-180, 525);
        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();
        glMatrixMode(GL_PROJECTION);
        glPopMatrix();
        glEnable(GL_TEXTURE_2D);
        
    }else if(gamestatus==0){
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(0, 200, 0, 200);
        
        void * font1 = GLUT_BITMAP_TIMES_ROMAN_24;
        void * font2 = GLUT_BITMAP_9_BY_15;
        void * font3 = GLUT_BITMAP_TIMES_ROMAN_10;
        
        //Title
        glColor3f(1, 0, 0);
        glRasterPos2i(70, 170);
        string title = "WALL BLASTER";
        for (string::iterator i = title.begin(); i != title.end(); ++i){
            char c = *i;
            glutBitmapCharacter(font1, c);
        }
        //Instruction line 1
        glColor3f(1, 1, 1);
        glRasterPos2i(15, 130);
        string desc1 = "CLICK TO FIRE BALLS. BREAK THE GLASS PLANES THAT COME AT YOU. IF YOU GET HIT BY ONE, YOU LOSE.";
        for (string::iterator i = desc1.begin(); i != desc1.end(); ++i){
            char c = *i;
            glutBitmapCharacter(font3, c);
        }
        //Instruction line 2
        glRasterPos2i(15, 120);
        string desc2 = "HITTING ONE OF THE MANY PYRAMIDS ON THE FLOOR WILL ADD THREE BALLS TO YOUR TOTAL BALL AMMO";
        for (string::iterator i = desc2.begin(); i != desc2.end(); ++i){
            char c = *i;
            glutBitmapCharacter(font3, c);
        }
        //S
        glRasterPos2i(80, 80);
        string start = "(S)";
        for (string::iterator i = start.begin(); i != start.end(); ++i){
            char c = *i;
            glutBitmapCharacter(font2, c);
        }
        //Q
        glRasterPos2i(80, 60);
        string quit = "(Q)";
        for (string::iterator i = quit.begin(); i != quit.end(); ++i){
            char c = *i;
            glutBitmapCharacter(font2, c);
        }
        //Start
        glColor3f(0, 0.5, 1);
        glRasterPos2i(90, 80);
        string start2 = "Start";
        for (string::iterator i = start2.begin(); i != start2.end(); ++i){
            char c = *i;
            glutBitmapCharacter(font2, c);
        }
        //Quit
        glRasterPos2i(90, 60);
        string quit2 = "Quit";
        for (string::iterator i = quit2.begin(); i != quit2.end(); ++i){
            char c = *i;
            glutBitmapCharacter(font2, c);
        }
        //Name
        glColor3f(1, 1, 1);
        glRasterPos2i(15, 10);
        string name = "BY: Simarpreet Singh (1216728), Birunthaa Umamahesan (1203142), Joseph Nguyen (1229287), Curran Tam (1231038)";
        for (string::iterator i = name.begin(); i != name.end(); ++i){
            char c = *i;
            glutBitmapCharacter(font3, c);
        }
    }else if(gamestatus == 2){
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(0, 200, 0, 200);
        
        //Pause Menu
        glColor3f(1, 1, 1);
        glRasterPos2i(80, 100);
        string pause = "PAUSED";
        void * font1 = GLUT_BITMAP_TIMES_ROMAN_24;
        for (string::iterator i = pause.begin(); i != pause.end(); ++i){
            char c = *i;
            glutBitmapCharacter(font1, c);
        }
        //additional description
        glRasterPos2i(60, 70);
        void * font3 = GLUT_BITMAP_TIMES_ROMAN_10;
        string desc2 = "PRESS (S) TO RESTART THE GAME OR (Q) TO QUIT";
        for (string::iterator i = desc2.begin(); i != desc2.end(); ++i){
            char c = *i;
            glutBitmapCharacter(font3, c);
        }
    }
    else if(gamestatus == 3){
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(0, 200, 0, 200);
        //GAMEOVER
        glColor3f(1, 0, 0);
        glRasterPos2i(80, 100);
        string gameover = "GAME OVER";
        void * font1 = GLUT_BITMAP_TIMES_ROMAN_24;
        for (string::iterator i = gameover.begin(); i != gameover.end(); ++i){
            char c = *i;
            glutBitmapCharacter(font1, c);
        }
        glRasterPos2i(20, 130);
        string gameover2 = "YOU HIT A GLASS OR RAN OUT OF BALLS!";
        for (string::iterator i = gameover2.begin(); i != gameover2.end(); ++i){
            char c = *i;
            glutBitmapCharacter(font1, c);
        }
        //additional description
        glColor3f(1, 1, 1);
        glRasterPos2i(60, 70);
        void * font3 = GLUT_BITMAP_TIMES_ROMAN_10;
        string desc2 = "PRESS (S) TO RESTART THE GAME OR (Q) TO QUIT";
        for (string::iterator i = desc2.begin(); i != desc2.end(); ++i){
            char c = *i;
            glutBitmapCharacter(font3, c);
        }
    }
    
    
    
    glFlush();
    glutSwapBuffers();

}
Exemple #10
0
void renderScene(void) {
    
    //Set up Viewport 1 scene
    
    // Use the Projection Matrix
    glMatrixMode(GL_PROJECTION);
    
    // Reset Matrix
    glLoadIdentity();
    
    
    glScissor(0, 0, (GLsizei) windowWidth, (GLsizei) windowHeight*0.9);
    glEnable(GL_SCISSOR_TEST);
    glClearDepth(1.0);
    
    glClearColor(0.49f, 0.75f, 0.93f, 1.0f);
    
    // Set the viewport to be the entire window
    glViewport (0, 0, (GLsizei) windowWidth, (GLsizei) windowHeight*0.9);
    
    // Set the correct perspective.
    
    if (viewMode == PERSPECTIVE)
        gluPerspective(45.0f*zoom, ratio, 1.0f, 1000.0f);
    else if (viewMode == ORTHOGRAPHIC)
        glOrtho((-windowWidth/50)*zoom, (windowWidth/50)*zoom, (-windowHeight/50)*zoom, (windowHeight/50)*zoom, 1.0f, 1000);
    
    // Get Back to the Modelview
    glMatrixMode(GL_MODELVIEW);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    //Decide if wire frame or shaded
    if (polygonMode == WIREFRAME)
        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    else if (polygonMode == SHADED)
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    
    glLoadIdentity();

    moveCamera();
    
    lx = (sin(heliRot+PI));
    lz = (cos(heliRot+PI));
    
    float camX = curX + lx * 10.0f;
    float camZ = curZ + lz * 10.0f;
    
    //Set camera
    if (viewPerson == THIRD) {
        gluLookAt(eyeX+curX, eyeY, eyeZ+curZ,
                  curX, 0.0f, curZ,
                  upX, upY, upZ);
    }

    else if (viewPerson == FIRST) {
        
        gluLookAt(camX, 1.5f, camZ,
                  camX+lx, 1.5f, camZ+lz,
                  0.0f, 1.0f, 0.0f);
        
    }
    
    glEnable(GL_DEPTH_TEST);
    
    glShadeModel(GL_SMOOTH); // smooth out lighting
    glEnable(GL_NORMALIZE);  // normalize lighting
    
    GLfloat mat_specular[] = {0.3, 0.3, 0.3, 1.0};
    GLfloat mat_shininess[] = { 10.0 };
    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
    glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
    glEnable(GL_COLOR_MATERIAL);
    
    if (lightingEnabled) {
        
        glEnable(GL_LIGHTING);
    
        if (sunlight) {

            setSunlight();
    
        }
    
        else {
            glDisable(GL_LIGHT0);
        }
        
        
        if (thirdPersonLight) {
            setThirdPersonLight();
        }
        
        else {
            glDisable(GL_LIGHT3);
        }
        
        
    }
    
    else {
        glDisable(GL_LIGHTING);
    }

    glPushMatrix();
    glTranslatef(0.0f, -10, 0.0f);
    drawGround(250, 100);
    glPopMatrix();
    
    glPushMatrix();
    glTranslatef(0.0f, -9.9, 0.0f);
    drawTrack(100.0, 100.0);
    glPopMatrix();
    
    glPushMatrix();
    moveHelicopter();
    glRotatef(heliRot/PI*180, 0.0f, 1.0f, 0.0f);
    drawHelicopter();
    
    
    if (lightingEnabled) {
    
        if (circleLight) {
    moveLight();
    setCircularLight();
        }
        
        else {
            glDisable(GL_LIGHT2);
        }
    
    }
    
    glPopMatrix();
    
    //Set up Viewport 2 scene
    
    // Use the Projection Matrix
    glMatrixMode(GL_PROJECTION);
    
    // Reset Matrix
    glLoadIdentity();
    
    glScissor(0, windowHeight*0.9, (GLsizei) windowWidth, (GLsizei) windowHeight*0.1);
    glEnable(GL_SCISSOR_TEST);
    glClearDepth(1.0);
    glClearColor(1, 1, 1, 1);

    
    // Set the viewport to be the entire window
    glViewport (0, windowHeight*0.9, (GLsizei) windowWidth, (GLsizei) windowHeight*0.1);
    
    // Set the correct perspective.
    
    // Get Back to the Modelview
    glMatrixMode(GL_MODELVIEW);
    
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    glEnable(GL_DEPTH_TEST);
    
    frame++;
    time=glutGet(GLUT_ELAPSED_TIME);
    if (time - timebase > 1000) {
        sprintf(s,"FPS:%4.2f",
                frame*1000.0/(time-timebase));
        timebase = time;
        frame = 0;
    }
    
    glColor3f(0.0f,0.0f,0.0f);
    
    glPushMatrix();
    glLoadIdentity();
    setOrthographicProjection();
    glTranslatef(100.0f, 150, 0.0f);
    renderBitmapString(5,30,0,GLUT_BITMAP_HELVETICA_18,s);
    glPopMatrix();
    restorePerspectiveProjection();
    
    glutSwapBuffers();
    
}
void GameManager::display(){
	
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	
	
	if(_cameraLook!=1){
		
		if(_cameraLook==3) updateThirdCameraView();
		_camera->computeVisualizationMatrix(_eyePosition->getX(), _eyePosition->getY(), _eyePosition->getZ(),
							_targetPosition->getX(), _targetPosition->getY(), _targetPosition->getZ(),
								_upVector->getX(), _upVector->getY(), _upVector->getZ());
		
		
	}
	
	
	glColorMaterial (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);	 //specifies which material parameters track the current color
	glEnable(GL_NORMALIZE);
	
	glPushMatrix();
    
    std::list<StaticObject*>::iterator object=_game_objects.begin();
    (*object)->draw(tex_water);
    object++;
    (*object)->draw(tex_riverside);
    object++;
    (*object)->draw(tex_road);
    object++;
    (*object)->draw(tex_roadside);
    object++;
		
		for(std::list<TimberLog*>::iterator object=_timberLogs.begin(); object != _timberLogs.end(); object++){
					(*object)->draw(tex_timberlog);
		}
		
		_frog->draw(tex_frog);
		
		for(std::list<DynamicObject*>::iterator object=_cars.begin(); object != _cars.end(); object++){
					(*object)->draw();
		}
    for(int i=0; i<6; i++){
        _lightPosts[i]->drawLightPost();
        _lightPosts[i]->shine();
    }
    
    _mainAmbientLight->shine();
    
    updateHeadLightPosition();
    
    glPopMatrix();

	
    glMatrixMode(GL_PROJECTION);
		glPushMatrix();
                glLoadIdentity();
				_vidasCamera->computeProjectionMatrix();
				
				glMatrixMode(GL_MODELVIEW);
				glLoadIdentity();
    
                if(_paused){
                        _message->draw(tex_pause);
                }
                else if (_gameOver){
                        _message->draw(tex_game_over);
                }
    
                for(int i=0; i<_vidas; i++){
                    _vida->draw(i, tex_frog, tex_eye);
                }
    
                glMatrixMode(GL_PROJECTION);
		glPopMatrix();
    glMatrixMode(GL_MODELVIEW);
    glutSwapBuffers();
}
Exemple #12
0
bool HGE_Impl::_GfxInit()
{
//	static const char *szFormats[]={"UNKNOWN", "R5G6B5", "X1R5G5B5", "A1R5G5B5", "X8R8G8B8", "A8R8G8B8"};
//	D3DADAPTER_IDENTIFIER9 AdID;
//	D3DDISPLAYMODE Mode;
//	D3DFORMAT Format=D3DFMT_UNKNOWN;
//	UINT nModes, i;

// Init Open GL
    /*
    	HDC hDC;
    	HGLRC hRC;
    	long gl_error;


    	hDC = GetDC(pHGE->hwnd);
    	hRC = wglCreateContext(hDC);

    	if (hRC == NULL)
    	{
    		System_Log("Creating GL Context Failed with error code: %d", GetLastError());
    		return false;
    	}

    	System_Log("Initializing Graphix");

    	wglMakeCurrent(hDC, hRC);
    */
    long gl_error;



    GLenum err = glewInit();
    if (GLEW_OK != err)
    {
        /* Problem: glewInit failed, something is seriously wrong. */
        System_Log("GLEW init Error: %s\n", glewGetErrorString(err));
    }
    else
        System_Log("Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));

    if (!GLEW_EXT_framebuffer_object)
    {
        System_Log("Status: Unavailable Extension GL_EXT_framebuffer_object\n");
    }
    else
        System_Log("Status: GL_EXT_framebuffer_object is supportet\n");



    glShadeModel(GL_SMOOTH);						// Enables Smooth Shading
    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);      // 4-byte pixel alignment

    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);


    glClearStencil(0);                          // clear stencil buffer
    glClearDepth(1.0f);								// Depth Buffer Setup


    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);
//	glCullFace(GL_BACK);
    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
    glEnable(GL_COLOR_MATERIAL);
//	glDisable(GL_DEPTH_TEST);


    glDepthFunc(GL_LEQUAL);							// The Type Of Depth Test To Do

    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);			// Really Nice Perspective Calculations



// Get adapter info

    System_Log("OpenGL version: %s", glGetString( GL_VERSION ));
//	System_Log("OpenGL version: %s", glGetString( GL_EXTENSIONS ));




// Set up Full Screen presentation parameters



    _AdjustWindow();

    System_Log("Mode: width = %d height = %d\n",nScreenWidth,nScreenHeight);

// Create vertex batch buffer

    textures=0;

// Init all stuff that can be lost

    _SetProjectionMatrix(nScreenWidth, nScreenHeight);

    if (GL_ERROR(gl_error))
    {
        System_Log("OpenGL error: %d", gl_error);
        return false;
    }

    if(!_init_lost()) return false;

    Gfx_Clear(0);

    System_Log("Graphix initialized");

    return true;
}
Exemple #13
0
int main(int argc,char** args) {

    srand(time(NULL));

    try {

        if (SDL_Init(SDL_INIT_VIDEO)) {
            fprintf(stderr,"Unable to initialize SDL: %s\n",SDL_GetError());
            return EXIT_FAILURE;
        }
        atexit(SDL_Quit);

        SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,1);
#if 0
        screen = SDL_SetVideoMode(1440,900,32,SDL_OPENGL|SDL_FULLSCREEN);
#else
        screen = SDL_SetVideoMode(1024,768,32,SDL_OPENGL/*|SDL_FULLSCREEN*/);
#endif
        if(!screen) {
            fprintf(stderr,"Unable to create SDL screen: %s\n",SDL_GetError());
            return EXIT_FAILURE;
        }
        SDL_WM_SetCaption("GlestNG","GlestNG");

        GLenum err = glewInit();
        if(GLEW_OK != err) {
            fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
            return EXIT_FAILURE;
        }
        fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));

        // we have a GL context so we can go ahead and init all the singletons
        std::auto_ptr<fs_t> fs_settings(fs_t::create("data/"));
        fs_t::settings = fs_settings.get(); // set it globally
        std::auto_ptr<xml_parser_t> xml_settings(new xml_parser_t("UI Settings",fs_settings->get_body("ui_settings.xml")));
        xml_settings->set_as_settings();
        std::auto_ptr<graphics_t::mgr_t> graphics_mgr(graphics_t::create());
        std::auto_ptr<fonts_t> fonts(fonts_t::create());
        std::auto_ptr<fs_t> fs;
        try {
            fs.reset(fs_t::create("data/Glest"));
            if(false) {
                fs_file_t::ptr_t logo_file(fs_settings->get("logo.g3d"));
                istream_t::ptr_t logostream(logo_file->reader());
                logo = std::auto_ptr<model_g3d_t>(new model_g3d_t(*logostream));
            }
            load(*fs);
        } catch(glest_exception_t* e) {
            std::cerr << "cannot load glest data: " << e << std::endl;
            delete e;
        }
        std::auto_ptr<ui_mgr_t> ui_(ui_mgr());
        std::auto_ptr<mod_ui_t> mod_ui(mod_ui_t::create());

        std::auto_ptr<terrain_t> terrain(terrain_t::gen_planet(5,500,3));
        //world()->dump(std::cout);

        v4_t light_amb(0,0,0,1), light_dif(1.,1.,1.,1.), light_spec(1.,1.,1.,1.), light_pos(1.,1.,-1.,0.),
             mat_amb(.7,.7,.7,1.), mat_dif(.8,.8,.8,1.), mat_spec(1.,1.,1.,1.);
        glLightfv(GL_LIGHT0,GL_AMBIENT,light_amb.v);
        glLightfv(GL_LIGHT0,GL_DIFFUSE,light_dif.v);
        glLightfv(GL_LIGHT0,GL_SPECULAR,light_spec.v);
        glLightfv(GL_LIGHT0,GL_POSITION,light_pos.v);
        glLightfv(GL_LIGHT1,GL_AMBIENT,light_amb.v);
        glLightfv(GL_LIGHT1,GL_DIFFUSE,light_dif.v);
        glLightfv(GL_LIGHT1,GL_SPECULAR,light_spec.v);
        glMaterialfv(GL_FRONT,GL_AMBIENT,mat_amb.v);
        glMaterialfv(GL_FRONT,GL_DIFFUSE,mat_dif.v);
        glMaterialfv(GL_FRONT,GL_SPECULAR,mat_spec.v);
        glMaterialf(GL_FRONT,GL_SHININESS,100.0);
        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);
        glEnable(GL_LIGHT1);
        glDepthFunc(GL_LEQUAL);
        glEnable(GL_DEPTH_TEST);
        glAlphaFunc(GL_GREATER,0.4);
        glEnable(GL_COLOR_MATERIAL);
        glEnable(GL_RESCALE_NORMAL);
        glEnable(GL_BLEND);
        glEnable(GL_TEXTURE_2D);
        glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
        glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
        glEnable(GL_COLOR_MATERIAL);
        glEnable(GL_NORMALIZE);
        glFrontFace(GL_CW);
        camera();
        bool quit = false;
        SDL_Event event;
        SDL_EnableKeyRepeat(200,20);
        SDL_EnableUNICODE(true);
        const unsigned start = SDL_GetTicks();
        framerate.reset();
        while(!quit) {
            set_now(SDL_GetTicks()-start);
            while(!quit && SDL_PollEvent(&event)) {
                if(ui_mgr()->offer(event))
                    continue;
                switch (event.type) {
                case SDL_MOUSEMOTION:
                    if(selection)
                        std::cout << "drag" << std::endl;
                    /*printf("Mouse moved by %d,%d to (%d,%d)\n",
                    event.motion.xrel, event.motion.yrel,
                    event.motion.x, event.motion.y);*/
                    break;
                case SDL_MOUSEBUTTONDOWN:
                    click(event.button.x,event.button.y);
                    if(selection)
                        std::cout << "selection: "<<selected_point<<std::endl;
                    break;
                case SDL_MOUSEBUTTONUP:
                    if(selection)
                        std::cout << "selection stopped" << std::endl;
                    selection = false;
                    break;
                case SDL_KEYDOWN:
                    switch(event.key.keysym.sym) {
                    case SDLK_PLUS:
                        zoom += 1;
                        camera();
                        break;
                    case SDLK_MINUS:
                        zoom -= 1;
                        camera();
                        break;
                    case SDLK_ESCAPE:
                        quit = true;
                        break;
                    case SDLK_m: // MODDING MODE
                        if(!fs.get()) {
                            std::cerr << "(modding menu triggered but mod not loaded)" << std::endl;
                            break;
                        }
                        if(mod_ui->is_shown())
                            mod_ui->hide();
                        else
                            mod_ui->show(ref_t(*techtree,TECHTREE,techtree->name));
                        break;
                    default:
                        std::cout << "Ignoring key " <<
                                  (int)event.key.keysym.scancode << "," <<
                                  event.key.keysym.sym << "," <<
                                  event.key.keysym.mod << "," <<
                                  event.key.keysym.unicode << std::endl;
                    }
                    break;
                case SDL_QUIT:
                    quit = true;
                    break;
                }
            }
            framerate.tick(now());
            tick();
        }
        for(tests_t::iterator i=objs.begin(); i!=objs.end(); i++)
            delete *i;
        return EXIT_SUCCESS;
    } catch(data_error_t* de) {
        std::cerr << "Oh! " << de << std::endl;
    } catch(graphics_error_t* ge) {
        std::cerr << "Oh! " << ge << std::endl;
    } catch(panic_t* panic) {
        std::cerr << "Oh! " << panic << std::endl;
    }
    return EXIT_FAILURE;
}
static void
cubemodelPaintInside (CompScreen              *s,
                      const ScreenPaintAttrib *sAttrib,
                      const CompTransform     *transform,
                      CompOutput              *output,
                      int                     size)
{
    int                i;
    static const float matShininess[] = { 60.0 };
    static const float matSpecular[] = { 0.6, 0.6, 0.6, 1.0 };
    static const float matDiffuse[] = { 1.0, 1.0, 1.0, 1.0 };
    static const float matAmbient[] = { 0.8, 0.8, 0.9, 1.0 };

    static const float lmodelLocalviewer[] = { 0.0 };
    static       float lmodelTwoside[] = { 0.0 };
    static       float lmodelAmbient[] = { 0.4, 0.4, 0.4, 0.4 };
    static       float lmodelDiffuse[] = { 1.0, 1.0, 1.0, 1.0 };
    static       float lmodelSpecular[]= { 0.6, 0.6, 0.6, 0.6 };

    ScreenPaintAttrib  sA = *sAttrib;
    CompTransform      mT = *transform;
    Bool               enabledCull;
    int                cull;
    float              scale, outputRatio = 1.0f;

    CUBEMODEL_SCREEN (s);
    CUBE_SCREEN (s);

    if (cms->hsize != s->hsize * cs->nOutput)
    {
	initWorldVariables (s);
	updateModel (s, 0, cms->numModels);
    }

    sA.yRotate += cs->invert * (360.0f / size) *
		  (cs->xRotations - (s->x* cs->nOutput));

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

    glPushMatrix ();

    if (cubemodelGetRotateLighting (s))
	setLightPosition (s, GL_LIGHT1);

    glLoadMatrixf (mT.m);

    if (!cubemodelGetRotateLighting (s))
	setLightPosition (s, GL_LIGHT1);


    glTranslatef (cs->outputXOffset, -cs->outputYOffset, 0.0f);
    glScalef (cs->outputXScale, cs->outputYScale, 1.0f);

    glPushAttrib (GL_COLOR_BUFFER_BIT | GL_TEXTURE_BIT |
		  GL_LIGHTING_BIT     | GL_DEPTH_BUFFER_BIT);

    glEnable (GL_BLEND);
    glColorMaterial (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);

    lmodelAmbient[0]  = cubemodelGetLightAmbient (s);
    lmodelDiffuse[0]  = cubemodelGetLightDiffuse (s);
    lmodelSpecular[0] = cubemodelGetLightSpecular (s);

    for (i = 1; i < 4; i++)
    {
	lmodelAmbient[i]  = lmodelAmbient[0];
	lmodelDiffuse[i]  = lmodelDiffuse[0];
	lmodelSpecular[i] = lmodelSpecular[0];
    }

    lmodelTwoside[0] = (cubemodelGetRenderFrontAndBack (s) ? 1.0f : 0.0f);


    glLightModelfv (GL_LIGHT_MODEL_LOCAL_VIEWER, lmodelLocalviewer);
    glLightModelfv (GL_LIGHT_MODEL_TWO_SIDE, lmodelTwoside);
    glLightModelfv (GL_LIGHT_MODEL_AMBIENT,  lmodelAmbient);
    glLightfv (GL_LIGHT1, GL_DIFFUSE,   lmodelDiffuse);
    glLightfv (GL_LIGHT1, GL_SPECULAR,  lmodelSpecular);

    enabledCull = glIsEnabled (GL_CULL_FACE);

    glGetIntegerv (GL_CULL_FACE_MODE, &cull);
    glEnable (GL_CULL_FACE);

    glCullFace (~cull & (GL_FRONT | GL_BACK));
    glCullFace (cull);

    glPushMatrix ();

    glColor4usv (defaultColor);

    glMaterialfv (GL_FRONT_AND_BACK, GL_SHININESS, matShininess);
    glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, matSpecular);
    glMaterialfv (GL_FRONT_AND_BACK, GL_DIFFUSE, matDiffuse);
    glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT, matAmbient);

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

    glDepthFunc (GL_LEQUAL); /* for transparency maps */
    glShadeModel(GL_SMOOTH);

    glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

    scale = cs->distance;

    if (cubemodelGetRescaleWidth (s))
    {
	if (cs->moMode == CUBE_MOMODE_AUTO && cs->nOutput < s->nOutputDev)
	    outputRatio = (float) s->width / (float) s->height;
	else
	    outputRatio = (float) output->width / (float) output->height;
    }

    glScalef (scale / outputRatio, scale, scale / outputRatio);

    glPushMatrix ();

    glColor4f (1.0, 1.0, 1.0, 1.0);

    for (i = 0; i < cms->numModels; i++)
    {
	glPushMatrix ();
	cubemodelDrawModelObject (s, cms->models[i],
	                          cubemodelGetGlobalModelScaleFactor (s));
	glPopMatrix ();

    }
    glPopMatrix ();

    glPopMatrix ();

    glDisable (GL_LIGHT1);
    glDisable (GL_NORMALIZE);

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

    glDisable (GL_DEPTH_TEST);

    if (enabledCull)
	glDisable (GL_CULL_FACE);

    glPopMatrix ();

    glPopAttrib ();

    cms->damage = TRUE;

    UNWRAP (cms, cs, paintInside);
    (*cs->paintInside) (s, sAttrib, transform, output, size);
    WRAP (cms, cs, paintInside, cubemodelPaintInside);
}
// Draw our world
void display(void)
{
int ix, iy;
int i;
int j;

glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  //Clear the screen

glMatrixMode (GL_PROJECTION);  // Tell opengl that we are doing project matrix work
glLoadIdentity();  // Clear the matrix
glOrtho(-9.0, 9.0, -9.0, 9.0, 0.0, 30.0);  // Setup an Ortho view
glMatrixMode(GL_MODELVIEW);  // Tell opengl that we are doing model matrix work. (drawing)
glLoadIdentity(); // Clear the model matrix

glDisable(GL_COLOR_MATERIAL);
glDisable(GL_LIGHTING);
glColor3f(1.0, 0.0, 0.0);

if ( start_game == 0 )
   {
   Sprint(-2, 1, "\nTIC TAC TOE");
   Sprint(-2, -2, "To Start press");
   Sprint(-2, -3, "right button for X's");
   Sprint(-2, -4, "and left for O's");
   }

if (win == 1) Sprint( -2, 1, "\nYou win ");
if (win == -1) Sprint( -2, 1, "\n\n\nComputer win ");
if (win == 2) Sprint( -2, 1, "\nTie");

// Setup view, and print view state on screen
if (view_state == 1)
	{
    glColor3f( 0.0, 0.0, 1.0);
    Sprint(-3, 8, "Perspective view");
    glMatrixMode (GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(60, 1, 1, 30);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    }
	else
	{
	glColor3f( 0.0, 0.0, 1.0);
   // Sprint(-2, 8, "Ortho view");
    }

// Lighting on/off
if (light_state == 1)
	{
	glDisable(GL_LIGHTING);
    glDisable(GL_COLOR_MATERIAL);
    }else
	{
    glEnable(GL_LIGHTING);
    glEnable(GL_COLOR_MATERIAL);
    }


gluLookAt( 0, 0, 20, 0, 0, 0, 0, 1, 0);


// Draw Grid
for( ix = 0; ix < 4; ix++)
	{
       glPushMatrix();
       glColor3f(1,1,1);
	   glBegin(GL_LINES);
	   glVertex2i(-9 , -9 + ix * 6);
	   glVertex2i(9 , -9 + ix * 6 );
	   glEnd();
	   glPopMatrix();
	}
	for( iy = 0; iy < 4; iy++ )
	   {
       glPushMatrix();
       glColor3f(1,1,1);
	   glBegin(GL_LINES);
	   glVertex2i(-9 + iy * 6, 9 );
	   glVertex2i(-9 + iy * 6, -9 );
	   glEnd();
	   glPopMatrix();
	   }

glColorMaterial(GL_FRONT, GL_AMBIENT);
glColor4f(0.0, 0.0, 1.0, 1.0);
glColorMaterial(GL_FRONT, GL_EMISSION);
glColor4f(0.1, 0.0, 0.0, 1.0 );
glColorMaterial(GL_FRONT, GL_SPECULAR);
glColor4f(0.35, 0.35, 0.35, 1.0);
glColorMaterial(GL_FRONT, GL_DIFFUSE);
glColor4f(0.69, 0.69, 0.69, 1.0);
//glDisable(GL_COLOR_MATERIAL);
glColor3f( 1.0, 0.0, 1.0);  // Cube color
//glEnable(GL_COLOR_MATERIAL);
// Draw object in box's

for( i = 0; i < 9; i++)
   {
   j = 0;
   if (abs( win ) == 1 )
      {
      if ( (i == box[spinboxes][0]) || (i == box[spinboxes][1]) || (i == box[spinboxes][2]))
         {
          j = spin;
          }else j = 0;
        }
   if(box_map[i] == 1) Draw_X( object_map[i][0], object_map[i][1], -1, j);

   if(box_map[i] == -1) Draw_O( object_map[i][0], object_map[i][1], -1, j);
   }

//glDisable(GL_COLOR_MATERIAL);

glutSwapBuffers();
}
void
hwColorPerVertexShader::drawTheSwatch( MGeometryData* pGeomData,
									   unsigned int* pIndexing,
									   unsigned int  numberOfData,
									   unsigned int  indexCount )

{
	MHardwareRenderer *pRenderer = MHardwareRenderer::theRenderer();
	if( !pRenderer )	return;

	// Set the default background color
	{
		float r, g, b, a;
		MHWShaderSwatchGenerator::getSwatchBackgroundColor( r, g, b, a );
		glClearColor( r, g, b, a );
	}
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	glShadeModel(GL_SMOOTH);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

	{
		// Enable the blending to get the transparency to work
		//
		glEnable(GL_BLEND);
		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	}

	// Load in a sample background image
	if (mSampleImageId == 0)
	{
		mSampleImage = new MImage;
		MStatus rstatus = mSampleImage->readFromFile("C:\\temp\\maya.gif");
		if (rstatus == MStatus::kSuccess)			
		{
			unsigned int w, h;
			mSampleImage->getSize( w, h );
			if (w > 2 && h > 2 )
			{
				glGenTextures( 1, &mSampleImageId );
				if (mSampleImageId > 0)
				{
					glEnable(GL_TEXTURE_2D);
					glBindTexture ( GL_TEXTURE_2D, mSampleImageId );
					glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, 
						GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid *) mSampleImage->pixels() );
				}
			}
		}
		if (mSampleImage)
		{
			delete mSampleImage;
		}
	}

	// Overlay the background checker board
	//
	bool drawBackGround = ( mTranspBias > 0.0f );
	bool drawBackGroundTexture = (mSampleImageId != 0);
	if (drawBackGround)
	{
		if (drawBackGroundTexture)
		{
			glMatrixMode(GL_TEXTURE);
			glLoadIdentity();
			glMatrixMode(GL_MODELVIEW);

			glBindTexture(GL_TEXTURE_2D, mSampleImageId );

			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

			glEnable(GL_TEXTURE_2D);
		}

		unsigned int numberOfRepeats = 8;
		MColor quadColor( 0.5f, 0.5f, 0.5f, 1.0f );
		pRenderer->drawSwatchBackGroundQuads( quadColor, 
							drawBackGroundTexture, numberOfRepeats );
		
		if (drawBackGroundTexture)
			glDisable(GL_TEXTURE_2D);
		glEnable(GL_LIGHTING);
	}

	{
		// Set some example material
		//
		float ambient[4]  = { 0.1f, 0.1f, 0.1f, 1.0f };
		float diffuse[4]  = { 0.7f, 0.7f, 0.7f, 1.0f };
		float specular[4] = { 0.5f, 0.5f, 0.5f, 1.0f };
		float emission[4] = { 0.0f, 0.0f, 0.0f, 1.0f };

		glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT,  ambient);
		glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emission );
		glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular );
		glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 20.0f);

		// Track diffuse color
		float swatchColor[4];
		float biasT = 1.0f - mTranspGain - mTranspBias;
		swatchColor[0] = (diffuse[0] * mColorGain[0]) + mColorBias[0];
		swatchColor[1] = (diffuse[1] * mColorGain[1]) + mColorBias[1];
		swatchColor[2] = (diffuse[2] * mColorGain[2]) + mColorBias[2];
		swatchColor[3] = (diffuse[3] * mTranspGain) + biasT;

		glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, swatchColor );			
		glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);

		glEnable(GL_COLOR_MATERIAL);
		glColor4fv( swatchColor );
	}

	if (pGeomData)
	{
		glPushClientAttrib ( GL_CLIENT_VERTEX_ARRAY_BIT );

		if (mNormalsPerVertex >= 1)
		{
			glDisable(GL_LIGHTING);
			float *normalData = (float *)( pGeomData[1].data() );
			float * tangentData = (float *)( pGeomData[3].data() );
			float * binormalData = (float *)( pGeomData[4].data() );
			if (normalData && mNormalsPerVertex  == 1)
			{
				glEnableClientState(GL_COLOR_ARRAY);
				glColorPointer(3, GL_FLOAT, 0, normalData);
			}
			else if (tangentData && mNormalsPerVertex  == 2)
			{
				glEnableClientState(GL_COLOR_ARRAY);
				glColorPointer(3, GL_FLOAT, 0, tangentData);
			}
			else if (binormalData)
			{
				glEnableClientState(GL_COLOR_ARRAY);
				glColorPointer(3, GL_FLOAT, 0, binormalData);
			}
		}

		float *vertexData = (float *)( pGeomData[0].data() );
		if (vertexData)
		{
			glEnableClientState( GL_VERTEX_ARRAY );
			glVertexPointer ( 3, GL_FLOAT, 0, vertexData );
		}

		float *normalData = (float *)( pGeomData[1].data() );
		if (normalData)
		{
			glEnableClientState( GL_NORMAL_ARRAY );
			glNormalPointer (    GL_FLOAT, 0, normalData );
		}

		if (mSampleImageId > 0)
		{
			float *uvData = (float *) (pGeomData[2].data() );
			if (uvData)
			{
				glBindTexture ( GL_TEXTURE_2D, mSampleImageId );
				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

				glEnable(GL_TEXTURE_2D);
				glEnableClientState( GL_TEXTURE_COORD_ARRAY );
				glTexCoordPointer( 2, GL_FLOAT, 0, uvData );

				glMatrixMode(GL_TEXTURE);
				glLoadIdentity();
				glScalef( 0.5f, 0.5f, 1 );
				//glTranslatef(0.5f, 0.5f, 0.0f);
				glRotatef( mTexRotateX, 1.0f, 0.0f, 0.0f);
				glRotatef( mTexRotateY, 0.0, 1.0f, 0.0f);
				glRotatef( mTexRotateZ, 0.0, 0.0f, 1.0f);
				glMatrixMode(GL_MODELVIEW);
			}
		}

		if (vertexData && normalData && pIndexing )
			glDrawElements ( GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, pIndexing );

		glPopClientAttrib();

		// Release data references
		pRenderer->dereferenceGeometry( pGeomData, numberOfData );

	}
	glDisable( GL_COLOR_MATERIAL );
	glDisable( GL_LIGHTING );
}
Exemple #17
0
int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(500, 500);
    glutCreateWindow("Newave");
    if (argc > 1 && argv[1] != 0)
        texFilename1 = argv[1];
    if (argc > 2 && argv[2] != 0)
        texFilename2 = argv[2];
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glPolygonOffset(1.0, 1.0);
    glEnable(GL_CULL_FACE);
    glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
    glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
    glEnable(GL_COLOR_MATERIAL);
    glColorMaterial(GL_FRONT, GL_DIFFUSE);
    glLightfv (GL_LIGHT0, GL_POSITION, lightPosition);
    glEnable(GL_LIGHT0);
    loadImageTexture();

    setSize(MEDIUM);
    setSpeed(NORMAL);
    setDisplay(TEXTURED);
    setOther(ENVMAP);
    reset(HILLFOUR);

    glutReshapeFunc(reshape);
    glutDisplayFunc(display);
    glutVisibilityFunc(visibility);

    glutKeyboardFunc(keyboard);
    glutMouseFunc(mouse);
    glutMotionFunc(motion);

    displayMenu = glutCreateMenu(setDisplay);
    glutAddMenuEntry("Wireframe", WIREFRAME);
    glutAddMenuEntry("Hidden Line", HIDDENLINE);
    glutAddMenuEntry("Flat Shaded", FLATSHADED);
    glutAddMenuEntry("Smooth Shaded", SMOOTHSHADED);
    glutAddMenuEntry("Textured", TEXTURED);

    otherMenu = glutCreateMenu(setOther);
    glutAddMenuEntry("Full Screen", FULLSCREEN);
    glutAddMenuEntry("Face Normals", FACENORMALS);
    glutAddMenuEntry("Antialias", ANTIALIAS);
    glutAddMenuEntry("Environment Map", ENVMAP);

    speedMenu = glutCreateMenu(setSpeed);
    glutAddMenuEntry("Weak", WEAK);
    glutAddMenuEntry("Normal", NORMAL);
    glutAddMenuEntry("Strong", STRONG);

    sizeMenu = glutCreateMenu(setSize);
    glutAddMenuEntry("Small", SMALL);
    glutAddMenuEntry("Medium", MEDIUM);
    glutAddMenuEntry("Large", LARGE);
    glutAddMenuEntry("Extra Large", XLARGE);

    resetMenu = glutCreateMenu(reset);
    glutAddMenuEntry("Current", CURRENT);
    glutAddMenuEntry("Spike", SPIKE);
    glutAddMenuEntry("Hole", HOLE);
    glutAddMenuEntry("Diagonal Wall", DIAGONALWALL);
    glutAddMenuEntry("Side Wall", SIDEWALL);
    glutAddMenuEntry("Middle Block", MIDDLEBLOCK);
    glutAddMenuEntry("Diagonal Block", DIAGONALBLOCK);
    glutAddMenuEntry("Corner Block", CORNERBLOCK);
    glutAddMenuEntry("Hill", HILL);
    glutAddMenuEntry("Hill Four", HILLFOUR);

    mainMenu = glutCreateMenu(setMain);
    glutAddMenuEntry("Go", 2);
    glutAddMenuEntry("Stop", 3);
    glutAddMenuEntry("Reverse", 4);
    glutAddSubMenu("Display", displayMenu);
    glutAddSubMenu("Reset", resetMenu);
    glutAddSubMenu("Size", sizeMenu);
    glutAddSubMenu("Speed", speedMenu);
    glutAddSubMenu("Other", otherMenu);
    glutAddMenuEntry("Exit", 5);
    glutAttachMenu(GLUT_RIGHT_BUTTON);

    glutMainLoop();
    return 0;             /* ANSI C requires main to return int. */
}
Exemple #18
0
// this is the code that actually draws the window
// it puts a lot of the work into other routines to simplify things
void TrainView::draw()
{

	glViewport(0,0,w(),h());

	// clear the window, be sure to clear the Z-Buffer too
	glClearColor(0,0,.3f,0);		// background should be blue
	// we need to clear out the stencil buffer since we'll use
	// it for shadows
	glClearStencil(0);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
	glEnable(GL_DEPTH);

	// Blayne prefers GL_DIFFUSE
    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);

	// prepare for projection
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	setProjection();		// put the code to set up matrices here

	// TODO: you might want to set the lighting up differently
	// if you do, 
	// we need to set up the lights AFTER setting up the projection

	// enable the lighting
	glEnable(GL_COLOR_MATERIAL);
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);
	// top view only needs one light
	if (tw->topCam->value()) {
		glDisable(GL_LIGHT1);
		glDisable(GL_LIGHT2);
	} else {
		glEnable(GL_LIGHT1);
		glEnable(GL_LIGHT2);
	}
	// set the light parameters
	GLfloat lightPosition1[] = {0,1,1,0}; // {50, 200.0, 50, 1.0};
	GLfloat lightPosition2[] = {1, 0, 0, 0};
	GLfloat lightPosition3[] = {0, -1, 0, 0};
	GLfloat yellowLight[] = {0.5f, 0.5f, .1f, 1.0};
	GLfloat whiteLight[] = {1.0f, 1.0f, 1.0f, 1.0};
	GLfloat blueLight[] = {.1f,.1f,.3f,1.0};
	GLfloat grayLight[] = {.3f, .3f, .3f, 1.0};

	glLightfv(GL_LIGHT0, GL_POSITION, lightPosition1);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, whiteLight);
	glLightfv(GL_LIGHT0, GL_AMBIENT, grayLight);

	glLightfv(GL_LIGHT1, GL_POSITION, lightPosition2);
	glLightfv(GL_LIGHT1, GL_DIFFUSE, yellowLight);

	glLightfv(GL_LIGHT2, GL_POSITION, lightPosition3);
	glLightfv(GL_LIGHT2, GL_DIFFUSE, blueLight);

	// now draw the ground plane
	setupFloor();
	glDisable(GL_LIGHTING);
	drawFloor(200,10);
	glEnable(GL_LIGHTING);
	setupObjects();

	// we draw everything twice - once for real, and then once for
	// shadows
	drawStuff();

	// this time drawing is for shadows (except for top view)
	if (!tw->topCam->value()) {
		setupShadows();
		drawStuff(true);
		unsetupShadows();
	}
	
}
Exemple #19
0
void ccOctree::RenderOctreeAs(  CC_OCTREE_DISPLAY_TYPE octreeDisplayType,
								ccOctree* theOctree,
								unsigned char level,
								ccGenericPointCloud* theAssociatedCloud,
								int &octreeGLListID,
								bool updateOctreeGLDisplay)
{
	if (!theOctree || !theAssociatedCloud)
		return;

	glPushAttrib(GL_LIGHTING_BIT);

	if (octreeDisplayType == WIRE)
	{
		//cet affichage demande trop de memoire pour le stocker sous forme de liste OpenGL
		//donc on doit le generer dynamiquement
		
		glDisable(GL_LIGHTING); //au cas où la lumiere soit allumee
		ccGL::Color3v(ccColor::green.rgba);

		void* additionalParameters[] = { theOctree->m_frustrumIntersector };
		theOctree->executeFunctionForAllCellsAtLevel(	level,
														&DrawCellAsABox,
														additionalParameters);
	}
	else
	{
		glDrawParams glParams;
		theAssociatedCloud->getDrawingParameters(glParams);

		if (glParams.showNorms)
		{
			//DGM: Strangely, when Qt::renderPixmap is called, the OpenGL version is sometimes 1.0!
			glEnable((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2 ? GL_RESCALE_NORMAL : GL_NORMALIZE));
			glMaterialfv(GL_FRONT_AND_BACK,	GL_AMBIENT,		CC_DEFAULT_CLOUD_AMBIENT_COLOR.rgba  );
			glMaterialfv(GL_FRONT_AND_BACK,	GL_SPECULAR,	CC_DEFAULT_CLOUD_SPECULAR_COLOR.rgba );
			glMaterialfv(GL_FRONT_AND_BACK,	GL_DIFFUSE,		CC_DEFAULT_CLOUD_DIFFUSE_COLOR.rgba  );
			glMaterialfv(GL_FRONT_AND_BACK,	GL_EMISSION,	CC_DEFAULT_CLOUD_EMISSION_COLOR.rgba );
			glMaterialf (GL_FRONT_AND_BACK,	GL_SHININESS,	CC_DEFAULT_CLOUD_SHININESS);
			glEnable(GL_LIGHTING);

			glEnable(GL_COLOR_MATERIAL);
			glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
		}

		if (!glParams.showColors)
			ccGL::Color3v(ccColor::white.rgba);

		if (updateOctreeGLDisplay || octreeGLListID < 0)
		{
			if (octreeGLListID < 0)
				octreeGLListID = glGenLists(1);
			else if (glIsList(octreeGLListID))
				glDeleteLists(octreeGLListID,1);
			glNewList(octreeGLListID,GL_COMPILE);

			if (octreeDisplayType == MEAN_POINTS)
			{
				void* additionalParameters[2] = {	reinterpret_cast<void*>(&glParams),
													reinterpret_cast<void*>(theAssociatedCloud),
				};

				glBegin(GL_POINTS);
				theOctree->executeFunctionForAllCellsAtLevel(	level,
																&DrawCellAsAPoint,
																additionalParameters);
				glEnd();
			}
			else
			{
				//by default we use a box as primitive
				PointCoordinateType cs = theOctree->getCellSize(level);
				CCVector3 dims(cs,cs,cs);
				ccBox box(dims);
				box.showColors(glParams.showColors || glParams.showSF);
				box.showNormals(glParams.showNorms);

				//trick: replace all normal indexes so that they point on the first one
				{
					if (box.arePerTriangleNormalsEnabled())
						for (unsigned i=0;i<box.size();++i)
							box.setTriangleNormalIndexes(i,0,0,0);
				}

				//fake context
				CC_DRAW_CONTEXT context;
				context.flags = CC_DRAW_3D | CC_DRAW_FOREGROUND| CC_LIGHT_ENABLED;
				context._win = 0;

				void* additionalParameters[4] = {	reinterpret_cast<void*>(&glParams),
													reinterpret_cast<void*>(theAssociatedCloud),
													reinterpret_cast<void*>(&box),
													reinterpret_cast<void*>(&context)
				};

				theOctree->executeFunctionForAllCellsAtLevel(	level,
																&DrawCellAsAPrimitive,
																additionalParameters);
			}

			glEndList();
		}

		glCallList(octreeGLListID);

		if (glParams.showNorms)
		{
			glDisable(GL_COLOR_MATERIAL);
			glDisable((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2 ? GL_RESCALE_NORMAL : GL_NORMALIZE));
			glDisable(GL_LIGHTING);
		}
	}

	glPopAttrib();
}
Exemple #20
0
int Terrain::Create(float xOffset, float yOffset, float zOffset) 
{
	GLuint terrainDL;
	float startW,startL;

	GLuint texName = LoadTextures();

	startW = width / 2.0 - width;
	startL = - length / 2.0 + length;

	terrainDL = glGenLists(1);

	glNewList(terrainDL,GL_COMPILE);
	if (normals != NULL && colors != NULL) 
	{
		glColorMaterial(GL_FRONT, GL_DIFFUSE);
		glEnable(GL_COLOR_MATERIAL);
	}

	for (int i = 0 ; i < length-1; i++) 
	{
		glEnable(GL_TEXTURE_2D);
		glBindTexture(GL_TEXTURE_2D, texName);

		/*glBegin(GL_QUADS);
			glTexCoord2f(1, 0);
			glVertex3f(10, 80, 0);
			glTexCoord2f(1, 1);
			glVertex3f(10, 90, 0);
			glTexCoord2f(0, 1);
			glVertex3f(0, 90, 0);
			glTexCoord2f(0, 0);
			glVertex3f(0, 80, 0);
		glEnd();*/

		glBegin(GL_TRIANGLE_STRIP);
		for (int j = 0;j < width; j++) 
		{
		
			if (colors != NULL) 
				glColor3f(colors[3*((i+1)*width + j)], colors[3*((i+1)*width + j)+1], colors[3*((i+1)*width + j)+2]);
			if (normals != NULL)
				glNormal3f(normals[3*((i+1)*width + j)], normals[3*((i+1)*width + j)+1], normals[3*((i+1)*width + j)+2]);

			if (colors != NULL) 
				glColor3f(colors[3*(i*width + j)], colors[3*(i*width + j)+1], colors[3*(i*width + j)+2]);
			if (normals != NULL)
				glNormal3f(normals[3*(i*width + j)], normals[3*(i*width + j)+1], normals[3*(i*width + j)+2]);

			glTexCoord2f((i+1) / 512.0, j / 512.0);
			glVertex3f(startW + j + xOffset, heights[(i+1)*width + (j)] + yOffset, startL - (i+1) + zOffset);

			glTexCoord2f(i / 512.0, j / 512.0);
			glVertex3f(startW + j + xOffset, heights[(i)*width + j] + yOffset, startL - i + zOffset);
		}
		glEnd();
		glDisable(GL_TEXTURE_2D);
	}
	glEndList();
	return(terrainDL);
}
        void GLContext::Invoke( const Message &msg )
        {
            for ( Message::message_t::const_iterator &it = msg.m_message.begin();
                    it != msg.m_message.end(); ++it )
            {
                unsigned int size = (*it).m_int;
                int opcode = (*++it).m_int;
                switch( opcode )
                {
                    // Transformation
                    case MATRIX_MODE:
                        assert( size == 3 );
                        {
                            int mode = ToGLFlag( (*++it).m_int );
                            glMatrixMode( mode );
                        }
                        break;
                        
                    case PUSH_MATRIX:
                        assert( size == 2 );
                        {
                            glPushMatrix();
                        }
                        break;

                    case POP_MATRIX:
                        assert( size == 2 );
                        {
                            glPopMatrix();
                        }
                        break;

                    case LOAD_IDENTITY:
                        assert( size == 2 );
                        {
                            glLoadIdentity();
                        }
                        break;

                    case LOAD_MATRIX:
                        assert( size == 18 );
                        {
                            float x[16];
                            for ( int i=0; i<16; ++i )
                            {
                                x[i] = (*++it).m_float;
                            }
                            glLoadMatrixf( x );
                        }
                        break;

                    case MULT_MATRIX:
                        assert( size == 18 );
                        {
                            float x[16];
                            for ( int i=0; i<16; ++i )
                            {
                                x[i] = (*++it).m_float;
                            }
                            glMultMatrixf( x );
                        }
                        break;

                    case TRANSLATE:
                        assert( size == 5 );
                        {
                            float x = (*++it).m_float;
                            float y = (*++it).m_float;
                            float z = (*++it).m_float;
                            glTranslatef( x, y ,z );
                        }
                        break;

                    case ROTATE:
                        assert( size == 6 );
                        {
                            float angle = (*++it).m_float;
                            float x = (*++it).m_float;
                            float y = (*++it).m_float;
                            float z = (*++it).m_float;
                            glRotatef( angle, x ,y ,z );
                        }
                        break;

                    case SCALE:
                        assert( size == 5 );
                        {
                            float x = (*++it).m_float;
                            float y = (*++it).m_float;
                            float z = (*++it).m_float;
                            glScalef( x, y ,z );
                        }
                        break;

                        // Blocks
                    case BLOCK_BEGIN:
                        {
                            m_restoreVector.push_back( Message() );
                        }
                        break;

                    case BLOCK_END:
                        {
                            Restore();
                            m_restoreVector.pop_back();
                        }
                        break;

                    case SAVE:
                        assert( size == 3 );
                        {
                            int flag = (*++it).m_int;
                            Save( flag );
                        }
                        break;

                    case SAVE_LIGHT:
                        assert( size == 4 );
                        {
                            int light = (*++it).m_int;
                            int flag = (*++it).m_int;
                            SaveLight( light, flag );
                        }
                        break;

                    case SAVE_MATERIAL:
                        assert( size == 4 );
                        {
                            int face = (*++it).m_int;
                            int flag = (*++it).m_int;
                            SaveMaterial( face, flag );
                        }
                        break;

                        // State
                    case ENABLE:
                        assert( size == 3 );
                        {
                            int flag = (*++it).m_int;
                            glEnable( ToGLFlag( flag ));
                        }
                        break;

                    case DISABLE:
                        assert( size == 3 );
                        {
                            int flag = (*++it).m_int;
                            glDisable( ToGLFlag( flag ));
                        }
                        break;

                    case BLEND_FUNC:
                        assert( size == 4 );
                        {
                            int sf = (*++it).m_int;
                            int df = (*++it).m_int;
                            glBlendFunc( ToGLBlendFun( sf ), ToGLBlendFun( df ));
                        }
                        break;

                    case BIND_TEXTURE:
                        assert( size == 4 );
                        {
                            int target = ToGLFlag( (*++it).m_int );
                            int index = (*++it).m_int;
                            glBindTexture( target, index );
                        }
                        break;

                    case MATERIAL_PROPERTY_FLOAT_4:
                        assert ( size == 8 );
                        {
                            int face = ToGLFlag( (*++it).m_int );
                            int prop = ToGLMaterial( (*++it).m_int );
                            float color[4];
                            for ( int i=0; i<4; ++i ) { color[i] = (*++it).m_float; }
                            glMaterialfv( face, prop, color );
                        }
                        break;

                    case MATERIAL_PROPERTY_FLOAT:
                        assert( size == 5 );
                        {
                            int face = ToGLFlag( (*++it).m_int );
                            int prop = ToGLMaterial( (*++it).m_int );
                            float x = (*++it).m_float;
                            glMaterialf( face, prop, x );
                        }
                        break;

                    case LIGHT_PROPERTY_FLOAT_4:
                        assert ( size == 8 );
                        {
                            int light = ToGLFlag( (*++it).m_int );
                            int prop = ToGLLight( (*++it).m_int );
                            float color[4];
                            for ( int i=0; i<4; ++i ) { color[i] = (*++it).m_float; }
                            glLightfv( light, prop, color );
                        }
                        break;

                    case LIGHT_PROPERTY_FLOAT_3:
                        assert ( size == 7 );
                        {
                            int light = ToGLFlag( (*++it).m_int );
                            int prop = ToGLLight( (*++it).m_int );
                            float direction[3];
                            for ( int i=0; i<3; ++i ) { direction[i] = (*++it).m_float; }
                            glLightfv( light, prop, direction );
                        }
                        break;

                    case LIGHT_PROPERTY_FLOAT:
                        assert( size == 5 );
                        {
                            int light = ToGLFlag( (*++it).m_int );
                            int prop = ToGLLight( (*++it).m_int );
                            float x = (*++it).m_float;
                            glLightf( light, prop, x );
                        }
                        break;

                    case LIGHT_MODEL_PROPERTY_FLOAT_4:
                        assert( size == 7 );
                        {
                            int prop = (*++it).m_int;
                            float color[4];
                            for ( int i=0; i<4; ++i ) { color[i] = (*++it).m_float; }
                            glLightModelfv( prop, color );
                        }
                        break;

                    case LIGHT_MODEL_PROPERTY_INT:
                        assert( size == 4 );
                        {
                            int prop = ToGLLightModel( (*++it).m_int );
                            int x = (*++it).m_int;
                            glLightModeli( prop, x );
                        }
                        break;

                    case COLOR_MATERIAL_MODE:
                        assert( size == 4 );
                        {
                            int face = ToGLFlag( (*++it).m_int );
                            int mode = ToGLMaterial( (*++it).m_int );
                            glColorMaterial( face, mode );
                        }
                        break;

                    case BEGIN:
                        assert( size == 3 );
                        {
                            int type = (*++it).m_int;
                            glBegin( ToGLPrimitive( type ));
                        }
                        break;

                    case END:
                        assert( size == 2 );
                        glEnd();
                        break;

                    case VERTEX:
                        assert( size == 5 );
                        {
                            float x = (*++it).m_float;
                            float y = (*++it).m_float;
                            float z = (*++it).m_float;
                            glVertex3f(x,y,z);
                        }
                        break;

                    case NORMAL:
                        assert( size == 5 );
                        {
                            float x = (*++it).m_float;
                            float y = (*++it).m_float;
                            float z = (*++it).m_float;
                            glNormal3f(x,y,z);
                        }
                        break;

                    case COLOR:
                        assert( size == 6 );
                        {
                            float r = (*++it).m_float;
                            float g = (*++it).m_float;
                            float b = (*++it).m_float;
                            float a = (*++it).m_float;
                            glColor4f(r,g,b,a);
                        }
                        break;

                    case TEXTURE_COORD:
                        assert( size == 4 );
                        {
                            float u = (*++it).m_float;
                            float v = (*++it).m_float;
                            glTexCoord2f(u,v);
                        }
                        break;

                        // Client State
                    case ENABLE_CLIENT_STATE:
                        assert( size == 3 );
                        {
                            int flag = (*++it).m_int;
                            if ( flag != INDEX_ARRAY )
                            {
                                glEnableClientState( ToGLClientFlag( flag ));
                            }
                        }
                        break;

                    case DISABLE_CLIENT_STATE:
                        assert( size == 3 );
                        {
                            int flag = (*++it).m_int;
                            if ( flag != INDEX_ARRAY )
                            {
                                glDisableClientState( ToGLClientFlag( flag ));
                            }
                        }
                        break;

                    case VERTEX_ARRAY:
                        assert( size == 4 );
                        {
                            void *ptr = (*++it).m_pointer;
                            unsigned int s = (*++it).m_uint;
                            glVertexPointer( 3, GL_FLOAT, sizeof( GAL::P3f ), ptr );
                        }
                        break;

                    case NORMAL_ARRAY:
                        assert( size == 4 );
                        {
                            void *ptr = (*++it).m_pointer;
                            unsigned int s = (*++it).m_uint;
                            glNormalPointer( GL_FLOAT, sizeof( GAL::P3f ), ptr );
                        }
                        break;

                    case COLOR_ARRAY:
                        assert( size == 4 );
                        {
                            void *ptr = (*++it).m_pointer;
                            unsigned int s = (*++it).m_uint;
                            glColorPointer( 4, GL_FLOAT, sizeof( GAL::P4f ), ptr );
                        }
                        break;

                    case TEXTURE_COORD_ARRAY:
                        assert( size == 4 );
                        {
                            void *ptr = (*++it).m_pointer;
                            unsigned int s = (*++it).m_uint;
                            glTexCoordPointer( 2, GL_FLOAT, sizeof( GAL::P2f ), ptr );
                        }
                        break;

                    case INDEX_ARRAY:
                        assert( size == 4 );
                        {
                            void *ptr = (*++it).m_pointer;
                            unsigned int s = (*++it).m_uint;
                            m_indexPointer = reinterpret_cast< unsigned int *>( ptr );
                            m_numIndices = s;
                        }
                        break;

                    case DRAW_ELEMENTS:
                        assert( size == 5 );
                        {
                            int type = (*++it).m_int;
                            unsigned int first = (*++it).m_int;
                            unsigned int count = (*++it).m_int;
                            glDrawElements( ToGLPrimitive( type ), count, GL_UNSIGNED_INT, m_indexPointer + first );
                        }
                        break;

                    case MESSAGE_CB:
                        {
                            int cbOffset = (*++it).m_int;                            
                            char *cbPtr = reinterpret_cast< char *>( const_cast< int * >( &((*++it).m_int )));
                            cbPtr += cbOffset;
                            MessageCallback *pCB = reinterpret_cast< MessageCallback * >( cbPtr );
                            Invoke( pCB->Apply());
                            std::advance( it, size-4 );
                        }
                        break;

                    default:
                        std::advance( it, size-2 );
                        break;
                };
            }
        }
Exemple #22
0
static void init()
{
    glPushGroupMarkerEXT(0, "init");

    glGenTextures( 1, &tex );
    GLubyte pix[] = {
        0x60, 0xff, 0x00, 0xff,  0xff, 0x00, 0x00, 0xff,  0xff, 0x00, 0xff, 0xff,  0x00, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff,  0x00, 0x00, 0xff, 0xff,  0x00, 0x00, 0x00, 0xff,  0xff, 0x80, 0x00, 0xff,
        0x80, 0x80, 0xff, 0xff,  0xff, 0x00, 0x00, 0xff,  0x80, 0x80, 0x80, 0xff,  0x00, 0x80, 0x80, 0xff,
        0x00, 0xff, 0xff, 0xff,  0x00, 0x80, 0x00, 0xff,  0x80, 0x00, 0xff, 0xff,  0x00, 0x00, 0x80, 0xff
    };
    glTextureImage2DEXT( tex, GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, pix );
    glTextureParameteriEXT( tex, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
    glTextureParameteriEXT( tex, GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
    glBindMultiTextureEXT( texunit, GL_TEXTURE_2D, tex );

    GLfloat mat_specular[]   = { 0.0f, 0.0f, 1.0f, 1.0f };
    GLfloat mat_shininess[]  = { 50.0f };
    GLfloat light_position[] = { 1.0f, 1.0f, 0.2f, 1.0f };
    GLfloat light_atten[]    = { 1.0f, 1.0f, 1.0f };
    GLfloat light_diffuse[]  = { 10.0f, 10.0f, 10.0f, 10.0f };
    GLfloat light_specular[] = { 10.0f, 10.0f, 10.0f, 10.0f };
    GLfloat light_spotdir[]  = { -0.1f, -0.1f, -1.0f };
    GLfloat light_spotcut[]  = { 30.0f };
    GLfloat light_spotexp[]  = { 3.0f };
    glClearColor (0.0, 0.0, 0.0, 0.0);
    //glShadeModel (GL_SMOOTH);

    glMatrixPushEXT( GL_MODELVIEW );
    glMatrixLoadIdentityEXT( GL_MODELVIEW );

    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
    glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);
    //glMaterialfv(GL_BACK, GL_SHININESS, mat_shininess);
    glLightfv(GL_LIGHT0, GL_POSITION, light_position);
    glLightf( GL_LIGHT0, GL_LINEAR_ATTENUATION, light_atten[1] );
    glLightf( GL_LIGHT0, GL_QUADRATIC_ATTENUATION, light_atten[2] );
    glLightfv( GL_LIGHT0, GL_DIFFUSE, light_diffuse );
    glLightfv( GL_LIGHT0, GL_SPECULAR, light_specular );
    glLightfv( GL_LIGHT0, GL_SPOT_DIRECTION, light_spotdir );
    glLightfv( GL_LIGHT0, GL_SPOT_CUTOFF, light_spotcut );
    glLightfv( GL_LIGHT0, GL_SPOT_EXPONENT, light_spotexp );
    //GLfloat light_ambient[] = { 0.0, -1.0, 0.0, 0.0 };
    //glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);

    glMatrixPopEXT( GL_MODELVIEW );

    glLightModeli( GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE );
    glLightModelf( GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR );

    glEnable( GL_COLOR_MATERIAL ) ;
    glColorMaterial( GL_BACK, GL_SPECULAR );

    glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE );

    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);

    glFogi( GL_FOG_MODE, GL_LINEAR );
    glFogf( GL_FOG_START, 2.0f );
    glFogf( GL_FOG_END, 4.0f );
    GLfloat fog_color[] = { 1.0, 1.0, 0.0, 0.0 };
    glFogfv( GL_FOG_COLOR, fog_color );

    glEnable( GL_CLIP_PLANE3 );
    GLdouble clip[] = { 1, 1, -1, 0 };
    glClipPlane( GL_CLIP_PLANE3, clip );

    glPopGroupMarkerEXT();
}
Exemple #23
0
C_OGL_3DMODEL::C_OGL_3DMODEL( const S3DMODEL &a3DModel,
                              MATERIAL_MODE aMaterialMode )
{
    m_ogl_idx_list_meshes = 0;
    m_ogl_idx_list_opaque = 0;
    m_ogl_idx_list_transparent = 0;
    m_nr_meshes = 0;
    m_meshs_bbox = NULL;

    // Validate a3DModel pointers
    wxASSERT( a3DModel.m_Materials != NULL );
    wxASSERT( a3DModel.m_Meshes != NULL );
    wxASSERT( a3DModel.m_MaterialsSize > 0 );
    wxASSERT( a3DModel.m_MeshesSize > 0 );

    if( (a3DModel.m_Materials != NULL) && (a3DModel.m_Meshes != NULL) &&
        (a3DModel.m_MaterialsSize > 0) && (a3DModel.m_MeshesSize > 0) )
    {
        m_nr_meshes = a3DModel.m_MeshesSize;

        m_meshs_bbox = new CBBOX[a3DModel.m_MeshesSize];

        // Generate m_MeshesSize auxiliar lists to render the meshes
        m_ogl_idx_list_meshes = glGenLists( a3DModel.m_MeshesSize );

        // Render each mesh of the model
        // /////////////////////////////////////////////////////////////////////
        for( unsigned int mesh_i = 0; mesh_i < a3DModel.m_MeshesSize; ++mesh_i )
        {
            if( glIsList( m_ogl_idx_list_meshes + mesh_i ) )
            {
                const SMESH &mesh = a3DModel.m_Meshes[mesh_i];

                // Validate the mesh pointers
                wxASSERT( mesh.m_Positions != NULL );
                wxASSERT( mesh.m_FaceIdx != NULL );
                wxASSERT( mesh.m_Normals != NULL );

                if( (mesh.m_Positions != NULL) &&
                    (mesh.m_Normals != NULL) &&
                    (mesh.m_FaceIdx != NULL) &&
                    (mesh.m_FaceIdxSize > 0) && (mesh.m_VertexSize > 0) )
                {
                    SFVEC4F *pColorRGBA = NULL;

                    // Create the bbox for this mesh
                    // /////////////////////////////////////////////////////////
                    m_meshs_bbox[mesh_i].Reset();

                    for( unsigned int vertex_i = 0;
                         vertex_i < mesh.m_VertexSize;
                         ++vertex_i )
                    {
                        m_meshs_bbox[mesh_i].Union( mesh.m_Positions[vertex_i] );
                    }

                    // Make sure we start with client state disabled
                    // /////////////////////////////////////////////////////////
                    glDisableClientState( GL_TEXTURE_COORD_ARRAY );
                    glDisableClientState( GL_COLOR_ARRAY );


                    // Enable arrays client states
                    // /////////////////////////////////////////////////////////
                    glEnableClientState( GL_VERTEX_ARRAY );
                    glEnableClientState( GL_NORMAL_ARRAY );

                    glVertexPointer( 3, GL_FLOAT, 0, mesh.m_Positions );
                    glNormalPointer( GL_FLOAT, 0, mesh.m_Normals );

                    if( mesh.m_Color != NULL )
                    {
                        glEnableClientState( GL_COLOR_ARRAY );

                        float transparency = 0.0f;

                        if( mesh.m_MaterialIdx < a3DModel.m_MaterialsSize )
                            transparency = a3DModel.m_Materials[mesh.m_MaterialIdx].m_Transparency;

                        if( (transparency > FLT_EPSILON) &&
                            (aMaterialMode ==  MATERIAL_MODE_NORMAL) )
                        {
                            // Create a new array of RGBA colors
                            pColorRGBA = new SFVEC4F[mesh.m_VertexSize];

                            // Copy RGB array and add the Alpha value
                            for( unsigned int i = 0; i < mesh.m_VertexSize; ++i )
                                pColorRGBA[i] = SFVEC4F( mesh.m_Color[i],
                                                         1.0f - transparency );

                            // Load an RGBA array
                            glColorPointer( 4, GL_FLOAT, 0, pColorRGBA );
                        }
                        else
                        {
                            switch( aMaterialMode )
                            {
                            case MATERIAL_MODE_NORMAL:
                            case MATERIAL_MODE_DIFFUSE_ONLY:
                                // load the original RGB color array
                                glColorPointer( 3, GL_FLOAT, 0, mesh.m_Color );
                                break;
                            case MATERIAL_MODE_CAD_MODE:
                                // Create a new array of RGBA colors
                                pColorRGBA = new SFVEC4F[mesh.m_VertexSize];

                                // Copy RGB array and add the Alpha value
                                for( unsigned int i = 0; i < mesh.m_VertexSize; ++i )
                                {
                                    pColorRGBA[i] =
                                            SFVEC4F( MaterialDiffuseToColorCAD( mesh.m_Color[i] ),
                                                     1.0f );
                                }

                                // Load an RGBA array
                                glColorPointer( 4, GL_FLOAT, 0, pColorRGBA );
                                break;
                            default:
                                break;
                            }
                        }
                    }

                    if( mesh.m_Texcoords != NULL )
                    {
                        glEnableClientState( GL_TEXTURE_COORD_ARRAY );
                        glTexCoordPointer( 2, GL_FLOAT, 0, mesh.m_Texcoords );
                    }

                    // Compile the display list to store triangles
                    // /////////////////////////////////////////////////////////
                    glNewList( m_ogl_idx_list_meshes + mesh_i, GL_COMPILE );

                    // Set material properties
                    // /////////////////////////////////////////////////////////

                    if( mesh.m_Color != NULL )
                    {
                        // This enables the use of the Color Pointer information
                        glEnable( GL_COLOR_MATERIAL );
                        glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
                    }
                    else
                    {
                        glDisable( GL_COLOR_MATERIAL );
                    }

                    if( mesh.m_MaterialIdx < a3DModel.m_MaterialsSize )
                    {
                        switch( aMaterialMode )
                        {
                        case MATERIAL_MODE_NORMAL:
                            OGL_SetMaterial( a3DModel.m_Materials[mesh.m_MaterialIdx] );
                            break;
                        case MATERIAL_MODE_DIFFUSE_ONLY:
                            OGL_SetDiffuseOnlyMaterial(
                                        a3DModel.m_Materials[mesh.m_MaterialIdx].m_Diffuse );
                            break;
                        case MATERIAL_MODE_CAD_MODE:
                            OGL_SetDiffuseOnlyMaterial(
                                        MaterialDiffuseToColorCAD(
                                            a3DModel.m_Materials[mesh.m_MaterialIdx].m_Diffuse ) );
                            break;
                        default:
                            break;
                        }
                    }

                    // Draw mesh
                    // /////////////////////////////////////////////////////////
                    glDrawElements( GL_TRIANGLES, mesh.m_FaceIdxSize,
                                    GL_UNSIGNED_INT, mesh.m_FaceIdx );

                    glDisable( GL_COLOR_MATERIAL );

                    glEndList();

                    // Disable arrays client states
                    // /////////////////////////////////////////////////////////
                    glDisableClientState( GL_TEXTURE_COORD_ARRAY );
                    glDisableClientState( GL_COLOR_ARRAY );
                    glDisableClientState( GL_NORMAL_ARRAY );
                    glDisableClientState( GL_VERTEX_ARRAY );

                    glFinish();

                    delete [] pColorRGBA;
                }
            }
        }// for each mesh


        m_ogl_idx_list_opaque = glGenLists( 1 );

        // Check if the generated list is valid
        if( glIsList( m_ogl_idx_list_opaque ) )
        {
            bool have_opaque_meshes = false;
            bool have_transparent_meshes = false;

            // Compile the model display list
            glNewList( m_ogl_idx_list_opaque, GL_COMPILE );

            // Render each mesh display list (opaque first)
            // /////////////////////////////////////////////////////////////////
            for( unsigned int mesh_i = 0; mesh_i < a3DModel.m_MeshesSize; ++mesh_i )
            {
                const SMESH &mesh = a3DModel.m_Meshes[mesh_i];

                if( mesh.m_MaterialIdx < a3DModel.m_MaterialsSize )
                {
                    const SMATERIAL &material = a3DModel.m_Materials[mesh.m_MaterialIdx];

                    if( material.m_Transparency == 0.0f )
                    {
                        have_opaque_meshes = true; // Flag that we have at least one opaque mesh
                        glCallList( m_ogl_idx_list_meshes + mesh_i );
                    }
                    else
                    {
                        have_transparent_meshes = true; // Flag that we found a transparent mesh
                    }
                }
            }

            glEndList();

            if( !have_opaque_meshes )
            {
                // If we dont have opaque meshes, we can free the list
                glDeleteLists( m_ogl_idx_list_opaque, 1 );
                m_ogl_idx_list_opaque = 0;
            }

            if( have_transparent_meshes )
            {
                m_ogl_idx_list_transparent = glGenLists( 1 );

                // Check if the generated list is valid
                if( glIsList( m_ogl_idx_list_transparent ) )
                {
                    // Compile the model display list
                    glNewList( m_ogl_idx_list_transparent, GL_COMPILE );

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

                    // Render each mesh display list
                    // /////////////////////////////////////////////////////////
                    for( unsigned mesh_i = 0; mesh_i < a3DModel.m_MeshesSize; ++mesh_i )
                    {
                        const SMESH &mesh = a3DModel.m_Meshes[mesh_i];

                        if( mesh.m_MaterialIdx < a3DModel.m_MaterialsSize )
                        {
                            const SMATERIAL &material = a3DModel.m_Materials[mesh.m_MaterialIdx];

                            // Render the transparent mesh if it have a transparency value
                            if( material.m_Transparency != 0.0f )
                                glCallList( m_ogl_idx_list_meshes + mesh_i );
                        }
                    }

                    glDisable( GL_BLEND );

                    glEndList();
                }
                else
                {
                    m_ogl_idx_list_transparent = 0;
                }
            }
        }
        else
        {
            m_ogl_idx_list_opaque = 0;
        }

        // Create the main bbox
        // /////////////////////////////////////////////////////////////////////
        m_model_bbox.Reset();

        for( unsigned int mesh_i = 0; mesh_i < a3DModel.m_MeshesSize; ++mesh_i )
            m_model_bbox.Union( m_meshs_bbox[mesh_i] );

        glFinish();
    }
}
Exemple #24
0
/*
 *  OpenGL (GLUT) calls this routine to display the scene
 */
void display()
{
   const double len=2000;  //  Length of axes

   float Position[] = {X+700*Cos(Th)-400,Y+50*Sin(Th),300+Z+1200*Sin(Th),1-inf};
   //  Erase the window and the depth buffer
   glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
   //  Enable Z-buffering in OpenGL
   glEnable(GL_DEPTH_TEST);
   //  Undo previous transformations
   glLoadIdentity();
   //  Perspective - set eye position
   if (mode)
   {
      double Ex = -2*dim*Sin(th)*Cos(ph);
      double Ey = +2*dim        *Sin(ph);
      double Ez = +2*dim*Cos(th)*Cos(ph);
      gluLookAt(Ex,Ey,Ez , 0,0,0 , 0,Cos(ph),0);
   }
   //  Orthogonal - set world orientation
   else
   {
      glRotatef(ph,1,0,0);
      glRotatef(th,0,1,0);
   }
   glShadeModel(smooth?GL_SMOOTH:GL_FLAT);
   //  Light switch
   if (light)
   {
      //  Translate intensity to color vectors
      float Ambient[]   = {0.01*ambient ,0.01*ambient ,0.01*ambient ,1.0};
      float Diffuse[]   = {0.01*diffuse ,0.01*diffuse ,0.01*diffuse ,1.0};
      float Specular[]  = {0.01*specular,0.01*specular,0.01*specular,1.0};
      //  Spotlight color and direction
      float yellow[] = {1.0,1.0,0.0,1.0};
      float Direction[] = {Cos(Th)*Sin(Ph),Sin(Th)*Sin(Ph),-Cos(Ph),0};
      //  Draw light position as ball (still no lighting here)
      ball(Position[0],Position[1],Position[2] , 10);
      //  OpenGL should normalize normal vectors
      glEnable(GL_NORMALIZE);
      //  Enable lighting
      glEnable(GL_LIGHTING);
      //  Location of viewer for specular calculations
      glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER,local);
      //  Two sided mode
      glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,side);
      //  glColor sets ambient and diffuse color materials
      glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
      glEnable(GL_COLOR_MATERIAL);
      //  Set specular colors
      glMaterialfv(GL_FRONT,GL_SPECULAR,yellow);
      glMaterialfv(GL_FRONT,GL_SHININESS,shinyvec);
      //  Enable light 0
      glEnable(GL_LIGHT0);
      //  Set ambient, diffuse, specular components and position of light 0
      glLightfv(GL_LIGHT0,GL_AMBIENT ,Ambient);
      glLightfv(GL_LIGHT0,GL_DIFFUSE ,Diffuse);
      glLightfv(GL_LIGHT0,GL_SPECULAR,Specular);
      glLightfv(GL_LIGHT0,GL_POSITION,Position);
      //  Set spotlight parameters
      glLightfv(GL_LIGHT0,GL_SPOT_DIRECTION,Direction);
      glLightf(GL_LIGHT0,GL_SPOT_CUTOFF,sco);
      glLightf(GL_LIGHT0,GL_SPOT_EXPONENT,Exp);
      //  Set attenuation
      glLightf(GL_LIGHT0,GL_CONSTANT_ATTENUATION ,at0/100.0);
      glLightf(GL_LIGHT0,GL_LINEAR_ATTENUATION   ,at1/100.0);
      glLightf(GL_LIGHT0,GL_QUADRATIC_ATTENUATION,at2/100.0);
   }
   else
      glDisable(GL_LIGHTING);
   //  Enable textures
   if (ntex)
      glEnable(GL_TEXTURE_2D);
   else
      glDisable(GL_TEXTURE_2D);
   glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
   


   // drawing the 3 great pyramids of Egypt
      pyramid(0,0,0,      230.124,138.684,230.124, 0);
       
      pyramid(300,0,115,  30,30,30, 0);
      pyramid(300,0,20,  30,30,30, 0);
      pyramid(300,0,-75,  30,30,30, 0);

      pyramid(-500,0,600, 230,136,230, 0);

      cube(-100, 0, 600, 115, 30, 50, 0);
      // sphere2(-20, 90, 600, 30);

      pyramid(-900,0,990, 103.327,60.96,103.327, 0);
      
      // drawig the queens' pyramids
      pyramid(-900,0, 1200, 30, 30, 30, 0);
      pyramid(-1000,0, 1200, 30, 30, 30, 0);
      pyramid(-800,0, 1200, 30, 30, 30, 0);
   


   glDisable(GL_TEXTURE_2D);
   //  Draw axes - no lighting from here on
   glDisable(GL_LIGHTING);
   glColor3f(1,1,1);
   if (axes)
   {
      glBegin(GL_LINES);
      glVertex3d(0.0,0.0,0.0);
      glVertex3d(len,0.0,0.0);
      glVertex3d(0.0,0.0,0.0);
      glVertex3d(0.0,len,0.0);
      glVertex3d(0.0,0.0,0.0);
      glVertex3d(0.0,0.0,len);
      glEnd();
      //  Label axes
      glRasterPos3d(len,0.0,0.0);
      Print("X");
      glRasterPos3d(0.0,len,0.0);
      Print("Y");
      glRasterPos3d(0.0,0.0,len);
      Print("Z");
   }
   //  Display parameters
   glWindowPos2i(5,5);
   Print("Angle=%d,%d  Dim=%.1f Projection=%s Light=%s",
     th,ph,dim,mode?"Orthogonal":"Perpective",light?"On":"Off");
   if (light)
   {
      glWindowPos2i(5,65);
      Print("Cutoff=%.0f Exponent=%.1f Direction=%d,%d Attenuation=%.2f,%.2f,%.2f",sco,Exp,Th,Ph,at0/100.0,at1/100.0,at2/100.0);
      glWindowPos2i(5,45);
      Print("Model=%s LocalViewer=%s TwoSided=%s Position=%.1f,%.1f,%.1f,%.1f",smooth?"Smooth":"Flat",local?"On":"Off",side?"On":"Off",Position[0],Position[1],Position[2],Position[3]);
      glWindowPos2i(5,25);
      Print("Ambient=%d  Diffuse=%d Specular=%d Emission=%d Shininess=%.0f",ambient,diffuse,specular,emission,shinyvec[0]);
   }
   //  Render the scene and make it visible
   ErrCheck("display");
   glFlush();
   glutSwapBuffers();
}
Exemple #25
0
int main(int argc, char* argv[])
{
	atexit(onExit);

	/****************************************/
	/*   Initialize GLUT and create window  */
	/****************************************/

	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
	glutInitWindowPosition(50, 50);
	glutInitWindowSize(500, 500);

	main_window = glutCreateWindow("COMP 175 In Class Assignment 10");
	glutDisplayFunc(myGlutDisplay);
	glutReshapeFunc(myGlutReshape);

	/****************************************/
	/*       Set up OpenGL lighting         */
	/****************************************/

	glShadeModel(GL_SMOOTH);

	glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
	glEnable(GL_COLOR_MATERIAL);
	
	glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);

	static float one[] = { 1, 1, 1, 1 };
	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, one);


	/****************************************/
	/*       Set up OpenGL Shaders          */
	/****************************************/

	// Initialize our shader using our special shader manager class.
	myShaderManager = new shaderManager();
	
	myShaderManager->loadImage("brick.ppm",0);
	myShaderManager->loadImage("bump.ppm",1);

	//myShaderManager->initShader("shaders/Bump/bump.vert","shaders/Bump/bump.frag");
	dragonPLY = new ply("./data/dragon.ply");

	/****************************************/
	/*          Enable z-buferring          */
	/****************************************/

	glEnable(GL_DEPTH_TEST);
	glPolygonOffset(1, 1);

	/****************************************/
	/*         Here's the GLUI code         */
	/****************************************/

	GLUI *glui = GLUI_Master.create_glui("GLUI");

	/*** Create the bottom subwindow ***/
    glui2 = GLUI_Master.create_glui_subwindow( main_window, GLUI_SUBWINDOW_BOTTOM );
    // Create a rotation widget
    GLUI_Rotation *view_rot = new GLUI_Rotation(glui2, "Objects", view_rotate );
    view_rot->set_spin( 1.0 );

    // Navigate our world
    new GLUI_Column( glui2, false );
    GLUI_Translation *trans_x =  new GLUI_Translation(glui2, "Objects X", GLUI_TRANSLATION_X, obj_pos );
    trans_x->set_speed( .1 );
    new GLUI_Column( glui2, false );
    GLUI_Translation *trans_y =  new GLUI_Translation( glui2, "Objects Y", GLUI_TRANSLATION_Y, &obj_pos[1] );
    trans_y->set_speed( .1 );
    new GLUI_Column( glui2, false );
    GLUI_Translation *trans_z =  new GLUI_Translation( glui2, "Objects Z", GLUI_TRANSLATION_Z, &obj_pos[2] );
    trans_z->set_speed( .1 );

	glui2->add_column(true);

	GLUI_Panel *render_panel = glui2->add_panel("Render");
	new GLUI_Checkbox(render_panel, "Wireframe", &wireframe);
	new GLUI_Checkbox(render_panel, "Filled", &filled);
	new GLUI_Checkbox(render_panel, "Grid", &grid);


	glui2->add_button("Quit", 0, (GLUI_Update_CB)exit);



	glui->set_main_gfx_window(main_window);
	/* We register the idle callback with GLUI, *not* with GLUT */
	GLUI_Master.set_glutIdleFunc(myGlutIdle);



	glutMainLoop();

	return EXIT_SUCCESS;
}
Exemple #26
0
void Renderer::setLighting(){
	// recompute emissive light colors for highlighted bodies
	Real now=TimingInfo::getNow(/*even if timing is disabled*/true)*1e-9;
	highlightEmission0[0]=highlightEmission0[1]=highlightEmission0[2]=.8*normSquare(now,1);
	highlightEmission1[0]=highlightEmission1[1]=highlightEmission0[2]=.5*normSaw(now,2);

	glClearColor(bgColor[0],bgColor[1],bgColor[2],1.0);

	// set light sources
	glLightModelf(GL_LIGHT_MODEL_TWO_SIDE,1); // important: do lighting calculations on both sides of polygons

	const GLfloat pos[4]	= {(GLfloat)lightPos[0],(GLfloat)lightPos[1],(GLfloat)lightPos[2],(GLfloat)1.0};
	const GLfloat ambientColor[4]={0.5,0.5,0.5,1.0};
	const GLfloat specularColor[4]={1,1,1,1.};
	const GLfloat diffuseLight[4] = { (GLfloat)lightColor[0], (GLfloat)lightColor[1], (GLfloat)lightColor[2], 1.0f };
	glLightfv(GL_LIGHT0, GL_POSITION,pos);
	glLightfv(GL_LIGHT0, GL_SPECULAR, specularColor);
	glLightfv(GL_LIGHT0, GL_AMBIENT, ambientColor);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight);
	if (light1) glEnable(GL_LIGHT0); else glDisable(GL_LIGHT0);

	const GLfloat pos2[4]	= {(GLfloat)light2Pos[0],(GLfloat)light2Pos[1],(GLfloat)light2Pos[2],1.0};
	const GLfloat ambientColor2[4]={0.0,0.0,0.0,1.0};
	const GLfloat specularColor2[4]={.8,.8,.8,1.};
	const GLfloat diffuseLight2[4] = { (GLfloat)light2Color[0], (GLfloat)light2Color[1], (GLfloat)light2Color[2], 1.0f };
	glLightfv(GL_LIGHT1, GL_POSITION,pos2);
	glLightfv(GL_LIGHT1, GL_SPECULAR, specularColor2);
	glLightfv(GL_LIGHT1, GL_AMBIENT, ambientColor2);
	glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuseLight2);
	if (light2) glEnable(GL_LIGHT1); else glDisable(GL_LIGHT1);

	glEnable(GL_LIGHTING);

	// show both sides of triangles
	glDisable(GL_CULL_FACE);

	glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER,1);
	glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,1);

	// http://www.sjbaker.org/steve/omniv/opengl_lighting.html
	glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
	glEnable(GL_COLOR_MATERIAL);
	//Shared material settings
	resetSpecularEmission();


	// not sctrictly lighting related
	glEnable(GL_BLEND);
	glEnable(GL_LINE_SMOOTH);
	//glEnable(GL_POLYGON_SMOOTH);
	glShadeModel(GL_SMOOTH);
	#ifdef __MINGW64__ 
		// see http://www.opengl.org/discussion_boards/showthread.php/133406-GL_RESCALE_NORMAL-in-VC
		// why is glext.h not in mingw:
		//    * http://sourceforge.net/projects/mingw-w64/forums/forum/723797/topic/3572810
		glEnable(GL_NORMALIZE);
	#else
		glEnable(GL_RESCALE_NORMAL);
	#endif
	// important for rendering text, to avoid repetivie glDisable(GL_TEXTURE_2D) ... glEnable(GL_TEXTURE_2D)
	// glBindTexture(GL_TEXTURE_2D,0);
};
Exemple #27
0
ENTRYPOINT void
init_flipflop(ModeInfo *mi)
{
    int screen; 
    Flipflopcreen *c;

    if (MI_IS_WIREFRAME(mi)) textured = 0;

    /* Set all constants to their correct values */
    if (board_avg_size != 0) {  /* general size specified by user */
        board_x_size = board_avg_size;
        board_y_size = board_avg_size;
    } else {
        board_avg_size = (board_x_size + board_y_size) / 2;
    }
    if ((numsquares == 0) && (freesquares != 0)) {
        numsquares = board_x_size * board_y_size - freesquares; 
    }
    if (strcmp(flipflopmode_str, "tiles")) {
      textured = 0;  /* textures look dumb in stick mode */
        half_thick = 1.0 * DEF_STICK_THICK / 100.0; 
        if (numsquares == 0) {  /* No value defined by user */
            numsquares = board_x_size * board_y_size * DEF_STICK_RATIO / 100;
        }
    } else {
        half_thick = 1.0 * DEF_TILE_THICK / 100.0; 
        if (numsquares == 0) {  /* No value defined by user */
            numsquares = board_x_size * board_y_size * DEF_TILE_RATIO/ 100;;
        }
    }
    if (board_avg_size < 2) {
        fprintf (stderr,"%s: the board must be at least 2x2.\n", progname);
        exit(1);
    }
    if ((board_x_size < 1) || (board_y_size < 1) ||	(numsquares < 1)) {
        fprintf (stderr,"%s: the number of elements ('-count') and the dimensions of the board ('-size-x', '-size-y') must be positive integers.\n", progname);
        exit(1);
    }
    if (board_x_size * board_y_size <= numsquares) {
        fprintf (stderr,"%s: the number of elements ('-count') that you specified is too big \n for the dimensions of the board ('-size-x', '-size-y'). Nothing will move.\n", progname);
    }

    screen = MI_SCREEN(mi);
    wire = MI_IS_WIREFRAME(mi);

    if(!qs &&
       !(qs = (Flipflopcreen *) calloc(MI_NUM_SCREENS(mi), sizeof(Flipflopcreen))))
        return;

    c = &qs[screen];
    c->window = MI_WINDOW(mi);
    c->trackball = gltrackball_init (False);

    c->flipspeed = 0.03;
    c->reldist = 1;
    c->energy = 40;

    if((c->glx_context = init_GL(mi)))
        reshape_flipflop(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
    else
        MI_CLEARWINDOW(mi);

	/* At this point, all the constants have already been set, */
	/* so we can create the board */
    c->sheet = (randsheet*) malloc(sizeof(randsheet)); 
    randsheet_create( c->sheet ); 

    clearbits = GL_COLOR_BUFFER_BIT;

    glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
    glEnable(GL_COLOR_MATERIAL);
    setup_lights();

    glEnable(GL_DEPTH_TEST);
    clearbits |= GL_DEPTH_BUFFER_BIT;
    glEnable(GL_CULL_FACE);
    glCullFace(GL_BACK);

    randsheet_initialize( c->sheet );
    if( textured ){
        /* check for anisotropic filtering */
        if(strstr((char *)glGetString(GL_EXTENSIONS),
            "GL_EXT_texture_filter_anisotropic"))
            glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &c->anisotropic);
        else
            c->anisotropic = 0;

        /* allocate a new texture and get it */
        glGenTextures(1, &c->texid);
        get_texture(mi);
    }
}
Exemple #28
0
void obj_draw(
    Obj *obj,
    Vec3D position,
    Vec3D rotation,
    Vec3D scale,
    Vec4D color,
    Sprite *texture
)
{
    int i;
    ObjTriangle* triangle;
    float trans[4];

    if (obj == NULL)
    {
        slog("cannot draw obj, none specified!");
        return;
    }
    glPushMatrix();

    glEnable(GL_LIGHTING);
    glEnable(GL_BLEND);
    glEnable(GL_NORMALIZE);
    glColorMaterial(GL_FRONT,GL_DIFFUSE);
    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
    if(texture != NULL)
    {
        glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D,texture->texture);
    }

    glEnable(GL_COLOR_MATERIAL);
    glMaterialfv(GL_FRONT,GL_DIFFUSE,trans);
    glDepthFunc(GL_LEQUAL);

    glTranslatef(position.x,position.y,position.z);
    glRotatef(rotation.x, 1.0f, 0.0f, 0.0f);
    glRotatef(rotation.y, 0.0f, 1.0f, 0.0f);
    glRotatef(rotation.z, 0.0f, 0.0f, 1.0f);
    glScalef(scale.x,scale.y,scale.z);

    glColor3f(color.x,color.y,color.z);
    glBegin(GL_TRIANGLES);
    for (i = 0; i < obj->num_tris; i++)
    {
        triangle = &obj->triangle_array[i];
        if (obj->normal_array)
        {
            glNormal3f(
                obj->normal_array[triangle->p[0].n * 3],
                obj->normal_array[triangle->p[0].n * 3 + 1],
                obj->normal_array[triangle->p[0].n * 3 + 2]
            );
        }
        if (obj->texel_array)
        {
            glTexCoord2f(
                obj->texel_array[triangle->p[0].t * 2],
                obj->texel_array[triangle->p[0].t * 2 + 1]
            );
        }
        glVertex3f(
            obj->vertex_array[triangle->p[0].v * 3],
            obj->vertex_array[triangle->p[0].v * 3 + 1],
            obj->vertex_array[triangle->p[0].v * 3 + 2]
        );

        if (obj->normal_array)
        {
            glNormal3f(
                obj->normal_array[triangle->p[1].n * 3],
                obj->normal_array[triangle->p[1].n * 3 + 1],
                obj->normal_array[triangle->p[1].n * 3 + 2]
            );
        }
        if (obj->texel_array)
        {
            glTexCoord2f(
                obj->texel_array[triangle->p[1].t * 2],
                obj->texel_array[triangle->p[1].t * 2 + 1]
            );
        }
        glVertex3f(
            obj->vertex_array[triangle->p[1].v * 3],
            obj->vertex_array[triangle->p[1].v * 3 + 1],
            obj->vertex_array[triangle->p[1].v * 3 + 2]);

        if (obj->normal_array)
        {
            glNormal3f(
                obj->normal_array[triangle->p[2].n * 3],
                obj->normal_array[triangle->p[2].n * 3 + 1],
                obj->normal_array[triangle->p[2].n * 3 + 2]
            );
        }
        if (obj->texel_array)
        {
            glTexCoord2f(
                obj->texel_array[triangle->p[2].t * 2],
                obj->texel_array[triangle->p[2].t * 2 + 1]
            );
        }
        glVertex3f(
            obj->vertex_array[triangle->p[2].v * 3],
            obj->vertex_array[triangle->p[2].v * 3 + 1],
            obj->vertex_array[triangle->p[2].v * 3 + 2]);

    }
    glEnd();

    glColor4f(1,1,1,1);
    glDisable(GL_LIGHTING);
    glDisable(GL_BLEND);
    glDisable(GL_COLOR_MATERIAL);
    if(texture != NULL)
    {
        glDisable(GL_TEXTURE_2D);
    }
    glPopMatrix();
}
Exemple #29
0
void GLWidget::initializeGL()
{
	qglClearColor(Qt::black);
	glEnable(GL_DEPTH_TEST);
	glEnable (GL_BLEND);
	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glShadeModel(GL_SMOOTH);
	glEnable(GL_NORMALIZE);
	glEnable(GL_LIGHTING);
	glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
	glEnable(GL_COLOR_MATERIAL);
	
	glEnable(GL_CULL_FACE);
	
	if (GLEW_OK != glewInit())
	{
		qDebug() << "glewInit() failed!";
		exit(1);
	}
	
	if(m_displaying_particles)
	{
		glEnable(GL_FOG);
		float fog_color[] = {1.0, 1.0, 1.0, 1.0};
		float fog_density[] = {0.3};
		glFogfv(GL_FOG_COLOR, fog_color);
		glFogfv(GL_FOG_DENSITY, fog_density);
	}
	
	float ambient[] = {0.1, 0.1, 0.1, 1.0};
	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);

	glEnable(GL_LIGHT0);
	glLighti(GL_LIGHT0, GL_NONE, 1);

	
	skybox = new Skybox();
	for (int i = 1; i<10; i++){
		glNewList(i, GL_COMPILE);
		tree();
		glEndList();
	}
	glNewList(11, GL_COMPILE);
	glColor3f(1.0,1.0,1.0);
	sphere();
	glEndList();
	m_map = new Map();
	
	change_current_chunk();
	qDebug() << "HARP DARP" << m_nchunk;
	Heightmap * hm = m_nchunk->heightmap;
	m_particles = new ParticleEngine();
	
	//cam = new TerrainCamera(2.5,2.5,hm, m_map);
	cam = new Camera3d(0,1.0,0, m_map);
	
	m_bloomShader = new BloomShader(this);	
	m_toonShader = new ToonShader();
	m_plainShader = new PlainShader();
	m_fbo = new QGLFramebufferObject(width(), height(), QGLFramebufferObject::NoAttachment);
	
	glGenRenderbuffers(1, &m_depthBuf);
}
Exemple #30
0
int main(int argc, char **argv) {
    buildTerrain();
    //Make the mian plane the lead friendly plane 
    friendlyPlanes.push_back(mainPlane);
    cDetector.carriers = &carriers;
    cDetector.tiles = &tiles;
    cDetector.friendlyPlanes = &friendlyPlanes;
    cDetector.enemyPlanes = &enemyPlanes;
    cDetector.mainPlane = &mainPlane;
    cDetector.explosives = &explosives;
    //buildEnemyPlanes();
    buildCarrierGroup();
    buildSilos();
    mainPlane.y = 45;
    mainPlane.explosives = &explosives;
    //explosives.generateExplosion(0, 45, -100, 0, 0, 0);

    glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
	glutInitWindowPosition(100,100);
	glutInitWindowSize(1024,768);
    //glutInitWindowSize(600,400);
	glutCreateWindow("Flight Simulator Basic");
    
	initScene();
    
    // Enable lighting
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_LIGHT1);
    GLfloat light_ambient[] = { 1, 1, 1, 1 };
    GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
    GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 };
    GLfloat light_pos[] = { 0.0, 30.0, 0.0, 1 };
    GLfloat light_dir[] = { 0.0, 0, 0};
    GLfloat mat_specular[] = {0.3, 0.3, 0.3, 1.0};
    GLfloat mat_shininess[] = { 10.0 };
    glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
    glLightfv(GL_LIGHT0, GL_POSITION, light_pos);
    glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, light_dir);
    glLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient);
    glLightfv(GL_LIGHT1, GL_SPECULAR, light_specular);
    glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
    glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
    glEnable(GL_COLOR_MATERIAL);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_BLEND);
    glClearColor(0.0f, 0.0f, .6f, .5f);
    
	glutIgnoreKeyRepeat(.05);
	glutSpecialFunc(pressKey);
    //glutKeyboardFunc(pressKey);
	glutSpecialUpFunc(releaseKey);
    
	glutDisplayFunc(renderScene);
	glutIdleFunc(renderScene);
    
	glutReshapeFunc(changeSize);
    
	glutMainLoop();
    
	return(0);
}