bg2e-js 2.1.2 → 2.2.0

package/src/db/Bg2LoaderPlugin.ts

@@ -0,0 +1,129 @@
+import LoaderPlugin from "./LoaderPlugin";
+import { ResourceType, getFileName, removeExtension, removeFileName } from "./../tools/Resource";
+import Resource from "../tools/Resource";
+import PolyList from "../base/PolyList";
+import Drawable from "../scene/Drawable";
+import Node from "../scene/Node";
+import Material from "../base/Material";
+import { deserializeComponent } from "../scene/Component";
+
+// @ts-ignore: module not typed
+import Bg2ioWrapper from 'bg2io/Bg2ioBrowser';
+import Loader from './Loader';
+
+let g_bg2Wrapper: any = null;
+
+const bg2ioFactory = async (path?: string | null): Promise<any> => {
+    if (g_bg2Wrapper === null) {
+        const params = path ? { wasmPath: path } : {};
+        g_bg2Wrapper = await Bg2ioWrapper(params);
+        if (!g_bg2Wrapper) {
+            throw new Error("Bg2LoaderPlugin: unable to initialize bg2io library");
+        }
+    }
+    return g_bg2Wrapper;
+}
+
+const createPolyList = (jsonData: any, loader: Loader): Array<{ plist: PolyList, materialData: any }> => {
+    const result = jsonData.polyLists.map((plData: any) => {
+        const plist = new PolyList();
+        const materialData = jsonData.materials.find((m: any) => m.name === plData.matName);
+        plist.name = plData.name
+        plist.visible = plData.visible;
+        if (materialData) {
+            plist.groupName = materialData.groupName || "";
+            plist.enableCullFace = materialData.cullFace;
+        }
+        plist.vertex = plData.vertex;
+        plist.normal = plData.normal;
+        plist.texCoord0 = plData.texCoord0
+        plist.texCoord1 = plData.texCoord1
+        plist.texCoord2 = plData.texCoord2
+        plist.index = plData.index;
+        return { plist, materialData };
+    });
+
+    return result;
+}
+
+const createDrawable = async (jsonData: any, filePath: string, loader: Loader): Promise<Drawable> => {
+    const name = removeExtension(getFileName(filePath));
+    const relativePath = removeFileName(filePath);
+    const drawable = new Drawable(name);
+    for (const item of createPolyList(jsonData, loader)) {
+        const mat = new Material(loader.canvas);
+        await mat.deserialize(item.materialData, relativePath);
+        drawable.addPolyList(item.plist, mat);
+    }
+    //createPolyList(jsonData).forEach(item => {
+    //    const mat = new Material();
+    //    mat.deserialize(item.materialData, relativePath);
+    //    drawable.addPolyList(item.plist, mat);
+    //});
+    return drawable;
+}
+
+const createNode = async (jsonData: any, filePath: string, loader: Loader): Promise<Node> => {
+    const name = removeExtension(getFileName(filePath));
+    const drawable = await createDrawable(jsonData,filePath,loader);
+    const node = new Node(name);
+    node.addComponent(drawable);
+    for (const compData of jsonData.components) {
+        try {
+            const comp = await deserializeComponent(compData,loader);
+            comp && node.addComponent(comp);
+        }
+        catch (err: any) {
+            console.warn(err.message);
+        }
+    }
+    console.log(jsonData);
+    return node;
+}
+
+export default class Bg2LoaderPlugin extends LoaderPlugin {
+    private _bg2ioPath: string | null;
+    private _resource: Resource;
+
+    constructor( { bg2ioPath = null }: { bg2ioPath?: string | null } = {}) {
+        super();
+        this._bg2ioPath = bg2ioPath;
+        this._resource = new Resource();
+    }
+
+    get supportedExtensions(): string[] { return ["bg2","vwglb"]; }
+
+    get resourceTypes(): ResourceType[] {
+        return [
+            ResourceType.PolyList, 
+            ResourceType.Drawable,
+            ResourceType.Node
+        ]; 
+    }
+
+    async load(path: string, resourceType: ResourceType, loader: Loader): Promise<any> {
+        const bg2io = await bg2ioFactory(this._bg2ioPath);
+
+        const buffer = await this._resource.load(path);
+        const jsonData = bg2io.loadBg2FileAsJson(buffer);
+
+        // Compatibility with 1.4 models
+        jsonData.materials.forEach((mat: any) => {
+            if (!mat.type) {
+                mat.type = mat["class"];
+                delete mat["class"];
+            }
+        });
+        
+        switch (resourceType) {
+        case ResourceType.PolyList:
+            return createPolyList(jsonData,loader).map(item => item.plist);
+        case ResourceType.Drawable:
+            return createDrawable(jsonData,path,loader);
+        case ResourceType.Node:
+            return await createNode(jsonData,path,loader);
+        default:
+            throw new Error(`Bg2LoaderPlugin.load() unexpected resource type received: ${resourceType}`);
+        }
+    }
+}

