d3dx9tex.h File Reference

#include <d3dx9.h>

Include dependency graph for d3dx9tex.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_D3DXIMAGE_INFO

Macros
#define	D3DX_FILTER_NONE   0x00000001
#define	D3DX_FILTER_POINT   0x00000002
#define	D3DX_FILTER_LINEAR   0x00000003
#define	D3DX_FILTER_TRIANGLE   0x00000004
#define	D3DX_FILTER_BOX   0x00000005
#define	D3DX_FILTER_MIRROR_U   0x00010000
#define	D3DX_FILTER_MIRROR_V   0x00020000
#define	D3DX_FILTER_MIRROR_W   0x00040000
#define	D3DX_FILTER_MIRROR   0x00070000
#define	D3DX_FILTER_DITHER   0x00080000
#define	D3DX_FILTER_DITHER_DIFFUSION   0x00100000
#define	D3DX_FILTER_SRGB_IN   0x00200000
#define	D3DX_FILTER_SRGB_OUT   0x00400000
#define	D3DX_FILTER_SRGB   0x00600000
#define	D3DX_SKIP_DDS_MIP_LEVELS_MASK   0x1f
#define	D3DX_SKIP_DDS_MIP_LEVELS_SHIFT   26
#define	D3DX_SKIP_DDS_MIP_LEVELS(l, f)
#define	D3DX_NORMALMAP_MIRROR_U   0x00010000
#define	D3DX_NORMALMAP_MIRROR_V   0x00020000
#define	D3DX_NORMALMAP_MIRROR   0x00030000
#define	D3DX_NORMALMAP_INVERTSIGN   0x00080000
#define	D3DX_NORMALMAP_COMPUTE_OCCLUSION   0x00100000
#define	D3DX_CHANNEL_RED   0x00000001
#define	D3DX_CHANNEL_BLUE   0x00000002
#define	D3DX_CHANNEL_GREEN   0x00000004
#define	D3DX_CHANNEL_ALPHA   0x00000008
#define	D3DX_CHANNEL_LUMINANCE   0x00000010
#define	D3DXGetImageInfoFromFile   WINELIB_NAME_AW(D3DXGetImageInfoFromFile)
#define	D3DXGetImageInfoFromResource   WINELIB_NAME_AW(D3DXGetImageInfoFromResource)
#define	D3DXLoadSurfaceFromFile   WINELIB_NAME_AW(D3DXLoadSurfaceFromFile)
#define	D3DXLoadSurfaceFromResource   WINELIB_NAME_AW(D3DXLoadSurfaceFromResource)
#define	D3DXSaveSurfaceToFile   WINELIB_NAME_AW(D3DXSaveSurfaceToFile)
#define	D3DXLoadVolumeFromFile   WINELIB_NAME_AW(D3DXLoadVolumeFromFile)
#define	D3DXLoadVolumeFromResource   WINELIB_NAME_AW(D3DXLoadVolumeFromResource)
#define	D3DXSaveVolumeToFile   WINELIB_NAME_AW(D3DXSaveVolumeToFile)
#define	D3DXCreateTextureFromFile   WINELIB_NAME_AW(D3DXCreateTextureFromFile)
#define	D3DXCreateCubeTextureFromFile   WINELIB_NAME_AW(D3DXCreateCubeTextureFromFile)
#define	D3DXCreateVolumeTextureFromFile   WINELIB_NAME_AW(D3DXCreateVolumeTextureFromFile)
#define	D3DXCreateTextureFromResource   WINELIB_NAME_AW(D3DXCreateTextureFromResource)
#define	D3DXCreateCubeTextureFromResource   WINELIB_NAME_AW(D3DXCreateCubeTextureFromResource)
#define	D3DXCreateVolumeTextureFromResource   WINELIB_NAME_AW(D3DXCreateVolumeTextureFromResource)
#define	D3DXCreateTextureFromFileEx   WINELIB_NAME_AW(D3DXCreateTextureFromFileEx)
#define	D3DXCreateCubeTextureFromFileEx   WINELIB_NAME_AW(D3DXCreateCubeTextureFromFileEx)
#define	D3DXCreateVolumeTextureFromFileEx   WINELIB_NAME_AW(D3DXCreateVolumeTextureFromFileEx)
#define	D3DXCreateTextureFromResourceEx   WINELIB_NAME_AW(D3DXCreateTextureFromResourceEx)
#define	D3DXCreateCubeTextureFromResourceEx   WINELIB_NAME_AW(D3DXCreateCubeTextureFromResourceEx)
#define	D3DXCreateVolumeTextureFromResourceEx   WINELIB_NAME_AW(D3DXCreateVolumeTextureFromResourceEx)
#define	D3DXSaveTextureToFile   WINELIB_NAME_AW(D3DXSaveTextureToFile)
#define	D3DXFilterCubeTexture   D3DXFilterTexture
#define	D3DXFilterVolumeTexture   D3DXFilterTexture

Typedefs
typedef enum _D3DXIMAGE_FILEFORMAT	D3DXIMAGE_FILEFORMAT
typedef struct _D3DXIMAGE_INFO	D3DXIMAGE_INFO
typedef void(WINAPI *	LPD3DXFILL2D) (D3DXVECTOR4 *out, const D3DXVECTOR2 *texcoord, const D3DXVECTOR2 *texelsize, void *data)
typedef void(WINAPI *	LPD3DXFILL3D) (D3DXVECTOR4 *out, const D3DXVECTOR3 *texcoord, const D3DXVECTOR3 *texelsize, void *data)

Enumerations
enum	_D3DXIMAGE_FILEFORMAT {   D3DXIFF_BMP , D3DXIFF_JPG , D3DXIFF_TGA , D3DXIFF_PNG ,   D3DXIFF_DDS , D3DXIFF_PPM , D3DXIFF_DIB , D3DXIFF_HDR ,   D3DXIFF_PFM , D3DXIFF_FORCE_DWORD = 0x7fffffff }

Functions
HRESULT WINAPI	D3DXGetImageInfoFromFileA (const char *file, D3DXIMAGE_INFO *info)
HRESULT WINAPI	D3DXGetImageInfoFromFileW (const WCHAR *file, D3DXIMAGE_INFO *info)
HRESULT WINAPI	D3DXGetImageInfoFromResourceA (HMODULE module, const char *resource, D3DXIMAGE_INFO *info)
HRESULT WINAPI	D3DXGetImageInfoFromResourceW (HMODULE module, const WCHAR *resource, D3DXIMAGE_INFO *info)
HRESULT WINAPI	D3DXGetImageInfoFromFileInMemory (const void *data, UINT data_size, D3DXIMAGE_INFO *info)
HRESULT WINAPI	D3DXLoadSurfaceFromFileA (struct IDirect3DSurface9 *destsurface, const PALETTEENTRY *destpalette, const RECT *destrect, const char *srcfile, const RECT *srcrect, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo)
HRESULT WINAPI	D3DXLoadSurfaceFromFileW (struct IDirect3DSurface9 *destsurface, const PALETTEENTRY *destpalette, const RECT *destrect, const WCHAR *srcfile, const RECT *srcrect, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo)
HRESULT WINAPI	D3DXLoadSurfaceFromResourceA (struct IDirect3DSurface9 *destsurface, const PALETTEENTRY *destpalette, const RECT *destrect, HMODULE srcmodule, const char *resource, const RECT *srcrect, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo)
HRESULT WINAPI	D3DXLoadSurfaceFromResourceW (struct IDirect3DSurface9 *destsurface, const PALETTEENTRY *destpalette, const RECT *destrect, HMODULE srcmodule, const WCHAR *resource, const RECT *srcrect, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo)
HRESULT WINAPI	D3DXLoadSurfaceFromFileInMemory (struct IDirect3DSurface9 *destsurface, const PALETTEENTRY *destpalette, const RECT *destrect, const void *srcdata, UINT srcdatasize, const RECT *srcrect, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo)
HRESULT WINAPI	D3DXLoadSurfaceFromSurface (struct IDirect3DSurface9 *destsurface, const PALETTEENTRY *destpalette, const RECT *destrect, struct IDirect3DSurface9 *srcsurface, const PALETTEENTRY *srcpalette, const RECT *srcrect, DWORD filter, D3DCOLOR colorkey)
HRESULT WINAPI	D3DXLoadSurfaceFromMemory (IDirect3DSurface9 *dst_surface, const PALETTEENTRY *dst_palette, const RECT *dst_rect, const void *src_memory, D3DFORMAT src_format, UINT src_pitch, const PALETTEENTRY *src_palette, const RECT *src_rect, DWORD filter, D3DCOLOR color_key)
HRESULT WINAPI	D3DXSaveSurfaceToFileInMemory (struct ID3DXBuffer **destbuffer, D3DXIMAGE_FILEFORMAT destformat, struct IDirect3DSurface9 *srcsurface, const PALETTEENTRY *srcpalette, const RECT *srcrect)
HRESULT WINAPI	D3DXSaveSurfaceToFileA (const char *destfile, D3DXIMAGE_FILEFORMAT destformat, struct IDirect3DSurface9 *srcsurface, const PALETTEENTRY *srcpalette, const RECT *srcrect)
HRESULT WINAPI	D3DXSaveSurfaceToFileW (const WCHAR *destfile, D3DXIMAGE_FILEFORMAT destformat, struct IDirect3DSurface9 *srcsurface, const PALETTEENTRY *srcpalette, const RECT *srcrect)
HRESULT WINAPI	D3DXLoadVolumeFromFileA (struct IDirect3DVolume9 *destvolume, const PALETTEENTRY *destpalette, const D3DBOX *destbox, const char *srcfile, const D3DBOX *srcbox, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo)
HRESULT WINAPI	D3DXLoadVolumeFromFileW (struct IDirect3DVolume9 *destvolume, const PALETTEENTRY *destpalette, const D3DBOX *destbox, const WCHAR *srcfile, const D3DBOX *srcbox, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo)
HRESULT WINAPI	D3DXLoadVolumeFromResourceA (struct IDirect3DVolume9 *destvolume, const PALETTEENTRY *destpalette, const D3DBOX *destbox, HMODULE srcmodule, const char *resource, const D3DBOX *srcbox, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo)
HRESULT WINAPI	D3DXLoadVolumeFromResourceW (struct IDirect3DVolume9 *destvolume, const PALETTEENTRY *destpalette, const D3DBOX *destbox, HMODULE srcmodule, const WCHAR *resource, const D3DBOX *srcbox, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo)
HRESULT WINAPI	D3DXLoadVolumeFromFileInMemory (struct IDirect3DVolume9 *destvolume, const PALETTEENTRY *destpalette, const D3DBOX *destbox, const void *srcdata, UINT srcdatasize, const D3DBOX *srcbox, DWORD filter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo)
HRESULT WINAPI	D3DXLoadVolumeFromVolume (struct IDirect3DVolume9 *destvolume, const PALETTEENTRY *destpalette, const D3DBOX *destbox, struct IDirect3DVolume9 *srcvolume, const PALETTEENTRY *srcpalette, const D3DBOX *srcbox, DWORD filter, D3DCOLOR colorkey)
HRESULT WINAPI	D3DXLoadVolumeFromMemory (struct IDirect3DVolume9 *destvolume, const PALETTEENTRY *destpalette, const D3DBOX *destbox, const void *srcmemory, D3DFORMAT srcformat, UINT srcrowpitch, UINT srcslicepitch, const PALETTEENTRY *srcpalette, const D3DBOX *srcbox, DWORD filter, D3DCOLOR colorkey)
HRESULT WINAPI	D3DXSaveVolumeToFileA (const char *destfile, D3DXIMAGE_FILEFORMAT destformat, struct IDirect3DVolume9 *srcvolume, const PALETTEENTRY *srcpalette, const D3DBOX *srcbox)
HRESULT WINAPI	D3DXSaveVolumeToFileW (const WCHAR *destfile, D3DXIMAGE_FILEFORMAT destformat, struct IDirect3DVolume9 *srcvolume, const PALETTEENTRY *srcpalette, const D3DBOX *srcbox)
HRESULT WINAPI	D3DXCheckTextureRequirements (struct IDirect3DDevice9 *device, UINT *width, UINT *height, UINT *miplevels, DWORD usage, D3DFORMAT *format, D3DPOOL pool)
HRESULT WINAPI	D3DXCheckCubeTextureRequirements (struct IDirect3DDevice9 *device, UINT *size, UINT *miplevels, DWORD usage, D3DFORMAT *format, D3DPOOL pool)
HRESULT WINAPI	D3DXCheckVolumeTextureRequirements (struct IDirect3DDevice9 *device, UINT *width, UINT *height, UINT *depth, UINT *miplevels, DWORD usage, D3DFORMAT *format, D3DPOOL pool)
HRESULT WINAPI	D3DXCreateTexture (struct IDirect3DDevice9 *device, UINT width, UINT height, UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, struct IDirect3DTexture9 **texture)
HRESULT WINAPI	D3DXCreateCubeTexture (struct IDirect3DDevice9 *device, UINT size, UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, struct IDirect3DCubeTexture9 **cube)
HRESULT WINAPI	D3DXCreateVolumeTexture (struct IDirect3DDevice9 *device, UINT width, UINT height, UINT depth, UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, struct IDirect3DVolumeTexture9 **volume)
HRESULT WINAPI	D3DXCreateTextureFromFileA (struct IDirect3DDevice9 *device, const char *srcfile, struct IDirect3DTexture9 **texture)
HRESULT WINAPI	D3DXCreateTextureFromFileW (struct IDirect3DDevice9 *device, const WCHAR *srcfile, struct IDirect3DTexture9 **texture)
HRESULT WINAPI	D3DXCreateCubeTextureFromFileA (struct IDirect3DDevice9 *device, const char *srcfile, struct IDirect3DCubeTexture9 **cube)
HRESULT WINAPI	D3DXCreateCubeTextureFromFileW (struct IDirect3DDevice9 *device, const WCHAR *srcfile, struct IDirect3DCubeTexture9 **cube)
HRESULT WINAPI	D3DXCreateVolumeTextureFromFileA (struct IDirect3DDevice9 *device, const char *srcfile, struct IDirect3DVolumeTexture9 **volume)
HRESULT WINAPI	D3DXCreateVolumeTextureFromFileW (struct IDirect3DDevice9 *device, const WCHAR *srcfile, struct IDirect3DVolumeTexture9 **volume)
HRESULT WINAPI	D3DXCreateTextureFromResourceA (struct IDirect3DDevice9 *device, HMODULE srcmodule, const char *resource, struct IDirect3DTexture9 **texture)
HRESULT WINAPI	D3DXCreateTextureFromResourceW (struct IDirect3DDevice9 *device, HMODULE srcmodule, const WCHAR *resource, struct IDirect3DTexture9 **texture)
HRESULT WINAPI	D3DXCreateCubeTextureFromResourceA (struct IDirect3DDevice9 *device, HMODULE srcmodule, const char *resource, struct IDirect3DCubeTexture9 **cube)
HRESULT WINAPI	D3DXCreateCubeTextureFromResourceW (struct IDirect3DDevice9 *device, HMODULE srcmodule, const WCHAR *resource, struct IDirect3DCubeTexture9 **cube)
HRESULT WINAPI	D3DXCreateVolumeTextureFromResourceA (struct IDirect3DDevice9 *device, HMODULE srcmodule, const char *resource, struct IDirect3DVolumeTexture9 **volume)
HRESULT WINAPI	D3DXCreateVolumeTextureFromResourceW (struct IDirect3DDevice9 *device, HMODULE srcmodule, const WCHAR *resource, struct IDirect3DVolumeTexture9 **volume)
HRESULT WINAPI	D3DXCreateTextureFromFileExA (struct IDirect3DDevice9 *device, const char *srcfile, UINT width, UINT height, UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, PALETTEENTRY *palette, struct IDirect3DTexture9 **texture)
HRESULT WINAPI	D3DXCreateTextureFromFileExW (struct IDirect3DDevice9 *device, const WCHAR *srcfile, UINT width, UINT height, UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, PALETTEENTRY *palette, struct IDirect3DTexture9 **texture)
HRESULT WINAPI	D3DXCreateCubeTextureFromFileExA (struct IDirect3DDevice9 *device, const char *srcfile, UINT size, UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, PALETTEENTRY *palette, struct IDirect3DCubeTexture9 **cube)
HRESULT WINAPI	D3DXCreateCubeTextureFromFileExW (struct IDirect3DDevice9 *device, const WCHAR *srcfile, UINT size, UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, PALETTEENTRY *palette, struct IDirect3DCubeTexture9 **cube)
HRESULT WINAPI	D3DXCreateVolumeTextureFromFileExA (struct IDirect3DDevice9 *device, const char *srcfile, UINT width, UINT height, UINT depth, UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, PALETTEENTRY *palette, struct IDirect3DVolumeTexture9 **volume)
HRESULT WINAPI	D3DXCreateVolumeTextureFromFileExW (struct IDirect3DDevice9 *device, const WCHAR *srcfile, UINT width, UINT height, UINT depth, UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, PALETTEENTRY *palette, struct IDirect3DVolumeTexture9 **volume)
HRESULT WINAPI	D3DXCreateTextureFromResourceExA (struct IDirect3DDevice9 *device, HMODULE srcmodule, const char *resource, UINT width, UINT height, UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, PALETTEENTRY *palette, struct IDirect3DTexture9 **texture)
HRESULT WINAPI	D3DXCreateTextureFromResourceExW (struct IDirect3DDevice9 *device, HMODULE srcmodule, const WCHAR *resource, UINT width, UINT height, UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, PALETTEENTRY *palette, struct IDirect3DTexture9 **texture)
HRESULT WINAPI	D3DXCreateCubeTextureFromResourceExA (struct IDirect3DDevice9 *device, HMODULE srcmodule, const char *resource, UINT size, UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, PALETTEENTRY *palette, struct IDirect3DCubeTexture9 **cube)
HRESULT WINAPI	D3DXCreateCubeTextureFromResourceExW (struct IDirect3DDevice9 *device, HMODULE srcmodule, const WCHAR *resource, UINT size, UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, PALETTEENTRY *palette, struct IDirect3DCubeTexture9 **cube)
HRESULT WINAPI	D3DXCreateVolumeTextureFromResourceExA (struct IDirect3DDevice9 *device, HMODULE srcmodule, const char *resource, UINT width, UINT height, UINT depth, UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, PALETTEENTRY *palette, struct IDirect3DVolumeTexture9 **volume)
HRESULT WINAPI	D3DXCreateVolumeTextureFromResourceExW (struct IDirect3DDevice9 *device, HMODULE srcmodule, const WCHAR *resource, UINT width, UINT height, UINT depth, UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, PALETTEENTRY *palette, struct IDirect3DVolumeTexture9 **volume)
HRESULT WINAPI	D3DXCreateTextureFromFileInMemory (struct IDirect3DDevice9 *device, const void *srcdata, UINT srcdatasize, struct IDirect3DTexture9 **texture)
HRESULT WINAPI	D3DXCreateCubeTextureFromFileInMemory (struct IDirect3DDevice9 *device, const void *srcdata, UINT srcdatasize, struct IDirect3DCubeTexture9 **cube)
HRESULT WINAPI	D3DXCreateVolumeTextureFromFileInMemory (struct IDirect3DDevice9 *device, const void *srcdata, UINT srcdatasize, struct IDirect3DVolumeTexture9 **volume)
HRESULT WINAPI	D3DXCreateTextureFromFileInMemoryEx (struct IDirect3DDevice9 *device, const void *srcdata, UINT srcdatasize, UINT width, UINT height, UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, PALETTEENTRY *palette, struct IDirect3DTexture9 **texture)
HRESULT WINAPI	D3DXCreateCubeTextureFromFileInMemoryEx (struct IDirect3DDevice9 *device, const void *srcdata, UINT srcdatasize, UINT size, UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, PALETTEENTRY *palette, struct IDirect3DCubeTexture9 **cube)
HRESULT WINAPI	D3DXCreateVolumeTextureFromFileInMemoryEx (struct IDirect3DDevice9 *device, const void *srcdata, UINT srcdatasize, UINT width, UINT height, UINT depth, UINT miplevels, DWORD usage, D3DFORMAT format, D3DPOOL pool, DWORD filter, DWORD mipfilter, D3DCOLOR colorkey, D3DXIMAGE_INFO *srcinfo, PALETTEENTRY *palette, struct IDirect3DVolumeTexture9 **volume)
HRESULT WINAPI	D3DXSaveTextureToFileInMemory (struct ID3DXBuffer **destbuffer, D3DXIMAGE_FILEFORMAT destformat, struct IDirect3DBaseTexture9 *srctexture, const PALETTEENTRY *srcpalette)
HRESULT WINAPI	D3DXSaveTextureToFileA (const char *destfile, D3DXIMAGE_FILEFORMAT destformat, struct IDirect3DBaseTexture9 *srctexture, const PALETTEENTRY *srcpalette)
HRESULT WINAPI	D3DXSaveTextureToFileW (const WCHAR *destfile, D3DXIMAGE_FILEFORMAT destformat, struct IDirect3DBaseTexture9 *srctexture, const PALETTEENTRY *srcpalette)
HRESULT WINAPI	D3DXFilterTexture (struct IDirect3DBaseTexture9 *texture, const PALETTEENTRY *palette, UINT srclevel, DWORD filter)
HRESULT WINAPI	D3DXFillTexture (struct IDirect3DTexture9 *texture, LPD3DXFILL2D function, void *data)
HRESULT WINAPI	D3DXFillCubeTexture (struct IDirect3DCubeTexture9 *cube, LPD3DXFILL3D function, void *data)
HRESULT WINAPI	D3DXFillVolumeTexture (struct IDirect3DVolumeTexture9 *volume, LPD3DXFILL3D function, void *data)
HRESULT WINAPI	D3DXFillTextureTX (struct IDirect3DTexture9 *texture, ID3DXTextureShader *texture_shader)
HRESULT WINAPI	D3DXFillCubeTextureTX (struct IDirect3DCubeTexture9 *cube, ID3DXTextureShader *texture_shader)
HRESULT WINAPI	D3DXFillVolumeTextureTX (struct IDirect3DVolumeTexture9 *volume, ID3DXTextureShader *texture_shader)
HRESULT WINAPI	D3DXComputeNormalMap (IDirect3DTexture9 *texture, IDirect3DTexture9 *srctexture, const PALETTEENTRY *srcpalette, DWORD flags, DWORD channel, float amplitude)

