bg2e-js 2.1.1 → 2.2.0

package/src/scene/LightComponent.ts

@@ -0,0 +1,155 @@
+import Component from "./Component";
+import Light, { LightType } from "../base/Light";
+import FindNodeVisitor from "./FindNodeVisitor";
+import Node from "./Node";
+
+
+export default class LightComponent extends Component {
+    static GetLights(sceneRoot: Node): LightComponent[] {
+        if (sceneRoot.sceneChanged || !(sceneRoot as any).__lights) {
+            (sceneRoot as any).__lights = [];
+            let findLights = new FindNodeVisitor();
+            findLights.hasComponents(["Light"]);
+            sceneRoot.accept(findLights);
+            (sceneRoot as any).__lights = findLights.result.map(n => n.lightComponent);
+        }
+        return (sceneRoot as any).__lights;
+    }
+
+    static GetFirstShadowCastingLight(sceneRoot: Node): LightComponent | undefined {
+        if (sceneRoot.sceneChanged || !(sceneRoot as any).__mainDirectionalLight) {
+            (sceneRoot as any).__mainDirectionalLight = LightComponent.GetLights(sceneRoot)
+                .find(l => l.light.type === LightType.DIRECTIONAL || l.light.type === LightType.SPOT);
+        }
+        return (sceneRoot as any).__mainDirectionalLight;
+    }
+
+    static GetMainDirectionalLight(sceneRoot: Node): LightComponent | undefined {
+        if (sceneRoot.sceneChanged || !(sceneRoot as any).__mainDirectionalLight) {
+            (sceneRoot as any).__mainDirectionalLight = LightComponent.GetLights(sceneRoot)
+                .find(l => l.light.type === LightType.DIRECTIONAL);
+        }
+        return (sceneRoot as any).__mainDirectionalLight || LightComponent.GetFirstShadowCastingLight(sceneRoot);
+    }
+
+    _light: Light;
+
+    constructor(light: Light | null = null) {
+        super("Light");
+
+        this._light = light || new Light();
+    }
+
+    get light(): Light { return this._light; }
+    set light(l: Light) { this._light = l; }
+
+    set depthTexture(t: any) {
+        this._light.depthTexture = t;
+    }
+
+    get depthTexture(): any {
+        return this._light.depthTexture;
+    }
+
+    set viewMatrix(vm: any) {
+        this._light.viewMatrix = vm;
+    }
+
+    get viewMatrix(): any {
+        return this._light.viewMatrix;
+    }
+
+    clone(): LightComponent {
+        const result = new LightComponent();
+        result.assign(this);
+        return result;
+    }
+
+    assign(other: LightComponent): void {
+        this._light = other._light.clone();
+    }
+
+    setProperties({
+        enabled,
+        type,
+        lightType,  // alias of type
+        direction,
+        position,
+        color,
+        spotCutoff,
+        spotExponent,
+        shadowStrength,
+        castShadows,
+        shadowBias,
+        intensity,
+        projection 
+    }: {
+        enabled?: boolean;
+        type?: LightType;
+        lightType?: LightType;
+        direction?: any;
+        position?: any;
+        color?: any;
+        spotCutoff?: number;
+        spotExponent?: number;
+        shadowStrength?: number;
+        castShadows?: boolean;
+        shadowBias?: number;
+        intensity?: number;
+        projection?: any;
+    }): void {
+        if (enabled !== undefined) {
+            this.light.enabled = enabled;
+        }
+        if (type !== undefined) {
+            this.light.type = type;
+        }
+        if (lightType !== undefined) {
+            this.light.type = lightType;
+        }
+        if (direction !== undefined) {
+            this.light.direction = direction;
+        }
+        if (position !== undefined) {
+            this.light.position = position;
+        }
+        if (color !== undefined) {
+            this.light.color = color;
+        }
+        if (spotCutoff !== undefined) {
+            this.light.spotCutoff = spotCutoff;
+        }
+        if (spotExponent !== undefined) {
+            this.light.spotExponent = spotExponent;
+        }
+        if (shadowStrength !== undefined) {
+            this.light.shadowStrength = shadowStrength;
+        }
+        if (castShadows !== undefined) {
+            this.light.castShadows = castShadows;
+        }
+        if (shadowBias !== undefined) {
+            this.light.shadowBias = shadowBias;
+        }
+        if (intensity !== undefined) {
+            this.light.intensity = intensity;
+        }
+        if (projection !== undefined) {
+            this.light.projection = projection;
+        }
+    }
+
+    async deserialize(sceneData: any, loader: any): Promise<void> {
+        await this._light.deserialize(sceneData);
+    }
+
+    async serialize(sceneData: any, writer: any): Promise<void> {
+        await super.serialize(sceneData,writer);
+        await this._light.serialize(sceneData);
+        throw new Error("LightComponent.serialize() not implemented");
+    }
+
+    draw(renderQueue: any, modelMatrix: any): void {
+        renderQueue.addLight(this.light, modelMatrix);
+    }
+}

