ReactOS 0.4.15-dev-8417-gb6b82fe
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_meshimpl_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 DWORDgenerate_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 point2dadd_points (struct outline *array, int num)
 
static struct outlineadd_outline (struct outline_array *array)
 
static faceadd_face (struct face_array *array)
 
static struct triangulationadd_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 D3DXVECTOR2convert_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 D3DXVECTOR2unit_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 D3DXVECTOR2get_indexed_point (struct point2d_index *pt_idx)
 
static D3DXVECTOR2get_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 D3DXVECTOR2triangulation_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 D3DXVECTOR3vertex_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++) \
{ \
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++; \
}
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
DWORD num_poly_faces
Definition: mesh.c:2613
DWORD * num_tri_per_face
Definition: mesh.c:2616

◆ 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

Definition at line 4747 of file mesh.c.

Enumeration Type Documentation

◆ 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.

5308 {
5309 POINTTYPE_CURVE = 0,
5314};
@ POINTTYPE_CURVE_MIDDLE
Definition: mesh.c:5313
@ POINTTYPE_CORNER
Definition: mesh.c:5310
@ POINTTYPE_CURVE_END
Definition: mesh.c:5312
@ POINTTYPE_CURVE_START
Definition: mesh.c:5311
@ POINTTYPE_CURVE
Definition: mesh.c:5309

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.

5481{
5482 D3DXVECTOR2 split1 = {0, 0}, split2 = {0, 0}, middle, vec;
5483 float deviation_sq;
5484
5485 D3DXVec2Scale(&split1, D3DXVec2Add(&split1, p1, p2), 0.5f);
5486 D3DXVec2Scale(&split2, D3DXVec2Add(&split2, p2, p3), 0.5f);
5487 D3DXVec2Scale(&middle, D3DXVec2Add(&middle, &split1, &split2), 0.5f);
5488
5489 deviation_sq = D3DXVec2LengthSq(D3DXVec2Subtract(&vec, &middle, p2));
5490 if (deviation_sq < max_deviation_sq) {
5491 struct point2d *pt = add_points(outline, 1);
5492 if (!pt) return E_OUTOFMEMORY;
5493 pt->pos = *p2;
5494 pt->corner = POINTTYPE_CURVE;
5495 /* the end point is omitted because the end line merges into the next segment of
5496 * the split bezier curve, and the end of the split bezier curve is added outside
5497 * this recursive function. */
5498 } else {
5499 HRESULT hr = add_bezier_points(outline, p1, &split1, &middle, max_deviation_sq);
5500 if (hr != S_OK) return hr;
5501 hr = add_bezier_points(outline, &middle, &split2, p3, max_deviation_sq);
5502 if (hr != S_OK) return hr;
5503 }
5504
5505 return S_OK;
5506}
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
static struct point2d * add_points(struct outline *array, int num)
Definition: mesh.c:5412
static HRESULT add_bezier_points(struct outline *outline, const D3DXVECTOR2 *p1, const D3DXVECTOR2 *p2, const D3DXVECTOR2 *p3, float max_deviation_sq)
Definition: mesh.c:5478
#define pt(x, y)
Definition: drawing.c:79
FT_Vector * vec
Definition: ftbbox.c:448
#define S_OK
Definition: intsafe.h:52
HRESULT hr
Definition: shlfolder.c:183
Definition: mesh.c:5330
Definition: mesh.c:5317

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.

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

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.

5425{
5426 struct outline *item;
5427
5428 if (!reserve((struct dynamic_array *)array, array->count + 1, sizeof(array->items[0])))
5429 return NULL;
5430
5431 item = &array->items[array->count++];
5432 ZeroMemory(item, sizeof(*item));
5433 return item;
5434}
#define NULL
Definition: types.h:112
static BOOL reserve(struct dynamic_array *array, int count, int itemsize)
Definition: mesh.c:5392
static ATOM item
Definition: dde.c:856
#define ZeroMemory
Definition: winbase.h:1712

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.

5413{
5414 struct point2d *item;
5415
5416 if (!reserve((struct dynamic_array *)array, array->count + num, sizeof(array->items[0])))
5417 return NULL;
5418
5419 item = &array->items[array->count];
5420 array->count += num;
5421 return item;
5422}
GLuint GLuint num
Definition: glext.h:9618

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.

5442{
5443 struct triangulation *item;
5444
5445 if (!reserve((struct dynamic_array *)array, array->count + 1, sizeof(array->items[0])))
5446 return NULL;
5447
5448 item = &array->items[array->count++];
5449 ZeroMemory(item, sizeof(*item));
5450 return item;
5451}

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.

5454{
5455 if (!reserve((struct dynamic_array *)array, array->count + 1, sizeof(array->items[0])))
5456 return E_OUTOFMEMORY;
5457
5458 array->items[array->count++] = vertex_index;
5459 return S_OK;
5460}
static WORD vertex_index(UINT slices, int slice, int stack)
Definition: mesh.c:4790

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.

2021{
2022 declaration[*idx].Stream = 0;
2023 declaration[*idx].Offset = *offset;
2024 declaration[*idx].Type = type;
2026 declaration[*idx].Usage = usage;
2027 declaration[*idx].UsageIndex = usage_idx;
2028
2030 ++(*idx);
2031}
BYTE usage_idx
@ D3DDECLMETHOD_DEFAULT
Definition: d3d9types.h:242
static const UINT d3dx_decltype_size[]
Definition: mesh.c:67
unsigned int idx
Definition: utils.c:41
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLsizeiptr const GLvoid GLenum usage
Definition: glext.h:5919
GLintptr offset
Definition: glext.h:5920

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.

5531{
5532 D3DXVECTOR2 curdir, lastdir;
5533 struct point2d *prevpt, *pt;
5534 BOOL ret = FALSE;
5535
5536 pt = &outline->items[pt_index];
5537 pt_index = (pt_index - 1 + outline->count) % outline->count;
5538 prevpt = &outline->items[pt_index];
5539
5540 if (to_curve)
5542
5543 if (outline->count < 2)
5544 return FALSE;
5545
5546 /* remove last point if the next line continues the last line */
5547 unit_vec2(&lastdir, &prevpt->pos, &pt->pos);
5548 unit_vec2(&curdir, &pt->pos, nextpt);
5549 if (is_direction_similar(&lastdir, &curdir, table->cos_half))
5550 {
5551 outline->count--;
5552 if (pt->corner == POINTTYPE_CURVE_END)
5553 prevpt->corner = pt->corner;
5554 if (prevpt->corner == POINTTYPE_CURVE_END && to_curve)
5556 pt = prevpt;
5557
5558 ret = TRUE;
5559 if (outline->count < 2)
5560 return ret;
5561
5562 pt_index = (pt_index - 1 + outline->count) % outline->count;
5563 prevpt = &outline->items[pt_index];
5564 unit_vec2(&lastdir, &prevpt->pos, &pt->pos);
5565 unit_vec2(&curdir, &pt->pos, nextpt);
5566 }
5567 return ret;
5568}
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
static BOOL is_direction_similar(D3DXVECTOR2 *dir1, D3DXVECTOR2 *dir2, float cos_theta)
Definition: mesh.c:5508
static D3DXVECTOR2 * unit_vec2(D3DXVECTOR2 *dir, const D3DXVECTOR2 *pt1, const D3DXVECTOR2 *pt2)
Definition: mesh.c:5514
unsigned int BOOL
Definition: ntddk_ex.h:94
if(dx< 0)
Definition: linetemp.h:194
struct point2d * items
Definition: mesh.c:5332
int count
Definition: mesh.c:5331
D3DXVECTOR2 pos
Definition: mesh.c:5318
enum pointtype corner
Definition: mesh.c:5319
int 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.

1594{
1595 const DWORD *ptr_a = *(const DWORD **)a;
1596 const DWORD *ptr_b = *(const DWORD **)b;
1597 int delta = *ptr_a - *ptr_b;
1598
1599 if (delta)
1600 return delta;
1601
1602 delta = ptr_a - ptr_b; /* for stable sort */
1603 return delta;
1604}
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204

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.

1499{
1500 HRESULT hr;
1501 DWORD *vertex_remap_ptr;
1502 DWORD num_used_vertices;
1503 DWORD i;
1504
1505 hr = D3DXCreateBuffer(This->numvertices * sizeof(DWORD), vertex_remap);
1506 if (FAILED(hr)) return hr;
1507 vertex_remap_ptr = ID3DXBuffer_GetBufferPointer(*vertex_remap);
1508
1509 for (i = 0; i < This->numfaces * 3; i++)
1510 vertex_remap_ptr[indices[i]] = 1;
1511
1512 /* create old->new vertex mapping */
1513 num_used_vertices = 0;
1514 for (i = 0; i < This->numvertices; i++) {
1515 if (vertex_remap_ptr[i])
1516 vertex_remap_ptr[i] = num_used_vertices++;
1517 else
1518 vertex_remap_ptr[i] = -1;
1519 }
1520 /* convert indices */
1521 for (i = 0; i < This->numfaces * 3; i++)
1522 indices[i] = vertex_remap_ptr[indices[i]];
1523
1524 /* create new->old vertex mapping */
1525 num_used_vertices = 0;
1526 for (i = 0; i < This->numvertices; i++) {
1527 if (vertex_remap_ptr[i] != -1)
1528 vertex_remap_ptr[num_used_vertices++] = i;
1529 }
1530 for (i = num_used_vertices; i < This->numvertices; i++)
1531 vertex_remap_ptr[i] = -1;
1532
1533 *new_num_vertices = num_used_vertices;
1534
1535 return D3D_OK;
1536}
#define D3D_OK
Definition: d3d.h:106
#define ID3DXBuffer_GetBufferPointer(p)
Definition: d3dx9core.h:85
HRESULT WINAPI D3DXCreateBuffer(DWORD size, ID3DXBuffer **buffer)
Definition: core.c:131
GLuint GLuint GLsizei GLenum const GLvoid * indices
Definition: gl.h:1545
#define FAILED(hr)
Definition: intsafe.h:51

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.

5846{
5847 const struct point2d_index *idx1 = a, *idx2 = b;
5848 const D3DXVECTOR2 *p1 = &idx1->outline->items[idx1->vertex].pos;
5849 const D3DXVECTOR2 *p2 = &idx2->outline->items[idx2->vertex].pos;
5850 float diff = p1->x - p2->x;
5851
5852 if (diff == 0.0f)
5853 diff = p1->y - p2->y;
5854
5855 return diff == 0.0f ? 0 : (diff > 0.0f ? -1 : 1);
5856}
#define a
Definition: ke_i.h:78
#define b
Definition: ke_i.h:79
FLOAT x
Definition: d3dx9math.h:64
FLOAT y
Definition: d3dx9math.h:64
struct outline * outline
Definition: mesh.c:5350
int vertex
Definition: mesh.c:5351

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.

1216{
1217 const struct vertex_metadata *left = a;
1218 const struct vertex_metadata *right = b;
1219 if (left->key == right->key)
1220 return 0;
1221 return left->key < right->key ? -1 : 1;
1222}
GLdouble GLdouble right
Definition: glext.h:10859
GLint left
Definition: glext.h:7726

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.

4763{
4764 float angle;
4765 int i;
4766
4768 if (!sincos_table->sin)
4769 {
4770 return FALSE;
4771 }
4773 if (!sincos_table->cos)
4774 {
4776 return FALSE;
4777 }
4778
4779 angle = angle_start;
4780 for (i = 0; i < n; i++)
4781 {
4784 angle += angle_step;
4785 }
4786
4787 return TRUE;
4788}
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
GLdouble n
Definition: glext.h:7729
GLfloat angle
Definition: glext.h:10853
_Check_return_ float __cdecl cosf(_In_ float x)
Definition: math.h:224
_Check_return_ float __cdecl sinf(_In_ float x)
Definition: math.h:233
float * sin
Definition: mesh.c:4751
float * cos
Definition: mesh.c:4752

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.

470{
471 BOOL fixme_once = FALSE;
472
473 switch (type_src)
474 {
476 {
477 FLOAT *src_ptr = (FLOAT*)src;
478 D3DXVECTOR4 src_float4 = {*src_ptr, 0.0f, 0.0f, 1.0f};
479 convert_float4(dst, &src_float4, type_dst);
480 break;
481 }
483 {
484 D3DXVECTOR2 *src_ptr = (D3DXVECTOR2*)src;
485 D3DXVECTOR4 src_float4 = {src_ptr->x, src_ptr->y, 0.0f, 1.0f};
486 convert_float4(dst, &src_float4, type_dst);
487 break;
488 }
490 {
491 D3DXVECTOR3 *src_ptr = (D3DXVECTOR3*)src;
492 D3DXVECTOR4 src_float4 = {src_ptr->x, src_ptr->y, src_ptr->z, 1.0f};
493 convert_float4(dst, &src_float4, type_dst);
494 break;
495 }
497 {
498 D3DXVECTOR4 *src_ptr = (D3DXVECTOR4*)src;
499 D3DXVECTOR4 src_float4 = {src_ptr->x, src_ptr->y, src_ptr->z, src_ptr->w};
500 convert_float4(dst, &src_float4, type_dst);
501 break;
502 }
504 {
505 D3DXVECTOR4 src_float4 =
506 {
507 (FLOAT)src[2]/UCHAR_MAX,
508 (FLOAT)src[1]/UCHAR_MAX,
509 (FLOAT)src[0]/UCHAR_MAX,
511 };
512 convert_float4(dst, &src_float4, type_dst);
513 break;
514 }
516 {
517 D3DXVECTOR4 src_float4 = {src[0], src[1], src[2], src[3]};
518 convert_float4(dst, &src_float4, type_dst);
519 break;
520 }
522 {
523 SHORT *src_ptr = (SHORT*)src;
524 D3DXVECTOR4 src_float4 = {src_ptr[0], src_ptr[1], 0.0f, 1.0f};
525 convert_float4(dst, &src_float4, type_dst);
526 break;
527 }
529 {
530 SHORT *src_ptr = (SHORT*)src;
531 D3DXVECTOR4 src_float4 = {src_ptr[0], src_ptr[1], src_ptr[2], src_ptr[3]};
532 convert_float4(dst, &src_float4, type_dst);
533 break;
534 }
536 {
537 D3DXVECTOR4 src_float4 =
538 {
539 (FLOAT)src[0]/UCHAR_MAX,
540 (FLOAT)src[1]/UCHAR_MAX,
541 (FLOAT)src[2]/UCHAR_MAX,
543 };
544 convert_float4(dst, &src_float4, type_dst);
545 break;
546 }
548 {
549 SHORT *src_ptr = (SHORT*)src;
550 D3DXVECTOR4 src_float4 = {(FLOAT)src_ptr[0]/SHRT_MAX, (FLOAT)src_ptr[1]/SHRT_MAX, 0.0f, 1.0f};
551 convert_float4(dst, &src_float4, type_dst);
552 break;
553 }
555 {
556 SHORT *src_ptr = (SHORT*)src;
557 D3DXVECTOR4 src_float4 =
558 {
559 (FLOAT)src_ptr[0]/SHRT_MAX,
560 (FLOAT)src_ptr[1]/SHRT_MAX,
561 (FLOAT)src_ptr[2]/SHRT_MAX,
562 (FLOAT)src_ptr[3]/SHRT_MAX
563 };
564 convert_float4(dst, &src_float4, type_dst);
565 break;
566 }
568 {
569 D3DXVECTOR4 src_float4 = {0.0f, 0.0f, 0.0f, 1.0f};
570 D3DXFloat16To32Array((FLOAT*)&src_float4, (D3DXFLOAT16*)src, 2);
571 convert_float4(dst, &src_float4, type_dst);
572 break;
573 }
575 {
576 D3DXVECTOR4 src_float4;
577 D3DXFloat16To32Array((FLOAT*)&src_float4, (D3DXFLOAT16*)src, 4);
578 convert_float4(dst, &src_float4, type_dst);
579 break;
580 }
581 default:
582 if (!fixme_once++)
583 FIXME("Conversion of D3DDECLTYPE %d to %d not implemented.\n", type_src, type_dst);
584 break;
585 }
586}
#define FIXME(fmt,...)
Definition: precomp.h:53
@ D3DDECLTYPE_UBYTE4
Definition: d3d9types.h:260
@ D3DDECLTYPE_SHORT2
Definition: d3d9types.h:261
@ D3DDECLTYPE_FLOAT3
Definition: d3d9types.h:257
@ D3DDECLTYPE_FLOAT1
Definition: d3d9types.h:255
@ D3DDECLTYPE_SHORT2N
Definition: d3d9types.h:265
@ D3DDECLTYPE_FLOAT16_4
Definition: d3d9types.h:272
@ D3DDECLTYPE_FLOAT16_2
Definition: d3d9types.h:271
@ D3DDECLTYPE_D3DCOLOR
Definition: d3d9types.h:259
@ D3DDECLTYPE_SHORT4
Definition: d3d9types.h:262
@ D3DDECLTYPE_UBYTE4N
Definition: d3d9types.h:264
@ D3DDECLTYPE_SHORT4N
Definition: d3d9types.h:266
@ D3DDECLTYPE_FLOAT2
Definition: d3d9types.h:256
@ D3DDECLTYPE_FLOAT4
Definition: d3d9types.h:258
FLOAT *WINAPI D3DXFloat16To32Array(FLOAT *pout, const D3DXFLOAT16 *pin, UINT n)
Definition: math.c:2221
static void convert_float4(BYTE *dst, const D3DXVECTOR4 *src, D3DDECLTYPE type_dst)
Definition: mesh.c:344
GLenum src
Definition: glext.h:6340
GLenum GLenum dst
Definition: glext.h:6340
#define FLOAT
Definition: i386-dis.c:525
#define SHRT_MAX
Definition: limits.h:37
#define UCHAR_MAX
Definition: limits.h:25
short SHORT
Definition: pedump.c:59
float FLOAT
Definition: typedefs.h:69

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.

