three-stdlib 2.16.0 → 2.16.2

package/loaders/PRWMLoader.js

@@ -1,56 +1,73 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
+import { Loader, FileLoader, BufferGeometry, BufferAttribute } from 'three';
+
+/**
+ * See https://github.com/kchapelier/PRWM for more informations about this file format
+ */
+
 let 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) {
-    const buffer = new ArrayBuffer(2), uint8Array = new Uint8Array(buffer), uint16Array = new Uint16Array(buffer);
-    uint8Array[0] = 170;
-    uint8Array[1] = 187;
-    bigEndianPlatform = uint16Array[0] === 43707;
+    const 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;
-}
-const InvertedEncodingTypes = [
-  null,
-  Float32Array,
-  null,
-  Int8Array,
-  Int16Array,
-  null,
-  Int32Array,
-  Uint8Array,
-  Uint16Array,
-  null,
-  Uint32Array
-];
+} // match the values defined in the spec to the TypedArray types
+
+
+const InvertedEncodingTypes = [null, Float32Array, null, Int8Array, Int16Array, null, Int32Array, Uint8Array, Uint16Array, null, Uint32Array]; // define the method to use on a DataView, corresponding the TypedArray type
+
 const getMethods = {
-  Uint16Array: "getUint16",
-  Uint32Array: "getUint32",
-  Int16Array: "getInt16",
-  Int32Array: "getInt32",
-  Float32Array: "getFloat32",
-  Float64Array: "getFloat64"
+  Uint16Array: 'getUint16',
+  Uint32Array: 'getUint32',
+  Int16Array: 'getInt16',
+  Int32Array: 'getInt32',
+  Float32Array: 'getFloat32',
+  Float64Array: 'getFloat64'
 };
+
 function copyFromBuffer(sourceArrayBuffer, viewType, position, length, fromBigEndian) {
   const bytesPerElement = viewType.BYTES_PER_ELEMENT;
   let result;
+
   if (fromBigEndian === isBigEndianPlatform() || bytesPerElement === 1) {
     result = new viewType(sourceArrayBuffer, position, length);
   } else {
-    const readView = new DataView(sourceArrayBuffer, position, length * bytesPerElement), getMethod = getMethods[viewType.name], littleEndian = !fromBigEndian;
+    const readView = new DataView(sourceArrayBuffer, position, length * bytesPerElement),
+          getMethod = getMethods[viewType.name],
+          littleEndian = !fromBigEndian;
     result = new viewType(length);
+
     for (let i = 0; i < length; i++) {
       result[i] = readView[getMethod](i * bytesPerElement, littleEndian);
     }
   }
+
   return result;
 }