Macro Definition Documentation

D3DX_CHANNEL_ALPHA

#define D3DX_CHANNEL_ALPHA   0x00000008

Definition at line 56 of file d3dx9tex.h.

D3DX_CHANNEL_BLUE

#define D3DX_CHANNEL_BLUE   0x00000002

Definition at line 54 of file d3dx9tex.h.

D3DX_CHANNEL_GREEN

#define D3DX_CHANNEL_GREEN   0x00000004

Definition at line 55 of file d3dx9tex.h.

D3DX_CHANNEL_LUMINANCE

#define D3DX_CHANNEL_LUMINANCE   0x00000010

Definition at line 57 of file d3dx9tex.h.

D3DX_CHANNEL_RED

#define D3DX_CHANNEL_RED   0x00000001

Definition at line 53 of file d3dx9tex.h.

D3DX_FILTER_BOX

#define D3DX_FILTER_BOX   0x00000005

Definition at line 31 of file d3dx9tex.h.

D3DX_FILTER_DITHER

#define D3DX_FILTER_DITHER   0x00080000

Definition at line 36 of file d3dx9tex.h.

D3DX_FILTER_DITHER_DIFFUSION

#define D3DX_FILTER_DITHER_DIFFUSION   0x00100000

Definition at line 37 of file d3dx9tex.h.

D3DX_FILTER_LINEAR

#define D3DX_FILTER_LINEAR   0x00000003

Definition at line 29 of file d3dx9tex.h.

D3DX_FILTER_MIRROR

#define D3DX_FILTER_MIRROR   0x00070000

Definition at line 35 of file d3dx9tex.h.

D3DX_FILTER_MIRROR_U

#define D3DX_FILTER_MIRROR_U   0x00010000

Definition at line 32 of file d3dx9tex.h.

D3DX_FILTER_MIRROR_V

#define D3DX_FILTER_MIRROR_V   0x00020000

Definition at line 33 of file d3dx9tex.h.

D3DX_FILTER_MIRROR_W

#define D3DX_FILTER_MIRROR_W   0x00040000

Definition at line 34 of file d3dx9tex.h.

D3DX_FILTER_NONE

#define D3DX_FILTER_NONE   0x00000001

Definition at line 27 of file d3dx9tex.h.

D3DX_FILTER_POINT

#define D3DX_FILTER_POINT   0x00000002

Definition at line 28 of file d3dx9tex.h.

D3DX_FILTER_SRGB

#define D3DX_FILTER_SRGB   0x00600000

Definition at line 40 of file d3dx9tex.h.

D3DX_FILTER_SRGB_IN

#define D3DX_FILTER_SRGB_IN   0x00200000

Definition at line 38 of file d3dx9tex.h.

D3DX_FILTER_SRGB_OUT

#define D3DX_FILTER_SRGB_OUT   0x00400000

Definition at line 39 of file d3dx9tex.h.

D3DX_FILTER_TRIANGLE

#define D3DX_FILTER_TRIANGLE   0x00000004

Definition at line 30 of file d3dx9tex.h.

D3DX_NORMALMAP_COMPUTE_OCCLUSION

#define D3DX_NORMALMAP_COMPUTE_OCCLUSION   0x00100000

Definition at line 51 of file d3dx9tex.h.

D3DX_NORMALMAP_INVERTSIGN

#define D3DX_NORMALMAP_INVERTSIGN   0x00080000

Definition at line 50 of file d3dx9tex.h.

D3DX_NORMALMAP_MIRROR

#define D3DX_NORMALMAP_MIRROR   0x00030000

Definition at line 49 of file d3dx9tex.h.

D3DX_NORMALMAP_MIRROR_U

#define D3DX_NORMALMAP_MIRROR_U   0x00010000

Definition at line 47 of file d3dx9tex.h.

D3DX_NORMALMAP_MIRROR_V

#define D3DX_NORMALMAP_MIRROR_V   0x00020000

Definition at line 48 of file d3dx9tex.h.

D3DX_SKIP_DDS_MIP_LEVELS

#define D3DX_SKIP_DDS_MIP_LEVELS	(		l,
			f
	)

Value:

        ((((l) & D3DX_SKIP_DDS_MIP_LEVELS_MASK) \
        << D3DX_SKIP_DDS_MIP_LEVELS_SHIFT) | ((f) == D3DX_DEFAULT ? D3DX_FILTER_BOX : (f)))

Definition at line 44 of file d3dx9tex.h.

D3DX_SKIP_DDS_MIP_LEVELS_MASK

#define D3DX_SKIP_DDS_MIP_LEVELS_MASK   0x1f

Definition at line 42 of file d3dx9tex.h.

D3DX_SKIP_DDS_MIP_LEVELS_SHIFT

#define D3DX_SKIP_DDS_MIP_LEVELS_SHIFT   26

Definition at line 43 of file d3dx9tex.h.

D3DXCreateCubeTextureFromFile

#define D3DXCreateCubeTextureFromFile   WINELIB_NAME_AW(D3DXCreateCubeTextureFromFile)

Definition at line 216 of file d3dx9tex.h.

D3DXCreateCubeTextureFromFileEx

#define D3DXCreateCubeTextureFromFileEx   WINELIB_NAME_AW(D3DXCreateCubeTextureFromFileEx)

Definition at line 260 of file d3dx9tex.h.

D3DXCreateCubeTextureFromResource

#define D3DXCreateCubeTextureFromResource   WINELIB_NAME_AW(D3DXCreateCubeTextureFromResource)

Definition at line 234 of file d3dx9tex.h.

D3DXCreateCubeTextureFromResourceEx

#define D3DXCreateCubeTextureFromResourceEx   WINELIB_NAME_AW(D3DXCreateCubeTextureFromResourceEx)

Definition at line 290 of file d3dx9tex.h.

D3DXCreateTextureFromFile

#define D3DXCreateTextureFromFile   WINELIB_NAME_AW(D3DXCreateTextureFromFile)

Definition at line 210 of file d3dx9tex.h.

D3DXCreateTextureFromFileEx

#define D3DXCreateTextureFromFileEx   WINELIB_NAME_AW(D3DXCreateTextureFromFileEx)

Definition at line 250 of file d3dx9tex.h.

D3DXCreateTextureFromResource

#define D3DXCreateTextureFromResource   WINELIB_NAME_AW(D3DXCreateTextureFromResource)

Definition at line 228 of file d3dx9tex.h.

D3DXCreateTextureFromResourceEx

#define D3DXCreateTextureFromResourceEx   WINELIB_NAME_AW(D3DXCreateTextureFromResourceEx)

Definition at line 280 of file d3dx9tex.h.

D3DXCreateVolumeTextureFromFile

#define D3DXCreateVolumeTextureFromFile   WINELIB_NAME_AW(D3DXCreateVolumeTextureFromFile)

Definition at line 222 of file d3dx9tex.h.

D3DXCreateVolumeTextureFromFileEx

#define D3DXCreateVolumeTextureFromFileEx   WINELIB_NAME_AW(D3DXCreateVolumeTextureFromFileEx)

Definition at line 270 of file d3dx9tex.h.

D3DXCreateVolumeTextureFromResource

#define D3DXCreateVolumeTextureFromResource   WINELIB_NAME_AW(D3DXCreateVolumeTextureFromResource)

Definition at line 240 of file d3dx9tex.h.

D3DXCreateVolumeTextureFromResourceEx

#define D3DXCreateVolumeTextureFromResourceEx   WINELIB_NAME_AW(D3DXCreateVolumeTextureFromResourceEx)

Definition at line 300 of file d3dx9tex.h.

D3DXFilterCubeTexture

#define D3DXFilterCubeTexture   D3DXFilterTexture

Definition at line 333 of file d3dx9tex.h.

D3DXFilterVolumeTexture

#define D3DXFilterVolumeTexture   D3DXFilterTexture

Definition at line 334 of file d3dx9tex.h.

D3DXGetImageInfoFromFile

#define D3DXGetImageInfoFromFile   WINELIB_NAME_AW(D3DXGetImageInfoFromFile)

Definition at line 104 of file d3dx9tex.h.

D3DXGetImageInfoFromResource

#define D3DXGetImageInfoFromResource   WINELIB_NAME_AW(D3DXGetImageInfoFromResource)

Definition at line 108 of file d3dx9tex.h.

D3DXLoadSurfaceFromFile

#define D3DXLoadSurfaceFromFile   WINELIB_NAME_AW(D3DXLoadSurfaceFromFile)

Definition at line 120 of file d3dx9tex.h.

D3DXLoadSurfaceFromResource

#define D3DXLoadSurfaceFromResource   WINELIB_NAME_AW(D3DXLoadSurfaceFromResource)

Definition at line 128 of file d3dx9tex.h.

D3DXLoadVolumeFromFile

#define D3DXLoadVolumeFromFile   WINELIB_NAME_AW(D3DXLoadVolumeFromFile)

Definition at line 161 of file d3dx9tex.h.

D3DXLoadVolumeFromResource

#define D3DXLoadVolumeFromResource   WINELIB_NAME_AW(D3DXLoadVolumeFromResource)

Definition at line 169 of file d3dx9tex.h.

D3DXSaveSurfaceToFile

#define D3DXSaveSurfaceToFile   WINELIB_NAME_AW(D3DXSaveSurfaceToFile)

Definition at line 151 of file d3dx9tex.h.

D3DXSaveTextureToFile

#define D3DXSaveTextureToFile   WINELIB_NAME_AW(D3DXSaveTextureToFile)

Definition at line 328 of file d3dx9tex.h.

D3DXSaveVolumeToFile

#define D3DXSaveVolumeToFile   WINELIB_NAME_AW(D3DXSaveVolumeToFile)

Definition at line 188 of file d3dx9tex.h.

Typedef Documentation

D3DXIMAGE_FILEFORMAT

typedef enum _D3DXIMAGE_FILEFORMAT D3DXIMAGE_FILEFORMAT

D3DXIMAGE_INFO

typedef struct _D3DXIMAGE_INFO D3DXIMAGE_INFO

LPD3DXFILL2D

typedef void(WINAPI * LPD3DXFILL2D) (D3DXVECTOR4 *out, const D3DXVECTOR2 *texcoord, const D3DXVECTOR2 *texelsize, void *data)

Definition at line 91 of file d3dx9tex.h.

LPD3DXFILL3D

typedef void(WINAPI * LPD3DXFILL3D) (D3DXVECTOR4 *out, const D3DXVECTOR3 *texcoord, const D3DXVECTOR3 *texelsize, void *data)

Definition at line 93 of file d3dx9tex.h.

Enumeration Type Documentation

_D3DXIMAGE_FILEFORMAT

enum _D3DXIMAGE_FILEFORMAT

Enumerator
D3DXIFF_BMP
D3DXIFF_JPG
D3DXIFF_TGA
D3DXIFF_PNG
D3DXIFF_DDS
D3DXIFF_PPM
D3DXIFF_DIB
D3DXIFF_HDR
D3DXIFF_PFM
D3DXIFF_FORCE_DWORD

Definition at line 62 of file d3dx9tex.h.

{
    D3DXIFF_BMP,
    D3DXIFF_JPG,
    D3DXIFF_TGA,
    D3DXIFF_PNG,
    D3DXIFF_DDS,
    D3DXIFF_PPM,
    D3DXIFF_DIB,
    D3DXIFF_HDR,
    D3DXIFF_PFM,
    D3DXIFF_FORCE_DWORD = 0x7fffffff
} D3DXIMAGE_FILEFORMAT;

Function Documentation

D3DXCheckCubeTextureRequirements()

HRESULT WINAPI D3DXCheckCubeTextureRequirements	(	struct IDirect3DDevice9 *	device,
		UINT *	size,
		UINT *	miplevels,
		DWORD	usage,
		D3DFORMAT *	format,
		D3DPOOL	pool
	)

Definition at line 421 of file texture.c.

{
    D3DCAPS9 caps;
    UINT s = (size && *size) ? *size : 256;
    HRESULT hr;
 
    TRACE("(%p, %p, %p, %u, %p, %u)\n", device, size, miplevels, usage, format, pool);
 
    if (s == D3DX_DEFAULT)
        s = 256;
 
    if (!device || FAILED(IDirect3DDevice9_GetDeviceCaps(device, &caps)))
        return D3DERR_INVALIDCALL;
 
    if (!(caps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP))
        return D3DERR_NOTAVAILABLE;
 
    if ((caps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP_POW2) && (!is_pow2(s)))
        s = make_pow2(s);
 
    hr = check_texture_requirements(device, &s, &s, miplevels, usage, format, pool, D3DRTYPE_CUBETEXTURE);
 
    if (!(caps.TextureCaps & D3DPTEXTURECAPS_MIPCUBEMAP))
    {
        if(miplevels)
            *miplevels = 1;
    }
 
    if (size)
        *size = s;
 
    return hr;
}

Referenced by D3DXCreateCubeTexture(), D3DXCreateCubeTextureFromFileInMemoryEx(), and test_D3DXCheckCubeTextureRequirements().

D3DXCheckTextureRequirements()

HRESULT WINAPI D3DXCheckTextureRequirements	(	struct IDirect3DDevice9 *	device,
		UINT *	width,
		UINT *	height,
		UINT *	miplevels,
		DWORD	usage,
		D3DFORMAT *	format,
		D3DPOOL	pool
	)

Definition at line 412 of file texture.c.

{
    TRACE("device %p, width %p, height %p, miplevels %p, usage %u, format %p, pool %u.\n",
            device, width, height, miplevels, usage, format, pool);
 
    return check_texture_requirements(device, width, height, miplevels, usage, format, pool, D3DRTYPE_TEXTURE);
}

Referenced by D3DXCreateRenderToEnvMap(), D3DXCreateTexture(), D3DXCreateTextureFromFileInMemoryEx(), and test_D3DXCheckTextureRequirements().

D3DXCheckVolumeTextureRequirements()

HRESULT WINAPI D3DXCheckVolumeTextureRequirements	(	struct IDirect3DDevice9 *	device,
		UINT *	width,
		UINT *	height,
		UINT *	depth,
		UINT *	miplevels,
		DWORD	usage,
		D3DFORMAT *	format,
		D3DPOOL	pool
	)

Definition at line 456 of file texture.c.

{
    D3DCAPS9 caps;
    UINT w = width ? *width : D3DX_DEFAULT;
    UINT h = height ? *height : D3DX_DEFAULT;
    UINT d = (depth && *depth) ? *depth : 1;
    HRESULT hr;
 
    TRACE("(%p, %p, %p, %p, %p, %u, %p, %u)\n", device, width, height, depth, miplevels,
          usage, format, pool);
 
    if (!device || FAILED(IDirect3DDevice9_GetDeviceCaps(device, &caps)))
        return D3DERR_INVALIDCALL;
 
    if (!(caps.TextureCaps & D3DPTEXTURECAPS_VOLUMEMAP))
        return D3DERR_NOTAVAILABLE;
 
    hr = check_texture_requirements(device, &w, &h, NULL, usage, format, pool, D3DRTYPE_VOLUMETEXTURE);
    if (d == D3DX_DEFAULT)
        d = 1;
 
    if ((caps.TextureCaps & D3DPTEXTURECAPS_VOLUMEMAP_POW2) &&
        (!is_pow2(w) || !is_pow2(h) || !is_pow2(d)))
    {
        w = make_pow2(w);
        h = make_pow2(h);
        d = make_pow2(d);
    }
 
    if (w > caps.MaxVolumeExtent)
        w = caps.MaxVolumeExtent;
    if (h > caps.MaxVolumeExtent)
        h = caps.MaxVolumeExtent;
    if (d > caps.MaxVolumeExtent)
        d = caps.MaxVolumeExtent;
 
    if (miplevels)
    {
        if (!(caps.TextureCaps & D3DPTEXTURECAPS_MIPVOLUMEMAP))
            *miplevels = 1;
        else if ((usage & D3DUSAGE_AUTOGENMIPMAP))
        {
            if (*miplevels > 1)
                *miplevels = 0;
        }
        else
        {
            UINT max_mipmaps = 1;
            UINT max_dimen = max(max(w, h), d);
 
            while (max_dimen > 1)
            {
                max_dimen >>= 1;
                max_mipmaps++;
            }
 
            if (*miplevels == 0 || *miplevels > max_mipmaps)
                *miplevels = max_mipmaps;
        }
    }
 
    if (width)
        *width = w;
    if (height)
        *height = h;
    if (depth)
        *depth = d;
 
    return hr;
}

Referenced by D3DXCreateVolumeTexture(), D3DXCreateVolumeTextureFromFileInMemoryEx(), and test_D3DXCheckVolumeTextureRequirements().

D3DXComputeNormalMap()

HRESULT WINAPI D3DXComputeNormalMap	(	IDirect3DTexture9 *	texture,
		IDirect3DTexture9 *	srctexture,
		const PALETTEENTRY *	srcpalette,
		DWORD	flags,
		DWORD	channel,
		float	amplitude
	)

Definition at line 1927 of file texture.c.

{
    FIXME("texture %p, src_texture %p, src_palette %p, flags %#x, channel %u, amplitude %.8e stub.\n",
            texture, src_texture, src_palette, flags, channel, amplitude);
 
    return D3D_OK;
}

D3DXCreateCubeTexture()

HRESULT WINAPI D3DXCreateCubeTexture	(	struct IDirect3DDevice9 *	device,
		UINT	size,
		UINT	miplevels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool,
		struct IDirect3DCubeTexture9 **	cube
	)

Definition at line 913 of file texture.c.

{
    HRESULT hr;
 
    TRACE("(%p, %u, %u, %#x, %#x, %#x, %p)\n", device, size, miplevels, usage, format,
        pool, texture);
 
    if (!device || !texture)
        return D3DERR_INVALIDCALL;
 
    hr = D3DXCheckCubeTextureRequirements(device, &size, &miplevels, usage, &format, pool);
 
    if (FAILED(hr))
    {
        TRACE("D3DXCheckCubeTextureRequirements failed\n");
        return hr;
    }
 
    return IDirect3DDevice9_CreateCubeTexture(device, size, miplevels, usage, format, pool, texture, NULL);
}

Referenced by D3DXCreateCubeTextureFromFileInMemoryEx().

D3DXCreateCubeTextureFromFileA()

HRESULT WINAPI D3DXCreateCubeTextureFromFileA	(	struct IDirect3DDevice9 *	device,
		const char *	srcfile,
		struct IDirect3DCubeTexture9 **	cube
	)

Definition at line 1531 of file texture.c.

{
    int len;
    HRESULT hr;
    WCHAR *filename;
    void *data;
    DWORD data_size;
 
    TRACE("(%p, %s, %p): relay\n", device, wine_dbgstr_a(src_filename), cube_texture);
 
    if (!src_filename) return D3DERR_INVALIDCALL;
 
    len = MultiByteToWideChar(CP_ACP, 0, src_filename, -1, NULL, 0);
    filename = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
    if (!filename) return E_OUTOFMEMORY;
    MultiByteToWideChar(CP_ACP, 0, src_filename, -1, filename, len);
 
    hr = map_view_of_file(filename, &data, &data_size);
    if (FAILED(hr))
    {
        HeapFree(GetProcessHeap(), 0, filename);
        return D3DXERR_INVALIDDATA;
    }
 
    hr = D3DXCreateCubeTextureFromFileInMemoryEx(device, data, data_size, D3DX_DEFAULT, D3DX_DEFAULT,
        0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, cube_texture);
 
    UnmapViewOfFile(data);
    HeapFree(GetProcessHeap(), 0, filename);
    return hr;
}

D3DXCreateCubeTextureFromFileExA()

