@needle-tools/engine 2.40.0-pre → 2.42.0-pre

package/src/engine-components/ReflectionProbe.ts

@@ -10,11 +10,14 @@ import { getParam } from "../engine/engine_utils";
 export const debug = getParam("debugreflectionprobe");
 const disable = getParam("noreflectionprobe");
 
+const $reflectionProbeKey = Symbol("reflectionProbeKey");
+const $originalMaterial = Symbol("original material");
+
 export class ReflectionProbe extends Behaviour {
 
     private static _probes: Map<Context, ReflectionProbe[]> = new Map();
 
-    public static get(object: Object3D | null | undefined, context: Context, isAnchor:boolean): ReflectionProbe | null {
+    public static get(object: Object3D | null | undefined, context: Context, isAnchor: boolean): ReflectionProbe | null {
         if (!object || object.isObject3D !== true) return null;
         if (disable) return null;
         const probes = ReflectionProbe._probes.get(context);
@@ -91,7 +94,7 @@ export class ReflectionProbe extends Behaviour {
     // and some need reflection probe and some don't
     // we need to make sure we don't override the material but use a copy
 
-    private static _rendererMaterialsCache: Map<IRenderer, Array<{ orig: Material, copy: Material }>> = new Map();
+    private static _rendererMaterialsCache: Map<IRenderer, Array<{ material: Material, copy: Material }>> = new Map();
 
     onSet(_rend: IRenderer) {
         if (disable) return;
@@ -109,22 +112,43 @@ export class ReflectionProbe extends Behaviour {
         // need to make sure materials are not shared when using reflection probes
         // otherwise some renderers outside of the probe will be affected or vice versa
         for (let i = 0; i < _rend.sharedMaterials.length; i++) {
-            const orig = _rend.sharedMaterials[i];
-            if (!orig) continue;
-            if (orig["envMap"] === undefined) continue;
+            const material = _rend.sharedMaterials[i];
+            if (!material) continue;
+            if (material["envMap"] === undefined) continue;
+            if (material["envMap"] === this.texture) {
+                continue;
+            }
             let cached = rendererCache[i];
-            let copy = cached?.copy;
-            if (!cached) {
-                const clone = orig.clone();
-                copy = clone;
-                rendererCache.push({ orig, copy });
 
-                copy["__reflection_probe"] = this;
-                copy["envMap"] = this.texture;
+            // make sure we have the currently assigned material cached (and an up to date clone of that)
+            if (!cached || cached.material !== material || cached.material.version !== material.version) {
+                const clone = material.clone();
+
+                if (cached) {
+                    cached.copy = clone;
+                    cached.material = material;
+                }
+                else {
+                    cached = {
+                        material: material,
+                        copy: clone
+                    };
+                    rendererCache.push(cached);
+                }
+
+                clone[$reflectionProbeKey] = this;
+                clone[$originalMaterial] = material;
+
+                // make sure the reflection probe is assigned
+                clone["envMap"] = this.texture;
 
                 if (debug)
                     console.log("Set reflection", _rend.name, _rend.guid);
             }
+
+            /** this is the material that we copied and that has the reflection probe */
+            const copy = cached?.copy;
+
             _rend.sharedMaterials[i] = copy;
         }
     }
@@ -134,7 +158,7 @@ export class ReflectionProbe extends Behaviour {
         if (rendererCache) {
             for (let i = 0; i < rendererCache.length; i++) {
                 const cached = rendererCache[i];
-                _rend.sharedMaterials[i] = cached.orig;
+                _rend.sharedMaterials[i] = cached.material;
             }
         }
     }

package/src/engine-components/Renderer.ts

@@ -219,6 +219,8 @@ export class Renderer extends Behaviour implements IRenderer {
         return lm !== null && lm !== undefined;
     }
 
+    allowProgressiveLoading : boolean = true;
+
     awake() {
         this.clearInstancingState();
 
@@ -457,7 +459,7 @@ export class Renderer extends Behaviour implements IRenderer {
     onBeforeRenderThree(_renderer, _scene, _camera, _geometry, material, _group) {
 
         // progressive load before rendering so we only load textures for visible materials
-        if (!suppressProgressiveLoading && material._didRequestTextureLOD === undefined) {
+        if (!suppressProgressiveLoading && material._didRequestTextureLOD === undefined && this.allowProgressiveLoading) {
             material._didRequestTextureLOD = 0;
             if (debugProgressiveLoading) {
                 console.log("Load material LOD (with delay)", material.name);
@@ -542,7 +544,7 @@ export class Renderer extends Behaviour implements IRenderer {
         // handle reflection probe
         this._reflectionProbe = null;
         if (this.reflectionProbeUsage !== ReflectionProbeUsage.Off) {
-            // if(this.gameObject.name.includes("Tank_Case_Jewlery") === false) return;
+            if(!this.probeAnchor) return;
             const obj = this.probeAnchor || this.gameObject;
             const isAnchor = this.probeAnchor ? true : false;
             this._reflectionProbe = ReflectionProbe.get(obj, this.context, isAnchor);

package/src/engine-components/WebXR.ts

@@ -87,6 +87,8 @@ export class WebXR extends Behaviour {
         if (!WebXR.XRSupported) {
             console.warn("WebXR is not supported on this device");
         }
+        else
+            webXR.__internalAwake();
         const vrButton = VRButton.createButton(webXR.context.renderer);
         vrButton.classList.add('webxr-ar-button');
         vrButton.classList.add('webxr-button');
@@ -98,12 +100,14 @@ export class WebXR extends Behaviour {
     }
 
     public static createARButton(webXR: WebXR, opts?: CreateButtonOptions): HTMLButtonElement {
+        webXR.__internalAwake();
         const domOverlayRoot = webXR.webAR?.getAROverlayContainer();
         const features: any = {};
         if (domOverlayRoot) {
             features.domOverlay = { root: domOverlayRoot };
             features.optionalFeatures = ['hit-test', 'dom-overlay'];
         }
+        else console.warn("No dom overlay root found, AR will not work");
         const arButton = ARButton.createButton(webXR.context.renderer, features);
         arButton.classList.add('webxr-ar-button');
         arButton.classList.add('webxr-button');
@@ -126,7 +130,7 @@ export class WebXR extends Behaviour {
     }
 
     public get Rig(): Object3D {
-        if(!this.rig) this.ensureRig();
+        if (!this.rig) this.ensureRig();
         return this.rig;
     }
 
@@ -184,6 +188,7 @@ export class WebXR extends Behaviour {
             const sync = GameObject.addNewComponent(this.gameObject, WebXRSync, false) as WebXRSync;
             sync.webXR = this;
         }
+        this.webAR = new WebAR(this);
     }
 
     onEnable() {
@@ -192,7 +197,6 @@ export class WebXR extends Behaviour {
         this.isInit = true;
 
         this.context.renderer.xr.enabled = true;
-        this.webAR = new WebAR(this);
 
         // general WebXR support?
         const browserSupportsXR = WebXR.XRSupported;
@@ -490,7 +494,7 @@ export class WebAR {
     getAROverlayContainer(): HTMLElement | null {
         this.arDomOverlay = this.webxr.context.domElement as HTMLElement;
         // for react cases we dont have an Engine Element
-        const element : any = this.arDomOverlay;
+        const element: any = this.arDomOverlay;
         if (element.getAROverlayContainer)
             this.arOverlayElement = element.getAROverlayContainer();
         else this.arOverlayElement = this.arDomOverlay;
@@ -523,9 +527,9 @@ export class WebAR {
         session.requestReferenceSpace('viewer').then((referenceSpace) => {
             session.requestHitTestSource({ space: referenceSpace }).then((source) => {
                 this.hitTestSource = source;
-            }).catch((_) => {
+            }).catch((err) => {
                 this.noHitTestAvailable = true;
-                console.warn("WebXR: Hit test not supported");
+                console.warn("WebXR: Hit test not supported", err);
             });
         });
 
@@ -544,7 +548,7 @@ export class WebAR {
             this.reticleParent.matrixAutoUpdate = false;
             this.reticleParent.add(this.reticle);
             this.reticleParent.matrix.copy(this.sessionRoot.gameObject.matrixWorld);
-            
+
             if (this.webxr.scene) {
                 this.context.scene.add(this.reticleParent);
                 // this.context.scene.add(this.reticle);
@@ -583,8 +587,7 @@ export class WebAR {
         if (this.sessionRoot) {
             this.sessionRoot.onEnd(this.webxr.Rig, session);
         }
-        if (this.arDomOverlay) 
-        {
+        if (this.arDomOverlay) {
             const el = this.arOverlayElement as INeedleEngineComponent;
             el.onExitAR?.call(el, session);
         }

package/src/engine-components/codegen/components.ts

@@ -50,9 +50,16 @@ export { OffsetConstraint } from "../OffsetConstraint";
 export { OrbitControls } from "../OrbitControls";
 export { ParticleSystemRenderer } from "../ParticleSystem";
 export { ParticleSystem } from "../ParticleSystem";
+export { Gradient } from "../ParticleSystemModules";
+export { MinMaxCurve } from "../ParticleSystemModules";
+export { MinMaxGradient } from "../ParticleSystemModules";
 export { MainModule } from "../ParticleSystemModules";
+export { ParticleBurst } from "../ParticleSystemModules";
 export { EmissionModule } from "../ParticleSystemModules";
+export { ColorOverLifetimeModule } from "../ParticleSystemModules";
+export { SizeOverLifetimeModule } from "../ParticleSystemModules";
 export { ShapeModule } from "../ParticleSystemModules";
+export { NoiseModule } from "../ParticleSystemModules";
 export { PlayerColor } from "../PlayerColor";
 export { ReflectionProbe } from "../ReflectionProbe";
 export { FieldWithDefault } from "../Renderer";