4

我正在制作一个 OpenGL c++ 应用程序来跟踪用户相对于屏幕的位置，然后将渲染场景更新为用户的视角。这被称为“桌面 VR”，或者您可以将屏幕视为立体模型或鱼缸。我对 OpenGL 相当陌生，到目前为止只定义了一个非常简单的场景，只是一个立方体，并且最初是正确渲染的。

问题是当我开始移动并想要重新渲染立方体场景时，投影平面似乎被平移了，我看不到我认为我应该看到的内容。我想把这架飞机修好。如果我正在编写光线追踪器，我的窗口将始终是固定的，但我的眼睛可以随意移动。有人可以向我解释如何在让我的相机/眼睛在非原点坐标处徘徊的同时达到我想要的效果（固定观察窗）吗？

我发现的所有示例都要求相机/眼睛位于原点，但这在概念上对我来说并不方便。另外，因为这是一个“鱼缸”，我将我的 d_near 设置为 xy 平面，其中 z = 0。

在屏幕/世界空间中，我将屏幕中心分配给 (0,0,0) 并将其 4 个角分配给：TL(-44.25, 25, 0) TR( 44.25, 25, 0) BR( 44.25,-25 , 0) BL(-44.25,-25, 0) 对于 16x9 显示器，这些值以厘米为单位。

然后，我使用 POSIT 计算用户的眼睛（实际上是我脸上的网络摄像头），通常在 (+/-40, +/-40, 40-250) 的范围内。我的 POSIT 方法是准确的。

我正在为透视和查看变换以及使用着色器定义自己的矩阵。

我初始化如下：

float right = 44.25;
float left = -44.25;
float top = 25.00;
float bottom = -25.00; 

vec3 eye = vec3(0.0, 0.0, 100.0);
vec3 view_dir = vec3(0.0, 0.0, -1.0);
vec3 up = vec3(0.0, 1.0, 0.0);
vec3 n = normalize(-view_dir);
vec3 u = normalize(cross(up, n)); 
vec3 v = normalize(cross(n, u));

float d_x = -(dot(eye, u));
float d_y = -(dot(eye, v));
float d_z = -(dot(eye, n));

float d_near = eye.z;
float d_far = d_near + 50;

// perspective transform matrix
mat4 P = mat4((2.0*d_near)/(right-left ), 0, (right+left)/(right-left), 0, 
            0, (2.0*d_near)/(top-bottom), (top+bottom)/(top-bottom), 0,
            0, 0, -(d_far+d_near)/(d_far-d_near), -(2.0*d_far*d_near)/(d_far-d_near),
            0, 0, -1.0, 0);

// viewing transform matrix
mat4 V = mat4(u.x, u.y, u.z, d_x,
              v.x, v.y, v.z, d_y,
              n.x, n.y, n.z, d_z,
              0.0, 0.0, 0.0, 1.0);

mat4 MV = C * V;
//MV = V;

根据我在网上收集的信息，我的 view_dir 及以上内容将保持不变。这意味着我只需要更新 d_near 和 d_far 以及 d_x、d_y 和 d_y？我在我的 glutIdleFunc(idle);

void idle (void) {  

    hBuffer->getFrame(hFrame);
    if (hFrame->goodH && hFrame->timeStamp != timeStamp) {
        timeStamp = hFrame->timeStamp;
        std::cout << "(" << hFrame->eye.x << ", " <<
                    hFrame->eye.y << ", " <<
                    hFrame->eye.z << ") \n";

        eye = vec3(hFrame->eye.x, hFrame->eye.y, hFrame->eye.z);

        d_near = eye.z;
        d_far = eye.z + 50;

        P = mat4((2.0*d_near)/(right-left), 0, (right+left)/(right-left), 0, 
                 0, (2.0*d_near)/(top-bottom), (top+bottom)/(top-bottom), 0,
                 0, 0, -(d_far+d_near)/(d_far-d_near), -(2.0*d_far*d_near)/(d_far-d_near),
                 0, 0, -1.0, 0);

        d_x = -(dot(eye, u));
        d_y = -(dot(eye, v));
        d_z = -(dot(eye, n));

        C = mat4(1.0, 0.0, 0.0, eye.x,
                 0.0, 1.0, 0.0, eye.y,
                 0.0, 0.0, 1.0, 0.0,
                 0.0, 0.0, 0.0, 1.0);

        V = mat4(u.x, u.y, u.z, d_x,
                 v.x, v.y, v.z, d_y,
                 n.x, n.y, n.z, d_z,
                 0.0, 0.0, 0.0, 1.0);

        MV = C * V;
        //MV = V;

        glutPostRedisplay();
    }
}

这是我的着色器代码：

