spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include <Windows.h>
#include <TriBase.h>
#include <math.h>
#include "..\\..\\Allgemeines\\InitWindow.h"
#include "..\\..\\Allgemeines\\Direct3DEnum.h"
#include "..\\..\\Allgemeines\\InitDirect3D.h"
#include "Resource.h"
#include <iostream>
using namespace std;




struct SVertex
{
    tbVector3   vPosition;  //Vertex Coord
    DWORD       dwColor;    //Vertex Farbe

    static const DWORD dwFVF;//nur zur übersicht

    tbVector2 vTexture;     //Für die UV-TexturKoordinaten


};

struct STriangle
{
    tbVector3 vPosition;
    tbVector3 vVelocity;
    tbVector3 vRotation;
    tbVector3 vRotVelocity;
    float     fSize;
    SVertex   aVertex[3];
};


//globale Variablen
float g_fTime;

SDirect3DParameters Direct3DParameters;
PDIRECT3DTEXTURE9   g_pTexture;
const int g_iNumTriangles = 1024;



STriangle g_aTriangle[g_iNumTriangles];//bezug auf die struktur svertex

const DWORD SVertex::dwFVF = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1;

tbResult InitScene()
{
    HRESULT hResult;

    if(FAILED(hResult = g_pD3DDevice->SetFVF(SVertex::dwFVF)))
    {
        TB_ERROR_DIRECTX("g_pD3DDevice->SetFVF", hResult, TB_ERROR);
    }

    g_pD3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE);//Beleuchtung aus
    g_pD3DDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);//Füllung
    g_pD3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); //Culling aus
    g_pD3DDevice->SetRenderState(D3DRS_DITHERENABLE, TRUE);     //Dithering für bessere Farbverläufe


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

    //Projektionsmatrix erzrugen

    tbMatrix mProjection = tbMatrixProjection(TB_DEG_TO_RAD(90.0f), fAspect, 0.0f, 100.0f);

    //und schliesslich einsetzen

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



    for(int iTri = 0; iTri < g_iNumTriangles; iTri++)
    {
        g_aTriangle[iTri].vPosition = tbVector3(0.0f, 0.0f, 50.0f);

        g_aTriangle[iTri].vVelocity = tbVector3Random() * tbFloatRandom(0.1f, 5.0f);

        g_aTriangle[iTri].vRotation = tbVector3(0.0f, 0.0f, 0.0f);

        g_aTriangle[iTri].vRotation.x = tbFloatRandom(-0.1f, 1.0f);
        g_aTriangle[iTri].vRotation.y = tbFloatRandom(-0.1f, 1.0f);
        g_aTriangle[iTri].vRotation.z = tbFloatRandom(-0.1f, 1.0f);

        g_aTriangle[iTri].fSize = tbFloatRandom(1.0f, 5.0f);

        for(int iVertex=0; iVertex<3; iVertex++)
        {

            g_aTriangle[iTri].aVertex[iVertex].vPosition = tbVector3Random();
            g_aTriangle[iTri].aVertex[iVertex].dwColor = tbColor(tbFloatRandom(0.0f, 1.0f),
                                                                 tbFloatRandom(0.5f, 1.0f),
                                                                 tbFloatRandom(0.0f, 1.0f));

            g_aTriangle[iTri].aVertex[iVertex].vTexture.u = tbFloatRandom(-1.0f, 2.0f);
            g_aTriangle[iTri].aVertex[iVertex].vTexture.v = tbFloatRandom(-1.0f, 2.0f);


        }
    }


    //Textur laden
    if(FAILED(hResult = D3DXCreateTextureFromFileEx(g_pD3DDevice,
                                                    "Texture.bmp",
                                                    D3DX_DEFAULT,
                                                    D3DX_DEFAULT,
                                                    D3DX_DEFAULT,
                                                    0,
                                                    D3DFMT_UNKNOWN,
                                                    D3DPOOL_MANAGED,
                                                    D3DX_FILTER_NONE,
                                                    D3DX_DEFAULT,
                                                    0,
                                                    NULL,
                                                    NULL,
                                                    &g_pTexture)))
    {
        //Fehler
        TB_ERROR_DIRECTX("CreateTextureFromFileEx", hResult, TB_ERROR);

    }

    g_pD3DDevice->SetTexture(0, g_pTexture);



    
    return TB_OK;
}


