Terrain rendern - Bsp.: tbDirect3D - Seite 2 - 2D- und 3D-Grafik

Terrain rendern - Bsp.: tbDirect3D

Werbeanzeige

Treue Seele

24.10.2003, 16:56

Hi,

ich verstehe deinen Code nicht. Was soll da gemacht werden? Ein Wabbel-Terrain?

Ich habe zwar den Fehler nicht gefunden, aber den Code mal ein bisschen geändert.

Die Funktion Create erstellt ein Terrain,

die Funktion CreateWater erstellt ein TErrain, das Wabbelt mit Environment-Mapping und der Wasser-Textur und dem Wasser-Effect. Die Funktion Render Rendert dann alles.

Quellcode

// Terrain Klasse von Christopher Schmidt, http://www.chrissi-in-the-web.de

// Klasse für eine Landschaft
class CTerrain
{
public:
    // Konstruktor 
    inline CTerrain() {ZeroMemory(this, sizeof(CTerrain)); m_bWater=false; m_bTerrain=false;} 
    // Destruktor
    ~CTerrain();

    tbResult Create(LPDIRECT3DSURFACE9 pHeightmap);             // erstellt eine Landschaft
    tbResult Create(std::vector<std::vector<float> > vHeightmap);
    tbResult Create(char* cPath);
    tbResult Render(float fTime);                               // Rendert die Landschaft (mit Wasser)

    tbResult CreateWater(LPDIRECT3DSURFACE9 pHeightmap);        // erstellt eine Landschaft
    tbResult CreateWater(std::vector<std::vector<float> > vHeightmap);
    tbResult CreateWater(char* cPath);

    inline SetLastTile(float fLastTile) {m_fLastTile=fLastTile;}// setzt das die Entfernung für das letzte (renderbare) Tile
        
private:

    #define TERRAIN_VERTEX_FVF (D3DFVF_XYZ | D3DFVF_NORMAL)// Der Terrain-Vertex
    struct STerrainVertex
    {
        tbVector3 vPosition;        
        tbVector3 vNormal;
    };

    #define WATER_VERTEX_FVF (D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1)
    struct SWaterVertex
    {
        tbVector3 vPosition;    // Position
        tbVector3 vNormal;      // Normalvektor
        tbVector2 vTexture;     // 2D-Texturkoordinaten
    };


    PDIRECT3DTEXTURE9 m_pWaterTexture;                          // Wassertextur
    tbEffect* m_pWaterEffect;                                   // Wassereffekt

    tbResult CreateBuffer();                                    // erstellt einen Vertex und einen Index-Buffer und füllt diese (für das Terrain)
    tbVector3 NormalProc(tbVector3 v);                          // berechnet den Normalvector eines Landschafts-Tile

    tbResult CreateWaterBuffer();                               // erstellt einen Vertex und einen Index-Buffer und füllt diese (für das Wasser des Terrains)
    tbVector3 WaterNormalProc(tbVector3 v, float fTime);        // berechnet den Normalvector eines Wasser-Tiles
    tbVector2 WaterTextureProc(tbVector3 v, float fTime);       // Berechnet die Texturkoordinaten (vom Wasser)
    tbVector3 WaterPositionProc(tbVector3 v, float fTime);      // berechnet die Position 
    tbResult UpdateWater(float fTime);                          // bewegt das Wasser der Landschaft

    inline GetVertexIndex(int x, int y) {return y * m_fTerrainData.size() + x;}
    inline GetWaterVertexIndex(int x, int y) {return y * m_fWaterData.size() + x;}

    float m_fLastTile;                                          // Entfernung des letzen (renderbaren) Tile
    std::vector<std::vector<float> > m_fTerrainData;
    std::vector<std::vector<float> > m_fWaterData;

    bool                    m_bWater;                           // Mit Wasser?
    bool                    m_bTerrain;                         // Mit Terrain?
    tbVertexBuffer*         m_pWaterVB;                         // Wasser-Vertex-Buffer
    tbIndexBuffer*          m_pWaterIB;                         // Wasser-Index-Buffer
    tbVertexBuffer*         m_pTerrainVB;                       // Terrain-Vertex-Buffer
    tbIndexBuffer*          m_pTerrainIB;                       // Terrain-Index-Buffer
};

