Hola.

Para solucionar el tema de la velocidad con la que dibujas, deberias hacerlo por tiempo, asi irá independiente del nº de fps que de en un equipo o en otro (a menos que tengas una pausa global o algo asi). Yo lo hago asignando una cantidad MS (milisengudos) a cada sprites, es decir, este sprite(frame), estará siendo dibujando durante ese tiempo y luego cambia al siguiente y asi. Para hacerlo por tiempo, usa funciones tales como GetTickCount();, y si quieres funciones mas proximas o mas precisas usa: QueryPerformanceCounter(); y QueryPerformanceFrequency();

Una idea es crearte varias clases para controlar animaciones, yo tengo una clase que gestiona todas las secuencias de un objeto (en tu caso, la nave), una clase que gestiona una secuencia y una clase que gestiona un frame de esa secuencia. Asi lo tienes todo muy ordenado y es bastante eficaz. Eso ya por gustos.

Para el tema del Z, yo lo hago por orden de render, create una lista con los elementos a dibujar ordenados por su Z y si esta cambia, cuando cambié, actualiza la lista. Si tienes un cambio abusivo de Z, no se si será optimo, aunque no creo que tengas muchos elementos para render a la vez.

Espero que te sea util. Chao.                                

                                Hola.

Yo los calculo asi:

void CRenderDevice::DisplayFPS()
{
 DWORD dwCurrentTime = GetTickCount();

 m_dwFPS++;

 if ((dwCurrentTime - m_dwLastTime) > 1000)
 {
   char szFPS[90];
   sprintf(szFPS, "%d FPS", m_dwFPS);
   SetWindowText(m_hwnd, szFPS);

   m_dwLastTime = dwCurrentTime;
   m_dwFPS      = 0;
 }
}

Yo lo muestro en la ventanita, pero vaya, tu sacalo donde te de la gana.

PD: A lo mejor hay otra manera mas chula y elegante, pero tampoco te marees calculando los fps de tu aplicacion, mientras supere lo necesario.

Chao.                                

                                Hola bnl.

Bueno, para dibujar 2D usando dx 8.1 puedes ahorrarte todas esas cosas que dicen e inclusive sino vas a usar nada 3D, olvidarte totalmente de la camara y programar tu juego olvidandote de los conceptos de 3D. Las dx 8.1 (como la 8), incorporan una interface llamada IDXSPRITE, que se usa para dibujar texturas 2D sin la necesitad de crear un poligono,aplicarle texturas, colocar vista,etc.. Ella sola se encarga de ello y es bastante rapido, logicamente no te lo hace todo. Tu necesidad 2D, será casi como la de todos, necesitaras dibujar imagenes de cualquier tamaño en pantalla,moverlas,etc.., al usar un api totalmente 3D, necesitaras solo un leve "concepto" de 3D en tu clase o funcion de dibujado 2D. Es necesario que la imagen la partas en texturas de un tamaño compatible con la tarjeta que estas usando (o usará el usuario), logicamente potencia de 2. Una vez que consigas tener un array,lista (lo que quieras) con todas las texturas potencia de 2 que formaría tu imagen, solo tiene que dibujarla usando la IDXSPRITE y listo, la imagen sale en pantalla olvidandote de todo el tema de la camara. Mirate el SDK.

P.D:
m_p3DXSprite-Draw(pTextura,&Rect,&Scala,&RotCenter,Rotation,&Pos,ModulateColor);

Una cosa asi, se usa para dibujar una textura 2D en dx 8.

Espero haberte servido de ayuda.                                

                                Hola amigo Loover.

Nunca he usado Opengl, pero te contaré mi experiencia con eso mismo que tu quieres con Direct3D, dado que la imagen la vas a dibujar como si una textura fuera, es logico pensar que salvo tamaños potencia de 2, no vas a poder dibujar, tu problema es obvio, no todas las tarjetas graficas soportan el mismo tamaño de texturas, las de ultima generacion trabajan a 1024x1024, lo cual es suficiente para montar toda la imagen en una sola textura, pero hay gente que aun sigue sin tener esas tarjetas (yo jeje) y solo soprtan texturas de 256x256 e inclusive menos (128x128). Lo ideal es crearte algo que cargue una imagen de cualquier tamaño, la leas y la monte por texturas, cuantas sean necesarias. Si tu tarjeta permite texturas de 1024, pues montaras la imagen en una sola textura y dibujas una sola texturas, ya es discutible si esto es lo mas optimo y rapido o no, eso ya no lo sé. Pero si no permite texturas tan amplias, deberas ir leyendo esta imagen y escribiendo bloques de datos del tamaño elegido o el maximo permitido por la tarjeta y guardando estos datos (pixeles) en la textura (creada del tamaño elegido o maximo permitido), tal que, al final te quedará un array de texturas que dibujadas en un orden correcto, mostrará la imagen elegida. No te posteo codigo ni nada, porque yo lo he hecho en DirectX.

