Os escribo aquí el original:

He hecho un programa para probar cómo procesan los triángulos las tarjetas. He implementado 2 técnicas:

1ª técnica: Renderizar el objeto en el momento en el que se pide. De esta forma, la tarjeta y la CPU funcionan en paralelo trabajando al mismo tiempo.

2ª técnica: Crear una lista de vértices enorme por textura y al final de todo el proceso lanzar ese mega-paquete a la tarjeta. He leido en algunos sitios que esto es lo más óptimo...pero yo dudo de que la CPU no se aburra!!

Mis FPS:

Pentium 200 MMX. Savage 4 32MB W98 96 MB.

Técnica 1:5.25 FPS
Técnica 2:5.25 FPS

(lógico porque yo no tengo GPU!!)

Bien, pues ahora sí tengo GPU y este es el resultado:

AMD 1900+. GForce 4 MX 64MB
Técnica 1:182.25 FPS
Técnica 2:56.67 FPS

Así que, según lo visto, y conforme a los post que se recibieron...¡no lanceis todo de gole a la tarjeta de vídeo!


[ Este Mensaje fue editado por: Drácula el 2002-08-15 21:47 ]                                

                                Bueno, teneis una beta en :

http://webs.ono.com/dracular/Beta1.zip

El código del programa está en juego.cpp
Os pediría que no os fijarais en la beta en sí(que es muuy fea) sino en el código que se utiliza para generar todo esto.

Juanjo Pastor me pidió una beta para ir empezando, y esta es la 2ª y por si a alguien le interesa...

¡ATENCION LA BETA YA NO ESTA DISPONIBLE!

[ Este Mensaje fue editado por: Drácula el 2002-08-18 12:44 ]                                

                                Muy pronto estará disponible gratuitamente la versión 1.0 del motor(que por cierto no se llamará Merlin porque ese nombre ya existe en un motor 3d!!)
Mantiene la facilidad de programación, además de una mayor potencia en la estructura de datos, lo que significa que, en teoría, las cosas difíciles son mucho más fáciles de hacer!
Faltan todavía muchas cosas del motor, pero creo que la estructura básica está ya realizada, por lo que lo que se añada son "simples" añadidos que no deberían afectar mucho al código ya escrito.
Sin embargo, cuando aparezca DX9 probablemente se tengan que reescribir algunas partes, por lo que la versión sí que puede llegar a sufrir severos cambios de estructura.
Mi idea es potenciar la versión 1.0 hasta que aparezca DX9, momento en el cual empezaré el desarrollo de la versión 2.0 y espero que en medio año pueda tenerla terminada. La versión 2.0 SOLO funcionará con tarjetas que soporten totalmente DX9 y Windows XP. La razón es muy sencilla:si alguien decide utilizar el engine para desarrollar un juego, tardará al menos 1 año y medio o 2, por lo que DX9 ya estará muy establecido y Windows XP será completamente estandard. Algunos quizás piensen que es un error no mantener compatibilidad con equipos inferiores, pero yo n opuedo permitirme el lujo de mantener código antiguo. Mi filosofía siempre ha sido renovar y creo que ahora por fin el motor está lo suficientemente maduro para que en poco tiempo se pueda adaptar a DX9. Además por primrea vez, parece que las tarjetas tendrán que ser TOTALMENTE compatibles con DX9, con lo cual me facilitará mucho el trabajo porque algo que funcione con mi tarjeta funcionará en las demás, y se podrá utilizar TODA la potencia de DX9:Curvas por hardware, Shader 2.0, ...
Para la versión 2.0 espero poder incluir por primerz vez un editor de niveles. Estará desarrollado en MFC con .Net y utilizando el GDI+, lo cual en teoría debería reducir el tiempo de desarrollo.

Bien, paso a incluir las características de la versión 1.0

Jerarquías
Frustum Culling
Carga .Ase y .X
Generar LOD automáticamente
Optimización de texturas(Compresión)
Instancias de objetos
Octree por objeto
Animación de texturas
Cache de States
Perlin Noise para efectos de agua
Multitextura
Animación por Keys de mallas
Vertex Shaders
Sombras volumétricas por Stencil
Lens Flare
Sprites
Reflejos dinámicos
Modos Ventana y Full Screen
En castellano

