11——qt opengl 镜面反射 光照贴图

最新推荐文章于 2024-04-25 10:32:43 发布
最新推荐文章于 2024-04-25 10:32:43 发布
阅读量550 收藏 1
点赞数
分类专栏： opengl 文章标签： qt opengl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wqs880527/article/details/123096186
版权

   qmyopenglwidget.h

#ifndef QMYOPENGLWIDGET_H
#define QMYOPENGLWIDGET_H

#include <QWidget>
#include <QOpenGLWidget>
#include <QOpenGLFunctions_3_3_Core>
#include <QOpenGLShaderProgram>
#include <QMouseEvent>
#include <QtMath>


class QMyOpenglWidget : public QOpenGLWidget, QOpenGLFunctions_3_3_Core
{
public:
    enum EType {
        eNone,
        eFull,
        eLine,
        ePoint,

    };

    Q_OBJECT
public:
    explicit QMyOpenglWidget(QWidget* parent = nullptr);

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

    virtual void mousePressEvent(QMouseEvent *event);
    virtual void mouseReleaseEvent(QMouseEvent *event);
    virtual void mouseDoubleClickEvent(QMouseEvent *event);
    virtual void mouseMoveEvent(QMouseEvent *event);
public:
    void keyPressEvent(QKeyEvent *event);
    void keyReleaseEvent(QKeyEvent *event);

public:
    void cretaeShader();
    void initDrawData(GLuint &vao, float *vertices, int vSize, float *uv, int uSize, float *normals, int nSize);
    void modeChange(EType type = eLine);
    unsigned int setImage(const char *filename);

private:

    unsigned int vao1;
    unsigned int vao2;
    unsigned int vao3;
    unsigned int vao4;
    unsigned int vao5;

    unsigned int ebo1;
    QOpenGLShaderProgram program;

    GLuint programId;
    GLint mLocation;
    GLint vLocation;
    GLint pLocation;

    GLint lightPosLocation;
    GLint viewPosLocation;

    GLint vertexLocation;
    GLint normalLocation;
    GLint colorLocation;
    GLint uvLocation;

    QMatrix4x4 mMatrix;
    QMatrix4x4 vMatrix;
    QMatrix4x4 pMatrix;

    unsigned int texture0;
    unsigned int texture1;

    bool isLeftPress;

    QPoint curPos;

    float yaw;
    float pitch;
    QVector3D cameraFront;
    QVector3D cameraPos;
    QVector3D cameraUp;


signals:

public slots:


};

#endif // QMYOPENGLWIDGET_H

qmyopenglwidget.cpp

#include "qmyopenglwidget.h"
#include <QGLWidget>
#include <QApplication>

QMyOpenglWidget::QMyOpenglWidget(QWidget* parent):QOpenGLWidget(parent)
{
    isLeftPress = false;
    yaw = -90;
    pitch = 0;

    cameraFront = QVector3D(0, 0, -1);
    cameraPos = QVector3D(0, 0, 10);
    cameraUp = QVector3D(0, 1, 0);
}

