occt-gltf-addon 0.1.0

package/src/occt_convert_xde.cpp

@@ -0,0 +1,760 @@
+#include "occt_convert.h"
+
+#include <algorithm>
+#include <chrono>
+#include <cstdint>
+#include <functional>
+#include <iostream>
+#include <cmath>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+
+// OCCT tessellation
+#include <BRepMesh_IncrementalMesh.hxx>
+#include <BRepBndLib.hxx>
+#include <BRep_Tool.hxx>
+#include <Bnd_Box.hxx>
+#include <IMeshTools_Parameters.hxx>
+#include <Poly_Triangulation.hxx>
+#include <TopExp_Explorer.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopoDS_Shape.hxx>
+#include <TopLoc_Location.hxx>
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <gp_Trsf.hxx>
+
+// OCCT XDE (assembly + names)
+#include <STEPCAFControl_Reader.hxx>
+#include <TDocStd_Document.hxx>
+#include <TDataStd_Name.hxx>
+#include <TDF_Label.hxx>
+#include <XCAFDoc_DocumentTool.hxx>
+#include <XCAFDoc_ColorTool.hxx>
+#include <XCAFDoc_ShapeTool.hxx>
+#include <TopTools_ShapeMapHasher.hxx>
+#include <NCollection_DataMap.hxx>
+#include <Quantity_ColorRGBA.hxx>
+
+static inline void AppendVec3(std::vector<float>& dst, const gp_Vec& v)
+{
+  dst.push_back(static_cast<float>(v.X()));
+  dst.push_back(static_cast<float>(v.Y()));
+  dst.push_back(static_cast<float>(v.Z()));
+}
+
+static inline void AppendPnt3(std::vector<float>& dst, const gp_Pnt& p)
+{
+  dst.push_back(static_cast<float>(p.X()));
+  dst.push_back(static_cast<float>(p.Y()));
+  dst.push_back(static_cast<float>(p.Z()));
+}
+
+static std::string ToUtf8(const TCollection_ExtendedString& s)
+{
+  const int len = s.LengthOfCString();
+  std::vector<char> buf((size_t)len + 1);
+  Standard_PCharacter p = buf.data();
+  s.ToUTF8CString(p);
+  return std::string(buf.data(), (size_t)len);
+}
+
+static std::string GetLabelNameUtf8(const TDF_Label& L)
+{
+  occ::handle<TDataStd_Name> nameAttr;
+  if (L.FindAttribute(TDataStd_Name::GetID(), nameAttr))
+  {
+    return ToUtf8(nameAttr->Get());
+  }
+  return std::string();
+}
+
+static std::array<float, 16> LocationToGltfMatrix(const TopLoc_Location& loc)
+{
+  const gp_Trsf t = loc.Transformation();
+  const double m11 = t.Value(1, 1), m12 = t.Value(1, 2), m13 = t.Value(1, 3), m14 = t.Value(1, 4);
+  const double m21 = t.Value(2, 1), m22 = t.Value(2, 2), m23 = t.Value(2, 3), m24 = t.Value(2, 4);
+  const double m31 = t.Value(3, 1), m32 = t.Value(3, 2), m33 = t.Value(3, 3), m34 = t.Value(3, 4);
+
+  // glTF expects column-major matrices.
+  return {
+    (float)m11, (float)m21, (float)m31, 0.0f,
+    (float)m12, (float)m22, (float)m32, 0.0f,
+    (float)m13, (float)m23, (float)m33, 0.0f,
+    (float)m14, (float)m24, (float)m34, 1.0f
+  };
+}
+
+static MeshData ConvertShapeToMesh(const TopoDS_Shape& shape,
+                                  double linearDeflection,
+                                  double angularDeflection,
+                                  bool smoothNormals,
+                                  double normalCreaseAngle,
+                                  ConvertStats* stats)
+{
+  using Clock = std::chrono::steady_clock;
+  auto ms = [](Clock::time_point a, Clock::time_point b) -> std::uint64_t {
+    return (std::uint64_t)std::chrono::duration_cast<std::chrono::milliseconds>(b - a).count();
+  };
+
+  const Clock::time_point tMesh0 = Clock::now();
+  BRepMesh_IncrementalMesh mesher;
+  mesher.SetShape(shape);
+  IMeshTools_Parameters& params = mesher.ChangeParameters();
+  params.Deflection = linearDeflection;
+  params.Angle = angularDeflection;
+  params.Relative = false;
+  params.InParallel = true;
+  mesher.Perform();
+  const Clock::time_point tMesh1 = Clock::now();
+  if (stats) stats->msMesh += ms(tMesh0, tMesh1);
+
+  MeshData out;
+  out.positions.reserve(1024);
+  out.normals.reserve(1024);
+
+  std::uint64_t faceCount = 0;
+  for (TopExp_Explorer exp(shape, TopAbs_FACE); exp.More(); exp.Next()) { ++faceCount; }
+  if (stats) stats->facesTotal += faceCount;
+
+  const Clock::time_point tExtract0 = Clock::now();
+
+  std::uint64_t facesWithTri = 0;
+  std::uint64_t triCountTotal = 0;
+
+  struct QuantKey
+  {
+    std::int64_t x = 0;
+    std::int64_t y = 0;
+    std::int64_t z = 0;
+    bool operator==(const QuantKey& o) const { return x == o.x && y == o.y && z == o.z; }
+  };
+  struct QuantKeyHash
+  {
+    std::size_t operator()(const QuantKey& k) const noexcept
+    {
+      const std::size_t h1 = std::hash<std::int64_t>{}(k.x);
+      const std::size_t h2 = std::hash<std::int64_t>{}(k.y);
+      const std::size_t h3 = std::hash<std::int64_t>{}(k.z);
+      return h1 ^ (h2 + 0x9e3779b97f4a7c15ULL + (h1 << 6) + (h1 >> 2))
+               ^ (h3 + 0x9e3779b97f4a7c15ULL + (h2 << 6) + (h2 >> 2));
+    }
+  };
+
+  // For smooth normals we need to group triangles by shared vertices.
+  // We weld vertices by quantized position (very fine grid to catch numeric noise).
+  std::vector<QuantKey> keys;
+  std::vector<float> weights; // per-vertex weight (triangle area*2)
+  constexpr double kQuantEps = 1e-6; // in STEP units (usually mm)
+  auto makeKey = [&](const gp_Pnt& p) -> QuantKey {
+    return QuantKey{
+      (std::int64_t)std::llround(p.X() / kQuantEps),
+      (std::int64_t)std::llround(p.Y() / kQuantEps),
+      (std::int64_t)std::llround(p.Z() / kQuantEps)
+    };
+  };
+
+  for (TopExp_Explorer exp(shape, TopAbs_FACE); exp.More(); exp.Next())
+  {
+    const TopoDS_Face face = TopoDS::Face(exp.Current());
+
+    TopLoc_Location triLoc;
+    Handle(Poly_Triangulation) tri = BRep_Tool::Triangulation(face, triLoc);
+    if (tri.IsNull())
+    {
+      continue;
+    }
+    ++facesWithTri;
+
+    const gp_Trsf trsf = triLoc.Transformation();
+
+    for (int i = 1; i <= tri->NbTriangles(); ++i)
+    {
+      int n1 = 0, n2 = 0, n3 = 0;
+      tri->Triangle(i).Get(n1, n2, n3);
+
+      gp_Pnt p1 = tri->Node(n1).Transformed(trsf);
+      gp_Pnt p2 = tri->Node(n2).Transformed(trsf);
+      gp_Pnt p3 = tri->Node(n3).Transformed(trsf);
+
+      const gp_Vec v12(p1, p2);
+      const gp_Vec v13(p1, p3);
+      gp_Vec n = v12.Crossed(v13); // unnormalized (magnitude ~ area*2)
+      const double nLen2 = n.SquareMagnitude();
+      const double w = (nLen2 > 0.0) ? std::sqrt(nLen2) : 0.0;
+      if (w > 0.0)
+      {
+        n /= w; // normalize
+      }
+
+      // Respect face orientation (avoid flipped shading).
+      if (face.Orientation() == TopAbs_REVERSED)
+      {
+        n.Reverse();
+      }
+
+      AppendPnt3(out.positions, p1);
+      AppendPnt3(out.positions, p2);
+      AppendPnt3(out.positions, p3);
+
+      AppendVec3(out.normals, n);
+      AppendVec3(out.normals, n);
+      AppendVec3(out.normals, n);
+
+      if (smoothNormals)
+      {
+        keys.push_back(makeKey(p1));
+        keys.push_back(makeKey(p2));
+        keys.push_back(makeKey(p3));
+        const float wf = static_cast<float>(w);
+        weights.push_back(wf);
+        weights.push_back(wf);
+        weights.push_back(wf);
+      }
+    }
+
+    triCountTotal += static_cast<std::uint64_t>(tri->NbTriangles());
+  }
+
+  const Clock::time_point tExtract1 = Clock::now();
+  if (stats)
+  {
+    stats->facesWithTriangulation += facesWithTri;
+    stats->triangles += triCountTotal;
+    stats->vertices += static_cast<std::uint64_t>(out.positions.size() / 3);
+    stats->msExtract += ms(tExtract0, tExtract1);
+  }
+
+  // Convert flat normals into smooth vertex normals (with crease angle).
+  if (smoothNormals && !out.positions.empty())
+  {
+    const double kPi = 3.1415926535897932384626433832795;
+    const double crease = std::max(0.0, std::min(kPi, normalCreaseAngle));
+    if (crease > 0.0)
+    {
+      const float cosThresh = static_cast<float>(std::cos(crease));
+      const size_t vCount = out.positions.size() / 3;
+      if (keys.size() == vCount && weights.size() == vCount && out.normals.size() == out.positions.size())
+      {
+        struct Cluster
+        {
+          float nx = 0.0f, ny = 0.0f, nz = 1.0f; // representative direction (unit)
+          double sx = 0.0, sy = 0.0, sz = 0.0;   // accumulated weighted normal
+        };
+
+        std::unordered_map<QuantKey, std::vector<Cluster>, QuantKeyHash> clustersByKey;
+        clustersByKey.reserve(vCount / 2);
+
+        auto normalizeDir = [](double& x, double& y, double& z) {
+          const double len2 = x * x + y * y + z * z;
+          if (len2 > 0.0)
+          {
+            const double inv = 1.0 / std::sqrt(len2);
+            x *= inv; y *= inv; z *= inv;
+          }
+        };
+
+        // 1) Build clusters for each welded vertex key.
+        for (size_t vi = 0; vi < vCount; ++vi)
+        {
+          const float fx = out.normals[vi * 3 + 0];
+          const float fy = out.normals[vi * 3 + 1];
+          const float fz = out.normals[vi * 3 + 2];
+          const float w = weights[vi];
+          if (w <= 0.0f)
+          {
+            continue;
+          }
+
+          auto& clusters = clustersByKey[keys[vi]];
+          int best = -1;
+          float bestDot = -2.0f;
+          for (int ci = 0; ci < (int)clusters.size(); ++ci)
+          {
+            const float dot = fx * clusters[ci].nx + fy * clusters[ci].ny + fz * clusters[ci].nz;
+            if (dot > bestDot)
+            {
+              bestDot = dot;
+              best = ci;
+            }
+          }
+
+          if (best >= 0 && bestDot >= cosThresh)
+          {
+            Cluster& c = clusters[(size_t)best];
+            c.sx += (double)fx * (double)w;
+            c.sy += (double)fy * (double)w;
+            c.sz += (double)fz * (double)w;
+            double nx = c.sx, ny = c.sy, nz = c.sz;
+            normalizeDir(nx, ny, nz);
+            c.nx = (float)nx; c.ny = (float)ny; c.nz = (float)nz;
+          }
+          else
+          {
+            Cluster c;
+            c.sx = (double)fx * (double)w;
+            c.sy = (double)fy * (double)w;
+            c.sz = (double)fz * (double)w;
+            c.nx = fx; c.ny = fy; c.nz = fz;
+            clusters.push_back(c);
+          }
+        }
+
+        // 2) Assign per-vertex smooth normals: pick the cluster closest to the original face normal.
+        for (size_t vi = 0; vi < vCount; ++vi)
+        {
+          const float fx = out.normals[vi * 3 + 0];
+          const float fy = out.normals[vi * 3 + 1];
+          const float fz = out.normals[vi * 3 + 2];
+
+          const auto it = clustersByKey.find(keys[vi]);
+          if (it == clustersByKey.end() || it->second.empty())
+          {
+            continue;
+          }
+          const auto& clusters = it->second;
+
+          int best = 0;
+          float bestDot = fx * clusters[0].nx + fy * clusters[0].ny + fz * clusters[0].nz;
+          for (int ci = 1; ci < (int)clusters.size(); ++ci)
+          {
+            const float dot = fx * clusters[(size_t)ci].nx + fy * clusters[(size_t)ci].ny + fz * clusters[(size_t)ci].nz;
+            if (dot > bestDot)
+            {
+              bestDot = dot;
+              best = ci;
+            }
+          }
+
+          const Cluster& c = clusters[(size_t)best];
+          double nx = c.sx, ny = c.sy, nz = c.sz;
+          normalizeDir(nx, ny, nz);
+          out.normals[vi * 3 + 0] = (float)nx;
+          out.normals[vi * 3 + 1] = (float)ny;
+          out.normals[vi * 3 + 2] = (float)nz;
+        }
+      }
+    }
+  }
+
+  return out;
+}
+
+static int AddNode(SceneData& scene, SceneNode node)
+{
+  scene.nodes.push_back(std::move(node));
+  return static_cast<int>(scene.nodes.size() - 1);
+}
+
+static double BBoxDiagonal(const TopoDS_Shape& shape)
+{
+  Bnd_Box box;
+  box.SetGap(0.0);
+  BRepBndLib::Add(shape, box);
+  if (box.IsVoid())
+  {
+    return 0.0;
+  }
+  double xmin = 0, ymin = 0, zmin = 0, xmax = 0, ymax = 0, zmax = 0;
+  box.Get(xmin, ymin, zmin, xmax, ymax, zmax);
+  const double dx = static_cast<double>(xmax - xmin);
+  const double dy = static_cast<double>(ymax - ymin);
+  const double dz = static_cast<double>(zmax - zmin);
+  return std::sqrt(dx * dx + dy * dy + dz * dz);
+}
+
+struct StepXdeContext
+{
+  occ::handle<TDocStd_Document> doc;
+  occ::handle<XCAFDoc_ShapeTool> shapeTool;
+  occ::handle<XCAFDoc_ColorTool> colorTool;
+  NCollection_Sequence<TDF_Label> roots;
+};
+
+StepXdeContext* LoadStepXdeContext(const std::string& inputPath,
+                                  const bool readNames,
+                                  const bool readColors,
+                                  ConvertStats* stats,
+                                  const int logLevel)
+{
+  using Clock = std::chrono::steady_clock;
+  auto ms = [](Clock::time_point a, Clock::time_point b) -> std::uint64_t {
+    return (std::uint64_t)std::chrono::duration_cast<std::chrono::milliseconds>(b - a).count();
+  };
+
+  if (logLevel >= 1)
+  {
+    std::cerr << "[occt-gltf] STEP(XDE) read: " << inputPath << "\n";
+  }
+
+  const Clock::time_point tRead0 = Clock::now();
+  STEPCAFControl_Reader reader;
+  reader.SetNameMode(readNames);   // read names (Unicode)
+  reader.SetColorMode(readColors); // read colors (if present)
+  reader.SetLayerMode(false);
+  reader.SetPropsMode(false);
+
+  const IFSelect_ReturnStatus status = reader.ReadFile(inputPath.c_str());
+  const Clock::time_point tRead1 = Clock::now();
+  if (status != IFSelect_RetDone)
+  {
+    throw std::runtime_error("Failed to read STEP file: " + inputPath);
+  }
+  if (stats) stats->msRead = ms(tRead0, tRead1);
+
+  const Clock::time_point tTransfer0 = Clock::now();
+  if (logLevel >= 1)
+  {
+    std::cerr << "[occt-gltf] XDE Transfer...\n";
+  }
+  occ::handle<TDocStd_Document> doc = new TDocStd_Document("occt-gltf");
+  if (!reader.Transfer(doc))
+  {
+    throw std::runtime_error("STEPCAFControl_Reader.Transfer() failed.");
+  }
+  const Clock::time_point tTransfer1 = Clock::now();
+  if (stats) stats->msTransfer = ms(tTransfer0, tTransfer1);
+
+  const occ::handle<XCAFDoc_ShapeTool> shapeTool =
+    XCAFDoc_DocumentTool::ShapeTool(doc->Main());
+  if (shapeTool.IsNull())
+  {
+    throw std::runtime_error("XCAFDoc_ShapeTool not available.");
+  }
+
+  StepXdeContext* ctx = new StepXdeContext();
+  ctx->doc = doc;
+  ctx->shapeTool = shapeTool;
+  ctx->colorTool = XCAFDoc_DocumentTool::ColorTool(doc->Main());
+  shapeTool->GetFreeShapes(ctx->roots);
+  if (logLevel >= 1)
+  {
+    std::cerr << "[occt-gltf] FreeShapes: " << ctx->roots.Length() << "\n";
+  }
+  return ctx;
+}
+
+void FreeStepXdeContext(StepXdeContext* ctx)
+{
+  delete ctx;
+}
+
+SceneData ConvertStepXdeContextToScene(StepXdeContext* ctx,
+                                      double linearDeflection,
+                                      double angularDeflection,
+                                      bool smoothNormals,
+                                      double normalCreaseAngle,
+                                      double minBBoxDiagonal,
+                                      ConvertStats* stats,
+                                      int logLevel)
+{
+  if (ctx == nullptr || ctx->doc.IsNull() || ctx->shapeTool.IsNull())
+  {
+    throw std::runtime_error("Invalid StepXdeContext.");
+  }
+
+  if (stats)
+  {
+    stats->linearDeflection = linearDeflection;
+    stats->angularDeflection = angularDeflection;
+  }
+
+  const occ::handle<XCAFDoc_ShapeTool> shapeTool = ctx->shapeTool;
+
+  SceneData scene;
+
+  const occ::handle<XCAFDoc_ColorTool> colorTool = ctx->colorTool;
+  std::unordered_map<std::uint32_t, int> materialMap;
+
+  struct ColorInfo
+  {
+    bool hasColor = false;
+    bool isInstance = false;        // instance color overrides shape colors
+    std::uint32_t rgba8 = 0;        // packed RGBA8
+  };
+
+  auto clamp01 = [](double v) -> double { return std::min(1.0, std::max(0.0, v)); };
+  auto toU8 = [&](double v) -> std::uint8_t {
+    const double x = clamp01(v);
+    return static_cast<std::uint8_t>(std::lround(x * 255.0));
+  };
+
+  auto packRgba8 = [&](const Quantity_ColorRGBA& c) -> std::uint32_t {
+    const auto& rgb = c.GetRGB();
+    const std::uint8_t r = toU8(rgb.Red());
+    const std::uint8_t g = toU8(rgb.Green());
+    const std::uint8_t b = toU8(rgb.Blue());
+    const std::uint8_t a = toU8(static_cast<double>(c.Alpha()));
+    return (static_cast<std::uint32_t>(r) << 24)
+         | (static_cast<std::uint32_t>(g) << 16)
+         | (static_cast<std::uint32_t>(b) << 8)
+         |  static_cast<std::uint32_t>(a);
+  };
+
+  auto getOrCreateMaterial = [&](const std::uint32_t rgba8) -> int {
+    const auto it = materialMap.find(rgba8);
+    if (it != materialMap.end())
+    {
+      return it->second;
+    }
+
+    const float r = static_cast<float>((rgba8 >> 24) & 0xFFu) / 255.0f;
+    const float g = static_cast<float>((rgba8 >> 16) & 0xFFu) / 255.0f;
+    const float b = static_cast<float>((rgba8 >> 8) & 0xFFu) / 255.0f;
+    const float a = static_cast<float>((rgba8) & 0xFFu) / 255.0f;
+
+    MaterialData mat;
+    mat.baseColorFactor = {r, g, b, a};
+    mat.metallicFactor = 0.0f;
+    mat.roughnessFactor = 1.0f;
+    mat.doubleSided = true;
+
+    scene.materials.push_back(mat);
+    const int idx = static_cast<int>(scene.materials.size() - 1);
+    materialMap.emplace(rgba8, idx);
+    return idx;
+  };
+
+  auto tryGetLabelColor = [](const TDF_Label& L, Quantity_ColorRGBA& out) -> bool {
+    // Prefer surface color; fall back to generic color.
+    if (XCAFDoc_ColorTool::GetColor(L, XCAFDoc_ColorSurf, out)) return true;
+    if (XCAFDoc_ColorTool::GetColor(L, XCAFDoc_ColorGen, out)) return true;
+    return false;
+  };
+
+  auto tryGetInstanceColor = [&](const TopoDS_Shape& instShape, Quantity_ColorRGBA& out) -> bool {
+    if (colorTool.IsNull()) return false;
+    if (colorTool->GetInstanceColor(instShape, XCAFDoc_ColorSurf, out)) return true;
+    if (colorTool->GetInstanceColor(instShape, XCAFDoc_ColorGen, out)) return true;
+    return false;
+  };
+
+  struct MeshVariants
+  {
+    std::unordered_map<std::uint32_t, int> byColor; // rgba8 -> meshIndex (or -1)
+  };
+
+  // Mesh cache by base shape (location stripped) + color (material).
+  NCollection_DataMap<TopoDS_Shape, MeshVariants, TopTools_ShapeMapHasher> meshMap;
+
+  std::function<int(const TDF_Label&, const TopLoc_Location&, const std::string&, const ColorInfo&)> build;
+  build = [&](const TDF_Label& label,
+              const TopLoc_Location& loc,
+              const std::string& overrideName,
+              const ColorInfo& parentColor) -> int {
+    const std::string name = [&]() -> std::string {
+      std::string n = !overrideName.empty() ? overrideName : GetLabelNameUtf8(label);
+      if (n.empty()) n = "Node";
+      return n;
+    }();
+
+    ColorInfo curColor = parentColor;
+    if (!curColor.isInstance)
+    {
+      Quantity_ColorRGBA col;
+      if (tryGetLabelColor(label, col))
+      {
+        curColor.hasColor = true;
+        curColor.isInstance = false;
+        curColor.rgba8 = packRgba8(col);
+      }
+    }
+
+    if (XCAFDoc_ShapeTool::IsAssembly(label))
+    {
+      // Build children first; if all children are discarded, discard this assembly node too.
+      std::vector<int> childIndices;
+      NCollection_Sequence<TDF_Label> comps;
+      XCAFDoc_ShapeTool::GetComponents(label, comps, false);
+      for (NCollection_Sequence<TDF_Label>::Iterator it(comps); it.More(); it.Next())
+      {
+        const TDF_Label compL = it.Value();
+        const TopLoc_Location childLoc = XCAFDoc_ShapeTool::GetLocation(compL);
+        TDF_Label refL;
+        std::string childName = GetLabelNameUtf8(compL);
+        if (!XCAFDoc_ShapeTool::GetReferredShape(compL, refL))
+        {
+          refL = compL;
+        }
+
+        ColorInfo childColor = curColor;
+        {
+          Quantity_ColorRGBA instCol;
+          bool hasInstCol = false;
+          TopoDS_Shape instShape = XCAFDoc_ShapeTool::GetShape(compL);
+          if (!instShape.IsNull() && tryGetInstanceColor(instShape, instCol))
+          {
+            hasInstCol = true;
+          }
+          else if (tryGetLabelColor(compL, instCol))
+          {
+            hasInstCol = true;
+          }
+
+          if (hasInstCol)
+          {
+            childColor.hasColor = true;
+            childColor.isInstance = true;
+            childColor.rgba8 = packRgba8(instCol);
+          }
+        }
+
+        const int childIdx = build(refL, childLoc, childName, childColor);
+        if (childIdx >= 0)
+        {
+          childIndices.push_back(childIdx);
+        }
+      }
+
+      if (childIndices.empty())
+      {
+        return -1;
+      }
+
+      SceneNode node;
+      node.matrix = LocationToGltfMatrix(loc);
+      node.name = name;
+      node.children = std::move(childIndices);
+      return AddNode(scene, std::move(node));
+    }
+
+    // Leaf / part: generate or reuse mesh.
+    TopoDS_Shape s = XCAFDoc_ShapeTool::GetShape(label);
+    if (s.IsNull())
+    {
+      return -1;
+    }
+    TopoDS_Shape base = s.Located(TopLoc_Location()); // strip location for cache key
+
+    // Small-part filter (before meshing).
+    if (minBBoxDiagonal > 0.0)
+    {
+      const double diag = BBoxDiagonal(base);
+      if (diag > 0.0 && diag < minBBoxDiagonal)
+      {
+        if (stats) stats->skippedSmallParts += 1;
+        return -1;
+      }
+    }
+
+    const std::uint32_t matKey = curColor.hasColor ? curColor.rgba8 : 0xFFFFFFFFu;
+
+    // meshIdx: -2 = not cached yet, -1 = cached as "no mesh", >=0 = mesh index
+    int meshIdx = -2;
+    MeshVariants* variants = meshMap.ChangeSeek(base);
+    if (variants == nullptr)
+    {
+      MeshVariants v;
+      meshMap.Bind(base, std::move(v));
+      variants = meshMap.ChangeSeek(base);
+    }
+    if (variants != nullptr)
+    {
+      const auto it = variants->byColor.find(matKey);
+      if (it != variants->byColor.end())
+      {
+        meshIdx = it->second;
+      }
+    }
+
+    if (meshIdx == -1)
+    {
+      return -1;
+    }
+
+    if (meshIdx == -2)
+    {
+      if (logLevel >= 2)
+      {
+        std::cerr << "[occt-gltf] Meshing leaf: " << name << "\n";
+      }
+      MeshData mesh = ConvertShapeToMesh(base,
+                                         linearDeflection,
+                                         angularDeflection,
+                                         smoothNormals,
+                                         normalCreaseAngle,
+                                         stats);
+      if (mesh.positions.empty())
+      {
+        if (logLevel >= 2)
+        {
+          std::cerr << "[occt-gltf] Warning: skip leaf (no triangulation): " << name << "\n";
+        }
+        if (stats) stats->skippedMeshesNoTriangulation += 1;
+        if (variants != nullptr) variants->byColor[matKey] = -1;
+        return -1;
+      }
+
+      if (curColor.hasColor)
+      {
+        mesh.materialIndex = getOrCreateMaterial(matKey);
+      }
+
+      scene.meshes.push_back(std::move(mesh));
+      meshIdx = static_cast<int>(scene.meshes.size() - 1);
+      if (variants != nullptr) variants->byColor[matKey] = meshIdx;
+    }
+
+    if (meshIdx < 0)
+    {
+      return -1;
+    }
+
+    SceneNode node;
+    node.matrix = LocationToGltfMatrix(loc);
+    node.name = name;
+    node.meshIndex = meshIdx;
+    return AddNode(scene, std::move(node));
+  };
+
+  for (NCollection_Sequence<TDF_Label>::Iterator it(ctx->roots); it.More(); it.Next())
+  {
+    const TDF_Label rootL = it.Value();
+    const ColorInfo noColor;
+    const int rootIdx = build(rootL, TopLoc_Location(), std::string(), noColor);
+    if (rootIdx >= 0)
+    {
+      scene.roots.push_back(rootIdx);
+    }
+  }
+
+  if (stats)
+  {
+    stats->nodes = static_cast<std::uint64_t>(scene.nodes.size());
+    stats->meshes = static_cast<std::uint64_t>(scene.meshes.size());
+    // stats->msTotal is computed by the worker (including read/transfer/write).
+  }
+
+  return scene;
+}
+
+SceneData ConvertSTEPToScene(const std::string& inputPath,
+                             double linearDeflection,
+                             double angularDeflection,
+                             double minBBoxDiagonal,
+                             ConvertStats* stats)
+{
+  StepXdeContext* ctx = LoadStepXdeContext(inputPath, true, true, stats, /*logLevel*/ 1);
+  try
+  {
+    SceneData scene =
+      ConvertStepXdeContextToScene(ctx,
+                                   linearDeflection,
+                                   angularDeflection,
+                                   /*smoothNormals*/ true,
+                                   /*normalCreaseAngle*/ 1.0471975511965976,
+                                   minBBoxDiagonal,
+                                   stats,
+                                   /*logLevel*/ 1);
+    FreeStepXdeContext(ctx);
+    return scene;
+  }
+  catch (...)
+  {
+    FreeStepXdeContext(ctx);
+    throw;
+  }
+}
+