"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.DDSLoader = void 0;
var _three = require("three");
class DDSLoader extends _three.CompressedTextureLoader {
  constructor(manager) {
    super(manager);
  }
  parse(buffer, loadMipmaps) {
    const dds = {
      mipmaps: [],
      width: 0,
      height: 0,
      format: null,
      mipmapCount: 1
    };

    // Adapted from @toji's DDS utils
    // https://github.com/toji/webgl-texture-utils/blob/master/texture-util/dds.js

    // All values and structures referenced from:
    // http://msdn.microsoft.com/en-us/library/bb943991.aspx/
    // const DDSD_CAPS = 0x1;
    // const DDSD_HEIGHT = 0x2;
    // const DDSD_WIDTH = 0x4;
    // const DDSD_PITCH = 0x8;
    // const DDSD_PIXELFORMAT = 0x1000;
    // const DDSD_LINEARSIZE = 0x80000;
    // const DDSD_DEPTH = 0x800000;
    // const DDSCAPS_COMPLEX = 0x8;
    // const DDSCAPS_MIPMAP = 0x400000;
    // const DDSCAPS_TEXTURE = 0x1000;
    // const DDSCAPS2_VOLUME = 0x200000;
    // const DDPF_ALPHAPIXELS = 0x1;
    // const DDPF_ALPHA = 0x2;
    // const DDPF_FOURCC = 0x4;
    // const DDPF_RGB = 0x40;
    // const DDPF_YUV = 0x200;
    // const DDPF_LUMINANCE = 0x20000;
    function fourCCToInt32(value) {
      return value.charCodeAt(0) + (value.charCodeAt(1) << 8) + (value.charCodeAt(2) << 16) + (value.charCodeAt(3) << 24);
    }
    function int32ToFourCC(value) {
      return String.fromCharCode(value & 0xff, value >> 8 & 0xff, value >> 16 & 0xff, value >> 24 & 0xff);
    }
    function loadARGBMip(buffer, dataOffset, width, height) {
      const dataLength = width * height * 4;
      const srcBuffer = new Uint8Array(buffer, dataOffset, dataLength);
      const byteArray = new Uint8Array(dataLength);
      let dst = 0;
      let src = 0;
      for (let y = 0; y < height; y++) {
        for (let x = 0; x < width; x++) {
          const b = srcBuffer[src];
          src++;
          const g = srcBuffer[src];
          src++;
          const r = srcBuffer[src];
          src++;
          const a = srcBuffer[src];
          src++;
          byteArray[dst] = r;
          dst++; //r
          byteArray[dst] = g;
          dst++; //g
          byteArray[dst] = b;
          dst++; //b
          byteArray[dst] = a;
          dst++; //a
        }
      }

      return byteArray;
    }
    const FOURCC_DXT1 = fourCCToInt32('DXT1');
    const FOURCC_DXT3 = fourCCToInt32('DXT3');
    const FOURCC_DXT5 = fourCCToInt32('DXT5');
    const FOURCC_ETC1 = fourCCToInt32('ETC1');
    const FOURCC_DX10 = fourCCToInt32('DX10');
    const headerLengthInt = 31; // The header length in 32 bit ints
    const extendedHeaderLengthInt = 5; // The extended header length in 32 bit ints

    // Offsets into the header array
    // const off_pfFlags = 20;
    // const off_caps = 27;
    // const off_caps3 = 29;
    // const off_caps4 = 30;
    // If fourCC = DX10, the extended header starts after 32
    // Parse header

    const header = new Int32Array(buffer, 0, headerLengthInt);
    if (header[0] !== 0x20534444) {
      console.error('THREE.DDSLoader.parse: Invalid magic number in DDS header.');
      return dds;
    }
    let blockBytes;
    const fourCC = header[21];
    let isRGBAUncompressed = false;
    let dataOffset = header[1] + 4;
    switch (fourCC) {
      case FOURCC_DXT1:
        blockBytes = 8;
        dds.format = _three.RGB_S3TC_DXT1_Format;
        break;
      case FOURCC_DXT3:
        blockBytes = 16;
        dds.format = _three.RGBA_S3TC_DXT3_Format;
        break;
      case FOURCC_DXT5:
        blockBytes = 16;
        dds.format = _three.RGBA_S3TC_DXT5_Format;
        break;
      case FOURCC_ETC1:
        blockBytes = 8;
        dds.format = _three.RGB_ETC1_Format;
        break;
      case FOURCC_DX10:
        dataOffset += extendedHeaderLengthInt * 4;
        const extendedHeader = new Int32Array(buffer, (headerLengthInt + 1) * 4, extendedHeaderLengthInt);
        const dxgiFormat = extendedHeader[0];
        switch (dxgiFormat) {
          case 96:
            {
              blockBytes = 16;
              dds.format = _three.RGB_BPTC_SIGNED_Format;
              break;
            }
          case 95:
            {
              blockBytes = 16;
              dds.format = _three.RGB_BPTC_UNSIGNED_Format;
              break;
            }
          default:
            {
              console.error('THREE.DDSLoader.parse: Unsupported DXGI_FORMAT code ', dxgiFormat);
              return dds;
            }
        }
        break;
      default:
        if (header[22] === 32 && header[23] & 0xff0000 && header[24] & 0xff00 && header[25] & 0xff && header[26] & 0xff000000) {
          isRGBAUncompressed = true;
          blockBytes = 64;
          dds.format = _three.RGBAFormat;
        } else {
          console.error('THREE.DDSLoader.parse: Unsupported FourCC code ', int32ToFourCC(fourCC));
          return dds;
        }
    }
    dds.mipmapCount = 1;
    if (header[2] & 0x20000 && loadMipmaps !== false) {
      dds.mipmapCount = Math.max(1, header[7]);
    }
    const caps2 = header[28];
    dds.isCubemap = caps2 & 0x200 ? true : false;
    if (dds.isCubemap && (!(caps2 & 0x400) || !(caps2 & 0x800) || !(caps2 & 0x1000) || !(caps2 & 0x2000) || !(caps2 & 0x4000) || !(caps2 & 0x8000))) {
      console.error('THREE.DDSLoader.parse: Incomplete cubemap faces');
      return dds;
    }
    dds.width = header[4];
    dds.height = header[3];

    // Extract mipmaps buffers

    const faces = dds.isCubemap ? 6 : 1;
    for (let face = 0; face < faces; face++) {
      let width = dds.width;
      let height = dds.height;
      for (let i = 0; i < dds.mipmapCount; i++) {
        let byteArray, dataLength;
        if (isRGBAUncompressed) {
          byteArray = loadARGBMip(buffer, dataOffset, width, height);
          dataLength = byteArray.length;
        } else {
          dataLength = Math.max(4, width) / 4 * Math.max(4, height) / 4 * blockBytes;
          byteArray = new Uint8Array(buffer, dataOffset, dataLength);
        }
        const mipmap = {
          'data': byteArray,
          'width': width,
          'height': height
        };
        dds.mipmaps.push(mipmap);
        dataOffset += dataLength;
        width = Math.max(width >> 1, 1);
        height = Math.max(height >> 1, 1);
      }
    }
    return dds;
  }
}
exports.DDSLoader = DDSLoader;