bg2e-js 2.0.1 → 2.0.2

package/render/SceneAppController.js

@@ -1,208 +0,0 @@
-import AppController from "../app/AppController";
-import SelectionHighlight from "../manipulation/SelectionHighlight";
-import SelectionManager from "../manipulation/SelectionManager";
-import { registerComponents } from "../scene";
-import Camera from "../scene/Camera";
-import DebugRenderer from "../debug/DebugRenderer";
-import Vec from "../math/Vec";
-
-export default class SceneAppController extends AppController {
-    get sceneRoot() {
-        return this._sceneRoot;
-    }
-
-    get sceneRenderer() {
-        return this._sceneRenderer;
-    }
-
-    get environment() {
-        return this._environment;
-    }
-
-    get selectionManager() {
-        return this._selectionManager;
-    }
-
-    get selectionHighlight() {
-        return this._selectionHighlight;
-    }
-
-    get selectionManagerEnabled() {
-        return true;
-    }
-
-    get selectionHighlightEnabled() {
-        return true;
-    }
-
-    get updateOnInputEvents() {
-        return this._updateOnInputEvents ?? true;
-    }
-
-    set updateOnInputEvents(update) {
-        this._updateOnInputEvents = update;
-    }
-
-    async loadScene() {
-        return new Node("Scene Root");
-    }
-
-    async loadEnvironment() {
-        return null;
-    }
-
-    async registerLoaders() {
-
-    }
-
-    async loadDone() {
-
-    }
-
-    async init() {
-        registerComponents();
-
-        await this.registerLoaders();
-
-        this._sceneRoot = await this.loadScene();
-
-        this._environment = await this.loadEnvironment();
-
-        if (!this._environment) {
-            this._environment = this.renderer.factory.environment();
-            await this._environment.load();   // Load black environment
-        }
-
-        this._sceneRenderer = this.renderer.factory.scene();
-        await this.sceneRenderer.init({ shadowMapSize: new Vec(4096, 4096) });
-        if (this.environment) {
-            await this.sceneRenderer.setEnvironment(this.environment);
-        }
-
-        await this.sceneRenderer.bindRenderer(this.sceneRoot);
-
-        if (this.selectionManagerEnabled) {
-            this._selectionManager = new SelectionManager(this.renderer);
-            await this._selectionManager.init();
-            this._selectionManager.sceneRoot = this.sceneRoot;
-        }
-
-        if (this.selectionHighlightEnabled) {
-            this._selectionHighlight = new SelectionHighlight(this.renderer);
-            await this._selectionHighlight.init();
-        }
-
-        this._debugRenderer = DebugRenderer.Get(this.renderer);
-        await this._debugRenderer.init();
-
-        await this.loadDone();
-    }
-
-    reshape(width,height) {
-        this.sceneRenderer.resize(this.sceneRoot,width,height);
-        this.selectionManager?.setViewportSize(width,height);
-        this.selectionHighlight?.setViewportSize(width,height);
-        this._debugRenderer.setViewportSize(width,height);
-    }
-
-    async frame(delta) {
-        this._debugRenderer.beginFrame();
-
-        await this.sceneRenderer.frame(this.sceneRoot, delta);
-    }
-
-    display() {
-        this.sceneRenderer.draw();
-        const camera = Camera.GetMain(this.sceneRoot);
-        this.selectionHighlight && this.selectionHighlight.draw(this.sceneRoot, camera);
-        this._debugRenderer.draw(camera);
-    }
-
-    destroy() {
-        this.sceneRenderer.destroy();
-        if (this.selectionManagerEnabled) {
-            this.selectionManager.destroy();
-        }
-    }
-
-    keyDown(evt) {
-        this.sceneRenderer.keyDown(this.sceneRoot,evt);
-        if (this.updateOnInputEvents) {
-            this.mainLoop.postRedisplay();
-        }
-    }
-
-    keyUp(evt) {
-        this.sceneRenderer.keyUp(this.sceneRoot,evt);
-        if (this.updateOnInputEvents) {
-            this.mainLoop.postRedisplay();
-        }
-    }
-
-    mouseUp(evt) {
-        this.sceneRenderer.mouseUp(this.sceneRoot,evt);
-        this.selectionManager?.mouseUp(evt);
-        if (this.updateOnInputEvents) {
-            this.mainLoop.postRedisplay();
-        }
-    }
-
-    mouseDown(evt) {
-        this.sceneRenderer.mouseDown(this.sceneRoot,evt);
-        this.selectionManager?.mouseDown(evt);
-        if (this.updateOnInputEvents) {
-            this.mainLoop.postRedisplay();
-        }
-    }
-
-    mouseMove(evt) {
-        this.sceneRenderer.mouseMove(this.sceneRoot,evt);
-        if (this.updateOnInputEvents) {
-            this.mainLoop.postRedisplay();
-        }
-    }
-
-    mouseOut(evt) {
-        this.sceneRenderer.mouseOut(this.sceneRoot,evt);
-        if (this.updateOnInputEvents) {
-            this.mainLoop.postRedisplay();
-        }
-    }
-
-    mouseDrag(evt) {
-        this.sceneRenderer.mouseDrag(this.sceneRoot,evt);
-        if (this.updateOnInputEvents) {
-            this.mainLoop.postRedisplay();
-        }
-    }
-
-    mouseWheel(evt) {
-        this.sceneRenderer.mouseWheel(this.sceneRoot,evt);
-        if (this.updateOnInputEvents) {
-            this.mainLoop.postRedisplay();
-        }
-    }
-
-    touchStart(evt) {
-        this.sceneRenderer.touchStart(this.sceneRoot,evt);
-        this.selectionManager?.touchStart(evt);
-        if (this.updateOnInputEvents) {
-            this.mainLoop.postRedisplay();
-        }
-    }
-
-    touchMove(evt) {
-        this.sceneRenderer.touchMove(this.sceneRoot,evt);
-        if (this.updateOnInputEvents) {
-            this.mainLoop.postRedisplay();
-        }
-    }
-
-    touchEnd(evt) {
-        this.sceneRenderer.touchEnd(this.sceneRoot,evt);
-        this.selectionManager?.touchEnd(evt);
-        if (this.updateOnInputEvents) {
-            this.mainLoop.postRedisplay();
-        }
-    }   
-}

