rayzee 7.13.0 → 7.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "7.13.0",
+  "version": "7.15.0",
   "type": "module",
   "description": "Real-time WebGPU path tracing engine built on Three.js",
   "main": "dist/rayzee.umd.js",

package/src/PathTracerApp.js

@@ -1780,6 +1780,7 @@ export class PathTracerApp extends EventDispatcher {
 			transformManager: this.transformManager,
 			appDispatch: ( e ) => this.dispatchEvent( e ),
 			orbitControls: this.cameraManager.controls,
+			helperScene: this._sceneHelpers.scene,
 		} );
 
 		this.denoisingManager.setOverlayManager( this.overlayManager );

package/src/Processor/LightSerializer.js

@@ -90,6 +90,7 @@ export class LightSerializer {
 
 	addDirectionalLight( light ) {
 
+		if ( ! light.visible ) return; // Skip hidden lights
 		if ( light.intensity <= 0.0 ) return; // Skip zero intensity lights
 
 		light.updateMatrixWorld();
@@ -146,6 +147,7 @@ export class LightSerializer {
 
 	addRectAreaLight( light ) {
 
+		if ( ! light.visible ) return; // Skip hidden lights
 		if ( light.intensity <= 0.0 ) return; // Skip zero intensity lights
 
 		light.updateMatrixWorld();
@@ -190,6 +192,7 @@ export class LightSerializer {
 
 	addPointLight( light ) {
 
+		if ( ! light.visible ) return; // Skip hidden lights
 		if ( light.intensity <= 0.0 ) return; // Skip zero intensity lights
 
 		light.updateMatrixWorld();
@@ -218,6 +221,7 @@ export class LightSerializer {
 
 	addSpotLight( light ) {
 
+		if ( ! light.visible ) return; // Skip hidden lights
 		if ( light.intensity <= 0.0 ) return; // Skip zero intensity lights
 
 		light.updateMatrixWorld();

package/src/managers/InteractionManager.js

@@ -71,6 +71,7 @@ export class InteractionManager extends EventDispatcher {
 		this._transformManager = null;
 		this._appDispatch = null;
 		this._orbitControls = null;
+		this._helperScene = null; // SceneHelpers' scene — lets clicking a light's visual helper select it
 
 	}
 
@@ -85,13 +86,15 @@ export class InteractionManager extends EventDispatcher {
 	 * @param {import('./TransformManager.js').TransformManager} deps.transformManager
 	 * @param {Function} deps.appDispatch - (event) => dispatches on PathTracerApp
 	 * @param {import('three/addons/controls/OrbitControls.js').OrbitControls} [deps.orbitControls]
+	 * @param {import('three').Scene} [deps.helperScene] - SceneHelpers' scene, for light-helper picking
 	 */
-	setDependencies( { overlayManager, transformManager, appDispatch, orbitControls } ) {
+	setDependencies( { overlayManager, transformManager, appDispatch, orbitControls, helperScene } ) {
 
 		this._overlayManager = overlayManager || null;
 		this._transformManager = transformManager || null;
 		this._appDispatch = appDispatch || null;
 		this._orbitControls = orbitControls || null;
+		this._helperScene = helperScene || null;
 
 	}
 
@@ -469,10 +472,26 @@ export class InteractionManager extends EventDispatcher {
 
 			const intersects = this.raycaster.intersectObjects( this.scene.children, true );
 			const validIntersects = this.filterValidIntersects( intersects );
+			const lightHit = this._pickLightHelper();
 
-			if ( validIntersects.length > 0 ) {
+			let object = null;
+
+			if ( validIntersects.length > 0 && lightHit ) {
+
+				object = validIntersects[ 0 ].distance <= lightHit.distance ? validIntersects[ 0 ].object : lightHit.light;
+
+			} else if ( validIntersects.length > 0 ) {
+
+				object = validIntersects[ 0 ].object;
+
+			} else if ( lightHit ) {
+
+				object = lightHit.light;
+
+			}
+
+			if ( object ) {
 
-				const object = validIntersects[ 0 ].object;
 				const currentlySelectedObject = this.selectedObject;
 				const isAlreadySelected = currentlySelectedObject && currentlySelectedObject.uuid === object.uuid;
 
@@ -674,6 +693,40 @@ export class InteractionManager extends EventDispatcher {
 
 	}
 
+	/**
+	 * Raycasts against the light-helper overlay scene (SceneHelpers) and
+	 * resolves the closest hit back to its source light. Helper geometry
+	 * (PointLightHelper, SpotLightHelper, DirectionalLightHelper,
+	 * RectAreaLightHelper) is often line/child geometry, so this walks up the
+	 * parent chain looking for the `.light` reference each helper exposes.
+	 * Returns null when there's no helper scene, no lights, or no hit — this
+	 * naturally happens when "Light Helper" is toggled off, since SceneHelpers
+	 * empties its scene in that case.
+	 * @private
+	 */
+	_pickLightHelper() {
+
+		if ( ! this._helperScene || this._helperScene.children.length === 0 ) return null;
+
+		const intersects = this.raycaster.intersectObjects( this._helperScene.children, true );
+
+		for ( const hit of intersects ) {
+
+			let object = hit.object;
+
+			while ( object ) {
+
+				if ( object.light ) return { distance: hit.distance, light: object.light };
+				object = object.parent;
+
+			}
+
+		}
+
+		return null;
+
+	}
+
 	/**
 	 * Update dependencies (useful when scene/camera changes)
 	 */

package/src/managers/LightManager.js

@@ -330,6 +330,7 @@ export class LightManager extends EventDispatcher {
 			uuid: light.uuid,
 			name: light.name,
 			type: light.type,
+			visible: light.visible,
 			intensity: light.intensity,
 			color: `#${light.color.getHexString()}`,
 			position: [ light.position.x, light.position.y, light.position.z ],

package/src/managers/TransformManager.js

@@ -9,6 +9,11 @@ import { Matrix3, Scene, Vector3 } from 'three';
 import { TransformControls } from 'three/addons/controls/TransformControls.js';
 import { EngineEvents } from '../EngineEvents.js';
 
+// Three.js "forward" convention (local -Z), used to derive a spot/directional
+// light's aim direction from its quaternion. Read-only — setFromUnitVectors()
+// does not mutate its arguments, so this can be a shared constant.
+const FORWARD = new Vector3( 0, 0, - 1 );
+
 export class TransformManager {
 
 	constructor( { camera, canvas, orbitControls, app } ) {
@@ -36,6 +41,12 @@ export class TransformManager {
 		this._refitInFlight = false;
 		this._baselineComputed = false;
 
+		// Light transform state — spot/directional lights aim via a separate
+		// `.target` Object3D rather than their own rotation (see attach()).
+		this._tempForward = new Vector3();
+		this._lightTargetDistance = null;
+		this._lastLightPosition = null;
+
 		// Bind handlers
 		this._onDraggingChanged = this._onDraggingChanged.bind( this );
 		this._onObjectChange = this._onObjectChange.bind( this );
@@ -91,6 +102,32 @@ export class TransformManager {
 		this._controls.attach( object );
 		this._attached = object;
 
+		this._lightTargetDistance = null;
+		this._lastLightPosition = null;
+
+		// Spot/directional lights aim via `.target.position`, not their own
+		// quaternion. Sync the quaternion to the current aim direction now so
+		// rotate mode starts from the true current direction instead of identity.
+		if ( object.isLight && object.target ) {
+
+			const forward = object.target.position.clone().sub( object.position );
+			const distance = forward.length();
+
+			if ( distance > 1e-4 ) {
+
+				object.quaternion.setFromUnitVectors( FORWARD, forward.normalize() );
+				this._lightTargetDistance = distance;
+
+			} else {
+
+				this._lightTargetDistance = 1;
+
+			}
+
+			this._lastLightPosition = object.position.clone();
+
+		}
+
 	}
 
 	/**
@@ -102,6 +139,8 @@ export class TransformManager {
 
 		this._controls.detach();
 		this._attached = null;
+		this._lightTargetDistance = null;
+		this._lastLightPosition = null;
 
 	}
 
@@ -112,6 +151,9 @@ export class TransformManager {
 
 		this._controls.setMode( mode );
 		this._app?.dispatchEvent( { type: EngineEvents.TRANSFORM_MODE_CHANGED, mode } );
+		// The gizmo shape changes (arrows/rings/boxes) but nothing else invalidates
+		// the frame — nudge a redraw so it doesn't wait for the next camera move.
+		this._app?.refreshFrame();
 
 	}
 
@@ -121,6 +163,7 @@ export class TransformManager {
 	setSpace( space ) {
 
 		this._controls.setSpace( space );
+		this._app?.refreshFrame();
 
 	}
 
@@ -188,8 +231,17 @@ export class TransformManager {
 
 		} else {
 
-			// Drag ended — trigger final refit
-			this._recomputeAndRefit();
+			// Drag ended — trigger final refit (mesh) or finalize (light)
+			if ( this._attached?.isLight ) {
+
+				this._finalizeLightTransform();
+
+			} else {
+
+				this._recomputeAndRefit();
+
+			}
+
 			this._app.dispatchEvent( { type: EngineEvents.OBJECT_TRANSFORM_END } );
 
 		}
@@ -202,6 +254,73 @@ export class TransformManager {
 		this._app.needsReset = true;
 		this._app.wake();
 
+		if ( this._attached?.isLight ) {
+
+			this._syncLightDuringDrag();
+
+		}
+
+	}
+
+	// ── Light Transform Sync ──
+
+	/**
+	 * Called every gizmo move while a light is attached. Translate mode carries
+	 * `.target` along by the same delta (so moving a light doesn't silently
+	 * swing its aim); rotate mode recomputes `.target` from the light's
+	 * quaternion at a fixed distance (so rotating actually steers the beam/sun).
+	 * Also resyncs GPU light buffers + the visible SceneHelpers gizmo live.
+	 */
+	_syncLightDuringDrag() {
+
+		const light = this._attached;
+
+		if ( light.target ) {
+
+			const mode = this._controls.mode;
+
+			if ( mode === 'translate' && this._lastLightPosition ) {
+
+				const delta = this._tempForward.copy( light.position ).sub( this._lastLightPosition );
+				light.target.position.add( delta );
+				light.target.updateMatrixWorld( true );
+
+			} else if ( mode === 'rotate' && this._lightTargetDistance != null ) {
+
+				const forward = this._tempForward.set( 0, 0, - 1 ).applyQuaternion( light.quaternion );
+				light.target.position.copy( light.position ).addScaledVector( forward, this._lightTargetDistance );
+				light.target.updateMatrixWorld( true );
+
+			}
+
+			this._lastLightPosition.copy( light.position );
+
+		}
+
+		this._app.lightManager?.updateLights();
+
+	}
+
+	/**
+	 * Called once on drag end while a light is attached. Bakes RectAreaLight
+	 * scale into width/height (the serializer also reads scale live, but the
+	 * Lights panel sliders are the source of truth for size) and does a final
+	 * GPU/helper resync.
+	 */
+	_finalizeLightTransform() {
+
+		const light = this._attached;
+
+		if ( light.isRectAreaLight && ( light.scale.x !== 1 || light.scale.y !== 1 ) ) {
+
+			light.width *= light.scale.x;
+			light.height *= light.scale.y;
+			light.scale.set( 1, 1, 1 );
+
+		}
+
+		this._app.lightManager?.updateLights();
+
 	}
 
 	// ── Position Extraction & BVH Refit ──
@@ -440,6 +559,9 @@ export class TransformManager {
 		this._skinnedCache = null;
 		this._normalCache = null;
 		this._baselineComputed = false;
+		this._tempForward = null;
+		this._lightTargetDistance = null;
+		this._lastLightPosition = null;
 
 		// Drop back-references to the owning app and shared resources so the
 		// PathTracerApp graph can be GC'd. Without this, _app pinned the entire