Generowanie płaszczyzny z paskami trójkąta

Oto jakiś kod, który to robi (nie testowany, ale przynajmniej masz pomysł):

void make_plane(int rows, int columns, float *vertices, int *indices) {
    // Set up vertices
    for (int r = 0; r < rows; ++r) {
        for (int c = 0; c < columns; ++c) {
            int index = r*columns + c;
            vertices[3*index + 0] = (float) c;
            vertices[3*index + 1] = (float) r;
            vertices[3*index + 2] = 0.0f;
        }
    }

    // Set up indices
    int i = 0;
    for (int r = 0; r < rows - 1; ++r) {
        indices[i++] = r * columns;
        for (int c = 0; c < columns; ++c) {
            indices[i++] = r * columns + c;
            indices[i++] = (r + 1) * columns + c;
        }
        indices[i++] = (r + 1) * columns + (columns - 1);
    }
 }

Pierwsza pętla ustawia tablicę wierzchołków w standardowej siatce prostokątnej. Istnieją wierzchołki R * C.

Druga pętla ustawia indeksy. Ogólnie rzecz biorąc, istnieją dwa wierzchołki na kwadrat w siatce. Każdy wierzchołek spowoduje narysowanie nowego trójkąta (z dwoma poprzednimi wierzchołkami), więc każdy kwadrat zostanie narysowany dwoma trójkątami.

Pierwszy i ostatni wierzchołek na początku i końcu każdy wiersz jest duplikowany. Oznacza to, że pomiędzy każdym rzędem znajdują się dwa trójkąty o powierzchni zerowej (Trójkąty zdegenerowane). Pozwala nam to narysować całą siatkę w jednym dużym pasku trójkąta. Technika ta nazywana jest szyciem.

Żaden z powyższych kodów nie daje prawidłowego generowania siatki. Bardzo dobry artykuł o tym, jak zrobić pasek trójkątów na prostej płaszczyźnie: http://www.learnopengles.com/android-lesson-eight-an-introduction-to-index-buffer-objects-ibos/

Oto Mój kod testowy, który faktycznie przetestowany i w pełni działa:

int plane_width = 4; // amount of columns
int plane_height = 2; // amount of rows

int total_vertices = (plane_width + 1) * (plane_height + 1);
planeVert = new CIwFVec2[total_vertices];
memset(planeVert, 0, sizeof(CIwFVec2) * total_vertices);

int numIndPerRow = plane_width * 2 + 2;
int numIndDegensReq = (plane_height - 1) * 2;
int total_indices = numIndPerRow * plane_height + numIndDegensReq;

planeInd = new uint16[total_indices];

make_plane(plane_width, plane_height, planeVert, planeInd);

...

void make_plane(int width, int height, CIwFVec2 *vertices, uint16 *indices)
{
width++;
height++;

int size = sizeof(CIwFVec2);
// Set up vertices
for(int y = 0; y < height; y++)
{
    int base = y * width;
    for(int x = 0; x < width; x++)
    {
        int index = base + x;
        CIwFVec2 *v = vertices + index;
        v->x = (float) x;
        v->y = (float) y;
        Debug::PrintDebug("%d: %f, %f", index, v->x, v->y);
    }
}

Debug::PrintDebug("-------------------------");

// Set up indices
int i = 0;
height--;
for(int y = 0; y < height; y++)
{
    int base = y * width;

    //indices[i++] = (uint16)base;
    for(int x = 0; x < width; x++)
    {
        indices[i++] = (uint16)(base + x);
        indices[i++] = (uint16)(base + width + x);
    }
    // add a degenerate triangle (except in a last row)
    if(y < height - 1)
    {
        indices[i++] = (uint16)((y + 1) * width + (width - 1));
        indices[i++] = (uint16)((y + 1) * width);
    }
}

for(int ind=0; ind < i; ind++)
    Debug::PrintDebug("%d ", indices[ind]);
}

Robiłem coś podobnego i korzystając z dwóch pierwszych odpowiedzi wymyśliłem to (tested, C#, XNA)

        // center x,z on origin
        float offset = worldSize / 2.0f, scale = worldSize / (float)vSize;

        // create local vertices
        VertexPositionColor[] vertices = new VertexPositionColor[vSize * vSize];

        for (uint z = 0; z < vSize; z++) {
            for (uint x = 0; x < vSize; x++) {
                uint index = x + (z * vSize);
                vertices[index].Position = new Vector3((scale*(float)x) - offset, 
                                                       heightValue, 
                                                       (scale*(float)z) - offset);
                vertices[index].Color = Color.White;
            }
        }

        // create local indices
        var indices = new System.Collections.Generic.List<IndexType>();

        for (int z = 0; z < vSize - 1; z++) {
            // degenerate index on non-first row
            if (z != 0) indices.Add((IndexType)(z * vSize));

            // main strip
            for (int x = 0; x < vSize; x++) {
                indices.Add((IndexType)(z * vSize + x));
                indices.Add((IndexType)((z + 1) * vSize + x));
            }

            // degenerate index on non-last row
            if (z != (vSize-2)) indices.Add((IndexType)((z + 1) * vSize + (vSize - 1)));
        }

Jest to łatwe do konwersji do c++, po prostu stwórz indices std:: vector.

Godnymi uwagi cechami mojego rozwiązania są: a) nie trzeba zmieniać kolejności nawijania na podst. - dodanie dwóch punktów tworzy dwa zdegenerowane Trójkąty, więc kolejność jest poprawna dla następnego podst. b) należy warunkowo dodać pierwszy i ostatni wierzchołek trójkąta dg.