bg2e-js 2.1.2 → 2.2.1

package/src/db/VitscnjLoaderPlugin.ts

@@ -0,0 +1,100 @@
+import Resource, { removeFileName, ResourceType } from "../tools/Resource";
+import LoaderPlugin from "./LoaderPlugin";
+import Node from "../scene/Node";
+import { deserializeComponent } from "../scene/Component";
+import Bg2LoaderPlugin from "./Bg2LoaderPlugin";
+import Loader from "./Loader";
+
+interface NodeData {
+    name: string;
+    enabled?: boolean;
+    steady?: boolean;
+    children?: NodeData[];
+    components?: any[];
+}
+
+const deserializeNode = async (nodeData: NodeData, loader: Loader): Promise<Node> => {
+    nodeData.children = nodeData.children || [];
+    nodeData.components = nodeData.components || [];
+
+    const node = new Node(nodeData.name);
+    node.enabled = nodeData.enabled !== undefined ? nodeData.enabled : true;
+    node.steady = nodeData.steady !== undefined ? nodeData.steady : false;
+
+    for (const componentData of nodeData.components) {
+        try {
+            const component = await deserializeComponent(componentData, loader);
+            if (component) {
+                node.addComponent(component);
+            }
+        }
+        catch (err: any) {
+            console.warn(`Deserialization of node with name "${node.name}": ${err.message}`);
+        }
+    }
+
+    for (const childData of nodeData.children) {
+        const child = await deserializeNode(childData, loader);
+        node.addChild(child);
+    }
+
+    return node;
+}
+
+export const DrawableFormat = {
+    LEGACY: 'vwglb',
+    BG2: 'bg2'
+} as const;
+
+export type DrawableFormatValue = typeof DrawableFormat[keyof typeof DrawableFormat];
+
+let g_prefDrawableFormat: DrawableFormatValue = DrawableFormat.BG2;
+export default class VitscnjLoaderPlugin extends LoaderPlugin {
+    private _bg2ioPath: string | null;
+
+    static PreferredDrawableFormat(): DrawableFormatValue {
+        return g_prefDrawableFormat;
+    }
+
+    constructor({ bg2ioPath, preferedDrawableFormat = DrawableFormat.BG2 }: { bg2ioPath: string | null; preferedDrawableFormat?: DrawableFormatValue } = { bg2ioPath: null }) {
+        super();
+
+        this._bg2ioPath = bg2ioPath;
+        g_prefDrawableFormat = preferedDrawableFormat;
+    }
+
+    get supportedExtensions(): string[] { return ["vitscnj"]; }
+
+    get resourceTypes(): ResourceType[] {
+        return [
+            ResourceType.Node
+        ];
+    }
+
+    async load(path: string, resourceType: ResourceType, loader: Loader): Promise<Node> {
+        if (resourceType !== ResourceType.Node) {
+            throw new Error(`VitscnjLoaderPlugin.load() unexpected resource type received: ${resourceType}`);
+        }
+
+        const prevPath = loader.currentPath;
+        loader.currentPath = removeFileName(path);
+
+        const resource = new Resource();
+
+        const root = new Node("Scene Root");
+
+        const { scene } = await resource.load(path);
+        for (const nodeData of scene) {
+            const node = await deserializeNode(nodeData, loader);
+            root.addChild(node);
+        }
+
+        loader.currentPath = prevPath;
+
+        return root;
+    }
+
+    get dependencies(): LoaderPlugin[] {
+        return [new Bg2LoaderPlugin({ bg2ioPath: this._bg2ioPath })];
+    }
+}

package/src/db/Writer.ts

