SlimDXc_Jun2010(VC++2008)/source/direct3d9/AnimationController.cpp

   1 /*\r
   2 * Copyright (c) 2007-2010 SlimDX Group\r
   3 * \r
   4 * Permission is hereby granted, free of charge, to any person obtaining a copy\r
   5 * of this software and associated documentation files (the "Software"), to deal\r
   6 * in the Software without restriction, including without limitation the rights\r
   7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r
   8 * copies of the Software, and to permit persons to whom the Software is\r
   9 * furnished to do so, subject to the following conditions:\r
  10 * \r
  11 * The above copyright notice and this permission notice shall be included in\r
  12 * all copies or substantial portions of the Software.\r
  13 * \r
  14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
  16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r
  17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r
  18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
  19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r
  20 * THE SOFTWARE.\r
  21 */\r
  22 #include "stdafx.h"\r
  23 \r
  24 #include "../DataStream.h"\r
  25 #include "../ComObject.h"\r
  26 \r
  27 #include "../Math/Matrix.h"\r
  28 #include "../Math/Vector3.h"\r
  29 \r
  30 #include "Direct3D9Exception.h"\r
  31 \r
  32 #include "AnimationFrame.h"\r
  33 #include "AnimationSet.h"\r
  34 #include "AnimationController.h"\r
  35 #include "TrackDescription.h"\r
  36 #include "EventDescription.h"\r
  37 \r
  38 using namespace System;\r
  39 using namespace System::Collections::Generic;\r
  40 using namespace System::Runtime::InteropServices;\r
  41 \r
  42 namespace SlimDX\r
  43 {\r
  44 namespace Direct3D9\r
  45 {\r
  46         AnimationController::AnimationController( int maxAnimationOutputs, int maxAnimationSets, int maxTracks, int maxEvents )\r
  47         {\r
  48                 ID3DXAnimationController *pointer;\r
  49 \r
  50                 HRESULT hr = D3DXCreateAnimationController( maxAnimationOutputs, maxAnimationSets, maxTracks, maxEvents, &pointer );            \r
  51                 if( RECORD_D3D9( hr ).IsFailure )\r
  52                         throw gcnew Direct3D9Exception( Result::Last );\r
  53 \r
  54                 outputs = gcnew List<GCHandle>();\r
  55 \r
  56                 Construct( pointer );\r
  57         }\r
  58 \r
  59         AnimationController::~AnimationController()\r
  60         {\r
  61                 for each (GCHandle handle in outputs)\r
  62                         handle.Free();\r
  63         }\r
  64 \r
  65         Result AnimationController::AdvanceTime( double time, AnimationCallback^ handler )\r
  66         {\r
  67                 LPD3DXANIMATIONCALLBACKHANDLER callback = NULL;\r
  68                 if(handler != nullptr)\r
  69                         callback = reinterpret_cast< LPD3DXANIMATIONCALLBACKHANDLER >( Marshal::GetFunctionPointerForDelegate( handler ).ToPointer() );\r
  70 \r
  71                 HRESULT hr = InternalPointer->AdvanceTime( time, callback );\r
  72                 return RECORD_D3D9( hr );\r
  73         }\r
  74 \r
  75         AnimationController^ AnimationController::Clone( int maxAnimationOutputs, int maxAnimationSets, int maxTracks, int maxEvents )\r
  76         {\r
  77                 LPD3DXANIMATIONCONTROLLER pointer;\r
  78 \r
  79                 HRESULT hr = InternalPointer->CloneAnimationController( maxAnimationOutputs, maxAnimationSets, maxTracks, maxEvents, &pointer );\r
  80 \r
  81                 if( RECORD_D3D9( hr ).IsFailure )\r
  82                         return nullptr;\r
  83 \r
  84                 return gcnew AnimationController( pointer, nullptr );\r
  85         }\r
  86 \r
  87         AnimationSet^ AnimationController::GetAnimationSet( int index )\r
  88         {\r
  89                 LPD3DXANIMATIONSET set;\r
  90 \r
  91                 HRESULT hr = InternalPointer->GetAnimationSet( index, &set );\r
  92 \r
  93                 if( RECORD_D3D9( hr ).IsFailure )\r
  94                         return nullptr;\r
  95 \r
  96                 return InternalAnimationSet::FromPointer( set, this );\r
  97         }\r
  98 \r
  99         AnimationSet^ AnimationController::GetAnimationSet( String^ name )\r
 100         {\r
 101                 LPD3DXANIMATIONSET set;\r
 102                 array<unsigned char>^ nameBytes = System::Text::ASCIIEncoding::ASCII->GetBytes( name );\r
 103                 pin_ptr<unsigned char> pinnedName = &nameBytes[0];\r
 104 \r
 105                 HRESULT hr = InternalPointer->GetAnimationSetByName( reinterpret_cast<LPCSTR>( pinnedName ), &set );\r
 106                 \r
 107                 if( RECORD_D3D9( hr ).IsFailure )\r
 108                         return nullptr;\r
 109 \r
 110                 return InternalAnimationSet::FromPointer( set, this );\r
 111         }\r
 112 \r
 113         int AnimationController::GetCurrentTrackEvent( int track, EventType eventType )\r
 114         {\r
 115                 return InternalPointer->GetCurrentTrackEvent( track, static_cast<D3DXEVENT_TYPE>( eventType ) );\r
 116         }\r
 117 \r
 118         EventDescription AnimationController::GetEventDescription( int handle )\r
 119         {\r
 120                 EventDescription result;\r
 121 \r
 122                 HRESULT hr = InternalPointer->GetEventDesc( handle, reinterpret_cast<LPD3DXEVENT_DESC>( &result ) );\r
 123                 RECORD_D3D9( hr );\r
 124 \r
 125                 return result;\r
 126         }\r
 127 \r
 128         AnimationSet^ AnimationController::GetTrackAnimationSet( int track )\r
 129         {\r
 130                 LPD3DXANIMATIONSET set;\r
 131 \r
 132                 HRESULT hr = InternalPointer->GetTrackAnimationSet( track, &set );\r
 133                 \r
 134                 if( RECORD_D3D9( hr ).IsFailure )\r
 135                         return nullptr;\r
 136 \r
 137                 return InternalAnimationSet::FromPointer( set, this );\r
 138         }\r
 139 \r
 140         TrackDescription AnimationController::GetTrackDescription( int track )\r
 141         {\r
 142                 TrackDescription result;\r
 143 \r
 144                 HRESULT hr = InternalPointer->GetTrackDesc( track, reinterpret_cast<LPD3DXTRACK_DESC>( &result ) );\r
 145                 RECORD_D3D9( hr );\r
 146 \r
 147                 return result;\r
 148         }\r
 149 \r
 150         int AnimationController::GetUpcomingPriorityBlend( int handle )\r
 151         {\r
 152                 return InternalPointer->GetUpcomingPriorityBlend( handle );\r
 153         }\r
 154 \r
 155         int AnimationController::GetUpcomingTrackEvent( int track, int handle )\r
 156         {\r
 157                 return InternalPointer->GetUpcomingTrackEvent( track, handle );\r
 158         }\r
 159 \r
 160         int AnimationController::KeyPriorityBlend( float newBlendWeight, double startTime, double duration, TransitionType transition )\r
 161         {\r
 162                 return InternalPointer->KeyPriorityBlend( newBlendWeight, startTime, duration, static_cast<D3DXTRANSITION_TYPE>( transition ) );\r
 163         }\r
 164 \r
 165         int AnimationController::KeyTrackEnable( int track, bool enable, double startTime )\r
 166         {\r
 167                 return InternalPointer->KeyTrackEnable( track, enable, startTime );\r
 168         }\r
 169 \r
 170         int AnimationController::KeyTrackPosition( int track, double position, double startTime )\r
 171         {\r
 172                 return InternalPointer->KeyTrackPosition( track, position, startTime );\r
 173         }\r
 174 \r
 175         int AnimationController::KeyTrackSpeed( int track, float newSpeed, double startTime, double duration, TransitionType transition )\r
 176         {\r
 177                 return InternalPointer->KeyTrackSpeed( track, newSpeed, startTime, duration, static_cast<D3DXTRANSITION_TYPE>( transition ) );\r
 178         }\r
 179 \r
 180         int AnimationController::KeyTrackWeight( int track, float newWeight, double startTime, double duration, TransitionType transition )\r
 181         {\r
 182                 return InternalPointer->KeyTrackWeight( track, newWeight, startTime, duration, static_cast<D3DXTRANSITION_TYPE>( transition ) );\r
 183         }\r
 184 \r
 185         Result AnimationController::RegisterAnimationOutput( Frame^ frame )\r
 186         {\r
 187                 HRESULT hr = InternalPointer->RegisterAnimationOutput( frame->Pointer->Name, &frame->Pointer->TransformationMatrix, NULL, NULL, NULL );\r
 188                 return RECORD_D3D9( hr );\r
 189         }\r
 190 \r
 191         Result AnimationController::RegisterAnimationOutput( String^ name, AnimationOutput^ output )\r
 192         {\r
 193                 D3DXMATRIX *matrix = NULL;\r
 194                 D3DXVECTOR3 *scale = NULL;\r
 195                 D3DXVECTOR3 *translation = NULL;\r
 196                 D3DXQUATERNION *rotation = NULL;\r
 197                 array<unsigned char>^ nameBytes = System::Text::ASCIIEncoding::ASCII->GetBytes( name );\r
 198                 pin_ptr<unsigned char> pinnedName = &nameBytes[0];\r
 199 \r
 200                 GCHandle handle = GCHandle::Alloc(output, GCHandleType::Pinned);\r
 201                 char *ptr = reinterpret_cast<char*>(handle.AddrOfPinnedObject().ToPointer()) + sizeof(AnimationOutputFlags);\r
 202                 outputs->Add(handle);\r
 203 \r
 204                 if( (output->Flags & AnimationOutputFlags::Transformation) == AnimationOutputFlags::Transformation )\r
 205                         matrix = reinterpret_cast<D3DXMATRIX*>(ptr);\r
 206 \r
 207                 ptr += sizeof(D3DXMATRIX);\r
 208                 if( (output->Flags & AnimationOutputFlags::Scale) == AnimationOutputFlags::Scale )\r
 209                         scale = reinterpret_cast<D3DXVECTOR3*>(ptr);\r
 210 \r
 211                 ptr += sizeof(D3DXVECTOR3);\r
 212                 if( (output->Flags & AnimationOutputFlags::Translation) == AnimationOutputFlags::Translation )\r
 213                         translation = reinterpret_cast<D3DXVECTOR3*>(ptr);\r
 214 \r
 215                 ptr += sizeof(D3DXVECTOR3);\r
 216                 if( (output->Flags & AnimationOutputFlags::Rotation) == AnimationOutputFlags::Rotation )\r
 217                         rotation = reinterpret_cast<D3DXQUATERNION*>(ptr);\r
 218 \r
 219                 HRESULT hr = InternalPointer->RegisterAnimationOutput( reinterpret_cast<LPCSTR>( pinnedName ), matrix, scale, rotation, translation );\r
 220                 return RECORD_D3D9( hr );\r
 221         }\r
 222 \r
 223         Result AnimationController::RegisterAnimationSet( AnimationSet^ set )\r
 224         {\r
 225                 HRESULT hr = InternalPointer->RegisterAnimationSet( set->InternalPointer );\r
 226                 return RECORD_D3D9( hr );\r
 227         }\r
 228 \r
 229         Result AnimationController::ResetTime()\r
 230         {\r
 231                 HRESULT hr = InternalPointer->ResetTime();\r
 232                 return RECORD_D3D9( hr );\r
 233         }\r
 234 \r
 235         Result AnimationController::SetTrackAnimationSet( int track, AnimationSet^ set )\r
 236         {\r
 237                 HRESULT hr = InternalPointer->SetTrackAnimationSet( track, set->InternalPointer );\r
 238                 return RECORD_D3D9( hr );\r
 239         }\r
 240 \r
 241         Result AnimationController::SetTrackDescription( int track, TrackDescription description )\r
 242         {\r
 243                 HRESULT hr = InternalPointer->SetTrackDesc( track, reinterpret_cast<LPD3DXTRACK_DESC>( &description ) );\r
 244                 return RECORD_D3D9( hr );\r
 245         }\r
 246 \r
 247         Result AnimationController::EnableTrack( int track )\r
 248         {\r
 249                 HRESULT hr = InternalPointer->SetTrackEnable( track, true );\r
 250                 return RECORD_D3D9( hr );\r
 251         }\r
 252 \r
 253         Result AnimationController::DisableTrack( int track )\r
 254         {\r
 255                 HRESULT hr = InternalPointer->SetTrackEnable( track, false );\r
 256                 return RECORD_D3D9( hr );\r
 257         }\r
 258 \r
 259         Result AnimationController::SetTrackPosition( int track, double position )\r
 260         {\r
 261                 HRESULT hr = InternalPointer->SetTrackPosition( track, position );\r
 262                 return RECORD_D3D9( hr );\r
 263         }\r
 264 \r
 265         Result AnimationController::SetTrackPriority( int track, TrackPriority priority )\r
 266         {\r
 267                 HRESULT hr = InternalPointer->SetTrackPriority( track, static_cast<D3DXPRIORITY_TYPE>( priority ) );\r
 268                 return RECORD_D3D9( hr );\r
 269         }\r
 270 \r
 271         Result AnimationController::SetTrackSpeed( int track, float speed )\r
 272         {\r
 273                 HRESULT hr = InternalPointer->SetTrackSpeed( track, speed );\r
 274                 return RECORD_D3D9( hr );\r
 275         }\r
 276 \r
 277         Result AnimationController::SetTrackWeight( int track, float weight )\r
 278         {\r
 279                 HRESULT hr = InternalPointer->SetTrackWeight( track, weight );\r
 280                 return RECORD_D3D9( hr );\r
 281         }\r
 282 \r
 283         Result AnimationController::UnkeyAllPriorityBlends()\r
 284         {\r
 285                 HRESULT hr = InternalPointer->UnkeyAllPriorityBlends();\r
 286                 return RECORD_D3D9( hr );\r
 287         }\r
 288 \r
 289         Result AnimationController::UnkeyAllTrackEvents( int track )\r
 290         {\r
 291                 HRESULT hr = InternalPointer->UnkeyAllTrackEvents( track );\r
 292                 return RECORD_D3D9( hr );\r
 293         }\r
 294 \r
 295         Result AnimationController::UnkeyEvent( int handle )\r
 296         {\r
 297                 HRESULT hr = InternalPointer->UnkeyEvent( handle );\r
 298                 return RECORD_D3D9( hr );\r
 299         }\r
 300 \r
 301         Result AnimationController::UnregisterAnimationSet( AnimationSet^ set )\r
 302         {\r
 303                 HRESULT hr = InternalPointer->UnregisterAnimationSet( set->InternalPointer );\r
 304                 return RECORD_D3D9( hr );\r
 305         }\r
 306 \r
 307         bool AnimationController::ValidateEvent( int handle )\r
 308         {\r
 309                 HRESULT hr = InternalPointer->ValidateEvent( handle );\r
 310 \r
 311                 return (hr == S_OK);\r
 312         }\r
 313 \r
 314         double AnimationController::Time::get()\r
 315         {\r
 316                 return InternalPointer->GetTime();\r
 317         }\r
 318 \r
 319         int AnimationController::CurrentPriorityBlend::get()\r
 320         {\r
 321                 return InternalPointer->GetCurrentPriorityBlend();\r
 322         }\r
 323 \r
 324         float AnimationController::PriorityBlend::get()\r
 325         {\r
 326                 return InternalPointer->GetPriorityBlend();\r
 327         }\r
 328 \r
 329         void AnimationController::PriorityBlend::set( float value )\r
 330         {\r
 331                 InternalPointer->SetPriorityBlend( value );\r
 332         }\r
 333 \r
 334         int AnimationController::AnimationSetCount::get()\r
 335         {\r
 336                 return InternalPointer->GetNumAnimationSets();\r
 337         }\r
 338 \r
 339         int AnimationController::MaxAnimationOutputs::get()\r
 340         {\r
 341                 return InternalPointer->GetMaxNumAnimationOutputs();\r
 342         }\r
 343 \r
 344         int AnimationController::MaxAnimationSets::get()\r
 345         {\r
 346                 return InternalPointer->GetMaxNumAnimationSets();\r
 347         }\r
 348 \r
 349         int AnimationController::MaxTracks::get()\r
 350         {\r
 351                 return InternalPointer->GetMaxNumTracks();\r
 352         }\r
 353 \r
 354         int AnimationController::MaxEvents::get()\r
 355         {\r
 356                 return InternalPointer->GetMaxNumEvents();\r
 357         }\r
 358 }\r
 359 }\r