mesh.c File Reference

#include <assert.h>
#include <float.h>
#include "d3dx9_private.h"
#include "dxfile.h"
#include "rmxfguid.h"
#include "rmxftmpl.h"
#include "wine/list.h"

Include dependency graph for mesh.c:

Go to the source code of this file.

Classes
struct	d3dx9_mesh
struct	edge_face
struct	edge_face_map
struct	vertex_metadata
struct	mesh_data
struct	mesh_container
struct	vertex
struct	sincos_table
struct	point2d
struct	dynamic_array
struct	outline
struct	outline_array
struct	face_array
struct	point2d_index
struct	point2d_index_array
struct	glyphinfo
struct	word_array
struct	triangulation
struct	triangulation_array
struct	cos_table
struct	udec3
struct	dec3n
struct	frame_node

Macros
#define	PROVIDE_MATERIALS   0x1
#define	PROVIDE_SKININFO   0x2
#define	PROVIDE_ADJACENCY   0x4
#define	EFFECT_TABLE_ENTRY(str, field)    {str, sizeof(str), sizeof(material_ptr->MatD3D.field), offsetof(D3DXMATERIAL, MatD3D.field)}
#define	FILL_INDEX_BUFFER(indices_var)
#define	NUM_ELEM   2
#define	NUM_ELEM   4

Typedefs
typedef WORD	face[3]

Enumerations
enum	pointtype {   POINTTYPE_CURVE = 0 , POINTTYPE_CORNER , POINTTYPE_CURVE_START , POINTTYPE_CURVE_END ,   POINTTYPE_CURVE_MIDDLE , POINTTYPE_CURVE = 0 , POINTTYPE_CORNER , POINTTYPE_CURVE_START ,   POINTTYPE_CURVE_END , POINTTYPE_CURVE_MIDDLE }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (d3dx)
static struct d3dx9_mesh *	impl_from_ID3DXMesh (ID3DXMesh *iface)
static HRESULT WINAPI	d3dx9_mesh_QueryInterface (ID3DXMesh *iface, REFIID riid, void **out)
static ULONG WINAPI	d3dx9_mesh_AddRef (ID3DXMesh *iface)
static ULONG WINAPI	d3dx9_mesh_Release (ID3DXMesh *iface)
static HRESULT WINAPI	d3dx9_mesh_DrawSubset (ID3DXMesh *iface, DWORD attrib_id)
static DWORD WINAPI	d3dx9_mesh_GetNumFaces (ID3DXMesh *iface)
static DWORD WINAPI	d3dx9_mesh_GetNumVertices (ID3DXMesh *iface)
static DWORD WINAPI	d3dx9_mesh_GetFVF (ID3DXMesh *iface)
static void	copy_declaration (D3DVERTEXELEMENT9 *dst, const D3DVERTEXELEMENT9 *src, UINT num_elem)
static HRESULT WINAPI	d3dx9_mesh_GetDeclaration (ID3DXMesh *iface, D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE])
static DWORD WINAPI	d3dx9_mesh_GetNumBytesPerVertex (ID3DXMesh *iface)
static DWORD WINAPI	d3dx9_mesh_GetOptions (ID3DXMesh *iface)
static HRESULT WINAPI	d3dx9_mesh_GetDevice (struct ID3DXMesh *iface, struct IDirect3DDevice9 **device)
static HRESULT WINAPI	d3dx9_mesh_CloneMeshFVF (struct ID3DXMesh *iface, DWORD options, DWORD fvf, struct IDirect3DDevice9 *device, struct ID3DXMesh **clone_mesh)
static FLOAT	scale_clamp_ubyten (FLOAT value)
static FLOAT	scale_clamp_shortn (FLOAT value)
static FLOAT	scale_clamp_ushortn (FLOAT value)
static INT	simple_round (FLOAT value)
static void	convert_float4 (BYTE *dst, const D3DXVECTOR4 *src, D3DDECLTYPE type_dst)
static void	convert_component (BYTE *dst, BYTE *src, D3DDECLTYPE type_dst, D3DDECLTYPE type_src)
static INT	get_equivalent_declaration_index (D3DVERTEXELEMENT9 orig_declaration, D3DVERTEXELEMENT9 *declaration)
static HRESULT	convert_vertex_buffer (ID3DXMesh *mesh_dst, ID3DXMesh *mesh_src)
static BOOL	declaration_equals (const D3DVERTEXELEMENT9 *declaration1, const D3DVERTEXELEMENT9 *declaration2)
static HRESULT WINAPI	d3dx9_mesh_CloneMesh (struct ID3DXMesh *iface, DWORD options, const D3DVERTEXELEMENT9 *declaration, struct IDirect3DDevice9 *device, struct ID3DXMesh **clone_mesh_out)
static HRESULT WINAPI	d3dx9_mesh_GetVertexBuffer (struct ID3DXMesh *iface, struct IDirect3DVertexBuffer9 **vertex_buffer)
static HRESULT WINAPI	d3dx9_mesh_GetIndexBuffer (struct ID3DXMesh *iface, struct IDirect3DIndexBuffer9 **index_buffer)
static HRESULT WINAPI	d3dx9_mesh_LockVertexBuffer (ID3DXMesh *iface, DWORD flags, void **data)
static HRESULT WINAPI	d3dx9_mesh_UnlockVertexBuffer (ID3DXMesh *iface)
static HRESULT WINAPI	d3dx9_mesh_LockIndexBuffer (ID3DXMesh *iface, DWORD flags, void **data)
static HRESULT WINAPI	d3dx9_mesh_UnlockIndexBuffer (ID3DXMesh *iface)
static HRESULT WINAPI	d3dx9_mesh_GetAttributeTable (ID3DXMesh *iface, D3DXATTRIBUTERANGE *attrib_table, DWORD *attrib_table_size)
static HRESULT	init_edge_face_map (struct edge_face_map *edge_face_map, const DWORD *index_buffer, const DWORD *point_reps, DWORD num_faces)
static DWORD	find_adjacent_face (struct edge_face_map *edge_face_map, DWORD vertex1, DWORD vertex2, DWORD num_faces)
static DWORD *	generate_identity_point_reps (DWORD num_vertices)
static HRESULT WINAPI	d3dx9_mesh_ConvertPointRepsToAdjacency (ID3DXMesh *iface, const DWORD *point_reps, DWORD *adjacency)
static HRESULT	propagate_face_vertices (const DWORD *adjacency, DWORD *point_reps, const DWORD *indices, DWORD *new_indices, DWORD face, DWORD numfaces)
static HRESULT WINAPI	d3dx9_mesh_ConvertAdjacencyToPointReps (ID3DXMesh *iface, const DWORD *adjacency, DWORD *point_reps)
static int __cdecl	compare_vertex_keys (const void *a, const void *b)
static HRESULT WINAPI	d3dx9_mesh_GenerateAdjacency (ID3DXMesh *iface, float epsilon, DWORD *adjacency)
static HRESULT WINAPI	d3dx9_mesh_UpdateSemantics (ID3DXMesh *iface, D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE])
static HRESULT WINAPI	d3dx9_mesh_LockAttributeBuffer (ID3DXMesh *iface, DWORD flags, DWORD **data)
static HRESULT WINAPI	d3dx9_mesh_UnlockAttributeBuffer (ID3DXMesh *iface)
static HRESULT WINAPI	d3dx9_mesh_Optimize (ID3DXMesh *iface, DWORD flags, const DWORD *adjacency_in, DWORD *adjacency_out, DWORD *face_remap, ID3DXBuffer **vertex_remap, ID3DXMesh **opt_mesh)
static HRESULT	compact_mesh (struct d3dx9_mesh *This, DWORD *indices, DWORD *new_num_vertices, ID3DXBuffer **vertex_remap)
static DWORD	count_attributes (const DWORD *attrib_buffer, DWORD numfaces)
static void	fill_attribute_table (DWORD *attrib_buffer, DWORD numfaces, void *indices, BOOL is_32bit_indices, D3DXATTRIBUTERANGE *attrib_table)
static int __cdecl	attrib_entry_compare (const void *a, const void *b)
static HRESULT	remap_faces_for_attrsort (struct d3dx9_mesh *This, const DWORD *indices, DWORD *attrib_buffer, DWORD **sorted_attrib_buffer, DWORD **face_remap)
static HRESULT WINAPI	d3dx9_mesh_OptimizeInplace (ID3DXMesh *iface, DWORD flags, const DWORD *adjacency_in, DWORD *adjacency_out, DWORD *face_remap_out, ID3DXBuffer **vertex_remap_out)
static HRESULT WINAPI	d3dx9_mesh_SetAttributeTable (ID3DXMesh *iface, const D3DXATTRIBUTERANGE *attrib_table, DWORD attrib_table_size)
BOOL WINAPI	D3DXBoxBoundProbe (const D3DXVECTOR3 *pmin, const D3DXVECTOR3 *pmax, const D3DXVECTOR3 *prayposition, const D3DXVECTOR3 *praydirection)
HRESULT WINAPI	D3DXComputeBoundingBox (const D3DXVECTOR3 *pfirstposition, DWORD numvertices, DWORD dwstride, D3DXVECTOR3 *pmin, D3DXVECTOR3 *pmax)
HRESULT WINAPI	D3DXComputeBoundingSphere (const D3DXVECTOR3 *pfirstposition, DWORD numvertices, DWORD dwstride, D3DXVECTOR3 *pcenter, float *pradius)
static void	append_decl_element (D3DVERTEXELEMENT9 *declaration, UINT *idx, UINT *offset, D3DDECLTYPE type, D3DDECLUSAGE usage, UINT usage_idx)
HRESULT WINAPI	D3DXDeclaratorFromFVF (DWORD fvf, D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE])
HRESULT WINAPI	D3DXFVFFromDeclarator (const D3DVERTEXELEMENT9 *declaration, DWORD *fvf)
static UINT	Get_TexCoord_Size_From_FVF (DWORD FVF, int tex_num)
UINT WINAPI	D3DXGetFVFVertexSize (DWORD FVF)
UINT WINAPI	D3DXGetDeclVertexSize (const D3DVERTEXELEMENT9 *decl, DWORD stream_idx)
UINT WINAPI	D3DXGetDeclLength (const D3DVERTEXELEMENT9 *decl)
BOOL WINAPI	D3DXIntersectTri (const D3DXVECTOR3 *p0, const D3DXVECTOR3 *p1, const D3DXVECTOR3 *p2, const D3DXVECTOR3 *praypos, const D3DXVECTOR3 *praydir, float *pu, float *pv, float *pdist)
BOOL WINAPI	D3DXSphereBoundProbe (const D3DXVECTOR3 *center, float radius, const D3DXVECTOR3 *ray_position, const D3DXVECTOR3 *ray_direction)
HRESULT WINAPI	D3DXCreateMesh (DWORD numfaces, DWORD numvertices, DWORD options, const D3DVERTEXELEMENT9 *declaration, struct IDirect3DDevice9 *device, struct ID3DXMesh **mesh)
HRESULT WINAPI	D3DXCreateMeshFVF (DWORD numfaces, DWORD numvertices, DWORD options, DWORD fvf, struct IDirect3DDevice9 *device, struct ID3DXMesh **mesh)
static HRESULT	parse_texture_filename (ID3DXFileData *filedata, char **filename_out)
static HRESULT	parse_material (ID3DXFileData *filedata, D3DXMATERIAL *material)
static void	destroy_materials (struct mesh_data *mesh)
static HRESULT	parse_material_list (ID3DXFileData *filedata, struct mesh_data *mesh)
static HRESULT	parse_texture_coords (ID3DXFileData *filedata, struct mesh_data *mesh)
static HRESULT	parse_vertex_colors (ID3DXFileData *filedata, struct mesh_data *mesh)
static HRESULT	parse_normals (ID3DXFileData *filedata, struct mesh_data *mesh)
static HRESULT	parse_skin_mesh_info (ID3DXFileData *filedata, struct mesh_data *mesh_data, DWORD index)
static HRESULT	parse_mesh (ID3DXFileData *filedata, struct mesh_data *mesh_data, DWORD provide_flags)
static HRESULT	generate_effects (ID3DXBuffer *materials, DWORD num_materials, ID3DXBuffer **effects)
HRESULT WINAPI	D3DXLoadSkinMeshFromXof (struct ID3DXFileData *filedata, DWORD options, struct IDirect3DDevice9 *device, struct ID3DXBuffer **adjacency_out, struct ID3DXBuffer **materials_out, struct ID3DXBuffer **effects_out, DWORD *num_materials_out, struct ID3DXSkinInfo **skin_info_out, struct ID3DXMesh **mesh_out)
HRESULT WINAPI	D3DXLoadMeshHierarchyFromXA (const char *filename, DWORD options, struct IDirect3DDevice9 *device, struct ID3DXAllocateHierarchy *alloc_hier, struct ID3DXLoadUserData *load_user_data, D3DXFRAME **frame_hierarchy, struct ID3DXAnimationController **anim_controller)
HRESULT WINAPI	D3DXLoadMeshHierarchyFromXW (const WCHAR *filename, DWORD options, struct IDirect3DDevice9 *device, struct ID3DXAllocateHierarchy *alloc_hier, struct ID3DXLoadUserData *load_user_data, D3DXFRAME **frame_hierarchy, struct ID3DXAnimationController **anim_controller)
static HRESULT	filedata_get_name (ID3DXFileData *filedata, char **name)
static HRESULT	load_mesh_container (struct ID3DXFileData *filedata, DWORD options, struct IDirect3DDevice9 *device, struct ID3DXAllocateHierarchy *alloc_hier, D3DXMESHCONTAINER **mesh_container)
static HRESULT	parse_transform_matrix (ID3DXFileData *filedata, D3DXMATRIX *transform)
static HRESULT	load_frame (struct ID3DXFileData *filedata, DWORD options, struct IDirect3DDevice9 *device, struct ID3DXAllocateHierarchy *alloc_hier, D3DXFRAME **frame_out)
HRESULT WINAPI	D3DXLoadMeshHierarchyFromXInMemory (const void *memory, DWORD memory_size, DWORD options, struct IDirect3DDevice9 *device, struct ID3DXAllocateHierarchy *alloc_hier, struct ID3DXLoadUserData *load_user_data, D3DXFRAME **frame_hierarchy, struct ID3DXAnimationController **anim_controller)
HRESULT WINAPI	D3DXCleanMesh (D3DXCLEANTYPE clean_type, ID3DXMesh *mesh_in, const DWORD *adjacency_in, ID3DXMesh **mesh_out, DWORD *adjacency_out, ID3DXBuffer **errors_and_warnings)
HRESULT WINAPI	D3DXFrameDestroy (D3DXFRAME *frame, ID3DXAllocateHierarchy *alloc_hier)
HRESULT WINAPI	D3DXLoadMeshFromXA (const char *filename, DWORD options, struct IDirect3DDevice9 *device, struct ID3DXBuffer **adjacency, struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances, DWORD *num_materials, struct ID3DXMesh **mesh)
HRESULT WINAPI	D3DXLoadMeshFromXW (const WCHAR *filename, DWORD options, struct IDirect3DDevice9 *device, struct ID3DXBuffer **adjacency, struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances, DWORD *num_materials, struct ID3DXMesh **mesh)
HRESULT WINAPI	D3DXLoadMeshFromXResource (HMODULE module, const char *name, const char *type, DWORD options, struct IDirect3DDevice9 *device, struct ID3DXBuffer **adjacency, struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances, DWORD *num_materials, struct ID3DXMesh **mesh)
static HRESULT	parse_frame (struct ID3DXFileData *filedata, DWORD options, struct IDirect3DDevice9 *device, const D3DXMATRIX *parent_transform, struct list *container_list, DWORD provide_flags)
HRESULT WINAPI	D3DXLoadMeshFromXInMemory (const void *memory, DWORD memory_size, DWORD options, struct IDirect3DDevice9 *device, struct ID3DXBuffer **adjacency_out, struct ID3DXBuffer **materials_out, struct ID3DXBuffer **effects_out, DWORD *num_materials_out, struct ID3DXMesh **mesh_out)
HRESULT WINAPI	D3DXCreatePolygon (struct IDirect3DDevice9 *device, float length, UINT sides, struct ID3DXMesh **mesh, struct ID3DXBuffer **adjacency)
HRESULT WINAPI	D3DXCreateBox (struct IDirect3DDevice9 *device, float width, float height, float depth, struct ID3DXMesh **mesh, struct ID3DXBuffer **adjacency)
static void	free_sincos_table (struct sincos_table *sincos_table)
static BOOL	compute_sincos_table (struct sincos_table *sincos_table, float angle_start, float angle_step, int n)
static WORD	vertex_index (UINT slices, int slice, int stack)
HRESULT WINAPI	D3DXCreateSphere (struct IDirect3DDevice9 *device, float radius, UINT slices, UINT stacks, struct ID3DXMesh **mesh, struct ID3DXBuffer **adjacency)
HRESULT WINAPI	D3DXCreateCylinder (struct IDirect3DDevice9 *device, float radius1, float radius2, float length, UINT slices, UINT stacks, struct ID3DXMesh **mesh, struct ID3DXBuffer **adjacency)
HRESULT WINAPI	D3DXCreateTeapot (struct IDirect3DDevice9 *device, struct ID3DXMesh **mesh, struct ID3DXBuffer **adjacency)
HRESULT WINAPI	D3DXCreateTextA (struct IDirect3DDevice9 *device, HDC hdc, const char *text, float deviation, float extrusion, struct ID3DXMesh **mesh, struct ID3DXBuffer **adjacency, GLYPHMETRICSFLOAT *glyphmetrics)
HRESULT WINAPI	D3DXCreateTorus (struct IDirect3DDevice9 *device, float innerradius, float outerradius, UINT sides, UINT rings, struct ID3DXMesh **mesh, ID3DXBuffer **adjacency)
static BOOL	reserve (struct dynamic_array *array, int count, int itemsize)
static struct point2d *	add_points (struct outline *array, int num)
static struct outline *	add_outline (struct outline_array *array)
static face *	add_face (struct face_array *array)
static struct triangulation *	add_triangulation (struct triangulation_array *array)
static HRESULT	add_vertex_index (struct word_array *array, WORD vertex_index)
	C_ASSERT (sizeof(FIXED)==sizeof(float))
	C_ASSERT (sizeof(POINTFX)==sizeof(D3DXVECTOR2))
