d3dx9mesh.h File Reference

#include <d3dx9.h>

Include dependency graph for d3dx9mesh.h:

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

Go to the source code of this file.

Classes
struct	_D3DXATTRIBUTERANGE
struct	_D3DXMATERIAL
struct	_D3DXEFFECTDEFAULT
struct	_D3DXEFFECTINSTANCE
struct	_D3DXATTRIBUTEWEIGHTS
struct	_D3DXWELDEPSILONS
struct	_D3DXBONECOMBINATION
struct	_D3DXPATCHINFO
struct	_D3DXINTERSECTINFO
struct	_D3DXSHMATERIAL
struct	_D3DXSHPRTSPLITMESHVERTDATA
struct	_D3DXSHPRTSPLITMESHCLUSTERDATA
struct	_XFILECOMPRESSEDANIMATIONSET

Macros
#define	UNUSED16   (0xffff)
#define	UNUSED32   (0xffffffff)
#define	INTERFACE   ID3DXBaseMesh
#define	INTERFACE   ID3DXMesh
#define	INTERFACE   ID3DXPMesh
#define	INTERFACE   ID3DXSPMesh
#define	INTERFACE   ID3DXPatchMesh
#define	INTERFACE   ID3DXSkinInfo
#define	INTERFACE   ID3DXPRTBuffer
#define	INTERFACE   ID3DXPRTCompBuffer
#define	INTERFACE   ID3DXTextureGutterHelper
#define	INTERFACE   ID3DXPRTEngine
#define	D3DXLoadMeshFromX   WINELIB_NAME_AW(D3DXLoadMeshFromX)
#define	D3DXLoadPRTBufferFromFile   WINELIB_NAME_AW(D3DXLoadPRTBufferFromFile)
#define	D3DXLoadPRTCompBufferFromFile   WINELIB_NAME_AW(D3DXLoadPRTCompBufferFromFile)
#define	D3DXSaveMeshToX   WINELIB_NAME_AW(D3DXSaveMeshToX)
#define	D3DXSavePRTBufferToFile   WINELIB_NAME_AW(D3DXSavePRTBufferToFile)
#define	D3DXSavePRTCompBufferToFile   WINELIB_NAME_AW(D3DXSavePRTCompBufferToFile)
#define	XSKINEXP_TEMPLATES    "xof 0303txt 0032\ template XSkinMeshHeader \ { \ <3CF169CE-FF7C-44ab-93C0-F78F62D172E2> \ WORD nMaxSkinWeightsPerVertex; \ WORD nMaxSkinWeightsPerFace; \ WORD nBones; \ } \ template VertexDuplicationIndices \ { \ <B8D65549-D7C9-4995-89CF-53A9A8B031E3> \ DWORD nIndices; \ DWORD nOriginalVertices; \ array DWORD indices[nIndices]; \ } \ template FaceAdjacency \ { \ <A64C844A-E282-4756-8B80-250CDE04398C> \ DWORD nIndices; \ array DWORD indices[nIndices]; \ } \ template SkinWeights \ { \ <6F0D123B-BAD2-4167-A0D0-80224F25FABB> \ STRING transformNodeName; \ DWORD nWeights; \ array DWORD vertexIndices[nWeights]; \ array float weights[nWeights]; \ Matrix4x4 matrixOffset; \ } \ template Patch \ { \ <A3EB5D44-FC22-429D-9AFB-3221CB9719A6> \ DWORD nControlIndices; \ array DWORD controlIndices[nControlIndices]; \ } \ template PatchMesh \ { \ <D02C95CC-EDBA-4305-9B5D-1820D7704BBF> \ DWORD nVertices; \ array Vector vertices[nVertices]; \ DWORD nPatches; \ array Patch patches[nPatches]; \ [ ... ] \ } \ template PatchMesh9 \ { \ <B9EC94E1-B9A6-4251-BA18-94893F02C0EA> \ DWORD Type; \ DWORD Degree; \ DWORD Basis; \ DWORD nVertices; \ array Vector vertices[nVertices]; \ DWORD nPatches; \ array Patch patches[nPatches]; \ [ ... ] \ } template EffectFloats \ { \ <F1CFE2B3-0DE3-4e28-AFA1-155A750A282D> \ DWORD nFloats; \ array float Floats[nFloats]; \ } \ template EffectString \ { \ <D55B097E-BDB6-4c52-B03D-6051C89D0E42> \ STRING Value; \ } \ template EffectDWord \ { \ <622C0ED0-956E-4da9-908A-2AF94F3CE716> \ DWORD Value; \ } template EffectParamFloats \ { \ <3014B9A0-62F5-478c-9B86-E4AC9F4E418B> \ STRING ParamName; \ DWORD nFloats; \ array float Floats[nFloats]; \ } template EffectParamString \ { \ <1DBC4C88-94C1-46ee-9076-2C28818C9481> \ STRING ParamName; \ STRING Value; \ } \ template EffectParamDWord \ { \ <E13963BC-AE51-4c5d-B00F-CFA3A9D97CE5> \ STRING ParamName; \ DWORD Value; \ } \ template EffectInstance \ { \ <E331F7E4-0559-4cc2-8E99-1CEC1657928F> \ STRING EffectFilename; \ [ ... ] \ } template AnimTicksPerSecond \ { \ <9E415A43-7BA6-4a73-8743-B73D47E88476> \ DWORD AnimTicksPerSecond; \ } \ template CompressedAnimationSet \ { \ <7F9B00B3-F125-4890-876E-1C42BF697C4D> \ DWORD CompressedBlockSize; \ FLOAT TicksPerSec; \ DWORD PlaybackType; \ DWORD BufferLength; \ array DWORD CompressedData[BufferLength]; \ } "
#define	XEXTENSIONS_TEMPLATES    "xof 0303txt 0032\ template FVFData \ { \ <B6E70A0E-8EF9-4e83-94AD-ECC8B0C04897> \ DWORD dwFVF; \ DWORD nDWords; \ array DWORD data[nDWords]; \ } \ template VertexElement \ { \ <F752461C-1E23-48f6-B9F8-8350850F336F> \ DWORD Type; \ DWORD Method; \ DWORD Usage; \ DWORD UsageIndex; \ } \ template DeclData \ { \ <BF22E553-292C-4781-9FEA-62BD554BDD93> \ DWORD nElements; \ array VertexElement Elements[nElements]; \ DWORD nDWords; \ array DWORD data[nDWords]; \ } \ template PMAttributeRange \ { \ <917E0427-C61E-4a14-9C64-AFE65F9E9844> \ DWORD iFaceOffset; \ DWORD nFacesMin; \ DWORD nFacesMax; \ DWORD iVertexOffset; \ DWORD nVerticesMin; \ DWORD nVerticesMax; \ } \ template PMVSplitRecord \ { \ <574CCC14-F0B3-4333-822D-93E8A8A08E4C> \ DWORD iFaceCLW; \ DWORD iVlrOffset; \ DWORD iCode; \ } \ template PMInfo \ { \ <B6C3E656-EC8B-4b92-9B62-681659522947> \ DWORD nAttributes; \ array PMAttributeRange attributeRanges[nAttributes]; \ DWORD nMaxValence; \ DWORD nMinLogicalVertices; \ DWORD nMaxLogicalVertices; \ DWORD nVSplits; \ array PMVSplitRecord splitRecords[nVSplits]; \ DWORD nAttributeMispredicts; \ array DWORD attributeMispredicts[nAttributeMispredicts]; \ } "

Typedefs
typedef enum _D3DXPATCHMESHTYPE	D3DXPATCHMESHTYPE
typedef enum D3DXCLEANTYPE	D3DXCLEANTYPE
typedef enum _D3DXTANGENT	D3DXTANGENT
typedef enum _D3DXIMT	D3DXIMT
typedef enum _D3DXUVATLAS	D3DXUVATLAS
typedef enum _D3DXEFFECTDEFAULTTYPE	D3DXEFFECTDEFAULTTYPE
typedef enum _D3DXSHCOMPRESSQUALITYTYPE	D3DXSHCOMPRESSQUALITYTYPE
typedef enum _D3DXSHGPUSIMOPT	D3DXSHGPUSIMOPT
typedef struct ID3DXBaseMesh *	LPD3DXBASEMESH
typedef struct ID3DXMesh *	LPD3DXMESH
typedef struct ID3DXPMesh *	LPD3DXPMESH
typedef struct ID3DXSPMesh *	LPD3DXSPMESH
typedef struct ID3DXSkinInfo *	LPD3DXSKININFO
typedef struct ID3DXPatchMesh *	LPD3DXPATCHMESH
typedef struct ID3DXPRTBuffer *	LPD3DXPRTBUFFER
typedef struct ID3DXPRTCompBuffer *	LPD3DXPRTCOMPBUFFER
typedef struct ID3DXPRTEngine *	LPD3DXPRTENGINE
typedef struct ID3DXTextureGutterHelper *	LPD3DXTEXTUREGUTTERHELPER
typedef struct _D3DXATTRIBUTERANGE	D3DXATTRIBUTERANGE
typedef D3DXATTRIBUTERANGE *	LPD3DXATTRIBUTERANGE
typedef struct _D3DXMATERIAL	D3DXMATERIAL
typedef struct _D3DXMATERIAL *	LPD3DXMATERIAL
typedef struct _D3DXEFFECTDEFAULT	D3DXEFFECTDEFAULT
typedef struct _D3DXEFFECTDEFAULT *	LPD3DXEFFECTDEFAULT
typedef struct _D3DXEFFECTINSTANCE	D3DXEFFECTINSTANCE
typedef struct _D3DXEFFECTINSTANCE *	LPD3DXEFFECTINSTANCE
typedef struct _D3DXATTRIBUTEWEIGHTS	D3DXATTRIBUTEWEIGHTS
typedef struct _D3DXATTRIBUTEWEIGHTS *	LPD3DXATTRIBUTEWEIGHTS
typedef struct _D3DXWELDEPSILONS	D3DXWELDEPSILONS
typedef struct _D3DXWELDEPSILONS *	LPD3DXWELDEPSILONS
typedef struct _D3DXBONECOMBINATION	D3DXBONECOMBINATION
typedef struct _D3DXBONECOMBINATION *	LPD3DXBONECOMBINATION
typedef struct _D3DXPATCHINFO	D3DXPATCHINFO
typedef struct _D3DXPATCHINFO *	LPD3DXPATCHINFO
typedef struct _D3DXINTERSECTINFO	D3DXINTERSECTINFO
typedef struct _D3DXINTERSECTINFO *	LPD3DXINTERSECTINFO
typedef struct _D3DXSHMATERIAL	D3DXSHMATERIAL
typedef struct _D3DXSHPRTSPLITMESHVERTDATA	D3DXSHPRTSPLITMESHVERTDATA
typedef struct _D3DXSHPRTSPLITMESHCLUSTERDATA	D3DXSHPRTSPLITMESHCLUSTERDATA
typedef struct _XFILECOMPRESSEDANIMATIONSET	XFILECOMPRESSEDANIMATIONSET
typedef HRESULT(WINAPI *	LPD3DXUVATLASCB) (float complete, void *ctx)
typedef HRESULT(WINAPI *	LPD3DXIMTSIGNALCALLBACK) (const D3DXVECTOR2 *, UINT, UINT, void *, FLOAT *)
typedef HRESULT(WINAPI *	LPD3DXSHPRTSIMCB) (float complete, void *ctx)

Enumerations
enum	_MAX_FVF_DECL_SIZE { MAX_FVF_DECL_SIZE = MAXD3DDECLLENGTH + 1 }
enum	_D3DXMESH {   D3DXMESH_32BIT = 0x001 , D3DXMESH_DONOTCLIP = 0x002 , D3DXMESH_POINTS = 0x004 , D3DXMESH_RTPATCHES = 0x008 ,   D3DXMESH_NPATCHES = 0x4000 , D3DXMESH_VB_SYSTEMMEM = 0x010 , D3DXMESH_VB_MANAGED = 0x020 , D3DXMESH_VB_WRITEONLY = 0x040 ,   D3DXMESH_VB_DYNAMIC = 0x080 , D3DXMESH_VB_SOFTWAREPROCESSING = 0x8000 , D3DXMESH_IB_SYSTEMMEM = 0x100 , D3DXMESH_IB_MANAGED = 0x200 ,   D3DXMESH_IB_WRITEONLY = 0x400 , D3DXMESH_IB_DYNAMIC = 0x800 , D3DXMESH_IB_SOFTWAREPROCESSING = 0x10000 , D3DXMESH_VB_SHARE = 0x1000 ,   D3DXMESH_USEHWONLY = 0x2000 , D3DXMESH_SYSTEMMEM = 0x110 , D3DXMESH_MANAGED = 0x220 , D3DXMESH_WRITEONLY = 0x440 ,   D3DXMESH_DYNAMIC = 0x880 , D3DXMESH_SOFTWAREPROCESSING = 0x18000 }
enum	_D3DXMESHOPT {   D3DXMESHOPT_DEVICEINDEPENDENT = 0x00400000 , D3DXMESHOPT_COMPACT = 0x01000000 , D3DXMESHOPT_ATTRSORT = 0x02000000 , D3DXMESHOPT_VERTEXCACHE = 0x04000000 ,   D3DXMESHOPT_STRIPREORDER = 0x08000000 , D3DXMESHOPT_IGNOREVERTS = 0x10000000 , D3DXMESHOPT_DONOTSPLIT = 0x20000000 }
enum	_D3DXPATCHMESHTYPE { D3DXPATCHMESH_RECT = 1 , D3DXPATCHMESH_TRI = 2 , D3DXPATCHMESH_NPATCH = 3 , D3DXPATCHMESH_FORCE_DWORD = 0x7fffffff }
enum	_D3DXPATCHMESH { D3DXPATCHMESH_DEFAULT = 0 }
enum	_D3DXMESHSIMP { D3DXMESHSIMP_VERTEX = 0x1 , D3DXMESHSIMP_FACE = 0x2 }
enum	D3DXCLEANTYPE {   D3DXCLEAN_BACKFACING = 0x00000001 , D3DXCLEAN_BOWTIES = 0x00000002 , D3DXCLEAN_SKINNING = D3DXCLEAN_BACKFACING , D3DXCLEAN_OPTIMIZATION = D3DXCLEAN_BACKFACING ,   D3DXCLEAN_SIMPLIFICATION = D3DXCLEAN_BACKFACING | D3DXCLEAN_BOWTIES }
enum	_D3DXTANGENT {   D3DXTANGENT_WRAP_U = 0x0001 , D3DXTANGENT_WRAP_V = 0x0002 , D3DXTANGENT_WRAP_UV = 0x0003 , D3DXTANGENT_DONT_NORMALIZE_PARTIALS = 0x0004 ,   D3DXTANGENT_DONT_ORTHOGONALIZE = 0x0008 , D3DXTANGENT_ORTHOGONALIZE_FROM_V = 0x0010 , D3DXTANGENT_ORTHOGONALIZE_FROM_U = 0x0020 , D3DXTANGENT_WEIGHT_BY_AREA = 0x0040 ,   D3DXTANGENT_WEIGHT_EQUAL = 0x0080 , D3DXTANGENT_WIND_CW = 0x0100 , D3DXTANGENT_CALCULATE_NORMALS = 0x0200 , D3DXTANGENT_GENERATE_IN_PLACE = 0x0400 }
enum	_D3DXIMT { D3DXIMT_WRAP_U = 0x01 , D3DXIMT_WRAP_V = 0x02 , D3DXIMT_WRAP_UV = 0x03 }
enum	_D3DXUVATLAS { D3DXUVATLAS_DEFAULT = 0x00 , D3DXUVATLAS_GEODESIC_FAST = 0x01 , D3DXUVATLAS_GEODESIC_QUALITY = 0x02 }
enum	_D3DXEFFECTDEFAULTTYPE { D3DXEDT_STRING = 1 , D3DXEDT_FLOATS = 2 , D3DXEDT_DWORD = 3 , D3DXEDT_FORCEDWORD = 0x7fffffff }
enum	_D3DXWELDEPSILONSFLAGS { D3DXWELDEPSILONS_WELDALL = 0x1 , D3DXWELDEPSILONS_WELDPARTIALMATCHES = 0x2 , D3DXWELDEPSILONS_DONOTREMOVEVERTICES = 0x4 , D3DXWELDEPSILONS_DONOTSPLIT = 0x8 }
enum	_D3DXSHCOMPRESSQUALITYTYPE { D3DXSHCQUAL_FASTLOWQUALITY = 1 , D3DXSHCQUAL_SLOWHIGHQUALITY = 2 , D3DXSHCQUAL_FORCE_DWORD = 0x7fffffff }
enum	_D3DXSHGPUSIMOPT {   D3DXSHGPUSIMOPT_SHADOWRES256 = 1 , D3DXSHGPUSIMOPT_SHADOWRES512 = 0 , D3DXSHGPUSIMOPT_SHADOWRES1024 = 2 , D3DXSHGPUSIMOPT_SHADOWRES2048 = 3 ,   D3DXSHGPUSIMOPT_HIGHQUALITY = 4 , D3DXSHGPUSIMOPT_FORCE_DWORD = 0x7fffffff }

Functions
	DEFINE_GUID (IID_ID3DXBaseMesh, 0x7ed943dd, 0x52e8, 0x40b5, 0xa8, 0xd8, 0x76, 0x68, 0x5c, 0x40, 0x63, 0x30)
	DEFINE_GUID (IID_ID3DXMesh, 0x4020e5c2, 0x1403, 0x4929, 0x88, 0x3f, 0xe2, 0xe8, 0x49, 0xfa, 0xc1, 0x95)
	DEFINE_GUID (IID_ID3DXPMesh, 0x8875769a, 0xd579, 0x4088, 0xaa, 0xeb, 0x53, 0x4d, 0x1a, 0xd8, 0x4e, 0x96)
	DEFINE_GUID (IID_ID3DXSPMesh, 0x667ea4c7, 0xf1cd, 0x4386, 0xb5, 0x23, 0x7c, 0x02, 0x90, 0xb8, 0x3c, 0xc5)
	DEFINE_GUID (IID_ID3DXSkinInfo, 0x11eaa540, 0xf9a6, 0x4d49, 0xae, 0x6a, 0xe1, 0x92, 0x21, 0xf7, 0x0c, 0xc4)
	DEFINE_GUID (IID_ID3DXPatchMesh, 0x3ce6cc22, 0xdbf2, 0x44f4, 0x89, 0x4d, 0xf9, 0xc3, 0x4a, 0x33, 0x71, 0x39)
	DEFINE_GUID (IID_ID3DXPRTBuffer, 0xf1827e47, 0x00a8, 0x49cd, 0x90, 0x8c, 0x9d, 0x11, 0x95, 0x5f, 0x87, 0x28)
	DEFINE_GUID (IID_ID3DXPRTCompBuffer, 0xa758d465, 0xfe8d, 0x45ad, 0x9c, 0xf0, 0xd0, 0x1e, 0x56, 0x26, 0x6a, 0x07)
	DEFINE_GUID (IID_ID3DXTextureGutterHelper, 0x838f01ec, 0x9729, 0x4527, 0xaa, 0xdb, 0xdf, 0x70, 0xad, 0xe7, 0xfe, 0xa9)
	DEFINE_GUID (IID_ID3DXPRTEngine, 0x683a4278, 0xcd5f, 0x4d24, 0x90, 0xad, 0xc4, 0xe1, 0xb6, 0x85, 0x5d, 0x53)
	DECLARE_INTERFACE_ (ID3DXBaseMesh, IUnknown)
	DECLARE_INTERFACE_ (ID3DXMesh, ID3DXBaseMesh)
	DECLARE_INTERFACE_ (ID3DXPMesh, ID3DXBaseMesh)
	DECLARE_INTERFACE_ (ID3DXSPMesh, IUnknown)
	DECLARE_INTERFACE_ (ID3DXPatchMesh, IUnknown)
	DECLARE_INTERFACE_ (ID3DXSkinInfo, IUnknown)
	DECLARE_INTERFACE_ (ID3DXPRTBuffer, IUnknown)
	DECLARE_INTERFACE_ (ID3DXPRTCompBuffer, IUnknown)
	DECLARE_INTERFACE_ (ID3DXTextureGutterHelper, IUnknown)
	DECLARE_INTERFACE_ (ID3DXPRTEngine, IUnknown)
