@needle-tools/engine 5.1.0-alpha → 5.1.0-canary.0d9f44e

package/src/engine-components/Light.ts

@@ -1,7 +1,9 @@
 import { CameraHelper, Color, DirectionalLight, DirectionalLightHelper, Light as ThreeLight, OrthographicCamera, PointLight, SpotLight, Vector3 } from "three";
+import { CSM } from "three/examples/jsm/csm/CSM.js";
+import { CSMHelper } from "three/examples/jsm/csm/CSMHelper.js";
 
 import { serializable } from "../engine/engine_serialization_decorator.js";
-import { FrameEvent } from "../engine/engine_setup.js";
+
 import { setWorldPositionXYZ } from "../engine/engine_three_utils.js";
 import type { ILight } from "../engine/engine_types.js";
 import { getParam } from "../engine/engine_utils.js";
@@ -106,11 +108,40 @@ enum LightShadows {
 export class Light extends Behaviour implements ILight {
 
     /**
-     * The type of light (spot, directional, point, etc.)  
-     * Can not be changed at runtime.  
+     * The type of light as a lowercase string: `"directional"`, `"point"`, `"spot"`.
+     * Implements {@link ILight.type}. Can not be changed at runtime.
      */
+    get type(): ILight["type"] {
+        return this._type;
+    }
+
+    /** Numeric LightType serialized from Unity/Blender — converts to string on write */
     @serializable()
-    private type: LightType = 0;
+    set type(value: LightType | ILight["type"]) {
+        if (this.light && this.__didAwake) {
+            throw new Error("Changing the light type at runtime is not supported");
+        }
+        switch (value) {
+            case LightType.Directional:
+                this._type = "directional";
+                break;
+            case LightType.Point:
+                this._type = "point";
+                break;
+            case LightType.Spot:
+                this._type = "spot";
+                break;
+            case "directional":
+            case "point":
+            case "spot":
+                this._type = value;
+                break;
+            default:
+                throw new Error("Invalid light type: " + value);
+        }
+    }
+    private _type: ILight["type"] = "point";
+
 
     /**
      * The maximum distance the light affects.  
@@ -174,6 +205,9 @@ export class Light extends Behaviour implements ILight {
         if (this.light !== undefined) {
             this.light.color = val;
         }
+        if (this._csm) {
+            for (const l of this._csm.lights) l.color.copy(val);
+        }
     }
     get color(): Color {
         if (this.light) return this.light.color;
@@ -259,6 +293,9 @@ export class Light extends Behaviour implements ILight {
         if (this.light) {
             this.light.intensity = val;
         }
+        if (this._csm) {
+            for (const l of this._csm.lights) l.intensity = val;
+        }
         if (debug) console.log("Set light intensity to " + this._intensity, val, this)
     }
     get intensity(): number { return this._intensity; }
@@ -312,6 +349,24 @@ export class Light extends Behaviour implements ILight {
     }
     private _shadowResolution?: number = undefined;
 
+    /**
+     * Number of shadow cascade levels (only used when `useCascades` is true)
+     */
+    @serializable()
+    cascades: number = 3;
+
+    /**
+     * Cascade split mode (only used when `useCascades` is true):
+     * - `practical` — balanced (default, recommended)
+     * - `logarithmic` — more resolution close up
+     * - `uniform` — equal splits
+     */
+    @serializable()
+    cascadeMode: "practical" | "logarithmic" | "uniform" = "practical";
+
+    private _csm?: CSM;
+    private _csmHelper?: CSMHelper;
+
     /**
      * Whether this light's illumination is entirely baked into lightmaps
      */
@@ -345,7 +400,7 @@ export class Light extends Behaviour implements ILight {
      */
     public getWorldPosition(vec: Vector3): Vector3 {
         if (this.light) {
-            if (this.type === LightType.Directional) {
+            if (this.type === "directional") {
                 return this.light.getWorldPosition(vec).multiplyScalar(1);
             }
             return this.light.getWorldPosition(vec);
@@ -372,12 +427,21 @@ export class Light extends Behaviour implements ILight {
             else if (this.light.parent !== this.gameObject)
                 this.gameObject.add(this.light);
         }
-        if (this.type === LightType.Directional)
-            this.startCoroutine(this.updateMainLightRoutine(), FrameEvent.LateUpdate);
+        this.context.lights.add(this);
     }
 
     onDisable() {
         if (debug) console.log("DISABLE LIGHT", this.name);
+        this.context.lights.delete(this);
+        if (this._csm) {
+            this._csm.remove();
+            this._csm.dispose();
+            this._csm = undefined;
+            if (this._csmHelper) {
+                this._csmHelper.removeFromParent();
+                this._csmHelper = undefined;
+            }
+        }
         if (this.light) {
             if (this.selfIsLight)
                 this.light.intensity = 0;
@@ -386,6 +450,27 @@ export class Light extends Behaviour implements ILight {
         }
     }
 
+    onBeforeRender() {
+        if (this.type === "directional" && this.shadows !== LightShadows.None) {
+            // context.mainLight is computed — always returns the brightest registered directional light
+            const isMain = this.context.mainLight === this;
+            if (isMain) {
+                if (!this._csm) this.createCSM();
+            } else if (this._csm) {
+                // this light is no longer the main light (a brighter one took over) — tear down CSM
+                this._csm.remove();
+                this._csm.dispose();
+                this._csm = undefined;
+            }
+        }
+        if (this._csm) {
+            // keep lightDirection in sync with the gameObject's world orientation
+            this._csm.lightDirection.copy(this.gameObject.worldForward);
+            this._csm.update();
+            if (this._csmHelper) this._csmHelper.update();
+        }
+    }
+
     /**
      * Creates the appropriate three.js light based on the configured light type
      * and applies all settings like shadows, intensity, and color.
@@ -399,14 +484,14 @@ export class Light extends Behaviour implements ILight {
             this._intensity = this.light.intensity;
 
             switch (this.type) {
-                case LightType.Directional:
+                case "directional":
                     this.setDirectionalLight(this.light as DirectionalLight);
                     break;
             }
         }
         else if (!this.light) {
             switch (this.type) {
-                case LightType.Directional:
+                case "directional":
                     // console.log(this);
                     const dirLight = new DirectionalLight(this.color, this.intensity * Math.PI);
                     // directional light target is at 0 0 0 by default
@@ -425,7 +510,7 @@ export class Light extends Behaviour implements ILight {
                     }
                     break;
 
-                case LightType.Spot:
+                case "spot":
                     const spotLight = new SpotLight(this.color, this.intensity * Math.PI, this.range, toRadians(this.spotAngle / 2), 1 - toRadians(this.innerSpotAngle / 2) / toRadians(this.spotAngle / 2), 2);
                     spotLight.position.set(0, 0, 0);
                     spotLight.rotation.set(0, 0, 0);
@@ -437,7 +522,7 @@ export class Light extends Behaviour implements ILight {
                     spotLightTarget.rotation.set(0, 0, 0);
                     break;
 
-                case LightType.Point:
+                case "point":
                     const pointLight = new PointLight(this.color, this.intensity * Math.PI, this.range);
                     this.light = pointLight;
 
@@ -526,22 +611,6 @@ export class Light extends Behaviour implements ILight {
 
     }
 
-    /**
-     * Coroutine that updates the main light reference in the context
-     * if this directional light should be the main light
-     */
-    *updateMainLightRoutine() {
-        while (true) {
-            if (this.type === LightType.Directional) {
-                if (!this.context.mainLight || this.intensity > this.context.mainLight.intensity) {
-                    this.context.mainLight = this;
-                }
-                yield;
-            }
-            break;
-        }
-    }
-
     /**
      * Controls whether the renderer's shadow map type can be changed when soft shadows are used
      */
@@ -598,6 +667,41 @@ export class Light extends Behaviour implements ILight {
         }
     }
 
+    /**
+     * Creates and initializes a CSM instance for this directional light.
+     * CSM manages its own cascade DirectionalLights internally.
+     */
+    private createCSM() {
+        const camera = this.context.mainCamera;
+        if (!camera) {
+            if (debug) console.warn("CSM: no main camera found, deferring");
+            return;
+        }
+
+        this._csm = new CSM({
+            camera,
+            parent: this.context.scene,
+            cascades: this.cascades,
+            mode: this.cascadeMode,
+            maxFar: this._shadowDistance ?? shadowMaxDistance,
+            shadowMapSize: this._shadowResolution ?? 2048,
+            shadowBias: this._shadowBias,
+            lightDirection: this.gameObject.worldForward.clone(),
+            lightIntensity: this._intensity >= 0 ? this._intensity : 1,
+        });
+        this._csm.fade = true;
+
+        // apply color to all cascade lights
+        for (const l of this._csm.lights) {
+            l.color.copy(this._color);
+        }
+
+        if (debug) {
+            this._csmHelper = new CSMHelper(this._csm);
+            this.context.scene.add(this._csmHelper);
+        }
+    }
+
     /**
      * Configures a directional light by adding and positioning its target
      * @param dirLight The directional light to set up
@@ -610,4 +714,5 @@ export class Light extends Behaviour implements ILight {
 }
 
 const vec = new Vector3(0, 0, 0);
+const _csmLightDir = new Vector3();
 

package/src/engine-components/RigidBody.ts

@@ -382,12 +382,12 @@ export class Rigidbody extends Behaviour implements IRigidbody {
         this._watch.start(true, true);
         this.startCoroutine(this.beforePhysics(), FrameEvent.LateUpdate);
         if (isDevEnvironment()) {
-            if (!globalThis["NEEDLE_USE_RAPIER"])
-                console.warn(`Rigidbody could not be created: Rapier physics are explicitly disabled.`);
+            if (globalThis["NEEDLE_USE_RAPIER"] === false)
+                console.warn(`RAPIER physics are disabled in your build. Enable them by setting NEEDLE_USE_RAPIER to true in your build config: Rigidbody could not be created.`);
             else {
                 MODULES.RAPIER_PHYSICS.ready().then(async () => {
                     await delayForFrames(3);
-                    if (!this.context.physics.engine?.getBody(this))
+                    if (this.activeAndEnabled && !this.context.physics.engine?.getBody(this))
                         console.warn(`Rigidbody could not be created. Ensure \"${this.name}\" has a Collider component.`);
                 })
             }

package/src/engine-components/SceneSwitcher.ts

@@ -723,6 +723,7 @@ export class SceneSwitcher extends Behaviour {
                     // unless the user defines that he wants to use the scene name
                     if (this.useSceneName) {
                         if (scene instanceof Object3D) queryParameterValue = scene.name;
+                        else if (scene instanceof AssetReference && scene.asset?.name) queryParameterValue = scene.asset.name;
                         else if (scene.url) queryParameterValue = sceneUriToName(scene.url);
                     }
                     // save the loaded scene as an url parameter

package/src/engine-components/api.ts

@@ -35,6 +35,7 @@
  */
 
 export * from "./codegen/components.js";
+export { AnimatorControllerBuilder, type ConditionMode, type StateOptions, type TransitionOptions } from "./AnimatorController.js";
 export { Collider } from "./Collider.js"; // export abstract type
 export { Behaviour, Component, GameObject } from "./Component.js";
 

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

@@ -6,6 +6,7 @@ export { Animation } from "../Animation.js";
 export { Keyframe } from "../AnimationCurve.js";
 export { AnimationCurve } from "../AnimationCurve.js";
 export { Animator } from "../Animator.js";
+export { AnimatorControllerBuilder } from "../AnimatorController.js";
 export { AnimatorController } from "../AnimatorController.js";
 export { AudioListener } from "../AudioListener.js";
 export { AudioSource } from "../AudioSource.js";

package/src/engine-components/postprocessing/Effects/BloomEffect.ts

@@ -1,4 +1,4 @@
-import { BloomEffect as _BloomEffect, EffectAttribute } from "postprocessing";
+import type { BloomEffect as _BloomEffect } from "postprocessing";
 import { MathUtils } from "three";
 
 import { MODULES } from "../../../engine/engine_modules.js";

package/src/engine-components/postprocessing/Effects/Sharpening.ts

@@ -1,4 +1,3 @@
-import { EffectAttribute } from "postprocessing";
 import { Uniform } from "three";
 
 import { MODULES } from "../../../engine/engine_modules.js";
@@ -138,7 +137,7 @@ function createSharpeningEffectType() {
                     ["radius", new Uniform(1)],
                     // ["threshold", new Uniform(0)],
                 ]),
-                attributes: EffectAttribute.CONVOLUTION
+                attributes: MODULES.POSTPROCESSING.MODULE.EffectAttribute.CONVOLUTION
             });
         }
     }

