Ver la versión completa : Sub-pixel antialiasing en GP2X
Aunque este no es un post especificamente de programación, tampoco es que sea de interés general asi que pensé que el foro de programación era el más adecuado.
Si alguien no sabe o quiere más detalles sobre lo que es el antialiasing por sub-pixels puede entrar aqui. (http://www.grc.com/ctwhat.htm)
He estado haciendo algunos experimentos intentando conseguir sup-pixel antialiasing en la GP. Tiene una pantalla LCD, y debería ser la técnica perfecta para visualizar texto (o cualquier otro tipo de gráfico en blanco sobre negro o viceversa) en la negrita, ya que en teoría, permite una resolución horizontal de prácticamente tres veces más de lo que acepte el lcd en cuestión (en nuestro caso serían 960 subpíxels, que no es moco de pavo).
Como generar el antialiasing en tiempo real por software parece una tarea muy intensiva para el procesador, pensé que la mejor solución sería generar la fuente en un bitmap, con un programa como el free&clear, por ejemplo (que se puede descargar en la página de la cual he puesto un link antes) y presentarlas en pantalla quizá como dicen en este tutorial. (http://cone3d.gamedev.net/cgi-bin/index.pl?page=tutorials/gfxsdl/tut4).
Solo hay un problema, y es que yo, no teniendo ni la más mísera idea de programación, tengo que hacer mis pruebas con simples imágenes. Y ahi es donde la cosa se complica, porque en el visor de imágenes de la GP las imágenes que meto se ven BORROSAS por el centro, aunque mucho mas nítidas en los bordes arruinando el efecto del antialiasing por subpixels. No creo que sea un problema de la pantalla, porque en el STerm por ejemplo, las fuentes se ven perfectamente nítidas.
Adjunto un zip con unas cuantas imágenes de prueba hechas de forma cutre-pastelosa en 5 minutos para que el que quiera y sea tan simpático de probar, compruebe por mi si es problema del visor de imágenes de la GP o de mi lcd en concreto, o de la pantalla en general de la GP (espero que no sean ninguna de esas dos últimas razones).
Y dono la idea, esperando que algun genial dev se programe un lector de TXT con antialiasing subpixel para que todos disfrutemos como enanos leyendo lexto con una resolución 3 veces mayor que la que permite la consola :D
Cheers
Luisodin
05/01/2006, 03:51
Curioso, siempre me ha impresionado las tecnicas que "engañan" al ojo. Es imprescindible, a mi parecer,para que algo en pixel art quede perfecto.
Para el 3D ya sería algo más complicado, porque no se trata de formas definidas en dos colores sólidos, ya sería mucho más complicado el algoritmo para hacerlo por ejemplo connn fondo rojo, asi que en 3D no se yo siquiera si sería adecuado incluso para un ordenador potente.
El caso es que windows ya hace algo parecido o igual, si teneis un monitor LCD podeis activar el antialiasing "ClearType" en las propiedades de pantalla. Supuestamente hace exactamente eso, engañar al ojo haciendole creer que hay mas pixeles de los que hay. En Linux tengo entendido que también se puede hacer, pero yo de linux ni papa.
P.D: Se que soy un pooto impaciente, pero... alguien ha probado a ver las imágenes que he puesto en el visor de la GP?
yo tambien había estado haciendo pruebas de sub-pixel rendering :D
http://gp32spain.com/foros/showthread.php?t=26266
En linux tienes la opción de definir que tipo de LCD tienes y varios metodos distintos, a esto me refiero:
Oh, vaya, lo siento, hice una búsqueda en el foro para ver si alguien habia dicho ya algo, pero no encontré nada.
De todas formas, ahi veo que tienes el mismo problema que yo, y que al resto de la gente también le pasaba exactamente lo mismo, asi que me dejas más tranquilo.
Intentaré por todos los medios programar yo la utilidad esa, pero no conteis con ello, tengo mente de grafista, no de otra cosa. Molaría que alguien intentara hacer algo antes que yo (no es difícil)
LukStarkiller
05/01/2006, 05:09
Me he leido la web que has posteado sobre el ausnto enterita, y la verdad es que es bastante interesante el tema, aunque solo se pueda utilizar con fuentes bitmap ya renderizadas, o con imagenes a mostrar, comoc reditos o cosas asi, pero al idea es buena como antigua, no sabia yo que los de Mac la habian usado hacia tanto tiempo, y eso que he usado bastantes Macs de esos n tan nuevos XD
un :arriba: para el tema ^^
bulbastre
05/01/2006, 05:13
Ta curioso. Muy curioso.
Pues si, es una de esas ideas que es más vieja que nada, pero que vuelve a tener actualidad otra vez. Antes se podia hacer con las teles, porque básicamente seguian la misma filosofía, pero claro... en crt es imposible, asi que se habia olvidado un poco la técnica, hasta que salió Microsoft creyendose que lo habia inventado :D
Pues si, es una de esas ideas que es más vieja que nada, pero que vuelve a tener actualidad otra vez. Antes se podia hacer con las teles, porque básicamente seguian la misma filosofía, pero claro... en crt es imposible, asi que se habia olvidado un poco la técnica, hasta que salió Microsoft creyendose que lo habia inventado :D
Pues esta muy bien, yo pensaba que eso de Subpixel era el antialiasing normal, pero veo que es un poco mas currado, he estado probando en la gp32 y se vee bastante bien [wei3]
Hola Zenzuke, nunca había escuchado nada de este tema y por lo que veo es bastante interesante, pero como dices que en sterm las fuentes se ven muy nítidas... ¿has probado ver un archivo de texto con el 'vi' ? ¿usando esta técnica se vería mejor o peor que con vi? Ahora es el que estoy usando hasta que no salga nada mejor.
Un saludo, y si te puedo echar una manilla cuenta conmigo ;)
Lamento parecer un poco newb, pero... que diablos es el vi?
No pasa nada, jeje. Te explico:
Vi es un visor de archivos de texto para consola, abre sterm y escribe: vi y a continuacion el archivo de texto
ej: vi readme.txt
Pruébalo!
Puess, si, con el vi se ve muy bien, porque son fuentes a pixel, pero piensa que con antialiasing a subpixel tienes unas 3 veces la resolución de eso, asi que podría verse unas 3 veces mejor :D
Vale pues no he dicho nada... a trastear con el subpixel!! :D
(Me cuesta trabajo imaginarlo 3 veces mejor)
Buenas noches, que mi cama me espera.
Si alguien lo quiere, podria generarle una imágen como la del tutorial de SDL, pero con fuentes subpixel. Aunque no es demasiado complicado, se coge uno el free&clear, se ponen todas las letras una detrás de otra y se captura la pantalla :D
No he probado a ver las imágenes en la GP2X, pero me ha sorprendido que estén en JPG. En JPG siempre te va a meter "ruido" para comprimir la imagen. De hecho tus imágenes tienen ese "ruido": he abierto la primera en GIMP, y en Capa->Colores->Tono-Saturación bajando la luminosidad un -60 y mira lo que aparece (lo envio en formato PNG ya que este no es "destructivo").
No se si afectará, pero desde luego si estamos hilando tan fino no se pueden usar imágenes JPG para hacer pruebas. Las imágenes de la página que has enviado están en GIF (no destructivo). Si haces la misma prueba en esas imágenes verás que no tienen "ruido".
Y otra cosa: no creo que sea cuestión de tener el triple de resolución. Acaso tendremos textos el triple de "suaves".
Argh el mítico vi, el rompeteclados :quepalmo:
MUY interesante esta técnica del sub-pixel, desconocia su existencia y realmente me parece cojonuda! Y yo que no pasaba del antialiasing xD
Mis imágenes de prueba originales estan en BMP, para subirlas al foro usé jpeg a la máxima calidad que permite photoshop. Comparando la original con la salvada en jpeg a simple vista, no se aprecia ningún cambio, dudo que afecte a la representación en la gp dado que tiene un gamma bastante alto y la mayoria del ruido esta en el blanco puro. De todas formas, es muy sencillo hacerse uno mismo unas imágenes de prueba, sacando las de la web y usando el programa que viene.
Cuando me referia al triple de resolución... me referia mas vien a un triple "virtual", esta claro que no vamos a aumentar mágicamente la resolución del LCD, pero a efectos prácticos, el texto podría contener 3 veces más detalle visual en horizontal. Ya te digo yo que en un tft normal de ordenador, se ve de auténtico lujo.
El tema es que esto no suaviza tanto la apariencia de las fuentes como un antialiasing normal, ese es el objetivo del asunto.
Mis imágenes de prueba originales estan en BMP, ...
Pues si la tienes guardada (con la primera vale) la puedes subir en BMP y ahorras el trabajo a otro de montar la imagen de nuevo...
Pues aqui esta... para los vaguetes :D
Edit: Por cierto, he estado mirando, y muchos teléfonos móviles de esos japoneses de última generación y pico, vienen usando esta técnica en los textos directamente. También he encontrado algunas otras cosas flipantes que hacen, pero no es plan de ponerlas aki :D
Entonces, si lo he entendido bien, por lo que se comenta aquí y en estos otros sitios que he visto:
http://grc.com/cleartype.htm
http://en.wikipedia.org/wiki/Subpixel_rendering
El asunto estaría en generar para cada fuente, por ejemplo, una imagen con un canal alfa con todos los glifos, y luego para pintarla ir haciendo "alfa-blending" (qué mal me suenan estos palabros en inglés) sobre el fondo para cada letra que se quiera presentar ¿no?
No se si de la manera que dices tu funcionaría, la verdad, aunque sospecho que si. Aunque desde luego que la manera mas sencilla seria hacerlas sobre fondo plano y con sprites sin transparencia ninguna :D
Por cierto, tras sudores y penas he conseguido compilar una chorrada para mostrar una imágen por SDL y... lo cierto es que el visor de imágenes de la GP es lo que estaba produciendo las zonas borrosas (chapuceros).
De todas formas, tengo un problema, no consigo hacer que presionando una tecla el programa salga de nuevo al menu. Pongo el código aqui, intentad no reiros, que no soy programador xDDD
#include <stdio.h>
#include <stdlib.h>
#include "SDL.h"
#define BTN_QU (8) // Start
void drawSprite(SDL_Surface* imageSurface, SDL_Surface* screenSurface, int srcX, int srcY, int dstX, int dstY, int width, int height)
{
SDL_Rect srcRect;
srcRect.x = srcX;
srcRect.y = srcY;
srcRect.w = width;
srcRect.h = height;
SDL_Rect dstRect;
dstRect.x = dstX;
dstRect.y = dstY;
dstRect.w = width;
dstRect.h = height;
SDL_BlitSurface(imageSurface, &srcRect, screenSurface, &dstRect);
}
int main(int argc, char *argv[])
{
SDL_Surface *screen;
int done = 0;
if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_JOYSTICK)< 0)
return 1;
screen = SDL_SetVideoMode(320, 240, 16, SDL_SWSURFACE);
SDL_JoystickOpen(0);
if (!screen)
{
fprintf(stderr, "Couldn't set video mode: %s\n", SDL_GetError());
return 1;
}
SDL_ShowCursor(SDL_DISABLE);
SDL_Surface* bitmap = SDL_LoadBMP("./subpixel.bmp");
drawSprite(bitmap, screen, 0, 0, 0, 0, bitmap->w, bitmap->h);
SDL_Flip(screen);
while (!done){
SDL_Event event;
while( SDL_PollEvent( &event ))
{
switch( event.type )
{
case SDL_JOYBUTTONDOWN:
done=1;
break;
//case SDL_KEYDOWN:
case SDL_QUIT:
done = 1;
break;
default: done =1;
}
}
}
SDL_Quit();
return 0;
}
Si alguien me diera la clave para solucionarlo se lo agradeceria muchísimo :D
Edit: El código original es el que venia con el devkit para windows que se colgó aqui en el foro, pero el código que tenia para salir del ejemplo tampoco funcionaba, sospecho que era porque estaba programado para detectar las teclas en windows (El SDL_Keydown que hay comentado, es del código original).
Zenzuke, tranquilo que no nos reiremos de ti. ¡Más te reirías tú de mí al ver mis diseños gráficos comparados con tu genial skin para el MAME! :) El programa está bien. Para salir, has de añadir #include <unistd.h> al principio (debajo del include de stdlib.h, por ejemplo), y justo antes de return 0;, esto:
chdir("/usr/gp2x");
execl("/usr/gp2x/gp2xmenu", "/usr/gp2x/gp2xmenu", NULL);
Este código ejecuta el menú de la consola al salir del programa.
Por último, hay algo que no creo que dé ningún problema, pero por si acaso te lo digo. En lugar de llamar a SDL_JoystickOpen tal como lo haces, yo declararía esta variable justo debajo de SDL_Surface *screen;:
SDL_Joystick* joystick;.
Tu llamada a SDL_JoystickOpen quedaría así:
joystick = SDL_JoystickOpen(0);
Y al salir, deberías liberar el dispositivo, antes de SDL_Quit() así:
SDL_JoystickClose(joystick);
Saludos.
Gracias miles, miq01! La verdad es que estuve mirando un poco el código de tu test del joystick para enterarme de que hacia mal. Ahora lo corregiré a ver si chuta ;)
Pues bien, ya funciona perfectamente, gracias a miq01. Uno es que nunca se habia metido con C mucho más alla de printefes y cosas asi, controlo actionscript, javascript y cosas asi para web y he llegado a hacer algun juego en flash y en DIV, pero no es lo mismo en absoluto :D
Dejo aqui el programita compilado con la imágen y todo, para que el que quiera y no le apetezca ponerse a hacerlo él mismo, pueda ver la estupenda diferencia que representa la técnica esta. Lo podeis meter donde querais de la SD. Sale del programa al pulsar cualquier cosa :D
Ahora voy a ponerme a intentar hacer el programa ese que pensé, que cargue TXT y los muestre con fuentes de este tipo, no se si llegaré a algo, pero deseadme suerte U_U
Edit: Creo que he conseguido convencer a mi novia (que sabe C mucho mejor que yo) para que me ayude :D Si consigo mantener su interés podeis esperar grandes cosas ;)
También podeis probar si queréis esta imagen, también tiene sub-pixel antialiasing y se ve muy bien (con el programa de zenzuke)
Aun nos estamos pegando con esto, estoy intentando compilar el ejemplo de usar fuentes bitmap en SDL, y esta es la salida del make:
C:/devkitGP2X/bin/arm-linux-g++ -static -o demo.gpe demo.o `C:/devkitGP2X/bin/arm-linux-sdl-config --libs
demo.o: In function `DrawScene()':
demo.cpp:(.text+0x34): undefined reference to `stringWidth(SDLFont*, char*, ...)'
demo.cpp:(.text+0x60): undefined reference to `drawString(SDL_Surface*, SDLFont*, int, int, char*, ...)'
demo.cpp:(.text+0x88): undefined reference to `drawString(SDL_Surface*, SDLFont*, int, int, char*, ...)'
demo.cpp:(.text+0x9c): undefined reference to `stringWidth(SDLFont*, char*, ...)'
demo.cpp:(.text+0xb8): undefined reference to `drawString(SDL_Surface*, SDLFont*, int, int, char*, ...)'
demo.o: In function `main':
demo.cpp:(.text+0x160): undefined reference to `initFont(char*, float, float, float, float)'
demo.cpp:(.text+0x180): undefined reference to `initFont(char*, float, float, float, float)'
demo.cpp:(.text+0x1d0): undefined reference to `freeFont(SDLFont*)'
demo.cpp:(.text+0x1d8): undefined reference to `freeFont(SDLFont*)'
make: *** [demo.gpe] Error 1
Estoy haciendo las cosas un poco a ciegas usando un makefile de ejemplo también, pero con mi programa anterior funcionaba sin problemas.
Adjunto un zip del directorio a ver. Lamento tirar tanto de el foro, pero ni mi novia ni yo tenemos experiencia con SDL o compilando para otras plataformas que no sean windows.
Edit: Se que esta creando una pantalla de 640x480 y eso, pero no afecta a esos errores que digo.
Edit edit: Vale, conseguí que compilara, solo habia que cambiar el makefile, si eske... :loco: Quité el archivo, que ya no tiene sentido
timofonic
09/01/2006, 06:13
¿Como va eso? La idea parece bastante interesante :)
Pues la verdad es que no he tenido mucho tiempo de ponerme con ello estos dias, pero al menos ya se puede controlar el scroll con el pad de la GP, carga textos externos por linea de comandos y bueno, estoy pegandome un poco con la manera que tiene de cargar las fuentes y aun falta que detecte bien los saltos de línea. Me vendría bien la ayuda de alguien que tuviera un poco de experiencia y mucha paciencia para aguantar que sea un lento de mi*rda xD
Powered by vBulletin® Version 4.2.5 Copyright © 2026 vBulletin Solutions Inc. All rights reserved.