spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

void render(float fNumSecsPassed)
{
    HRESULT     hResult;
    D3DXMATRIX  mScaling;       // Skalierungsmatrix

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

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

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

    D3DXMATRIX  mTranslation;   // Translationsmatrix

    D3DXMATRIX  mWorld;         // Vereinende Weltmatrix



    // Den Bildpuffer und den Z-Buffer leeren

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

    }

    // Szene beginnen

    g_pD3DDevice->BeginScene();


    // Keine Filter ("PlayStation-Effekt"), auch kein MIP-Mapping

    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
    

    // Jedes einzelne Dreieck zeichnen

    for(int iTriangle = 0; iTriangle < g_iNumTriangles; iTriangle++)
    {
        // Skalierungsmatrix anhand der Größe des Dreiecks erstellen

        D3DXMatrixScaling(&mScaling, g_aTriangle[iTriangle].fSize, g_aTriangle[iTriangle].fSize, g_aTriangle[iTriangle].fSize);

        

        // Rotationsmatrizen für das Dreieck erzeugen

        D3DXMatrixRotationX(&mRotationX, g_aTriangle[iTriangle].vRotation.x);
        D3DXMatrixRotationY(&mRotationY, g_aTriangle[iTriangle].vRotation.y);
        D3DXMatrixRotationZ(&mRotationZ, g_aTriangle[iTriangle].vRotation.z);

        // Translationsmatrix

        D3DXMatrixTranslation(&mTranslation, g_aTriangle[iTriangle].vPosition.x, g_aTriangle[iTriangle].vPosition.y, g_aTriangle[iTriangle].vPosition.z);
        
        // Alle Matrizen kombinieren und als Weltmatrix einsetzen

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

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

                                                          1,                                // 1 Dreieck

                                                          g_aTriangle[iTriangle].aVertex,   // Vertexdaten

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

        {
            // Fehler beim Zeichnen!

            MessageBox(g_hWnd, TEXT("Fehler beim zeichnen!"), TEXT("Render fehler"), MB_OK | MB_ICONWARNING | MB_SETFOREGROUND);
        }
    }

    // Szene beenden

    g_pD3DDevice->EndScene();

    // Bildpuffer sichtbar machen

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

C-/C++-Quelltext

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

C-/C++-Quelltext

for(int iTriangle = 0; iTriangle < g_iNumTriangles; iTriangle++)
    {
        // Alle Dreiecke starten am Punkt (0, 0, 50).

        g_aTriangle[iTriangle].vPosition = D3DXVECTOR3(0.0f, 0.0f, 50.0f);

        // Die Bewegung ist zufällig.

        g_aTriangle[iTriangle].vVelocity = tbVector3Random() * tbFloatRandom(0.1f, 5.0f);
        
        // Rotation zurücksetzen

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

        // Rotationsgeschwindigkeit ist zufällig auf allen drei Achsen

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

        // Größe zufällig zwischen 1 und 5 festlegen

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

        // Nun die einzelnen Vertizes generieren.

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

            g_aTriangle[iTriangle].aVertex[iVertex].vPosition = tbVector3Random();

            // Farbe

            VertexColor.r = tbFloatRandom(0.0f, 1.0f);
            VertexColor.g = tbFloatRandom(0.0f, 1.0f);
            VertexColor.b = tbFloatRandom(0.0f, 1.0f);
            g_aTriangle[iTriangle].aVertex[iVertex].dwColor = VertexColor;

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

            g_aTriangle[iTriangle].aVertex[iVertex].vTexture.x = tbFloatRandom(-1.0f, 2.0f);
            g_aTriangle[iTriangle].aVertex[iVertex].vTexture.y = tbFloatRandom(-1.0f, 2.0f);
        }
    }

C-/C++-Quelltext

   D3DXMatrixLookAtLH( &matView, &D3DXVECTOR3(0.0f, 0.0f, 10.0f), 
                                  &D3DXVECTOR3(0.0f, 0.0f, 0.0f), 
                                  &D3DXVECTOR3(0.0f, 1.0f, 0.0f ) );

C-/C++-Quelltext

 D3DXMatrixLookAtLH( &matView, &D3DXVECTOR3(0.0f, 0.0f, 60.0f), 
                                  &D3DXVECTOR3(0.0f, 0.0f, 0.0f), 
                                  &D3DXVECTOR3(0.0f, 1.0f, 0.0f ) );