diff --git a/Source/Dolphin.sln b/Source/Dolphin.sln index d165e7e58c..0fc16f53a7 100644 --- a/Source/Dolphin.sln +++ b/Source/Dolphin.sln @@ -193,6 +193,15 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Plugin_GCPad", "Plugins\Plu {C573CAF7-EE6A-458E-8049-16C0BF34C2E9} = {C573CAF7-EE6A-458E-8049-16C0BF34C2E9} EndProjectSection EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Plugin_GCPadNew", "Plugins\Plugin_GCPadNew\Plugin_GCPadNew.vcproj", "{1C3A7A91-A97F-4C7C-B45D-26F2242904D7}" + ProjectSection(ProjectDependencies) = postProject + {05C75041-D67D-4903-A362-8395A7B35C75} = {05C75041-D67D-4903-A362-8395A7B35C75} + {11F55366-12EC-4C44-A8CB-1D4E315D61ED} = {11F55366-12EC-4C44-A8CB-1D4E315D61ED} + {0E231FB1-F3C9-4724-ACCB-DE8BCB3C089E} = {0E231FB1-F3C9-4724-ACCB-DE8BCB3C089E} + {1C8436C9-DBAF-42BE-83BC-CF3EC9175ABE} = {1C8436C9-DBAF-42BE-83BC-CF3EC9175ABE} + {C573CAF7-EE6A-458E-8049-16C0BF34C2E9} = {C573CAF7-EE6A-458E-8049-16C0BF34C2E9} + EndProjectSection +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Win32 = Debug|Win32 @@ -553,6 +562,18 @@ Global {9FF603F8-B3BB-4144-9688-B2B802FA0F16}.Release|Win32.Build.0 = Release|Win32 {9FF603F8-B3BB-4144-9688-B2B802FA0F16}.Release|x64.ActiveCfg = Release|x64 {9FF603F8-B3BB-4144-9688-B2B802FA0F16}.Release|x64.Build.0 = Release|x64 + {1C3A7A91-A97F-4C7C-B45D-26F2242904D7}.Debug|Win32.ActiveCfg = Debug|Win32 + {1C3A7A91-A97F-4C7C-B45D-26F2242904D7}.Debug|Win32.Build.0 = Debug|Win32 + {1C3A7A91-A97F-4C7C-B45D-26F2242904D7}.Debug|x64.ActiveCfg = Debug|x64 + {1C3A7A91-A97F-4C7C-B45D-26F2242904D7}.Debug|x64.Build.0 = Debug|x64 + {1C3A7A91-A97F-4C7C-B45D-26F2242904D7}.DebugFast|Win32.ActiveCfg = DebugFast|Win32 + {1C3A7A91-A97F-4C7C-B45D-26F2242904D7}.DebugFast|Win32.Build.0 = DebugFast|Win32 + {1C3A7A91-A97F-4C7C-B45D-26F2242904D7}.DebugFast|x64.ActiveCfg = DebugFast|x64 + {1C3A7A91-A97F-4C7C-B45D-26F2242904D7}.DebugFast|x64.Build.0 = DebugFast|x64 + {1C3A7A91-A97F-4C7C-B45D-26F2242904D7}.Release|Win32.ActiveCfg = Release|Win32 + {1C3A7A91-A97F-4C7C-B45D-26F2242904D7}.Release|Win32.Build.0 = Release|Win32 + {1C3A7A91-A97F-4C7C-B45D-26F2242904D7}.Release|x64.ActiveCfg = Release|x64 + {1C3A7A91-A97F-4C7C-B45D-26F2242904D7}.Release|x64.Build.0 = Release|x64 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/Source/Plugins/Plugin_GCPadNew/Plugin_GCPadNew.vcproj b/Source/Plugins/Plugin_GCPadNew/Plugin_GCPadNew.vcproj new file mode 100644 index 0000000000..f7c62c9a59 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Plugin_GCPadNew.vcproj @@ -0,0 +1,680 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Source/Plugins/Plugin_GCPadNew/Src/Config.cpp b/Source/Plugins/Plugin_GCPadNew/Src/Config.cpp new file mode 100644 index 0000000000..78629fafd1 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/Config.cpp @@ -0,0 +1,54 @@ + +#include "Config.h" + +Plugin::Plugin() +{ + // GCPads + for ( unsigned int i = 0; i<4; ++i ) + controllers.push_back( new GCPad( i ) ); + // Wiimotes / disabled, cause it only the GUI half is done + //for ( unsigned int i = 0; i<4; ++i ) + // controllers.push_back( new Wiimote( i ) ); +}; + +Plugin::~Plugin() +{ + // delete pads + std::vector::const_iterator i = controllers.begin(), + e = controllers.end(); + for ( ; i != e; ++i ) + delete *i; +} + +void Plugin::LoadConfig() +{ + IniFile inifile; + + std::ifstream file; + file.open( (std::string(File::GetUserPath(D_CONFIG_IDX)) + CONFIG_FILE_NAME ).c_str() ); + inifile.Load( file ); + file.close(); + + std::vector< ControllerEmu* >::const_iterator i = controllers.begin(), + e = controllers.end(); + for ( ; i!=e; ++i ) + (*i)->LoadConfig( inifile[ (*i)->GetName() ] ); +} + +void Plugin::SaveConfig() +{ + IniFile inifile; + + std::vector< ControllerEmu* >::const_iterator i = controllers.begin(), + e = controllers.end(); + for ( ; i!=e; ++i ) + (*i)->SaveConfig( inifile[ (*i)->GetName() ] ); + + // dont need to save empty values + inifile.Clean(); + + std::ofstream file; + file.open( (std::string(File::GetUserPath(D_CONFIG_IDX)) + CONFIG_FILE_NAME ).c_str() ); + inifile.Save( file ); + file.close(); +} diff --git a/Source/Plugins/Plugin_GCPadNew/Src/Config.h b/Source/Plugins/Plugin_GCPadNew/Src/Config.h new file mode 100644 index 0000000000..39159bdd93 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/Config.h @@ -0,0 +1,51 @@ +#ifndef _CONFIG_H_ +#define _CONFIG_H_ + +#define CONFIG_FILE_NAME "GCPadNew.ini" + +#include "ControllerInterface/ControllerInterface.h" +#include "../../../Core/Common/Src/thread.h" +#include "../../../Core/Common/Src/FileUtil.h" +#include "IniFile.h" + +#include "ControllerEmu.h" +#include "ControllerEmu/GCPad/GCPad.h" +#include "ControllerEmu/Wiimote/Wiimote.h" + +#include +#include +#include +#include + +class Plugin +{ +public: + + Plugin(); + ~Plugin(); + + void LoadConfig(); + void SaveConfig(); + + class Pad : public std::vector + { + public: + class Options + { + public: + Options() : adjust_diagonal(1), allow_background_input(false) {} + + ControlState adjust_diagonal; // will contain the full diagonal value from the input device + bool allow_background_input; + + } options; + }; + + std::vector< ControllerEmu* > controllers; + + Common::CriticalSection controls_crit, interface_crit; // lock controls first + ControllerInterface controller_interface; + const std::string name; +}; + +#endif diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ConfigDiag.cpp b/Source/Plugins/Plugin_GCPadNew/Src/ConfigDiag.cpp new file mode 100644 index 0000000000..2230778606 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ConfigDiag.cpp @@ -0,0 +1,781 @@ + +#include "ConfigDiag.h" + +SettingCBox::SettingCBox( wxWindow* const parent, ControlState& _value, int min, int max ) + : wxChoice( parent, -1, wxDefaultPosition, wxSize( 48, -1 ) ) + , value(_value) +{ + Append( wxT("0") ); + for ( ; min<=max; ++min ) + { + std::ostringstream ss; + ss << min; + Append( wxString::FromAscii( ss.str().c_str() ) ); + } + + std::ostringstream ss; + ss << int(value * 100); + SetSelection( FindString( wxString::FromAscii( ss.str().c_str() ) ) ); + +} + +ControlDialog::ControlDialog( wxWindow* const parent, ControllerInterface::ControlReference* const ref, const std::vector& devs ) + :wxDialog( parent, -1, wxT("Configure Control"), wxDefaultPosition ) + ,control_reference(ref) +{ + + device_cbox = new wxComboBox( this, -1, wxString::FromAscii( ref->device_qualifier.ToString().c_str() ), wxDefaultPosition, wxSize(256,-1), wxArrayString(), wxTE_PROCESS_ENTER ); + + #define _connect_macro2_( b, f, c ) (b)->Connect( wxID_ANY, c, wxCommandEventHandler( GamepadPage::f ), (wxObject*)0, (wxEvtHandler*)parent ); + + _connect_macro2_( device_cbox, SetDevice, wxEVT_COMMAND_COMBOBOX_SELECTED ); + _connect_macro2_( device_cbox, SetDevice, wxEVT_COMMAND_TEXT_ENTER ); + + std::vector< ControllerInterface::Device* >::const_iterator i = devs.begin(), + e = devs.end(); + ControllerInterface::DeviceQualifier dq; + for ( ; i!=e; ++i ) + { + dq.FromDevice( *i ); + device_cbox->Append( wxString::FromAscii( dq.ToString().c_str() ) ); + } + + control_chooser = new ControlChooser( this, ref, parent ); + + wxStaticBoxSizer* d_szr = new wxStaticBoxSizer( wxVERTICAL, this, wxT("Device") ); + d_szr->Add( device_cbox, 0, wxEXPAND|wxALL, 5 ); + + wxBoxSizer* szr = new wxBoxSizer( wxVERTICAL ); + szr->Add( d_szr, 0, wxEXPAND|wxLEFT|wxRIGHT|wxTOP, 5 ); + szr->Add( control_chooser, 0, wxEXPAND|wxALL, 5 ); + + SetSizerAndFit( szr ); + +} + +ControlButton::ControlButton( wxWindow* const parent, ControllerInterface::ControlReference* const _ref, const unsigned int width, const std::string& label ) +: wxButton( parent, -1, wxT(""), wxDefaultPosition, wxSize( width,20) ) +, control_reference( _ref ) +{ + if ( label.empty() ) + SetLabel( wxString::FromAscii( _ref->control_qualifier.name.c_str() ) ); + else + SetLabel( wxString::FromAscii( label.c_str() ) ); +} + +void ConfigDialog::UpdateProfileComboBox() +{ + std::string pname( File::GetUserPath(D_CONFIG_IDX) ); + pname += PROFILES_PATH; + + CFileSearch::XStringVector exts; + exts.push_back("*.ini"); + CFileSearch::XStringVector dirs; + dirs.push_back( pname ); + CFileSearch cfs( exts, dirs ); + const CFileSearch::XStringVector& sv = cfs.GetFileNames(); + + wxArrayString strs; + CFileSearch::XStringVector::const_iterator si = sv.begin(), + se = sv.end(); + for ( ; si!=se; ++si ) + { + std::string str( si->begin() + si->find_last_of('/') + 1 , si->end() - 4 ) ; + strs.push_back( wxString::FromAscii( str.c_str() ) ); + } + + std::vector< GamepadPage* >::iterator i = m_padpages.begin(), + e = m_padpages.end(); + for ( ; i != e; ++i ) + { + (*i)->profile_cbox->Clear(); + (*i)->profile_cbox->Append(strs); + } +} + +void ConfigDialog::UpdateControlReferences() +{ + std::vector< GamepadPage* >::iterator i = m_padpages.begin(), + e = m_padpages.end(); + for ( ; i != e; ++i ) + (*i)->controller->UpdateReferences( m_plugin.controller_interface ); +} + +void ConfigDialog::ClickSave( wxCommandEvent& event ) +{ + m_plugin.SaveConfig(); + Close(); +}; + +void ControlChooser::UpdateGUI() +{ + control_lbox->Clear(); + + // make sure it's a valid device + if ( control_reference->device ) + if ( control_reference->is_input ) + { + // for inputs + std::vector::const_iterator i = control_reference->device->Inputs().begin(), + e = control_reference->device->Inputs().end(); + for ( ; i!=e; ++i ) + control_lbox->Append( wxString::FromAscii( (*i)->GetName().c_str() ) ); + } + else + { + // for outputs + std::vector::const_iterator i = control_reference->device->Outputs().begin(), + e = control_reference->device->Outputs().end(); + for ( ; i!=e; ++i ) + control_lbox->Append( wxString::FromAscii( (*i)->GetName().c_str() ) ); + } + + // logic not 100% right here for a poorly formated qualifier + // but its just for selecting crap in the listbox + wxArrayString control_names = control_lbox->GetStrings(); + const std::string cname = control_reference->control_qualifier.name; + for ( int i = int(control_names.size()) - 1; i >=0; --i ) + { + if ( cname == std::string(control_names[i].ToAscii()) || + cname.find( control_names[i].Prepend(wxT('|')).Append(wxT('|')).ToAscii() ) != std::string::npos ) + control_lbox->Select( i ); + else + control_lbox->Deselect( i ); + } + + size_t bound = control_reference->controls.size(); + std::ostringstream ss; + ss << "Bound Controls: "; + if ( bound ) ss << bound; else ss << "None"; + m_bound_label->SetLabel( wxString::FromAscii(ss.str().c_str()) ); + + textctrl->SetLabel( wxString::FromAscii( control_reference->control_qualifier.name.c_str() ) ); +}; + +void GamepadPage::UpdateGUI() +{ + device_cbox->SetLabel( wxString::FromAscii( controller->default_device.ToString().c_str() ) ); + + std::vector< ControlGroupBox* >::const_iterator g = control_groups.begin(), + ge = control_groups.end(); + for ( ; g!=ge; ++g ) + { + // buttons + std::vector::const_iterator i = (*g)->control_buttons.begin() + , e = (*g)->control_buttons.end(); + for ( ; i!=e; ++i ) + (*i)->SetLabel( wxString::FromAscii( (*i)->control_reference->control_qualifier.name.c_str() ) ); + + // cboxes + std::vector::const_iterator si = (*g)->options.begin() + , se = (*g)->options.end(); + for ( ; si!=se; ++si ) + { + std::ostringstream ss; + ss << int((*si)->value * 100); + (*si)->SetSelection( (*si)->FindString( wxString::FromAscii( ss.str().c_str() ) ) ); + } + } +} + +void GamepadPage::ClearAll( wxCommandEvent& event ) +{ + m_plugin.controls_crit.Enter(); // enter + + // just load an empty ini section to clear everything :P + controller->LoadConfig( IniSection() ); + + // no point in using the real ControllerInterface i guess + controller->UpdateReferences( ControllerInterface() ); + + UpdateGUI(); + + m_plugin.controls_crit.Leave(); // leave +} + +void GamepadPage::SetControl( wxCommandEvent& event ) +{ + m_plugin.controls_crit.Enter(); // enter + + m_control_dialog->control_reference->control_qualifier.name = std::string( m_control_dialog->control_chooser->textctrl->GetLabel().ToAscii() ); + m_control_dialog->control_reference->UpdateControls(); + m_control_dialog->control_chooser->UpdateGUI(); + + UpdateGUI(); + + m_plugin.controls_crit.Leave(); // leave +} + +void GamepadPage::SetDevice( wxCommandEvent& event ) +{ + m_plugin.controls_crit.Enter(); // enter + + + // TODO: need to handle the ConfigControl device in here + + // default device + if ( event.GetEventObject() == device_cbox ) + { + controller->default_device.FromString( std::string( device_cbox->GetLabel().ToAscii() ) ); + + // show user what it was validated as + device_cbox->SetLabel( wxString::FromAscii( controller->default_device.ToString().c_str() ) ); + + // this will set all the controls to this default device + controller->UpdateDefaultDevice(); + + // update references + controller->UpdateReferences( m_plugin.controller_interface ); + } + // control dialog + else + { + m_control_dialog->control_reference->device_qualifier.FromString( std::string( m_control_dialog->device_cbox->GetLabel().ToAscii() ) ); + + m_control_dialog->device_cbox->SetLabel( wxString::FromAscii( m_control_dialog->control_reference->device_qualifier.ToString().c_str() ) ); + + m_plugin.controller_interface.UpdateReference( m_control_dialog->control_reference ); + + m_control_dialog->control_chooser->UpdateGUI(); + + } + + m_plugin.controls_crit.Leave(); // leave + +} + +void GamepadPage::ClearControl( wxCommandEvent& event ) +{ + m_control_dialog->control_reference->control_qualifier.name.clear(); + m_control_dialog->control_reference->UpdateControls(); + m_control_dialog->control_chooser->UpdateGUI(); + UpdateGUI(); +} + +void GamepadPage::AdjustSetting( wxCommandEvent& event ) +{ + m_plugin.controls_crit.Enter(); // enter + + float setting = atoi( ((SettingCBox*)event.GetEventObject())->GetStringSelection().mb_str() ); + ((SettingCBox*)event.GetEventObject())->value = setting / 100; + + m_plugin.controls_crit.Leave(); // leave +} + +void GamepadPage::AdjustControlOption( wxCommandEvent& event ) +{ + m_plugin.controls_crit.Enter(); // enter + + m_control_dialog->control_reference->range = ControlState( m_control_dialog->control_chooser->range_slider->GetValue() ) / SLIDER_TICK_COUNT; + + if ( m_control_dialog->control_reference->is_input ) + { + ((ControllerInterface::InputReference*)m_control_dialog->control_reference)->mode = m_control_dialog->control_chooser->mode_cbox->GetSelection(); + } + + m_plugin.controls_crit.Leave(); // leave +} + +void GamepadPage::ConfigControl( wxCommandEvent& event ) +{ + m_control_dialog = new ControlDialog( this, ((ControlButton*)event.GetEventObject())->control_reference, m_plugin.controller_interface.Devices() ); + m_control_dialog->ShowModal(); + m_control_dialog->Destroy(); +} + +void GamepadPage::ConfigDetectControl( wxCommandEvent& event ) +{ + m_plugin.controls_crit.Enter(); // enter + + // major major hacks + wxChar num = ((wxButton*)event.GetEventObject())->GetLabel()[0]; + if ( num > '9' ) + num = 1; + else + num -= 0x30; + + if ( m_control_dialog->control_reference->Detect( DETECT_WAIT_TIME, num ) ) // if we got input, update control + { + UpdateGUI(); + m_control_dialog->control_chooser->UpdateGUI(); + } + + m_plugin.controls_crit.Leave(); // leave +} + +void GamepadPage::DetectControl( wxCommandEvent& event ) +{ + ControlButton* btn = (ControlButton*)event.GetEventObject(); + + m_plugin.controls_crit.Enter(); // enter + + btn->control_reference->Detect( DETECT_WAIT_TIME ); + btn->SetLabel( wxString::FromAscii( btn->control_reference->control_qualifier.name.c_str() ) ); + + m_plugin.controls_crit.Leave(); // leave +} + +void ControlDialog::SelectControl( wxCommandEvent& event ) +{ + wxListBox* lb = (wxListBox*)event.GetEventObject(); + + wxArrayInt sels; + lb->GetSelections( sels ); + wxArrayString names = lb->GetStrings(); + + wxString final_label; + + if ( sels.size() == 1 ) + final_label = names[ sels[0] ]; + //else if ( sels.size() == lb->GetCount() ) + // final_label = "||"; + else + { + final_label = wxT('|'); + for ( unsigned int i=0; itextctrl->SetLabel( final_label ); + + // kinda dumb + wxCommandEvent nullevent; + ((GamepadPage*)m_parent)->SetControl( nullevent ); + +} + +ControlChooser::ControlChooser( wxWindow* const parent, ControllerInterface::ControlReference* const ref, wxWindow* const eventsink ) +: wxStaticBoxSizer( wxVERTICAL, parent, ref->is_input ? wxT("Input") : wxT("Output") ) + , control_reference(ref) +{ + #define _connect_macro_( b, f, c ) (b)->Connect( wxID_ANY, (c), wxCommandEventHandler( GamepadPage::f ), (wxObject*)0, (wxEvtHandler*)eventsink ); + + textctrl = new wxTextCtrl( parent, -1 ); + wxButton* detect_button = new wxButton( parent, -1, ref->is_input ? wxT("Detect 1") : wxT("Test") ); + wxButton* clear_button = new wxButton( parent, -1, wxT("Clear"), wxDefaultPosition ); + wxButton* set_button = new wxButton( parent, -1, wxT("Set")/*, wxDefaultPosition, wxSize( 32, -1 )*/ ); + + control_lbox = new wxListBox( parent, -1, wxDefaultPosition, wxSize( 256, 128 ), wxArrayString(), wxLB_EXTENDED ); + + control_lbox->Connect( wxID_ANY, wxEVT_COMMAND_LISTBOX_SELECTED, wxCommandEventHandler( ControlDialog::SelectControl ), (wxObject*)0, parent ); + + wxBoxSizer* button_sizer = new wxBoxSizer( wxHORIZONTAL ); + button_sizer->Add( detect_button, 1, 0, 5 ); + if ( ref->is_input ) + for ( unsigned int i = 2; i<5; ++i ) + { + wxButton* d_btn = new wxButton( parent, -1, wxChar( '0'+i ), wxDefaultPosition, wxSize(16,-1) ); + _connect_macro_( d_btn, ConfigDetectControl, wxEVT_COMMAND_BUTTON_CLICKED); + button_sizer->Add( d_btn ); + } + button_sizer->Add( clear_button, 1, 0, 5 ); + button_sizer->Add( set_button, 1, 0, 5 ); + + range_slider = new wxSlider( parent, -1, SLIDER_TICK_COUNT, 0, SLIDER_TICK_COUNT, wxDefaultPosition, wxDefaultSize, wxSL_TOP | wxSL_LABELS /*| wxSL_AUTOTICKS*/ ); + + range_slider->SetValue( control_reference->range * SLIDER_TICK_COUNT ); + + _connect_macro_( detect_button, ConfigDetectControl, wxEVT_COMMAND_BUTTON_CLICKED); + _connect_macro_( clear_button, ClearControl, wxEVT_COMMAND_BUTTON_CLICKED); + _connect_macro_( set_button, SetControl, wxEVT_COMMAND_BUTTON_CLICKED); + + _connect_macro_( range_slider, AdjustControlOption, wxEVT_SCROLL_CHANGED); + wxStaticText* range_label = new wxStaticText( parent, -1, wxT("Range")); + m_bound_label = new wxStaticText( parent, -1, wxT("") ); + + wxBoxSizer* range_sizer = new wxBoxSizer( wxHORIZONTAL ); + range_sizer->Add( range_label, 0, wxCENTER|wxLEFT, 5 ); + range_sizer->Add( range_slider, 1, wxEXPAND|wxLEFT, 5 ); + + wxBoxSizer* txtbox_szr = new wxBoxSizer( wxHORIZONTAL ); + + txtbox_szr->Add( textctrl, 1, wxEXPAND, 0 ); + + wxBoxSizer* mode_szr; + if ( control_reference->is_input ) + { + mode_cbox = new wxChoice( parent, -1 ); + mode_cbox->Append( wxT("OR") ); + mode_cbox->Append( wxT("AND") ); + mode_cbox->Append( wxT("NOT") ); + mode_cbox->Select( ((ControllerInterface::InputReference*)control_reference)->mode ); + + _connect_macro_( mode_cbox, AdjustControlOption, wxEVT_COMMAND_CHOICE_SELECTED ); + + mode_szr = new wxBoxSizer( wxHORIZONTAL ); + mode_szr->Add( new wxStaticText( parent, -1, wxT("Mode") ), 0, wxCENTER|wxLEFT|wxRIGHT, 5 ); + mode_szr->Add( mode_cbox, 0, wxLEFT, 5 ); + } + + Add( range_sizer, 0, wxEXPAND|wxLEFT|wxRIGHT, 5 ); + if ( control_reference->is_input ) + Add( mode_szr, 0, wxEXPAND|wxLEFT|wxRIGHT, 5 ); + Add( txtbox_szr, 0, wxEXPAND|wxTOP|wxLEFT|wxRIGHT, 5 ); + Add( button_sizer, 0, wxEXPAND|wxBOTTOM|wxLEFT|wxRIGHT, 5 ); + Add( control_lbox, 0, wxEXPAND|wxLEFT|wxRIGHT|wxBOTTOM, 5 ); + Add( m_bound_label, 0, wxEXPAND|wxLEFT, 80 ); + + UpdateGUI(); +} + +void GamepadPage::LoadProfile( wxCommandEvent& event ) +{ + // TODO: check for dumb characters maybe + if ( profile_cbox->GetValue().empty() ) + return; + + m_plugin.controls_crit.Enter(); + + std::ifstream file; + std::string fname( File::GetUserPath(D_CONFIG_IDX) ); + fname += PROFILES_PATH; fname += profile_cbox->GetValue().ToAscii(); fname += ".ini"; + + if ( false == File::Exists( fname.c_str() ) ) + return; + + file.open( fname.c_str() ); + IniFile inifile; + inifile.Load( file ); + controller->LoadConfig( inifile["Profile"] ); + file.close(); + + controller->UpdateReferences( m_plugin.controller_interface ); + + m_plugin.controls_crit.Leave(); + + UpdateGUI(); +} + +void GamepadPage::SaveProfile( wxCommandEvent& event ) +{ + // TODO: check for dumb characters + if ( profile_cbox->GetValue().empty() ) + return; + + // don't need lock + IniFile inifile; + controller->SaveConfig( inifile["Profile"] ); + std::ofstream file; + std::string fname( File::GetUserPath(D_CONFIG_IDX) ); + fname += PROFILES_PATH; + + if ( false == File::Exists( fname.c_str() ) ) + File::CreateFullPath( fname.c_str() ); + + fname += profile_cbox->GetValue().ToAscii(); fname += ".ini"; + + file.open( fname.c_str() ); + inifile.Save( file ); + file.close(); + + m_config_dialog->UpdateProfileComboBox(); +} + +void GamepadPage::DeleteProfile( wxCommandEvent& event ) +{ + // TODO: check for dumb characters maybe + if ( profile_cbox->GetValue().empty() ) + return; + + // don't need lock + std::string fname( File::GetUserPath(D_CONFIG_IDX) ); + fname += PROFILES_PATH; fname += profile_cbox->GetValue().ToAscii(); fname += ".ini"; + if ( File::Exists( fname.c_str() ) ) + File::Delete( fname.c_str() ); + + m_config_dialog->UpdateProfileComboBox(); +} + +void ConfigDialog::UpdateDeviceComboBox() +{ + std::vector< GamepadPage* >::iterator i = m_padpages.begin(), + e = m_padpages.end(); + ControllerInterface::DeviceQualifier dq; + for ( ; i != e; ++i ) + { + (*i)->device_cbox->Clear(); + std::vector::const_iterator di = m_plugin.controller_interface.Devices().begin(), + de = m_plugin.controller_interface.Devices().end(); + for ( ; di!=de; ++di ) + { + dq.FromDevice( *di ); + (*i)->device_cbox->Append( wxString::FromAscii( dq.ToString().c_str() ) ); + } + (*i)->device_cbox->SetValue( wxString::FromAscii( (*i)->controller->default_device.ToString().c_str() ) ); + } +} + +void GamepadPage::RefreshDevices( wxCommandEvent& event ) +{ + m_plugin.controls_crit.Enter(); // enter + + // refresh devices + m_plugin.controller_interface.DeInit(); + m_plugin.controller_interface.Init(); + + // update all control references + m_config_dialog->UpdateControlReferences(); + + // update device cbox + m_config_dialog->UpdateDeviceComboBox(); + + m_plugin.controls_crit.Leave(); // leave +} + +ControlGroupBox::ControlGroupBox( ControllerEmu::ControlGroup* const group, wxWindow* const parent ) +: wxStaticBoxSizer( wxVERTICAL, parent, wxString::FromAscii( group->name ) ) +{ + + control_group = group; + static_bitmap = NULL; + + for ( unsigned int c = 0; c < group->controls.size(); ++c ) + { + + wxStaticText* label = new wxStaticText( parent, -1, wxString::FromAscii( group->controls[c]->name )/*.append(wxT(" :"))*/ ); + ControlButton* control_button = new ControlButton( parent, group->controls[c]->control_ref, 80 ); + controls.push_back( control_button ); + ControlButton* adv_button = new ControlButton( parent, group->controls[c]->control_ref, 16, "+" ); + + control_buttons.push_back( control_button ); + + control_button->Connect( wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( GamepadPage::DetectControl ), + (wxObject*)0, (wxEvtHandler*)parent ); + + adv_button->Connect( wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( GamepadPage::ConfigControl ), + (wxObject*)0, (wxEvtHandler*)parent ); + + wxBoxSizer* control_sizer = new wxBoxSizer( wxHORIZONTAL ); + control_sizer->AddStretchSpacer( 1 ); + control_sizer->Add( label, 0, wxCENTER | wxRIGHT, 5 ); + control_sizer->Add( control_button, 0, 0, 0 ); + control_sizer->Add( adv_button, 0, 0, 5 ); + + Add( control_sizer, 0, wxEXPAND|wxLEFT|wxRIGHT, 5 ); + + } + + switch ( group->type ) + { + case GROUP_TYPE_STICK : + { + wxBitmap bitmap(64, 64); + wxMemoryDC dc; + dc.SelectObject(bitmap); + dc.Clear(); + dc.SelectObject(wxNullBitmap); + + static_bitmap = new wxStaticBitmap( parent, -1, bitmap, wxDefaultPosition, wxDefaultSize, wxBITMAP_TYPE_BMP ); + + SettingCBox* deadzone_cbox = new SettingCBox( parent, group->settings[0]->value, 1, 50 ); + SettingCBox* diagonal_cbox = new SettingCBox( parent, group->settings[1]->value, 1, 100 ); + + deadzone_cbox->Connect( wxID_ANY, wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler( GamepadPage::AdjustSetting ), (wxObject*)0, (wxEvtHandler*)parent ); + diagonal_cbox->Connect( wxID_ANY, wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler( GamepadPage::AdjustSetting ), (wxObject*)0, (wxEvtHandler*)parent ); + + options.push_back( deadzone_cbox ); + options.push_back( diagonal_cbox ); + + wxBoxSizer* szr = new wxBoxSizer( wxVERTICAL ); + szr->Add( new wxStaticText( parent, -1, wxString::FromAscii( group->settings[0]->name ) ) ); + szr->Add( deadzone_cbox, 0, wxLEFT, 0 ); + szr->Add( new wxStaticText( parent, -1, wxString::FromAscii( group->settings[1]->name ) ) ); + szr->Add( diagonal_cbox, 0, wxLEFT, 0 ); + + wxBoxSizer* h_szr = new wxBoxSizer( wxHORIZONTAL ); + h_szr->Add( szr, 1, 0, 5 ); + h_szr->Add( static_bitmap, 0, wxALL|wxCENTER, 5 ); + + Add( h_szr, 0, wxEXPAND|wxLEFT|wxCENTER|wxTOP, 5 ); + } + break; + case GROUP_TYPE_BUTTONS : + { + wxBitmap bitmap(int(12*group->controls.size()+1), 12); + wxMemoryDC dc; + dc.SelectObject(bitmap); + dc.Clear(); + dc.SelectObject(wxNullBitmap); + static_bitmap = new wxStaticBitmap( parent, -1, bitmap, wxDefaultPosition, wxDefaultSize, wxBITMAP_TYPE_BMP ); + + SettingCBox* threshold_cbox = new SettingCBox( parent, group->settings[0]->value, 1, 99 ); + threshold_cbox->Connect( wxID_ANY, wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler( GamepadPage::AdjustSetting ), (wxObject*)0, (wxEvtHandler*)parent ); + + options.push_back( threshold_cbox ); + + wxBoxSizer* szr = new wxBoxSizer( wxHORIZONTAL ); + szr->Add( new wxStaticText( parent, -1, wxString::FromAscii( group->settings[0]->name ) ), 0, wxCENTER|wxRIGHT, 5 ); + szr->Add( threshold_cbox, 0, wxRIGHT, 5 ); + + Add( szr, 0, wxALL|wxCENTER, 5 ); + Add( static_bitmap, 0, wxALL|wxCENTER, 5 ); + } + break; + case GROUP_TYPE_MIXED_TRIGGERS : + { + wxBitmap bitmap(64+12+1, int(6*group->controls.size())+1); + wxMemoryDC dc; + dc.SelectObject(bitmap); + dc.Clear(); + dc.SelectObject(wxNullBitmap); + static_bitmap = new wxStaticBitmap( parent, -1, bitmap, wxDefaultPosition, wxDefaultSize, wxBITMAP_TYPE_BMP ); + + SettingCBox* threshold_cbox = new SettingCBox( parent, group->settings[0]->value, 1, 99 ); + threshold_cbox->Connect( wxID_ANY, wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler( GamepadPage::AdjustSetting ), (wxObject*)0, (wxEvtHandler*)parent ); + + options.push_back( threshold_cbox ); + + wxBoxSizer* szr = new wxBoxSizer( wxHORIZONTAL ); + szr->Add( new wxStaticText( parent, -1, wxString::FromAscii( group->settings[0]->name ) ), 0, wxCENTER|wxRIGHT, 5 ); + szr->Add( threshold_cbox, 0, wxRIGHT, 5 ); + + Add( szr, 0, wxALL|wxCENTER, 5 ); + Add( static_bitmap, 0, wxALL|wxCENTER, 5 ); + } + break; + default : + break; + + } + + //AddStretchSpacer( 0 ); +} + +GamepadPage::GamepadPage( wxWindow* parent, Plugin& plugin, const unsigned int pad_num, ConfigDialog* const config_dialog ) + : wxNotebookPage( parent, -1 , wxDefaultPosition, wxDefaultSize ) + ,controller(plugin.controllers[pad_num]) + ,m_plugin(plugin) + ,m_config_dialog(config_dialog) +{ + + wxBoxSizer* control_group_sizer = new wxBoxSizer( wxHORIZONTAL ); + + wxBoxSizer* stacked_groups = NULL; + for ( unsigned int i = 0; i < m_plugin.controllers[pad_num]->groups.size(); ++i ) + { + ControlGroupBox* control_group = new ControlGroupBox( m_plugin.controllers[pad_num]->groups[i], this ); + + if ( control_group->control_buttons.size() > 3 ) + { + if ( stacked_groups ) + control_group_sizer->Add( stacked_groups, 0, /*wxEXPAND|*/wxBOTTOM|wxRIGHT, 5 ); + + stacked_groups = new wxBoxSizer( wxVERTICAL ); + stacked_groups->Add( control_group, 1 ); + } + else + stacked_groups->Add( control_group ); + + control_groups.push_back( control_group ); + } + + if ( stacked_groups ) + control_group_sizer->Add( stacked_groups, 0, /*wxEXPAND|*/wxBOTTOM|wxRIGHT, 5 ); + + wxStaticBoxSizer* profile_sbox = new wxStaticBoxSizer( wxHORIZONTAL, this, wxT("Profile") ); + + // device chooser + + wxStaticBoxSizer* device_sbox = new wxStaticBoxSizer( wxHORIZONTAL, this, wxT("Device") ); + + device_cbox = new wxComboBox( this, -1, wxT(""), wxDefaultPosition, wxSize(128,-1), 0, 0, wxTE_PROCESS_ENTER ); + + wxButton* refresh_button = new wxButton( this, -1, wxT("Refresh"), wxDefaultPosition, wxSize(48,-1) ); + + #define _connect_macro3_( b, f, c ) (b)->Connect( wxID_ANY, c, wxCommandEventHandler( GamepadPage::f ), (wxObject*)0, (wxEvtHandler*)this ); + + _connect_macro3_( device_cbox, SetDevice, wxEVT_COMMAND_COMBOBOX_SELECTED ); + _connect_macro3_( device_cbox, SetDevice, wxEVT_COMMAND_TEXT_ENTER ); + _connect_macro3_( refresh_button, RefreshDevices, wxEVT_COMMAND_BUTTON_CLICKED ); + + device_sbox->Add( device_cbox, 1, wxLEFT|wxRIGHT, 5 ); + device_sbox->Add( refresh_button, 0, wxRIGHT|wxBOTTOM, 5 ); + + wxStaticBoxSizer* clear_sbox = new wxStaticBoxSizer( wxHORIZONTAL, this, wxT("Clear") ); + wxButton* all_button = new wxButton( this, -1, wxT("All"), wxDefaultPosition, wxSize(48,-1) ); + clear_sbox->Add( all_button, 1, wxLEFT|wxRIGHT, 5 ); + + all_button->Connect( wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( GamepadPage::ClearAll ), + (wxObject*)0, (wxEvtHandler*)this ); + + profile_cbox = new wxComboBox( this, -1, wxT(""), wxDefaultPosition, wxSize(128,-1) ); + + wxButton* const pload_btn = new wxButton( this, -1, wxT("Load"), wxDefaultPosition, wxSize(48,-1) ); + wxButton* const psave_btn = new wxButton( this, -1, wxT("Save"), wxDefaultPosition, wxSize(48,-1) ); + wxButton* const pdelete_btn = new wxButton( this, -1, wxT("Delete"), wxDefaultPosition, wxSize(48,-1) ); + + pload_btn->Connect( wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( GamepadPage::LoadProfile ), + (wxObject*)0, (wxEvtHandler*)this ); + psave_btn->Connect( wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( GamepadPage::SaveProfile ), + (wxObject*)0, (wxEvtHandler*)this ); + pdelete_btn->Connect( wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( GamepadPage::DeleteProfile ), + (wxObject*)0, (wxEvtHandler*)this ); + + profile_sbox->Add( profile_cbox, 1, wxLEFT, 5 ); + profile_sbox->Add( pload_btn, 0, wxLEFT, 5 ); + profile_sbox->Add( psave_btn, 0, 0, 5 ); + profile_sbox->Add( pdelete_btn, 0, wxRIGHT|wxBOTTOM, 5 ); + + wxBoxSizer* dio = new wxBoxSizer( wxHORIZONTAL ); + dio->Add( device_sbox, 1, wxEXPAND|wxRIGHT, 5 ); + dio->Add( clear_sbox, 0, wxEXPAND|wxRIGHT, 5 ); + dio->Add( profile_sbox, 1, wxEXPAND|wxRIGHT, 5 ); + + wxBoxSizer* mapping = new wxBoxSizer( wxVERTICAL ); + + mapping->Add( dio, 1, wxEXPAND|wxLEFT|wxTOP|wxBOTTOM, 5 ); + mapping->Add( control_group_sizer, 0, wxLEFT|wxEXPAND, 5 ); + + UpdateGUI(); + + SetSizerAndFit( mapping ); + Layout(); +}; + +ConfigDialog::~ConfigDialog() +{ + m_update_timer->Stop(); +} + +ConfigDialog::ConfigDialog( wxWindow* const parent, Plugin& plugin, const std::string& name, const bool _is_game_running ) + : wxDialog( parent, wxID_ANY, wxString::FromAscii(name.c_str()), wxPoint(128,-1), wxDefaultSize ) + , is_game_running(_is_game_running) + , m_plugin(plugin) +{ + m_pad_notebook = new wxNotebook( this, -1, wxDefaultPosition, wxDefaultSize, wxNB_DEFAULT ); + for ( unsigned int i = 0; i < plugin.controllers.size(); ++i ) + { + GamepadPage* gp = new GamepadPage( m_pad_notebook, plugin, i, this ); + m_padpages.push_back( gp ); + m_pad_notebook->AddPage( gp, wxString::FromAscii((plugin.controllers[i]->GetName().c_str())) ); + } + + UpdateDeviceComboBox(); + UpdateProfileComboBox(); + + wxButton* close_button = new wxButton( this, -1, wxT("Save")); + + close_button->Connect( wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( ConfigDialog::ClickSave ), (wxObject*)0, (wxEvtHandler*)this ); + + wxBoxSizer* btns = new wxBoxSizer( wxHORIZONTAL ); + //btns->Add( new wxStaticText( this, -1, wxString::FromAscii(ver.c_str())), 0, wxLEFT|wxTOP, 5 ); + btns->AddStretchSpacer(); + btns->Add( close_button, 0, 0, 0 ); + + wxBoxSizer* szr = new wxBoxSizer( wxVERTICAL ); + szr->Add( m_pad_notebook, 0, wxEXPAND|wxTOP|wxLEFT|wxRIGHT, 5 ); + szr->Add( btns, 0, wxEXPAND|wxALL, 5 ); + + SetSizerAndFit( szr ); + // not needed here it seems, but it cant hurt + Layout(); + + Center(); + + // live preview update timer + m_update_timer = new wxTimer( this, -1 ); + Connect( wxID_ANY, wxEVT_TIMER, wxTimerEventHandler( ConfigDialog::UpdateBitmaps ), (wxObject*)0, this ); + m_update_timer->Start( PREVIEW_UPDATE_TIME, wxTIMER_CONTINUOUS); + + +} diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ConfigDiag.h b/Source/Plugins/Plugin_GCPadNew/Src/ConfigDiag.h new file mode 100644 index 0000000000..9175cd4ae1 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ConfigDiag.h @@ -0,0 +1,166 @@ +#ifndef _CONFIGBOX_H_ +#define _CONFIGBOX_H_ + +#define SLIDER_TICK_COUNT 100 +#define DETECT_WAIT_TIME 1500 +#define PREVIEW_UPDATE_TIME 25 + +// might have to change this setup for wiimote +#define PROFILES_PATH "Profiles/GCPad/" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "ControllerInterface/ControllerInterface.h" +#include "Config.h" +#include "FileSearch.h" + +class SettingCBox : public wxChoice +{ +public: + SettingCBox( wxWindow* const parent, ControlState& _value, int min, int max ); + + ControlState& value; +}; + +class ControlChooser : public wxStaticBoxSizer +{ +public: + ControlChooser( wxWindow* const parent, ControllerInterface::ControlReference* const ref, wxWindow* const eventsink ); + + void UpdateGUI(); + + ControllerInterface::ControlReference* control_reference; + + wxTextCtrl* textctrl; + wxListBox* control_lbox; + wxChoice* mode_cbox; + wxSlider* range_slider; + +private: + wxStaticText* m_bound_label; +}; + +class ControlList : public wxDialog +{ +public: + + ControlList( wxWindow* const parent, ControllerInterface::ControlReference* const ref, ControlChooser* const chooser ); + +private: + ControlChooser* const m_control_chooser; +}; + +class ControlDialog : public wxDialog +{ +public: + ControlDialog( wxWindow* const parent, ControllerInterface::ControlReference* const ref, const std::vector& devs ); + void SelectControl( wxCommandEvent& event ); + + ControllerInterface::ControlReference* const control_reference; + wxComboBox* device_cbox; + ControlChooser* control_chooser; +}; + +class ControlButton : public wxButton +{ +public: + ControlButton( wxWindow* const parent, ControllerInterface::ControlReference* const _ref, const unsigned int width, const std::string& label = "" ); + + ControllerInterface::ControlReference* const control_reference; +}; + +class ControlGroupBox : public wxStaticBoxSizer +{ +public: + ControlGroupBox( ControllerEmu::ControlGroup* const group, wxWindow* const parent ); + + ControllerEmu::ControlGroup* control_group; + wxStaticBitmap* static_bitmap; + std::vector< SettingCBox* > options; + std::vector< wxButton* > controls; + std::vector control_buttons; +}; + +class ConfigDialog; + +class GamepadPage : public wxNotebookPage +{ + friend class ConfigDialog; + +public: + GamepadPage( wxWindow* parent, Plugin& plugin, const unsigned int pad_num, ConfigDialog* const config_dialog ); + + void UpdateGUI(); + + void RefreshDevices( wxCommandEvent& event ); + + void LoadProfile( wxCommandEvent& event ); + void SaveProfile( wxCommandEvent& event ); + void DeleteProfile( wxCommandEvent& event ); + + void ConfigControl( wxCommandEvent& event ); + void ConfigDetectControl( wxCommandEvent& event ); + void DetectControl( wxCommandEvent& event ); + void ClearControl( wxCommandEvent& event ); + + void SetDevice( wxCommandEvent& event ); + void SetControl( wxCommandEvent& event ); + + void ClearAll( wxCommandEvent& event ); + + void AdjustControlOption( wxCommandEvent& event ); + void AdjustSetting( wxCommandEvent& event ); + + wxComboBox* profile_cbox; + wxComboBox* device_cbox; + + std::vector control_groups; + +protected: + + ControllerEmu* const controller; + +private: + + ControlDialog* m_control_dialog; + Plugin& m_plugin; + ConfigDialog* const m_config_dialog; +}; + +class ConfigDialog : public wxDialog +{ +public: + + ConfigDialog( wxWindow* const parent, Plugin& plugin, const std::string& name, const bool _is_game_running ); + ~ConfigDialog(); + + void ClickSave( wxCommandEvent& event ); + + void UpdateDeviceComboBox(); + void UpdateProfileComboBox(); + + void UpdateControlReferences(); + void UpdateBitmaps(wxTimerEvent&); + + const bool is_game_running; + +private: + + wxNotebook* m_pad_notebook; + std::vector m_padpages; + Plugin& m_plugin; + wxTimer* m_update_timer; +}; + +#endif diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ConfigDiagBitmaps.cpp b/Source/Plugins/Plugin_GCPadNew/Src/ConfigDiagBitmaps.cpp new file mode 100644 index 0000000000..4cf9898928 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ConfigDiagBitmaps.cpp @@ -0,0 +1,186 @@ + +#include "ConfigDiag.h" + +void ConfigDialog::UpdateBitmaps(wxTimerEvent& WXUNUSED(event)) +{ + + GamepadPage* const current_page = (GamepadPage*)m_pad_notebook->GetPage( m_pad_notebook->GetSelection() ); + + std::vector< ControlGroupBox* >::iterator g = current_page->control_groups.begin(), + ge = current_page->control_groups.end(); + for ( ; g != ge; ++g ) + { + + if ( (*g)->static_bitmap ) + { + + // don't want game thread updating input when we are using it here + if ( false == m_plugin.interface_crit.TryEnter() ) + return; + + if ( false == is_game_running ) + m_plugin.controller_interface.UpdateInput(); + + switch ( (*g)->control_group->type ) + { + case GROUP_TYPE_STICK : + { + float x, y; + float xx, yy; + ((ControllerEmu::AnalogStick*)(*g)->control_group)->GetState( &x, &y, 32.0, 32-1.5 ); + + xx = ((ControllerEmu::AnalogStick*)(*g)->control_group)->controls[3]->control_ref->State(); + xx -= ((ControllerEmu::AnalogStick*)(*g)->control_group)->controls[2]->control_ref->State(); + yy = ((ControllerEmu::AnalogStick*)(*g)->control_group)->controls[1]->control_ref->State(); + yy -= ((ControllerEmu::AnalogStick*)(*g)->control_group)->controls[0]->control_ref->State(); + xx *= 32 - 1; xx += 32; + yy *= 32 - 1; yy += 32; + + // setup + wxBitmap bitmap(64, 64); + wxMemoryDC dc; + dc.SelectObject(bitmap); + dc.Clear(); + + // draw the shit + + // circle for visual aid for diagonal adjustment + dc.SetPen(*wxLIGHT_GREY_PEN); + dc.SetBrush(*wxTRANSPARENT_BRUSH); + dc.DrawCircle( 32, 32, 32); + + // deadzone circle + dc.SetBrush(*wxLIGHT_GREY_BRUSH); + dc.DrawCircle( 32, 32, ((ControllerEmu::AnalogStick*)(*g)->control_group)->settings[0]->value * 32 ); + + // raw dot + dc.SetPen(*wxGREY_PEN); + dc.SetBrush(*wxGREY_BRUSH); + // i like the dot better than the cross i think + dc.DrawRectangle( xx - 2, yy - 2, 4, 4 ); + //dc.DrawRectangle( xx-1, 64-yy-4, 2, 8 ); + //dc.DrawRectangle( xx-4, 64-yy-1, 8, 2 ); + + // adjusted dot + if ( x!=32 || y!=32 ) + { + dc.SetPen(*wxRED_PEN); + dc.SetBrush(*wxRED_BRUSH); + dc.DrawRectangle( x-2, 64-y-2, 4, 4 ); + // i like the dot better than the cross i think + //dc.DrawRectangle( x-1, 64-y-4, 2, 8 ); + //dc.DrawRectangle( x-4, 64-y-1, 8, 2 ); + } + + // box outline + // Windows XP color + dc.SetPen(wxPen(_T("#7f9db9"))); + dc.SetBrush(*wxTRANSPARENT_BRUSH); + dc.DrawRectangle(0, 0, 64, 64); + + // done drawing + dc.SelectObject(wxNullBitmap); + + // set the shit + (*g)->static_bitmap->SetBitmap( bitmap ); + } + break; + case GROUP_TYPE_BUTTONS : + { + const unsigned int button_count = ((unsigned int)(*g)->control_group->controls.size()); + // setup + wxBitmap bitmap(12*button_count+1, 12); + wxMemoryDC dc; + dc.SelectObject(bitmap); + dc.Clear(); + + // draw the shit + dc.SetPen(*wxGREY_PEN); + + unsigned int * const bitmasks = new unsigned int[ button_count ]; + for ( unsigned int n = 0; ncontrol_group)->GetState( &buttons, bitmasks ); + + for ( unsigned int n = 0; ncontrol_group->controls[n]->control_ref->State() * 128; + dc.SetBrush( wxBrush( wxColor( amt, amt, amt ) ) ); + } + dc.DrawRectangle(n*12, 0, 14, 12); + } + + delete bitmasks; + + // box outline + // Windows XP color + dc.SetPen(wxPen(_T("#7f9db9"))); + dc.SetBrush(*wxTRANSPARENT_BRUSH); + dc.DrawRectangle(0, 0, bitmap.GetWidth(), bitmap.GetHeight()); + + // done drawing + dc.SelectObject(wxNullBitmap); + + // set the shit + (*g)->static_bitmap->SetBitmap( bitmap ); + } + break; + + case GROUP_TYPE_MIXED_TRIGGERS : + { + const unsigned int trigger_count = ((unsigned int)((*g)->control_group->controls.size() / 2)); + // setup + wxBitmap bitmap( 64+12+1, 12*trigger_count+1); + wxMemoryDC dc; + dc.SelectObject(bitmap); + dc.Clear(); + + // draw the shit + dc.SetPen(*wxGREY_PEN); + ControlState thresh = (*g)->control_group->settings[0]->value; + + for ( unsigned int n = 0; n < trigger_count; ++n ) + { + dc.SetBrush(*wxRED_BRUSH); + ControlState trig_d = (*g)->control_group->controls[n]->control_ref->State(); + + ControlState trig_a = trig_d > thresh ? 1 + : (*g)->control_group->controls[n+trigger_count]->control_ref->State(); + + dc.DrawRectangle(0, n*12, 64+20, 14); + if ( trig_d <= thresh ) + dc.SetBrush(*wxWHITE_BRUSH); + dc.DrawRectangle(trig_a*64, n*12, 64+20, 14); + dc.DrawRectangle(64, n*12, 32, 14); + } + dc.SetBrush(*wxTRANSPARENT_BRUSH); + dc.DrawRectangle(thresh*64, 0, 128, trigger_count*14); + + // box outline + // Windows XP color + dc.SetPen(wxPen(_T("#7f9db9"))); + dc.DrawRectangle(0, 0, bitmap.GetWidth(), bitmap.GetHeight()); + + // done drawing + dc.SelectObject(wxNullBitmap); + + // set the shit + (*g)->static_bitmap->SetBitmap( bitmap ); + } + break; + default : + break; + } + + m_plugin.interface_crit.Leave(); + } + } + +} diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerEmu.cpp b/Source/Plugins/Plugin_GCPadNew/Src/ControllerEmu.cpp new file mode 100644 index 0000000000..64a3038fa0 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerEmu.cpp @@ -0,0 +1,138 @@ +#include "ControllerEmu.h" + +#include "ControllerEmu/GCPad/GCPad.h" + +const char modifier[] = "Modifier"; + +// TODO: make this use iterators +ControllerEmu::~ControllerEmu() +{ + for ( unsigned int g = 0; gcontrols.size(); ++i ) + devi.UpdateReference( groups[g]->controls[i]->control_ref ); +} + +void ControllerEmu::UpdateDefaultDevice() +{ + std::vector::const_iterator i = groups.begin(), + e = groups.end(); + for ( ; i!=e; ++i ) + { + std::vector::const_iterator ci = (*i)->controls.begin(), + ce = (*i)->controls.end(); + for ( ; ci!=ce; ++ci ) + (*ci)->control_ref->device_qualifier = default_device; + } +} + +void ControllerEmu::LoadConfig( IniFile::Section& sec ) +{ + const std::string default_dev = sec[ "Device" ]; + default_device.FromString( default_dev ); + + std::vector::const_iterator i = groups.begin(), + e = groups.end(); + for ( ; i!=e; ++i ) + { + std::string group( (*i)->name ); group += "/"; + + // settings + std::vector::const_iterator si = (*i)->settings.begin(), + se = (*i)->settings.end(); + for ( ; si!=se; ++si ) + (*si)->value = sec.GetValue(group+(*si)->name, (*si)->default_value*100) / 100; + + // controls + std::vector::const_iterator ci = (*i)->controls.begin(), + ce = (*i)->controls.end(); + for ( ; ci!=ce; ++ci ) + { + // control and dev qualifier + (*ci)->control_ref->control_qualifier.name = sec[group + (*ci)->name]; + (*ci)->control_ref->device_qualifier.FromString( sec.GetValue( group+(*ci)->name+"/Device", default_dev ) ); + + // range + (*ci)->control_ref->range = sec.GetValue( group+(*ci)->name+"/Range", 100.0f ) / 100; + + // input mode + if ( (*ci)->control_ref->is_input ) + ((ControllerInterface::InputReference*)((*ci)->control_ref))->mode + = sec.GetValue( group+(*ci)->name+"/Mode", 0 ); + + } + } +} + +void ControllerEmu::SaveConfig( IniFile::Section& sec ) +{ + const std::string default_dev = default_device.ToString(); + sec[ " Device" ] = default_dev; + + std::vector::const_iterator i = groups.begin(), + e = groups.end(); + for ( ; i!=e; ++i ) + { + std::string group( (*i)->name ); group += "/"; + + // settings + std::vector::const_iterator si = (*i)->settings.begin(), + se = (*i)->settings.end(); + for ( ; si!=se; ++si ) + sec.SetValue( group+(*si)->name, (*si)->value*100, (*si)->default_value*100 ); + + // controls + std::vector::const_iterator ci = (*i)->controls.begin(), + ce = (*i)->controls.end(); + for ( ; ci!=ce; ++ci ) + { + // control and dev qualifier + sec[group + (*ci)->name] = (*ci)->control_ref->control_qualifier.name; + sec.SetValue( group+(*ci)->name+"/Device", (*ci)->control_ref->device_qualifier.ToString(), default_dev ); + + // range + sec.SetValue( group+(*ci)->name+"/Range", (*ci)->control_ref->range*100, 100 ); + + // input mode + if ( (*ci)->control_ref->is_input ) + sec.SetValue( group+(*ci)->name+"/Mode", + ((ControllerInterface::InputReference*)((*ci)->control_ref))->mode, 0 ); + } + } +} + +ControllerEmu::AnalogStick::AnalogStick( const char* const _name ) : ControlGroup( _name, GROUP_TYPE_STICK ) +{ + for ( unsigned int i = 0; i < 4; ++i ) + controls.push_back( new Input( named_directions[i] ) ); + + controls.push_back( new Input( modifier ) ); + + settings.push_back( new Setting("Dead Zone", 0 ) ); + settings.push_back( new Setting("Square Stick", 0 ) ); + +} + +ControllerEmu::Buttons::Buttons( const char* const _name ) : ControlGroup( _name, GROUP_TYPE_BUTTONS ) +{ + settings.push_back( new Setting("Threshold", 0.5f ) ); +} + +ControllerEmu::MixedTriggers::MixedTriggers( const char* const _name ) : ControlGroup( _name, GROUP_TYPE_MIXED_TRIGGERS ) +{ + settings.push_back( new Setting("Threshold", 0.9f ) ); +} diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerEmu.h b/Source/Plugins/Plugin_GCPadNew/Src/ControllerEmu.h new file mode 100644 index 0000000000..06327d1685 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerEmu.h @@ -0,0 +1,225 @@ +#ifndef _CONTROLLEREMU_H_ +#define _CONTROLLEREMU_H_ + +// windows crap +#define NOMINMAX + +#include "pluginspecs_pad.h" +#include "pluginspecs_wiimote.h" +//#include + +#include "ControllerInterface/ControllerInterface.h" +#include "IniFile.h" + +#include +#include +#include + +#define sign(x) ((x)?(x)<0?-1:1:0) + +enum +{ + GROUP_TYPE_OTHER + ,GROUP_TYPE_STICK + ,GROUP_TYPE_MIXED_TRIGGERS + ,GROUP_TYPE_BUTTONS +}; + +const char * const named_directions[] = +{ + "Up", + "Down", + "Left", + "Right" +}; + +class ControllerEmu +{ +public: + + class ControlGroup + { + public: + + class Control + { + protected: + Control( ControllerInterface::ControlReference* const _ref, const char * const _name ) + : control_ref(_ref), name(_name){} + public: + + + //virtual std::string GetName() const = 0; + + ControllerInterface::ControlReference* const control_ref; + const char * const name; + + }; + + class Input : public Control + { + public: + + Input( const char * const _name ) + : Control( new ControllerInterface::InputReference, _name ) {} + + }; + + class Output : public Control + { + public: + + Output( const char * const _name ) + : Control( new ControllerInterface::OutputReference, _name ) {} + + }; + + class Setting + { + public: + + Setting(const char* const _name, const float def_value ) : name(_name), value(def_value), default_value(def_value) {} + + const char* const name; + ControlState value; + const ControlState default_value; + }; + + ControlGroup( const char* const _name, const unsigned int _type = GROUP_TYPE_OTHER ) : name(_name), type(_type) {} + virtual ~ControlGroup(); + + //ControlGroup( const ControlGroup& ctrl ); + + //const unsigned int type; + const char* const name; + const unsigned int type; + + std::vector< Control* > controls; + std::vector< Setting* > settings; + + }; + + class AnalogStick : public ControlGroup + { + public: + + template + void GetState( C* const x, C* const y, const unsigned int base, const unsigned int range ) + { + // this is all a mess + + ControlState yy = controls[0]->control_ref->State() - controls[1]->control_ref->State(); + ControlState xx = controls[3]->control_ref->State() - controls[2]->control_ref->State(); + + ControlState deadzone = settings[0]->value; + ControlState square = settings[1]->value; + ControlState m = controls[4]->control_ref->State(); + + // modifier code + if ( m ) + { + yy = (abs(yy)>deadzone) * sign(yy) * m; + xx = (abs(xx)>deadzone) * sign(xx) * m; + } + + // deadzone / square stick code + if ( deadzone || square ) + { + // this section might be all wrong, but its working good enough, i think + + ControlState ang = atan2( yy, xx ); + ControlState ang_sin = sin(ang); + ControlState ang_cos = cos(ang); + + // the amt a full square stick would have at current angle + ControlState square_full = std::min( 1/abs(ang_sin), 1/abs(ang_cos) ); + + // the amt a full stick would have that was ( user setting squareness) at current angle + // i think this is more like a pointed circle rather than a rounded square like it should be + ControlState stick_full = ( 1 + ( square_full - 1 ) * square ); + + ControlState dist = sqrt(xx*xx + yy*yy); + + // dead zone code + dist = std::max( 0.0f, dist - deadzone * stick_full ); + dist /= ( 1 - deadzone ); + + // square stick code + ControlState amt = ( dist ) / stick_full; + dist -= ((square_full - 1) * amt * square); + + yy = std::max( -1.0f, std::min( 1.0f, ang_sin * dist ) ); + xx = std::max( -1.0f, std::min( 1.0f, ang_cos * dist ) ); + } + + *y = C( yy * range + base ); + *x = C( xx * range + base ); + } + + AnalogStick( const char* const _name ); + + }; + + class Buttons : public ControlGroup + { + public: + Buttons( const char* const _name ); + + template + void GetState( C* const buttons, const C* bitmasks ) + { + std::vector::iterator i = controls.begin(), + e = controls.end(); + for ( ; i!=e; ++i, ++bitmasks ) + if ( (*i)->control_ref->State() > settings[0]->value ) // threshold + *buttons |= *bitmasks; + } + + }; + + class MixedTriggers : public ControlGroup + { + public: + + template + void GetState( C* const digital, const C* bitmasks, S* analog, const unsigned int range ) + { + const unsigned int trig_count = ((unsigned int) (controls.size() / 2)); + for ( unsigned int i=0; icontrol_ref->State() > settings[0]->value ) //threshold + { + *analog = range; + *digital |= *bitmasks; + } + else + *analog = controls[i+trig_count]->control_ref->State() * range; + + } + } + + MixedTriggers( const char* const _name ); + + }; + + virtual ~ControllerEmu(); + + virtual std::string GetName() const = 0; + + void LoadConfig( IniFile::Section& sec ); + void SaveConfig( IniFile::Section& sec ); + void UpdateDefaultDevice(); + + void UpdateReferences( ControllerInterface& devi ); + + std::vector< ControlGroup* > groups; + + + ControllerInterface::DeviceQualifier default_device; + +}; + + + + +#endif diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerEmu/GCPad/GCPad.cpp b/Source/Plugins/Plugin_GCPadNew/Src/ControllerEmu/GCPad/GCPad.cpp new file mode 100644 index 0000000000..d4a44449ea --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerEmu/GCPad/GCPad.cpp @@ -0,0 +1,97 @@ + +#include "GCPad.h" + +// this is all temporary, but sticking with the padspecs ...for now +const u16 button_bitmasks[] = +{ + PAD_BUTTON_A, + PAD_BUTTON_B, + PAD_BUTTON_X, + PAD_BUTTON_Y, + PAD_TRIGGER_Z, + PAD_BUTTON_START +}; + +const u16 trigger_bitmasks[] = +{ + PAD_TRIGGER_L, + PAD_TRIGGER_R, +}; + +const u16 dpad_bitmasks[] = +{ + PAD_BUTTON_UP, PAD_BUTTON_DOWN, PAD_BUTTON_LEFT, PAD_BUTTON_RIGHT +}; + +const char* const named_buttons[] = +{ + "A", + "B", + "X", + "Y", + "Z", + "Start", +}; + +const char* const named_triggers[] = +{ + "L", "R", "L-Analog", "R-Analog" +}; + +GCPad::GCPad( const unsigned int index ) : m_index(index) +{ + + // buttons + groups.push_back( m_buttons = new Buttons( "Buttons" ) ); + for ( unsigned int i=0; i < sizeof(named_buttons)/sizeof(*named_buttons); ++i ) + m_buttons->controls.push_back( new ControlGroup::Input( named_buttons[i] ) ); + + // sticks + groups.push_back( m_main_stick = new AnalogStick( "Main Stick" ) ); + groups.push_back( m_c_stick = new AnalogStick( "C-Stick" ) ); + + // triggers + groups.push_back( m_triggers = new MixedTriggers( "Triggers" ) ); + for ( unsigned int i=0; i < sizeof(named_triggers)/sizeof(*named_triggers); ++i ) + m_triggers->controls.push_back( new ControlGroup::Input( named_triggers[i] ) ); + + // dpad + groups.push_back( m_dpad = new Buttons( "D-Pad" ) ); + for ( unsigned int i=0; i < 4; ++i ) + m_dpad->controls.push_back( new ControlGroup::Input( named_directions[i] ) ); + + // rumble + groups.push_back( m_rumble = new ControlGroup( "Rumble" ) ); + m_rumble->controls.push_back( new ControlGroup::Output( "Motor" ) ); + +} + +std::string GCPad::GetName() const +{ + return std::string("GCPad") + char('1'+m_index); +} + +void GCPad::GetInput( SPADStatus* const pad ) +{ + std::vector< ControlGroup::Control* >::iterator i,e; + + // buttons + m_buttons->GetState( &pad->button, button_bitmasks ); + + // TODO: set analog A/B to full or w/e + + // dpad + m_dpad->GetState( &pad->button, dpad_bitmasks ); + + // sticks + m_main_stick->GetState( &pad->stickX, &pad->stickY, 0x80, 127 ); + m_c_stick->GetState( &pad->substickX, &pad->substickY, 0x80, 127 ); + + // triggers + m_triggers->GetState( &pad->button, trigger_bitmasks, &pad->triggerLeft, 0xFF ); +} + +void GCPad::SetOutput( const bool on ) +{ + m_rumble->controls[0]->control_ref->State( on ); +} diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerEmu/GCPad/GCPad.h b/Source/Plugins/Plugin_GCPadNew/Src/ControllerEmu/GCPad/GCPad.h new file mode 100644 index 0000000000..216fcc3abe --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerEmu/GCPad/GCPad.h @@ -0,0 +1,31 @@ +#ifndef _CONEMU_GCPAD_H_ +#define _CONEMU_GCPAD_H_ + +#include "../../ControllerEmu.h" + +class GCPad : public ControllerEmu +{ +public: + + GCPad( const unsigned int index ); + void GetInput( SPADStatus* const pad ); + void SetOutput( const bool on ); + + std::string GetName() const; + + +private: + + Buttons* m_buttons; + AnalogStick* m_main_stick; + AnalogStick* m_c_stick; + Buttons* m_dpad; + MixedTriggers* m_triggers; + ControlGroup* m_rumble; + + const unsigned int m_index; + +}; + + +#endif diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerEmu/Wiimote/Wiimote.cpp b/Source/Plugins/Plugin_GCPadNew/Src/ControllerEmu/Wiimote/Wiimote.cpp new file mode 100644 index 0000000000..ee5941a1d2 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerEmu/Wiimote/Wiimote.cpp @@ -0,0 +1,257 @@ + +#include "Wiimote.h" + +// buttons + +#define WIIMOTE_PAD_LEFT 0x01 +#define WIIMOTE_PAD_RIGHT 0x02 +#define WIIMOTE_PAD_DOWN 0x04 +#define WIIMOTE_PAD_UP 0x08 +#define WIIMOTE_PLUS 0x10 + +#define WIIMOTE_TWO 0x0100 +#define WIIMOTE_ONE 0x0200 +#define WIIMOTE_B 0x0400 +#define WIIMOTE_A 0x0800 +#define WIIMOTE_MINUS 0x1000 +#define WIIMOTE_HOME 0x8000 + +// reports + +#define REPORT_UNKNOWN 0x10 +#define REPORT_LEDS 0x11 +#define REPORT_DATA_MODE 0x12 +#define REPORT_IR_ENABLE 0x13 +#define REPORT_SPEAKER_ENABLE 0x14 +#define REPORT_STATUS_REQUEST 0x15 +#define REPORT_WRITE_MEMORY 0x16 +#define REPORT_READ_MEMORY 0x17 +#define REPORT_SPEAKER_DATA 0x18 +#define REPORT_SPEAKER_MUTE 0x19 +#define REPORT_IR_ENABLE_2 0x1a +#define REPORT_STATUS 0x20 +#define REPORT_READ_MEMORY_DATA 0x21 +#define REPORT_ACKNOWLEDGE_OUTPUT 0x22 +//#define REPORT_DATA_REPORTS 0x30-0x3f + +// reporting modes + +#define REPORT_MODE_CORE 0x30 +#define REPORT_MODE_CORE_ACCEL 0x31 +#define REPORT_MODE_CORE_EXTEN8 0x32 +#define REPORT_MODE_CORE_ACCEL_IR12 0x33 +#define REPORT_MODE_CORE_EXTEN19 0x34 +#define REPORT_MODE_CORE_ACCEL_EXTEN16 0x35 +#define REPORT_MODE_CORE_IR10_EXTEN9 0x36 +#define REPORT_MODE_CORE_ACCEL_IR10_EXTEN6 0x37 +#define REPORT_MODE_EXTEN21 0x3d +#define REPORT_MODE_IL_CORE_ACCEL_IR36_1 0x3e +#define REPORT_MODE_IL_CORE_ACCEL_IR36_2 0x3f + +// this is all temporary, but sticking with the padspecs ...for now +const u16 button_bitmasks[] = +{ + WIIMOTE_A, WIIMOTE_B, WIIMOTE_ONE, WIIMOTE_TWO, WIIMOTE_MINUS, WIIMOTE_PLUS, WIIMOTE_HOME +}; + +const u16 dpad_bitmasks[] = +{ + WIIMOTE_PAD_UP, WIIMOTE_PAD_DOWN, WIIMOTE_PAD_LEFT, WIIMOTE_PAD_RIGHT +}; + +const char* const named_buttons[] = +{ + "A", + "B", + "One", + "Two", + "Minus", + "Plus", + "Home", +}; + +const char * const named_groups[] = +{ + "Buttons", "D-Pad" +}; + +Wiimote::Wiimote( const unsigned int index ) : m_index(index), m_report_mode(REPORT_MODE_CORE) +{ + + // buttons + groups.push_back( m_buttons = new Buttons( named_groups[0] ) ); + for ( unsigned int i=0; i < sizeof(named_buttons)/sizeof(*named_buttons); ++i ) + m_buttons->controls.push_back( new ControlGroup::Input( named_buttons[i] ) ); + + // dpad + groups.push_back( m_dpad = new Buttons( named_groups[1] ) ); + for ( unsigned int i=0; i < 4; ++i ) + m_dpad->controls.push_back( new ControlGroup::Input( named_directions[i] ) ); + + // rumble + groups.push_back( m_rumble = new ControlGroup( "Rumble" ) ); + m_rumble->controls.push_back( new ControlGroup::Output( "Motor" ) ); + +} + +std::string Wiimote::GetName() const +{ + return std::string("Wiimote") + char('1'+m_index); +} + +void Wiimote::Cycle() +{ + + HIDReport rpt; + rpt << (u8)m_report_mode; + + switch ( m_report_mode ) + { + //(a1) 30 BB BB + case REPORT_MODE_CORE : + { + u16 buttons; + m_buttons->GetState( &buttons, button_bitmasks ); + m_dpad->GetState( &buttons, dpad_bitmasks ); + rpt << buttons; + } + break; + //(a1) 31 BB BB AA AA AA + case REPORT_MODE_CORE_ACCEL : + { + u16 buttons; + m_buttons->GetState( &buttons, button_bitmasks ); + m_dpad->GetState( &buttons, dpad_bitmasks ); + rpt << buttons << (u16)0 << (u8)0; + } + break; + //(a1) 32 BB BB EE EE EE EE EE EE EE EE + case REPORT_MODE_CORE_EXTEN8 : + { + u16 buttons; + m_buttons->GetState( &buttons, button_bitmasks ); + m_dpad->GetState( &buttons, dpad_bitmasks ); + rpt << buttons << (u64)0; + } + break; + //(a1) 33 BB BB AA AA AA II II II II II II II II II II II II + case REPORT_MODE_CORE_ACCEL_IR12 : + { + u16 buttons; + m_buttons->GetState( &buttons, button_bitmasks ); + m_dpad->GetState( &buttons, dpad_bitmasks ); + rpt << buttons << (u64)0 << (u32)0 << (u16)0 << (u8)0; + } + break; + //(a1) 34 BB BB EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE + case REPORT_MODE_CORE_EXTEN19 : + { + u16 buttons; + m_buttons->GetState( &buttons, button_bitmasks ); + m_dpad->GetState( &buttons, dpad_bitmasks ); + rpt << buttons << (u64)0 << (u64)0 << (u16)0 << (u8)0; + } + break; + //(a1) 35 BB BB AA AA AA EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE + case REPORT_MODE_CORE_ACCEL_EXTEN16 : + { + u16 buttons; + m_buttons->GetState( &buttons, button_bitmasks ); + m_dpad->GetState( &buttons, dpad_bitmasks ); + rpt << buttons << (u64)0 << (u64)0 << (u16)0 << (u8)0; + } + break; + //(a1) 36 BB BB II II II II II II II II II II EE EE EE EE EE EE EE EE EE + case REPORT_MODE_CORE_IR10_EXTEN9 : + { + u16 buttons; + m_buttons->GetState( &buttons, button_bitmasks ); + m_dpad->GetState( &buttons, dpad_bitmasks ); + rpt << buttons << (u64)0 << (u64)0 << (u16)0 << (u8)0; + } + break; + //(a1) 37 BB BB AA AA AA II II II II II II II II II II EE EE EE EE EE EE + case REPORT_MODE_CORE_ACCEL_IR10_EXTEN6 : + { + u16 buttons; + m_buttons->GetState( &buttons, button_bitmasks ); + m_dpad->GetState( &buttons, dpad_bitmasks ); + rpt << buttons << (u64)0 << (u64)0 << (u16)0 << (u8)0; + } + break; + //(a1) 3d EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE + case REPORT_MODE_EXTEN21 : + { + u16 buttons; + m_buttons->GetState( &buttons, button_bitmasks ); + m_dpad->GetState( &buttons, dpad_bitmasks ); + rpt << buttons << (u64)0 << (u64)0 << (u16)0 << (u8)0; + } + break; + //(a1) 3e/3f BB BB AA II II II II II II II II II II II II II II II II II II + case REPORT_MODE_IL_CORE_ACCEL_IR36_1 : + case REPORT_MODE_IL_CORE_ACCEL_IR36_2 : + { + u16 buttons; + m_buttons->GetState( &buttons, button_bitmasks ); + m_dpad->GetState( &buttons, dpad_bitmasks ); + //rpt << buttons << (u64)0 << (u64)0 << (u64)0 << (u64)0 << (u32)0 << (u8)0; + rpt << buttons << (u64)0 << (u64)0 << (u16)0 << (u8)0; + } + break; + default : + break; + } + +} + +Wiimote& Wiimote::operator<<( HIDReport& rpt_in ) +{ + const u8 report_id = rpt_in.front(); rpt_in.pop(); + + HIDReport rpt_out; + + switch ( report_id ) + { + case REPORT_LEDS : + break; + case REPORT_DATA_MODE : + { + rpt_in.pop(); // continuous + m_report_mode = rpt_in.front(); + } + break; + case REPORT_IR_ENABLE : + break; + case REPORT_SPEAKER_ENABLE : + break; + case REPORT_STATUS_REQUEST : + { + u16 buttons; + m_buttons->GetState( &buttons, button_bitmasks ); + m_dpad->GetState( &buttons, dpad_bitmasks ); + rpt_out << (u8)REPORT_STATUS << buttons << (u16)0 << (u8)0 << (u8)0xFF; + } + break; + case REPORT_WRITE_MEMORY : + break; + case REPORT_READ_MEMORY : + break; + case REPORT_SPEAKER_DATA : + break; + case REPORT_SPEAKER_MUTE : + break; + case REPORT_IR_ENABLE_2 : + break; + case REPORT_STATUS : + break; + case REPORT_READ_MEMORY_DATA : + break; + case REPORT_ACKNOWLEDGE_OUTPUT : + break; + default : + break; + } + + return *this; +} diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerEmu/Wiimote/Wiimote.h b/Source/Plugins/Plugin_GCPadNew/Src/ControllerEmu/Wiimote/Wiimote.h new file mode 100644 index 0000000000..f796b9ca05 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerEmu/Wiimote/Wiimote.h @@ -0,0 +1,46 @@ +#ifndef _CONEMU_WIIMOTE_H_ +#define _CONEMU_WIIMOTE_H_ + +#include "../../ControllerEmu.h" + +#include + +class HIDReport : public std::queue +{ +public: + template + HIDReport& operator<<( const T& t ) + { + const u8* const e = ((u8*)&t) + sizeof(t); + const u8* i = (u8*)&t; + for ( ;i::const_iterator d = m_devices.begin(), + Devices_end = m_devices.end(); + for ( ;d != Devices_end; ++d ) + { + std::vector::const_iterator o = (*d)->Outputs().begin(), + e = (*d)->Outputs().end(); + // set outputs to ZERO before destroying device + for ( ;o!=e; ++o) + (*d)->SetOutputState( *o, 0 ); + // update output + (*d)->UpdateOutput(); + //delete device + delete *d; + } + + m_devices.clear(); + +#ifdef CIFACE_USE_XINPUT + // nothing needed +#endif +#ifdef CIFACE_USE_DIRECTINPUT + // nothing needed +#endif +#ifdef CIFACE_USE_XLIB + // nothing needed +#endif +#ifdef CIFACE_USE_SDL + // there seems to be some sort of memory leak with SDL, quit isn't freeing everything up + SDL_Quit(); +#endif + + m_is_init = false; +} + +// +// SetHwnd +// +// sets the hwnd used for some crap when initializing, use before calling Init +// +void ControllerInterface::SetHwnd( void* const hwnd ) +{ + m_hwnd = hwnd; +} + +// +// UpdateInput +// +// update input for all devices, return true if all devices returned successful +// +bool ControllerInterface::UpdateInput() +{ + size_t ok_count = 0; + + std::vector::const_iterator d = m_devices.begin(), + e = m_devices.end(); + for ( ;d != e; ++d ) + { + if ( (*d)->UpdateInput() ) + ++ok_count; + else + (*d)->ClearInputState(); + } + + return ( m_devices.size() == ok_count ); +} + +// +// UpdateOutput +// +// update output for all devices, return true if all devices returned successful +// +bool ControllerInterface::UpdateOutput() +{ + size_t ok_count = 0; + + std::vector::const_iterator d = m_devices.begin(), + e = m_devices.end(); + for ( ;d != e; ++d ) + (*d)->UpdateOutput(); + + return ( m_devices.size() == ok_count ); +} + +// +// Devices +// +// i dont really like this but, +// return : constant copy of the devices vector +// +const std::vector& ControllerInterface::Devices() +{ + return m_devices; +} + +// +// Device :: ~Device +// +// dtor, delete all inputs/outputs on device destruction +// +ControllerInterface::Device::~Device() +{ + { + // delete inputs + std::vector::iterator i = inputs.begin(), + e = inputs.end(); + for ( ;i!=e; ++i) + delete *i; + } + + { + // delete outputs + std::vector::iterator o = outputs.begin(), + e = outputs.end(); + for ( ;o!=e; ++o) + delete *o; + } +} + +// +// Device :: ClearInputState +// +// device classes should override this func +// ControllerInterface will call this when the device returns failure durring UpdateInput +// used to try to set all buttons and axes to their default state when user unplugs a gamepad durring play +// buttons/axes that were held down at the time of unplugging should be seen as not pressed after unplugging +// +void ControllerInterface::Device::ClearInputState() +{ + // this is going to be called for every UpdateInput call that fails + // kinda slow but, w/e, should only happen when user unplugs a device while playing +} + +// +// Device :: Inputs +// +// get a const version of the device's input vector +// +const std::vector& ControllerInterface::Device::Inputs() +{ + return inputs; +} + +// +// Device :: Outputs +// +// get a const version of the device's outputs vector +// +const std::vector& ControllerInterface::Device::Outputs() +{ + return outputs; +} + +// +// HasInit +// +// check if interface is inited +// +bool ControllerInterface::IsInit() +{ + return m_is_init; +} + +// +// InputReference :: State +// +// get the state of an input reference +// override function for ControlReference::State ... +// +ControlState ControllerInterface::InputReference::State( const ControlState ignore ) +{ + if ( NULL == device ) + return 0; + + ControlState state; + // this mode thing will be turned into a switch statement + switch ( mode ) + { + // OR + case 0 : + { + state = 0; + std::vector::const_iterator ci = controls.begin(), + ce = controls.end(); + for ( ; ci != ce; ++ci ) + state = std::max( state, device->GetInputState( (Device::Input*)*ci ) ); // meh casting + break; + } + // AND + case 1 : + { + // TODO: i think i can remove the if here + + state = 1; + bool is_bound = false; + std::vector::const_iterator ci = controls.begin(), + ce = controls.end(); + for ( ; ci != ce; ++ci ) + { + is_bound = true; + state = std::min( state, device->GetInputState( (Device::Input*)*ci ) ); // meh casting + } + if ( !is_bound ) + state = 0; + break; + } + // NOT + case 2 : + { + state = 0; + std::vector::const_iterator ci = controls.begin(), + ce = controls.end(); + for ( ; ci != ce; ++ci ) + state = std::max( state, device->GetInputState( (Device::Input*)*ci ) ); // meh casting + state = std::max( 0.0, 1.0 - state ); + break; + } + } + + return std::min( 1.0f, state * range ); +} + +// +// OutputReference :: State +// +// set the state of all binded outputs +// overrides ControlReference::State .. combined them so i could make the gui simple / inputs == same as outputs one list +// i was lazy and it works so watever +// +ControlState ControllerInterface::OutputReference::State( const ControlState state ) +{ + std::vector::iterator ci = controls.begin(), + ce = controls.end(); + for ( ; ci != ce; ++ci ) + device->SetOutputState( (Device::Output*)*ci, state * range ); // casting again + + return state; // just return the output, watever +} + +// +// DeviceQualifier :: ToString +// +// get string from a device qualifier / serialize +// +std::string ControllerInterface::DeviceQualifier::ToString() const +{ + if ( source.empty() && (id < 0) && name.empty() ) + return ""; + std::ostringstream ss; + ss << source << '/'; + if ( id > -1 ) + ss << id; + ss << '/' << name; + return ss.str(); +} + +// +// DeviceQualifier :: FromString +// +// set a device qualifier from a string / unserialize +// +void ControllerInterface::DeviceQualifier::FromString(const std::string& str) +{ + std::istringstream ss(str); + + // good + std::getline( ss, source = "", '/' ); + + + // dum + std::getline( ss, name, '/' ); + std::istringstream(name) >> (id = -1); + + // good + std::getline( ss, name = ""); +} + +// +// DeviceQualifier :: FromDevice +// +// set a device qualifier from a device +// +void ControllerInterface::DeviceQualifier::FromDevice(const ControllerInterface::Device* const dev) +{ + name = dev->GetName(); + id = dev->GetId(); + source= dev->GetSource(); +} + +// +// DeviceQualifier = = Device* +// +// check if a device matches a device qualifier +// +bool ControllerInterface::DeviceQualifier::operator==(const ControllerInterface::Device* const dev) const +{ + if ( dev->GetName() == name ) + if ( dev->GetId() == id ) + if ( dev->GetSource() == source ) + return true; + return false; +} + +// +// ControlQualifier = FromControl +// +// set a control qualifier from a device control +// +void ControllerInterface::ControlQualifier::FromControl(const ControllerInterface::Device::Control* const c) +{ + // hardly needs a function for this + name = c->GetName(); +} + +// +// ControlQualifier = = Device :: Control* +// +// check if a control qualifier matches a device control +// if qualifier name is /.../ form, uses a regular expression match +// also |control1|control2| form, || matches all +// +bool ControllerInterface::ControlQualifier::operator==(const ControllerInterface::Device::Control* const control) const +{ + if ( name.size() ) + { +#ifdef CIFACE_USE_REGEX + if ( '/' == name[0] && '/' == (*name.rbegin()) ) // check if regex + { + wxRegEx re( + wxString::FromAscii(name.substr( 1, name.size()-2).c_str()).Prepend(wxT("^(")).Append(wxT(")$")) + , wxRE_ADVANCED | wxRE_EXTENDED | wxRE_NOSUB | wxRE_ICASE ); + + if ( re.IsValid() ) + return re.Matches( wxString::FromAscii( control->GetName().c_str() ) ); + else + return true; + } +#endif + if ( '|' == name[0] && '|' == (*name.rbegin()) ) // check if using |button1|button2| format + { + return ( name.find( '|' + control->GetName() + '|' ) != name.npos || "||" == name ); + } + } + return (control->GetName() == name); +} + +// +// UpdateReference +// +// updates a controlreference's binded devices then update binded controls +// need to call this after changing a device qualifier on a control reference +// if the device qualifier hasnt changed, the below functions: "UpdateControls" can be used +// +void ControllerInterface::UpdateReference( ControllerInterface::ControlReference* ref ) +{ + ref->device = NULL; + std::vector::const_iterator d = m_devices.begin(), + e = m_devices.end(); + for ( ; d!=e; ++d ) + if ( ref->device_qualifier == *d ) + { + ref->device = *d; + break; + } + ref->UpdateControls(); +} + +// +// InputReference :: UpdateControls +// +// after changing a control qualifier, need to call this to rebind the new matching controls +// +void ControllerInterface::InputReference::UpdateControls() +{ + controls.clear(); + if ( device ) + { + std::vector::const_iterator i = device->Inputs().begin(), + e = device->Inputs().end(); + for ( ;i != e; ++i ) + if ( control_qualifier == *i ) + controls.push_back( *i ); + } +} + +// +// OutputReference :: UpdateControls +// +// same as the inputRef version +// after changing a control qualifier, need to call this to rebind the new matching controls +// +void ControllerInterface::OutputReference::UpdateControls() +{ + controls.clear(); + if ( device ) + { + std::vector::const_iterator i = device->Outputs().begin(), + e = device->Outputs().end(); + for ( ;i != e; ++i ) + if ( control_qualifier == *i ) + controls.push_back( *i ); + } + +} + +// +// InputReference :: Detect +// +// wait for input on all binded devices +// supports waiting for n number of inputs +// supports not detecting inputs that were held down at the time of Detect start, +// which is useful for those crazy flightsticks that have certain buttons that are always held down +// or some crazy axes or something +// upon input, set control qualifier, update controls and return true +// else return false +// +bool ControllerInterface::InputReference::Detect( const unsigned int ms, const unsigned int count ) +{ + + unsigned int time = 0; + + // don't wait if we don't have a device + if ( device ) + { + bool* const states = new bool[device->Inputs().size()]; + + std::vector::const_iterator i = device->Inputs().begin(), + e = device->Inputs().end(); + for ( unsigned int n=0;i != e; ++i,++n ) + states[n] = ( device->GetInputState( *i ) > INPUT_DETECT_THRESHOLD ); + + std::vector detected; + + while ( (time < ms) && (detected.size() < count) ) + { + device->UpdateInput(); + std::vector::const_iterator i = device->Inputs().begin(), + e = device->Inputs().end(); + for ( unsigned int n=0;i != e; ++i,++n ) + { + if ( device->GetInputState( *i ) > INPUT_DETECT_THRESHOLD ) + { + if ( false == states[n] ) + if ( std::find( detected.begin(), detected.end(), *i ) == detected.end() ) + detected.push_back( *i ); + } + else + states[n] = false; + } + wxMilliSleep( 10 ); time += 10; + } + + delete states; + + if ( detected.size() == count ) + { + controls = detected; + + if ( controls.size() > 1 ) + { + control_qualifier.name = '|'; + std::vector::const_iterator i = controls.begin(), + e = controls.end(); + for ( ; i!=e; ++i ) + control_qualifier.name += (*i)->GetName() + '|'; + } + else + control_qualifier.FromControl( controls[0] ); + + return true; + } + } + return false; +} + +// +// OutputReference :: Detect +// +// totally different from the inputReference detect / i have them combined so it was simplier to make the gui. +// the gui doesnt know the difference between an input and an output / its odd but i was lazy and it was easy +// +// set all binded outputs to power for x milliseconds return false +// +bool ControllerInterface::OutputReference::Detect( const unsigned int ms, const unsigned int ignored ) +{ + // dont hang if we dont even have any controls mapped + if ( controls.size() ) + { + State( 1 ); + unsigned int slept = 0; + // this loop is to make stuff like flashing keyboard LEDs work + while ( ms > ( slept += 10 ) ) + { + device->UpdateOutput(); + wxMilliSleep( 10 ); + } + + State( 0 ); + device->UpdateOutput(); + } + return false; +} diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/ControllerInterface.h b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/ControllerInterface.h new file mode 100644 index 0000000000..e216ba4d74 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/ControllerInterface.h @@ -0,0 +1,258 @@ +#ifndef _DEVICEINTERFACE_H_ +#define _DEVICEINTERFACE_H_ + +#include +#include +#include +#include +#include + +//#define CIFACE_USE_REGEX + +// enable disable sources +#ifdef _WIN32 + #define CIFACE_USE_XINPUT + #define CIFACE_USE_DIRECTINPUT_JOYSTICK + #define CIFACE_USE_DIRECTINPUT_KBM + #define CIFACE_USE_DIRECTINPUT +#endif +#if defined(HAVE_X11) && HAVE_X11 +// Xlib is not tested at all currently, it is like 80% complete at least though + #define CIFACE_USE_XLIB +#endif +#ifndef CIFACE_USE_DIRECTINPUT_JOYSTICK + #define CIFACE_USE_SDL +#endif + +#ifdef CIFACE_USE_REGEX + #include +#endif +#include +#include + +// idk in case i wanted to change it to double or somethin, idk what's best +typedef float ControlState; + +// +// ControllerInterface +// +// some crazy shit i made to control different device inputs and outputs +// from lots of different sources, hopefully more easily +// +class ControllerInterface +{ +public: + + // + // Device + // + // Pretty obviously, a device class + // + class Device + { + public: + + // + // Control + // + // control includes inputs and outputs + // + class Control // input or output + { + public: + virtual std::string GetName() const = 0; + }; + + // + // Input + // + // an input on a device + // + class Input : public Control + { + public: + virtual ~Input() {} + }; + + // + // Output + // + // guess wut it is, yup and output + // + class Output : public Control + { + public: + virtual ~Output() {} + }; + + virtual ~Device(); + + virtual std::string GetName() const = 0; + virtual int GetId() const = 0; + virtual std::string GetSource() const = 0; + + virtual ControlState GetInputState( const Input* const input ) = 0; + virtual void SetOutputState( const Output* const output, const ControlState state ) = 0; + + virtual bool UpdateInput() = 0; + virtual bool UpdateOutput() = 0; + + virtual void ClearInputState(); + + const std::vector< Input* >& Inputs(); + const std::vector< Output* >& Outputs(); + + protected: + std::vector inputs; + std::vector outputs; + + }; + + // + // DeviceQualifier + // + // device qualifier used to match devices + // currently has ( source, id, name ) properties which match a device + // + class DeviceQualifier + { + public: + DeviceQualifier() : id(-1){} + DeviceQualifier( const std::string& _source, const int _id, const std::string& _name ) + : source(_source), id(_id), name(_name) {} + bool operator==(const Device* const dev) const; + void FromDevice(const Device* const dev); + void FromString(const std::string& str); + std::string ToString() const; + + std::string source; + int id; + std::string name; + }; + + // + // ControlQualifier + // + // control qualifier includes input and output qualifiers + // used to match controls on devices, only has name property + // if name is blank it matches nothing, if name is /../ form, it matches controls using a regex + // |input1|input2| form as well, || matches anything, might change this to * or something + // + class ControlQualifier + { + public: + ControlQualifier() {}; + ControlQualifier( const std::string& _name ) : name(_name) {} + virtual bool operator==(const Device::Control* const in) const; + void FromControl(const Device::Control* const in); + + std::string name; + }; + + // + // InputQualifier + // + // ControlQualifier for inputs + // + class InputQualifier : public ControlQualifier + { + public: + InputQualifier() {}; + InputQualifier( const std::string& _name ) : ControlQualifier(_name) {} + }; + + // + // OutputQualifier + // + // ControlQualifier for outputs + // + class OutputQualifier : public ControlQualifier + { + public: + OutputQualifier() {}; + OutputQualifier( const std::string& _name ) : ControlQualifier(_name) {} + }; + + // + // ControlReference + // + // these are what you create to actually use the inputs, InputReference or OutputReference + // they have a vector < struct { device , vector < controls > } > + // + // after being binded to devices and controls with ControllerInterface::UpdateReference, + // each one can binded to 0+ devices, and 0+ controls on each device + // ControlReference can update its own controls when you change its control qualifier + // using ControlReference::UpdateControls but when you change its device qualifer + // you must use ControllerInterface::UpdateReference + // + class ControlReference + { + public: + ControlReference( const bool _is_input ) : range(1), is_input(_is_input), device(NULL) {} + + virtual ControlState State( const ControlState state = 0 ) = 0; + virtual bool Detect( const unsigned int ms, const unsigned int count = 1 ) = 0; + virtual void UpdateControls() = 0; + + ControlState range; + + DeviceQualifier device_qualifier; + ControlQualifier control_qualifier; + + const bool is_input; + Device* device; + + std::vector controls; + + }; + + // + // InputReference + // + // control reference for inputs + // + class InputReference : public ControlReference + { + public: + InputReference() : ControlReference( true ) {} + ControlState State( const ControlState state ); + bool Detect( const unsigned int ms, const unsigned int count ); + void UpdateControls(); + + unsigned int mode; + }; + + // + // OutputReference + // + // control reference for outputs + // + class OutputReference : public ControlReference + { + public: + OutputReference() : ControlReference( false ) {} + ControlState State( const ControlState state ); + bool Detect( const unsigned int ms, const unsigned int count ); + void UpdateControls(); + }; + + ControllerInterface() : m_is_init(false) {} + + void SetHwnd( void* const hwnd ); + void Init(); + void DeInit(); + bool IsInit(); + + void UpdateReference( ControlReference* control ); + bool UpdateInput(); + bool UpdateOutput(); + + const std::vector& Devices(); + +private: + bool m_is_init; + std::vector m_devices; + void* m_hwnd; +}; + +#endif diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/DirectInput.cpp b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/DirectInput.cpp new file mode 100644 index 0000000000..634dab4196 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/DirectInput.cpp @@ -0,0 +1,35 @@ +#include "../ControllerInterface.h" + +#ifdef CIFACE_USE_DIRECTINPUT + +#include "DirectInput.h" + +#pragma comment(lib, "Dinput8.lib") +#pragma comment(lib, "dxguid.lib") + +namespace ciface +{ +namespace DirectInput +{ + +void Init( std::vector& devices/*, HWND hwnd*/ ) +{ + IDirectInput8* idi8; + if ( DI_OK != DirectInput8Create( GetModuleHandle(NULL), DIRECTINPUT_VERSION, IID_IDirectInput8, (LPVOID*)&idi8, NULL ) ) + return; + +#ifdef CIFACE_USE_DIRECTINPUT_KBM + InitKeyboardMouse( idi8, devices ); +#endif +#ifdef CIFACE_USE_DIRECTINPUT_JOYSTICK + InitJoystick( idi8, devices/*, hwnd*/ ); +#endif + + idi8->Release(); + +} + +} +} + +#endif diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/DirectInput.h b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/DirectInput.h new file mode 100644 index 0000000000..0686f870a2 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/DirectInput.h @@ -0,0 +1,29 @@ +#ifndef _CIFACE_DIRECTINPUT_H_ +#define _CIFACE_DIRECTINPUT_H_ + +#include "../ControllerInterface.h" + +#define DIRECTINPUT_VERSION 0x0800 +#define WIN32_LEAN_AND_MEAN +#define NOMINMAX +#include +#include + +#ifdef CIFACE_USE_DIRECTINPUT_JOYSTICK + #include "DirectInputJoystick.h" +#endif +#ifdef CIFACE_USE_DIRECTINPUT_KBM + #include "DirectInputKeyboardMouse.h" +#endif + +namespace ciface +{ +namespace DirectInput +{ + +void Init( std::vector& devices/*, HWND hwnd*/ ); + +} +} + +#endif diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/DirectInputJoystick.cpp b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/DirectInputJoystick.cpp new file mode 100644 index 0000000000..e8a22fb1a7 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/DirectInputJoystick.cpp @@ -0,0 +1,353 @@ +#include "../ControllerInterface.h" + +#ifdef CIFACE_USE_DIRECTINPUT_JOYSTICK + +#include "DirectInputJoystick.h" + +namespace ciface +{ +namespace DirectInput +{ + +std::string TStringToString( const std::basic_string& in ) +{ + const int size = WideCharToMultiByte( CP_UTF8, 0, in.data(), int(in.length()), NULL, 0, NULL, NULL ); + + if ( 0 == size ) + return ""; + + char* const data = new char[size]; + WideCharToMultiByte( CP_UTF8, 0, in.data(), int(in.length()), data, size, NULL, NULL ); + const std::string out( data, size ); + delete[] data; + return out; +} + +//BOOL CALLBACK DIEnumEffectsCallback( LPCDIEFFECTINFO pdei, LPVOID pvRef ) +//{ +// ((std::vector*)pvRef)->push_back( *pdei ); +// return DIENUM_CONTINUE; +//} + +BOOL CALLBACK DIEnumDeviceObjectsCallback( LPCDIDEVICEOBJECTINSTANCE lpddoi, LPVOID pvRef ) +{ + ((std::vector*)pvRef)->push_back( *lpddoi ); + return DIENUM_CONTINUE; +} + +BOOL CALLBACK DIEnumDevicesCallback( LPCDIDEVICEINSTANCE lpddi, LPVOID pvRef ) +{ + ((std::vector*)pvRef)->push_back( *lpddi ); + return DIENUM_CONTINUE; +} + +void InitJoystick( IDirectInput8* const idi8, std::vector& devices/*, HWND hwnd*/ ) +{ + std::vector joysticks; + idi8->EnumDevices( DI8DEVCLASS_GAMECTRL, DIEnumDevicesCallback, (LPVOID)&joysticks, DIEDFL_ATTACHEDONLY ); + + // just a struct with an int that is set to ZERO by default + struct ZeroedInt{ZeroedInt():value(0){}unsigned int value;}; + // this is used to number the joysticks + // multiple joysticks with the same name shall get unique ids starting at 0 + std::map< std::basic_string, ZeroedInt > name_counts; + + std::vector::iterator i = joysticks.begin(), + e = joysticks.end(); + for ( ; i!=e; ++i ) + { + // TODO: this has potential to mess up on createdev or setdatafmt failure + LPDIRECTINPUTDEVICE8 js_device; + if ( DI_OK == idi8->CreateDevice( i->guidInstance, &js_device, NULL ) ) + if ( DI_OK == js_device->SetDataFormat( &c_dfDIJoystick ) ) + // using foregroundwindow seems like a hack + if ( DI_OK != js_device->SetCooperativeLevel( GetForegroundWindow(), DISCL_BACKGROUND | DISCL_EXCLUSIVE ) ) + { + // fall back to non-exclusive mode, with no rumble + if ( DI_OK != js_device->SetCooperativeLevel( NULL, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE ) ) + { + js_device->Release(); + continue; + } + } + + if ( DI_OK == js_device->Acquire() ) + { + Joystick* js = new Joystick( /*&*i, */js_device, name_counts[i->tszInstanceName].value++ ); + // only add if it has some inputs/outpus + if ( js->Inputs().size() || js->Outputs().size() ) + devices.push_back( js ); + else + delete js; + } + else + js_device->Release(); + + } +} + +Joystick::Joystick( /*const LPCDIDEVICEINSTANCE lpddi, */const LPDIRECTINPUTDEVICE8 device, const unsigned int index ) + : m_device(device) + , m_index(index) + //, m_name(TStringToString(lpddi->tszInstanceName)) +{ + // get joystick caps + DIDEVCAPS js_caps; + ZeroMemory( &js_caps, sizeof(js_caps) ); + js_caps.dwSize = sizeof(js_caps); + m_device->GetCapabilities(&js_caps); + + // max of 32 buttons and 4 hats / the limit of the data format i am using + js_caps.dwButtons = std::min((DWORD)32, js_caps.dwButtons); + js_caps.dwPOVs = std::min((DWORD)4, js_caps.dwPOVs); + + m_must_poll = ( ( js_caps.dwFlags & DIDC_POLLEDDATAFORMAT ) > 0 ); + + // buttons + for ( unsigned int i = 0; i < js_caps.dwButtons; ++i ) + inputs.push_back( new Button( i ) ); + // hats + for ( unsigned int i = 0; i < js_caps.dwPOVs; ++i ) + { + // each hat gets 4 input instances associated with it, (up down left right) + for ( unsigned int d = 0; d<4; ++d ) + inputs.push_back( new Hat( i, d ) ); + } + // axes / only the first 6 currently + std::vector axes; + m_device->EnumObjects( DIEnumDeviceObjectsCallback, (LPVOID)&axes, DIDFT_AXIS ); + for( unsigned int i = 0; iSetProperty( DIPROP_RANGE, &range.diph ); + // so i getproperty right afterward incase it didn't set :P + if ( DI_OK == m_device->GetProperty( DIPROP_RANGE, &range.diph ) ) + { + const LONG base = (range.lMin + range.lMax) / 2; + // each axis gets a negative and a positive input instance associated with it + inputs.push_back( new Axis( i, base, range.lMin-base ) ); + inputs.push_back( new Axis( i, base, range.lMax-base ) ); + } + } + // do people need sliders? maybe later + + // get supported ff effects + std::vector objects; + m_device->EnumObjects( DIEnumDeviceObjectsCallback, (LPVOID)&objects, DIDFT_AXIS ); + // got some ff axes or something + if ( objects.size() ) + { + // temporary + DWORD rgdwAxes[] = { DIJOFS_X, DIJOFS_Y }; + LONG rglDirection[] = { 0, 0 }; + DICONSTANTFORCE cf = { 0 }; + DIEFFECT eff; + ZeroMemory( &eff, sizeof( DIEFFECT ) ); + eff.dwSize = sizeof( DIEFFECT ); + eff.dwFlags = DIEFF_CARTESIAN | DIEFF_OBJECTOFFSETS; + eff.dwDuration = INFINITE; + eff.dwGain = DI_FFNOMINALMAX; + eff.dwTriggerButton = DIEB_NOTRIGGER; + eff.cAxes = std::min( (DWORD)2, (DWORD)objects.size() ); + eff.rgdwAxes = rgdwAxes; + eff.rglDirection = rglDirection; + eff.cbTypeSpecificParams = sizeof( DICONSTANTFORCE ); + eff.lpvTypeSpecificParams = &cf; + + LPDIRECTINPUTEFFECT pEffect; + if ( DI_OK == m_device->CreateEffect( GUID_ConstantForce, &eff, &pEffect, NULL ) ) + { + // temp + outputs.push_back( new Force( 0 ) ); + m_state_out.push_back( EffectState( pEffect ) ); + } + } + + // disable autocentering + if ( outputs.size() ) + { + DIPROPDWORD dipdw; + dipdw.diph.dwSize = sizeof( DIPROPDWORD ); + dipdw.diph.dwHeaderSize = sizeof( DIPROPHEADER ); + dipdw.diph.dwObj = 0; + dipdw.diph.dwHow = DIPH_DEVICE; + dipdw.dwData = FALSE; + m_device->SetProperty( DIPROP_AUTOCENTER, &dipdw.diph ); + } + + ClearInputState(); +} + +Joystick::~Joystick() +{ + // release the ff effect iface's + std::vector::iterator i = m_state_out.begin(), + e = m_state_out.end(); + for ( ; i!=e; ++i ) + { + i->iface->Stop(); + i->iface->Unload(); + i->iface->Release(); + } + + m_device->Unacquire(); + m_device->Release(); +} + +void Joystick::ClearInputState() +{ + ZeroMemory(&m_state_in, sizeof(m_state_in)); + // set hats to center + memset( m_state_in.rgdwPOV, 0xFF, sizeof(m_state_in.rgdwPOV) ); +} + +std::string Joystick::GetName() const +{ + DIPROPSTRING str; + ZeroMemory( &str, sizeof(str) ); + str.diph.dwSize = sizeof(str); + str.diph.dwHeaderSize = sizeof(str.diph); + str.diph.dwHow = DIPH_DEVICE; + m_device->GetProperty( DIPROP_PRODUCTNAME, &str.diph ); + return TStringToString( str.wsz ); + //return m_name; +} + +int Joystick::GetId() const +{ + return m_index; +} + +std::string Joystick::GetSource() const +{ + return "DirectInput"; +} + +// update IO + +bool Joystick::UpdateInput() +{ + if ( m_must_poll ) + if ( DI_OK != m_device->Poll() ) + return false; + + return ( DI_OK == m_device->GetDeviceState( sizeof(m_state_in), &m_state_in ) ); +} + +bool Joystick::UpdateOutput() +{ + // temporary + size_t ok_count = 0; + std::vector::iterator i = m_state_out.begin(), + e = m_state_out.end(); + for ( ; i!=e; ++i ) + { + if ( i->changed ) + { + i->changed = false; + DICONSTANTFORCE cf; + cf.lMagnitude = 10000 * i->magnitude; + + if ( cf.lMagnitude ) + { + DIEFFECT eff; + ZeroMemory( &eff, sizeof( eff ) ); + eff.dwSize = sizeof( DIEFFECT ); + eff.dwFlags = DIEFF_CARTESIAN | DIEFF_OBJECTOFFSETS; + eff.cbTypeSpecificParams = sizeof( cf ); + eff.lpvTypeSpecificParams = &cf; + // set params and start effect + ok_count += ( DI_OK == i->iface->SetParameters( &eff, DIEP_TYPESPECIFICPARAMS | DIEP_START ) ); + } + else + ok_count += ( DI_OK == i->iface->Stop() ); + } + else + ++ok_count; + } + + return ( m_state_out.size() == ok_count ); +} + +// get name + +std::string Joystick::Button::GetName() const +{ + std::ostringstream ss; + ss << "Button " << m_index; + return ss.str(); +} + +std::string Joystick::Axis::GetName() const +{ + std::ostringstream ss; + ss << "Axis " << m_index << ( m_range>0 ? '+' : '-' ); + return ss.str(); +} + +std::string Joystick::Hat::GetName() const +{ + std::ostringstream ss; + ss << "Hat " << m_index << ' ' << "NESW"[m_direction]; + return ss.str(); +} + +std::string Joystick::Force::GetName() const +{ + // temporary + return "Constant"; +} + +// get / set state + +ControlState Joystick::GetInputState( const ControllerInterface::Device::Input* const input ) +{ + return ((Input*)input)->GetState( &m_state_in ); +} + +void Joystick::SetOutputState( const ControllerInterface::Device::Output* const output, const ControlState state ) +{ + ((Output*)output)->SetState( state, &m_state_out[0] ); +} + +// get / set state + +ControlState Joystick::Axis::GetState( const DIJOYSTATE* const joystate ) +{ + return std::max( 0.0f, ControlState((&joystate->lX)[m_index]-m_base) / m_range ); +} + +ControlState Joystick::Button::GetState( const DIJOYSTATE* const joystate ) +{ + return ControlState( joystate->rgbButtons[m_index] > 0 ); +} + +ControlState Joystick::Hat::GetState( const DIJOYSTATE* const joystate ) +{ + // can this func be simplified ? + const DWORD val = joystate->rgdwPOV[m_index]; + // hat centered code from msdn + if ( 0xFFFF == LOWORD(val) ) + return 0; + return ( abs( (int)(val/4500-m_direction*2+8)%8 - 4) > 2 ); +} + +void Joystick::Force::SetState( const ControlState state, Joystick::EffectState* const joystate ) +{ + joystate[m_index].magnitude = state; + joystate[m_index].changed = true; +} + +} +} + +#endif diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/DirectInputJoystick.h b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/DirectInputJoystick.h new file mode 100644 index 0000000000..b98c805402 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/DirectInputJoystick.h @@ -0,0 +1,130 @@ +#ifndef _CIFACE_DIRECTINPUT_JOYSTICK_H_ +#define _CIFACE_DIRECTINPUT_JOYSTICK_H_ + +#include "../ControllerInterface.h" + +#define DIRECTINPUT_VERSION 0x0800 +#define WIN32_LEAN_AND_MEAN +#define NOMINMAX +#include +#include + +namespace ciface +{ +namespace DirectInput +{ + +void InitJoystick( IDirectInput8* const idi8, std::vector& devices/*, HWND hwnd*/ ); + +class Joystick : public ControllerInterface::Device +{ + friend class ControllerInterface; + friend class ControllerInterface::ControlReference; + +protected: + + struct EffectState + { + EffectState( LPDIRECTINPUTEFFECT eff ) : changed(0), iface(eff) {} + LPDIRECTINPUTEFFECT iface; + ControlState magnitude; + bool changed; + }; + + class Input : public ControllerInterface::Device::Input + { + friend class Joystick; + protected: + virtual ControlState GetState( const DIJOYSTATE* const joystate ) = 0; + }; + + // can probably eliminate this base class + class Output : public ControllerInterface::Device::Output + { + friend class Joystick; + protected: + virtual void SetState( const ControlState state, EffectState* const joystate ) = 0; + }; + + class Button : public Input + { + friend class Joystick; + public: + std::string GetName() const; + protected: + Button( const unsigned int index ) : m_index(index) {} + ControlState GetState( const DIJOYSTATE* const joystate ); + private: + const unsigned int m_index; + }; + + class Axis : public Input + { + friend class Joystick; + public: + std::string GetName() const; + protected: + Axis( const unsigned int index, const LONG base, const LONG range ) : m_index(index), m_base(base), m_range(range) {} + ControlState GetState( const DIJOYSTATE* const joystate ); + private: + const unsigned int m_index; + const LONG m_base; + const LONG m_range; + }; + + class Hat : public Input + { + friend class Joystick; + public: + std::string GetName() const; + protected: + Hat( const unsigned int index, const unsigned int direction ) : m_index(index), m_direction(direction) {} + ControlState GetState( const DIJOYSTATE* const joystate ); + private: + const unsigned int m_index; + const unsigned int m_direction; + }; + + class Force : public Output + { + friend class Joystick; + public: + std::string GetName() const; + protected: + Force( const unsigned int index ) : m_index(index) {} + void SetState( const ControlState state, EffectState* const joystate ); + private: + const unsigned int m_index; + }; + + bool UpdateInput(); + bool UpdateOutput(); + + ControlState GetInputState( const ControllerInterface::Device::Input* const input ); + void SetOutputState( const ControllerInterface::Device::Output* const input, const ControlState state ); + + void ClearInputState(); + +public: + Joystick( /*const LPCDIDEVICEINSTANCE lpddi, */const LPDIRECTINPUTDEVICE8 device, const unsigned int index ); + ~Joystick(); + + std::string GetName() const; + int GetId() const; + std::string GetSource() const; + +private: + const LPDIRECTINPUTDEVICE8 m_device; + const unsigned int m_index; + //const std::string m_name; + + DIJOYSTATE m_state_in; + std::vector m_state_out; + + bool m_must_poll; +}; + +} +} + +#endif diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/DirectInputKeyboardMouse.cpp b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/DirectInputKeyboardMouse.cpp new file mode 100644 index 0000000000..55a32f68a7 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/DirectInputKeyboardMouse.cpp @@ -0,0 +1,269 @@ +#include "../ControllerInterface.h" + +#ifdef CIFACE_USE_DIRECTINPUT_KBM + +#include "DirectInputKeyboardMouse.h" + +// TODO: maybe add a ClearInputState function to this device + + // (lower would be more sensitive) user can lower sensitivity by setting range + // seems decent here ( at 8 ), I dont think anyone would need more sensitive than this + // and user can lower it much farther than they would want to with the range +#define MOUSE_AXIS_SENSITIVITY 8 + + // if input hasn't been received for this many ms, mouse input will be skipped + // otherwise it is just some crazy value +#define DROP_INPUT_TIME 250 + +namespace ciface +{ +namespace DirectInput +{ + +struct +{ + const BYTE code; + const char* const name; +} named_keys[] = +{ +#include "NamedKeys.h" +}; + +struct +{ + const BYTE code; + const char* const name; +} named_lights[] = +{ + { VK_NUMLOCK, "NUM LOCK" }, + { VK_CAPITAL, "CAPS LOCK" }, + { VK_SCROLL, "SCROLL LOCK" } +}; + +void InitKeyboardMouse( IDirectInput8* const idi8, std::vector& devices ) +{ + // mouse and keyboard are a combined device, to allow shift+click and stuff + // if thats dumb, i will make a VirtualDevice class that just uses ranges of inputs/outputs from other devices + // so there can be a separated Keyboard and mouse, as well as combined KeyboardMouse + + // TODO: this has potential to not release devices if set datafmt or cooplevel fails + + LPDIRECTINPUTDEVICE8 kb_device; + LPDIRECTINPUTDEVICE8 mo_device; + + if ( DI_OK == idi8->CreateDevice( GUID_SysKeyboard, &kb_device, NULL ) ) + if ( DI_OK == kb_device->SetDataFormat( &c_dfDIKeyboard ) ) + if ( DI_OK == kb_device->SetCooperativeLevel( NULL, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE) ) + if ( DI_OK == kb_device->Acquire() ) + { + + if ( DI_OK == idi8->CreateDevice( GUID_SysMouse, &mo_device, NULL ) ) + if ( DI_OK == mo_device->SetDataFormat( &c_dfDIMouse2 ) ) + if ( DI_OK == mo_device->SetCooperativeLevel( NULL, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE) ) + if ( DI_OK == mo_device->Acquire() ) + { + devices.push_back( new KeyboardMouse( kb_device, mo_device ) ); + return; + } + else + goto release_mouse; + + goto unacquire_kb; + } + else + goto release_kb; + +release_mouse: + mo_device->Release(); +unacquire_kb: + kb_device->Unacquire(); +release_kb: + kb_device->Release(); +} + +KeyboardMouse::~KeyboardMouse() +{ + // kb + m_kb_device->Unacquire(); + m_kb_device->Release(); + // mouse + m_mo_device->Unacquire(); + m_mo_device->Release(); +} + +KeyboardMouse::KeyboardMouse( const LPDIRECTINPUTDEVICE8 kb_device, const LPDIRECTINPUTDEVICE8 mo_device ) + : m_kb_device(kb_device) + , m_mo_device(mo_device) +{ + m_last_update = wxGetLocalTimeMillis(); + + ZeroMemory( &m_state_in, sizeof(m_state_in) ); + ZeroMemory( m_state_out, sizeof(m_state_out) ); + ZeroMemory( &m_current_state_out, sizeof(m_current_state_out) ); + + // KEYBOARD + // add keys + for ( unsigned int i = 0; i < sizeof(named_keys)/sizeof(*named_keys); ++i ) + inputs.push_back( new Key( i ) ); + // add lights + for ( unsigned int i = 0; i < sizeof(named_lights)/sizeof(*named_lights); ++i ) + outputs.push_back( new Light( i ) ); + + // MOUSE + // get caps + DIDEVCAPS mouse_caps; + ZeroMemory( &mouse_caps, sizeof(mouse_caps) ); + mouse_caps.dwSize = sizeof(mouse_caps); + m_mo_device->GetCapabilities(&mouse_caps); + // mouse buttons + for ( unsigned int i = 0; i < mouse_caps.dwButtons; ++i ) + inputs.push_back( new Button( i ) ); + // mouse axes + for ( unsigned int i = 0; i < mouse_caps.dwAxes; ++i ) + { + // each axis gets a negative and a positive input instance associated with it + inputs.push_back( new Axis( i, (2==i) ? -1 : -MOUSE_AXIS_SENSITIVITY ) ); + inputs.push_back( new Axis( i, -(2==i) ? 1 : MOUSE_AXIS_SENSITIVITY ) ); + } + +} + +bool KeyboardMouse::UpdateInput() +{ + DIMOUSESTATE2 tmp_mouse; + + // if mouse position hasn't been updated in a short while, skip a dev state + wxLongLong cur_time = wxGetLocalTimeMillis(); + if ( cur_time - m_last_update > DROP_INPUT_TIME ) + { + // set axes to zero + ZeroMemory( &m_state_in.mouse, sizeof(m_state_in.mouse) ); + // skip this input state + m_mo_device->GetDeviceState( sizeof(tmp_mouse), &tmp_mouse ); + } + + m_last_update = cur_time; + + if ( DI_OK == m_kb_device->GetDeviceState( sizeof(m_state_in.keyboard), &m_state_in.keyboard ) + && DI_OK == m_mo_device->GetDeviceState( sizeof(tmp_mouse), &tmp_mouse ) ) + { + // need to smooth out the axes, otherwise it doesnt work for shit + for ( unsigned int i = 0; i < 3; ++i ) + ((&m_state_in.mouse.lX)[i] += (&tmp_mouse.lX)[i]) /= 2; + + // copy over the buttons + memcpy( m_state_in.mouse.rgbButtons, tmp_mouse.rgbButtons, sizeof(m_state_in.mouse.rgbButtons) ); + return true; + } + else + return false; +} + +bool KeyboardMouse::UpdateOutput() +{ + class KInput : public INPUT + { + public: + KInput( const unsigned char key, const bool up = false ) + { + memset( this, 0, sizeof(*this) ); + type = INPUT_KEYBOARD; + ki.wVk = key; + if (up) ki.dwFlags = KEYEVENTF_KEYUP; + } + }; + + std::vector< KInput > kbinputs; + for ( unsigned int i = 0; i < sizeof(m_state_out)/sizeof(*m_state_out); ++i ) + { + bool want_on = false; + if ( m_state_out[i] ) + want_on = m_state_out[i] > wxGetLocalTimeMillis() % 255 ; // light should flash when output is 0.5 + + // lights are set to their original state when output is zero + if ( want_on ^ m_current_state_out[i] ) + { + kbinputs.push_back( KInput( named_lights[i].code ) ); // press + kbinputs.push_back( KInput( named_lights[i].code, true ) ); // release + + m_current_state_out[i] ^= 1; + } + } + + return ( kbinputs.size() == SendInput( (UINT)kbinputs.size(), &kbinputs[0], sizeof( kbinputs[0] ) ) ); +} + +std::string KeyboardMouse::GetName() const +{ + return "Keyboard Mouse"; +} + +int KeyboardMouse::GetId() const +{ + // should this be -1, idk + return 0; +} + +std::string KeyboardMouse::GetSource() const +{ + return "DirectInput"; +} + +ControlState KeyboardMouse::GetInputState( const ControllerInterface::Device::Input* const input ) +{ + return ( ((Input*)input)->GetState( &m_state_in ) ); +} + +void KeyboardMouse::SetOutputState( const ControllerInterface::Device::Output* const output, const ControlState state ) +{ + ((Output*)output)->SetState( state, m_state_out ); +} + +// names +std::string KeyboardMouse::Key::GetName() const +{ + return named_keys[m_index].name; +} + +std::string KeyboardMouse::Button::GetName() const +{ + return std::string("Button ") + char('0'+m_index); +} + +std::string KeyboardMouse::Axis::GetName() const +{ + std::string tmpstr("Mouse "); + tmpstr += "XYZ"[m_index]; tmpstr += ( m_range>0 ? '+' : '-' ); + return tmpstr; +} + +std::string KeyboardMouse::Light::GetName() const +{ + return named_lights[ m_index ].name; +} + +// get/set state +ControlState KeyboardMouse::Key::GetState( const State* const state ) +{ + return ( state->keyboard[named_keys[m_index].code] > 0 ); +} + +ControlState KeyboardMouse::Button::GetState( const State* const state ) +{ + return ( state->mouse.rgbButtons[m_index] > 0 ); +} + +ControlState KeyboardMouse::Axis::GetState( const State* const state ) +{ + return std::max( 0.0f, ControlState((&state->mouse.lX)[m_index]) / m_range ); +} + +void KeyboardMouse::Light::SetState( const ControlState state, unsigned char* const state_out ) +{ + state_out[ m_index ] = state * 255; +} + +} +} + +#endif diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/DirectInputKeyboardMouse.h b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/DirectInputKeyboardMouse.h new file mode 100644 index 0000000000..40807862c2 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/DirectInputKeyboardMouse.h @@ -0,0 +1,122 @@ +#ifndef _CIFACE_DIRECTINPUT_KBM_H_ +#define _CIFACE_DIRECTINPUT_KBM_H_ + +#include "../ControllerInterface.h" + +#define DIRECTINPUT_VERSION 0x0800 +#define WIN32_LEAN_AND_MEAN +#define NOMINMAX +#include +#include + +namespace ciface +{ +namespace DirectInput +{ + +void InitKeyboardMouse( IDirectInput8* const idi8, std::vector& devices ); + +class KeyboardMouse : public ControllerInterface::Device +{ + friend class ControllerInterface; + friend class ControllerInterface::ControlReference; + +protected: + + struct State + { + BYTE keyboard[256]; + DIMOUSESTATE2 mouse; + }; + + class Input : public ControllerInterface::Device::Input + { + friend class KeyboardMouse; + protected: + virtual ControlState GetState( const State* const boardstate ) = 0; + }; + + class Output : public ControllerInterface::Device::Output + { + friend class KeyboardMouse; + protected: + virtual void SetState( const ControlState state, unsigned char* const state_out ) = 0; + }; + + class Key : public Input + { + friend class KeyboardMouse; + public: + std::string GetName() const; + protected: + Key( const unsigned int index ) : m_index(index) {} + ControlState GetState( const State* const state ); + private: + const unsigned int m_index; + }; + + class Button : public Input + { + friend class KeyboardMouse; + public: + std::string GetName() const; + protected: + Button( const unsigned int index ) : m_index(index) {} + ControlState GetState( const State* const state ); + private: + const unsigned int m_index; + }; + + class Axis : public Input + { + friend class KeyboardMouse; + public: + std::string GetName() const; + protected: + Axis( const unsigned int index, const LONG range ) : m_index(index), m_range(range) {} + ControlState GetState( const State* const state ); + private: + const unsigned int m_index; + const LONG m_range; + }; + + class Light : public Output + { + friend class KeyboardMouse; + public: + std::string GetName() const; + protected: + Light( const unsigned int index ) : m_index(index) {} + void SetState( const ControlState state, unsigned char* const state_out ); + private: + const unsigned int m_index; + }; + + bool UpdateInput(); + bool UpdateOutput(); + + ControlState GetInputState( const ControllerInterface::Device::Input* const input ); + void SetOutputState( const ControllerInterface::Device::Output* const input, const ControlState state ); + +public: + KeyboardMouse( const LPDIRECTINPUTDEVICE8 kb_device, const LPDIRECTINPUTDEVICE8 mo_device ); + ~KeyboardMouse(); + + std::string GetName() const; + int GetId() const; + std::string GetSource() const; + +private: + const LPDIRECTINPUTDEVICE8 m_kb_device; + const LPDIRECTINPUTDEVICE8 m_mo_device; + + wxLongLong m_last_update; + State m_state_in; + unsigned char m_state_out[3]; // NUM CAPS SCROLL + bool m_current_state_out[3]; // NUM CAPS SCROLL +}; + +} +} + +#endif diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/NamedKeys.h b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/NamedKeys.h new file mode 100644 index 0000000000..6266bbb73d --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/NamedKeys.h @@ -0,0 +1,144 @@ +{ DIK_A, "A" }, +{ DIK_B, "B" }, +{ DIK_C, "C" }, +{ DIK_D, "D" }, +{ DIK_E, "E" }, +{ DIK_F, "F" }, +{ DIK_G, "G" }, +{ DIK_H, "H" }, +{ DIK_I, "I" }, +{ DIK_J, "J" }, +{ DIK_K, "K" }, +{ DIK_L, "L" }, +{ DIK_M, "M" }, +{ DIK_N, "N" }, +{ DIK_O, "O" }, +{ DIK_P, "P" }, +{ DIK_Q, "Q" }, +{ DIK_R, "R" }, +{ DIK_S, "S" }, +{ DIK_T, "T" }, +{ DIK_U, "U" }, +{ DIK_V, "V" }, +{ DIK_W, "W" }, +{ DIK_X, "X" }, +{ DIK_Y, "Y" }, +{ DIK_Z, "Z" }, +{ DIK_0, "0" }, +{ DIK_1, "1" }, +{ DIK_2, "2" }, +{ DIK_3, "3" }, +{ DIK_4, "4" }, +{ DIK_5, "5" }, +{ DIK_6, "6" }, +{ DIK_7, "7" }, +{ DIK_8, "8" }, +{ DIK_9, "9" }, +{ DIK_UP, "UP" }, +{ DIK_DOWN, "DOWN" }, +{ DIK_LEFT, "LEFT" }, +{ DIK_RIGHT, "RIGHT" }, +{ DIK_ABNT_C1, "ABNT_C1" }, +{ DIK_ABNT_C2, "ABNT_C2" }, +{ DIK_ADD, "ADD" }, +{ DIK_APOSTROPHE, "APOSTROPHE" }, +{ DIK_APPS, "APPS" }, +{ DIK_AT, "AT" }, +{ DIK_AX, "AX" }, +{ DIK_BACK, "BACK" }, +{ DIK_BACKSLASH, "BACKSLASH" }, +{ DIK_CALCULATOR, "CALCULATOR" }, +{ DIK_CAPITAL, "CAPITAL" }, +{ DIK_COLON, "COLON" }, +{ DIK_COMMA, "COMMA" }, +{ DIK_CONVERT, "CONVERT" }, +{ DIK_DECIMAL, "DECIMAL" }, +{ DIK_DELETE, "DELETE" }, +{ DIK_DIVIDE, "DIVIDE" }, +{ DIK_EQUALS, "EQUALS" }, +{ DIK_ESCAPE, "ESCAPE" }, +{ DIK_F1, "F1" }, +{ DIK_F2, "F2" }, +{ DIK_F3, "F3" }, +{ DIK_F4, "F4" }, +{ DIK_F5, "F5" }, +{ DIK_F6, "F6" }, +{ DIK_F7, "F7" }, +{ DIK_F8, "F8" }, +{ DIK_F9, "F9" }, +{ DIK_F10, "F10" }, +{ DIK_F11, "F11" }, +{ DIK_F12, "F12" }, +{ DIK_F13, "F13" }, +{ DIK_F14, "F14" }, +{ DIK_F15, "F15" }, +{ DIK_GRAVE, "GRAVE" }, +{ DIK_HOME, "HOME" }, +{ DIK_END, "END" }, +{ DIK_INSERT, "INSERT" }, +{ DIK_KANA, "KANA" }, +{ DIK_KANJI, "KANJI" }, +{ DIK_MAIL, "MAIL" }, +{ DIK_MEDIASELECT, "MEDIASELECT" }, +{ DIK_MEDIASTOP, "MEDIASTOP" }, +{ DIK_MINUS, "MINUS" }, +{ DIK_MULTIPLY, "MULTIPLY" }, +{ DIK_MUTE, "MUTE" }, +{ DIK_MYCOMPUTER, "MYCOMPUTER" }, +{ DIK_NEXTTRACK, "NEXTTRACK" }, +{ DIK_NOCONVERT, "NOCONVERT" }, +{ DIK_NUMLOCK, "NUMLOCK" }, +{ DIK_NUMPAD0, "NUMPAD0" }, +{ DIK_NUMPAD1, "NUMPAD1" }, +{ DIK_NUMPAD2, "NUMPAD2" }, +{ DIK_NUMPAD3, "NUMPAD3" }, +{ DIK_NUMPAD4, "NUMPAD4" }, +{ DIK_NUMPAD5, "NUMPAD5" }, +{ DIK_NUMPAD6, "NUMPAD6" }, +{ DIK_NUMPAD7, "NUMPAD7" }, +{ DIK_NUMPAD8, "NUMPAD8" }, +{ DIK_NUMPAD9, "NUMPAD9" }, +{ DIK_NUMPADCOMMA, "NUMPADCOMMA" }, +{ DIK_NUMPADENTER, "NUMPADENTER" }, +{ DIK_NUMPADEQUALS, "NUMPADEQUALS" }, +{ DIK_OEM_102, "OEM_102" }, +{ DIK_PAUSE, "PAUSE" }, +{ DIK_PERIOD, "PERIOD" }, +{ DIK_PLAYPAUSE, "PLAYPAUSE" }, +{ DIK_POWER, "POWER" }, +{ DIK_PREVTRACK, "PREVTRACK" }, +{ DIK_PRIOR, "PRIOR" }, +{ DIK_NEXT, "NEXT" }, +{ DIK_RETURN, "RETURN" }, +{ DIK_LBRACKET, "LBRACKET" }, +{ DIK_RBRACKET, "RBRACKET" }, +{ DIK_LCONTROL, "LCONTROL" }, +{ DIK_RCONTROL, "RCONTROL" }, +{ DIK_LMENU, "LMENU" }, +{ DIK_RMENU, "RMENU" }, +{ DIK_LSHIFT, "LSHIFT" }, +{ DIK_RSHIFT, "RSHIFT" }, +{ DIK_LWIN, "LWIN" }, +{ DIK_RWIN, "RWIN" }, +{ DIK_SCROLL, "SCROLL" }, +{ DIK_SEMICOLON, "SEMICOLON" }, +{ DIK_SLASH, "SLASH" }, +{ DIK_SLEEP, "SLEEP" }, +{ DIK_SPACE, "SPACE" }, +{ DIK_STOP, "STOP" }, +{ DIK_SUBTRACT, "SUBTRACT" }, +{ DIK_SYSRQ, "SYSRQ" }, +{ DIK_TAB, "TAB" }, +{ DIK_UNDERLINE, "UNDERLINE" }, +{ DIK_UNLABELED, "UNLABELED" }, +{ DIK_VOLUMEDOWN, "VOLUMEDOWN" }, +{ DIK_VOLUMEUP, "VOLUMEUP" }, +{ DIK_WAKE, "WAKE" }, +{ DIK_WEBBACK, "WEBBACK" }, +{ DIK_WEBFAVORITES, "WEBFAVORITES" }, +{ DIK_WEBFORWARD, "WEBFORWARD" }, +{ DIK_WEBHOME, "WEBHOME" }, +{ DIK_WEBREFRESH, "WEBREFRESH" }, +{ DIK_WEBSEARCH, "WEBSEARCH" }, +{ DIK_WEBSTOP, "WEBSTOP" }, +{ DIK_YEN, "YEN" }, diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/SDL/SDL.cpp b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/SDL/SDL.cpp new file mode 100644 index 0000000000..d91af9f849 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/SDL/SDL.cpp @@ -0,0 +1,283 @@ +#include "../ControllerInterface.h" + +#ifdef CIFACE_USE_SDL + +#include "SDL.h" + +#ifdef _WIN32 + #pragma comment(lib, "SDL.1.3.lib") +#endif + +// temp for debuggin +//#include + +namespace ciface +{ +namespace SDL +{ + +void Init( std::vector& devices ) +{ + if ( SDL_Init( SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC ) >= 0 ) + { + // joysticks + for( int i = 0; i < SDL_NumJoysticks(); ++i ) + { + SDL_Joystick* dev; + if ( dev = SDL_JoystickOpen( i ) ) + { + Joystick* js = new Joystick( dev, i ); + // only add if it has some inputs/outputs + if ( js->Inputs().size() || js->Outputs().size() ) + devices.push_back( js ); + else + delete js; + } + } + } +} + +Joystick::Joystick( SDL_Joystick* const joystick, const unsigned int index ) : m_joystick(joystick), m_index(index) +{ + // get buttons + for ( int i = 0; i < SDL_JoystickNumButtons( m_joystick ); ++i ) + { + inputs.push_back( new Button( i ) ); + } + + // get hats + for ( int i = 0; i < SDL_JoystickNumHats( m_joystick ); ++i ) + { + // each hat gets 4 input instances associated with it, (up down left right) + for ( unsigned int d = 0; d < 4; ++d ) + inputs.push_back( new Hat( i, d ) ); + } + + // get axes + for ( int i = 0; i < SDL_JoystickNumAxes( m_joystick ); ++i ) + { + // each axis gets a negative and a positive input instance associated with it + inputs.push_back( new Axis( i, -32768 ) ); + inputs.push_back( new Axis( i, 32767 ) ); + } + + // try to get supported ff effects + if ( m_haptic = SDL_HapticOpenFromJoystick( m_joystick ) ) + { + + //SDL_HapticSetGain( m_haptic, 1000 ); + //SDL_HapticSetAutocenter( m_haptic, 0 ); + + const unsigned int supported_effects = SDL_HapticQuery( m_haptic ); // use this later + + // constant effect + if ( supported_effects & SDL_HAPTIC_CONSTANT ) + { + outputs.push_back( new ConstantEffect( m_state_out.size() ) ); + m_state_out.push_back( EffectIDState() ); + } + + // ramp effect + if ( supported_effects & SDL_HAPTIC_RAMP ) + { + outputs.push_back( new RampEffect( m_state_out.size() ) ); + m_state_out.push_back( EffectIDState() ); + } + } + +} + +Joystick::~Joystick() +{ + if ( m_haptic ) + { + // stop/destroy all effects + //SDL_HapticStopAll( m_haptic ); // ControllerInterface handles this + std::vector::iterator i = m_state_out.begin(), + e = m_state_out.end(); + for ( ; i!=e; ++i ) + if ( i->id != -1 ) + SDL_HapticDestroyEffect( m_haptic, i->id ); + // close haptic first + SDL_HapticClose( m_haptic ); + } + + // close joystick + SDL_JoystickClose( m_joystick ); +} + +//std::string Joystick::Effect::GetName() const +//{ +// return haptic_named_effects[m_index].name; +//} + +std::string Joystick::ConstantEffect::GetName() const +{ + return "Constant"; +} + +std::string Joystick::RampEffect::GetName() const +{ + return "Ramp"; +} + +void Joystick::ConstantEffect::SetState( const ControlState state, Joystick::EffectIDState* const effect ) +{ + if ( state ) + { + //debuggin here ... + //memset( &effect->effect, 0, sizeof(effect->effect) ); + effect->effect.type = SDL_HAPTIC_CONSTANT; + effect->effect.constant.length = SDL_HAPTIC_INFINITY; + //effect->effect.constant.attack_length = 3000; + //effect->effect.constant.direction.type = SDL_HAPTIC_CARTESIAN; + //effect->effect + //effect->effect.constant.button = 0xFFFFFFFF; + } + else + effect->effect.type = 0; + + Sint16 old = effect->effect.constant.level; + effect->effect.constant.level = state * 0x7FFF; + if ( old != effect->effect.constant.level ) + effect->changed = true; +} + +void Joystick::RampEffect::SetState( const ControlState state, Joystick::EffectIDState* const effect ) +{ + if ( state ) + { + effect->effect.type = SDL_HAPTIC_RAMP; + effect->effect.ramp.length = SDL_HAPTIC_INFINITY; + } + else + effect->effect.type = 0; + + Sint16 old = effect->effect.ramp.start; + effect->effect.ramp.start = state * 0x7FFF; + if ( old != effect->effect.ramp.start ) + effect->changed = true; +} + +ControlState Joystick::GetInputState(const ControllerInterface::Device::Input* input) +{ + return ((Input*)input)->GetState( m_joystick ); +} + +void Joystick::SetOutputState(const ControllerInterface::Device::Output* output, const ControlState state) +{ + ((Output*)output)->SetState( state, &m_state_out[ ((Output*)output)->m_index ] ); +} + +bool Joystick::UpdateInput() +{ + SDL_JoystickUpdate(); // each joystick is doin this, o well + + return true; +} + +bool Joystick::UpdateOutput() +{ + std::vector::iterator i = m_state_out.begin(), + e = m_state_out.end(); + for ( ; i!=e; ++i ) + if ( i->changed ) // if SetState was called on this output + { + if ( -1 == i->id ) // effect isn't currently uploaded + { + if ( i->effect.type ) // if outputstate is >0 this would be true + if ( (i->id = SDL_HapticNewEffect( m_haptic, &i->effect )) > -1 ) // upload the effect + { + //std::ofstream file( "SDLgood.txt" ); + + /*if ( 0 == */SDL_HapticRunEffect( m_haptic, i->id, 1 );//) // run the effect + // file << "all good"; + //else + // file << "not good"; + //file.close(); + + } + else + { + // DEBUG + + //std::ofstream file( "SDLerror.txt" ); + //file << SDL_GetError(); + //file.close(); + + } + } + else // effect is already uploaded + { + if ( i->effect.type ) // if ouputstate >0 + SDL_HapticUpdateEffect( m_haptic, i->id, &i->effect ); // update the effect + else + { + SDL_HapticStopEffect( m_haptic, i->id ); // else, stop and remove the effect + SDL_HapticDestroyEffect( m_haptic, i->id ); + i->id = -1; // mark it as not uploaded + } + } + + i->changed = false; + } + return true; +} + +std::string Joystick::GetName() const +{ + return SDL_JoystickName( m_index ); +} + +std::string Joystick::GetSource() const +{ + return "SDL"; +} + +int Joystick::GetId() const +{ + return m_index; +} + +std::string Joystick::Button::GetName() const +{ + std::ostringstream ss; + ss << "Button " << m_index; + return ss.str(); +} + +std::string Joystick::Axis::GetName() const +{ + std::ostringstream ss; + ss << "Axis " << m_index << ( m_range>0 ? '+' : '-' ); + return ss.str(); +} + +std::string Joystick::Hat::GetName() const +{ + std::ostringstream ss; + ss << "Hat " << m_index << ' ' << "NESW"[m_direction]; + return ss.str(); +} + +ControlState Joystick::Button::GetState( SDL_Joystick* const js ) const +{ + return SDL_JoystickGetButton( js, m_index ); +} + +ControlState Joystick::Axis::GetState( SDL_Joystick* const js ) const +{ + return std::max( 0.0f, ControlState(SDL_JoystickGetAxis( js, m_index )) / m_range ); +} + +ControlState Joystick::Hat::GetState( SDL_Joystick* const js ) const +{ + return (SDL_JoystickGetHat( js, m_index ) & ( 1 << m_direction )) > 0; +} + + + +} +} + +#endif diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/SDL/SDL.h b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/SDL/SDL.h new file mode 100644 index 0000000000..3da477ca23 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/SDL/SDL.h @@ -0,0 +1,141 @@ +#ifndef _CIFACE_SDL_H_ +#define _CIFACE_SDL_H_ + +#include "../ControllerInterface.h" + +// getting rid of warning, sdl/wxwidgets both define it +#undef M_PI +// really dum +#ifdef _WIN32 + #include + #include +#else + #include + #include +#endif + +namespace ciface +{ +namespace SDL +{ + +void Init( std::vector& devices ); + +class Joystick : public ControllerInterface::Device +{ + friend class ControllerInterface; + friend class ControllerInterface::ControlReference; + +protected: + + class EffectIDState + { + friend class Joystick; + protected: + EffectIDState() : id(-1), changed(false) { memset( &effect, 0, sizeof(effect)); } + protected: + SDL_HapticEffect effect; + int id; + bool changed; + }; + + class Input : public ControllerInterface::Device::Input + { + friend class Joystick; + protected: + Input( const unsigned int index ) : m_index(index) {} + virtual ControlState GetState( SDL_Joystick* const js ) const = 0; + + const unsigned int m_index; + }; + + class Output : public ControllerInterface::Device::Output + { + friend class Joystick; + protected: + Output( const size_t index ) : m_index(index) {} + virtual void SetState( const ControlState state, EffectIDState* const effect ) = 0; + + const size_t m_index; + }; + + class Button : public Input + { + friend class Joystick; + public: + std::string GetName() const; + protected: + Button( const unsigned int index ) : Input(index) {} + ControlState GetState( SDL_Joystick* const js ) const; + }; + class Axis : public Input + { + friend class Joystick; + public: + std::string GetName() const; + protected: + Axis( const unsigned int index, const Sint16 range ) : Input(index), m_range(range) {} + ControlState GetState( SDL_Joystick* const js ) const; + private: + const Sint16 m_range; + }; + + class Hat : public Input + { + friend class Joystick; + public: + std::string GetName() const; + protected: + Hat( const unsigned int index, const unsigned int direction ) : Input(index), m_direction(direction) {} + ControlState GetState( SDL_Joystick* const js ) const; + private: + const unsigned int m_direction; + }; + + class ConstantEffect : public Output + { + friend class Joystick; + public: + std::string GetName() const; + protected: + ConstantEffect( const size_t index ) : Output(index) {} + void SetState( const ControlState state, EffectIDState* const effect ); + }; + + class RampEffect : public Output + { + friend class Joystick; + public: + std::string GetName() const; + protected: + RampEffect( const size_t index ) : Output(index) {} + void SetState( const ControlState state, EffectIDState* const effect ); + }; + + bool UpdateInput(); + bool UpdateOutput(); + + ControlState GetInputState( const ControllerInterface::Device::Input* const input ); + void SetOutputState( const ControllerInterface::Device::Output* const output, const ControlState state ); + +public: + Joystick( SDL_Joystick* const joystick, const unsigned int index ); + ~Joystick(); + + std::string GetName() const; + int GetId() const; + std::string GetSource() const; + +private: + std::vector m_state_out; + + SDL_Haptic* m_haptic; + SDL_Joystick* const m_joystick; + const unsigned int m_index; +}; + + +} +} + +#endif diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/XInput/XInput.cpp b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/XInput/XInput.cpp new file mode 100644 index 0000000000..76b3f4a43c --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/XInput/XInput.cpp @@ -0,0 +1,214 @@ +#include "../ControllerInterface.h" + +#ifdef CIFACE_USE_XINPUT + +#include "XInput.h" + +namespace ciface +{ +namespace XInput +{ + +struct +{ + const char* const name; + const WORD bitmask; +} named_buttons[] = +{ + { "Button A", XINPUT_GAMEPAD_A }, + { "Button B", XINPUT_GAMEPAD_B }, + { "Button X", XINPUT_GAMEPAD_X }, + { "Button Y", XINPUT_GAMEPAD_Y }, + { "Pad N", XINPUT_GAMEPAD_DPAD_UP }, + { "Pad S", XINPUT_GAMEPAD_DPAD_DOWN }, + { "Pad W", XINPUT_GAMEPAD_DPAD_LEFT }, + { "Pad E", XINPUT_GAMEPAD_DPAD_RIGHT }, + { "Start", XINPUT_GAMEPAD_START }, + { "Back", XINPUT_GAMEPAD_BACK }, + { "Shoulder L", XINPUT_GAMEPAD_LEFT_SHOULDER }, + { "Shoulder R", XINPUT_GAMEPAD_RIGHT_SHOULDER }, + { "Thumb L", XINPUT_GAMEPAD_LEFT_THUMB }, + { "Thumb R", XINPUT_GAMEPAD_RIGHT_THUMB } +}; + +const char* named_triggers[] = +{ + "Trigger L", + "Trigger R" +}; + +const char* named_axes[] = +{ + "Left X", + "Left Y", + "Right X", + "Right Y" +}; + +const char* named_motors[] = +{ + "Motor L", + "Motor R" +}; + +void Init( std::vector& devices ) +{ + XINPUT_CAPABILITIES caps; + for ( int i = 0; i < 4; ++i ) + if ( ERROR_SUCCESS == XInputGetCapabilities( i, 0, &caps ) ) + devices.push_back( new Device( &caps, i ) ); + +} + +Device::Device( const XINPUT_CAPABILITIES* const caps, const unsigned int index ) +: m_index(index), m_subtype(caps->SubType) +{ + ZeroMemory( &m_state_out, sizeof(m_state_out) ); + + // XInputGetCaps seems to always claim all capabilities are supported + // but i will leave all this stuff in, incase m$ fixes xinput up a bit + + // get supported buttons + for ( int i = 0; i < sizeof(named_buttons)/sizeof(*named_buttons); ++i ) + if ( named_buttons[i].bitmask & caps->Gamepad.wButtons ) + inputs.push_back( new Button( /*xinput_named_buttons[i].bitmask, */i ) ); + + // get supported triggers + for ( int i = 0; i < sizeof(named_triggers)/sizeof(*named_triggers); ++i ) + { + //BYTE val = (&caps->Gamepad.bLeftTrigger)[i]; // should be max value / msdn lies + if ( (&caps->Gamepad.bLeftTrigger)[i] ) + inputs.push_back( new Trigger( i, 255 ) ); + } + + // get supported axes + for ( int i = 0; i < sizeof(named_axes)/sizeof(*named_axes); ++i ) + { + //SHORT val = (&caps->Gamepad.sThumbLX)[i]; // xinput doesnt give the range / msdn is lier + if ( (&caps->Gamepad.sThumbLX)[i] ) + { + // each axis gets a negative and a positive input instance associated with it + inputs.push_back( new Axis( i, -32768 ) ); + inputs.push_back( new Axis( i, 32767 ) ); + } + } + + // get supported motors + for ( int i = 0; i < sizeof(named_motors)/sizeof(*named_motors); ++i ) + { + //WORD val = (&caps->Vibration.wLeftMotorSpeed)[i]; // should be max value / nope, more lies + if ( (&caps->Vibration.wLeftMotorSpeed)[i] ) + outputs.push_back( new Motor(i, 65535 ) ); + } + + ClearInputState(); + +} + +void Device::ClearInputState() +{ + ZeroMemory( &m_state_in, sizeof(m_state_in) ); +} + +std::string Device::GetName() const +{ + // why aren't these defined + // subtype doesn't seem to work, i tested with 2 diff arcade sticks, both were shown as gamepad + // ill leave it in anyway, maybe m$ will fix it + + switch ( m_subtype ) + { + case XINPUT_DEVSUBTYPE_GAMEPAD : return "Gamepad"; break; + case 0x02 /*XINPUT_DEVSUBTYPE_WHEEL*/ : return "Wheel"; break; + case 0x03 /*XINPUT_DEVSUBTYPE_ARCADE_STICK*/ : return "Arcade Stick"; break; + case 0x04 /*XINPUT_DEVSUBTYPE_FLIGHT_STICK*/ : return "Flight Stick"; break; + case 0x05 /*XINPUT_DEVSUBTYPE_DANCE_PAD*/ : return "Dance Pad"; break; + case 0x06 /*XINPUT_DEVSUBTYPE_GUITAR*/ : return "Guitar"; break; + case 0x08 /*XINPUT_DEVSUBTYPE_DRUM_KIT*/ : return "Drum Kit"; break; + default : return "Device"; break; + } +} + +int Device::GetId() const +{ + return m_index; +} + +std::string Device::GetSource() const +{ + return "XInput"; +} + +// update i/o + +bool Device::UpdateInput() +{ + return ( ERROR_SUCCESS == XInputGetState( m_index, &m_state_in ) ); +} + +bool Device::UpdateOutput() +{ + return ( ERROR_SUCCESS == XInputSetState( m_index, &m_state_out ) ); +} + +// GET name/source/id + + +std::string Device::Button::GetName() const +{ + return named_buttons[m_index].name; +} + +std::string Device::Axis::GetName() const +{ + return std::string(named_axes[m_index]) + ( m_range>0 ? '+' : '-' ); +} + +std::string Device::Trigger::GetName() const +{ + return named_triggers[m_index]; +} + +std::string Device::Motor::GetName() const +{ + return named_motors[m_index]; +} + +// get/set control state + +ControlState Device::GetInputState( const ControllerInterface::Device::Input* const input ) +{ + return ((Input*)input)->GetState( &m_state_in.Gamepad ); +} + +void Device::SetOutputState( const ControllerInterface::Device::Output* const output, const ControlState state ) +{ + return ((Output*)output)->SetState( state, &m_state_out ); +} + +// GET / SET STATES + +ControlState Device::Button::GetState( const XINPUT_GAMEPAD* const gamepad ) +{ + return (gamepad->wButtons & named_buttons[m_index].bitmask) > 0; +} + +ControlState Device::Trigger::GetState( const XINPUT_GAMEPAD* const gamepad ) +{ + return ControlState((&gamepad->bLeftTrigger)[m_index]) / m_range; +} + +ControlState Device::Axis::GetState( const XINPUT_GAMEPAD* const gamepad ) +{ + return std::max( 0.0f, ControlState((&gamepad->sThumbLX)[m_index]) / m_range ); +} + +void Device::Motor::SetState( const ControlState state, XINPUT_VIBRATION* const vibration ) +{ + (&vibration->wLeftMotorSpeed)[m_index] = (WORD)(state * m_range); +} + +} +} + +#endif diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/XInput/XInput.h b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/XInput/XInput.h new file mode 100644 index 0000000000..c3dc51cca3 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/XInput/XInput.h @@ -0,0 +1,116 @@ +#ifndef _CIFACE_XINPUT_H_ +#define _CIFACE_XINPUT_H_ + +#include "../ControllerInterface.h" + +#define NOMINMAX +#include +#include + +namespace ciface +{ +namespace XInput +{ + +void Init( std::vector& devices ); + +class Device : public ControllerInterface::Device +{ + friend class ControllerInterface; + friend class ControllerInterface::ControlReference; + +protected: + + class Input : public ControllerInterface::Device::Input + { + friend class Device; + protected: + virtual ControlState GetState( const XINPUT_GAMEPAD* const gamepad ) = 0; + }; + + class Output : public ControllerInterface::Device::Output + { + friend class Device; + protected: + virtual void SetState( const ControlState state, XINPUT_VIBRATION* const vibration ) = 0; + }; + + class Button : public Input + { + friend class Device; + public: + std::string GetName() const; + protected: + Button( const unsigned int index ) : m_index(index) {} + ControlState GetState( const XINPUT_GAMEPAD* const gamepad ); + private: + const unsigned int m_index; + }; + + class Axis : public Input + { + friend class Device; + public: + std::string GetName() const; + protected: + Axis( const unsigned int index, const SHORT range ) : m_index(index), m_range(range) {} + ControlState GetState( const XINPUT_GAMEPAD* const gamepad ); + private: + const unsigned int m_index; + const SHORT m_range; + }; + + class Trigger : public Input + { + friend class Device; + public: + std::string GetName() const; + protected: + Trigger( const unsigned int index, const BYTE range ) : m_index(index), m_range(range) {} + ControlState GetState( const XINPUT_GAMEPAD* const gamepad ); + private: + const unsigned int m_index; + const BYTE m_range; + }; + + class Motor : public Output + { + friend class Device; + public: + std::string GetName() const; + protected: + Motor( const unsigned int index, const WORD range ) : m_index(index), m_range(range) {} + void SetState( const ControlState state, XINPUT_VIBRATION* const vibration ); + private: + const unsigned int m_index; + const WORD m_range; + }; + + bool UpdateInput(); + bool UpdateOutput(); + + ControlState GetInputState( const ControllerInterface::Device::Input* const input ); + void SetOutputState( const ControllerInterface::Device::Output* const input, const ControlState state ); + + void ClearInputState(); + +public: + Device( const XINPUT_CAPABILITIES* const capabilities, const unsigned int index ); + + std::string GetName() const; + int GetId() const; + std::string GetSource() const; + +private: + const unsigned int m_index; + XINPUT_STATE m_state_in; + XINPUT_VIBRATION m_state_out; + const unsigned int m_subtype; +}; + + +} +} + + +#endif diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/Xlib/Xlib.cpp b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/Xlib/Xlib.cpp new file mode 100644 index 0000000000..57a7f32f62 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/Xlib/Xlib.cpp @@ -0,0 +1,98 @@ +#include "../ControllerInterface.h" + +#ifdef CIFACE_USE_XLIB + +#include "Xlib.h" + +namespace ciface +{ +namespace Xlib +{ + + +void Init( std::vector& devices, void* const hwnd ) +{ + // mouse will be added to this, Keyboard class will be turned into KeyboardMouse + // single device for combined keyboard/mouse, this will allow combinations like shift+click more easily + devices.push_back( new Keyboard( (Display*)display ) ); +} + +Keyboard::Keyboard( Display* const display ) : m_display(display) +{ + + memset( &m_state, 0, sizeof(m_state) ); + + // this is probably dumb + for ( KeySym i = 0; i < 1024; ++i ) + { + if ( XKeysymToString( m_keysym ) ) // if it isnt NULL + inputs.push_back( new Key( i ) ); + } + +} + + +Keyboard::~Keyboard() +{ + // might not need this func +} + + +ControlState Keyboard::GetInputState( const ControllerInterface::Device::Input* const input ) +{ + return ((Input*)input)->GetState( &m_state ); +} + +void Keyboard::SetOutputState( const ControllerInterface::Device::Output* const output, const ControlState state ) +{ + +} + +bool Keyboard::UpdateInput() +{ + XQueryKeymap( m_display, m_state.keyboard ); + + // mouse stuff in here too + + return true; +} + +bool Keyboard::UpdateOutput() +{ + return true; +} + + +std::string Keyboard::GetName() const +{ + return "Keyboard"; + //return "Keyboard Mouse"; // change to this later +} + +std::string Keyboard::GetSource() const +{ + return "Xlib"; +} + +int Keyboard::GetId() const +{ + return 0; +} + + +ControlState Keyboard::Key::GetState( const State* const state ) +{ + key_code = XKeysymToKeycode(m_display, m_keysym ); + return (state->keyboard[key_code/8] & (1 << (key_code%8))); // need >0 ? +} + +std::string Keyboard::Key::GetName() const +{ + return XKeysymToString( m_keysym ); +} + + +} +} + +#endif diff --git a/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/Xlib/Xlib.h b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/Xlib/Xlib.h new file mode 100644 index 0000000000..7ddebb8897 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/Xlib/Xlib.h @@ -0,0 +1,70 @@ +#ifndef _CIFACE_XLIB_H_ +#define _CIFACE_XLIB_H_ + +#include "../ControllerInterface.h" + +#include + +namespace ciface +{ +namespace XInput +{ + +void Init( std::vector& devices, void* const hwnd ); + +class Keyboard : public ControllerInterface::Device +{ + friend class ControllerInterface; + friend class ControllerInterface::ControlReference; + +protected: + + struct State + { + char keyboard[32]; + // mouse crap will go here + }; + + class Input : public ControllerInterface::Input + { + friend class Keyboard; + protected: + ControlState GetState( const State* const state ) = 0; + } + + class Key : public Input + { + friend class Keyboard; + public: + std::string GetName() const; + protected: + Key( KeySym keysym ) : m_keysym(keysym) {} + ControlState GetState( const State* const state ); + private: + const KeySym m_keysym + + }; + + bool UpdateInput(); + bool UpdateOutput(); + + ControlState Keyboard::GetInputState( const ControllerInterface::Device::Input* const input ); + void Keyboard::SetOutputState( const ControllerInterface::Device::Output* const output, const ControlState state ); + +public: + Keyboard( Display* const display ); + ~Keyboard(); + + std::string GetName() const; + std::string GetSource() const; + int GetId() const; + +private: + Display* const m_display; + State m_state; +}; + +} +} + +#endif diff --git a/Source/Plugins/Plugin_GCPadNew/Src/GCPadNew.cpp b/Source/Plugins/Plugin_GCPadNew/Src/GCPadNew.cpp new file mode 100644 index 0000000000..c68d138fc6 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/GCPadNew.cpp @@ -0,0 +1,354 @@ + +#include + +#include "pluginspecs_pad.h" +#include "pluginspecs_wiimote.h" + +#include "ControllerInterface/ControllerInterface.h" +#include "ConfigDiag.h" + +#define CIFACE_PLUGIN_VERSION 0x0100 + +#define CIFACE_PLUGIN_BRANDING /*"Billiard's"//*/"Dolphin" +#define CIFACE_PLUGIN_TYPE "GCPad" +#define CIFACE_PLUGIN_NAME "New" +//#define CIFACE_PLUGIN_VERSTR "v1.0" + +#define CIFACE_PLUGIN_FULL_NAME CIFACE_PLUGIN_BRANDING" "CIFACE_PLUGIN_TYPE" "CIFACE_PLUGIN_NAME//" "CIFACE_PLUGIN_VERSTR + +#ifdef _WIN32 +class wxDLLApp : public wxApp +{ + bool OnInit() + { + return true; + }; +}; +IMPLEMENT_APP_NO_MAIN(wxDLLApp) +WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst); +#endif +// copied from GCPad +SPADInitialize *g_PADInitialize = NULL; +// Check if Dolphin is in focus +// ---------------- +bool IsFocus() +{ +#ifdef _WIN32 + HWND RenderingWindow = (g_PADInitialize) ? g_PADInitialize->hWnd : NULL; + HWND Parent = GetParent(RenderingWindow); + HWND TopLevel = GetParent(Parent); + + if (GetForegroundWindow() == TopLevel || GetForegroundWindow() == RenderingWindow) + return true; + else + return false; +#elif defined HAVE_X11 && HAVE_X11 + Window GLWin = *(Window *)g_PADInitialize->pXWindow; + Window FocusWin; + int Revert; + XGetInputFocus((Display*)g_PADInitialize->hWnd, &FocusWin, &Revert); + XWindowAttributes WinAttribs; + XGetWindowAttributes (GCdisplay, GLWin, &WinAttribs); + return (GLWin != 0 && (GLWin == FocusWin || WinAttribs.override_redirect)); +#else + return true; +#endif +} + +// copied from GCPad +HINSTANCE g_hInstance; + +// copied from GCPad +#if defined(HAVE_WX) && HAVE_WX +wxWindow* GetParentedWxWindow(HWND Parent) +{ +#ifdef _WIN32 + wxSetInstance((HINSTANCE)g_hInstance); +#endif + wxWindow *win = new wxWindow(); +#ifdef _WIN32 + win->SetHWND((WXHWND)Parent); + win->AdoptAttributesFromHWND(); +#endif + return win; +} +#endif +// / + +// the plugin +Plugin g_plugin; +#ifdef _WIN32 +BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved ) +{ + switch (fdwReason) + { + case DLL_PROCESS_ATTACH: + wxSetInstance(hinstDLL); + wxInitialize(); + break; + case DLL_PROCESS_DETACH: + wxUninitialize(); + break; + default: + break; + } + + g_hInstance = hinstDLL; + return TRUE; +} +#endif + + +// wut ?? +#define EXPORT +#define CALL + +int _last_numPAD = 4; + + +// if plugin isn't initialized, init and load config +void InitPlugin( void* const hwnd ) +{ + //g_plugin.controls_crit.Enter(); // enter + //g_plugin.interface_crit.Enter(); + + if ( false == g_plugin.controller_interface.IsInit() ) + { + // load the saved controller config + g_plugin.LoadConfig(); + + // needed for Xlib and exclusive dinput + g_plugin.controller_interface.SetHwnd( hwnd ); + g_plugin.controller_interface.Init(); + + // update control refs + std::vector::const_iterator i = g_plugin.controllers.begin(), + e = g_plugin.controllers.end(); + for ( ; i!=e; ++i ) + (*i)->UpdateReferences( g_plugin.controller_interface ); + + } + + //g_plugin.interface_crit.Leave(); + //g_plugin.controls_crit.Leave(); // leave +} + +// I N T E R F A C E + +// __________________________________________________________________________________________________ +// Function: +// Purpose: +// input: +// output: +// +EXPORT void CALL PAD_GetStatus(u8 _numPAD, SPADStatus* _pPADStatus) +{ + // why not, i guess + if ( NULL == _pPADStatus ) + return; + + memset( _pPADStatus, 0, sizeof(*_pPADStatus) ); + _pPADStatus->err = PAD_ERR_NONE; + // wtf is this? + _pPADStatus->button |= PAD_USE_ORIGIN; + + // TODO: this will need changing + // need focus ? + // i'm not inside CritSec when I access this bool + //if ( false == (g_plugin.pads[_numPAD].options.allow_background_input || IsFocus()) ) + //{ + // // center axes and return + // memset( &_pPADStatus->stickX, 0x80, 4 ); + // return; + //} + + // try lock + if ( false == g_plugin.controls_crit.TryEnter() ) + { + // if gui has lock (messing with controls), skip this input cycle + // center axes and return + memset( &_pPADStatus->stickX, 0x80, 4 ); + return; + } + + // if we are on the next input cycle, update output and input + // if we can get a lock + if ( _numPAD <= _last_numPAD && g_plugin.interface_crit.TryEnter() ) + { + g_plugin.controller_interface.UpdateOutput(); + g_plugin.controller_interface.UpdateInput(); + g_plugin.interface_crit.Leave(); + } + _last_numPAD = _numPAD; + + // get input + ((GCPad*)g_plugin.controllers[ _numPAD ])->GetInput( _pPADStatus ); + + // leave + g_plugin.controls_crit.Leave(); + +} + +// __________________________________________________________________________________________________ +// Function: Send keyboard input to the plugin +// Purpose: +// input: The key and if it's pressed or released +// output: None +// +EXPORT void CALL PAD_Input(u16 _Key, u8 _UpDown) +{ + // nofin +} + +// __________________________________________________________________________________________________ +// Function: PAD_Rumble +// Purpose: Pad rumble! +// input: PAD number, Command type (Stop=0, Rumble=1, Stop Hard=2) and strength of Rumble +// output: none +// +EXPORT void CALL PAD_Rumble(u8 _numPAD, unsigned int _uType, unsigned int _uStrength) +{ + // enter + if ( g_plugin.controls_crit.TryEnter() ) + { + // only on/off rumble + ((GCPad*)g_plugin.controllers[ _numPAD ])->SetOutput( 1 == _uType && _uStrength > 2 ); + + // leave + g_plugin.controls_crit.Leave(); + } +} + + +// GLOBAL I N T E R F A C E +// Function: GetDllInfo +// Purpose: This function allows the emulator to gather information +// about the DLL by filling in the PluginInfo structure. +// input: A pointer to a PLUGIN_INFO structure that needs to be +// filled by the function. (see def above) +// output: none +// +EXPORT void CALL GetDllInfo(PLUGIN_INFO* _pPluginInfo) +{ + // don't feel like messing around with all those strcpy functions and warnings + //char *s1 = CIFACE_PLUGIN_FULL_NAME, *s2 = _pPluginInfo->Name; + //while ( *s2++ = *s1++ ); + memcpy( _pPluginInfo->Name, CIFACE_PLUGIN_FULL_NAME, sizeof(CIFACE_PLUGIN_FULL_NAME) ); + _pPluginInfo->Type = PLUGIN_TYPE_PAD; + _pPluginInfo->Version = CIFACE_PLUGIN_VERSION; +} + +// ___________________________________________________________________________ +// Function: DllConfig +// Purpose: This function is optional function that is provided +// to allow the user to configure the DLL +// input: A handle to the window that calls this function +// output: none +// +EXPORT void CALL DllConfig(HWND _hParent) +{ + bool was_init = false; + if ( g_plugin.controller_interface.IsInit() ) // hack for showing dialog when game isnt running + was_init = true; + else + InitPlugin( _hParent ); + + // copied from GCPad +#if defined(HAVE_WX) && HAVE_WX + wxWindow *frame = GetParentedWxWindow(_hParent); + ConfigDialog* m_ConfigFrame = new ConfigDialog( frame, g_plugin, CIFACE_PLUGIN_FULL_NAME, was_init ); + +#ifdef _WIN32 + frame->Disable(); + m_ConfigFrame->ShowModal(); + frame->Enable(); +#else + m_ConfigFrame->ShowModal(); +#endif + +#ifdef _WIN32 + wxMilliSleep( 50 ); // hooray for hacks + frame->SetFocus(); + frame->SetHWND(NULL); +#endif + + m_ConfigFrame->Destroy(); + m_ConfigFrame = NULL; + frame->Destroy(); +#endif + // / + + if ( false == was_init ) // hack for showing dialog when game isnt running + g_plugin.controller_interface.DeInit(); +} + +// ___________________________________________________________________________ +// Function: DllDebugger +// Purpose: Open the debugger +// input: a handle to the window that calls this function +// output: none +// +EXPORT void CALL DllDebugger(HWND _hParent, bool Show) +{ + // wut? +} + +// ___________________________________________________________________________ +// Function: DllSetGlobals +// Purpose: Set the pointer for globals variables +// input: a pointer to the global struct +// output: none +// +EXPORT void CALL SetDllGlobals(PLUGIN_GLOBALS* _pPluginGlobals) +{ + // wut? +} + +// ___________________________________________________________________________ +// Function: Initialize +// Purpose: Initialize the plugin +// input: Init +// output: none +// +EXPORT void CALL Initialize(void *init) +{ + if ( false == g_plugin.controller_interface.IsInit() ) + InitPlugin( ((SPADInitialize*)init)->hWnd ); +} + +// ___________________________________________________________________________ +// Function: Shutdown +// Purpose: This function is called when the emulator is shutting down +// a game allowing the dll to de-initialise. +// input: none +// output: none +// +EXPORT void CALL Shutdown(void) +{ + //plugin.controls_crit.Enter(); // enter + if ( g_plugin.controller_interface.IsInit() ) + g_plugin.controller_interface.DeInit(); + //plugin.controls_crit.Leave(); // leave +} + +// ___________________________________________________________________________ +// Function: DoState +// Purpose: Saves/load state +// input/output: ptr +// input: mode +// +EXPORT void CALL DoState(unsigned char **ptr, int mode) +{ + // prolly won't need this +} + +// ___________________________________________________________________________ +// Function: EmuStateChange +// Purpose: Notifies the plugin of a change in emulation state +// input: newState +// output: none +// +EXPORT void CALL EmuStateChange(PLUGIN_EMUSTATE newState) +{ + // maybe use this later +} diff --git a/Source/Plugins/Plugin_GCPadNew/Src/IniFile.cpp b/Source/Plugins/Plugin_GCPadNew/Src/IniFile.cpp new file mode 100644 index 0000000000..b9a05b83b0 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/IniFile.cpp @@ -0,0 +1,142 @@ + +#include "IniFile.h" + +// +// TrimChars +// +// trim whitespace, or any, chars from both ends +// +template +std::string TrimChars( const std::string& str, const S space ) +{ + const size_t start = str.find_first_not_of( space ); + + if ( str.npos == start ) + return ""; + + return str.substr( start, str.find_last_not_of( space ) - start + 1 ); +} + +// +// IniSection :: SetValue +// +// set key's value if it doesn't match the default +// otherwise remove the key from the section if it exists +// +void IniSection::SetValue( const std::string& key, const std::string& val, const std::string& def ) +{ + if ( val != def ) + operator[](key) = val; + else + { + const const_iterator f = find(key); + if ( f != end() ) + erase( f ); + } +} + +// +// IniSection :: GetValue +// +// return a key's value if it exists +// otherwise return the default +// +std::string IniSection::GetValue( const std::string& key, const std::string& def ) +{ + const const_iterator f = find(key); + if ( f != end() ) + if ( false == f->second.empty() ) + return f->second; + return def; +} + +// +// IniFile :: Save +// +// save a file +// +void IniFile::Save( std::ostream& file ) +{ + const_iterator i = begin(), + e = end(); + for ( ; i != e; ++i ) + { + // skip a line at new sections + file << "\n[" << i->first << "]\n"; + Section::const_iterator si = i->second.begin(), + se = i->second.end(); + for ( ; si != se; ++si ) + file << si->first << " = " << si->second << '\n'; + } +} + +// +// IniFile :: Load +// +// load a file +// +void IniFile::Load( std::istream& file ) +{ + const char* const space = "\t\r "; + std::string line; + // start off with an empty section + Section* section = &(*this)[""]; + while ( std::getline( file, line ).good() ) // read a line + { + line = TrimChars(line,space); + if ( line.size() ) + { + switch ( line[0] ) + { + // comment + case '#' : + case ';' : + break; + // section + case '[' : + // kinda odd trimming + section = &(*this)[ TrimChars(line,"][\t\r ") ]; + break; + // key/value + default : + { + std::istringstream ss(line); + std::string key; std::getline( ss, key, '=' ); + std::string val; std::getline( ss, val ); + (*section)[ TrimChars(key,space) ] = TrimChars(val,space); + break; + } + } + } + } + Clean(); +} + +// +// IniFile :: Clean +// +// remove empty key/values and sections +// after trying to access ini sections/values, they are automatically allocated +// this deletes the empty stuff +// +void IniFile::Clean() +{ + iterator i = begin(), + e = end(); + for ( ; i != e; ) + { + Section::const_iterator si = i->second.begin(), + se = i->second.end(); + for ( ; si != se; ) + { + if ( si->second.empty() ) + i->second.erase( si++ ); + else + ++si; + } + if ( i->second.empty() ) + erase( i++ ); + else + ++i; + } +} diff --git a/Source/Plugins/Plugin_GCPadNew/Src/IniFile.h b/Source/Plugins/Plugin_GCPadNew/Src/IniFile.h new file mode 100644 index 0000000000..982c84b070 --- /dev/null +++ b/Source/Plugins/Plugin_GCPadNew/Src/IniFile.h @@ -0,0 +1,61 @@ +#ifndef _INIFILE_H_ +#define _INIFILE_H_ + +#include +#include +#include +#include + +// +// IniFile +// +class IniSection : public std::map< std::string, std::string > +{ +public: + void SetValue( const std::string& key, const std::string& val, const std::string& def = "" ); + std::string GetValue( const std::string& key, const std::string& def = "" ); + + template + void SetValue( const std::string& key, const V& val, const D& def = 0 ) + { + if ( val != def ) + { + std::ostringstream ss; + ss << long(val); + operator[](key) = ss.str(); + } + else + { + const const_iterator f = find(key); + if ( f != end() ) + erase( f ); + } + } + template + V GetValue( const std::string& key, const V& def = 0 ) + { + const const_iterator f = find(key); + if ( f != end() ) + if ( false == f->second.empty() ) + { + std::istringstream ss(f->second); + int val; + ss >> val; + return V(val); + } + return def; + } +}; + +class IniFile : public std::map< std::string, IniSection > +{ +public: + typedef IniSection Section; + + void Clean(); + void Save( std::ostream& file ); + void Load( std::istream& file ); +}; + + +#endif