1.8.1 摄像机

最新推荐文章于 2024-04-24 16:18:49 发布
最新推荐文章于 2024-04-24 16:18:49 发布
阅读量951 收藏 16
点赞数 28
分类专栏： OpenGL-Qt学习笔记 文章标签： qt OpenGL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Viciower/article/details/137154255
版权

一、摄像机

OpenGL本身没有摄像机的概念，但是我们可以通过把场景中的所有物体往相反方向移动的方式来模拟出摄像机，产生一种我们在移动的感觉，而不是场景在移动。

本节将会讨论如何在OpenGL中配置一个摄像机，让你能够在3D场景中自由移动，也会讨论键盘和鼠标输入，最终完成一个自定义的摄像机类。

1、摄像机/观察空间

当讨论摄像机/观察空间（Camera/View Space）的时候，是在讨论以摄像机的视角作为场景原点时场景中所有的顶点坐标：观察矩阵把所有的世界坐标变换为相对于摄像机位置与方向的观察坐标。要定义一个摄像机，需要它在世界空间中的位置、观察的方向、一个指向它右侧的向量以及一个指向它上方的向量，实际上创建了一个三个单位轴相互垂直的、以摄像机的位置为原点的坐标系。

1）摄像机位置

摄像机位置就是世界空间中一个指向摄像机位置的向量。把摄像机位置设置为上一节的那个位置：

QVector3D cameraPos = QVector3D(0.0f, 0.0f, 3.0f); //位置

2）摄像机方向

摄像机的方向是摄像机指向的方向。现在让摄像机指定场景原点(0, 0, 0)。用场景原点向量减去摄像机位置向量的结果就是摄像机的指向向量。我们知道摄像机指向z轴负方向，但是希望方向向量指向摄像机的z轴正方向，交换相减的顺序，就会获得一个指向摄像机z轴正方向的向量：

QVector3D cameraTarget = QVector3D(0.0f, 0.0f, 0.0f);
QVector3D cameraDirection = cameraPos - cameraTarget; //方向
cameraDirection.normalize(); //单位向量

方向向量不是最好的名字，因为它实际上指向从它到目标向量的相反方向，如上图中蓝色的方向向量大概指向z轴的正方向，与摄像机实际指向的方向是相反的。

3）右轴

需要一个右向量，它代表摄像机空间的x轴的正方向。为获得右向量需要先使用一个小技巧：先定义一个上向量，把上向量和第二步的方向向量进行叉乘，两个向量叉乘的结果会同时垂直于这两个向量，因此会得到指向x轴正方向的那个向量（如果交换两个向量叉乘的顺序就会得到指向x轴负方向的向量）：

QVector3D up = QVector3D(0.0f, 1.0f, 0.0f);
QVector3D cameraRight = QVector3D::crossProduct(up, cameraDirection); //叉乘，右向量
cameraRight.normalize(); //单位向量

4）上轴

现在把x轴向量和z轴向量进行叉乘，得到y轴向量

QVector3D cameraUp = QVector3D::crossProduct(cameraDirection,cameraRight); //叉乘，上向量

2、Look At

可以用3个相互垂直的轴定义一个坐标空间，可以用3个轴外加一个平移向量来创建一个矩阵，并且可以用这个矩阵乘以任何向量来将其变换到那个坐标空间，这正是LookAt矩阵所做的。

其中R是右向量，U是上向量，D是方向向量，P是摄像机位置向量（位置向量是相反的）

只需要给Qt中lookAt()函数提供一个摄像机位置、一个目标位置和一个表示世界空间中的上向量的向量，就可以得到一个观察矩阵（因为在上面四步中用摄像机位置、目标位置和上向量计算出其他向量，lookAt函数会自动计算出其他向量）

QMatrix4x4 view;
view.lookAt(cameraPos, cameraTarget, up);

下面实现摄像机在场景中旋转，摄像机的注视点保持在(0, 0, 0)。

在myopenglwidget.h文件中声明了6个QVector3D类型的变量，用于存储摄像机相关的数据；QTime类型的变量用于计时：

#ifndef MYOPENGLWIDGET_H
#define MYOPENGLWIDGET_H
#include <QOpenGLWidget>
#include <QOpenGLFunctions_3_3_Core>
#include <QOpenGLShaderProgram>
#include <QOpenGLTexture>
#include <QTimer>
#include <QTime>

class MyOpenGLWidget : public QOpenGLWidget,QOpenGLFunctions_3_3_Core
{
    Q_OBJECT

public:
    explicit MyOpenGLWidget(QWidget *parent = nullptr);
    ~MyOpenGLWidget();

protected:
    virtual void initializeGL();
    virtual void resizeGL(int w, int h);
    virtual void paintGL();

    void keyPressEvent(QKeyEvent *event);

private slots:
    void onTimeout();

private:
    QOpenGLShaderProgram m_shaderProgram;
    QOpenGLTexture *m_textureWall;
    QOpenGLTexture *m_textureSmile;
    QOpenGLTexture *m_textureSmall;

    float mixValue = 0.5;

    QTimer m_timer;
    QTime m_time;

    QVector3D m_cameraPos;
    QVector3D m_cameraTarget;
    QVector3D m_cameraDirection;
    QVector3D m_up;
    QVector3D m_cameraRight;
    QVector3D m_cameraUp;
};

#endif // MYOPENGLWIDGET_H

更改myopenglwidget.cpp代码如下：

#include "myopenglwidget.h"
#include <QDebug>
#include <QKeyEvent>

unsigned int VBO; //顶点缓冲对象
unsigned int VAO; //顶点数组对象
unsigned int EBO; //元素缓冲对象

MyOpenGLWidget::MyOpenGLWidget(QWidget *parent) : QOpenGLWidget(parent)
{
    setFocusPolicy(Qt::StrongFocus);

    //位置
    m_cameraPos = QVector3D(0.0f, 0.0f, 3.0f);

    //方向
    m_cameraTarget = QVector3D(0.0f, 0.0f, 0.0f);
    m_cameraDirection = m_cameraPos - m_cameraTarget;
    m_cameraDirection.normalize(); //单位向量

    //右向量
    m_up = QVector3D(0.0f, 1.0f, 0.0f);
    m_cameraRight = QVector3D::crossProduct(m_up, m_cameraDirection); //叉乘，右向量
    m_cameraRight.normalize(); //单位向量

    //上向量
    m_cameraUp = QVector3D::crossProduct(m_cameraDirection, m_cameraRight); //叉乘，上向量

    connect(&m_timer, &QTimer::timeout, this, &MyOpenGLWidget::onTimeout);
    m_timer.start(100); //100ms
    m_time.start(); //开始计时
}

