//////////////////////////////////////////////////////////////////////////////
//
//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
//
//  File:       d3dx11tex.h
//  Content:    D3DX11 texturing APIs
//
//////////////////////////////////////////////////////////////////////////////

#include "d3dx11.h"

#ifndef __D3DX11TEX_H__
#define __D3DX11TEX_H__

//----------------------------------------------------------------------------
// D3DX11_FILTER flags:
// ------------------
//
// A valid filter must contain one of these values:
//
//  D3DX11_FILTER_NONE
//      No scaling or filtering will take place.  Pixels outside the bounds
//      of the source image are assumed to be transparent black.
//  D3DX11_FILTER_POINT
//      Each destination pixel is computed by sampling the nearest pixel
//      from the source image.
//  D3DX11_FILTER_LINEAR
//      Each destination pixel is computed by linearly interpolating between
//      the nearest pixels in the source image.  This filter works best
//      when the scale on each axis is less than 2.
//  D3DX11_FILTER_TRIANGLE
//      Every pixel in the source image contributes equally to the
//      destination image.  This is the slowest of all the filters.
//  D3DX11_FILTER_BOX
//      Each pixel is computed by averaging a 2x2(x2) box pixels from
//      the source image. Only works when the dimensions of the
//      destination are half those of the source. (as with mip maps)
//
// And can be OR'd with any of these optional flags:
//
//  D3DX11_FILTER_MIRROR_U
//      Indicates that pixels off the edge of the texture on the U-axis
//      should be mirrored, not wraped.
//  D3DX11_FILTER_MIRROR_V
//      Indicates that pixels off the edge of the texture on the V-axis
//      should be mirrored, not wraped.
//  D3DX11_FILTER_MIRROR_W
//      Indicates that pixels off the edge of the texture on the W-axis
//      should be mirrored, not wraped.
//  D3DX11_FILTER_MIRROR
//      Same as specifying D3DX11_FILTER_MIRROR_U | D3DX11_FILTER_MIRROR_V |
//      D3DX11_FILTER_MIRROR_V
//  D3DX11_FILTER_DITHER
//      Dithers the resulting image using a 4x4 order dither pattern.
//  D3DX11_FILTER_SRGB_IN
//      Denotes that the input data is in sRGB (gamma 2.2) colorspace.
//  D3DX11_FILTER_SRGB_OUT
//      Denotes that the output data is in sRGB (gamma 2.2) colorspace.
//  D3DX11_FILTER_SRGB
//      Same as specifying D3DX11_FILTER_SRGB_IN | D3DX11_FILTER_SRGB_OUT
//
//----------------------------------------------------------------------------

typedef enum D3DX11_FILTER_FLAG
{
    D3DX11_FILTER_NONE = (1 << 0),
    D3DX11_FILTER_POINT = (2 << 0),
    D3DX11_FILTER_LINEAR = (3 << 0),
    D3DX11_FILTER_TRIANGLE = (4 << 0),
    D3DX11_FILTER_BOX = (5 << 0),

    D3DX11_FILTER_MIRROR_U = (1 << 16),
    D3DX11_FILTER_MIRROR_V = (2 << 16),
    D3DX11_FILTER_MIRROR_W = (4 << 16),
    D3DX11_FILTER_MIRROR = (7 << 16),

    D3DX11_FILTER_DITHER = (1 << 19),
    D3DX11_FILTER_DITHER_DIFFUSION = (2 << 19),

    D3DX11_FILTER_SRGB_IN = (1 << 21),
    D3DX11_FILTER_SRGB_OUT = (2 << 21),
    D3DX11_FILTER_SRGB = (3 << 21),
} D3DX11_FILTER_FLAG;

