Vereis, quiero que cuando el ratón llegue a los bordes de la ventana, vuelva a posicionarse en el otro borde . Por ejemplo, muevo el ratón a la derecha, y cuando llego al borde, quiero que aparezca por la izquierda.

Lo necesito porque cuando llego al final de la pantalla ya no puedes mover más el ratón hacia ese lado y claro...¡sería conveniente en los juegos que esto se hiciera!

Sé que con DirectInput no hay problemas, pero prefiero no utilizarlo para que el debug sea mucho más cómodo.

(por favor, én este post preferiría un poco de código en lugar de teoría)

Gracias                                

                                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!!

Así que aquí está el programa( http://webs.ono.com/dracular/test.zip ). Os pido que lo probeis y posteis vuestras especificaciones y que valores os da en los dos métodos, para ver si hay diferencias.

Empiezo yo:

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!!)



[ Este Mensaje fue editado por: Drácula el 2002-05-03 15:07 ]                                

                                ¿Alguien puede explicarme cómo funcionan los bones?                                

                                Como supongo que sabreis, sigo con Merlín, esta vez enfocado totalmente a 3D. Bien, pues ahora voy a implementar la partición del espacio por Octrees y para ver que funciona bien, me gustaría que alguien pudiera enviarme una escena en formato ase con bastante complejidad(más de 100.000 polígonos) para poder probar a conciencia el motor.
Una vez resuelva el problema de forma óptima, subiré la 1ª demo tecnológica. Os pido por favor ayuda para que sea lo más impactante posible.

                               

                                Bien, todos conocemos lo fantástico que es el mundo matricial, pero ahora os planteo una duda..¿Cómo definir una estructura matricial para un objeto ? Parece una tonteria, pero voy a poner un ejemplo:

Utilizar 5 matrices, 3 de rotación, 1 de posición y 1 de escalado. Esto facilita mucho el código, pero no es optimo, porque..¿qué pasa si no utilizo uno de los ejes de rotación en algunos casos?
Y otro problema..¿Qué pasa cuando no me bastan esas matrices y necesito definir alguna más?

Entonces...¿Cómo solucionariais el problema que SEGURO que os ocurre a todos?
                               

                               
Debido a que Terra tarda en actualizarse, he puesto la web en otro servidor:

http://webs.ono.com/dracular

Disculpad las molestias.                                

                                Corrige ciertos errores y mejora en algunos aspectos, como el efecto de flash utilizando Gamma.

Os agradecería que me enviarais vuestros feedbacks. Los que me habeis enviado hasta ahora me han ayudado mucho, y os lo agradezco mucho. Os pido que si lo probais y notais algún error, me lo indiqueis para poder mejorarlo.

Gracias a todos.
                               

                                Sabeis cual es el correcto, o en cualquier caso, cómo detectar qué sistema soporta la tarjeta para adecuarlo al mismo?                                

                                ¿Cómo puedo convertir una textura normal en una comprimida?

No me sirve grabarla y después cargarla, quiero hacerlo en tiempo de ejecucíón.

¿alguien conoce el tema?                                

                                Pues eso, necesito conocer el tamaño del escritorio y también su profundidad.

¿alguien sabe cómo?                                

                                Cuando grabo el backbuffer, me aparece TODO del mismo color. Y no entiendo porqué, puesto que creo que lo hago correctamente.

Este es mi código:

   LPDIRECT3DSURFACE8 pBackBuffer;

   m_pd3dDevice->GetBackBuffer( 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer );

   HRESULT hr=D3DXSaveSurfaceToFile(nombre,
      D3DXIFF_BMP,   // Formato
      pBackBuffer,
      NULL,   // Paleta
      NULL   // Rectángulo del area a grabar
      );
   if(hr!=D3D_OK) {
      EstablecerUltimoError(hr);
      Merlin.Debug(_T("CXVideo::GrabarPantalla"),*UltimoError());
   }
   pBackBuffer->Release();


¿Alguien puede ayudarme?
                               

                                He encontrado un documento en nvidia que explica como se calcula un color. Es muy interesante y clarificador.

El documento se llama ColorKey.pdf y está en la sección de DirectX. Aunque se refiere a DX7, su utilización es aplicable a DX8.                                

                                Ya he subido la nueva versión. Espero que seais críticos y me echeis un cable con vuestros feedbacks!!

Gracias.

http://www.terra.es/personal4/dracular                                

                                Me ocurre a menudo que ejecuto mi motor y el programa sale perfectamente liberando toda la memoria. Sin embargo, la ventana queda abajo, en la barra de tareas, y al pulsar sobre ella, desaparece!!

¿Conoceis la razón?

Tened en cuenta que libero toda la memoria y por debug sé que es así. También UnregisterClass!!

