spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// AntSim.cpp : Definiert den Einstiegspunkt für die Anwendung.



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

// ******************Präprozessor-Direktiven**************************

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


#define MAX_LOADSTRING 100
#define _CRT_SECURE_NO_DEPRECATE 
#pragma warning(disable:4267 4312 4311)
#include <TriBase.h>
#include <Windows.h>
#include <MMsystem.h>
#include "stdafx.h"
#include "AntSim.h"



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

// ***********************Globale Variablen****************************

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

// Direct3D

PDIRECT3DTEXTURE9       g_pTexture = NULL;              // Die Textur

PDIRECT3DVERTEXBUFFER9  g_pVertexBuffer = NULL;         // Vertex-Buffer

PDIRECT3DINDEXBUFFER9   g_pIndexBuffer = NULL;          // Index-Buffer

LPD3DXMESH              g_pAntMesh       = NULL;        // Der Mesh

D3DMATERIAL9*           g_pMeshMaterials = NULL;        // Oberflächen für den Mesh

LPDIRECT3DTEXTURE9*     g_pMeshTextures  = NULL;        // Texturen des Mesh

DWORD                   g_dwNumMaterials = 0L;          // Anzahl der Mesh-Oberflächen

LPD3DXBUFFER            pD3DXMtrlBuffer;                // Buffer f. Mesh

tbDirect3D&             D3D = tbDirect3D::Instance();

// Eingabegeräte

LPDIRECTINPUT8          g_pDInput = NULL;               // IDirectInput8-Objekt

LPDIRECTINPUTDEVICE8    g_pMouse = NULL;                // Schnittstelle der Maus

DIMOUSESTATE2           MouseState;                     // Mausstatus

BOOL                    *g_pbButtons = NULL;
float                   *g_pfButtons = NULL;

// Kamera

tbVector3               g_vCameraPosition;              // Die Kameraposition

tbVector3               g_vCameraPositionStart;         // Die Anfangs-Kameraposition

float                   g_fCameraAngle = 0.0f;          // Drehwinkel der Kamera

float                   g_fCameraUpDown;                // Nach unten bzw. oben schauen

float                   v_fAnt = 2.0f;                  // Globale Begrenzungsvariable f. Ant-Bewegung

float                   g_fFOV = TB_DEG_TO_RAD(90.0f);  // Sichtfeld


// Allgemeine Objekte/Variablen

float                   g_fTime = 0.0f;                 // Zeitzähler

DWORD                   dw_i=0;                         // Zählvariable

tbConfig                g_Config;

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

// *********************FUNKTIONSBLOCK*******************************

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


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

// Initialisieren der Szene

