spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// Richtungslicht mit der Richtung der Kamera erstellen und aktivieren
    ZeroMemory(&CamLight, sizeof(D3DLIGHT9));
    CamLight.Type = D3DLIGHT_DIRECTIONAL;
    CamLight.Diffuse = tbColor(1.0f, 1.0f, 1.0f);
    CamLight.Specular = tbColor(1.0f, 1.0f, 1.0f);
    CamLight.Direction = vCameraLookAt - vCameraPos;
    D3D->SetLight(0, &CamLight);
    D3D->LightEnable(0, TRUE);

    // Hintergrundbeleuchtung
    D3D.SetRS(D3DRS_AMBIENT, tbColor(1.0f, 1.0f, 1.0f));

C-/C++-Quelltext

// 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);
    }


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

// 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));
    }

C-/C++-Quelltext

// Lädt den Spielzustand
tbResult CGame::Load()
{
// Terrain laden
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //m_terrain = new CTerrain;
    //m_terrain->CreateTerrain();
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

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"




// ******************************************************************
//
//tbResult CTerrain::CreateTerrain(void) {

//return TB_OK;
//}
// Vektor aus dem Terrain generiert wird
// __________________________________________________________________
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;

tbResult CTerrain::CreateTerrain(void) 
{
    //tbWriteToLog("%s","Enter  CTerrain::CreateTerrain");
    m_pTerrainVB = NULL;
    m_pTerrainIB = NULL;

    // g_Config;                    // Konfigurationsstruktur
    g_pWaterTexture = NULL;     // Wassertextur
    g_pWaterEffect = NULL;      // Wassereffekt
    g_pWaterVB = NULL;          // Wasser-Vertex-Buffer
    g_pWaterIB = NULL;          // Wasser-Index-Buffer
    g_iResolution = 64;         // Die Auflösung der Wasseroberfläche
    g_fTime = 0.0f;             // Globaler Zeitzähler


    InitTerrain();
    UpdateWater();
    int vvvv = 0;
    return TB_OK;
}

// ******************************************************************
// Die Move-Funktion
tbResult CTerrain::MoveProc(float fNumSecsPassed)
{
    return TB_OK;
}

// ******************************************************************
// Diese Funktion liefert den Index eines Vertex zurück, der durch
// seine Position im Gitter angegeben wird.
WORD CTerrain::GetVertexIndex(WORD x,
                    WORD y)
{
    return y * g_iResolution + x;
}

// ******************************************************************
// Rückruffunktion für die Vertexposition
tbVector3 CTerrain::PositionProc(tbVector3 v)
{
    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 + g_fTime * 3.0f) * cosf(v.z * 0.2f + g_fTime * 3.0f)) *
            sinf(g_fTime + v.x * 0.1f + v.z * 0.1f) * 2.0f +
              sinf(g_fTime) * 0.5f;
    
    // Positionsvektor liefern
    return tbVector3(v.x, fHeight, v.z);
}

// ******************************************************************
// Rückruffunktion für den Vertexnormalenvektor
tbVector3 CTerrain::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 CTerrain::TextureProc(tbVector3 v)
{
    return tbVector2(v.x * 0.01f + sinf(g_fTime * 0.1f),
                    v.z * 0.01f + cosf(g_fTime * 0.1f));
}

