spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

// erstmal laden der Texturen:
m_Textures = new PDIRECT3DTEXTURE9[NumTextures];
D3DXIMAGE_INFO  ImageInfo;

for(int Num = 0; Num < NumTextures; Num++)
{
// Textur laden
  D3DXCreateTextureFromFileEx(me_g_D3D->GetDevice(), // Zeiger auf den Device
    TexName[Num],   // DateiName
    D3DX_DEFAULT, D3DX_DEFAULT, // Breite, Höhe
    1,  // Keine MIP-Maps
    0,  // Verwendungszweck, ganz normale Textur
    D3DFMT_A1R5G5B5,        // Format
    D3DPOOL_MANAGED,        // Speicherklasse
    D3DX_FILTER_NONE,       // Keine Mip-Maps - Kein Filter
    D3DX_FILTER_NONE,
    ColorKey,  // Die Transparente Farbe (RGBA(0, 0, 0, 0))
    &ImageInfo, // Wird mit Bildinformationen gefüllt
    NULL,       // Keine Palette, was auch immer das ist
    &m_Textures[Num]))) // Das zu erstellende Objekt

  // ERstellen der Vertizes
  struct me2DMapTile
  {
    int Number;  // Nummer des Tiles
    float u, v;     // Die Koordinaten des Tiles
  };

  me2DMapTiles** m_Tiles;   

  m_Tiles = new me2DMapTile*[NumTextures];
  // Ein Array erstellen, dass die Tiles beinhaltet
  m_Tiles[Num] = new me2DMapTile[TilesInTexture]; // Num -> für jede Textur, ist aber bis jetzt noch 1

  // Den Tiles Position und Nummer zuweisen
  ComputeTilePosition(ImageInfo.Width, ImageInfo.Height, TileWidth, TileHeight, m_Tiles[Num]); 
 
// Funktion Compute TilePositions
DLLEXPORT meResult me2DMap::ComputeTilePosition(int TexWidth, int TexHeight, int TileWidth, int TileHeight, me2DMapTile* Tiles)
{
  // Auf falsche Parameter überprüfen
  if(Tiles == NULL)
    return ME_ERROR;
  
  int TilesPerRow = TexWidth / TileWidth;
  int TilesPerColumn = TexHeight / TileHeight;
  int NumRows = TilesPerColumn;
  int NumColumns = TilesPerRow;
  int Number = 0;
  
  // TileHeightUV - float-Array, gibt Breite/Höhe in Texturkoordinaten an
  m_TileWidthUV[Number] = (float)1 / NumColumns;
  m_TileHeightUV[Number] = (float)1 / NumRows;
  
  for(int Row = 0; Row < NumRows; Row++)
  {
    for(int Column = 0; Column < NumColumns; Column++)
    {
       Tiles[Number].Number = Number;
       Tiles[Number].u      = (float)Column / NumColumns;
       Tiles[Number].v      = (float)Row / NumRows; 
       Number++;
    }
  }

  return ME_OK;
}

 // Dann Rendern

// Das Vertexdatenarray aktualisieren:
for(Line = 0; Line < m_TilesPerScreenY; Line++)
{
  for(int Column = 0; Column < m_TilesPerScreenX; Column++)
  {
  // Die Vertexpositionen aktualisieren
  
  // Links oben
  m_Vertizes[Line][Column].Vertizes[TOPLEFT].x = m_TileWidth * Column + SmoothX + StartX;
  m_Vertizes[Line][Column].Vertizes[TOPLEFT].y = m_TileHeight * Line + SmoothY + StartY;

  // Rechts oben, Dreieck 1
  m_Vertizes[Line][Column].Vertizes[TOPRIGHT_T1].x = m_TileWidth * (Column + 1) + SmoothX + StartX;
  m_Vertizes[Line][Column].VertizesTOPRIGHT_T1].y = m_TileHeight * Line + SmoothY + StartY;

//Links unten, Dreieck 1
  m_Vertizes[Line][Column].Vertizes[BOTTOMLEFT_T1].x = m_TileWidth * Column + SmoothX + StartX;
  m_Vertizes[Line][Column].Vertizes[BOTTOMLEFT_T1].y = m_TileHeight * (Line + 1) + SmoothY + StartY;

// Rechts unten
  m_Vertizes[Line][Column].Vertizes[BOTTOMRIGHT].x = m_TileWidth * (Column + 1) + SmoothX + StartX;
  m_Vertizes[Line][Column].Vertizes[BOTTOMRIGHT].y = m_TileHeight * (Line + 1) + SmoothY + StartY;

  // Dreieck 2 = Dreieck 1 links unten; rechts oben
  m_Vertizes[Line][Column].Vertizes[TOPRIGHT_T2] = m_Vertizes[Line][Column].Vertizes[TOPRIGHT_T1]; 
  m_Vertizes[Line][Column].Vertizes[BOTTOMLEFT_T2] = m_Vertizes[Line][Column].Vertizes[BOTTOMLEFT_T1];

  // rhw und z ist für alle gleich
  for(int i = 0; i < 6; i++)
  {
    m_Vertizes[Line][Column].Vertizes[(ME_2DMAP_VERTEXPOSITION)i].z = 0.0f;
    m_Vertizes[Line][Column].Vertizes[(ME_2DMAP_VERTEXPOSITION)i].rhw = 1.0f;
   }
  }
}