5467{
5469 while (count--) {
5470 D3DXVECTOR2 *pt_flt = (D3DXVECTOR2*)pt;
5471 pt_flt->x = (pt->x.value + pt->x.fract / (float)0x10000) / emsquare;
5472 pt_flt->y = (pt->y.value + pt->y.fract / (float)0x10000) / emsquare;
5473 pt++;
5474 }
5475 return ret;
5476}
static float(__cdecl *square_half_float)(float x
char * value
Definition: compiler.c:67

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.

345{
346 BOOL fixme_once = FALSE;
347
348 switch (type_dst)
349 {
351 {
352 FLOAT *dst_ptr = (FLOAT*)dst;
353 *dst_ptr = src->x;
354 break;
355 }
357 {
358 D3DXVECTOR2 *dst_ptr = (D3DXVECTOR2*)dst;
359 dst_ptr->x = src->x;
360 dst_ptr->y = src->y;
361 break;
362 }
364 {
365 D3DXVECTOR3 *dst_ptr = (D3DXVECTOR3*)dst;
366 dst_ptr->x = src->x;
367 dst_ptr->y = src->y;
368 dst_ptr->z = src->z;
369 break;
370 }
372 {
373 D3DXVECTOR4 *dst_ptr = (D3DXVECTOR4*)dst;
374 dst_ptr->x = src->x;
375 dst_ptr->y = src->y;
376 dst_ptr->z = src->z;
377 dst_ptr->w = src->w;
378 break;
379 }
381 {
386 break;
387 }
389 {
390 dst[0] = src->x < 0.0f ? 0 : (BYTE)simple_round(src->x);
391 dst[1] = src->y < 0.0f ? 0 : (BYTE)simple_round(src->y);
392 dst[2] = src->z < 0.0f ? 0 : (BYTE)simple_round(src->z);
393 dst[3] = src->w < 0.0f ? 0 : (BYTE)simple_round(src->w);
394 break;
395 }
397 {
398 SHORT *dst_ptr = (SHORT*)dst;
399 dst_ptr[0] = (SHORT)simple_round(src->x);
400 dst_ptr[1] = (SHORT)simple_round(src->y);
401 break;
402 }
404 {
405 SHORT *dst_ptr = (SHORT*)dst;
406 dst_ptr[0] = (SHORT)simple_round(src->x);
407 dst_ptr[1] = (SHORT)simple_round(src->y);
408 dst_ptr[2] = (SHORT)simple_round(src->z);
409 dst_ptr[3] = (SHORT)simple_round(src->w);
410 break;
411 }
413 {
418 break;
419 }
421 {
422 SHORT *dst_ptr = (SHORT*)dst;
423 dst_ptr[0] = (SHORT)simple_round(scale_clamp_shortn(src->x));
424 dst_ptr[1] = (SHORT)simple_round(scale_clamp_shortn(src->y));
425 break;
426 }
428 {
429 SHORT *dst_ptr = (SHORT*)dst;
430 dst_ptr[0] = (SHORT)simple_round(scale_clamp_shortn(src->x));
431 dst_ptr[1] = (SHORT)simple_round(scale_clamp_shortn(src->y));
432 dst_ptr[2] = (SHORT)simple_round(scale_clamp_shortn(src->z));
433 dst_ptr[3] = (SHORT)simple_round(scale_clamp_shortn(src->w));
434 break;
435 }
437 {
438 USHORT *dst_ptr = (USHORT*)dst;
439 dst_ptr[0] = (USHORT)simple_round(scale_clamp_ushortn(src->x));
440 dst_ptr[1] = (USHORT)simple_round(scale_clamp_ushortn(src->y));
441 break;
442 }
444 {
445 USHORT *dst_ptr = (USHORT*)dst;
446 dst_ptr[0] = (USHORT)simple_round(scale_clamp_ushortn(src->x));
447 dst_ptr[1] = (USHORT)simple_round(scale_clamp_ushortn(src->y));
448 dst_ptr[2] = (USHORT)simple_round(scale_clamp_ushortn(src->z));
449 dst_ptr[3] = (USHORT)simple_round(scale_clamp_ushortn(src->w));
450 break;
451 }
453 {
455 break;
456 }
458 {
460 break;
461 }
462 default:
463 if (!fixme_once++)
464 FIXME("Conversion from D3DDECLTYPE_FLOAT4 to %d not implemented.\n", type_dst);
465 break;
466 }
467}
@ D3DDECLTYPE_USHORT4N
Definition: d3d9types.h:268
@ D3DDECLTYPE_USHORT2N
Definition: d3d9types.h:267
D3DXFLOAT16 *WINAPI D3DXFloat32To16Array(D3DXFLOAT16 *pout, const FLOAT *pin, UINT n)
Definition: math.c:2187
static FLOAT scale_clamp_ushortn(FLOAT value)
Definition: mesh.c:320
static FLOAT scale_clamp_shortn(FLOAT value)
Definition: mesh.c:301
static FLOAT scale_clamp_ubyten(FLOAT value)
Definition: mesh.c:284
static INT simple_round(FLOAT value)
Definition: mesh.c:337
unsigned short USHORT
Definition: pedump.c:61
unsigned char BYTE
Definition: xxhash.c:193

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.

605{
606 HRESULT hr;
607 D3DVERTEXELEMENT9 orig_declaration[MAX_FVF_DECL_SIZE] = {D3DDECL_END()};
609 BYTE *vb_dst = NULL;
610 BYTE *vb_src = NULL;
611 UINT i;
612 UINT num_vertices = mesh_src->lpVtbl->GetNumVertices(mesh_src);
613 UINT dst_vertex_size = mesh_dst->lpVtbl->GetNumBytesPerVertex(mesh_dst);
614 UINT src_vertex_size = mesh_src->lpVtbl->GetNumBytesPerVertex(mesh_src);
615
616 hr = mesh_src->lpVtbl->GetDeclaration(mesh_src, orig_declaration);
617 if (FAILED(hr)) return hr;
618 hr = mesh_dst->lpVtbl->GetDeclaration(mesh_dst, declaration);
619 if (FAILED(hr)) return hr;
620
621 hr = mesh_src->lpVtbl->LockVertexBuffer(mesh_src, D3DLOCK_READONLY, (void**)&vb_src);
622 if (FAILED(hr)) goto cleanup;
623 hr = mesh_dst->lpVtbl->LockVertexBuffer(mesh_dst, 0, (void**)&vb_dst);
624 if (FAILED(hr)) goto cleanup;
625
626 /* Clear all new fields by clearing the entire vertex buffer. */
627 memset(vb_dst, 0, num_vertices * dst_vertex_size);
628
629 for (i = 0; orig_declaration[i].Stream != 0xff; i++)
630 {
631 INT eq_idx = get_equivalent_declaration_index(orig_declaration[i], declaration);
632
633 if (eq_idx >= 0)
634 {
635 UINT j;
636 for (j = 0; j < num_vertices; j++)
637 {
638 UINT idx_dst = dst_vertex_size * j + declaration[eq_idx].Offset;
639 UINT idx_src = src_vertex_size * j + orig_declaration[i].Offset;
640 UINT type_size = d3dx_decltype_size[orig_declaration[i].Type];
641
642 if (orig_declaration[i].Type == declaration[eq_idx].Type)
643 memcpy(&vb_dst[idx_dst], &vb_src[idx_src], type_size);
644 else
645 convert_component(&vb_dst[idx_dst], &vb_src[idx_src], declaration[eq_idx].Type, orig_declaration[i].Type);
646 }
647 }
648 }
649
650 hr = D3D_OK;
651cleanup:
652 if (vb_dst) mesh_dst->lpVtbl->UnlockVertexBuffer(mesh_dst);
653 if (vb_src) mesh_src->lpVtbl->UnlockVertexBuffer(mesh_src);
654
655 return hr;
656}
Type
Definition: Type.h:7
#define D3DLOCK_READONLY
Definition: d3d8types.h:69
#define D3DDECL_END()
Definition: d3d9types.h:311
@ MAX_FVF_DECL_SIZE
Definition: d3dx9mesh.h:41
static void convert_component(BYTE *dst, BYTE *src, D3DDECLTYPE type_dst, D3DDECLTYPE type_src)
Definition: mesh.c:469
static INT get_equivalent_declaration_index(D3DVERTEXELEMENT9 orig_declaration, D3DVERTEXELEMENT9 *declaration)
Definition: mesh.c:588
static void cleanup(void)
Definition: main.c:1335
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
unsigned int UINT
Definition: ndis.h:50
#define memset(x, y, z)
Definition: compat.h:39
int32_t INT
Definition: typedefs.h:58

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.

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

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.

1540{
1541 DWORD last_attribute = attrib_buffer[0];
1542 DWORD attrib_table_size = 1;
1543 DWORD i;
1544 for (i = 1; i < numfaces; i++) {
1545 if (attrib_buffer[i] != last_attribute) {
1546 last_attribute = attrib_buffer[i];
1547 attrib_table_size++;
1548 }
1549 }
1550 return attrib_table_size;
1551}

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.

5573{
5574 TTPOLYGONHEADER *header = (TTPOLYGONHEADER *)raw_outline;
5575
5576 while ((char *)header < (char *)raw_outline + datasize)
5577 {
5578 TTPOLYCURVE *curve = (TTPOLYCURVE *)(header + 1);
5579 struct point2d *lastpt, *pt;
5580 D3DXVECTOR2 lastdir;
5581 D3DXVECTOR2 *pt_flt;
5582 int j;
5583 struct outline *outline = add_outline(&glyph->outlines);
5584
5585 if (!outline)
5586 return E_OUTOFMEMORY;
5587
5588 pt = add_points(outline, 1);
5589 if (!pt)
5590 return E_OUTOFMEMORY;
5591 pt_flt = convert_fixed_to_float(&header->pfxStart, 1, emsquare);
5592 pt->pos = *pt_flt;
5593 pt->corner = POINTTYPE_CORNER;
5594
5595 if (header->dwType != TT_POLYGON_TYPE)
5596 FIXME("Unknown header type %d\n", header->dwType);
5597
5598 while ((char *)curve < (char *)header + header->cb)
5599 {
5600 D3DXVECTOR2 bezier_start = outline->items[outline->count - 1].pos;
5601 BOOL to_curve = curve->wType != TT_PRIM_LINE && curve->cpfx > 1;
5602 unsigned int j2 = 0;
5603
5604 if (!curve->cpfx) {
5605 curve = (TTPOLYCURVE *)&curve->apfx[curve->cpfx];
5606 continue;
5607 }
5608
5609 pt_flt = convert_fixed_to_float(curve->apfx, curve->cpfx, emsquare);
5610
5611 attempt_line_merge(outline, outline->count - 1, &pt_flt[0], to_curve, cos_table);
5612
5613 if (to_curve)
5614 {
5615 HRESULT hr;
5616 int count = curve->cpfx;
5617
5618 while (count > 2)
5619 {
5620 D3DXVECTOR2 bezier_end;
5621
5622 D3DXVec2Scale(&bezier_end, D3DXVec2Add(&bezier_end, &pt_flt[j2], &pt_flt[j2+1]), 0.5f);
5623 hr = add_bezier_points(outline, &bezier_start, &pt_flt[j2], &bezier_end, max_deviation_sq);
5624 if (hr != S_OK)
5625 return hr;
5626 bezier_start = bezier_end;
5627 count--;
5628 j2++;
5629 }
5630 hr = add_bezier_points(outline, &bezier_start, &pt_flt[j2], &pt_flt[j2+1], max_deviation_sq);
5631 if (hr != S_OK)
5632 return hr;
5633
5634 pt = add_points(outline, 1);
5635 if (!pt)
5636 return E_OUTOFMEMORY;
5637 j2++;
5638 pt->pos = pt_flt[j2];
5639 pt->corner = POINTTYPE_CURVE_END;
5640 } else {
5641 pt = add_points(outline, curve->cpfx);
5642 if (!pt)
5643 return E_OUTOFMEMORY;
5644 for (j2 = 0; j2 < curve->cpfx; j2++)
5645 {
5646 pt->pos = pt_flt[j2];
5647 pt->corner = POINTTYPE_CORNER;
5648 pt++;
5649 }
5650 }
5651
5652 curve = (TTPOLYCURVE *)&curve->apfx[curve->cpfx];
5653 }
5654
5655 /* remove last point if the next line continues the last line */
5656 if (outline->count >= 3) {
5657 BOOL to_curve;
5658
5659 lastpt = &outline->items[outline->count - 1];
5660 pt = &outline->items[0];
5661 if (pt->pos.x == lastpt->pos.x && pt->pos.y == lastpt->pos.y) {
5662 if (lastpt->corner == POINTTYPE_CURVE_END)
5663 {
5664 if (pt->corner == POINTTYPE_CURVE_START)
5665 pt->corner = POINTTYPE_CURVE_MIDDLE;
5666 else
5667 pt->corner = POINTTYPE_CURVE_END;
5668 }
5669 outline->count--;
5670 } else {
5671 /* outline closed with a line from end to start point */
5673 }
5674 lastpt = &outline->items[0];
5675 to_curve = lastpt->corner != POINTTYPE_CORNER && lastpt->corner != POINTTYPE_CURVE_END;
5676 if (lastpt->corner == POINTTYPE_CURVE_START)
5677 lastpt->corner = POINTTYPE_CORNER;
5678 pt = &outline->items[1];
5679 if (attempt_line_merge(outline, 0, &pt->pos, to_curve, cos_table))
5680 *lastpt = outline->items[outline->count];
5681 }
5682
5683 lastpt = &outline->items[outline->count - 1];
5684 pt = &outline->items[0];
5685 unit_vec2(&lastdir, &lastpt->pos, &pt->pos);
5686 for (j = 0; j < outline->count; j++)
5687 {
5688 D3DXVECTOR2 curdir;
5689
5690 lastpt = pt;
5691 pt = &outline->items[(j + 1) % outline->count];
5692 unit_vec2(&curdir, &lastpt->pos, &pt->pos);
5693
5694 switch (lastpt->corner)
5695 {
5698 if (!is_direction_similar(&lastdir, &curdir, cos_table->cos_45))
5699 lastpt->corner = POINTTYPE_CORNER;
5700 break;
5702 if (!is_direction_similar(&lastdir, &curdir, cos_table->cos_90))
5703 lastpt->corner = POINTTYPE_CORNER;
5704 else
5705 lastpt->corner = POINTTYPE_CURVE;
5706 break;
5707 default:
5708 break;
5709 }
5710 lastdir = curdir;
5711 }
5712
5713 header = (TTPOLYGONHEADER *)((char *)header + header->cb);
5714 }
5715 return S_OK;
5716}
static SIZE_T datasize
Definition: asm.c:30
static D3DXVECTOR2 * convert_fixed_to_float(POINTFX *pt, int count, unsigned int emsquare)
Definition: mesh.c:5466
static struct outline * add_outline(struct outline_array *array)
Definition: mesh.c:5424
static BOOL attempt_line_merge(struct outline *outline, int pt_index, const D3DXVECTOR2 *nextpt, BOOL to_curve, const struct cos_table *table)
Definition: mesh.c:5526
float cos_90
Definition: mesh.c:5523
float cos_45
Definition: mesh.c:5522
struct outline_array outlines
Definition: mesh.c:5362
POINTFX apfx[1]
Definition: wingdi.h:2714
#define TT_POLYGON_TYPE
Definition: wingdi.h:1318
#define TT_PRIM_LINE
Definition: wingdi.h:1319

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.

112{
113 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
114 ULONG refcount = InterlockedIncrement(&mesh->ref);
115
116 TRACE("%p increasing refcount to %u.\n", mesh, refcount);
117
118 return refcount;
119}
#define InterlockedIncrement
Definition: armddk.h:53
static struct d3dx9_mesh * impl_from_ID3DXMesh(ID3DXMesh *iface)
Definition: mesh.c:88
#define TRACE(s)
Definition: solgame.cpp:4
Definition: mesh.c:198
uint32_t ULONG
Definition: typedefs.h:59

◆ 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.

679{
680 struct d3dx9_mesh *This = impl_from_ID3DXMesh(iface);
681 struct d3dx9_mesh *cloned_this;
682 ID3DXMesh *clone_mesh;
683 D3DVERTEXELEMENT9 orig_declaration[MAX_FVF_DECL_SIZE] = { D3DDECL_END() };
684 void *data_in, *data_out;
685 DWORD vertex_size;
686 HRESULT hr;
687 BOOL same_declaration;
688
689 TRACE("iface %p, options %#x, declaration %p, device %p, clone_mesh_out %p.\n",
690 iface, options, declaration, device, clone_mesh_out);
691
692 if (!clone_mesh_out)
693 return D3DERR_INVALIDCALL;
694
695 hr = iface->lpVtbl->GetDeclaration(iface, orig_declaration);
696 if (FAILED(hr)) return hr;
697
698 hr = D3DXCreateMesh(This->numfaces, This->numvertices, options & ~D3DXMESH_VB_SHARE,
699 declaration, device, &clone_mesh);
700 if (FAILED(hr)) return hr;
701
702 cloned_this = impl_from_ID3DXMesh(clone_mesh);
703 vertex_size = clone_mesh->lpVtbl->GetNumBytesPerVertex(clone_mesh);
704 same_declaration = declaration_equals(declaration, orig_declaration);
705
707 if (!same_declaration) {
709 goto error;
710 }
711 IDirect3DVertexBuffer9_AddRef(This->vertex_buffer);
712 /* FIXME: refactor to avoid creating a new vertex buffer */
714 cloned_this->vertex_buffer = This->vertex_buffer;
715 } else if (same_declaration) {
716 hr = iface->lpVtbl->LockVertexBuffer(iface, D3DLOCK_READONLY, &data_in);
717 if (FAILED(hr)) goto error;
718 hr = clone_mesh->lpVtbl->LockVertexBuffer(clone_mesh, 0, &data_out);
719 if (FAILED(hr)) {
720 iface->lpVtbl->UnlockVertexBuffer(iface);
721 goto error;
722 }
723 memcpy(data_out, data_in, This->numvertices * vertex_size);
724 clone_mesh->lpVtbl->UnlockVertexBuffer(clone_mesh);
725 iface->lpVtbl->UnlockVertexBuffer(iface);
726 } else {
727 hr = convert_vertex_buffer(clone_mesh, iface);
728 if (FAILED(hr)) goto error;
729 }
730
731 hr = iface->lpVtbl->LockIndexBuffer(iface, D3DLOCK_READONLY, &data_in);
732 if (FAILED(hr)) goto error;
733 hr = clone_mesh->lpVtbl->LockIndexBuffer(clone_mesh, 0, &data_out);
734 if (FAILED(hr)) {
735 iface->lpVtbl->UnlockIndexBuffer(iface);
736 goto error;
737 }
738 if ((options ^ This->options) & D3DXMESH_32BIT) {
739 DWORD i;
740 if (options & D3DXMESH_32BIT) {
741 for (i = 0; i < This->numfaces * 3; i++)
742 ((DWORD*)data_out)[i] = ((WORD*)data_in)[i];
743 } else {
744 for (i = 0; i < This->numfaces * 3; i++)
745 ((WORD*)data_out)[i] = ((DWORD*)data_in)[i];
746 }
747 } else {
748 memcpy(data_out, data_in, This->numfaces * 3 * (options & D3DXMESH_32BIT ? 4 : 2));
749 }
750 clone_mesh->lpVtbl->UnlockIndexBuffer(clone_mesh);
751 iface->lpVtbl->UnlockIndexBuffer(iface);
752
753 memcpy(cloned_this->attrib_buffer, This->attrib_buffer, This->numfaces * sizeof(*This->attrib_buffer));
754
755 if (This->attrib_table_size)
756 {
757 cloned_this->attrib_table_size = This->attrib_table_size;
758 cloned_this->attrib_table = HeapAlloc(GetProcessHeap(), 0, This->attrib_table_size * sizeof(*This->attrib_table));
759 if (!cloned_this->attrib_table) {
761 goto error;
762 }
763 memcpy(cloned_this->attrib_table, This->attrib_table, This->attrib_table_size * sizeof(*This->attrib_table));
764 }
765
766 *clone_mesh_out = clone_mesh;
767
768 return D3D_OK;
769error:
770 IUnknown_Release(clone_mesh);
771 return hr;
772}
#define IDirect3DVertexBuffer9_Release(p)
Definition: d3d9.h:696
#define IDirect3DVertexBuffer9_AddRef(p)
Definition: d3d9.h:695
#define D3DERR_INVALIDCALL
@ D3DXMESH_32BIT
Definition: d3dx9mesh.h:46
@ D3DXMESH_VB_SHARE
Definition: d3dx9mesh.h:61
static HRESULT convert_vertex_buffer(ID3DXMesh *mesh_dst, ID3DXMesh *mesh_src)
Definition: mesh.c:604
HRESULT WINAPI D3DXCreateMesh(DWORD numfaces, DWORD numvertices, DWORD options, const D3DVERTEXELEMENT9 *declaration, struct IDirect3DDevice9 *device, struct ID3DXMesh **mesh)
Definition: mesh.c:2433
static BOOL declaration_equals(const D3DVERTEXELEMENT9 *declaration1, const D3DVERTEXELEMENT9 *declaration2)
Definition: mesh.c:658
#define error(str)
Definition: mkdosfs.c:1605
D3DXATTRIBUTERANGE * attrib_table
Definition: mesh.c:64
IDirect3DVertexBuffer9 * vertex_buffer
Definition: mesh.c:59
DWORD * attrib_buffer
Definition: mesh.c:61
DWORD attrib_table_size
Definition: mesh.c:63
Definition: devices.h:37