tbResult InitScene()
{
    HRESULT         hResult;
    D3DXMATERIAL*   D3DxMaterials;

    // Beleuchtung und Culling ausschalten, Dithering aktivieren

    D3D.SetRS(D3DRS_LIGHTING, FALSE);
    D3D.SetRS(D3DRS_CULLMODE, D3DCULL_NONE);
    D3D.SetRS(D3DRS_DITHERENABLE, TRUE);
    D3D.SetRS(D3DRS_ZENABLE, TRUE);
    D3D.SetRS(D3DRS_AMBIENT, 0xff000000);

    // Bilineare Texturfilter mit linearem MIP-Mapping

    D3D.SetSS(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
    D3D.SetSS(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
    D3D.SetSS(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);


    // Mesh aus *.X datei laden

    if(FAILED(hResult = D3DXLoadMeshFromX("ant.x",      // Datei

        D3DXMESH_DYNAMIC,                               // Speicherverwaltung

        D3D.GetDevice(),                                // Direct3D-Device

        NULL,                                           // Umgebungs-Buffer|Unwichtig

        &pD3DXMtrlBuffer,                               // Material-Buffer

        NULL,                                           // Effekt-Buffer|Vorerst unwichtig

        &g_dwNumMaterials,                              // Anzahl der Materialien 

        &g_pAntMesh)))                                  // Pointer auf Mesh

    {
        //Error!

        MessageBox( NULL, "Fehler beim Laden des Mesh!", "Error!",
            MB_OK | MB_ICONEXCLAMATION);
        TB_ERROR_DIRECTX("D3DXLoadMeshFromX", hResult, TB_ERROR);
    }

    // Extrahieren der Materialgrößen und Textur-Namem aus pD3DXMtrlBuffer 

    D3DxMaterials    = (D3DXMATERIAL*)pD3DXMtrlBuffer->GetBufferPointer();
    g_pMeshMaterials = new D3DMATERIAL9[g_dwNumMaterials];
    g_pMeshTextures  = new LPDIRECT3DTEXTURE9[g_dwNumMaterials];

    for( dw_i=0; dw_i < g_dwNumMaterials; dw_i++ )
    {
        // Copy the material

        g_pMeshMaterials[dw_i] = D3DxMaterials[dw_i].MatD3D;

        g_pMeshTextures[dw_i] = NULL;
        if( D3DxMaterials[dw_i].pTextureFilename != NULL && 
            lstrlen(D3DxMaterials[dw_i].pTextureFilename) > 0 )
        {
            // Create the texture

            if( FAILED( hResult=D3DXCreateTextureFromFile(D3D.GetDevice(), 
                D3DxMaterials[dw_i].pTextureFilename, 
                &g_pMeshTextures[dw_i])))
            {
                MessageBox(NULL, "Kann Textur nicht finden!", "Error!", MB_OK | MB_ICONEXCLAMATION);
                TB_ERROR_DIRECTX("D3DXCreateTextureFromFile", hResult, TB_ERROR);
            }
        }
    }
    return TB_OK;
}
// ******************************************************************



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

// Herunterfahren der Szene

tbResult ExitScene()
{
    // Textur deaktivieren und löschen --> TEXTUR NOCH NICHT RELEASED! PROBLEM NOCH LÖSEN!

    D3D.SetTexture(0, NULL);


    // Modelle löschen

    TB_SAFE_RELEASE(g_pAntMesh);

    // Vertex- und Index-Buffer deaktivieren und löschen

    D3D.Exit();
    TB_SAFE_RELEASE(g_pVertexBuffer);
    TB_SAFE_RELEASE(g_pIndexBuffer);

    return TB_OK;
}
// ******************************************************************


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

// Render-Funktion

tbResult Render(float fNumSecsPassed)
{
    HRESULT     hResult;
    tbMatrix    mCamera;
    tbMatrix    mWorld;
    tbMatrix    mProjection;
    g_vCameraPositionStart.x = 1.0f; 
    g_vCameraPositionStart.y = 1.5f;
    g_vCameraPositionStart.z = -1.0f;

    
    // Den Bildpuffer und den Z-Buffer leeren

    //D3D->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, tbColor(0.0f, 0.0f, 0.0f), 1.0f, 0);

    if(FAILED(hResult = D3D->Clear(0, NULL,
                                      D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
                                      tbColor(0.0f, 0.0f, 0.0f),
                                      1.0f,
                                      0)))
    {
        // Fehler beim Leeren!

        TB_ERROR_DIRECTX("m_pD3DDevice->Clear", hResult, TB_STOP);
    }

    // Szene beginnen

    D3D->BeginScene();

    // Die Projektionsmatrix erzeugen und einsetzen.

    // Das geschieht hier einmal pro Bild, weil das Sichtfeld variabel ist.

    mProjection = tbMatrixProjection(g_fFOV,            // Sichtfeld

                                     D3D.GetAspect(),   // Bildseitenverhältnis

                                     0.1f,              // Nahe Clipping-Ebene

                                     500.0f);           // Ferne Clipping-Ebene

    D3D.SetTransform(D3DTS_PROJECTION, mProjection);

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


    // Die Kameramatrix erzeugen und einsetzen.

    // Dafür benötigen wir die Kameraposition, den Blickpunkt der Kamera und

    // die lokale y-Achse der Kamera, die normalerweise (0, 1, 0) ist (es sei denn,

    // die Kamera "rollt").

    mCamera = tbMatrixCamera(g_vCameraPositionStart + g_vCameraPosition,
                             g_vCameraPosition + tbVector3(sinf(g_fCameraAngle),
                                                           0.0f,
                                                           cosf(g_fCameraAngle)),
                             tbVector3(0.0f, 1.0f, 0.0f));
    D3D.SetTransform(D3DTS_VIEW, mCamera);
    
        //ANT1

            // Positionen der Ants

            mWorld = tbMatrixTranslation(tbVector3(0.0f, -2.0f, 0.0f))
                   * tbMatrixIdentity()
                   * tbMatrixTranslation(tbVector3(v_fAnt, v_fAnt, v_fAnt));
            D3D.SetTransform(D3DTS_WORLD, mWorld);
                
            // Für jedes Material wird ein eigener Subset im Mesh angelegt. Rendern mittels Schleife

            for( DWORD i=0; i<g_dwNumMaterials; i++ )
                {
                    // Set the material and texture for this subset

                    D3D->SetMaterial( &g_pMeshMaterials[i] );
                    D3D.SetTexture( 0, g_pMeshTextures[i] );
        
                    // Draw the mesh subset

                    g_pAntMesh->DrawSubset( i );
                }

        //ANT 2

            // Positionen der Ants

            mWorld = tbMatrixTranslation(tbVector3(0.0f, -2.0f, 0.0f))
                   * tbMatrixIdentity()
                   * tbMatrixTranslation(tbVector3(0.0, v_fAnt, 0.0f));
            D3D.SetTransform(D3DTS_WORLD, mWorld);

                
            // Für jedes material wird ein eigener Subset im Mesh angelegt. Rendern mittels Schleife

            for( DWORD i=0; i<g_dwNumMaterials; i++ )
                {
                    // Set the material and texture for this subset

                    D3D->SetMaterial( &g_pMeshMaterials[i] );
                    D3D.SetTexture( 0, g_pMeshTextures[i] );
        
                    // Draw the mesh subset

                    g_pAntMesh->DrawSubset( i );
                }


    // Szene beenden

    D3D->EndScene();

    // Der große Moment: den Bildpuffer sichtbar machen

    D3D.Present();

    return TB_OK;
}
// ******************************************************************


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

// Move-Funktion

tbResult Move(float fNumSecsPassed)
{
    tbVector3       vCameraDirection;   // Kamera-Blickrichtung

    BOOL            b_rMButtonDre;      // Variable f. Rechte Maustaste


    // Zeitzähler erhöhen

    g_fTime += fNumSecsPassed;


    // Wenn der Benutzer die Pfeiltaste nach links oder rechts drückt,

    // wird der Winkel erhöht/verringert. Rotation-Speed = 45°/Sec.

    if(FALSE)   g_fCameraAngle -= 1.0f * fNumSecsPassed;
    if(FALSE)   g_fCameraAngle += 1.0f * fNumSecsPassed;

    // Wenn der Benutzer die Pfeiltaste nach oben oder unten drückt,

    // wird die Kamera vor- bzw. zurückbewegt. Blickrichtung wird zur Kamarapostion addiert, 

    // bzw. subtrahiert. 

    // Blickrichtung wird mit dem Sinus und dem Kosinus des Drehwinkels

    // der Kamera berechnet. Bewegung ist momentan nur auf der xz-Ebene möglich.

    vCameraDirection = tbVector3(sinf(g_fCameraAngle), 0.0f, cosf(g_fCameraAngle));

    // Die Kamera soll sich mit 20 Einheiten pro Sekunde bewegen.

    // Die Blickrichtung ist normalisiert und hat daher die Länge 1.

    if(GetAsyncKeyState(VK_DOWN))   g_vCameraPosition += g_vCameraPositionStart * vCameraDirection * 10.0f * fNumSecsPassed;
    if(GetAsyncKeyState(VK_UP)) g_vCameraPosition -= g_vCameraPositionStart * vCameraDirection * 10.0f * fNumSecsPassed;

    // Abfrage der rechten Maustaste

    if(GetAsyncKeyState(0x02/*Right-MouseButton*/))  b_rMButtonDre = TRUE;
    else                                             b_rMButtonDre = FALSE;

    // Kameraansicht nach links bzw. rechts drehen

    if(    GetAsyncKeyState(0x01/*Left-MouseButton*/)
        && b_rMButtonDre == FALSE
         )
 
    // Kameraansicht nach oben bzw. unten drehen

    if(    GetAsyncKeyState(0x01/*Left-MouseButton*/)
        && b_rMButtonDre == TRUE 
        )   g_fCameraUpDown -= 1.0f * fNumSecsPassed;
    
    if(GetAsyncKeyState(0x01/*Left-MouseButton*/)
        && GetAsyncKeyState(0x02/*Right-MouseButton*/)) g_fCameraUpDown += 1.0f * fNumSecsPassed;

    // Die Tasten "Bild auf" und "Bild ab" verändern das Sichtfeld.

    // So kann man in das Bild "hineinzoomen", mit 15 Grad pro Sekunde.

    if(GetAsyncKeyState(VK_PRIOR)) g_fFOV -= TB_DEG_TO_RAD(15.0f) * fNumSecsPassed;
    if(GetAsyncKeyState(VK_NEXT))  g_fFOV += TB_DEG_TO_RAD(15.0f) * fNumSecsPassed;

    // Das Sichtfeld darf 180° und 0° nicht erreichen.

    if(g_fFOV >= TB_DEG_TO_RAD(180.0f))    g_fFOV = TB_DEG_TO_RAD(179.9f);
    else if(g_fFOV <= TB_DEG_TO_RAD(0.0f)) g_fFOV = TB_DEG_TO_RAD(0.1f);

    //Ameiße bewegen + y-axis

    if(GetAsyncKeyState(0x41/*A-Key)*/)) v_fAnt += 1.0f * fNumSecsPassed;
    if(GetAsyncKeyState(0x42/*B-Key*/)) v_fAnt -= 1.0f * fNumSecsPassed;

    if(v_fAnt >= 3.0f) v_fAnt=1.0f;

    return TB_OK;
}
// ******************************************************************


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

// Herunterfahren der Anwendung

tbResult ExitApplication(void)
{
    // Szene herunterfahren

    ExitScene();

    //DirectInput beenden

    tbDirectInput::Instance().Exit();   

    //Direct3D beenden

    tbDirect3D::Instance().Exit();

    //Die TriBase Engine beenden

    if(tbExit())
    {
        TB_ERROR("Fehler beim beenden der TriBase Engine.", TB_ERROR);
    }

    return TB_OK;

}
// ******************************************************************


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

// Initialisierungsfunktion

tbResult InitApplication(char *WindowTitle)
{

    //Die TriBase Engine initialisieren


    if(tbInit())
    {
        TB_ERROR("Die TriBase Engine konnte nicht initialisiert werden.", TB_ERROR);
    }

    //Konfiguration speichern

    if(tbDoConfigDialog(&g_Config))
    {
        TB_ERROR("Fehler im Konfigurationsdialog.", TB_ERROR);
    }

    //Direct3D initialisieren

    if(tbDirect3D::Instance().Init(&g_Config, WindowTitle, NULL, NULL))
    {
        TB_ERROR("Direct3D konnte nicht initialisiert werden.", TB_ERROR);
    }

    //DirectInput initialisieren

    if(tbDirectInput::Instance().Init())
    {
        //Fehler

        TB_ERROR("DirectInput konnte nicht initialisiert werden!", TB_ERROR);
    }
    //Speicher für Buttons reservieren

    g_pfButtons = new float[tbDirectInput::Instance().GetNumButtons()];
    g_pbButtons = new BOOL[tbDirectInput::Instance().GetNumButtons()];

    return TB_OK;
}
// ******************************************************************




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

// Windows-Hauptfunktion

int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   char* pcCmdLine,
                   int iShowCmd)
{
    tbResult Result;

    // Initialisierung

    Result = InitApplication("AntSim DirectX");
    if(Result == TB_CANCELED) return 0;
    else if(Result)
    {
        MessageBox(NULL, "Fehler beim Initialisieren der Anwendung!",
                   "Fehler", MB_OK | MB_ICONEXCLAMATION);
        return 1;
    };
    
    // Nachrichtenschleife

    tbDoMessageLoop(Render, Move);

    // Herunterfahren

    ExitApplication();

    return 0;
}
// ******************************************************************