@woosh/meep-engine 2.43.3 → 2.43.4

package/engine/graphics/sh3/prototypeSH3Probe.js

@@ -0,0 +1,427 @@
+import { EngineHarness } from "../../EngineHarness.js";
+import { seededRandom } from "../../../core/math/random/seededRandom.js";
+import { ShadedGeometrySystem } from "../ecs/mesh-v2/ShadedGeometrySystem.js";
+import { GizmoRenderingPlugin } from "../render/gizmo/GizmoRenderingPlugin.js";
+import { LightProbeVolume } from "./LightProbeVolume.js";
+import EntityBuilder from "../../ecs/EntityBuilder.js";
+import { ShadedGeometry } from "../ecs/mesh-v2/ShadedGeometry.js";
+import {
+    ClampToEdgeWrapping,
+    DataTexture,
+    LinearFilter,
+    MeshBasicMaterial,
+    MeshStandardMaterial,
+    NearestFilter,
+    PlaneBufferGeometry,
+    RGBAFormat,
+    UnsignedByteType
+} from "three";
+import { Transform } from "../../ecs/transform/Transform.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
+import { is_typed_array_equals } from "../../../core/collection/array/typed/is_typed_array_equals.js";
+import { array_copy } from "../../../core/collection/array/copyArray.js";
+import { randomFloatBetween } from "../../../core/math/random/randomFloatBetween.js";
+import { GLTFAssetLoader } from "../../asset/loaders/GLTFAssetLoader.js";
+import { three_object_to_entity_composition } from "../ecs/mesh-v2/three_object_to_entity_composition.js";
+import { TransformAttachmentSystem } from "../../ecs/transform-attachment/TransformAttachmentSystem.js";
+import { ShadedGeometryFlags } from "../ecs/mesh-v2/ShadedGeometryFlags.js";
+import { AABB3 } from "../../../core/bvh2/aabb3/AABB3.js";
+import { delay } from "../../../core/process/delay.js";
+import { make_justified_point_grid } from "../../../core/geom/3d/util/make_justified_point_grid.js";
+import LightSystem from "../ecs/light/LightSystem.js";
+import { Light } from "../ecs/light/Light.js";
+import { LightType } from "../ecs/light/LightType.js";
+
+/**
+ *
+ * @param {Storage} storage
+ * @param {*} component
+ * @param {BinaryClassSerializationAdapter} adapter
+ * @param {string} key
+ * @param {Signal[]} signals
+ */
+async function persist_component(storage, component, adapter, key = 'temp', signals) {
+
+
+    const current_state = new BinaryBuffer();
+
+    const full_key = `persisted_transform:${key}`;
+
+    if (await storage.promiseContains(full_key)) {
+
+        const loaded = await storage.promiseLoadBinary(full_key);
+
+        const buffer = BinaryBuffer.fromArrayBuffer(loaded);
+
+        adapter.deserialize(buffer, component);
+    }
+
+    // make a binary state copy
+    adapter.serialize(current_state, component);
+
+
+    for (let i = 0; i < signals.length; i++) {
+        signals[i].add(store);
+    }
+
+    function store() {
+
+        const buffer = new BinaryBuffer();
+
+        adapter.serialize(buffer, component);
+
+        buffer.trim();
+
+
+        if (!is_typed_array_equals(current_state.__data_uint8, buffer.__data_uint8)) {
+            // change detected
+
+            storage.promiseStoreBinary(full_key, buffer.data);
+
+
+            current_state.setCapacity(buffer.length);
+            array_copy(buffer.__data_uint8, 0, current_state.__data_uint8, 0, buffer.length);
+        }
+    }
+
+
+}
+
+/**
+ *
+ * @param {number|Vector3} scale
+ * @param {Vector3} offset
+ * @param {Vector3} direction
+ * @param up
+ * @param shadow
+ * @param material
+ * @param {Engine} engine
+ */
+function make_plane({
+                        scale,
+                        offset,
+                        direction = Vector3.forward,
+                        up = Vector3.up,
+                        shadow = true,
+                        material = new MeshBasicMaterial({ color: 0xFFFFFF }),
+                        engine
+                    }) {
+
+    const t1 = Transform.fromJSON({
+        position: offset,
+        scale: scale
+    });
+    t1.rotation.lookRotation(direction, up);
+
+    if (engine) {
+        material = engine.graphics.getMaterialManager().obtain(material).getValue();
+    }
+
+    const sg = ShadedGeometry.from(new PlaneBufferGeometry(), material);
+
+    sg.writeFlag(ShadedGeometryFlags.CastShadow, shadow);
+    sg.writeFlag(ShadedGeometryFlags.ReceiveShadow, shadow);
+
+    return new EntityBuilder()
+        .add(sg)
+        .add(t1);
+
+}
+
+function make_cornel_box(ecd) {
+
+
+    make_plane({
+        scale: 20,
+        offset: new Vector3(10, 10, 0),
+        direction: Vector3.forward,
+        material: new MeshBasicMaterial({ color: 0xFF0000 })
+    }).build(ecd);
+    make_plane({
+        scale: 20,
+        offset: new Vector3(10, 10, 20),
+        direction: Vector3.left,
+        material: new MeshBasicMaterial({ color: 0x00FF00 })
+    }).build(ecd);
+    make_plane({
+        scale: 20,
+        offset: new Vector3(0, 10, 10),
+        direction: Vector3.right,
+        material: new MeshBasicMaterial({ color: 0xFFFFFF })
+    }).build(ecd);
+
+}
+
+function make_test_texture(t = 1) {
+    const t1 = (1 - t) * 0.5;
+    const tex = new DataTexture(new Uint8ClampedArray([
+        255 * t, 255 * t1, 255 * t1, 255,
+        255 * t1, 255 * t, 255 * t1, 255,
+        255 * t1, 255 * t1, 255 * t, 255,
+        255 * t, 255 * t, 255 * t1, 255
+    ]), 2, 2, RGBAFormat, UnsignedByteType);
+
+    tex.flipY = false;
+    tex.wrapS = ClampToEdgeWrapping;
+    tex.wrapT = ClampToEdgeWrapping;
+    tex.magFilter = NearestFilter;
+    tex.minFilter = LinearFilter;
+    tex.generateMipmaps = false;
+
+    tex.needsUpdate = true;
+
+    return tex;
+}
+
+/**
+ *
+ * @param {Engine} engine
+ * @return {Promise<void>}
+ */
+async function main(engine) {
+    await EngineHarness.buildBasics({
+        engine,
+        enableWater: false,
+        enableTerrain: false,
+        enableLights: false,
+        cameraFarDistance: 200,
+        focus: { x: 0, y: 0, z: 0 },
+        pitch: 0.5500000000000453,
+        yaw: -2.4300000000000566,
+        distance: 10,
+        shadowmapResolution: 4096
+    });
+
+    const ecd = engine.entityManager.dataset;
+
+
+    // const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
+    const path = 'data/models/sibenik/model.gltf';
+    // const path = 'data/models/sponza-pbr/gltf/sponza.glb';
+    // const path = 'data/models/LowPolyTownshipSet/Town_Hall/model.gltf';
+    // const path = 'data/models/Slaughter Mech/Slaugter Mech.gltf';
+
+    const mesh_asset = await engine.assetManager.promise(path, 'gltf');
+    const gltf = mesh_asset.gltf;
+
+
+    const composition = three_object_to_entity_composition(gltf.scene);
+
+    composition.traverse(n => {
+
+        /**
+         * @type {ShadedGeometry}
+         */
+        const sg = n.entity.getComponent(ShadedGeometry);
+
+        if (sg !== null) {
+            sg.setFlag(ShadedGeometryFlags.CastShadow);
+            sg.setFlag(ShadedGeometryFlags.ReceiveShadow);
+        }
+    });
+
+
+    // model_bounds.setNegativelyInfiniteBounds();
+    // composition.traverse((n) => {
+    //
+    //     /**
+    //      * @type {ShadedGeometry}
+    //      */
+    //     const sg = n.entity.getComponent(ShadedGeometry);
+    //
+    //     if (sg !== null) {
+    //         const aabb3 = new AABB3();
+    //         sg.getBoundingBox(aabb3);
+    //
+    //         model_bounds.expandToFit(aabb3);
+    //     }
+    // })
+
+    composition.transform.scale.setScalar(1);
+    composition.transform.position.set(0, -mesh_asset.boundingBox.y0, 0);
+
+    composition.build(ecd);
+
+    const model_footprint = Math.hypot(mesh_asset.boundingBox.getExtentsX(), mesh_asset.boundingBox.getExtentsY(), mesh_asset.boundingBox.getExtentsZ());
+
+
+    make_plane({
+        engine,
+        scale: 2 * model_footprint,
+        offset: new Vector3(0, 0, 0),
+        direction: Vector3.up,
+        up: Vector3.forward,
+        material: new MeshStandardMaterial({
+            color: 0x111111,
+            // map: make_test_texture()
+        })
+    }).build(ecd);
+
+    //
+    // make_plane({
+    //     scale: 3 * model_footprint,
+    //     offset: new Vector3(0, mesh_asset.boundingBox.y1 + 2, 0),
+    //     direction: Vector3.down,
+    //     up: Vector3.forward,
+    //     shadow: false,
+    //     material: new MeshStandardMaterial({ color: '#c6f5ff' })
+    // }).build(ecd);
+
+    const points = [
+        0, 0, 0,
+        10, 0, 0,
+        10, 0, 10,
+        0, 0, 10,
+
+        0, 10, 0,
+        10, 10, 0,
+        10, 10, 10,
+        0, 10, 10,
+    ];
+
+    //
+    // new EntityBuilder()
+    //     .add(Transform.fromJSON({
+    //         position: {
+    //             x: mesh_asset.boundingBox.x0,
+    //             y: mesh_asset.boundingBox.getCenterY(),
+    //             z: mesh_asset.boundingBox.getCenterZ()
+    //         }
+    //     }))
+    //     .add(Light.fromJSON({
+    //         distance: model_footprint * 2,
+    //         type: LightType.POINT,
+    //         intensity: 10,
+    //         color: 0xFF0000
+    //     }))
+    //     .build(ecd);
+    //
+    // new EntityBuilder()
+    //     .add(Transform.fromJSON({
+    //         position: {
+    //             x: mesh_asset.boundingBox.x1,
+    //             y: mesh_asset.boundingBox.getCenterY(),
+    //             z: mesh_asset.boundingBox.getCenterZ()
+    //         }
+    //     }))
+    //     .add(Light.fromJSON({
+    //         distance: model_footprint * 2,
+    //         type: LightType.POINT,
+    //         intensity: 10,
+    //         color: '#00f7ff'
+    //     }))
+    //     .build(ecd);
+
+    const random = seededRandom();
+
+    for (let i = 0; i < 16; i++) {
+
+        new EntityBuilder()
+            .add(Transform.fromJSON({
+                position: {
+                    x: randomFloatBetween(random, mesh_asset.boundingBox.x0, mesh_asset.boundingBox.x1),
+                    y: randomFloatBetween(random, mesh_asset.boundingBox.y0, mesh_asset.boundingBox.y1),
+                    z: randomFloatBetween(random, mesh_asset.boundingBox.z0, mesh_asset.boundingBox.z1),
+                }
+            }))
+            .add(Light.fromJSON({
+                distance: model_footprint *0.2,
+                type: LightType.POINT,
+                intensity: 1,
+                color: `hsv(${random()},${1},1)`
+            }))
+            .build(ecd);
+    }
+
+
+    const lpv = new LightProbeVolume();
+
+    // lpv.add_point(10, 5, 10);
+
+    const desired_density = 15;
+
+
+    // const light_volume_bounds = new AABB3(-10, 0.5, -10, 10, 11, 10);
+    const probe_grid_spacing_dense = Math.min(mesh_asset.boundingBox.getExtentsX(), mesh_asset.boundingBox.getExtentsY(), mesh_asset.boundingBox.getExtentsZ()) / desired_density;
+    const probe_grid_spacing_sparse = Math.max(mesh_asset.boundingBox.getExtentsX(), mesh_asset.boundingBox.getExtentsY(), mesh_asset.boundingBox.getExtentsZ()) / desired_density;
+
+    const probe_grid_spacing = (probe_grid_spacing_sparse / probe_grid_spacing_dense) < 2 ? probe_grid_spacing_dense : probe_grid_spacing_sparse * 0.5;
+    //
+    // const probe_grid_spacing =desired_density/ (mesh_asset.boundingBox.getExtentsX()* mesh_asset.boundingBox.getExtentsY()* mesh_asset.boundingBox.getExtentsZ());
+
+    const model_bounds = new AABB3(-10, 0.5, -10, 10, 11, 10);
+    model_bounds.copy(mesh_asset.boundingBox);
+    model_bounds.grow(probe_grid_spacing * 1.1);
+
+
+    // sg_hierarchy_compute_bounding_box_via_parent_entity(light_volume_bounds, composition.entity.entity, ecd);
+
+    // for (let i = 0; i < 100; i++) {
+    //     lpv.add_point(
+    //         randomFloatBetween(random, light_volume_bounds.x0, light_volume_bounds.x1),
+    //         randomFloatBetween(random,  light_volume_bounds.y0, light_volume_bounds.y1),
+    //         randomFloatBetween(random,  light_volume_bounds.z0, light_volume_bounds.z1),
+    //     );
+    // }
+
+    make_justified_point_grid(model_bounds, probe_grid_spacing, (x, y, z) => {
+        lpv.add_point(x, y, z);
+    });
+
+    // lpv.add_point(10, 1, -10);
+
+    await delay(2000);
+
+    //
+    // console.profile('lpv build');
+    //
+    lpv.build(engine);
+    // console.profileEnd('lpv build');
+
+    // fill probes with random data
+    // for (let i = 0; i < lpv.__length * 27; i++) {
+    //     lpv.__probe_data[i] = random();
+    // }
+
+    // for (let i = 0; i < lpv.__length; i++) {
+    //
+    //     for (let j = 0; j < 9; j++) {
+    //         lpv.__probe_data[(i * 9 + j) * 3] = max2(0, (lpv.__positions[i * 3] + 10) / 20);
+    //         lpv.__probe_data[(i * 9 + j) * 3 + 1] = max2(0, (lpv.__positions[i * 3 + 1] - 0.5) / 10.5);
+    //         lpv.__probe_data[(i * 9 + j) * 3 + 2] = max2(0, (lpv.__positions[i * 3 + 2] + 10) / 20);
+    //     }
+    // }
+
+    // lpv.white_probe(0, [
+    //     0.7953949, 0.4405923, 0.5459412,
+    //     0.3981450, 0.3526911, 0.6097158,
+    //     -0.3424573, -0.1838151, -0.2715583,
+    //
+    //     -0.2944621, -0.0560606, 0.0095193,
+    //     -0.1123051, -0.0513088, -0.1232869,
+    //     -0.2645007, -0.2257996, -0.4785847,
+    //
+    //     -0.1569444, -0.0954703, -0.1485053,
+    //     0.5646247, 0.2161586, 0.1402643,
+    //     0.2137442, -0.0547578, -0.3061700], 0);
+
+
+    // lpv.visualize_mesh({ ecd: ecd });
+    lpv.visualize_probes({ ecd: ecd, size: probe_grid_spacing * 0.08 });
+
+
+    console.log(lpv);
+}
+
+new EngineHarness().initialize({
+    configuration(config, engine) {
+        config.addSystem(new ShadedGeometrySystem(engine));
+        config.addSystem(new TransformAttachmentSystem());
+        config.addSystem(new LightSystem(engine));
+
+        config.addLoader('gltf', new GLTFAssetLoader());
+
+        config.addPlugin(GizmoRenderingPlugin);
+    }
+}).then(main);