◆ 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.

271{
272 HRESULT hr;
274
275 TRACE("iface %p, options %#x, fvf %#x, device %p, clone_mesh %p.\n",
276 iface, options, fvf, device, clone_mesh);
277
279 return hr;
280
281 return iface->lpVtbl->CloneMesh(iface, options, declaration, device, clone_mesh);
282}
HRESULT WINAPI D3DXDeclaratorFromFVF(DWORD fvf, D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE])
Definition: mesh.c:2036

◆ 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.

1105{
1106 struct d3dx9_mesh *This = impl_from_ID3DXMesh(iface);
1107 HRESULT hr;
1108 DWORD face;
1109 DWORD i;
1110 DWORD *indices = NULL;
1111 WORD *indices_16bit = NULL;
1112 DWORD *new_indices = NULL;
1113 const unsigned int VERTS_PER_FACE = 3;
1114
1115 TRACE("iface %p, adjacency %p, point_reps %p.\n", iface, adjacency, point_reps);
1116
1117 if (!adjacency)
1118 {
1119 WARN("NULL adjacency.\n");
1121 goto cleanup;
1122 }
1123
1124 if (!point_reps)
1125 {
1126 WARN("NULL point_reps.\n");
1128 goto cleanup;
1129 }
1130
1131 /* Should never happen as CreateMesh does not allow meshes with 0 faces */
1132 if (This->numfaces == 0)
1133 {
1134 ERR("Number of faces was zero.\n");
1136 goto cleanup;
1137 }
1138
1139 new_indices = HeapAlloc(GetProcessHeap(), 0, VERTS_PER_FACE * This->numfaces * sizeof(*indices));
1140 if (!new_indices)
1141 {
1142 hr = E_OUTOFMEMORY;
1143 goto cleanup;
1144 }
1145
1146 if (This->options & D3DXMESH_32BIT)
1147 {
1148 hr = iface->lpVtbl->LockIndexBuffer(iface, D3DLOCK_READONLY, (void**)&indices);
1149 if (FAILED(hr)) goto cleanup;
1150 memcpy(new_indices, indices, VERTS_PER_FACE * This->numfaces * sizeof(*indices));
1151 }
1152 else
1153 {
1154 /* Make a widening copy of indices_16bit into indices and new_indices
1155 * in order to re-use the helper function */
1156 hr = iface->lpVtbl->LockIndexBuffer(iface, D3DLOCK_READONLY, (void**)&indices_16bit);
1157 if (FAILED(hr)) goto cleanup;
1158 indices = HeapAlloc(GetProcessHeap(), 0, VERTS_PER_FACE * This->numfaces * sizeof(*indices));
1159 if (!indices)
1160 {
1161 hr = E_OUTOFMEMORY;
1162 goto cleanup;
1163 }
1164 for (i = 0; i < VERTS_PER_FACE * This->numfaces; i++)
1165 {
1166 new_indices[i] = indices_16bit[i];
1167 indices[i] = indices_16bit[i];
1168 }
1169 }
1170
1171 /* Vertices are ordered sequentially in the point representation. */
1172 for (i = 0; i < This->numvertices; i++)
1173 {
1174 point_reps[i] = i;
1175 }
1176
1177 /* Propagate vertices with low indices so as few vertices as possible
1178 * are used in the mesh.
1179 */
1180 for (face = 0; face < This->numfaces; face++)
1181 {
1182 hr = propagate_face_vertices(adjacency, point_reps, indices, new_indices, face, This->numfaces);
1183 if (FAILED(hr)) goto cleanup;
1184 }
1185 /* Go in opposite direction to catch all face orderings */
1186 for (face = 0; face < This->numfaces; face++)
1187 {
1188 hr = propagate_face_vertices(adjacency, point_reps,
1189 indices, new_indices,
1190 (This->numfaces - 1) - face, This->numfaces);
1191 if (FAILED(hr)) goto cleanup;
1192 }
1193
1194 hr = D3D_OK;
1195cleanup:
1196 if (This->options & D3DXMESH_32BIT)
1197 {
1198 if (indices) iface->lpVtbl->UnlockIndexBuffer(iface);
1199 }
1200 else
1201 {
1202 if (indices_16bit) iface->lpVtbl->UnlockIndexBuffer(iface);
1204 }
1205 HeapFree(GetProcessHeap(), 0, new_indices);
1206 return hr;
1207}
#define WARN(fmt,...)
Definition: precomp.h:61
#define ERR(fmt,...)
Definition: precomp.h:57
static HRESULT propagate_face_vertices(const DWORD *adjacency, DWORD *point_reps, const DWORD *indices, DWORD *new_indices, DWORD face, DWORD numfaces)
Definition: mesh.c:1054
WORD face[3]
Definition: mesh.c:4747
GLenum GLuint GLint GLenum face
Definition: glext.h:7025

◆ 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.

