@woosh/meep-engine 2.36.14 → 2.36.17

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

@@ -71,4 +71,16 @@ export class SurfacePoint3 {
         this.position.copy(other.position);
         this.normal.copy(other.normal);
     }
+
+    /**
+     *
+     * @returns {SurfacePoint3}
+     */
+    clone() {
+        const r = new SurfacePoint3();
+
+        r.copy(this);
+
+        return r;
+    }
 }

package/engine/graphics/ecs/highlight/Highlight.d.ts

@@ -11,4 +11,6 @@ export default class Highlight {
     fromJSON(j: any): void
 
     toJSON(): any
+
+    static fromOne(r: number, g: number, b: number, a?: number): Highlight
 }

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

@@ -275,6 +275,91 @@ export class ShadedGeometrySystem extends System {
         }
     }
 
+    /**
+     *
+     * @param {number} origin_x
+     * @param {number} origin_y
+     * @param {number} origin_z
+     * @param {number} direction_x
+     * @param {number} direction_y
+     * @param {number} direction_z
+     * @param {function(entity:number, mesh:ShadedGeometry):boolean} [filter_function]
+     * @param {*} [filter_function_context]
+     * @returns {{entity:number, mesh:ShadedGeometry, contact: SurfacePoint3}[]}
+     */
+    raycast(
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z,
+        filter_function = returnTrue, filter_function_context
+    ) {
+        const result = [];
+
+        const hits = [];
+
+        const hit_count = bvh_query_leaves_generic(hits, 0, this.__bvh_binary, BVHQueryIntersectsRay.from([origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]));
+
+        const ecd = this.entityManager.dataset;
+
+        if (ecd === null) {
+            // no ECD set
+            return result;
+        }
+
+        const sg_component_index = ecd.computeComponentTypeIndex(ShadedGeometry);
+
+        for (let i = 0; i < hit_count; i++) {
+            const node_id = hits[i];
+
+            const entity = this.__bvh_binary.node_get_user_data(node_id);
+
+            /**
+             *
+             * @type {ShadedGeometry}
+             */
+            const sg = ecd.getComponentByIndex(entity, sg_component_index);
+
+            if (!filter_function.call(filter_function_context, entity, sg)) {
+                // filtered out
+                continue;
+            }
+
+            const m4 = sg.transform;
+
+            // get transform in local space
+            mat4.invert(scratch_m4, m4);
+
+            ray3_array_compose(
+                scratch_ray_0,
+                origin_x, origin_y, origin_z,
+                direction_x, direction_y, direction_z
+            );
+
+            // transform ray to local space
+            ray3_array_apply_matrix4(scratch_ray_0, scratch_ray_0, scratch_m4);
+
+            const geometry_hit_found = GeometrySpatialQueryAccelerator.INSTANCE.queryRaycastNearest_array(
+                scratch_point,
+                sg.geometry,
+                scratch_ray_0
+            );
+
+            if (!geometry_hit_found) {
+                continue;
+            }
+
+            // transform hit contact into global space
+            scratch_point.applyMatrix4(m4);
+
+            result.push({
+                entity,
+                mesh: sg,
+                contact: scratch_point.clone()
+            });
+        }
+
+        return result;
+    }
+
     /**
      *
      * @param {SurfacePoint3} contact
@@ -327,6 +412,10 @@ export class ShadedGeometrySystem extends System {
                 continue;
             }
 
+            /**
+             *
+             * @type {number[]|mat4|null}
+             */
             const m4 = sg.transform;
 
             // get transform in local space

package/engine/graphics/ecs/mesh-v2/aggregate/SGMeshHighlightSystem.d.ts

@@ -0,0 +1,7 @@
+import {System} from "../../../../ecs/System";
+import {SGMesh} from "./SGMesh";
+import Highlight from "../../highlight/Highlight";
+
+export class SGMeshHighlightSystem extends System<SGMesh, Highlight> {
+    constructor()
+}

package/engine/graphics/ecs/mesh-v2/aggregate/SGMeshHighlightSystem.js

@@ -0,0 +1,81 @@
+import { System } from "../../../../ecs/System.js";
+import { SGMesh } from "./SGMesh.js";
+import Highlight from "../../highlight/Highlight.js";
+import { SGMeshEvents } from "./SGMeshEvents.js";
+
+export class SGMeshHighlightSystem extends System {
+    constructor() {
+        super();
+
+        this.dependencies = [Highlight, SGMesh];
+    }
+
+    /**
+     *
+     * @param event
+     * @param {number} entity
+     * @private
+     */
+    __apply_highlight( event, entity) {
+        const ecd = this.entityManager.dataset;
+
+        const sg_mesh = ecd.getComponent(entity, SGMesh);
+        const highlight = ecd.getComponent(entity, Highlight);
+
+        const node = sg_mesh.__node;
+
+        node.traverse(t => {
+            t.entity.add(highlight);
+        });
+    }
+
+    /**
+     *
+     * @param event
+     * @param {number} entity
+     * @private
+     */
+    __remove_highlight( event, entity) {
+
+        const ecd = this.entityManager.dataset;
+
+        const sg_mesh = ecd.getComponent(entity, SGMesh);
+
+        const node = sg_mesh.__node;
+
+        node.traverse(t => {
+            t.entity.removeComponent(Highlight);
+        });
+    }
+
+    /**
+     *
+     * @param {Highlight} highlight
+     * @param {SGMesh} mesh
+     * @param {number} entity
+     */
+    link(highlight, mesh, entity) {
+        if (mesh.__node !== null) {
+            this.__apply_highlight(undefined,  entity);
+        }
+
+        const ecd = this.entityManager.dataset;
+
+        ecd.addEntityEventListener(entity, SGMeshEvents.AssetLoaded, this.__apply_highlight, this);
+    }
+
+    /**
+     *
+     * @param {Highlight} highlight
+     * @param {SGMesh} mesh
+     * @param {number} entity
+     */
+    unlink(highlight, mesh, entity) {
+        const ecd = this.entityManager.dataset;
+        ecd.removeEntityEventListener(entity, SGMeshEvents.AssetLoaded, this.__apply_highlight, this);
+
+        if (mesh.__node !== null) {
+            this.__remove_highlight(undefined, entity);
+        }
+    }
+}

