occt-gltf-addon 0.1.0

package/src/convert_worker.cpp

@@ -0,0 +1,474 @@
+#include "convert_worker.h"
+
+#include "gltf_writer.h"
+#include "mesh_types.h"
+#include "occt_convert.h"
+
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <exception>
+#include <iomanip>
+#include <iostream>
+#include <limits>
+#include <sstream>
+#include <utility>
+
+static std::string FormatHMSms(const std::uint64_t ms)
+{
+  const std::uint64_t milli = ms % 1000;
+  const std::uint64_t totalSec = ms / 1000;
+  const std::uint64_t sec = totalSec % 60;
+  const std::uint64_t totalMin = totalSec / 60;
+  const std::uint64_t min = totalMin % 60;
+  const std::uint64_t hour = totalMin / 60;
+
+  std::ostringstream oss;
+  oss << std::setfill('0')
+      << std::setw(2) << hour << ":"
+      << std::setw(2) << min << ":"
+      << std::setw(2) << sec << "."
+      << std::setw(3) << milli;
+  return oss.str();
+}
+
+static std::string FormatSeconds(const std::uint64_t ms)
+{
+  std::ostringstream oss;
+  oss << std::fixed << std::setprecision(3) << (static_cast<double>(ms) / 1000.0) << "s";
+  return oss.str();
+}
+
+static void ApplyUnitScale(SceneData& scene, const double s)
+{
+  if (s == 1.0)
+  {
+    return;
+  }
+  // Apply uniform scale on root nodes so it propagates to the whole hierarchy.
+  for (int rootIdx : scene.roots)
+  {
+    if (rootIdx < 0 || static_cast<size_t>(rootIdx) >= scene.nodes.size())
+    {
+      continue;
+    }
+    auto& m = scene.nodes[static_cast<size_t>(rootIdx)].matrix;
+    // Column-major 4x4: scale the basis vectors and translation.
+    m[0] *= static_cast<float>(s);  m[1] *= static_cast<float>(s);  m[2] *= static_cast<float>(s);
+    m[4] *= static_cast<float>(s);  m[5] *= static_cast<float>(s);  m[6] *= static_cast<float>(s);
+    m[8] *= static_cast<float>(s);  m[9] *= static_cast<float>(s);  m[10] *= static_cast<float>(s);
+    m[12] *= static_cast<float>(s); m[13] *= static_cast<float>(s); m[14] *= static_cast<float>(s);
+  }
+}
+
+using Mat4 = std::array<float, 16>;
+
+static Mat4 MulMat4(const Mat4& A, const Mat4& B);
+
+static Mat4 YUpToZUpMat4()
+{
+  // Rotate +90 degrees about X:
+  // (x, y, z) -> (x, -z, y)
+  // Column-major 4x4.
+  return Mat4{
+    1, 0, 0, 0,
+    0, 0, 1, 0,
+    0, -1, 0, 0,
+    0, 0, 0, 1
+  };
+}
+
+static void ApplyYUpToZUp(SceneData& scene)
+{
+  const Mat4 R = YUpToZUpMat4();
+  for (int rootIdx : scene.roots)
+  {
+    if (rootIdx < 0 || static_cast<size_t>(rootIdx) >= scene.nodes.size())
+    {
+      continue;
+    }
+    scene.nodes[(size_t)rootIdx].matrix = MulMat4(R, scene.nodes[(size_t)rootIdx].matrix);
+  }
+}
+
+using CenterMode = ConvertWorker::OutputOptions::CenterMode;
+
+static Mat4 IdentityMat4()
+{
+  return Mat4{
+    1,0,0,0,
+    0,1,0,0,
+    0,0,1,0,
+    0,0,0,1
+  };
+}
+
+static Mat4 MulMat4(const Mat4& A, const Mat4& B)
+{
+  Mat4 C{};
+  for (int col = 0; col < 4; ++col)
+  {
+    for (int row = 0; row < 4; ++row)
+    {
+      float sum = 0.0f;
+      for (int k = 0; k < 4; ++k)
+      {
+        sum += A[k * 4 + row] * B[col * 4 + k];
+      }
+      C[col * 4 + row] = sum;
+    }
+  }
+  return C;
+}
+
+static inline void TransformPoint(const Mat4& M, float& x, float& y, float& z)
+{
+  const float tx = M[0] * x + M[4] * y + M[8] * z + M[12];
+  const float ty = M[1] * x + M[5] * y + M[9] * z + M[13];
+  const float tz = M[2] * x + M[6] * y + M[10] * z + M[14];
+  x = tx; y = ty; z = tz;
+}
+
+static inline void TransformVector3x3(const Mat4& M, float& x, float& y, float& z)
+{
+  const float tx = M[0] * x + M[4] * y + M[8] * z;
+  const float ty = M[1] * x + M[5] * y + M[9] * z;
+  const float tz = M[2] * x + M[6] * y + M[10] * z;
+  x = tx; y = ty; z = tz;
+}
+
+static inline void Normalize3(float& x, float& y, float& z)
+{
+  const float len2 = x * x + y * y + z * z;
+  if (len2 > 0.0f)
+  {
+    const float inv = 1.0f / std::sqrt(len2);
+    x *= inv; y *= inv; z *= inv;
+  }
+}
+
+struct BBox3D
+{
+  float minX = std::numeric_limits<float>::infinity();
+  float maxX = -std::numeric_limits<float>::infinity();
+  float minY = std::numeric_limits<float>::infinity();
+  float maxY = -std::numeric_limits<float>::infinity();
+  float minZ = std::numeric_limits<float>::infinity();
+  float maxZ = -std::numeric_limits<float>::infinity();
+  bool valid = false;
+};
+
+static void BakeTransformsToMeshes(SceneData& scene, BBox3D* bbox)
+{
+  if (scene.nodes.empty())
+  {
+    return;
+  }
+
+  std::vector<Mat4> world(scene.nodes.size(), IdentityMat4());
+  const Mat4 I = IdentityMat4();
+
+  std::function<void(int, const Mat4&)> dfs = [&](int idx, const Mat4& parent) {
+    if (idx < 0 || static_cast<size_t>(idx) >= scene.nodes.size())
+    {
+      return;
+    }
+    const Mat4 w = MulMat4(parent, scene.nodes[(size_t)idx].matrix);
+    world[(size_t)idx] = w;
+    for (int c : scene.nodes[(size_t)idx].children)
+    {
+      dfs(c, w);
+    }
+  };
+
+  for (int root : scene.roots)
+  {
+    dfs(root, I);
+  }
+
+  std::vector<MeshData> baked;
+  baked.reserve(scene.nodes.size());
+
+  for (size_t ni = 0; ni < scene.nodes.size(); ++ni)
+  {
+    SceneNode& node = scene.nodes[ni];
+    if (node.meshIndex < 0)
+    {
+      continue;
+    }
+    const int srcIdx = node.meshIndex;
+    if (static_cast<size_t>(srcIdx) >= scene.meshes.size())
+    {
+      continue;
+    }
+
+    const MeshData& src = scene.meshes[(size_t)srcIdx];
+    MeshData dst;
+    dst.materialIndex = src.materialIndex;
+    dst.positions = src.positions;
+    dst.normals = src.normals;
+
+    const Mat4& M = world[ni];
+
+    // Transform positions
+    for (size_t i = 0; i + 2 < dst.positions.size(); i += 3)
+    {
+      float x = dst.positions[i + 0];
+      float y = dst.positions[i + 1];
+      float z = dst.positions[i + 2];
+      TransformPoint(M, x, y, z);
+      dst.positions[i + 0] = x;
+      dst.positions[i + 1] = y;
+      dst.positions[i + 2] = z;
+
+      if (bbox)
+      {
+        bbox->valid = true;
+        bbox->minX = std::min(bbox->minX, x);
+        bbox->maxX = std::max(bbox->maxX, x);
+        bbox->minY = std::min(bbox->minY, y);
+        bbox->maxY = std::max(bbox->maxY, y);
+        bbox->minZ = std::min(bbox->minZ, z);
+        bbox->maxZ = std::max(bbox->maxZ, z);
+      }
+    }
+
+    // Transform normals (3x3) + normalize
+    for (size_t i = 0; i + 2 < dst.normals.size(); i += 3)
+    {
+      float x = dst.normals[i + 0];
+      float y = dst.normals[i + 1];
+      float z = dst.normals[i + 2];
+      TransformVector3x3(M, x, y, z);
+      Normalize3(x, y, z);
+      dst.normals[i + 0] = x;
+      dst.normals[i + 1] = y;
+      dst.normals[i + 2] = z;
+    }
+
+    baked.push_back(std::move(dst));
+    node.meshIndex = static_cast<int>(baked.size() - 1);
+  }
+
+  scene.meshes = std::move(baked);
+
+  // Reset all node transforms to identity (apply transforms).
+  for (auto& node : scene.nodes)
+  {
+    node.matrix = IdentityMat4();
+  }
+}
+
+static void ShiftMeshes(SceneData& scene, const float dx, const float dy, const float dz)
+{
+  for (auto& mesh : scene.meshes)
+  {
+    for (size_t i = 0; i + 2 < mesh.positions.size(); i += 3)
+    {
+      mesh.positions[i + 0] -= dx;
+      mesh.positions[i + 1] -= dy;
+      mesh.positions[i + 2] -= dz;
+    }
+  }
+}
+
+ConvertWorker::ConvertWorker(const Napi::Env& env,
+                             Napi::Promise::Deferred deferred,
+                             std::string inputPath,
+                             const int logLevel,
+                             std::vector<VariantOptions> variants)
+  : Napi::AsyncWorker(env),
+    deferred_(std::move(deferred)),
+    inputPath_(std::move(inputPath)),
+    logLevel_(logLevel),
+    variants_(std::move(variants))
+{
+}
+
+void ConvertWorker::Execute()
+{
+  try
+  {
+    if (logLevel_ >= 1)
+    {
+      std::cerr << "[occt-gltf] ===== Convert START =====\n";
+    }
+
+    if (variants_.empty())
+    {
+      throw std::runtime_error("No output variants specified.");
+    }
+
+    // Load STEP/XDE once (dominant cost), then run meshing+export for each variant.
+    ConvertStats shared;
+    StepXdeContext* ctx = LoadStepXdeContext(inputPath_, /*readNames*/ true, /*readColors*/ true, &shared, logLevel_);
+    try
+    {
+      // Process coarsest tessellation first to avoid reusing a finer triangulation for a coarse variant.
+      std::vector<size_t> order(variants_.size());
+      for (size_t i = 0; i < variants_.size(); ++i) order[i] = i;
+      std::stable_sort(order.begin(), order.end(), [&](size_t a, size_t b) {
+        const auto& A = variants_[a].tess;
+        const auto& B = variants_[b].tess;
+        if (A.linearDeflection != B.linearDeflection) return A.linearDeflection > B.linearDeflection;
+        return A.angularDeflection > B.angularDeflection;
+      });
+
+      for (size_t oi = 0; oi < order.size(); ++oi)
+      {
+        const VariantOptions& v = variants_[order[oi]];
+
+        if (logLevel_ >= 1)
+        {
+          std::cerr << "[occt-gltf] Variant " << (oi + 1) << "/" << order.size()
+                    << " -> " << v.outputPath
+                    << " (lin=" << v.tess.linearDeflection
+                    << ", ang=" << v.tess.angularDeflection
+                    << ", normals=" << (v.tess.smoothNormals ? "smooth" : "flat");
+          if (v.tess.smoothNormals)
+          {
+            std::cerr << ", crease=" << v.tess.normalCreaseAngle;
+          }
+          std::cerr
+                    << ", minBBoxDiag=" << v.filter.minBBoxDiagonal
+                    << ", unitScale=" << v.output.unitScale
+                    << ", bake=" << (v.output.bakeTransforms ? "true" : "false")
+                    << ", center=";
+          switch (v.output.center)
+          {
+            case CenterMode::XY: std::cerr << "xy"; break;
+            case CenterMode::XZ: std::cerr << "xz"; break;
+            case CenterMode::YZ: std::cerr << "yz"; break;
+            case CenterMode::None: default: std::cerr << "none"; break;
+          }
+          std::cerr << ")\n";
+        }
+
+        ConvertStats st;
+        st.msRead = shared.msRead;
+        st.msTransfer = shared.msTransfer;
+
+        SceneData scene = ConvertStepXdeContextToScene(ctx,
+                                                      v.tess.linearDeflection,
+                                                      v.tess.angularDeflection,
+                                                      v.tess.smoothNormals,
+                                                      v.tess.normalCreaseAngle,
+                                                      v.filter.minBBoxDiagonal,
+                                                      &st,
+                                                      logLevel_);
+
+        ApplyUnitScale(scene, v.output.unitScale);
+        if (v.output.zUp)
+        {
+          ApplyYUpToZUp(scene);
+        }
+
+        if (v.output.bakeTransforms)
+        {
+          const bool needCenter = (v.output.center != CenterMode::None);
+          BBox3D bbox;
+          BakeTransformsToMeshes(scene, needCenter ? &bbox : nullptr);
+          if (needCenter && bbox.valid)
+          {
+            const float cx = (bbox.minX + bbox.maxX) * 0.5f;
+            const float cy = (bbox.minY + bbox.maxY) * 0.5f;
+            const float cz = (bbox.minZ + bbox.maxZ) * 0.5f;
+
+            float dx = 0.0f, dy = 0.0f, dz = 0.0f;
+            switch (v.output.center)
+            {
+              case CenterMode::XY:
+                dx = cx;
+                dy = cy;
+                if (v.output.zUp)
+                {
+                  dz = bbox.minZ; // ground for Z-up: make minZ = 0
+                }
+                break;
+              case CenterMode::XZ:
+                dx = cx;
+                dz = cz;
+                if (!v.output.zUp)
+                {
+                  dy = bbox.minY; // ground for Y-up: make minY = 0
+                }
+                break;
+              case CenterMode::YZ: dy = cy; dz = cz; break;
+              case CenterMode::None: default: break;
+            }
+            ShiftMeshes(scene, dx, dy, dz);
+          }
+        }
+        else if (v.output.center != CenterMode::None)
+        {
+          if (logLevel_ >= 1)
+          {
+            std::cerr << "[occt-gltf] Warning: output.center requested but output.bakeTransforms=false; ignored.\n";
+          }
+        }
+
+        const auto tWrite0 = std::chrono::steady_clock::now();
+        GltfWriteOptions wopt;
+        wopt.dracoEnabled = v.output.dracoEnabled;
+        wopt.dracoCompressionLevel = v.output.dracoCompressionLevel;
+        wopt.dracoQuantBitsPosition = v.output.dracoQuantBitsPosition;
+        wopt.dracoQuantBitsNormal = v.output.dracoQuantBitsNormal;
+        st.glbBytes = WriteGLB(v.outputPath, scene, wopt);
+        const auto tWrite1 = std::chrono::steady_clock::now();
+        st.msWrite =
+          (std::uint64_t)std::chrono::duration_cast<std::chrono::milliseconds>(tWrite1 - tWrite0).count();
+
+        st.msTotal = st.msRead + st.msTransfer + st.msMesh + st.msExtract + st.msWrite;
+
+        if (logLevel_ >= 1)
+        {
+          std::cerr << "[occt-gltf] DONE. faces=" << st.facesWithTriangulation << "/" << st.facesTotal
+                    << ", triangles=" << st.triangles
+                    << ", vertices=" << st.vertices
+                    << ", glbBytes=" << st.glbBytes
+                    << ", total=" << FormatHMSms(st.msTotal) << "\n";
+          std::cerr << "[occt-gltf] Timing. read=" << FormatHMSms(st.msRead)
+                    << ", transfer=" << FormatHMSms(st.msTransfer)
+                    << ", mesh=" << FormatHMSms(st.msMesh)
+                    << ", extract=" << FormatHMSms(st.msExtract)
+                    << ", write=" << FormatHMSms(st.msWrite) << "\n";
+          std::cerr << "[occt-gltf] Scene. nodes=" << scene.nodes.size()
+                    << ", meshes=" << scene.meshes.size()
+                    << ", skippedNoTri=" << st.skippedMeshesNoTriangulation
+                    << ", skippedSmall=" << st.skippedSmallParts << "\n";
+        }
+      }
+
+      FreeStepXdeContext(ctx);
+    }
+    catch (...)
+    {
+      FreeStepXdeContext(ctx);
+      throw;
+    }
+
+    if (logLevel_ >= 1)
+    {
+      std::cerr << "[occt-gltf] ===== Convert END =====\n";
+    }
+  }
+  catch (const std::exception& ex)
+  {
+    SetError(ex.what());
+  }
+  catch (...)
+  {
+    SetError("Unknown error");
+  }
+}
+
+void ConvertWorker::OnOK()
+{
+  deferred_.Resolve(Env().Undefined());
+}
+
+void ConvertWorker::OnError(const Napi::Error& e)
+{
+  deferred_.Reject(e.Value());
+}
+