955{
956 HRESULT hr;
957 DWORD num_faces = iface->lpVtbl->GetNumFaces(iface);
958 DWORD num_vertices = iface->lpVtbl->GetNumVertices(iface);
959 DWORD options = iface->lpVtbl->GetOptions(iface);
960 BOOL indices_are_16_bit = !(options & D3DXMESH_32BIT);
961 DWORD *ib = NULL;
962 void *ib_ptr = NULL;
963 DWORD face;
964 DWORD edge;
965 struct edge_face_map edge_face_map = {0};
966 const DWORD *point_reps_ptr = NULL;
967 DWORD *id_point_reps = NULL;
968
969 TRACE("iface %p, point_reps %p, adjacency %p.\n", iface, point_reps, adjacency);
970
971 if (!adjacency) return D3DERR_INVALIDCALL;
972
973 if (!point_reps) /* Identity point reps */
974 {
975 id_point_reps = generate_identity_point_reps(num_vertices);
976 if (!id_point_reps)
977 {
979 goto cleanup;
980 }
981
982 point_reps_ptr = id_point_reps;
983 }
984 else
985 {
986 point_reps_ptr = point_reps;
987 }
988
989 hr = iface->lpVtbl->LockIndexBuffer(iface, D3DLOCK_READONLY, &ib_ptr);
990 if (FAILED(hr)) goto cleanup;
991
992 if (indices_are_16_bit)
993 {
994 /* Widen 16 bit to 32 bit */
995 DWORD i;
996 WORD *ib_16bit = ib_ptr;
997 ib = HeapAlloc(GetProcessHeap(), 0, 3 * num_faces * sizeof(DWORD));
998 if (!ib)
999 {
1000 hr = E_OUTOFMEMORY;
1001 goto cleanup;
1002 }
1003 for (i = 0; i < 3 * num_faces; i++)
1004 {
1005 ib[i] = ib_16bit[i];
1006 }
1007 }
1008 else
1009 {
1010 ib = ib_ptr;
1011 }
1012
1013 hr = init_edge_face_map(&edge_face_map, ib, point_reps_ptr, num_faces);
1014 if (FAILED(hr)) goto cleanup;
1015
1016 /* Create adjacency */
1017 for (face = 0; face < num_faces; face++)
1018 {
1019 for (edge = 0; edge < 3; edge++)
1020 {
1021 DWORD v1 = ib[3*face + edge];
1022 DWORD v2 = ib[3*face + (edge+1)%3];
1023 DWORD new_v1 = point_reps_ptr[v1];
1024 DWORD new_v2 = point_reps_ptr[v2];
1025 DWORD adj_face;
1026
1027 adj_face = find_adjacent_face(&edge_face_map, new_v1, new_v2, num_faces);
1028 adjacency[3*face + edge] = adj_face;
1029 }
1030 }
1031
1032 hr = D3D_OK;
1033cleanup:
1034 HeapFree(GetProcessHeap(), 0, id_point_reps);
1035 if (indices_are_16_bit) HeapFree(GetProcessHeap(), 0, ib);
1038 if(ib_ptr) iface->lpVtbl->UnlockIndexBuffer(iface);
1039 return hr;
1040}
static DWORD find_adjacent_face(struct edge_face_map *edge_face_map, DWORD vertex1, DWORD vertex2, DWORD num_faces)
Definition: mesh.c:923
static HRESULT init_edge_face_map(struct edge_face_map *edge_face_map, const DWORD *index_buffer, const DWORD *point_reps, DWORD num_faces)
Definition: mesh.c:882
static DWORD * generate_identity_point_reps(DWORD num_vertices)
Definition: mesh.c:936
GLfloat GLfloat v1
Definition: glext.h:6062
GLfloat GLfloat GLfloat v2
Definition: glext.h:6063
struct edge_face * entries
Definition: mesh.c:869
struct list * lists
Definition: mesh.c:868

◆ d3dx9_mesh_DrawSubset()

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

Definition at line 143 of file mesh.c.

144{
145 struct d3dx9_mesh *This = impl_from_ID3DXMesh(iface);
146 HRESULT hr;
147 DWORD face_start;
148 DWORD face_end = 0;
149 DWORD vertex_size;
150
151 TRACE("iface %p, attrib_id %u.\n", iface, attrib_id);
152
153 if (!This->vertex_declaration)
154 {
155 WARN("Can't draw a mesh with an invalid vertex declaration.\n");
156 return E_FAIL;
157 }
158
159 vertex_size = iface->lpVtbl->GetNumBytesPerVertex(iface);
160
161 hr = IDirect3DDevice9_SetVertexDeclaration(This->device, This->vertex_declaration);
162 if (FAILED(hr)) return hr;
163 hr = IDirect3DDevice9_SetStreamSource(This->device, 0, This->vertex_buffer, 0, vertex_size);
164 if (FAILED(hr)) return hr;
165 hr = IDirect3DDevice9_SetIndices(This->device, This->index_buffer);
166 if (FAILED(hr)) return hr;
167
168 while (face_end < This->numfaces)
169 {
170 for (face_start = face_end; face_start < This->numfaces; face_start++)
171 {
172 if (This->attrib_buffer[face_start] == attrib_id)
173 break;
174 }
175 if (face_start >= This->numfaces)
176 break;
177 for (face_end = face_start + 1; face_end < This->numfaces; face_end++)
178 {
179 if (This->attrib_buffer[face_end] != attrib_id)
180 break;
181 }
182
184 0, 0, This->numvertices, face_start * 3, face_end - face_start);
185 if (FAILED(hr)) return hr;
186 }
187
188 return D3D_OK;
189}
@ D3DPT_TRIANGLELIST
Definition: d3d8types.h:721
#define IDirect3DDevice9_SetIndices(p, a)
Definition: d3d9.h:1611
#define IDirect3DDevice9_DrawIndexedPrimitive(p, a, b, c, d, e, f)
Definition: d3d9.h:1589
#define IDirect3DDevice9_SetStreamSource(p, a, b, c, d)
Definition: d3d9.h:1607
#define IDirect3DDevice9_SetVertexDeclaration(p, a)
Definition: d3d9.h:1594
#define E_FAIL
Definition: ddrawi.h:102
DWORD numfaces
Definition: mesh.c:50

◆ d3dx9_mesh_GenerateAdjacency()

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

Definition at line 1224 of file mesh.c.

1225{
1226 struct d3dx9_mesh *This = impl_from_ID3DXMesh(iface);
1227 HRESULT hr;
1228 BYTE *vertices = NULL;
1229 const DWORD *indices = NULL;
1230 DWORD vertex_size;
1232 /* sort the vertices by (x + y + z) to quickly find coincident vertices */
1233 struct vertex_metadata *sorted_vertices;
1234 /* shared_indices links together identical indices in the index buffer so
1235 * that adjacency checks can be limited to faces sharing a vertex */
1236 DWORD *shared_indices = NULL;
1237 const FLOAT epsilon_sq = epsilon * epsilon;
1238 DWORD i;
1239
1240 TRACE("iface %p, epsilon %.8e, adjacency %p.\n", iface, epsilon, adjacency);
1241
1242 if (!adjacency)
1243 return D3DERR_INVALIDCALL;
1244
1245 buffer_size = This->numfaces * 3 * sizeof(*shared_indices) + This->numvertices * sizeof(*sorted_vertices);
1246 if (!(This->options & D3DXMESH_32BIT))
1247 buffer_size += This->numfaces * 3 * sizeof(*indices);
1248 shared_indices = HeapAlloc(GetProcessHeap(), 0, buffer_size);
1249 if (!shared_indices)
1250 return E_OUTOFMEMORY;
1251 sorted_vertices = (struct vertex_metadata*)(shared_indices + This->numfaces * 3);
1252
1253 hr = iface->lpVtbl->LockVertexBuffer(iface, D3DLOCK_READONLY, (void**)&vertices);
1254 if (FAILED(hr)) goto cleanup;
1255 hr = iface->lpVtbl->LockIndexBuffer(iface, D3DLOCK_READONLY, (void**)&indices);
1256 if (FAILED(hr)) goto cleanup;
1257
1258 if (!(This->options & D3DXMESH_32BIT)) {
1259 const WORD *word_indices = (const WORD*)indices;
1260 DWORD *dword_indices = (DWORD*)(sorted_vertices + This->numvertices);
1261 indices = dword_indices;
1262 for (i = 0; i < This->numfaces * 3; i++)
1263 *dword_indices++ = *word_indices++;
1264 }
1265
1266 vertex_size = iface->lpVtbl->GetNumBytesPerVertex(iface);
1267 for (i = 0; i < This->numvertices; i++) {
1268 D3DXVECTOR3 *vertex = (D3DXVECTOR3*)(vertices + vertex_size * i);
1269 sorted_vertices[i].first_shared_index = -1;
1270 sorted_vertices[i].key = vertex->x + vertex->y + vertex->z;
1271 sorted_vertices[i].vertex_index = i;
1272 }
1273 for (i = 0; i < This->numfaces * 3; i++) {
1274 DWORD *first_shared_index = &sorted_vertices[indices[i]].first_shared_index;
1275 shared_indices[i] = *first_shared_index;
1277 adjacency[i] = -1;
1278 }
1279 qsort(sorted_vertices, This->numvertices, sizeof(*sorted_vertices), compare_vertex_keys);
1280
1281 for (i = 0; i < This->numvertices; i++) {
1282 struct vertex_metadata *sorted_vertex_a = &sorted_vertices[i];
1283 D3DXVECTOR3 *vertex_a = (D3DXVECTOR3*)(vertices + sorted_vertex_a->vertex_index * vertex_size);
1284 DWORD shared_index_a = sorted_vertex_a->first_shared_index;
1285
1286 while (shared_index_a != -1) {
1287 DWORD j = i;
1288 DWORD shared_index_b = shared_indices[shared_index_a];
1289 struct vertex_metadata *sorted_vertex_b = sorted_vertex_a;
1290
1291 while (TRUE) {
1292 while (shared_index_b != -1) {
1293 /* faces are adjacent if they have another coincident vertex */
1294 DWORD base_a = (shared_index_a / 3) * 3;
1295 DWORD base_b = (shared_index_b / 3) * 3;
1296 BOOL adjacent = FALSE;
1297 int k;
1298
1299 for (k = 0; k < 3; k++) {
1300 if (adjacency[base_b + k] == shared_index_a / 3) {
1301 adjacent = TRUE;
1302 break;
1303 }
1304 }
1305 if (!adjacent) {
1306 for (k = 1; k <= 2; k++) {
1307 DWORD vertex_index_a = base_a + (shared_index_a + k) % 3;
1308 DWORD vertex_index_b = base_b + (shared_index_b + (3 - k)) % 3;
1309 adjacent = indices[vertex_index_a] == indices[vertex_index_b];
1310 if (!adjacent && epsilon >= 0.0f) {
1311 D3DXVECTOR3 delta = {0.0f, 0.0f, 0.0f};
1312 FLOAT length_sq;
1313
1314 D3DXVec3Subtract(&delta,
1315 (D3DXVECTOR3*)(vertices + indices[vertex_index_a] * vertex_size),
1316 (D3DXVECTOR3*)(vertices + indices[vertex_index_b] * vertex_size));
1317 length_sq = D3DXVec3LengthSq(&delta);
1318 adjacent = epsilon == 0.0f ? length_sq == 0.0f : length_sq < epsilon_sq;
1319 }
1320 if (adjacent) {
1321 DWORD adj_a = base_a + 2 - (vertex_index_a + shared_index_a + 1) % 3;
1322 DWORD adj_b = base_b + 2 - (vertex_index_b + shared_index_b + 1) % 3;
1323 if (adjacency[adj_a] == -1 && adjacency[adj_b] == -1) {
1324 adjacency[adj_a] = base_b / 3;
1325 adjacency[adj_b] = base_a / 3;
1326 break;
1327 }
1328 }
1329 }
1330 }
1331
1332 shared_index_b = shared_indices[shared_index_b];
1333 }
1334 while (++j < This->numvertices) {
1335 D3DXVECTOR3 *vertex_b;
1336
1337 sorted_vertex_b++;
1338 if (sorted_vertex_b->key - sorted_vertex_a->key > epsilon * 3.0f) {
1339 /* no more coincident vertices to try */
1340 j = This->numvertices;
1341 break;
1342 }
1343 /* check for coincidence */
1344 vertex_b = (D3DXVECTOR3*)(vertices + sorted_vertex_b->vertex_index * vertex_size);
1345 if (fabsf(vertex_a->x - vertex_b->x) <= epsilon &&
1346 fabsf(vertex_a->y - vertex_b->y) <= epsilon &&
1347 fabsf(vertex_a->z - vertex_b->z) <= epsilon)
1348 {
1349 break;
1350 }
1351 }
1352 if (j >= This->numvertices)
1353 break;
1354 shared_index_b = sorted_vertex_b->first_shared_index;
1355 }
1356
1357 sorted_vertex_a->first_shared_index = shared_indices[sorted_vertex_a->first_shared_index];
1358 shared_index_a = sorted_vertex_a->first_shared_index;
1359 }
1360 }
1361
1362 hr = D3D_OK;
1363cleanup:
1364 if (indices) iface->lpVtbl->UnlockIndexBuffer(iface);
1365 if (vertices) iface->lpVtbl->UnlockVertexBuffer(iface);
1366 HeapFree(GetProcessHeap(), 0, shared_indices);
1367 return hr;
1368}
static int __cdecl compare_vertex_keys(const void *a, const void *b)
Definition: mesh.c:1215
_Check_return_ __CRT_INLINE float __CRTDECL fabsf(_In_ float x)
Definition: math.h:179
int k
Definition: mpi.c:3369
void __cdecl qsort(_Inout_updates_bytes_(_NumOfElements *_SizeOfElements) void *_Base, _In_ size_t _NumOfElements, _In_ size_t _SizeOfElements, _In_ int(__cdecl *_PtFuncCompare)(const void *, const void *))
DWORD first_shared_index
Definition: mesh.c:1212
float key
Definition: mesh.c:1210
DWORD vertex_index
Definition: mesh.c:1211
Definition: mesh.c:4558
float x
Definition: hlsl.c:29
float y
Definition: hlsl.c:29
float z
Definition: hlsl.c:29
static void buffer_size(GLcontext *ctx, GLuint *width, GLuint *height)
Definition: swimpl.c:888

◆ 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.