package/engine/graphics/ecs/mesh-v2/aggregate/SGMeshSystem.js

@@ -79,10 +79,7 @@ export class SGMeshSystem extends System {
         const entity_node = three_object_to_entity_composition(asset.create());
 
         // attach parent entity to link hierarchy to this entity
-        const parentEntity = new ParentEntity();
-        parentEntity.entity = entity;
-
-        entity_node.entity.add(parentEntity)
+        entity_node.entity.add(ParentEntity.from(entity));
 
         mesh.__node = entity_node;
 

package/engine/graphics/ecs/mesh-v2/aggregate/prototypeSGMesh.js

@@ -12,6 +12,9 @@ import { TransformAttachmentSystem } from "../../../../ecs/transform-attachment/
 import { SGMeshEvents } from "./SGMeshEvents.js";
 import { ShadedGeometry } from "../ShadedGeometry.js";
 import { MeshSystem } from "../../mesh/MeshSystem.js";
+import { SGMeshHighlightSystem } from "./SGMeshHighlightSystem.js";
+import Highlight from "../../highlight/Highlight.js";
+import { ShadedGeometryHighlightSystem } from "../../highlight/system/ShadedGeometryHighlightSystem.js";
 
 new EngineHarness().initialize({
     configuration(config, engine) {
@@ -20,7 +23,9 @@ new EngineHarness().initialize({
             new SGMeshSystem(engine),
             new BehaviorSystem(engine),
             new MeshSystem(engine),
-            new TransformAttachmentSystem()
+            new TransformAttachmentSystem(),
+            new SGMeshHighlightSystem(),
+            new ShadedGeometryHighlightSystem(engine)
         );
 
         config.addLoader(GameAssetType.ModelGLTF_JSON, new GLTFAssetLoader());
@@ -46,12 +51,13 @@ function main(engine) {
         .add(Transform.fromJSON({
             position: new Vector3(10, 0, 10)
         }))
+        .add(Highlight.fromOne(1, 0, 0, 1))
         .add(mesh)
-     /*   .add(BehaviorComponent.fromOne(OrbitingBehavior.from({
-            center: new Vector3(10, 0, 10),
-            radius: 5,
-            rate: 2
-        })))*/
+        /*   .add(BehaviorComponent.fromOne(OrbitingBehavior.from({
+               center: new Vector3(10, 0, 10),
+               radius: 5,
+               rate: 2
+           })))*/
         .addEventListener(SGMeshEvents.AssetLoaded, () => {
             mesh.__node.traverse(n => {
                 /**

package/engine/graphics/particles/particular/engine/renderers/billboard/ParticleBillboardMaterial.js

@@ -11,8 +11,6 @@ import {
 } from "three";
 import { Vector2 as ThreeVector2 } from "three/src/math/Vector2.js";
 
-const DEPTH_ERROR_MARGIN = 0.0001;
-
 const CHUNK_LAMBERT_LIGHTING = `
 vec3 diffuse = vec3( 1.0 );
 
@@ -234,24 +232,32 @@ function make_fragment_shader() {
                     
                     float d_n = 2.0*z - 1.0;
                     
-                    float fn = f*n;
-                    
                     float z_diff = f - n;
                     
                     float denominator = (f + n - d_n * z_diff );
-                
-                    float z_view = (2.0*fn) / denominator;
+                    
+                    float z_view = (2.0*f*n) / denominator;
                 
                     return z_view-n;
                 }
                 
+                float depthToLinear_v2(float z){
+                    float far = cameraFar;
+                    float near = cameraNear;
+                    
+                    // perspectiveDepthToViewZ
+                    float view_z = ( near * far ) / ( ( near-far  ) * z + far );
+                    
+                    return  view_z;
+                }
+                
                 
                 float calculateFade(in float particleDepth, in float sceneDepth){
                     float zFade;
                                                             
-                    float linearParticleDepth = depthToLinear(particleDepth);
+                    float linearParticleDepth = depthToLinear_v2(particleDepth);
                     
-                    float linearSceneDepth = depthToLinear(sceneDepth);
+                    float linearSceneDepth = depthToLinear_v2(sceneDepth);
                                     
                     float depthDelta = (linearSceneDepth - linearParticleDepth);
                                                     
@@ -266,9 +272,9 @@ function make_fragment_shader() {
                     }
                     
                     if(inputDepth <= 0.5){
-                        zFade = 0.5 * pow( clamp(2.0*inputDepth, 0.0, 1.0), 2.0);
+                        zFade = 2.0 * pow( clamp(inputDepth, 0.0, 1.0), 2.0);
                     }else{
-                        zFade = 1.0 - 0.5 * pow( clamp(2.0*(1.0 - inputDepth), 0.0, 1.0), 2.0);
+                        zFade = 1.0 - 2.0 * pow( clamp(1.0 - inputDepth, 0.0, 1.0), 2.0);
                     }
                     
                     return zFade;
@@ -335,7 +341,7 @@ function make_fragment_shader() {
                     
                     #ifdef DEPTH_READ_ENABLED
                     
-                        if(fragmentDepth + ${DEPTH_ERROR_MARGIN} > sceneDepth){
+                        if(fragmentDepth > sceneDepth){
                             discard;
                         }
                     

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.36.14",
+  "version": "2.36.17",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",