spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

struct Texture2DVertexx
{
    tbVector3 position; // Position des Vertex

    DWORD color;        // Farbe des Vertex

    tbVector2 texture;  // Texturkoordinaten

    DWORD   dwFVF;      // Vertexformat

};



tbResult Render(float fNumSecsPassed)
{
    tbMatrix    mScaling;       // Skalierungsmatrix

    tbMatrix    mRotationX;     // Rotationsmatrix für die x-Achse

    tbMatrix    mRotationY;     // Rotationsmatrix für die y-Achse

    tbMatrix    mRotationZ;     // Rotationsmatrix für die z-Achse

    tbMatrix    mTranslation;   // Translationsmatrix

    tbMatrix    mWorld;         // Vereinende Weltmatrix

    

    Dreieck** dreiecke = aquarium->getDreiecke();

    tbDirect3D& D3D = tbDirect3D::Instance();
    D3D->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0,0,255), 1.0f, 0 );

    D3D->BeginScene();

    // Projektionsmatrix erstellen und einsetzen

    tbMatrix mProjection = tbMatrixProjection(TB_DEG_TO_RAD(90.0f), D3D.GetAspect(), 0.1f, 1000.0f);
    D3D.SetTransform(D3DTS_PROJECTION, mProjection);

    // Kameramatrix

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

    //D3D.SetTransform(D3DTS_VIEW, mCamera);




    // Z-Buffer deaktivieren, Dithering aktivieren

    D3D.SetRS(D3DRS_ZENABLE, FALSE);
    //D3D.SetRS(D3DRS_DITHERENABLE, TRUE);



        // Skalierungsmatrix anhand der Größe des Dreiecks erstellen

        mScaling = tbMatrixScaling(tbVector3(dreiecke[0][0].getSize()));

        // Rotationsmatrizen für das Dreieck erzeugen

        mRotationX = tbMatrixRotationX(dreiecke[0][0].getRotation().x);
        mRotationY = tbMatrixRotationY(dreiecke[0][0].getRotation().y);
        mRotationZ = tbMatrixRotationZ(dreiecke[0][0].getRotation().z);

        // Translationsmatrix

        mTranslation = tbMatrixTranslation(dreiecke[0][0].getPosition());
        
        // Alle Matrizen kombinieren und als Weltmatrix einsetzen

        mWorld = mScaling * mRotationX * mRotationY * mRotationZ * mTranslation;
        D3D.SetTransform(D3DTS_WORLD, mWorld);

        Texture2DVertexx *textureVertizes = dreiecke[0][0].getVertizes();

        Texture2DVertexx textureVertex[] = 
        {
            textureVertizes[0], textureVertizes[1], textureVertizes[2]
        };

        D3D.SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE);

        D3D->DrawPrimitiveUP(D3DPT_TRIANGLELIST,                // Dreiecksliste

                            1,                                                                      // 1 Dreieck

                            textureVertex,                                              // Vertexdaten

                            sizeof(Texture2DVertexx));                      // Vertexgröße

        


    D3D->EndScene();
    
    return TB_OK;
}



tbResult Move(float fNumSecsPassed)
{
    float fDistance;

    // Den Zeitzähler aktualisieren

    g_fTime += fNumSecsPassed;

    Dreieck** dreiecke = aquarium->getDreiecke();

        // Position und Rotation aktualisieren

        dreiecke[0][0].setPosition( dreiecke[0][0].getPosition() + dreiecke[0][0].getVelocity() * fNumSecsPassed );
        dreiecke[0][0].setRotation( dreiecke[0][0].getRotation() + dreiecke[0][0].getRotVelocity() * fNumSecsPassed );

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

        fDistance = tbVector3Length(dreiecke[0][0].getPosition());

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

        if(fDistance > 100.0f) 
            dreiecke[0][0].setVelocity( dreiecke[0][0].getVelocity() * -1.0f);
    }

    return TB_OK;
}

void CreateDreiecke()
{
// Vertizes generieren

        Texture2DVertexx vertizes[3];
        for(int j = 0; j < 3; j++)
        {
            // Position

            tbVector3 position = tbVector3Random();


            // Farbe

            tbColor VertexColor;
            VertexColor.r = tbFloatRandom(0.0f, 1.0f);
            VertexColor.g = tbFloatRandom(0.0f, 1.0f);
            VertexColor.b = tbFloatRandom(0.0f, 1.0f);
            DWORD farbe = (DWORD)(VertexColor);

            // Texturkoordinaten zufällig zwischen -1 und 2 erzeugen

            float textureU = tbFloatRandom(-1.0f, 2.0f);
            float textureV = tbFloatRandom(-1.0f, 2.0f);
            tbVector2 textureKoordinaten(textureU, textureV);

            vertizes[j].position = position;
            vertizes[j].color = 0xffff0000;
            vertizes[j].texture = textureKoordinaten;
            vertizes[j].dwFVF = D3DFVF_XYZ | D3DFVF_DIFFUSE;

        }

        // Alle Dreiecke starten am Punkt (0, 0, 50).

        dreiecke[0] = new Dreieck(
            tbVector3(0.0f, 0.0f, 25.0f),
            tbVector3Random() * tbFloatRandom(3.1f, 5.0f),
            tbVector3(0.0f, 0.0f, 0.0f),
            tbVector3Random() * tbFloatRandom(0.1f, -2.0f),
            tbFloatRandom(1.0f, 5.0f),
            vertizes
            );
            
}