HRESULT WINAPI D3DXCreateCubeTextureFromFileExA	(	struct IDirect3DDevice9 *	device,
		const char *	srcfile,
		UINT	size,
		UINT	miplevels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool,
		DWORD	filter,
		DWORD	mipfilter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo,
		PALETTEENTRY *	palette,
		struct IDirect3DCubeTexture9 **	cube
	)

Definition at line 1585 of file texture.c.

{
    int len;
    HRESULT hr;
    WCHAR *filename;
    void *data;
    DWORD data_size;
 
    TRACE("(%p, %s, %u, %u, %#x, %#x, %#x, %#x, %#x, %#x, %p, %p, %p): relay\n",
            device, wine_dbgstr_a(src_filename), size, mip_levels, usage, format,
            pool, filter, mip_filter, color_key, image_info, palette, cube_texture);
 
    if (!src_filename) return D3DERR_INVALIDCALL;
 
    len = MultiByteToWideChar(CP_ACP, 0, src_filename, -1, NULL, 0);
    filename = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
    if (!filename) return E_OUTOFMEMORY;
    MultiByteToWideChar(CP_ACP, 0, src_filename, -1, filename, len);
 
    hr = map_view_of_file(filename, &data, &data_size);
    if (FAILED(hr))
    {
        HeapFree(GetProcessHeap(), 0, filename);
        return D3DXERR_INVALIDDATA;
    }
 
    hr = D3DXCreateCubeTextureFromFileInMemoryEx(device, data, data_size, size, mip_levels,
        usage, format, pool, filter, mip_filter, color_key, image_info, palette, cube_texture);
 
    UnmapViewOfFile(data);
    HeapFree(GetProcessHeap(), 0, filename);
    return hr;
}

D3DXCreateCubeTextureFromFileExW()

HRESULT WINAPI D3DXCreateCubeTextureFromFileExW	(	struct IDirect3DDevice9 *	device,
		const WCHAR *	srcfile,
		UINT	size,
		UINT	miplevels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool,
		DWORD	filter,
		DWORD	mipfilter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo,
		PALETTEENTRY *	palette,
		struct IDirect3DCubeTexture9 **	cube
	)

Definition at line 1631 of file texture.c.

{
    HRESULT hr;
    void *data;
    DWORD data_size;
 
    TRACE("(%p, %s, %u, %u, %#x, %#x, %#x, %#x, %#x, %#x, %p, %p, %p): relay\n",
            device, wine_dbgstr_w(src_filename), size, mip_levels, usage, format,
            pool, filter, mip_filter, color_key, image_info, palette, cube_texture);
 
    hr = map_view_of_file(src_filename, &data, &data_size);
    if (FAILED(hr)) return D3DXERR_INVALIDDATA;
 
    hr = D3DXCreateCubeTextureFromFileInMemoryEx(device, data, data_size, size, mip_levels,
        usage, format, pool, filter, mip_filter, color_key, image_info, palette, cube_texture);
 
    UnmapViewOfFile(data);
    return hr;
}

D3DXCreateCubeTextureFromFileInMemory()

HRESULT WINAPI D3DXCreateCubeTextureFromFileInMemory	(	struct IDirect3DDevice9 *	device,
		const void *	srcdata,
		UINT	srcdatasize,
		struct IDirect3DCubeTexture9 **	cube
	)

Definition at line 935 of file texture.c.

{
    TRACE("(%p, %p, %u, %p)\n", device, data, datasize, texture);
 
    return D3DXCreateCubeTextureFromFileInMemoryEx(device, data, datasize, D3DX_DEFAULT, D3DX_DEFAULT,
        0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, texture);
}

Referenced by test_D3DXCreateCubeTextureFromFileInMemory().

D3DXCreateCubeTextureFromFileInMemoryEx()

HRESULT WINAPI D3DXCreateCubeTextureFromFileInMemoryEx	(	struct IDirect3DDevice9 *	device,
		const void *	srcdata,
		UINT	srcdatasize,
		UINT	size,
		UINT	miplevels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool,
		DWORD	filter,
		DWORD	mipfilter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo,
		PALETTEENTRY *	palette,
		struct IDirect3DCubeTexture9 **	cube
	)

Definition at line 1400 of file texture.c.

{
    HRESULT hr;
    D3DCAPS9 caps;
    UINT loaded_miplevels;
    D3DXIMAGE_INFO img_info;
    BOOL dynamic_texture;
    BOOL file_size = FALSE;
    BOOL file_format = FALSE;
    BOOL file_mip_levels = FALSE;
    IDirect3DCubeTexture9 *tex, *buftex;
 
    TRACE("(%p, %p, %u, %u, %u, %#x, %#x, %#x, %#x, %#x, %#x, %p, %p, %p)\n", device,
        src_data, src_data_size, size, mip_levels, usage, format, pool, filter, mip_filter,
        color_key, src_info, palette, cube_texture);
 
    if (!device || !cube_texture || !src_data || !src_data_size)
        return D3DERR_INVALIDCALL;
 
    hr = D3DXGetImageInfoFromFileInMemory(src_data, src_data_size, &img_info);
    if (FAILED(hr))
        return hr;
 
    if (img_info.ImageFileFormat != D3DXIFF_DDS)
        return D3DXERR_INVALIDDATA;
 
    if (img_info.Width != img_info.Height)
        return D3DXERR_INVALIDDATA;
 
    if (size == 0 || size == D3DX_DEFAULT_NONPOW2)
        size = img_info.Width;
    if (size == D3DX_DEFAULT)
        size = make_pow2(img_info.Width);
 
    if (format == D3DFMT_UNKNOWN || format == D3DX_DEFAULT)
        format = img_info.Format;
 
    if (size == D3DX_FROM_FILE)
    {
        file_size = TRUE;
        size = img_info.Width;
    }
 
    if (format == D3DFMT_FROM_FILE)
    {
        file_format = TRUE;
        format = img_info.Format;
    }
 
    if (mip_levels == D3DX_FROM_FILE)
    {
        file_mip_levels = TRUE;
        mip_levels = img_info.MipLevels;
    }
 
    hr = D3DXCheckCubeTextureRequirements(device, &size, &mip_levels, usage, &format, pool);
    if (FAILED(hr))
        return hr;
 
    if ((file_size && size != img_info.Width)
            || (file_format && format != img_info.Format)
            || (file_mip_levels && mip_levels != img_info.MipLevels))
        return D3DERR_NOTAVAILABLE;
 
    hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
    if (FAILED(hr))
        return D3DERR_INVALIDCALL;
 
    dynamic_texture = (caps.Caps2 & D3DCAPS2_DYNAMICTEXTURES) && (usage & D3DUSAGE_DYNAMIC);
    if (pool == D3DPOOL_DEFAULT && !dynamic_texture)
    {
        hr = D3DXCreateCubeTexture(device, size, mip_levels, 0, format, D3DPOOL_SYSTEMMEM, &buftex);
        tex = buftex;
    }
    else
    {
        hr = D3DXCreateCubeTexture(device, size, mip_levels, usage, format, pool, &tex);
        buftex = NULL;
    }
    if (FAILED(hr))
        return hr;
 
    hr = load_cube_texture_from_dds(tex, src_data, palette, filter, color_key, &img_info);
    if (FAILED(hr))
    {
        IDirect3DCubeTexture9_Release(tex);
        return hr;
    }
 
    loaded_miplevels = min(IDirect3DCubeTexture9_GetLevelCount(tex), img_info.MipLevels);
    hr = D3DXFilterTexture((IDirect3DBaseTexture9*) tex, palette, loaded_miplevels - 1, mip_filter);
    if (FAILED(hr))
    {
        IDirect3DCubeTexture9_Release(tex);
        return hr;
    }
 
    if (buftex)
    {
        hr = D3DXCreateCubeTexture(device, size, mip_levels, usage, format, pool, &tex);
        if (FAILED(hr))
        {
            IDirect3DCubeTexture9_Release(buftex);
            return hr;
        }
 
        IDirect3DDevice9_UpdateTexture(device, (IDirect3DBaseTexture9 *)buftex, (IDirect3DBaseTexture9 *)tex);
        IDirect3DCubeTexture9_Release(buftex);
    }
 
    if (src_info)
        *src_info = img_info;
 
    *cube_texture = tex;
    return D3D_OK;
}

Referenced by D3DXCreateCubeTextureFromFileA(), D3DXCreateCubeTextureFromFileExA(), D3DXCreateCubeTextureFromFileExW(), D3DXCreateCubeTextureFromFileInMemory(), D3DXCreateCubeTextureFromFileW(), and test_D3DXCreateCubeTextureFromFileInMemoryEx().

D3DXCreateCubeTextureFromFileW()

HRESULT WINAPI D3DXCreateCubeTextureFromFileW	(	struct IDirect3DDevice9 *	device,
		const WCHAR *	srcfile,
		struct IDirect3DCubeTexture9 **	cube
	)

Definition at line 1565 of file texture.c.

{
    HRESULT hr;
    void *data;
    DWORD data_size;
 
    TRACE("(%p, %s, %p): relay\n", device, wine_dbgstr_w(src_filename), cube_texture);
 
    hr = map_view_of_file(src_filename, &data, &data_size);
    if (FAILED(hr)) return D3DXERR_INVALIDDATA;
 
    hr = D3DXCreateCubeTextureFromFileInMemoryEx(device, data, data_size, D3DX_DEFAULT, D3DX_DEFAULT,
        0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, cube_texture);
 
    UnmapViewOfFile(data);
    return hr;
}

D3DXCreateCubeTextureFromResourceA()

HRESULT WINAPI D3DXCreateCubeTextureFromResourceA	(	struct IDirect3DDevice9 *	device,
		HMODULE	srcmodule,
		const char *	resource,
		struct IDirect3DCubeTexture9 **	cube
	)

D3DXCreateCubeTextureFromResourceExA()

HRESULT WINAPI D3DXCreateCubeTextureFromResourceExA	(	struct IDirect3DDevice9 *	device,
		HMODULE	srcmodule,
		const char *	resource,
		UINT	size,
		UINT	miplevels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool,
		DWORD	filter,
		DWORD	mipfilter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo,
		PALETTEENTRY *	palette,
		struct IDirect3DCubeTexture9 **	cube
	)

D3DXCreateCubeTextureFromResourceExW()

HRESULT WINAPI D3DXCreateCubeTextureFromResourceExW	(	struct IDirect3DDevice9 *	device,
		HMODULE	srcmodule,
		const WCHAR *	resource,
		UINT	size,
		UINT	miplevels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool,
		DWORD	filter,
		DWORD	mipfilter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo,
		PALETTEENTRY *	palette,
		struct IDirect3DCubeTexture9 **	cube
	)

D3DXCreateCubeTextureFromResourceW()

HRESULT WINAPI D3DXCreateCubeTextureFromResourceW	(	struct IDirect3DDevice9 *	device,
		HMODULE	srcmodule,
		const WCHAR *	resource,
		struct IDirect3DCubeTexture9 **	cube
	)

D3DXCreateTexture()

HRESULT WINAPI D3DXCreateTexture	(	struct IDirect3DDevice9 *	device,
		UINT	width,
		UINT	height,
		UINT	miplevels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool,
		struct IDirect3DTexture9 **	texture
	)

Definition at line 528 of file texture.c.

{
    HRESULT hr;
 
    TRACE("device %p, width %u, height %u, miplevels %u, usage %#x, format %#x, pool %#x, texture %p.\n",
            device, width, height, miplevels, usage, format, pool, texture);
 
    if (!device || !texture)
        return D3DERR_INVALIDCALL;
 
    if (FAILED(hr = D3DXCheckTextureRequirements(device, &width, &height, &miplevels, usage, &format, pool)))
        return hr;
 
    return IDirect3DDevice9_CreateTexture(device, width, height, miplevels, usage, format, pool, texture, NULL);
}

Referenced by D3DXCreateTextureFromFileInMemoryEx(), test_D3DXCreateTexture(), test_effect_parameter_block(), and test_effect_setvalue_object().

D3DXCreateTextureFromFileA()

HRESULT WINAPI D3DXCreateTextureFromFileA	(	struct IDirect3DDevice9 *	device,
		const char *	srcfile,
		struct IDirect3DTexture9 **	texture
	)

Definition at line 818 of file texture.c.

{
    TRACE("(%p, %s, %p)\n", device, debugstr_a(srcfile), texture);
 
    return D3DXCreateTextureFromFileExA(device, srcfile, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0, D3DFMT_UNKNOWN,
                                        D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, texture);
}

D3DXCreateTextureFromFileExA()

HRESULT WINAPI D3DXCreateTextureFromFileExA	(	struct IDirect3DDevice9 *	device,
		const char *	srcfile,
		UINT	width,
		UINT	height,
		UINT	miplevels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool,
		DWORD	filter,
		DWORD	mipfilter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo,
		PALETTEENTRY *	palette,
		struct IDirect3DTexture9 **	texture
	)

Definition at line 789 of file texture.c.

{
    WCHAR *widename;
    HRESULT hr;
    DWORD len;
 
    TRACE("device %p, srcfile %s, width %u, height %u, miplevels %u, usage %#x, format %#x, "
            "pool %#x, filter %#x, mipfilter %#x, colorkey 0x%08x, srcinfo %p, palette %p, texture %p.\n",
            device, debugstr_a(srcfile), width, height, miplevels, usage, format,
            pool, filter, mipfilter, colorkey, srcinfo, palette, texture);
 
    if (!device || !srcfile || !texture)
        return D3DERR_INVALIDCALL;
 
    len = MultiByteToWideChar(CP_ACP, 0, srcfile, -1, NULL, 0);
    widename = HeapAlloc(GetProcessHeap(), 0, len * sizeof(*widename));
    MultiByteToWideChar(CP_ACP, 0, srcfile, -1, widename, len);
 
    hr = D3DXCreateTextureFromFileExW(device, widename, width, height, miplevels,
                                      usage, format, pool, filter, mipfilter,
                                      colorkey, srcinfo, palette, texture);
 
    HeapFree(GetProcessHeap(), 0, widename);
    return hr;
}

Referenced by D3DXCreateTextureFromFileA().

D3DXCreateTextureFromFileExW()

HRESULT WINAPI D3DXCreateTextureFromFileExW	(	struct IDirect3DDevice9 *	device,
		const WCHAR *	srcfile,
		UINT	width,
		UINT	height,
		UINT	miplevels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool,
		DWORD	filter,
		DWORD	mipfilter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo,
		PALETTEENTRY *	palette,
		struct IDirect3DTexture9 **	texture
	)

Definition at line 757 of file texture.c.

{
    void *buffer;
    HRESULT hr;
    DWORD size;
 
    TRACE("device %p, srcfile %s, width %u, height %u, miplevels %u, usage %#x, format %#x, "
            "pool %#x, filter %#x, mipfilter %#x, colorkey 0x%08x, srcinfo %p, palette %p, texture %p.\n",
            device, debugstr_w(srcfile), width, height, miplevels, usage, format,
            pool, filter, mipfilter, colorkey, srcinfo, palette, texture);
 
    if (!srcfile)
        return D3DERR_INVALIDCALL;
 
    hr = map_view_of_file(srcfile, &buffer, &size);
    if (FAILED(hr))
    {
        WARN("Failed to open file.\n");
        return D3DXERR_INVALIDDATA;
    }
 
    hr = D3DXCreateTextureFromFileInMemoryEx(device, buffer, size, width, height, miplevels, usage, format, pool,
        filter, mipfilter, colorkey, srcinfo, palette, texture);
 
    UnmapViewOfFile(buffer);
 
    return hr;
}

Referenced by D3DXCreateTextureFromFileExA(), and D3DXCreateTextureFromFileW().

D3DXCreateTextureFromFileInMemory()

HRESULT WINAPI D3DXCreateTextureFromFileInMemory	(	struct IDirect3DDevice9 *	device,
		const void *	srcdata,
		UINT	srcdatasize,
		struct IDirect3DTexture9 **	texture
	)

Definition at line 748 of file texture.c.

{
    TRACE("(%p, %p, %d, %p)\n", device, srcdata, srcdatasize, texture);
 
    return D3DXCreateTextureFromFileInMemoryEx(device, srcdata, srcdatasize, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0, D3DFMT_UNKNOWN,
                                               D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, texture);
}

Referenced by test_D3DXCreateTextureFromFileInMemory().

D3DXCreateTextureFromFileInMemoryEx()

HRESULT WINAPI D3DXCreateTextureFromFileInMemoryEx	(	struct IDirect3DDevice9 *	device,
		const void *	srcdata,
		UINT	srcdatasize,
		UINT	width,
		UINT	height,
		UINT	miplevels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool,
		DWORD	filter,
		DWORD	mipfilter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo,
		PALETTEENTRY *	palette,
		struct IDirect3DTexture9 **	texture
	)

Definition at line 568 of file texture.c.

{
    BOOL dynamic_texture, format_specified = FALSE;
    unsigned int loaded_miplevels, skip_levels;
    IDirect3DSurface9 *surface;
    IDirect3DTexture9 **texptr;
    IDirect3DTexture9 *buftex;
    D3DXIMAGE_INFO imginfo;
    D3DCAPS9 caps;
    HRESULT hr;
 
    TRACE("device %p, srcdata %p, srcdatasize %u, width %u, height %u, miplevels %u,"
            " usage %#x, format %#x, pool %#x, filter %#x, mipfilter %#x, colorkey %#x,"
            " srcinfo %p, palette %p, texture %p.\n",
            device, srcdata, srcdatasize, width, height, miplevels, usage, format, pool,
            filter, mipfilter, colorkey, srcinfo, palette, texture);
 
    /* check for invalid parameters */
    if (!device || !texture || !srcdata || !srcdatasize)
        return D3DERR_INVALIDCALL;
 
    hr = D3DXGetImageInfoFromFileInMemory(srcdata, srcdatasize, &imginfo);
    if (FAILED(hr))
    {
        FIXME("Unrecognized file format, returning failure.\n");
        *texture = NULL;
        return hr;
    }
 
    /* handle default values */
    if (width == 0 || width == D3DX_DEFAULT_NONPOW2)
        width = imginfo.Width;
 
    if (height == 0 || height == D3DX_DEFAULT_NONPOW2)
        height = imginfo.Height;
 
    if (width == D3DX_DEFAULT)
        width = make_pow2(imginfo.Width);
 
    if (height == D3DX_DEFAULT)
        height = make_pow2(imginfo.Height);
 
    if (format == D3DFMT_UNKNOWN || format == D3DX_DEFAULT)
        format = imginfo.Format;
    else
        format_specified = TRUE;
 
    if (width == D3DX_FROM_FILE)
    {
        width = imginfo.Width;
    }
 
    if (height == D3DX_FROM_FILE)
    {
        height = imginfo.Height;
    }
 
    if (format == D3DFMT_FROM_FILE)
    {
        format = imginfo.Format;
    }
 
    if (miplevels == D3DX_FROM_FILE)
    {
        miplevels = imginfo.MipLevels;
    }
 
    skip_levels = mipfilter != D3DX_DEFAULT ? mipfilter >> D3DX_SKIP_DDS_MIP_LEVELS_SHIFT : 0;
    if (skip_levels && imginfo.MipLevels > skip_levels)
    {
        TRACE("Skipping the first %u (of %u) levels of a DDS mipmapped texture.\n",
                skip_levels, imginfo.MipLevels);
        TRACE("Texture level 0 dimensions are %ux%u.\n", imginfo.Width, imginfo.Height);
        width >>= skip_levels;
        height >>= skip_levels;
        miplevels -= skip_levels;
    }
    else
    {
        skip_levels = 0;
    }
 
    /* Fix up texture creation parameters. */
    hr = D3DXCheckTextureRequirements(device, &width, &height, &miplevels, usage, &format, pool);
    if (FAILED(hr))
    {
        FIXME("Couldn't find suitable texture parameters.\n");
        *texture = NULL;
        return hr;
    }
 
    if (colorkey && !format_specified)
        format = get_alpha_replacement_format(format);
 
    if (imginfo.ResourceType == D3DRTYPE_VOLUMETEXTURE
            && D3DFMT_DXT1 <= imginfo.Format && imginfo.Format <= D3DFMT_DXT5 && miplevels > 1)
    {
        FIXME("Generation of mipmaps for compressed volume textures is not implemented yet.\n");
        miplevels = 1;
    }
 
    if (FAILED(IDirect3DDevice9_GetDeviceCaps(device, &caps)))
        return D3DERR_INVALIDCALL;
 
    /* Create the to-be-filled texture */
    dynamic_texture = (caps.Caps2 & D3DCAPS2_DYNAMICTEXTURES) && (usage & D3DUSAGE_DYNAMIC);
    if (pool == D3DPOOL_DEFAULT && !dynamic_texture)
    {
        hr = D3DXCreateTexture(device, width, height, miplevels, 0, format, D3DPOOL_SYSTEMMEM, &buftex);
        texptr = &buftex;
    }
    else
    {
        hr = D3DXCreateTexture(device, width, height, miplevels, usage, format, pool, texture);
        texptr = texture;
    }
 
    if (FAILED(hr))
    {
        FIXME("Texture creation failed.\n");
        *texture = NULL;
        return hr;
    }
 
    TRACE("Texture created correctly. Now loading the texture data into it.\n");
    if (imginfo.ImageFileFormat != D3DXIFF_DDS)
    {
        IDirect3DTexture9_GetSurfaceLevel(*texptr, 0, &surface);
        hr = D3DXLoadSurfaceFromFileInMemory(surface, palette, NULL, srcdata, srcdatasize, NULL, filter, colorkey, NULL);
        IDirect3DSurface9_Release(surface);
        loaded_miplevels = min(IDirect3DTexture9_GetLevelCount(*texptr), imginfo.MipLevels);
    }
    else
    {
        hr = load_texture_from_dds(*texptr, srcdata, palette, filter, colorkey, &imginfo, skip_levels,
                &loaded_miplevels);
    }
 
    if (FAILED(hr))
    {
        FIXME("Texture loading failed.\n");
        IDirect3DTexture9_Release(*texptr);
        *texture = NULL;
        return hr;
    }
 
    hr = D3DXFilterTexture((IDirect3DBaseTexture9*) *texptr, palette, loaded_miplevels - 1, mipfilter);
    if (FAILED(hr))
    {
        FIXME("Texture filtering failed.\n");
        IDirect3DTexture9_Release(*texptr);
        *texture = NULL;
        return hr;
    }
 
    /* Move the data to the actual texture if necessary */
    if (texptr == &buftex)
    {
        hr = D3DXCreateTexture(device, width, height, miplevels, usage, format, pool, texture);
 
        if (FAILED(hr))
        {
            IDirect3DTexture9_Release(buftex);
            *texture = NULL;
            return hr;
        }
 
        IDirect3DDevice9_UpdateTexture(device, (IDirect3DBaseTexture9*)buftex, (IDirect3DBaseTexture9*)(*texture));
        IDirect3DTexture9_Release(buftex);
    }
 
    if (srcinfo)
        *srcinfo = imginfo;
 
    return D3D_OK;
}

