ओपनजीएल 3 (एलडब्ल्यूजेजीएल) लुकएट मैट्रिक्स भ्रम

Question

मैं एलडब्ल्यूजेजीएल का उपयोग कर ओपनजीएल 3 सीख रहा हूं। मैंने gluLookAt() के बराबर लागू करने की कोशिश की है, और हालांकि यह काम करता है मैं कुछ हद तक उलझन में हूं।

मैं इस कोड को वेब पर विभिन्न स्रोतों से कॉपी करने के लिए कबूल करता हूं, लेकिन बहुत से अध्ययन के बाद मुझे लगता है कि इसके पीछे गणित को समझते हैं, और मैं समझता हूं कि एलडब्ल्यूजेजीएल क्या कर रहा है।

हालांकि 'सही' gluLookAt कोड मेरे आवेदन में गलत तरीके से व्यवहार किया गया था, क्योंकि कैमरा गलत तरीके से बदल रहा था। मैं केवल orthonormal वैक्टर forward, side, और up transposing द्वारा काम कर मेरी कोड पाने में कामयाब रहे (आशा है कि मैं सही शब्दावली का उपयोग कर रहा हूँ!) है, जो मैं कर रहा हूँ यकीन है कि गलत है ...

private static final Vector3f forward = new Vector3f(); 
private static final Vector3f side = new Vector3f(); 
private static final Vector3f up = new Vector3f(); 
private static final Vector3f eye = new Vector3f(); 

public static Matrix4f lookAt(float eyeX, float eyeY, float eyeZ, 
           float centerX, float centerY, float centerZ, 
           float upX, float upY, float upZ) { 
    forward.set(centerX - eyeX, centerY - eyeY, centerZ - eyeZ); 
    forward.normalise(); 

    up.set(upX, upY, upZ); 

    Vector3f.cross(forward, up, side); 
    side.normalise(); 

    Vector3f.cross(side, forward, up); 
    up.normalise(); 

    Matrix4f matrix = new Matrix4f(); 
    matrix.m00 = side.x; 
    matrix.m01 = side.y; 
    matrix.m02 = side.z; 

    matrix.m10 = up.x; 
    matrix.m11 = up.y; 
    matrix.m12 = up.z; 

    matrix.m20 = -forward.x; 
    matrix.m21 = -forward.y; 
    matrix.m22 = -forward.z; 

    matrix.transpose(); // <------ My dumb hack 

    eye.set(-eyeX, -eyeY, -eyeZ); 
    matrix.translate(eye); 

    return matrix; 
} 

मैं मुझे नहीं लगता कि मुझे ट्रांसपोज़ करना चाहिए, लेकिन यह इसके बिना काम नहीं करता है। मैंने transpose() लगाया क्योंकि मुझे सभी मैट्रिक्स सेल स्थितियों को पुनः टाइप करने के लिए परेशान नहीं किया जा सका!

मेरे समझ के साथ कि lookAt मैट्रिक्स के रूप के रूप में

[ side.x up.x fwd.x 0 ] [ 1 0 0 -eye.x ] 
[ side.y up.y fwd.y 0 ] [ 0 1 0 -eye.y ] 
[ side.z up.z fwd.z 0 ] [ 0 0 1 -eye.z ] 
[  0  0  0 1 ] [ 0 0 0  1 ] 

इस प्रकार है और मुझे लगता है कि LWJGL Matrix4f वर्ग m<col><row> के रूप में मैट्रिक्स कोशिकाओं का प्रतिनिधित्व करता है होना चाहिए। translate(Vector3f) विधि निम्नलिखित

public static Matrix4f translate(Vector3f vec, Matrix4f src, Matrix4f dest) { 
    ... 
    dest.m30 += src.m00 * vec.x + src.m10 * vec.y + src.m20 * vec.z; 
    dest.m31 += src.m01 * vec.x + src.m11 * vec.y + src.m21 * vec.z; 
    dest.m32 += src.m02 * vec.x + src.m12 * vec.y + src.m22 * vec.z; 
    dest.m33 += src.m03 * vec.x + src.m13 * vec.y + src.m23 * vec.z; 
    ... 
} 

तो मैं बेहद उलझन में छोड़ दिया हूँ के रूप में करने के लिए इस का क्या हिस्सा मैं बँधा हुआ है नहीं करता है। क्या यह देखने की मेरी समझ है मैट्रिक्स, कॉलम/पंक्ति प्रमुख-नेस (क्या वह शब्द है ?!) Matrix4f, या कुछ और? क्या मेरा बाकी कोड अभी टूट गया है? क्या यह वास्तव में सही है और मैं बस बहुत ज्यादा चिंता कर रहा हूं? क्या मैं सिर्फ मूर्ख हूँ?

धन्यवाद।

Answer 1

आपको कुछ भी स्थानांतरित नहीं करना चाहिए। आपको देखो() मैट्रिक्स और दिखने की दिशा के "आंख" वेक्टर को अस्वीकार करना चाहिए। "ईवाईई" कैमरे की स्थिति से मेल खाता है जिसे हमेशा उलटा होना चाहिए। यह सब देखने के अंदर किया जाता है()

यहां famous GLM math lib के जावा पोर्ट से lookAt() विधि है।

public static Mat4 lookAt(Vec3 eye, Vec3 center, Vec3 up) { 

    Vec3 f = normalize(Vec3.sub(center, eye)); 
    Vec3 u = normalize(up); 
    Vec3 s = normalize(cross(f, u)); 
    u = cross(s, f); 

    Mat4 result = new Mat4(1.0f); 
    result.set(0, 0, s.x); 
    result.set(1, 0, s.y); 
    result.set(2, 0, s.z); 
    result.set(0, 1, u.x); 
    result.set(1, 1, u.y); 
    result.set(2, 1, u.z); 
    result.set(0, 2, -f.x); 
    result.set(1, 2, -f.y); 
    result.set(2, 2, -f.z); 

    return translate(result, new Vec3(-eye.x,-eye.y,-eye.z)); 
} 

मैं अपने LWJGL आधारित ओपन 4 दाता के साथ इसका इस्तेमाल और यह एक आकर्षण :)