Funkcja rysująca sprężynę w OpenGL – prośba o wyjaśnienie działania kodu

Witam. Szukam kogoś kto mi pomoże zrozumieć funkcje rysującą sprężyne w opengl

void spring(float size) {
	const float T = 8.0 * PI;
	const float U = 2.0 * PI;
	const float RATIO = T / U;
	const float dt = T / (RATIO * QUADRIC_SLICES);
	const float du = U / QUADRIC_STACKS;
	float v[4][3], n[4][3], c[4][2];
	float sint, cost, sint2, cost2;
	float sinu, cosu, sinu2, cosu2;

	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();

T = 8 PI ponieważ obwód koła to 2PI a mamy 4 zwoje więc 8 PI.
U - obwód drutu sprężyny 2PI

Nie rozumiem jednak tej pętli v- to są współrzędne , c to współrzędne tekstury a n - wektory normalne , za co one odpowiadają? Tak naprawdę gdy zakomentuje zarówno c i n to sprężyna ma ten sam kształt . V to 4 punkty które tworzą prostokąty?

I co robi ta pętla na końcu? Odpowiada za rysowanie punktów(vertexow) i ustawia te wektory normalne i wspolrzedne tekstury?

Proszę o pomoc w zrozumieniu.

Pozdrawiam

kod w skrócie wygląda tak:

    glBegin(GL_QUADS);
    for (...) {
        // jakieś liczenie
 
        for (...) {
            // jakieś liczenie
 
            for (int i = 0; i < 4; i++) {
                glTexCoord2fv(c[i]);
                glNormal3fv(n[i]);
                glVertex3fv(v[i]);
            }
        }
    }
    glEnd();

Ostatnia pętla generuje cztery wierzchołki tworzące jeden czworokąt.
glTexCoord ustawia bieżące współrzędne tekstury, glNormal ustawia bieżący wektor normalny, a glVertex generuje jeden wierzchołek na podanej pozycji i z aktualną wartością współrzędnych tekstury, wektorem normalnym i innymi parametrami.
Czyli glVertex oprócz własnych parametrów bierze pod uwagę ostatnio ustawione wartości za pomocą glTexCoord, glNormal i in.

glBegin(GL_QUADS) bierze wierzchołki czwórkami, każda czwórka wierzchołków między glBegin a glEnd to jeden czworokąt.

Pytasz co to jest wektor normalny. Jest to wektor (z założenia) prostopadły do powierzchni. Używany jest m.in. do obliczeń związanych z oświetleniem.
Dlaczego podaje się je osobno a nie są automatycznie obliczane na podstawie wierzchołków? Z wielu powodów, ale to może już poczytaj..

buduje kwadraty w opengl troszke skomplikowany kod ale w sumie wyswietla kwadraty