671 lines
25 KiB
JavaScript
671 lines
25 KiB
JavaScript
/******/
|
|
(function(modules) { // webpackBootstrap
|
|
/******/ // The module cache
|
|
/******/
|
|
var installedModules = {};
|
|
/******/
|
|
/******/ // The require function
|
|
/******/
|
|
function __webpack_require__(moduleId) {
|
|
/******/
|
|
/******/ // Check if module is in cache
|
|
/******/
|
|
if (installedModules[moduleId]) {
|
|
/******/
|
|
return installedModules[moduleId].exports;
|
|
/******/
|
|
}
|
|
/******/ // Create a new module (and put it into the cache)
|
|
/******/
|
|
var module = installedModules[moduleId] = {
|
|
/******/
|
|
i: moduleId,
|
|
/******/
|
|
l: false,
|
|
/******/
|
|
exports: {}
|
|
/******/
|
|
};
|
|
/******/
|
|
/******/ // Execute the module function
|
|
/******/
|
|
modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
/******/
|
|
/******/ // Flag the module as loaded
|
|
/******/
|
|
module.l = true;
|
|
/******/
|
|
/******/ // Return the exports of the module
|
|
/******/
|
|
return module.exports;
|
|
/******/
|
|
}
|
|
/******/
|
|
/******/
|
|
/******/ // expose the modules object (__webpack_modules__)
|
|
/******/
|
|
__webpack_require__.m = modules;
|
|
/******/
|
|
/******/ // expose the module cache
|
|
/******/
|
|
__webpack_require__.c = installedModules;
|
|
/******/
|
|
/******/ // define getter function for harmony exports
|
|
/******/
|
|
__webpack_require__.d = function(exports, name, getter) {
|
|
/******/
|
|
if (!__webpack_require__.o(exports, name)) {
|
|
/******/
|
|
Object.defineProperty(exports, name, {
|
|
enumerable: true,
|
|
get: getter
|
|
});
|
|
/******/
|
|
}
|
|
/******/
|
|
};
|
|
/******/
|
|
/******/ // define __esModule on exports
|
|
/******/
|
|
__webpack_require__.r = function(exports) {
|
|
/******/
|
|
if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
|
|
/******/
|
|
Object.defineProperty(exports, Symbol.toStringTag, {
|
|
value: 'Module'
|
|
});
|
|
/******/
|
|
}
|
|
/******/
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
/******/
|
|
};
|
|
/******/
|
|
/******/ // create a fake namespace object
|
|
/******/ // mode & 1: value is a module id, require it
|
|
/******/ // mode & 2: merge all properties of value into the ns
|
|
/******/ // mode & 4: return value when already ns object
|
|
/******/ // mode & 8|1: behave like require
|
|
/******/
|
|
__webpack_require__.t = function(value, mode) {
|
|
/******/
|
|
if (mode & 1) value = __webpack_require__(value);
|
|
/******/
|
|
if (mode & 8) return value;
|
|
/******/
|
|
if ((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
|
|
/******/
|
|
var ns = Object.create(null);
|
|
/******/
|
|
__webpack_require__.r(ns);
|
|
/******/
|
|
Object.defineProperty(ns, 'default', {
|
|
enumerable: true,
|
|
value: value
|
|
});
|
|
/******/
|
|
if (mode & 2 && typeof value != 'string')
|
|
for (var key in value) __webpack_require__.d(ns, key, function(key) {
|
|
return value[key];
|
|
}.bind(null, key));
|
|
/******/
|
|
return ns;
|
|
/******/
|
|
};
|
|
/******/
|
|
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
|
/******/
|
|
__webpack_require__.n = function(module) {
|
|
/******/
|
|
var getter = module && module.__esModule ?
|
|
/******/
|
|
function getDefault() {
|
|
return module['default'];
|
|
} :
|
|
/******/
|
|
function getModuleExports() {
|
|
return module;
|
|
};
|
|
/******/
|
|
__webpack_require__.d(getter, 'a', getter);
|
|
/******/
|
|
return getter;
|
|
/******/
|
|
};
|
|
/******/
|
|
/******/ // Object.prototype.hasOwnProperty.call
|
|
/******/
|
|
__webpack_require__.o = function(object, property) {
|
|
return Object.prototype.hasOwnProperty.call(object, property);
|
|
};
|
|
/******/
|
|
/******/ // __webpack_public_path__
|
|
/******/
|
|
__webpack_require__.p = "";
|
|
/******/
|
|
/******/
|
|
/******/ // Load entry module and return exports
|
|
/******/
|
|
return __webpack_require__(__webpack_require__.s = 0);
|
|
/******/
|
|
})
|
|
/************************************************************************/
|
|
/******/
|
|
([
|
|
/* 0 */
|
|
/***/
|
|
(function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
|
|
// CONCATENATED MODULE: ./src/scripts/lib/pixi-3d/fbx/three/LoaderUtils.js
|
|
function decodeText(array) {
|
|
if (typeof TextDecoder !== 'undefined') {
|
|
return new TextDecoder().decode(array);
|
|
} // Avoid the String.fromCharCode.apply(null, array) shortcut, which
|
|
// throws a "maximum call stack size exceeded" error for large arrays.
|
|
|
|
|
|
var s = '';
|
|
|
|
for (var i = 0, il = array.length; i < il; i++) {
|
|
// Implicitly assumes little-endian.
|
|
s += String.fromCharCode(array[i]);
|
|
} // Merges multi-byte utf-8 characters.
|
|
|
|
|
|
return decodeURIComponent(escape(s));
|
|
}
|
|
|
|
function extractUrlBase(url) {
|
|
var index = url.lastIndexOf('/');
|
|
if (index === -1) return './';
|
|
return url.substr(0, index + 1);
|
|
}
|
|
// CONCATENATED MODULE: ./src/scripts/lib/pixi-3d/fbx/BinaryReader.js
|
|
|
|
|
|
var BinaryReader_BinaryReader =
|
|
/*#__PURE__*/
|
|
function() {
|
|
function BinaryReader(buffer, littleEndian) {
|
|
this.dv = new DataView(buffer);
|
|
this.offset = 0;
|
|
this.littleEndian = littleEndian !== undefined ? littleEndian : true;
|
|
}
|
|
|
|
var _proto = BinaryReader.prototype;
|
|
|
|
_proto.getOffset = function getOffset() {
|
|
return this.offset;
|
|
};
|
|
|
|
_proto.size = function size() {
|
|
return this.dv.buffer.byteLength;
|
|
};
|
|
|
|
_proto.skip = function skip(length) {
|
|
this.offset += length;
|
|
} // seems like true/false representation depends on exporter.
|
|
// true: 1 or 'Y'(=0x59), false: 0 or 'T'(=0x54)
|
|
// then sees LSB.
|
|
;
|
|
|
|
_proto.getBoolean = function getBoolean() {
|
|
return (this.getUint8() & 1) === 1;
|
|
};
|
|
|
|
_proto.getBooleanArray = function getBooleanArray(size) {
|
|
var a = [];
|
|
|
|
for (var i = 0; i < size; i++) {
|
|
a.push(this.getBoolean());
|
|
}
|
|
|
|
return a;
|
|
};
|
|
|
|
_proto.getUint8 = function getUint8() {
|
|
var value = this.dv.getUint8(this.offset);
|
|
this.offset += 1;
|
|
return value;
|
|
};
|
|
|
|
_proto.getInt16 = function getInt16() {
|
|
var value = this.dv.getInt16(this.offset, this.littleEndian);
|
|
this.offset += 2;
|
|
return value;
|
|
};
|
|
|
|
_proto.getInt32 = function getInt32() {
|
|
var value = this.dv.getInt32(this.offset, this.littleEndian);
|
|
this.offset += 4;
|
|
return value;
|
|
};
|
|
|
|
_proto.getInt32Array = function getInt32Array(size) {
|
|
var a = [];
|
|
|
|
for (var i = 0; i < size; i++) {
|
|
a.push(this.getInt32());
|
|
}
|
|
|
|
return a;
|
|
};
|
|
|
|
_proto.getUint32 = function getUint32() {
|
|
var value = this.dv.getUint32(this.offset, this.littleEndian);
|
|
this.offset += 4;
|
|
return value;
|
|
} // JavaScript doesn't support 64-bit integer so calculate this here
|
|
// 1 << 32 will return 1 so using multiply operation instead here.
|
|
// There's a possibility that this method returns wrong value if the value
|
|
// is out of the range between Number.MAX_SAFE_INTEGER and Number.MIN_SAFE_INTEGER.
|
|
// TODO: safely handle 64-bit integer
|
|
;
|
|
|
|
_proto.getInt64 = function getInt64() {
|
|
var low, high;
|
|
|
|
if (this.littleEndian) {
|
|
low = this.getUint32();
|
|
high = this.getUint32();
|
|
} else {
|
|
high = this.getUint32();
|
|
low = this.getUint32();
|
|
} // calculate negative value
|
|
|
|
|
|
if (high & 0x80000000) {
|
|
high = ~high & 0xFFFFFFFF;
|
|
low = ~low & 0xFFFFFFFF;
|
|
if (low === 0xFFFFFFFF) high = high + 1 & 0xFFFFFFFF;
|
|
low = low + 1 & 0xFFFFFFFF;
|
|
return -(high * 0x100000000 + low);
|
|
}
|
|
|
|
return high * 0x100000000 + low;
|
|
};
|
|
|
|
_proto.getInt64Array = function getInt64Array(size) {
|
|
var a = [];
|
|
|
|
for (var i = 0; i < size; i++) {
|
|
a.push(this.getInt64());
|
|
}
|
|
|
|
return a;
|
|
} // Note: see getInt64() comment
|
|
;
|
|
|
|
_proto.getUint64 = function getUint64() {
|
|
var low, high;
|
|
|
|
if (this.littleEndian) {
|
|
low = this.getUint32();
|
|
high = this.getUint32();
|
|
} else {
|
|
high = this.getUint32();
|
|
low = this.getUint32();
|
|
}
|
|
|
|
var res = high * 0x100000000 + low;
|
|
|
|
if (Math.abs(res) > Number.MAX_SAFE_INTEGER) {
|
|
console.log("Not safe");
|
|
}
|
|
|
|
return high * 0x100000000 + low;
|
|
};
|
|
|
|
_proto.getFloat32 = function getFloat32() {
|
|
var value = this.dv.getFloat32(this.offset, this.littleEndian);
|
|
this.offset += 4;
|
|
return value;
|
|
};
|
|
|
|
_proto.getFloat32Array = function getFloat32Array(size) {
|
|
var a = [];
|
|
|
|
for (var i = 0; i < size; i++) {
|
|
a.push(this.getFloat32());
|
|
}
|
|
|
|
return a;
|
|
};
|
|
|
|
_proto.getFloat64 = function getFloat64() {
|
|
var value = this.dv.getFloat64(this.offset, this.littleEndian);
|
|
this.offset += 8;
|
|
return value;
|
|
};
|
|
|
|
_proto.getFloat64Array = function getFloat64Array(size) {
|
|
var a = [];
|
|
|
|
for (var i = 0; i < size; i++) {
|
|
a.push(this.getFloat64());
|
|
}
|
|
|
|
return a;
|
|
};
|
|
|
|
_proto.getArrayBuffer = function getArrayBuffer(size) {
|
|
var value = this.dv.buffer.slice(this.offset, this.offset + size);
|
|
this.offset += size;
|
|
return value;
|
|
};
|
|
|
|
_proto.getString = function getString(size) {
|
|
// note: safari 9 doesn't support Uint8Array.indexOf; create intermediate array instead
|
|
var a = [];
|
|
|
|
for (var i = 0; i < size; i++) {
|
|
a[i] = this.getUint8();
|
|
}
|
|
|
|
var nullByte = a.indexOf(0);
|
|
if (nullByte >= 0) a = a.slice(0, nullByte);
|
|
return decodeText(new Uint8Array(a));
|
|
};
|
|
|
|
return BinaryReader;
|
|
}();
|
|
|
|
|
|
// CONCATENATED MODULE: ./src/scripts/lib/pixi-3d/fbx/FBXTree.js
|
|
var FBXTree =
|
|
/*#__PURE__*/
|
|
function() {
|
|
function FBXTree() {}
|
|
|
|
var _proto = FBXTree.prototype;
|
|
|
|
_proto.add = function add(key, val) {
|
|
this[key] = val;
|
|
};
|
|
|
|
return FBXTree;
|
|
}();
|
|
// CONCATENATED MODULE: ./src/scripts/lib/pixi-3d/fbx/BinaryParser.js
|
|
|
|
|
|
|
|
var BinaryParser_BinaryParser =
|
|
/*#__PURE__*/
|
|
function() {
|
|
function BinaryParser(context) {
|
|
this.context = context;
|
|
}
|
|
|
|
var _proto = BinaryParser.prototype;
|
|
|
|
_proto.parse = function parse(buffer) {
|
|
var reader = new BinaryReader_BinaryReader(buffer);
|
|
reader.skip(23); // skip magic 23 bytes
|
|
|
|
var version = reader.getUint32(); // console.log('THREE.FBXLoader: FBX binary version: ' + version);
|
|
|
|
var allNodes = new FBXTree();
|
|
|
|
while (!this.endOfContent(reader)) {
|
|
var node = this.parseNode(reader, version);
|
|
if (node !== null) allNodes.add(node.name, node);
|
|
}
|
|
|
|
return allNodes;
|
|
} // Check if reader has reached the end of content.
|
|
;
|
|
|
|
_proto.endOfContent = function endOfContent(reader) {
|
|
// footer size: 160bytes + 16-byte alignment padding
|
|
// - 16bytes: magic
|
|
// - padding til 16-byte alignment (at least 1byte?)
|
|
// (seems like some exporters embed fixed 15 or 16bytes?)
|
|
// - 4bytes: magic
|
|
// - 4bytes: version
|
|
// - 120bytes: zero
|
|
// - 16bytes: magic
|
|
if (reader.size() % 16 === 0) {
|
|
return (reader.getOffset() + 160 + 16 & ~0xf) >= reader.size();
|
|
} else {
|
|
return reader.getOffset() + 160 + 16 >= reader.size();
|
|
}
|
|
} // recursively parse nodes until the end of the file is reached
|
|
;
|
|
|
|
_proto.parseNode = function parseNode(reader, version) {
|
|
var node = {}; // The first three data sizes depends on version.
|
|
|
|
var endOffset = version >= 7500 ? reader.getUint64() : reader.getUint32();
|
|
var numProperties = version >= 7500 ? reader.getUint64() : reader.getUint32(); // note: do not remove this even if you get a linter warning as it moves the buffer forward
|
|
|
|
var propertyListLen = version >= 7500 ? reader.getUint64() : reader.getUint32();
|
|
var nameLen = reader.getUint8();
|
|
var name = reader.getString(nameLen); // Regards this node as NULL-record if endOffset is zero
|
|
|
|
if (endOffset === 0) return null;
|
|
var propertyList = [];
|
|
|
|
for (var i = 0; i < numProperties; i++) {
|
|
propertyList.push(this.parseProperty(reader));
|
|
} // Regards the first three elements in propertyList as id, attrName, and attrType
|
|
|
|
|
|
var id = propertyList.length > 0 ? propertyList[0] : '';
|
|
var attrName = propertyList.length > 1 ? propertyList[1] : '';
|
|
var attrType = propertyList.length > 2 ? propertyList[2] : ''; // check if this node represents just a single property
|
|
// like (name, 0) set or (name2, [0, 1, 2]) set of {name: 0, name2: [0, 1, 2]}
|
|
|
|
node.singleProperty = numProperties === 1 && reader.getOffset() === endOffset ? true : false;
|
|
|
|
while (endOffset > reader.getOffset()) {
|
|
var subNode = this.parseNode(reader, version);
|
|
if (subNode !== null) this.parseSubNode(name, node, subNode);
|
|
}
|
|
|
|
node.propertyList = propertyList; // raw property list used by parent
|
|
|
|
if (typeof id === 'number') node.id = id;
|
|
if (attrName !== '') node.attrName = attrName;
|
|
if (attrType !== '') node.attrType = attrType;
|
|
if (name !== '') node.name = name;
|
|
return node;
|
|
};
|
|
|
|
_proto.parseSubNode = function parseSubNode(name, node, subNode) {
|
|
// special case: child node is single property
|
|
if (subNode.singleProperty === true) {
|
|
var value = subNode.propertyList[0];
|
|
|
|
if (Array.isArray(value)) {
|
|
node[subNode.name] = subNode;
|
|
subNode.a = value;
|
|
} else {
|
|
node[subNode.name] = value;
|
|
}
|
|
} else if (name === 'Connections' && subNode.name === 'C') {
|
|
var array = [];
|
|
subNode.propertyList.forEach(function(property, i) {
|
|
// first Connection is FBX type (OO, OP, etc.). We'll discard these
|
|
if (i !== 0) array.push(property);
|
|
});
|
|
|
|
if (node.connections === undefined) {
|
|
node.connections = [];
|
|
}
|
|
|
|
node.connections.push(array);
|
|
} else if (subNode.name === 'Properties70') {
|
|
var keys = Object.keys(subNode);
|
|
keys.forEach(function(key) {
|
|
node[key] = subNode[key];
|
|
});
|
|
} else if (name === 'Properties70' && subNode.name === 'P') {
|
|
var innerPropName = subNode.propertyList[0];
|
|
var innerPropType1 = subNode.propertyList[1];
|
|
var innerPropType2 = subNode.propertyList[2];
|
|
var innerPropFlag = subNode.propertyList[3];
|
|
var innerPropValue;
|
|
if (innerPropName.indexOf('Lcl ') === 0) innerPropName = innerPropName.replace('Lcl ', 'Lcl_');
|
|
if (innerPropType1.indexOf('Lcl ') === 0) innerPropType1 = innerPropType1.replace('Lcl ', 'Lcl_');
|
|
|
|
if (innerPropType1 === 'Color' || innerPropType1 === 'ColorRGB' || innerPropType1 === 'Vector' || innerPropType1 === 'Vector3D' || innerPropType1.indexOf('Lcl_') === 0) {
|
|
innerPropValue = [subNode.propertyList[4], subNode.propertyList[5], subNode.propertyList[6]];
|
|
} else {
|
|
innerPropValue = subNode.propertyList[4];
|
|
} // this will be copied to parent, see above
|
|
|
|
|
|
node[innerPropName] = {
|
|
'type': innerPropType1,
|
|
'type2': innerPropType2,
|
|
'flag': innerPropFlag,
|
|
'value': innerPropValue
|
|
};
|
|
} else if (node[subNode.name] === undefined) {
|
|
if (typeof subNode.id === 'number') {
|
|
node[subNode.name] = {};
|
|
node[subNode.name][subNode.id] = subNode;
|
|
} else {
|
|
node[subNode.name] = subNode;
|
|
}
|
|
} else {
|
|
if (subNode.name === 'PoseNode') {
|
|
if (!Array.isArray(node[subNode.name])) {
|
|
node[subNode.name] = [node[subNode.name]];
|
|
}
|
|
|
|
node[subNode.name].push(subNode);
|
|
} else if (node[subNode.name][subNode.id] === undefined) {
|
|
node[subNode.name][subNode.id] = subNode;
|
|
}
|
|
}
|
|
};
|
|
|
|
_proto.parseProperty = function parseProperty(reader) {
|
|
var type = reader.getString(1);
|
|
var length = 0;
|
|
|
|
switch (type) {
|
|
case 'C':
|
|
return reader.getBoolean();
|
|
|
|
case 'D':
|
|
return reader.getFloat64();
|
|
|
|
case 'F':
|
|
return reader.getFloat32();
|
|
|
|
case 'I':
|
|
return reader.getInt32();
|
|
|
|
case 'L':
|
|
return reader.getInt64();
|
|
|
|
case 'R':
|
|
length = reader.getUint32();
|
|
return reader.getArrayBuffer(length);
|
|
|
|
case 'S':
|
|
length = reader.getUint32();
|
|
return reader.getString(length);
|
|
|
|
case 'Y':
|
|
return reader.getInt16();
|
|
|
|
case 'b':
|
|
case 'c':
|
|
case 'd':
|
|
case 'f':
|
|
case 'i':
|
|
case 'l':
|
|
var arrayLength = reader.getUint32();
|
|
var encoding = reader.getUint32(); // 0: non-compressed, 1: compressed
|
|
|
|
var compressedLength = reader.getUint32();
|
|
|
|
if (encoding === 0) {
|
|
switch (type) {
|
|
case 'b':
|
|
case 'c':
|
|
return reader.getBooleanArray(arrayLength);
|
|
|
|
case 'd':
|
|
return reader.getFloat64Array(arrayLength);
|
|
|
|
case 'f':
|
|
return reader.getFloat32Array(arrayLength);
|
|
|
|
case 'i':
|
|
return reader.getInt32Array(arrayLength);
|
|
|
|
case 'l':
|
|
return reader.getInt64Array(arrayLength);
|
|
}
|
|
}
|
|
|
|
if (typeof Zlib === 'undefined') {
|
|
console.error('THREE.FBXLoader: External library Inflate.min.js required, obtain or import from https://github.com/imaya/zlib.js');
|
|
}
|
|
|
|
var inflate = new Zlib.Inflate(new Uint8Array(reader.getArrayBuffer(compressedLength))); // eslint-disable-line no-undef
|
|
|
|
var reader2 = new BinaryReader_BinaryReader(inflate.decompress().buffer);
|
|
|
|
switch (type) {
|
|
case 'b':
|
|
case 'c':
|
|
return reader2.getBooleanArray(arrayLength);
|
|
|
|
case 'd':
|
|
return reader2.getFloat64Array(arrayLength);
|
|
|
|
case 'f':
|
|
return reader2.getFloat32Array(arrayLength);
|
|
|
|
case 'i':
|
|
return reader2.getInt32Array(arrayLength);
|
|
|
|
case 'l':
|
|
return reader2.getInt64Array(arrayLength);
|
|
}
|
|
|
|
default:
|
|
throw new Error('THREE.FBXLoader: Unknown property type ' + type);
|
|
}
|
|
};
|
|
|
|
return BinaryParser;
|
|
}();
|
|
|
|
|
|
// CONCATENATED MODULE: ./node_modules/babel-loader/lib??ref--10!./src/scripts/lib/pixi-3d/fbx/fbx.worker.js
|
|
importScripts('../inflate.min.js');
|
|
|
|
|
|
function fbx_worker_parse(buffer, id) {
|
|
var fbxTree = new BinaryParser_BinaryParser({}).parse(buffer);
|
|
return {
|
|
id: id,
|
|
fbxTree: fbxTree
|
|
};
|
|
}
|
|
|
|
onmessage = function onmessage(e) {
|
|
if (e.data['parse']) {
|
|
// console.log('[FBXWORKER] Parse start:', e.data.id);
|
|
var res = fbx_worker_parse(e.data['parse'], e.data.id); // console.log('[FBXWORKER] Parse complete:', e.data.id);
|
|
|
|
postMessage(res);
|
|
}
|
|
};
|
|
|
|
/***/
|
|
})
|
|
/******/
|
|
]);
|
|
//# sourceMappingURL=worker.21cc18ec46e616e4eed8.js.map
|