package/src/scene/MatrixState.ts

@@ -0,0 +1,46 @@
+
+import Mat4 from "../math/Mat4";
+
+const pushMatrix = function(mat: Mat4, stack: Mat4[], id: string): void {
+    stack.push(new Mat4(mat));
+}
+
+const popMatrix = function(mat: Mat4, stack: Mat4[], id: string): void {
+    if (stack.length > 0) {
+        mat.assign(stack[stack.length - 1]);
+        stack.splice(stack.length - 1, 1);
+    }
+    else {
+        throw new Error(`Matrix stack underflow detected in ${id} matrix`);
+    }
+}
+
+export default class MatrixState {
+    private _projection: Mat4;
+    private _view: Mat4;
+    private _model: Mat4;
+    private _projMatrixStack: Mat4[];
+    private _viewMatrixStack: Mat4[];
+    private _modelMatrixStack: Mat4[];
+
+    constructor() {
+        this._projection = Mat4.MakeIdentity();
+        this._view = Mat4.MakeIdentity();
+        this._model = Mat4.MakeIdentity();
+
+        this._projMatrixStack = [];
+        this._viewMatrixStack = [];
+        this._modelMatrixStack = [];
+    }
+
+    get projection(): Mat4 { return this._projection; }
+    get view(): Mat4 { return this._view; }
+    get model(): Mat4 { return this._model; }
+
+    pushProjection(): void { pushMatrix(this._projection, this._projMatrixStack, 'projection'); }
+    popProjection(): void { popMatrix(this._projection, this._projMatrixStack, 'projection'); }
+    pushView(): void { pushMatrix(this._view, this._viewMatrixStack, 'view'); }
+    popView(): void { popMatrix(this._view, this._viewMatrixStack, 'view'); }
+    pushModel(): void { pushMatrix(this._model, this._modelMatrixStack, 'model'); }
+    popModel(): void { popMatrix(this._model, this._modelMatrixStack, 'model'); }
+}

package/src/scene/Node.ts

