occt-gltf-addon 0.1.0

package/src/gltf_writer_scene.cpp

@@ -0,0 +1,545 @@
+#include "gltf_writer.h"
+
+#include <algorithm>
+#include <array>
+#include <cstdint>
+#include <cstring>
+#include <fstream>
+#include <limits>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#ifdef OCCT_GLTF_WITH_DRACO
+  #include <draco/compression/encode.h>
+  #include <draco/core/encoder_buffer.h>
+  #include <draco/mesh/mesh.h>
+  #include <draco/attributes/geometry_attribute.h>
+#endif
+
+static inline uint32_t Align4(uint32_t v) { return (v + 3u) & ~3u; }
+
+static void AppendU32(std::vector<uint8_t>& out, uint32_t v)
+{
+  out.push_back(static_cast<uint8_t>(v & 0xFFu));
+  out.push_back(static_cast<uint8_t>((v >> 8) & 0xFFu));
+  out.push_back(static_cast<uint8_t>((v >> 16) & 0xFFu));
+  out.push_back(static_cast<uint8_t>((v >> 24) & 0xFFu));
+}
+
+static void AppendBytes(std::vector<uint8_t>& out, const void* data, size_t size)
+{
+  const auto* p = static_cast<const uint8_t*>(data);
+  out.insert(out.end(), p, p + size);
+}
+
+static void AppendFloat32(std::vector<uint8_t>& out, float f)
+{
+  static_assert(sizeof(float) == 4, "float must be 32-bit");
+  uint32_t u = 0;
+  std::memcpy(&u, &f, 4);
+  AppendU32(out, u);
+}
+
+static std::array<float, 3> Min3Init()
+{
+  return {std::numeric_limits<float>::infinity(),
+          std::numeric_limits<float>::infinity(),
+          std::numeric_limits<float>::infinity()};
+}
+static std::array<float, 3> Max3Init()
+{
+  return {-std::numeric_limits<float>::infinity(),
+          -std::numeric_limits<float>::infinity(),
+          -std::numeric_limits<float>::infinity()};
+}
+
+static bool IsIdentityMatrix(const std::array<float, 16>& m)
+{
+  const std::array<float, 16> I = {
+    1,0,0,0,
+    0,1,0,0,
+    0,0,1,0,
+    0,0,0,1
+  };
+  return m == I;
+}
+
+static std::string JsonEscapeUtf8(const std::string& s)
+{
+  std::string out;
+  out.reserve(s.size() + 16);
+  static const char hex[] = "0123456789ABCDEF";
+
+  for (unsigned char uc : s)
+  {
+    switch (uc)
+    {
+      case '\\': out += "\\\\"; break;
+      case '"': out += "\\\""; break;
+      case '\b': out += "\\b"; break;
+      case '\f': out += "\\f"; break;
+      case '\n': out += "\\n"; break;
+      case '\r': out += "\\r"; break;
+      case '\t': out += "\\t"; break;
+      default:
+      {
+        // JSON does not allow unescaped control characters (0x00-0x1F).
+        if (uc < 0x20)
+        {
+          out += "\\u00";
+          out.push_back(hex[(uc >> 4) & 0x0F]);
+          out.push_back(hex[uc & 0x0F]);
+        }
+        else
+        {
+          out.push_back(static_cast<char>(uc));
+        }
+        break;
+      }
+    }
+  }
+  return out;
+}
+
+struct MeshChunk
+{
+  // Uncompressed layout
+  uint32_t posOff = 0, posLen = 0;
+  uint32_t nrmOff = 0, nrmLen = 0;
+
+  // Draco-compressed layout
+  uint32_t dracoOff = 0, dracoLen = 0;
+  int dracoPosId = 0;
+  int dracoNrmId = 1;
+
+  uint32_t vCount = 0;
+  std::array<float, 3> minP = Min3Init();
+  std::array<float, 3> maxP = Max3Init();
+};
+
+static void PadBinTo4(std::vector<uint8_t>& bin)
+{
+  const uint32_t pad = Align4(static_cast<uint32_t>(bin.size())) - static_cast<uint32_t>(bin.size());
+  for (uint32_t i = 0; i < pad; ++i) bin.push_back(0);
+}
+
+#ifdef OCCT_GLTF_WITH_DRACO
+static std::vector<uint8_t> EncodeMeshDraco(const MeshData& mesh, const GltfWriteOptions& opt, int& posAttId, int& nrmAttId)
+{
+  const uint32_t vCount = static_cast<uint32_t>(mesh.positions.size() / 3);
+  if (vCount == 0)
+  {
+    posAttId = 0;
+    nrmAttId = 1;
+    return {};
+  }
+  if (vCount % 3 != 0)
+  {
+    throw std::runtime_error("Draco encode expects triangle-list with vertexCount % 3 == 0.");
+  }
+
+  const uint32_t faceCount = vCount / 3;
+
+  draco::Mesh dmesh;
+  dmesh.SetNumFaces(faceCount);
+  dmesh.set_num_points(vCount);
+
+  draco::GeometryAttribute posAtt;
+  posAtt.Init(draco::GeometryAttribute::POSITION,
+              /*attribute_name*/ nullptr,
+              /*num_components*/ 3,
+              draco::DT_FLOAT32,
+              /*normalized*/ false,
+              /*byte_stride*/ sizeof(float) * 3,
+              /*byte_offset*/ 0);
+  posAttId = dmesh.AddAttribute(posAtt, /*identity_mapping*/ true, vCount);
+
+  draco::GeometryAttribute nrmAtt;
+  nrmAtt.Init(draco::GeometryAttribute::NORMAL,
+              /*attribute_name*/ nullptr,
+              /*num_components*/ 3,
+              draco::DT_FLOAT32,
+              /*normalized*/ false,
+              /*byte_stride*/ sizeof(float) * 3,
+              /*byte_offset*/ 0);
+  nrmAttId = dmesh.AddAttribute(nrmAtt, /*identity_mapping*/ true, vCount);
+
+  auto* posPtr = dmesh.attribute(posAttId);
+  auto* nrmPtr = dmesh.attribute(nrmAttId);
+  if (posPtr == nullptr || nrmPtr == nullptr)
+  {
+    throw std::runtime_error("Draco: failed to create attributes.");
+  }
+
+  for (uint32_t i = 0; i < vCount; ++i)
+  {
+    const draco::PointIndex pi(i);
+    posPtr->SetAttributeValue(posPtr->mapped_index(pi), &mesh.positions[i * 3]);
+    nrmPtr->SetAttributeValue(nrmPtr->mapped_index(pi), &mesh.normals[i * 3]);
+  }
+
+  for (uint32_t f = 0; f < faceCount; ++f)
+  {
+    const draco::FaceIndex fi(f);
+    draco::Mesh::Face face;
+    face[0] = draco::PointIndex(f * 3 + 0);
+    face[1] = draco::PointIndex(f * 3 + 1);
+    face[2] = draco::PointIndex(f * 3 + 2);
+    dmesh.SetFace(fi, face);
+  }
+
+  draco::Encoder encoder;
+  const int encSpeed = std::max(0, std::min(10, 10 - opt.dracoCompressionLevel));
+  encoder.SetSpeedOptions(encSpeed, /*decode_speed*/ 10);
+  encoder.SetEncodingMethod(draco::MESH_EDGEBREAKER_ENCODING);
+
+  encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, opt.dracoQuantBitsPosition);
+  encoder.SetAttributeQuantization(draco::GeometryAttribute::NORMAL, opt.dracoQuantBitsNormal);
+
+  draco::EncoderBuffer buffer;
+  const draco::Status status = encoder.EncodeMeshToBuffer(dmesh, &buffer);
+  if (!status.ok())
+  {
+    throw std::runtime_error(std::string("Draco encode failed: ") + status.error_msg());
+  }
+
+  const uint8_t* p = reinterpret_cast<const uint8_t*>(buffer.data());
+  return std::vector<uint8_t>(p, p + buffer.size());
+}
+#endif
+
+std::uint64_t WriteGLB(const std::string& outputPath, const SceneData& scene, const GltfWriteOptions& opt)
+{
+  std::vector<uint8_t> bin;
+  bin.reserve(1024 * 1024);
+
+  std::vector<MeshChunk> chunks;
+  chunks.reserve(scene.meshes.size());
+
+  if (opt.dracoEnabled)
+  {
+#ifndef OCCT_GLTF_WITH_DRACO
+    throw std::runtime_error("Draco compression requested, but addon was built without Draco (OCCT_GLTF_WITH_DRACO).");
+#endif
+  }
+
+  // Build BIN and per-mesh metadata.
+  for (const auto& mesh : scene.meshes)
+  {
+    if (mesh.positions.size() % 3 != 0 || mesh.normals.size() != mesh.positions.size())
+    {
+      throw std::runtime_error("Invalid mesh buffers (positions/normals mismatch).");
+    }
+
+    MeshChunk ch;
+    ch.vCount = static_cast<uint32_t>(mesh.positions.size() / 3);
+
+    // min/max for POSITION
+    for (uint32_t i = 0; i < ch.vCount; ++i)
+    {
+      const float x = mesh.positions[i * 3 + 0];
+      const float y = mesh.positions[i * 3 + 1];
+      const float z = mesh.positions[i * 3 + 2];
+      ch.minP[0] = std::min(ch.minP[0], x); ch.minP[1] = std::min(ch.minP[1], y); ch.minP[2] = std::min(ch.minP[2], z);
+      ch.maxP[0] = std::max(ch.maxP[0], x); ch.maxP[1] = std::max(ch.maxP[1], y); ch.maxP[2] = std::max(ch.maxP[2], z);
+    }
+
+    if (!opt.dracoEnabled)
+    {
+      ch.posOff = static_cast<uint32_t>(bin.size());
+      for (float f : mesh.positions) AppendFloat32(bin, f);
+      ch.posLen = static_cast<uint32_t>(bin.size()) - ch.posOff;
+
+      ch.nrmOff = static_cast<uint32_t>(bin.size());
+      for (float f : mesh.normals) AppendFloat32(bin, f);
+      ch.nrmLen = static_cast<uint32_t>(bin.size()) - ch.nrmOff;
+    }
+    else
+    {
+#ifdef OCCT_GLTF_WITH_DRACO
+      PadBinTo4(bin);
+      ch.dracoOff = static_cast<uint32_t>(bin.size());
+      int posId = 0, nrmId = 1;
+      const std::vector<uint8_t> draco = EncodeMeshDraco(mesh, opt, posId, nrmId);
+      ch.dracoPosId = posId;
+      ch.dracoNrmId = nrmId;
+      AppendBytes(bin, draco.data(), draco.size());
+      ch.dracoLen = static_cast<uint32_t>(bin.size()) - ch.dracoOff;
+      PadBinTo4(bin);
+#endif
+    }
+
+    chunks.push_back(ch);
+  }
+
+  // Build glTF JSON (UTF-8) preserving nodes hierarchy.
+  std::ostringstream json;
+  json << "{";
+  json << "\"asset\":{\"version\":\"2.0\",\"generator\":\"occt-gltf-addon\"},";
+  json << "\"scene\":0,";
+  if (opt.dracoEnabled)
+  {
+    json << "\"extensionsUsed\":[\"KHR_draco_mesh_compression\"],";
+    json << "\"extensionsRequired\":[\"KHR_draco_mesh_compression\"],";
+  }
+
+  // scenes
+  json << "\"scenes\":[{\"nodes\":[";
+  for (size_t i = 0; i < scene.roots.size(); ++i)
+  {
+    if (i) json << ",";
+    json << scene.roots[i];
+  }
+  json << "]}],";
+
+  // nodes
+  json << "\"nodes\":[";
+  for (size_t i = 0; i < scene.nodes.size(); ++i)
+  {
+    const SceneNode& n = scene.nodes[i];
+    if (i) json << ",";
+
+    std::ostringstream node;
+    node << "{";
+    bool first = true;
+
+    if (!n.name.empty())
+    {
+      node << "\"name\":\"" << JsonEscapeUtf8(n.name) << "\"";
+      first = false;
+    }
+    if (n.meshIndex >= 0)
+    {
+      if (!first) node << ",";
+      node << "\"mesh\":" << n.meshIndex;
+      first = false;
+    }
+    if (!n.children.empty())
+    {
+      if (!first) node << ",";
+      node << "\"children\":[";
+      for (size_t ci = 0; ci < n.children.size(); ++ci)
+      {
+        if (ci) node << ",";
+        node << n.children[ci];
+      }
+      node << "]";
+      first = false;
+    }
+    if (!IsIdentityMatrix(n.matrix))
+    {
+      if (!first) node << ",";
+      node << "\"matrix\":[";
+      for (int k = 0; k < 16; ++k)
+      {
+        if (k) node << ",";
+        node << n.matrix[(size_t)k];
+      }
+      node << "]";
+    }
+
+    node << "}";
+    json << node.str();
+  }
+  json << "],";
+
+  // meshes
+  json << "\"meshes\":[";
+  for (size_t mi = 0; mi < scene.meshes.size(); ++mi)
+  {
+    if (mi) json << ",";
+    const MeshData& mesh = scene.meshes[mi];
+    const uint32_t posAccessor = static_cast<uint32_t>(mi * 2);
+    const uint32_t nrmAccessor = static_cast<uint32_t>(mi * 2 + 1);
+    json << "{"
+         << "\"primitives\":[{"
+         << "\"attributes\":{"
+         << "\"POSITION\":" << posAccessor << ","
+         << "\"NORMAL\":" << nrmAccessor
+         << "},\"mode\":4";
+    if (mesh.materialIndex >= 0)
+    {
+      json << ",\"material\":" << mesh.materialIndex;
+    }
+    if (opt.dracoEnabled)
+    {
+      const MeshChunk& ch = chunks[mi];
+      json << ",\"extensions\":{"
+           << "\"KHR_draco_mesh_compression\":{"
+           << "\"bufferView\":" << mi
+           << ",\"attributes\":{"
+           << "\"POSITION\":" << ch.dracoPosId << ","
+           << "\"NORMAL\":" << ch.dracoNrmId
+           << "}}}";
+    }
+    json
+         << "}]}";
+  }
+  json << "],";
+
+  // materials (optional)
+  if (!scene.materials.empty())
+  {
+    json << "\"materials\":[";
+    for (size_t i = 0; i < scene.materials.size(); ++i)
+    {
+      const MaterialData& m = scene.materials[i];
+      if (i) json << ",";
+      json << "{"
+           << "\"pbrMetallicRoughness\":{"
+           <<   "\"baseColorFactor\":["
+           <<     m.baseColorFactor[0] << "," << m.baseColorFactor[1] << "," << m.baseColorFactor[2] << "," << m.baseColorFactor[3]
+           <<   "],"
+           <<   "\"metallicFactor\":" << m.metallicFactor << ","
+           <<   "\"roughnessFactor\":" << m.roughnessFactor
+           << "},"
+           << "\"doubleSided\":" << (m.doubleSided ? "true" : "false");
+      if (m.baseColorFactor[3] < 1.0f)
+      {
+        json << ",\"alphaMode\":\"BLEND\"";
+      }
+      json << "}";
+    }
+    json << "],";
+  }
+
+  // bufferViews
+  json << "\"bufferViews\":[";
+  if (!opt.dracoEnabled)
+  {
+    // 2 per mesh (POSITION, NORMAL)
+    for (size_t mi = 0; mi < chunks.size(); ++mi)
+    {
+      const MeshChunk& ch = chunks[mi];
+      if (mi) json << ",";
+      json << "{"
+           << "\"buffer\":0,\"byteOffset\":" << ch.posOff << ",\"byteLength\":" << ch.posLen << ",\"target\":34962"
+           << "},"
+           << "{"
+           << "\"buffer\":0,\"byteOffset\":" << ch.nrmOff << ",\"byteLength\":" << ch.nrmLen << ",\"target\":34962"
+           << "}";
+    }
+  }
+  else
+  {
+    // 1 per mesh (Draco compressed data)
+    for (size_t mi = 0; mi < chunks.size(); ++mi)
+    {
+      const MeshChunk& ch = chunks[mi];
+      if (mi) json << ",";
+      json << "{"
+           << "\"buffer\":0,\"byteOffset\":" << ch.dracoOff << ",\"byteLength\":" << ch.dracoLen
+           << "}";
+    }
+  }
+  json << "],";
+
+  // accessors (2 per mesh)
+  json << "\"accessors\":[";
+  for (size_t mi = 0; mi < chunks.size(); ++mi)
+  {
+    const MeshChunk& ch = chunks[mi];
+    if (mi) json << ",";
+    if (!opt.dracoEnabled)
+    {
+      const uint32_t posView = static_cast<uint32_t>(mi * 2);
+      const uint32_t nrmView = static_cast<uint32_t>(mi * 2 + 1);
+      json << "{"
+           << "\"bufferView\":" << posView
+           << ",\"byteOffset\":0,\"componentType\":5126,\"count\":" << ch.vCount
+           << ",\"type\":\"VEC3\""
+           << ",\"min\":[" << ch.minP[0] << "," << ch.minP[1] << "," << ch.minP[2] << "]"
+           << ",\"max\":[" << ch.maxP[0] << "," << ch.maxP[1] << "," << ch.maxP[2] << "]"
+           << "},"
+           << "{"
+           << "\"bufferView\":" << nrmView
+           << ",\"byteOffset\":0,\"componentType\":5126,\"count\":" << ch.vCount
+           << ",\"type\":\"VEC3\""
+           << "}";
+    }
+    else
+    {
+      // For Draco, accessors describe the attribute type/count; data comes from the extension bufferView.
+      json << "{"
+           << "\"componentType\":5126,\"count\":" << ch.vCount
+           << ",\"type\":\"VEC3\""
+           << ",\"min\":[" << ch.minP[0] << "," << ch.minP[1] << "," << ch.minP[2] << "]"
+           << ",\"max\":[" << ch.maxP[0] << "," << ch.maxP[1] << "," << ch.maxP[2] << "]"
+           << "},"
+           << "{"
+           << "\"componentType\":5126,\"count\":" << ch.vCount
+           << ",\"type\":\"VEC3\""
+           << "}";
+    }
+  }
+  json << "],";
+
+  json << "\"buffers\":[{\"byteLength\":" << bin.size() << "}]}";
+
+  std::string jsonStr = json.str();
+
+  // JSON chunk padded to 4 bytes with spaces.
+  const uint32_t jsonLen = static_cast<uint32_t>(jsonStr.size());
+  const uint32_t jsonPaddedLen = Align4(jsonLen);
+  jsonStr.resize(jsonPaddedLen, ' ');
+
+  // BIN chunk padded to 4 bytes with zeros.
+  const uint32_t binLen = static_cast<uint32_t>(bin.size());
+  const uint32_t binPaddedLen = Align4(binLen);
+  bin.resize(binPaddedLen, 0);
+
+  const uint32_t totalLen = 12u
+    + 8u + static_cast<uint32_t>(jsonStr.size())
+    + 8u + static_cast<uint32_t>(bin.size());
+
+  std::vector<uint8_t> glb;
+  glb.reserve(totalLen);
+
+  AppendU32(glb, 0x46546C67u); // 'glTF'
+  AppendU32(glb, 2u);
+  AppendU32(glb, totalLen);
+
+  // JSON chunk
+  AppendU32(glb, static_cast<uint32_t>(jsonStr.size()));
+  AppendU32(glb, 0x4E4F534Au); // 'JSON'
+  AppendBytes(glb, jsonStr.data(), jsonStr.size());
+
+  // BIN chunk
+  AppendU32(glb, static_cast<uint32_t>(bin.size()));
+  AppendU32(glb, 0x004E4942u); // 'BIN\0'
+  AppendBytes(glb, bin.data(), bin.size());
+
+  if (glb.size() != totalLen)
+  {
+    throw std::runtime_error("Internal error: GLB size mismatch.");
+  }
+
+  std::ofstream ofs(outputPath, std::ios::binary);
+  if (!ofs)
+  {
+    throw std::runtime_error("Failed to open output file: " + outputPath);
+  }
+  ofs.write(reinterpret_cast<const char*>(glb.data()), static_cast<std::streamsize>(glb.size()));
+  if (!ofs)
+  {
+    throw std::runtime_error("Failed to write output file: " + outputPath);
+  }
+
+  return static_cast<std::uint64_t>(glb.size());
+}
+
+std::uint64_t WriteGLB(const std::string& outputPath, const MeshData& mesh, const GltfWriteOptions& opt)
+{
+  SceneData scene;
+  scene.meshes.push_back(mesh);
+  SceneNode root;
+  root.name = "Root";
+  root.meshIndex = 0;
+  scene.nodes.push_back(root);
+  scene.roots.push_back(0);
+  return WriteGLB(outputPath, scene, opt);
+}
+

