bg2e-js 2.1.1 → 2.2.0

package/src/scene/Component.ts

@@ -0,0 +1,173 @@
+import Renderer from "../render/Renderer";
+import Camera from "./Camera";
+import Drawable from "./Drawable";
+import LightComponent from "./LightComponent";
+import Node from "./Node";
+import Transform from "./Transform";
+
+// Type definitions
+type ComponentConstructor<T extends Component = Component> = new () => T;
+
+interface ComponentRegistry {
+    [typeId: string]: ComponentConstructor;
+}
+
+const g_componentClasses: ComponentRegistry = {};
+
+export const registerComponent = <T extends Component>(
+    typeId: string,
+    componentClass: ComponentConstructor<T>
+): void => {
+    g_componentClasses[typeId] = componentClass;
+};
+
+export const createComponent = (typeId: string): Component | null => {
+    const ComponentClass = g_componentClasses[typeId];
+    if (ComponentClass) {
+        try {
+            const compInstance = new ComponentClass();
+            return compInstance;
+        }
+        catch (err: any) {
+            if (err.code === -1) {
+                throw new Error(`Error in component constructor definition. Check the implementation of the '${ typeId }' component constructor. It should call super('typeId') to configure the component type id.`);
+            }
+        }
+    }
+    else {
+        console.debug(`Ignoring component with type id='${typeId}'. If this is not expected, check if the component is registered in the component factory.`);
+        return null;
+    }
+    return null;
+};
+
+export const deserializeComponent = async (sceneData: any, loader: any): Promise<Component | null> => {
+    const componentInstance = createComponent(sceneData.type);
+    if (!componentInstance) {
+        return null;
+    }
+    
+    await componentInstance.deserialize(sceneData, loader);
+    return componentInstance;
+};
+
+export default class Component {
+    private _node: any = null;
+    private _typeId: string;
+    protected _renderer: Renderer | null = null;
+
+    constructor(typeId: string) {
+        if (!typeId) {
+            const e: any = new Error("Invalid typeId specified creating component.");
+            e.code = -1;
+            throw e;
+        }
+        this._typeId = typeId;
+    }
+
+    get node(): Node { return this._node; }
+
+    get typeId(): string { return this._typeId; }
+
+    clone(): Component {
+        throw new Error("Component.clone() not implemented");
+    }
+
+    assign(other: Component): void {
+        throw new Error("Component.assign() not implemented");
+    }
+
+    destroy(): void {
+        // Override in subclasses if needed
+    }
+
+    addedToNode(node: any): void {
+        // Override in subclasses if needed
+    }
+
+    removedFromNode(node: any): void {
+        // Override in subclasses if needed
+    }
+
+    async deserialize(sceneData: any, loader: any): Promise<void> {
+        // Override in subclasses if needed
+    }
+
+    async serialize(sceneData: any, writer: any): Promise<void> {
+        sceneData.type = this.typeId;
+    }
+
+    bindRenderer(renderer: Renderer): void {
+        if (!(renderer instanceof Renderer)) {
+            throw Error("Component.bindRenderer(): invalid renderer. Object is not instance of render.Renderer");
+        }
+
+        this._renderer = renderer;
+    }
+
+    async init(): Promise<void> {
+        // Override in subclasses if needed
+    }
+
+    get ready(): boolean {
+        return this._renderer !== null;
+    }
+
+    get renderer(): Renderer | null {
+        return this._renderer;
+    }
+
+    // Access to brother components
+    component(identifier: string): Component | undefined {
+        return this.node.component(identifier);
+    }
+
+    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;
+    }
+
+    // Life cycle functions and properties
+    get requireWillUpdate(): boolean { 
+        return typeof((this as any).willUpdate) === "function";
+    }
+    
+    get requireUpdate(): boolean { 
+        return typeof((this as any).update) === "function";
+    }
+    
+    get requireDraw(): boolean { 
+        return typeof((this as any).draw) === "function";
+    }
+
+    // The following functions can be implemented in component classes to complete the 
+    // life cycle functions
+    // async init(): Promise<void> {}
+    // willUpdate(delta: number): void {}
+    // update(delta: number, modelMatrix: any): void {}
+    // draw(renderQueue: any, modelMatrix: any): void {}
+
+    // Event callbacks
+    keyDown(evt: any): void {}
+    keyUp(evt: any): void {}
+    mouseUp(evt: any): void {}
+    mouseDown(evt: any): void {}
+    mouseMove(evt: any): void {}
+    mouseOut(evt: any): void {}
+    mouseDrag(evt: any): void {}
+    mouseWheel(evt: any): void {}
+    touchStart(evt: any): void {}
+    touchMove(evt: any): void {}
+    touchEnd(evt: any): void {}
+}

