@woosh/meep-engine 2.48.20 → 2.48.21

package/src/engine/graphics/micron/render/v1/ThreeVirtualGeometryAdapter.js

@@ -1,255 +0,0 @@
-import { BufferAttribute, BufferGeometry, DynamicDrawUsage } from "three";
-import Signal from "../../../../../core/events/signal/Signal.js";
-import {
-    DataType2TypedArrayConstructorMapping
-} from "../../../../../core/binary/type/DataType2TypedArrayConstructorMapping.js";
-import { getTransformedPositionsCached } from "./getTransformedPositionsCached.js";
-import { Color } from "../../../../../core/color/Color.js";
-import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
-import { randomFloatBetween } from "../../../../../core/math/random/randomFloatBetween.js";
-
-
-const scratch_random = seededRandom(0);
-const scratch_color = new Color();
-
-export class ThreeVirtualGeometryAdapter {
-    constructor() {
-        this.buffer_geometry = new BufferGeometry();
-
-        this.__vertex_capacity = -1;
-        this.__face_capacity = -1;
-
-        /**
-         *
-         * @type {VertexDataSpec}
-         * @private
-         */
-        this.__vertex_spec = null;
-
-        /**
-         *
-         * @type {Signal}
-         */
-        this.onRebuild = new Signal();
-
-        /**
-         *
-         * @type {boolean}
-         * @private
-         */
-        this.__enable_debug_attribute_patch_vertex_color = true;
-    }
-
-    /**
-     *
-     * @param {number} vertex_count
-     * @param {number} face_count
-     */
-    resizeGeometry(vertex_count, face_count) {
-        if (this.__face_capacity < face_count || this.__vertex_capacity < vertex_count) {
-
-
-            this.rebuildBufferGeometry(vertex_count, face_count);
-        }
-        this.buffer_geometry.setDrawRange(0, face_count * 3);
-    }
-
-    /**
-     *
-     * @param {number} vertex_count
-     * @param {number} face_count
-     */
-    rebuildBufferGeometry(vertex_count, face_count) {
-
-        this.buffer_geometry.dispose();
-
-        const geometry = new BufferGeometry();
-
-        const index_buffer = new BufferAttribute(new Uint32Array(face_count * 3), 1, false);
-        index_buffer.setUsage(DynamicDrawUsage);
-        geometry.setIndex(index_buffer);
-
-        const vertexSpec = this.__vertex_spec;
-        const vertexAttributeSpecs = vertexSpec.attributes;
-
-        for (let i = 0; i < vertexAttributeSpecs.length; i++) {
-            const attribute_spec = vertexAttributeSpecs[i];
-
-            const array = new DataType2TypedArrayConstructorMapping[attribute_spec.type](vertex_count * attribute_spec.itemSize);
-
-            const attribute = new BufferAttribute(array, attribute_spec.itemSize, attribute_spec.normalized);
-            attribute.setUsage(DynamicDrawUsage);
-
-            geometry.setAttribute(attribute_spec.name, attribute);
-        }
-
-        if (this.__enable_debug_attribute_patch_vertex_color) {
-            //
-            const colors_array = new Uint8Array(vertex_count * 3);
-            geometry.setAttribute('color', new BufferAttribute(colors_array, 3, true));
-        }
-
-        this.__face_capacity = face_count;
-        this.__vertex_capacity = vertex_count;
-
-        this.buffer_geometry = geometry;
-
-        this.onRebuild.send0();
-    }
-
-
-    /**
-     *
-     * @param {VirtualGeometry} vg
-     */
-    build(vg) {
-        const face_count = vg.computeFaceCount();
-        const vertex_count = vg.computeVertexCount();
-
-        this.resizeGeometry(vertex_count, face_count);
-
-        const geometry = this.buffer_geometry;
-
-        const attribute_index = geometry.getIndex();
-        attribute_index.needsUpdate = true;
-        attribute_index.updateRange.offset = 0;
-        attribute_index.updateRange.count = face_count * 3;
-
-
-        const vertex_attribute_specs = this.__vertex_spec.attributes;
-        const vertex_attribute_spec_count = vertex_attribute_specs.length;
-
-        // map attributes by index for faster access
-        const geometry_attributes = [];
-        for (let i = 0; i < vertex_attribute_specs.length; i++) {
-            const attributeSpec = vertex_attribute_specs[i];
-            const geometry_attribute = geometry.getAttribute(attributeSpec.name);
-            geometry_attribute.needsUpdate = true;
-            geometry_attribute.updateRange.offset = 0;
-            geometry_attribute.updateRange.count = vertex_count * geometry_attribute.itemSize;
-
-            geometry_attributes.push(geometry_attribute);
-        }
-
-        // populate
-        let face_cursor = 0;
-        let vertex_cursor = 0;
-
-        /*
-        WebGL offers gl_VertexID attribute: https://webgl2fundamentals.org/webgl/lessons/webgl-drawing-without-data.html
-        can use gl_VertexID to figure out which patch a triangle/vertex belongs to
-        inside transform shader, apply matrix transform to the patch geometry
-        can use textures to store some extra data if we don't want to touch geometry unnecessarily
-         */
-        // TODO do a transform feedback pass, store patch info in a texture
-
-        const patches = vg.patches;
-        const patch_count = vg.patch_count;
-
-        const destination_index_attribute_array = attribute_index.array;
-
-        // fill indices
-        for (let patch_index = 0; patch_index < patch_count; patch_index++) {
-            const occurrence = patches[patch_index];
-
-            const patch = occurrence.patch;
-            const patch_face_count = patch.polygon_count;
-            const patch_vertex_count = patch.vertex_count;
-            const face_indices = patch.face_indices;
-
-            const patch_index_size = patch_face_count * 3;
-            const face_cursor_3 = face_cursor * 3;
-
-            for (let i = 0; i < patch_index_size; i++) {
-                const source_vertex_index = face_indices[i];
-                const remapped_vertex_index = source_vertex_index + vertex_cursor;
-
-                destination_index_attribute_array[face_cursor_3 + i] = remapped_vertex_index;
-            }
-
-            face_cursor += patch_face_count;
-            vertex_cursor += patch_vertex_count;
-        }
-
-        for (let i = 0; i < vertex_attribute_spec_count; i++) {
-            const attributeSpec = vertex_attribute_specs[i];
-
-            const itemSize = attributeSpec.itemSize;
-
-            const geometryAttribute = geometry_attributes[i];
-
-
-            const destination_attribute_array = geometryAttribute.array;
-            vertex_cursor = 0;
-
-            for (let patch_index = 0; patch_index < patch_count; patch_index++) {
-                const occurrence = patches[patch_index];
-
-                const patch = occurrence.patch;
-
-                const patch_vertex_count = patch.vertex_count;
-
-                const vertex_array_start_offset = vertex_cursor * itemSize;
-
-                // fill vertex data
-                const source_attribute_array = patch.vertex_attribute_arrays[i];
-
-                let transformed_attribute_array;
-                if (attributeSpec.name === 'position') {
-                    transformed_attribute_array = getTransformedPositionsCached(occurrence, i);
-                } else {
-                    transformed_attribute_array = source_attribute_array;
-                }
-
-                destination_attribute_array.set(transformed_attribute_array, vertex_array_start_offset);
-
-                // update cursors
-                vertex_cursor += patch_vertex_count;
-            }
-
-
-        }
-
-
-        if (this.__enable_debug_attribute_patch_vertex_color) {
-            vertex_cursor = 0;
-            const color_attribute = geometry.getAttribute('color');
-            const colors_array = color_attribute.array;
-
-            for (let patch_index = 0; patch_index < patch_count; patch_index++) {
-                const occurrence = patches[patch_index];
-
-                const patch = occurrence.patch;
-
-                const patch_vertex_count = patch.vertex_count;
-
-                const vertex_array_start_offset = vertex_cursor * 3;
-
-                // compute color
-
-                scratch_random.setCurrentSeed(occurrence.hash());
-
-                scratch_color.setHSL(scratch_random(), randomFloatBetween(scratch_random, 0.5, 0.9), 0.5);
-
-                const r = Math.round(scratch_color.r * 255);
-                const g = Math.round(scratch_color.g * 255);
-                const b = Math.round(scratch_color.b * 255);
-
-                for (let i = 0; i < patch_vertex_count; i++) {
-                    const i3 = i * 3 + vertex_array_start_offset;
-                    colors_array[i3] = r;
-                    colors_array[i3 + 1] = g;
-                    colors_array[i3 + 2] = b;
-                }
-                // update cursors
-                vertex_cursor += patch_vertex_count;
-            }
-
-            color_attribute.needsUpdate = true;
-            color_attribute.updateRange.offset = 0;
-            color_attribute.updateRange.count = vertex_count * 3;
-
-        }
-
-    }
-}

