@volter/blender-engine 0.1.55 → 0.1.57

package/browser/three/blender-frame-columns.ts

@@ -79,6 +79,8 @@ export const ATTRIBUTE_LAYOUT: Record<AttributeType, { size: number }> = {
 export interface MeshColumns {
   /** 3 * nv */
   co: Float32Array | Float64Array;
+  /** Blender's tessellation, triangle corner indices in face order. */
+  cornerTri?: Uint32Array | undefined;
   /** Blender-evaluated normals, 3 per corner, independent of UV splits. */
   cornerNormal?: Float32Array | undefined;
   /** 3 * nv, a deformed mesh's Generated coordinates in Blender's stored

package/browser/three/blender-runtime-geometry.ts

@@ -313,8 +313,113 @@ export function geometryFromDrawArrays(
   return geometry;
 }
 
+/** Blender already supplied corner normals and triangulation. Read those
+ * columns directly: no polygon triangulation, adjacency graph, vector objects
+ * or stringified floating-point keys. Two passes size final buffers exactly. */
+function drawNativeColumns(c: MeshColumns, hash: string): DrawArrays {
+  const triangles = c.cornerTri!, normal = c.cornerNormal!;
+  const nv = c.co.length / 3, nc = c.corner.length, nf = c.faceStart.length - 1;
+  const maps = c.attributes.filter(a => a.type === 'FLOAT2' && a.domain === 'CORNER');
+  const mapName = c.renderUv ?? c.activeUv ?? maps[0]?.name;
+  const activeMap = maps.findIndex(a => a.name === mapName);
+  if (mapName && activeMap < 0) throw new Error(`Runtime UV map ${mapName} is missing`);
+  const attributes = graphAttributeLayers(c.attributes, data => data as ArrayLike<number>);
+  const width = 3 + maps.length * 2 + attributes.length * 4;
+  const scratch = new Float32Array(width), comparison = new Float32Array(width);
+  const bits = new Uint32Array(scratch.buffer), comparisonBits = new Uint32Array(comparison.buffer);
+  const faces = new Uint32Array(nc), cornerIndex = new Uint32Array(nc);
+  const representative = new Uint32Array(nc), links = new Uint32Array(nc);
+  const used = new Uint8Array(nv);
+  let tableSize = 1;
+  while (tableSize < Math.max(1, nc * 2)) tableSize *= 2;
+  const buckets = new Uint32Array(tableSize);
+  const read = (corner: number, face: number, vertex: number, target: Float32Array): void => {
+    let offset = 0;
+    for (let k = 0; k < 3; k++) target[offset++] = normal[corner * 3 + k]!;
+    for (const map of maps) for (let k = 0; k < 2; k++) target[offset++] = Number(map.data[corner * 2 + k]);
+    for (const layer of attributes) {
+      const value = layer.read(vertex, corner, face);
+      for (let k = 0; k < 4; k++) target[offset++] = Number(value[k]);
+    }
+  };
+  let count = 0;
+  for (let face = 0; face < nf; face++) {
+    for (let corner = c.faceStart[face]!; corner < c.faceStart[face + 1]!; corner++) {
+      const vertex = c.corner[corner]!;
+      if (vertex >= nv) throw new Error('Native mesh corner references a missing vertex');
+      faces[corner] = face; used[vertex] = 1;
+      read(corner, face, vertex, scratch);
+      let digest = Math.imul(vertex ^ 2166136261, 16777619);
+      for (const word of bits) digest = Math.imul(digest ^ word, 16777619);
+      const bucket = (digest >>> 0) & (tableSize - 1);
+      let found = -1;
+      for (let entry = buckets[bucket]!; entry; entry = links[entry - 1]!) {
+        const index = entry - 1, previous = representative[index]!;
+        if (c.corner[previous] !== vertex) continue;
+        read(previous, faces[previous]!, vertex, comparison);
+        let equal = true;
+        for (let k = 0; k < width; k++) if (bits[k] !== comparisonBits[k]) { equal = false; break; }
+        if (equal) { found = index; break; }
+      }
+      if (found < 0) {
+        found = count++; representative[found] = corner;
+        links[found] = buckets[bucket]!; buckets[bucket] = found + 1;
+      }
+      cornerIndex[corner] = found;
+    }
+  }
+  let loose = 0; for (const flag of used) if (!flag) loose++;
+  const total = count + loose;
+  const positions = new Float32Array(total * 3), normals = new Float32Array(total * 3);
+  const sourceVertex = new Uint32Array(total);
+  const uvLayers = maps.map(map => ({ name: map.name, data: new Float32Array(total * 2) }));
+  const attributeLayers = attributes.map(layer => ({ name: layer.name, data: new Float32Array(total * 4) }));
+  const orco = c.orco ? new Float32Array(total * 3) : null;
+  const position = (index: number, vertex: number): void => {
+    sourceVertex[index] = vertex;
+    for (let k = 0; k < 3; k++) {
+      positions[index * 3 + k] = c.co[vertex * 3 + k]!;
+      if (orco) orco[index * 3 + k] = c.orco![vertex * 3 + k]! * 0.5 + 0.5;
+    }
+  };
+  for (let index = 0; index < count; index++) {
+    const corner = representative[index]!, vertex = c.corner[corner]!;
+    position(index, vertex); read(corner, faces[corner]!, vertex, scratch);
+    normals.set(scratch.subarray(0, 3), index * 3);
+    let offset = 3;
+    for (const layer of uvLayers) { layer.data.set(scratch.subarray(offset, offset + 2), index * 2); offset += 2; }
+    for (const layer of attributeLayers) { layer.data.set(scratch.subarray(offset, offset + 4), index * 4); offset += 4; }
+  }
+  let index = count;
+  for (let vertex = 0; vertex < nv; vertex++) if (!used[vertex]) {
+    position(index, vertex);
+    for (let layer = 0; layer < attributes.length; layer++) attributeLayers[layer]!.data.set(attributes[layer]!.read(vertex, undefined, undefined), index * 4);
+    index++;
+  }
+  const indices = new Uint32Array(triangles.length), groups: DrawArrays['groups'] = [];
+  let offset = 0;
+  for (let face = 0; face < nf; face++) {
+    const start = c.faceStart[face]!, end = c.faceStart[face + 1]!;
+    const length = Math.max(0, end - start - 2) * 3;
+    if (offset + length > triangles.length) throw new Error('Native mesh triangulation is incomplete');
+    for (let j = 0; j < length; j++) {
+      const corner = triangles[offset + j]!;
+      if (corner < start || corner >= end) throw new Error('Native triangle references a different face');
+      indices[offset + j] = cornerIndex[corner]!;
+    }
+    const materialIndex = c.material[face]!, previous = groups.at(-1);
+    if (previous?.materialIndex === materialIndex) previous.count += length;
+    else groups.push({ start: offset, count: length, materialIndex });
+    offset += length;
+  }
+  if (offset !== triangles.length) throw new Error('Native mesh triangulation has extra triangles');
+  return { positions, normals, sourceVertex, uv: activeMap < 0 ? null : uvLayers[activeMap]!.data,
+    uvLayers, attributeLayers, orco, indices, groups, hash };
+}
+
 /** The worker's door: the mesh store's columns, drawn into buffers. */
 export function drawArraysFromColumns(c: MeshColumns, hash: string): DrawArrays {
+  if (c.cornerTri && c.cornerNormal) return drawNativeColumns(c, hash);
   const nv = c.co.length / 3;
   const maps = c.attributes.filter((a) => a.type === 'FLOAT2' && a.domain === 'CORNER');
   const mapName = c.renderUv ?? c.activeUv ?? maps[0]?.name;

package/browser/three/blender-runtime-view.ts

@@ -186,6 +186,7 @@ const columnsSchema = z
   .object({
     co: z.union([z.instanceof(Float32Array), z.instanceof(Float64Array)]),
     cornerNormal: z.instanceof(Float32Array).optional(),
+    cornerTri: z.instanceof(Uint32Array).optional(),
     orco: z.instanceof(Float32Array).optional(),
     faceStart: z.instanceof(Uint32Array),
     corner: z.instanceof(Uint32Array),

package/package.json

@@ -2,7 +2,7 @@
   "name": "@volter/blender-engine",
   "author": "Volter AI, Inc.",
   "license": "GPL-3.0-or-later",
-  "version": "0.1.55",
+  "version": "0.1.57",
   "publishConfig": {
     "access": "public"
   },

package/wasm/BUNDLE.json

@@ -1,10 +1,9 @@
 {
   "blender": "5.2.0 LTS",
-  "source": "e5d7eec67572dfc7c73f8f4d3f601d03442546f9",
-  "reviewedSource": "e5d7eec67572dfc7c73f8f4d3f601d03442546f9",
+  "source": "54e4af619a285c6d76c56ef960dc99d45aca5084",
   "upstream": "fbe6228777e7d9afefcd61a413844e790ae75db7",
   "sourceRepository": "https://github.com/volter-ai/blender",
-  "sourceRecipe": "https://github.com/volter-ai/blender/blob/e5d7eec67572dfc7c73f8f4d3f601d03442546f9/build_files/emscripten/RELEASE.md",
+  "sourceRecipe": "https://github.com/volter-ai/blender/blob/54e4af619a285c6d76c56ef960dc99d45aca5084/build_files/emscripten/RELEASE.md",
   "factoryEngine": "BLENDER_EEVEE",
   "files": {
     "blender_browser.js": "raw",
@@ -17,8 +16,8 @@
       "sha256": "0c63c29e7d4b1ba1fce4e94057778b0757767b25ea4f6f01d329e99351568f30"
     },
     "blender_browser.wasm": {
-      "bytes": 86317655,
-      "sha256": "0ba94ac8388de893bcec4da70516aea69128addaa490ef27f17ca06262ee6546"
+      "bytes": 86332914,
+      "sha256": "15c4b7072ebc655418849da79a6fefed8bff26774e7446ade8d3a54bd6ad7a61"
     },
     "blender_browser.data": {
       "bytes": 52698568,
@@ -31,8 +30,8 @@
       "sha256": "0c63c29e7d4b1ba1fce4e94057778b0757767b25ea4f6f01d329e99351568f30"
     },
     "blender_browser.wasm.br": {
-      "bytes": 18596913,
-      "sha256": "64af23954e1911ffcb879f69a9e8c9bbd83b5531939b586228f44fcea8211e3b"
+      "bytes": 18601239,
+      "sha256": "8cd29a87fcce046c292c52cc62523fe0ebbd1db8f05b19503d56311ae12c84c5"
     },
     "blender_browser.data.br": {
       "bytes": 8056563,
@@ -43,9 +42,9 @@
       "sha256": "4085e9336266cf66f061d4d5c962a5929cc96d5732c746b5c13ea05cd104a75b"
     }
   },
-  "note": "Unreleased Stoneguard candidate. Clean source build at the named commit; Release -O3 objects and -O2 link, Emscripten 6.0.5. Focused geometry regression matches shipped engine across original, vertex edit and subdivision-level edit. Full historical battery is absent from current editor checkout; no full-battery claim.",
+  "note": "Stoneguard c7/c14/c15 engine. Emscripten 6.0.5, Release -O3 objects and -O2 link. Portable native arm64 matrix reciprocal plus fused generic OpenSubdiv stencil and patch accumulation; bodice four-stage comparison 28/28 arrays exact. Full-scene comparison and memory scope recorded in provenance/stoneguard-memory.json. Historical battery absent; no full-battery or hosted acceptance claim.",
   "callTrampoline": "CPython 3.13.13 is compiled with PY_CALL_TRAMPOLINE for Blender CPython slot arity casts. This applies to CPython dispatch, not arbitrary indirect calls.",
   "engineIds": "The existing session registers Python render engines under CYCLES, BLENDER_EEVEE and BLENDER_WORKBENCH; the headless build permits built-in IDs to be shadowed.",
-  "exportDoor": "The source-owned bpy_web_export.cc exports Principled physical inputs, normal images, eight named UV layers and evaluated corner normals, and takes graph_materials/graph_images/graph_generated (a graph-drawn shader mix reduced to the one Principled BSDF it reaches, graph images at the door revisions with every UDIM tile, orco for deformed meshes whose graph reads Generated coordinates). A frame can defer its changed meshes and pictures (defer) for the caller to pull one at a time (export_mesh, export_image), each call freeing the previous one's columns and a picture it decoded; an undo step keeps the revisions when Blender kept the depsgraph (session_undo); Blender's CPU subdivision descriptor is released once a mesh is read; the memory door reports malloc in-use and free. Datablock revisions are keyed by session_uid. writefile.cc writes one copy of the document per save in the browser build. CPU evaluators adopt stencil tables without cloning; browser subdivision descriptors are released immediately after CPU tessellation/deformation.",
+  "exportDoor": "The source-owned bpy_web_export.cc exports Principled physical inputs, normal images, eight named UV layers and evaluated corner normals, and takes graph_materials/graph_images/graph_generated (a graph-drawn shader mix reduced to the one Principled BSDF it reaches, graph images at the door revisions with every UDIM tile, orco for deformed meshes whose graph reads Generated coordinates). A frame can defer its changed meshes and pictures (defer) for the caller to pull one at a time (export_mesh, export_image), each call freeing the previous one's columns and a picture it decoded; an undo step keeps the revisions when Blender kept the depsgraph (session_undo); Blender's CPU subdivision descriptor is released once a mesh is read; the memory door reports malloc in-use and free. Datablock revisions are keyed by session_uid. writefile.cc writes one copy of the document per save in the browser build. CPU evaluators adopt stencil tables without cloning; browser subdivision descriptors are released immediately after CPU tessellation/deformation. Native evaluated corner triangles accompany corner normals. Consumed local conversion stencils are released before later UV channels are constructed.",
   "preloadedPayload": "releasePreloadedFileData releases the JS preload buffer after session ready. The measured working payload exclusions are retained."
 }