dds.h

Go to the documentation of this file.

/*! \file
  \brief This header defines constants and structures that are needed to parse DDS files.

  \par Copyright Information

  Copyright (c) 2017 by The DiSTI Corporation.<br>
  11301 Corporate Blvd; Suite 100<br>
  Orlando, Florida 32817<br>
  USA<br>
  <br>
  All rights reserved.<br>

  This Software contains proprietary trade secrets of DiSTI and may not be
reproduced, in whole or part, in any form, or by any means of electronic,
mechanical, or otherwise, without the written permission of DiSTI.  Said
permission may be derived through the purchase of applicable DiSTI product
licenses which detail the distribution rights of this content and any
Derivative Works based on this or other copyrighted DiSTI Software.

  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.

  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
EXCEED FIVE DOLLARS (US$5.00).

 The aforementioned terms and restrictions are governed by the laws of the
State of Florida and the United States of America. Use, distribution,
duplication, or disclosure by the U. S. Government is subject to
"Restricted Rights" as set forth in DFARS 252.227-7014(c)(1)(ii).

*/
#ifndef INCLUDED_DDS_H
#define INCLUDED_DDS_H

// This file is copied and modified from Lumen: cpp\src\core\textureloader\dds\dds.h

#ifdef WIN32
#    include <windows.h>
#endif

#include "DXGIFormat.h"

///////////////////////////////////////////////////////////////////////////////
// stuff from windef.h
///////////////////////////////////////////////////////////////////////////////
#ifndef _WINDEF_
#    include <stdint.h>

typedef uint32_t      DWORD; ///< Type used in orignal DirectX dds.h file
typedef unsigned char BYTE;  ///< Type used in orignal DirectX dds.h file
typedef uint32_t      UINT;  ///< Type used in orignal DirectX dds.h file

#endif // _WINDEF_

///////////////////////////////////////////////////////////////////////////////
// stuff from d3d9types.h
///////////////////////////////////////////////////////////////////////////////
#ifndef _d3d9TYPES_H_

/** Combines four charaters into a DWORD.  Used for specified compressed texture formats.
  * See http://msdn.microsoft.com/en-us/library/bb172558.aspx#DXTn_Compressed_Texture_Formats
  */
#    ifndef MAKEFOURCC
#        define MAKEFOURCC( ch0, ch1, ch2, ch3 ) \
            ( ( DWORD )( BYTE )( ch0 ) | ( ( DWORD )( BYTE )( ch1 ) << 8 ) | ( ( DWORD )( BYTE )( ch2 ) << 16 ) | ( ( DWORD )( BYTE )( ch3 ) << 24 ) )
#    endif /* defined(MAKEFOURCC) */

/** Defines the various types of surface formats.  http://msdn.microsoft.com/en-us/library/bb172558.aspx
  */
