@manycore/aholo-splat-transform 1.2.7 → 1.2.9

package/dist/utils/voxel/binary.d.ts

@@ -0,0 +1,8 @@
+export type VoxelNodeEncoding = 'raw' | 'compact';
+export interface DecodedVoxelBinary {
+    nodes: Uint32Array;
+    leafData: Uint32Array;
+}
+export declare function encodeRawVoxelBinary(nodes: Uint32Array, leafData: Uint32Array): Uint8Array;
+export declare function encodeCompactVoxelBinary(nodes: Uint32Array, leafData: Uint32Array, numInteriorNodes: number, numMixedLeaves: number): Uint8Array;
+export declare function decodeCompactVoxelBinary(binary: Uint8Array): DecodedVoxelBinary;

package/dist/utils/voxel/binary.js

@@ -0,0 +1,176 @@
+const SOLID_LEAF_MARKER = 0xff000000 >>> 0;
+const COMPACT_MAGIC = 0x31424356; // "VCB1" little-endian
+const COMPACT_VERSION = 1;
+const HEADER_UINT32_COUNT = 8;
+const HEADER_BYTES = HEADER_UINT32_COUNT * 4;
+const TAG_MIXED = 0;
+const TAG_SOLID = 1;
+const TAG_INTERNAL = 2;
+function popcount(n) {
+    n >>>= 0;
+    n -= (n >>> 1) & 0x55555555;
+    n = (n & 0x33333333) + ((n >>> 2) & 0x33333333);
+    return (((n + (n >>> 4)) & 0x0f0f0f0f) * 0x01010101) >>> 24;
+}
+function getTagByteLength(nodeCount) {
+    return Math.ceil(nodeCount / 4);
+}
+function align4(value) {
+    return (value + 3) & ~3;
+}
+function writeTag(tags, index, tag) {
+    const shift = (index & 3) << 1;
+    tags[index >> 2] = (tags[index >> 2] & ~(0x3 << shift)) | ((tag & 0x3) << shift);
+}
+function readTag(tags, index) {
+    const shift = (index & 3) << 1;
+    return (tags[index >> 2] >>> shift) & 0x3;
+}
+function toUint8Array(data) {
+    return data.byteOffset === 0 && data.byteLength === data.buffer.byteLength
+        ? data
+        : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+}
+export function encodeRawVoxelBinary(nodes, leafData) {
+    const binary = new Uint8Array((nodes.length + leafData.length) * 4);
+    const view = new Uint32Array(binary.buffer);
+    view.set(nodes, 0);
+    view.set(leafData, nodes.length);
+    return binary;
+}
+export function encodeCompactVoxelBinary(nodes, leafData, numInteriorNodes, numMixedLeaves) {
+    const nodeCount = nodes.length;
+    const tagBytes = getTagByteLength(nodeCount);
+    const tags = new Uint8Array(tagBytes);
+    const childMasks = new Uint8Array(numInteriorNodes);
+    let interiorCursor = 0;
+    let mixedCursor = 0;
+    for (let i = 0; i < nodeCount; i++) {
+        const node = nodes[i] >>> 0;
+        if (node === SOLID_LEAF_MARKER) {
+            writeTag(tags, i, TAG_SOLID);
+            continue;
+        }
+        const childMask = node >>> 24;
+        if (childMask === 0) {
+            const leafDataIndex = node & 0x00ffffff;
+            if (leafDataIndex !== mixedCursor) {
+                throw new Error(`compact voxel encoding requires mixed leaf indices to be BFS-sequential: ` +
+                    `node ${i} has ${leafDataIndex}, expected ${mixedCursor}`);
+            }
+            writeTag(tags, i, TAG_MIXED);
+            mixedCursor++;
+            continue;
+        }
+        if (childMask === 0xff && (node & 0x00ffffff) === 0) {
+            throw new Error(`invalid voxel node ${i}: solid sentinel must be encoded as 0xFF000000`);
+        }
+        writeTag(tags, i, TAG_INTERNAL);
+        if (interiorCursor >= childMasks.length) {
+            throw new Error(`compact voxel encoding found more interior nodes than metadata (${numInteriorNodes})`);
+        }
+        childMasks[interiorCursor++] = childMask;
+    }
+    if (interiorCursor !== numInteriorNodes) {
+        throw new Error(`compact voxel encoding interior count mismatch: ${interiorCursor} !== ${numInteriorNodes}`);
+    }
+    if (mixedCursor !== numMixedLeaves) {
+        throw new Error(`compact voxel encoding mixed leaf count mismatch: ${mixedCursor} !== ${numMixedLeaves}`);
+    }
+    const leafBytes = toUint8Array(new Uint8Array(leafData.buffer, leafData.byteOffset, leafData.byteLength));
+    const leafOffset = align4(HEADER_BYTES + tagBytes + childMasks.byteLength);
+    const binary = new Uint8Array(leafOffset + leafBytes.byteLength);
+    const header = new DataView(binary.buffer, 0, HEADER_BYTES);
+    header.setUint32(0, COMPACT_MAGIC, true);
+    header.setUint32(4, COMPACT_VERSION, true);
+    header.setUint32(8, nodeCount, true);
+    header.setUint32(12, numInteriorNodes, true);
+    header.setUint32(16, numMixedLeaves, true);
+    header.setUint32(20, leafData.length, true);
+    header.setUint32(24, tagBytes, true);
+    header.setUint32(28, childMasks.byteLength, true);
+    binary.set(tags, HEADER_BYTES);
+    binary.set(childMasks, HEADER_BYTES + tagBytes);
+    binary.set(leafBytes, leafOffset);
+    return binary;
+}
+export function decodeCompactVoxelBinary(binary) {
+    if (binary.byteLength < HEADER_BYTES) {
+        throw new Error('compact voxel binary is too small for header');
+    }
+    const header = new DataView(binary.buffer, binary.byteOffset, HEADER_BYTES);
+    const magic = header.getUint32(0, true);
+    const version = header.getUint32(4, true);
+    if (magic !== COMPACT_MAGIC) {
+        throw new Error(`invalid compact voxel magic 0x${magic.toString(16)}`);
+    }
+    if (version !== COMPACT_VERSION) {
+        throw new Error(`unsupported compact voxel version ${version}`);
+    }
+    const nodeCount = header.getUint32(8, true);
+    const numInteriorNodes = header.getUint32(12, true);
+    const numMixedLeaves = header.getUint32(16, true);
+    const leafDataCount = header.getUint32(20, true);
+    const tagBytes = header.getUint32(24, true);
+    const childMaskBytes = header.getUint32(28, true);
+    if (tagBytes !== getTagByteLength(nodeCount)) {
+        throw new Error(`compact voxel tag byte count mismatch: ${tagBytes} !== ${getTagByteLength(nodeCount)}`);
+    }
+    if (childMaskBytes !== numInteriorNodes) {
+        throw new Error(`compact voxel child-mask byte count mismatch: ${childMaskBytes} !== ${numInteriorNodes}`);
+    }
+    const leafOffset = align4(HEADER_BYTES + tagBytes + childMaskBytes);
+    const expectedBytes = leafOffset + leafDataCount * 4;
+    if (binary.byteLength !== expectedBytes) {
+        throw new Error(`compact voxel byte length mismatch: ${binary.byteLength} !== ${expectedBytes}`);
+    }
+    const tags = new Uint8Array(binary.buffer, binary.byteOffset + HEADER_BYTES, tagBytes);
+    const childMasks = new Uint8Array(binary.buffer, binary.byteOffset + HEADER_BYTES + tagBytes, childMaskBytes);
+    const leafData = new Uint32Array(leafDataCount);
+    leafData.set(new Uint32Array(binary.buffer, binary.byteOffset + leafOffset, leafDataCount));
+    const nodes = new Uint32Array(nodeCount);
+    let levelStart = 0;
+    let levelEnd = nodeCount > 0 ? 1 : 0;
+    let childStart = levelEnd;
+    let interiorCursor = 0;
+    let mixedCursor = 0;
+    while (levelStart < levelEnd) {
+        let nextLevelEnd = childStart;
+        for (let i = levelStart; i < levelEnd; i++) {
+            const tag = readTag(tags, i);
+            if (tag === TAG_SOLID) {
+                nodes[i] = SOLID_LEAF_MARKER;
+            }
+            else if (tag === TAG_MIXED) {
+                nodes[i] = mixedCursor++;
+            }
+            else if (tag === TAG_INTERNAL) {
+                if (interiorCursor >= childMasks.length) {
+                    throw new Error('compact voxel decode exhausted child masks');
+                }
+                const childMask = childMasks[interiorCursor++];
+                nodes[i] = ((childMask << 24) | childStart) >>> 0;
+                childStart += popcount(childMask);
+                nextLevelEnd = childStart;
+                if (childStart > nodeCount) {
+                    throw new Error(`compact voxel child range exceeds node count (${childStart} > ${nodeCount})`);
+                }
+            }
+            else {
+                throw new Error(`compact voxel decode found reserved node tag ${tag} at node ${i}`);
+            }
+        }
+        levelStart = levelEnd;
+        levelEnd = nextLevelEnd;
+    }
+    if (levelEnd !== nodeCount) {
+        throw new Error(`compact voxel decode did not consume all nodes: ${levelEnd} !== ${nodeCount}`);
+    }
+    if (interiorCursor !== numInteriorNodes) {
+        throw new Error(`compact voxel decode interior count mismatch: ${interiorCursor} !== ${numInteriorNodes}`);
+    }
+    if (mixedCursor !== numMixedLeaves) {
+        throw new Error(`compact voxel decode mixed leaf count mismatch: ${mixedCursor} !== ${numMixedLeaves}`);
+    }
+    return { nodes, leafData };
+}