// ******************************************************************
// Diese Funktion aktualisiert die Wasseroberfläche.
tbResult CTerrain::UpdateWater()
{
    // tbWriteToLog("%s","Enter   CTerrain::UpdateWater");
    STerrainVertex  Vertex;
    tbVector3       vPosition;

    // tbWriteToLog("%s","=========Start===========");
    // Jeden Vertex durchgehen
    for(WORD x = 0; x < g_iResolution; x++)
    {
        // tbWriteToLog("%s","=========Start y===========");
        for(WORD y = 0; y < g_iResolution; 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)(g_iResolution - 1) - 0.5f) * 200.0f;
            vPosition.y = 0.0f;
            vPosition.z = ((float)(-y) / (float)(g_iResolution - 1) + 0.5f) * 200.0f;

            // Rückruffunktionen aufrufen
            Vertex.vPosition = PositionProc(vPosition);
            Vertex.vNormal = NormalProc(vPosition);
            Vertex.vTexture = TextureProc(vPosition);

            // Den Vertex setzen
            g_pWaterVB->SetVertex(GetVertexIndex(x, y), &Vertex);
        }
        // tbWriteToLog("%s","=========End y===========");
    }
    // tbWriteToLog("%s","=========End===========");

    // Den Vertex-Buffer aktualisieren
    if(g_pWaterVB->Update()) return TB_ERROR;

    // tbWriteToLog("%s","Exit   CTerrain::UpdateWater");
    return TB_OK;
}
// ******************************************************************
// Die Render-Funktion
tbResult CTerrain::RenderProc()
{
    // tbWriteToLog("%s","Enter   CTerrain::RenderProc");
    tbMatrix    mProjection;
    tbMatrix    mCamera;
    tbMatrix    mWorld;
    tbVector3   vCamera;
    D3DLIGHT9   CamLight;
    int         iNumPasses;
    
    // Die Szene beginnen
    tbDirect3D& D3D = tbDirect3D::Instance();
    //D3D->BeginScene();
    // ------------------------------------------------------------------
    
    
    // tbMatrixProjection(sichtfeld, bildseitenverhältnis, nahe clippingebene, entfernte clippingebene)
    D3D.SetTransform(D3DTS_PROJECTION, tbMatrixProjection(TB_DEG_TO_RAD(90.0f), D3D.GetAspect(), 0.1f, 100.0f));

    // kameramatrix
    D3D.SetTransform(D3DTS_VIEW, tbMatrixCamera(tbVector3(0.0f, 10.0f, -10.0f), tbVector3(0.0f, 0.0f, 0.0f), tbVector3(0.0f, 1.0f, 0.0f)));
    
    // Richtungslicht mit der Richtung der Kamera erstellen und aktivieren
    ZeroMemory(&CamLight, sizeof(D3DLIGHT9));
    CamLight.Type = D3DLIGHT_DIRECTIONAL;
    CamLight.Diffuse = tbColor(1.0f, 1.0f, 1.0f);
    CamLight.Specular = tbColor(1.0f, 1.0f, 1.0f);
    CamLight.Direction = tbVector3(0.0f, 0.0f, 0.0f) - tbVector3(0.0f, 10.0f, -10.0f);
    D3D->SetLight(0, &CamLight);
    D3D->LightEnable(0, TRUE);
    
    // ------------------------------------------------------------------

    // Weltmatrix zurücksetzen
    D3D.SetTransform(D3DTS_WORLD, tbMatrixIdentity());

    // Texturen setzen
    D3D.SetTexture(0, g_pWaterTexture);
    // D3D.SetTexture(1, g_pEnvMap);

    // Datenquellen und Vertexformat setzen
    D3D->SetStreamSource(0, g_pWaterVB->GetVB(), 0, sizeof(STerrainVertex));
    D3D->SetIndices(g_pWaterIB->GetIB());
    D3D.SetFVF(STerrainVertex::dwFVF);

    // Zeichnen!    
    iNumPasses = g_pWaterEffect->Begin();
    for(int iPass = 0; iPass < iNumPasses; iPass++)
    {
        g_pWaterEffect->Pass(iPass);
        D3D->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0,
                                g_iResolution * g_iResolution, 0,
                                  (g_iResolution - 1) * (g_iResolution - 1) * 2);
    }

    g_pWaterEffect->End();
    
    // ------------------------------------------------------------------

    return TB_OK;
}