Quellcode

// Terrain Klasse von Christopher Schmidt, http://www.chrissi-in-the-web.de

tbResult CTerrain::Create(LPDIRECT3DSURFACE9 sHeightmap)
{
    m_bTerrain=true;

    // Zählvariablen für die Schleifen
    int i,j;
           
    D3DSURFACE_DESC HeightmapInfo;

    // Informationen über die Heightmap holen    
    sHeightmap->GetDesc(&HeightmapInfo);
    
    // Breite und Länge der Landschaft speichern (Vector anpassen!)
    m_fTerrainData.resize(HeightmapInfo.Width);
    for(i=0; i<=m_fTerrainData.size();i++) {
        m_fTerrainData[i].resize(HeightmapInfo.Height);
    }

    // Oberfläche sperren
    D3DLOCKED_RECT LockedRect;
    
    sHeightmap->LockRect(&LockedRect,0,0);

    // und einen Zeiger auf die Pixel anlegen
    BYTE* lpHeights = (BYTE*) LockedRect.pBits;

    int nPitch = LockedRect.Pitch;

    // und mit Werten belegen
    for(i=0;i<=m_fTerrainData.size();i++)
    {
        // der Farbwert des Pixels bestimmt die Höhe
        for(j=0;j<=m_fTerrainData[i].size();j++)
        {
            m_fTerrainData[i][j] = (float)lpHeights[i*nPitch+j];
        }
    }

    sHeightmap->UnlockRect();

    CreateBuffer();
    
    return TB_OK;
};

tbResult CTerrain::Create(char* cPath)
{
    m_bTerrain=true;

    if(!tbFileExists(GetPath(cPath))) {
        TB_ERROR("Heightmap exestiert nicht", TB_ERROR);
    }

    PDIRECT3DSURFACE9 pHeightmap;

    D3DXIMAGE_INFO ImgInfo;
    
    // Informationen über die Heightmap holen    
    D3DXGetImageInfoFromFile(GetPath(cPath),&ImgInfo);

    // Oberfläche für die Heightmap anlegen
    tbDirect3D::GetDevice()->CreateOffscreenPlainSurface(ImgInfo.Width,
                                               ImgInfo.Height,
                                               D3DFMT_L8,
                                               D3DPOOL_SCRATCH,
                                               &pHeightmap,0);

    // Heightmap laden
    D3DXLoadSurfaceFromFile(pHeightmap,0,0,GetPath(cPath),0,D3DX_DEFAULT,0,0);

    Create(pHeightmap);

    TB_SAFE_RELEASE(pHeightmap);

    return TB_OK;
};

tbResult CTerrain::Create(std::vector<std::vector<float> > vHeightmap)
{
    m_bTerrain=true;

    // Zählvariablen für die Schleifen
    int i,j;
           
    // Breite und Länge der Landschaft anpassen
    m_fTerrainData.resize(vHeightmap.size());
    for(i=0;i<=m_fTerrainData.size();i++) {
        m_fTerrainData[i].resize(vHeightmap[0].size());
    } 

    // und mit Werten belegen
    for(i=0;i<=m_fTerrainData.size();i++)
    {
        // der Inhalt des Vectors bestimmt die Höhe
        for(j=0;j<=m_fTerrainData[i].size();j++)
        {
            m_fTerrainData[i][j] = (vHeightmap[i][j]);
        }
    }

    CreateBuffer();

    return TB_OK;
};

