bg2e-js 2.3.11 → 2.3.13

package/src/debug/DebugRenderer.ts

@@ -1,173 +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;
-    }
-}
+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

@@ -1,75 +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);
-    }
-}
+
+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

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

package/src/index.html

@@ -1,11 +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>
+<!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

@@ -1,33 +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;
+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;