MyOpenGLWidget::~MyOpenGLWidget()
{
    if(m_timer.isActive())
        m_timer.stop();

    makeCurrent();
    glDeleteBuffers(1, &VBO);
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &EBO);
    doneCurrent();
}

void MyOpenGLWidget::onTimeout()
{
    update();
}

void MyOpenGLWidget::initializeGL()
{
    //初始化OpenGL函数
    initializeOpenGLFunctions();

    //创建VBO，并赋予ID
    glGenBuffers(1, &VBO);
    //绑定VBO对象
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    //顶点数据
    float vertices[] = {
         //位置                //纹理
        -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
         0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
        -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,

        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
         0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
        -0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,

        -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
        -0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
        -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,

         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
         0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
         0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
         0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,

        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
         0.5f, -0.5f, -0.5f,  1.0f, 1.0f,
         0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
         0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,

        -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
        -0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
        -0.5f,  0.5f, -0.5f,  0.0f, 1.0f
    };
    //把顶点数据复制到显存中
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    //创建VAO对象，并赋予ID
    glGenVertexArrays(1, &VAO);
    //绑定VAO对象
    glBindVertexArray(VAO);

    //创建EBO对象，并赋予ID
    glGenBuffers(1, &EBO);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    unsigned int indices[] = {
                               0, 1, 3, //第一个三角形
                               1, 2, 3 //第二个三角形
                             };
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

    //位置属性
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0); //开启VAO管理的第一个属性值

    //纹理属性
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
    glEnableVertexAttribArray(1); //开启VAO管理的第三个属性值

    //解绑VBO
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    //解绑VAO
    glBindVertexArray(0);

    //创建一个程序对象
    m_shaderProgram.addShaderFromSourceFile(QOpenGLShader::Vertex,":/shaders/shapes.vert");
    m_shaderProgram.addShaderFromSourceFile(QOpenGLShader::Fragment,":/shaders/shapes.frag");
    bool success = m_shaderProgram.link();
    if(!success)
        qDebug()<<"ERR:" << m_shaderProgram.log();

    m_shaderProgram.bind();
    m_shaderProgram.setUniformValue("vertexColor", 0.0, 1.0, 0.0, 1.0);

    m_textureWall = new QOpenGLTexture(QImage(":/images/wall.jpg").mirrored()); //mirrored消除镜像
    m_shaderProgram.setUniformValue("textureWall", 0); //把纹理单元传给片段着色器中的采样器

    m_textureSmile = new QOpenGLTexture(QImage(":/images/awesomeface.png").mirrored()); //mirrored消除镜像
    m_shaderProgram.setUniformValue("textureSmile", 1); //把纹理单元传给片段着色器中的采样器

    m_textureSmall = new QOpenGLTexture(QImage(":/images/small.png").mirrored()); //mirrored消除镜像
    m_shaderProgram.setUniformValue("textureSmall", 2); //把纹理单元传给片段着色器中的采样器

    m_shaderProgram.setUniformValue("mixValue", mixValue);
}

void MyOpenGLWidget::resizeGL(int w, int h)
{
    Q_UNUSED(w);

    Q_UNUSED(h);
    //glViewport(0, 0, w, h);
}

QVector<QVector3D> cubePositions=
{
    QVector3D( 0.0f, 0.0f, 0.0f),
    QVector3D( 2.0f, 5.0f, -15.0f),
    QVector3D(-1.5f, -2.2f, -2.5f),
    QVector3D(-3.8f, -2.0f, -12.3f),
    QVector3D( 2.4f, -0.4f, -3.5f),
    QVector3D(-1.7f, 3.0f, -7.5f),
    QVector3D( 1.3f, -2.0f, -2.5f),
    QVector3D( 1.5f, 2.0f, -2.5f),
    QVector3D( 1.5f, 0.2f, -1.5f),
    QVector3D(-1.3f, 1.0f, -1.5f)
};

void MyOpenGLWidget::paintGL()
{
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f); //设置墨绿色背景
    glEnable(GL_DEPTH_TEST); //打开深度缓冲区
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清空

    //观察矩阵
    QMatrix4x4 view; //创建单位矩阵
    const float radius = 10.0f;
    float time = m_time.elapsed()/1000.0;
    float camX = sin(time) * radius;
    float camZ = cos(time) * radius;
    view.lookAt(QVector3D(camX, 0.0, camZ), m_cameraTarget, m_up);
    m_shaderProgram.setUniformValue("view", view);

    //投影矩阵
    QMatrix4x4 projection; //创建单位矩阵
    projection.perspective(45.0f, (float)width()/height(), 0.1f, 100.0f); //透视投影
    m_shaderProgram.setUniformValue("projection", projection);

    //绘制
    m_shaderProgram.bind(); //激活程序对象
    glBindVertexArray(VAO); //绑定VAO
    m_textureWall->bind(0); //绑定激活纹理单元0
    m_textureSmile->bind(1); //绑定激活纹理单元1
    m_textureSmall->bind(2); //绑定激活纹理单元2

    foreach(auto item, cubePositions)
    {
        //模型矩阵
        QMatrix4x4 model; //创建单位矩阵
        model.translate(item); //移动
        model.rotate(time, 1.0f, 1.f, 0.0f); //绕向量(1.0f, 1.f, 0.0f)旋转
        m_shaderProgram.setUniformValue("model", model); //传给顶点着色器
        glDrawArrays(GL_TRIANGLES, 0, 36); //绘图
    }
}

void MyOpenGLWidget::keyPressEvent(QKeyEvent *event)
{
    if(event->key() == Qt::Key_Up)
        mixValue+=0.1;
    else if(event->key() == Qt::Key_Down)
        mixValue-=0.1;
    else
        return;

    if(mixValue > 1.0)
        mixValue = 1.0;

    if(mixValue < 0.0)
        mixValue = 0.0;

    makeCurrent();
    m_shaderProgram.setUniformValue("mixValue", mixValue);
    doneCurrent();
    update();

    QOpenGLWidget::keyPressEvent(event);
}

在构造函数中初始化6个QVector3D类型的变量；同时变量m_time开始计时；

在paintGL()函数中通过更改摄像机的位置来生成不同的观察矩阵，使摄像机达到随着时间流逝围绕场景转动的效果

//观察矩阵
QMatrix4x4 view; //创建单位矩阵
const float radius = 10.0f;
float time = m_time.elapsed()/1000.0; //elapsed()函数：从start开始到现在一共经历了多少毫秒
float camX = sin(time) * radius;
float camZ = cos(time) * radius;
view.lookAt(QVector3D(camX, 0.0, camZ), m_cameraTarget, m_up);
m_shaderProgram.setUniformValue("view", view);