tbResult CTerrain::CreateBuffer()
{

    STerrainVertex  Vertex;
    tbVector3       vPosition;
    WORD            wIndex;
    int             x,y;

    // Puffer erstellen mit 16 Bits pro Index (int)
    m_pTerrainIB = new tbIndexBuffer;
    if(m_pTerrainIB->Init(((m_fTerrainData.size()-1) * (m_fTerrainData[0].size()-1) * 6) * sizeof(WORD), sizeof(WORD), D3DFMT_INDEX16))
    {
        // Fehler!
        TB_ERROR("Fehler beim erstellen des Index-Buffers des Terrains",TB_ERROR);
    }

    // Den Index-Buffer initialisieren
    for(x = 0; x < m_fTerrainData.size() - 1; x++)
    {
        for(y = 0; y < m_fTerrainData[0].size() - 1; y++)
        {
            wIndex = GetVertexIndex(x, y);      m_pTerrainIB->AddIndex(&wIndex);
            wIndex = GetVertexIndex(x + 1, y);  m_pTerrainIB->AddIndex(&wIndex);
            wIndex = GetVertexIndex(x, y + 1);  m_pTerrainIB->AddIndex(&wIndex);

            // Zweites Dreieck
            wIndex = GetVertexIndex(x, y + 1);      m_pTerrainIB->AddIndex(&wIndex);
            wIndex = GetVertexIndex(x + 1, y);      m_pTerrainIB->AddIndex(&wIndex);
            wIndex = GetVertexIndex(x + 1, y + 1);  m_pTerrainIB->AddIndex(&wIndex);
        }
    }

    // Den Index-Buffer aktualisieren
    if(m_pTerrainIB->Update()) return TB_ERROR;

    // Vertex-Buffer erstellen
    m_pTerrainVB = new tbVertexBuffer;
    if(m_pTerrainVB->Init(m_fTerrainData.size() * m_fTerrainData[0].size() * sizeof(STerrainVertex), 
                            sizeof(STerrainVertex),
                            TERRAIN_VERTEX_FVF,
                            0,
                            D3DPOOL_MANAGED))
    {
        TB_ERROR("Fehler beim erstellen des Vertexbuffers",TB_ERROR);
    }

    // Die Position der Vertizes berechnen (mittels Heightmap)!
    for(x = 0; x < m_fTerrainData.size(); x++)
    {
        for(y = 0; y < m_fTerrainData[0].size(); y++)
        {
            // Den Vertex generieren.
            Vertex.vPosition.x = (float)y;

            Vertex.vPosition.y = (float)m_fTerrainData[x][y]/10.0f;

            Vertex.vPosition.z = (float)(m_fTerrainData.size()-1 - y);

            Vertex.vNormal = vPosition;

            // Den Vertex setzen
            m_pTerrainVB->SetVertex(GetVertexIndex(x, y), &Vertex);
        }
    }

    // Den Vertex-Buffer aktualisieren
    if(m_pTerrainVB->Update()) TB_ERROR("Fehler beim aktuallisieren des Terrain-Vertex-Buffers",TB_ERROR);;

    return TB_OK;
};

tbResult CTerrain::Render(float fTime)
{
    if(m_bTerrain) {
        // Datenquellen und Vertexformat setzen
        tbDirect3D::GetDevice()->SetStreamSource(0, m_pTerrainVB->GetVB(), 0, sizeof(STerrainVertex));
        tbDirect3D::GetDevice()->SetIndices(m_pTerrainIB->GetIB());
        tbDirect3D::SetFVF(TERRAIN_VERTEX_FVF);

        // Zeichnen!
        tbDirect3D::GetDevice()->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0,
                                                      (m_fTerrainData.size()) * (m_fTerrainData[0].size()), 0,
                                                      (m_fTerrainData.size()-1) * (m_fTerrainData[0].size()-1) * 2);
    }

    // Wasser zeichene (wenn möglich)
    if(m_bWater) {

        UpdateWater(fTime);

        // Texturen setzen
        tbDirect3D::SetTexture(0, m_pWaterTexture);

        // Datenquellen und Vertexformat setzen
        tbDirect3D::GetDevice()->SetStreamSource(0, m_pWaterVB->GetVB(), 0, sizeof(SWaterVertex));
        tbDirect3D::GetDevice()->SetIndices(m_pWaterIB->GetIB());
        tbDirect3D::SetFVF(WATER_VERTEX_FVF);

        // Zeichnen!
        int iNumPasses = m_pWaterEffect->Begin();
        for(int iPass = 0; iPass < iNumPasses; iPass++)
        {
            m_pWaterEffect->Pass(iPass);
            tbDirect3D::GetDevice()->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0,
                                                          (m_fWaterData.size()) * (m_fWaterData[0].size()), 0,
                                                          ((m_fWaterData.size()-1) * (m_fWaterData[0].size()-1) * 2));
        }
        m_pWaterEffect->End();  
    };

    return TB_OK;
};

