OpenGL学习脚印: 视变换(view transformation)

最新推荐文章于 2023-03-06 16:58:49 发布
最新推荐文章于 2023-03-06 16:58:49 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： Android Linux Opengl 文章标签： view transformation opengl
Android 同时被 3 个专栏收录
202 篇文章 2 订阅
订阅专栏
Linux
114 篇文章 1 订阅
订阅专栏
Opengl
25 篇文章 0 订阅
订阅专栏

http://blog.csdn.net/wangdingqiaoit/article/details/51570001

写在前面 
OpenGL中的坐标处理过程包括模型变换、视变换、投影变换、视口变换等内容，这个主题的内容有些多，因此分节学习，主题将分为5节内容来学习。上一节模型变换，本节学习模型变换的下一阶段——视变换。到目前位置，主要在2D下编写程序，学习了视变换后，我们可以看到3D应用的效果了。本节示例程序均可在我的github下载。

通过本节可以了解到

  • 视变换的概念
  • 索引绘制立方体
  • LookAt矩阵的推导(对数学不感兴趣，可以跳过)
  • 相机位置随时间改变的应用程序

坐标处理的全局过程(了解，另文详述)

OpenGL中的坐标处理包括模型变换、视变换、投影变换、视口变换等内容，具体过程如下图1所示:

坐标处理过程

每一个过程处理都有其原因，这些内容计划将会在不同节里分别介绍，最后再整体把握一遍。 
今天我们学习第二个阶段——视变换。

并不存在真正的相机

OpenGL成像采用的是虚拟相机模型。在场景中你通过模型变换，将物体放在场景中不同位置后，最终哪些部分需要成像，显示在屏幕上，主要由视变换和后面要介绍的投影变换、视口变换等决定。

其中视变换阶段，通过假想的相机来处理矩阵计算能够方便处理。对于OpenGL来说并不存在真正的相机，所谓的相机坐标空间(camera space 或者eye space)只是为了方便处理，而引入的坐标空间。

在现实生活中，我们通过移动相机来拍照，而在OpenGL中我们通过以相反方式调整物体，让物体以适当方式呈现出来。例如，初始时，相机镜头指向-z轴，要观察-z轴上的一个立方体的右侧面，那么有两种方式：

  1. 相机绕着+y轴，旋转+90度，此时相机镜头朝向立方体的右侧面，实现目的。注意这时立方体并没有转动。

  2. 相机不动，让立方体绕着+y轴，旋转-90度，此时也能实现同样的目的。注意这时相机没有转动。完成这一旋转的矩阵记作 Ry(−π2)

在OpenGL中，采用方式2来完成物体成像的调整。例如下面的图表示了假想的相机：

相机

进一步说明

进一步说明这里相对的概念，对这个概念不感兴趣的可以跳过。默认时相机位于(0,0,0)，指向-z轴，相当于调用了：

glm::lookAt(glm::vec(0.0f,0.0f,0.0f),
        glm::vec3(0.0f, 0.0f, -1.0f),
        glm::vec3(0.0f, 1.0f, 0.0f)),
 
 
  • 1
  • 2
  • 3

 
 
  • 1
  • 2
  • 3

得到是单位矩阵，这是相机的默认情况。

上述第一种方式，相机绕着+y轴旋转90度，相机指向-x轴，则等价于调用变为:

   glm::mat4 view =glm::lookAt(glm::vec(0.0f,0.0f,0.0f),
        glm::vec3(-1.0f, 0.0f, 0.0f),
        glm::vec3(0.0f, 1.0f, 0.0f)),
 
 
  • 1
  • 2
  • 3

 
 
  • 1
  • 2
  • 3

得到的视变换矩阵为:

view=⎡⎣⎢⎢⎢00100100−10000001⎤⎦⎥⎥⎥