+
 function decodePrwm(buffer) {
-  const array = new Uint8Array(buffer), version = array[0];
+  const array = new Uint8Array(buffer),
+        version = array[0];
   let flags = array[1];
-  const indexedGeometry = !!(flags >> 7 & 1), indicesType = flags >> 6 & 1, bigEndian = (flags >> 5 & 1) === 1, attributesNumber = flags & 31;
-  let valuesNumber = 0, indicesNumber = 0;
+  const indexedGeometry = !!(flags >> 7 & 0x01),
+        indicesType = flags >> 6 & 0x01,
+        bigEndian = (flags >> 5 & 0x01) === 1,
+        attributesNumber = flags & 0x1f;
+  let valuesNumber = 0,
+      indicesNumber = 0;
+
   if (bigEndian) {
     valuesNumber = (array[2] << 16) + (array[3] << 8) + array[4];
     indicesNumber = (array[5] << 16) + (array[6] << 8) + array[7];
@@ -58,103 +75,123 @@ function decodePrwm(buffer) {
     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");
+    throw new Error('PRWM decoder: Invalid format version: 0');
   } else if (version !== 1) {
-    throw new Error("PRWM decoder: Unsupported format version: " + version);
+    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");
+      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");
+      throw new Error('PRWM decoder: Number of indices must be set to 0 for non-indexed geometries');
     }
   }
+  /** PARSING **/
+
+
   let pos = 8;
   const attributes = {};
+
   for (let i = 0; i < attributesNumber; i++) {
-    let attributeName = "";
+    let attributeName = '';
+
     while (pos < array.length) {
       const char = array[pos];
       pos++;
+
       if (char === 0) {
         break;
       } else {
         attributeName += String.fromCharCode(char);
       }
     }
+
     flags = array[pos];
-    const attributeType = flags >> 7 & 1;
-    const cardinality = (flags >> 4 & 3) + 1;
-    const encodingType = flags & 15;
+    const attributeType = flags >> 7 & 0x01;
+    const cardinality = (flags >> 4 & 0x03) + 1;
+    const encodingType = flags & 0x0f;
     const arrayType = InvertedEncodingTypes[encodingType];
-    pos++;
+    pos++; // padding to next multiple of 4
+
     pos = Math.ceil(pos / 4) * 4;
     const values = copyFromBuffer(buffer, arrayType, pos, cardinality * valuesNumber, bigEndian);
     pos += arrayType.BYTES_PER_ELEMENT * cardinality * valuesNumber;
     attributes[attributeName] = {
       type: attributeType,
-      cardinality,
-      values
+      cardinality: cardinality,
+      values: values
     };
   }
+
   pos = Math.ceil(pos / 4) * 4;
   let indices = null;
+
   if (indexedGeometry) {
     indices = copyFromBuffer(buffer, indicesType === 1 ? Uint32Array : Uint16Array, pos, indicesNumber, bigEndian);
   }
+
   return {
-    version,
-    attributes,
-    indices
+    version: version,
+    attributes: attributes,
+    indices: indices
   };
-}
-class PRWMLoader extends THREE.Loader {
+} // Define the public interface
+
+
+class PRWMLoader extends Loader {
   constructor(manager) {
     super(manager);
   }
+
   load(url, onLoad, onProgress, onError) {
     const scope = this;
-    const loader = new THREE.FileLoader(scope.manager);
+    const loader = new FileLoader(scope.manager);
     loader.setPath(scope.path);
-    loader.setResponseType("arraybuffer");
+    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);
+    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);
         }
-      },
-      onProgress,
-      onError
-    );
+
+        scope.manager.itemError(url);
+      }
+    }, onProgress, onError);
   }
+
   parse(arrayBuffer) {
-    const data = decodePrwm(arrayBuffer), attributesKey = Object.keys(data.attributes), bufferGeometry = new THREE.BufferGeometry();
+    const data = decodePrwm(arrayBuffer),
+          attributesKey = Object.keys(data.attributes),
+          bufferGeometry = new BufferGeometry();
+
     for (let i = 0; i < attributesKey.length; i++) {
       const attribute = data.attributes[attributesKey[i]];
-      bufferGeometry.setAttribute(
-        attributesKey[i],
-        new THREE.BufferAttribute(attribute.values, attribute.cardinality, attribute.normalized)
-      );
+      bufferGeometry.setAttribute(attributesKey[i], new BufferAttribute(attribute.values, attribute.cardinality, attribute.normalized));
     }
+
     if (data.indices !== null) {
-      bufferGeometry.setIndex(new THREE.BufferAttribute(data.indices, 1));
+      bufferGeometry.setIndex(new BufferAttribute(data.indices, 1));
     }
+
     return bufferGeometry;
   }
+
   static isBigEndianPlatform() {
     return isBigEndianPlatform();
   }
+
 }
-exports.PRWMLoader = PRWMLoader;
+
+export { PRWMLoader };

