occt-gltf-addon 0.1.0

package/src/occt_convert.cpp

@@ -0,0 +1,313 @@
+#include "occt_convert.h"
+
+#include <chrono>
+#include <iostream>
+#include <stdexcept>
+#include <unordered_map>
+
+// OCCT tessellation
+#include <BRepMesh_IncrementalMesh.hxx>
+#include <BRep_Tool.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 <TDF_LabelSequence.hxx>
+#include <XCAFDoc_DocumentTool.hxx>
+#include <XCAFDoc_ShapeTool.hxx>
+#include <TopTools_ShapeMapHasher.hxx>
+#include <NCollection_DataMap.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::string out;
+  out.resize((size_t)len);
+  std::vector<char> buf((size_t)len + 1);
+  Standard_PCharacter p = buf.data();
+  s.ToUTF8CString(p);
+  out.assign(buf.data(), (size_t)len);
+  return out;
+}
+
+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();
+  // gp_Trsf::Value(i,j): i=1..3, j=1..4 (last column is translation).
+  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,
+                                  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(shape, linearDeflection, false /*isRelative*/,
+                                  angularDeflection, true /*inParallel*/);
+  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;
+
+  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);
+      if (n.SquareMagnitude() > 0.0)
+      {
+        n.Normalize();
+      }
+
+      AppendPnt3(out.positions, p1);
+      AppendPnt3(out.positions, p2);
+      AppendPnt3(out.positions, p3);
+
+      AppendVec3(out.normals, n);
+      AppendVec3(out.normals, n);
+      AppendVec3(out.normals, n);
+    }
+
+    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);
+  }
+
+  if (out.positions.empty())
+  {
+    throw std::runtime_error("No triangulation produced (empty mesh).");
+  }
+
+  return out;
+}
+
+static int AddNode(SceneData& scene, SceneNode node)
+{
+  scene.nodes.push_back(std::move(node));
+  return static_cast<int>(scene.nodes.size() - 1);
+}
+
+SceneData ConvertSTEPToScene(const std::string& inputPath,
+                             double linearDeflection,
+                             double angularDeflection,
+                             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 tAll0 = Clock::now();
+
+  if (stats)
+  {
+    stats->linearDeflection = linearDeflection;
+    stats->angularDeflection = angularDeflection;
+  }
+
+  std::cerr << "[occt-gltf] STEP(XDE) read: " << inputPath << "\n";
+
+  const Clock::time_point tRead0 = Clock::now();
+  STEPCAFControl_Reader reader;
+  reader.SetNameMode(true);  // read names (Unicode)
+  reader.SetColorMode(false);
+  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();
+  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.");
+  }
+
+  // Mesh cache by base shape (location stripped) to support instancing.
+  NCollection_DataMap<TopoDS_Shape, int, TopTools_ShapeMapHasher> meshMap;
+
+  SceneData scene;
+
+  std::function<int(const TDF_Label&, const TopLoc_Location&, const std::string&)> build;
+  build = [&](const TDF_Label& label, const TopLoc_Location& loc, const std::string& overrideName) -> int {
+    SceneNode node;
+    node.matrix = LocationToGltfMatrix(loc);
+    node.name = !overrideName.empty() ? overrideName : GetLabelNameUtf8(label);
+    if (node.name.empty())
+    {
+      node.name = "Node";
+    }
+
+    if (XCAFDoc_ShapeTool::IsAssembly(label))
+    {
+      const int idx = AddNode(scene, std::move(node));
+      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;
+        }
+        const int childIdx = build(refL, childLoc, childName);
+        scene.nodes[idx].children.push_back(childIdx);
+      }
+      return idx;
+    }
+
+    // Leaf / part: generate or reuse mesh.
+    TopoDS_Shape s = XCAFDoc_ShapeTool::GetShape(label);
+    if (s.IsNull())
+    {
+      return AddNode(scene, std::move(node));
+    }
+    TopoDS_Shape base = s.Located(TopLoc_Location()); // strip location for cache key
+
+    int meshIdx = -1;
+    if (meshMap.IsBound(base))
+    {
+      meshIdx = meshMap.Find(base);
+    }
+    else
+    {
+      std::cerr << "[occt-gltf] Meshing leaf: " << node.name << "\n";
+      MeshData mesh = ConvertShapeToMesh(base, linearDeflection, angularDeflection, stats);
+      scene.meshes.push_back(std::move(mesh));
+      meshIdx = static_cast<int>(scene.meshes.size() - 1);
+      meshMap.Bind(base, meshIdx);
+    }
+    node.meshIndex = meshIdx;
+    return AddNode(scene, std::move(node));
+  };
+
+  NCollection_Sequence<TDF_Label> roots;
+  shapeTool->GetFreeShapes(roots);
+  std::cerr << "[occt-gltf] FreeShapes: " << roots.Length() << "\n";
+
+  for (NCollection_Sequence<TDF_Label>::Iterator it(roots); it.More(); it.Next())
+  {
+    const TDF_Label rootL = it.Value();
+    const int rootIdx = build(rootL, TopLoc_Location(), std::string());
+    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 = ms(tAll0, Clock::now());
+  }
+
+  return scene;
+}

package/src/occt_convert.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "mesh_types.h"
+
+#include <string>
+
+// Opaque handle to an XDE document loaded from STEP.
+// Used to reuse Read+Transfer across multiple output variants in one worker call.
+struct StepXdeContext;
+
+// Load STEP into an XDE document (preserves assembly hierarchy, names, colors).
+// - logLevel: 0=quiet, 1=info, 2=debug
+// - stats (optional) will be filled with msRead/msTransfer
+StepXdeContext* LoadStepXdeContext(const std::string& inputPath,
+                                  bool readNames,
+                                  bool readColors,
+                                  ConvertStats* stats,
+                                  int logLevel);
+
+void FreeStepXdeContext(StepXdeContext* ctx);
+
+// Build a scene from a previously loaded XDE context.
+// This performs meshing + triangle extraction and applies filtering.
+SceneData ConvertStepXdeContextToScene(StepXdeContext* ctx,
+                                      double linearDeflection,
+                                      double angularDeflection,
+                                      bool smoothNormals,
+                                      double normalCreaseAngle,
+                                      double minBBoxDiagonal,
+                                      ConvertStats* stats,
+                                      int logLevel);
+
+// Reads STEP and produces a scene graph preserving assembly hierarchy + names (UTF-8).
+// Leaf nodes reference meshes generated from B-Rep tessellation.
+SceneData ConvertSTEPToScene(const std::string& inputPath,
+                             double linearDeflection,
+                             double angularDeflection,
+                             double minBBoxDiagonal,
+                             ConvertStats* stats = nullptr);
+