static D3DXVECTOR2 *	convert_fixed_to_float (POINTFX *pt, int count, unsigned int emsquare)
static HRESULT	add_bezier_points (struct outline *outline, const D3DXVECTOR2 *p1, const D3DXVECTOR2 *p2, const D3DXVECTOR2 *p3, float max_deviation_sq)
static BOOL	is_direction_similar (D3DXVECTOR2 *dir1, D3DXVECTOR2 *dir2, float cos_theta)
static D3DXVECTOR2 *	unit_vec2 (D3DXVECTOR2 *dir, const D3DXVECTOR2 *pt1, const D3DXVECTOR2 *pt2)
static BOOL	attempt_line_merge (struct outline *outline, int pt_index, const D3DXVECTOR2 *nextpt, BOOL to_curve, const struct cos_table *table)
static HRESULT	create_outline (struct glyphinfo *glyph, void *raw_outline, int datasize, float max_deviation_sq, unsigned int emsquare, const struct cos_table *cos_table)
static float	get_line_to_point_y_distance (D3DXVECTOR2 *line_pt1, D3DXVECTOR2 *line_pt2, D3DXVECTOR2 *point)
static D3DXVECTOR2 *	get_indexed_point (struct point2d_index *pt_idx)
static D3DXVECTOR2 *	get_ordered_vertex (struct glyphinfo *glyph, WORD index)
static void	remove_triangulation (struct triangulation_array *array, struct triangulation *item)
static HRESULT	triangulation_add_point (struct triangulation **t_ptr, struct triangulation_array *triangulations, WORD vtx_idx, BOOL to_top)
static D3DXVECTOR2 *	triangulation_get_next_point (struct triangulation *t, struct glyphinfo *glyph, BOOL on_top)
static int __cdecl	compare_vertex_indices (const void *a, const void *b)
static HRESULT	triangulate (struct triangulation_array *triangulations)
HRESULT WINAPI	D3DXCreateTextW (struct IDirect3DDevice9 *device, HDC hdc, const WCHAR *text, float deviation, float extrusion, struct ID3DXMesh **mesh_ptr, struct ID3DXBuffer **adjacency, GLYPHMETRICSFLOAT *glyphmetrics)
HRESULT WINAPI	D3DXValidMesh (ID3DXMesh *mesh, const DWORD *adjacency, ID3DXBuffer **errors_and_warnings)
static BOOL	weld_float1 (void *to, void *from, FLOAT epsilon)
static BOOL	weld_float2 (void *to, void *from, FLOAT epsilon)
static BOOL	weld_float3 (void *to, void *from, FLOAT epsilon)
static BOOL	weld_float4 (void *to, void *from, FLOAT epsilon)
static BOOL	weld_ubyte4 (void *to, void *from, FLOAT epsilon)
static BOOL	weld_ubyte4n (void *to, void *from, FLOAT epsilon)
static BOOL	weld_d3dcolor (void *to, void *from, FLOAT epsilon)
static BOOL	weld_short2 (void *to, void *from, FLOAT epsilon)
static BOOL	weld_short2n (void *to, void *from, FLOAT epsilon)
static BOOL	weld_short4 (void *to, void *from, FLOAT epsilon)
static BOOL	weld_short4n (void *to, void *from, FLOAT epsilon)
static BOOL	weld_ushort2n (void *to, void *from, FLOAT epsilon)
static BOOL	weld_ushort4n (void *to, void *from, FLOAT epsilon)
static struct udec3	dword_to_udec3 (DWORD d)
static BOOL	weld_udec3 (void *to, void *from, FLOAT epsilon)
static struct dec3n	dword_to_dec3n (DWORD d)
static BOOL	weld_dec3n (void *to, void *from, FLOAT epsilon)
static BOOL	weld_float16_2 (void *to, void *from, FLOAT epsilon)
static BOOL	weld_float16_4 (void *to, void *from, FLOAT epsilon)
static BOOL	weld_component (void *to, void *from, D3DDECLTYPE type, FLOAT epsilon)
static FLOAT	get_component_epsilon (const D3DVERTEXELEMENT9 *decl_ptr, const D3DXWELDEPSILONS *epsilons)
static DWORD	read_ib (void *index_buffer, BOOL indices_are_32bit, DWORD index)
static void	write_ib (void *index_buffer, BOOL indices_are_32bit, DWORD index, DWORD value)
HRESULT WINAPI	D3DXWeldVertices (ID3DXMesh *mesh, DWORD flags, const D3DXWELDEPSILONS *epsilons, const DWORD *adjacency, DWORD *adjacency_out, DWORD *face_remap_out, ID3DXBuffer **vertex_remap_out)
HRESULT WINAPI	D3DXOptimizeVertices (const void *indices, UINT num_faces, UINT num_vertices, BOOL indices_are_32bit, DWORD *vertex_remap)
HRESULT WINAPI	D3DXOptimizeFaces (const void *indices, UINT num_faces, UINT num_vertices, BOOL indices_are_32bit, DWORD *face_remap)
static D3DXVECTOR3 *	vertex_element_vec3 (BYTE *vertices, const D3DVERTEXELEMENT9 *declaration, DWORD vertex_stride, DWORD index)
static D3DXVECTOR3	read_vec3 (BYTE *vertices, const D3DVERTEXELEMENT9 *declaration, DWORD vertex_stride, DWORD index)
HRESULT WINAPI	D3DXComputeTangentFrameEx (ID3DXMesh *mesh, DWORD texture_in_semantic, DWORD texture_in_index, DWORD u_partial_out_semantic, DWORD u_partial_out_index, DWORD v_partial_out_semantic, DWORD v_partial_out_index, DWORD normal_out_semantic, DWORD normal_out_index, DWORD options, const DWORD *adjacency, float partial_edge_threshold, float singular_point_threshold, float normal_edge_threshold, ID3DXMesh **mesh_out, ID3DXBuffer **vertex_mapping)
HRESULT WINAPI	D3DXComputeTangent (ID3DXMesh *mesh, DWORD stage_idx, DWORD tangent_idx, DWORD binorm_idx, DWORD wrap, const DWORD *adjacency)
HRESULT WINAPI	D3DXComputeNormals (struct ID3DXBaseMesh *mesh, const DWORD *adjacency)
HRESULT WINAPI	D3DXIntersect (ID3DXBaseMesh *mesh, const D3DXVECTOR3 *ray_pos, const D3DXVECTOR3 *ray_dir, BOOL *hit, DWORD *face_index, float *u, float *v, float *distance, ID3DXBuffer **all_hits, DWORD *count_of_hits)
HRESULT WINAPI	D3DXTessellateNPatches (ID3DXMesh *mesh, const DWORD *adjacency_in, float num_segs, BOOL quadratic_normals, ID3DXMesh **mesh_out, ID3DXBuffer **adjacency_out)
HRESULT WINAPI	D3DXConvertMeshSubsetToSingleStrip (struct ID3DXBaseMesh *mesh_in, DWORD attribute_id, DWORD ib_flags, struct IDirect3DIndexBuffer9 **index_buffer, DWORD *index_count)
static BOOL	queue_frame_node (struct list *queue, D3DXFRAME *frame)
static void	empty_frame_queue (struct list *queue)
D3DXFRAME *WINAPI	D3DXFrameFind (const D3DXFRAME *root, const char *name)

Variables
static const UINT	d3dx_decltype_size []
static const struct ID3DXMeshVtbl	D3DXMesh_Vtbl

Macro Definition Documentation

EFFECT_TABLE_ENTRY

#define EFFECT_TABLE_ENTRY	(		str,
			field
	)		{str, sizeof(str), sizeof(material_ptr->MatD3D.field), offsetof(D3DXMATERIAL, MatD3D.field)}

FILL_INDEX_BUFFER

#define FILL_INDEX_BUFFER

(

indices_var

)

Value:

        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++; \
        }

NUM_ELEM [1/2]

#define NUM_ELEM   2

NUM_ELEM [2/2]

#define NUM_ELEM   4

PROVIDE_ADJACENCY

#define PROVIDE_ADJACENCY   0x4

Definition at line 3165 of file mesh.c.

PROVIDE_MATERIALS

#define PROVIDE_MATERIALS   0x1

Definition at line 3163 of file mesh.c.

PROVIDE_SKININFO

#define PROVIDE_SKININFO   0x2

Definition at line 3164 of file mesh.c.

Typedef Documentation

face

typedef GLenum GLuint GLint GLenum face

Definition at line 4747 of file mesh.c.

Enumeration Type Documentation

pointtype

enum pointtype

Enumerator
POINTTYPE_CURVE
POINTTYPE_CORNER
POINTTYPE_CURVE_START
POINTTYPE_CURVE_END
POINTTYPE_CURVE_MIDDLE
POINTTYPE_CURVE
POINTTYPE_CORNER
POINTTYPE_CURVE_START
POINTTYPE_CURVE_END
POINTTYPE_CURVE_MIDDLE

Definition at line 5308 of file mesh.c.

               {
    POINTTYPE_CURVE = 0,
    POINTTYPE_CORNER,
    POINTTYPE_CURVE_START,
    POINTTYPE_CURVE_END,
    POINTTYPE_CURVE_MIDDLE,
};

Function Documentation

add_bezier_points()

static HRESULT add_bezier_points ( struct outline *  outline, const D3DXVECTOR2 *  p1, const D3DXVECTOR2 *  p2, const D3DXVECTOR2 *  p3, float  max_deviation_sq  )

static

Definition at line 5478 of file mesh.c.

{
    D3DXVECTOR2 split1 = {0, 0}, split2 = {0, 0}, middle, vec;
    float deviation_sq;
 
    D3DXVec2Scale(&split1, D3DXVec2Add(&split1, p1, p2), 0.5f);
    D3DXVec2Scale(&split2, D3DXVec2Add(&split2, p2, p3), 0.5f);
    D3DXVec2Scale(&middle, D3DXVec2Add(&middle, &split1, &split2), 0.5f);
 
    deviation_sq = D3DXVec2LengthSq(D3DXVec2Subtract(&vec, &middle, p2));
    if (deviation_sq < max_deviation_sq) {
        struct point2d *pt = add_points(outline, 1);
        if (!pt) return E_OUTOFMEMORY;
        pt->pos = *p2;
        pt->corner = POINTTYPE_CURVE;
        /* the end point is omitted because the end line merges into the next segment of
         * the split bezier curve, and the end of the split bezier curve is added outside
         * this recursive function. */
    } else {
        HRESULT hr = add_bezier_points(outline, p1, &split1, &middle, max_deviation_sq);
        if (hr != S_OK) return hr;
        hr = add_bezier_points(outline, &middle, &split2, p3, max_deviation_sq);
        if (hr != S_OK) return hr;
    }
 
    return S_OK;
}

Referenced by add_bezier_points(), and create_outline().

add_face()

static face * add_face ( struct face_array *  array )

inlinestatic

Definition at line 5436 of file mesh.c.

{
    return &array->items[array->count++];
}

Referenced by triangulation_add_point().

add_outline()

static struct outline * add_outline ( struct outline_array *  array )

