dlls/windows.gaming.input/force_feedback.c

   1 /* WinRT Windows.Gaming.Input implementation
   2  *
   3  * Copyright 2022 Rémi Bernon for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "private.h"
  21
  22 #include "math.h"
  23
  24 #include "ddk/hidsdi.h"
  25 #include "dinput.h"
  26 #include "hidusage.h"
  27 #include "provider.h"
  28
  29 #include "wine/debug.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(input);
  32
  33 struct effect
  34 {
  35     IWineForceFeedbackEffectImpl IWineForceFeedbackEffectImpl_iface;
  36     IForceFeedbackEffect IForceFeedbackEffect_iface;
  37     IInspectable *IInspectable_outer;
  38     LONG ref;
  39
  40     CRITICAL_SECTION cs;
  41     IDirectInputEffect *effect;
  42
  43     GUID type;
  44     DWORD axes[3];
  45     LONG directions[3];
  46     ULONG repeat_count;
  47     DICONSTANTFORCE constant_force;
  48     DIRAMPFORCE ramp_force;
  49     DICONDITION condition;
  50     DIPERIODIC periodic;
  51     DIENVELOPE envelope;
  52     DIEFFECT params;
  53 };
  54
  55 static inline struct effect *impl_from_IWineForceFeedbackEffectImpl( IWineForceFeedbackEffectImpl *iface )
  56 {
  57     return CONTAINING_RECORD( iface, struct effect, IWineForceFeedbackEffectImpl_iface );
  58 }
  59
  60 static HRESULT WINAPI effect_impl_QueryInterface( IWineForceFeedbackEffectImpl *iface, REFIID iid, void **out )
  61 {
  62     struct effect *impl = impl_from_IWineForceFeedbackEffectImpl( iface );
  63
  64     TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
  65
  66     if (IsEqualGUID( iid, &IID_IUnknown ) ||
  67         IsEqualGUID( iid, &IID_IInspectable ) ||
  68         IsEqualGUID( iid, &IID_IAgileObject ) ||
  69         IsEqualGUID( iid, &IID_IWineForceFeedbackEffectImpl ))
  70     {
  71         IWineForceFeedbackEffectImpl_AddRef( (*out = &impl->IWineForceFeedbackEffectImpl_iface) );
  72         return S_OK;
  73     }
  74
  75     if (IsEqualGUID( iid, &IID_IForceFeedbackEffect ))
  76     {
  77         IInspectable_AddRef( (*out = &impl->IForceFeedbackEffect_iface) );
  78         return S_OK;
  79     }
  80
  81     FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
  82     *out = NULL;
  83     return E_NOINTERFACE;
  84 }
  85
  86 static ULONG WINAPI effect_impl_AddRef( IWineForceFeedbackEffectImpl *iface )
  87 {
  88     struct effect *impl = impl_from_IWineForceFeedbackEffectImpl( iface );
  89     ULONG ref = InterlockedIncrement( &impl->ref );
  90     TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
  91     return ref;
  92 }
  93
  94 static ULONG WINAPI effect_impl_Release( IWineForceFeedbackEffectImpl *iface )
  95 {
  96     struct effect *impl = impl_from_IWineForceFeedbackEffectImpl( iface );
  97     ULONG ref = InterlockedDecrement( &impl->ref );
  98
  99     TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
 100
 101     if (!ref)
 102     {
 103         if (impl->effect) IDirectInputEffect_Release( impl->effect );
 104         impl->cs.DebugInfo->Spare[0] = 0;
 105         DeleteCriticalSection( &impl->cs );
 106         free( impl );
 107     }
 108
 109     return ref;
 110 }
 111
 112 static int effect_reorient_direction( const WineForceFeedbackEffectParameters *params, Vector3 *direction )
 113 {
 114     int sign = +1;
 115
 116     switch (params->type)
 117     {
 118     case WineForceFeedbackEffectType_Constant:
 119         *direction = params->constant.direction;
 120         sign = params->constant.direction.X < 0 ? -1 : +1;
 121         break;
 122
 123     case WineForceFeedbackEffectType_Ramp:
 124         *direction = params->ramp.start_vector;
 125         sign = params->ramp.start_vector.X < 0 ? -1 : +1;
 126         break;
 127
 128     case WineForceFeedbackEffectType_Periodic_SineWave:
 129     case WineForceFeedbackEffectType_Periodic_TriangleWave:
 130     case WineForceFeedbackEffectType_Periodic_SquareWave:
 131     case WineForceFeedbackEffectType_Periodic_SawtoothWaveDown:
 132     case WineForceFeedbackEffectType_Periodic_SawtoothWaveUp:
 133         *direction = params->periodic.direction;
 134         break;
 135
 136     case WineForceFeedbackEffectType_Condition_Spring:
 137     case WineForceFeedbackEffectType_Condition_Damper:
 138     case WineForceFeedbackEffectType_Condition_Inertia:
 139     case WineForceFeedbackEffectType_Condition_Friction:
 140         *direction = params->condition.direction;
 141         sign = -1;
 142         break;
 143     }
 144
 145     direction->X *= -sign;
 146     direction->Y *= -sign;
 147     direction->Z *= -sign;
 148
 149     return sign;
 150 }
 151
 152 static HRESULT WINAPI effect_impl_put_Parameters( IWineForceFeedbackEffectImpl *iface, WineForceFeedbackEffectParameters params,
 153                                                   WineForceFeedbackEffectEnvelope *envelope )
 154 {
 155     struct effect *impl = impl_from_IWineForceFeedbackEffectImpl( iface );
 156     Vector3 direction = {0};
 157     double magnitude = 0;
 158     DWORD count = 0;
 159     HRESULT hr;
 160     int sign;
 161
 162     TRACE( "iface %p, params %p, envelope %p.\n", iface, &params, envelope );
 163
 164     EnterCriticalSection( &impl->cs );
 165
 166     sign = effect_reorient_direction( &params, &direction );
 167     /* Y and Z axes seems to be always ignored, is it really the case? */
 168     magnitude += direction.X * direction.X;
 169
 170     switch (params.type)
 171     {
 172     case WineForceFeedbackEffectType_Constant:
 173         impl->repeat_count = params.constant.repeat_count;
 174         impl->constant_force.lMagnitude = sign * round( params.constant.gain * sqrt( magnitude ) * 10000 );
 175         impl->params.dwDuration = min( max( params.constant.duration.Duration / 10, 0 ), INFINITE );
 176         impl->params.dwStartDelay = min( max( params.constant.start_delay.Duration / 10, 0 ), INFINITE );
 177         break;
 178
 179     case WineForceFeedbackEffectType_Ramp:
 180         impl->repeat_count = params.ramp.repeat_count;
 181         impl->ramp_force.lStart = sign * round( params.ramp.gain * sqrt( magnitude ) * 10000 );
 182         impl->ramp_force.lEnd = round( params.ramp.gain * params.ramp.end_vector.X * 10000 );
 183         impl->params.dwDuration = min( max( params.ramp.duration.Duration / 10, 0 ), INFINITE );
 184         impl->params.dwStartDelay = min( max( params.ramp.start_delay.Duration / 10, 0 ), INFINITE );
 185         break;
 186
 187     case WineForceFeedbackEffectType_Periodic_SineWave:
 188     case WineForceFeedbackEffectType_Periodic_TriangleWave:
 189     case WineForceFeedbackEffectType_Periodic_SquareWave:
 190     case WineForceFeedbackEffectType_Periodic_SawtoothWaveDown:
 191     case WineForceFeedbackEffectType_Periodic_SawtoothWaveUp:
 192         impl->repeat_count = params.periodic.repeat_count;
 193         impl->periodic.dwMagnitude = round( params.periodic.gain * 10000 );
 194         impl->periodic.dwPeriod = 1000000 / params.periodic.frequency;
 195         impl->periodic.dwPhase = round( params.periodic.phase * 36000 );
 196         impl->periodic.lOffset = round( params.periodic.bias * 10000 );
 197         impl->params.dwDuration = min( max( params.periodic.duration.Duration / 10, 0 ), INFINITE );
 198         impl->params.dwStartDelay = min( max( params.periodic.start_delay.Duration / 10, 0 ), INFINITE );
 199         break;
 200
 201     case WineForceFeedbackEffectType_Condition_Spring:
 202     case WineForceFeedbackEffectType_Condition_Damper:
 203     case WineForceFeedbackEffectType_Condition_Inertia:
 204     case WineForceFeedbackEffectType_Condition_Friction:
 205         impl->repeat_count = 1;
 206         impl->condition.lPositiveCoefficient = round( atan( params.condition.positive_coeff ) / M_PI_2 * 10000 );
 207         impl->condition.lNegativeCoefficient = round( atan( params.condition.negative_coeff ) / M_PI_2 * 10000 );
 208         impl->condition.dwPositiveSaturation = round( params.condition.max_positive_magnitude * 10000 );
 209         impl->condition.dwNegativeSaturation = round( params.condition.max_negative_magnitude * 10000 );
 210         impl->condition.lDeadBand = round( params.condition.deadzone * 10000 );
 211         impl->condition.lOffset = round( params.condition.bias * 10000 );
 212         impl->params.dwDuration = -1;
 213         impl->params.dwStartDelay = 0;
 214         break;
 215     }
 216
 217     if (impl->axes[count] == DIJOFS_X) impl->directions[count++] = round( direction.X * 10000 );
 218     if (impl->axes[count] == DIJOFS_Y) impl->directions[count++] = round( direction.Y * 10000 );
 219     if (impl->axes[count] == DIJOFS_Z) impl->directions[count++] = round( direction.Z * 10000 );
 220
 221     if (!envelope) impl->params.lpEnvelope = NULL;
 222     else
 223     {
 224         impl->envelope.dwAttackTime = min( max( envelope->attack_duration.Duration / 10, 0 ), INFINITE );
 225         impl->envelope.dwAttackLevel = round( envelope->attack_gain * 10000 );
 226         impl->envelope.dwFadeTime = impl->params.dwDuration - min( max( envelope->release_duration.Duration / 10, 0 ), INFINITE );
 227         impl->envelope.dwFadeLevel = round( envelope->release_gain * 10000 );
 228         impl->params.lpEnvelope = &impl->envelope;
 229     }
 230
 231     if (!impl->effect) hr = S_OK;
 232     else hr = IDirectInputEffect_SetParameters( impl->effect, &impl->params, DIEP_ALLPARAMS & ~DIEP_AXES );
 233     LeaveCriticalSection( &impl->cs );
 234
 235     return hr;
 236 }
 237
 238 static const struct IWineForceFeedbackEffectImplVtbl effect_impl_vtbl =
 239 {
 240     effect_impl_QueryInterface,
 241     effect_impl_AddRef,
 242     effect_impl_Release,
 243     /* IWineForceFeedbackEffectImpl methods */
 244     effect_impl_put_Parameters,
 245 };
 246
 247 DEFINE_IINSPECTABLE_OUTER( effect, IForceFeedbackEffect, struct effect, IInspectable_outer )
 248
 249 static HRESULT WINAPI effect_get_Gain( IForceFeedbackEffect *iface, DOUBLE *value )
 250 {
 251     struct effect *impl = impl_from_IForceFeedbackEffect( iface );
 252
 253     TRACE( "iface %p, value %p.\n", iface, value );
 254
 255     EnterCriticalSection( &impl->cs );
 256     *value = impl->params.dwGain / 10000.;
 257     LeaveCriticalSection( &impl->cs );
 258
 259     return S_OK;
 260 }
 261
 262 static HRESULT WINAPI effect_put_Gain( IForceFeedbackEffect *iface, DOUBLE value )
 263 {
 264     struct effect *impl = impl_from_IForceFeedbackEffect( iface );
 265     HRESULT hr;
 266
 267     TRACE( "iface %p, value %f.\n", iface, value );
 268
 269     EnterCriticalSection( &impl->cs );
 270     impl->params.dwGain = round( value * 10000 );
 271     if (!impl->effect) hr = S_FALSE;
 272     else hr = IDirectInputEffect_SetParameters( impl->effect, &impl->params, DIEP_GAIN );
 273     LeaveCriticalSection( &impl->cs );
 274
 275     return hr;
 276 }
 277
 278 static HRESULT WINAPI effect_get_State( IForceFeedbackEffect *iface, ForceFeedbackEffectState *value )
 279 {
 280     struct effect *impl = impl_from_IForceFeedbackEffect( iface );
 281     DWORD status;
 282     HRESULT hr;
 283
 284     TRACE( "iface %p, value %p.\n", iface, value );
 285
 286     EnterCriticalSection( &impl->cs );
 287     if (!impl->effect)
 288         *value = ForceFeedbackEffectState_Stopped;
 289     else if (FAILED(hr = IDirectInputEffect_GetEffectStatus( impl->effect, &status )))
 290         *value = ForceFeedbackEffectState_Faulted;
 291     else
 292     {
 293         if (status == DIEGES_PLAYING) *value = ForceFeedbackEffectState_Running;
 294         else *value = ForceFeedbackEffectState_Stopped;
 295     }
 296     LeaveCriticalSection( &impl->cs );
 297
 298     return S_OK;
 299 }
 300
 301 static HRESULT WINAPI effect_Start( IForceFeedbackEffect *iface )
 302 {
 303     struct effect *impl = impl_from_IForceFeedbackEffect( iface );
 304     HRESULT hr = E_UNEXPECTED;
 305     DWORD flags = 0;
 306
 307     TRACE( "iface %p.\n", iface );
 308
 309     EnterCriticalSection( &impl->cs );
 310     if (impl->effect) hr = IDirectInputEffect_Start( impl->effect, impl->repeat_count, flags );
 311     LeaveCriticalSection( &impl->cs );
 312
 313     return hr;
 314 }
 315
 316 static HRESULT WINAPI effect_Stop( IForceFeedbackEffect *iface )
 317 {
 318     struct effect *impl = impl_from_IForceFeedbackEffect( iface );
 319     HRESULT hr = E_UNEXPECTED;
 320
 321     TRACE( "iface %p.\n", iface );
 322
 323     EnterCriticalSection( &impl->cs );
 324     if (impl->effect) hr = IDirectInputEffect_Stop( impl->effect );
 325     LeaveCriticalSection( &impl->cs );
 326
 327     return hr;
 328 }
 329
 330 static const struct IForceFeedbackEffectVtbl effect_vtbl =
 331 {
 332     effect_QueryInterface,
 333     effect_AddRef,
 334     effect_Release,
 335     /* IInspectable methods */
 336     effect_GetIids,
 337     effect_GetRuntimeClassName,
 338     effect_GetTrustLevel,
 339     /* IForceFeedbackEffect methods */
 340     effect_get_Gain,
 341     effect_put_Gain,
 342     effect_get_State,
 343     effect_Start,
 344     effect_Stop,
 345 };
 346
 347 HRESULT force_feedback_effect_create( enum WineForceFeedbackEffectType type, IInspectable *outer, IWineForceFeedbackEffectImpl **out )
 348 {
 349     struct effect *impl;
 350
 351     TRACE( "outer %p, out %p\n", outer, out );
 352
 353     if (!(impl = calloc( 1, sizeof(*impl) ))) return E_OUTOFMEMORY;
 354     impl->IWineForceFeedbackEffectImpl_iface.lpVtbl = &effect_impl_vtbl;
 355     impl->IForceFeedbackEffect_iface.lpVtbl = &effect_vtbl;
 356     impl->IInspectable_outer = outer;
 357     impl->ref = 1;
 358
 359     switch (type)
 360     {
 361     case WineForceFeedbackEffectType_Constant:
 362         impl->type = GUID_ConstantForce;
 363         impl->params.lpvTypeSpecificParams = &impl->constant_force;
 364         impl->params.cbTypeSpecificParams = sizeof(impl->constant_force);
 365         break;
 366
 367     case WineForceFeedbackEffectType_Ramp:
 368         impl->type = GUID_RampForce;
 369         impl->params.lpvTypeSpecificParams = &impl->ramp_force;
 370         impl->params.cbTypeSpecificParams = sizeof(impl->ramp_force);
 371         break;
 372
 373     case WineForceFeedbackEffectType_Periodic_SineWave:
 374         impl->type = GUID_Sine;
 375         goto WineForceFeedbackEffectType_Periodic;
 376     case WineForceFeedbackEffectType_Periodic_TriangleWave:
 377         impl->type = GUID_Triangle;
 378         goto WineForceFeedbackEffectType_Periodic;
 379     case WineForceFeedbackEffectType_Periodic_SquareWave:
 380         impl->type = GUID_Square;
 381         goto WineForceFeedbackEffectType_Periodic;
 382     case WineForceFeedbackEffectType_Periodic_SawtoothWaveDown:
 383         impl->type = GUID_SawtoothDown;
 384         goto WineForceFeedbackEffectType_Periodic;
 385     case WineForceFeedbackEffectType_Periodic_SawtoothWaveUp:
 386         impl->type = GUID_SawtoothUp;
 387         goto WineForceFeedbackEffectType_Periodic;
 388     WineForceFeedbackEffectType_Periodic:
 389         impl->params.lpvTypeSpecificParams = &impl->periodic;
 390         impl->params.cbTypeSpecificParams = sizeof(impl->periodic);
 391         break;
 392
 393     case WineForceFeedbackEffectType_Condition_Spring:
 394         impl->type = GUID_Spring;
 395         goto WineForceFeedbackEffectType_Condition;
 396     case WineForceFeedbackEffectType_Condition_Damper:
 397         impl->type = GUID_Damper;
 398         goto WineForceFeedbackEffectType_Condition;
 399     case WineForceFeedbackEffectType_Condition_Inertia:
 400         impl->type = GUID_Inertia;
 401         goto WineForceFeedbackEffectType_Condition;
 402     case WineForceFeedbackEffectType_Condition_Friction:
 403         impl->type = GUID_Friction;
 404         goto WineForceFeedbackEffectType_Condition;
 405     WineForceFeedbackEffectType_Condition:
 406         impl->params.lpvTypeSpecificParams = &impl->condition;
 407         impl->params.cbTypeSpecificParams = sizeof(impl->condition);
 408         break;
 409     }
 410
 411     impl->envelope.dwSize = sizeof(DIENVELOPE);
 412     impl->params.dwSize = sizeof(DIEFFECT);
 413     impl->params.rgdwAxes = impl->axes;
 414     impl->params.rglDirection = impl->directions;
 415     impl->params.dwTriggerButton = -1;
 416     impl->params.dwGain = 10000;
 417     impl->params.dwFlags = DIEFF_CARTESIAN|DIEFF_OBJECTOFFSETS;
 418     impl->params.cAxes = -1;
 419     impl->axes[0] = DIJOFS_X;
 420     impl->axes[1] = DIJOFS_Y;
 421     impl->axes[2] = DIJOFS_Z;
 422
 423     InitializeCriticalSection( &impl->cs );
 424     impl->cs.DebugInfo->Spare[0] = (DWORD_PTR)( __FILE__ ": effect.cs" );
 425
 426     *out = &impl->IWineForceFeedbackEffectImpl_iface;
 427     TRACE( "created ForceFeedbackEffect %p\n", *out );
 428     return S_OK;
 429 }
 430
 431 struct motor
 432 {
 433     IForceFeedbackMotor IForceFeedbackMotor_iface;
 434     LONG ref;
 435
 436     IDirectInputDevice8W *device;
 437 };
 438
 439 static inline struct motor *impl_from_IForceFeedbackMotor( IForceFeedbackMotor *iface )
 440 {
 441     return CONTAINING_RECORD( iface, struct motor, IForceFeedbackMotor_iface );
 442 }
 443
 444 static HRESULT WINAPI motor_QueryInterface( IForceFeedbackMotor *iface, REFIID iid, void **out )
 445 {
 446     struct motor *impl = impl_from_IForceFeedbackMotor( iface );
 447
 448     TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
 449
 450     if (IsEqualGUID( iid, &IID_IUnknown ) ||
 451         IsEqualGUID( iid, &IID_IInspectable ) ||
 452         IsEqualGUID( iid, &IID_IAgileObject ) ||
 453         IsEqualGUID( iid, &IID_IForceFeedbackMotor ))
 454     {
 455         IInspectable_AddRef( (*out = &impl->IForceFeedbackMotor_iface) );
 456         return S_OK;
 457     }
 458
 459     FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
 460     *out = NULL;
 461     return E_NOINTERFACE;
 462 }
 463
 464 static ULONG WINAPI motor_AddRef( IForceFeedbackMotor *iface )
 465 {
 466     struct motor *impl = impl_from_IForceFeedbackMotor( iface );
 467     ULONG ref = InterlockedIncrement( &impl->ref );
 468     TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
 469     return ref;
 470 }
 471
 472 static ULONG WINAPI motor_Release( IForceFeedbackMotor *iface )
 473 {
 474     struct motor *impl = impl_from_IForceFeedbackMotor( iface );
 475     ULONG ref = InterlockedDecrement( &impl->ref );
 476
 477     TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
 478
 479     if (!ref)
 480     {
 481         IDirectInputDevice8_Release( impl->device );
 482         free( impl );
 483     }
 484
 485     return ref;
 486 }
 487
 488 static HRESULT WINAPI motor_GetIids( IForceFeedbackMotor *iface, ULONG *iid_count, IID **iids )
 489 {
 490     FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
 491     return E_NOTIMPL;
 492 }
 493
 494 static HRESULT WINAPI motor_GetRuntimeClassName( IForceFeedbackMotor *iface, HSTRING *class_name )
 495 {
 496     return WindowsCreateString( RuntimeClass_Windows_Gaming_Input_ForceFeedback_ForceFeedbackMotor,
 497                                 ARRAY_SIZE(RuntimeClass_Windows_Gaming_Input_ForceFeedback_ForceFeedbackMotor),
 498                                 class_name );
 499 }
 500
 501 static HRESULT WINAPI motor_GetTrustLevel( IForceFeedbackMotor *iface, TrustLevel *trust_level )
 502 {
 503     FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
 504     return E_NOTIMPL;
 505 }
 506
 507 static HRESULT WINAPI motor_get_AreEffectsPaused( IForceFeedbackMotor *iface, BOOLEAN *value )
 508 {
 509     struct motor *impl = impl_from_IForceFeedbackMotor( iface );
 510     DWORD state;
 511     HRESULT hr;
 512
 513     TRACE( "iface %p, value %p.\n", iface, value );
 514
 515     if (FAILED(hr = IDirectInputDevice8_GetForceFeedbackState( impl->device, &state ))) *value = FALSE;
 516     else *value = (state & DIGFFS_PAUSED);
 517
 518     return hr;
 519 }
 520
 521 static HRESULT WINAPI motor_get_MasterGain( IForceFeedbackMotor *iface, double *value )
 522 {
 523     struct motor *impl = impl_from_IForceFeedbackMotor( iface );
 524     DIPROPDWORD gain =
 525     {
 526         .diph =
 527         {
 528             .dwSize = sizeof(DIPROPDWORD),
 529             .dwHeaderSize = sizeof(DIPROPHEADER),
 530             .dwHow = DIPH_DEVICE,
 531         },
 532     };
 533     HRESULT hr;
 534
 535     TRACE( "iface %p, value %p.\n", iface, value );
 536
 537     if (FAILED(hr = IDirectInputDevice8_GetProperty( impl->device, DIPROP_FFGAIN, &gain.diph ))) *value = 1.;
 538     else *value = gain.dwData / 10000.;
 539
 540     return hr;
 541 }
 542
 543 static HRESULT WINAPI motor_put_MasterGain( IForceFeedbackMotor *iface, double value )
 544 {
 545     struct motor *impl = impl_from_IForceFeedbackMotor( iface );
 546     DIPROPDWORD gain =
 547     {
 548         .diph =
 549         {
 550             .dwSize = sizeof(DIPROPDWORD),
 551             .dwHeaderSize = sizeof(DIPROPHEADER),
 552             .dwHow = DIPH_DEVICE,
 553         },
 554     };
 555
 556     TRACE( "iface %p, value %f.\n", iface, value );
 557
 558     gain.dwData = 10000 * value;
 559     return IDirectInputDevice8_SetProperty( impl->device, DIPROP_FFGAIN, &gain.diph );
 560 }
 561
 562 static HRESULT WINAPI motor_get_IsEnabled( IForceFeedbackMotor *iface, BOOLEAN *value )
 563 {
 564     struct motor *impl = impl_from_IForceFeedbackMotor( iface );
 565     DWORD state;
 566     HRESULT hr;
 567
 568     TRACE( "iface %p, value %p.\n", iface, value );
 569
 570     if (FAILED(hr = IDirectInputDevice8_GetForceFeedbackState( impl->device, &state ))) *value = FALSE;
 571     else *value = !(state & DIGFFS_ACTUATORSOFF);
 572
 573     return hr;
 574 }
 575
 576 static BOOL CALLBACK check_ffb_axes( const DIDEVICEOBJECTINSTANCEW *obj, void *args )
 577 {
 578     ForceFeedbackEffectAxes *value = args;
 579
 580     if (obj->dwType & DIDFT_FFACTUATOR)
 581     {
 582         if (IsEqualIID( &obj->guidType, &GUID_XAxis )) *value |= ForceFeedbackEffectAxes_X;
 583         else if (IsEqualIID( &obj->guidType, &GUID_YAxis )) *value |= ForceFeedbackEffectAxes_Y;
 584         else if (IsEqualIID( &obj->guidType, &GUID_ZAxis )) *value |= ForceFeedbackEffectAxes_Z;
 585     }
 586
 587     return DIENUM_CONTINUE;
 588 }
 589
 590 static HRESULT WINAPI motor_get_SupportedAxes( IForceFeedbackMotor *iface, enum ForceFeedbackEffectAxes *value )
 591 {
 592     struct motor *impl = impl_from_IForceFeedbackMotor( iface );
 593     HRESULT hr;
 594
 595     TRACE( "iface %p, value %p.\n", iface, value );
 596
 597     *value = ForceFeedbackEffectAxes_None;
 598     if (FAILED(hr = IDirectInputDevice8_EnumObjects( impl->device, check_ffb_axes, value, DIDFT_AXIS )))
 599         *value = ForceFeedbackEffectAxes_None;
 600
 601     return hr;
 602 }
 603
 604 static HRESULT WINAPI motor_load_effect_async( IUnknown *invoker, IUnknown *param, PROPVARIANT *result )
 605 {
 606     struct effect *effect = impl_from_IForceFeedbackEffect( (IForceFeedbackEffect *)param );
 607     IForceFeedbackMotor *motor = (IForceFeedbackMotor *)invoker;
 608     struct motor *impl = impl_from_IForceFeedbackMotor( motor );
 609     ForceFeedbackEffectAxes supported_axes = 0;
 610     IDirectInputEffect *dinput_effect;
 611     HRESULT hr;
 612
 613     EnterCriticalSection( &effect->cs );
 614
 615     if (FAILED(hr = IForceFeedbackMotor_get_SupportedAxes( motor, &supported_axes )))
 616     {
 617         WARN( "get_SupportedAxes for motor %p returned %#lx\n", motor, hr );
 618         effect->params.cAxes = 0;
 619     }
 620     else if (effect->params.cAxes == -1)
 621     {
 622         DWORD count = 0;
 623
 624         /* initialize axis mapping and re-map directions that were set with the initial mapping */
 625         if (supported_axes & ForceFeedbackEffectAxes_X)
 626         {
 627             effect->directions[count] = effect->directions[0];
 628             effect->axes[count++] = DIJOFS_X;
 629         }
 630         if (supported_axes & ForceFeedbackEffectAxes_Y)
 631         {
 632             effect->directions[count] = effect->directions[1];
 633             effect->axes[count++] = DIJOFS_Y;
 634         }
 635         if (supported_axes & ForceFeedbackEffectAxes_Z)
 636         {
 637             effect->directions[count] = effect->directions[2];
 638             effect->axes[count++] = DIJOFS_Z;
 639         }
 640
 641         effect->params.cAxes = count;
 642     }
 643
 644     if (SUCCEEDED(hr = IDirectInputDevice8_CreateEffect( impl->device, &effect->type, &effect->params,
 645                                                          &dinput_effect, NULL )))
 646     {
 647         if (effect->effect) IDirectInputEffect_Release( effect->effect );
 648         effect->effect = dinput_effect;
 649         IDirectInputEffect_AddRef( effect->effect );
 650     }
 651
 652     LeaveCriticalSection( &effect->cs );
 653
 654     result->vt = VT_UI4;
 655     if (SUCCEEDED(hr)) result->ulVal = ForceFeedbackLoadEffectResult_Succeeded;
 656     else if (hr == DIERR_DEVICEFULL) result->ulVal = ForceFeedbackLoadEffectResult_EffectStorageFull;
 657     else result->ulVal = ForceFeedbackLoadEffectResult_EffectNotSupported;
 658
 659     return hr;
 660 }
 661
 662 static HRESULT WINAPI motor_LoadEffectAsync( IForceFeedbackMotor *iface, IForceFeedbackEffect *effect,
 663                                              IAsyncOperation_ForceFeedbackLoadEffectResult **async_op )
 664 {
 665     TRACE( "iface %p, effect %p, async_op %p.\n", iface, effect, async_op );
 666     return async_operation_effect_result_create( (IUnknown *)iface, (IUnknown *)effect, motor_load_effect_async, async_op );
 667 }
 668
 669 static HRESULT WINAPI motor_PauseAllEffects( IForceFeedbackMotor *iface )
 670 {
 671     struct motor *impl = impl_from_IForceFeedbackMotor( iface );
 672
 673     TRACE( "iface %p.\n", iface );
 674
 675     return IDirectInputDevice8_SendForceFeedbackCommand( impl->device, DISFFC_PAUSE );
 676 }
 677
 678 static HRESULT WINAPI motor_ResumeAllEffects( IForceFeedbackMotor *iface )
 679 {
 680     struct motor *impl = impl_from_IForceFeedbackMotor( iface );
 681
 682     TRACE( "iface %p.\n", iface );
 683
 684     return IDirectInputDevice8_SendForceFeedbackCommand( impl->device, DISFFC_CONTINUE );
 685 }
 686
 687 static HRESULT WINAPI motor_StopAllEffects( IForceFeedbackMotor *iface )
 688 {
 689     struct motor *impl = impl_from_IForceFeedbackMotor( iface );
 690
 691     TRACE( "iface %p.\n", iface );
 692
 693     return IDirectInputDevice8_SendForceFeedbackCommand( impl->device, DISFFC_STOPALL );
 694 }
 695
 696 static HRESULT WINAPI motor_try_disable_async( IUnknown *invoker, IUnknown *param, PROPVARIANT *result )
 697 {
 698     struct motor *impl = impl_from_IForceFeedbackMotor( (IForceFeedbackMotor *)invoker );
 699     HRESULT hr;
 700
 701     hr = IDirectInputDevice8_SendForceFeedbackCommand( impl->device, DISFFC_SETACTUATORSOFF );
 702     result->vt = VT_BOOL;
 703     result->boolVal = SUCCEEDED(hr);
 704
 705     return hr;
 706 }
 707
 708 static HRESULT WINAPI motor_TryDisableAsync( IForceFeedbackMotor *iface, IAsyncOperation_boolean **async_op )
 709 {
 710     TRACE( "iface %p, async_op %p.\n", iface, async_op );
 711     return async_operation_boolean_create( (IUnknown *)iface, NULL, motor_try_disable_async, async_op );
 712 }
 713
 714 static HRESULT WINAPI motor_try_enable_async( IUnknown *invoker, IUnknown *param, PROPVARIANT *result )
 715 {
 716     struct motor *impl = impl_from_IForceFeedbackMotor( (IForceFeedbackMotor *)invoker );
 717     HRESULT hr;
 718
 719     hr = IDirectInputDevice8_SendForceFeedbackCommand( impl->device, DISFFC_SETACTUATORSON );
 720     result->vt = VT_BOOL;
 721     result->boolVal = SUCCEEDED(hr);
 722
 723     return hr;
 724 }
 725
 726 static HRESULT WINAPI motor_TryEnableAsync( IForceFeedbackMotor *iface, IAsyncOperation_boolean **async_op )
 727 {
 728     TRACE( "iface %p, async_op %p.\n", iface, async_op );
 729     return async_operation_boolean_create( (IUnknown *)iface, NULL, motor_try_enable_async, async_op );
 730 }
 731
 732 static HRESULT WINAPI motor_try_reset_async( IUnknown *invoker, IUnknown *param, PROPVARIANT *result )
 733 {
 734     struct motor *impl = impl_from_IForceFeedbackMotor( (IForceFeedbackMotor *)invoker );
 735     HRESULT hr;
 736
 737     hr = IDirectInputDevice8_SendForceFeedbackCommand( impl->device, DISFFC_RESET );
 738     result->vt = VT_BOOL;
 739     result->boolVal = SUCCEEDED(hr);
 740
 741     return hr;
 742 }
 743
 744 static HRESULT WINAPI motor_TryResetAsync( IForceFeedbackMotor *iface, IAsyncOperation_boolean **async_op )
 745 {
 746     TRACE( "iface %p, async_op %p.\n", iface, async_op );
 747     return async_operation_boolean_create( (IUnknown *)iface, NULL, motor_try_reset_async, async_op );
 748 }
 749
 750 static HRESULT WINAPI motor_unload_effect_async( IUnknown *iface, IUnknown *param, PROPVARIANT *result )
 751 {
 752     struct effect *effect = impl_from_IForceFeedbackEffect( (IForceFeedbackEffect *)param );
 753     IDirectInputEffect *dinput_effect;
 754     HRESULT hr;
 755
 756     EnterCriticalSection( &effect->cs );
 757     dinput_effect = effect->effect;
 758     effect->effect = NULL;
 759     LeaveCriticalSection( &effect->cs );
 760
 761     if (!dinput_effect) hr = S_OK;
 762     else
 763     {
 764         hr = IDirectInputEffect_Unload( dinput_effect );
 765         IDirectInputEffect_Release( dinput_effect );
 766     }
 767
 768     result->vt = VT_BOOL;
 769     result->boolVal = SUCCEEDED(hr);
 770     return hr;
 771 }
 772
 773 static HRESULT WINAPI motor_TryUnloadEffectAsync( IForceFeedbackMotor *iface, IForceFeedbackEffect *effect,
 774                                                   IAsyncOperation_boolean **async_op )
 775 {
 776     struct effect *impl = impl_from_IForceFeedbackEffect( (IForceFeedbackEffect *)effect );
 777     HRESULT hr = S_OK;
 778
 779     TRACE( "iface %p, effect %p, async_op %p.\n", iface, effect, async_op );
 780
 781     EnterCriticalSection( &impl->cs );
 782     if (!impl->effect) hr = E_FAIL;
 783     LeaveCriticalSection( &impl->cs );
 784     if (FAILED(hr)) return hr;
 785
 786     return async_operation_boolean_create( (IUnknown *)iface, (IUnknown *)effect, motor_unload_effect_async, async_op );
 787 }
 788
 789 static const struct IForceFeedbackMotorVtbl motor_vtbl =
 790 {
 791     motor_QueryInterface,
 792     motor_AddRef,
 793     motor_Release,
 794     /* IInspectable methods */
 795     motor_GetIids,
 796     motor_GetRuntimeClassName,
 797     motor_GetTrustLevel,
 798     /* IForceFeedbackMotor methods */
 799     motor_get_AreEffectsPaused,
 800     motor_get_MasterGain,
 801     motor_put_MasterGain,
 802     motor_get_IsEnabled,
 803     motor_get_SupportedAxes,
 804     motor_LoadEffectAsync,
 805     motor_PauseAllEffects,
 806     motor_ResumeAllEffects,
 807     motor_StopAllEffects,
 808     motor_TryDisableAsync,
 809     motor_TryEnableAsync,
 810     motor_TryResetAsync,
 811     motor_TryUnloadEffectAsync,
 812 };
 813
 814 HRESULT force_feedback_motor_create( IDirectInputDevice8W *device, IForceFeedbackMotor **out )
 815 {
 816     struct motor *impl;
 817     HRESULT hr;
 818
 819     TRACE( "device %p, out %p\n", device, out );
 820
 821     if (FAILED(hr = IDirectInputDevice8_Unacquire( device ))) goto failed;
 822     if (FAILED(hr = IDirectInputDevice8_SetCooperativeLevel( device, GetDesktopWindow(), DISCL_BACKGROUND | DISCL_EXCLUSIVE ))) goto failed;
 823     if (FAILED(hr = IDirectInputDevice8_Acquire( device ))) goto failed;
 824
 825     if (!(impl = calloc( 1, sizeof(*impl) ))) return E_OUTOFMEMORY;
 826     impl->IForceFeedbackMotor_iface.lpVtbl = &motor_vtbl;
 827     impl->ref = 1;
 828
 829     IDirectInputDevice_AddRef( device );
 830     impl->device = device;
 831
 832     *out = &impl->IForceFeedbackMotor_iface;
 833     TRACE( "created ForceFeedbackMotor %p\n", *out );
 834     return S_OK;
 835
 836 failed:
 837     IDirectInputDevice8_SetCooperativeLevel( device, 0, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE );
 838     IDirectInputDevice8_Acquire( device );
 839     WARN( "Failed to acquire device exclusively, hr %#lx\n", hr );
 840     return hr;
 841 }