Files
wii-ipl/src/homebutton/HBMController.cpp
coah a348c9777a cleanup: rename HBMController alarm-created flag (#490)
Rename lbl_816989BC to sAlarmCreated. DOL sha1 unchanged.
2026-10-01 16:55:12 -05:00

332 lines
9.7 KiB
C++

#include <nw4r/snd.h>
#define SoundHandle SoundHandle*
#include "homebutton/HBMController.h"
#undef SoundHandle
#include "homebutton/HBMRemoteSpk.h"
#include "homebutton/internal/HBMBase.h"
#include <revolution/mtx.h>
#include <revolution/os.h>
#include <revolution/pad.h>
#include <revolution/wpad.h>
extern "C" void __dt__Q34nw4r3snd11SoundHandleFv(nw4r::snd::SoundHandle*, int);
namespace homebutton {
bool Controller::sBatteryFlag[WPAD_MAX_CONTROLLERS];
bool Controller::sAlarmCreated[WPAD_MAX_CONTROLLERS];
OSAlarm Controller::sAlarm[WPAD_MAX_CONTROLLERS];
OSAlarm Controller::sAlarmSoundOff[WPAD_MAX_CONTROLLERS];
Controller* Controller::sThis[WPAD_MAX_CONTROLLERS];
void Controller::wpadConnectCallback(s32 chan, s32 result) {
switch (result) {
case WPAD_ERR_OK: {
if (!sThis[chan]->mCallbackFlag) {
sThis[chan]->mOldExtensionCallback = WPADSetExtensionCallback(chan, &wpadExtensionCallback);
sThis[chan]->mCallbackFlag = true;
}
WPADControlSpeaker(chan, WPAD_SPEAKER_OFF, NULL);
break;
}
case WPAD_ERR_NO_CONTROLLER: {
WPADSetExtensionCallback(chan, sThis[chan]->mOldExtensionCallback);
sThis[chan]->mOldExtensionCallback = NULL;
sThis[chan]->mCallbackFlag = false;
sThis[chan]->mCheckSoundTimeFlag = false;
sThis[chan]->mCheckSoundIntervalFlag = false;
break;
}
}
if (sThis[chan]->mOldConnectCallback != NULL) {
sThis[chan]->mOldConnectCallback(chan, result);
}
}
void Controller::wpadExtensionCallback(s32 chan, s32 result) {
switch (result) {
case WPAD_DEV_UNKNOWN: {
sThis[chan]->soundOff(1000);
break;
}
}
if (sThis[chan]->mOldExtensionCallback != NULL) {
sThis[chan]->mOldExtensionCallback(chan, result);
}
}
void Controller::soundOnCallback(OSAlarm* alarm, OSContext* context) {
int chan = reinterpret_cast<int>(OSGetAlarmUserData(alarm));
sThis[chan]->soundOn();
}
Controller::Controller(int chan, RemoteSpk* pSpk) {
mSoundHandle = NULL;
mHBController.chan = chan;
mHBController.rumble = false;
mHBController.spVol = 1.0f;
remotespk = pSpk;
mOldConnectCallback = NULL;
mOldExtensionCallback = NULL;
mCallbackFlag = false;
mSoundOffFlag = false;
if (chan < WPAD_MAX_CONTROLLERS) {
sBatteryFlag[chan] = false;
OSReport("Create %d\n", chan);
if (!sAlarmCreated[chan]) {
OSCreateAlarm(&sAlarm[chan]);
OSCreateAlarm(&sAlarmSoundOff[chan]);
sAlarmCreated[chan] = true;
}
sThis[chan] = this;
}
}
Controller::~Controller() {
OSCancelAlarm(&sAlarm[mHBController.chan]);
OSCancelAlarm(&sAlarmSoundOff[mHBController.chan]);
__dt__Q34nw4r3snd11SoundHandleFv(reinterpret_cast<nw4r::snd::SoundHandle*>(&mSoundHandle), -1);
}
void Controller::initCallback() {
s32 type;
mOldConnectCallback = WPADSetConnectCallback(mHBController.chan, &wpadConnectCallback);
switch (WPADProbe(mHBController.chan, (u32*)&type)) {
case WPAD_ERR_OK: {
mOldExtensionCallback = WPADSetExtensionCallback(mHBController.chan, &wpadExtensionCallback);
mCallbackFlag = true;
break;
}
case WPAD_ERR_NO_CONTROLLER: {
mCallbackFlag = false;
break;
}
}
}
void Controller::clearCallback() {
WPADSetConnectCallback(mHBController.chan, mOldConnectCallback);
mOldConnectCallback = NULL;
WPADSetExtensionCallback(mHBController.chan, mOldExtensionCallback);
mOldExtensionCallback = NULL;
}
void Controller::setKpad(const HBMKPadData* pPadData, bool updatePos) {
if (pPadData->kpad == NULL) {
return;
}
if (updatePos) {
if (pPadData->kpad->dev_type == WPAD_DEV_CLASSIC && pPadData->use_devtype == WPAD_DEV_CLASSIC) {
mHBController.x = pPadData->pos.x;
mHBController.y = pPadData->pos.y;
} else {
mHBController.x = pPadData->kpad->pos.x;
mHBController.y = pPadData->kpad->pos.y;
}
}
mHBController.trig = pPadData->kpad->trig;
mHBController.hold = pPadData->kpad->hold;
mHBController.release = pPadData->kpad->release;
if (pPadData->kpad->dev_type == WPAD_DEV_CLASSIC) {
u32 h = pPadData->kpad->ex_status.cl.hold;
u32 t = pPadData->kpad->ex_status.cl.trig;
u32 r = pPadData->kpad->ex_status.cl.release;
if (h & WPAD_BUTTON_CL_A)
mHBController.hold |= WPAD_BUTTON_A;
if (t & WPAD_BUTTON_CL_A)
mHBController.trig |= WPAD_BUTTON_A;
if (r & WPAD_BUTTON_CL_A)
mHBController.release |= WPAD_BUTTON_A;
if (h & WPAD_BUTTON_CL_PLUS)
mHBController.hold |= WPAD_BUTTON_PLUS;
if (t & WPAD_BUTTON_CL_PLUS)
mHBController.trig |= WPAD_BUTTON_PLUS;
if (r & WPAD_BUTTON_CL_PLUS)
mHBController.release |= WPAD_BUTTON_PLUS;
if (h & WPAD_BUTTON_CL_MINUS)
mHBController.hold |= WPAD_BUTTON_MINUS;
if (t & WPAD_BUTTON_CL_MINUS)
mHBController.trig |= WPAD_BUTTON_MINUS;
if (r & WPAD_BUTTON_CL_MINUS)
mHBController.release |= WPAD_BUTTON_MINUS;
if (h & WPAD_BUTTON_CL_HOME)
mHBController.hold |= WPAD_BUTTON_HOME;
if (t & WPAD_BUTTON_CL_HOME)
mHBController.trig |= WPAD_BUTTON_HOME;
if (r & WPAD_BUTTON_CL_HOME)
mHBController.release |= WPAD_BUTTON_HOME;
}
}
void Controller::clrKpadButton() {
mHBController.trig = 0;
mHBController.hold = 0;
mHBController.release = 0;
}
void Controller::setInValidPos() {
mHBController.x = -10000.0f;
mHBController.y = -10000.0f;
}
int Controller::getChan() const {
return mHBController.chan;
}
void Controller::connect() {
getRemoteSpk()->Connect(getChan());
}
void Controller::disconnect() {
}
void Controller::setSpeakerVol(f32 vol) {
mHBController.spVol = vol;
}
f32 Controller::getSpeakerVol() const {
return mHBController.spVol;
}
void Controller::playSound(nw4r::snd::SoundArchivePlayer* pPlayer, int id) {
if (mSoundOffFlag) {
return;
}
getRemoteSpk()->Play(getChan(), id, getSpeakerVol() * HBM_MAX_VOLUME);
if (WPADIsSpeakerEnabled(getChan())) {
if (!mCheckSoundTimeFlag) {
mPlaySoundTime = OSGetTime();
}
mCheckSoundTimeFlag = true;
mCheckSoundIntervalFlag = false;
}
}
bool Controller::isPlayingSound() const {
return getRemoteSpk()->isPlaying(getChan());
}
bool Controller::isPlayingSoundId(int id) const {
if (!isPlayingSound()) {
return false;
}
if (!getRemoteSpk()->isPlayingId(getChan(), id)) {
return false;
}
return true;
}
void Controller::initSound() {
mCheckSoundTimeFlag = false;
mCheckSoundIntervalFlag = false;
}
void Controller::soundOff(int msec) {
int chan = getChan();
if (!WPADIsSpeakerEnabled(chan)) {
return;
}
WPADControlSpeaker(chan, WPAD_SPEAKER_MUTE, NULL);
OSSetAlarmUserData(&sAlarmSoundOff[chan], reinterpret_cast<void*>(chan));
OSCancelAlarm(&sAlarmSoundOff[chan]);
OSSetAlarm(&sAlarmSoundOff[chan], OSMillisecondsToTicks(msec), &soundOnCallback);
mSoundOffFlag = true;
}
void Controller::soundOn() {
int chan = getChan();
if (WPADIsSpeakerEnabled(chan)) {
WPADControlSpeaker(chan, WPAD_SPEAKER_UNMUTE, NULL);
}
mSoundOffFlag = false;
}
bool Controller::isPlayReady() const {
return getRemoteSpk()->isPlayReady(getChan());
}
HBController* Controller::getController() {
return &mHBController;
}
void Controller::startMotor() {
if (getChan() < WPAD_MAX_CONTROLLERS && !isPlayingSound()) {
setRumble();
WPADControlMotor(getChan(), WPAD_MOTOR_RUMBLE);
}
}
void Controller::stopMotor() {
if (getChan() < WPAD_MAX_CONTROLLERS && isRumbling()) {
clrRumble();
WPADControlMotor(getChan(), WPAD_MOTOR_STOP);
}
}
s32 Controller::getInfoAsync(WPADInfo* pInfo) {
if (getChan() >= WPAD_MAX_CONTROLLERS) {
return WPAD_ERR_COMMUNICATION_ERROR;
}
if (isPlayingSound() || isRumbling()) {
return WPAD_ERR_COMMUNICATION_ERROR;
}
return WPADGetInfoAsync(getChan(), pInfo, &ControllerCallback);
}
void Controller::ControllerCallback(s32 chan, s32 result) {
if (result == WPAD_ERR_OK && chan < WPAD_MAX_CONTROLLERS) {
sBatteryFlag[chan] = true;
}
}
bool Controller::getBatteryFlag() const {
if (getChan() >= WPAD_MAX_CONTROLLERS) {
return false;
}
return sBatteryFlag[getChan()];
}
void Controller::clrBatteryFlag() {
if (getChan() >= WPAD_MAX_CONTROLLERS) {
return;
}
sBatteryFlag[getChan()] = false;
}
} // namespace homebutton