package/src/db/DBPluginApi.ts

@@ -0,0 +1,48 @@
+import { getExtension, ResourceType } from '../tools/Resource';
+import LoaderPlugin from './LoaderPlugin';
+
+export const PluginOperationType = {
+    Read: "read",
+    Write: "write"
+} as const;
+
+export type PluginOperationTypeValue = typeof PluginOperationType[keyof typeof PluginOperationType];
+
+export interface PluginDatabase {
+    operationType: PluginOperationTypeValue;
+    plugins: Partial<Record<ResourceType, LoaderPlugin[]>>;
+}
+
+export const createPluginDatabase = (operationType: PluginOperationTypeValue): PluginDatabase => {
+    return {
+        operationType,
+        plugins: {}
+    }
+}
+
+export const registerPluginInDatabase = (pluginInstance: LoaderPlugin, pluginDatabase: PluginDatabase): void => {
+    pluginInstance.resourceTypes.forEach(type => {
+        pluginDatabase.plugins[type] = pluginDatabase.plugins[type] || [];
+        pluginDatabase.plugins[type]!.push(pluginInstance);
+    });
+}
+
+export const getPluginFromDatabase = function(path: string, type: ResourceType, pluginDatabase: PluginDatabase): LoaderPlugin {
+    const ext = getExtension(path);
+    const extCheck = new RegExp(ext, "i");
+    const errMsg = `Could not find a plugin to ${pluginDatabase.operationType} file '${path}' of type '${type}'.`;
+
+    const plugins = pluginDatabase.plugins[type];
+    if (!plugins) {
+        throw new Error(errMsg);
+    }
+    else {
+        for (const plugin of plugins) {
+            if (plugin.supportedExtensions.find(e => extCheck.test(e))) {
+                return plugin;
+            }
+        }
+        throw new Error(errMsg);
+    }
+}
+

package/src/db/Loader.ts

@@ -0,0 +1,116 @@
+
+import { isAbsolute, jointUrl, ResourceType } from '../tools/Resource';
+import { 
+    PluginOperationType,
+    createPluginDatabase, 
+    registerPluginInDatabase, 
+    getPluginFromDatabase 
+} from './DBPluginApi';
+import Canvas from '../app/Canvas';
+import LoaderPlugin from './LoaderPlugin';
+import PolyList from '../base/PolyList';
+import Texture from '../base/Texture';
+
+const g_loadPluginDatabase = createPluginDatabase(PluginOperationType.Read);
+
+type ResourceCache = {
+    [ResourceType.PolyList]: Record<string, PolyList>;
+    [ResourceType.Drawable]: Record<string, any>;
+    [ResourceType.Node]: Record<string, any>;
+    [ResourceType.Texture]: Record<string, Texture>;
+    [ResourceType.Material]: Record<string, any>;
+}
+
+export const registerLoaderPlugin = (pluginInstance: LoaderPlugin): void => {
+    pluginInstance.dependencies.forEach(dep => registerPluginInDatabase(dep, g_loadPluginDatabase));
+    registerPluginInDatabase(pluginInstance, g_loadPluginDatabase);
+}
+
+export const getLoaderPlugin = (path: string, type: ResourceType): LoaderPlugin => {
+    return getPluginFromDatabase(path, type, g_loadPluginDatabase);
+}
+
+const getClearedCache = (): ResourceCache => {
+    return {
+        [ResourceType.PolyList]: {},
+        [ResourceType.Drawable]: {},
+        [ResourceType.Node]: {},
+        [ResourceType.Texture]: {},
+        [ResourceType.Material]: {}
+    }
+}
+
+export default class Loader {
+    private _canvas: Canvas;
+    private _cache: ResourceCache;
+    private _currentPath: string;
+
+    constructor(canvas?: Canvas | null) {
+        this._canvas = canvas || Canvas.FirstCanvas();
+        this._cache = getClearedCache();
+        this._currentPath = "";
+    }
+
+    get canvas(): Canvas {
+        return this._canvas;
+    }
+
+    get currentPath(): string {
+        return this._currentPath;
+    }
+
+    set currentPath(p: string) {
+        this._currentPath = p;
+    }
+
+    clearCache(): void {
+        this._cache = getClearedCache();
+    }
+
+    findCache(path: string, type: ResourceType): any {
+        return this._cache[type] && this._cache[type][path];
+    }
+
+    async loadResource(path: string, type: ResourceType): Promise<any> {
+        if (!isAbsolute(path) && this.currentPath !== "") {
+            path = jointUrl(this.currentPath, path);
+        }
+        let result = this.findCache(path, type);
+        if (!result) {
+            const plugin = getLoaderPlugin(path, type);
+            result = await plugin.load(path, type, this);
+        }
+        return result;
+    }
+
+    async loadResourceBuffer(buffer: ArrayBuffer, format: string, dependencies: string[], type: ResourceType): Promise<any> {
+        const plugin = getLoaderPlugin(`file.${ format }`, type);
+        const result = await plugin.loadBuffer(buffer, format, dependencies, type, this);
+        return result;
+    }
+
+    async loadPolyList(path: string): Promise<PolyList> {
+        return await this.loadResource(path, ResourceType.PolyList);
+    }
+
+    async loadDrawable(path: string): Promise<any> {
+        return await this.loadResource(path, ResourceType.Drawable);
+    }
+
+    async loadDrawableBuffer(buffer: ArrayBuffer, format: string, dependencies: string[]): Promise<any> {
+        return await this.loadResourceBuffer(buffer, format, dependencies, ResourceType.Drawable);
+    }
+
+    async loadNode(path: string): Promise<any> {
+        return await this.loadResource(path, ResourceType.Node);
+    }
+
+    async loadTexture(path: string): Promise<Texture> {
+        return await this.loadResource(path, ResourceType.Texture);
+    }
+
+    async loadMaterial(path: string): Promise<any> {
+        return await this.loadResource(path, ResourceType.Material);
+    }
+}
+

