@woosh/meep-engine 2.33.63 → 2.33.68

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/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/geometry/buffered/query/ClippingPlaneContainmentComputingVisitor.js

@@ -79,21 +79,32 @@ export class ClippingPlaneContainmentComputingVisitor extends GeometrySpatialAcc
 
             const index3 = index * 3;
 
-            const a = this.__buffer_indices[index3] * 3;
-            const b = this.__buffer_indices[index3 + 1] * 3;
-            const c = this.__buffer_indices[index3 + 2] * 3;
+            const indices = this.__buffer_indices;
 
-            const ax = this.__buffer_vertices[a];
-            const ay = this.__buffer_vertices[a + 1];
-            const az = this.__buffer_vertices[a + 2];
+            const a = indices[index3];
+            const b = indices[index3 + 1];
+            const c = indices[index3 + 2];
 
-            const bx = this.__buffer_vertices[b];
-            const by = this.__buffer_vertices[b + 1];
-            const bz = this.__buffer_vertices[b + 2];
+            const vertices = this.__buffer_vertices;
 
-            const cx = this.__buffer_vertices[c];
-            const cy = this.__buffer_vertices[c + 1];
-            const cz = this.__buffer_vertices[c + 2];
+            const stride = this.__buffer_vertex_stride;
+            const offset = this.__buffer_position_offset;
+
+            const a_address = a * stride + offset;
+            const b_address = b * stride + offset;
+            const c_address = c * stride + offset;
+
+            const ax = vertices[a_address];
+            const ay = vertices[a_address + 1];
+            const az = vertices[a_address + 2];
+
+            const bx = vertices[b_address];
+            const by = vertices[b_address + 1];
+            const bz = vertices[b_address + 2];
+
+            const cx = vertices[c_address];
+            const cy = vertices[c_address + 1];
+            const cz = vertices[c_address + 2];
 
             for (let i = 0; i < plane_count; i++) {
                 const plane = planes[i];
@@ -108,15 +119,9 @@ export class ClippingPlaneContainmentComputingVisitor extends GeometrySpatialAcc
                     plane_normal_y,
                     plane_normal_z,
                     plane_constant,
-                    ax,
-                    ay,
-                    az,
-                    bx,
-                    by,
-                    bz,
-                    cx,
-                    cy,
-                    cz
+                    ax, ay, az,
+                    bx, by, bz,
+                    cx, cy, cz
                 );
 
                 if (side === -3) {
@@ -163,12 +168,8 @@ export class ClippingPlaneContainmentComputingVisitor extends GeometrySpatialAcc
                     plane_normal_z,
                     plane_constant,
 
-                    x0,
-                    y0,
-                    z0,
-                    x1,
-                    y1,
-                    z1
+                    x0, y0, z0,
+                    x1, y1, z1
                 );
 
                 if (side === -2) {

package/engine/graphics/geometry/buffered/query/GeometryVisitor.js

@@ -1,6 +1,6 @@
 import { IndexedBinaryBVHVisitor } from "../../../../../core/bvh2/binary/IndexedBinaryBVHVisitor.js";
 
-export class GeometrySpatialAcceleratorVisitor extends IndexedBinaryBVHVisitor{
+export class GeometrySpatialAcceleratorVisitor extends IndexedBinaryBVHVisitor {
     constructor() {
         super();
 
@@ -25,6 +25,20 @@ export class GeometrySpatialAcceleratorVisitor extends IndexedBinaryBVHVisitor{
          */
         this.__buffer_vertices = null;
 
+        /**
+         *
+         * @type {number}
+         * @protected
+         */
+        this.__buffer_vertex_stride = 3;
+
+        /**
+         *
+         * @type {number}
+         * @protected
+         */
+        this.__buffer_position_offset = 0;
+
         /**
          * @protected
          * @type {IndexedBinaryBVH}
@@ -47,7 +61,20 @@ export class GeometrySpatialAcceleratorVisitor extends IndexedBinaryBVHVisitor{
         this.geometry = geometry;
 
         this.__buffer_indices = geometry.getIndex().array;
-        this.__buffer_vertices = geometry.getAttribute('position').array;
+
+        const position_attribute = geometry.getAttribute('position');
+
+        if (position_attribute.isInterleavedBufferAttribute) {
+            const data = position_attribute.data;
+
+            this.__buffer_vertices = data.array;
+            this.__buffer_vertex_stride = data.stride;
+            this.__buffer_position_offset = position_attribute.offset;
+        } else {
+            this.__buffer_vertices = position_attribute.array;
+            this.__buffer_vertex_stride = 3;
+            this.__buffer_position_offset = 0;
+        }
     }
 
 }

package/engine/graphics/geometry/buffered/query/RaycastNearestHitComputingVisitor.js

@@ -96,21 +96,32 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
 
             const index3 = index * 3;
 
-            const a = this.__buffer_indices[index3] * 3;
-            const b = this.__buffer_indices[index3 + 1] * 3;
-            const c = this.__buffer_indices[index3 + 2] * 3;
+            const indices = this.__buffer_indices;
 
-            const ax = this.__buffer_vertices[a];
-            const ay = this.__buffer_vertices[a + 1];
-            const az = this.__buffer_vertices[a + 2];
+            const a = indices[index3];
+            const b = indices[index3 + 1];
+            const c = indices[index3 + 2];
 
-            const bx = this.__buffer_vertices[b];
-            const by = this.__buffer_vertices[b + 1];
-            const bz = this.__buffer_vertices[b + 2];
+            const vertices = this.__buffer_vertices;
 
-            const cx = this.__buffer_vertices[c];
-            const cy = this.__buffer_vertices[c + 1];
-            const cz = this.__buffer_vertices[c + 2];
+            const stride = this.__buffer_vertex_stride;
+            const offset = this.__buffer_position_offset;
+
+            const a_address = a * stride + offset;
+            const b_address = b * stride + offset;
+            const c_address = c * stride + offset;
+
+            const ax = vertices[a_address];
+            const ay = vertices[a_address + 1];
+            const az = vertices[a_address + 2];
+
+            const bx = vertices[b_address];
+            const by = vertices[b_address + 1];
+            const bz = vertices[b_address + 2];
+
+            const cx = vertices[c_address];
+            const cy = vertices[c_address + 1];
+            const cz = vertices[c_address + 2];
 
             if (computeTriangleRayIntersection(
                 this.__temp_hit,
@@ -120,15 +131,9 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
                 rayDirection.x,
                 rayDirection.y,
                 rayDirection.z,
-                ax,
-                ay,
-                az,
-                bx,
-                by,
-                bz,
-                cx,
-                cy,
-                cz
+                ax, ay, az,
+                bx, by, bz,
+                cx, cy, cz
             )) {
                 const d = this.__temp_hit.position.distanceSqrTo(rayOrigin);
 
@@ -154,12 +159,8 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
             const z1 = data[address + 5];
 
             return intersectRay(
-                x0,
-                y0,
-                z0,
-                x1,
-                y1,
-                z1,
+                x0, y0, z0,
+                x1, y1, z1,
 
                 rayOrigin.x,
                 rayOrigin.y,

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();