Referenced by D3DXCreateTextureFromFileExW(), D3DXCreateTextureFromFileInMemory(), D3DXCreateTextureFromResourceExA(), D3DXCreateTextureFromResourceExW(), and test_D3DXCreateTextureFromFileInMemoryEx().

D3DXCreateTextureFromFileW()

HRESULT WINAPI D3DXCreateTextureFromFileW	(	struct IDirect3DDevice9 *	device,
		const WCHAR *	srcfile,
		struct IDirect3DTexture9 **	texture
	)

Definition at line 827 of file texture.c.

{
    TRACE("(%p, %s, %p)\n", device, debugstr_w(srcfile), texture);
 
    return D3DXCreateTextureFromFileExW(device, srcfile, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0, D3DFMT_UNKNOWN,
                                        D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, texture);
}

D3DXCreateTextureFromResourceA()

HRESULT WINAPI D3DXCreateTextureFromResourceA	(	struct IDirect3DDevice9 *	device,
		HMODULE	srcmodule,
		const char *	resource,
		struct IDirect3DTexture9 **	texture
	)

Definition at line 837 of file texture.c.

{
    TRACE("(%p, %s): relay\n", srcmodule, debugstr_a(resource));
 
    return D3DXCreateTextureFromResourceExA(device, srcmodule, resource, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0, D3DFMT_UNKNOWN,
                                            D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, texture);
}

Referenced by test_D3DXCreateTexture().

D3DXCreateTextureFromResourceExA()

HRESULT WINAPI D3DXCreateTextureFromResourceExA	(	struct IDirect3DDevice9 *	device,
		HMODULE	srcmodule,
		const char *	resource,
		UINT	width,
		UINT	height,
		UINT	miplevels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool,
		DWORD	filter,
		DWORD	mipfilter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo,
		PALETTEENTRY *	palette,
		struct IDirect3DTexture9 **	texture
	)

Definition at line 855 of file texture.c.

{
    HRSRC resinfo;
    void *buffer;
    DWORD size;
 
    TRACE("device %p, srcmodule %p, resource %s, width %u, height %u, miplevels %u, usage %#x, format %#x, "
            "pool %#x, filter %#x, mipfilter %#x, colorkey 0x%08x, srcinfo %p, palette %p, texture %p.\n",
            device, srcmodule, debugstr_a(resource), width, height, miplevels, usage, format,
            pool, filter, mipfilter, colorkey, srcinfo, palette, texture);
 
    if (!device || !texture)
        return D3DERR_INVALIDCALL;
 
    if (!(resinfo = FindResourceA(srcmodule, resource, (const char *)RT_RCDATA))
            /* Try loading the resource as bitmap data (which is in DIB format D3DXIFF_DIB) */
            && !(resinfo = FindResourceA(srcmodule, resource, (const char *)RT_BITMAP)))
        return D3DXERR_INVALIDDATA;
 
    if (FAILED(load_resource_into_memory(srcmodule, resinfo, &buffer, &size)))
        return D3DXERR_INVALIDDATA;
 
    return D3DXCreateTextureFromFileInMemoryEx(device, buffer, size, width, height, miplevels,
            usage, format, pool, filter, mipfilter, colorkey, srcinfo, palette, texture);
}

Referenced by D3DXCreateTextureFromResourceA(), and test_D3DXCreateTexture().

D3DXCreateTextureFromResourceExW()

HRESULT WINAPI D3DXCreateTextureFromResourceExW	(	struct IDirect3DDevice9 *	device,
		HMODULE	srcmodule,
		const WCHAR *	resource,
		UINT	width,
		UINT	height,
		UINT	miplevels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool,
		DWORD	filter,
		DWORD	mipfilter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo,
		PALETTEENTRY *	palette,
		struct IDirect3DTexture9 **	texture
	)

Definition at line 884 of file texture.c.

{
    HRSRC resinfo;
    void *buffer;
    DWORD size;
 
    TRACE("device %p, srcmodule %p, resource %s, width %u, height %u, miplevels %u, usage %#x, format %#x, "
            "pool %#x, filter %#x, mipfilter %#x, colorkey 0x%08x, srcinfo %p, palette %p, texture %p.\n",
            device, srcmodule, debugstr_w(resource), width, height, miplevels, usage, format,
            pool, filter, mipfilter, colorkey, srcinfo, palette, texture);
 
    if (!device || !texture)
        return D3DERR_INVALIDCALL;
 
    if (!(resinfo = FindResourceW(srcmodule, resource, (const WCHAR *)RT_RCDATA))
            /* Try loading the resource as bitmap data (which is in DIB format D3DXIFF_DIB) */
            && !(resinfo = FindResourceW(srcmodule, resource, (const WCHAR *)RT_BITMAP)))
        return D3DXERR_INVALIDDATA;
 
    if (FAILED(load_resource_into_memory(srcmodule, resinfo, &buffer, &size)))
        return D3DXERR_INVALIDDATA;
 
    return D3DXCreateTextureFromFileInMemoryEx(device, buffer, size, width, height, miplevels,
            usage, format, pool, filter, mipfilter, colorkey, srcinfo, palette, texture);
}

Referenced by D3DXCreateTextureFromResourceW().

D3DXCreateTextureFromResourceW()

HRESULT WINAPI D3DXCreateTextureFromResourceW	(	struct IDirect3DDevice9 *	device,
		HMODULE	srcmodule,
		const WCHAR *	resource,
		struct IDirect3DTexture9 **	texture
	)

Definition at line 846 of file texture.c.

{
    TRACE("(%p, %s): relay\n", srcmodule, debugstr_w(resource));
 
    return D3DXCreateTextureFromResourceExW(device, srcmodule, resource, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0, D3DFMT_UNKNOWN,
                                            D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, texture);
}

D3DXCreateVolumeTexture()

HRESULT WINAPI D3DXCreateVolumeTexture	(	struct IDirect3DDevice9 *	device,
		UINT	width,
		UINT	height,
		UINT	depth,
		UINT	miplevels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool,
		struct IDirect3DVolumeTexture9 **	volume
	)

Definition at line 944 of file texture.c.

{
    HRESULT hr;
 
    TRACE("(%p, %u, %u, %u, %u, %#x, %#x, %#x, %p)\n", device, width, height, depth,
          miplevels, usage, format, pool, texture);
 
    if (!device || !texture)
        return D3DERR_INVALIDCALL;
 
    hr = D3DXCheckVolumeTextureRequirements(device, &width, &height, &depth,
                                            &miplevels, usage, &format, pool);
 
    if (FAILED(hr))
    {
        TRACE("D3DXCheckVolumeTextureRequirements failed\n");
        return hr;
    }
 
    return IDirect3DDevice9_CreateVolumeTexture(device, width, height, depth, miplevels,
                                                usage, format, pool, texture, NULL);
}

Referenced by D3DXCreateVolumeTextureFromFileInMemoryEx().

D3DXCreateVolumeTextureFromFileA()

HRESULT WINAPI D3DXCreateVolumeTextureFromFileA	(	struct IDirect3DDevice9 *	device,
		const char *	srcfile,
		struct IDirect3DVolumeTexture9 **	volume
	)

Definition at line 968 of file texture.c.

{
    int len;
    HRESULT hr;
    void *data;
    DWORD data_size;
    WCHAR *filenameW;
 
    TRACE("(%p, %s, %p): relay\n",
            device, debugstr_a(filename), volume_texture);
 
    if (!filename) return D3DERR_INVALIDCALL;
 
    len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
    filenameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
    if (!filenameW) return E_OUTOFMEMORY;
    MultiByteToWideChar(CP_ACP, 0, filename, -1, filenameW, len);
 
    hr = map_view_of_file(filenameW, &data, &data_size);
    HeapFree(GetProcessHeap(), 0, filenameW);
    if (FAILED(hr)) return D3DXERR_INVALIDDATA;
 
    hr = D3DXCreateVolumeTextureFromFileInMemoryEx(device, data, data_size, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT,
            D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, volume_texture);
 
    UnmapViewOfFile(data);
    return hr;
}

D3DXCreateVolumeTextureFromFileExA()

HRESULT WINAPI D3DXCreateVolumeTextureFromFileExA	(	struct IDirect3DDevice9 *	device,
		const char *	srcfile,
		UINT	width,
		UINT	height,
		UINT	depth,
		UINT	miplevels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool,
		DWORD	filter,
		DWORD	mipfilter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo,
		PALETTEENTRY *	palette,
		struct IDirect3DVolumeTexture9 **	volume
	)

Definition at line 1022 of file texture.c.

{
    int len;
    HRESULT hr;
    WCHAR *filenameW;
    void *data;
    DWORD data_size;
 
    TRACE("(%p, %s, %u, %u, %u, %u, %#x, %#x, %#x, %#x, %#x, %#x, %p, %p, %p): relay\n",
            device, debugstr_a(filename), width, height, depth, mip_levels,
            usage, format, pool, filter, mip_filter, color_key, src_info,
            palette, volume_texture);
 
    if (!filename) return D3DERR_INVALIDCALL;
 
    len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
    filenameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
    if (!filenameW) return E_OUTOFMEMORY;
    MultiByteToWideChar(CP_ACP, 0, filename, -1, filenameW, len);
 
    hr = map_view_of_file(filenameW, &data, &data_size);
    HeapFree(GetProcessHeap(), 0, filenameW);
    if (FAILED(hr)) return D3DXERR_INVALIDDATA;
 
    hr = D3DXCreateVolumeTextureFromFileInMemoryEx(device, data, data_size, width, height, depth,
            mip_levels, usage, format, pool, filter, mip_filter, color_key, src_info, palette,
            volume_texture);
 
    UnmapViewOfFile(data);
    return hr;
}

D3DXCreateVolumeTextureFromFileExW()

HRESULT WINAPI D3DXCreateVolumeTextureFromFileExW	(	struct IDirect3DDevice9 *	device,
		const WCHAR *	srcfile,
		UINT	width,
		UINT	height,
		UINT	depth,
		UINT	miplevels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool,
		DWORD	filter,
		DWORD	mipfilter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo,
		PALETTEENTRY *	palette,
		struct IDirect3DVolumeTexture9 **	volume
	)

Definition at line 1068 of file texture.c.

{
    HRESULT hr;
    void *data;
    DWORD data_size;
 
    TRACE("(%p, %s, %u, %u, %u, %u, %#x, %#x, %#x, %#x, %#x, %#x, %p, %p, %p): relay\n",
            device, debugstr_w(filename), width, height, depth, mip_levels,
            usage, format, pool, filter, mip_filter, color_key, src_info,
            palette, volume_texture);
 
    if (!filename) return D3DERR_INVALIDCALL;
 
    hr = map_view_of_file(filename, &data, &data_size);
    if (FAILED(hr)) return D3DXERR_INVALIDDATA;
 
    hr = D3DXCreateVolumeTextureFromFileInMemoryEx(device, data, data_size, width, height, depth,
            mip_levels, usage, format, pool, filter, mip_filter, color_key, src_info, palette,
            volume_texture);
 
    UnmapViewOfFile(data);
    return hr;
}

D3DXCreateVolumeTextureFromFileInMemory()

HRESULT WINAPI D3DXCreateVolumeTextureFromFileInMemory	(	struct IDirect3DDevice9 *	device,
		const void *	srcdata,
		UINT	srcdatasize,
		struct IDirect3DVolumeTexture9 **	volume
	)

Definition at line 1106 of file texture.c.

{
    TRACE("(%p, %p, %u, %p): relay\n", device, data, data_size, volume_texture);
 
    return D3DXCreateVolumeTextureFromFileInMemoryEx(device, data, data_size, D3DX_DEFAULT, D3DX_DEFAULT,
        D3DX_DEFAULT, D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT,
        0, NULL, NULL, volume_texture);
}

Referenced by test_D3DXCreateVolumeTextureFromFileInMemory().

D3DXCreateVolumeTextureFromFileInMemoryEx()

HRESULT WINAPI D3DXCreateVolumeTextureFromFileInMemoryEx	(	struct IDirect3DDevice9 *	device,
		const void *	srcdata,
		UINT	srcdatasize,
		UINT	width,
		UINT	height,
		UINT	depth,
		UINT	miplevels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool,
		DWORD	filter,
		DWORD	mipfilter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo,
		PALETTEENTRY *	palette,
		struct IDirect3DVolumeTexture9 **	volume
	)

Definition at line 1118 of file texture.c.

{
    HRESULT hr;
    D3DCAPS9 caps;
    D3DXIMAGE_INFO image_info;
    BOOL dynamic_texture;
    BOOL file_width = FALSE;
    BOOL file_height = FALSE;
    BOOL file_depth = FALSE;
    BOOL file_format = FALSE;
    BOOL file_mip_levels = FALSE;
    IDirect3DVolumeTexture9 *tex, *buftex;
 
    TRACE("(%p, %p, %u, %u, %u, %u, %u, %#x, %#x, %#x, %#x, %#x, %#x, %p, %p, %p)\n",
            device, data, data_size, width, height, depth, mip_levels, usage, format, pool,
            filter, mip_filter, color_key, info, palette, volume_texture);
 
    if (!device || !data || !data_size || !volume_texture)
        return D3DERR_INVALIDCALL;
 
    hr = D3DXGetImageInfoFromFileInMemory(data, data_size, &image_info);
    if (FAILED(hr)) return hr;
 
    if (image_info.ImageFileFormat != D3DXIFF_DDS)
        return D3DXERR_INVALIDDATA;
 
    if (width == 0 || width == D3DX_DEFAULT_NONPOW2)
        width = image_info.Width;
    if (width == D3DX_DEFAULT)
        width = make_pow2(image_info.Width);
 
    if (height == 0 || height == D3DX_DEFAULT_NONPOW2)
        height = image_info.Height;
    if (height == D3DX_DEFAULT)
        height = make_pow2(image_info.Height);
 
    if (depth == 0 || depth == D3DX_DEFAULT_NONPOW2)
        depth = image_info.Depth;
    if (depth == D3DX_DEFAULT)
        depth = make_pow2(image_info.Depth);
 
    if (format == D3DFMT_UNKNOWN || format == D3DX_DEFAULT)
        format = image_info.Format;
 
    if (width == D3DX_FROM_FILE)
    {
        file_width = TRUE;
        width = image_info.Width;
    }
 
    if (height == D3DX_FROM_FILE)
    {
        file_height = TRUE;
        height = image_info.Height;
    }
 
    if (depth == D3DX_FROM_FILE)
    {
        file_depth = TRUE;
        depth = image_info.Depth;
    }
 
    if (format == D3DFMT_FROM_FILE)
    {
        file_format = TRUE;
        format = image_info.Format;
    }
 
    if (mip_levels == D3DX_FROM_FILE)
    {
        file_mip_levels = TRUE;
        mip_levels = image_info.MipLevels;
    }
 
    hr = D3DXCheckVolumeTextureRequirements(device, &width, &height, &depth, &mip_levels, usage, &format, pool);
    if (FAILED(hr)) return hr;
 
    if ((file_width && width != image_info.Width)
            || (file_height && height != image_info.Height)
            || (file_depth && depth != image_info.Depth)
            || (file_format && format != image_info.Format)
            || (file_mip_levels && mip_levels != image_info.MipLevels))
        return D3DERR_NOTAVAILABLE;
 
    hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
    if (FAILED(hr))
        return D3DERR_INVALIDCALL;
 
    if (mip_levels > image_info.MipLevels)
    {
        FIXME("Generation of mipmaps for volume textures is not implemented yet.\n");
        mip_levels = image_info.MipLevels;
    }
 
    dynamic_texture = (caps.Caps2 & D3DCAPS2_DYNAMICTEXTURES) && (usage & D3DUSAGE_DYNAMIC);
    if (pool == D3DPOOL_DEFAULT && !dynamic_texture)
    {
        hr = D3DXCreateVolumeTexture(device, width, height, depth, mip_levels, 0, format, D3DPOOL_SYSTEMMEM, &buftex);
        tex = buftex;
    }
    else
    {
        hr = D3DXCreateVolumeTexture(device, width, height, depth, mip_levels, usage, format, pool, &tex);
        buftex = NULL;
    }
    if (FAILED(hr)) return hr;
 
    hr = load_volume_texture_from_dds(tex, data, palette, filter, color_key, &image_info);
    if (FAILED(hr))
    {
        IDirect3DVolumeTexture9_Release(tex);
        return hr;
    }
 
    if (buftex)
    {
        hr = D3DXCreateVolumeTexture(device, width, height, depth, mip_levels, usage, format, pool, &tex);
        if (FAILED(hr))
        {
            IDirect3DVolumeTexture9_Release(buftex);
            return hr;
        }
 
        IDirect3DDevice9_UpdateTexture(device, (IDirect3DBaseTexture9 *)buftex, (IDirect3DBaseTexture9 *)tex);
        IDirect3DVolumeTexture9_Release(buftex);
    }
 
    if (info)
        *info = image_info;
 
    *volume_texture = tex;
    return D3D_OK;
}

Referenced by D3DXCreateVolumeTextureFromFileA(), D3DXCreateVolumeTextureFromFileExA(), D3DXCreateVolumeTextureFromFileExW(), D3DXCreateVolumeTextureFromFileInMemory(), D3DXCreateVolumeTextureFromFileW(), and test_D3DXCreateVolumeTextureFromFileInMemoryEx().

D3DXCreateVolumeTextureFromFileW()

HRESULT WINAPI D3DXCreateVolumeTextureFromFileW	(	struct IDirect3DDevice9 *	device,
		const WCHAR *	srcfile,
		struct IDirect3DVolumeTexture9 **	volume
	)

Definition at line 999 of file texture.c.

{
    HRESULT hr;
    void *data;
    DWORD data_size;
 
    TRACE("(%p, %s, %p): relay\n",
            device, debugstr_w(filename), volume_texture);
 
    if (!filename) return D3DERR_INVALIDCALL;
 
    hr = map_view_of_file(filename, &data, &data_size);
    if (FAILED(hr)) return D3DXERR_INVALIDDATA;
 
    hr = D3DXCreateVolumeTextureFromFileInMemoryEx(device, data, data_size, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT,
            D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, volume_texture);
 
    UnmapViewOfFile(data);
    return hr;
}

D3DXCreateVolumeTextureFromResourceA()

HRESULT WINAPI D3DXCreateVolumeTextureFromResourceA	(	struct IDirect3DDevice9 *	device,
		HMODULE	srcmodule,
		const char *	resource,
		struct IDirect3DVolumeTexture9 **	volume
	)

D3DXCreateVolumeTextureFromResourceExA()

HRESULT WINAPI D3DXCreateVolumeTextureFromResourceExA	(	struct IDirect3DDevice9 *	device,
		HMODULE	srcmodule,
		const char *	resource,
		UINT	width,
		UINT	height,
		UINT	depth,
		UINT	miplevels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool,
		DWORD	filter,
		DWORD	mipfilter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo,
		PALETTEENTRY *	palette,
		struct IDirect3DVolumeTexture9 **	volume
	)

D3DXCreateVolumeTextureFromResourceExW()

