@needle-tools/engine 3.28.7-beta → 3.28.7-beta.1

package/lib/engine-components/ReflectionProbe.js

@@ -1,182 +1,182 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { Behaviour } from "./Component.js";
-import { EquirectangularReflectionMapping, SRGBColorSpace, Texture, Vector3 } from "three";
-import { serializable } from "../engine/engine_serialization.js";
-import { BoxHelperComponent } from "./BoxHelperComponent.js";
-import { getParam } from "../engine/engine_utils.js";
-export const debug = getParam("debugreflectionprobe");
-const disable = getParam("noreflectionprobe");
-const $reflectionProbeKey = Symbol("reflectionProbeKey");
-const $originalMaterial = Symbol("original material");
-export class ReflectionProbe extends Behaviour {
-    static _probes = new Map();
-    static get(object, context, isAnchor, anchor) {
-        if (!object || object.isObject3D !== true)
-            return null;
-        if (disable)
-            return null;
-        const probes = ReflectionProbe._probes.get(context);
-        if (probes) {
-            for (const probe of probes) {
-                if (!probe.__didAwake)
-                    probe.__internalAwake();
-                if (probe.enabled) {
-                    if (anchor) {
-                        // test if anchor is reflection probe object
-                        if (probe.gameObject === anchor) {
-                            return probe;
-                        }
-                    }
-                    else if (probe.isInBox(object, undefined)) {
-                        if (debug)
-                            console.log("Found reflection probe", object.name, probe.name);
-                        return probe;
-                    }
-                }
-            }
-        }
-        if (debug)
-            console.debug("Did not find reflection probe", object.name, isAnchor, object);
-        return null;
-    }
-    _texture;
-    set texture(tex) {
-        if (tex && !(tex instanceof Texture)) {
-            console.error("ReflectionProbe.texture must be a Texture", tex);
-            return;
-        }
-        this._texture = tex;
-        if (tex) {
-            tex.mapping = EquirectangularReflectionMapping;
-            tex.colorSpace = SRGBColorSpace;
-            tex.needsUpdate = true;
-        }
-    }
-    get texture() {
-        return this._texture;
-    }
-    center;
-    size;
-    _boxHelper;
-    isInBox(obj, scaleFactor) {
-        return this._boxHelper?.isInBox(obj, scaleFactor);
-    }
-    constructor() {
-        super();
-        if (!ReflectionProbe._probes.has(this.context)) {
-            ReflectionProbe._probes.set(this.context, []);
-        }
-        ReflectionProbe._probes.get(this.context)?.push(this);
-    }
-    awake() {
-        this._boxHelper = this.gameObject.addNewComponent(BoxHelperComponent);
-        this._boxHelper.updateBox(true);
-        if (debug)
-            this._boxHelper.showHelper(0x555500, true);
-        if (this.texture) {
-            this.texture.mapping = EquirectangularReflectionMapping;
-            this.texture.colorSpace = SRGBColorSpace;
-            this.texture.needsUpdate = true;
-        }
-    }
-    onDestroy() {
-        const probes = ReflectionProbe._probes.get(this.context);
-        if (probes) {
-            const index = probes.indexOf(this);
-            if (index >= 0) {
-                probes.splice(index, 1);
-            }
-        }
-    }
-    // when objects are rendered and they share material
-    // and some need reflection probe and some don't
-    // we need to make sure we don't override the material but use a copy
-    static _rendererMaterialsCache = new Map();
-    onSet(_rend) {
-        if (disable)
-            return;
-        if (!this.enabled)
-            return;
-        if (_rend.sharedMaterials?.length <= 0)
-            return;
-        if (!this.texture)
-            return;
-        let rendererCache = ReflectionProbe._rendererMaterialsCache.get(_rend);
-        if (!rendererCache) {
-            rendererCache = [];
-            ReflectionProbe._rendererMaterialsCache.set(_rend, rendererCache);
-        }
-        // TODO: dont clone material for every renderer that uses reflection probes, we can do it once per material when they use the same reflection texture
-        // 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 material = _rend.sharedMaterials[i];
-            if (!material) {
-                continue;
-            }
-            if (material["envMap"] === undefined) {
-                continue;
-            }
-            let cached = rendererCache[i];
-            // make sure we have the currently assigned material cached (and an up to date clone of that)
-            // TODO: this is causing problems with progressive textures sometimes (depending on the order) when the version changes and we re-create materials over and over. We might want to just set the material envmap instead of making a clone
-            const isCachedInstance = material === cached?.copy;
-            const hasChanged = !cached || cached.material.uuid !== material.uuid || cached.copy.version !== material.version;
-            if (!isCachedInstance && hasChanged) {
-                if (debug) {
-                    let reason = "";
-                    if (!cached)
-                        reason = "not cached";
-                    else if (cached.material !== material)
-                        reason = "reference changed; cached instance?: " + isCachedInstance;
-                    else if (cached.copy.version !== material.version)
-                        reason = "version changed";
-                    console.warn("Cloning material", material.name, material.version, "Reason:", reason, "\n", material.uuid, "\n", cached?.copy.uuid, "\n", _rend.name);
-                }
-                const clone = material.clone();
-                clone.version = material.version;
-                if (cached) {
-                    cached.copy = clone;
-                    cached.material = material;
-                }
-                else {
-                    cached = {
-                        material: material,
-                        copy: clone
-                    };
-                    rendererCache.push(cached);
-                }
-                clone[$reflectionProbeKey] = this;
-                clone[$originalMaterial] = material;
-                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;
-            // make sure the reflection probe is assigned
-            copy["envMap"] = this.texture;
-            _rend.sharedMaterials[i] = copy;
-        }
-    }
-    onUnset(_rend) {
-        const rendererCache = ReflectionProbe._rendererMaterialsCache.get(_rend);
-        if (rendererCache) {
-            for (let i = 0; i < rendererCache.length; i++) {
-                const cached = rendererCache[i];
-                _rend.sharedMaterials[i] = cached.material;
-            }
-        }
-    }
-}
-__decorate([
-    serializable(Vector3)
-], ReflectionProbe.prototype, "center", void 0);
-__decorate([
-    serializable(Vector3)
-], ReflectionProbe.prototype, "size", void 0);
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Behaviour } from "./Component.js";
+import { EquirectangularReflectionMapping, SRGBColorSpace, Texture, Vector3 } from "three";
+import { serializable } from "../engine/engine_serialization.js";
+import { BoxHelperComponent } from "./BoxHelperComponent.js";
+import { getParam } from "../engine/engine_utils.js";
+export const debug = getParam("debugreflectionprobe");
+const disable = getParam("noreflectionprobe");
+const $reflectionProbeKey = Symbol("reflectionProbeKey");
+const $originalMaterial = Symbol("original material");
+export class ReflectionProbe extends Behaviour {
+    static _probes = new Map();
+    static get(object, context, isAnchor, anchor) {
+        if (!object || object.isObject3D !== true)
+            return null;
+        if (disable)
+            return null;
+        const probes = ReflectionProbe._probes.get(context);
+        if (probes) {
+            for (const probe of probes) {
+                if (!probe.__didAwake)
+                    probe.__internalAwake();
+                if (probe.enabled) {
+                    if (anchor) {
+                        // test if anchor is reflection probe object
+                        if (probe.gameObject === anchor) {
+                            return probe;
+                        }
+                    }
+                    else if (probe.isInBox(object, undefined)) {
+                        if (debug)
+                            console.log("Found reflection probe", object.name, probe.name);
+                        return probe;
+                    }
+                }
+            }
+        }
+        if (debug)
+            console.debug("Did not find reflection probe", object.name, isAnchor, object);
+        return null;
+    }
+    _texture;
+    set texture(tex) {
+        if (tex && !(tex instanceof Texture)) {
+            console.error("ReflectionProbe.texture must be a Texture", tex);
+            return;
+        }
+        this._texture = tex;
+        if (tex) {
+            tex.mapping = EquirectangularReflectionMapping;
+            tex.colorSpace = SRGBColorSpace;
+            tex.needsUpdate = true;
+        }
+    }
+    get texture() {
+        return this._texture;
+    }
+    center;
+    size;
+    _boxHelper;
+    isInBox(obj, scaleFactor) {
+        return this._boxHelper?.isInBox(obj, scaleFactor);
+    }
+    constructor() {
+        super();
+        if (!ReflectionProbe._probes.has(this.context)) {
+            ReflectionProbe._probes.set(this.context, []);
+        }
+        ReflectionProbe._probes.get(this.context)?.push(this);
+    }
+    awake() {
+        this._boxHelper = this.gameObject.addNewComponent(BoxHelperComponent);
+        this._boxHelper.updateBox(true);
+        if (debug)
+            this._boxHelper.showHelper(0x555500, true);
+        if (this.texture) {
+            this.texture.mapping = EquirectangularReflectionMapping;
+            this.texture.colorSpace = SRGBColorSpace;
+            this.texture.needsUpdate = true;
+        }
+    }
+    onDestroy() {
+        const probes = ReflectionProbe._probes.get(this.context);
+        if (probes) {
+            const index = probes.indexOf(this);
+            if (index >= 0) {
+                probes.splice(index, 1);
+            }
+        }
+    }
+    // when objects are rendered and they share material
+    // and some need reflection probe and some don't
+    // we need to make sure we don't override the material but use a copy
+    static _rendererMaterialsCache = new Map();
+    onSet(_rend) {
+        if (disable)
+            return;
+        if (!this.enabled)
+            return;
+        if (_rend.sharedMaterials?.length <= 0)
+            return;
+        if (!this.texture)
+            return;
+        let rendererCache = ReflectionProbe._rendererMaterialsCache.get(_rend);
+        if (!rendererCache) {
+            rendererCache = [];
+            ReflectionProbe._rendererMaterialsCache.set(_rend, rendererCache);
+        }
+        // TODO: dont clone material for every renderer that uses reflection probes, we can do it once per material when they use the same reflection texture
+        // 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 material = _rend.sharedMaterials[i];
+            if (!material) {
+                continue;
+            }
+            if (material["envMap"] === undefined) {
+                continue;
+            }
+            let cached = rendererCache[i];
+            // make sure we have the currently assigned material cached (and an up to date clone of that)
+            // TODO: this is causing problems with progressive textures sometimes (depending on the order) when the version changes and we re-create materials over and over. We might want to just set the material envmap instead of making a clone
+            const isCachedInstance = material === cached?.copy;
+            const hasChanged = !cached || cached.material.uuid !== material.uuid || cached.copy.version !== material.version;
+            if (!isCachedInstance && hasChanged) {
+                if (debug) {
+                    let reason = "";
+                    if (!cached)
+                        reason = "not cached";
+                    else if (cached.material !== material)
+                        reason = "reference changed; cached instance?: " + isCachedInstance;
+                    else if (cached.copy.version !== material.version)
+                        reason = "version changed";
+                    console.warn("Cloning material", material.name, material.version, "Reason:", reason, "\n", material.uuid, "\n", cached?.copy.uuid, "\n", _rend.name);
+                }
+                const clone = material.clone();
+                clone.version = material.version;
+                if (cached) {
+                    cached.copy = clone;
+                    cached.material = material;
+                }
+                else {
+                    cached = {
+                        material: material,
+                        copy: clone
+                    };
+                    rendererCache.push(cached);
+                }
+                clone[$reflectionProbeKey] = this;
+                clone[$originalMaterial] = material;
+                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;
+            // make sure the reflection probe is assigned
+            copy["envMap"] = this.texture;
+            _rend.sharedMaterials[i] = copy;
+        }
+    }
+    onUnset(_rend) {
+        const rendererCache = ReflectionProbe._rendererMaterialsCache.get(_rend);
+        if (rendererCache) {
+            for (let i = 0; i < rendererCache.length; i++) {
+                const cached = rendererCache[i];
+                _rend.sharedMaterials[i] = cached.material;
+            }
+        }
+    }
+}
+__decorate([
+    serializable(Vector3)
+], ReflectionProbe.prototype, "center", void 0);
+__decorate([
+    serializable(Vector3)
+], ReflectionProbe.prototype, "size", void 0);
 //# sourceMappingURL=ReflectionProbe.js.map

