@woosh/meep-engine 2.35.2 → 2.35.3

package/core/geom/3d/SurfacePoint3.js

@@ -1,9 +1,6 @@
-import Quaternion from "../Quaternion.js";
 import Vector3 from "../Vector3.js";
 import { v3_length } from "../v3_length.js";
 
-const q = new Quaternion();
-
 /**
  * Used for representing points on a 3D surface. Used for raycasting contacts
  */
@@ -25,9 +22,12 @@ export class SurfacePoint3 {
         const p_y = p.y;
         const p_z = p.z;
 
-        const result_p_x = m4[0] * p_x + m4[4] * p_y + m4[8] * p_z + m4[12];
-        const result_p_y = m4[1] * p_x + m4[5] * p_y + m4[9] * p_z + m4[13];
-        const result_p_z = m4[2] * p_x + m4[6] * p_y + m4[10] * p_z + m4[14];
+        // compute perspective projection
+        const w = 1 / (m4[3] * p_x + m4[7] * p_y + m4[11] * p_z + m4[15]);
+
+        const result_p_x = (m4[0] * p_x + m4[4] * p_y + m4[8] * p_z + m4[12]) * w;
+        const result_p_y = (m4[1] * p_x + m4[5] * p_y + m4[9] * p_z + m4[13]) * w;
+        const result_p_z = (m4[2] * p_x + m4[6] * p_y + m4[10] * p_z + m4[14]) * w;
 
         this.position.set(
             result_p_x,

package/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js

@@ -9,6 +9,7 @@ import { returnTrue } from "../../../../core/function/Functions.js";
 import { aabb3_intersects_ray } from "../../../../core/bvh2/aabb3/aabb3_intersects_ray.js";
 import { ShadedGeometryRendererContext } from "./render/ShadedGeometryRendererContext.js";
 import { BinaryNode } from "../../../../core/bvh2/BinaryNode.js";
+import { assert } from "../../../../core/assert.js";
 
 /**
  *
@@ -66,6 +67,58 @@ export class ShadedGeometrySystem extends System {
 
         this.__bvh = new BinaryNode();
         this.__bvh.setNegativelyInfiniteBounds();
+
+        /**
+         *
+         * @type {Map<number, function():AbstractRenderAdapter>}
+         * @private
+         */
+        this.__adapter_suppliers = new Map();
+    }
+
+    /**
+     *
+     * @param {number} index
+     * @param {function():AbstractRenderAdapter} supplier
+     */
+    register_render_adapter(index, supplier) {
+        assert.isNonNegativeInteger(index, 'index');
+
+        if (this.__adapter_suppliers.has(index)) {
+            // slot is already taken
+            console.warn(`Render adapter slot '${index}' is already taken, removing old adapter`);
+            this.unregister_render_adapter(index);
+        }
+
+        this.__adapter_suppliers.set(index, supplier);
+
+        this.__view_contexts.forEach((value, key) => {
+            value.setAdapter(index, supplier());
+        });
+    }
+
+    /**
+     *
+     * @param {number} index
+     * @return {boolean}
+     */
+    unregister_render_adapter(index) {
+        assert.isNonNegativeInteger(index, 'index');
+
+        const supplier = this.__adapter_suppliers.get(index);
+
+        if (supplier === undefined) {
+            // not found
+            return false;
+        }
+
+        this.__adapter_suppliers.delete(index);
+
+        this.__view_contexts.forEach((value, key) => {
+            value.removeAdapter(index);
+        });
+
+        return true;
     }
 
     /**
@@ -74,7 +127,14 @@ export class ShadedGeometrySystem extends System {
      * @private
      */
     __handle_view_added(view) {
-        this.__view_contexts.set(view, new ShadedGeometryRendererContext());
+        const ctx = new ShadedGeometryRendererContext();
+
+        // attach adapters
+        this.__adapter_suppliers.forEach((value, key) => {
+            ctx.setAdapter(key, value());
+        });
+
+        this.__view_contexts.set(view, ctx);
     }
 
     /**

package/engine/graphics/ecs/mesh-v2/render/ShadedGeometryRendererContext.js

@@ -1,7 +1,8 @@
 import { queryBinaryNode_FrustumIntersections_Data } from "../../../../../core/bvh2/traversal/queryBinaryNode_FrustumIntersections.js";
-import { AbstractRenderAdapter } from "./AbstractRenderAdapter.js";
-import { InstancedRendererAdapter } from "./InstancedRendererAdapter.js";
-import { GenericRendererAdapter } from "./GenericRendererAdapter.js";
+import { AbstractRenderAdapter } from "./adapters/AbstractRenderAdapter.js";
+import { InstancedRendererAdapter } from "./adapters/InstancedRendererAdapter.js";
+import { GenericRendererAdapter } from "./adapters/GenericRendererAdapter.js";
+import { assert } from "../../../../../core/assert.js";
 
 /**
  * 1 - collect visible meshes
@@ -19,7 +20,16 @@ export class ShadedGeometryRendererContext {
         ];
     }
 
+    /**
+     *
+     * @param {number} index
+     * @param {AbstractRenderAdapter} adapter
+     */
     setAdapter(index, adapter) {
+        assert.isNonNegativeInteger(index, 'index');
+        assert.defined(adapter, 'adapter');
+        assert.equal(adapter.isShadedGeometryRenderAdapter, true, 'adapter.isShadedGeometryRenderAdapter !== true');
+
         const existing = this.adapters[index];
         if (existing !== undefined) {
             // dispose of existing adapter
@@ -29,14 +39,36 @@ export class ShadedGeometryRendererContext {
         this.adapters[index] = adapter;
     }
 
+    /**
+     *
+     * @param {number} index
+     * @returns {boolean}
+     */
+    removeAdapter(index) {
+        assert.isNonNegativeInteger(index, 'index');
+
+        const adapter = this.adapters[index];
+
+        if (adapter === undefined) {
+            return false;
+        }
+
+        delete this.adapters[index];
+
+        adapter.dispose();
+
+        return true;
+    }
+
     /**
      *
      * @param {THREE.Object3D[]} destination
      * @param {number} destination_offset
+     * @param {THREE.WebGLRenderer} renderer
      * @param {CameraView} view
      * @param {BinaryNode<ShadedGeometry>} bvh
      */
-    collect(destination, destination_offset, view, bvh) {
+    collect(destination, destination_offset, renderer, view, bvh) {
         const adapters = this.adapters;
         const adapter_count = adapters.length;
 
@@ -44,7 +76,7 @@ export class ShadedGeometryRendererContext {
         for (; i < adapter_count; i++) {
             const adapter = adapters[i];
 
-            adapter.build_start();
+            adapter.build_start(renderer);
         }
 
 

package/engine/graphics/ecs/mesh-v2/render/{AbstractRenderAdapter.js → adapters/AbstractRenderAdapter.js}

@@ -35,7 +35,13 @@ export class AbstractRenderAdapter {
         throw new Error('Not Implemented');
     }
 
-    build_start() {
+
+    /**
+     *
+     * @param {THREE.WebGLRenderer} renderer
+     * @param {CameraView} view
+     */
+    build_start(renderer, view) {
 
     }
 
@@ -65,3 +71,9 @@ export class AbstractRenderAdapter {
 
     }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+AbstractRenderAdapter.prototype.isShadedGeometryRenderAdapter = true;

package/engine/graphics/ecs/mesh-v2/render/{GenericRendererAdapter.js → adapters/GenericRendererAdapter.js}

@@ -1,6 +1,6 @@
 import { AbstractRenderAdapter } from "./AbstractRenderAdapter.js";
-import { array_copy } from "../../../../../core/collection/array/copyArray.js";
-import { build_three_object } from "../build_three_object.js";
+import { array_copy } from "../../../../../../core/collection/array/copyArray.js";
+import { build_three_object } from "../../build_three_object.js";
 
 export class GenericRendererAdapter extends AbstractRenderAdapter {
     constructor() {
@@ -19,7 +19,12 @@ export class GenericRendererAdapter extends AbstractRenderAdapter {
         return 0;
     }
 
-    build_start() {
+    /**
+     *
+     * @param {THREE.WebGLRenderer} renderer
+     * @param {CameraView} view
+     */
+    build_start(renderer, view) {
         this.clear();
     }
 

package/engine/graphics/ecs/mesh-v2/render/{InstancedRendererAdapter.js → adapters/InstancedRendererAdapter.js}

@@ -1,8 +1,8 @@
 import { AbstractRenderAdapter } from "./AbstractRenderAdapter.js";
-import { HashMap } from "../../../../../core/collection/HashMap.js";
-import { InstancedMeshGroup } from "../../../geometry/instancing/InstancedMeshGroup.js";
-import { ShadedGeometryFlags } from "../ShadedGeometryFlags.js";
-import { DrawMode } from "../DrawMode.js";
+import { HashMap } from "../../../../../../core/collection/HashMap.js";
+import { InstancedMeshGroup } from "../../../../geometry/instancing/InstancedMeshGroup.js";
+import { ShadedGeometryFlags } from "../../ShadedGeometryFlags.js";
+import { DrawMode } from "../../DrawMode.js";
 
 const INSTANCED_EQUALITY_FLAGS = ShadedGeometryFlags.CastShadow
     | ShadedGeometryFlags.ReceiveShadow
@@ -122,7 +122,12 @@ export class InstancedRendererAdapter extends AbstractRenderAdapter {
         this.__active_meshes.add(mesh);
     }
 
-    build_start() {
+    /**
+     *
+     * @param {THREE.WebGLRenderer} renderer
+     * @param {CameraView} view
+     */
+    build_start(renderer, view) {
         this.clear();
     }
 

package/engine/graphics/ecs/mesh-v2/three_object_to_entity_composition.js

@@ -22,7 +22,6 @@ export function three_object_to_entity_composition(root) {
         }
 
         const sg = ShadedGeometry.from(root.geometry, root.material);
-        sg.draw_method = 1;
 
         entity.add(sg);
     }

package/engine/graphics/micron/plugin/shaded_geometry/MicronShadedGeometryRenderAdapter.js

@@ -0,0 +1,150 @@
+import { AbstractRenderAdapter } from "../../../ecs/mesh-v2/render/adapters/AbstractRenderAdapter.js";
+import Vector2 from "../../../../../core/geom/Vector2.js";
+import { MaterialVertexSpec } from "../../render/v1/MaterialVertexSpec.js";
+
+/**
+ *
+ * @type {MaterialVertexSpec}
+ */
+const scratch_mvc = new MaterialVertexSpec();
+
+class MicronRenderContext {
+
+}
+
+export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
+    constructor({
+                    vgtr
+                }) {
+        super();
+
+        /**
+         * @type {VGThreeRenderer}
+         * @private
+         */
+        this.__vgtr = vgtr;
+
+        /**
+         *
+         * @type {VirtualGeometry|null}
+         * @private
+         */
+        this.__vg = null;
+
+        /**
+         *
+         * @type {VirtualGeometryBuilder|null}
+         * @private
+         */
+        this.__vgb = null;
+
+        /**
+         *
+         * @type {Map<number, MicronGeometry>}
+         * @private
+         */
+        this.__geometry_map = new Map();
+
+        /**
+         *
+         * @type {Set<MaterialContext>}
+         * @private
+         */
+        this.__active_contexts = new Set();
+    }
+
+    add(sg) {
+
+        const micron_geometry = this.__geometry_map.get(sg.geometry.id);
+
+        // populate virtual geometry for this instance
+        this.__vgb.buildForMesh(sg.entity, micron_geometry, sg.transform);
+
+    }
+
+    /**
+     *
+     * @param {THREE.WebGLRenderer} renderer
+     * @param {CameraView} view
+     */
+    build_start(renderer, view) {
+        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.__vgb;
+
+        vg_builder.resolution.set(resolution.x * pixelRatio, resolution.y * pixelRatio);
+        vg_builder.setMatricesFromCamera(view.camera);
+        vg_builder.setOutput(this.__vg);
+
+        vg_builder.build();
+    }
+
+    build_end() {
+        const contexts = this.__contexts_array;
+        const context_count = contexts.length;
+
+        /**
+         *
+         * @type {Map<number, MaterialContext>}
+         */
+        const instance_to_ctx = new Map();
+
+        for (let i = 0; i < context_count; i++) {
+            const ctx = contexts[i];
+            ctx.__patch_count = 0;
+
+            for (const instance of ctx.instances) {
+                instance_to_ctx.set(instance, ctx);
+            }
+        }
+
+        // sort patches into relevant contexts
+        const geometry = this.geometry;
+        const patch_count = geometry.patch_count;
+        const patches = geometry.patches;
+
+        for (let i = 0; i < patch_count; i++) {
+            const i3 = i * 3;
+
+            const instance_id = patches[i3];
+            const geometry_id = patches[i3 + 1];
+            const patch_id = patches[i3 + 2];
+
+            const ctx = instance_to_ctx.get(instance_id);
+
+            const target_address = ctx.__patch_count * 3;
+            ctx.__patch_count++;
+
+            const ctx_patches = ctx.__patches;
+
+            ctx_patches[target_address] = instance_id;
+            ctx_patches[target_address + 1] = geometry_id;
+            ctx_patches[target_address + 2] = patch_id;
+        }
+
+        // build each context
+        for (let i = 0; i < context_count; i++) {
+            const ctx = contexts[i];
+
+            ctx.build(this.geometry);
+        }
+    }
+
+    dispose() {
+
+    }
+}

package/engine/graphics/micron/render/VirtualGeometryBuilder.js

@@ -141,13 +141,11 @@ export class VirtualGeometryBuilder {
      * @param {number} instance_id
      * @param {MicronGeometry} geometry
      * @param {number[]} transform world transform matrix of the instance
-     * @param {ActivePatchList} apl
      */
     buildForMesh(
         instance_id,
         geometry,
-        transform,
-        apl
+        transform
     ) {
         refinement_spec.build(transform, this.view_projection_matrix);
 

package/engine/graphics/micron/render/instanced/ThreeInstancedAdapter.js

@@ -42,13 +42,6 @@ export class ThreeInstancedAdapter {
 
         this.__uniforms = Object.assign({}, this.__patch_data.genUniforms());
 
-        /**
-         *
-         * @type {WebGL2RenderingContext|null}
-         * @private
-         */
-        this.__gl_context = null;
-
         /**
          *
          * @type {Signal}

package/engine/graphics/micron/render/v1/MaterialContext.js

@@ -73,8 +73,7 @@ export class MaterialContext {
         return this.instances.has(occurrence.instance_id);
     }
 
-    init(gl) {
-        this.adapter.__gl_context = gl;
+    init() {
 
         const material = this.material.clone();
 

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

@@ -19,13 +19,6 @@ export class VGThreeRenderer {
 
         this.builder = new VirtualGeometryBuilder();
 
-        /**
-         *
-         * @type {WebGL2RenderingContext|null}
-         * @private
-         */
-        this.__gl_context = null;
-
         /**
          *
          * @type {Map<MaterialVertexSpec, MaterialContext>}
@@ -89,7 +82,7 @@ export class VGThreeRenderer {
 
         const ctx = new MaterialContext(spec, m);
 
-        ctx.init(this.__gl_context);
+        ctx.init();
 
         this.material_contexts.set(key, ctx);
         this.__contexts_array.push(ctx);

package/engine/graphics/particles/particular/engine/utils/volume/ParticleVolume.js

@@ -1,6 +1,5 @@
 import { ParticleEmitterFlag } from "../../emitter/ParticleEmitterFlag.js";
 import { PARTICLE_ATTRIBUTE_DEATH_AGE, PARTICLE_ATTRIBUTE_POSITION } from "../../emitter/PARTICLE_ATTRIBUTES.js";
-import { EmissionShapeType } from "../../emitter/EmissionShapeType.js";
 import { Matrix4 } from "three";
 import { composeMatrix4 } from "../../../../../util/composeMatrix4.js";
 import Quaternion from "../../../../../../../core/geom/Quaternion.js";
@@ -14,55 +13,6 @@ import { SerializationMetadata } from "../../../../../../ecs/components/Serializ
 import { UnitCubeShape3D } from "../../../../../../../core/geom/3d/shape/UnitCubeShape3D.js";
 import { shape_from_json } from "../../../../../../../core/geom/3d/shape/json/shape_from_json.js";
 
-/**
- *
- * @param {ParticleLayer} layer
- * @returns {number}
- */
-function computeLayerVolume(layer) {
-    let base_volume = 0;
-
-    switch (layer.emissionShape) {
-        case EmissionShapeType.Box:
-            base_volume = 1;
-            break;
-        case EmissionShapeType.Sphere:
-            base_volume = 0.5236;
-            break;
-        case EmissionShapeType.Point:
-            base_volume = 0;
-            break;
-    }
-
-    const scale_volume = layer.scale.x * layer.scale.y * layer.scale.z;
-
-    return base_volume * scale_volume;
-}
-
-/**
- *
- * @param {ParticleEmitter} emitter
- * @param {Transform} transform
- * @returns {number}
- */
-function computeEmitterVolume(emitter, transform) {
-
-    const layers = emitter.layers;
-    const n = layers.length;
-
-    let layer_volume_sum = 0;
-
-    for (let i = 0; i < n; i++) {
-        const particleLayer = layers.get(i);
-
-        layer_volume_sum += computeLayerVolume(particleLayer);
-    }
-
-    const scale_volume = transform.scale.x * transform.scale.y * transform.scale.z;
-
-    return layer_volume_sum * scale_volume;
-}
-
 const DEFAULT_ATTRIBUTE_VALUES = {
     color: [1, 1, 1, 1],
     age: [0],

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.35.2",
+  "version": "2.35.3",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",