@woosh/meep-engine 2.48.20 → 2.48.21

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

@@ -1,250 +0,0 @@
-import LineBuilder from "../../../../../../core/codegen/LineBuilder.js";
-import { BinaryDataType } from "../../../../../../core/binary/type/BinaryDataType.js";
-import { gen_micron_vertex_attribute_texture_name } from "./gen_micron_vertex_attribute_texture_name.js";
-import { MICRON_PATCH_SIZE_MAX } from "../../../build/MICRON_PATCH_SIZE_MAX.js";
-
-const DEBUG_PATCHES = false;
-
-/**
- *
- * @param {{vertexShader,fragmentShader,uniforms:Object<IUniform>}} shader
- * @param {Object<IUniform>} uniforms
- * @param {VertexDataSpec} spec
- * @param {number} column_count
- */
-export function shader_rewrite_standard(shader, uniforms, spec, column_count) {
-    Object.assign(shader.uniforms, uniforms);
-
-    const originalVertexShader = shader.vertexShader;
-
-    const vx_lb_preamble = new LineBuilder();
-
-    vx_lb_preamble.add('precision mediump usampler2D;');
-    vx_lb_preamble.add('precision mediump isampler2D;');
-
-    vx_lb_preamble.add('attribute float micron_patch_address;');
-    vx_lb_preamble.add('attribute mat4 micron_patch_transform;');
-
-    if (DEBUG_PATCHES) {
-        // vx_lb_preamble.add('attribute float micron_instance_id;');
-        vx_lb_preamble.add('varying float v_micron_patch_address;');
-        vx_lb_preamble.add('varying float v_vertex_id;');
-        vx_lb_preamble.add('varying float v_micron_instance_id;');
-    }
-
-    const attributes = spec.attributes;
-    const attribute_count = attributes.length;
-
-    for (let i = 0; i < attribute_count; i++) {
-        const attribute = attributes[i];
-        let type;
-
-        switch (attribute.type) {
-            case BinaryDataType.Int8:
-                type = 'isampler2D';
-                break;
-            default:
-                type = 'sampler2D';
-                break
-        }
-
-        vx_lb_preamble.add(`uniform sampler2D ${gen_micron_vertex_attribute_texture_name(attribute.name)};`);
-    }
-
-
-    let rewrittenVertexShader = originalVertexShader
-        .replace(
-            '#include <uv_vertex>',
-            ` 
-                int micron_patch_address_int = int(micron_patch_address);
-                
-                ${
-                DEBUG_PATCHES ? `
-                v_micron_patch_address = micron_patch_address;
-                v_vertex_id = float(gl_VertexID);
-                // v_micron_instance_id = float(micron_instance_id);
-                ` : ''
-            }
-                int micron_patch_slot_column = micron_patch_address_int  % ${column_count};
-                int micron_patch_slot_x = micron_patch_slot_column * ${MICRON_PATCH_SIZE_MAX * 3};
-                int micron_patch_slot_y = (micron_patch_address_int - micron_patch_slot_column)  / ${column_count};
-                
-                ivec2 micron_vertex_uv = ivec2( gl_VertexID + micron_patch_slot_x, micron_patch_slot_y );
-                  
-                #include <uv_vertex>
-                `
-        )
-        .replace(
-            '#include <begin_vertex>',
-            `
-                vec3 position_micron = texelFetch(${gen_micron_vertex_attribute_texture_name('position')}, micron_vertex_uv, 0).rgb;
-                vec3 transformed = ( micron_patch_transform * vec4(position_micron,1.0) ).xyz;
-                
-                `
-        );
-
-    const attribute_spec_uv = spec.getAttributeByName('uv');
-
-    if (attribute_spec_uv !== undefined) {
-        const vx_uv_value = `texelFetch(${gen_micron_vertex_attribute_texture_name('uv')}, micron_vertex_uv, 0).rg`
-
-        rewrittenVertexShader = rewrittenVertexShader.replace(
-            '#include <uv_vertex>',
-            `
-                #ifdef USE_UV
-                    vUv = ( uvTransform * vec3( ${vx_uv_value}, 1 ) ).xy;
-                #endif
-                `
-        );
-    }
-
-    const attribute_spec_uv2 = spec.getAttributeByName('uv2');
-
-    if (attribute_spec_uv2 !== undefined) {
-        const vx_uv2_value = `texelFetch(${gen_micron_vertex_attribute_texture_name('uv2')}, micron_vertex_uv, 0).rg`
-
-        rewrittenVertexShader = rewrittenVertexShader.replace(
-            '#include <uv2_vertex>',
-            `
-                #if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
-                    vUv2 = ( uv2Transform * vec3( ${vx_uv2_value}, 1 ) ).xy;
-                #endif
-                `
-        );
-    }
-
-    const attribute_spec_normal = spec.getAttributeByName('normal');
-
-
-    if (attribute_spec_normal !== undefined) {
-        const vx_normal_value = `texelFetch(${gen_micron_vertex_attribute_texture_name('normal')}, micron_vertex_uv, 0).rgb`
-
-        rewrittenVertexShader = rewrittenVertexShader.replace(
-            '#include <beginnormal_vertex>',
-            `
-                vec3 objectNormal = ${vx_normal_value};
-                #ifdef USE_TANGENT
-                    vec3 objectTangent = vec3( tangent.xyz );
-                #endif
-                `
-        );
-
-    }
-
-    rewrittenVertexShader = rewrittenVertexShader.replace(
-        '#include <defaultnormal_vertex>',
-        `
-                vec3 transformedNormal = objectNormal;
-                
-                // this is in lieu of a per-instance normal-matrix
-                // shear transforms in the instance matrix are not supported
-                mat3 m = mat3( micron_patch_transform );
-                transformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );
-                transformedNormal = m * transformedNormal;
-                
-                transformedNormal = normalMatrix * transformedNormal;
-                
-                #ifdef FLIP_SIDED
-                    transformedNormal = - transformedNormal;
-                #endif
-                #ifdef USE_TANGENT
-                    vec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;
-                    #ifdef FLIP_SIDED
-                        transformedTangent = - transformedTangent;
-                    #endif
-                #endif
-                `
-    );
-
-    const attribute_spec_color = spec.getAttributeByName('color');
-
-    if (attribute_spec_color !== undefined) {
-        // using color
-        const vx_color_value = `texelFetch(${gen_micron_vertex_attribute_texture_name('color')}, micron_vertex_uv, 0)`
-
-        rewrittenVertexShader = rewrittenVertexShader.replace(
-            '#include <color_vertex>',
-            `
-                #if defined( USE_COLOR_ALPHA )
-                    vColor = vec4( 1.0 );
-                #elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
-                    vColor = vec3( 1.0 );
-                #endif
-                
-                #ifdef USE_COLOR
-                
-                    #ifdef USE_COLOR_ALPHA
-                        vColor *= ${vx_color_value}.rgba;
-                    #else
-                        vColor *= ${vx_color_value}.rgb;
-                    #endif
-                    
-                #endif
-                
-                `
-        );
-
-    }
-
-    // shader.defines.USE_COLOR  = true;
-    //
-    // rewrittenVertexShader = rewrittenVertexShader.replace(
-    //     '#include <color_vertex>',
-    //     `
-    //     #include <color_vertex>
-    //              //vColor = vec3(1.0);
-    //              vColor.xyz = vec3(
-    //                     sin(float(micron_patch_address)*123.1),
-    //                     sin(float(micron_patch_address)*11.7),
-    //                     sin(float(micron_patch_address)*932.183)
-    //                     );
-    //             `
-    // );
-
-    const newVertexShader = vx_lb_preamble.build()
-        + '\n'
-        + rewrittenVertexShader;
-
-
-    shader.vertexShader = newVertexShader;
-
-    if (DEBUG_PATCHES) {
-        shader.fragmentShader = shader.fragmentShader.replace(
-            '#include <color_pars_fragment>',
-            `#include <color_pars_fragment>
-             varying float v_micron_patch_address;
-             varying float v_vertex_id;
-             varying float v_micron_instance_id;
-`
-        );
-        shader.fragmentShader = shader.fragmentShader.replace(
-            '#include <color_fragment>',
-            // `diffuseColor.rgb =  vec3(
-            //           sin(v_micron_patch_address*123.1),
-            //           sin(v_micron_patch_address*11.7),
-            //           sin(v_micron_patch_address*932.183)
-            // );`
-            `diffuseColor.rgb = vec3(1.0);`
-        );
-
-        shader.fragmentShader = shader.fragmentShader.replace(
-            '#include <dithering_fragment>',
-            `gl_FragColor.rgb =  vec3(
-                      sin(v_micron_patch_address*123.1)*0.5 + 0.5,
-                      sin(v_micron_patch_address*11.7)*0.5 + 0.5,
-                      sin(v_micron_patch_address*932.183)*0.5 + 0.5
-            );`
-            // `gl_FragColor.rgb =  vec3(
-            //           sin(v_micron_instance_id*123.1)*0.5 + 0.5,
-            //           sin(v_micron_instance_id*11.7)*0.5 + 0.5,
-            //           sin(v_micron_instance_id*932.183)*0.5 + 0.5
-            // );`
-            //     `gl_FragColor.rgb =  vec3(
-            //           v_vertex_id*0.0026041666666666665,
-            //           1.0,
-            //           1.0
-            // );`
-            //`gl_FragColor.rgb = vec3(1.0);`
-        );
-    }
-}

