bg2e-js 2.0.1 → 2.0.2

package/scene/Component.js

@@ -1,146 +0,0 @@
-import Renderer from "../render/Renderer";
-
-const g_componentClasses = {}
-
-export const registerComponent = (typeId,componentClass) => {
-    g_componentClasses[typeId] = componentClass;
-}
-
-export const createComponent = (typeId) => {
-    const ComponentClass = g_componentClasses[typeId];
-    if (ComponentClass) {
-        try {
-            const compInstance = new ComponentClass();
-            return compInstance;
-        }
-        catch (err) {
-            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;
-    }
-}
-
-export const deserializeComponent = async (sceneData,loader) => {
-    const componentInstance = createComponent(sceneData.type);
-    if (!componentInstance) {
-        return null;
-    }
-    
-    await componentInstance.deserialize(sceneData,loader);
-    return componentInstance;
-}
-
-export default class Component {
-    constructor(typeId) {
-        this._node = null;
-        if (!typeId) {
-            const e = new Error("Invalid typeId specified creating component.");
-            e.code = -1;
-            throw e;
-        }
-        this._typeId = typeId;
-    }
-
-    get node() { return this._node; }
-
-    get typeId() { return this._typeId; }
-
-    clone() {
-        throw new Error("Component.clone() not implemented");
-    }
-
-    assign(other) {
-        throw new Error("Component.assign() not implemented");
-    }
-
-    destroy() {
-
-    }
-
-    addedToNode(node) {
-
-    }
-
-    removedFromNode(node) {
-
-    }
-
-    async deserialize(sceneData,loader) {
-    }
-
-    async serialize(sceneData,writer) {
-        sceneData.type = this.typeId;
-    }
-
-    bindRenderer(renderer) {
-        if (!renderer instanceof Renderer) {
-            throw Error("Component.bindRenderer(): invalid renderer. Object is not instance of render.Renderer");
-        }
-
-        this._renderer = renderer;
-    }
-
-    async init() {
-        
-    }
-
-    get ready() {
-        return this._renderer !== null;
-    }
-
-    get renderer() {
-        return this._renderer;
-    }
-
-    // Access to brother components
-    component(identifier) {
-        return this.node.component(identifier);
-    }
-
-    get transform() {
-        return this.component("Transform");
-    }
-
-    get lightComponent() {
-        return this.component("Light");
-    }
-
-    get drawable() {
-        return this.component("Drawable");
-    }
-
-    get camera() {
-        return this.component("Camera");
-    }
-
-    // Life cycle functions and properties
-    get requireWillUpdate() { return typeof(this.willUpdate) === "function" }
-    get requireUpdate() { return typeof(this.update) === "function" }
-    get requireDraw() { return typeof(this.draw) === "function"; }
-
-    // The following functions can be implemented in component classes to complete the 
-    // life cycle functions
-    // async init() {}
-    // willUpdate(delta) {}
-    // update(delta,modelMatrix) {}
-    // draw(renderQueue,modelMatrix) {}
-
-    // Event callbacks
-    keyDown(evt) {}
-    keyUp(evt) {}
-    mouseUp(evt) {}
-    mouseDown(evt) {}
-    mouseMove(evt) {}
-    mouseOut(evt) {}
-    mouseDrag(evt) {}
-    mouseWheel(evt) {}
-    touchStart(evt) {}
-    touchMove(evt) {}
-    touchEnd(evt) {}
-}
-

package/scene/ComponentMap.js

@@ -1,99 +0,0 @@
-
-import Component from "./Component";
-
-function syncArray() {
-    this._array = [];
-    for (const type in this._obj) {
-        const c = this._obj[type];
-        this._array.push(c);
-    } 
-}
-
-export default class ComponentMap {
-    constructor(node) {
-        this._node = node;
-        this._obj = {};
-        this._array = [];
-    }
-
-    get array() {
-        return this._array;
-    }
-
-    add(comp) {
-        const typeId = comp.typeId;
-        const existingComp = this._obj[typeId];
-        if (existingComp) {
-            existingComp._node = null;
-            existingComp.removedFromNode(this._node);
-        }
-        this._obj[typeId] = comp;
-        comp._node = this._node;
-        comp.addedToNode(this._node);
-        syncArray.apply(this);
-    }
-
-    remove(compOrType) {
-        const typeId = compOrType instanceof Component ? compOrType.typeId : compOrType;
-        const existingComp = this._obj[typeId];
-        if (existingComp) {
-            existingComp._node = null;
-            existingComp.removedFromNode(this._node);
-            delete this._obj[typeId];
-            syncArray.apply(this);
-        }
-    }
-
-    empty() {
-        for (const typeId in this._obj) {
-            const comp = this._obj[typeId];
-            comp._node = null;
-            comp.removedFromNode(this._node);
-        }
-        this._obj = {};
-        this._array = [];
-    }
-
-    find(typeId) {
-        return this._obj[typeId];
-    }
-
-    forEach(cb) {
-        return this._array.forEach(cb);
-    }
-
-    every(cb) {
-        return this._array.every(cb);
-    }
-
-    some(cb) {
-        return this._array.some(cb);
-    }
-
-    map(cb) {
-        return this._array.map(cb);
-    }
-
-    filter(cb) {
-        return this._array.filter(cb);
-    }
-
-    clone(parentNode) {
-        const result = new Components(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) {
-        this.empty();
-        for (const typeId in other._obj) {
-            const comp = other._obj[typeId];
-            const compClone = comp.clone();
-            this._obj[typeId] = compClone;
-        }
-        syncArray.apply(this);
-    }
-}

package/scene/Drawable.js

@@ -1,130 +0,0 @@
-
-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";
-
-export default class Drawable extends Component {
-    constructor(name) {
-        super("Drawable");
-        this._name = name || "";
-        this._items = [];
-    }
-
-    get name() {
-        return this._name;
-    }
-
-    set name(n) {
-        this._name = n;
-    }
-
-    get valid() {
-        return this._items.length>0 && this._items.every(item => item.polyList !== null && item.material !== null);
-    }
-
-    get items() {
-        return this._items;
-    }
-
-    clone() {
-        const result = new Drawable();
-        result.assign(this);
-        return result;
-    }
-
-    assign(other) {
-        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,material,transform = Mat4.MakeIdentity(),r) {
-        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) {
-        this._items = this._items.filter(item => item.polyList != plist);
-    }
-
-    destroy() {
-
-    }
-
-    addedToNode(node) {
-
-    }
-
-    removedFromNode(node) {
-
-    }
-
-    makeSelectable(selectable = true) {
-        this._items.forEach(({polyList}) => {
-            polyList.selectable = selectable;
-        })
-    }
-
-    async deserialize(sceneData,loader) {
-        const tryload = async (drawablePath) => {
-            try {
-                const result = await loader.loadDrawable(drawablePath);
-                return result;
-            }
-            catch (err) {
-
-            }
-        }
-
-        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,writer) {
-        await super.serialize(sceneData,writer);
-        throw new Error("Drawable.serialice() not implemented");
-    }
-
-    bindRenderer(renderer) {
-        super.bindRenderer(renderer);
-        this._items.forEach(item => {
-            item.polyListRenderer = renderer.factory.polyList(item.polyList);
-            item.materialRenderer = renderer.factory.material(item.material);
-        });
-    }
-
-    draw(renderQueue,modelMatrix) {
-        if (this.ready) {
-            this._items.forEach(({transform,polyListRenderer,materialRenderer}) => {
-                renderQueue.addPolyList(
-                    polyListRenderer,
-                    materialRenderer,
-                    Mat4.Mult(transform, modelMatrix));
-            });
-        }
-    }
-}

package/scene/EnvironmentComponent.js

@@ -1,123 +0,0 @@
-import { jointUrl } from "../tools/Resource";
-import Component from "./Component";
-
-export default class EnvironmentComponent extends Component {
-    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) {
-        this._equirectangularTexture = v;
-    }
-
-    get equirectangularTexture() {
-        return this._equirectangularTexture;
-    }
-
-    set irradianceIntensity(v) {
-        this._irradianceIntensity = v;
-    }
-
-    get irradianceIntensity() {
-        return this._irradianceIntensity;
-    }
-
-    set showSkybox(v) {
-        this._showSkybox = v;
-    }
-
-    get showSkybox() {
-        return this._showSkybox;
-    }
-
-    set cubemapSize(v) {
-        this._cubemapSize = v;
-    }
-
-    get cubemapSize() {
-        return this._cubemapSize;
-    }
-
-    set irradianceMapSize(v) {
-        this._irradianceMapSize = v;
-    }
-
-    get irradianceMapSize() {
-        return this._irradianceMapSize;
-    }
-
-    set specularMapSize(v) {
-        this._specularMapSize = v;
-    }
-
-    get specularMapSize() {
-        return this._specularMapSize;
-    }
-
-    set specularMapL2Size(v) {
-        this._specularMapL2Size = v;
-    }
-
-    get specularMapL2Size() {
-        return this._specularMapL2Size;
-    }
-
-    get environment() {
-        return this._environment;
-    }
-
-    clone() {
-        const result = new EnvironmentComponent();
-        result.assign(this);
-        return result;
-    }
-
-    assign(other) {
-        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,loader) {
-        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,writer) {
-        await super.serialize(sceneData,writer);
-        throw Error("EnvironmentComponent.serialize(): not implemented");
-    }
-
-    async init() {
-        this._environment = this.renderer.factory.environment();
-        await this._environment.load({
-            textureUrl: this.equirectangularTexture,
-            environmentMapSize: [ this.cubemapSize, this.cubemapSize ],
-            specularMapSize: [ this.specularMapSize, this.specularMapSize ],
-            irradianceMapSize: [ this.irradianceMapSize, this.irradianceMapSize ]
-        });
-    }
-}

package/scene/FindNodeVisitor.js

@@ -1,55 +0,0 @@
-import NodeVisitor from "./NodeVisitor";
-
-export default class FindNodeVisitor extends NodeVisitor {
-    constructor() {
-        super();
-
-        this._name;
-        this._result = [];
-        this._hasComponents = [];
-    }
-
-    set name(n) {
-        this._name = n;
-    }
-
-    get name() {
-        return this._name;
-    }
-
-    get result() {
-        return this._result;
-    }
-
-    clear() {
-        this._result = [];
-    }
-
-    hasComponents(components) {
-        if (!Array.isArray(components)) {
-            components = [components];
-        }
-        this._hasComponents = components;
-    }
-
-    visit(node) {
-        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);
-        }
-    }
-}

package/scene/LightComponent.js

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