package/dist/utils/voxel/common.d.ts

@@ -1,162 +1,178 @@
-/** 3D Morton (Z-order) for integer block coordinates. */
-export declare const encodeMorton3: (x: number, y: number, z: number) => number;
-export declare const decodeMorton3: (m: number) => [number, number, number];
-export interface Bounds {
-    min: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    max: {
-        x: number;
-        y: number;
-        z: number;
-    };
-}
-/** Voxel leaf edge length in voxels (4³ block). */
-export declare const LEAF_SIZE = 4;
-export declare const ALPHA_THRESHOLD: number;
-export declare const alignGridBounds: (bounds: Bounds, voxelResolution: number) => Bounds;
-/** Opacity-aware AABB half-extents from scale + unit quaternion. */
-export declare const extentsFromQuatScale: (sx: number, sy: number, sz: number, qx: number, qy: number, qz: number, qw: number, opacity?: number, opacityThreshold?: number) => {
-    ex: number;
-    ey: number;
-    ez: number;
-};
-export declare class GaussianBVH {
-    private static readonly MAX_LEAF_SIZE;
-    private readonly x;
-    private readonly y;
-    private readonly z;
-    private readonly extents;
-    private readonly root;
-    constructor(x: Float32Array, y: Float32Array, z: Float32Array, extents: Float32Array);
-    queryOverlappingRaw(minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): number[];
-    queryOverlappingRawInto(minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number, output: Uint32Array, offset?: number): number;
-    private computeBounds;
-    private buildNode;
-    private queryNode;
-    private queryNodeInto;
-}
-declare const SOLID_LO: number;
-declare const SOLID_HI: number;
-/**
- * Append-only buffer for streaming voxelization results.
- * Stores (linear blockIdx, voxel mask) pairs for non-empty 4x4x4 blocks.
- *
- * Block keys are linear block indices `bx + by*nbx + bz*nbx*nby` in the
- * producer's grid coordinate system. Producers and consumers must agree on
- * the grid dimensions; the buffer itself is dimension-agnostic.
- */
-export declare class BlockMaskBuffer {
-    private solidIdx;
-    private solidCountValue;
-    private solidCap;
-    private mixedIdx;
-    private mixedCountValue;
-    private mixedCap;
-    private mixedMasks;
-    addBlock(blockIdx: number, lo: number, hi: number): void;
-    getMixedBlocks(): {
-        blockIdx: Float64Array<ArrayBufferLike>;
-        masks: Uint32Array<ArrayBufferLike>;
-    };
-    getSolidBlocks(): Float64Array<ArrayBufferLike>;
-    get count(): number;
-    get mixedCount(): number;
-    get solidCount(): number;
-    clear(): void;
-}
-declare const BLOCK_EMPTY = 0;
-declare const BLOCK_SOLID = 1;
-declare const BLOCK_MIXED = 2;
-declare const TYPE_MASK = 3;
-declare const BLOCKS_PER_WORD = 16;
-declare const EVEN_BITS: number;
-declare const readBlockType: (types: Uint32Array, blockIdx: number) => number;
-declare const writeBlockType: (types: Uint32Array, blockIdx: number, blockType: number) => void;
-declare class BlockMaskMap {
-    keys: Int32Array;
-    lo: Uint32Array;
-    hi: Uint32Array;
-    private _size;
-    private _capacity;
-    private _mask;
-    constructor(initialCapacity?: number);
-    slot(key: number): number;
-    set(key: number, loVal: number, hiVal: number): void;
-    removeAt(slot: number): void;
-    clear(): void;
-    get size(): number;
-    releaseStorage(): void;
-    clone(): BlockMaskMap;
-    private _grow;
-}
-declare class SparseVoxelGrid {
-    readonly nx: number;
-    readonly ny: number;
-    readonly nz: number;
-    readonly nbx: number;
-    readonly nby: number;
-    readonly nbz: number;
-    readonly bStride: number;
-    types: Uint32Array;
-    masks: BlockMaskMap;
-    constructor(nx: number, ny: number, nz: number);
-    getVoxel(ix: number, iy: number, iz: number): number;
-    setVoxel(ix: number, iy: number, iz: number): void;
-    orBlock(blockIdx: number, lo: number, hi: number): void;
-    clear(): void;
-    releaseStorage(): void;
-    clone(): SparseVoxelGrid;
-    cropTo(cropMinBx: number, cropMinBy: number, cropMinBz: number, cropMaxBx: number, cropMaxBy: number, cropMaxBz: number, onProgress?: (done: number, total: number) => void): SparseVoxelGrid;
-    cropToInverted(cropMinBx: number, cropMinBy: number, cropMinBz: number, cropMaxBx: number, cropMaxBy: number, cropMaxBz: number, onProgress?: (done: number, total: number) => void): SparseVoxelGrid;
-    static fromBuffer(acc: BlockMaskBuffer, nx: number, ny: number, nz: number): SparseVoxelGrid;
-    toBuffer(cropMinBx: number, cropMinBy: number, cropMinBz: number, cropMaxBx: number, cropMaxBy: number, cropMaxBz: number, defaultSolid?: boolean): BlockMaskBuffer;
-    toBufferInverted(cropMinBx: number, cropMinBy: number, cropMinBz: number, cropMaxBx: number, cropMaxBy: number, cropMaxBz: number): BlockMaskBuffer;
-    getOccupiedBlockBounds(onProgress?: (done: number, total: number) => void): {
-        minBx: number;
-        minBy: number;
-        minBz: number;
-        maxBx: number;
-        maxBy: number;
-        maxBz: number;
-    } | null;
-    getNavigableBlockBounds(onProgress?: (done: number, total: number) => void): {
-        minBx: number;
-        minBy: number;
-        minBz: number;
-        maxBx: number;
-        maxBy: number;
-        maxBz: number;
-    } | null;
-    static findNearestFreeCell(blocked: SparseVoxelGrid, seedIx: number, seedIy: number, seedIz: number, maxRadius: number): {
-        ix: number;
-        iy: number;
-        iz: number;
-    } | null;
-}
-export declare const SOLID_LEAF_MARKER: number;
-export declare const getChildOffset: (mask: number, octant: number) => number;
-interface BuildSparseOctreeOptions {
-    consumeGrid?: boolean;
-    dense?: boolean;
-}
-/**
- * Build a sparse octree from block masks using:
- * 1) mixed+solid SoA merge and Morton sort
- * 2) bottom-up level construction by parent Morton grouping
- * 3) BFS flatten to node/leafData arrays.
- */
-export declare const buildSparseOctree: (grid: SparseVoxelGrid, gridBounds: Bounds, sceneBounds: Bounds, voxelResolution: number, options?: BuildSparseOctreeOptions) => {
-    gridBounds: Bounds;
-    sceneBounds: Bounds;
-    voxelResolution: number;
-    leafSize: number;
-    treeDepth: number;
-    numInteriorNodes: number;
-    numMixedLeaves: number;
-    nodes: Uint32Array<ArrayBuffer>;
-    leafData: Uint32Array<ArrayBuffer>;
-};
-export { BLOCK_EMPTY, BLOCK_SOLID, BLOCK_MIXED, BLOCKS_PER_WORD, TYPE_MASK, EVEN_BITS, readBlockType, writeBlockType, SOLID_LO, SOLID_HI, SparseVoxelGrid };
+/** 3D Morton (Z-order) for integer block coordinates. */
+export declare function encodeMorton3(x: number, y: number, z: number): number;
+export declare function decodeMorton3(m: number): [number, number, number];
+export interface Bounds {
+    min: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    max: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+/** Voxel leaf edge length in voxels (4³ block). */
+export declare const LEAF_SIZE = 4;
+export declare const ALPHA_THRESHOLD: number;
+export declare function alignGridBounds(bounds: Bounds, voxelResolution: number): Bounds;
+/**
+ * Max linear block index (signed 32-bit): BlockMaskMap keys, worker `blockIdx >>> 0`,
+ * and types bitmap indexing. Implies types bitmap <= ceil(MAX / 16) * 4 ~= 512 MB.
+ */
+export declare const MAX_VOXEL_BLOCK_COUNT_INT32 = 2147483647;
+/** Preflight hard grid limits before voxelization allocates the types bitmap. */
+export declare function checkVoxelGridCapacity(gridBounds: Bounds, voxelResolution: number): void;
+/** Opacity-aware AABB half-extents from scale + unit quaternion. */
+export declare function extentsFromQuatScale(sx: number, sy: number, sz: number, qx: number, qy: number, qz: number, qw: number, opacity?: number, opacityThreshold?: number): {
+    ex: number;
+    ey: number;
+    ez: number;
+};
+export declare class GaussianBVH {
+    private static readonly MAX_LEAF_SIZE;
+    private readonly x;
+    private readonly y;
+    private readonly z;
+    private readonly extents;
+    private readonly root;
+    constructor(x: Float32Array, y: Float32Array, z: Float32Array, extents: Float32Array);
+    queryOverlappingRaw(minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): number[];
+    queryOverlappingRawInto(minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number, output: Uint32Array, offset?: number): number;
+    private computeBounds;
+    private buildNode;
+    private queryNode;
+    private queryNodeInto;
+}
+declare const SOLID_LO: number;
+declare const SOLID_HI: number;
+/**
+ * Append-only buffer for streaming voxelization results.
+ * Stores (linear blockIdx, voxel mask) pairs for non-empty 4x4x4 blocks.
+ *
+ * Block keys are linear block indices `bx + by*nbx + bz*nbx*nby` in the
+ * producer's grid coordinate system. Producers and consumers must agree on
+ * the grid dimensions; the buffer itself is dimension-agnostic.
+ */
+export declare class BlockMaskBuffer {
+    private solidIdx;
+    private solidCountValue;
+    private solidCap;
+    private mixedIdx;
+    private mixedCountValue;
+    private mixedCap;
+    private mixedMasks;
+    addBlock(blockIdx: number, lo: number, hi: number): void;
+    getMixedBlocks(): {
+        blockIdx: Float64Array<ArrayBufferLike>;
+        masks: Uint32Array<ArrayBufferLike>;
+    };
+    getSolidBlocks(): Float64Array<ArrayBufferLike>;
+    get count(): number;
+    get mixedCount(): number;
+    get solidCount(): number;
+    clear(): void;
+}
+declare const BLOCK_EMPTY = 0;
+declare const BLOCK_SOLID = 1;
+declare const BLOCK_MIXED = 2;
+declare const TYPE_MASK = 3;
+declare const BLOCKS_PER_WORD = 16;
+declare const EVEN_BITS: number;
+declare function readBlockType(types: Uint32Array, blockIdx: number): number;
+declare function writeBlockType(types: Uint32Array, blockIdx: number, blockType: number): void;
+declare class BlockMaskMap {
+    keys: Int32Array;
+    lo: Uint32Array;
+    hi: Uint32Array;
+    private _size;
+    private _capacity;
+    private _mask;
+    constructor(initialCapacity?: number);
+    slot(key: number): number;
+    set(key: number, loVal: number, hiVal: number): void;
+    removeAt(slot: number): void;
+    clear(): void;
+    get size(): number;
+    releaseStorage(): void;
+    clone(): BlockMaskMap;
+    private _grow;
+}
+declare class SparseVoxelGrid {
+    readonly nx: number;
+    readonly ny: number;
+    readonly nz: number;
+    readonly nbx: number;
+    readonly nby: number;
+    readonly nbz: number;
+    readonly bStride: number;
+    types: Uint32Array;
+    masks: BlockMaskMap;
+    constructor(nx: number, ny: number, nz: number);
+    getVoxel(ix: number, iy: number, iz: number): number;
+    setVoxel(ix: number, iy: number, iz: number): void;
+    orBlock(blockIdx: number, lo: number, hi: number): void;
+    clear(): void;
+    releaseStorage(): void;
+    clone(): SparseVoxelGrid;
+    cropTo(cropMinBx: number, cropMinBy: number, cropMinBz: number, cropMaxBx: number, cropMaxBy: number, cropMaxBz: number, onProgress?: (done: number, total: number) => void): SparseVoxelGrid;
+    cropToInverted(cropMinBx: number, cropMinBy: number, cropMinBz: number, cropMaxBx: number, cropMaxBy: number, cropMaxBz: number, onProgress?: (done: number, total: number) => void): SparseVoxelGrid;
+    static fromBuffer(acc: BlockMaskBuffer, nx: number, ny: number, nz: number): SparseVoxelGrid;
+    toBuffer(cropMinBx: number, cropMinBy: number, cropMinBz: number, cropMaxBx: number, cropMaxBy: number, cropMaxBz: number, defaultSolid?: boolean): BlockMaskBuffer;
+    toBufferInverted(cropMinBx: number, cropMinBy: number, cropMinBz: number, cropMaxBx: number, cropMaxBy: number, cropMaxBz: number): BlockMaskBuffer;
+    getOccupiedBlockBounds(onProgress?: (done: number, total: number) => void): {
+        minBx: number;
+        minBy: number;
+        minBz: number;
+        maxBx: number;
+        maxBy: number;
+        maxBz: number;
+    } | null;
+    getNavigableBlockBounds(onProgress?: (done: number, total: number) => void): {
+        minBx: number;
+        minBy: number;
+        minBz: number;
+        maxBx: number;
+        maxBy: number;
+        maxBz: number;
+    } | null;
+    static findNearestFreeCell(blocked: SparseVoxelGrid, seedIx: number, seedIy: number, seedIz: number, maxRadius: number): {
+        ix: number;
+        iy: number;
+        iz: number;
+    } | null;
+}
+export declare const SOLID_LEAF_MARKER: number;
+export declare const MAX_24BIT_OFFSET = 16777215;
+export declare class SparseOctree24BitOverflowError extends Error {
+    kind: 'node' | 'mixed-leaf';
+    actual: number;
+    limit: number;
+    voxelResolution?: number;
+    constructor(kind: 'node' | 'mixed-leaf', actual: number, limit: number);
+}
+export interface SparseOctree {
+    gridBounds: Bounds;
+    sceneBounds: Bounds;
+    voxelResolution: number;
+    leafSize: number;
+    treeDepth: number;
+    numInteriorNodes: number;
+    numMixedLeaves: number;
+    nodes: Uint32Array;
+    leafData: Uint32Array;
+}
+export declare function getChildOffset(mask: number, octant: number): number;
+interface BuildSparseOctreeOptions {
+    consumeGrid?: boolean;
+    dense?: boolean;
+}
+/**
+ * Build a sparse octree from block masks using:
+ * 1) mixed+solid SoA merge and Morton sort
+ * 2) bottom-up level construction by parent Morton grouping
+ * 3) BFS flatten to node/leafData arrays.
+ */
+export declare function buildSparseOctree(grid: SparseVoxelGrid, gridBounds: Bounds, sceneBounds: Bounds, voxelResolution: number, options?: BuildSparseOctreeOptions): SparseOctree;
+export { BLOCK_EMPTY, BLOCK_SOLID, BLOCK_MIXED, BLOCKS_PER_WORD, TYPE_MASK, EVEN_BITS, readBlockType, writeBlockType, SOLID_LO, SOLID_HI, SparseVoxelGrid, };