package/src/engine/graphics/micron/render/makeThreeMeshFromVirtualGeometry.js

@@ -1,37 +0,0 @@
-import { ThreeVirtualGeometryAdapter } from "./v1/ThreeVirtualGeometryAdapter.js";
-import { Group, Mesh } from "three";
-
-/**
- *
- * @param {VertexDataSpec} spec
- * @param {VirtualGeometry} virtual_geometry
- * @param {THREE.Material[]} materials
- * @returns {Mesh}
- */
-export function makeThreeMeshFromVirtualGeometry(spec, virtual_geometry, materials) {
-    const adapter = new ThreeVirtualGeometryAdapter();
-    adapter.__vertex_spec = spec;
-
-    const g = new Group();
-
-    materials.forEach(material =>{
-
-        const mesh = new Mesh(adapter.buffer_geometry, material);
-        mesh.frustumCulled = false;
-
-        adapter.onRebuild.add(() => {
-            mesh.geometry = adapter.buffer_geometry;
-        });
-
-        g.add(mesh);
-    })
-
-    g.update = () => {
-        adapter.build(virtual_geometry);
-    };
-
-    g['@micron'] = true;
-
-
-    return g;
-}

package/src/engine/graphics/micron/render/refinement/ActivePatchFlags.js

@@ -1,8 +0,0 @@
-/**
- *
- * @enum {number}
- */
-export const ActivePatchFlags = {
-    Visible: 1,
-    Occluded: 2
-};

