Hombre, los archivos de recursos están bastante bien porque no solo guardan los textos, también guardan posiciones, tamaños, etc etc. Los botones pueden variar de tamaño según el texto que lleven dentro, etc etc.

Un saludo!

Vicente

Yo tb uso ese sistema...lo que no he logrado conseguir es cambiar de indiomas mientras se ejecuta la App. Vicente, sabes algo sobre esto ?

Un saludo.

Hola,

A mi me va perfecto.
500-600 FPS.

Win xP
Amd 3500
6600TG

-Me gusta mucho la estética.
-Yo agregaría tiempo en el nivel y bonificaría en puntuación a quien acabe antes.

MA]Mestre queda expulsado de la casa  :D

Ok, me las piro. Uno menos.

Jare

Puedes creerme, yo sí he tenido en mis manos las especificaciones de la Virge bit a bit y registro a registro. Y sobre todo, he trabajado con ella.

Te repito que sin dudar de tu palabra, me cuesta creerlo, primero se anda después se corre, primero fue el alphatest, después el alphablend. Lástima que no tengamos las Specs. No estaría soportado por hard y tubieran el problema X con ella ?

Jare

Alpha Test en general es más rápido de ejecutar que un blend, pero alpha test en software será más lento que blend por hardware. :P

Claro, pero los dos en las mismas condiciones (soft/hard) no hay color.

Jare

Como dice zuper, el test genera bordes "duros" que pueden quedar muy feos

Claro coño, pero con el blending se puede llegar al mismo punto, no es esa la solucion, no crees ?

pero el blending tiene su propio conjunto de problemas: ordenación y multipass son los más clásicos.

Y alguno más... entonces mejor evitarlo cuando no sea necesario ? :P

El tercer problema clásico (y el que más quebraderos de cabeza me dio en su momento) es el hecho de que con blending, los texel transparentes también escriben en el ZBuffer.

Por arriba he puesto el pipeline. Los texels trasparentes se escribian pq no eran transparentes.

Hoy en día lo del ZBuffer se suele resolver activando blending Y testing a la vez, aunque suelen quedar unas babas un poco feas alrededor del gráfico.

Y que hacemos para suavizar las babas... otro blending ? :P o la tecnica q corresponda ?

P.D: Sorry por el flood de msgs

[McBain]

[quote="[EX3]"Y digo yo, no es un poco estupida toda esta cuestion que
estas formando con el AlphaTest?[/quote]

Si en algo que conozco veo que sueltan una de estas, que debo pensar de lo que pone la gente sobre temas que desconozco ? por eso para mi es importante.

[quote="[EX3]No has pensado que luego McBain querra aplicar AlphaBlending? Para que vas a implementar AlphaTest y Blending cuando con Blending cubres las dos necesidades?[/quote]

Que cada uno emplee lo que quiera, pero que sepa que esta haciendo exactamente en cada momento. Para lo demás, me remito a el universo de los 300 rectangulos huecos.

[quote="[EX3]Ahi tienes la 'logica y razon' de por que se usa y recomienda Blending y no AlphaTest en la mayoria de tutoriales de toda la red.[/quote]

Aquí entramos en lo del criterio propio, donde la mayoria, no es sinónimo de nada. ( Sin ser comparable a lo que estamos hablando, Hitler llego al poder através de las elecciones. )

P.D: Por cierto, googleando un poco me encotre con esto...  

http://www.stratos-ad.com/forums2/viewtopic.php?p=18410&sid=605c73a582a25e25cdaf0b6d508846b0

curioso no ?

Veamos ¿por que tengo que defender lo que dice la documentacion de direct3d?

No hombre no, no debes defender la documentación del direct3D. Debes defender tus palabras. Por lo pronto, recomendar el alphablending para hacer un colorkey.

Algunas citas.

"...ademas este es el sistema de toda la vida para crear transparencias teniendo un canal alfa. "  ( refiriendote al alpha blending )"

"...ademas es como se ha hecho toda la vida, espero que te haya quedado claro y si no busca en google como hacer mascara de color con estas dos instrucciones en google." ( refiriendote a usar máscaras )

"Ni tu ni nadie por la sencilla razon de que el alpha testing descarta pixels con el problema de que no suaviza los bordes como hace el alpha blending"

Este de que el blending suaviza bordes es brutal !!! más caracteristicas para el blending !!!! ole ole !!! a tomaaaaaar pol cuuuuulo el Full-Screen Antialiasiingggg  (entonación cálico )

Ponte una imagen cuadrada blanca (255,255,255), pon un rombo negro(0,0,0) dentro. Los pixeles blancos pon el alpha a 0, y los negros a 1. y ahora quiero q desaparezcan los blacos o negros con blending... y que se suavicen el brodes !!!!

La comunidad del alpha test te agradece que reconozcas que sirve para descartar pixels ( por alpha ).

b) Opengl fuerza todo a estar presente mediante fallback software si no fuese posible por hard. DirectX no obliga a nada ya que entiende que una implementación software podría ser poco util. Lo suyo es que la aplicación consulte y utilice solo las funciones implementadas por hard si requiere velocidad. (familia GetCaps en DX y GetInteger()+bases de datos basadas en vendor string en OpenGL).

No tenía noticias de que OpenGL de soporte a todo ( todo ? ) por fallback software. Tienes algun link de esto ? ( icono - curiosidad )

c) Soportase OpenGL o no, era la época negra de la programación OpenGL en windows (y si me apuras de DX también, pero de OpenGL mejor ni hablar). Dejémoslo correr :D

No voy a entrar en los problemas que pudiera haber con Win o drivers. Pero vamos... que un GRUPO de PROFESIONALES que desarrollan hardware, ofrezcan soporte para alpha blending que es más complicado de desarrollar y no para alpha test que es más simple...
es como si alguien te dice que sabe hacer carros pero no ruedas... ...i si le sumas lo poco sobrados q por la época ivan de hard para hacer blend... pffff

d) Por software, alpha test es potencialmente más rápido al ser simplemente una comparación. Blending implica hacer una mezcla de color (por ejemplo una media ponderada mediante alpha de la textura).

 alpha test:  if (framebuffer[x,y].alpha > texel.alpha) then framebuffer[x,y] = texel
 blending:  framebuffer[x,y].pixel = framebuffer[x,y].pixel * (1-texel.alpha) + texel.pixel * texel.alpha

