dll/directx/wine/d3dx9_36/skin.c

   1 /*
   2  * Skin Info operations specific to D3DX9.
   3  *
   4  * Copyright (C) 2011 Dylan Smith
   5  * Copyright (C) 2013 Christian Costa
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "d3dx9_36_private.h"
  23
  24 struct bone
  25 {
  26     char *name;
  27     D3DXMATRIX transform;
  28     DWORD num_influences;
  29     DWORD *vertices;
  30     FLOAT *weights;
  31 };
  32
  33 struct d3dx9_skin_info
  34 {
  35     ID3DXSkinInfo ID3DXSkinInfo_iface;
  36     LONG ref;
  37
  38     DWORD fvf;
  39     D3DVERTEXELEMENT9 vertex_declaration[MAX_FVF_DECL_SIZE];
  40     DWORD num_vertices;
  41     DWORD num_bones;
  42     struct bone *bones;
  43 };
  44
  45 static inline struct d3dx9_skin_info *impl_from_ID3DXSkinInfo(ID3DXSkinInfo *iface)
  46 {
  47     return CONTAINING_RECORD(iface, struct d3dx9_skin_info, ID3DXSkinInfo_iface);
  48 }
  49
  50 static HRESULT WINAPI d3dx9_skin_info_QueryInterface(ID3DXSkinInfo *iface, REFIID riid, void **out)
  51 {
  52     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
  53
  54     if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ID3DXSkinInfo))
  55     {
  56         IUnknown_AddRef(iface);
  57         *out = iface;
  58         return D3D_OK;
  59     }
  60
  61     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
  62
  63     return E_NOINTERFACE;
  64 }
  65
  66 static ULONG WINAPI d3dx9_skin_info_AddRef(ID3DXSkinInfo *iface)
  67 {
  68     struct d3dx9_skin_info *skin = impl_from_ID3DXSkinInfo(iface);
  69     ULONG refcount = InterlockedIncrement(&skin->ref);
  70
  71     TRACE("%p increasing refcount to %u.\n", skin, refcount);
  72
  73     return refcount;
  74 }
  75
  76 static ULONG WINAPI d3dx9_skin_info_Release(ID3DXSkinInfo *iface)
  77 {
  78     struct d3dx9_skin_info *skin = impl_from_ID3DXSkinInfo(iface);
  79     ULONG refcount = InterlockedDecrement(&skin->ref);
  80
  81     TRACE("%p decreasing refcount to %u.\n", skin, refcount);
  82
  83     if (!refcount)
  84     {
  85         DWORD i;
  86
  87         for (i = 0; i < skin->num_bones; ++i)
  88         {
  89             HeapFree(GetProcessHeap(), 0, skin->bones[i].name);
  90             HeapFree(GetProcessHeap(), 0, skin->bones[i].vertices);
  91             HeapFree(GetProcessHeap(), 0, skin->bones[i].weights);
  92         }
  93         if (skin->bones) HeapFree(GetProcessHeap(), 0, skin->bones);
  94         HeapFree(GetProcessHeap(), 0, skin);
  95     }
  96
  97     return refcount;
  98 }
  99
 100 static HRESULT WINAPI d3dx9_skin_info_SetBoneInfluence(ID3DXSkinInfo *iface,
 101         DWORD bone_num, DWORD num_influences, const DWORD *vertices, const float *weights)
 102 {
 103     struct d3dx9_skin_info *skin = impl_from_ID3DXSkinInfo(iface);
 104     struct bone *bone;
 105     DWORD *new_vertices = NULL;
 106     FLOAT *new_weights = NULL;
 107
 108     TRACE("iface %p, bone_num %u, num_influences %u, vertices %p, weights %p.\n",
 109             iface, bone_num, num_influences, vertices, weights);
 110
 111     if (bone_num >= skin->num_bones || !vertices || !weights)
 112         return D3DERR_INVALIDCALL;
 113
 114     if (num_influences) {
 115         new_vertices = HeapAlloc(GetProcessHeap(), 0, num_influences * sizeof(*vertices));
 116         if (!new_vertices)
 117             return E_OUTOFMEMORY;
 118         new_weights = HeapAlloc(GetProcessHeap(), 0, num_influences * sizeof(*weights));
 119         if (!new_weights) {
 120             HeapFree(GetProcessHeap(), 0, new_vertices);
 121             return E_OUTOFMEMORY;
 122         }
 123         memcpy(new_vertices, vertices, num_influences * sizeof(*vertices));
 124         memcpy(new_weights, weights, num_influences * sizeof(*weights));
 125     }
 126     bone = &skin->bones[bone_num];
 127     bone->num_influences = num_influences;
 128     HeapFree(GetProcessHeap(), 0, bone->vertices);
 129     HeapFree(GetProcessHeap(), 0, bone->weights);
 130     bone->vertices = new_vertices;
 131     bone->weights = new_weights;
 132
 133     return D3D_OK;
 134 }
 135
 136 static HRESULT WINAPI d3dx9_skin_info_SetBoneVertexInfluence(ID3DXSkinInfo *iface,
 137         DWORD bone_num, DWORD influence_num, float weight)
 138 {
 139     FIXME("iface %p, bone_num %u, influence_num %u, weight %.8e stub!\n",
 140             iface, bone_num, influence_num, weight);
 141
 142     return E_NOTIMPL;
 143 }
 144
 145 static DWORD WINAPI d3dx9_skin_info_GetNumBoneInfluences(ID3DXSkinInfo *iface, DWORD bone_num)
 146 {
 147     struct d3dx9_skin_info *skin = impl_from_ID3DXSkinInfo(iface);
 148
 149     TRACE("iface %p, bone_num %u.\n", iface, bone_num);
 150
 151     if (bone_num >= skin->num_bones)
 152         return 0;
 153
 154     return skin->bones[bone_num].num_influences;
 155 }
 156
 157 static HRESULT WINAPI d3dx9_skin_info_GetBoneInfluence(ID3DXSkinInfo *iface,
 158         DWORD bone_num, DWORD *vertices, float *weights)
 159 {
 160     struct d3dx9_skin_info *skin = impl_from_ID3DXSkinInfo(iface);
 161     struct bone *bone;
 162
 163     TRACE("iface %p, bone_num %u, vertices %p, weights %p.\n",
 164             iface, bone_num, vertices, weights);
 165
 166     if (bone_num >= skin->num_bones || !vertices)
 167         return D3DERR_INVALIDCALL;
 168
 169     bone = &skin->bones[bone_num];
 170     if (!bone->num_influences)
 171         return D3D_OK;
 172
 173     memcpy(vertices, bone->vertices, bone->num_influences * sizeof(*vertices));
 174     if (weights)
 175         memcpy(weights, bone->weights, bone->num_influences * sizeof(*weights));
 176
 177     return D3D_OK;
 178 }
 179
 180 static HRESULT WINAPI d3dx9_skin_info_GetBoneVertexInfluence(ID3DXSkinInfo *iface,
 181         DWORD bone_num, DWORD influence_num, float *weight, DWORD *vertex_num)
 182 {
 183     FIXME("iface %p, bone_num %u, influence_num %u, weight %p, vertex_num %p stub!\n",
 184             iface, bone_num, influence_num, weight, vertex_num);
 185
 186     return E_NOTIMPL;
 187 }
 188
 189 static HRESULT WINAPI d3dx9_skin_info_GetMaxVertexInfluences(ID3DXSkinInfo *iface, DWORD *max_vertex_influences)
 190 {
 191     FIXME("iface %p, max_vertex_influences %p stub!\n", iface, max_vertex_influences);
 192
 193     return E_NOTIMPL;
 194 }
 195
 196 static DWORD WINAPI d3dx9_skin_info_GetNumBones(ID3DXSkinInfo *iface)
 197 {
 198     struct d3dx9_skin_info *skin = impl_from_ID3DXSkinInfo(iface);
 199
 200     TRACE("iface %p.\n", iface);
 201
 202     return skin->num_bones;
 203 }
 204
 205 static HRESULT WINAPI d3dx9_skin_info_FindBoneVertexInfluenceIndex(ID3DXSkinInfo *iface,
 206         DWORD bone_num, DWORD vertex_num, DWORD *influence_index)
 207 {
 208     FIXME("iface %p, bone_num %u, vertex_num %u, influence_index %p stub!\n",
 209             iface, bone_num, vertex_num, influence_index);
 210
 211     return E_NOTIMPL;
 212 }
 213
 214 static HRESULT WINAPI d3dx9_skin_info_GetMaxFaceInfluences(struct ID3DXSkinInfo *iface,
 215         struct IDirect3DIndexBuffer9 *index_buffer, DWORD num_faces, DWORD *max_face_influences)
 216 {
 217     FIXME("iface %p, index_buffer %p, num_faces %u, max_face_influences %p stub!\n",
 218             iface, index_buffer, num_faces, max_face_influences);
 219
 220     return E_NOTIMPL;
 221 }
 222
 223 static HRESULT WINAPI d3dx9_skin_info_SetMinBoneInfluence(ID3DXSkinInfo *iface, float min_influence)
 224 {
 225     FIXME("iface %p, min_influence %.8e stub!\n", iface, min_influence);
 226
 227     return E_NOTIMPL;
 228 }
 229
 230 static float WINAPI d3dx9_skin_info_GetMinBoneInfluence(ID3DXSkinInfo *iface)
 231 {
 232     FIXME("iface %p stub!\n", iface);
 233
 234     return 0.0f;
 235 }
 236
 237 static HRESULT WINAPI d3dx9_skin_info_SetBoneName(ID3DXSkinInfo *iface, DWORD bone_idx, const char *name)
 238 {
 239     struct d3dx9_skin_info *skin = impl_from_ID3DXSkinInfo(iface);
 240     char *new_name;
 241     size_t size;
 242
 243     TRACE("iface %p, bone_idx %u, name %s.\n", iface, bone_idx, debugstr_a(name));
 244
 245     if (bone_idx >= skin->num_bones || !name)
 246         return D3DERR_INVALIDCALL;
 247
 248     size = strlen(name) + 1;
 249     new_name = HeapAlloc(GetProcessHeap(), 0, size);
 250     if (!new_name)
 251         return E_OUTOFMEMORY;
 252     memcpy(new_name, name, size);
 253     HeapFree(GetProcessHeap(), 0, skin->bones[bone_idx].name);
 254     skin->bones[bone_idx].name = new_name;
 255
 256     return D3D_OK;
 257 }
 258
 259 static const char * WINAPI d3dx9_skin_info_GetBoneName(ID3DXSkinInfo *iface, DWORD bone_idx)
 260 {
 261     struct d3dx9_skin_info *skin = impl_from_ID3DXSkinInfo(iface);
 262
 263     TRACE("iface %p, bone_idx %u.\n", iface, bone_idx);
 264
 265     if (bone_idx >= skin->num_bones)
 266         return NULL;
 267
 268     return skin->bones[bone_idx].name;
 269 }
 270
 271 static HRESULT WINAPI d3dx9_skin_info_SetBoneOffsetMatrix(ID3DXSkinInfo *iface,
 272         DWORD bone_num, const D3DXMATRIX *bone_transform)
 273 {
 274     struct d3dx9_skin_info *skin = impl_from_ID3DXSkinInfo(iface);
 275
 276     TRACE("iface %p, bone_num %u, bone_transform %p.\n", iface, bone_num, bone_transform);
 277
 278     if (bone_num >= skin->num_bones || !bone_transform)
 279         return D3DERR_INVALIDCALL;
 280
 281     skin->bones[bone_num].transform = *bone_transform;
 282     return D3D_OK;
 283 }
 284
 285 static D3DXMATRIX * WINAPI d3dx9_skin_info_GetBoneOffsetMatrix(ID3DXSkinInfo *iface, DWORD bone_num)
 286 {
 287     struct d3dx9_skin_info *skin = impl_from_ID3DXSkinInfo(iface);
 288
 289     TRACE("iface %p, bone_num %u.\n", iface, bone_num);
 290
 291     if (bone_num >= skin->num_bones)
 292         return NULL;
 293
 294     return &skin->bones[bone_num].transform;
 295 }
 296
 297 static HRESULT WINAPI d3dx9_skin_info_Clone(ID3DXSkinInfo *iface, ID3DXSkinInfo **skin_info)
 298 {
 299     FIXME("iface %p, skin_info %p stub!\n", iface, skin_info);
 300
 301     return E_NOTIMPL;
 302 }
 303
 304 static HRESULT WINAPI d3dx9_skin_info_Remap(ID3DXSkinInfo *iface, DWORD num_vertices, DWORD *vertex_remap)
 305 {
 306     FIXME("iface %p, num_vertices %u, vertex_remap %p stub!\n", iface, num_vertices, vertex_remap);
 307
 308     return E_NOTIMPL;
 309 }
 310
 311 static HRESULT WINAPI d3dx9_skin_info_SetFVF(ID3DXSkinInfo *iface, DWORD fvf)
 312 {
 313     HRESULT hr;
 314     D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE];
 315
 316     TRACE("iface %p, fvf %#x.\n", iface, fvf);
 317
 318     hr = D3DXDeclaratorFromFVF(fvf, declaration);
 319     if (FAILED(hr)) return hr;
 320
 321     return iface->lpVtbl->SetDeclaration(iface, declaration);
 322 }
 323
 324 static HRESULT WINAPI d3dx9_skin_info_SetDeclaration(ID3DXSkinInfo *iface, const D3DVERTEXELEMENT9 *declaration)
 325 {
 326     struct d3dx9_skin_info *skin = impl_from_ID3DXSkinInfo(iface);
 327     HRESULT hr;
 328     int count;
 329
 330     TRACE("iface %p, declaration %p.\n", iface, declaration);
 331
 332     if (!declaration)
 333         return D3DERR_INVALIDCALL;
 334     for (count = 0; declaration[count].Stream != 0xff; count++) {
 335         if (declaration[count].Stream != 0) {
 336             WARN("Invalid vertex element %u; contains non-zero stream %u\n",
 337                  count, declaration[count].Stream);
 338             return D3DERR_INVALIDCALL;
 339         }
 340     }
 341     count++;
 342
 343     memcpy(skin->vertex_declaration, declaration, count * sizeof(*declaration));
 344
 345     if (FAILED(hr = D3DXFVFFromDeclarator(skin->vertex_declaration, &skin->fvf)))
 346         skin->fvf = 0;
 347
 348     return D3D_OK;
 349 }
 350
 351 static DWORD WINAPI d3dx9_skin_info_GetFVF(ID3DXSkinInfo *iface)
 352 {
 353     struct d3dx9_skin_info *skin = impl_from_ID3DXSkinInfo(iface);
 354
 355     TRACE("iface %p.\n", iface);
 356
 357     return skin->fvf;
 358 }
 359
 360 static HRESULT WINAPI d3dx9_skin_info_GetDeclaration(ID3DXSkinInfo *iface,
 361         D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE])
 362 {
 363     struct d3dx9_skin_info *skin = impl_from_ID3DXSkinInfo(iface);
 364     UINT count = 0;
 365
 366     TRACE("iface %p, declaration %p.\n", iface, declaration);
 367
 368     while (skin->vertex_declaration[count++].Stream != 0xff);
 369     memcpy(declaration, skin->vertex_declaration, count * sizeof(declaration[0]));
 370     return D3D_OK;
 371 }
 372
 373 static HRESULT WINAPI d3dx9_skin_info_UpdateSkinnedMesh(ID3DXSkinInfo *iface, const D3DXMATRIX *bone_transforms,
 374         const D3DXMATRIX *bone_inv_transpose_transforms, const void *src_vertices, void *dst_vertices)
 375 {
 376     struct d3dx9_skin_info *skin = impl_from_ID3DXSkinInfo(iface);
 377     DWORD size = D3DXGetFVFVertexSize(skin->fvf);
 378     DWORD i, j;
 379
 380     TRACE("iface %p, bone_transforms %p, bone_inv_transpose_transforms %p, src_vertices %p, dst_vertices %p\n",
 381             skin, bone_transforms, bone_inv_transpose_transforms, src_vertices, dst_vertices);
 382
 383     if (bone_inv_transpose_transforms)
 384         FIXME("Skinning vertices with two position elements not supported\n");
 385
 386     if ((skin->fvf & D3DFVF_POSITION_MASK) != D3DFVF_XYZ) {
 387         FIXME("Vertex type %#x not supported\n", skin->fvf & D3DFVF_POSITION_MASK);
 388         return E_FAIL;
 389     }
 390
 391     /* Reset all positions */
 392     for (i = 0; i < skin->num_vertices; i++) {
 393         D3DXVECTOR3 *position = (D3DXVECTOR3*)((BYTE*)dst_vertices + size * i);
 394         position->x = 0.0f;
 395         position->y = 0.0f;
 396         position->z = 0.0f;
 397     }
 398
 399     /* Update positions that are influenced by bones */
 400     for (i = 0; i < skin->num_bones; i++) {
 401         D3DXMATRIX bone_inverse, matrix;
 402
 403         D3DXMatrixInverse(&bone_inverse, NULL, &skin->bones[i].transform);
 404         D3DXMatrixMultiply(&matrix, &bone_transforms[i], &bone_inverse);
 405         D3DXMatrixMultiply(&matrix, &matrix, &skin->bones[i].transform);
 406
 407         for (j = 0; j < skin->bones[i].num_influences; j++) {
 408             D3DXVECTOR3 position;
 409             D3DXVECTOR3 *position_src = (D3DXVECTOR3*)((BYTE*)src_vertices + size * skin->bones[i].vertices[j]);
 410             D3DXVECTOR3 *position_dest = (D3DXVECTOR3*)((BYTE*)dst_vertices + size * skin->bones[i].vertices[j]);
 411             FLOAT weight = skin->bones[i].weights[j];
 412
 413             D3DXVec3TransformCoord(&position, position_src, &matrix);
 414             position_dest->x += weight * position.x;
 415             position_dest->y += weight * position.y;
 416             position_dest->z += weight * position.z;
 417         }
 418     }
 419
 420     if (skin->fvf & D3DFVF_NORMAL) {
 421         /* Reset all normals */
 422         for (i = 0; i < skin->num_vertices; i++) {
 423             D3DXVECTOR3 *normal = (D3DXVECTOR3*)((BYTE*)dst_vertices + size * i + sizeof(D3DXVECTOR3));
 424             normal->x = 0.0f;
 425             normal->y = 0.0f;
 426             normal->z = 0.0f;
 427         }
 428
 429         /* Update normals that are influenced by bones */
 430         for (i = 0; i < skin->num_bones; i++) {
 431             D3DXMATRIX bone_inverse, matrix;
 432
 433             D3DXMatrixInverse(&bone_inverse, NULL, &skin->bones[i].transform);
 434             D3DXMatrixMultiply(&matrix, &skin->bones[i].transform, &bone_transforms[i]);
 435
 436             for (j = 0; j < skin->bones[i].num_influences; j++) {
 437                 D3DXVECTOR3 normal;
 438                 D3DXVECTOR3 *normal_src = (D3DXVECTOR3*)((BYTE*)src_vertices + size * skin->bones[i].vertices[j] + sizeof(D3DXVECTOR3));
 439                 D3DXVECTOR3 *normal_dest = (D3DXVECTOR3*)((BYTE*)dst_vertices + size * skin->bones[i].vertices[j] + sizeof(D3DXVECTOR3));
 440                 FLOAT weight = skin->bones[i].weights[j];
 441
 442                 D3DXVec3TransformNormal(&normal, normal_src, &bone_inverse);
 443                 D3DXVec3TransformNormal(&normal, &normal, &matrix);
 444                 normal_dest->x += weight * normal.x;
 445                 normal_dest->y += weight * normal.y;
 446                 normal_dest->z += weight * normal.z;
 447             }
 448         }
 449
 450         /* Normalize all normals that are influenced by bones*/
 451         for (i = 0; i < skin->num_vertices; i++) {
 452             D3DXVECTOR3 *normal_dest = (D3DXVECTOR3*)((BYTE*)dst_vertices + (i * size) + sizeof(D3DXVECTOR3));
 453             if ((normal_dest->x != 0.0f) && (normal_dest->y != 0.0f) && (normal_dest->z != 0.0f))
 454                 D3DXVec3Normalize(normal_dest, normal_dest);
 455         }
 456     }
 457
 458     return D3D_OK;
 459 }
 460
 461 static HRESULT WINAPI d3dx9_skin_info_ConvertToBlendedMesh(ID3DXSkinInfo *iface, ID3DXMesh *mesh_in,
 462         DWORD options, const DWORD *adjacency_in, DWORD *adjacency_out, DWORD *face_remap,
 463         ID3DXBuffer **vertex_remap, DWORD *max_face_infl, DWORD *num_bone_combinations,
 464         ID3DXBuffer **bone_combination_table, ID3DXMesh **mesh_out)
 465 {
 466     FIXME("iface %p, mesh_in %p, options %#x, adjacency_in %p, adjacency_out %p, face_remap %p, vertex_remap %p, "
 467             "max_face_infl %p, num_bone_combinations %p, bone_combination_table %p, mesh_out %p stub!\n",
 468             iface, mesh_in, options, adjacency_in, adjacency_out, face_remap, vertex_remap,
 469             max_face_infl, num_bone_combinations, bone_combination_table, mesh_out);
 470
 471     return E_NOTIMPL;
 472 }
 473
 474 static HRESULT WINAPI d3dx9_skin_info_ConvertToIndexedBlendedMesh(ID3DXSkinInfo *iface, ID3DXMesh *mesh_in,
 475         DWORD options, DWORD palette_size, const DWORD *adjacency_in, DWORD *adjacency_out, DWORD *face_remap,
 476         ID3DXBuffer **vertex_remap, DWORD *max_face_infl, DWORD *num_bone_combinations,
 477         ID3DXBuffer **bone_combination_table, ID3DXMesh **mesh_out)
 478 {
 479     FIXME("iface %p, mesh_in %p, options %#x, palette_size %u, adjacency_in %p, adjacency_out %p, face_remap %p, vertex_remap %p, "
 480             "max_face_infl %p, num_bone_combinations %p, bone_combination_table %p, mesh_out %p stub!\n",
 481             iface, mesh_in, options, palette_size, adjacency_in, adjacency_out, face_remap, vertex_remap,
 482             max_face_infl, num_bone_combinations, bone_combination_table, mesh_out);
 483
 484     return E_NOTIMPL;
 485 }
 486
 487 static const struct ID3DXSkinInfoVtbl d3dx9_skin_info_vtbl =
 488 {
 489     d3dx9_skin_info_QueryInterface,
 490     d3dx9_skin_info_AddRef,
 491     d3dx9_skin_info_Release,
 492     d3dx9_skin_info_SetBoneInfluence,
 493     d3dx9_skin_info_SetBoneVertexInfluence,
 494     d3dx9_skin_info_GetNumBoneInfluences,
 495     d3dx9_skin_info_GetBoneInfluence,
 496     d3dx9_skin_info_GetBoneVertexInfluence,
 497     d3dx9_skin_info_GetMaxVertexInfluences,
 498     d3dx9_skin_info_GetNumBones,
 499     d3dx9_skin_info_FindBoneVertexInfluenceIndex,
 500     d3dx9_skin_info_GetMaxFaceInfluences,
 501     d3dx9_skin_info_SetMinBoneInfluence,
 502     d3dx9_skin_info_GetMinBoneInfluence,
 503     d3dx9_skin_info_SetBoneName,
 504     d3dx9_skin_info_GetBoneName,
 505     d3dx9_skin_info_SetBoneOffsetMatrix,
 506     d3dx9_skin_info_GetBoneOffsetMatrix,
 507     d3dx9_skin_info_Clone,
 508     d3dx9_skin_info_Remap,
 509     d3dx9_skin_info_SetFVF,
 510     d3dx9_skin_info_SetDeclaration,
 511     d3dx9_skin_info_GetFVF,
 512     d3dx9_skin_info_GetDeclaration,
 513     d3dx9_skin_info_UpdateSkinnedMesh,
 514     d3dx9_skin_info_ConvertToBlendedMesh,
 515     d3dx9_skin_info_ConvertToIndexedBlendedMesh,
 516 };
 517
 518 HRESULT WINAPI D3DXCreateSkinInfo(DWORD num_vertices, const D3DVERTEXELEMENT9 *declaration,
 519         DWORD num_bones, ID3DXSkinInfo **skin_info)
 520 {
 521     HRESULT hr;
 522     static const D3DVERTEXELEMENT9 empty_declaration = D3DDECL_END();
 523     struct d3dx9_skin_info *object = NULL;
 524
 525     TRACE("num_vertices %u, declaration %p, num_bones %u, skin_info %p.\n",
 526             num_vertices, declaration, num_bones, skin_info);
 527
 528     if (!skin_info || !declaration)
 529         return D3DERR_INVALIDCALL;
 530
 531     object = HeapAlloc(GetProcessHeap(), 0, sizeof(*object));
 532     if (!object)
 533         return E_OUTOFMEMORY;
 534
 535     object->ID3DXSkinInfo_iface.lpVtbl = &d3dx9_skin_info_vtbl;
 536     object->ref = 1;
 537     object->num_vertices = num_vertices;
 538     object->num_bones = num_bones;
 539     object->vertex_declaration[0] = empty_declaration;
 540     object->fvf = 0;
 541
 542     object->bones = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, num_bones * sizeof(*object->bones));
 543     if (!object->bones) {
 544         hr = E_OUTOFMEMORY;
 545         goto error;
 546     }
 547
 548     if (FAILED(hr = d3dx9_skin_info_SetDeclaration(&object->ID3DXSkinInfo_iface, declaration)))
 549         goto error;
 550
 551     *skin_info = &object->ID3DXSkinInfo_iface;
 552
 553     return D3D_OK;
 554 error:
 555     HeapFree(GetProcessHeap(), 0, object->bones);
 556     HeapFree(GetProcessHeap(), 0, object);
 557     return hr;
 558 }
 559
 560 HRESULT WINAPI D3DXCreateSkinInfoFVF(DWORD num_vertices, DWORD fvf, DWORD num_bones, ID3DXSkinInfo **skin_info)
 561 {
 562     HRESULT hr;
 563     D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE];
 564
 565     TRACE("(%u, %x, %u, %p)\n", num_vertices, fvf, num_bones, skin_info);
 566
 567     hr = D3DXDeclaratorFromFVF(fvf, declaration);
 568     if (FAILED(hr))
 569         return hr;
 570
 571     return D3DXCreateSkinInfo(num_vertices, declaration, num_bones, skin_info);
 572 }
 573
 574 HRESULT create_dummy_skin(ID3DXSkinInfo **iface)
 575 {
 576     static const D3DVERTEXELEMENT9 empty_declaration = D3DDECL_END();
 577     struct d3dx9_skin_info *object = NULL;
 578
 579     object = HeapAlloc(GetProcessHeap(), 0, sizeof(*object));
 580     if (!object) return E_OUTOFMEMORY;
 581
 582     object->ID3DXSkinInfo_iface.lpVtbl = &d3dx9_skin_info_vtbl;
 583     object->ref = 1;
 584     object->num_vertices = 0;
 585     object->num_bones = 0;
 586     object->vertex_declaration[0] = empty_declaration;
 587     object->fvf = 0;
 588     object->bones = NULL;
 589
 590     *iface = &object->ID3DXSkinInfo_iface;
 591     return D3D_OK;
 592 }