void QMyOpenglWidget::initializeGL()
{
    initializeOpenGLFunctions();

    glEnable(GL_CULL_FACE); //启动了背面裁剪
    glFrontFace(GL_CCW); //设置逆时针为正面

    //glEnable(GL_DEPTH_TEST);
    //glDepthFunc(GL_LESS);
    //glClearDepth (1.0f);

    cretaeShader();

    //三角形顶点坐标
    float s = 2.0f/2;
    GLfloat vertices[] = {

        //上
        -s,  s,  s,
         s,  s,  s,
         s,  s, -s,
        -s,  s, -s,

        //下
        -s, -s, -s,
         s, -s, -s,
         s, -s,  s,
        -s, -s,  s,

        //前
        -s, -s,  s,
         s, -s,  s,
         s,  s,  s,
        -s,  s,  s,
        //后
         s, -s, -s,
        -s, -s, -s,
        -s,  s, -s,
         s,  s, -s,
        //left
        -s, -s, -s,
        -s, -s,  s,
        -s,  s,  s,
        -s,  s, -s,
        //right
         s, -s,  s,
         s, -s, -s,
         s,  s, -s,
         s,  s,  s,
    };


    GLfloat uv[] = {0, 0,
                    1, 0,
                    1, 1,
                    0, 1,
                    0, 1,
                    1, 1,
                    1, 0,
                    0, 0,

                    0, 0,
                    1, 0,
                    1, 1,
                    0, 1,
                    0, 1,
                    1, 1,
                    1, 0,
                    0, 0,

                    0, 0,
                    1, 0,
                    1, 1,
                    0, 1,
                    0, 1,
                    1, 1,
                    1, 0,
                    0, 0,

                    };

    GLfloat normals[]{
        0, 1, 0,  0, 1, 0,  0, 1, 0,  0, 1, 0,
        0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0,
        0, 0, 1,  0, 0, 1,  0, 0, 1,  0, 0, 1,
        0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1,
        -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0,
        1, 0, 0,  1, 0, 0,  1, 0, 0,  1, 0, 0,
    };


    initDrawData(vao1, vertices, sizeof(vertices), uv, sizeof(uv), normals, sizeof(normals));

    glUniform1i(glGetUniformLocation(programId, "texture0"), 0);
    texture0 = setImage(":/container.png");

    glUniform1i(glGetUniformLocation(programId, "specular"), 1);
    texture1 = setImage(":/specular.png");
}

void QMyOpenglWidget::resizeGL(int w, int h)
{
    glViewport(0, 0, w, h);
    pMatrix.setToIdentity();
    float aspect = float(w*1.0)/ float(h);
    //printf("aspect = %f \n", aspect);
    qDebug()<<"aspect = "<<aspect<<" resizeGL";
    //aspect = int(aspect * 100) / 100.0f;
    //aspect = 1.42857f;
    pMatrix.perspective(60.0f, aspect, 0.000f, 100.f);
    //pMatrix.ortho(0, 0 , w, h, 0, 100);
    vMatrix.setToIdentity();
    vMatrix.lookAt(cameraPos, cameraPos+ cameraFront , cameraUp);
    mMatrix.setToIdentity();
    //mMatrix.translate(QVector3D{0.0,1.0,1.0});

    mMatrix.rotate(00, QVector3D{1.0,0.0,0.0});

}

void QMyOpenglWidget::paintGL()
{
    //qDebug()<<" paintGL";
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    int tranlate;
    static int xrotate = 1;
    xrotate +=1;

    glUniformMatrix4fv(mLocation, 1, GL_FALSE, mMatrix.data());
    glUniformMatrix4fv(vLocation, 1, GL_FALSE, vMatrix.data());
    glUniformMatrix4fv(pLocation, 1, GL_FALSE, pMatrix.data());

    GLfloat x=0, y=0, z=3.0f;
    glUniform3f(lightPosLocation, x, y, z);
    glUniform3f(viewPosLocation, cameraPos[0], cameraPos[1], cameraPos[2]);

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, texture0);
    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D, texture1);

    //mMatrix.rotate(1, QVector3D{1.0,0.5,0.0});

    //glActiveTexture(GL_TEXTURE0);

    int num = 5;
    //for(int i = 0; i < num; i++)
    {
        mMatrix.setToIdentity();
        mMatrix.translate(-3, 3, 0);
        glUniformMatrix4fv(mLocation, 1, GL_FALSE, mMatrix.data());
        glBindVertexArray(vao1);
        glDrawArrays(GL_QUADS, 0, 64);

        mMatrix.setToIdentity();
        mMatrix.translate(0, 0, 0);
        glUniformMatrix4fv(mLocation, 1, GL_FALSE, mMatrix.data());
        glBindVertexArray(vao1);
        glDrawArrays(GL_QUADS, 0, 64);

        mMatrix.setToIdentity();
        mMatrix.translate(3, 3, 0);
        glUniformMatrix4fv(mLocation, 1, GL_FALSE, mMatrix.data());
        glBindVertexArray(vao1);
        glDrawArrays(GL_QUADS, 0, 64);
    }

    update();

    //draw(eLine);
}