HRESULT WINAPI D3DXCreateVolumeTextureFromResourceExW	(	struct IDirect3DDevice9 *	device,
		HMODULE	srcmodule,
		const WCHAR *	resource,
		UINT	width,
		UINT	height,
		UINT	depth,
		UINT	miplevels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool,
		DWORD	filter,
		DWORD	mipfilter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo,
		PALETTEENTRY *	palette,
		struct IDirect3DVolumeTexture9 **	volume
	)

D3DXCreateVolumeTextureFromResourceW()

HRESULT WINAPI D3DXCreateVolumeTextureFromResourceW	(	struct IDirect3DDevice9 *	device,
		HMODULE	srcmodule,
		const WCHAR *	resource,
		struct IDirect3DVolumeTexture9 **	volume
	)

D3DXFillCubeTexture()

HRESULT WINAPI D3DXFillCubeTexture	(	struct IDirect3DCubeTexture9 *	cube,
		LPD3DXFILL3D	function,
		void *	data
	)

Definition at line 1695 of file texture.c.

{
    DWORD miplevels;
    DWORD m, x, y, f;
    D3DSURFACE_DESC desc;
    D3DLOCKED_RECT lock_rect;
    D3DXVECTOR4 value;
    D3DXVECTOR3 coord, size;
    const struct pixel_format_desc *format;
    BYTE *data;
    static const enum cube_coord coordmap[6][3] =
        {
            {ONE, YCOORDINV, XCOORDINV},
            {ZERO, YCOORDINV, XCOORD},
            {XCOORD, ONE, YCOORD},
            {XCOORD, ZERO, YCOORDINV},
            {XCOORD, YCOORDINV, ONE},
            {XCOORDINV, YCOORDINV, ZERO}
        };
 
    if (texture == NULL || function == NULL)
        return D3DERR_INVALIDCALL;
 
    miplevels = IDirect3DBaseTexture9_GetLevelCount(texture);
 
    for (m = 0; m < miplevels; m++)
    {
        if (FAILED(IDirect3DCubeTexture9_GetLevelDesc(texture, m, &desc)))
            return D3DERR_INVALIDCALL;
 
        format = get_format_info(desc.Format);
        if (format->type != FORMAT_ARGB && format->type != FORMAT_ARGBF16 && format->type != FORMAT_ARGBF)
        {
            FIXME("Unsupported texture format %#x\n", desc.Format);
            return D3DERR_INVALIDCALL;
        }
 
        for (f = 0; f < 6; f++)
        {
            if (FAILED(IDirect3DCubeTexture9_LockRect(texture, f, m, &lock_rect, NULL, D3DLOCK_DISCARD)))
                return D3DERR_INVALIDCALL;
 
            size.x = (f == 0) || (f == 1) ? 0.0f : 2.0f / desc.Width;
            size.y = (f == 2) || (f == 3) ? 0.0f : 2.0f / desc.Width;
            size.z = (f == 4) || (f == 5) ? 0.0f : 2.0f / desc.Width;
 
            data = lock_rect.pBits;
 
            for (y = 0; y < desc.Height; y++)
            {
                for (x = 0; x < desc.Width; x++)
                {
                    coord.x = get_cube_coord(coordmap[f][0], x, y, desc.Width) / desc.Width * 2.0f - 1.0f;
                    coord.y = get_cube_coord(coordmap[f][1], x, y, desc.Width) / desc.Width * 2.0f - 1.0f;
                    coord.z = get_cube_coord(coordmap[f][2], x, y, desc.Width) / desc.Width * 2.0f - 1.0f;
 
                    function(&value, &coord, &size, funcdata);
 
                    fill_texture(format, data + y * lock_rect.Pitch + x * format->bytes_per_pixel, &value);
                }
            }
            IDirect3DCubeTexture9_UnlockRect(texture, f, m);
        }
    }
 
    return D3D_OK;
}

Referenced by test_D3DXFillCubeTexture(), and test_D3DXSaveTextureToFileInMemory().

D3DXFillCubeTextureTX()

HRESULT WINAPI D3DXFillCubeTextureTX	(	struct IDirect3DCubeTexture9 *	cube,
		ID3DXTextureShader *	texture_shader
	)

Definition at line 1763 of file texture.c.

{
    FIXME("texture %p, texture_shader %p stub.\n", texture, texture_shader);
    return E_NOTIMPL;
}

Referenced by test_texture_shader().

D3DXFillTexture()

HRESULT WINAPI D3DXFillTexture	(	struct IDirect3DTexture9 *	texture,
		LPD3DXFILL2D	function,
		void *	data
	)

Definition at line 1323 of file texture.c.

{
    IDirect3DSurface9 *surface, *temp_surface;
    DWORD miplevels;
    DWORD m, x, y;
    D3DSURFACE_DESC desc;
    D3DLOCKED_RECT lock_rect;
    D3DXVECTOR4 value;
    D3DXVECTOR2 coord, size;
    const struct pixel_format_desc *format;
    BYTE *data;
    HRESULT hr;
 
    TRACE("texture %p, function %p, funcdata %p.\n", texture, function, funcdata);
 
    if (!texture || !function)
        return D3DERR_INVALIDCALL;
 
    miplevels = IDirect3DBaseTexture9_GetLevelCount(texture);
 
    for (m = 0; m < miplevels; m++)
    {
        if (FAILED(hr = IDirect3DTexture9_GetLevelDesc(texture, m, &desc)))
            return hr;
 
        format = get_format_info(desc.Format);
        if (format->type != FORMAT_ARGB && format->type != FORMAT_ARGBF16 && format->type != FORMAT_ARGBF)
        {
            FIXME("Unsupported texture format %#x.\n", desc.Format);
            return D3DERR_INVALIDCALL;
        }
 
        if (FAILED(hr = IDirect3DTexture9_GetSurfaceLevel(texture, m, &surface)))
            return hr;
        if (FAILED(hr = lock_surface(surface, NULL, &lock_rect, &temp_surface, TRUE)))
        {
            IDirect3DSurface9_Release(surface);
            return hr;
        }
 
        size.x = 1.0f / desc.Width;
        size.y = 1.0f / desc.Height;
 
        data = lock_rect.pBits;
 
        for (y = 0; y < desc.Height; y++)
        {
            /* The callback function expects the coordinates of the center
               of the texel */
            coord.y = (y + 0.5f) / desc.Height;
 
            for (x = 0; x < desc.Width; x++)
            {
                coord.x = (x + 0.5f) / desc.Width;
 
                function(&value, &coord, &size, funcdata);
 
                fill_texture(format, data + y * lock_rect.Pitch + x * format->bytes_per_pixel, &value);
            }
        }
        if (FAILED(hr = unlock_surface(surface, NULL, temp_surface, TRUE)))
        {
            IDirect3DSurface9_Release(surface);
            return hr;
        }
        IDirect3DSurface9_Release(surface);
    }
 
    return D3D_OK;
}

Referenced by test_D3DXFillTexture().

D3DXFillTextureTX()

HRESULT WINAPI D3DXFillTextureTX	(	struct IDirect3DTexture9 *	texture,
		ID3DXTextureShader *	texture_shader
	)

Definition at line 1394 of file texture.c.

{
    FIXME("texture %p, texture_shader %p stub.\n", texture, texture_shader);
    return E_NOTIMPL;
}

Referenced by test_texture_shader().

D3DXFillVolumeTexture()

HRESULT WINAPI D3DXFillVolumeTexture	(	struct IDirect3DVolumeTexture9 *	volume,
		LPD3DXFILL3D	function,
		void *	data
	)

Definition at line 1769 of file texture.c.

{
    DWORD miplevels;
    DWORD m, x, y, z;
    D3DVOLUME_DESC desc;
    D3DLOCKED_BOX lock_box;
    D3DXVECTOR4 value;
    D3DXVECTOR3 coord, size;
    const struct pixel_format_desc *format;
    BYTE *data;
 
    if (texture == NULL || function == NULL)
        return D3DERR_INVALIDCALL;
 
    miplevels = IDirect3DBaseTexture9_GetLevelCount(texture);
 
    for (m = 0; m < miplevels; m++)
    {
        if (FAILED(IDirect3DVolumeTexture9_GetLevelDesc(texture, m, &desc)))
            return D3DERR_INVALIDCALL;
 
        format = get_format_info(desc.Format);
        if (format->type != FORMAT_ARGB && format->type != FORMAT_ARGBF16 && format->type != FORMAT_ARGBF)
        {
            FIXME("Unsupported texture format %#x\n", desc.Format);
            return D3DERR_INVALIDCALL;
        }
 
        if (FAILED(IDirect3DVolumeTexture9_LockBox(texture, m, &lock_box, NULL, D3DLOCK_DISCARD)))
            return D3DERR_INVALIDCALL;
 
        size.x = 1.0f / desc.Width;
        size.y = 1.0f / desc.Height;
        size.z = 1.0f / desc.Depth;
 
        data = lock_box.pBits;
 
        for (z = 0; z < desc.Depth; z++)
        {
            /* The callback function expects the coordinates of the center
               of the texel */
            coord.z = (z + 0.5f) / desc.Depth;
 
            for (y = 0; y < desc.Height; y++)
            {
                coord.y = (y + 0.5f) / desc.Height;
 
                for (x = 0; x < desc.Width; x++)
                {
                    coord.x = (x + 0.5f) / desc.Width;
 
                    function(&value, &coord, &size, funcdata);
 
                    fill_texture(format, data + z * lock_box.SlicePitch + y * lock_box.RowPitch
                            + x * format->bytes_per_pixel, &value);
                }
            }
        }
        IDirect3DVolumeTexture9_UnlockBox(texture, m);
    }
 
    return D3D_OK;
}

Referenced by test_D3DXFillVolumeTexture().

D3DXFillVolumeTextureTX()

HRESULT WINAPI D3DXFillVolumeTextureTX	(	struct IDirect3DVolumeTexture9 *	volume,
		ID3DXTextureShader *	texture_shader
	)

Definition at line 1833 of file texture.c.

{
    FIXME("texture %p, texture_shader %p stub.\n", texture, texture_shader);
    return E_NOTIMPL;
}

Referenced by test_texture_shader().

D3DXFilterTexture()

HRESULT WINAPI D3DXFilterTexture	(	struct IDirect3DBaseTexture9 *	texture,
		const PALETTEENTRY *	palette,
		UINT	srclevel,
		DWORD	filter
	)

Definition at line 52 of file texture.c.

{
    UINT level;
    HRESULT hr;
    D3DRESOURCETYPE type;
 
    TRACE("(%p, %p, %u, %#x)\n", texture, palette, srclevel, filter);
 
    if (!texture)
        return D3DERR_INVALIDCALL;
 
    if ((filter & 0xFFFF) > D3DX_FILTER_BOX && filter != D3DX_DEFAULT)
        return D3DERR_INVALIDCALL;
 
    if (srclevel == D3DX_DEFAULT)
        srclevel = 0;
    else if (srclevel >= IDirect3DBaseTexture9_GetLevelCount(texture))
        return D3DERR_INVALIDCALL;
 
    switch (type = IDirect3DBaseTexture9_GetType(texture))
    {
        case D3DRTYPE_TEXTURE:
        case D3DRTYPE_CUBETEXTURE:
        {
            IDirect3DSurface9 *topsurf, *mipsurf;
            D3DSURFACE_DESC desc;
            int i, numfaces;
 
            if (type == D3DRTYPE_TEXTURE)
            {
                numfaces = 1;
                IDirect3DTexture9_GetLevelDesc((IDirect3DTexture9*) texture, srclevel, &desc);
            }
            else
            {
                numfaces = 6;
                IDirect3DCubeTexture9_GetLevelDesc((IDirect3DTexture9*) texture, srclevel, &desc);
            }
 
            if (filter == D3DX_DEFAULT)
            {
                if (is_pow2(desc.Width) && is_pow2(desc.Height))
                    filter = D3DX_FILTER_BOX;
                else
                    filter = D3DX_FILTER_BOX | D3DX_FILTER_DITHER;
            }
 
            for (i = 0; i < numfaces; i++)
            {
                level = srclevel + 1;
                hr = get_surface(type, texture, i, srclevel, &topsurf);
 
                if (FAILED(hr))
                    return D3DERR_INVALIDCALL;
 
                while (get_surface(type, texture, i, level, &mipsurf) == D3D_OK)
                {
                    hr = D3DXLoadSurfaceFromSurface(mipsurf, palette, NULL, topsurf, palette, NULL, filter, 0);
                    IDirect3DSurface9_Release(topsurf);
                    topsurf = mipsurf;
 
                    if (FAILED(hr))
                        break;
 
                    level++;
                }
 
                IDirect3DSurface9_Release(topsurf);
                if (FAILED(hr))
                    return hr;
            }
 
            return D3D_OK;
        }
 
        case D3DRTYPE_VOLUMETEXTURE:
        {
            D3DVOLUME_DESC desc;
            int level, level_count;
            IDirect3DVolume9 *top_volume, *mip_volume;
            IDirect3DVolumeTexture9 *volume_texture = (IDirect3DVolumeTexture9*) texture;
 
            IDirect3DVolumeTexture9_GetLevelDesc(volume_texture, srclevel, &desc);
 
            if (filter == D3DX_DEFAULT)
            {
                if (is_pow2(desc.Width) && is_pow2(desc.Height) && is_pow2(desc.Depth))
                    filter = D3DX_FILTER_BOX;
                else
                    filter = D3DX_FILTER_BOX | D3DX_FILTER_DITHER;
            }
 
            hr = IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, srclevel, &top_volume);
            if (FAILED(hr))
                return hr;
 
            level_count = IDirect3DVolumeTexture9_GetLevelCount(volume_texture);
            for (level = srclevel + 1; level < level_count; level++)
            {
                IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, level, &mip_volume);
                hr = D3DXLoadVolumeFromVolume(mip_volume, palette, NULL, top_volume, palette, NULL, filter, 0);
                IDirect3DVolume9_Release(top_volume);
                top_volume = mip_volume;
 
                if (FAILED(hr))
                    break;
            }
 
            IDirect3DVolume9_Release(top_volume);
            if (FAILED(hr))
                return hr;
 
            return D3D_OK;
        }
 
        default:
            return D3DERR_INVALIDCALL;
    }
}

Referenced by D3DXCreateCubeTextureFromFileInMemoryEx(), D3DXCreateTextureFromFileInMemoryEx(), D3DXRenderToEnvMap_End(), and test_D3DXFilterTexture().

D3DXGetImageInfoFromFileA()

HRESULT WINAPI D3DXGetImageInfoFromFileA	(	const char *	file,
		D3DXIMAGE_INFO *	info
	)

Definition at line 1135 of file surface.c.

{
    WCHAR *widename;
    HRESULT hr;
    int strlength;
 
    TRACE("file %s, info %p.\n", debugstr_a(file), info);
 
    if( !file ) return D3DERR_INVALIDCALL;
 
    strlength = MultiByteToWideChar(CP_ACP, 0, file, -1, NULL, 0);
    widename = HeapAlloc(GetProcessHeap(), 0, strlength * sizeof(*widename));
    MultiByteToWideChar(CP_ACP, 0, file, -1, widename, strlength);
 
    hr = D3DXGetImageInfoFromFileW(widename, info);
    HeapFree(GetProcessHeap(), 0, widename);
 
    return hr;
}

Referenced by test_D3DXGetImageInfo().

D3DXGetImageInfoFromFileInMemory()

HRESULT WINAPI D3DXGetImageInfoFromFileInMemory	(	const void *	data,
		UINT	data_size,
		D3DXIMAGE_INFO *	info
	)

Definition at line 985 of file surface.c.

{
    IWICImagingFactory *factory;
    IWICBitmapDecoder *decoder = NULL;
    IWICStream *stream;
    HRESULT hr;
    BOOL dib;
 
    TRACE("(%p, %d, %p)\n", data, datasize, info);
 
    if (!data || !datasize)
        return D3DERR_INVALIDCALL;
 
    if (!info)
        return D3D_OK;
 
    if ((datasize >= 4) && !strncmp(data, "DDS ", 4)) {
        TRACE("File type is DDS\n");
        return get_image_info_from_dds(data, datasize, info);
    }
 
    /* In case of DIB file, convert it to BMP */
    dib = convert_dib_to_bmp(&data, &datasize);
 
    hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
 
    if (SUCCEEDED(hr)) {
        IWICImagingFactory_CreateStream(factory, &stream);
        IWICStream_InitializeFromMemory(stream, (BYTE*)data, datasize);
        hr = IWICImagingFactory_CreateDecoderFromStream(factory, (IStream*)stream, NULL, 0, &decoder);
        IWICStream_Release(stream);
        IWICImagingFactory_Release(factory);
    }
 
    if (FAILED(hr)) {
        if ((datasize >= 2) && (!strncmp(data, "P3", 2) || !strncmp(data, "P6", 2)))
            FIXME("File type PPM is not supported yet\n");
        else if ((datasize >= 10) && !strncmp(data, "#?RADIANCE", 10))
            FIXME("File type HDR is not supported yet\n");
        else if ((datasize >= 2) && (!strncmp(data, "PF", 2) || !strncmp(data, "Pf", 2)))
            FIXME("File type PFM is not supported yet\n");
    }
 
    if (SUCCEEDED(hr)) {
        GUID container_format;
        UINT frame_count;
 
        hr = IWICBitmapDecoder_GetContainerFormat(decoder, &container_format);
        if (SUCCEEDED(hr)) {
            if (IsEqualGUID(&container_format, &GUID_ContainerFormatBmp)) {
                if (dib) {
                    TRACE("File type is DIB\n");
                    info->ImageFileFormat = D3DXIFF_DIB;
                } else {
                    TRACE("File type is BMP\n");
                    info->ImageFileFormat = D3DXIFF_BMP;
                }
            } else if (IsEqualGUID(&container_format, &GUID_ContainerFormatPng)) {
                TRACE("File type is PNG\n");
                info->ImageFileFormat = D3DXIFF_PNG;
            } else if(IsEqualGUID(&container_format, &GUID_ContainerFormatJpeg)) {
                TRACE("File type is JPG\n");
                info->ImageFileFormat = D3DXIFF_JPG;
            } else if(IsEqualGUID(&container_format, &GUID_WineContainerFormatTga)) {
                TRACE("File type is TGA\n");
                info->ImageFileFormat = D3DXIFF_TGA;
            } else {
                WARN("Unsupported image file format %s\n", debugstr_guid(&container_format));
                hr = D3DXERR_INVALIDDATA;
            }
        }
 
        if (SUCCEEDED(hr))
            hr = IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
        if (SUCCEEDED(hr) && !frame_count)
            hr = D3DXERR_INVALIDDATA;
 
        if (SUCCEEDED(hr)) {
            IWICBitmapFrameDecode *frame = NULL;
 
            hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
 
            if (SUCCEEDED(hr))
                hr = IWICBitmapFrameDecode_GetSize(frame, &info->Width, &info->Height);
 
            if (SUCCEEDED(hr)) {
                WICPixelFormatGUID pixel_format;
 
                hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &pixel_format);
                if (SUCCEEDED(hr)) {
                    info->Format = wic_guid_to_d3dformat(&pixel_format);
                    if (info->Format == D3DFMT_UNKNOWN) {
                        WARN("Unsupported pixel format %s\n", debugstr_guid(&pixel_format));
                        hr = D3DXERR_INVALIDDATA;
                    }
                }
            }
 
            /* For 32 bpp BMP, windowscodecs.dll never returns a format with alpha while
             * d3dx9_xx.dll returns one if at least 1 pixel has a non zero alpha component */
            if (SUCCEEDED(hr) && (info->Format == D3DFMT_X8R8G8B8) && (info->ImageFileFormat == D3DXIFF_BMP)) {
                DWORD size = sizeof(DWORD) * info->Width * info->Height;
                BYTE *buffer = HeapAlloc(GetProcessHeap(), 0, size);
                hr = IWICBitmapFrameDecode_CopyPixels(frame, NULL, sizeof(DWORD) * info->Width, size, buffer);
                if (SUCCEEDED(hr)) {
                    DWORD i;
                    for (i = 0; i < info->Width * info->Height; i++) {
                        if (buffer[i*4+3]) {
                            info->Format = D3DFMT_A8R8G8B8;
                            break;
                        }
                    }
                }
                HeapFree(GetProcessHeap(), 0, buffer);
            }
 
            if (frame)
                 IWICBitmapFrameDecode_Release(frame);
 
            info->Depth = 1;
            info->MipLevels = 1;
            info->ResourceType = D3DRTYPE_TEXTURE;
        }
    }
 
    if (decoder)
        IWICBitmapDecoder_Release(decoder);
 
    if (dib)
        HeapFree(GetProcessHeap(), 0, (void*)data);
 
    if (FAILED(hr)) {
        TRACE("Invalid or unsupported image file\n");
        return D3DXERR_INVALIDDATA;
    }
 
    return D3D_OK;
}