下面这行代码使用三角学的知识来计算每一帧的x和z坐标，预先设定圆的半径radius，QVector3D(camX, 0.0, camZ)表示圆上的一点；随着时间的流逝，会遍历圆上所有的点，这样摄像机就会绕着场景旋转了

float camX = sin(time) * radius;
float camZ = cos(time) * radius;

运行结果如下：

二、自由移动

下面用键盘上A、S、D、W键来控制摄像机移动

更改myopenglwidget.h代码如下，新定义一个方向向量 m_cameraFront：

#ifndef MYOPENGLWIDGET_H
#define MYOPENGLWIDGET_H
#include <QOpenGLWidget>
#include <QOpenGLFunctions_3_3_Core>
#include <QOpenGLShaderProgram>
#include <QOpenGLTexture>
#include <QTimer>
#include <QTime>

class MyOpenGLWidget : public QOpenGLWidget,QOpenGLFunctions_3_3_Core
{
    Q_OBJECT

public:
    explicit MyOpenGLWidget(QWidget *parent = nullptr);
    ~MyOpenGLWidget();

protected:
    virtual void initializeGL();
    virtual void resizeGL(int w, int h);
    virtual void paintGL();

    void keyPressEvent(QKeyEvent *event);

private slots:
    void onTimeout();

private:
    QOpenGLShaderProgram m_shaderProgram;
    QOpenGLTexture *m_textureWall;
    QOpenGLTexture *m_textureSmile;
    QOpenGLTexture *m_textureSmall;

    float mixValue = 0.5;

    QTimer m_timer;
    QTime m_time;

    QVector3D m_cameraPos;
    QVector3D m_cameraTarget;
    QVector3D m_cameraDirection;
    QVector3D m_up;
    QVector3D m_cameraRight;
    QVector3D m_cameraUp;
    QVector3D m_cameraFront;
};

#endif // MYOPENGLWIDGET_H

更改myopenglwidget.cpp代码如下：

#include "myopenglwidget.h"
#include <QDebug>
#include <QKeyEvent>

unsigned int VBO; //顶点缓冲对象
unsigned int VAO; //顶点数组对象
unsigned int EBO; //元素缓冲对象

#define TIMEOUTMSEC 100

MyOpenGLWidget::MyOpenGLWidget(QWidget *parent) : QOpenGLWidget(parent)
{
    setFocusPolicy(Qt::StrongFocus);

    //位置
    m_cameraPos = QVector3D(0.0f, 0.0f, 3.0f);

    //方向
    m_cameraTarget = QVector3D(0.0f, 0.0f, 0.0f);
    m_cameraDirection = m_cameraPos - m_cameraTarget;
    m_cameraDirection.normalize(); //单位向量

    //右向量
    m_up = QVector3D(0.0f, 1.0f, 0.0f);
    m_cameraRight = QVector3D::crossProduct(m_up, m_cameraDirection); //叉乘，右向量
    m_cameraRight.normalize(); //单位向量

    //上向量
    m_cameraUp = QVector3D::crossProduct(m_cameraDirection, m_cameraRight); //叉乘，上向量
    m_cameraFront = QVector3D(0.0, 0.0, -1.0);

    connect(&m_timer, &QTimer::timeout, this, &MyOpenGLWidget::onTimeout);
    m_timer.start(TIMEOUTMSEC); //ms
    m_time.start(); //开始计时
}

MyOpenGLWidget::~MyOpenGLWidget()
{
    if(m_timer.isActive())
        m_timer.stop();

    makeCurrent();
    glDeleteBuffers(1, &VBO);
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &EBO);
    doneCurrent();
}

void MyOpenGLWidget::onTimeout()
{
    update();
}

void MyOpenGLWidget::initializeGL()
{
    //初始化OpenGL函数
    initializeOpenGLFunctions();

    //创建VBO，并赋予ID
    glGenBuffers(1, &VBO);
    //绑定VBO对象
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    //顶点数据
    float vertices[] = {
         //位置                //纹理
        -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
         0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
        -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,

        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
         0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
        -0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,

        -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
        -0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
        -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,

         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
         0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
         0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
         0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,

        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
         0.5f, -0.5f, -0.5f,  1.0f, 1.0f,
         0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
         0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,

        -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
        -0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
        -0.5f,  0.5f, -0.5f,  0.0f, 1.0f
    };
    //把顶点数据复制到显存中
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    //创建VAO对象，并赋予ID
    glGenVertexArrays(1, &VAO);
    //绑定VAO对象
    glBindVertexArray(VAO);

    //创建EBO对象，并赋予ID
    glGenBuffers(1, &EBO);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    unsigned int indices[] = {
                               0, 1, 3, //第一个三角形
                               1, 2, 3 //第二个三角形
                             };
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

    //位置属性
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0); //开启VAO管理的第一个属性值

    //纹理属性
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
    glEnableVertexAttribArray(1); //开启VAO管理的第三个属性值

    //解绑VBO
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    //解绑VAO
    glBindVertexArray(0);

    //创建一个程序对象
    m_shaderProgram.addShaderFromSourceFile(QOpenGLShader::Vertex,":/shaders/shapes.vert");
    m_shaderProgram.addShaderFromSourceFile(QOpenGLShader::Fragment,":/shaders/shapes.frag");
    bool success = m_shaderProgram.link();
    if(!success)
        qDebug()<<"ERR:" << m_shaderProgram.log();

    m_shaderProgram.bind();
    m_shaderProgram.setUniformValue("vertexColor", 0.0, 1.0, 0.0, 1.0);

    m_textureWall = new QOpenGLTexture(QImage(":/images/wall.jpg").mirrored()); //mirrored消除镜像
    m_shaderProgram.setUniformValue("textureWall", 0); //把纹理单元传给片段着色器中的采样器

    m_textureSmile = new QOpenGLTexture(QImage(":/images/awesomeface.png").mirrored()); //mirrored消除镜像
    m_shaderProgram.setUniformValue("textureSmile", 1); //把纹理单元传给片段着色器中的采样器

    m_textureSmall = new QOpenGLTexture(QImage(":/images/small.png").mirrored()); //mirrored消除镜像
    m_shaderProgram.setUniformValue("textureSmall", 2); //把纹理单元传给片段着色器中的采样器

    m_shaderProgram.setUniformValue("mixValue", mixValue);
}

void MyOpenGLWidget::resizeGL(int w, int h)
{
    Q_UNUSED(w);

    Q_UNUSED(h);
    //glViewport(0, 0, w, h);
}