void QMyOpenglWidget::cretaeShader()
{
    program.addShaderFromSourceFile(QOpenGLShader::Vertex, ":/vertex.vert");
    program.addShaderFromSourceFile(QOpenGLShader::Fragment, ":/frag.frag");
    program.bind();
    program.link();

    programId = program.programId();
    mLocation = glGetUniformLocation(programId, "mMatrix");
    vLocation = glGetUniformLocation(programId, "vMatrix");
    pLocation = glGetUniformLocation(programId, "pMatrix");

    lightPosLocation = glGetUniformLocation(programId, "lightPos");
    viewPosLocation = glGetUniformLocation(programId, "viewPos");

    vertexLocation = glGetAttribLocation(programId, "pos");
    normalLocation = glGetAttribLocation(programId, "normal");
    uvLocation = glGetAttribLocation(programId, "uv0");


    Q_ASSERT(mLocation != -1);
    Q_ASSERT(vLocation != -1);
    Q_ASSERT(pLocation != -1);
    Q_ASSERT(vertexLocation != -1);
    Q_ASSERT(normalLocation != -1);
    Q_ASSERT(lightPosLocation != -1);
    Q_ASSERT(viewPosLocation != -1);
    Q_ASSERT(uvLocation != -1);
}

void QMyOpenglWidget::initDrawData(GLuint &vao, float *vertices, int vSize, float *uv, int uSize, float *normals, int nSize)
{
    //**************vao******************************//
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);

    //******************* Vbo vertices*******************//
    unsigned int vbo1;
    glGenBuffers(1, &vbo1);
    glBindBuffer(GL_ARRAY_BUFFER, vbo1);
    //为当前绑定到target 的缓冲区对象创建一个新的数据存储  //
    glBufferData(GL_ARRAY_BUFFER, vSize, vertices, GL_STATIC_DRAW);
    //告知显卡如何解析缓冲区里的属性值
    glVertexAttribPointer(vertexLocation, 3, GL_FLOAT, FALSE, 3*sizeof (GL_FLOAT), nullptr);
    //开启VAO管理的第一个属性
    glEnableVertexAttribArray(vertexLocation);

    //******************* Vbo Normals*******************//
    unsigned int vbo2;
    glGenBuffers(1, &vbo2);
    glBindBuffer(GL_ARRAY_BUFFER, vbo2);
    //为当前绑定到target 的缓冲区对象创建一个新的数据存储  //
    glBufferData(GL_ARRAY_BUFFER, nSize, normals, GL_STATIC_DRAW);
    //告知显卡如何解析缓冲区里的属性值
    glVertexAttribPointer(normalLocation, 3, GL_FLOAT, FALSE, 3*sizeof (GL_FLOAT), nullptr);
    //开启VAO管理的第一个属性
    glEnableVertexAttribArray(normalLocation);

    //************** Vbo UV**************************/
    unsigned int vboUv;
    glGenBuffers(1, &vboUv);
    glBindBuffer(GL_ARRAY_BUFFER, vboUv);
    //为当前绑定到target 的缓冲区对象创建一个新的数据存储  //
    glBufferData(GL_ARRAY_BUFFER, uSize, uv, GL_STATIC_DRAW);
    //告知显卡如何解析缓冲区里的属性值
    glVertexAttribPointer(uvLocation, 2, GL_FLOAT, FALSE, 2*sizeof (GL_FLOAT), nullptr);
    //开启VAO管理的第一个属性
    glEnableVertexAttribArray(uvLocation);


}

unsigned int QMyOpenglWidget:: setImage(const char *filename)
{
    QImage image = QImage(filename);
    image = QGLWidget::convertToGLFormat(image); //格式转换

    unsigned int texture;
    glGenTextures(1, &texture);
    //glActiveTexture(textureNum);
    glBindTexture(GL_TEXTURE_2D, texture);

    // set the texture wrapping/filtering options (on the currently bound texture object)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    // load and generate the texture
    int width, height, nrChannels;
    width = image.width();
    height = image.height();
    nrChannels = image.depth();
    Q_ASSERT(width>0 && height > 0);
    //unsigned char *data = stbi_load("container.jpg", &width, &height, &nrChannels, 0);
    if (image.bits())
    {
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image.bits());
        glGenerateMipmap(GL_TEXTURE_2D);
    }
    else
    {
        //std::cout << "Failed to load texture" << std::endl;
        Q_ASSERT(0);
    }


    return texture;

}