ohhhh :wink:  permiteme hacer un par de matices y un añadido.

Matices

Por software y por hardware, alpha test es realmente más rapido.

El alphablending dispone de numerosas combinaciones de mezcla y algunas un tanto complejas. O lo que es lo mismo, muchisimo más tiempo de proceso.

Añadido
Te ha faltado agregar el pipeline donde se encuentran los dos procesos.

... alpha test --> stencil test --> depth buffer test --> blending ...

alguien se ha preguntado alguna vez pq con un blending no aditivo debe realizar una ordenación de los elementos de back to top ?

Podemos estar deacuerdo en definir el que alpha test realiza un test para eliminar un pixel ? ( lo que pedia MacBain )

Podemos estar deacuerto en definir al Blending ( no blending test xD ) como mezclar pixeles ?

Como vendemos a alguien quiere hacer un universo con 300 rectanglos huecos, que use blending, .( tengo problemas raros !!! ) ...que trace la distancia de cada rectangulo para después ordenarlo... y que encima se compre una tarjeta de 140€... pq cuando unos pocos de rectangulos cubren toda la ventana los frames se le tiran abajo... ...pero claro, saldrá alguien y le dirá... Frustrum Culling!!! o culquier otra técnica del estilo... ...lo implementará y seguirá exactamente igual... ... pq usando esa o otra técnica a el trozo de pipeline que he puesto le llegarán exactamente la misma cantidad de putos pixeles...

¿Quieres uno? La S3 Virge. Aaaaadiooosss! ;)

De hecho, los drivers D3D de la S3 Virge *emulaban* Alpha Testing activando en su lugar Alpha Blending, lo que nos dio no pocos quebraderos de cabeza, porque los pixels transparentes por Alpha Testing no escriben en el ZBuffer, pero los transparentes por Blending si. Hablamos de 1997... en el 98 ya era infrecuente que juegos comerciales se molestasen en soportar la Virge. O sea que no es lo que se dice muy relevante.

A día de hoy se asume que el Alpha Testing existe y funciona realmente como debe, porque es muy útil y se usa en practicamente todos los motores gráficos.

Qua adios más entusiasta.  :lol:

He estado buscando las Specs Técnicas de la S3 Virge, no las he econtrado... pero sin ellas y sin dudar de tu palabra, dire que:

a) OpenGL desde su primera version 1992-1997 soporta Alpha Test y Alpha Blending ( no con todas las combinaciones de ahora ).

b) OpenGL, nunca ha especificado que estas opciones son dependientes del hardware. Que raro, no ? Pq DirectX en su documentación del SDK del summer 2003 si lo pone ? lo pone en el SDK actual ?  :wink:

c) La S3 Virge no soportaba OpenGL entonces ? aun que varias personas de S3 por entonces tomaban parte y voto en las reuniones de la ARB ? :roll:

d) Que es más complicado desde el punto de vista técnico ? implementar un Alpha Test o un Alpha Blending ? Cual de las dos técnicas es más rápido de computar ?

"] todos los ejemplo tiran de Blending para hacer alphablending y asignacion de color transparente o Colorkey en la textura"

