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