OpenGL入门第六步：材质

已于 2024-07-25 17:33:55 修改
阅读量352 收藏 12
点赞数 6
文章标签： qt openGL c++
于 2024-07-25 15:39:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yanjun2i/article/details/140685330
版权

目录

结果显示

材质介绍

函数解析

具体代码

结果显示

材质介绍

当描述一个表面时，我们可以分别为三个光照分量定义一个材质颜色(Material Color)：环境光照(Ambient Lighting)、漫反射光照(Diffuse Lighting)和镜面光照(Specular Lighting)。通过为每个分量指定一个颜色，我们就能够对表面的颜色输出有细粒度的控制了。现在，我们再添加一个反光度(Shininess)分量，结合上述的三个颜色，我们就有了全部所需的材质属性了。

为风氏光照模型的每个分量都定义一个颜色向量。ambient材质向量定义了在环境光照下这个表面反射的是什么颜色，通常与表面的颜色相同。diffuse材质向量定义了在漫反射光照下表面的颜色。漫反射颜色（和环境光照一样）也被设置为我们期望的物体颜色。specular材质向量设置的是表面上镜面高光的颜色（或者甚至可能反映一个特定表面的颜色）。最后，shininess影响镜面高光的散射/半径。有这4个元素定义一个物体的材质，我们能够模拟很多现实世界中的材质。devernay.free.fr中的一个表格展示了一系列材质属性，它们模拟了现实世界中的真实材质。下图展示了几组现实世界的材质参数值对我们的立方体的影响：

可以看到，通过正确地指定一个物体的材质属性，我们对这个物体的感知也就不同了。效果非常明显，但是要想获得更真实的效果，我们需要以更复杂的形状替换这个立方体。

函数解析

timerEvent(QTimerEvent *event)函数：

initializeGL()函数：绘制光源

顶点着色器

片段着色器 

环境光通常被认为是均匀地照亮场景的，所以直接用光源的环境光和材质的环境光相乘来简单表示。

漫反射光的强度取决于光线与表面法向量的夹角。通过归一化法向量和光线方向向量，然后计算它们的点积，就能得到光线与表面的夹角余弦值。夹角越小，漫反射光越强，所以用这个点积值来控制漫反射光的强度。

镜面反射光主要是模拟物体表面的高光效果。通过计算反射方向向量和观察方向向量的点积，并对结果进行幂运算，来模拟高光的集中和锐利程度。材质的 shininess 值越大，高光就越集中和锐利。

光源的绘制和前一次（基础光照）没有区别。 

paintGL()函数：传参进行绘制

具体代码

.h

#ifndef OPENGLWIDGET_H
#define OPENGLWIDGET_H

#include <QOpenGLWidget>
#include <QOpenGLShaderProgram>
#include <QOpenGLBuffer>
#include <QOpenGLVertexArrayObject>
#include <QOpenGLTexture>
#include <QElapsedTimer>
#include "Camera.h"

QT_BEGIN_NAMESPACE
namespace Ui { class openGLWidget; }
QT_END_NAMESPACE

class openGLWidget : public QOpenGLWidget
{
    Q_OBJECT

public:
    openGLWidget(QWidget *parent = nullptr);
    ~openGLWidget();
protected:
    virtual void timerEvent(QTimerEvent *event) override;
    //鼠标事件
    virtual void enterEvent(QEnterEvent *event) override;
    virtual void leaveEvent(QEvent *event) override;
    virtual void mouseMoveEvent(QMouseEvent *event) override;
    virtual void wheelEvent(QWheelEvent *event) override;
    virtual void keyPressEvent(QKeyEvent *event) override;
    virtual void keyReleaseEvent(QKeyEvent *event) override;
    //初始化
    virtual void initializeGL() override;
    virtual void resizeGL(int w, int h) override;
    virtual void paintGL() override;

private:
    QOpenGLShaderProgram lightingShader;
    QOpenGLShaderProgram lightCubeShader;
    QOpenGLBuffer vbo;
    QOpenGLVertexArrayObject cubeVao;
    QOpenGLVertexArrayObject lightVao;
    QMatrix4x4 projection;
    QMatrix4x4 view;
    Camera camera {Camera(QVector3D(0.0f, 0.0f, 3.0f))};
    QVector3D lightPos {QVector3D(1.2f, 1.0f, 2.0f)};
    // 用 0 - 1 的值 直接表示颜色
    QVector3D diffuseColor;
    QVector3D ambientColor;
    QElapsedTimer time;
    float lastFrameTime {0.f};
    struct {
        bool W {false};
        bool S {false};
        bool A {false};
        bool D {false};
    } keys;

private:
    Ui::openGLWidget *ui;
};
#endif // OPENGLWIDGET_H

