ris-framework 0.2.0-dev.14 → 0.2.0-dev.16

package/src/api/camera/OrbitCamera.ts

@@ -10,6 +10,8 @@ import {MouseButton} from "../input/mouse/MouseButton.ts";
 import {TouchCollection} from "../input/touch/TouchCollection.ts";
 import {TouchLocation} from "../input/touch/TouchLocation.ts";
 import {InputDeviceType} from "../input/InputDeviceType.ts";
+import {CameraTransformUtilities} from "./CameraTransformUtilities.ts";
+import type {TransformNode} from "../scene/node/TransformNode.ts";
 
 /**
  * Camerae that support orbit movement.
@@ -31,6 +33,7 @@ export class OrbitCamera implements ICamera {
     private readonly _inputManager: IInputManager
 
     /** The rotation around the vertical axis. */
+    private readonly _target = vec3.create();
     private _yaw = 0;
 
     /** The tilt of the camera.*/
@@ -47,8 +50,8 @@ export class OrbitCamera implements ICamera {
                        public supportedInputTypes: InputDeviceType = InputDeviceType.MOUSE | InputDeviceType.TOUCHPAD) {
         this._coreCamera = coreCamera;
         this._inputManager = inputManager;
-        this.eye = vec3.fromValues(0, 0, -3);
-        this.target = vec3.fromValues(0, 0, 0);
+        vec3.set(this._coreCamera.transform.position, 0, 0, 3);
+        this._syncFromTransform();
         void this.POSITIVE_179_DEG;
         void this.findTarget;
     }