package/src/scene/ComponentMap.ts

@@ -0,0 +1,107 @@
+
+import Component from "./Component";
+
+interface ComponentObject {
+    [typeId: string]: Component;
+}
+
+export default class ComponentMap {
+    private _node: any;
+    private _obj: ComponentObject;
+    private _array: Component[];
+
+    private syncArray(): void {
+        this._array = [];
+        for (const type in this._obj) {
+            const c = this._obj[type];
+            this._array.push(c);
+        } 
+    }
+
+    constructor(node: any) {
+        this._node = node;
+        this._obj = {};
+        this._array = [];
+    }
+
+    get array(): Component[] {
+        return this._array;
+    }
+
+    add(comp: Component): void {
+        const typeId = comp.typeId;
+        const existingComp = this._obj[typeId];
+        if (existingComp) {
+            (existingComp as any)._node = null;
+            existingComp.removedFromNode(this._node);
+        }
+        this._obj[typeId] = comp;
+        (comp as any)._node = this._node;
+        comp.addedToNode(this._node);
+        this.syncArray();
+    }
+
+    remove(compOrType: Component | string): void {
+        const typeId = compOrType instanceof Component ? compOrType.typeId : compOrType;
+        const existingComp = this._obj[typeId];
+        if (existingComp) {
+            (existingComp as any)._node = null;
+            existingComp.removedFromNode(this._node);
+            delete this._obj[typeId];
+            this.syncArray();
+        }
+    }
+
+    empty(): void {
+        for (const typeId in this._obj) {
+            const comp = this._obj[typeId];
+            (comp as any)._node = null;
+            comp.removedFromNode(this._node);
+        }
+        this._obj = {};
+        this._array = [];
+    }
+
+    find(typeId: string): Component | undefined {
+        return this._obj[typeId];
+    }
+
+    forEach(cb: (component: Component, index: number, array: Component[]) => void): void {
+        return this._array.forEach(cb);
+    }
+
+    every(cb: (component: Component, index: number, array: Component[]) => boolean): boolean {
+        return this._array.every(cb);
+    }
+
+    some(cb: (component: Component, index: number, array: Component[]) => boolean): boolean {
+        return this._array.some(cb);
+    }
+
+    map<T>(cb: (component: Component, index: number, array: Component[]) => T): T[] {
+        return this._array.map(cb);
+    }
+
+    filter(cb: (component: Component, index: number, array: Component[]) => boolean): Component[] {
+        return this._array.filter(cb);
+    }
+
+    clone(parentNode: any): ComponentMap {
+        const result = new ComponentMap(parentNode);
+        result.assign(this);
+        return result;
+    }
+
+    // Note: this function clones the components from 'other'
+    // instance to this instance.
+    // This function doesn't modify this._node reference
+    assign(other: ComponentMap): void {
+        this.empty();
+        for (const typeId in other._obj) {
+            const comp = other._obj[typeId];
+            const compClone = comp.clone();
+            this._obj[typeId] = compClone;
+        }
+        this.syncArray();
+    }
+}

package/src/scene/Drawable.ts

