blitzkit/src/core/streams/dds.ts

import { times } from 'lodash';
import { readDVPLFile } from '../blitz/readDVPLFile';
import { WindowsStream } from './windows';

type Bits2 = 0b00 | 0b01 | 0b10 | 0b11;

enum DxgiFormat {
  UNKNOWN = 0,
  R32G32B32A32_TYPELESS = 1,
  R32G32B32A32_FLOAT = 2,
  R32G32B32A32_UINT = 3,
  R32G32B32A32_SINT = 4,
  R32G32B32_TYPELESS = 5,
  R32G32B32_FLOAT = 6,
  R32G32B32_UINT = 7,
  R32G32B32_SINT = 8,
  R16G16B16A16_TYPELESS = 9,
  R16G16B16A16_FLOAT = 10,
  R16G16B16A16_UNORM = 11,
  R16G16B16A16_UINT = 12,
  R16G16B16A16_SNORM = 13,
  R16G16B16A16_SINT = 14,
  R32G32_TYPELESS = 15,
  R32G32_FLOAT = 16,
  R32G32_UINT = 17,
  R32G32_SINT = 18,
  R32G8X24_TYPELESS = 19,
  D32_FLOAT_S8X24_UINT = 20,
  R32_FLOAT_X8X24_TYPELESS = 21,
  X32_TYPELESS_G8X24_UINT = 22,
  R10G10B10A2_TYPELESS = 23,
  R10G10B10A2_UNORM = 24,
  R10G10B10A2_UINT = 25,
  R11G11B10_FLOAT = 26,
  R8G8B8A8_TYPELESS = 27,
  R8G8B8A8_UNORM = 28,
  R8G8B8A8_UNORM_SRGB = 29,
  R8G8B8A8_UINT = 30,
  R8G8B8A8_SNORM = 31,
  R8G8B8A8_SINT = 32,
  R16G16_TYPELESS = 33,
  R16G16_FLOAT = 34,
  R16G16_UNORM = 35,
  R16G16_UINT = 36,
  R16G16_SNORM = 37,
  R16G16_SINT = 38,
  R32_TYPELESS = 39,
  D32_FLOAT = 40,
  R32_FLOAT = 41,
  R32_UINT = 42,
  R32_SINT = 43,
  R24G8_TYPELESS = 44,
  D24_UNORM_S8_UINT = 45,
  R24_UNORM_X8_TYPELESS = 46,
  X24_TYPELESS_G8_UINT = 47,
  R8G8_TYPELESS = 48,
  R8G8_UNORM = 49,
  R8G8_UINT = 50,
  R8G8_SNORM = 51,
  R8G8_SINT = 52,
  R16_TYPELESS = 53,
  R16_FLOAT = 54,
  D16_UNORM = 55,
  R16_UNORM = 56,
  R16_UINT = 57,
  R16_SNORM = 58,
  R16_SINT = 59,
  R8_TYPELESS = 60,
  R8_UNORM = 61,
  R8_UINT = 62,
  R8_SNORM = 63,
  R8_SINT = 64,
  A8_UNORM = 65,
  R1_UNORM = 66,
  R9G9B9E5_SHAREDEXP = 67,
  R8G8_B8G8_UNORM = 68,
  G8R8_G8B8_UNORM = 69,
  BC1_TYPELESS = 70,
  BC1_UNORM = 71,
  BC1_UNORM_SRGB = 72,
  BC2_TYPELESS = 73,
  BC2_UNORM = 74,
  BC2_UNORM_SRGB = 75,
  BC3_TYPELESS = 76,
  BC3_UNORM = 77,
  BC3_UNORM_SRGB = 78,
  BC4_TYPELESS = 79,
  BC4_UNORM = 80,
  BC4_SNORM = 81,
  BC5_TYPELESS = 82,
  BC5_UNORM = 83,
  BC5_SNORM = 84,
  B5G6R5_UNORM = 85,
  B5G5R5A1_UNORM = 86,
  B8G8R8A8_UNORM = 87,
  B8G8R8X8_UNORM = 88,
  R10G10B10_XR_BIAS_A2_UNORM = 89,
  B8G8R8A8_TYPELESS = 90,
  B8G8R8A8_UNORM_SRGB = 91,
  B8G8R8X8_TYPELESS = 92,
  B8G8R8X8_UNORM_SRGB = 93,
  BC6H_TYPELESS = 94,
  BC6H_UF16 = 95,
  BC6H_SF16 = 96,
  BC7_TYPELESS = 97,
  BC7_UNORM = 98,
  BC7_UNORM_SRGB = 99,
  AYUV = 100,
  Y410 = 101,
  Y416 = 102,
  NV12 = 103,
  P010 = 104,
  P016 = 105,
  '420_OPAQUE' = 106,
  YUY2 = 107,
  Y210 = 108,
  Y216 = 109,
  NV11 = 110,
  AI44 = 111,
  IA44 = 112,
  P8 = 113,
  A8P8 = 114,
  B4G4R4A4_UNORM = 115,
  P208 = 130,
  V208 = 131,
  V408 = 132,
  SAMPLER_FEEDBACK_MIN_MIP_OPAQUE,
  SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE,
  FORCE_UINT = 0xffffffff,
}