@@ -0,0 +1,52 @@
+import { ResourceType } from '../tools/Resource';
+import { 
+    PluginOperationType,
+    createPluginDatabase, 
+    registerPluginInDatabase, 
+    getPluginFromDatabase 
+} from './DBPluginApi';
+import LoaderPlugin from './LoaderPlugin';
+import PolyList from '../base/PolyList';
+import Texture from '../base/Texture';
+
+const g_writePluginDatabase = createPluginDatabase(PluginOperationType.Write);
+
+export const registerWriterPlugin = (pluginInstance: LoaderPlugin): void => {
+    registerPluginInDatabase(pluginInstance, g_writePluginDatabase);
+}
+
+export const getWriterPlugin = (path: string, type: ResourceType): LoaderPlugin => {
+    return getPluginFromDatabase(path, type, g_writePluginDatabase);
+}
+
+export default class Writer {
+    constructor() {
+
+    }
+
+    async writeResource(path: string, data: any, type: ResourceType): Promise<any> {
+        const plugin = getWriterPlugin(path, type);
+        const result = await plugin.write(path, data, type, this);
+        return result;
+    }
+
+    async writePolyList(path: string, data: PolyList | PolyList[]): Promise<any> {
+        return await this.writeResource(path, data, ResourceType.PolyList);
+    }
+
+    async writeDrawable(path: string, data: any): Promise<any> {
+        return await this.writeResource(path, data, ResourceType.Drawable);
+    }
+
+    async writeNode(path: string, data: any): Promise<any> {
+        return await this.writeResource(path, data, ResourceType.Node);
+    }
+
+    async writeTexture(path: string, data: Texture): Promise<any> {
+        return await this.writeResource(path, data, ResourceType.Texture);
+    }
+
+    async writeMaterial(path: string, data: any): Promise<any> {
+        return await this.writeResource(path, data, ResourceType.Material);
+    }
+}

package/src/db/WriterPlugin.ts

@@ -0,0 +1,22 @@
+import { ResourceType } from "../tools/Resource.js";
+import Writer from "./Writer";
+
+export default class WriterPlugin {
+    // Returns an array of valid file extensions for this plugin
+    //  example: ['obj','dae']
+    get supportedExtensions(): string[] {
+        throw new Error("WriterPlugin.supportedExtensions: attribute not implemented");
+    }
+
+    // Returns the resource types that the loader plugin can handle
+    // example: [ResourceType.PolyList, ResourceType.Drawable]
+    get resourceTypes(): ResourceType[] {
+        throw new Error("WriterPlugin.resourceTypes: attribute not implemented");
+    }
+
+    // Performs the write action to the specified path, using the specified data
+    // and for the specified type.
+    async write(path: string, data: any, type: ResourceType, writer: Writer): Promise<any> {
+        throw new Error("WriterPlugin.write(): method not implemented");
+    }
+}

package/src/db/index.ts

@@ -0,0 +1,44 @@
+
+import Bg2LoaderPlugin from "./Bg2LoaderPlugin";
+import {
+    PluginOperationType,
+    createPluginDatabase,
+    registerPluginInDatabase,
+    getPluginFromDatabase
+} from "./DBPluginApi";
+import Loader, {
+    registerLoaderPlugin,
+    getLoaderPlugin
+} from "./Loader"
+import LoaderPlugin from "./LoaderPlugin";
+import MtlParser from "./MtlParser";
+import ObjLoaderPlugin from "./ObjLoaderPlugin";
+import ObjParser from "./ObjParser";
+import ObjWriterPlugin from "./ObjWriterPlugin";
+import VitscnjLoaderPlugin from "./VitscnjLoaderPlugin";
+import Writer, {
+    registerWriterPlugin,
+    getWriterPlugin
+} from "./Writer"
+import WriterPlugin from "./WriterPlugin";
+
+export default {
+    Bg2LoaderPlugin,
+    PluginOperationType,
+    createPluginDatabase,
+    registerPluginInDatabase,
+    getPluginFromDatabase,
+    Loader,
+    registerLoaderPlugin,
+    getLoaderPlugin,
+    LoaderPlugin,
+    MtlParser,
+    ObjLoaderPlugin,
+    ObjParser,
+    ObjWriterPlugin,
+    VitscnjLoaderPlugin,
+    Writer,
+    registerWriterPlugin,
+    getWriterPlugin,
+    WriterPlugin
+}

package/src/debug/DebugRenderer.ts

