spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// Windows-Hauptfunktion
int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   char* pcCommandLine,
                   int iShowCommand)
{
    // TriBase-Engine initialisieren
    tbInit();

...

C-/C++-Quelltext

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


    // Jeden Vertex durchgehen
    for(WORD x = 0; x < g_iResolution; x++)
    {

...

C-/C++-Quelltext

// Verwendete Symbole vordeklarieren
class CGame;

// __________________________________________________________________
// Klasse das Terrain
class CTerrain
{
public:
    CGame*                  m_pGame;                // Zeiger auf die Spielklasse
    PDIRECT3DTEXTURE9       m_tTerrainTexture;      // Terraintextur
    PDIRECT3DCUBETEXTURE9   g_pEnvMap;              // Umgebungstextur
    tbEffect*               m_eTerrainEffect;       // Terrain-Effekte
    tbVertexBuffer*         m_vbTerrainVB;          // Terrain-Vertex-Buffer
    tbIndexBuffer*          m_ibTerrainIB;          // Terrain-Index-Buffer
    const int               m_iResolution;          // Die Auflösung der Oberfläche
    int                     m_fBitmap[40000];
    int                     m_isize;
    
    
    //Konstruktor
    inline CTerrain():
        m_tTerrainTexture(NULL),
        g_pEnvMap(NULL),
        m_eTerrainEffect(NULL),
        m_vbTerrainVB(NULL),
        m_ibTerrainIB(NULL),
        m_iResolution(64),
        m_isize(200)


        {
        }
  

        
            tbResult CTerrain::InitTerrain();
            tbVector3 PositionProc(float x, float z);
            tbVector3 NormalProc(tbVector3 v);
            tbVector2 TextureProc(tbVector3 v);
            float CTerrain::GiveHeight(float fx, float fy);
}

C-/C++-Quelltext

// math um PI nutzen zu können. Wichtig für die Default-Kameraeinstellungen.
#define _USE_MATH_DEFINES
#include <math.h>
#include "Breakanoid.h"


struct STerrainVertex
{
    tbVector3           vPosition;  // Position
    tbVector3           vNormal;    // Normalenvektor
    tbVector2           vTexture;   // 2D-Texturkoordinaten
    static const DWORD  dwFVF;      // Vertexformat
}; 
const DWORD STerrainVertex::dwFVF = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1;


// Initialisierung des Terrains
tbResult CTerrain::InitTerrain()
{
 float fHeight;
 STerrainVertex Vertex;
 int iNumVertices;
 int iNumIndices;
 WORD wIndex;


 // Vertex- und Index-Buffer erstellen. 8 Vertizes, 36 Indizes.
 // Der Vertex-Buffer soll dynamisch sein.
 // Die Anzahl der benötigten Vertizes ist die Auflösung zum Quadrat.
 iNumVertices = m_iResolution * m_iResolution;

 // Statischen Vertex-Buffer erstellen
 m_vbTerrainVB = new tbVertexBuffer;
 if(m_vbTerrainVB->Init(iNumVertices * sizeof(STerrainVertex), sizeof(STerrainVertex), STerrainVertex::dwFVF,
 D3DUSAGE_WRITEONLY, D3DPOOL_DEFAULT))
 {
 // Fehler!
 return TB_ERROR;
}


// Rückruffunktion für die Vertexposition

 tbVector3 PositionProc(tbVector3 v);
{

float randomValue = rand()%1+1; //Randomfunktion für die Bestimmung der Höhe!

fHeight = (sinf(v.x * 0.2f +randomValue * 3.0f) * cosf(v.z * 0.2f + randomValue * 3.0f)) *
sinf(randomValue + v.x * 0.1f + v.z * 0.1f) * 2.0f +
sinf(randomValue) * 0.5f;

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

C-/C++-Quelltext

/*
**  BREAKANOID
**  ==========
**
**  Game.cpp
**  --------
**  Das Spiel
*/
// math um PI nutzen zu können. Wichtig für die Default-Kameraeinstellungen.
#define _USE_MATH_DEFINES
#include <math.h>
#include "Breakanoid.h"


struct STerrainVertex
{
    tbVector3           vPosition;  // Position
    tbVector3           vNormal;    // Normalenvektor
    tbVector2           vTexture;   // 2D-Texturkoordinaten
    static const DWORD  dwFVF;      // Vertexformat
}; 
const DWORD STerrainVertex::dwFVF = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1;

// ******************************************************************

// Initialisierung des Terrains
tbResult CTerrain::InitTerrain()
{
 float fHeight;
 STerrainVertex Vertex;
 int iNumVertices;
 int iNumIndices;
 WORD wIndex;


 // Vertex- und Index-Buffer erstellen. 8 Vertizes, 36 Indizes.
 // Der Vertex-Buffer soll dynamisch sein.
 // Die Anzahl der benötigten Vertizes ist die Auflösung zum Quadrat.
 iNumVertices = m_iResolution * m_iResolution;

 // Statischen Vertex-Buffer erstellen
 m_vbTerrainVB = new tbVertexBuffer;
 if(m_vbTerrainVB->Init(iNumVertices * sizeof(STerrainVertex), sizeof(STerrainVertex), STerrainVertex::dwFVF,
 D3DUSAGE_WRITEONLY, D3DPOOL_DEFAULT))
 {
 // Fehler!
 return TB_ERROR;
}
;

// Rückruffunktion für die Vertexposition

 tbVector3 PositionProc(tbVector3 v)
{
float fHeight;
float randomValue = rand()%1+1; //Randomfunktion für die Bestimmung der Höhe!

fHeight = (sinf(v.x * 0.2f +randomValue * 3.0f) * cosf(v.z * 0.2f + randomValue * 3.0f)) *
sinf(randomValue + v.x * 0.1f + v.z * 0.1f) * 2.0f +
sinf(randomValue) * 0.5f;

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

//Die Funktion rufste eben bei der Initialisierung der Vertices so auf:
int y; 
y = fHeight;

for(v.x=0;v.x<m_iResolution;v.x++)
for(v.z=0;v.z<m_iResolution;v.z++)
{
m_fBitmap[v.x*y] = PositionProc(v.x, v.z);
}
 // ******************************************************************

// Rückruffunktion für den Vertexnormalenvektor
tbVector3 NormalProc(tbVector3 v)
{
    tbVector3 m;

    // Steigung berechnen
    m.x = (PositionProc(v + tbVector3(0.01f, 0.0f, 0.0f)).y - PositionProc(v).y) / 0.01f;
    m.z = (PositionProc(v + tbVector3(0.0f, 0.0f, 0.01f)).y - PositionProc(v).y) / 0.01f;

    // In Normalenvektor umwandeln
    return tbVector3Cross(tbVector3Normalize(tbVector3(1.0f, m.x, 0.0f)),
                          tbVector3Normalize(tbVector3(0.0f, m.z, 1.0f)));
}

// ******************************************************************
// Rückruffunktion für die Texturkoordinaten
tbVector2 TextureProc(tbVector3 v)
{
    return tbVector2(v.x * 0.01f + sinf(0 * 0.1f),
                    v.z * 0.01f + cosf(0 * 0.1f));
}

// ******************************************************************
 // Jeden Vertex durchgehen
 for(WORD x = 0; x < m_iResolution; x++)
 {
 for(WORD y = 0; y < m_iResolution; y++)
 {
 // Die Höhe ergibt sich entsprechend des gespeicherten Wertes aus der Bitmap
 fHeight = m_fBitmap[y * m_iResolution + x];
 // Den Vertex generieren. Dazu wird die Position des Vertex berechnet
 // und dann als Parameter für die verschiedenen Rückruffunktionen verwendet.
 Vertex.vPosition.x = ((float)(x) / (float)(m_iResolution - 1) - 0.5f) * m_isize;
 Vertex.vPosition.y = fHeight;
 Vertex.vPosition.z = ((float)(-y) / (float)(m_iResolution - 1) + 0.5f) * m_isize;
 //
 // Rückruffunktion + Funktion zur Bestimmung der Höhe fehlt und muss selber geschrieben werden!
 tbVector3 vPosition;
 Vertex.vPosition = PositionProc(vPosition); //Funktion muss noch umgeschrieben werden zur Höhenbestimmung.
 Vertex.vNormal = tbVector3Cross(tbVector3Normalize(tbVector3(1.0f, ((Vertex.vPosition + tbVector3(0.01f, 0.0f, 0.0f)).y - Vertex.vPosition.y) / 0.01f, 0.0f)),
 tbVector3Normalize(tbVector3(0.0f, ((Vertex.vPosition + tbVector3(0.01f, 0.0f, 0.0f)).y - Vertex.vPosition.y) / 0.01f, 1.0f)));
 Vertex.vTexture = tbVector2(Vertex.vPosition.x *0.05f ,Vertex.vPosition.z*0.05f );

 // Den Vertex setzen
 m_vbTerrainVB->SetVertex(y * m_iResolution + x, &Vertex);
 }