844{
845 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
846
847 TRACE("iface %p, attrib_table %p, attrib_table_size %p.\n",
849
851 *attrib_table_size = mesh->attrib_table_size;
852
853 if (attrib_table)
854 memcpy(attrib_table, mesh->attrib_table, mesh->attrib_table_size * sizeof(*attrib_table));
855
856 return D3D_OK;
857}

◆ 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.

224{
225 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
226
227 TRACE("iface %p, declaration %p.\n", iface, declaration);
228
229 if (!declaration)
230 return D3DERR_INVALIDCALL;
231
232 copy_declaration(declaration, mesh->cached_declaration, mesh->num_elem);
233
234 return D3D_OK;
235}
static void copy_declaration(D3DVERTEXELEMENT9 *dst, const D3DVERTEXELEMENT9 *src, UINT num_elem)
Definition: mesh.c:218

◆ d3dx9_mesh_GetDevice()

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

Definition at line 255 of file mesh.c.

256{
257 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
258
259 TRACE("iface %p, device %p.\n", iface, device);
260
261 if (!device)
262 return D3DERR_INVALIDCALL;
263 *device = mesh->device;
265
266 return D3D_OK;
267}
#define IDirect3DDevice9_AddRef(p)
Definition: d3d9.h:1507

◆ d3dx9_mesh_GetFVF()

static DWORD WINAPI d3dx9_mesh_GetFVF ( ID3DXMesh *  iface)
static

Definition at line 209 of file mesh.c.

210{
211 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
212
213 TRACE("iface %p.\n", iface);
214
215 return mesh->fvf;
216}
DWORD fvf
Definition: mesh.c:205

◆ 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.

791{
792 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
793
794 TRACE("iface %p, index_buffer %p.\n", iface, index_buffer);
795
796 if (!index_buffer)
797 return D3DERR_INVALIDCALL;
798 *index_buffer = mesh->index_buffer;
799 IDirect3DIndexBuffer9_AddRef(mesh->index_buffer);
800
801 return D3D_OK;
802}
#define IDirect3DIndexBuffer9_AddRef(p)
Definition: d3d9.h:763
IDirect3DIndexBuffer9 * index_buffer
Definition: mesh.c:60

◆ d3dx9_mesh_GetNumBytesPerVertex()

static DWORD WINAPI d3dx9_mesh_GetNumBytesPerVertex ( ID3DXMesh *  iface)
static

Definition at line 237 of file mesh.c.

238{
239 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
240
241 TRACE("iface %p.\n", iface);
242
243 return mesh->vertex_declaration_size;
244}

◆ d3dx9_mesh_GetNumFaces()

static DWORD WINAPI d3dx9_mesh_GetNumFaces ( ID3DXMesh *  iface)
static

Definition at line 191 of file mesh.c.

192{
193 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
194
195 TRACE("iface %p.\n", iface);
196
197 return mesh->numfaces;
198}

◆ d3dx9_mesh_GetNumVertices()

static DWORD WINAPI d3dx9_mesh_GetNumVertices ( ID3DXMesh *  iface)
static

Definition at line 200 of file mesh.c.

201{
202 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
203
204 TRACE("iface %p.\n", iface);
205
206 return mesh->numvertices;
207}

◆ d3dx9_mesh_GetOptions()

static DWORD WINAPI d3dx9_mesh_GetOptions ( ID3DXMesh *  iface)
static

Definition at line 246 of file mesh.c.

247{
248 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
249
250 TRACE("iface %p.\n", iface);
251
252 return mesh->options;
253}

◆ 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.

776{
777 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
778
779 TRACE("iface %p, vertex_buffer %p.\n", iface, vertex_buffer);
780
781 if (!vertex_buffer)
782 return D3DERR_INVALIDCALL;
783 *vertex_buffer = mesh->vertex_buffer;
784 IDirect3DVertexBuffer9_AddRef(mesh->vertex_buffer);
785
786 return D3D_OK;
787}

◆ d3dx9_mesh_LockAttributeBuffer()

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

Definition at line 1429 of file mesh.c.

1430{
1431 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
1432
1433 TRACE("iface %p, flags %#x, data %p.\n", iface, flags, data);
1434
1435 InterlockedIncrement(&mesh->attrib_buffer_lock_count);
1436
1437 if (!(flags & D3DLOCK_READONLY))
1438 {
1439 D3DXATTRIBUTERANGE *attrib_table = mesh->attrib_table;
1440 mesh->attrib_table_size = 0;
1441 mesh->attrib_table = NULL;
1443 }
1444
1445 *data = mesh->attrib_buffer;
1446
1447 return D3D_OK;
1448}
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLbitfield flags
Definition: glext.h:7161

◆ d3dx9_mesh_LockIndexBuffer()

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

Definition at line 822 of file mesh.c.

823{
824 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
825
826 TRACE("iface %p, flags %#x, data %p.\n", iface, flags, data);
827
828 return IDirect3DIndexBuffer9_Lock(mesh->index_buffer, 0, 0, data, flags);
829}
#define IDirect3DIndexBuffer9_Lock(p, a, b, c, d)
Definition: d3d9.h:775

◆ d3dx9_mesh_LockVertexBuffer()

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

Definition at line 804 of file mesh.c.

805{
806 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
807
808 TRACE("iface %p, flags %#x, data %p.\n", iface, flags, data);
809
810 return IDirect3DVertexBuffer9_Lock(mesh->vertex_buffer, 0, 0, data, flags);
811}
#define IDirect3DVertexBuffer9_Lock(p, a, b, c, d)
Definition: d3d9.h:707

◆ 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.

1469{
1470 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
1471 HRESULT hr;
1473 ID3DXMesh *optimized_mesh;
1474
1475 TRACE("iface %p, flags %#x, adjacency_in %p, adjacency_out %p, face_remap %p, vertex_remap %p, opt_mesh %p.\n",
1476 iface, flags, adjacency_in, adjacency_out, face_remap, vertex_remap, opt_mesh);
1477
1478 if (!opt_mesh)
1479 return D3DERR_INVALIDCALL;
1480
1481 hr = iface->lpVtbl->GetDeclaration(iface, declaration);
1482 if (FAILED(hr)) return hr;
1483
1484 if (FAILED(hr = iface->lpVtbl->CloneMesh(iface, mesh->options, declaration, mesh->device, &optimized_mesh)))
1485 return hr;
1486
1487 hr = optimized_mesh->lpVtbl->OptimizeInplace(optimized_mesh, flags, adjacency_in, adjacency_out, face_remap, vertex_remap);
1488 if (SUCCEEDED(hr))
1489 *opt_mesh = optimized_mesh;
1490 else
1491 IUnknown_Release(optimized_mesh);
1492 return hr;
1493}
#define SUCCEEDED(hr)
Definition: intsafe.h:50

◆ 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.

1644{
1645 struct d3dx9_mesh *This = impl_from_ID3DXMesh(iface);
1646 void *indices = NULL;
1648 HRESULT hr;
1649 ID3DXBuffer *vertex_remap = NULL;
1650 DWORD *face_remap = NULL; /* old -> new mapping */
1651 DWORD *dword_indices = NULL;
1652 DWORD new_num_vertices = 0;
1653 DWORD new_num_alloc_vertices = 0;
1654 IDirect3DVertexBuffer9 *vertex_buffer = NULL;
1655 DWORD *sorted_attrib_buffer = NULL;
1656 DWORD i;
1657
1658 TRACE("iface %p, flags %#x, adjacency_in %p, adjacency_out %p, face_remap_out %p, vertex_remap_out %p.\n",
1659 iface, flags, adjacency_in, adjacency_out, face_remap_out, vertex_remap_out);
1660
1661 if (!flags)
1662 return D3DERR_INVALIDCALL;
1663 if (!adjacency_in && (flags & (D3DXMESHOPT_VERTEXCACHE | D3DXMESHOPT_STRIPREORDER)))
1664 return D3DERR_INVALIDCALL;
1666 return D3DERR_INVALIDCALL;
1667
1669 {
1671 FIXME("D3DXMESHOPT_VERTEXCACHE not implemented.\n");
1673 FIXME("D3DXMESHOPT_STRIPREORDER not implemented.\n");
1674 return E_NOTIMPL;
1675 }
1676
1677 hr = iface->lpVtbl->LockIndexBuffer(iface, 0, &indices);
1678 if (FAILED(hr)) goto cleanup;
1679
1680 dword_indices = HeapAlloc(GetProcessHeap(), 0, This->numfaces * 3 * sizeof(DWORD));
1681 if (!dword_indices) return E_OUTOFMEMORY;
1682 if (This->options & D3DXMESH_32BIT) {
1683 memcpy(dword_indices, indices, This->numfaces * 3 * sizeof(DWORD));
1684 } else {
1685 WORD *word_indices = indices;
1686 for (i = 0; i < This->numfaces * 3; i++)
1687 dword_indices[i] = *word_indices++;
1688 }
1689
1691 {
1692 new_num_alloc_vertices = This->numvertices;
1693 hr = compact_mesh(This, dword_indices, &new_num_vertices, &vertex_remap);
1694 if (FAILED(hr)) goto cleanup;
1695 } else if (flags & D3DXMESHOPT_ATTRSORT) {
1697 FIXME("D3DXMESHOPT_ATTRSORT vertex reordering not implemented.\n");
1698
1699 hr = iface->lpVtbl->LockAttributeBuffer(iface, 0, &attrib_buffer);
1700 if (FAILED(hr)) goto cleanup;
1701
1702 hr = remap_faces_for_attrsort(This, dword_indices, attrib_buffer, &sorted_attrib_buffer, &face_remap);
1703 if (FAILED(hr)) goto cleanup;
1704 }
1705
1706 if (vertex_remap)
1707 {
1708 /* reorder the vertices using vertex_remap */
1709 D3DVERTEXBUFFER_DESC vertex_desc;
1710 DWORD *vertex_remap_ptr = ID3DXBuffer_GetBufferPointer(vertex_remap);
1711 DWORD vertex_size = iface->lpVtbl->GetNumBytesPerVertex(iface);
1712 BYTE *orig_vertices;
1713 BYTE *new_vertices;
1714
1715 hr = IDirect3DVertexBuffer9_GetDesc(This->vertex_buffer, &vertex_desc);
1716 if (FAILED(hr)) goto cleanup;
1717
1718 hr = IDirect3DDevice9_CreateVertexBuffer(This->device, new_num_alloc_vertices * vertex_size,
1719 vertex_desc.Usage, This->fvf, vertex_desc.Pool, &vertex_buffer, NULL);
1720 if (FAILED(hr)) goto cleanup;
1721
1722 hr = IDirect3DVertexBuffer9_Lock(This->vertex_buffer, 0, 0, (void**)&orig_vertices, D3DLOCK_READONLY);
1723 if (FAILED(hr)) goto cleanup;
1724
1725 hr = IDirect3DVertexBuffer9_Lock(vertex_buffer, 0, 0, (void**)&new_vertices, 0);
1726 if (FAILED(hr)) {
1727 IDirect3DVertexBuffer9_Unlock(This->vertex_buffer);
1728 goto cleanup;
1729 }
1730
1731 for (i = 0; i < new_num_vertices; i++)
1732 memcpy(new_vertices + i * vertex_size, orig_vertices + vertex_remap_ptr[i] * vertex_size, vertex_size);
1733
1734 IDirect3DVertexBuffer9_Unlock(This->vertex_buffer);
1736 } else if (vertex_remap_out) {
1737 DWORD *vertex_remap_ptr;
1738
1739 hr = D3DXCreateBuffer(This->numvertices * sizeof(DWORD), &vertex_remap);
1740 if (FAILED(hr)) goto cleanup;
1741 vertex_remap_ptr = ID3DXBuffer_GetBufferPointer(vertex_remap);
1742 for (i = 0; i < This->numvertices; i++)
1743 *vertex_remap_ptr++ = i;
1744 }
1745
1747 {
1750
1751 attrib_table_size = count_attributes(sorted_attrib_buffer, This->numfaces);
1753 if (!attrib_table) {
1754 hr = E_OUTOFMEMORY;
1755 goto cleanup;
1756 }
1757
1758 memcpy(attrib_buffer, sorted_attrib_buffer, This->numfaces * sizeof(*attrib_buffer));
1759
1760 /* reorder the indices using face_remap */
1761 if (This->options & D3DXMESH_32BIT) {
1762 for (i = 0; i < This->numfaces; i++)
1763 memcpy((DWORD*)indices + face_remap[i] * 3, dword_indices + i * 3, 3 * sizeof(DWORD));
1764 } else {
1765 WORD *word_indices = indices;
1766 for (i = 0; i < This->numfaces; i++) {
1767 DWORD new_pos = face_remap[i] * 3;
1768 DWORD old_pos = i * 3;
1769 word_indices[new_pos++] = dword_indices[old_pos++];
1770 word_indices[new_pos++] = dword_indices[old_pos++];
1771 word_indices[new_pos] = dword_indices[old_pos];
1772 }
1773 }
1774
1776 This->options & D3DXMESH_32BIT, attrib_table);
1777
1778 HeapFree(GetProcessHeap(), 0, This->attrib_table);
1779 This->attrib_table = attrib_table;
1780 This->attrib_table_size = attrib_table_size;
1781 } else {
1782 if (This->options & D3DXMESH_32BIT) {
1783 memcpy(indices, dword_indices, This->numfaces * 3 * sizeof(DWORD));
1784 } else {
1785 WORD *word_indices = indices;
1786 for (i = 0; i < This->numfaces * 3; i++)
1787 *word_indices++ = dword_indices[i];
1788 }
1789 }
1790
1791 if (adjacency_out) {
1792 if (face_remap) {
1793 for (i = 0; i < This->numfaces; i++) {
1794 DWORD old_pos = i * 3;
1795 DWORD new_pos = face_remap[i] * 3;
1796 adjacency_out[new_pos++] = face_remap[adjacency_in[old_pos++]];
1797 adjacency_out[new_pos++] = face_remap[adjacency_in[old_pos++]];
1798 adjacency_out[new_pos++] = face_remap[adjacency_in[old_pos++]];
1799 }
1800 } else {
1801 memcpy(adjacency_out, adjacency_in, This->numfaces * 3 * sizeof(*adjacency_out));
1802 }
1803 }
1804 if (face_remap_out) {
1805 if (face_remap) {
1806 for (i = 0; i < This->numfaces; i++)
1807 face_remap_out[face_remap[i]] = i;
1808 } else {
1809 for (i = 0; i < This->numfaces; i++)
1810 face_remap_out[i] = i;
1811 }
1812 }
1813 if (vertex_remap_out)
1814 *vertex_remap_out = vertex_remap;
1815 vertex_remap = NULL;
1816
1817 if (vertex_buffer) {
1818 IDirect3DVertexBuffer9_Release(This->vertex_buffer);
1819 This->vertex_buffer = vertex_buffer;
1821 This->numvertices = new_num_vertices;
1822 }
1823
1824 hr = D3D_OK;
1825cleanup:
1826 HeapFree(GetProcessHeap(), 0, sorted_attrib_buffer);
1827 HeapFree(GetProcessHeap(), 0, face_remap);
1828 HeapFree(GetProcessHeap(), 0, dword_indices);
1829 if (vertex_remap) ID3DXBuffer_Release(vertex_remap);
1831 if (attrib_buffer) iface->lpVtbl->UnlockAttributeBuffer(iface);
1832 if (indices) iface->lpVtbl->UnlockIndexBuffer(iface);
1833 return hr;
1834}
#define IDirect3DVertexBuffer9_Unlock(p)
Definition: d3d9.h:708
#define IDirect3DVertexBuffer9_GetDesc(p, a)
Definition: d3d9.h:709
#define IDirect3DDevice9_CreateVertexBuffer(p, a, b, c, d, e, f)
Definition: d3d9.h:1533
struct ID3DXBuffer ID3DXBuffer
Definition: d3dx8core.h:51
#define ID3DXBuffer_Release(p)
Definition: d3dx9core.h:83
@ D3DXMESHOPT_STRIPREORDER
Definition: d3dx9mesh.h:76
@ D3DXMESHOPT_IGNOREVERTS
Definition: d3dx9mesh.h:77
@ D3DXMESHOPT_ATTRSORT
Definition: d3dx9mesh.h:74
@ D3DXMESHOPT_VERTEXCACHE
Definition: d3dx9mesh.h:75
@ D3DXMESHOPT_COMPACT
Definition: d3dx9mesh.h:73
#define E_NOTIMPL
Definition: ddrawi.h:99
static void fill_attribute_table(DWORD *attrib_buffer, DWORD numfaces, void *indices, BOOL is_32bit_indices, D3DXATTRIBUTERANGE *attrib_table)
Definition: mesh.c:1553
static HRESULT compact_mesh(struct d3dx9_mesh *This, DWORD *indices, DWORD *new_num_vertices, ID3DXBuffer **vertex_remap)
Definition: mesh.c:1497
static HRESULT remap_faces_for_attrsort(struct d3dx9_mesh *This, const DWORD *indices, DWORD *attrib_buffer, DWORD **sorted_attrib_buffer, DWORD **face_remap)
Definition: mesh.c:1607
static DWORD count_attributes(const DWORD *attrib_buffer, DWORD numfaces)
Definition: mesh.c:1539

◆ d3dx9_mesh_QueryInterface()

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

Definition at line 93 of file mesh.c.

94{
95 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
96
98 IsEqualGUID(riid, &IID_ID3DXBaseMesh) ||
99 IsEqualGUID(riid, &IID_ID3DXMesh))
100 {
101 iface->lpVtbl->AddRef(iface);
102 *out = iface;
103 return S_OK;
104 }
105
106 WARN("Interface %s not found.\n", debugstr_guid(riid));
107
108 return E_NOINTERFACE;
109}
const GUID IID_IUnknown
REFIID riid
Definition: atlbase.h:39
#define debugstr_guid
Definition: kernel32.h:35
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
static FILE * out
Definition: regtests2xml.c:44
#define E_NOINTERFACE
Definition: winerror.h:2364

◆ d3dx9_mesh_Release()

static ULONG WINAPI d3dx9_mesh_Release ( ID3DXMesh *  iface)
static

