Example #1
0
/**
 * Callback d'affichage d'OpenGL
 */
void DisplayCallback()
{
	// On ne repasse pas dans le loop si il y a une demande de fermeture
	if(_exitRequest || glutGet(GLUT_WINDOW_FORMAT_ID) == 0 ){
		_displayExited = true;
		return;
	}

	// Vidage de la frame	
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	// On dirige la caméra
	_camera->Look();

	// Par défaut, on applique un matérial blanc
	Material mat = Material();
	mat.ToWhiteReflect();
	mat.Enable();

	// Affichage de la montre
	glPushMatrix();
		glRotatef(-45.0, 1.0, 0.0, 0.0);
		glScalef(0.2, 0.2, 0.2);
		_montre->FastDisplay();
	glPopMatrix();

	// On réapplique le matériel 
	// Et on affiche la pièce
	mat.Enable();
	glPushMatrix();
		glTranslatef(0, -1.8, 0);
		glRotatef(-90, 1.0, 0.0, 0.0);
		_room->BuildAndDisplayHorloge();
		_room->FastDisplay();
	glPopMatrix();

	// Netoyage
	glutSwapBuffers();
	glFlush();
}
Example #2
0
void Montre::BuildStructureIntermediaire()
{
	// Plaque
	glPushMatrix();
		glTranslatef(-0.35, 0, 0);
		glRotatef(180, 0, 1, 0);
		_plaqueSeparation->FastDisplay();
	glPopMatrix();

	// Pilier de soutien
	for(int i=0; i<4; i++)
	{
		Material mat = Material();
		mat.ToBlackReflect();
		mat.Enable();
		glPushMatrix();
			glTranslatef((i%2?1:-1)*1.15, 0.02, (i%3?1:-1)*1.15);
			glRotatef(90, 1, 0, 0);
			_rotorInferieur->FastDisplay();
		glPopMatrix();
	}
}
void BlocMinute::BuildAndDisplay()
{
	float cos60 = cosf(DEGREES_TO_RADIANS(60.0));
	float sin60 = sinf(DEGREES_TO_RADIANS(60.0));
	float eHauteur = 0.5;
	float eHauteurTiges = 0.8;
	Point3D* pts = new Point3D[120 + 4 * 2];
	
	int nb = 0;
	// Point central
	//pts[nb++] = Point3D(cos60 + _longBase, 0.0, 0.0);

	// Faces gauche
	pts[nb++] = Point3D(_longBase + cos60, 0.0, _longBase/2);
	pts[nb++] = Point3D(cos60 + _longBras, 0.0, sin60 + _largBras);
	pts[nb++] = Point3D(cos60, 0.0, sin60 + _largBras);

	// Faces arcs
	int iArc1 = nb;
	for(int slice = 60; slice >= -60; slice--)
	{
		pts[nb++] = Point3D(_rayon * cosf(DEGREES_TO_RADIANS(slice)), 0.0, _rayon *  sinf(DEGREES_TO_RADIANS(slice)) );
	}
	int iArc2 = nb;
		
	// Faces droites
	pts[nb++] = Point3D(cos60, 0.0, - sin60 - _largBras);
	pts[nb++] = Point3D(cos60 + _longBras, 0.0, - sin60 - _largBras);
	pts[nb++] = Point3D(_longBase + cos60, 0.0, -_longBase/2);

	//glPolygonMode(GL_FRONT, GL_LINE);

	Material mat = Material();
	mat.ToChrome();
	mat.Enable();
	
	// Face du bas gauche
	glBegin(GL_TRIANGLE_FAN);
		for(int i=0; i<=iArc1 + 60; i++)
			glVertex3f(pts[i]._x, pts[i]._y, pts[i]._z);
	glEnd();

	// Face du bas droit
	glBegin(GL_TRIANGLE_FAN);
		glVertex3f(pts[nb-1]._x, pts[nb-1]._y, pts[nb-1]._z);
		for(int i=iArc1 + 60 ; i< nb-1; i++)
			glVertex3f(pts[i]._x, pts[i]._y, pts[i]._z);
	glEnd();

	// On relie les 2 faces du bas de droite et gauche
	glBegin(GL_TRIANGLE_STRIP);
		glVertex3f(pts[nb-1]._x, pts[nb-1]._y, pts[nb-1]._z);
		glVertex3f(pts[iArc1+60]._x, pts[iArc1+60]._y, pts[iArc1+60]._z);
		glVertex3f(pts[0]._x, pts[0]._y, pts[0]._z);
	glEnd();

	// Face du haut gauche
	glBegin(GL_TRIANGLE_FAN);
		for(int i=0; i<iArc1; i++)
			glVertex3f(pts[i]._x, pts[i]._y + _hauteur, pts[i]._z);
		for(int i=iArc1; i<=iArc1 + 60; i++)
			glVertex3f(pts[i]._x, pts[i]._y + _hauteur * eHauteur, pts[i]._z);
	glEnd();

	// Face du haut droit
	glBegin(GL_TRIANGLE_FAN);
		glVertex3f(pts[nb-1]._x, pts[nb-1]._y + _hauteur, pts[nb-1]._z);
		for(int i=iArc1 + 60 ; i< iArc2; i++)
			glVertex3f(pts[i]._x, pts[i]._y + _hauteur * eHauteur, pts[i]._z);
		for(int i=iArc2 ; i< nb-1; i++)
			glVertex3f(pts[i]._x, pts[i]._y + _hauteur, pts[i]._z);
	glEnd();

	// On relie les 2 faces du haut de droite et gauche
	glBegin(GL_TRIANGLE_STRIP);
		glVertex3f(pts[nb-1]._x, pts[nb-1]._y + _hauteur, pts[nb-1]._z);
		glVertex3f(pts[iArc1+60]._x, pts[iArc1+60]._y + _hauteur * eHauteur, pts[iArc1+60]._z);
		glVertex3f(pts[0]._x, pts[0]._y + _hauteur, pts[0]._z);
	glEnd();

	// Faces de cotés
	glBegin(GL_TRIANGLE_STRIP);
		for(int i=0; i<iArc1; i++)
		{
			glVertex3f(pts[i]._x, pts[i]._y, pts[i]._z);
			glVertex3f(pts[i]._x, pts[i]._y + _hauteur, pts[i]._z);
		}
		for(int i=iArc1 ; i<iArc2; i++)
		{
			glVertex3f(pts[i]._x, pts[i]._y, pts[i]._z);
			glVertex3f(pts[i]._x, pts[i]._y + _hauteur * eHauteur, pts[i]._z);
		}
		for(int i=iArc2; i<nb; i++)
		{
			glVertex3f(pts[i]._x, pts[i]._y, pts[i]._z);
			glVertex3f(pts[i]._x, pts[i]._y + _hauteur, pts[i]._z);
		}
		glVertex3f(pts[0]._x, pts[0]._y, pts[0]._z);
		glVertex3f(pts[0]._x, pts[0]._y + _hauteur, pts[0]._z);
	glEnd();

	mat = Material();
	mat.ToRuby();
	mat.Enable();
	
	float angle = 2;
	Point3D pCentre = Point3D(_rayon, _hauteur*eHauteur/1.15, 0);
	for(int i=-60; i<=60; i+=2)
	{
			
		glPushMatrix();

			float rad = DEGREES_TO_RADIANS(i);
			glRotatef(2.0, 0.0, 0.0, 1.0);
			glTranslatef(cosf(rad) * pCentre._x + sinf(rad) * pCentre._z , pCentre._y - (60-abs(i)) * 0.001, -sinf(rad) * pCentre._x + cosf(rad) * pCentre._z);
			glRotatef(i, 0.0, 1.0, 0.0);
				
			if(abs(i)<=20)
				glRotatef(20, 0.0, 0.0, 1.0);
			else if(abs(i) > 20 && abs(i) <= 30)
				glRotatef(20, 0.0, 0.0, 1.0);
			else if(abs(i) > 30 && abs(i) <= 40)
				glRotatef(25, 0.0, 0.0, 1.0);
			else if(abs(i) > 40 && abs(i) <= 50)
				glRotatef(27.5, 0.0, 0.0, 1.0);
			else if(abs(i) > 50)
				glRotatef(30, 0.0, 0.0, 1.0);

			glTranslatef(_largBras * 0.25, 0.0, 0.0);
			glScalef(i%5==0?_largBras * 0.35:_largBras*0.35/2, _largBase/(60 * 1.5), _largBase/(60 * 1.5));

			glPushMatrix();
				glutSolidCube(1);
			glPopMatrix();
		glPopMatrix();
	}

	mat.Disable();

	delete pts;
}
Example #4
0
void Montre::BuildStructureSuperieure(float rotation)
{
	// Ratio engrenage principale vers bras des heures
	float ratio_0p85_0p25 = 85.0 / 25.0;

	// Structure complète
	glPushMatrix();
	
		// Boite minute
		if(!_displayMecanismeOnly && !_displayMecanismeOnlyProcessing){
			glPushMatrix();
				glRotatef(180, 0, 1, 0);
				glTranslatef(0.325, 0.0, 0.0);
				_blocMinute->FastDisplay();

				glPushMatrix();
					glRotatef(-90, 1, 0, 0);

					glPushMatrix();
						glTranslatef(0.95, 1.6, 0.3);
						_chiffre0->FastDisplay();
					glPopMatrix();

					glPushMatrix();
						glTranslatef(1.7, 0.95, 0.3);
						_chiffre15->FastDisplay();
					glPopMatrix();

					glPushMatrix();
						glTranslatef(1.95, 0.0, 0.26);
						_chiffre30->FastDisplay();
					glPopMatrix();

					glPushMatrix();
						glTranslatef(1.7, -0.95, 0.3);
						_chiffre45->FastDisplay();
					glPopMatrix();

					glPushMatrix();
						glTranslatef(0.95, -1.6, 0.3);
						_chiffre60->FastDisplay();
					glPopMatrix();
				glPopMatrix();
			glPopMatrix();
		}


		// Engrenage principal
		glPushMatrix();
			glTranslatef(0, -0.01, 0);
			_engrenage_M0p01_0p85->FastDisplay();
		glPopMatrix();

		// Rotation de la structure complète
		glRotatef(rotation, 0, 1, 0);

		glPushMatrix();

			// Rotor structure principale du minutes heures
			glPushMatrix();
				glRotatef(90, 1, 0, 0);
				glTranslatef(0, 0, -0.045 * 2 - 0.15/2 - 0.15 - 0.025);
				_rotorPieceMaitresse->FastDisplay();
			glPopMatrix();

			// Sur-rotor central
			glPushMatrix();
				glRotatef(-30, 0, 1, 0);
				glRotatef(-90, 1, 0, 0);
				glTranslatef(0, 0, 0.045 * 2 + 0.15/2);
				_surCentralRotor->FastDisplay();
			glPopMatrix();

			// Piece maitresse
			glPushMatrix();
				glRotatef(-30, 0, 1, 0);
				_maitresse->FastDisplay();
			glPopMatrix();

			// Matrice des engrenages
			glPushMatrix();
				glTranslatef(0, -0.01, 0);

				// Parcours des bras mécaniques
				for(int iAxe = 0; iAxe<3; iAxe++)
				{
					// Placements des 3 axes
					glPushMatrix();
						glRotatef(iAxe*120, 0, 1, 0);

						// Engrenages intermédiaires
						// Rotation des engrenages intermédiaires
						glPushMatrix();
							glTranslatef(0.552, 0, 0);
							glRotatef(rotation * ratio_0p85_0p25 + iAxe*4, 0, 1, 0);
							_engrenage_M0p01_0p25->FastDisplay();
						glPopMatrix();

						// Engrenages finaux
						glPushMatrix();
							glTranslatef(1.11, 0, 0);
							
							// Rotation des engrenages 
							glPushMatrix();
								glRotatef(-rotation - iAxe*5, 0, 1, 0);
								_engrenage_M0p01_0p85->FastDisplay();
							glPopMatrix();

							// Plateau fixe
							glPushMatrix();
								glRotatef(-rotation - iAxe * 120, 0, 1, 0);
								
								// Cache engrenage
								glPushMatrix();
									glRotatef(-90, 1.0, 0.0, 0.0);

									// Rotor
									glPushMatrix();
										glTranslatef(0,0,0.045);
										_rotorEngrenageFinal->FastDisplay();
									glPopMatrix();

									// Cache
									glPushMatrix();
										glTranslatef(0,0,0.065);

										glPushMatrix();
											_cacheEngrenage->FastDisplay();
										glPopMatrix();

										// Pointeur horraire
										glPushMatrix();
											glRotatef(180, 0, 0, 1);

											// Cadre horraire
											glPushMatrix();
												glTranslatef(-0.8+0.08/2,-0.25,0.045+0.175);
												_pointeurHorraire->FastDisplay();
											glPopMatrix();
											
											// Cube heure
											glPushMatrix();
												glTranslatef(-0.27 - 0.085 - 0.07 - 0.05,0,0.17);
												glRotatef(GetCurrentHourRotation(iAxe), 1, 0, 0);
												_cubeHeure[iAxe]->FastDisplay();
											glPopMatrix();

											// Rotor Cube heure
											glPushMatrix();
												glTranslatef(-0.05,0,0.17);
												glRotatef(-90, 0, 1, 0);

												Material mat = Material();
												mat.ToBlackReflect();
												mat.Enable();
												_rotorCubeHeure->FastDisplay();

												glPushMatrix();
													glTranslatef(0,0,0.06);
													_connectorCubeHeure->BuildAndDisplay();
												glPopMatrix();

												glPushMatrix();
													glRotatef(180.0, 1,0,0);
													glTranslatef(0,0,-0.71);
													_connectorCubeHeure->BuildAndDisplay();
												glPopMatrix();
											glPopMatrix();
											
										glPopMatrix();

										// Pointeur mintute
										glPushMatrix();
											glTranslatef(0.03+0.085/2, 0.35/2, 0.045+0.175-0.085+0.05/2);
											glRotatef(180, 0, 0, 1);
											glRotatef(90, 1, 0, 0);
											_indicateurMin->FastDisplay();
										glPopMatrix();
									glPopMatrix();
								glPopMatrix();
							glPopMatrix();
						glPopMatrix();
					glPopMatrix();
				}
			glPopMatrix();
		glPopMatrix();
	glPopMatrix();
}