Cool_Tools/FFBArcadePlugin
1
0
Fork 0
mirror of synced 2024-11-30 17:34:33 +01:00
Code Releases Activity
b9170c96b1
FFBArcadePlugin/DllMain.cpp

3565 lines
145 KiB
C++
Raw Normal View History

Open Source FFB Arcade Plugin
2019-09-14 03:13:05 +02:00
/*This file is part of FFB Arcade Plugin.
FFB Arcade Plugin is free software : you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
FFB Arcade Plugin is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with FFB Arcade Plugin.If not, see < https://www.gnu.org/licenses/>.
*/
0.8 update
2019-04-07 07:16:19 +02:00
#include <Windows.h>
#include <math.h>
#include <dinput.h>
#include <stdio.h>
#include <tchar.h>
#include "SDL.h"
#include <iostream>
#include <fstream>
#include <cstdio>
#include <string>
#include <chrono>
#include <thread>
#include "IDirectInputDevice.h"
#include <d3d11.h>
Add Text to Speech for FFB Strength Adjustment
2020-06-25 08:30:20 +02:00
#include <sapi.h>
Fix Win XP Crash (i think)
2020-07-31 07:04:47 +02:00
#include <atlcomcli.h>
Flycast Output FFB Support
2023-03-02 08:39:51 +01:00
#include <TlHelp32.h>
Add some Persistant Value Stuff
2020-06-24 11:23:05 +02:00
#include "Config/PersistentValues.h"
0.8 update
2019-04-07 07:16:19 +02:00
// include all game header files here.
#include "Game Files/TestGame.h"
Added Aliens Extermination
2019-12-16 06:55:50 +01:00
#include "Game Files/AliensExtermination.h"
Added Batman
2020-03-13 23:05:19 +01:00
#include "Game Files/Batman.h"
#include "Game Files/BG4JP.h"
0.8 update
2019-04-07 07:16:19 +02:00
#include "Game Files/ChaseHQ2.h"
add WMMT5DX and Crazy Taxi Steam
2021-09-26 09:27:43 +02:00
#include "Game Files/CrazyTaxi.h"
FnF Added
2024-04-07 11:59:56 +02:00
#include "Game Files/CruisnBlast.h"
Add D1GP Support
2021-05-20 08:20:30 +02:00
#include "Game Files/D1GP.h"
0.8 update
2019-04-07 07:16:19 +02:00
#include "Game Files/Daytona3.h"
add Daytona New Season Edition
2021-12-01 05:29:59 +01:00
#include "Game Files/Daytona3NSE.h"
add Dead Heat and WMMT3
2022-06-08 07:06:23 +02:00
#include "Game Files/DeadHeat.h"
add Dead Heat Riders
2022-06-09 07:25:54 +02:00
#include "Game Files/DeadHeatRiders.h"
Add Dirty Drivin
2019-12-22 22:41:31 +01:00
#include "Game Files/DirtyDrivin.h"
FnF Added
2024-04-07 11:59:56 +02:00
#include "Game Files/FnF.h"
#include "Game Files/FnFDrift.h"
#include "Game Files/FnFSuperCars.h"
0.8 update
2019-04-07 07:16:19 +02:00
#include "Game Files/FordRacing.h"
updated to 0.9
2019-05-15 09:25:41 +02:00
#include "Game Files/FordRacingOther.h"
Add FFB to Gaelco games
2022-06-10 12:41:25 +02:00
#include "Game Files/GaelcoTuningRace.h"
Add GRID Custom and Spring to MKGP
2023-03-25 11:14:46 +01:00
#include "Game Files/GRIDReal.h"
#include "Game Files/GRIDCustom.h"
Added Golden Gun Rumble as requested
2019-12-20 01:59:19 +01:00
#include "Game Files/GoldenGun.h"
Added Hummer Extreme
2024-07-07 11:38:58 +02:00
#include "Game Files/HummerExtreme.h"
rename id0 to id0v131
2021-02-20 01:50:07 +01:00
#include "Game Files/InitialD0v131.h"
Changes for past few weeks
2021-02-09 05:10:00 +01:00
#include "Game Files/InitialD0v211.h"
add ID Zero 2.30 and Flycast Dojo
2022-09-17 10:24:36 +02:00
#include "Game Files/InitialD0v230.h"
0.8 update
2019-04-07 07:16:19 +02:00
#include "Game Files/InitialD4.h"
#include "Game Files/InitialD4Japan.h"
#include "Game Files/InitialD5.h"
#include "Game Files/InitialD6.h"
#include "Game Files/InitialD7.h"
#include "Game Files/InitialD8.h"
Mario Kart FFB Changes etc and 2.0.0.28 version
2023-03-25 10:45:33 +01:00
#include "Game Files/MarioKartGPDXCustom.h"
#include "Game Files/MarioKartGPDX1.10Custom.h"
#include "Game Files/MarioKartGPDX1.10Real.h"
MK 1.18 Custom
2023-03-26 11:16:12 +02:00
#include "Game Files/MarioKartGPDX1.18Custom.h"
Mario Kart FFB Changes etc and 2.0.0.28 version
2023-03-25 10:45:33 +01:00
#include "Game Files/MarioKartGPDX1.18Real.h"
#include "Game Files/MarioKartGPDXUSACustom.h"
#include "Game Files/MarioKartGPDXUSAReal.h"
Rename OutputReading to MAMESupermodel
2020-05-25 07:36:14 +02:00
#include "Game Files/MAMESupermodel.h"
0.8 update
2019-04-07 07:16:19 +02:00
#include "Game Files/OutRun2Fake.h"
#include "Game Files/OutRun2Real.h"
FnF Added
2024-04-07 11:59:56 +02:00
#include "Game Files/SegaRaceTV.h"
0.8 update
2019-04-07 07:16:19 +02:00
#include "Game Files/SegaRacingClassic.h"
#include "Game Files/SegaRally3.h"
Add Sega Rally 3 Other
2020-05-27 11:57:10 +02:00
#include "Game Files/SegaRally3Other.h"
add Showdown
2023-08-26 08:07:18 +02:00
#include "Game Files/Showdown.h"
Added SnoCross
2020-01-09 00:42:33 +01:00
#include "Game Files/SnoCross.h"
0.8 update
2019-04-07 07:16:19 +02:00
#include "Game Files/WackyRaces.h"
add Dead Heat and WMMT3
2022-06-08 07:06:23 +02:00
#include "Game Files/WMMT3.h"
0.8 update
2019-04-07 07:16:19 +02:00
#include "Game Files/WMMT5.h"
add WMMT5DX+
2021-08-25 13:45:47 +02:00
#include "Game Files/WMMT5DX.h"
add WMMT5DX and Crazy Taxi Steam
2021-09-26 09:27:43 +02:00
#include "Game Files/WMMT5DX+.h"
Add WMMT6 and WMMT6R FFB Support
2021-02-19 23:44:55 +01:00
#include "Game Files/WMMT6.h"
#include "Game Files/WMMT6R.h"
0.8 update
2019-04-07 07:16:19 +02:00
#include "Game Files/Machstorm.h"
#include "Game Files/AfterburnerClimax.h"
#include "Game Files/PokkenTournament.h"
#include "Game Files/SonicSegaAllStarsRacing.h"
Add Spring Effect
2023-08-26 08:36:41 +02:00
#include "Game Files/SpringEffect.h"
0.8 update
2019-04-07 07:16:19 +02:00
#include "Game Files/M2Emulator.h"
#include "Game Files/GTIClub3.h"
#include "Game Files/Demul.h"
Cleaned up some stuff Removed seperate cpp files etc for 32bit and 64bit for Mame & Button Rumble
2019-10-26 04:46:16 +02:00
#include "Game Files/ButtonRumble.h"
Add FFB to Gaelco games
2022-06-10 12:41:25 +02:00
#include "Game Files/RingRiders.h"
0.8 update
2019-04-07 07:16:19 +02:00
#include "Game Files/RoadFighters3D.h"
#include "Game Files/LGI3D.h"
#include "Game Files/LGI.h"
Added KO Drive
2019-09-14 02:29:00 +02:00
#include "Game Files/KODrive.h"
Added HOTD4 Disabled for now as it has some serious lag for some reason
2019-10-26 22:57:33 +02:00
#include "Game Files/HOTD4.h"
Bunch of code changes, added transformers and rambo etc
2019-12-18 01:41:02 +01:00
#include "Game Files/Rambo.h"
Add R-Tuned Support
2020-05-19 01:14:34 +02:00
#include "Game Files/R-Tuned.h"
Add SWDC 2018 and MK USA
2021-02-09 05:30:19 +01:00
#include "Game Files/SWDC2018.h"
Add FFB to Gaelco games
2022-06-10 12:41:25 +02:00
#include "Game Files/TokyoCop.h"
Bunch of code changes, added transformers and rambo etc
2019-12-18 01:41:02 +01:00
#include "Game Files/Transformers.h"
Added H2Overdrive
2019-12-24 23:33:42 +01:00
#include "Game Files/H2Overdrive.h"
Storm Racer G
2021-04-17 00:31:12 +02:00
#include "Game Files/StormRacerG.h"
push Arctic Thunder code i never added
2024-03-20 02:02:55 +01:00
#include "Game Files/ArcticThunder.h"
0.8 update
2019-04-07 07:16:19 +02:00
// typedefs
typedef unsigned char U8;
typedef unsigned int U32;
// DINPUT8 FUNCTION DEFINITIONS
typedef HRESULT(WINAPI* pfnDirectInputDirectInput8Create)(HINSTANCE hinst, DWORD dwVersion, REFIID riidltf, LPVOID* ppvOut, LPUNKNOWN punkOuter);
typedef HRESULT(WINAPI* pfnDirectInputDllRegisterServer)(void);
typedef HRESULT(WINAPI* pfnDirectInputDllUnregisterServer)(void);
typedef HRESULT(WINAPI* pfnDirectInputDllCanUnloadNow)(void);
typedef HRESULT(WINAPI* pfnDirectInputDllGetClassObject)(REFCLSID rclsid, REFIID riid, LPVOID* ppv);
typedef LPCDIDATAFORMAT(WINAPI* pfnDirectInputGetdfDIJoystick)();
// DINPUT FUNCTION DEFINITIONS
typedef HRESULT(WINAPI* pfnDirectInputDirectInputCreateA)(HINSTANCE hinst, DWORD dwVersion, LPDIRECTINPUTA* ppDI, LPUNKNOWN punkOuter);
typedef HRESULT(WINAPI* pfnDirectInputDirectInputCreateW)(HINSTANCE hinst, DWORD dwVersion, LPDIRECTINPUTW* ppDI, LPUNKNOWN punkOuter);
Fix
2019-10-30 06:14:51 +01:00
typedef HRESULT(WINAPI* pfnDirectInputDirectInputCreateEx)(HINSTANCE hinst, DWORD dwVersion, REFIID riidltf, LPVOID* ppvOut, LPUNKNOWN punkOuter);
0.8 update
2019-04-07 07:16:19 +02:00
// DINPUT8 REAL FUNCTIONS
pfnDirectInputDirectInput8Create originalDirectInputDirectInput8Create = NULL;
pfnDirectInputDllRegisterServer originalDirectInputDllRegisterServer = NULL;
pfnDirectInputDllUnregisterServer originalDirectInputDllUnregisterServer = NULL;
pfnDirectInputDllCanUnloadNow originalDirectInputDllCanUnloadNow = NULL;
pfnDirectInputDllGetClassObject originalDirectInputDllGetClassObject = NULL;
pfnDirectInputGetdfDIJoystick originalGetdfDIJoystick = NULL;
// DINPUT REAL FUNCTIONS
pfnDirectInputDirectInputCreateA originalDirectInputDirectInputCreateA = NULL;
pfnDirectInputDirectInputCreateW originalDirectInputDirectInputCreateW = NULL;
pfnDirectInputDirectInputCreateEx originalDirectInputDirectInputCreateEx = NULL;
// DX11 REAL FUNCTIONS
extern "C"
{
FARPROC originalCreateDirect3D11DeviceFromDXGIDevice;
FARPROC originalCreateDirect3D11SurfaceFromDXGISurface;
FARPROC originalD3D11CoreCreateDevice;
FARPROC originalD3D11CoreCreateLayeredDevice;
FARPROC originalD3D11CoreGetLayeredDeviceSize;
FARPROC originalD3D11CoreRegisterLayers;
FARPROC originalD3D11CreateDevice;
FARPROC originalD3D11CreateDeviceAndSwapChain;
FARPROC originalD3D11CreateDeviceForD3D12;
FARPROC originalD3D11On12CreateDevice;
FARPROC originalD3DKMTCloseAdapter;
FARPROC originalD3DKMTCreateAllocation;
FARPROC originalD3DKMTCreateContext;
FARPROC originalD3DKMTCreateDevice;
FARPROC originalD3DKMTCreateSynchronizationObject;
FARPROC originalD3DKMTDestroyAllocation;
FARPROC originalD3DKMTDestroyContext;
FARPROC originalD3DKMTDestroyDevice;
FARPROC originalD3DKMTDestroySynchronizationObject;
FARPROC originalD3DKMTEscape;
FARPROC originalD3DKMTGetContextSchedulingPriority;
FARPROC originalD3DKMTGetDeviceState;
FARPROC originalD3DKMTGetDisplayModeList;
FARPROC originalD3DKMTGetMultisampleMethodList;
FARPROC originalD3DKMTGetRuntimeData;
FARPROC originalD3DKMTGetSharedPrimaryHandle;
FARPROC originalD3DKMTLock;
FARPROC originalD3DKMTOpenAdapterFromHdc;
FARPROC originalD3DKMTOpenResource;
FARPROC originalD3DKMTPresent;
FARPROC originalD3DKMTQueryAdapterInfo;
FARPROC originalD3DKMTQueryAllocationResidency;
FARPROC originalD3DKMTQueryResourceInfo;
FARPROC originalD3DKMTRender;
FARPROC originalD3DKMTSetAllocationPriority;
FARPROC originalD3DKMTSetContextSchedulingPriority;
FARPROC originalD3DKMTSetDisplayMode;
FARPROC originalD3DKMTSetDisplayPrivateDriverFormat;
FARPROC originalD3DKMTSetGammaRamp;
FARPROC originalD3DKMTSetVidPnSourceOwner;
FARPROC originalD3DKMTSignalSynchronizationObject;
FARPROC originalD3DKMTUnlock;
FARPROC originalD3DKMTWaitForSynchronizationObject;
FARPROC originalD3DKMTWaitForVerticalBlankEvent;
FARPROC originalD3DPerformance_BeginEvent;
FARPROC originalD3DPerformance_EndEvent;
FARPROC originalD3DPerformance_GetStatus;
FARPROC originalD3DPerformance_SetMarker;
FARPROC originalEnableFeatureLevelUpgrade;
FARPROC originalOpenAdapter10;
FARPROC originalOpenAdapter10_2;
}
// XINPUT1_3 REAL FUNCTIONS
extern "C"
{
FARPROC originalXInputGetState;
FARPROC originalXInputSetState;
FARPROC originalXInputGetCapabilities;
FARPROC originalXInputEnable;
FARPROC originalXInputGetDSoundAudioDeviceGuids;
FARPROC originalXInputGetBatteryInformation;
FARPROC originalXInputGetKeystroke;
FARPROC originalXInputGetStateEx;
FARPROC originalXInputWaitForGuideButton;
FARPROC originalXInputCancelGuideButtonWait;
FARPROC originalXInputPowerOffController;
}
// D3D9 REAL FUNCTIONS
extern "C"
{
FARPROC originalDirect3DShaderValidatorCreate9;
FARPROC originalPSGPError;
FARPROC originalPSGPSampleTexture;
FARPROC originalD3DPERF_BeginEvent;
FARPROC originalD3DPERF_EndEvent;
FARPROC originalD3DPERF_GetStatus;
FARPROC originalD3DPERF_QueryRepeatFrame;
FARPROC originalD3DPERF_SetMarker;
FARPROC originalD3DPERF_SetOptions;
FARPROC originalD3DPERF_SetRegion;
FARPROC originalDebugSetLevel;
FARPROC originalDebugSetMute;
FARPROC originalDirect3D9EnableMaximizedWindowedModeShim;
FARPROC originalDirect3DCreate9;
FARPROC originalDirect3DCreate9Ex;
}
// WINMM REAL FUNCTIONS
extern "C"
{
FARPROC originalPlaySoundW;
FARPROC originaltimeSetEvent;
FARPROC originaltimeKillEvent;
FARPROC originalmidiOutMessage;
FARPROC originaltimeBeginPeriod;
FARPROC originaltimeGetTime;
FARPROC originalNotifyCallbackData;
FARPROC originalWOW32DriverCallback;
FARPROC originalWOW32ResolveMultiMediaHandle;
FARPROC originalaux32Message;
FARPROC originaljoy32Message;
FARPROC originalmid32Message;
FARPROC originalmod32Message;
FARPROC originalmxd32Message;
FARPROC originaltid32Message;
FARPROC originalwid32Message;
FARPROC originalwod32Message;
FARPROC originalmci32Message;
FARPROC originalCloseDriver;
FARPROC originalDefDriverProc;
FARPROC originalDriverCallback;
FARPROC originalDrvGetModuleHandle;
FARPROC originalGetDriverModuleHandle;
FARPROC originalOpenDriver;
FARPROC originalPlaySound;
FARPROC originalOrdinal2;
FARPROC originalSendDriverMessage;
FARPROC originalauxGetDevCapsA;
FARPROC originalauxGetDevCapsW;
FARPROC originalauxGetNumDevs;
FARPROC originalauxGetVolume;
FARPROC originalauxOutMessage;
FARPROC originalauxSetVolume;
FARPROC originaljoyConfigChanged;
FARPROC originaljoyGetDevCapsA;
FARPROC originaljoyGetDevCapsW;
FARPROC originaljoyGetNumDevs;
FARPROC originaljoyGetPosEx;
FARPROC originaljoyGetPos;
FARPROC originaljoyGetThreshold;
FARPROC originaljoyReleaseCapture;
FARPROC originaljoySetCapture;
FARPROC originaljoySetThreshold;
FARPROC originalmidiConnect;
FARPROC originalmidiDisconnect;
FARPROC originalmidiInAddBuffer;
FARPROC originalmidiInClose;
FARPROC originalmidiInGetDevCapsA;
FARPROC originalmidiInGetDevCapsW;
FARPROC originalmidiInGetErrorTextA;
FARPROC originalmidiInGetErrorTextW;
FARPROC originalmidiInGetID;
FARPROC originalmidiInGetNumDevs;
FARPROC originalmidiInMessage;
FARPROC originalmidiInOpen;
FARPROC originalmidiInPrepareHeader;
FARPROC originalmidiInReset;
FARPROC originalmidiInStart;
FARPROC originalmidiInStop;
FARPROC originalmidiInUnprepareHeader;
FARPROC originalmidiOutCacheDrumPatches;
FARPROC originalmidiOutCachePatches;
FARPROC originalmidiOutClose;
FARPROC originalmidiOutGetDevCapsA;
FARPROC originalmidiOutGetDevCapsW;
FARPROC originalmidiOutGetErrorTextA;
FARPROC originalmidiOutGetErrorTextW;
FARPROC originalmidiOutGetID;
FARPROC originalmidiOutGetNumDevs;
FARPROC originalmidiOutGetVolume;
FARPROC originalmidiOutLongMsg;
FARPROC originalmidiOutOpen;
FARPROC originalmidiOutPrepareHeader;
FARPROC originalmidiOutReset;
FARPROC originalmidiOutSetVolume;
FARPROC originalmidiOutShortMsg;
FARPROC originalmidiOutUnprepareHeader;
FARPROC originalmidiStreamClose;
FARPROC originalmidiStreamOpen;
FARPROC originalmidiStreamOut;
FARPROC originalmidiStreamPause;
FARPROC originalmidiStreamPosition;
FARPROC originalmidiStreamProperty;
FARPROC originalmidiStreamRestart;
FARPROC originalmidiStreamStop;
FARPROC originalmixerClose;
FARPROC originalmixerGetControlDetailsA;
FARPROC originalmixerGetControlDetailsW;
FARPROC originalmixerGetDevCapsA;
FARPROC originalmixerGetDevCapsW;
FARPROC originalmixerGetID;
FARPROC originalmixerGetLineControlsA;
FARPROC originalmixerGetLineControlsW;
FARPROC originalmixerGetLineInfoA;
FARPROC originalmixerGetLineInfoW;
FARPROC originalmixerGetNumDevs;
FARPROC originalmixerMessage;
FARPROC originalmixerOpen;
FARPROC originalmixerSetControlDetails;
FARPROC originalmmDrvInstall;
FARPROC originalmmGetCurrentTask;
FARPROC originalmmTaskBlock;
FARPROC originalmmTaskCreate;
FARPROC originalmmTaskSignal;
FARPROC originalmmTaskYield;
FARPROC originalmmioAdvance;
FARPROC originalmmioAscend;
FARPROC originalmmioClose;
FARPROC originalmmioCreateChunk;
FARPROC originalmmioDescend;
FARPROC originalmmioFlush;
FARPROC originalmmioGetInfo;
FARPROC originalmmioInstallIOProcA;
FARPROC originalmmioInstallIOProcW;
FARPROC originalmmioOpenA;
FARPROC originalmmioOpenW;
FARPROC originalmmioRead;
FARPROC originalmmioRenameA;
FARPROC originalmmioRenameW;
FARPROC originalmmioSeek;
FARPROC originalmmioSendMessage;
FARPROC originalmmioSetBuffer;
FARPROC originalmmioSetInfo;
FARPROC originalmmioStringToFOURCCA;
FARPROC originalmmioStringToFOURCCW;
FARPROC originalmmioWrite;
FARPROC originaltimeEndPeriod;
FARPROC originaltimeGetDevCaps;
FARPROC originaltimeGetSystemTime;
FARPROC originalwaveInAddBuffer;
FARPROC originalwaveInClose;
FARPROC originalwaveInGetDevCapsA;
FARPROC originalwaveInGetDevCapsW;
FARPROC originalwaveInGetErrorTextA;
FARPROC originalwaveInGetErrorTextW;
FARPROC originalwaveInGetID;
FARPROC originalwaveInGetNumDevs;
FARPROC originalwaveInGetPosition;
FARPROC originalwaveInMessage;
FARPROC originalwaveInOpen;
FARPROC originalwaveInPrepareHeader;
FARPROC originalwaveInReset;
FARPROC originalwaveInStart;
FARPROC originalwaveInStop;
FARPROC originalwaveInUnprepareHeader;
FARPROC originalwaveOutBreakLoop;
FARPROC originalwaveOutClose;
FARPROC originalwaveOutGetDevCapsA;
FARPROC originalwaveOutGetDevCapsW;
FARPROC originalwaveOutGetErrorTextA;
FARPROC originalwaveOutGetErrorTextW;
FARPROC originalwaveOutGetID;
FARPROC originalwaveOutGetNumDevs;
FARPROC originalwaveOutGetPitch;
FARPROC originalwaveOutGetPlaybackRate;
FARPROC originalwaveOutGetPosition;
FARPROC originalwaveOutGetVolume;
FARPROC originalwaveOutMessage;
FARPROC originalwaveOutOpen;
FARPROC originalwaveOutPause;
FARPROC originalwaveOutPrepareHeader;
FARPROC originalwaveOutReset;
FARPROC originalwaveOutRestart;
FARPROC originalwaveOutSetPitch;
FARPROC originalwaveOutSetPlaybackRate;
FARPROC originalwaveOutSetVolume;
FARPROC originalwaveOutUnprepareHeader;
FARPROC originalwaveOutWrite;
FARPROC originalmciExecute;
FARPROC originalmciGetErrorStringA;
FARPROC originalmciGetErrorStringW;
FARPROC originalmciSendCommandA;
FARPROC originalmciSendCommandW;
FARPROC originalmciSendStringA;
FARPROC originalmciSendStringW;
FARPROC originalmciFreeCommandResource;
FARPROC originalmciLoadCommandResource;
FARPROC originalmciDriverNotify;
FARPROC originalmciDriverYield;
FARPROC originalmciGetCreatorTask;
FARPROC originalmciGetDeviceIDA;
FARPROC originalmciGetDeviceIDFromElementIDA;
FARPROC originalmciGetDeviceIDFromElementIDW;
FARPROC originalmciGetDeviceIDW;
FARPROC originalmciGetDriverData;
FARPROC originalmciGetYieldProc;
FARPROC originalmciSetDriverData;
FARPROC originalmciSetYieldProc;
FARPROC originalPlaySoundA;
FARPROC originalsndPlaySoundA;
FARPROC originalsndPlaySoundW;
FARPROC originalWOWAppExit;
FARPROC originalmmsystemGetVersion;
}
// OpenGL32 REAL FUNCTIONS
extern "C"
{
FARPROC originalwglUseFontOutlinesA;
FARPROC originalwglUseFontOutlinesW;
FARPROC originalwglDescribeLayerPlane;
FARPROC originalwglSetLayerPaletteEntries;
FARPROC originalwglGetLayerPaletteEntries;
FARPROC originalwglRealizeLayerPalette;
FARPROC originalwglSwapLayerBuffers;
FARPROC originalwglMakeCurrent;
FARPROC originalGlmfInitPlayback;
FARPROC originalGlmfBeginGlsBlock;
FARPROC originalGlmfPlayGlsRecord;
FARPROC originalGlmfEndGlsBlock;
FARPROC originalGlmfEndPlayback;
FARPROC originalGlmfCloseMetaFile;
FARPROC originalwglSwapMultipleBuffers;
FARPROC originalwglCreateLayerContext;
FARPROC originalwglCreateContext;
FARPROC originalwglDeleteContext;
FARPROC originalwglGetCurrentContext;
FARPROC originalwglGetCurrentDC;
FARPROC originalwglUseFontBitmapsA;
FARPROC originalwglUseFontBitmapsW;
FARPROC originalwglShareLists;
FARPROC originalwglGetDefaultProcAddress;
FARPROC originalwglGetProcAddress;
FARPROC originalwglCopyContext;
FARPROC originalglDebugEntry;
FARPROC originalwglGetPixelFormat;
FARPROC originalwglSetPixelFormat;
FARPROC originalwglChoosePixelFormat;
FARPROC originalwglDescribePixelFormat;
FARPROC originalwglSwapBuffers;
FARPROC originalglNewList;
FARPROC originalglEndList;
FARPROC originalglCallList;
FARPROC originalglCallLists;
FARPROC originalglBegin;
FARPROC originalglColor3b;
FARPROC originalglColor3bv;
FARPROC originalglColor3d;
FARPROC originalglColor3dv;
FARPROC originalglColor3f;
FARPROC originalglColor3fv;
FARPROC originalglColor3i;
FARPROC originalglColor3iv;
FARPROC originalglColor3s;
FARPROC originalglColor3sv;
FARPROC originalglColor3ub;
FARPROC originalglColor3ubv;
FARPROC originalglColor3ui;
FARPROC originalglColor3uiv;
FARPROC originalglColor3us;
FARPROC originalglColor3usv;
FARPROC originalglColor4b;
FARPROC originalglColor4bv;
FARPROC originalglColor4d;
FARPROC originalglColor4dv;
FARPROC originalglColor4f;
FARPROC originalglColor4fv;
FARPROC originalglColor4i;
FARPROC originalglColor4iv;
FARPROC originalglColor4s;
FARPROC originalglColor4sv;
FARPROC originalglColor4ub;
FARPROC originalglColor4ubv;
FARPROC originalglColor4ui;
FARPROC originalglColor4uiv;
FARPROC originalglColor4us;
FARPROC originalglColor4usv;
FARPROC originalglEdgeFlag;
FARPROC originalglEdgeFlagv;
FARPROC originalglEnd;
FARPROC originalglIndexd;
FARPROC originalglIndexdv;
FARPROC originalglIndexf;
FARPROC originalglIndexfv;
FARPROC originalglIndexi;
FARPROC originalglIndexiv;
FARPROC originalglIndexs;
FARPROC originalglIndexsv;
FARPROC originalglNormal3b;
FARPROC originalglNormal3bv;
FARPROC originalglNormal3d;
FARPROC originalglNormal3dv;
FARPROC originalglNormal3f;
FARPROC originalglNormal3fv;
FARPROC originalglNormal3i;
FARPROC originalglNormal3iv;
FARPROC originalglNormal3s;
FARPROC originalglNormal3sv;
FARPROC originalglTexCoord1d;
FARPROC originalglTexCoord1dv;
FARPROC originalglTexCoord1f;
FARPROC originalglTexCoord1fv;
FARPROC originalglTexCoord1i;
FARPROC originalglTexCoord1iv;
FARPROC originalglTexCoord1s;
FARPROC originalglTexCoord1sv;
FARPROC originalglTexCoord2d;
FARPROC originalglTexCoord2dv;
FARPROC originalglTexCoord2f;
FARPROC originalglTexCoord2fv;
FARPROC originalglTexCoord2i;
FARPROC originalglTexCoord2iv;
FARPROC originalglTexCoord2s;
FARPROC originalglTexCoord2sv;
FARPROC originalglTexCoord3d;
FARPROC originalglTexCoord3dv;
FARPROC originalglTexCoord3f;
FARPROC originalglTexCoord3fv;
FARPROC originalglTexCoord3i;
FARPROC originalglTexCoord3iv;
FARPROC originalglTexCoord3s;
FARPROC originalglTexCoord3sv;
FARPROC originalglTexCoord4d;
FARPROC originalglTexCoord4dv;
FARPROC originalglTexCoord4f;
FARPROC originalglTexCoord4fv;
FARPROC originalglTexCoord4i;
FARPROC originalglTexCoord4iv;
FARPROC originalglTexCoord4s;
FARPROC originalglTexCoord4sv;
FARPROC originalglVertex2d;
FARPROC originalglVertex2dv;
FARPROC originalglVertex2f;
FARPROC originalglVertex2fv;
FARPROC originalglVertex2i;
FARPROC originalglVertex2iv;
FARPROC originalglVertex2s;
FARPROC originalglVertex2sv;
FARPROC originalglVertex3d;
FARPROC originalglVertex3dv;
FARPROC originalglVertex3f;
FARPROC originalglVertex3fv;
FARPROC originalglVertex3i;
FARPROC originalglVertex3iv;
FARPROC originalglVertex3s;
FARPROC originalglVertex3sv;
FARPROC originalglVertex4d;
FARPROC originalglVertex4dv;
FARPROC originalglVertex4f;
FARPROC originalglVertex4fv;
FARPROC originalglVertex4i;
FARPROC originalglVertex4iv;
FARPROC originalglVertex4s;
FARPROC originalglVertex4sv;
FARPROC originalglMaterialf;
FARPROC originalglMaterialfv;
FARPROC originalglMateriali;
FARPROC originalglMaterialiv;
FARPROC originalglDisable;
FARPROC originalglEnable;
FARPROC originalglPopAttrib;
FARPROC originalglPushAttrib;
FARPROC originalglEvalCoord1d;
FARPROC originalglEvalCoord1dv;
FARPROC originalglEvalCoord1f;
FARPROC originalglEvalCoord1fv;
FARPROC originalglEvalCoord2d;
FARPROC originalglEvalCoord2dv;
FARPROC originalglEvalCoord2f;
FARPROC originalglEvalCoord2fv;
FARPROC originalglEvalPoint1;
FARPROC originalglEvalPoint2;
FARPROC originalglLoadIdentity;
FARPROC originalglLoadMatrixf;
FARPROC originalglLoadMatrixd;
FARPROC originalglMatrixMode;
FARPROC originalglMultMatrixf;
FARPROC originalglMultMatrixd;
FARPROC originalglPopMatrix;
FARPROC originalglPushMatrix;
FARPROC originalglRotated;
FARPROC originalglRotatef;
FARPROC originalglScaled;
FARPROC originalglScalef;
FARPROC originalglTranslated;
FARPROC originalglTranslatef;
FARPROC originalglArrayElement;
FARPROC originalglBindTexture;
FARPROC originalglColorPointer;
FARPROC originalglDisableClientState;
FARPROC originalglDrawArrays;
FARPROC originalglDrawElements;
FARPROC originalglEdgeFlagPointer;
FARPROC originalglEnableClientState;
FARPROC originalglIndexPointer;
FARPROC originalglIndexub;
FARPROC originalglIndexubv;
FARPROC originalglInterleavedArrays;
FARPROC originalglNormalPointer;
FARPROC originalglPolygonOffset;
FARPROC originalglTexCoordPointer;
FARPROC originalglVertexPointer;
FARPROC originalglGetPointerv;
FARPROC originalglPopClientAttrib;
FARPROC originalglPushClientAttrib;
FARPROC originalglClear;
FARPROC originalglClearAccum;
FARPROC originalglClearIndex;
FARPROC originalglClearColor;
FARPROC originalglClearStencil;
FARPROC originalglClearDepth;
FARPROC originalglBitmap;
FARPROC originalglTexImage1D;
FARPROC originalglTexImage2D;
FARPROC originalglCopyPixels;
FARPROC originalglReadPixels;
FARPROC originalglDrawPixels;
FARPROC originalglRectd;
FARPROC originalglRectdv;
FARPROC originalglRectf;
FARPROC originalglRectfv;
FARPROC originalglRecti;
FARPROC originalglRectiv;
FARPROC originalglRects;
FARPROC originalglRectsv;
FARPROC originalglDeleteLists;
FARPROC originalglGenLists;
FARPROC originalglListBase;
FARPROC originalglRasterPos2d;
FARPROC originalglRasterPos2dv;
FARPROC originalglRasterPos2f;
FARPROC originalglRasterPos2fv;
FARPROC originalglRasterPos2i;
FARPROC originalglRasterPos2iv;
FARPROC originalglRasterPos2s;
FARPROC originalglRasterPos2sv;
FARPROC originalglRasterPos3d;
FARPROC originalglRasterPos3dv;
FARPROC originalglRasterPos3f;
FARPROC originalglRasterPos3fv;
FARPROC originalglRasterPos3i;
FARPROC originalglRasterPos3iv;
FARPROC originalglRasterPos3s;
FARPROC originalglRasterPos3sv;
FARPROC originalglRasterPos4d;
FARPROC originalglRasterPos4dv;
FARPROC originalglRasterPos4f;
FARPROC originalglRasterPos4fv;
FARPROC originalglRasterPos4i;
FARPROC originalglRasterPos4iv;
FARPROC originalglRasterPos4s;
FARPROC originalglRasterPos4sv;
FARPROC originalglClipPlane;
FARPROC originalglColorMaterial;
FARPROC originalglCullFace;
FARPROC originalglFogf;
FARPROC originalglFogfv;
FARPROC originalglFogi;
FARPROC originalglFogiv;
FARPROC originalglFrontFace;
FARPROC originalglHint;
FARPROC originalglLightf;
FARPROC originalglLightfv;
FARPROC originalglLighti;
FARPROC originalglLightiv;
FARPROC originalglLightModelf;
FARPROC originalglLightModelfv;
FARPROC originalglLightModeli;
FARPROC originalglLightModeliv;
FARPROC originalglLineStipple;
FARPROC originalglLineWidth;
FARPROC originalglPointSize;
FARPROC originalglPolygonMode;
FARPROC originalglPolygonStipple;
FARPROC originalglScissor;
FARPROC originalglFinish;
FARPROC originalglShadeModel;
FARPROC originalglTexParameterf;
FARPROC originalglTexParameterfv;
FARPROC originalglTexParameteri;
FARPROC originalglTexParameteriv;
FARPROC originalglTexEnvf;
FARPROC originalglTexEnvfv;
FARPROC originalglTexEnvi;
FARPROC originalglTexEnviv;
FARPROC originalglTexGend;
FARPROC originalglTexGendv;
FARPROC originalglTexGenf;
FARPROC originalglTexGenfv;
FARPROC originalglTexGeni;
FARPROC originalglTexGeniv;
FARPROC originalglFeedbackBuffer;
FARPROC originalglSelectBuffer;
FARPROC originalglRenderMode;
FARPROC originalglInitNames;
FARPROC originalglLoadName;
FARPROC originalglPassThrough;
FARPROC originalglPopName;
FARPROC originalglPushName;
FARPROC originalglDrawBuffer;
FARPROC originalglStencilMask;
FARPROC originalglColorMask;
FARPROC originalglDepthMask;
FARPROC originalglIndexMask;
FARPROC originalglAccum;
FARPROC originalglFlush;
FARPROC originalglMap1d;
FARPROC originalglMap1f;
FARPROC originalglMap2d;
FARPROC originalglMap2f;
FARPROC originalglMapGrid1d;
FARPROC originalglMapGrid1f;
FARPROC originalglMapGrid2d;
FARPROC originalglMapGrid2f;
FARPROC originalglEvalMesh1;
FARPROC originalglEvalMesh2;
FARPROC originalglAlphaFunc;
FARPROC originalglBlendFunc;
FARPROC originalglLogicOp;
FARPROC originalglStencilFunc;
FARPROC originalglStencilOp;
FARPROC originalglDepthFunc;
FARPROC originalglPixelZoom;
FARPROC originalglPixelTransferf;
FARPROC originalglPixelTransferi;
FARPROC originalglPixelStoref;
FARPROC originalglPixelStorei;
FARPROC originalglPixelMapfv;
FARPROC originalglPixelMapuiv;
FARPROC originalglPixelMapusv;
FARPROC originalglReadBuffer;
FARPROC originalglGetBooleanv;
FARPROC originalglGetClipPlane;
FARPROC originalglGetDoublev;
FARPROC originalglGetError;
FARPROC originalglGetFloatv;
FARPROC originalglGetIntegerv;
FARPROC originalglGetLightfv;
FARPROC originalglGetLightiv;
FARPROC originalglGetMapdv;
FARPROC originalglGetMapfv;
FARPROC originalglGetMapiv;
FARPROC originalglGetMaterialfv;
FARPROC originalglGetMaterialiv;
FARPROC originalglGetPixelMapfv;
FARPROC originalglGetPixelMapuiv;
FARPROC originalglGetPixelMapusv;
FARPROC originalglGetPolygonStipple;
FARPROC originalglGetString;
FARPROC originalglGetTexEnvfv;
FARPROC originalglGetTexEnviv;
FARPROC originalglGetTexGendv;
FARPROC originalglGetTexGenfv;
FARPROC originalglGetTexGeniv;
FARPROC originalglGetTexImage;
FARPROC originalglGetTexParameterfv;
FARPROC originalglGetTexParameteriv;
FARPROC originalglGetTexLevelParameterfv;
FARPROC originalglGetTexLevelParameteriv;
FARPROC originalglIsEnabled;
FARPROC originalglIsList;
FARPROC originalglDepthRange;
FARPROC originalglFrustum;
FARPROC originalglOrtho;
FARPROC originalglViewport;
FARPROC originalglAreTexturesResident;
FARPROC originalglCopyTexImage1D;
FARPROC originalglCopyTexImage2D;
FARPROC originalglCopyTexSubImage1D;
FARPROC originalglCopyTexSubImage2D;
FARPROC originalglDeleteTextures;
FARPROC originalglGenTextures;
FARPROC originalglIsTexture;
FARPROC originalglPrioritizeTextures;
FARPROC originalglTexSubImage1D;
FARPROC originalglTexSubImage2D;
}
// SUPPORT FOR WRAPPING DIFFERENT LIBRARIES
enum lib
{
unknown = 0,
dinput8,
d3d11,
xinput1_3,
d3d9,
opengl32,
winmm,
dinput
};
lib currentLibrary = lib::unknown;
// DINPUT WRAPPER
HRESULT WINAPI DirectInputDirectInputCreateA(HINSTANCE hinst, DWORD dwVersion, LPDIRECTINPUTA* ppDI, LPUNKNOWN punkOuter)
{
HRESULT res = originalDirectInputDirectInputCreateA(hinst, dwVersion, ppDI, punkOuter);
return res;
}
HRESULT WINAPI DirectInputDirectInputCreateW(HINSTANCE hinst, DWORD dwVersion, LPDIRECTINPUTW* ppDI, LPUNKNOWN punkOuter)
{
HRESULT res = originalDirectInputDirectInputCreateW(hinst, dwVersion, ppDI, punkOuter);
return res;
}
Fix
2019-10-30 06:14:51 +01:00
HRESULT WINAPI DirectInputDirectInputCreateEx(HINSTANCE hinst, DWORD dwVersion, REFIID riidltf, LPVOID* ppvOut, LPUNKNOWN punkOuter)
0.8 update
2019-04-07 07:16:19 +02:00
{
HRESULT res = originalDirectInputDirectInputCreateEx(hinst, dwVersion, riidltf, ppvOut, punkOuter);
return res;
}
// DINPUT8 WRAPPER
HRESULT WINAPI DirectInputDirectInput8Create(HINSTANCE hinst, DWORD dwVersion, REFIID riidltf, LPVOID* ppvOut, LPUNKNOWN punkOuter)
{
Fix
2019-10-30 06:14:51 +01:00
LPVOID val;
HRESULT res = originalDirectInputDirectInput8Create(hinst, dwVersion, riidltf, &val, punkOuter);
*ppvOut = new DirectInputDeviceWrapper(val, (IID_IDirectInput8W == riidltf));
return res;
0.8 update
2019-04-07 07:16:19 +02:00
}
HRESULT WINAPI DirectInputDllRegisterServer(void)
{
return originalDirectInputDllRegisterServer();
}
HRESULT WINAPI DirectInputDllUnregisterServer(void)
{
return originalDirectInputDllUnregisterServer();
}
HRESULT WINAPI DirectInputDllCanUnloadNow(void)
{
return originalDirectInputDllCanUnloadNow();
}
HRESULT WINAPI DirectInputDllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv)
{
return originalDirectInputDllGetClassObject(rclsid, riid, ppv);
}
LPCDIDATAFORMAT WINAPI DirectInputGetdfDIJoystick()
{
return originalGetdfDIJoystick();
}
Add Sega Rally 3 Other
2020-05-27 11:57:10 +02:00
void MEMwrite(void* adr, void* ptr, int size)
{
DWORD OldProtection;
VirtualProtect(adr, size, PAGE_EXECUTE_READWRITE, &OldProtection);
memcpy(adr, ptr, size);
VirtualProtect(adr, size, OldProtection, &OldProtection);
}
Launch Outputs Thread quicker on games requiring it
2023-11-25 09:46:09 +01:00
extern DWORD WINAPI ThreadForOutputs(LPVOID lpParam);
0.8 update
2019-04-07 07:16:19 +02:00
// global variables
SDL_Haptic* haptic;
SDL_Haptic* haptic2 = NULL;
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
SDL_Haptic* haptic3 = NULL;
0.8 update
2019-04-07 07:16:19 +02:00
EffectCollection effects;
EffectConstants effectConst;
Helpers hlp;
Fix various issues MAME Changes and modify how games load
2020-06-13 07:54:36 +02:00
EffectTriggers t;
0.8 update
2019-04-07 07:16:19 +02:00
Fix issues with Demul
2020-08-02 01:41:11 +02:00
bool CustomStrength = false;
bool WaitForGame = false;
0.8 update
2019-04-07 07:16:19 +02:00
bool keepRunning = true;
float wheel = 0.0f;
SDL_Joystick* GameController = NULL;
SDL_Haptic* ControllerHaptic = NULL;
SDL_Joystick* GameController2 = NULL;
SDL_Haptic* ControllerHaptic2 = NULL;
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
SDL_Joystick* GameController3 = NULL;
SDL_Haptic* ControllerHaptic3 = NULL;
0.8 update
2019-04-07 07:16:19 +02:00
HINSTANCE gl_hOriginalDll = NULL;
HINSTANCE gl_hjgtDll = NULL;
Modified HOTD4 & Updated ToolSet
2019-10-27 03:03:02 +01:00
HINSTANCE gl_cgGLDll = NULL;
0.8 update
2019-04-07 07:16:19 +02:00
HINSTANCE gl_hlibavs = NULL;
FreeLibrary on MAME32 & 64
2019-12-08 20:33:16 +01:00
extern HINSTANCE ProcDLL;
0.8 update
2019-04-07 07:16:19 +02:00
int joystick_index1;
int joystick1Index = -1;
int joystick_index2 = -1;
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
int joystick_index3 = -1;
Flycast Output FFB Support
2023-03-02 08:39:51 +01:00
static DWORD GameProcessID;
0.8 update
2019-04-07 07:16:19 +02:00
Changes to FFB Strength Adjustment
2020-06-25 07:19:41 +02:00
LPCSTR CustomAlternativeMaxForceLeft;
LPCSTR CustomAlternativeMaxForceRight;
LPCSTR CustomMaxForce;
Add some Persistant Value Stuff
2020-06-24 11:23:05 +02:00
0.8 update
2019-04-07 07:16:19 +02:00
// settings
Fix
2019-10-30 06:14:51 +01:00
wchar_t* settingsFilename = TEXT(".\\FFBPlugin.ini");
0.8 update
2019-04-07 07:16:19 +02:00
int configMinForce = GetPrivateProfileInt(TEXT("Settings"), TEXT("MinForce"), 0, settingsFilename);
int configMaxForce = GetPrivateProfileInt(TEXT("Settings"), TEXT("MaxForce"), 100, settingsFilename);
int enableLogging = GetPrivateProfileInt(TEXT("Settings"), TEXT("Logging"), 0, settingsFilename);
Rename FFBMode to PowerMode
2019-11-02 09:09:50 +01:00
int PowerMode = GetPrivateProfileInt(TEXT("Settings"), TEXT("PowerMode"), 0, settingsFilename);
Revert EnableRumble
2019-10-30 06:04:22 +01:00
int EnableRumble = GetPrivateProfileInt(TEXT("Settings"), TEXT("EnableRumble"), 0, settingsFilename);
Update SDL2 and add rumble trigger support
2021-02-14 00:38:22 +01:00
int EnableRumbleTriggers = GetPrivateProfileInt(TEXT("Settings"), TEXT("EnableRumbleTriggers"), 0, settingsFilename);
0.8 update
2019-04-07 07:16:19 +02:00
int ReverseRumble = GetPrivateProfileInt(TEXT("Settings"), TEXT("ReverseRumble"), 0, settingsFilename);
add SingleMotor rumble option
2022-10-23 07:16:36 +02:00
int SingleRumbleMotor = GetPrivateProfileInt(TEXT("Settings"), TEXT("SingleRumbleMotor"), 0, settingsFilename);
Add optional damper effect to all wheel games
2021-02-20 09:34:03 +01:00
int EnableDamper = GetPrivateProfileInt(TEXT("Settings"), TEXT("EnableDamper"), 0, settingsFilename);
int DamperStrength = GetPrivateProfileInt(TEXT("Settings"), TEXT("DamperStrength"), 100, settingsFilename);
Fix
2019-10-30 06:14:51 +01:00
wchar_t* deviceGUIDString = new wchar_t[256];
0.8 update
2019-04-07 07:16:19 +02:00
int DeviceGUID = GetPrivateProfileString(TEXT("Settings"), TEXT("DeviceGUID"), NULL, deviceGUIDString, 256, settingsFilename);
int configFeedbackLength = GetPrivateProfileInt(TEXT("Settings"), TEXT("FeedbackLength"), 120, settingsFilename);
updated to 0.9
2019-05-15 09:25:41 +02:00
int configGameId = GetPrivateProfileInt(TEXT("Settings"), TEXT("GameId"), 0, settingsFilename);
0.8 update
2019-04-07 07:16:19 +02:00
int configDefaultCentering = GetPrivateProfileInt(TEXT("Settings"), TEXT("DefaultCentering"), 0, settingsFilename);
int configDefaultFriction = GetPrivateProfileInt(TEXT("Settings"), TEXT("DefaultFriction"), 0, settingsFilename);
int BeepWhenHook = GetPrivateProfileInt(TEXT("Settings"), TEXT("BeepWhenHook"), 0, settingsFilename);
int AlternativeFFB = GetPrivateProfileInt(TEXT("Settings"), TEXT("AlternativeFFB"), 0, settingsFilename);
int configAlternativeMinForceLeft = GetPrivateProfileInt(TEXT("Settings"), TEXT("AlternativeMinForceLeft"), 0, settingsFilename);
int configAlternativeMaxForceLeft = GetPrivateProfileInt(TEXT("Settings"), TEXT("AlternativeMaxForceLeft"), 100, settingsFilename);
int configAlternativeMinForceRight = GetPrivateProfileInt(TEXT("Settings"), TEXT("AlternativeMinForceRight"), 0, settingsFilename);
int configAlternativeMaxForceRight = GetPrivateProfileInt(TEXT("Settings"), TEXT("AlternativeMaxForceRight"), 100, settingsFilename);
updated to 0.9
2019-05-15 09:25:41 +02:00
int ForceShowDeviceGUIDMessageBox = GetPrivateProfileInt(TEXT("Settings"), TEXT("ForceShowDeviceGUIDMessageBox"), 0, settingsFilename);
Added 2nd device FFB for Outrunners
2019-12-06 12:24:06 +01:00
int configMinForceDevice2 = GetPrivateProfileInt(TEXT("Settings"), TEXT("MinForceDevice2"), 0, settingsFilename);
int configMaxForceDevice2 = GetPrivateProfileInt(TEXT("Settings"), TEXT("MaxForceDevice2"), 100, settingsFilename);
int EnableRumbleDevice2 = GetPrivateProfileInt(TEXT("Settings"), TEXT("EnableRumbleDevice2"), 0, settingsFilename);
int ReverseRumbleDevice2 = GetPrivateProfileInt(TEXT("Settings"), TEXT("ReverseRumbleDevice2"), 0, settingsFilename);
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
int AlternativeFFBDevice2 = GetPrivateProfileInt(TEXT("Settings"), TEXT("AlternativeFFBDevice2"), 0, settingsFilename);
Added 2nd device FFB for Outrunners
2019-12-06 12:24:06 +01:00
int configAlternativeMinForceLeftDevice2 = GetPrivateProfileInt(TEXT("Settings"), TEXT("AlternativeMinForceLeftDevice2"), 0, settingsFilename);
int configAlternativeMaxForceLeftDevice2 = GetPrivateProfileInt(TEXT("Settings"), TEXT("AlternativeMaxForceLeftDevice2"), 100, settingsFilename);
int configAlternativeMinForceRightDevice2 = GetPrivateProfileInt(TEXT("Settings"), TEXT("AlternativeMinForceRightDevice2"), 0, settingsFilename);
int configAlternativeMaxForceRightDevice2 = GetPrivateProfileInt(TEXT("Settings"), TEXT("AlternativeMaxForceRightDevice2"), 100, settingsFilename);
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
int configMinForceDevice3 = GetPrivateProfileInt(TEXT("Settings"), TEXT("MinForceDevice3"), 0, settingsFilename);
int configMaxForceDevice3 = GetPrivateProfileInt(TEXT("Settings"), TEXT("MaxForceDevice3"), 100, settingsFilename);
int EnableRumbleDevice3 = GetPrivateProfileInt(TEXT("Settings"), TEXT("EnableRumbleDevice3"), 0, settingsFilename);
int ReverseRumbleDevice3 = GetPrivateProfileInt(TEXT("Settings"), TEXT("ReverseRumbleDevice3"), 0, settingsFilename);
int AlternativeFFBDevice3 = GetPrivateProfileInt(TEXT("Settings"), TEXT("AlternativeFFBDevice3"), 0, settingsFilename);
int configAlternativeMinForceLeftDevice3 = GetPrivateProfileInt(TEXT("Settings"), TEXT("AlternativeMinForceLeftDevice3"), 0, settingsFilename);
int configAlternativeMaxForceLeftDevice3 = GetPrivateProfileInt(TEXT("Settings"), TEXT("AlternativeMaxForceLeftDevice3"), 100, settingsFilename);
int configAlternativeMinForceRightDevice3 = GetPrivateProfileInt(TEXT("Settings"), TEXT("AlternativeMinForceRightDevice3"), 0, settingsFilename);
int configAlternativeMaxForceRightDevice3 = GetPrivateProfileInt(TEXT("Settings"), TEXT("AlternativeMaxForceRightDevice3"), 100, settingsFilename);
Make MAME and Supermodel Outputs have seperate game config settings Adjust strength etc different between each game
2019-12-22 02:59:53 +01:00
int SinePeriod = GetPrivateProfileInt(TEXT("Settings"), TEXT("SinePeriod"), 0, settingsFilename);
int SineFadePeriod = GetPrivateProfileInt(TEXT("Settings"), TEXT("SineFadePeriod"), 0, settingsFilename);
int SineStrength = GetPrivateProfileInt(TEXT("Settings"), TEXT("SineStrength"), 0, settingsFilename);
int RumbleStrengthLeftMotor = GetPrivateProfileInt(TEXT("Settings"), TEXT("RumbleStrengthLeftMotor"), 0, settingsFilename);
int RumbleStrengthRightMotor = GetPrivateProfileInt(TEXT("Settings"), TEXT("RumbleStrengthRightMotor"), 0, settingsFilename);
int EnableForceSpringEffect = GetPrivateProfileInt(TEXT("Settings"), TEXT("EnableForceSpringEffect"), 0, settingsFilename);
int ForceSpringStrength = GetPrivateProfileInt(TEXT("Settings"), TEXT("ForceSpringStrength"), 0, settingsFilename);
Add Change Volume Stuff for Demul
2020-06-20 00:32:00 +02:00
int AutoCloseWindowError = GetPrivateProfileInt(TEXT("Settings"), TEXT("AutoCloseWindowError"), 0, settingsFilename);
Adding optional dynamic strength adjustment controls.
2020-06-19 14:11:59 +02:00
int EnableFFBStrengthDynamicAdjustment = GetPrivateProfileInt(TEXT("Settings"), TEXT("EnableFFBStrengthDynamicAdjustment"), 0, settingsFilename);
int IncreaseFFBStrength = GetPrivateProfileInt(TEXT("Settings"), TEXT("IncreaseFFBStrength"), NULL, settingsFilename);
int DecreaseFFBStrength = GetPrivateProfileInt(TEXT("Settings"), TEXT("DecreaseFFBStrength"), NULL, settingsFilename);
int ResetFFBStrength = GetPrivateProfileInt(TEXT("Settings"), TEXT("ResetFFBStrength"), NULL, settingsFilename);
int StepFFBStrength = GetPrivateProfileInt(TEXT("Settings"), TEXT("StepFFBStrength"), 5, settingsFilename);
Adding persistence flag to disable saving strength adjustments.
2020-07-01 01:56:37 +02:00
int EnableFFBStrengthPersistence = GetPrivateProfileInt(TEXT("Settings"), TEXT("EnableFFBStrengthPersistence"), 0, settingsFilename);
Add Text to Speech for FFB Strength Adjustment
2020-06-25 08:30:20 +02:00
int EnableFFBStrengthTextToSpeech = GetPrivateProfileInt(TEXT("Settings"), TEXT("EnableFFBStrengthTextToSpeech"), 0, settingsFilename);
Fix lots of issues
2020-08-01 06:11:15 +02:00
int InputDeviceWheelEnable = GetPrivateProfileInt(TEXT("Settings"), TEXT("InputDeviceWheelEnable"), 0, settingsFilename);
Update and add option to ignore first matching guid
2021-12-12 00:43:51 +01:00
int IgnoreFirstMatchingGUID = GetPrivateProfileInt(TEXT("Settings"), TEXT("IgnoreFirstMatchingGUID"), 0, settingsFilename);
Changes
2023-03-05 06:00:07 +01:00
int DoubleSine = GetPrivateProfileInt(TEXT("Settings"), TEXT("DoubleSine"), 0, settingsFilename);
int DoubleConstant = GetPrivateProfileInt(TEXT("Settings"), TEXT("DoubleConstant"), 0, settingsFilename);
Daytona NSE Changes
2023-03-17 11:50:29 +01:00
int DoubleSpring = GetPrivateProfileInt(TEXT("Settings"), TEXT("DoubleSpring"), 0, settingsFilename);
int DoubleFriction = GetPrivateProfileInt(TEXT("Settings"), TEXT("DoubleFriction"), 0, settingsFilename);
GRID and MK Changes
2023-04-06 22:10:00 +02:00
int FFBOrRumble = GetPrivateProfileInt(TEXT("Settings"), TEXT("FFBOrRumble"), 0, settingsFilename);
Update SDL2 and add StartDelay option to ini files
2023-11-17 22:42:01 +01:00
int StartDelay = GetPrivateProfileInt(TEXT("Settings"), TEXT("StartDelay"), 0, settingsFilename);
Adding optional dynamic strength adjustment controls.
2020-06-19 14:11:59 +02:00
Add some Persistant Value Stuff
2020-06-24 11:23:05 +02:00
extern void DefaultConfigValues();
Changes to FFB Strength Adjustment
2020-06-25 07:19:41 +02:00
extern void CustomFFBStrengthSetup();
0.8 update
2019-04-07 07:16:19 +02:00
char chainedDLL[256];
Add Text to Speech for FFB Strength Adjustment
2020-06-25 08:30:20 +02:00
static char FFBStrength1[256];
static wchar_t FFBStrength2[256];
Fix lots of issues
2020-08-01 06:11:15 +02:00
SDL_Event e;
Add Text to Speech for FFB Strength Adjustment
2020-06-25 08:30:20 +02:00
HRESULT hr;
CComPtr<ISpVoice> cpVoice;
0.8 update
2019-04-07 07:16:19 +02:00
const int TEST_GAME_CONST = -1;
const int TEST_GAME_SINE = -2;
const int TEST_GAME_FRICTION = -3;
const int TEST_GAME_SPRING = -4;
const int TEST_GAME_HEAVY = -5;
const int TEST_GAME_LOOSE = -6;
updated to 0.9
2019-05-15 09:25:41 +02:00
const int TEST_GAME_RUMBLE = -7;
Add optional damper effect to all wheel games
2021-02-20 09:34:03 +01:00
const int TEST_GAME_RUMBLE_TRIGGER = -8;
0.8 update
2019-04-07 07:16:19 +02:00
const int DAYTONA_3 = 1;
const int WACKY_RACES = 2;
const int CHASE_HQ_2 = 3;
Added HOTD4 Disabled for now as it has some serious lag for some reason
2019-10-26 22:57:33 +02:00
const int HOTD_4 = 4;
0.8 update
2019-04-07 07:16:19 +02:00
const int SEGA_RACING_CLASSIC = 5;
const int SEGA_RALLY_3 = 6;
const int FORD_RACING = 7;
const int INITIAL_D_6 = 8;
const int WMMT_5 = 9;
Add GRID Custom and Spring to MKGP
2023-03-25 11:14:46 +01:00
const int GRID_Real = 10;
Mario Kart FFB Changes etc and 2.0.0.28 version
2023-03-25 10:45:33 +01:00
const int MARIO_KART_GPDX_CUSTOM = 11;
0.8 update
2019-04-07 07:16:19 +02:00
const int OUTRUN_2Fake = 12;
const int BG4_JP = 13;
const int MACH_STORM = 14;
const int AFTER_BURNER_CLIMAX = 15;
const int INITIAL_D_4 = 16;
const int INITIAL_D_7 = 17;
const int INITIAL_D_8 = 18;
const int POKKEN_TOURNAMENT = 19;
Mario Kart FFB Changes etc and 2.0.0.28 version
2023-03-25 10:45:33 +01:00
const int MARIO_KART_GPDX_110_CUSTOM = 20;
0.8 update
2019-04-07 07:16:19 +02:00
const int Sonic_Sega_AllStars_Racing = 21;
Rename OutputReading to MAMESupermodel
2020-05-25 07:36:14 +02:00
const int MAME_ = 22;
0.8 update
2019-04-07 07:16:19 +02:00
const int INITIAL_D_5 = 23;
const int INITIAL_D_4_Japan = 24;
const int M2_Emulator = 25;
const int Demul_Emulator = 26;
const int GTI_Club_3 = 27;
Cleaned up some stuff Removed seperate cpp files etc for 32bit and 64bit for Mame & Button Rumble
2019-10-26 04:46:16 +02:00
const int Button_Rumble = 28;
0.8 update
2019-04-07 07:16:19 +02:00
const int Road_Fighters_3D = 29;
const int LGI_3D = 30;
const int LGI_ = 31;
1.2
2019-11-14 21:36:13 +01:00
const int INITIAL_D_0 = 32;
Rename OutputReading to MAMESupermodel
2020-05-25 07:36:14 +02:00
const int SUPERMODEL_ = 34;
0.8 update
2019-04-07 07:16:19 +02:00
const int OUTRUN_2Real = 35;
Added Aliens Extermination
2019-12-16 06:55:50 +01:00
const int ALIENS_EXTERMINATION = 36;
Bunch of code changes, added transformers and rambo etc
2019-12-18 01:41:02 +01:00
const int RAMBO_ = 37;
updated to 0.9
2019-05-15 09:25:41 +02:00
const int FORD_RACING_OTHER = 38;
Added KO Drive
2019-09-14 02:29:00 +02:00
const int KO_Drive = 39;
Bunch of code changes, added transformers and rambo etc
2019-12-18 01:41:02 +01:00
const int Transformers_ = 40;
Added Golden Gun Rumble as requested
2019-12-20 01:59:19 +01:00
const int Golden_Gun = 41;
Add Dirty Drivin
2019-12-22 22:41:31 +01:00
const int Dirty_Drivin = 42;
Added H2Overdrive
2019-12-24 23:33:42 +01:00
const int H2_Overdrive = 43;
Added SnoCross
2020-01-09 00:42:33 +01:00
const int Sno_Cross = 44;
Added Batman
2020-03-13 23:05:19 +01:00
const int Bat_man = 45;
Add R-Tuned Support
2020-05-19 01:14:34 +02:00
const int R_Tuned = 46;
Add Sega Rally 3 Other
2020-05-27 11:57:10 +02:00
const int SEGA_RALLY_3_Other = 47;
Changes for past few weeks
2021-02-09 05:10:00 +01:00
const int INITIAL_D_0_211 = 49;
Add SWDC 2018 and MK USA
2021-02-09 05:30:19 +01:00
const int SWDC_2018 = 50;
Mario Kart FFB Changes etc and 2.0.0.28 version
2023-03-25 10:45:33 +01:00
const int MARIO_KART_GPDX_USA_CUSTOM = 51;
Add WMMT6 and WMMT6R FFB Support
2021-02-19 23:44:55 +01:00
const int WMMT_6 = 52;
const int WMMT_6_R = 53;
Storm Racer G
2021-04-17 00:31:12 +02:00
const int SRG = 54;
Add D1GP Support
2021-05-20 08:20:30 +02:00
const int D1_GP = 55;
add WMMT5DX and Crazy Taxi Steam
2021-09-26 09:27:43 +02:00
const int WMMT_5DXPlus = 56;
const int WMMT_5DX = 57;
const int Crazy_Taxi = 58;
add Daytona New Season Edition
2021-12-01 05:29:59 +01:00
const int DAYTONA_3_NSE = 59;
Add Flycast Initial D 1-3
2022-05-18 07:29:58 +02:00
const int FLYCAST = 60;
add Dead Heat and WMMT3
2022-06-08 07:06:23 +02:00
const int WMMT_3 = 61;
const int DEAD_HEAT = 62;
add Dead Heat Riders
2022-06-09 07:25:54 +02:00
const int DEAD_HEAT_RIDERS = 63;
Add FFB to Gaelco games
2022-06-10 12:41:25 +02:00
const int GAELCO_TUNING_RACE = 64;
const int TOKYO_COP = 65;
const int RING_RIDERS = 66;
add ID Zero 2.30 and Flycast Dojo
2022-09-17 10:24:36 +02:00
const int INITIAL_D_0_230 = 67;
Mario Kart FFB Changes etc and 2.0.0.28 version
2023-03-25 10:45:33 +01:00
const int MARIO_KART_GPDX_118_REAL = 68;
const int MARIO_KART_GPDX_110_REAL = 69;
const int MARIO_KART_GPDX_USA_REAL = 70;
Add GRID Custom and Spring to MKGP
2023-03-25 11:14:46 +01:00
const int GRID_Custom = 71;
MK 1.18 Custom
2023-03-26 11:16:12 +02:00
const int MARIO_KART_GPDX_118_CUSTOM = 72;
add Showdown
2023-08-26 08:07:18 +02:00
const int SEGA_SHOWDOWN = 73;
Add Spring Effect
2023-08-26 08:36:41 +02:00
const int SPRING_EFFECT = 74;
push Arctic Thunder code i never added
2024-03-20 02:02:55 +01:00
const int ARCTIC_THUNDER = 75;
FnF Added
2024-04-07 11:59:56 +02:00
const int CRUISN_BLAST = 76;
const int FNF = 77;
const int FNF_DRIFT = 78;
const int FNF_SUPERCARS = 79;
const int SEGA_RACE_TV = 80;
Added Hummer Extreme
2024-07-07 11:38:58 +02:00
const int HUMMER_EXTREME = 81;
0.8 update
2019-04-07 07:16:19 +02:00
HINSTANCE Get_hInstance()
{
MEMORY_BASIC_INFORMATION mbi;
VirtualQuery(Get_hInstance, &mbi, sizeof(mbi));
return reinterpret_cast<HINSTANCE>(mbi.AllocationBase);
}
void Initialize(int device_index)
{
hlp.log("in initialize");
Update SDL2 and add rumble trigger support
2021-02-14 00:38:22 +01:00
SDL_SetHint(SDL_HINT_JOYSTICK_RAWINPUT, "0");
remove SDL Init Video as it caused crash on Supermodel Emu
2023-11-25 08:48:05 +01:00
if (SDL_Init(SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC | SDL_INIT_GAMECONTROLLER) < 0)
0.8 update
2019-04-07 07:16:19 +02:00
SDL_JoystickEventState(SDL_ENABLE);
Removed ResetFeedback + small fixes
2019-10-28 22:32:21 +01:00
SDL_JoystickUpdate();
0.8 update
2019-04-07 07:16:19 +02:00
char joystick_guid[256];
sprintf(joystick_guid, "%S", deviceGUIDString);
SDL_JoystickGUID guid, dev_guid;
int numJoysticks = SDL_NumJoysticks();
hlp.log("numJoysticks = ");
std::string njs = std::to_string(numJoysticks);
Fix
2019-10-30 06:14:51 +01:00
hlp.log((char*)njs.c_str());
Fix Fanatec duplicate controller issue
2019-09-25 18:52:18 +02:00
char firstJoystickSelectedText[256];
SDL_Joystick* FirstGameController = NULL;
Fix
2019-10-30 06:14:51 +01:00
for (int i = 0; i < SDL_NumJoysticks(); i++)
0.8 update
2019-04-07 07:16:19 +02:00
{
SDL_Joystick* js = SDL_JoystickOpen(i);
const char* name = SDL_JoystickName(js);
Removed ResetFeedback + small fixes
2019-10-28 22:32:21 +01:00
guid = SDL_JoystickGetGUID(js);
0.8 update
2019-04-07 07:16:19 +02:00
if (ForceShowDeviceGUIDMessageBox == 1)
{
char text[256];
SDL_JoystickGetGUIDString(guid, text, 256);
MessageBoxA(NULL, name, "", 0);
MessageBoxA(NULL, text, "", 0);
}
char guid_str[1024];
SDL_JoystickGetGUIDString(guid, guid_str, sizeof(guid_str));
char text[256];
sprintf(text, "Joystick: %d / Name: %s / GUID: %s\n", i, name, guid_str);
hlp.log(text);
guid = SDL_JoystickGetGUIDFromString(joystick_guid);
dev_guid = SDL_JoystickGetGUID(js);
SDL_JoystickClose(js);
if (!memcmp(&guid, &dev_guid, sizeof(SDL_JoystickGUID)))
{
Update and add option to ignore first matching guid
2021-12-12 00:43:51 +01:00
if (!IgnoreFirstMatchingGUID)
Fix Fanatec duplicate controller issue
2019-09-25 18:52:18 +02:00
{
Update and add option to ignore first matching guid
2021-12-12 00:43:51 +01:00
joystick1Index = i;
GameController = SDL_JoystickOpen(i);
joystick_index1 = SDL_JoystickInstanceID(GameController);
ControllerHaptic = SDL_HapticOpenFromJoystick(GameController);
if (FirstGameController == NULL)
{
sprintf(firstJoystickSelectedText, "No haptic joystick found, selecting first joystick matching the GUID: %d / Name: %s / GUID: %s\n", i, name, guid_str);
FirstGameController = GameController;
}
if (ControllerHaptic != NULL)
{
sprintf(text, "Haptic joystick found: %d / Name: %s / GUID: %s\n", i, name, guid_str);
hlp.log(text);
break;
}
Fix Fanatec duplicate controller issue
2019-09-25 18:52:18 +02:00
}
Update and add option to ignore first matching guid
2021-12-12 00:43:51 +01:00
IgnoreFirstMatchingGUID = 0;
0.8 update
2019-04-07 07:16:19 +02:00
}
}
Update and add option to ignore first matching guid
2021-12-12 00:43:51 +01:00
if (ControllerHaptic == NULL && FirstGameController != NULL) // If no haptic controller has been found, we select the first controller matching the guid.
Fix Fanatec duplicate controller issue
2019-09-25 18:52:18 +02:00
{
GameController = FirstGameController;
hlp.log(firstJoystickSelectedText);
}
0.8 update
2019-04-07 07:16:19 +02:00
haptic = ControllerHaptic;
Update SDL2
2023-01-21 08:01:21 +01:00
if ((SDL_HapticRumbleSupported(haptic) == SDL_TRUE && EnableRumble))
0.8 update
2019-04-07 07:16:19 +02:00
{
Fix
2019-10-30 06:14:51 +01:00
SDL_HapticRumbleInit(ControllerHaptic);
0.8 update
2019-04-07 07:16:19 +02:00
hlp.log("Rumble Init");
}
hlp.log("disabling all current FFB effects");
SDL_HapticStopAll(haptic);
hlp.log("setting haptic gain to 100");
SDL_HapticSetGain(haptic, 100); // HapticSetGain should be between 0 and 100 as per https://wiki.libsdl.org/SDL_HapticSetGain
hlp.log("setting haptic auto center to 0");
SDL_HapticSetAutocenter(haptic, 0); // 0 disables autocenter https://wiki.libsdl.org/SDL_HapticSetAutocenter
Fix
2019-10-30 06:14:51 +01:00
0.8 update
2019-04-07 07:16:19 +02:00
SDL_HapticEffect tempEffect;
hlp.log("creating base effects...");
SDL_memset(&tempEffect, 0, sizeof(SDL_HapticEffect));
tempEffect.type = SDL_HAPTIC_CONSTANT;
tempEffect.constant.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.constant.direction.dir[0] = -1; //left => right is +1 as per this 2d array explanation: https://wiki.libsdl.org/SDL_HapticDirection
tempEffect.constant.length = configFeedbackLength; // presumably is ms, but is not documented
tempEffect.constant.delay = 0;
tempEffect.constant.level = 9999; // this is an sint16 => -32768 to 32767
Clean up constant force related code
2019-10-06 22:32:24 +02:00
effects.effect_constant_id = SDL_HapticNewEffect(haptic, &tempEffect); // Upload the effect
0.8 update
2019-04-07 07:16:19 +02:00
tempEffect = SDL_HapticEffect();
tempEffect.type = SDL_HAPTIC_FRICTION;
tempEffect.constant.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.condition.delay = 0;
tempEffect.condition.length = 5000;
effects.effect_friction_id = SDL_HapticNewEffect(haptic, &tempEffect);
tempEffect = SDL_HapticEffect();
tempEffect.type = SDL_HAPTIC_SINE;
tempEffect.constant.direction.type = SDL_HAPTIC_CARTESIAN;
effects.effect_sine_id = SDL_HapticNewEffect(haptic, &tempEffect);
tempEffect = SDL_HapticEffect();
tempEffect.type = SDL_HAPTIC_SPRING;
tempEffect.condition.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.condition.delay = 0;
tempEffect.condition.length = 5000;
effects.effect_spring_id = SDL_HapticNewEffect(haptic, &tempEffect);
updated to 0.9
2019-05-15 09:25:41 +02:00
tempEffect = SDL_HapticEffect();
tempEffect.type = SDL_HAPTIC_INERTIA;
tempEffect.condition.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.condition.delay = 0;
tempEffect.condition.length = 5000;
effects.effect_inertia_id = SDL_HapticNewEffect(haptic, &tempEffect);
tempEffect = SDL_HapticEffect();
tempEffect.type = SDL_HAPTIC_DAMPER;
tempEffect.condition.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.condition.delay = 0;
tempEffect.condition.length = 5000;
effects.effect_damper_id = SDL_HapticNewEffect(haptic, &tempEffect);
tempEffect = SDL_HapticEffect();
tempEffect.type = SDL_HAPTIC_TRIANGLE;
tempEffect.condition.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.condition.delay = 0;
tempEffect.condition.length = 5000;
effects.effect_triangle_id = SDL_HapticNewEffect(haptic, &tempEffect);
tempEffect = SDL_HapticEffect();
tempEffect.type = SDL_HAPTIC_RAMP;
tempEffect.ramp.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.ramp.delay = 0;
tempEffect.ramp.length = 5000;
effects.effect_ramp_id = SDL_HapticNewEffect(haptic, &tempEffect);
tempEffect = SDL_HapticEffect();
tempEffect.type = SDL_HAPTIC_SAWTOOTHUP;
tempEffect.condition.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.condition.delay = 0;
tempEffect.condition.length = 5000;
effects.effect_sawtoothup_id = SDL_HapticNewEffect(haptic, &tempEffect);
tempEffect = SDL_HapticEffect();
tempEffect.type = SDL_HAPTIC_SAWTOOTHDOWN;
tempEffect.condition.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.condition.delay = 0;
tempEffect.condition.length = 5000;
effects.effect_sawtoothdown_id = SDL_HapticNewEffect(haptic, &tempEffect);
Added 2nd device FFB for Outrunners
2019-12-06 12:24:06 +01:00
if (haptic2 != NULL)
{
SDL_HapticEffect tempEffect2;
SDL_memset(&tempEffect2, 0, sizeof(SDL_HapticEffect));
tempEffect2 = SDL_HapticEffect();
tempEffect2.type = SDL_HAPTIC_SINE;
tempEffect2.constant.direction.type = SDL_HAPTIC_CARTESIAN;
effects.effect_sine_id_device2 = SDL_HapticNewEffect(haptic2, &tempEffect2);
}
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
if (haptic3 != NULL)
{
SDL_HapticEffect tempEffect3;
SDL_memset(&tempEffect3, 0, sizeof(SDL_HapticEffect));
tempEffect3 = SDL_HapticEffect();
tempEffect3.type = SDL_HAPTIC_SINE;
tempEffect3.constant.direction.type = SDL_HAPTIC_CARTESIAN;
effects.effect_sine_id_device3 = SDL_HapticNewEffect(haptic3, &tempEffect3);
}
Added 2nd device FFB for Outrunners
2019-12-06 12:24:06 +01:00
0.8 update
2019-04-07 07:16:19 +02:00
// TODO: why don't we just define this as hackFix = true in the other file?
// Was there a reason to put it here?
updated to 0.9
2019-05-15 09:25:41 +02:00
// extern bool hackFix;
// hackFix = true;
Fix
2019-10-30 06:14:51 +01:00
0.8 update
2019-04-07 07:16:19 +02:00
}
using namespace std::chrono;
std::chrono::milliseconds timeOfLastSineEffect = duration_cast<milliseconds>(system_clock::now().time_since_epoch());
Added 2nd device FFB for Outrunners
2019-12-06 12:24:06 +01:00
std::chrono::milliseconds timeOfLastSineEffectDevice2 = duration_cast<milliseconds>(system_clock::now().time_since_epoch());
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
std::chrono::milliseconds timeOfLastSineEffectDevice3 = duration_cast<milliseconds>(system_clock::now().time_since_epoch());
Fix WMMT5 FFB Fix friction effect
2019-09-23 19:15:12 +02:00
double lastSineEffectStrength = 0;
Added 2nd device FFB for Outrunners
2019-12-06 12:24:06 +01:00
double lastSineEffectStrengthDevice2 = 0;
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
double lastSineEffectStrengthDevice3 = 0;
Improve WMMT5 FFB + fix sine effect globally
2019-09-29 18:01:35 +02:00
double lastSineEffectPeriod = 0;
Added 2nd device FFB for Outrunners
2019-12-06 12:24:06 +01:00
double lastSineEffectPeriodDevice2 = 0;
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
double lastSineEffectPeriodDevice3 = 0;
0.8 update
2019-04-07 07:16:19 +02:00
void TriggerConstantEffect(int direction, double strength)
{
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SDL_HapticEffect tempEffect;
SDL_memset(&tempEffect, 0, sizeof(SDL_HapticEffect));
tempEffect.type = SDL_HAPTIC_CONSTANT;
tempEffect.constant.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.constant.direction.dir[0] = direction;
tempEffect.constant.length = configFeedbackLength;
tempEffect.constant.delay = 0;
Clean up constant force and match pinkimo's changes Properly best to do this for all forces, easier to follow then
2019-10-04 11:48:15 +02:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
int confMinForce = configMinForce;
int confMaxForce = configMaxForce;
Clean up constant force and match pinkimo's changes Properly best to do this for all forces, easier to follow then
2019-10-04 11:48:15 +02:00
Update SDL2
2023-01-21 08:01:21 +01:00
if (AlternativeFFB)
Revert EnableRumble
2019-10-30 06:04:22 +01:00
{
if (direction == -1)
0.8 update
2019-04-07 07:16:19 +02:00
{
Revert EnableRumble
2019-10-30 06:04:22 +01:00
confMinForce = configAlternativeMinForceLeft;
confMaxForce = configAlternativeMaxForceLeft;
0.8 update
2019-04-07 07:16:19 +02:00
}
Revert EnableRumble
2019-10-30 06:04:22 +01:00
else
0.8 update
2019-04-07 07:16:19 +02:00
{
Revert EnableRumble
2019-10-30 06:04:22 +01:00
confMinForce = configAlternativeMinForceRight;
confMaxForce = configAlternativeMaxForceRight;
0.8 update
2019-04-07 07:16:19 +02:00
}
Revert EnableRumble
2019-10-30 06:04:22 +01:00
}
Update SDL2
2023-01-21 08:01:21 +01:00
if (PowerMode)
Update Output Reading Stuff rename Mame to OldMame as so outdated now
2019-12-07 08:26:04 +01:00
strength = pow(strength, 0.5);
Added FFBMode to be used global if enabled
2019-11-02 05:30:14 +01:00
Changes
2023-03-05 06:00:07 +01:00
if (DoubleConstant)
{
strength = strength * 2.0;
if (strength > 1.0)
strength = 1.0;
}
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SHORT MinForce = (SHORT)(strength > 0.001 ? (confMinForce / 100.0 * 32767.0) : 0);
SHORT MaxForce = (SHORT)(confMaxForce / 100.0 * 32767.0);
SHORT range = MaxForce - MinForce;
SHORT level = (SHORT)(strength * range + MinForce);
Revert "Add code for ffb to not work if rumble is enabled" This reverts commit 2d00338254a977d5fe3c038cd75d2a7db25f8b60.
2019-10-29 07:35:48 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
if (range > 0 && level < 0)
level = 32767;
else if (range < 0 && level > 0)
level = -32767;
tempEffect.constant.level = level;
Add optional damper effect to all wheel games
2021-02-20 09:34:03 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SDL_HapticUpdateEffect(haptic, effects.effect_constant_id, &tempEffect);
SDL_HapticRunEffect(haptic, effects.effect_constant_id, 1);
0.8 update
2019-04-07 07:16:19 +02:00
}
Removed ResetFeedback + small fixes
2019-10-28 22:32:21 +01:00
void TriggerFrictionEffectWithDefaultOption(double strength, bool isDefault)
{
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SDL_HapticEffect tempEffect;
SDL_memset(&tempEffect, 0, sizeof(SDL_HapticEffect));
tempEffect.type = SDL_HAPTIC_FRICTION;
tempEffect.condition.type = SDL_HAPTIC_FRICTION;
tempEffect.condition.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.condition.delay = 0;
tempEffect.condition.length = isDefault ? SDL_HAPTIC_INFINITY : configFeedbackLength;
tempEffect.condition.left_sat[0] = 0xFFFF;
tempEffect.condition.right_sat[0] = 0xFFFF;
Daytona NSE Changes
2023-03-17 11:50:29 +01:00
if (DoubleFriction)
{
strength = strength * 2.0;
if (strength > 1.0)
strength = 1.0;
}
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SHORT minForce = (SHORT)(strength > 0.001 ? (configMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
SHORT maxForce = (SHORT)(configMaxForce / 100.0 * 32767.0);
SHORT range = maxForce - minForce;
SHORT coeff = (SHORT)(strength * range + minForce);
Update SDL2
2023-01-21 08:01:21 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
if (coeff < 0)
coeff = 32767;
Revert "Add code for ffb to not work if rumble is enabled" This reverts commit 2d00338254a977d5fe3c038cd75d2a7db25f8b60.
2019-10-29 07:35:48 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.condition.left_coeff[0] = (short)(coeff);
tempEffect.condition.right_coeff[0] = (short)(coeff);
SDL_HapticUpdateEffect(haptic, effects.effect_friction_id, &tempEffect);
SDL_HapticRunEffect(haptic, effects.effect_friction_id, 1);
0.8 update
2019-04-07 07:16:19 +02:00
}
Fix
2019-10-30 06:14:51 +01:00
void TriggerInertiaEffect(double strength)
updated to 0.9
2019-05-15 09:25:41 +02:00
{
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SDL_HapticEffect tempEffect;
SDL_memset(&tempEffect, 0, sizeof(SDL_HapticEffect));
tempEffect.type = SDL_HAPTIC_INERTIA;
tempEffect.condition.type = SDL_HAPTIC_INERTIA;
tempEffect.condition.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.condition.delay = 0;
tempEffect.condition.length = configFeedbackLength;
tempEffect.condition.direction.dir[0] = 1;
tempEffect.condition.direction.dir[1] = 1; //Y Position
SHORT minForce = (SHORT)(strength > 0.001 ? (configMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
SHORT maxForce = (SHORT)(configMaxForce / 100.0 * 32767.0);
SHORT range = maxForce - minForce;
SHORT coeff = (SHORT)(strength * range + minForce);
Update SDL2
2023-01-21 08:01:21 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
if (coeff < 0)
coeff = 32767;
updated to 0.9
2019-05-15 09:25:41 +02:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.condition.left_coeff[0] = (short)(coeff);
tempEffect.condition.right_coeff[0] = (short)(coeff);
tempEffect.condition.left_sat[0] = (short)(coeff) * 10;
tempEffect.condition.right_sat[0] = (short)(coeff) * 10;
tempEffect.condition.center[0] = 0;
updated to 0.9
2019-05-15 09:25:41 +02:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SDL_HapticUpdateEffect(haptic, effects.effect_inertia_id, &tempEffect);
SDL_HapticRunEffect(haptic, effects.effect_inertia_id, 1);
updated to 0.9
2019-05-15 09:25:41 +02:00
}
void TriggerTriangleEffect(double strength, double length)
{
Revert EnableRumble
2019-10-30 06:04:22 +01:00
int direction = 1;
Fix
2019-10-30 06:14:51 +01:00
if (strength < -0.001) {
Revert EnableRumble
2019-10-30 06:04:22 +01:00
strength *= -1;
direction = -1;
}
Now Choose FFB or Rumble wont perform both at same time anymore
2019-10-29 08:53:58 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SDL_HapticEffect tempEffect;
SDL_memset(&tempEffect, 0, sizeof(SDL_HapticEffect));
tempEffect.type = SDL_HAPTIC_TRIANGLE;
tempEffect.condition.type = SDL_HAPTIC_TRIANGLE;
tempEffect.condition.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.condition.direction.dir[0] = direction;
tempEffect.condition.direction.dir[1] = 0; //Y Position
tempEffect.periodic.period = 500;
int confMinForce = configMinForce;
int confMaxForce = configMaxForce;
Update SDL2
2023-01-21 08:01:21 +01:00
if (AlternativeFFB)
Revert EnableRumble
2019-10-30 06:04:22 +01:00
{
if (direction == -1)
Add code for ffb to not work if rumble is enabled
2019-10-29 07:27:58 +01:00
{
Revert EnableRumble
2019-10-30 06:04:22 +01:00
confMinForce = configAlternativeMinForceLeft;
confMaxForce = configAlternativeMaxForceLeft;
Add code for ffb to not work if rumble is enabled
2019-10-29 07:27:58 +01:00
}
Revert EnableRumble
2019-10-30 06:04:22 +01:00
else
Now Choose FFB or Rumble wont perform both at same time anymore
2019-10-29 08:53:58 +01:00
{
Revert EnableRumble
2019-10-30 06:04:22 +01:00
confMinForce = configAlternativeMinForceRight;
confMaxForce = configAlternativeMaxForceRight;
Now Choose FFB or Rumble wont perform both at same time anymore
2019-10-29 08:53:58 +01:00
}
Revert "Add code for ffb to not work if rumble is enabled" This reverts commit 2d00338254a977d5fe3c038cd75d2a7db25f8b60.
2019-10-29 07:35:48 +01:00
}
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SHORT minForce = (SHORT)(strength > 0.001 ? (confMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
SHORT maxForce = (SHORT)(confMaxForce / 100.0 * 32767.0);
SHORT range = maxForce - minForce;
SHORT power = (SHORT)(strength * range + minForce);
Update SDL2
2023-01-21 08:01:21 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
if (range > 0 && power < 0)
power = 32767;
else if (range < 0 && power > 0)
power = -32767;
Update SDL2
2023-01-21 08:01:21 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.periodic.magnitude = power;
tempEffect.periodic.length = length;
tempEffect.periodic.attack_length = 1000;
tempEffect.periodic.fade_length = 1000;
Fix
2019-10-30 06:14:51 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SDL_HapticUpdateEffect(haptic, effects.effect_triangle_id, &tempEffect);
SDL_HapticRunEffect(haptic, effects.effect_triangle_id, 1);
updated to 0.9
2019-05-15 09:25:41 +02:00
}
Fix
2019-10-30 06:14:51 +01:00
void TriggerDamperEffect(double strength)
updated to 0.9
2019-05-15 09:25:41 +02:00
{
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SDL_HapticEffect tempEffect;
SDL_memset(&tempEffect, 0, sizeof(SDL_HapticEffect));
tempEffect.type = SDL_HAPTIC_DAMPER;
tempEffect.condition.type = SDL_HAPTIC_DAMPER;
tempEffect.condition.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.condition.delay = 0;
tempEffect.condition.length = configFeedbackLength;
tempEffect.condition.direction.dir[0] = 1; // not used
tempEffect.condition.direction.dir[1] = 0; //Y Position
SHORT minForce = (SHORT)(strength > 0.001 ? (configMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
SHORT maxForce = (SHORT)(configMaxForce / 100.0 * 32767.0);
SHORT range = maxForce - minForce;
SHORT coeff = (SHORT)(strength * range + minForce);
Add optional damper effect to all wheel games
2021-02-20 09:34:03 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
if (coeff < 0)
coeff = 32767;
Fix WMMT5 FFB Fix friction effect
2019-09-23 19:15:12 +02:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.condition.left_coeff[0] = (short)(coeff);
tempEffect.condition.right_coeff[0] = (short)(coeff);
Add optional damper effect to all wheel games
2021-02-20 09:34:03 +01:00
tempEffect.condition.left_sat[0] = (DWORD)(coeff) * 2;
tempEffect.condition.right_sat[0] = (DWORD)(coeff) * 2;
updated to 0.9
2019-05-15 09:25:41 +02:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SDL_HapticUpdateEffect(haptic, effects.effect_damper_id, &tempEffect);
SDL_HapticRunEffect(haptic, effects.effect_damper_id, 1);
updated to 0.9
2019-05-15 09:25:41 +02:00
}
Fix
2019-10-30 06:14:51 +01:00
void TriggerRampEffect(double start, double end, double length)
updated to 0.9
2019-05-15 09:25:41 +02:00
{
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SDL_HapticEffect tempEffect;
SDL_memset(&tempEffect, 0, sizeof(SDL_HapticEffect));
tempEffect.type = SDL_HAPTIC_RAMP;
tempEffect.ramp.type = SDL_HAPTIC_RAMP;
tempEffect.ramp.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.ramp.length = length;
SHORT minForce = (SHORT)(start > 0.001 ? (configMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
SHORT maxForce = (SHORT)(configMaxForce / 100.0 * 32767.0);
SHORT range = maxForce - minForce;
SHORT start1 = (SHORT)(start * range + minForce);
Update SDL2
2023-01-21 08:01:21 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
if (start1 < 0)
start1 = 32767;
Update SDL2
2023-01-21 08:01:21 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SHORT minForce2 = (SHORT)(end > 0.001 ? (configMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
SHORT maxForce2 = (SHORT)(configMaxForce / 100.0 * 32767.0);
SHORT range2 = maxForce - minForce;
SHORT start2 = (SHORT)(end * range + minForce);
Update SDL2
2023-01-21 08:01:21 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
if (start2 < 0)
start2 = 32767;
Update SDL2
2023-01-21 08:01:21 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.ramp.delay = 0;
tempEffect.ramp.start = start1;
tempEffect.ramp.end = -start2;
Fix
2019-10-30 06:14:51 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SDL_HapticUpdateEffect(haptic, effects.effect_ramp_id, &tempEffect);
SDL_HapticRunEffect(haptic, effects.effect_ramp_id, 1);
updated to 0.9
2019-05-15 09:25:41 +02:00
}
Fix
2019-10-30 06:14:51 +01:00
void TriggerSawtoothUpEffect(double strength, double length)
updated to 0.9
2019-05-15 09:25:41 +02:00
{
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SDL_HapticEffect tempEffect;
SDL_memset(&tempEffect, 0, sizeof(SDL_HapticEffect));
tempEffect.type = SDL_HAPTIC_SAWTOOTHUP;
tempEffect.condition.type = SDL_HAPTIC_SAWTOOTHUP;
tempEffect.condition.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.periodic.period = 500;
SHORT minForce = (SHORT)(strength > 0.001 ? (configMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
SHORT maxForce = (SHORT)(configMaxForce / 100.0 * 32767.0);
SHORT range = maxForce - minForce;
SHORT power = (SHORT)(strength * range + minForce);
Update SDL2
2023-01-21 08:01:21 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
if (power < 0)
power = 32767;
Update SDL2
2023-01-21 08:01:21 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.periodic.magnitude = power;
tempEffect.periodic.length = length;
tempEffect.periodic.attack_length = 1000;
tempEffect.periodic.fade_length = 1000;
SDL_HapticUpdateEffect(haptic, effects.effect_sawtoothup_id, &tempEffect);
SDL_HapticRunEffect(haptic, effects.effect_sawtoothup_id, 1);
updated to 0.9
2019-05-15 09:25:41 +02:00
}
Revert EnableRumble
2019-10-30 06:04:22 +01:00
void TriggerSawtoothDownEffect(double strength, double length) {
SDL_HapticEffect tempEffect;
SDL_memset(&tempEffect, 0, sizeof(SDL_HapticEffect));
tempEffect.type = SDL_HAPTIC_SAWTOOTHDOWN;
tempEffect.condition.type = SDL_HAPTIC_SAWTOOTHDOWN;
tempEffect.condition.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.periodic.period = 500;
SHORT minForce = (SHORT)(strength > 0.001 ? (configMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
SHORT maxForce = (SHORT)(configMaxForce / 100.0 * 32767.0);
SHORT range = maxForce - minForce;
SHORT power = (SHORT)(strength * range + minForce);
Update SDL2
2023-01-21 08:01:21 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
if (power < 0)
power = 32767;
Update SDL2
2023-01-21 08:01:21 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.periodic.magnitude = power;
tempEffect.periodic.length = length;
tempEffect.periodic.attack_length = 1000;
tempEffect.periodic.fade_length = 1000;
SDL_HapticUpdateEffect(haptic, effects.effect_sawtoothdown_id, &tempEffect);
SDL_HapticRunEffect(haptic, effects.effect_sawtoothdown_id, 1);
updated to 0.9
2019-05-15 09:25:41 +02:00
}
0.8 update
2019-04-07 07:16:19 +02:00
void TriggerFrictionEffect(double strength)
{
Revert EnableRumble
2019-10-30 06:04:22 +01:00
TriggerFrictionEffectWithDefaultOption(strength, false);
0.8 update
2019-04-07 07:16:19 +02:00
}
void TriggerSineEffect(UINT16 period, UINT16 fadePeriod, double strength)
{
Revert EnableRumble
2019-10-30 06:04:22 +01:00
std::chrono::milliseconds now = duration_cast<milliseconds>(system_clock::now().time_since_epoch());
long long elapsedTime = (std::chrono::duration_cast<std::chrono::milliseconds>(now - timeOfLastSineEffect)).count();
0.8 update
2019-04-07 07:16:19 +02:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
int direction = 1;
Fix
2019-10-30 06:14:51 +01:00
if (strength < -0.001) {
Revert EnableRumble
2019-10-30 06:04:22 +01:00
strength *= -1;
direction = -1;
}
Improve WMMT5 FFB + fix sine effect globally
2019-09-29 18:01:35 +02:00
Fix
2019-10-30 06:14:51 +01:00
// if no strength, we do nothing
Update SDL2
2023-01-21 08:01:21 +01:00
if (strength <= 0.001)
Revert EnableRumble
2019-10-30 06:04:22 +01:00
return;
Fix
2019-10-30 06:14:51 +01:00
// we ignore the new effect until the last one is completed, unless the new one is significantly stronger
if (elapsedTime < lastSineEffectPeriod && strength < (lastSineEffectStrength * 1.5)) {
Revert EnableRumble
2019-10-30 06:04:22 +01:00
return;
}
SDL_HapticEffect tempEffect;
SDL_memset(&tempEffect, 0, sizeof(SDL_HapticEffect));
hlp.log("Doing sine...");
tempEffect.type = SDL_HAPTIC_SINE;
tempEffect.periodic.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.periodic.direction.dir[0] = direction;
tempEffect.constant.direction.dir[1] = 0; //Y Position
tempEffect.periodic.period = period;
int confMinForce = configMinForce;
int confMaxForce = configMaxForce;
Update SDL2
2023-01-21 08:01:21 +01:00
if (AlternativeFFB)
Revert EnableRumble
2019-10-30 06:04:22 +01:00
{
if (direction == -1)
Add code for ffb to not work if rumble is enabled
2019-10-29 07:27:58 +01:00
{
Revert EnableRumble
2019-10-30 06:04:22 +01:00
confMinForce = configAlternativeMinForceLeft;
confMaxForce = configAlternativeMaxForceLeft;
Now Choose FFB or Rumble wont perform both at same time anymore
2019-10-29 08:53:58 +01:00
}
Revert EnableRumble
2019-10-30 06:04:22 +01:00
else
Now Choose FFB or Rumble wont perform both at same time anymore
2019-10-29 08:53:58 +01:00
{
Revert EnableRumble
2019-10-30 06:04:22 +01:00
confMinForce = configAlternativeMinForceRight;
confMaxForce = configAlternativeMaxForceRight;
Add support for alternative FFB to sine and triangle effects Fix constant effect alternative FFB
2019-09-28 02:37:29 +02:00
}
Revert EnableRumble
2019-10-30 06:04:22 +01:00
}
Changes
2023-03-05 06:00:07 +01:00
if (DoubleSine)
{
strength = strength * 2.0;
if (strength > 1.0)
strength = 1.0;
}
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SHORT minForce = (SHORT)(strength > 0.001 ? (confMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
SHORT maxForce = (SHORT)(confMaxForce / 100.0 * 32767.0);
SHORT range = maxForce - minForce;
SHORT magnitude = (SHORT)(strength * range + minForce);
Update SDL2
2023-01-21 08:01:21 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
if (range > 0 && magnitude < 0)
magnitude = 32767;
else if (range < 0 && magnitude > 0)
magnitude = -32767;
0.8 update
2019-04-07 07:16:19 +02:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.periodic.magnitude = (SHORT)(magnitude);
tempEffect.periodic.length = period;
tempEffect.periodic.attack_length = fadePeriod;
tempEffect.periodic.fade_length = fadePeriod;
0.8 update
2019-04-07 07:16:19 +02:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SDL_HapticUpdateEffect(haptic, effects.effect_sine_id, &tempEffect);
SDL_HapticRunEffect(haptic, effects.effect_sine_id, 1);
0.8 update
2019-04-07 07:16:19 +02:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
timeOfLastSineEffect = now;
lastSineEffectStrength = strength;
lastSineEffectPeriod = period;
0.8 update
2019-04-07 07:16:19 +02:00
}
Added 2nd device FFB for Outrunners
2019-12-06 12:24:06 +01:00
void TriggerSineEffectDevice2(UINT16 period, UINT16 fadePeriod, double strength)
{
std::chrono::milliseconds now = duration_cast<milliseconds>(system_clock::now().time_since_epoch());
long long elapsedTime = (std::chrono::duration_cast<std::chrono::milliseconds>(now - timeOfLastSineEffectDevice2)).count();
int direction = 1;
if (strength < -0.001) {
strength *= -1;
direction = -1;
}
// if no strength, we do nothing
Update SDL2
2023-01-21 08:01:21 +01:00
if (strength <= 0.001)
Added 2nd device FFB for Outrunners
2019-12-06 12:24:06 +01:00
return;
// we ignore the new effect until the last one is completed, unless the new one is significantly stronger
if (elapsedTime < lastSineEffectPeriodDevice2 && strength < (lastSineEffectStrengthDevice2 * 1.5)) {
return;
}
SDL_HapticEffect tempEffect;
SDL_memset(&tempEffect, 0, sizeof(SDL_HapticEffect));
hlp.log("Doing Device2 sine...");
tempEffect.type = SDL_HAPTIC_SINE;
tempEffect.periodic.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.periodic.direction.dir[0] = direction;
tempEffect.constant.direction.dir[1] = 0; //Y Position
tempEffect.periodic.period = period;
int confMinForce = configMinForceDevice2;
int confMaxForce = configMaxForceDevice2;
Update SDL2
2023-01-21 08:01:21 +01:00
if (AlternativeFFBDevice2)
Added 2nd device FFB for Outrunners
2019-12-06 12:24:06 +01:00
{
if (direction == -1)
{
confMinForce = configAlternativeMinForceLeftDevice2;
confMaxForce = configAlternativeMaxForceLeftDevice2;
}
else
{
confMinForce = configAlternativeMinForceRightDevice2;
confMaxForce = configAlternativeMaxForceRightDevice2;
}
}
SHORT minForce = (SHORT)(strength > 0.001 ? (confMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
SHORT maxForce = (SHORT)(confMaxForce / 100.0 * 32767.0);
SHORT range = maxForce - minForce;
SHORT magnitude = (SHORT)(strength * range + minForce);
Update SDL2
2023-01-21 08:01:21 +01:00
Added 2nd device FFB for Outrunners
2019-12-06 12:24:06 +01:00
if (range > 0 && magnitude < 0)
magnitude = 32767;
else if (range < 0 && magnitude > 0)
magnitude = -32767;
tempEffect.periodic.magnitude = (SHORT)(magnitude);
tempEffect.periodic.length = period;
tempEffect.periodic.attack_length = fadePeriod;
tempEffect.periodic.fade_length = fadePeriod;
SDL_HapticUpdateEffect(haptic2, effects.effect_sine_id_device2, &tempEffect);
SDL_HapticRunEffect(haptic2, effects.effect_sine_id_device2, 1);
timeOfLastSineEffectDevice2 = now;
lastSineEffectStrengthDevice2 = strength;
lastSineEffectPeriodDevice2 = period;
}
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
void TriggerSineEffectDevice3(UINT16 period, UINT16 fadePeriod, double strength)
{
std::chrono::milliseconds now = duration_cast<milliseconds>(system_clock::now().time_since_epoch());
long long elapsedTime = (std::chrono::duration_cast<std::chrono::milliseconds>(now - timeOfLastSineEffectDevice3)).count();
int direction = 1;
if (strength < -0.001) {
strength *= -1;
direction = -1;
}
// if no strength, we do nothing
Update SDL2
2023-01-21 08:01:21 +01:00
if (strength <= 0.001)
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
return;
// we ignore the new effect until the last one is completed, unless the new one is significantly stronger
if (elapsedTime < lastSineEffectPeriodDevice3 && strength < (lastSineEffectStrengthDevice3 * 1.5)) {
return;
}
SDL_HapticEffect tempEffect;
SDL_memset(&tempEffect, 0, sizeof(SDL_HapticEffect));
hlp.log("Doing Device3 sine...");
tempEffect.type = SDL_HAPTIC_SINE;
tempEffect.periodic.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.periodic.direction.dir[0] = direction;
tempEffect.constant.direction.dir[1] = 0; //Y Position
tempEffect.periodic.period = period;
int confMinForce = configMinForceDevice3;
int confMaxForce = configMaxForceDevice3;
Update SDL2
2023-01-21 08:01:21 +01:00
if (AlternativeFFBDevice3)
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
{
if (direction == -1)
{
confMinForce = configAlternativeMinForceLeftDevice3;
confMaxForce = configAlternativeMaxForceLeftDevice3;
}
else
{
confMinForce = configAlternativeMinForceRightDevice3;
confMaxForce = configAlternativeMaxForceRightDevice3;
}
}
SHORT minForce = (SHORT)(strength > 0.001 ? (confMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
SHORT maxForce = (SHORT)(confMaxForce / 100.0 * 32767.0);
SHORT range = maxForce - minForce;
SHORT magnitude = (SHORT)(strength * range + minForce);
Update SDL2
2023-01-21 08:01:21 +01:00
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
if (range > 0 && magnitude < 0)
magnitude = 32767;
else if (range < 0 && magnitude > 0)
magnitude = -32767;
tempEffect.periodic.magnitude = (SHORT)(magnitude);
tempEffect.periodic.length = period;
tempEffect.periodic.attack_length = fadePeriod;
tempEffect.periodic.fade_length = fadePeriod;
SDL_HapticUpdateEffect(haptic3, effects.effect_sine_id_device3, &tempEffect);
SDL_HapticRunEffect(haptic3, effects.effect_sine_id_device3, 1);
timeOfLastSineEffectDevice3 = now;
lastSineEffectStrengthDevice3 = strength;
lastSineEffectPeriodDevice3 = period;
}
Removed ResetFeedback + small fixes
2019-10-28 22:32:21 +01:00
void TriggerSpringEffectWithDefaultOption(double strength, bool isDefault)
{
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SDL_HapticEffect tempEffect;
SDL_memset(&tempEffect, 0, sizeof(SDL_HapticEffect));
tempEffect.type = SDL_HAPTIC_SPRING;
tempEffect.condition.type = SDL_HAPTIC_SPRING;
tempEffect.condition.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.condition.delay = 0;
tempEffect.condition.length = isDefault ? SDL_HAPTIC_INFINITY : configFeedbackLength;
tempEffect.condition.direction.dir[0] = 1;
tempEffect.constant.direction.dir[1] = 0; //Y Position
Fix
2019-10-30 06:14:51 +01:00
Daytona NSE Changes
2023-03-17 11:50:29 +01:00
if (DoubleSpring)
{
strength = strength * 2.0;
if (strength > 1.0)
strength = 1.0;
}
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SHORT minForce = (SHORT)(strength > 0.001 ? (configMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
SHORT maxForce = (SHORT)(configMaxForce / 100.0 * 32767.0);
SHORT range = maxForce - minForce;
SHORT coeff = (SHORT)(strength * range + minForce);
Update SDL2
2023-01-21 08:01:21 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
if (coeff < 0)
coeff = 32767;
0.8 update
2019-04-07 07:16:19 +02:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.condition.left_coeff[0] = (short)(coeff);
tempEffect.condition.right_coeff[0] = (short)(coeff);
Changes output reading and spring
2020-01-02 21:40:01 +01:00
tempEffect.condition.left_sat[0] = (short)(coeff * 2.0); //Needed for Logitech G920 wheel
tempEffect.condition.right_sat[0] = (short)(coeff * 2.0); //Needed for Logitech G920 wheel
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.condition.center[0] = 0;
0.8 update
2019-04-07 07:16:19 +02:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SDL_HapticUpdateEffect(haptic, effects.effect_spring_id, &tempEffect);
SDL_HapticRunEffect(haptic, effects.effect_spring_id, 1);
0.8 update
2019-04-07 07:16:19 +02:00
}
void TriggerSpringEffectInfinite(double strength)
{
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SDL_HapticEffect tempEffect;
SDL_memset(&tempEffect, 0, sizeof(SDL_HapticEffect));
tempEffect.type = SDL_HAPTIC_SPRING;
tempEffect.condition.type = SDL_HAPTIC_SPRING;
tempEffect.condition.direction.type = SDL_HAPTIC_CARTESIAN;
tempEffect.condition.delay = 0;
tempEffect.condition.length = SDL_HAPTIC_INFINITY;
tempEffect.condition.direction.dir[0] = 1;
tempEffect.constant.direction.dir[1] = 1; //Y Position
Spring Changes
2023-08-27 09:56:37 +02:00
SHORT minForce;
SHORT maxForce;
if (EnableForceSpringEffect)
{
minForce = (SHORT)(0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
maxForce = (SHORT)(ForceSpringStrength / 100.0 * 32767.0);
}
else
{
minForce = (SHORT)(strength > 0.001 ? (configMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
maxForce = (SHORT)(configMaxForce / 100.0 * 32767.0);
}
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SHORT range = maxForce - minForce;
SHORT coeff = (SHORT)(strength * range + minForce);
Update SDL2
2023-01-21 08:01:21 +01:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
if (coeff < 0)
coeff = 32767;
0.8 update
2019-04-07 07:16:19 +02:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.condition.left_coeff[0] = (short)(coeff);
tempEffect.condition.right_coeff[0] = (short)(coeff);
Changes output reading and spring
2020-01-02 21:40:01 +01:00
tempEffect.condition.left_sat[0] = (short)(coeff * 2.0); //Needed for Logitech G920 wheel
tempEffect.condition.right_sat[0] = (short)(coeff * 2.0); //Needed for Logitech G920 wheel
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.condition.center[0] = 0;
0.8 update
2019-04-07 07:16:19 +02:00
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SDL_HapticUpdateEffect(haptic, effects.effect_spring_id, &tempEffect);
SDL_HapticRunEffect(haptic, effects.effect_spring_id, 1);
0.8 update
2019-04-07 07:16:19 +02:00
}
void TriggerLeftRightEffect(double smallstrength, double largestrength, double length)
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (EnableRumble)
0.8 update
2019-04-07 07:16:19 +02:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (!ReverseRumble)
0.8 update
2019-04-07 07:16:19 +02:00
{
SDL_HapticEffect tempEffect;
tempEffect.type = SDL_HAPTIC_LEFTRIGHT;
tempEffect.leftright.length = length;
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SHORT minForce = (SHORT)(smallstrength > 0.001 ? (configMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
0.8 update
2019-04-07 07:16:19 +02:00
SHORT maxForce = (SHORT)(configMaxForce / 100.0 * 32767.0);
SHORT range = maxForce - minForce;
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.leftright.small_magnitude = (SHORT)(smallstrength * range + minForce);
SHORT minForce1 = (SHORT)(largestrength > 0.001 ? (configMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
0.8 update
2019-04-07 07:16:19 +02:00
SHORT maxForce1 = (SHORT)(configMaxForce / 100.0 * 32767.0);
SHORT range1 = maxForce1 - minForce1;
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.leftright.large_magnitude = (SHORT)(largestrength * range1 + minForce1);
0.8 update
2019-04-07 07:16:19 +02:00
SDL_HapticUpdateEffect(haptic, effects.effect_leftright_id, &tempEffect);
SDL_HapticRunEffect(haptic, effects.effect_leftright_id, 1);
}
Update SDL2
2023-01-21 08:01:21 +01:00
else
0.8 update
2019-04-07 07:16:19 +02:00
{
SDL_HapticEffect tempEffect;
tempEffect.type = SDL_HAPTIC_LEFTRIGHT;
tempEffect.leftright.length = length;
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SHORT minForce = (SHORT)(largestrength > 0.001 ? (configMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
0.8 update
2019-04-07 07:16:19 +02:00
SHORT maxForce = (SHORT)(configMaxForce / 100.0 * 32767.0);
SHORT range = maxForce - minForce;
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.leftright.small_magnitude = (SHORT)(largestrength * range + minForce);
SHORT minForce1 = (SHORT)(smallstrength > 0.001 ? (configMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
0.8 update
2019-04-07 07:16:19 +02:00
SHORT maxForce1 = (SHORT)(configMaxForce / 100.0 * 32767.0);
SHORT range1 = maxForce1 - minForce1;
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.leftright.large_magnitude = (SHORT)(smallstrength * range1 + minForce1);
0.8 update
2019-04-07 07:16:19 +02:00
SDL_HapticUpdateEffect(haptic, effects.effect_leftright_id, &tempEffect);
SDL_HapticRunEffect(haptic, effects.effect_leftright_id, 1);
}
}
}
void TriggerLeftRightDevice2Effect(double smallstrength, double largestrength, double length)
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (EnableRumble)
0.8 update
2019-04-07 07:16:19 +02:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (!ReverseRumble)
0.8 update
2019-04-07 07:16:19 +02:00
{
SDL_HapticEffect tempEffect;
tempEffect.type = SDL_HAPTIC_LEFTRIGHT;
tempEffect.leftright.length = length;
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SHORT minForce = (SHORT)(smallstrength > 0.001 ? (configMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
0.8 update
2019-04-07 07:16:19 +02:00
SHORT maxForce = (SHORT)(configMaxForce / 100.0 * 32767.0);
SHORT range = maxForce - minForce;
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.leftright.small_magnitude = (SHORT)(smallstrength * range + minForce);
SHORT minForce1 = (SHORT)(largestrength > 0.001 ? (configMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
0.8 update
2019-04-07 07:16:19 +02:00
SHORT maxForce1 = (SHORT)(configMaxForce / 100.0 * 32767.0);
SHORT range1 = maxForce1 - minForce1;
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.leftright.large_magnitude = (SHORT)(largestrength * range1 + minForce1);
0.8 update
2019-04-07 07:16:19 +02:00
SDL_HapticUpdateEffect(haptic2, effects.effect_leftright_id, &tempEffect);
SDL_HapticRunEffect(haptic2, effects.effect_leftright_id, 1);
}
Update SDL2
2023-01-21 08:01:21 +01:00
else
0.8 update
2019-04-07 07:16:19 +02:00
{
SDL_HapticEffect tempEffect;
tempEffect.type = SDL_HAPTIC_LEFTRIGHT;
tempEffect.leftright.length = length;
Revert EnableRumble
2019-10-30 06:04:22 +01:00
SHORT minForce = (SHORT)(largestrength > 0.001 ? (configMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
0.8 update
2019-04-07 07:16:19 +02:00
SHORT maxForce = (SHORT)(configMaxForce / 100.0 * 32767.0);
SHORT range = maxForce - minForce;
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.leftright.small_magnitude = (SHORT)(largestrength * range + minForce);
SHORT minForce1 = (SHORT)(smallstrength > 0.001 ? (configMinForce / 100.0 * 32767.0) : 0); // strength is a double so we do an epsilon check of 0.001 instead of > 0.
0.8 update
2019-04-07 07:16:19 +02:00
SHORT maxForce1 = (SHORT)(configMaxForce / 100.0 * 32767.0);
SHORT range1 = maxForce1 - minForce1;
Revert EnableRumble
2019-10-30 06:04:22 +01:00
tempEffect.leftright.large_magnitude = (SHORT)(smallstrength * range1 + minForce1);
0.8 update
2019-04-07 07:16:19 +02:00
SDL_HapticUpdateEffect(haptic2, effects.effect_leftright_id, &tempEffect);
SDL_HapticRunEffect(haptic2, effects.effect_leftright_id, 1);
}
}
}
Workaround for SDL_JoystickRUmble rumble not stopping issue
2019-11-02 00:06:34 +01:00
void TriggerRumbleEffect(double highfrequency, double lowfrequency, double length)
0.8 update
2019-04-07 07:16:19 +02:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (EnableRumble)
0.8 update
2019-04-07 07:16:19 +02:00
{
Add new rumble code inplace of old simple rumble never used so no need to keep it
2019-10-30 06:20:41 +01:00
DWORD minForceLow = (DWORD)(lowfrequency > 0.001 ? (configMinForce / 100.0 * 65535.0) : 0);
DWORD minForceHigh = (DWORD)(highfrequency > 0.001 ? (configMinForce / 100.0 * 65535.0) : 0);
DWORD maxForce = (DWORD)(configMaxForce / 100.0 * 65535.0);
DWORD rangeLow = maxForce - minForceLow;
DWORD rangeHigh = maxForce - minForceHigh;
DWORD LowMotor = (DWORD)(lowfrequency * rangeLow + minForceLow);
DWORD HighMotor = (DWORD)(highfrequency * rangeHigh + minForceHigh);
add SingleMotor rumble option
2022-10-23 07:16:36 +02:00
if (SingleRumbleMotor)
{
double LowPercent = (LowMotor / 65535.0) * 100.0;
double LowPercentRange = 100.0 - LowPercent;
double HighPercent = (HighMotor / 65535.0) * 100.0;
double Calculation = LowPercent + ((LowPercentRange * HighPercent) / 100.0);
LowMotor = 65535.0 * (Calculation / 100.0);
}
Update SDL2
2023-01-21 08:01:21 +01:00
if (ReverseRumble)
Added Reverse for new rumble
2019-10-30 06:24:36 +01:00
{
Fix issue where Rumble would slow down and crash games etc If used on unsupported device eg Wheel now Rumble will automatically disable if its unsupported
2019-11-01 13:49:29 +01:00
int ReverseRumble = SDL_JoystickRumble(GameController, HighMotor, LowMotor, length);
Update SDL2
2023-01-21 08:01:21 +01:00
Fix issue where Rumble would slow down and crash games etc If used on unsupported device eg Wheel now Rumble will automatically disable if its unsupported
2019-11-01 13:49:29 +01:00
if (ReverseRumble == -1)
EnableRumble = 0;
Added Reverse for new rumble
2019-10-30 06:24:36 +01:00
}
else
Revert "Fixed Rumble never stopping effects" This reverts commit 5aa55e86663ce0926235c22fea1588110055b10e.
2019-10-31 09:22:59 +01:00
{
Fix issue where Rumble would slow down and crash games etc If used on unsupported device eg Wheel now Rumble will automatically disable if its unsupported
2019-11-01 13:49:29 +01:00
int Rumble = SDL_JoystickRumble(GameController, LowMotor, HighMotor, length);
Update SDL2
2023-01-21 08:01:21 +01:00
Fix issue where Rumble would slow down and crash games etc If used on unsupported device eg Wheel now Rumble will automatically disable if its unsupported
2019-11-01 13:49:29 +01:00
if (Rumble == -1)
EnableRumble = 0;
Revert without mess
2019-11-01 21:48:38 +01:00
}
0.8 update
2019-04-07 07:16:19 +02:00
}
}
Change Rumble param for Device2 aswell
2019-11-02 00:13:35 +01:00
void TriggerRumbleEffectDevice2(double highfrequency, double lowfrequency, double length)
Changed all rumble to use New Rumble compared to old LeftRight
2019-10-30 07:03:50 +01:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (EnableRumbleDevice2)
Changed all rumble to use New Rumble compared to old LeftRight
2019-10-30 07:03:50 +01:00
{
DWORD minForceLow = (DWORD)(lowfrequency > 0.001 ? (configMinForce / 100.0 * 65535.0) : 0);
DWORD minForceHigh = (DWORD)(highfrequency > 0.001 ? (configMinForce / 100.0 * 65535.0) : 0);
DWORD maxForce = (DWORD)(configMaxForce / 100.0 * 65535.0);
DWORD rangeLow = maxForce - minForceLow;
DWORD rangeHigh = maxForce - minForceHigh;
DWORD LowMotor = (DWORD)(lowfrequency * rangeLow + minForceLow);
DWORD HighMotor = (DWORD)(highfrequency * rangeHigh + minForceHigh);
Update SDL2
2023-01-21 08:01:21 +01:00
if (ReverseRumbleDevice2)
Changed all rumble to use New Rumble compared to old LeftRight
2019-10-30 07:03:50 +01:00
{
Add fix for Device 2 aswell
2019-11-01 13:51:10 +01:00
int ReverseRumble2 = SDL_JoystickRumble(GameController2, HighMotor, LowMotor, length);
Update SDL2
2023-01-21 08:01:21 +01:00
Add fix for Device 2 aswell
2019-11-01 13:51:10 +01:00
if (ReverseRumble2 == -1)
Added 2nd device FFB for Outrunners
2019-12-06 12:24:06 +01:00
EnableRumbleDevice2 = 0;
Changed all rumble to use New Rumble compared to old LeftRight
2019-10-30 07:03:50 +01:00
}
else
{
Add fix for Device 2 aswell
2019-11-01 13:51:10 +01:00
int Rumble2 = SDL_JoystickRumble(GameController2, LowMotor, HighMotor, length);
Update SDL2
2023-01-21 08:01:21 +01:00
Add fix for Device 2 aswell
2019-11-01 13:51:10 +01:00
if (Rumble2 == -1)
Added 2nd device FFB for Outrunners
2019-12-06 12:24:06 +01:00
EnableRumbleDevice2 = 0;
Changed all rumble to use New Rumble compared to old LeftRight
2019-10-30 07:03:50 +01:00
}
}
}
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
void TriggerRumbleEffectDevice3(double highfrequency, double lowfrequency, double length)
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (EnableRumbleDevice3)
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
{
DWORD minForceLow = (DWORD)(lowfrequency > 0.001 ? (configMinForce / 100.0 * 65535.0) : 0);
DWORD minForceHigh = (DWORD)(highfrequency > 0.001 ? (configMinForce / 100.0 * 65535.0) : 0);
DWORD maxForce = (DWORD)(configMaxForce / 100.0 * 65535.0);
DWORD rangeLow = maxForce - minForceLow;
DWORD rangeHigh = maxForce - minForceHigh;
DWORD LowMotor = (DWORD)(lowfrequency * rangeLow + minForceLow);
DWORD HighMotor = (DWORD)(highfrequency * rangeHigh + minForceHigh);
Update SDL2
2023-01-21 08:01:21 +01:00
if (ReverseRumbleDevice3)
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
{
int ReverseRumble3 = SDL_JoystickRumble(GameController3, HighMotor, LowMotor, length);
Update SDL2
2023-01-21 08:01:21 +01:00
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
if (ReverseRumble3 == -1)
EnableRumbleDevice3 = 0;
}
else
{
int Rumble3 = SDL_JoystickRumble(GameController3, LowMotor, HighMotor, length);
Update SDL2
2023-01-21 08:01:21 +01:00
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
if (Rumble3 == -1)
EnableRumbleDevice3 = 0;
}
}
}
Update SDL2 and add rumble trigger support
2021-02-14 00:38:22 +01:00
void TriggerRumbleTriggerEffect(double lefttrigger, double righttrigger, double length)
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (EnableRumbleTriggers)
Update SDL2 and add rumble trigger support
2021-02-14 00:38:22 +01:00
{
DWORD minForceLow = (DWORD)(lefttrigger > 0.001 ? (configMinForce / 100.0 * 65535.0) : 0);
DWORD minForceHigh = (DWORD)(righttrigger > 0.001 ? (configMinForce / 100.0 * 65535.0) : 0);
DWORD maxForce = (DWORD)(configMaxForce / 100.0 * 65535.0);
DWORD rangeLow = maxForce - minForceLow;
DWORD rangeHigh = maxForce - minForceHigh;
DWORD LeftMotor = (DWORD)(lefttrigger * rangeLow + minForceLow);
DWORD RightMotor = (DWORD)(righttrigger * rangeHigh + minForceHigh);
int RumbleTriggers = SDL_JoystickRumbleTriggers(GameController, LeftMotor, RightMotor, length);
Update SDL2
2023-01-21 08:01:21 +01:00
Update SDL2 and add rumble trigger support
2021-02-14 00:38:22 +01:00
if (RumbleTriggers == -1)
EnableRumbleTriggers = 0;
}
}
0.8 update
2019-04-07 07:16:19 +02:00
void TriggerSpringEffect(double strength)
{
Revert EnableRumble
2019-10-30 06:04:22 +01:00
TriggerSpringEffectWithDefaultOption(strength, false);
0.8 update
2019-04-07 07:16:19 +02:00
}
Fix
2019-11-02 00:19:03 +01:00
int WorkaroundToFixRumble(void* ptr)
Workaround for SDL_JoystickRUmble rumble not stopping issue
2019-11-02 00:06:34 +01:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
while (SDL_WaitEvent(&e) != 0){}
Workaround for SDL_JoystickRUmble rumble not stopping issue
2019-11-02 00:06:34 +01:00
return 0;
}
Adding optional persistence to FFB Strength adjustments.
2020-06-22 01:05:49 +02:00
void WritePersistentMaxForce()
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (EnableFFBStrengthPersistence)
Changes to FFB Strength Adjustment
2020-06-25 07:19:41 +02:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (AlternativeFFB)
Adding persistence flag to disable saving strength adjustments.
2020-07-01 01:56:37 +02:00
{
WritePrivateProfileStringA("Settings", CustomAlternativeMaxForceLeft, (char*)(std::to_string(configAlternativeMaxForceLeft)).c_str(), ".\\FFBPlugin.ini");
WritePrivateProfileStringA("Settings", CustomAlternativeMaxForceRight, (char*)(std::to_string(configAlternativeMaxForceRight)).c_str(), ".\\FFBPlugin.ini");
}
else
WritePrivateProfileStringA("Settings", CustomMaxForce, (char*)(std::to_string(configMaxForce)).c_str(), ".\\FFBPlugin.ini");
Adding optional persistence to FFB Strength adjustments.
2020-06-22 01:05:49 +02:00
}
}
Fix issues with Demul
2020-08-02 01:41:11 +02:00
static int StrengthLoopWaitEvent()
Change when Thread opens for new FFB Strength Adjustment
2020-06-20 00:29:00 +02:00
{
Fix issues with Demul
2020-08-02 01:41:11 +02:00
if (!WaitForGame)
{
if (configGameId != 26)
{
Sleep(4000);
WaitForGame = true;
}
}
else
Change when Thread opens for new FFB Strength Adjustment
2020-06-20 00:29:00 +02:00
{
Fix issues with Demul
2020-08-02 01:41:11 +02:00
if (!CustomStrength)
{
CustomFFBStrengthSetup();
CustomStrength = true;
}
while (SDL_WaitEvent(&e) != 0)
Change when Thread opens for new FFB Strength Adjustment
2020-06-20 00:29:00 +02:00
{
if (e.type == SDL_JOYBUTTONDOWN)
{
if (e.jbutton.which == joystick_index1)
{
if (e.jbutton.button == IncreaseFFBStrength)
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (AlternativeFFB)
Change when Thread opens for new FFB Strength Adjustment
2020-06-20 00:29:00 +02:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (configAlternativeMaxForceRight >= 0 && configAlternativeMaxForceRight < 100)
Change when Thread opens for new FFB Strength Adjustment
2020-06-20 00:29:00 +02:00
{
configAlternativeMaxForceRight += StepFFBStrength;
configAlternativeMaxForceRight = max(0, min(100, configAlternativeMaxForceRight));
}
Update SDL2
2023-01-21 08:01:21 +01:00
if (configAlternativeMaxForceLeft <= 0 && configAlternativeMaxForceLeft > -100)
Change when Thread opens for new FFB Strength Adjustment
2020-06-20 00:29:00 +02:00
{
configAlternativeMaxForceLeft -= StepFFBStrength;
configAlternativeMaxForceLeft = max(-100, min(0, configAlternativeMaxForceLeft));
}
}
else
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (configMaxForce >= 0 && configMaxForce < 100)
Change when Thread opens for new FFB Strength Adjustment
2020-06-20 00:29:00 +02:00
{
configMaxForce += StepFFBStrength;
Fix issues with Demul
2020-08-02 01:41:11 +02:00
configMaxForce = max(0, min(100, configMaxForce));
Change when Thread opens for new FFB Strength Adjustment
2020-06-20 00:29:00 +02:00
}
}
Adding optional persistence to FFB Strength adjustments.
2020-06-22 01:05:49 +02:00
WritePersistentMaxForce();
Change when Thread opens for new FFB Strength Adjustment
2020-06-20 00:29:00 +02:00
}
if (e.jbutton.button == DecreaseFFBStrength)
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (AlternativeFFB)
Change when Thread opens for new FFB Strength Adjustment
2020-06-20 00:29:00 +02:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (configAlternativeMaxForceRight > 0 && configAlternativeMaxForceRight <= 100)
Change when Thread opens for new FFB Strength Adjustment
2020-06-20 00:29:00 +02:00
{
configAlternativeMaxForceRight -= StepFFBStrength;
configAlternativeMaxForceRight = max(0, min(100, configAlternativeMaxForceRight));
}
Update SDL2
2023-01-21 08:01:21 +01:00
if (configAlternativeMaxForceLeft < 0 && configAlternativeMaxForceLeft >= -100)
Change when Thread opens for new FFB Strength Adjustment
2020-06-20 00:29:00 +02:00
{
configAlternativeMaxForceLeft += StepFFBStrength;
configAlternativeMaxForceLeft = max(-100, min(0, configAlternativeMaxForceLeft));
}
}
else
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (configMaxForce > 0 && configMaxForce <= 100)
Change when Thread opens for new FFB Strength Adjustment
2020-06-20 00:29:00 +02:00
{
configMaxForce -= StepFFBStrength;
configMaxForce = max(0, min(100, configMaxForce));
}
}
Adding optional persistence to FFB Strength adjustments.
2020-06-22 01:05:49 +02:00
WritePersistentMaxForce();
Change when Thread opens for new FFB Strength Adjustment
2020-06-20 00:29:00 +02:00
}
if (e.jbutton.button == ResetFFBStrength)
{
Add some Persistant Value Stuff
2020-06-24 11:23:05 +02:00
DefaultConfigValues();
Adding optional persistence to FFB Strength adjustments.
2020-06-22 01:05:49 +02:00
WritePersistentMaxForce();
Change when Thread opens for new FFB Strength Adjustment
2020-06-20 00:29:00 +02:00
}
Add Text to Speech for FFB Strength Adjustment
2020-06-25 08:30:20 +02:00
Update SDL2
2023-01-21 08:01:21 +01:00
if (EnableFFBStrengthTextToSpeech)
Add Text to Speech for FFB Strength Adjustment
2020-06-25 08:30:20 +02:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (e.jbutton.button == IncreaseFFBStrength || e.jbutton.button == DecreaseFFBStrength || e.jbutton.button == ResetFFBStrength)
Add Text to Speech for FFB Strength Adjustment
2020-06-25 08:30:20 +02:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (AlternativeFFB)
Fix TTS Talking every button press
2020-07-19 01:40:08 +02:00
sprintf(FFBStrength1, "Max Force: %d", configAlternativeMaxForceRight);
else
sprintf(FFBStrength1, "Max Force: %d", configMaxForce);
Add Text to Speech for FFB Strength Adjustment
2020-06-25 08:30:20 +02:00
Fix TTS Talking every button press
2020-07-19 01:40:08 +02:00
hr = ::CoInitialize(nullptr);
hr = cpVoice.CoCreateInstance(CLSID_SpVoice);
mbstowcs(FFBStrength2, FFBStrength1, strlen(FFBStrength1) + 1);
LPWSTR ptr = FFBStrength2;
Add Text to Speech for FFB Strength Adjustment
2020-06-25 08:30:20 +02:00
Fix TTS Talking every button press
2020-07-19 01:40:08 +02:00
if (SUCCEEDED(hr))
{
hr = cpVoice->SetRate(3);
hr = cpVoice->SetOutput(NULL, TRUE);
hr = cpVoice->Speak(ptr, SPF_PURGEBEFORESPEAK, NULL);
::CoUninitialize();
}
Add Text to Speech for FFB Strength Adjustment
2020-06-25 08:30:20 +02:00
}
}
Change when Thread opens for new FFB Strength Adjustment
2020-06-20 00:29:00 +02:00
}
}
}
Fix issues with Demul
2020-08-02 01:41:11 +02:00
}
return 0;
}
static int StrengthLoopNoWaitEvent()
{
if (!WaitForGame)
{
if (configGameId != 26)
Fix lots of issues
2020-08-01 06:11:15 +02:00
{
Fix issues with Demul
2020-08-02 01:41:11 +02:00
Sleep(4000);
WaitForGame = true;
}
}
else
{
if (!CustomStrength)
{
CustomFFBStrengthSetup();
CustomStrength = true;
}
if (e.type == SDL_JOYBUTTONDOWN)
{
if (e.jbutton.which == joystick_index1)
Fix lots of issues
2020-08-01 06:11:15 +02:00
{
Fix issues with Demul
2020-08-02 01:41:11 +02:00
if (e.jbutton.button == IncreaseFFBStrength)
Fix lots of issues
2020-08-01 06:11:15 +02:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (AlternativeFFB)
Fix lots of issues
2020-08-01 06:11:15 +02:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (configAlternativeMaxForceRight >= 0 && configAlternativeMaxForceRight < 100)
Fix lots of issues
2020-08-01 06:11:15 +02:00
{
Fix issues with Demul
2020-08-02 01:41:11 +02:00
configAlternativeMaxForceRight += StepFFBStrength;
configAlternativeMaxForceRight = max(0, min(100, configAlternativeMaxForceRight));
Fix lots of issues
2020-08-01 06:11:15 +02:00
}
Update SDL2
2023-01-21 08:01:21 +01:00
if (configAlternativeMaxForceLeft <= 0 && configAlternativeMaxForceLeft > -100)
Fix lots of issues
2020-08-01 06:11:15 +02:00
{
Fix issues with Demul
2020-08-02 01:41:11 +02:00
configAlternativeMaxForceLeft -= StepFFBStrength;
configAlternativeMaxForceLeft = max(-100, min(0, configAlternativeMaxForceLeft));
}
}
else
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (configMaxForce >= 0 && configMaxForce < 100)
Fix issues with Demul
2020-08-02 01:41:11 +02:00
{
configMaxForce += StepFFBStrength;
configMaxForce = max(0, min(100, configMaxForce));
Fix lots of issues
2020-08-01 06:11:15 +02:00
}
}
Fix issues with Demul
2020-08-02 01:41:11 +02:00
WritePersistentMaxForce();
}
Fix lots of issues
2020-08-01 06:11:15 +02:00
Fix issues with Demul
2020-08-02 01:41:11 +02:00
if (e.jbutton.button == DecreaseFFBStrength)
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (AlternativeFFB)
Fix lots of issues
2020-08-01 06:11:15 +02:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (configAlternativeMaxForceRight > 0 && configAlternativeMaxForceRight <= 100)
Fix lots of issues
2020-08-01 06:11:15 +02:00
{
Fix issues with Demul
2020-08-02 01:41:11 +02:00
configAlternativeMaxForceRight -= StepFFBStrength;
configAlternativeMaxForceRight = max(0, min(100, configAlternativeMaxForceRight));
Fix lots of issues
2020-08-01 06:11:15 +02:00
}
Update SDL2
2023-01-21 08:01:21 +01:00
if (configAlternativeMaxForceLeft < 0 && configAlternativeMaxForceLeft >= -100)
Fix lots of issues
2020-08-01 06:11:15 +02:00
{
Fix issues with Demul
2020-08-02 01:41:11 +02:00
configAlternativeMaxForceLeft += StepFFBStrength;
configAlternativeMaxForceLeft = max(-100, min(0, configAlternativeMaxForceLeft));
Fix lots of issues
2020-08-01 06:11:15 +02:00
}
}
Fix issues with Demul
2020-08-02 01:41:11 +02:00
else
Fix lots of issues
2020-08-01 06:11:15 +02:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (configMaxForce > 0 && configMaxForce <= 100)
Fix issues with Demul
2020-08-02 01:41:11 +02:00
{
configMaxForce -= StepFFBStrength;
configMaxForce = max(0, min(100, configMaxForce));
}
Fix lots of issues
2020-08-01 06:11:15 +02:00
}
Fix issues with Demul
2020-08-02 01:41:11 +02:00
WritePersistentMaxForce();
}
Fix lots of issues
2020-08-01 06:11:15 +02:00
Fix issues with Demul
2020-08-02 01:41:11 +02:00
if (e.jbutton.button == ResetFFBStrength)
{
DefaultConfigValues();
WritePersistentMaxForce();
}
Update SDL2
2023-01-21 08:01:21 +01:00
if (EnableFFBStrengthTextToSpeech)
Fix issues with Demul
2020-08-02 01:41:11 +02:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (e.jbutton.button == IncreaseFFBStrength || e.jbutton.button == DecreaseFFBStrength || e.jbutton.button == ResetFFBStrength)
Fix lots of issues
2020-08-01 06:11:15 +02:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (AlternativeFFB)
Fix issues with Demul
2020-08-02 01:41:11 +02:00
sprintf(FFBStrength1, "Max Force: %d", configAlternativeMaxForceRight);
else
sprintf(FFBStrength1, "Max Force: %d", configMaxForce);
Fix lots of issues
2020-08-01 06:11:15 +02:00
Fix issues with Demul
2020-08-02 01:41:11 +02:00
hr = ::CoInitialize(nullptr);
hr = cpVoice.CoCreateInstance(CLSID_SpVoice);
mbstowcs(FFBStrength2, FFBStrength1, strlen(FFBStrength1) + 1);
LPWSTR ptr = FFBStrength2;
Fix lots of issues
2020-08-01 06:11:15 +02:00
Fix issues with Demul
2020-08-02 01:41:11 +02:00
if (SUCCEEDED(hr))
{
hr = cpVoice->SetRate(3);
hr = cpVoice->SetOutput(NULL, TRUE);
hr = cpVoice->Speak(ptr, SPF_PURGEBEFORESPEAK, NULL);
::CoUninitialize();
Fix lots of issues
2020-08-01 06:11:15 +02:00
}
}
}
}
}
Fix issues with Demul
2020-08-02 01:41:11 +02:00
}
return 0;
}
DWORD WINAPI AdjustFFBStrengthLoopWaitEvent(LPVOID lpParam)
{
while (true)
{
StrengthLoopWaitEvent();
Sleep(16);
}
}
DWORD WINAPI AdjustFFBStrengthLoopNoWaitEvent(LPVOID lpParam)
{
while (true)
{
StrengthLoopNoWaitEvent();
Change when Thread opens for new FFB Strength Adjustment
2020-06-20 00:29:00 +02:00
Sleep(16);
}
}
Flycast Output FFB Support
2023-03-02 08:39:51 +01:00
static DWORD MyGetProcessId(LPCTSTR ProcessName)
{
PROCESSENTRY32 pt;
HANDLE hsnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
pt.dwSize = sizeof(PROCESSENTRY32);
if (Process32First(hsnap, &pt)) {
do {
if (!lstrcmpi(pt.szExeFile, ProcessName)) {
CloseHandle(hsnap);
return pt.th32ProcessID;
}
} while (Process32Next(hsnap, &pt));
}
CloseHandle(hsnap);
return 0;
}
static BOOL IsProcessRunning(DWORD pid)
{
HANDLE process = OpenProcess(SYNCHRONIZE, FALSE, pid);
DWORD ret = WaitForSingleObject(process, 0);
CloseHandle(process);
return ret == WAIT_TIMEOUT;
}
Fix FFB not working on certain games
2020-07-18 05:22:37 +02:00
DWORD WINAPI FFBLoop(LPVOID lpParam)
0.8 update
2019-04-07 07:16:19 +02:00
{
Fix FFB not working on certain games
2020-07-18 05:22:37 +02:00
hlp.log("In FFBLoop");
Update SDL2 and add StartDelay option to ini files
2023-11-17 22:42:01 +01:00
if (StartDelay) //For games which need code to run quicker etc. Some games will crash if no sleep added
Fix FFB not working on certain games
2020-07-18 05:22:37 +02:00
Sleep(2500);
Update SDL2
2023-01-21 08:01:21 +01:00
Fix FFB not working on certain games
2020-07-18 05:22:37 +02:00
Initialize(0);
hlp.log("Initialize() complete");
Update SDL2
2023-01-21 08:01:21 +01:00
if (EnableRumble)
Add some Persistant Value Stuff
2020-06-24 11:23:05 +02:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (!EnableFFBStrengthDynamicAdjustment && !InputDeviceWheelEnable)
Add some Persistant Value Stuff
2020-06-24 11:23:05 +02:00
{
Daytona 3 changes etc
2023-11-19 06:27:50 +01:00
if (configGameId != 9 && configGameId != 12 && configGameId != 28 && configGameId != 29 && configGameId != 35) // Workaround for SDL_JoystickRumble rumble not stopping issue
Changes for adjusting strength
2020-07-18 11:53:35 +02:00
SDL_CreateThread(WorkaroundToFixRumble, "WorkaroundToFixRumble", (void*)NULL);
Add some Persistant Value Stuff
2020-06-24 11:23:05 +02:00
}
//SPECIAL K DISABLES RUMBLE BY DEFAULT. WRITE IT TO FALSE
char RumbleDisableChar[256];
GetPrivateProfileStringA("Input.Gamepad", "DisableRumble", "", RumbleDisableChar, 256, ".\\dxgi.ini");
std::string rumbletrue("true");
std::string rumbleTRUE("TRUE");
std::string rumbleTrue("True");
std::string rumdisable(RumbleDisableChar);
Update SDL2
2023-01-21 08:01:21 +01:00
if (rumdisable.compare(rumbletrue) == 0 || rumdisable.compare(rumbleTrue) == 0 || rumdisable.compare(rumbleTRUE) == 0)
Add some Persistant Value Stuff
2020-06-24 11:23:05 +02:00
WritePrivateProfileStringA("Input.Gamepad", "DisableRumble", "false", ".\\dxgi.ini");
}
0.8 update
2019-04-07 07:16:19 +02:00
// assign FFB effects here
t.Constant = &TriggerConstantEffect;
t.Spring = &TriggerSpringEffect;
t.Friction = &TriggerFrictionEffect;
t.Sine = &TriggerSineEffect;
Added 2nd device FFB for Outrunners
2019-12-06 12:24:06 +01:00
t.SineDevice2 = &TriggerSineEffectDevice2;
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
t.SineDevice3 = &TriggerSineEffectDevice3;
0.8 update
2019-04-07 07:16:19 +02:00
t.Rumble = &TriggerRumbleEffect;
Changed all rumble to use New Rumble compared to old LeftRight
2019-10-30 07:03:50 +01:00
t.RumbleDevice2 = &TriggerRumbleEffectDevice2;
Added bunch of shooting games and set up for 3rd device
2019-12-15 22:37:54 +01:00
t.RumbleDevice3 = &TriggerRumbleEffectDevice3;
Update SDL2 and add rumble trigger support
2021-02-14 00:38:22 +01:00
t.RumbleTriggers = &TriggerRumbleTriggerEffect;
0.8 update
2019-04-07 07:16:19 +02:00
t.LeftRight = &TriggerLeftRightEffect;
t.LeftRightDevice2 = &TriggerLeftRightDevice2Effect;
t.Springi = &TriggerSpringEffectInfinite;
updated to 0.9
2019-05-15 09:25:41 +02:00
t.Damper = &TriggerDamperEffect;
t.Inertia = &TriggerInertiaEffect;
t.Ramp = &TriggerRampEffect;
t.SawtoothUp = &TriggerSawtoothUpEffect;
t.SawtoothDown = &TriggerSawtoothDownEffect;
t.Triangle = &TriggerTriangleEffect;
0.8 update
2019-04-07 07:16:19 +02:00
Game* game;
switch (configGameId) {
case AFTER_BURNER_CLIMAX:
game = new AfterburnerClimax;
break;
case CHASE_HQ_2:
game = new ChaseHQ2;
break;
case DAYTONA_3:
game = new Daytona3;
break;
add Daytona New Season Edition
2021-12-01 05:29:59 +01:00
case DAYTONA_3_NSE:
game = new Daytona3NSE;
break;
Rename OutputReading to MAMESupermodel
2020-05-25 07:36:14 +02:00
case MAME_:
Flycast Output FFB Support
2023-03-02 08:39:51 +01:00
case SUPERMODEL_:
case FLYCAST:
Rename OutputReading to MAMESupermodel
2020-05-25 07:36:14 +02:00
game = new MAMESupermodel;
Update with output reading and fix strange bug with logging etc
2019-12-06 09:55:39 +01:00
break;
0.8 update
2019-04-07 07:16:19 +02:00
case FORD_RACING:
game = new FordRacing;
break;
updated to 0.9
2019-05-15 09:25:41 +02:00
case FORD_RACING_OTHER:
game = new FordRacingOther;
break;
Add GRID Custom and Spring to MKGP
2023-03-25 11:14:46 +01:00
case GRID_Real:
game = new GRIDReal;
Added GRID Support not using real ffb values but still works ok so far
2019-10-28 06:09:55 +01:00
break;
Added Golden Gun Rumble as requested
2019-12-20 01:59:19 +01:00
case Golden_Gun:
game = new GoldenGun;
break;
Bunch of code changes, added transformers and rambo etc
2019-12-18 01:41:02 +01:00
case Transformers_:
game = new Transformers;
break;
1.2
2019-11-14 21:36:13 +01:00
case INITIAL_D_0:
game = new InitialD0;
break;
Changes for past few weeks
2021-02-09 05:10:00 +01:00
case INITIAL_D_0_211:
game = new InitialD0v211;
break;
add ID Zero 2.30 and Flycast Dojo
2022-09-17 10:24:36 +02:00
case INITIAL_D_0_230:
game = new InitialD0v230;
break;
0.8 update
2019-04-07 07:16:19 +02:00
case INITIAL_D_4:
game = new InitialD4;
break;
case INITIAL_D_4_Japan:
game = new InitialD4Japan;
break;
case INITIAL_D_5:
game = new InitialD5;
break;
case INITIAL_D_6:
game = new InitialD6;
break;
case INITIAL_D_7:
game = new InitialD7;
break;
case INITIAL_D_8:
game = new InitialD8;
break;
case SEGA_RACING_CLASSIC:
game = new SegaRacingClassic;
break;
case SEGA_RALLY_3:
game = new SegaRally3;
break;
Add Sega Rally 3 Other
2020-05-27 11:57:10 +02:00
case SEGA_RALLY_3_Other:
game = new SegaRally3Other;
break;
0.8 update
2019-04-07 07:16:19 +02:00
case WACKY_RACES:
game = new WackyRaces;
break;
case WMMT_5:
game = new WMMT5;
break;
add WMMT5DX+
2021-08-25 13:45:47 +02:00
case WMMT_5DX:
game = new WMMT5DX;
break;
add WMMT5DX and Crazy Taxi Steam
2021-09-26 09:27:43 +02:00
case WMMT_5DXPlus:
game = new WMMT5DXPlus;
break;
Mario Kart FFB Changes etc and 2.0.0.28 version
2023-03-25 10:45:33 +01:00
case MARIO_KART_GPDX_CUSTOM:
game = new MarioKartGPDX100Custom;
0.8 update
2019-04-07 07:16:19 +02:00
break;
case OUTRUN_2Fake:
game = new OutRun2Fake;
break;
case OUTRUN_2Real:
game = new OutRun2Real;
break;
case BG4_JP:
game = new BG4JP;
break;
case MACH_STORM:
game = new Machstorm;
break;
case POKKEN_TOURNAMENT:
game = new PokkenTournament;
break;
Bunch of code changes, added transformers and rambo etc
2019-12-18 01:41:02 +01:00
case RAMBO_:
game = new Rambo;
break;
Mario Kart FFB Changes etc and 2.0.0.28 version
2023-03-25 10:45:33 +01:00
case MARIO_KART_GPDX_110_CUSTOM:
game = new MarioKartGPDX110Custom;
0.8 update
2019-04-07 07:16:19 +02:00
break;
MK 1.18 Custom
2023-03-26 11:16:12 +02:00
case MARIO_KART_GPDX_118_CUSTOM:
game = new MarioKartGPDX118Custom;
break;
Mario Kart FFB Changes etc and 2.0.0.28 version
2023-03-25 10:45:33 +01:00
case MARIO_KART_GPDX_USA_CUSTOM:
game = new MarioKartGPDXUSACustom;
Add SWDC 2018 and MK USA
2021-02-09 05:30:19 +01:00
break;
0.8 update
2019-04-07 07:16:19 +02:00
case Sonic_Sega_AllStars_Racing:
game = new SonicSegaAllStarsRacing;
break;
case M2_Emulator:
game = new M2Emulator;
break;
case Demul_Emulator:
game = new Demul;
break;
Added Aliens Extermination
2019-12-16 06:55:50 +01:00
case ALIENS_EXTERMINATION:
game = new AliensExtermination;
break;
0.8 update
2019-04-07 07:16:19 +02:00
case GTI_Club_3:
game = new GTIClub3;
break;
Cleaned up some stuff Removed seperate cpp files etc for 32bit and 64bit for Mame & Button Rumble
2019-10-26 04:46:16 +02:00
case Button_Rumble:
game = new ButtonRumble;
0.8 update
2019-04-07 07:16:19 +02:00
break;
case Road_Fighters_3D:
game = new RoadFighters3D;
break;
case LGI_3D:
game = new LGI3D;
break;
case LGI_:
game = new LGI;
break;
Added KO Drive
2019-09-14 02:29:00 +02:00
case KO_Drive:
game = new KODrive;
break;
Added HOTD4 Disabled for now as it has some serious lag for some reason
2019-10-26 22:57:33 +02:00
case HOTD_4:
game = new HOTD4;
break;
Add Dirty Drivin
2019-12-22 22:41:31 +01:00
case Dirty_Drivin:
game = new DirtyDrivin;
break;
Added H2Overdrive
2019-12-24 23:33:42 +01:00
case H2_Overdrive:
game = new H2Overdrive;
break;
Added SnoCross
2020-01-09 00:42:33 +01:00
case Sno_Cross:
game = new SnoCross;
break;
Added Batman
2020-03-13 23:05:19 +01:00
case Bat_man:
game = new Batman;
break;
Add R-Tuned Support
2020-05-19 01:14:34 +02:00
case R_Tuned:
game = new RTuned;
break;
Add SWDC 2018 and MK USA
2021-02-09 05:30:19 +01:00
case SWDC_2018:
game = new SWDC;
break;
Add WMMT6 and WMMT6R FFB Support
2021-02-19 23:44:55 +01:00
case WMMT_6:
game = new WMMT6;
break;
case WMMT_6_R:
game = new WMMT6R;
break;
Storm Racer G
2021-04-17 00:31:12 +02:00
case SRG:
game = new StormRacerG;
break;
Add D1GP Support
2021-05-20 08:20:30 +02:00
case D1_GP:
game = new D1GP;
break;
add WMMT5DX and Crazy Taxi Steam
2021-09-26 09:27:43 +02:00
case Crazy_Taxi:
game = new CrazyTaxi;
break;
add Dead Heat and WMMT3
2022-06-08 07:06:23 +02:00
case WMMT_3:
game = new WMMT3;
break;
case DEAD_HEAT:
game = new DeadHeat;
break;
add Dead Heat Riders
2022-06-09 07:25:54 +02:00
case DEAD_HEAT_RIDERS:
game = new DeadHeatRiders;
break;
Add FFB to Gaelco games
2022-06-10 12:41:25 +02:00
case GAELCO_TUNING_RACE:
game = new GaelcoTuningRace;
break;
case TOKYO_COP:
game = new TokyoCop;
break;
case RING_RIDERS:
game = new RingRiders;
break;
Mario Kart FFB Changes etc and 2.0.0.28 version
2023-03-25 10:45:33 +01:00
case MARIO_KART_GPDX_118_REAL:
game = new MarioKartGPDX118Real;
break;
case MARIO_KART_GPDX_110_REAL:
game = new MarioKartGPDX110Real;
break;
case MARIO_KART_GPDX_USA_REAL:
game = new MarioKartGPDXUSAReal;
break;
Add GRID Custom and Spring to MKGP
2023-03-25 11:14:46 +01:00
case GRID_Custom:
game = new GRIDCustom;
break;
add Showdown
2023-08-26 08:07:18 +02:00
case SEGA_SHOWDOWN:
game = new Showdown;
break;
Add Spring Effect
2023-08-26 08:36:41 +02:00
case SPRING_EFFECT:
game = new SpringEffect;
break;
push Arctic Thunder code i never added
2024-03-20 02:02:55 +01:00
case ARCTIC_THUNDER:
game = new ArcticThunder;
break;
FnF Added
2024-04-07 11:59:56 +02:00
case CRUISN_BLAST:
game = new CruisnBlast;
break;
case FNF:
game = new FnF;
break;
case FNF_DRIFT:
game = new FnFDrift;
break;
case FNF_SUPERCARS:
game = new FnFSuperCars;
break;
case SEGA_RACE_TV:
game = new SegaRaceTV;
break;
Added Hummer Extreme
2024-07-07 11:38:58 +02:00
case HUMMER_EXTREME:
game = new HummerExtreme;
break;
0.8 update
2019-04-07 07:16:19 +02:00
case TEST_GAME_CONST:
case TEST_GAME_FRICTION:
case TEST_GAME_SINE:
case TEST_GAME_SPRING:
case TEST_GAME_HEAVY:
case TEST_GAME_LOOSE:
updated to 0.9
2019-05-15 09:25:41 +02:00
case TEST_GAME_RUMBLE:
0.8 update
2019-04-07 07:16:19 +02:00
game = new TestGame;
break;
default:
game = 0;
}
hlp.log("Setting DefaultCentering & DefaultFriction forces...");
if (configDefaultCentering >= 0 && configDefaultCentering <= 100) {
TriggerSpringEffectWithDefaultOption(configDefaultCentering / 100.0, true);
}
if (configDefaultFriction >= 0 && configDefaultFriction <= 100) {
TriggerFrictionEffectWithDefaultOption(configDefaultFriction / 100.0, true);
}
Fix FFB not working on certain games
2020-07-18 05:22:37 +02:00
if (EnableFFBStrengthDynamicAdjustment == 1)
{
Daytona 3 changes etc
2023-11-19 06:27:50 +01:00
if (configGameId != 9 && configGameId != 12 && configGameId != 28 && configGameId != 29 && configGameId != 35)
Fix issues with Demul
2020-08-02 01:41:11 +02:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (configGameId == 26 && InputDeviceWheelEnable)
Fix Demul WaitEvent Issue
2020-08-02 11:03:46 +02:00
CreateThread(NULL, 0, AdjustFFBStrengthLoopNoWaitEvent, NULL, 0, NULL);
Fix issues with Demul
2020-08-02 01:41:11 +02:00
else
Fix Demul WaitEvent Issue
2020-08-02 11:03:46 +02:00
CreateThread(NULL, 0, AdjustFFBStrengthLoopWaitEvent, NULL, 0, NULL);
}
else
CreateThread(NULL, 0, AdjustFFBStrengthLoopNoWaitEvent, NULL, 0, NULL);
Fix FFB not working on certain games
2020-07-18 05:22:37 +02:00
}
0.8 update
2019-04-07 07:16:19 +02:00
hlp.log("Entering Game's FFBLoop loop");
bool* kr = (bool*)lpParam;
while (*kr)
{
updated to 0.9
2019-05-15 09:25:41 +02:00
if (game != 0)
{
game->FFBLoop(&effectConst, &hlp, &t);
Sleep(16);
Fix
2019-10-30 06:14:51 +01:00
}
0.8 update
2019-04-07 07:16:19 +02:00
}
hlp.log("about to exit FFBLoop");
return 0;
}
void CreateFFBLoopThread()
{
hlp.log("Before CreateThread");
CreateThread(NULL, 0, FFBLoop, (LPVOID)&keepRunning, 0, NULL);
hlp.log("After CreateThread");
}
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ulReasonForCall, LPVOID lpReserved)
{
BOOL result = TRUE;
hlp.enableLogging = enableLogging;
char buff[MAX_PATH];
hlp.log("DLLMAIN ENTERED");
GetModuleFileNameA(NULL, buff, MAX_PATH);
std::string processName = std::string(buff);
hlp.log("process name:");
Fix
2019-10-30 06:14:51 +01:00
hlp.log((char*)processName.c_str());
0.8 update
2019-04-07 07:16:19 +02:00
hlp.log("default centering & friction values:");
hlp.logInt(configDefaultCentering);
hlp.logInt(configDefaultFriction);
switch (ulReasonForCall)
{
case DLL_PROCESS_ATTACH:
// log, etc.
hlp.log("dll process attach:");
Fix
2019-10-30 06:14:51 +01:00
hlp.log((char*)processName.c_str());
hlp.log((char*)(std::to_string(configMinForce)).c_str());
hlp.log((char*)(std::to_string(configMaxForce)).c_str());
0.8 update
2019-04-07 07:16:19 +02:00
DisableThreadLibraryCalls(hModule);
hlp.log("loading original library...");
GetPrivateProfileStringA("Settings", "ChainLoad", "", chainedDLL, 256, ".\\FFBplugin.ini");
if (0 == strlen(chainedDLL))
{
char buffer[MAX_PATH];
GetSystemDirectoryA(buffer, MAX_PATH);
char libName[256];
GetModuleFileNameA(hModule, libName, 256);
_strupr(libName);
Launch Outputs Thread quicker on games requiring it
2023-11-25 09:46:09 +01:00
0.8 update
2019-04-07 07:16:19 +02:00
if (NULL != strstr(libName, "DINPUT8"))
{
currentLibrary = lib::dinput8;
strcat_s(buffer, MAX_PATH, "\\dinput8.dll");
}
else if (NULL != strstr(libName, "DINPUT"))
{
currentLibrary = lib::dinput;
strcat_s(buffer, MAX_PATH, "\\dinput.dll");
}
Launch Outputs Thread quicker on games requiring it
2023-11-25 09:46:09 +01:00
else if (NULL != strstr(libName, "D3D11"))
0.8 update
2019-04-07 07:16:19 +02:00
{
currentLibrary = lib::d3d11;
strcat_s(buffer, MAX_PATH, "\\d3d11.dll");
}
Launch Outputs Thread quicker on games requiring it
2023-11-25 09:46:09 +01:00
else if (NULL != strstr(libName, "XINPUT1_3"))
0.8 update
2019-04-07 07:16:19 +02:00
{
currentLibrary = lib::xinput1_3;
strcat_s(buffer, MAX_PATH, "\\xinput1_3.dll");
}
Launch Outputs Thread quicker on games requiring it
2023-11-25 09:46:09 +01:00
else if (NULL != strstr(libName, "XINPUT1_4"))
add xinput1_4 as option and update version
2023-03-15 07:48:04 +01:00
{
currentLibrary = lib::xinput1_3;
strcat_s(buffer, MAX_PATH, "\\xinput1_4.dll");
}
Launch Outputs Thread quicker on games requiring it
2023-11-25 09:46:09 +01:00
else if (NULL != strstr(libName, "OPENGL32"))
0.8 update
2019-04-07 07:16:19 +02:00
{
currentLibrary = lib::opengl32;
strcat_s(buffer, MAX_PATH, "\\opengl32.dll");
}
Launch Outputs Thread quicker on games requiring it
2023-11-25 09:46:09 +01:00
else if (NULL != strstr(libName, "D3D9"))
0.8 update
2019-04-07 07:16:19 +02:00
{
currentLibrary = lib::d3d9;
strcat_s(buffer, MAX_PATH, "\\d3d9.dll");
}
Launch Outputs Thread quicker on games requiring it
2023-11-25 09:46:09 +01:00
else if (NULL != strstr(libName, "WINMM"))
0.8 update
2019-04-07 07:16:19 +02:00
{
currentLibrary = lib::winmm;
strcat_s(buffer, MAX_PATH, "\\winmm.dll");
Launch Outputs Thread quicker on games requiring it
2023-11-25 09:46:09 +01:00
}
0.8 update
2019-04-07 07:16:19 +02:00
hlp.log(buffer);
Launch Outputs Thread quicker on games requiring it
2023-11-25 09:46:09 +01:00
0.8 update
2019-04-07 07:16:19 +02:00
gl_hOriginalDll = LoadLibraryA(buffer);
Launch Outputs Thread quicker on games requiring it
2023-11-25 09:46:09 +01:00
if (configGameId == 22 || configGameId == 34 || configGameId == 60)
CreateThread(NULL, 0, ThreadForOutputs, NULL, 0, NULL);
Add Sega Rally 3 Other
2020-05-27 11:57:10 +02:00
if (configGameId == 47)
MEMwrite((void*)(0x57B2F0), (void*)"\x33\xC0\x40\xC3", 4);
Launch Outputs Thread quicker on games requiring it
2023-11-25 09:46:09 +01:00
0.8 update
2019-04-07 07:16:19 +02:00
if (configGameId == 29)
{
gl_hjgtDll = LoadLibraryA("jgt.dll");
gl_hlibavs = LoadLibraryA("libavs-win32-ea3.dll");
}
Launch Outputs Thread quicker on games requiring it
2023-11-25 09:46:09 +01:00
if (configGameId == 4 || configGameId == 37)
Modified HOTD4 & Updated ToolSet
2019-10-27 03:03:02 +01:00
gl_cgGLDll = LoadLibraryA("cgGL.dll");
0.8 update
2019-04-07 07:16:19 +02:00
}
else
{
hlp.log(chainedDLL);
gl_hOriginalDll = LoadLibraryA(chainedDLL);
// e.g. ChainLoad = dinput8-old.dll (if we need to intercept another dinput8.dll file).
}
if (!gl_hOriginalDll)
{
hlp.log("library load process failed");
ExitProcess(0);
}
else {
hlp.log("library loaded");
}
if (currentLibrary == lib::dinput8)
{
originalDirectInputDirectInput8Create = (pfnDirectInputDirectInput8Create)GetProcAddress(gl_hOriginalDll, "DirectInput8Create");
originalDirectInputDllRegisterServer = (pfnDirectInputDllRegisterServer)GetProcAddress(gl_hOriginalDll, "DllRegisterServer");
originalDirectInputDllUnregisterServer = (pfnDirectInputDllUnregisterServer)GetProcAddress(gl_hOriginalDll, "DllUnregisterServer");
originalDirectInputDllCanUnloadNow = (pfnDirectInputDllCanUnloadNow)GetProcAddress(gl_hOriginalDll, "DllCanUnloadNow");
originalDirectInputDllGetClassObject = (pfnDirectInputDllGetClassObject)GetProcAddress(gl_hOriginalDll, "DllGetClassObject");
originalGetdfDIJoystick = (pfnDirectInputGetdfDIJoystick)GetProcAddress(gl_hOriginalDll, "GetdfDIJoystick");
}
if (currentLibrary == lib::dinput)
{
originalDirectInputDllRegisterServer = (pfnDirectInputDllRegisterServer)GetProcAddress(gl_hOriginalDll, "DllRegisterServer");
originalDirectInputDllUnregisterServer = (pfnDirectInputDllUnregisterServer)GetProcAddress(gl_hOriginalDll, "DllUnregisterServer");
originalDirectInputDllCanUnloadNow = (pfnDirectInputDllCanUnloadNow)GetProcAddress(gl_hOriginalDll, "DllCanUnloadNow");
originalDirectInputDllGetClassObject = (pfnDirectInputDllGetClassObject)GetProcAddress(gl_hOriginalDll, "DllGetClassObject");
originalDirectInputDirectInputCreateA = (pfnDirectInputDirectInputCreateA)GetProcAddress(gl_hOriginalDll, "DirectInputCreateA");
originalDirectInputDirectInputCreateW = (pfnDirectInputDirectInputCreateW)GetProcAddress(gl_hOriginalDll, "DirectInputCreateW");
originalDirectInputDirectInputCreateEx = (pfnDirectInputDirectInputCreateEx)GetProcAddress(gl_hOriginalDll, "DirectInputCreateEx");
}
if (currentLibrary == lib::d3d11)
{
originalCreateDirect3D11DeviceFromDXGIDevice = GetProcAddress(gl_hOriginalDll, "CreateDirect3D11DeviceFromDXGIDevice");
originalCreateDirect3D11SurfaceFromDXGISurface = GetProcAddress(gl_hOriginalDll, "CreateDirect3D11SurfaceFromDXGISurface");
originalD3D11CoreCreateDevice = GetProcAddress(gl_hOriginalDll, "D3D11CoreCreateDevice");
originalD3D11CoreCreateLayeredDevice = GetProcAddress(gl_hOriginalDll, "D3D11CoreCreateLayeredDevice");
originalD3D11CoreGetLayeredDeviceSize = GetProcAddress(gl_hOriginalDll, "D3D11CoreGetLayeredDeviceSize");
originalD3D11CoreRegisterLayers = GetProcAddress(gl_hOriginalDll, "D3D11CoreRegisterLayers");
originalD3D11CreateDevice = GetProcAddress(gl_hOriginalDll, "D3D11CreateDevice");
originalD3D11CreateDeviceAndSwapChain = GetProcAddress(gl_hOriginalDll, "D3D11CreateDeviceAndSwapChain");
originalD3D11CreateDeviceForD3D12 = GetProcAddress(gl_hOriginalDll, "D3D11CreateDeviceForD3D12");
originalD3D11On12CreateDevice = GetProcAddress(gl_hOriginalDll, "D3D11On12CreateDevice");
originalD3DKMTCloseAdapter = GetProcAddress(gl_hOriginalDll, "D3DKMTCloseAdapter");
originalD3DKMTCreateAllocation = GetProcAddress(gl_hOriginalDll, "D3DKMTCreateAllocation");
originalD3DKMTCreateContext = GetProcAddress(gl_hOriginalDll, "D3DKMTCreateContext");
originalD3DKMTCreateDevice = GetProcAddress(gl_hOriginalDll, "D3DKMTCreateDevice");
originalD3DKMTCreateSynchronizationObject = GetProcAddress(gl_hOriginalDll, "D3DKMTCreateSynchronizationObject");
originalD3DKMTDestroyAllocation = GetProcAddress(gl_hOriginalDll, "D3DKMTDestroyAllocation");
originalD3DKMTDestroyContext = GetProcAddress(gl_hOriginalDll, "D3DKMTDestroyContext");
originalD3DKMTDestroyDevice = GetProcAddress(gl_hOriginalDll, "D3DKMTDestroyDevice");
originalD3DKMTDestroySynchronizationObject = GetProcAddress(gl_hOriginalDll, "D3DKMTDestroySynchronizationObject");
originalD3DKMTEscape = GetProcAddress(gl_hOriginalDll, "D3DKMTEscape");
originalD3DKMTGetContextSchedulingPriority = GetProcAddress(gl_hOriginalDll, "D3DKMTGetContextSchedulingPriority");
originalD3DKMTGetDeviceState = GetProcAddress(gl_hOriginalDll, "D3DKMTGetDeviceState");
originalD3DKMTGetDisplayModeList = GetProcAddress(gl_hOriginalDll, "D3DKMTGetDisplayModeList");
originalD3DKMTGetMultisampleMethodList = GetProcAddress(gl_hOriginalDll, "D3DKMTGetMultisampleMethodList");
originalD3DKMTGetRuntimeData = GetProcAddress(gl_hOriginalDll, "D3DKMTGetRuntimeData");
originalD3DKMTGetSharedPrimaryHandle = GetProcAddress(gl_hOriginalDll, "D3DKMTGetSharedPrimaryHandle");
originalD3DKMTLock = GetProcAddress(gl_hOriginalDll, "D3DKMTLock");
originalD3DKMTOpenAdapterFromHdc = GetProcAddress(gl_hOriginalDll, "D3DKMTOpenAdapterFromHdc");
originalD3DKMTOpenResource = GetProcAddress(gl_hOriginalDll, "D3DKMTOpenResource");
originalD3DKMTPresent = GetProcAddress(gl_hOriginalDll, "D3DKMTPresent");
originalD3DKMTQueryAdapterInfo = GetProcAddress(gl_hOriginalDll, "D3DKMTQueryAdapterInfo");
originalD3DKMTQueryAllocationResidency = GetProcAddress(gl_hOriginalDll, "D3DKMTQueryAllocationResidency");
originalD3DKMTQueryResourceInfo = GetProcAddress(gl_hOriginalDll, "D3DKMTQueryResourceInfo");
originalD3DKMTRender = GetProcAddress(gl_hOriginalDll, "D3DKMTRender");
originalD3DKMTSetAllocationPriority = GetProcAddress(gl_hOriginalDll, "D3DKMTSetAllocationPriority");
originalD3DKMTSetContextSchedulingPriority = GetProcAddress(gl_hOriginalDll, "D3DKMTSetContextSchedulingPriority");
originalD3DKMTSetDisplayMode = GetProcAddress(gl_hOriginalDll, "D3DKMTSetDisplayMode");
originalD3DKMTSetDisplayPrivateDriverFormat = GetProcAddress(gl_hOriginalDll, "D3DKMTSetDisplayPrivateDriverFormat");
originalD3DKMTSetGammaRamp = GetProcAddress(gl_hOriginalDll, "D3DKMTSetGammaRamp");
originalD3DKMTSetVidPnSourceOwner = GetProcAddress(gl_hOriginalDll, "D3DKMTSetVidPnSourceOwner");
originalD3DKMTSignalSynchronizationObject = GetProcAddress(gl_hOriginalDll, "D3DKMTSignalSynchronizationObject");
originalD3DKMTUnlock = GetProcAddress(gl_hOriginalDll, "D3DKMTUnlock");
originalD3DKMTWaitForSynchronizationObject = GetProcAddress(gl_hOriginalDll, "D3DKMTWaitForSynchronizationObject");
originalD3DKMTWaitForVerticalBlankEvent = GetProcAddress(gl_hOriginalDll, "D3DKMTWaitForVerticalBlankEvent");
originalD3DPerformance_BeginEvent = GetProcAddress(gl_hOriginalDll, "D3DPerformance_BeginEvent");
originalD3DPerformance_EndEvent = GetProcAddress(gl_hOriginalDll, "D3DPerformance_EndEvent");
originalD3DPerformance_GetStatus = GetProcAddress(gl_hOriginalDll, "D3DPerformance_GetStatus");
originalD3DPerformance_SetMarker = GetProcAddress(gl_hOriginalDll, "D3DPerformance_SetMarker");
originalEnableFeatureLevelUpgrade = GetProcAddress(gl_hOriginalDll, "EnableFeatureLevelUpgrade");
originalOpenAdapter10 = GetProcAddress(gl_hOriginalDll, "OpenAdapter10");
originalOpenAdapter10_2 = GetProcAddress(gl_hOriginalDll, "OpenAdapter10_2");
}
if (currentLibrary == lib::xinput1_3)
{
originalXInputGetState = GetProcAddress(gl_hOriginalDll, "XInputGetState");
originalXInputSetState = GetProcAddress(gl_hOriginalDll, "XInputSetState");
originalXInputGetCapabilities = GetProcAddress(gl_hOriginalDll, "XInputGetCapabilities");
originalXInputEnable = GetProcAddress(gl_hOriginalDll, "XInputEnable");
originalXInputGetDSoundAudioDeviceGuids = GetProcAddress(gl_hOriginalDll, "XInputGetDSoundAudioDeviceGuids");
originalXInputGetBatteryInformation = GetProcAddress(gl_hOriginalDll, "XInputGetBatteryInformation");
originalXInputGetKeystroke = GetProcAddress(gl_hOriginalDll, "XInputGetKeystroke");
originalXInputGetStateEx = GetProcAddress(gl_hOriginalDll, MAKEINTRESOURCEA(100));
originalXInputWaitForGuideButton = GetProcAddress(gl_hOriginalDll, MAKEINTRESOURCEA(101));
originalXInputCancelGuideButtonWait = GetProcAddress(gl_hOriginalDll, MAKEINTRESOURCEA(102));
originalXInputPowerOffController = GetProcAddress(gl_hOriginalDll, MAKEINTRESOURCEA(103));
}
if (currentLibrary == lib::d3d9)
Fix
2019-10-30 06:14:51 +01:00
{
0.8 update
2019-04-07 07:16:19 +02:00
originalDirect3DShaderValidatorCreate9 = GetProcAddress(gl_hOriginalDll, "Direct3DShaderValidatorCreate9");
originalPSGPError = GetProcAddress(gl_hOriginalDll, "PSGPError");
originalPSGPSampleTexture = GetProcAddress(gl_hOriginalDll, "PSGPSampleTexture");
originalD3DPERF_BeginEvent = GetProcAddress(gl_hOriginalDll, "D3DPERF_BeginEvent");
originalD3DPERF_EndEvent = GetProcAddress(gl_hOriginalDll, "D3DPERF_EndEvent");
originalD3DPERF_GetStatus = GetProcAddress(gl_hOriginalDll, "D3DPERF_GetStatus");
originalD3DPERF_QueryRepeatFrame = GetProcAddress(gl_hOriginalDll, "D3DPERF_QueryRepeatFrame");
originalD3DPERF_SetMarker = GetProcAddress(gl_hOriginalDll, "D3DPERF_SetMarker");
originalD3DPERF_SetOptions = GetProcAddress(gl_hOriginalDll, "D3DPERF_SetOptions");
originalD3DPERF_SetRegion = GetProcAddress(gl_hOriginalDll, "D3DPERF_SetRegion");
originalDebugSetLevel = GetProcAddress(gl_hOriginalDll, "DebugSetLevel");
originalDebugSetMute = GetProcAddress(gl_hOriginalDll, "DebugSetMute");
originalDirect3D9EnableMaximizedWindowedModeShim = GetProcAddress(gl_hOriginalDll, "Direct3D9EnableMaximizedWindowedModeShim");
originalDirect3DCreate9 = GetProcAddress(gl_hOriginalDll, "Direct3DCreate9");
Fix
2019-10-30 06:14:51 +01:00
originalDirect3DCreate9Ex = GetProcAddress(gl_hOriginalDll, "Direct3DCreate9Ex");
0.8 update
2019-04-07 07:16:19 +02:00
}
if (currentLibrary == lib::opengl32)
{
originalwglUseFontOutlinesA = GetProcAddress(gl_hOriginalDll, "wglUseFontOutlinesA");
originalwglUseFontOutlinesW = GetProcAddress(gl_hOriginalDll, "wglUseFontOutlinesW");
originalwglDescribeLayerPlane = GetProcAddress(gl_hOriginalDll, "wglDescribeLayerPlane");
originalwglSetLayerPaletteEntries = GetProcAddress(gl_hOriginalDll, "wglSetLayerPaletteEntries");
originalwglGetLayerPaletteEntries = GetProcAddress(gl_hOriginalDll, "wglGetLayerPaletteEntries");
originalwglRealizeLayerPalette = GetProcAddress(gl_hOriginalDll, "wglRealizeLayerPalette");
originalwglSwapLayerBuffers = GetProcAddress(gl_hOriginalDll, "wglSwapLayerBuffers");
originalwglMakeCurrent = GetProcAddress(gl_hOriginalDll, "wglMakeCurrent");
originalGlmfInitPlayback = GetProcAddress(gl_hOriginalDll, "GlmfInitPlayback");
originalGlmfBeginGlsBlock = GetProcAddress(gl_hOriginalDll, "GlmfBeginGlsBlock");
originalGlmfPlayGlsRecord = GetProcAddress(gl_hOriginalDll, "GlmfPlayGlsRecord");
originalGlmfEndGlsBlock = GetProcAddress(gl_hOriginalDll, "GlmfEndGlsBlock");
originalGlmfEndPlayback = GetProcAddress(gl_hOriginalDll, "GlmfEndPlayback");
originalGlmfCloseMetaFile = GetProcAddress(gl_hOriginalDll, "GlmfCloseMetaFile");
originalwglSwapMultipleBuffers = GetProcAddress(gl_hOriginalDll, "wglSwapMultipleBuffers");
originalwglCreateLayerContext = GetProcAddress(gl_hOriginalDll, "wglCreateLayerContext");
originalwglCreateContext = GetProcAddress(gl_hOriginalDll, "wglCreateContext");
originalwglDeleteContext = GetProcAddress(gl_hOriginalDll, "wglDeleteContext");
originalwglGetCurrentContext = GetProcAddress(gl_hOriginalDll, "wglGetCurrentContext");
originalwglGetCurrentDC = GetProcAddress(gl_hOriginalDll, "wglGetCurrentDC");
originalwglUseFontBitmapsA = GetProcAddress(gl_hOriginalDll, "wglUseFontBitmapsA");
originalwglUseFontBitmapsW = GetProcAddress(gl_hOriginalDll, "wglUseFontBitmapsW");
originalwglShareLists = GetProcAddress(gl_hOriginalDll, "wglShareLists");
originalwglGetDefaultProcAddress = GetProcAddress(gl_hOriginalDll, "wglGetDefaultProcAddress");
originalwglGetProcAddress = GetProcAddress(gl_hOriginalDll, "wglGetProcAddress");
originalwglCopyContext = GetProcAddress(gl_hOriginalDll, "wglCopyContext");
originalglDebugEntry = GetProcAddress(gl_hOriginalDll, "glDebugEntry");
originalwglGetPixelFormat = GetProcAddress(gl_hOriginalDll, "wglGetPixelFormat");
originalwglSetPixelFormat = GetProcAddress(gl_hOriginalDll, "wglSetPixelFormat");
originalwglChoosePixelFormat = GetProcAddress(gl_hOriginalDll, "wglChoosePixelFormat");
originalwglDescribePixelFormat = GetProcAddress(gl_hOriginalDll, "wglDescribePixelFormat");
originalwglSwapBuffers = GetProcAddress(gl_hOriginalDll, "wglSwapBuffers");
originalglCallList = GetProcAddress(gl_hOriginalDll, "glCallList");
originalglCallLists = GetProcAddress(gl_hOriginalDll, "glCallLists");
originalglBegin = GetProcAddress(gl_hOriginalDll, "glBegin");
originalglColor3b = GetProcAddress(gl_hOriginalDll, "glColor3b");
originalglColor3bv = GetProcAddress(gl_hOriginalDll, "glColor3bv");
originalglColor3d = GetProcAddress(gl_hOriginalDll, "glColor3d");
originalglColor3dv = GetProcAddress(gl_hOriginalDll, "glColor3dv");
originalglColor3f = GetProcAddress(gl_hOriginalDll, "glColor3f");
originalglColor3fv = GetProcAddress(gl_hOriginalDll, "glColor3fv");
originalglColor3i = GetProcAddress(gl_hOriginalDll, "glColor3i");
originalglColor3iv = GetProcAddress(gl_hOriginalDll, "glColor3iv");
originalglColor3s = GetProcAddress(gl_hOriginalDll, "glColor3s");
originalglColor3sv = GetProcAddress(gl_hOriginalDll, "glColor3sv");
originalglColor3ub = GetProcAddress(gl_hOriginalDll, "glColor3ub");
originalglColor3ubv = GetProcAddress(gl_hOriginalDll, "glColor3ubv");
originalglColor3ui = GetProcAddress(gl_hOriginalDll, "glColor3ui");
originalglColor3uiv = GetProcAddress(gl_hOriginalDll, "glColor3uiv");
originalglColor3us = GetProcAddress(gl_hOriginalDll, "glColor3us");
originalglColor3usv = GetProcAddress(gl_hOriginalDll, "glColor3usv");
originalglColor4b = GetProcAddress(gl_hOriginalDll, "glColor4b");
originalglColor4bv = GetProcAddress(gl_hOriginalDll, "glColor4bv");
originalglColor4d = GetProcAddress(gl_hOriginalDll, "glColor4d");
originalglColor4dv = GetProcAddress(gl_hOriginalDll, "glColor4dv");
originalglColor4f = GetProcAddress(gl_hOriginalDll, "glColor4f");
originalglColor4fv = GetProcAddress(gl_hOriginalDll, "glColor4fv");
originalglColor4i = GetProcAddress(gl_hOriginalDll, "glColor4i");
originalglColor4iv = GetProcAddress(gl_hOriginalDll, "glColor4iv");
originalglColor4s = GetProcAddress(gl_hOriginalDll, "glColor4s");
originalglColor4sv = GetProcAddress(gl_hOriginalDll, "glColor4sv");
originalglColor4ub = GetProcAddress(gl_hOriginalDll, "glColor4ub");
originalglColor4ubv = GetProcAddress(gl_hOriginalDll, "glColor4ubv");
originalglColor4ui = GetProcAddress(gl_hOriginalDll, "glColor4ui");
originalglColor4uiv = GetProcAddress(gl_hOriginalDll, "glColor4uiv");
originalglColor4us = GetProcAddress(gl_hOriginalDll, "glColor4us");
originalglColor4usv = GetProcAddress(gl_hOriginalDll, "glColor4usv");
originalglEdgeFlag = GetProcAddress(gl_hOriginalDll, "glEdgeFlag");
originalglEdgeFlagv = GetProcAddress(gl_hOriginalDll, "glEdgeFlagv");
originalglEnd = GetProcAddress(gl_hOriginalDll, "glEnd");
originalglIndexd = GetProcAddress(gl_hOriginalDll, "glIndexd");
originalglIndexdv = GetProcAddress(gl_hOriginalDll, "glIndexdv");
originalglIndexf = GetProcAddress(gl_hOriginalDll, "glIndexf");
originalglIndexfv = GetProcAddress(gl_hOriginalDll, "glIndexfv");
originalglIndexi = GetProcAddress(gl_hOriginalDll, "glIndexi");
originalglIndexiv = GetProcAddress(gl_hOriginalDll, "glIndexiv");
originalglIndexs = GetProcAddress(gl_hOriginalDll, "glIndexs");
originalglIndexsv = GetProcAddress(gl_hOriginalDll, "glIndexsv");
originalglNormal3b = GetProcAddress(gl_hOriginalDll, "glNormal3b");
originalglNormal3bv = GetProcAddress(gl_hOriginalDll, "glNormal3bv");
originalglNormal3d = GetProcAddress(gl_hOriginalDll, "glNormal3d");
originalglNormal3dv = GetProcAddress(gl_hOriginalDll, "glNormal3dv");
originalglNormal3f = GetProcAddress(gl_hOriginalDll, "glNormal3f");
originalglNormal3fv = GetProcAddress(gl_hOriginalDll, "glNormal3fv");
originalglNormal3i = GetProcAddress(gl_hOriginalDll, "glNormal3i");
originalglNormal3iv = GetProcAddress(gl_hOriginalDll, "glNormal3iv");
originalglNormal3s = GetProcAddress(gl_hOriginalDll, "glNormal3s");
originalglNormal3sv = GetProcAddress(gl_hOriginalDll, "glNormal3sv");
originalglTexCoord1d = GetProcAddress(gl_hOriginalDll, "glTexCoord1d");
originalglTexCoord1dv = GetProcAddress(gl_hOriginalDll, "glTexCoord1dv");
originalglTexCoord1f = GetProcAddress(gl_hOriginalDll, "glTexCoord1f");
originalglTexCoord1fv = GetProcAddress(gl_hOriginalDll, "glTexCoord1fv");
originalglTexCoord1i = GetProcAddress(gl_hOriginalDll, "glTexCoord1i");
originalglTexCoord1iv = GetProcAddress(gl_hOriginalDll, "glTexCoord1iv");
originalglTexCoord1s = GetProcAddress(gl_hOriginalDll, "glTexCoord1s");
originalglTexCoord1sv = GetProcAddress(gl_hOriginalDll, "glTexCoord1sv");
originalglTexCoord2d = GetProcAddress(gl_hOriginalDll, "glTexCoord2d");
originalglTexCoord2dv = GetProcAddress(gl_hOriginalDll, "glTexCoord2dv");
originalglTexCoord2f = GetProcAddress(gl_hOriginalDll, "glTexCoord2f");
originalglTexCoord2fv = GetProcAddress(gl_hOriginalDll, "glTexCoord2fv");
originalglTexCoord2i = GetProcAddress(gl_hOriginalDll, "glTexCoord2i");
originalglTexCoord2iv = GetProcAddress(gl_hOriginalDll, "glTexCoord2iv");
originalglTexCoord2s = GetProcAddress(gl_hOriginalDll, "glTexCoord2s");
originalglTexCoord2sv = GetProcAddress(gl_hOriginalDll, "glTexCoord2sv");
originalglTexCoord3d = GetProcAddress(gl_hOriginalDll, "glTexCoord3d");
originalglTexCoord3dv = GetProcAddress(gl_hOriginalDll, "glTexCoord3dv");
originalglTexCoord3f = GetProcAddress(gl_hOriginalDll, "glTexCoord3f");
originalglTexCoord3fv = GetProcAddress(gl_hOriginalDll, "glTexCoord3fv");
originalglTexCoord3i = GetProcAddress(gl_hOriginalDll, "glTexCoord3i");
originalglTexCoord3iv = GetProcAddress(gl_hOriginalDll, "glTexCoord3iv");
originalglTexCoord3s = GetProcAddress(gl_hOriginalDll, "glTexCoord3s");
originalglTexCoord3sv = GetProcAddress(gl_hOriginalDll, "glTexCoord3sv");
originalglTexCoord4d = GetProcAddress(gl_hOriginalDll, "glTexCoord4d");
originalglTexCoord4dv = GetProcAddress(gl_hOriginalDll, "glTexCoord4dv");
originalglTexCoord4f = GetProcAddress(gl_hOriginalDll, "glTexCoord4f");
originalglTexCoord4fv = GetProcAddress(gl_hOriginalDll, "glTexCoord4fv");
originalglTexCoord4i = GetProcAddress(gl_hOriginalDll, "glTexCoord4i");
originalglTexCoord4iv = GetProcAddress(gl_hOriginalDll, "glTexCoord4iv");
originalglTexCoord4s = GetProcAddress(gl_hOriginalDll, "glTexCoord4s");
originalglTexCoord4sv = GetProcAddress(gl_hOriginalDll, "glTexCoord4sv");
originalglVertex2d = GetProcAddress(gl_hOriginalDll, "glVertex2d");
originalglVertex2dv = GetProcAddress(gl_hOriginalDll, "glVertex2dv");
originalglVertex2f = GetProcAddress(gl_hOriginalDll, "glVertex2f");
originalglVertex2fv = GetProcAddress(gl_hOriginalDll, "glVertex2fv");
originalglVertex2i = GetProcAddress(gl_hOriginalDll, "glVertex2i");
originalglVertex2iv = GetProcAddress(gl_hOriginalDll, "glVertex2iv");
originalglVertex2s = GetProcAddress(gl_hOriginalDll, "glVertex2s");
originalglVertex2sv = GetProcAddress(gl_hOriginalDll, "glVertex2sv");
originalglVertex3d = GetProcAddress(gl_hOriginalDll, "glVertex3d");
originalglVertex3dv = GetProcAddress(gl_hOriginalDll, "glVertex3dv");
originalglVertex3f = GetProcAddress(gl_hOriginalDll, "glVertex3f");
originalglVertex3fv = GetProcAddress(gl_hOriginalDll, "glVertex3fv");
originalglVertex3i = GetProcAddress(gl_hOriginalDll, "glVertex3i");
originalglVertex3iv = GetProcAddress(gl_hOriginalDll, "glVertex3iv");
originalglVertex3s = GetProcAddress(gl_hOriginalDll, "glVertex3s");
originalglVertex3sv = GetProcAddress(gl_hOriginalDll, "glVertex3sv");
originalglVertex4d = GetProcAddress(gl_hOriginalDll, "glVertex4d");
originalglVertex4dv = GetProcAddress(gl_hOriginalDll, "glVertex4dv");
originalglVertex4f = GetProcAddress(gl_hOriginalDll, "glVertex4f");
originalglVertex4fv = GetProcAddress(gl_hOriginalDll, "glVertex4fv");
originalglVertex4i = GetProcAddress(gl_hOriginalDll, "glVertex4i");
originalglVertex4iv = GetProcAddress(gl_hOriginalDll, "glVertex4iv");
originalglVertex4s = GetProcAddress(gl_hOriginalDll, "glVertex4s");
originalglVertex4sv = GetProcAddress(gl_hOriginalDll, "glVertex4sv");
originalglMaterialf = GetProcAddress(gl_hOriginalDll, "glMaterialf");
originalglMaterialfv = GetProcAddress(gl_hOriginalDll, "glMaterialfv");
originalglMateriali = GetProcAddress(gl_hOriginalDll, "glMateriali");
originalglMaterialiv = GetProcAddress(gl_hOriginalDll, "glMaterialiv");
originalglDisable = GetProcAddress(gl_hOriginalDll, "glDisable");
originalglEnable = GetProcAddress(gl_hOriginalDll, "glEnable");
originalglPopAttrib = GetProcAddress(gl_hOriginalDll, "glPopAttrib");
originalglPushAttrib = GetProcAddress(gl_hOriginalDll, "glPushAttrib");
originalglEvalCoord1d = GetProcAddress(gl_hOriginalDll, "glEvalCoord1d");
originalglEvalCoord1dv = GetProcAddress(gl_hOriginalDll, "glEvalCoord1dv");
originalglEvalCoord1f = GetProcAddress(gl_hOriginalDll, "glEvalCoord1f");
originalglEvalCoord1fv = GetProcAddress(gl_hOriginalDll, "glEvalCoord1fv");
originalglEvalCoord2d = GetProcAddress(gl_hOriginalDll, "glEvalCoord2d");
originalglEvalCoord2dv = GetProcAddress(gl_hOriginalDll, "glEvalCoord2dv");
originalglEvalCoord2f = GetProcAddress(gl_hOriginalDll, "glEvalCoord2f");
originalglEvalCoord2fv = GetProcAddress(gl_hOriginalDll, "glEvalCoord2fv");
originalglEvalPoint1 = GetProcAddress(gl_hOriginalDll, "glEvalPoint1");
originalglEvalPoint2 = GetProcAddress(gl_hOriginalDll, "glEvalPoint2");
originalglLoadIdentity = GetProcAddress(gl_hOriginalDll, "glLoadIdentity");
originalglLoadMatrixf = GetProcAddress(gl_hOriginalDll, "glLoadMatrixf");
originalglLoadMatrixd = GetProcAddress(gl_hOriginalDll, "glLoadMatrixd");
originalglMatrixMode = GetProcAddress(gl_hOriginalDll, "glMatrixMode");
originalglMultMatrixf = GetProcAddress(gl_hOriginalDll, "glMultMatrixf");
originalglMultMatrixd = GetProcAddress(gl_hOriginalDll, "glMultMatrixd");
originalglPopMatrix = GetProcAddress(gl_hOriginalDll, "glPopMatrix");
originalglPushMatrix = GetProcAddress(gl_hOriginalDll, "glPushMatrix");
originalglRotated = GetProcAddress(gl_hOriginalDll, "glRotated");
originalglRotatef = GetProcAddress(gl_hOriginalDll, "glRotatef");
originalglScaled = GetProcAddress(gl_hOriginalDll, "glScaled");
originalglScalef = GetProcAddress(gl_hOriginalDll, "glScalef");
originalglTranslated = GetProcAddress(gl_hOriginalDll, "glTranslated");
originalglTranslatef = GetProcAddress(gl_hOriginalDll, "glTranslatef");
originalglArrayElement = GetProcAddress(gl_hOriginalDll, "glArrayElement");
originalglBindTexture = GetProcAddress(gl_hOriginalDll, "glBindTexture");
originalglColorPointer = GetProcAddress(gl_hOriginalDll, "glColorPointer");
originalglDisableClientState = GetProcAddress(gl_hOriginalDll, "glDisableClientState");
originalglDrawArrays = GetProcAddress(gl_hOriginalDll, "glDrawArrays");
originalglDrawElements = GetProcAddress(gl_hOriginalDll, "glDrawElements");
originalglEdgeFlagPointer = GetProcAddress(gl_hOriginalDll, "glEdgeFlagPointer");
originalglEnableClientState = GetProcAddress(gl_hOriginalDll, "glEnableClientState");
originalglIndexPointer = GetProcAddress(gl_hOriginalDll, "glIndexPointer");
originalglIndexub = GetProcAddress(gl_hOriginalDll, "glIndexub");
originalglIndexubv = GetProcAddress(gl_hOriginalDll, "glIndexubv");
originalglInterleavedArrays = GetProcAddress(gl_hOriginalDll, "glInterleavedArrays");
originalglNormalPointer = GetProcAddress(gl_hOriginalDll, "glNormalPointer");
originalglPolygonOffset = GetProcAddress(gl_hOriginalDll, "glPolygonOffset");
originalglTexCoordPointer = GetProcAddress(gl_hOriginalDll, "glTexCoordPointer");
originalglVertexPointer = GetProcAddress(gl_hOriginalDll, "glVertexPointer");
originalglGetPointerv = GetProcAddress(gl_hOriginalDll, "glGetPointerv");
originalglPopClientAttrib = GetProcAddress(gl_hOriginalDll, "glPopClientAttrib");
originalglPushClientAttrib = GetProcAddress(gl_hOriginalDll, "glPushClientAttrib");
originalglClear = GetProcAddress(gl_hOriginalDll, "glClear");
originalglClearAccum = GetProcAddress(gl_hOriginalDll, "glClearAccum");
originalglClearIndex = GetProcAddress(gl_hOriginalDll, "glClearIndex");
originalglClearColor = GetProcAddress(gl_hOriginalDll, "glClearColor");
originalglClearStencil = GetProcAddress(gl_hOriginalDll, "glClearStencil");
originalglClearDepth = GetProcAddress(gl_hOriginalDll, "glClearDepth");
originalglBitmap = GetProcAddress(gl_hOriginalDll, "glBitmap");
originalglTexImage1D = GetProcAddress(gl_hOriginalDll, "glTexImage1D");
originalglTexImage2D = GetProcAddress(gl_hOriginalDll, "glTexImage2D");
originalglCopyPixels = GetProcAddress(gl_hOriginalDll, "glCopyPixels");
originalglReadPixels = GetProcAddress(gl_hOriginalDll, "glReadPixels");
originalglDrawPixels = GetProcAddress(gl_hOriginalDll, "glDrawPixels");
originalglRectd = GetProcAddress(gl_hOriginalDll, "glRectd");
originalglRectdv = GetProcAddress(gl_hOriginalDll, "glRectdv");
originalglRectf = GetProcAddress(gl_hOriginalDll, "glRectf");
originalglRectfv = GetProcAddress(gl_hOriginalDll, "glRectfv");
originalglRecti = GetProcAddress(gl_hOriginalDll, "glRecti");
originalglRectiv = GetProcAddress(gl_hOriginalDll, "glRectiv");
originalglRects = GetProcAddress(gl_hOriginalDll, "glRects");
originalglRectsv = GetProcAddress(gl_hOriginalDll, "glRectsv");
originalglNewList = GetProcAddress(gl_hOriginalDll, "glNewList");
originalglEndList = GetProcAddress(gl_hOriginalDll, "glEndList");
originalglDeleteLists = GetProcAddress(gl_hOriginalDll, "glDeleteLists");
originalglGenLists = GetProcAddress(gl_hOriginalDll, "glGenLists");
originalglListBase = GetProcAddress(gl_hOriginalDll, "glListBase");
originalglRasterPos2d = GetProcAddress(gl_hOriginalDll, "glRasterPos2d");
originalglRasterPos2dv = GetProcAddress(gl_hOriginalDll, "glRasterPos2dv");
originalglRasterPos2f = GetProcAddress(gl_hOriginalDll, "glRasterPos2f");
originalglRasterPos2fv = GetProcAddress(gl_hOriginalDll, "glRasterPos2fv");
originalglRasterPos2i = GetProcAddress(gl_hOriginalDll, "glRasterPos2i");
originalglRasterPos2iv = GetProcAddress(gl_hOriginalDll, "glRasterPos2iv");
originalglRasterPos2s = GetProcAddress(gl_hOriginalDll, "glRasterPos2s");
originalglRasterPos2sv = GetProcAddress(gl_hOriginalDll, "glRasterPos2sv");
originalglRasterPos3d = GetProcAddress(gl_hOriginalDll, "glRasterPos3d");
originalglRasterPos3dv = GetProcAddress(gl_hOriginalDll, "glRasterPos3dv");
originalglRasterPos3f = GetProcAddress(gl_hOriginalDll, "glRasterPos3f");
originalglRasterPos3fv = GetProcAddress(gl_hOriginalDll, "glRasterPos3fv");
originalglRasterPos3i = GetProcAddress(gl_hOriginalDll, "glRasterPos3i");
originalglRasterPos3iv = GetProcAddress(gl_hOriginalDll, "glRasterPos3iv");
originalglRasterPos3s = GetProcAddress(gl_hOriginalDll, "glRasterPos3s");
originalglRasterPos3sv = GetProcAddress(gl_hOriginalDll, "glRasterPos3sv");
originalglRasterPos4d = GetProcAddress(gl_hOriginalDll, "glRasterPos4d");
originalglRasterPos4dv = GetProcAddress(gl_hOriginalDll, "glRasterPos4dv");
originalglRasterPos4f = GetProcAddress(gl_hOriginalDll, "glRasterPos4f");
originalglRasterPos4fv = GetProcAddress(gl_hOriginalDll, "glRasterPos4fv");
originalglRasterPos4i = GetProcAddress(gl_hOriginalDll, "glRasterPos4i");
originalglRasterPos4iv = GetProcAddress(gl_hOriginalDll, "glRasterPos4iv");
originalglRasterPos4s = GetProcAddress(gl_hOriginalDll, "glRasterPos4s");
originalglRasterPos4sv = GetProcAddress(gl_hOriginalDll, "glRasterPos4sv");
originalglClipPlane = GetProcAddress(gl_hOriginalDll, "glClipPlane");
originalglColorMaterial = GetProcAddress(gl_hOriginalDll, "glColorMaterial");
originalglCullFace = GetProcAddress(gl_hOriginalDll, "glCullFace");
originalglFogf = GetProcAddress(gl_hOriginalDll, "glFogf");
originalglFogfv = GetProcAddress(gl_hOriginalDll, "glFogfv");
originalglFogi = GetProcAddress(gl_hOriginalDll, "glFogi");
originalglFogiv = GetProcAddress(gl_hOriginalDll, "glFogiv");
originalglFrontFace = GetProcAddress(gl_hOriginalDll, "glFrontFace");
originalglHint = GetProcAddress(gl_hOriginalDll, "glHint");
originalglLightf = GetProcAddress(gl_hOriginalDll, "glLightf");
originalglLightfv = GetProcAddress(gl_hOriginalDll, "glLightfv");
originalglLighti = GetProcAddress(gl_hOriginalDll, "glLighti");
originalglLightiv = GetProcAddress(gl_hOriginalDll, "glLightiv");
originalglLightModelf = GetProcAddress(gl_hOriginalDll, "glLightModelf");
originalglLightModelfv = GetProcAddress(gl_hOriginalDll, "glLightModelfv");
originalglLightModeli = GetProcAddress(gl_hOriginalDll, "glLightModeli");
originalglLightModeliv = GetProcAddress(gl_hOriginalDll, "glLightModeliv");
originalglLineStipple = GetProcAddress(gl_hOriginalDll, "glLineStipple");
originalglLineWidth = GetProcAddress(gl_hOriginalDll, "glLineWidth");
originalglPointSize = GetProcAddress(gl_hOriginalDll, "glPointSize");
originalglPolygonMode = GetProcAddress(gl_hOriginalDll, "glPolygonMode");
originalglPolygonStipple = GetProcAddress(gl_hOriginalDll, "glPolygonStipple");
originalglScissor = GetProcAddress(gl_hOriginalDll, "glScissor");
originalglFinish = GetProcAddress(gl_hOriginalDll, "glFinish");
originalglShadeModel = GetProcAddress(gl_hOriginalDll, "glShadeModel");
originalglTexParameterf = GetProcAddress(gl_hOriginalDll, "glTexParameterf");
originalglTexParameterfv = GetProcAddress(gl_hOriginalDll, "glTexParameterfv");
originalglTexParameteri = GetProcAddress(gl_hOriginalDll, "glTexParameteri");
originalglTexParameteriv = GetProcAddress(gl_hOriginalDll, "glTexParameteriv");
originalglTexEnvf = GetProcAddress(gl_hOriginalDll, "glTexEnvf");
originalglTexEnvfv = GetProcAddress(gl_hOriginalDll, "glTexEnvfv");
originalglTexEnvi = GetProcAddress(gl_hOriginalDll, "glTexEnvi");
originalglTexEnviv = GetProcAddress(gl_hOriginalDll, "glTexEnviv");
originalglTexGend = GetProcAddress(gl_hOriginalDll, "glTexGend");
originalglTexGendv = GetProcAddress(gl_hOriginalDll, "glTexGendv");
originalglTexGenf = GetProcAddress(gl_hOriginalDll, "glTexGenf");
originalglTexGenfv = GetProcAddress(gl_hOriginalDll, "glTexGenfv");
originalglTexGeni = GetProcAddress(gl_hOriginalDll, "glTexGeni");
originalglTexGeniv = GetProcAddress(gl_hOriginalDll, "glTexGeniv");
originalglFeedbackBuffer = GetProcAddress(gl_hOriginalDll, "glFeedbackBuffer");
originalglSelectBuffer = GetProcAddress(gl_hOriginalDll, "glSelectBuffer");
originalglRenderMode = GetProcAddress(gl_hOriginalDll, "glRenderMode");
originalglInitNames = GetProcAddress(gl_hOriginalDll, "glInitNames");
originalglLoadName = GetProcAddress(gl_hOriginalDll, "glLoadName");
originalglPassThrough = GetProcAddress(gl_hOriginalDll, "glPassThrough");
originalglPopName = GetProcAddress(gl_hOriginalDll, "glPopName");
originalglPushName = GetProcAddress(gl_hOriginalDll, "glPushName");
originalglDrawBuffer = GetProcAddress(gl_hOriginalDll, "glDrawBuffer");
originalglStencilMask = GetProcAddress(gl_hOriginalDll, "glStencilMask");
originalglColorMask = GetProcAddress(gl_hOriginalDll, "glColorMask");
originalglDepthMask = GetProcAddress(gl_hOriginalDll, "glDepthMask");
originalglIndexMask = GetProcAddress(gl_hOriginalDll, "glIndexMask");
originalglAccum = GetProcAddress(gl_hOriginalDll, "glAccum");
originalglFlush = GetProcAddress(gl_hOriginalDll, "glFlush");
originalglMap1d = GetProcAddress(gl_hOriginalDll, "glMap1d");
originalglMap1f = GetProcAddress(gl_hOriginalDll, "glMap1f");
originalglMap2d = GetProcAddress(gl_hOriginalDll, "glMap2d");
originalglMap2f = GetProcAddress(gl_hOriginalDll, "glMap2f");
originalglMapGrid1d = GetProcAddress(gl_hOriginalDll, "glMapGrid1d");
originalglMapGrid1f = GetProcAddress(gl_hOriginalDll, "glMapGrid1f");
originalglMapGrid2d = GetProcAddress(gl_hOriginalDll, "glMapGrid2d");
originalglMapGrid2f = GetProcAddress(gl_hOriginalDll, "glMapGrid2f");
originalglEvalMesh1 = GetProcAddress(gl_hOriginalDll, "glEvalMesh1");
originalglEvalMesh2 = GetProcAddress(gl_hOriginalDll, "glEvalMesh2");
originalglAlphaFunc = GetProcAddress(gl_hOriginalDll, "glAlphaFunc");
originalglBlendFunc = GetProcAddress(gl_hOriginalDll, "glBlendFunc");
originalglLogicOp = GetProcAddress(gl_hOriginalDll, "glLogicOp");
originalglStencilFunc = GetProcAddress(gl_hOriginalDll, "glStencilFunc");
originalglStencilOp = GetProcAddress(gl_hOriginalDll, "glStencilOp");
originalglDepthFunc = GetProcAddress(gl_hOriginalDll, "glDepthFunc");
originalglPixelZoom = GetProcAddress(gl_hOriginalDll, "glPixelZoom");
originalglPixelTransferf = GetProcAddress(gl_hOriginalDll, "glPixelTransferf");
originalglPixelTransferi = GetProcAddress(gl_hOriginalDll, "glPixelTransferi");
originalglPixelStoref = GetProcAddress(gl_hOriginalDll, "glPixelStoref");
originalglPixelStorei = GetProcAddress(gl_hOriginalDll, "glPixelStorei");
originalglPixelMapfv = GetProcAddress(gl_hOriginalDll, "glPixelMapfv");
originalglPixelMapuiv = GetProcAddress(gl_hOriginalDll, "glPixelMapuiv");
originalglPixelMapusv = GetProcAddress(gl_hOriginalDll, "glPixelMapusv");
originalglReadBuffer = GetProcAddress(gl_hOriginalDll, "glReadBuffer");
originalglGetBooleanv = GetProcAddress(gl_hOriginalDll, "glGetBooleanv");
originalglGetClipPlane = GetProcAddress(gl_hOriginalDll, "glGetClipPlane");
originalglGetDoublev = GetProcAddress(gl_hOriginalDll, "glGetDoublev");
originalglGetError = GetProcAddress(gl_hOriginalDll, "glGetError");
originalglGetFloatv = GetProcAddress(gl_hOriginalDll, "glGetFloatv");
originalglGetIntegerv = GetProcAddress(gl_hOriginalDll, "glGetIntegerv");
originalglGetLightfv = GetProcAddress(gl_hOriginalDll, "glGetLightfv");
originalglGetLightiv = GetProcAddress(gl_hOriginalDll, "glGetLightiv");
originalglGetMapdv = GetProcAddress(gl_hOriginalDll, "glGetMapdv");
originalglGetMapfv = GetProcAddress(gl_hOriginalDll, "glGetMapfv");
originalglGetMapiv = GetProcAddress(gl_hOriginalDll, "glGetMapiv");
originalglGetMaterialfv = GetProcAddress(gl_hOriginalDll, "glGetMaterialfv");
originalglGetMaterialiv = GetProcAddress(gl_hOriginalDll, "glGetMaterialiv");
originalglGetPixelMapfv = GetProcAddress(gl_hOriginalDll, "glGetPixelMapfv");
originalglGetPixelMapuiv = GetProcAddress(gl_hOriginalDll, "glGetPixelMapuiv");
originalglGetPixelMapusv = GetProcAddress(gl_hOriginalDll, "glGetPixelMapusv");
originalglGetPolygonStipple = GetProcAddress(gl_hOriginalDll, "glGetPolygonStipple");
originalglGetString = GetProcAddress(gl_hOriginalDll, "glGetString");
originalglGetTexEnvfv = GetProcAddress(gl_hOriginalDll, "glGetTexEnvfv");
originalglGetTexEnviv = GetProcAddress(gl_hOriginalDll, "glGetTexEnviv");
originalglGetTexGendv = GetProcAddress(gl_hOriginalDll, "glGetTexGendv");
originalglGetTexGenfv = GetProcAddress(gl_hOriginalDll, "glGetTexGenfv");
originalglGetTexGeniv = GetProcAddress(gl_hOriginalDll, "glGetTexGeniv");
originalglGetTexImage = GetProcAddress(gl_hOriginalDll, "glGetTexImage");
originalglGetTexParameterfv = GetProcAddress(gl_hOriginalDll, "glGetTexParameterfv");
originalglGetTexParameteriv = GetProcAddress(gl_hOriginalDll, "glGetTexParameteriv");
originalglGetTexLevelParameterfv = GetProcAddress(gl_hOriginalDll, "glGetTexLevelParameterfv");
originalglGetTexLevelParameteriv = GetProcAddress(gl_hOriginalDll, "glGetTexLevelParameteriv");
originalglIsEnabled = GetProcAddress(gl_hOriginalDll, "glIsEnabled");
originalglIsList = GetProcAddress(gl_hOriginalDll, "glIsList");
originalglDepthRange = GetProcAddress(gl_hOriginalDll, "glDepthRange");
originalglFrustum = GetProcAddress(gl_hOriginalDll, "glFrustum");
originalglOrtho = GetProcAddress(gl_hOriginalDll, "glOrtho");
originalglViewport = GetProcAddress(gl_hOriginalDll, "glViewport");
originalglAreTexturesResident = GetProcAddress(gl_hOriginalDll, "glAreTexturesResident");
originalglCopyTexImage1D = GetProcAddress(gl_hOriginalDll, "glCopyTexImage1D");
originalglCopyTexImage2D = GetProcAddress(gl_hOriginalDll, "glCopyTexImage2D");
originalglCopyTexSubImage1D = GetProcAddress(gl_hOriginalDll, "glCopyTexSubImage1D");
originalglCopyTexSubImage2D = GetProcAddress(gl_hOriginalDll, "glCopyTexSubImage2D");
originalglDeleteTextures = GetProcAddress(gl_hOriginalDll, "glDeleteTextures");
originalglGenTextures = GetProcAddress(gl_hOriginalDll, "glGenTextures");
originalglIsTexture = GetProcAddress(gl_hOriginalDll, "glIsTexture");
originalglPrioritizeTextures = GetProcAddress(gl_hOriginalDll, "glPrioritizeTextures");
originalglTexSubImage1D = GetProcAddress(gl_hOriginalDll, "glTexSubImage1D");
originalglTexSubImage2D = GetProcAddress(gl_hOriginalDll, "glTexSubImage2D");
Fix
2019-10-30 06:14:51 +01:00
}
0.8 update
2019-04-07 07:16:19 +02:00
Fix
2019-10-30 06:14:51 +01:00
if (currentLibrary == lib::winmm)
{
originalPlaySoundW = GetProcAddress(gl_hOriginalDll, "PlaySoundW");
originaltimeSetEvent = GetProcAddress(gl_hOriginalDll, "timeSetEvent");
originaltimeKillEvent = GetProcAddress(gl_hOriginalDll, "timeKillEvent");
originalmidiOutMessage = GetProcAddress(gl_hOriginalDll, "midiOutMessage");
originaltimeBeginPeriod = GetProcAddress(gl_hOriginalDll, "timeBeginPeriod");
originaltimeGetTime = GetProcAddress(gl_hOriginalDll, "timeGetTime");
originalNotifyCallbackData = GetProcAddress(gl_hOriginalDll, "NotifyCallbackData");
originalWOW32DriverCallback = GetProcAddress(gl_hOriginalDll, "WOW32DriverCallback");
originalWOW32ResolveMultiMediaHandle = GetProcAddress(gl_hOriginalDll, "WOW32ResolveMultiMediaHandle");
originalaux32Message = GetProcAddress(gl_hOriginalDll, "aux32Message");
originaljoy32Message = GetProcAddress(gl_hOriginalDll, "joy32Message");
originalmid32Message = GetProcAddress(gl_hOriginalDll, "mid32Message");
originalmod32Message = GetProcAddress(gl_hOriginalDll, "mod32Message");
originalmxd32Message = GetProcAddress(gl_hOriginalDll, "mxd32Message");
originaltid32Message = GetProcAddress(gl_hOriginalDll, "tid32Message");
originalwid32Message = GetProcAddress(gl_hOriginalDll, "wid32Message");
originalwod32Message = GetProcAddress(gl_hOriginalDll, "wod32Message");
originalmci32Message = GetProcAddress(gl_hOriginalDll, "mci32Message");
originalCloseDriver = GetProcAddress(gl_hOriginalDll, "CloseDriver");
originalDefDriverProc = GetProcAddress(gl_hOriginalDll, "DefDriverProc");
originalDriverCallback = GetProcAddress(gl_hOriginalDll, "DriverCallback");
originalDrvGetModuleHandle = GetProcAddress(gl_hOriginalDll, "DrvGetModuleHandle");
originalGetDriverModuleHandle = GetProcAddress(gl_hOriginalDll, "GetDriverModuleHandle");
originalOpenDriver = GetProcAddress(gl_hOriginalDll, "OpenDriver");
originalPlaySound = GetProcAddress(gl_hOriginalDll, "PlaySound");
originalOrdinal2 = GetProcAddress(gl_hOriginalDll, "Ordinal2");
originalSendDriverMessage = GetProcAddress(gl_hOriginalDll, "SendDriverMessage");
originalauxGetDevCapsA = GetProcAddress(gl_hOriginalDll, "auxGetDevCapsA");
originalauxGetDevCapsW = GetProcAddress(gl_hOriginalDll, "auxGetDevCapsW");
originalauxGetNumDevs = GetProcAddress(gl_hOriginalDll, "auxGetNumDevs");
originalauxGetVolume = GetProcAddress(gl_hOriginalDll, "auxGetVolume");
originalauxOutMessage = GetProcAddress(gl_hOriginalDll, "auxOutMessage");
originalauxSetVolume = GetProcAddress(gl_hOriginalDll, "auxSetVolume");
originaljoyConfigChanged = GetProcAddress(gl_hOriginalDll, "joyConfigChanged");
originaljoyGetDevCapsA = GetProcAddress(gl_hOriginalDll, "joyGetDevCapsA");
originaljoyGetDevCapsW = GetProcAddress(gl_hOriginalDll, "joyGetDevCapsW");
originaljoyGetNumDevs = GetProcAddress(gl_hOriginalDll, "joyGetNumDevs");
originaljoyGetPosEx = GetProcAddress(gl_hOriginalDll, "joyGetPosEx");
originaljoyGetPos = GetProcAddress(gl_hOriginalDll, "joyGetPos");
originaljoyGetThreshold = GetProcAddress(gl_hOriginalDll, "joyGetThreshold");
originaljoyReleaseCapture = GetProcAddress(gl_hOriginalDll, "joyReleaseCapture");
originaljoySetCapture = GetProcAddress(gl_hOriginalDll, "joySetCapture");
originaljoySetThreshold = GetProcAddress(gl_hOriginalDll, "joySetThreshold");
originalmidiConnect = GetProcAddress(gl_hOriginalDll, "midiConnect");
originalmidiDisconnect = GetProcAddress(gl_hOriginalDll, "midiDisconnect");
originalmidiInAddBuffer = GetProcAddress(gl_hOriginalDll, "midiInAddBuffer");
originalmidiInClose = GetProcAddress(gl_hOriginalDll, "midiInClose");
originalmidiInGetDevCapsA = GetProcAddress(gl_hOriginalDll, "midiInGetDevCapsA");
originalmidiInGetDevCapsW = GetProcAddress(gl_hOriginalDll, "midiInGetDevCapsW");
originalmidiInGetErrorTextA = GetProcAddress(gl_hOriginalDll, "midiInGetErrorTextA");
originalmidiInGetErrorTextW = GetProcAddress(gl_hOriginalDll, "midiInGetErrorTextW");
originalmidiInGetID = GetProcAddress(gl_hOriginalDll, "midiInGetID");
originalmidiInGetNumDevs = GetProcAddress(gl_hOriginalDll, "midiInGetNumDevs");
originalmidiInMessage = GetProcAddress(gl_hOriginalDll, "midiInMessage");
originalmidiInOpen = GetProcAddress(gl_hOriginalDll, "midiInOpen");
originalmidiInPrepareHeader = GetProcAddress(gl_hOriginalDll, "midiInPrepareHeader");
originalmidiInReset = GetProcAddress(gl_hOriginalDll, "midiInReset");
originalmidiInStart = GetProcAddress(gl_hOriginalDll, "midiInStart");
originalmidiInStop = GetProcAddress(gl_hOriginalDll, "midiInStop");
originalmidiInUnprepareHeader = GetProcAddress(gl_hOriginalDll, "midiInUnprepareHeader");
originalmidiOutCacheDrumPatches = GetProcAddress(gl_hOriginalDll, "midiOutCacheDrumPatches");
originalmidiOutCachePatches = GetProcAddress(gl_hOriginalDll, "midiOutCachePatches");
originalmidiOutClose = GetProcAddress(gl_hOriginalDll, "midiOutClose");
originalmidiOutGetDevCapsA = GetProcAddress(gl_hOriginalDll, "midiOutGetDevCapsA");
originalmidiOutGetDevCapsW = GetProcAddress(gl_hOriginalDll, "midiOutGetDevCapsW");
originalmidiOutGetErrorTextA = GetProcAddress(gl_hOriginalDll, "midiOutGetErrorTextA");
originalmidiOutGetErrorTextW = GetProcAddress(gl_hOriginalDll, "midiOutGetErrorTextW");
originalmidiOutGetID = GetProcAddress(gl_hOriginalDll, "midiOutGetID");
originalmidiOutGetNumDevs = GetProcAddress(gl_hOriginalDll, "midiOutGetNumDevs");
originalmidiOutGetVolume = GetProcAddress(gl_hOriginalDll, "midiOutGetVolume");
originalmidiOutLongMsg = GetProcAddress(gl_hOriginalDll, "midiOutLongMsg");
originalmidiOutOpen = GetProcAddress(gl_hOriginalDll, "midiOutOpen");
originalmidiOutPrepareHeader = GetProcAddress(gl_hOriginalDll, "midiOutPrepareHeader");
originalmidiOutReset = GetProcAddress(gl_hOriginalDll, "midiOutReset");
originalmidiOutSetVolume = GetProcAddress(gl_hOriginalDll, "midiOutSetVolume");
originalmidiOutShortMsg = GetProcAddress(gl_hOriginalDll, "midiOutShortMsg");
originalmidiOutUnprepareHeader = GetProcAddress(gl_hOriginalDll, "midiOutUnprepareHeader");
originalmidiStreamClose = GetProcAddress(gl_hOriginalDll, "midiStreamClose");
originalmidiStreamOpen = GetProcAddress(gl_hOriginalDll, "midiStreamOpen");
originalmidiStreamOut = GetProcAddress(gl_hOriginalDll, "midiStreamOut");
originalmidiStreamPause = GetProcAddress(gl_hOriginalDll, "midiStreamPause");
originalmidiStreamPosition = GetProcAddress(gl_hOriginalDll, "midiStreamPosition");
originalmidiStreamProperty = GetProcAddress(gl_hOriginalDll, "midiStreamProperty");
originalmidiStreamRestart = GetProcAddress(gl_hOriginalDll, "midiStreamRestart");
originalmidiStreamStop = GetProcAddress(gl_hOriginalDll, "midiStreamStop");
originalmixerClose = GetProcAddress(gl_hOriginalDll, "mixerClose");
originalmixerGetControlDetailsA = GetProcAddress(gl_hOriginalDll, "mixerGetControlDetailsA");
originalmixerGetControlDetailsW = GetProcAddress(gl_hOriginalDll, "mixerGetControlDetailsW");
originalmixerGetDevCapsA = GetProcAddress(gl_hOriginalDll, "mixerGetDevCapsA");
originalmixerGetDevCapsW = GetProcAddress(gl_hOriginalDll, "mixerGetDevCapsW");
originalmixerGetID = GetProcAddress(gl_hOriginalDll, "mixerGetID");
originalmixerGetLineControlsA = GetProcAddress(gl_hOriginalDll, "mixerGetLineControlsA");
originalmixerGetLineControlsW = GetProcAddress(gl_hOriginalDll, "mixerGetLineControlsW");
originalmixerGetLineInfoA = GetProcAddress(gl_hOriginalDll, "mixerGetLineInfoA");
originalmixerGetLineInfoW = GetProcAddress(gl_hOriginalDll, "mixerGetLineInfoW");
originalmixerGetNumDevs = GetProcAddress(gl_hOriginalDll, "mixerGetNumDevs");
originalmixerMessage = GetProcAddress(gl_hOriginalDll, "mixerMessage");
originalmixerOpen = GetProcAddress(gl_hOriginalDll, "mixerOpen");
originalmixerSetControlDetails = GetProcAddress(gl_hOriginalDll, "mixerSetControlDetails");
originalmmDrvInstall = GetProcAddress(gl_hOriginalDll, "mmDrvInstall");
originalmmGetCurrentTask = GetProcAddress(gl_hOriginalDll, "mmGetCurrentTask");
originalmmTaskBlock = GetProcAddress(gl_hOriginalDll, "mmTaskBlock");
originalmmTaskCreate = GetProcAddress(gl_hOriginalDll, "mmTaskCreate");
originalmmTaskSignal = GetProcAddress(gl_hOriginalDll, "mmTaskSignal");
originalmmTaskYield = GetProcAddress(gl_hOriginalDll, "mmTaskYield");
originalmmioAdvance = GetProcAddress(gl_hOriginalDll, "mmioAdvance");
originalmmioAscend = GetProcAddress(gl_hOriginalDll, "mmioAscend");
originalmmioClose = GetProcAddress(gl_hOriginalDll, "mmioClose");
originalmmioCreateChunk = GetProcAddress(gl_hOriginalDll, "mmioCreateChunk");
originalmmioDescend = GetProcAddress(gl_hOriginalDll, "mmioDescend");
originalmmioFlush = GetProcAddress(gl_hOriginalDll, "mmioFlush");
originalmmioGetInfo = GetProcAddress(gl_hOriginalDll, "mmioGetInfo");
originalmmioInstallIOProcA = GetProcAddress(gl_hOriginalDll, "mmioInstallIOProcA");
originalmmioInstallIOProcW = GetProcAddress(gl_hOriginalDll, "mmioInstallIOProcW");
originalmmioOpenA = GetProcAddress(gl_hOriginalDll, "mmioOpenA");
originalmmioOpenW = GetProcAddress(gl_hOriginalDll, "mmioOpenW");
originalmmioRead = GetProcAddress(gl_hOriginalDll, "mmioRead");
originalmmioRenameA = GetProcAddress(gl_hOriginalDll, "mmioRenameA");
originalmmioRenameW = GetProcAddress(gl_hOriginalDll, "mmioRenameW");
originalmmioSeek = GetProcAddress(gl_hOriginalDll, "mmioSeek");
originalmmioSendMessage = GetProcAddress(gl_hOriginalDll, "mmioSendMessage");
originalmmioSetBuffer = GetProcAddress(gl_hOriginalDll, "mmioSetBuffer");
originalmmioSetInfo = GetProcAddress(gl_hOriginalDll, "mmioSetInfo");
originalmmioStringToFOURCCA = GetProcAddress(gl_hOriginalDll, "mmioStringToFOURCCA");
originalmmioStringToFOURCCW = GetProcAddress(gl_hOriginalDll, "mmioStringToFOURCCW");
originalmmioWrite = GetProcAddress(gl_hOriginalDll, "mmioWrite");
originaltimeEndPeriod = GetProcAddress(gl_hOriginalDll, "timeEndPeriod");
originaltimeGetDevCaps = GetProcAddress(gl_hOriginalDll, "timeGetDevCaps");
originaltimeGetSystemTime = GetProcAddress(gl_hOriginalDll, "timeGetSystemTime");
originalwaveInAddBuffer = GetProcAddress(gl_hOriginalDll, "waveInAddBuffer");
originalwaveInClose = GetProcAddress(gl_hOriginalDll, "waveInClose");
originalwaveInGetDevCapsA = GetProcAddress(gl_hOriginalDll, "waveInGetDevCapsA");
originalwaveInGetDevCapsW = GetProcAddress(gl_hOriginalDll, "waveInGetDevCapsW");
originalwaveInGetErrorTextA = GetProcAddress(gl_hOriginalDll, "waveInGetErrorTextA");
originalwaveInGetErrorTextW = GetProcAddress(gl_hOriginalDll, "waveInGetErrorTextW");
originalwaveInGetID = GetProcAddress(gl_hOriginalDll, "waveInGetID");
originalwaveInGetNumDevs = GetProcAddress(gl_hOriginalDll, "waveInGetNumDevs");
originalwaveInGetPosition = GetProcAddress(gl_hOriginalDll, "waveInGetPosition");
originalwaveInMessage = GetProcAddress(gl_hOriginalDll, "waveInMessage");
originalwaveInOpen = GetProcAddress(gl_hOriginalDll, "waveInOpen");
originalwaveInPrepareHeader = GetProcAddress(gl_hOriginalDll, "waveInPrepareHeader");
originalwaveInReset = GetProcAddress(gl_hOriginalDll, "waveInReset");
originalwaveInStart = GetProcAddress(gl_hOriginalDll, "waveInStart");
originalwaveInStop = GetProcAddress(gl_hOriginalDll, "waveInStop");
originalwaveInUnprepareHeader = GetProcAddress(gl_hOriginalDll, "waveInUnprepareHeader");
originalwaveOutBreakLoop = GetProcAddress(gl_hOriginalDll, "waveOutBreakLoop");
originalwaveOutClose = GetProcAddress(gl_hOriginalDll, "waveOutClose");
originalwaveOutGetDevCapsA = GetProcAddress(gl_hOriginalDll, "waveOutGetDevCapsA");
originalwaveOutGetDevCapsW = GetProcAddress(gl_hOriginalDll, "waveOutGetDevCapsW");
originalwaveOutGetErrorTextA = GetProcAddress(gl_hOriginalDll, "waveOutGetErrorTextA");
originalwaveOutGetErrorTextW = GetProcAddress(gl_hOriginalDll, "waveOutGetErrorTextW");
originalwaveOutGetID = GetProcAddress(gl_hOriginalDll, "waveOutGetID");
originalwaveOutGetNumDevs = GetProcAddress(gl_hOriginalDll, "waveOutGetNumDevs");
originalwaveOutGetPitch = GetProcAddress(gl_hOriginalDll, "waveOutGetPitch");
originalwaveOutGetPlaybackRate = GetProcAddress(gl_hOriginalDll, "waveOutGetPlaybackRate");
originalwaveOutGetPosition = GetProcAddress(gl_hOriginalDll, "waveOutGetPosition");
originalwaveOutGetVolume = GetProcAddress(gl_hOriginalDll, "waveOutGetVolume");
originalwaveOutMessage = GetProcAddress(gl_hOriginalDll, "waveOutMessage");
originalwaveOutOpen = GetProcAddress(gl_hOriginalDll, "waveOutOpen");
originalwaveOutPause = GetProcAddress(gl_hOriginalDll, "waveOutPause");
originalwaveOutPrepareHeader = GetProcAddress(gl_hOriginalDll, "waveOutPrepareHeader");
originalwaveOutReset = GetProcAddress(gl_hOriginalDll, "waveOutReset");
originalwaveOutRestart = GetProcAddress(gl_hOriginalDll, "waveOutRestart");
originalwaveOutSetPitch = GetProcAddress(gl_hOriginalDll, "waveOutSetPitch");
originalwaveOutSetPlaybackRate = GetProcAddress(gl_hOriginalDll, "waveOutSetPlaybackRate");
originalwaveOutSetVolume = GetProcAddress(gl_hOriginalDll, "waveOutSetVolume");
originalwaveOutUnprepareHeader = GetProcAddress(gl_hOriginalDll, "waveOutUnprepareHeader");
originalwaveOutWrite = GetProcAddress(gl_hOriginalDll, "waveOutWrite");
originalmciExecute = GetProcAddress(gl_hOriginalDll, "mciExecute");
originalmciGetErrorStringA = GetProcAddress(gl_hOriginalDll, "mciGetErrorStringA");
originalmciGetErrorStringW = GetProcAddress(gl_hOriginalDll, "mciGetErrorStringW");
originalmciSendCommandA = GetProcAddress(gl_hOriginalDll, "mciSendCommandA");
originalmciSendCommandW = GetProcAddress(gl_hOriginalDll, "mciSendCommandW");
originalmciSendStringA = GetProcAddress(gl_hOriginalDll, "mciSendStringA");
originalmciSendStringW = GetProcAddress(gl_hOriginalDll, "mciSendStringW");
originalmciFreeCommandResource = GetProcAddress(gl_hOriginalDll, "mciFreeCommandResource");
originalmciLoadCommandResource = GetProcAddress(gl_hOriginalDll, "mciLoadCommandResource");
originalmciDriverNotify = GetProcAddress(gl_hOriginalDll, "mciDriverNotify");
originalmciDriverYield = GetProcAddress(gl_hOriginalDll, "mciDriverYield");
originalmciGetCreatorTask = GetProcAddress(gl_hOriginalDll, "mciGetCreatorTask");
originalmciGetDeviceIDA = GetProcAddress(gl_hOriginalDll, "mciGetDeviceIDA");
originalmciGetDeviceIDFromElementIDA = GetProcAddress(gl_hOriginalDll, "mciGetDeviceIDFromElementIDA");
originalmciGetDeviceIDFromElementIDW = GetProcAddress(gl_hOriginalDll, "mciGetDeviceIDFromElementIDW");
originalmciGetDeviceIDW = GetProcAddress(gl_hOriginalDll, "mciGetDeviceIDW");
originalmciGetDriverData = GetProcAddress(gl_hOriginalDll, "mciGetDriverData");
originalmciGetYieldProc = GetProcAddress(gl_hOriginalDll, "mciGetYieldProc");
originalmciSetDriverData = GetProcAddress(gl_hOriginalDll, "mciSetDriverData");
originalmciSetYieldProc = GetProcAddress(gl_hOriginalDll, "mciSetYieldProc");
originalPlaySoundA = GetProcAddress(gl_hOriginalDll, "PlaySoundA");
originalsndPlaySoundA = GetProcAddress(gl_hOriginalDll, "sndPlaySoundA");
originalsndPlaySoundW = GetProcAddress(gl_hOriginalDll, "sndPlaySoundW");
originalWOWAppExit = GetProcAddress(gl_hOriginalDll, "WOWAppExit");
originalmmsystemGetVersion = GetProcAddress(gl_hOriginalDll, "mmsystemGetVersion");
}
0.8 update
2019-04-07 07:16:19 +02:00
Fix Flycast issue
2023-03-02 10:31:02 +01:00
if (configGameId == 60)
Flycast Output FFB Support
2023-03-02 08:39:51 +01:00
{
DWORD ProcessID = GetPrivateProfileInt(TEXT("Settings"), TEXT("ProcessID"), 0, settingsFilename);
if (IsProcessRunning(ProcessID))
break;
GameProcessID = MyGetProcessId(L"flycast.exe");
if (GameProcessID)
WritePrivateProfileStringA("Settings", "ProcessID", (char*)(std::to_string(GameProcessID)).c_str(), ".\\FFBPlugin.ini");
}
Prevent the plugin from hooking FFBPluginGUI.exe
2019-11-03 04:54:38 +01:00
if (processName.find("FFBPluginGUI.exe") != std::string::npos)
{
hlp.log("hooked FFBPluginGUI.exe, aborting");
break;
}
Changes output reading and spring
2020-01-02 21:40:01 +01:00
SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
0.8 update
2019-04-07 07:16:19 +02:00
hlp.log("creating ffb loop thread...");
CreateFFBLoopThread();
Update SDL2
2023-01-21 08:01:21 +01:00
if (BeepWhenHook)
Fix
2019-10-30 06:14:51 +01:00
MessageBeep(MB_ICONASTERISK);
0.8 update
2019-04-07 07:16:19 +02:00
break;
case DLL_THREAD_ATTACH:
hlp.log("dll thread attach");
break;
case DLL_THREAD_DETACH:
hlp.log("dll thread detach");
break;
case DLL_PROCESS_DETACH:
hlp.log("detaching from process:");
Fix
2019-10-30 06:14:51 +01:00
hlp.log((char*)processName.c_str());
0.8 update
2019-04-07 07:16:19 +02:00
keepRunning = false;
FreeLibrary on MAME32 & 64
2019-12-08 20:33:16 +01:00
Fix Flycast issue
2023-03-02 10:31:02 +01:00
if (configGameId == 60)
Flycast Output FFB Support
2023-03-02 08:39:51 +01:00
WritePrivateProfileStringA("Settings", "ProcessID", 0, ".\\FFBPlugin.ini");
Update SDL2
2023-01-21 08:01:21 +01:00
if (haptic)
GRID and MK Changes
2023-04-06 22:10:00 +02:00
{
SDL_HapticStopAll(haptic);
Update SDL2
2023-01-21 08:01:21 +01:00
SDL_HapticClose(haptic);
GRID and MK Changes
2023-04-06 22:10:00 +02:00
}
Update SDL2
2023-01-21 08:01:21 +01:00
if (haptic2)
GRID and MK Changes
2023-04-06 22:10:00 +02:00
{
SDL_HapticStopAll(haptic2);
Update SDL2
2023-01-21 08:01:21 +01:00
SDL_HapticClose(haptic2);
GRID and MK Changes
2023-04-06 22:10:00 +02:00
}
Update SDL2
2023-01-21 08:01:21 +01:00
if (haptic3)
GRID and MK Changes
2023-04-06 22:10:00 +02:00
{
SDL_HapticStopAll(haptic3);
Update SDL2
2023-01-21 08:01:21 +01:00
SDL_HapticClose(haptic3);
GRID and MK Changes
2023-04-06 22:10:00 +02:00
}
Update SDL2
2023-01-21 08:01:21 +01:00
change how plugin closes devices etc
2020-09-02 07:43:07 +02:00
if (GameController)
0.8 update
2019-04-07 07:16:19 +02:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (EnableRumble)
change how plugin closes devices etc
2020-09-02 07:43:07 +02:00
SDL_JoystickRumble(GameController, 0, 0, 0);
Update SDL2 and add rumble trigger support
2021-02-14 00:38:22 +01:00
Update SDL2
2023-01-21 08:01:21 +01:00
if (EnableRumbleTriggers)
Update SDL2 and add rumble trigger support
2021-02-14 00:38:22 +01:00
SDL_JoystickRumbleTriggers(GameController, 0, 0, 0);
Update SDL2
2023-01-21 08:01:21 +01:00
SDL_JoystickClose(GameController);
0.8 update
2019-04-07 07:16:19 +02:00
}
FreeLibrary on MAME32 & 64
2019-12-08 20:33:16 +01:00
change how plugin closes devices etc
2020-09-02 07:43:07 +02:00
if (GameController2)
0.8 update
2019-04-07 07:16:19 +02:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (EnableRumbleDevice2)
change how plugin closes devices etc
2020-09-02 07:43:07 +02:00
SDL_JoystickRumble(GameController2, 0, 0, 0);
Update SDL2
2023-01-21 08:01:21 +01:00
SDL_JoystickClose(GameController2);
0.8 update
2019-04-07 07:16:19 +02:00
}
FreeLibrary on MAME32 & 64
2019-12-08 20:33:16 +01:00
change how plugin closes devices etc
2020-09-02 07:43:07 +02:00
if (GameController3)
0.8 update
2019-04-07 07:16:19 +02:00
{
Update SDL2
2023-01-21 08:01:21 +01:00
if (EnableRumbleDevice3)
change how plugin closes devices etc
2020-09-02 07:43:07 +02:00
SDL_JoystickRumble(GameController3, 0, 0, 0);
Fix
2019-10-30 06:14:51 +01:00
Update SDL2
2023-01-21 08:01:21 +01:00
SDL_JoystickClose(GameController3);
Changed all rumble to use New Rumble compared to old LeftRight
2019-10-30 07:03:50 +01:00
}
0.8 update
2019-04-07 07:16:19 +02:00
break;
}
return result;
}
Copy Permalink