tbResult Render(float fNumSecsPassed)
{

    HRESULT hResult;


    tbMatrix mRotation = tbMatrixRotationY(TB_DEG_TO_RAD(g_fTime * 45.0f));
    tbMatrix mTranslation = tbMatrixTranslation(tbVector3(0.0f, 0.0f, 5.0f));

    tbMatrix mWorld = mRotation * mTranslation;
    g_pD3DDevice->SetTransform(D3DTS_WORLD, (D3DMATRIX*) (&mWorld));

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

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

    }


    //Hier wird dann das dreieck gerendert
    //Szene beginnen
    g_pD3DDevice->BeginScene();

    if((int) (g_fTime/3.0f) % 3 == 0)
    {
        //bilinear mit mip
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
        SetWindowText(g_hWindow, "min: lin, mag: lin, mip: lin");
    }
    else if((int) (g_fTime/3.0f) % 3 == 2)
    {
        //playstation efffect
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
        SetWindowText(g_hWindow, "playstation");
    }
    else
    {
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MAXANISOTROPY, 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_NONE);
        SetWindowText(g_hWindow, "min: anisotropic , mip: none");
    }





    //################################################### D3DPT ändern
    

    //Szene beenden
    g_pD3DDevice->EndScene();

    //Bildpuffer wird sichtbar
    g_pD3DDevice->Present(NULL, NULL, NULL, NULL);





    return TB_OK; //das gleiche wie return 0, Makro von der enum tbresult

}

tbResult Move(float fNumSecsPassed)
{
    g_fTime = g_fTime + fNumSecsPassed;

    if(GetAsyncKeyState(VK_SPACE))
    {
        //Leertaste gedrückt;
        fNumSecsPassed = 0.0f;
    }


    float fDistance;
    for(int iTriangle = 0; iTriangle  < g_iNumTriangles; iTriangle++)
    {
        g_aTriangle[iTriangle].vPosition += g_aTriangle[iTriangle].vVelocity * fNumSecsPassed;
        g_aTriangle[iTriangle].vRotation += g_aTriangle[iTriangle].vRotVelocity * fNumSecsPassed;

        fDistance = tbVector3Length(g_aTriangle[iTriangle].vPosition);

        if(fDistance > 100.0f)
        {
            g_aTriangle[iTriangle].vVelocity = -1.0f;

        }

    }


    return TB_OK;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, char* pcCmdLine, int iShowCmd)
{
    
    //initialisieren
    tbInit();

    //parameter abfrage
    
    tbResult Result = GetDirect3DParameters(&Direct3DParameters);
    if(Result == TB_ERROR)
    {
        MessageBoxA(NULL, "Fehler beim Abzählen!!!", "Fehler", MB_OK);

        tbExit();
        return 1;

    }
    else if(Result == TB_CANCELED)//vom benutzer abgebrochen
    {
        tbExit();
        return 0;
    }
    if(InitWindow(Direct3DParameters.VideoMode.Width,
                    Direct3DParameters.VideoMode.Height,
                    "Beispiel", LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON1))))
    {
        MessageBoxA(NULL, "Fehler beim erstellen des Fensters", "Failure", MB_OK);

        tbExit();
        return 1;
    }

    if(InitDirect3D(&Direct3DParameters, g_hWindow))
    {
        MessageBoxA(g_hWindow, "Fehler beim Initialisieren von D3D", "Failure", MB_OK);

        ExitWindow();
        tbExit();
        return 1;
    }

    InitScene();
    tbDoMessageLoop(Render, Move);

    
    ExitDirect3D();
    ExitWindow();

    tbExit();

    return 0;
}