bg2e-js 2.3.11 → 2.3.13

package/src/scene/Chain.ts

@@ -1,44 +1,44 @@
-
-import Mat4 from "../math/Mat4";
-import Component from "./Component";
-import { ChainJoint } from "./ChainJoint";
-
-export default class Chain extends Component {
-    constructor() {
-        super('Chain');
-    }
-
-    willUpdate(frame: number, matrixState: any): void {
-        if (this.node) {
-            const matrix = Mat4.MakeIdentity();
-            this.node.children.forEach((child, index) => {
-                const trx = child.transform;
-                const inJoint = child.component("InputChainJoint") as ChainJoint;
-                const outJoint = child.component("OutputChainJoint") as ChainJoint;
-
-                if (index > 0 && inJoint) {
-                    inJoint.joint.applyTransform(matrix);
-                }
-                else {
-                    matrix.identity();
-                }
-
-                if (trx) {
-                    trx.matrix.assign(matrix);
-                }
-
-                if (outJoint) {
-                    outJoint.joint.applyTransform(matrix);
-                }
-            });
-        }
-    }
-    
-    clone(): Chain { return new Chain(); }
-    assign(other: Chain): void {}
-    async deserialize(sceneData: any, loader: any): Promise<void> {}
-
-    async serialize(sceneData: any, writer: any): Promise<void> {
-        await super.serialize(sceneData, writer);
-    }
-}
+
+import Mat4 from "../math/Mat4";
+import Component from "./Component";
+import { ChainJoint } from "./ChainJoint";
+
+export default class Chain extends Component {
+    constructor() {
+        super('Chain');
+    }
+
+    willUpdate(frame: number, matrixState: any): void {
+        if (this.node) {
+            const matrix = Mat4.MakeIdentity();
+            this.node.children.forEach((child, index) => {
+                const trx = child.transform;
+                const inJoint = child.component("InputChainJoint") as ChainJoint;
+                const outJoint = child.component("OutputChainJoint") as ChainJoint;
+
+                if (index > 0 && inJoint) {
+                    inJoint.joint.applyTransform(matrix);
+                }
+                else {
+                    matrix.identity();
+                }
+
+                if (trx) {
+                    trx.matrix.assign(matrix);
+                }
+
+                if (outJoint) {
+                    outJoint.joint.applyTransform(matrix);
+                }
+            });
+        }
+    }
+    
+    clone(): Chain { return new Chain(); }
+    assign(other: Chain): void {}
+    async deserialize(sceneData: any, loader: any): Promise<void> {}
+
+    async serialize(sceneData: any, writer: any): Promise<void> {
+        await super.serialize(sceneData, writer);
+    }
+}

package/src/scene/ChainJoint.ts

