C++ qmatrix4 translate不起任何作用

我在opengl方面没有太多经验，所以如果这个问题很愚蠢，请原谅

我试图通过转换类glView中的Qmatrix4x4字段来移动带有mouseMoveEvent的三角形。当我没有做任何事情（透视，用矩阵翻译）并且只调用

m_程序->setUniformValue（m_matrixUniform，m_矩阵）

一切都很好，但是如果我只做

this->m_矩阵=矩阵

（其中矩阵只是Qmatrix4x4变量）然后

m_程序->setUniformValue（m_matrixUniform，m_矩阵）

方法不起作用

在我看来，我在更新小部件（我只调用update（））或所有着色器逻辑方面存在一些问题。谢谢大家!

//Here is glView.h
#ifndef GLVIEW_H
#define GLVIEW_H
#include <QtOpenGL>
#include <QGLWidget>
#include <QOpenGLWidget>

#include <QtGui/QWindow>
#include <QtGui/QOpenGLFunctions>
#include <QMouseEvent>

//Class for drawing triangles
class glView : public QOpenGLWidget, public QOpenGLFunctions
{
public:
    glView(float left, float right, float bot, float top, float minz, float maxz)
        : QOpenGLWidget(), QOpenGLFunctions(), f_left(left), f_right(right), f_bot(bot), f_top(top), f_minz(minz), f_maxz(maxz)
    {}
    virtual~glView()
    {}
    void initializeGL() override;
    void resizeGL(int w, int h)override;
    void paintGL()override;

    void mousePressEvent(QMouseEvent *event) override;
    void mouseMoveEvent(QMouseEvent *event) override;
    void mouseReleaseEvent(QMouseEvent *event) override;
    void keyPressEvent(QKeyEvent* pe) Q_DECL_OVERRIDE;
private:

    struct CFace{
        int v1,v2,v3;
    };

    GLuint m_posAttr;
    GLuint m_colAttr;
    GLuint m_matrixUniform;
    QOpenGLShaderProgram *m_program;
    int m_frame = 0;
    QMatrix4x4 m_matrix;

    QPoint mPrevMousePos;
};

#endif // GLVIEW_H

//这里是glView.h
#ifndef GLVIEW\U H
#定义GLVIEW\u H
#包括
#包括
#包括
#包括
#包括
#包括
//绘制三角形的类
类glView：公共QOpenGLWidget、公共QOpenGLFunctions
{
公众：
glView（左浮动、右浮动、浮动机器人、顶部浮动、最小浮动、最大浮动）
：QOpenGLWidget（）、QOpenGLFunctions（）、f_left（左）、f_right（右）、f_bot（机器人）、f_top（上）、f_minz（minz）、f_maxz（maxz）
{}
虚拟视图（）
{}
void initializeGL（）覆盖；
void resizeGL（int w，int h）覆盖；
void paintGL（）覆盖；
作废MousePresseEvent（QMouseEvent*事件）覆盖；
作废mouseMoveEvent（QMouseEvent*事件）覆盖；
无效mouseReleaseEvent（QMouseEvent*事件）覆盖；
无效按键事件（QKeyEvent*pe）Q_DECL_覆盖；
私人：
结构面{
int v1、v2、v3；
};
GLuint m_posAttr；
GLuint m_colAttr；
GLuint m_矩阵流形；
QOpenGLShaderProgram*m_计划；
int m_frame=0；
qmatrix4x4m_矩阵；
QPoint-mPrevMousePos；
};
#endif//GLVIEW\u H

和cpp

//Here is glView.cpp
#include <qopengl.h>
#include "glView.h"

#include <QtGui/QGuiApplication>
#include <QtGui/QMatrix4x4>
#include <QtGui/QOpenGLShaderProgram>

#include <QMouseEvent>

static const char *vertexShaderSource =
    "attribute highp vec4 posAttr;\n"
    "attribute lowp vec4 colAttr;\n"
    "varying lowp vec4 col;\n"
    "uniform highp mat4 matrix;\n"
    "void main() {\n"
    "   col = colAttr;\n"
    "   gl_Position = matrix*posAttr;\n"
    "}\n";

