RGBELoader.js 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491
  1. import {
  2. DataTextureLoader,
  3. DataUtils,
  4. FloatType,
  5. HalfFloatType,
  6. LinearEncoding,
  7. LinearFilter,
  8. NearestFilter,
  9. RGBEEncoding,
  10. RGBEFormat,
  11. RGBFormat,
  12. UnsignedByteType
  13. } from '../../../build/three.module.js';
  14. // https://github.com/mrdoob/three.js/issues/5552
  15. // http://en.wikipedia.org/wiki/RGBE_image_format
  16. var RGBELoader = function ( manager ) {
  17. DataTextureLoader.call( this, manager );
  18. this.type = UnsignedByteType;
  19. };
  20. RGBELoader.prototype = Object.assign( Object.create( DataTextureLoader.prototype ), {
  21. constructor: RGBELoader,
  22. // adapted from http://www.graphics.cornell.edu/~bjw/rgbe.html
  23. parse: function ( buffer ) {
  24. var
  25. /* return codes for rgbe routines */
  26. //RGBE_RETURN_SUCCESS = 0,
  27. RGBE_RETURN_FAILURE = - 1,
  28. /* default error routine. change this to change error handling */
  29. rgbe_read_error = 1,
  30. rgbe_write_error = 2,
  31. rgbe_format_error = 3,
  32. rgbe_memory_error = 4,
  33. rgbe_error = function ( rgbe_error_code, msg ) {
  34. switch ( rgbe_error_code ) {
  35. case rgbe_read_error: console.error( 'THREE.RGBELoader Read Error: ' + ( msg || '' ) );
  36. break;
  37. case rgbe_write_error: console.error( 'THREE.RGBELoader Write Error: ' + ( msg || '' ) );
  38. break;
  39. case rgbe_format_error: console.error( 'THREE.RGBELoader Bad File Format: ' + ( msg || '' ) );
  40. break;
  41. default:
  42. case rgbe_memory_error: console.error( 'THREE.RGBELoader: Error: ' + ( msg || '' ) );
  43. }
  44. return RGBE_RETURN_FAILURE;
  45. },
  46. /* offsets to red, green, and blue components in a data (float) pixel */
  47. //RGBE_DATA_RED = 0,
  48. //RGBE_DATA_GREEN = 1,
  49. //RGBE_DATA_BLUE = 2,
  50. /* number of floats per pixel, use 4 since stored in rgba image format */
  51. //RGBE_DATA_SIZE = 4,
  52. /* flags indicating which fields in an rgbe_header_info are valid */
  53. RGBE_VALID_PROGRAMTYPE = 1,
  54. RGBE_VALID_FORMAT = 2,
  55. RGBE_VALID_DIMENSIONS = 4,
  56. NEWLINE = '\n',
  57. fgets = function ( buffer, lineLimit, consume ) {
  58. lineLimit = ! lineLimit ? 1024 : lineLimit;
  59. var p = buffer.pos,
  60. i = - 1, len = 0, s = '', chunkSize = 128,
  61. chunk = String.fromCharCode.apply( null, new Uint16Array( buffer.subarray( p, p + chunkSize ) ) )
  62. ;
  63. while ( ( 0 > ( i = chunk.indexOf( NEWLINE ) ) ) && ( len < lineLimit ) && ( p < buffer.byteLength ) ) {
  64. s += chunk; len += chunk.length;
  65. p += chunkSize;
  66. chunk += String.fromCharCode.apply( null, new Uint16Array( buffer.subarray( p, p + chunkSize ) ) );
  67. }
  68. if ( - 1 < i ) {
  69. /*for (i=l-1; i>=0; i--) {
  70. byteCode = m.charCodeAt(i);
  71. if (byteCode > 0x7f && byteCode <= 0x7ff) byteLen++;
  72. else if (byteCode > 0x7ff && byteCode <= 0xffff) byteLen += 2;
  73. if (byteCode >= 0xDC00 && byteCode <= 0xDFFF) i--; //trail surrogate
  74. }*/
  75. if ( false !== consume ) buffer.pos += len + i + 1;
  76. return s + chunk.slice( 0, i );
  77. }
  78. return false;
  79. },
  80. /* minimal header reading. modify if you want to parse more information */
  81. RGBE_ReadHeader = function ( buffer ) {
  82. var line, match,
  83. // regexes to parse header info fields
  84. magic_token_re = /^#\?(\S+)/,
  85. gamma_re = /^\s*GAMMA\s*=\s*(\d+(\.\d+)?)\s*$/,
  86. exposure_re = /^\s*EXPOSURE\s*=\s*(\d+(\.\d+)?)\s*$/,
  87. format_re = /^\s*FORMAT=(\S+)\s*$/,
  88. dimensions_re = /^\s*\-Y\s+(\d+)\s+\+X\s+(\d+)\s*$/,
  89. // RGBE format header struct
  90. header = {
  91. valid: 0, /* indicate which fields are valid */
  92. string: '', /* the actual header string */
  93. comments: '', /* comments found in header */
  94. programtype: 'RGBE', /* listed at beginning of file to identify it after "#?". defaults to "RGBE" */
  95. format: '', /* RGBE format, default 32-bit_rle_rgbe */
  96. gamma: 1.0, /* image has already been gamma corrected with given gamma. defaults to 1.0 (no correction) */
  97. exposure: 1.0, /* a value of 1.0 in an image corresponds to <exposure> watts/steradian/m^2. defaults to 1.0 */
  98. width: 0, height: 0 /* image dimensions, width/height */
  99. };
  100. if ( buffer.pos >= buffer.byteLength || ! ( line = fgets( buffer ) ) ) {
  101. return rgbe_error( rgbe_read_error, 'no header found' );
  102. }
  103. /* if you want to require the magic token then uncomment the next line */
  104. if ( ! ( match = line.match( magic_token_re ) ) ) {
  105. return rgbe_error( rgbe_format_error, 'bad initial token' );
  106. }
  107. header.valid |= RGBE_VALID_PROGRAMTYPE;
  108. header.programtype = match[ 1 ];
  109. header.string += line + '\n';
  110. while ( true ) {
  111. line = fgets( buffer );
  112. if ( false === line ) break;
  113. header.string += line + '\n';
  114. if ( '#' === line.charAt( 0 ) ) {
  115. header.comments += line + '\n';
  116. continue; // comment line
  117. }
  118. if ( match = line.match( gamma_re ) ) {
  119. header.gamma = parseFloat( match[ 1 ], 10 );
  120. }
  121. if ( match = line.match( exposure_re ) ) {
  122. header.exposure = parseFloat( match[ 1 ], 10 );
  123. }
  124. if ( match = line.match( format_re ) ) {
  125. header.valid |= RGBE_VALID_FORMAT;
  126. header.format = match[ 1 ];//'32-bit_rle_rgbe';
  127. }
  128. if ( match = line.match( dimensions_re ) ) {
  129. header.valid |= RGBE_VALID_DIMENSIONS;
  130. header.height = parseInt( match[ 1 ], 10 );
  131. header.width = parseInt( match[ 2 ], 10 );
  132. }
  133. if ( ( header.valid & RGBE_VALID_FORMAT ) && ( header.valid & RGBE_VALID_DIMENSIONS ) ) break;
  134. }
  135. if ( ! ( header.valid & RGBE_VALID_FORMAT ) ) {
  136. return rgbe_error( rgbe_format_error, 'missing format specifier' );
  137. }
  138. if ( ! ( header.valid & RGBE_VALID_DIMENSIONS ) ) {
  139. return rgbe_error( rgbe_format_error, 'missing image size specifier' );
  140. }
  141. return header;
  142. },
  143. RGBE_ReadPixels_RLE = function ( buffer, w, h ) {
  144. var data_rgba, offset, pos, count, byteValue,
  145. scanline_buffer, ptr, ptr_end, i, l, off, isEncodedRun,
  146. scanline_width = w, num_scanlines = h, rgbeStart
  147. ;
  148. if (
  149. // run length encoding is not allowed so read flat
  150. ( ( scanline_width < 8 ) || ( scanline_width > 0x7fff ) ) ||
  151. // this file is not run length encoded
  152. ( ( 2 !== buffer[ 0 ] ) || ( 2 !== buffer[ 1 ] ) || ( buffer[ 2 ] & 0x80 ) )
  153. ) {
  154. // return the flat buffer
  155. return new Uint8Array( buffer );
  156. }
  157. if ( scanline_width !== ( ( buffer[ 2 ] << 8 ) | buffer[ 3 ] ) ) {
  158. return rgbe_error( rgbe_format_error, 'wrong scanline width' );
  159. }
  160. data_rgba = new Uint8Array( 4 * w * h );
  161. if ( ! data_rgba.length ) {
  162. return rgbe_error( rgbe_memory_error, 'unable to allocate buffer space' );
  163. }
  164. offset = 0; pos = 0; ptr_end = 4 * scanline_width;
  165. rgbeStart = new Uint8Array( 4 );
  166. scanline_buffer = new Uint8Array( ptr_end );
  167. // read in each successive scanline
  168. while ( ( num_scanlines > 0 ) && ( pos < buffer.byteLength ) ) {
  169. if ( pos + 4 > buffer.byteLength ) {
  170. return rgbe_error( rgbe_read_error );
  171. }
  172. rgbeStart[ 0 ] = buffer[ pos ++ ];
  173. rgbeStart[ 1 ] = buffer[ pos ++ ];
  174. rgbeStart[ 2 ] = buffer[ pos ++ ];
  175. rgbeStart[ 3 ] = buffer[ pos ++ ];
  176. if ( ( 2 != rgbeStart[ 0 ] ) || ( 2 != rgbeStart[ 1 ] ) || ( ( ( rgbeStart[ 2 ] << 8 ) | rgbeStart[ 3 ] ) != scanline_width ) ) {
  177. return rgbe_error( rgbe_format_error, 'bad rgbe scanline format' );
  178. }
  179. // read each of the four channels for the scanline into the buffer
  180. // first red, then green, then blue, then exponent
  181. ptr = 0;
  182. while ( ( ptr < ptr_end ) && ( pos < buffer.byteLength ) ) {
  183. count = buffer[ pos ++ ];
  184. isEncodedRun = count > 128;
  185. if ( isEncodedRun ) count -= 128;
  186. if ( ( 0 === count ) || ( ptr + count > ptr_end ) ) {
  187. return rgbe_error( rgbe_format_error, 'bad scanline data' );
  188. }
  189. if ( isEncodedRun ) {
  190. // a (encoded) run of the same value
  191. byteValue = buffer[ pos ++ ];
  192. for ( i = 0; i < count; i ++ ) {
  193. scanline_buffer[ ptr ++ ] = byteValue;
  194. }
  195. //ptr += count;
  196. } else {
  197. // a literal-run
  198. scanline_buffer.set( buffer.subarray( pos, pos + count ), ptr );
  199. ptr += count; pos += count;
  200. }
  201. }
  202. // now convert data from buffer into rgba
  203. // first red, then green, then blue, then exponent (alpha)
  204. l = scanline_width; //scanline_buffer.byteLength;
  205. for ( i = 0; i < l; i ++ ) {
  206. off = 0;
  207. data_rgba[ offset ] = scanline_buffer[ i + off ];
  208. off += scanline_width; //1;
  209. data_rgba[ offset + 1 ] = scanline_buffer[ i + off ];
  210. off += scanline_width; //1;
  211. data_rgba[ offset + 2 ] = scanline_buffer[ i + off ];
  212. off += scanline_width; //1;
  213. data_rgba[ offset + 3 ] = scanline_buffer[ i + off ];
  214. offset += 4;
  215. }
  216. num_scanlines --;
  217. }
  218. return data_rgba;
  219. };
  220. var RGBEByteToRGBFloat = function ( sourceArray, sourceOffset, destArray, destOffset ) {
  221. var e = sourceArray[ sourceOffset + 3 ];
  222. var scale = Math.pow( 2.0, e - 128.0 ) / 255.0;
  223. destArray[ destOffset + 0 ] = sourceArray[ sourceOffset + 0 ] * scale;
  224. destArray[ destOffset + 1 ] = sourceArray[ sourceOffset + 1 ] * scale;
  225. destArray[ destOffset + 2 ] = sourceArray[ sourceOffset + 2 ] * scale;
  226. };
  227. var RGBEByteToRGBHalf = function ( sourceArray, sourceOffset, destArray, destOffset ) {
  228. var e = sourceArray[ sourceOffset + 3 ];
  229. var scale = Math.pow( 2.0, e - 128.0 ) / 255.0;
  230. destArray[ destOffset + 0 ] = DataUtils.toHalfFloat( sourceArray[ sourceOffset + 0 ] * scale );
  231. destArray[ destOffset + 1 ] = DataUtils.toHalfFloat( sourceArray[ sourceOffset + 1 ] * scale );
  232. destArray[ destOffset + 2 ] = DataUtils.toHalfFloat( sourceArray[ sourceOffset + 2 ] * scale );
  233. };
  234. var byteArray = new Uint8Array( buffer );
  235. byteArray.pos = 0;
  236. var rgbe_header_info = RGBE_ReadHeader( byteArray );
  237. if ( RGBE_RETURN_FAILURE !== rgbe_header_info ) {
  238. var w = rgbe_header_info.width,
  239. h = rgbe_header_info.height,
  240. image_rgba_data = RGBE_ReadPixels_RLE( byteArray.subarray( byteArray.pos ), w, h );
  241. if ( RGBE_RETURN_FAILURE !== image_rgba_data ) {
  242. switch ( this.type ) {
  243. case UnsignedByteType:
  244. var data = image_rgba_data;
  245. var format = RGBEFormat; // handled as THREE.RGBAFormat in shaders
  246. var type = UnsignedByteType;
  247. break;
  248. case FloatType:
  249. var numElements = ( image_rgba_data.length / 4 ) * 3;
  250. var floatArray = new Float32Array( numElements );
  251. for ( var j = 0; j < numElements; j ++ ) {
  252. RGBEByteToRGBFloat( image_rgba_data, j * 4, floatArray, j * 3 );
  253. }
  254. var data = floatArray;
  255. var format = RGBFormat;
  256. var type = FloatType;
  257. break;
  258. case HalfFloatType:
  259. var numElements = ( image_rgba_data.length / 4 ) * 3;
  260. var halfArray = new Uint16Array( numElements );
  261. for ( var j = 0; j < numElements; j ++ ) {
  262. RGBEByteToRGBHalf( image_rgba_data, j * 4, halfArray, j * 3 );
  263. }
  264. var data = halfArray;
  265. var format = RGBFormat;
  266. var type = HalfFloatType;
  267. break;
  268. default:
  269. console.error( 'THREE.RGBELoader: unsupported type: ', this.type );
  270. break;
  271. }
  272. return {
  273. width: w, height: h,
  274. data: data,
  275. header: rgbe_header_info.string,
  276. gamma: rgbe_header_info.gamma,
  277. exposure: rgbe_header_info.exposure,
  278. format: format,
  279. type: type
  280. };
  281. }
  282. }
  283. return null;
  284. },
  285. setDataType: function ( value ) {
  286. this.type = value;
  287. return this;
  288. },
  289. load: function ( url, onLoad, onProgress, onError ) {
  290. function onLoadCallback( texture, texData ) {
  291. switch ( texture.type ) {
  292. case UnsignedByteType:
  293. texture.encoding = RGBEEncoding;
  294. texture.minFilter = NearestFilter;
  295. texture.magFilter = NearestFilter;
  296. texture.generateMipmaps = false;
  297. texture.flipY = true;
  298. break;
  299. case FloatType:
  300. texture.encoding = LinearEncoding;
  301. texture.minFilter = LinearFilter;
  302. texture.magFilter = LinearFilter;
  303. texture.generateMipmaps = false;
  304. texture.flipY = true;
  305. break;
  306. case HalfFloatType:
  307. texture.encoding = LinearEncoding;
  308. texture.minFilter = LinearFilter;
  309. texture.magFilter = LinearFilter;
  310. texture.generateMipmaps = false;
  311. texture.flipY = true;
  312. break;
  313. }
  314. if ( onLoad ) onLoad( texture, texData );
  315. }
  316. return DataTextureLoader.prototype.load.call( this, url, onLoadCallback, onProgress, onError );
  317. }
  318. } );
  319. export { RGBELoader };