[más espacio que pixeles tiene la textura]

creo que deberias enterarte mejor de lo que es el MAG_FILTER y el MIN_FILTER.

Primero tenias problemas con el MAG_FILTER y lo pusiste a NEAR, de ese modo cuando el sprite ocupa en pantalla más espacio que pixeles tiene la textura lo que hace es coger el pixel más cercano, evitando difuminados que matan el pixel art.

Pero el MIN_FILTER es para el caso contrario, cuando el area donde se va a representar el sprite sea más pequeño que la textura, en tal caso coge los pixeles que más cerca quedan, pero se produce ese efecto de parpadeo ya que nada te garantiza que cada vez coja el mismo pixel.

Para evitar eso deberias actiar el MIN_FILTER para que use los mipmaps, es decir, versiones de menor resolucion de la imagen en las que se ha hecho un promedio. Prueba con GL_LINEAR_MIPMAP_LINEAR

Antes de que este hilo se hunda en el foro, comentar una cosilla...

Tal y como comenté en otra réplica, estuve tirando por ahí, por los filtros esos de texturas pero me encontré con un problema que no llegúe a solucionar. Resultaba que cuando usaba otros filtros en el MIN_FILTER diferentes del GL_LINEAR y el GL_NEAREST, me aparecían todas las texturas en pantalla de color blanco (vamos, que no se veía nada).

De todos modos, supongo que para como quiero trabajar, siempre que quiera escalar la escena con un valor constante, creo que me resultará mejor escalar previamente los sprites de las objetos en movimiento por software y crear una nueva textura para ellos.

Scalas el poligono ( cuadrado por 2 triangulos ) y la textura que tenga aplicada, pero es posible que al interpolar entre frames pase algo extraño.

Está el mucho quieto y sin animación cuando parpadea?

Un saludo.

No tiene animación, pero tampoco está quieto. Ocurre cuando se mueve ese sprite.

Y si, me ocurre cuando hago alguna rotación o escalado, aunque supongo que pasará con todo lo que altere de algún modo la imagen de la textura. Con translate y cosas así no sucede.

Estoy por subir una "demo" donde se vea el tembleque xD.

Me refería a que por ejemplo usando un escalado en la escena del 0.8 (constante), cuando hay movimiento no me paran de oscilar bruscamente de color algunos pixeles del interior del muñeco (no en los bordes, que si me parecería razonable). Aquí se puede ver claramente:



Para evitar un poco esto, he decidido cambiar de resolución. Antes trabajaba con 320x240, y ahora trabajo a 640x240 (simplemente he escalado todo al doble) que tal y como suponía disimula un poco ese oscilamiento que crea el filtro. No obstante, se nota un leve tembleque que es bastante molesto. Me parece raro que una misma textura, aplicándosele las mismas transformaciones y sin que su contexto cambie (osea, sin que haya ninguna textura encima) salvo los bordes, de como resultado una imagen donde sus pixeles internos (aquellos que no están en los bordes) son variables según la posición de la pantalla en la que se encuentre...

[EX3] No sabía que usando la transparencia del PNG se evitaba esto, precisamente yo uso PNG a los que previamente le meto un ColorKey con SDL, me va a venir bien ahorrarme ese paso. De todos modos, es cierto que no creo que me favorezca el efecto de difuminado a mis sprites. Si no fuese por ese tembleque que contaba antes, con GL_NEAREST estaría encantado.

PD: No uso depth test.

Pues si, parece que era muy elemental :oops:  Le he metido  GL_CLAMP_TO_EDGE y ya está todo en su sitio. Aunque lo del borde verde del muñeco no lo he solucionado, con el filtro GL_NEAREST es verdad que se quita, pero queda bastante mal (sobre todo en movimiento, si fuese epiléptico no habría sobrevivido a ese parpadeo). De todos modos ya se por donde tengo que tirar, seguiré investigando eso de los filtros MIN y MAG...  gracias a ambos :)

Hola de nuevo, tengo un programa que utiliza texturas de 24 bits para recrear un entorno en 2D y todo me va muy bien, hasta que hago que OpenGL trabaje transformando la información de esas texturas.

En esta imagen se ve a la izquierda la escena sin ninguna transformación de ese tipo, y a la derecha con un glScalef(1.3,1.3,1.0) por medio.



Fijaos en el contorno verde que le sale al muñeco por las buenas, y en las lineas del mismo color que salen alrededor de los tiles. Imagino que igual debí haber activado algo antes de renderizar, pero tras investigar por ahí (y por aquí xD) no he encontrado nada.

En mi caso, lo único que activo antes de dibujar la escena es lo siguiente:
   glEnable(GL_TEXTURE_2D);
   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

Eso es todo, a ver si me ayudais a quitarme de estos berenjenales que me traen frito... Gracias.

Gracias tamat, ya he entendido el uso de esas funciones y me sirven de maravilla para lo que pretendía hacer.

Otra cosa, sobre lo que comenté también en mi primer mensaje de este hilo. Me he encontrado con que SDL_GL_SWAP_CONTROL no trabaja bien en todas las TG. Del mismo modo SDL_GL_DOUBLEBUFFER tampoco es suficiente para activar el Vsync en algunos PCs (bueno, esto realmente no me ha sido suficiente en ninguno de los PCs donde lo he probado). Me podeis dar algún consejo para poder casi garantizar la sincronización vertical en mi programa usando SDL+OpenGL?

Lo he estado probando, y he visto que glViewport reescala la proyección, cuando a mi lo que me interesa es que las escalas permanezcan intactas. Lo he probado también con glScissors y glTranslatef, y casi resulta como yo quería:



El problema es que sólo funciona bien para 2 escenas dispuestas en horizontal. Si lo purebo en vertical, o con 4 cámaras tal y como lo muestra Buffon, glScissors se carga la proyección de cada escena cuando antes no lo hacía, lo cual me lía un poco.

Este es el fragmento de código que recrea cada escena:

Código [Seleccionar] Expand

glMatrixMode(GL_MODELVIEW);
glTranslatef(area->getX(),area->getY(),0.0);

glEnable(GL_SCISSOR_TEST);
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

for (int i=0;i<Capas.size();i++) {
Capas[i]->redraw();
}

glScissor(area->getX(),area->getY(),area->getW(),area->getH());

glDisable(GL_SCISSOR_TEST);
glDisable(GL_BLEND);
glDisable(GL_TEXTURE_2D);

Buenas, ando un poco perdido con OpenGL y quería saber si me podríais echar una mano. Trabajo con SDL, y me he dado cuenda de que sin las gráficas por hardware no voy a ninguna parte.

En mi juego, quiero que aparezcan varias "camaras" enfocando objetivos distintos, viendose por lo tanto la pantalla dividida por el número de camaras (pensado así para soportar varios jugadores en el juego, donde cada uno pueda moverse a su antojo por su camara). Entonces, quería saber si hay algún modo sencillito de dividir el worldspace en varios contextos que pudiese manejar de igual manera. Otra cosa que para el caso, me vendría bien es algo para trasladar todo el sistema de coordenadas.

Sinceramente no quiero entretenerme mucho con el OpenGL, y tirar de libros ya que lo voy a usar de un modo muy simple (2D), y me urge más avanzar en otras cosas. Lo digo porque más de uno se tiene que estar tirando de los pelos con las cosas que estoy diciendo sobre este tema xD.

Una última duda: alguien sabe si hay alguna pega en usar este atributo? SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, 1 )