hola a todos,

estoy cargando un modelo a partir de un fichero .3ds, cargo los colores del material y la trasparencia (y el shininess, y todo eso), y luego se los aplico. El problema que tengo es que la trasparencia parece que funciona, al menos le da un aspecto como traslucido al objeto, pero no va bien del todo, no se ve nada de lo que hay detras, solo un poco la parte de atras del mismo objeto. Pongo una captura:



Lo de arriba es el modelo como es. Lo de abajo es lo que veo cuando cargo yo el modelo. A parte de los colores que se van diferentes por las luces y todo eso, al menos si lo estuviera haciendo bien se veria algo de la pelota.

El codigo donde hago esto lo pongo abajo, mas o menos se ve en que orden llamo a las funciones de opengl y eso. Pongo las luces, calculo el material y le doy los vertices del trianglo y sus normales.

Antes de usar materiales usaba la funcion gColor4f y entonces si que se hacia bien la trasparencia, se veia lo de tras y eso.

Sabeis por que puede ser esto?

Un saludo y muchas gracias.

Código [Seleccionar] Expand


glLightfv (GL_LIGHT0, GL_AMBIENT, Light->ambient);
glLightfv (GL_LIGHT0, GL_DIFFUSE, Light->diffuse);
glLightfv (GL_LIGHT0, GL_SPECULAR, Light->specular);
glLightfv (GL_LIGHT0, GL_POSITION, TempLightPos);
glEnable (GL_LIGHTING);
glEnable (GL_LIGHT0);
   
   for (i=0;i<Obj->nObjectTriangles;i++)
   {
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

     Camera->VertexFromCamera(&Obj->WorldObjectVertexes[Obj->ObjectTriangles[i].a],&CameraVertexa);
     Camera->VertexFromCamera(&Obj->WorldObjectVertexes[Obj->ObjectTriangles[i].b],&CameraVertexb);
     Camera->VertexFromCamera(&Obj->WorldObjectVertexes[Obj->ObjectTriangles[i].c],&CameraVertexc);

     float mat_ambient[]=
     {((float)Obj->ObjectInfo3ds->Materials[Obj->ObjectInfo3ds->FaceMaterial[i]]->AmbientColorRgba.r)/0xff,
      ((float)Obj->ObjectInfo3ds->Materials[Obj->ObjectInfo3ds->FaceMaterial[i]]->AmbientColorRgba.g)/0xff,
      ((float)Obj->ObjectInfo3ds->Materials[Obj->ObjectInfo3ds->FaceMaterial[i]]->AmbientColorRgba.b)/0xff,
      ((float)(100-((float)Obj->ObjectInfo3ds->Materials[Obj->ObjectInfo3ds->FaceMaterial[i]]->Transparency)))/100};
     float mat_diffuse[]=
     {((float)Obj->ObjectInfo3ds->Materials[Obj->ObjectInfo3ds->FaceMaterial[i]]->DiffuseColorRgba.r)/0xff,
      ((float)Obj->ObjectInfo3ds->Materials[Obj->ObjectInfo3ds->FaceMaterial[i]]->DiffuseColorRgba.g)/0xff,
      ((float)Obj->ObjectInfo3ds->Materials[Obj->ObjectInfo3ds->FaceMaterial[i]]->DiffuseColorRgba.b)/0xff,
      ((float)(100-((float)Obj->ObjectInfo3ds->Materials[Obj->ObjectInfo3ds->FaceMaterial[i]]->Transparency)))/100};  
     float mat_specular[]=
     {((float)Obj->ObjectInfo3ds->Materials[Obj->ObjectInfo3ds->FaceMaterial[i]]->SpecularColorRgba.r)/0xff,
      ((float)Obj->ObjectInfo3ds->Materials[Obj->ObjectInfo3ds->FaceMaterial[i]]->SpecularColorRgba.g)/0xff,
      ((float)Obj->ObjectInfo3ds->Materials[Obj->ObjectInfo3ds->FaceMaterial[i]]->SpecularColorRgba.b)/0xff,
      ((float)(100-((float)Obj->ObjectInfo3ds->Materials[Obj->ObjectInfo3ds->FaceMaterial[i]]->Transparency)))/100};
     float mat_selfillum[]=
     {((float)Obj->ObjectInfo3ds->Materials[Obj->ObjectInfo3ds->FaceMaterial[i]]->SelfIllumColorRgba.r)/0xff,
      ((float)Obj->ObjectInfo3ds->Materials[Obj->ObjectInfo3ds->FaceMaterial[i]]->SelfIllumColorRgba.g)/0xff,
      ((float)Obj->ObjectInfo3ds->Materials[Obj->ObjectInfo3ds->FaceMaterial[i]]->SelfIllumColorRgba.b)/0xff,
      ((float)(100-((float)Obj->ObjectInfo3ds->Materials[Obj->ObjectInfo3ds->FaceMaterial[i]]->Transparency)))/100};

       glMaterialfv (GL_FRONT, GL_AMBIENT, mat_ambient);
       glMaterialfv (GL_FRONT, GL_DIFFUSE, mat_diffuse);
       glMaterialfv (GL_FRONT, GL_SPECULAR, mat_specular);
       glMaterialf (GL_FRONT, GL_SHININESS,1.28*((float)Obj->ObjectInfo3ds->Materials[Obj->ObjectInfo3ds->FaceMaterial[i]]->Shininess));

     glBegin(GL_TRIANGLES);

     Obj->GetWorldVertexNormal(i,0,&Normal);
     Normal.x+=Obj->WorldObjectVertexes[Obj->ObjectTriangles[i].a].x;
     Normal.y+=Obj->WorldObjectVertexes[Obj->ObjectTriangles[i].a].y;
     Normal.z+=Obj->WorldObjectVertexes[Obj->ObjectTriangles[i].a].z;
     Camera->VertexFromCamera(&Normal,&Normal);
     Normal.x-=CameraVertexa.x;
     Normal.y-=CameraVertexa.y;
     Normal.z-=CameraVertexa.z;
     glNormal3f(Normal.x,Normal.y,Normal.z);

     glVertex3f( CameraVertexa.x,    
                 CameraVertexa.y,    
                 CameraVertexa.z );

     Obj->GetWorldVertexNormal(i,1,&Normal);
     Normal.x+=Obj->WorldObjectVertexes[Obj->ObjectTriangles[i].b].x;
     Normal.y+=Obj->WorldObjectVertexes[Obj->ObjectTriangles[i].b].y;
     Normal.z+=Obj->WorldObjectVertexes[Obj->ObjectTriangles[i].b].z;
     Camera->VertexFromCamera(&Normal,&Normal);
     Normal.x-=CameraVertexb.x;
     Normal.y-=CameraVertexb.y;
     Normal.z-=CameraVertexb.z;
     glNormal3f(Normal.x,Normal.y,Normal.z);

     glVertex3f( CameraVertexb.x,    
                 CameraVertexb.y,    
                 CameraVertexb.z );

     Obj->GetWorldVertexNormal(i,2,&Normal);
     Normal.x+=Obj->WorldObjectVertexes[Obj->ObjectTriangles[i].c].x;
     Normal.y+=Obj->WorldObjectVertexes[Obj->ObjectTriangles[i].c].y;
     Normal.z+=Obj->WorldObjectVertexes[Obj->ObjectTriangles[i].c].z;
     Camera->VertexFromCamera(&Normal,&Normal);
     Normal.x-=CameraVertexc.x;
     Normal.y-=CameraVertexc.y;
     Normal.z-=CameraVertexc.z;
     glNormal3f(Normal.x,Normal.y,Normal.z);

     glVertex3f( CameraVertexc.x,    
                 CameraVertexc.y,    
                 CameraVertexc.z );
     
     glEnd();
     glDisable(GL_BLEND);


hola,

estoy haciendo un trozo de codigo para cargar objectos a partir de archivos 3ds. Estoy teniendo problemas con un campo. Seria el chunkid 0xa080, que se supone que es el color de la autoiluminación del objeto. El caso es que creo un material en 3d studio, le pongo autoiluminación y se lo asigno a un objeto, pero luego a parsear el fichero 3ds no encuentro el campo 0xa080, solamente encuentro el 0xa084, que es la intensidad de la autoiluminación.

Habia pensado que a lo mejor cambiara los colores ambiente, diffuse o specular pero no cambia nada de eso. De que parte se lee el color de la iluminacion? Deberia ser de ese campo, pero ya digo, solo mete el 0xa084.

hola,

soy nuevo por aquí (así como en el mundillo del 3d) así que aprovecho este post para presentarme también.

me gustaría hacer una pregunta sobre una pieza de código que he encontrado que implementa un test de colisión entre dos oriented bounding boxes. El código lo saqué de aquí:

http://www.gamasutra.com/features/19991018/Gomez_5.htm

El autor es Miguel Gómez. Me da la impresión que es un tutorial y trozo de código bastante conocido, por ejemplo un motor (opcode 1.2) lo usa, y lo he visto comentado en distintos foros.

El problema que tengo es llamando a la función OBBOverlap. Varias veces funciona y me devuelve correctamente si colisiona o no, pero cuando las dos boxes están en algunos ángulos y posiciones entre ellas lo que me devuelve es erroneo. Se ve claramente que no colisionan, pero me devuelven que sí.

Mi pregunta es si alguien por aquí ha usado esta función y en este caso de que manera le pasa los parámetros. A mi me parecía que estaba haciendo bien, y intentando seguir el código de la función me lo sigue pareciendo, pero en algunos casos me dice que colisionan cuando no es así.

La función tiene este prototipo:

//check if two oriented bounding boxes overlap
const bool OBBOverlap
(
//A
VECTOR& a, //extents
VECTOR& Pa, //position
VECTOR* A, //orthonormal basis
//B
VECTOR& b, //extents
VECTOR& Pb, //position
VECTOR* B //orthonormal basis
)

Teniendo las caras mas alta y mas baja de la caja así:

  v7 - v6
 /       /
v4 - v5

v3 - v2
/      /
v0 - v1

El extent (a) lo calculo así:

 Extents.x = fabs((v5->x - v3->x)/2);
 Extents.y = fabs((v5->y - v3->y)/2);
 Extents.z = fabs((v5->z - v3->z)/2);

La posición (Pa):

 Position.x = ((v5->x - v3->x)/2) + v3->x;
 Position.y = ((v5->y - v3->y)/2) + v3->y;
 Position.z = ((v5->z - v3->z)/2) + v3->z;

La base ortonormal (A) así:

 OrthoBasis[0].x = v2->x - v3->x;
 OrthoBasis[0].y = v2->y - v3->y;
 OrthoBasis[0].z = v2->z - v3->z;

 normalize(OrthoBasis[0]);

 OrthoBasis[1].x = v7->x - v3->x;
 OrthoBasis[1].y = v7->y - v3->y;
 OrthoBasis[1].z = v7->z - v3->z;
 
 normalize(OrthoBasis[1]);

 OrthoBasis[2].x = v0->x - v3->x;
 OrthoBasis[2].y = v0->y - v3->y;
 OrthoBasis[2].z = v0->z - v3->z;

 normalize(OrthoBasis[2]);

Veis algo mal?

Si no habeis usado esta, teneis alguna otra implementación de este test de colisiones?

Un saludo y gracias.