Ejemplo n.º 1
0
//-------------------------------------------------------------------------
void MontanaRusa::draw(bool relleno,bool dibujaNormales,bool derrapa){

	Malla::draw(relleno,dibujaNormales);  // Dibuja la malla
        
	PV3D* fderivate = fDerivate(carPos);
	PV3D* sderivate = sDerivate(carPos);

	PV3D* Tt=fDerivate(carPos); Tt->normalize();					// Tt = C'
	PV3D* Bt=fderivate->crossProduct(sderivate); Bt->normalize();	// Bt = C'.C''
	PV3D* Nt=Bt->crossProduct(Tt);									// Nt = Bt.Tt
	PV3D* Ct=function(carPos);										// Ct = C

	GLfloat m[] ={  Nt->getX(),	Nt->getY(),	Nt->getZ(),	0,		// Se niega Bt porque al ser 
					-Bt->getX(),-Bt->getY(),-Bt->getZ(),0,		// un producto escalar es perpendicular 
					Tt->getX(),	Tt->getY(),	Tt->getZ(),	0,		// al plano definido por C'.C'' 
					Ct->getX(),	Ct->getY(),	Ct->getZ(),	1};		// pero en sentido contrario

	glMatrixMode(GL_MODELVIEW);        
	glPushMatrix();
               
		glMultMatrixf(m);
		if (derrapa)
			glTranslated(0,0,-1.3);
		//glTranslated(Ct->getX(),Ct->getY(),Ct->getZ());  // lo pone en la posición pero no con la torsión necesaria
		car->draw(); 
              
	glPopMatrix();

	//deletes de los objetos ya no necesarios
	delete sderivate;	delete fderivate;	delete Tt;
	delete Bt;			delete Nt;			delete Ct;
		
}
Ejemplo n.º 2
0
//-------------------------------------------------------------------------
void MontanaRusa::build(){
     
	GLfloat intervaloToma = 2*2*M_PI/NQ;  // Hay que dar dos vueltas porque hay puntos con 2 valores
	
	Poligon *poli = new Poligon(new PV3D(),NP,tam);  // un polígono del tamaño y con los lados que queremos
    vector<PV3D*>* puntos= poli->getVertex();  
        
    for(int i=0;i<NQ;i++){  // Esto ocurre en cada "sección" del gusano
            GLfloat toma=intervaloToma*i;				// Este valor hace que a cada vuelta la "matriz" sea única
            
            PV3D* fderivate = fDerivate(toma);			// Se calculan los valores que ayudan al cálculo de los puntos
			PV3D* sderivate = sDerivate(toma);

			PV3D* Tt=fDerivate(toma); Tt->normalize();
            PV3D* Bt=fderivate->crossProduct(sderivate); Bt->normalize();
            PV3D* Nt=Bt->crossProduct(Tt);
            PV3D* Ct=function(toma);

			for(int j=0;j<NP;j++){									// Esto ocurre con cada uno de los vértices del polígono
                int numV=NP*i+j;
                PV3D* clon=puntos->at(j)->clone();					// Un clon del punto del polígono para trabajar
                PV3D* punto=clon->matrixProduct(Nt,Bt,Tt,Ct);
				vertex->at(numV)=punto;								// El punto recibe un identificador y siempre con sentido
                delete clon;  
            }

            //deletes de los objetos ya no necesarios
            delete sderivate;	delete fderivate;	delete Tt;
			delete Bt;			delete Nt;			delete Ct;

    }
    // Se construyen las caras

	for(int numFace=0;numFace<faces->size();numFace++){      //  |>Recorremos todas las caras en orden
        faces->at(numFace)= new Cara(4);
        vector<VerticeNormal*>* auxNormals= new vector<VerticeNormal*>(4);

		int a= (numFace) % (NP*NQ);
        int b= (nextVertex(numFace) )% (NP*NQ);		// Teniendo cuidado de cerrar bien el círculo
        int c= (nextVertex(numFace) +NP)% (NP*NQ);
        int d= (numFace+NP)% (NP*NQ);

        auxNormals->at(0)=new VerticeNormal(a,numFace);
        auxNormals->at(1)=new VerticeNormal(b,numFace);
        auxNormals->at(2)=new VerticeNormal(c,numFace);
        auxNormals->at(3)=new VerticeNormal(d,numFace);
        
        faces->at(numFace)->setIndicesVN(auxNormals); 
     }
	// Se hacen las normales

    for(int i=0;i<this->numFaces;i++){
            normals->at(i)= this->doVectorNormalNewell(faces->at(i));
    }
	
    delete poli;
	
}