home *** CD-ROM | disk | FTP | other *** search
/ Xentax forum attachments archive / xentax.7z / 5036 / source.7z / x_dds.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2011-12-13  |  11.7 KB  |  456 lines
  1. #include "xentax.h"
  2.  
  3. BOOL CreateUncompressedDDSHeader(DWORD dx, DWORD dy, DWORD mipmaps, DWORD maskR, DWORD maskG, DWORD maskB, DWORD maskA, BOOL cubemap, DDS_HEADER* header)
  4. {
  5.  // validate
  6.  if(!header) return FALSE;
  7.  if(dx == 0) return FALSE;
  8.  if(dy == 0) return FALSE;
  9.  
  10.  // set header size
  11.  header->dwSize = 124;
  12.  
  13.  // set flags
  14.  header->dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PITCH | DDSD_PIXELFORMAT;
  15.  if(mipmaps) header->dwFlags |= DDSD_MIPMAPCOUNT;
  16.  
  17.  // set dimensions
  18.  header->dwHeight = dy;
  19.  header->dwWidth  = dx;
  20.  header->dwDepth  = 0;
  21.  
  22.  // set pitch
  23.  DWORD bpp = 0;
  24.  if(maskR) bpp += 8;
  25.  if(maskG) bpp += 8;
  26.  if(maskB) bpp += 8;
  27.  if(maskA) bpp += 8;
  28.  header->dwPitchOrLinearSize = (bpp*dx + 7)/8;
  29.  
  30.  // set mipmap count
  31.  header->dwMipMapCount = mipmaps;
  32.  
  33.  // set reserved data
  34.  header->dwReserved01 = 0;
  35.  header->dwReserved02 = 0;
  36.  header->dwReserved03 = 0;
  37.  header->dwReserved04 = 0;
  38.  header->dwReserved05 = 0;
  39.  header->dwReserved06 = 0;
  40.  header->dwReserved07 = 0;
  41.  header->dwReserved08 = 0;
  42.  header->dwReserved09 = 0;
  43.  header->dwReserved10 = 0;
  44.  header->dwReserved11 = 0;
  45.  
  46.  // set pixel format
  47.  header->ddspf.dwSize = 32;
  48.  header->ddspf.dwFlags = DDPF_RGB;
  49.  if(maskA) header->ddspf.dwFlags |= DDPF_ALPHAPIXELS;
  50.  header->ddspf.dwFourCC = 0;
  51.  header->ddspf.dwRGBBitCount = bpp;
  52.  header->ddspf.dwRBitMask = maskR;
  53.  header->ddspf.dwGBitMask = maskG;
  54.  header->ddspf.dwBBitMask = maskB;
  55.  header->ddspf.dwABitMask = maskA;
  56.  
  57.  // set capabilities
  58.  DWORD DDS_CUBEMAP_ALLFACES = 0xFC00;
  59.  header->dwCaps1 = DDSCAPS_TEXTURE;
  60.  if(mipmaps) header->dwCaps1 |= (DDSCAPS_COMPLEX | DDSCAPS_MIPMAP);
  61.  header->dwCaps2 = 0;
  62.  if(mipmaps) header->dwCaps2 |= (DDSCAPS2_CUBEMAP | DDS_CUBEMAP_ALLFACES);
  63.  header->dwCaps3 = 0;
  64.  header->dwCaps4 = 0;
  65.  header->dwReserved12 = 0;
  66.  
  67.  return TRUE;
  68. }
  69.  
  70. BOOL CreateDXT1Header(DWORD dx, DWORD dy, DWORD mipmaps, BOOL cubemap, DDS_HEADER* header)
  71. {
  72.  // validate
  73.  if(!header) return FALSE;
  74.  if(dx == 0) return FALSE;
  75.  if(dy == 0) return FALSE;
  76.  
  77.  // set header size
  78.  header->dwSize = 124;
  79.  
  80.  // set flags
  81.  header->dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_LINEARSIZE | DDSD_PIXELFORMAT;
  82.  if(mipmaps) header->dwFlags |= DDSD_MIPMAPCOUNT;
  83.  
  84.  // set dimensions
  85.  header->dwHeight = dy;
  86.  header->dwWidth  = dx;
  87.  header->dwDepth  = 0;
  88.  
  89.  // set linear size
  90.  DWORD blocksize = 8;
  91.  DWORD rows = std::max((DWORD)1, (DWORD)((dy + 3)/4));
  92.  DWORD cols = std::max((DWORD)1, (DWORD)((dx + 3)/4));
  93.  header->dwPitchOrLinearSize = rows*cols*blocksize;
  94.  
  95.  // set mipmap count
  96.  header->dwMipMapCount = mipmaps;
  97.  
  98.  // set reserved data
  99.  header->dwReserved01 = 0;
  100.  header->dwReserved02 = 0;
  101.  header->dwReserved03 = 0;
  102.  header->dwReserved04 = 0;
  103.  header->dwReserved05 = 0;
  104.  header->dwReserved06 = 0;
  105.  header->dwReserved07 = 0;
  106.  header->dwReserved08 = 0;
  107.  header->dwReserved09 = 0;
  108.  header->dwReserved10 = 0;
  109.  header->dwReserved11 = 0;
  110.  
  111.  // set pixel format
  112.  header->ddspf.dwSize = 32;
  113.  header->ddspf.dwFlags = DDPF_FOURCC;
  114.  header->ddspf.dwFourCC = 0x31545844;
  115.  
  116.  // set capabilities
  117.  DWORD DDS_CUBEMAP_ALLFACES = 0xFC00;
  118.  header->dwCaps1 = DDSCAPS_TEXTURE;
  119.  if(mipmaps) header->dwCaps1 |= (DDSCAPS_COMPLEX | DDSCAPS_MIPMAP);
  120.  header->dwCaps2 = 0;
  121.  if(mipmaps) header->dwCaps2 |= (DDSCAPS2_CUBEMAP | DDS_CUBEMAP_ALLFACES);
  122.  header->dwCaps3 = 0;
  123.  header->dwCaps4 = 0;
  124.  header->dwReserved12 = 0;
  125.  
  126.  return TRUE;
  127. }
  128.  
  129. BOOL CreateDXT2Header(DWORD dx, DWORD dy, DWORD mipmaps, BOOL cubemap, DDS_HEADER* header)
  130. {
  131.  // validate
  132.  if(!header) return FALSE;
  133.  if(dx == 0) return FALSE;
  134.  if(dy == 0) return FALSE;
  135.  
  136.  // set header size
  137.  header->dwSize = 124;
  138.  
  139.  // set flags
  140.  header->dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_LINEARSIZE | DDSD_PIXELFORMAT;
  141.  if(mipmaps) header->dwFlags |= DDSD_MIPMAPCOUNT;
  142.  
  143.  // set dimensions
  144.  header->dwHeight = dy;
  145.  header->dwWidth  = dx;
  146.  header->dwDepth  = 0;
  147.  
  148.  // set linear size
  149.  DWORD blocksize = 16;
  150.  DWORD rows = std::max((DWORD)1, (DWORD)((dy + 3)/4));
  151.  DWORD cols = std::max((DWORD)1, (DWORD)((dx + 3)/4));
  152.  header->dwPitchOrLinearSize = rows*cols*blocksize;
  153.  
  154.  // set mipmap count
  155.  header->dwMipMapCount = mipmaps;
  156.  
  157.  // set reserved data
  158.  header->dwReserved01 = 0;
  159.  header->dwReserved02 = 0;
  160.  header->dwReserved03 = 0;
  161.  header->dwReserved04 = 0;
  162.  header->dwReserved05 = 0;
  163.  header->dwReserved06 = 0;
  164.  header->dwReserved07 = 0;
  165.  header->dwReserved08 = 0;
  166.  header->dwReserved09 = 0;
  167.  header->dwReserved10 = 0;
  168.  header->dwReserved11 = 0;
  169.  
  170.  // set pixel format
  171.  header->ddspf.dwSize = 32;
  172.  header->ddspf.dwFlags = DDPF_FOURCC;
  173.  header->ddspf.dwFourCC = 0x32545844;
  174.  
  175.  // set capabilities
  176.  DWORD DDS_CUBEMAP_ALLFACES = 0xFC00;
  177.  header->dwCaps1 = DDSCAPS_TEXTURE;
  178.  if(mipmaps) header->dwCaps1 |= (DDSCAPS_COMPLEX | DDSCAPS_MIPMAP);
  179.  header->dwCaps2 = 0;
  180.  if(mipmaps) header->dwCaps2 |= (DDSCAPS2_CUBEMAP | DDS_CUBEMAP_ALLFACES);
  181.  header->dwCaps3 = 0;
  182.  header->dwCaps4 = 0;
  183.  header->dwReserved12 = 0;
  184.  
  185.  return TRUE;
  186. }
  187.  
  188. BOOL CreateDXT3Header(DWORD dx, DWORD dy, DWORD mipmaps, BOOL cubemap, DDS_HEADER* header)
  189. {
  190.  // validate
  191.  if(!header) return FALSE;
  192.  if(dx == 0) return FALSE;
  193.  if(dy == 0) return FALSE;
  194.  
  195.  // set header size
  196.  header->dwSize = 124;
  197.  
  198.  // set flags
  199.  header->dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_LINEARSIZE | DDSD_PIXELFORMAT;
  200.  if(mipmaps) header->dwFlags |= DDSD_MIPMAPCOUNT;
  201.  
  202.  // set dimensions
  203.  header->dwHeight = dy;
  204.  header->dwWidth  = dx;
  205.  header->dwDepth  = 0;
  206.  
  207.  // set linear size
  208.  DWORD blocksize = 16;
  209.  DWORD rows = std::max((DWORD)1, (DWORD)((dy + 3)/4));
  210.  DWORD cols = std::max((DWORD)1, (DWORD)((dx + 3)/4));
  211.  header->dwPitchOrLinearSize = rows*cols*blocksize;
  212.  
  213.  // set mipmap count
  214.  header->dwMipMapCount = mipmaps;
  215.  
  216.  // set reserved data
  217.  header->dwReserved01 = 0;
  218.  header->dwReserved02 = 0;
  219.  header->dwReserved03 = 0;
  220.  header->dwReserved04 = 0;
  221.  header->dwReserved05 = 0;
  222.  header->dwReserved06 = 0;
  223.  header->dwReserved07 = 0;
  224.  header->dwReserved08 = 0;
  225.  header->dwReserved09 = 0;
  226.  header->dwReserved10 = 0;
  227.  header->dwReserved11 = 0;
  228.  
  229.  // set pixel format
  230.  header->ddspf.dwSize = 32;
  231.  header->ddspf.dwFlags = DDPF_FOURCC;
  232.  header->ddspf.dwFourCC = 0x33545844;
  233.  
  234.  // set capabilities
  235.  DWORD DDS_CUBEMAP_ALLFACES = 0xFC00;
  236.  header->dwCaps1 = DDSCAPS_TEXTURE;
  237.  if(mipmaps) header->dwCaps1 |= (DDSCAPS_COMPLEX | DDSCAPS_MIPMAP);
  238.  header->dwCaps2 = 0;
  239.  if(mipmaps) header->dwCaps2 |= (DDSCAPS2_CUBEMAP | DDS_CUBEMAP_ALLFACES);
  240.  header->dwCaps3 = 0;
  241.  header->dwCaps4 = 0;
  242.  header->dwReserved12 = 0;
  243.  
  244.  return TRUE;
  245. }
  246.  
  247. BOOL CreateDXT4Header(DWORD dx, DWORD dy, DWORD mipmaps, BOOL cubemap, DDS_HEADER* header)
  248. {
  249.  // validate
  250.  if(!header) return FALSE;
  251.  if(dx == 0) return FALSE;
  252.  if(dy == 0) return FALSE;
  253.  
  254.  // set header size
  255.  header->dwSize = 124;
  256.  
  257.  // set flags
  258.  header->dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_LINEARSIZE | DDSD_PIXELFORMAT;
  259.  if(mipmaps) header->dwFlags |= DDSD_MIPMAPCOUNT;
  260.  
  261.  // set dimensions
  262.  header->dwHeight = dy;
  263.  header->dwWidth  = dx;
  264.  header->dwDepth  = 0;
  265.  
  266.  // set linear size
  267.  DWORD blocksize = 16;
  268.  DWORD rows = std::max((DWORD)1, (DWORD)((dy + 3)/4));
  269.  DWORD cols = std::max((DWORD)1, (DWORD)((dx + 3)/4));
  270.  header->dwPitchOrLinearSize = rows*cols*blocksize;
  271.  
  272.  // set mipmap count
  273.  header->dwMipMapCount = mipmaps;
  274.  
  275.  // set reserved data
  276.  header->dwReserved01 = 0;
  277.  header->dwReserved02 = 0;
  278.  header->dwReserved03 = 0;
  279.  header->dwReserved04 = 0;
  280.  header->dwReserved05 = 0;
  281.  header->dwReserved06 = 0;
  282.  header->dwReserved07 = 0;
  283.  header->dwReserved08 = 0;
  284.  header->dwReserved09 = 0;
  285.  header->dwReserved10 = 0;
  286.  header->dwReserved11 = 0;
  287.  
  288.  // set pixel format
  289.  header->ddspf.dwSize = 32;
  290.  header->ddspf.dwFlags = DDPF_FOURCC;
  291.  header->ddspf.dwFourCC = 0x34545844;
  292.  
  293.  // set capabilities
  294.  DWORD DDS_CUBEMAP_ALLFACES = 0xFC00;
  295.  header->dwCaps1 = DDSCAPS_TEXTURE;
  296.  if(mipmaps) header->dwCaps1 |= (DDSCAPS_COMPLEX | DDSCAPS_MIPMAP);
  297.  header->dwCaps2 = 0;
  298.  if(mipmaps) header->dwCaps2 |= (DDSCAPS2_CUBEMAP | DDS_CUBEMAP_ALLFACES);
  299.  header->dwCaps3 = 0;
  300.  header->dwCaps4 = 0;
  301.  header->dwReserved12 = 0;
  302.  
  303.  return TRUE;
  304. }
  305.  
  306. BOOL CreateDXT5Header(DWORD dx, DWORD dy, DWORD mipmaps, BOOL cubemap, DDS_HEADER* header)
  307. {
  308.  // validate
  309.  if(!header) return FALSE;
  310.  if(dx == 0) return FALSE;
  311.  if(dy == 0) return FALSE;
  312.  
  313.  // set header size
  314.  header->dwSize = 124;
  315.  
  316.  // set flags
  317.  header->dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_LINEARSIZE | DDSD_PIXELFORMAT;
  318.  if(mipmaps) header->dwFlags |= DDSD_MIPMAPCOUNT;
  319.  
  320.  // set dimensions
  321.  header->dwHeight = dy;
  322.  header->dwWidth  = dx;
  323.  header->dwDepth  = 0;
  324.  
  325.  // set linear size
  326.  DWORD blocksize = 16;
  327.  DWORD rows = std::max((DWORD)1, (DWORD)((dy + 3)/4));
  328.  DWORD cols = std::max((DWORD)1, (DWORD)((dx + 3)/4));
  329.  header->dwPitchOrLinearSize = 0;//rows*cols*blocksize;
  330.  
  331.  // set mipmap count
  332.  header->dwMipMapCount = mipmaps;
  333.  
  334.  // set reserved data
  335.  header->dwReserved01 = 0;
  336.  header->dwReserved02 = 0;
  337.  header->dwReserved03 = 0;
  338.  header->dwReserved04 = 0;
  339.  header->dwReserved05 = 0;
  340.  header->dwReserved06 = 0;
  341.  header->dwReserved07 = 0;
  342.  header->dwReserved08 = 0;
  343.  header->dwReserved09 = 0;
  344.  header->dwReserved10 = 0;
  345.  header->dwReserved11 = 0;
  346.  
  347.  // set pixel format
  348.  header->ddspf.dwSize = 32;
  349.  header->ddspf.dwFlags = DDPF_FOURCC;
  350.  header->ddspf.dwFourCC = 0x35545844;
  351.  
  352.  // set capabilities
  353.  DWORD DDS_CUBEMAP_ALLFACES = 0xFC00;
  354.  header->dwCaps1 = DDSCAPS_TEXTURE;
  355.  if(mipmaps) header->dwCaps1 |= (DDSCAPS_COMPLEX | DDSCAPS_MIPMAP);
  356.  header->dwCaps2 = 0;
  357.  if(mipmaps) header->dwCaps2 |= (DDSCAPS2_CUBEMAP | DDS_CUBEMAP_ALLFACES);
  358.  header->dwCaps3 = 0;
  359.  header->dwCaps4 = 0;
  360.  header->dwReserved12 = 0;
  361.  
  362.  return TRUE;
  363. }
  364.  
  365. DWORD UncompressedDDSFileSize(DWORD dx, DWORD dy, DWORD mipmaps, DWORD maskR, DWORD maskG, DWORD maskB, DWORD maskA)
  366. {
  367.  // validate
  368.  if(dx == 0) return 0;
  369.  if(dy == 0) return 0;
  370.  
  371.  // compute filesize
  372.  DWORD bpp = 0;
  373.  if(maskR) bpp += 8;
  374.  if(maskG) bpp += 8;
  375.  if(maskB) bpp += 8;
  376.  if(maskA) bpp += 8;
  377.  
  378.  // TODO: handle mipmaps
  379.  return ((bpp*dx + 7)/8)*dy;
  380. }
  381.  
  382. DWORD DXT1Filesize(DWORD dx, DWORD dy, DWORD mipmaps)
  383. {
  384.  // validate
  385.  if(dx == 0) return 0;
  386.  if(dy == 0) return 0;
  387.  
  388.  // set linear size
  389.  DWORD blocksize = 8;
  390.  DWORD rows = std::max((DWORD)1, (DWORD)((dy + 3)/4));
  391.  DWORD cols = std::max((DWORD)1, (DWORD)((dx + 3)/4));
  392.  
  393.  // TODO: handle mipmaps
  394.  return rows*cols*blocksize;
  395. }
  396.  
  397. DWORD DXT2Filesize(DWORD dx, DWORD dy, DWORD mipmaps)
  398. {
  399.  // validate
  400.  if(dx == 0) return 0;
  401.  if(dy == 0) return 0;
  402.  
  403.  // set linear size
  404.  DWORD blocksize = 16;
  405.  DWORD rows = std::max((DWORD)1, (DWORD)((dy + 3)/4));
  406.  DWORD cols = std::max((DWORD)1, (DWORD)((dx + 3)/4));
  407.  
  408.  // TODO: handle mipmaps
  409.  return rows*cols*blocksize;
  410. }
  411.  
  412. DWORD DXT3Filesize(DWORD dx, DWORD dy, DWORD mipmaps)
  413. {
  414.  // validate
  415.  if(dx == 0) return 0;
  416.  if(dy == 0) return 0;
  417.  
  418.  // set linear size
  419.  DWORD blocksize = 16;
  420.  DWORD rows = std::max((DWORD)1, (DWORD)((dy + 3)/4));
  421.  DWORD cols = std::max((DWORD)1, (DWORD)((dx + 3)/4));
  422.  
  423.  // TODO: handle mipmaps
  424.  return rows*cols*blocksize;
  425. }
  426.  
  427. DWORD DXT4Filesize(DWORD dx, DWORD dy, DWORD mipmaps)
  428. {
  429.  // validate
  430.  if(dx == 0) return 0;
  431.  if(dy == 0) return 0;
  432.  
  433.  // set linear size
  434.  DWORD blocksize = 16;
  435.  DWORD rows = std::max((DWORD)1, (DWORD)((dy + 3)/4));
  436.  DWORD cols = std::max((DWORD)1, (DWORD)((dx + 3)/4));
  437.  
  438.  // TODO: handle mipmaps
  439.  return rows*cols*blocksize;
  440. }
  441.  
  442. DWORD DXT5Filesize(DWORD dx, DWORD dy, DWORD mipmaps)
  443. {
  444.  // validate
  445.  if(dx == 0) return 0;
  446.  if(dy == 0) return 0;
  447.  
  448.  // set linear size
  449.  DWORD blocksize = 16;
  450.  DWORD rows = std::max((DWORD)1, (DWORD)((dy + 3)/4));
  451.  DWORD cols = std::max((DWORD)1, (DWORD)((dx + 3)/4));
  452.  
  453.  // TODO: handle mipmaps
  454.  return rows*cols*blocksize;
  455. }
  456.