package/loaders/PVRLoader.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three");class r extends e.CompressedTextureLoader{constructor(e){super(e)}parse(r,a){const o=new Uint32Array(r,0,13),s={buffer:r,header:o,loadMipmaps:a};return 55727696===o[0]?function(r){const a=r.header;let o,s;const n=a[12],m=a[2],p=a[6],i=a[7],u=a[10],P=a[11];switch(m){case 0:o=2,s=e.RGB_PVRTC_2BPPV1_Format;break;case 1:o=2,s=e.RGBA_PVRTC_2BPPV1_Format;break;case 2:o=4,s=e.RGB_PVRTC_4BPPV1_Format;break;case 3:o=4,s=e.RGBA_PVRTC_4BPPV1_Format;break;default:console.error("THREE.PVRLoader: Unsupported PVR format:",m)}return r.dataPtr=52+n,r.bpp=o,r.format=s,r.width=i,r.height=p,r.numSurfaces=u,r.numMipmaps=P,r.isCubemap=6===u,t(r)}(s):559044176===o[11]?function(r){const a=r.header,o=a[0],s=a[1],n=a[2],m=a[3],p=a[4],i=a[10],u=a[12],P=24,c=255&p;let d,R;const _=i>0;25===c?(R=_?e.RGBA_PVRTC_4BPPV1_Format:e.RGB_PVRTC_4BPPV1_Format,d=4):c===P?(R=_?e.RGBA_PVRTC_2BPPV1_Format:e.RGB_PVRTC_2BPPV1_Format,d=2):console.error("THREE.PVRLoader: Unknown PVR format:",c);return r.dataPtr=o,r.bpp=d,r.format=R,r.width=n,r.height=s,r.numSurfaces=u,r.numMipmaps=m+1,r.isCubemap=6===u,t(r)}(s):void console.error("THREE.PVRLoader: Unknown PVR format.")}}function t(e){const r={mipmaps:[],width:e.width,height:e.height,format:e.format,mipmapCount:e.numMipmaps,isCubemap:e.isCubemap},t=e.buffer;let a=e.dataPtr,o=0,s=0,n=0,m=0,p=0,i=0;const u=e.bpp,P=e.numSurfaces;2===u?(n=8,m=4):(n=4,m=4),s=n*m*u/8,r.mipmaps.length=e.numMipmaps*P;let c=0;for(;c<e.numMipmaps;){const u=e.width>>c,d=e.height>>c;p=u/n,i=d/m,p<2&&(p=2),i<2&&(i=2),o=p*i*s;for(let s=0;s<P;s++){const n={data:new Uint8Array(t,a,o),width:u,height:d};r.mipmaps[s*e.numMipmaps+c]=n,a+=o}c++}return r}exports.PVRLoader=r;

package/loaders/PVRLoader.js

