// cubo //////////////////////////////////////////////////////////////
// v6----- v5
// /| /|
// v1------v0|
// | | | |
// | |v7---|-|v4
// |/ |/
// v2------v3
Model_Cube::Model_Cube(float size)
{
// Vertices
vertices.push_back(_vertex3f(-size, -size, size));
vertices.push_back(_vertex3f(size, -size, size));
vertices.push_back(_vertex3f(size, size, size));
vertices.push_back(_vertex3f(-size, size, size));
vertices.push_back(_vertex3f(-size, -size, -size));
vertices.push_back(_vertex3f(size, -size, -size));
vertices.push_back(_vertex3f(size, size, -size));
vertices.push_back(_vertex3f(-size, size, -size));
// Caras
caras.push_back(_vertex3i(0, 1, 4));
caras.push_back(_vertex3i(1, 5, 4));
caras.push_back(_vertex3i(1, 2, 5));
caras.push_back(_vertex3i(2, 6, 5));
caras.push_back(_vertex3i(2, 3, 6));
caras.push_back(_vertex3i(3, 7, 6));
caras.push_back(_vertex3i(3, 0, 7));
caras.push_back(_vertex3i(0, 4, 7));
caras.push_back(_vertex3i(4, 5, 7));
caras.push_back(_vertex3i(5, 6, 7));
caras.push_back(_vertex3i(3, 2, 0));
caras.push_back(_vertex3i(2, 1, 0));
}
// piramide /////////////////////////////////////////////
// /\.
// / |\/.
// / | \/ .
// / | \/./
// /____|___\/
Model_Pyramid::Model_Pyramid(float size)
{
// Vertices
vertices.push_back(_vertex3f(-size, -size, size));
vertices.push_back(_vertex3f(size, -size, size));
vertices.push_back(_vertex3f(size, size, size));
vertices.push_back(_vertex3f(-size, size, size));
vertices.push_back(_vertex3f(0, 0, size*3)); // punta de la piramide
// Caras
caras.push_back(_vertex3i(1, 0, 3));
caras.push_back(_vertex3i(1, 3, 2));
caras.push_back(_vertex3i(0, 1, 4));
caras.push_back(_vertex3i(0, 4, 3));
caras.push_back(_vertex3i(3, 4, 2));
caras.push_back(_vertex3i(1, 2, 4));
}
// piramide /////////////////////////////////////////////
// /\.
// / |\/.
// / | \/ .
// / | \/./
// /____|___\/
Model_Pyramid::Model_Pyramid(float size)
{
vector<_vertex3f> vertices;
vector<_vertex3i> caras;
// Vertices
vertices.push_back(_vertex3f(-size, -size, size));
vertices.push_back(_vertex3f(size, -size, size));
vertices.push_back(_vertex3f(size, size, size));
vertices.push_back(_vertex3f(-size, size, size));
vertices.push_back(_vertex3f(0, 0, size*3)); // punta de la piramide
// Caras
caras.push_back(_vertex3i(1, 0, 3));
caras.push_back(_vertex3i(1, 3, 2));
caras.push_back(_vertex3i(0, 1, 4));
caras.push_back(_vertex3i(0, 4, 3));
caras.push_back(_vertex3i(3, 4, 2));
caras.push_back(_vertex3i(1, 2, 4));
setVertices(vertices);
setFaces(caras);
}
void Model_Revolution::generarNormalesVertices()
{
// Generamos las normales de los vertices
vector<_vertex3f> normales_vertices;
// Recorremos los vertices
for(int i = 0; i < _vertices.size(); i++)
{
_vertex3f verticeactual = _vertices[i];
_vertex3f normal(0,0,0);
// Recorremos las caras
for(int h = 0; h < _caras.size(); h++)
{
// Comprobamos si el vertice esta en otra cara (por la posicion)
if (_caras[h]._0 == i || _caras[h]._1 == i || _caras[h]._2 == i)
{
normal = _vertex3f(normal.x + _normales_caras[h].x,
normal.y + _normales_caras[h].y,
normal.z + _normales_caras[h].z);
}
}
// Antonio para normalizar
float modulo=sqrt(normal.x*normal.x+normal.y*normal.y+normal.z*normal.z);
normal.x=normal.x/modulo;
normal.y=normal.y/modulo;
normal.z=normal.z/modulo;
// Fin Antonio
// La agregago al vector
normales_vertices.push_back(normal);
}
setNormalesVertices(normales_vertices);
}
// cubo //////////////////////////////////////////////////////////////
// v6----- v5
// /| /|
// v1------v0|
// | | | |
// | |v7---|-|v4
// |/ |/
// v2------v3
Model_Cube::Model_Cube(float size)
{
setColor(0,1,0,1);
vector<_vertex3f> vertices;
vector<_vertex3i> caras;
// Vertices
vertices.push_back(_vertex3f(-size, -size, size));
vertices.push_back(_vertex3f(size, -size, size));
vertices.push_back(_vertex3f(size, size, size));
vertices.push_back(_vertex3f(-size, size, size));
vertices.push_back(_vertex3f(-size, -size, -size));
vertices.push_back(_vertex3f(size, -size, -size));
vertices.push_back(_vertex3f(size, size, -size));
vertices.push_back(_vertex3f(-size, size, -size));
// Caras
caras.push_back(_vertex3i(0, 1, 4));
caras.push_back(_vertex3i(1, 5, 4));
caras.push_back(_vertex3i(1, 2, 5));
caras.push_back(_vertex3i(2, 6, 5));
caras.push_back(_vertex3i(2, 3, 6));
caras.push_back(_vertex3i(3, 7, 6));
caras.push_back(_vertex3i(3, 0, 7));
caras.push_back(_vertex3i(0, 4, 7));
caras.push_back(_vertex3i(4, 5, 7));
caras.push_back(_vertex3i(5, 6, 7));
caras.push_back(_vertex3i(3, 2, 0));
caras.push_back(_vertex3i(2, 1, 0));
setVertices(vertices);
setFaces(caras);
}
_multiple_meshes::_multiple_meshes()
{
fesc = _vertex3f(1.0,1.0,1.0);
despl = _vertex3f( 0.0,0.0,0.0);
}
_sup_par_triangles_object3D::_sup_par_triangles_object3D
(
const unsigned long nu,
const unsigned long nv,
const FunPar & fp
)
{
assert( nu > 1 && nv > 1 );
const unsigned long
nverts = (nu+1L)*(nv+1L) , // número total de vértices del modelo
//naris = 3L*nverts + nu + nv , // número total de aristas del modelo
ncaras = 2L*nu*nv ; // número de caras del modelo
// crear tablas de vértices, normales y coordenadas de textura
Vertices.resize( nverts );
Vertices_normals.resize( nverts );
Vertices_tex_coords.resize( nverts );
for( unsigned long iv = 0 ; iv <= nv ; iv++ )
for( unsigned long iu = 0 ; iu <= nu ; iu++ )
{
const vector2d // coords. paramétricas
cpar( double(iu)/double(nu) , double(iv)/double(nv) );
vector3d
pos, nor ; // posicion y normal
// evalua posición y normal a partir de las coordenadas paramétricas
fp.eval( cpar.s,cpar.t, pos, nor );
// insertar vectores en las tablas
const unsigned long
inv = indice(nu,nv,iu,iv) ; // indice del vértice en la tabla
Vertices[inv] = _vertex3f( pos.x, pos.y, pos.z ) ;
Vertices_normals[inv] = _vertex3f( nor.x, nor.y, nor.z ) ;
Vertices_tex_coords[inv] = _vertex2f( cpar.s, 1.0-cpar.t );
}
Vertices_normals_computed = true ;
Vertices_tex_coords_computed = true ;
// crear tablas de aristas y caras
Faces_vertices.resize( ncaras );
unsigned long
co_car = 0L ;
for( unsigned long iv = 0 ; iv < nv ; iv++ )
for( unsigned long iu = 0 ; iu < nu ; iu++ )
{
const unsigned long // indices de los vértices en la tabla de v.
inv0 = indice( nu,nv, iu ,iv ) , // inf.izq.
inv1 = indice( nu,nv, iu+1,iv ) , // inf.der.
inv2 = indice( nu,nv, iu ,iv+1 ) , // sup.izq.
inv3 = indice( nu,nv, iu+1,iv+1 ) ; // sup.der.
Faces_vertices[co_car++] = _vertex3i( inv0, inv1, inv3 );
Faces_vertices[co_car++] = _vertex3i( inv0, inv3, inv2 );
}
// calcular la caja englobante y normales de caras
//compute_bounding_box();
compute_faces_normals() ;
}
void RevolutionGenerator::generate(unsigned int steps, vector<float> &vertices_vertex, Object3d & obj)
{
double angulo = (PI*2)/steps;
vector<float>::iterator
it = vertices_vertex.begin(),
vertices_vertex_end = vertices_vertex.end();
_vertex3f aux;
//Vértice tapa abajo
obj.addVertex(_vertex3f(0,vertices_vertex[1],0));
while(it != vertices_vertex_end) {
aux.x = (*it);
++it;
aux.y = (*it);
++it;
aux.z = (*it);
++it;
obj.addVertex(aux);
for(unsigned int i=0; i<steps; i++) {
double anguloR = angulo * i;
obj.addVertex(_vertex3f(
aux.x* cos(anguloR) + aux.z * sin(anguloR),
aux.y,
aux.z * cos(anguloR) - aux.x * sin(anguloR)));
}
}
//Vértice tapa arriba
obj.addVertex(_vertex3f(0,vertices_vertex[vertices_vertex.size()-2],0));
vector<int> faces_vertex;
int vertices_number = obj.getVerticesNumber();
//Caras tapa abajo
for(unsigned int i=1; i<=steps; i++) {
if(i==steps) {
//obj.addFace(_vertex3ui(0,i,(i+1)%steps));
} else {
obj.addFace(_vertex3ui(0,i,i+1));
}
}
for(unsigned int i=0; i<=steps; i++) {
if(i==steps) {
for(unsigned int j=i; j<(vertices_number-steps-1); j=j+steps) {
obj.addFace(_vertex3ui(j,j+1-steps,j+steps));
obj.addFace(_vertex3ui(j+steps,j+1,j+1-steps));
}
} else {
for(unsigned int j=i; j<(vertices_number-steps-1); j=j+steps) {
obj.addFace(_vertex3ui(j,j+1,j+1+steps));
obj.addFace(_vertex3ui(j+steps,j,j+1+steps));
}
}
}
//Tapa de arriba
for (unsigned int i=steps; i>=1; i--) {
if(i == 1) {
obj.addFace(_vertex3ui(
vertices_number-1,
vertices_number-i-1,
vertices_number-steps-1));
} else {
obj.addFace(_vertex3ui(vertices_number-1,
vertices_number-i-1,
vertices_number-i));
}
}
}