Definition at line 121 of file mesh.c.

122{
123 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
124 ULONG refcount = InterlockedDecrement(&mesh->ref);
125
126 TRACE("%p decreasing refcount to %u.\n", mesh, refcount);
127
128 if (!refcount)
129 {
130 IDirect3DIndexBuffer9_Release(mesh->index_buffer);
131 IDirect3DVertexBuffer9_Release(mesh->vertex_buffer);
132 if (mesh->vertex_declaration)
133 IDirect3DVertexDeclaration9_Release(mesh->vertex_declaration);
135 HeapFree(GetProcessHeap(), 0, mesh->attrib_buffer);
136 HeapFree(GetProcessHeap(), 0, mesh->attrib_table);
138 }
139
140 return refcount;
141}
#define InterlockedDecrement
Definition: armddk.h:52
#define IDirect3DVertexDeclaration9_Release(p)
Definition: d3d9.h:1185
#define IDirect3DDevice9_Release(p)
Definition: d3d9.h:1508
#define IDirect3DIndexBuffer9_Release(p)
Definition: d3d9.h:764

◆ 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.

1838{
1839 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
1840 D3DXATTRIBUTERANGE *new_table = NULL;
1841
1842 TRACE("iface %p, attrib_table %p, attrib_table_size %u.\n", iface, attrib_table, attrib_table_size);
1843
1844 if (attrib_table_size) {
1845 size_t size = attrib_table_size * sizeof(*attrib_table);
1846
1847 new_table = HeapAlloc(GetProcessHeap(), 0, size);
1848 if (!new_table)
1849 return E_OUTOFMEMORY;
1850
1851 CopyMemory(new_table, attrib_table, size);
1852 } else if (attrib_table) {
1853 return D3DERR_INVALIDCALL;
1854 }
1855 HeapFree(GetProcessHeap(), 0, mesh->attrib_table);
1856 mesh->attrib_table = new_table;
1857 mesh->attrib_table_size = attrib_table_size;
1858
1859 return D3D_OK;
1860}
GLsizeiptr size
Definition: glext.h:5919
#define CopyMemory
Definition: winbase.h:1710

◆ d3dx9_mesh_UnlockAttributeBuffer()

static HRESULT WINAPI d3dx9_mesh_UnlockAttributeBuffer ( ID3DXMesh *  iface)
static

Definition at line 1450 of file mesh.c.

1451{
1452 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
1453 int lock_count;
1454
1455 TRACE("iface %p.\n", iface);
1456
1457 lock_count = InterlockedDecrement(&mesh->attrib_buffer_lock_count);
1458 if (lock_count < 0)
1459 {
1460 InterlockedIncrement(&mesh->attrib_buffer_lock_count);
1461 return D3DERR_INVALIDCALL;
1462 }
1463
1464 return D3D_OK;
1465}

◆ d3dx9_mesh_UnlockIndexBuffer()

static HRESULT WINAPI d3dx9_mesh_UnlockIndexBuffer ( ID3DXMesh *  iface)
static

Definition at line 831 of file mesh.c.

832{
833 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
834
835 TRACE("iface %p.\n", iface);
836
837 return IDirect3DIndexBuffer9_Unlock(mesh->index_buffer);
838}
#define IDirect3DIndexBuffer9_Unlock(p)
Definition: d3d9.h:776

◆ d3dx9_mesh_UnlockVertexBuffer()

static HRESULT WINAPI d3dx9_mesh_UnlockVertexBuffer ( ID3DXMesh *  iface)
static

Definition at line 813 of file mesh.c.

814{
815 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
816
817 TRACE("iface %p.\n", iface);
818
819 return IDirect3DVertexBuffer9_Unlock(mesh->vertex_buffer);
820}

◆ 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.

1371{
1372 struct d3dx9_mesh *This = impl_from_ID3DXMesh(iface);
1373 HRESULT hr;
1375 int i;
1376
1377 TRACE("iface %p, declaration %p.\n", iface, declaration);
1378
1379 if (!declaration)
1380 {
1381 WARN("Invalid declaration. Can't use NULL declaration.\n");
1382 return D3DERR_INVALIDCALL;
1383 }
1384
1385 /* New declaration must be same size as original */
1387 if (vertex_declaration_size != This->vertex_declaration_size)
1388 {
1389 WARN("Invalid declaration. New vertex size does not match the original vertex size.\n");
1390 return D3DERR_INVALIDCALL;
1391 }
1392
1393 /* New declaration must not contain non-zero Stream value */
1394 for (i = 0; declaration[i].Stream != 0xff; i++)
1395 {
1396 if (declaration[i].Stream != 0)
1397 {
1398 WARN("Invalid declaration. New declaration contains non-zero Stream value.\n");
1399 return D3DERR_INVALIDCALL;
1400 }
1401 }
1402
1403 This->num_elem = i + 1;
1404 copy_declaration(This->cached_declaration, declaration, This->num_elem);
1405
1406 if (This->vertex_declaration)
1407 IDirect3DVertexDeclaration9_Release(This->vertex_declaration);
1408
1409 /* An application can pass an invalid declaration to UpdateSemantics and
1410 * still expect D3D_OK (see tests). If the declaration is invalid, then
1411 * subsequent calls to DrawSubset will fail. This is handled by setting the
1412 * vertex declaration to NULL.
1413 * GetDeclaration, GetNumBytesPerVertex must, however, use the new
1414 * invalid declaration. This is handled by them using the cached vertex
1415 * declaration instead of the actual vertex declaration.
1416 */
1419 &This->vertex_declaration);
1420 if (FAILED(hr))
1421 {
1422 WARN("Using invalid declaration. Calls to DrawSubset will fail.\n");
1423 This->vertex_declaration = NULL;
1424 }
1425
1426 return D3D_OK;
1427}
#define IDirect3DDevice9_CreateVertexDeclaration(p, a, b)
Definition: d3d9.h:1593
UINT WINAPI D3DXGetDeclVertexSize(const D3DVERTEXELEMENT9 *decl, DWORD stream_idx)
Definition: mesh.c:2323
static IStream Stream
Definition: htmldoc.c:1115
UINT vertex_declaration_size
Definition: mesh.c:57

◆ D3DXBoxBoundProbe()

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

Definition at line 1911 of file mesh.c.

1913{
1914 FLOAT div, tmin, tmax, tymin, tymax, tzmin, tzmax;
1915
1916 div = 1.0f / praydirection->x;
1917 if ( div >= 0.0f )
1918 {
1919 tmin = ( pmin->x - prayposition->x ) * div;
1920 tmax = ( pmax->x - prayposition->x ) * div;
1921 }
1922 else
1923 {
1924 tmin = ( pmax->x - prayposition->x ) * div;
1925 tmax = ( pmin->x - prayposition->x ) * div;
1926 }
1927
1928 if ( tmax < 0.0f ) return FALSE;
1929
1930 div = 1.0f / praydirection->y;
1931 if ( div >= 0.0f )
1932 {
1933 tymin = ( pmin->y - prayposition->y ) * div;
1934 tymax = ( pmax->y - prayposition->y ) * div;
1935 }
1936 else
1937 {
1938 tymin = ( pmax->y - prayposition->y ) * div;
1939 tymax = ( pmin->y - prayposition->y ) * div;
1940 }
1941
1942 if ( ( tymax < 0.0f ) || ( tmin > tymax ) || ( tymin > tmax ) ) return FALSE;
1943
1944 if ( tymin > tmin ) tmin = tymin;
1945 if ( tymax < tmax ) tmax = tymax;
1946
1947 div = 1.0f / praydirection->z;
1948 if ( div >= 0.0f )
1949 {
1950 tzmin = ( pmin->z - prayposition->z ) * div;
1951 tzmax = ( pmax->z - prayposition->z ) * div;
1952 }
1953 else
1954 {
1955 tzmin = ( pmax->z - prayposition->z ) * div;
1956 tzmax = ( pmin->z - prayposition->z ) * div;
1957 }
1958
1959 if ( (tzmax < 0.0f ) || ( tmin > tzmax ) || ( tzmin > tmax ) ) return FALSE;
1960
1961 return TRUE;
1962}
_STLP_VENDOR_CSTD::ldiv_t div(long __x, long __y)
Definition: _cstdlib.h:137

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.

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

◆ D3DXComputeBoundingBox()

HRESULT WINAPI D3DXComputeBoundingBox ( const D3DXVECTOR3 pfirstposition,
DWORD  numvertices,
DWORD  dwstride,
D3DXVECTOR3 pmin,
D3DXVECTOR3 pmax 
)

Definition at line 1964 of file mesh.c.

1966{
1968 unsigned int i;
1969
1970 if( !pfirstposition || !pmin || !pmax ) return D3DERR_INVALIDCALL;
1971
1972 *pmin = *pfirstposition;
1973 *pmax = *pmin;
1974
1975 for(i=0; i<numvertices; i++)
1976 {
1977 vec = *( (const D3DXVECTOR3*)((const char*)pfirstposition + dwstride * i) );
1978
1979 if ( vec.x < pmin->x ) pmin->x = vec.x;
1980 if ( vec.x > pmax->x ) pmax->x = vec.x;
1981
1982 if ( vec.y < pmin->y ) pmin->y = vec.y;
1983 if ( vec.y > pmax->y ) pmax->y = vec.y;
1984
1985 if ( vec.z < pmin->z ) pmin->z = vec.z;
1986 if ( vec.z > pmax->z ) pmax->z = vec.z;
1987 }
1988
1989 return D3D_OK;
1990}
FT_Pos x
Definition: ftimage.h:76
FT_Pos y
Definition: ftimage.h:77

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.

1994{
1996 FLOAT d;
1997 unsigned int i;
1998
1999 if( !pfirstposition || !pcenter || !pradius ) return D3DERR_INVALIDCALL;
2000
2001 temp.x = 0.0f;
2002 temp.y = 0.0f;
2003 temp.z = 0.0f;
2004 *pradius = 0.0f;
2005
2006 for(i=0; i<numvertices; i++)
2007 D3DXVec3Add(&temp, &temp, (const D3DXVECTOR3*)((const char*)pfirstposition + dwstride * i));
2008
2009 D3DXVec3Scale(pcenter, &temp, 1.0f / numvertices);
2010
2011 for(i=0; i<numvertices; i++)
2012 {
2013 d = D3DXVec3Length(D3DXVec3Subtract(&temp, (const D3DXVECTOR3*)((const char*)pfirstposition + dwstride * i), pcenter));
2014 if ( d > *pradius ) *pradius = d;
2015 }
2016 return D3D_OK;
2017}
#define d
Definition: ke_i.h:81
static calc_node_t temp
Definition: rpn_ieee.c:38

Referenced by D3DXComputeBoundingSphereTest().

◆ D3DXComputeNormals()

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

Definition at line 7563 of file mesh.c.

7564{
7565 TRACE("mesh %p, adjacency %p\n", mesh, adjacency);
7566
7567 if (mesh && (ID3DXMeshVtbl *)mesh->lpVtbl != &D3DXMesh_Vtbl)
7568 {
7569 ERR("Invalid virtual table\n");
7570 return D3DERR_INVALIDCALL;
7571 }
7572
7573 return D3DXComputeTangentFrameEx((ID3DXMesh *)mesh, D3DX_DEFAULT, 0,
7576 adjacency, -1.01f, -0.01f, -1.01f, NULL, NULL);
7577}
@ D3DDECLUSAGE_NORMAL
Definition: d3d9types.h:223
#define D3DX_DEFAULT
Definition: d3dx9.h:24
@ D3DXTANGENT_CALCULATE_NORMALS
Definition: d3dx9mesh.h:121
@ D3DXTANGENT_GENERATE_IN_PLACE
Definition: d3dx9mesh.h:122
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: mesh.c:7320
static const struct ID3DXMeshVtbl D3DXMesh_Vtbl
Definition: mesh.c:1862

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.

7547{
7548 TRACE("mesh %p, stage_idx %d, tangent_idx %d, binorm_idx %d, wrap %d, adjacency %p.\n",
7549 mesh, stage_idx, tangent_idx, binorm_idx, wrap, adjacency);
7550
7552 ( binorm_idx == D3DX_DEFAULT ) ? D3DX_DEFAULT : D3DDECLUSAGE_BINORMAL,
7553 binorm_idx,
7554 ( tangent_idx == D3DX_DEFAULT ) ? D3DX_DEFAULT : D3DDECLUSAGE_TANGENT,
7555 tangent_idx, D3DX_DEFAULT, 0,
7557 adjacency, -1.01f, -0.01f, -1.01f, NULL, NULL);
7558}
@ D3DDECLUSAGE_TANGENT
Definition: d3d9types.h:226
@ D3DDECLUSAGE_BINORMAL
Definition: d3d9types.h:227
@ D3DDECLUSAGE_TEXCOORD
Definition: d3d9types.h:225
@ D3DXTANGENT_ORTHOGONALIZE_FROM_U
Definition: d3dx9mesh.h:117
@ D3DXTANGENT_WRAP_UV
Definition: d3dx9mesh.h:113
#define wrap(journal, var)
Definition: recovery.c:207

◆ 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.