@@ -66,7 +69,6 @@ export class OrbitCamera implements ICamera {
     public pinchSpeed: number = 1;
 
     /** The up vector. */
-    public up = vec3.fromValues(0, 1, 0);
 
     /** The clamp values of pitch axis */
     public pitchClamp = vec2.fromValues(-this.POSITIVE_89_DEG, this.POSITIVE_89_DEG);
@@ -119,37 +121,65 @@ export class OrbitCamera implements ICamera {
     /** Orbit controls can be used if this button is pressed. */
     public orbitButton = MouseButton.LEFT;
 
-    /**
-     * The eye position of the camera.
-     */
-    public get eye(): vec3 {
-        return this._coreCamera.eye;
+    /** The orbit camera's transform: the core camera's transform. Its position is the eye; the rotation is set each update to look at {@link target}. */
+    public get transform(): TransformNode {
+        return this._coreCamera.transform;
     }
 
     /**
-     * The eye position of the camera.
+     * Sets the point the camera orbits around and looks at (the core camera's target). By default, the origin.
+     * @param target The world point.
      */
-    public set eye(value: vec3) {
-        this._coreCamera.eye = value;
-        this._setPitchAndYawFromDirection(this._coreCamera.direction);
+    public setTarget(target: vec3): void {
+        vec3.copy(this._target, target);
+        this._syncFromTransform();
     }
 
-    /**
-     * The eye position of the camera.
-     */
-    public get target(): vec3 {
-        return this._coreCamera.target;
+    /** @inheritDoc */
+    public getTarget(out: vec3 = vec3.create()): vec3 {
+        return vec3.copy(out, this._target);
     }
 
     /**
-     * The eye position of the camera.
+     * Moves the camera to a world position and re-derives the orbit (pitch, yaw, distance) around the target.
+     * @param eye The world position.
      */
-    public set target(value: vec3) {
-        this._coreCamera.target = value;
-        this._setPitchAndYawFromDirection(this._coreCamera.direction);
+    public setEye(eye: vec3): void {
+        CameraTransformUtilities.setWorldPosition(this._coreCamera.transform, eye);
+        this._syncFromTransform();
+    }
+
+    /** @inheritDoc */
+    public getEye(out?: vec3): vec3 {
+        return this._coreCamera.getEye(out);
+    }
+
+    /** Sets the up vector the core camera aims with (the orbit angles stay around world +Y, so this rolls the view). */
+    public setUp(up: vec3): void {
+        this._coreCamera.setUp(up);
+        this._coreCamera.setTarget(this._target);
+    }
+
+    /** @inheritDoc */
+    public getUp(out?: vec3): vec3 {
+        return this._coreCamera.getUp(out);
+    }
+
+    /** The eye: `transform.position` (world space). */
+    private get _eye(): vec3 {
+        return this._coreCamera.transform.position;
+    }
+
+    /** Re-derives pitch and yaw from the eye and target, and aims the core camera at the target. */
+    private _syncFromTransform(): void {
+        vec3.sub(this._tempDirection, this._target, this._eye);
+        if (vec3.sqrLen(this._tempDirection) === 0) {
+            return;
+        }
+        this._setPitchAndYawFromDirection(this._tempDirection);
+        this._coreCamera.setTarget(this._target);
     }
 
-    /** Gets the core camera.*/
     public get coreCamera(): ICamera | undefined {
         return this._coreCamera;
     }
@@ -184,7 +214,8 @@ export class OrbitCamera implements ICamera {
         vec3.normalize(lookDirection, lookDirection);
         const y = MathHelper.clamp(lookDirection[1], -1, 1);
         this._pitch = -this._pitchClamp(Math.asin(y));
-        this._yaw = -Math.atan2(lookDirection[0], lookDirection[2]);
+        // World direction; the orbit angles keep their original z-flipped convention.
+        this._yaw = -Math.atan2(lookDirection[0], 0 - lookDirection[2]);
     }
 
     private _calculateOrbitMovement() {
@@ -192,7 +223,7 @@ export class OrbitCamera implements ICamera {
         this._pitch = this._pitchClamp(this._pitch);
 
         // Convert spherical coordinates to Cartesian
-        vec3.sub(this._tempVec3, this._coreCamera.target, this._coreCamera.eye);
+        vec3.sub(this._tempVec3, this._target, this._eye);
         const radius = vec3.len(this._tempVec3);
 
         const sinPitch = Math.sin(this._pitch);
@@ -204,8 +235,9 @@ export class OrbitCamera implements ICamera {
 
         this._tempVec3[0] = x;
         this._tempVec3[1] = y;
-        this._tempVec3[2] = -z;
-        vec3.add(this._coreCamera.eye, this._coreCamera.target, this._tempVec3);
+        this._tempVec3[2] = z;
+        vec3.add(this._eye, this._target, this._tempVec3);
+        this._coreCamera.setTarget(this._target);
     }
 
     /**
@@ -267,11 +299,11 @@ export class OrbitCamera implements ICamera {
         }
 
         // Find the current distance.
-        vec3.copy(this._tempDirection, this.direction);
+        vec3.sub(this._tempDirection, this._target, this._eye);
 
         // Find the next eye position.
         vec3.normalize(this._tempDirection, this._tempDirection);
-        vec3.copy(this._tempNextEye, this.eye);
+        vec3.copy(this._tempNextEye, this._eye);
 
         if (diff < 0) {
             vec3.scale(this._tempVec3, this._tempDirection, this.pinchSpeed * deltaTime);
@@ -282,8 +314,8 @@ export class OrbitCamera implements ICamera {
         }
 
         // Find the new potential length.
-        vec3.sub(this._tempNextDirection, this.target, this._tempNextEye);
-        const nextLength = this._tempNextDirection.length;
+        vec3.sub(this._tempNextDirection, this._target, this._tempNextEye);
+        const nextLength = vec3.len(this._tempNextDirection);
         vec3.normalize(this._tempNextDirection, this._tempNextDirection);
 
         // Difference between next direction and direction.
@@ -298,8 +330,8 @@ export class OrbitCamera implements ICamera {
             return;
         }
 
-        vec3.copy(this._coreCamera.eye, this._tempNextEye);
-        this._setPitchAndYawFromDirection(this._coreCamera.direction);
+        vec3.copy(this._eye, this._tempNextEye);
+        this._syncFromTransform();
     }
 
     /** Handles forward/backward movement */
@@ -312,7 +344,7 @@ export class OrbitCamera implements ICamera {
         }
 
         // Find the current distance.
-        vec3.copy(this._tempDirection, this.direction);
+        vec3.sub(this._tempDirection, this._target, this._eye);
         const distance = vec3.len(this._tempDirection);
 
         // Map it to [1,0.1f] space.
@@ -331,7 +363,7 @@ export class OrbitCamera implements ICamera {
 
         // Find the next eye position.
         vec3.normalize(this._tempDirection, this._tempDirection);
-        vec3.copy(this._tempNextEye, this.eye);
+        vec3.copy(this._tempNextEye, this._eye);
 
         if (mouseScrollPos > 0) {
             vec3.scale(this._tempVec3, this._tempDirection, trueScrollSpeed * deltaTime);
@@ -342,8 +374,8 @@ export class OrbitCamera implements ICamera {
         }
 
         // Find the new potential length.
-        vec3.sub(this._tempNextDirection, this.target, this._tempNextEye);
-        const nextLength = this._tempNextDirection.length;
+        vec3.sub(this._tempNextDirection, this._target, this._tempNextEye);
+        const nextLength = vec3.len(this._tempNextDirection);
         vec3.normalize(this._tempNextDirection, this._tempNextDirection);
 
         // Difference between next direction and direction.
@@ -358,8 +390,8 @@ export class OrbitCamera implements ICamera {
             return;
         }
 
-        vec3.copy(this._coreCamera.eye, this._tempNextEye);
-        this._setPitchAndYawFromDirection(this._coreCamera.direction);
+        vec3.copy(this._eye, this._tempNextEye);
+        this._syncFromTransform();
     }
 
     /** @inheritDoc */
@@ -392,6 +424,7 @@ export class OrbitCamera implements ICamera {
             }
         }
 
+        this._coreCamera.setTarget(this._target);
         this._coreCamera.update(time);
     }
 

package/src/api/camera/OrthographicCamera.ts

@@ -4,21 +4,21 @@ import {vec3, mat4} from "gl-matrix";
 import type { IUniformBuffer } from "../rendering/buffers/IUniformBuffer.ts";
 import {BufferUsage} from "../rendering/buffers/BufferUsage.ts";
 import {GameTime} from "../time/GameTime.ts";
+import {TransformNode} from "../scene/node/TransformNode.ts";
+import {CameraAim, CameraTransformUtilities} from "./CameraTransformUtilities.ts";
 
 /**
  * The Orthographic Camera.
  */
 export class OrthographicCamera implements IOrthographicCamera {
 
-    static UP_VECTOR = vec3.fromValues(0, 1, 0);
-
     private readonly _framework: IFramework;
 
     /** @ts-ignore */
     private readonly _zSpaceLength: number;
 
-    private _eye: vec3;
-    private _target: vec3;
+    private readonly _lastWorld = mat4.fromValues(NaN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+    private readonly _direction = vec3.create();
 
     private _left: number;
     private _right: number;
@@ -33,9 +33,58 @@ export class OrthographicCamera implements IOrthographicCamera {
     protected _viewMatrix = mat4.create();
     protected _projectionViewMatrix = mat4.create();
 
-    public readonly position = vec3.create();
-    public readonly target = vec3.create();
-    public readonly direction = vec3.create();
+    /**
+     * The camera transform: the single source of the view. The camera looks down its local -Z axis;
+     * the view matrix is `inverse(T * R)` of `transform.modelMatrix` (scale is ignored).
+     * By default, at (0, 0, 1) looking down -Z at the origin.
+     */
+    public transform = new TransformNode();
+
+    /** The unit direction the camera looks in, from the transform. */
+    public get direction(): vec3 {
+        return CameraTransformUtilities.forwardFromWorld(this._direction, this.transform.modelMatrix);
+    }
+
+    private readonly _aim = new CameraAim(() => this.transform);
+
+    /**
+     * Rotates the transform once so the camera looks at a world point, using the current up ({@link getUp}).
+     * Forgets the target stored by {@link setTarget}, so a later {@link setEye} does not re-aim.
+     * @param target The point to look at.
+     */
+    public lookAt(target: vec3): void {
+        this._aim.lookAt(target);
+    }
+
+    /** @inheritDoc */
+    public setEye(eye: vec3): void {
+        this._aim.setEye(eye);
+    }
+
+    /** @inheritDoc */
+    public getEye(out?: vec3): vec3 {
+        return this._aim.getEye(out);
+    }
+
+    /** @inheritDoc */
+    public setTarget(target: vec3): void {
+        this._aim.setTarget(target);
+    }
+
+    /** @inheritDoc */
+    public getTarget(out?: vec3): vec3 {
+        return this._aim.getTarget(out);
+    }
+
+    /** @inheritDoc */
+    public setUp(up: vec3): void {
+        this._aim.setUp(up);
+    }
+
+    /** @inheritDoc */
+    public getUp(out?: vec3): vec3 {
+        return this._aim.getUp(out);
+    }
 
     private _projectionBuffer: IUniformBuffer = null!;
     private _viewBuffer: IUniformBuffer = null!;
@@ -72,8 +121,7 @@ export class OrthographicCamera implements IOrthographicCamera {
         this._near = near;
         this._far = far;
 
-        this._eye = vec3.fromValues(0, 0, 1);
-        this._target = vec3.fromValues(0, 0, 0);
+        vec3.set(this.transform.position, 0, 0, 1);
 
         this._zSpaceLength = 2; // For WebGL2 it is 2, WebGPU it is 1.
 
@@ -164,19 +212,6 @@ export class OrthographicCamera implements IOrthographicCamera {
         this._isDirty = true;
     }
 
-    /** @inheritDoc */
-    public get eye(): vec3 {
-        return this._eye;
-    }
-
-    /** @inheritDoc */
-    public set eye(value: vec3) {
-        if (this._eye === value)
-            return;
-        this._eye = value;
-        this._isDirty = true;
-    }
-
     /** @inheritDoc */
     public get projectionMatrix(): mat4 {
         return this._projectionMatrix;
@@ -212,19 +247,27 @@ export class OrthographicCamera implements IOrthographicCamera {
         return this._positionBuffer;
     }
 
-    /** Writes the world-space eye into the std140 position data (no z flip: the look-at uses the eye as is). */
+    /** Writes the transform's world position into the std140 position data. */
     private _updatePositionData(): number[] {
-        this._positionData[0] = this._eye[0];
-        this._positionData[1] = this._eye[1];
-        this._positionData[2] = this._eye[2];
+        const m = this.transform.modelMatrix;
+        this._positionData[0] = m[12];
+        this._positionData[1] = m[13];
+        this._positionData[2] = m[14];
         return this._positionData;
     }
 
+    /** True when the transform's world matrix changed since the view was last built. */
+    private _transformChanged(): boolean {
+        return !mat4.exactEquals(this._lastWorld, this.transform.modelMatrix);
+    }
+
     /**
      * Updates the camera matrices.
      */
     protected _updateMatrices() {
-        mat4.lookAt(this._viewMatrix, this._eye, this._target, OrthographicCamera.UP_VECTOR);
+        const world = this.transform.modelMatrix;
+        mat4.copy(this._lastWorld, world);
+        CameraTransformUtilities.viewFromWorld(this._viewMatrix, world);
         mat4.orthoNO(this._projectionMatrix, this._left, this._right, this._bottom, this._top, this._near, this._far);
         mat4.multiply(this._projectionViewMatrix, this._projectionMatrix, this._viewMatrix);
     }
@@ -261,7 +304,7 @@ export class OrthographicCamera implements IOrthographicCamera {
     /** @inheritDoc */
     public update(_: GameTime): void {
 
-        if (!this._isDirty)
+        if (!this._isDirty && !this._transformChanged())
             return;
 
         this.updateBuffers();

package/src/api/camera/PerspectiveCamera.ts

@@ -6,6 +6,8 @@ import {BufferUsage} from "../rendering/buffers/BufferUsage.ts";
 import type { IUniformBuffer } from "../rendering/buffers/IUniformBuffer.ts";
 import {GameTime} from "../time/GameTime.ts";
 import type {Scene} from "../scene/Scene.ts";
+import {TransformNode} from "../scene/node/TransformNode.ts";
+import {CameraAim, CameraTransformUtilities} from "./CameraTransformUtilities.ts";
 
 /**
  * The descriptor for a perspective camera. Every field is optional.
@@ -24,13 +26,16 @@ export interface PerspectiveCameraDescriptor {
     /** The far plane. By default, 100. */
     far?: number;
 
-    /** The eye position. Copied. By default, (0, 0, 3). */
+    /** The world position (see {@link ICamera.setEye}). By default, (0, 0, -3). */
+    position?: vec3;
+
+    /** Alias of {@link position}; `position` wins when both are given. */
     eye?: vec3;
 
-    /** The point the camera looks at. Copied. By default, the origin. */
+    /** The point the camera looks at (see {@link ICamera.setTarget}). By default, the origin. */
     target?: vec3;
 
-    /** The up vector. Copied. By default, (0, 1, 0). */
+    /** The up vector used to aim (see {@link ICamera.setUp}). By default, (0, 1, 0). */
     up?: vec3;
 }
 
@@ -40,7 +45,8 @@ export interface PerspectiveCameraDescriptor {
 export class PerspectiveCamera implements ICamera {
 
     protected readonly _framework: IFramework;
-    private readonly _tempVec3 = vec3.create();
+    private readonly _lastWorld = mat4.fromValues(NaN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+    private readonly _positionData = [0, 0, 0, 0];
 
     private _projectionMatrix = mat4.create();
     private _viewMatrix = mat4.create();
@@ -69,15 +75,11 @@ export class PerspectiveCamera implements ICamera {
         this.aspectRatio = descriptor?.aspectRatio ?? 1;
         this.nearPlane = descriptor?.near ?? 0.01;
         this.farPlane = descriptor?.far ?? 100;
-        if (descriptor?.eye) {
-            vec3.copy(this.eye, descriptor.eye);
-        }
-        if (descriptor?.target) {
-            vec3.copy(this.target, descriptor.target);
-        }
+        vec3.copy(this.transform.position, descriptor?.position ?? descriptor?.eye ?? [0, 0, -3]);
         if (descriptor?.up) {
-            vec3.copy(this.up, descriptor.up);
+            this.setUp(descriptor.up);
         }
+        this.setTarget(descriptor?.target ?? [0, 0, 0]);
         if (scene) {
             scene.add(this);
         }
@@ -148,24 +150,56 @@ export class PerspectiveCamera implements ICamera {
     }
 
     /**
-     * The eye position of the camera.
+     * The camera transform: the single source of the view. The camera looks down its local -Z axis;
+     * the view matrix is `inverse(T * R)` of `transform.modelMatrix` (scale is ignored).
+     * By default, at (0, 0, -3) looking at the origin.
      */
-    public eye = vec3.fromValues(0,0,3);
+    public transform = new TransformNode();
 
-    /**
-     * The target position of the camera.
-     */
-    public target = vec3.create();
+    /** The unit direction the camera looks in, from the transform. */
+    public get direction(): vec3 {
+        return CameraTransformUtilities.forwardFromWorld(this._direction, this.transform.modelMatrix);
+    }
+
+    private readonly _aim = new CameraAim(() => this.transform);
 
     /**
-     * The up vector of the camera.
+     * Rotates the transform once so the camera looks at a world point, using the current up ({@link getUp}).
+     * Forgets the target stored by {@link setTarget}, so a later {@link setEye} does not re-aim.
+     * @param target The point to look at.
      */
-    public up = vec3.fromValues(0,1,0);
+    public lookAt(target: vec3): void {
+        this._aim.lookAt(target);
+    }
 
-    /** The direction of a camera. */
-    public get direction(): vec3 {
-        vec3.sub(this._direction, this.target, this.eye);
-        return this._direction;
+    /** @inheritDoc */
+    public setEye(eye: vec3): void {
+        this._aim.setEye(eye);
+    }
+
+    /** @inheritDoc */
+    public getEye(out?: vec3): vec3 {
+        return this._aim.getEye(out);
+    }
+
+    /** @inheritDoc */
+    public setTarget(target: vec3): void {
+        this._aim.setTarget(target);
+    }
+
+    /** @inheritDoc */
+    public getTarget(out?: vec3): vec3 {
+        return this._aim.getTarget(out);
+    }
+
+    /** @inheritDoc */
+    public setUp(up: vec3): void {
+        this._aim.setUp(up);
+    }
+
+    /** @inheritDoc */
+    public getUp(out?: vec3): vec3 {
+        return this._aim.getUp(out);
     }
 
     /**
@@ -202,12 +236,13 @@ export class PerspectiveCamera implements ICamera {
         this._viewBuffer = this._framework.bufferFactory.createUniformBuffer(this.viewMatrix, bufferUsage);
     }
 
-    /**
-     * The eye in world space, as used by the view matrix: z is flipped for the right-handed look-at.
-     * This is what {@link positionBuffer} holds, std140 `vec3` (padded to 16 bytes).
-     */
+    /** The world position, std140 `vec3` (padded to 16 bytes). This is what {@link positionBuffer} holds. */
     private _worldEye(): number[] {
-        return [this.eye[0], this.eye[1], -this.eye[2], 0];
+        const m = this.transform.modelMatrix;
+        this._positionData[0] = m[12];
+        this._positionData[1] = m[13];
+        this._positionData[2] = m[14];
+        return this._positionData;
     }
 
     /**
@@ -218,11 +253,12 @@ export class PerspectiveCamera implements ICamera {
         // Right-handed
         mat4.perspectiveNO(this._projectionMatrix, this.fieldOfView, this.aspectRatio, this.nearPlane, this.farPlane);
 
-        // mat4 does not have right-handed look at, therefore swap z for right-handed matrix.
-        this._tempVec3[0] = this.eye[0];
-        this._tempVec3[1] = this.eye[1];
-        this._tempVec3[2] = -this.eye[2];
-        mat4.lookAt(this.viewMatrix, this._tempVec3, this.target, this.up);
+        // The view only changes when the transform's world matrix changed.
+        const world = this.transform.modelMatrix;
+        if (!mat4.exactEquals(this._lastWorld, world)) {
+            mat4.copy(this._lastWorld, world);
+            CameraTransformUtilities.viewFromWorld(this.viewMatrix, world);
+        }
         mat4.multiply(this.projectionViewMatrix, this.projectionMatrix, this.viewMatrix);
     }
 

package/src/api/content/ContentManager.ts

@@ -1,3 +1,4 @@
+import {ColorSpace} from "../rendering/enums.ts";
 import {
     type IShaderModule,
     type IContentManager,
@@ -94,7 +95,10 @@ export class ContentManager implements IContentManager {
             return tex;
         }
 
-        let format = this._framework.renderer.preferredTextureFormat;
+        // The descriptor's color space overrides the renderer's; an explicit format overrides both.
+        let format = desc.preferredColorSpace
+            ? (desc.preferredColorSpace == ColorSpace.SRGB ? TextureFormat.RGBA_8_UNORM_SRGB : TextureFormat.RGBA_8_UNORM)
+            : this._framework.renderer.preferredTextureFormat;
 
         if (desc.textureFormat != TextureFormat.UNDEFINED) {
             format = desc.textureFormat;
@@ -103,13 +107,12 @@ export class ContentManager implements IContentManager {
         const imageLoader = this._framework.imageLoader;
         const data = await imageLoader.loadAsync(path, contentConfig?.keepDataCached);
 
-        // TODO: pass texture descriptor
         return this._framework.textureFactory.create(
             data.baseWidth, data.baseHeight,
             data.getData(0) as Uint8Array,
             data.channels,
-            path,
-            TextureUsage.TEXTURE_BINDING | TextureUsage.COPY_SRC,
+            desc.label ?? path,
+            textureDescriptor?.textureUsage ?? (TextureUsage.TEXTURE_BINDING | TextureUsage.COPY_SRC),
             format,
             desc.generateMipmaps
         );
@@ -118,7 +121,8 @@ export class ContentManager implements IContentManager {
     /** @inheritDoc */
     public loadTexture2DFromPixels(width: number, height: number, pixels: ArrayBuffer): ITexture2D {
         const view = new Uint8Array(pixels);
-        return this._framework.textureFactory.create(width, height, view);
+        // Raw pixels keep the old linear default.
+        return this._framework.textureFactory.create(width, height, view, 4, undefined, undefined, TextureFormat.RGBA_8_UNORM);
     }
 
     /** @inheritDoc */

package/src/api/lights/AmbientLight.ts

@@ -1,6 +1,8 @@
 import {Color} from "../data/Color.ts";
 import {createLightId} from "./LightId.ts";
 import type {Scene} from "../scene/Scene.ts";
+import type {ILight} from "./ILight.ts";
+import {TransformNode} from "../scene/node/TransformNode.ts";
 
 /** The descriptor for an ambient light. All fields are optional. */
 export interface AmbientLightDescriptor {
@@ -18,11 +20,12 @@ export interface AmbientLightDescriptor {
 }
 
 /**
- * The ambient light. Plain data: it has no GPU resources.
+ * The ambient light. Plain data: it has no GPU resources. It has a {@link transform} (so it can live in `scene.nodes`),
+ * but the transform has no effect on the lighting.
  * Put it into a {@link LightsBuffer} to use it in shaders.
  * @public
  */
-export class AmbientLight {
+export class AmbientLight implements ILight {
 
     /**
      * The constructor.
@@ -39,6 +42,9 @@ export class AmbientLight {
         scene?.add(this);
     }
 
+    /** The transform. It has no effect on an ambient light. */
+    public transform: TransformNode = new TransformNode();
+
     /** The unique id of this light. */
     public readonly id: number;