HRESULT WINAPI	D3DXCreateMesh (DWORD face_count, DWORD vertex_count, DWORD flags, const D3DVERTEXELEMENT9 *declaration, struct IDirect3DDevice9 *device, struct ID3DXMesh **mesh)
HRESULT WINAPI	D3DXCreateMeshFVF (DWORD face_count, DWORD vertex_count, DWORD flags, DWORD fvf, struct IDirect3DDevice9 *device, struct ID3DXMesh **mesh)
HRESULT WINAPI	D3DXCreateBuffer (DWORD size, ID3DXBuffer **buffer)
HRESULT WINAPI	D3DXCreateSPMesh (ID3DXMesh *mesh, const DWORD *adjacency, const D3DXATTRIBUTEWEIGHTS *attribute_weights, const float *vertex_weights, ID3DXSPMesh **spmesh)
HRESULT WINAPI	D3DXCreatePMeshFromStream (struct IStream *stream, DWORD flags, struct IDirect3DDevice9 *device, struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances, DWORD *material_count, struct ID3DXPMesh **mesh)
HRESULT WINAPI	D3DXCreateSkinInfo (DWORD vertex_count, const D3DVERTEXELEMENT9 *declaration, DWORD bone_count, ID3DXSkinInfo **skin_info)
HRESULT WINAPI	D3DXCreateSkinInfoFVF (DWORD vertex_count, DWORD fvf, DWORD bone_count, ID3DXSkinInfo **skin_info)
HRESULT WINAPI	D3DXCreateSkinInfoFromBlendedMesh (ID3DXBaseMesh *mesh, DWORD bone_count, const D3DXBONECOMBINATION *bone_combination_table, ID3DXSkinInfo **skin_info)
HRESULT WINAPI	D3DXCreatePatchMesh (const D3DXPATCHINFO *patch_info, DWORD patch_count, DWORD vertex_count, DWORD flags, const D3DVERTEXELEMENT9 *declaration, struct IDirect3DDevice9 *device, struct ID3DXPatchMesh **mesh)
HRESULT WINAPI	D3DXCreatePRTBuffer (UINT sample_count, UINT coeff_count, UINT channel_count, ID3DXPRTBuffer **buffer)
HRESULT WINAPI	D3DXCreatePRTBufferTex (UINT width, UINT height, UINT coeff_count, UINT channel_count, ID3DXPRTBuffer **buffer)
HRESULT WINAPI	D3DXCreatePRTCompBuffer (D3DXSHCOMPRESSQUALITYTYPE quality, UINT cluster_count, UINT pca_count, LPD3DXSHPRTSIMCB cb, void *ctx, ID3DXPRTBuffer *input, ID3DXPRTCompBuffer **buffer)
HRESULT WINAPI	D3DXCreateTextureGutterHelper (UINT width, UINT height, ID3DXMesh *mesh, float gutter_size, ID3DXTextureGutterHelper **gh)
HRESULT WINAPI	D3DXCreatePRTEngine (ID3DXMesh *mesh, DWORD *adjacency, BOOL extract_uv, ID3DXMesh *blocker_mesh, ID3DXPRTEngine **engine)
HRESULT WINAPI	D3DXLoadMeshFromXA (const char *filename, DWORD flags, struct IDirect3DDevice9 *device, struct ID3DXBuffer **adjacency, struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances, DWORD *material_count, struct ID3DXMesh **mesh)
HRESULT WINAPI	D3DXLoadMeshFromXW (const WCHAR *filename, DWORD flags, struct IDirect3DDevice9 *device, struct ID3DXBuffer **adjacency, struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances, DWORD *material_count, struct ID3DXMesh **mesh)
HRESULT WINAPI	D3DXLoadMeshFromXInMemory (const void *data, DWORD data_size, DWORD flags, struct IDirect3DDevice9 *device, struct ID3DXBuffer **adjacency, struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances, DWORD *material_count, struct ID3DXMesh **mesh)
HRESULT WINAPI	D3DXLoadMeshFromXResource (HMODULE module, const char *resource, const char *resource_type, DWORD flags, struct IDirect3DDevice9 *device, struct ID3DXBuffer **adjacency, struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances, DWORD *material_count, struct ID3DXMesh **mesh)
HRESULT WINAPI	D3DXLoadMeshFromXof (struct ID3DXFileData *file_data, DWORD flags, struct IDirect3DDevice9 *device, struct ID3DXBuffer **adjacency, struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances, DWORD *material_count, struct ID3DXMesh **mesh)
HRESULT WINAPI	D3DXLoadPatchMeshFromXof (struct ID3DXFileData *file_data, DWORD flags, struct IDirect3DDevice9 *device, struct ID3DXBuffer **adjacency, struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances, DWORD *material_count, struct ID3DXPatchMesh **mesh)
HRESULT WINAPI	D3DXLoadSkinMeshFromXof (struct ID3DXFileData *file_data, DWORD flags, struct IDirect3DDevice9 *device, struct ID3DXBuffer **adjacency, struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances, DWORD *material_count, struct ID3DXSkinInfo **skin_info, struct ID3DXMesh **mesh)
HRESULT WINAPI	D3DXLoadPRTBufferFromFileA (const char *filename, ID3DXPRTBuffer **buffer)
HRESULT WINAPI	D3DXLoadPRTBufferFromFileW (const WCHAR *filename, ID3DXPRTBuffer **buffer)
HRESULT WINAPI	D3DXLoadPRTCompBufferFromFileA (const char *filename, ID3DXPRTCompBuffer **buffer)
HRESULT WINAPI	D3DXLoadPRTCompBufferFromFileW (const WCHAR *filename, ID3DXPRTCompBuffer **buffer)
HRESULT WINAPI	D3DXSaveMeshToXA (const char *filename, ID3DXMesh *mesh, const DWORD *adjacency, const D3DXMATERIAL *materials, const D3DXEFFECTINSTANCE *effect_instances, DWORD material_count, DWORD format)
HRESULT WINAPI	D3DXSaveMeshToXW (const WCHAR *filename, ID3DXMesh *mesh, const DWORD *adjacency, const D3DXMATERIAL *materials, const D3DXEFFECTINSTANCE *effect_instances, DWORD material_count, DWORD format)
HRESULT WINAPI	D3DXSavePRTBufferToFileA (const char *filename, ID3DXPRTBuffer *buffer)
HRESULT WINAPI	D3DXSavePRTBufferToFileW (const WCHAR *filename, ID3DXPRTBuffer *buffer)
HRESULT WINAPI	D3DXSavePRTCompBufferToFileA (const char *filename, ID3DXPRTCompBuffer *buffer)
HRESULT WINAPI	D3DXSavePRTCompBufferToFileW (const WCHAR *filename, ID3DXPRTCompBuffer *buffer)
UINT WINAPI	D3DXGetDeclLength (const D3DVERTEXELEMENT9 *decl)
UINT WINAPI	D3DXGetDeclVertexSize (const D3DVERTEXELEMENT9 *decl, DWORD stream_idx)
UINT WINAPI	D3DXGetFVFVertexSize (DWORD)
BOOL WINAPI	D3DXBoxBoundProbe (const D3DXVECTOR3 *vmin, const D3DXVECTOR3 *vmax, const D3DXVECTOR3 *ray_pos, const D3DXVECTOR3 *ray_dir)
BOOL WINAPI	D3DXSphereBoundProbe (const D3DXVECTOR3 *center, FLOAT radius, const D3DXVECTOR3 *ray_pos, const D3DXVECTOR3 *ray_dir)
HRESULT WINAPI	D3DXCleanMesh (D3DXCLEANTYPE clean_type, ID3DXMesh *mesh_in, const DWORD *adjacency_in, ID3DXMesh **mesh_out, DWORD *adjacency_out, ID3DXBuffer **errors)
HRESULT WINAPI	D3DXConcatenateMeshes (struct ID3DXMesh **meshes, UINT mesh_count, DWORD flags, const D3DXMATRIX *geometry_matrices, const D3DXMATRIX *texture_matrices, const D3DVERTEXELEMENT9 *declaration, struct IDirect3DDevice9 *device, struct ID3DXMesh **mesh)
HRESULT WINAPI	D3DXComputeBoundingBox (const D3DXVECTOR3 *first_pos, DWORD num_vertices, DWORD stride, D3DXVECTOR3 *vmin, D3DXVECTOR3 *vmax)
HRESULT WINAPI	D3DXComputeBoundingSphere (const D3DXVECTOR3 *first_pos, DWORD num_vertices, DWORD stride, D3DXVECTOR3 *center, FLOAT *radius)
HRESULT WINAPI	D3DXComputeIMTFromPerTexelSignal (ID3DXMesh *mesh, DWORD texture_idx, float *texel_signal, UINT width, UINT height, UINT signal_dimension, UINT component_count, DWORD flags, LPD3DXUVATLASCB cb, void *ctx, ID3DXBuffer **buffer)
HRESULT WINAPI	D3DXComputeIMTFromPerVertexSignal (ID3DXMesh *mesh, const float *vertex_signal, UINT signal_dimension, UINT signal_stride, DWORD flags, LPD3DXUVATLASCB cb, void *ctx, ID3DXBuffer **buffer)
HRESULT WINAPI	D3DXComputeIMTFromSignal (ID3DXMesh *mesh, DWORD texture_idx, UINT signal_dimension, float max_uv_distance, DWORD flags, LPD3DXIMTSIGNALCALLBACK signal_cb, void *signal_ctx, LPD3DXUVATLASCB status_cb, void *status_ctx, ID3DXBuffer **buffer)
HRESULT WINAPI	D3DXComputeIMTFromTexture (struct ID3DXMesh *mesh, struct IDirect3DTexture9 *texture, DWORD texture_idx, DWORD options, LPD3DXUVATLASCB cb, void *ctx, struct ID3DXBuffer **out)
HRESULT WINAPI	D3DXComputeNormals (ID3DXBaseMesh *mesh, const DWORD *adjacency)
HRESULT WINAPI	D3DXComputeTangentFrameEx (ID3DXMesh *mesh_in, DWORD texture_in_semantic, DWORD texture_in_idx, DWORD u_partial_out_semantic, DWORD u_partial_out_idx, DWORD v_partial_out_semantic, DWORD v_partial_out_idx, DWORD normal_out_semantic, DWORD normal_out_idx, DWORD flags, const DWORD *adjacency, float partial_edge_threshold, float singular_point_threshold, float normal_edge_threshold, ID3DXMesh **mesh_out, ID3DXBuffer **buffer)
HRESULT WINAPI	D3DXComputeTangent (ID3DXMesh *mesh, DWORD stage, DWORD tangent_idx, DWORD binorm_idx, DWORD wrap, const DWORD *adjacency)
HRESULT WINAPI	D3DXConvertMeshSubsetToSingleStrip (struct ID3DXBaseMesh *mesh_in, DWORD attribute_id, DWORD ib_flags, struct IDirect3DIndexBuffer9 **index_buffer, DWORD *index_count)
HRESULT WINAPI	D3DXConvertMeshSubsetToStrips (struct ID3DXBaseMesh *mesh_in, DWORD attribute_id, DWORD ib_flags, struct IDirect3DIndexBuffer9 **index_buffer, DWORD *index_count, struct ID3DXBuffer **strip_lengths, DWORD *strip_count)
HRESULT WINAPI	D3DXDeclaratorFromFVF (DWORD, D3DVERTEXELEMENT9[MAX_FVF_DECL_SIZE])
HRESULT WINAPI	D3DXFVFFromDeclarator (const D3DVERTEXELEMENT9 *decl, DWORD *fvf)
HRESULT WINAPI	D3DXGenerateOutputDecl (D3DVERTEXELEMENT9 *decl_out, const D3DVERTEXELEMENT9 *decl_in)
HRESULT WINAPI	D3DXGeneratePMesh (ID3DXMesh *mesh, const DWORD *adjacency, const D3DXATTRIBUTEWEIGHTS *attribute_weights, const float *vertex_weights, DWORD min_value, DWORD flags, ID3DXPMesh **pmesh)
HRESULT WINAPI	D3DXIntersect (ID3DXBaseMesh *mesh, const D3DXVECTOR3 *ray_position, const D3DXVECTOR3 *ray_direction, BOOL *hit, DWORD *face_idx, float *u, float *v, float *distance, ID3DXBuffer **hits, DWORD *hit_count)
HRESULT WINAPI	D3DXIntersectSubset (ID3DXBaseMesh *mesh, DWORD attribute_id, const D3DXVECTOR3 *ray_position, const D3DXVECTOR3 *ray_direction, BOOL *hit, DWORD *face_idx, float *u, float *v, float *distance, ID3DXBuffer **hits, DWORD *hit_count)
BOOL WINAPI	D3DXIntersectTri (const D3DXVECTOR3 *vtx0, const D3DXVECTOR3 *vtx1, const D3DXVECTOR3 *vtx2, const D3DXVECTOR3 *ray_pos, const D3DXVECTOR3 *ray_dir, FLOAT *u, FLOAT *v, FLOAT *dist)
HRESULT WINAPI	D3DXOptimizeFaces (const void *indices, UINT face_count, UINT vertex_count, BOOL idx_32bit, DWORD *face_remap)
HRESULT WINAPI	D3DXOptimizeVertices (const void *indices, UINT face_count, UINT vertex_count, BOOL idx_32bit, DWORD *vertex_remap)
HRESULT WINAPI	D3DXRectPatchSize (const FLOAT *segment_count, DWORD *num_triangles, DWORD *num_vertices)
HRESULT WINAPI	D3DXSHPRTCompSuperCluster (UINT *cluster_ids, ID3DXMesh *scene, UINT max_cluster_count, UINT cluster_count, UINT *scluster_ids, UINT *scluster_count)
HRESULT WINAPI	D3DXSHPRTCompSplitMeshSC (UINT *cluster_idx, UINT vertex_count, UINT cluster_count, UINT *scluster_ids, UINT scluster_count, void *index_buffer_in, BOOL ib_in_32bit, UINT face_count, ID3DXBuffer **index_buffer_out, UINT *index_buffer_size, BOOL ib_out_32bit, ID3DXBuffer **face_remap, ID3DXBuffer **vertex_data, UINT *vertex_data_length, UINT *sc_cluster_list, D3DXSHPRTSPLITMESHCLUSTERDATA *sc_data)
HRESULT WINAPI	D3DXSimplifyMesh (ID3DXMesh *mesh_in, const DWORD *adjacency, const D3DXATTRIBUTEWEIGHTS *attribute_weights, const float *vertex_weights, DWORD min_value, DWORD flags, ID3DXMesh **mesh_out)
HRESULT WINAPI	D3DXSplitMesh (ID3DXMesh *mesh_in, const DWORD *adjacency_in, const DWORD max_size, const DWORD flags, DWORD *mesh_out_count, ID3DXBuffer **mesh_out, ID3DXBuffer **adjacency_out, ID3DXBuffer **face_remap_out, ID3DXBuffer **vertex_remap_out)
HRESULT WINAPI	D3DXTessellateNPatches (ID3DXMesh *mesh_in, const DWORD *adjacency_in, float segment_count, BOOL quad_interp, ID3DXMesh **mesh_out, ID3DXBuffer **adjacency_out)
HRESULT WINAPI	D3DXTessellateRectPatch (struct IDirect3DVertexBuffer9 *buffer, const float *segment_count, const D3DVERTEXELEMENT9 *declaration, const D3DRECTPATCH_INFO *patch_info, struct ID3DXMesh *mesh)
HRESULT WINAPI	D3DXTessellateTriPatch (struct IDirect3DVertexBuffer9 *buffer, const float *segment_count, const D3DVERTEXELEMENT9 *declaration, const D3DTRIPATCH_INFO *patch_info, struct ID3DXMesh *mesh)
HRESULT WINAPI	D3DXTriPatchSize (const FLOAT *segment_count, DWORD *num_triangles, DWORD *num_vertices)
HRESULT WINAPI	D3DXUVAtlasCreate (ID3DXMesh *mesh_in, UINT max_chart_count, float max_stretch_in, UINT width, UINT height, float gutter, DWORD texture_idx, const DWORD *adjacency, const DWORD *false_edges, const float *imt_array, LPD3DXUVATLASCB cb, float cb_freq, void *ctx, DWORD flags, ID3DXMesh **mesh_out, ID3DXBuffer **face_partitioning_out, ID3DXBuffer **vertex_remap_out, float *max_stretch_out, UINT *chart_count)
HRESULT WINAPI	D3DXUVAtlasPack (ID3DXMesh *mesh, UINT width, UINT height, float gutter, DWORD texture_idx, const DWORD *partition_result_adjacency, LPD3DXUVATLASCB cb, float cb_freq, void *ctx, DWORD flags, ID3DXBuffer *face_partitioning)
HRESULT WINAPI	D3DXUVAtlasPartition (ID3DXMesh *mesh_in, UINT max_chart_count, float max_stretch_in, DWORD texture_idx, const DWORD *adjacency, const DWORD *false_edges, const float *imt_array, LPD3DXUVATLASCB cb, float cb_freq, void *ctx, DWORD flags, ID3DXMesh **mesh_out, ID3DXBuffer **face_partitioning_out, ID3DXBuffer **vertex_remap_out, ID3DXBuffer **adjacency_out, float *max_stretch_out, UINT *chart_count)
HRESULT WINAPI	D3DXValidMesh (ID3DXMesh *mesh, const DWORD *adjacency, ID3DXBuffer **errors)
HRESULT WINAPI	D3DXValidPatchMesh (ID3DXPatchMesh *mesh, DWORD *degenerate_vertex_count, DWORD *degenerate_patch_count, ID3DXBuffer **errors)
HRESULT WINAPI	D3DXWeldVertices (ID3DXMesh *mesh, DWORD flags, const D3DXWELDEPSILONS *epsilons, const DWORD *adjacency_in, DWORD *adjacency_out, DWORD *face_remap_out, ID3DXBuffer **vertex_remap_out)
	DEFINE_GUID (DXFILEOBJ_XSkinMeshHeader, 0x3cf169ce, 0xff7c, 0x44ab, 0x93, 0xc0, 0xf7, 0x8f, 0x62, 0xd1, 0x72, 0xe2)
	DEFINE_GUID (DXFILEOBJ_VertexDuplicationIndices, 0xb8d65549, 0xd7c9, 0x4995, 0x89, 0xcf, 0x53, 0xa9, 0xa8, 0xb0, 0x31, 0xe3)
	DEFINE_GUID (DXFILEOBJ_FaceAdjacency, 0xa64c844a, 0xe282, 0x4756, 0x8b, 0x80, 0x25, 0x0c, 0xde, 0x04, 0x39, 0x8c)
	DEFINE_GUID (DXFILEOBJ_SkinWeights, 0x6f0d123b, 0xbad2, 0x4167, 0xa0, 0xd0, 0x80, 0x22, 0x4f, 0x25, 0xfa, 0xbb)
	DEFINE_GUID (DXFILEOBJ_Patch, 0xa3eb5d44, 0xfc22, 0x429d, 0x9a, 0xfb, 0x32, 0x21, 0xcb, 0x97, 0x19, 0xa6)
	DEFINE_GUID (DXFILEOBJ_PatchMesh, 0xd02c95cc, 0xedba, 0x4305, 0x9b, 0x5d, 0x18, 0x20, 0xd7, 0x70, 0x4d, 0xbf)
	DEFINE_GUID (DXFILEOBJ_PatchMesh9, 0xb9ec94e1, 0xb9a6, 0x4251, 0xba, 0x18, 0x94, 0x89, 0x3f, 0x02, 0xc0, 0xea)
	DEFINE_GUID (DXFILEOBJ_PMInfo, 0xb6c3e656, 0xec8b, 0x4b92, 0x9b, 0x62, 0x68, 0x16, 0x59, 0x52, 0x29, 0x47)
	DEFINE_GUID (DXFILEOBJ_PMAttributeRange, 0x917e0427, 0xc61e, 0x4a14, 0x9c, 0x64, 0xaf, 0xe6, 0x5f, 0x9e, 0x98, 0x44)
	DEFINE_GUID (DXFILEOBJ_PMVSplitRecord, 0x574ccc14, 0xf0b3, 0x4333, 0x82, 0x2d, 0x93, 0xe8, 0xa8, 0xa0, 0x8e, 0x4c)
	DEFINE_GUID (DXFILEOBJ_FVFData, 0xb6e70a0e, 0x8ef9, 0x4e83, 0x94, 0xad, 0xec, 0xc8, 0xb0, 0xc0, 0x48, 0x97)
	DEFINE_GUID (DXFILEOBJ_VertexElement, 0xf752461c, 0x1e23, 0x48f6, 0xb9, 0xf8, 0x83, 0x50, 0x85, 0x0f, 0x33, 0x6f)
	DEFINE_GUID (DXFILEOBJ_DeclData, 0xbf22e553, 0x292c, 0x4781, 0x9f, 0xea, 0x62, 0xbd, 0x55, 0x4b, 0xdd, 0x93)
	DEFINE_GUID (DXFILEOBJ_EffectFloats, 0xf1cfe2b3, 0x0de3, 0x4e28, 0xaf, 0xa1, 0x15, 0x5a, 0x75, 0x0a, 0x28, 0x2d)
	DEFINE_GUID (DXFILEOBJ_EffectString, 0xd55b097e, 0xbdb6, 0x4c52, 0xb0, 0x3d, 0x60, 0x51, 0xc8, 0x9d, 0x0e, 0x42)
	DEFINE_GUID (DXFILEOBJ_EffectDWord, 0x622c0ed0, 0x956e, 0x4da9, 0x90, 0x8a, 0x2a, 0xf9, 0x4f, 0x3c, 0xe7, 0x16)
	DEFINE_GUID (DXFILEOBJ_EffectParamFloats, 0x3014b9a0, 0x62f5, 0x478c, 0x9b, 0x86, 0xe4, 0xac, 0x9f, 0x4e, 0x41, 0x8b)
	DEFINE_GUID (DXFILEOBJ_EffectParamString, 0x1dbc4c88, 0x94c1, 0x46ee, 0x90, 0x76, 0x2c, 0x28, 0x81, 0x8c, 0x94, 0x81)
	DEFINE_GUID (DXFILEOBJ_EffectParamDWord, 0xe13963bc, 0xae51, 0x4c5d, 0xb0, 0x0f, 0xcf, 0xa3, 0xa9, 0xd9, 0x7c, 0xe5)
	DEFINE_GUID (DXFILEOBJ_EffectInstance, 0xe331f7e4, 0x0559, 0x4cc2, 0x8e, 0x99, 0x1c, 0xec, 0x16, 0x57, 0x92, 0x8f)
	DEFINE_GUID (DXFILEOBJ_AnimTicksPerSecond, 0x9e415a43, 0x7ba6, 0x4a73, 0x87, 0x43, 0xb7, 0x3d, 0x47, 0xe8, 0x84, 0x76)
	DEFINE_GUID (DXFILEOBJ_CompressedAnimationSet, 0x7f9b00b3, 0xf125, 0x4890, 0x87, 0x6e, 0x1c, 0x42, 0xbf, 0x69, 0x7c, 0x4d)