@@ -0,0 +1,173 @@
+import Color from "../base/Color";
+import Material from "../base/Material";
+import Mat4 from "../math/Mat4";
+import Vec from "../math/Vec";
+import { createArrow, createSphere } from "../primitives";
+import BasicDiffuseColorShader from "../shaders/BasicDiffuseColorShader";
+import Transform from "../scene/Transform";
+import Texture, { 
+    TextureRenderTargetAttachment, 
+    TextureComponentFormat, 
+    TextureWrap
+} from "../base/Texture";
+import DebugRenderShader from "../shaders/DebugRenderShader";
+import PresentDebugFramebufferShader from "../shaders/PresentDebugFramebufferShader";
+import type Renderer from "../render/Renderer";
+import type PolyListRenderer from "../render/PolyListRenderer";
+import type MaterialRenderer from "../render/MaterialRenderer";
+import type RenderBuffer from "../render/RenderBuffer";
+import type Camera from "../scene/Camera";
+import type PolyList from "../base/PolyList";
+
+interface DebugObject {
+    renderer: PolyListRenderer;
+    scale: number;
+    color: Color;
+    transformMatrix: Mat4;
+}
+
+const g_renderers: Record<string, DebugRenderer> = {};
+
+const getMatrix = (transformMatrix: Mat4 | null, position: Vec | null): Mat4 => {
+    if (!transformMatrix && position) {
+        transformMatrix = Mat4.MakeTranslation(position);
+    }
+    else if (!transformMatrix) {
+        transformMatrix = Mat4.MakeIdentity();
+    }
+    return transformMatrix;
+}
+
+export default class DebugRenderer {
+    private _renderer: Renderer;
+    private _objects: DebugObject[];
+    private _sphere: PolyList;
+    private _sphereRenderer: PolyListRenderer;
+    private _arrow: PolyList;
+    private _arrowRenderer: PolyListRenderer;
+    private _baseMaterial: Material;
+    private _materialRenderer: MaterialRenderer;
+    private _shader!: DebugRenderShader;
+    private _presentShader!: PresentDebugFramebufferShader;
+    private _targetTexture!: Texture;
+    private _renderBuffer!: RenderBuffer;
+
+    static Get(renderer: Renderer): DebugRenderer {
+        if (!g_renderers[renderer.uniqueId]) {
+            g_renderers[renderer.uniqueId] = new DebugRenderer(renderer);
+        }
+        return g_renderers[renderer.uniqueId];
+    }
+
+    constructor(renderer: Renderer) {
+        this._renderer = renderer;
+
+        this._objects = [];
+
+        this._sphere = createSphere(1);
+        this._sphereRenderer = this.renderer.factory.polyList(this._sphere);
+
+        this._arrow = createArrow(1, 0.3);
+        this._arrow.lineWidth = 3;
+        this._arrowRenderer = this.renderer.factory.polyList(this._arrow);
+
+        this._baseMaterial = new Material();
+        this._materialRenderer = this.renderer.factory.material(this._baseMaterial);
+    }
+
+    get renderer(): Renderer { return this._renderer; }
+
+    async init(): Promise<void> {
+        const renderer = this._renderer;
+        
+        this._shader = new DebugRenderShader(renderer);
+        await this._shader.load();
+
+        this._presentShader = new PresentDebugFramebufferShader(renderer);
+        await this._presentShader.load();
+
+        this._targetTexture = new Texture();
+        this._targetTexture.name = `DebugRendererTargetTexture`;
+        this._targetTexture.renderTargetAttachment = TextureRenderTargetAttachment.COLOR_ATTACHMENT_0;
+        this._targetTexture.componentFormat = TextureComponentFormat.UNSIGNED_BYTE;
+        this._targetTexture.wrapModeXY = TextureWrap.CLAMP;
+
+        this._renderBuffer = renderer.factory.renderBuffer();
+        await this._renderBuffer.attachTexture(this._targetTexture);
+    }
+
+    beginFrame(): void {
+        this._objects = [];
+    }
+
+    drawSphere({ radius = 1, color = Color.White(), transformMatrix = null, position = null }: {
+        radius?: number;
+        color?: Color;
+        transformMatrix?: Mat4 | null;
+        position?: Vec | null;
+    } = {}): void {
+        transformMatrix = getMatrix(transformMatrix, position);
+
+        this._objects.push({
+            renderer: this._sphereRenderer,
+            scale: radius,
+            color,
+            transformMatrix
+        });
+    }
+
+    drawArrow({ length = 1, color = Color.White(), transformMatrix = null, position = null }: {
+        length?: number;
+        color?: Color;
+        transformMatrix?: Mat4 | null;
+        position?: Vec | null;
+    } = {}): void {
+        transformMatrix = getMatrix(transformMatrix, position);
+
+        this._objects.push({
+            renderer: this._arrowRenderer,
+            scale: length,
+            color,
+            transformMatrix
+        });
+    }
+
+    setViewportSize(width: number, height: number): void {
+        this._renderBuffer.size = new Vec(width, height);
+    }
+
+    draw(camera: Camera): void {
+        const cameraView = Mat4.GetInverted(Transform.GetWorldMatrix(camera.node));
+        const viewMatrix = cameraView;
+        const projectionMatrix = camera.projectionMatrix;
+        this._renderBuffer.update(() => {
+            this._renderBuffer.frameBuffer.clear();
+
+            this._objects.forEach((object: DebugObject) => {
+                const scale = Mat4.MakeScale(object.scale, object.scale, object.scale);
+                const matrix = scale.mult(object.transformMatrix);
+                this._materialRenderer.material.albedo = object.color;
+    
+                object.renderer.bindBuffers();
+                this._shader.setup(
+                    object.renderer,
+                    this._materialRenderer,
+                    matrix,
+                    viewMatrix,
+                    projectionMatrix
+                );
+                object.renderer.draw();
+            })
+        });
+
+        const shader = this._presentShader;
+        this._renderer.presentTexture(this._targetTexture, { clearBuffers: false, shader });
+    }
+
+    destroy(): void {
+        this._renderBuffer.destroy();
+        this._targetTexture.destroy();
+        this._renderBuffer = null as any;
+        this._targetTexture = null as any;
+    }
+}

