ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Attachment: Use std::array over C arrays

This commit is contained in:
Lioncash 2017-01-23 00:10:25 -05:00
parent 4b2f40a634
commit c87ee2a00e
12 changed files with 131 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
Source/Core/Core/HW/WiimoteEmu/Attachment/Attachment.cpp
View File

@ -2,45 +2,45 @@
// Licensed under GPLv2+
// Refer to the license.txt file included.
#include "Core/HW/WiimoteEmu/Attachment/Attachment.h"
#include <algorithm>
#include <array>
#include <cstring>
#include "Common/Common.h"
#include "Common/CommonTypes.h"
#include "Core/HW/WiimoteEmu/Attachment/Attachment.h"
#include "Core/HW/WiimoteEmu/WiimoteEmu.h"
namespace WiimoteEmu
{
// Extension device IDs to be written to the last bytes of the extension reg
// The id for nothing inserted
static const u8 nothing_id[] = {0x00, 0x00, 0x00, 0x00, 0x2e, 0x2e};
constexpr std::array<u8, 6> nothing_id{{0x00, 0x00, 0x00, 0x00, 0x2e, 0x2e}};
// The id for a partially inserted extension (currently unused)
UNUSED static const u8 partially_id[] = {0x00, 0x00, 0x00, 0x00, 0xff, 0xff};
UNUSED constexpr std::array<u8, 6> partially_id{{0x00, 0x00, 0x00, 0x00, 0xff, 0xff}};
Attachment::Attachment(const char* const _name, WiimoteEmu::ExtensionReg& _reg)
: name(_name), reg(_reg)
Attachment::Attachment(const char* const name, ExtensionReg& reg) : m_name(name), m_reg(reg)
{
memset(id, 0, sizeof(id));
memset(calibration, 0, sizeof(calibration));
}
None::None(WiimoteEmu::ExtensionReg& _reg) : Attachment("None", _reg)
None::None(ExtensionReg& reg) : Attachment("None", reg)
{
// set up register
memcpy(&id, nothing_id, sizeof(nothing_id));
m_id = nothing_id;
}
std::string Attachment::GetName() const
{
return name;
return m_name;
}
void Attachment::Reset()
{
// set up register
memset(&reg, 0, WIIMOTE_REG_EXT_SIZE);
memcpy(&reg.constant_id, id, sizeof(id));
memcpy(&reg.calibration, calibration, sizeof(calibration));
m_reg = {};
std::copy(m_id.cbegin(), m_id.cend(), m_reg.constant_id);
std::copy(m_calibration.cbegin(), m_calibration.cend(), m_reg.calibration);
}
}

15
Source/Core/Core/HW/WiimoteEmu/Attachment/Attachment.h
View File

@ -4,6 +4,9 @@
#pragma once
#include <array>
#include <string>
#include "Common/CommonTypes.h"
#include "InputCommon/ControllerEmu.h"
namespace WiimoteEmu
@ -13,7 +16,7 @@ struct ExtensionReg;
class Attachment : public ControllerEmu
{
public:
Attachment(const char* const _name, WiimoteEmu::ExtensionReg& _reg);
Attachment(const char* const name, ExtensionReg& reg);
virtual void GetState(u8* const data) {}
virtual bool IsButtonPressed() const { return false; }
@ -24,17 +27,17 @@ protected:
// Default radius for attachment analog sticks.
static constexpr ControlState DEFAULT_ATTACHMENT_STICK_RADIUS = 1.0;
u8 id[6];
u8 calibration[0x10];
std::array<u8, 6> m_id{};
std::array<u8, 0x10> m_calibration{};
private:
const char* const name;
WiimoteEmu::ExtensionReg& reg;
const char* const m_name;
ExtensionReg& m_reg;
};
class None : public Attachment
{
public:
None(WiimoteEmu::ExtensionReg& _reg);
None(ExtensionReg& reg);
};
}

64
Source/Core/Core/HW/WiimoteEmu/Attachment/Classic.cpp
View File

