spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

for(int i=0; i<g_iNumCubes; i++){
        g_pD3DDevice->SetStreamSource(0, g_pVertexBuffer, sizeof(SVertex)*i, sizeof(SVertex));

        hResult = g_pD3DDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,    // Dreiecksliste

                                                     0,                     // Basisvertexindex

                                                     0,                     // Der kleinste Index

                                                     8,                     // Diff. zw. größtem u. kleinstem Index

                                                     0,                     // Von Anfang an zeichnen

                                                     12);                   // 12 Dreiecke pro Würfel

        if(FAILED(hResult))
        {
            // Fehler beim Zeichnen!

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

Quellcode

g_pVertexBuffer->Lock(0, 0, (void**)(&pVertices), D3DLOCK_NOSYSLOCK);
    g_pIndexBuffer->Lock(0, 0, (void**)(&pusIndices), D3DLOCK_NOSYSLOCK);

    // Nun gehen wir jeden einzelnen Würfel durch.
    for(int iCube = 0; iCube < g_iNumCubes; iCube++)
    {
        // Zufällige Position für diesen Würfel erzeugen
        vCubePosition = tbVector3Random() * tbFloatRandom(20.0f, 250.0f);

        // Startvertex und Startindex für diesen Würfel berechnen.
        // Diese Werte beschreiben, an welcher Stelle im Vertex- und Index-Buffer
        // die Daten des aktuellen Würfels beginnen.
        iStartVertex = iCube * 8;
        iStartIndex = iCube * 36;

        // Vertizes für diesen Würfel generieren. Erst die Positionsangaben.
        pVertices[iStartVertex + 0].vPosition = vCubePosition + tbVector3(-1.0f,  1.0f, -1.0f);
        pVertices[iStartVertex + 1].vPosition = vCubePosition + tbVector3(-1.0f,  1.0f,  1.0f);
        pVertices[iStartVertex + 2].vPosition = vCubePosition + tbVector3( 1.0f,  1.0f,  1.0f);
        pVertices[iStartVertex + 3].vPosition = vCubePosition + tbVector3( 1.0f,  1.0f, -1.0f);
        pVertices[iStartVertex + 4].vPosition = vCubePosition + tbVector3(-1.0f, -1.0f, -1.0f);
        pVertices[iStartVertex + 5].vPosition = vCubePosition + tbVector3(-1.0f, -1.0f,  1.0f);
        pVertices[iStartVertex + 6].vPosition = vCubePosition + tbVector3( 1.0f, -1.0f,  1.0f);
        pVertices[iStartVertex + 7].vPosition = vCubePosition + tbVector3( 1.0f, -1.0f, -1.0f);

        for(int iVertex = iStartVertex; iVertex < iStartVertex + 8; iVertex++)
        {
            // Texturkoordinaten generieren
            pVertices[iVertex].vTexture = tbVector2Random();
        }

        // Nun die Indizes eintragen. Jeweils drei von ihnen ergeben ein Dreieck.
        int aiIndex[36] = {0, 3, 7,   0, 7, 4,  // Vorderseite
                           2, 1, 5,   2, 5, 6,  // Hinterseite
                           1, 0, 4,   1, 4, 5,  // Linke Seite
                           3, 2, 6,   3, 6, 7,  // Rechte Seite
                           0, 1, 2,   0, 2, 3,  // Oberseite
                           6, 5, 4,   6, 4, 7}; // Unterseite

        // Die 36 Indizes in den Index-Buffer übertragen.
        // Zu jedem Indexwert muss noch der Startvertexwert addiert werden.
        for(int iIndex = 0; iIndex < 36; iIndex++)
        {
            // Index eintragen
            pusIndices[iStartIndex + iIndex] = aiIndex[iIndex] + iStartVertex;
        }
    }

    // Vertex- und Index-Buffer wieder entsperren
    g_pVertexBuffer->Unlock();
    g_pIndexBuffer->Unlock();