.cpp

#include "openGLWidget.h"
#include "./ui_openGLWidget.h"

#include <QOpenGLFunctions>
#include <QKeyEvent>
#include <QPainter>
#include <QtMath>

openGLWidget::openGLWidget(QWidget *parent)
    : QOpenGLWidget(parent)
    , ui(new Ui::openGLWidget)
{
    ui->setupUi(this);
    setMouseTracking(true);
}

openGLWidget::~openGLWidget()
{
    makeCurrent();
    lightVao.destroy();
    cubeVao.destroy();
    vbo.destroy();
    doneCurrent();
    delete ui;
}

void openGLWidget::timerEvent(QTimerEvent *event)
{
    float s = time.elapsed() / 1000.0;
    float delta = s - lastFrameTime;
    lastFrameTime = s;
    if (keys.W)
        camera.ProcessKeyboard(FORWARD, delta);
    if (keys.S)
        camera.ProcessKeyboard(BACKWARD, delta);
    if (keys.A)
        camera.ProcessKeyboard(LEFT, delta);
    if (keys.D)
        camera.ProcessKeyboard(RIGHT, delta);
    view = camera.GetViewMatrix();
    QVector3D lightColor(qSin(lastFrameTime * 2.0), qSin(lastFrameTime * 0.7), qSin(lastFrameTime * 1.3));
    diffuseColor = lightColor * 0.5;
    ambientColor = lightColor * 0.2;
    update();
}

void openGLWidget::enterEvent(QEnterEvent *event)
{
    // 隐藏鼠标指针，将指针置于窗口中心
    setCursor(Qt::BlankCursor);
    QCursor::setPos(mapToGlobal(rect().center()));
}

void openGLWidget::leaveEvent(QEvent *event)
{

}

void openGLWidget::mouseMoveEvent(QMouseEvent *event)
{
    float xoffset = rect().center().x() - event->x();
    float yoffset = rect().center().y() - event->y();

    float sensitivity = 0.1f; // change this value to your liking
    xoffset *= sensitivity;
    yoffset *= sensitivity;

    camera.ProcessMouseMovement(xoffset, yoffset);

    // 将指针置于窗口中心
    QCursor::setPos(mapToGlobal(rect().center()));
}

void openGLWidget::wheelEvent(QWheelEvent *event)
{
    float f = event->angleDelta().y() > 0 ? 1.0f : -1.0f;
    camera.ProcessMouseScroll(f);
    projection.setToIdentity();
    projection.perspective(camera.Zoom, float(width()) / float(height()), 0.1f, 100.f);
}

void openGLWidget::keyPressEvent(QKeyEvent *event)
{
    switch(event->key()) {
    case Qt::Key_W:
        keys.W = true;
        break;
    case Qt::Key_S:
        keys.S = true;
        break;
    case Qt::Key_A:
        keys.A = true;
        break;
    case Qt::Key_D:
        keys.D = true;
        break;
    default:
        return;
    }
}

void openGLWidget::keyReleaseEvent(QKeyEvent *event)
{
    switch(event->key()) {
    case Qt::Key_W:
        keys.W = false;
        break;
    case Qt::Key_S:
        keys.S = false;
        break;
    case Qt::Key_A:
        keys.A = false;
        break;
    case Qt::Key_D:
        keys.D = false;
        break;
    default:
        return;
    }
}