void QMyOpenglWidget::modeChange(QMyOpenglWidget::EType type)
{
    makeCurrent(); //设置当前opengl 渲染环境
    switch(type)
    {
        case eLine: {glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); break;}
        case eFull: {glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); break;}
        case ePoint: {glPolygonMode(GL_FRONT_AND_BACK, GL_POINT); break;}
        default: {glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); break;}
    }


    //glBindVertexArray(vao1);
    //glDrawArrays(GL_TRIANGLES, 0, 3);
    update();
    doneCurrent();
}

void QMyOpenglWidget::mousePressEvent(QMouseEvent *event)
{
    isLeftPress = true;
    curPos = event->pos();
}

void QMyOpenglWidget::mouseReleaseEvent(QMouseEvent *event)
{
    isLeftPress = false;
}

void QMyOpenglWidget::mouseDoubleClickEvent(QMouseEvent *event)
{

}

void QMyOpenglWidget::mouseMoveEvent(QMouseEvent *event)
{
    if(!isLeftPress) return;
    QPoint newPos = event->pos();
    QPoint xy = newPos - curPos;
    curPos = newPos;
    //vMatrix.rotate(xy.x(), QVector3D(0, 1, 0));
    //vMatrix.rotate(xy.y(), QVector3D(1, 0, 0));
    yaw += xy.x()*0.1;
    pitch += xy.y()*0.1;
#if 0
    if (pitch > 89.0f)
        pitch = 89.0f;
    if (pitch < -89.0f)
        pitch = -89.0f;
#endif
    QVector3D front;
    front[0] = qCos(qDegreesToRadians(yaw))  * qCos(qDegreesToRadians(pitch));
    front[1] = qSin(qDegreesToRadians(pitch));
    front[2] = qSin(qDegreesToRadians(yaw)) * qCos(qDegreesToRadians(pitch));
    cameraFront = front.normalized();
    vMatrix.setToIdentity();
    vMatrix.lookAt(cameraPos, cameraPos+ cameraFront , cameraUp);
}

void QMyOpenglWidget::keyPressEvent(QKeyEvent *event)
{
    //qDebug()<<"keyPress";
}

void QMyOpenglWidget::keyReleaseEvent(QKeyEvent *event)
{
    //qDebug()<<"keyRelease";
    int keyCode = event->key();
    if(keyCode == Qt::Key_Space)
    {
        //mMatrix.setToIdentity();
        //vMatrix.setToIdentity();
        //vMatrix.lookAt(QVector3D{0.0,0.0,10.0}, QVector3D{0.0,0.0,0.0},QVector3D{0.0,1.0,0.0});
        yaw = -90;
        pitch = 0;
        QVector3D front;
        front[0] = qCos(qDegreesToRadians(yaw))  * qCos(qDegreesToRadians(pitch));
        front[1] = qSin(qDegreesToRadians(pitch));
        front[2] = qSin(qDegreesToRadians(yaw)) * qCos(qDegreesToRadians(pitch));
        cameraFront = front.normalized();

        vMatrix.setToIdentity();

        cameraFront = QVector3D(0, 0, -1);
        cameraPos = QVector3D(0, 0, 10);
        cameraUp = QVector3D(0, 1, 0);
        vMatrix.lookAt(cameraPos, cameraPos+ cameraFront , cameraUp);

    }
    switch(keyCode)
    {
        case Qt::Key_W:
        {
            cameraPos += cameraFront;
        }
        break;
        case Qt::Key_S:
        {
            cameraPos -= cameraFront;
        }
        break;
        case Qt::Key_A:
        {
            cameraPos -= QVector3D::crossProduct(cameraFront, cameraUp).normalized() * 0.1;
        }
        break;
        case Qt::Key_D:
        {
            cameraPos += QVector3D::crossProduct(cameraFront, cameraUp).normalized() * 0.1;
        }
        break;
        case Qt::Key_Q:
        {
            cameraPos -= QVector3D(cameraFront[1], cameraFront[2], cameraFront[0]);
        }
        break;
        case Qt::Key_E:
        {
            cameraPos += QVector3D(cameraFront[1], cameraFront[2], cameraFront[0]);
        }
        break;
        case Qt::Key_Escape:
        {
            QApplication::quit();
        }
        break;
    }
    vMatrix.setToIdentity();
    vMatrix.lookAt(cameraPos, cameraPos+ cameraFront , cameraUp);
}