QVector<QVector3D> cubePositions=
{
    QVector3D( 0.0f, 0.0f, 0.0f),
    QVector3D( 2.0f, 5.0f, -15.0f),
    QVector3D(-1.5f, -2.2f, -2.5f),
    QVector3D(-3.8f, -2.0f, -12.3f),
    QVector3D( 2.4f, -0.4f, -3.5f),
    QVector3D(-1.7f, 3.0f, -7.5f),
    QVector3D( 1.3f, -2.0f, -2.5f),
    QVector3D( 1.5f, 2.0f, -2.5f),
    QVector3D( 1.5f, 0.2f, -1.5f),
    QVector3D(-1.3f, 1.0f, -1.5f)
};

void MyOpenGLWidget::paintGL()
{
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f); //设置墨绿色背景
    glEnable(GL_DEPTH_TEST); //打开深度缓冲区
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清空

    float time = m_time.elapsed()/1000.0;

    //观察矩阵
    QMatrix4x4 view; //创建单位矩阵
    view.lookAt(m_cameraPos, m_cameraPos + m_cameraFront, m_up);
    m_shaderProgram.setUniformValue("view", view);

    //投影矩阵
    QMatrix4x4 projection; //创建单位矩阵
    projection.perspective(45.0f, (float)width()/height(), 0.1f, 100.0f); //透视投影
    m_shaderProgram.setUniformValue("projection", projection);

    //绘制
    m_shaderProgram.bind(); //激活程序对象
    glBindVertexArray(VAO); //绑定VAO
    m_textureWall->bind(0); //绑定激活纹理单元0
    m_textureSmile->bind(1); //绑定激活纹理单元1
    m_textureSmall->bind(2); //绑定激活纹理单元2

    foreach(auto item, cubePositions)
    {
        //模型矩阵
        QMatrix4x4 model; //创建单位矩阵
        model.translate(item); //移动
        model.rotate(time, 1.0f, 1.f, 0.0f); //绕向量(1.0f, 1.f, 0.0f)旋转
        m_shaderProgram.setUniformValue("model", model); //传给顶点着色器
        glDrawArrays(GL_TRIANGLES, 0, 36); //绘图
    }
}

void MyOpenGLWidget::keyPressEvent(QKeyEvent *event)
{
    float cameraSpeed = 2.5 * TIMEOUTMSEC / 1000.0;

    switch (event->key()) {
    case Qt::Key_Up: mixValue += 0.1; break;
    case Qt::Key_Down: mixValue -= 0.1; break;
    case Qt::Key_W: m_cameraPos += cameraSpeed * m_cameraFront; break;
    case Qt::Key_S: m_cameraPos -= cameraSpeed * m_cameraFront; break;
    case Qt::Key_D: m_cameraPos += cameraSpeed * m_cameraRight; break;
    case Qt::Key_A: m_cameraPos -= cameraSpeed * m_cameraRight; break;
    default: break;
    }

    if(mixValue > 1.0)
        mixValue = 1.0;

    if(mixValue < 0.0)
        mixValue = 0.0;

    makeCurrent();
    m_shaderProgram.setUniformValue("mixValue", mixValue);
    doneCurrent();
    update();

    QOpenGLWidget::keyPressEvent(event);
}

首先，进行宏定义

#define TIMEOUTMSEC 100

更改一下定时器

m_timer.start(TIMEOUTMSEC);

方向向量初始化，使摄像机一直向前看

m_cameraFront = QVector3D(0.0, 0.0, -1.0);

更改观察矩阵，把摄像机位置设置为之前定义的m_cameraPos，方向是当前的位置加上新定义的方向向量m_cameraFront，这样能够保证无论怎么移动，摄像机都会注视着目标方向。

//观察矩阵
QMatrix4x4 view; //创建单位矩阵
view.lookAt(m_cameraPos, m_cameraPos + m_cameraFront, m_up);
m_shaderProgram.setUniformValue("view", view);

更改keyPressEvent()函数代码，使键盘上A、S、D、W键起作用

//移动步长
float cameraSpeed = 2.5 * TIMEOUTMSEC / 1000.0;

switch (event->key())
{
    case Qt::Key_Up: mixValue += 0.1; break;
    case Qt::Key_Down: mixValue -= 0.1; break;
    case Qt::Key_W: m_cameraPos += cameraSpeed * m_cameraFront; break;
    case Qt::Key_S: m_cameraPos -= cameraSpeed * m_cameraFront; break;
    case Qt::Key_D: m_cameraPos += cameraSpeed * m_cameraRight; break;
    case Qt::Key_A: m_cameraPos -= cameraSpeed * m_cameraRight; break;
    default: break;
}

2.5是固定步长，当只有固定步长时，一直按着某一个键，刷新速度快的机器移动速度就快，为了消除不同机器的影响，使移动速度都一样，使固定步长乘以定时器刷新时间（TIMEOUTMSEC是毫秒，除以1000变成秒）（定时器刷新时间可以当做机器刷新时间）

当向前或向后移动时，把位置向量加减方向向量；左右移动时，把位置向量加减右向量（对右向进行量标准化是为了匀速移动）；

运行程序，使用WASD键可以控制摄像机移动，摄像机一直看着前方

三、视角移动

通过鼠标改变方向向量m_cameraFront，来改变摄像机的视角

1、欧拉角

欧拉角（Euler Angle）是可以表示3D空间中任何旋转的3个值，由莱昂哈德·欧拉在18世纪提出，一共有3中欧拉角：俯仰角（Pitch）、偏航角（Yaw）和滚转角（Roll），如下图所示：

  • 第一张图片展示俯仰角，俯仰角是描述如何往上或往下看的角；
  • 第二张图片展示偏航角，偏航角是描述如何往左或往右看的角；
  • 第三张图片展示滚转角，滚转角是描述如何翻滚摄像机。
  • 把三个角结合起来就能够计算3D空间中任何的旋转向量。在摄像机系统，只关心俯仰角和偏航角。

上图中把斜边边长定义为1，领边的长度是

对边边长是

这样这样获得了能够得到x和y方向长度的通用公式，它们取决于所给的角度，使用它来计算方向向量的分量：

这个三角形看起来和前面的三角形很像，所以如果我们想象自己在xz平面，看向y轴，我们可以基于第一个三角形来计算它的长度/y方向的强度（我们往上或往下看多少），从图中可以看到对于一个给定俯仰角的y值等于sinθ：

cameraFront.setY(sin(pitch*PI/180)); //先把角度转为弧度

这里只更新了y值，仔细观察x和z分量也被影响l，从三角形中我们可以看到它们的值等于：

cameraFront.setX(cos(pitch*PI/180));
cameraFront.setZ(cos(pitch*PI/180));