void openGLWidget::initializeGL()
{
    // 设置用来清空屏幕的颜色 这里设置为黑色
    QOpenGLFunctions *f = context()->functions();
    f->glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

    lightingShader.addCacheableShaderFromSourceCode(QOpenGLShader::Vertex, R"(
        #version 330 core
        layout (location = 0) in vec3 aPos;
        layout (location = 1) in vec3 aNormal;
        out vec3 vFragPos;
        out vec3 vNormal;
        uniform mat4 uProjection;
        uniform mat4 uView;
        uniform mat4 uModel;

        void main()
        {
            vFragPos = vec3(uModel * vec4(aPos, 1.0));
            vNormal = mat3(transpose(inverse(uModel))) * aNormal;

            gl_Position = uProjection * uView * uModel * vec4(aPos, 1.0);
        }
    )");
    // 片段着色器
    lightingShader.addCacheableShaderFromSourceCode(QOpenGLShader::Fragment, R"(
        #version 330 core
        out vec4 FragColor;

        struct Material {
            vec3 ambient;
            vec3 diffuse;
            vec3 specular;
            float shininess;
        };

        struct Light {
            vec3 position;
            vec3 ambient;
            vec3 diffuse;
            vec3 specular;
        };

        in vec3 vNormal;
        in vec3 vFragPos;

        uniform vec3 uViewPos;
        uniform Material uMaterial;
        uniform Light uLight;

        void main()
        {
            // ambient
            vec3 ambient = uLight.ambient * uMaterial.ambient;

            // diffuse
            vec3 norm = normalize(vNormal);
            vec3 lightDir = normalize(uLight.position - vFragPos);
            float diff = max(dot(norm, lightDir), 0.0);
            vec3 diffuse = uLight.diffuse * (diff * uMaterial.diffuse);

            // specular
            vec3 viewDir = normalize(uViewPos - vFragPos);
            vec3 reflectDir = reflect(-lightDir, norm);
            float spec = pow(max(dot(viewDir, reflectDir), 0.0), uMaterial.shininess);
            vec3 specular = uLight.specular * (spec * uMaterial.specular);

            vec3 result = ambient + diffuse + specular;
            FragColor = vec4(result, 1.0);
        }
    )");
    // 编译链接
    if(!lightingShader.link()) {
        qDebug() << lightingShader.log();
    };

    //光源
    lightCubeShader.addCacheableShaderFromSourceCode(QOpenGLShader::Vertex, R"(
        #version 330 core
        layout (location = 0) in vec3 aPos;

        uniform mat4 uModel;
        uniform mat4 uView;
        uniform mat4 uProjection;

        void main()
        {
            gl_Position = uProjection * uView * uModel * vec4(aPos, 1.0);
        }
    )");

    lightCubeShader.addCacheableShaderFromSourceCode(QOpenGLShader::Fragment, R"(
        #version 330 core
        out vec4 FragColor;

        void main()
        {
            FragColor = vec4(1.0); // set all 4 vector values to 1.0
        }
    )");
    // 编译链接
    if(!lightCubeShader.link()) {
        qDebug() << lightCubeShader.log();
    };

    // 顶点数据
    float vertices[] = {
        -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
        0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
        0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
        0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
        -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,

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

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

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

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

        -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,
        0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,
        0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
        0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
        -0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
        -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f
    };
    // 创建VBO
    vbo.create();
    vbo.bind();
    vbo.allocate(vertices, sizeof(vertices));

    cubeVao.create();
    cubeVao.bind();
    lightingShader.enableAttributeArray(0);
    lightingShader.setAttributeBuffer(0, GL_FLOAT, 0, 3, 6 * sizeof(float));
    lightingShader.enableAttributeArray(1);
    lightingShader.setAttributeBuffer(1, GL_FLOAT, 3 * sizeof(float), 3, 6 * sizeof(float));

    lightVao.create();
    lightVao.bind();
    lightCubeShader.enableAttributeArray(0);
    lightCubeShader.setAttributeBuffer(0, GL_FLOAT, 0, 3, 6 * sizeof(float));
    startTimer(1);
    time.start();
}

void openGLWidget::resizeGL(int w, int h)
{
    QOpenGLFunctions *f = context()->functions();
    f->glViewport(0, 0, w, h);
    projection.setToIdentity();
    projection.perspective(camera.Zoom, float(w) / float(h), 0.1f, 100.f);
}