package/engine/graphics/sh3/visualise_probe.js

@@ -0,0 +1,40 @@
+import { SH3VisualisationMaterial } from "./SH3VisualisationMaterial.js";
+import EntityBuilder from "../../ecs/EntityBuilder.js";
+import { Transform } from "../../ecs/transform/Transform.js";
+import { ShadedGeometry } from "../ecs/mesh-v2/ShadedGeometry.js";
+import { OctahedronBufferGeometry } from "three";
+import { ShadedGeometryFlags } from "../ecs/mesh-v2/ShadedGeometryFlags.js";
+
+/**
+ *
+ * @param {number} [size]
+ * @param position
+ * @param position_offset
+ * @param sh
+ * @param sh_offset
+ * @return {EntityBuilder}
+ */
+export function visualise_probe({ size = 1,shadow=false, position, position_offset = 0, sh, sh_offset = 0 }) {
+
+    const mat = new SH3VisualisationMaterial();
+
+    for (let i = 0; i < 9; i++) {
+        mat.uniforms.sh.value[i].fromArray(sh, sh_offset + i * 3);
+    }
+
+    const shadedGeometry = ShadedGeometry.from(new OctahedronBufferGeometry(1, 5), mat);
+
+    shadedGeometry.writeFlag(ShadedGeometryFlags.ReceiveShadow,shadow);
+    shadedGeometry.writeFlag(ShadedGeometryFlags.CastShadow,shadow);
+
+    return new EntityBuilder()
+        .add(Transform.fromJSON({
+            position: {
+                x: position[position_offset],
+                y: position[position_offset + 1],
+                z: position[position_offset + 2],
+            },
+            scale: size
+        }))
+        .add(shadedGeometry);
+}