package/src/debug/WebGLTextureViewer.ts

@@ -0,0 +1,75 @@
+
+import WebGLRenderer from '../render/webgl/Renderer';
+import type Texture from '../base/Texture';
+
+export default class WebGLTextureViewer {
+    private _renderer: WebGLRenderer;
+    private _size: [number, number];
+    private _canvas: HTMLCanvasElement;
+    private _context: CanvasRenderingContext2D | null;
+
+    constructor(renderer: WebGLRenderer) {
+        if (!(renderer instanceof WebGLRenderer)) {
+            throw new Error("WebGLTextureViewer works only with WebGL Renderer");
+        }
+
+        this._renderer = renderer;
+
+        this._size = [512,512];
+
+        this._canvas = document.createElement('canvas');
+        this._canvas.width = this._size[0];
+        this._canvas.height = this._size[1];
+        this._context = this._canvas.getContext('2d');
+    }
+
+    get canvas(): HTMLCanvasElement { return this._canvas; }
+    get context(): CanvasRenderingContext2D | null { return this._context; }
+
+    attachToElement(element: HTMLElement): void {
+        element.appendChild(this._canvas);
+    }
+
+    drawTexture(texture: Texture): void {
+        const { gl } = this._renderer;
+        const textureWithApi = texture as any;
+
+        if (!textureWithApi._apiObject) {
+            throw new Error("Error drawing WebGL texture: WebGL texture not initialized");
+        }
+
+        this._canvas.width = texture.size.width;
+        this._canvas.height = texture.size.height;
+
+        // Save current state
+        const currentTexture = gl.getParameter(gl.TEXTURE_BINDING_2D);
+        const currentFramebuffer = gl.getParameter(gl.FRAMEBUFFER_BINDING);
+
+        // Draw texture to canvas
+        gl.bindTexture(gl.TEXTURE_2D, textureWithApi._apiObject);
+        
+        // Create a framebuffer to read the texture data
+        const framebuffer = gl.createFramebuffer();
+        gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, textureWithApi._apiObject, 0);
+        
+        // Read texture data
+        let data = new Uint8Array(texture.size.width * texture.size.height * 4);
+        gl.readPixels(0, 0, texture.size[0], texture.size[1], gl.RGBA, gl.UNSIGNED_BYTE, data);
+
+        // Draw texture data to canvas
+        const imageData = new ImageData(new Uint8ClampedArray(data), texture.size.width, texture.size.height);
+        const w = imageData.width, h = imageData.height;
+        const flipped = imageData.data;
+        Array.from({length: h}, (val, i) => data.slice(i * w * 4, (i + 1) * w * 4))
+                .forEach((val, i) => flipped.set(val, (h - i - 1) * w * 4));
+        const ctx = this._context;
+        if (ctx) {
+            ctx.putImageData(imageData, 0, 0);
+        }
+
+        // Restore previous state
+        gl.bindTexture(gl.TEXTURE_2D, currentTexture);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, currentFramebuffer);
+    }
+}

package/src/debug/index.ts