package/render/SceneRenderer.js

@@ -1,310 +0,0 @@
-import { RenderLayer } from "../base/PolyList";
-import { BlendFunction } from "./Pipeline";
-import RenderQueue from "./RenderQueue";
-import NodeVisitor from "../scene/NodeVisitor";
-import Mat4 from "../math/Mat4";
-import Vec from "../math/Vec";
-import Camera from "../scene/Camera";
-import FindNodeVisitor from "../scene/FindNodeVisitor";
-import Transform from "../scene/Transform";
-import { bindRenderer, init } from "../scene/Node";
-import LightComponent from "../scene/LightComponent";
-
-export class FrameVisitor extends NodeVisitor {
-    constructor(renderQueue) {
-        super();
-        this._renderQueue = renderQueue;
-        this._delta = 0;
-        this._modelMatrix = Mat4.MakeIdentity();
-        this._matrixStack = [];
-    }
-
-    get delta() { return this._delta; }
-    set delta(d) { this._delta = d; }
-
-    get modelMatrix() { return this._modelMatrix; }
-    
-    visit(node) {
-        this._matrixStack.push(new Mat4(this._modelMatrix));
-        node.frame(this._delta, this._modelMatrix, this._renderQueue);
-    }
-
-    didVisit(node) {
-        this._modelMatrix = this._matrixStack[this._matrixStack.length - 1] || Mat4.MakeIdentity();
-        this._matrixStack.pop();
-    }
-}
-
-export class BindRendererVisitor extends NodeVisitor {
-    constructor(renderer) {
-        super(renderer);
-        this._renderer = renderer;
-    }
-
-    visit(node) {
-        bindRenderer(node, this._renderer);
-    }
-}
-
-export class InitVisitor extends NodeVisitor {
-    constructor() {
-        super();
-    }
-
-    async asyncVisit(node) {
-        await init(node);
-    }
-}
-
-export class EventCallbackVisitor extends NodeVisitor {
-    constructor(callbackName)  {
-        super();
-        this._callbackName = callbackName;
-        this._event = null;
-    }
-
-    set event(evt) {
-        this._event = evt;
-    }
-
-    get event() {
-        return this._event;
-    }
-
-    visit(node) {
-        node[this._callbackName](this._event);
-    }
-}
-
-export default class SceneRenderer {
-    constructor(renderer) {
-        this._renderer = renderer;
-        this._keyDownVisitor = new EventCallbackVisitor('keyDown');
-        this._keyUpVisitor = new EventCallbackVisitor('keyUp');
-        this._mouseUpVisitor = new EventCallbackVisitor('mouseUp');
-        this._mouseDownVisitor = new EventCallbackVisitor('mouseDown');
-        this._mouseMoveVisitor = new EventCallbackVisitor('mouseMove');
-        this._mouseOutVisitor = new EventCallbackVisitor('mouseOut');
-        this._mouseDragVisitor = new EventCallbackVisitor('mouseDrag');
-        this._mouseWheelVisitor = new EventCallbackVisitor('mouseWheel');
-        this._touchStartVisitor = new EventCallbackVisitor('touchStart');
-        this._touchMoveVisitor = new EventCallbackVisitor('touchMove');
-        this._touchEndVisitor = new EventCallbackVisitor('touchEnd');
-
-        // This will be the EnvironmentComponent component, if one is defined in the scene.
-        this._sceneEnvironment = null;
-    }
-
-    get renderer() {
-        return this._renderer;
-    }
-
-    get renderQueue() {
-        return this._renderQueue;
-    }
-
-    async init({ shadowMapSize = new Vec(1024, 1024) } = {}) {
-        if (typeof(shadowMapSize) === "number") {
-            shadowMapSize = new Vec(shadowMapSize, shadowMapSize);
-        }
-
-        // TODO: Create function to resize shadow map
-        this._shadowMapSize = shadowMapSize;
-
-        this._mainDirectionalLight = null;
-
-        this._opaquePipeline = this.renderer.factory.pipeline();
-        this._opaquePipeline.setBlendState({ enabled: false });
-        this._opaquePipeline.create();
-
-        this._transparentPipeline = this.renderer.factory.pipeline();
-        this._transparentPipeline.setBlendState({
-            enabled: true,
-            blendFuncSrc: BlendFunction.SRC_ALPHA,
-            blendFuncDst: BlendFunction.ONE_MINUS_SRC_ALPHA,
-            blendFuncSrcAlpha: BlendFunction.ONE,
-            blendFuncDstAlpha: BlendFunction.ONE_MINUS_SRC_ALPHA
-        });
-        this._transparentPipeline.create();
-
-        this._renderQueue = new RenderQueue(this.renderer);
-        this._initVisitor = new InitVisitor();
-        this._frameVisitor = new FrameVisitor(this._renderQueue);
-
-        this._skyCube = this.renderer.factory.skyCube();
-
-        this._shadowRenderer = this.renderer.factory.shadowRenderer();
-        await this._shadowRenderer.create(this._shadowMapSize);
-    }
-
-    async setEnvironment(env) {
-        this._environment = env;
-        this._skyCube.load(this._environment.environmentMap);
-    }
-
-    get environment() {
-        return this._environment;
-    }
-
-    get defaultViewMatrix() {
-        return this._defaultViewMatrix || Mat4.MakeIdentity();
-    }
-
-    set defaultViewMatrix(mat) {
-        this._defaultViewMatrix = mat;
-    }
-
-    get defaultProjectionMatrix() {
-        return this._defaultProjectionMatrix || Mat4.MakePerspective(55,this.renderer.viewport.aspectRatio, 0.2, 100.0);
-    }
-
-    set defaultProjectionMatrix(mat) {
-        this._defaultProjectionMatrix = mat;
-    }
-    
-    async bindRenderer(sceneRoot) {
-        const bindRendererVisitor = new BindRendererVisitor(this.renderer);
-        sceneRoot.accept(bindRendererVisitor);
-
-        await sceneRoot.asyncAccept(this._initVisitor);        
-
-        const findVisitor = new FindNodeVisitor();
-        findVisitor.hasComponents("Environment");
-        sceneRoot.accept(findVisitor);
-        if (findVisitor.result.length) {
-            const comp = findVisitor.result[0].component("Environment");
-            this.setEnvironment(comp.environment);
-            this._sceneEnvironment = comp;
-        }
-    }
-
-    resize(sceneRoot, width,height) {
-        this.renderer.viewport = new Vec([0, 0, width, height]);
-        this.renderer.canvas.updateViewportSize();
-        const mainCamera = Camera.GetMain(sceneRoot);
-        if (mainCamera) {
-            mainCamera.resize(width,height);
-        }
-    }
-
-    async frame(sceneRoot,delta) {
-        if (sceneRoot.sceneChanged) {
-            await sceneRoot.asyncAccept(this._initVisitor);
-        }
-        this._sceneRoot = sceneRoot;
-
-        this._renderQueue.newFrame();
-        this._frameVisitor.delta = delta;
-        this._frameVisitor.modelMatrix.identity();
-
-        const mainCamera = Camera.GetMain(sceneRoot);
-
-        let viewMatrix = this.defaultViewMatrix;
-        let projectionMatrix = this.defaultProjectionMatrix;
-        if (mainCamera) {
-            projectionMatrix = mainCamera.projectionMatrix;
-            viewMatrix = Mat4.GetInverted(Transform.GetWorldMatrix(mainCamera.node));
-        }
-
-        this._renderQueue.viewMatrix = viewMatrix;
-        this._renderQueue.projectionMatrix = projectionMatrix;
-
-        sceneRoot.accept(this._frameVisitor);
-
-        this._skyCube.updateRenderState({
-            viewMatrix: viewMatrix,
-            projectionMatrix: projectionMatrix
-        });
-    }
-
-    draw({ clearBuffers = true, drawSky = true } = {}) {
-        const mainLight = LightComponent.GetMainDirectionalLight(this._sceneRoot);
-        const camera = Camera.GetMain(this._sceneRoot);
-
-        // Update the light projection based on the camera focus distance, to optimize
-        // the shadow map size
-        if (mainLight && camera) {
-            const focus = camera.focusDistance;
-            const lightProjection = Mat4.MakeOrtho(-focus,focus,-focus,focus,0.1,500.0);
-            mainLight.light.projection = lightProjection;
-        }
-        if (mainLight) {
-            this._shadowRenderer.update(camera, mainLight, this._renderQueue);
-        }
-        
-        if (clearBuffers) {
-            this.renderer.frameBuffer.clear();
-        }
-
-        if (this.environment && !this.environment.updated) {
-            this.environment.updateMaps();
-        }
-
-        if (drawSky && (!this._sceneEnvironment || this._sceneEnvironment.showSkybox)) {
-            this._skyCube.draw();
-        }
-
-        this._renderQueue.draw(RenderLayer.OPAQUE_DEFAULT);
-        this._renderQueue.draw(RenderLayer.TRANSPARENT_DEFAULT);
-    }
-
-    destroy() {
-
-    }
-
-    keyDown(sceneRoot, evt) {
-        this._keyDownVisitor.event = evt;
-        sceneRoot.accept(this._keyDownVisitor);
-    }
-
-    keyUp(sceneRoot, evt) {
-        this._keyUpVisitor.event = evt;
-        sceneRoot.accept(this._keyUpVisitor);
-    }
-
-    mouseUp(sceneRoot, evt) {
-        this._mouseUpVisitor.event = evt;
-        sceneRoot.accept(this._mouseUpVisitor);
-    }
-
-    mouseDown(sceneRoot, evt) {
-        this._mouseDownVisitor.event = evt;
-        sceneRoot.accept(this._mouseDownVisitor);
-    }
-
-    mouseMove(sceneRoot, evt) {
-        this._mouseMoveVisitor.event = evt;
-        sceneRoot.accept(this._mouseMoveVisitor);
-    }
-
-    mouseOut(sceneRoot, evt) {
-        this._mouseOutVisitor.event = evt;
-        sceneRoot.accept(this._mouseOutVisitor);
-    }
-
-    mouseDrag(sceneRoot, evt) {
-        this._mouseDragVisitor.event = evt;
-        sceneRoot.accept(this._mouseDragVisitor);
-    }
-
-    mouseWheel(sceneRoot, evt) {
-        this._mouseWheelVisitor.event = evt;
-        sceneRoot.accept(this._mouseWheelVisitor);
-    }
-
-    touchStart(sceneRoot, evt) {
-        this._touchStartVisitor.event = evt;
-        sceneRoot.accept(this._touchStartVisitor);
-    }
-
-    touchMove(sceneRoot, evt) {
-        this._touchMoveVisitor.event = evt;
-        sceneRoot.accept(this._touchMoveVisitor);
-    }
-
-    touchEnd(sceneRoot, evt) {
-        this._touchEndVisitor.event = evt;
-        sceneRoot.accept(this._touchEndVisitor);
-    }
-
-}