static

Definition at line 5424 of file mesh.c.

{
    struct outline *item;
 
    if (!reserve((struct dynamic_array *)array, array->count + 1, sizeof(array->items[0])))
        return NULL;
 
    item = &array->items[array->count++];
    ZeroMemory(item, sizeof(*item));
    return item;
}

Referenced by create_outline().

add_points()

static struct point2d * add_points ( struct outline *  array, int  num  )

static

Definition at line 5412 of file mesh.c.

{
    struct point2d *item;
 
    if (!reserve((struct dynamic_array *)array, array->count + num, sizeof(array->items[0])))
        return NULL;
 
    item = &array->items[array->count];
    array->count += num;
    return item;
}

Referenced by add_bezier_points(), and create_outline().

add_triangulation()

static struct triangulation * add_triangulation ( struct triangulation_array *  array )

static

Definition at line 5441 of file mesh.c.

{
    struct triangulation *item;
 
    if (!reserve((struct dynamic_array *)array, array->count + 1, sizeof(array->items[0])))
        return NULL;
 
    item = &array->items[array->count++];
    ZeroMemory(item, sizeof(*item));
    return item;
}

Referenced by triangulate().

add_vertex_index()

static HRESULT add_vertex_index ( struct word_array *  array, WORD  vertex_index  )

static

Definition at line 5453 of file mesh.c.

{
    if (!reserve((struct dynamic_array *)array, array->count + 1, sizeof(array->items[0])))
        return E_OUTOFMEMORY;
 
    array->items[array->count++] = vertex_index;
    return S_OK;
}

Referenced by triangulate(), and triangulation_add_point().

append_decl_element()

static void append_decl_element ( D3DVERTEXELEMENT9 *  declaration, UINT *  idx, UINT *  offset, D3DDECLTYPE  type, D3DDECLUSAGE  usage, UINT  usage_idx  )

static

Definition at line 2019 of file mesh.c.

{
    declaration[*idx].Stream = 0;
    declaration[*idx].Offset = *offset;
    declaration[*idx].Type = type;
    declaration[*idx].Method = D3DDECLMETHOD_DEFAULT;
    declaration[*idx].Usage = usage;
    declaration[*idx].UsageIndex = usage_idx;
 
    *offset += d3dx_decltype_size[type];
    ++(*idx);
}

Referenced by D3DXDeclaratorFromFVF().

attempt_line_merge()

static BOOL attempt_line_merge ( struct outline *  outline, int  pt_index, const D3DXVECTOR2 *  nextpt, BOOL  to_curve, const struct cos_table *  table  )

static

Definition at line 5526 of file mesh.c.

{
    D3DXVECTOR2 curdir, lastdir;
    struct point2d *prevpt, *pt;
    BOOL ret = FALSE;
 
    pt = &outline->items[pt_index];
    pt_index = (pt_index - 1 + outline->count) % outline->count;
    prevpt = &outline->items[pt_index];
 
    if (to_curve)
        pt->corner = pt->corner != POINTTYPE_CORNER ? POINTTYPE_CURVE_MIDDLE : POINTTYPE_CURVE_START;
 
    if (outline->count < 2)
        return FALSE;
 
    /* remove last point if the next line continues the last line */
    unit_vec2(&lastdir, &prevpt->pos, &pt->pos);
    unit_vec2(&curdir, &pt->pos, nextpt);
    if (is_direction_similar(&lastdir, &curdir, table->cos_half))
    {
        outline->count--;
        if (pt->corner == POINTTYPE_CURVE_END)
            prevpt->corner = pt->corner;
        if (prevpt->corner == POINTTYPE_CURVE_END && to_curve)
            prevpt->corner = POINTTYPE_CURVE_MIDDLE;
        pt = prevpt;
 
        ret = TRUE;
        if (outline->count < 2)
            return ret;
 
        pt_index = (pt_index - 1 + outline->count) % outline->count;
        prevpt = &outline->items[pt_index];
        unit_vec2(&lastdir, &prevpt->pos, &pt->pos);
        unit_vec2(&curdir, &pt->pos, nextpt);
    }
    return ret;
}

Referenced by create_outline().

attrib_entry_compare()

static int __cdecl attrib_entry_compare ( const void *  a, const void *  b  )

static

Definition at line 1593 of file mesh.c.

{
    const DWORD *ptr_a = *(const DWORD **)a;
    const DWORD *ptr_b = *(const DWORD **)b;
    int delta = *ptr_a - *ptr_b;
 
    if (delta)
        return delta;
 
    delta = ptr_a - ptr_b; /* for stable sort */
    return delta;
}

Referenced by remap_faces_for_attrsort().

C_ASSERT() [1/2]

C_ASSERT

(

sizeof(FIXED)

= =sizeof(float)

)

C_ASSERT() [2/2]

C_ASSERT

(

sizeof(POINTFX)

= =sizeof(D3DXVECTOR2)

)

compact_mesh()

static HRESULT compact_mesh ( struct d3dx9_mesh *  This, DWORD *  indices, DWORD *  new_num_vertices, ID3DXBuffer **  vertex_remap  )

static

Definition at line 1497 of file mesh.c.

{
    HRESULT hr;
    DWORD *vertex_remap_ptr;
    DWORD num_used_vertices;
    DWORD i;
 
    hr = D3DXCreateBuffer(This->numvertices * sizeof(DWORD), vertex_remap);
    if (FAILED(hr)) return hr;
    vertex_remap_ptr = ID3DXBuffer_GetBufferPointer(*vertex_remap);
 
    for (i = 0; i < This->numfaces * 3; i++)
        vertex_remap_ptr[indices[i]] = 1;
 
    /* create old->new vertex mapping */
    num_used_vertices = 0;
    for (i = 0; i < This->numvertices; i++) {
        if (vertex_remap_ptr[i])
            vertex_remap_ptr[i] = num_used_vertices++;
        else
            vertex_remap_ptr[i] = -1;
    }
    /* convert indices */
    for (i = 0; i < This->numfaces * 3; i++)
        indices[i] = vertex_remap_ptr[indices[i]];
 
    /* create new->old vertex mapping */
    num_used_vertices = 0;
    for (i = 0; i < This->numvertices; i++) {
        if (vertex_remap_ptr[i] != -1)
            vertex_remap_ptr[num_used_vertices++] = i;
    }
    for (i = num_used_vertices; i < This->numvertices; i++)
        vertex_remap_ptr[i] = -1;
 
    *new_num_vertices = num_used_vertices;
 
    return D3D_OK;
}

Referenced by d3dx9_mesh_OptimizeInplace().

compare_vertex_indices()

static int __cdecl compare_vertex_indices ( const void *  a, const void *  b  )

static

Definition at line 5845 of file mesh.c.

{
    const struct point2d_index *idx1 = a, *idx2 = b;
    const D3DXVECTOR2 *p1 = &idx1->outline->items[idx1->vertex].pos;
    const D3DXVECTOR2 *p2 = &idx2->outline->items[idx2->vertex].pos;
    float diff = p1->x - p2->x;
 
    if (diff == 0.0f)
        diff = p1->y - p2->y;
 
    return diff == 0.0f ? 0 : (diff > 0.0f ? -1 : 1);
}

Referenced by triangulate().

compare_vertex_keys()

static int __cdecl compare_vertex_keys ( const void *  a, const void *  b  )

static

Definition at line 1215 of file mesh.c.

{
    const struct vertex_metadata *left = a;
    const struct vertex_metadata *right = b;
    if (left->key == right->key)
        return 0;
    return left->key < right->key ? -1 : 1;
}

Referenced by d3dx9_mesh_GenerateAdjacency().

compute_sincos_table()

static BOOL compute_sincos_table ( struct sincos_table *  sincos_table, float  angle_start, float  angle_step, int  n  )

static

Definition at line 4762 of file mesh.c.

{
    float angle;
    int i;
 
    sincos_table->sin = HeapAlloc(GetProcessHeap(), 0, n * sizeof(*sincos_table->sin));
    if (!sincos_table->sin)
    {
        return FALSE;
    }
    sincos_table->cos = HeapAlloc(GetProcessHeap(), 0, n * sizeof(*sincos_table->cos));
    if (!sincos_table->cos)
    {
        HeapFree(GetProcessHeap(), 0, sincos_table->sin);
        return FALSE;
    }
 
    angle = angle_start;
    for (i = 0; i < n; i++)
    {
        sincos_table->sin[i] = sinf(angle);
        sincos_table->cos[i] = cosf(angle);
        angle += angle_step;
    }
 
    return TRUE;
}

Referenced by compute_cylinder(), compute_sphere(), D3DXCreateCylinder(), and D3DXCreateSphere().

convert_component()

static void convert_component ( BYTE *  dst, BYTE *  src, D3DDECLTYPE  type_dst, D3DDECLTYPE  type_src  )

static

Definition at line 469 of file mesh.c.

{
    BOOL fixme_once = FALSE;
 
    switch (type_src)
    {
        case D3DDECLTYPE_FLOAT1:
        {
            FLOAT *src_ptr = (FLOAT*)src;
            D3DXVECTOR4 src_float4 = {*src_ptr, 0.0f, 0.0f, 1.0f};
            convert_float4(dst, &src_float4, type_dst);
            break;
        }
        case D3DDECLTYPE_FLOAT2:
        {
            D3DXVECTOR2 *src_ptr = (D3DXVECTOR2*)src;
            D3DXVECTOR4 src_float4 = {src_ptr->x, src_ptr->y, 0.0f, 1.0f};
            convert_float4(dst, &src_float4, type_dst);
            break;
        }
        case D3DDECLTYPE_FLOAT3:
        {
            D3DXVECTOR3 *src_ptr = (D3DXVECTOR3*)src;
            D3DXVECTOR4 src_float4 = {src_ptr->x, src_ptr->y, src_ptr->z, 1.0f};
            convert_float4(dst, &src_float4, type_dst);
            break;
        }
        case D3DDECLTYPE_FLOAT4:
        {
            D3DXVECTOR4 *src_ptr = (D3DXVECTOR4*)src;
            D3DXVECTOR4 src_float4 = {src_ptr->x, src_ptr->y, src_ptr->z, src_ptr->w};
            convert_float4(dst, &src_float4, type_dst);
            break;
        }
        case D3DDECLTYPE_D3DCOLOR:
        {
            D3DXVECTOR4 src_float4 =
            {
                (FLOAT)src[2]/UCHAR_MAX,
                (FLOAT)src[1]/UCHAR_MAX,
                (FLOAT)src[0]/UCHAR_MAX,
                (FLOAT)src[3]/UCHAR_MAX
            };
            convert_float4(dst, &src_float4, type_dst);
            break;
        }
        case D3DDECLTYPE_UBYTE4:
        {
            D3DXVECTOR4 src_float4 = {src[0], src[1], src[2], src[3]};
            convert_float4(dst, &src_float4, type_dst);
            break;
        }
        case D3DDECLTYPE_SHORT2:
        {
            SHORT *src_ptr = (SHORT*)src;
            D3DXVECTOR4 src_float4 = {src_ptr[0], src_ptr[1], 0.0f, 1.0f};
            convert_float4(dst, &src_float4, type_dst);
            break;
        }
        case D3DDECLTYPE_SHORT4:
        {
            SHORT *src_ptr = (SHORT*)src;
            D3DXVECTOR4 src_float4 = {src_ptr[0], src_ptr[1], src_ptr[2], src_ptr[3]};
            convert_float4(dst, &src_float4, type_dst);
            break;
        }
        case D3DDECLTYPE_UBYTE4N:
        {
            D3DXVECTOR4 src_float4 =
            {
                (FLOAT)src[0]/UCHAR_MAX,
                (FLOAT)src[1]/UCHAR_MAX,
                (FLOAT)src[2]/UCHAR_MAX,
                (FLOAT)src[3]/UCHAR_MAX
            };
            convert_float4(dst, &src_float4, type_dst);
            break;
        }
        case D3DDECLTYPE_SHORT2N:
        {
            SHORT *src_ptr = (SHORT*)src;
            D3DXVECTOR4 src_float4 = {(FLOAT)src_ptr[0]/SHRT_MAX, (FLOAT)src_ptr[1]/SHRT_MAX, 0.0f, 1.0f};
            convert_float4(dst, &src_float4, type_dst);
            break;
        }
        case D3DDECLTYPE_SHORT4N:
        {
            SHORT *src_ptr = (SHORT*)src;
            D3DXVECTOR4 src_float4 =
            {
                (FLOAT)src_ptr[0]/SHRT_MAX,
                (FLOAT)src_ptr[1]/SHRT_MAX,
                (FLOAT)src_ptr[2]/SHRT_MAX,
                (FLOAT)src_ptr[3]/SHRT_MAX
            };
            convert_float4(dst, &src_float4, type_dst);
            break;
        }
        case D3DDECLTYPE_FLOAT16_2:
        {
            D3DXVECTOR4 src_float4 = {0.0f, 0.0f, 0.0f, 1.0f};
            D3DXFloat16To32Array((FLOAT*)&src_float4, (D3DXFLOAT16*)src, 2);
            convert_float4(dst, &src_float4, type_dst);
            break;
        }
        case D3DDECLTYPE_FLOAT16_4:
        {
            D3DXVECTOR4 src_float4;
            D3DXFloat16To32Array((FLOAT*)&src_float4, (D3DXFLOAT16*)src, 4);
            convert_float4(dst, &src_float4, type_dst);
            break;
        }
        default:
            if (!fixme_once++)
                FIXME("Conversion of D3DDECLTYPE %d to %d not implemented.\n", type_src, type_dst);
            break;
    }
}

Referenced by convert_vertex_buffer().

convert_fixed_to_float()

static D3DXVECTOR2 * convert_fixed_to_float ( POINTFX *  pt, int  count, unsigned int  emsquare  )

inlinestatic

Definition at line 5466 of file mesh.c.

{
    D3DXVECTOR2 *ret = (D3DXVECTOR2*)pt;
    while (count--) {
        D3DXVECTOR2 *pt_flt = (D3DXVECTOR2*)pt;
        pt_flt->x = (pt->x.value + pt->x.fract / (float)0x10000) / emsquare;
        pt_flt->y = (pt->y.value + pt->y.fract / (float)0x10000) / emsquare;
        pt++;
    }
    return ret;
}

Referenced by create_outline().

convert_float4()

static void convert_float4 ( BYTE *  dst, const D3DXVECTOR4 *  src, D3DDECLTYPE  type_dst  )

static

Definition at line 344 of file mesh.c.