Espero que si todo va bien, pueda tenerlo listo para mediados de Septiembre.

                               

                                Me gustaría saber qué sistema de shadows utilizais, y porqué. Yo utilizo Stencil Shadows por proyección, pero me parecen que pierdo mucho tiempo con el maldito contorno y después construyendo la lista de nuevo.                                

                                Bien, tengo un problema con el vertex shader má simple:El rectángulo con color. Este shader NO tiene que transformar, sólo dibujar un rectángulo con u ncolor(lo utilizo para las sombras)

He aquí el código:
      float sx,sy;CXCUADROPLANOVERTEX2 vpv[4];float color[4]={ .5,.5,.5,.5 };
      
      sx = (FLOAT)Video.Ancho();
      sy = (FLOAT)Video.Alto();
      sx--;
      sy--;
      BYTE *dest;
      vpv[0].x=0;vpv[0].y=sy;vpv[0].z=0;vpv[0].w=1;
      vpv[1].x=0;vpv[1].y=0;vpv[1].z=0;vpv[1].w=1;
      vpv[2].x=sx;vpv[2].y=sy;vpv[2].z=0;vpv[2].w=1;
      vpv[3].x=sx;vpv[3].y=0;vpv[3].z=0;vpv[3].w=1;
      Video.m_VBCuadro->Lock(0,0,(BYTE **)&dest,0);
      memcpy(dest,vpv,16*4);
      Video.m_VBCuadro->Unlock();
      Video.Device()->SetVertexShaderConstant(8,color,1);
      Video.Device()->SetStreamSource(0,Video.m_VBCuadro,16);
      Video.Device()->DrawPrimitive(D3DPT_TRIANGLESTRIP,0,2);

Y aquí el Shader:
static const char sPosRHWUnColor[] =
"vs.1.0                             //Shader version 1.0         n"
"mov     oPos, v0                                                   n"
"mov     oD0    , c8                //Diffuse color = vertex color  n";

static DWORD PosRHWUnColor[] =
{
   D3DVSD_STREAM(0),
   D3DVSD_REG(0, D3DVSDT_FLOAT4 ),   
   D3DVSD_END()
};

La cuestión es...¡que no hace nada! No me dibuja el rectángulo para hacer la sombra.
¿Alguien puede ayudarme?
                               

                                Bien, este VertexShader me funciona y al crearlo no me da ningún error:
static const char sPosDiffuseTex1[] =
"vs.1.0                             //Shader version 1.0         n"
"dp4     oPos.x , v0   , c4         //emit projected x position      n"
"dp4     oPos.y , v0   , c5         //emit projected y position      n"
"dp4     oPos.z , v0   , c6         //emit projected z position      n"
"dp4     oPos.w , v0   , c7         //emit projected w position      n"
"mov     oD0    , v5                //Diffuse color = vertex color  n"
"mov     oT0.xy , v7                //copy texcoords            n";

static DWORD PosDiffuseTex1[] =
{
   D3DVSD_STREAM(0),
   D3DVSD_REG(D3DVSDE_POSITION, D3DVSDT_FLOAT3 ),         //D3DVSDE_POSITION,  0  
   D3DVSD_REG(D3DVSDE_DIFFUSE,  D3DVSDT_D3DCOLOR ),      //D3DVSDE_DIFFUSE,   5  
   D3DVSD_REG(D3DVSDE_TEXCOORD0,D3DVSDT_FLOAT2 ),          //D3DVSDE_TEXCOORD0, 7  
   D3DVSD_CONST(0,1),*(DWORD*)&c[0],*(DWORD*)&c[1],*(DWORD*)&c[2],*(DWORD*)&c[3],
   D3DVSD_END()
};


Sin embargo, este...¡no!

static const char sPosTex1[] =
"vs.1.0                             //Shader version 1.0         n"
"dp4     oPos.x , v0   , c4         //emit projected x position      n"
"dp4     oPos.y , v0   , c5         //emit projected y position      n"
"dp4     oPos.z , v0   , c6         //emit projected z position      n"
"dp4     oPos.w , v0   , c7         //emit projected w position      n"
"mov     oT0.xy , v5                //copy texcoords            n";

