spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

//-----------------------------------------------------------------------------------------------------------------
// Initialisiert ein Objekt
void c_eglWaterSurface::Initialize(char* cpObjectName,int nResolution,int nSize)
{
    // Logeintrag machen
    Log.Log(__FILE__,__LINE__,"Ein Watersurface Objekt wird initialisiert .... ");

    HRESULT hResult; // lokale Ergebnisvariable
    
    // Objektauflösung sowie Vertex und Dreiecksanzahl berechnen und speichern
    this->m_nResolution = nResolution;
    this->m_nVertices   = nResolution * nResolution;
    this->m_nTriangles  = ((nResolution - 1) * (nResolution -1)) * 2;
    this->m_nIndices    = this->m_nTriangles * 3;

    // Array erstellen indem die Indexes gespeichert werden können
    unsigned short* ausIndexes = new unsigned short[this->m_nIndices];

    // Indexedaten erstellen
    int nIndexCount = 0;
    
    // X Reihe des Gitters durchgehen
    for(int x = 0; x < nResolution - 1; x++) {
        
        // Y Reihe des Gitters durchgehen
        for(int y = 0; y < nResolution - 1; y++) {
            
            // Erster Index
            ausIndexes[nIndexCount] = this->GetIndexFromXY(x,y);
            nIndexCount += 1;
            // Zweiter Index
            ausIndexes[nIndexCount] = this->GetIndexFromXY(x + 1,y);
            nIndexCount += 1;
            // Dritter Index
            ausIndexes[nIndexCount] = this->GetIndexFromXY(x,y + 1);
            nIndexCount += 1;

            // Vierter Index
            ausIndexes[nIndexCount] = this->GetIndexFromXY(x + 1,y);
            nIndexCount += 1;
            // Fünfter Index
            ausIndexes[nIndexCount] = this->GetIndexFromXY(x + 1,y + 1);
            nIndexCount += 1;
            // Sechster Index
            ausIndexes[nIndexCount] = this->GetIndexFromXY(x,y + 1);
            nIndexCount += 1;
        }
    }

    // Indexbuffer erstellen
    if(FAILED(hResult = g_pD3DD->CreateIndexBuffer(this->m_nIndices * sizeof(unsigned short),D3DUSAGE_WRITEONLY,D3DFMT_INDEX16,D3DPOOL_DEFAULT,&this->m_pIB))) {
        // Fehler !
        Log.DirectXError(__FILE__,__LINE__,hResult,"Fehler beim erstellen des Indexbuffers für ein Wasseroberflächenobjekt -> Objektname: %s", cpObjectName);
        return;
    }

    // Indexbuffer Sperren und Daten hineinkopieren
    void *pIndexData;
    if(FAILED(hResult = this->m_pIB->Lock(0,this->m_nIndices * sizeof(unsigned short),(BYTE**)&pIndexData,0))) {
        // Fehler !
        Log.DirectXError(__FILE__,__LINE__,hResult,"Fehler beim sperren des Indexbuffer eines Wasseroberflächenobjekt -> Objektname: %s",cpObjectName);
        return;
    }

    // Erste 6 Indexes Loggen
    Log.Log(__FILE__,__LINE__,"Index1: %d",ausIndexes[0]);
    Log.Log(__FILE__,__LINE__,"Index2: %d",ausIndexes[1]);
    Log.Log(__FILE__,__LINE__,"Index3: %d",ausIndexes[2]);
    Log.Log(__FILE__,__LINE__,"Index4: %d",ausIndexes[3]);
    Log.Log(__FILE__,__LINE__,"Index5: %d",ausIndexes[4]);
    Log.Log(__FILE__,__LINE__,"Index6: %d",ausIndexes[5]);

    // Daten hineinkopieren
    memcpy(pIndexData,ausIndexes,sizeof(ausIndexes));

    // Indexbuffer entsperren
    this->m_pIB->Unlock();
    
    // Temporäre index Daten löschen
    delete[] ausIndexes;

    // Array mit Vertexdaten anlegen
    s_eglWaterVertex* sVertices = new s_eglWaterVertex[this->m_nVertices];

    // Vertexdaten erstellen
    int nVertexCount    = 0;
    float fSquareStep   = (float)nSize / (float)nResolution;
    float fActStepX     = 0.0f;
    float fActStepY     = 0.0f - ((float)nResolution / 2.0f) * fSquareStep;
    
    // Variablen Loggen
    Log.Log(__FILE__,__LINE__,"SquareStep =  %f, ActStepX = %f, ActStepY = %f, VertexCount = %d",fSquareStep,fActStepX,fActStepY,nVertexCount); 

    // X Reihe des Gitter durchgehen
    for(int y = 0; y < nResolution - 1; y++) {
        // Auf Anfangswert zurücksetzen
        fActStepX = 0 - ((float)nResolution / 2.0f) * fSquareStep;
        // Y Reihe des Gitters durchgehen
        for(int x = 0; x < nResolution; x++) {
    
            // Erster Vertex
            sVertices[nVertexCount].vecPosition = D3DXVECTOR3(fActStepX,0.0f,fActStepY);
            sVertices[nVertexCount].dwColor     = D3DCOLOR_XRGB(  0,  0,255);

            // Step und Vertexzähler erhöhen
            fActStepX       += fSquareStep;
            nVertexCount    += 1;
        }

        // Y Step erhöhen
        fActStepY += fSquareStep;
    }

    // Vertexbuffer erstellen
    if(FAILED(hResult = g_pD3DD->CreateVertexBuffer(4 * sizeof(s_eglWaterVertex),D3DUSAGE_WRITEONLY,D3DFVF_XYZ | D3DFVF_DIFFUSE,D3DPOOL_DEFAULT,&this->m_pVB))) {
        // Fehler !
        Log.DirectXError(__FILE__,__LINE__,hResult,"Fehler beim  erstellen des Vertexbuffers für ein Wasseroberflächenobjekt -> Objektname: %s",cpObjectName);
        return;
    }
    
    // Vertexbuffer sperren
    void* pVertexData;
    if(FAILED(hResult = this->m_pVB->Lock(0,this->m_nVertices * sizeof(s_eglWaterVertex),(BYTE**)&pVertexData,0))) {
        // Fehler !
        Log.DirectXError(__FILE__,__LINE__,hResult,"Fehler beim sperren des Vertexbuffers eines Wasseroberflächenobjekts -> Objektname %s",cpObjectName);
        return;
    }
    // Logeinträge

    // Daten hineinkopieren
    memcpy(pVertexData,sVertices,sizeof(sVertices));

    // Vertexbuffer entsperren
    this->m_pVB->Unlock();

    // Temporäre Vertexdaten löschen
    delete[] sVertices;

    // Eingenschaften speichern und Status ändern
    this->m_cpObjectName = cpObjectName;
    this->m_bInitialized = TRUE;

    // Logentrag machen
    Log.Log(__FILE__,__LINE__,"Das Wasseroberflächenobjekt: %s mit einer Auflösung von: %d und einer Große von: %d wurde <b>erfolgreich</b> initialisiert",cpObjectName,nResolution,nSize);
}