@ -2,45 +2,51 @@
// Licensed under GPLv2+
// Refer to the license.txt file included.
#include "Core/HW/WiimoteEmu/Attachment/Classic.h"
#include <array>
#include <cassert>
#include <cstring>
#include "Common/Common.h"
#include "Common/CommonTypes.h"
#include "Core/HW/WiimoteEmu/Attachment/Classic.h"
#include "Core/HW/WiimoteEmu/WiimoteEmu.h"
namespace WiimoteEmu
{
static const u8 classic_id[] = {0x00, 0x00, 0xa4, 0x20, 0x01, 0x01};
/* Classic Controller calibration */
static const u8 classic_calibration[] = {0xff, 0x00, 0x80, 0xff, 0x00, 0x80, 0xff, 0x00,
0x80, 0xff, 0x00, 0x80, 0x00, 0x00, 0x51, 0xa6};
constexpr std::array<u8, 6> classic_id{{0x00, 0x00, 0xa4, 0x20, 0x01, 0x01}};
static const u16 classic_button_bitmasks[] = {
Classic::BUTTON_A, Classic::BUTTON_B, Classic::BUTTON_X, Classic::BUTTON_Y,
// Classic Controller calibration
constexpr std::array<u8, 0x10> classic_calibration{{
0xff, 0x00, 0x80, 0xff, 0x00, 0x80, 0xff, 0x00, 0x80, 0xff, 0x00, 0x80, 0x00, 0x00, 0x51, 0xa6,
}};
Classic::BUTTON_ZL, Classic::BUTTON_ZR,
constexpr std::array<u16, 9> classic_button_bitmasks{{
Classic::BUTTON_A, Classic::BUTTON_B, Classic::BUTTON_X, Classic::BUTTON_Y,
Classic::BUTTON_ZL, Classic::BUTTON_ZR,
Classic::BUTTON_MINUS, Classic::BUTTON_PLUS,
Classic::BUTTON_HOME,
};
}};
static const char* const classic_button_names[] = {
constexpr std::array<const char*, 9> classic_button_names{{
"A", "B", "X", "Y", "ZL", "ZR", "-", "+", "Home",
};
}};
static const u16 classic_trigger_bitmasks[] = {
constexpr std::array<u16, 2> classic_trigger_bitmasks{{
Classic::TRIGGER_L, Classic::TRIGGER_R,
};
}};
static const char* const classic_trigger_names[] = {"L", "R", "L-Analog", "R-Analog"};
constexpr std::array<const char*, 4> classic_trigger_names{{
"L", "R", "L-Analog", "R-Analog",
}};
static const u16 classic_dpad_bitmasks[] = {Classic::PAD_UP, Classic::PAD_DOWN, Classic::PAD_LEFT,
Classic::PAD_RIGHT};
constexpr std::array<u16, 4> classic_dpad_bitmasks{{
Classic::PAD_UP, Classic::PAD_DOWN, Classic::PAD_LEFT, Classic::PAD_RIGHT,
}};
Classic::Classic(WiimoteEmu::ExtensionReg& _reg) : Attachment(_trans("Classic"), _reg)
Classic::Classic(ExtensionReg& reg) : Attachment(_trans("Classic"), reg)
{
// buttons
groups.emplace_back(m_buttons = new Buttons("Buttons"));
@ -63,11 +69,9 @@ Classic::Classic(WiimoteEmu::ExtensionReg& _reg) : Attachment(_trans("Classic"),
for (auto& named_direction : named_directions)
m_dpad->controls.emplace_back(new ControlGroup::Input(named_direction));
// set up register
// calibration
memcpy(&calibration, classic_calibration, sizeof(classic_calibration));
// id
memcpy(&id, classic_id, sizeof(classic_id));
// Set up register
m_calibration = classic_calibration;
m_id = classic_id;
}
void Classic::GetState(u8* const data)
@ -107,7 +111,7 @@ void Classic::GetState(u8* const data)
{
ControlState trigs[2] = {0, 0};
u8 lt, rt;
m_triggers->GetState(&ccdata->bt.hex, classic_trigger_bitmasks, trigs);
m_triggers->GetState(&ccdata->bt.hex, classic_trigger_bitmasks.data(), trigs);
lt = static_cast<u8>(trigs[0] * Classic::LEFT_TRIGGER_RANGE);
rt = static_cast<u8>(trigs[1] * Classic::RIGHT_TRIGGER_RANGE);
@ -118,9 +122,9 @@ void Classic::GetState(u8* const data)
}
// buttons
m_buttons->GetState(&ccdata->bt.hex, classic_button_bitmasks);
m_buttons->GetState(&ccdata->bt.hex, classic_button_bitmasks.data());
// dpad
m_dpad->GetState(&ccdata->bt.hex, classic_dpad_bitmasks);
m_dpad->GetState(&ccdata->bt.hex, classic_dpad_bitmasks.data());
// flip button bits
ccdata->bt.hex ^= 0xFFFF;
@ -129,10 +133,10 @@ void Classic::GetState(u8* const data)
bool Classic::IsButtonPressed() const
{
u16 buttons = 0;
ControlState trigs[2] = {0, 0};
m_buttons->GetState(&buttons, classic_button_bitmasks);
m_dpad->GetState(&buttons, classic_dpad_bitmasks);
m_triggers->GetState(&buttons, classic_trigger_bitmasks, trigs);
std::array<ControlState, 2> trigs{};
m_buttons->GetState(&buttons, classic_button_bitmasks.data());
m_dpad->GetState(&buttons, classic_dpad_bitmasks.data());
m_triggers->GetState(&buttons, classic_trigger_bitmasks.data(), trigs.data());
return buttons != 0;
}

2
Source/Core/Core/HW/WiimoteEmu/Attachment/Classic.h
View File

@ -14,7 +14,7 @@ struct ExtensionReg;
class Classic : public Attachment
{
public:
Classic(WiimoteEmu::ExtensionReg& _reg);
Classic(ExtensionReg& reg);
void GetState(u8* const data) override;
bool IsButtonPressed() const override;

38
Source/Core/Core/HW/WiimoteEmu/Attachment/Drums.cpp
View File

@ -2,31 +2,34 @@
// Licensed under GPLv2+
// Refer to the license.txt file included.
#include "Core/HW/WiimoteEmu/Attachment/Drums.h"
#include <array>
#include <cassert>
#include <cstring>
#include "Common/Common.h"
#include "Common/CommonTypes.h"
#include "Core/HW/WiimoteEmu/Attachment/Drums.h"
#include "Core/HW/WiimoteEmu/WiimoteEmu.h"
namespace WiimoteEmu
{
static const u8 drums_id[] = {0x01, 0x00, 0xa4, 0x20, 0x01, 0x03};
constexpr std::array<u8, 6> drums_id{{0x01, 0x00, 0xa4, 0x20, 0x01, 0x03}};
static const u16 drum_pad_bitmasks[] = {
Drums::PAD_RED, Drums::PAD_YELLOW, Drums::PAD_BLUE,
Drums::PAD_GREEN, Drums::PAD_ORANGE, Drums::PAD_BASS,
};
constexpr std::array<u16, 6> drum_pad_bitmasks{{
Drums::PAD_RED, Drums::PAD_YELLOW, Drums::PAD_BLUE, Drums::PAD_GREEN, Drums::PAD_ORANGE,
Drums::PAD_BASS,
}};
static const char* const drum_pad_names[] = {_trans("Red"), _trans("Yellow"), _trans("Blue"),
_trans("Green"), _trans("Orange"), _trans("Bass")};
constexpr std::array<const char*, 6> drum_pad_names{{
_trans("Red"), _trans("Yellow"), _trans("Blue"), _trans("Green"), _trans("Orange"),
_trans("Bass"),
}};
static const u16 drum_button_bitmasks[] = {
constexpr std::array<u16, 2> drum_button_bitmasks{{
Drums::BUTTON_MINUS, Drums::BUTTON_PLUS,
};
}};
Drums::Drums(WiimoteEmu::ExtensionReg& _reg) : Attachment(_trans("Drums"), _reg)
Drums::Drums(ExtensionReg& reg) : Attachment(_trans("Drums"), reg)
{
// pads
groups.emplace_back(m_pads = new Buttons(_trans("Pads")));
@ -42,8 +45,7 @@ Drums::Drums(WiimoteEmu::ExtensionReg& _reg) : Attachment(_trans("Drums"), _reg)
m_buttons->controls.emplace_back(new ControlGroup::Input("+"));
// set up register
// id
memcpy(&id, drums_id, sizeof(drums_id));
m_id = drums_id;
}
void Drums::GetState(u8* const data)
@ -67,9 +69,9 @@ void Drums::GetState(u8* const data)
data[3] = 0xFF;
// buttons
m_buttons->GetState(&ddata->bt, drum_button_bitmasks);
m_buttons->GetState(&ddata->bt, drum_button_bitmasks.data());
// pads
m_pads->GetState(&ddata->bt, drum_pad_bitmasks);
m_pads->GetState(&ddata->bt, drum_pad_bitmasks.data());
// flip button bits
ddata->bt ^= 0xFFFF;
@ -78,8 +80,8 @@ void Drums::GetState(u8* const data)
bool Drums::IsButtonPressed() const
{
u16 buttons = 0;
m_buttons->GetState(&buttons, drum_button_bitmasks);
m_pads->GetState(&buttons, drum_pad_bitmasks);
m_buttons->GetState(&buttons, drum_button_bitmasks.data());
m_pads->GetState(&buttons, drum_pad_bitmasks.data());
return buttons != 0;
}

2
Source/Core/Core/HW/WiimoteEmu/Attachment/Drums.h
View File

@ -14,7 +14,7 @@ struct ExtensionReg;
class Drums : public Attachment
{
public:
Drums(WiimoteEmu::ExtensionReg& _reg);
Drums(ExtensionReg& reg);
void GetState(u8* const data) override;
bool IsButtonPressed() const override;

44
Source/Core/Core/HW/WiimoteEmu/Attachment/Guitar.cpp
View File

@ -2,36 +2,37 @@
// Licensed under GPLv2+
// Refer to the license.txt file included.
#include "Core/HW/WiimoteEmu/Attachment/Guitar.h"
#include <array>
#include <cassert>
#include <cstring>
#include "Common/Common.h"
#include "Common/CommonTypes.h"
#include "Core/HW/WiimoteEmu/Attachment/Guitar.h"
#include "Core/HW/WiimoteEmu/WiimoteEmu.h"
namespace WiimoteEmu
{
static const u8 guitar_id[] = {0x00, 0x00, 0xa4, 0x20, 0x01, 0x03};
constexpr std::array<u8, 6> guitar_id{{0x00, 0x00, 0xa4, 0x20, 0x01, 0x03}};
static const u16 guitar_fret_bitmasks[] = {
Guitar::FRET_GREEN, Guitar::FRET_RED, Guitar::FRET_YELLOW,
Guitar::FRET_BLUE, Guitar::FRET_ORANGE,
};
constexpr std::array<u16, 5> guitar_fret_bitmasks{{
Guitar::FRET_GREEN, Guitar::FRET_RED, Guitar::FRET_YELLOW, Guitar::FRET_BLUE,
Guitar::FRET_ORANGE,
}};
static const char* const guitar_fret_names[] = {
constexpr std::array<const char*, 5> guitar_fret_names{{
"Green", "Red", "Yellow", "Blue", "Orange",
};
}};
static const u16 guitar_button_bitmasks[] = {
constexpr std::array<u16, 2> guitar_button_bitmasks{{
Guitar::BUTTON_MINUS, Guitar::BUTTON_PLUS,
};
}};
static const u16 guitar_strum_bitmasks[] = {
constexpr std::array<u16, 2> guitar_strum_bitmasks{{
Guitar::BAR_UP, Guitar::BAR_DOWN,
};
}};
Guitar::Guitar(WiimoteEmu::ExtensionReg& _reg) : Attachment(_trans("Guitar"), _reg)
Guitar::Guitar(ExtensionReg& reg) : Attachment(_trans("Guitar"), reg)
{
// frets
groups.emplace_back(m_frets = new Buttons(_trans("Frets")));
@ -56,8 +57,7 @@ Guitar::Guitar(WiimoteEmu::ExtensionReg& _reg) : Attachment(_trans("Guitar"), _r
m_whammy->controls.emplace_back(new ControlGroup::Input(_trans("Bar")));
// set up register
// id
memcpy(&id, guitar_id, sizeof(guitar_id));
m_id = guitar_id;
}
void Guitar::GetState(u8* const data)
@ -85,11 +85,11 @@ void Guitar::GetState(u8* const data)
gdata->whammy = static_cast<u8>(whammy * 0x1F);
// buttons
m_buttons->GetState(&gdata->bt, guitar_button_bitmasks);
m_buttons->GetState(&gdata->bt, guitar_button_bitmasks.data());
// frets
m_frets->GetState(&gdata->bt, guitar_fret_bitmasks);
m_frets->GetState(&gdata->bt, guitar_fret_bitmasks.data());
// strum
m_strum->GetState(&gdata->bt, guitar_strum_bitmasks);
m_strum->GetState(&gdata->bt, guitar_strum_bitmasks.data());
// flip button bits
gdata->bt ^= 0xFFFF;
@ -98,9 +98,9 @@ void Guitar::GetState(u8* const data)
bool Guitar::IsButtonPressed() const
{
u16 buttons = 0;
m_buttons->GetState(&buttons, guitar_button_bitmasks);
m_frets->GetState(&buttons, guitar_fret_bitmasks);
m_strum->GetState(&buttons, guitar_strum_bitmasks);
m_buttons->GetState(&buttons, guitar_button_bitmasks.data());
m_frets->GetState(&buttons, guitar_fret_bitmasks.data());
m_strum->GetState(&buttons, guitar_strum_bitmasks.data());
return buttons != 0;
}

2
Source/Core/Core/HW/WiimoteEmu/Attachment/Guitar.h
View File

@ -14,7 +14,7 @@ struct ExtensionReg;
class Guitar : public Attachment
{
public:
Guitar(WiimoteEmu::ExtensionReg& _reg);
Guitar(ExtensionReg& reg);
void GetState(u8* const data) override;
bool IsButtonPressed() const override;

25
Source/Core/Core/HW/WiimoteEmu/Attachment/Nunchuk.cpp
View File

@ -2,24 +2,25 @@
// Licensed under GPLv2+
// Refer to the license.txt file included.
#include "Core/HW/WiimoteEmu/Attachment/Nunchuk.h"
#include <array>
#include <cassert>
#include <cstring>
#include "Common/Common.h"
#include "Common/CommonTypes.h"
#include "Common/MathUtil.h"
#include "Core/HW/WiimoteEmu/Attachment/Nunchuk.h"
#include "Core/HW/WiimoteEmu/WiimoteEmu.h"
namespace WiimoteEmu
{
static const u8 nunchuk_id[] = {0x00, 0x00, 0xa4, 0x20, 0x00, 0x00};
constexpr std::array<u8, 6> nunchuk_id{{0x00, 0x00, 0xa4, 0x20, 0x00, 0x00}};
static const u8 nunchuk_button_bitmasks[] = {
constexpr std::array<u8, 2> nunchuk_button_bitmasks{{
Nunchuk::BUTTON_C, Nunchuk::BUTTON_Z,
};
}};
Nunchuk::Nunchuk(WiimoteEmu::ExtensionReg& _reg) : Attachment(_trans("Nunchuk"), _reg)
Nunchuk::Nunchuk(ExtensionReg& reg) : Attachment(_trans("Nunchuk"), reg)
{
// buttons
groups.emplace_back(m_buttons = new Buttons("Buttons"));
@ -41,11 +42,7 @@ Nunchuk::Nunchuk(WiimoteEmu::ExtensionReg& _reg) : Attachment(_trans("Nunchuk"),
m_shake->controls.emplace_back(new ControlGroup::Input("Y"));
m_shake->controls.emplace_back(new ControlGroup::Input("Z"));
// id
memcpy(&id, nunchuk_id, sizeof(nunchuk_id));
// this should get set to 0 on disconnect, but it isn't, o well
memset(m_shake_step, 0, sizeof(m_shake_step));
m_id = nunchuk_id;
}
void Nunchuk::GetState(u8* const data)
@ -84,9 +81,9 @@ void Nunchuk::GetState(u8* const data)
// swing
EmulateSwing(&accel, m_swing);
// shake
EmulateShake(&accel, m_shake, m_shake_step);
EmulateShake(&accel, m_shake, m_shake_step.data());
// buttons
m_buttons->GetState(&ncdata->bt.hex, nunchuk_button_bitmasks);
m_buttons->GetState(&ncdata->bt.hex, nunchuk_button_bitmasks.data());
// flip the button bits :/
ncdata->bt.hex ^= 0x03;
@ -111,7 +108,7 @@ void Nunchuk::GetState(u8* const data)
bool Nunchuk::IsButtonPressed() const
{
u8 buttons = 0;
m_buttons->GetState(&buttons, nunchuk_button_bitmasks);
m_buttons->GetState(&buttons, nunchuk_button_bitmasks.data());
return buttons != 0;
}

5
Source/Core/Core/HW/WiimoteEmu/Attachment/Nunchuk.h
View File

@ -4,6 +4,7 @@
#pragma once
#include <array>
#include "Core/HW/WiimoteEmu/Attachment/Attachment.h"
namespace WiimoteEmu
@ -14,7 +15,7 @@ struct ExtensionReg;
class Nunchuk : public Attachment
{
public:
Nunchuk(WiimoteEmu::ExtensionReg& _reg);
Nunchuk(ExtensionReg& reg);
void GetState(u8* const data) override;
bool IsButtonPressed() const override;
@ -51,6 +52,6 @@ private:
Buttons* m_buttons;
AnalogStick* m_stick;
u8 m_shake_step[3];
std::array<u8, 3> m_shake_step{};
};
}

37
Source/Core/Core/HW/WiimoteEmu/Attachment/Turntable.cpp
View File

@ -2,37 +2,31 @@
// Licensed under GPLv2+
// Refer to the license.txt file included.
#include "Core/HW/WiimoteEmu/Attachment/Turntable.h"
#include <array>
#include <cassert>
#include <cstring>
#include "Common/Common.h"
#include "Common/CommonTypes.h"
#include "Core/HW/WiimoteEmu/Attachment/Turntable.h"
#include "Core/HW/WiimoteEmu/WiimoteEmu.h"
namespace WiimoteEmu
{
static const u8 turntable_id[] = {0x03, 0x00, 0xa4, 0x20, 0x01, 0x03};
constexpr std::array<u8, 6> turntable_id{{0x03, 0x00, 0xa4, 0x20, 0x01, 0x03}};
static const u16 turntable_button_bitmasks[] = {
constexpr std::array<u16, 9> turntable_button_bitmasks{{
Turntable::BUTTON_L_GREEN, Turntable::BUTTON_L_RED, Turntable::BUTTON_L_BLUE,
Turntable::BUTTON_R_GREEN, Turntable::BUTTON_R_RED, Turntable::BUTTON_R_BLUE,
Turntable::BUTTON_MINUS, Turntable::BUTTON_PLUS, Turntable::BUTTON_EUPHORIA,
};
Turntable::BUTTON_MINUS, Turntable::BUTTON_PLUS, Turntable::BUTTON_EUPHORIA,
}};
static const char* const turntable_button_names[] = {
_trans("Green Left"),
_trans("Red Left"),
_trans("Blue Left"),
_trans("Green Right"),
_trans("Red Right"),
_trans("Blue Right"),
"-",
"+",
_trans("Euphoria"),
};
constexpr std::array<const char*, 9> turntable_button_names{{
_trans("Green Left"), _trans("Red Left"), _trans("Blue Left"), _trans("Green Right"),
_trans("Red Right"), _trans("Blue Right"), "-", "+", _trans("Euphoria"),
}};
Turntable::Turntable(WiimoteEmu::ExtensionReg& _reg) : Attachment(_trans("Turntable"), _reg)
Turntable::Turntable(ExtensionReg& reg) : Attachment(_trans("Turntable"), reg)
{
// buttons
groups.emplace_back(m_buttons = new Buttons("Buttons"));
@ -54,8 +48,7 @@ Turntable::Turntable(WiimoteEmu::ExtensionReg& _reg) : Attachment(_trans("Turnta
groups.emplace_back(m_crossfade = new Slider(_trans("Crossfade")));
// set up register
// id
memcpy(&id, turntable_id, sizeof(turntable_id));
m_id = turntable_id;
}
void Turntable::GetState(u8* const data)
@ -119,7 +112,7 @@ void Turntable::GetState(u8* const data)
}
// buttons
m_buttons->GetState(&ttdata->bt, turntable_button_bitmasks);
m_buttons->GetState(&ttdata->bt, turntable_button_bitmasks.data());
// flip button bits :/
ttdata->bt ^= (BUTTON_L_GREEN | BUTTON_L_RED | BUTTON_L_BLUE | BUTTON_R_GREEN | BUTTON_R_RED |
@ -129,7 +122,7 @@ void Turntable::GetState(u8* const data)
bool Turntable::IsButtonPressed() const
{
u16 buttons = 0;
m_buttons->GetState(&buttons, turntable_button_bitmasks);
m_buttons->GetState(&buttons, turntable_button_bitmasks.data());
return buttons != 0;
}

2
Source/Core/Core/HW/WiimoteEmu/Attachment/Turntable.h
View File

@ -14,7 +14,7 @@ struct ExtensionReg;
class Turntable : public Attachment
{
public:
Turntable(WiimoteEmu::ExtensionReg& _reg);
Turntable(ExtensionReg& reg);
void GetState(u8* const data) override;
bool IsButtonPressed() const override;