看看我们能否为偏航角找到需要的分量：

就像俯仰角三角形一样，我们可以看到x分量取决于cos(yaw)的值，z值同样取决于偏航角的正弦值。把这个加到前面的值中，会得到基于俯仰角和偏航角的方向向量：

cameraFront.setX(cos(yaw*PI/180) * cos(pitch*PI/180));
cameraFront.setY(sin(pitch*PI/180));
cameraFront.setZ(sin(yaw*PI/180) * cos(pitch*PI/180));

这样就有了一个可以把俯仰角和偏航角转化为用来自由旋转视角的摄像机的3维方向向量了。

2、鼠标输入

在myopenglwidget.h中重载鼠标事件：

void mouseMoveEvent(QMouseEvent *event);

在myopenglwidget.cpp的构造函数的上面定义两个全局变量

float PI = 3.1415926; //π值
QPoint deltaPos; //上次鼠标的差值

在myopenglwidget.cpp的构造函数中捕获鼠标事件

setMouseTracking(true);

mouseMoveEvent()函数代码

void MyOpenGLWidget::mouseMoveEvent(QMouseEvent *event)
{
    static float yaw = -90; //偏航角默认-90度
    static float pitch = 0;
    static QPoint lastPos(width()/2,height()/2); //上一帧鼠标的位置，初始化为屏幕中心
    
    auto currentPos = event->pos(); //当前帧的鼠标位置
    deltaPos = currentPos - lastPos; //当前帧和上一帧鼠标位置的偏移量
    lastPos = currentPos;
    
    float sensitivity = 0.1f; //灵敏度
    deltaPos *= sensitivity;
    
    yaw += deltaPos.x();
    pitch -= deltaPos.y();
    
    //限制范围
    if(pitch > 89.0f) pitch = 89.0f;
    if(pitch < -89.0f) pitch = -89.0f;

    //通过俯仰角和偏航角来计算得到真正的方向向量
    m_cameraFront.setX(cos(yaw*PI/180) * cos(pitch*PI/180));
    m_cameraFront.setY(sin(pitch*PI/180));
    m_cameraFront.setZ(sin(yaw*PI/180) * cos(pitch*PI/180));
    m_cameraFront.normalize();

    update();
}

运行程序，通过鼠标的移动可以控制摄像头向上、下、左或右转动：

3、缩放

之前的教程中视野（Field of View） 或fov定义了我们可以看到场景中多大的范围，当视野变小时，场景投影出来的空间就会减小，产生放大（Zoom In）的感觉。

在myopenglwidget.h中重载鼠标滚轮事件：

void wheelEvent(QWheelEvent *event);

在myopenglwidget.cpp的构造函数的上面定义一个全局变量

float fov = 45.0;

添加鼠标滚轮事件代码

void MyOpenGLWidget::wheelEvent(QWheelEvent *event)
{
    if(fov >= 1.0f && fov <= 75.0f)
        fov -= event->angleDelta().y()/120;//一步是120
    if(fov <= 1.0f) fov = 1.0f;
    if(fov >= 75.0f) fov = 75.0f;

    update();
}

运行程序，通过鼠标滚轮控制视野的放大或缩小：

四、摄像机类

把camera.h拷贝到项目目录下

#ifndef CAMERA_H
#define CAMERA_H

#include<QMatrix4x4>

#include <vector>

// 移动方向枚举量. 是一种抽象，以避开特定于窗口系统的输入方法
// 我们这里是WSAD
enum Camera_Movement {
    FORWARD,
    BACKWARD,
    LEFT,
    RIGHT
};

// 默认值
const float YAW         = -90.0f;
const float PITCH       =  0.0f;
const float SPEED       =  2.5f;
const float SENSITIVITY =  0.1f;
const float ZOOM        =  45.0f;


// 一个抽象的camera类，用于处理输入并计算相应的Euler角度、向量和矩阵，以便在OpenGL中使用
class Camera
{
public:
    // camera Attributes
    QVector3D Position;
    QVector3D Front;
    QVector3D Up;
    QVector3D Right;
    QVector3D WorldUp;
    // euler Angles
    float Yaw;
    float Pitch;
    // camera options
    float MovementSpeed;
    float MouseSensitivity;
    float Zoom;

    // constructor with vectors
    Camera(QVector3D position = QVector3D(0.0f, 0.0f, 0.0f), QVector3D up = QVector3D(0.0f, 1.0f, 0.0f), float yaw = YAW, float pitch = PITCH) : Front(QVector3D(0.0f, 0.0f, -1.0f)), MovementSpeed(SPEED), MouseSensitivity(SENSITIVITY), Zoom(ZOOM)
    {
        Position = position;
        WorldUp = up;
        Yaw = yaw;
        Pitch = pitch;
        updateCameraVectors();
    }
    // constructor with scalar values
    Camera(float posX, float posY, float posZ, float upX, float upY, float upZ, float yaw, float pitch) : Front(QVector3D(0.0f, 0.0f, -1.0f)), MovementSpeed(SPEED), MouseSensitivity(SENSITIVITY), Zoom(ZOOM)
    {
        Position = QVector3D(posX, posY, posZ);
        WorldUp = QVector3D(upX, upY, upZ);
        Yaw = yaw;
        Pitch = pitch;
        updateCameraVectors();
    }

    // returns the view matrix calculated using Euler Angles and the LookAt Matrix
    QMatrix4x4 GetViewMatrix()
    {
        QMatrix4x4 theMatrix;
        theMatrix.lookAt(Position, Position + Front, Up);
        return theMatrix;
    }

    // 处理从任何类似键盘的输入系统接收的输入。接受摄像机定义枚举形式的输入参数（从窗口系统中提取）
    void ProcessKeyboard(Camera_Movement direction, float deltaTime)
    {
        float velocity = MovementSpeed * deltaTime;
        if (direction == FORWARD)
            Position += Front * velocity;
        if (direction == BACKWARD)
            Position -= Front * velocity;
        if (direction == LEFT)
            Position -= Right * velocity;
        if (direction == RIGHT)
            Position += Right * velocity;
    }

    // 处理从鼠标输入系统接收的输入。需要x和y方向上的偏移值。
    void ProcessMouseMovement(float xoffset, float yoffset, GLboolean constrainPitch = true)
    {
        xoffset *= MouseSensitivity;
        yoffset *= MouseSensitivity;

        Yaw   += xoffset;
        Pitch += yoffset;

        // 确保当投球超出边界时，屏幕不会翻转
        if (constrainPitch)
        {
            if (Pitch > 89.0f)
                Pitch = 89.0f;
            if (Pitch < -89.0f)
                Pitch = -89.0f;
        }

        // 使用更新的Euler角度更新前、右和上矢量
        updateCameraVectors();
    }