Para hacer alphablending es lógico tirar de blending. Nunca he dicho lo contratio. Ahora que para hacer un color transparente usen Blending, es una estupidez. Y me la pela que salga en los SDK de Microsoft, yo, como creo que deberiais tener todos, tengo mi criterio propio y critico todo lo que me parece una estupidez... por mucho MS que sea...

...por ejemplo, los ejemplos del SDK de DirectxShow de MS hacen servir la instrucción "goto"... ...que debo pensar sobre ello ? que es una estupidez ? o me sumo al carro ?

cual es la finalidad del Alpha Test ? cual es su proceso interno ? en que posicion de la cadena del pipeline esta situado ?

Ahora haceros las mismas preguntas para el Alpha Blending... ...y después con VUESTRO CRITERIO... responder si para hacer un pixel trasparente o no... se deberia usar una técnica o la otra...

Para el yogourth la cuchara, para las patatas el tenedor.

Yo no asumo nada, ¿has hecho rutinas graficas en asm en la epoca de ms-dos o en otras plataformas? una comprobacion era mucho mas lenta que usar operaciones para pintar una imagen con mascara de color.

Pos va a ser que he hecho unas cuantas rutinas en la época de ms-dos... ...pero el haber hecho o estar haciendo, no da más fuerza ni más rigor ni más prestigio a mis palabras... por lo demás, espero la respuesta a la pregunta de sés.

pero ma]mestre, acaso en OGL no hay que activar blending para que haga alphatest al pintar un quad?

No tamat.

//www.m3str3.org/AlphaTest.rar

Código [Seleccionar] Expand

#include <windows.h>
#include <stdio.h>
#include <gl\gl.h>
#include <gl\glu.h>


#pragma comment (lib,"opengl32.lib")
#pragma comment (lib,"glu32.lib")


int BeginOpenGL (HWND hWnd);
void Render (void);
void SetDCPixelFormat (HDC hdc);
void LoadSprite (const char *ruta,short ancho,short alto,GLubyte **sprite);
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM );
HINSTANCE hInst;

GLuint ntexture;
int iLessGreater=GL_LESS;

int WINAPI WinMain (HINSTANCE hInstance,HINSTANCE hPrevInstance, LPSTR  lpCmdLine, int iCmdShow)
{
char nombre []="OpenGL";
HWND hWnd;
MSG msg;
WNDCLASSEX wndclass;

hInst=hInstance;
wndclass.cbSize=sizeof (wndclass);
wndclass.style=CS_HREDRAW|CS_VREDRAW;
wndclass.lpfnWndProc=WndProc;
wndclass.cbClsExtra=0;
wndclass.cbWndExtra=0;
wndclass.hInstance=hInstance;
wndclass.hIcon=LoadIcon (NULL, IDI_APPLICATION);
wndclass.hIconSm=LoadIcon (NULL, IDI_APPLICATION);
wndclass.hCursor=LoadCursor (NULL, IDI_APPLICATION);
wndclass.hbrBackground= (HBRUSH ) GetStockObject ( WHITE_BRUSH);
wndclass.lpszMenuName=NULL;
wndclass.lpszClassName=nombre;


RegisterClassEx (&wndclass);

hWnd=CreateWindowEx ( NULL,
nombre,
"OpenGL",
WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_VISIBLE | WS_BORDER | WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
600,
600,
NULL,
NULL,
hInstance,
NULL);

while (GetMessage (&msg, NULL, 0, 0))
{
TranslateMessage (&msg);
DispatchMessage (&msg);
}
return msg.wParam;
}


LRESULT CALLBACK WndProc (HWND hWnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
static HGLRC hrc;
static HDC hdc;
static HANDLE hilo=NULL;
static float AnguloRotacion=0.0f;
DWORD w9x;

switch (iMsg)
{
case WM_CREATE:
hdc=GetDC(hWnd);
SetDCPixelFormat(hdc);
hrc=wglCreateContext (hdc);
wglMakeCurrent (hdc,hrc);
BeginOpenGL(hWnd);
return 0;
case WM_PAINT:
Render();
SwapBuffers (hdc);
return 0;
case WM_KEYDOWN:
if (iLessGreater==GL_LESS) iLessGreater=GL_GREATER;
else iLessGreater=GL_LESS;
return 0;
case WM_DESTROY:
wglMakeCurrent (hdc,NULL);
wglDeleteContext (hrc);
PostQuitMessage (0);
return 0;
}
return DefWindowProc ( hWnd, iMsg, wParam, lParam);
}