// ******************************************************************
// Initialisierung der Terrainfläche
tbResult CTerrain::InitTerrain()
{
    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 = g_iResolution * g_iResolution;

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

    // Index-Buffer erstellen.
    // Die Anzahl der Vierecke ist g_iNumVertices minus 1 zum Quadrat.
    // Wir brauchen 6 Indizes pro Viereck.
    iNumIndices = (g_iResolution - 1) * (g_iResolution - 1) * 6;

    // Puffer erstellen mit 16 Bits pro Index (WORD)
    g_pWaterIB = new tbIndexBuffer;
    if(g_pWaterIB->Init(iNumIndices * sizeof(WORD), sizeof(WORD), D3DFMT_INDEX16))
    {
        // Fehler!
        return TB_ERROR;
    }

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

    // Den Index-Buffer können wir jetzt schon initialisieren, denn er ist
    // ja statisch. Dazu gehen wir alle Vertizes (außer denen, die am Rand liegen)
    // durch und erstellen ein Viereck, bei denen der Vertex links oben liegt.
    for(int x = 0; x < g_iResolution - 1; x++)
    {
        for(int y = 0; y < g_iResolution - 1; y++)
        {
            // Erstes Dreieck erzeugen, bei dem der Vertex (x, y) links oben ist
            // (x,y) _______ (x+1,y)
            //   1   |  /   2
            //      |   /
            //      |   /
            //      |  /
            //      | /
            //      |/
            //  (x,y+1)
            //  3
            wIndex = GetVertexIndex(x, y);      g_pWaterIB->AddIndex(&wIndex);
            wIndex = GetVertexIndex(x + 1, y);  g_pWaterIB->AddIndex(&wIndex);
            wIndex = GetVertexIndex(x, y + 1);  g_pWaterIB->AddIndex(&wIndex);

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

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

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

    // Die Textur der Wasseroberfläche laden
    
    g_pWaterTexture = tbTextureManager::Instance().GetTexture("Terrain0.jpg");
    if(g_pWaterTexture == NULL) return TB_ERROR;

    // Effekt laden
    
    g_pWaterEffect = new tbEffect;
    if(g_pWaterEffect == NULL) return TB_ERROR;
    if(g_pWaterEffect->Init("Water.fx")) return TB_ERROR;
    

    return TB_OK;
}


// ******************************************************************
// Aufräumen
tbResult CTerrain::CleanUp()
{
    // Alles löschen
// **   tbDirect3D::Instance().Exit();
// **   tbTextureManager::Instance().Exit();
    TB_SAFE_DELETE(g_pWaterEffect);
    TB_SAFE_DELETE(g_pWaterVB);
    TB_SAFE_DELETE(g_pWaterIB);

    // Die TriBase-Engine herunterfahren
// **   tbExit();

    return TB_OK;
}


// __________________________________________________________________
// Initialisiert den Spielzustand
tbResult CGame::Init()
{
    // Laden...
    if(Load()) TB_ERROR("Fehler beim Laden des Spielzustands!", TB_ERROR);

    // Ersten Level initialisieren
    InitLevel();

    // Default Kameraposition, PI um die Kamera einmal um 180° zu drehen und "hinter" der Kugel zu starten:
    relativeCamera = tbVector3((float)M_PI, 10.0f, (float)M_PI);

    return TB_OK;
}

// __________________________________________________________________
// Fährt den Spielzustand herunter
tbResult CGame::Exit()
{
    // Entladen...
    Unload();

    return TB_OK;
}

// __________________________________________________________________
// Lädt den Spielzustand
tbResult CGame::Load()
{
// Terrain laden
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    
    m_terrain = new CTerrain;
    m_terrain->CreateTerrain();
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


// Ballmodell laden
    m_pBallModel = new tbModel;
    if(m_pBallModel->Init("Data\\Ball.tbm", "Data\\")) TB_ERROR("Fehler beim Laden des Ballmodells!", TB_ERROR);

    return TB_OK;
}

// __________________________________________________________________
// Entlädt den Spielzustand
tbResult CGame::Unload()
{
    // Alle Modelle freigeben
    TB_SAFE_DELETE(m_pLevelModel);
    TB_SAFE_DELETE(m_pBallModel);
    //TB_SAFE_DELETE(m_terrain);
    return TB_OK;
}

// __________________________________________________________________
// Bewegt den Spielzustand
tbResult CGame::Move(float fTime)
{
    // P oder Pause hält das Spiel an oder setzt es fort.
    if(g_pbButtons[TB_KEY_P] || g_pbButtons[TB_KEY_PAUSE])
    {
        m_bPaused = !m_bPaused;
        tbDelay(100);
    }

    // Wenn das Spiel pausiert, gibt es nichts mehr zu tun.
    if(m_bPaused) return TB_OK;


    // Das "Kleben" abschalten - wir haben keinen Schläger mehr, also haben wir auch keine klebenden Bälle mehr.
    Ball.m_bGrabbed = FALSE;

    Ball.m_vVelocity.x += g_pfButtons[TB_KEY_RIGHT] * 20.0f * fTime;
    Ball.m_vVelocity.x -= g_pfButtons[TB_KEY_LEFT] * 20.0f * fTime;
    Ball.m_vVelocity.z += g_pfButtons[TB_KEY_UP] * 20.0f * fTime;
    Ball.m_vVelocity.z -= g_pfButtons[TB_KEY_DOWN] * 20.0f * fTime;
    
    
    /* Die Bewegung abschwächen (80% Verlust pro Sekunde)
     Grund: Die Kontrolle über den Ball ist stark erschwert, da der Bewegungsvektor durch die normalen Funktionen der Klasse CBall sehr stark beeinflusst wird.
     Deswegen schwächen wir die Bewegung einfach insgesamt ab.
     Dies ermöglicht zugleich auch bessere Kontrolle wenn viele Bälle gleichzeitig auf dem Feld sind. */

    Ball.m_vVelocity.x *= powf(0.2f, fTime);
    Ball.m_vVelocity.z *= powf(0.2f, fTime);
    Ball.m_vVelocity.y *= powf(0.2f, fTime);

    Ball.Move(fTime);



    // Kameraposition auf Wunsch verändern.
    // Drehen um die Kugel
    relativeCamera.x += g_pfButtons[TB_KEY_D] * 1.0f * fTime;
    relativeCamera.z += g_pfButtons[TB_KEY_D] * 1.0f * fTime;

    relativeCamera.x -= g_pfButtons[TB_KEY_A] * 1.0f * fTime;
    relativeCamera.z -= g_pfButtons[TB_KEY_A] * 1.0f * fTime;

    // Höhe Verändern
    relativeCamera.y += g_pfButtons[TB_KEY_S] * 10.0f * fTime;
    relativeCamera.y -= g_pfButtons[TB_KEY_W] * 10.0f * fTime;

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

    // Wenn die Escape-Taste gedrückt wird, geht's zurück ins Hauptmenü.
    if(g_pbButtons[TB_KEY_ESCAPE]) g_pBreakanoid->SetGameState(GS_INTRO);

    return TB_OK;
}

// __________________________________________________________________


    // Rendert den Spielzustand
    tbResult CGame::Render(float fTime)
    {
    tbMatrix    mCamera;
    tbMatrix    mProjection;
    tbVector3   vCameraPos;
    tbVector3   vCameraLookAt;
    D3DLIGHT9   CamLight;
    tbVector3   vPosition;
    float       y;

    // Puffer leeren und Szene beginnen
    tbDirect3D& D3D = tbDirect3D::Instance();
    D3D->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, tbColor(0.0f, 0.0f, 0.0f), 1.0f, 0);
    D3D->BeginScene();

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

    // Die Kameraposition:
    vCameraPos.x = Ball.GetAbsPosition().x + 10.0f*sinf(relativeCamera.x);
    vCameraPos.y = Ball.GetAbsPosition().y + relativeCamera.y;
    vCameraPos.z = Ball.GetAbsPosition().z + 10.0f*cosf(relativeCamera.z);

    // Fokus der Kamera auf den Ball
    vCameraLookAt = Ball.GetAbsPosition();

    // Kameramatrix erstellen und aktivieren
    mCamera = tbMatrixCamera(vCameraPos, vCameraLookAt);
    D3D.SetTransform(D3DTS_VIEW, mCamera);

    // Projektionsmatrix erstellen und aktivieren
    mProjection = tbMatrixProjection(TB_DEG_TO_RAD(70.0f),
                                    D3D.GetAspect(),
                                     0.1f, 500.0f);
    D3D.SetTransform(D3DTS_PROJECTION, mProjection);

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

    // Richtungslicht mit der Richtung der Kamera erstellen und aktivieren
    ZeroMemory(&CamLight, sizeof(D3DLIGHT9));
    CamLight.Type = D3DLIGHT_DIRECTIONAL;
    CamLight.Diffuse = tbColor(1.0f, 1.0f, 1.0f);
    CamLight.Specular = tbColor(1.0f, 1.0f, 1.0f);
    CamLight.Direction = vCameraLookAt - vCameraPos;
    D3D->SetLight(0, &CamLight);
    D3D->LightEnable(0, TRUE);

    // Hintergrundbeleuchtung
    D3D.SetRS(D3DRS_AMBIENT, tbColor(1.0f, 1.0f, 1.0f));

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

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

    // Höhe des Balls im Terrain ausrechnen
    //y = getHeightAtPosition(Ball.GetAbsPosition().x, Ball.GetAbsPosition().z);
    //Ball.m_vPosition.y = y;

    // Ball rendern
    Ball.Render(fTime);

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

    // Wenn das Spiel pausiert, wird "Pause" in der Bildmitte angezeigt.
    if(m_bPaused)
    {
        g_pBreakanoid->m_pFont1->Begin();
        g_pBreakanoid->m_pFont1->DrawText(tbVector2(0.5f, 0.5f), "Pause",
                                        TB_FF_ALIGN_HCENTER | TB_FF_ALIGN_VCENTER | TB_FF_RELATIVE | TB_FF_RELATIVESCALING);
        g_pBreakanoid->m_pFont1->End();
    }

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

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

    // Szene beenden
    D3D->EndScene();

    return TB_OK;
}

// __________________________________________________________________
// Initialisiert einen Level
tbResult CGame::InitLevel()
{
        
    // Sound für neuen Level abspielen
    //g_pBreakanoid->m_apSound[2]->PlayNextBuffer();

    // Neuen Level setzen
    m_bPaused = FALSE;
    m_bGameOver = FALSE;

    // Einen Ball erstellen
    CreateBall(tbVector3(200.0f, 10.0f, 200.0f), tbVector3(0.0f), FALSE);

    return TB_OK;
}

// __________________________________________________________________
// Erstellt einen neuen Ball
int CGame::CreateBall(tbVector3 vPosition,
                      tbVector3 vVelocity,
                      BOOL bGrabbed)
{


    Ball.m_bExists = TRUE;
    Ball.m_pGame = this;
    Ball.m_bGrabbed = bGrabbed;
    Ball.m_vPosition = vPosition;
    Ball.m_vVelocity = vVelocity;

    return 0;
}

// __________________________________________________________________