Chao.

PD: Buena suerte amigo, los libros van en marcha :lengua:.                                

                                Hola.

Pues si tu idea es usar otra version de dx e incluso otra API, lo que yo conozco no te sirve, aun asi,se haria mas o menos de la misma forma, creas una surface (el futuro bmp) del tamaño de todos los sprites que vayas a dibujar, vas leyendo los sprites y escribiendo estos datos (pixeles) en la surface creada, cuando termines, podras guardar esa surface en un fichero (bmp) y asi tendrias un bmp con todos los pequeños bmp anteriores juntos. Con dx8 si lo he hecho, pero al ser una version integrada el 2d/3d muchas funciones han cambiado mucho. Chao.                                

                                Hola.

Si conoces las dx 8, tardarias pocas horas en hacerte una aplicación para eso que tu mismo dices. Si tu idea es crear un bmp del tamaño de todos los tiles juntos, no es mas que crear una funcion que te lea un tile y lo copie en una surface previamente creada (con el tamaño correspodiente),guardas la posicion dentro de la surface del ultimo pixel dibujado y asi con todos los tiles, ya segun como queires dibujarlo, en filas y columnas, todos en una fila, etc.. Si queires guardar un array con las posiciones de la textura(tile),cuando termines de dibujarlo en la surface, podrias conseguirlo. Si usas dx 8 te puedo postear las rutinas que leen y escribe sobre surfaces. Chao.                                

                                Hola.

Estoy probando el uso de toLUA y LUA para usarlo en mi "engine", sobre todo quiero encontrar algun ejemplo practico que una toLUA con funciones escritas en c++, si alguien lo ha usado y tiene información,ejemplos o direcciones de inet que no dude en ponerlo aqui. Gracias.

P.D: La web oficial ya la conozco :sonriendo:                                

                                Hola.

Bueno, antes de explicarte como se hace, tendrás que decir que tipo de scroll estas haciendo, y me refiero a como bien dice la gente, si usas Tile o no. Si usas un scroll tipico de Aventuras Graficas y estas usando las CopyRects o el Blt, es bastante sencillo, solo tienes que copiar regiones y como quieres que se "mueva" en ambas direcciones, pues copias el rectangulo que desees subiendo o bajando el valor de x e y.
Si en cambio estas usando las dx8 y te has creado un sistema de dibujado por particion de texturas, o sea, por texturitas, pues es un poco diferente, si tu modo es como el ultimo, te podria decir como lo he hecho de una forma muy sencilla.

Chao.                                

                                Hola.

Bueno, sin duda alguna la version 8 de las dx está fuertemente mas orientada a facilitar la programacion 3D que la 2D, pero a su vez trae consigo una "interface" llamada "ID3DXSprite", la cual facilita y mucho el dibujado de una textura,si lo siento, al ser textura ha de ser potencia de 2 (su tamaño) para que no te haga cosas raras, lo cual si quieres dibujar una imagen a pantalla completa tendras que hacer un sistema que parta la imagen en texturas y su posterior dibujado.

En cambio sino requieres de una gran cantidad de fps en tu aplicacion y no te quieres molestar mucho, siempre puedes usar las CopyRects, que copian una region de una surface y da igual el tamaño que tenga, eso si, son bastante lentas en compracion con el manejo de texturas.                                

                                Hola.

Como tu lo que quieres es tener el resultado unido en un unico bmp y tiene que ser bmp, no un formato propio, pues yo lo haria de la siguiente manera:
En la dx8.1 existe una función llamada "D3DXSaveSurfaceToFile", que como bien indica su nombre, salva una surface creada en un fichero del formato que eligas,en tu caso BMP.
Bien, lo que deberias hacer es crear dos surfaces, una será la que contendra un frame y la otra la que contendria todos los frames unidos en el orden que tu eligas (su tamaño sera el ancho de todos los frames que quieras en una fila y el alto pues lo mismo).
Bien, cargas un bmp en una surface y bloqueas ambas, luego lees de una surface y escribes en la otra y asi con todos los frames y en las posiciones que tu quieras, cuando hayas leido todos los frames, pues grabas las surface resultante en un fichero y asi tendras todos los bmp en un unico fichero. Es una forma rapida, no la mejor, pero si la mas rapida, si algo no te ha quedado claro dimelo y te lo explico con mas detenimiento.

