Dust3D开源项目分析——渲染与材质部分 | 纹理生成 Part5

最新推荐文章于 2026-07-02 11:03:30 发布
原创 最新推荐文章于 2026-07-02 11:03:30 发布 · 376 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
Dust3D

当前文章被收录于：

Dust3D
14 篇文章 1 人学习
订阅专栏 查看详情
该博客详细介绍了三维图形渲染中溶解性贴图的绘制过程，涉及三角形处理、邻域半边结构填充以及纹理生成的算法。在处理过程中，遇到无效的三角形和找不到的UV矩形时，会进行异常处理并跳过。最后，通过Qt进行纹理的生成和清理，完成整个渲染任务。

 2021SC@SDUSC

auto drawBySolubility = [&](const QUuid &partId, size_t triangleIndex, size_t firstVertexIndex, size_t secondVertexIndex,
            const QUuid &neighborPartId) {
        const std::vector<QVector2D> &uv = triangleVertexUvs[triangleIndex];
        const auto &allRects = partUvRects.find(partId);
        if (allRects == partUvRects.end()) {
            qDebug() << "Found part uv rects failed";
            return;
        }
        const auto &firstPoint = uv[firstVertexIndex];
        const auto &secondPoint = uv[secondVertexIndex];
        auto edgeLength = firstPoint.distanceToPoint(secondPoint);
        auto middlePoint = (firstPoint + secondPoint) / 2.0;
        float alpha = 1.0;
        const auto &findColor = partColorMap.find(partId);
        if (findColor == partColorMap.end())
            return;
        alpha = findColor->second.alphaF();
        const auto &findNeighborColorSolubility = partColorSolubilityMap.find(neighborPartId);
        if (findNeighborColorSolubility == partColorSolubilityMap.end())
            return;
        if (qFuzzyIsNull(findNeighborColorSolubility->second))
            return;
        const auto &findNeighborColor = partColorMap.find(neighborPartId);
        if (findNeighborColor == partColorMap.end())
            return;
        for (const auto &it: allRects->second) {
            if (it.contains(firstPoint.x(), firstPoint.y()) ||
                    it.contains(secondPoint.x(), secondPoint.y())) {
                float finalRadius = (it.width() + it.height()) * 0.5 * findNeighborColorSolubility->second;
                if (finalRadius < edgeLength)
                    finalRadius = edgeLength;
                QRectF fillTarget((middlePoint.x() - finalRadius),
                    (middlePoint.y() - finalRadius),
                    (finalRadius + finalRadius),
                    (finalRadius + finalRadius));
                auto clippedRect = it.intersected(fillTarget);
                QRectF translatedRect = {
                    clippedRect.left() * TextureGenerator::m_textureSize,
                    clippedRect.top() * TextureGenerator::m_textureSize,
                    clippedRect.width() * TextureGenerator::m_textureSize,
                    clippedRect.height() * TextureGenerator::m_textureSize
                };
                texturePainter.setOpacity(alpha);
                auto findTextureResult = partColorTexturePixmaps.find(neighborPartId);
                if (findTextureResult != partColorTexturePixmaps.end()) {
                    const auto &pixmap = findTextureResult->second.first;
                    const auto &rotatedPixmap = findTextureResult->second.second;
                    
                    QImage tmpImage(translatedRect.width(), translatedRect.height(), QImage::Format_ARGB32);
                    QPixmap tmpPixmap = QPixmap::fromImage(tmpImage);
                    QPainter tmpPainter;
                    QRectF tmpImageFrame = QRectF(0, 0, translatedRect.width(), translatedRect.height());
                    
                    // Fill tiled texture
                    tmpPainter.begin(&tmpPixmap);
                    tmpPainter.setOpacity(alpha);
                    if (it.width() < it.height()) {
                        tmpPainter.drawTiledPixmap(tmpImageFrame, rotatedPixmap, QPointF(translatedRect.top(), translatedRect.left()));
                    } else {
                        tmpPainter.drawTiledPixmap(tmpImageFrame, pixmap, translatedRect.topLeft());
                    }
                    tmpPainter.setOpacity(1.0);
                    tmpPainter.end();
                    
                    // Apply gradient
                    QRadialGradient gradient(QPointF(middlePoint.x() * TextureGenerator::m_textureSize - translatedRect.left(),
                        middlePoint.y() * TextureGenerator::m_textureSize - translatedRect.top()),
                        finalRadius * TextureGenerator::m_textureSize);
                    gradient.setColorAt(0.0, findNeighborColor->second);
                    gradient.setColorAt(1.0, Qt::transparent);
                    
                    tmpPainter.begin(&tmpPixmap);
                    tmpPainter.setCompositionMode(QPainter::CompositionMode_DestinationIn);
                    tmpPainter.fillRect(tmpImageFrame, gradient);
                    tmpPainter.end();
                    
                    texturePainter.drawPixmap(translatedRect, tmpPixmap, tmpImageFrame);
                } else {
                    QRadialGradient gradient(QPointF(middlePoint.x() * TextureGenerator::m_textureSize,
                        middlePoint.y() * TextureGenerator::m_textureSize),
                        finalRadius * TextureGenerator::m_textureSize);
                    gradient.setColorAt(0.0, findNeighborColor->second);
                    gradient.setColorAt(1.0, Qt::transparent);
                    texturePainter.fillRect(translatedRect, gradient);
                }
                texturePainter.setOpacity(1.0);
                break;
            }
        }
    };
    
    std::map<std::pair<size_t, size_t>, std::tuple<size_t, size_t, size_t>> halfEdgeToTriangleMap;
    for (size_t i = 0; i < m_object->triangles.size(); ++i) {
        const auto &triangleIndices = m_object->triangles[i];
        if (triangleIndices.size() != 3) {
            qDebug() << "Found invalid triangle indices";
            continue;
        }
        for (size_t j = 0; j < triangleIndices.size(); ++j) {
            size_t k = (j + 1) % triangleIndices.size();
            halfEdgeToTriangleMap.insert(std::make_pair(std::make_pair(triangleIndices[j], triangleIndices[k]),
                std::make_tuple(i, j, k)));
        }
    }
    for (const auto &it: halfEdgeToTriangleMap) {
        auto oppositeHalfEdge = std::make_pair(it.first.second, it.first.first);
        const auto &opposite = halfEdgeToTriangleMap.find(oppositeHalfEdge);
        if (opposite == halfEdgeToTriangleMap.end())
            continue;
        const std::pair<QUuid, QUuid> &source = triangleSourceNodes[std::get<0>(it.second)];
        const std::pair<QUuid, QUuid> &oppositeSource = triangleSourceNodes[std::get<0>(opposite->second)];
        if (source.first == oppositeSource.first)
            continue;
        drawBySolubility(source.first, std::get<0>(it.second), std::get<1>(it.second), std::get<2>(it.second), oppositeSource.first);
        drawBySolubility(oppositeSource.first, std::get<0>(opposite->second), std::get<1>(opposite->second), std::get<2>(opposite->second), source.first);
    }
    
    // Draw belly white
    texturePainter.setCompositionMode(QPainter::CompositionMode_SoftLight);
    for (size_t triangleIndex = 0; triangleIndex < m_object->triangles.size(); ++triangleIndex) {
        const auto &normal = triangleNormals[triangleIndex];
        const std::pair<QUuid, QUuid> &source = triangleSourceNodes[triangleIndex];
        const auto &partId = source.first;
        if (m_countershadedPartIds.find(partId) == m_countershadedPartIds.end())
            continue;
        
        const auto &allRects = partUvRects.find(partId);
        if (allRects == partUvRects.end()) {
            qDebug() << "Found part uv rects failed";
            continue;
        }
        
        const auto &findObjectNode = nodeMap.find(source);
        if (findObjectNode == nodeMap.end())
            continue;
        const ObjectNode *objectNode = findObjectNode->second;
        if (qAbs(QVector3D::dotProduct(objectNode->direction, QVector3D(0, 1, 0))) >= 0.707) {
            if (QVector3D::dotProduct(normal, QVector3D(0, 0, 1)) <= 0.0)
                continue;
        } else {
            if (QVector3D::dotProduct(normal, QVector3D(0, -1, 0)) <= 0.0)
                continue;
        }
        
        const auto &triangleIndices = m_object->triangles[triangleIndex];
        if (triangleIndices.size() != 3) {
            qDebug() << "Found invalid triangle indices";
            continue;
        }
        
        const std::vector<QVector2D> &uv = triangleVertexUvs[triangleIndex];
        QVector2D middlePoint = (uv[0] + uv[1] + uv[2]) / 3.0;
        float finalRadius = (uv[0].distanceToPoint(uv[1]) +
            uv[1].distanceToPoint(uv[2]) +
            uv[2].distanceToPoint(uv[0])) / 3.0;
        QRadialGradient gradient(QPointF(middlePoint.x() * TextureGenerator::m_textureSize,
            middlePoint.y() * TextureGenerator::m_textureSize),
            finalRadius * TextureGenerator::m_textureSize);
        gradient.setColorAt(0.0, Qt::white);
        gradient.setColorAt(1.0, Qt::transparent);
        for (const auto &it: allRects->second) {
            if (it.contains(middlePoint.x(), middlePoint.y())) {
                QRectF fillTarget((middlePoint.x() - finalRadius),
                    (middlePoint.y() - finalRadius),
                    (finalRadius + finalRadius),
                    (finalRadius + finalRadius));
                auto clippedRect = it.intersected(fillTarget);
                QRectF translatedRect = {
                    clippedRect.left() * TextureGenerator::m_textureSize,
                    clippedRect.top() * TextureGenerator::m_textureSize,
                    clippedRect.width() * TextureGenerator::m_textureSize,
                    clippedRect.height() * TextureGenerator::m_textureSize
                };
                texturePainter.fillRect(translatedRect, gradient);
            }
        }
        
        // Fill the neighbor halfedges
        for (int i = 0; i < 3; ++i) {
            int j = (i + 1) % 3;
            auto oppositeHalfEdge = std::make_pair(triangleIndices[j], triangleIndices[i]);
            const auto &opposite = halfEdgeToTriangleMap.find(oppositeHalfEdge);
            if (opposite == halfEdgeToTriangleMap.end())
                continue;
            auto oppositeTriangleIndex = std::get<0>(opposite->second);
            const std::pair<QUuid, QUuid> &oppositeSource = triangleSourceNodes[oppositeTriangleIndex];
            if (partId == oppositeSource.first)
                continue;
            const auto &oppositeAllRects = partUvRects.find(oppositeSource.first);
            if (oppositeAllRects == partUvRects.end()) {
                qDebug() << "Found part uv rects failed";
                continue;
            }
            const std::vector<QVector2D> &oppositeUv = triangleVertexUvs[oppositeTriangleIndex];
            QVector2D oppositeMiddlePoint = (oppositeUv[std::get<1>(opposite->second)] + oppositeUv[std::get<2>(opposite->second)]) * 0.5;
            QRadialGradient oppositeGradient(QPointF(oppositeMiddlePoint.x() * TextureGenerator::m_textureSize,
                oppositeMiddlePoint.y() * TextureGenerator::m_textureSize),
                finalRadius * TextureGenerator::m_textureSize);
            oppositeGradient.setColorAt(0.0, Qt::white);
            oppositeGradient.setColorAt(1.0, Qt::transparent);
            for (const auto &it: oppositeAllRects->second) {
                if (it.contains(oppositeMiddlePoint.x(), oppositeMiddlePoint.y())) {
                    QRectF fillTarget((oppositeMiddlePoint.x() - finalRadius),
                        (oppositeMiddlePoint.y() - finalRadius),
                        (finalRadius + finalRadius),
                        (finalRadius + finalRadius));
                    auto clippedRect = it.intersected(fillTarget);
                    QRectF translatedRect = {
                        clippedRect.left() * TextureGenerator::m_textureSize,
                        clippedRect.top() * TextureGenerator::m_textureSize,
                        clippedRect.width() * TextureGenerator::m_textureSize,
                        clippedRect.height() * TextureGenerator::m_textureSize
                    };
                    texturePainter.fillRect(translatedRect, oppositeGradient);
                }
            }
        }
    }
    
    hasNormalMap = !m_partNormalTextureMap.empty();
    if (!m_partMetalnessTextureMap.empty())
        hasMetalnessMap = true;
    if (!m_partRoughnessTextureMap.empty())
        hasRoughnessMap = true;
    hasAmbientOcclusionMap = !m_partAmbientOcclusionTextureMap.empty();
    
    auto paintTextureEndTime = countTimeConsumed.elapsed();

    texturePainter.end();
    textureNormalPainter.end();
    textureMetalnessPainter.end();
    textureRoughnessPainter.end();
    textureAmbientOcclusionPainter.end();
    
    if (!hasNormalMap) {
        delete m_resultTextureNormalImage;
        m_resultTextureNormalImage = nullptr;
    }
    
    if (!hasMetalnessMap && !hasRoughnessMap && !hasAmbientOcclusionMap) {
        delete m_resultTextureMetalnessImage;
        m_resultTextureMetalnessImage = nullptr;

        delete m_resultTextureRoughnessImage;
        m_resultTextureRoughnessImage = nullptr;

        delete m_resultTextureAmbientOcclusionImage;
        m_resultTextureAmbientOcclusionImage = nullptr;
    }
    
    auto createResultBeginTime = countTimeConsumed.elapsed();
    m_resultMesh->setTextureImage(new QImage(*m_resultTextureColorImage));
    if (nullptr != m_resultTextureNormalImage)
        m_resultMesh->setNormalMapImage(new QImage(*m_resultTextureNormalImage));
    if (hasMetalnessMap || hasRoughnessMap || hasAmbientOcclusionMap) {
        m_resultMesh->setMetalnessRoughnessAmbientOcclusionImage(combineMetalnessRoughnessAmbientOcclusionImages(
            m_resultTextureMetalnessImage,
            m_resultTextureRoughnessImage,
            m_resultTextureAmbientOcclusionImage));
        m_resultMesh->setHasMetalnessInImage(hasMetalnessMap);
        m_resultMesh->setHasRoughnessInImage(hasRoughnessMap);
        m_resultMesh->setHasAmbientOcclusionInImage(hasAmbientOcclusionMap);
    }
    auto createResultEndTime = countTimeConsumed.elapsed();
    
    qDebug() << "The texture[" << TextureGenerator::m_textureSize << "x" << TextureGenerator::m_textureSize << "] generation took" << countTimeConsumed.elapsed() << "milliseconds";
}

