Fix UV map generator

application/sources/component_property_widget.cc

@@ -57,7 +57,7 @@ ComponentPropertyWidget::ComponentPropertyWidget(Document* document,
 
     QHBoxLayout* topLayout = new QHBoxLayout;
 
-    if (hasTextureConfigure()) {
+    if (!m_componentIds.empty()) {
         QPushButton* colorPreviewArea = new QPushButton;
         colorPreviewArea->setStyleSheet("QPushButton {background-color: " + m_color.name() + "; border-radius: 0;}");
         colorPreviewArea->setFixedSize(Theme::toolIconSize * 1.8, Theme::toolIconSize);
@@ -309,7 +309,7 @@ ComponentPropertyWidget::ComponentPropertyWidget(Document* document,
     }
 
     QGroupBox* colorImageGroupBox = nullptr;
-    if (hasTextureConfigure()) {
+    if (!m_componentIds.empty()) {
         ImagePreviewWidget* colorImagePreviewWidget = new ImagePreviewWidget;
         colorImagePreviewWidget->setFixedSize(Theme::partPreviewImageSize * 2, Theme::partPreviewImageSize * 2);
         auto colorImageId = lastColorImageId();
@@ -507,25 +507,3 @@ void ComponentPropertyWidget::showColorDialog()
     }
     emit groupOperationAdded();
 }
-
-bool ComponentPropertyWidget::hasTextureConfigure()
-{
-    if (!m_partIds.empty())
-        return true;
-
-    for (const auto& componentId : m_componentIds) {
-        const Document::Component* parentComponent = m_document->findComponent(componentId);
-        if (nullptr == parentComponent)
-            continue;
-        for (const auto& childId : parentComponent->childrenIds) {
-            const Document::Component* component = m_document->findComponent(childId);
-            if (nullptr == component)
-                continue;
-            if (component->linkToPartId.isNull())
-                continue;
-            return true;
-        }
-    }
-
-    return false;
-}

application/sources/component_property_widget.h

@@ -50,7 +50,6 @@ public slots:
     std::vector<QString> m_cutFaceList;
 
     void updateCutFaceButtonState(size_t index);
-    bool hasTextureConfigure();
 };
 
 #endif

application/sources/uv_map_generator.cc

@@ -93,74 +93,40 @@ QImage* UvMapGenerator::combineMetalnessRoughnessAmbientOcclusionImages(QImage*
     return textureMetalnessRoughnessAmbientOcclusionImage;
 }
 
-void UvMapGenerator::collectStitchingLines(const std::map<std::string, std::string>& component)
-{
-    // TODO: Pick the most occurent image id and color
-    // ...
-
-    /*
-    for (const auto& childId : dust3d::String::split(dust3d::String::valueOrEmpty(component, "children"), ',')) {
-        if (childId.empty())
-            continue;
-        dust3dDebug << childId;
-        const auto& componentIt = m_snapshot->components.find(childId);
-        if (componentIt == m_snapshot->components.end())
-            continue;
-        if ("partId" != dust3d::String::valueOrEmpty(componentIt->second, "linkDataType")) {
-            collectStitchingLines(componentIt->second);
-            continue;
-        }
-        const auto& partIt = m_snapshot->parts.find(dust3d::String::valueOrEmpty(componentIt->second, "linkData"));
-        if (partIt == m_snapshot->parts.end())
-            continue;
-        auto partTarget = dust3d::PartTargetFromString(dust3d::String::valueOrEmpty(partIt->second, "target").c_str());
-        if (dust3d::PartTarget::StitchingLine != partTarget)
-            continue;
-        dust3dDebug << childId << partIt->first;
-        // TODO:
-    }
-    */
-}
-
 void UvMapGenerator::packUvs()
 {
     m_mapPacker = std::make_unique<dust3d::UvMapPacker>();
 
-    for (const auto& partIt : m_snapshot->parts) {
-        auto partTarget = dust3d::PartTargetFromString(dust3d::String::valueOrEmpty(partIt.second, "target").c_str());
-        if (dust3d::PartTarget::Model != partTarget)
+    for (const auto& componentTriangleUvIt : m_object->componentTriangleUvs) {
+        auto componentIt = m_snapshot->components.find(componentTriangleUvIt.first.toString());
+        if (componentIt == m_snapshot->components.end())
             continue;
         dust3d::Uuid imageId;
         dust3d::Color color(1.0, 1.0, 1.0);
         double width = 1.0;
         double height = 1.0;
-        const auto& colorIt = partIt.second.find("color");
-        if (colorIt != partIt.second.end()) {
+        const auto& colorIt = componentIt->second.find("color");
+        if (colorIt != componentIt->second.end()) {
             color = dust3d::Color(colorIt->second);
         }
-        const auto& colorImageIdIt = partIt.second.find("colorImageId");
-        if (colorImageIdIt != partIt.second.end()) {
+        const auto& colorImageIdIt = componentIt->second.find("colorImageId");
+        if (colorImageIdIt != componentIt->second.end()) {
             imageId = dust3d::Uuid(colorImageIdIt->second);
             const QImage* image = ImageForever::get(imageId);
             if (nullptr != image) {
                 width = image->width();
                 height = image->height();
             }
         }
-        const auto& findUvs = m_object->partTriangleUvs.find(dust3d::Uuid(partIt.first));
-        if (findUvs == m_object->partTriangleUvs.end())
-            continue;
         dust3d::UvMapPacker::Part part;
         part.id = imageId;
         part.color = color;
         part.width = width;
         part.height = height;
-        part.localUv = findUvs->second;
+        part.localUv = componentTriangleUvIt.second;
         m_mapPacker->addPart(part);
     }
 
-    collectStitchingLines(m_snapshot->rootComponent);
-
     m_mapPacker->addSeams(m_object->seamTriangleUvs);
 
     m_mapPacker->pack();

application/sources/uv_map_generator.h

@@ -43,7 +43,6 @@ public slots:
     bool m_hasTransparencySettings = false;
     static size_t m_textureSize;
     void packUvs();
-    void collectStitchingLines(const std::map<std::string, std::string>& component);
     void generateTextureColorImage();
     void generateUvCoords();
 };

dust3d/base/object.h

@@ -62,7 +62,7 @@ class Object {
     std::map<Uuid, ObjectNode> nodeMap;
     std::vector<std::vector<size_t>> triangleAndQuads;
     std::vector<std::vector<size_t>> triangles;
-    std::unordered_map<Uuid, std::map<std::array<PositionKey, 3>, std::array<Vector2, 3>>> partTriangleUvs;
+    std::unordered_map<Uuid, std::map<std::array<PositionKey, 3>, std::array<Vector2, 3>>> componentTriangleUvs;
     std::vector<std::map<std::array<PositionKey, 3>, std::array<Vector2, 3>>> seamTriangleUvs;
     std::vector<Vector3> triangleNormals;
     std::vector<Color> vertexColors;

dust3d/mesh/mesh_generator.cc

@@ -501,7 +501,7 @@ std::unique_ptr<MeshState> MeshGenerator::combineStitchingMesh(const std::string
 
     const auto& faceUvs = stitchMeshBuilder->generatedFaceUvs();
     Uuid componentId = Uuid(componentIdString);
-    auto& triangleUvs = componentCache.partTriangleUvs[componentId];
+    auto& triangleUvs = componentCache.componentTriangleUvs[componentId];
     for (size_t i = 0; i < faceUvs.size(); ++i) {
         const auto& uv = faceUvs[i];
         const auto& face = generatedFaces[i];
@@ -823,7 +823,7 @@ std::unique_ptr<MeshState> MeshGenerator::combineComponentMesh(const std::string
             for (const auto& vertex : partCache.vertices)
                 componentCache.noneSeamVertices.insert(vertex);
             collectSharedQuadEdges(partCache.vertices, partCache.faces, &componentCache.sharedQuadEdges);
-            componentCache.partTriangleUvs.insert({ Uuid(partIdString), partCache.triangleUvs });
+            componentCache.componentTriangleUvs.insert({ componentId, partCache.triangleUvs });
             for (const auto& it : partCache.positionToNodeIdMap)
                 componentCache.positionToNodeIdMap.emplace(it);
             for (const auto& it : partCache.nodeMap)
@@ -959,8 +959,8 @@ std::unique_ptr<MeshState> MeshGenerator::combineComponentChildGroupMesh(const s
             componentCache.noneSeamVertices.insert(vertex);
         for (const auto& it : childComponentCache.sharedQuadEdges)
             componentCache.sharedQuadEdges.insert(it);
-        for (const auto& it : childComponentCache.partTriangleUvs)
-            componentCache.partTriangleUvs.insert({ it.first, it.second });
+        for (const auto& it : childComponentCache.componentTriangleUvs)
+            componentCache.componentTriangleUvs.insert({ it.first, it.second });
         for (const auto& it : childComponentCache.positionToNodeIdMap)
             componentCache.positionToNodeIdMap.emplace(it);
         for (const auto& it : childComponentCache.nodeMap)
@@ -1073,8 +1073,8 @@ void MeshGenerator::collectIncombinableMesh(const MeshState* mesh, const Generat
     updateVertexIndices(uncombinedFaces);
     updateVertexIndices(uncombinedTriangleAndQuads);
 
-    for (const auto& it : componentCache.partTriangleUvs)
-        m_object->partTriangleUvs.insert({ it.first, it.second });
+    for (const auto& it : componentCache.componentTriangleUvs)
+        m_object->componentTriangleUvs.insert({ it.first, it.second });
     for (const auto& it : componentCache.positionToNodeIdMap)
         m_object->positionToNodeIdMap.emplace(it);
     for (const auto& it : componentCache.nodeMap)
@@ -1267,7 +1267,7 @@ void MeshGenerator::generate()
 
     m_object->positionToNodeIdMap = componentCache.positionToNodeIdMap;
     m_object->nodeMap = componentCache.nodeMap;
-    m_object->partTriangleUvs = componentCache.partTriangleUvs;
+    m_object->componentTriangleUvs = componentCache.componentTriangleUvs;
 
     std::vector<Vector3> combinedVertices;
     std::vector<std::vector<size_t>> combinedFaces;

dust3d/mesh/mesh_generator.h

@@ -71,7 +71,7 @@ class MeshGenerator {
     struct GeneratedComponent {
         std::unique_ptr<MeshState> mesh;
         std::set<std::pair<PositionKey, PositionKey>> sharedQuadEdges;
-        std::unordered_map<Uuid, std::map<std::array<PositionKey, 3>, std::array<Vector2, 3>>> partTriangleUvs;
+        std::unordered_map<Uuid, std::map<std::array<PositionKey, 3>, std::array<Vector2, 3>>> componentTriangleUvs;
         std::vector<std::map<std::array<PositionKey, 3>, std::array<Vector2, 3>>> seamTriangleUvs;
         std::set<PositionKey> noneSeamVertices;
         std::map<PositionKey, Uuid> positionToNodeIdMap;
@@ -80,7 +80,7 @@ class MeshGenerator {
         {
             mesh.reset();
             sharedQuadEdges.clear();
-            partTriangleUvs.clear();
+            componentTriangleUvs.clear();
             seamTriangleUvs.clear();
             noneSeamVertices.clear();
             positionToNodeIdMap.clear();