package/engine/graphics/texture/atlas/TextureAtlas.js

@@ -20,11 +20,16 @@ export class TextureAtlas extends AbstractTextureAtlas {
      *
      * @param {number} [size]
      * @param {DataType} [data_type]
+     * @param {number} [channel_count]
      * @constructor
      */
-    constructor(size = 16, data_type = DataType.Uint8) {
+    constructor(size = 16, data_type = DataType.Uint8, channel_count = 4) {
         super();
 
+        assert.isNonNegativeInteger(size, 'size');
+        assert.enum(data_type, DataType, 'data_type');
+        assert.isNonNegativeInteger(channel_count, 'channel_count');
+
         /**
          *
          * @type {IdPool}
@@ -46,8 +51,6 @@ export class TextureAtlas extends AbstractTextureAtlas {
 
         const TypeArrayConstructor = DataType2TypedArrayConstructorMapping[data_type];
 
-        const channel_count = 4;
-
         /**
          * @private
          * @readonly
@@ -150,6 +153,9 @@ export class TextureAtlas extends AbstractTextureAtlas {
      * @returns {boolean} true if resizing successful, false otherwise
      */
     resize(x, y) {
+        assert.isNonNegativeInteger(x, 'x');
+        assert.isNonNegativeInteger(y, 'y');
+
         //check if any patches would be cut
         const patches = this.patches;
         const numPatches = patches.length;
@@ -255,6 +261,12 @@ export class TextureAtlas extends AbstractTextureAtlas {
      * @return {AtlasPatch}
      */
     add(sampler, padding = 4) {
+
+        assert.notNull(sampler, 'sampler');
+        assert.defined(sampler, 'sampler');
+
+        assert.isNonNegativeInteger(padding, 'padding');
+
         // console.log('#add');
 
         const patch = new AtlasPatch();

package/engine/intelligence/blackboard/AbstractBlackboard.d.ts

@@ -1,5 +1,5 @@
 import ObservedBoolean from "../../../core/model/ObservedBoolean";
-import {Vector1} from "../../../core/geom/Vector1";
+import Vector1 from "../../../core/geom/Vector1";
 import ObservedString from "../../../core/model/ObservedString";
 
 export class AbstractBlackboard {

package/package.json

@@ -5,12 +5,13 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.43.3",
+  "version": "2.43.4",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",
     "opentype.js": "1.3.3",
     "simplex-noise": "2.4.0",
+    "robust-predicates": "3.0.1",
     "three": "^0.135.0"
   },
   "devDependencies": {