// Definiert in Header
struct meTile
{
    int TexNumber;
    int TileNumber;
};


// m_TileData ist ein 2D-Array aus meTile


// Dann die Arrays mit den Texturkoordinaten füllen



me2DMapTile* tile;
int TileNumber;
int TexNumber;
    
for(Line = TileY; Line < (m_MapHeight < m_TilesPerScreenY ? TileY + m_MapHeight : m_TilesPerScreenY +  TileY); Line++)
{
  for(int Column = TileX; Column < (m_MapWidth < m_TilesPerScreenX ? TileX + m_MapWidth : m_TilesPerScreenX + TileX); Column++)
  {
    // Das Tile bestimmen, welches an der Position gezeichnet werden soll
    TileNumber = m_TileData[Layer][Line][Column].TileNumber;
    TexNumber = m_TileData[Layer][Line][Column].TexNumber;
    tile = &m_Tiles[TexNumber][TileNumber];
    
   // Linke obere Ecke des Vertex
   m_Vertizes[Line - TileY][Column - TileX].Vertizes[TOPLEFT].u = tile->u;
   m_Vertizes[Line - TileY][Column - TileX].Vertizes[TOPLEFT].v = tile->v;

   // Rechte obere Ecke des Vertex
   m_Vertizes[Line - TileY][Column - TileX].Vertizes[TOPRIGHT_T1].u = tile->u + m_TileWidthUV[TexNumber];
   m_Vertizes[Line - TileY][Column - TileX].Vertizes[TOPRIGHT_T1].v = tile->v;

   // Linke untere Ecke des Vertex
   m_Vertizes[Line - TileY][Column - TileX].Vertizes[BOTTOMLEFT_T1].u = tile->u;
   m_Vertizes[Line - TileY][Column - TileX].Vertizes[BOTTOMLEFT_T1].v = tile->v + m_TileHeightUV[TexNumber];

   // Rechte obere, Dreieck 2
   m_Vertizes[Line - TileY][Column - TileX].Vertizes[TOPRIGHT_T2].u = m_Vertizes[Line - TileY][Column - TileX].Vertizes[TOPRIGHT_T1].u;
   m_Vertizes[Line - TileY][Column - TileX].Vertizes[TOPRIGHT_T2].v = m_Vertizes[Line - TileY][Column - TileX].Vertizes[TOPRIGHT_T1].v;

   // Linke untere, Dreieck 2
   m_Vertizes[Line - TileY][Column - TileX].Vertizes[BOTTOMLEFT_T2].u = m_Vertizes[Line - TileY][Column - TileX].Vertizes[BOTTOMLEFT_T1].u;
   m_Vertizes[Line - TileY][Column - TileX].Vertizes[BOTTOMLEFT_T2].v = m_Vertizes[Line - TileY][Column - TileX].Vertizes[BOTTOMLEFT_T1].v;

   // Rechte untere Ecke
   m_Vertizes[Line - TileY][Column - TileX].Vertizes[BOTTOMRIGHT].u = tile->u + m_TileWidthUV[TexNumber];
   m_Vertizes[Line - TileY][Column - TileX].Vertizes[BOTTOMRIGHT].v = tile->v + m_TileHeightUV[TexNumber];
   }
 }

PDIRECT3DDEVICE9 Device = me_g_D3D->GetDevice();  // Der D3D-Device zum zeichnen
meTile Tile;  // Gibt das aktuelle Tile an, welches gezeichnet wird
PDIRECT3DTEXTURE9 CurrentTexture = NULL;  // Gibt an, welche Textur gerade geldaen ist

#define ME_2DMAP_VERTEXFVF (D3DFVF_XYZRHW | D3DFVF_TEX1)
Device->SetFVF(ME_2DMAP_VERTEXFVF); // Vertexformat setzen

for(int l = 0; l < (m_TilesPerScreenY < m_MapHeight ? m_TilesPerScreenY : m_MapWidth); l++)
{
  for(int c = 0; c < (m_TilesPerScreenX < m_MapWidth ? m_TilesPerScreenX : m_MapWidth); c++)
  {
    Tile = m_TileData[Layer][l + TileY][c + TileX];
    if(CurrentTexture != m_Textures[Tile.TexNumber])
    {
    // Wenn Textur schon gesetzt ist, dann nicht nochmal setzen
    Device->SetTexture(0, m_Textures[Tile.TexNumber]);
    CurrentTexture = m_Textures[Tile.TexNumber];
    }
                
    // Rechtecke zeichnen, Geschwindigkeit wird noch verbessert...
    if(FAILED(Device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, &m_Vertizes[l][c], sizeof(me2DMap::me2DMapVertex))))
    {
    // Bei Fehler beenden, tritt aber nciht auf
    char d[256];
    sprintf(d, "Fehler in me2DMap::Render(): DrawPrimitiveUP");
    meErrorLog(d);
    return ME_STOP;
    }
  }
}