@woosh/meep-engine 2.33.62 → 2.33.67

package/engine/ecs/terrain/ecs/PromiseSamplerHeight.js

@@ -0,0 +1,59 @@
+import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
+import { deserializeTexture } from "../../../graphics/texture/sampler/TextureBinaryBufferSerializer.js";
+import { Sampler2D } from "../../../graphics/texture/sampler/Sampler2D.js";
+import { GameAssetType } from "../../../asset/GameAssetType.js";
+import rgbaData2valueSampler2D from "../../../graphics/texture/sampler/rgbaData2valueSampler2D.js";
+
+/**
+ *
+ * @param zRange
+ * @param heightMapURL
+ * @param {AssetManager} assetManager
+ * @returns {Promise<any>}
+ */
+export function promiseSamplerHeight(zRange, heightMapURL, assetManager) {
+    return new Promise(function (fulfill, reject) {
+
+        function assetObtained(asset) {
+            const array = asset.create();
+
+            const binaryBuffer = new BinaryBuffer();
+            //
+            // binaryBuffer.writeUint32(2560);
+            // binaryBuffer.writeUint32(2560);
+            //
+            // binaryBuffer.writeUint8(1);
+            //
+            // binaryBuffer.writeUint8(6);
+
+            binaryBuffer.writeBytes(new Uint8Array(array), 0, array.length);
+
+            binaryBuffer.position = 0;
+
+            const sampler2D = deserializeTexture(binaryBuffer);
+            fulfill(sampler2D);
+        }
+
+
+        if (heightMapURL === undefined) {
+            console.warn('Height map is not specified');
+            const defaultSampler = new Sampler2D(new Uint8Array(1), 1, 1, 1);
+            fulfill(defaultSampler);
+        } else if (heightMapURL.endsWith('.bin')) {
+            //load texture from a binary file
+            assetManager.get(heightMapURL, GameAssetType.ArrayBuffer, assetObtained, reject);
+        } else {
+            assetManager.get(heightMapURL, GameAssetType.Image, function (asset) {
+                const image = asset.create();
+
+                // plane
+                const imgWidth = image.width;
+                const imgHeight = image.height;
+
+                const samplerHeight = rgbaData2valueSampler2D(image.data, imgWidth, imgHeight, zRange, -zRange / 2);
+
+                fulfill(samplerHeight);
+            }, reject);
+        }
+    });
+}

package/engine/ecs/terrain/ecs/Terrain.js

@@ -14,9 +14,6 @@ import {
 } from 'three';
 import { clamp } from "../../../../core/math/clamp.js";
 import { Sampler2D } from '../../../graphics/texture/sampler/Sampler2D.js';
-import heightMap2NormalMap from '../../grid/HeightMap2NormalMap.js';
-import normalMap2AOMap from '../../grid/NormalMap2AOMap.js';
-import rgbaData2valueSampler2D from '../../../graphics/texture/sampler/rgbaData2valueSampler2D.js';
 import { BinaryNode } from '../../../../core/bvh2/BinaryNode.js';
 import Vector2 from '../../../../core/geom/Vector2.js';
 import { TerrainOverlay } from '../overlay/TerrainOverlay.js';
@@ -24,13 +21,9 @@ import { TerrainOverlay } from '../overlay/TerrainOverlay.js';
 import Clouds from '../TerrainClouds.js';
 
 import TerrainTileManager from '../tiles/TerrainTileManager.js';
-import { WebGLRendererPool } from "../../../graphics/render/RendererPool.js";
-import { deserializeTexture } from "../../../graphics/texture/sampler/TextureBinaryBufferSerializer.js";
-import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
 import { TerrainPreview } from "../TerrainPreview.js";
 import { assert } from "../../../../core/assert.js";
 import { GameAssetType } from "../../../asset/GameAssetType.js";