tbVector3 CTerrain::NormalProc(tbVector3 v)
{
    tbVector3 vNormal;

    // In Normalvektor umwandeln
    vNormal = tbVector3Cross(tbVector3Normalize(tbVector3(1.0f, v.x, 0.0f)),
                             tbVector3Normalize(tbVector3(0.0f, v.z, 1.0f)));

    return vNormal;
};

tbResult CTerrain::CreateWater(LPDIRECT3DSURFACE9 sHeightmap)
{
    m_bWater=true;

    // Zählvariablen für die Schleifen
    int i,j;
           
    D3DSURFACE_DESC HeightmapInfo;

    // Informationen über die Heightmap holen    
    sHeightmap->GetDesc(&HeightmapInfo);
    
    // Breite und Länge des Wassers speichern (Vector anpassen!)
    m_fWaterData.resize(HeightmapInfo.Width);
    for(i=0; i<=m_fWaterData.size();i++) {
        m_fWaterData[i].resize(HeightmapInfo.Height);
    }

    // Oberfläche sperren
    D3DLOCKED_RECT LockedRect;
    
    sHeightmap->LockRect(&LockedRect,0,0);

    // und einen Zeiger auf die Pixel anlegen
    BYTE* lpHeights = (BYTE*) LockedRect.pBits;

    int nPitch = LockedRect.Pitch;

    // und mit Werten belegen
    for(i=0;i<=m_fWaterData.size();i++)
    {
        // der Farbwert des Pixels bestimmt die Höhe
        for(j=0;j<=m_fWaterData[i].size();j++)
        {
            m_fWaterData[i][j] = (float)lpHeights[i*nPitch+j] / 10.0f;
        }
    }

    sHeightmap->UnlockRect();

    CreateWaterBuffer();
    
    return TB_OK;
};

tbResult CTerrain::CreateWater(char* cPath)
{
    m_bWater=true;

    if(!tbFileExists(GetPath(cPath))) {
        TB_ERROR("Heightmap exestiert nicht", TB_ERROR);
    }

    PDIRECT3DSURFACE9 pHeightmap;

    D3DXIMAGE_INFO ImgInfo;
    
    // Informationen über die Heightmap holen    
    D3DXGetImageInfoFromFile(GetPath(cPath),&ImgInfo);

    // Oberfläche für die Heightmap anlegen
    tbDirect3D::GetDevice()->CreateOffscreenPlainSurface(ImgInfo.Width,
                                               ImgInfo.Height,
                                               D3DFMT_L8,
                                               D3DPOOL_SCRATCH,
                                               &pHeightmap,0);

    // Heightmap laden
    D3DXLoadSurfaceFromFile(pHeightmap,0,0,GetPath(cPath),0,D3DX_DEFAULT,0,0);

    CreateWater(pHeightmap);

    TB_SAFE_RELEASE(pHeightmap);

    return TB_OK;
};

tbResult CTerrain::CreateWater(std::vector<std::vector<float> > vHeightmap)
{
    m_bWater=true;
 
    // Zählvariablen für die Schleifen
    int i,j;
           
    // Breite und Länge der Landschaft anpassen
    m_fWaterData.resize(vHeightmap.size());
    for(i=0;i<=m_fWaterData.size();i++) {
        m_fWaterData[i].resize(vHeightmap[0].size());
    }

    // und mit Werten belegen
    for(i=0;i<=m_fWaterData.size();i++)
    {
        // der Inhalt des Vectors bestimmt die Höhe
        for(j=0;j<=m_fWaterData[i].size();j++)
        {
            m_fWaterData[i][j] = vHeightmap[i][j];
        }
    }

    CreateWaterBuffer();

    return TB_OK;
};

tbVector3 CTerrain::WaterPositionProc(tbVector3 v, float fTime)
{
    float fHeight;

    // Die Höhe berechnet sich mit verschiedenen Sinusfunktionen,
    // die abhängig von der Position des Vertex und abhängig von der Zeit sind.
    fHeight = ((sinf(v.x * 0.2f + fTime * 3.0f) * cosf(v.z * 0.2f + fTime * 3.0f)) *
              sinf(fTime + v.x * 0.1f + v.z * 0.1f) * 2.0f +
              sinf(fTime) * 0.5f) * tbFloatRandom(0.9f,1.1f);

    // Positionsvektor liefern
    return tbVector3(v.x, fHeight, v.z);
}

