opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/loaders/PRWMLoader.js

@@ -0,0 +1,247 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.PRWMLoader = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.PRWMLoader = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  /**
+   * See https://github.com/kchapelier/PRWM for more informations about this file format
+   */
+  var bigEndianPlatform = null;
+  /**
+  	 * Check if the endianness of the platform is big-endian (most significant bit first)
+  	 * @returns {boolean} True if big-endian, false if little-endian
+  	 */
+
+  function _isBigEndianPlatform() {
+    if (bigEndianPlatform === null) {
+      var buffer = new ArrayBuffer(2),
+          uint8Array = new Uint8Array(buffer),
+          uint16Array = new Uint16Array(buffer);
+      uint8Array[0] = 0xAA; // set first byte
+
+      uint8Array[1] = 0xBB; // set second byte
+
+      bigEndianPlatform = uint16Array[0] === 0xAABB;
+    }
+
+    return bigEndianPlatform;
+  } // match the values defined in the spec to the TypedArray types
+
+
+  var InvertedEncodingTypes = [null, Float32Array, null, Int8Array, Int16Array, null, Int32Array, Uint8Array, Uint16Array, null, Uint32Array]; // define the method to use on a DataView, corresponding the TypedArray type
+
+  var getMethods = {
+    Uint16Array: 'getUint16',
+    Uint32Array: 'getUint32',
+    Int16Array: 'getInt16',
+    Int32Array: 'getInt32',
+    Float32Array: 'getFloat32',
+    Float64Array: 'getFloat64'
+  };
+
+  function copyFromBuffer(sourceArrayBuffer, viewType, position, length, fromBigEndian) {
+    var bytesPerElement = viewType.BYTES_PER_ELEMENT;
+    var result;
+
+    if (fromBigEndian === _isBigEndianPlatform() || bytesPerElement === 1) {
+      result = new viewType(sourceArrayBuffer, position, length);
+    } else {
+      var readView = new DataView(sourceArrayBuffer, position, length * bytesPerElement),
+          getMethod = getMethods[viewType.name],
+          littleEndian = !fromBigEndian;
+      result = new viewType(length);
+
+      for (var i = 0; i < length; i++) {
+        result[i] = readView[getMethod](i * bytesPerElement, littleEndian);
+      }
+    }
+
+    return result;
+  }
+
+  function decodePrwm(buffer) {
+    var array = new Uint8Array(buffer),
+        version = array[0];
+    var flags = array[1];
+    var indexedGeometry = !!(flags >> 7 & 0x01),
+        indicesType = flags >> 6 & 0x01,
+        bigEndian = (flags >> 5 & 0x01) === 1,
+        attributesNumber = flags & 0x1F;
+    var valuesNumber = 0,
+        indicesNumber = 0;
+
+    if (bigEndian) {
+      valuesNumber = (array[2] << 16) + (array[3] << 8) + array[4];
+      indicesNumber = (array[5] << 16) + (array[6] << 8) + array[7];
+    } else {
+      valuesNumber = array[2] + (array[3] << 8) + (array[4] << 16);
+      indicesNumber = array[5] + (array[6] << 8) + (array[7] << 16);
+    }
+    /** PRELIMINARY CHECKS **/
+
+
+    if (version === 0) {
+      throw new Error('PRWM decoder: Invalid format version: 0');
+    } else if (version !== 1) {
+      throw new Error('PRWM decoder: Unsupported format version: ' + version);
+    }
+
+    if (!indexedGeometry) {
+      if (indicesType !== 0) {
+        throw new Error('PRWM decoder: Indices type must be set to 0 for non-indexed geometries');
+      } else if (indicesNumber !== 0) {
+        throw new Error('PRWM decoder: Number of indices must be set to 0 for non-indexed geometries');
+      }
+    }
+    /** PARSING **/
+
+
+    var pos = 8;
+    var attributes = {};
+
+    for (var i = 0; i < attributesNumber; i++) {
+      var attributeName = '';
+
+      while (pos < array.length) {
+        var char = array[pos];
+        pos++;
+
+        if (char === 0) {
+          break;
+        } else {
+          attributeName += String.fromCharCode(char);
+        }
+      }
+
+      flags = array[pos];
+      var attributeType = flags >> 7 & 0x01;
+      var cardinality = (flags >> 4 & 0x03) + 1;
+      var encodingType = flags & 0x0F;
+      var arrayType = InvertedEncodingTypes[encodingType];
+      pos++; // padding to next multiple of 4
+
+      pos = Math.ceil(pos / 4) * 4;
+      var values = copyFromBuffer(buffer, arrayType, pos, cardinality * valuesNumber, bigEndian);
+      pos += arrayType.BYTES_PER_ELEMENT * cardinality * valuesNumber;
+      attributes[attributeName] = {
+        type: attributeType,
+        cardinality: cardinality,
+        values: values
+      };
+    }
+
+    pos = Math.ceil(pos / 4) * 4;
+    var indices = null;
+
+    if (indexedGeometry) {
+      indices = copyFromBuffer(buffer, indicesType === 1 ? Uint32Array : Uint16Array, pos, indicesNumber, bigEndian);
+    }
+
+    return {
+      version: version,
+      attributes: attributes,
+      indices: indices
+    };
+  } // Define the public interface
+
+
+  var PRWMLoader = /*#__PURE__*/function (_Loader) {
+    _inherits(PRWMLoader, _Loader);
+
+    var _super = _createSuper(PRWMLoader);
+
+    function PRWMLoader(manager) {
+      _classCallCheck(this, PRWMLoader);
+
+      return _super.call(this, manager);
+    }
+
+    _createClass(PRWMLoader, [{
+      key: "load",
+      value: function load(url, onLoad, onProgress, onError) {
+        var scope = this;
+        var loader = new _three.FileLoader(scope.manager);
+        loader.setPath(scope.path);
+        loader.setResponseType('arraybuffer');
+        loader.setRequestHeader(scope.requestHeader);
+        loader.setWithCredentials(scope.withCredentials);
+        url = url.replace(/\*/g, _isBigEndianPlatform() ? 'be' : 'le');
+        loader.load(url, function (arrayBuffer) {
+          try {
+            onLoad(scope.parse(arrayBuffer));
+          } catch (e) {
+            if (onError) {
+              onError(e);
+            } else {
+              console.error(e);
+            }
+
+            scope.manager.itemError(url);
+          }
+        }, onProgress, onError);
+      }
+    }, {
+      key: "parse",
+      value: function parse(arrayBuffer) {
+        var data = decodePrwm(arrayBuffer),
+            attributesKey = Object.keys(data.attributes),
+            bufferGeometry = new _three.BufferGeometry();
+
+        for (var i = 0; i < attributesKey.length; i++) {
+          var attribute = data.attributes[attributesKey[i]];
+          bufferGeometry.setAttribute(attributesKey[i], new _three.BufferAttribute(attribute.values, attribute.cardinality, attribute.normalized));
+        }
+
+        if (data.indices !== null) {
+          bufferGeometry.setIndex(new _three.BufferAttribute(data.indices, 1));
+        }
+
+        return bufferGeometry;
+      }
+    }], [{
+      key: "isBigEndianPlatform",
+      value: function isBigEndianPlatform() {
+        return _isBigEndianPlatform();
+      }
+    }]);
+
+    return PRWMLoader;
+  }(_three.Loader);
+
+  _exports.PRWMLoader = PRWMLoader;
+});