vertex.vert

#version 330 core
uniform mat4 pMatrix;
uniform mat4 vMatrix;
uniform mat4 mMatrix;

in vec3 pos;
in vec3 normal;
in vec2 uv0;

out vec2 TexCoord0;
out vec3 fnormal;
out vec3 fragPos;
void main(void)
{
    //法线方向随着模型 矩阵变动而变动
    //fnormal = vec3(mMatrix * vec4(normal, 1.0));
    //fnormal = mat3(transpose(inverse(mMatrix))) * normal;
    fnormal = vec3(transpose(inverse(mMatrix)) * vec4(normal, 1.0f));
    gl_Position = pMatrix  * vMatrix * mMatrix * vec4(pos, 1.0);
    fragPos = vec3(mMatrix * vec4(pos, 1.0));
    TexCoord0 = uv0;
}

frag.frag

#version 330 core
in vec3 fnormal;
in vec3 fragPos;
out vec4 FragColor; //片段着色器输出
in vec2 TexCoord0;
uniform sampler2D texture0;
uniform sampler2D specular;
//uniform vec3 lightDir;
uniform vec3 lightPos;
uniform vec3 viewPos;

void main(void)
{
    vec3 lightColor = vec3(1.0, 1.0, 1.0);
    //距离
    float distance = length(lightPos - fragPos);
    //点光源强度
    float pointPow = max(dot(normalize(fnormal), normalize(lightPos - fragPos)), 0.2) ;
    //贴图状态
    vec3 ambient = texture2D(texture0, TexCoord0).rgb * 0.2;
    //点光源漫反射
    vec3 lightAmbient = texture2D(texture0, TexCoord0).rgb * pointPow * 3 * 1/ distance;
    //视觉方向
    vec3 viewDir = normalize(viewPos - fragPos);
    //光源方向
    vec3 lightDir = normalize(lightPos - fragPos);
    //反射方向
    vec3 reflectDir = reflect(-lightDir, normalize(fnormal));
    //镜面发射强度计算
    float specPow = pow(max(dot(viewDir, reflectDir), 0.0), 32) * 3;
    //镜面反射贴图叠加 反射强度
    vec3 speColor = specPow * texture2D(specular, TexCoord0).rgb * lightColor;

    FragColor = vec4(ambient +lightAmbient + speColor, 1.0);
}

 

 

 

 

 

 