static const char *fragmentShaderSource =
    "varying lowp vec4 col;\n"
    "void main() {\n"
    "   gl_FragColor = col;\n"
    "}\n";

//------------------------------------------------------------------------------
void glView::initializeGL()
{   
    m_program = new QOpenGLShaderProgram(this);
    m_program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexShaderSource);
    m_program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentShaderSource);
    m_program->link();
    m_posAttr = m_program->attributeLocation("posAttr");
    m_colAttr = m_program->attributeLocation("colAttr");
    m_matrixUniform = m_program->uniformLocation("matrix");
}
//------------------------------------------------------------------------------

void glView::paintGL()
{   
    QOpenGLFunctions *f = QOpenGLContext::currentContext()->functions();

    const qreal retinaScale = devicePixelRatio();
    f->glViewport(0, 0, width() * retinaScale, height() * retinaScale);

    f->glClear(GL_COLOR_BUFFER_BIT);
    m_program->bind();

    QMatrix4x4 matrix;
//Here is the problem!
    //matrix.perspective(0.0f, 4.0f/3.0f, 0.1f, 100.0f);
    //matrix.translate(-5, -5, 0);

    //???
    this->m_matrix=matrix;
    m_program->setUniformValue(m_matrixUniform, m_matrix);


    GLfloat vertices[] = {
        0.0f, 0.707f,
        -0.5f, -0.5f,
        0.5f, -0.5f
    };

    GLfloat colors[] = {
        1.0f, 0.0f, 0.0f,
        0.0f, 1.0f, 0.0f,
        0.0f, 0.0f, 1.0f
    };

    f->glVertexAttribPointer(m_posAttr, 2, GL_FLOAT, GL_FALSE, 0, vertices);
    f->glVertexAttribPointer(m_colAttr, 3, GL_FLOAT, GL_FALSE, 0, colors);

    f->glEnableVertexAttribArray(0);
    f->glEnableVertexAttribArray(1);

    f->glDrawArrays(GL_TRIANGLES, 0, 3);

    f->glDisableVertexAttribArray(1);
    f->glDisableVertexAttribArray(0);

    m_program->release();

    ++m_frame;
}

void glView::mousePressEvent(QMouseEvent *event)
{
    mPrevMousePos = event->pos();
    QOpenGLWidget::mousePressEvent(event);
}

void glView::mouseMoveEvent(QMouseEvent *event)
{
    auto diff = event->pos() - mPrevMousePos;
    //??
    this->m_matrix.translate(diff.x()/(width()*0.5), -diff.y()/(height()*0.5));

    mPrevMousePos = event->pos();

    //?? m_program->setUniformValue(m_matrixUniform, m_matrix);
    update();
    QOpenGLWidget::mouseMoveEvent(event);
}

void glView::mouseReleaseEvent(QMouseEvent *event)
{

    QOpenGLWidget::mouseReleaseEvent(event);
}

void glView::keyPressEvent(QKeyEvent *pe)
{
    switch (pe->key())
       {
          case Qt::Key_Up:
             this->m_matrix.scale(QVector3D(2.0f,2.0f,1.0f));
          break;

          case Qt::Key_Down:
             this->m_matrix.translate(QVector3D(0,-1,0));
          break;
       }
    update();
    QOpenGLWidget::keyPressEvent(pe); // Передать событие дальше
}