@@ -0,0 +1,314 @@
+import Mat4 from '../math/Mat4';
+import ComponentMap from './ComponentMap';
+import Component from './Component';
+import Renderer from '../render/Renderer';
+import Camera from './Camera';
+import Transform from './Transform';
+import Drawable from './Drawable';
+import LightComponent from './LightComponent';
+
+export function bindRenderer(node: Node, renderer: Renderer): void {
+    (node as any)._bindedRenderer = renderer;
+    node.components.forEach(comp => {
+        comp.bindRenderer(renderer);
+    });
+}
+
+export async function init(node: Node): Promise<void> {
+    for (const i in node.components.array) {
+        const comp = node.components.array[i];
+        if (!(comp as any)._initialized) {
+            await comp.init();
+            (comp as any)._initialized = true;
+        }
+    }
+    (node as any)._sceneChanged = false;
+}
+
+export default class Node {
+    private _name: string;
+    private _enabled: boolean;
+    private _steady: boolean;
+    private _components: ComponentMap;
+    private _parent: Node | null;
+    private _children: Node[];
+    private _bindedRenderer?: Renderer;
+    private _sceneChanged: boolean = false;
+
+    constructor(name: string = "") {
+        this._name = name;
+        this._enabled = true;
+        this._steady = false;
+
+        this._components = new ComponentMap(this);
+
+        this._parent = null;
+        this._children = [];
+    }
+
+    get name(): string { return this._name; }
+    set name(n: string) { this._name = n; }
+
+    get enabled(): boolean { return this._enabled; }
+    set enabled(e: boolean) { this._enabled = e; }
+
+    get steady(): boolean { return this._steady; }
+    set steady(s: boolean) { this._steady = s; }
+
+    get components(): ComponentMap { return this._components; }
+
+    get parent(): Node | null { return this._parent; }
+    get children(): Node[] { return this._children; }
+
+    clone(cloneChildren: boolean = false): Node {
+        const newNode = new Node();
+        newNode.assign(this, cloneChildren);
+        return newNode;
+    }
+
+    assign(other: Node, cloneChildren: boolean = false): void {
+        this._name = other.name + "-copy";
+        this._enabled = other.enabled;
+        this._steady = other.steady;
+        this._components.assign(other._components);
+        if (cloneChildren) {
+            this._children = [];
+            other._children.forEach(c => {
+                this._children.push(c.clone(cloneChildren));
+            });
+        }
+    }
+
+    destroy(): void {
+        this._components.empty();
+        this.emptyChildren();
+    }
+
+    async deserialize(sceneData: any, loader: any): Promise<void> {
+        throw new Error("Node.deserialize() not implemented");
+    }
+
+    async serialize(sceneData: any, writer: any): Promise<void> {
+        throw new Error("Node.serialice() not implemented");
+    }
+
+    addComponent(component: Component): Component {
+        this.components.add(component);
+        this.setSceneChanged();
+        return component;
+    }
+
+    component(typeId: string): Component | undefined {
+        return this.components.find(typeId);
+    }
+
+    removeComponent(component: Component | string): void {
+        this.components.remove(component);
+        this.setSceneChanged();
+    }
+
+    addedToNode(node: Node): void {
+        // Override in subclasses if needed
+    }
+
+    removedFromNode(node: Node): void {
+        // Override in subclasses if needed
+    }
+
+    // This attribute returns true if a node or component
+    // has been added or removed to this node or any child node
+    get sceneChanged(): boolean {
+        return this._sceneChanged;
+    }
+
+    setSceneChanged(): void {
+        this._sceneChanged = true;
+        if (this._parent) {
+            this._parent.setSceneChanged();
+        }
+    }
+
+    addChild(node: Node): void {
+        if (node._parent) {
+            node._parent.removeChild(node);
+        }
+        node._parent = this;
+        this._children.push(node);
+        node.addedToNode(this);
+
+        // If this node has been binded to a renderer, we need to bind
+        // the same renderer to any node that is added as child
+        if (this._bindedRenderer) {
+            bindRenderer(node, this._bindedRenderer);
+        }
+
+        this.setSceneChanged();
+    }
+
+    removeChild(node: Node): void {
+        if (node._parent === this) {
+            node._parent = null;
+            node.removedFromNode(this);
+            const index = this._children.indexOf(node);
+            if (index !== -1) {
+                this._children.splice(index, 1);
+                this.setSceneChanged();
+            }
+            else {
+                console.warn(`Scene inconsistency found removing node '${ node.name }' from node '${ this.name }'. The parent node is valid, but the child is not present in the children array.`);
+            }
+        }
+        else {
+            throw new Error(`Node.removeChild() - the specified node is not a child of this node.`);
+        }
+    }
+
+    emptyChildren(): void {
+        this._children.forEach(ch => {
+            ch._parent = null;
+            ch.removedFromNode(this);
+        });
+        this._children = [];
+        this.setSceneChanged();
+    }
+
+    haveChild(node: Node): boolean {
+        return this._children.indexOf(node) !== -1;
+    }
+
+    isAncientOf(node: Node): boolean {
+        const isNodeAncient = (node: Node | null, ancient: Node): boolean => {
+            if (!node || !ancient) {
+                return false;
+            }
+            else if (node._parent === ancient) {
+                return true;
+            }
+            else {
+                return isNodeAncient(node._parent, ancient);
+            }
+        }
+        return isNodeAncient(this, node);
+    }
+
+    // Visitor functions
+    accept(nodeVisitor: any): void {
+        if (!nodeVisitor.ignoreDisabled || this.enabled) {
+            nodeVisitor.visit(this);
+            this._children.forEach(ch => ch.accept(nodeVisitor));
+            nodeVisitor.didVisit(this);
+        }
+    }
+
+    acceptReverse(nodeVisitor: any): void {
+        if (!nodeVisitor.ignoreDisabled || this.enabled) {
+            if (this._parent) {
+                this._parent.acceptReverse(nodeVisitor);
+            }
+            nodeVisitor.visit(this);
+        }
+    }
+
+    async asyncAccept(nodeVisitor: any): Promise<void> {
+        if (!nodeVisitor.ignoreDisabled || this.enabled) {
+            await nodeVisitor.asyncVisit(this);
+            for (const ch in this._children) {
+                await this._children[ch].asyncAccept(nodeVisitor);
+            }
+        }
+    }
+    
+    // Most usual components
+    get transform(): Transform | undefined {
+        return this.component("Transform") as Transform;
+    }
+
+    get lightComponent(): LightComponent | undefined {
+        return this.component("Light") as LightComponent;
+    }
+
+    get drawable(): Drawable | undefined {
+        return this.component("Drawable") as Drawable;
+    }
+
+    get camera(): Camera | undefined {
+        return this.component("Camera") as Camera;
+    }
+
+    frame(delta: number, modelMatrix: Mat4, renderQueue: any): void {
+        const willUpdateComponents: Component[] = [];
+        const updateComponents: Component[] = [];
+        const drawComponents: Component[] = [];
+        this._components.forEach(comp => {
+            if (comp.requireWillUpdate) {
+                willUpdateComponents.push(comp);
+            }
+            if (comp.requireUpdate) {
+                updateComponents.push(comp);
+            }
+            if (comp.requireDraw) {
+                drawComponents.push(comp);
+            }
+        });
+
+        willUpdateComponents.forEach(comp => (comp as any).willUpdate(delta));
+        updateComponents.forEach(comp => (comp as any).update(delta, modelMatrix));
+        drawComponents.forEach(comp => (comp as any).draw(renderQueue, modelMatrix));
+    }
+
+    keyDown(evt: any): void {
+        this._components.forEach(comp => {
+            comp.keyDown(evt);
+        });
+    }
+    keyUp(evt: any): void {
+        this._components.forEach(comp => {
+            comp.keyUp(evt);
+        });
+    }
+    mouseUp(evt: any): void {
+        this._components.forEach(comp => {
+            comp.mouseUp(evt);
+        });
+    }
+    mouseDown(evt: any): void {
+        this._components.forEach(comp => {
+            comp.mouseDown(evt);
+        });
+    }
+    mouseMove(evt: any): void {
+        this._components.forEach(comp => {
+            comp.mouseMove(evt);
+        });
+    }
+    mouseOut(evt: any): void {
+        this._components.forEach(comp => {
+            comp.mouseOut(evt);
+        });
+    }
+    mouseDrag(evt: any): void {
+        this._components.forEach(comp => {
+            comp.mouseDrag(evt);
+        });
+    }
+    mouseWheel(evt: any): void {
+        this._components.forEach(comp => {
+            comp.mouseWheel(evt);
+        });
+    }
+    touchStart(evt: any): void {
+        this._components.forEach(comp => {
+            comp.touchStart(evt);
+        });
+    }
+    touchMove(evt: any): void {
+        this._components.forEach(comp => {
+            comp.touchMove(evt);
+        });
+    }
+    touchEnd(evt: any): void {
+        this._components.forEach(comp => {
+            comp.touchEnd(evt);
+        });
+    }
+}

package/src/scene/NodeVisitor.ts

@@ -0,0 +1,15 @@
+import Node
+ from "./Node";
+export default class NodeVisitor {
+    private _ignoreDisabled: boolean;
+
+    constructor() {
+        this._ignoreDisabled = true;
+    }
+
+    get ignoreDisabled() { return this._ignoreDisabled; }
+    set ignoreDisabled(i) { this._ignoreDisabled = i; }
+
+    visit(node: Node) {}
+    didVisit(node: Node) {}
+}