예제 #1
0
PV3D* MontanaRusa::vNormal(GLfloat t){
	PV3D* bin = vBinormal(t);
	PV3D* tang = vTangente(t);

	PV3D* norm = bin->productoVectorial(tang);
	norm->normaliza();

	return norm;
}
예제 #2
0
void MontanaRusa::creaTuboFrenet(){
        //Lo multiplicamos por el numero de vueltas
        GLfloat intervalo = 2*M_PI*2/NQ;
        PV3D** vertices = getVertices();

        //Construimos los vertices de cada cara del tubo
        for(int i=0; i<NQ; i++){
                GLfloat valor = i*intervalo;
                PV3D* T = primeraDerivada(valor);
                T->normaliza();
                PV3D* B = primeraDerivada(valor)->productoVectorial(segundaDerivada(valor));
                B->normaliza();
                PV3D* N = B->productoVectorial(T);
                PV3D* C = funcion(valor);
                for(int j=0; j<NP; j++){
                        int indiceVertice = NP*i+j;
                        PV3D* vertice = perfil[j]->multiplicaMatriz(N,B,T,C);
                        vertices[indiceVertice] = vertice;
                }
        }

        //Construimos las caras
        for(int i=0; i<NQ; i++){
                for (int j=0; j<NP; j++){
                        int indiceCara = NP*i+j;
                        caras[indiceCara] = new Cara(4);
                        VerticeNormal** normalesCara = new VerticeNormal*[4];

                        int verticeBase = indiceCara;
                        int v0 = verticeBase % (NP*NQ);
                        int v1 = sucesor(verticeBase % (NP*NQ));
                        int v2 = (sucesor(verticeBase)+NP) % (NP*NQ);
                        int v3 = (verticeBase + NP) % (NP*NQ);

                        normalesCara[0] = new VerticeNormal(v0,indiceCara);
                        normalesCara[1] = new VerticeNormal(v1,indiceCara);
                        normalesCara[2] = new VerticeNormal(v2,indiceCara);
                        normalesCara[3] = new VerticeNormal(v3,indiceCara);

                        caras[indiceCara]->addVerticeNormal(normalesCara);
                }

        }

        //Calculamos las normales de cada cara
        for(int i=0; i<numCaras; i++){
                normales[i] = CalculoVectorNormalPorNewell(caras[i]);
        }
}
예제 #3
0
void MontanaRusa::dibujaCoche(){
        GLfloat movimiento = coche->getMovimiento();
        PV3D* T = primeraDerivada(movimiento);
        T->normaliza();
        PV3D* B = primeraDerivada(movimiento)->productoVectorial(segundaDerivada(movimiento));
        B->normaliza();
        PV3D* N = B->productoVectorial(T);
        PV3D* C = funcion(movimiento);

        GLfloat m[] = { N->getX(), N->getY(), N->getZ(), N->isPoint(),
                        B->getX(), B->getY(), B->getZ(), B->isPoint(),
                        T->getX(), T->getY(), T->getZ(), T->isPoint(),
                        C->getX(), C->getY(), C->getZ(), C->isPoint()};

        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
                glMultMatrixf(m);
                coche->dibuja();
        glPopMatrix();
}