dlls/d3dx9_36/skin.c

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