Bueno, pues ya que me ha dado por retozar de nuevo por los campos de Stratos, os dejo una muestra de un pequeño motor isométrico basado en gráficos 2D que programé en XNA a partir del trabajo ya hecho para el nonato "Abadia 2".

No usa tiles para el mapeado. Hay libertad absoluta de tamaño de objetos y salas así como del número de los mismos.

http://youtu.be/p1h2QTXQRrw

 En mi hilo anterior la gente comenzó a darme consejos para optimizar Direct3D.
Viendo la cantidad de posibilidades e ideas de todos, he pensado que sería mejor un hilo dedicado al tema.
La forma en que dibujo los sprites 2D la he cogido de GameDev.net

El codigo que define los vertices y dibuja la textura es este:

void BlitD3D (IDirect3DTexture9 *texture, RECT *rDest,  D3DCOLOR vertexColour, float rotate)
{ TLVERTEX* vertices;

  //Lock the vertex buffer
  vertexBuffer->Lock(0, 0, (void**)&vertices, NULL);

  vertices[0].colour = vertexColour;
  vertices[0].x = (float) rDest->left - 0.5f;
  vertices[0].y = (float) rDest->top - 0.5f;
  vertices[0].z = 0.0f;
  vertices[0].rhw = 1.0f;
  vertices[0].u = 0.0f;
  vertices[0].v = 0.0f;

  vertices[1].colour = vertexColour;
  vertices[1].x = (float) rDest->right - 0.5f;
  vertices[1].y = (float) rDest->top - 0.5f;
  vertices[1].z = 0.0f;
  vertices[1].rhw = 1.0f;
  vertices[1].u = 1.0f;
  vertices[1].v = 0.0f;

  vertices[2].colour = vertexColour;
  vertices[2].x = (float) rDest->right - 0.5f;
  vertices[2].y = (float) rDest->bottom - 0.5f;
  vertices[2].z = 0.0f;
  vertices[2].rhw = 1.0f;
  vertices[2].u = 1.0f;
  vertices[2].v = 1.0f;

  vertices[3].colour = vertexColour;
  vertices[3].x = (float) rDest->left - 0.5f;
  vertices[3].y = (float) rDest->bottom - 0.5f;
  vertices[3].z = 0.0f;
  vertices[3].rhw = 1.0f;
  vertices[3].u = 0.0f;
  vertices[3].v = 1.0f;
 
  //Unlock the vertex buffer
  vertexBuffer->Unlock();

  //Set texture
  DEVICE->SetTexture (0, texture);

  //Draw image
  DEVICE->DrawPrimitive (D3DPT_TRIANGLEFAN, 0, 2);
}

¿Alguna idea para optimizar esto?

 Pues eso, he implementado el ejemplo más tonto posible con ID3DXSprite y me peta en tiempo de ejecución diciendo que le programa ha realizado una operacion no valida.

#include
#include

ID3DXSprite *sp;
IDirect3DTexture9* tex;

.... INICIALIZO DIRECT3D ....

D3DXCreateSprite(g_pd3dDevice,&sp);
D3DXCreateTextureFromFile(g_pd3dDevice,"prueba.bmp",&tex);

g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, 0xFF000000, 0, 0 );

  g_pd3dDevice->BeginScene();

      sp->Begin(NULL);   
      sp->Draw(tex,NULL ,NULL, NULL,0xffffffff);
     sp->End();

   g_pd3dDevice->EndScene();

g_pd3dDevice->Present(NULL,NULL,NULL,NULL);   

Pues bien, he comprobado que cargue la textura, he comprobado que cree el sprite, he probado el sp->Begin() y el sp->End() sin el sp->Draw, y tambien peta (en el sp->End())

Estoy en modo a pantalla completa, a 1024x768.

Hay algo especifico que poner en la inicialización de Direct3D para que esto funcione ? o puede ser que la tarjeta grafica no soporte algo ?

Ayuda !!!

 Hola.

Os cuento a ver si alguien me da una idea.

Estoy haciendo un mapa basado en una cuadricula, y muestro en pantalla cada vez sólo cuatro cuadros. (para ahorrar memoria).
Mi idea era ir sustituyendo cada cuadro por los nuevos cargandolos de disco.

En fin... que me lio, la idea básica es:

-cargar una imagen del disco durante el juego
-meterla en la memoria de una surface ya creada

¿o es mejor destruir la antigua y crear una nueva?

                                He implementado un getpixel para leer el color de un pixel dentro de una surface siguiendo el siguiente código:

unsigned char* videoMemory;
long pitch;

void lock()
{
   DDSURFACEDESC2 ddsd;
   ddsd.dwSize = sizeof(ddsd);
   back->Lock(0, &ddsd, DDLOCK_WAIT, 0);
   videoMemory = (unsigned char*)ddsd.lpSurface;
   pitch = ddsd.lPitch;
}

void unlock()
{back->Unlock(0);}

int getPixel(int x, int y)
{return(videoMemory[x + pitch * y]);}


  Aunque todo es correcto y compila, no funciona bien. No sé si puede ser debido al formato de color o a que no me coloco en el pixel correcto dentro de la surface... no sé, el caso es que tengo muchas dudas con el mapeado de memoria de una surface en función de su profundidad de color. Estoy usando un modo gráfico de 800x600x16 bits y las surfaces son creadas a partir de BMP's de 24bits.

  Gracias por adelantado por vuestra colaboración.