spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

bool Window2World(const int x,      // X-Koordinate des Fensters

                  const int y,      // Y-Koordinate des Fensters

                  Vector3& vObj)    // World-Koordinaten (out)

{
    Matrix4x4 modelview;    // Model-View-Matrix

    Matrix4x4 projection;   // Projection-Matrix

    GLint viewport[4];      // Viewport-Dimensionen


    Matrix4x4 M;    // Model-View-Matrix * Projection-Matrix

    Matrix4x4 I;    // Invertierte Matrix: I = M^-1


    Vector4 in, out;    // Vektoren für Transformationen


    // Model-View-Matrix und Projection-Matrix ermitteln.

    glGetFloatv( GL_MODELVIEW_MATRIX, (GLfloat*) modelview );
    glGetFloatv( GL_PROJECTION_MATRIX, (GLfloat*) projection );

    // Viewport-Dimensionen ermitteln.

    glGetIntegerv( GL_VIEWPORT, (GLint*) viewport );

    // Homogenen Vektor erzeugen. (Die Z-Komponente

    // lesen wir aus dem Tiefen-Buffer).

    in.x = GLfloat(x);
    in.y = GLfloat(viewport[3] - y);
    glReadPixels( x, viewport[3] - y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &in.z );
    in.w = 1.0f;

    // Falls die Tiefe "Unendlichkeit" bedeutet,

    // liegt der Punkt nicht innerhalb des

    // gültigen Bereichs des View-Frustums.

    if (in.z == 1.0f)
        return false;

    // Fensterkoordinaten in den Bereich [0;1]

    // transformieren (Viewport-Koordinaten).

    in.x = (in.x - GLfloat(viewport[0])) / GLfloat(viewport[2]);
    in.y = (in.y - GLfloat(viewport[1])) / GLfloat(viewport[3]);
    // Die Z-Komponente hat bereits einen

    // Wert im Bereich [0;1].


    // Koordinaten in den Bereich [-1;+1]

    // transformieren (normalisierte

    // Gerätekoordinaten).

    in.x = (in.x * 2.0f) - 1.0f;
    in.y = (in.y * 2.0f) - 1.0f;
    in.z = (in.z * 2.0f) - 1.0f;

    // Model-View-Matrix mit der Projection-Matrix

    // multiplizieren und invertieren.

    MatrixMul( modelview, projection, M );
    if (!MatrixInv( M, I ))
        return false;

    // Homogenen Vektor mit der invertierten

    // Transformationsmatrix multiplizieren.

    VectorTransform( I, in, out );

    // Gültigkeits-Check.

    if (out.w == 0.0f)
        return false;

    // Aus resultierendem "Strahl" einen "Punkt" machen,

    // indem durch die w-Komponente dividiert wird.

    vObj.x = out.x / out.w;
    vObj.y = out.y / out.w;
    vObj.z = out.z / out.w;

    return true;
}