{
    BOOL fixme_once = FALSE;
 
    switch (type_dst)
    {
        case D3DDECLTYPE_FLOAT1:
        {
            FLOAT *dst_ptr = (FLOAT*)dst;
            *dst_ptr = src->x;
            break;
        }
        case D3DDECLTYPE_FLOAT2:
        {
            D3DXVECTOR2 *dst_ptr = (D3DXVECTOR2*)dst;
            dst_ptr->x = src->x;
            dst_ptr->y = src->y;
            break;
        }
        case D3DDECLTYPE_FLOAT3:
        {
            D3DXVECTOR3 *dst_ptr = (D3DXVECTOR3*)dst;
            dst_ptr->x = src->x;
            dst_ptr->y = src->y;
            dst_ptr->z = src->z;
            break;
        }
        case D3DDECLTYPE_FLOAT4:
        {
            D3DXVECTOR4 *dst_ptr = (D3DXVECTOR4*)dst;
            dst_ptr->x = src->x;
            dst_ptr->y = src->y;
            dst_ptr->z = src->z;
            dst_ptr->w = src->w;
            break;
        }
        case D3DDECLTYPE_D3DCOLOR:
        {
            dst[0] = (BYTE)simple_round(scale_clamp_ubyten(src->z));
            dst[1] = (BYTE)simple_round(scale_clamp_ubyten(src->y));
            dst[2] = (BYTE)simple_round(scale_clamp_ubyten(src->x));
            dst[3] = (BYTE)simple_round(scale_clamp_ubyten(src->w));
            break;
        }
        case D3DDECLTYPE_UBYTE4:
        {
            dst[0] = src->x < 0.0f ? 0 : (BYTE)simple_round(src->x);
            dst[1] = src->y < 0.0f ? 0 : (BYTE)simple_round(src->y);
            dst[2] = src->z < 0.0f ? 0 : (BYTE)simple_round(src->z);
            dst[3] = src->w < 0.0f ? 0 : (BYTE)simple_round(src->w);
            break;
        }
        case D3DDECLTYPE_SHORT2:
        {
            SHORT *dst_ptr = (SHORT*)dst;
            dst_ptr[0] = (SHORT)simple_round(src->x);
            dst_ptr[1] = (SHORT)simple_round(src->y);
            break;
        }
        case D3DDECLTYPE_SHORT4:
        {
            SHORT *dst_ptr = (SHORT*)dst;
            dst_ptr[0] = (SHORT)simple_round(src->x);
            dst_ptr[1] = (SHORT)simple_round(src->y);
            dst_ptr[2] = (SHORT)simple_round(src->z);
            dst_ptr[3] = (SHORT)simple_round(src->w);
            break;
        }
        case D3DDECLTYPE_UBYTE4N:
        {
            dst[0] = (BYTE)simple_round(scale_clamp_ubyten(src->x));
            dst[1] = (BYTE)simple_round(scale_clamp_ubyten(src->y));
            dst[2] = (BYTE)simple_round(scale_clamp_ubyten(src->z));
            dst[3] = (BYTE)simple_round(scale_clamp_ubyten(src->w));
            break;
        }
        case D3DDECLTYPE_SHORT2N:
        {
            SHORT *dst_ptr = (SHORT*)dst;
            dst_ptr[0] = (SHORT)simple_round(scale_clamp_shortn(src->x));
            dst_ptr[1] = (SHORT)simple_round(scale_clamp_shortn(src->y));
            break;
        }
        case D3DDECLTYPE_SHORT4N:
        {
            SHORT *dst_ptr = (SHORT*)dst;
            dst_ptr[0] = (SHORT)simple_round(scale_clamp_shortn(src->x));
            dst_ptr[1] = (SHORT)simple_round(scale_clamp_shortn(src->y));
            dst_ptr[2] = (SHORT)simple_round(scale_clamp_shortn(src->z));
            dst_ptr[3] = (SHORT)simple_round(scale_clamp_shortn(src->w));
            break;
        }
        case D3DDECLTYPE_USHORT2N:
        {
            USHORT *dst_ptr = (USHORT*)dst;
            dst_ptr[0] = (USHORT)simple_round(scale_clamp_ushortn(src->x));
            dst_ptr[1] = (USHORT)simple_round(scale_clamp_ushortn(src->y));
            break;
        }
        case D3DDECLTYPE_USHORT4N:
        {
            USHORT *dst_ptr = (USHORT*)dst;
            dst_ptr[0] = (USHORT)simple_round(scale_clamp_ushortn(src->x));
            dst_ptr[1] = (USHORT)simple_round(scale_clamp_ushortn(src->y));
            dst_ptr[2] = (USHORT)simple_round(scale_clamp_ushortn(src->z));
            dst_ptr[3] = (USHORT)simple_round(scale_clamp_ushortn(src->w));
            break;
        }
        case D3DDECLTYPE_FLOAT16_2:
        {
            D3DXFloat32To16Array((D3DXFLOAT16*)dst, (FLOAT*)src, 2);
            break;
        }
        case D3DDECLTYPE_FLOAT16_4:
        {
            D3DXFloat32To16Array((D3DXFLOAT16*)dst, (FLOAT*)src, 4);
            break;
        }
        default:
            if (!fixme_once++)
                FIXME("Conversion from D3DDECLTYPE_FLOAT4 to %d not implemented.\n", type_dst);
            break;
    }
}

Referenced by convert_component().

convert_vertex_buffer()

static HRESULT convert_vertex_buffer ( ID3DXMesh *  mesh_dst, ID3DXMesh *  mesh_src  )

static

Definition at line 604 of file mesh.c.

{
    HRESULT hr;
    D3DVERTEXELEMENT9 orig_declaration[MAX_FVF_DECL_SIZE] = {D3DDECL_END()};
    D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE] = {D3DDECL_END()};
    BYTE *vb_dst = NULL;
    BYTE *vb_src = NULL;
    UINT i;
    UINT num_vertices = mesh_src->lpVtbl->GetNumVertices(mesh_src);
    UINT dst_vertex_size = mesh_dst->lpVtbl->GetNumBytesPerVertex(mesh_dst);
    UINT src_vertex_size = mesh_src->lpVtbl->GetNumBytesPerVertex(mesh_src);
 
    hr = mesh_src->lpVtbl->GetDeclaration(mesh_src, orig_declaration);
    if (FAILED(hr)) return hr;
    hr = mesh_dst->lpVtbl->GetDeclaration(mesh_dst, declaration);
    if (FAILED(hr)) return hr;
 
    hr = mesh_src->lpVtbl->LockVertexBuffer(mesh_src, D3DLOCK_READONLY, (void**)&vb_src);
    if (FAILED(hr)) goto cleanup;
    hr = mesh_dst->lpVtbl->LockVertexBuffer(mesh_dst, 0, (void**)&vb_dst);
    if (FAILED(hr)) goto cleanup;
 
    /* Clear all new fields by clearing the entire vertex buffer. */
    memset(vb_dst, 0, num_vertices * dst_vertex_size);
 
    for (i = 0; orig_declaration[i].Stream != 0xff; i++)
    {
        INT eq_idx = get_equivalent_declaration_index(orig_declaration[i], declaration);
 
        if (eq_idx >= 0)
        {
            UINT j;
            for (j = 0; j < num_vertices; j++)
            {
                UINT idx_dst = dst_vertex_size * j + declaration[eq_idx].Offset;
                UINT idx_src = src_vertex_size * j + orig_declaration[i].Offset;
                UINT type_size = d3dx_decltype_size[orig_declaration[i].Type];
 
                if (orig_declaration[i].Type == declaration[eq_idx].Type)
                    memcpy(&vb_dst[idx_dst], &vb_src[idx_src], type_size);
                else
                   convert_component(&vb_dst[idx_dst], &vb_src[idx_src], declaration[eq_idx].Type, orig_declaration[i].Type);
            }
        }
    }
 
    hr = D3D_OK;
cleanup:
    if (vb_dst) mesh_dst->lpVtbl->UnlockVertexBuffer(mesh_dst);
    if (vb_src) mesh_src->lpVtbl->UnlockVertexBuffer(mesh_src);
 
    return hr;
}

Referenced by d3dx9_mesh_CloneMesh().

copy_declaration()

static void copy_declaration ( D3DVERTEXELEMENT9 *  dst, const D3DVERTEXELEMENT9 *  src, UINT  num_elem  )

static

Definition at line 218 of file mesh.c.

{
    memcpy(dst, src, num_elem * sizeof(*src));
}

Referenced by d3dx9_mesh_GetDeclaration(), d3dx9_mesh_UpdateSemantics(), and D3DXCreateMesh().

count_attributes()

static DWORD count_attributes ( const DWORD *  attrib_buffer, DWORD  numfaces  )

static

Definition at line 1539 of file mesh.c.

{
    DWORD last_attribute = attrib_buffer[0];
    DWORD attrib_table_size = 1;
    DWORD i;
    for (i = 1; i < numfaces; i++) {
        if (attrib_buffer[i] != last_attribute) {
            last_attribute = attrib_buffer[i];
            attrib_table_size++;
        }
    }
    return attrib_table_size;
}

Referenced by d3dx9_mesh_OptimizeInplace().

create_outline()

static HRESULT create_outline ( struct glyphinfo *  glyph, void *  raw_outline, int  datasize, float  max_deviation_sq, unsigned int  emsquare, const struct cos_table *  cos_table  )

static

Definition at line 5570 of file mesh.c.

{
    TTPOLYGONHEADER *header = (TTPOLYGONHEADER *)raw_outline;
 
    while ((char *)header < (char *)raw_outline + datasize)
    {
        TTPOLYCURVE *curve = (TTPOLYCURVE *)(header + 1);
        struct point2d *lastpt, *pt;
        D3DXVECTOR2 lastdir;
        D3DXVECTOR2 *pt_flt;
        int j;
        struct outline *outline = add_outline(&glyph->outlines);
 
        if (!outline)
            return E_OUTOFMEMORY;
 
        pt = add_points(outline, 1);
        if (!pt)
            return E_OUTOFMEMORY;
        pt_flt = convert_fixed_to_float(&header->pfxStart, 1, emsquare);
        pt->pos = *pt_flt;
        pt->corner = POINTTYPE_CORNER;
 
        if (header->dwType != TT_POLYGON_TYPE)
            FIXME("Unknown header type %d\n", header->dwType);
 
        while ((char *)curve < (char *)header + header->cb)
        {
            D3DXVECTOR2 bezier_start = outline->items[outline->count - 1].pos;
            BOOL to_curve = curve->wType != TT_PRIM_LINE && curve->cpfx > 1;
            unsigned int j2 = 0;
 
            if (!curve->cpfx) {
                curve = (TTPOLYCURVE *)&curve->apfx[curve->cpfx];
                continue;
            }
 
            pt_flt = convert_fixed_to_float(curve->apfx, curve->cpfx, emsquare);
 
            attempt_line_merge(outline, outline->count - 1, &pt_flt[0], to_curve, cos_table);
 
            if (to_curve)
            {
                HRESULT hr;
                int count = curve->cpfx;
 
                while (count > 2)
                {
                    D3DXVECTOR2 bezier_end;
 
                    D3DXVec2Scale(&bezier_end, D3DXVec2Add(&bezier_end, &pt_flt[j2], &pt_flt[j2+1]), 0.5f);
                    hr = add_bezier_points(outline, &bezier_start, &pt_flt[j2], &bezier_end, max_deviation_sq);
                    if (hr != S_OK)
                        return hr;
                    bezier_start = bezier_end;
                    count--;
                    j2++;
                }
                hr = add_bezier_points(outline, &bezier_start, &pt_flt[j2], &pt_flt[j2+1], max_deviation_sq);
                if (hr != S_OK)
                    return hr;
 
                pt = add_points(outline, 1);
                if (!pt)
                    return E_OUTOFMEMORY;
                j2++;
                pt->pos = pt_flt[j2];
                pt->corner = POINTTYPE_CURVE_END;
            } else {
                pt = add_points(outline, curve->cpfx);
                if (!pt)
                    return E_OUTOFMEMORY;
                for (j2 = 0; j2 < curve->cpfx; j2++)
                {
                    pt->pos = pt_flt[j2];
                    pt->corner = POINTTYPE_CORNER;
                    pt++;
                }
            }
 
            curve = (TTPOLYCURVE *)&curve->apfx[curve->cpfx];
        }
 
        /* remove last point if the next line continues the last line */
        if (outline->count >= 3) {
            BOOL to_curve;
 
            lastpt = &outline->items[outline->count - 1];
            pt = &outline->items[0];
            if (pt->pos.x == lastpt->pos.x && pt->pos.y == lastpt->pos.y) {
                if (lastpt->corner == POINTTYPE_CURVE_END)
                {
                    if (pt->corner == POINTTYPE_CURVE_START)
                        pt->corner = POINTTYPE_CURVE_MIDDLE;
                    else
                        pt->corner = POINTTYPE_CURVE_END;
                }
                outline->count--;
            } else {
                /* outline closed with a line from end to start point */
                attempt_line_merge(outline, outline->count - 1, &pt->pos, FALSE, cos_table);
            }
            lastpt = &outline->items[0];
            to_curve = lastpt->corner != POINTTYPE_CORNER && lastpt->corner != POINTTYPE_CURVE_END;
            if (lastpt->corner == POINTTYPE_CURVE_START)
                lastpt->corner = POINTTYPE_CORNER;
            pt = &outline->items[1];
            if (attempt_line_merge(outline, 0, &pt->pos, to_curve, cos_table))
                *lastpt = outline->items[outline->count];
        }
 
        lastpt = &outline->items[outline->count - 1];
        pt = &outline->items[0];
        unit_vec2(&lastdir, &lastpt->pos, &pt->pos);
        for (j = 0; j < outline->count; j++)
        {
            D3DXVECTOR2 curdir;
 
            lastpt = pt;
            pt = &outline->items[(j + 1) % outline->count];
            unit_vec2(&curdir, &lastpt->pos, &pt->pos);
 
            switch (lastpt->corner)
            {
                case POINTTYPE_CURVE_START:
                case POINTTYPE_CURVE_END:
                    if (!is_direction_similar(&lastdir, &curdir, cos_table->cos_45))
                        lastpt->corner = POINTTYPE_CORNER;
                    break;
                case POINTTYPE_CURVE_MIDDLE:
                    if (!is_direction_similar(&lastdir, &curdir, cos_table->cos_90))
                        lastpt->corner = POINTTYPE_CORNER;
                    else
                        lastpt->corner = POINTTYPE_CURVE;
                    break;
                default:
                    break;
            }
            lastdir = curdir;
        }
 
        header = (TTPOLYGONHEADER *)((char *)header + header->cb);
    }
    return S_OK;
}

Referenced by D3DXCreateTextW(), and test_createtext().

d3dx9_mesh_AddRef()

static ULONG WINAPI d3dx9_mesh_AddRef ( ID3DXMesh *  iface )