    // 处理从鼠标滚轮事件接收的输入。仅需要在垂直车轮轴上输入
    void ProcessMouseScroll(float yoffset)
    {
        Zoom -= (float)yoffset;
        if (Zoom < 1.0f)
            Zoom = 1.0f;
        if (Zoom > 75.0f)
            Zoom = 75.0f;
    }

private:
    // 根据相机的（更新的）Euler角度计算前矢量
    void updateCameraVectors()
    {
        // calculate the new Front vector
        float PI=3.1415926;
        QVector3D front;
        front.setX(cos(Yaw*PI/180.0) * cos(Pitch*PI/180.0));
        front.setY( sin(Pitch*PI/180.0));
        front.setZ(sin(Yaw*PI/180.0) * cos(Pitch*PI/180.0));
        front.normalize();
        Front = front;
        // also re-calculate the Right and Up vector
        Right = QVector3D::crossProduct(Front, WorldUp);
        // 标准化向量，因为向上或向下看得越多，向量的长度就越接近0，这会导致移动速度变慢。
        Right.normalize();
        Up    = QVector3D::crossProduct(Right, Front);
        Up.normalize();
    }
};
#endif

右击项目名称，选择添加现有文件

选择camera.h

更改myopenglwidget.h中的代码，包含摄像机类头文件以及创建其类对象；删除掉QVector3D类型的变量

#ifndef MYOPENGLWIDGET_H
#define MYOPENGLWIDGET_H
#include <QOpenGLWidget>
#include <QOpenGLFunctions_3_3_Core>
#include <QOpenGLShaderProgram>
#include <QOpenGLTexture>
#include <QTimer>
#include <QTime>
#include "camera.h"

class MyOpenGLWidget : public QOpenGLWidget,QOpenGLFunctions_3_3_Core
{
    Q_OBJECT

public:
    explicit MyOpenGLWidget(QWidget *parent = nullptr);
    ~MyOpenGLWidget();

protected:
    virtual void initializeGL();
    virtual void resizeGL(int w, int h);
    virtual void paintGL();

    void keyPressEvent(QKeyEvent *event);
    void mouseMoveEvent(QMouseEvent *event);
    void wheelEvent(QWheelEvent *event);

private slots:
    void onTimeout();

private:
    QOpenGLShaderProgram m_shaderProgram;
    QOpenGLTexture *m_textureWall;
    QOpenGLTexture *m_textureSmile;
    QOpenGLTexture *m_textureSmall;

    float mixValue = 0.5;

    QTimer m_timer;
    QTime m_time;

    Camera m_camera;
};

#endif // MYOPENGLWIDGET_H

更改myopenglwidget.cpp中的代码

#include "myopenglwidget.h"
#include <QDebug>
#include <QKeyEvent>

unsigned int VBO; //顶点缓冲对象
unsigned int VAO; //顶点数组对象
unsigned int EBO; //元素缓冲对象

#define TIMEOUTMSEC 100

QPoint deltaPos;

MyOpenGLWidget::MyOpenGLWidget(QWidget *parent) : QOpenGLWidget(parent)
{
    setFocusPolicy(Qt::StrongFocus);
    setMouseTracking(true);

    m_camera.Position = QVector3D(0,0,3.0);

    connect(&m_timer, &QTimer::timeout, this, &MyOpenGLWidget::onTimeout);
    m_timer.start(TIMEOUTMSEC); //100ms
    m_time.start(); //开始计时
}

MyOpenGLWidget::~MyOpenGLWidget()
{
    if(m_timer.isActive())
        m_timer.stop();

    makeCurrent();
    glDeleteBuffers(1, &VBO);
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &EBO);
    doneCurrent();
}

void MyOpenGLWidget::onTimeout()
{
    update();
}

void MyOpenGLWidget::initializeGL()
{
    //初始化OpenGL函数
    initializeOpenGLFunctions();

    //创建VBO，并赋予ID
    glGenBuffers(1, &VBO);
    //绑定VBO对象
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    //顶点数据
    float vertices[] = {
         //位置                //纹理
        -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
         0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
        -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,

        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
         0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
        -0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,

        -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
        -0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
        -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,

         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
         0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
         0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
         0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,

        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
         0.5f, -0.5f, -0.5f,  1.0f, 1.0f,
         0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
         0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,

        -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
        -0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
        -0.5f,  0.5f, -0.5f,  0.0f, 1.0f
    };
    //把顶点数据复制到显存中
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    //创建VAO对象，并赋予ID
    glGenVertexArrays(1, &VAO);
    //绑定VAO对象
    glBindVertexArray(VAO);

    //创建EBO对象，并赋予ID
    glGenBuffers(1, &EBO);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    unsigned int indices[] = {
                               0, 1, 3, //第一个三角形
                               1, 2, 3 //第二个三角形
                             };
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

    //位置属性
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0); //开启VAO管理的第一个属性值

    //纹理属性
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
    glEnableVertexAttribArray(1); //开启VAO管理的第三个属性值

    //解绑VBO
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    //解绑VAO
    glBindVertexArray(0);

    //创建一个程序对象
    m_shaderProgram.addShaderFromSourceFile(QOpenGLShader::Vertex,":/shaders/shapes.vert");
    m_shaderProgram.addShaderFromSourceFile(QOpenGLShader::Fragment,":/shaders/shapes.frag");
    bool success = m_shaderProgram.link();
    if(!success)
        qDebug()<<"ERR:" << m_shaderProgram.log();

    m_shaderProgram.bind();
    m_shaderProgram.setUniformValue("vertexColor", 0.0, 1.0, 0.0, 1.0);

    m_textureWall = new QOpenGLTexture(QImage(":/images/wall.jpg").mirrored()); //mirrored消除镜像
    m_shaderProgram.setUniformValue("textureWall", 0); //把纹理单元传给片段着色器中的采样器

    m_textureSmile = new QOpenGLTexture(QImage(":/images/awesomeface.png").mirrored()); //mirrored消除镜像
    m_shaderProgram.setUniformValue("textureSmile", 1); //把纹理单元传给片段着色器中的采样器

    m_textureSmall = new QOpenGLTexture(QImage(":/images/small.png").mirrored()); //mirrored消除镜像
    m_shaderProgram.setUniformValue("textureSmall", 2); //把纹理单元传给片段着色器中的采样器

    m_shaderProgram.setUniformValue("mixValue", mixValue);
}

void MyOpenGLWidget::resizeGL(int w, int h)
{
    Q_UNUSED(w);

    Q_UNUSED(h);
    //glViewport(0, 0, w, h);
}