@@ -1,51 +1,78 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
-class PVRLoader extends THREE.CompressedTextureLoader {
+import { CompressedTextureLoader, RGBA_PVRTC_4BPPV1_Format, RGB_PVRTC_4BPPV1_Format, RGBA_PVRTC_2BPPV1_Format, RGB_PVRTC_2BPPV1_Format } from 'three';
+
+/*
+ *	 PVR v2 (legacy) parser
+ *   TODO : Add Support for PVR v3 format
+ *   TODO : implement loadMipmaps option
+ */
+
+class PVRLoader extends CompressedTextureLoader {
   constructor(manager) {
     super(manager);
   }
+
   parse(buffer, loadMipmaps) {
     const headerLengthInt = 13;
     const header = new Uint32Array(buffer, 0, headerLengthInt);
     const pvrDatas = {
-      buffer,
-      header,
-      loadMipmaps
+      buffer: buffer,
+      header: header,
+      loadMipmaps: loadMipmaps
     };
-    if (header[0] === 55727696) {
+
+    if (header[0] === 0x03525650) {
+      // PVR v3
       return _parseV3(pvrDatas);
-    } else if (header[11] === 559044176) {
+    } else if (header[11] === 0x21525650) {
+      // PVR v2
       return _parseV2(pvrDatas);
     } else {
-      console.error("THREE.PVRLoader: Unknown PVR format.");
+      console.error('THREE.PVRLoader: Unknown PVR format.');
     }
   }
+
 }
+
 function _parseV3(pvrDatas) {
   const header = pvrDatas.header;
   let bpp, format;
-  const metaLen = header[12], pixelFormat = header[2], height = header[6], width = header[7], numFaces = header[10], numMipmaps = header[11];
+  const 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;
+      format = RGB_PVRTC_2BPPV1_Format;
       break;
+
     case 1:
+      // PVRTC 2bpp RGBA
       bpp = 2;
-      format = THREE.RGBA_PVRTC_2BPPV1_Format;
+      format = RGBA_PVRTC_2BPPV1_Format;
       break;
+
     case 2:
+      // PVRTC 4bpp RGB
       bpp = 4;
-      format = THREE.RGB_PVRTC_4BPPV1_Format;
+      format = RGB_PVRTC_4BPPV1_Format;
       break;
+
     case 3:
+      // PVRTC 4bpp RGBA
       bpp = 4;
-      format = THREE.RGBA_PVRTC_4BPPV1_Format;
+      format = RGBA_PVRTC_4BPPV1_Format;
       break;
+
     default:
-      console.error("THREE.PVRLoader: Unsupported PVR format:", pixelFormat);
+      console.error('THREE.PVRLoader: Unsupported PVR format:', pixelFormat);
   }
+
   pvrDatas.dataPtr = 52 + metaLen;
   pvrDatas.bpp = bpp;
   pvrDatas.format = format;
@@ -56,33 +83,53 @@ function _parseV3(pvrDatas) {
   pvrDatas.isCubemap = numFaces === 6;
   return _extract(pvrDatas);
 }
+
 function _parseV2(pvrDatas) {
   const header = pvrDatas.header;
-  const headerLength = header[0], height = header[1], width = header[2], numMipmaps = header[3], flags = header[4], bitmaskAlpha = header[10], numSurfs = header[12];
-  const TYPE_MASK = 255;
-  const PVRTC_2 = 24, PVRTC_4 = 25;
+  const 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];
+  const TYPE_MASK = 0xff;
+  const PVRTC_2 = 24,
+        PVRTC_4 = 25;
   const formatFlags = flags & TYPE_MASK;
   let bpp, format;
+
   const _hasAlpha = bitmaskAlpha > 0;
+
   if (formatFlags === PVRTC_4) {
-    format = _hasAlpha ? THREE.RGBA_PVRTC_4BPPV1_Format : THREE.RGB_PVRTC_4BPPV1_Format;
+    format = _hasAlpha ? RGBA_PVRTC_4BPPV1_Format : RGB_PVRTC_4BPPV1_Format;
     bpp = 4;
   } else if (formatFlags === PVRTC_2) {
-    format = _hasAlpha ? THREE.RGBA_PVRTC_2BPPV1_Format : THREE.RGB_PVRTC_2BPPV1_Format;
+    format = _hasAlpha ? RGBA_PVRTC_2BPPV1_Format : RGB_PVRTC_2BPPV1_Format;
     bpp = 2;
   } else {
-    console.error("THREE.PVRLoader: Unknown PVR format:", formatFlags);
+    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;
+  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) {
   const pvr = {
     mipmaps: [],
@@ -93,8 +140,16 @@ function _extract(pvrDatas) {
     isCubemap: pvrDatas.isCubemap
   };
   const buffer = pvrDatas.buffer;
-  let dataOffset = pvrDatas.dataPtr, dataSize = 0, blockSize = 0, blockWidth = 0, blockHeight = 0, widthBlocks = 0, heightBlocks = 0;
-  const bpp = pvrDatas.bpp, numSurfs = pvrDatas.numSurfaces;
+  let dataOffset = pvrDatas.dataPtr,
+      dataSize = 0,
+      blockSize = 0,
+      blockWidth = 0,
+      blockHeight = 0,
+      widthBlocks = 0,
+      heightBlocks = 0;
+  const bpp = pvrDatas.bpp,
+        numSurfs = pvrDatas.numSurfaces;
+
   if (bpp === 2) {
     blockWidth = 8;
     blockHeight = 4;
@@ -102,18 +157,21 @@ function _extract(pvrDatas) {
     blockWidth = 4;
     blockHeight = 4;
   }
+
   blockSize = blockWidth * blockHeight * bpp / 8;
   pvr.mipmaps.length = pvrDatas.numMipmaps * numSurfs;
   let mipLevel = 0;
+
   while (mipLevel < pvrDatas.numMipmaps) {
-    const sWidth = pvrDatas.width >> mipLevel, sHeight = pvrDatas.height >> mipLevel;
+    const sWidth = pvrDatas.width >> mipLevel,
+          sHeight = pvrDatas.height >> mipLevel;
     widthBlocks = sWidth / blockWidth;
-    heightBlocks = sHeight / blockHeight;
-    if (widthBlocks < 2)
-      widthBlocks = 2;
-    if (heightBlocks < 2)
-      heightBlocks = 2;
+    heightBlocks = sHeight / blockHeight; // Clamp to minimum number of blocks
+
+    if (widthBlocks < 2) widthBlocks = 2;
+    if (heightBlocks < 2) heightBlocks = 2;
     dataSize = widthBlocks * heightBlocks * blockSize;
+
     for (let surfIndex = 0; surfIndex < numSurfs; surfIndex++) {
       const byteArray = new Uint8Array(buffer, dataOffset, dataSize);
       const mipmap = {
@@ -124,8 +182,11 @@ function _extract(pvrDatas) {
       pvr.mipmaps[surfIndex * pvrDatas.numMipmaps + mipLevel] = mipmap;
       dataOffset += dataSize;
     }
+
     mipLevel++;
   }
+
   return pvr;
 }
-exports.PVRLoader = PVRLoader;
+
+export { PVRLoader };

package/loaders/RGBELoader.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three");class t extends e.DataTextureLoader{constructor(t){super(t),this.type=e.HalfFloatType}parse(t){const r=function(e,t){switch(e){case 1:console.error("THREE.RGBELoader Read Error: "+(t||""));break;case 2:console.error("THREE.RGBELoader Write Error: "+(t||""));break;case 3:console.error("THREE.RGBELoader Bad File Format: "+(t||""));break;default:case 4:console.error("THREE.RGBELoader: Error: "+(t||""))}return-1},a=function(e,t,r){t=t||1024;let a=e.pos,n=-1,o=0,s="",i=String.fromCharCode.apply(null,new Uint16Array(e.subarray(a,a+128)));for(;0>(n=i.indexOf("\n"))&&o<t&&a<e.byteLength;)s+=i,o+=i.length,a+=128,i+=String.fromCharCode.apply(null,new Uint16Array(e.subarray(a,a+128)));return-1<n&&(!1!==r&&(e.pos+=o+n+1),s+i.slice(0,n))},n=function(e,t,r,a){const n=e[t+3],o=Math.pow(2,n-128)/255;r[a+0]=e[t+0]*o,r[a+1]=e[t+1]*o,r[a+2]=e[t+2]*o,r[a+3]=1},o=function(t,r,a,n){const o=t[r+3],s=Math.pow(2,o-128)/255;a[n+0]=e.DataUtils.toHalfFloat(Math.min(t[r+0]*s,65504)),a[n+1]=e.DataUtils.toHalfFloat(Math.min(t[r+1]*s,65504)),a[n+2]=e.DataUtils.toHalfFloat(Math.min(t[r+2]*s,65504)),a[n+3]=e.DataUtils.toHalfFloat(1)},s=new Uint8Array(t);s.pos=0;const i=function(e){const t=/^\s*GAMMA\s*=\s*(\d+(\.\d+)?)\s*$/,n=/^\s*EXPOSURE\s*=\s*(\d+(\.\d+)?)\s*$/,o=/^\s*FORMAT=(\S+)\s*$/,s=/^\s*\-Y\s+(\d+)\s+\+X\s+(\d+)\s*$/,i={valid:0,string:"",comments:"",programtype:"RGBE",format:"",gamma:1,exposure:1,width:0,height:0};let l,c;if(e.pos>=e.byteLength||!(l=a(e)))return r(1,"no header found");if(!(c=l.match(/^#\?(\S+)/)))return r(3,"bad initial token");for(i.valid|=1,i.programtype=c[1],i.string+=l+"\n";l=a(e),!1!==l;)if(i.string+=l+"\n","#"!==l.charAt(0)){if((c=l.match(t))&&(i.gamma=parseFloat(c[1])),(c=l.match(n))&&(i.exposure=parseFloat(c[1])),(c=l.match(o))&&(i.valid|=2,i.format=c[1]),(c=l.match(s))&&(i.valid|=4,i.height=parseInt(c[1],10),i.width=parseInt(c[2],10)),2&i.valid&&4&i.valid)break}else i.comments+=l+"\n";return 2&i.valid?4&i.valid?i:r(3,"missing image size specifier"):r(3,"missing format specifier")}(s);if(-1!==i){const t=i.width,a=i.height,l=function(e,t,a){const n=t;if(n<8||n>32767||2!==e[0]||2!==e[1]||128&e[2])return new Uint8Array(e);if(n!==(e[2]<<8|e[3]))return r(3,"wrong scanline width");const o=new Uint8Array(4*t*a);if(!o.length)return r(4,"unable to allocate buffer space");let s=0,i=0;const l=4*n,c=new Uint8Array(4),f=new Uint8Array(l);let p=a;for(;p>0&&i<e.byteLength;){if(i+4>e.byteLength)return r(1);if(c[0]=e[i++],c[1]=e[i++],c[2]=e[i++],c[3]=e[i++],2!=c[0]||2!=c[1]||(c[2]<<8|c[3])!=n)return r(3,"bad rgbe scanline format");let t,a=0;for(;a<l&&i<e.byteLength;){t=e[i++];const n=t>128;if(n&&(t-=128),0===t||a+t>l)return r(3,"bad scanline data");if(n){const r=e[i++];for(let e=0;e<t;e++)f[a++]=r}else f.set(e.subarray(i,i+t),a),a+=t,i+=t}const d=n;for(let e=0;e<d;e++){let t=0;o[s]=f[e+t],t+=n,o[s+1]=f[e+t],t+=n,o[s+2]=f[e+t],t+=n,o[s+3]=f[e+t],s+=4}p--}return o}(s.subarray(s.pos),t,a);if(-1!==l){let r,s,c;switch(this.type){case e.FloatType:c=l.length/4;const t=new Float32Array(4*c);for(let e=0;e<c;e++)n(l,4*e,t,4*e);r=t,s=e.FloatType;break;case e.HalfFloatType:c=l.length/4;const a=new Uint16Array(4*c);for(let e=0;e<c;e++)o(l,4*e,a,4*e);r=a,s=e.HalfFloatType;break;default:console.error("THREE.RGBELoader: unsupported type: ",this.type)}return{width:t,height:a,data:r,header:i.string,gamma:i.gamma,exposure:i.exposure,type:s}}}return null}setDataType(e){return this.type=e,this}load(t,r,a,n){return super.load(t,(function(t,a){switch(t.type){case e.FloatType:case e.HalfFloatType:t.encoding=e.LinearEncoding,t.minFilter=e.LinearFilter,t.magFilter=e.LinearFilter,t.generateMipmaps=!1,t.flipY=!0}r&&r(t,a)}),a,n)}}exports.RGBELoader=t;