volt-spatial-assembler 1.0.1__tar.gz

volt_spatial_assembler-1.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VoltLabs Research
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

volt_spatial_assembler-1.0.1/MANIFEST.in

@@ -0,0 +1,2 @@
+include src/glb_core.h
+include src/glb_python.cpp

volt_spatial_assembler-1.0.1/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: volt-spatial-assembler
+Version: 1.0.1
+Summary: Native GLB assembler for Volt (shared C++ core with the Node addon).
+License-Expression: MIT
+Requires-Python: >=3.10
+License-File: LICENSE
+Dynamic: license-file

volt_spatial_assembler-1.0.1/pyproject.toml

@@ -0,0 +1,13 @@
+[build-system]
+requires = ["setuptools>=64", "pybind11>=2.12"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "volt-spatial-assembler"
+version = "1.0.1"
+description = "Native GLB assembler for Volt (shared C++ core with the Node addon)."
+requires-python = ">=3.10"
+license = "MIT"
+
+[tool.setuptools]
+packages = ["volt_spatial_assembler"]

volt_spatial_assembler-1.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

volt_spatial_assembler-1.0.1/setup.py

@@ -0,0 +1,15 @@
+from pybind11.setup_helpers import Pybind11Extension, build_ext
+from setuptools import setup
+
+setup(
+    cmdclass={'build_ext': build_ext},
+    ext_modules=[
+        Pybind11Extension(
+            'volt_spatial_assembler._spatial_assembler',
+            ['src/glb_python.cpp'],
+            include_dirs=['src'],
+            cxx_std=17,
+            extra_compile_args=['-O3', '-pthread'],
+        ),
+    ],
+)

volt_spatial_assembler-1.0.1/src/glb_core.h

@@ -0,0 +1,353 @@
+#pragma once
+//
+// glb_core.h - Runtime-agnostic GLB assembly core.
+//
+// Single source of truth for GLB generation, shared by the Node (N-API) and
+// Python (pybind11) bindings. Contains NO node_api.h / Python.h: just plain
+// C++ on raw buffers. All functions are `inline` and all file-scope state is
+// `static` so the header can be included in multiple translation units.
+//
+#include <algorithm>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <thread>
+#include <vector>
+
+// Fast SIMD path: GCC/Clang on x86 only (target attributes + __builtin_cpu_*).
+#if (defined(__GNUC__) || defined(__clang__)) && (defined(__x86_64__) || defined(__i386__))
+#define SA_FAST_PATH 1
+#include <immintrin.h>
+#define SA_AVX2_BMI2_TARGET __attribute__((target("avx2,bmi2")))
+#else
+#define SA_FAST_PATH 0
+#define SA_AVX2_BMI2_TARGET
+#endif
+
+#if defined(_MSC_VER)
+#define SA_FORCE_INLINE inline
+#else
+#define SA_FORCE_INLINE inline __attribute__((always_inline))
+#endif
+#define SA_RESTRICT __restrict
+
+namespace glbcore {
+
+static inline void* aligned_malloc(size_t size) {
+    void* ptr = malloc(size);
+    if (!ptr) abort();
+    return ptr;
+}
+
+static inline void aligned_free(void* ptr) {
+    free(ptr);
+}
+
+static inline unsigned int worker_thread_count(unsigned int fallback = 4) {
+    unsigned int n = std::thread::hardware_concurrency();
+    return n == 0 ? fallback : n;
+}
+
+static inline bool has_fast_cpu_features() {
+#if SA_FAST_PATH
+    __builtin_cpu_init();
+    return __builtin_cpu_supports("avx2") && __builtin_cpu_supports("bmi2");
+#else
+    return false;
+#endif
+}
+
+// Type colors (SoA), 8 structure types.
+static const float TYPE_COLORS_R[8] = {0.5f, 1.0f, 0.267f, 0.267f, 1.0f, 1.0f, 0.267f, 0.6f};
+static const float TYPE_COLORS_G[8] = {0.5f, 0.267f, 1.0f, 0.267f, 1.0f, 0.267f, 1.0f, 0.6f};
+static const float TYPE_COLORS_B[8] = {0.5f, 0.267f, 0.267f, 1.0f, 0.267f, 1.0f, 1.0f, 0.6f};
+
+SA_FORCE_INLINE uint32_t expand_bits_3d(uint32_t v) {
+    v &= 0x000003ffu;
+    v = (v | (v << 16)) & 0x030000FFu;
+    v = (v | (v << 8)) & 0x0300F00Fu;
+    v = (v | (v << 4)) & 0x030C30C3u;
+    v = (v | (v << 2)) & 0x09249249u;
+    return v;
+}
+
+SA_FORCE_INLINE uint32_t morton3d_scalar(uint32_t x, uint32_t y, uint32_t z) {
+    return expand_bits_3d(x) | (expand_bits_3d(y) << 1) | (expand_bits_3d(z) << 2);
+}
+
+#if SA_FAST_PATH
+SA_AVX2_BMI2_TARGET static inline uint32_t morton3d_bmi2(uint32_t x, uint32_t y, uint32_t z) {
+    return _pdep_u32(x, 0x92492492) | _pdep_u32(y, 0x24924924) | _pdep_u32(z, 0x49249249);
+}
+#endif
+
+struct RadixHist {
+    uint32_t count[256];
+};
+
+static inline void radix_count_chunk(const uint32_t* SA_RESTRICT keys, size_t start, size_t end, int shift, RadixHist* hist) {
+    memset(hist->count, 0, sizeof(hist->count));
+    for (size_t i = start; i < end; i++) {
+        hist->count[(keys[i] >> shift) & 0xFF]++;
+    }
+}
+
+static inline void radix_scatter(
+    const uint32_t* SA_RESTRICT srcKeys, const uint32_t* SA_RESTRICT srcIndices,
+    uint32_t* SA_RESTRICT dstKeys, uint32_t* SA_RESTRICT dstIndices,
+    size_t start, size_t end, int shift, uint32_t* localOffsets) {
+    for (size_t i = start; i < end; i++) {
+        uint8_t bucket = (srcKeys[i] >> shift) & 0xFF;
+        uint32_t d = localOffsets[bucket]++;
+        dstKeys[d] = srcKeys[i];
+        dstIndices[d] = srcIndices[i];
+    }
+}
+
+static inline void lock_free_radix_sort(uint32_t*& keys, uint32_t*& indices, size_t n, unsigned int numThreads) {
+    uint32_t* tmpKeys = (uint32_t*)aligned_malloc(n * sizeof(uint32_t));
+    uint32_t* tmpIndices = (uint32_t*)aligned_malloc(n * sizeof(uint32_t));
+    uint32_t *srcK = keys, *dstK = tmpKeys;
+    uint32_t *srcI = indices, *dstI = tmpIndices;
+
+    std::vector<RadixHist> hists(numThreads);
+    std::vector<std::thread> threads;
+    size_t blockSize = (n + numThreads - 1) / numThreads;
+    std::vector<std::vector<uint32_t>> threadOffsets(numThreads, std::vector<uint32_t>(256));
+
+    for (int shift = 0; shift < 32; shift += 8) {
+        threads.clear();
+        for (unsigned int t = 0; t < numThreads; t++) {
+            size_t start = t * blockSize, end = std::min(start + blockSize, n);
+            if (start < n) threads.emplace_back(radix_count_chunk, srcK, start, end, shift, &hists[t]);
+        }
+        for (auto& th : threads) th.join();
+
+        uint32_t globalOffsets[256];
+        uint32_t running = 0;
+        for (int b = 0; b < 256; b++) {
+            globalOffsets[b] = running;
+            for (unsigned int t = 0; t < numThreads; t++) running += hists[t].count[b];
+        }
+        for (int b = 0; b < 256; b++) {
+            uint32_t offset = globalOffsets[b];
+            for (unsigned int t = 0; t < numThreads; t++) {
+                threadOffsets[t][b] = offset;
+                offset += hists[t].count[b];
+            }
+        }
+
+        threads.clear();
+        for (unsigned int t = 0; t < numThreads; t++) {
+            size_t start = t * blockSize, end = std::min(start + blockSize, n);
+            if (start < n) threads.emplace_back(radix_scatter, srcK, srcI, dstK, dstI, start, end, shift, threadOffsets[t].data());
+        }
+        for (auto& th : threads) th.join();
+        std::swap(srcK, dstK);
+        std::swap(srcI, dstI);
+    }
+
+    if (srcK != keys) {
+        memcpy(keys, srcK, n * sizeof(uint32_t));
+        memcpy(indices, srcI, n * sizeof(uint32_t));
+    }
+    aligned_free(tmpKeys);
+    aligned_free(tmpIndices);
+}
+
+static inline void colorize_by_type(
+    const uint32_t* SA_RESTRICT indices, const uint16_t* SA_RESTRICT srcTypes,
+    float* SA_RESTRICT dstColors, size_t start, size_t end) {
+    for (size_t i = start; i < end; i++) {
+        uint16_t t = srcTypes[indices[i]];
+        uint32_t c = (t <= 7) ? t : 7;
+        size_t out = i * 3;
+        dstColors[out] = TYPE_COLORS_R[c];
+        dstColors[out + 1] = TYPE_COLORS_G[c];
+        dstColors[out + 2] = TYPE_COLORS_B[c];
+    }
+}
+
+static inline void gather_positions(
+    const uint32_t* SA_RESTRICT indices, const float* SA_RESTRICT srcPos,
+    float* SA_RESTRICT dstPos, size_t start, size_t end) {
+    for (size_t i = start; i < end; i++) {
+        size_t s = indices[i] * 3, d = i * 3;
+        dstPos[d] = srcPos[s];
+        dstPos[d + 1] = srcPos[s + 1];
+        dstPos[d + 2] = srcPos[s + 2];
+    }
+}
+
+// Assemble a GLB container from a JSON chunk and a contiguous BIN blob.
+static inline std::vector<uint8_t> assemble_glb(const char* json, size_t jsonLen, const uint8_t* bin, size_t binLen) {
+    size_t jsonPad = (4 - (jsonLen % 4)) % 4;
+    size_t binPad = (4 - (binLen % 4)) % 4;
+    size_t jsonChunk = jsonLen + jsonPad;
+    size_t binChunk = binLen + binPad;
+    size_t total = 12 + 8 + jsonChunk + 8 + binChunk;
+
+    std::vector<uint8_t> glb(total);
+    uint8_t* p = glb.data();
+    auto put = [&](uint32_t v) { memcpy(p, &v, 4); p += 4; };
+    put(0x46546C67); put(2); put((uint32_t)total);          // GLB header
+    put((uint32_t)jsonChunk); put(0x4E4F534A);              // JSON chunk header
+    memcpy(p, json, jsonLen); p += jsonLen;
+    memset(p, ' ', jsonPad); p += jsonPad;
+    put((uint32_t)binChunk); put(0x004E4942);               // BIN chunk header
+    if (binLen) { memcpy(p, bin, binLen); p += binLen; }
+    memset(p, 0, binPad);
+    return glb;
+}
+
+// ---- Entry points ---------------------------------------------------------
+
+// Atom cloud: Morton-sort by position, colorize by structure type, emit GLB.
+static inline std::vector<uint8_t> generate_atom_glb(
+    const float* srcPos, size_t n, const uint16_t* srcTypes,
+    const double minA[3], const double maxA[3]) {
+    if (n == 0) return assemble_glb("{}", 2, nullptr, 0);
+
+    const bool fast = has_fast_cpu_features();
+    float* outPos = (float*)aligned_malloc(n * 3 * sizeof(float));
+    float* outCol = (float*)aligned_malloc(n * 3 * sizeof(float));
+    uint32_t* keys = (uint32_t*)aligned_malloc(n * sizeof(uint32_t));
+    uint32_t* indices = (uint32_t*)aligned_malloc(n * sizeof(uint32_t));
+
+    unsigned int numThreads = (n < 100000) ? 1 : worker_thread_count();
+    size_t blockSize = (n + numThreads - 1) / numThreads;
+
+    float invX = 1.0f / std::max(1e-10f, (float)(maxA[0] - minA[0]));
+    float invY = 1.0f / std::max(1e-10f, (float)(maxA[1] - minA[1]));
+    float invZ = 1.0f / std::max(1e-10f, (float)(maxA[2] - minA[2]));
+
+    auto mortonWorker = [&](size_t start, size_t end) {
+        for (size_t i = start; i < end; i++) {
+            size_t p = i * 3;
+            float x = (srcPos[p] - (float)minA[0]) * invX;
+            float y = (srcPos[p + 1] - (float)minA[1]) * invY;
+            float z = (srcPos[p + 2] - (float)minA[2]) * invZ;
+            uint32_t ux = std::min(1023u, std::max(0u, (uint32_t)(x * 1023.0f)));
+            uint32_t uy = std::min(1023u, std::max(0u, (uint32_t)(y * 1023.0f)));
+            uint32_t uz = std::min(1023u, std::max(0u, (uint32_t)(z * 1023.0f)));
+#if SA_FAST_PATH
+            keys[i] = fast ? morton3d_bmi2(ux, uy, uz) : morton3d_scalar(ux, uy, uz);
+#else
+            keys[i] = morton3d_scalar(ux, uy, uz);
+#endif
+            indices[i] = (uint32_t)i;
+        }
+    };
+
+    std::vector<std::thread> threads;
+    for (unsigned int t = 0; t < numThreads; t++) {
+        size_t start = t * blockSize, end = std::min(start + blockSize, n);
+        if (start < n) threads.emplace_back(mortonWorker, start, end);
+    }
+    for (auto& th : threads) th.join();
+
+    lock_free_radix_sort(keys, indices, n, numThreads);
+
+    threads.clear();
+    for (unsigned int t = 0; t < numThreads; t++) {
+        size_t start = t * blockSize, end = std::min(start + blockSize, n);
+        if (start < n) threads.emplace_back([&, start, end]() {
+            gather_positions(indices, srcPos, outPos, start, end);
+            colorize_by_type(indices, srcTypes, outCol, start, end);
+        });
+    }
+    for (auto& th : threads) th.join();
+
+    size_t posBytes = n * 3 * sizeof(float);
+    char json[2048];
+    int jsonLen = snprintf(json, sizeof(json),
+        R"({"asset":{"version":"2.0","generator":"Volt Native"},"scene":0,"scenes":[{"nodes":[0]}],"nodes":[{"mesh":0,"name":"Atoms"}],"meshes":[{"primitives":[{"attributes":{"POSITION":0,"COLOR_0":1},"mode":0}],"name":"AtomCloud"}],"accessors":[{"bufferView":0,"componentType":5126,"count":%zu,"type":"VEC3","min":[%.6f,%.6f,%.6f],"max":[%.6f,%.6f,%.6f]},{"bufferView":1,"componentType":5126,"count":%zu,"type":"VEC3"}],"bufferViews":[{"buffer":0,"byteOffset":0,"byteLength":%zu,"target":34962},{"buffer":0,"byteOffset":%zu,"byteLength":%zu,"target":34962}],"buffers":[{"byteLength":%zu}]})",
+        n, minA[0], minA[1], minA[2], maxA[0], maxA[1], maxA[2], n, posBytes, posBytes, posBytes, posBytes * 2);
+
+    std::vector<uint8_t> bin(posBytes * 2);
+    memcpy(bin.data(), outPos, posBytes);
+    memcpy(bin.data() + posBytes, outCol, posBytes);
+
+    aligned_free(outPos);
+    aligned_free(outCol);
+    aligned_free(keys);
+    aligned_free(indices);
+    return assemble_glb(json, jsonLen, bin.data(), bin.size());
+}
+
+// Pre-colored point cloud (colors VEC3 or VEC4).
+static inline std::vector<uint8_t> generate_point_cloud_glb(
+    const float* positions, size_t posCount, const float* colors, size_t colCount,
+    const double minA[3], const double maxA[3]) {
+    size_t atomCount = posCount / 3;
+    bool isVec4 = (colCount == atomCount * 4);
+    size_t posBytes = posCount * sizeof(float);
+    size_t colBytes = colCount * sizeof(float);
+
+    char json[2048];
+    int jsonLen = snprintf(json, sizeof(json),
+        R"({"asset":{"version":"2.0","generator":"Volt Native"},"scene":0,"scenes":[{"nodes":[0]}],"nodes":[{"mesh":0,"name":"Atoms"}],"meshes":[{"primitives":[{"attributes":{"POSITION":0,"COLOR_0":1},"mode":0}],"name":"AtomCloud"}],"accessors":[{"bufferView":0,"componentType":5126,"count":%zu,"type":"VEC3","min":[%.6f,%.6f,%.6f],"max":[%.6f,%.6f,%.6f]},{"bufferView":1,"componentType":5126,"count":%zu,"type":"%s"}],"bufferViews":[{"buffer":0,"byteOffset":0,"byteLength":%zu,"target":34962},{"buffer":0,"byteOffset":%zu,"byteLength":%zu,"target":34962}],"buffers":[{"byteLength":%zu}]})",
+        atomCount, minA[0], minA[1], minA[2], maxA[0], maxA[1], maxA[2],
+        atomCount, isVec4 ? "VEC4" : "VEC3", posBytes, posBytes, colBytes, posBytes + colBytes);
+
+    std::vector<uint8_t> bin(posBytes + colBytes);
+    memcpy(bin.data(), positions, posBytes);
+    memcpy(bin.data() + posBytes, colors, colBytes);
+    return assemble_glb(json, jsonLen, bin.data(), bin.size());
+}
+
+struct Material {
+    double baseColor[4] = {1, 1, 1, 1};
+    double metallic = 0;
+    double roughness = 1;
+    double emissive[3] = {0, 0, 0};
+    bool doubleSided = true;
+};
+
+// Indexed triangle mesh with normals, optional VEC4 colors, and a PBR material.
+// Indices are uint32 (SCALAR componentType 5125).
+static inline std::vector<uint8_t> generate_mesh_glb(
+    const float* positions, size_t posCount, const float* normals, size_t normCount,
+    const uint32_t* indices, size_t idxCount, const float* colors, size_t colCount,
+    const double bounds[6], const Material& mat) {
+    size_t vertexCount = posCount / 3;
+    bool hasColors = (colors != nullptr && colCount > 0);
+
+    size_t posBytes = posCount * sizeof(float);
+    size_t normBytes = normCount * sizeof(float);
+    size_t colBytes = hasColors ? colCount * sizeof(float) : 0;
+    size_t idxBytes = idxCount * sizeof(uint32_t);
+    size_t binTotal = posBytes + normBytes + colBytes + idxBytes;
+
+    const char* ds = mat.doubleSided ? "true" : "false";
+    char json[8192];
+    int jsonLen;
+    if (hasColors) {
+        jsonLen = snprintf(json, sizeof(json),
+            R"({"asset":{"version":"2.0","generator":"Volt Native"},"scene":0,"scenes":[{"nodes":[0]}],"nodes":[{"mesh":0,"name":"Mesh"}],"materials":[{"pbrMetallicRoughness":{"baseColorFactor":[%.4f,%.4f,%.4f,%.4f],"metallicFactor":%.4f,"roughnessFactor":%.4f},"emissiveFactor":[%.4f,%.4f,%.4f],"doubleSided":%s}],"meshes":[{"primitives":[{"attributes":{"POSITION":0,"NORMAL":1,"COLOR_0":2},"indices":3,"material":0,"mode":4}],"name":"MeshGeometry"}],"accessors":[{"bufferView":0,"componentType":5126,"count":%zu,"type":"VEC3","min":[%.6f,%.6f,%.6f],"max":[%.6f,%.6f,%.6f]},{"bufferView":1,"componentType":5126,"count":%zu,"type":"VEC3"},{"bufferView":2,"componentType":5126,"count":%zu,"type":"VEC4"},{"bufferView":3,"componentType":5125,"count":%zu,"type":"SCALAR"}],"bufferViews":[{"buffer":0,"byteOffset":0,"byteLength":%zu,"target":34962},{"buffer":0,"byteOffset":%zu,"byteLength":%zu,"target":34962},{"buffer":0,"byteOffset":%zu,"byteLength":%zu,"target":34962},{"buffer":0,"byteOffset":%zu,"byteLength":%zu,"target":34963}],"buffers":[{"byteLength":%zu}]})",
+            mat.baseColor[0], mat.baseColor[1], mat.baseColor[2], mat.baseColor[3], mat.metallic, mat.roughness,
+            mat.emissive[0], mat.emissive[1], mat.emissive[2], ds,
+            vertexCount, bounds[0], bounds[1], bounds[2], bounds[3], bounds[4], bounds[5],
+            vertexCount, vertexCount, idxCount,
+            posBytes, posBytes, normBytes, posBytes + normBytes, colBytes, posBytes + normBytes + colBytes, idxBytes, binTotal);
+    } else {
+        jsonLen = snprintf(json, sizeof(json),
+            R"({"asset":{"version":"2.0","generator":"Volt Native"},"scene":0,"scenes":[{"nodes":[0]}],"nodes":[{"mesh":0,"name":"Mesh"}],"materials":[{"pbrMetallicRoughness":{"baseColorFactor":[%.4f,%.4f,%.4f,%.4f],"metallicFactor":%.4f,"roughnessFactor":%.4f},"emissiveFactor":[%.4f,%.4f,%.4f],"doubleSided":%s}],"meshes":[{"primitives":[{"attributes":{"POSITION":0,"NORMAL":1},"indices":2,"material":0,"mode":4}],"name":"MeshGeometry"}],"accessors":[{"bufferView":0,"componentType":5126,"count":%zu,"type":"VEC3","min":[%.6f,%.6f,%.6f],"max":[%.6f,%.6f,%.6f]},{"bufferView":1,"componentType":5126,"count":%zu,"type":"VEC3"},{"bufferView":2,"componentType":5125,"count":%zu,"type":"SCALAR"}],"bufferViews":[{"buffer":0,"byteOffset":0,"byteLength":%zu,"target":34962},{"buffer":0,"byteOffset":%zu,"byteLength":%zu,"target":34962},{"buffer":0,"byteOffset":%zu,"byteLength":%zu,"target":34963}],"buffers":[{"byteLength":%zu}]})",
+            mat.baseColor[0], mat.baseColor[1], mat.baseColor[2], mat.baseColor[3], mat.metallic, mat.roughness,
+            mat.emissive[0], mat.emissive[1], mat.emissive[2], ds,
+            vertexCount, bounds[0], bounds[1], bounds[2], bounds[3], bounds[4], bounds[5],
+            vertexCount, idxCount,
+            posBytes, posBytes, normBytes, posBytes + normBytes, idxBytes, binTotal);
+    }
+
+    std::vector<uint8_t> bin(binTotal);
+    uint8_t* p = bin.data();
+    memcpy(p, positions, posBytes); p += posBytes;
+    memcpy(p, normals, normBytes); p += normBytes;
+    if (hasColors) { memcpy(p, colors, colBytes); p += colBytes; }
+    memcpy(p, indices, idxBytes);
+    return assemble_glb(json, jsonLen, bin.data(), bin.size());
+}
+
+}  // namespace glbcore

volt_spatial_assembler-1.0.1/src/glb_python.cpp

@@ -0,0 +1,80 @@
+// Python (pybind11) binding over the shared glb_core.h. Mirrors the Node addon
+// using the same C++ encoders, so there is one source of truth for GLB output.
+#include <pybind11/pybind11.h>
+
+#include <cstdint>
+#include <vector>
+
+#include "glb_core.h"
+
+namespace py = pybind11;
+
+static const uint8_t* buf_bytes(const py::buffer& b, size_t& nbytes) {
+    py::buffer_info info = b.request();
+    nbytes = static_cast<size_t>(info.size) * static_cast<size_t>(info.itemsize);
+    return reinterpret_cast<const uint8_t*>(info.ptr);
+}
+
+static void read_doubles(const py::sequence& s, double* out, size_t n) {
+    if (static_cast<size_t>(py::len(s)) < n) throw py::value_error("sequence too short");
+    for (size_t i = 0; i < n; i++) out[i] = py::cast<double>(s[i]);
+}
+
+static py::bytes to_bytes(const std::vector<uint8_t>& v) {
+    return py::bytes(reinterpret_cast<const char*>(v.data()), v.size());
+}
+
+static py::bytes atom_glb(py::buffer positions, py::buffer types, py::sequence vmin, py::sequence vmax) {
+    size_t pb, tb;
+    const float* pos = reinterpret_cast<const float*>(buf_bytes(positions, pb));
+    const uint16_t* typ = reinterpret_cast<const uint16_t*>(buf_bytes(types, tb));
+    double mn[3], mx[3];
+    read_doubles(vmin, mn, 3);
+    read_doubles(vmax, mx, 3);
+    return to_bytes(glbcore::generate_atom_glb(pos, (pb / 4) / 3, typ, mn, mx));
+}
+
+static py::bytes point_cloud_glb(py::buffer positions, py::buffer colors, py::sequence vmin, py::sequence vmax) {
+    size_t pb, cb;
+    const float* pos = reinterpret_cast<const float*>(buf_bytes(positions, pb));
+    const float* col = reinterpret_cast<const float*>(buf_bytes(colors, cb));
+    double mn[3], mx[3];
+    read_doubles(vmin, mn, 3);
+    read_doubles(vmax, mx, 3);
+    return to_bytes(glbcore::generate_point_cloud_glb(pos, pb / 4, col, cb / 4, mn, mx));
+}
+
+static py::bytes mesh_glb(py::buffer positions, py::buffer normals, py::buffer indices,
+                          py::sequence bounds, py::sequence base_color, double metallic, double roughness,
+                          py::sequence emissive, bool double_sided, py::object colors) {
+    size_t pb, nb, ib;
+    const float* pos = reinterpret_cast<const float*>(buf_bytes(positions, pb));
+    const float* nor = reinterpret_cast<const float*>(buf_bytes(normals, nb));
+    const uint32_t* idx = reinterpret_cast<const uint32_t*>(buf_bytes(indices, ib));
+
+    const float* col = nullptr;
+    size_t cb = 0;
+    if (!colors.is_none()) {
+        col = reinterpret_cast<const float*>(buf_bytes(py::cast<py::buffer>(colors), cb));
+    }
+
+    double bnd[6];
+    read_doubles(bounds, bnd, 6);
+    glbcore::Material mat;
+    read_doubles(base_color, mat.baseColor, 4);
+    read_doubles(emissive, mat.emissive, 3);
+    mat.metallic = metallic;
+    mat.roughness = roughness;
+    mat.doubleSided = double_sided;
+
+    return to_bytes(glbcore::generate_mesh_glb(pos, pb / 4, nor, nb / 4, idx, ib / 4, col, cb / 4, bnd, mat));
+}
+
+PYBIND11_MODULE(_spatial_assembler, m) {
+    m.doc() = "Native GLB assembler (shared C++ core with the Node addon).";
+    m.def("atom_glb", &atom_glb, py::arg("positions"), py::arg("types"), py::arg("vmin"), py::arg("vmax"));
+    m.def("point_cloud_glb", &point_cloud_glb, py::arg("positions"), py::arg("colors"), py::arg("vmin"), py::arg("vmax"));
+    m.def("mesh_glb", &mesh_glb, py::arg("positions"), py::arg("normals"), py::arg("indices"), py::arg("bounds"),
+          py::arg("base_color"), py::arg("metallic"), py::arg("roughness"), py::arg("emissive"),
+          py::arg("double_sided"), py::arg("colors") = py::none());
+}

volt_spatial_assembler-1.0.1/volt_spatial_assembler/__init__.py

@@ -0,0 +1,5 @@
+"""Native GLB assembler for Volt — thin Python surface over the shared C++ core."""
+
+from ._spatial_assembler import atom_glb, mesh_glb, point_cloud_glb
+
+__all__ = ['atom_glb', 'mesh_glb', 'point_cloud_glb']

volt_spatial_assembler-1.0.1/volt_spatial_assembler.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: volt-spatial-assembler
+Version: 1.0.1
+Summary: Native GLB assembler for Volt (shared C++ core with the Node addon).
+License-Expression: MIT
+Requires-Python: >=3.10
+License-File: LICENSE
+Dynamic: license-file

volt_spatial_assembler-1.0.1/volt_spatial_assembler.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+MANIFEST.in
+pyproject.toml
+setup.py
+src/glb_core.h
+src/glb_python.cpp
+volt_spatial_assembler/__init__.py
+volt_spatial_assembler.egg-info/PKG-INFO
+volt_spatial_assembler.egg-info/SOURCES.txt
+volt_spatial_assembler.egg-info/dependency_links.txt
+volt_spatial_assembler.egg-info/top_level.txt

volt_spatial_assembler-1.0.1/volt_spatial_assembler.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

volt_spatial_assembler-1.0.1/volt_spatial_assembler.egg-info/top_level.txt

@@ -0,0 +1 @@
+volt_spatial_assembler