enum DdsDimension {
  UNKNOWN = 0,
  BUFFER = 1,
  TEXTURE1D = 2,
  TEXTURE2D = 3,
  TEXTURE3D = 4,
}

enum DdsdFlags {
  CAPS = 0x1,
  HEIGHT = 0x2,
  WIDTH = 0x4,
  PITCH = 0x8,
  PIXELFORMAT = 0x1000,
  MIPMAPCOUNT = 0x20000,
  LINEARSIZE = 0x80000,
  DEPTH = 0x800000,
}

enum DdpfFlags {
  ALPHA = 0x1,
  FOURCC = 0x4,
  RGB = 0x40,
  YUV = 0x200,
  LUMINANCE = 0x20000,
}

enum DdsCaps {
  COMPLEX = 0x8,
  MIPMAP = 0x400000,
  TEXTURE = 0x1000,
}

enum DdsCaps2 {
  CUBEMAP = 0x200,
  CUBEMAP_POSITIVEX = 0x400,
  CUBEMAP_NEGATIVEX = 0x800,
  CUBEMAP_POSITIVEY = 0x1000,
  CUBEMAP_NEGATIVEY = 0x2000,
  CUBEMAP_POSITIVEZ = 0x4000,
  CUBEMAP_NEGATIVEZ = 0x8000,
  VOLUME = 0x200000,
}

export class DdsStream extends WindowsStream {
  async dds() {
    this.magicNumber();

    const header = this.header();

    if (header.pf.flags !== DdpfFlags.FOURCC || header.pf.fourCC !== 'DX10') {
      throw new RangeError('No other formats other than DX10 are supported');
    }

    const headerDxt10 = this.headerDxt10();

    switch (headerDxt10.dxgiFormat) {
      case DxgiFormat.BC1_UNORM_SRGB: {
        if (header.width % 4 !== 0 || header.height % 4 !== 0) {
          throw new RangeError('Width and height must be divisible by 4');
        }

        const data = Buffer.alloc(header.width * header.height * 4);
        const blocksX = header.width / 4;
        const blocksY = header.height / 4;

        times(blocksX * blocksY, (blockIndex) => {
          const blockPosX = (blockIndex % blocksX) * 4;
          const blockPosY = Math.floor(blockIndex / blocksX) * 4;
          const interpolations = this.interpolations();
          const indices = this.indices();

          indices.forEach((index, indexIndex) => {
            let pixelPosX = 4 - (indexIndex % 4);
            let pixelPosY = Math.floor(indexIndex / 4);
            let x = blockPosX + pixelPosX;
            let y = blockPosY + pixelPosY;

            const bufferIndex = 4 * (y * header.width + x);
            const color = interpolations[index].map((standard) =>
              Math.round(255 * standard),
            );

            data[bufferIndex] = color[0];
            data[bufferIndex + 1] = color[1];
            data[bufferIndex + 2] = color[2];
            data[bufferIndex + 3] = color[3];
          });
        });

        // writeFileSync(
        //   'dist/assets/models/15697/baseColor_1.jpg',
        //   await sharp(image, {
        //     raw: {
        //       width: header.width,
        //       height: header.height,
        //       channels: 4,
        //     },
        //   })
        //     .jpeg()
        //     .toBuffer(),
        // );

        return {
          width: header.width,
          height: header.height,
          channels: 4 as const,
          data,
        };

        break;
      }

      default:
        throw new TypeError(
          `Unsupported DXGI format: ${DxgiFormat[headerDxt10.dxgiFormat]} (${
            headerDxt10.dxgiFormat
          })`,
        );
    }
  }

