////////////////////////////////////////////////////////////////////////////// // // Copyright (C) Microsoft Corporation. All Rights Reserved. // // File: d3dx10tex.h // Content: D3DX10 texturing APIs // ////////////////////////////////////////////////////////////////////////////// #include "d3dx10.h" #ifndef __D3DX10TEX_H__ #define __D3DX10TEX_H__ //---------------------------------------------------------------------------- // D3DX10_FILTER flags: // ------------------ // // A valid filter must contain one of these values: // // D3DX10_FILTER_NONE // No scaling or filtering will take place. Pixels outside the bounds // of the source image are assumed to be transparent black. // D3DX10_FILTER_POINT // Each destination pixel is computed by sampling the nearest pixel // from the source image. // D3DX10_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. // D3DX10_FILTER_TRIANGLE // Every pixel in the source image contributes equally to the // destination image. This is the slowest of all the filters. // D3DX10_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: // // D3DX10_FILTER_MIRROR_U // Indicates that pixels off the edge of the texture on the U-axis // should be mirrored, not wraped. // D3DX10_FILTER_MIRROR_V // Indicates that pixels off the edge of the texture on the V-axis // should be mirrored, not wraped. // D3DX10_FILTER_MIRROR_W // Indicates that pixels off the edge of the texture on the W-axis // should be mirrored, not wraped. // D3DX10_FILTER_MIRROR // Same as specifying D3DX10_FILTER_MIRROR_U | D3DX10_FILTER_MIRROR_V | // D3DX10_FILTER_MIRROR_V // D3DX10_FILTER_DITHER // Dithers the resulting image using a 4x4 order dither pattern. // D3DX10_FILTER_SRGB_IN // Denotes that the input data is in sRGB (gamma 2.2) colorspace. // D3DX10_FILTER_SRGB_OUT // Denotes that the output data is in sRGB (gamma 2.2) colorspace. // D3DX10_FILTER_SRGB // Same as specifying D3DX10_FILTER_SRGB_IN | D3DX10_FILTER_SRGB_OUT // //---------------------------------------------------------------------------- typedef enum D3DX10_FILTER_FLAG { D3DX10_FILTER_NONE = (1 << 0), D3DX10_FILTER_POINT = (2 << 0), D3DX10_FILTER_LINEAR = (3 << 0), D3DX10_FILTER_TRIANGLE = (4 << 0), D3DX10_FILTER_BOX = (5 << 0), D3DX10_FILTER_MIRROR_U = (1 << 16), D3DX10_FILTER_MIRROR_V = (2 << 16), D3DX10_FILTER_MIRROR_W = (4 << 16), D3DX10_FILTER_MIRROR = (7 << 16), D3DX10_FILTER_DITHER = (1 << 19), D3DX10_FILTER_DITHER_DIFFUSION= (2 << 19), D3DX10_FILTER_SRGB_IN = (1 << 21), D3DX10_FILTER_SRGB_OUT = (2 << 21), D3DX10_FILTER_SRGB = (3 << 21), } D3DX10_FILTER_FLAG; //---------------------------------------------------------------------------- // D3DX10_NORMALMAP flags: // --------------------- // These flags are used to control how D3DX10ComputeNormalMap generates normal // maps. Any number of these flags may be OR'd together in any combination. // // D3DX10_NORMALMAP_MIRROR_U // Indicates that pixels off the edge of the texture on the U-axis // should be mirrored, not wraped. // D3DX10_NORMALMAP_MIRROR_V // Indicates that pixels off the edge of the texture on the V-axis // should be mirrored, not wraped. // D3DX10_NORMALMAP_MIRROR // Same as specifying D3DX10_NORMALMAP_MIRROR_U | D3DX10_NORMALMAP_MIRROR_V // D3DX10_NORMALMAP_INVERTSIGN // Inverts the direction of each normal // D3DX10_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 D3DX10_NORMALMAP_FLAG { D3DX10_NORMALMAP_MIRROR_U = (1 << 16), D3DX10_NORMALMAP_MIRROR_V = (2 << 16), D3DX10_NORMALMAP_MIRROR = (3 << 16), D3DX10_NORMALMAP_INVERTSIGN = (8 << 16), D3DX10_NORMALMAP_COMPUTE_OCCLUSION = (16 << 16), } D3DX10_NORMALMAP_FLAG; //---------------------------------------------------------------------------- // D3DX10_CHANNEL flags: // ------------------- // These flags are used by functions which operate on or more channels // in a texture. // // D3DX10_CHANNEL_RED // Indicates the red channel should be used // D3DX10_CHANNEL_BLUE // Indicates the blue channel should be used // D3DX10_CHANNEL_GREEN // Indicates the green channel should be used // D3DX10_CHANNEL_ALPHA // Indicates the alpha channel should be used // D3DX10_CHANNEL_LUMINANCE // Indicates the luminaces of the red green and blue channels should be // used. // //---------------------------------------------------------------------------- typedef enum D3DX10_CHANNEL_FLAG { D3DX10_CHANNEL_RED = (1 << 0), D3DX10_CHANNEL_BLUE = (1 << 1), D3DX10_CHANNEL_GREEN = (1 << 2), D3DX10_CHANNEL_ALPHA = (1 << 3), D3DX10_CHANNEL_LUMINANCE = (1 << 4), } D3DX10_CHANNEL_FLAG; //---------------------------------------------------------------------------- // D3DX10_IMAGE_FILE_FORMAT: // --------------------- // This enum is used to describe supported image file formats. // //---------------------------------------------------------------------------- typedef enum D3DX10_IMAGE_FILE_FORMAT { D3DX10_IFF_BMP = 0, D3DX10_IFF_JPG = 1, D3DX10_IFF_PNG = 3, D3DX10_IFF_DDS = 4, D3DX10_IFF_TIFF = 10, D3DX10_IFF_GIF = 11, D3DX10_IFF_WMP = 12, D3DX10_IFF_FORCE_DWORD = 0x7fffffff } D3DX10_IMAGE_FILE_FORMAT; //---------------------------------------------------------------------------- // D3DX10_SAVE_TEXTURE_FLAG: // --------------------- // This enum is used to support texture saving options. // //---------------------------------------------------------------------------- typedef enum D3DX10_SAVE_TEXTURE_FLAG { D3DX10_STF_USEINPUTBLOB = 0x0001, } D3DX10_SAVE_TEXTURE_FLAG; //---------------------------------------------------------------------------- // D3DX10_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 // D3D10_RESOURCE_DIMENSION representing the dimension of texture stored in the file. // D3D10_RESOURCE_DIMENSION_TEXTURE1D, 2D, 3D // ImageFileFormat // D3DX10_IMAGE_FILE_FORMAT representing the format of the image file. //---------------------------------------------------------------------------- typedef struct D3DX10_IMAGE_INFO { UINT Width; UINT Height; UINT Depth; UINT ArraySize; UINT MipLevels; UINT MiscFlags; DXGI_FORMAT Format; D3D10_RESOURCE_DIMENSION ResourceDimension; D3DX10_IMAGE_FILE_FORMAT ImageFileFormat; } D3DX10_IMAGE_INFO; #ifdef __cplusplus extern "C" { #endif //__cplusplus ////////////////////////////////////////////////////////////////////////////// // Image File APIs /////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// //---------------------------------------------------------------------------- // D3DX10_IMAGE_LOAD_INFO: // --------------- // This structure can be optionally passed in to texture loader APIs to // control how textures get loaded. Pass in D3DX10_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 // D3D10_USAGE flag for the new texture // BindFlags // D3D10 Bind flags for the new texture // CpuAccessFlags // D3D10 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 D3DX10_IMAGE_INFO structure that will get // populated with source image information //---------------------------------------------------------------------------- typedef struct D3DX10_IMAGE_LOAD_INFO { UINT Width; UINT Height; UINT Depth; UINT FirstMipLevel; UINT MipLevels; D3D10_USAGE Usage; UINT BindFlags; UINT CpuAccessFlags; UINT MiscFlags; DXGI_FORMAT Format; UINT Filter; UINT MipFilter; D3DX10_IMAGE_INFO* pSrcInfo; #ifdef __cplusplus D3DX10_IMAGE_LOAD_INFO() { Width = D3DX10_DEFAULT; Height = D3DX10_DEFAULT; Depth = D3DX10_DEFAULT; FirstMipLevel = D3DX10_DEFAULT; MipLevels = D3DX10_DEFAULT; Usage = (D3D10_USAGE) D3DX10_DEFAULT; BindFlags = D3DX10_DEFAULT; CpuAccessFlags = D3DX10_DEFAULT; MiscFlags = D3DX10_DEFAULT; Format = DXGI_FORMAT_FROM_FILE; Filter = D3DX10_DEFAULT; MipFilter = D3DX10_DEFAULT; pSrcInfo = NULL; } #endif } D3DX10_IMAGE_LOAD_INFO; //------------------------------------------------------------------------------- // GetImageInfoFromFile/Resource/Memory: // ------------------------------ // Fills in a D3DX10_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 D3DX10_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 D3DX10GetImageInfoFromFileA( LPCSTR pSrcFile, ID3DX10ThreadPump* pPump, D3DX10_IMAGE_INFO* pSrcInfo, HRESULT* pHResult); HRESULT WINAPI D3DX10GetImageInfoFromFileW( LPCWSTR pSrcFile, ID3DX10ThreadPump* pPump, D3DX10_IMAGE_INFO* pSrcInfo, HRESULT* pHResult); #ifdef UNICODE #define D3DX10GetImageInfoFromFile D3DX10GetImageInfoFromFileW #else #define D3DX10GetImageInfoFromFile D3DX10GetImageInfoFromFileA #endif HRESULT WINAPI D3DX10GetImageInfoFromResourceA( HMODULE hSrcModule, LPCSTR pSrcResource, ID3DX10ThreadPump* pPump, D3DX10_IMAGE_INFO* pSrcInfo, HRESULT* pHResult); HRESULT WINAPI D3DX10GetImageInfoFromResourceW( HMODULE hSrcModule, LPCWSTR pSrcResource, ID3DX10ThreadPump* pPump, D3DX10_IMAGE_INFO* pSrcInfo, HRESULT* pHResult); #ifdef UNICODE #define D3DX10GetImageInfoFromResource D3DX10GetImageInfoFromResourceW #else #define D3DX10GetImageInfoFromResource D3DX10GetImageInfoFromResourceA #endif HRESULT WINAPI D3DX10GetImageInfoFromMemory( LPCVOID pSrcData, SIZE_T SrcDataSize, ID3DX10ThreadPump* pPump, D3DX10_IMAGE_INFO* pSrcInfo, HRESULT* pHResult); ////////////////////////////////////////////////////////////////////////////// // Create/Save Texture APIs ////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// //---------------------------------------------------------------------------- // D3DX10CreateTextureFromFile/Resource/Memory: // D3DX10CreateShaderResourceViewFromFile/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 D3DX10_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 D3DX10CreateShaderResourceViewFromFileA( ID3D10Device* pDevice, LPCSTR pSrcFile, D3DX10_IMAGE_LOAD_INFO *pLoadInfo, ID3DX10ThreadPump* pPump, ID3D10ShaderResourceView** ppShaderResourceView, HRESULT* pHResult); HRESULT WINAPI D3DX10CreateShaderResourceViewFromFileW( ID3D10Device* pDevice, LPCWSTR pSrcFile, D3DX10_IMAGE_LOAD_INFO *pLoadInfo, ID3DX10ThreadPump* pPump, ID3D10ShaderResourceView** ppShaderResourceView, HRESULT* pHResult); #ifdef UNICODE #define D3DX10CreateShaderResourceViewFromFile D3DX10CreateShaderResourceViewFromFileW #else #define D3DX10CreateShaderResourceViewFromFile D3DX10CreateShaderResourceViewFromFileA #endif HRESULT WINAPI D3DX10CreateTextureFromFileA( ID3D10Device* pDevice, LPCSTR pSrcFile, D3DX10_IMAGE_LOAD_INFO *pLoadInfo, ID3DX10ThreadPump* pPump, ID3D10Resource** ppTexture, HRESULT* pHResult); HRESULT WINAPI D3DX10CreateTextureFromFileW( ID3D10Device* pDevice, LPCWSTR pSrcFile, D3DX10_IMAGE_LOAD_INFO *pLoadInfo, ID3DX10ThreadPump* pPump, ID3D10Resource** ppTexture, HRESULT* pHResult); #ifdef UNICODE #define D3DX10CreateTextureFromFile D3DX10CreateTextureFromFileW #else #define D3DX10CreateTextureFromFile D3DX10CreateTextureFromFileA #endif // FromResource (resources in dll/exes) HRESULT WINAPI D3DX10CreateShaderResourceViewFromResourceA( ID3D10Device* pDevice, HMODULE hSrcModule, LPCSTR pSrcResource, D3DX10_IMAGE_LOAD_INFO* pLoadInfo, ID3DX10ThreadPump* pPump, ID3D10ShaderResourceView** ppShaderResourceView, HRESULT* pHResult); HRESULT WINAPI D3DX10CreateShaderResourceViewFromResourceW( ID3D10Device* pDevice, HMODULE hSrcModule, LPCWSTR pSrcResource, D3DX10_IMAGE_LOAD_INFO* pLoadInfo, ID3DX10ThreadPump* pPump, ID3D10ShaderResourceView** ppShaderResourceView, HRESULT* pHResult); #ifdef UNICODE #define D3DX10CreateShaderResourceViewFromResource D3DX10CreateShaderResourceViewFromResourceW #else #define D3DX10CreateShaderResourceViewFromResource D3DX10CreateShaderResourceViewFromResourceA #endif HRESULT WINAPI D3DX10CreateTextureFromResourceA( ID3D10Device* pDevice, HMODULE hSrcModule, LPCSTR pSrcResource, D3DX10_IMAGE_LOAD_INFO *pLoadInfo, ID3DX10ThreadPump* pPump, ID3D10Resource** ppTexture, HRESULT* pHResult); HRESULT WINAPI D3DX10CreateTextureFromResourceW( ID3D10Device* pDevice, HMODULE hSrcModule, LPCWSTR pSrcResource, D3DX10_IMAGE_LOAD_INFO* pLoadInfo, ID3DX10ThreadPump* pPump, ID3D10Resource** ppTexture, HRESULT* pHResult); #ifdef UNICODE #define D3DX10CreateTextureFromResource D3DX10CreateTextureFromResourceW #else #define D3DX10CreateTextureFromResource D3DX10CreateTextureFromResourceA #endif // FromFileInMemory HRESULT WINAPI D3DX10CreateShaderResourceViewFromMemory( ID3D10Device* pDevice, LPCVOID pSrcData, SIZE_T SrcDataSize, D3DX10_IMAGE_LOAD_INFO* pLoadInfo, ID3DX10ThreadPump* pPump, ID3D10ShaderResourceView** ppShaderResourceView, HRESULT* pHResult); HRESULT WINAPI D3DX10CreateTextureFromMemory( ID3D10Device* pDevice, LPCVOID pSrcData, SIZE_T SrcDataSize, D3DX10_IMAGE_LOAD_INFO* pLoadInfo, ID3DX10ThreadPump* pPump, ID3D10Resource** ppTexture, HRESULT* pHResult); ////////////////////////////////////////////////////////////////////////////// // Misc Texture APIs ///////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// //---------------------------------------------------------------------------- // D3DX10_TEXTURE_LOAD_INFO: // ------------------------ // //---------------------------------------------------------------------------- typedef struct _D3DX10_TEXTURE_LOAD_INFO { D3D10_BOX *pSrcBox; D3D10_BOX *pDstBox; UINT SrcFirstMip; UINT DstFirstMip; UINT NumMips; UINT SrcFirstElement; UINT DstFirstElement; UINT NumElements; UINT Filter; UINT MipFilter; #ifdef __cplusplus _D3DX10_TEXTURE_LOAD_INFO() { pSrcBox = NULL; pDstBox = NULL; SrcFirstMip = 0; DstFirstMip = 0; NumMips = D3DX10_DEFAULT; SrcFirstElement = 0; DstFirstElement = 0; NumElements = D3DX10_DEFAULT; Filter = D3DX10_DEFAULT; MipFilter = D3DX10_DEFAULT; } #endif } D3DX10_TEXTURE_LOAD_INFO; //---------------------------------------------------------------------------- // D3DX10LoadTextureFromTexture: // ---------------------------- // Load a texture from a texture. // // Parameters: // //---------------------------------------------------------------------------- HRESULT WINAPI D3DX10LoadTextureFromTexture( ID3D10Resource *pSrcTexture, D3DX10_TEXTURE_LOAD_INFO *pLoadInfo, ID3D10Resource *pDstTexture); //---------------------------------------------------------------------------- // D3DX10FilterTexture: // ------------------ // 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 // D3DX10_FILTER flags controlling how each miplevel is filtered. // Or D3DX10_DEFAULT for D3DX10_FILTER_BOX, // //---------------------------------------------------------------------------- HRESULT WINAPI D3DX10FilterTexture( ID3D10Resource *pTexture, UINT SrcLevel, UINT MipFilter); //---------------------------------------------------------------------------- // D3DX10SaveTextureToFile: // ---------------------- // Save a texture to a file. // // Parameters: // pDestFile // File name of the destination file // DestFormat // D3DX10_IMAGE_FILE_FORMAT specifying file format to use when saving. // pSrcTexture // Source texture, containing the image to be saved // //---------------------------------------------------------------------------- HRESULT WINAPI D3DX10SaveTextureToFileA( ID3D10Resource *pSrcTexture, D3DX10_IMAGE_FILE_FORMAT DestFormat, LPCSTR pDestFile); HRESULT WINAPI D3DX10SaveTextureToFileW( ID3D10Resource *pSrcTexture, D3DX10_IMAGE_FILE_FORMAT DestFormat, LPCWSTR pDestFile); #ifdef UNICODE #define D3DX10SaveTextureToFile D3DX10SaveTextureToFileW #else #define D3DX10SaveTextureToFile D3DX10SaveTextureToFileA #endif //---------------------------------------------------------------------------- // D3DX10SaveTextureToMemory: // ---------------------- // Save a texture to a blob. // // Parameters: // pSrcTexture // Source texture, containing the image to be saved // DestFormat // D3DX10_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 D3DX10SaveTextureToMemory( ID3D10Resource* pSrcTexture, D3DX10_IMAGE_FILE_FORMAT DestFormat, LPD3D10BLOB* ppDestBuf, UINT Flags); //---------------------------------------------------------------------------- // D3DX10ComputeNormalMap: // --------------------- // 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 // D3DX10_NORMALMAP flags // Channel // D3DX10_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 D3DX10ComputeNormalMap( ID3D10Texture2D *pSrcTexture, UINT Flags, UINT Channel, FLOAT Amplitude, ID3D10Texture2D *pDestTexture); //---------------------------------------------------------------------------- // D3DX10SHProjectCubeMap: // ---------------------- // 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 D3DX10SHProjectCubeMap( __in_range(2,6) UINT Order, ID3D10Texture2D *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 //__D3DX10TEX_H__