void openGLWidget::paintGL()
{
    QOpenGLFunctions* f = context()->functions();
    f->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    // 启用深度测试
    f->glEnable(GL_DEPTH_TEST);

    lightingShader.bind();
    lightingShader.setUniformValue("uViewPos", camera.Position);
    lightingShader.setUniformValue("uLight.position", lightPos);
    lightingShader.setUniformValue("uLight.ambient", ambientColor);
    lightingShader.setUniformValue("uLight.diffuse", diffuseColor);
    lightingShader.setUniformValue("uLight.specular", 1.0f, 1.0f, 1.0f);

    lightingShader.setUniformValue("uMaterial.ambient", 1.0f, 0.5f, 0.31f);
    lightingShader.setUniformValue("uMaterial.diffuse", 1.0f, 0.5f, 0.31f);
    lightingShader.setUniformValue("uMaterial.specular", 0.5f, 0.5f, 0.5f);
    lightingShader.setUniformValue("uMaterial.shininess", 32.0f);

    lightingShader.setUniformValue("uProjection", projection);
    lightingShader.setUniformValue("uView", view);
    lightingShader.setUniformValue("uModel", QMatrix4x4());
    cubeVao.bind();
    f->glDrawArrays(GL_TRIANGLES, 0, 36);

    lightCubeShader.bind();
    lightCubeShader.setUniformValue("uProjection", projection);
    lightCubeShader.setUniformValue("uView", view);
    QMatrix4x4 model;
    model.translate(lightPos);
    model.scale(0.2f);
    lightCubeShader.setUniformValue("uModel", model);
    lightVao.bind();
    f->glDrawArrays(GL_TRIANGLES, 0, 36);
}

Camera.h参考前一篇