package/src/engine-components/postprocessing/PostProcessingHandler.ts

@@ -14,10 +14,6 @@ import { threeToneMappingToEffectMode } from "./Effects/Tonemapping.utils.js";
 import { PostProcessingEffect, PostProcessingEffectContext } from "./PostProcessingEffect.js";
 import { orderEffects, PostprocessingEffectData, PostProcessingEffectOrder } from "./utils.js";
 
-declare const NEEDLE_USE_POSTPROCESSING: boolean;
-globalThis["NEEDLE_USE_POSTPROCESSING"] = globalThis["NEEDLE_USE_POSTPROCESSING"] !== undefined ? globalThis["NEEDLE_USE_POSTPROCESSING"] : true;
-
-
 const debug = getParam("debugpost");
 
 const activeKey = Symbol("needle:postprocessing-handler");
@@ -58,13 +54,13 @@ export class PostProcessingHandler implements IPostProcessingHandler {
 
     apply(components: PostProcessingEffect[]): Promise<void> {
         if ("env" in import.meta && (import.meta as any /* webpack support */ ).env.VITE_NEEDLE_USE_POSTPROCESSING === "false") {
-            if (debug) console.warn("Postprocessing is disabled via vite env setting");
-            else console.debug("Postprocessing is disabled via vite env setting");
+            if (debug) console.warn("POSTPROCESSING is disabled via vite env setting");
+            else console.debug("POSTPROCESSING is disabled via vite env setting");
             return Promise.resolve();
         }
         if (!NEEDLE_USE_POSTPROCESSING) {
-            if (debug) console.warn("Postprocessing is disabled via global vite define setting");
-            else console.debug("Postprocessing is disabled via vite define");
+            if (debug || isDevEnvironment()) console.warn("POSTPROCESSING is disabled via global vite define setting");
+            else console.debug("POSTPROCESSING is disabled via vite define");
             return Promise.resolve();
         }
 

package/src/engine-components/web/ScrollFollow.ts

@@ -1,5 +1,5 @@
-// For firefox ViewTimeline support
-import "scroll-timeline-polyfill/dist/scroll-timeline.js";
+// For firefox ViewTimeline support — dynamic import to avoid SSR crashes (polyfill accesses window at module level)
+if (typeof window !== "undefined") import("scroll-timeline-polyfill/dist/scroll-timeline.js");
 
 import { Box3, Object3D } from "three";
 

package/src/needle-engine.ts

@@ -1,3 +1,5 @@
+/// <reference path="../plugins/types/needle-bindings.d.ts" />
+
 import { initEngine } from "./engine/engine_init.js";
 initEngine();
 import "./engine/webcomponents/needle-engine.js";

package/src/vite-env.d.ts

@@ -0,0 +1,16 @@
+// Vite global defines — see plugins/vite/defines.js
+// declare const entries here are picked up globally (ambient, no import/export).
+// Vite sets these as globals in dev and statically replaces them at build time.
+// Webpack DefinePlugin replaces them at build time too.
+// The globalThis fallbacks for vanilla JS are in engine_constants.ts.
+
+declare const NEEDLE_ENGINE_VERSION: string;
+declare const NEEDLE_ENGINE_GENERATOR: string;
+declare const NEEDLE_PROJECT_BUILD_TIME: string;
+declare const NEEDLE_PUBLIC_KEY: string;
+
+// #region treeshake flags
+// declare var (not const) so globalThis["NEEDLE_USE_*"] access is also type-safe
+declare var NEEDLE_USE_RAPIER: boolean;
+declare var NEEDLE_USE_POSTPROCESSING: boolean;
+// #endregion treeshake flags