package/src/db/LoaderPlugin.ts

@@ -0,0 +1,34 @@
+import { ResourceType } from "../tools/Resource.js";
+
+export default class LoaderPlugin {
+    // Returns an array of valid file extensions for this plugin
+    //  example: ["obj","dae"]
+    get supportedExtensions(): string[] {
+        throw new Error("LoaderPlugin.supportedExtensions: attribute not implemented");
+    }
+
+    // Returns the resource types that the loader plugin can handle
+    // example: [ ResourceType.PolyList, ResourceType.Scene ]
+    get resourceTypes(): ResourceType[] {
+        throw new Error("LoaderPlugin.resourceTypes: attribute not implemented");
+    }
+
+    // Returns the resource loaded with the path. The resource type must be one
+    // of the specified in the resourceTypes attribute
+    async load(path: string, type: ResourceType, loader: any): Promise<any> {
+        throw new Error("LoaderPlugin.load(): method not implemented");
+    }
+
+    async loadBuffer(buffer: ArrayBuffer, format: string, dependencies: string[], type: ResourceType, loader: any): Promise<any> {
+        throw new Error("LoaderPlugin.loadBuffer(): method not implemented");
+    }
+
+    // Returns an array of LoaderPlugin objects that are necessary for this plugin to work.
+    get dependencies(): LoaderPlugin[] {
+        return [];
+    }
+
+    async write(path: string, data: any, type: ResourceType, writer: any): Promise<any> {
+        throw new Error("LoaderPlugin.write(): method not implemented");
+    }
+}

package/src/db/MtlParser.ts

@@ -0,0 +1,7 @@
+
+
+export default class MtlParser {
+    constructor(mtlText: string) {
+        
+    }
+}

package/src/db/ObjLoaderPlugin.ts

@@ -0,0 +1,55 @@
+import LoaderPlugin from './LoaderPlugin';
+import Resource, { getFileName, removeExtension, removeFileName, ResourceType } from './../tools/Resource';
+import ObjParser from './ObjParser';
+import Drawable from '../scene/Drawable';
+import Material from '../base/Material';
+import PolyList from '../base/PolyList';
+import Loader from './Loader';
+
+const buildDrawable = (polyListArray: PolyList[], mtlData: any, filePath: string): Drawable => {
+    const name = removeExtension(getFileName(filePath));
+    const drawable = new Drawable(name);
+
+    polyListArray.forEach((plist: PolyList) => {
+        // TODO: set mtl data
+        const mat = new Material();
+        drawable.addPolyList(plist,mat);
+    });
+
+    return drawable;
+}
+
+export default class ObjLoaderPlugin extends LoaderPlugin {
+    private _resource: Resource;
+
+    constructor() {
+        super();
+        this._resource = new Resource();
+    }
+
+    get supportedExtensions(): string[] { return ['obj']; }
+
+    get resourceTypes(): ResourceType[] {
+        return [
+            ResourceType.PolyList,
+            ResourceType.Drawable
+        ];
+    }
+
+    async load(path: string, resourceType: ResourceType, loader: Loader): Promise<PolyList[] | Drawable> {
+        const objText = await this._resource.load(path);
+        const parser = new ObjParser(objText);
+
+        // TODO: load material from mtl file
+        // const relativePath = removeFileName(filePath);
+
+        switch (resourceType) {
+        case ResourceType.PolyList:
+            return parser.polyListArray;
+        case ResourceType.Drawable:
+            return buildDrawable(parser.polyListArray, null, path);
+        default:
+            throw new Error(`ObjLoaderPlugin.load() unexpected resource type received: ${resourceType}`);
+        }
+    }
+}

