Clases Para La Luz (opengl)

[Leoheart]

 Wenas a todos,
Como tais? Bueno no conocereis mucho por que no posteo pero veo el foro casi a diario. Bueno soy principiante en esto de la programacion , y estoy haceindo una clase para gestionar las luces en el juego. No se si lo estoy haciendo bien , y quiero que me digais ke si se puede hacer de esa forma. No puedo probarlo por que no tengo un compilador ahora. Bueno hay va.

Class COGLLuces
{
   public:
          void ActivaLuz();
          unsigned void GetID();
          void DefineLuz(Luz, Pos , Amb , Dif , Spec);
   private:
   unsigned int ID;
};

void COGLLuces::ActivaLuz();
{
    glEnable(ID);
}

void COGLLuces::DefineLuz( Luz , Pos , Amb , Dif , Spec);
{
    glLightfv(ID, GL_Position, Pos);
    glLightfv(ID, GL_Ambient, Amb);
    glLightfv(ID, GL_Diffuse, Dif);
    glLightfv(ID, GL_Specular, Spec);
}

Void COGLLuces::GetID();
{
return ID;
}

Bueno decirme si hay algun error asias.

[Schaffer]

 A ver, GetID deberia devolver GLenum no Void o unsigned void supongo.

El atributo privado ID deberia ser de tipo GLenum ademas de que solo valen los valores
GL_LIGHT0-7 ($4000-$4007) normalmente.

El parametro luz de DefineLuz sobra y te faltaria poner sus tipos, ademas otros parámetros como la atenuación podrían ser interesantes, así como poder no especificarlos todos.

Además deberias activar la iluminacion en si. (glEnable(GL_LIGHTING))

Una función para apagar la luz no vendria mal tampoco.

Si quieres que todas tus dudas se aclaren busca por ahi el libro rojo de OpenGL que está en muchos sitios para bajarse.

Ale, ánimo.

[_Grey]

 Hace tiempo que no uso OGL (Por que es OGL? no^_^)

Asi a primera vista diria que le pongas un constructor donde coga el "ID", y un destructor donde libere ese "handle" a la luz.

Y ya puestos que pueda tratar con el resto de tipos de luz... no recuerdo mucho de OGL, pero lo primero que e dicho si que me parece importante, si tenemos encuenta que las luces en OGL estan limitadas a 8, 8 en teoria por suerte  (mola).

[Leoheart]

 Wenas,
Gracias por contestar. Vamos a ver he entendido todo lo que me has dicho pero lo de la atenuacion y todo eso que dices no se que es(soy novato) , por favor dime donde pouedo ver algo referente a eso.
Despues lo de activar la luz habia pensado en hacerlo asi :
GL_Enable(GL_Lighting);

...Lo que se tenga ke hacer con las luces...

GL_Disable(GL_Lighting);

