KTXLoader.js 6.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180
  1. import {
  2. CompressedTextureLoader
  3. } from '../../../build/three.module.js';
  4. /**
  5. * for description see https://www.khronos.org/opengles/sdk/tools/KTX/
  6. * for file layout see https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/
  7. *
  8. * ported from https://github.com/BabylonJS/Babylon.js/blob/master/src/Tools/babylon.khronosTextureContainer.ts
  9. */
  10. var KTXLoader = function ( manager ) {
  11. CompressedTextureLoader.call( this, manager );
  12. };
  13. KTXLoader.prototype = Object.assign( Object.create( CompressedTextureLoader.prototype ), {
  14. constructor: KTXLoader,
  15. parse: function ( buffer, loadMipmaps ) {
  16. var ktx = new KhronosTextureContainer( buffer, 1 );
  17. return {
  18. mipmaps: ktx.mipmaps( loadMipmaps ),
  19. width: ktx.pixelWidth,
  20. height: ktx.pixelHeight,
  21. format: ktx.glInternalFormat,
  22. isCubemap: ktx.numberOfFaces === 6,
  23. mipmapCount: ktx.numberOfMipmapLevels
  24. };
  25. }
  26. } );
  27. var KhronosTextureContainer = ( function () {
  28. /**
  29. * @param {ArrayBuffer} arrayBuffer- contents of the KTX container file
  30. * @param {number} facesExpected- should be either 1 or 6, based whether a cube texture or or
  31. * @param {boolean} threeDExpected- provision for indicating that data should be a 3D texture, not implemented
  32. * @param {boolean} textureArrayExpected- provision for indicating that data should be a texture array, not implemented
  33. */
  34. function KhronosTextureContainer( arrayBuffer, facesExpected /*, threeDExpected, textureArrayExpected */ ) {
  35. this.arrayBuffer = arrayBuffer;
  36. // Test that it is a ktx formatted file, based on the first 12 bytes, character representation is:
  37. // '´', 'K', 'T', 'X', ' ', '1', '1', 'ª', '\r', '\n', '\x1A', '\n'
  38. // 0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A
  39. var identifier = new Uint8Array( this.arrayBuffer, 0, 12 );
  40. if ( identifier[ 0 ] !== 0xAB ||
  41. identifier[ 1 ] !== 0x4B ||
  42. identifier[ 2 ] !== 0x54 ||
  43. identifier[ 3 ] !== 0x58 ||
  44. identifier[ 4 ] !== 0x20 ||
  45. identifier[ 5 ] !== 0x31 ||
  46. identifier[ 6 ] !== 0x31 ||
  47. identifier[ 7 ] !== 0xBB ||
  48. identifier[ 8 ] !== 0x0D ||
  49. identifier[ 9 ] !== 0x0A ||
  50. identifier[ 10 ] !== 0x1A ||
  51. identifier[ 11 ] !== 0x0A ) {
  52. console.error( 'texture missing KTX identifier' );
  53. return;
  54. }
  55. // load the reset of the header in native 32 bit uint
  56. var dataSize = Uint32Array.BYTES_PER_ELEMENT;
  57. var headerDataView = new DataView( this.arrayBuffer, 12, 13 * dataSize );
  58. var endianness = headerDataView.getUint32( 0, true );
  59. var littleEndian = endianness === 0x04030201;
  60. this.glType = headerDataView.getUint32( 1 * dataSize, littleEndian ); // must be 0 for compressed textures
  61. this.glTypeSize = headerDataView.getUint32( 2 * dataSize, littleEndian ); // must be 1 for compressed textures
  62. this.glFormat = headerDataView.getUint32( 3 * dataSize, littleEndian ); // must be 0 for compressed textures
  63. this.glInternalFormat = headerDataView.getUint32( 4 * dataSize, littleEndian ); // the value of arg passed to gl.compressedTexImage2D(,,x,,,,)
  64. this.glBaseInternalFormat = headerDataView.getUint32( 5 * dataSize, littleEndian ); // specify GL_RGB, GL_RGBA, GL_ALPHA, etc (un-compressed only)
  65. this.pixelWidth = headerDataView.getUint32( 6 * dataSize, littleEndian ); // level 0 value of arg passed to gl.compressedTexImage2D(,,,x,,,)
  66. this.pixelHeight = headerDataView.getUint32( 7 * dataSize, littleEndian ); // level 0 value of arg passed to gl.compressedTexImage2D(,,,,x,,)
  67. this.pixelDepth = headerDataView.getUint32( 8 * dataSize, littleEndian ); // level 0 value of arg passed to gl.compressedTexImage3D(,,,,,x,,)
  68. this.numberOfArrayElements = headerDataView.getUint32( 9 * dataSize, littleEndian ); // used for texture arrays
  69. this.numberOfFaces = headerDataView.getUint32( 10 * dataSize, littleEndian ); // used for cubemap textures, should either be 1 or 6
  70. this.numberOfMipmapLevels = headerDataView.getUint32( 11 * dataSize, littleEndian ); // number of levels; disregard possibility of 0 for compressed textures
  71. this.bytesOfKeyValueData = headerDataView.getUint32( 12 * dataSize, littleEndian ); // the amount of space after the header for meta-data
  72. // Make sure we have a compressed type. Not only reduces work, but probably better to let dev know they are not compressing.
  73. if ( this.glType !== 0 ) {
  74. console.warn( 'only compressed formats currently supported' );
  75. return;
  76. } else {
  77. // value of zero is an indication to generate mipmaps @ runtime. Not usually allowed for compressed, so disregard.
  78. this.numberOfMipmapLevels = Math.max( 1, this.numberOfMipmapLevels );
  79. }
  80. if ( this.pixelHeight === 0 || this.pixelDepth !== 0 ) {
  81. console.warn( 'only 2D textures currently supported' );
  82. return;
  83. }
  84. if ( this.numberOfArrayElements !== 0 ) {
  85. console.warn( 'texture arrays not currently supported' );
  86. return;
  87. }
  88. if ( this.numberOfFaces !== facesExpected ) {
  89. console.warn( 'number of faces expected' + facesExpected + ', but found ' + this.numberOfFaces );
  90. return;
  91. }
  92. // we now have a completely validated file, so could use existence of loadType as success
  93. // would need to make this more elaborate & adjust checks above to support more than one load type
  94. this.loadType = KhronosTextureContainer.COMPRESSED_2D;
  95. }
  96. // return mipmaps for js
  97. KhronosTextureContainer.prototype.mipmaps = function ( loadMipmaps ) {
  98. var mipmaps = [];
  99. // initialize width & height for level 1
  100. var dataOffset = KhronosTextureContainer.HEADER_LEN + this.bytesOfKeyValueData;
  101. var width = this.pixelWidth;
  102. var height = this.pixelHeight;
  103. var mipmapCount = loadMipmaps ? this.numberOfMipmapLevels : 1;
  104. for ( var level = 0; level < mipmapCount; level ++ ) {
  105. var imageSize = new Int32Array( this.arrayBuffer, dataOffset, 1 )[ 0 ]; // size per face, since not supporting array cubemaps
  106. dataOffset += 4; // size of the image + 4 for the imageSize field
  107. for ( var face = 0; face < this.numberOfFaces; face ++ ) {
  108. var byteArray = new Uint8Array( this.arrayBuffer, dataOffset, imageSize );
  109. mipmaps.push( { 'data': byteArray, 'width': width, 'height': height } );
  110. dataOffset += imageSize;
  111. dataOffset += 3 - ( ( imageSize + 3 ) % 4 ); // add padding for odd sized image
  112. }
  113. width = Math.max( 1.0, width * 0.5 );
  114. height = Math.max( 1.0, height * 0.5 );
  115. }
  116. return mipmaps;
  117. };
  118. KhronosTextureContainer.HEADER_LEN = 12 + ( 13 * 4 ); // identifier + header elements (not including key value meta-data pairs)
  119. // load types
  120. KhronosTextureContainer.COMPRESSED_2D = 0; // uses a gl.compressedTexImage2D()
  121. KhronosTextureContainer.COMPRESSED_3D = 1; // uses a gl.compressedTexImage3D()
  122. KhronosTextureContainer.TEX_2D = 2; // uses a gl.texImage2D()
  123. KhronosTextureContainer.TEX_3D = 3; // uses a gl.texImage3D()
  124. return KhronosTextureContainer;
  125. }() );
  126. export { KTXLoader };