package/src/db/ObjParser.ts

@@ -0,0 +1,252 @@
+
+import PolyList from "../base/PolyList";
+
+function parseM(this: ObjParser, line: string) {
+    // mtllib
+    let res = /mtllib\s+(.*)/.exec(line);
+    if (res) {
+        this._mtlLib = res[1];
+    }
+}
+
+function parseG(this: ObjParser, line: string) {
+    // g
+    let res = /g\s+(.*)/.exec(line);
+    if (res && this._currentPlist) {
+        this._currentPlist.name = res[1];
+    }
+}
+
+function parseU(this: ObjParser, line: string) {
+    // usemtl
+    let res = /usemtl\s+(.*)/.exec(line);
+    if (res && this._currentPlist) {
+        // Temporarily store the material name in a custom property
+        (this._currentPlist as any)._matName = res[1];
+        if (this._currentPlist.name=="") {
+            this._currentPlist.name = res[1];
+        }
+    }
+}
+
+function parseS(this: ObjParser, line: string) {
+    // s
+    let res = /s\s+(.*)/.exec(line);
+    if (res) {
+        // TODO: Do something with smoothing groups
+    }
+}
+
+function addPoint(this: ObjParser, pointData: any) {
+    if (!this._currentPlist) return;
+    this._currentPlist.vertex.push(pointData.vertex[0],pointData.vertex[1],pointData.vertex[2]);
+    if (pointData.normal) {
+        this._currentPlist.normal.push(pointData.normal[0],pointData.normal[1],pointData.normal[2]);
+    }
+    if (pointData.tex) {
+        this._currentPlist.texCoord0.push(pointData.tex[0],pointData.tex[1]);
+    }
+    this._currentPlist.index.push(this._currentPlist.index.length);
+}
+
+function isValid(point: any): boolean {
+    return point && point.vertex && point.tex && point.normal;
+}
+
+function addPolygon(this: ObjParser, polygonData: any[]) {
+    let currentVertex = 0;
+    let sides = polygonData.length;
+    if (sides<3) return;
+    while (currentVertex<sides) {
+        let i0 = currentVertex;
+        let i1 = currentVertex + 1;
+        let i2 = currentVertex + 2;
+        if (i2==sides) {
+            i2 = 0;
+        }
+        else if (i1==sides) {
+            i1 = 0;
+            i2 = 2;
+        }
+
+        let p0 = polygonData[i0];
+        let p1 = polygonData[i1];
+        let p2 = polygonData[i2];
+
+        if (isValid(p0) && isValid(p1) && isValid(p2)) {
+            addPoint.apply(this,[p0]);
+            addPoint.apply(this,[p1]);
+            addPoint.apply(this,[p2]);
+        }
+        else {
+            console.warn("Invalid point data found loading OBJ file");
+        }
+        currentVertex+=3;
+    }
+}
+
+function parseF(this: ObjParser, line: string) {
+    // f
+    this._addPlist = true;
+    let res = /f\s+(.*)/.exec(line);
+    if (res) {
+        let params = res[1];
+        let vtnRE = /([\d\-]+)\/([\d\-]*)\/([\d\-]*)/g;
+        if (params.indexOf('/')==-1) {
+            let vRE = /([\d\-]+)/g;
+        }
+        let polygon = [];
+        while ( (res=vtnRE.exec(params)) ) {
+            let iV = Number(res[1]);
+            let iN = res[3] ? Number(res[3]):null;
+            let iT = res[2] ? Number(res[2]):null;
+            iV = iV<0 ? this._vertexArray.length + iV : iV - 1;
+            
+            let v = this._vertexArray[iV];
+            let n: number[] | null = null;
+            let t: number[] | null = null;
+
+            if (iN !== null) {
+                iN = iN<0 ? this._normalArray.length + iN : (iN===null ? null : iN - 1);
+                n = iN!==null ? this._normalArray[iN] : null;
+            }
+            if (iT !== null) {
+                iT = iT<0 ? this._texCoordArray.length + iT : (iT===null ? null : iT - 1);
+                t = iT!==null ? this._texCoordArray[iT] : null;
+            }
+
+            polygon.push({
+                vertex:v,
+                normal:n,
+                tex:t
+            });
+        }
+        addPolygon.apply(this,[polygon]);
+    }
+}
+
+function parseO(this: ObjParser, line: string) {
+    // o
+    let res = /s\s+(.*)/.exec(line);
+    if (res && this._currentPlist?.name=="") {
+        this._currentPlist.name = res[1];
+    }
+}
+
+function checkAddPlist(this: ObjParser) {
+    if (this._addPlist) {
+        if (this._currentPlist) {
+            this._plistArray.push(this._currentPlist);
+        }
+        this._currentPlist = new PolyList();
+        this._addPlist = false;
+    }
+}
+
+function loadObjData(this: ObjParser) {
+    let lines = this._textData.split('\n');
+    let multiLine = "";
+    lines.forEach(line => {
+        line = line.trim();
+
+        // This section controls the break line character \
+        // to concatenate this new line with the next one
+        if (multiLine) {
+            line = multiLine + line;
+        }
+        if (line[line.length - 1] === '\\') {
+            line = line.substring(0,line.length - 1);
+            multiLine += line;
+            return;
+        }
+        else {
+            multiLine = "";
+        }
+
+        // First optimization: parse the first character and string length
+        if (line.length>1 && line[0] !== '#') {
+            // Second optimization: parse by the first character
+            switch (line[0]) {
+            case 'v':
+                let res = /v\s+([\d\.\-e]+)\s+([\d\.\-e]+)\s+([\d\.\-e]+)/.exec(line);
+                if (res) {
+                    this._vertexArray.push(
+                        [ Number(res[1]), Number(res[2]), Number(res[3]) ]
+                    );
+                }
+                else if ( (res = /vn\s+([\d\.\-e]+)\s+([\d\.\-e]+)\s+([\d\.\-e]+)/.exec(line)) ) {
+                    this._normalArray.push(
+                        [ Number(res[1]), Number(res[2]), Number(res[3]) ]
+                    );
+                }
+                else if ( (res = /vt\s+([\d\.\-e]+)\s+([\d\.\-e]+)/.exec(line)) ) {
+                    this._texCoordArray.push(
+                        [ Number(res[1]), Number(res[2]) ]
+                    );
+                }
+                else {
+                    console.warn("Error parsing line " + line);
+                }
+                break;
+            case 'm':
+                checkAddPlist.apply(this);
+                parseM.apply(this,[line]);
+                break;
+            case 'g':
+                checkAddPlist.apply(this);
+                parseG.apply(this,[line]);
+                break;
+            case 'u':
+                checkAddPlist.apply(this);
+                parseU.apply(this,[line]);
+                break;
+            case 's':
+                parseS.apply(this,[line]);
+                break;
+            case 'f':
+                parseF.apply(this,[line]);
+                break;
+            case 'o':
+                checkAddPlist.apply(this);
+                parseO.apply(this,[line]);
+                break;
+            }
+        }
+    });
+
+    if (this._currentPlist && this._addPlist) {
+        this._plistArray.push(this._currentPlist);
+    }
+}
+
+export default class ObjParser {
+    _textData: string;
+    _plistArray: PolyList[];
+    _vertexArray: number[][];
+    _normalArray: number[][];
+    _texCoordArray: number[][];
+    _mtlLib: string;
+    _currentPlist?: PolyList | null;
+    _addPlist: boolean;
+
+    constructor(objText: string) {
+        this._textData = objText;
+
+        this._plistArray = [];
+
+        this._vertexArray = [];
+        this._normalArray = [];
+        this._texCoordArray = [];
+
+        this._mtlLib = "";
+
+        this._addPlist = true;
+
+        loadObjData.apply(this);
+    }
+
+
+    get polyListArray() {
+        return this._plistArray;
+    }
+}

package/src/db/ObjWriterPlugin.ts

@@ -0,0 +1,19 @@
+import { ResourceType } from "../tools/Resource";
+import WriterPlugin from "./WriterPlugin";
+import Writer from "./Writer";
+
+export default class ObjWriterPlugin extends WriterPlugin {
+    get supportedExtensions(): string[] {
+        return ["obj"];
+    }
+
+    get resourceTypes(): ResourceType[] {
+        return [ResourceType.Drawable];
+    }
+
+    async write(path: string, data: any, type: ResourceType, writer: Writer): Promise<void> {
+        console.log(path);
+        console.log(data);
+        console.log(type);
+    }
+}