Fix ioi strings in rpkg load dialogs, fix transparency

Author: dbierek

include/NavKit/render/Mesh.h

@@ -38,6 +38,7 @@ class Mesh {
     glm::vec3 aabbMax;
 
     bool isTransparent = false;
+    bool isBlended = false;
 
     Mesh(const std::vector<Vertex>& vertices, const std::vector<unsigned int>& indices,
          const std::vector<Texture>& textures);

src/module/Rpkg.cpp

@@ -42,9 +42,7 @@ void Rpkg::initExtractionData() {
                         const std::string navpHash =
                             dotPos != std::string::npos ? hashPart.substr(0, dotPos) : hashPart;
                         std::lock_guard lock(Navp::navpHashIoiStringMapMutex);
-                        if (Navp::navpHashIoiStringMap.contains(navpHash)) {
-                            Navp::navpHashIoiStringMap[navpHash] = ioiString;
-                        }
+                        Navp::navpHashIoiStringMap[navpHash] = ioiString;
                     }
                 }
                 if (line.find(".AIRG") != std::string::npos) {
@@ -58,9 +56,7 @@ void Rpkg::initExtractionData() {
                         const std::string airgHash =
                             dotPos != std::string::npos ? hashPart.substr(0, dotPos) : hashPart;
                         std::lock_guard lock(Airg::airgHashIoiStringMapMutex);
-                        if (Airg::airgHashIoiStringMap.contains(airgHash)) {
-                            Airg::airgHashIoiStringMap[airgHash] = ioiString;
-                        }
+                        Airg::airgHashIoiStringMap[airgHash] = ioiString;
                     }
                 }
             }

src/render/Mesh.cpp

@@ -26,13 +26,20 @@ Mesh::Mesh(const std::vector<Vertex>& vertices, const std::vector<unsigned int>&
             aabbMax = glm::max(aabbMax, v.position);
             if (v.color.a < 0.99f) {
                 isTransparent = true;
+                if (v.color.a > 0.1f) {
+                    isBlended = true;
+                }
             }
         }
     }
 
     for (const auto& t : textures) {
         if (t.uploadFormat == GL_RGBA) {
             isTransparent = true;
+            // We assume RGBA textures might need blending, 
+            // but the shader handles cutout with discard.
+            // If it's a known format or we could check the data, we'd be more sure.
+            // For now, let's treat RGBA as "could be transparent".
             break;
         }
     }

src/render/Model.cpp

@@ -275,48 +275,44 @@ void Model::draw(const Shader& shader, const glm::mat4& viewProj) const {
             viewProj[2][3] + (i % 2 == 0 ? 1 : -1) * viewProj[2][i / 2],
             viewProj[3][3] + (i % 2 == 0 ? 1 : -1) * viewProj[3][i / 2]
         );
+        const float length = glm::length(glm::vec3(planes[i]));
+        if (length > 0.0f) {
+            planes[i] /= length;
+        }
     }
 
-    auto& [drawOrder, sortFuture] = sortContexts[this];
-
-    if (drawOrder.size() != meshes.size()) {
-        drawOrder.resize(meshes.size());
-        std::iota(drawOrder.begin(), drawOrder.end(), 0);
-    }
+    std::vector<unsigned int> opaqueIndices;
+    std::vector<unsigned int> transparentIndices;
+    opaqueIndices.reserve(meshes.size());
+    transparentIndices.reserve(meshes.size());
 
-    if (sortFuture.valid() && sortFuture.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
-        if (std::vector<unsigned int> newOrder = sortFuture.get(); newOrder.size() == meshes.size()) {
-            drawOrder = std::move(newOrder);
+    for (unsigned int i = 0; i < meshes.size(); ++i) {
+        if (meshes[i].isBlended) {
+            transparentIndices.push_back(i);
+        } else {
+            opaqueIndices.push_back(i);
         }
     }
 
-    if (!sortFuture.valid()) {
-        std::vector<glm::vec3> centers;
-        centers.reserve(meshes.size());
-        for (const auto& mesh : meshes) {
-            centers.push_back((mesh.aabbMin + mesh.aabbMax) * 0.5f);
-        }
-
-        sortFuture = std::async(std::launch::async, [centers = std::move(centers), viewProj]() {
-            std::vector<unsigned int> indices(centers.size());
-            std::iota(indices.begin(), indices.end(), 0);
+    std::vector<float> distances(meshes.size());
+    for (size_t i = 0; i < meshes.size(); ++i) {
+        const glm::vec3 center = (meshes[i].aabbMin + meshes[i].aabbMax) * 0.5f;
+        distances[i] = (viewProj * glm::vec4(center, 1.0f)).w;
+    }
 
-            std::vector<float> distances(centers.size());
-            for (size_t i = 0; i < centers.size(); ++i) {
-                distances[i] = (viewProj * glm::vec4(centers[i], 1.0f)).w;
-            }
+    // Sort Opaque Front-to-Back (Optimizes overdraw)
+    std::sort(opaqueIndices.begin(), opaqueIndices.end(), [&](unsigned int a, unsigned int b) {
+        return distances[a] < distances[b];
+    });
 
-            std::ranges::sort(indices, [&](unsigned int a, unsigned int b) {
-                return distances[a] > distances[b];
-            });
-            return indices;
-        });
-    }
+    // Sort Transparent Back-to-Front (Required for correct blending)
+    std::sort(transparentIndices.begin(), transparentIndices.end(), [&](unsigned int a, unsigned int b) {
+        return distances[a] > distances[b];
+    });
 
-    // Pass 1: Opaque meshes
-    for (const unsigned int i : drawOrder) {
+    // Pass 1: Opaque meshes (including cutout transparency)
+    for (const unsigned int i : opaqueIndices) {
         const Mesh& mesh = meshes[i];
-        if (mesh.isTransparent) continue;
 
         const glm::vec3 center = (mesh.aabbMin + mesh.aabbMax) * 0.5f;
         const glm::vec3 extents = (mesh.aabbMax - mesh.aabbMin) * 0.5f;
@@ -334,10 +330,9 @@ void Model::draw(const Shader& shader, const glm::mat4& viewProj) const {
         }
     }
 
-    // Pass 2: Transparent meshes (sorted back-to-front by distances[a] > distances[b])
-    for (const unsigned int i : drawOrder) {
+    // Pass 2: Blended transparent meshes (sorted back-to-front by distances[a] > distances[b])
+    for (const unsigned int i : transparentIndices) {
         const Mesh& mesh = meshes[i];
-        if (!mesh.isTransparent) continue;
 
         const glm::vec3 center = (mesh.aabbMin + mesh.aabbMax) * 0.5f;
         const glm::vec3 extents = (mesh.aabbMax - mesh.aabbMin) * 0.5f;