• Jueves 2 de Mayo de 2024, 15:23

Autor Tema:  Materiales  (Leído 1764 veces)

Perla_kiko

  • Miembro MUY activo
  • ***
  • Mensajes: 114
    • Ver Perfil
Materiales
« en: Jueves 3 de Febrero de 2005, 18:51 »
0
Hola,

Ahora tengo un problema con los materiales...

Cargo desde un fichero ASE los materiales y lo guardo en una estructura

y hago el sguiente codigo...donde me equivoco pq se me todo blanco...

<!--xc1--></div><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>XCODE </td></tr><tr><td id='XCODE'><!--exc1-->
void CGlView::Cargar_Ase()
{
    char Linea[150];
    CString Linea2,sx,sy,sz,aux;
    int indice,v,RMat;

    


    ifstream entrada("barco_basico_ajustes.ase");
    if(entrada)                                              
    {    
        while(entrada)
        {    
            entrada.getline(Linea,150);
            Linea2=Linea;
            if (Linea2.Find("*MESH {")==2)
            {
                for (v=1;v<=5;v++)
                {
                    entrada.getline(Linea,150);
                    Linea2=Linea;
                    Buscar_num_ver_cara(Linea2);
                }
                for (indice=0;indice<=NumLineas-1;indice++)
                {
                    Cargar_Vertices(Linea2,indice);
                    entrada.getline(Linea,150);
                    Linea2=Linea;
                }
                entrada.getline(Linea,150);
                Linea2=Linea;
                entrada.getline(Linea,150);
                Linea2=Linea;
                for (indice=0;indice<=NumCaras-1;indice++)
                {
                    Cargar_Caras(Linea2,indice);
                    entrada.getline(Linea,150);
                    Linea2=Linea;
                }
            }//fi mesh
            v=Linea2.Find("*MATERIAL_REF");
            if (v>0)
            {
            RMat=atoi(Linea2.Mid(v+13,3));
            Dibujar_vertices(RMat);
            }

        }
    }
}

void CGlView::Dibujar_vertices(int mat)
{
    int c,divi=50;
    glMaterialfv (GL_FRONT, GL_AMBIENT, VMaterial[mat].Ambiente);
    glMaterialfv (GL_FRONT, GL_DIFFUSE, VMaterial[mat].Difuso);
    glMaterialfv (GL_FRONT, GL_SPECULAR, VMaterial[mat].Specular);
    glMaterialf (GL_FRONT, GL_SHININESS, VMaterial[mat].Shine);
    glPushMatrix ();
for (c=0;c<=NumCaras-1;c++)
{
    glBegin(GL_TRIANGLES);
        glVertex3f(VVertice[VCaras[c].A].x/divi,VVertice[VCaras[c].A].y/divi,VVertice[VCaras[c].A].z/divi);
        glVertex3f(VVertice[VCaras[c].B].x/divi,VVertice[VCaras[c].B].y/divi,VVertice[VCaras[c].B].z/divi);
        glVertex3f(VVertice[VCaras[c].C].x/divi,VVertice[VCaras[c].C].y/divi,VVertice[VCaras[c].C].z/divi);
    glEnd();
}
glPopMatrix ();

    
};)
void CGlView::Cargar_Materiales()
{
    
    char Linea[150];
    CString Linea2,aux,sx,sy,sz;
    int v,NMat,n,seguir=1;
    ifstream entrada("barco_basico_ajustes.ase");
    if(entrada)                                              
    {    
        while(entrada)
        {    
            entrada.getline(Linea,150);
            Linea2=Linea;
            if (Linea2.Find("*MATERIAL_COUNT")==1)
            {
                v=Linea2.Find("*MATERIAL_COUNT");
                NMat=atoi(Linea2.Mid(v+16,3));
                for (n=0;n<=(NMat-1);n++)
                {
                    seguir=1;
                    while(seguir==1)
                    {
                        if (Linea2.Find("*MATERIAL_AMBIENT")==2)Cargar_Mat_Amb(Linea2,n);
                        if (Linea2.Find("*MATERIAL_DIFFUSE")==2)Cargar_Mat_Dif(Linea2,n);
                        if (Linea2.Find("*MATERIAL_SPECULAR")==2)Cargar_Mat_Spe(Linea2,n);
                        if (Linea2.Find("*MATERIAL_SHINE ")==2)
                        {
                            Cargar_Mat_shi(Linea2,n);
                            seguir=0;
                        }
                    entrada.getline(Linea,150);
                    Linea2=Linea;
                    }
                }
                entrada.getline(Linea,150);
            }
        entrada.getline(Linea,150);
        }
    }
}
int CGlView::DrawGLScene(GLvoid)                    // Here's Where We Do All The Drawing
{
    glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
    glMatrixMode (GL_MODELVIEW);
    glLoadIdentity ();
    glPushMatrix ( );
    glTranslatef(mx,my,mz);
    glRotatef(alpha,1.0f,0.0f,0.0f);
    glRotatef(beta,0.0f,0.0f,1.0f);
    glRotatef(r2,.0f,0.0f,1.0f);
    GLfloat light_ambient[] = { 0.75, 0.75, 0.75, 1.0 };
    GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
    GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 };
    GLfloat light_position[] = { 0.0, 0.0, 1.0, 0.0 };

    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, light_position);
    
    
    glEnable (GL_LIGHT0);
      Cargar_Materiales();
    Cargar_Ase();
    SwapBuffers(m_hDC);
    return TRUE;                                        // Keep Going
}<!--xc2--></td></tr></table><div class='postcolor'><!--exc2-->