Macro Definition Documentation

D3DXLoadMeshFromX

#define D3DXLoadMeshFromX   WINELIB_NAME_AW(D3DXLoadMeshFromX)

Definition at line 733 of file d3dx9mesh.h.

D3DXLoadPRTBufferFromFile

#define D3DXLoadPRTBufferFromFile   WINELIB_NAME_AW(D3DXLoadPRTBufferFromFile)

Definition at line 752 of file d3dx9mesh.h.

D3DXLoadPRTCompBufferFromFile

#define D3DXLoadPRTCompBufferFromFile   WINELIB_NAME_AW(D3DXLoadPRTCompBufferFromFile)

Definition at line 755 of file d3dx9mesh.h.

D3DXSaveMeshToX

#define D3DXSaveMeshToX   WINELIB_NAME_AW(D3DXSaveMeshToX)

Definition at line 760 of file d3dx9mesh.h.

D3DXSavePRTBufferToFile

#define D3DXSavePRTBufferToFile   WINELIB_NAME_AW(D3DXSavePRTBufferToFile)

Definition at line 763 of file d3dx9mesh.h.

D3DXSavePRTCompBufferToFile

#define D3DXSavePRTCompBufferToFile   WINELIB_NAME_AW(D3DXSavePRTCompBufferToFile)

Definition at line 766 of file d3dx9mesh.h.

INTERFACE [1/10]

#define INTERFACE   ID3DXBaseMesh

Definition at line 635 of file d3dx9mesh.h.

INTERFACE [2/10]

#define INTERFACE   ID3DXMesh

Definition at line 635 of file d3dx9mesh.h.

INTERFACE [3/10]

#define INTERFACE   ID3DXPMesh

Definition at line 635 of file d3dx9mesh.h.

INTERFACE [4/10]

#define INTERFACE   ID3DXSPMesh

Definition at line 635 of file d3dx9mesh.h.

INTERFACE [5/10]

#define INTERFACE   ID3DXPatchMesh

Definition at line 635 of file d3dx9mesh.h.

INTERFACE [6/10]

#define INTERFACE   ID3DXSkinInfo

Definition at line 635 of file d3dx9mesh.h.

INTERFACE [7/10]

#define INTERFACE   ID3DXPRTBuffer

Definition at line 635 of file d3dx9mesh.h.

INTERFACE [8/10]

#define INTERFACE   ID3DXPRTCompBuffer

Definition at line 635 of file d3dx9mesh.h.

INTERFACE [9/10]

#define INTERFACE   ID3DXTextureGutterHelper

Definition at line 635 of file d3dx9mesh.h.

INTERFACE [10/10]

#define INTERFACE   ID3DXPRTEngine

Definition at line 635 of file d3dx9mesh.h.

UNUSED16

#define UNUSED16   (0xffff)

Definition at line 36 of file d3dx9mesh.h.

UNUSED32

#define UNUSED32   (0xffffffff)

Definition at line 37 of file d3dx9mesh.h.

XEXTENSIONS_TEMPLATES

#define XEXTENSIONS_TEMPLATES    "xof 0303txt 0032\ template FVFData \ { \ <B6E70A0E-8EF9-4e83-94AD-ECC8B0C04897> \ DWORD dwFVF; \ DWORD nDWords; \ array DWORD data[nDWords]; \ } \ template VertexElement \ { \ <F752461C-1E23-48f6-B9F8-8350850F336F> \ DWORD Type; \ DWORD Method; \ DWORD Usage; \ DWORD UsageIndex; \ } \ template DeclData \ { \ <BF22E553-292C-4781-9FEA-62BD554BDD93> \ DWORD nElements; \ array VertexElement Elements[nElements]; \ DWORD nDWords; \ array DWORD data[nDWords]; \ } \ template PMAttributeRange \ { \ <917E0427-C61E-4a14-9C64-AFE65F9E9844> \ DWORD iFaceOffset; \ DWORD nFacesMin; \ DWORD nFacesMax; \ DWORD iVertexOffset; \ DWORD nVerticesMin; \ DWORD nVerticesMax; \ } \ template PMVSplitRecord \ { \ <574CCC14-F0B3-4333-822D-93E8A8A08E4C> \ DWORD iFaceCLW; \ DWORD iVlrOffset; \ DWORD iCode; \ } \ template PMInfo \ { \ <B6C3E656-EC8B-4b92-9B62-681659522947> \ DWORD nAttributes; \ array PMAttributeRange attributeRanges[nAttributes]; \ DWORD nMaxValence; \ DWORD nMinLogicalVertices; \ DWORD nMaxLogicalVertices; \ DWORD nVSplits; \ array PMVSplitRecord splitRecords[nVSplits]; \ DWORD nAttributeMispredicts; \ array DWORD attributeMispredicts[nAttributeMispredicts]; \ } "

Definition at line 1002 of file d3dx9mesh.h.

XSKINEXP_TEMPLATES

#define XSKINEXP_TEMPLATES    "xof 0303txt 0032\ template XSkinMeshHeader \ { \ <3CF169CE-FF7C-44ab-93C0-F78F62D172E2> \ WORD nMaxSkinWeightsPerVertex; \ WORD nMaxSkinWeightsPerFace; \ WORD nBones; \ } \ template VertexDuplicationIndices \ { \ <B8D65549-D7C9-4995-89CF-53A9A8B031E3> \ DWORD nIndices; \ DWORD nOriginalVertices; \ array DWORD indices[nIndices]; \ } \ template FaceAdjacency \ { \ <A64C844A-E282-4756-8B80-250CDE04398C> \ DWORD nIndices; \ array DWORD indices[nIndices]; \ } \ template SkinWeights \ { \ <6F0D123B-BAD2-4167-A0D0-80224F25FABB> \ STRING transformNodeName; \ DWORD nWeights; \ array DWORD vertexIndices[nWeights]; \ array float weights[nWeights]; \ Matrix4x4 matrixOffset; \ } \ template Patch \ { \ <A3EB5D44-FC22-429D-9AFB-3221CB9719A6> \ DWORD nControlIndices; \ array DWORD controlIndices[nControlIndices]; \ } \ template PatchMesh \ { \ <D02C95CC-EDBA-4305-9B5D-1820D7704BBF> \ DWORD nVertices; \ array Vector vertices[nVertices]; \ DWORD nPatches; \ array Patch patches[nPatches]; \ [ ... ] \ } \ template PatchMesh9 \ { \ <B9EC94E1-B9A6-4251-BA18-94893F02C0EA> \ DWORD Type; \ DWORD Degree; \ DWORD Basis; \ DWORD nVertices; \ array Vector vertices[nVertices]; \ DWORD nPatches; \ array Patch patches[nPatches]; \ [ ... ] \ } template EffectFloats \ { \ <F1CFE2B3-0DE3-4e28-AFA1-155A750A282D> \ DWORD nFloats; \ array float Floats[nFloats]; \ } \ template EffectString \ { \ <D55B097E-BDB6-4c52-B03D-6051C89D0E42> \ STRING Value; \ } \ template EffectDWord \ { \ <622C0ED0-956E-4da9-908A-2AF94F3CE716> \ DWORD Value; \ } template EffectParamFloats \ { \ <3014B9A0-62F5-478c-9B86-E4AC9F4E418B> \ STRING ParamName; \ DWORD nFloats; \ array float Floats[nFloats]; \ } template EffectParamString \ { \ <1DBC4C88-94C1-46ee-9076-2C28818C9481> \ STRING ParamName; \ STRING Value; \ } \ template EffectParamDWord \ { \ <E13963BC-AE51-4c5d-B00F-CFA3A9D97CE5> \ STRING ParamName; \ DWORD Value; \ } \ template EffectInstance \ { \ <E331F7E4-0559-4cc2-8E99-1CEC1657928F> \ STRING EffectFilename; \ [ ... ] \ } template AnimTicksPerSecond \ { \ <9E415A43-7BA6-4a73-8743-B73D47E88476> \ DWORD AnimTicksPerSecond; \ } \ template CompressedAnimationSet \ { \ <7F9B00B3-F125-4890-876E-1C42BF697C4D> \ DWORD CompressedBlockSize; \ FLOAT TicksPerSec; \ DWORD PlaybackType; \ DWORD BufferLength; \ array DWORD CompressedData[BufferLength]; \ } "

Definition at line 892 of file d3dx9mesh.h.

Typedef Documentation

D3DXATTRIBUTERANGE

typedef struct _D3DXATTRIBUTERANGE D3DXATTRIBUTERANGE

D3DXATTRIBUTEWEIGHTS

typedef struct _D3DXATTRIBUTEWEIGHTS D3DXATTRIBUTEWEIGHTS

D3DXBONECOMBINATION

typedef struct _D3DXBONECOMBINATION D3DXBONECOMBINATION

D3DXCLEANTYPE

typedef enum D3DXCLEANTYPE D3DXCLEANTYPE

D3DXEFFECTDEFAULT

typedef struct _D3DXEFFECTDEFAULT D3DXEFFECTDEFAULT

D3DXEFFECTDEFAULTTYPE

typedef enum _D3DXEFFECTDEFAULTTYPE D3DXEFFECTDEFAULTTYPE

D3DXEFFECTINSTANCE

typedef struct _D3DXEFFECTINSTANCE D3DXEFFECTINSTANCE

D3DXIMT

typedef enum _D3DXIMT D3DXIMT

D3DXINTERSECTINFO

typedef struct _D3DXINTERSECTINFO D3DXINTERSECTINFO

D3DXMATERIAL

typedef struct _D3DXMATERIAL D3DXMATERIAL

D3DXPATCHINFO

typedef struct _D3DXPATCHINFO D3DXPATCHINFO

D3DXPATCHMESHTYPE

typedef enum _D3DXPATCHMESHTYPE D3DXPATCHMESHTYPE

D3DXSHCOMPRESSQUALITYTYPE

typedef enum _D3DXSHCOMPRESSQUALITYTYPE D3DXSHCOMPRESSQUALITYTYPE

D3DXSHGPUSIMOPT

typedef enum _D3DXSHGPUSIMOPT D3DXSHGPUSIMOPT

D3DXSHMATERIAL

typedef struct _D3DXSHMATERIAL D3DXSHMATERIAL

D3DXSHPRTSPLITMESHCLUSTERDATA

typedef struct _D3DXSHPRTSPLITMESHCLUSTERDATA D3DXSHPRTSPLITMESHCLUSTERDATA

D3DXSHPRTSPLITMESHVERTDATA

typedef struct _D3DXSHPRTSPLITMESHVERTDATA D3DXSHPRTSPLITMESHVERTDATA

D3DXTANGENT

typedef enum _D3DXTANGENT D3DXTANGENT

D3DXUVATLAS

typedef enum _D3DXUVATLAS D3DXUVATLAS

D3DXWELDEPSILONS

typedef struct _D3DXWELDEPSILONS D3DXWELDEPSILONS

LPD3DXATTRIBUTERANGE

typedef D3DXATTRIBUTERANGE* LPD3DXATTRIBUTERANGE

Definition at line 191 of file d3dx9mesh.h.

LPD3DXATTRIBUTEWEIGHTS

typedef struct _D3DXATTRIBUTEWEIGHTS * LPD3DXATTRIBUTEWEIGHTS

LPD3DXBASEMESH

typedef struct ID3DXBaseMesh* LPD3DXBASEMESH

Definition at line 172 of file d3dx9mesh.h.

LPD3DXBONECOMBINATION

typedef struct _D3DXBONECOMBINATION * LPD3DXBONECOMBINATION

LPD3DXEFFECTDEFAULT

typedef struct _D3DXEFFECTDEFAULT * LPD3DXEFFECTDEFAULT

LPD3DXEFFECTINSTANCE

typedef struct _D3DXEFFECTINSTANCE * LPD3DXEFFECTINSTANCE

LPD3DXIMTSIGNALCALLBACK

typedef HRESULT(WINAPI * LPD3DXIMTSIGNALCALLBACK) (const D3DXVECTOR2 *, UINT, UINT, void *, FLOAT *)

Definition at line 301 of file d3dx9mesh.h.

LPD3DXINTERSECTINFO

typedef struct _D3DXINTERSECTINFO * LPD3DXINTERSECTINFO

LPD3DXMATERIAL

typedef struct _D3DXMATERIAL * LPD3DXMATERIAL

LPD3DXMESH

typedef struct ID3DXMesh* LPD3DXMESH

Definition at line 173 of file d3dx9mesh.h.

LPD3DXPATCHINFO

typedef struct _D3DXPATCHINFO * LPD3DXPATCHINFO

LPD3DXPATCHMESH

typedef struct ID3DXPatchMesh* LPD3DXPATCHMESH

Definition at line 177 of file d3dx9mesh.h.

LPD3DXPMESH

typedef struct ID3DXPMesh* LPD3DXPMESH

Definition at line 174 of file d3dx9mesh.h.

LPD3DXPRTBUFFER

typedef struct ID3DXPRTBuffer* LPD3DXPRTBUFFER

Definition at line 178 of file d3dx9mesh.h.

LPD3DXPRTCOMPBUFFER

typedef struct ID3DXPRTCompBuffer* LPD3DXPRTCOMPBUFFER

Definition at line 179 of file d3dx9mesh.h.

LPD3DXPRTENGINE

typedef struct ID3DXPRTEngine* LPD3DXPRTENGINE

Definition at line 180 of file d3dx9mesh.h.

LPD3DXSHPRTSIMCB

typedef HRESULT(WINAPI * LPD3DXSHPRTSIMCB) (float complete, void *ctx)

Definition at line 302 of file d3dx9mesh.h.

LPD3DXSKININFO

typedef struct ID3DXSkinInfo* LPD3DXSKININFO

Definition at line 176 of file d3dx9mesh.h.

LPD3DXSPMESH

typedef struct ID3DXSPMesh* LPD3DXSPMESH

Definition at line 175 of file d3dx9mesh.h.

LPD3DXTEXTUREGUTTERHELPER

typedef struct ID3DXTextureGutterHelper* LPD3DXTEXTUREGUTTERHELPER

Definition at line 181 of file d3dx9mesh.h.

LPD3DXUVATLASCB

typedef HRESULT(WINAPI * LPD3DXUVATLASCB) (float complete, void *ctx)

Definition at line 300 of file d3dx9mesh.h.

LPD3DXWELDEPSILONS

typedef struct _D3DXWELDEPSILONS * LPD3DXWELDEPSILONS

XFILECOMPRESSEDANIMATIONSET

typedef struct _XFILECOMPRESSEDANIMATIONSET XFILECOMPRESSEDANIMATIONSET

Enumeration Type Documentation

_D3DXEFFECTDEFAULTTYPE

enum _D3DXEFFECTDEFAULTTYPE

Enumerator
D3DXEDT_STRING
D3DXEDT_FLOATS
D3DXEDT_DWORD
D3DXEDT_FORCEDWORD

Definition at line 139 of file d3dx9mesh.h.

{
    D3DXEDT_STRING     = 1,
    D3DXEDT_FLOATS     = 2,
    D3DXEDT_DWORD      = 3,
    D3DXEDT_FORCEDWORD = 0x7fffffff,
} D3DXEFFECTDEFAULTTYPE;

_D3DXIMT

enum _D3DXIMT

Enumerator
D3DXIMT_WRAP_U
D3DXIMT_WRAP_V
D3DXIMT_WRAP_UV

Definition at line 125 of file d3dx9mesh.h.

{
    D3DXIMT_WRAP_U   = 0x01,
    D3DXIMT_WRAP_V   = 0x02,
    D3DXIMT_WRAP_UV  = 0x03,
} D3DXIMT;

_D3DXMESH

enum _D3DXMESH

Enumerator
D3DXMESH_32BIT
D3DXMESH_DONOTCLIP
D3DXMESH_POINTS
D3DXMESH_RTPATCHES
D3DXMESH_NPATCHES
D3DXMESH_VB_SYSTEMMEM
D3DXMESH_VB_MANAGED
D3DXMESH_VB_WRITEONLY
D3DXMESH_VB_DYNAMIC
D3DXMESH_VB_SOFTWAREPROCESSING
D3DXMESH_IB_SYSTEMMEM
D3DXMESH_IB_MANAGED
D3DXMESH_IB_WRITEONLY
D3DXMESH_IB_DYNAMIC
D3DXMESH_IB_SOFTWAREPROCESSING
D3DXMESH_VB_SHARE
D3DXMESH_USEHWONLY
D3DXMESH_SYSTEMMEM
D3DXMESH_MANAGED
D3DXMESH_WRITEONLY
D3DXMESH_DYNAMIC
D3DXMESH_SOFTWAREPROCESSING