Repsecto a lo de liberar el handle me podrias decir como se hace es ke no me acuerdo  (nooo)  :(

Reponder lo antes posible

[_Grey]

 Pues ahora que lo dices ese "handle" ni se coge ni se libera (ya digo que no hace que no le doy....), pero te las tendrias que apañar para que no usen el mismo indice de luz mas de una de ellas, o sera un caos.

yo en el programilla que hice tengo estos 2 arrays:

// ARRAY CON EL VALOR OpenGL de cada luz (porke GL_LIGHT0+1 != GL_LIGHT1 podria ser diferente)
unsigned int luces[8]={   GL_LIGHT0,
         GL_LIGHT1,
         GL_LIGHT2,
         GL_LIGHT3,
         GL_LIGHT4,
         GL_LIGHT5,
         GL_LIGHT6,
         GL_LIGHT7,
         };
// ARRAY con el valor de uso de la luz (0 no usada 1 usada despues de una en 0 las demas no se usan)
unsigned int lucesenuso[8]={0,
         0,
         0,
         0,
         0,
         0,
         0,
         0,
         };

cuando tengo que usar una luz, busco en lucesenuso un valor false, y cuando lo encuentro cojo en luces el "handle" de esa luz, si tengo que dejar alguna luz pongo su lucesenuso a 0, y ya esta.

PD: No se hasta que punto puede ser cierto que solo tenga 8 luces hoy, podria haber cambiado a estas alturas, pero ya se sabe la "norma" son 8.

[Schaffer]

 Buena página de referencia rápida, aunque un poco anticuada:
MSDN (OpenGL)

Todos los tutoriales que puedas pedir.
Tutoriales OpenGL.org

El libro de los libros. (Segunda edición, un poco vieja pero te vale para empezar)
OpenGL red book

Ya tienes ahi faena para rato.

Si estas estudiando en alguna universidad busca en la biblioteca seguro que hay algun libro de OpenGL.

[DraKKaR]

 Pues a mi la verdad es que no me mola el diseño de la clase. Parece un simple wrapper a opengl. Yo no haria ke cada clase de luz represente a una luz de opengl. Mas ke eso, yo haria que cada luz representara una luz en el juego, sin mas. Despues, la misma clase se apañaria para activar o desactivar las luces necesarias parailuminar correctamente los modelos.
Por ejemplo, imagina ke un mapa tiene 35 luces. Opengl no tiene 35 luces! y aunke solo fueran 5 luces, no kieres ke un modelo se ilumine por 5 luces distintas... con una (o dos) luz ke le ilumine ya es suficiente.
De la manera que yo digo tendrias almacenadas en clases los datos de todas las luces virtuales del mapa, y a la hora de renderizar un objeto miraria que luz esta mas cerca del obj y la configurarias para iluminarlo correctamente.

Digo todo esto pq creo que todo esto deberia ser independiente del API ke uses...

[Leoheart]

 Wenas,
Pues la verdad es ke me gusta el metodo ke dice DraKKar me gusta mucho , pero no se si lo he entendido bien (nooo) . Me parece que lo queries decir es que cree todas las luces y segun la posicion del personaje que active unas u otras siempre con un maximo de dos o tres. Creo que es eso , tengo una duda. OpenGL tiene limitada las luces a que solo se puedan activar 8 luces o a que solo se puedan crear 8 luces. Por favor decirmelo.

P.D: No estoy estudiando en la uni , voi a entrar en el insti  (ole)  

[Mars Attacks]

 Qué precoz. Yo casi a punto de entrar en el jeriátrico :-/

[DraKKaR]

 Joder, pues para ir a entrar en el insti vas muy bien en cuestion de esto. Yo no aprendi OpenGL hasta ke estuve en 2º de carrera.

No quiero decir que crees todas las luces en opengl. Lo que quiero decir es, que te guardes una lista con todas las luces del escenario. Cada elemento de esa lista sera un elemento de la clase CLuz, pero sin tocar nada de opengl.
La cuestion esta en que, para cada objeto que vayas a renderizar, calcules la luz que este mas cerca de ese objeto, la configures (ya a base de comandos de opengl) en posicion, color, etc, y sibujes el objeto con esa luz.

Con este metodo solo necesitarias una luz fisica de opengl activa, que sera la que siempre uses para iluminar cada objeto, pero podras tener un numero ilimitado de luces virtuales en el mundo. Asi una luz es mas que suficiente para lo que quieres hacer. Si quieres, puedes usar 2 luces, cogiendo las 2 que esten mas cerca el objeto y usarlas para iluminarlo.

El eskema, por si no me expreso biens eria el siguiente:

- activar la luz0 de opengl.
- bucle que pinta todos los objetos
---- mirar que luz esta la mas cerca al objeto
---- a base de glLightPos, etc configuras la luz en opengl con los parametros de la clase CLuz de la luz mas cercana.
---- pintas el objeto con esa luz


Todo esto que te he dicho habria que usarlo para objetos dinamicos del juego (cualquier cosa que no forme parte de la estructura fija del escenario), ya que para el propio mapa, se usan otras tecnicas para iluminarlo (como el lightmapping).

OpenGL solo te permite tener activas 8 luces simultaneamente (en realidad esto depende de la implementacion de opengl), pero eso no es ningun problema, porque no creo que vayas a iluminar un objeto con 8 luces al mismo tiempo. Usando el metodo de antes, con una sola luz te vale de sobra.

Espero haberme explicado bien.

[Leoheart]

 Wenas,
Bueno pues mira yo creo que voi muy atrasado en cuestion de concepto . TENDRIA KE SABER MÁS!!! (nooo) xD

Bueno habia pensado en hacerlo con tu estructura. Entonces hago tantos lightpos como luces se hayan creado con la clase. Osea miro cuantas instancias de la clase y hago un bucle y le meto su luz a cada una segun las coordenadas que he definido y compruebo la distancia entonces la creo o no.
Es asi?
Por favor contestame lo antes posible.

[DraKKaR]

 

hago tantos lightpos como luces se hayan creado con la clase

No se a que te refieres con eso de hacer lightpos, pero parece que has cogido la idea. En realidad la idea principal es simple: montartelo de forma que solo uses una luz de opengl.

Intenta implementarlo y me pasteas el codigo aquidentro, asi nos entenderemos mejor ;)