tbVector3 CTerrain::WaterNormalProc(tbVector3 v, float fTime)
{
    tbVector3 m;
    tbVector3 vNormal;


    // Steigung berechnen
    m.x = WaterPositionProc(v + tbVector3(1.0f, 0.0f, 0.0f), fTime).y - WaterPositionProc(v, fTime).y;
    m.z = WaterPositionProc(v + tbVector3(0.0f, 0.0f, 1.0f), fTime).y - WaterPositionProc(v, fTime).y;

    // In Normalvektor umwandeln
    vNormal = tbVector3Cross(tbVector3Normalize(tbVector3(1.0f, m.x, 0.0f)),
                             tbVector3Normalize(tbVector3(0.0f, m.z, 1.0f)));

    return vNormal;
}

// Rückruffunktion für die Texturkoordinaten
tbVector2 CTerrain::WaterTextureProc(tbVector3 v, float fTime)
{
    return tbVector2(v.x * 0.01f + sinf(fTime * 0.1f), v.z * 0.01f + cosf(fTime * 0.1f));
}

// Diese Funktion aktualisiert die Wasseroberfläche.
tbResult CTerrain::UpdateWater(float fTime)
{
    SWaterVertex Vertex;
    tbVector3 vPosition;

    // Jeden Vertex durchgehen
    for(int x = 0; x < m_fWaterData.size(); x++)
    {
        for(int y = 0; y < m_fWaterData[0].size(); y++)
        {
            // Den Vertex generieren. Dazu wird die Position des Vertex berechnet
            // und dann als Parameter für die verschiedenen Rückruffunktionen verwendet.
            vPosition.x = ((float)(x) / (float)(m_fWaterData.size() - 1) - 0.5f) * 200.0f;
            vPosition.y = m_fWaterData[x][y]/10.0f;
            vPosition.z = ((float)(-y) / (float)(m_fWaterData[0].size() - 1) + 0.5f) * 200.0f;

            // Rückruffunktionen aufrufen
            Vertex.vPosition = WaterPositionProc(vPosition, fTime);
            Vertex.vNormal = WaterNormalProc(vPosition, fTime);
            Vertex.vTexture = WaterTextureProc(vPosition, fTime);
            
            // Den Vertex setzen
            m_pWaterVB->SetVertex(GetWaterVertexIndex(x, y), &Vertex);
        }
    }

    // Den Vertex-Buffer aktualisieren
    if(m_pWaterVB->Update()) TB_ERROR("Fehler beim akutallisieren des Wasser-Vertex-Buffers",TB_ERROR);
    
    return TB_OK;
}

// Initialisierung der Wasseroberfläche
tbResult CTerrain::CreateWaterBuffer()
{
    WORD wIndex;

    // Dynamischen Vertex-Buffer erstellen
    m_pWaterVB = new tbVertexBuffer;
    if(m_pWaterVB->Init(m_fWaterData.size() * m_fWaterData[0].size() * sizeof(SWaterVertex), sizeof(SWaterVertex), WATER_VERTEX_FVF,
                        D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DPOOL_DEFAULT))
    {
        TB_ERROR("Fehler beim erstellen des Wasser-Vertex-Buffer",TB_ERROR);
    }

    // Puffer erstellen mit 16 Bits pro Index (WORD)
    m_pWaterIB = new tbIndexBuffer;
    if(m_pWaterIB->Init((m_fWaterData.size() - 1) * (m_fWaterData[0].size() - 1) * 6 * sizeof(WORD), sizeof(WORD), D3DFMT_INDEX16))
    {
        TB_ERROR("Fehler beim erstellen des Wasser-Index-Buffer",TB_ERROR);
    }

    // Den Index-Buffer können wir jetzt schon initialisieren, denn er ist
    // ja statisch. 
    for(int x = 0; x < m_fWaterData.size()-1; x++)
    {
        for(int y = 0; y < m_fWaterData[0].size()-1; y++)
        {
            // erstes Dreieck
            wIndex = GetWaterVertexIndex(x, y);     m_pWaterIB->AddIndex(&wIndex);
            wIndex = GetWaterVertexIndex(x + 1, y); m_pWaterIB->AddIndex(&wIndex);
            wIndex = GetWaterVertexIndex(x, y + 1); m_pWaterIB->AddIndex(&wIndex);

            // Zweites Dreieck
            wIndex = GetWaterVertexIndex(x, y + 1);     m_pWaterIB->AddIndex(&wIndex);
            wIndex = GetWaterVertexIndex(x + 1, y);     m_pWaterIB->AddIndex(&wIndex);
            wIndex = GetWaterVertexIndex(x + 1, y + 1); m_pWaterIB->AddIndex(&wIndex);
        }
    }

    // Den Index-Buffer aktualisieren
    if(m_pWaterIB->Update()) TB_ERROR("Fehler beim aktuallisieren des Wasser-Index-Buffers",TB_ERROR);

    // ------------------------------------------------------------------

    // Die Textur der Wasseroberfläche laden
    m_pWaterTexture = tbTextureManager::GetTexture(GetPath(".\\data\\Water.jpg"));
    if(m_pWaterTexture == NULL) TB_ERROR("Die Wassertextur des Terrain ist NULL",TB_ERROR);

    // Effekt laden
    m_pWaterEffect = new tbEffect;
    if(m_pWaterEffect == NULL) TB_ERROR("Der Wassereffect des Terrain ist NULL", TB_ERROR);
    if(m_pWaterEffect->Init(GetPath(".\\data\\Water.fx")))  TB_ERROR("Der Wassereffect des Terrain konnte nicht intitallisiert werden", TB_ERROR);

    return TB_OK;
};