//----------------------------------------------------------------------------
// D3DX11_NORMALMAP flags:
// ---------------------
// These flags are used to control how D3DX11ComputeNormalMap generates normal
// maps.  Any number of these flags may be OR'd together in any combination.
//
//  D3DX11_NORMALMAP_MIRROR_U
//      Indicates that pixels off the edge of the texture on the U-axis
//      should be mirrored, not wraped.
//  D3DX11_NORMALMAP_MIRROR_V
//      Indicates that pixels off the edge of the texture on the V-axis
//      should be mirrored, not wraped.
//  D3DX11_NORMALMAP_MIRROR
//      Same as specifying D3DX11_NORMALMAP_MIRROR_U | D3DX11_NORMALMAP_MIRROR_V
//  D3DX11_NORMALMAP_INVERTSIGN
//      Inverts the direction of each normal
//  D3DX11_NORMALMAP_COMPUTE_OCCLUSION
//      Compute the per pixel Occlusion term and encodes it into the alpha.
//      An Alpha of 1 means that the pixel is not obscured in anyway, and
//      an alpha of 0 would mean that the pixel is completly obscured.
//
//----------------------------------------------------------------------------

typedef enum D3DX11_NORMALMAP_FLAG
{
    D3DX11_NORMALMAP_MIRROR_U = (1 << 16),
    D3DX11_NORMALMAP_MIRROR_V = (2 << 16),
    D3DX11_NORMALMAP_MIRROR = (3 << 16),
    D3DX11_NORMALMAP_INVERTSIGN = (8 << 16),
    D3DX11_NORMALMAP_COMPUTE_OCCLUSION = (16 << 16),
} D3DX11_NORMALMAP_FLAG;

//----------------------------------------------------------------------------
// D3DX11_CHANNEL flags:
// -------------------
// These flags are used by functions which operate on or more channels
// in a texture.
//
// D3DX11_CHANNEL_RED
//     Indicates the red channel should be used
// D3DX11_CHANNEL_BLUE
//     Indicates the blue channel should be used
// D3DX11_CHANNEL_GREEN
//     Indicates the green channel should be used
// D3DX11_CHANNEL_ALPHA
//     Indicates the alpha channel should be used
// D3DX11_CHANNEL_LUMINANCE
//     Indicates the luminaces of the red green and blue channels should be
//     used.
//
//----------------------------------------------------------------------------

typedef enum D3DX11_CHANNEL_FLAG
{
    D3DX11_CHANNEL_RED = (1 << 0),
    D3DX11_CHANNEL_BLUE = (1 << 1),
    D3DX11_CHANNEL_GREEN = (1 << 2),
    D3DX11_CHANNEL_ALPHA = (1 << 3),
    D3DX11_CHANNEL_LUMINANCE = (1 << 4),
} D3DX11_CHANNEL_FLAG;

//----------------------------------------------------------------------------
// D3DX11_IMAGE_FILE_FORMAT:
// ---------------------
// This enum is used to describe supported image file formats.
//
//----------------------------------------------------------------------------

typedef enum D3DX11_IMAGE_FILE_FORMAT
{
    D3DX11_IFF_BMP = 0,
    D3DX11_IFF_JPG = 1,
    D3DX11_IFF_PNG = 3,
    D3DX11_IFF_DDS = 4,
    D3DX11_IFF_TIFF = 10,
    D3DX11_IFF_GIF = 11,
    D3DX11_IFF_WMP = 12,
    D3DX11_IFF_FORCE_DWORD = 0x7fffffff

} D3DX11_IMAGE_FILE_FORMAT;

//----------------------------------------------------------------------------
// D3DX11_SAVE_TEXTURE_FLAG:
// ---------------------
// This enum is used to support texture saving options.
//
//----------------------------------------------------------------------------

typedef enum D3DX11_SAVE_TEXTURE_FLAG
{
    D3DX11_STF_USEINPUTBLOB = 0x0001,
} D3DX11_SAVE_TEXTURE_FLAG;