上述第二种方式，通过立方体绕着+y轴旋转-90度，则得到的矩阵M,相当于:

   glm::mat4 model = glm::rotate(glm::mat4(1.0), glm::radians(-90.0f), glm::vec3(0.0, 1.0, 0.0));
 
 
  • 1

 
 
  • 1

这里得到的矩阵M和上面的矩阵view是相同的，可以自行验证下。 
也就是说，通过旋转相机+y轴90度，和旋转立方体+y轴-90度，最终计算得到的矩阵相同。调整相机来得到观察效果，可以通过相应的方式来调整物体达到相同的效果。在OpenGL中并不存在真正的相机，这只是一个虚构的概念。

视变换矩阵的推导（了解，对数学不感兴趣可跳过）

相机坐标系由相机位置eye和UVN基向量(或者说由forward, side ,up）构成，如下图所示：

相机坐标系 
各个参数的含义如下：

  • 相机位置 也称为观察参考点 (View Reference Point) 在世界坐标系下指定相机的位置eye。
  • 相机镜头方向，由相机位置和相机指向的目标(target)位置计算出， forwrad=(target−eye) 。
  • 相机顶部正朝向: View Up Vector 确定在相机哪个方向是向上的，一般取(0, 1, 0)。这个参数稍后详细解释。

上面的图简化为： 
相机参数

在使用过程中，我们是要指定的参数即为相机位置(eye)，相机指向的目标位置(target)和viewUp vector三个参数。 
Step1 : 首选计算相机镜头方向  forwrad=(target−eye) , 
进行标准化 forward=forward∥forwrad∥ 。 
Step2: 根据view-up vector和forward确定相机的side向量: 
viewUp′=viewUp∥viewUp∥  
side=cross(forward,viewUp′)

Step3 : 根据forward和side计算up向量: 
up=cross(side,forward)  
这样eye位置，以及forward、side、up三个基向量构成一个新的坐标系，注意这个坐标系是一个左手坐标系，因此在实际使用中，需要对forward进行一个翻转，利用-forward、side、up和eye来构成一个右手坐标系。

我们的目标是计算世界坐标系中的物体在相机坐标系下的坐标，也就是从相机的角度来解释物体的坐标。从一个坐标系的坐标变换到另一个坐标系，这就是不同坐标系间坐标转换的过程。

计算方法1——直接计算变换矩阵

从坐标和变换一节，了解到，要实现不同坐标系之间的坐标转换，需要求取一个变换矩阵。而这个矩阵就是一个坐标系A中的原点和基在另一个坐标系B下的表示。 
我们将相机坐标系的原点和基，使用世界坐标系表示为(s代表side基向量，u代表up基向量，f代表forward基向量)： 

[Camera]world=⎡⎣⎢⎢⎢⎢s[0]s[1]s[1]0u[0]u[1]u[2]0−f[0]−f[1]−f[2]0eyexeyeyeyez1⎤⎦⎥⎥⎥⎥

现在要求取的是坐标从世界坐标系变换到相机坐标系，则计算点p在相机坐标系下表示为： 
[p]camera=[World]camera[p]world=[Camera]−1world[p]world=view[p]world  
即求得视变换矩阵为 
view=[Camera]−1world=⎡⎣⎢⎢⎢⎢s[0]u[0]−f[0]0s[1]u[1]−f[1]0s[2]u[2]−f[2]0−dot(s,eye)−dot(u,eye)dot(f,eye)1⎤⎦⎥⎥⎥⎥

上面计算逆矩阵的过程中使用到了分块矩阵求逆矩阵的定理：

设方阵A、D可逆，那么分块矩阵 (A0BD) 可逆，且其逆矩阵为 T−1=(A−10−A−1BD−1D−1)

这种方式对应的计算代码如下：

　　　　// 手动构造LookAt矩阵 方式1
glm::mat4 computeLookAtMatrix1(glm::vec3 eye, glm::vec3 target, glm::vec3 viewUp)
{
    glm::vec3 f = glm::normalize(target - eye); // forward vector
    glm::vec3 s = glm::normalize(glm::cross(f, viewUp)); // side vector
    glm::vec3 u = glm::normalize(glm::cross(s, f)); // up vector
    glm::mat4 lookAtMat(
        glm::vec4(s.x, u.x, -f.x, 0.0), // 第一列
        glm::vec4(s.y, u.y, -f.y, 0.0), // 第二列
        glm::vec4(s.z, u.z, -f.z, 0.0), // 第三列
        glm::vec4(-glm::dot(s, eye),
        -glm::dot(u, eye), glm::dot(f, eye), 1.0)  // 第四列
        );
    return lookAtMat;
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

这种方式求取过程中涉及到了分块矩阵的逆矩阵计算，如果不习惯，可以看下面的方式2，这是比较常用的方式。

计算方法2——利用旋转和平移矩阵求逆矩阵

求取坐标转换矩阵的过程，也可以从另外一个角度出发，即将世界坐标系旋转和平移至于相机坐标系重合，这样这个旋转 R 和平移 T 矩阵的组合矩阵 M=T∗R ，就是将相机坐标系中坐标变换到世界坐标系中坐标的变换矩阵，那么所求的视变换矩阵（世界坐标系中坐标转换到相机坐标系中坐标的矩阵） view=M−1 . 
其中R就是上面求得的side、up、forward基向量构成的矩阵，如下： 

R=⎡⎣⎢⎢⎢⎢s[0]s[1]s[2]0u[0]u[1]u[2]0−f[0]−f[1]−f[2]00001⎤⎦⎥⎥⎥⎥

T=⎡⎣⎢⎢⎢⎢000000000000eyexeyeyeyez1⎤⎦⎥⎥⎥⎥

那么所求的矩阵view计算过程如下: 
view=(T∗R)−1=R−1∗T−1=RT∗T−1  
在计算过程中，使用到了旋转矩阵的性质，即旋转矩阵是正交矩阵，它的逆矩阵等于矩阵的转置。 
因此所求的: 
RT=⎡⎣⎢⎢⎢⎢s[0]u[0]−f[0]0s[1]u[1]−f[1]0s[2]u[2]−f[2]00001⎤⎦⎥⎥⎥⎥

T−1=⎡⎣⎢⎢⎢⎢１0000１0000１0－eyex－eyey－eyez１⎤⎦⎥⎥⎥⎥

同样计算得到视变换矩阵为： 

view＝RT∗T−1　＝　⎡⎣⎢⎢⎢⎢s[0]u[0]−f[0]0s[1]u[1]−f[1]0s[2]u[2]−f[2]0−dot(s,eye)−dot(u,eye)dot(f,eye)1⎤⎦⎥⎥⎥⎥

这种方式对应的计算代码如下：

   // 手动构造LookAt矩阵 方式2
glm::mat4 computeLookAtMatrix2(glm::vec3 eye, glm::vec3 target, glm::vec3 viewUp)
{
    glm::vec3 f = glm::normalize(target - eye); // forward vector
    glm::vec3 s = glm::normalize(glm::cross(f, viewUp)); // side vector
    glm::vec3 u = glm::normalize(glm::cross(s, f)); // up vector
    glm::mat4 rotate(
        glm::vec4(s.x, u.x, -f.x, 0.0), // 第一列
        glm::vec4(s.y, u.y, -f.y, 0.0), // 第二列
        glm::vec4(s.z, u.z, -f.z, 0.0), // 第三列
        glm::vec4(0.0, 0.0, 0.0, 1.0)  //  第四列
        );
    glm::mat4  translate;
    translate = glm::translate(translate, -eye);
    return rotate * translate;
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

OpenGL中视变换的实现

在OpenGL中，我们可以通过函数glm::lookAt来实现相机指定，这个函数计算的就是上面求出的视变换矩阵。以前glu版本实现为gluLookAt，这两个函数完成的功能是一样的，参数定义如下：

API lookAt ( GLdouble eyeX, GLdouble eyeY, GLdouble eyeZ, GLdouble centerX, GLdouble centerY, GLdouble centerZ, GLdouble upX, GLdouble upY, GLdouble upZ) 
其中eye指定相机位置，center指定相机指向目标位置，up指定viewUp向量。

利用GLM数学库一般实现为：

glm::mat4 view = glm::lookAt(eyePos,
    glm::vec3(0.0f, 0.0f, 0.0f), 
    glm::vec3(0.0f, 1.0f, 0.0f));
 
 
  • 1
  • 2
  • 3

 
 
  • 1
  • 2
  • 3

下面利用这个函数进行一些实验，以帮助理解。在设置相机参数之前，我们学习下绘制立方体，为实验增加素材。

绘制立方体

前面索引绘制矩形一节使用了索引了矩形，如果利用索引绘制立方体，表面上看确实可以节省顶点数据，但是存在的问题是，不能为不同面上的共同顶点指定不同的纹理坐标，这在某些情况下会出现问题的。例如下面使用索引绘制的立方体： 
索引绘制 
由于在正面和侧面的顶点制定了相同的纹理坐标，插值后纹理一致，并没有出现可爱的猫咪图案。为此，我们需要为共用顶点指定不同的顶点属性，那么解决办法之一是，继续使用顶点数组绘制方式，定义立方体的数据如下：

  // 指定顶点属性数据 顶点位置 颜色 纹理
GLfloat vertices[] = {
    -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,   // A
    0.5f, -0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,    // B
    0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f,     // C
    0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f,     // C
    -0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,    // D
    -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,   // A

    -0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f,  // E
    -0.5f, 0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 0.0, 1.0f,    // H
    0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,    // G
        0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,    // G
    0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f,   // F
    -0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f,  // E

    -0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,    // D
    -0.5f, 0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 1.0, 1.0f,    // H
    -0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f,  // E
    -0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f,  // E
    -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,   // A
    -0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,    // D

    0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f,   // F
    0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,    // G
    0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f,     // C
    0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f,    // C
    0.5f, -0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,    // B
    0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f,   // F

    0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,    // G
    -0.5f, 0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 0.0, 1.0f,    // H
    -0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f,    // D
    -0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f,    // D
    0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, // C
    0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,    // G

    -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,   // A
    -0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f,  // E
    0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f,   // F
    0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f,   // F
    0.5f, -0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,    // B
    -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,   // A
    };
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

着色器使用上一节绘制矩形的着色器程序。绘制立方体后，通过设定相机位置随着时间发生改变来观察这个立方体。指定相机位置为在xoz平面圆周运动的点轨迹，代码为:

GLfloat radius = 3.0f;
GLfloat xPos = radius * cos(glfwGetTime());
GLfloat zPos = radius * sin(glfwGetTime());
glm::vec3 eyePos(xPos, 0.0f, zPos);
glm::mat4 view = glm::lookAt(eyePos,
glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

同时在代码中指定投影方式为透视投影，代码为：

// 投影矩阵
glm::mat4 projection = glm::perspective(glm::radians(45.0f),
        (GLfloat)(WINDOW_WIDTH) / WINDOW_HEIGHT, 1.0f, 100.0f);
 
 
  • 1
  • 2
  • 3

 
 
  • 1
  • 2
  • 3

投影方式和投影矩阵的计算将在后面小结介绍，这里只需要知道使用方法即可。

实现绘制立方体，效果如下图所示：

需要开启深度测试

从上面的图中我们看到了奇怪的现象，立方体后面的部分绘制在了前面的部分上，这种现象是由于深度测试(Depth Test)未开启影响的。深度测试根据物体在场景中到观察者的距离，根据设定的glDepthFunc函数判定是否通过深度测试，默认为GL_LESS，即深度小者通过测试绘制在最终的屏幕上。关于深度测试这个主题，后面会继续学习，这里不再展开。 
OpenGL中开启深度测试方法：

  glEnable(GL_DEPTH_TEST);
 
 
  • 1

 
 
  • 1

同时在主循环中，清除深度缓冲区和颜色缓冲区：

   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
 
  • 1

 
 
  • 1

开启深度测试后，旋转相机来观察立方体，效果如下： 
旋转的相机

viewUp向量

上面提到了在指定相机时需要指定相机的viewUP向量，这个向量指定了相机中哪个方向是向上的。对于相机而言，指定了相机位置eye和相机指向位置target后确定了相机的指向，位置不变，指向不变时，还是可以通过改变这个viewUp而影响成像的。这个类似于你眼睛的位置不变，看着的方向不变，但是你可以扭动脖子来确定哪个方向是向上，这个viewUp好比头顶给定的方向。相机位置固定在(0,0,3.0)，指向原点，依次取viewUp为 (0,1,0),(1,0,0),(0,−1,0) ，绘制立方体后的效果如下图所示：

viewUp

图中viewUp为(0,1,0)时猫的尾巴朝上，为(1,0,0)时相当于把脖子右旋转90度，看到猫的尾巴是在左边的；为(0,-1,0)相当于倒立过来看，猫的尾巴是向下的。如果想了解更多关于viewUp的解释，可以参考What exactly is the UP vector in OpenGL’s LookAt function.

更多立方体

上一节介绍了模型变换，我们可以利用模型变换，在场景中绘制多个立方体，同时相机的位置可以采用圆的参数方程或者球面参数方程设定。绘制多个立方体的方法：

 // 指定立方体位移
 glm::vec3 cubePostitions[] = {
        glm::vec3(0.0f, 0.0f, 1.2f),
        glm::vec3(0.0f, 0.0f, 0.0f),
        glm::vec3(1.2f, 1.2f, 0.0f),
        glm::vec3(-1.2f, 1.2f, 0.0f),
        glm::vec3(-1.2f, -1.5f, 0.0f),
        glm::vec3(1.2f, -1.5f, 0.0f),
        glm::vec3(0.0f, 0.0f, -1.2f),
    };
  // 在主循环中绘制立方体
for (int i = 0; i < sizeof(cubePostitions) / sizeof(cubePostitions[0]); ++i)
{
    model = glm::mat4();
    model = glm::translate(model, cubePostitions[i]);
            glUniformMatrix4fv(glGetUniformLocation(shader.programId, "model"),
        1, GL_FALSE, glm::value_ptr(model));
    glDrawArrays(GL_TRIANGLES, 0, 36);
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

对相机位置随着时间进行改变，可以采用圆的参数方程或者球面参数方程设定。这里只是作为一个示例来设定，可以根据你的具体需求设定对应角度值。示例代码如下：

 // xoz平面内圆形坐标
glm::vec3 getEyePosCircle()
{
    GLfloat radius = 6.0f;
    GLfloat xPos = radius * cos(glfwGetTime());
    GLfloat zPos = radius * sin(glfwGetTime());
    return glm::vec3(xPos, 0.0f, zPos);
}
// 球形坐标 这里计算theta phi角度仅做示例演示
// 可以根据需要设定
glm::vec3 getEyePosSphere()
{
    GLfloat radius = 6.0f;
    GLfloat theta = glfwGetTime(), phi = glfwGetTime() / 2.0f;
    GLfloat xPos = radius * sin(theta) * cos(phi);
    GLfloat yPos = radius * sin(theta) * sin(phi);
    GLfloat zPos = radius * cos(theta);
    return glm::vec3(xPos, yPos, zPos);
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

例如利用球面坐标方程设定的相机位置，效果如下图所示：

球形相机坐标

最后的说明

经过视变换后，世界坐标系中坐标转换到了相机坐标系下。需要注意的相机在OpenGL中是个假想的概念，本质是通过矩阵来完成计算的。本节设定相机位置为圆周或者球面运动轨迹，并不能让用户来交互地观察场景中物体，下一节将设计一个第一人称FPS相机，让用户通过键盘和鼠标控制相机，更好地观察场景。


fu_shuwu
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
qt下opengl的三维视角转换算法
08-29
主要实现了对一个简单的立方体进行鼠标三键操作，包括放大缩小平移等类似cad的可视化操作，对实现网格可视化等opengl绘图需求有较强的参考意义，已在qt5.11 msvc2017 64bitrelease下编译通过，附有编译完成的exe
视图模型转换矩阵的推导也是关于gluLookAt函数即视图转换矩阵的推导及代码实现
LC_若水微韧的博客
11-06 4736
关于gluLookAt函数即视图转换矩阵的推导及代码实现 视图模型转换矩阵的推导也是关于gluLookAt函数即视图转换矩阵的推导及代码实现   gluLookAt函数提供给用户完成模式变换(model-view transformation)中，在将模型坐标系转换都世界坐标系后，进行世界坐标系到照相机坐标系的转换。实际上，照相机的定位也是在世界坐标系下定义的，这里的转换，可以理解为:
相机变换矩阵
CHENFEIYANG2009的专栏
01-20 7091
一些网友写信给我希望能够了解固定流水线中世界空间到相机空间变换矩阵的具体推导过程。其实之前我在《向量几何在游戏编程中的使用6》中已经简单的把相机变换作为一个使用基理论的例子进行了说明，但可能仍然不够具体。这篇文章中，我会尽力阐述相机变换的整个来龙去脉。希望能够对正在学习固定流水线的朋友们有所帮助。这里我们仍然会在推导相机变换之前介绍几个理论知识，目的是为了更好的理解推导过程。我们马上开始！ 什么
推导相机变换矩阵
热门推荐
Popy007(Twinsen)的专栏
01-02 3万+
-潘宏-2009.12.31-本人水平有限，疏忽错误在所难免，还请各位数学高手、编程高手不吝赐教-email: [email protected]一些网友写信给我希望能够了解固定流水线中世界空间到相机空间变换矩阵的具体推导过程。其实之前我在《向量几何在游戏编程中的使用6》中已经简单的把相机变换作为一个使用基理论的例子进行了说明，但可能仍然不够具体。这篇文章中，我会尽力阐述相机变换
SLAM中相机位姿求解（李群李代数）
A_cainiao_A
07-12 1万+
前言slam中一个关键问题之一就是求解相机的位姿，人们找了很多以相机位姿为变量的误差函数，比如光度误差，重投影误差，3D几何误差等等，希望使得误差最小，进而求得比较准确的相机位姿。举一个重投影例子： T∗=min12∑i=0n||ui−1siKTPi||2(1) T^* = min \frac{1}{2} \sum_{i=0}^n || u_i - \frac{1}{s_i}KTP_i||^2 \
三维坐标变换_坐标变换_transformation3d_源码
10-02
超系统的三维坐标变换讲义，工程软件开发必备
image-transformation.rar_TRANSFORMATION_绘图 变换
09-19
利用VC++实现图像变换（包括平移、伸缩、旋转），附绘图所需头文件
METAmorphoses: DB to RDF transformation-开源
04-25
METAmorphoses是一个用于直接从关系数据库中灵活而易于使用的RDF元数据生成的系统。 根据从现有数据库架构到特定本体的映射来生成元数据。
Gray-linear-transformation.zip_TRANSFORMATION_灰度线性变换
07-15
灰度的线性变换就是将图像中所有的点按照线性灰度变换函数进行变换
transformation-matrix-js:JavaScript 的二维变换矩阵实现
06-28
二维仿射变换矩阵 用于 JavaScript 的仿射变换矩阵 (3x3) 类，可执行各种变换，例如旋转、缩放、平移、倾斜、剪切、加、减、乘、除、逆、分解等（包括完整的 HTML 文档）。 它主要用于需要跟踪或创建变换并希望将其...
第五章 opengl之摄像机
Re_view的博客
03-06 1326
第五章 opengl之摄像机
LearnOpenGL笔记6摄像机观察空间
Suqiaoyi的博客
06-10 280
相机观察空间look at移动速度二级目录三级目录 正z轴是从屏幕指向你，相机往后移动，沿着z轴正方向。 方向向量(Direction Vector)并不是最好的名字，因为它实际上指向从它到目标向量的相反方向。 look at 使用三个相互垂直（或非线性）的轴定义了一个坐标空间，可以用3个轴外加一个平移向量来创建一个矩阵， glm有对应的调用函数，同时可以设置通过键盘控制。 右向量进行了标准化。如果我们没对这个向量进行标准化，最后的叉乘结果会根据cameraFront变量返回大小不同的向量。如果我们不对向量
Mars3D开发基础学习：相机Camera及视角控制
木遥的专栏
12-30 4186
Camera相机控制了三维场景的视图。有很多方法可以操作Camera，如旋转(rotate)、缩放(zoom)、平移(pan)和飞到目的地(flyTo)。同时也有鼠标和触摸事件用来处理与Camrea的交互，还有API来以编程方式操作摄像机。
关于solvePNP的一点思考之二通过solvePnP求解相机位置
lircsszz的博客
04-18 4450
        在调用solvePnP函数之后会得到旋转向量rvec和平移向量tvec。确定相机位置就需要用到这两个向量。在介绍相机位置计算方法之前需要对solvePnP做简要介绍。与solvePnP函数有关的坐标系有三个，分别是世界坐标系(物体坐标系)、相机坐标系(以相机光心为原点的坐标系)、像素坐标系（图像坐标系）。solvePnP就是利用物体在像素坐标系的坐标和在世界坐标系的坐标的对应关系来...
OpenGL学习之路11----相机空间
Zach_z的博客
04-27 3016
代码放在github上 本文根据教程：ogldev进行扩充学习，一步步从零开始，记录学习历程 之前已经学习了怎么将物体在3维空间里自由地缩放、旋转和平移，博客链接如下： OpenGL学习之路6—-平移，旋转和缩放变换 OpenGL学习之路9—-混合变换 也学习怎么把三维世界表现在我们屏幕这个2维平面上，博客链接如下： OpenGL学习之路10—-透视投影 但是我们发现了一个问题，我们...
【计算机图形2】实验1: 从[世界坐标系]到[相机坐标系]到[透视投影变化]及[隐藏面消除]的计算
Sengo的博客
02-27 1307
前言:本文记录计算机图形2的第一个实验，如何从世界坐标系投影到2D平面上并做隐藏面消除。由于我看的材料（课件及资料）很多都是英文的，因此可能导致英文名词写成中文翻译得不对。从世界坐标系到相机坐标系：这里引用我在GW上这门课的教授James K. Hahn的课件。把世界坐标系转成相机坐标系（如图1），就是把世界坐标系的点一个个转换成以相机（观察点）为原点的坐标系中所在的点。换句话说就是，在世界坐标系...
【OpenGL学习笔记十】摄像机
briant_ccj的专栏
03-14 661
根据之前的学习已经学习到，如果需要从不同的角度去观察空间中的物体，其实就是构造LookAt矩阵即观察矩阵。构造lookAt矩阵，给出几个坐标即可 void lookAt(const QVector3D& eye, const QVector3D& center, const QVector3D& up); 摄像机盯着原点看 QVector3D eye(0.0f, 0.0f, -3.0f); QVector3D center(0.0f, 0.0f, 0.0f);//center
OpenGL学习脚印
最新发布
08-13
- *1* *3* [OpenGL学习脚印: 模型变换(model transformation)](https://blog.csdn.net/ziyuanxiazai123/article/details/51531002)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值