Chao.                                

                                Hola a todos.
El problema no era el tipo de formato de pixel, ya me aseguro que la surface creada sea del tipo del fichero cargado y ademas la textura es creada con este formato, comprobado.
Ya he conseguido solucinarlo y dibuja a la perfeccion, la surface la tenia como LPDIRECT3DSURFACE8 m_pSurface; y la Textura era LPDIRECT3DTEXTURE8 *m_pTextura;
Al bloquearlos y colocar los punteros, parece que el memcpy no lo hacia correctamente, ahora he declarado la surface como *m_pSurface; y el memcpy lo hace bien y como tenia pensado. Gracias por vuestro interes. Gracias.                                

                                Hola a todos.
El problema no era el tipo de formato de pixel, ya me aseguro que la surface creada sea del tipo del fichero cargado y ademas la textura es creada con este formato, comprobado.
Ya he conseguido solucinarlo y dibuja a la perfeccion, la surface la tenia como LPDIRECT3DSURFACE8 m_pSurface; y la Textura era LPDIRECT3DTEXTURE8 *m_pTextura;
Al bloquearlos y colocar los punteros, parece que el memcpy no lo hacia correctamente, ahora he declarado la surface como *m_pSurface; y el memcpy lo hace bien y como tenia pensado. Gracias por vuestro interes. Gracias.                                

                                Hola Lord.
La creacion de la textura, la creacion de la surface y la carga de una imagen dentro de la surface se hace correctamente. He dibujado la surface con las CopyRects y lo hace correctamente, asi que he deducido que mi problema está en el paso de datos del trozo de surface bloqeuado al trozo de textura bloqueado. Con esta funcion:
memcpy(_DstCur,&_SrcCur,_ScanLineSize);
he conseguido que cuando dibujo la textura se dibuje una textura con colores raros, en realidad lo que hace es grabar la misma linea de pixel ERRONEAS desde la surface en las 512 lineas (256 de textura correcto) de la textura, con lo cual  bloqueo mal la surface,coloco mal el puntero o paso mal la informacion.
HE propbado a copiar dentro de la textura bloqueada un array de color blanco y luego al dibujarla lo hace correctamente, asi que no se que puede ser...

Cuentame como lo hiciste tu.
Gracias de antemano.                                

                                Hola, estoy haciendo una clase que se encargue de dividir una imagen de cualquier tamaño en partes iguales, o sea en texturas.

Todo el proceso de calcular el numero de texturas necesarias, crearlas y demas lo hace correctamente. Luego para copiar datos de la surface en la textura, bloqueo la surface y la textura.
Tengo dos punteros a BYTE que los coloco en el inicio de la TEXTURA y el lugar que quiero empezar a leer en la surface, luego recorro todo el ALTO del rectangulo de la surface que he elegido y linea a linea (calculo la linea teniendo en cuento el Pith y el tamaño del pixel) lo copia en la textura usando
memcpy(puntero_destino,puntero_origen,tamaño_linea);

Parece que lo copia bien, pero luego el Sprite->Draw(Textura[cont],etc...); no dibuja nda. el Textura es un LPDIRECT3DTEXTURE8 *Textura;

A ver si alguien se ha encontrado con el mismo problema. Gracias.                                

                                Hola.
He estado haciendo pruebas sobre como renderizar imagenes de cualquier tamaño en dx8, el unico modo que he encontrado es usando las CopyRects, las cuales son bastante lentas, consigo hacer scroll y demas pero aunque me da 60 fps me debe ir mas rapido. Dibujando un fondo de 800x600 partido en texturas de 256x256 me puede dar hasta 200 fps o mas pero no se hacer scroll.
Mi pregunta es si en dx8 la forma mas optima de hacer esto seria creando poligonos en pantalla y texturizarlo hasta que quede algo asi como un fondo 2D y hacer el scroll por camara o hay otro modo que yo no conozco?

Si alguien ha hecho esto y lo ha resuelto de un modo optimo, porfavor hagamelo saber, gracias.