zoukankan      html  css  js  c++  java
  • 摄像机

    一、使用lookat函数处理摄像头问题

    widget需要做一些修改,支持按钮wsadqe改变摄像头视角,鼠标左键和滚轮也可以改变位置

    #include "widget.h"
    #include "ui_widget.h"
    
    GLuint VBO, VAO, EBO;
    
    Widget::Widget()
    {
        cameraPos = QVector3D(0.0f, 0.0f, 3.0f);
        cameraFront = QVector3D(0.0f, 0.0f, -1.0f);
        cameraUp = QVector3D(0.0f, 1.0f, 0.0f);
        deltaTime = 0.0f;
        lastFrame = 0.0f;
    
        firstMouse = true;
        yaw = -90.0f;
        pitch = 0.0f;
        lastX = 800.0f / 2.0;
        lastY = 600.0 / 2.0;
        fov = 45.0f;
    }
    
    Widget::~Widget()
    {
        delete ourShader;
        core->glDeleteVertexArrays(1, &VAO);
        core->glDeleteBuffers(1, &VBO);
        core->glDeleteBuffers(1, &EBO);
        texture1->destroy();
        texture2->destroy();
    }
    
    void Widget::initializeGL()
    {
        //着色器部分
        core = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_3_3_Core>();
        if (!core) {
              qWarning() << "Could not obtain required OpenGL context version";
              exit(1);
        }
        ourShader = new Shader(":/shader/vertexshadersource.vert", ":/shader/fragmentshadersource.frag");
    
        //VAO,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
        };
    
        GLuint indices[] = {
            0, 1, 3, // first triangle
            1, 2, 3  // second triangle
        };
    
    
        core->glGenVertexArrays(1, &VAO);
        core->glGenBuffers(1, &VBO);
        core->glGenBuffers(1, &EBO);
    
        core->glBindVertexArray(VAO);
    
        core->glBindBuffer(GL_ARRAY_BUFFER, VBO);
        core->glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    
    //    core->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    //    core->glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
        //position attribute
        core->glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5*sizeof(GLfloat), nullptr);
        core->glEnableVertexAttribArray(0);
        //texture coord attribute
        core->glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5*sizeof(GLfloat), (void*)(3 * sizeof(float)));
        core->glEnableVertexAttribArray(1);
        //纹理1
        texture1 = new QOpenGLTexture(QImage(":/image/box.jpg").mirrored(), QOpenGLTexture::GenerateMipMaps); //直接生成绑定一个2d纹理, 并生成多级纹理MipMaps
        if(!texture1->isCreated()) {
            qDebug()<<"Failed to load texture" << endl;
        }
        texture1->setWrapMode(QOpenGLTexture::DirectionS, QOpenGLTexture::Repeat);
        texture1->setWrapMode(QOpenGLTexture::DirectionT, QOpenGLTexture::Repeat);
    
        texture1->setMinificationFilter(QOpenGLTexture::Linear);
        texture1->setMagnificationFilter(QOpenGLTexture::Linear);
        texture1->setFormat(QOpenGLTexture::RGBFormat);
    
        texture2 = new QOpenGLTexture(QImage(":/image/smile.png").mirrored(), QOpenGLTexture::GenerateMipMaps); //直接生成绑定一个2d纹理, 并生成多级纹理MipMaps
        if(!texture2->isCreated()) {
            qDebug()<<"Failed to load texture" << endl;
        }
        texture2->setWrapMode(QOpenGLTexture::DirectionS, QOpenGLTexture::Repeat);
        texture2->setWrapMode(QOpenGLTexture::DirectionT, QOpenGLTexture::Repeat);
    
        texture2->setMinificationFilter(QOpenGLTexture::Linear);
        texture2->setMagnificationFilter(QOpenGLTexture::Linear);
        texture2->setFormat(QOpenGLTexture::RGBFormat);
        ourShader->use();
        ourShader->shaderProgram.setUniformValue("texture1", 0);
        ourShader->shaderProgram.setUniformValue("texture2", 1);
        mtime.start();
    
        core->glEnable(GL_DEPTH_TEST);
    }
    
    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 Widget::paintGL()
    {
        deltaTime = (GLfloat)mtime.elapsed()/100 - lastFrame;
        lastFrame = (GLfloat)mtime.elapsed()/100;
    
        core->glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        core->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
        ourShader->use();
        core->glActiveTexture(GL_TEXTURE1);
        texture2->bind();
        core->glActiveTexture(GL_TEXTURE0);
        texture1->bind();    
    
        QMatrix4x4 view, projection;
        view.translate(QVector3D(0.0f, 0.0f, -3.0f));
        projection.perspective(fov, (GLfloat)width()/(float)height(), 0.1f, 100.0f);
        ourShader->use();
        ourShader->shaderProgram.setUniformValue("view", view);
        ourShader->shaderProgram.setUniformValue("projection", projection);
    
    //    ourShader->use();
        view.lookAt(cameraPos, cameraPos+cameraFront, cameraUp);
        ourShader->shaderProgram.setUniformValue("view", view);
        core->glBindVertexArray(VAO);
    
        for(unsigned int i=0;i<10;i++) {
            QMatrix4x4 model;
            model.translate(cubePositions[i]);
            if(i%3 == 0) {
                float angle = 20.0f*i + (float)mtime.elapsed()/10;
                model.rotate(angle, QVector3D(0.5f, 1.0f, 0.0f));
            }
            ourShader->shaderProgram.setUniformValue("model", model);
            core->glDrawArrays(GL_TRIANGLES, 0, 36);
        }
    
        update();
    }
    
    void Widget::resizeGL(int w, int h)
    {
        core->glViewport(0, 0, w, h);
    }
    
    void Widget::keyPressEvent(QKeyEvent *event)
    {
        GLfloat cameraSpeed = 2.5 * deltaTime;
        if(event->key() == Qt::Key_W) {
            cameraPos -= cameraFront * cameraSpeed;
        }
    
        if(event->key() == Qt::Key_S) {
            cameraPos += cameraFront * cameraSpeed;
        }
    
        if(event->key() == Qt::Key_A) {
            cameraPos -= (QVector3D::crossProduct(cameraFront, cameraUp).normalized()) * cameraSpeed;
        }
    
        if(event->key() == Qt::Key_D) {
            cameraPos += (QVector3D::crossProduct(cameraFront, cameraUp).normalized()) * cameraSpeed;
        }
        if(event->key() == Qt::Key_E) {
            cameraPos += cameraUp * cameraSpeed;
        }
        if(event->key() == Qt::Key_Q) {
            cameraPos -= cameraUp * cameraSpeed;
        }
    }
    
    void Widget::mouseMoveEvent(QMouseEvent *event)
    {
        GLfloat xpos = event->pos().x();
        GLfloat ypos = event->pos().y();
        if (firstMouse) {
            lastX = event->pos().x();
            lastY = event->pos().y();
            firstMouse = false;
        }
    
        GLfloat xoffset = xpos - lastX;
        GLfloat yoffset = lastY - ypos; // reversed since y-coordinates go from bottom to top
        lastX = xpos;
        lastY = ypos;
    
        GLfloat sensitivity = 0.01f; // change this value to your liking
        xoffset *= sensitivity;
        yoffset *= sensitivity;
    
        yaw += xoffset;
        pitch += yoffset;
    
        // make sure that when pitch is out of bounds, screen doesn't get flipped
        if (pitch > 89.0f)
            pitch = 89.0f;
        if (pitch < -89.0f)
            pitch = -89.0f;
    
        QVector3D front(cos(yaw) * cos(pitch), sin(pitch), sin(yaw) * cos(pitch));
        cameraFront = front.normalized();
    }
    
    void Widget::wheelEvent(QWheelEvent *event)
    {
        QPoint offset = event->angleDelta();
        if(fov >= 1.0f && fov <=45.0f)
            fov -= ((GLfloat)offset.y())/20;
        if(fov < 1.0f)
            fov = 1.0f;
        if(fov > 45.0f)
            fov = 45.0f;
    }
    widget.cpp

    h文件中多了一些变量

    #ifndef WIDGET_H
    #define WIDGET_H
    
    #include <QWidget>
    #include <QGLWidget>
    #include <QOpenGLShader>
    #include <QOpenGLShaderProgram>
    #include <QDebug>
    #include <QOpenGLFunctions>
    #include <QOpenGLFunctions_3_3_Core>
    #include <QTime>
    #include <QtMath>
    #include <QTimer>
    #include <QOpenGLTexture>
    #include <QKeyEvent>
    
    #include "shader.h"
    
    namespace Ui {
    class Widget;
    }
    
    class Widget : public QGLWidget
    {
        Q_OBJECT
    
    public:
        Widget();
        ~Widget();
    public slots:
    
    protected:
        virtual void initializeGL();
        virtual void paintGL();
        virtual void resizeGL(int w, int h);
        virtual void keyPressEvent(QKeyEvent *event);
        virtual void mouseMoveEvent(QMouseEvent *event);
        virtual void wheelEvent(QWheelEvent *event);
    
    private:
        QOpenGLFunctions_3_3_Core *core;
        QOpenGLTexture *texture1, *texture2;
        Shader *ourShader;
        QTimer updateTimer;
        QTime mtime;
        QVector3D cameraPos;
        QVector3D cameraFront;
        QVector3D cameraUp;
        GLfloat deltaTime;
        GLfloat lastFrame;
    
        GLboolean firstMouse;
        GLfloat yaw;
        GLfloat pitch;
        GLfloat lastX;
        GLfloat lastY;
        GLfloat fov;
    };
    
    #endif // WIDGET_H
    widget.h
    • 看看你是否能够修改摄像机类,使得其能够变成一个真正的FPS摄像机(也就是说不能够随意飞行);你只能够呆在xz平面上:

      void Widget::keyPressEvent(QKeyEvent *event)
      {
          GLfloat cameraSpeed = 2.5 * deltaTime;
          if(event->key() == Qt::Key_W) {
              cameraPos -= cameraFront * cameraSpeed;
          }
      
          if(event->key() == Qt::Key_S) {
              cameraPos += cameraFront * cameraSpeed;
          }
      
          if(event->key() == Qt::Key_A) {
              cameraPos -= (QVector3D::crossProduct(cameraFront, cameraUp).normalized()) * cameraSpeed;
          }
      
          if(event->key() == Qt::Key_D) {
              cameraPos += (QVector3D::crossProduct(cameraFront, cameraUp).normalized()) * cameraSpeed;
          }
      //    if(event->key() == Qt::Key_E) {
      //        cameraPos += cameraUp * cameraSpeed;
      //    }
      //    if(event->key() == Qt::Key_Q) {
      //        cameraPos -= cameraUp * cameraSpeed;
      //    }
      }
      keyPressEvent
    • 试着创建你自己的LookAt函数,其中你需要手动创建一个我们在一开始讨论的观察矩阵。用你的函数实现来替换GLM的LookAt函数,看看它是否还能一样地工作:

      #ifndef MYCAMERA_H
      #define MYCAMERA_H
      
      #include <QObject>
      #include <QMatrix4x4>
      #include <QKeyEvent>
      #include <QOpenGLShader>
      #include <QtMath>
      #include <QDebug>
      
      enum Camera_Movement {
          FORWARD,
          BACKWARD,
          LEFT,
          RIGHT,
          UP,
          DOWN
      };
      
      const GLfloat YAW = -90.0f;
      const GLfloat PITCH = 0.0f;
      const GLfloat SPEED = 1.0f;
      const GLfloat SENSITIVITY = 0.01f;
      const GLfloat ZOOM = 45.0f;
      
      class MyCamera : public QObject
      {
          Q_OBJECT
      public:
          explicit MyCamera(QVector3D position = QVector3D(0.0f, 0.0f, 0.0f), QVector3D up = QVector3D(0.0f, 1.0f, 0.0f),
                            GLfloat yaw = YAW, GLfloat pitch = PITCH);
      
          QMatrix4x4 getViewMatrix();                     //返回lookat函数
          void processMouseMovement(GLfloat xoffset, GLfloat yoffset, GLboolean constraintPitch = true);//相应鼠标操作函数
          void processMouseScroll(GLfloat yoffset);       //鼠标滚轮事件
          void processInput(GLfloat dt);                  //键盘循环函数
      
          QVector3D position;
          QVector3D worldUp;
          QVector3D front;
      
          QVector3D up;           // view坐标系 的上方向
          QVector3D right;        // view坐标系的 右方向
          //Eular Angles
          GLfloat picth;
          GLfloat yaw;
      
          //Camera options
          GLfloat movementSpeed;
          GLfloat mouseSensitivity;
          GLfloat zoom;
      
          //键盘多键触控所需
          GLboolean keys[1024];
      
      private:
          void updateCameraVectors();
          void processKeyboard(Camera_Movement direction, GLfloat deltaTime);//键盘处理事件函数
      };
      
      #endif // MYCAMERA_H
      myCamera.h

      myCamera.cpp

      #include "mycamera.h"
      
      MyCamera::MyCamera(QVector3D position, QVector3D up, GLfloat yaw, GLfloat pitch) :
          front(QVector3D(0.0f, 0.0f, -1.0f)), movementSpeed(SPEED), mouseSensitivity(SENSITIVITY),
          zoom(ZOOM)
      {
          this->position = position;
          this->worldUp = up;
          this->yaw = yaw;
          this->picth = pitch;
          this->updateCameraVectors();
      
          for(GLuint i = 0; i != 1024; ++i)
              keys[i] = GL_FALSE;
      }
      
      QMatrix4x4 MyCamera::getViewMatrix()
      {
          QMatrix4x4 view;
          view.lookAt(this->position, this->position + this->front, this->up);
          return view;
      }
      
      void MyCamera::processMouseMovement(GLfloat xoffset, GLfloat yoffset, GLboolean constraintPitch)
      {
          xoffset *= this->mouseSensitivity;
          yoffset *= this->mouseSensitivity;
      
          this->yaw += xoffset;
          this->picth += yoffset;
      
          if (constraintPitch) {
              if (this->picth > 89.0f)
                  this->picth = 89.0f;
              if (this->picth < -89.0f)
                  this->picth = -89.0f;
          }
      
          this->updateCameraVectors();
      }
      
      void MyCamera::processMouseScroll(GLfloat yoffset)
      {
          if (this->zoom >= 1.0f && this->zoom <= 45.0f)
              this->zoom -= yoffset;
            if (this->zoom > 45.0f)
              this->zoom = 45.0f;
            if (this->zoom < 1.0f)
                this->zoom = 1.0f;
      }
      
      void MyCamera::processInput(GLfloat dt)
      {
          if (keys[Qt::Key_W])
            processKeyboard(FORWARD, dt);
          if (keys[Qt::Key_S])
            processKeyboard(BACKWARD, dt);
          if (keys[Qt::Key_A])
            processKeyboard(LEFT, dt);
          if (keys[Qt::Key_D])
            processKeyboard(RIGHT, dt);
          if (keys[Qt::Key_E])
            processKeyboard(UP, dt);
          if (keys[Qt::Key_Q])
            processKeyboard(DOWN, dt);
      }
      
      void MyCamera::updateCameraVectors()
      {
          QVector3D front3(qCos(this->yaw) * qCos(this->picth), qSin(this->picth), qSin(this->yaw) * qCos(this->picth));
          this->front = front3.normalized();
          this->right = QVector3D::crossProduct(this->front, this->worldUp).normalized();
          this->up = QVector3D::crossProduct(this->right, this->front).normalized();
      }
      
      void MyCamera::processKeyboard(Camera_Movement direction, GLfloat deltaTime)
      {
          GLfloat velocity = this->movementSpeed * deltaTime;
          if (direction == FORWARD)
            this->position += this->front * velocity;
          if (direction == BACKWARD)
            this->position -= this->front * velocity;
          if (direction == LEFT)
            this->position -= this->right * velocity;
          if (direction == RIGHT)
            this->position += this->right * velocity;
          if (direction == UP)
            this->position += this->worldUp * velocity;
          if (direction == DOWN)
            this->position -= this->worldUp * velocity;
      }
      myCamera.cpp

      widget.h

      #ifndef WIDGET_H
      #define WIDGET_H
      
      #include <QWidget>
      #include <QGLWidget>
      #include <QOpenGLShader>
      #include <QOpenGLShaderProgram>
      #include <QDebug>
      #include <QOpenGLFunctions>
      #include <QOpenGLFunctions_3_3_Core>
      #include <QTime>
      #include <QtMath>
      #include <QTimer>
      #include <QOpenGLTexture>
      #include <QKeyEvent>
      
      #include "shader.h"
      #include "mycamera.h"
      
      namespace Ui {
      class Widget;
      }
      
      class Widget : public QGLWidget
      {
          Q_OBJECT
      
      public:
          Widget();
          ~Widget();
      public slots:
      
      protected:
          virtual void initializeGL();
          virtual void paintGL();
          virtual void resizeGL(int w, int h);
          void keyPressEvent(QKeyEvent *event);
          void keyReleaseEvent(QKeyEvent *event);
          void mouseMoveEvent(QMouseEvent *event);
          void wheelEvent(QWheelEvent *event);
          void mousePressEvent(QMouseEvent *event);
          void mouseReleaseEvent(QMouseEvent *event);
      
      private:
          QOpenGLFunctions_3_3_Core *core;
          QOpenGLTexture *texture1, *texture2;
          Shader *ourShader;
      //    QTimer updateTimer;
          QTime mtime;
          MyCamera *camera;
      //    QVector3D cameraPos;
      //    QVector3D cameraFront;
      //    QVector3D cameraUp;
          GLfloat deltaTime;
          GLfloat lastFrame;
      
          GLboolean isFirstMouse;
          GLboolean isLeftMousePress;
      //    GLfloat yaw;
      //    GLfloat pitch;
      //    GLfloat fov;
          GLfloat lastX;
          GLfloat lastY;
      };
      
      #endif // WIDGET_H
      widget.h

      widget.cpp

      #include "widget.h"
      #include "ui_widget.h"
      
      GLuint VBO, VAO, EBO;
      
      Widget::Widget()
      {
          deltaTime = 0.0f;
          lastFrame = 0.0f;
      
          lastX = 800.0f / 2.0;
          lastY = 600.0 / 2.0;
      }
      
      Widget::~Widget()
      {
          delete ourShader;
          core->glDeleteVertexArrays(1, &VAO);
          core->glDeleteBuffers(1, &VBO);
          core->glDeleteBuffers(1, &EBO);
          texture1->destroy();
          texture2->destroy();
          delete camera;
      }
      
      void Widget::initializeGL()
      {
          //着色器部分
          core = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_3_3_Core>();
          if (!core) {
                qWarning() << "Could not obtain required OpenGL context version";
                exit(1);
          }
          ourShader = new Shader(":/shader/vertexshadersource.vert", ":/shader/fragmentshadersource.frag");
      
          //VAO,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
          };
      
          core->glGenVertexArrays(1, &VAO);
          core->glGenBuffers(1, &VBO);
      
          core->glBindVertexArray(VAO);
      
          core->glBindBuffer(GL_ARRAY_BUFFER, VBO);
          core->glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
      
          //position attribute
          core->glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5*sizeof(GLfloat), nullptr);
          core->glEnableVertexAttribArray(0);
          //texture coord attribute
          core->glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5*sizeof(GLfloat), (void*)(3 * sizeof(float)));
          core->glEnableVertexAttribArray(1);
          //纹理1
          texture1 = new QOpenGLTexture(QImage(":/image/box.jpg").mirrored(), QOpenGLTexture::GenerateMipMaps); //直接生成绑定一个2d纹理, 并生成多级纹理MipMaps
          if(!texture1->isCreated()) {
              qDebug()<<"Failed to load texture" << endl;
          }
          texture1->setWrapMode(QOpenGLTexture::DirectionS, QOpenGLTexture::Repeat);
          texture1->setWrapMode(QOpenGLTexture::DirectionT, QOpenGLTexture::Repeat);
      
          texture1->setMinificationFilter(QOpenGLTexture::Linear);
          texture1->setMagnificationFilter(QOpenGLTexture::Linear);
          texture1->setFormat(QOpenGLTexture::RGBFormat);
      
          //第二张笑脸
          texture2 = new QOpenGLTexture(QImage(":/image/smile.png").mirrored(), QOpenGLTexture::GenerateMipMaps); //直接生成绑定一个2d纹理, 并生成多级纹理MipMaps
          if(!texture2->isCreated()) {
              qDebug()<<"Failed to load texture" << endl;
          }
          texture2->setWrapMode(QOpenGLTexture::DirectionS, QOpenGLTexture::Repeat);
          texture2->setWrapMode(QOpenGLTexture::DirectionT, QOpenGLTexture::Repeat);
      
          texture2->setMinificationFilter(QOpenGLTexture::Linear);
          texture2->setMagnificationFilter(QOpenGLTexture::Linear);
          texture2->setFormat(QOpenGLTexture::RGBFormat);
          ourShader->use();
          ourShader->shaderProgram.setUniformValue("texture1", 0);
          ourShader->shaderProgram.setUniformValue("texture2", 1);
          mtime.start();
      
          core->glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
          core->glEnable(GL_DEPTH_TEST);
      
          //初试化相机
          camera = new MyCamera(QVector3D(0.0f, 0.0f, 3.0f));
      
          deltaTime = 0.0f;
          lastFrame = 0.0f;
      
          isFirstMouse = GL_TRUE;
          isLeftMousePress = GL_FALSE;
          lastX = width() / 2.0f;
          lastY = height() / 2.0f;
      }
      
      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 Widget::paintGL()
      {
          GLfloat currentFrame = (GLfloat)mtime.elapsed()/100;
          deltaTime = currentFrame - lastFrame;
          lastFrame = currentFrame;
      
          camera->processInput(deltaTime);
          core->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
      
          ourShader->use();
          core->glActiveTexture(GL_TEXTURE0);
          texture2->bind();
          core->glActiveTexture(GL_TEXTURE1);
          texture1->bind();    
      
          QMatrix4x4 view, projection;
          view.translate(QVector3D(0.0f, 0.0f, -3.0f));
          projection.perspective(camera->zoom, (GLfloat)width()/(GLfloat)height(), 0.1f, 200.f);
          ourShader->use();
          ourShader->shaderProgram.setUniformValue("view", camera->getViewMatrix());
          ourShader->shaderProgram.setUniformValue("projection", projection);
      
          for(GLuint i=0;i<10;i++) {
              QMatrix4x4 model;
              model.translate(cubePositions[i]);
              model.rotate(20.0f*i, cubePositions[i]);
      
              ourShader->shaderProgram.setUniformValue("model", model);
              core->glBindVertexArray(VAO);
              core->glDrawArrays(GL_TRIANGLES, 0, 36);
          }
      
          update();
      }
      
      void Widget::resizeGL(int w, int h)
      {
          core->glViewport(0, 0, w, h);
      }
      
      void Widget::keyPressEvent(QKeyEvent *event)
      {
          GLuint key = event->key();
          if(key >= 0 && key<1024)
              camera->keys[key] = GL_TRUE;
      }
      
      void Widget::keyReleaseEvent(QKeyEvent *event)
      {
          GLuint key = event->key();
          if(key >= 0 && key < 1024)
              camera->keys[key] = GL_FALSE;
      }
      
      void Widget::mouseMoveEvent(QMouseEvent *event)
      {
          GLfloat xpos = event->pos().x();
          GLfloat ypos = event->pos().y();
      
          if(isLeftMousePress){
              if (isFirstMouse){
                  lastX = xpos;
                  lastY = ypos;
                  isFirstMouse = GL_FALSE;
              }
      
              GLint xoffset = xpos - lastX;
              GLint yoffset = lastY - ypos; // reversed since y-coordinates go from bottom to top
              lastX = xpos;
              lastY = ypos;
              camera->processMouseMovement(xoffset, yoffset);
          }
      }
      
      void Widget::wheelEvent(QWheelEvent *event)
      {
          QPoint offset = event->angleDelta();
          camera->processMouseScroll(offset.y()/20.0f);
      }
      
      void Widget::mousePressEvent(QMouseEvent *event)
      {
          if(event->button() == Qt::LeftButton){ //注意是button()不是buttons();
              isLeftMousePress = GL_TRUE;
          }
      }
      
      void Widget::mouseReleaseEvent(QMouseEvent *event)
      {
          if(event->button() == Qt::LeftButton){ //注意是button()不是buttons();
              isLeftMousePress = GL_FALSE;
              isFirstMouse = GL_TRUE;
          }
      }
      widget.cpp
  • 相关阅读:
    设计模式
    包装类
    php 闭包的理解
    is_null empty isset等的判定
    PHP基础一 $this ,static 和 self的区别
    lumen安装踩过得坑
    composer的使用和安装
    使用submine来写c++
    php 和 thinkphp中的常量一览
    路径问题 ./ / ../ 空 的区别
  • 原文地址:https://www.cnblogs.com/ch122633/p/12103855.html
Copyright © 2011-2022 走看看