package/src/convert_worker.h

@@ -0,0 +1,94 @@
+#pragma once
+
+#include <napi.h>
+
+#include <string>
+#include <vector>
+
+class ConvertWorker final : public Napi::AsyncWorker
+{
+public:
+  struct TessellationOptions
+  {
+    double linearDeflection = 0.1;
+    double angularDeflection = 0.5; // radians
+
+    // Generate smooth vertex normals by averaging adjacent triangle normals.
+    // If false, flat normals are generated (one normal per triangle).
+    bool smoothNormals = true;
+
+    // Crease angle (radians) used when smoothNormals=true. Faces meeting at angles
+    // larger than this are treated as sharp edges (their normals won't be averaged).
+    // Default 60 degrees.
+    double normalCreaseAngle = 1.0471975511965976;
+  };
+
+  struct FilterOptions
+  {
+    // Discard leaf parts with bounding-box diagonal smaller than this value (<= 0 disables).
+    // Units are the STEP model units as imported by OCCT (usually mm).
+    double minBBoxDiagonal = 0.0;
+  };
+
+  struct OutputOptions
+  {
+    // Unit scale applied to the exported scene (via root node transforms).
+    // OCCT XSTEP defaults to millimeters, while glTF convention is meters.
+    // Therefore default is 0.001 (mm -> m).
+    double unitScale = 0.001;
+
+    // If true, bake node transforms into mesh vertex data and reset all node transforms to identity
+    // (similar to Blender "Apply transforms").
+    bool bakeTransforms = false;
+
+    // Recenter the exported model so that the selected plane center of its bounding box is at (0,0).
+    // - Requires bakeTransforms=true (we shift vertex positions).
+    enum class CenterMode
+    {
+      None = 0,
+      XY, // center X/Y to (0,0)
+      XZ, // center X/Z to (0,0) and shift Y so bbox.minY becomes 0 (ground)
+      YZ
+    };
+    CenterMode center = CenterMode::None;
+
+    // If true, treat the source coordinates as Z-up (common in CAD/Blender) and rotate
+    // the exported scene into Z-up orientation (useful when your runtime (e.g. three.js)
+    // uses Z-up world: THREE.Object3D.DEFAULT_UP.set(0,0,1)).
+    //
+    // Note: glTF's standard coordinate system is Y-up. Enabling zUp makes the exported
+    // data Z-up (non-standard glTF), so Y-up viewers may show it rotated.
+    bool zUp = false;
+
+    // Draco mesh compression (KHR_draco_mesh_compression)
+    bool dracoEnabled = false;
+    int dracoCompressionLevel = 7; // 0..10 (higher = smaller/slower)
+    int dracoQuantBitsPosition = 14;
+    int dracoQuantBitsNormal = 10;
+  };
+
+  struct VariantOptions
+  {
+    std::string outputPath;
+    TessellationOptions tess;
+    FilterOptions filter;
+    OutputOptions output;
+  };
+
+  ConvertWorker(const Napi::Env& env,
+                Napi::Promise::Deferred deferred,
+                std::string inputPath,
+                int logLevel,
+                std::vector<VariantOptions> variants);
+
+  void Execute() override;
+  void OnOK() override;
+  void OnError(const Napi::Error& e) override;
+
+private:
+  Napi::Promise::Deferred deferred_;
+  std::string inputPath_;
+  int logLevel_ = 1; // 0=quiet,1=info,2=debug
+  std::vector<VariantOptions> variants_;
+};
+