static DWORD PosTex1[] =
{
   D3DVSD_STREAM(0),
   D3DVSD_REG(D3DVSDE_POSITION, D3DVSDT_FLOAT3 ),         //D3DVSDE_POSITION,  0  
   D3DVSD_REG(D3DVSDE_TEXCOORD0,D3DVSDT_FLOAT2 ),          //D3DVSDE_TEXCOORD0, 5
   D3DVSD_CONST(0,1),*(DWORD*)&c[0],*(DWORD*)&c[1],*(DWORD*)&c[2],*(DWORD*)&c[3],
   D3DVSD_END()
};

Me da un error al crearlo de InvalidCall. He probado modificando la declaración para incluir el diffuse y sí funciona, por lo que creo que es problema de la declaración, pero ...¿porqué?

Otra cosa, cuando lo defino, no me salen muy bien las cuentas a la hora de conocer el nº de v que se relaciona, es decir, si la primera definición ocupa 4 floats ( D3DVSDT_FLOAT3)..¿Porqué me refiero al v5 para referirme al diffuse? ¿No debería ser v4 puesto que v0,v1,v2,v3 están asociados a la posición?

Gracias por vuestra ayuda                                

                                Pues como me habeis pedido una foto de la cosa..aquí está...

Como no hay pixel shader, no se puede ver el efecto real del agua, pero la malla sí se mueve bastante bien.

                               

                                Bien, me han preguntado qué tal llevo el motor y he pensado que no estaría mal exponerlo en el foro.

Ahora mismo es perfectamente funcional. Estoy haciendo una demo tecnológica de un avión que tiene que aterrizar en una isla. El mar se crea con un Perlin Noise, lo que da una sensación de realidad muy buena, y ahora estoy implementando el sistema de nubes. Pero bueno, ahora mismo tendemos:

-Carga objetos con jerarquías(esto es fundamental. Si un motor no lo tiene...¡olvídate!)
-Sombras dinámicas utilizando Stencil.
-Reflejos dinámicos.
-Perlin Noise para simular el océano.
-Instancias de mallas, para reutilizar la misma malla.
-Efecto de Lens Flare.
-Octree por objeto.
-LOD automático y configurable.
-Animación de texturas.
-Animación de mallas por key.

Me falta:
-Nubes volumétricas.
-Vertex y Pixel Shaders.

Pero no hay fecha de finalización. ¡Hay que hacer las cosas bien!

[ Este Mensaje fue editado por: Drácula el 2002-07-25 13:01 ]                                

                                Bien, el avión ya vuela y el mar está formado por un perlin noise que da una buena impresión. Pero ahora debo hacer que el avión refleje en el mar. Sin embargo, al tener olas , no puedo utilizar la típica matriz de reflejo. Entonces se me ocurre:

a-En lugar de hacer el reflejo proyectar la sombra

b-Utilizar la técnica que aparecen en NVidia sobre proyecciones de luz para hacer Shadows. Es decir, primero renderizamos visto desde arriba y luego asociamos vértices con coordenada de textura.

¿Alguna idea sobre estos método u otros que se os ocurran?                                

                                Llevo horas pegandome con el problema y ya no sé si lo que hago es correcto o no. Tengo que hacer el efecto de que el avión rote en los ejes X(subir y bajar el morro),Y(rotar). El Z no lo utilizo por ahora.

Pues bien, al rotar en X,Y me hace un efecto super raro el avión, como si TAMBIEN rotara en Z!!

Lo que yo hago es rotar en X. Luego tengo que rotar en Y respecto al vector perpendicular con X, es decir:
VY=(0,1,0)*Matriz_Rotación X

RotarPorVector(Vy,angulo de rotación Y)

Sin embargo, sigue haciéndome locuras!! ¿Alguina idea?
                               

                                Estoy intentando implementar el efecto del mar. He visto documentación y veo que utilizan la transformada de Fourier. Sin embargo, no entiendo porqué se utiliza. ¿Alguien puede explicarme para qué se utiliza Fourier? Pero por favor, no respuestas técnicas. Lo que quiero saber es porqué debo utilizar Fourier y no simplemente la función del seno.                                

                                me convirtiera los puntos según la siguiente fórmula:

xf=(1-xi)

