Witam. Mam pytanie odnośnie OpenGl - rysowania sprężyny chodzi o zrozumienie kodu. Zadaniem było narysowanie sprężyny według tego wzoru:

xi = cos(ti)*(3+cos(ui))
yi = sin(ti)*(3+cos(ui))
zi=0.6*ti+sin(ui)

i mamy taki kod

glBegin(GL_QUADS);
    for (float t = 0; t < T; t += dt) {
        sint = sinf(t);
        cost = cosf(t);
        sint2 = sinf(t + dt);
        cost2 = cosf(t + dt);
        c[0][0] = c[3][0] = RATIO * t / T;
        c[1][0] = c[2][0] = RATIO * (t + dt) / T;

        for (float u = 0; u < U; u += du) {
            sinu = sinf(u);
            cosu = cosf(u);
            sinu2 = sinf(u + du);
            cosu2 = cosf(u + du);

            v[0][0] = cost * (3 + cosu);
            v[0][1] = sint * (3 + cosu);
            v[0][2] = size * t / T + sinu;
            n[0][0] = v[0][0] - cost * 3;
            n[0][1] = v[0][1] - sint * 3;
            n[0][2] = v[0][2] - size * t / T;

            v[1][0] = cost2 * (3 + cosu);
            v[1][1] = sint2 * (3 + cosu);
            v[1][2] = size * (t + dt) / T + sinu;
            n[1][0] = v[1][0] - cost2 * 3;
            n[1][1] = v[1][1] - sint2 * 3;
            n[1][2] = v[1][2] - size * (t + dt) / T;

            c[0][1] = c[1][1] = u / U;

            v[2][0] = cost2 * (3 + cosu2);
            v[2][1] = sint2 * (3 + cosu2);
            v[2][2] = size * (t + dt) / T + sinu2;
            n[2][0] = v[2][0] - cost2 * 3;
            n[2][1] = v[2][1] - sint2 * 3;
            n[2][2] = v[2][2] - size * (t + dt) / T;

            v[3][0] = cost * (3 + cosu2);
            v[3][1] = sint * (3 + cosu2);
            v[3][2] = size * t / T + sinu2;
            n[3][0] = v[3][0] - cost * 3;
            n[3][1] = v[3][1] - sint * 3;
            n[3][2] = v[3][2] - size * t / T;

            c[2][1] = c[3][1] = (u + du) / U;

            for (int i = 0; i < 4; i++) {
                glTexCoord2fv(c[i]);
                glNormal3fv(n[i]);
                glVertex3fv(v[i]);
            }
        }
    }
    glEnd();

No i ogólnie rozumiem mniej więcej że glBegin bierze wierzchołki czwórkami i każda 4 wierzchołków między GlBegin a GLEnd to jeden czworokąt, zaś ta ostatnia pętla generuje 4 wierzchołki ustawiając wektory normalne i współrzędne tekstury. Ale za co odpowiadają pozostałe 2 pętle? i ogólnie nie rozumiem tego zapisu tych v dlaczego są 3 czyli przykładowo v[0][0] , v[0][1] ,v[0][2]? bo rozumiem że każdy taki bloczek przykładowo ten:

                    v[1][0] = cost2 * (3 + cosu);
            v[1][1] = sint2 * (3 + cosu);
            v[1][2] = size * (t + dt) / T + sinu;
            n[1][0] = v[1][0] - cost2 * 3;
            n[1][1] = v[1][1] - sint2 * 3;
            n[1][2] = v[1][2] - size * (t + dt) / T;

to jest jakby jeden wierzchołek? Proszę o wytłumaczenie