110401(DTXMania089)/SlimDXc_Jun2010(VC++2008)/source/direct3d9/SkinInfo.cpp

   1 #include "stdafx.h"\r
   2 /*\r
   3 * Copyright (c) 2007-2010 SlimDX Group\r
   4 * \r
   5 * Permission is hereby granted, free of charge, to any person obtaining a copy\r
   6 * of this software and associated documentation files (the "Software"), to deal\r
   7 * in the Software without restriction, including without limitation the rights\r
   8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r
   9 * copies of the Software, and to permit persons to whom the Software is\r
  10 * furnished to do so, subject to the following conditions:\r
  11 * \r
  12 * The above copyright notice and this permission notice shall be included in\r
  13 * all copies or substantial portions of the Software.\r
  14 * \r
  15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
  17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r
  18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r
  19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
  20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r
  21 * THE SOFTWARE.\r
  22 */\r
  23 #include <d3d9.h>\r
  24 #include <d3dx9.h>\r
  25 #include <vcclr.h>\r
  26 \r
  27 #include "../stack_array.h"\r
  28 #include "../DataStream.h"\r
  29 #include "../ComObject.h"\r
  30 \r
  31 #include "Device.h"\r
  32 #include "IndexBuffer.h"\r
  33 #include "Mesh.h"\r
  34 #include "SkinInfo.h"\r
  35 \r
  36 #include "Direct3D9Exception.h"\r
  37 \r
  38 using namespace System;\r
  39 \r
  40 namespace SlimDX\r
  41 {\r
  42 namespace Direct3D9\r
  43 {\r
  44         SkinInfo::SkinInfo( int vertexCount, array<VertexElement>^ vertexDeclaration, int boneCount )\r
  45         {\r
  46                 ID3DXSkinInfo *result;\r
  47 \r
  48                 pin_ptr<VertexElement> pinnedDecl = &vertexDeclaration[0];\r
  49 \r
  50                 HRESULT hr = D3DXCreateSkinInfo( vertexCount, reinterpret_cast<const D3DVERTEXELEMENT9*>( pinnedDecl ),\r
  51                         boneCount, &result );\r
  52                 \r
  53                 if( RECORD_D3D9( hr ).IsFailure )\r
  54                         throw gcnew Direct3D9Exception( Result::Last );\r
  55 \r
  56                 Construct( result );\r
  57         }\r
  58 \r
  59         SkinInfo::SkinInfo( BaseMesh^ mesh, int boneCount, array<BoneCombination^>^ boneCombinationTable )\r
  60         {\r
  61                 ID3DXSkinInfo *result;\r
  62 \r
  63                 int length = boneCombinationTable->Length;\r
  64                 stack_array<D3DXBONECOMBINATION> bones = stackalloc( D3DXBONECOMBINATION, length );\r
  65                 for( int i = 0; i < length; i++ )\r
  66                         bones[i] = boneCombinationTable[i]->ToUnmanaged();\r
  67 \r
  68                 HRESULT hr = D3DXCreateSkinInfoFromBlendedMesh( mesh->InternalPointer, boneCount, &bones[0], &result );\r
  69 \r
  70                 for( int i = 0; i < length; i++ )\r
  71                         delete[] bones[i].BoneId;\r
  72 \r
  73                 if( RECORD_D3D9( hr ).IsFailure )\r
  74                         throw gcnew Direct3D9Exception( Result::Last );\r
  75 \r
  76                 Construct( result );\r
  77         }\r
  78 \r
  79         SkinInfo::SkinInfo( int vertexCount, SlimDX::Direct3D9::VertexFormat fvf, int boneCount )\r
  80         {\r
  81                 ID3DXSkinInfo *result;\r
  82 \r
  83                 HRESULT hr = D3DXCreateSkinInfoFVF( vertexCount, static_cast<DWORD>( fvf ),\r
  84                         boneCount, &result );\r
  85                 \r
  86                 if( RECORD_D3D9( hr ).IsFailure )\r
  87                         throw gcnew Direct3D9Exception( Result::Last );\r
  88 \r
  89                 Construct( result );\r
  90         }\r
  91 \r
  92         SkinInfo^ SkinInfo::Clone()\r
  93         {\r
  94                 ID3DXSkinInfo *result;\r
  95 \r
  96                 HRESULT hr = InternalPointer->Clone( &result );\r
  97                 \r
  98                 if( RECORD_D3D9( hr ).IsFailure )\r
  99                         return nullptr;\r
 100 \r
 101                 return gcnew SkinInfo( result, nullptr );\r
 102         }\r
 103 \r
 104         Mesh^ SkinInfo::ConvertToBlendedMesh( Mesh^ mesh, array<int>^ adjacency,\r
 105                 [Out] array<int>^% faceRemap, [Out] array<int>^% vertexRemap, [Out] int% maxVertexInfluence,\r
 106                 [Out] array<BoneCombination^>^% boneCombinationTable )\r
 107         {\r
 108                 ID3DXMesh *result;\r
 109                 ID3DXBuffer *vr;\r
 110                 ID3DXBuffer *bct;\r
 111                 DWORD mvi;\r
 112                 DWORD bcc;\r
 113                 DWORD *adjacencyIn = NULL;\r
 114 \r
 115                 faceRemap = gcnew array<int>( mesh->FaceCount );\r
 116 \r
 117                 array<int>^ adjacencyOut = gcnew array<int>( mesh->FaceCount * 3 );\r
 118 \r
 119                 pin_ptr<int> pinnedAdjIn;\r
 120                 pin_ptr<int> pinnedAdjOut = &adjacencyOut[0];\r
 121                 pin_ptr<int> pinnedFR = &faceRemap[0];\r
 122 \r
 123                 if( adjacency != nullptr )\r
 124                 {\r
 125                         pinnedAdjIn = &adjacency[0];\r
 126                         adjacencyIn = reinterpret_cast<DWORD*>( pinnedAdjIn );\r
 127                 }\r
 128 \r
 129                 HRESULT hr = InternalPointer->ConvertToBlendedMesh( mesh->InternalPointer, 0, adjacencyIn,\r
 130                         reinterpret_cast<DWORD*>( pinnedAdjOut ), reinterpret_cast<DWORD*>( pinnedFR ), &vr, &mvi, &bcc, &bct, &result );\r
 131                 \r
 132                 if( RECORD_D3D9( hr ).IsFailure )\r
 133                 {\r
 134                         boneCombinationTable = nullptr;\r
 135                         maxVertexInfluence = 0;\r
 136                         vertexRemap = nullptr;\r
 137                         faceRemap = nullptr;\r
 138                         return nullptr;\r
 139                 }\r
 140 \r
 141                 boneCombinationTable = gcnew array<BoneCombination^>( bcc );\r
 142                 LPD3DXBONECOMBINATION pointer = reinterpret_cast<LPD3DXBONECOMBINATION>( bct->GetBufferPointer() );\r
 143 \r
 144                 for( DWORD i = 0; i < bcc; i++ )\r
 145                 {\r
 146                         boneCombinationTable[i] = BoneCombination::FromUnmanaged( pointer[i] );\r
 147                         boneCombinationTable[i]->BoneIds = gcnew array<int>( mvi );\r
 148                         for( DWORD j = 0; j < mvi; j++ )\r
 149                                 boneCombinationTable[i]->BoneIds[j] = pointer[i].BoneId[j];                     \r
 150                 }\r
 151 \r
 152                 Mesh^ out = Mesh::FromPointer( result );\r
 153                 if( adjacency != nullptr )\r
 154                         out->SetAdjacency( adjacencyOut );\r
 155                 else\r
 156                         out->SetAdjacency( NULL );\r
 157 \r
 158                 maxVertexInfluence = mvi;\r
 159                 vertexRemap = Utilities::ReadRange<int>( vr, result->GetNumVertices() );\r
 160                 return out;\r
 161         }\r
 162 \r
 163         Mesh^ SkinInfo::ConvertToBlendedMesh( Mesh^ mesh, array<int>^ adjacency,\r
 164                 [Out] int% maxVertexInfluence, [Out] array<BoneCombination^>^% boneCombinationTable )\r
 165         {\r
 166                 ID3DXMesh *result;\r
 167                 ID3DXBuffer *bct;\r
 168                 DWORD mvi;\r
 169                 DWORD bcc;\r
 170                 DWORD *adjacencyIn = NULL;\r
 171 \r
 172                 array<int>^ adjacencyOut = gcnew array<int>( mesh->FaceCount * 3 );\r
 173 \r
 174                 pin_ptr<int> pinnedAdjIn;\r
 175                 pin_ptr<int> pinnedAdjOut = &adjacencyOut[0];\r
 176 \r
 177                 if( adjacency != nullptr )\r
 178                 {\r
 179                         pinnedAdjIn = &adjacency[0];\r
 180                         adjacencyIn = reinterpret_cast<DWORD*>( pinnedAdjIn );\r
 181                 }\r
 182 \r
 183                 HRESULT hr = InternalPointer->ConvertToBlendedMesh( mesh->InternalPointer, 0, adjacencyIn,\r
 184                         reinterpret_cast<DWORD*>( pinnedAdjOut ), NULL, NULL, &mvi, &bcc, &bct, &result );\r
 185                 \r
 186                 if( RECORD_D3D9( hr ).IsFailure )\r
 187                 {\r
 188                         boneCombinationTable = nullptr;\r
 189                         maxVertexInfluence = 0;\r
 190                         return nullptr;\r
 191                 }\r
 192 \r
 193                 boneCombinationTable = gcnew array<BoneCombination^>( bcc );\r
 194                 LPD3DXBONECOMBINATION pointer = reinterpret_cast<LPD3DXBONECOMBINATION>( bct->GetBufferPointer() );\r
 195 \r
 196                 for( DWORD i = 0; i < bcc; i++ )\r
 197                 {\r
 198                         boneCombinationTable[i] = BoneCombination::FromUnmanaged( pointer[i] );\r
 199                         boneCombinationTable[i]->BoneIds = gcnew array<int>( mvi );\r
 200                         for( DWORD j = 0; j < mvi; j++ )\r
 201                                 boneCombinationTable[i]->BoneIds[j] = pointer[i].BoneId[j];                     \r
 202                 }\r
 203 \r
 204                 Mesh^ out = Mesh::FromPointer( result );\r
 205                 if( adjacency != nullptr )\r
 206                         out->SetAdjacency( adjacencyOut );\r
 207                 else\r
 208                         out->SetAdjacency( NULL );\r
 209 \r
 210                 maxVertexInfluence = mvi;\r
 211                 return out;\r
 212         }\r
 213 \r
 214         Mesh^ SkinInfo::ConvertToIndexedBlendedMesh( Mesh^ mesh, int paletteSize, array<int>^ adjacency,\r
 215                 [Out] array<int>^% faceRemap, [Out] array<int>^% vertexRemap, [Out] int% maxVertexInfluence,\r
 216                 [Out] array<BoneCombination^>^% boneCombinationTable )\r
 217         {\r
 218                 ID3DXMesh *result;\r
 219                 ID3DXBuffer *vr;\r
 220                 ID3DXBuffer *bct;\r
 221                 DWORD mvi;\r
 222                 DWORD bcc;\r
 223                 DWORD *adjacencyIn = NULL;\r
 224 \r
 225                 faceRemap = gcnew array<int>( mesh->FaceCount );\r
 226 \r
 227                 array<int>^ adjacencyOut = gcnew array<int>( mesh->FaceCount * 3 );\r
 228 \r
 229                 pin_ptr<int> pinnedAdjIn;\r
 230                 pin_ptr<int> pinnedAdjOut = &adjacencyOut[0];\r
 231 \r
 232                 if( adjacency != nullptr )\r
 233                 {\r
 234                         pinnedAdjIn = &adjacency[0];\r
 235                         adjacencyIn = reinterpret_cast<DWORD*>( pinnedAdjIn );\r
 236                 }\r
 237 \r
 238                 pin_ptr<int> pinnedFR = &faceRemap[0];\r
 239 \r
 240                 HRESULT hr = InternalPointer->ConvertToIndexedBlendedMesh( mesh->InternalPointer, 0, paletteSize, adjacencyIn,\r
 241                         reinterpret_cast<DWORD*>( pinnedAdjOut ), reinterpret_cast<DWORD*>( pinnedFR ), &vr, &mvi, &bcc, &bct, &result );\r
 242                 \r
 243                 if( RECORD_D3D9( hr ).IsFailure )\r
 244                 {\r
 245                         boneCombinationTable = nullptr;\r
 246                         maxVertexInfluence = 0;\r
 247                         vertexRemap = nullptr;\r
 248                         faceRemap = nullptr;\r
 249                         return nullptr;\r
 250                 }\r
 251 \r
 252                 boneCombinationTable = gcnew array<BoneCombination^>( bcc );\r
 253                 LPD3DXBONECOMBINATION pointer = reinterpret_cast<LPD3DXBONECOMBINATION>( bct->GetBufferPointer() );\r
 254 \r
 255                 for( DWORD i = 0; i < bcc; i++ )\r
 256                 {\r
 257                         boneCombinationTable[i] = BoneCombination::FromUnmanaged( pointer[i] );\r
 258                         boneCombinationTable[i]->BoneIds = gcnew array<int>( paletteSize );\r
 259                         for( int j = 0; j < paletteSize; j++ )\r
 260                                 boneCombinationTable[i]->BoneIds[j] = pointer[i].BoneId[j];                     \r
 261                 }\r
 262 \r
 263                 Mesh^ out = Mesh::FromPointer( result );\r
 264                 if( adjacency != nullptr )\r
 265                         out->SetAdjacency( adjacencyOut );\r
 266                 else\r
 267                         out->SetAdjacency( NULL );\r
 268 \r
 269                 maxVertexInfluence = mvi;\r
 270                 vertexRemap = Utilities::ReadRange<int>( vr, result->GetNumVertices() );\r
 271                 return out;\r
 272         }\r
 273 \r
 274         Mesh^ SkinInfo::ConvertToIndexedBlendedMesh( Mesh^ mesh, int paletteSize, array<int>^ adjacency,\r
 275                 [Out] int% maxVertexInfluence, [Out] array<BoneCombination^>^% boneCombinationTable )\r
 276         {\r
 277                 ID3DXMesh *result;\r
 278                 ID3DXBuffer *bct;\r
 279                 DWORD mvi;\r
 280                 DWORD bcc;\r
 281                 DWORD *adjacencyIn = NULL;\r
 282 \r
 283                 array<int>^ adjacencyOut = gcnew array<int>( mesh->FaceCount * 3 );\r
 284 \r
 285                 pin_ptr<int> pinnedAdjIn;\r
 286                 pin_ptr<int> pinnedAdjOut = &adjacencyOut[0];\r
 287 \r
 288                 if( adjacency != nullptr )\r
 289                 {\r
 290                         pinnedAdjIn = &adjacency[0];\r
 291                         adjacencyIn = reinterpret_cast<DWORD*>( pinnedAdjIn );\r
 292                 }\r
 293 \r
 294                 HRESULT hr = InternalPointer->ConvertToIndexedBlendedMesh( mesh->InternalPointer, 0, paletteSize, adjacencyIn,\r
 295                         reinterpret_cast<DWORD*>( pinnedAdjOut ), NULL, NULL, &mvi, &bcc, &bct, &result );\r
 296                 \r
 297                 if( RECORD_D3D9( hr ).IsFailure )\r
 298                 {\r
 299                         boneCombinationTable = nullptr;\r
 300                         maxVertexInfluence = 0;\r
 301                         return nullptr;\r
 302                 }\r
 303 \r
 304                 boneCombinationTable = gcnew array<BoneCombination^>( bcc );\r
 305                 LPD3DXBONECOMBINATION pointer = reinterpret_cast<LPD3DXBONECOMBINATION>( bct->GetBufferPointer() );\r
 306 \r
 307                 for( DWORD i = 0; i < bcc; i++ )\r
 308                 {\r
 309                         boneCombinationTable[i] = BoneCombination::FromUnmanaged( pointer[i] );\r
 310                         boneCombinationTable[i]->BoneIds = gcnew array<int>( paletteSize );\r
 311                         for( int j = 0; j < paletteSize; j++ )\r
 312                                 boneCombinationTable[i]->BoneIds[j] = pointer[i].BoneId[j];                     \r
 313                 }\r
 314 \r
 315                 Mesh^ out = Mesh::FromPointer( result );\r
 316                 if( adjacency != nullptr )\r
 317                         out->SetAdjacency( adjacencyOut );\r
 318                 else\r
 319                         out->SetAdjacency( NULL );\r
 320 \r
 321                 maxVertexInfluence = mvi;\r
 322                 return out;\r
 323         }\r
 324 \r
 325         int SkinInfo::FindBoneVertexInfluenceIndex( int bone, int vertex )\r
 326         {\r
 327                 DWORD influence;\r
 328 \r
 329                 HRESULT hr = InternalPointer->FindBoneVertexInfluenceIndex( bone, vertex, &influence );\r
 330                 \r
 331                 if( RECORD_D3D9( hr ).IsFailure )\r
 332                         return 0;\r
 333 \r
 334                 return influence;\r
 335         }\r
 336 \r
 337         Result SkinInfo::GetBoneInfluence( int bone, [Out] array<int>^% vertices, [Out] array<float>^% weights )\r
 338         {\r
 339                 int count = GetBoneInfluenceCount( bone );\r
 340                 vertices = gcnew array<int>( count );\r
 341                 weights = gcnew array<float>( count );\r
 342 \r
 343                 pin_ptr<int> pinnedVerts = &vertices[0];\r
 344                 pin_ptr<float> pinnedWeights = &weights[0];\r
 345 \r
 346                 HRESULT hr = InternalPointer->GetBoneInfluence( bone, reinterpret_cast<DWORD*>( pinnedVerts ),\r
 347                         reinterpret_cast<float*>( pinnedWeights ) );\r
 348                 \r
 349                 if( RECORD_D3D9( hr ).IsFailure )\r
 350                 {\r
 351                         vertices = nullptr;\r
 352                         weights = nullptr;\r
 353                 }\r
 354 \r
 355                 return Result::Last;\r
 356         }\r
 357 \r
 358         Result SkinInfo::SetBoneInfluence( int bone, array<int>^ vertices, array<float>^ weights )\r
 359         {\r
 360                 pin_ptr<int> pinnedVerts = &vertices[0];\r
 361                 pin_ptr<float> pinnedWeights = &weights[0];\r
 362 \r
 363                 HRESULT hr = InternalPointer->SetBoneInfluence( bone, vertices->Length, reinterpret_cast<const DWORD*>( pinnedVerts ),\r
 364                         reinterpret_cast<const float*>( pinnedWeights ) );\r
 365                 \r
 366                 return RECORD_D3D9( hr );\r
 367         }\r
 368 \r
 369         String^ SkinInfo::GetBoneName( int bone )\r
 370         {\r
 371                 return gcnew String( InternalPointer->GetBoneName( bone ) );\r
 372         }\r
 373 \r
 374         Result SkinInfo::SetBoneName( int bone, String^ name )\r
 375         {\r
 376                 array<unsigned char>^ nameBytes = System::Text::ASCIIEncoding::ASCII->GetBytes( name );\r
 377                 pin_ptr<unsigned char> pinnedName = &nameBytes[0];\r
 378 \r
 379                 HRESULT hr = InternalPointer->SetBoneName( bone, reinterpret_cast<LPCSTR>( pinnedName ) );\r
 380                 return RECORD_D3D9( hr );\r
 381         }\r
 382 \r
 383         Result SkinInfo::GetBoneVertexInfluence( int bone, int influence, [Out] float% weight, [Out] int% vertex )\r
 384         {\r
 385                 float w;\r
 386                 DWORD v;\r
 387 \r
 388                 HRESULT hr = InternalPointer->GetBoneVertexInfluence( bone, influence, &w, &v );\r
 389 \r
 390                 if( RECORD_D3D9( hr ).IsFailure )\r
 391                 {\r
 392                         weight = 0;\r
 393                         vertex = 0;\r
 394                 }\r
 395                 else\r
 396                 {\r
 397                         weight = w;\r
 398                         vertex = v;\r
 399                 }\r
 400 \r
 401                 return Result::Last;\r
 402         }\r
 403 \r
 404         Result SkinInfo::SetBoneVertexInfluence( int bone, int influence, float weight )\r
 405         {\r
 406                 HRESULT hr = InternalPointer->SetBoneVertexInfluence( bone, influence, weight );\r
 407                 return RECORD_D3D9( hr );\r
 408         }\r
 409 \r
 410         Matrix SkinInfo::GetBoneOffsetMatrix( int bone )\r
 411         {\r
 412                 return Matrix::FromD3DXMATRIX( *InternalPointer->GetBoneOffsetMatrix( bone ) );\r
 413         }\r
 414 \r
 415         Result SkinInfo::SetBoneOffsetMatrix( int bone, Matrix matrix )\r
 416         {\r
 417                 HRESULT hr = InternalPointer->SetBoneOffsetMatrix( bone, reinterpret_cast<D3DXMATRIX*>( &matrix ) );\r
 418                 return RECORD_D3D9( hr );\r
 419         }\r
 420 \r
 421         array<VertexElement>^ SkinInfo::GetDeclaration()\r
 422         {\r
 423                 D3DVERTEXELEMENT9 elementBuffer[MAX_FVF_DECL_SIZE];\r
 424                 HRESULT hr = InternalPointer->GetDeclaration( elementBuffer );\r
 425                 \r
 426                 if( RECORD_D3D9( hr ).IsFailure )\r
 427                         return nullptr;\r
 428 \r
 429                 // Apparently the returned decl does not include an End element. This is bizarre and confusing,\r
 430                 // not to mention completely unexpected. We patch it up here.\r
 431                 int count = D3DXGetDeclLength( elementBuffer ) + 1;\r
 432                 array<VertexElement>^ elements = gcnew array<VertexElement>( count );\r
 433                 pin_ptr<VertexElement> pinnedElements = &elements[0];\r
 434                 memcpy( pinnedElements, elementBuffer, count * sizeof(D3DVERTEXELEMENT9) );\r
 435                 elements[count - 1] = VertexElement::VertexDeclarationEnd;\r
 436 \r
 437                 return elements;\r
 438         }\r
 439 \r
 440         Result SkinInfo::SetDeclaration( array<VertexElement>^ declaration )\r
 441         {\r
 442                 pin_ptr<VertexElement> pinnedDecl = &declaration[0];\r
 443 \r
 444                 HRESULT hr = InternalPointer->SetDeclaration( reinterpret_cast<D3DVERTEXELEMENT9*>( pinnedDecl ) );\r
 445                 return RECORD_D3D9( hr );\r
 446         }\r
 447 \r
 448         int SkinInfo::GetMaxFaceInfluences( IndexBuffer^ indexBuffer, int faceCount )\r
 449         {\r
 450                 DWORD ret;\r
 451 \r
 452                 HRESULT hr = InternalPointer->GetMaxFaceInfluences( indexBuffer->InternalPointer, faceCount, &ret );\r
 453                 \r
 454                 if( RECORD_D3D9( hr ).IsFailure )\r
 455                         return 0;\r
 456 \r
 457                 return ret;\r
 458         }\r
 459 \r
 460         Result SkinInfo::Remap( array<int>^ remapData )\r
 461         {\r
 462                 pin_ptr<int> pinnedData = &remapData[0];\r
 463 \r
 464                 HRESULT hr = InternalPointer->Remap( remapData->Length, reinterpret_cast<DWORD*>( pinnedData ) );\r
 465                 return RECORD_D3D9( hr );\r
 466         }\r
 467 \r
 468         Result SkinInfo::UpdateSkinnedMesh( array<Matrix>^ boneTransforms, array<Matrix>^ boneInvTransposeTransforms, DataStream^ source, DataStream^ destination )\r
 469         {\r
 470                 pin_ptr<Matrix> pinnedTransforms = &boneTransforms[0];\r
 471                 pin_ptr<Matrix> pinnedInvTransforms = &boneInvTransposeTransforms[0];\r
 472 \r
 473                 HRESULT hr = InternalPointer->UpdateSkinnedMesh( reinterpret_cast<const D3DXMATRIX*>( pinnedTransforms ),\r
 474                         reinterpret_cast<const D3DXMATRIX*>( pinnedInvTransforms ), source->PositionPointer, destination->PositionPointer );\r
 475                 return RECORD_D3D9( hr );\r
 476         }\r
 477 \r
 478         int SkinInfo::GetBoneInfluenceCount( int bone )\r
 479         {\r
 480                 return InternalPointer->GetNumBoneInfluences( bone );\r
 481         }\r
 482 \r
 483         int SkinInfo::MaximumVertexInfluences::get()\r
 484         {\r
 485                 DWORD result;\r
 486 \r
 487                 HRESULT hr = InternalPointer->GetMaxVertexInfluences( &result );\r
 488                 \r
 489                 if( RECORD_D3D9( hr ).IsFailure )\r
 490                         return 0;\r
 491 \r
 492                 return result;\r
 493         }\r
 494 \r
 495         int SkinInfo::BoneCount::get()\r
 496         {\r
 497                 return InternalPointer->GetNumBones();\r
 498         }\r
 499 \r
 500         float SkinInfo::MinimumBoneInfluence::get()\r
 501         {\r
 502                 return InternalPointer->GetMinBoneInfluence();\r
 503         }\r
 504 \r
 505         void SkinInfo::MinimumBoneInfluence::set( float value )\r
 506         {\r
 507                 HRESULT hr = InternalPointer->SetMinBoneInfluence( value );\r
 508                 RECORD_D3D9( hr );\r
 509         }\r
 510 \r
 511         SlimDX::Direct3D9::VertexFormat SkinInfo::VertexFormat::get()\r
 512         {\r
 513                 return static_cast<SlimDX::Direct3D9::VertexFormat>( InternalPointer->GetFVF() );\r
 514         }\r
 515 \r
 516         void SkinInfo::VertexFormat::set( SlimDX::Direct3D9::VertexFormat value )\r
 517         {\r
 518                 HRESULT hr = InternalPointer->SetFVF( static_cast<DWORD>( value ) );\r
 519                 RECORD_D3D9( hr );\r
 520         }\r
 521 }\r
 522 }\r