drawSolubility这里也是一个Lambda Function，用于绘制溶解性贴图。之后是一个debug环节，遍历m_object的triangles.size()，如果size不为3，说明存在N-Gon，前面的三角化环节没有处理正确，借助Qt抛出异常，跳过这个三角形执行后面的操作。之后在处理局部UV时如果不能判断找到一个UV矩形，同样会抛出异常并跳过当前出问题的partUvRects。处理完毕后，填充邻域的半边结构，做一些最后的清理工作，完成纹理的生成任务。

标签
#3d
WPF 3D入门，MeshGeometry3D的Positions、TriangleIndices和TextureCoordinates的简单理解
Junwillday的专栏
08-13 5543
MeshGeometry3D类是WPF 3D编程中必不可少的一部分，要想正确的使用这个类，对其常用的Positions、TriangleIndices和TextureCoordinates这三个属性的理解非常重要。 1、Positions       首先我们要知道，在计算机的3D世界里，所有的图形都是有三角形组成的，比如，一个正方形可以有两个三角形组成，一个立方体可以有12个三角形组成，Po
Qt/C++编写自定义控件26-平铺背景控件
Qt/C++视频监控/推流/物联网/大屏系统/自定义控件/UI定制/输入法
07-14 1293
一、前言 平铺背景控件，主要的应用场景是作为画布出现，黑白相间的背景图，然后上面可以放置图片图形等，使得看起来更美观，比如PS软件新建图层以后的背景，FireWorks软件新建画布以后的透明背景，ICO制作软件新建画布以后的背景，都会采用一个黑白相间的背景。尽管本人用QPainter很多年，后面在翻阅QPainter自带的函数中才发现居然QPainter自带了这个绘制平铺背景的函数，擦，他么叫dr...
Qt 完成图片的缩放拖动
qq_35662333的博客
03-29 2809
1）右击界面文件—添加新文件—QT—QT设计师界面类—choose—Dialog without buttons。现再添加一界面用于单独显示图片，作为子窗口供调用（当然，也可在main.c直接调用，作为父窗口）。按钮的回调函数主要用来修改变量的值。修改完后，调用update_para、update，重绘。其中，label控件仅仅是提供绘图的区域，但最终绘图不是绘在label控件上。update_para函数用来确定drawTiledPixmap函数的各参数。构造函数中，添加输入图片的读取，以及变量初始化。
QT-Qpixmap实现图片鼠标缩放,鼠标拖动示例(详解)
热门推荐
su1041168096的博客
07-19 1万+
通过 QPainter 绘画实现,以本地图片985*740为例 转载地址：https://www.cnblogs.com/lifexy/p/9057046.html 如下图所示: 效果如下所示: 实现原理 主要通过以下函数实现: void QPainter::drawTiledPixmap ( int x, int y, int w int h const QPixmap &a...
别再死记公式了！用Python+LTspice快速搞定RC低通滤波器设计与仿真（附代码）
weixin_33716154的博客
06-02 398
本文介绍如何利用Python和LTspice进行RC低通滤波器设计与仿真，避免死记硬背公式。通过Python进行参数计算和可视化分析，结合LTspice进行电路仿真验证，实现从理论到实践的完整设计流程。特别适合电子工程师和信号处理爱好者快速掌握无源低通滤波器的工程应用。
Qt：玩转QPainter序列八(QPixmap,QImage)
m0_71489826的博客
08-28 1863
继续。
Dust3D开源项目分析——渲染与材质部分 | 纹理生成 Part1
JosonTon的博客
10-17 431
2021SC@SDUSC 通过阅读源码文件和查阅相关资料，笔者发现Dust 3D使用的图形引擎是（基于Qt的）OpenGL，或者说QOpenGL。就Qt 5.0 而言，QOpenGL是建立在OpenGL ES(Embeded System)2.0规范上的，可以说是OpenGL ES 3.0的弱化版本。事实上OpenGL ES 2.0是2004年发布的一个相当古老的版本，并不支持部分相对先进的OpenGL方法、数据格式、快捷算法等功能。笔者认为之所以选用2.0版本，一方面是因为Dust ...
AI视觉任务算法全景详解（全部任务类型与对应算法列表）
最新发布
weixin_45590420的博客
07-02 280
本文档全面梳理了计算机视觉领域的46类核心任务及600+主流算法，涵盖图像理解、目标检测、3D视觉、图像增强、生成编辑、视频处理等方向。内容包含每类任务的算法原理、演进脉络和工业选型建议，并附6个实用附录（选型速查表、骨干网络对比、数据集汇总等）。适用于算法工程师、视觉AI研究员和技术决策者进行技术调研和项目落地参考，技术栈覆盖深度学习框架与CUDA加速方案。文档采用系统化分类体系，提供从理论到实践的完整指导。
Qt背景平铺
sc_o_r_pio的博客
06-13 395
QT实现窗口平铺的方式有3种
【qt】绘制图像
lsz441的博客
03-06 659
17[(1024∗1024768∗76821​​75.2PPI75.225.4​0.3377毫米示例：若系统设置的DIP为M 像素/英寸(ppi)，设备像素为N 像素/英寸，假设我们绘制X像素长度的图形，若使用DIP绘制图形，求显示屏实际显示的像素Y为多少所绘制图形的逻辑长度：L = (X像素) / (M像素/英寸) = X /M 英寸;以上公式要注意的是X / M结果的单位是英寸。
绘画系统(03)：【类】QPainter[官翻]
读书笔记
09-27 2068
QPainter提供了绘制大多数图元的函数：drawPoint(),drawPoints(),drawLine(),drawRect(),drawRoundedRect( )，drawEllipse( )，drawArc( )，drawPie( )，drawChord( )，drawPolyline( )，drawPolygon( )，drawConvexPolygon( )和drawCubicBezier( )。在某些情况下，也可以使用昂贵的操作，例如，将结果缓存在QPixmap中。
qt绘制背景图加速方法
07-04 2620
在使用qt3.3.2开发实时系统的图形时,如果我们需要设置图形的背景图,需要使用下面的函数进行绘制: void QPainter::drawImage ( const QPoint &, const QImage &, const QRect & sr, int conversionFlags = 0 ) 或者是  void QPainter::drawPixmap ( int x, int
QT--2D绘图
DanyLin's CSDN
08-31 2576
2D绘图简介         Qt4中的2D绘图部分称为Arthur绘图系统，它由3个类支撑整个框架，QPainter,QPainterDevice和QPainterEngine。QPainter用来执行具体的绘图相关操作如画点，画线，填充，变换，alpha通道等。QPainterDevice是QPainter用来绘图的绘图设备，Qt中有几种预定义的绘图设备，如QWidget,QPixamp,Q
QPainter绘制图片填充方式（正常大小、剪切大小、自适应大小、平铺）
weixin_30437337的博客
07-22 1821
Qt中QPainter提供了绘制图像的API，极大地方便了我们对图像的绘制。 Qt中提供了QPixmap, QBitmap,QBitMapQImage,QPicture等图像绘图设备，它们的类关系如下图所示： QPixmap继承了QPaintDevice，您可用以建立QPainter并于上进行绘图，您也可以直接指定图案加载Qt所支持的图档，像是BMP、GIF、JPG、JPEG、PNG等，并...
Qt开发之绘图与更新绘图
Demo.demo的博客
01-10 3434
关于Qt的绘画，简单介绍吧，一些常用的知识点 Qt中的所有的图都是画出来的，例如我们的按钮，窗口，标签上的图 画图需要两个东西 1.画家QPainter 2.画板QPaintDevice（常见的控件，按钮label窗口） Qt绘图机制为屏幕显示和打印显示提供了统一的API接口，主要有三部分组成： （1）QPainter类，提供了画图的各种接口，可方便地绘制各种各样的图形 （2）QPaintDevice类，提供可用于画图的控件，及画图容器 （3）QPainterEngine类，抽象类，提供了Q
Qt实战案例（20）——利用QPixmap实现图片缩放、平移等操作
Wendy的博客
01-12 5887
目录一、项目介绍二、项目基本配置三、UI界面设计四、主程序实现4.1 widget.h头文件4.2 widget.cpp源文件五、效果演示 一、项目介绍 利用QPixmap实现图片缩放、平移等操作。 二、项目基本配置 新建一个Qt案例，项目名称为“PhotoTest”，基类选择“QWidget”，取消创建UI界面复选框的选中状态，完成项目创建。 三、UI界面设计 无UI界面 四、主程序实现 4.1 widget.h头文件 4.2 widget.cpp源文件 五、效果演示 ...
QStyle实现自绘界面项目实战（二）
danshiming的博客
06-26 2213
利用QStyle实现自定义风格
WPF 3D MeshGeometry3D类的Positions和TriangleIndices属性研究
bcbobo21cn的专栏
12-02 1427
WPF 3D MeshGeometry3D类的Positions和TriangleIndices属性；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值