package/src/engine/graphics/micron/render/v1/VGThreeRenderer.js

@@ -1,142 +0,0 @@
-import Vector2 from "../../../../../core/geom/Vector2.js";
-import { MaterialContext } from "./MaterialContext.js";
-import { array_copy } from "../../../../../core/collection/array/copyArray.js";
-import { MicronRenderContext } from "./MicronRenderContext.js";
-import { MaterialVertexSpec, MaterialVertexSpecFlags } from "./MaterialVertexSpec.js";
-
-/**
- *
- * @type {MaterialVertexSpec}
- */
-const scratch_mvc = new MaterialVertexSpec();
-
-export class VGThreeRenderer {
-    constructor() {
-        /**
-         *
-         * @type {Object3D[]}
-         * @private
-         */
-        this.__inputs = [];
-
-        this.ctx = new MicronRenderContext();
-
-        this.on = {
-            /**
-             * @type {Signal<MaterialContext>}
-             */
-            contextAdded: this.ctx.on.contextAdded
-        };
-    }
-
-    get geometry() {
-        return this.ctx.geometry;
-    }
-
-    /**
-     * Enable/disable wireframe rendering
-     * @param {boolean} x
-     */
-    set wireframe(x) {
-        this.ctx.wireframe = x;
-    }
-
-    /**
-     *
-     * @param {THREE.Scene} scene
-     */
-    attach(scene) {
-        this.__inputs.push(scene);
-        this.ctx.builder.appendToScene([scene]);
-    }
-
-    attachMany(objects, object_count = objects.length) {
-        array_copy(objects, 0, this.__inputs, this.__inputs.length, objects.length);
-        this.ctx.builder.appendToScene(objects);
-    }
-
-    clear() {
-        this.__inputs = [];
-        this.ctx.builder.clearScene();
-    }
-
-    __prepare_contexts() {
-        // clear contexts
-        const render_context = this.ctx;
-        const contexts = render_context.__contexts_array;
-        const context_count = contexts.length;
-
-        for (let i = 0; i < context_count; i++) {
-            const ctx = contexts[i];
-
-            ctx.instances.clear();
-        }
-
-        const processObject = (o) => {
-            if (o.isMicronMesh) {
-                /**
-                 *
-                 * @type {ThreeMicronMesh}
-                 */
-                const m = o;
-
-                scratch_mvc.material = m.material;
-                scratch_mvc.spec = m.geometry.vertex_spec;
-                scratch_mvc.writeFlag(MaterialVertexSpecFlags.CastShadow, m.castShadow);
-                scratch_mvc.writeFlag(MaterialVertexSpecFlags.ReceiveShadow, m.receiveShadow);
-
-                const ctx = render_context.obtain_material(scratch_mvc);
-
-                ctx.instances.add(o.instance_id);
-            }
-        };
-
-        const inputs = this.__inputs;
-        const input_count = inputs.length;
-
-        for (let i = 0; i < input_count; i++) {
-            const input_object = inputs[i];
-
-            input_object.traverse(processObject);
-        }
-
-    }
-
-    render() {
-        this.ctx.render();
-    }
-
-
-    /**
-     *
-     * @param {THREE.WebGLRenderer} renderer
-     * @param {THREE.PerspectiveCamera|THREE.OrthographicCamera|THREE.Camera} camera
-     */
-    update(renderer, camera) {
-        this.__prepare_contexts();
-
-        const resolution = new Vector2();
-        let pixelRatio = 1;
-
-        /**
-         *
-         * @type {THREE.RenderTarget}
-         */
-        const render_target = renderer.getRenderTarget();
-
-        if (render_target !== null) {
-            resolution.set(render_target.width, render_target.height);
-        } else {
-            renderer.getSize(resolution);
-            pixelRatio = renderer.getPixelRatio();
-        }
-
-        const vg_builder = this.ctx.builder;
-
-        vg_builder.resolution.set(resolution.x * pixelRatio, resolution.y * pixelRatio);
-        vg_builder.setMatricesFromCamera(camera);
-        vg_builder.setOutput(this.ctx.geometry);
-
-        vg_builder.build();
-    }
-}