-import { writeSample2DDataToDataTexture } from "../../../graphics/texture/sampler/writeSampler2DDataToDataTexture.js";
 import { TerrainLayers } from "./layers/TerrainLayers.js";
 import { SplatMaterial } from "../../../graphics/material/SplatMaterial.js";
 import { loadLegacyTerrainSplats, SplatMapping } from "./splat/SplatMapping.js";
@@ -41,147 +34,8 @@ import { MeepSettings } from "../../../MeepSettings.js";
 import { loadLegacyTerrainLayers } from "./layers/loadLegacyTerrainLayers.js";
 import { TerrainFlags } from "./TerrainFlags.js";
 import { IllegalStateException } from "../../../../core/fsm/exceptions/IllegalStateException.js";
-
-/**
- *
- * @param zRange
- * @param heightMapURL
- * @param {AssetManager} assetManager
- * @returns {Promise<any>}
- */
-function promiseSamplerHeight(zRange, heightMapURL, assetManager) {
-    return new Promise(function (fulfill, reject) {
-
-        function assetObtained(asset) {
-            const array = asset.create();
-
-            const binaryBuffer = new BinaryBuffer();
-            //
-            // binaryBuffer.writeUint32(2560);
-            // binaryBuffer.writeUint32(2560);
-            //
-            // binaryBuffer.writeUint8(1);
-            //
-            // binaryBuffer.writeUint8(6);
-
-            binaryBuffer.writeBytes(new Uint8Array(array), 0, array.length);
-
-            binaryBuffer.position = 0;
-
-            const sampler2D = deserializeTexture(binaryBuffer);
-            fulfill(sampler2D);
-        }
-
-
-        if (heightMapURL === undefined) {
-            console.warn('Height map is not specified');
-            const defaultSampler = new Sampler2D(new Uint8Array(1), 1, 1, 1);
-            fulfill(defaultSampler);
-        } else if (heightMapURL.endsWith('.bin')) {
-            //load texture from a binary file
-            assetManager.get(heightMapURL, GameAssetType.ArrayBuffer, assetObtained, reject);
-        } else {
-            assetManager.get(heightMapURL, GameAssetType.Image, function (asset) {
-                const image = asset.create();
-
-                // plane
-                const imgWidth = image.width;
-                const imgHeight = image.height;
-
-                const samplerHeight = rgbaData2valueSampler2D(image.data, imgWidth, imgHeight, zRange, -zRange / 2);
-
-                fulfill(samplerHeight);
-            }, reject);
-        }
-    });
-}
-
-/**
- *
- * @param {WebGLRenderer} renderer
- * @param {Sampler2D} sampler
- * @returns {Promise<Sampler2D>}
- */
-function promiseSamplerNormal(renderer, sampler) {
-
-    console.time("generating normal map");
-    const normalSampler = heightMap2NormalMap(renderer, sampler);
-    console.timeEnd("generating normal map");
-
-
-    return Promise.resolve(normalSampler);
-}
-
-/**
- *
- * @param {WebGLRenderer} renderer
- * @param {Promise<Sampler2D>} pSamplerNormal
- * @param {Sampler2D} samplerHeight
- * @param {Vector2} resolution
- * @param {number} rayLength
- * @returns {Promise<unknown>}
- */
-function promiseSamplerAO(
-    renderer,
-    pSamplerNormal,
-    samplerHeight,
-    resolution,
-    rayLength
-) {
-    return new Promise(function (resolve, reject) {
-        Promise.all([pSamplerNormal]).then(function (values) {
-            const samplerNormal = values[0];
-            console.time("generating AO map");
-            const occlusionSampler = normalMap2AOMap(
-                renderer,
-                samplerHeight,
-                samplerNormal,
-                resolution,
-                rayLength
-            );
-            console.timeEnd("generating AO map");
-            //console.info(occlusionSampler);
-            //
-            // paintSamplerOnHTML(samplerHeight, 0, 0, 40, 3);
-            // paintSamplerOnHTML(samplerNormal, 1, 0, 128, 1);
-            // paintSamplerOnHTML(occlusionSampler, 2, 0, 1, 0);
-            //
-            //
-            resolve(occlusionSampler);
-        }, reject);
-    });
-}
-
-/**
- *
- * @param {DataTexture} texture
- * @param {Vector2} resolution
- * @param {Sampler2D} heightSampler
- * @param {number} heightRange
- * @param {number} [rayLength]
- * @returns {Promise}
- */
-function buildLightTexture({ texture, heightSampler, resolution, rayLength = 17 }) {
-
-    const renderer = WebGLRendererPool.global.get();
-
-    if (resolution === undefined) {
-        resolution = new Vector2(texture.image.width, texture.image.height);
-    }
-
-    const normal = promiseSamplerNormal(renderer, heightSampler);
-    const ao = promiseSamplerAO(renderer, normal, heightSampler, resolution, rayLength);
-
-    const promise = ao.then(sampler => {
-        writeSample2DDataToDataTexture(sampler, texture);
-    });
-
-    Promise.all([normal, ao]).finally(() => {
-        WebGLRendererPool.global.release(renderer);
-    });
-
-    return promise;
-}
+import { buildLightTexture } from "./BuildLightTexture.js";
+import { promiseSamplerHeight } from "./PromiseSamplerHeight.js";
 
 let idCounter = 0;
 
