@needle-tools/engine 3.7.7-beta → 3.9.0-alpha

package/src/engine/extensions/NEEDLE_lightmaps.ts

@@ -1,5 +1,5 @@
 import { ILightDataRegistry } from "../engine_lightdata";
-import { FloatType, HalfFloatType, LinearEncoding, sRGBEncoding, Texture } from "three";
+import { FloatType, HalfFloatType, LinearEncoding, LinearSRGBColorSpace, SRGBColorSpace, sRGBEncoding, Texture } from "three";
 import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
 import { SourceIdentifier } from "../engine_types";
 import { resolveReferences } from "./extension_utils";
@@ -70,9 +70,9 @@ export class NEEDLE_lightmaps implements GLTFLoaderPlugin {
                                     else {
                                         // TODO this is most likely wrong for floating point textures
                                         if (entry.type !== LightmapType.Lightmap)
-                                            tex.encoding = sRGBEncoding;
+                                            tex.colorSpace = SRGBColorSpace;
                                         else
-                                            tex.encoding = LinearEncoding;
+                                            tex.colorSpace = LinearSRGBColorSpace;
 
 
                                         // Dont flip skybox textures anymore - previously we exported them flipped when baking in Unity but now we allow to pass through export without re-baking exisitng skybox textures if they use default values. So we expect textures to be NOT flipped anymore

package/src/engine/extensions/NEEDLE_render_objects.ts

@@ -22,6 +22,8 @@ import {
     IncrementWrapStencilOp,
     DecrementWrapStencilOp,
     InvertStencilOp,
+    StencilFunc,
+    StencilOp as ThreeStencilOp,
 } from "three";
 import { getParam, isDebugMode } from "../engine_utils";
 import { showBalloonWarning } from "../debug";
@@ -81,10 +83,10 @@ export class NEEDLE_render_objects implements GLTFLoaderPlugin {
                         mat.stencilWriteMask = 255;
                         mat.stencilFuncMask = 255;
                         mat.stencilRef = stencil.value;
-                        mat.stencilFunc = stencil.compareFunc;
-                        mat.stencilZPass = stencil.passOp;
-                        mat.stencilFail = stencil.failOp;
-                        mat.stencilZFail = stencil.zFailOp;
+                        mat.stencilFunc = stencil.compareFunc as StencilFunc;
+                        mat.stencilZPass = stencil.passOp as ThreeStencilOp;
+                        mat.stencilFail = stencil.failOp as ThreeStencilOp;
+                        mat.stencilZFail = stencil.zFailOp as ThreeStencilOp;
                         obj.sharedMaterials[i] = mat;
                     }
                 }
@@ -116,7 +118,7 @@ export class NEEDLE_render_objects implements GLTFLoaderPlugin {
                 if (stencils && Array.isArray(stencils)) {
                     for (const stencil of stencils) {
                         const obj: StencilSettingsModel = { ...stencil };
-                        obj.compareFunc = ToThreeCompareFunction(obj.compareFunc);
+                        obj.compareFunc = ToThreeCompareFunction(obj.compareFunc as number);
                         obj.passOp = ToThreeStencilOp(obj.passOp);
                         obj.failOp = ToThreeStencilOp(obj.failOp);
                         obj.zFailOp = ToThreeStencilOp(obj.zFailOp);
@@ -161,7 +163,7 @@ enum CompareFunction {
     Always,
 }
 
-function ToThreeStencilOp(op: StencilOp): number {
+function ToThreeStencilOp(op: StencilOp): ThreeStencilOp {
     switch (op) {
         case StencilOp.Keep:
             return KeepStencilOp;
@@ -183,7 +185,7 @@ function ToThreeStencilOp(op: StencilOp): number {
     return 0;
 }
 
-function ToThreeCompareFunction(func: CompareFunction): number {
+function ToThreeCompareFunction(func: CompareFunction): StencilFunc {
     switch (func) {
         case CompareFunction.Never:
             return NeverStencilFunc;
@@ -202,7 +204,7 @@ function ToThreeCompareFunction(func: CompareFunction): number {
         case CompareFunction.Always:
             return AlwaysStencilFunc;
     }
-    return 0;
+    return NeverStencilFunc;
 }
 
 

package/src/engine/extensions/NEEDLE_techniques_webgl.ts

@@ -1,6 +1,6 @@
 import { GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
 import { FindShaderTechniques, whiteDefaultTexture, ToUnityMatrixArray, SetUnitySphericalHarmonics } from '../engine_shaders';
-import { AlwaysDepth, BackSide, Camera, DoubleSide, EqualDepth, FrontSide, GreaterDepth, GreaterEqualDepth, IUniform, LessDepth, LessEqualDepth, LinearEncoding, Material, Matrix4, NotEqualDepth, Object3D, RawShaderMaterial, Vector3, Vector4 } from 'three';
+import { AlwaysDepth, BackSide, Camera, DoubleSide, EqualDepth, FrontSide, GLSL3, GreaterDepth, GreaterEqualDepth, IUniform, LessDepth, LessEqualDepth, LinearEncoding, Material, Matrix4, NotEqualDepth, Object3D, RawShaderMaterial, Vector3, Vector4 } from 'three';
 import { Context } from '../engine_setup';
 import { getParam } from "../engine_utils";
 import * as SHADERDATA from "../shaders/shaderData"
@@ -455,6 +455,10 @@ export class NEEDLE_techniques_webgl implements GLTFLoaderPlugin {
                     //     "USE_SHADOWMAP" : true
                     // },
                 });
+            material.glslVersion = GLSL3;
+            material.vertexShader = material.vertexShader.replace("#version 300 es", "");
+            material.fragmentShader = material.fragmentShader.replace("#version 300 es", "");
+
 
             const culling = uniforms["_Cull"]?.value;
             switch (culling) {

package/src/engine/extensions/extensions.ts

@@ -15,7 +15,17 @@ import { NEEDLE_render_objects } from "./NEEDLE_render_objects";
 import { NEEDLE_progressive } from "./NEEDLE_progressive";
 import { InternalUsageTrackerPlugin } from "./usage_tracker";
 import { isUsageTrackingEnabled } from "../engine_assetdatabase";
-import { GLTFLoaderPlugin } from "three/examples/jsm/loaders/GLTFLoader";
+import { GLTFLoaderPlugin } from "three/examples/jsm/loaders/GLTFLoader.js";
+// import { GLTFAnimationPointerExtension } from "three/examples/jsm/loaders/GLTFLoaderAnimationPointer";
+
+// lazily import the GLTFAnimationPointerExtension in case it doesnt exist (e.g. using vanilla three)
+let GLTFAnimationPointerExtension : any;
+import("three/examples/jsm/loaders/GLTFLoaderAnimationPointer").then(mod => {
+    GLTFAnimationPointerExtension = mod.GLTFAnimationPointerExtension;
+    return GLTFAnimationPointerExtension;
+}).catch(e => {
+    console.warn("Failed to import GLTFLoaderAnimationPointer. Please use @needle-tools/three for full KHR_animation support", e);
+});
 
 const _addedCustomExtension = new Array<ConstructorConcrete<GLTFLoaderPlugin>>();
 
@@ -70,8 +80,13 @@ export function registerExtensions(loader: GLTFLoader, context: Context, sourceI
     for (const ext of _addedCustomExtension)
         loader.register(p => new ext(p));
 
-    const setPointerResolverFunction = loader["setAnimationPointerResolver"];
-    if (typeof setPointerResolverFunction === "function")
-        setPointerResolverFunction.bind(loader)(new PointerResolver());
+    loader.register(p => {
+        if (GLTFAnimationPointerExtension) {
+            const ext = new GLTFAnimationPointerExtension(p);
+            const setPointerResolverFunction = ext.setAnimationPointerResolver;
+            setPointerResolverFunction.bind(ext)(new PointerResolver());
+            return ext;
+        }
+    });
 
 }

package/src/engine-components/Camera.ts

@@ -8,7 +8,7 @@ import { showBalloonMessage } from "../engine/debug/debug";
 import { getWorldPosition, Graphics } from "../engine/engine_three_utils";
 import { Gizmos } from "../engine/engine_gizmos";
 
-import { EquirectangularReflectionMapping, OrthographicCamera, PerspectiveCamera, Ray, sRGBEncoding, Vector3 } from "three";
+import { EquirectangularReflectionMapping, OrthographicCamera, PerspectiveCamera, Ray, SRGBColorSpace, sRGBEncoding, Vector3 } from "three";
 import { OrbitControls } from "./OrbitControls";
 import { RenderTexture } from "../engine/engine_texture";
 
@@ -261,7 +261,7 @@ export class Camera extends Behaviour implements ICamera {
         else
             cam = this.gameObject.children[0] as THREE.PerspectiveCamera | THREE.OrthographicCamera | null;
         if (cam && cam.isCamera) {
-            if (cam.type === "PerspectiveCamera") {
+            if (cam instanceof PerspectiveCamera) {
                 if (this._fov)
                     cam.fov = this._fov;
                 cam.near = this._nearClipPlane;
@@ -391,7 +391,7 @@ class CameraSkybox {
         else if (this.context.scene.background !== this._skybox) {
             if (debug)
                 console.log("Set skybox", this._camera, this._skybox);
-            this._skybox.encoding = sRGBEncoding;
+            this._skybox.colorSpace = SRGBColorSpace;
             this._skybox.mapping = EquirectangularReflectionMapping;
             this.context.scene.background = this._skybox;
         }

package/src/engine-components/GroundProjection.ts

@@ -1,5 +1,5 @@
 import { Behaviour, GameObject } from "./Component";
-import { GroundProjectedEnv as GroundProjection } from 'three/examples/jsm/objects/GroundProjectedEnv.js';
+import { GroundProjectedSkybox as GroundProjection } from 'three/examples/jsm/objects/GroundProjectedSkybox.js';
 import { serializable } from "../engine/engine_serialization_decorator";
 import { Watch as Watch } from "../engine/engine_utils";
 import { Texture } from "three";

package/src/engine-components/Light.ts

@@ -173,6 +173,7 @@ export class Light extends Behaviour implements ILight {
             }
             this.light.intensity = val * factor;
         }
+        if (debug) console.log("Set light intensity to " + this._intensity, val, this)
     }
     get intensity(): number { return this._intensity; }
     private _intensity: number = -1;
@@ -180,7 +181,7 @@ export class Light extends Behaviour implements ILight {
     @serializable()
     get shadowDistance(): number {
         const light = this.light;
-        if (light) {
+        if (light?.shadow) {
             const cam = light.shadow.camera as OrthographicCamera;
             return cam.far;
         }
@@ -189,7 +190,7 @@ export class Light extends Behaviour implements ILight {
     set shadowDistance(val: number) {
         this._shadowDistance = val;
         const light = this.light;
-        if (light) {
+        if (light?.shadow) {
             const cam = light.shadow.camera as OrthographicCamera;
             cam.far = val;
             cam.updateProjectionMatrix();
@@ -203,7 +204,7 @@ export class Light extends Behaviour implements ILight {
     @serializable()
     get shadowResolution(): number {
         const light = this.light;
-        if (light) {
+        if (light?.shadow) {
             return light.shadow.mapSize.x;
         }
         return -1;
@@ -212,7 +213,7 @@ export class Light extends Behaviour implements ILight {
         if (val === this._shadowResolution) return;
         this._shadowResolution = val;
         const light = this.light;
-        if (light) {
+        if (light?.shadow) {
             light.shadow.mapSize.set(val, val);
             light.shadow.needsUpdate = true;
         }
@@ -256,12 +257,13 @@ export class Light extends Behaviour implements ILight {
     }
 
     onEnable(): void {
-        if(debug) console.log("ENABLE LIGHT", this.name);
+        if (debug) console.log("ENABLE LIGHT", this.name);
         this.createLight();
         if (this.isBaked) return;
         else if (this.light) {
             this.light.visible = true;
             this.light.intensity = this._intensity;
+            if (debug) console.log("Set light intensity to " + this.light.intensity, this.name)
             if (this.selfIsLight) {
                 // nothing to do
             }
@@ -275,7 +277,7 @@ export class Light extends Behaviour implements ILight {
     }
 
     onDisable() {
-        if(debug) console.log("DISABLE LIGHT", this.name);
+        if (debug) console.log("DISABLE LIGHT", this.name);
         if (this.light) {
             if (this.selfIsLight)
                 this.light.intensity = 0;
@@ -376,61 +378,63 @@ export class Light extends Behaviour implements ILight {
             }
             else this.light.castShadow = false;
 
-            // shadow intensity is currently not a thing: https://github.com/mrdoob/three.js/pull/14087
-            if (this._shadowResolution !== undefined && this._shadowResolution > 4) {
-                this.light.shadow.mapSize.width = this._shadowResolution;
-                this.light.shadow.mapSize.height = this._shadowResolution;
-            }
-            else {
-                this.light.shadow.mapSize.width = 2048;
-                this.light.shadow.mapSize.height = 2048;
-            }
-            // this.light.shadow.needsUpdate = true;
-            // console.log(this.light.shadow.mapSize);
-            // return;
-
-            if (debug)
-                console.log("Override shadow bias?", this._overrideShadowBiasSettings, this.shadowBias, this.shadowNormalBias);
-
-            this.light.shadow.bias = this.shadowBias;
-            this.light.shadow.normalBias = this.shadowNormalBias;
-
-            this.updateShadowSoftHard();
+            if (this.light.shadow) {
+                // shadow intensity is currently not a thing: https://github.com/mrdoob/three.js/pull/14087
+                if (this._shadowResolution !== undefined && this._shadowResolution > 4) {
+                    this.light.shadow.mapSize.width = this._shadowResolution;
+                    this.light.shadow.mapSize.height = this._shadowResolution;
+                }
+                else {
+                    this.light.shadow.mapSize.width = 2048;
+                    this.light.shadow.mapSize.height = 2048;
+                }
+                // this.light.shadow.needsUpdate = true;
+                // console.log(this.light.shadow.mapSize);
+                // return;
+
+                if (debug)
+                    console.log("Override shadow bias?", this._overrideShadowBiasSettings, this.shadowBias, this.shadowNormalBias);
+
+                this.light.shadow.bias = this.shadowBias;
+                this.light.shadow.normalBias = this.shadowNormalBias;
+
+                this.updateShadowSoftHard();
+
+                const cam = this.light.shadow.camera as THREE.OrthographicCamera;
+                cam.near = this.shadowNearPlane;
+                // use shadow distance that was set explictly (if any)
+                if (this._shadowDistance !== undefined && typeof this._shadowDistance === "number")
+                    cam.far = this._shadowDistance;
+                else // otherwise fallback to object scale and max distance
+                    cam.far = shadowMaxDistance * Math.abs(this.gameObject.scale.z);
+
+                // width and height
+                this.gameObject.scale.set(1, 1, 1);
+                if (this.shadowWidth !== undefined) {
+                    cam.left = -this.shadowWidth / 2;
+                    cam.right = this.shadowWidth / 2;
+                }
+                else {
+                    const sx = this.gameObject.scale.x;
+                    cam.left *= sx;
+                    cam.right *= sx;
+                }
+                if (this.shadowHeight !== undefined) {
+                    cam.top = this.shadowHeight / 2;
+                    cam.bottom = -this.shadowHeight / 2;
+                }
+                else {
+                    const sy = this.gameObject.scale.y;
+                    cam.top *= sy;
+                    cam.bottom *= sy;
+                }
+                this.light.shadow.needsUpdate = true;
 
-            const cam = this.light.shadow.camera as THREE.OrthographicCamera;
-            cam.near = this.shadowNearPlane;
-            // use shadow distance that was set explictly (if any)
-            if (this._shadowDistance !== undefined && typeof this._shadowDistance === "number")
-                cam.far = this._shadowDistance;
-            else // otherwise fallback to object scale and max distance
-                cam.far = shadowMaxDistance * Math.abs(this.gameObject.scale.z);
-
-            // width and height
-            this.gameObject.scale.set(1, 1, 1);
-            if (this.shadowWidth !== undefined) {
-                cam.left = -this.shadowWidth / 2;
-                cam.right = this.shadowWidth / 2;
-            }
-            else {
-                const sx = this.gameObject.scale.x;
-                cam.left *= sx;
-                cam.right *= sx;
-            }
-            if (this.shadowHeight !== undefined) {
-                cam.top = this.shadowHeight / 2;
-                cam.bottom = -this.shadowHeight / 2;
-            }
-            else {
-                const sy = this.gameObject.scale.y;
-                cam.top *= sy;
-                cam.bottom *= sy;
+                if (debug)
+                    this.context.scene.add(new THREE.CameraHelper(cam));
             }
 
 
-            this.light.shadow.needsUpdate = true;
-            if (debug)
-                this.context.scene.add(new THREE.CameraHelper(cam));
-
 
             if (this.isBaked) {
                 this.light.removeFromParent();
@@ -457,6 +461,7 @@ export class Light extends Behaviour implements ILight {
 
     private updateShadowSoftHard() {
         if (!this.light) return;
+        if (!this.light.shadow) return;
         if (this.shadows === LightShadows.Soft) {
             // const radius = this.light.shadow.mapSize.width / 1024 * 5;
             // const samples = Mathf.clamp(Math.round(radius), 2, 10);

package/src/engine-components/OrbitControls.ts

@@ -272,10 +272,10 @@ export class OrbitControls extends Behaviour implements ICameraController {
         if (!freeCam && this.lookAtConstraint?.locked) this.setFromTargetPosition(0, this.lookAtConstraint01);
 
 
-        if (this._controls && !this.context.isInXR) {
+        if (this._controls) {
             if (this.debugLog)
                 this._controls.domElement = this.context.renderer.domElement;
-            this._controls.enabled = !this._shouldDisable && this._camera === this.context.mainCameraComponent;
+            this._controls.enabled = !this._shouldDisable && this._camera === this.context.mainCameraComponent && !this.context.isInXR;
             this._controls.enableDamping = this.enableDamping;
             this._controls.keys = this.enableKeys ? defaultKeys : disabledKeys;
             this._controls.autoRotate = this.autoRotate;
@@ -283,7 +283,8 @@ export class OrbitControls extends Behaviour implements ICameraController {
             this._controls.enableZoom = this.enableZoom;
             this._controls.dampingFactor = this.dampingFactor;
             this._controls.enablePan = this.enablePan;
-            this._controls.update();
+            if (!this.context.isInXR)
+                this._controls.update();
         }
     }
 

package/src/engine-components/ParticleSystem.ts

@@ -69,7 +69,21 @@ export class ParticleSystemRenderer extends Behaviour {
         return res;
     }
 
+    private static _havePatchedQuarkShaders = false;
+
     getMaterial(trailEnabled: boolean = false) {
+
+        if (!ParticleSystemRenderer._havePatchedQuarkShaders) {
+            ParticleSystemRenderer._havePatchedQuarkShaders = true;
+            
+            // HACK patch three.quarks fo three152+, see https://github.com/Alchemist0823/three.quarks/issues/56#issuecomment-1560825038
+            const _rebuild = TrailBatch.prototype.rebuildMaterial;
+            TrailBatch.prototype.rebuildMaterial = function () {
+                _rebuild.call(this);
+                this.material.defines.MAP_UV = "uv";
+            }
+        }
+
         const material = (trailEnabled === true && this.trailMaterial) ? this.trailMaterial : this.particleMaterial;
 
         // progressive load on start

package/src/engine-components/ReflectionProbe.ts

@@ -1,5 +1,5 @@
 import { Behaviour } from "./Component";
-import { Box3, Color, EquirectangularReflectionMapping, LinearEncoding, LineBasicMaterial, Material, MeshStandardMaterial, Object3D, SrcAlphaFactor, sRGBEncoding, Texture, Vector3, WebGLCubeRenderTarget, WebGLRenderTarget } from "three";
+import { Box3, Color, EquirectangularReflectionMapping, LinearEncoding, LineBasicMaterial, Material, MeshStandardMaterial, Object3D, SrcAlphaFactor, SRGBColorSpace, sRGBEncoding, Texture, Vector3, WebGLCubeRenderTarget, WebGLRenderTarget } from "three";
 import { serializable } from "../engine/engine_serialization";
 import { Context } from "../engine/engine_setup";
 import { getWorldPosition, getWorldScale } from "../engine/engine_three_utils";
@@ -54,7 +54,7 @@ export class ReflectionProbe extends Behaviour {
         this._texture = tex;
         if (tex) {
             tex.mapping = EquirectangularReflectionMapping;
-            tex.encoding = sRGBEncoding;
+            tex.colorSpace = SRGBColorSpace;
             tex.needsUpdate = true;
         }
     }
@@ -89,7 +89,7 @@ export class ReflectionProbe extends Behaviour {
 
         if (this.texture) {
             this.texture.mapping = EquirectangularReflectionMapping;
-            this.texture.encoding = sRGBEncoding;
+            this.texture.colorSpace = SRGBColorSpace;
             this.texture.needsUpdate = true;
         }
     }

package/src/engine-components/Renderer.ts

@@ -20,7 +20,6 @@ export { InstancingUtil } from "../engine/engine_instancing";
 
 const debugRenderer = getParam("debugrenderer");
 const suppressInstancing = getParam("noInstancing");
-const debugLightmap = getParam("debuglightmaps") ? true : false;
 const debugInstancing = getParam("debuginstancing");
 const debugProgressiveLoading = getParam("debugprogressive");
 const suppressProgressiveLoading = getParam("noprogressive");
@@ -353,7 +352,7 @@ export class Renderer extends Behaviour implements IRenderer {
 
         if (this.isMultiMaterialObject(this.gameObject)) {
             for (const child of this.gameObject.children) {
-                this.context.addBeforeRenderListener(child, this.onBeforeRenderThree.bind(this));
+                this.context.addBeforeRenderListener(child, this.onBeforeRenderThree);
                 child.layers.mask = this.gameObject.layers.mask;
             }
 
@@ -377,14 +376,13 @@ export class Renderer extends Behaviour implements IRenderer {
         }
         // TODO: custom shader with sub materials
         else if (this.isMeshOrSkinnedMesh(this.gameObject)) {
-
-            this.context.addBeforeRenderListener(this.gameObject, this.onBeforeRenderThree.bind(this));
+            this.context.addBeforeRenderListener(this.gameObject, this.onBeforeRenderThree);
 
             if (this.renderOrder !== undefined && this.renderOrder.length > 0)
                 this.gameObject.renderOrder = this.renderOrder[0];
         }
         else {
-            this.context.addBeforeRenderListener(this.gameObject, this.onBeforeRenderThree.bind(this));
+            this.context.addBeforeRenderListener(this.gameObject, this.onBeforeRenderThree);
         }
 
         this.applyLightmapping();
@@ -416,11 +414,11 @@ export class Renderer extends Behaviour implements IRenderer {
                     const mat = this.gameObject["material"];
                     if (!mat?.isMeshBasicMaterial) {
                         if (this._lightmaps.length <= 0) {
-                            const rm = new RendererLightmap(this.gameObject, this.context);
+                            const rm = new RendererLightmap(this.gameObject as any as Mesh, this.context);
                             this._lightmaps.push(rm);
                         }
                         const rm = this._lightmaps[0];
-                        rm.init(this.lightmapIndex, this.lightmapScaleOffset, tex, debugLightmap);
+                        rm.init(this.lightmapIndex, this.lightmapScaleOffset, tex);
                     }
                     else {
                         if (mat)
@@ -435,16 +433,12 @@ export class Renderer extends Behaviour implements IRenderer {
                         if (!child["material"]?.isMeshBasicMaterial) {
                             let rm: RendererLightmap | undefined = undefined;
                             if (i >= this._lightmaps.length) {
-                                rm = new RendererLightmap(child as GameObject, this.context);
+                                rm = new RendererLightmap(child as Mesh, this.context);
                                 this._lightmaps.push(rm);
                             }
                             else
                                 rm = this._lightmaps[i];
-                            rm.init(this.lightmapIndex, this.lightmapScaleOffset, tex, debugLightmap);
-                            // onBeforeRender is not called when the renderer is on a group
-                            // this is an issue we probably also need to handle for custom shaders
-                            // and need a better solution, but for now this fixes lightmaps for multimaterial objects
-                            rm.bindOnBeforeRender();
+                            rm.init(this.lightmapIndex, this.lightmapScaleOffset, tex);
                         }
                     }
                 }
@@ -530,7 +524,6 @@ export class Renderer extends Behaviour implements IRenderer {
         }
 
         this.updateReflectionProbe();
-
     }
 
     onDisable() {
@@ -543,13 +536,22 @@ export class Renderer extends Behaviour implements IRenderer {
 
     onDestroy(): void {
         this.handles = null;
+
+        if (this.isMultiMaterialObject(this.gameObject)) {
+            for (const child of this.gameObject.children) {
+                this.context.removeBeforeRenderListener(child, this.onBeforeRenderThree);
+            }
+        }
+        else {
+            this.context.removeBeforeRenderListener(this.gameObject, this.onBeforeRenderThree);
+        }
+
     }
 
     applyStencil() {
         NEEDLE_render_objects.applyStencil(this);
     }
 
-
     onBeforeRender() {
         if (!this.gameObject) {
             return;
@@ -612,7 +614,9 @@ export class Renderer extends Behaviour implements IRenderer {
         }
 
     }
-    onBeforeRenderThree(_renderer, _scene, _camera, _geometry, material, _group) {
+
+
+    private onBeforeRenderThree = (_renderer, _scene, _camera, _geometry, material, _group) => {
 
         this.loadProgressiveTextures(material);
 
@@ -657,7 +661,7 @@ export class Renderer extends Behaviour implements IRenderer {
 
         if (this._lightmaps) {
             for (const lm of this._lightmaps) {
-                lm.onBeforeRenderThree(material);
+                lm.updateLightmapUniforms(material);
             }
         }
     }