ldr 0.33.12 → 0.33.13

package/dist/render.d.ts

@@ -70,11 +70,26 @@ export declare function conditionalLineVisible(cond: ArrayLike<number>, i: numbe
  *  `cond` is part-space stride 12 (p0, p1, c0, c1), e.g. from `conditionalLines(pack, pack.header.parts[name])`.
  *  GPU cost: 2 vertices x 13 floats per line (104 B/line), per part, not per instance. Keep `geometry.instanceCount` in sync with `im.count`. */
 export declare function createInstancedConditionalEdges(cond: ArrayLike<number>, im: THREE.InstancedMesh, material?: THREE.Material): THREE.LineSegments;
+/** Running state of `instancedBoundingSphere`: [centre x, y, z, radius (-1 = empty), geometry sphere centre x, y, z, radius]. */
+export declare function sphereState(g: THREE.BufferGeometry): Float64Array<ArrayBuffer>;
+/** Union the first `n` instance slots of `A` (16 floats each, as `setMatrixAt` stores them) into sphere state `S`, in order: three's
+ *  loop, same arithmetic (a scratch slot of hidden studs / undersides goes through it with n = 1). */
+export declare function sphereUnion(S: Float64Array, A: Float32Array, n: number): void;
+/** Set `im.boundingSphere` from a sphere state. */
+export declare function setSphere(im: THREE.InstancedMesh, S: Float64Array): THREE.Sphere;
 /** InstancedMesh.computeBoundingSphere() (three r151-r186), ported to a loop over the instance array: same arithmetic, same result
- *  bit for bit, without a Matrix4 copy + Sphere clone per instance (1.8M studs on Datsville 100k). */
-export declare function instancedBoundingSphere(im: THREE.InstancedMesh): THREE.Sphere;
+ *  bit for bit, without a Matrix4 copy + Sphere clone per instance (1.8M studs on Datsville 100k). With `S`, continues that state
+ *  (Round 74: the culled-away slots that are never stored are unioned in afterwards, see `sphereUnion`). */
+export declare function instancedBoundingSphere(im: THREE.InstancedMesh, S?: Float64Array<ArrayBuffer>, set?: boolean): Float64Array<ArrayBuffer> | THREE.Sphere;
 /** Axis-aligned box (min xyz, max xyz) around every instance slot of an InstancedMesh: each instance's transformed geometry box. */
 export declare function instancedBoundingBox(im: THREE.InstancedMesh): Float32Array | undefined;
+/** Running state of `instancedBoundingBox` (Round 74, for slots that are never stored, like `sphereState`): [min x y z, max x y z,
+ *  geometry box half-size x y z and centre x y z, slots unioned]; null when the geometry box is empty. */
+export declare function boxState(g: THREE.BufferGeometry): Float64Array | null;
+/** Union the first `n` instance slots of `A` into box state `B` (each slot's transformed geometry box; order-independent). */
+export declare function boxUnion(B: Float64Array, A: Float32Array, n: number): void;
+/** The box of a box state (undefined: empty geometry box or no slots). */
+export declare const boxOf: (B: Float64Array | null) => Float32Array<ArrayBuffer> | undefined;
 import { forEachStud, cullCore, STEP_NEVER, type CullResult } from './cull.js';
 export { forEachStud, cullCore, STEP_NEVER, type CullResult };
 /** Object-shaped culling result (one entry per stud with its world matrix). Kept for API compatibility; `buildLdrScene` uses `cullCore`. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ldr",
-  "version": "0.33.12",
+  "version": "0.33.13",
   "description": "High-performance LEGO (LDraw) rendering for three.js: instanced parts packs, hidden stud/tube culling, low-detail studs, indexed edges, build steps.",
   "license": "MIT",
   "author": "Evan Bacon",