Definition at line 44 of file d3dx9mesh.h.

{
    D3DXMESH_32BIT                 = 0x001,
    D3DXMESH_DONOTCLIP             = 0x002,
    D3DXMESH_POINTS                = 0x004,
    D3DXMESH_RTPATCHES             = 0x008,
    D3DXMESH_NPATCHES              = 0x4000,
    D3DXMESH_VB_SYSTEMMEM          = 0x010,
    D3DXMESH_VB_MANAGED            = 0x020,
    D3DXMESH_VB_WRITEONLY          = 0x040,
    D3DXMESH_VB_DYNAMIC            = 0x080,
    D3DXMESH_VB_SOFTWAREPROCESSING = 0x8000,
    D3DXMESH_IB_SYSTEMMEM          = 0x100,
    D3DXMESH_IB_MANAGED            = 0x200,
    D3DXMESH_IB_WRITEONLY          = 0x400,
    D3DXMESH_IB_DYNAMIC            = 0x800,
    D3DXMESH_IB_SOFTWAREPROCESSING = 0x10000,
    D3DXMESH_VB_SHARE              = 0x1000,
    D3DXMESH_USEHWONLY             = 0x2000,
    D3DXMESH_SYSTEMMEM             = 0x110,
    D3DXMESH_MANAGED               = 0x220,
    D3DXMESH_WRITEONLY             = 0x440,
    D3DXMESH_DYNAMIC               = 0x880,
    D3DXMESH_SOFTWAREPROCESSING    = 0x18000
};

_D3DXMESHOPT

enum _D3DXMESHOPT

Enumerator
D3DXMESHOPT_DEVICEINDEPENDENT
D3DXMESHOPT_COMPACT
D3DXMESHOPT_ATTRSORT
D3DXMESHOPT_VERTEXCACHE
D3DXMESHOPT_STRIPREORDER
D3DXMESHOPT_IGNOREVERTS
D3DXMESHOPT_DONOTSPLIT

Definition at line 70 of file d3dx9mesh.h.

{
    D3DXMESHOPT_DEVICEINDEPENDENT = 0x00400000,
    D3DXMESHOPT_COMPACT           = 0x01000000,
    D3DXMESHOPT_ATTRSORT          = 0x02000000,
    D3DXMESHOPT_VERTEXCACHE       = 0x04000000,
    D3DXMESHOPT_STRIPREORDER      = 0x08000000,
    D3DXMESHOPT_IGNOREVERTS       = 0x10000000,
    D3DXMESHOPT_DONOTSPLIT        = 0x20000000,
};

_D3DXMESHSIMP

enum _D3DXMESHSIMP

Enumerator
D3DXMESHSIMP_VERTEX
D3DXMESHSIMP_FACE

Definition at line 94 of file d3dx9mesh.h.

{
    D3DXMESHSIMP_VERTEX = 0x1,
    D3DXMESHSIMP_FACE   = 0x2,
};

_D3DXPATCHMESH

enum _D3DXPATCHMESH

Enumerator
D3DXPATCHMESH_DEFAULT

Definition at line 89 of file d3dx9mesh.h.

{
    D3DXPATCHMESH_DEFAULT = 0,
};

_D3DXPATCHMESHTYPE

enum _D3DXPATCHMESHTYPE

Enumerator
D3DXPATCHMESH_RECT
D3DXPATCHMESH_TRI
D3DXPATCHMESH_NPATCH
D3DXPATCHMESH_FORCE_DWORD

Definition at line 81 of file d3dx9mesh.h.

{
    D3DXPATCHMESH_RECT        = 1,
    D3DXPATCHMESH_TRI         = 2,
    D3DXPATCHMESH_NPATCH      = 3,
    D3DXPATCHMESH_FORCE_DWORD = 0x7fffffff,
} D3DXPATCHMESHTYPE;

_D3DXSHCOMPRESSQUALITYTYPE

enum _D3DXSHCOMPRESSQUALITYTYPE

Enumerator
D3DXSHCQUAL_FASTLOWQUALITY
D3DXSHCQUAL_SLOWHIGHQUALITY
D3DXSHCQUAL_FORCE_DWORD

Definition at line 155 of file d3dx9mesh.h.

{
    D3DXSHCQUAL_FASTLOWQUALITY  = 1,
    D3DXSHCQUAL_SLOWHIGHQUALITY = 2,
    D3DXSHCQUAL_FORCE_DWORD     = 0x7fffffff,
} D3DXSHCOMPRESSQUALITYTYPE;

_D3DXSHGPUSIMOPT

enum _D3DXSHGPUSIMOPT

Enumerator
D3DXSHGPUSIMOPT_SHADOWRES256
D3DXSHGPUSIMOPT_SHADOWRES512
D3DXSHGPUSIMOPT_SHADOWRES1024
D3DXSHGPUSIMOPT_SHADOWRES2048
D3DXSHGPUSIMOPT_HIGHQUALITY
D3DXSHGPUSIMOPT_FORCE_DWORD

Definition at line 162 of file d3dx9mesh.h.

{
    D3DXSHGPUSIMOPT_SHADOWRES256   = 1,
    D3DXSHGPUSIMOPT_SHADOWRES512   = 0,
    D3DXSHGPUSIMOPT_SHADOWRES1024  = 2,
    D3DXSHGPUSIMOPT_SHADOWRES2048  = 3,
    D3DXSHGPUSIMOPT_HIGHQUALITY    = 4,
    D3DXSHGPUSIMOPT_FORCE_DWORD    = 0x7fffffff,
} D3DXSHGPUSIMOPT;

_D3DXTANGENT

enum _D3DXTANGENT

Enumerator
D3DXTANGENT_WRAP_U
D3DXTANGENT_WRAP_V
D3DXTANGENT_WRAP_UV
D3DXTANGENT_DONT_NORMALIZE_PARTIALS
D3DXTANGENT_DONT_ORTHOGONALIZE
D3DXTANGENT_ORTHOGONALIZE_FROM_V
D3DXTANGENT_ORTHOGONALIZE_FROM_U
D3DXTANGENT_WEIGHT_BY_AREA
D3DXTANGENT_WEIGHT_EQUAL
D3DXTANGENT_WIND_CW
D3DXTANGENT_CALCULATE_NORMALS
D3DXTANGENT_GENERATE_IN_PLACE

Definition at line 109 of file d3dx9mesh.h.

{
    D3DXTANGENT_WRAP_U =                  0x0001,
    D3DXTANGENT_WRAP_V =                  0x0002,
    D3DXTANGENT_WRAP_UV =                 0x0003,
    D3DXTANGENT_DONT_NORMALIZE_PARTIALS = 0x0004,
    D3DXTANGENT_DONT_ORTHOGONALIZE =      0x0008,
    D3DXTANGENT_ORTHOGONALIZE_FROM_V =    0x0010,
    D3DXTANGENT_ORTHOGONALIZE_FROM_U =    0x0020,
    D3DXTANGENT_WEIGHT_BY_AREA =          0x0040,
    D3DXTANGENT_WEIGHT_EQUAL =            0x0080,
    D3DXTANGENT_WIND_CW =                 0x0100,
    D3DXTANGENT_CALCULATE_NORMALS =       0x0200,
    D3DXTANGENT_GENERATE_IN_PLACE =       0x0400,
} D3DXTANGENT;

_D3DXUVATLAS

enum _D3DXUVATLAS

Enumerator
D3DXUVATLAS_DEFAULT
D3DXUVATLAS_GEODESIC_FAST
D3DXUVATLAS_GEODESIC_QUALITY

Definition at line 132 of file d3dx9mesh.h.

{
    D3DXUVATLAS_DEFAULT          = 0x00,
    D3DXUVATLAS_GEODESIC_FAST    = 0x01,
    D3DXUVATLAS_GEODESIC_QUALITY = 0x02,
} D3DXUVATLAS;

_D3DXWELDEPSILONSFLAGS

enum _D3DXWELDEPSILONSFLAGS

Enumerator
D3DXWELDEPSILONS_WELDALL
D3DXWELDEPSILONS_WELDPARTIALMATCHES
D3DXWELDEPSILONS_DONOTREMOVEVERTICES
D3DXWELDEPSILONS_DONOTSPLIT

Definition at line 147 of file d3dx9mesh.h.

{
    D3DXWELDEPSILONS_WELDALL             = 0x1,
    D3DXWELDEPSILONS_WELDPARTIALMATCHES  = 0x2,
    D3DXWELDEPSILONS_DONOTREMOVEVERTICES = 0x4,
    D3DXWELDEPSILONS_DONOTSPLIT          = 0x8,
};

_MAX_FVF_DECL_SIZE

enum _MAX_FVF_DECL_SIZE

Enumerator
MAX_FVF_DECL_SIZE

Definition at line 39 of file d3dx9mesh.h.

{
    MAX_FVF_DECL_SIZE = MAXD3DDECLLENGTH + 1
};

D3DXCLEANTYPE

enum D3DXCLEANTYPE

Enumerator
D3DXCLEAN_BACKFACING
D3DXCLEAN_BOWTIES
D3DXCLEAN_SKINNING
D3DXCLEAN_OPTIMIZATION
D3DXCLEAN_SIMPLIFICATION

Definition at line 100 of file d3dx9mesh.h.

                           {
    D3DXCLEAN_BACKFACING     = 0x00000001,
    D3DXCLEAN_BOWTIES        = 0x00000002,
 
    D3DXCLEAN_SKINNING       = D3DXCLEAN_BACKFACING,
    D3DXCLEAN_OPTIMIZATION   = D3DXCLEAN_BACKFACING,
    D3DXCLEAN_SIMPLIFICATION = D3DXCLEAN_BACKFACING | D3DXCLEAN_BOWTIES,
} D3DXCLEANTYPE;

Function Documentation

D3DXBoxBoundProbe()

BOOL WINAPI D3DXBoxBoundProbe	(	const D3DXVECTOR3 *	vmin,
		const D3DXVECTOR3 *	vmax,
		const D3DXVECTOR3 *	ray_pos,
		const D3DXVECTOR3 *	ray_dir
	)

Definition at line 1911 of file mesh.c.

{
    FLOAT div, tmin, tmax, tymin, tymax, tzmin, tzmax;
 
    div = 1.0f / praydirection->x;
    if ( div >= 0.0f )
    {
        tmin = ( pmin->x - prayposition->x ) * div;
        tmax = ( pmax->x - prayposition->x ) * div;
    }
    else
    {
        tmin = ( pmax->x - prayposition->x ) * div;
        tmax = ( pmin->x - prayposition->x ) * div;
    }
 
    if ( tmax < 0.0f ) return FALSE;
 
    div = 1.0f / praydirection->y;
    if ( div >= 0.0f )
    {
        tymin = ( pmin->y - prayposition->y ) * div;
        tymax = ( pmax->y - prayposition->y ) * div;
    }
    else
    {
        tymin = ( pmax->y - prayposition->y ) * div;
        tymax = ( pmin->y - prayposition->y ) * div;
    }
 
    if ( ( tymax < 0.0f ) || ( tmin > tymax ) || ( tymin > tmax ) ) return FALSE;
 
    if ( tymin > tmin ) tmin = tymin;
    if ( tymax < tmax ) tmax = tymax;
 
    div = 1.0f / praydirection->z;
    if ( div >= 0.0f )
    {
        tzmin = ( pmin->z - prayposition->z ) * div;
        tzmax = ( pmax->z - prayposition->z ) * div;
    }
    else
    {
        tzmin = ( pmax->z - prayposition->z ) * div;
        tzmax = ( pmin->z - prayposition->z ) * div;
    }
 
    if ( (tzmax < 0.0f ) || ( tmin > tzmax ) || ( tzmin > tmax ) ) return FALSE;
 
    return TRUE;
}

Referenced by D3DXBoundProbeTest().

D3DXCleanMesh()

HRESULT WINAPI D3DXCleanMesh	(	D3DXCLEANTYPE	clean_type,
		ID3DXMesh *	mesh_in,
		const DWORD *	adjacency_in,
		ID3DXMesh **	mesh_out,
		DWORD *	adjacency_out,
		ID3DXBuffer **	errors
	)

Definition at line 4002 of file mesh.c.

{
    FIXME("(%u, %p, %p, %p, %p, %p)\n", clean_type, mesh_in, adjacency_in, mesh_out, adjacency_out, errors_and_warnings);
 
    return E_NOTIMPL;
}

D3DXComputeBoundingBox()

HRESULT WINAPI D3DXComputeBoundingBox	(	const D3DXVECTOR3 *	first_pos,
		DWORD	num_vertices,
		DWORD	stride,
		D3DXVECTOR3 *	vmin,
		D3DXVECTOR3 *	vmax
	)

Definition at line 1964 of file mesh.c.

{
    D3DXVECTOR3 vec;
    unsigned int i;
 
    if( !pfirstposition || !pmin || !pmax ) return D3DERR_INVALIDCALL;
 
    *pmin = *pfirstposition;
    *pmax = *pmin;
 
    for(i=0; i<numvertices; i++)
    {
        vec = *( (const D3DXVECTOR3*)((const char*)pfirstposition + dwstride * i) );
 
        if ( vec.x < pmin->x ) pmin->x = vec.x;
        if ( vec.x > pmax->x ) pmax->x = vec.x;
 
        if ( vec.y < pmin->y ) pmin->y = vec.y;
        if ( vec.y > pmax->y ) pmax->y = vec.y;
 
        if ( vec.z < pmin->z ) pmin->z = vec.z;
        if ( vec.z > pmax->z ) pmax->z = vec.z;
    }
 
    return D3D_OK;
}

Referenced by D3DXComputeBoundingBoxTest().

D3DXComputeBoundingSphere()

HRESULT WINAPI D3DXComputeBoundingSphere	(	const D3DXVECTOR3 *	first_pos,
		DWORD	num_vertices,
		DWORD	stride,
		D3DXVECTOR3 *	center,
		FLOAT *	radius
	)

Definition at line 1992 of file mesh.c.

{
    D3DXVECTOR3 temp;
    FLOAT d;
    unsigned int i;
 
    if( !pfirstposition || !pcenter || !pradius ) return D3DERR_INVALIDCALL;
 
    temp.x = 0.0f;
    temp.y = 0.0f;
    temp.z = 0.0f;
    *pradius = 0.0f;
 
    for(i=0; i<numvertices; i++)
        D3DXVec3Add(&temp, &temp, (const D3DXVECTOR3*)((const char*)pfirstposition + dwstride * i));
 
    D3DXVec3Scale(pcenter, &temp, 1.0f / numvertices);
 
    for(i=0; i<numvertices; i++)
    {
        d = D3DXVec3Length(D3DXVec3Subtract(&temp, (const D3DXVECTOR3*)((const char*)pfirstposition + dwstride * i), pcenter));
        if ( d > *pradius ) *pradius = d;
    }
    return D3D_OK;
}

Referenced by D3DXComputeBoundingSphereTest().

D3DXComputeIMTFromPerTexelSignal()

HRESULT WINAPI D3DXComputeIMTFromPerTexelSignal	(	ID3DXMesh *	mesh,
		DWORD	texture_idx,
		float *	texel_signal,
		UINT	width,
		UINT	height,
		UINT	signal_dimension,
		UINT	component_count,
		DWORD	flags,
		LPD3DXUVATLASCB	cb,
		void *	ctx,
		ID3DXBuffer **	buffer
	)

D3DXComputeIMTFromPerVertexSignal()

HRESULT WINAPI D3DXComputeIMTFromPerVertexSignal	(	ID3DXMesh *	mesh,
		const float *	vertex_signal,
		UINT	signal_dimension,
		UINT	signal_stride,
		DWORD	flags,
		LPD3DXUVATLASCB	cb,
		void *	ctx,
		ID3DXBuffer **	buffer
	)

D3DXComputeIMTFromSignal()

HRESULT WINAPI D3DXComputeIMTFromSignal	(	ID3DXMesh *	mesh,
		DWORD	texture_idx,
		UINT	signal_dimension,
		float	max_uv_distance,
		DWORD	flags,
		LPD3DXIMTSIGNALCALLBACK	signal_cb,
		void *	signal_ctx,
		LPD3DXUVATLASCB	status_cb,
		void *	status_ctx,
		ID3DXBuffer **	buffer
	)

D3DXComputeIMTFromTexture()

HRESULT WINAPI D3DXComputeIMTFromTexture	(	struct ID3DXMesh *	mesh,
		struct IDirect3DTexture9 *	texture,
		DWORD	texture_idx,
		DWORD	options,
		LPD3DXUVATLASCB	cb,
		void *	ctx,
		struct ID3DXBuffer **	out
	)

D3DXComputeNormals()

HRESULT WINAPI D3DXComputeNormals	(	ID3DXBaseMesh *	mesh,
		const DWORD *	adjacency
	)

Definition at line 7563 of file mesh.c.

{
    TRACE("mesh %p, adjacency %p\n", mesh, adjacency);
 
    if (mesh && (ID3DXMeshVtbl *)mesh->lpVtbl != &D3DXMesh_Vtbl)
    {
        ERR("Invalid virtual table\n");
        return D3DERR_INVALIDCALL;
    }
 
    return D3DXComputeTangentFrameEx((ID3DXMesh *)mesh, D3DX_DEFAULT, 0,
            D3DX_DEFAULT, 0, D3DX_DEFAULT, 0, D3DDECLUSAGE_NORMAL, 0,
            D3DXTANGENT_GENERATE_IN_PLACE | D3DXTANGENT_CALCULATE_NORMALS,
            adjacency, -1.01f, -0.01f, -1.01f, NULL, NULL);
}

Referenced by compute_normals_D3DXComputeNormals().

D3DXComputeTangent()

HRESULT WINAPI D3DXComputeTangent	(	ID3DXMesh *	mesh,
		DWORD	stage,
		DWORD	tangent_idx,
		DWORD	binorm_idx,
		DWORD	wrap,
		const DWORD *	adjacency
	)

Definition at line 7545 of file mesh.c.

{
    TRACE("mesh %p, stage_idx %d, tangent_idx %d, binorm_idx %d, wrap %d, adjacency %p.\n",
           mesh, stage_idx, tangent_idx, binorm_idx, wrap, adjacency);
 
    return D3DXComputeTangentFrameEx( mesh, D3DDECLUSAGE_TEXCOORD, stage_idx,
            ( binorm_idx == D3DX_DEFAULT ) ? D3DX_DEFAULT : D3DDECLUSAGE_BINORMAL,
            binorm_idx,
            ( tangent_idx == D3DX_DEFAULT ) ? D3DX_DEFAULT : D3DDECLUSAGE_TANGENT,
            tangent_idx, D3DX_DEFAULT, 0,
            ( wrap ? D3DXTANGENT_WRAP_UV : 0 ) | D3DXTANGENT_GENERATE_IN_PLACE | D3DXTANGENT_ORTHOGONALIZE_FROM_U,
            adjacency, -1.01f, -0.01f, -1.01f, NULL, NULL);
}

D3DXComputeTangentFrameEx()

HRESULT WINAPI D3DXComputeTangentFrameEx	(	ID3DXMesh *	mesh_in,
		DWORD	texture_in_semantic,
		DWORD	texture_in_idx,
		DWORD	u_partial_out_semantic,
		DWORD	u_partial_out_idx,
		DWORD	v_partial_out_semantic,
		DWORD	v_partial_out_idx,
		DWORD	normal_out_semantic,
		DWORD	normal_out_idx,
		DWORD	flags,
		const DWORD *	adjacency,
		float	partial_edge_threshold,
		float	singular_point_threshold,
		float	normal_edge_threshold,
		ID3DXMesh **	mesh_out,
		ID3DXBuffer **	buffer
	)

Definition at line 7320 of file mesh.c.

