@croquet/worldcore-three - npm Package Compare versions

Comparing version 1.1.2 to 1.2.0

CHANGELOG.md

@@ -7,4 +7,26 @@ # Changelog
 
-## [1.1.2] - 2021-1-28
+## [1.2.0] - 2022-4-20
+### Changed
+- PM_ThreeCamera.raycast handles grouped objects
+- PM_Visible inherits from base PM_Visible in kernel
+- PM_ThreeCamera inherits from base PM_Camera in kernel
+- ThreeRenderManager inherits from base RenderManager in kernel
+
+### Added
+- ThreeRenderManager has threeLayer() to access Three-specific layer data.
+- ThreeRenderManager has threeLayerUnion()
+
+- removeFromLayers dynamically removes an object from layers.
+- BVH Bounding Volume Hierachy (three-mesh-bvh) is added as an option to optimize raycast.
+- setColliderObject is used to set up the BVH geometry for an object.
+- The result from the raycaster has distance property.
+- setVelocitySpin is a convenience method to set _velocity and _spin at the same time.
+- pointerRaycast takes an optional flag to restrict the set of targets to objects in the targets list.
+- object that returns hitNormal can set the normal in pointerRaycast.
+
 ### Fixed
+- invoke update() only once per object
+
+## [1.1.2] - 2022-1-28
+### Fixed
 - Fixed crash if you create a raycast pointer with no targets.
@@ -33,3 +55,2 @@
 ## Pending
-### Added
 

package.json

 {
   "name": "@croquet/worldcore-three",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "Three.js Component for Croquet Worldcore",
@@ -26,4 +26,5 @@ "keywords": [
   "dependencies": {
-    "@croquet/worldcore-kernel": "^1.1.2",
-    "three": "^0.134.0"
+    "@croquet/worldcore-kernel": "^1.2.0",
+    "three": "^0.138.0",
+    "three-mesh-bvh": "^0.5.6"
   },
@@ -33,3 +34,3 @@ "publishConfig": {
   },
-  "gitHead": "9a3b57dc464d01f1701d621210fbfb7e4bc601c0"
+  "gitHead": "7633b5da452e79cee2be15721d744e4cd9f9924c"
 }

src/ThreeRender.js

 import * as THREE from 'three';
 import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js';
 import { RenderPass } from 'three/examples/jsm/postprocessing/RenderPass.js';
-import { ViewService } from "@croquet/worldcore-kernel";
+import { PM_Visible, PM_Camera, RenderManager } from "@croquet/worldcore-kernel";
+import { MeshBVH, MeshBVHVisualizer } from "three-mesh-bvh";
 
@@ -9,5 +10,4 @@ //------------------------------------------------------------------------------------------
 //------------------------------------------------------------------------------------------
+export const PM_ThreeVisible = superclass => class extends PM_Visible(superclass) {
 
-export const PM_ThreeVisible = superclass => class extends superclass {
-
     constructor(...args) {
@@ -21,3 +21,6 @@ super(...args);
         const render = this.service("ThreeRenderManager");
-        if (render && render.scene) render.scene.remove(this.renderObject);
+        if (render && render.scene) {
+            if(this.renderObject)render.scene.remove(this.renderObject);
+            if(this.colliderObject)render.scene.remove(this.colliderObject);
+        }
     }
@@ -30,2 +33,6 @@
         }
+        if(this.colliderObject){
+            this.colliderObject.matrix.fromArray(this.global);
+            this.colliderObject.matrixWorldNeedsUpdate = true;
+        }
     }
@@ -35,2 +42,3 @@
         const render = this.service("ThreeRenderManager");
+        if (render) render.dirtyAllLayers();
         renderObject.wcPawn = this;
@@ -45,2 +53,12 @@ this.renderObject = renderObject;
 
+    setColliderObject(colliderObject) {
+        const render = this.service("ThreeRenderManager");
+        if (render) render.dirtyAllLayers();
+        colliderObject.wcPawn = this;
+        this.colliderObject = colliderObject;
+        this.colliderObject.matrixAutoUpdate = false;
+        this.colliderObject.matrix.fromArray(this.global);
+        this.colliderObject.matrixWorldNeedsUpdate = true;
+        if (render && render.scene) render.scene.add(this.colliderObject);
+    }
 };
@@ -54,3 +72,3 @@
 