typedef enum _D3DFORMAT
{
    D3DFMT_UNKNOWN = 0,

    D3DFMT_R8G8B8       = 20,
    D3DFMT_A8R8G8B8     = 21,
    D3DFMT_X8R8G8B8     = 22,
    D3DFMT_R5G6B5       = 23,
    D3DFMT_X1R5G5B5     = 24,
    D3DFMT_A1R5G5B5     = 25,
    D3DFMT_A4R4G4B4     = 26,
    D3DFMT_R3G3B2       = 27,
    D3DFMT_A8           = 28,
    D3DFMT_A8R3G3B2     = 29,
    D3DFMT_X4R4G4B4     = 30,
    D3DFMT_A2B10G10R10  = 31,
    D3DFMT_A8B8G8R8     = 32,
    D3DFMT_X8B8G8R8     = 33,
    D3DFMT_G16R16       = 34,
    D3DFMT_A2R10G10B10  = 35,
    D3DFMT_A16B16G16R16 = 36,

    D3DFMT_A8P8 = 40,
    D3DFMT_P8   = 41,

    D3DFMT_L8   = 50,
    D3DFMT_A8L8 = 51,
    D3DFMT_A4L4 = 52,

    D3DFMT_V8U8        = 60,
    D3DFMT_L6V5U5      = 61,
    D3DFMT_X8L8V8U8    = 62,
    D3DFMT_Q8W8V8U8    = 63,
    D3DFMT_V16U16      = 64,
    D3DFMT_A2W10V10U10 = 67,

    D3DFMT_UYVY      = MAKEFOURCC( 'U', 'Y', 'V', 'Y' ),
    D3DFMT_R8G8_B8G8 = MAKEFOURCC( 'R', 'G', 'B', 'G' ),
    D3DFMT_YUY2      = MAKEFOURCC( 'Y', 'U', 'Y', '2' ),
    D3DFMT_G8R8_G8B8 = MAKEFOURCC( 'G', 'R', 'G', 'B' ),
    D3DFMT_DXT1      = MAKEFOURCC( 'D', 'X', 'T', '1' ),
    D3DFMT_DXT2      = MAKEFOURCC( 'D', 'X', 'T', '2' ),
    D3DFMT_DXT3      = MAKEFOURCC( 'D', 'X', 'T', '3' ),
    D3DFMT_DXT4      = MAKEFOURCC( 'D', 'X', 'T', '4' ),
    D3DFMT_DXT5      = MAKEFOURCC( 'D', 'X', 'T', '5' ),

    D3DFMT_D16_LOCKABLE = 70,
    D3DFMT_D32          = 71,
    D3DFMT_D15S1        = 73,
    D3DFMT_D24S8        = 75,
    D3DFMT_D24X8        = 77,
    D3DFMT_D24X4S4      = 79,
    D3DFMT_D16          = 80,

    D3DFMT_D32F_LOCKABLE = 82,
    D3DFMT_D24FS8        = 83,

/* D3D9Ex only -- */
#    if !defined( D3D_DISABLE_9EX )

    /* Z-Stencil formats valid for CPU access */
    D3DFMT_D32_LOCKABLE = 84,
    D3DFMT_S8_LOCKABLE  = 85,

#    endif // !D3D_DISABLE_9EX
           /* -- D3D9Ex only */

    D3DFMT_L16 = 81,

    D3DFMT_VERTEXDATA = 100,
    D3DFMT_INDEX16    = 101,
    D3DFMT_INDEX32    = 102,

    D3DFMT_Q16W16V16U16 = 110,

    D3DFMT_MULTI2_ARGB8 = MAKEFOURCC( 'M', 'E', 'T', '1' ),

    // Floating point surface formats

    // s10e5 formats (16-bits per channel)
    D3DFMT_R16F          = 111,
    D3DFMT_G16R16F       = 112,
    D3DFMT_A16B16G16R16F = 113,

    // IEEE s23e8 formats (32-bits per channel)
    D3DFMT_R32F          = 114,
    D3DFMT_G32R32F       = 115,
    D3DFMT_A32B32G32R32F = 116,

    D3DFMT_CxV8U8 = 117,

/* D3D9Ex only -- */
#    if !defined( D3D_DISABLE_9EX )

    // Monochrome 1 bit per pixel format
    D3DFMT_A1 = 118,

    // 2.8 biased fixed point
    D3DFMT_A2B10G10R10_XR_BIAS = 119,

    // Binary format indicating that the data has no inherent type
    D3DFMT_BINARYBUFFER = 199,

#    endif // !D3D_DISABLE_9EX
           /* -- D3D9Ex only */

    D3DFMT_FORCE_DWORD = 0x7fffffff
} D3DFORMAT;

#endif // _d3d9TYPES_H_

///////////////////////////////////////////////////////////////////////////////
// stuff from d3d10.h
///////////////////////////////////////////////////////////////////////////////
#ifndef __d3d10_h__

/** Maximum number of mipmap levels a texture resource may have.
  * http://msdn.microsoft.com/en-us/library/bb509540.aspx
  */
#    define D3D10_REQ_MIP_LEVELS ( 14 )

/** Maximum array size of a 2D texture array.
  * http://msdn.microsoft.com/en-us/library/bb509540.aspx  
  */
#    define D3D10_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION ( 512 )

/** Identifies the type of resource being used.  http://msdn.microsoft.com/en-us/library/bb172411.aspx
  */
typedef enum D3D10_RESOURCE_DIMENSION
{
    D3D10_RESOURCE_DIMENSION_UNKNOWN   = 0,
    D3D10_RESOURCE_DIMENSION_BUFFER    = 1,
    D3D10_RESOURCE_DIMENSION_TEXTURE1D = 2,
    D3D10_RESOURCE_DIMENSION_TEXTURE2D = 3,
    D3D10_RESOURCE_DIMENSION_TEXTURE3D = 4
} D3D10_RESOURCE_DIMENSION;

#endif // __d3d10_h__

///////////////////////////////////////////////////////////////////////////////
// stuff from the original dds.h
///////////////////////////////////////////////////////////////////////////////
#ifndef _DDS_H_

#    pragma pack( push, 1 )

/** A DWORD (magic number) containing the four character code value 'DDS '
  * It is the first value in a DDS file
  */
#    define DDS_MAGIC 0x20534444 // "DDS "

/** Surface pixel format.  See http://msdn.microsoft.com/en-us/library/bb943984.aspx
  */