  interpolations() {
    const buffer0 = this.consume(2);
    const buffer1 = this.consume(2);
    const int0 = buffer0.readUInt16LE();
    const int1 = buffer1.readUInt16LE();
    const alpha = int0 < int1;
    const color0 = [
      ((buffer0[1] & 0b11111000) >>> 3) / 0x1f,
      (((buffer0[1] & 0b111) << 3) + ((buffer0[0] & 0b11100000) >>> 5)) / 0x3f,
      (buffer0[0] & 0b11111) / 0x1f,
      1,
    ];
    const color1 = [
      ((buffer1[1] & 0b11111000) >>> 3) / 0x1f,
      (((buffer1[1] & 0b111) << 3) + ((buffer1[0] & 0b11100000) >>> 5)) / 0x3f,
      (buffer1[0] & 0b11111) / 0x1f,
      1,
    ];
    const color2 = alpha
      ? color0.map((channel0, index) => (channel0 + color1[index]) / 2)
      : color0.map((channel0, index) => (2 * channel0 + color1[index]) / 3);
    const color3 = alpha
      ? [0, 0, 0, 0]
      : color0.map((channel0, index) => (channel0 + 2 * color1[index]) / 3);

    return {
      [0b00]: color0,
      [0b01]: color1,
      [0b10]: color2,
      [0b11]: color3,
    };
  }

  indices() {
    const indicesBuffer = this.consume(4);
    const indices = times(16, (index) => {
      const bufferIndex = Math.floor(index / 4);
      const maskShift = 2 * (index % 4);
      const valueShift = 2 * (3 - (index % 4));
      const buffer = indicesBuffer[bufferIndex];
      const mask = 0b11000000 >>> maskShift;
      const masked = buffer & mask;
      const value = masked >>> valueShift;

      return value as Bits2;
    });

    return indices;
  }

  magicNumber() {
    const magic = this.dword();

    if (magic !== 0x20534444) {
      throw new Error(`Invalid DDS magic number: 0x${magic.toString(16)}`);
    }

    return magic;
  }

  header() {
    return {
      size: this.dword(),
      flags: this.dword() as DdsdFlags,
      height: this.dword(),
      width: this.dword(),
      pitchOrLinearSize: this.dword(),
      depth: this.dword(),
      mipMapCount: this.dword(),
      reserved1: times(11, () => this.dword()),
      pf: this.pixelFormat(),
      caps: this.dword() as DdsCaps,
      caps2: this.dword() as DdsCaps2,
      caps3: this.dword(),
      caps4: this.dword(),
      reserved2: times(1, () => this.dword()),
    };
  }

  pixelFormat() {
    return {
      size: this.dword(),
      flags: this.dword() as DdpfFlags,
      fourCC: this.ascii(4),
      rgbBitCount: this.dword(),
      rBitMask: this.dword(),
      gBitMask: this.dword(),
      bBitMask: this.dword(),
      aBitMask: this.dword(),
    };
  }

  headerDxt10() {
    return {
      dxgiFormat: this.dword() as DxgiFormat,
      resourceDimension: this.dword() as DdsDimension,
      miscFlag: this.dword(),
      arraySize: this.dword(),
      miscFlags2: this.dword(),
    };
  }
}

new DdsStream(
  await readDVPLFile(
    'C:/Program Files (x86)/Steam/steamapps/common/World of Tanks Blitz/Data/3d/Tanks/GB/images_pbr/Chieftain_Mk6_BC.dx11.dds.dvpl',
  ),
).dds();