static

Definition at line 111 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
    ULONG refcount = InterlockedIncrement(&mesh->ref);
 
    TRACE("%p increasing refcount to %u.\n", mesh, refcount);
 
    return refcount;
}

d3dx9_mesh_CloneMesh()

static HRESULT WINAPI d3dx9_mesh_CloneMesh ( struct ID3DXMesh *  iface, DWORD  options, const D3DVERTEXELEMENT9 *  declaration, struct IDirect3DDevice9 *  device, struct ID3DXMesh **  clone_mesh_out  )

static

Definition at line 677 of file mesh.c.

{
    struct d3dx9_mesh *This = impl_from_ID3DXMesh(iface);
    struct d3dx9_mesh *cloned_this;
    ID3DXMesh *clone_mesh;
    D3DVERTEXELEMENT9 orig_declaration[MAX_FVF_DECL_SIZE] = { D3DDECL_END() };
    void *data_in, *data_out;
    DWORD vertex_size;
    HRESULT hr;
    BOOL same_declaration;
 
    TRACE("iface %p, options %#x, declaration %p, device %p, clone_mesh_out %p.\n",
            iface, options, declaration, device, clone_mesh_out);
 
    if (!clone_mesh_out)
        return D3DERR_INVALIDCALL;
 
    hr = iface->lpVtbl->GetDeclaration(iface, orig_declaration);
    if (FAILED(hr)) return hr;
 
    hr = D3DXCreateMesh(This->numfaces, This->numvertices, options & ~D3DXMESH_VB_SHARE,
                        declaration, device, &clone_mesh);
    if (FAILED(hr)) return hr;
 
    cloned_this = impl_from_ID3DXMesh(clone_mesh);
    vertex_size = clone_mesh->lpVtbl->GetNumBytesPerVertex(clone_mesh);
    same_declaration = declaration_equals(declaration, orig_declaration);
 
    if (options & D3DXMESH_VB_SHARE) {
        if (!same_declaration) {
            hr = D3DERR_INVALIDCALL;
            goto error;
        }
        IDirect3DVertexBuffer9_AddRef(This->vertex_buffer);
        /* FIXME: refactor to avoid creating a new vertex buffer */
        IDirect3DVertexBuffer9_Release(cloned_this->vertex_buffer);
        cloned_this->vertex_buffer = This->vertex_buffer;
    } else if (same_declaration) {
        hr = iface->lpVtbl->LockVertexBuffer(iface, D3DLOCK_READONLY, &data_in);
        if (FAILED(hr)) goto error;
        hr = clone_mesh->lpVtbl->LockVertexBuffer(clone_mesh, 0, &data_out);
        if (FAILED(hr)) {
            iface->lpVtbl->UnlockVertexBuffer(iface);
            goto error;
        }
        memcpy(data_out, data_in, This->numvertices * vertex_size);
        clone_mesh->lpVtbl->UnlockVertexBuffer(clone_mesh);
        iface->lpVtbl->UnlockVertexBuffer(iface);
    } else {
        hr = convert_vertex_buffer(clone_mesh, iface);
        if (FAILED(hr)) goto error;
    }
 
    hr = iface->lpVtbl->LockIndexBuffer(iface, D3DLOCK_READONLY, &data_in);
    if (FAILED(hr)) goto error;
    hr = clone_mesh->lpVtbl->LockIndexBuffer(clone_mesh, 0, &data_out);
    if (FAILED(hr)) {
        iface->lpVtbl->UnlockIndexBuffer(iface);
        goto error;
    }
    if ((options ^ This->options) & D3DXMESH_32BIT) {
        DWORD i;
        if (options & D3DXMESH_32BIT) {
            for (i = 0; i < This->numfaces * 3; i++)
                ((DWORD*)data_out)[i] = ((WORD*)data_in)[i];
        } else {
            for (i = 0; i < This->numfaces * 3; i++)
                ((WORD*)data_out)[i] = ((DWORD*)data_in)[i];
        }
    } else {
        memcpy(data_out, data_in, This->numfaces * 3 * (options & D3DXMESH_32BIT ? 4 : 2));
    }
    clone_mesh->lpVtbl->UnlockIndexBuffer(clone_mesh);
    iface->lpVtbl->UnlockIndexBuffer(iface);
 
    memcpy(cloned_this->attrib_buffer, This->attrib_buffer, This->numfaces * sizeof(*This->attrib_buffer));
 
    if (This->attrib_table_size)
    {
        cloned_this->attrib_table_size = This->attrib_table_size;
        cloned_this->attrib_table = HeapAlloc(GetProcessHeap(), 0, This->attrib_table_size * sizeof(*This->attrib_table));
        if (!cloned_this->attrib_table) {
            hr = E_OUTOFMEMORY;
            goto error;
        }
        memcpy(cloned_this->attrib_table, This->attrib_table, This->attrib_table_size * sizeof(*This->attrib_table));
    }
 
    *clone_mesh_out = clone_mesh;
 
    return D3D_OK;
error:
    IUnknown_Release(clone_mesh);
    return hr;
}

d3dx9_mesh_CloneMeshFVF()

static HRESULT WINAPI d3dx9_mesh_CloneMeshFVF ( struct ID3DXMesh *  iface, DWORD  options, DWORD  fvf, struct IDirect3DDevice9 *  device, struct ID3DXMesh **  clone_mesh  )

static

Definition at line 269 of file mesh.c.

{
    HRESULT hr;
    D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE];
 
    TRACE("iface %p, options %#x, fvf %#x, device %p, clone_mesh %p.\n",
            iface, options, fvf, device, clone_mesh);
 
    if (FAILED(hr = D3DXDeclaratorFromFVF(fvf, declaration)))
        return hr;
 
    return iface->lpVtbl->CloneMesh(iface, options, declaration, device, clone_mesh);
}

d3dx9_mesh_ConvertAdjacencyToPointReps()

static HRESULT WINAPI d3dx9_mesh_ConvertAdjacencyToPointReps ( ID3DXMesh *  iface, const DWORD *  adjacency, DWORD *  point_reps  )

static

Definition at line 1103 of file mesh.c.

{
    struct d3dx9_mesh *This = impl_from_ID3DXMesh(iface);
    HRESULT hr;
    DWORD face;
    DWORD i;
    DWORD *indices = NULL;
    WORD *indices_16bit = NULL;
    DWORD *new_indices = NULL;
    const unsigned int VERTS_PER_FACE = 3;
 
    TRACE("iface %p, adjacency %p, point_reps %p.\n", iface, adjacency, point_reps);
 
    if (!adjacency)
    {
        WARN("NULL adjacency.\n");
        hr = D3DERR_INVALIDCALL;
        goto cleanup;
    }
 
    if (!point_reps)
    {
        WARN("NULL point_reps.\n");
        hr = D3DERR_INVALIDCALL;
        goto cleanup;
    }
 
    /* Should never happen as CreateMesh does not allow meshes with 0 faces */
    if (This->numfaces == 0)
    {
        ERR("Number of faces was zero.\n");
        hr = D3DERR_INVALIDCALL;
        goto cleanup;
    }
 
    new_indices = HeapAlloc(GetProcessHeap(), 0, VERTS_PER_FACE * This->numfaces * sizeof(*indices));
    if (!new_indices)
    {
        hr = E_OUTOFMEMORY;
        goto cleanup;
    }
 
    if (This->options & D3DXMESH_32BIT)
    {
        hr = iface->lpVtbl->LockIndexBuffer(iface, D3DLOCK_READONLY, (void**)&indices);
        if (FAILED(hr)) goto cleanup;
        memcpy(new_indices, indices, VERTS_PER_FACE * This->numfaces * sizeof(*indices));
    }
    else
    {
        /* Make a widening copy of indices_16bit into indices and new_indices
         * in order to re-use the helper function */
        hr = iface->lpVtbl->LockIndexBuffer(iface, D3DLOCK_READONLY, (void**)&indices_16bit);
        if (FAILED(hr)) goto cleanup;
        indices = HeapAlloc(GetProcessHeap(), 0, VERTS_PER_FACE * This->numfaces * sizeof(*indices));
        if (!indices)
        {
            hr = E_OUTOFMEMORY;
            goto cleanup;
        }
        for (i = 0; i < VERTS_PER_FACE * This->numfaces; i++)
        {
            new_indices[i] = indices_16bit[i];
            indices[i] = indices_16bit[i];
        }
    }
 
    /* Vertices are ordered sequentially in the point representation. */
    for (i = 0; i < This->numvertices; i++)
    {
        point_reps[i] = i;
    }
 
    /* Propagate vertices with low indices so as few vertices as possible
     * are used in the mesh.
     */
    for (face = 0; face < This->numfaces; face++)
    {
        hr = propagate_face_vertices(adjacency, point_reps, indices, new_indices, face, This->numfaces);
        if (FAILED(hr)) goto cleanup;
    }
    /* Go in opposite direction to catch all face orderings */
    for (face = 0; face < This->numfaces; face++)
    {
        hr = propagate_face_vertices(adjacency, point_reps,
                                     indices, new_indices,
                                     (This->numfaces - 1) - face, This->numfaces);
        if (FAILED(hr)) goto cleanup;
    }
 
    hr = D3D_OK;
cleanup:
    if (This->options & D3DXMESH_32BIT)
    {
        if (indices) iface->lpVtbl->UnlockIndexBuffer(iface);
    }
    else
    {
        if (indices_16bit) iface->lpVtbl->UnlockIndexBuffer(iface);
        HeapFree(GetProcessHeap(), 0, indices);
    }
    HeapFree(GetProcessHeap(), 0, new_indices);
    return hr;
}

d3dx9_mesh_ConvertPointRepsToAdjacency()

static HRESULT WINAPI d3dx9_mesh_ConvertPointRepsToAdjacency ( ID3DXMesh *  iface, const DWORD *  point_reps, DWORD *  adjacency  )

static

Definition at line 953 of file mesh.c.

{
    HRESULT hr;
    DWORD num_faces = iface->lpVtbl->GetNumFaces(iface);
    DWORD num_vertices = iface->lpVtbl->GetNumVertices(iface);
    DWORD options = iface->lpVtbl->GetOptions(iface);
    BOOL indices_are_16_bit = !(options & D3DXMESH_32BIT);
    DWORD *ib = NULL;
    void *ib_ptr = NULL;
    DWORD face;
    DWORD edge;
    struct edge_face_map edge_face_map = {0};
    const DWORD *point_reps_ptr = NULL;
    DWORD *id_point_reps = NULL;
 
    TRACE("iface %p, point_reps %p, adjacency %p.\n", iface, point_reps, adjacency);
 
    if (!adjacency) return D3DERR_INVALIDCALL;
 
    if (!point_reps) /* Identity point reps */
    {
        id_point_reps = generate_identity_point_reps(num_vertices);
        if (!id_point_reps)
        {
            hr = E_OUTOFMEMORY;
            goto cleanup;
        }
 
        point_reps_ptr = id_point_reps;
    }
    else
    {
        point_reps_ptr = point_reps;
    }
 
    hr = iface->lpVtbl->LockIndexBuffer(iface, D3DLOCK_READONLY, &ib_ptr);
    if (FAILED(hr)) goto cleanup;
 
    if (indices_are_16_bit)
    {
        /* Widen 16 bit to 32 bit */
        DWORD i;
        WORD *ib_16bit = ib_ptr;
        ib = HeapAlloc(GetProcessHeap(), 0, 3 * num_faces * sizeof(DWORD));
        if (!ib)
        {
            hr = E_OUTOFMEMORY;
            goto cleanup;
        }
        for (i = 0; i < 3 * num_faces; i++)
        {
            ib[i] = ib_16bit[i];
        }
    }
    else
    {
        ib = ib_ptr;
    }
 
    hr = init_edge_face_map(&edge_face_map, ib, point_reps_ptr, num_faces);
    if (FAILED(hr)) goto cleanup;
 
    /* Create adjacency */
    for (face = 0; face < num_faces; face++)
    {
        for (edge = 0; edge < 3; edge++)
        {
            DWORD v1 = ib[3*face + edge];
            DWORD v2 = ib[3*face + (edge+1)%3];
            DWORD new_v1 = point_reps_ptr[v1];
            DWORD new_v2 = point_reps_ptr[v2];
            DWORD adj_face;
 
            adj_face = find_adjacent_face(&edge_face_map, new_v1, new_v2, num_faces);
            adjacency[3*face + edge] = adj_face;
        }
    }
 
    hr = D3D_OK;
cleanup:
    HeapFree(GetProcessHeap(), 0, id_point_reps);
    if (indices_are_16_bit) HeapFree(GetProcessHeap(), 0, ib);
    HeapFree(GetProcessHeap(), 0, edge_face_map.lists);
    HeapFree(GetProcessHeap(), 0, edge_face_map.entries);
    if(ib_ptr) iface->lpVtbl->UnlockIndexBuffer(iface);
    return hr;
}

d3dx9_mesh_DrawSubset()

static HRESULT WINAPI d3dx9_mesh_DrawSubset ( ID3DXMesh *  iface, DWORD  attrib_id  )

static

Definition at line 143 of file mesh.c.

{
    struct d3dx9_mesh *This = impl_from_ID3DXMesh(iface);
    HRESULT hr;
    DWORD face_start;
    DWORD face_end = 0;
    DWORD vertex_size;
 
    TRACE("iface %p, attrib_id %u.\n", iface, attrib_id);
 
    if (!This->vertex_declaration)
    {
        WARN("Can't draw a mesh with an invalid vertex declaration.\n");
        return E_FAIL;
    }
 
    vertex_size = iface->lpVtbl->GetNumBytesPerVertex(iface);
 
    hr = IDirect3DDevice9_SetVertexDeclaration(This->device, This->vertex_declaration);
    if (FAILED(hr)) return hr;
    hr = IDirect3DDevice9_SetStreamSource(This->device, 0, This->vertex_buffer, 0, vertex_size);
    if (FAILED(hr)) return hr;
    hr = IDirect3DDevice9_SetIndices(This->device, This->index_buffer);
    if (FAILED(hr)) return hr;
 
    while (face_end < This->numfaces)
    {
        for (face_start = face_end; face_start < This->numfaces; face_start++)
        {
            if (This->attrib_buffer[face_start] == attrib_id)
                break;
        }
        if (face_start >= This->numfaces)
            break;
        for (face_end = face_start + 1; face_end < This->numfaces; face_end++)
        {
            if (This->attrib_buffer[face_end] != attrib_id)
                break;
        }
 
        hr = IDirect3DDevice9_DrawIndexedPrimitive(This->device, D3DPT_TRIANGLELIST,
                0, 0, This->numvertices, face_start * 3, face_end - face_start);
        if (FAILED(hr)) return hr;
    }
 
    return D3D_OK;
}