struct DDS_PIXELFORMAT
{
    DWORD dwSize;        ///< Structure size; set to 32 (bytes).
    DWORD dwFlags;       ///< Values which indicate what type of data is in the surface.
    DWORD dwFourCC;      ///< Four-character codes for specifying compressed or custom formats.
    DWORD dwRGBBitCount; ///< Number of bits in an RGB (possibly including alpha) format.
    DWORD dwRBitMask;    ///< Red (or lumiannce or Y) mask for reading color data.
    DWORD dwGBitMask;    ///< Green (or U) mask for reading color data.
    DWORD dwBBitMask;    ///< Blue (or V) mask for reading color data.
    DWORD dwABitMask;    ///< Alpha mask for reading alpha data.
};

/// DDPF_FOURCC
/// Texture contains compressed RGB data; dwFourCC contains valid data.
#    define DDS_FOURCC 0x00000004

/// DDPF_RGB - Texture contains uncompressed RGB data;
/// dwRGBBitCount and the RGB masks (dwRBitMask, dwGBitMask, dwBBitMask) contain valid data.
#    define DDS_RGB 0x00000040

/// DDPF_RGB | DDPF_ALPHAPIXELS - Texture contains uncompressed RGBA data;
/// dwRGBBitCount and the RGB masks (dwRBitMask, dwGBitMask, dwBBitMask, dwABitMask) contain valid data.
#    define DDS_RGBA 0x00000041

/// DDPF_LUMINANCE - Used in some older DDS files for single channel color uncompressed data
/// (dwRGBBitCount contains the luminance channel bit count; dwRBitMask contains the channel mask).
/// Can be combined with DDPF_ALPHAPIXELS for a two channel DDS file.
#    define DDS_LUMINANCE 0x00020000

/// DDPF_ALPHA - Used in some older DDS files for alpha channel only uncompressed data
/// (dwRGBBitCount contains the alpha channel bitcount; dwABitMask contains valid data)
#    define DDS_ALPHA 0x00000002

const DDS_PIXELFORMAT DDSPF_DXT1 = { sizeof( DDS_PIXELFORMAT ), DDS_FOURCC, MAKEFOURCC( 'D', 'X', 'T', '1' ), 0, 0, 0, 0, 0 }; ///< DXT1 Pixel format

const DDS_PIXELFORMAT DDSPF_DXT2 = { sizeof( DDS_PIXELFORMAT ), DDS_FOURCC, MAKEFOURCC( 'D', 'X', 'T', '2' ), 0, 0, 0, 0, 0 }; ///< DXT2 Pixel format

const DDS_PIXELFORMAT DDSPF_DXT3 = { sizeof( DDS_PIXELFORMAT ), DDS_FOURCC, MAKEFOURCC( 'D', 'X', 'T', '3' ), 0, 0, 0, 0, 0 }; ///< DXT3 Pixel format

const DDS_PIXELFORMAT DDSPF_DXT4 = { sizeof( DDS_PIXELFORMAT ), DDS_FOURCC, MAKEFOURCC( 'D', 'X', 'T', '4' ), 0, 0, 0, 0, 0 }; ///< DXT4 Pixel format

const DDS_PIXELFORMAT DDSPF_DXT5 = { sizeof( DDS_PIXELFORMAT ), DDS_FOURCC, MAKEFOURCC( 'D', 'X', 'T', '5' ), 0, 0, 0, 0, 0 }; ///< DXT5 Pixel format

const DDS_PIXELFORMAT DDSPF_A8R8G8B8 = { sizeof( DDS_PIXELFORMAT ), DDS_RGBA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 }; ///< A8R8G8B8 Pixel format

const DDS_PIXELFORMAT DDSPF_A1R5G5B5 = { sizeof( DDS_PIXELFORMAT ), DDS_RGBA, 0, 16, 0x00007c00, 0x000003e0, 0x0000001f, 0x00008000 }; ///< A1R5G5B5 Pixel format

const DDS_PIXELFORMAT DDSPF_A4R4G4B4 = { sizeof( DDS_PIXELFORMAT ), DDS_RGBA, 0, 16, 0x00000f00, 0x000000f0, 0x0000000f, 0x0000f000 }; ///< A4R4G4B4 Pixel format

const DDS_PIXELFORMAT DDSPF_R8G8B8 = { sizeof( DDS_PIXELFORMAT ), DDS_RGB, 0, 24, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000 }; ///< R8G8B8 Pixel format

const DDS_PIXELFORMAT DDSPF_R5G6B5 = { sizeof( DDS_PIXELFORMAT ), DDS_RGB, 0, 16, 0x0000f800, 0x000007e0, 0x0000001f, 0x00000000 }; ///< R5G6B5 Pixel format

// This indicates the DDS_HEADER_DXT10 extension is present (the format is in dxgiFormat)
const DDS_PIXELFORMAT DDSPF_DX10 = { sizeof( DDS_PIXELFORMAT ), DDS_FOURCC, MAKEFOURCC( 'D', 'X', '1', '0' ), 0, 0, 0, 0, 0 }; ///< DX10 Pixel format