package/src/engine/graphics/micron/render/refinement/ActivePatchList.js

@@ -1,241 +0,0 @@
-import { ActivePatchRecord } from "./ActivePatchRecord.js";
-import { ActivePatchFlags } from "./ActivePatchFlags.js";
-import { aabb3_project_to_2d } from "../../../../../core/geom/3d/aabb/aabb3_compute_projected_area.js";
-import { BitSet } from "../../../../../core/binary/BitSet.js";
-import {
-    aabb3_array_intersects_frustum_array
-} from "../../../../../core/geom/3d/aabb/aabb3_array_intersects_frustum_array.js";
-
-export class ActivePatchList {
-    constructor() {
-        /**
-         * Linked list
-         * @type {ActivePatchRecord}
-         */
-        this.records = null;
-
-        /**
-         * Used for tracking changes
-         * @type {number}
-         */
-        this.version = 0;
-
-        /**
-         *
-         * @type {BitSet}
-         */
-        this.unfolded = new BitSet();
-
-        // prevent re-allocation related thrashing
-        this.unfolded.preventShrink();
-    }
-
-    clear() {
-        const unfolded = this.unfolded;
-
-        unfolded.reset();
-
-        ActivePatchRecord.pool_release_all(this.records);
-
-        this.records = null;
-    }
-
-    /**
-     *
-     * @param {MicronGeometry} geometry
-     */
-    initializeFromGeometry(geometry) {
-        this.clear();
-
-        const record = ActivePatchRecord.pool_get();
-
-        record.patch = geometry.root;
-        record.link_next = null;
-        record.link_previous = null;
-
-        const unfolded = this.unfolded;
-        unfolded.set(record.patch.id, true);
-
-        this.records = record;
-    }
-
-    /**
-     *
-     * @param {ActivePatchRecord} record
-     * @returns {ActivePatchRecord}
-     */
-    node_split(record) {
-
-        const sub_patches = record.patch.children;
-        const sub_patch_count = sub_patches.length;
-        const unfolded = this.unfolded;
-
-        for (let i = 0; i < sub_patch_count; i++) {
-            const child = sub_patches[i];
-
-            const child_id = child.id;
-
-            if (unfolded.getAndSet(child_id)) {
-                // already unfolded, skip
-                continue;
-            }
-
-            const child_record = ActivePatchRecord.pool_get();
-            child_record.patch = child;
-
-            this.record_insert_after(record, child_record);
-        }
-
-        this.record_remove(record);
-
-        const next = record.link_next;
-
-        ActivePatchRecord.pool_release(record);
-
-        return next;
-    }
-
-    /**
-     *
-     * @param {ActivePatchRecord} record
-     */
-    record_remove(record) {
-        const previous = record.link_previous;
-        const next = record.link_next;
-
-        if (previous === null) {
-            this.records = next;
-        } else {
-            previous.link_next = next;
-        }
-
-        if (next !== null) {
-            next.link_previous = previous;
-        }
-    }
-
-    /**
-     *
-     * @param {ActivePatchRecord} reference
-     * @param {ActivePatchRecord} record
-     */
-    record_insert_after(reference, record) {
-        const tail = reference.link_next;
-
-        reference.link_next = record;
-
-        record.link_previous = reference;
-        record.link_next = tail;
-
-        if (tail !== null) {
-            tail.link_previous = record;
-        }
-    }
-
-    /**
-     *
-     * @param {ActivePatchRecord} record
-     */
-    insert(record) {
-        if (this.records === null) {
-            this.records = record;
-        } else {
-            this.record_insert_after(this.records, record);
-        }
-    }
-
-    /**
-     *
-     * @param {ActivePatchRecord} a
-     * @param {ActivePatchRecord} b
-     */
-    node_merge(a, b) {
-        a.patch = a.patch.parent;
-        a.setFlag(ActivePatchFlags.Visible);
-
-        this.record_remove(b);
-    }
-
-
-    /**
-     * Populate with LOD-X of a given geometry
-     * @param {MicronGeometry} geometry
-     * @param {number} lod
-     */
-    build_from_lod(geometry, lod) {
-        // reset current records
-        this.records = null;
-
-        const patches = geometry.__patches;
-
-        for (let i = 0; i < patches.length; i++) {
-            const p = patches[i];
-            if (p.lod !== lod) {
-                continue;
-            }
-            const record = ActivePatchRecord.fromPatch(p);
-            record.setFlag(ActivePatchFlags.Visible);
-            this.insert(record);
-        }
-
-    }
-
-    /**
-     *
-     * @param {RefinementSpec} spec
-     */
-    refine(spec) {
-
-        const frustum_planes = spec.frustum_f32;
-        const projection_matrix = spec.projection_matrix;
-        const error_threshold = spec.error_threshold_normalized;
-
-        let record = this.records
-
-        for (; record !== null;) {
-
-            const node = record.patch;
-
-
-            /*
-             check if node is in view frustum
-             NOTE: following suggestion in "FastMesh: Efficient View-dependent Meshing" by Renato Pajarola et al, we can do a more coarse frustum test approximating frustum as a cone initially
-             */
-            const in_view_frustum = aabb3_array_intersects_frustum_array(node.bounding_box, frustum_planes);
-
-            if (!in_view_frustum) {
-                // outside of view frustum, cull
-                record = record.link_next;
-                continue;
-            }
-
-            record.setFlag(ActivePatchFlags.Visible);
-
-            /*
-             scale error to projection space:
-                1 - project bounding sphere of the patch to view space
-                2 - compute relative scale of the projected sphere
-                3 - multiply group error by the projected sphere scale to know the projected error
-             */
-
-
-            // check if record needs to be split
-            if (node.lod > 0) {
-
-                // not the lowest level of LOD, see if subdivision might be necessary
-
-                // compute average triangle area
-                const group_screen_area = aabb3_project_to_2d(node.group_bounding_box_corners, projection_matrix);
-                const screen_space_error = node.group_error * group_screen_area;
-
-                if (screen_space_error > error_threshold) {
-                    // error too large, needs to be split
-                    record = this.node_split(record);
-                    continue;
-                }
-            }
-
-            record = record.link_next;
-        }
-    }
-}