Yanjun2i
关注
  • 6
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
OpenGL入门学习.pdf
03-21
一、第一个OPENGL程序...................................................................................................................4 1.1、OPENGL的优点.................................................
OpenGL_参考手册.rar
08-21
本书第1章是OpenGL入门，第2章对命令和例程进行了简介，第3章集中介绍了各种命令和例程，第4章介绍了定义的常量和相关命令，第5章是OpenGL参考说明，第6章是GLU的参考说明，第7章是GLX的参考说明。 本书在翻译过程...
OpenGL编程指南（第四版）
02-11
《OpenGL编程指南（第四版）》是一本深入探讨OpenGL编程技术的专业书籍，旨在为读者提供全面、详实的OpenGL知识体系。此书不仅适合初学者入门，也适用于有一定基础的开发者进行进阶学习和深入研究。以下是根据书名、...
OpenGL_Nehe(NeHe中文教程).pdf
11-27
《OpenGL_Nehe(NeHe中文教程)》是一份详尽的OpenGL编程入门教程，旨在为初学者提供一套系统的学习路径，使他们在学习过程中能够轻松理解并应用OpenGL的基本概念和技术。该教程由NeHe编写，他是一位知名的OpenGL教程...
OpenGL超级宝典(中文版)
10-23
#### 二、OpenGL入门基础知识 1. **OpenGL的基本概念**：在学习OpenGL之前，理解一些基本的概念非常重要，例如顶点(Vertex)、多边形(Polygon)、纹理(Texture)等。 - **顶点**：是构成图形的基本元素之一，每个...
Qt自定义下拉列表-可为选项设置标题、可禁用选项
u012959478的博客
07-20 1120
在Qt中,ComboBox（组合框）是一种常用的用户界面控件,它提供了一个下拉列表,允许用户从预定义的选项中选择一个。在项目开发中，如果简单的QComboBox无法满足需求，可以通过自定义QComboBox来实现更复杂的功能。本文介绍一个自定义的下拉列表，并为选项设置标题、可禁用选项。
QT--线程
m0_51830537的博客
07-24 738
【代码】QT--线程。
【QT】线程控制和同步
lzb_kkk的博客
07-21 1095
qt线程QThread常用API介绍，如何创建一个线程，启动一个线程，以及什么是线程安全；qt中互斥锁QMutex的概念，及其使用，QMutexLocker 是 QMutex 的辅助类，⽤途：简化对互斥锁的上锁和解锁操作，避免忘记解锁导致的死锁等问题。；qt中条件变量和信号量的介绍
Qt Creator平台编译snmp++
燃犀的博客
07-19 1210
编译源码 使用动态库 测试代码
QT环形进度条（圆形进度条）
u012959478的博客
07-24 861
在Qt自带的控件中，只有垂直进度条、水平进度条两种。在平时做页面开发时，有些时候会用到环形进度条。环形进度条可以在各种需要显示任务或操作进度的场景中使用，提供可视化的进度反馈，提升用户体验。本示例使用QT实现一个自定义环形进度条。实现这个功能主要两个重点：图形绘制和数值计算。
在 Qt 中获取 MouseMove 事件
最新发布
电脑管家
07-24 357
在MainWindow类中定义并实现方法。(event);通过事件过滤器可以实现应用程序窗口内的鼠标移动状态更新，而通过捕捉鼠标或定时轮询的方法可以实现更广泛的鼠标位置追踪。根据具体需求选择合适的方法，以实现最佳效果。
【QT】QT 概述（背景介绍、搭建开发环境、Qt Creator、程序、项目文件解析、编程注意事项）
Elena's Blog
07-20 1334
搭建 Qt 开发环境。
Qt 实战（7）元对象系统 | 7.5、QMetaProperty详解
个人技术博客
07-22 1198
Qt的动态属性（Dynamic Properties）是Qt框架中一个非常有用的特性，它允许在运行时动态地获取和设置对象的属性。这个特性基于Qt的元对象系统（Meta-Object System），可以让我们以一种统一的方式访问和操作对象的各种属性，而无需关心这些属性的具体实现。动态属性的主要优势在于它的灵活性和可扩展性。通过使用动态属性，我们可以在不修改类定义的情况下，为类添加新的属性。这对于一些需要频繁修改或扩展的场景非常有用，比如插件系统、用户界面组件等。在Qt中，动态属性是通过QObject。
QT5:多窗口跳转
m0_55986987的博客
07-19 576
学习使用qt5完成多窗口（界面）跳转：从主界面可分别跳转至界面一和界面二，从界面一可以返回主界面和跳转至界面二，界面二可返回对应的父界面（从主界面跳转则返回主界面，从界面一跳转则返回界面一）。
QT--网络篇
m0_51830537的博客
07-19 925
是在 Qt 中声明一个名为sockets的列表，该列表包含 QTcpSocket。一般用第一个判断是否断开连接。
QT 信号槽机制
m0_54442739的博客
07-21 356
1.信号发生对象/槽对象:const QObject* 类型，大部分qt有的组件都是QObject的子类，直接用就行。注意:信号用SIGNAL()宏包起来，槽函数用SLOT()包起来，并且如果有参数要把参数列表类型完整的写入。函数作用：连接信号和槽，使得信号发生对象发射信号发生时槽对象执行槽函数。，唯一的作用就是当调用发射时将参数发射到槽对象槽函数的参数里。信号不需要内容定义，在槽函数定义里面写一个打印。新建一个widget，加一个按键，转到槽函数。3.槽函数:信号发射后执行的函数，
【Qt】修改窗口的标题和图标
t5y22的博客
07-24 1041
以下操作仅对顶层 widget(独⽴窗口),有效修改窗口的标题。
QT--文件操作和文件读写
m0_51830537的博客
07-22 1092
假设已经给fn指定好路径了，那么则有fn.open(权限)
【Qt】文字换行
weixin_44623642的博客
07-23 428
它提供了现代文本布局引擎所期望的许多功能，包括 Unicode 兼容的渲染、换行和光标定位处理。它还可以生成和渲染与设备无关的布局，这对于所见即所得应用程序非常重要。该类具有相当低级别的 API，除非您打算为某些专用小部件实现自己的文本渲染，否则您可能不需要直接使用它。但此方法对于多语言文本不太友好，可以在超出文本框时添加省略符，方法如下。在Qt控件中经常遇到文字超出文本框，因此介绍几种换行方式。QTextLayout 可用于纯文本和富文本。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值