Referenced by check_dds_pixel_format_(), D3DXCreateCubeTextureFromFileInMemoryEx(), D3DXCreateTextureFromFileInMemoryEx(), D3DXCreateVolumeTextureFromFileInMemoryEx(), D3DXGetImageInfoFromFileW(), D3DXGetImageInfoFromResourceA(), D3DXGetImageInfoFromResourceW(), D3DXLoadSurfaceFromFileInMemory(), D3DXLoadVolumeFromFileInMemory(), test_D3DXGetImageInfo(), test_D3DXSaveTextureToFileInMemory(), and test_dds_header_handling().

D3DXGetImageInfoFromFileW()

HRESULT WINAPI D3DXGetImageInfoFromFileW	(	const WCHAR *	file,
		D3DXIMAGE_INFO *	info
	)

Definition at line 1155 of file surface.c.

{
    void *buffer;
    HRESULT hr;
    DWORD size;
 
    TRACE("file %s, info %p.\n", debugstr_w(file), info);
 
    if (!file)
        return D3DERR_INVALIDCALL;
 
    if (FAILED(map_view_of_file(file, &buffer, &size)))
        return D3DXERR_INVALIDDATA;
 
    hr = D3DXGetImageInfoFromFileInMemory(buffer, size, info);
    UnmapViewOfFile(buffer);
 
    return hr;
}

Referenced by D3DXGetImageInfoFromFileA().

D3DXGetImageInfoFromResourceA()

HRESULT WINAPI D3DXGetImageInfoFromResourceA	(	HMODULE	module,
		const char *	resource,
		D3DXIMAGE_INFO *	info
	)

Definition at line 1184 of file surface.c.

{
    HRSRC resinfo;
    void *buffer;
    DWORD size;
 
    TRACE("module %p, resource %s, info %p.\n", module, debugstr_a(resource), info);
 
    if (!(resinfo = FindResourceA(module, resource, (const char *)RT_RCDATA))
            /* Try loading the resource as bitmap data (which is in DIB format D3DXIFF_DIB) */
            && !(resinfo = FindResourceA(module, resource, (const char *)RT_BITMAP)))
        return D3DXERR_INVALIDDATA;
 
    if (FAILED(load_resource_into_memory(module, resinfo, &buffer, &size)))
        return D3DXERR_INVALIDDATA;
 
    return D3DXGetImageInfoFromFileInMemory(buffer, size, info);
}

Referenced by test_D3DXGetImageInfo().

D3DXGetImageInfoFromResourceW()

HRESULT WINAPI D3DXGetImageInfoFromResourceW	(	HMODULE	module,
		const WCHAR *	resource,
		D3DXIMAGE_INFO *	info
	)

Definition at line 1203 of file surface.c.

{
    HRSRC resinfo;
    void *buffer;
    DWORD size;
 
    TRACE("module %p, resource %s, info %p.\n", module, debugstr_w(resource), info);
 
    if (!(resinfo = FindResourceW(module, resource, (const WCHAR *)RT_RCDATA))
            /* Try loading the resource as bitmap data (which is in DIB format D3DXIFF_DIB) */
            && !(resinfo = FindResourceW(module, resource, (const WCHAR *)RT_BITMAP)))
        return D3DXERR_INVALIDDATA;
 
    if (FAILED(load_resource_into_memory(module, resinfo, &buffer, &size)))
        return D3DXERR_INVALIDDATA;
 
    return D3DXGetImageInfoFromFileInMemory(buffer, size, info);
}

D3DXLoadSurfaceFromFileA()

HRESULT WINAPI D3DXLoadSurfaceFromFileA	(	struct IDirect3DSurface9 *	destsurface,
		const PALETTEENTRY *	destpalette,
		const RECT *	destrect,
		const char *	srcfile,
		const RECT *	srcrect,
		DWORD	filter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo
	)

Definition at line 1416 of file surface.c.

{
    WCHAR *src_file_w;
    HRESULT hr;
    int strlength;
 
    TRACE("dst_surface %p, dst_palette %p, dst_rect %s, src_file %s, "
            "src_rect %s, filter %#x, color_key 0x%08x, src_info %p.\n",
            dst_surface, dst_palette, wine_dbgstr_rect(dst_rect), debugstr_a(src_file),
            wine_dbgstr_rect(src_rect), filter, color_key, src_info);
 
    if (!src_file || !dst_surface)
        return D3DERR_INVALIDCALL;
 
    strlength = MultiByteToWideChar(CP_ACP, 0, src_file, -1, NULL, 0);
    src_file_w = HeapAlloc(GetProcessHeap(), 0, strlength * sizeof(*src_file_w));
    MultiByteToWideChar(CP_ACP, 0, src_file, -1, src_file_w, strlength);
 
    hr = D3DXLoadSurfaceFromFileW(dst_surface, dst_palette, dst_rect,
            src_file_w, src_rect, filter, color_key, src_info);
    HeapFree(GetProcessHeap(), 0, src_file_w);
 
    return hr;
}

Referenced by test_D3DXLoadSurface(), and test_D3DXSaveSurfaceToFile().

D3DXLoadSurfaceFromFileInMemory()

HRESULT WINAPI D3DXLoadSurfaceFromFileInMemory	(	struct IDirect3DSurface9 *	destsurface,
		const PALETTEENTRY *	destpalette,
		const RECT *	destrect,
		const void *	srcdata,
		UINT	srcdatasize,
		const RECT *	srcrect,
		DWORD	filter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo
	)

Definition at line 1245 of file surface.c.

{
    D3DXIMAGE_INFO imginfo;
    HRESULT hr;
 
    IWICImagingFactory *factory = NULL;
    IWICBitmapDecoder *decoder;
    IWICBitmapFrameDecode *bitmapframe;
    IWICStream *stream;
 
    const struct pixel_format_desc *formatdesc;
    WICRect wicrect;
    RECT rect;
 
    TRACE("dst_surface %p, dst_palette %p, dst_rect %s, src_data %p, src_data_size %u, "
            "src_rect %s, filter %#x, color_key 0x%08x, src_info %p.\n",
            pDestSurface, pDestPalette, wine_dbgstr_rect(pDestRect), pSrcData, SrcDataSize,
            wine_dbgstr_rect(pSrcRect), dwFilter, Colorkey, pSrcInfo);
 
    if (!pDestSurface || !pSrcData || !SrcDataSize)
        return D3DERR_INVALIDCALL;
 
    hr = D3DXGetImageInfoFromFileInMemory(pSrcData, SrcDataSize, &imginfo);
 
    if (FAILED(hr))
        return hr;
 
    if (pSrcRect)
    {
        wicrect.X = pSrcRect->left;
        wicrect.Y = pSrcRect->top;
        wicrect.Width = pSrcRect->right - pSrcRect->left;
        wicrect.Height = pSrcRect->bottom - pSrcRect->top;
    }
    else
    {
        wicrect.X = 0;
        wicrect.Y = 0;
        wicrect.Width = imginfo.Width;
        wicrect.Height = imginfo.Height;
    }
 
    SetRect(&rect, wicrect.X, wicrect.Y, wicrect.X + wicrect.Width, wicrect.Y + wicrect.Height);
 
    if (imginfo.ImageFileFormat == D3DXIFF_DDS)
    {
        hr = load_surface_from_dds(pDestSurface, pDestPalette, pDestRect, pSrcData, &rect,
            dwFilter, Colorkey, &imginfo);
        if (SUCCEEDED(hr) && pSrcInfo)
            *pSrcInfo = imginfo;
        return hr;
    }
 
    if (imginfo.ImageFileFormat == D3DXIFF_DIB)
        convert_dib_to_bmp(&pSrcData, &SrcDataSize);
 
    if (FAILED(WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory)))
        goto cleanup_err;
 
    if (FAILED(IWICImagingFactory_CreateStream(factory, &stream)))
    {
        IWICImagingFactory_Release(factory);
        factory = NULL;
        goto cleanup_err;
    }
 
    IWICStream_InitializeFromMemory(stream, (BYTE*)pSrcData, SrcDataSize);
 
    hr = IWICImagingFactory_CreateDecoderFromStream(factory, (IStream*)stream, NULL, 0, &decoder);
 
    IWICStream_Release(stream);
 
    if (FAILED(hr))
        goto cleanup_err;
 
    hr = IWICBitmapDecoder_GetFrame(decoder, 0, &bitmapframe);
 
    if (FAILED(hr))
        goto cleanup_bmp;
 
    formatdesc = get_format_info(imginfo.Format);
 
    if (formatdesc->type == FORMAT_UNKNOWN)
    {
        FIXME("Unsupported pixel format\n");
        hr = D3DXERR_INVALIDDATA;
    }
    else
    {
        BYTE *buffer;
        DWORD pitch;
        PALETTEENTRY *palette = NULL;
        WICColor *colors = NULL;
 
        pitch = formatdesc->bytes_per_pixel * wicrect.Width;
        buffer = HeapAlloc(GetProcessHeap(), 0, pitch * wicrect.Height);
 
        hr = IWICBitmapFrameDecode_CopyPixels(bitmapframe, &wicrect, pitch,
                                              pitch * wicrect.Height, buffer);
 
        if (SUCCEEDED(hr) && (formatdesc->type == FORMAT_INDEX))
        {
            IWICPalette *wic_palette = NULL;
            UINT nb_colors;
 
            hr = IWICImagingFactory_CreatePalette(factory, &wic_palette);
            if (SUCCEEDED(hr))
                hr = IWICBitmapFrameDecode_CopyPalette(bitmapframe, wic_palette);
            if (SUCCEEDED(hr))
                hr = IWICPalette_GetColorCount(wic_palette, &nb_colors);
            if (SUCCEEDED(hr))
            {
                colors = HeapAlloc(GetProcessHeap(), 0, nb_colors * sizeof(colors[0]));
                palette = HeapAlloc(GetProcessHeap(), 0, nb_colors * sizeof(palette[0]));
                if (!colors || !palette)
                    hr = E_OUTOFMEMORY;
            }
            if (SUCCEEDED(hr))
                hr = IWICPalette_GetColors(wic_palette, nb_colors, colors, &nb_colors);
            if (SUCCEEDED(hr))
            {
                UINT i;
 
                /* Convert colors from WICColor (ARGB) to PALETTEENTRY (ABGR) */
                for (i = 0; i < nb_colors; i++)
                {
                    palette[i].peRed   = (colors[i] >> 16) & 0xff;
                    palette[i].peGreen = (colors[i] >> 8) & 0xff;
                    palette[i].peBlue  = colors[i] & 0xff;
                    palette[i].peFlags = (colors[i] >> 24) & 0xff; /* peFlags is the alpha component in DX8 and higher */
                }
            }
            if (wic_palette)
                IWICPalette_Release(wic_palette);
        }
 
        if (SUCCEEDED(hr))
        {
            hr = D3DXLoadSurfaceFromMemory(pDestSurface, pDestPalette, pDestRect,
                                           buffer, imginfo.Format, pitch,
                                           palette, &rect, dwFilter, Colorkey);
        }
 
        HeapFree(GetProcessHeap(), 0, colors);
        HeapFree(GetProcessHeap(), 0, palette);
        HeapFree(GetProcessHeap(), 0, buffer);
    }
 
    IWICBitmapFrameDecode_Release(bitmapframe);
 
cleanup_bmp:
    IWICBitmapDecoder_Release(decoder);
 
cleanup_err:
    if (factory)
        IWICImagingFactory_Release(factory);
 
    if (imginfo.ImageFileFormat == D3DXIFF_DIB)
        HeapFree(GetProcessHeap(), 0, (void*)pSrcData);
 
    if (FAILED(hr))
        return D3DXERR_INVALIDDATA;
 
    if (pSrcInfo)
        *pSrcInfo = imginfo;
 
    return D3D_OK;
}

Referenced by D3DXCreateTextureFromFileInMemoryEx(), D3DXLoadSurfaceFromFileW(), D3DXLoadSurfaceFromResourceA(), D3DXLoadSurfaceFromResourceW(), test_D3DXCreateTextureFromFileInMemory(), test_D3DXLoadSurface(), and test_D3DXSaveTextureToFileInMemory().

D3DXLoadSurfaceFromFileW()

HRESULT WINAPI D3DXLoadSurfaceFromFileW	(	struct IDirect3DSurface9 *	destsurface,
		const PALETTEENTRY *	destpalette,
		const RECT *	destrect,
		const WCHAR *	srcfile,
		const RECT *	srcrect,
		DWORD	filter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo
	)

Definition at line 1443 of file surface.c.

{
    UINT data_size;
    void *data;
    HRESULT hr;
 
    TRACE("dst_surface %p, dst_palette %p, dst_rect %s, src_file %s, "
            "src_rect %s, filter %#x, color_key 0x%08x, src_info %p.\n",
            dst_surface, dst_palette, wine_dbgstr_rect(dst_rect), debugstr_w(src_file),
            wine_dbgstr_rect(src_rect), filter, color_key, src_info);
 
    if (!src_file || !dst_surface)
        return D3DERR_INVALIDCALL;
 
    if (FAILED(map_view_of_file(src_file, &data, &data_size)))
        return D3DXERR_INVALIDDATA;
 
    hr = D3DXLoadSurfaceFromFileInMemory(dst_surface, dst_palette, dst_rect,
            data, data_size, src_rect, filter, color_key, src_info);
    UnmapViewOfFile(data);
 
    return hr;
}

Referenced by D3DXLoadSurfaceFromFileA().

D3DXLoadSurfaceFromMemory()

HRESULT WINAPI D3DXLoadSurfaceFromMemory	(	IDirect3DSurface9 *	dst_surface,
		const PALETTEENTRY *	dst_palette,
		const RECT *	dst_rect,
		const void *	src_memory,
		D3DFORMAT	src_format,
		UINT	src_pitch,
		const PALETTEENTRY *	src_palette,
		const RECT *	src_rect,
		DWORD	filter,
		D3DCOLOR	color_key
	)

Definition at line 1963 of file surface.c.

{
    const struct pixel_format_desc *srcformatdesc, *destformatdesc;
    struct volume src_size, dst_size, dst_size_aligned;
    RECT dst_rect_temp, dst_rect_aligned;
    IDirect3DSurface9 *surface;
    D3DSURFACE_DESC surfdesc;
    D3DLOCKED_RECT lockrect;
    HRESULT hr;
 
    TRACE("(%p, %p, %s, %p, %#x, %u, %p, %s, %#x, 0x%08x)\n",
            dst_surface, dst_palette, wine_dbgstr_rect(dst_rect), src_memory, src_format,
            src_pitch, src_palette, wine_dbgstr_rect(src_rect), filter, color_key);
 
    if (!dst_surface || !src_memory || !src_rect)
    {
        WARN("Invalid argument specified.\n");
        return D3DERR_INVALIDCALL;
    }
    if (src_format == D3DFMT_UNKNOWN
            || src_rect->left >= src_rect->right
            || src_rect->top >= src_rect->bottom)
    {
        WARN("Invalid src_format or src_rect.\n");
        return E_FAIL;
    }
 
    srcformatdesc = get_format_info(src_format);
    if (srcformatdesc->type == FORMAT_UNKNOWN)
    {
        FIXME("Unsupported format %#x.\n", src_format);
        return E_NOTIMPL;
    }
 
    src_size.width = src_rect->right - src_rect->left;
    src_size.height = src_rect->bottom - src_rect->top;
    src_size.depth = 1;
 
    IDirect3DSurface9_GetDesc(dst_surface, &surfdesc);
    destformatdesc = get_format_info(surfdesc.Format);
    if (!dst_rect)
    {
        dst_rect = &dst_rect_temp;
        dst_rect_temp.left = 0;
        dst_rect_temp.top = 0;
        dst_rect_temp.right = surfdesc.Width;
        dst_rect_temp.bottom = surfdesc.Height;
    }
    else
    {
        if (dst_rect->left > dst_rect->right || dst_rect->right > surfdesc.Width
                || dst_rect->top > dst_rect->bottom || dst_rect->bottom > surfdesc.Height
                || dst_rect->left < 0 || dst_rect->top < 0)
        {
            WARN("Invalid dst_rect specified.\n");
            return D3DERR_INVALIDCALL;
        }
        if (dst_rect->left == dst_rect->right || dst_rect->top == dst_rect->bottom)
        {
            WARN("Empty dst_rect specified.\n");
            return D3D_OK;
        }
    }
 
    dst_rect_aligned = *dst_rect;
    if (dst_rect_aligned.left & (destformatdesc->block_width - 1))
        dst_rect_aligned.left = dst_rect_aligned.left & ~(destformatdesc->block_width - 1);
    if (dst_rect_aligned.top & (destformatdesc->block_height - 1))
        dst_rect_aligned.top = dst_rect_aligned.top & ~(destformatdesc->block_height - 1);
    if (dst_rect_aligned.right & (destformatdesc->block_width - 1) && dst_rect_aligned.right != surfdesc.Width)
        dst_rect_aligned.right = min((dst_rect_aligned.right + destformatdesc->block_width - 1)
                & ~(destformatdesc->block_width - 1), surfdesc.Width);
    if (dst_rect_aligned.bottom & (destformatdesc->block_height - 1) && dst_rect_aligned.bottom != surfdesc.Height)
        dst_rect_aligned.bottom = min((dst_rect_aligned.bottom + destformatdesc->block_height - 1)
                & ~(destformatdesc->block_height - 1), surfdesc.Height);
 
    dst_size.width = dst_rect->right - dst_rect->left;
    dst_size.height = dst_rect->bottom - dst_rect->top;
    dst_size.depth = 1;
    dst_size_aligned.width = dst_rect_aligned.right - dst_rect_aligned.left;
    dst_size_aligned.height = dst_rect_aligned.bottom - dst_rect_aligned.top;
    dst_size_aligned.depth = 1;
 
    if (filter == D3DX_DEFAULT)
        filter = D3DX_FILTER_TRIANGLE | D3DX_FILTER_DITHER;
 
    if (FAILED(hr = lock_surface(dst_surface, &dst_rect_aligned, &lockrect, &surface, TRUE)))
        return hr;
 
    src_memory = (BYTE *)src_memory + src_rect->top / srcformatdesc->block_height * src_pitch
            + src_rect->left / srcformatdesc->block_width * srcformatdesc->block_byte_count;
 
    if (src_format == surfdesc.Format
            && dst_size.width == src_size.width
            && dst_size.height == src_size.height
            && color_key == 0
            && !(src_rect->left & (srcformatdesc->block_width - 1))
            && !(src_rect->top & (srcformatdesc->block_height - 1))
            && !(dst_rect->left & (destformatdesc->block_width - 1))
            && !(dst_rect->top & (destformatdesc->block_height - 1)))
    {
        TRACE("Simple copy.\n");
        copy_pixels(src_memory, src_pitch, 0, lockrect.pBits, lockrect.Pitch, 0,
                &src_size, srcformatdesc);
    }
    else /* Stretching or format conversion. */
    {
        const struct pixel_format_desc *dst_format;
        DWORD *src_uncompressed = NULL;
        BYTE *dst_uncompressed = NULL;
        unsigned int dst_pitch;
        BYTE *dst_mem;
 
        if (!is_conversion_from_supported(srcformatdesc)
                || !is_conversion_to_supported(destformatdesc))
        {
            FIXME("Unsupported format conversion %#x -> %#x.\n", src_format, surfdesc.Format);
            unlock_surface(dst_surface, &dst_rect_aligned, surface, FALSE);
            return E_NOTIMPL;
        }
 
        if (srcformatdesc->type == FORMAT_DXT)
        {
            void (*fetch_dxt_texel)(int srcRowStride, const BYTE *pixdata,
                    int i, int j, void *texel);
            unsigned int x, y;
 
            src_pitch = src_pitch * srcformatdesc->block_width / srcformatdesc->block_byte_count;
 
            src_uncompressed = heap_alloc(src_size.width * src_size.height * sizeof(DWORD));
            if (!src_uncompressed)
            {
                unlock_surface(dst_surface, &dst_rect_aligned, surface, FALSE);
                return E_OUTOFMEMORY;
            }
 
            switch(src_format)
            {
                case D3DFMT_DXT1:
                    fetch_dxt_texel = fetch_2d_texel_rgba_dxt1;
                    break;
                case D3DFMT_DXT2:
                case D3DFMT_DXT3:
                    fetch_dxt_texel = fetch_2d_texel_rgba_dxt3;
                    break;
                case D3DFMT_DXT4:
                case D3DFMT_DXT5:
                    fetch_dxt_texel = fetch_2d_texel_rgba_dxt5;
                    break;
                default:
                    FIXME("Unexpected compressed texture format %u.\n", src_format);
                    fetch_dxt_texel = NULL;
            }
 
            TRACE("Uncompressing DXTn surface.\n");
            for (y = 0; y < src_size.height; ++y)
            {
                DWORD *ptr = &src_uncompressed[y * src_size.width];
                for (x = 0; x < src_size.width; ++x)
                {
                    fetch_dxt_texel(src_pitch, src_memory, x + src_rect->left, y + src_rect->top, ptr);
                    ++ptr;
                }
            }
            src_memory = src_uncompressed;
            src_pitch = src_size.width * sizeof(DWORD);
            srcformatdesc = get_format_info(D3DFMT_A8B8G8R8);
        }
 
        if (destformatdesc->type == FORMAT_DXT)
        {
            BOOL dst_misaligned = dst_rect->left != dst_rect_aligned.left
                    || dst_rect->top != dst_rect_aligned.top
                    || dst_rect->right != dst_rect_aligned.right
                    || dst_rect->bottom != dst_rect_aligned.bottom;
 
            dst_uncompressed = HeapAlloc(GetProcessHeap(), dst_misaligned ? HEAP_ZERO_MEMORY : 0,
                    dst_size_aligned.width * dst_size_aligned.height * sizeof(DWORD));
            if (!dst_uncompressed)
            {
                heap_free(src_uncompressed);
                unlock_surface(dst_surface, &dst_rect_aligned, surface, FALSE);
                return E_OUTOFMEMORY;
            }
            dst_pitch = dst_size_aligned.width * sizeof(DWORD);
            dst_format = get_format_info(D3DFMT_A8B8G8R8);
            dst_mem = dst_uncompressed + (dst_rect->top - dst_rect_aligned.top) * dst_pitch
                    + (dst_rect->left - dst_rect_aligned.left) * sizeof(DWORD);
        }
        else
        {
            dst_mem = lockrect.pBits;
            dst_pitch = lockrect.Pitch;
            dst_format = destformatdesc;
        }
 
        if ((filter & 0xf) == D3DX_FILTER_NONE)
        {
            convert_argb_pixels(src_memory, src_pitch, 0, &src_size, srcformatdesc,
                    dst_mem, dst_pitch, 0, &dst_size, dst_format, color_key, src_palette);
        }
        else /* if ((filter & 0xf) == D3DX_FILTER_POINT) */
        {
            if ((filter & 0xf) != D3DX_FILTER_POINT)
                FIXME("Unhandled filter %#x.\n", filter);
 
            /* Always apply a point filter until D3DX_FILTER_LINEAR,
             * D3DX_FILTER_TRIANGLE and D3DX_FILTER_BOX are implemented. */
            point_filter_argb_pixels(src_memory, src_pitch, 0, &src_size, srcformatdesc,
                    dst_mem, dst_pitch, 0, &dst_size, dst_format, color_key, src_palette);
        }
 
        heap_free(src_uncompressed);
 
        if (dst_uncompressed)
        {
            GLenum gl_format = 0;
 
            TRACE("Compressing DXTn surface.\n");
            switch(surfdesc.Format)
            {
                case D3DFMT_DXT1:
                    gl_format = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
                    break;
                case D3DFMT_DXT2:
                case D3DFMT_DXT3:
                    gl_format = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
                    break;
                case D3DFMT_DXT4:
                case D3DFMT_DXT5:
                    gl_format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
                    break;
                default:
                    ERR("Unexpected destination compressed format %u.\n", surfdesc.Format);
            }
            tx_compress_dxtn(4, dst_size_aligned.width, dst_size_aligned.height,
                    dst_uncompressed, gl_format, lockrect.pBits,
                    lockrect.Pitch * destformatdesc->block_width / destformatdesc->block_byte_count);
            heap_free(dst_uncompressed);
        }
    }
 
    return unlock_surface(dst_surface, &dst_rect_aligned, surface, TRUE);
}

