@xeokit/xeokit-sdk 2.5.2-beta-10 → 2.5.2-beta-13

package/src/src/plugins/OBJLoaderPlugin/OBJSceneGraphLoader.js

@@ -0,0 +1,777 @@
+import {Mesh} from "../../viewer/scene/mesh/Mesh.js";
+import {ReadableGeometry} from "../../viewer/scene/geometry/ReadableGeometry.js";
+import {PhongMaterial} from "../../viewer/scene/materials/PhongMaterial.js";
+import {Texture} from "../../viewer/scene/materials/Texture.js";
+import {core} from "../../viewer/scene/core.js";
+import {worldToRTCPositions} from "../../viewer/scene/math/rtcCoords.js";
+import {math} from "../../viewer/scene/math/math.js";
+
+const tempVec3a = math.vec3();
+
+/**
+ * @private
+ */
+class OBJSceneGraphLoader {
+
+    /**
+     * Loads OBJ and MTL from file(s) into a {@link Node}.
+     *
+     * @static
+     * @param {Node} modelNode Node to load into.
+     * @param {String} src Path to OBJ file.
+     * @param {Object} params Loading options.
+     */
+    load(modelNode, src, params = {}) {
+
+        var spinner = modelNode.scene.canvas.spinner;
+        spinner.processes++;
+
+        loadOBJ(modelNode, src, function (state) {
+            loadMTLs(modelNode, state, function () {
+
+                createMeshes(modelNode, state);
+
+                spinner.processes--;
+
+                core.scheduleTask(function () {
+                    modelNode.fire("loaded", true, false);
+                });
+            });
+        });
+    }
+
+    /**
+     * Parses OBJ and MTL text strings into a {@link Node}.
+     *
+     * @static
+     * @param {Node} modelNode Node to load into.
+     * @param {String} objText OBJ text string.
+     * @param {String} [mtlText] MTL text string.
+     * @param {String} [basePath] Base path for external resources.
+     */
+    parse(modelNode, objText, mtlText, basePath) {
+        if (!objText) {
+            this.warn("load() param expected: objText");
+            return;
+        }
+        var state = parseOBJ(modelNode, objText, null);
+        if (mtlText) {
+            parseMTL(modelNode, mtlText, basePath);
+        }
+        createMeshes(modelNode, state);
+        modelNode.src = null;
+        modelNode.fire("loaded", true, false);
+    }
+}
+
+//--------------------------------------------------------------------------------------------
+// Loads OBJ
+//
+// Parses OBJ into an intermediate state object. The object will contain geometry data
+// and material IDs from which meshes can be created later. The object will also
+// contain a list of filenames of the MTL files referenced by the OBJ, is any.
+//
+// Originally based on the THREE.js OBJ and MTL loaders:
+//
+// https://github.com/mrdoob/three.js/blob/dev/examples/js/loaders/OBJLoader.js
+// https://github.com/mrdoob/three.js/blob/dev/examples/js/loaders/MTLLoader.js
+//--------------------------------------------------------------------------------------------
+
+var loadOBJ = function (modelNode, url, ok) {
+    loadFile(url, function (text) {
+            var state = parseOBJ(modelNode, text, url);
+            ok(state);
+        },
+        function (error) {
+            modelNode.error(error);
+        });
+};
+
+var parseOBJ = (function () {
+
+    const regexp = {
+        // v float float float
+        vertex_pattern: /^v\s+([\d|\.|\+|\-|e|E]+)\s+([\d|\.|\+|\-|e|E]+)\s+([\d|\.|\+|\-|e|E]+)/,
+        // vn float float float
+        normal_pattern: /^vn\s+([\d|\.|\+|\-|e|E]+)\s+([\d|\.|\+|\-|e|E]+)\s+([\d|\.|\+|\-|e|E]+)/,
+        // vt float float
+        uv_pattern: /^vt\s+([\d|\.|\+|\-|e|E]+)\s+([\d|\.|\+|\-|e|E]+)/,
+        // f vertex vertex vertex
+        face_vertex: /^f\s+(-?\d+)\s+(-?\d+)\s+(-?\d+)(?:\s+(-?\d+))?/,
+        // f vertex/uv vertex/uv vertex/uv
+        face_vertex_uv: /^f\s+(-?\d+)\/(-?\d+)\s+(-?\d+)\/(-?\d+)\s+(-?\d+)\/(-?\d+)(?:\s+(-?\d+)\/(-?\d+))?/,
+        // f vertex/uv/normal vertex/uv/normal vertex/uv/normal
+        face_vertex_uv_normal: /^f\s+(-?\d+)\/(-?\d+)\/(-?\d+)\s+(-?\d+)\/(-?\d+)\/(-?\d+)\s+(-?\d+)\/(-?\d+)\/(-?\d+)(?:\s+(-?\d+)\/(-?\d+)\/(-?\d+))?/,
+        // f vertex//normal vertex//normal vertex//normal
+        face_vertex_normal: /^f\s+(-?\d+)\/\/(-?\d+)\s+(-?\d+)\/\/(-?\d+)\s+(-?\d+)\/\/(-?\d+)(?:\s+(-?\d+)\/\/(-?\d+))?/,
+        // o object_name | g group_name
+        object_pattern: /^[og]\s*(.+)?/,
+        // s boolean
+        smoothing_pattern: /^s\s+(\d+|on|off)/,
+        // mtllib file_reference
+        material_library_pattern: /^mtllib /,
+        // usemtl material_name
+        material_use_pattern: /^usemtl /
+    };
+
+    return function (modelNode, text, url) {
+
+        url = url || "";
+
+        var state = {
+            src: url,
+            basePath: getBasePath(url),
+            objects: [],
+            object: {},
+            positions: [],
+            normals: [],
+            uv: [],
+            materialLibraries: {}
+        };
+
+        startObject(state, "", false);
+
+        // Parts of this parser logic are derived from the THREE.js OBJ loader:
+        // https://github.com/mrdoob/three.js/blob/dev/examples/js/loaders/OBJLoader.js
+
+        if (text.indexOf('\r\n') !== -1) {
+            // This is faster than String.split with regex that splits on both
+            text = text.replace('\r\n', '\n');
+        }
+
+        var lines = text.split('\n');
+        var line = '', lineFirstChar = '', lineSecondChar = '';
+        var lineLength = 0;
+        var result = [];
+
+        // Faster to just trim left side of the line. Use if available.
+        var trimLeft = (typeof ''.trimLeft === 'function');
+
+        for (var i = 0, l = lines.length; i < l; i++) {
+
+            line = lines[i];
+
+            line = trimLeft ? line.trimLeft() : line.trim();
+
+            lineLength = line.length;
+
+            if (lineLength === 0) {
+                continue;
+            }
+
+            lineFirstChar = line.charAt(0);
+
+            if (lineFirstChar === '#') {
+                continue;
+            }
+
+            if (lineFirstChar === 'v') {
+
+                lineSecondChar = line.charAt(1);
+
+                if (lineSecondChar === ' ' && (result = regexp.vertex_pattern.exec(line)) !== null) {
+
+                    // 0                  1      2      3
+                    // ['v 1.0 2.0 3.0', '1.0', '2.0', '3.0']
+
+                    state.positions.push(
+                        parseFloat(result[1]),
+                        parseFloat(result[2]),
+                        parseFloat(result[3])
+                    );
+
+                } else if (lineSecondChar === 'n' && (result = regexp.normal_pattern.exec(line)) !== null) {
+
+                    // 0                   1      2      3
+                    // ['vn 1.0 2.0 3.0', '1.0', '2.0', '3.0']
+
+                    state.normals.push(
+                        parseFloat(result[1]),
+                        parseFloat(result[2]),
+                        parseFloat(result[3])
+                    );
+
+                } else if (lineSecondChar === 't' && (result = regexp.uv_pattern.exec(line)) !== null) {
+
+                    // 0               1      2
+                    // ['vt 0.1 0.2', '0.1', '0.2']
+
+                    state.uv.push(
+                        parseFloat(result[1]),
+                        parseFloat(result[2])
+                    );
+
+                } else {
+
+                    modelNode.error('Unexpected vertex/normal/uv line: \'' + line + '\'');
+                    return;
+                }
+
+            } else if (lineFirstChar === 'f') {
+
+                if ((result = regexp.face_vertex_uv_normal.exec(line)) !== null) {
+
+                    // f vertex/uv/normal vertex/uv/normal vertex/uv/normal
+                    // 0                        1    2    3    4    5    6    7    8    9   10         11         12
+                    // ['f 1/1/1 2/2/2 3/3/3', '1', '1', '1', '2', '2', '2', '3', '3', '3', undefined, undefined, undefined]
+
+                    addFace(state,
+                        result[1], result[4], result[7], result[10],
+                        result[2], result[5], result[8], result[11],
+                        result[3], result[6], result[9], result[12]
+                    );
+
+                } else if ((result = regexp.face_vertex_uv.exec(line)) !== null) {
+
+                    // f vertex/uv vertex/uv vertex/uv
+                    // 0                  1    2    3    4    5    6   7          8
+                    // ['f 1/1 2/2 3/3', '1', '1', '2', '2', '3', '3', undefined, undefined]
+
+                    addFace(state,
+                        result[1], result[3], result[5], result[7],
+                        result[2], result[4], result[6], result[8]
+                    );
+
+                } else if ((result = regexp.face_vertex_normal.exec(line)) !== null) {
+
+                    // f vertex//normal vertex//normal vertex//normal
+                    // 0                     1    2    3    4    5    6   7          8
+                    // ['f 1//1 2//2 3//3', '1', '1', '2', '2', '3', '3', undefined, undefined]
+
+                    addFace(state,
+                        result[1], result[3], result[5], result[7],
+                        undefined, undefined, undefined, undefined,
+                        result[2], result[4], result[6], result[8]
+                    );
+
+                } else if ((result = regexp.face_vertex.exec(line)) !== null) {
+
+                    // f vertex vertex vertex
+                    // 0            1    2    3   4
+                    // ['f 1 2 3', '1', '2', '3', undefined]
+
+                    addFace(state, result[1], result[2], result[3], result[4]);
+                } else {
+                    modelNode.error('Unexpected face line: \'' + line + '\'');
+                    return;
+                }
+
+            } else if (lineFirstChar === 'l') {
+
+                var lineParts = line.substring(1).trim().split(' ');
+                var lineVertices = [], lineUVs = [];
+
+                if (line.indexOf('/') === -1) {
+
+                    lineVertices = lineParts;
+
+                } else {
+                    for (var li = 0, llen = lineParts.length; li < llen; li++) {
+                        var parts = lineParts[li].split('/');
+                        if (parts[0] !== '') {
+                            lineVertices.push(parts[0]);
+                        }
+                        if (parts[1] !== '') {
+                            lineUVs.push(parts[1]);
+                        }
+                    }
+                }
+                addLineGeometry(state, lineVertices, lineUVs);
+
+            } else if ((result = regexp.object_pattern.exec(line)) !== null) {
+
+                // o object_name
+                // or
+                // g group_name
+
+                var id = result[0].substr(1).trim();
+                startObject(state, id, true);
+
+            } else if (regexp.material_use_pattern.test(line)) {
+
+                // material
+
+                var id = line.substring(7).trim();
+                state.object.material.id = id;
+
+            } else if (regexp.material_library_pattern.test(line)) {
+
+                // mtl file
+
+                state.materialLibraries[line.substring(7).trim()] = true;
+
+            } else if ((result = regexp.smoothing_pattern.exec(line)) !== null) {
+
+                // smooth shading
+
+                var value = result[1].trim().toLowerCase();
+                state.object.material.smooth = (value === '1' || value === 'on');
+
+            } else {
+
+                // Handle null terminated files without exception
+                if (line === '\0') {
+                    continue;
+                }
+
+                modelNode.error('Unexpected line: \'' + line + '\'');
+                return;
+            }
+        }
+
+        return state;
+    };
+
+    function getBasePath(src) {
+        var n = src.lastIndexOf('/');
+        return (n === -1) ? src : src.substring(0, n + 1);
+    }
+
+    function startObject(state, id, fromDeclaration) {
+        if (state.object && state.object.fromDeclaration === false) {
+            state.object.id = id;
+            state.object.fromDeclaration = (fromDeclaration !== false);
+            return;
+        }
+        state.object = {
+            id: id || '',
+            geometry: {
+                positions: [],
+                normals: [],
+                uv: []
+            },
+            material: {
+                id: '',
+                smooth: true
+            },
+            fromDeclaration: (fromDeclaration !== false)
+        };
+        state.objects.push(state.object);
+    }
+
+    function parseVertexIndex(value, len) {
+        var index = parseInt(value, 10);
+        return (index >= 0 ? index - 1 : index + len / 3) * 3;
+    }
+
+    function parseNormalIndex(value, len) {
+        var index = parseInt(value, 10);
+        return (index >= 0 ? index - 1 : index + len / 3) * 3;
+    }
+
+    function parseUVIndex(value, len) {
+        var index = parseInt(value, 10);
+        return (index >= 0 ? index - 1 : index + len / 2) * 2;
+    }
+
+    function addVertex(state, a, b, c) {
+        var src = state.positions;
+        var dst = state.object.geometry.positions;
+        dst.push(src[a + 0]);
+        dst.push(src[a + 1]);
+        dst.push(src[a + 2]);
+        dst.push(src[b + 0]);
+        dst.push(src[b + 1]);
+        dst.push(src[b + 2]);
+        dst.push(src[c + 0]);
+        dst.push(src[c + 1]);
+        dst.push(src[c + 2]);
+    }
+
+    function addVertexLine(state, a) {
+        var src = state.positions;
+        var dst = state.object.geometry.positions;
+        dst.push(src[a + 0]);
+        dst.push(src[a + 1]);
+        dst.push(src[a + 2]);
+    }
+
+    function addNormal(state, a, b, c) {
+        var src = state.normals;
+        var dst = state.object.geometry.normals;
+        dst.push(src[a + 0]);
+        dst.push(src[a + 1]);
+        dst.push(src[a + 2]);
+        dst.push(src[b + 0]);
+        dst.push(src[b + 1]);
+        dst.push(src[b + 2]);
+        dst.push(src[c + 0]);
+        dst.push(src[c + 1]);
+        dst.push(src[c + 2]);
+    }
+
+    function addUV(state, a, b, c) {
+        var src = state.uv;
+        var dst = state.object.geometry.uv;
+        dst.push(src[a + 0]);
+        dst.push(src[a + 1]);
+        dst.push(src[b + 0]);
+        dst.push(src[b + 1]);
+        dst.push(src[c + 0]);
+        dst.push(src[c + 1]);
+    }
+
+    function addUVLine(state, a) {
+        var src = state.uv;
+        var dst = state.object.geometry.uv;
+        dst.push(src[a + 0]);
+        dst.push(src[a + 1]);
+    }
+
+    function addFace(state, a, b, c, d, ua, ub, uc, ud, na, nb, nc, nd) {
+        var vLen = state.positions.length;
+        var ia = parseVertexIndex(a, vLen);
+        var ib = parseVertexIndex(b, vLen);
+        var ic = parseVertexIndex(c, vLen);
+        var id;
+        if (d === undefined) {
+            addVertex(state, ia, ib, ic);
+
+        } else {
+            id = parseVertexIndex(d, vLen);
+            addVertex(state, ia, ib, id);
+            addVertex(state, ib, ic, id);
+        }
+
+        if (ua !== undefined) {
+
+            var uvLen = state.uv.length;
+
+            ia = parseUVIndex(ua, uvLen);
+            ib = parseUVIndex(ub, uvLen);
+            ic = parseUVIndex(uc, uvLen);
+
+            if (d === undefined) {
+                addUV(state, ia, ib, ic);
+
+            } else {
+                id = parseUVIndex(ud, uvLen);
+                addUV(state, ia, ib, id);
+                addUV(state, ib, ic, id);
+            }
+        }
+
+        if (na !== undefined) {
+
+            // Normals are many times the same. If so, skip function call and parseInt.
+
+            var nLen = state.normals.length;
+
+            ia = parseNormalIndex(na, nLen);
+            ib = na === nb ? ia : parseNormalIndex(nb, nLen);
+            ic = na === nc ? ia : parseNormalIndex(nc, nLen);
+
+            if (d === undefined) {
+                addNormal(state, ia, ib, ic);
+
+            } else {
+
+                id = parseNormalIndex(nd, nLen);
+                addNormal(state, ia, ib, id);
+                addNormal(state, ib, ic, id);
+            }
+        }
+    }
+
+    function addLineGeometry(state, positions, uv) {
+
+        state.object.geometry.type = 'Line';
+
+        var vLen = state.positions.length;
+        var uvLen = state.uv.length;
+
+        for (var vi = 0, l = positions.length; vi < l; vi++) {
+            addVertexLine(state, parseVertexIndex(positions[vi], vLen));
+        }
+
+        for (var uvi = 0, uvl = uv.length; uvi < uvl; uvi++) {
+            addUVLine(state, parseUVIndex(uv[uvi], uvLen));
+        }
+    }
+})();
+
+//--------------------------------------------------------------------------------------------
+// Loads MTL files listed in parsed state
+//--------------------------------------------------------------------------------------------
+
+function loadMTLs(modelNode, state, ok) {
+    var basePath = state.basePath;
+    var srcList = Object.keys(state.materialLibraries);
+    var numToLoad = srcList.length;
+    for (var i = 0, len = numToLoad; i < len; i++) {
+        loadMTL(modelNode, basePath, basePath + srcList[i], function () {
+            if (--numToLoad === 0) {
+                ok();
+            }
+        });
+    }
+}
+
+//--------------------------------------------------------------------------------------------
+// Loads an MTL file
+//--------------------------------------------------------------------------------------------
+
+var loadMTL = function (modelNode, basePath, src, ok) {
+    loadFile(src, function (text) {
+            parseMTL(modelNode, text, basePath);
+            ok();
+        },
+        function (error) {
+            modelNode.error(error);
+            ok();
+        });
+};
+
+var parseMTL = (function () {
+
+    var delimiter_pattern = /\s+/;
+
+    return function (modelNode, mtlText, basePath) {
+
+        var lines = mtlText.split('\n');
+        var materialCfg = {
+            id: "Default"
+        };
+        var needCreate = false;
+        var line;
+        var pos;
+        var key;
+        var value;
+        var alpha;
+
+        basePath = basePath || "";
+
+        for (var i = 0; i < lines.length; i++) {
+
+            line = lines[i].trim();
+
+            if (line.length === 0 || line.charAt(0) === '#') { // Blank line or comment ignore
+                continue;
+            }
+
+            pos = line.indexOf(' ');
+
+            key = (pos >= 0) ? line.substring(0, pos) : line;
+            key = key.toLowerCase();
+
+            value = (pos >= 0) ? line.substring(pos + 1) : '';
+            value = value.trim();
+
+            switch (key.toLowerCase()) {
+
+                case "newmtl": // New material
+                    //if (needCreate) {
+                    createMaterial(modelNode, materialCfg);
+                    //}
+                    materialCfg = {
+                        id: value
+                    };
+                    needCreate = true;
+                    break;
+
+                case 'ka':
+                    materialCfg.ambient = parseRGB(value);
+                    break;
+
+                case 'kd':
+                    materialCfg.diffuse = parseRGB(value);
+                    break;
+
+                case 'ks':
+                    materialCfg.specular = parseRGB(value);
+                    break;
+
+                case 'map_kd':
+                    if (!materialCfg.diffuseMap) {
+                        materialCfg.diffuseMap = createTexture(modelNode, basePath, value, "sRGB");
+                    }
+                    break;
+
+                case 'map_ks':
+                    if (!materialCfg.specularMap) {
+                        materialCfg.specularMap = createTexture(modelNode, basePath, value, "linear");
+                    }
+                    break;
+
+                case 'map_bump':
+                case 'bump':
+                    if (!materialCfg.normalMap) {
+                        materialCfg.normalMap = createTexture(modelNode, basePath, value);
+                    }
+                    break;
+
+                case 'ns':
+                    materialCfg.shininess = parseFloat(value);
+                    break;
+
+                case 'd':
+                    alpha = parseFloat(value);
+                    if (alpha < 1) {
+                        materialCfg.alpha = alpha;
+                        materialCfg.alphaMode = "blend";
+                    }
+                    break;
+
+                case 'tr':
+                    alpha = parseFloat(value);
+                    if (alpha > 0) {
+                        materialCfg.alpha = 1 - alpha;
+                        materialCfg.alphaMode = "blend";
+                    }
+                    break;
+
+                default:
+                // modelNode.error("Unrecognized token: " + key);
+            }
+        }
+
+        if (needCreate) {
+            createMaterial(modelNode, materialCfg);
+        }
+    };
+
+    function createTexture(modelNode, basePath, value, encoding) {
+        var textureCfg = {};
+        var items = value.split(/\s+/);
+        var pos = items.indexOf('-bm');
+        if (pos >= 0) {
+            //matParams.bumpScale = parseFloat(items[pos + 1]);
+            items.splice(pos, 2);
+        }
+        pos = items.indexOf('-s');
+        if (pos >= 0) {
+            textureCfg.scale = [parseFloat(items[pos + 1]), parseFloat(items[pos + 2])];
+            items.splice(pos, 4); // we expect 3 parameters here!
+        }
+        pos = items.indexOf('-o');
+        if (pos >= 0) {
+            textureCfg.translate = [parseFloat(items[pos + 1]), parseFloat(items[pos + 2])];
+            items.splice(pos, 4); // we expect 3 parameters here!
+        }
+        textureCfg.src = basePath + items.join(' ').trim();
+        textureCfg.flipY = true;
+        textureCfg.encoding = encoding || "linear";
+        //textureCfg.wrapS = self.wrap;
+        //textureCfg.wrapT = self.wrap;
+        var texture = new Texture(modelNode, textureCfg);
+        return texture.id;
+    }
+
+    function createMaterial(modelNode, materialCfg) {
+        new PhongMaterial(modelNode, materialCfg);
+    }
+
+    function parseRGB(value) {
+        var ss = value.split(delimiter_pattern, 3);
+        return [parseFloat(ss[0]), parseFloat(ss[1]), parseFloat(ss[2])];
+    }
+
+})();
+//--------------------------------------------------------------------------------------------
+// Creates meshes from parsed state
+//--------------------------------------------------------------------------------------------
+
+
+function createMeshes(modelNode, state) {
+
+    for (var j = 0, k = state.objects.length; j < k; j++) {
+
+        var object = state.objects[j];
+        var geometry = object.geometry;
+        var isLine = (geometry.type === 'Line');
+
+        if (geometry.positions.length === 0) {
+            // Skip o/g line declarations that did not follow with any faces
+            continue;
+        }
+
+        var geometryCfg = {
+            primitive: "triangles",
+            compressGeometry: false
+        };
+
+        geometryCfg.positions = geometry.positions;
+
+        if (geometry.normals.length > 0) {
+            geometryCfg.normals = geometry.normals;
+        }
+
+        if (geometry.uv.length > 0) {
+            geometryCfg.uv = geometry.uv;
+        }
+
+        var indices = new Array(geometryCfg.positions.length / 3); // Triangle soup
+        for (var idx = 0; idx < indices.length; idx++) {
+            indices[idx] = idx;
+        }
+        geometryCfg.indices = indices;
+
+        const origin = tempVec3a;
+
+        worldToRTCPositions(geometry.positions, geometry.positions, origin);
+
+        var readableGeometry = new ReadableGeometry(modelNode, geometryCfg);
+
+        var materialId = object.material.id;
+        var material;
+        if (materialId && materialId !== "") {
+            material = modelNode.scene.components[materialId];
+            if (!material) {
+                modelNode.error("Material not found: " + materialId);
+            }
+        } else {
+            material = new PhongMaterial(modelNode, {
+                //emissive: [0.6, 0.6, 0.0],
+                diffuse: [0.6, 0.6, 0.6],
+                backfaces: true
+            });
+
+        }
+
+        // material.emissive = [Math.random(), Math.random(), Math.random()];
+
+        var mesh = new Mesh(modelNode, {
+            id: modelNode.id + "#" + object.id,
+            origin: (origin[0] !== 0 || origin[1] !== 0 || origin[2] !== 0) ? origin : null,
+            isObject: true,
+            geometry: readableGeometry,
+            material: material,
+            pickable: true
+        });
+
+        modelNode.addChild(mesh);
+    }
+}
+
+function loadFile(url, ok, err) {
+    var request = new XMLHttpRequest();
+    request.open('GET', url, true);
+    request.addEventListener('load', function (event) {
+        var response = event.target.response;
+        if (this.status === 200) {
+            if (ok) {
+                ok(response);
+            }
+        } else if (this.status === 0) {
+            // Some browsers return HTTP Status 0 when using non-http protocol
+            // e.g. 'file://' or 'data://'. Handle as success.
+            console.warn('loadFile: HTTP Status 0 received.');
+            if (ok) {
+                ok(response);
+            }
+        } else {
+            if (err) {
+                err(event);
+            }
+        }
+    }, false);
+
+    request.addEventListener('error', function (event) {
+        if (err) {
+            err(event);
+        }
+    }, false);
+    request.send(null);
+}
+
+export {OBJSceneGraphLoader};