ris-framework 0.1.0 → 0.2.0-dev.12

package/src/Framework.ts

@@ -1,40 +1,42 @@
-import {container, type DependencyContainer} from "tsyringe";
+import {WebGlAmbientLightFactory} from "./webgl/lights/WebGlAmbientLightFactory.ts";
 import {WindowManager} from "./api/window/WindowManager.ts";
-import {FrameworkConfiguration} from "./api/FrameworkConfiguration.ts";
-import {type IRendererConfiguration, RenderConfigurationSymbol} from "./api/rendering/renderer-interface.ts";
 import {GeometryBuilder} from "./api/geometry/GeometryBuilder.ts";
 import {ContentManager} from "./api/content/ContentManager.ts";
+import {ObjLoader} from "./api/loaders/ObjLoader.ts";
 import {WebGlRenderer} from "./webgl/WebGlRenderer.ts";
 import {WebGlBuffersFactory} from "./webgl/buffers/WebGlBuffersFactory.ts";
 import {
-    type ICameraFactory,
-    type IContentManager,
-    type IFramework, IFrameworkConfiguration,
-    type IImageLoader,
-    type IRenderer,
-    type IRenderPipelineFactory,
-    type IWindowManager
-} from "./api/index.ts";
-import {
+    type AmbientLightFactory,
     CameraFactory,
     CpuImageProcessor,
     GameTime,
     type IBufferFactory,
+    type ICameraFactory,
+    type IContentManager,
+    type IFramework,
+    IFrameworkConfiguration,
     type IGeometryBuilder,
     type IGraphicsDevice,
+    type IImageLoader,
     type IImageProcessor,
     type IInputManager,
     ImageLoader,
     type IMaterialFactory,
     type IMeshFactory,
+    type IRenderer,
+    type IRendererConfiguration,
+    type IRenderPipelineFactory,
     type ISpriteBatch,
     type ITextureFactory,
     type ITimeManager,
+    type IWindowManager,
     MaterialFactory,
     MeshFactory,
     RenderingBackend,
     TimeManager
 } from "./api/index.ts";
+import {WebGlTexture2D} from "./webgl/texture/WebGlTexture2D.ts";
+import type {IDisposable} from "./api/core/IDisposable.ts";
 import {WebGlShaderModuleLoader} from "./webgl/shader/WebGlShaderModuleLoader.ts";
 import {TextureSamplerFilteringPreset} from "./core/rendering/enums.ts";
 import {SpriteBatch} from "./api/sprites/SpriteBatch.ts";
@@ -45,7 +47,16 @@ import type {IKtx2Factory} from "ris-ktx2";
 import {Ktx2Factory} from "ris-ktx2";
 import {PowerPreferenceType} from "./api/rendering/PowerPreference.ts";
 import {vec2} from "gl-matrix";