//----------------------------------------------------------------------------
// D3DX11_IMAGE_INFO:
// ---------------
// This structure is used to return a rough description of what the
// the original contents of an image file looked like.
//
//  Width
//      Width of original image in pixels
//  Height
//      Height of original image in pixels
//  Depth
//      Depth of original image in pixels
//  ArraySize
//      Array size in textures
//  MipLevels
//      Number of mip levels in original image
//  MiscFlags
//      Miscellaneous flags
//  Format
//      D3D format which most closely describes the data in original image
//  ResourceDimension
//      D3D11_RESOURCE_DIMENSION representing the dimension of texture stored in the file.
//      D3D11_RESOURCE_DIMENSION_TEXTURE1D, 2D, 3D
//  ImageFileFormat
//      D3DX11_IMAGE_FILE_FORMAT representing the format of the image file.
//----------------------------------------------------------------------------

typedef struct D3DX11_IMAGE_INFO
{
    UINT Width;
    UINT Height;
    UINT Depth;
    UINT ArraySize;
    UINT MipLevels;
    UINT MiscFlags;
    DXGI_FORMAT Format;
    D3D11_RESOURCE_DIMENSION ResourceDimension;
    D3DX11_IMAGE_FILE_FORMAT ImageFileFormat;
} D3DX11_IMAGE_INFO;

