bg2e-js 2.0.1 → 2.0.2

package/debug/DebugRenderer.js

@@ -1,138 +0,0 @@
-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";
-
-const g_renderers = {};
-
-const getMatrix = (transformMatrix, position) => {
-    if (!transformMatrix && position) {
-        transformMatrix = Mat4.MakeTranslation(position);
-    }
-    else if (!transformMatrix) {
-        transformMatrix = Mat4.MakeIdentity();
-    }
-    return transformMatrix;
-}
-
-export default class DebugRenderer {
-
-    static Get(renderer) {
-        if (!g_renderers[renderer.uniqueId]) {
-            g_renderers[renderer.uniqueId] = new DebugRenderer(renderer);
-        }
-        return g_renderers[renderer.uniqueId];
-    }
-
-    constructor(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() { return this._renderer; }
-
-    async init() {
-        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() {
-        this._objects = [];
-    }
-
-    drawSphere({ radius = 1, color = Color.White(), transformMatrix = null, position = null } = {}) {
-        transformMatrix = getMatrix(transformMatrix, position);
-
-        this._objects.push({
-            renderer: this._sphereRenderer,
-            scale: radius,
-            color,
-            transformMatrix
-        });
-    }
-
-    drawArrow({ length = 1, color = Color.White(), transformMatrix = null, position = null } = {}) {
-        transformMatrix = getMatrix(transformMatrix, position);
-
-        this._objects.push({
-            renderer: this._arrowRenderer,
-            scale: length,
-            color,
-            transformMatrix
-        });
-    }
-
-    setViewportSize(width, height) {
-        this._renderBuffer.size = new Vec(width, height);
-    }
-
-    draw(camera) {
-        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 => {
-                const scale = Mat4.MakeScale(object.scale, object.scale, object.scale);
-                const matrix = scale.mult(object.transformMatrix);
-                this._materialRenderer.material.diffuse = 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 });
-    }
-
-    destoy() {
-        this._renderBuffer.destroy();
-        this._targetTexture.destroy();
-        this._renderBuffer = null;
-        this._targetTexture = null;
-    }
-}

package/debug/WebGLTextureViewer.js

@@ -1,67 +0,0 @@
-
-import WebGLRenderer from '../render/webgl/Renderer';
-
-export default class WebGLTextureViewer {
-
-    constructor(renderer) {
-        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() { return this._canvas; }
-    get context() { return this._context; }
-
-    attachToElement(element) {
-        element.appendChild(this._canvas);
-    }
-
-    drawTexture(texture) {
-        const { gl } = this._renderer;
-
-        if (!texture._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, texture._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, texture._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;
-        ctx.putImageData(imageData, 0, 0);
-
-        // Restore previous state
-        gl.bindTexture(gl.TEXTURE_2D, currentTexture);
-        gl.bindFramebuffer(gl.FRAMEBUFFER, currentFramebuffer);
-    }
-}

package/manipulation/SelectionBuffer.js

@@ -1,65 +0,0 @@
-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";
-
-export default class SelectionBuffer {
-    constructor(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,height) {
-        this._renderBuffer.size = new Vec(width,height);
-    }
-
-    draw(scene,camera,x,y,width = 1,height = 1) {
-        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/manipulation/SelectionHighlight.js

@@ -1,69 +0,0 @@
-
-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";
-
-export default class SelectionHighlight {
-    constructor(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,height) {
-        this._renderBuffer.size = new Vec(width,height);
-    }
-
-    draw(scene,camera) {
-        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;
-    }
-}

package/manipulation/SelectionIdAssignVisitor.js

@@ -1,86 +0,0 @@
-import NodeVisitor from "../scene/NodeVisitor";
-import SelectionMode from "./SelectionMode";
-import Color from "../base/Color";
-
-const getColor = (comps) => "" + comps[0] + comps[1] + comps[2];
-
-export default class SelectionAssignVisitor extends NodeVisitor {
-    constructor() {
-        super();
-
-        this._selectionMode = SelectionMode.POLY_LIST;
-        this._elements = {};
-    }
-
-    set selectionMode(mode) {
-        this._selectionMode = mode;
-        this.clear();
-    }
-
-    get selectionMode() {
-        return this._selectionMode;
-    }
-
-    clear() {
-        this._r = 0;
-        this._g = 0;
-        this._b = 0;
-        this._elements = {};
-    }
-
-    getNextColor() {
-        const getId = () => {
-            return [ Math.round(Math.random()*255),
-                     Math.round(Math.random()*255),
-                     Math.round(Math.random()*255)];
-        }
-        
-        let components = getId();
-        let color = getColor(components);
-        while (this._elements[color]) {
-            components = getId();
-            color = getColor(components);
-        }
-
-        this._r = components[0];
-        this._g = components[1];
-        this._b = components[2];
-
-        return new Color([components[0]/255, components[1]/255, components[2]/255, 1]);
-    }
-
-    findElement(pickedColor) {
-        const color = [
-            pickedColor[0],
-            pickedColor[1],
-            pickedColor[2]
-        ];
-        return this._elements[getColor(color)];
-    }
-
-    visit(node) {
-        const { drawable } = node;
-        if (drawable) {
-            let color = this.getNextColor();
-            drawable.items.forEach(({polyList}, i, array) => {
-                if (polyList.isSelectable) {
-                    polyList.colorCode = color;
-                    polyList.selected = false;
-                    const colorCode = getColor([
-                        Math.round(color[0] * 255),
-                        Math.round(color[1] * 255),
-                        Math.round(color[2] * 255)
-                    ]);
-                    this._elements[colorCode] = { polyList, drawable };
-                }
-
-                // Get new color code for the next polyList, only if this is not the
-                // last item, and the selection mode is POLY_LIST, otherwise we'll
-                // use the same color code for all polyList in the drawable
-                if (i<array.length-1 && this._selectionMode == SelectionMode.POLY_LIST) {
-                    color = this.getNextColor();
-                }
-            });
-        }
-    }
-}

package/manipulation/SelectionManager.js

@@ -1,134 +0,0 @@
-import Vec from "../math/Vec";
-import SelectionBuffer from "./SelectionBuffer";
-import Camera from "../scene/Camera";
-import SelectionIdAssignVisitor from "./SelectionIdAssignVisitor";
-import SelectionMode from "./SelectionMode";
-
-export default class SelectionManager {
-    constructor(renderer) {
-        this._renderer = renderer;
-        this._sceneRoot = null;
-        this._camera = null;
-        this._selectionMode = SelectionMode.POLY_LIST;
-        this._multiSelect = false;
-
-        this._selection = [];
-
-        this._selectionChangedCallbacks = {}
-    }
-
-    async init() {
-        this._selectionBuffer = new SelectionBuffer(this._renderer);
-        await this._selectionBuffer.init();
-
-        this._selectionIdVisitor = new SelectionIdAssignVisitor();
-    }
-
-    setViewportSize(w,h) {
-        this._viewportSize = [w, h];
-    }
-
-    get selection() {
-        return this._selection;
-    }
-
-    clearSelection() {
-        this._selection = [];
-    }
-
-    set sceneRoot(root) {
-        this._sceneRoot = root;
-        this.clearSelection();
-    }
-
-    get sceneRoot() {
-        return this._sceneRoot;
-    }
-
-    set camera(cam) {
-        this._camera = cam;
-        this.clearSelection();
-    }
-
-    get camera() {
-        if (this._camera) {
-            return this._camera;
-        }
-
-        this._camera = Camera.GetMain(this.sceneRoot);
-        return this._camera;
-    }
-
-    set selectionMode(mode) {
-        this._selectionMode = mode;
-        this.clearSelection();
-    }
-
-    get selectionMode() {
-        return this._selectionMode;
-    }
-
-    set multiSelectMode(mode) {
-        this._multiSelect = mode;
-        this.clearSelection();
-    }
-
-    get multiSelectMode() {
-        return this._multiSelect;
-    }
-
-    onSelectionChanged(id, cb) {
-        this._selectionChangedCallbacks[id] = cb;
-    }
-
-    triggerSelectionChanged() {
-        for (const key in this._selectionChangedCallbacks) {
-            this._selectionChangedCallbacks[key](this._selection);
-        }
-    }
-
-    mouseUp(evt) {
-        const upPosition = new Vec([evt.x, evt.y]);
-        if (Vec.Distance(this._downPosition, upPosition) < 2) {
-            this._selectionIdVisitor.selectionMode = this.selectionMode;
-            this.sceneRoot.accept(this._selectionIdVisitor);
-            
-            this._selectionBuffer.reshape(this._viewportSize[0], this._viewportSize[1]);
-            const pickedColor = this._selectionBuffer.draw(this.sceneRoot, this.camera, evt.x, evt.y);
-            const item = this._selectionIdVisitor.findElement(pickedColor);
-            const isSelected = () => this._selection.find(s => {
-                return s.polyList === item.polyList && s.drawable === item.drawable
-            });
-            if (item && this._multiSelect && !isSelected()) {
-                this._selection.push(item);
-                this.triggerSelectionChanged();
-            }
-            else if (item && !isSelected()) {
-                this._selection = [item];
-                this.triggerSelectionChanged();
-            }
-            else if (!item && !this._multiSelect && this._selection.length > 0) {
-                this._selection = [];
-                this.triggerSelectionChanged();
-            }
-
-            this._selection.forEach(item => item.polyList.selected = true);
-        }
-    }
-
-    mouseDown(evt) {
-        this._downPosition = new Vec([evt.x, evt.y]);
-    }
-
-    touchStart(evt) {
-
-    }
-
-    touchEnd(evt) {
-
-    }
-
-    destroy() {
-        this._selectionBuffer.destroy();
-    }
-}

package/manipulation/SelectionMode.js

@@ -1,6 +0,0 @@
-const SelectionMode = Object.freeze({
-    OBJECT: 0,
-    POLY_LIST: 1
-});
-
-export default SelectionMode;