¿Qué misterio es este?
                               

                                Curiosamente me acabo de dar cuenta de que en DX8.1 con mi Savage de 32 MB NO PUEDO tener el escritorio en 32 bits y ejecutar ningún ejemplo de D3D en modo ventana. Sin embargo, hasta ahora funcionaba perfectamente con versiones anteriores. Sí que funciona en pantalla completa, o en 16 bits en modo ventana.

¿Alguien ha observado el mismo problema?
                               

                                Bien, una vez resuelto el blending para que el sprite me ilumine el fondo, he decidido utilizar el Specular para darle más fuerza.
Según tengo entendido, para que veamos un color, DX8 calcular primero el valor del texel realizando la operación que le indicamos, normalmente modular textura y diffuse, y después le suma el Specular. Algo así:

Texel Final=(Texel Modulate Diffuse)+Specular


Por eso, si queremos iluminar un sprite, debemos aumentar su specular, y si queremos oscurecerlo, disminuimos su diffuse.

Esto funciona, pero...Si utilizo el specular siguiente:

Specular=ARGB(0,255,255,255)

Ocurre un problema, y es que no me respeta el Alpha, y el sprite en lugar de aparecer con la forma del foco de luz, me aparece un rectángulo, como si no tuviera transparencia. Y eso sí, me sale más iluminado...

¿Alguien sabe qué hago mal o qué puedo hacer para solventar el problema?
                               

                                Quier hacer que un sprite cuando pase por encima del fondo, actue como si fuera un foco. Es una especie de LightMap, pero en lugar de utilizar dos texturas en la misma cascada, primero dibujo el fondo, y luego quiero que la siguiente textura que dibujo(que es el sprite) ilumine el fondo.
He probado con:
   s->m_ListaState.Insertar(0, D3DTSS_COLOROP,   D3DTOP_ADD);
   s->m_ListaState.Insertar( 0, D3DTSS_COLORARG1, D3DTA_CURRENT );
   s->m_ListaState.Insertar( 0, D3DTSS_COLORARG2, D3DTA_TEXTURE );

Pero me sale el sprite totalmente blanco, y no hace el efecto que yo espero. ¿Qué es lo correcto?

Por cierto, la textura del sprite tiene Aplha, que se mezcla utilizando:

   EstablecerTextureStageState(0,D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
   EstablecerTextureStageState(0,D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
   EstablecerTextureStageState(0,D3DTSS_ALPHAOP,   D3DTOP_MODULATE );
                               

                                Y ahora las características del Motor, Merlín v0.5

-Control automático de Lost Devices.
Esto es realmente pesado y complejo si tienes que hacerlo tu mismo. Resulta que en algunos casos puedes perder la memoria en la que están los gráficos. Ello conlleva tener que volver a cargarlos, o en el caso de los VertexBuffer, volver a crearlos. Merlín lo resuelve automáticamente.
-Totalmente compatible con DirectX 8.1
No se utilizan para nada las referencias a versiones anteriores de DirectX, con lo que se consigue una estabilidad y fiabilidad máximas con los últimos drivers del mercado.
-Sprites con rotaciones, escalado, trasparencias y tinte.
Los Sprites pueden tener cualquier tamaño y ¡pueden rotarse en los 3 ejes!, escalarse en horizontal, vertical o en ambos, permiten efectos de trasparencias, y se pueden tintar.
-Control de velocidad.
Existe una función que correctamente utilizada ajusta la velocidad del juego a cualquier ordenador. Este es uno de los grandes problemas de los programadores 2D, que ven como sus juegos funcionan demasiado rápidos en ordenadores modernos, y quieren que funcionen a la misma velocidad.
-Fácil acceso a los objetos.
A la hora de programa, se agradece mucho que se puedan utilizar las facilidades de C++. Se puede acceder a una objeto de una lista por su nombre, con lo que clarifica muchísimo el código.
-Castellano.
Las clases son en castellano, por lo que su lectura y comprensión es mucho más sencilla para aquellos que no dominamos el inglés.
-Velocidad.
Utilizo las técnicas aprendidas en anteriores motores para ofrecer la máxima velocidad de ejecución. Si algo se tiene que calcular, el motor lo hará sólo cuando sea necesario, aumentando así la velocidad del juego.
-Modos de pantalla: Pantalla completa o Ventana.
Se puede seleccionar cualquier resolución y profundidad de pantalla disponibles. También se puede utilizar el modo ventana, que permite una depuración del código mucho más cómoda.
-Múltiples formatos de carga de ficheros gráficos.
DirectX 8 permite cargar jpg, png, tga, bmp y otros formatos.
-Fuentes por aceleradora.
Muestra las fuentes en pantalla utilizando la aceleradora y no las funciones de Windows.

Espero que esta semana pueda subir la versión definitiva.
                               

                                Recuerdo que leí hace un tiempo que se podía incluir un

#pragma comment(linker,???)

para que en un archivo.cpp se informara al linkador de qué librerías tenía que incluir.

Pero lo he probado y no me funciona.

¿Sabeis algo de esto?
                               

                                Qué es esto?