@@ -0,0 +1,154 @@
+
+import Component from "./Component";
+import Mat4 from "../math/Mat4";
+import PolyList from "../base/PolyList";
+import Material from "../base/Material";
+import VitscnjLoaderPlugin, { DrawableFormat } from "../db/VitscnjLoaderPlugin";
+import Renderer from "../render/Renderer";
+
+interface DrawableItem {
+    polyList: PolyList;
+    material: Material;
+    transform: Mat4;
+    polyListRenderer?: any; // PolyListRenderer
+    materialRenderer?: any; // MaterialRenderer
+}
+
+interface DrawableSceneData {
+    name: string;
+    [key: string]: unknown;
+}
+
+interface LoadedDrawable {
+    name: string;
+    items: DrawableItem[];
+}
+
+export default class Drawable extends Component {
+    private _name: string;
+    private _items: DrawableItem[];
+    constructor(name?: string) {
+        super("Drawable");
+        this._name = name || "";
+        this._items = [];
+    }
+
+    get name(): string {
+        return this._name;
+    }
+
+    set name(n: string) {
+        this._name = n;
+    }
+
+    get valid(): boolean {
+        return this._items.length>0 && this._items.every(item => item.polyList !== null && item.material !== null);
+    }
+
+    get items(): DrawableItem[] {
+        return this._items;
+    }
+
+    clone(): Drawable {
+        const result = new Drawable();
+        result.assign(this);
+        return result;
+    }
+
+    assign(other: Drawable): void {
+        this.destroy();
+        this._name = other._name;
+        this._items = [];
+        other._items.forEach(item => {
+            const pl = item.polyList.clone();
+            const mat = item.material.clone();
+            const trx = new Mat4(item.transform);
+            this.addPolyList(pl,mat,trx);
+        });
+    }
+
+    addPolyList(polyList: PolyList, material: Material, transform: Mat4 = Mat4.MakeIdentity()): void {
+        if (!(polyList instanceof PolyList)) {
+            throw new Error("Error adding polyList to drawable object: polyList is not an instance of PolyList");
+        }
+        if (!(material instanceof Material)) {
+            throw new Error("Error adding polyList to drawable object: material is not an instance of Material");
+        }
+        if (!(transform instanceof Mat4)) {
+            throw new Error("Error adding polyList to drawable object: transform is not an instance of Mat4");
+        }
+        this._items.push({ polyList, material, transform });
+    }
+
+    removePolyList(plist: PolyList): void {
+        this._items = this._items.filter(item => item.polyList != plist);
+    }
+
+    destroy(): void {
+
+    }
+
+    addedToNode(node: any): void {
+
+    }
+
+    removedFromNode(node: any): void {
+
+    }
+
+    makeSelectable(selectable: boolean = true): void {
+        this._items.forEach(({polyList}) => {
+            polyList.selectable = selectable;
+        })
+    }
+
+    async deserialize(sceneData: DrawableSceneData, loader: any): Promise<void> {
+        const tryload = async (drawablePath: string): Promise<LoadedDrawable | null> => {
+            try {
+                const result = await loader.loadDrawable(drawablePath);
+                return result;
+            }
+            catch (err: any) {
+                if (!/not found/i.test(err.message)) {
+                    console.error(err);
+                }
+                return null;
+            }
+        }
+
+        const drwFormat = VitscnjLoaderPlugin.PreferredDrawableFormat();
+        const drw = drwFormat === DrawableFormat.BG2
+            ? (await tryload(sceneData.name + '.bg2') || await tryload(sceneData.name + '.vwglb'))
+            :   (await tryload(sceneData.name + '.vwglb') || await tryload(sceneData.name + '.bg2'));
+
+        if (!drw) {
+            throw new Error(`Drawable.deserialize(): could not load drawable with name ${sceneData.name}`);
+        }
+        drw.items.forEach(({polyList,material,transform}) => this.addPolyList(polyList,material,transform));
+        this.name = drw.name;
+    }
+
+    async serialize(sceneData: DrawableSceneData, writer: any): Promise<void> {
+        await super.serialize(sceneData,writer);
+        throw new Error("Drawable.serialice() not implemented");
+    }
+
+    bindRenderer(renderer: Renderer): void {
+        super.bindRenderer(renderer);
+        this._items.forEach(item => {
+            item.polyListRenderer = renderer.factory.polyList(item.polyList);
+            item.materialRenderer = renderer.factory.material(item.material);
+        });
+    }
+
+    draw(renderQueue: any, modelMatrix: Mat4): void {
+        if (this.ready) {
+            this._items.forEach(({transform,polyListRenderer,materialRenderer}) => {
+                renderQueue.addPolyList(
+                    polyListRenderer,
+                    materialRenderer,
+                    Mat4.Mult(transform, modelMatrix));
+            });
+        }
+    }
+}

package/src/scene/EnvironmentComponent.ts