#    define DDS_HEADER_FLAGS_TEXTURE 0x00001007    ///< DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT
#    define DDS_HEADER_FLAGS_MIPMAP 0x00020000     ///< DDSD_MIPMAPCOUNT
#    define DDS_HEADER_FLAGS_VOLUME 0x00800000     ///< DDSD_DEPTH
#    define DDS_HEADER_FLAGS_PITCH 0x00000008      ///< DDSD_PITCH
#    define DDS_HEADER_FLAGS_LINEARSIZE 0x00080000 ///< DDSD_LINEARSIZE

#    define DDS_SURFACE_FLAGS_TEXTURE 0x00001000 ///< DDSCAPS_TEXTURE
#    define DDS_SURFACE_FLAGS_MIPMAP 0x00400008  ///< DDSCAPS_COMPLEX | DDSCAPS_MIPMAP
#    define DDS_SURFACE_FLAGS_CUBEMAP 0x00000008 ///< DDSCAPS_COMPLEX

#    define DDSCAPS2_CUBEMAP 0x00000200
#    define DDS_CUBEMAP_POSITIVEX 0x00000600 ///< DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEX
#    define DDS_CUBEMAP_NEGATIVEX 0x00000a00 ///< DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEX
#    define DDS_CUBEMAP_POSITIVEY 0x00001200 ///< DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEY
#    define DDS_CUBEMAP_NEGATIVEY 0x00002200 ///< DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEY
#    define DDS_CUBEMAP_POSITIVEZ 0x00004200 ///< DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEZ
#    define DDS_CUBEMAP_NEGATIVEZ 0x00008200 ///< DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEZ

/** DDS structure contains all faces
  */
#    define DDS_CUBEMAP_ALLFACES ( DDS_CUBEMAP_POSITIVEX | DDS_CUBEMAP_NEGATIVEX | DDS_CUBEMAP_POSITIVEY | DDS_CUBEMAP_NEGATIVEY | DDS_CUBEMAP_POSITIVEZ | DDS_CUBEMAP_NEGATIVEZ )

#    define DDS_FLAGS_VOLUME 0x00200000 ///< DDSCAPS2_VOLUME

/** Describes a DDS file header.  See http://msdn.microsoft.com/en-us/library/bb943982.aspx
  */
typedef struct
{
    DWORD           dwSize;              ///< Size of structure. This member must be set to 124.
    DWORD           dwHeaderFlags;       ///< Flags to indicate which members contain valid data.
    DWORD           dwHeight;            ///< Surface height (in pixels).
    DWORD           dwWidth;             ///< Surface width (in pixels).
    DWORD           dwPitchOrLinearSize; ///< The pitch or number of bytes per scan line in an uncompressed texture;
    DWORD           dwDepth;             ///< Depth of a volume texture (in pixels), only if DDS_HEADER_FLAGS_VOLUME is set in dwHeaderFlags
    DWORD           dwMipMapCount;       ///< Number of mipmap levels, otherwise unused.
    DWORD           dwReserved1[ 11 ];   ///< Unused.
    DDS_PIXELFORMAT ddspf;               ///< The pixel format
    DWORD           dwSurfaceFlags;      ///< Specifies the complexity of the surfaces stored.
    DWORD           dwCubemapFlags;      ///< Additional detail about the surfaces stored.
    DWORD           dwReserved2[ 3 ];    ///< Unused.
} DDS_HEADER;

/** DDS header extension to handle resource arrays.  See http://msdn.microsoft.com/en-us/library/bb943983.aspx
  */
typedef struct
{
    DXGI_FORMAT              dxgiFormat;        ///< The surface pixel format
    D3D10_RESOURCE_DIMENSION resourceDimension; ///< Identifies the type of resource.
    UINT                     miscFlag;          ///< Identifies other, less common options for resources.
    UINT                     arraySize;         ///< The number of elements in the array.
    UINT                     reserved;          ///< Reserved for future use.
} DDS_HEADER_DXT10;

// THE BELOW FORMATS ARE USED IN LUMEN UNIT TEST AND WERE NOT PART OF THE ORIGINAL MICROSOFT DDS.H FILE

#    define DDS_LUMINANCEA 0x00020001 // DDPF_LUMINANCE | DDPF_ALPHAPIXELS

const DDS_PIXELFORMAT DDSPF_A8 = { sizeof( DDS_PIXELFORMAT ), DDS_ALPHA, 0, 8, 0x00, 0x00, 0x00, 0xff };

const DDS_PIXELFORMAT DDSPF_A8L8 = { sizeof( DDS_PIXELFORMAT ), DDS_LUMINANCEA, 0, 16, 0x00ff, 0x0000, 0x0000, 0xff00 };

#    pragma pack( pop )

#endif // _DDS_H_

#endif // INCLUDED_DDS_H