{
    HRESULT hr;
    void *indices = NULL;
    BYTE *vertices = NULL;
    DWORD *point_reps = NULL;
    size_t normal_size;
    BOOL indices_are_32bit;
    DWORD i, j, num_faces, num_vertices, vertex_stride;
    D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE] = {D3DDECL_END()};
    D3DVERTEXELEMENT9 *position_declaration = NULL, *normal_declaration = NULL;
    DWORD weighting_method = options & (D3DXTANGENT_WEIGHT_EQUAL | D3DXTANGENT_WEIGHT_BY_AREA);
 
    TRACE("mesh %p, texture_in_semantic %u, texture_in_index %u, u_partial_out_semantic %u, u_partial_out_index %u, "
            "v_partial_out_semantic %u, v_partial_out_index %u, normal_out_semantic %u, normal_out_index %u, "
            "options %#x, adjacency %p, partial_edge_threshold %f, singular_point_threshold %f, "
            "normal_edge_threshold %f, mesh_out %p, vertex_mapping %p\n",
            mesh, texture_in_semantic, texture_in_index, u_partial_out_semantic, u_partial_out_index,
            v_partial_out_semantic, v_partial_out_index, normal_out_semantic, normal_out_index, options, adjacency,
            partial_edge_threshold, singular_point_threshold, normal_edge_threshold, mesh_out, vertex_mapping);
 
    if (!mesh)
    {
        WARN("mesh is NULL\n");
        return D3DERR_INVALIDCALL;
    }
 
    if (weighting_method == (D3DXTANGENT_WEIGHT_EQUAL | D3DXTANGENT_WEIGHT_BY_AREA))
    {
        WARN("D3DXTANGENT_WEIGHT_BY_AREA and D3DXTANGENT_WEIGHT_EQUAL are mutally exclusive\n");
        return D3DERR_INVALIDCALL;
    }
 
    if (u_partial_out_semantic != D3DX_DEFAULT)
    {
        FIXME("tangent vectors computation is not supported\n");
        return E_NOTIMPL;
    }
 
    if (v_partial_out_semantic != D3DX_DEFAULT)
    {
        FIXME("binormal vectors computation is not supported\n");
        return E_NOTIMPL;
    }
 
    if (options & ~(D3DXTANGENT_GENERATE_IN_PLACE | D3DXTANGENT_CALCULATE_NORMALS | D3DXTANGENT_WEIGHT_EQUAL | D3DXTANGENT_WEIGHT_BY_AREA))
    {
        FIXME("unsupported options %#x\n", options);
        return E_NOTIMPL;
    }
 
    if (!(options & D3DXTANGENT_CALCULATE_NORMALS))
    {
        FIXME("only normals computation is supported\n");
        return E_NOTIMPL;
    }
 
    if (!(options & D3DXTANGENT_GENERATE_IN_PLACE) || mesh_out || vertex_mapping)
    {
        FIXME("only D3DXTANGENT_GENERATE_IN_PLACE is supported\n");
        return E_NOTIMPL;
    }
 
    if (FAILED(hr = mesh->lpVtbl->GetDeclaration(mesh, declaration)))
        return hr;
 
    for (i = 0; declaration[i].Stream != 0xff; i++)
    {
        if (declaration[i].Usage == D3DDECLUSAGE_POSITION && !declaration[i].UsageIndex)
            position_declaration = &declaration[i];
        if (declaration[i].Usage == normal_out_semantic && declaration[i].UsageIndex == normal_out_index)
            normal_declaration = &declaration[i];
    }
 
    if (!position_declaration || !normal_declaration)
        return D3DERR_INVALIDCALL;
 
    if (normal_declaration->Type == D3DDECLTYPE_FLOAT3)
    {
        normal_size = sizeof(D3DXVECTOR3);
    }
    else if (normal_declaration->Type == D3DDECLTYPE_FLOAT4)
    {
        normal_size = sizeof(D3DXVECTOR4);
    }
    else
    {
        WARN("unsupported normals type %u\n", normal_declaration->Type);
        return D3DERR_INVALIDCALL;
    }
 
    num_faces = mesh->lpVtbl->GetNumFaces(mesh);
    num_vertices = mesh->lpVtbl->GetNumVertices(mesh);
    vertex_stride = mesh->lpVtbl->GetNumBytesPerVertex(mesh);
    indices_are_32bit = mesh->lpVtbl->GetOptions(mesh) & D3DXMESH_32BIT;
 
    point_reps = HeapAlloc(GetProcessHeap(), 0, num_vertices * sizeof(*point_reps));
    if (!point_reps)
    {
        hr = E_OUTOFMEMORY;
        goto done;
    }
 
    if (adjacency)
    {
        if (FAILED(hr = mesh->lpVtbl->ConvertAdjacencyToPointReps(mesh, adjacency, point_reps)))
            goto done;
    }
    else
    {
        for (i = 0; i < num_vertices; i++)
            point_reps[i] = i;
    }
 
    if (FAILED(hr = mesh->lpVtbl->LockIndexBuffer(mesh, 0, &indices)))
        goto done;
 
    if (FAILED(hr = mesh->lpVtbl->LockVertexBuffer(mesh, 0, (void **)&vertices)))
        goto done;
 
    for (i = 0; i < num_vertices; i++)
    {
        static const D3DXVECTOR4 default_vector = {0.0f, 0.0f, 0.0f, 1.0f};
        void *normal = vertices + normal_declaration->Offset + i * vertex_stride;
 
        memcpy(normal, &default_vector, normal_size);
    }
 
    for (i = 0; i < num_faces; i++)
    {
        float denominator, weights[3];
        D3DXVECTOR3 a, b, cross, face_normal;
        const DWORD face_indices[3] =
        {
            read_ib(indices, indices_are_32bit, 3 * i + 0),
            read_ib(indices, indices_are_32bit, 3 * i + 1),
            read_ib(indices, indices_are_32bit, 3 * i + 2)
        };
        const D3DXVECTOR3 v0 = read_vec3(vertices, position_declaration, vertex_stride, face_indices[0]);
        const D3DXVECTOR3 v1 = read_vec3(vertices, position_declaration, vertex_stride, face_indices[1]);
        const D3DXVECTOR3 v2 = read_vec3(vertices, position_declaration, vertex_stride, face_indices[2]);
 
        D3DXVec3Cross(&cross, D3DXVec3Subtract(&a, &v0, &v1), D3DXVec3Subtract(&b, &v0, &v2));
 
        switch (weighting_method)
        {
            case D3DXTANGENT_WEIGHT_EQUAL:
                weights[0] = weights[1] = weights[2] = 1.0f;
                break;
            case D3DXTANGENT_WEIGHT_BY_AREA:
                weights[0] = weights[1] = weights[2] = D3DXVec3Length(&cross);
                break;
            default:
                /* weight by angle */
                denominator = D3DXVec3Length(&a) * D3DXVec3Length(&b);
                if (!denominator)
                    weights[0] = 0.0f;
                else
                    weights[0] = acosf(D3DXVec3Dot(&a, &b) / denominator);
 
                D3DXVec3Subtract(&a, &v1, &v0);
                D3DXVec3Subtract(&b, &v1, &v2);
                denominator = D3DXVec3Length(&a) * D3DXVec3Length(&b);
                if (!denominator)
                    weights[1] = 0.0f;
                else
                    weights[1] = acosf(D3DXVec3Dot(&a, &b) / denominator);
 
                D3DXVec3Subtract(&a, &v2, &v0);
                D3DXVec3Subtract(&b, &v2, &v1);
                denominator = D3DXVec3Length(&a) * D3DXVec3Length(&b);
                if (!denominator)
                    weights[2] = 0.0f;
                else
                    weights[2] = acosf(D3DXVec3Dot(&a, &b) / denominator);
 
                break;
        }
 
        D3DXVec3Normalize(&face_normal, &cross);
 
        for (j = 0; j < 3; j++)
        {
            D3DXVECTOR3 normal;
            DWORD rep_index = point_reps[face_indices[j]];
            D3DXVECTOR3 *rep_normal = vertex_element_vec3(vertices, normal_declaration, vertex_stride, rep_index);
 
            D3DXVec3Scale(&normal, &face_normal, weights[j]);
            D3DXVec3Add(rep_normal, rep_normal, &normal);
        }
    }
 
    for (i = 0; i < num_vertices; i++)
    {
        DWORD rep_index = point_reps[i];
        D3DXVECTOR3 *normal = vertex_element_vec3(vertices, normal_declaration, vertex_stride, i);
        D3DXVECTOR3 *rep_normal = vertex_element_vec3(vertices, normal_declaration, vertex_stride, rep_index);
 
        if (i == rep_index)
            D3DXVec3Normalize(rep_normal, rep_normal);
        else
            *normal = *rep_normal;
    }
 
    hr = D3D_OK;
 
done:
    if (vertices)
        mesh->lpVtbl->UnlockVertexBuffer(mesh);
 
    if (indices)
        mesh->lpVtbl->UnlockIndexBuffer(mesh);
 
    HeapFree(GetProcessHeap(), 0, point_reps);
 
    return hr;
}

Referenced by compute_normals_D3DXComputeTangentFrameEx(), D3DXComputeNormals(), D3DXComputeTangent(), and test_compute_normals().

D3DXConcatenateMeshes()

HRESULT WINAPI D3DXConcatenateMeshes	(	struct ID3DXMesh **	meshes,
		UINT	mesh_count,
		DWORD	flags,
		const D3DXMATRIX *	geometry_matrices,
		const D3DXMATRIX *	texture_matrices,
		const D3DVERTEXELEMENT9 *	declaration,
		struct IDirect3DDevice9 *	device,
		struct ID3DXMesh **	mesh
	)

D3DXConvertMeshSubsetToSingleStrip()

HRESULT WINAPI D3DXConvertMeshSubsetToSingleStrip	(	struct ID3DXBaseMesh *	mesh_in,
		DWORD	attribute_id,
		DWORD	ib_flags,
		struct IDirect3DIndexBuffer9 **	index_buffer,
		DWORD *	index_count
	)

Definition at line 7600 of file mesh.c.

{
    FIXME("mesh_in %p, attribute_id %u, ib_flags %u, index_buffer %p, index_count %p stub.\n",
            mesh_in, attribute_id, ib_flags, index_buffer, index_count);
 
    return E_NOTIMPL;
}

D3DXConvertMeshSubsetToStrips()

HRESULT WINAPI D3DXConvertMeshSubsetToStrips	(	struct ID3DXBaseMesh *	mesh_in,
		DWORD	attribute_id,
		DWORD	ib_flags,
		struct IDirect3DIndexBuffer9 **	index_buffer,
		DWORD *	index_count,
		struct ID3DXBuffer **	strip_lengths,
		DWORD *	strip_count
	)

D3DXCreateBuffer()

HRESULT WINAPI D3DXCreateBuffer	(	DWORD	size,
		ID3DXBuffer **	buffer
	)

Definition at line 131 of file core.c.

{
    struct ID3DXBufferImpl *object;
    HRESULT hr;
 
    TRACE("size %u, buffer %p.\n", size, buffer);
 
    if (!buffer)
    {
        WARN("Invalid buffer specified.\n");
        return D3DERR_INVALIDCALL;
    }
 
    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
    if (!object)
        return E_OUTOFMEMORY;
 
    hr = d3dx9_buffer_init(object, size);
    if (FAILED(hr))
    {
        WARN("Failed to initialize buffer, hr %#x.\n", hr);
        HeapFree(GetProcessHeap(), 0, object);
        return hr;
    }
 
    *buffer = &object->ID3DXBuffer_iface;
 
    TRACE("Created ID3DXBuffer %p.\n", *buffer);
 
    return D3D_OK;
}

D3DXCreateMesh()

HRESULT WINAPI D3DXCreateMesh	(	DWORD	face_count,
		DWORD	vertex_count,
		DWORD	flags,
		const D3DVERTEXELEMENT9 *	declaration,
		struct IDirect3DDevice9 *	device,
		struct ID3DXMesh **	mesh
	)

Definition at line 2433 of file mesh.c.

{
    HRESULT hr;
    DWORD fvf;
    IDirect3DVertexDeclaration9 *vertex_declaration;
    UINT vertex_declaration_size;
    UINT num_elem;
    IDirect3DVertexBuffer9 *vertex_buffer;
    IDirect3DIndexBuffer9 *index_buffer;
    DWORD *attrib_buffer;
    struct d3dx9_mesh *object;
    DWORD index_usage = 0;
    D3DPOOL index_pool = D3DPOOL_DEFAULT;
    D3DFORMAT index_format = D3DFMT_INDEX16;
    DWORD vertex_usage = 0;
    D3DPOOL vertex_pool = D3DPOOL_DEFAULT;
    int i;
 
    TRACE("numfaces %u, numvertices %u, options %#x, declaration %p, device %p, mesh %p.\n",
            numfaces, numvertices, options, declaration, device, mesh);
 
    if (numfaces == 0 || numvertices == 0 || declaration == NULL || device == NULL || mesh == NULL ||
        /* D3DXMESH_VB_SHARE is for cloning, and D3DXMESH_USEHWONLY is for ConvertToBlendedMesh */
        (options & (D3DXMESH_VB_SHARE | D3DXMESH_USEHWONLY | 0xfffe0000)))
    {
        return D3DERR_INVALIDCALL;
    }
    for (i = 0; declaration[i].Stream != 0xff; i++)
        if (declaration[i].Stream != 0)
            return D3DERR_INVALIDCALL;
    num_elem = i + 1;
 
    if (options & D3DXMESH_32BIT)
        index_format = D3DFMT_INDEX32;
 
    if (options & D3DXMESH_DONOTCLIP) {
        index_usage |= D3DUSAGE_DONOTCLIP;
        vertex_usage |= D3DUSAGE_DONOTCLIP;
    }
    if (options & D3DXMESH_POINTS) {
        index_usage |= D3DUSAGE_POINTS;
        vertex_usage |= D3DUSAGE_POINTS;
    }
    if (options & D3DXMESH_RTPATCHES) {
        index_usage |= D3DUSAGE_RTPATCHES;
        vertex_usage |= D3DUSAGE_RTPATCHES;
    }
    if (options & D3DXMESH_NPATCHES) {
        index_usage |= D3DUSAGE_NPATCHES;
        vertex_usage |= D3DUSAGE_NPATCHES;
    }
 
    if (options & D3DXMESH_VB_SYSTEMMEM)
        vertex_pool = D3DPOOL_SYSTEMMEM;
    else if (options & D3DXMESH_VB_MANAGED)
        vertex_pool = D3DPOOL_MANAGED;
 
    if (options & D3DXMESH_VB_WRITEONLY)
        vertex_usage |= D3DUSAGE_WRITEONLY;
    if (options & D3DXMESH_VB_DYNAMIC)
        vertex_usage |= D3DUSAGE_DYNAMIC;
    if (options & D3DXMESH_VB_SOFTWAREPROCESSING)
        vertex_usage |= D3DUSAGE_SOFTWAREPROCESSING;
 
    if (options & D3DXMESH_IB_SYSTEMMEM)
        index_pool = D3DPOOL_SYSTEMMEM;
    else if (options & D3DXMESH_IB_MANAGED)
        index_pool = D3DPOOL_MANAGED;
 
    if (options & D3DXMESH_IB_WRITEONLY)
        index_usage |= D3DUSAGE_WRITEONLY;
    if (options & D3DXMESH_IB_DYNAMIC)
        index_usage |= D3DUSAGE_DYNAMIC;
    if (options & D3DXMESH_IB_SOFTWAREPROCESSING)
        index_usage |= D3DUSAGE_SOFTWAREPROCESSING;
 
    hr = D3DXFVFFromDeclarator(declaration, &fvf);
    if (hr != D3D_OK)
    {
        fvf = 0;
    }
 
    /* Create vertex declaration */
    hr = IDirect3DDevice9_CreateVertexDeclaration(device,
                                                  declaration,
                                                  &vertex_declaration);
    if (FAILED(hr))
    {
        WARN("Unexpected return value %x from IDirect3DDevice9_CreateVertexDeclaration.\n",hr);
        return hr;
    }
    vertex_declaration_size = D3DXGetDeclVertexSize(declaration, declaration[0].Stream);
 
    /* Create vertex buffer */
    hr = IDirect3DDevice9_CreateVertexBuffer(device,
                                             numvertices * vertex_declaration_size,
                                             vertex_usage,
                                             fvf,
                                             vertex_pool,
                                             &vertex_buffer,
                                             NULL);
    if (FAILED(hr))
    {
        WARN("Unexpected return value %x from IDirect3DDevice9_CreateVertexBuffer.\n",hr);
        IDirect3DVertexDeclaration9_Release(vertex_declaration);
        return hr;
    }
 
    /* Create index buffer */
    hr = IDirect3DDevice9_CreateIndexBuffer(device,
                                            numfaces * 3 * ((index_format == D3DFMT_INDEX16) ? 2 : 4),
                                            index_usage,
                                            index_format,
                                            index_pool,
                                            &index_buffer,
                                            NULL);
    if (FAILED(hr))
    {
        WARN("Unexpected return value %x from IDirect3DDevice9_CreateVertexBuffer.\n",hr);
        IDirect3DVertexBuffer9_Release(vertex_buffer);
        IDirect3DVertexDeclaration9_Release(vertex_declaration);
        return hr;
    }
 
    attrib_buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, numfaces * sizeof(*attrib_buffer));
    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
    if (object == NULL || attrib_buffer == NULL)
    {
        HeapFree(GetProcessHeap(), 0, object);
        HeapFree(GetProcessHeap(), 0, attrib_buffer);
        IDirect3DIndexBuffer9_Release(index_buffer);
        IDirect3DVertexBuffer9_Release(vertex_buffer);
        IDirect3DVertexDeclaration9_Release(vertex_declaration);
        *mesh = NULL;
        return E_OUTOFMEMORY;
    }
    object->ID3DXMesh_iface.lpVtbl = &D3DXMesh_Vtbl;
    object->ref = 1;
 
    object->numfaces = numfaces;
    object->numvertices = numvertices;
    object->options = options;
    object->fvf = fvf;
    object->device = device;
    IDirect3DDevice9_AddRef(device);
 
    copy_declaration(object->cached_declaration, declaration, num_elem);
    object->vertex_declaration = vertex_declaration;
    object->vertex_declaration_size = vertex_declaration_size;
    object->num_elem = num_elem;
    object->vertex_buffer = vertex_buffer;
    object->index_buffer = index_buffer;
    object->attrib_buffer = attrib_buffer;
 
    *mesh = &object->ID3DXMesh_iface;
 
    return D3D_OK;
}

Referenced by d3dx9_mesh_CloneMesh(), D3DXCreateMeshFVF(), D3DXCreateMeshTest(), init_test_mesh(), test_convert_adjacency_to_point_reps(), test_convert_point_reps_to_adjacency(), and test_update_semantics().

D3DXCreateMeshFVF()

HRESULT WINAPI D3DXCreateMeshFVF	(	DWORD	face_count,
		DWORD	vertex_count,
		DWORD	flags,
		DWORD	fvf,
		struct IDirect3DDevice9 *	device,
		struct ID3DXMesh **	mesh
	)

Definition at line 2596 of file mesh.c.

{
    HRESULT hr;
    D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE];
 
    TRACE("(%u, %u, %u, %u, %p, %p)\n", numfaces, numvertices, options, fvf, device, mesh);
 
    hr = D3DXDeclaratorFromFVF(fvf, declaration);
    if (FAILED(hr)) return hr;
 
    return D3DXCreateMesh(numfaces, numvertices, options, declaration, device, mesh);
}

Referenced by D3DXCreateBox(), D3DXCreateCylinder(), D3DXCreateMeshFVFTest(), D3DXCreatePolygon(), D3DXCreateSphere(), D3DXCreateTextW(), D3DXCreateTorus(), D3DXGenerateAdjacencyTest(), D3DXLoadMeshFromXInMemory(), and D3DXLoadSkinMeshFromXof().

D3DXCreatePatchMesh()