data/lib-opal/js_wrap/three/loaders/PVRLoader.js

@@ -0,0 +1,240 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.PVRLoader = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.PVRLoader = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  /*
+   *	 PVR v2 (legacy) parser
+   *   TODO : Add Support for PVR v3 format
+   *   TODO : implement loadMipmaps option
+   */
+  var PVRLoader = /*#__PURE__*/function (_CompressedTextureLoa) {
+    _inherits(PVRLoader, _CompressedTextureLoa);
+
+    var _super = _createSuper(PVRLoader);
+
+    function PVRLoader(manager) {
+      _classCallCheck(this, PVRLoader);
+
+      return _super.call(this, manager);
+    }
+
+    _createClass(PVRLoader, [{
+      key: "parse",
+      value: function parse(buffer, loadMipmaps) {
+        var headerLengthInt = 13;
+        var header = new Uint32Array(buffer, 0, headerLengthInt);
+        var pvrDatas = {
+          buffer: buffer,
+          header: header,
+          loadMipmaps: loadMipmaps
+        };
+
+        if (header[0] === 0x03525650) {
+          // PVR v3
+          return _parseV3(pvrDatas);
+        } else if (header[11] === 0x21525650) {
+          // PVR v2
+          return _parseV2(pvrDatas);
+        } else {
+          console.error('THREE.PVRLoader: Unknown PVR format.');
+        }
+      }
+    }]);
+
+    return PVRLoader;
+  }(_three.CompressedTextureLoader);
+
+  _exports.PVRLoader = PVRLoader;
+
+  function _parseV3(pvrDatas) {
+    var header = pvrDatas.header;
+    var bpp, format;
+    var metaLen = header[12],
+        pixelFormat = header[2],
+        height = header[6],
+        width = header[7],
+        // numSurfs = header[ 9 ],
+    numFaces = header[10],
+        numMipmaps = header[11];
+
+    switch (pixelFormat) {
+      case 0:
+        // PVRTC 2bpp RGB
+        bpp = 2;
+        format = _three.RGB_PVRTC_2BPPV1_Format;
+        break;
+
+      case 1:
+        // PVRTC 2bpp RGBA
+        bpp = 2;
+        format = _three.RGBA_PVRTC_2BPPV1_Format;
+        break;
+
+      case 2:
+        // PVRTC 4bpp RGB
+        bpp = 4;
+        format = _three.RGB_PVRTC_4BPPV1_Format;
+        break;
+
+      case 3:
+        // PVRTC 4bpp RGBA
+        bpp = 4;
+        format = _three.RGBA_PVRTC_4BPPV1_Format;
+        break;
+
+      default:
+        console.error('THREE.PVRLoader: Unsupported PVR format:', pixelFormat);
+    }
+
+    pvrDatas.dataPtr = 52 + metaLen;
+    pvrDatas.bpp = bpp;
+    pvrDatas.format = format;
+    pvrDatas.width = width;
+    pvrDatas.height = height;
+    pvrDatas.numSurfaces = numFaces;
+    pvrDatas.numMipmaps = numMipmaps;
+    pvrDatas.isCubemap = numFaces === 6;
+    return _extract(pvrDatas);
+  }
+
+  function _parseV2(pvrDatas) {
+    var header = pvrDatas.header;
+    var headerLength = header[0],
+        height = header[1],
+        width = header[2],
+        numMipmaps = header[3],
+        flags = header[4],
+        // dataLength = header[ 5 ],
+    // bpp =  header[ 6 ],
+    // bitmaskRed = header[ 7 ],
+    // bitmaskGreen = header[ 8 ],
+    // bitmaskBlue = header[ 9 ],
+    bitmaskAlpha = header[10],
+        // pvrTag = header[ 11 ],
+    numSurfs = header[12];
+    var TYPE_MASK = 0xff;
+    var PVRTC_2 = 24,
+        PVRTC_4 = 25;
+    var formatFlags = flags & TYPE_MASK;
+    var bpp, format;
+
+    var _hasAlpha = bitmaskAlpha > 0;
+
+    if (formatFlags === PVRTC_4) {
+      format = _hasAlpha ? _three.RGBA_PVRTC_4BPPV1_Format : _three.RGB_PVRTC_4BPPV1_Format;
+      bpp = 4;
+    } else if (formatFlags === PVRTC_2) {
+      format = _hasAlpha ? _three.RGBA_PVRTC_2BPPV1_Format : _three.RGB_PVRTC_2BPPV1_Format;
+      bpp = 2;
+    } else {
+      console.error('THREE.PVRLoader: Unknown PVR format:', formatFlags);
+    }
+
+    pvrDatas.dataPtr = headerLength;
+    pvrDatas.bpp = bpp;
+    pvrDatas.format = format;
+    pvrDatas.width = width;
+    pvrDatas.height = height;
+    pvrDatas.numSurfaces = numSurfs;
+    pvrDatas.numMipmaps = numMipmaps + 1; // guess cubemap type seems tricky in v2
+    // it juste a pvr containing 6 surface (no explicit cubemap type)
+
+    pvrDatas.isCubemap = numSurfs === 6;
+    return _extract(pvrDatas);
+  }
+
+  function _extract(pvrDatas) {
+    var pvr = {
+      mipmaps: [],
+      width: pvrDatas.width,
+      height: pvrDatas.height,
+      format: pvrDatas.format,
+      mipmapCount: pvrDatas.numMipmaps,
+      isCubemap: pvrDatas.isCubemap
+    };
+    var buffer = pvrDatas.buffer;
+    var dataOffset = pvrDatas.dataPtr,
+        dataSize = 0,
+        blockSize = 0,
+        blockWidth = 0,
+        blockHeight = 0,
+        widthBlocks = 0,
+        heightBlocks = 0;
+    var bpp = pvrDatas.bpp,
+        numSurfs = pvrDatas.numSurfaces;
+
+    if (bpp === 2) {
+      blockWidth = 8;
+      blockHeight = 4;
+    } else {
+      blockWidth = 4;
+      blockHeight = 4;
+    }
+
+    blockSize = blockWidth * blockHeight * bpp / 8;
+    pvr.mipmaps.length = pvrDatas.numMipmaps * numSurfs;
+    var mipLevel = 0;
+
+    while (mipLevel < pvrDatas.numMipmaps) {
+      var sWidth = pvrDatas.width >> mipLevel,
+          sHeight = pvrDatas.height >> mipLevel;
+      widthBlocks = sWidth / blockWidth;
+      heightBlocks = sHeight / blockHeight; // Clamp to minimum number of blocks
+
+      if (widthBlocks < 2) widthBlocks = 2;
+      if (heightBlocks < 2) heightBlocks = 2;
+      dataSize = widthBlocks * heightBlocks * blockSize;
+
+      for (var surfIndex = 0; surfIndex < numSurfs; surfIndex++) {
+        var byteArray = new Uint8Array(buffer, dataOffset, dataSize);
+        var mipmap = {
+          data: byteArray,
+          width: sWidth,
+          height: sHeight
+        };
+        pvr.mipmaps[surfIndex * pvrDatas.numMipmaps + mipLevel] = mipmap;
+        dataOffset += dataSize;
+      }
+
+      mipLevel++;
+    }
+
+    return pvr;
+  }
+});