青松0527
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
QT之OpenGL光照
weixin_41111116的博客
01-09 752
QT之OpenGL光照
基于Qt的OpenGL编程（3.x以上GLSL可编程管线版）---(二)你好，三角形_QOpenGLFunctions_3_3_Core版
博客
04-06 6149
本篇文章，是一项带引号的“翻译”类型文章。 Joey De Vries  的现代OpenGL教程是我看过最好的图形学教程，没有之一。奈何原作者是在Visual Studio平台进行开发，针对GUI和OpenGL的结合，没有多言。在自己实际开发应用中，没有好的GUI确是造成不少困扰，故我欲作为一名搬运工，将Vries大神的代码进行Qt平台的“移植”。预了解代码中关于OpenGL函数的详细解释，请看...
Qt实现OpenGL光照，环境光，漫反射，镜面高光⑧
最新发布
qq_45233572的博客
04-25 359
Qt版本：6.7操作系统：Windows10。
Qt实现OpenGL的经典教程②——你好，三角形
qq_45233572的博客
04-17 1124
上一篇文章中，我们继承了QOpenGLFunctions来实现gl.h中的窗口，但是在编写新一章内容时，我发现继承QOpenGLFunctions所提供的函数标准是OpenGL2.0，这导致一些函数无法使用，比如glBindVertexArray()等，而LearnOpenGL所使用的标准是3.3。这里为了保持统一，对自定义的myOpenGLWidget做出如下修改，继承QOpenGLFunctions_3_3_Core而非QOpenGLFunctions。
QtOpenGL(一)简单的三维点
weixin_45128059的博客
06-02 1215
OpenGL网上的例子也很多，之前也一直在用，最近又系统的看了一下，也总结了一下，我我们开始吧。先绘制一些简单的三维点。
Qt Openglwidget 显示图片纹理贴图
12-05
在本文中，我们将深入探讨如何在Qt环境中使用QOpenGLWidget显示图片并实现纹理贴图，主要涉及Qt、OpenGL Widget、QImage以及纹理贴图等关键概念。首先，我们需要理解Qt库是一个跨平台的应用程序开发框架，它提供了...
Qt3d加载obj文件实现贴图和光照
03-27
使用 Qmesh 加载 obj 文件 使用 QtextureImage 加载贴图文件 使用 QDiffuseSpecularMaterial 提供光照 说明:官方示例中有创建场景相机等代码, cpp文件只包含载入核心代码.
QtOpenGL：一些Qt OpenGL演示
02-04
QtOpenGL模块是Qt库的一部分，专门用于结合OpenGL图形库，为开发者提供了在Qt环境中使用OpenGL进行高性能3D图形渲染的能力。OpenGL是一个广泛使用的开放标准，用于在各种操作系统上创建动态的2D和3D图形。 在"Qt...
Qt OpenGL绘制立方体
02-05
1.Qt 5.9 OpenGL3.3 2.绘制带有材质的立方体 3.使用timer 使立方体可以滚动起来
第11章 界面程序设计——Qt1
08-04
4. **OpenGL三维图形模块**：提供对OpenGL的开发支持，可以创建丰富的3D图形界面。 5. **网络模块**：包含对套接字、TCP/IP、DNS等网络操作的接口。 6. **表格模块**：允许开发人员创建和编辑电子表格。 7. **XML...
OpenGL3.3_Lighting_SpotLight
08-14
OpenGL3.3_Lighting_SpotLight
opengl内使用聚光灯对模型进行照明
05-13
关于opengl计算机图形学中的灯光的运用，还有一些模型的制作以及贴图
[OpenGL] 茶壶与光照
(ง •̀_•́)ง
05-10 1万+
OpenGL可以设置至少8种光源，它们的标号为GL_LIGHT0,GL_LIGHT1,GL_LIGHT2……。在这里我们使用了两种光源，一种是环境光，另一种是聚光灯。         在设置光照时，我们需要考虑这样三种光：环境反射光、镜面反射光、漫反射光。在Phong光照模型中，就是通过这三种分量的取值来模拟真实光照的。其中，环境反射光是光源多次反射后的光，可以理解为背景光，镜面反射和漫反射反映
基于Qt的OpenGL编程（3.x以上GLSL可编程管线版）---(二)你好，三角形_QOpenGLShader版
博客
04-09 4126
(这篇文章，代码部分感谢RyuZhihao123的技术支持，他的blog如下，一个很有趣的技术blog https://my.csdn.net/mahabharata_) 本篇文章，是一项带引号的“翻译”类型文章。 Joey De Vries  的现代OpenGL教程是我看过最好的图形学教程，没有之一。奈何原作者是在Visual Studio平台进行开发，针对GUI和OpenGL的结合，没有...
OpenGL纹理上下颠倒翻转的三种解决办法
热门推荐
narutojzm1的博客
07-18 1万+
综述在使用OpenGL函数加载纹理到图形时，经常遇到纹理上下颠倒的问题。原因是因为OpenGL要求纹理坐标原点在图片最下面，如图： 而图片信息中的原点一般都在最上方，一行行记录下来的，就会导致整个图片上下颠倒了。 如图： 从这个思路触发共有三种办法解决问题：一.翻转顶点信息中的纹理坐标原始顶点如图: 因为纹理坐标的范围是0-1，所以翻转的话都统一用1去减 得到正确的图片： 二
Qt例子学习笔记 - Examples/Qt-6.2.0/qt3d/advancedcustommaterial
虾球
10-10 596
main.cpp //演示在 Qt3D 中创建高级材料。 //此示例演示创建高级自定义材料。 //描述 //高级自定义材质示例展示了更复杂的着色器，并演示了使用 QtQuick //用户界面和动画控制着色器属性。 水是一个 3D 网格，在 Blender //中建模和 uv 映射，然后作为 .obj 文件带入 Scene 3D。 //用户可以控制的着色器属性在 advancedcustommaterial/ //WaterMaterial.qm 中定义 //控件 //纹理比例滑块 //将顶点着色器
OpenGL ES2.0 中级篇
06-27
巩固OpenGL ES2.0,增加了场景控制，shader光照计算，光照的多种模型，shader雾化计算 shader法线贴图的计算，shader Cartoon效果实现，以及Spline,曲线的实现，应用中实现路径动画。
Qt OpenGL（二十九）——Qt OpenGL 核心模式-纹理（给四边形贴上图片）
ifeng12358的博客
01-19 1612
如上图所示，我们希望三角形的左下角对应纹理的左下角，因此我们把三角形左下角顶点的纹理坐标设置为(0, 0)；也就是说我们把墙纸贴到四边形墙面上，需要确定墙纸的哪个脚对应墙面的哪个脚，如果没有对应好，可能就贴反了。你家房子装修，你想要在不同的房间贴上不同风格的墙纸，有科技感的，有雍容华贵的，还有动漫的等等，此时的墙纸就是我们所说的纹理了。纹理坐标起始于(0, 0)，也就是纹理图片的左下角，终始于(1, 1)，即纹理图片的右上角。纹理坐标在x和y轴上，范围为0到1之间（注意我们使用的是2D纹理图像）。
LearnOpenGL 笔记（二）-光照
qq_41061477的博客
02-13 667
九、颜色 定义物体的颜色为物体从一个光源反射各个颜色分量的大小。 创建一个光照场景 首先我们需要一个物体来作为被投光(Cast the light)的对象，光源。 为灯创建一个新的VAO unsigned int lightVAO; glGenVertexArrays(1, &lightVAO); glBindVertexArray(lightVAO); // 只需要绑定VBO不用再次设置VBO的数据，因为箱子的VBO数据中已经包含了正确的立方体顶点数据 glBindBuffer(GL_
qt OpenGl实现天空壳贴图
04-16
Qt是一个跨平台的应用程序开发框架，而OpenGL是一种用于渲染2D和3D图形的图形库。在Qt中使用OpenGL实现天空壳贴图可以通过以下步骤进行： 1. 创建一个Qt窗口应用程序项目，并在.pro文件中添加OpenGL模块的依赖。 2. 在Qt窗口中创建一个QOpenGLWidget控件，该控件将用于显示OpenGL渲染的内容。 3. 在QOpenGLWidget的子类中重写initializeGL、resizeGL和paintGL函数。 - initializeGL函数用于初始化OpenGL环境，可以在其中进行OpenGL的初始化设置，例如启用深度测试、启用纹理等。 - resizeGL函数用于处理窗口大小变化时的事件，可以在其中更新OpenGL视口的大小。 - paintGL函数用于绘制OpenGL场景，可以在其中进行天空壳贴图的绘制。 4. 在paintGL函数中实现天空壳贴图的绘制。天空壳贴图是一种将天空图像映射到一个球体上的技术，使得观察者在球体内部时能够看到逼真的天空效果。 - 首先，加载天空壳贴图的纹理图片，并将其绑定到一个OpenGL纹理对象上。 - 然后，绘制一个球体，并将天空壳贴图作为球体的纹理。 - 最后，使用OpenGL的着色器程序进行渲染，将天空壳贴图映射到球体上。 以上是使用Qt和OpenGL实现天空壳贴图的基本步骤。具体的实现细节可以根据具体需求进行调整和扩展。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值