Quellcode

//-----------------------------------------------------------------------------------------------------------------
// Render das Wasseroberflächen Objekt
void c_eglWaterSurface::Render(void)
{
    // Prüfen ob das Objekt initialisiert ist wenn ja Rendern ansonsten Funktion abbrechen
    if(IsInitialized() == FALSE) { return; }

    HRESULT hResult;    // lokale Ergebnissvariable

    // Aktuelle Renderstates speichern
    DWORD dwRenderstates[10];
    g_pD3DD->GetRenderState(D3DRS_LIGHTING,&dwRenderstates[0]);
    
    // Neue Renderstates setzen
    g_pD3DD->SetRenderState(D3DRS_LIGHTING,FALSE);
    g_pD3DD->SetRenderState(D3DRS_FILLMODE,D3DFILL_WIREFRAME);

    // Vertexquelle ( Stream ) setzen
    g_pD3DD->SetStreamSource(0,this->m_pVB,sizeof(s_eglWaterVertex));

    // Indexes setzen
    g_pD3DD->SetIndices(this->m_pIB,0);
    
    // Texturen setzen
    g_pD3DD->SetTexture(0,NULL);

    // VertexShader setzen
    g_pD3DD->SetVertexShader(D3DFVF_XYZ | D3DFVF_DIFFUSE);

    // Transformation setzen
    D3DXMATRIX matWorld;
    D3DXMatrixIdentity(&matWorld);
    g_pD3DD->SetTransform(D3DTS_WORLD,&matWorld);
    
    // Objekt zeichnen
    if(FAILED(hResult = g_pD3DD->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,0,this->m_nVertices,0,this->m_nTriangles))) {
        // Fehler !
        Log.DirectXError(__FILE__,__LINE__,hResult,"Fehler beim zeichnen eines Wasseroberflachen Objekts");
    }

    // Alte Renderstates wieder herstellen
    g_pD3DD->SetRenderState(D3DRS_LIGHTING,dwRenderstates[0]);
    g_pD3DD->SetRenderState(D3DRS_FILLMODE,D3DFILL_SOLID);
}