-export const PM_ThreeCamera = superclass => class extends superclass {
+export const PM_ThreeCamera = superclass => class extends PM_Camera(superclass) {
     constructor(...args) {
@@ -76,18 +94,69 @@ super(...args);
 
-    pointerRaycast(xy) {
+    setRayCast(xy){
+        const x = ( xy[0] / window.innerWidth ) * 2 - 1;
+        const y = - ( xy[1] / window.innerHeight ) * 2 + 1;
         const render = this.service("ThreeRenderManager");
         if (!this.raycaster) this.raycaster = new THREE.Raycaster();
-        this.raycaster.setFromCamera({x: xy[0], y: xy[1]}, render.camera);
-        const h = this.raycaster.intersectObjects(render.layers.pointer);
+        this.raycaster.setFromCamera({x: x, y: y}, render.camera);
+        return this.raycaster;
+    }
+
+    pointerRaycast(xy, targets, optStrictTargets) {
+        this.setRayCast(xy);
+        const render = this.service("ThreeRenderManager");
+        const h = this.raycaster.intersectObjects(targets || render.threeLayer("pointer"));
         if (h.length === 0) return {};
-        const hit = h[0];
+ 
+        let hit;
+        let normal;
+        if (optStrictTargets) {
+            for (let i = 0; i < h.length; i++) {
+                let me = h[i].object;
+                let wcPawn = me.wcPawn;
+                while (!wcPawn && me) {
+                    me = me.parent;
+                    wcPawn = me.wcPawn;
+                }
+                if (wcPawn) {
+                    normal = wcPawn.hitNormal;
+                    if (Array.isArray(normal)) {
+                        normal = new THREE.Vector3(...normal);
+                    }
+                    hit = h[i];
+                    break;
+                }
+            }
+        }
+
+        if (!hit) {
+            hit = h[0];
+        }
+
+        if(hit.face && !normal) {
+            normal = hit.face.normal;
+        }
+        if (normal) {
+            let m = new THREE.Matrix3().getNormalMatrix( hit.object.matrixWorld );
+            normal = normal.clone().applyMatrix3( m ).normalize();
+        } else {
+            normal = new THREE.Vector3(0,1,0);
+        }
         return {
-            pawn: hit.object.wcPawn,
+            pawn: this.getPawn(hit.object),
             xyz: hit.point.toArray(),
-            xyzLocal: hit.object.worldToLocal(hit.point).toArray(),
-            uv: hit.uv.toArray(),
-            normal: hit.face.normal.toArray()
+            uv: hit.uv?hit.uv.toArray():undefined,
+            normal: normal.toArray(),
+            distance: hit.distance
         };
     }
 
+    getPawn(object) {
+        let o = object;
+        while(!o.wcPawn) {
+            if (!o.parent) return null;
+            o = o.parent;
+        };
+        return o.wcPawn;
+    }
+
 };
@@ -101,10 +170,10 @@
 
-export class ThreeRenderManager extends ViewService {
+export class ThreeRenderManager extends RenderManager {
     constructor(options = {}, name) {
-        super(name || "ThreeRenderManager");
+        super(options, name || "ThreeRenderManager");
 
+        this.threeLayers = {}; // Three-specific layers
+
         this.scene = new THREE.Scene();
         this.camera = new THREE.PerspectiveCamera(60, window.innerWidth / window.innerHeight, 0.1, 10000);
-        this.layers = {};
-        this.layers.pointer = [];
 
@@ -127,6 +196,20 @@ if (!options.canvas) {
 
+        this.useBVH = options.useBVH;
+        if (options.useBVH) {
+            this.setupBVH();
+        }
+
         this.resize();
         this.subscribe("input", "resize", () => this.resize());
+        this.setRender(true);
     }
 
+    setupBVH() {
+        this.MeshBVH = MeshBVH;
+        this.MeshBVHVisualizer = MeshBVHVisualizer;
+
+     //   console.log(computeBoundsTree, disposeBoundsTree, acceleratedRaycast);
+    }
+
+    setRender(bool){this.doRender = bool; }
     destroy() {
@@ -145,6 +228,31 @@ super.destroy();
 
+    dirtyLayer(name) {
+        this.threeLayers[name] = null;
+    }
+
+    dirtyAllLayers(){
+        this.threeLayers = {};
+    }
+
+    threeLayer(name) {
+        if (!this.layers[name]) return [];
+        if (!this.threeLayers[name]) {
+            this.threeLayers[name] = Array.from(this.layers[name]).map(p => p.colliderObject || p.renderObject);
+        }
+        return this.threeLayers[name];
+    }
+
+    threeLayerUnion(...names) {
+        let result = [];
+        while (names.length > 0) {
+            const a = this.threeLayer(names.pop());
+            result = result.concat(a.filter(x => result.indexOf(x) < 0))
+        }
+        return result;
+    }
+
     update() {
-        this.composer.render();
+        if(this.doRender)this.composer.render();
     }
 
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

12571

increased by54.74%

Lines of code

210

increased by84.21%

Worsened metrics

Dependency count

3

increased by50%

Dependency changes

• + Addedthree-mesh-bvh@^0.5.6

• + Addedthree@0.138.3(transitive)

• + Addedthree-mesh-bvh@0.5.24(transitive)

• - Removedthree@0.134.0(transitive)

• Updated@croquet/worldcore-kernel@^1.2.0

• Updatedthree@^0.138.0