QVector<QVector3D> cubePositions=
{
    QVector3D( 0.0f, 0.0f, 0.0f),
    QVector3D( 2.0f, 5.0f, -15.0f),
    QVector3D(-1.5f, -2.2f, -2.5f),
    QVector3D(-3.8f, -2.0f, -12.3f),
    QVector3D( 2.4f, -0.4f, -3.5f),
    QVector3D(-1.7f, 3.0f, -7.5f),
    QVector3D( 1.3f, -2.0f, -2.5f),
    QVector3D( 1.5f, 2.0f, -2.5f),
    QVector3D( 1.5f, 0.2f, -1.5f),
    QVector3D(-1.3f, 1.0f, -1.5f)
};

void MyOpenGLWidget::paintGL()
{
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f); //设置墨绿色背景
    glEnable(GL_DEPTH_TEST); //打开深度缓冲区
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清空

    float time = m_time.elapsed()/1000.0;

    //观察矩阵
    QMatrix4x4 view; //创建单位矩阵
    view = m_camera.GetViewMatrix();
    m_shaderProgram.setUniformValue("view", view);

    //投影矩阵
    QMatrix4x4 projection; //创建单位矩阵
    projection.perspective(m_camera.Zoom, (float)width()/height(), 0.1, 100);
    m_shaderProgram.setUniformValue("projection", projection);

    //绘制
    m_shaderProgram.bind(); //激活程序对象
    glBindVertexArray(VAO); //绑定VAO
    m_textureWall->bind(0); //绑定激活纹理单元0
    m_textureSmile->bind(1); //绑定激活纹理单元1
    m_textureSmall->bind(2); //绑定激活纹理单元2

    foreach(auto item, cubePositions)
    {
        //模型矩阵
        QMatrix4x4 model; //创建单位矩阵
        model.translate(item); //移动
        model.rotate(time, 1.0f, 1.f, 0.0f); //绕向量(1.0f, 1.f, 0.0f)旋转
        m_shaderProgram.setUniformValue("model", model); //传给顶点着色器
        glDrawArrays(GL_TRIANGLES, 0, 36); //绘图
    }
}

void MyOpenGLWidget::keyPressEvent(QKeyEvent *event)
{
    //移动步长
    //float cameraSpeed = 2.5 * TIMEOUTMSEC / 1000.0;
    float deltaTime = TIMEOUTMSEC/1000.0;

    switch (event->key())
    {
        case Qt::Key_Up: mixValue += 0.1; break;
        case Qt::Key_Down: mixValue -= 0.1; break;
        case Qt::Key_W: m_camera.ProcessKeyboard(FORWARD, deltaTime); break;
        case Qt::Key_S: m_camera.ProcessKeyboard(BACKWARD, deltaTime); break;
        case Qt::Key_D: m_camera.ProcessKeyboard(RIGHT, deltaTime); break;
        case Qt::Key_A: m_camera.ProcessKeyboard(LEFT, deltaTime); break;
        default: break;
    }

    if(mixValue > 1.0)
        mixValue = 1.0;

    if(mixValue < 0.0)
        mixValue = 0.0;

    makeCurrent();
    m_shaderProgram.setUniformValue("mixValue", mixValue);
    doneCurrent();
    update();

    QOpenGLWidget::keyPressEvent(event);
}

void MyOpenGLWidget::mouseMoveEvent(QMouseEvent *event)
{
    static QPoint lastPos(width()/2,height()/2); //上一帧鼠标的位置，初始化为屏幕中心

    auto currentPos = event->pos(); //当前帧的鼠标位置
    deltaPos = currentPos - lastPos; //当前帧和上一帧鼠标位置的偏移量
    lastPos = currentPos;

    m_camera.ProcessMouseMovement(deltaPos.x(), -deltaPos.y());

    update();
}

void MyOpenGLWidget::wheelEvent(QWheelEvent *event)
{
    m_camera.ProcessMouseScroll(event->angleDelta().y()/120);

    update();
}

运行程序，键盘WASD控制摄像机移动，鼠标控制摄像机转向，鼠标滚轮控制缩放

注：观看OpenGL中文官网（https://learnopengl-cn.github.io/）和阿西拜的现代OpenGL入门（https://ke.qq.com/course/3999604#term_id=104150693）学习OpenGL