d3dx9_mesh_GenerateAdjacency()

static HRESULT WINAPI d3dx9_mesh_GenerateAdjacency ( ID3DXMesh *  iface, float  epsilon, DWORD *  adjacency  )

static

Definition at line 1224 of file mesh.c.

{
    struct d3dx9_mesh *This = impl_from_ID3DXMesh(iface);
    HRESULT hr;
    BYTE *vertices = NULL;
    const DWORD *indices = NULL;
    DWORD vertex_size;
    DWORD buffer_size;
    /* sort the vertices by (x + y + z) to quickly find coincident vertices */
    struct vertex_metadata *sorted_vertices;
    /* shared_indices links together identical indices in the index buffer so
     * that adjacency checks can be limited to faces sharing a vertex */
    DWORD *shared_indices = NULL;
    const FLOAT epsilon_sq = epsilon * epsilon;
    DWORD i;
 
    TRACE("iface %p, epsilon %.8e, adjacency %p.\n", iface, epsilon, adjacency);
 
    if (!adjacency)
        return D3DERR_INVALIDCALL;
 
    buffer_size = This->numfaces * 3 * sizeof(*shared_indices) + This->numvertices * sizeof(*sorted_vertices);
    if (!(This->options & D3DXMESH_32BIT))
        buffer_size += This->numfaces * 3 * sizeof(*indices);
    shared_indices = HeapAlloc(GetProcessHeap(), 0, buffer_size);
    if (!shared_indices)
        return E_OUTOFMEMORY;
    sorted_vertices = (struct vertex_metadata*)(shared_indices + This->numfaces * 3);
 
    hr = iface->lpVtbl->LockVertexBuffer(iface, D3DLOCK_READONLY, (void**)&vertices);
    if (FAILED(hr)) goto cleanup;
    hr = iface->lpVtbl->LockIndexBuffer(iface, D3DLOCK_READONLY, (void**)&indices);
    if (FAILED(hr)) goto cleanup;
 
    if (!(This->options & D3DXMESH_32BIT)) {
        const WORD *word_indices = (const WORD*)indices;
        DWORD *dword_indices = (DWORD*)(sorted_vertices + This->numvertices);
        indices = dword_indices;
        for (i = 0; i < This->numfaces * 3; i++)
            *dword_indices++ = *word_indices++;
    }
 
    vertex_size = iface->lpVtbl->GetNumBytesPerVertex(iface);
    for (i = 0; i < This->numvertices; i++) {
        D3DXVECTOR3 *vertex = (D3DXVECTOR3*)(vertices + vertex_size * i);
        sorted_vertices[i].first_shared_index = -1;
        sorted_vertices[i].key = vertex->x + vertex->y + vertex->z;
        sorted_vertices[i].vertex_index = i;
    }
    for (i = 0; i < This->numfaces * 3; i++) {
        DWORD *first_shared_index = &sorted_vertices[indices[i]].first_shared_index;
        shared_indices[i] = *first_shared_index;
        *first_shared_index = i;
        adjacency[i] = -1;
    }
    qsort(sorted_vertices, This->numvertices, sizeof(*sorted_vertices), compare_vertex_keys);
 
    for (i = 0; i < This->numvertices; i++) {
        struct vertex_metadata *sorted_vertex_a = &sorted_vertices[i];
        D3DXVECTOR3 *vertex_a = (D3DXVECTOR3*)(vertices + sorted_vertex_a->vertex_index * vertex_size);
        DWORD shared_index_a = sorted_vertex_a->first_shared_index;
 
        while (shared_index_a != -1) {
            DWORD j = i;
            DWORD shared_index_b = shared_indices[shared_index_a];
            struct vertex_metadata *sorted_vertex_b = sorted_vertex_a;
 
            while (TRUE) {
                while (shared_index_b != -1) {
                    /* faces are adjacent if they have another coincident vertex */
                    DWORD base_a = (shared_index_a / 3) * 3;
                    DWORD base_b = (shared_index_b / 3) * 3;
                    BOOL adjacent = FALSE;
                    int k;
 
                    for (k = 0; k < 3; k++) {
                        if (adjacency[base_b + k] == shared_index_a / 3) {
                            adjacent = TRUE;
                            break;
                        }
                    }
                    if (!adjacent) {
                        for (k = 1; k <= 2; k++) {
                            DWORD vertex_index_a = base_a + (shared_index_a + k) % 3;
                            DWORD vertex_index_b = base_b + (shared_index_b + (3 - k)) % 3;
                            adjacent = indices[vertex_index_a] == indices[vertex_index_b];
                            if (!adjacent && epsilon >= 0.0f) {
                                D3DXVECTOR3 delta = {0.0f, 0.0f, 0.0f};
                                FLOAT length_sq;
 
                                D3DXVec3Subtract(&delta,
                                                 (D3DXVECTOR3*)(vertices + indices[vertex_index_a] * vertex_size),
                                                 (D3DXVECTOR3*)(vertices + indices[vertex_index_b] * vertex_size));
                                length_sq = D3DXVec3LengthSq(&delta);
                                adjacent = epsilon == 0.0f ? length_sq == 0.0f : length_sq < epsilon_sq;
                            }
                            if (adjacent) {
                                DWORD adj_a = base_a + 2 - (vertex_index_a + shared_index_a + 1) % 3;
                                DWORD adj_b = base_b + 2 - (vertex_index_b + shared_index_b + 1) % 3;
                                if (adjacency[adj_a] == -1 && adjacency[adj_b] == -1) {
                                    adjacency[adj_a] = base_b / 3;
                                    adjacency[adj_b] = base_a / 3;
                                    break;
                                }
                            }
                        }
                    }
 
                    shared_index_b = shared_indices[shared_index_b];
                }
                while (++j < This->numvertices) {
                    D3DXVECTOR3 *vertex_b;
 
                    sorted_vertex_b++;
                    if (sorted_vertex_b->key - sorted_vertex_a->key > epsilon * 3.0f) {
                        /* no more coincident vertices to try */
                        j = This->numvertices;
                        break;
                    }
                    /* check for coincidence */
                    vertex_b = (D3DXVECTOR3*)(vertices + sorted_vertex_b->vertex_index * vertex_size);
                    if (fabsf(vertex_a->x - vertex_b->x) <= epsilon &&
                        fabsf(vertex_a->y - vertex_b->y) <= epsilon &&
                        fabsf(vertex_a->z - vertex_b->z) <= epsilon)
                    {
                        break;
                    }
                }
                if (j >= This->numvertices)
                    break;
                shared_index_b = sorted_vertex_b->first_shared_index;
            }
 
            sorted_vertex_a->first_shared_index = shared_indices[sorted_vertex_a->first_shared_index];
            shared_index_a = sorted_vertex_a->first_shared_index;
        }
    }
 
    hr = D3D_OK;
cleanup:
    if (indices) iface->lpVtbl->UnlockIndexBuffer(iface);
    if (vertices) iface->lpVtbl->UnlockVertexBuffer(iface);
    HeapFree(GetProcessHeap(), 0, shared_indices);
    return hr;
}

d3dx9_mesh_GetAttributeTable()

static HRESULT WINAPI d3dx9_mesh_GetAttributeTable ( ID3DXMesh *  iface, D3DXATTRIBUTERANGE *  attrib_table, DWORD *  attrib_table_size  )

static

Definition at line 842 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
 
    TRACE("iface %p, attrib_table %p, attrib_table_size %p.\n",
            iface, attrib_table, attrib_table_size);
 
    if (attrib_table_size)
        *attrib_table_size = mesh->attrib_table_size;
 
    if (attrib_table)
        memcpy(attrib_table, mesh->attrib_table, mesh->attrib_table_size * sizeof(*attrib_table));
 
    return D3D_OK;
}

d3dx9_mesh_GetDeclaration()

static HRESULT WINAPI d3dx9_mesh_GetDeclaration ( ID3DXMesh *  iface, D3DVERTEXELEMENT9  declaration[MAX_FVF_DECL_SIZE]  )

static

Definition at line 223 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
 
    TRACE("iface %p, declaration %p.\n", iface, declaration);
 
    if (!declaration)
        return D3DERR_INVALIDCALL;
 
    copy_declaration(declaration, mesh->cached_declaration, mesh->num_elem);
 
    return D3D_OK;
}

d3dx9_mesh_GetDevice()

static HRESULT WINAPI d3dx9_mesh_GetDevice ( struct ID3DXMesh *  iface, struct IDirect3DDevice9 **  device  )

static

Definition at line 255 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
 
    TRACE("iface %p, device %p.\n", iface, device);
 
    if (!device)
        return D3DERR_INVALIDCALL;
    *device = mesh->device;
    IDirect3DDevice9_AddRef(mesh->device);
 
    return D3D_OK;
}

d3dx9_mesh_GetFVF()

static DWORD WINAPI d3dx9_mesh_GetFVF ( ID3DXMesh *  iface )

static

Definition at line 209 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
 
    TRACE("iface %p.\n", iface);
 
    return mesh->fvf;
}

d3dx9_mesh_GetIndexBuffer()

static HRESULT WINAPI d3dx9_mesh_GetIndexBuffer ( struct ID3DXMesh *  iface, struct IDirect3DIndexBuffer9 **  index_buffer  )

static

Definition at line 789 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
 
    TRACE("iface %p, index_buffer %p.\n", iface, index_buffer);
 
    if (!index_buffer)
        return D3DERR_INVALIDCALL;
    *index_buffer = mesh->index_buffer;
    IDirect3DIndexBuffer9_AddRef(mesh->index_buffer);
 
    return D3D_OK;
}

d3dx9_mesh_GetNumBytesPerVertex()

static DWORD WINAPI d3dx9_mesh_GetNumBytesPerVertex ( ID3DXMesh *  iface )

static

Definition at line 237 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
 
    TRACE("iface %p.\n", iface);
 
    return mesh->vertex_declaration_size;
}

d3dx9_mesh_GetNumFaces()

static DWORD WINAPI d3dx9_mesh_GetNumFaces ( ID3DXMesh *  iface )

static

Definition at line 191 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
 
    TRACE("iface %p.\n", iface);
 
    return mesh->numfaces;
}

d3dx9_mesh_GetNumVertices()

static DWORD WINAPI d3dx9_mesh_GetNumVertices ( ID3DXMesh *  iface )

static

Definition at line 200 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
 
    TRACE("iface %p.\n", iface);
 
    return mesh->numvertices;
}

d3dx9_mesh_GetOptions()

static DWORD WINAPI d3dx9_mesh_GetOptions ( ID3DXMesh *  iface )

static

Definition at line 246 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
 
    TRACE("iface %p.\n", iface);
 
    return mesh->options;
}

d3dx9_mesh_GetVertexBuffer()

static HRESULT WINAPI d3dx9_mesh_GetVertexBuffer ( struct ID3DXMesh *  iface, struct IDirect3DVertexBuffer9 **  vertex_buffer  )

static

Definition at line 774 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
 
    TRACE("iface %p, vertex_buffer %p.\n", iface, vertex_buffer);
 
    if (!vertex_buffer)
        return D3DERR_INVALIDCALL;
    *vertex_buffer = mesh->vertex_buffer;
    IDirect3DVertexBuffer9_AddRef(mesh->vertex_buffer);
 
    return D3D_OK;
}

d3dx9_mesh_LockAttributeBuffer()

static HRESULT WINAPI d3dx9_mesh_LockAttributeBuffer ( ID3DXMesh *  iface, DWORD  flags, DWORD **  data  )

static

Definition at line 1429 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
 
    TRACE("iface %p, flags %#x, data %p.\n", iface, flags, data);
 
    InterlockedIncrement(&mesh->attrib_buffer_lock_count);
 
    if (!(flags & D3DLOCK_READONLY))
    {
        D3DXATTRIBUTERANGE *attrib_table = mesh->attrib_table;
        mesh->attrib_table_size = 0;
        mesh->attrib_table = NULL;
        HeapFree(GetProcessHeap(), 0, attrib_table);
    }
 
    *data = mesh->attrib_buffer;
 
    return D3D_OK;
}

d3dx9_mesh_LockIndexBuffer()

static HRESULT WINAPI d3dx9_mesh_LockIndexBuffer ( ID3DXMesh *  iface, DWORD  flags, void **  data  )

static

Definition at line 822 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
 
    TRACE("iface %p, flags %#x, data %p.\n", iface, flags, data);
 
    return IDirect3DIndexBuffer9_Lock(mesh->index_buffer, 0, 0, data, flags);
}

d3dx9_mesh_LockVertexBuffer()

static HRESULT WINAPI d3dx9_mesh_LockVertexBuffer ( ID3DXMesh *  iface, DWORD  flags, void **  data  )

static

Definition at line 804 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
 
    TRACE("iface %p, flags %#x, data %p.\n", iface, flags, data);
 
    return IDirect3DVertexBuffer9_Lock(mesh->vertex_buffer, 0, 0, data, flags);
}

d3dx9_mesh_Optimize()

static HRESULT WINAPI d3dx9_mesh_Optimize ( ID3DXMesh *  iface, DWORD  flags, const DWORD *  adjacency_in, DWORD *  adjacency_out, DWORD *  face_remap, ID3DXBuffer **  vertex_remap, ID3DXMesh **  opt_mesh  )

static

Definition at line 1467 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
    HRESULT hr;
    D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE] = { D3DDECL_END() };
    ID3DXMesh *optimized_mesh;
 
    TRACE("iface %p, flags %#x, adjacency_in %p, adjacency_out %p, face_remap %p, vertex_remap %p, opt_mesh %p.\n",
            iface, flags, adjacency_in, adjacency_out, face_remap, vertex_remap, opt_mesh);
 
    if (!opt_mesh)
        return D3DERR_INVALIDCALL;
 
    hr = iface->lpVtbl->GetDeclaration(iface, declaration);
    if (FAILED(hr)) return hr;
 
    if (FAILED(hr = iface->lpVtbl->CloneMesh(iface, mesh->options, declaration, mesh->device, &optimized_mesh)))
        return hr;
 
    hr = optimized_mesh->lpVtbl->OptimizeInplace(optimized_mesh, flags, adjacency_in, adjacency_out, face_remap, vertex_remap);
    if (SUCCEEDED(hr))
        *opt_mesh = optimized_mesh;
    else
        IUnknown_Release(optimized_mesh);
    return hr;
}

d3dx9_mesh_OptimizeInplace()

static HRESULT WINAPI d3dx9_mesh_OptimizeInplace ( ID3DXMesh *  iface, DWORD  flags, const DWORD *  adjacency_in, DWORD *  adjacency_out, DWORD *  face_remap_out, ID3DXBuffer **  vertex_remap_out  )

