@needle-tools/engine 4.1.0-experimental.13 → 4.1.1

package/src/engine-components/GroundProjection.ts

@@ -3,7 +3,7 @@ import { GroundedSkybox as GroundProjection } from 'three/examples/jsm/objects/G
 
 import { Gizmos } from "../engine/engine_gizmos.js";
 import { serializable } from "../engine/engine_serialization_decorator.js";
-import { getBoundingBox, getTempVector, getWorldScale, Graphics, setVisibleInCustomShadowRendering,setWorldPosition } from "../engine/engine_three_utils.js";
+import { getBoundingBox, getTempVector, getWorldScale, Graphics, setVisibleInCustomShadowRendering, setWorldPosition } from "../engine/engine_three_utils.js";
 import { delayForFrames, getParam, Watch as Watch } from "../engine/engine_utils.js";
 import { Behaviour } from "./Component.js";
 
@@ -37,7 +37,7 @@ export class GroundProjectedEnv extends Behaviour {
     @serializable()
     set radius(val: number) {
         this._radius = val;
-        this.updateProjection();
+        if (this._projection) this.updateProjection();
     }
     get radius(): number { return this._radius; }
     private _radius: number = 50;
@@ -49,7 +49,7 @@ export class GroundProjectedEnv extends Behaviour {
     @serializable()
     set height(val: number) {
         this._height = val;
-        this.updateProjection();
+        if (this._projection) this.updateProjection();
     }
     get height(): number { return this._height; }
     private _height: number = 3;
@@ -68,7 +68,7 @@ export class GroundProjectedEnv extends Behaviour {
     get arBlending(): number { return this._arblending; }
     private _arblending = 0;
 
-    private _lastEnvironment?: Texture;
+    private _lastBackground?: Texture;
     private _lastRadius?: number;
     private _lastHeight?: number;
     private _projection?: GroundProjection;
@@ -88,9 +88,10 @@ export class GroundProjectedEnv extends Behaviour {
                 this.updateAndCreate();
         }
         if (!this._watcher) {
-            this._watcher = new Watch(this.context.scene, "environment");
+            this._watcher = new Watch(this.context.scene, "background");
             this._watcher.subscribeWrite(_ => {
-                this.updateProjection();
+                if (debug) console.log("Background changed", this.context.scene.background);
+                this._needsTextureUpdate = true;
             });
         }
     }
@@ -101,13 +102,13 @@ export class GroundProjectedEnv extends Behaviour {
     }
     /** @internal */
     onEnterXR(): void {
-        if(!this.activeAndEnabled) return;
+        if (!this.activeAndEnabled) return;
         this._needsTextureUpdate = true;
         this.updateProjection();
     }
     /** @internal */
     async onLeaveXR() {
-        if(!this.activeAndEnabled) return;
+        if (!this.activeAndEnabled) return;
         await delayForFrames(1);
         this.updateProjection();
     }
@@ -121,8 +122,8 @@ export class GroundProjectedEnv extends Behaviour {
         if (blurrinessChanged) {
             this.updateProjection();
         }
-        else if (this._needsTextureUpdate) {
-            this.updateBlurriness();
+        else if (this._needsTextureUpdate && this.context.scene.background instanceof Texture) {
+            this.updateBlurriness(this.context.scene.background, this.context.scene.backgroundBlurriness);
         }
     }
 
@@ -138,10 +139,16 @@ export class GroundProjectedEnv extends Behaviour {
      * Updates the ground projection. This is called automatically when the environment or settings change.
      */
     updateProjection() {
-        if (!this.context.scene.environment) {
+        if (!this.context.scene.background) {
+            this._projection?.removeFromParent();
+            return;
+        }
+        const backgroundTexture = this.context.scene.background;
+        if (!(backgroundTexture instanceof Texture)) {
             this._projection?.removeFromParent();
             return;
         }
+
         if (this.context.xr?.isPassThrough || this.context.xr?.isAR) {
             if (this.arBlending === 0) {
                 this._projection?.removeFromParent();
@@ -152,25 +159,25 @@ export class GroundProjectedEnv extends Behaviour {
         if (!this.gameObject || this.destroyed) {
             return;
         }
-        
+
         let needsNewAutoFit = true;
         // offset here must be zero (and not .01) because the plane occlusion (when mesh tracking is active) is otherwise not correct
         const offset = 0;
-        if (!this._projection || this.context.scene.environment !== this._lastEnvironment || this._height !== this._lastHeight || this._radius !== this._lastRadius) {
-            if (debug)
-                console.log("Create/Update Ground Projection", this.context.scene.environment.name);
+
+        const hasChanged = backgroundTexture !== this._lastBackground || this._height !== this._lastHeight || this._radius !== this._lastRadius;
+
+        if (!this._projection || hasChanged) {
+            if (debug) console.log("Create/Update Ground Projection", backgroundTexture.name);
+
             this._projection?.removeFromParent();
-            if (!this._projection || (this.context.scene.environment !== this._lastEnvironment || this._lastHeight !== this._height || this._lastRadius !== this._radius)) {
-                try {
-                    this._projection = new GroundProjection(this.context.scene.environment, this._height, this.radius, 64);
-                }
-                catch (e) {
-                    console.error("Failed to enable GroundProjection for environment", e);
-                    return;
-                }
+
+            try {
+                this._projection = new GroundProjection(backgroundTexture, this._height, this._radius, 64);
+            }
+            catch (e) {
+                console.error("Error creating three GroundProjection", e);
+                return;
             }
-            else
-                needsNewAutoFit = false;
             this._projection.position.y = this._height - offset;
             this._projection.name = "GroundProjection";
             setVisibleInCustomShadowRendering(this._projection, false);
@@ -205,35 +212,35 @@ export class GroundProjectedEnv extends Behaviour {
         this.env.radius = this._radius;
         this.env.height = this._height;
         */
-       
+
         if (this.context.scene.backgroundBlurriness > 0.001 && this._needsTextureUpdate) {
-            this.updateBlurriness();
+            this.updateBlurriness(backgroundTexture, this.context.scene.backgroundBlurriness);
         }
 
-        this._lastEnvironment = this.context.scene.environment;
+        this._lastBackground = backgroundTexture;
         this._lastHeight = this._height;
         this._lastRadius = this._radius;
-
         this._needsTextureUpdate = false;
     }
 
     private _blurrynessShader: ShaderMaterial | null = null;
     private _lastBlurriness: number = -1;
 
-    private updateBlurriness() {
+    private updateBlurriness(texture: Texture, blurriness: number) {
         if (!this._projection) {
             return;
         }
-        else if (!this.context.scene.environment) {
+        else if (!texture) {
             return;
         }
+
         this._needsTextureUpdate = false;
-        if (debug) console.log("Update Blurriness", this.context.scene.backgroundBlurriness);
+        if (debug) console.log("Update Blurriness", blurriness);
         this._blurrynessShader ??= new ShaderMaterial({
             name: "GroundProjectionBlurriness",
             uniforms: {
-                map: { value: this.context.scene.environment },
-                blurriness: { value: this.context.scene.backgroundBlurriness },
+                map: { value: texture },
+                blurriness: { value: blurriness },
                 blending: { value: 0 },
                 alphaFactor: { value: 1 }
             },
@@ -241,9 +248,10 @@ export class GroundProjectedEnv extends Behaviour {
             fragmentShader: blurFragmentShader
         });
         this._blurrynessShader.depthWrite = false;
-        this._blurrynessShader.uniforms.blurriness.value = this.context.scene.backgroundBlurriness;
-        this._lastBlurriness = this.context.scene.backgroundBlurriness;
-        this.context.scene.environment.needsPMREMUpdate = true;
+        this._blurrynessShader.uniforms.map.value = texture;
+        this._blurrynessShader.uniforms.blurriness.value = 1;//blurriness;
+        this._lastBlurriness = blurriness;
+        texture.needsUpdate = true;
 
         const wasTransparent = this._projection.material.transparent;
         this._projection.material.transparent = (this.context.xr?.isAR === true && this.arBlending > 0.000001) ?? false;
@@ -266,7 +274,7 @@ export class GroundProjectedEnv extends Behaviour {
         }
 
         // Update the texture
-        this._projection.material.map = Graphics.copyTexture(this.context.scene.environment, this._blurrynessShader);
+        this._projection.material.map = Graphics.copyTexture(texture, this._blurrynessShader);
         this._projection.material.depthTest = true;
         this._projection.material.depthWrite = false;
     }

package/src/engine-components/OrbitControls.ts

@@ -287,7 +287,7 @@ export class OrbitControls extends Behaviour implements ICameraController {
             cam = this.gameObject;
         }
         if (cam) setCameraController(cam, this, true);
-        if (!this._controls && cam instanceof PerspectiveCamera) {
+        if (!this._controls && cam instanceof Object3D) {
             this._cameraObject = cam;
             // Using the parent if possible to make it possible to disable input on the canvas
             // for having HTML content behind it and still receive input
@@ -297,6 +297,14 @@ export class OrbitControls extends Behaviour implements ICameraController {
             this._controls = new ThreeOrbitControls(cam!, element);
             cam?.quaternion.copy(mat!)
             if (defaultKeys === undefined) defaultKeys = { ...this._controls.keys };
+            // set controls look point in front of the current camera by default
+            // it may be overriden by the autoTarget feature
+            // but if we don't do this and autoTarget is OFF then the camera will turn to look at 0 0 0 of the scene 
+            const worldPosition = getWorldPosition(cam);
+            const forward = this.gameObject.worldForward;
+            const dist = 2.5;
+            const lookAt = worldPosition.clone().sub(forward.multiplyScalar(dist));
+            this._controls.target.copy(lookAt);
         }
 
         if (this._controls) {

package/src/engine-components/RigidBody.ts

@@ -1,13 +1,14 @@
 import { Matrix4, Object3D, Quaternion, Vector3, Vector3Like } from "three";
 
 import { isDevEnvironment } from "../engine/debug/index.js";
+import { MODULES } from "../engine/engine_modules.js";
 import { CollisionDetectionMode, RigidbodyConstraints } from "../engine/engine_physics.types.js";
 import { serializable } from "../engine/engine_serialization_decorator.js";
 import { Context, FrameEvent } from "../engine/engine_setup.js";
 import { getWorldPosition } from "../engine/engine_three_utils.js";
 import type { IRigidbody, Vec3 } from "../engine/engine_types.js";
 import { validate } from "../engine/engine_util_decorator.js";
-import { Watch } from "../engine/engine_utils.js";
+import { delayForFrames, Watch } from "../engine/engine_utils.js";
 import { Behaviour } from "./Component.js";
 
 class TransformWatch {
@@ -139,6 +140,8 @@ class TransformWatch {
  */
 export class Rigidbody extends Behaviour implements IRigidbody {
 
+    get isRigidbody() { return true; }
+
     /** When true the mass will be automatically calculated by the attached colliders */
     @validate()
     autoMass: boolean = true;
@@ -316,11 +319,16 @@ export class Rigidbody extends Behaviour implements IRigidbody {
         }
         this._watch.start(true, true);
         this.startCoroutine(this.beforePhysics(), FrameEvent.LateUpdate);
-        if (isDevEnvironment() && !this.context.physics.engine?.getBody(this)) {
+        if (isDevEnvironment()) {
             if (!globalThis["NEEDLE_USE_RAPIER"])
                 console.warn(`Rigidbody could not be created: Rapier physics are explicitly disabled.`);
-            else
-                console.warn(`Rigidbody could not be created. Ensure \"(${this.name}\" has a Collider component.`);
+            else {
+                MODULES.RAPIER_PHYSICS.ready().then(async () => {
+                    await delayForFrames(3);
+                    if (!this.context.physics.engine?.getBody(this))
+                        console.warn(`Rigidbody could not be created. Ensure \"${this.name}\" has a Collider component.`);
+                })
+            }
         }
     }
 
@@ -338,7 +346,7 @@ export class Rigidbody extends Behaviour implements IRigidbody {
     }
 
     // need to do this right before updating physics to prevent rendered object glitching through physical bodies
-    *beforePhysics() {
+    * beforePhysics() {
         while (true) {
             if (this._propertiesChanged) {
                 this._propertiesChanged = false;

package/src/engine-components/SceneSwitcher.ts

@@ -760,7 +760,7 @@ export class SceneSwitcher extends Behaviour {
             }
             this._lastLoadingScene = this.loadingScene;
             if (!this._loadingScenePromise) {
-                this._loadingScenePromise = this.loadingScene?.loadAssetAsync();
+                this._loadingScenePromise = this.loadingScene?.loadAssetAsync().then(res => res != null);
             }
             await this._loadingScenePromise;
             if (this._isCurrentlyLoading && this.loadingScene?.asset) {

package/src/engine-components/SpatialTrigger.ts

@@ -62,23 +62,23 @@ export class SpatialTriggerReceiver extends Behaviour {
 
     }
 
-    currentIntersected: SpatialTrigger[] = [];
-    lastIntersected: SpatialTrigger[] = [];
+    readonly currentIntersected: SpatialTrigger[] = [];
+    readonly lastIntersected: SpatialTrigger[] = [];
 
     onEnterTrigger(trigger: SpatialTrigger): void {
         if(debug) console.log("ENTER TRIGGER", this.name, trigger.name, this, trigger);
         trigger.raiseOnEnterEvent(this);
-        this.onEnter?.invoke(this, trigger);
+        this.onEnter?.invoke();
     }
     onExitTrigger(trigger: SpatialTrigger): void {
-        if(debug) console.log("EXIT TRIGGER", this.name, trigger.name, this, trigger);
+        if(debug) console.log("EXIT TRIGGER", this.name, trigger.name, );
         trigger.raiseOnExitEvent(this);
-        this.onExit?.invoke(this, trigger);
+        this.onExit?.invoke();
     }
 
     onStayTrigger(trigger: SpatialTrigger): void {
         trigger.raiseOnStayEvent(this);
-        this.onStay?.invoke(this, trigger);
+        this.onStay?.invoke();
     }
 }
 

package/src/engine-components/TransformGizmo.ts

@@ -1,4 +1,4 @@
-import { MathUtils,Mesh, MeshBasicMaterial, Object3D } from "three";
+import { MathUtils, Mesh, MeshBasicMaterial, Object3D } from "three";
 import { TransformControls } from "three/examples/jsm/controls/TransformControls.js";
 
 import * as params from "../engine/engine_default_parameters.js";
@@ -26,7 +26,15 @@ export class TransformGizmo extends Behaviour {
     @serializable()
     public scaleSnap: number = .25;
 
-    private control?: TransformControls;
+    /**
+     * Get the underlying three.js TransformControls instance.
+     * @returns The TransformControls instance.
+     */
+    get control() {
+        return this._control;
+    }
+
+    private _control?: TransformControls;
     private orbit?: OrbitControls;
 
     /** @internal */
@@ -35,12 +43,12 @@ export class TransformGizmo extends Behaviour {
 
         if (!this.context.mainCamera) return;
 
-        if (!this.control) {
-            this.control = new TransformControls(this.context.mainCamera, this.context.renderer.domElement);
-            this.control.enabled = true;
-            this.control.getRaycaster().layers.set(2);
-            this.control.size = 1;
-            const obj = ("_root" in this.control ? this.control._root : this.control) as Object3D;
+        if (!this._control) {
+            this._control = new TransformControls(this.context.mainCamera, this.context.renderer.domElement);
+            this._control.enabled = true;
+            this._control.getRaycaster().layers.set(2);
+            this._control.size = 1;
+            const obj = ("_root" in this._control ? this._control._root : this._control) as Object3D;
             obj.traverse(x => {
                 const mesh = x as Mesh;
                 mesh.layers.set(2);
@@ -54,12 +62,12 @@ export class TransformGizmo extends Behaviour {
             this.orbit = GameObject.getComponentInParent(this.context.mainCamera, OrbitControls) ?? undefined;
         }
 
-        if (this.control) {
-            const obj = this.control.getHelper();
+        if (this._control) {
+            const obj = this._control.getHelper();
             this.context.scene.add(obj);
-            this.control.attach(this.gameObject);
+            this._control.attach(this.gameObject);
 
-            this.control?.addEventListener('dragging-changed', this.onControlChangedEvent);
+            this._control?.addEventListener('dragging-changed', this.onControlChangedEvent);
             window.addEventListener('keydown', this.windowKeyDownListener);
             window.addEventListener('keyup', this.windowKeyUpListener);
         }
@@ -67,25 +75,25 @@ export class TransformGizmo extends Behaviour {
 
     /** @internal */
     onDisable() {
-        this.control?.getHelper()?.removeFromParent();
-        this.control?.removeEventListener('dragging-changed', this.onControlChangedEvent);
+        this._control?.getHelper()?.removeFromParent();
+        this._control?.removeEventListener('dragging-changed', this.onControlChangedEvent);
         window.removeEventListener('keydown', this.windowKeyDownListener);
         window.removeEventListener('keyup', this.windowKeyUpListener);
     }
 
     enableSnapping() {
-        if (this.control) {
-            this.control.setTranslationSnap(this.translationSnap);
-            this.control.setRotationSnap(MathUtils.degToRad(this.rotationSnapAngle));
-            this.control.setScaleSnap(this.scaleSnap);
+        if (this._control) {
+            this._control.setTranslationSnap(this.translationSnap);
+            this._control.setRotationSnap(MathUtils.degToRad(this.rotationSnapAngle));
+            this._control.setScaleSnap(this.scaleSnap);
         }
     }
 
     disableSnapping() {
-        if (this.control) {
-            this.control.setTranslationSnap(null);
-            this.control.setRotationSnap(null);
-            this.control.setScaleSnap(null);
+        if (this._control) {
+            this._control.setTranslationSnap(null);
+            this._control.setRotationSnap(null);
+            this._control.setScaleSnap(null);
         }
     }
 
@@ -104,11 +112,11 @@ export class TransformGizmo extends Behaviour {
 
     private windowKeyDownListener = (event) => {
         if (!this.enabled) return;
-        if (!this.control) return;
+        if (!this._control) return;
         switch (event.keyCode) {
 
             case 81: // Q
-                this.control.setSpace(this.control.space === 'local' ? 'world' : 'local');
+                this._control.setSpace(this._control.space === 'local' ? 'world' : 'local');
                 break;
 
             case 16: // Shift
@@ -116,40 +124,40 @@ export class TransformGizmo extends Behaviour {
                 break;
 
             case 87: // W
-                this.control.setMode('translate');
+                this._control.setMode('translate');
                 break;
 
             case 69: // E
-                this.control.setMode('rotate');
+                this._control.setMode('rotate');
                 break;
 
             case 82: // R
-                this.control.setMode('scale');
+                this._control.setMode('scale');
                 break;
             case 187:
             case 107: // +, =, num+
-                this.control.setSize(this.control.size + 0.1);
+                this._control.setSize(this._control.size + 0.1);
                 break;
 
             case 189:
             case 109: // -, _, num-
-                this.control.setSize(Math.max(this.control.size - 0.1, 0.1));
+                this._control.setSize(Math.max(this._control.size - 0.1, 0.1));
                 break;
 
             case 88: // X
-                this.control.showX = !this.control.showX;
+                this._control.showX = !this._control.showX;
                 break;
 
             case 89: // Y
-                this.control.showY = !this.control.showY;
+                this._control.showY = !this._control.showY;
                 break;
 
             case 90: // Z
-                this.control.showZ = !this.control.showZ;
+                this._control.showZ = !this._control.showZ;
                 break;
 
             case 32: // Spacebar
-                this.control.enabled = !this.control.enabled;
+                this._control.enabled = !this._control.enabled;
                 break;
         }
     }

package/src/engine-components/VideoPlayer.ts

@@ -1017,7 +1017,6 @@ class ScreenspaceTexture extends ShaderMaterial {
             else
             {
                 vec4 texcolor = texture2D(map, vUv);
-                texcolor = LinearTosRGB(texcolor);
                 gl_FragColor = texcolor;
             }
         }

package/src/engine-components/export/gltf/GltfExport.ts

@@ -6,6 +6,8 @@ import { SerializationContext } from "../../../engine/engine_serialization_core.
 import { serializable } from "../../../engine/engine_serialization_decorator.js";
 import { getWorldPosition } from "../../../engine/engine_three_utils.js";
 import { getParam } from "../../../engine/engine_utils.js";
+import { RenderTextureWriter } from "../../../engine/export/gltf/Writers.js";
+import { shouldExport_HideFlags } from "../../../engine/export/utils.js";
 import { registerExportExtensions } from "../../../engine/extensions/index.js";
 import { NEEDLE_components } from "../../../engine/extensions/NEEDLE_components.js";
 import GLTFMeshGPUInstancingExtension from '../../../include/three/EXT_mesh_gpu_instancing_exporter.js';
@@ -48,8 +50,8 @@ export class GltfExport extends Behaviour {
         if (!this.objects || this.objects.length <= 0)
             this.objects = [this.context.scene];
 
-        const options = { 
-            binary: this.binary, 
+        const options = {
+            binary: this.binary,
             pivot: GltfExport.calculateCenter(this.objects),
             ...opts
         };
@@ -74,6 +76,15 @@ export class GltfExport extends Behaviour {
 
     async export(objectsToExport: Object3D[], opts?: ExportOptions): Promise<any> {
 
+        // -----------------------
+        // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        // TODO: refactor this to use ../engine/export/index exportAsGLTF function
+
+        // TODO add filtering / tags for what to export and what not < this is implemented in exportAsGLTF, see TODO above
+
         if (!objectsToExport || objectsToExport.length <= 0) {
             console.warn("No objects set to export");
             return;
@@ -82,12 +93,11 @@ export class GltfExport extends Behaviour {
         // Instantiate a exporter
         const exporter = new GLTFExporter();
         exporter.register(writer => new GLTFMeshGPUInstancingExtension(writer));
+        exporter.register(writer => new RenderTextureWriter(writer));
         registerExportExtensions(exporter, this.context);
 
         GltfExport.filterTopmostParent(objectsToExport);
 
-        // TODO export only worldglb BUT exclude "World" child which contains all build tools
-        // TODO add filtering / tags for what to export and what not
 
         // https://threejs.org/docs/#examples/en/exporters/GLTFExporter
         const options = {
@@ -102,7 +112,7 @@ export class GltfExport extends Behaviour {
             ...opts
         };
 
-        // hide objects that we don't want to export
+        const undo = new Array<() => void>();
 
         const exportScene = new Object3D();
         // set the pivot position
@@ -112,7 +122,7 @@ export class GltfExport extends Behaviour {
         // add objects for export
         if (debugExport) console.log("EXPORT", objectsToExport);
         objectsToExport.forEach(obj => {
-            if (obj) {
+            if (obj && shouldExport_HideFlags(obj)) {
                 // adding directly does not require us to change parents and mess with the hierarchy actually
                 exportScene.children.push(obj);
                 // TODO: we should probably be doing this before writing nodes?? apply world scale, position, rotation etc for export only
@@ -122,6 +132,15 @@ export class GltfExport extends Behaviour {
                 GameObject.getComponentsInChildren(obj, Renderer).forEach(r => {
                     if (GameObject.isActiveInHierarchy(r.gameObject)) r.setInstancingEnabled(false)
                 });
+                obj.traverse(o => {
+                    if (!shouldExport_HideFlags(o)) {
+                        const parent = o.parent;
+                        o.removeFromParent();
+                        undo.push(() => {
+                            if (parent) parent.add(o);
+                        });
+                    }
+                })
             }
         });
 
@@ -159,6 +178,7 @@ export class GltfExport extends Behaviour {
                 reject(err);
             }
             finally {
+                undo.forEach(u => u());
                 if (debugExport) console.log("Finished glTF export.");
             }
         });

package/src/engine-components/export/usdz/ThreeUSDZExporter.ts

@@ -1174,7 +1174,7 @@ declare type ImageReadbackResult = {
 	imageBitmap?: ImageBitmap;
 } 
 
-/** Reads back a texture from the GPU (can be compressed, a render texture, or aynthing), apply colorScale to it, and return CPU data for further usage. 
+/** Reads back a texture from the GPU (can be compressed, a render texture, or anything), optionally applies RGBA colorScale to it, and returns CPU data for further usage. 
  * Note that there are WebGL / WebGPU rules preventing some use of data between WebGL contexts.
 */
 async function decompressGpuTexture( texture, maxTextureSize = Infinity, renderer: WebGLRenderer | null = null, colorScale: Vector4 | undefined = undefined): Promise<ImageReadbackResult> {
@@ -1204,7 +1204,7 @@ async function decompressGpuTexture( texture, maxTextureSize = Infinity, rendere
                 gl_FragColor = vec4(vUv.xy, 0, 1);
                 
                 #ifdef IS_SRGB
-                gl_FragColor = LinearTosRGB( texture2D( blitTexture, vUv) );
+                gl_FragColor = sRGBTransferOETF( texture2D( blitTexture, vUv) );
                 #else
                 gl_FragColor = texture2D( blitTexture, vUv);
                 #endif

package/src/engine-components/export/usdz/index.ts

@@ -1,3 +1,3 @@
 export { type UsdzBehaviour } from "./extensions/behavior/Behaviour.js";
-export { imageToCanvas, makeNameSafeForUSD, USDZExporter as NeedleUSDZExporter, USDDocument, USDObject, USDWriter,type USDZExporterContext } from "./ThreeUSDZExporter.js";
+export { decompressGpuTexture, imageToCanvas, makeNameSafeForUSD, USDZExporter as NeedleUSDZExporter, USDDocument, USDObject, USDWriter,type USDZExporterContext } from "./ThreeUSDZExporter.js";
 export { USDZExporter } from "./USDZExporter.js";