@@ -0,0 +1,7 @@
+import DebugRenderer from "./DebugRenderer.js";
+import WebGLTextureViewer from "./WebGLTextureViewer.js";
+
+export default {
+    DebugRenderer,
+    WebGLTextureViewer
+};

package/src/index.html

@@ -0,0 +1,11 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>bg2e compilation page</title>
+  </head>
+  <body>
+    <script type="module" src="/src/index.js"></script>
+  </body>
+</html>

package/src/index.ts

@@ -0,0 +1,33 @@
+import bg2math from './math/index';
+import Mat3 from './math/Mat3';
+import Mat4 from './math/Mat4';
+import Vec from './math/Vec';
+import Quat from './math/Quat';
+import MatrixStrategy from './math/MatrixStrategy';
+import bg2tools from './tools/index';
+import bgdb from './db/index';
+import bgbase from './base/index';
+import bgscene from './scene/index';
+import bgapp from './app/index';
+import bgrender from './render/index';
+import * as bgprimitives from './primitives/index';
+import bgshaders from './shaders/index';
+import bgdebug from './debug/index';
+
+export const app = bgapp;
+export const base = bgbase;
+export const db = bgdb;
+export const debug = bgdebug;
+export const math = {
+    ...bg2math,
+    Mat3,
+    Mat4,
+    Vec,
+    Quat,
+    MatrixStrategy
+};
+export const render = bgrender;
+export const scene = bgscene;
+export const tools = bg2tools;
+export const primitives = bgprimitives;
+export const shaders = bgshaders;

package/src/manipulation/SelectionBuffer.ts

@@ -0,0 +1,82 @@
+import { RenderLayer } from "../base/PolyList";
+import Texture, { TextureComponentFormat, TextureRenderTargetAttachment, TextureWrap } from "../base/Texture";
+import PickSelectionShader from "../shaders/PickSelectionShader";
+import { FrameVisitor } from "../render/SceneRenderer";
+import RenderQueue from "../render/RenderQueue";
+import Vec from "../math/Vec";
+import Mat4 from "../math/Mat4";
+import Transform from "../scene/Transform";
+import Renderer from "../render/Renderer";
+import RenderBuffer from "../render/RenderBuffer";
+import Camera from "../scene/Camera";
+import Node from "../scene/Node";
+
+export default class SelectionBuffer {
+    protected _renderer: Renderer;
+    protected _targetTexture: Texture | null = null;
+    protected _renderBuffer: RenderBuffer | null = null;
+    protected _shader: PickSelectionShader | null = null
+    protected _renderQueue: RenderQueue | null = null;
+    protected _frameVisitor: FrameVisitor | null = null;
+
+    constructor(renderer: Renderer) {
+        this._renderer = renderer;
+    }
+    
+    async init() {
+        const renderer = this._renderer;
+        this._targetTexture = new Texture();
+        this._targetTexture.renderTargetAttachment = TextureRenderTargetAttachment.COLOR_ATTACHMENT_0;
+        this._targetTexture.componentFormat = TextureComponentFormat.UNSIGNED_BYTE;
+        this._targetTexture.wrapModeXY = TextureWrap.CLAMP;
+
+        this._renderBuffer = renderer.factory.renderBuffer();
+
+        await this._renderBuffer.attachTexture(this._targetTexture);
+
+        this._shader = new PickSelectionShader(renderer);
+        await this._shader.load();
+
+        this._renderQueue = new RenderQueue(renderer);
+        this._renderQueue.enableQueue(RenderLayer.SELECTION_DEFAULT, this._shader);
+
+        this._frameVisitor = new FrameVisitor(this._renderQueue);
+    }
+
+    reshape(width: number, height: number) {
+        if (!this._renderBuffer) {
+            return;
+        }
+        this._renderBuffer.size = new Vec(width,height);
+    }
+
+    draw(scene: Node, camera: Camera, x: number, y: number, width = 1, height = 1) {
+        if (!this._renderQueue || !this._frameVisitor || !this._renderBuffer) {
+            return;
+        }
+        const cameraView = Mat4.GetInverted(Transform.GetWorldMatrix(camera.node));
+        this._renderQueue.viewMatrix = cameraView;
+        this._renderQueue.projectionMatrix = camera.projectionMatrix;
+        this._renderQueue.newFrame();
+        this._frameVisitor.delta = 0;
+        this._frameVisitor.modelMatrix.identity();
+        scene.accept(this._frameVisitor);
+
+        let result = null;
+        this._renderBuffer.update(() => {
+            this._renderBuffer?.frameBuffer.clear();
+            this._renderQueue?.draw(RenderLayer.SELECTION_DEFAULT);
+            result = this._renderBuffer?.readPixels(x, y, width, height);
+        });
+
+        return result;
+    }
+
+    destroy() {
+        this._renderBuffer?.destroy();
+        this._targetTexture?.destroy();
+        this._renderBuffer = null;
+        this._targetTexture = null;
+    }
+}
+

