ColorKey en OpenGL

[deadLock++]

                                Estaba portando una aplicación Direct3D a OpenGL y no encuentro el modo de hacer lo que hacía en la anterior con la función D3DXCreateTextureFromFileEx que me permitía especificar un color que no se trasladara al objeto final.

De este modo pretedo hacer sprites 2d, que en realidad son texturas dispuestas sobre un cuadrado (o dos triángulos adyacentes) pero con un color transparente definido convenientemente (que era lo que hacía en DirectX).

Estuve viendo los tutoriales de NeHe y de gameTutorials pero no encuentro este modo de aplicación.

Desde ya muchas gracias.                                

[MChiz]

                                Hola!
Tienes que utilizar el AlphaTest. Es muy sencillo de utilizar y te sirve. Tambien puedes ponerle canal alpha a la textura y donde quieres que sea transparente, le pones Alpha a 0. A la hora de renderizar, activas el blending y listo. GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA. Creo que ese era el blending para la transparencia ( no te lo aseguro, estoy un poco frio en ese tema ;) )
Un saludote!                                

[deadLock++]

                                Gracias, ahora anda del churrete!  :P                                

[Ithaqua]

                                Para sprites siempre usa el alphatest ya que el blending sale muchísimo más caro. El blending úsalo cuando quieras tener niveles de transparencia.                                

[MChiz]

                                Nada!! Me alegro haberte ayudado!
Un saludote!                                

[Loover]

                                ¿Ithaqua como se usa el alphatest en OpenGl?                                

[Degiik]

                               

¿Ithaqua como se usa el alphatest en OpenGl?

Yo pregunto lo mismo, a cualquiera que quiera responder.                                

[MChiz]

                                Hola! Yo mismo os respondo:

Para usar AlphaTest ( os voy a hablar utilizando GL, que no D3D no lo he hecho ) lo primero es hacer esto:

glEnable( GL_ALPHA_TEST ); // ;b

Y luego se define la funcion que quereis que haga el AlphaTest ( como con el ZBuffer ), con glAlphaFunc. Por ejemplo, si se quiere que los texels con menos de 128 de alpha NO se pinten, se ha de poner:

glAlphaFunc( GL_LESS, 128.0f / 255.0f ); // El parametro numerico va de 0.0f a 1.0f.

En fin, es asi de facil. Esta tirao, en serio.
Espero que os funcione!
Un saludote!!                                

[Degiik]

                                amo abé.

no se me ve nada nada...

pero mi reflexion es la siguiente...

supongo que la textura que estoy utilizando no es la correcta, pues cargo una textura GL_RGB cuando creo que he de utilizar una GL_RGBA...

si es así como guardo una textura desde el photoshop de turno con el Alpha me me interesa, hay opciones en estos programas graficos...

que alguien me diga si voy bien encamindado.

Tambien se me ha ocurrido, manualmente añadirle yo un valor Alpha al BMP que voy leyendo segun me convenga... weno

Otra cosita...  ( prometo que es la última ) ...Puedo saber la cantidad de memoria de la targeta grafica que tengo utilizada y por consiguiente la libre.

Zen-Kui.
Degiik.                                

[Loover]

                                Los programas de dibujo como Gimp o Potochoff te permiten usar el canal alpha facilmente. Suele ser así: Imagen nueva > fondo transparente y ya tienes canal alpha. Lo bueno de esto es que NO ES UN COLOR KEY; la transparencia tiene 256 posibles niveles (0 todo transparente, 255 opaco completamente). Prueba a emborronarlo con la herramienta del dedito :)
Formatos que soporten transparencia... png, tga son los mejores

Ahora bien, si cargas un bmp (BGR en memoria) y quieres luego mezclarlo (por ejemplo con glTexSubImage) con otra textura que sea RGBA, deberas pasarlo a ese modo. La forma: muy fácil, reservas espacio para la nueva imagen (ancho * alto * 4 bytes) y recorres el bmp (BGR) y lo vas almacenando como RGB y ademas le metes el A (opaco, 256 de valor). Luego creas la textura y a correr.

Yo paso todas las imagenes que cargo (bmp, png, tga, tiff, ico, jpeg, etc) a RGBA por defecto (aunque tengo la opcion de forzarlo a RGB). Para poder mezclarlas entre ellas con canal alpha y hacer efectos interesantes.

Lo de la memoria en la tarjeta ni idea.

Un saludo                                

[Degiik]

                                gracias por la informacion del potochoff lo provare...


mas o menos lo supuse... asi que realize el código y ... funciono.

void LoadSprite (const char *ruta,short ancho,short alto,GLubyte **sprite)
   {
   int tam=ancho*alto*3;
   GLubyte *aux;
   HANDLE fp;
   DWORD b;
   GLint i,j;

   fp=CreateFile (ruta,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);

   *sprite=(GLubyte *)malloc(tam);
   aux=(GLubyte *)malloc(ancho*alto*4);
   SetFilePointer(fp,54,NULL,FILE_BEGIN);
   ReadFile (fp,*sprite,tam,&b,NULL);

   for (i=0,j=0;i<(ancho*alto*3);j++,i++)
      {
      if ( i % 3 == 0 && i!=0)
         {
         if (* (aux+j-1)<120 && *(aux+j-2)<120 && *(aux+j-3)<120 )
            *(aux+j)=255;
         else
            *(aux+j)=0;
         j++;
         }
      *(aux+j)=*((*sprite)+i);
      }


   /*for (i=0,j=0;i<(ancho*alto*4);i++)
      {
      if ( i % 4 == 3 )
         {
         if (* (aux+i-1)==0 && *(aux+i-2)==0 && *(aux+i-3)==0 )
            *(aux+i)=255;
         else
            *(aux+i)=0;
         j++;
         }
      else
         {
         *(aux+i)=*(*sprite+i-j);
         }
      }*/

   free(*sprite);
   *sprite=aux;

   CloseHandle (fp);
   }

Hay un metodo comentado que tambien sirve, para lo que pretendo...

Weno si alguien sabe lo de la targeta que lo responda.

Asias.


Pq sale tan mal tabulado ? aki cuando lo sescribo se ve bien  :(