@@ -0,0 +1,142 @@
+import { jointUrl } from "../tools/Resource";
+import Component from "./Component";
+import EnvironmentRenderer from "../render/Environment";
+
+export default class EnvironmentComponent extends Component {
+    private _equirectangularTexture: string;
+    private _irradianceIntensity: number;
+    private _showSkybox: boolean;
+    private _cubemapSize: number;
+    private _irradianceMapSize: number;
+    private _specularMapSize: number;
+    private _specularMapL2Size: number;
+    private _environment: EnvironmentRenderer | null;
+
+    constructor() {
+        super("Environment");
+
+        this._equirectangularTexture = "";
+        this._irradianceIntensity = 1;
+        this._showSkybox = true;
+        this._cubemapSize = 512;
+        this._irradianceMapSize = 32;
+        this._specularMapSize = 32;
+        this._specularMapL2Size = 32;
+
+        // Non-serializable attribute
+        this._environment = null;
+    }
+
+    set equirectangularTexture(v: string) {
+        this._equirectangularTexture = v;
+    }
+
+    get equirectangularTexture(): string {
+        return this._equirectangularTexture;
+    }
+
+    set irradianceIntensity(v: number) {
+        this._irradianceIntensity = v;
+    }
+
+    get irradianceIntensity(): number {
+        return this._irradianceIntensity;
+    }
+
+    set showSkybox(v: boolean) {
+        this._showSkybox = v;
+    }
+
+    get showSkybox(): boolean {
+        return this._showSkybox;
+    }
+
+    set cubemapSize(v: number) {
+        this._cubemapSize = v;
+    }
+
+    get cubemapSize(): number {
+        return this._cubemapSize;
+    }
+
+    set irradianceMapSize(v: number) {
+        this._irradianceMapSize = v;
+    }
+
+    get irradianceMapSize(): number {
+        return this._irradianceMapSize;
+    }
+
+    set specularMapSize(v: number) {
+        this._specularMapSize = v;
+    }
+
+    get specularMapSize(): number {
+        return this._specularMapSize;
+    }
+
+    set specularMapL2Size(v: number) {
+        this._specularMapL2Size = v;
+    }
+
+    get specularMapL2Size(): number {
+        return this._specularMapL2Size;
+    }
+
+    get environment(): any {
+        return this._environment;
+    }
+
+    clone(): EnvironmentComponent {
+        const result = new EnvironmentComponent();
+        result.assign(this);
+        return result;
+    }
+
+    assign(other: EnvironmentComponent): void {
+        this.equirectangularTexture = other.equirectangularTexture;
+        this.irradianceIntensity = other.irradianceIntensity;
+        this.showSkybox = other.showSkybox;
+        this.cubemapSize = other.cubemapSize;
+        this.irradianceMapSize = other.irradianceMapSize;
+        this.specularMapSize = other.specularMapSize;
+        this.specularMapL2Size = other.specularMapL2Size;
+    }
+
+    async deserialize(sceneData: any, loader: any): Promise<void> {
+        super.deserialize(sceneData, loader);
+        if (loader.currentPath && sceneData.equirectangularTexture) {
+            this.equirectangularTexture = jointUrl(loader.currentPath, sceneData.equirectangularTexture);
+        }
+        this.irradianceIntensity = sceneData.irradianceIntensity || this.irradianceIntensity;
+        this.showSkybox = sceneData.showSkybox ?? this.showSkybox;
+        this.cubemapSize = sceneData.cubemapSize || this.cubemapSize;
+        this.irradianceMapSize = sceneData.irradianceMapSize || this.irradianceMapSize;
+        this.specularMapSize = sceneData.specularMapSize || this.specularMapSize;
+        this.specularMapL2Size = sceneData.specularMapL2Size || this.specularMapL2Size;
+    }
+
+    async serialize(sceneData: any, writer: any): Promise<void> {
+        await super.serialize(sceneData, writer);
+        throw Error("EnvironmentComponent.serialize(): not implemented");
+    }
+
+    async init(): Promise<void> {
+        this._environment = this.renderer?.factory.environment()!;
+        if (!this._environment) {
+            throw new Error("EnvironmentComponent.init(): unexpected error. Unable to create environment object from renderer factory");
+        }
+
+        if (!this.equirectangularTexture) {
+            return;
+        }
+
+        await this._environment.load({
+            // @ts-ignore TODO: convert render/Environment.js to TS
+            textureUrl: this.equirectangularTexture,
+            environmentMapSize: [ this.cubemapSize, this.cubemapSize ],
+            specularMapSize: [ this.specularMapSize, this.specularMapSize ],
+            irradianceMapSize: [ this.irradianceMapSize, this.irradianceMapSize ]
+        });
+    }
+}

package/src/scene/FindNodeVisitor.ts

@@ -0,0 +1,60 @@
+import NodeVisitor from "./NodeVisitor";
+import Node from "./Node";
+
+export default class FindNodeVisitor extends NodeVisitor {
+    private _name?: string | RegExp;
+    private _result: Node[];
+    private _hasComponents: string[];
+
+    constructor() {
+        super();
+
+        this._name = undefined;
+        this._result = [];
+        this._hasComponents = [];
+    }
+
+    set name(n: string | RegExp | undefined) {
+        this._name = n;
+    }
+
+    get name(): string | RegExp | undefined {
+        return this._name;
+    }
+
+    get result(): Node[] {
+        return this._result;
+    }
+
+    clear(): void {
+        this._result = [];
+    }
+
+    hasComponents(components: string | string[]): void {
+        if (!Array.isArray(components)) {
+            components = [components];
+        }
+        this._hasComponents = components;
+    }
+
+    visit(node: Node): void {
+        let add = false;
+        if (typeof(this._name) === "string") {
+            add = this._name === node.name;
+        }
+        else if (this._name instanceof RegExp) {
+            add = this._name.test(node.name);
+        }
+        else {
+            add = true;
+        }
+
+        add = add && (
+            this._hasComponents.some(compId => node.component(compId)) ||
+            this._hasComponents.length == 0
+        );
+        if (add) {
+            this._result.push(node);
+        }
+    }
+}