static

Definition at line 1642 of file mesh.c.

{
    struct d3dx9_mesh *This = impl_from_ID3DXMesh(iface);
    void *indices = NULL;
    DWORD *attrib_buffer = NULL;
    HRESULT hr;
    ID3DXBuffer *vertex_remap = NULL;
    DWORD *face_remap = NULL; /* old -> new mapping */
    DWORD *dword_indices = NULL;
    DWORD new_num_vertices = 0;
    DWORD new_num_alloc_vertices = 0;
    IDirect3DVertexBuffer9 *vertex_buffer = NULL;
    DWORD *sorted_attrib_buffer = NULL;
    DWORD i;
 
    TRACE("iface %p, flags %#x, adjacency_in %p, adjacency_out %p, face_remap_out %p, vertex_remap_out %p.\n",
            iface, flags, adjacency_in, adjacency_out, face_remap_out, vertex_remap_out);
 
    if (!flags)
        return D3DERR_INVALIDCALL;
    if (!adjacency_in && (flags & (D3DXMESHOPT_VERTEXCACHE | D3DXMESHOPT_STRIPREORDER)))
        return D3DERR_INVALIDCALL;
    if ((flags & (D3DXMESHOPT_VERTEXCACHE | D3DXMESHOPT_STRIPREORDER)) == (D3DXMESHOPT_VERTEXCACHE | D3DXMESHOPT_STRIPREORDER))
        return D3DERR_INVALIDCALL;
 
    if (flags & (D3DXMESHOPT_VERTEXCACHE | D3DXMESHOPT_STRIPREORDER))
    {
        if (flags & D3DXMESHOPT_VERTEXCACHE)
            FIXME("D3DXMESHOPT_VERTEXCACHE not implemented.\n");
        if (flags & D3DXMESHOPT_STRIPREORDER)
            FIXME("D3DXMESHOPT_STRIPREORDER not implemented.\n");
        return E_NOTIMPL;
    }
 
    hr = iface->lpVtbl->LockIndexBuffer(iface, 0, &indices);
    if (FAILED(hr)) goto cleanup;
 
    dword_indices = HeapAlloc(GetProcessHeap(), 0, This->numfaces * 3 * sizeof(DWORD));
    if (!dword_indices) return E_OUTOFMEMORY;
    if (This->options & D3DXMESH_32BIT) {
        memcpy(dword_indices, indices, This->numfaces * 3 * sizeof(DWORD));
    } else {
        WORD *word_indices = indices;
        for (i = 0; i < This->numfaces * 3; i++)
            dword_indices[i] = *word_indices++;
    }
 
    if ((flags & (D3DXMESHOPT_COMPACT | D3DXMESHOPT_IGNOREVERTS | D3DXMESHOPT_ATTRSORT)) == D3DXMESHOPT_COMPACT)
    {
        new_num_alloc_vertices = This->numvertices;
        hr = compact_mesh(This, dword_indices, &new_num_vertices, &vertex_remap);
        if (FAILED(hr)) goto cleanup;
    } else if (flags & D3DXMESHOPT_ATTRSORT) {
        if (!(flags & D3DXMESHOPT_IGNOREVERTS))
            FIXME("D3DXMESHOPT_ATTRSORT vertex reordering not implemented.\n");
 
        hr = iface->lpVtbl->LockAttributeBuffer(iface, 0, &attrib_buffer);
        if (FAILED(hr)) goto cleanup;
 
        hr = remap_faces_for_attrsort(This, dword_indices, attrib_buffer, &sorted_attrib_buffer, &face_remap);
        if (FAILED(hr)) goto cleanup;
    }
 
    if (vertex_remap)
    {
        /* reorder the vertices using vertex_remap */
        D3DVERTEXBUFFER_DESC vertex_desc;
        DWORD *vertex_remap_ptr = ID3DXBuffer_GetBufferPointer(vertex_remap);
        DWORD vertex_size = iface->lpVtbl->GetNumBytesPerVertex(iface);
        BYTE *orig_vertices;
        BYTE *new_vertices;
 
        hr = IDirect3DVertexBuffer9_GetDesc(This->vertex_buffer, &vertex_desc);
        if (FAILED(hr)) goto cleanup;
 
        hr = IDirect3DDevice9_CreateVertexBuffer(This->device, new_num_alloc_vertices * vertex_size,
                vertex_desc.Usage, This->fvf, vertex_desc.Pool, &vertex_buffer, NULL);
        if (FAILED(hr)) goto cleanup;
 
        hr = IDirect3DVertexBuffer9_Lock(This->vertex_buffer, 0, 0, (void**)&orig_vertices, D3DLOCK_READONLY);
        if (FAILED(hr)) goto cleanup;
 
        hr = IDirect3DVertexBuffer9_Lock(vertex_buffer, 0, 0, (void**)&new_vertices, 0);
        if (FAILED(hr)) {
            IDirect3DVertexBuffer9_Unlock(This->vertex_buffer);
            goto cleanup;
        }
 
        for (i = 0; i < new_num_vertices; i++)
            memcpy(new_vertices + i * vertex_size, orig_vertices + vertex_remap_ptr[i] * vertex_size, vertex_size);
 
        IDirect3DVertexBuffer9_Unlock(This->vertex_buffer);
        IDirect3DVertexBuffer9_Unlock(vertex_buffer);
    } else if (vertex_remap_out) {
        DWORD *vertex_remap_ptr;
 
        hr = D3DXCreateBuffer(This->numvertices * sizeof(DWORD), &vertex_remap);
        if (FAILED(hr)) goto cleanup;
        vertex_remap_ptr = ID3DXBuffer_GetBufferPointer(vertex_remap);
        for (i = 0; i < This->numvertices; i++)
            *vertex_remap_ptr++ = i;
    }
 
    if (flags & D3DXMESHOPT_ATTRSORT)
    {
        D3DXATTRIBUTERANGE *attrib_table;
        DWORD attrib_table_size;
 
        attrib_table_size = count_attributes(sorted_attrib_buffer, This->numfaces);
        attrib_table = HeapAlloc(GetProcessHeap(), 0, attrib_table_size * sizeof(*attrib_table));
        if (!attrib_table) {
            hr = E_OUTOFMEMORY;
            goto cleanup;
        }
 
        memcpy(attrib_buffer, sorted_attrib_buffer, This->numfaces * sizeof(*attrib_buffer));
 
        /* reorder the indices using face_remap */
        if (This->options & D3DXMESH_32BIT) {
            for (i = 0; i < This->numfaces; i++)
                memcpy((DWORD*)indices + face_remap[i] * 3, dword_indices + i * 3, 3 * sizeof(DWORD));
        } else {
            WORD *word_indices = indices;
            for (i = 0; i < This->numfaces; i++) {
                DWORD new_pos = face_remap[i] * 3;
                DWORD old_pos = i * 3;
                word_indices[new_pos++] = dword_indices[old_pos++];
                word_indices[new_pos++] = dword_indices[old_pos++];
                word_indices[new_pos] = dword_indices[old_pos];
            }
        }
 
        fill_attribute_table(attrib_buffer, This->numfaces, indices,
                             This->options & D3DXMESH_32BIT, attrib_table);
 
        HeapFree(GetProcessHeap(), 0, This->attrib_table);
        This->attrib_table = attrib_table;
        This->attrib_table_size = attrib_table_size;
    } else {
        if (This->options & D3DXMESH_32BIT) {
            memcpy(indices, dword_indices, This->numfaces * 3 * sizeof(DWORD));
        } else {
            WORD *word_indices = indices;
            for (i = 0; i < This->numfaces * 3; i++)
                *word_indices++ = dword_indices[i];
        }
    }
 
    if (adjacency_out) {
        if (face_remap) {
            for (i = 0; i < This->numfaces; i++) {
                DWORD old_pos = i * 3;
                DWORD new_pos = face_remap[i] * 3;
                adjacency_out[new_pos++] = face_remap[adjacency_in[old_pos++]];
                adjacency_out[new_pos++] = face_remap[adjacency_in[old_pos++]];
                adjacency_out[new_pos++] = face_remap[adjacency_in[old_pos++]];
            }
        } else {
            memcpy(adjacency_out, adjacency_in, This->numfaces * 3 * sizeof(*adjacency_out));
        }
    }
    if (face_remap_out) {
        if (face_remap) {
            for (i = 0; i < This->numfaces; i++)
                face_remap_out[face_remap[i]] = i;
        } else {
            for (i = 0; i < This->numfaces; i++)
                face_remap_out[i] = i;
        }
    }
    if (vertex_remap_out)
        *vertex_remap_out = vertex_remap;
    vertex_remap = NULL;
 
    if (vertex_buffer) {
        IDirect3DVertexBuffer9_Release(This->vertex_buffer);
        This->vertex_buffer = vertex_buffer;
        vertex_buffer = NULL;
        This->numvertices = new_num_vertices;
    }
 
    hr = D3D_OK;
cleanup:
    HeapFree(GetProcessHeap(), 0, sorted_attrib_buffer);
    HeapFree(GetProcessHeap(), 0, face_remap);
    HeapFree(GetProcessHeap(), 0, dword_indices);
    if (vertex_remap) ID3DXBuffer_Release(vertex_remap);
    if (vertex_buffer) IDirect3DVertexBuffer9_Release(vertex_buffer);
    if (attrib_buffer) iface->lpVtbl->UnlockAttributeBuffer(iface);
    if (indices) iface->lpVtbl->UnlockIndexBuffer(iface);
    return hr;
}

d3dx9_mesh_QueryInterface()

static HRESULT WINAPI d3dx9_mesh_QueryInterface ( ID3DXMesh *  iface, REFIID  riid, void **  out  )

static

Definition at line 93 of file mesh.c.

{
    TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 
    if (IsEqualGUID(riid, &IID_IUnknown) ||
        IsEqualGUID(riid, &IID_ID3DXBaseMesh) ||
        IsEqualGUID(riid, &IID_ID3DXMesh))
    {
        iface->lpVtbl->AddRef(iface);
        *out = iface;
        return S_OK;
    }
 
    WARN("Interface %s not found.\n", debugstr_guid(riid));
 
    return E_NOINTERFACE;
}

d3dx9_mesh_Release()

static ULONG WINAPI d3dx9_mesh_Release ( ID3DXMesh *  iface )

static

Definition at line 121 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
    ULONG refcount = InterlockedDecrement(&mesh->ref);
 
    TRACE("%p decreasing refcount to %u.\n", mesh, refcount);
 
    if (!refcount)
    {
        IDirect3DIndexBuffer9_Release(mesh->index_buffer);
        IDirect3DVertexBuffer9_Release(mesh->vertex_buffer);
        if (mesh->vertex_declaration)
            IDirect3DVertexDeclaration9_Release(mesh->vertex_declaration);
        IDirect3DDevice9_Release(mesh->device);
        HeapFree(GetProcessHeap(), 0, mesh->attrib_buffer);
        HeapFree(GetProcessHeap(), 0, mesh->attrib_table);
        HeapFree(GetProcessHeap(), 0, mesh);
    }
 
    return refcount;
}

d3dx9_mesh_SetAttributeTable()

static HRESULT WINAPI d3dx9_mesh_SetAttributeTable ( ID3DXMesh *  iface, const D3DXATTRIBUTERANGE *  attrib_table, DWORD  attrib_table_size  )

static

Definition at line 1836 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
    D3DXATTRIBUTERANGE *new_table = NULL;
 
    TRACE("iface %p, attrib_table %p, attrib_table_size %u.\n", iface, attrib_table, attrib_table_size);
 
    if (attrib_table_size) {
        size_t size = attrib_table_size * sizeof(*attrib_table);
 
        new_table = HeapAlloc(GetProcessHeap(), 0, size);
        if (!new_table)
            return E_OUTOFMEMORY;
 
        CopyMemory(new_table, attrib_table, size);
    } else if (attrib_table) {
        return D3DERR_INVALIDCALL;
    }
    HeapFree(GetProcessHeap(), 0, mesh->attrib_table);
    mesh->attrib_table = new_table;
    mesh->attrib_table_size = attrib_table_size;
 
    return D3D_OK;
}

d3dx9_mesh_UnlockAttributeBuffer()

static HRESULT WINAPI d3dx9_mesh_UnlockAttributeBuffer ( ID3DXMesh *  iface )

static

Definition at line 1450 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
    int lock_count;
 
    TRACE("iface %p.\n", iface);
 
    lock_count = InterlockedDecrement(&mesh->attrib_buffer_lock_count);
    if (lock_count < 0)
    {
        InterlockedIncrement(&mesh->attrib_buffer_lock_count);
        return D3DERR_INVALIDCALL;
    }
 
    return D3D_OK;
}

d3dx9_mesh_UnlockIndexBuffer()

static HRESULT WINAPI d3dx9_mesh_UnlockIndexBuffer ( ID3DXMesh *  iface )

static

Definition at line 831 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
 
    TRACE("iface %p.\n", iface);
 
    return IDirect3DIndexBuffer9_Unlock(mesh->index_buffer);
}

d3dx9_mesh_UnlockVertexBuffer()

static HRESULT WINAPI d3dx9_mesh_UnlockVertexBuffer ( ID3DXMesh *  iface )

static

Definition at line 813 of file mesh.c.

{
    struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
 
    TRACE("iface %p.\n", iface);
 
    return IDirect3DVertexBuffer9_Unlock(mesh->vertex_buffer);
}

d3dx9_mesh_UpdateSemantics()

static HRESULT WINAPI d3dx9_mesh_UpdateSemantics ( ID3DXMesh *  iface, D3DVERTEXELEMENT9  declaration[MAX_FVF_DECL_SIZE]  )

static

Definition at line 1370 of file mesh.c.

{
    struct d3dx9_mesh *This = impl_from_ID3DXMesh(iface);
    HRESULT hr;
    UINT vertex_declaration_size;
    int i;
 
    TRACE("iface %p, declaration %p.\n", iface, declaration);
 
    if (!declaration)
    {
        WARN("Invalid declaration. Can't use NULL declaration.\n");
        return D3DERR_INVALIDCALL;
    }
 
    /* New declaration must be same size as original */
    vertex_declaration_size = D3DXGetDeclVertexSize(declaration, declaration[0].Stream);
    if (vertex_declaration_size != This->vertex_declaration_size)
    {
        WARN("Invalid declaration. New vertex size does not match the original vertex size.\n");
        return D3DERR_INVALIDCALL;
    }
 
    /* New declaration must not contain non-zero Stream value  */
    for (i = 0; declaration[i].Stream != 0xff; i++)
    {
        if (declaration[i].Stream != 0)
        {
            WARN("Invalid declaration. New declaration contains non-zero Stream value.\n");
            return D3DERR_INVALIDCALL;
        }
    }
 
    This->num_elem = i + 1;
    copy_declaration(This->cached_declaration, declaration, This->num_elem);
 
    if (This->vertex_declaration)
        IDirect3DVertexDeclaration9_Release(This->vertex_declaration);
 
    /* An application can pass an invalid declaration to UpdateSemantics and
     * still expect D3D_OK (see tests). If the declaration is invalid, then
     * subsequent calls to DrawSubset will fail. This is handled by setting the
     * vertex declaration to NULL.
     *     GetDeclaration, GetNumBytesPerVertex must, however, use the new
     * invalid declaration. This is handled by them using the cached vertex
     * declaration instead of the actual vertex declaration.
     */
    hr = IDirect3DDevice9_CreateVertexDeclaration(This->device,
                                                  declaration,
                                                  &This->vertex_declaration);
    if (FAILED(hr))
    {
        WARN("Using invalid declaration. Calls to DrawSubset will fail.\n");
        This->vertex_declaration = NULL;
    }
 
    return D3D_OK;
}