Referenced by D3DXLoadSurfaceFromFileInMemory(), D3DXLoadSurfaceFromSurface(), load_cube_texture_from_dds(), load_surface_from_dds(), load_texture_from_dds(), test_D3DXCreateTextureFromFileInMemory(), test_D3DXLoadSurface(), and test_D3DXSaveSurfaceToFile().

D3DXLoadSurfaceFromResourceA()

HRESULT WINAPI D3DXLoadSurfaceFromResourceA	(	struct IDirect3DSurface9 *	destsurface,
		const PALETTEENTRY *	destpalette,
		const RECT *	destrect,
		HMODULE	srcmodule,
		const char *	resource,
		const RECT *	srcrect,
		DWORD	filter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo
	)

Definition at line 1469 of file surface.c.

{
    UINT data_size;
    HRSRC resinfo;
    void *data;
 
    TRACE("dst_surface %p, dst_palette %p, dst_rect %s, src_module %p, resource %s, "
            "src_rect %s, filter %#x, color_key 0x%08x, src_info %p.\n",
            dst_surface, dst_palette, wine_dbgstr_rect(dst_rect), src_module, debugstr_a(resource),
            wine_dbgstr_rect(src_rect), filter, color_key, src_info);
 
    if (!dst_surface)
        return D3DERR_INVALIDCALL;
 
    if (!(resinfo = FindResourceA(src_module, resource, (const char *)RT_RCDATA))
            /* Try loading the resource as bitmap data (which is in DIB format D3DXIFF_DIB) */
            && !(resinfo = FindResourceA(src_module, resource, (const char *)RT_BITMAP)))
        return D3DXERR_INVALIDDATA;
 
    if (FAILED(load_resource_into_memory(src_module, resinfo, &data, &data_size)))
        return D3DXERR_INVALIDDATA;
 
    return D3DXLoadSurfaceFromFileInMemory(dst_surface, dst_palette, dst_rect,
            data, data_size, src_rect, filter, color_key, src_info);
}

Referenced by test_D3DXLoadSurface().

D3DXLoadSurfaceFromResourceW()

HRESULT WINAPI D3DXLoadSurfaceFromResourceW	(	struct IDirect3DSurface9 *	destsurface,
		const PALETTEENTRY *	destpalette,
		const RECT *	destrect,
		HMODULE	srcmodule,
		const WCHAR *	resource,
		const RECT *	srcrect,
		DWORD	filter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo
	)

Definition at line 1497 of file surface.c.

{
    UINT data_size;
    HRSRC resinfo;
    void *data;
 
    TRACE("dst_surface %p, dst_palette %p, dst_rect %s, src_module %p, resource %s, "
            "src_rect %s, filter %#x, color_key 0x%08x, src_info %p.\n",
            dst_surface, dst_palette, wine_dbgstr_rect(dst_rect), src_module, debugstr_w(resource),
            wine_dbgstr_rect(src_rect), filter, color_key, src_info);
 
    if (!dst_surface)
        return D3DERR_INVALIDCALL;
 
    if (!(resinfo = FindResourceW(src_module, resource, (const WCHAR *)RT_RCDATA))
            /* Try loading the resource as bitmap data (which is in DIB format D3DXIFF_DIB) */
            && !(resinfo = FindResourceW(src_module, resource, (const WCHAR *)RT_BITMAP)))
        return D3DXERR_INVALIDDATA;
 
    if (FAILED(load_resource_into_memory(src_module, resinfo, &data, &data_size)))
        return D3DXERR_INVALIDDATA;
 
    return D3DXLoadSurfaceFromFileInMemory(dst_surface, dst_palette, dst_rect,
            data, data_size, src_rect, filter, color_key, src_info);
}

D3DXLoadSurfaceFromSurface()

HRESULT WINAPI D3DXLoadSurfaceFromSurface	(	struct IDirect3DSurface9 *	destsurface,
		const PALETTEENTRY *	destpalette,
		const RECT *	destrect,
		struct IDirect3DSurface9 *	srcsurface,
		const PALETTEENTRY *	srcpalette,
		const RECT *	srcrect,
		DWORD	filter,
		D3DCOLOR	colorkey
	)

Definition at line 2233 of file surface.c.

{
    const struct pixel_format_desc *src_format_desc, *dst_format_desc;
    D3DSURFACE_DESC src_desc, dst_desc;
    struct volume src_size, dst_size;
    IDirect3DSurface9 *temp_surface;
    D3DTEXTUREFILTERTYPE d3d_filter;
    IDirect3DDevice9 *device;
    D3DLOCKED_RECT lock;
    RECT dst_rect_temp;
    HRESULT hr;
    RECT s;
 
    TRACE("dst_surface %p, dst_palette %p, dst_rect %s, src_surface %p, "
            "src_palette %p, src_rect %s, filter %#x, color_key 0x%08x.\n",
            dst_surface, dst_palette, wine_dbgstr_rect(dst_rect), src_surface,
            src_palette, wine_dbgstr_rect(src_rect), filter, color_key);
 
    if (!dst_surface || !src_surface)
        return D3DERR_INVALIDCALL;
 
    IDirect3DSurface9_GetDesc(src_surface, &src_desc);
    src_format_desc = get_format_info(src_desc.Format);
    if (!src_rect)
    {
        SetRect(&s, 0, 0, src_desc.Width, src_desc.Height);
        src_rect = &s;
    }
    else if (src_rect->left == src_rect->right || src_rect->top == src_rect->bottom)
    {
        WARN("Empty src_rect specified.\n");
        return filter == D3DX_FILTER_NONE ? D3D_OK : E_FAIL;
    }
    else if (src_rect->left > src_rect->right || src_rect->right > src_desc.Width
            || src_rect->left < 0 || src_rect->left > src_desc.Width
            || src_rect->top > src_rect->bottom || src_rect->bottom > src_desc.Height
            || src_rect->top < 0 || src_rect->top > src_desc.Height)
    {
        WARN("Invalid src_rect specified.\n");
        return D3DERR_INVALIDCALL;
    }
 
    src_size.width = src_rect->right - src_rect->left;
    src_size.height = src_rect->bottom - src_rect->top;
    src_size.depth = 1;
 
    IDirect3DSurface9_GetDesc(dst_surface, &dst_desc);
    dst_format_desc = get_format_info(dst_desc.Format);
    if (!dst_rect)
    {
        SetRect(&dst_rect_temp, 0, 0, dst_desc.Width, dst_desc.Height);
        dst_rect = &dst_rect_temp;
    }
    else if (dst_rect->left == dst_rect->right || dst_rect->top == dst_rect->bottom)
    {
        WARN("Empty dst_rect specified.\n");
        return filter == D3DX_FILTER_NONE ? D3D_OK : E_FAIL;
    }
    else if (dst_rect->left > dst_rect->right || dst_rect->right > dst_desc.Width
            || dst_rect->left < 0 || dst_rect->left > dst_desc.Width
            || dst_rect->top > dst_rect->bottom || dst_rect->bottom > dst_desc.Height
            || dst_rect->top < 0 || dst_rect->top > dst_desc.Height)
    {
        WARN("Invalid dst_rect specified.\n");
        return D3DERR_INVALIDCALL;
    }
 
    dst_size.width = dst_rect->right - dst_rect->left;
    dst_size.height = dst_rect->bottom - dst_rect->top;
    dst_size.depth = 1;
 
    if (!dst_palette && !src_palette && !color_key)
    {
        if (src_desc.Format == dst_desc.Format
                && dst_size.width == src_size.width
                && dst_size.height == src_size.height
                && color_key == 0
                && !(src_rect->left & (src_format_desc->block_width - 1))
                && !(src_rect->top & (src_format_desc->block_height - 1))
                && !(dst_rect->left & (dst_format_desc->block_width - 1))
                && !(dst_rect->top & (dst_format_desc->block_height - 1)))
        {
            d3d_filter = D3DTEXF_NONE;
        }
        else
        {
            switch (filter)
            {
                case D3DX_FILTER_NONE:
                    d3d_filter = D3DTEXF_NONE;
                    break;
 
                case D3DX_FILTER_POINT:
                    d3d_filter = D3DTEXF_POINT;
                    break;
 
                case D3DX_FILTER_LINEAR:
                    d3d_filter = D3DTEXF_LINEAR;
                    break;
 
                default:
                    d3d_filter = D3DTEXF_FORCE_DWORD;
                    break;
            }
        }
 
        if (d3d_filter != D3DTEXF_FORCE_DWORD)
        {
            IDirect3DSurface9_GetDevice(src_surface, &device);
            hr = IDirect3DDevice9_StretchRect(device, src_surface, src_rect, dst_surface, dst_rect, d3d_filter);
            IDirect3DDevice9_Release(device);
            if (SUCCEEDED(hr))
                return D3D_OK;
        }
    }
 
    if (FAILED(lock_surface(src_surface, NULL, &lock, &temp_surface, FALSE)))
        return D3DXERR_INVALIDDATA;
 
    hr = D3DXLoadSurfaceFromMemory(dst_surface, dst_palette, dst_rect, lock.pBits,
            src_desc.Format, lock.Pitch, src_palette, src_rect, filter, color_key);
 
    if (FAILED(unlock_surface(src_surface, NULL, temp_surface, FALSE)))
        return D3DXERR_INVALIDDATA;
 
    return hr;
}

Referenced by copy_render_target_to_cube_texture_face(), D3DXFilterTexture(), D3DXRenderToSurface_EndScene(), test_D3DXCreateTextureFromFileInMemory(), and test_D3DXLoadSurface().

D3DXLoadVolumeFromFileA()

HRESULT WINAPI D3DXLoadVolumeFromFileA	(	struct IDirect3DVolume9 *	destvolume,
		const PALETTEENTRY *	destpalette,
		const D3DBOX *	destbox,
		const char *	srcfile,
		const D3DBOX *	srcbox,
		DWORD	filter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo
	)

Definition at line 28 of file volume.c.

{
    HRESULT hr;
    int length;
    WCHAR *filenameW;
 
    TRACE("(%p, %p, %p, %s, %p, %#x, %#x, %p)\n",
            dst_volume, dst_palette, dst_box, debugstr_a(filename), src_box,
            filter, color_key, info);
 
    if (!dst_volume || !filename) return D3DERR_INVALIDCALL;
 
    length = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
    filenameW = HeapAlloc(GetProcessHeap(), 0, length * sizeof(*filenameW));
    if (!filenameW) return E_OUTOFMEMORY;
 
    hr = D3DXLoadVolumeFromFileW(dst_volume, dst_palette, dst_box, filenameW,
            src_box, filter, color_key, info);
    HeapFree(GetProcessHeap(), 0, filenameW);
 
    return hr;
}

D3DXLoadVolumeFromFileInMemory()

HRESULT WINAPI D3DXLoadVolumeFromFileInMemory	(	struct IDirect3DVolume9 *	destvolume,
		const PALETTEENTRY *	destpalette,
		const D3DBOX *	destbox,
		const void *	srcdata,
		UINT	srcdatasize,
		const D3DBOX *	srcbox,
		DWORD	filter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo
	)

Definition at line 230 of file volume.c.

{
    HRESULT hr;
    D3DBOX box;
    D3DXIMAGE_INFO image_info;
 
    TRACE("dst_volume %p, dst_palette %p, dst_box %p, src_data %p, src_data_size %u, src_box %p, "
            "filter %#x, color_key 0x%08x, src_info %p.\n",
            dst_volume, dst_palette, dst_box, src_data, src_data_size, src_box,
            filter, color_key, src_info);
 
    if (!dst_volume || !src_data)
        return D3DERR_INVALIDCALL;
 
    if (FAILED(hr = D3DXGetImageInfoFromFileInMemory(src_data, src_data_size, &image_info)))
        return hr;
 
    if (src_box)
    {
        if (src_box->Right > image_info.Width
                || src_box->Bottom > image_info.Height
                || src_box->Back > image_info.Depth)
            return D3DERR_INVALIDCALL;
 
        box = *src_box;
    }
    else
    {
        box.Left = 0;
        box.Top = 0;
        box.Right = image_info.Width;
        box.Bottom = image_info.Height;
        box.Front = 0;
        box.Back = image_info.Depth;
 
    }
 
    if (image_info.ImageFileFormat != D3DXIFF_DDS)
    {
        FIXME("File format %#x is not supported yet\n", image_info.ImageFileFormat);
        return E_NOTIMPL;
    }
 
    hr = load_volume_from_dds(dst_volume, dst_palette, dst_box, src_data, &box,
            filter, color_key, &image_info);
    if (FAILED(hr)) return hr;
 
    if (src_info)
        *src_info = image_info;
 
    return D3D_OK;
}

Referenced by D3DXLoadVolumeFromFileW(), and test_D3DXLoadVolumeFromFileInMemory().

D3DXLoadVolumeFromFileW()

HRESULT WINAPI D3DXLoadVolumeFromFileW	(	struct IDirect3DVolume9 *	destvolume,
		const PALETTEENTRY *	destpalette,
		const D3DBOX *	destbox,
		const WCHAR *	srcfile,
		const D3DBOX *	srcbox,
		DWORD	filter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo
	)

Definition at line 58 of file volume.c.

{
    HRESULT hr;
    void *data;
    UINT data_size;
 
    TRACE("(%p, %p, %p, %s, %p, %#x, %#x, %p)\n",
            dst_volume, dst_palette, dst_box, debugstr_w(filename), src_box,
            filter, color_key, info);
 
    if (!dst_volume || !filename) return D3DERR_INVALIDCALL;
 
    if (FAILED(map_view_of_file(filename, &data, &data_size)))
        return D3DXERR_INVALIDDATA;
 
    hr = D3DXLoadVolumeFromFileInMemory(dst_volume, dst_palette, dst_box,
            data, data_size, src_box, filter, color_key, info);
    UnmapViewOfFile(data);
 
    return hr;
}

Referenced by D3DXLoadVolumeFromFileA().

D3DXLoadVolumeFromMemory()

HRESULT WINAPI D3DXLoadVolumeFromMemory	(	struct IDirect3DVolume9 *	destvolume,
		const PALETTEENTRY *	destpalette,
		const D3DBOX *	destbox,
		const void *	srcmemory,
		D3DFORMAT	srcformat,
		UINT	srcrowpitch,
		UINT	srcslicepitch,
		const PALETTEENTRY *	srcpalette,
		const D3DBOX *	srcbox,
		DWORD	filter,
		D3DCOLOR	colorkey
	)

Definition at line 87 of file volume.c.

{
    HRESULT hr;
    D3DVOLUME_DESC desc;
    D3DLOCKED_BOX locked_box;
    struct volume dst_size, src_size;
    const struct pixel_format_desc *src_format_desc, *dst_format_desc;
 
    TRACE("(%p, %p, %p, %p, %#x, %u, %u, %p, %p, %x, %x)\n", dst_volume, dst_palette, dst_box,
            src_memory, src_format, src_row_pitch, src_slice_pitch, src_palette, src_box,
            filter, color_key);
 
    if (!dst_volume || !src_memory || !src_box) return D3DERR_INVALIDCALL;
 
    if (src_format == D3DFMT_UNKNOWN
            || src_box->Left >= src_box->Right
            || src_box->Top >= src_box->Bottom
            || src_box->Front >= src_box->Back)
        return E_FAIL;
 
    if (filter == D3DX_DEFAULT)
        filter = D3DX_FILTER_TRIANGLE | D3DX_FILTER_DITHER;
 
    IDirect3DVolume9_GetDesc(dst_volume, &desc);
 
    src_size.width = src_box->Right - src_box->Left;
    src_size.height = src_box->Bottom - src_box->Top;
    src_size.depth = src_box->Back - src_box->Front;
 
    if (!dst_box)
    {
        dst_size.width = desc.Width;
        dst_size.height = desc.Height;
        dst_size.depth = desc.Depth;
    }
    else
    {
        if (dst_box->Left >= dst_box->Right || dst_box->Right > desc.Width)
            return D3DERR_INVALIDCALL;
        if (dst_box->Top >= dst_box->Bottom || dst_box->Bottom > desc.Height)
            return D3DERR_INVALIDCALL;
        if (dst_box->Front >= dst_box->Back || dst_box->Back > desc.Depth)
            return D3DERR_INVALIDCALL;
 
        dst_size.width = dst_box->Right - dst_box->Left;
        dst_size.height = dst_box->Bottom - dst_box->Top;
        dst_size.depth = dst_box->Back - dst_box->Front;
    }
 
    src_format_desc = get_format_info(src_format);
    if (src_format_desc->type == FORMAT_UNKNOWN)
        return E_NOTIMPL;
 
    dst_format_desc = get_format_info(desc.Format);
    if (dst_format_desc->type == FORMAT_UNKNOWN)
        return E_NOTIMPL;
 
    if (desc.Format == src_format
            && dst_size.width == src_size.width
            && dst_size.height == src_size.height
            && dst_size.depth == src_size.depth
            && color_key == 0)
    {
        const BYTE *src_addr;
 
        if (src_box->Left & (src_format_desc->block_width - 1)
                || src_box->Top & (src_format_desc->block_height - 1)
                || (src_box->Right & (src_format_desc->block_width - 1)
                    && src_size.width != desc.Width)
                || (src_box->Bottom & (src_format_desc->block_height - 1)
                    && src_size.height != desc.Height))
        {
            FIXME("Source box (%u, %u, %u, %u) is misaligned\n",
                    src_box->Left, src_box->Top, src_box->Right, src_box->Bottom);
            return E_NOTIMPL;
        }
 
        src_addr = src_memory;
        src_addr += src_box->Front * src_slice_pitch;
        src_addr += (src_box->Top / src_format_desc->block_height) * src_row_pitch;
        src_addr += (src_box->Left / src_format_desc->block_width) * src_format_desc->block_byte_count;
 
        hr = IDirect3DVolume9_LockBox(dst_volume, &locked_box, dst_box, 0);
        if (FAILED(hr)) return hr;
 
        copy_pixels(src_addr, src_row_pitch, src_slice_pitch,
                locked_box.pBits, locked_box.RowPitch, locked_box.SlicePitch,
                &dst_size, dst_format_desc);
 
        IDirect3DVolume9_UnlockBox(dst_volume);
    }
    else
    {
        const BYTE *src_addr;
 
        if (!is_conversion_from_supported(src_format_desc)
                || !is_conversion_to_supported(dst_format_desc))
        {
            FIXME("Pixel format conversion is not implemented %#x -> %#x\n",
                    src_format_desc->format, dst_format_desc->format);
            return E_NOTIMPL;
        }
 
        src_addr = src_memory;
        src_addr += src_box->Front * src_slice_pitch;
        src_addr += src_box->Top * src_row_pitch;
        src_addr += src_box->Left * src_format_desc->bytes_per_pixel;
 
        hr = IDirect3DVolume9_LockBox(dst_volume, &locked_box, dst_box, 0);
        if (FAILED(hr)) return hr;
 
        if ((filter & 0xf) == D3DX_FILTER_NONE)
        {
            convert_argb_pixels(src_memory, src_row_pitch, src_slice_pitch, &src_size, src_format_desc,
                    locked_box.pBits, locked_box.RowPitch, locked_box.SlicePitch, &dst_size, dst_format_desc, color_key,
                    src_palette);
        }
        else
        {
            if ((filter & 0xf) != D3DX_FILTER_POINT)
                FIXME("Unhandled filter %#x.\n", filter);
 
            point_filter_argb_pixels(src_addr, src_row_pitch, src_slice_pitch, &src_size, src_format_desc,
                    locked_box.pBits, locked_box.RowPitch, locked_box.SlicePitch, &dst_size, dst_format_desc, color_key,
                    src_palette);
        }
 
        IDirect3DVolume9_UnlockBox(dst_volume);
    }
 
    return D3D_OK;
}