//这是glView.cpp
#包括
#包括“glView.h”
#包括
#包括
#包括
#包括
静态常量字符*vertexShaderSource=
“属性highp vec4 posAttr；\n”
“属性lowp vec4 colAttr；\n”
“可变低电平向量4列；\n”
“一致高p mat4矩阵；\n”
“void main（）{\n”
“col=colAttr；\n”
“gl_位置=矩阵*posAttr；\n”
“}\n”；
静态常量字符*fragmentShaderSource=
“可变低电平向量4列；\n”
“void main（）{\n”
“gl\u FragColor=col；\n”
“}\n”；
//------------------------------------------------------------------------------
void glView:：initializeGL（）
{   
m_计划=新QOpenGLShaderProgram（本）；
m_程序->addShaderFromSourceCode（QOpenGLShader:：Vertex，vertexShaderSource）；
m_程序->addShaderFromSourceCode（QOpenGLShader:：Fragment，fragmentShaderSource）；
m_程序->链接（）；
m_posAttr=m_程序->属性定位（“posAttr”）；
m_colAttr=m_程序->属性定位（“colAttr”）；
m_matrixUniform=m_程序->统一位置（“矩阵”）；
}
//------------------------------------------------------------------------------
void glView:：paintGL（）
{   
QOpenGLFunctions*f=QOpenGLContext:：currentContext（）->functions（）；
常数qreal retinaScale=设备比例（）；
f->glViewport（0，0，width（）*retinaScale，height（）*retinaScale）；
f->glClear（GL\u颜色\u缓冲\u位）；
m_程序->绑定（）；
QMatrix4x4矩阵；
//问题就在这里！
//矩阵透视图（0.0f、4.0f/3.0f、0.1f、100.0f）；
//矩阵转换（-5，-5,0）；
//???
这->m_矩阵=矩阵；
m_程序->设置统一值（m_矩阵统一形式，m_矩阵）；
GLfloat顶点[]={
0.0f，0.707f，
-0.5f，-0.5f，
0.5f，-0.5f
};
GLfloat颜色[]={
1.0f，0.0f，0.0f，
0.0f，1.0f，0.0f，
0.0f，0.0f，1.0f
};
f->glvertexattributepointer（m_posAttr，2，GL_FLOAT，GL_FALSE，0，顶点）；
f->glvertexattributepointer（m_colAttr，3，GL_FLOAT，GL_FALSE，0，颜色）；
f->GlenableVertexAttribute数组（0）；
f->GlenableVertexAttributeArray（1）；
f->gldrawArray（GL_三角形，0,3）；
f->glDisableVertexAttribute数组（1）；
f->glDisableVertexAttribute数组（0）；
m_程序->发布（）；
++m_框架；
}
void glView:：mousePresseEvent（QMouseEvent*事件）
{
mPrevMousePos=事件->位置（）；
QOpenGLWidget:：MousePresseEvent（事件）；
}
void glView:：mouseMoveEvent（QMouseEvent*事件）
{
自动差异=事件->位置（）-mPrevMousePos；
//??
这个->m_矩阵转换（diff.x（）/（width（）*0.5），-diff.y（）/（height（）*0.5））；
mPrevMousePos=事件->位置（）；
//？？m_程序->设置统一值（m_矩阵统一形式，m_矩阵）；
更新（）；
QOpenGLWidget:：mouseMoveEvent（事件）；
}
void glView:：mouseReleaseEvent（QMouseEvent*事件）
{
QOpenGLWidget:：mouseReleaseEvent（事件）；
}
void glView:：keyPressEvent（QKeyEvent*pe）
{
开关（pe->key（））
{
案例Qt：：键向上：
这个->m_矩阵比例（QVector3D（2.0f，2.0f，1.0f））；
打破
案例Qt：：按键向下：
这个->m_矩阵.translate（QVector3D（0，-1,0））；
打破
}
更新（）；
QOpenGLWidget:：keyPressEvent（pe）；//ПСаааааааа
}

的第一个参数是垂直场角，单位为度。如果角度为0，则视野无限小，它是一个点。例如，使用90.0度

3D参数是到近平面的距离，第四个参数是到远平面的距离。近平面和远平面定义了视锥体的极限。所有几何体都必须位于该区域。所以在你的例子中，近距是0.1，远距是100.0。
由于z轴指向viewspace中的视口之外，因此必须设置z平移，该平移大于-0.1且小于*-100.0

由于透视投影处的视图体积是平截头体（截断棱锥），因此视口投影中的x和y平移量取决于几何体的深度（视图空间z坐标）和视野角度。无论如何（-5，-5）对于这个设置来说太多了，并且会将三角形移出视图。但您可以使用（-1，-1）作为示例

QMatrix4x4矩阵