@@ -1,58 +1,58 @@
-import Component from "./Component";
-import Joint, { LinkTransformOrder, LinkJoint } from "../phsics/joint";
-
-export class ChainJoint extends Component {
-    protected _joint: LinkJoint;
-
-    constructor(typeId: string) {
-        super(typeId);
-
-        this._joint = new LinkJoint();
-    }
-
-    get joint(): LinkJoint { return this._joint; }
-    set joint(j: LinkJoint) { this._joint = j; }
-
-    assign(other: ChainJoint): void {
-        this.joint.assign(other.joint);
-    }
-
-    async deserialize(sceneData: any, loader: any): Promise<void> {
-        const joint: Joint | null = Joint.Factory(sceneData.joint);
-        if (joint && joint instanceof LinkJoint) {
-            this.joint = joint;
-        }
-    }
-
-    async serialize(sceneData: any, writer: any): Promise<void> {
-        await super.serialize(sceneData, writer);
-        sceneData.joint = {};
-        this.joint.serialize(sceneData.joint);
-    }
-}
-
-export class InputChainJoint extends ChainJoint {
-    constructor() {
-        super('InputChainJoint');
-        this.joint.transformOrder = LinkTransformOrder.ROTATE_TRANSLATE;
-    }
-
-    clone(): InputChainJoint {
-        const result = new InputChainJoint();
-        result.assign(this);
-        return result;
-    }
-}
-
-export class OutputChainJoint extends ChainJoint {
-    constructor() {
-        super('OutputChainJoint');
-        this.joint.transformOrder = LinkTransformOrder.TRANSLATE_ROTATE;
-    }
-
-    clone(): OutputChainJoint {
-        const result = new OutputChainJoint();
-        result.assign(this);
-        return result;
-    }
-}
+import Component from "./Component";
+import Joint, { LinkTransformOrder, LinkJoint } from "../phsics/joint";
+
+export class ChainJoint extends Component {
+    protected _joint: LinkJoint;
+
+    constructor(typeId: string) {
+        super(typeId);
+
+        this._joint = new LinkJoint();
+    }
+
+    get joint(): LinkJoint { return this._joint; }
+    set joint(j: LinkJoint) { this._joint = j; }
+
+    assign(other: ChainJoint): void {
+        this.joint.assign(other.joint);
+    }
+
+    async deserialize(sceneData: any, loader: any): Promise<void> {
+        const joint: Joint | null = Joint.Factory(sceneData.joint);
+        if (joint && joint instanceof LinkJoint) {
+            this.joint = joint;
+        }
+    }
+
+    async serialize(sceneData: any, writer: any): Promise<void> {
+        await super.serialize(sceneData, writer);
+        sceneData.joint = {};
+        this.joint.serialize(sceneData.joint);
+    }
+}
+
+export class InputChainJoint extends ChainJoint {
+    constructor() {
+        super('InputChainJoint');
+        this.joint.transformOrder = LinkTransformOrder.ROTATE_TRANSLATE;
+    }
+
+    clone(): InputChainJoint {
+        const result = new InputChainJoint();
+        result.assign(this);
+        return result;
+    }
+}
+
+export class OutputChainJoint extends ChainJoint {
+    constructor() {
+        super('OutputChainJoint');
+        this.joint.transformOrder = LinkTransformOrder.TRANSLATE_ROTATE;
+    }
+
+    clone(): OutputChainJoint {
+        const result = new OutputChainJoint();
+        result.assign(this);
+        return result;
+    }
+}

package/src/scene/Component.ts

@@ -1,177 +1,177 @@
-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";
-import Bg2KeyboardEvent from "../app/Bg2KeyboardEvent";
-import Bg2MouseEvent from "../app/Bg2MouseEvent";
-import Bg2TouchEvent from "../app/Bg2TouchEvent";
-import Loader from "../db/Loader";
-
-// 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: Loader): 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: Node): void {
-        // Override in subclasses if needed
-    }
-
-    removedFromNode(node: Node): 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: Bg2KeyboardEvent): void {}
-    keyUp(evt: Bg2KeyboardEvent): void {}
-    mouseUp(evt: Bg2MouseEvent): void {}
-    mouseDown(evt: Bg2MouseEvent): void {}
-    mouseMove(evt: Bg2MouseEvent): void {}
-    mouseOut(evt: Bg2MouseEvent): void {}
-    mouseDrag(evt: Bg2MouseEvent): void {}
-    mouseWheel(evt: Bg2MouseEvent): void {}
-    touchStart(evt: Bg2TouchEvent): void {}
-    touchMove(evt: Bg2TouchEvent): void {}
-    touchEnd(evt: Bg2TouchEvent): void {}
-}
+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";
+import Bg2KeyboardEvent from "../app/Bg2KeyboardEvent";
+import Bg2MouseEvent from "../app/Bg2MouseEvent";
+import Bg2TouchEvent from "../app/Bg2TouchEvent";
+import Loader from "../db/Loader";
+
+// 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: Loader): 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: Node): void {
+        // Override in subclasses if needed
+    }
+
+    removedFromNode(node: Node): 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: Bg2KeyboardEvent): void {}
+    keyUp(evt: Bg2KeyboardEvent): void {}
+    mouseUp(evt: Bg2MouseEvent): void {}
+    mouseDown(evt: Bg2MouseEvent): void {}
+    mouseMove(evt: Bg2MouseEvent): void {}
+    mouseOut(evt: Bg2MouseEvent): void {}
+    mouseDrag(evt: Bg2MouseEvent): void {}
+    mouseWheel(evt: Bg2MouseEvent): void {}
+    touchStart(evt: Bg2TouchEvent): void {}
+    touchMove(evt: Bg2TouchEvent): void {}
+    touchEnd(evt: Bg2TouchEvent): void {}
+}