@@ -903,13 +757,13 @@ class Terrain {
         this.updateWorkerHeights();
     }
 
-    updateWorkerHeights() {
+    async updateWorkerHeights() {
         const s = this.samplerHeight;
         const worker = this.buildWorker;
 
-        worker.setHeightSampler(s.data, s.itemSize, s.width, s.height);
+        await worker.setHeightSampler(s.data, s.itemSize, s.width, s.height);
 
-       return worker.computeHeightRange()
+        return await worker.computeHeightRange()
             .then(({ min, max }) => {
                 this.tiles.setHeightRange(min, max);
             });
@@ -1012,7 +866,12 @@ class Terrain {
         this.setFlag(TerrainFlags.Built);
     }
 
-    buildLightMap() {
+    /**
+     *
+     * @param {number} quality resolution in texels per grid cell (4 = 4x4 light map texels per single grid cell)
+     * @return {Promise<DataTexture>}
+     */
+    buildLightMap(quality = 4) {
 
 
         const size_x = this.size.x;
@@ -1035,7 +894,9 @@ class Terrain {
 
         const promise = buildLightTexture({
             texture,
-            heightSampler: this.samplerHeight
+            heightSampler: this.samplerHeight,
+            worldSize: new Vector2(size_x * this.gridScale, size_y * this.gridScale),
+            resolution: new Vector2(size_x * quality, size_y *quality)
         });
 
 

package/engine/ecs/tooltip/TooltipComponentSystem.js

@@ -2,10 +2,10 @@ import { System } from "../System.js";
 import { TooltipComponent } from "./TooltipComponent.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { MeshSystem } from "../../graphics/ecs/mesh/MeshSystem.js";
-import { modelHitTest } from "../../../../model/game/util/ScreenGridPicker.js";
 import { SurfacePoint3 } from "../../../core/geom/3d/SurfacePoint3.js";
 import { VisualTip } from "../../../view/tooltip/VisualTip.js";
 import Rectangle from "../../../core/geom/Rectangle.js";
+import { modelHitTest } from "../../graphics/util/modelHitTest.js";
 
 const ray_source = new Vector3();
 const ray_direction = new Vector3();

package/engine/graphics/FULL_SCREEN_QUAD_VERTEX_SHADER.js

@@ -0,0 +1,10 @@
+export const FULL_SCREEN_QUAD_VERTEX_SHADER = `        
+        varying vec2 vUv;
+
+        void main() {
+
+            vUv = uv;
+                
+            gl_Position = vec4( (uv - 0.5)*2.0, 0.0, 1.0 );
+            
+        }`;

package/engine/graphics/filter/ImageFilter.js

@@ -5,13 +5,14 @@
 
 import { LinearFilter, Mesh, OrthographicCamera, Scene, ShaderMaterial, WebGLRenderTarget } from 'three';
 import { FULL_SCREEN_TRIANGLE_GEOMETRY } from "../geometry/FULL_SCREEN_TRIANGLE_GEOMETRY.js";
+import { FULL_SCREEN_QUAD_VERTEX_SHADER } from "../FULL_SCREEN_QUAD_VERTEX_SHADER.js";
 
 /**
  *
  * @param {WebGLRenderer} renderer
  * @param {number} width
  * @param {number} height
- * @param {{vertexShader:string,fragmentShader:string, uniforms?:Object, defines?:Object}} processShader
+ * @param {{vertexShader?:string,fragmentShader:string, uniforms?:Object, defines?:Object}} processShader
  * @param {Uint8Array} [destination]
  * @return {{array: Uint8Array, renderer: WebGLRenderer}}
  */
@@ -34,9 +35,12 @@ function processTexture(
     scene.add(camera);
 
     //make a quad to render
-    const material = new ShaderMaterial(processShader);
+    const material = new ShaderMaterial(Object.assign({ vertexShader: FULL_SCREEN_QUAD_VERTEX_SHADER }, processShader));
+
     material.lights = false;
     material.fog = false;
+    material.uniformsNeedUpdate = true;
+    material.needsUpdate = true;
 
     const quad = new Mesh(FULL_SCREEN_TRIANGLE_GEOMETRY, material);
 

package/engine/graphics/geometry/AttributeSpec.d.ts

@@ -0,0 +1,8 @@
+import {DataType} from "../../../core/parser/simple/DataType";
+
+export class AttributeSpec {
+    readonly name: string
+    readonly type: DataType
+    readonly itemSize: number
+    readonly normalized: boolean
+}

package/engine/graphics/geometry/VertexDataSpec.d.ts

@@ -0,0 +1,15 @@
+import {AttributeSpec} from "./AttributeSpec";
+
+export class VertexDataSpec {
+    readonly attributes: AttributeSpec[]
+
+    getAttributeByName(name: string): AttributeSpec | undefined
+
+    add(attribute: AttributeSpec): this
+
+    setAttributes(attributes: AttributeSpec[]): void
+
+    equals(other: VertexDataSpec): boolean
+
+    hash(): number
+}

package/engine/graphics/geometry/buffered/deinterleaveBufferAttribute.js

@@ -0,0 +1,39 @@
+import { BufferAttribute } from "three";
+
+
+/**
+ *
+ * @param {THREE.InterleavedBufferAttribute|THREE.BufferAttribute} source_attribute
+ * @returns {THREE.BufferAttribute}
+ */
+export function deinterleaveBufferAttribute(source_attribute) {
+    if (source_attribute.isInterleavedBufferAttribute !== true && source_attribute.isBufferAttribute) {
+        return source_attribute;
+    }
+
+    const source_data = source_attribute.data;
+    const source_data_array = source_data.array;
+    const stride = source_data.stride;
+
+    const item_count = source_attribute.count;
+    const itemSize = source_attribute.itemSize;
+    const array_size = item_count * itemSize;
+
+    const offset = source_attribute.offset;
+
+    const destination_array = new source_data_array.constructor(array_size);
+
+    const attribute = new BufferAttribute(destination_array, itemSize);
+
+    attribute.normalized = source_attribute.normalized;
+    attribute.name = source_attribute.name;
+
+    // copy data
+    for (let i = 0; i < item_count; i++) {
+        for (let j = 0; j < itemSize; j++) {
+            destination_array[i * itemSize + j] = source_data_array[i * stride + offset + j];
+        }
+    }
+
+    return attribute;
+}

package/engine/graphics/geometry/buffered/deinterleaveBufferGeometry.js

@@ -0,0 +1,50 @@
+import { BufferGeometry } from "three";
+import { deinterleaveBufferAttribute } from "./deinterleaveBufferAttribute.js";
+
+/**
+ *
+ * @param {THREE.BufferGeometry} geometry
+ * @returns {THREE.BufferGeometry}
+ */
+export function deinterleaveBufferGeometry(geometry) {
+    const result = new BufferGeometry();
+
+    if (geometry.getIndex() !== null) {
+        result.setIndex(deinterleaveBufferAttribute(geometry.getIndex()));
+    }
+
+    for (const attribute_key in geometry.attributes) {
+        const source_attribute = geometry.attributes[attribute_key];
+
+        result.setAttribute(attribute_key, deinterleaveBufferAttribute(source_attribute));
+    }
+
+    // copy other bits
+    result.name = geometry.name;
+
+    result.morphTargetsRelative = geometry.morphTargetsRelative;
+
+    for (const attribute_key in geometry.morphAttributes) {
+        const source_attributes = geometry.morphAttributes[attribute_key];
+
+        const result_attributes = [];
+
+        result.morphAttributes[attribute_key] = result_attributes;
+
+        for (let i = 0; i < source_attributes.length; i++) {
+            const source_attribute = source_attributes[i];
+            result_attributes[i] = deinterleaveBufferAttribute(source_attribute);
+        }
+    }
+
+    result.groups = geometry.groups.slice();
+
+
+    result.boundingBox = geometry.boundingBox !== null ? geometry.boundingBox.clone() : null;
+    result.boundingSphere = geometry.boundingSphere !== null ? geometry.boundingSphere.clone() : null;
+    result.drawRange.start = geometry.drawRange.start;
+    result.drawRange.count = geometry.drawRange.count;
+    result.userData = JSON.parse(JSON.stringify(geometry.userData));
+
+    return result;
+}

package/engine/graphics/micron/MICRON_GEOMETRY_FIELD.js

@@ -0,0 +1 @@
+export const MICRON_GEOMETRY_FIELD = '@micron_geometry';

package/engine/graphics/micron/MICRON_URI_FIELD.js

@@ -0,0 +1 @@
+export const MICRON_URI_FIELD = '@micron_path';

package/engine/graphics/micron/build/buildMicronGeometryFromBufferGeometry.js

@@ -12,6 +12,7 @@ import { expandConnectivityByLocality } from "../../../../core/geom/3d/topology/
 import { build_geometry_info } from "./build_geometry_info.js";
 import { build_leaf_patches_metis } from "./clustering/build_leaf_patches_metis.js";
 import { compute_buffer_geometry_byte_size } from "../../geometry/buffered/compute_buffer_geometry_byte_size.js";
+import { deinterleaveBufferGeometry } from "../../geometry/buffered/deinterleaveBufferGeometry.js";
 
 /**
  * Returns current time in milliseconds
@@ -105,11 +106,13 @@ const PRINT_VERBOSE_STATS = false;
  * @returns {MicronGeometry}
  */
 export async function buildMicronGeometryFromBufferGeometry(input) {
+    const source_geometry = deinterleaveBufferGeometry(input);
+
     // build topology representation
     const topoMesh = new TopoMesh();
 
-    const position_attribute = input.getAttribute("position");
-    const index_attribute = input.index;
+    const position_attribute = source_geometry.getAttribute("position");
+    const index_attribute = source_geometry.index;
 
     const face_index_array = index_attribute.array;
     const vertex_position_array = position_attribute.array;
@@ -183,18 +186,18 @@ export async function buildMicronGeometryFromBufferGeometry(input) {
 
     const r = new MicronGeometry();
 
-    r.proxy = input; // TODO use r.buildProxy(1) instead
+    r.proxy = source_geometry; // TODO use r.buildProxy(1) instead
 
     r.source_triangle_count = index_attribute.count / 3;
-    r.source_vertex_count = input.getAttribute('position').count;
-    r.source_byte_size = compute_buffer_geometry_byte_size(input);
+    r.source_vertex_count = source_geometry.getAttribute('position').count;
+    r.source_byte_size = compute_buffer_geometry_byte_size(source_geometry);
 
     // console.time('build geometry');
 
-    const vertex_attributes = attributes_from_buffer_geometry(input);
+    const vertex_attributes = attributes_from_buffer_geometry(source_geometry);
 
     r.vertex_spec.setAttributes(vertex_attributes);
-    r.root = compilePatchGraph(root, input, r.vertex_spec);
+    r.root = compilePatchGraph(root, source_geometry, r.vertex_spec);
 
     r.initialize();
 

package/engine/graphics/micron/convert_three_object_to_micron.js

@@ -4,6 +4,7 @@ import { computeGeometryEquality } from "../../asset/loaders/geometry/geometry/c
 import { buildMicronGeometryFromBufferGeometry } from "./build/buildMicronGeometryFromBufferGeometry.js";
 import { ThreeMicronMesh } from "./format/ThreeMicronMesh.js";
 import { AsyncMapWrapper } from "../../../core/collection/map/AsyncMapWrapper.js";
+import { MICRON_GEOMETRY_FIELD } from "./MICRON_GEOMETRY_FIELD.js";
 
 /**
  *
@@ -19,7 +20,6 @@ const pending_cache = new HashMap({
     keyEqualityFunction: computeGeometryEquality
 });
 
-
 /**
  *
  * @param {THREE.Object3D} object
@@ -36,10 +36,22 @@ export async function convert_three_object_to_micron(object, micron_cache = defa
      * @returns {MicronGeometry}
      */
     async function obtain_geometry(g) {
-        const existing = await micron_cache.get(g);
+        const attached_micron = g[MICRON_GEOMETRY_FIELD];
 
-        if (existing !== undefined && existing !== null) {
-            return existing;
+        if (attached_micron !== undefined && attached_micron.isMicronGeometry) {
+            // micron geometry is already attached, use it
+            return attached_micron;
+        }
+
+        const cached_micron = await micron_cache.get(g);
+
+
+        if (cached_micron !== undefined && cached_micron !== null) {
+
+            // set proxy
+            cached_micron.proxy = g;
+
+            return cached_micron;
         }
 
         const pending = pending_cache.get(g);
@@ -54,8 +66,14 @@ export async function convert_three_object_to_micron(object, micron_cache = defa
 
         promises.push(micron_geometry_promise);
 
+        /**
+         *
+         * @type {MicronGeometry}
+         */
         const micron_geometry = await micron_geometry_promise;
 
+        micron_geometry.proxy = g;
+
         await micron_cache.set(g, micron_geometry);
 
         return micron_geometry;
@@ -90,7 +108,15 @@ export async function convert_three_object_to_micron(object, micron_cache = defa
             && !mesh.isSkinnedMesh // skinned meshes not supported
         ) {
 
-            const micronGeometry = await obtain_geometry(mesh.geometry);
+            let micronGeometry;
+            try {
+                micronGeometry = await obtain_geometry(mesh.geometry);
+            } catch (e) {
+                console.error(`Failed to convert geometry to micron, skipping : ${e}`);
+
+                // return original
+                return mesh;
+            }
 
             const micron_mesh = new ThreeMicronMesh(micronGeometry, mesh.material);
 

package/engine/graphics/micron/format/MicronGeometry.d.ts

@@ -1,5 +1,9 @@
 import {BufferGeometry} from "three";
+import {VertexDataSpec} from "../../geometry/VertexDataSpec";
 
 export class MicronGeometry {
+    vertex_spec: VertexDataSpec
     public proxy: BufferGeometry
+
+    initialize(): void
 }

package/engine/graphics/micron/format/MicronGeometry.js

@@ -117,3 +117,9 @@ export class MicronGeometry {
         return this.__patches[id];
     }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+MicronGeometry.prototype.isMicronGeometry = true;