package/src/mesh_types.h

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <array>
+#include <vector>
+
+struct MeshData
+{
+  // Unindexed triangle list. Each 3 floats = one vertex position.
+  std::vector<float> positions; // xyz xyz xyz ...
+  std::vector<float> normals;   // xyz xyz xyz ...
+
+  // glTF material index (SceneData::materials), -1 for default.
+  int materialIndex = -1;
+};
+
+struct MaterialData
+{
+  // glTF PBR baseColorFactor (linear RGBA in [0..1])
+  std::array<float, 4> baseColorFactor = {1.0f, 1.0f, 1.0f, 1.0f};
+  float metallicFactor = 0.0f;
+  float roughnessFactor = 1.0f;
+  bool doubleSided = true;
+};
+
+struct ConvertStats
+{
+  // Inputs
+  double linearDeflection = 0.1;
+  double angularDeflection = 0.5;
+
+  // STEP / mesh stats
+  std::uint64_t facesTotal = 0;
+  std::uint64_t facesWithTriangulation = 0;
+  std::uint64_t triangles = 0;
+  std::uint64_t vertices = 0; // expanded vertices (triangle list)
+
+  // Output stats
+  std::uint64_t glbBytes = 0;
+
+  // Timings (milliseconds)
+  std::uint64_t msRead = 0;
+  std::uint64_t msTransfer = 0;
+  std::uint64_t msMesh = 0;
+  std::uint64_t msExtract = 0;
+  std::uint64_t msWrite = 0;
+  std::uint64_t msTotal = 0;
+
+  // Scene graph stats
+  std::uint64_t nodes = 0;
+  std::uint64_t meshes = 0;
+
+  // Diagnostics
+  std::uint64_t skippedMeshesNoTriangulation = 0;
+  std::uint64_t skippedSmallParts = 0;
+};
+
+struct SceneNode
+{
+  std::string name;                 // UTF-8 (supports Chinese)
+  std::vector<int> children;        // indices into SceneData::nodes
+  int meshIndex = -1;               // index into SceneData::meshes, -1 for none
+  std::array<float, 16> matrix = {  // glTF column-major 4x4
+    1,0,0,0,
+    0,1,0,0,
+    0,0,1,0,
+    0,0,0,1
+  };
+};
+
+struct SceneData
+{
+  std::vector<MeshData> meshes;
+  std::vector<MaterialData> materials;
+  std::vector<SceneNode> nodes;
+  std::vector<int> roots; // root node indices
+};