#version 150

uniform mat4 MV;
uniform mat4 P;
in vec4 vPosition;
in vec4 vColor;
out vec4 color;

void 
main() 
{ 
    gl_Position = P * MV * vPosition;
    color = vColor;
}

好的，我对代码进行了一些更改，但没有成功。当我在顶点着色器中使用 V 代替 MV 时，一切看起来都如我所愿，透视正确且对象大小合适，但是，场景是通过相机的位移来平移的。

当使用 C 和 V 获得 MV 时，我的场景是从观察者的角度直接渲染的，渲染的场景会按应有的方式填充窗口，但眼睛/相机的视角会丢失。

真的，我想要的是通过眼睛/相机的适当 x 和 y 值来平移 2D 像素，投影平面，以便将对象的中心（其 xy 中心为（0,0））保持在渲染图像的中心。我以教科书“交互式计算机图形学：基于着色器的 OpenGL（第 6 版）的自顶向下方法”中的示例为指导。使用网络上免费提供的与本书配对的文件，我将继续使用行主要方法。

以下图像是在不使用矩阵 C 创建 MV 时拍摄的。当我确实使用 C 创建 MV 时，所有场景看起来都像下面的第一张图片。我不希望在 z 中进行翻译，所以我将其保留为 0。

因为投影平面和我的相机平面是平行的，所以从一个坐标系到另一个坐标系的转换只是简单的平移和inv(T) ~ -T。

这是我在 (0,0,50) 处的眼睛图像： 这是我在 (0,0,50) 处的眼睛图像：

这是我在 (56,-16,50) 的眼睛图像： 这是我在 (56,-16,50) 的眼睛图像：

4

2 回答 2

3

解决方案是更新 d_x、d_y 和 d_z，考虑新的眼睛位置，但永远不要改变 u、v 或 n。此外，必须用左、右、上和下的新值更新矩阵 P，因为它们与相机/眼睛的新位置有关。

我用这个初始化：

float screen_right = 44.25;
float screen_left = -44.25;
float screen_top = 25.00;
float screen_bottom = -25.00; 
float screen_front = 0.0;
float screen_back = -150;

现在我的空闲函数看起来像这样，注意顶部、底部、右侧和左侧的计算：

void idle (void) {  

hBuffer->getFrame(&hFrame);
if (hFrame.goodH && hFrame.timeStamp != timeStamp) {
    timeStamp = hFrame.timeStamp;
    //std::cout << "(" << hFrame.eye.x << ", " <<
    //                  hFrame.eye.y << ", " <<
    //                  hFrame.eye.z << ") \n";

    eye = vec3(hFrame.eye.x, hFrame.eye.y, hFrame.eye.z);

    d_near = eye.z;
    d_far = eye.z + abs(screen_back) + 1;

    float top = screen_top - eye.y;
    float bottom = top - 2*screen_top;
    float right = screen_right - eye.x;
    float left = right - 2*screen_right;

    P = mat4((2.0 * d_near)/(right - left ), 0.0, (right + left)/(right - left), 0.0, 
             0.0, (2.0 * d_near)/(top - bottom), (top + bottom)/(top - bottom), 0.0,
             0.0, 0.0, -(d_far + d_near)/(d_far - d_near), -(2.0 * d_far * d_near)/(d_far - d_near),
             0.0, 0.0, -1.0, 0.0);

    d_x = -(dot(eye, u));
    d_y = -(dot(eye, v));
    d_z = -(dot(eye, n));

    V = mat4(u.x, u.y, u.z, d_x,
             v.x, v.y, v.z, d_y,
             n.x, n.y, n.z, d_z,
             0.0, 0.0, 0.0, 1.0);

    glutPostRedisplay();
}

}

透视矩阵的这种重新定义使渲染图像无法平移。我仍然有相机捕捉和屏幕抓取同步问题，但我能够创建如下图像，为用户的位置实时更新：

在此处输入图像描述

于 2013-04-21T19:33:19.903 回答
0

我发现的所有示例都要求相机/眼睛位于原点

这不是要求。OpenGL 没有定义相机，这一切都归结为转换。这些通常称为投影和模型视图（模型和视图变换相结合）。相机，即视图变换只是相机在世界空间中的定位的倒数。所以说你为你的相机建立了一个矩阵C，然后你会在模型视图上预乘它的逆矩阵。

mat4 MV = inv(C) * V

附带说明一下，您的着色器代码是错误的：

gl_Position = P * ( (V * vPosition ) / vPosition.w );
                                    ^^^^^^^^^^^^^^

同质划分不是在着色器中完成的，因为它是硬连线到渲染管道中的。

于 2013-04-18T09:18:03.737 回答