怎么追摩羯座
关注
专栏目录
【目标检测】基于yolov7的安全帽佩戴检测和识别(附代码和数据集，Ubuntu系统)
学无止境、积少成多、厚积薄发
04-04 1216
【目标检测】基于yolov7的安全帽佩戴检测和识别(附代码和数据集，Ubuntu系统)
「3D视觉技术交流群」精华帖与关键问题
3D视觉工坊
07-27 3470
原文首发于微信公众号3D视觉工坊： 「3D视觉技术交流群」精华帖与关键问题 本文主要总结了「3D视觉技术交流群」自建立以来，星球内共发布与交流过的技术帖及关键问题，以便大家回顾温习。 一 星球主题，主要包括： 1.1　２Ｄ视觉 １）相机标定； ２）图像处理基础； ３）相机与镜头 1.2　手眼标定 1.3　３Ｄ视觉 1.4　编程技巧 1.5　VSLAＭ，包括：ubuntu系统；VSLAM技术； 1...
QT与OPENGL二：用鼠标控制lookat视角
豆腐车
08-24 5104
单独控制lookat的左右，和上下比较容易，合在一起遇到了些问题，主要是涉及到了球坐标。 当按下鼠标时记录当前点坐标。 mousePoint.push(mousePressPosition); 当移动鼠标时计算移动差 mouseCurPosition = QVector2D(e-&amp;gt;localPos()); QVector2D offset; if (mo...
QT之OpenGL摄像机
weixin_41111116的博客
11-20 1210
QT之OpenGL摄像机
QT中学习Opengl---（摄像机）
比卡丘不皮的博客
03-16 1749
前言： 本文的代码是 LearnOpenGL 中对应代码，这里提供学习，大家喜欢的可去官方网站去看看:LearnOpenGL-CNhttps://learnopengl-cn.readthedocs.io/zh/latest/ 本章将要讲解摄像机的功效。 Camera OpenGL本身没有摄像机的概念， 但我们可以通过把场景中的所有物体往相反方向移动的方式来模拟出摄像机， 这样感觉就像我们在移动， 而不是场景在移动。 如下图： 定义一个摄像机， 我们需要一个摄像机在世界空间中...
Osg getLookAt 函数
kasteluo的专栏
08-10 1097
使用OSG的人都知道，OSG的坐标系数为：右手系，+z 向上。但若不设置Camera朝向，相机是俯看地面的。 原因就在于OSG的相机将初始方向设置为：+y 向上，+z 向前。 OSG 相机坐标系： +y +Z | / | /   |  /   | /   |/__________ +x OSG 世界坐标系： +z +y | / | /   |  /
[OpenGL] 视图矩阵（View）矩阵与glm::lookAt函数源码解析
weixin_44179561的博客
04-13 9502
一、视图矩阵（View）矩阵 首先明确视图矩阵的作用：在OpenGL的众多坐标系中，存在一个世界坐标系和一个摄像机坐标系，视图矩阵的作用就是将世界坐标系内的坐标转换成摄像机坐标系内的坐标。 如图，空间中存在一个点 PPP，它在世界坐标系内的坐标为(Xw,Yw,Zw)(X_w,Y_w,Z_w)(Xw​,Yw​,Zw​)，在摄像机坐标系内的坐标为(Xc,Yc,Zc)(X_c,Y_c,Z_c)(Xc​,Yc​,Zc​)，在视图矩阵的转换下，存在如下等式： [XcYcZc1]=View[XwYwZw1] \be
iOS 6 Programming Cookbook第13章_照相机和图片库
05-30
例如，iPhone 5配备了前后双摄像头，而早期型号如iPhone 3G和3GS仅配备了一个后置摄像头。 - **权限检查**：确保应用程序获得了用户的授权，才能访问摄像头。使用`AVCaptureDevice`类的`hasPermission`方法来检查...
SfM多视图三维点云重建【VS2015+OpenCV3.4+PLC1.8】–完整工程文件
03-12
2. **摄像机姿态估计**：利用匹配的特征点，我们可以使用RANSAC（随机样本一致性）或其他稳健的估计方法来估计相机的相对姿态，即旋转和平移矩阵。 3. **构建本质矩阵和单应性矩阵**：根据匹配的特征点，可以计算...
Ogre个人初步学习总结
a100214225的博客
07-28 576
Ogre个人初步学习总结 目录 1.开发环境 2.环境配置 2.1Ogre环境配置 2.2ParticleUniverse环境配置 3.OGRE的学习札记 3.1Ogre的学前准备 3.1.1Ogre1.8.1的Sample事例分析 3.1.2熟悉Ogre的第一个的项目 3.1.3编写Ogre的样例的注意事项 3.2Ogre的基本知识 3.2.1Ogre场景内的坐标 3.2.2利用Ogre生成Entity实体 3.2.3Ogre中的节点SceneNode 3.2...
QT框架下的OpenGL使用---复现篇---摄像机
weixinhum
08-13 2733
QT框架下的OpenGL使用—复现篇—摄像机 OpenGL编程中，始终会用到的除了顶点和着色器外，应该就属摄像机了。 在QT封装的OpenGL中，可以通过QMatrix4x4这个类来设置摄像机的各种参数，其中最为基础的两个函数为perspective及lookAt。 perspective函数 用于设置摄像头自身的信息，有四个参数，含义如下： 参数一：视角大小(度数) 参数二：视角的宽长比 参数三：近平面距离 参数四：远平面距离 通过设置视角的大小，我们可以模拟出远近的效果。例如在近距离下，我们能看到的东西
Qt实现OpenGL的经典教程⑦——摄像机
最新发布
qq_45233572的博客
04-24 1318
Qt版本：6.7操作系统：Windows10。
【OpenGL学习笔记⑦】——键盘控制镜头的平移【3D正方体 透视投影 观察矩阵 对LookAt的理解】
热门推荐
Wang_Dou_Dou_的博客
10-25 1万+
关键词：OpenGL、键盘控制、透视投影、观察矩阵、LookAt、摄影机Camera类。
14.opengl-qt显示多个立方体(添加摄像机)
抵抗时间扭曲，坚持做一件有意义的事
03-23 1424
参考摄像机 - LearnOpenGL CN 本章demo效果如下所示(代码已上传至opengl技术交流群:929155430): 1.摄像机介绍 摄像机用来在3D场景中随意移动的东西,需要用到鼠标和键盘输入来控制摄像机方向和姿态.如下图所示: 2.实现一个摄像机 首先定义一个摄像机位置,然后获取一个摄影机指向原点的向量,并且获取指向摄像机的单位向量(只关心摄像机的方向,不关心其长度).代码如下所示: QVector3D cameraPos(0, 0, 3); QVector3.
推导LookAt函数定义的视图矩阵
WhoisPo的专栏
09-10 3565
在OpenGL中需要定义一个视图(view)矩阵，很多库都提供一个叫LookAt的函数，可以定义该视图矩阵。 该函数的原型是 Mat4x4 LookAt(pos: vector3D, target: vector3D, up:vector3D) 直观的理解，就是pos为观察者当前的坐标，target朝向的点坐标，up为观察者上方方向。返回的就是一个视图矩阵。 其实所谓的视图矩阵，就是一个坐标系与坐标系之间的转换矩阵。视图矩阵将世界坐标系下的坐标转换到了视图坐标系下。 我们来推导一下三维坐标系转换的关系
右手坐标系下LookAt视图矩阵的推导
weixin_33875564的博客
03-14 462
基本知识 右手坐标系 右手手掌弯曲，手指方向由正X轴指向正Y轴，如果这时Z轴正方向与大拇指方向保持一致，坐标系为右手坐标系，否则为左手坐标系。 向量叉乘的方向 向量(1,0,0)与向量(0,1,0)叉乘的结果可以由公式计算得到为(0,0,1),在数值上它是始终不变的。但放在坐标中进行解释，(0,0,1)都是代表Z轴正方向，但在左右手坐标系中他们与X,Y轴正方向的相对空间位置是不同的。在...
QT调用D3D绘制旋转三角形
迎风的舵手
12-30 4381
我的环境是win7+Qt5.1 之前在网上找了一些例子, 怎么调试都不出来. 原来是窗口属性的问题. 解决方法: 网上的例子: setAttribute(Qt::WA_PaintOnScreen, true); Note: This flag is only supported on X11 and it disables double buffering. 看文档发现这个属性只能用于X
OpenGL lookat 函数 c++
chrisfxs的专栏
07-24 3935
参考原文：http://games.greggman.com/game/webgl-3d-cameras/
天优家教手机版 v1.8.1 - 新一代安卓教育学习应用
资源摘要信息: "安卓应用-教育学习-天优家教手机版 v1.8.1 安卓版.zip" 该资源名称表明它是一款安卓平台上的教育学习类应用程序，名为“天优家教”，其版本为1.8.1。该应用程序被归档为一个ZIP文件，以便于存储和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值