package/src/engine/graphics/micron/render/refinement/ActivePatchRecord.js

@@ -1,154 +0,0 @@
-import { assert } from "../../../../../core/assert.js";
-
-/**
- *
- * @type {ActivePatchRecord|null}
- */
-let patch_pool = null;
-let patch_pool_size = 0;
-
-const patch_limit = 4096;
-
-export class ActivePatchRecord {
-    constructor() {
-        /**
-         *
-         * @type {number}
-         */
-        this.flags = 0;
-
-        /**
-         *
-         * @type {MicronGeometryPatch}
-         */
-        this.patch = null;
-
-        /**
-         * Linked list
-         * @type {ActivePatchRecord|null}
-         */
-        this.link_previous = null;
-        /**
-         * Linked list
-         * @type {ActivePatchRecord|null}
-         */
-        this.link_next = null;
-    }
-
-    /**
-     * @param {MicronGeometryPatch} patch
-     * @returns {ActivePatchRecord}
-     */
-    static fromPatch(patch) {
-        assert.equal(patch.isMicronGeometryPatch, true, 'patch.MicronGeometryPatch !== true');
-
-        const r = new ActivePatchRecord();
-
-        r.patch = patch;
-
-        return r;
-    }
-
-    static pool_get() {
-        if (patch_pool_size <= 0) {
-            return new ActivePatchRecord();
-        }
-
-        const r = patch_pool;
-
-        patch_pool = patch_pool.link_next;
-        patch_pool_size--;
-
-        // reset record
-        r.flags = 0;
-
-        return r;
-    }
-
-    /**
-     *
-     * @param {ActivePatchRecord} r
-     */
-    static pool_release(r) {
-        if (patch_pool_size >= patch_limit) {
-            // just drop
-            return;
-        }
-
-        r.link_previous = null;
-        r.patch = null;
-        r.link_next = patch_pool;
-
-        patch_pool = r;
-
-        patch_pool_size++;
-    }
-
-    /**
-     *
-     * @param {ActivePatchRecord} r
-     */
-    static pool_release_all(r) {
-        if (r === null) {
-            return;
-        }
-
-        let p = r;
-
-        for (; patch_pool_size < patch_limit;) {
-            const next = p.link_next;
-            patch_pool_size++;
-
-            if (next === null) {
-                break;
-            }
-
-            p = next;
-        }
-
-        const old_head = patch_pool;
-
-        patch_pool = r;
-        p.link_next = old_head;
-    }
-
-    /**
-     *
-     * @param {number|ActivePatchFlags} flag
-     * @returns {void}
-     */
-    setFlag(flag) {
-        this.flags |= flag;
-    }
-
-    /**
-     *
-     * @param {number|ActivePatchFlags} flag
-     * @returns {void}
-     */
-    clearFlag(flag) {
-        this.flags &= ~flag;
-    }
-
-    /**
-     *
-     * @param {number|ActivePatchFlags} flag
-     * @param {boolean} value
-     */
-    writeFlag(flag, value) {
-        if (value) {
-            this.setFlag(flag);
-        } else {
-            this.clearFlag(flag);
-        }
-    }
-
-    /**
-     *
-     * @param {number|ActivePatchFlags} flag
-     * @returns {boolean}
-     */
-    getFlag(flag) {
-        return (this.flags & flag) === flag;
-    }
-}