7325{
7326 HRESULT hr;
7327 void *indices = NULL;
7328 BYTE *vertices = NULL;
7329 DWORD *point_reps = NULL;
7330 size_t normal_size;
7331 BOOL indices_are_32bit;
7332 DWORD i, j, num_faces, num_vertices, vertex_stride;
7334 D3DVERTEXELEMENT9 *position_declaration = NULL, *normal_declaration = NULL;
7336
7337 TRACE("mesh %p, texture_in_semantic %u, texture_in_index %u, u_partial_out_semantic %u, u_partial_out_index %u, "
7338 "v_partial_out_semantic %u, v_partial_out_index %u, normal_out_semantic %u, normal_out_index %u, "
7339 "options %#x, adjacency %p, partial_edge_threshold %f, singular_point_threshold %f, "
7340 "normal_edge_threshold %f, mesh_out %p, vertex_mapping %p\n",
7341 mesh, texture_in_semantic, texture_in_index, u_partial_out_semantic, u_partial_out_index,
7342 v_partial_out_semantic, v_partial_out_index, normal_out_semantic, normal_out_index, options, adjacency,
7343 partial_edge_threshold, singular_point_threshold, normal_edge_threshold, mesh_out, vertex_mapping);
7344
7345 if (!mesh)
7346 {
7347 WARN("mesh is NULL\n");
7348 return D3DERR_INVALIDCALL;
7349 }
7350
7351 if (weighting_method == (D3DXTANGENT_WEIGHT_EQUAL | D3DXTANGENT_WEIGHT_BY_AREA))
7352 {
7353 WARN("D3DXTANGENT_WEIGHT_BY_AREA and D3DXTANGENT_WEIGHT_EQUAL are mutally exclusive\n");
7354 return D3DERR_INVALIDCALL;
7355 }
7356
7357 if (u_partial_out_semantic != D3DX_DEFAULT)
7358 {
7359 FIXME("tangent vectors computation is not supported\n");
7360 return E_NOTIMPL;
7361 }
7362
7363 if (v_partial_out_semantic != D3DX_DEFAULT)
7364 {
7365 FIXME("binormal vectors computation is not supported\n");
7366 return E_NOTIMPL;
7367 }
7368
7370 {
7371 FIXME("unsupported options %#x\n", options);
7372 return E_NOTIMPL;
7373 }
7374
7376 {
7377 FIXME("only normals computation is supported\n");
7378 return E_NOTIMPL;
7379 }
7380
7381 if (!(options & D3DXTANGENT_GENERATE_IN_PLACE) || mesh_out || vertex_mapping)
7382 {
7383 FIXME("only D3DXTANGENT_GENERATE_IN_PLACE is supported\n");
7384 return E_NOTIMPL;
7385 }
7386
7387 if (FAILED(hr = mesh->lpVtbl->GetDeclaration(mesh, declaration)))
7388 return hr;
7389
7390 for (i = 0; declaration[i].Stream != 0xff; i++)
7391 {
7392 if (declaration[i].Usage == D3DDECLUSAGE_POSITION && !declaration[i].UsageIndex)
7393 position_declaration = &declaration[i];
7394 if (declaration[i].Usage == normal_out_semantic && declaration[i].UsageIndex == normal_out_index)
7395 normal_declaration = &declaration[i];
7396 }
7397
7398 if (!position_declaration || !normal_declaration)
7399 return D3DERR_INVALIDCALL;
7400
7401 if (normal_declaration->Type == D3DDECLTYPE_FLOAT3)
7402 {
7403 normal_size = sizeof(D3DXVECTOR3);
7404 }
7405 else if (normal_declaration->Type == D3DDECLTYPE_FLOAT4)
7406 {
7407 normal_size = sizeof(D3DXVECTOR4);
7408 }
7409 else
7410 {
7411 WARN("unsupported normals type %u\n", normal_declaration->Type);
7412 return D3DERR_INVALIDCALL;
7413 }
7414
7415 num_faces = mesh->lpVtbl->GetNumFaces(mesh);
7416 num_vertices = mesh->lpVtbl->GetNumVertices(mesh);
7417 vertex_stride = mesh->lpVtbl->GetNumBytesPerVertex(mesh);
7418 indices_are_32bit = mesh->lpVtbl->GetOptions(mesh) & D3DXMESH_32BIT;
7419
7420 point_reps = HeapAlloc(GetProcessHeap(), 0, num_vertices * sizeof(*point_reps));
7421 if (!point_reps)
7422 {
7423 hr = E_OUTOFMEMORY;
7424 goto done;
7425 }
7426
7427 if (adjacency)
7428 {
7429 if (FAILED(hr = mesh->lpVtbl->ConvertAdjacencyToPointReps(mesh, adjacency, point_reps)))
7430 goto done;
7431 }
7432 else
7433 {
7434 for (i = 0; i < num_vertices; i++)
7435 point_reps[i] = i;
7436 }
7437
7438 if (FAILED(hr = mesh->lpVtbl->LockIndexBuffer(mesh, 0, &indices)))
7439 goto done;
7440
7441 if (FAILED(hr = mesh->lpVtbl->LockVertexBuffer(mesh, 0, (void **)&vertices)))
7442 goto done;
7443
7444 for (i = 0; i < num_vertices; i++)
7445 {
7446 static const D3DXVECTOR4 default_vector = {0.0f, 0.0f, 0.0f, 1.0f};
7447 void *normal = vertices + normal_declaration->Offset + i * vertex_stride;
7448
7449 memcpy(normal, &default_vector, normal_size);
7450 }
7451
7452 for (i = 0; i < num_faces; i++)
7453 {
7454 float denominator, weights[3];
7455 D3DXVECTOR3 a, b, cross, face_normal;
7456 const DWORD face_indices[3] =
7457 {
7458 read_ib(indices, indices_are_32bit, 3 * i + 0),
7459 read_ib(indices, indices_are_32bit, 3 * i + 1),
7460 read_ib(indices, indices_are_32bit, 3 * i + 2)
7461 };
7462 const D3DXVECTOR3 v0 = read_vec3(vertices, position_declaration, vertex_stride, face_indices[0]);
7463 const D3DXVECTOR3 v1 = read_vec3(vertices, position_declaration, vertex_stride, face_indices[1]);
7464 const D3DXVECTOR3 v2 = read_vec3(vertices, position_declaration, vertex_stride, face_indices[2]);
7465
7466 D3DXVec3Cross(&cross, D3DXVec3Subtract(&a, &v0, &v1), D3DXVec3Subtract(&b, &v0, &v2));
7467
7468 switch (weighting_method)
7469 {
7471 weights[0] = weights[1] = weights[2] = 1.0f;
7472 break;
7474 weights[0] = weights[1] = weights[2] = D3DXVec3Length(&cross);
7475 break;
7476 default:
7477 /* weight by angle */
7478 denominator = D3DXVec3Length(&a) * D3DXVec3Length(&b);
7479 if (!denominator)
7480 weights[0] = 0.0f;
7481 else
7482 weights[0] = acosf(D3DXVec3Dot(&a, &b) / denominator);
7483
7484 D3DXVec3Subtract(&a, &v1, &v0);
7485 D3DXVec3Subtract(&b, &v1, &v2);
7486 denominator = D3DXVec3Length(&a) * D3DXVec3Length(&b);
7487 if (!denominator)
7488 weights[1] = 0.0f;
7489 else
7490 weights[1] = acosf(D3DXVec3Dot(&a, &b) / denominator);
7491
7492 D3DXVec3Subtract(&a, &v2, &v0);
7493 D3DXVec3Subtract(&b, &v2, &v1);
7494 denominator = D3DXVec3Length(&a) * D3DXVec3Length(&b);
7495 if (!denominator)
7496 weights[2] = 0.0f;
7497 else
7498 weights[2] = acosf(D3DXVec3Dot(&a, &b) / denominator);
7499
7500 break;
7501 }
7502
7503 D3DXVec3Normalize(&face_normal, &cross);
7504
7505 for (j = 0; j < 3; j++)
7506 {
7508 DWORD rep_index = point_reps[face_indices[j]];
7509 D3DXVECTOR3 *rep_normal = vertex_element_vec3(vertices, normal_declaration, vertex_stride, rep_index);
7510
7511 D3DXVec3Scale(&normal, &face_normal, weights[j]);
7512 D3DXVec3Add(rep_normal, rep_normal, &normal);
7513 }
7514 }
7515
7516 for (i = 0; i < num_vertices; i++)
7517 {
7518 DWORD rep_index = point_reps[i];
7519 D3DXVECTOR3 *normal = vertex_element_vec3(vertices, normal_declaration, vertex_stride, i);
7520 D3DXVECTOR3 *rep_normal = vertex_element_vec3(vertices, normal_declaration, vertex_stride, rep_index);
7521
7522 if (i == rep_index)
7523 D3DXVec3Normalize(rep_normal, rep_normal);
7524 else
7525 *normal = *rep_normal;
7526 }
7527
7528 hr = D3D_OK;
7529
7530done:
7531 if (vertices)
7532 mesh->lpVtbl->UnlockVertexBuffer(mesh);
7533
7534 if (indices)
7535 mesh->lpVtbl->UnlockIndexBuffer(mesh);
7536
7537 HeapFree(GetProcessHeap(), 0, point_reps);
7538
7539 return hr;
7540}
@ D3DDECLUSAGE_POSITION
Definition: d3d9types.h:220
struct _D3DVECTOR D3DXVECTOR3
Definition: d3dx9math.h:97
@ D3DXTANGENT_WEIGHT_BY_AREA
Definition: d3dx9mesh.h:118
@ D3DXTANGENT_WEIGHT_EQUAL
Definition: d3dx9mesh.h:119
D3DXVECTOR3 *WINAPI D3DXVec3Normalize(D3DXVECTOR3 *pout, const D3DXVECTOR3 *pv)
Definition: math.c:1805
static D3DXVECTOR3 read_vec3(BYTE *vertices, const D3DVERTEXELEMENT9 *declaration, DWORD vertex_stride, DWORD index)
Definition: mesh.c:7290
static DWORD read_ib(void *index_buffer, BOOL indices_are_32bit, DWORD index)
Definition: mesh.c:6951
static D3DXVECTOR3 * vertex_element_vec3(BYTE *vertices, const D3DVERTEXELEMENT9 *declaration, DWORD vertex_stride, DWORD index)
Definition: mesh.c:7284
GLfloat v0
Definition: glext.h:6061
const GLbyte * weights
Definition: glext.h:6523
_Must_inspect_result_ _In_ USAGE _In_ USHORT _In_ USAGE Usage
Definition: hidpi.h:384
_Check_return_ float __cdecl acosf(_In_ float x)
Definition: math.h:219
@ normal
Definition: optimize.h:166
static void cross(float v1[3], float v2[3], float result[3])
Definition: project.c:100

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.

7602{
7603 FIXME("mesh_in %p, attribute_id %u, ib_flags %u, index_buffer %p, index_count %p stub.\n",
7604 mesh_in, attribute_id, ib_flags, index_buffer, index_count);
7605
7606 return E_NOTIMPL;
7607}

◆ 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.

4655{
4656 HRESULT hr;
4657 ID3DXMesh *box;
4658 struct vertex *vertices;
4659 WORD (*faces)[3];
4660 DWORD *adjacency_buf;
4661 unsigned int i, face;
4662 static const D3DXVECTOR3 unit_box[] =
4663 {
4664 {-0.5f, -0.5f, -0.5f}, {-0.5f, -0.5f, 0.5f}, {-0.5f, 0.5f, 0.5f}, {-0.5f, 0.5f, -0.5f},
4665 {-0.5f, 0.5f, -0.5f}, {-0.5f, 0.5f, 0.5f}, { 0.5f, 0.5f, 0.5f}, { 0.5f, 0.5f, -0.5f},
4666 { 0.5f, 0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f}, { 0.5f, -0.5f, 0.5f}, { 0.5f, -0.5f, -0.5f},
4667 {-0.5f, -0.5f, 0.5f}, {-0.5f, -0.5f, -0.5f}, { 0.5f, -0.5f, -0.5f}, { 0.5f, -0.5f, 0.5f},
4668 {-0.5f, -0.5f, 0.5f}, { 0.5f, -0.5f, 0.5f}, { 0.5f, 0.5f, 0.5f}, {-0.5f, 0.5f, 0.5f},
4669 {-0.5f, -0.5f, -0.5f}, {-0.5f, 0.5f, -0.5f}, { 0.5f, 0.5f, -0.5f}, { 0.5f, -0.5f, -0.5f}
4670 };
4671 static const D3DXVECTOR3 normals[] =
4672 {
4673 {-1.0f, 0.0f, 0.0f}, { 0.0f, 1.0f, 0.0f}, { 1.0f, 0.0f, 0.0f},
4674 { 0.0f, -1.0f, 0.0f}, { 0.0f, 0.0f, 1.0f}, { 0.0f, 0.0f, -1.0f}
4675 };
4676 static const DWORD adjacency_table[] =
4677 {
4678 6, 9, 1, 2, 10, 0, 1, 9, 3, 4, 10, 2,
4679 3, 8, 5, 7, 11, 4, 0, 11, 7, 5, 8, 6,
4680 7, 4, 9, 2, 0, 8, 1, 3, 11, 5, 6, 10
4681 };
4682
4683 TRACE("device %p, width %f, height %f, depth %f, mesh %p, adjacency %p\n",
4684 device, width, height, depth, mesh, adjacency);
4685
4686 if (!device || width < 0.0f || height < 0.0f || depth < 0.0f || !mesh)
4687 {
4688 return D3DERR_INVALIDCALL;
4689 }
4690
4692 {
4693 return hr;
4694 }
4695
4696 if (FAILED(hr = box->lpVtbl->LockVertexBuffer(box, 0, (void **)&vertices)))
4697 {
4698 box->lpVtbl->Release(box);
4699 return hr;
4700 }
4701
4702 if (FAILED(hr = box->lpVtbl->LockIndexBuffer(box, 0, (void **)&faces)))
4703 {
4704 box->lpVtbl->UnlockVertexBuffer(box);
4705 box->lpVtbl->Release(box);
4706 return hr;
4707 }
4708
4709 for (i = 0; i < 24; i++)
4710 {
4711 vertices[i].position.x = width * unit_box[i].x;
4712 vertices[i].position.y = height * unit_box[i].y;
4713 vertices[i].position.z = depth * unit_box[i].z;
4714 vertices[i].normal.x = normals[i / 4].x;
4715 vertices[i].normal.y = normals[i / 4].y;
4716 vertices[i].normal.z = normals[i / 4].z;
4717 }
4718
4719 face = 0;
4720 for (i = 0; i < 12; i++)
4721 {
4722 faces[i][0] = face++;
4723 faces[i][1] = face++;
4724 faces[i][2] = (i % 2) ? face - 4 : face;
4725 }
4726
4727 box->lpVtbl->UnlockIndexBuffer(box);
4728 box->lpVtbl->UnlockVertexBuffer(box);
4729
4730 if (adjacency)
4731 {
4732 if (FAILED(hr = D3DXCreateBuffer(sizeof(adjacency_table), adjacency)))
4733 {
4734 box->lpVtbl->Release(box);
4735 return hr;
4736 }
4737
4738 adjacency_buf = ID3DXBuffer_GetBufferPointer(*adjacency);
4739 memcpy(adjacency_buf, adjacency_table, sizeof(adjacency_table));
4740 }
4741
4742 *mesh = box;
4743
4744 return D3D_OK;
4745}
#define D3DFVF_XYZ
Definition: d3d8types.h:113
#define D3DFVF_NORMAL
Definition: d3d8types.h:120
@ D3DXMESH_MANAGED
Definition: d3dx9mesh.h:64
HRESULT WINAPI D3DXCreateMeshFVF(DWORD numfaces, DWORD numvertices, DWORD options, DWORD fvf, struct IDirect3DDevice9 *device, struct ID3DXMesh **mesh)
Definition: mesh.c:2596
GLint GLint GLsizei GLsizei GLsizei depth
Definition: gl.h:1546
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
GLint GLint GLsizei width
Definition: gl.h:1546
Definition: palette.c:468

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.

