three-stdlib 2.15.1 → 2.16.0

package/loaders/RGBELoader.js

@@ -1,381 +1,244 @@
-import { DataTextureLoader, HalfFloatType, FloatType, DataUtils, LinearEncoding, LinearFilter } from 'three';
-
-// http://en.wikipedia.org/wiki/RGBE_image_format
-
-class RGBELoader extends DataTextureLoader {
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+class RGBELoader extends THREE.DataTextureLoader {
   constructor(manager) {
     super(manager);
-    this.type = HalfFloatType;
-  } // adapted from http://www.graphics.cornell.edu/~bjw/rgbe.html
-
-
+    this.type = THREE.HalfFloatType;
+  }
   parse(buffer) {
-    const
-    /* return codes for rgbe routines */
-    //RGBE_RETURN_SUCCESS = 0,
-    RGBE_RETURN_FAILURE = -1,
-
-    /* default error routine.  change this to change error handling */
-    rgbe_read_error = 1,
-          rgbe_write_error = 2,
-          rgbe_format_error = 3,
-          rgbe_memory_error = 4,
-          rgbe_error = function (rgbe_error_code, msg) {
+    const RGBE_RETURN_FAILURE = -1, rgbe_read_error = 1, rgbe_write_error = 2, rgbe_format_error = 3, rgbe_memory_error = 4, rgbe_error = function(rgbe_error_code, msg) {
       switch (rgbe_error_code) {
         case rgbe_read_error:
-          console.error('THREE.RGBELoader Read Error: ' + (msg || ''));
+          console.error("THREE.RGBELoader Read Error: " + (msg || ""));
           break;
-
         case rgbe_write_error:
-          console.error('THREE.RGBELoader Write Error: ' + (msg || ''));
+          console.error("THREE.RGBELoader Write Error: " + (msg || ""));
           break;
-
         case rgbe_format_error:
-          console.error('THREE.RGBELoader Bad File Format: ' + (msg || ''));
+          console.error("THREE.RGBELoader Bad File Format: " + (msg || ""));
           break;
-
         default:
         case rgbe_memory_error:
-          console.error('THREE.RGBELoader: Error: ' + (msg || ''));
+          console.error("THREE.RGBELoader: Error: " + (msg || ""));
       }
-
       return RGBE_RETURN_FAILURE;
-    },
-
-    /* offsets to red, green, and blue components in a data (float) pixel */
-    //RGBE_DATA_RED = 0,
-    //RGBE_DATA_GREEN = 1,
-    //RGBE_DATA_BLUE = 2,
-
-    /* number of floats per pixel, use 4 since stored in rgba image format */
-    //RGBE_DATA_SIZE = 4,
-
-    /* flags indicating which fields in an rgbe_header_info are valid */
-    RGBE_VALID_PROGRAMTYPE = 1,
-          RGBE_VALID_FORMAT = 2,
-          RGBE_VALID_DIMENSIONS = 4,
-          NEWLINE = '\n',
-          fgets = function (buffer, lineLimit, consume) {
+    }, RGBE_VALID_PROGRAMTYPE = 1, RGBE_VALID_FORMAT = 2, RGBE_VALID_DIMENSIONS = 4, NEWLINE = "\n", fgets = function(buffer2, lineLimit, consume) {
       const chunkSize = 128;
       lineLimit = !lineLimit ? 1024 : lineLimit;
-      let p = buffer.pos,
-          i = -1,
-          len = 0,
-          s = '',
-          chunk = String.fromCharCode.apply(null, new Uint16Array(buffer.subarray(p, p + chunkSize)));
-
-      while (0 > (i = chunk.indexOf(NEWLINE)) && len < lineLimit && p < buffer.byteLength) {
+      let p = buffer2.pos, i = -1, len = 0, s = "", chunk = String.fromCharCode.apply(null, new Uint16Array(buffer2.subarray(p, p + chunkSize)));
+      while (0 > (i = chunk.indexOf(NEWLINE)) && len < lineLimit && p < buffer2.byteLength) {
         s += chunk;
         len += chunk.length;
         p += chunkSize;
-        chunk += String.fromCharCode.apply(null, new Uint16Array(buffer.subarray(p, p + chunkSize)));
+        chunk += String.fromCharCode.apply(null, new Uint16Array(buffer2.subarray(p, p + chunkSize)));
       }
-
       if (-1 < i) {
-        /*for (i=l-1; i>=0; i--) {
-        byteCode = m.charCodeAt(i);
-        if (byteCode > 0x7f && byteCode <= 0x7ff) byteLen++;
-        else if (byteCode > 0x7ff && byteCode <= 0xffff) byteLen += 2;
-        if (byteCode >= 0xDC00 && byteCode <= 0xDFFF) i--; //trail surrogate
-        }*/
-        if (false !== consume) buffer.pos += len + i + 1;
+        if (false !== consume)
+          buffer2.pos += len + i + 1;
         return s + chunk.slice(0, i);
       }
-
       return false;
-    },
-
-    /* minimal header reading.  modify if you want to parse more information */
-    RGBE_ReadHeader = function (buffer) {
-      // regexes to parse header info fields
-      const magic_token_re = /^#\?(\S+)/,
-            gamma_re = /^\s*GAMMA\s*=\s*(\d+(\.\d+)?)\s*$/,
-            exposure_re = /^\s*EXPOSURE\s*=\s*(\d+(\.\d+)?)\s*$/,
-            format_re = /^\s*FORMAT=(\S+)\s*$/,
-            dimensions_re = /^\s*\-Y\s+(\d+)\s+\+X\s+(\d+)\s*$/,
-            // RGBE format header struct
-      header = {
-        valid: 0
-        /* indicate which fields are valid */
-        ,
-        string: ''
-        /* the actual header string */
-        ,
-        comments: ''
-        /* comments found in header */
-        ,
-        programtype: 'RGBE'
-        /* listed at beginning of file to identify it after "#?". defaults to "RGBE" */
-        ,
-        format: ''
-        /* RGBE format, default 32-bit_rle_rgbe */
-        ,
-        gamma: 1.0
-        /* image has already been gamma corrected with given gamma. defaults to 1.0 (no correction) */
-        ,
-        exposure: 1.0
-        /* a value of 1.0 in an image corresponds to <exposure> watts/steradian/m^2. defaults to 1.0 */
-        ,
+    }, RGBE_ReadHeader = function(buffer2) {
+      const magic_token_re = /^#\?(\S+)/, gamma_re = /^\s*GAMMA\s*=\s*(\d+(\.\d+)?)\s*$/, exposure_re = /^\s*EXPOSURE\s*=\s*(\d+(\.\d+)?)\s*$/, format_re = /^\s*FORMAT=(\S+)\s*$/, dimensions_re = /^\s*\-Y\s+(\d+)\s+\+X\s+(\d+)\s*$/, header = {
+        valid: 0,
+        string: "",
+        comments: "",
+        programtype: "RGBE",
+        format: "",
+        gamma: 1,
+        exposure: 1,
         width: 0,
         height: 0
-        /* image dimensions, width/height */
-
       };
       let line, match;
-
-      if (buffer.pos >= buffer.byteLength || !(line = fgets(buffer))) {
-        return rgbe_error(rgbe_read_error, 'no header found');
+      if (buffer2.pos >= buffer2.byteLength || !(line = fgets(buffer2))) {
+        return rgbe_error(rgbe_read_error, "no header found");
       }
-      /* if you want to require the magic token then uncomment the next line */
-
-
       if (!(match = line.match(magic_token_re))) {
-        return rgbe_error(rgbe_format_error, 'bad initial token');
+        return rgbe_error(rgbe_format_error, "bad initial token");
       }
-
       header.valid |= RGBE_VALID_PROGRAMTYPE;
       header.programtype = match[1];
-      header.string += line + '\n';
-
+      header.string += line + "\n";
       while (true) {
-        line = fgets(buffer);
-        if (false === line) break;
-        header.string += line + '\n';
-
-        if ('#' === line.charAt(0)) {
-          header.comments += line + '\n';
-          continue; // comment line
+        line = fgets(buffer2);
+        if (false === line)
+          break;
+        header.string += line + "\n";
+        if ("#" === line.charAt(0)) {
+          header.comments += line + "\n";
+          continue;
         }
-
         if (match = line.match(gamma_re)) {
           header.gamma = parseFloat(match[1]);
         }
-
         if (match = line.match(exposure_re)) {
           header.exposure = parseFloat(match[1]);
         }
-
         if (match = line.match(format_re)) {
           header.valid |= RGBE_VALID_FORMAT;
-          header.format = match[1]; //'32-bit_rle_rgbe';
+          header.format = match[1];
         }
-
         if (match = line.match(dimensions_re)) {
           header.valid |= RGBE_VALID_DIMENSIONS;
           header.height = parseInt(match[1], 10);
           header.width = parseInt(match[2], 10);
         }
-
-        if (header.valid & RGBE_VALID_FORMAT && header.valid & RGBE_VALID_DIMENSIONS) break;
+        if (header.valid & RGBE_VALID_FORMAT && header.valid & RGBE_VALID_DIMENSIONS)
+          break;
       }
-
       if (!(header.valid & RGBE_VALID_FORMAT)) {
-        return rgbe_error(rgbe_format_error, 'missing format specifier');
+        return rgbe_error(rgbe_format_error, "missing format specifier");
       }
-
       if (!(header.valid & RGBE_VALID_DIMENSIONS)) {
-        return rgbe_error(rgbe_format_error, 'missing image size specifier');
+        return rgbe_error(rgbe_format_error, "missing image size specifier");
       }
-
       return header;
-    },
-          RGBE_ReadPixels_RLE = function (buffer, w, h) {
+    }, RGBE_ReadPixels_RLE = function(buffer2, w, h) {
       const scanline_width = w;
-
-      if ( // run length encoding is not allowed so read flat
-      scanline_width < 8 || scanline_width > 0x7fff || // this file is not run length encoded
-      2 !== buffer[0] || 2 !== buffer[1] || buffer[2] & 0x80) {
-        // return the flat buffer
-        return new Uint8Array(buffer);
+      if (scanline_width < 8 || scanline_width > 32767 || 2 !== buffer2[0] || 2 !== buffer2[1] || buffer2[2] & 128) {
+        return new Uint8Array(buffer2);
       }
-
-      if (scanline_width !== (buffer[2] << 8 | buffer[3])) {
-        return rgbe_error(rgbe_format_error, 'wrong scanline width');
+      if (scanline_width !== (buffer2[2] << 8 | buffer2[3])) {
+        return rgbe_error(rgbe_format_error, "wrong scanline width");
       }
-
       const data_rgba = new Uint8Array(4 * w * h);
-
       if (!data_rgba.length) {
-        return rgbe_error(rgbe_memory_error, 'unable to allocate buffer space');
+        return rgbe_error(rgbe_memory_error, "unable to allocate buffer space");
       }
-
-      let offset = 0,
-          pos = 0;
+      let offset = 0, pos = 0;
       const ptr_end = 4 * scanline_width;
       const rgbeStart = new Uint8Array(4);
       const scanline_buffer = new Uint8Array(ptr_end);
-      let num_scanlines = h; // read in each successive scanline
-
-      while (num_scanlines > 0 && pos < buffer.byteLength) {
-        if (pos + 4 > buffer.byteLength) {
+      let num_scanlines = h;
+      while (num_scanlines > 0 && pos < buffer2.byteLength) {
+        if (pos + 4 > buffer2.byteLength) {
           return rgbe_error(rgbe_read_error);
         }
-
-        rgbeStart[0] = buffer[pos++];
-        rgbeStart[1] = buffer[pos++];
-        rgbeStart[2] = buffer[pos++];
-        rgbeStart[3] = buffer[pos++];
-
+        rgbeStart[0] = buffer2[pos++];
+        rgbeStart[1] = buffer2[pos++];
+        rgbeStart[2] = buffer2[pos++];
+        rgbeStart[3] = buffer2[pos++];
         if (2 != rgbeStart[0] || 2 != rgbeStart[1] || (rgbeStart[2] << 8 | rgbeStart[3]) != scanline_width) {
-          return rgbe_error(rgbe_format_error, 'bad rgbe scanline format');
-        } // read each of the four channels for the scanline into the buffer
-        // first red, then green, then blue, then exponent
-
-
-        let ptr = 0,
-            count;
-
-        while (ptr < ptr_end && pos < buffer.byteLength) {
-          count = buffer[pos++];
+          return rgbe_error(rgbe_format_error, "bad rgbe scanline format");
+        }
+        let ptr = 0, count;
+        while (ptr < ptr_end && pos < buffer2.byteLength) {
+          count = buffer2[pos++];
           const isEncodedRun = count > 128;
-          if (isEncodedRun) count -= 128;
-
+          if (isEncodedRun)
+            count -= 128;
           if (0 === count || ptr + count > ptr_end) {
-            return rgbe_error(rgbe_format_error, 'bad scanline data');
+            return rgbe_error(rgbe_format_error, "bad scanline data");
           }
-
           if (isEncodedRun) {
-            // a (encoded) run of the same value
-            const byteValue = buffer[pos++];
-
+            const byteValue = buffer2[pos++];
             for (let i = 0; i < count; i++) {
               scanline_buffer[ptr++] = byteValue;
-            } //ptr += count;
-
+            }
           } else {
-            // a literal-run
-            scanline_buffer.set(buffer.subarray(pos, pos + count), ptr);
+            scanline_buffer.set(buffer2.subarray(pos, pos + count), ptr);
             ptr += count;
             pos += count;
           }
-        } // now convert data from buffer into rgba
-        // first red, then green, then blue, then exponent (alpha)
-
-
-        const l = scanline_width; //scanline_buffer.byteLength;
-
+        }
+        const l = scanline_width;
         for (let i = 0; i < l; i++) {
           let off = 0;
           data_rgba[offset] = scanline_buffer[i + off];
-          off += scanline_width; //1;
-
+          off += scanline_width;
           data_rgba[offset + 1] = scanline_buffer[i + off];
-          off += scanline_width; //1;
-
+          off += scanline_width;
           data_rgba[offset + 2] = scanline_buffer[i + off];
-          off += scanline_width; //1;
-
+          off += scanline_width;
           data_rgba[offset + 3] = scanline_buffer[i + off];
           offset += 4;
         }
-
         num_scanlines--;
       }
-
       return data_rgba;
     };
-
-    const RGBEByteToRGBFloat = function (sourceArray, sourceOffset, destArray, destOffset) {
+    const RGBEByteToRGBFloat = function(sourceArray, sourceOffset, destArray, destOffset) {
       const e = sourceArray[sourceOffset + 3];
-      const scale = Math.pow(2.0, e - 128.0) / 255.0;
+      const scale = Math.pow(2, e - 128) / 255;
       destArray[destOffset + 0] = sourceArray[sourceOffset + 0] * scale;
       destArray[destOffset + 1] = sourceArray[sourceOffset + 1] * scale;
       destArray[destOffset + 2] = sourceArray[sourceOffset + 2] * scale;
       destArray[destOffset + 3] = 1;
     };
-
-    const RGBEByteToRGBHalf = function (sourceArray, sourceOffset, destArray, destOffset) {
+    const RGBEByteToRGBHalf = function(sourceArray, sourceOffset, destArray, destOffset) {
       const e = sourceArray[sourceOffset + 3];
-      const scale = Math.pow(2.0, e - 128.0) / 255.0; // clamping to 65504, the maximum representable value in float16
-
-      destArray[destOffset + 0] = DataUtils.toHalfFloat(Math.min(sourceArray[sourceOffset + 0] * scale, 65504));
-      destArray[destOffset + 1] = DataUtils.toHalfFloat(Math.min(sourceArray[sourceOffset + 1] * scale, 65504));
-      destArray[destOffset + 2] = DataUtils.toHalfFloat(Math.min(sourceArray[sourceOffset + 2] * scale, 65504));
-      destArray[destOffset + 3] = DataUtils.toHalfFloat(1);
+      const scale = Math.pow(2, e - 128) / 255;
+      destArray[destOffset + 0] = THREE.DataUtils.toHalfFloat(Math.min(sourceArray[sourceOffset + 0] * scale, 65504));
+      destArray[destOffset + 1] = THREE.DataUtils.toHalfFloat(Math.min(sourceArray[sourceOffset + 1] * scale, 65504));
+      destArray[destOffset + 2] = THREE.DataUtils.toHalfFloat(Math.min(sourceArray[sourceOffset + 2] * scale, 65504));
+      destArray[destOffset + 3] = THREE.DataUtils.toHalfFloat(1);
     };
-
     const byteArray = new Uint8Array(buffer);
     byteArray.pos = 0;
     const rgbe_header_info = RGBE_ReadHeader(byteArray);
-
     if (RGBE_RETURN_FAILURE !== rgbe_header_info) {
-      const w = rgbe_header_info.width,
-            h = rgbe_header_info.height,
-            image_rgba_data = RGBE_ReadPixels_RLE(byteArray.subarray(byteArray.pos), w, h);
-
+      const w = rgbe_header_info.width, h = rgbe_header_info.height, image_rgba_data = RGBE_ReadPixels_RLE(byteArray.subarray(byteArray.pos), w, h);
       if (RGBE_RETURN_FAILURE !== image_rgba_data) {
         let data, type;
         let numElements;
-
         switch (this.type) {
-          case FloatType:
+          case THREE.FloatType:
             numElements = image_rgba_data.length / 4;
             const floatArray = new Float32Array(numElements * 4);
-
             for (let j = 0; j < numElements; j++) {
               RGBEByteToRGBFloat(image_rgba_data, j * 4, floatArray, j * 4);
             }
-
             data = floatArray;
-            type = FloatType;
+            type = THREE.FloatType;
             break;
-
-          case HalfFloatType:
+          case THREE.HalfFloatType:
             numElements = image_rgba_data.length / 4;
             const halfArray = new Uint16Array(numElements * 4);
-
             for (let j = 0; j < numElements; j++) {
               RGBEByteToRGBHalf(image_rgba_data, j * 4, halfArray, j * 4);
             }
-
             data = halfArray;
-            type = HalfFloatType;
+            type = THREE.HalfFloatType;
             break;
-
           default:
-            console.error('THREE.RGBELoader: unsupported type: ', this.type);
+            console.error("THREE.RGBELoader: unsupported type: ", this.type);
             break;
         }
-
         return {
           width: w,
           height: h,
-          data: data,
+          data,
           header: rgbe_header_info.string,
           gamma: rgbe_header_info.gamma,
           exposure: rgbe_header_info.exposure,
-          type: type
+          type
         };
       }
     }
-
     return null;
   }
-
   setDataType(value) {
     this.type = value;
     return this;
   }
-
   load(url, onLoad, onProgress, onError) {
     function onLoadCallback(texture, texData) {
       switch (texture.type) {
-        case FloatType:
-        case HalfFloatType:
-          texture.encoding = LinearEncoding;
-          texture.minFilter = LinearFilter;
-          texture.magFilter = LinearFilter;
+        case THREE.FloatType:
+        case THREE.HalfFloatType:
+          texture.encoding = THREE.LinearEncoding;
+          texture.minFilter = THREE.LinearFilter;
+          texture.magFilter = THREE.LinearFilter;
           texture.generateMipmaps = false;
           texture.flipY = true;
           break;
       }
-
-      if (onLoad) onLoad(texture, texData);
+      if (onLoad)
+        onLoad(texture, texData);
     }
-
     return super.load(url, onLoadCallback, onProgress, onError);
   }
-
 }
-
-export { RGBELoader };
+exports.RGBELoader = RGBELoader;