HRESULT WINAPI D3DXCreatePatchMesh	(	const D3DXPATCHINFO *	patch_info,
		DWORD	patch_count,
		DWORD	vertex_count,
		DWORD	flags,
		const D3DVERTEXELEMENT9 *	declaration,
		struct IDirect3DDevice9 *	device,
		struct ID3DXPatchMesh **	mesh
	)

D3DXCreatePMeshFromStream()

HRESULT WINAPI D3DXCreatePMeshFromStream	(	struct IStream *	stream,
		DWORD	flags,
		struct IDirect3DDevice9 *	device,
		struct ID3DXBuffer **	materials,
		struct ID3DXBuffer **	effect_instances,
		DWORD *	material_count,
		struct ID3DXPMesh **	mesh
	)

D3DXCreatePRTBuffer()

HRESULT WINAPI D3DXCreatePRTBuffer	(	UINT	sample_count,
		UINT	coeff_count,
		UINT	channel_count,
		ID3DXPRTBuffer **	buffer
	)

D3DXCreatePRTBufferTex()

HRESULT WINAPI D3DXCreatePRTBufferTex	(	UINT	width,
		UINT	height,
		UINT	coeff_count,
		UINT	channel_count,
		ID3DXPRTBuffer **	buffer
	)

D3DXCreatePRTCompBuffer()

HRESULT WINAPI D3DXCreatePRTCompBuffer	(	D3DXSHCOMPRESSQUALITYTYPE	quality,
		UINT	cluster_count,
		UINT	pca_count,
		LPD3DXSHPRTSIMCB	cb,
		void *	ctx,
		ID3DXPRTBuffer *	input,
		ID3DXPRTCompBuffer **	buffer
	)

D3DXCreatePRTEngine()

HRESULT WINAPI D3DXCreatePRTEngine	(	ID3DXMesh *	mesh,
		DWORD *	adjacency,
		BOOL	extract_uv,
		ID3DXMesh *	blocker_mesh,
		ID3DXPRTEngine **	engine
	)

D3DXCreateSkinInfo()

HRESULT WINAPI D3DXCreateSkinInfo	(	DWORD	vertex_count,
		const D3DVERTEXELEMENT9 *	declaration,
		DWORD	bone_count,
		ID3DXSkinInfo **	skin_info
	)

Definition at line 549 of file skin.c.

{
    HRESULT hr;
    static const D3DVERTEXELEMENT9 empty_declaration = D3DDECL_END();
    struct d3dx9_skin_info *object = NULL;
 
    TRACE("num_vertices %u, declaration %p, num_bones %u, skin_info %p.\n",
            num_vertices, declaration, num_bones, skin_info);
 
    if (!skin_info || !declaration)
        return D3DERR_INVALIDCALL;
 
    object = HeapAlloc(GetProcessHeap(), 0, sizeof(*object));
    if (!object)
        return E_OUTOFMEMORY;
 
    object->ID3DXSkinInfo_iface.lpVtbl = &d3dx9_skin_info_vtbl;
    object->ref = 1;
    object->num_vertices = num_vertices;
    object->num_bones = num_bones;
    object->vertex_declaration[0] = empty_declaration;
    object->fvf = 0;
 
    object->bones = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, num_bones * sizeof(*object->bones));
    if (!object->bones) {
        hr = E_OUTOFMEMORY;
        goto error;
    }
 
    if (FAILED(hr = d3dx9_skin_info_SetDeclaration(&object->ID3DXSkinInfo_iface, declaration)))
        goto error;
 
    *skin_info = &object->ID3DXSkinInfo_iface;
 
    return D3D_OK;
error:
    HeapFree(GetProcessHeap(), 0, object->bones);
    HeapFree(GetProcessHeap(), 0, object);
    return hr;
}

Referenced by d3dx9_skin_info_Clone(), D3DXCreateSkinInfoFVF(), and test_create_skin_info().

D3DXCreateSkinInfoFromBlendedMesh()

HRESULT WINAPI D3DXCreateSkinInfoFromBlendedMesh	(	ID3DXBaseMesh *	mesh,
		DWORD	bone_count,
		const D3DXBONECOMBINATION *	bone_combination_table,
		ID3DXSkinInfo **	skin_info
	)

D3DXCreateSkinInfoFVF()

HRESULT WINAPI D3DXCreateSkinInfoFVF	(	DWORD	vertex_count,
		DWORD	fvf,
		DWORD	bone_count,
		ID3DXSkinInfo **	skin_info
	)

Definition at line 591 of file skin.c.

{
    HRESULT hr;
    D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE];
 
    TRACE("(%u, %x, %u, %p)\n", num_vertices, fvf, num_bones, skin_info);
 
    hr = D3DXDeclaratorFromFVF(fvf, declaration);
    if (FAILED(hr))
        return hr;
 
    return D3DXCreateSkinInfo(num_vertices, declaration, num_bones, skin_info);
}

Referenced by parse_mesh(), parse_skin_mesh_info(), test_create_skin_info(), and test_update_skinned_mesh().

D3DXCreateSPMesh()

HRESULT WINAPI D3DXCreateSPMesh	(	ID3DXMesh *	mesh,
		const DWORD *	adjacency,
		const D3DXATTRIBUTEWEIGHTS *	attribute_weights,
		const float *	vertex_weights,
		ID3DXSPMesh **	spmesh
	)

D3DXCreateTextureGutterHelper()

HRESULT WINAPI D3DXCreateTextureGutterHelper	(	UINT	width,
		UINT	height,
		ID3DXMesh *	mesh,
		float	gutter_size,
		ID3DXTextureGutterHelper **	gh
	)

D3DXDeclaratorFromFVF()

HRESULT WINAPI D3DXDeclaratorFromFVF	(	DWORD	fvf,
		D3DVERTEXELEMENT9	declaration[MAX_FVF_DECL_SIZE]
	)

Definition at line 2036 of file mesh.c.

{
    static const D3DVERTEXELEMENT9 end_element = D3DDECL_END();
    DWORD tex_count = (fvf & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT;
    unsigned int offset = 0;
    unsigned int idx = 0;
    unsigned int i;
 
    TRACE("fvf %#x, declaration %p.\n", fvf, declaration);
 
    if (fvf & (D3DFVF_RESERVED0 | D3DFVF_RESERVED2)) return D3DERR_INVALIDCALL;
 
    if (fvf & D3DFVF_POSITION_MASK)
    {
        BOOL has_blend = (fvf & D3DFVF_XYZB5) >= D3DFVF_XYZB1;
        DWORD blend_count = 1 + (((fvf & D3DFVF_XYZB5) - D3DFVF_XYZB1) >> 1);
        BOOL has_blend_idx = (fvf & D3DFVF_LASTBETA_D3DCOLOR) || (fvf & D3DFVF_LASTBETA_UBYTE4);
 
        if (has_blend_idx) --blend_count;
 
        if ((fvf & D3DFVF_POSITION_MASK) == D3DFVF_XYZW
                || (has_blend && blend_count > 4))
            return D3DERR_INVALIDCALL;
 
        if ((fvf & D3DFVF_POSITION_MASK) == D3DFVF_XYZRHW)
            append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT4, D3DDECLUSAGE_POSITIONT, 0);
        else
            append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT3, D3DDECLUSAGE_POSITION, 0);
 
        if (has_blend)
        {
            switch (blend_count)
            {
                 case 0:
                    break;
                 case 1:
                    append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT1, D3DDECLUSAGE_BLENDWEIGHT, 0);
                    break;
                 case 2:
                    append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT2, D3DDECLUSAGE_BLENDWEIGHT, 0);
                    break;
                 case 3:
                    append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT3, D3DDECLUSAGE_BLENDWEIGHT, 0);
                    break;
                 case 4:
                    append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT4, D3DDECLUSAGE_BLENDWEIGHT, 0);
                    break;
                 default:
                     ERR("Invalid blend count %u.\n", blend_count);
                     break;
            }
 
            if (has_blend_idx)
            {
                if (fvf & D3DFVF_LASTBETA_UBYTE4)
                    append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_UBYTE4, D3DDECLUSAGE_BLENDINDICES, 0);
                else if (fvf & D3DFVF_LASTBETA_D3DCOLOR)
                    append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_D3DCOLOR, D3DDECLUSAGE_BLENDINDICES, 0);
            }
        }
    }
 
    if (fvf & D3DFVF_NORMAL)
        append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT3, D3DDECLUSAGE_NORMAL, 0);
    if (fvf & D3DFVF_PSIZE)
        append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT1, D3DDECLUSAGE_PSIZE, 0);
    if (fvf & D3DFVF_DIFFUSE)
        append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_D3DCOLOR, D3DDECLUSAGE_COLOR, 0);
    if (fvf & D3DFVF_SPECULAR)
        append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_D3DCOLOR, D3DDECLUSAGE_COLOR, 1);
 
    for (i = 0; i < tex_count; ++i)
    {
        switch ((fvf >> (16 + 2 * i)) & 0x03)
        {
            case D3DFVF_TEXTUREFORMAT1:
                append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT1, D3DDECLUSAGE_TEXCOORD, i);
                break;
            case D3DFVF_TEXTUREFORMAT2:
                append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT2, D3DDECLUSAGE_TEXCOORD, i);
                break;
            case D3DFVF_TEXTUREFORMAT3:
                append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT3, D3DDECLUSAGE_TEXCOORD, i);
                break;
            case D3DFVF_TEXTUREFORMAT4:
                append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT4, D3DDECLUSAGE_TEXCOORD, i);
                break;
        }
    }
 
    declaration[idx] = end_element;
 
    return D3D_OK;
}

Referenced by d3dx9_mesh_CloneMeshFVF(), d3dx9_skin_info_SetFVF(), D3DXCreateMeshFVF(), D3DXCreateSkinInfoFVF(), test_create_skin_info(), and test_fvf_to_decl().

D3DXFVFFromDeclarator()

HRESULT WINAPI D3DXFVFFromDeclarator	(	const D3DVERTEXELEMENT9 *	decl,
		DWORD *	fvf
	)

Definition at line 2134 of file mesh.c.

{
    unsigned int i = 0, texture, offset;
 
    TRACE("(%p, %p)\n", declaration, fvf);
 
    *fvf = 0;
    if (declaration[0].Type == D3DDECLTYPE_FLOAT3 && declaration[0].Usage == D3DDECLUSAGE_POSITION)
    {
        if ((declaration[1].Type == D3DDECLTYPE_FLOAT4 && declaration[1].Usage == D3DDECLUSAGE_BLENDWEIGHT &&
             declaration[1].UsageIndex == 0) &&
            (declaration[2].Type == D3DDECLTYPE_FLOAT1 && declaration[2].Usage == D3DDECLUSAGE_BLENDINDICES &&
             declaration[2].UsageIndex == 0))
        {
            return D3DERR_INVALIDCALL;
        }
        else if ((declaration[1].Type == D3DDECLTYPE_UBYTE4 || declaration[1].Type == D3DDECLTYPE_D3DCOLOR) &&
                 declaration[1].Usage == D3DDECLUSAGE_BLENDINDICES && declaration[1].UsageIndex == 0)
        {
            if (declaration[1].Type == D3DDECLTYPE_UBYTE4)
            {
                *fvf |= D3DFVF_XYZB1 | D3DFVF_LASTBETA_UBYTE4;
            }
            else
            {
                *fvf |= D3DFVF_XYZB1 | D3DFVF_LASTBETA_D3DCOLOR;
            }
            i = 2;
        }
        else if (declaration[1].Type <= D3DDECLTYPE_FLOAT4 && declaration[1].Usage == D3DDECLUSAGE_BLENDWEIGHT &&
                 declaration[1].UsageIndex == 0)
        {
            if ((declaration[2].Type == D3DDECLTYPE_UBYTE4 || declaration[2].Type == D3DDECLTYPE_D3DCOLOR) &&
                declaration[2].Usage == D3DDECLUSAGE_BLENDINDICES && declaration[2].UsageIndex == 0)
            {
                if (declaration[2].Type == D3DDECLTYPE_UBYTE4)
                {
                    *fvf |= D3DFVF_LASTBETA_UBYTE4;
                }
                else
                {
                    *fvf |= D3DFVF_LASTBETA_D3DCOLOR;
                }
                switch (declaration[1].Type)
                {
                    case D3DDECLTYPE_FLOAT1: *fvf |= D3DFVF_XYZB2; break;
                    case D3DDECLTYPE_FLOAT2: *fvf |= D3DFVF_XYZB3; break;
                    case D3DDECLTYPE_FLOAT3: *fvf |= D3DFVF_XYZB4; break;
                    case D3DDECLTYPE_FLOAT4: *fvf |= D3DFVF_XYZB5; break;
                }
                i = 3;
            }
            else
            {
                switch (declaration[1].Type)
                {
                    case D3DDECLTYPE_FLOAT1: *fvf |= D3DFVF_XYZB1; break;
                    case D3DDECLTYPE_FLOAT2: *fvf |= D3DFVF_XYZB2; break;
                    case D3DDECLTYPE_FLOAT3: *fvf |= D3DFVF_XYZB3; break;
                    case D3DDECLTYPE_FLOAT4: *fvf |= D3DFVF_XYZB4; break;
                }
                i = 2;
            }
        }
        else
        {
            *fvf |= D3DFVF_XYZ;
            i = 1;
        }
    }
    else if (declaration[0].Type == D3DDECLTYPE_FLOAT4 && declaration[0].Usage == D3DDECLUSAGE_POSITIONT &&
             declaration[0].UsageIndex == 0)
    {
        *fvf |= D3DFVF_XYZRHW;
        i = 1;
    }
 
    if (declaration[i].Type == D3DDECLTYPE_FLOAT3 && declaration[i].Usage == D3DDECLUSAGE_NORMAL)
    {
        *fvf |= D3DFVF_NORMAL;
        i++;
    }
    if (declaration[i].Type == D3DDECLTYPE_FLOAT1 && declaration[i].Usage == D3DDECLUSAGE_PSIZE &&
        declaration[i].UsageIndex == 0)
    {
        *fvf |= D3DFVF_PSIZE;
        i++;
    }
    if (declaration[i].Type == D3DDECLTYPE_D3DCOLOR && declaration[i].Usage == D3DDECLUSAGE_COLOR &&
        declaration[i].UsageIndex == 0)
    {
        *fvf |= D3DFVF_DIFFUSE;
        i++;
    }
    if (declaration[i].Type == D3DDECLTYPE_D3DCOLOR && declaration[i].Usage == D3DDECLUSAGE_COLOR &&
        declaration[i].UsageIndex == 1)
    {
        *fvf |= D3DFVF_SPECULAR;
        i++;
    }
 
    for (texture = 0; texture < D3DDP_MAXTEXCOORD; i++, texture++)
    {
        if (declaration[i].Stream == 0xFF)
        {
            break;
        }
        else if (declaration[i].Type == D3DDECLTYPE_FLOAT1 && declaration[i].Usage == D3DDECLUSAGE_TEXCOORD &&
                 declaration[i].UsageIndex == texture)
        {
            *fvf |= D3DFVF_TEXCOORDSIZE1(declaration[i].UsageIndex);
        }
        else if (declaration[i].Type == D3DDECLTYPE_FLOAT2 && declaration[i].Usage == D3DDECLUSAGE_TEXCOORD &&
                 declaration[i].UsageIndex == texture)
        {
            *fvf |= D3DFVF_TEXCOORDSIZE2(declaration[i].UsageIndex);
        }
        else if (declaration[i].Type == D3DDECLTYPE_FLOAT3 && declaration[i].Usage == D3DDECLUSAGE_TEXCOORD &&
                 declaration[i].UsageIndex == texture)
        {
            *fvf |= D3DFVF_TEXCOORDSIZE3(declaration[i].UsageIndex);
        }
        else if (declaration[i].Type == D3DDECLTYPE_FLOAT4 && declaration[i].Usage == D3DDECLUSAGE_TEXCOORD &&
                 declaration[i].UsageIndex == texture)
        {
            *fvf |= D3DFVF_TEXCOORDSIZE4(declaration[i].UsageIndex);
        }
        else
        {
            return D3DERR_INVALIDCALL;
        }
    }
 
    *fvf |= (texture << D3DFVF_TEXCOUNT_SHIFT);
 
    for (offset = 0, i = 0; declaration[i].Stream != 0xFF;
         offset += d3dx_decltype_size[declaration[i].Type], i++)
    {
        if (declaration[i].Offset != offset)
        {
            return D3DERR_INVALIDCALL;
        }
    }
 
    return D3D_OK;
}

Referenced by d3dx9_skin_info_SetDeclaration(), D3DXCreateMesh(), test_create_skin_info(), and test_decl_to_fvf().

D3DXGenerateOutputDecl()

HRESULT WINAPI D3DXGenerateOutputDecl	(	D3DVERTEXELEMENT9 *	decl_out,
		const D3DVERTEXELEMENT9 *	decl_in
	)

D3DXGeneratePMesh()

HRESULT WINAPI D3DXGeneratePMesh	(	ID3DXMesh *	mesh,
		const DWORD *	adjacency,
		const D3DXATTRIBUTEWEIGHTS *	attribute_weights,
		const float *	vertex_weights,
		DWORD	min_value,
		DWORD	flags,
		ID3DXPMesh **	pmesh
	)

D3DXGetDeclLength()

UINT WINAPI D3DXGetDeclLength

(

const D3DVERTEXELEMENT9 *

decl

)

Definition at line 2354 of file mesh.c.

{
    const D3DVERTEXELEMENT9 *element;
 
    TRACE("decl %p\n", decl);
 
    /* null decl results in exception on Windows XP */
 
    for (element = decl; element->Stream != 0xff; ++element);
 
    return element - decl;
}

Referenced by test_clone_mesh(), and test_get_decl_length().

D3DXGetDeclVertexSize()

UINT WINAPI D3DXGetDeclVertexSize	(	const D3DVERTEXELEMENT9 *	decl,
		DWORD	stream_idx
	)

Definition at line 2323 of file mesh.c.

{
    const D3DVERTEXELEMENT9 *element;
    UINT size = 0;
 
    TRACE("decl %p, stream_idx %u\n", decl, stream_idx);
 
    if (!decl) return 0;
 
    for (element = decl; element->Stream != 0xff; ++element)
    {
        UINT type_size;
 
        if (element->Stream != stream_idx) continue;
 
        if (element->Type >= ARRAY_SIZE(d3dx_decltype_size))
        {
            FIXME("Unhandled element type %#x, size will be incorrect.\n", element->Type);
            continue;
        }
 
        type_size = d3dx_decltype_size[element->Type];
        if (element->Offset + type_size > size) size = element->Offset + type_size;
    }
 
    return size;
}

Referenced by d3dx9_mesh_UpdateSemantics(), D3DXCreateMesh(), D3DXLoadMeshFromXInMemory(), test_clone_mesh(), and test_get_decl_vertex_size().

D3DXGetFVFVertexSize()

UINT WINAPI D3DXGetFVFVertexSize

(

DWORD

FVF

)

Definition at line 2289 of file mesh.c.