4977{
4978 DWORD number_of_vertices, number_of_faces;
4979 HRESULT hr;
4980 ID3DXMesh *cylinder;
4981 struct vertex *vertices;
4982 face *faces;
4983 float theta_step, theta_start;
4984 struct sincos_table theta;
4985 float delta_radius, radius, radius_step;
4986 float z, z_step, z_normal;
4988
4989 TRACE("(%p, %f, %f, %f, %u, %u, %p, %p)\n", device, radius1, radius2, length, slices, stacks, mesh, adjacency);
4990
4991 if (device == NULL || radius1 < 0.0f || radius2 < 0.0f || length < 0.0f || slices < 2 || stacks < 1 || mesh == NULL)
4992 {
4993 return D3DERR_INVALIDCALL;
4994 }
4995
4996 number_of_vertices = 2 + (slices * (3 + stacks));
4997 number_of_faces = 2 * slices + stacks * (2 * slices);
4998
4999 hr = D3DXCreateMeshFVF(number_of_faces, number_of_vertices, D3DXMESH_MANAGED,
5001 if (FAILED(hr))
5002 {
5003 return hr;
5004 }
5005
5006 if (FAILED(hr = cylinder->lpVtbl->LockVertexBuffer(cylinder, 0, (void **)&vertices)))
5007 {
5008 cylinder->lpVtbl->Release(cylinder);
5009 return hr;
5010 }
5011
5012 if (FAILED(hr = cylinder->lpVtbl->LockIndexBuffer(cylinder, 0, (void **)&faces)))
5013 {
5014 cylinder->lpVtbl->UnlockVertexBuffer(cylinder);
5015 cylinder->lpVtbl->Release(cylinder);
5016 return hr;
5017 }
5018
5019 /* theta = angle on xy plane wrt x axis */
5020 theta_step = -2.0f * D3DX_PI / slices;
5021 theta_start = D3DX_PI / 2.0f;
5022
5023 if (!compute_sincos_table(&theta, theta_start, theta_step, slices))
5024 {
5025 cylinder->lpVtbl->UnlockIndexBuffer(cylinder);
5026 cylinder->lpVtbl->UnlockVertexBuffer(cylinder);
5027 cylinder->lpVtbl->Release(cylinder);
5028 return E_OUTOFMEMORY;
5029 }
5030
5031 vertex = 0;
5032 face = 0;
5033
5034 delta_radius = radius1 - radius2;
5035 radius = radius1;
5036 radius_step = delta_radius / stacks;
5037
5038 z = -length / 2;
5039 z_step = length / stacks;
5040 z_normal = delta_radius / length;
5041 if (isnan(z_normal))
5042 {
5043 z_normal = 0.0f;
5044 }
5045
5046 vertices[vertex].normal.x = 0.0f;
5047 vertices[vertex].normal.y = 0.0f;
5048 vertices[vertex].normal.z = -1.0f;
5049 vertices[vertex].position.x = 0.0f;
5050 vertices[vertex].position.y = 0.0f;
5051 vertices[vertex++].position.z = z;
5052
5053 for (slice = 0; slice < slices; slice++, vertex++)
5054 {
5055 vertices[vertex].normal.x = 0.0f;
5056 vertices[vertex].normal.y = 0.0f;
5057 vertices[vertex].normal.z = -1.0f;
5058 vertices[vertex].position.x = radius * theta.cos[slice];
5059 vertices[vertex].position.y = radius * theta.sin[slice];
5060 vertices[vertex].position.z = z;
5061
5062 if (slice > 0)
5063 {
5064 faces[face][0] = 0;
5065 faces[face][1] = slice;
5066 faces[face++][2] = slice + 1;
5067 }
5068 }
5069
5070 faces[face][0] = 0;
5071 faces[face][1] = slice;
5072 faces[face++][2] = 1;
5073
5074 for (stack = 1; stack <= stacks+1; stack++)
5075 {
5076 for (slice = 0; slice < slices; slice++, vertex++)
5077 {
5078 vertices[vertex].normal.x = theta.cos[slice];
5079 vertices[vertex].normal.y = theta.sin[slice];
5080 vertices[vertex].normal.z = z_normal;
5081 D3DXVec3Normalize(&vertices[vertex].normal, &vertices[vertex].normal);
5082 vertices[vertex].position.x = radius * theta.cos[slice];
5083 vertices[vertex].position.y = radius * theta.sin[slice];
5084 vertices[vertex].position.z = z;
5085
5086 if (stack > 1 && slice > 0)
5087 {
5088 faces[face][0] = vertex_index(slices, slice-1, stack-1);
5089 faces[face][1] = vertex_index(slices, slice-1, stack);
5090 faces[face++][2] = vertex_index(slices, slice, stack-1);
5091
5092 faces[face][0] = vertex_index(slices, slice, stack-1);
5093 faces[face][1] = vertex_index(slices, slice-1, stack);
5094 faces[face++][2] = vertex_index(slices, slice, stack);
5095 }
5096 }
5097
5098 if (stack > 1)
5099 {
5100 faces[face][0] = vertex_index(slices, slice-1, stack-1);
5101 faces[face][1] = vertex_index(slices, slice-1, stack);
5102 faces[face++][2] = vertex_index(slices, 0, stack-1);
5103
5104 faces[face][0] = vertex_index(slices, 0, stack-1);
5105 faces[face][1] = vertex_index(slices, slice-1, stack);
5106 faces[face++][2] = vertex_index(slices, 0, stack);
5107 }
5108
5109 if (stack < stacks + 1)
5110 {
5111 z += z_step;
5112 radius -= radius_step;
5113 }
5114 }
5115
5116 for (slice = 0; slice < slices; slice++, vertex++)
5117 {
5118 vertices[vertex].normal.x = 0.0f;
5119 vertices[vertex].normal.y = 0.0f;
5120 vertices[vertex].normal.z = 1.0f;
5121 vertices[vertex].position.x = radius * theta.cos[slice];
5122 vertices[vertex].position.y = radius * theta.sin[slice];
5123 vertices[vertex].position.z = z;
5124
5125 if (slice > 0)
5126 {
5127 faces[face][0] = vertex_index(slices, slice-1, stack);
5128 faces[face][1] = number_of_vertices - 1;
5129 faces[face++][2] = vertex_index(slices, slice, stack);
5130 }
5131 }
5132
5133 vertices[vertex].position.x = 0.0f;
5134 vertices[vertex].position.y = 0.0f;
5135 vertices[vertex].position.z = z;
5136 vertices[vertex].normal.x = 0.0f;
5137 vertices[vertex].normal.y = 0.0f;
5138 vertices[vertex].normal.z = 1.0f;
5139
5140 faces[face][0] = vertex_index(slices, slice-1, stack);
5141 faces[face][1] = number_of_vertices - 1;
5142 faces[face][2] = vertex_index(slices, 0, stack);
5143
5144 free_sincos_table(&theta);
5145 cylinder->lpVtbl->UnlockIndexBuffer(cylinder);
5146 cylinder->lpVtbl->UnlockVertexBuffer(cylinder);
5147
5148 if (adjacency)
5149 {
5150 if (FAILED(hr = D3DXCreateBuffer(number_of_faces * sizeof(DWORD) * 3, adjacency)))
5151 {
5152 cylinder->lpVtbl->Release(cylinder);
5153 return hr;
5154 }
5155
5156 if (FAILED(hr = cylinder->lpVtbl->GenerateAdjacency(cylinder, 0.0f, (*adjacency)->lpVtbl->GetBufferPointer(*adjacency))))
5157 {
5158 (*adjacency)->lpVtbl->Release(*adjacency);
5159 cylinder->lpVtbl->Release(cylinder);
5160 return hr;
5161 }
5162 }
5163
5164 *mesh = cylinder;
5165
5166 return D3D_OK;
5167}
Definition: _stack.h:55
GLUquadricObj * cylinder
Definition: cylfrac.c:44
#define D3DX_PI
Definition: d3dx9math.h:27
static void free_sincos_table(struct sincos_table *sincos_table)
Definition: mesh.c:4755
static BOOL compute_sincos_table(struct sincos_table *sincos_table, float angle_start, float angle_step, int n)
Definition: mesh.c:4762
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
GLdouble GLdouble z
Definition: glext.h:5874
ULONG Release()
#define isnan(x)
Definition: mingw_math.h:133

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.

2435{
2436 HRESULT hr;
2437 DWORD fvf;
2438 IDirect3DVertexDeclaration9 *vertex_declaration;
2439 UINT vertex_declaration_size;
2440 UINT num_elem;
2441 IDirect3DVertexBuffer9 *vertex_buffer;
2442 IDirect3DIndexBuffer9 *index_buffer;
2443 DWORD *attrib_buffer;
2444 struct d3dx9_mesh *object;
2445 DWORD index_usage = 0;
2446 D3DPOOL index_pool = D3DPOOL_DEFAULT;
2447 D3DFORMAT index_format = D3DFMT_INDEX16;
2448 DWORD vertex_usage = 0;
2449 D3DPOOL vertex_pool = D3DPOOL_DEFAULT;
2450 int i;
2451
2452 TRACE("numfaces %u, numvertices %u, options %#x, declaration %p, device %p, mesh %p.\n",
2454
2455 if (numfaces == 0 || numvertices == 0 || declaration == NULL || device == NULL || mesh == NULL ||
2456 /* D3DXMESH_VB_SHARE is for cloning, and D3DXMESH_USEHWONLY is for ConvertToBlendedMesh */
2457 (options & (D3DXMESH_VB_SHARE | D3DXMESH_USEHWONLY | 0xfffe0000)))
2458 {
2459 return D3DERR_INVALIDCALL;
2460 }
2461 for (i = 0; declaration[i].Stream != 0xff; i++)
2462 if (declaration[i].Stream != 0)
2463 return D3DERR_INVALIDCALL;
2464 num_elem = i + 1;
2465
2466 if (options & D3DXMESH_32BIT)
2467 index_format = D3DFMT_INDEX32;
2468
2470 index_usage |= D3DUSAGE_DONOTCLIP;
2471 vertex_usage |= D3DUSAGE_DONOTCLIP;
2472 }
2473 if (options & D3DXMESH_POINTS) {
2474 index_usage |= D3DUSAGE_POINTS;
2475 vertex_usage |= D3DUSAGE_POINTS;
2476 }
2478 index_usage |= D3DUSAGE_RTPATCHES;
2479 vertex_usage |= D3DUSAGE_RTPATCHES;
2480 }
2481 if (options & D3DXMESH_NPATCHES) {
2482 index_usage |= D3DUSAGE_NPATCHES;
2483 vertex_usage |= D3DUSAGE_NPATCHES;
2484 }
2485
2487 vertex_pool = D3DPOOL_SYSTEMMEM;
2488 else if (options & D3DXMESH_VB_MANAGED)
2489 vertex_pool = D3DPOOL_MANAGED;
2490
2492 vertex_usage |= D3DUSAGE_WRITEONLY;
2494 vertex_usage |= D3DUSAGE_DYNAMIC;
2496 vertex_usage |= D3DUSAGE_SOFTWAREPROCESSING;
2497
2499 index_pool = D3DPOOL_SYSTEMMEM;
2500 else if (options & D3DXMESH_IB_MANAGED)
2501 index_pool = D3DPOOL_MANAGED;
2502
2504 index_usage |= D3DUSAGE_WRITEONLY;
2506 index_usage |= D3DUSAGE_DYNAMIC;
2508 index_usage |= D3DUSAGE_SOFTWAREPROCESSING;
2509
2511 if (hr != D3D_OK)
2512 {
2513 fvf = 0;
2514 }
2515
2516 /* Create vertex declaration */
2520 if (FAILED(hr))
2521 {
2522 WARN("Unexpected return value %x from IDirect3DDevice9_CreateVertexDeclaration.\n",hr);
2523 return hr;
2524 }
2526
2527 /* Create vertex buffer */
2530 vertex_usage,
2531 fvf,
2532 vertex_pool,
2534 NULL);
2535 if (FAILED(hr))
2536 {
2537 WARN("Unexpected return value %x from IDirect3DDevice9_CreateVertexBuffer.\n",hr);
2539 return hr;
2540 }
2541
2542 /* Create index buffer */
2544 numfaces * 3 * ((index_format == D3DFMT_INDEX16) ? 2 : 4),
2545 index_usage,
2546 index_format,
2547 index_pool,
2548 &index_buffer,
2549 NULL);
2550 if (FAILED(hr))
2551 {
2552 WARN("Unexpected return value %x from IDirect3DDevice9_CreateVertexBuffer.\n",hr);
2555 return hr;
2556 }
2557
2559 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2560 if (object == NULL || attrib_buffer == NULL)
2561 {
2562 HeapFree(GetProcessHeap(), 0, object);
2567 *mesh = NULL;
2568 return E_OUTOFMEMORY;
2569 }
2570 object->ID3DXMesh_iface.lpVtbl = &D3DXMesh_Vtbl;
2571 object->ref = 1;
2572
2573 object->numfaces = numfaces;
2574 object->numvertices = numvertices;
2575 object->options = options;
2576 object->fvf = fvf;
2577 object->device = device;
2579
2580 copy_declaration(object->cached_declaration, declaration, num_elem);
2581 object->vertex_declaration = vertex_declaration;
2582 object->vertex_declaration_size = vertex_declaration_size;
2583 object->num_elem = num_elem;
2584 object->vertex_buffer = vertex_buffer;
2585 object->index_buffer = index_buffer;
2586 object->attrib_buffer = attrib_buffer;
2587
2588 *mesh = &object->ID3DXMesh_iface;
2589
2590 return D3D_OK;
2591}
#define D3DUSAGE_NPATCHES
Definition: d3d8types.h:98
#define D3DUSAGE_POINTS
Definition: d3d8types.h:96
#define D3DUSAGE_DONOTCLIP
Definition: d3d8types.h:95
@ D3DFMT_INDEX16
Definition: d3d8types.h:649
@ D3DFMT_INDEX32
Definition: d3d8types.h:650
#define D3DUSAGE_DYNAMIC
Definition: d3d8types.h:99
#define D3DUSAGE_WRITEONLY
Definition: d3d8types.h:93
enum _D3DPOOL D3DPOOL
@ D3DPOOL_DEFAULT
Definition: d3d8types.h:709
@ D3DPOOL_SYSTEMMEM
Definition: d3d8types.h:711
@ D3DPOOL_MANAGED
Definition: d3d8types.h:710
enum _D3DFORMAT D3DFORMAT
#define D3DUSAGE_SOFTWAREPROCESSING
Definition: d3d8types.h:94
#define D3DUSAGE_RTPATCHES
Definition: d3d8types.h:97
#define IDirect3DDevice9_CreateIndexBuffer(p, a, b, c, d, e, f)
Definition: d3d9.h:1534
@ D3DXMESH_NPATCHES
Definition: d3dx9mesh.h:50
@ D3DXMESH_VB_MANAGED
Definition: d3dx9mesh.h:52
@ D3DXMESH_USEHWONLY
Definition: d3dx9mesh.h:62
@ D3DXMESH_DONOTCLIP
Definition: d3dx9mesh.h:47
@ D3DXMESH_VB_SOFTWAREPROCESSING
Definition: d3dx9mesh.h:55
@ D3DXMESH_VB_WRITEONLY
Definition: d3dx9mesh.h:53
@ D3DXMESH_POINTS
Definition: d3dx9mesh.h:48
@ D3DXMESH_IB_MANAGED
Definition: d3dx9mesh.h:57
@ D3DXMESH_IB_WRITEONLY
Definition: d3dx9mesh.h:58
@ D3DXMESH_VB_SYSTEMMEM
Definition: d3dx9mesh.h:51
@ D3DXMESH_RTPATCHES
Definition: d3dx9mesh.h:49
@ D3DXMESH_IB_SYSTEMMEM
Definition: d3dx9mesh.h:56
@ D3DXMESH_IB_SOFTWAREPROCESSING
Definition: d3dx9mesh.h:60
@ D3DXMESH_IB_DYNAMIC
Definition: d3dx9mesh.h:59
@ D3DXMESH_VB_DYNAMIC
Definition: d3dx9mesh.h:54
HRESULT WINAPI D3DXFVFFromDeclarator(const D3DVERTEXELEMENT9 *declaration, DWORD *fvf)
Definition: mesh.c:2134
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
DWORD fvf
Definition: mesh.c:53
UINT num_elem
Definition: mesh.c:58
DWORD numvertices
Definition: mesh.c:51
IDirect3DDevice9 * device
Definition: mesh.c:54
DWORD options
Definition: mesh.c:52
IDirect3DVertexDeclaration9 * vertex_declaration
Definition: mesh.c:56

Referenced by d3dx9_mesh_CloneMesh(), D3DXCreateMeshFVF(), D3DXCreateMeshTest(), init_test_mesh(), test_convert_adjacency_to_point_reps(), test_convert_point_reps_to_