1593 lines
53 KiB
C
1593 lines
53 KiB
C
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) Microsoft Corporation. All Rights Reserved.
|
|
//
|
|
// File: d3dx8tex.h
|
|
// Content: D3DX texturing APIs
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "d3dx8.h"
|
|
|
|
#ifndef __D3DX8TEX_H__
|
|
#define __D3DX8TEX_H__
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DX_FILTER flags:
|
|
// ------------------
|
|
//
|
|
// A valid filter must contain one of these values:
|
|
//
|
|
// D3DX_FILTER_NONE
|
|
// No scaling or filtering will take place. Pixels outside the bounds
|
|
// of the source image are assumed to be transparent black.
|
|
// D3DX_FILTER_POINT
|
|
// Each destination pixel is computed by sampling the nearest pixel
|
|
// from the source image.
|
|
// D3DX_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.
|
|
// D3DX_FILTER_TRIANGLE
|
|
// Every pixel in the source image contributes equally to the
|
|
// destination image. This is the slowest of all the filters.
|
|
// D3DX_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:
|
|
//
|
|
// D3DX_FILTER_MIRROR_U
|
|
// Indicates that pixels off the edge of the texture on the U-axis
|
|
// should be mirrored, not wraped.
|
|
// D3DX_FILTER_MIRROR_V
|
|
// Indicates that pixels off the edge of the texture on the V-axis
|
|
// should be mirrored, not wraped.
|
|
// D3DX_FILTER_MIRROR_W
|
|
// Indicates that pixels off the edge of the texture on the W-axis
|
|
// should be mirrored, not wraped.
|
|
// D3DX_FILTER_MIRROR
|
|
// Same as specifying D3DX_FILTER_MIRROR_U | D3DX_FILTER_MIRROR_V |
|
|
// D3DX_FILTER_MIRROR_V
|
|
// D3DX_FILTER_DITHER
|
|
// Dithers the resulting image.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#define D3DX_FILTER_NONE (1 << 0)
|
|
#define D3DX_FILTER_POINT (2 << 0)
|
|
#define D3DX_FILTER_LINEAR (3 << 0)
|
|
#define D3DX_FILTER_TRIANGLE (4 << 0)
|
|
#define D3DX_FILTER_BOX (5 << 0)
|
|
|
|
#define D3DX_FILTER_MIRROR_U (1 << 16)
|
|
#define D3DX_FILTER_MIRROR_V (2 << 16)
|
|
#define D3DX_FILTER_MIRROR_W (4 << 16)
|
|
#define D3DX_FILTER_MIRROR (7 << 16)
|
|
#define D3DX_FILTER_DITHER (8 << 16)
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DX_NORMALMAP flags:
|
|
// ---------------------
|
|
// These flags are used to control how D3DXComputeNormalMap generates normal
|
|
// maps. Any number of these flags may be OR'd together in any combination.
|
|
//
|
|
// D3DX_NORMALMAP_MIRROR_U
|
|
// Indicates that pixels off the edge of the texture on the U-axis
|
|
// should be mirrored, not wraped.
|
|
// D3DX_NORMALMAP_MIRROR_V
|
|
// Indicates that pixels off the edge of the texture on the V-axis
|
|
// should be mirrored, not wraped.
|
|
// D3DX_NORMALMAP_MIRROR
|
|
// Same as specifying D3DX_NORMALMAP_MIRROR_U | D3DX_NORMALMAP_MIRROR_V
|
|
// D3DX_NORMALMAP_INVERTSIGN
|
|
// Inverts the direction of each normal
|
|
// D3DX_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.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
#define D3DX_NORMALMAP_MIRROR_U (1 << 16)
|
|
#define D3DX_NORMALMAP_MIRROR_V (2 << 16)
|
|
#define D3DX_NORMALMAP_MIRROR (3 << 16)
|
|
#define D3DX_NORMALMAP_INVERTSIGN (8 << 16)
|
|
#define D3DX_NORMALMAP_COMPUTE_OCCLUSION (16 << 16)
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DX_CHANNEL flags:
|
|
// -------------------
|
|
// These flags are used by functions which operate on or more channels
|
|
// in a texture.
|
|
//
|
|
// D3DX_CHANNEL_RED
|
|
// Indicates the red channel should be used
|
|
// D3DX_CHANNEL_BLUE
|
|
// Indicates the blue channel should be used
|
|
// D3DX_CHANNEL_GREEN
|
|
// Indicates the green channel should be used
|
|
// D3DX_CHANNEL_ALPHA
|
|
// Indicates the alpha channel should be used
|
|
// D3DX_CHANNEL_LUMINANCE
|
|
// Indicates the luminaces of the red green and blue channels should be
|
|
// used.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#define D3DX_CHANNEL_RED (1 << 0)
|
|
#define D3DX_CHANNEL_BLUE (1 << 1)
|
|
#define D3DX_CHANNEL_GREEN (1 << 2)
|
|
#define D3DX_CHANNEL_ALPHA (1 << 3)
|
|
#define D3DX_CHANNEL_LUMINANCE (1 << 4)
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DXIMAGE_FILEFORMAT:
|
|
// ---------------------
|
|
// This enum is used to describe supported image file formats.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
typedef enum _D3DXIMAGE_FILEFORMAT
|
|
{
|
|
D3DXIFF_BMP = 0,
|
|
D3DXIFF_JPG = 1,
|
|
D3DXIFF_TGA = 2,
|
|
D3DXIFF_PNG = 3,
|
|
D3DXIFF_DDS = 4,
|
|
D3DXIFF_PPM = 5,
|
|
D3DXIFF_DIB = 6,
|
|
D3DXIFF_FORCE_DWORD = 0x7fffffff
|
|
|
|
} D3DXIMAGE_FILEFORMAT;
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// LPD3DXFILL2D and LPD3DXFILL3D:
|
|
// ------------------------------
|
|
// Function types used by the texture fill functions.
|
|
//
|
|
// Parameters:
|
|
// pOut
|
|
// Pointer to a vector which the function uses to return its result.
|
|
// X,Y,Z,W will be mapped to R,G,B,A respectivly.
|
|
// pTexCoord
|
|
// Pointer to a vector containing the coordinates of the texel currently
|
|
// being evaluated. Textures and VolumeTexture texcoord components
|
|
// range from 0 to 1. CubeTexture texcoord component range from -1 to 1.
|
|
// pTexelSize
|
|
// Pointer to a vector containing the dimensions of the current texel.
|
|
// pData
|
|
// Pointer to user data.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
typedef VOID (*LPD3DXFILL2D)(D3DXVECTOR4 *pOut, D3DXVECTOR2 *pTexCoord, D3DXVECTOR2 *pTexelSize, LPVOID pData);
|
|
typedef VOID (*LPD3DXFILL3D)(D3DXVECTOR4 *pOut, D3DXVECTOR3 *pTexCoord, D3DXVECTOR3 *pTexelSize, LPVOID pData);
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DXIMAGE_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
|
|
// MipLevels
|
|
// Number of mip levels in original image
|
|
// Format
|
|
// D3D format which most closely describes the data in original image
|
|
// ResourceType
|
|
// D3DRESOURCETYPE representing the type of texture stored in the file.
|
|
// D3DRTYPE_TEXTURE, D3DRTYPE_VOLUMETEXTURE, or D3DRTYPE_CUBETEXTURE.
|
|
// ImageFileFormat
|
|
// D3DXIMAGE_FILEFORMAT representing the format of the image file.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
typedef struct _D3DXIMAGE_INFO
|
|
{
|
|
UINT Width;
|
|
UINT Height;
|
|
UINT Depth;
|
|
UINT MipLevels;
|
|
D3DFORMAT Format;
|
|
D3DRESOURCETYPE ResourceType;
|
|
D3DXIMAGE_FILEFORMAT ImageFileFormat;
|
|
|
|
} D3DXIMAGE_INFO;
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif //__cplusplus
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Image File APIs ///////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
;
|
|
//----------------------------------------------------------------------------
|
|
// GetImageInfoFromFile/Resource:
|
|
// ------------------------------
|
|
// Fills in a D3DXIMAGE_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.
|
|
// pSrcInfo
|
|
// Pointer to a D3DXIMAGE_INFO structure to be filled in with the
|
|
// description of the data in the source image file.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT WINAPI
|
|
D3DXGetImageInfoFromFileA(
|
|
LPCSTR pSrcFile,
|
|
D3DXIMAGE_INFO* pSrcInfo);
|
|
|
|
HRESULT WINAPI
|
|
D3DXGetImageInfoFromFileW(
|
|
LPCWSTR pSrcFile,
|
|
D3DXIMAGE_INFO* pSrcInfo);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXGetImageInfoFromFile D3DXGetImageInfoFromFileW
|
|
#else
|
|
#define D3DXGetImageInfoFromFile D3DXGetImageInfoFromFileA
|
|
#endif
|
|
|
|
|
|
HRESULT WINAPI
|
|
D3DXGetImageInfoFromResourceA(
|
|
HMODULE hSrcModule,
|
|
LPCSTR pSrcResource,
|
|
D3DXIMAGE_INFO* pSrcInfo);
|
|
|
|
HRESULT WINAPI
|
|
D3DXGetImageInfoFromResourceW(
|
|
HMODULE hSrcModule,
|
|
LPCWSTR pSrcResource,
|
|
D3DXIMAGE_INFO* pSrcInfo);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXGetImageInfoFromResource D3DXGetImageInfoFromResourceW
|
|
#else
|
|
#define D3DXGetImageInfoFromResource D3DXGetImageInfoFromResourceA
|
|
#endif
|
|
|
|
|
|
HRESULT WINAPI
|
|
D3DXGetImageInfoFromFileInMemory(
|
|
LPCVOID pSrcData,
|
|
UINT SrcDataSize,
|
|
D3DXIMAGE_INFO* pSrcInfo);
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Load/Save Surface APIs ////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DXLoadSurfaceFromFile/Resource:
|
|
// ---------------------------------
|
|
// Load surface from a file or resource
|
|
//
|
|
// Parameters:
|
|
// pDestSurface
|
|
// Destination surface, which will receive the image.
|
|
// pDestPalette
|
|
// Destination palette of 256 colors, or NULL
|
|
// pDestRect
|
|
// Destination rectangle, or NULL for entire surface
|
|
// 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.
|
|
// pSrcRect
|
|
// Source rectangle, or NULL for entire image
|
|
// Filter
|
|
// D3DX_FILTER flags controlling how the image is filtered.
|
|
// Or D3DX_DEFAULT for D3DX_FILTER_TRIANGLE.
|
|
// ColorKey
|
|
// Color to replace with transparent black, or 0 to disable colorkey.
|
|
// This is always a 32-bit ARGB color, independent of the source image
|
|
// format. Alpha is significant, and should usually be set to FF for
|
|
// opaque colorkeys. (ex. Opaque black == 0xff000000)
|
|
// pSrcInfo
|
|
// Pointer to a D3DXIMAGE_INFO structure to be filled in with the
|
|
// description of the data in the source image file, or NULL.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT WINAPI
|
|
D3DXLoadSurfaceFromFileA(
|
|
LPDIRECT3DSURFACE8 pDestSurface,
|
|
CONST PALETTEENTRY* pDestPalette,
|
|
CONST RECT* pDestRect,
|
|
LPCSTR pSrcFile,
|
|
CONST RECT* pSrcRect,
|
|
DWORD Filter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo);
|
|
|
|
HRESULT WINAPI
|
|
D3DXLoadSurfaceFromFileW(
|
|
LPDIRECT3DSURFACE8 pDestSurface,
|
|
CONST PALETTEENTRY* pDestPalette,
|
|
CONST RECT* pDestRect,
|
|
LPCWSTR pSrcFile,
|
|
CONST RECT* pSrcRect,
|
|
DWORD Filter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXLoadSurfaceFromFile D3DXLoadSurfaceFromFileW
|
|
#else
|
|
#define D3DXLoadSurfaceFromFile D3DXLoadSurfaceFromFileA
|
|
#endif
|
|
|
|
|
|
|
|
HRESULT WINAPI
|
|
D3DXLoadSurfaceFromResourceA(
|
|
LPDIRECT3DSURFACE8 pDestSurface,
|
|
CONST PALETTEENTRY* pDestPalette,
|
|
CONST RECT* pDestRect,
|
|
HMODULE hSrcModule,
|
|
LPCSTR pSrcResource,
|
|
CONST RECT* pSrcRect,
|
|
DWORD Filter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo);
|
|
|
|
HRESULT WINAPI
|
|
D3DXLoadSurfaceFromResourceW(
|
|
LPDIRECT3DSURFACE8 pDestSurface,
|
|
CONST PALETTEENTRY* pDestPalette,
|
|
CONST RECT* pDestRect,
|
|
HMODULE hSrcModule,
|
|
LPCWSTR pSrcResource,
|
|
CONST RECT* pSrcRect,
|
|
DWORD Filter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo);
|
|
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXLoadSurfaceFromResource D3DXLoadSurfaceFromResourceW
|
|
#else
|
|
#define D3DXLoadSurfaceFromResource D3DXLoadSurfaceFromResourceA
|
|
#endif
|
|
|
|
|
|
|
|
HRESULT WINAPI
|
|
D3DXLoadSurfaceFromFileInMemory(
|
|
LPDIRECT3DSURFACE8 pDestSurface,
|
|
CONST PALETTEENTRY* pDestPalette,
|
|
CONST RECT* pDestRect,
|
|
LPCVOID pSrcData,
|
|
UINT SrcDataSize,
|
|
CONST RECT* pSrcRect,
|
|
DWORD Filter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo);
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DXLoadSurfaceFromSurface:
|
|
// ---------------------------
|
|
// Load surface from another surface (with color conversion)
|
|
//
|
|
// Parameters:
|
|
// pDestSurface
|
|
// Destination surface, which will receive the image.
|
|
// pDestPalette
|
|
// Destination palette of 256 colors, or NULL
|
|
// pDestRect
|
|
// Destination rectangle, or NULL for entire surface
|
|
// pSrcSurface
|
|
// Source surface
|
|
// pSrcPalette
|
|
// Source palette of 256 colors, or NULL
|
|
// pSrcRect
|
|
// Source rectangle, or NULL for entire surface
|
|
// Filter
|
|
// D3DX_FILTER flags controlling how the image is filtered.
|
|
// Or D3DX_DEFAULT for D3DX_FILTER_TRIANGLE.
|
|
// ColorKey
|
|
// Color to replace with transparent black, or 0 to disable colorkey.
|
|
// This is always a 32-bit ARGB color, independent of the source image
|
|
// format. Alpha is significant, and should usually be set to FF for
|
|
// opaque colorkeys. (ex. Opaque black == 0xff000000)
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT WINAPI
|
|
D3DXLoadSurfaceFromSurface(
|
|
LPDIRECT3DSURFACE8 pDestSurface,
|
|
CONST PALETTEENTRY* pDestPalette,
|
|
CONST RECT* pDestRect,
|
|
LPDIRECT3DSURFACE8 pSrcSurface,
|
|
CONST PALETTEENTRY* pSrcPalette,
|
|
CONST RECT* pSrcRect,
|
|
DWORD Filter,
|
|
D3DCOLOR ColorKey);
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DXLoadSurfaceFromMemory:
|
|
// --------------------------
|
|
// Load surface from memory.
|
|
//
|
|
// Parameters:
|
|
// pDestSurface
|
|
// Destination surface, which will receive the image.
|
|
// pDestPalette
|
|
// Destination palette of 256 colors, or NULL
|
|
// pDestRect
|
|
// Destination rectangle, or NULL for entire surface
|
|
// pSrcMemory
|
|
// Pointer to the top-left corner of the source image in memory
|
|
// SrcFormat
|
|
// Pixel format of the source image.
|
|
// SrcPitch
|
|
// Pitch of source image, in bytes. For DXT formats, this number
|
|
// should represent the width of one row of cells, in bytes.
|
|
// pSrcPalette
|
|
// Source palette of 256 colors, or NULL
|
|
// pSrcRect
|
|
// Source rectangle.
|
|
// Filter
|
|
// D3DX_FILTER flags controlling how the image is filtered.
|
|
// Or D3DX_DEFAULT for D3DX_FILTER_TRIANGLE.
|
|
// ColorKey
|
|
// Color to replace with transparent black, or 0 to disable colorkey.
|
|
// This is always a 32-bit ARGB color, independent of the source image
|
|
// format. Alpha is significant, and should usually be set to FF for
|
|
// opaque colorkeys. (ex. Opaque black == 0xff000000)
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT WINAPI
|
|
D3DXLoadSurfaceFromMemory(
|
|
LPDIRECT3DSURFACE8 pDestSurface,
|
|
CONST PALETTEENTRY* pDestPalette,
|
|
CONST RECT* pDestRect,
|
|
LPCVOID pSrcMemory,
|
|
D3DFORMAT SrcFormat,
|
|
UINT SrcPitch,
|
|
CONST PALETTEENTRY* pSrcPalette,
|
|
CONST RECT* pSrcRect,
|
|
DWORD Filter,
|
|
D3DCOLOR ColorKey);
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DXSaveSurfaceToFile:
|
|
// ----------------------
|
|
// Save a surface to a image file.
|
|
//
|
|
// Parameters:
|
|
// pDestFile
|
|
// File name of the destination file
|
|
// DestFormat
|
|
// D3DXIMAGE_FILEFORMAT specifying file format to use when saving.
|
|
// pSrcSurface
|
|
// Source surface, containing the image to be saved
|
|
// pSrcPalette
|
|
// Source palette of 256 colors, or NULL
|
|
// pSrcRect
|
|
// Source rectangle, or NULL for the entire image
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT WINAPI
|
|
D3DXSaveSurfaceToFileA(
|
|
LPCSTR pDestFile,
|
|
D3DXIMAGE_FILEFORMAT DestFormat,
|
|
LPDIRECT3DSURFACE8 pSrcSurface,
|
|
CONST PALETTEENTRY* pSrcPalette,
|
|
CONST RECT* pSrcRect);
|
|
|
|
HRESULT WINAPI
|
|
D3DXSaveSurfaceToFileW(
|
|
LPCWSTR pDestFile,
|
|
D3DXIMAGE_FILEFORMAT DestFormat,
|
|
LPDIRECT3DSURFACE8 pSrcSurface,
|
|
CONST PALETTEENTRY* pSrcPalette,
|
|
CONST RECT* pSrcRect);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXSaveSurfaceToFile D3DXSaveSurfaceToFileW
|
|
#else
|
|
#define D3DXSaveSurfaceToFile D3DXSaveSurfaceToFileA
|
|
#endif
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Load/Save Volume APIs /////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DXLoadVolumeFromFile/Resource:
|
|
// --------------------------------
|
|
// Load volume from a file or resource
|
|
//
|
|
// Parameters:
|
|
// pDestVolume
|
|
// Destination volume, which will receive the image.
|
|
// pDestPalette
|
|
// Destination palette of 256 colors, or NULL
|
|
// pDestBox
|
|
// Destination box, or NULL for entire volume
|
|
// 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.
|
|
// pSrcBox
|
|
// Source box, or NULL for entire image
|
|
// Filter
|
|
// D3DX_FILTER flags controlling how the image is filtered.
|
|
// Or D3DX_DEFAULT for D3DX_FILTER_TRIANGLE.
|
|
// ColorKey
|
|
// Color to replace with transparent black, or 0 to disable colorkey.
|
|
// This is always a 32-bit ARGB color, independent of the source image
|
|
// format. Alpha is significant, and should usually be set to FF for
|
|
// opaque colorkeys. (ex. Opaque black == 0xff000000)
|
|
// pSrcInfo
|
|
// Pointer to a D3DXIMAGE_INFO structure to be filled in with the
|
|
// description of the data in the source image file, or NULL.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT WINAPI
|
|
D3DXLoadVolumeFromFileA(
|
|
LPDIRECT3DVOLUME8 pDestVolume,
|
|
CONST PALETTEENTRY* pDestPalette,
|
|
CONST D3DBOX* pDestBox,
|
|
LPCSTR pSrcFile,
|
|
CONST D3DBOX* pSrcBox,
|
|
DWORD Filter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo);
|
|
|
|
HRESULT WINAPI
|
|
D3DXLoadVolumeFromFileW(
|
|
LPDIRECT3DVOLUME8 pDestVolume,
|
|
CONST PALETTEENTRY* pDestPalette,
|
|
CONST D3DBOX* pDestBox,
|
|
LPCWSTR pSrcFile,
|
|
CONST D3DBOX* pSrcBox,
|
|
DWORD Filter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXLoadVolumeFromFile D3DXLoadVolumeFromFileW
|
|
#else
|
|
#define D3DXLoadVolumeFromFile D3DXLoadVolumeFromFileA
|
|
#endif
|
|
|
|
|
|
HRESULT WINAPI
|
|
D3DXLoadVolumeFromResourceA(
|
|
LPDIRECT3DVOLUME8 pDestVolume,
|
|
CONST PALETTEENTRY* pDestPalette,
|
|
CONST D3DBOX* pDestBox,
|
|
HMODULE hSrcModule,
|
|
LPCSTR pSrcResource,
|
|
CONST D3DBOX* pSrcBox,
|
|
DWORD Filter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo);
|
|
|
|
HRESULT WINAPI
|
|
D3DXLoadVolumeFromResourceW(
|
|
LPDIRECT3DVOLUME8 pDestVolume,
|
|
CONST PALETTEENTRY* pDestPalette,
|
|
CONST D3DBOX* pDestBox,
|
|
HMODULE hSrcModule,
|
|
LPCWSTR pSrcResource,
|
|
CONST D3DBOX* pSrcBox,
|
|
DWORD Filter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXLoadVolumeFromResource D3DXLoadVolumeFromResourceW
|
|
#else
|
|
#define D3DXLoadVolumeFromResource D3DXLoadVolumeFromResourceA
|
|
#endif
|
|
|
|
|
|
|
|
HRESULT WINAPI
|
|
D3DXLoadVolumeFromFileInMemory(
|
|
LPDIRECT3DVOLUME8 pDestVolume,
|
|
CONST PALETTEENTRY* pDestPalette,
|
|
CONST D3DBOX* pDestBox,
|
|
LPCVOID pSrcData,
|
|
UINT SrcDataSize,
|
|
CONST D3DBOX* pSrcBox,
|
|
DWORD Filter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo);
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DXLoadVolumeFromVolume:
|
|
// -------------------------
|
|
// Load volume from another volume (with color conversion)
|
|
//
|
|
// Parameters:
|
|
// pDestVolume
|
|
// Destination volume, which will receive the image.
|
|
// pDestPalette
|
|
// Destination palette of 256 colors, or NULL
|
|
// pDestBox
|
|
// Destination box, or NULL for entire volume
|
|
// pSrcVolume
|
|
// Source volume
|
|
// pSrcPalette
|
|
// Source palette of 256 colors, or NULL
|
|
// pSrcBox
|
|
// Source box, or NULL for entire volume
|
|
// Filter
|
|
// D3DX_FILTER flags controlling how the image is filtered.
|
|
// Or D3DX_DEFAULT for D3DX_FILTER_TRIANGLE.
|
|
// ColorKey
|
|
// Color to replace with transparent black, or 0 to disable colorkey.
|
|
// This is always a 32-bit ARGB color, independent of the source image
|
|
// format. Alpha is significant, and should usually be set to FF for
|
|
// opaque colorkeys. (ex. Opaque black == 0xff000000)
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT WINAPI
|
|
D3DXLoadVolumeFromVolume(
|
|
LPDIRECT3DVOLUME8 pDestVolume,
|
|
CONST PALETTEENTRY* pDestPalette,
|
|
CONST D3DBOX* pDestBox,
|
|
LPDIRECT3DVOLUME8 pSrcVolume,
|
|
CONST PALETTEENTRY* pSrcPalette,
|
|
CONST D3DBOX* pSrcBox,
|
|
DWORD Filter,
|
|
D3DCOLOR ColorKey);
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DXLoadVolumeFromMemory:
|
|
// -------------------------
|
|
// Load volume from memory.
|
|
//
|
|
// Parameters:
|
|
// pDestVolume
|
|
// Destination volume, which will receive the image.
|
|
// pDestPalette
|
|
// Destination palette of 256 colors, or NULL
|
|
// pDestBox
|
|
// Destination box, or NULL for entire volume
|
|
// pSrcMemory
|
|
// Pointer to the top-left corner of the source volume in memory
|
|
// SrcFormat
|
|
// Pixel format of the source volume.
|
|
// SrcRowPitch
|
|
// Pitch of source image, in bytes. For DXT formats, this number
|
|
// should represent the size of one row of cells, in bytes.
|
|
// SrcSlicePitch
|
|
// Pitch of source image, in bytes. For DXT formats, this number
|
|
// should represent the size of one slice of cells, in bytes.
|
|
// pSrcPalette
|
|
// Source palette of 256 colors, or NULL
|
|
// pSrcBox
|
|
// Source box.
|
|
// Filter
|
|
// D3DX_FILTER flags controlling how the image is filtered.
|
|
// Or D3DX_DEFAULT for D3DX_FILTER_TRIANGLE.
|
|
// ColorKey
|
|
// Color to replace with transparent black, or 0 to disable colorkey.
|
|
// This is always a 32-bit ARGB color, independent of the source image
|
|
// format. Alpha is significant, and should usually be set to FF for
|
|
// opaque colorkeys. (ex. Opaque black == 0xff000000)
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT WINAPI
|
|
D3DXLoadVolumeFromMemory(
|
|
LPDIRECT3DVOLUME8 pDestVolume,
|
|
CONST PALETTEENTRY* pDestPalette,
|
|
CONST D3DBOX* pDestBox,
|
|
LPCVOID pSrcMemory,
|
|
D3DFORMAT SrcFormat,
|
|
UINT SrcRowPitch,
|
|
UINT SrcSlicePitch,
|
|
CONST PALETTEENTRY* pSrcPalette,
|
|
CONST D3DBOX* pSrcBox,
|
|
DWORD Filter,
|
|
D3DCOLOR ColorKey);
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DXSaveVolumeToFile:
|
|
// ---------------------
|
|
// Save a volume to a image file.
|
|
//
|
|
// Parameters:
|
|
// pDestFile
|
|
// File name of the destination file
|
|
// DestFormat
|
|
// D3DXIMAGE_FILEFORMAT specifying file format to use when saving.
|
|
// pSrcVolume
|
|
// Source volume, containing the image to be saved
|
|
// pSrcPalette
|
|
// Source palette of 256 colors, or NULL
|
|
// pSrcBox
|
|
// Source box, or NULL for the entire volume
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT WINAPI
|
|
D3DXSaveVolumeToFileA(
|
|
LPCSTR pDestFile,
|
|
D3DXIMAGE_FILEFORMAT DestFormat,
|
|
LPDIRECT3DVOLUME8 pSrcVolume,
|
|
CONST PALETTEENTRY* pSrcPalette,
|
|
CONST D3DBOX* pSrcBox);
|
|
|
|
HRESULT WINAPI
|
|
D3DXSaveVolumeToFileW(
|
|
LPCWSTR pDestFile,
|
|
D3DXIMAGE_FILEFORMAT DestFormat,
|
|
LPDIRECT3DVOLUME8 pSrcVolume,
|
|
CONST PALETTEENTRY* pSrcPalette,
|
|
CONST D3DBOX* pSrcBox);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXSaveVolumeToFile D3DXSaveVolumeToFileW
|
|
#else
|
|
#define D3DXSaveVolumeToFile D3DXSaveVolumeToFileA
|
|
#endif
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Create/Save Texture APIs //////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DXCheckTextureRequirements:
|
|
// -----------------------------
|
|
// Checks texture creation parameters. If parameters are invalid, this
|
|
// function returns corrected parameters.
|
|
//
|
|
// Parameters:
|
|
//
|
|
// pDevice
|
|
// The D3D device to be used
|
|
// pWidth, pHeight, pDepth, pSize
|
|
// Desired size in pixels, or NULL. Returns corrected size.
|
|
// pNumMipLevels
|
|
// Number of desired mipmap levels, or NULL. Returns corrected number.
|
|
// Usage
|
|
// Texture usage flags
|
|
// pFormat
|
|
// Desired pixel format, or NULL. Returns corrected format.
|
|
// Pool
|
|
// Memory pool to be used to create texture
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT WINAPI
|
|
D3DXCheckTextureRequirements(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
UINT* pWidth,
|
|
UINT* pHeight,
|
|
UINT* pNumMipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT* pFormat,
|
|
D3DPOOL Pool);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCheckCubeTextureRequirements(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
UINT* pSize,
|
|
UINT* pNumMipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT* pFormat,
|
|
D3DPOOL Pool);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCheckVolumeTextureRequirements(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
UINT* pWidth,
|
|
UINT* pHeight,
|
|
UINT* pDepth,
|
|
UINT* pNumMipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT* pFormat,
|
|
D3DPOOL Pool);
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DXCreateTexture:
|
|
// ------------------
|
|
// Create an empty texture
|
|
//
|
|
// Parameters:
|
|
//
|
|
// pDevice
|
|
// The D3D device with which the texture is going to be used.
|
|
// Width, Height, Depth, Size
|
|
// size in pixels; these must be non-zero
|
|
// MipLevels
|
|
// number of mip levels desired; if zero or D3DX_DEFAULT, a complete
|
|
// mipmap chain will be created.
|
|
// Usage
|
|
// Texture usage flags
|
|
// Format
|
|
// Pixel format.
|
|
// Pool
|
|
// Memory pool to be used to create texture
|
|
// ppTexture, ppCubeTexture, ppVolumeTexture
|
|
// The texture object that will be created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateTexture(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
UINT Width,
|
|
UINT Height,
|
|
UINT MipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
LPDIRECT3DTEXTURE8* ppTexture);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateCubeTexture(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
UINT Size,
|
|
UINT MipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
LPDIRECT3DCUBETEXTURE8* ppCubeTexture);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateVolumeTexture(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
UINT Width,
|
|
UINT Height,
|
|
UINT Depth,
|
|
UINT MipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
LPDIRECT3DVOLUMETEXTURE8* ppVolumeTexture);
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DXCreateTextureFromFile/Resource:
|
|
// -----------------------------------
|
|
// 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.
|
|
// Width, Height, Depth, Size
|
|
// Size in pixels; if zero or D3DX_DEFAULT, the size will be taken
|
|
// from the file.
|
|
// MipLevels
|
|
// Number of mip levels; if zero or D3DX_DEFAULT, a complete mipmap
|
|
// chain will be created.
|
|
// Usage
|
|
// Texture usage flags
|
|
// Format
|
|
// Desired pixel format. If D3DFMT_UNKNOWN, the format will be
|
|
// taken from the file.
|
|
// Pool
|
|
// Memory pool to be used to create texture
|
|
// Filter
|
|
// D3DX_FILTER flags controlling how the image is filtered.
|
|
// Or D3DX_DEFAULT for D3DX_FILTER_TRIANGLE.
|
|
// MipFilter
|
|
// D3DX_FILTER flags controlling how each miplevel is filtered.
|
|
// Or D3DX_DEFAULT for D3DX_FILTER_BOX,
|
|
// ColorKey
|
|
// Color to replace with transparent black, or 0 to disable colorkey.
|
|
// This is always a 32-bit ARGB color, independent of the source image
|
|
// format. Alpha is significant, and should usually be set to FF for
|
|
// opaque colorkeys. (ex. Opaque black == 0xff000000)
|
|
// pSrcInfo
|
|
// Pointer to a D3DXIMAGE_INFO structure to be filled in with the
|
|
// description of the data in the source image file, or NULL.
|
|
// pPalette
|
|
// 256 color palette to be filled in, or NULL
|
|
// ppTexture, ppCubeTexture, ppVolumeTexture
|
|
// The texture object that will be created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
|
|
// FromFile
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateTextureFromFileA(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
LPCSTR pSrcFile,
|
|
LPDIRECT3DTEXTURE8* ppTexture);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateTextureFromFileW(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
LPCWSTR pSrcFile,
|
|
LPDIRECT3DTEXTURE8* ppTexture);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXCreateTextureFromFile D3DXCreateTextureFromFileW
|
|
#else
|
|
#define D3DXCreateTextureFromFile D3DXCreateTextureFromFileA
|
|
#endif
|
|
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateCubeTextureFromFileA(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
LPCSTR pSrcFile,
|
|
LPDIRECT3DCUBETEXTURE8* ppCubeTexture);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateCubeTextureFromFileW(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
LPCWSTR pSrcFile,
|
|
LPDIRECT3DCUBETEXTURE8* ppCubeTexture);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXCreateCubeTextureFromFile D3DXCreateCubeTextureFromFileW
|
|
#else
|
|
#define D3DXCreateCubeTextureFromFile D3DXCreateCubeTextureFromFileA
|
|
#endif
|
|
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateVolumeTextureFromFileA(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
LPCSTR pSrcFile,
|
|
LPDIRECT3DVOLUMETEXTURE8* ppVolumeTexture);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateVolumeTextureFromFileW(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
LPCWSTR pSrcFile,
|
|
LPDIRECT3DVOLUMETEXTURE8* ppVolumeTexture);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXCreateVolumeTextureFromFile D3DXCreateVolumeTextureFromFileW
|
|
#else
|
|
#define D3DXCreateVolumeTextureFromFile D3DXCreateVolumeTextureFromFileA
|
|
#endif
|
|
|
|
|
|
// FromResource
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateTextureFromResourceA(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
HMODULE hSrcModule,
|
|
LPCSTR pSrcResource,
|
|
LPDIRECT3DTEXTURE8* ppTexture);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateTextureFromResourceW(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
HMODULE hSrcModule,
|
|
LPCWSTR pSrcResource,
|
|
LPDIRECT3DTEXTURE8* ppTexture);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXCreateTextureFromResource D3DXCreateTextureFromResourceW
|
|
#else
|
|
#define D3DXCreateTextureFromResource D3DXCreateTextureFromResourceA
|
|
#endif
|
|
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateCubeTextureFromResourceA(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
HMODULE hSrcModule,
|
|
LPCSTR pSrcResource,
|
|
LPDIRECT3DCUBETEXTURE8* ppCubeTexture);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateCubeTextureFromResourceW(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
HMODULE hSrcModule,
|
|
LPCWSTR pSrcResource,
|
|
LPDIRECT3DCUBETEXTURE8* ppCubeTexture);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXCreateCubeTextureFromResource D3DXCreateCubeTextureFromResourceW
|
|
#else
|
|
#define D3DXCreateCubeTextureFromResource D3DXCreateCubeTextureFromResourceA
|
|
#endif
|
|
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateVolumeTextureFromResourceA(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
HMODULE hSrcModule,
|
|
LPCSTR pSrcResource,
|
|
LPDIRECT3DVOLUMETEXTURE8* ppVolumeTexture);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateVolumeTextureFromResourceW(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
HMODULE hSrcModule,
|
|
LPCWSTR pSrcResource,
|
|
LPDIRECT3DVOLUMETEXTURE8* ppVolumeTexture);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXCreateVolumeTextureFromResource D3DXCreateVolumeTextureFromResourceW
|
|
#else
|
|
#define D3DXCreateVolumeTextureFromResource D3DXCreateVolumeTextureFromResourceA
|
|
#endif
|
|
|
|
|
|
// FromFileEx
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateTextureFromFileExA(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
LPCSTR pSrcFile,
|
|
UINT Width,
|
|
UINT Height,
|
|
UINT MipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
DWORD Filter,
|
|
DWORD MipFilter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo,
|
|
PALETTEENTRY* pPalette,
|
|
LPDIRECT3DTEXTURE8* ppTexture);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateTextureFromFileExW(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
LPCWSTR pSrcFile,
|
|
UINT Width,
|
|
UINT Height,
|
|
UINT MipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
DWORD Filter,
|
|
DWORD MipFilter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo,
|
|
PALETTEENTRY* pPalette,
|
|
LPDIRECT3DTEXTURE8* ppTexture);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXCreateTextureFromFileEx D3DXCreateTextureFromFileExW
|
|
#else
|
|
#define D3DXCreateTextureFromFileEx D3DXCreateTextureFromFileExA
|
|
#endif
|
|
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateCubeTextureFromFileExA(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
LPCSTR pSrcFile,
|
|
UINT Size,
|
|
UINT MipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
DWORD Filter,
|
|
DWORD MipFilter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo,
|
|
PALETTEENTRY* pPalette,
|
|
LPDIRECT3DCUBETEXTURE8* ppCubeTexture);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateCubeTextureFromFileExW(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
LPCWSTR pSrcFile,
|
|
UINT Size,
|
|
UINT MipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
DWORD Filter,
|
|
DWORD MipFilter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo,
|
|
PALETTEENTRY* pPalette,
|
|
LPDIRECT3DCUBETEXTURE8* ppCubeTexture);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXCreateCubeTextureFromFileEx D3DXCreateCubeTextureFromFileExW
|
|
#else
|
|
#define D3DXCreateCubeTextureFromFileEx D3DXCreateCubeTextureFromFileExA
|
|
#endif
|
|
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateVolumeTextureFromFileExA(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
LPCSTR pSrcFile,
|
|
UINT Width,
|
|
UINT Height,
|
|
UINT Depth,
|
|
UINT MipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
DWORD Filter,
|
|
DWORD MipFilter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo,
|
|
PALETTEENTRY* pPalette,
|
|
LPDIRECT3DVOLUMETEXTURE8* ppVolumeTexture);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateVolumeTextureFromFileExW(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
LPCWSTR pSrcFile,
|
|
UINT Width,
|
|
UINT Height,
|
|
UINT Depth,
|
|
UINT MipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
DWORD Filter,
|
|
DWORD MipFilter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo,
|
|
PALETTEENTRY* pPalette,
|
|
LPDIRECT3DVOLUMETEXTURE8* ppVolumeTexture);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXCreateVolumeTextureFromFileEx D3DXCreateVolumeTextureFromFileExW
|
|
#else
|
|
#define D3DXCreateVolumeTextureFromFileEx D3DXCreateVolumeTextureFromFileExA
|
|
#endif
|
|
|
|
|
|
// FromResourceEx
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateTextureFromResourceExA(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
HMODULE hSrcModule,
|
|
LPCSTR pSrcResource,
|
|
UINT Width,
|
|
UINT Height,
|
|
UINT MipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
DWORD Filter,
|
|
DWORD MipFilter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo,
|
|
PALETTEENTRY* pPalette,
|
|
LPDIRECT3DTEXTURE8* ppTexture);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateTextureFromResourceExW(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
HMODULE hSrcModule,
|
|
LPCWSTR pSrcResource,
|
|
UINT Width,
|
|
UINT Height,
|
|
UINT MipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
DWORD Filter,
|
|
DWORD MipFilter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo,
|
|
PALETTEENTRY* pPalette,
|
|
LPDIRECT3DTEXTURE8* ppTexture);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXCreateTextureFromResourceEx D3DXCreateTextureFromResourceExW
|
|
#else
|
|
#define D3DXCreateTextureFromResourceEx D3DXCreateTextureFromResourceExA
|
|
#endif
|
|
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateCubeTextureFromResourceExA(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
HMODULE hSrcModule,
|
|
LPCSTR pSrcResource,
|
|
UINT Size,
|
|
UINT MipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
DWORD Filter,
|
|
DWORD MipFilter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo,
|
|
PALETTEENTRY* pPalette,
|
|
LPDIRECT3DCUBETEXTURE8* ppCubeTexture);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateCubeTextureFromResourceExW(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
HMODULE hSrcModule,
|
|
LPCWSTR pSrcResource,
|
|
UINT Size,
|
|
UINT MipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
DWORD Filter,
|
|
DWORD MipFilter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo,
|
|
PALETTEENTRY* pPalette,
|
|
LPDIRECT3DCUBETEXTURE8* ppCubeTexture);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXCreateCubeTextureFromResourceEx D3DXCreateCubeTextureFromResourceExW
|
|
#else
|
|
#define D3DXCreateCubeTextureFromResourceEx D3DXCreateCubeTextureFromResourceExA
|
|
#endif
|
|
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateVolumeTextureFromResourceExA(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
HMODULE hSrcModule,
|
|
LPCSTR pSrcResource,
|
|
UINT Width,
|
|
UINT Height,
|
|
UINT Depth,
|
|
UINT MipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
DWORD Filter,
|
|
DWORD MipFilter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo,
|
|
PALETTEENTRY* pPalette,
|
|
LPDIRECT3DVOLUMETEXTURE8* ppVolumeTexture);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateVolumeTextureFromResourceExW(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
HMODULE hSrcModule,
|
|
LPCWSTR pSrcResource,
|
|
UINT Width,
|
|
UINT Height,
|
|
UINT Depth,
|
|
UINT MipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
DWORD Filter,
|
|
DWORD MipFilter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo,
|
|
PALETTEENTRY* pPalette,
|
|
LPDIRECT3DVOLUMETEXTURE8* ppVolumeTexture);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXCreateVolumeTextureFromResourceEx D3DXCreateVolumeTextureFromResourceExW
|
|
#else
|
|
#define D3DXCreateVolumeTextureFromResourceEx D3DXCreateVolumeTextureFromResourceExA
|
|
#endif
|
|
|
|
|
|
// FromFileInMemory
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateTextureFromFileInMemory(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
LPCVOID pSrcData,
|
|
UINT SrcDataSize,
|
|
LPDIRECT3DTEXTURE8* ppTexture);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateCubeTextureFromFileInMemory(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
LPCVOID pSrcData,
|
|
UINT SrcDataSize,
|
|
LPDIRECT3DCUBETEXTURE8* ppCubeTexture);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateVolumeTextureFromFileInMemory(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
LPCVOID pSrcData,
|
|
UINT SrcDataSize,
|
|
LPDIRECT3DVOLUMETEXTURE8* ppVolumeTexture);
|
|
|
|
|
|
// FromFileInMemoryEx
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateTextureFromFileInMemoryEx(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
LPCVOID pSrcData,
|
|
UINT SrcDataSize,
|
|
UINT Width,
|
|
UINT Height,
|
|
UINT MipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
DWORD Filter,
|
|
DWORD MipFilter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo,
|
|
PALETTEENTRY* pPalette,
|
|
LPDIRECT3DTEXTURE8* ppTexture);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateCubeTextureFromFileInMemoryEx(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
LPCVOID pSrcData,
|
|
UINT SrcDataSize,
|
|
UINT Size,
|
|
UINT MipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
DWORD Filter,
|
|
DWORD MipFilter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo,
|
|
PALETTEENTRY* pPalette,
|
|
LPDIRECT3DCUBETEXTURE8* ppCubeTexture);
|
|
|
|
HRESULT WINAPI
|
|
D3DXCreateVolumeTextureFromFileInMemoryEx(
|
|
LPDIRECT3DDEVICE8 pDevice,
|
|
LPCVOID pSrcData,
|
|
UINT SrcDataSize,
|
|
UINT Width,
|
|
UINT Height,
|
|
UINT Depth,
|
|
UINT MipLevels,
|
|
DWORD Usage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
DWORD Filter,
|
|
DWORD MipFilter,
|
|
D3DCOLOR ColorKey,
|
|
D3DXIMAGE_INFO* pSrcInfo,
|
|
PALETTEENTRY* pPalette,
|
|
LPDIRECT3DVOLUMETEXTURE8* ppVolumeTexture);
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DXSaveTextureToFile:
|
|
// ----------------------
|
|
// Save a texture to a file.
|
|
//
|
|
// Parameters:
|
|
// pDestFile
|
|
// File name of the destination file
|
|
// DestFormat
|
|
// D3DXIMAGE_FILEFORMAT specifying file format to use when saving.
|
|
// pSrcTexture
|
|
// Source texture, containing the image to be saved
|
|
// pSrcPalette
|
|
// Source palette of 256 colors, or NULL
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
|
|
HRESULT WINAPI
|
|
D3DXSaveTextureToFileA(
|
|
LPCSTR pDestFile,
|
|
D3DXIMAGE_FILEFORMAT DestFormat,
|
|
LPDIRECT3DBASETEXTURE8 pSrcTexture,
|
|
CONST PALETTEENTRY* pSrcPalette);
|
|
|
|
HRESULT WINAPI
|
|
D3DXSaveTextureToFileW(
|
|
LPCWSTR pDestFile,
|
|
D3DXIMAGE_FILEFORMAT DestFormat,
|
|
LPDIRECT3DBASETEXTURE8 pSrcTexture,
|
|
CONST PALETTEENTRY* pSrcPalette);
|
|
|
|
#ifdef UNICODE
|
|
#define D3DXSaveTextureToFile D3DXSaveTextureToFileW
|
|
#else
|
|
#define D3DXSaveTextureToFile D3DXSaveTextureToFileA
|
|
#endif
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Misc Texture APIs /////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DXFilterTexture:
|
|
// ------------------
|
|
// Filters mipmaps levels of a texture.
|
|
//
|
|
// Parameters:
|
|
// pBaseTexture
|
|
// The texture object to be filtered
|
|
// pPalette
|
|
// 256 color palette to be used, or NULL for non-palettized formats
|
|
// SrcLevel
|
|
// The level whose image is used to generate the subsequent levels.
|
|
// Filter
|
|
// D3DX_FILTER flags controlling how each miplevel is filtered.
|
|
// Or D3DX_DEFAULT for D3DX_FILTER_BOX,
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT WINAPI
|
|
D3DXFilterTexture(
|
|
LPDIRECT3DBASETEXTURE8 pBaseTexture,
|
|
CONST PALETTEENTRY* pPalette,
|
|
UINT SrcLevel,
|
|
DWORD Filter);
|
|
|
|
#define D3DXFilterCubeTexture D3DXFilterTexture
|
|
#define D3DXFilterVolumeTexture D3DXFilterTexture
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DXFillTexture:
|
|
// ----------------
|
|
// Uses a user provided function to fill each texel of each mip level of a
|
|
// given texture.
|
|
//
|
|
// Paramters:
|
|
// pTexture, pCubeTexture, pVolumeTexture
|
|
// Pointer to the texture to be filled.
|
|
// pFunction
|
|
// Pointer to user provided evalutor function which will be used to
|
|
// compute the value of each texel.
|
|
// pData
|
|
// Pointer to an arbitrary block of user defined data. This pointer
|
|
// will be passed to the function provided in pFunction
|
|
//-----------------------------------------------------------------------------
|
|
|
|
HRESULT WINAPI
|
|
D3DXFillTexture(
|
|
LPDIRECT3DTEXTURE8 pTexture,
|
|
LPD3DXFILL2D pFunction,
|
|
LPVOID pData);
|
|
|
|
HRESULT WINAPI
|
|
D3DXFillCubeTexture(
|
|
LPDIRECT3DCUBETEXTURE8 pCubeTexture,
|
|
LPD3DXFILL3D pFunction,
|
|
LPVOID pData);
|
|
|
|
HRESULT WINAPI
|
|
D3DXFillVolumeTexture(
|
|
LPDIRECT3DVOLUMETEXTURE8 pVolumeTexture,
|
|
LPD3DXFILL3D pFunction,
|
|
LPVOID pData);
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// D3DXComputeNormalMap:
|
|
// ---------------------
|
|
// 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
|
|
// pTexture
|
|
// Pointer to the destination texture
|
|
// pSrcTexture
|
|
// Pointer to the source heightmap texture
|
|
// pSrcPalette
|
|
// Source palette of 256 colors, or NULL
|
|
// Flags
|
|
// D3DX_NORMALMAP flags
|
|
// Channel
|
|
// D3DX_CHANNEL specifying source of height information
|
|
// Amplitude
|
|
// The constant value which the height information is multiplied by.
|
|
//---------------------------------------------------------------------------
|
|
|
|
HRESULT WINAPI
|
|
D3DXComputeNormalMap(
|
|
LPDIRECT3DTEXTURE8 pTexture,
|
|
LPDIRECT3DTEXTURE8 pSrcTexture,
|
|
CONST PALETTEENTRY* pSrcPalette,
|
|
DWORD Flags,
|
|
DWORD Channel,
|
|
FLOAT Amplitude);
|
|
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif //__cplusplus
|
|
|
|
#endif //__D3DX8TEX_H__
|