1330 lines
49 KiB
C++
1330 lines
49 KiB
C++
#include "extdev.h"
|
|
#include <cmath>
|
|
#include <string>
|
|
#include <optional>
|
|
#include <windows.h>
|
|
#include "util/utils.h"
|
|
#include "util/detour.h"
|
|
#include "util/libutils.h"
|
|
#include "util/circular_buffer.h"
|
|
#include "misc/eamuse.h"
|
|
#include "cfg/api.h"
|
|
#include "acio/icca/icca.h"
|
|
#include "games/gitadora/io.h"
|
|
#include "avs/game.h"
|
|
|
|
using namespace GameAPI;
|
|
|
|
#if SPICE64
|
|
typedef uint64_t LED_INDEX;
|
|
#else
|
|
typedef uint32_t LED_INDEX;
|
|
#endif
|
|
|
|
// card unit
|
|
static size_t EXTDEV_CARDUNIT_COUNT = 0;
|
|
static circular_buffer<int> EXTDEV_CARDUNIT_KEY[2] = {
|
|
circular_buffer<int>(32),
|
|
circular_buffer<int>(32)
|
|
};
|
|
static circular_buffer<const char*> EXTDEV_CARDUNIT_KEY_STR[2] = {
|
|
circular_buffer<const char*>(32),
|
|
circular_buffer<const char*>(32)
|
|
};
|
|
static int EXTDEV_CARDUNIT_EJECT[2] = {0, 0};
|
|
static bool EXTDEV_CARD_IN[2] = {false, false};
|
|
static bool EXTDEV_CARD_PRESSED[2] = {false, false};
|
|
static uint8_t EXTDEV_CARD[2][8];
|
|
static bool EXTDEV_CARDUNIT_TENKEY_STATE[2][12]{};
|
|
static std::string EXTDEV_CARDUNIT_TENKEY_STRINGS[] = {
|
|
"0",
|
|
"1",
|
|
"2",
|
|
"3",
|
|
"4",
|
|
"5",
|
|
"6",
|
|
"7",
|
|
"8",
|
|
"9",
|
|
"RETURN", // enter
|
|
"00" // double zero
|
|
};
|
|
static unsigned int EXTDEV_CARDUNIT_TENKEY_EAMUSE_MAPPING[] = {
|
|
0, 1, 5, 9, 2, 6, 10, 3, 7, 11, 8, 4
|
|
};
|
|
static unsigned int EXTDEV_CARDUNIT_TENKEY_NUMS[] {
|
|
0, 1, 5, 9, 2, 6, 10, 3, 7, 11, 8, 4
|
|
};
|
|
|
|
// GFDM
|
|
static int32_t GFDM_DM_ATTACK_BORDER_VALUE[] = {
|
|
0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50
|
|
};
|
|
static bool GFDM_GF_PICK_STATE_UP[2]{};
|
|
static bool GFDM_GF_PICK_STATE_DOWN[2]{};
|
|
|
|
// state
|
|
static HINSTANCE EXTDEV_INSTANCE;
|
|
static std::string EXTDEV_INSTANCE_NAMES[] = {
|
|
"ext_dev.dll",
|
|
"libextio.dll",
|
|
"libcardunit.dll",
|
|
"libledunit.dll",
|
|
"libgfdm_unit2.dll",
|
|
"libshare-pj.dll",
|
|
};
|
|
|
|
static void set_led_state(games::gitadora::Lights::gitadora_lights_t light, bool led_on);
|
|
static void set_led_value(games::gitadora::Lights::gitadora_lights_t light, uint8_t value);
|
|
static bool is_drum() {
|
|
return (
|
|
avs::game::is_model({ "J32", "K32", "L32" }) ||
|
|
(avs::game::is_model("M32") && avs::game::SPEC[0] == 'B')
|
|
);
|
|
}
|
|
static bool is_guitar() {
|
|
return (
|
|
avs::game::is_model({ "J33", "K33", "L33" }) ||
|
|
(avs::game::is_model("M32") && avs::game::SPEC[0] == 'A')
|
|
);
|
|
}
|
|
|
|
static long __cdecl gitadora_led_common(long index, uint8_t *data);
|
|
|
|
static void __cdecl cardunit_boot2(int a1, int a2, int a3) {
|
|
|
|
// default reader count to 1
|
|
EXTDEV_CARDUNIT_COUNT = 1;
|
|
|
|
// exceptions for games with two readers
|
|
if (avs::game::is_model({ "J33", "K33", "L33", "M32" })) {
|
|
EXTDEV_CARDUNIT_COUNT = 2;
|
|
}
|
|
}
|
|
|
|
static void __cdecl cardunit_boot(int a1, int a2) {
|
|
cardunit_boot2(1, a1, a2);
|
|
}
|
|
|
|
static int __cdecl cardunit_boot_initialize() {
|
|
return 0;
|
|
}
|
|
|
|
static void __cdecl cardunit_boot_no_slot_type(int a1, int a2) {
|
|
cardunit_boot2(1, a1, a2);
|
|
}
|
|
|
|
static void __cdecl cardunit_card_eject(int unit) {
|
|
EXTDEV_CARDUNIT_EJECT[unit] = 1;
|
|
}
|
|
|
|
static int __cdecl cardunit_card_eject_complete(int unit) {
|
|
EXTDEV_CARD_IN[unit] = false;
|
|
return EXTDEV_CARDUNIT_EJECT[unit];
|
|
}
|
|
|
|
static int __cdecl cardunit_card_eject_wait(int unit) {
|
|
return EXTDEV_CARDUNIT_EJECT[unit];
|
|
}
|
|
|
|
static int __cdecl cardunit_card_read2(int unit, void *card, int *status) {
|
|
|
|
// clear the eject flag
|
|
EXTDEV_CARDUNIT_EJECT[unit] = 0;
|
|
|
|
// check if a card was inserted
|
|
if (EXTDEV_CARD_IN[unit]) {
|
|
|
|
// copy card, return success
|
|
memcpy(card, EXTDEV_CARD[unit], 8);
|
|
*status = is_card_uid_felica(EXTDEV_CARD[unit]) ? 2 : 1;
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
// tried to read card with no card inserted, return fail
|
|
memset(card, 0, 8);
|
|
*status = 0;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
static int __cdecl cardunit_card_read(int unit, void *card) {
|
|
return cardunit_card_read2(unit, card, nullptr);
|
|
}
|
|
|
|
static void __cdecl cardunit_card_ready(int unit) {
|
|
EXTDEV_CARDUNIT_EJECT[unit] = 0;
|
|
}
|
|
|
|
static int __cdecl cardunit_card_sensor() {
|
|
return 0;
|
|
}
|
|
|
|
static int __cdecl cardunit_card_sensor_raw(int a1) {
|
|
return 1;
|
|
}
|
|
|
|
static void __cdecl cardunit_update() {
|
|
|
|
// update all units
|
|
for (size_t unit = 0; unit < EXTDEV_CARDUNIT_COUNT; unit++) {
|
|
bool kb_insert_press = false;
|
|
|
|
// eamio keypress
|
|
kb_insert_press |= eamuse_get_keypad_state(unit) & (1 << EAM_IO_INSERT);
|
|
|
|
// update card inserts
|
|
if (eamuse_card_insert_consume((int) EXTDEV_CARDUNIT_COUNT, unit) ||
|
|
(kb_insert_press && !EXTDEV_CARD_PRESSED[unit])) {
|
|
EXTDEV_CARD_PRESSED[unit] = true;
|
|
if (!EXTDEV_CARD_IN[unit]) {
|
|
EXTDEV_CARD_IN[unit] = true;
|
|
eamuse_get_card((int) EXTDEV_CARDUNIT_COUNT, unit, EXTDEV_CARD[unit]);
|
|
}
|
|
} else
|
|
EXTDEV_CARD_PRESSED[unit] = false;
|
|
|
|
// get eamu key states
|
|
uint16_t eamu_state = eamuse_get_keypad_state(unit);
|
|
|
|
// iterate all keys
|
|
for (int i = 0; i < 12; i++) {
|
|
|
|
// check if key is pressed
|
|
if (eamu_state & (1 << EXTDEV_CARDUNIT_TENKEY_EAMUSE_MAPPING[i])) {
|
|
|
|
// check if key was pressed before
|
|
if (!EXTDEV_CARDUNIT_TENKEY_STATE[unit][i]) {
|
|
|
|
// remember key press
|
|
EXTDEV_CARDUNIT_TENKEY_STATE[unit][i] = true;
|
|
|
|
// set last key
|
|
EXTDEV_CARDUNIT_KEY[unit].put(EXTDEV_CARDUNIT_TENKEY_NUMS[i]);
|
|
EXTDEV_CARDUNIT_KEY_STR[unit].put(EXTDEV_CARDUNIT_TENKEY_STRINGS[i].c_str());
|
|
|
|
// we can only detect one key at a time
|
|
break;
|
|
}
|
|
|
|
} else {
|
|
|
|
// forget old key press
|
|
EXTDEV_CARDUNIT_TENKEY_STATE[unit][i] = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static int __cdecl cardunit_get_status(int unit) {
|
|
|
|
// might not be needed
|
|
cardunit_update();
|
|
|
|
// TODO: why only for reflec beat?
|
|
if (avs::game::is_model("MBR")) {
|
|
return EXTDEV_CARD_IN[unit] && is_card_uid_felica(EXTDEV_CARD[unit]) ? 2 : 1;
|
|
}
|
|
|
|
// gitadora always wants 1 apparently
|
|
return 1;
|
|
}
|
|
|
|
static long __cdecl cardunit_cardnumber_obfuscate_decode(void* a1, int a2, void* a3, void* a4) {
|
|
return 0;
|
|
}
|
|
|
|
static long __cdecl cardunit_cardnumber_obfuscate_encode(void* a1, int a2, void* a3, void* a4) {
|
|
return 0;
|
|
}
|
|
|
|
static int __cdecl cardunit_get_errorcount(int a1) {
|
|
return 0;
|
|
}
|
|
|
|
static int __cdecl cardunit_get_recvcount(int a1) {
|
|
return 0;
|
|
}
|
|
|
|
static int __cdecl cardunit_get_sendcount(int a1) {
|
|
return 0;
|
|
}
|
|
|
|
static const char* __cdecl cardunit_get_version(int a1) {
|
|
static const char* ver = "DUMMY\x04\x02\x00";
|
|
return ver;
|
|
}
|
|
|
|
static int __cdecl cardunit_check_version() {
|
|
return 1;
|
|
}
|
|
|
|
static int __cdecl cardunit_key_get(int unit) {
|
|
if (EXTDEV_CARDUNIT_KEY[unit].empty())
|
|
return -1;
|
|
return EXTDEV_CARDUNIT_KEY[unit].get();
|
|
}
|
|
|
|
static const char *__cdecl cardunit_key_str(int unit) {
|
|
if (EXTDEV_CARDUNIT_KEY_STR[unit].empty())
|
|
return nullptr;
|
|
return EXTDEV_CARDUNIT_KEY_STR[unit].get();
|
|
}
|
|
|
|
static int __cdecl cardunit_reset() {
|
|
return 0;
|
|
}
|
|
|
|
static void __cdecl cardunit_shutdown() {
|
|
}
|
|
|
|
static void __cdecl cardunit_sleep(int unit) {
|
|
}
|
|
|
|
static const size_t gitadora_button_mapping[] = {
|
|
games::gitadora::Buttons::Service,
|
|
games::gitadora::Buttons::Test,
|
|
games::gitadora::Buttons::Coin,
|
|
games::gitadora::Buttons::GuitarP1PickUp,
|
|
games::gitadora::Buttons::GuitarP1PickDown,
|
|
games::gitadora::Buttons::GuitarP1R,
|
|
games::gitadora::Buttons::GuitarP1G,
|
|
games::gitadora::Buttons::GuitarP1B,
|
|
games::gitadora::Buttons::GuitarP1Y,
|
|
games::gitadora::Buttons::GuitarP1P,
|
|
games::gitadora::Buttons::GuitarP1KnobUp,
|
|
games::gitadora::Buttons::GuitarP1KnobDown,
|
|
games::gitadora::Buttons::GuitarP1WailUp,
|
|
games::gitadora::Buttons::GuitarP1WailDown,
|
|
games::gitadora::Buttons::GuitarP2PickUp,
|
|
games::gitadora::Buttons::GuitarP2PickDown,
|
|
games::gitadora::Buttons::GuitarP2R,
|
|
games::gitadora::Buttons::GuitarP2G,
|
|
games::gitadora::Buttons::GuitarP2B,
|
|
games::gitadora::Buttons::GuitarP2Y,
|
|
games::gitadora::Buttons::GuitarP2P,
|
|
games::gitadora::Buttons::GuitarP2KnobUp,
|
|
games::gitadora::Buttons::GuitarP2KnobDown,
|
|
games::gitadora::Buttons::GuitarP2WailUp,
|
|
games::gitadora::Buttons::GuitarP2WailDown,
|
|
games::gitadora::Buttons::DrumHiHat,
|
|
games::gitadora::Buttons::DrumHiHatClosed,
|
|
games::gitadora::Buttons::DrumHiHatHalfOpen,
|
|
games::gitadora::Buttons::DrumSnare,
|
|
games::gitadora::Buttons::DrumHiTom,
|
|
games::gitadora::Buttons::DrumLowTom,
|
|
games::gitadora::Buttons::DrumRightCymbal,
|
|
games::gitadora::Buttons::DrumBassPedal,
|
|
games::gitadora::Buttons::DrumLeftCymbal,
|
|
games::gitadora::Buttons::DrumLeftPedal,
|
|
games::gitadora::Buttons::DrumFloorTom,
|
|
};
|
|
|
|
static const size_t gitadora_analog_mapping[] = {
|
|
games::gitadora::Analogs::GuitarP1WailX,
|
|
games::gitadora::Analogs::GuitarP1WailY,
|
|
games::gitadora::Analogs::GuitarP1WailZ,
|
|
games::gitadora::Analogs::GuitarP1Knob,
|
|
games::gitadora::Analogs::GuitarP2WailX,
|
|
games::gitadora::Analogs::GuitarP2WailY,
|
|
games::gitadora::Analogs::GuitarP2WailZ,
|
|
games::gitadora::Analogs::GuitarP2Knob,
|
|
};
|
|
|
|
static void __cdecl gfdm_unit_boot(unsigned int is_dm, unsigned int a2, unsigned int a3) {
|
|
}
|
|
|
|
static void __cdecl gfdm_unit2_boot(unsigned int is_dm, unsigned int a2, unsigned int a3) {
|
|
}
|
|
|
|
static int __cdecl gfdm_unit_boot_initialize() {
|
|
return 1;
|
|
}
|
|
|
|
static int __cdecl gfdm_unit2_boot_initialize() {
|
|
return 1;
|
|
}
|
|
|
|
static void *__cdecl gfdm_unit_get_button_p(void *a1, int a2, size_t player) {
|
|
memset(a1, 0, 64);
|
|
|
|
// irrelevant for drummania
|
|
if (is_drum())
|
|
return a1;
|
|
|
|
// get buttons
|
|
auto &buttons = games::gitadora::get_buttons();
|
|
auto &analogs = games::gitadora::get_analogs();
|
|
|
|
// X
|
|
((int *) a1)[4] = a2 == 1 ? 4080 : -4080;
|
|
if (analogs.at(player * 3 + 0).isSet())
|
|
((int *) a1)[4] = lroundf(Analogs::getState(
|
|
RI_MGR, analogs.at(gitadora_analog_mapping[player * 4 + 0])) * 8160.f) - 4080;
|
|
|
|
// Y
|
|
((int *) a1)[5] = 0;
|
|
if (analogs.at(player * 3 + 1).isSet())
|
|
((int *) a1)[5] = lroundf(Analogs::getState(
|
|
RI_MGR, analogs.at(gitadora_analog_mapping[player * 4 + 1])) * 8160.f) - 4080;
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[12 + 11 * (size_t) player])))
|
|
((int *) a1)[5] = -4080;
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[13 + 11 * (size_t) player])))
|
|
((int *) a1)[5] = 4080;
|
|
|
|
// Z
|
|
((int *) a1)[6] = 0;
|
|
if (analogs.at(player * 3 + 2).isSet())
|
|
((int *) a1)[6] = lroundf(Analogs::getState(
|
|
RI_MGR, analogs.at(gitadora_analog_mapping[player * 4 + 2])) * 8160.f) - 4080;
|
|
|
|
// return the same buffer
|
|
return a1;
|
|
}
|
|
|
|
static void *__cdecl gfdm_unit_get_button(void *a1, int a2) {
|
|
return gfdm_unit_get_button_p(a1, a2, 0);
|
|
}
|
|
|
|
static void *__cdecl gfdm_unit2_get_button(void *a1, int a2) {
|
|
return gfdm_unit_get_button_p(a1, a2, 1);
|
|
}
|
|
|
|
static bool __cdecl gfdm_unit_get_button_dm(int a1) {
|
|
return a1 == 9 || a1 == 8;
|
|
}
|
|
|
|
static bool __cdecl gfdm_unit2_get_button_dm(int a1) {
|
|
return a1 == 9 || a1 == 8;
|
|
}
|
|
|
|
static int __cdecl gfdm_unit_get_button_gf(int a1, int a2) {
|
|
return 0;
|
|
}
|
|
|
|
static int __cdecl gfdm_unit2_get_button_gf(int a1, int a2) {
|
|
return 0;
|
|
}
|
|
|
|
static long __cdecl gfdm_unit_get_dm_attack_border_value(int a1, int *a2) {
|
|
if (a1 >= 7)
|
|
return -1;
|
|
memcpy(a2, GFDM_DM_ATTACK_BORDER_VALUE, 7 * sizeof(int32_t));
|
|
return 0;
|
|
}
|
|
|
|
static long __cdecl gfdm_unit2_get_dm_attack_border_value(int a1, int *a2) {
|
|
if (a1 >= 7)
|
|
return -1;
|
|
memcpy(a2, GFDM_DM_ATTACK_BORDER_VALUE, 7 * sizeof(int32_t));
|
|
return 0;
|
|
}
|
|
|
|
static long __cdecl gfdm_unit_get_errorcount(int a1) {
|
|
return 0;
|
|
}
|
|
|
|
static long __cdecl gfdm_unit2_get_errorcount(int a1) {
|
|
return 0;
|
|
}
|
|
|
|
static long __cdecl gfdm_unit_get_input_p(int device, size_t player) {
|
|
long ret = 0;
|
|
|
|
// get buttons and analogs
|
|
auto &buttons = games::gitadora::get_buttons();
|
|
auto &analogs = games::gitadora::get_analogs();
|
|
|
|
// drum mania
|
|
if (is_drum()) {
|
|
|
|
// we don't want input for this
|
|
if (device == 1)
|
|
return 0;
|
|
|
|
// hi hat
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[25])) ||
|
|
Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[26])) ||
|
|
Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[27])))
|
|
{
|
|
ret |= 0x20;
|
|
}
|
|
|
|
// snare
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[28]))) {
|
|
ret |= 0x40;
|
|
}
|
|
|
|
// hi tom
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[29]))) {
|
|
ret |= 0x80;
|
|
}
|
|
|
|
// low tom
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[30]))) {
|
|
ret |= 0x100;
|
|
}
|
|
|
|
// right cymbal
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[31]))) {
|
|
ret |= 0x200;
|
|
}
|
|
|
|
// bass pedal
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[32]))) {
|
|
ret |= 0x800;
|
|
}
|
|
|
|
// left cymbal
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[33]))) {
|
|
ret |= 0x4000;
|
|
}
|
|
|
|
// left pedal
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[34]))) {
|
|
ret |= 0x8000;
|
|
}
|
|
|
|
// floor tom
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[35]))) {
|
|
ret |= 0x10000;
|
|
}
|
|
}
|
|
|
|
// guitar freaks
|
|
if (is_guitar()) {
|
|
auto offset = player * 11;
|
|
|
|
// pick up
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[3 + offset]))) {
|
|
if (!GFDM_GF_PICK_STATE_UP[player]) {
|
|
GFDM_GF_PICK_STATE_UP[player] = true;
|
|
ret |= 0x80 | 0x20;
|
|
}
|
|
} else {
|
|
GFDM_GF_PICK_STATE_UP[player] = false;
|
|
}
|
|
|
|
// pick down
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[4 + offset]))) {
|
|
if (!GFDM_GF_PICK_STATE_DOWN[player]) {
|
|
GFDM_GF_PICK_STATE_DOWN[player] = true;
|
|
ret |= 0x100 | 0x20;
|
|
}
|
|
} else {
|
|
GFDM_GF_PICK_STATE_DOWN[player] = false;
|
|
}
|
|
|
|
// button R
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[5 + offset]))) {
|
|
ret |= 0x200;
|
|
}
|
|
|
|
// button G
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[6 + offset]))) {
|
|
ret |= 0x400;
|
|
}
|
|
|
|
// button B
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[7 + offset]))) {
|
|
ret |= 0x800;
|
|
}
|
|
|
|
// button Y
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[8 + offset]))) {
|
|
ret |= 0x1000;
|
|
}
|
|
|
|
// button P
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[9 + offset]))) {
|
|
ret |= 0x4000;
|
|
}
|
|
|
|
// knob statics
|
|
static size_t knob[2]{};
|
|
static long knob_flags[] = {
|
|
0x8000,
|
|
0x18000,
|
|
0x10000,
|
|
0x30000,
|
|
0x38000,
|
|
0x28000
|
|
};
|
|
|
|
// knob up
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[10 + offset]))) {
|
|
if ((knob[player] >> 2) < 5) {
|
|
knob[player]++;
|
|
}
|
|
}
|
|
|
|
// knob down
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[11 + offset]))) {
|
|
if (knob[player] > 0) {
|
|
knob[player]--;
|
|
}
|
|
}
|
|
|
|
// get value from 0 to 5
|
|
size_t value = knob[player] >> 2;
|
|
|
|
// analog override
|
|
if (analogs.at(gitadora_analog_mapping[player * 4 + 3]).isSet()) {
|
|
value = (size_t) (Analogs::getState(
|
|
RI_MGR, analogs.at(gitadora_analog_mapping[player * 4 + 3])) * 5.999f);
|
|
}
|
|
|
|
// apply value
|
|
ret |= knob_flags[value];
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static long __cdecl gfdm_unit_get_input(int device) {
|
|
if (device > 0) {
|
|
return gfdm_unit_get_input_p(device, 1);
|
|
} else {
|
|
return gfdm_unit_get_input_p(device, 0);
|
|
}
|
|
}
|
|
|
|
static long __cdecl gfdm_unit2_get_input(int device) {
|
|
return gfdm_unit_get_input_p(device, 1);
|
|
}
|
|
|
|
static long __cdecl gfdm_unit_get_sensor_gf_p(int a1, int a2, size_t player) {
|
|
|
|
// return if it's actually drum mania
|
|
if (is_drum())
|
|
return 0;
|
|
|
|
// get buttons and analogs
|
|
auto &buttons = games::gitadora::get_buttons();
|
|
auto &analogs = games::gitadora::get_analogs();
|
|
|
|
// X
|
|
if (a2 == 0) {
|
|
|
|
// analog override
|
|
if (analogs.at(gitadora_analog_mapping[player * 3 + 0]).isSet()) {
|
|
return lroundf(Analogs::getState(
|
|
RI_MGR, analogs.at(gitadora_analog_mapping[player * 4 + 0])) * 8160.f) - 4080;
|
|
}
|
|
|
|
// default
|
|
return a1 == 1 ? 4080 : -4080;
|
|
}
|
|
|
|
// Y
|
|
if (a2 == 1) {
|
|
|
|
// analog override
|
|
if (analogs.at(player * 3 + 1).isSet()) {
|
|
return lroundf(Analogs::getState(
|
|
RI_MGR, analogs.at(gitadora_analog_mapping[player * 4 + 1])) * 8160.f) - 4080;
|
|
}
|
|
|
|
// variables
|
|
long ret = 0;
|
|
size_t offset = (size_t) player * 11;
|
|
|
|
// wail up
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[12 + offset]))) {
|
|
ret -= 4080;
|
|
}
|
|
|
|
// wail down
|
|
if (Buttons::getState(RI_MGR, buttons.at(gitadora_button_mapping[13 + offset]))) {
|
|
ret += 4080;
|
|
}
|
|
|
|
// return value
|
|
return ret;
|
|
}
|
|
|
|
// Z
|
|
if (a2 == 2) {
|
|
|
|
// analog override
|
|
if (analogs.at(gitadora_analog_mapping[player * 3 + 2]).isSet()) {
|
|
return lroundf(Analogs::getState(
|
|
RI_MGR, analogs.at(gitadora_analog_mapping[player * 4 + 2])) * 8160.f) - 4080;
|
|
}
|
|
|
|
// default
|
|
return 0;
|
|
}
|
|
|
|
// unknown sensor
|
|
return 0;
|
|
}
|
|
|
|
static long __cdecl gfdm_unit_get_sensor_gf(int a1, int a2) {
|
|
return gfdm_unit_get_sensor_gf_p(a1, a2, 0);
|
|
}
|
|
|
|
static long __cdecl gfdm_unit2_get_sensor_gf(int a1, int a2) {
|
|
return gfdm_unit_get_sensor_gf_p(a1, a2, 1);
|
|
}
|
|
|
|
static int __cdecl gfdm_unit_get_status(int a1) {
|
|
return 1;
|
|
}
|
|
|
|
static int __cdecl gfdm_unit2_get_status(int a1) {
|
|
return 1;
|
|
}
|
|
|
|
static int __cdecl gfdm_unit_get_stream_errorcount(int a1) {
|
|
return 0;
|
|
}
|
|
|
|
static int __cdecl gfdm_unit2_get_stream_errorcount(int a1) {
|
|
return 0;
|
|
}
|
|
|
|
static const char *__cdecl gfdm_unit_get_version() {
|
|
static const char* ver = "DUMMY\x04\x02\x00";
|
|
return ver;
|
|
}
|
|
|
|
static const char *__cdecl gfdm_unit2_get_version() {
|
|
static const char* ver = "DUMMY\x04\x02\x00";
|
|
return ver;
|
|
}
|
|
|
|
static long __cdecl gfdm_unit_reset() {
|
|
return 0;
|
|
}
|
|
|
|
static long __cdecl gfdm_unit2_reset() {
|
|
return 0;
|
|
}
|
|
|
|
static void __cdecl gfdm_unit_reset_stream_errorcount(int a1) {
|
|
}
|
|
|
|
static void __cdecl gfdm_unit2_reset_stream_errorcount(int a1) {
|
|
}
|
|
|
|
static int __cdecl gfdm_unit_send_motor_value(size_t motor, uint8_t value) {
|
|
if (motor == 0) {
|
|
auto &lights = games::gitadora::get_lights();
|
|
auto &light = lights.at(games::gitadora::Lights::GuitarP1Motor);
|
|
GameAPI::Lights::writeLight(RI_MGR, light, value / 127.f);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int __cdecl gfdm_unit2_send_motor_value(size_t motor, uint8_t value) {
|
|
if (motor == 0) {
|
|
auto &lights = games::gitadora::get_lights();
|
|
auto &light = lights.at(games::gitadora::Lights::GuitarP2Motor);
|
|
GameAPI::Lights::writeLight(RI_MGR, light, value / 127.f);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void __cdecl gfdm_unit_set_dm_attack_border_value(int32_t *a1) {
|
|
memcpy(GFDM_DM_ATTACK_BORDER_VALUE, a1, 7 * sizeof(int32_t));
|
|
}
|
|
|
|
static void __cdecl gfdm_unit2_set_dm_attack_border_value(int32_t *a1) {
|
|
memcpy(GFDM_DM_ATTACK_BORDER_VALUE, a1, 7 * sizeof(int32_t));
|
|
}
|
|
|
|
static void __cdecl gfdm_unit_shutdown() {
|
|
}
|
|
|
|
static void __cdecl gfdm_unit2_shutdown() {
|
|
}
|
|
|
|
static void __cdecl gfdm_unit_update() {
|
|
}
|
|
|
|
static void __cdecl gfdm_unit2_update() {
|
|
}
|
|
|
|
static const char* __cdecl led_get_version() {
|
|
static const char* ver = "DUMMY\x04\x02\x00";
|
|
return ver;
|
|
}
|
|
|
|
static void __cdecl led_unit_boot(int a1, int a2) {
|
|
}
|
|
|
|
static int __cdecl led_unit_boot_initialize() {
|
|
return 0;
|
|
}
|
|
|
|
static int __cdecl led_unit_get_errorcount(int a1) {
|
|
return 0;
|
|
}
|
|
|
|
static int __cdecl led_unit_get_status() {
|
|
return 1;
|
|
}
|
|
|
|
static int __cdecl led_unit_reset() {
|
|
return 0;
|
|
}
|
|
|
|
static void set_led_state(games::gitadora::Lights::gitadora_lights_t light, bool led_on) {
|
|
auto &lights = games::gitadora::get_lights();
|
|
GameAPI::Lights::writeLight(RI_MGR, lights.at(light), (led_on ? 1.f : 0.f));
|
|
}
|
|
|
|
static void set_led_value(games::gitadora::Lights::gitadora_lights_t light, uint8_t value) {
|
|
auto &lights = games::gitadora::get_lights();
|
|
GameAPI::Lights::writeLight(RI_MGR, lights.at(light), value / 128.f);
|
|
}
|
|
|
|
static unsigned int __cdecl led_unit_send_custom1(int index, uint8_t *data) {
|
|
return 0;
|
|
}
|
|
|
|
struct ExtDevLight {
|
|
int data_index;
|
|
games::gitadora::Lights::gitadora_lights_t light;
|
|
ExtDevLight(
|
|
int data_index, games::gitadora::Lights::gitadora_lights_t light) :
|
|
data_index(data_index), light(light) {}
|
|
};
|
|
|
|
// GITADORA series
|
|
static unsigned int __cdecl led_unit_send_custom2(int index, uint8_t *data) {
|
|
#ifdef SPICE64
|
|
return gitadora_led_common(index, data);
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
// XG series
|
|
static long __cdecl led_unit_send_direct(long index, uint8_t *data) {
|
|
#ifdef SPICE64
|
|
return 0;
|
|
#else
|
|
return gitadora_led_common(index, data);
|
|
#endif
|
|
}
|
|
|
|
static long __cdecl gitadora_led_common(long index, uint8_t *data) {
|
|
// log_info("extdev::led", "gitadora_led_common {}", index);
|
|
// for (size_t i = 0; i < 24; i += 3) {
|
|
// log_info("extdev::led", "gitadora_led_common ... {} {} {}", data[i], data[i+1], data[i+2]);
|
|
// }
|
|
|
|
if (is_drum()) {
|
|
// Drum: index is always 0, data array has 24 elements, each value ranging [0, 128]
|
|
static ExtDevLight mapping_dm[] = {
|
|
{0, games::gitadora::Lights::DrumWooferR},
|
|
{1, games::gitadora::Lights::DrumWooferG},
|
|
{2, games::gitadora::Lights::DrumWooferB},
|
|
|
|
{3, games::gitadora::Lights::DrumSpotRearLeft},
|
|
{7, games::gitadora::Lights::DrumSpotRearRight},
|
|
{11, games::gitadora::Lights::SpotFrontLeft},
|
|
|
|
{12, games::gitadora::Lights::DrumStageR},
|
|
{13, games::gitadora::Lights::DrumStageG},
|
|
{14, games::gitadora::Lights::DrumStageB},
|
|
|
|
{15, games::gitadora::Lights::SpotCenterLeft},
|
|
{19, games::gitadora::Lights::SpotCenterRight},
|
|
{23, games::gitadora::Lights::SpotFrontRight}
|
|
};
|
|
if (index == 0) {
|
|
for (const auto &map : mapping_dm) {
|
|
set_led_value(map.light, data[map.data_index]);
|
|
}
|
|
}
|
|
} else {
|
|
// Guitar: index is {0,1,2}, data array has 24 elements, each value ranging [0, 128]
|
|
static ExtDevLight mapping0[] = {
|
|
{0, games::gitadora::Lights::GuitarLowerLeftR},
|
|
{1, games::gitadora::Lights::GuitarLowerLeftG},
|
|
{2, games::gitadora::Lights::GuitarLowerLeftB},
|
|
|
|
{3, games::gitadora::Lights::SpotFrontLeft},
|
|
{7, games::gitadora::Lights::SpotCenterLeft},
|
|
|
|
{8, games::gitadora::Lights::GuitarLowerRightR},
|
|
{9, games::gitadora::Lights::GuitarLowerRightG},
|
|
{10, games::gitadora::Lights::GuitarLowerRightB},
|
|
|
|
{11, games::gitadora::Lights::SpotCenterRight},
|
|
{15, games::gitadora::Lights::SpotFrontRight}
|
|
};
|
|
|
|
static ExtDevLight mapping1[] = {
|
|
{0, games::gitadora::Lights::GuitarLeftSpeakerUpperR},
|
|
{1, games::gitadora::Lights::GuitarLeftSpeakerUpperG},
|
|
{2, games::gitadora::Lights::GuitarLeftSpeakerUpperB},
|
|
|
|
{4, games::gitadora::Lights::GuitarLeftSpeakerMidUpLeftR},
|
|
{5, games::gitadora::Lights::GuitarLeftSpeakerMidUpLeftG},
|
|
{6, games::gitadora::Lights::GuitarLeftSpeakerMidUpLeftB},
|
|
|
|
{8, games::gitadora::Lights::GuitarLeftSpeakerMidUpRightR},
|
|
{9, games::gitadora::Lights::GuitarLeftSpeakerMidUpRightG},
|
|
{10, games::gitadora::Lights::GuitarLeftSpeakerMidUpRightB},
|
|
|
|
{12, games::gitadora::Lights::GuitarLeftSpeakerMidLowLeftR},
|
|
{13, games::gitadora::Lights::GuitarLeftSpeakerMidLowLeftG},
|
|
{14, games::gitadora::Lights::GuitarLeftSpeakerMidLowLeftB},
|
|
|
|
{16, games::gitadora::Lights::GuitarLeftSpeakerMidLowRightR},
|
|
{17, games::gitadora::Lights::GuitarLeftSpeakerMidLowRightG},
|
|
{18, games::gitadora::Lights::GuitarLeftSpeakerMidLowRightB},
|
|
|
|
{20, games::gitadora::Lights::GuitarLeftSpeakerLowerR},
|
|
{21, games::gitadora::Lights::GuitarLeftSpeakerLowerG},
|
|
{22, games::gitadora::Lights::GuitarLeftSpeakerLowerB}
|
|
};
|
|
|
|
static ExtDevLight mapping2[] = {
|
|
{0, games::gitadora::Lights::GuitarRightSpeakerUpperR},
|
|
{1, games::gitadora::Lights::GuitarRightSpeakerUpperG},
|
|
{2, games::gitadora::Lights::GuitarRightSpeakerUpperB},
|
|
|
|
{4, games::gitadora::Lights::GuitarRightSpeakerMidUpLeftR},
|
|
{5, games::gitadora::Lights::GuitarRightSpeakerMidUpLeftG},
|
|
{6, games::gitadora::Lights::GuitarRightSpeakerMidUpLeftB},
|
|
|
|
{8, games::gitadora::Lights::GuitarRightSpeakerMidUpRightR},
|
|
{9, games::gitadora::Lights::GuitarRightSpeakerMidUpRightG},
|
|
{10, games::gitadora::Lights::GuitarRightSpeakerMidUpRightB},
|
|
|
|
{12, games::gitadora::Lights::GuitarRightSpeakerMidLowLeftR},
|
|
{13, games::gitadora::Lights::GuitarRightSpeakerMidLowLeftG},
|
|
{14, games::gitadora::Lights::GuitarRightSpeakerMidLowLeftB},
|
|
|
|
{16, games::gitadora::Lights::GuitarRightSpeakerMidLowRightR},
|
|
{17, games::gitadora::Lights::GuitarRightSpeakerMidLowRightG},
|
|
{18, games::gitadora::Lights::GuitarRightSpeakerMidLowRightB},
|
|
|
|
{20, games::gitadora::Lights::GuitarRightSpeakerLowerR},
|
|
{21, games::gitadora::Lights::GuitarRightSpeakerLowerG},
|
|
{22, games::gitadora::Lights::GuitarRightSpeakerLowerB}
|
|
};
|
|
|
|
switch (index) {
|
|
case 0:
|
|
for (const auto &map : mapping0) {
|
|
set_led_value(map.light, data[map.data_index]);
|
|
}
|
|
break;
|
|
case 1:
|
|
for (const auto &map : mapping1) {
|
|
set_led_value(map.light, data[map.data_index]);
|
|
}
|
|
break;
|
|
case 2:
|
|
for (const auto &map : mapping2) {
|
|
set_led_value(map.light, data[map.data_index]);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void __cdecl led_unit_shutdown() {
|
|
}
|
|
|
|
static void __cdecl led_unit_update() {
|
|
}
|
|
|
|
static int __cdecl sci_boot() {
|
|
return 1;
|
|
}
|
|
|
|
static int __cdecl sci_clear_error(int a1) {
|
|
return 0;
|
|
}
|
|
|
|
static int __cdecl sci_close(int a1) {
|
|
return 0;
|
|
}
|
|
|
|
static int __cdecl sci_flush() {
|
|
return 0;
|
|
}
|
|
|
|
static int __cdecl sci_flush_complete() {
|
|
return 1;
|
|
}
|
|
|
|
static int __cdecl sci_get_error(int a1) {
|
|
return 0;
|
|
}
|
|
|
|
static int __cdecl sci_gets(int a1, int a2, int a3) {
|
|
return 0;
|
|
}
|
|
|
|
static int __cdecl sci_print_error(int a1, void *a2) {
|
|
return 0;
|
|
}
|
|
|
|
static int __cdecl sci_puts(int a1, int a2, int a3) {
|
|
return 0;
|
|
}
|
|
|
|
static int __cdecl sci_set_linebreak(int a1, int a2) {
|
|
return 0;
|
|
}
|
|
|
|
static int __cdecl sci_setparam(int a1, int a2, int a3, char a4) {
|
|
return 1;
|
|
}
|
|
|
|
static void __cdecl dm_output_set_padled(LED_INDEX index, bool led_on) {
|
|
games::gitadora::Lights::gitadora_lights_t lights[] = {
|
|
games::gitadora::Lights::DrumHighTom,
|
|
games::gitadora::Lights::DrumLowTom,
|
|
games::gitadora::Lights::DrumSnare,
|
|
games::gitadora::Lights::DrumFloorTom,
|
|
games::gitadora::Lights::DrumLeftCymbal,
|
|
games::gitadora::Lights::DrumRightCymbal,
|
|
games::gitadora::Lights::DrumHiHat
|
|
};
|
|
|
|
// log_info("gitadora", "dm_output_set_padled {} {}", index, led_on);
|
|
|
|
if (index < std::size(lights)) {
|
|
set_led_state(lights[index], led_on);
|
|
}
|
|
}
|
|
|
|
static void __cdecl dm_output_set_startled(bool led_on) {
|
|
set_led_state(games::gitadora::Lights::P1MenuStart, led_on);
|
|
}
|
|
|
|
static void __cdecl dm_output_set_up_down(bool led_on) {
|
|
set_led_state(games::gitadora::Lights::P1MenuUpDown, led_on);
|
|
}
|
|
|
|
static void __cdecl dm_output_set_left_right(bool led_on) {
|
|
set_led_state(games::gitadora::Lights::P1MenuLeftRight, led_on);
|
|
}
|
|
|
|
static void __cdecl dm_output_set_help(bool led_on) {
|
|
set_led_state(games::gitadora::Lights::P1MenuHelp, led_on);
|
|
}
|
|
|
|
static void __cdecl gf_output_set_startlamp(LED_INDEX index, bool led_on) {
|
|
if (index == 0) {
|
|
set_led_state(games::gitadora::Lights::P1MenuStart, led_on);
|
|
} else if (index == 1) {
|
|
set_led_state(games::gitadora::Lights::P2MenuStart, led_on);
|
|
}
|
|
}
|
|
|
|
static void __cdecl gf_output_set_up_down(LED_INDEX index, bool led_on) {
|
|
if (index == 0) {
|
|
set_led_state(games::gitadora::Lights::P1MenuUpDown, led_on);
|
|
} else if (index == 1) {
|
|
set_led_state(games::gitadora::Lights::P2MenuUpDown, led_on);
|
|
}
|
|
}
|
|
|
|
static void __cdecl gf_output_set_left_right(LED_INDEX index, bool led_on) {
|
|
if (index == 0) {
|
|
set_led_state(games::gitadora::Lights::P1MenuLeftRight, led_on);
|
|
} else if (index == 1) {
|
|
set_led_state(games::gitadora::Lights::P2MenuLeftRight, led_on);
|
|
}
|
|
}
|
|
|
|
static void __cdecl gf_output_set_help(LED_INDEX index, bool led_on) {
|
|
if (index == 0) {
|
|
set_led_state(games::gitadora::Lights::P1MenuHelp, led_on);
|
|
} else if (index == 1) {
|
|
set_led_state(games::gitadora::Lights::P2MenuHelp, led_on);
|
|
}
|
|
}
|
|
|
|
void extdev_attach() {
|
|
|
|
// get instance
|
|
for (auto &name : EXTDEV_INSTANCE_NAMES) {
|
|
auto instance = libutils::try_module(name);
|
|
if (instance) {
|
|
EXTDEV_INSTANCE = instance;
|
|
} else {
|
|
continue;
|
|
}
|
|
|
|
// card unit
|
|
detour::inline_hook((void *) cardunit_boot2, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_boot2", "?cardunit_boot2@@YAXHHH@Z"}));
|
|
detour::inline_hook((void *) cardunit_boot, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_boot", "?cardunit_boot@@YAXHH@Z"}));
|
|
detour::inline_hook((void *) cardunit_boot_initialize, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_boot_initialize", "?cardunit_boot_initialize@@YAHXZ"}));
|
|
detour::inline_hook((void *) cardunit_boot_no_slot_type, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_boot_no_slot_type", "?cardunit_boot_no_slot_type@@YAXHH@Z"}));
|
|
detour::inline_hook((void *) cardunit_card_eject, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_card_eject", "?cardunit_card_eject@@YAXH@Z"}));
|
|
detour::inline_hook((void *) cardunit_card_eject_complete, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_card_eject_complete", "?cardunit_card_eject_complete@@YAHH@Z"}));
|
|
detour::inline_hook((void *) cardunit_card_eject_wait, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_card_eject_wait", "?cardunit_card_eject_wait@@YAHH@Z"}));
|
|
detour::inline_hook((void *) cardunit_card_read2, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_card_read2",
|
|
"?cardunit_card_read2@@YAHHQAEPAH@Z",
|
|
"?cardunit_card_read2@@YAHHQEAEPEAH@Z"}));
|
|
detour::inline_hook((void *) cardunit_card_read, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_card_read", "?cardunit_card_read@@YAHHQAE@Z"}));
|
|
detour::inline_hook((void *) cardunit_card_ready, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_card_ready", "?cardunit_card_ready@@YAXH@Z"}));
|
|
detour::inline_hook((void *) cardunit_card_sensor, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_card_sensor", "?cardunit_card_sensor@@YAHH@Z"}));
|
|
detour::inline_hook((void *) cardunit_card_sensor_raw, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_card_sensor_raw", "?cardunit_card_sensor_raw@@YAHH@Z"}));
|
|
detour::inline_hook((void *) cardunit_update, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_update", "?cardunit_update@@YAXXZ"}));
|
|
detour::inline_hook((void *) cardunit_get_status, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_get_status", "?cardunit_get_status@@YAHH@Z"}));
|
|
detour::inline_hook((void *) cardunit_cardnumber_obfuscate_decode, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_cardnumber_obfuscate_decode",
|
|
"?cardunit_cardnumber_obfuscate_decode@@YAHPEADHPEBD1@Z"}));
|
|
detour::inline_hook((void *) cardunit_cardnumber_obfuscate_encode, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_cardnumber_obfuscate_encode",
|
|
"?cardunit_cardnumber_obfuscate_encode@@YAHPEADHPEBD1@Z"}));
|
|
detour::inline_hook((void *) cardunit_get_errorcount, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_get_errorcount", "?cardunit_get_errorcount@@YAHH@Z"}));
|
|
detour::inline_hook((void *) cardunit_get_recvcount, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_get_recvcount", "?cardunit_get_recvcount@@YAHH@Z"}));
|
|
detour::inline_hook((void *) cardunit_get_sendcount, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_get_sendcount", "?cardunit_get_sendcount@@YAHH@Z"}));
|
|
detour::inline_hook((void *) cardunit_get_version, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_get_version",
|
|
"?cardunit_get_version@@YAPBUcardunit_firm_version@@H@Z"}));
|
|
detour::inline_hook((void *) cardunit_check_version, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_check_version", "?cardunit_check_version@@YAEH@Z"}));
|
|
detour::inline_hook((void *) cardunit_key_get, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_key_get", "?cardunit_key_get@@YAHH@Z"}));
|
|
detour::inline_hook((void *) cardunit_key_str, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_key_str", "?cardunit_key_str@@YAPBDH@Z"}));
|
|
detour::inline_hook((void *) cardunit_reset, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_reset", "?cardunit_reset@@YAHXZ"}));
|
|
detour::inline_hook((void *) cardunit_shutdown, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_shutdown", "?cardunit_shutdown@@YAXXZ"}));
|
|
detour::inline_hook((void *) cardunit_sleep, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"cardunit_sleep", "?cardunit_sleep@@YAXH@Z"}));
|
|
|
|
// GFDM UNIT
|
|
detour::inline_hook((void *) gfdm_unit_boot, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit_boot",
|
|
"?gfdm_unit_boot@@YAXW4UNIT_TYPE@@HH@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit_boot_initialize, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit_boot_initialize",
|
|
"?gfdm_unit_boot_initialize@@YAHXZ"}));
|
|
detour::inline_hook((void *) gfdm_unit_get_button, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit_get_button",
|
|
"?gfdm_unit_get_button@@YA?AUunit_button_t@@H@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit_get_button_dm, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit_get_button_dm",
|
|
"?gfdm_unit_get_button_dm@@YAHW4DM_BUTTON_DEFINITION@@@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit_get_button_gf, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit_get_button_gf",
|
|
"?gfdm_unit_get_button_gf@@YAHW4UNIT_NO@@W4GF_BUTTON_DEFINITION@@@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit_get_dm_attack_border_value, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit_get_dm_attack_border_value",
|
|
"?gfdm_unit_get_dm_attack_border_value@@YAHHPEAH@Z",
|
|
"?gfdm_unit_get_dm_attack_border_value@@YAHHPAH@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit_get_errorcount, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit_get_errorcount",
|
|
"?gfdm_unit_get_errorcount@@YAHH@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit_get_input, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit_get_input",
|
|
"?gfdm_unit_get_input@@YAIH@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit_get_sensor_gf, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit_get_sensor_gf",
|
|
"?gfdm_unit_get_sensor_gf@@YAHW4UNIT_NO@@W4GF_SENSOR_DEFINITION@@@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit_get_status, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit_get_status",
|
|
"?gfdm_unit_get_status@@YAHH@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit_get_stream_errorcount, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit_get_stream_errorcount",
|
|
"?gfdm_unit_get_stream_errorcount@@YAHH@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit_get_version, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit_get_version",
|
|
"?gfdm_unit_get_version@@YAPEBUfirm_version@@H@Z",
|
|
"?gfdm_unit_get_version@@YAPBUfirm_version@@H@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit_reset, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit_reset",
|
|
"?gfdm_unit_reset@@YAHXZ"}));
|
|
detour::inline_hook((void *) gfdm_unit_reset_stream_errorcount, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit_reset_stream_errorcount",
|
|
"?gfdm_unit_reset_stream_errorcount@@YAXH@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit_send_motor_value, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit_send_motor_value",
|
|
"?gfdm_unit_send_motor_value@@YAIHE@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit_set_dm_attack_border_value, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit_set_dm_attack_border_value",
|
|
"?gfdm_unit_set_dm_attack_border_value@@YAXQEAH@Z",
|
|
"?gfdm_unit_set_dm_attack_border_value@@YAXQAH@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit_shutdown, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit_shutdown",
|
|
"?gfdm_unit_shutdown@@YAXXZ"}));
|
|
detour::inline_hook((void *) gfdm_unit_update, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit_update",
|
|
"?gfdm_unit_update@@YAXXZ"}));
|
|
|
|
// GFDM UNIT 2
|
|
detour::inline_hook((void *) gfdm_unit2_boot, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit2_boot",
|
|
"?gfdm_unit2_boot@@YAXW4UNIT_TYPE@@HH@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit2_boot_initialize, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit2_boot_initialize",
|
|
"?gfdm_unit2_boot_initialize@@YAHXZ"}));
|
|
detour::inline_hook((void *) gfdm_unit2_get_button, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit2_get_button",
|
|
"?gfdm_unit2_get_button@@YA?AUunit_button_t@@H@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit2_get_button_dm, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit2_get_button_dm",
|
|
"?gfdm_unit2_get_button_dm@@YAHW4DM_BUTTON_DEFINITION@@@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit2_get_button_gf, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit2_get_button_gf",
|
|
"?gfdm_unit2_get_button_gf@@YAHW4UNIT_NO@@W4GF_BUTTON_DEFINITION@@@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit2_get_dm_attack_border_value, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit2_get_dm_attack_border_value",
|
|
"?gfdm_unit2_get_dm_attack_border_value@@YAHHPEAH@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit2_get_errorcount, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit2_get_errorcount",
|
|
"?gfdm_unit2_get_errorcount@@YAHH@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit2_get_input, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit2_get_input",
|
|
"?gfdm_unit2_get_input@@YAIH@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit2_get_sensor_gf, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit2_get_sensor_gf",
|
|
"?gfdm_unit2_get_sensor_gf@@YAHW4UNIT_NO@@W4GF_SENSOR_DEFINITION@@@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit2_get_status, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit2_get_status",
|
|
"?gfdm_unit2_get_status@@YAHH@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit2_get_stream_errorcount, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit2_get_stream_errorcount",
|
|
"?gfdm_unit2_get_stream_errorcount@@YAHH@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit2_get_version, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit2_get_version",
|
|
"?gfdm_unit2_get_version@@YAPEBUfirm_version@@H@Z",
|
|
"?gfdm_unit2_get_version@@YAPBUfirm_version@@H@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit2_reset, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit2_reset",
|
|
"?gfdm_unit2_reset@@YAHXZ"}));
|
|
detour::inline_hook((void *) gfdm_unit2_reset_stream_errorcount, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit2_reset_stream_errorcount",
|
|
"?gfdm_unit2_reset_stream_errorcount@@YAXH@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit2_send_motor_value, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit2_send_motor_value",
|
|
"?gfdm_unit2_send_motor_value@@YAIHE@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit2_set_dm_attack_border_value, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit2_set_dm_attack_border_value",
|
|
"?gfdm_unit2_set_dm_attack_border_value@@YAXQEAH@Z"}));
|
|
detour::inline_hook((void *) gfdm_unit2_shutdown, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit2_shutdown",
|
|
"?gfdm_unit2_shutdown@@YAXXZ"}));
|
|
detour::inline_hook((void *) gfdm_unit2_update, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"gfdm_unit2_update",
|
|
"?gfdm_unit2_update@@YAXXZ"}));
|
|
|
|
// led unit
|
|
detour::inline_hook((void *) led_get_version, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"led_get_version",
|
|
"?led_get_version@@YAPEBUfirm_version@@H@Z",
|
|
"?led_get_version@@YAPBUfirm_version@@H@Z"}));
|
|
detour::inline_hook((void *) led_unit_boot, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"led_unit_boot",
|
|
"?led_unit_boot@@YAXHH@Z"}));
|
|
detour::inline_hook((void *) led_unit_boot_initialize, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"led_unit_boot_initialize",
|
|
"?led_unit_boot_initialize@@YAHXZ"}));
|
|
detour::inline_hook((void *) led_unit_get_errorcount, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"led_unit_get_errorcount",
|
|
"?led_unit_get_errorcount@@YAHH@Z"}));
|
|
detour::inline_hook((void *) led_unit_get_status, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"led_unit_get_status",
|
|
"?led_unit_get_status@@YAHH@Z"}));
|
|
detour::inline_hook((void *) led_unit_reset, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"led_unit_reset",
|
|
"?led_unit_reset@@YAHXZ"}));
|
|
detour::inline_hook((void *) led_unit_send_custom1, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"led_unit_send_custom1",
|
|
"?led_unit_send_custom1@@YAIHQEAE@Z",
|
|
"?led_unit_send_custom1@@YAIHQAE@Z"}));
|
|
detour::inline_hook((void *) led_unit_send_custom2, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"led_unit_send_custom2",
|
|
"?led_unit_send_custom2@@YAIHQEAE@Z",
|
|
"?led_unit_send_custom2@@YAIHQAE@Z"}));
|
|
detour::inline_hook((void *) led_unit_send_direct, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"led_unit_send_direct",
|
|
"?led_unit_send_direct@@YAIHQEAE@Z",
|
|
"?led_unit_send_direct@@YAIHQAE@Z"}));
|
|
detour::inline_hook((void *) led_unit_shutdown, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"led_unit_shutdown",
|
|
"?led_unit_shutdown@@YAXXZ"}));
|
|
detour::inline_hook((void *) led_unit_update, libutils::try_proc_list(
|
|
EXTDEV_INSTANCE, {"led_unit_update",
|
|
"?led_unit_update@@YAXXZ"}));
|
|
|
|
// SCI
|
|
detour::inline_hook((void *) sci_boot, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "sci_boot"));
|
|
detour::inline_hook((void *) sci_clear_error, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "sci_clear_error"));
|
|
detour::inline_hook((void *) sci_close, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "sci_close"));
|
|
detour::inline_hook((void *) sci_flush, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "sci_flush"));
|
|
detour::inline_hook((void *) sci_flush_complete, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "sci_flush_complete"));
|
|
detour::inline_hook((void *) sci_get_error, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "sci_get_error"));
|
|
detour::inline_hook((void *) sci_gets, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "sci_gets"));
|
|
detour::inline_hook((void *) sci_print_error, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "sci_print_error"));
|
|
detour::inline_hook((void *) sci_puts, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "sci_puts"));
|
|
detour::inline_hook((void *) sci_set_linebreak, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "sci_set_linebreak"));
|
|
detour::inline_hook((void *) sci_setparam, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "sci_setparam"));
|
|
|
|
// libshare-pj.dll - dm_output
|
|
detour::inline_hook((void *) dm_output_set_padled, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "dm_output_set_padled"));
|
|
detour::inline_hook((void *) dm_output_set_startled, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "dm_output_set_startled"));
|
|
detour::inline_hook((void *) dm_output_set_up_down, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "dm_output_set_up_down"));
|
|
detour::inline_hook((void *) dm_output_set_left_right, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "dm_output_set_left_right"));
|
|
detour::inline_hook((void *) dm_output_set_help, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "dm_output_set_help"));
|
|
|
|
// libshare-pj.dll - gf_output
|
|
detour::inline_hook((void *) gf_output_set_startlamp, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "gf_output_set_startlamp"));
|
|
detour::inline_hook((void *) gf_output_set_up_down, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "gf_output_set_up_down"));
|
|
detour::inline_hook((void *) gf_output_set_left_right, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "gf_output_set_left_right"));
|
|
detour::inline_hook((void *) gf_output_set_help, libutils::try_proc(
|
|
EXTDEV_INSTANCE, "gf_output_set_help"));
|
|
}
|
|
}
|
|
|
|
void extdev_detach() {
|
|
// TODO
|
|
}
|