@woosh/meep-engine 2.48.20 → 2.48.21

package/src/engine/graphics/micron/render/instanced/PatchDataTextures.js

@@ -1,329 +0,0 @@
-import { assert } from "../../../../../core/assert.js";
-import { BitSet } from "../../../../../core/binary/BitSet.js";
-import { AttributeDataTexture } from "../../../texture/AttributeDataTexture.js";
-import { max3 } from "../../../../../core/math/max3.js";
-import { gen_micron_vertex_attribute_texture_name } from "./shader/gen_micron_vertex_attribute_texture_name.js";
-import { min2 } from "../../../../../core/math/min2.js";
-import { MICRON_PATCH_SIZE_MAX } from "../../build/MICRON_PATCH_SIZE_MAX.js";
-
-/**
- *
- * @type {number}
- */
-const ALLOCATION_GROW_STEP = 16;
-
-/**
- *
- * @type {number}
- */
-const ALLOCATION_GROW_FACTOR = 1.2;
-
-/**
- *
- * @type {number}
- */
-const MAX_TEXTURE_SIZE = 16384;
-
-const VERTICES_PER_TRIANGLE = 3;
-const ATTRIBUTE_TEXTURE_SLOT_WIDTH =MICRON_PATCH_SIZE_MAX * VERTICES_PER_TRIANGLE;
-
-export class PatchDataTextures {
-    /**
-     *
-     * @param {VertexDataSpec} spec
-     * @param {number} [column_count]
-     */
-    constructor(spec, column_count = 2) {
-        assert.defined(spec, 'spec');
-        assert.isNonNegativeInteger(column_count, 'column_count');
-
-        /**
-         *
-         * @type {VertexDataSpec}
-         * @private
-         */
-        this.__spec = spec;
-
-        /**
-         *
-         * @type {AttributeDataTexture[]}
-         * @private
-         */
-        this.__attributes = [];
-
-        /**
-         *
-         * @type {Map<MicronGeometryPatch, number>}
-         * @private
-         */
-        this.__residence = new Map();
-
-        this.__occupied_slots = new BitSet();
-
-        this.__capacity = 0;
-
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__column_count = column_count;
-
-        // initialize attributes
-        const attributes = this.__attributes;
-        const attribute_count = spec.attributes.length;
-
-        for (let i = 0; i < attribute_count; i++) {
-            attributes[i] = new AttributeDataTexture(spec.attributes[i], this.__column_count, ATTRIBUTE_TEXTURE_SLOT_WIDTH);
-        }
-
-    }
-
-    /**
-     *
-     * @returns {VertexDataSpec}
-     */
-    get spec() {
-        return this.__spec;
-    }
-
-    /**
-     *
-     * @returns {number}
-     */
-    get column_count() {
-        return this.__column_count;
-    }
-
-    /**
-     * Clear all data
-     */
-    clear() {
-        this.__residence.clear();
-        this.__occupied_slots.reset();
-
-        const attributes = this.__attributes;
-        const attribute_count = attributes.length;
-        for (let i = 0; i < attribute_count; i++) {
-            const attribute = attributes[i];
-
-            attribute.clear();
-        }
-    }
-
-    estimateByteSize() {
-        let result = 0;
-
-        const attributes = this.__attributes;
-        const attribute_count = attributes.length;
-        for (let i = 0; i < attribute_count; i++) {
-            const attribute = attributes[i];
-
-            result += attribute.estimateByteSize();
-        }
-
-        return result;
-    }
-
-    /**
-     *
-     * @param {number} n
-     */
-    set capacity(n) {
-        // console.log(`#PatchDataTextures.capacity = ${n}`); // DEBUG
-
-        const attributes = this.__attributes;
-        const attribute_count = attributes.length;
-        for (let i = 0; i < attribute_count; i++) {
-            const attribute = attributes[i];
-
-            attribute.resize(n);
-        }
-
-        this.__capacity = n;
-    }
-
-    /**
-     *
-     * @param {number} index
-     */
-    zero_fill_slot(index) {
-        const attributes = this.__attributes;
-        const attribute_count = attributes.length;
-        for (let i = 0; i < attribute_count; i++) {
-            const attribute = attributes[i];
-
-            attribute.zero_fill_slot(index);
-        }
-    }
-
-    /**
-     *
-     * @param {MicronGeometryPatch} patch
-     * @return {boolean}
-     */
-    release(patch) {
-        const address = this.__residence.get(patch);
-
-        if (address !== undefined) {
-            this.__residence.delete(patch);
-            this.__occupied_slots.clear(address);
-
-            // zero-fill slot
-            this.zero_fill_slot(address);
-
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    /**
-     *
-     * @param {number} address
-     * @param {MicronGeometryPatch} patch
-     */
-    bind(address, patch) {
-        // console.log(`#PatchDataTextures.bind(${address}, ${patch.id})`); // DEBUG
-
-        this.__residence.set(patch, address);
-        this.__occupied_slots.set(address, true);
-    }
-
-    /**
-     *
-     * @param {number} address
-     * @param {MicronGeometryPatch} patch
-     */
-    write_data(address, patch) {
-        // console.log(`#PatchDataTextures.write_data(${address}, ${patch.id})`); // DEBUG
-
-        const indices = patch.face_indices;
-
-        const attribute_arrays = patch.vertex_attribute_arrays;
-
-        const attribute_textures = this.__attributes;
-        const attribute_count = attribute_arrays.length;
-
-        for (let i = 0; i < attribute_count; i++) {
-            const attribute_source = attribute_arrays[i];
-
-            const attribute_texture = attribute_textures[i];
-
-            attribute_texture.write_slot_from_indexed(address, indices, attribute_source);
-        }
-    }
-
-    /**
-     *
-     * @param {number} address
-     * @param {MicronGeometryPatch} patch
-     * @returns {boolean}
-     */
-    is_slot_data_equal(address, patch) {
-        const indices = patch.face_indices;
-
-        const attribute_arrays = patch.vertex_attribute_arrays;
-
-        const attribute_textures = this.__attributes;
-        const attribute_count = attribute_arrays.length;
-
-        for (let i = 0; i < attribute_count; i++) {
-            const attribute_source = attribute_arrays[i];
-
-            const attribute_texture = attribute_textures[i];
-
-            const equal = attribute_texture.is_slot_data_equal(address, indices, attribute_source);
-
-            if (!equal) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    /**
-     *
-     * @param {number} capacity
-     */
-    ensureCapacity(capacity) {
-        const existing_capacity = this.__capacity;
-
-        if (capacity > existing_capacity) {
-            let next_capacity = max3(
-                existing_capacity + ALLOCATION_GROW_STEP,
-                Math.ceil(existing_capacity * ALLOCATION_GROW_FACTOR),
-                capacity + 1
-            );
-
-            // Clamp to maximum texture size
-            next_capacity = min2(next_capacity, MAX_TEXTURE_SIZE * this.__column_count);
-
-            if (next_capacity < capacity) {
-                throw new Error(`Maximum texture size exceeded`);
-            }
-
-            this.capacity = next_capacity;
-        }
-    }
-
-    validate_contents() {
-        for (const [patch, address] of this.__residence) {
-            if (!this.is_slot_data_equal(address, patch)) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-
-    /**
-     *
-     * @param {MicronGeometryPatch} patch
-     * @returns {number}
-     */
-    ensure(patch) {
-
-        const existing_address = this.__residence.get(patch);
-
-        if (existing_address !== undefined) {
-            return existing_address;
-        }
-
-        // write
-        const address = this.__occupied_slots.nextClearBit(0);
-
-        this.ensureCapacity(address + 1);
-
-        this.bind(address, patch);
-        this.write_data(address, patch);
-
-        return address;
-    }
-
-    genUniforms() {
-        const result = {};
-
-
-        const attributes = this.__attributes;
-        const attribute_count = attributes.length;
-
-        for (let i = 0; i < attribute_count; i++) {
-            const attribute = attributes[i];
-
-            const spec = attribute.spec;
-
-            const uniform_name = gen_micron_vertex_attribute_texture_name(spec.name);
-
-            result[uniform_name] = {
-                type: 't',
-                value: attribute.texture
-            };
-        }
-
-        return result;
-    }
-
-}

package/src/engine/graphics/micron/render/instanced/ThreeInstancedAdapter.js

@@ -1,175 +0,0 @@
-import { PatchDataTextures } from "./PatchDataTextures.js";
-import {
-    BufferAttribute,
-    InstancedBufferAttribute,
-    InstancedBufferGeometry,
-    StaticReadUsage,
-    StreamDrawUsage
-} from "three";
-import { MICRON_PATCH_SIZE_MAX } from "../../build/MICRON_PATCH_SIZE_MAX.js";
-import Signal from "../../../../../core/events/signal/Signal.js";
-import { ATTRIBUTE_NAME_ADDRESS, ATTRIBUTE_NAME_TRANSFORM } from "./shader/constants.js";
-import { shader_rewrite_standard } from "./shader/shader_rewrite_standard.js";
-
-export class ThreeInstancedAdapter {
-    /**
-     *
-     * @param {VertexDataSpec} spec
-     */
-    constructor(spec) {
-        /**
-         *
-         * @type {InstancedBufferGeometry|null}
-         * @private
-         */
-        this.__buffer_geometry = null;
-
-        // build non-indexed geometry for a patch
-
-        this.__capacity = -1;
-
-        this.__spec = spec;
-
-
-        /**
-         * 10 columns come from 4096 texture resolution, that seems to be maximum widely supported resolution.
-         * Here's the math: 4096/ (3*128) = 10.6666
-         * @type {PatchDataTextures}
-         * @private
-         */
-        this.__patch_data = new PatchDataTextures(spec, 10);
-
-
-        this.__uniforms = Object.assign({}, this.__patch_data.genUniforms());
-
-        /**
-         *
-         * @type {Signal}
-         */
-        this.onRebuild = new Signal();
-    }
-
-    /**
-     *
-     * @param {{vertexShader,fragmentShader,uniforms:Object<IUniform>}} shader
-     */
-    rewriteMaterial(shader) {
-        shader_rewrite_standard(shader, this.__uniforms, this.__spec, this.__patch_data.column_count);
-    }
-
-    __build_geometry() {
-        if (this.__buffer_geometry !== null) {
-            this.__buffer_geometry.dispose();
-        }
-
-        this.__buffer_geometry = new InstancedBufferGeometry();
-
-
-        // build non-indexed geometry for a patch
-        const geo = this.__buffer_geometry;
-
-        const position_buffer = new BufferAttribute(new Uint8Array(MICRON_PATCH_SIZE_MAX * 3 * 3), 3, false);
-
-
-        position_buffer.setUsage(StaticReadUsage);
-
-        geo.setAttribute('position', position_buffer);
-        // geo.setAttribute('normal', new BufferAttribute(new Uint8Array(MICRON_PATCH_SIZE_MAX * 3 * 3), 3, false));
-
-        // instance attributes
-        const capacity = this.__capacity;
-
-        const transform_buffer = new InstancedBufferAttribute(new Float32Array(capacity * 16), 16, false);
-        // const transform_buffer = new InstancedInterleavedBuffer(this.__attribute__transform, 16);
-        transform_buffer.setUsage(StreamDrawUsage);
-
-        geo.setAttribute(ATTRIBUTE_NAME_TRANSFORM, transform_buffer);
-
-
-        const ia_patch_ref = new InstancedBufferAttribute(new Uint16Array(capacity), 1, false);
-        ia_patch_ref.setUsage(StreamDrawUsage);
-
-        geo.setAttribute(ATTRIBUTE_NAME_ADDRESS, ia_patch_ref);
-
-        // signal
-        this.onRebuild.send0();
-    }
-
-    /**
-     *
-     * @param {number} target
-     * @private
-     */
-    __resize_capacity(target) {
-        this.__capacity = target;
-        this.__build_geometry();
-    }
-
-    /**
-     *
-     * @param {number} v
-     * @private
-     */
-    __prepare_capacity(v) {
-        if (this.__capacity < v) {
-            this.__resize_capacity(v);
-        }
-
-        const geometry = this.__buffer_geometry;
-
-        if (geometry.instanceCount !== v) {
-            geometry.instanceCount = v;
-        }
-    }
-
-
-    /**
-     *
-     * @param {Uint32Array} patches
-     * @param {number} patch_count
-     * @param {VirtualGeometry} virtual_geometry
-     */
-    build(patches, patch_count, virtual_geometry) {
-        this.__prepare_capacity(patch_count);
-
-        const geo = this.__buffer_geometry;
-
-        const patch_transform_attribute = geo.attributes[ATTRIBUTE_NAME_TRANSFORM];
-        /**
-         *
-         * @type {Float32Array}
-         */
-        const patch_transform_array = patch_transform_attribute.array;
-
-        patch_transform_attribute.needsUpdate = true;
-
-        const patch_address_attribute = geo.attributes[ATTRIBUTE_NAME_ADDRESS];
-        const patch_address_array = patch_address_attribute.array;
-
-        patch_address_attribute.needsUpdate = true;
-
-        const patch_data = this.__patch_data;
-        const transforms = virtual_geometry.lookup_instance_transforms;
-        const geometries = virtual_geometry.loolup_geometries;
-
-        for (let i = 0; i < patch_count; i++) {
-            const i3 = i * 3;
-
-            const instance_id = patches[i3];
-            const geometry_id = patches[i3 + 1];
-            const patch_id = patches[i3 + 2];
-
-            const transform = transforms[instance_id];
-            const micron_geometry = geometries[geometry_id];
-            const patch = micron_geometry.patches[patch_id];
-
-            const i16 = i * 16;
-
-            patch_transform_array.set(transform, i16);
-
-            const patch_slot_id = patch_data.ensure(patch);
-
-            patch_address_array[i] = patch_slot_id;
-        }
-    }
-}

package/src/engine/graphics/micron/render/instanced/shader/constants.js

@@ -1,3 +0,0 @@
-export const ATTRIBUTE_NAME_TRANSFORM = 'micron_patch_transform';
-export const ATTRIBUTE_NAME_ADDRESS = 'micron_patch_address';
-export const ATTRIBUTE_INSTANCE_ID = 'micron_instance_id';

package/src/engine/graphics/micron/render/instanced/shader/gen_micron_vertex_attribute_texture_name.js

@@ -1,8 +0,0 @@
-/**
- *
- * @param {string} attribute_name
- * @return {string}
- */
-export function gen_micron_vertex_attribute_texture_name(attribute_name) {
-    return `micron_patch_data_vertex_attribute_${attribute_name}`;
-}