GluLookAt কীভাবে কাজ করে?

Question

আমার বোধ থেকে,

gluLookAt(
        eye_x, eye_y, eye_z,
        center_x, center_y, center_z,   
        up_x, up_y, up_z
    );

সমান:

glRotatef(B, 0.0, 0.0, 1.0);
glRotatef(A, wx, wy, wz);
glTranslatef(-eye_x, -eye_y, -eye_z);

তবে আমি যখন ModelViewম্যাট্রিক্সটি মুদ্রণ করি তখন কলটি glTranslatef()ঠিকভাবে কাজ করে না বলে মনে হয়। কোড স্নিপেট এখানে:

#include <stdlib.h>
#include <stdio.h>
#include <GL/glut.h>

#include <iomanip>
#include <iostream>
#include <string>

using namespace std;

static const int Rx = 0;
static const int Ry = 1;
static const int Rz = 2;

static const int Ux = 4;
static const int Uy = 5;
static const int Uz = 6;

static const int Ax = 8;
static const int Ay = 9;
static const int Az = 10;

static const int Tx = 12;
static const int Ty = 13;
static const int Tz = 14;

void init() {
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glEnable(GL_DEPTH_TEST);
    glShadeModel(GL_SMOOTH);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    GLfloat lmodel_ambient[] = { 0.8, 0.0, 0.0, 0.0 };
    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
}

void displayModelviewMatrix(float MV[16]) {
    int SPACING = 12;
    cout << left;
    cout << "\tMODELVIEW MATRIX\n";
    cout << "--------------------------------------------------" << endl;
    cout << setw(SPACING) << "R" << setw(SPACING) << "U" << setw(SPACING) << "A" << setw(SPACING) << "T" << endl;   
    cout << "--------------------------------------------------" << endl;
    cout << setw(SPACING) << MV[Rx] << setw(SPACING) << MV[Ux] << setw(SPACING) << MV[Ax]  << setw(SPACING) << MV[Tx] << endl;
    cout << setw(SPACING) << MV[Ry] << setw(SPACING) << MV[Uy] << setw(SPACING) << MV[Ay]  << setw(SPACING) << MV[Ty] << endl;
    cout << setw(SPACING) << MV[Rz] << setw(SPACING) << MV[Uz] << setw(SPACING) << MV[Az] << setw(SPACING)  << MV[Tz] << endl;
    cout << setw(SPACING) << MV[3] << setw(SPACING) << MV[7] << setw(SPACING) << MV[11] << setw(SPACING) << MV[15] << endl;
    cout << "--------------------------------------------------" << endl;
    cout << endl;
}

void reshape(int w, int h) {
    float ratio = static_cast<float>(w)/h;
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0, ratio, 1.0, 425.0);
}

void draw() {
    float m[16];
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glGetFloatv(GL_MODELVIEW_MATRIX, m);
    gluLookAt(
        300.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 0.0f,
        0.0f, 1.0f, 0.0f
    );
    glColor3f(1.0, 0.0, 0.0);
    glutSolidCube(100.0);
    glGetFloatv(GL_MODELVIEW_MATRIX, m);
    displayModelviewMatrix(m);
    glutSwapBuffers();
}


int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(400, 400);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("Demo");
    glutReshapeFunc(reshape);
    glutDisplayFunc(draw);
    init();
    glutMainLoop();
    return 0;
} 

কোন ব্যাপার কি মান আমি জন্য ব্যবহার eyeভেক্টর:
300, 0, 0বা
0, 300, 0বা
0, 0, 300
অনুবাদ ভেক্টর একই, কারণ কোডের অর্ডার অনগ্রসর অর্ডার তাই যা কোন মানে নেই glTranslatefপ্রথম 2 ঘুর্ণন চালানো উচিত, তারপর। প্লাস, রোটেশন ম্যাট্রিক্স অনুবাদ কলাম থেকে সম্পূর্ণরূপে স্বতন্ত্র (মডেলভিউ ম্যাট্রিক্সে), তাহলে এই অদ্ভুত আচরণের কারণ কী হবে? এখানে চোখের ভেক্টর দিয়ে আউটপুট দেওয়া হচ্ছে(0.0f, 300.0f, 0.0f)

        MODELVIEW MATRIX
--------------------------------------------------
R           U           A           T
--------------------------------------------------
0           0           0           0
0           0           0           0
0           1           0           -300
0           0           0           1
--------------------------------------------------

আমি Tকলামটি আশা করব (0, -300, 0)! সুতরাং কেউ আমাকে এই ব্যাখ্যা করতে সাহায্য করতে পারে?

