spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// Shader

// ===================

// 


#include <Windows.h>
#include <TriBase.h>
#include <math.h>
#include "InitWindow.h"
#include "Direct3DEnum.h"
#include "InitDirect3D.h"
#include "Resource.h"


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

//Globale Variablen


SDirect3DParameters g_Direct3DParameters;   // Direct3D-Parameter

float               g_fTime  = 0.0f;        // Zeitzähler

LPD3DXEFFECT        g_pEffect = NULL;       // Der Effekt

PDIRECT3DTEXTURE9   g_pTexture = NULL;      // Die Textur

LPD3DXMESH          g_pModel = NULL;        // Das Modell




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

//Render Funktion

tbResult Render(float fNumSecsPassed)
{
    //Variablen

    HRESULT     hResult;
    tbMatrix    mTranslation;
    tbMatrix    mWorld;
    tbMatrix    mCamera;
    tbMatrix    mWorldView;

    D3DLIGHT9   mLight;
    D3DMATERIAL9 mMaterial;

    //Lichteigenschaften füllen

    mLight.Type     = D3DLIGHT_POINT;
    mLight.Position = tbVector3(0.0f, 0.0f, 0.0f);
    mLight.Diffuse  = tbColor(1.0f, 1.0f, 1.0f);
    mLight.Ambient  = tbColor(1.0f, 1.0f, 1.0f);

    //Materialeigenschaften füllen

    mMaterial.Diffuse = tbColor(1.0f, 1.0f, 1.0f);
    mMaterial.Emissive = tbColor(1.0f, 1.0f, 1.0f);
    g_pD3DDevice->SetMaterial(&mMaterial);

    //Licht setzen

    g_pD3DDevice->SetLight(0, &mLight);

    //Das Bildseitenverhältnis berechnen

    float fAspect = (float)(g_Direct3DParameters.VideoMode.Width)
                   /(float)(g_Direct3DParameters.VideoMode.Height);



    //Die Projektionsmatrix erzeugen

    tbMatrix mProjection = tbMatrixProjection(TB_DEG_TO_RAD(90.0f),   //Sichtverhältnis 90°

                                              fAspect,                //Bildseitenverhältnis

                                              0.1f,                   //Nahe  Clipping-Ebene

                                              100.0f);                //Ferne Clipping-Ebene








    //Den Bildpuffer und den Z-Buffer leeren

    if(FAILED(hResult = g_pD3DDevice->Clear(0, NULL,
                                            D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
                                            D3DCOLOR_XRGB(0, 0, 0),
                                            1.0f, 0)))
    {
        //Fehler beim leeren

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

    //Szene beginnen

    g_pD3DDevice->BeginScene();



    //Kamermatrix

    mCamera = tbMatrixCamera(tbVector3(0.0f, 0.0f, 0.0f), tbVector3(0.0f, 0.0f, 1.0f), tbVector3(0.0f, 1.0f, 0.0f));

    //Translationsmatrix

    mTranslation = tbMatrixTranslation(tbVector3(0.0f, 0.0f, 60.0f));

    //Projektionsmatrix setzen

    g_pD3DDevice->SetTransform(D3DTS_PROJECTION, (D3DMATRIX*)(&mProjection));
    //Kameramatrix setzen

    g_pD3DDevice->SetTransform(D3DTS_VIEW, (D3DXMATRIX*)(&mCamera));
    //Weltmatrix setzen

    g_pD3DDevice->SetTransform(D3DTS_WORLD, (D3DMATRIX*)(&mTranslation));


    //WorldView Matrix berechnen

    mWorldView = mCamera * mTranslation;


    //Matrizen an Shader übergeben

    g_pEffect->SetMatrix("WorldView", (D3DXMATRIX*)(&mWorldView));
    g_pEffect->SetMatrix("Projection", (D3DXMATRIX*)(&mProjection));


    unsigned int uiNumPasses;
    g_pEffect->Begin(&uiNumPasses, 0);

    // Für jeden Durchgang...

    for(unsigned int uiPass = 0; uiPass < uiNumPasses; uiPass++)
    {
        // Einstellungen aktivieren

        g_pEffect->BeginPass(uiPass);

        // Modell rendern

        g_pModel->DrawSubset(0);


        g_pEffect->EndPass();
    }


    g_pEffect->End();


    //Szene beenden

    g_pD3DDevice->EndScene();

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

    g_pD3DDevice->Present(NULL, NULL, NULL, NULL);


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

//Move Funktion

tbResult Move(float fNumSecsPassed)
{

    g_fTime += fNumSecsPassed;


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

//Herunterfahren der Szene

tbResult ExitScene()
{
    return TB_OK;
}
// ******************************************************************


// Herunterfahren der Anwendung

tbResult ExitApplication()
{
    // Szene herunterfahren

    ExitScene();

    // Direct3D und Fenster herunterfahren

    ExitDirect3D();
    ExitWindow();

    // Engine herunterfahren

    tbExit();

    return TB_OK;
}

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


tbResult InitScene()
{
    HRESULT hResult;

    ID3DXBuffer* errors = 0; 

    //Vertexformat setzen - Positions- und Farbübergänge

    if(FAILED(hResult = g_pD3DDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1)))
    {
        //Fehler beim Setzen des Vertexformates

        TB_ERROR_DIRECTX("g_pD3DDevice->SetFVF", hResult, TB_ERROR);
    }


    // Beleuchtung und Culling ausschalten, Dithering aktivieren

    g_pD3DDevice->SetRenderState(D3DRS_LIGHTING, TRUE);
    g_pD3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
    g_pD3DDevice->SetRenderState(D3DRS_DITHERENABLE, TRUE);

        //Maximaler ansitropischer Filter ohne Mip Mapping

        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MAXANISOTROPY,
                g_Direct3DParameters.DeviceCaps.MaxAnisotropy);

        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);


        //Die Textur laden

    if(FAILED(hResult = D3DXCreateTextureFromFileEx(g_pD3DDevice,
                                                    "sun.dds",
                                                    D3DX_DEFAULT,
                                                    D3DX_DEFAULT,
                                                    D3DX_DEFAULT,
                                                    0,
                                                    D3DFMT_UNKNOWN,
                                                    D3DPOOL_MANAGED,
                                                    D3DX_FILTER_TRIANGLE,
                                                    D3DX_DEFAULT,
                                                    0,
                                                    NULL,
                                                    NULL,
                                                    &g_pTexture)))
    {
        //Fehler

        TB_ERROR_DIRECTX("D3DXCreateTextureFromFileEx", hResult, TB_ERROR);
    }

    g_pD3DDevice->SetTexture(0, g_pTexture);


    if(FAILED(D3DXLoadMeshFromX("teapot.x",
                                  D3DXMESH_MANAGED,
                                  g_pD3DDevice,
                                  NULL,
                                  NULL,
                                  NULL,
                                  NULL,
                                  &g_pModel)))
    {
        MessageBox(NULL, "Fehler beim laden des Meshes", "Fehler: ", MB_OK | MB_ICONEXCLAMATION);
    } 


    // Nun laden wir den Effekt. Sein Dateiname ist in der Variablen

    // g_acEffectFilename gespeichert.

    if(FAILED(hResult = D3DXCreateEffectFromFile(g_pD3DDevice,
                                                 "shader.fx",
                                                 NULL,
                                                 NULL,
                                                 0,
                                                 NULL,
                                                 &g_pEffect,
                                                 &errors)))
    {
        // Fehler! Womöglich ein Syntaxfehler in der Effektdatei!

        MessageBox(g_hWindow, "Der Effekt konnte nicht geladen werden!\nMöglicherweise ist er fehlerhaft.",
                   "Fehler", MB_OK | MB_ICONEXCLAMATION);
        TB_ERROR_DIRECTX("D3DXCreateEffectFromFile", hResult, TB_ERROR);
    }


    g_pEffect->SetTechnique("TECHNIQUE T1");
    




    
    
    return TB_OK;


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


// Initialisierungsfunktion

tbResult InitApplication()
{
    tbResult Result;

    // TriBase-Engine initialisieren

    tbInit();

    // Direct3D-Optionen abfragen (vom Benutzer gewählt)

    Result = GetDirect3DParameters(&g_Direct3DParameters);
    if(Result == TB_ERROR)
    {
        // Es trat ein Fehler auf!

        MessageBox(NULL, "Fehler beim Abzählen!", "Fehler",
                   MB_OK | MB_ICONEXCLAMATION);
        return TB_ERROR;
    }
    else if(Result == TB_CANCELED)
    {
        // Der Dialog wurde abgebrochen!

        return TB_CANCELED;
    }

    // Fenster initialisieren. Die Größe hängt vom gewählten

    // Videomodus ab, der in der Parameterstruktur gespeichert ist.

    if(InitWindow(g_Direct3DParameters.VideoMode.Width,
                  g_Direct3DParameters.VideoMode.Height,
                  "Beispielprogramm Nr. 3: Das erste Dreieck",
                  LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON1))))
    {
        // Fehler beim Erstellen des Fensters!

        MessageBox(NULL, "Fehler beim Erstellen des Fensters!",
                   "Fehler", MB_OK | MB_ICONEXCLAMATION);
        return TB_ERROR;
    }

    // Direct3D mit den abgefragten Einstellungen initialisieren

    if(InitDirect3D(&g_Direct3DParameters,
                    g_hWindow))
    {
        // Fehler!

        MessageBox(g_hWindow, "Fehler beim Initialisieren von Direct3D!",
                   "Fehler", MB_OK | MB_ICONEXCLAMATION);
        ExitApplication();
        return TB_ERROR;
    }

    // Szene initialisieren

    if(InitScene())
    {
        // Fehler!

        MessageBox(g_hWindow, "Fehler beim Initialisieren der Szene!",
                   "Fehler", MB_OK | MB_ICONINFORMATION);
        ExitApplication();
        return TB_ERROR;
    }

    // Alles OK!

    return TB_OK;
}

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

// Windows-Hauptfunktion

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

    // Initialisierung

    Result = InitApplication();
    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;
}