CTerrain::~CTerrain() {

    // Buffer löschen
    TB_SAFE_DELETE(m_pTerrainVB);
    TB_SAFE_DELETE(m_pTerrainIB);

    TB_SAFE_DELETE(m_pWaterVB);
    TB_SAFE_DELETE(m_pWaterIB);
    TB_SAFE_DELETE(m_pWaterEffect);
};

Hoffentlich hilft das dir,

Cu,

Chrissi

[EDIT]Ich hab das ganze noch sehr provisorisch gemacht. Es könnte sein, das dort noch ein paar Speicherlecks sind.[/EDIT]

Zum Seitenanfang

Nahdar

Frischling

Beiträge: 36

Wohnort: Köln

Beruf: Student

13.04.2012, 17:42

Hey Chrissi, was an deinem Code müsste ich verändern um das wabbeln rauszunehmen? Will halt ein gewelltes Terrain ohne permanente Bewegung.

LG

Zum Seitenanfang

ludosimius

Frischling

Beiträge: 1

08.04.2015, 12:03

Hallo Leute,
Der Eintrag ist zwar schon über 10 Jahre alt, aber ich versuche gerade die von Christopher Schmidt erstellte CTerrain Klasse in das tbDirect3D Beispiel zu implementieren.
Ich tue mich allerdings etwas schwer. Außerdem weiß ich nicht welches Format die Heightmap haben sollte? Bin dankbar für jede Hilfe!
Also ich hab die Terrain.h und Terrain.cpp Datei zum Projekt hinzugefügt und erstmal die Zeichen Funktion in der vorhandenen tbDirect3D.cpp Datei auskommentiert.
Falls ich das richtig verstehe, muss ich an sich ja nur ein neues Objekt der Klasse CTerrain erstellen un an die Winmain übergeben?

Gruß,
ludosimius

Zum Seitenanfang

Julién

Alter Hase

Beiträge: 717

Wohnort: Bayreuth

Beruf: Student | Hilfswissenschaftler in der Robotik

14.04.2015, 17:29

Inwiefern meinst du welches Format?
Für ein einfaches Terrain brauchst du eigentlich nur die Vertexpositionen sowie die UV Koordinaten,
du musst dann lediglich nur noch einen Vertex Buffer mit den Vertices füllen, den Texturebuffer füllen und rendern. Et Voilá!

Ich bin mir aber nicht sicher, ob ich deine Frage wirklich verstanden habe.

Bitte eröffne einen neuen eigenen Thread und schreibe mal was du genau mit "Format [für] die Heigmap" meinst.
MfG Julien

I write my own game engines because if I'm going to live in buggy crappy filth, I want it to me my own - Ron Gilbert

Zum Seitenanfang

Werbeanzeige

spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Terrain rendern - Bsp.: tbDirect3D

Quellcode

Quellcode