package/src/engine/graphics/micron/render/v1/getTransformedPositionsCached.js

@@ -1,54 +0,0 @@
-import { PatchCacheKey } from "../PatchCacheKey.js";
-import { apply_mat4_transform_to_v3_array } from "../../../../../core/geom/3d/apply_mat4_transform_to_v3_array.js";
-import { Cache } from "../../../../../core/cache/Cache.js";
-import { invokeObjectHash } from "../../../../../core/model/object/invokeObjectHash.js";
-import { invokeObjectEquals } from "../../../../../core/model/object/invokeObjectEquals.js";
-
-/**
- *
- * @type {Cache<PatchCacheKey, Float32Array>}
- */
-export const transformed_position_cache = new Cache({
-    keyHashFunction: invokeObjectHash,
-    keyEqualityFunction: invokeObjectEquals,
-    valueWeigher(array) {
-        return array.length * 4
-    },
-    maxWeight: 100 * 1024 * 1024 //100Mb
-});
-transformed_position_cache.onEvicted.add(PatchCacheKey.pool.release, PatchCacheKey.pool);
-const scratch_cache_key = new PatchCacheKey();
-
-/**
- *
- * @param {MicronGeometryPatchOccurrence} occurrence
- * @param {number} attribute_index
- * @returns {Float32Array}
- */
-export function getTransformedPositionsCached(occurrence, attribute_index) {
-    // we assume that cache misses will be less frequent, so we use an additional fixed key for faster cache queries
-    scratch_cache_key.fromPatchOccurrence(occurrence);
-
-    const existing = transformed_position_cache.get(scratch_cache_key);
-
-    if (existing !== null) {
-        // cache hit
-        return existing;
-    }
-
-    // create key to be stored in cache
-    const key = PatchCacheKey.pool.get();
-    key.copy(scratch_cache_key);
-
-    const patch = occurrence.patch;
-    const source_array = patch.vertex_attribute_arrays[attribute_index];
-
-    const destination = new Float32Array(source_array.length);
-
-    apply_mat4_transform_to_v3_array(source_array, 0, destination, 0, patch.vertex_count, occurrence.transform.elements);
-
-    // store in cache
-    transformed_position_cache.put(key, destination);
-
-    return destination;
-}