Ruben3d: Me he permitido dar formato al código, ya que estaba simplemente pegado sobre el mensaje.

Ruben3d

  • Moderador
  • ******
  • Mensajes: 710
  • Nacionalidad: es
    • Ver Perfil
    • Web personal
Re: Materiales
« Respuesta #1 en: Sábado 5 de Febrero de 2005, 19:31 »
0
Asumo que has comprobado que el código que carga las definiciones de materiales es correcto.

En CGlView::DrawGLScene() añade, junto a glEnable(GL_LIGHT0), lo siguiente:
Código: Text
  1. glEnable(GL_LIGHTING);
  2. glShadeModel(GL_SMOOTH);
  3.  
Ésto activará la iluminación, en general, y el sombreado suave de la malla.

Según veo, no introduces las normales al pintar los triángulos. Las normales son necesarias para el cálculo de la iluminación. En OpenGL, las normales de la malla no se generan solas. Hay que calcularlas he introducirlas con glNormal3f(...) para cada vértice, de esta manera (código de ejemplo):
Código: Text
  1.  
  2.     glBegin(GL_TRIANGLES);
  3.     for (i=0; i&#60;g_Triangles.size(); i++)
  4.     {
  5.       int n;
  6.       for (n=0; n&#60;3; n++)
  7.       {
  8.         glNormal3f(g_Normals[g_Triangles[i].vertices[n]].x, g_Normals[g_Triangles[i].vertices[n]].y, g_Normals[g_Triangles[i].vertices[n]].z);
  9.         glVertex3f(g_Vertices[g_Triangles[i].vertices[n]].x, g_Vertices[g_Triangles[i].vertices[n]].y, g_Vertices[g_Triangles[i].vertices[n]].z);
  10.       }
  11.     }
  12.     glEnd();
  13.  
  14.  
En ese código, están precalculadas en un array.

Para calcular la normal de cada vértice has de calcular la normal de cada triángulo. Con ésto hecho, la normal de un vértice es la media de las normales de sus triángulos adyacentes (sumas todas las coordenadas X, Y y Z y las divides entre el número de triángulos adyacentes al vértice en cuestión). Con ésto tienes lo que en 3dsmas es llamado Grupo de suavizado (todo el objeto es suave), de talla el objeto completo. Según cómo calcules las normales, puedes hacer partes suaves y partes que no lo son (por ejemplo, un cilindro es suave excepto las tapas, que son planas).

Espero que te sirva.

Un saludo.

Ruben3d