D3DXBoxBoundProbe()

BOOL WINAPI D3DXBoxBoundProbe	(	const D3DXVECTOR3 *	pmin,
		const D3DXVECTOR3 *	pmax,
		const D3DXVECTOR3 *	prayposition,
		const D3DXVECTOR3 *	praydirection
	)

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_and_warnings
	)

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 *	pfirstposition,
		DWORD	numvertices,
		DWORD	dwstride,
		D3DXVECTOR3 *	pmin,
		D3DXVECTOR3 *	pmax
	)

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 *	pfirstposition,
		DWORD	numvertices,
		DWORD	dwstride,
		D3DXVECTOR3 *	pcenter,
		float *	pradius
	)

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().

D3DXComputeNormals()

HRESULT WINAPI D3DXComputeNormals	(	struct 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_idx,
		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,
		DWORD	texture_in_semantic,
		DWORD	texture_in_index,
		DWORD	u_partial_out_semantic,
		DWORD	u_partial_out_index,
		DWORD	v_partial_out_semantic,
		DWORD	v_partial_out_index,
		DWORD	normal_out_semantic,
		DWORD	normal_out_index,
		DWORD	options,
		const DWORD *	adjacency,
		float	partial_edge_threshold,
		float	singular_point_threshold,
		float	normal_edge_threshold,
		ID3DXMesh **	mesh_out,
		ID3DXBuffer **	vertex_mapping
	)

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().

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;
}

D3DXCreateBox()

HRESULT WINAPI D3DXCreateBox	(	struct IDirect3DDevice9 *	device,
		float	width,
		float	height,
		float	depth,
		struct ID3DXMesh **	mesh,
		struct ID3DXBuffer **	adjacency
	)

Definition at line 4653 of file mesh.c.

{
    HRESULT hr;
    ID3DXMesh *box;
    struct vertex *vertices;
    WORD (*faces)[3];
    DWORD *adjacency_buf;
    unsigned int i, face;
    static const D3DXVECTOR3 unit_box[] =
    {
        {-0.5f, -0.5f, -0.5f}, {-0.5f, -0.5f,  0.5f}, {-0.5f,  0.5f,  0.5f}, {-0.5f,  0.5f, -0.5f},
        {-0.5f,  0.5f, -0.5f}, {-0.5f,  0.5f,  0.5f}, { 0.5f,  0.5f,  0.5f}, { 0.5f,  0.5f, -0.5f},
        { 0.5f,  0.5f, -0.5f}, { 0.5f,  0.5f,  0.5f}, { 0.5f, -0.5f,  0.5f}, { 0.5f, -0.5f, -0.5f},
        {-0.5f, -0.5f,  0.5f}, {-0.5f, -0.5f, -0.5f}, { 0.5f, -0.5f, -0.5f}, { 0.5f, -0.5f,  0.5f},
        {-0.5f, -0.5f,  0.5f}, { 0.5f, -0.5f,  0.5f}, { 0.5f,  0.5f,  0.5f}, {-0.5f,  0.5f,  0.5f},
        {-0.5f, -0.5f, -0.5f}, {-0.5f,  0.5f, -0.5f}, { 0.5f,  0.5f, -0.5f}, { 0.5f, -0.5f, -0.5f}
    };
    static const D3DXVECTOR3 normals[] =
    {
        {-1.0f,  0.0f, 0.0f}, { 0.0f, 1.0f, 0.0f}, { 1.0f, 0.0f,  0.0f},
        { 0.0f, -1.0f, 0.0f}, { 0.0f, 0.0f, 1.0f}, { 0.0f, 0.0f, -1.0f}
    };
    static const DWORD adjacency_table[] =
    {
        6, 9, 1, 2, 10, 0, 1,  9,  3, 4, 10,  2,
        3, 8, 5, 7, 11, 4, 0, 11,  7, 5,  8,  6,
        7, 4, 9, 2,  0, 8, 1,  3, 11, 5,  6, 10
    };
 
    TRACE("device %p, width %f, height %f, depth %f, mesh %p, adjacency %p\n",
                    device, width, height, depth, mesh, adjacency);
 
    if (!device || width < 0.0f || height < 0.0f || depth < 0.0f || !mesh)
    {
        return D3DERR_INVALIDCALL;
    }
 
    if (FAILED(hr = D3DXCreateMeshFVF(12, 24, D3DXMESH_MANAGED, D3DFVF_XYZ | D3DFVF_NORMAL, device, &box)))
    {
        return hr;
    }
 
    if (FAILED(hr = box->lpVtbl->LockVertexBuffer(box, 0, (void **)&vertices)))
    {
        box->lpVtbl->Release(box);
        return hr;
    }
 
    if (FAILED(hr = box->lpVtbl->LockIndexBuffer(box, 0, (void **)&faces)))
    {
        box->lpVtbl->UnlockVertexBuffer(box);
        box->lpVtbl->Release(box);
        return hr;
    }
 
    for (i = 0; i < 24; i++)
    {
        vertices[i].position.x = width * unit_box[i].x;
        vertices[i].position.y = height * unit_box[i].y;
        vertices[i].position.z = depth * unit_box[i].z;
        vertices[i].normal.x = normals[i / 4].x;
        vertices[i].normal.y = normals[i / 4].y;
        vertices[i].normal.z = normals[i / 4].z;
    }
 
    face = 0;
    for (i = 0; i < 12; i++)
    {
        faces[i][0] = face++;
        faces[i][1] = face++;
        faces[i][2] = (i % 2) ? face - 4 : face;
    }
 
    box->lpVtbl->UnlockIndexBuffer(box);
    box->lpVtbl->UnlockVertexBuffer(box);
 
    if (adjacency)
    {
        if (FAILED(hr = D3DXCreateBuffer(sizeof(adjacency_table), adjacency)))
        {
            box->lpVtbl->Release(box);
            return hr;
        }
 
        adjacency_buf = ID3DXBuffer_GetBufferPointer(*adjacency);
        memcpy(adjacency_buf, adjacency_table, sizeof(adjacency_table));
    }
 
    *mesh = box;
 
    return D3D_OK;
}

Referenced by D3DXCreateBoxTest(), test_box(), and test_compute_normals().

D3DXCreateCylinder()

HRESULT WINAPI D3DXCreateCylinder	(	struct IDirect3DDevice9 *	device,
		float	radius1,
		float	radius2,
		float	length,
		UINT	slices,
		UINT	stacks,
		struct ID3DXMesh **	mesh,
		struct ID3DXBuffer **	adjacency
	)

Definition at line 4975 of file mesh.c.

{
    DWORD number_of_vertices, number_of_faces;
    HRESULT hr;
    ID3DXMesh *cylinder;
    struct vertex *vertices;
    face *faces;
    float theta_step, theta_start;
    struct sincos_table theta;
    float delta_radius, radius, radius_step;
    float z, z_step, z_normal;
    DWORD vertex, face, slice, stack;
 
    TRACE("(%p, %f, %f, %f, %u, %u, %p, %p)\n", device, radius1, radius2, length, slices, stacks, mesh, adjacency);
 
    if (device == NULL || radius1 < 0.0f || radius2 < 0.0f || length < 0.0f || slices < 2 || stacks < 1 || mesh == NULL)
    {
        return D3DERR_INVALIDCALL;
    }
 
    number_of_vertices = 2 + (slices * (3 + stacks));
    number_of_faces = 2 * slices + stacks * (2 * slices);
 
    hr = D3DXCreateMeshFVF(number_of_faces, number_of_vertices, D3DXMESH_MANAGED,
                           D3DFVF_XYZ | D3DFVF_NORMAL, device, &cylinder);
    if (FAILED(hr))
    {
        return hr;
    }
 
    if (FAILED(hr = cylinder->lpVtbl->LockVertexBuffer(cylinder, 0, (void **)&vertices)))
    {
        cylinder->lpVtbl->Release(cylinder);
        return hr;
    }
 
    if (FAILED(hr = cylinder->lpVtbl->LockIndexBuffer(cylinder, 0, (void **)&faces)))
    {
        cylinder->lpVtbl->UnlockVertexBuffer(cylinder);
        cylinder->lpVtbl->Release(cylinder);
        return hr;
    }
 
    /* theta = angle on xy plane wrt x axis */
    theta_step = -2.0f * D3DX_PI / slices;
    theta_start = D3DX_PI / 2.0f;
 
    if (!compute_sincos_table(&theta, theta_start, theta_step, slices))
    {
        cylinder->lpVtbl->UnlockIndexBuffer(cylinder);
        cylinder->lpVtbl->UnlockVertexBuffer(cylinder);
        cylinder->lpVtbl->Release(cylinder);
        return E_OUTOFMEMORY;
    }
 
    vertex = 0;
    face = 0;
 
    delta_radius = radius1 - radius2;
    radius = radius1;
    radius_step = delta_radius / stacks;
 
    z = -length / 2;
    z_step = length / stacks;
    z_normal = delta_radius / length;
    if (isnan(z_normal))
    {
        z_normal = 0.0f;
    }
 
    vertices[vertex].normal.x = 0.0f;
    vertices[vertex].normal.y = 0.0f;
    vertices[vertex].normal.z = -1.0f;
    vertices[vertex].position.x = 0.0f;
    vertices[vertex].position.y = 0.0f;
    vertices[vertex++].position.z = z;
 
    for (slice = 0; slice < slices; slice++, vertex++)
    {
        vertices[vertex].normal.x = 0.0f;
        vertices[vertex].normal.y = 0.0f;
        vertices[vertex].normal.z = -1.0f;
        vertices[vertex].position.x = radius * theta.cos[slice];
        vertices[vertex].position.y = radius * theta.sin[slice];
        vertices[vertex].position.z = z;
 
        if (slice > 0)
        {
            faces[face][0] = 0;
            faces[face][1] = slice;
            faces[face++][2] = slice + 1;
        }
    }
 
    faces[face][0] = 0;
    faces[face][1] = slice;
    faces[face++][2] = 1;
 
    for (stack = 1; stack <= stacks+1; stack++)
    {
        for (slice = 0; slice < slices; slice++, vertex++)
        {
            vertices[vertex].normal.x = theta.cos[slice];
            vertices[vertex].normal.y = theta.sin[slice];
            vertices[vertex].normal.z = z_normal;
            D3DXVec3Normalize(&vertices[vertex].normal, &vertices[vertex].normal);
            vertices[vertex].position.x = radius * theta.cos[slice];
            vertices[vertex].position.y = radius * theta.sin[slice];
            vertices[vertex].position.z = z;
 
            if (stack > 1 && slice > 0)
            {
                faces[face][0] = vertex_index(slices, slice-1, stack-1);
                faces[face][1] = vertex_index(slices, slice-1, stack);
                faces[face++][2] = vertex_index(slices, slice, stack-1);
 
                faces[face][0] = vertex_index(slices, slice, stack-1);
                faces[face][1] = vertex_index(slices, slice-1, stack);
                faces[face++][2] = vertex_index(slices, slice, stack);
            }
        }
 
        if (stack > 1)
        {
            faces[face][0] = vertex_index(slices, slice-1, stack-1);
            faces[face][1] = vertex_index(slices, slice-1, stack);
            faces[face++][2] = vertex_index(slices, 0, stack-1);
 
            faces[face][0] = vertex_index(slices, 0, stack-1);
            faces[face][1] = vertex_index(slices, slice-1, stack);
            faces[face++][2] = vertex_index(slices, 0, stack);
        }
 
        if (stack < stacks + 1)
        {
            z += z_step;
            radius -= radius_step;
        }
    }
 
    for (slice = 0; slice < slices; slice++, vertex++)
    {
        vertices[vertex].normal.x = 0.0f;
        vertices[vertex].normal.y = 0.0f;
        vertices[vertex].normal.z = 1.0f;
        vertices[vertex].position.x = radius * theta.cos[slice];
        vertices[vertex].position.y = radius * theta.sin[slice];
        vertices[vertex].position.z = z;
 
        if (slice > 0)
        {
            faces[face][0] = vertex_index(slices, slice-1, stack);
            faces[face][1] = number_of_vertices - 1;
            faces[face++][2] = vertex_index(slices, slice, stack);
        }
    }
 
    vertices[vertex].position.x = 0.0f;
    vertices[vertex].position.y = 0.0f;
    vertices[vertex].position.z = z;
    vertices[vertex].normal.x = 0.0f;
    vertices[vertex].normal.y = 0.0f;
    vertices[vertex].normal.z = 1.0f;
 
    faces[face][0] = vertex_index(slices, slice-1, stack);
    faces[face][1] = number_of_vertices - 1;
    faces[face][2] = vertex_index(slices, 0, stack);
 
    free_sincos_table(&theta);
    cylinder->lpVtbl->UnlockIndexBuffer(cylinder);
    cylinder->lpVtbl->UnlockVertexBuffer(cylinder);
 
    if (adjacency)
    {
        if (FAILED(hr = D3DXCreateBuffer(number_of_faces * sizeof(DWORD) * 3, adjacency)))
        {
            cylinder->lpVtbl->Release(cylinder);
            return hr;
        }
 
        if (FAILED(hr = cylinder->lpVtbl->GenerateAdjacency(cylinder, 0.0f, (*adjacency)->lpVtbl->GetBufferPointer(*adjacency))))
        {
            (*adjacency)->lpVtbl->Release(*adjacency);
            cylinder->lpVtbl->Release(cylinder);
            return hr;
        }
    }
 
    *mesh = cylinder;
 
    return D3D_OK;
}

Referenced by D3DXCreateCylinderTest(), and test_cylinder().

D3DXCreateMesh()

HRESULT WINAPI D3DXCreateMesh	(	DWORD	numfaces,
		DWORD	numvertices,
		DWORD	options,
		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(),