package/src/engine/graphics/micron/simplifyGeometry.js

@@ -1,26 +0,0 @@
-import { TopoMesh } from "../../../core/geom/3d/topology/struct/TopoMesh.js";
-import { simplifyTopoMesh } from "../../../core/geom/3d/topology/simplify/simplifyTopoMesh.js";
-import {
-    topo_mesh_to_three_buffer_geometry
-} from "../../../core/geom/3d/topology/topo_mesh_to_three_buffer_geometry.js";
-
-/**
- *
- * @param {BufferGeometry} input
- * @param {number} target
- * @return {BufferGeometry}
- */
-function simplifyGeometry(input, target) {
-    const position_attribute = input.getAttribute("position");
-    const index_attribute = input.index;
-
-    const topo = new TopoMesh();
-
-    topo.build(position_attribute.array, index_attribute.array);
-
-    // expandConnectivityByLocality(topo);
-
-    simplifyTopoMesh(topo, target);
-
-    return topo_mesh_to_three_buffer_geometry(topo);
-}

package/src/engine/graphics/micron/util/patchToBufferGeometry.js

@@ -1,19 +0,0 @@
-import { BufferAttribute, BufferGeometry, InterleavedBuffer, InterleavedBufferAttribute } from "three";
-
-/**
- *
- * @param {MicronGeometryPatch} patch
- * @returns {BufferGeometry}
- */
-export function patchToBufferGeometry(patch) {
-    const geometry = new BufferGeometry();
-
-    geometry.setIndex(new BufferAttribute(patch.face_indices, 1, false))
-
-    const interleavedBuffer = new InterleavedBuffer(new Float32Array(patch.vertex_attribute_data), 3);
-    const position_attribute = new InterleavedBufferAttribute(interleavedBuffer, 3, 0, false);
-    geometry.setAttribute("position", position_attribute);
-    geometry.computeVertexNormals();
-
-    return geometry;
-}