package/lib/engine-components/Renderer.d.ts

@@ -1,112 +1,112 @@
-import { Behaviour } from "./Component.js";
-import * as THREE from "three";
-import { Material, Mesh, Object3D, Texture } from "three";
-import type { IRenderer, ISharedMaterials } from "../engine/engine_types.js";
-export { InstancingUtil } from "../engine/engine_instancing.js";
-export declare enum ReflectionProbeUsage {
-    Off = 0,
-    BlendProbes = 1,
-    BlendProbesAndSkybox = 2,
-    Simple = 3
-}
-export declare class FieldWithDefault {
-    path: string | null;
-    asset: object | null;
-    default: any;
-}
-export declare enum RenderState {
-    Both = 0,
-    Back = 1,
-    Front = 2
-}
-declare class SharedMaterialArray implements ISharedMaterials {
-    [num: number]: THREE.Material;
-    private _renderer;
-    private _targets;
-    private _indexMapMaxIndex?;
-    private _indexMap?;
-    private _changed;
-    get changed(): boolean;
-    set changed(value: boolean);
-    is(renderer: Renderer): boolean;
-    constructor(renderer: Renderer, originalMaterials: Material[]);
-    get length(): number;
-    [Symbol.iterator](): Generator<THREE.Material | null, void, unknown>;
-    private resolveIndex;
-    private setMaterial;
-    private getMaterial;
-}
-export declare class Renderer extends Behaviour implements IRenderer {
-    /** Set the rendering state only of an object (makes it visible or invisible) without affecting component state or child hierarchy visibility! You can also just enable/disable the Renderer component on that object for the same effect!
-     *
-     * If you want to activate or deactivate a complete object you can use obj.visible as usual (it acts the same as setActive in Unity) */
-    static setVisible(obj: Object3D, visible: boolean): void;
-    receiveShadows: boolean;
-    shadowCastingMode: ShadowCastingMode;
-    lightmapIndex: number;
-    lightmapScaleOffset: THREE.Vector4;
-    enableInstancing: boolean[] | undefined;
-    renderOrder: number[] | undefined;
-    allowOcclusionWhenDynamic: boolean;
-    probeAnchor?: Object3D;
-    reflectionProbeUsage: ReflectionProbeUsage;
-    private _lightmaps?;
-    get sharedMesh(): Mesh | undefined;
-    get sharedMaterial(): THREE.Material;
-    set sharedMaterial(mat: THREE.Material);
-    /**@deprecated please use sharedMaterial */
-    get material(): THREE.Material;
-    /**@deprecated please use sharedMaterial */
-    set material(mat: THREE.Material);
-    private _sharedMaterials;
-    private _originalMaterials?;
-    private set sharedMaterials(value);
-    get sharedMaterials(): SharedMaterialArray;
-    static get shouldSuppressInstancing(): string | number | boolean;
-    private _lightmapTextureOverride;
-    get lightmap(): Texture | null;
-    /** set undefined to return to default lightmap */
-    set lightmap(tex: Texture | null | undefined);
-    get hasLightmap(): boolean;
-    allowProgressiveLoading: boolean;
-    registering(): void;
-    awake(): void;
-    private applyLightmapping;
-    private _isInstancingEnabled;
-    private handles;
-    private prevLayers;
-    private clearInstancingState;
-    setInstancingEnabled(enabled: boolean): boolean;
-    /** Return true to wrap matrix update events for instanced rendering to update instance matrices automatically when matrixWorld changes
-     * This is a separate method to be overrideable from user code
-     */
-    useInstanceMatrixWorldAutoUpdate(): boolean;
-    start(): void;
-    onEnable(): void;
-    onDisable(): void;
-    onDestroy(): void;
-    applyStencil(): void;
-    onBeforeRender(): void;
-    private onBeforeRenderThree;
-    onAfterRender(): void;
-    loadProgressiveTextures(material: THREE.Material): Promise<any>;
-    applySettings(go: THREE.Object3D): void;
-    private _reflectionProbe;
-    private updateReflectionProbe;
-    private _updateReflectionProbe;
-    private setVisibility;
-    private isMultiMaterialObject;
-    private isMeshOrSkinnedMesh;
-}
-export declare class MeshRenderer extends Renderer {
-}
-export declare class SkinnedMeshRenderer extends MeshRenderer {
-    awake(): void;
-    onBeforeRender(): void;
-}
-export declare enum ShadowCastingMode {
-    Off = 0,
-    On = 1,
-    TwoSided = 2,
-    ShadowsOnly = 3
-}
+import { Behaviour } from "./Component.js";
+import * as THREE from "three";
+import { Material, Mesh, Object3D, Texture } from "three";
+import type { IRenderer, ISharedMaterials } from "../engine/engine_types.js";
+export { InstancingUtil } from "../engine/engine_instancing.js";
+export declare enum ReflectionProbeUsage {
+    Off = 0,
+    BlendProbes = 1,
+    BlendProbesAndSkybox = 2,
+    Simple = 3
+}
+export declare class FieldWithDefault {
+    path: string | null;
+    asset: object | null;
+    default: any;
+}
+export declare enum RenderState {
+    Both = 0,
+    Back = 1,
+    Front = 2
+}
+declare class SharedMaterialArray implements ISharedMaterials {
+    [num: number]: THREE.Material;
+    private _renderer;
+    private _targets;
+    private _indexMapMaxIndex?;
+    private _indexMap?;
+    private _changed;
+    get changed(): boolean;
+    set changed(value: boolean);
+    is(renderer: Renderer): boolean;
+    constructor(renderer: Renderer, originalMaterials: Material[]);
+    get length(): number;
+    [Symbol.iterator](): Generator<THREE.Material | null, void, unknown>;
+    private resolveIndex;
+    private setMaterial;
+    private getMaterial;
+}
+export declare class Renderer extends Behaviour implements IRenderer {
+    /** Set the rendering state only of an object (makes it visible or invisible) without affecting component state or child hierarchy visibility! You can also just enable/disable the Renderer component on that object for the same effect!
+     *
+     * If you want to activate or deactivate a complete object you can use obj.visible as usual (it acts the same as setActive in Unity) */
+    static setVisible(obj: Object3D, visible: boolean): void;
+    receiveShadows: boolean;
+    shadowCastingMode: ShadowCastingMode;
+    lightmapIndex: number;
+    lightmapScaleOffset: THREE.Vector4;
+    enableInstancing: boolean[] | undefined;
+    renderOrder: number[] | undefined;
+    allowOcclusionWhenDynamic: boolean;
+    probeAnchor?: Object3D;
+    reflectionProbeUsage: ReflectionProbeUsage;
+    private _lightmaps?;
+    get sharedMesh(): Mesh | undefined;
+    get sharedMaterial(): THREE.Material;
+    set sharedMaterial(mat: THREE.Material);
+    /**@deprecated please use sharedMaterial */
+    get material(): THREE.Material;
+    /**@deprecated please use sharedMaterial */
+    set material(mat: THREE.Material);
+    private _sharedMaterials;
+    private _originalMaterials?;
+    private set sharedMaterials(value);
+    get sharedMaterials(): SharedMaterialArray;
+    static get shouldSuppressInstancing(): string | number | boolean;
+    private _lightmapTextureOverride;
+    get lightmap(): Texture | null;
+    /** set undefined to return to default lightmap */
+    set lightmap(tex: Texture | null | undefined);
+    get hasLightmap(): boolean;
+    allowProgressiveLoading: boolean;
+    registering(): void;
+    awake(): void;
+    private applyLightmapping;
+    private _isInstancingEnabled;
+    private handles;
+    private prevLayers;
+    private clearInstancingState;
+    setInstancingEnabled(enabled: boolean): boolean;
+    /** Return true to wrap matrix update events for instanced rendering to update instance matrices automatically when matrixWorld changes
+     * This is a separate method to be overrideable from user code
+     */
+    useInstanceMatrixWorldAutoUpdate(): boolean;
+    start(): void;
+    onEnable(): void;
+    onDisable(): void;
+    onDestroy(): void;
+    applyStencil(): void;
+    onBeforeRender(): void;
+    private onBeforeRenderThree;
+    onAfterRender(): void;
+    loadProgressiveTextures(material: THREE.Material): Promise<any>;
+    applySettings(go: THREE.Object3D): void;
+    private _reflectionProbe;
+    private updateReflectionProbe;
+    private _updateReflectionProbe;
+    private setVisibility;
+    private isMultiMaterialObject;
+    private isMeshOrSkinnedMesh;
+}
+export declare class MeshRenderer extends Renderer {
+}
+export declare class SkinnedMeshRenderer extends MeshRenderer {
+    awake(): void;
+    onBeforeRender(): void;
+}
+export declare enum ShadowCastingMode {
+    Off = 0,
+    On = 1,
+    TwoSided = 2,
+    ShadowsOnly = 3
+}