Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!
Werbeanzeige
Zitat
Der RCCSWU (RandomCamelCaseSomtimesWithUndersquare) Stil bricht auch mal mit den veraltet strukturierten Denkmustern und erlaubt dem Entwickler seine Kreativität zu entfalten.
![]() |
C-/C++-Quelltext |
1 2 3 4 5 6 7 8 9 10 |
// Windows-Hauptfunktion int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, char* pcCommandLine, int iShowCommand) { // TriBase-Engine initialisieren tbInit(); ... |
![]() |
C-/C++-Quelltext |
1 2 3 4 5 6 7 8 9 10 11 12 |
// 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 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
// 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 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
// 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); } |
Wieso ist die Einrückung bei der Terrainklasse so komisch? Das ist beim lesen sehr verwirrend. Außerdem fehlt da am Ende ein Semikolon (Zeile 41), was schon einige Fehler beheben dürfte.
![]() |
C-/C++-Quelltext |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 |
/* ** 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); } |
![]() |
C-/C++-Quelltext |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 |
/* ** 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); } |
Werbeanzeige