বাস্তবায়ন gluLookAtHttp://www.mesa3d.org থেকে

void GLAPIENTRY
gluLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez, GLdouble centerx,
      GLdouble centery, GLdouble centerz, GLdouble upx, GLdouble upy,
      GLdouble upz)
{
    float forward[3], side[3], up[3];
    GLfloat m[4][4];

    forward[0] = centerx - eyex;
    forward[1] = centery - eyey;
    forward[2] = centerz - eyez;

    up[0] = upx;
    up[1] = upy;
    up[2] = upz;

    normalize(forward);

    /* Side = forward x up */
    cross(forward, up, side);
    normalize(side);

    /* Recompute up as: up = side x forward */
    cross(side, forward, up);

    __gluMakeIdentityf(&m[0][0]);
    m[0][0] = side[0];
    m[1][0] = side[1];
    m[2][0] = side[2];

    m[0][1] = up[0];
    m[1][1] = up[1];
    m[2][1] = up[2];

    m[0][2] = -forward[0];
    m[1][2] = -forward[1];
    m[2][2] = -forward[2];

    glMultMatrixf(&m[0][0]);
    glTranslated(-eyex, -eyey, -eyez);
}

Answer 1

gluLookAt পৃথিবীটি এমনভাবে ঘোরাবে এবং অনুবাদ করবে যে ক্যামেরাটি অবস্থিত হবে {0, 0, 0} এবং নেতিবাচক জেড-অক্ষের দিকে তাকাবে। এটি ওপেনজিএলে ব্যবহৃত ক্যামেরা সেটআপ। ক্যামেরা আসলে কখনও চলাফেরা করে না, বিশ্বটি করে। বিভ্রান্ত শব্দ? হ্যাঁ, আমাকে ব্যাখ্যা করার চেষ্টা করুন :)

এই উদাহরণটি নেওয়া যাক:

eye    :  {300, 0, 0}
lookat :  {  0, 0, 0}
up     :  {  0, 1, 0}

MODELVIEW MATRIX
--------------------------------------------------
R           U           A           T           
--------------------------------------------------
0           0           -1          0           
0           1           0           0           
1           0           0           -300        
0           0           0           1           
--------------------------------------------------

আমরা প্রথমে ম্যাট্রিক্স আবর্তনজনিত অংশ বিশ্লেষণ করা প্রয়োজন: R, Uএবং A। আপনি দেখতে পাচ্ছেন যে সঠিক ভেক্টর ( R) আর এক্স-অক্ষে নেই {1, 0, 0}, এটি জেড-অক্ষে রয়েছে {0, 0, 1}। এর অর্থ এটি y- অক্ষের চারপাশে 90 ডিগ্রি ঘোরানো হয়। চোখের অবস্থানের ক্ষেত্রেও একই ঘটনা ঘটে। {-300, 0, 0}Y- অক্ষের চারপাশে 90 ডিগ্রি ঘোরানো এটিকে {0, 0, -300}ভয়েলা, এখানে রয়েছে lets

এটাই -300300 বিশ্বব্যাপী সরানো এবং ক্যামেরা নয় বলেই নয়, তাই বিশ্বটি বিপরীত দিকে চলে গেছে, এখনও ক্যামেরা থেকে 300 ইউনিট দূরে রয়েছে {0, 0, 0}। এবং আবারও, এটি নেতিবাচক জেড-অক্ষের দিকে সরানো হয়েছে, কারণ ওপেনজিএল ক্যামেরাটি উপরে উল্লিখিত হিসাবে দেখায়।

---

দ্রষ্টব্য: আপনার উদাহরণে একটি অসঙ্গতি রয়েছে, চক্ষু-অবস্থান থেকে দেখার-বিন্দুতে স্বাভাবিক ভেক্টরটি আপ-ভেক্টরের মতো হওয়া উচিত নয়, তাই:

eye    : {0, 300, 0}
lookat : {0,   0, 0}
up     : {0,   1, 0}    

normalize(eye - lookat): {0, 1, 0} -> the same as the up-vector

প্রকৃতপক্ষে কাজ করবে না, উদাহরণস্বরূপ, আমাদের আরও একটি আপ-ভেক্টর বাছাই করতে হবে {1, 0, 0}

Comments

অনেক ধন্যবাদ, যদিও আমি আপনার ব্যাখ্যাটি বুঝতে পেরেছি যদিও আমি এখনও কিছুটা বিভ্রান্ত।

— চান