• The math used by the implementation of GLKMatrix4MakeLookAt() cannot produce a useful point of view that looks directly along the “up” vector. The limitation exists because when looking directly “up” or “down,” the math used by GLKMatrix4MakeLookAt() attempts to calculate the tangent of 90 degrees, which is mathematically undefined.
• Quaternions take advantage of 4D space to represent 3D angles.
• Gimbal lock is the loss of one degree of freedom in a three-dimensional, three-gimbal mechanism that occurs when the axes of two of the three gimbals are driven into a parallel configuration, “locking” the system into rotation in a degenerate two-dimensional space.
• Gimbal with 3 axes of rotation. A set of three gimbals mounted together to allow three degrees of freedom: roll, pitch and yaw. When two gimbals rotate around the same axis, the system loses one degree of freedom.

Partiendo del concepto de coordenadas homogeneas (x, y, z, w). Donde w…

• … Vale 1 si es una posición en el espaco.
• … Vale 0 si es una dirección.

Las coordenadas homogeneas son las que nos permiten trabajar con matrices de traslación, rotación y escalado.

La w es el valor de perspectiva, se utilizará para divir X, Y, y Z entre este. The Advantages of Dividing by W You might be wondering why we don’t simply divide by z instead. After all, if we interpret z as the distance and had two coordinates, (1, 1, 1) and (1, 1, 2) , we could then divide by z to get two normalized coordinates of (1, 1) and (0.5, 0.5). While this can work, there are additional advantages to adding w as a fourth component. We can decouple the perspective effect from the actual z coordinate, so we can switch between an orthographic and a perspective projection. There’s also a benefit to preserving the z component as a depth buffer.

Recuerda, es importante el orden de operaciones. Al multiplicar una matriz por un vector el primer operando siempre será el vector:

transformedVector = myMatrix * myVector;

En el que las coordenadas se plasman en un plano (cartesiano) a partir de los valores X, Y.

Las coordenadas polares o sistemas polares son un sistema de coordenadas bidimensional en el cual cada punto del plano se determina por una distancia y un ángulo, ampliamente utilizados en física y trigonometría.

El sistema de coordenadas esféricas se basa en la misma idea que las coordenadas polares y se utiliza para determinar la posición espacial de un punto mediante una distancia y dos ángulos. En consecuencia, un punto P queda representado por un conjunto de tres magnitudes: el radio r, el ángulo polar o colatitud φ y el azimut θ (r, phi, theta).

void renderSphere(float cx, float cy, float cz, float r, int p)
{
    float theta1 = 0.0, theta2 = 0.0, theta3 = 0.0;
    float ex = 0.0f, ey = 0.0f, ez = 0.0f;
    float px = 0.0f, py = 0.0f, pz = 0.0f;
    GLfloat vertices[p*6+6], normals[p*6+6], texCoords[p*4+4];
 
    if( r < 0 )
        r = -r;
 
    if( p < 0 )
        p = -p;
 
    for(int i = 0; i < p/2; ++i)
    {
        theta1 = i * (M_PI*2) / p - M_PI_2;
        theta2 = (i + 1) * (M_PI*2) / p - M_PI_2;
 
        for(int j = 0; j <= p; ++j)
        {
            theta3 = j * (M_PI*2) / p;
 
            ex = cosf(theta2) * cosf(theta3);
            ey = sinf(theta2);
            ez = cosf(theta2) * sinf(theta3);
            px = cx + r * ex;
            py = cy + r * ey;
            pz = cz + r * ez;
 
            vertices[(6*j)+(0%6)] = px;
            vertices[(6*j)+(1%6)] = py;
            vertices[(6*j)+(2%6)] = pz;
 
            normals[(6*j)+(0%6)] = ex;
            normals[(6*j)+(1%6)] = ey;
            normals[(6*j)+(2%6)] = ez;
 
            texCoords[(4*j)+(0%4)] = -(j/(float)p);
            texCoords[(4*j)+(1%4)] = 2*(i+1)/(float)p;
 
 
            ex = cosf(theta1) * cosf(theta3);
            ey = sinf(theta1);
            ez = cosf(theta1) * sinf(theta3);
            px = cx + r * ex;
            py = cy + r * ey;
            pz = cz + r * ez;
 
            vertices[(6*j)+(3%6)] = px;
            vertices[(6*j)+(4%6)] = py;
            vertices[(6*j)+(5%6)] = pz;
 
            normals[(6*j)+(3%6)] = ex;
            normals[(6*j)+(4%6)] = ey;
            normals[(6*j)+(5%6)] = ez;
 
            texCoords[(4*j)+(2%4)] = -(j/(float)p);
            texCoords[(4*j)+(3%4)] = 2*i/(float)p;
        }
        glVertexPointer(3, GL_FLOAT, 0, vertices);
        glNormalPointer(GL_FLOAT, 0, normals);
        glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
        glDrawArrays(GL_TRIANGLE_STRIP, 0, (p+1)*2);
    }
}