occt-gltf-addon 0.1.0

package/src/addon.cpp

@@ -0,0 +1,504 @@
+#include <napi.h>
+
+#include "convert_worker.h"
+
+#include <string>
+#include <vector>
+
+static Napi::Value ConvertSTEPToGLTF(const Napi::CallbackInfo& info)
+{
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1 || !info[0].IsObject())
+  {
+    Napi::TypeError::New(env, "Expected options object").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Object options = info[0].As<Napi::Object>();
+
+  if (!options.Has("inputPath") || !options.Get("inputPath").IsString())
+  {
+    Napi::TypeError::New(env, "options.inputPath must be a string").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  std::string inputPath = options.Get("inputPath").As<Napi::String>().Utf8Value();
+
+  int logLevel = 1; // 0=quiet, 1=info, 2=debug
+  if (options.Has("logLevel"))
+  {
+    const Napi::Value v = options.Get("logLevel");
+    if (v.IsNumber())
+    {
+      logLevel = v.As<Napi::Number>().Int32Value();
+    }
+    else if (v.IsString())
+    {
+      const std::string s = v.As<Napi::String>().Utf8Value();
+      if (s == "quiet") logLevel = 0;
+      else if (s == "info") logLevel = 1;
+      else if (s == "debug") logLevel = 2;
+      else
+      {
+        Napi::RangeError::New(env, "logLevel must be 0|1|2 or 'quiet'|'info'|'debug'")
+          .ThrowAsJavaScriptException();
+        return env.Null();
+      }
+    }
+    else
+    {
+      Napi::TypeError::New(env, "logLevel must be a number or string").ThrowAsJavaScriptException();
+      return env.Null();
+    }
+  }
+  if (logLevel < 0 || logLevel > 2)
+  {
+    Napi::RangeError::New(env, "logLevel must be 0, 1, or 2").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  ConvertWorker::TessellationOptions tess;
+  if (options.Has("tessellation") && options.Get("tessellation").IsObject())
+  {
+    Napi::Object t = options.Get("tessellation").As<Napi::Object>();
+    if (t.Has("linearDeflection") && t.Get("linearDeflection").IsNumber())
+    {
+      tess.linearDeflection = t.Get("linearDeflection").As<Napi::Number>().DoubleValue();
+    }
+    if (t.Has("angularDeflection") && t.Get("angularDeflection").IsNumber())
+    {
+      tess.angularDeflection = t.Get("angularDeflection").As<Napi::Number>().DoubleValue();
+    }
+    if (t.Has("smoothNormals") && t.Get("smoothNormals").IsBoolean())
+    {
+      tess.smoothNormals = t.Get("smoothNormals").As<Napi::Boolean>().Value();
+    }
+    if (t.Has("normalCreaseAngle") && t.Get("normalCreaseAngle").IsNumber())
+    {
+      tess.normalCreaseAngle = t.Get("normalCreaseAngle").As<Napi::Number>().DoubleValue();
+    }
+  }
+
+  if (tess.linearDeflection <= 0.0)
+  {
+    Napi::RangeError::New(env, "tessellation.linearDeflection must be > 0").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  if (tess.angularDeflection <= 0.0)
+  {
+    Napi::RangeError::New(env, "tessellation.angularDeflection must be > 0").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  if (tess.normalCreaseAngle < 0.0)
+  {
+    Napi::RangeError::New(env, "tessellation.normalCreaseAngle must be >= 0").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  ConvertWorker::FilterOptions filter;
+  if (options.Has("filter") && options.Get("filter").IsObject())
+  {
+    Napi::Object f = options.Get("filter").As<Napi::Object>();
+    if (f.Has("minBBoxDiagonal") && f.Get("minBBoxDiagonal").IsNumber())
+    {
+      filter.minBBoxDiagonal = f.Get("minBBoxDiagonal").As<Napi::Number>().DoubleValue();
+    }
+  }
+  if (filter.minBBoxDiagonal < 0.0)
+  {
+    Napi::RangeError::New(env, "filter.minBBoxDiagonal must be >= 0").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  ConvertWorker::OutputOptions output;
+  if (options.Has("output") && options.Get("output").IsObject())
+  {
+    Napi::Object o = options.Get("output").As<Napi::Object>();
+    if (o.Has("unit") && o.Get("unit").IsString())
+    {
+      const std::string unit = o.Get("unit").As<Napi::String>().Utf8Value();
+      if (unit == "m")
+      {
+        output.unitScale = 0.001; // mm -> m (OCCT default)
+      }
+      else if (unit == "cm")
+      {
+        output.unitScale = 0.1; // mm -> cm
+      }
+      else if (unit == "mm")
+      {
+        output.unitScale = 1.0; // keep mm
+      }
+      else
+      {
+        Napi::RangeError::New(env, "output.unit must be one of: 'm', 'cm', 'mm'")
+          .ThrowAsJavaScriptException();
+        return env.Null();
+      }
+    }
+    if (o.Has("unitScale") && o.Get("unitScale").IsNumber())
+    {
+      output.unitScale = o.Get("unitScale").As<Napi::Number>().DoubleValue();
+    }
+
+    if (o.Has("bakeTransforms") && o.Get("bakeTransforms").IsBoolean())
+    {
+      output.bakeTransforms = o.Get("bakeTransforms").As<Napi::Boolean>().Value();
+    }
+
+    if (o.Has("centerXY") && o.Get("centerXY").IsBoolean())
+    {
+      const bool v = o.Get("centerXY").As<Napi::Boolean>().Value();
+      output.center = v ? ConvertWorker::OutputOptions::CenterMode::XY
+                        : ConvertWorker::OutputOptions::CenterMode::None;
+    }
+    if (o.Has("centerXZ") && o.Get("centerXZ").IsBoolean())
+    {
+      const bool v = o.Get("centerXZ").As<Napi::Boolean>().Value();
+      output.center = v ? ConvertWorker::OutputOptions::CenterMode::XZ
+                        : ConvertWorker::OutputOptions::CenterMode::None;
+    }
+    if (o.Has("centerYZ") && o.Get("centerYZ").IsBoolean())
+    {
+      const bool v = o.Get("centerYZ").As<Napi::Boolean>().Value();
+      output.center = v ? ConvertWorker::OutputOptions::CenterMode::YZ
+                        : ConvertWorker::OutputOptions::CenterMode::None;
+    }
+
+    if (o.Has("center") && o.Get("center").IsString())
+    {
+      const std::string center = o.Get("center").As<Napi::String>().Utf8Value();
+      if (center == "none")
+      {
+        output.center = ConvertWorker::OutputOptions::CenterMode::None;
+      }
+      else if (center == "xy")
+      {
+        output.center = ConvertWorker::OutputOptions::CenterMode::XY;
+      }
+      else if (center == "xz")
+      {
+        output.center = ConvertWorker::OutputOptions::CenterMode::XZ;
+      }
+      else if (center == "yz")
+      {
+        output.center = ConvertWorker::OutputOptions::CenterMode::YZ;
+      }
+      else
+      {
+        Napi::RangeError::New(env, "output.center must be one of: 'none', 'xy', 'xz', 'yz'")
+          .ThrowAsJavaScriptException();
+        return env.Null();
+      }
+    }
+
+    if (o.Has("zUp") && o.Get("zUp").IsBoolean())
+    {
+      output.zUp = o.Get("zUp").As<Napi::Boolean>().Value();
+    }
+    if (o.Has("zup") && o.Get("zup").IsBoolean())
+    {
+      output.zUp = o.Get("zup").As<Napi::Boolean>().Value();
+    }
+
+    if (o.Has("draco"))
+    {
+      const Napi::Value dv = o.Get("draco");
+      if (dv.IsBoolean())
+      {
+        output.dracoEnabled = dv.As<Napi::Boolean>().Value();
+      }
+      else if (dv.IsObject())
+      {
+        Napi::Object d = dv.As<Napi::Object>();
+        if (d.Has("enabled") && d.Get("enabled").IsBoolean())
+        {
+          output.dracoEnabled = d.Get("enabled").As<Napi::Boolean>().Value();
+        }
+        else
+        {
+          output.dracoEnabled = true;
+        }
+        if (d.Has("compressionLevel") && d.Get("compressionLevel").IsNumber())
+        {
+          output.dracoCompressionLevel = d.Get("compressionLevel").As<Napi::Number>().Int32Value();
+        }
+        if (d.Has("quantizationBitsPosition") && d.Get("quantizationBitsPosition").IsNumber())
+        {
+          output.dracoQuantBitsPosition = d.Get("quantizationBitsPosition").As<Napi::Number>().Int32Value();
+        }
+        if (d.Has("quantizationBitsNormal") && d.Get("quantizationBitsNormal").IsNumber())
+        {
+          output.dracoQuantBitsNormal = d.Get("quantizationBitsNormal").As<Napi::Number>().Int32Value();
+        }
+      }
+      else
+      {
+        Napi::TypeError::New(env, "output.draco must be boolean or object").ThrowAsJavaScriptException();
+        return env.Null();
+      }
+    }
+  }
+  if (output.unitScale <= 0.0)
+  {
+    Napi::RangeError::New(env, "output.unitScale must be > 0").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  if (output.dracoCompressionLevel < 0 || output.dracoCompressionLevel > 10)
+  {
+    Napi::RangeError::New(env, "output.draco.compressionLevel must be in [0..10]").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  if (output.dracoQuantBitsPosition < 1 || output.dracoQuantBitsPosition > 30)
+  {
+    Napi::RangeError::New(env, "output.draco.quantizationBitsPosition must be in [1..30]")
+      .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  if (output.dracoQuantBitsNormal < 1 || output.dracoQuantBitsNormal > 30)
+  {
+    Napi::RangeError::New(env, "output.draco.quantizationBitsNormal must be in [1..30]")
+      .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  // Build variants list (multi-output) or fallback to single outputPath.
+  std::vector<ConvertWorker::VariantOptions> variants;
+  if (options.Has("variants"))
+  {
+    if (!options.Get("variants").IsArray())
+    {
+      Napi::TypeError::New(env, "options.variants must be an array").ThrowAsJavaScriptException();
+      return env.Null();
+    }
+    Napi::Array arr = options.Get("variants").As<Napi::Array>();
+    const uint32_t n = arr.Length();
+    if (n == 0)
+    {
+      Napi::RangeError::New(env, "options.variants must be non-empty").ThrowAsJavaScriptException();
+      return env.Null();
+    }
+    variants.reserve(n);
+    for (uint32_t i = 0; i < n; ++i)
+    {
+      if (!arr.Get(i).IsObject())
+      {
+        Napi::TypeError::New(env, "variants[i] must be an object").ThrowAsJavaScriptException();
+        return env.Null();
+      }
+      Napi::Object v = arr.Get(i).As<Napi::Object>();
+      if (!v.Has("outputPath") || !v.Get("outputPath").IsString())
+      {
+        Napi::TypeError::New(env, "variants[i].outputPath must be a string").ThrowAsJavaScriptException();
+        return env.Null();
+      }
+
+      ConvertWorker::VariantOptions vo;
+      vo.outputPath = v.Get("outputPath").As<Napi::String>().Utf8Value();
+      vo.tess = tess;
+      vo.filter = filter;
+      vo.output = output;
+
+      if (v.Has("tessellation") && v.Get("tessellation").IsObject())
+      {
+        Napi::Object t = v.Get("tessellation").As<Napi::Object>();
+        if (t.Has("linearDeflection") && t.Get("linearDeflection").IsNumber())
+        {
+          vo.tess.linearDeflection = t.Get("linearDeflection").As<Napi::Number>().DoubleValue();
+        }
+        if (t.Has("angularDeflection") && t.Get("angularDeflection").IsNumber())
+        {
+          vo.tess.angularDeflection = t.Get("angularDeflection").As<Napi::Number>().DoubleValue();
+        }
+        if (t.Has("smoothNormals") && t.Get("smoothNormals").IsBoolean())
+        {
+          vo.tess.smoothNormals = t.Get("smoothNormals").As<Napi::Boolean>().Value();
+        }
+        if (t.Has("normalCreaseAngle") && t.Get("normalCreaseAngle").IsNumber())
+        {
+          vo.tess.normalCreaseAngle = t.Get("normalCreaseAngle").As<Napi::Number>().DoubleValue();
+        }
+        if (vo.tess.linearDeflection <= 0.0)
+        {
+          Napi::RangeError::New(env, "variants[i].tessellation.linearDeflection must be > 0")
+            .ThrowAsJavaScriptException();
+          return env.Null();
+        }
+        if (vo.tess.angularDeflection <= 0.0)
+        {
+          Napi::RangeError::New(env, "variants[i].tessellation.angularDeflection must be > 0")
+            .ThrowAsJavaScriptException();
+          return env.Null();
+        }
+        if (vo.tess.normalCreaseAngle < 0.0)
+        {
+          Napi::RangeError::New(env, "variants[i].tessellation.normalCreaseAngle must be >= 0")
+            .ThrowAsJavaScriptException();
+          return env.Null();
+        }
+      }
+
+      if (v.Has("filter") && v.Get("filter").IsObject())
+      {
+        Napi::Object f = v.Get("filter").As<Napi::Object>();
+        if (f.Has("minBBoxDiagonal") && f.Get("minBBoxDiagonal").IsNumber())
+        {
+          vo.filter.minBBoxDiagonal = f.Get("minBBoxDiagonal").As<Napi::Number>().DoubleValue();
+        }
+        if (vo.filter.minBBoxDiagonal < 0.0)
+        {
+          Napi::RangeError::New(env, "variants[i].filter.minBBoxDiagonal must be >= 0")
+            .ThrowAsJavaScriptException();
+          return env.Null();
+        }
+      }
+
+      if (v.Has("output") && v.Get("output").IsObject())
+      {
+        Napi::Object o = v.Get("output").As<Napi::Object>();
+        // Reuse the same parsing logic by applying overrides in the same order.
+        if (o.Has("unit") && o.Get("unit").IsString())
+        {
+          const std::string unit = o.Get("unit").As<Napi::String>().Utf8Value();
+          if (unit == "m") vo.output.unitScale = 0.001;
+          else if (unit == "cm") vo.output.unitScale = 0.1;
+          else if (unit == "mm") vo.output.unitScale = 1.0;
+          else
+          {
+            Napi::RangeError::New(env, "variants[i].output.unit must be one of: 'm', 'cm', 'mm'")
+              .ThrowAsJavaScriptException();
+            return env.Null();
+          }
+        }
+        if (o.Has("unitScale") && o.Get("unitScale").IsNumber())
+        {
+          vo.output.unitScale = o.Get("unitScale").As<Napi::Number>().DoubleValue();
+        }
+        if (vo.output.unitScale <= 0.0)
+        {
+          Napi::RangeError::New(env, "variants[i].output.unitScale must be > 0").ThrowAsJavaScriptException();
+          return env.Null();
+        }
+
+        if (o.Has("bakeTransforms") && o.Get("bakeTransforms").IsBoolean())
+        {
+          vo.output.bakeTransforms = o.Get("bakeTransforms").As<Napi::Boolean>().Value();
+        }
+
+        if (o.Has("center") && o.Get("center").IsString())
+        {
+          const std::string center = o.Get("center").As<Napi::String>().Utf8Value();
+          if (center == "none") vo.output.center = ConvertWorker::OutputOptions::CenterMode::None;
+          else if (center == "xy") vo.output.center = ConvertWorker::OutputOptions::CenterMode::XY;
+          else if (center == "xz") vo.output.center = ConvertWorker::OutputOptions::CenterMode::XZ;
+          else if (center == "yz") vo.output.center = ConvertWorker::OutputOptions::CenterMode::YZ;
+          else
+          {
+            Napi::RangeError::New(env, "variants[i].output.center must be one of: 'none', 'xy', 'xz', 'yz'")
+              .ThrowAsJavaScriptException();
+            return env.Null();
+          }
+        }
+
+        if (o.Has("zUp") && o.Get("zUp").IsBoolean())
+        {
+          vo.output.zUp = o.Get("zUp").As<Napi::Boolean>().Value();
+        }
+        if (o.Has("zup") && o.Get("zup").IsBoolean())
+        {
+          vo.output.zUp = o.Get("zup").As<Napi::Boolean>().Value();
+        }
+
+        if (o.Has("draco"))
+        {
+          const Napi::Value dv = o.Get("draco");
+          if (dv.IsBoolean())
+          {
+            vo.output.dracoEnabled = dv.As<Napi::Boolean>().Value();
+          }
+          else if (dv.IsObject())
+          {
+            Napi::Object d = dv.As<Napi::Object>();
+            if (d.Has("enabled") && d.Get("enabled").IsBoolean())
+            {
+              vo.output.dracoEnabled = d.Get("enabled").As<Napi::Boolean>().Value();
+            }
+            else
+            {
+              vo.output.dracoEnabled = true;
+            }
+            if (d.Has("compressionLevel") && d.Get("compressionLevel").IsNumber())
+            {
+              vo.output.dracoCompressionLevel = d.Get("compressionLevel").As<Napi::Number>().Int32Value();
+            }
+            if (d.Has("quantizationBitsPosition") && d.Get("quantizationBitsPosition").IsNumber())
+            {
+              vo.output.dracoQuantBitsPosition = d.Get("quantizationBitsPosition").As<Napi::Number>().Int32Value();
+            }
+            if (d.Has("quantizationBitsNormal") && d.Get("quantizationBitsNormal").IsNumber())
+            {
+              vo.output.dracoQuantBitsNormal = d.Get("quantizationBitsNormal").As<Napi::Number>().Int32Value();
+            }
+          }
+          else
+          {
+            Napi::TypeError::New(env, "variants[i].output.draco must be boolean or object")
+              .ThrowAsJavaScriptException();
+            return env.Null();
+          }
+        }
+
+        if (vo.output.dracoCompressionLevel < 0 || vo.output.dracoCompressionLevel > 10)
+        {
+          Napi::RangeError::New(env, "variants[i].output.draco.compressionLevel must be in [0..10]")
+            .ThrowAsJavaScriptException();
+          return env.Null();
+        }
+        if (vo.output.dracoQuantBitsPosition < 1 || vo.output.dracoQuantBitsPosition > 30)
+        {
+          Napi::RangeError::New(env, "variants[i].output.draco.quantizationBitsPosition must be in [1..30]")
+            .ThrowAsJavaScriptException();
+          return env.Null();
+        }
+        if (vo.output.dracoQuantBitsNormal < 1 || vo.output.dracoQuantBitsNormal > 30)
+        {
+          Napi::RangeError::New(env, "variants[i].output.draco.quantizationBitsNormal must be in [1..30]")
+            .ThrowAsJavaScriptException();
+          return env.Null();
+        }
+      }
+
+      variants.push_back(std::move(vo));
+    }
+  }
+  else
+  {
+    if (!options.Has("outputPath") || !options.Get("outputPath").IsString())
+    {
+      Napi::TypeError::New(env, "options.outputPath must be a string").ThrowAsJavaScriptException();
+      return env.Null();
+    }
+    ConvertWorker::VariantOptions vo;
+    vo.outputPath = options.Get("outputPath").As<Napi::String>().Utf8Value();
+    vo.tess = tess;
+    vo.filter = filter;
+    vo.output = output;
+    variants.push_back(std::move(vo));
+  }
+
+  Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
+  auto* worker = new ConvertWorker(env, deferred, std::move(inputPath), logLevel, std::move(variants));
+  worker->Queue();
+
+  return deferred.Promise();
+}
+
+static Napi::Object Init(Napi::Env env, Napi::Object exports)
+{
+  exports.Set("convertSTEPToGLTF", Napi::Function::New(env, ConvertSTEPToGLTF));
+  return exports;
+}
+
+NODE_API_MODULE(occt_gltf_addon, Init)
+