package/src/manipulation/SelectionHighlight.ts

@@ -0,0 +1,85 @@
+
+import { RenderLayer } from "../base/PolyList";
+import Texture, { TextureRenderTargetAttachment, TextureComponentFormat, TextureWrap } from "../base/Texture";
+import Mat4 from "../math/Mat4";
+import Vec from "../math/Vec";
+import RenderQueue from "../render/RenderQueue";
+import { FrameVisitor } from "../render/SceneRenderer";
+import Transform from "../scene/Transform";
+import PickSelectionShader from "../shaders/PickSelectionShader";
+import SelectionHighlightShader from "../shaders/SelectionHighlightShader";
+import Renderer from "../render/Renderer";
+import RenderBuffer from "../render/RenderBuffer";
+import Node from "../scene/Node";
+import Camera from "../scene/Camera";
+
+export default class SelectionHighlight {
+    protected _renderer: Renderer;
+    protected _targetTexture: Texture | null = null
+    protected _renderBuffer: RenderBuffer | null = null;
+    protected _shader: PickSelectionShader | null = null;
+    protected _renderQueue: RenderQueue | null = null
+    protected _frameVisitor: FrameVisitor | null = null;
+    protected _selectionDrawShader: SelectionHighlightShader | null = null;
+
+    constructor(renderer: Renderer) {
+        this._renderer = renderer;
+    }
+
+    async init() {
+        const renderer = this._renderer;
+        this._targetTexture = new Texture();
+        this._targetTexture.renderTargetAttachment = TextureRenderTargetAttachment.COLOR_ATTACHMENT_0;
+        this._targetTexture.componentFormat = TextureComponentFormat.UNSIGNED_BYTE;
+        this._targetTexture.wrapModeXY = TextureWrap.CLAMP;
+
+        this._renderBuffer = renderer.factory.renderBuffer();
+        await this._renderBuffer.attachTexture(this._targetTexture);
+
+        this._shader = new PickSelectionShader(renderer);
+        await this._shader.load();
+        this._shader.forceDraw = false;
+
+        this._renderQueue = new RenderQueue(renderer);
+        this._renderQueue.enableQueue(RenderLayer.SELECTION_DEFAULT, this._shader);
+
+        this._frameVisitor = new FrameVisitor(this._renderQueue);
+
+        this._selectionDrawShader = new SelectionHighlightShader(renderer);
+        await this._selectionDrawShader.load();
+    }
+
+    setViewportSize(width: number, height: number) {
+        this._renderBuffer!.size = new Vec(width,height);
+    }
+
+    draw(scene: Node, camera: Camera) {
+        if (!this._renderQueue || !this._frameVisitor || !this._renderBuffer || !this._targetTexture) {
+            return;
+        }
+
+        const cameraView = Mat4.GetInverted(Transform.GetWorldMatrix(camera.node));
+        this._renderQueue.viewMatrix = cameraView;
+        this._renderQueue.projectionMatrix = camera.projectionMatrix;
+        this._renderQueue.newFrame();
+        this._frameVisitor.delta = 0;
+        this._frameVisitor.modelMatrix.identity();
+        scene.accept(this._frameVisitor);
+
+        this._renderBuffer.update(() => {
+            this._renderBuffer?.frameBuffer.clear();
+            this._renderQueue?.draw(RenderLayer.SELECTION_DEFAULT);
+        });
+
+        // TODO: Draw target texture using a border detection shader
+        const shader = this._selectionDrawShader;
+        this._renderer.presentTexture(this._targetTexture, { clearBuffers: false, shader });
+    }
+
+    destroy() {
+        this._renderBuffer?.destroy();
+        this._targetTexture?.destroy();
+        this._renderBuffer = null;
+        this._targetTexture = null;
+    }
+}