-
+import {ARenderer} from "./core/rendering/ARenderer.ts";
+import {WebGpuRenderer} from "./webgpu/WebGpuRenderer.ts";
+import {WebGpuTextureFactory} from "./webgpu/texture/WebGpuTextureFactory.ts";
+import {WebGpuRenderPipelineFactory} from "./webgpu/render-pipelines/WebGpuRenderPipelineFactory.ts";
+import {WebGpuShaderModuleLoader} from "./webgpu/shader/WebGpuShaderModuleLoader.ts";
+import {WebGpuBuffersFactory} from "./webgpu/buffers/WebGpuBuffersFactory.ts";
+import {WebGpuTexture2D} from "./webgpu/texture/WebGpuTexture2D.ts";
+import {TextureColorSpace} from "./api/rendering/enums.ts";
+
+/** The Ris framework */
 export class Framework implements IFramework {
 
     private readonly _onLoadContentListeners: (() => void)[] = [];
@@ -53,47 +64,63 @@ export class Framework implements IFramework {
     private readonly _onUpdateListeners: ((gameTime: GameTime) => void)[] = [];
     private readonly _onRenderListeners: (() => void)[] = [];
 
-    private readonly _container: DependencyContainer;
-    private readonly _textureFactory: ITextureFactory;
-    private readonly _buffersFactory: IBufferFactory;
-    private readonly _contentManager: IContentManager;
+    private _configuration: IFrameworkConfiguration;
+    private _textureFactory: ITextureFactory = null!;
+    private _buffersFactory: IBufferFactory = null!;
+    private _contentManager: IContentManager = null!;
+    private readonly _rendererConfiguration: IRendererConfiguration = null!;
+    private _renderer: IRenderer = null!;
     private readonly _geometryBuilder: IGeometryBuilder;
     private readonly _meshFactory: IMeshFactory;
+    private _disposed = false;
 
     /**
      * The constructor for the Framework class.
-     * @param options The optional framework configuration. When omitted, a default `FrameworkConfiguration` is used.
+     * @param configuration The optional framework configuration. When omitted, a default `FrameworkConfiguration` is used.
      */
-    constructor(options?: IFrameworkConfiguration) {
-        options = options ?? new FrameworkConfiguration();
+    constructor(configuration?: IFrameworkConfiguration) {
+
+        this._configuration = configuration ?? {}
+
+        if(!this._configuration.backBufferSize){
+            this._configuration.backBufferSize = vec2.fromValues(800, 600);
+        }
 
         // Without a canvas, WindowManager creates one and appends it to document.body.
-        if(!options.canvas){
+        if(!this._configuration.canvas){
             console.warn("Canvas not provided. Creating canvas and appending it to document.body.")
         }
-        options.backBufferSize = options.backBufferSize ?? vec2.fromValues(800, 600);
+        this._configuration.backBufferSize = this._configuration.backBufferSize ?? vec2.fromValues(800, 600);
 
-        this._container = container.createChildContainer();
-        this.windowManager = new WindowManager(options.canvas ?? null);
+        this.windowManager = new WindowManager(this._configuration.canvas ?? null);
 
-        // Setup container.
-        const rendererConfig: IRendererConfiguration = {
-            backBufferSize: options.backBufferSize,
-            textureFiltering: options.textureFiltering ?? TextureSamplerFilteringPreset.BILINEAR,
-            alpha: options.alpha ?? false,
-            powerPreference: options.powerPreference ?? PowerPreferenceType.DEFAULT
+        // Services are created here and get their dependencies through their constructors.
+        this._rendererConfiguration  = {
+            backBufferSize: this._configuration.backBufferSize,
+            textureFiltering: this._configuration.textureFiltering ?? TextureSamplerFilteringPreset.BILINEAR,
+            alpha: this._configuration.alpha ?? false,
+            powerPreference: this._configuration.powerPreference ?? PowerPreferenceType.DEFAULT,
+            textureColorSpace: this._configuration.textureColorSpace ?? TextureColorSpace.SRGB
         };
-        this._container.registerInstance(RenderConfigurationSymbol, rendererConfig);
-        this.renderer = new WebGlRenderer(this, rendererConfig);
-        this.renderingBackend = RenderingBackend.WEB_GL;
-        this._textureFactory = new WebGlTextureFactory(this);
+
+
+        // The renderer, texture, pipeline, shader and buffer services depend on the backend.
+        let backend = this._configuration.renderingBackend ?? RenderingBackend.WEB_GL;
+        if (backend === RenderingBackend.DEFAULT) {
+            backend = RenderingBackend.WEB_GL;
+        }
+        if (backend === RenderingBackend.WEB_GPU && !WebGpuRenderer.isSupported()) {
+            console.warn("WebGPU was requested, but navigator.gpu is missing. Falling back to WebGL.");
+            backend = RenderingBackend.WEB_GL;
+        }
+        this.renderingBackend = backend;
+        this._setupBackendServices(backend);
+
         this._geometryBuilder = new GeometryBuilder();
-        this.renderPipelineFactory = new WebGlRenderPipelineFactory(this);
-        this._contentManager = new ContentManager(this, new WebGlShaderModuleLoader(this));
         this._meshFactory = new MeshFactory(this);
         this.materialFactory = new MaterialFactory(this);
+        this.lightsFactory = new WebGlAmbientLightFactory(this);
 
-        this._buffersFactory = new WebGlBuffersFactory(this);
         this.spriteBatch = new SpriteBatch(this);
         this.cameraFactory = new CameraFactory(this);
         this.timeManager = new TimeManager();
@@ -101,7 +128,7 @@ export class Framework implements IFramework {
         this.imageProcessor = new CpuImageProcessor();
         this.imageLoader = new ImageLoader(this);
 
-        if(options.useKtx2){
+        if(this._configuration.useKtx2){
             this.ktx2Factory = new Ktx2Factory();
         }
     }
@@ -115,7 +142,30 @@ export class Framework implements IFramework {
     public readonly imageProcessor :IImageProcessor;
 
     /** @inheritDoc */
-    public readonly renderer : IRenderer;
+    public get renderer(): IRenderer {
+        return this._renderer;
+    }
+
+    /**
+     * Creates the backend-specific services: renderer, texture factory, pipeline factory, shader loader and buffers factory.
+     * @param backend WEB_GL or WEB_GPU.
+     */
+    private _setupBackendServices(backend: RenderingBackend): void {
+        this.renderingBackend = backend;
+        if (backend === RenderingBackend.WEB_GPU) {
+            this._renderer = new WebGpuRenderer(this, this._rendererConfiguration);
+            this._textureFactory = new WebGpuTextureFactory(this);
+            this.renderPipelineFactory = new WebGpuRenderPipelineFactory(this);
+            this._contentManager = new ContentManager(this, new WebGpuShaderModuleLoader(this));
+            this._buffersFactory = new WebGpuBuffersFactory(this);
+        } else {
+            this._renderer = new WebGlRenderer(this, this._rendererConfiguration);
+            this._textureFactory = new WebGlTextureFactory(this);
+            this.renderPipelineFactory = new WebGlRenderPipelineFactory(this);
+            this._contentManager = new ContentManager(this, new WebGlShaderModuleLoader(this));
+            this._buffersFactory = new WebGlBuffersFactory(this);
+        }
+    }
 
     /** @inheritDoc */
     public readonly spriteBatch: ISpriteBatch;
@@ -183,7 +233,7 @@ export class Framework implements IFramework {
     }
 
     /** @inheritdoc */
-    public renderPipelineFactory: IRenderPipelineFactory;
+    public renderPipelineFactory: IRenderPipelineFactory = null!;
 
     /** @inheritdoc */
     get geometryBuilder(): IGeometryBuilder {
@@ -213,9 +263,15 @@ export class Framework implements IFramework {
         return this._meshFactory;
     }
 
+    /** @inheritDoc */
+    public readonly objLoader: ObjLoader = new ObjLoader(this);
+
     /** @inheritDoc */
     public readonly materialFactory: IMaterialFactory;
 
+    /** @inheritDoc */
+    public readonly lightsFactory: AmbientLightFactory;
+
     /** @inheritDoc */
     public readonly timeManager: ITimeManager;
 
@@ -225,22 +281,55 @@ export class Framework implements IFramework {
     /** @inheritdoc */
     public initialize(): void {
 
+        // WebGPU needs an async device request; initialize() keeps the synchronous WebGL path.
+        if (this.renderingBackend === RenderingBackend.WEB_GPU) {
+            console.warn("WebGPU needs Framework.initializeAsync(). initialize() falls back to WebGL.");
+            this._setupBackendServices(RenderingBackend.WEB_GL);
+        }
+
         if(this.ktx2Factory) {
             this.ktx2Factory.initializeAsync();
         }
 
-        (this.renderer as WebGlRenderer).initialize();
+        this._initializeCore();
+    }
+
+    /**
+     * Initializes the framework and starts the event loop. Required for WebGPU, which requests its adapter
+     * and device asynchronously; for WebGL it behaves like {@link initialize}.
+     * If the WebGPU device cannot be acquired, the framework falls back to WebGL with a warning.
+     */
+    public async initializeAsync(): Promise<void> {
+        if (this.renderingBackend === RenderingBackend.WEB_GPU) {
+            try {
+                await (this._renderer as WebGpuRenderer).acquireDeviceAsync();
+            } catch (error) {
+                console.warn(`WebGPU could not be initialized (${(error as Error)?.message ?? error}). Falling back to WebGL.`);
+                this._setupBackendServices(RenderingBackend.WEB_GL);
+            }
+        }
+
+        if (this.ktx2Factory) {
+            this.ktx2Factory.initializeAsync();
+        }
+
+        this._initializeCore();
+    }
+
+    private _initializeCore(): void {
+        (this._renderer as ARenderer).initialize();
         this.spriteBatch.initialize();
         this.input.initialize();
 
         this.timeManager.prepareStart();
 
-        // Load content events.
-        for(const listener of this._onLoadContentListeners){
+        // Initialize callbacks.
+        for(const listener of this._onInitializeListeners){
             listener();
         }
 
-        for(const listener of this._onInitializeListeners){
+        // Load content events.
+        for(const listener of this._onLoadContentListeners){
             listener();
         }
 
@@ -271,10 +360,29 @@ export class Framework implements IFramework {
         this.windowManager.runEventLoop();
     }
 
-    /** @inheritDoc */
-    public dispose() {
-       //  this.windowManager.dispose();
+    /**
+     * Stops the event loop and disposes the framework's services and GL resources,
+     * including per-framework caches such as the default texture and the shader modules.
+     * A new `Framework` afterwards creates fresh resources on its own context. Calling it twice does nothing.
+     */
+    public dispose(): void {
+        if (this._disposed) {
+            return;
+        }
+        this._disposed = true;
+
+        this.windowManager.dispose();
+        (this.input as Partial<IDisposable>).dispose?.();
+
+        this._onLoadContentListeners.length = 0;
+        this._onInitializeListeners.length = 0;
+        this._onUpdateListeners.length = 0;
+        this._onRenderListeners.length = 0;
 
-        // TODO: dispose of other resources
+        WebGlTexture2D.disposeDefault(this);
+        WebGpuTexture2D.disposeDefault(this);
+        (this._contentManager as Partial<IDisposable>).dispose?.();
+        // Only exists after initialize(); it owns the default sampler and blend state.
+        (this.renderer.graphicsDevice as IGraphicsDevice | undefined)?.dispose();
     }
 }

package/src/api/IFramework.ts

@@ -7,10 +7,12 @@ import type { IBufferFactory } from "./rendering/buffers/IBufferFactory.ts";
 import type { IGeometryBuilder } from "./geometry/IGeometryBuilder.ts";
 import type { ICameraFactory } from "./camera/ICameraFactory.ts";
 import type { ITextureFactory } from "./rendering/texture/ITextureFactory.ts";
+import type { ObjLoader } from "./loaders/ObjLoader.ts";
 import type { IContentManager } from "./content/IContentManager.ts";
 import type { IImageLoader } from "./loaders/IImageLoader.ts";
 import type { IMeshFactory } from "./meshes/IMeshFactory.ts";
 import type { IMaterialFactory } from "./material/IMaterialFactory.ts";
+import type { AmbientLightFactory } from "./lights/LightFactory.ts";
 import type { ITimeManager } from "./time/ITimeManager.ts";
 import type { IInputManager } from "./input/IInputManager.ts";
 import type { IWindowManager } from "./window/IWindowManager.ts";
@@ -18,6 +20,49 @@ import {GameTime} from "./time/GameTime.ts";
 import type { IImageProcessor } from "./image/IImageProcessor.ts";
 import type { IKtx2Factory } from "ris-ktx2";
 import type { IDisposable } from "./core/IDisposable.ts";
+import type {vec2} from "gl-matrix";
+import type {TextureSamplerFilteringPreset} from "../core/rendering/enums.ts";
+import type {PowerPreferenceType} from "./rendering/PowerPreference.ts";
+import type {TextureColorSpace} from "./rendering/enums.ts";
+
+
+/**
+ * The configuration for the framework.
+ * @public
+ **/
+export class IFrameworkConfiguration {
+
+    /** If true, creates and makes the KTX2 factory available. */
+    useKtx2?: boolean;
+
+    /** The size of back buffer. By default, if not specified (800, 600). */
+    backBufferSize?: vec2;
+
+    /** The texture filtering to configure */
+    textureFiltering?: TextureSamplerFilteringPreset;
+
+    /** The texture color space to use by default. By default, it is {@link TextureColorSpace.SRGB}. */
+     textureColorSpace?: TextureColorSpace;
+
+     /**
+     * The HTMLCanvasElement to use for rendering.
+     * If null, a new canvas will be created and added to the document body.
+     */
+    canvas?: HTMLCanvasElement;
+
+    /** Should back buffer use alpha. */
+    alpha?: boolean;
+
+    /** The preference when it comes to selecting GPU device. Only makes sense to set on multi-GPU devices. */
+    powerPreference ?: PowerPreferenceType;
+
+    /**
+     * The rendering backend. Defaults to WebGL.
+     * WebGPU requires `Framework.initializeAsync()`; when `navigator.gpu` is missing or no device is available,
+     * the framework falls back to WebGL with a warning.
+     */
+    renderingBackend?: RenderingBackend;
+}
 
 /** The framework interface. */
 export interface IFramework extends IDisposable {
@@ -86,11 +131,21 @@ export interface IFramework extends IDisposable {
      */
     readonly meshFactory: IMeshFactory;
 
+    /**
+     * The OBJ loader: `objLoader.loadAsync(path, blinnPhongDescriptor | subMesh => material)`.
+     */
+    readonly objLoader: ObjLoader;
+
     /**
      * The material factory.
      */
     readonly materialFactory: IMaterialFactory;
 
+    /**
+     * The ambient light factory.
+     */
+    readonly lightsFactory: AmbientLightFactory;
+
     /**
      * The time manager.
      */
@@ -117,14 +172,10 @@ export interface IFramework extends IDisposable {
      */
     removeOnLoadContentListener(event: () => void): void;
 
-    /**
-     * Called when the framework is initialized.
-     */
+    /** Called when the framework is initialized.*/
     addOnInitializedListener(event: () => void): void;
 
-    /**
-     * Called when the framework is initialized.
-     */
+    /** Called when the framework is initialized.*/
     removeOnInitializedListener(event: () => void): void;
 
     /**
@@ -150,4 +201,10 @@ export interface IFramework extends IDisposable {
     /** Initializes the framework. */
     initialize(): void;
 
+    /**
+     * Initializes the framework asynchronously and starts the event loop.
+     * Required for the WebGPU backend; for WebGL it behaves like {@link initialize}.
+     */
+    initializeAsync(): Promise<void>;
+
 }

package/src/api/_export.ts

@@ -1,5 +1,4 @@
 export * from "./IFramework.ts";
-export * from "./IFrameworkConfiguration.ts";
 export * from "./rendering/texture/_export-texture.ts";
 export * from "./rendering/buffers/_export-buffers.ts";
 export * from "./data/_export.ts";
@@ -22,5 +21,8 @@ export * from "./rendering/sampler/_export.ts"
 export * from "./utilities/_export.ts"
 export * from "./meshes/_export.ts";
 export * from "./material/_export.ts";
+export * from "./lights/_export.ts";
+export * from "./scene/Scene.ts";
+export * from "./scene/SceneMesh.ts";
 export * from "./input/_export.ts";
 export * from "./image/_export.ts";

package/src/api/camera/CameraFactory.ts

@@ -1,11 +1,11 @@
 import  {vec2} from "gl-matrix";
 import type { ICameraFactory } from "./ICameraFactory.ts";
+import type { Scene } from "../scene/Scene.ts";
 import type { IFramework } from "../IFramework.ts";
 import type { IOrthographicCamera } from "./IOrthographicCamera.ts";
 import {OrthographicCamera} from "./OrthographicCamera.ts";
 import {OrbitCamera} from "./OrbitCamera.ts";
-import {PerspectiveCamera} from "./PerspectiveCamera.ts";
-import {MathHelper} from "../utilities/MathHelper.ts";
+import {PerspectiveCamera, type PerspectiveCameraDescriptor} from "./PerspectiveCamera.ts";
 
 /** The Camera Factory */
 export class CameraFactory implements ICameraFactory {
@@ -41,15 +41,15 @@ export class CameraFactory implements ICameraFactory {
 
     /** @inheritDoc */
     public createOrbitCamera(fov = 60, aspectRatio = 1, near = 0.01, far = 100): OrbitCamera {
-        return new OrbitCamera(this.createPerspectiveCamera(fov, aspectRatio, near, far), this._framework.input);
+        return new OrbitCamera(this.createPerspectiveCamera({fov, aspectRatio, near, far}), this._framework.input);
 
     }
 
     /** @inheritDoc */
-    public createPerspectiveCamera(fov= 60, aspectRatio = 1, near= 0.01, far = 100): PerspectiveCamera {
-        fov = MathHelper.toRadians(fov);
-        const camera = new PerspectiveCamera(this._framework, fov, aspectRatio, near, far);
+    public createPerspectiveCamera(descriptor?: PerspectiveCameraDescriptor, scene? : Scene): PerspectiveCamera {
+        const camera = new PerspectiveCamera(this._framework, descriptor, scene);
         camera.initialize();
+
         return camera;
     }
 

package/src/api/camera/ICamera.ts

@@ -36,6 +36,12 @@ export interface ICamera extends IDisposable {
      */
     readonly viewBuffer: IUniformBuffer;
 
+    /**
+     * The world-space eye position buffer, std140 `vec3` (`[x, y, z, 0]`).
+     * Used by lit materials for specular highlights.
+     */
+    readonly positionBuffer: IUniformBuffer;
+
     /**
      * Update the GPU buffers.
      * This needs to be called when camera properties are changed.

package/src/api/camera/ICameraFactory.ts

@@ -1,7 +1,8 @@
 import type { IOrthographicCamera } from "./IOrthographicCamera.ts";
 import {vec2} from "gl-matrix";
 import {OrbitCamera} from "./OrbitCamera.ts";
-import {PerspectiveCamera} from "./PerspectiveCamera.ts";
+import {PerspectiveCamera, type PerspectiveCameraDescriptor} from "./PerspectiveCamera.ts";
+import type {Scene} from "../scene/Scene.ts";
 
 /**
  * The camera factory.
@@ -10,17 +11,11 @@ export interface ICameraFactory {
 
     /**
      * Creates a new perspective camera.
-     * @param fov The field of view. By default, 60 degrees.
-     * @param aspectRatio The aspect ratio. By default, 1.
-     * @param near The near plane. By default, 0.01.
-     * @param far The far plane. By default, 100.
+     * @param descriptor The optional descriptor; omitted fields use the defaults documented on {@link PerspectiveCameraDescriptor}.
+     * @param scene The optional scene; the camera becomes its `scene.camera`.
      * @return The perspective camera.
      */
-    createPerspectiveCamera(
-        fov?: number,
-        aspectRatio?: number,
-        near?: number,
-        far?: number): PerspectiveCamera;
+    createPerspectiveCamera(descriptor?: PerspectiveCameraDescriptor, scene?: Scene): PerspectiveCamera;
 
     /**
      * Creates a new orthographic camera which is suitable for 2D games, or for UI rendering.

package/src/api/camera/OrthographicCamera.ts

@@ -40,6 +40,9 @@ export class OrthographicCamera implements IOrthographicCamera {
     private _projectionBuffer: IUniformBuffer = null!;
     private _viewBuffer: IUniformBuffer = null!;
     private _projectionViewBuffer: IUniformBuffer = null!;
+    private _positionBuffer: IUniformBuffer = null!;
+    /** std140 vec3 world-space eye, padded to 4 floats. */
+    private readonly _positionData = [0, 0, 0, 0];
 
     /**
      *
@@ -69,7 +72,7 @@ export class OrthographicCamera implements IOrthographicCamera {
         this._near = near;
         this._far = far;
 
-        this._eye = vec3.fromValues(0, 0, -1);
+        this._eye = vec3.fromValues(0, 0, 1);
         this._target = vec3.fromValues(0, 0, 0);
 
         this._zSpaceLength = 2; // For WebGL2 it is 2, WebGPU it is 1.
@@ -204,6 +207,19 @@ export class OrthographicCamera implements IOrthographicCamera {
         return this._viewBuffer;
     }
 
+    /** @inheritDoc */
+    public get positionBuffer(): IUniformBuffer {
+        return this._positionBuffer;
+    }
+
+    /** Writes the world-space eye into the std140 position data (no z flip: the look-at uses the eye as is). */
+    private _updatePositionData(): number[] {
+        this._positionData[0] = this._eye[0];
+        this._positionData[1] = this._eye[1];
+        this._positionData[2] = this._eye[2];
+        return this._positionData;
+    }
+
     /**
      * Updates the camera matrices.
      */
@@ -227,6 +243,10 @@ export class OrthographicCamera implements IOrthographicCamera {
         this._projectionViewBuffer = this._framework.bufferFactory.createUniformBuffer(
             this._projectionViewMatrix, BufferUsage.UNIFORM, "OrthographicCamera.projectionViewBuffer"
         );
+
+        this._positionBuffer = this._framework.bufferFactory.createUniformBuffer(
+            this._updatePositionData(), BufferUsage.UNIFORM, "OrthographicCamera.positionBuffer"
+        );
     }
 
     /** @inheritDoc */
@@ -235,6 +255,7 @@ export class OrthographicCamera implements IOrthographicCamera {
         this.projectionBuffer.update(this.projectionMatrix);
         this.viewBuffer.update(this.viewMatrix);
         this.projectionViewBuffer.update(this.projectionViewMatrix);
+        this.positionBuffer.update(this._updatePositionData());
     }
 
     /** @inheritDoc */
@@ -253,5 +274,6 @@ export class OrthographicCamera implements IOrthographicCamera {
         this.projectionBuffer.dispose();
         this.projectionViewBuffer.dispose();
         this.viewBuffer.dispose();
+        this.positionBuffer.dispose();
     }
 }