spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

struct SVertex
{
    tbVector3       vPosition;
    D3DCOLOR    D3D_Color;
};

struct STriangle
{
    tbVector3   vVelocity;          //Geschwindigkeit

    tbVector3   vPosition;          //Position

    tbVector3   vRotation;          //Rotationszustand

    tbVector3   vVelocityRotation;  //Rotation in eine bestimmte Richtung


    float       fSize;              //Größe des Dreiecks

    SVertex     SVertex[3];         //Vertexdaten des Dreiecks

};



const int                   g_iNumTriangles = 1000;
STriangle                   g_aTriangle[g_iNumTriangles];

//**************************    Movefunktion    **************************************************

void move(float fTime)
{
    float fDistance;
    g_fTime = g_fTime + fTime;
    for(int iTriangle = 0; iTriangle < g_iNumTriangles ; iTriangle ++)
    {
        g_aTriangle[iTriangle].vPosition += g_aTriangle[iTriangle].vVelocity         * g_fTime;
        g_aTriangle[iTriangle].vRotation += g_aTriangle[iTriangle].vVelocityRotation * g_fTime;

        // Distanz des Dreiecks zum Beobachter (zum Nullpunkt) berechnen

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

        // Wenn die Distanz größer als 100 ist, soll das Dreieck umkehren.

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


//**************************    Renderfunktion  **************************************************

void render(float fTime)
{
    HRESULT     hResult;
    tbMatrix    mTranslation;   // Translationsmatrix

    tbMatrix    mWorld;         // Vereinende Weltmatrix

    tbMatrix    mRotationX;     // Rotation um die X Achse

    tbMatrix    mRotationY;     // Rotation um die Y Achse

    tbMatrix    mRotationZ;     // Rotation um die Z Achse

    tbMatrix    mScaling;

    

    // Den Bildpuffer und den Z-Buffer leeren

    if(FAILED(hResult = pD3D_Interface->Clear(0,
        NULL,
        D3DCLEAR_TARGET| D3DCLEAR_ZBUFFER,
        D3DCOLOR_XRGB(0, 0, 63),
        1.0f,
        0)))
    {
        // Fehler beim Leeren der Strukturen

        MessageBox(NULL, "Fehler beim Leeren der Puffer!",
            "Fehler", MB_OK | MB_ICONEXCLAMATION);
    }

    // Szene beginnen

    pD3D_Interface->BeginScene();

    for(int iTriangle = 0; iTriangle < g_iNumTriangles; iTriangle++);
    {
        mScaling = tbMatrixScaling(g_aTriangle[iTriangle].fSize);

        mRotationX = tbMatrixRotationX(g_aTriangle[iTriangle].vRotation.x);
        mRotationY = tbMatrixRotationY(g_aTriangle[iTriangle].vRotation.y);
        mRotationZ = tbMatrixRotationZ(g_aTriangle[iTriangle].vRotation.z);

        mTranslation = tbMatrixTranslation(g_aTriangle[iTriangle].vPosition);


        // Beide Matrizen kombinieren und als Weltmatrix einsetzen

        mWorld = mScaling * mRotationX * mRotationY * mRotationZ * mTranslation;
        pD3D_Interface->SetTransform(D3DTS_WORLD,(D3DMATRIX*)(&mWorld));

        // Nun das Dreieck zeichnen

        if(FAILED(hResult = pD3D_Interface->DrawPrimitiveUP(D3DPT_TRIANGLELIST, // Dreiecksliste

            1,                                  // 1 Dreieck

            &g_aTriangle[iTriangle].SVertex,    // Vertexdaten

            sizeof(SVertex))))                  // Vertexgröße

        {
            // Fehler beim Zeichnen!

            MessageBox(NULL, "Fehler beim Zeichnen des Dreiecks!",
                "Fehler", MB_OK | MB_ICONEXCLAMATION);
        }
    }

    // Szene beenden

    pD3D_Interface->EndScene();

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

    pD3D_Interface->Present(NULL, NULL, NULL, NULL);
}
//************************************************************************************************


//**************************    Funktion zu Scenenerstellung    **********************************

bool initScene()
{
    HRESULT     hResult;
    float       fAspectration;

    //Vertexformat registrieren

    if(FAILED(hResult = pD3D_Interface->SetFVF(D3DFVF_XYZ|D3DFVF_DIFFUSE)))
    {
        MessageBox(NULL,"Das Vertexformat konnte nicht gesetzt werden","Fehler bei initScene",MB_OK);
        return (false);
    }

    //Beleuchtung ausschalten, da sie nicht benötigit wird

    //CULLMODE deaktivieren

    //Dithering aktivieren wegen 16Bit-Farbübergang


    hResult =pD3D_Interface->SetRenderState(D3DRS_LIGHTING,FALSE);
    hResult =pD3D_Interface->SetRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
    hResult =pD3D_Interface->SetRenderState(D3DRS_DITHERENABLE,TRUE);

    //Seitenverhältnis ausrechnen

    fAspectration = (float)(SD3DPresentVarialbes.D3D_Register.BackBufferWidth)/
        (float)(SD3DPresentVarialbes.D3D_Register.BackBufferHeight);

    //Projektionsmatrix erstellen

    tbMatrix    mProjketion = tbMatrixProjection(TB_DEG_TO_RAD(90.0f),
        fAspectration,
        0.1f,
        100.0f);

    //Projektionsmatrix setzen

    hResult = pD3D_Interface->SetTransform(D3DTS_PROJECTION,(D3DMATRIX*)(&mProjketion));

    for(int iTriangle = 0; iTriangle < g_iNumTriangles ; iTriangle++)
    {
        //Zufällige Geschwindigkeit festlegen

        g_aTriangle[iTriangle].vVelocity = tbVector3Random() * RandomNumberFloat(0.1f, 5.0f);

        //Position des Dreiecks festlegen

        g_aTriangle[iTriangle].vPosition = tbVector3(0.0f,0.0f,20.0f);          

        //Rotation zuerste stoppen

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

        //Rotationsgeschwindigkeit zufällig wählen


        g_aTriangle[iTriangle].vVelocityRotation.x = RandomNumberFloat(-1.0f, 1.0f);
        g_aTriangle[iTriangle].vVelocityRotation.y = RandomNumberFloat(-1.0f, 1.0f);
        g_aTriangle[iTriangle].vVelocityRotation.z = RandomNumberFloat(-1.0f, 1.0f);


        //Größe des Dreiecks festlegen

        g_aTriangle[iTriangle].fSize = RandomNumberFloat(1.0f, 5.0f);



        //Farben festlegen

        for(int iVertex = 0; iVertex < 3; iVertex++)
        {
            g_aTriangle[iTriangle].SVertex[iVertex].vPosition = tbVector3Random();
            g_aTriangle[iTriangle].SVertex[iVertex].D3D_Color = D3DCOLOR_ARGB(255,RandomNumberInt(0,255),RandomNumberInt(0,255),RandomNumberInt(0,255));
        }
    }


    //Alles hat geklappt

    return (true);
}
//************************************************************************************************