Es decir, que me haga un espejo que sólo afecte a las "x" y no a las "y" ni "z".

Gracias.                                

                                Voy a empezar a implementar los lightmaps y tengo una pregunta:

Imaginamos una habitación formada por 4 paredes y el suelo y el techo. Hasta aquí el lightmap es sencillo porque sería una textura de luz por cada rectángulo.
Poer ahora ponemos en el centro una pirámide.¿Cómo tengo que tratar la piramide para crear un lightmap? Al ser caras triangulares..¡me sobrará un cacho de espacio de textura en el lightmap que no utilizaré!

Es decir, está claro crear una textura de lightmap para un rectángulo, pero no se me ocurre que hacer en los casos en los que sea un solo triángulo, puesto que desperdicio mucho espacio de textura!

¿alguien conoce el tema?
Espero que entendais el problema                                

                                He subido un ejemplo en:
http://webs.ono.com/dracular/test2.zip

Aquí podeis ver como el nº de caras que se va renderizando se reduce deacuerdo a un octree establecido. La técnica es la siguiente:

Realizar un octree de forma que sólo los últimos nodos tengan la información de que VERTICE está dentro de su zona.

Al renderizar RECONSTRUIMOS la lista de índices basado en aquellos nodos que se ven. Según mac^3pixels, con una GPU esto debería ser lo más óptimo.

Espero que os funcione a todos y me digais vuestra opinión.
                               

                                mac3pixels hizo un comentario que me desconcertó, y es que el coste de la transformación de un vértice con una GPU es 0. Entonces...¿Tienen alguna utilidad los octree a nivel de malla? Los octrees a nivel de malla dividen la malla en un octree y permiten que muchos vértices y caras de la malla se desechen. A fin de cuentas, se desechan más tarde porque no se ven. Entonces, si el hecho de eliminar vértices no tiene ninguna mejora de rendimiento, y eliminar caras no mejora tampoco el rendimiento porque no se dibujan de todas formas..¿para qué un octree?

Pensadlo un poco y dadme vuestras opiniones.                                

                                Estoy desarrollando el Octree para Merlín y he decidido basarlo en vértices en lugar de en caras. ¿Para qué hacerlo por caras? Si alguien tiene algo que decir, se lo agradecería mucho.
                               

                                Juanjo pastor ha creado una librería para utilizar con Merlín v0.51. ¡Ha incluido el código fuente!, y es muuuy fácil de utilizar. Podeis descargarla desde la página downloads del motor.
                               

                                ¡Ha desaparecido! ¿Alguien sabe dónde ir para buscar algo en FlipCode?
                               

                                Vereis, quiero renderizar un objeto, y que si está la opción seleccionada, tmbién mostrar el mismo objeto pero en WireFrame. Lo malo es que no utilizo las luces de DX y el objeto no tiene diffuse, es decir que su FVF=XYZ

Pues me sale el objeto en blanco y también el wireframe en blanco. Yo lo que quiero es poder especificar un color para el wireframe. Creo que si activo el Lightning, se ejecutan los cálculos y puedo entonces utilizar la propiedad emissive de un material para que lo trate como el color a aplicar, pero...¡no me sale!

Esta es la técnica

RenderObject();
      Video.EstablecerRenderState(D3DRS_FILLMODE,D3DFILL_WIREFRAME);
      Video.m_MaterialPorDefecto->Emissive.r=1;
      Video.m_MaterialPorDefecto->Emissive.g=0;
      Video.m_MaterialPorDefecto->Emissive.b=0;
      Video.m_MaterialPorDefecto->Emissive.a=0;
      Video.m_MaterialPorDefecto->Diffuse.r=1;
      Video.m_MaterialPorDefecto->Diffuse.g=0;
      Video.m_MaterialPorDefecto->Diffuse.b=0;
      Video.m_MaterialPorDefecto->Diffuse.a=1;
      Video.EstablecerRenderState(D3DRS_LIGHTING,TRUE);

      Video.Device()->SetMaterial(Video.m_MaterialPorDefecto);

      RenderObject();

¿Alguna idea por favor?

                               

                                ¿Cómo puedo saber la memoria AGP disponible y la de Vídeo Real? Em abmos casos me gustaría conocer el total y la memoria libre que queda.

Gracias.