Referenced by D3DXLoadVolumeFromVolume(), load_volume_from_dds(), load_volume_texture_from_dds(), and test_D3DXLoadVolumeFromMemory().

D3DXLoadVolumeFromResourceA()

HRESULT WINAPI D3DXLoadVolumeFromResourceA	(	struct IDirect3DVolume9 *	destvolume,
		const PALETTEENTRY *	destpalette,
		const D3DBOX *	destbox,
		HMODULE	srcmodule,
		const char *	resource,
		const D3DBOX *	srcbox,
		DWORD	filter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo
	)

D3DXLoadVolumeFromResourceW()

HRESULT WINAPI D3DXLoadVolumeFromResourceW	(	struct IDirect3DVolume9 *	destvolume,
		const PALETTEENTRY *	destpalette,
		const D3DBOX *	destbox,
		HMODULE	srcmodule,
		const WCHAR *	resource,
		const D3DBOX *	srcbox,
		DWORD	filter,
		D3DCOLOR	colorkey,
		D3DXIMAGE_INFO *	srcinfo
	)

D3DXLoadVolumeFromVolume()

HRESULT WINAPI D3DXLoadVolumeFromVolume	(	struct IDirect3DVolume9 *	destvolume,
		const PALETTEENTRY *	destpalette,
		const D3DBOX *	destbox,
		struct IDirect3DVolume9 *	srcvolume,
		const PALETTEENTRY *	srcpalette,
		const D3DBOX *	srcbox,
		DWORD	filter,
		D3DCOLOR	colorkey
	)

Definition at line 291 of file volume.c.

{
    HRESULT hr;
    D3DBOX box;
    D3DVOLUME_DESC desc;
    D3DLOCKED_BOX locked_box;
 
    TRACE("(%p, %p, %p, %p, %p, %p, %#x, %#x)\n",
            dst_volume, dst_palette, dst_box, src_volume, src_palette, src_box,
            filter, color_key);
 
    if (!dst_volume || !src_volume) return D3DERR_INVALIDCALL;
 
    IDirect3DVolume9_GetDesc(src_volume, &desc);
 
    if (!src_box)
    {
        box.Left = box.Top = 0;
        box.Right = desc.Width;
        box.Bottom = desc.Height;
        box.Front = 0;
        box.Back = desc.Depth;
    }
    else box = *src_box;
 
    hr = IDirect3DVolume9_LockBox(src_volume, &locked_box, NULL, D3DLOCK_READONLY);
    if (FAILED(hr)) return hr;
 
    hr = D3DXLoadVolumeFromMemory(dst_volume, dst_palette, dst_box,
            locked_box.pBits, desc.Format, locked_box.RowPitch, locked_box.SlicePitch,
            src_palette, &box, filter, color_key);
 
    IDirect3DVolume9_UnlockBox(src_volume);
    return hr;
}

Referenced by D3DXFilterTexture().

D3DXSaveSurfaceToFileA()

HRESULT WINAPI D3DXSaveSurfaceToFileA	(	const char *	destfile,
		D3DXIMAGE_FILEFORMAT	destformat,
		struct IDirect3DSurface9 *	srcsurface,
		const PALETTEENTRY *	srcpalette,
		const RECT *	srcrect
	)

Definition at line 2364 of file surface.c.

{
    int len;
    WCHAR *filename;
    HRESULT hr;
    ID3DXBuffer *buffer;
 
    TRACE("(%s, %#x, %p, %p, %s): relay\n",
            wine_dbgstr_a(dst_filename), file_format, src_surface, src_palette, wine_dbgstr_rect(src_rect));
 
    if (!dst_filename) return D3DERR_INVALIDCALL;
 
    len = MultiByteToWideChar(CP_ACP, 0, dst_filename, -1, NULL, 0);
    filename = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
    if (!filename) return E_OUTOFMEMORY;
    MultiByteToWideChar(CP_ACP, 0, dst_filename, -1, filename, len);
 
    hr = D3DXSaveSurfaceToFileInMemory(&buffer, file_format, src_surface, src_palette, src_rect);
    if (SUCCEEDED(hr))
    {
        hr = write_buffer_to_file(filename, buffer);
        ID3DXBuffer_Release(buffer);
    }
 
    HeapFree(GetProcessHeap(), 0, filename);
    return hr;
}

Referenced by test_D3DXSaveSurfaceToFile().

D3DXSaveSurfaceToFileInMemory()

HRESULT WINAPI D3DXSaveSurfaceToFileInMemory	(	struct ID3DXBuffer **	destbuffer,
		D3DXIMAGE_FILEFORMAT	destformat,
		struct IDirect3DSurface9 *	srcsurface,
		const PALETTEENTRY *	srcpalette,
		const RECT *	srcrect
	)

Definition at line 2414 of file surface.c.

{
    IWICBitmapEncoder *encoder = NULL;
    IWICBitmapFrameEncode *frame = NULL;
    IPropertyBag2 *encoder_options = NULL;
    IStream *stream = NULL;
    HRESULT hr;
    const GUID *container_format;
    const GUID *pixel_format_guid;
    WICPixelFormatGUID wic_pixel_format;
    IWICImagingFactory *factory;
    D3DFORMAT d3d_pixel_format;
    D3DSURFACE_DESC src_surface_desc;
    IDirect3DSurface9 *temp_surface;
    D3DLOCKED_RECT locked_rect;
    int width, height;
    STATSTG stream_stats;
    HGLOBAL stream_hglobal;
    ID3DXBuffer *buffer;
    DWORD size;
 
    TRACE("dst_buffer %p, file_format %#x, src_surface %p, src_palette %p, src_rect %s.\n",
        dst_buffer, file_format, src_surface, src_palette, wine_dbgstr_rect(src_rect));
 
    if (!dst_buffer || !src_surface) return D3DERR_INVALIDCALL;
 
    if (src_palette)
    {
        FIXME("Saving surfaces with palettized pixel formats is not implemented yet\n");
        return D3DERR_INVALIDCALL;
    }
 
    switch (file_format)
    {
        case D3DXIFF_BMP:
        case D3DXIFF_DIB:
            container_format = &GUID_ContainerFormatBmp;
            break;
        case D3DXIFF_PNG:
            container_format = &GUID_ContainerFormatPng;
            break;
        case D3DXIFF_JPG:
            container_format = &GUID_ContainerFormatJpeg;
            break;
        case D3DXIFF_DDS:
            return save_dds_surface_to_memory(dst_buffer, src_surface, src_rect);
        case D3DXIFF_HDR:
        case D3DXIFF_PFM:
        case D3DXIFF_TGA:
        case D3DXIFF_PPM:
            FIXME("File format %#x is not supported yet\n", file_format);
            return E_NOTIMPL;
        default:
            return D3DERR_INVALIDCALL;
    }
 
    IDirect3DSurface9_GetDesc(src_surface, &src_surface_desc);
    if (src_rect)
    {
        if (src_rect->left == src_rect->right || src_rect->top == src_rect->bottom)
        {
            WARN("Invalid rectangle with 0 area\n");
            return D3DXCreateBuffer(64, dst_buffer);
        }
        if (src_rect->left < 0 || src_rect->top < 0)
            return D3DERR_INVALIDCALL;
        if (src_rect->left > src_rect->right || src_rect->top > src_rect->bottom)
            return D3DERR_INVALIDCALL;
        if (src_rect->right > src_surface_desc.Width || src_rect->bottom > src_surface_desc.Height)
            return D3DERR_INVALIDCALL;
 
        width = src_rect->right - src_rect->left;
        height = src_rect->bottom - src_rect->top;
    }
    else
    {
        width = src_surface_desc.Width;
        height = src_surface_desc.Height;
    }
 
    hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
    if (FAILED(hr)) goto cleanup_err;
 
    hr = IWICImagingFactory_CreateEncoder(factory, container_format, NULL, &encoder);
    IWICImagingFactory_Release(factory);
    if (FAILED(hr)) goto cleanup_err;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    if (FAILED(hr)) goto cleanup_err;
 
    hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache);
    if (FAILED(hr)) goto cleanup_err;
 
    hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frame, &encoder_options);
    if (FAILED(hr)) goto cleanup_err;
 
    hr = IWICBitmapFrameEncode_Initialize(frame, encoder_options);
    if (FAILED(hr)) goto cleanup_err;
 
    hr = IWICBitmapFrameEncode_SetSize(frame, width, height);
    if (FAILED(hr)) goto cleanup_err;
 
    pixel_format_guid = d3dformat_to_wic_guid(src_surface_desc.Format);
    if (!pixel_format_guid)
    {
        FIXME("Pixel format %#x is not supported yet\n", src_surface_desc.Format);
        hr = E_NOTIMPL;
        goto cleanup;
    }
 
    memcpy(&wic_pixel_format, pixel_format_guid, sizeof(GUID));
    hr = IWICBitmapFrameEncode_SetPixelFormat(frame, &wic_pixel_format);
    d3d_pixel_format = wic_guid_to_d3dformat(&wic_pixel_format);
    if (SUCCEEDED(hr) && d3d_pixel_format != D3DFMT_UNKNOWN)
    {
        TRACE("Using pixel format %s %#x\n", debugstr_guid(&wic_pixel_format), d3d_pixel_format);
        if (src_surface_desc.Format == d3d_pixel_format) /* Simple copy */
        {
            if (FAILED(hr = lock_surface(src_surface, src_rect, &locked_rect, &temp_surface, FALSE)))
                goto cleanup;
 
            IWICBitmapFrameEncode_WritePixels(frame, height,
                locked_rect.Pitch, height * locked_rect.Pitch, locked_rect.pBits);
            unlock_surface(src_surface, src_rect, temp_surface, FALSE);
        }
        else /* Pixel format conversion */
        {
            const struct pixel_format_desc *src_format_desc, *dst_format_desc;
            struct volume size;
            DWORD dst_pitch;
            void *dst_data;
 
            src_format_desc = get_format_info(src_surface_desc.Format);
            dst_format_desc = get_format_info(d3d_pixel_format);
            if (!is_conversion_from_supported(src_format_desc)
                    || !is_conversion_to_supported(dst_format_desc))
            {
                FIXME("Unsupported format conversion %#x -> %#x.\n",
                    src_surface_desc.Format, d3d_pixel_format);
                hr = E_NOTIMPL;
                goto cleanup;
            }
 
            size.width = width;
            size.height = height;
            size.depth = 1;
            dst_pitch = width * dst_format_desc->bytes_per_pixel;
            dst_data = HeapAlloc(GetProcessHeap(), 0, dst_pitch * height);
            if (!dst_data)
            {
                hr = E_OUTOFMEMORY;
                goto cleanup;
            }
            if (FAILED(hr = lock_surface(src_surface, src_rect, &locked_rect, &temp_surface, FALSE)))
            {
                HeapFree(GetProcessHeap(), 0, dst_data);
                goto cleanup;
            }
            convert_argb_pixels(locked_rect.pBits, locked_rect.Pitch, 0, &size, src_format_desc,
                dst_data, dst_pitch, 0, &size, dst_format_desc, 0, NULL);
            unlock_surface(src_surface, src_rect, temp_surface, FALSE);
 
            IWICBitmapFrameEncode_WritePixels(frame, height, dst_pitch, dst_pitch * height, dst_data);
            HeapFree(GetProcessHeap(), 0, dst_data);
        }
 
        hr = IWICBitmapFrameEncode_Commit(frame);
        if (SUCCEEDED(hr)) hr = IWICBitmapEncoder_Commit(encoder);
    }
    else WARN("Unsupported pixel format %#x\n", src_surface_desc.Format);
 
    /* copy data from stream to ID3DXBuffer */
    hr = IStream_Stat(stream, &stream_stats, STATFLAG_NONAME);
    if (FAILED(hr)) goto cleanup_err;
 
    if (stream_stats.cbSize.u.HighPart != 0)
    {
        hr = D3DXERR_INVALIDDATA;
        goto cleanup;
    }
    size = stream_stats.cbSize.u.LowPart;
 
    /* Remove BMP header for DIB */
    if (file_format == D3DXIFF_DIB)
        size -= sizeof(BITMAPFILEHEADER);
 
    hr = D3DXCreateBuffer(size, &buffer);
    if (FAILED(hr)) goto cleanup;
 
    hr = GetHGlobalFromStream(stream, &stream_hglobal);
    if (SUCCEEDED(hr))
    {
        void *buffer_pointer = ID3DXBuffer_GetBufferPointer(buffer);
        void *stream_data = GlobalLock(stream_hglobal);
        /* Remove BMP header for DIB */
        if (file_format == D3DXIFF_DIB)
            stream_data = (void*)((BYTE*)stream_data + sizeof(BITMAPFILEHEADER));
        memcpy(buffer_pointer, stream_data, size);
        GlobalUnlock(stream_hglobal);
        *dst_buffer = buffer;
    }
    else ID3DXBuffer_Release(buffer);
 
cleanup_err:
    if (FAILED(hr) && hr != E_OUTOFMEMORY)
        hr = D3DERR_INVALIDCALL;
 
cleanup:
    if (stream) IStream_Release(stream);
 
    if (frame) IWICBitmapFrameEncode_Release(frame);
    if (encoder_options) IPropertyBag2_Release(encoder_options);
 
    if (encoder) IWICBitmapEncoder_Release(encoder);
 
    return hr;
}

Referenced by D3DXSaveSurfaceToFileA(), D3DXSaveSurfaceToFileW(), D3DXSaveTextureToFileInMemory(), and test_D3DXSaveSurfaceToFileInMemory().

D3DXSaveSurfaceToFileW()

HRESULT WINAPI D3DXSaveSurfaceToFileW	(	const WCHAR *	destfile,
		D3DXIMAGE_FILEFORMAT	destformat,
		struct IDirect3DSurface9 *	srcsurface,
		const PALETTEENTRY *	srcpalette,
		const RECT *	srcrect
	)

Definition at line 2393 of file surface.c.

{
    HRESULT hr;
    ID3DXBuffer *buffer;
 
    TRACE("(%s, %#x, %p, %p, %s): relay\n",
        wine_dbgstr_w(dst_filename), file_format, src_surface, src_palette, wine_dbgstr_rect(src_rect));
 
    if (!dst_filename) return D3DERR_INVALIDCALL;
 
    hr = D3DXSaveSurfaceToFileInMemory(&buffer, file_format, src_surface, src_palette, src_rect);
    if (SUCCEEDED(hr))
    {
        hr = write_buffer_to_file(dst_filename, buffer);
        ID3DXBuffer_Release(buffer);
    }
 
    return hr;
}

D3DXSaveTextureToFileA()

HRESULT WINAPI D3DXSaveTextureToFileA	(	const char *	destfile,
		D3DXIMAGE_FILEFORMAT	destformat,
		struct IDirect3DBaseTexture9 *	srctexture,
		const PALETTEENTRY *	srcpalette
	)

Definition at line 1839 of file texture.c.

{
    int len;
    WCHAR *filename;
    HRESULT hr;
    ID3DXBuffer *buffer;
 
    TRACE("(%s, %#x, %p, %p): relay\n",
            wine_dbgstr_a(dst_filename), file_format, src_texture, src_palette);
 
    if (!dst_filename) return D3DERR_INVALIDCALL;
 
    len = MultiByteToWideChar(CP_ACP, 0, dst_filename, -1, NULL, 0);
    filename = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
    if (!filename) return E_OUTOFMEMORY;
    MultiByteToWideChar(CP_ACP, 0, dst_filename, -1, filename, len);
 
    hr = D3DXSaveTextureToFileInMemory(&buffer, file_format, src_texture, src_palette);
    if (SUCCEEDED(hr))
    {
        hr = write_buffer_to_file(filename, buffer);
        ID3DXBuffer_Release(buffer);
    }
 
    HeapFree(GetProcessHeap(), 0, filename);
    return hr;
}

D3DXSaveTextureToFileInMemory()

HRESULT WINAPI D3DXSaveTextureToFileInMemory	(	struct ID3DXBuffer **	destbuffer,
		D3DXIMAGE_FILEFORMAT	destformat,
		struct IDirect3DBaseTexture9 *	srctexture,
		const PALETTEENTRY *	srcpalette
	)

Definition at line 1889 of file texture.c.

{
    HRESULT hr;
    D3DRESOURCETYPE type;
    IDirect3DSurface9 *surface;
 
    TRACE("(%p, %#x, %p, %p)\n",
        dst_buffer, file_format, src_texture, src_palette);
 
    if (!dst_buffer || !src_texture) return D3DERR_INVALIDCALL;
 
    if (file_format == D3DXIFF_DDS)
        return save_dds_texture_to_memory(dst_buffer, src_texture, src_palette);
 
    type = IDirect3DBaseTexture9_GetType(src_texture);
    switch (type)
    {
        case D3DRTYPE_TEXTURE:
        case D3DRTYPE_CUBETEXTURE:
            hr = get_surface(type, src_texture, D3DCUBEMAP_FACE_POSITIVE_X, 0, &surface);
            break;
        case D3DRTYPE_VOLUMETEXTURE:
            FIXME("Volume textures aren't supported yet\n");
            return E_NOTIMPL;
        default:
            return D3DERR_INVALIDCALL;
    }
 
    if (SUCCEEDED(hr))
    {
        hr = D3DXSaveSurfaceToFileInMemory(dst_buffer, file_format, surface, src_palette, NULL);
        IDirect3DSurface9_Release(surface);
    }
 
    return hr;
}

Referenced by D3DXSaveTextureToFileA(), D3DXSaveTextureToFileW(), and test_D3DXSaveTextureToFileInMemory().

D3DXSaveTextureToFileW()

HRESULT WINAPI D3DXSaveTextureToFileW	(	const WCHAR *	destfile,
		D3DXIMAGE_FILEFORMAT	destformat,
		struct IDirect3DBaseTexture9 *	srctexture,
		const PALETTEENTRY *	srcpalette
	)

Definition at line 1868 of file texture.c.

{
    HRESULT hr;
    ID3DXBuffer *buffer;
 
    TRACE("(%s, %#x, %p, %p): relay\n",
        wine_dbgstr_w(dst_filename), file_format, src_texture, src_palette);
 
    if (!dst_filename) return D3DERR_INVALIDCALL;
 
    hr = D3DXSaveTextureToFileInMemory(&buffer, file_format, src_texture, src_palette);
    if (SUCCEEDED(hr))
    {
        hr = write_buffer_to_file(dst_filename, buffer);
        ID3DXBuffer_Release(buffer);
    }
 
    return hr;
}

D3DXSaveVolumeToFileA()

HRESULT WINAPI D3DXSaveVolumeToFileA	(	const char *	destfile,
		D3DXIMAGE_FILEFORMAT	destformat,
		struct IDirect3DVolume9 *	srcvolume,
		const PALETTEENTRY *	srcpalette,
		const D3DBOX *	srcbox
	)

D3DXSaveVolumeToFileW()

HRESULT WINAPI D3DXSaveVolumeToFileW	(	const WCHAR *	destfile,
		D3DXIMAGE_FILEFORMAT	destformat,
		struct IDirect3DVolume9 *	srcvolume,
		const PALETTEENTRY *	srcpalette,
		const D3DBOX *	srcbox
	)