{
    DWORD size = 0;
    UINT i;
    UINT numTextures = (FVF & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT;
 
    if (FVF & D3DFVF_NORMAL) size += sizeof(D3DXVECTOR3);
    if (FVF & D3DFVF_DIFFUSE) size += sizeof(DWORD);
    if (FVF & D3DFVF_SPECULAR) size += sizeof(DWORD);
    if (FVF & D3DFVF_PSIZE) size += sizeof(DWORD);
 
    switch (FVF & D3DFVF_POSITION_MASK)
    {
        case D3DFVF_XYZ:    size += sizeof(D3DXVECTOR3); break;
        case D3DFVF_XYZRHW: size += 4 * sizeof(FLOAT); break;
        case D3DFVF_XYZB1:  size += 4 * sizeof(FLOAT); break;
        case D3DFVF_XYZB2:  size += 5 * sizeof(FLOAT); break;
        case D3DFVF_XYZB3:  size += 6 * sizeof(FLOAT); break;
        case D3DFVF_XYZB4:  size += 7 * sizeof(FLOAT); break;
        case D3DFVF_XYZB5:  size += 8 * sizeof(FLOAT); break;
        case D3DFVF_XYZW:   size += 4 * sizeof(FLOAT); break;
    }
 
    for (i = 0; i < numTextures; i++)
    {
        size += Get_TexCoord_Size_From_FVF(FVF, i) * sizeof(FLOAT);
    }
 
    return size;
}

D3DXIntersect()

HRESULT WINAPI D3DXIntersect	(	ID3DXBaseMesh *	mesh,
		const D3DXVECTOR3 *	ray_position,
		const D3DXVECTOR3 *	ray_direction,
		BOOL *	hit,
		DWORD *	face_idx,
		float *	u,
		float *	v,
		float *	distance,
		ID3DXBuffer **	hits,
		DWORD *	hit_count
	)

Definition at line 7582 of file mesh.c.

{
    FIXME("mesh %p, ray_pos %p, ray_dir %p, hit %p, face_index %p, u %p, v %p, distance %p, all_hits %p, "
            "count_of_hits %p stub!\n", mesh, ray_pos, ray_dir, hit, face_index, u, v, distance, all_hits, count_of_hits);
 
    return E_NOTIMPL;
}

D3DXIntersectSubset()

HRESULT WINAPI D3DXIntersectSubset	(	ID3DXBaseMesh *	mesh,
		DWORD	attribute_id,
		const D3DXVECTOR3 *	ray_position,
		const D3DXVECTOR3 *	ray_direction,
		BOOL *	hit,
		DWORD *	face_idx,
		float *	u,
		float *	v,
		float *	distance,
		ID3DXBuffer **	hits,
		DWORD *	hit_count
	)

D3DXIntersectTri()

BOOL WINAPI D3DXIntersectTri	(	const D3DXVECTOR3 *	vtx0,
		const D3DXVECTOR3 *	vtx1,
		const D3DXVECTOR3 *	vtx2,
		const D3DXVECTOR3 *	ray_pos,
		const D3DXVECTOR3 *	ray_dir,
		FLOAT *	u,
		FLOAT *	v,
		FLOAT *	dist
	)

Definition at line 2367 of file mesh.c.

{
    D3DXMATRIX m;
    D3DXVECTOR4 vec;
 
    TRACE("p0 %p, p1 %p, p2 %p, praypos %p, praydir %p, pu %p, pv %p, pdist %p.\n",
            p0, p1, p2, praypos, praydir, pu, pv, pdist);
 
    m.u.m[0][0] = p1->x - p0->x;
    m.u.m[1][0] = p2->x - p0->x;
    m.u.m[2][0] = -praydir->x;
    m.u.m[3][0] = 0.0f;
    m.u.m[0][1] = p1->y - p0->y;
    m.u.m[1][1] = p2->y - p0->y;
    m.u.m[2][1] = -praydir->y;
    m.u.m[3][1] = 0.0f;
    m.u.m[0][2] = p1->z - p0->z;
    m.u.m[1][2] = p2->z - p0->z;
    m.u.m[2][2] = -praydir->z;
    m.u.m[3][2] = 0.0f;
    m.u.m[0][3] = 0.0f;
    m.u.m[1][3] = 0.0f;
    m.u.m[2][3] = 0.0f;
    m.u.m[3][3] = 1.0f;
 
    vec.x = praypos->x - p0->x;
    vec.y = praypos->y - p0->y;
    vec.z = praypos->z - p0->z;
    vec.w = 0.0f;
 
    if ( D3DXMatrixInverse(&m, NULL, &m) )
    {
        D3DXVec4Transform(&vec, &vec, &m);
        if ( (vec.x >= 0.0f) && (vec.y >= 0.0f) && (vec.x + vec.y <= 1.0f) && (vec.z >= 0.0f) )
        {
            if (pu) *pu = vec.x;
            if (pv) *pv = vec.y;
            if (pdist) *pdist = fabsf( vec.z );
            return TRUE;
        }
    }
 
    return FALSE;
}

Referenced by D3DXIntersectTriTest().

D3DXLoadMeshFromXA()

HRESULT WINAPI D3DXLoadMeshFromXA	(	const char *	filename,
		DWORD	flags,
		struct IDirect3DDevice9 *	device,
		struct ID3DXBuffer **	adjacency,
		struct ID3DXBuffer **	materials,
		struct ID3DXBuffer **	effect_instances,
		DWORD *	material_count,
		struct ID3DXMesh **	mesh
	)

Definition at line 4052 of file mesh.c.

{
    WCHAR *filenameW;
    HRESULT hr;
    int len;
 
    TRACE("filename %s, options %#x, device %p, adjacency %p, materials %p, "
            "effect_instances %p, num_materials %p, mesh %p.\n",
            debugstr_a(filename), options, device, adjacency, materials,
            effect_instances, num_materials, mesh);
 
    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 = D3DXLoadMeshFromXW(filenameW, options, device, adjacency, materials,
                            effect_instances, num_materials, mesh);
    HeapFree(GetProcessHeap(), 0, filenameW);
 
    return hr;
}

D3DXLoadMeshFromXInMemory()

HRESULT WINAPI D3DXLoadMeshFromXInMemory	(	const void *	data,
		DWORD	data_size,
		DWORD	flags,
		struct IDirect3DDevice9 *	device,
		struct ID3DXBuffer **	adjacency,
		struct ID3DXBuffer **	materials,
		struct ID3DXBuffer **	effect_instances,
		DWORD *	material_count,
		struct ID3DXMesh **	mesh
	)

Definition at line 4198 of file mesh.c.

{
    HRESULT hr;
    ID3DXFile *d3dxfile = NULL;
    ID3DXFileEnumObject *enumobj = NULL;
    ID3DXFileData *filedata = NULL;
    D3DXF_FILELOADMEMORY source;
    ID3DXBuffer *materials = NULL;
    ID3DXBuffer *effects = NULL;
    ID3DXBuffer *adjacency = NULL;
    struct list container_list = LIST_INIT(container_list);
    struct mesh_container *container_ptr, *next_container_ptr;
    DWORD num_materials;
    DWORD num_faces, num_vertices;
    D3DXMATRIX identity;
    DWORD provide_flags = 0;
    DWORD fvf;
    ID3DXMesh *concat_mesh = NULL;
    D3DVERTEXELEMENT9 concat_decl[MAX_FVF_DECL_SIZE];
    BYTE *concat_vertices = NULL;
    void *concat_indices = NULL;
    DWORD index_offset;
    DWORD concat_vertex_size;
    SIZE_T i, nb_children;
    GUID guid;
 
    TRACE("(%p, %u, %x, %p, %p, %p, %p, %p, %p)\n", memory, memory_size, options,
          device, adjacency_out, materials_out, effects_out, num_materials_out, mesh_out);
 
    if (!memory || !memory_size || !device || !mesh_out)
        return D3DERR_INVALIDCALL;
 
    hr = D3DXFileCreate(&d3dxfile);
    if (FAILED(hr)) goto cleanup;
 
    hr = d3dxfile->lpVtbl->RegisterTemplates(d3dxfile, D3DRM_XTEMPLATES, D3DRM_XTEMPLATE_BYTES);
    if (FAILED(hr)) goto cleanup;
 
    source.lpMemory = (void*)memory;
    source.dSize = memory_size;
    hr = d3dxfile->lpVtbl->CreateEnumObject(d3dxfile, &source, D3DXF_FILELOAD_FROMMEMORY, &enumobj);
    if (FAILED(hr)) goto cleanup;
 
    D3DXMatrixIdentity(&identity);
    if (adjacency_out) provide_flags |= PROVIDE_ADJACENCY;
    if (materials_out || effects_out) provide_flags |= PROVIDE_MATERIALS;
 
    hr = enumobj->lpVtbl->GetChildren(enumobj, &nb_children);
    if (FAILED(hr))
        goto cleanup;
 
    for (i = 0; i < nb_children; i++)
    {
        hr = enumobj->lpVtbl->GetChild(enumobj, i, &filedata);
        if (FAILED(hr))
            goto cleanup;
 
        hr = filedata->lpVtbl->GetType(filedata, &guid);
        if (SUCCEEDED(hr)) {
            if (IsEqualGUID(&guid, &TID_D3DRMMesh)) {
                container_ptr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*container_ptr));
                if (!container_ptr) {
                    hr = E_OUTOFMEMORY;
                    goto cleanup;
                }
                list_add_tail(&container_list, &container_ptr->entry);
                D3DXMatrixIdentity(&container_ptr->transform);
 
                hr = D3DXLoadSkinMeshFromXof(filedata, options, device,
                        (provide_flags & PROVIDE_ADJACENCY) ? &container_ptr->adjacency : NULL,
                        (provide_flags & PROVIDE_MATERIALS) ? &container_ptr->materials : NULL,
                        NULL, &container_ptr->num_materials, NULL, &container_ptr->mesh);
            } else if (IsEqualGUID(&guid, &TID_D3DRMFrame)) {
                hr = parse_frame(filedata, options, device, &identity, &container_list, provide_flags);
            }
            if (FAILED(hr)) goto cleanup;
        }
        filedata->lpVtbl->Release(filedata);
        filedata = NULL;
        if (FAILED(hr))
            goto cleanup;
    }
 
    enumobj->lpVtbl->Release(enumobj);
    enumobj = NULL;
    d3dxfile->lpVtbl->Release(d3dxfile);
    d3dxfile = NULL;
 
    if (list_empty(&container_list)) {
        hr = E_FAIL;
        goto cleanup;
    }
 
    fvf = D3DFVF_XYZ;
    num_faces = 0;
    num_vertices = 0;
    num_materials = 0;
    LIST_FOR_EACH_ENTRY(container_ptr, &container_list, struct mesh_container, entry)
    {
        ID3DXMesh *mesh = container_ptr->mesh;
        fvf |= mesh->lpVtbl->GetFVF(mesh);
        num_faces += mesh->lpVtbl->GetNumFaces(mesh);
        num_vertices += mesh->lpVtbl->GetNumVertices(mesh);
        num_materials += container_ptr->num_materials;
    }
 
    hr = D3DXCreateMeshFVF(num_faces, num_vertices, options, fvf, device, &concat_mesh);
    if (FAILED(hr)) goto cleanup;
 
    hr = concat_mesh->lpVtbl->GetDeclaration(concat_mesh, concat_decl);
    if (FAILED(hr)) goto cleanup;
 
    concat_vertex_size = D3DXGetDeclVertexSize(concat_decl, 0);
 
    hr = concat_mesh->lpVtbl->LockVertexBuffer(concat_mesh, 0, (void**)&concat_vertices);
    if (FAILED(hr)) goto cleanup;
 
    LIST_FOR_EACH_ENTRY(container_ptr, &container_list, struct mesh_container, entry)
    {
        D3DVERTEXELEMENT9 mesh_decl[MAX_FVF_DECL_SIZE];
        ID3DXMesh *mesh = container_ptr->mesh;
        DWORD num_mesh_vertices = mesh->lpVtbl->GetNumVertices(mesh);
        DWORD mesh_vertex_size;
        const BYTE *mesh_vertices;
        DWORD i;
 
        hr = mesh->lpVtbl->GetDeclaration(mesh, mesh_decl);
        if (FAILED(hr)) goto cleanup;
 
        mesh_vertex_size = D3DXGetDeclVertexSize(mesh_decl, 0);
 
        hr = mesh->lpVtbl->LockVertexBuffer(mesh, D3DLOCK_READONLY, (void**)&mesh_vertices);
        if (FAILED(hr)) goto cleanup;
 
        for (i = 0; i < num_mesh_vertices; i++) {
            int j;
            int k = 1;
 
            D3DXVec3TransformCoord((D3DXVECTOR3*)concat_vertices,
                                   (D3DXVECTOR3*)mesh_vertices,
                                   &container_ptr->transform);
            for (j = 1; concat_decl[j].Stream != 0xff; j++)
            {
                if (concat_decl[j].Usage == mesh_decl[k].Usage &&
                    concat_decl[j].UsageIndex == mesh_decl[k].UsageIndex)
                {
                    if (concat_decl[j].Usage == D3DDECLUSAGE_NORMAL) {
                        D3DXVec3TransformCoord((D3DXVECTOR3*)(concat_vertices + concat_decl[j].Offset),
                                               (D3DXVECTOR3*)(mesh_vertices + mesh_decl[k].Offset),
                                               &container_ptr->transform);
                    } else {
                        memcpy(concat_vertices + concat_decl[j].Offset,
                               mesh_vertices + mesh_decl[k].Offset,
                               d3dx_decltype_size[mesh_decl[k].Type]);
                    }
                    k++;
                }
            }
            mesh_vertices += mesh_vertex_size;
            concat_vertices += concat_vertex_size;
        }
 
        mesh->lpVtbl->UnlockVertexBuffer(mesh);
    }
 
    concat_mesh->lpVtbl->UnlockVertexBuffer(concat_mesh);
    concat_vertices = NULL;
 
    hr = concat_mesh->lpVtbl->LockIndexBuffer(concat_mesh, 0, &concat_indices);
    if (FAILED(hr)) goto cleanup;
 
    index_offset = 0;
    LIST_FOR_EACH_ENTRY(container_ptr, &container_list, struct mesh_container, entry)
    {
        ID3DXMesh *mesh = container_ptr->mesh;
        const void *mesh_indices;
        DWORD num_mesh_faces = mesh->lpVtbl->GetNumFaces(mesh);
        DWORD i;
 
        hr = mesh->lpVtbl->LockIndexBuffer(mesh, D3DLOCK_READONLY, (void**)&mesh_indices);
        if (FAILED(hr)) goto cleanup;
 
        if (options & D3DXMESH_32BIT) {
            DWORD *dest = concat_indices;
            const DWORD *src = mesh_indices;
            for (i = 0; i < num_mesh_faces * 3; i++)
                *dest++ = index_offset + *src++;
            concat_indices = dest;
        } else {
            WORD *dest = concat_indices;
            const WORD *src = mesh_indices;
            for (i = 0; i < num_mesh_faces * 3; i++)
                *dest++ = index_offset + *src++;
            concat_indices = dest;
        }
        mesh->lpVtbl->UnlockIndexBuffer(mesh);
 
        index_offset += num_mesh_faces * 3;
    }
 
    concat_mesh->lpVtbl->UnlockIndexBuffer(concat_mesh);
    concat_indices = NULL;
 
    if (num_materials) {
        DWORD *concat_attrib_buffer = NULL;
        DWORD offset = 0;
 
        hr = concat_mesh->lpVtbl->LockAttributeBuffer(concat_mesh, 0, &concat_attrib_buffer);
        if (FAILED(hr)) goto cleanup;
 
        LIST_FOR_EACH_ENTRY(container_ptr, &container_list, struct mesh_container, entry)
        {
            ID3DXMesh *mesh = container_ptr->mesh;
            const DWORD *mesh_attrib_buffer = NULL;
            DWORD count = mesh->lpVtbl->GetNumFaces(mesh);
 
            hr = mesh->lpVtbl->LockAttributeBuffer(mesh, D3DLOCK_READONLY, (DWORD**)&mesh_attrib_buffer);
            if (FAILED(hr)) {
                concat_mesh->lpVtbl->UnlockAttributeBuffer(concat_mesh);
                goto cleanup;
            }
 
            while (count--)
                *concat_attrib_buffer++ = offset + *mesh_attrib_buffer++;
 
            mesh->lpVtbl->UnlockAttributeBuffer(mesh);
            offset += container_ptr->num_materials;
        }
        concat_mesh->lpVtbl->UnlockAttributeBuffer(concat_mesh);
    }
 
    if (materials_out || effects_out) {
        D3DXMATERIAL *out_ptr;
        if (!num_materials) {
            /* create default material */
            hr = D3DXCreateBuffer(sizeof(D3DXMATERIAL), &materials);
            if (FAILED(hr)) goto cleanup;
 
            out_ptr = ID3DXBuffer_GetBufferPointer(materials);
            out_ptr->MatD3D.Diffuse.r = 0.5f;
            out_ptr->MatD3D.Diffuse.g = 0.5f;
            out_ptr->MatD3D.Diffuse.b = 0.5f;
            out_ptr->MatD3D.Specular.r = 0.5f;
            out_ptr->MatD3D.Specular.g = 0.5f;
            out_ptr->MatD3D.Specular.b = 0.5f;
            /* D3DXCreateBuffer initializes the rest to zero */
        } else {
            DWORD buffer_size = num_materials * sizeof(D3DXMATERIAL);
            char *strings_out_ptr;
 
            LIST_FOR_EACH_ENTRY(container_ptr, &container_list, struct mesh_container, entry)
            {
                if (container_ptr->materials) {
                    DWORD i;
                    const D3DXMATERIAL *in_ptr = ID3DXBuffer_GetBufferPointer(container_ptr->materials);
                    for (i = 0; i < container_ptr->num_materials; i++)
                    {
                        if (in_ptr->pTextureFilename)
                            buffer_size += strlen(in_ptr->pTextureFilename) + 1;
                        in_ptr++;
                    }
                }
            }
 
            hr = D3DXCreateBuffer(buffer_size, &materials);
            if (FAILED(hr)) goto cleanup;
            out_ptr = ID3DXBuffer_GetBufferPointer(materials);
            strings_out_ptr = (char*)(out_ptr + num_materials);
 
            LIST_FOR_EACH_ENTRY(container_ptr, &container_list, struct mesh_container, entry)
            {
                if (container_ptr->materials) {
                    DWORD i;
                    const D3DXMATERIAL *in_ptr = ID3DXBuffer_GetBufferPointer(container_ptr->materials);
                    for (i = 0; i < container_ptr->num_materials; i++)
                    {
                        out_ptr->MatD3D = in_ptr->MatD3D;
                        if (in_ptr->pTextureFilename) {
                            out_ptr->pTextureFilename = strings_out_ptr;
                            strcpy(out_ptr->pTextureFilename, in_ptr->pTextureFilename);
                            strings_out_ptr += strlen(in_ptr->pTextureFilename) + 1;
                        }
                        in_ptr++;
                        out_ptr++;
                    }
                }
            }
        }
    }
    if (!num_materials)
        num_materials = 1;
 
    if (effects_out) {
        generate_effects(materials, num_materials, &effects);
        if (!materials_out) {
            ID3DXBuffer_Release(materials);
            materials = NULL;
        }
    }
 
    if (adjacency_out) {
        if (!list_next(&container_list, list_head(&container_list))) {
            container_ptr = LIST_ENTRY(list_head(&container_list), struct mesh_container, entry);
            adjacency = container_ptr->adjacency;
            container_ptr->adjacency = NULL;
        } else {
            DWORD offset = 0;
            DWORD *out_ptr;
 
            hr = D3DXCreateBuffer(num_faces * 3 * sizeof(DWORD), &adjacency);
            if (FAILED(hr)) goto cleanup;
 
            out_ptr = ID3DXBuffer_GetBufferPointer(adjacency);
            LIST_FOR_EACH_ENTRY(container_ptr, &container_list, struct mesh_container, entry)
            {
                DWORD i;
                DWORD count = 3 * container_ptr->mesh->lpVtbl->GetNumFaces(container_ptr->mesh);
                DWORD *in_ptr = ID3DXBuffer_GetBufferPointer(container_ptr->adjacency);
 
                for (i = 0; i < count; i++)
                    *out_ptr++ = offset + *in_ptr++;
 
                offset += count;
            }
        }
    }
 
    *mesh_out = concat_mesh;
    if (adjacency_out) *adjacency_out = adjacency;
    if (materials_out) *materials_out = materials;
    if (effects_out) *effects_out = effects;
    if (num_materials_out) *num_materials_out = num_materials;
 
    hr = D3D_OK;