#ifdef __cplusplus
extern "C"
{
#endif //__cplusplus

    //////////////////////////////////////////////////////////////////////////////
    // Image File APIs ///////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////

    //----------------------------------------------------------------------------
    // D3DX11_IMAGE_LOAD_INFO:
    // ---------------
    // This structure can be optionally passed in to texture loader APIs to
    // control how textures get loaded. Pass in D3DX11_DEFAULT for any of these
    // to have D3DX automatically pick defaults based on the source file.
    //
    //  Width
    //      Rescale texture to Width texels wide
    //  Height
    //      Rescale texture to Height texels high
    //  Depth
    //      Rescale texture to Depth texels deep
    //  FirstMipLevel
    //      First mip level to load
    //  MipLevels
    //      Number of mip levels to load after the first level
    //  Usage
    //      D3D11_USAGE flag for the new texture
    //  BindFlags
    //      D3D11 Bind flags for the new texture
    //  CpuAccessFlags
    //      D3D11 CPU Access flags for the new texture
    //  MiscFlags
    //      Reserved. Must be 0
    //  Format
    //      Resample texture to the specified format
    //  Filter
    //      Filter the texture using the specified filter (only when resampling)
    //  MipFilter
    //      Filter the texture mip levels using the specified filter (only if
    //      generating mips)
    //  pSrcInfo
    //      (optional) pointer to a D3DX11_IMAGE_INFO structure that will get
    //      populated with source image information
    //----------------------------------------------------------------------------

    typedef struct D3DX11_IMAGE_LOAD_INFO
    {
        UINT Width;
        UINT Height;
        UINT Depth;
        UINT FirstMipLevel;
        UINT MipLevels;
        D3D11_USAGE Usage;
        UINT BindFlags;
        UINT CpuAccessFlags;
        UINT MiscFlags;
        DXGI_FORMAT Format;
        UINT Filter;
        UINT MipFilter;
        D3DX11_IMAGE_INFO* pSrcInfo;

#ifdef __cplusplus
        D3DX11_IMAGE_LOAD_INFO()
        {
            Width = D3DX11_DEFAULT;
            Height = D3DX11_DEFAULT;
            Depth = D3DX11_DEFAULT;
            FirstMipLevel = D3DX11_DEFAULT;
            MipLevels = D3DX11_DEFAULT;
            Usage = (D3D11_USAGE) D3DX11_DEFAULT;
            BindFlags = D3DX11_DEFAULT;
            CpuAccessFlags = D3DX11_DEFAULT;
            MiscFlags = D3DX11_DEFAULT;
            Format = DXGI_FORMAT_FROM_FILE;
            Filter = D3DX11_DEFAULT;
            MipFilter = D3DX11_DEFAULT;
            pSrcInfo = NULL;
        }
#endif

    } D3DX11_IMAGE_LOAD_INFO;

    //-------------------------------------------------------------------------------
    // GetImageInfoFromFile/Resource/Memory:
    // ------------------------------
    // Fills in a D3DX11_IMAGE_INFO struct with information about an image file.
    //
    // Parameters:
    //  pSrcFile
    //      File name of the source image.
    //  pSrcModule
    //      Module where resource is located, or NULL for module associated
    //      with image the os used to create the current process.
    //  pSrcResource
    //      Resource name.
    //  pSrcData
    //      Pointer to file in memory.
    //  SrcDataSize
    //      Size in bytes of file in memory.
    //  pPump
    //      Optional pointer to a thread pump object to use.
    //  pSrcInfo
    //      Pointer to a D3DX11_IMAGE_INFO structure to be filled in with the
    //      description of the data in the source image file.
    //  pHResult
    //      Pointer to a memory location to receive the return value upon completion.
    //      Maybe NULL if not needed.
    //      If pPump != NULL, pHResult must be a valid memory location until the
    //      the asynchronous execution completes.
    //-------------------------------------------------------------------------------

    HRESULT WINAPI D3DX11GetImageInfoFromFileA(LPCSTR pSrcFile, ID3DX11ThreadPump* pPump, D3DX11_IMAGE_INFO* pSrcInfo,
                                               HRESULT* pHResult);

    HRESULT WINAPI D3DX11GetImageInfoFromFileW(LPCWSTR pSrcFile, ID3DX11ThreadPump* pPump, D3DX11_IMAGE_INFO* pSrcInfo,
                                               HRESULT* pHResult);

#ifdef UNICODE
#define D3DX11GetImageInfoFromFile D3DX11GetImageInfoFromFileW
#else
#define D3DX11GetImageInfoFromFile D3DX11GetImageInfoFromFileA
#endif

    HRESULT WINAPI D3DX11GetImageInfoFromResourceA(HMODULE hSrcModule, LPCSTR pSrcResource, ID3DX11ThreadPump* pPump,
                                                   D3DX11_IMAGE_INFO* pSrcInfo, HRESULT* pHResult);

    HRESULT WINAPI D3DX11GetImageInfoFromResourceW(HMODULE hSrcModule, LPCWSTR pSrcResource, ID3DX11ThreadPump* pPump,
                                                   D3DX11_IMAGE_INFO* pSrcInfo, HRESULT* pHResult);

#ifdef UNICODE
#define D3DX11GetImageInfoFromResource D3DX11GetImageInfoFromResourceW
#else
#define D3DX11GetImageInfoFromResource D3DX11GetImageInfoFromResourceA
#endif

    HRESULT WINAPI D3DX11GetImageInfoFromMemory(LPCVOID pSrcData, SIZE_T SrcDataSize, ID3DX11ThreadPump* pPump,
                                                D3DX11_IMAGE_INFO* pSrcInfo, HRESULT* pHResult);

    //////////////////////////////////////////////////////////////////////////////
    // Create/Save Texture APIs //////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////

    //----------------------------------------------------------------------------
    // D3DX11CreateTextureFromFile/Resource/Memory:
    // D3DX11CreateShaderResourceViewFromFile/Resource/Memory:
    // -----------------------------------
    // Create a texture object from a file or resource.
    //
    // Parameters:
    //
    //  pDevice
    //      The D3D device with which the texture is going to be used.
    //  pSrcFile
    //      File name.
    //  hSrcModule
    //      Module handle. if NULL, current module will be used.
    //  pSrcResource
    //      Resource name in module
    //  pvSrcData
    //      Pointer to file in memory.
    //  SrcDataSize
    //      Size in bytes of file in memory.
    //  pLoadInfo
    //      Optional pointer to a D3DX11_IMAGE_LOAD_INFO structure that
    //      contains additional loader parameters.
    //  pPump
    //      Optional pointer to a thread pump object to use.
    //  ppTexture
    //      [out] Created texture object.
    //  ppShaderResourceView
    //      [out] Shader resource view object created.
    //  pHResult
    //      Pointer to a memory location to receive the return value upon completion.
    //      Maybe NULL if not needed.
    //      If pPump != NULL, pHResult must be a valid memory location until the
    //      the asynchronous execution completes.
    //
    //----------------------------------------------------------------------------

    // FromFile

    HRESULT WINAPI D3DX11CreateShaderResourceViewFromFileA(ID3D11Device* pDevice, LPCSTR pSrcFile,
                                                           D3DX11_IMAGE_LOAD_INFO* pLoadInfo, ID3DX11ThreadPump* pPump,
                                                           ID3D11ShaderResourceView** ppShaderResourceView,
                                                           HRESULT* pHResult);

    HRESULT WINAPI D3DX11CreateShaderResourceViewFromFileW(ID3D11Device* pDevice, LPCWSTR pSrcFile,
                                                           D3DX11_IMAGE_LOAD_INFO* pLoadInfo, ID3DX11ThreadPump* pPump,
                                                           ID3D11ShaderResourceView** ppShaderResourceView,
                                                           HRESULT* pHResult);

#ifdef UNICODE
#define D3DX11CreateShaderResourceViewFromFile D3DX11CreateShaderResourceViewFromFileW
#else
#define D3DX11CreateShaderResourceViewFromFile D3DX11CreateShaderResourceViewFromFileA
#endif

    HRESULT WINAPI D3DX11CreateTextureFromFileA(ID3D11Device* pDevice, LPCSTR pSrcFile,
                                                D3DX11_IMAGE_LOAD_INFO* pLoadInfo, ID3DX11ThreadPump* pPump,
                                                ID3D11Resource** ppTexture, HRESULT* pHResult);

    HRESULT WINAPI D3DX11CreateTextureFromFileW(ID3D11Device* pDevice, LPCWSTR pSrcFile,
                                                D3DX11_IMAGE_LOAD_INFO* pLoadInfo, ID3DX11ThreadPump* pPump,
                                                ID3D11Resource** ppTexture, HRESULT* pHResult);

#ifdef UNICODE
#define D3DX11CreateTextureFromFile D3DX11CreateTextureFromFileW
#else
#define D3DX11CreateTextureFromFile D3DX11CreateTextureFromFileA
#endif

    // FromResource (resources in dll/exes)

    HRESULT WINAPI D3DX11CreateShaderResourceViewFromResourceA(ID3D11Device* pDevice, HMODULE hSrcModule,
                                                               LPCSTR pSrcResource, D3DX11_IMAGE_LOAD_INFO* pLoadInfo,
                                                               ID3DX11ThreadPump* pPump,
                                                               ID3D11ShaderResourceView** ppShaderResourceView,
                                                               HRESULT* pHResult);

    HRESULT WINAPI D3DX11CreateShaderResourceViewFromResourceW(ID3D11Device* pDevice, HMODULE hSrcModule,
                                                               LPCWSTR pSrcResource, D3DX11_IMAGE_LOAD_INFO* pLoadInfo,
                                                               ID3DX11ThreadPump* pPump,
                                                               ID3D11ShaderResourceView** ppShaderResourceView,
                                                               HRESULT* pHResult);

#ifdef UNICODE
#define D3DX11CreateShaderResourceViewFromResource D3DX11CreateShaderResourceViewFromResourceW
#else
#define D3DX11CreateShaderResourceViewFromResource D3DX11CreateShaderResourceViewFromResourceA
#endif

    HRESULT WINAPI D3DX11CreateTextureFromResourceA(ID3D11Device* pDevice, HMODULE hSrcModule, LPCSTR pSrcResource,
                                                    D3DX11_IMAGE_LOAD_INFO* pLoadInfo, ID3DX11ThreadPump* pPump,
                                                    ID3D11Resource** ppTexture, HRESULT* pHResult);

    HRESULT WINAPI D3DX11CreateTextureFromResourceW(ID3D11Device* pDevice, HMODULE hSrcModule, LPCWSTR pSrcResource,
                                                    D3DX11_IMAGE_LOAD_INFO* pLoadInfo, ID3DX11ThreadPump* pPump,
                                                    ID3D11Resource** ppTexture, HRESULT* pHResult);

#ifdef UNICODE
#define D3DX11CreateTextureFromResource D3DX11CreateTextureFromResourceW
#else
#define D3DX11CreateTextureFromResource D3DX11CreateTextureFromResourceA
#endif

    // FromFileInMemory

    HRESULT WINAPI D3DX11CreateShaderResourceViewFromMemory(ID3D11Device* pDevice, LPCVOID pSrcData, SIZE_T SrcDataSize,
                                                            D3DX11_IMAGE_LOAD_INFO* pLoadInfo, ID3DX11ThreadPump* pPump,
                                                            ID3D11ShaderResourceView** ppShaderResourceView,
                                                            HRESULT* pHResult);

    HRESULT WINAPI D3DX11CreateTextureFromMemory(ID3D11Device* pDevice, LPCVOID pSrcData, SIZE_T SrcDataSize,
                                                 D3DX11_IMAGE_LOAD_INFO* pLoadInfo, ID3DX11ThreadPump* pPump,
                                                 ID3D11Resource** ppTexture, HRESULT* pHResult);

    //////////////////////////////////////////////////////////////////////////////
    // Misc Texture APIs /////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////

    //----------------------------------------------------------------------------
    // D3DX11_TEXTURE_LOAD_INFO:
    // ------------------------
    //
    //----------------------------------------------------------------------------

    typedef struct _D3DX11_TEXTURE_LOAD_INFO
    {
        D3D11_BOX* pSrcBox;
        D3D11_BOX* pDstBox;
        UINT SrcFirstMip;
        UINT DstFirstMip;
        UINT NumMips;
        UINT SrcFirstElement;
        UINT DstFirstElement;
        UINT NumElements;
        UINT Filter;
        UINT MipFilter;

#ifdef __cplusplus
        _D3DX11_TEXTURE_LOAD_INFO()
        {
            pSrcBox = NULL;
            pDstBox = NULL;
            SrcFirstMip = 0;
            DstFirstMip = 0;
            NumMips = D3DX11_DEFAULT;
            SrcFirstElement = 0;
            DstFirstElement = 0;
            NumElements = D3DX11_DEFAULT;
            Filter = D3DX11_DEFAULT;
            MipFilter = D3DX11_DEFAULT;
        }
#endif

    } D3DX11_TEXTURE_LOAD_INFO;

    //----------------------------------------------------------------------------
    // D3DX11LoadTextureFromTexture:
    // ----------------------------
    // Load a texture from a texture.
    //
    // Parameters:
    //
    //----------------------------------------------------------------------------

    HRESULT WINAPI D3DX11LoadTextureFromTexture(ID3D11DeviceContext* pContext, ID3D11Resource* pSrcTexture,
                                                D3DX11_TEXTURE_LOAD_INFO* pLoadInfo, ID3D11Resource* pDstTexture);

    //----------------------------------------------------------------------------
    // D3DX11FilterTexture:
    // ------------------
    // Filters mipmaps levels of a texture.
    //
    // Parameters:
    //  pBaseTexture
    //      The texture object to be filtered
    //  SrcLevel
    //      The level whose image is used to generate the subsequent levels.
    //  MipFilter
    //      D3DX11_FILTER flags controlling how each miplevel is filtered.
    //      Or D3DX11_DEFAULT for D3DX11_FILTER_BOX,
    //
    //----------------------------------------------------------------------------

    HRESULT WINAPI D3DX11FilterTexture(ID3D11DeviceContext* pContext, ID3D11Resource* pTexture, UINT SrcLevel,
                                       UINT MipFilter);

    //----------------------------------------------------------------------------
    // D3DX11SaveTextureToFile:
    // ----------------------
    // Save a texture to a file.
    //
    // Parameters:
    //  pDestFile
    //      File name of the destination file
    //  DestFormat
    //      D3DX11_IMAGE_FILE_FORMAT specifying file format to use when saving.
    //  pSrcTexture
    //      Source texture, containing the image to be saved
    //
    //----------------------------------------------------------------------------

    HRESULT WINAPI D3DX11SaveTextureToFileA(ID3D11DeviceContext* pContext, ID3D11Resource* pSrcTexture,
                                            D3DX11_IMAGE_FILE_FORMAT DestFormat, LPCSTR pDestFile);

    HRESULT WINAPI D3DX11SaveTextureToFileW(ID3D11DeviceContext* pContext, ID3D11Resource* pSrcTexture,
                                            D3DX11_IMAGE_FILE_FORMAT DestFormat, LPCWSTR pDestFile);

#ifdef UNICODE
#define D3DX11SaveTextureToFile D3DX11SaveTextureToFileW
#else
#define D3DX11SaveTextureToFile D3DX11SaveTextureToFileA
#endif

    //----------------------------------------------------------------------------
    // D3DX11SaveTextureToMemory:
    // ----------------------
    // Save a texture to a blob.
    //
    // Parameters:
    //  pSrcTexture
    //      Source texture, containing the image to be saved
    //  DestFormat
    //      D3DX11_IMAGE_FILE_FORMAT specifying file format to use when saving.
    //  ppDestBuf
    //      address of a d3dxbuffer pointer to return the image data
    //  Flags
    //      optional flags
    //----------------------------------------------------------------------------

    HRESULT WINAPI D3DX11SaveTextureToMemory(ID3D11DeviceContext* pContext, ID3D11Resource* pSrcTexture,
                                             D3DX11_IMAGE_FILE_FORMAT DestFormat, ID3D10Blob** ppDestBuf, UINT Flags);

    //----------------------------------------------------------------------------
    // D3DX11ComputeNormalMap:
    // ---------------------
    // Converts a height map into a normal map.  The (x,y,z) components of each
    // normal are mapped to the (r,g,b) channels of the output texture.
    //
    // Parameters
    //  pSrcTexture
    //      Pointer to the source heightmap texture
    //  Flags
    //      D3DX11_NORMALMAP flags
    //  Channel
    //      D3DX11_CHANNEL specifying source of height information
    //  Amplitude
    //      The constant value which the height information is multiplied by.
    //  pDestTexture
    //      Pointer to the destination texture
    //---------------------------------------------------------------------------

    HRESULT WINAPI D3DX11ComputeNormalMap(ID3D11DeviceContext* pContext, ID3D11Texture2D* pSrcTexture, UINT Flags,
                                          UINT Channel, FLOAT Amplitude, ID3D11Texture2D* pDestTexture);

    //----------------------------------------------------------------------------
    // D3DX11SHProjectCubeMap:
    // ----------------------
    //  Projects a function represented in a cube map into spherical harmonics.
    //
    //  Parameters:
    //   Order
    //      Order of the SH evaluation, generates Order^2 coefs, degree is Order-1
    //   pCubeMap
    //      CubeMap that is going to be projected into spherical harmonics
    //   pROut
    //      Output SH vector for Red.
    //   pGOut
    //      Output SH vector for Green
    //   pBOut
    //      Output SH vector for Blue
    //
    //---------------------------------------------------------------------------

    HRESULT WINAPI D3DX11SHProjectCubeMap(ID3D11DeviceContext* pContext, __in_range(2, 6) UINT Order,
                                          ID3D11Texture2D* pCubeMap, __out_ecount(Order* Order) FLOAT* pROut,
                                          __out_ecount_opt(Order* Order) FLOAT* pGOut,
                                          __out_ecount_opt(Order* Order) FLOAT* pBOut);

#ifdef __cplusplus
}
#endif //__cplusplus

#endif //__D3DX11TEX_H__