[Leoheart]

 Wenas,
Siguiendo las indicaciones que tu me has dado he creado esta clase que  administra las luces , dime si esta bien o que.

class CLuz {
   public:
    void definecarac( Pos , Amb , Dif , Spec);
    void numeroluz();
       void Pos();
    void Amb();
    void Dif();
    void Spec();
    float luz [30][4];
   private:
       unsigned int NumLuz;
       float rpos;
    float ramb;
    float rdif;
    float rspec;
};

void CLuz::definecarac( Pos , Amb , Dif , Spec)
{
   if ( luz[30] == 0 )
   {
   for(i=0 ; i<31 ; i++)
   {
    if ( luz == 0 )
    {
     luz = i;
        luz[1] = [Pos];
     luz[2] = [Amb];
     luz[3] = [Dif];
     luz[4] = [Spec];
     NumLuz = Luz;
    }
   }
  }
}
   
void CLuz::numeroluz()
{
   return NumLuz;

}

void CLuz::Pos()
{
   rpos = NumLuz[1];
   return rpos;
}

void CLuz::Amb()
{
   ramb = NumLuz[2];
   return ramb;
}

void CLuz::Dif()
{
   rdif = NumLuz[3];
   return rdif;
}

void CLuz::Spec()
{
   rspec = NumLuz[4];
   return rspec;
}

Bueno , espero que este bien.

[tywok]

 hola, lo que seguro q esta mal son las definiciones de las funciones dentro de la clase. si pretendes q te devuelva un valor no puedes poner un void delante de la funcion ;)  

[Leoheart]

 Wenas,
Ya esta corregido.

class CLuz {
  public:
    void definecarac( Pos , Amb , Dif , Spec);
    void numeroluz();
    int unsigned Pos();
    int unsigned  Amb();
    int unsigned  Dif();
    int unsigned  Spec();
    float luz [30][4];
  private:
      unsigned int NumLuz;
      float rpos;
    float ramb;
    float rdif;
    float rspec;
};

void CLuz::definecarac( Pos , Amb , Dif , Spec)
{
  if ( luz[30] == 0 )
  {
for(i=0 ; i<31 ; i++)
  {
    if ( luz == 0 )
    {
    luz = i;
        luz[1] = [Pos];
    luz[2] = [Amb];
    luz[3] = [Dif];
    luz[4] = [Spec];
    NumLuz = Luz;
    }
  }
  }
}
 
int unsigned  CLuz::numeroluz()
{
return NumLuz;

}

int unsigned CLuz::Pos()
{
rpos = NumLuz[1];
return rpos;
}

int unsigned  CLuz::Amb()
{
ramb = NumLuz[2];
return ramb;
}

int unsigned  CLuz::Dif()
{
rdif = NumLuz[3];
return rdif;
}

int unsigned  CLuz::Spec()
{
rspec = NumLuz[4];
return rspec;
}