cleanup:
    if (concat_indices) concat_mesh->lpVtbl->UnlockIndexBuffer(concat_mesh);
    if (concat_vertices) concat_mesh->lpVtbl->UnlockVertexBuffer(concat_mesh);
    if (filedata) filedata->lpVtbl->Release(filedata);
    if (enumobj) enumobj->lpVtbl->Release(enumobj);
    if (d3dxfile) d3dxfile->lpVtbl->Release(d3dxfile);
    if (FAILED(hr)) {
        if (concat_mesh) IUnknown_Release(concat_mesh);
        if (materials) ID3DXBuffer_Release(materials);
        if (effects) ID3DXBuffer_Release(effects);
        if (adjacency) ID3DXBuffer_Release(adjacency);
    }
    LIST_FOR_EACH_ENTRY_SAFE(container_ptr, next_container_ptr, &container_list, struct mesh_container, entry)
    {
        if (container_ptr->mesh) IUnknown_Release(container_ptr->mesh);
        if (container_ptr->adjacency) ID3DXBuffer_Release(container_ptr->adjacency);
        if (container_ptr->materials) ID3DXBuffer_Release(container_ptr->materials);
        if (container_ptr->effects) ID3DXBuffer_Release(container_ptr->effects);
        HeapFree(GetProcessHeap(), 0, container_ptr);
    }
    return hr;
}

Referenced by D3DXLoadMeshFromXResource(), D3DXLoadMeshFromXW(), D3DXLoadMeshTest(), and test_LoadMeshFromX_().

D3DXLoadMeshFromXof()

HRESULT WINAPI D3DXLoadMeshFromXof	(	struct ID3DXFileData *	file_data,
		DWORD	flags,
		struct IDirect3DDevice9 *	device,
		struct ID3DXBuffer **	adjacency,
		struct ID3DXBuffer **	materials,
		struct ID3DXBuffer **	effect_instances,
		DWORD *	material_count,
		struct ID3DXMesh **	mesh
	)

D3DXLoadMeshFromXResource()

HRESULT WINAPI D3DXLoadMeshFromXResource	(	HMODULE	module,
		const char *	resource,
		const char *	resource_type,
		DWORD	flags,
		struct IDirect3DDevice9 *	device,
		struct ID3DXBuffer **	adjacency,
		struct ID3DXBuffer **	materials,
		struct ID3DXBuffer **	effect_instances,
		DWORD *	material_count,
		struct ID3DXMesh **	mesh
	)

Definition at line 4108 of file mesh.c.

{
    HRESULT hr;
    HRSRC resinfo;
    void *buffer;
    DWORD size;
 
    TRACE("module %p, name %s, type %s, options %#x, device %p, adjacency %p, "
            "materials %p, effect_instances %p, num_materials %p, mesh %p.\n",
            module, debugstr_a(name), debugstr_a(type), options, device, adjacency,
            materials, effect_instances, num_materials, mesh);
 
    resinfo = FindResourceA(module, name, type);
    if (!resinfo) return D3DXERR_INVALIDDATA;
 
    hr = load_resource_into_memory(module, resinfo, &buffer, &size);
    if (FAILED(hr)) return D3DXERR_INVALIDDATA;
 
    return D3DXLoadMeshFromXInMemory(buffer, size, options, device, adjacency,
            materials, effect_instances, num_materials, mesh);
}

D3DXLoadMeshFromXW()

HRESULT WINAPI D3DXLoadMeshFromXW	(	const WCHAR *	filename,
		DWORD	flags,
		struct IDirect3DDevice9 *	device,
		struct ID3DXBuffer **	adjacency,
		struct ID3DXBuffer **	materials,
		struct ID3DXBuffer **	effect_instances,
		DWORD *	material_count,
		struct ID3DXMesh **	mesh
	)

Definition at line 4080 of file mesh.c.

{
    void *buffer;
    HRESULT hr;
    DWORD size;
 
    TRACE("filename %s, options %#x, device %p, adjacency %p, materials %p, "
            "effect_instances %p, num_materials %p, mesh %p.\n",
            debugstr_w(filename), options, device, adjacency, materials,
            effect_instances, num_materials, mesh);
 
    if (!filename)
        return D3DERR_INVALIDCALL;
 
    hr = map_view_of_file(filename, &buffer, &size);
    if (FAILED(hr))
        return D3DXERR_INVALIDDATA;
 
    hr = D3DXLoadMeshFromXInMemory(buffer, size, options, device, adjacency,
            materials, effect_instances, num_materials, mesh);
 
    UnmapViewOfFile(buffer);
 
    return hr;
}

Referenced by D3DXLoadMeshFromXA().

D3DXLoadPatchMeshFromXof()

HRESULT WINAPI D3DXLoadPatchMeshFromXof	(	struct ID3DXFileData *	file_data,
		DWORD	flags,
		struct IDirect3DDevice9 *	device,
		struct ID3DXBuffer **	adjacency,
		struct ID3DXBuffer **	materials,
		struct ID3DXBuffer **	effect_instances,
		DWORD *	material_count,
		struct ID3DXPatchMesh **	mesh
	)

D3DXLoadPRTBufferFromFileA()

HRESULT WINAPI D3DXLoadPRTBufferFromFileA	(	const char *	filename,
		ID3DXPRTBuffer **	buffer
	)

D3DXLoadPRTBufferFromFileW()

HRESULT WINAPI D3DXLoadPRTBufferFromFileW	(	const WCHAR *	filename,
		ID3DXPRTBuffer **	buffer
	)

D3DXLoadPRTCompBufferFromFileA()

HRESULT WINAPI D3DXLoadPRTCompBufferFromFileA	(	const char *	filename,
		ID3DXPRTCompBuffer **	buffer
	)

D3DXLoadPRTCompBufferFromFileW()

HRESULT WINAPI D3DXLoadPRTCompBufferFromFileW	(	const WCHAR *	filename,
		ID3DXPRTCompBuffer **	buffer
	)

D3DXLoadSkinMeshFromXof()

HRESULT WINAPI D3DXLoadSkinMeshFromXof	(	struct ID3DXFileData *	file_data,
		DWORD	flags,
		struct IDirect3DDevice9 *	device,
		struct ID3DXBuffer **	adjacency,
		struct ID3DXBuffer **	materials,
		struct ID3DXBuffer **	effect_instances,
		DWORD *	material_count,
		struct ID3DXSkinInfo **	skin_info,
		struct ID3DXMesh **	mesh
	)

Definition at line 3445 of file mesh.c.

{
    HRESULT hr;
    DWORD *index_in_ptr;
    struct mesh_data mesh_data;
    DWORD total_vertices;
    ID3DXMesh *d3dxmesh = NULL;
    ID3DXBuffer *adjacency = NULL;
    ID3DXBuffer *materials = NULL;
    ID3DXBuffer *effects = NULL;
    struct vertex_duplication {
        DWORD normal_index;
        struct list entry;
    } *duplications = NULL;
    DWORD i;
    void *vertices = NULL;
    void *indices = NULL;
    BYTE *out_ptr;
    DWORD provide_flags = 0;
 
    TRACE("(%p, %x, %p, %p, %p, %p, %p, %p, %p)\n", filedata, options, device, adjacency_out, materials_out,
          effects_out, num_materials_out, skin_info_out, mesh_out);
 
    ZeroMemory(&mesh_data, sizeof(mesh_data));
 
    if (num_materials_out || materials_out || effects_out)
        provide_flags |= PROVIDE_MATERIALS;
    if (skin_info_out)
        provide_flags |= PROVIDE_SKININFO;
 
    hr = parse_mesh(filedata, &mesh_data, provide_flags);
    if (FAILED(hr)) goto cleanup;
 
    total_vertices = mesh_data.num_vertices;
    if (mesh_data.fvf & D3DFVF_NORMAL) {
        /* duplicate vertices with multiple normals */
        DWORD num_face_indices = mesh_data.num_poly_faces * 2 + mesh_data.num_tri_faces;
        duplications = HeapAlloc(GetProcessHeap(), 0, (mesh_data.num_vertices + num_face_indices) * sizeof(*duplications));
        if (!duplications) {
            hr = E_OUTOFMEMORY;
            goto cleanup;
        }
        for (i = 0; i < total_vertices; i++)
        {
            duplications[i].normal_index = -1;
            list_init(&duplications[i].entry);
        }
        for (i = 0; i < num_face_indices; i++) {
            DWORD vertex_index = mesh_data.indices[i];
            DWORD normal_index = mesh_data.normal_indices[i];
            struct vertex_duplication *dup_ptr = &duplications[vertex_index];
 
            if (dup_ptr->normal_index == -1) {
                dup_ptr->normal_index = normal_index;
            } else {
                D3DXVECTOR3 *new_normal = &mesh_data.normals[normal_index];
                struct list *dup_list = &dup_ptr->entry;
                while (TRUE) {
                    D3DXVECTOR3 *cur_normal = &mesh_data.normals[dup_ptr->normal_index];
                    if (new_normal->x == cur_normal->x &&
                        new_normal->y == cur_normal->y &&
                        new_normal->z == cur_normal->z)
                    {
                        mesh_data.indices[i] = dup_ptr - duplications;
                        break;
                    } else if (!list_next(dup_list, &dup_ptr->entry)) {
                        dup_ptr = &duplications[total_vertices++];
                        dup_ptr->normal_index = normal_index;
                        list_add_tail(dup_list, &dup_ptr->entry);
                        mesh_data.indices[i] = dup_ptr - duplications;
                        break;
                    } else {
                        dup_ptr = LIST_ENTRY(list_next(dup_list, &dup_ptr->entry),
                                             struct vertex_duplication, entry);
                    }
                }
            }
        }
    }
 
    hr = D3DXCreateMeshFVF(mesh_data.num_tri_faces, total_vertices, options, mesh_data.fvf, device, &d3dxmesh);
    if (FAILED(hr)) goto cleanup;
 
    hr = d3dxmesh->lpVtbl->LockVertexBuffer(d3dxmesh, 0, &vertices);
    if (FAILED(hr)) goto cleanup;
 
    out_ptr = vertices;
    for (i = 0; i < mesh_data.num_vertices; i++) {
        *(D3DXVECTOR3*)out_ptr = mesh_data.vertices[i];
        out_ptr += sizeof(D3DXVECTOR3);
        if (mesh_data.fvf & D3DFVF_NORMAL) {
            if (duplications[i].normal_index == -1)
                ZeroMemory(out_ptr, sizeof(D3DXVECTOR3));
            else
                *(D3DXVECTOR3*)out_ptr = mesh_data.normals[duplications[i].normal_index];
            out_ptr += sizeof(D3DXVECTOR3);
        }
        if (mesh_data.fvf & D3DFVF_DIFFUSE) {
            *(DWORD*)out_ptr = mesh_data.vertex_colors[i];
            out_ptr += sizeof(DWORD);
        }
        if (mesh_data.fvf & D3DFVF_TEX1) {
            *(D3DXVECTOR2*)out_ptr = mesh_data.tex_coords[i];
            out_ptr += sizeof(D3DXVECTOR2);
        }
    }
    if (mesh_data.fvf & D3DFVF_NORMAL) {
        DWORD vertex_size = D3DXGetFVFVertexSize(mesh_data.fvf);
        out_ptr = vertices;
        for (i = 0; i < mesh_data.num_vertices; i++) {
            struct vertex_duplication *dup_ptr;
            LIST_FOR_EACH_ENTRY(dup_ptr, &duplications[i].entry, struct vertex_duplication, entry)
            {
                int j = dup_ptr - duplications;
                BYTE *dest_vertex = (BYTE*)vertices + j * vertex_size;
 
                memcpy(dest_vertex, out_ptr, vertex_size);
                dest_vertex += sizeof(D3DXVECTOR3);
                *(D3DXVECTOR3*)dest_vertex = mesh_data.normals[dup_ptr->normal_index];
            }
            out_ptr += vertex_size;
        }
    }
    d3dxmesh->lpVtbl->UnlockVertexBuffer(d3dxmesh);
 
    hr = d3dxmesh->lpVtbl->LockIndexBuffer(d3dxmesh, 0, &indices);
    if (FAILED(hr)) goto cleanup;
 
    index_in_ptr = mesh_data.indices;
#define FILL_INDEX_BUFFER(indices_var) \
        for (i = 0; i < mesh_data.num_poly_faces; i++) \
        { \
            DWORD count = mesh_data.num_tri_per_face[i]; \
            WORD first_index = *index_in_ptr++; \
            while (count--) { \
                *indices_var++ = first_index; \
                *indices_var++ = *index_in_ptr; \
                index_in_ptr++; \
                *indices_var++ = *index_in_ptr; \
            } \
            index_in_ptr++; \
        }
    if (options & D3DXMESH_32BIT) {
        DWORD *dword_indices = indices;
        FILL_INDEX_BUFFER(dword_indices)
    } else {
        WORD *word_indices = indices;
        FILL_INDEX_BUFFER(word_indices)
    }
#undef FILL_INDEX_BUFFER
    d3dxmesh->lpVtbl->UnlockIndexBuffer(d3dxmesh);
 
    if (mesh_data.material_indices) {
        DWORD *attrib_buffer = NULL;
        hr = d3dxmesh->lpVtbl->LockAttributeBuffer(d3dxmesh, 0, &attrib_buffer);
        if (FAILED(hr)) goto cleanup;
        for (i = 0; i < mesh_data.num_poly_faces; i++)
        {
            DWORD count = mesh_data.num_tri_per_face[i];
            while (count--)
                *attrib_buffer++ = mesh_data.material_indices[i];
        }
        d3dxmesh->lpVtbl->UnlockAttributeBuffer(d3dxmesh);
 
        hr = d3dxmesh->lpVtbl->OptimizeInplace(d3dxmesh,
                D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_IGNOREVERTS | D3DXMESHOPT_DONOTSPLIT,
                NULL, NULL, NULL, NULL);
        if (FAILED(hr)) goto cleanup;
    }
 
    if (mesh_data.num_materials && (materials_out || effects_out)) {
        DWORD buffer_size = mesh_data.num_materials * sizeof(D3DXMATERIAL);
        char *strings_out_ptr;
        D3DXMATERIAL *materials_ptr;
 
        for (i = 0; i < mesh_data.num_materials; i++) {
            if (mesh_data.materials[i].pTextureFilename)
                buffer_size += strlen(mesh_data.materials[i].pTextureFilename) + 1;
        }
 
        hr = D3DXCreateBuffer(buffer_size, &materials);
        if (FAILED(hr)) goto cleanup;
 
        materials_ptr = ID3DXBuffer_GetBufferPointer(materials);
        memcpy(materials_ptr, mesh_data.materials, mesh_data.num_materials * sizeof(D3DXMATERIAL));
        strings_out_ptr = (char*)(materials_ptr + mesh_data.num_materials);
        for (i = 0; i < mesh_data.num_materials; i++) {
            if (materials_ptr[i].pTextureFilename) {
                strcpy(strings_out_ptr, mesh_data.materials[i].pTextureFilename);
                materials_ptr[i].pTextureFilename = strings_out_ptr;
                strings_out_ptr += strlen(mesh_data.materials[i].pTextureFilename) + 1;
            }
        }
    }
 
    if (mesh_data.num_materials && effects_out) {
        hr = generate_effects(materials, mesh_data.num_materials, &effects);
        if (FAILED(hr)) goto cleanup;
 
        if (!materials_out) {
            ID3DXBuffer_Release(materials);
            materials = NULL;
        }
    }
 
    if (adjacency_out) {
        hr = D3DXCreateBuffer(mesh_data.num_tri_faces * 3 * sizeof(DWORD), &adjacency);
        if (FAILED(hr)) goto cleanup;
        hr = d3dxmesh->lpVtbl->GenerateAdjacency(d3dxmesh, 0.0f, ID3DXBuffer_GetBufferPointer(adjacency));
        if (FAILED(hr)) goto cleanup;
    }
 
    *mesh_out = d3dxmesh;
    if (adjacency_out) *adjacency_out = adjacency;
    if (num_materials_out) *num_materials_out = mesh_data.num_materials;
    if (materials_out) *materials_out = materials;
    if (effects_out) *effects_out = effects;
    if (skin_info_out) *skin_info_out = mesh_data.skin_info;
 
    hr = D3D_OK;
cleanup:
    if (FAILED(hr)) {
        if (d3dxmesh) IUnknown_Release(d3dxmesh);
        if (adjacency) ID3DXBuffer_Release(adjacency);
        if (materials) ID3DXBuffer_Release(materials);
        if (effects) ID3DXBuffer_Release(effects);
        if (mesh_data.skin_info) mesh_data.skin_info->lpVtbl->Release(mesh_data.skin_info);
        if (skin_info_out) *skin_info_out = NULL;
    }
    HeapFree(GetProcessHeap(), 0, mesh_data.vertices);
    HeapFree(GetProcessHeap(), 0, mesh_data.num_tri_per_face);
    HeapFree(GetProcessHeap(), 0, mesh_data.indices);
    HeapFree(GetProcessHeap(), 0, mesh_data.normals);
    HeapFree(GetProcessHeap(), 0, mesh_data.normal_indices);
    destroy_materials(&mesh_data);
    HeapFree(GetProcessHeap(), 0, mesh_data.tex_coords);
    HeapFree(GetProcessHeap(), 0, mesh_data.vertex_colors);
    HeapFree(GetProcessHeap(), 0, duplications);
    return hr;
}

Referenced by D3DXLoadMeshFromXInMemory(), load_mesh_container(), parse_frame(), and test_load_skin_mesh_from_xof().

D3DXOptimizeFaces()

HRESULT WINAPI D3DXOptimizeFaces	(	const void *	indices,
		UINT	face_count,
		UINT	vertex_count,
		BOOL	idx_32bit,
		DWORD *	face_remap
	)

Definition at line 7239 of file mesh.c.

{
    UINT i;
    UINT j = num_faces - 1;
    UINT limit_16_bit = 2 << 15; /* According to MSDN */
    HRESULT hr = D3D_OK;
 
    FIXME("indices %p, num_faces %u, num_vertices %u, indices_are_32bit %#x, face_remap %p semi-stub. "
            "Face order will not be optimal.\n",
            indices, num_faces, num_vertices, indices_are_32bit, face_remap);
 
    if (!indices_are_32bit && num_faces >= limit_16_bit)
    {
        WARN("Number of faces must be less than %d when using 16-bit indices.\n",
             limit_16_bit);
        hr = D3DERR_INVALIDCALL;
        goto error;
    }
 
    if (!face_remap)
    {
        WARN("Face remap pointer is NULL.\n");
        hr = D3DERR_INVALIDCALL;
        goto error;
    }
 
    /* The faces are drawn in reverse order for simple meshes. This ordering
     * is not optimal for complicated meshes, but will not break anything
     * either. The ordering should be changed to take advantage of the vertex
     * cache on the graphics card.
     *
     * TODO Re-order to take advantage of vertex cache.
     */
    for (i = 0; i < num_faces; i++)
    {
        face_remap[i] = j--;
    }
 
    return D3D_OK;
 
error:
    return hr;
}

Referenced by test_optimize_faces().

D3DXOptimizeVertices()

HRESULT WINAPI D3DXOptimizeVertices	(	const void *	indices,
		UINT	face_count,
		UINT	vertex_count,
		BOOL	idx_32bit,
		DWORD *	vertex_remap
	)

Definition at line 7196 of file mesh.c.

{
    UINT i;
 
    FIXME("indices %p, num_faces %u, num_vertices %u, indices_are_32bit %#x, vertex_remap %p semi-stub.\n",
            indices, num_faces, num_vertices, indices_are_32bit, vertex_remap);
 
    if (!vertex_remap)
    {
        WARN("vertex remap pointer is NULL.\n");
        return D3DERR_INVALIDCALL;
    }
 
    for (i = 0; i < num_vertices; i++)
    {
        vertex_remap[i] = i;
    }
 
    return D3D_OK;
}

Referenced by test_optimize_vertices().

D3DXRectPatchSize()

HRESULT WINAPI D3DXRectPatchSize	(	const FLOAT *	segment_count,
		DWORD *	num_triangles,
		DWORD *	num_vertices
	)

D3DXSaveMeshToXA()

HRESULT WINAPI D3DXSaveMeshToXA	(	const char *	filename,
		ID3DXMesh *	mesh,
		const DWORD *	adjacency,
		const