int BeginOpenGL (HWND hWnd)
{
static GLubyte *Unicornio,*Pwar;

glEnable (GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
glEnable ( GL_ALPHA_TEST );

glViewport (0,0,600,600);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0f,1.0f, 1.0f, 800.0);

glClearColor(0.0f,0.0f,1.0f,0.0f);

LoadSprite ("pwar.bmp",128,128,&Unicornio);

glGenTextures(1, &ntexture);

glBindTexture(GL_TEXTURE_2D, ntexture);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, 4, 128, 128, 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE,Unicornio);

free (Unicornio);
return 0;
}


void SetDCPixelFormat (HDC hdc)
{
int n;
PIXELFORMATDESCRIPTOR pfd;

memset (&pfd,0,sizeof(pfd));
pfd.nSize=sizeof (PIXELFORMATDESCRIPTOR);
pfd.nVersion=1;
pfd.dwFlags=PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType=PFD_TYPE_RGBA;
pfd.cColorBits=8;
pfd.cDepthBits=32;

n=ChoosePixelFormat (hdc,&pfd);

SetPixelFormat (hdc,n,&pfd);
}


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);
}

free(*sprite);
*sprite=aux;

CloseHandle (fp);
}


void Render (void)
{
glMatrixMode(GL_MODELVIEW );
glLoadIdentity();
glTranslatef (0.0f,0.0f,-50.0f);

glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

glAlphaFunc (iLessGreater, 0.5f);
glBindTexture(GL_TEXTURE_2D,ntexture);

glBegin (GL_TRIANGLE_STRIP );
glTexCoord2f(0.0f, 0.0f); glVertex3f (-10.0f,-10.0f,0.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f (-10.0f,10.0f,0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f (10.0f,-10.0f,0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f (10.0f,10.0f,0.0f);
glEnd ();
}

A.- Alpha Test
B.- Blending

B no puede existir, si no exite previamente A.

Conclusión:

Si A no es soportado por el harware, B tampoco lo será.

---

Es una estupidez recomendar el uso de BLENDING cuando el ALPHA TEST resuelve el problema infitamente más rápido.

---

Es una estupidez más grande decir que el BLENDING es el sistema de toda la vida para que no se pinte un color de pixel, simplemente pq es mentira. Aunque supongo q esto ya lo asumes, pq no dices nada en tu último post.

Mestre"]

Si claro, muchichisimos más... lástima q los programadores no solo hacen juegos... sino, de q viviriamos ?

Sobre el futuro de ser diseñador gráfico, no voy a ser yo el que rompa tus ilusiones, es más, te animo... pero no olvides tener un plan B, por si falla el plan A...

Un saludo.

Bueno no creas, por muy paquete que sea siempre podrá dedicarse a maquetar enciclopedias, que tambien es diseño gráfico ;-)

Cuando decía que los programadores no solo hacen juegos, no quería insinuar que los grafos solo hacen juegos. Aunque entiendo q leyendo lo que escribí, se pueda llegar a esa conclusión. No obstante, creo que un informático tiene un abanico más grande de salidas en el mundo laboral que un diseñador gráfico, aunque solo sea para hacer HTML... ( ouch... )

Me tratas de explicar que un hardware que no soporta Alpha Test soportará Alpha Blending ?  

Que parte de la pregunta no entiendes ?

Te criticaré con el mismo morro que tu dices estupideces con tanta soberbia. Si encuentras algún hardware que SI soporte Alpha Blending y NO soporte Alpha Test, dejaré de escribir en estos foros para siempre... que estas dispuesto a jugarte tu ?

Dejaré de programar, y me dedicaré a criar pollos, conejos y cerdos, si demuestras que el BLENDING es el sistema de toda la vida para que no se pinte un color de pixel.

Por otro lado, el Alpha Test.

...
pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE, true );
pd3dDevice->SetRenderState( D3DRS_ALPHAREF, 0x01 );
pd3dDevice->SetRenderState( D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL );
...

http://www.computersciencelab.com/Direct3DTut1.htm

HRESULT D3DXLoadSurfaceFromResource(
 LPDIRECT3DSURFACE9 pDestSurface,
 CONST PALETTEENTRY * pDestPalette,
 CONST RECT * pDestRect,
 HMODULE hSrcModule,
 LPCTSTR pSrcResource,
 CONST RECT * pSrcRect,
 DWORD Filter,
 D3DCOLOR ColorKey,
 D3DXIMAGE_INFO * pSrcInfo
);



ColorKey
[in] D3DCOLOR value to replace with transparent black, or 0 to disable the colorkey. This is always a 32-bit ARGB color, independent of the source image format. Alpha is significant and should usually be set to FF for opaque color keys Thus, for opaque black, the value would be equal to 0xFF000000.

Quieres decir que no es esto ?

Me tratas de explicar que un hardware que no soporta Alpha Test soportará  Alpha Blending ? lol lol lol ( icono - borracho )

el sistema de toda la vida ?  :shock: