@needle-tools/engine 4.16.1 → 4.16.3

package/src/engine-components/ReflectionProbe.ts

@@ -1,17 +1,21 @@
-import { CubeTexture, EquirectangularReflectionMapping, LinearSRGBColorSpace, Material, Object3D, Texture, Vector3 } from "three";
+import { Box3, Color, CubeTexture, EquirectangularReflectionMapping, LinearSRGBColorSpace, LineSegments, Material, Object3D, Quaternion, Texture, Vector3 } from "three";
 
+import { CreateWireCube } from "../engine/engine_gizmos.js";
 import { MaterialPropertyBlock } from "../engine/engine_materialpropertyblock.js";
 import { loadPMREM } from "../engine/engine_pmrem.js";
 import { serializable } from "../engine/engine_serialization.js";
 import { Context } from "../engine/engine_setup.js";
+import { getBoundingBox, getWorldPosition } from "../engine/engine_three_utils.js";
 import { getParam, resolveUrl } from "../engine/engine_utils.js";
-import { BoxHelperComponent } from "./BoxHelperComponent.js";
 import { Behaviour } from "./Component.js";
 import { EventList } from "./EventList.js";
 
 export const debug = getParam("debugreflectionprobe");
 const disable = getParam("noreflectionprobe");
 
+let box: Box3 | null = null;
+const _identityRotation = new Quaternion();
+
 const $reflectionProbeKey = Symbol("reflectionProbeKey");
 /**
  * The [ReflectionProbe](https://engine.needle.tools/docs/api/ReflectionProbe) provides environment reflection data to materials within its defined area.
@@ -40,10 +44,11 @@ const $reflectionProbeKey = Symbol("reflectionProbeKey");
 export class ReflectionProbe extends Behaviour {
 
     private static _probes: Map<Context, ReflectionProbe[]> = new Map();
-    
-    
+    private static testBox: Box3 = new Box3();
+
     /**
-     * Checks if the given material is currently using a reflection probe. This is determined by checking for an override on the material's "envMap" property, which is set by the Renderer component when applying a reflection probe.
+     * Checks if the given material is currently using a reflection probe.  
+     * This is determined by checking for an override on the material's "envMap" property, which is set by the Renderer component when applying a reflection probe.
      */
     static isUsingReflectionProbe(material: Material) {
         return !!(material as any)[$reflectionProbeKey];
@@ -101,14 +106,17 @@ export class ReflectionProbe extends Behaviour {
     private _textureUrlInFlight?: string;
 
     /**
-     * The cubemap or HDR texture used for reflections. Can be assigned directly or via a URL string. When assigning via URL, the texture will be loaded asynchronously and applied once ready.
+     * The cubemap or HDR texture used for reflections. Can be assigned directly or via a URL string.   
+     * When assigning via URL, the texture will be loaded asynchronously and applied once ready.
+     * @param tex The texture or URL to assign to this reflection probe
+     * @default null
      */
     @serializable([Texture, String])
     set texture(tex: Texture | null) {
         if (this._texture === tex) return;
 
         if (typeof tex === "string") {
-            if(debug) console.debug(`[ReflectionProbe] Loading reflection probe texture from URL: ${tex}`);
+            if (debug) console.debug(`[ReflectionProbe] Loading reflection probe texture from URL: ${tex}`);
             this._textureUrlInFlight = tex;
             const textureUrl = resolveUrl(this.sourceId, tex);
             loadPMREM(textureUrl, this.context.renderer).then(loaded => {
@@ -124,7 +132,7 @@ export class ReflectionProbe extends Behaviour {
         // During deserialization / loading of the GLB the deserializer sets an empty DataTexture 
         // But if the texture is serialized as a string (via Blender Reflection Probes) then the async loading above
         // Will abort IF textureInFlight is reset (here). That's why we do NOT reset textureInFlight during initialization (when __didAwake is false). Only after awake, when we are sure that the async loading is done, we reset the in-flight URL to allow new assignments.
-        if(this.__didAwake) this._textureUrlInFlight = undefined;
+        if (this.__didAwake) this._textureUrlInFlight = undefined;
 
         this._texture = tex;
 
@@ -144,30 +152,49 @@ export class ReflectionProbe extends Behaviour {
         return this._texture;
     }
 
+    /**
+     * The intensity of the reflection probe's influence.  
+     *  Higher values will make reflections brighter, while lower values will make them dimmer.  
+     * The default value is 1, which means the reflections will be applied at their original brightness. Adjust this value to achieve the desired look for your scene.
+     * @default 1
+     */
     @serializable()
     intensity: number = 1;
 
     /**
-     * Defines the center and size of the reflection probe's influence area.
+     * Defines the center of the reflection probe's influence area relative to the GameObject's position.   
+     * The probe will affect objects within a box defined by this center and the `size` property.  
+     * Note: The actual influence area is determined by both the `center` and `size` properties. The `center` defines the offset from the GameObject's position, while the `size` defines the dimensions of the box around that center. Objects within this box will be influenced by the reflection probe.
      */
     @serializable(Vector3)
-    center?: Vector3;
+    center: Vector3 = new Vector3();
 
     /**
-     * Defines the size of the reflection probe's influence area. Objects within this box will be affected by the probe's reflections.
+     * Defines the size of the reflection probe's influence area. Objects within this box will be affected by the probe's reflections.  
+     * Note: The actual influence area is determined by both the `center` and `size` properties. The `center` defines the offset from the GameObject's position, while the `size` defines the dimensions of the box around that center. Objects within this box will be influenced by the reflection probe.
      */
     @serializable(Vector3)
-    size?: Vector3;
+    size: Vector3 = new Vector3(1, 1, 1);
 
     /**
      * Workaround for lightmap. Compensates for the fact that lightmaps are pre-multiplied by intensity, while reflection probes are not. This means that if you use both lightmaps and reflection probes, you may need to adjust this value to get the correct balance between them. The default value of `Math.PI` is a good starting point for most cases, but you may need to tweak it based on your specific lighting setup and artistic needs.
      */
     __lightmapIntensityScale: boolean = true;
 
-    private _boxHelper?: BoxHelperComponent;
 
     private isInBox(obj: Object3D) {
-        return this._boxHelper?.isInBox(obj);
+
+        box ??= new Box3();
+        box!.setFromCenterAndSize(this.gameObject.worldPosition.add(this.center), this.gameObject.worldScale.multiply(this.size));
+
+        getBoundingBox([obj], undefined, undefined, ReflectionProbe.testBox);
+
+        if (ReflectionProbe.testBox.isEmpty()) {
+            return box.containsPoint(obj.worldPosition);
+        }
+        else {
+            return box?.intersectsBox(ReflectionProbe.testBox);
+        }
     }
 
     constructor() {
@@ -178,12 +205,15 @@ export class ReflectionProbe extends Behaviour {
         ReflectionProbe._probes.get(this.context)?.push(this);
     }
 
+    private _gizmo: LineSegments | null = null;
+    private _color: Color | null = null;
+
     /** @internal */
     awake() {
-        this._boxHelper = this.gameObject.addComponent(BoxHelperComponent) as BoxHelperComponent;
-        this._boxHelper.updateBox(true);
-        if (debug)
-            this._boxHelper.showHelper(0x555500, true);
+        if (debug) {
+            this._gizmo = CreateWireCube(0x555500);
+            this.gameObject.add(this._gizmo);
+        }
 
         if (this._texture) {
             this._texture.mapping = EquirectangularReflectionMapping;
@@ -192,6 +222,15 @@ export class ReflectionProbe extends Behaviour {
         }
     }
 
+    /** @internal */
+    update(): void {
+        if (this._gizmo) {
+            if (this.center) this._gizmo.position.copy(this.center);
+            if (this.size) this._gizmo.scale.copy(this.size);
+            this._gizmo.worldQuaternion = _identityRotation.identity();
+        }
+    }
+
     /** @internal */
     onEnable(): void {
         ReflectionProbe.onEnabled?.invoke(this);
@@ -221,7 +260,10 @@ export class ReflectionProbe extends Behaviour {
     }
 
     /**
-     * Applies this reflection probe to the given object by setting material property overrides for "envMap", "envMapRotation", and "envMapIntensity". This is typically called by the Renderer component when determining which reflection probe to use for a given object.
+     * Applies this reflection probe to the given object by setting material property overrides for "envMap", "envMapRotation", and "envMapIntensity".   
+     * This is typically called by the Renderer component when determining which reflection probe to use for a given object.
+     * @param object The object to apply the reflection probe to
+     * @see {@link unapply} for the corresponding method to remove the probe's influence from an object.
      */
     apply(object: Object3D) {
         if (disable) return;
@@ -240,7 +282,10 @@ export class ReflectionProbe extends Behaviour {
     }
 
     /**
-     * Removes the reflection probe overrides from the given object. This is typically called by the Renderer component when an object is no longer influenced by this probe or when the probe is disabled.
+     * Removes the reflection probe overrides from the given object.   
+     * This is typically called by the Renderer component when an object is no longer influenced by this probe or when the probe is disabled.
+     * @param object The object to remove the reflection probe overrides from
+     * @see {@link apply} for the corresponding method to apply the probe's influence to an object.
      */
     unapply(obj: Object3D) {
         const block = MaterialPropertyBlock.get(obj);

package/src/engine-components/VideoPlayer.ts

@@ -143,7 +143,7 @@ export class VideoPlayer extends Behaviour {
     private _url: string | null = null;
 
     @serializable()
-    private renderMode?: VideoRenderMode;
+    private renderMode: VideoRenderMode = VideoRenderMode.MaterialOverride;
 
     @serializable()
     private targetMaterialProperty?: string;

package/plugins/types/next.d.ts

@@ -1,3 +0,0 @@
-import { userSettings } from './userconfig.js';
-
-export declare function needleNext(nextConfig?: import('next').NextConfig, userSettings?: userSettings): Promise<import('next').NextConfig>;

package/plugins/types/vite.d.ts

@@ -1,14 +0,0 @@
-import { needleConfig, needleMeta } from "./needleConfig.d.ts";
-import { userSettings } from "./userconfig.d.ts";
-
-export declare function needlePlugins(command: import("vite").ConfigEnv["command"], meta?: needleMeta | null, userSettings?: userSettings): Promise<any>;
-
-/**
- * Loads the generated needle meta file
- */
-export declare function loadConfig(path: string | null = null): Promise<needleMeta | null>;
-
-/**
- * Returns true if the project is configured to use gzip compression
- */
-export declare function useGzip(config?: needleConfig): boolean;