package/render/Shader.js

@@ -1,21 +0,0 @@
-import Material from "../base/Material";
-
-export default class Shader {
-    constructor(renderer) {
-        this._renderer = renderer;
-    }
-
-    get renderer() { return this._renderer; }
-
-    async load() {
-
-    }
-    
-    setup(plistRenderer, materialRenderer, modelMatrix, viewMatrix, projectionMatrix) {
-        throw new Error("Error: using an abstract implementation of render.Shader.");
-    }
-
-    destroy() {
-        throw new Error("Error: using an abstract implementation of render.Shader.destroy()");
-    }
-}

package/render/ShadowRenderer.js

@@ -1,159 +0,0 @@
-import { RenderLayer } from "../base/PolyList";
-import Texture, {
-    TextureComponentFormat,
-    TextureRenderTargetAttachment,
-    TextureWrap
-} from "../base/Texture";
-import Mat4 from "../math/Mat4";
-import Vec from "../math/Vec";
-import Color from "../base/Color";
-import Camera from "../scene/Camera";
-import LightComponent from "../scene/LightComponent";
-import Transform from "../scene/Transform";
-import DebugRenderer from "../debug/DebugRenderer";
-import DepthRenderShader from "../shaders/DepthRenderShader";
-
-
-export default class ShadowRenderer {
-    constructor(renderer) {
-        this._renderer = renderer;
-        this._shadowMapRenderDistance = 100;
-        this._debug = false;
-    }
-
-    get renderer() { return this._renderer; }
-
-    get size() {
-        return this._size;
-    }
-
-    get shadowMapRenderDistance() {
-        return this._shadowMapRenderDistance;
-    }
-
-    get debug() {
-        return this._debug;
-    }
-
-    set debug(d) {
-        this._debug = d;
-    }
-
-    set shadowMapRenderDistance(d) {
-        this._shadowMapRenderDistance = d;
-    }
-
-    // TODO: set size. Update the shadow map size
-
-    get depthTexture() {
-        return this._depthTexture;
-    }
-
-    async create(size = new Vec(1024, 1024)) {
-        this._size = size;
-
-        this._texture = new Texture();
-        this._texture.name = `ShadowMap_${ size.width }x${ size.height }`;
-        this._texture.renderTargetAttachment = TextureRenderTargetAttachment.COLOR_ATTACHMENT_0;
-        this._texture.componentFormat = TextureComponentFormat.UNSIGNED_BYTE;
-        this._texture.wrapModeXY = TextureWrap.CLAMP;
-
-        this._renderBuffer = this.renderer.factory.renderBuffer();
-
-        await this._renderBuffer.attachTexture(this._texture);
-
-        this._depthTexture = new Texture();
-        this._depthTexture.name = `ShadowMapDepth_${ size.width }x${ size.height }`;
-        this._depthTexture.renderTargetAttachment = TextureRenderTargetAttachment.DEPTH_ATTACHMENT;
-        this._depthTexture.componentFormat = TextureComponentFormat.UNSIGNED_BYTE;
-        this._depthTexture.wrapModeXY = TextureWrap.CLAMP;
-        await this._renderBuffer.attachTexture(this._depthTexture);
-
-        this._renderBuffer.size = this._size;
-
-        this._shader = new DepthRenderShader(this.renderer);
-        await this._shader.load();
-    }
-
-    getLightTransform(camera, light) {
-        let cameraNode = null;
-        if (camera instanceof Camera) {
-            cameraNode = camera.node;
-        }
-        else if (camera instanceof Node) {
-            cameraNode = camera;
-            camera = cameraNode.camera;
-        }
-
-        if (!cameraNode || !camera) {
-            throw Error(`ShadowRenderer.getLightPosition(): invalid camera parameter. Camera must be a Node or a Camera component, and the camera must be added to the scene.`);
-        }
-
-        let lightNode = null;
-        if (light instanceof LightComponent) {
-            lightNode = light.node;
-        }
-        else if (light instanceof Node) {
-            lightNode = light;
-            light = light.lightComponent;
-        }
-
-        if (!lightNode || !light) {
-            throw Error(`ShadowRenderer.getLightPosition(): invalid light. Light must be a Node or a LightComponent`);
-        }
-
-        // Get the camera focus point
-        const focus = camera.focusDistance;
-        const cameraTransform = Transform.GetWorldMatrix(cameraNode);
-        const cameraPos = Vec.Add(Mat4.GetPosition(cameraTransform), Vec.Mult(cameraTransform.forwardVector, -focus)); 
-
-        // Get the light rotation vector and scale it to the light shadow map render distance
-        const lightTransform = Transform.GetWorldMatrix(lightNode);
-        const lightVector = Mat4.GetRotation(lightTransform).forwardVector;
-        lightVector.scale(this._shadowMapRenderDistance);
-
-        // Get the light render position, adding the camera focus point to the light vector
-        const lightPos = Vec.Add(cameraPos, lightVector);
-
-        // Set the light render position to the light transform matrix
-        lightTransform.setPosition(lightPos);
-
-        if (this._debug) {
-            DebugRenderer.Get(this._renderer).drawSphere({ radius: 0.1, color: Color.Red(), position: cameraPos });
-            DebugRenderer.Get(this.renderer).drawSphere({ radius: 0.1, color: Color.Blue(), position: lightPos });
-            DebugRenderer.Get(this.renderer).drawArrow({ length: 0.8, color: Color.Green(), transformMatrix: lightTransform });
-        }
-
-        return lightTransform;
-    }
-
-    update(camera, lightComponent, renderQueue) {  
-        const viewMatrix = Mat4.GetInverted(this.getLightTransform(camera, lightComponent));
-        
-        this._renderBuffer.update(() => {
-            this._renderBuffer.renderer.state.clear();
-            const layer = RenderLayer.OPAQUE_DEFAULT;
-            const queue = renderQueue.getQueue(layer);
-            if (queue) {
-
-                if (typeof(queue.beginOperation) === "function") {
-                    queue.beginOperation(layer);
-                }
-                queue.queue.forEach(rs => {
-                    rs.draw({
-                        overrideShader: this._shader,
-                        overrideViewMatrix: viewMatrix,
-                        overrideProjectionMatrix: lightComponent.light.projection
-                    });
-                });
-                if (typeof(queue.endOperation) === "function") {
-                    queue.endOperation(layer);
-                }
-            }
-        });
-
-        // Set the depthTexture to the light component. If the shader needs the depth texture, it will use it
-        lightComponent.depthTexture = this._depthTexture;
-        lightComponent.viewMatrix = viewMatrix;
-    }
-}