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

Removed the dx9 pad plugin. I won't miss it. 

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@704 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
fires.gc 2008-09-26 07:31:43 +00:00
parent 7fcc9abe67
commit f69166d0c2
17 changed files with 0 additions and 3420 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
Source/Dolphin.sln
View File

@ -56,7 +56,6 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DolphinWX", "Core\DolphinWX
{636FAD5F-02D1-4E9A-BE67-FB8EA99B9A18} = {636FAD5F-02D1-4E9A-BE67-FB8EA99B9A18}
{33546D62-7F34-4EA6-A88E-D538B36E16BF} = {33546D62-7F34-4EA6-A88E-D538B36E16BF}
{3E03C179-8251-46E4-81F4-466F114BAC63} = {3E03C179-8251-46E4-81F4-466F114BAC63}
{805B34AA-82A5-4875-8DC7-3C85BDC0BCEE} = {805B34AA-82A5-4875-8DC7-3C85BDC0BCEE}
{521498BE-6089-4780-8223-E67C22F4E068} = {521498BE-6089-4780-8223-E67C22F4E068}
{E5D1F0C0-AA07-4841-A4EB-4CF4DAA6B0FA} = {E5D1F0C0-AA07-4841-A4EB-4CF4DAA6B0FA}
{29C2ABC1-ADA5-42CD-A5FC-96022D52A510} = {29C2ABC1-ADA5-42CD-A5FC-96022D52A510}
@ -84,8 +83,6 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VideoCommon", "Core\VideoCo
{C573CAF7-EE6A-458E-8049-16C0BF34C2E9} = {C573CAF7-EE6A-458E-8049-16C0BF34C2E9}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Plugin_PadDX9", "Plugins\Plugin_PadDX9\Plugin_PadDX9.vcproj", "{805B34AA-82A5-4875-8DC7-3C85BDC0BCEE}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Plugin_nJoy_SDL", "Plugins\Plugin_nJoy_SDL\Plugin_nJoy_SDL.vcproj", "{521498BE-6089-4780-8223-E67C22F4E068}"
ProjectSection(ProjectDependencies) = postProject
{48AD7E0A-25B1-4974-A1E3-03F8C438D34F} = {48AD7E0A-25B1-4974-A1E3-03F8C438D34F}
@ -290,18 +287,6 @@ Global
{E5D1F0C0-AA07-4841-A4EB-4CF4DAA6B0FA}.Release|Win32.Build.0 = Release|Win32
{E5D1F0C0-AA07-4841-A4EB-4CF4DAA6B0FA}.Release|x64.ActiveCfg = Release|x64
{E5D1F0C0-AA07-4841-A4EB-4CF4DAA6B0FA}.Release|x64.Build.0 = Release|x64
{805B34AA-82A5-4875-8DC7-3C85BDC0BCEE}.Debug|Win32.ActiveCfg = Debug|Win32
{805B34AA-82A5-4875-8DC7-3C85BDC0BCEE}.Debug|Win32.Build.0 = Debug|Win32
{805B34AA-82A5-4875-8DC7-3C85BDC0BCEE}.Debug|x64.ActiveCfg = Debug|x64
{805B34AA-82A5-4875-8DC7-3C85BDC0BCEE}.Debug|x64.Build.0 = Debug|x64
{805B34AA-82A5-4875-8DC7-3C85BDC0BCEE}.DebugFast|Win32.ActiveCfg = DebugFast|Win32
{805B34AA-82A5-4875-8DC7-3C85BDC0BCEE}.DebugFast|Win32.Build.0 = DebugFast|Win32
{805B34AA-82A5-4875-8DC7-3C85BDC0BCEE}.DebugFast|x64.ActiveCfg = DebugFast|x64
{805B34AA-82A5-4875-8DC7-3C85BDC0BCEE}.DebugFast|x64.Build.0 = DebugFast|x64
{805B34AA-82A5-4875-8DC7-3C85BDC0BCEE}.Release|Win32.ActiveCfg = Release|Win32
{805B34AA-82A5-4875-8DC7-3C85BDC0BCEE}.Release|Win32.Build.0 = Release|Win32
{805B34AA-82A5-4875-8DC7-3C85BDC0BCEE}.Release|x64.ActiveCfg = Release|x64
{805B34AA-82A5-4875-8DC7-3C85BDC0BCEE}.Release|x64.Build.0 = Release|x64
{521498BE-6089-4780-8223-E67C22F4E068}.Debug|Win32.ActiveCfg = Debug|Win32
{521498BE-6089-4780-8223-E67C22F4E068}.Debug|Win32.Build.0 = Debug|Win32
{521498BE-6089-4780-8223-E67C22F4E068}.Debug|x64.ActiveCfg = Debug|x64

752
Source/Plugins/Plugin_PadDX9/Plugin_PadDX9.vcproj
View File

@ -1,752 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9,00"
Name="Plugin_PadDX9"
ProjectGUID="{805B34AA-82A5-4875-8DC7-3C85BDC0BCEE}"
RootNamespace="Plugin_PadDX9"
TargetFrameworkVersion="131072"
>
<Platforms>
<Platform
Name="Win32"
/>
<Platform
Name="x64"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Release|Win32"
OutputDirectory="$(PlatformName)\$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="true"
SuppressStartupBanner="true"
TargetEnvironment="1"
TypeLibraryName=".\Release/Pad_DirectX9.tlb"
HeaderFileName=""
/>
<Tool
Name="VCCLCompilerTool"
Optimization="3"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="../../../Externals/WTL80;../../PluginSpecs"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;PAD_DIRECTX9_EXPORTS;_CRT_SECURE_NO_DEPRECATE"
StringPooling="true"
RuntimeLibrary="0"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
FloatingPointModel="0"
UsePrecompiledHeader="1"
PrecompiledHeaderThrough="stdafx.h"
PrecompiledHeaderFile="$(IntDir)\$(TargetName).pch"
AssemblerListingLocation="$(IntDir)\"
ObjectFile="$(IntDir)\"
ProgramDataBaseFileName="$(IntDir)\"
WarningLevel="3"
WarnAsError="false"
SuppressStartupBanner="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1053"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="dxguid.lib dxerr9.lib dinput8.lib odbc32.lib odbccp32.lib"
OutputFile="..\..\..\Binary\Win32/plugins\Plugin_PadDX9.dll"
LinkIncremental="1"
SuppressStartupBanner="true"
GenerateManifest="false"
ProgramDatabaseFile=".\Release/Pad_DirectX9.pdb"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
ImportLibrary=".\Release/Pad_DirectX9.lib"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|x64"
OutputDirectory="$(PlatformName)\$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="true"
SuppressStartupBanner="true"
TargetEnvironment="3"
TypeLibraryName=".\Release/Pad_DirectX9.tlb"
HeaderFileName=""
/>
<Tool
Name="VCCLCompilerTool"
Optimization="3"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="../../../Externals/WTL80;../../PluginSpecs"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;PAD_DIRECTX9_EXPORTS;_CRT_SECURE_NO_DEPRECATE"
StringPooling="true"
RuntimeLibrary="0"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
FloatingPointModel="0"
UsePrecompiledHeader="1"
PrecompiledHeaderThrough="stdafx.h"
PrecompiledHeaderFile="$(IntDir)\$(TargetName).pch"
AssemblerListingLocation="$(IntDir)\"
ObjectFile="$(IntDir)\"
ProgramDataBaseFileName="$(IntDir)\"
WarningLevel="3"
WarnAsError="false"
SuppressStartupBanner="true"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1053"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="dxguid.lib dxerr9.lib dinput8.lib odbc32.lib odbccp32.lib"
OutputFile="..\..\..\Binary\x64\plugins\Plugin_PadDX9.dll"
LinkIncremental="1"
SuppressStartupBanner="true"
GenerateManifest="false"
ProgramDatabaseFile=".\Release/Pad_DirectX9.pdb"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
ImportLibrary=".\Release/Pad_DirectX9.lib"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Debug|Win32"
OutputDirectory="$(PlatformName)\$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="_DEBUG"
MkTypLibCompatible="true"
SuppressStartupBanner="true"
TargetEnvironment="1"
TypeLibraryName=".\Debug/Pad_DirectX9.tlb"
HeaderFileName=""
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="../../../Externals/WTL80;../../PluginSpecs"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;PAD_DIRECTX9_EXPORTS;;_CRT_SECURE_NO_DEPRECATE"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
FloatingPointModel="0"
UsePrecompiledHeader="0"
PrecompiledHeaderThrough="stdafx.h"
PrecompiledHeaderFile="$(IntDir)\$(TargetName).pch"
AssemblerListingLocation="$(IntDir)\"
ObjectFile="$(IntDir)\"
ProgramDataBaseFileName="$(IntDir)\"
WarningLevel="3"
WarnAsError="false"
SuppressStartupBanner="true"
DebugInformationFormat="4"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1053"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="dxguid.lib dxerr9.lib dinput8.lib odbc32.lib odbccp32.lib"
OutputFile="..\..\..\Binary\Win32/plugins\Plugin_PadDX9D.dll"
LinkIncremental="2"
SuppressStartupBanner="true"
GenerateManifest="false"
GenerateDebugInformation="true"
ProgramDatabaseFile=".\Debug/Pad_DirectX9.pdb"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
ImportLibrary=".\Debug/Pad_DirectX9.lib"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Debug|x64"
OutputDirectory="$(PlatformName)\$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="_DEBUG"
MkTypLibCompatible="true"
SuppressStartupBanner="true"
TargetEnvironment="3"
TypeLibraryName=".\Debug/Pad_DirectX9.tlb"
HeaderFileName=""
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="../../../Externals/WTL80;../../PluginSpecs"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;PAD_DIRECTX9_EXPORTS;;_CRT_SECURE_NO_DEPRECATE"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
FloatingPointModel="0"
UsePrecompiledHeader="0"
PrecompiledHeaderThrough="stdafx.h"
PrecompiledHeaderFile="$(IntDir)\$(TargetName).pch"
AssemblerListingLocation="$(IntDir)\"
ObjectFile="$(IntDir)\"
ProgramDataBaseFileName="$(IntDir)\"
WarningLevel="3"
WarnAsError="false"
SuppressStartupBanner="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1053"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="dxguid.lib dxerr9.lib dinput8.lib odbc32.lib odbccp32.lib"
OutputFile="..\..\..\Binary\x64\plugins\Plugin_PadDX9D.dll"
LinkIncremental="1"
SuppressStartupBanner="true"
GenerateManifest="false"
GenerateDebugInformation="true"
ProgramDatabaseFile=".\Debug/Pad_DirectX9.pdb"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
ImportLibrary=".\Debug/Pad_DirectX9.lib"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="DebugFast|Win32"
OutputDirectory="$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="true"
SuppressStartupBanner="true"
TargetEnvironment="1"
TypeLibraryName=".\Release/Pad_DirectX9.tlb"
HeaderFileName=""
/>
<Tool
Name="VCCLCompilerTool"
Optimization="3"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="../../../Externals/WTL80;../../PluginSpecs"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;PAD_DIRECTX9_EXPORTS;_CRT_SECURE_NO_DEPRECATE"
StringPooling="true"
RuntimeLibrary="0"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
FloatingPointModel="0"
UsePrecompiledHeader="1"
PrecompiledHeaderThrough="stdafx.h"
PrecompiledHeaderFile="$(IntDir)\$(TargetName).pch"
AssemblerListingLocation="$(IntDir)\"
ObjectFile="$(IntDir)\"
ProgramDataBaseFileName="$(IntDir)\"
WarningLevel="3"
WarnAsError="false"
SuppressStartupBanner="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1053"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="dxguid.lib dxerr9.lib dinput8.lib odbc32.lib odbccp32.lib"
OutputFile="..\..\..\Binary\Win32/plugins\Plugin_PadDX9.dll"
LinkIncremental="1"
SuppressStartupBanner="true"
GenerateManifest="false"
ProgramDatabaseFile=".\Release/Pad_DirectX9.pdb"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
ImportLibrary=".\Release/Pad_DirectX9.lib"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="DebugFast|x64"
OutputDirectory="$(PlatformName)\$(ConfigurationName)"
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="true"
SuppressStartupBanner="true"
TargetEnvironment="3"
TypeLibraryName=".\Release/Pad_DirectX9.tlb"
HeaderFileName=""
/>
<Tool
Name="VCCLCompilerTool"
Optimization="3"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="../../../Externals/WTL80;../../PluginSpecs"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;PAD_DIRECTX9_EXPORTS;_CRT_SECURE_NO_DEPRECATE"
StringPooling="true"
RuntimeLibrary="0"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
FloatingPointModel="0"
UsePrecompiledHeader="1"
PrecompiledHeaderThrough="stdafx.h"
PrecompiledHeaderFile="$(IntDir)\$(TargetName).pch"
AssemblerListingLocation="$(IntDir)\"
ObjectFile="$(IntDir)\"
ProgramDataBaseFileName="$(IntDir)\"
WarningLevel="3"
WarnAsError="false"
SuppressStartupBanner="true"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1053"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="dxguid.lib dxerr9.lib dinput8.lib odbc32.lib odbccp32.lib"
OutputFile="..\..\..\Binary\x64\plugins\Plugin_PadDX9.dll"
LinkIncremental="1"
SuppressStartupBanner="true"
GenerateManifest="false"
ProgramDatabaseFile=".\Release/Pad_DirectX9.pdb"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
ImportLibrary=".\Release/Pad_DirectX9.lib"
TargetMachine="17"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="AboutDialog"
>
<File
RelativePath=".\Src\AboutDlg.cpp"
>
</File>
<File
RelativePath=".\Src\AboutDlg.h"
>
</File>
</Filter>
<Filter
Name="ConfigDialog"
>
<File
RelativePath=".\Src\ConfigDlg.cpp"
>
</File>
<File
RelativePath=".\Src\ConfigDlg.h"
>
</File>
</Filter>
<Filter
Name="IniFile"
>
<File
RelativePath=".\Src\IniFile.cpp"
>
</File>
<File
RelativePath=".\Src\IniFile.h"
>
</File>
</Filter>
<Filter
Name="Resource Files"
>
<File
RelativePath=".\Src\resource.h"
>
</File>
<File
RelativePath=".\Src\resource.rc"
>
</File>
</Filter>
<File
RelativePath=".\Src\DIHandler.cpp"
>
</File>
<File
RelativePath=".\Src\DIHandler.h"
>
</File>
<File
RelativePath=".\Src\main.cpp"
>
<FileConfiguration
Name="Release|Win32"
>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;PAD_DIRECTX9_EXPORTS;$(NoInherit)"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|x64"
>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;PAD_DIRECTX9_EXPORTS;$(NoInherit)"
/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32"
>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;PAD_DIRECTX9_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"
/>
</FileConfiguration>
<FileConfiguration
Name="Debug|x64"
>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;PAD_DIRECTX9_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"
/>
</FileConfiguration>
<FileConfiguration
Name="DebugFast|Win32"
>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;PAD_DIRECTX9_EXPORTS;$(NoInherit)"
/>
</FileConfiguration>
<FileConfiguration
Name="DebugFast|x64"
>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;PAD_DIRECTX9_EXPORTS;$(NoInherit)"
/>
</FileConfiguration>
</File>
<File
RelativePath=".\Src\multidi.cpp"
>
</File>
<File
RelativePath=".\Src\multidi.h"
>
</File>
<File
RelativePath="..\Plugin_Specs\pad.h"
>
</File>
<File
RelativePath=".\Src\stdafx.cpp"
>
</File>
<File
RelativePath=".\Src\stdafx.h"
>
</File>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

48
Source/Plugins/Plugin_PadDX9/Src/AboutDlg.cpp
View File

@ -1,48 +0,0 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
/////////////////////////////////////////////////////////////////////////////////////////////////////
// M O D U L E B E G I N ///////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "resource.h"
#include "AboutDlg.h"
/////////////////////////////////////////////////////////////////////////////////////////////////////
// I M P L E M E N T A T I O N //////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
// __________________________________________________________________________________________________
// OnInitDialog
//
LRESULT
CAboutDlg::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
{
CenterWindow(GetParent());
return TRUE;
}
// __________________________________________________________________________________________________
// OnCloseCmd
//
LRESULT
CAboutDlg::OnCloseCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
EndDialog(wID);
return 0;
}

42
Source/Plugins/Plugin_PadDX9/Src/AboutDlg.h
View File

@ -1,42 +0,0 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
/////////////////////////////////////////////////////////////////////////////////////////////////////
// M O D U L E B E G I N ///////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma once
class CAboutDlg : public CDialogImpl<CAboutDlg>
{
public:
enum { IDD = IDD_ABOUTPAD };
BEGIN_MSG_MAP(CAboutDlg)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
COMMAND_ID_HANDLER(IDOK, OnCloseCmd)
COMMAND_ID_HANDLER(IDCANCEL, OnCloseCmd)
END_MSG_MAP()
// Handler prototypes (uncomment arguments if needed):
// LRESULT MessageHandler(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
// LRESULT CommandHandler(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
// LRESULT NotifyHandler(int /*idCtrl*/, LPNMHDR /*pnmh*/, BOOL& /*bHandled*/)
LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/);
LRESULT OnCloseCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/);
};

47
Source/Plugins/Plugin_PadDX9/Src/ConfigDlg.cpp
View File

@ -1,47 +0,0 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
/////////////////////////////////////////////////////////////////////////////////////////////////////
// M O D U L E B E G I N ///////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "resource.h"
#include "ConfigDlg.h"
/////////////////////////////////////////////////////////////////////////////////////////////////////
// I M P L E M E N T A T I O N //////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
// __________________________________________________________________________________________________
// OnInitDialog
//
LRESULT
CConfigDlg::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
{
return TRUE;
}
// __________________________________________________________________________________________________
// OnCloseCmd
//
LRESULT
CConfigDlg::OnCloseCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
EndDialog(wID);
return 0;
}

42
Source/Plugins/Plugin_PadDX9/Src/ConfigDlg.h
View File

@ -1,42 +0,0 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
/////////////////////////////////////////////////////////////////////////////////////////////////////
// M O D U L E B E G I N ///////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma once
class CConfigDlg : public CDialogImpl<CConfigDlg>
{
public:
enum { IDD = IDD_PADCONFIG };
BEGIN_MSG_MAP(CConfigDlg)
MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
COMMAND_ID_HANDLER(IDOK, OnCloseCmd)
END_MSG_MAP()
private:
// Handler prototypes (uncomment arguments if needed):
// LRESULT MessageHandler(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
// LRESULT CommandHandler(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
// LRESULT NotifyHandler(int /*idCtrl*/, LPNMHDR /*pnmh*/, BOOL& /*bHandled*/)
LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/);
LRESULT OnCloseCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/);
};

482
Source/Plugins/Plugin_PadDX9/Src/DIHandler.cpp
View File

@ -1,482 +0,0 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
/////////////////////////////////////////////////////////////////////////////////////////////////////
// M O D U L E B E G I N ///////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include <math.h>
#include "PluginSpecs_Pad.h"
#include "MultiDI.h"
#include "DIHandler.h"
/////////////////////////////////////////////////////////////////////////////////////////////////////
// T Y P E D E F S / D E F I N E S //////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
// Actions used by this app
DIACTION CDIHandler::m_rgGameAction[] =
{
// Keyboard input mappings
{ CDIHandler::INPUT_MAIN_LEFT, DIKEYBOARD_LEFT, 0, TEXT("Main left"), },
{ CDIHandler::INPUT_MAIN_RIGHT, DIKEYBOARD_RIGHT, 0, TEXT("Main right"), },
{ CDIHandler::INPUT_MAIN_UP, DIKEYBOARD_UP, 0, TEXT("Main up"), },
{ CDIHandler::INPUT_MAIN_DOWN, DIKEYBOARD_DOWN, 0, TEXT("Main down"), },
{ CDIHandler::INPUT_CPAD_LEFT, DIKEYBOARD_J, 0, TEXT("CPad left"), },
{ CDIHandler::INPUT_CPAD_RIGHT, DIKEYBOARD_L, 0, TEXT("CPad right"), },
{ CDIHandler::INPUT_CPAD_UP, DIKEYBOARD_I, 0, TEXT("CPad up"), },
{ CDIHandler::INPUT_CPAD_DOWN, DIKEYBOARD_K, 0, TEXT("CPad down"), },
{ CDIHandler::INPUT_DPAD_LEFT, DIKEYBOARD_F, 0, TEXT("DPad left"), },
{ CDIHandler::INPUT_DPAD_RIGHT, DIKEYBOARD_H, 0, TEXT("DPad right"), },
{ CDIHandler::INPUT_DPAD_UP, DIKEYBOARD_T, 0, TEXT("DPad up"), },
{ CDIHandler::INPUT_DPAD_DOWN, DIKEYBOARD_G, 0, TEXT("DPad down"), },
{ CDIHandler::INPUT_BUTTON_START, DIKEYBOARD_RETURN, 0, TEXT("Start"), },
{ CDIHandler::INPUT_BUTTON_A, DIKEYBOARD_X, 0, TEXT("A-Button"), },
{ CDIHandler::INPUT_BUTTON_B, DIKEYBOARD_Y, 0, TEXT("B-Button"), },
{ CDIHandler::INPUT_BUTTON_X, DIKEYBOARD_S, 0, TEXT("X-Button"), },
{ CDIHandler::INPUT_BUTTON_Y, DIKEYBOARD_C, 0, TEXT("Y-Button"), },
{ CDIHandler::INPUT_BUTTON_Z, DIKEYBOARD_D, 0, TEXT("Z-Button"), },
{ CDIHandler::INPUT_BUTTON_L, DIKEYBOARD_Q, 0, TEXT("L-Trigger"), },
{ CDIHandler::INPUT_BUTTON_R, DIKEYBOARD_W, 0, TEXT("R-Trigger"), },
// Joystick input mappings
{ CDIHandler::INPUT_MAIN_AXIS_LR, DIAXIS_ARCADEP_LATERAL, 0, _T("Main left/right"), },
{ CDIHandler::INPUT_MAIN_AXIS_UD, DIAXIS_ARCADEP_MOVE, 0, _T("Main Up/Down"), },
{ CDIHandler::INPUT_CPAD_AXIS_LR, DIAXIS_ANY_1, 0, _T("CPad left/right"), },
{ CDIHandler::INPUT_CPAD_AXIS_UP, DIAXIS_ANY_2, 0, _T("CPad Up/Down"), },
{ CDIHandler::INPUT_DPAD_AXIS_LR, DIPOV_ANY_1, 0, _T("DPad left/right"), },
{ CDIHandler::INPUT_DPAD_AXIS_UP, DIPOV_ANY_2, 0, _T("DPad Up/Down"), },
};
const GUID g_guidApp = { 0x3afabad0, 0xd2c0, 0x4514, { 0xb4, 0x7e, 0x65, 0xfe, 0xf9, 0xb5, 0x14, 0x2e } };
#define SAMPLE_KEY TEXT("Emulator\\Dolphin\\PadPlugin2")
#define NUMBER_OF_GAMEACTIONS (sizeof(m_rgGameAction)/sizeof(DIACTION))
/////////////////////////////////////////////////////////////////////////////////////////////////////
// I M P L E M E N T A T I O N ////////////////////////// ////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
// ________________________________________________________________________________________ __________
// constructor
//
CDIHandler::CDIHandler(void) :
m_hWnd(NULL),
m_pInputDeviceManager(NULL)
{
}
// ________________________________________________________________________________________ __________
// destructor
//
CDIHandler::~CDIHandler(void)
{
CleanupDirectInput();
}
// ________________________________________________________________________________________ __________
// InitInput
//
HRESULT
CDIHandler::InitInput(HWND _hWnd)
{
if (m_hWnd == _hWnd)
return S_OK;
CleanupDirectInput();
m_hWnd = _hWnd;
HRESULT hr;
// Setup action format for the actual gameplay
ZeroMemory( &m_diafGame, sizeof(DIACTIONFORMAT) );
m_diafGame.dwSize = sizeof(DIACTIONFORMAT);
m_diafGame.dwActionSize = sizeof(DIACTION);
m_diafGame.dwDataSize = NUMBER_OF_GAMEACTIONS * sizeof(DWORD);
m_diafGame.guidActionMap = g_guidApp;
m_diafGame.dwGenre = DIVIRTUAL_ARCADE_PLATFORM;
m_diafGame.dwNumActions = NUMBER_OF_GAMEACTIONS;
m_diafGame.rgoAction = m_rgGameAction;
m_diafGame.lAxisMin = -100;
m_diafGame.lAxisMax = 100;
m_diafGame.dwBufferSize = 32;
_tcscpy_s( m_diafGame.tszActionMap, _T("Dolphin Pad Plugin") );
// Create a new input device manager
m_pInputDeviceManager = new CMultiplayerInputDeviceManager( SAMPLE_KEY );
if( FAILED( hr = ChangeNumPlayers( 1, FALSE, FALSE ) ) )
{
MessageBox(NULL, "InitInput", "Pad", MB_OK);
return S_FALSE;
}
return S_OK;
}
// ________________________________________________________________________________________ __________
// ConfigInput
//
void
CDIHandler::ConfigInput(void)
{
HRESULT hr;
CleanupDeviceStateStructs();
// Configure the devices (with edit capability)
hr = m_pInputDeviceManager->ConfigureDevices( m_hWnd, NULL, NULL, DICD_EDIT, NULL );
if( FAILED(hr) )
{
if( hr == E_DIUTILERR_PLAYERWITHOUTDEVICE )
{
// There's a player that hasn't been assigned a device. Some games may
// want to handle this by reducing the number of players, or auto-assigning
// a device, or warning the user, etc.
MessageBox( m_hWnd, TEXT("There is at least one player that wasn't assigned ") \
TEXT("a device\n") \
TEXT("Press OK to auto-assign a device to these users"),
TEXT("Player Without Device"), MB_OK | MB_ICONEXCLAMATION );
}
// Auto-reassign every player a device.
ChangeNumPlayers( m_dwNumPlayers, FALSE, FALSE );
}
}
// ________________________________________________________________________________________ __________
// CleanupDirectInput
//
void
CDIHandler::CleanupDirectInput(void)
{
if( NULL == m_pInputDeviceManager )
return;
CleanupDeviceStateStructs();
// Cleanup DirectX input objects
SAFE_DELETE( m_pInputDeviceManager );
}
// ________________________________________________________________________________________ __________
// CleanupDeviceStateStructs
//
void
CDIHandler::CleanupDeviceStateStructs(void)
{
// Get access to the list of semantically-mapped input devices
// to delete all InputDeviceState structs before calling ConfigureDevices()
CMultiplayerInputDeviceManager::DeviceInfo* pDeviceInfos;
DWORD dwNumDevices;
m_pInputDeviceManager->GetDevices( &pDeviceInfos, &dwNumDevices );
for( DWORD i=0; i<dwNumDevices; i++ )
{
SUserInput* pInputDeviceState = (SUserInput*) pDeviceInfos[i].pParam;
SAFE_DELETE( pInputDeviceState );
pDeviceInfos[i].pParam = NULL;
}
}
// ________________________________________________________________________________________ __________
// CleanupDeviceStateStructs
//
HRESULT
CDIHandler::ChangeNumPlayers( DWORD dwNumPlayers, BOOL bResetOwnership, BOOL bResetMappings )
{
HRESULT hr;
m_dwNumPlayers = dwNumPlayers;
// Just pass in stock names. Real games may want to ask the user for a name, etc.
TCHAR* strUserNames[4] = { TEXT("Controller 1"), TEXT("Controller 2"),
TEXT("Controller 3"), TEXT("Controller 4") };
BOOL bSuccess = FALSE;
while( !bSuccess )
{
hr = m_pInputDeviceManager->Create( m_hWnd, strUserNames, m_dwNumPlayers, &m_diafGame,
StaticInputAddDeviceCB, NULL,
bResetOwnership, bResetMappings );
if( FAILED(hr) )
{
switch( hr )
{
case E_DIUTILERR_DEVICESTAKEN:
{
// It's possible that a single user could "own" too many devices for the other
// players to get into the game. If so, we reinit the manager class to provide
// each user with a device that has a default configuration.
bResetOwnership = TRUE;
MessageBox( m_hWnd, TEXT("You have entered more users than there are suitable ") \
TEXT("devices, or some users are claiming too many devices.\n") \
TEXT("Press OK to give each user a default device"),
TEXT("Devices Are Taken"), MB_OK | MB_ICONEXCLAMATION );
break;
}
case E_DIUTILERR_TOOMANYUSERS:
{
// Another common error is if more users are attempting to play than there are devices
// attached to the machine. In this case, the number of players is automatically
// lowered to make playing the game possible.
DWORD dwNumDevices = m_pInputDeviceManager->GetNumDevices();
m_dwNumPlayers = dwNumDevices;
TCHAR sz[256];
wsprintf( sz, TEXT("There are not enough devices attached to the ") \
TEXT("system for the number of users you entered.\nThe ") \
TEXT("number of users has been automatically changed to ") \
TEXT("%i (the number of devices available on the system)."),
m_dwNumPlayers );
MessageBox( m_hWnd, sz, _T("Too Many Users"), MB_OK | MB_ICONEXCLAMATION );
break;
}
default:
MessageBox(NULL, "Error creating DirectInput device.", "Pad DX9", MB_OK);
return S_FALSE;
}
m_pInputDeviceManager->Cleanup();
}
else
{
bSuccess = TRUE;
}
}
return S_OK;
}
// ________________________________________________________________________________________ __________
// UpdateInput
//
void
CDIHandler::UpdateInput(void)
{
if( NULL == m_pInputDeviceManager )
return;
CMultiplayerInputDeviceManager::DeviceInfo* pDeviceInfos;
DWORD dwNumDevices;
// Get access to the list of semantically-mapped input devices
m_pInputDeviceManager->GetDevices( &pDeviceInfos, &dwNumDevices );
// Loop through all devices and check game input
for( DWORD i=0; i<dwNumDevices; i++ )
{
// skip past any devices that aren't assigned,
// since we don't care about them
if( pDeviceInfos[i].pPlayerInfo == NULL )
continue;
DIDEVICEOBJECTDATA rgdod[10];
DWORD dwItems = 10;
HRESULT hr;
LPDIRECTINPUTDEVICE8 pdidDevice = pDeviceInfos[i].pdidDevice;
SUserInput* pInputDeviceState = (SUserInput*) pDeviceInfos[i].pParam;
// dunno if we need this
if(pDeviceInfos[i].bRelativeAxis)
{
// For relative axis data, the action mapper only informs us when
// the delta data is non-zero, so we need to zero its state
// out each frame
pInputDeviceState->fMainLR = 0.0f;
pInputDeviceState->fMainUP = 0.0f;
pInputDeviceState->fCPadLR = 0.0f;
pInputDeviceState->fCPadUP = 0.0f;
pInputDeviceState->fDPadLR = 0.0f;
pInputDeviceState->fDPadUP = 0.0f;
pInputDeviceState->fTriggerL = 0.0f;
pInputDeviceState->fTriggerR = 0.0f;
}
hr = pdidDevice->Acquire();
hr = pdidDevice->Poll();
hr = pdidDevice->GetDeviceData( sizeof(DIDEVICEOBJECTDATA), rgdod, &dwItems, 0 );
if( FAILED(hr) )
continue;
// Get the sematics codes for the game menu
for( DWORD j=0; j<dwItems; j++ )
{
bool bButtonState = (rgdod[j].dwData==0x80) ? true : false;
FLOAT fAxisState = (FLOAT)((int)rgdod[j].dwData)/100.0f;
switch( rgdod[j].uAppData )
{
// Handle relative axis data
case INPUT_MAIN_AXIS_LR: pInputDeviceState->fMainLR = fAxisState; break;
case INPUT_MAIN_AXIS_UD: pInputDeviceState->fMainUP = fAxisState; break;
case INPUT_CPAD_AXIS_LR: pInputDeviceState->fCPadLR = fAxisState; break;
case INPUT_CPAD_AXIS_UP: pInputDeviceState->fCPadUP = fAxisState; break;
case INPUT_DPAD_AXIS_LR: pInputDeviceState->fDPadLR = fAxisState; break;
case INPUT_DPAD_AXIS_UP: pInputDeviceState->fDPadUP = fAxisState; break;
// Handle buttons separately so the button state data
// doesn't overwrite the axis state data, and handle
// each button separately so they don't overwrite each other
case INPUT_MAIN_LEFT: pInputDeviceState->bMainLeft = bButtonState; break;
case INPUT_MAIN_RIGHT: pInputDeviceState->bMainRight = bButtonState; break;
case INPUT_MAIN_UP: pInputDeviceState->bMainUp = bButtonState; break;
case INPUT_MAIN_DOWN: pInputDeviceState->bMainDown = bButtonState; break;
case INPUT_CPAD_LEFT: pInputDeviceState->bCPadLeft = bButtonState; break;
case INPUT_CPAD_RIGHT: pInputDeviceState->bCPadRight = bButtonState; break;
case INPUT_CPAD_UP: pInputDeviceState->bCPadUp = bButtonState; break;
case INPUT_CPAD_DOWN: pInputDeviceState->bCPadDown = bButtonState; break;
case INPUT_DPAD_LEFT: pInputDeviceState->bDPadLeft = bButtonState; break;
case INPUT_DPAD_RIGHT: pInputDeviceState->bDPadRight = bButtonState; break;
case INPUT_DPAD_UP: pInputDeviceState->bDPadUp = bButtonState; break;
case INPUT_DPAD_DOWN: pInputDeviceState->bDPadDown = bButtonState; break;
case INPUT_BUTTON_START: pInputDeviceState->bButtonStart = bButtonState; break;
case INPUT_BUTTON_A: pInputDeviceState->bButtonA = bButtonState; break;
case INPUT_BUTTON_B: pInputDeviceState->bButtonB = bButtonState; break;
case INPUT_BUTTON_X: pInputDeviceState->bButtonX = bButtonState; break;
case INPUT_BUTTON_Y: pInputDeviceState->bButtonY = bButtonState; break;
case INPUT_BUTTON_Z: pInputDeviceState->bButtonZ = bButtonState; break;
case INPUT_BUTTON_L: pInputDeviceState->fTriggerL = bButtonState; break;
case INPUT_BUTTON_R: pInputDeviceState->fTriggerR = bButtonState; break;
}
}
}
for( DWORD iPlayer=0; iPlayer<m_dwNumPlayers; iPlayer++ )
{
SControllerInput& ctrlInput = m_controllerInput[iPlayer];
m_controllerInput[iPlayer].fMainLR = 0.0f;
m_controllerInput[iPlayer].fMainUP = 0.0f;
m_controllerInput[iPlayer].fCPadLR = 0.0f;
m_controllerInput[iPlayer].fCPadUP = 0.0f;
m_controllerInput[iPlayer].fDPadLR = 0.0f;
m_controllerInput[iPlayer].fDPadUP = 0.0f;
ctrlInput.bButtonA = false;
ctrlInput.bButtonB = false;
ctrlInput.bButtonX = false;
ctrlInput.bButtonY = false;
ctrlInput.bButtonZ = false;
ctrlInput.bButtonStart = false;
ctrlInput.fTriggerL = false;
ctrlInput.fTriggerR = false;
// Concatinate the data from all the DirectInput devices
for(DWORD i=0; i<dwNumDevices; i++)
{
// Only look at devices that are assigned to this player
if( pDeviceInfos[i].pPlayerInfo == NULL ||
pDeviceInfos[i].pPlayerInfo->dwPlayerIndex != iPlayer )
continue;
SUserInput* pInputDeviceState = (SUserInput*)pDeviceInfos[i].pParam;
// main-axis
if( fabs(pInputDeviceState->fMainLR) > fabs(ctrlInput.fMainLR) )
ctrlInput.fMainLR = pInputDeviceState->fMainLR;
if( fabs(pInputDeviceState->fMainUP) > fabs(ctrlInput.fMainUP) )
ctrlInput.fMainUP = pInputDeviceState->fMainUP;
if (pInputDeviceState->bMainLeft) ctrlInput.fMainLR = -1.0f;
if (pInputDeviceState->bMainRight) ctrlInput.fMainLR = 1.0f;
if (pInputDeviceState->bMainUp) ctrlInput.fMainUP = -1.0f;
if (pInputDeviceState->bMainDown) ctrlInput.fMainUP = 1.0f;
// CPad-axis
if( fabs(pInputDeviceState->fCPadLR) > fabs(ctrlInput.fCPadLR) )
ctrlInput.fCPadLR = pInputDeviceState->fCPadLR;
if( fabs(pInputDeviceState->fCPadUP) > fabs(ctrlInput.fCPadUP) )
ctrlInput.fCPadUP = pInputDeviceState->fCPadUP;
if (pInputDeviceState->bCPadLeft) ctrlInput.fCPadLR = -1.0f;
if (pInputDeviceState->bCPadRight) ctrlInput.fCPadLR = 1.0f;
if (pInputDeviceState->bCPadUp) ctrlInput.fCPadUP = -1.0f;
if (pInputDeviceState->bCPadDown) ctrlInput.fCPadUP = 1.0f;
// DPad-axis
if( fabs(pInputDeviceState->fDPadLR) > fabs(ctrlInput.fDPadLR) )
ctrlInput.fDPadLR = pInputDeviceState->fDPadLR;
if( fabs(pInputDeviceState->fDPadUP) > fabs(ctrlInput.fDPadUP) )
ctrlInput.fDPadUP = pInputDeviceState->fDPadUP;
if (pInputDeviceState->bDPadLeft) ctrlInput.fDPadLR = -1.0f;
if (pInputDeviceState->bDPadRight) ctrlInput.fDPadLR = 1.0f;
if (pInputDeviceState->bDPadUp) ctrlInput.fDPadUP = -1.0f;
if (pInputDeviceState->bDPadDown) ctrlInput.fDPadUP = 1.0f;
// buttons
if (pInputDeviceState->bButtonA) ctrlInput.bButtonA = true;
if (pInputDeviceState->bButtonB) ctrlInput.bButtonB = true;
if (pInputDeviceState->bButtonX) ctrlInput.bButtonX = true;
if (pInputDeviceState->bButtonY) ctrlInput.bButtonY = true;
if (pInputDeviceState->bButtonZ) ctrlInput.bButtonZ = true;
if (pInputDeviceState->bButtonStart)ctrlInput.bButtonStart = true;
if (pInputDeviceState->fTriggerL) ctrlInput.fTriggerL = true;
if (pInputDeviceState->fTriggerR) ctrlInput.fTriggerR = true;
}
}
}
// ________________________________________________________________________________________ __________
// StaticInputAddDeviceCB
//
HRESULT CALLBACK
CDIHandler::StaticInputAddDeviceCB( CMultiplayerInputDeviceManager::PlayerInfo* pPlayerInfo,
CMultiplayerInputDeviceManager::DeviceInfo* pDeviceInfo,
const DIDEVICEINSTANCE* pdidi,
LPVOID pParam)
{
CDIHandler* pApp = (CDIHandler*) pParam;
return pApp->InputAddDeviceCB( pPlayerInfo, pDeviceInfo, pdidi );
}
// ________________________________________________________________________________________ __________
// InputAddDeviceCB
//
HRESULT
CDIHandler::InputAddDeviceCB( CMultiplayerInputDeviceManager::PlayerInfo* pPlayerInfo,
CMultiplayerInputDeviceManager::DeviceInfo* pDeviceInfo,
const DIDEVICEINSTANCE* pdidi)
{
if( (GET_DIDEVICE_TYPE(pdidi->dwDevType) != DI8DEVTYPE_KEYBOARD) &&
(GET_DIDEVICE_TYPE(pdidi->dwDevType) != DI8DEVTYPE_MOUSE) )
{
// Setup the deadzone
DIPROPDWORD dipdw;
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = 500;
pDeviceInfo->pdidDevice->SetProperty( DIPROP_DEADZONE, &dipdw.diph );
}
// Create a new InputDeviceState for each device so the
// app can record its state
SUserInput* pNewInputDeviceState = new SUserInput;
ZeroMemory( pNewInputDeviceState, sizeof(SUserInput) );
pDeviceInfo->pParam = (LPVOID) pNewInputDeviceState;
return S_OK;
}

164
Source/Plugins/Plugin_PadDX9/Src/DIHandler.h
View File

@ -1,164 +0,0 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
/////////////////////////////////////////////////////////////////////////////////////////////////////
// M O D U L E B E G I N ///////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma once
// Struct to store the current input state
struct SControllerInput
{
float fMainLR;
float fMainUP;
float fCPadLR;
float fCPadUP;
float fDPadLR;
float fDPadUP;
bool bButtonStart;
bool bButtonA;
bool bButtonB;
bool bButtonX;
bool bButtonY;
bool bButtonZ;
float fTriggerL;
float fTriggerR;
};
class CDIHandler
{
public:
CDIHandler(void);
~CDIHandler(void);
HRESULT InitInput(HWND _hWnd);
void ConfigInput(void);
void CleanupDirectInput(void);
void UpdateInput(void);
const SControllerInput& GetControllerInput(unsigned int _number)
{
return m_controllerInput[_number];
}
private:
enum
{
MAX_AXIS = 127
};
enum INPUT_SEMANTICS
{
// Gameplay semantics
INPUT_MAIN_AXIS_LR=1,
INPUT_MAIN_AXIS_UD,
INPUT_MAIN_LEFT,
INPUT_MAIN_RIGHT,
INPUT_MAIN_UP,
INPUT_MAIN_DOWN,
INPUT_CPAD_AXIS_LR,
INPUT_CPAD_AXIS_UP,
INPUT_CPAD_LEFT,
INPUT_CPAD_RIGHT,
INPUT_CPAD_UP,
INPUT_CPAD_DOWN,
INPUT_DPAD_AXIS_LR,
INPUT_DPAD_AXIS_UP,
INPUT_DPAD_LEFT,
INPUT_DPAD_RIGHT,
INPUT_DPAD_UP,
INPUT_DPAD_DOWN,
INPUT_BUTTON_START,
INPUT_BUTTON_A,
INPUT_BUTTON_B,
INPUT_BUTTON_X,
INPUT_BUTTON_Y,
INPUT_BUTTON_Z,
INPUT_BUTTON_L,
INPUT_BUTTON_R
};
// Struct to store the current input state
struct SUserInput
{
bool bMainLeft;
bool bMainRight;
bool bMainUp;
bool bMainDown;
float fMainLR;
float fMainUP;
bool bCPadLeft;
bool bCPadRight;
bool bCPadUp;
bool bCPadDown;
float fCPadLR;
float fCPadUP;
bool bDPadLeft;
bool bDPadRight;
bool bDPadUp;
bool bDPadDown;
float fDPadLR;
float fDPadUP;
bool bButtonStart;
bool bButtonA;
bool bButtonB;
bool bButtonX;
bool bButtonY;
bool bButtonZ;
bool fTriggerL;
bool fTriggerR;
};
// handle to window that "owns" the DInput
HWND m_hWnd;
static DIACTION m_rgGameAction[];
// DirectInput multiplayer device manager
CMultiplayerInputDeviceManager* m_pInputDeviceManager;
// Action format for game play
DIACTIONFORMAT m_diafGame;
// Struct for storing user input
SControllerInput m_controllerInput[4];
// Number of players in the game
DWORD m_dwNumPlayers;
void CleanupDeviceStateStructs(void);
HRESULT ChangeNumPlayers(DWORD _dwNumPlayers, BOOL _bResetOwnership, BOOL _bResetMappings);
static HRESULT CALLBACK StaticInputAddDeviceCB(CMultiplayerInputDeviceManager::PlayerInfo* _pPlayerInfo,
CMultiplayerInputDeviceManager::DeviceInfo* _pDeviceInfo,
const DIDEVICEINSTANCE* _pdidi,
LPVOID _pParam);
HRESULT InputAddDeviceCB(CMultiplayerInputDeviceManager::PlayerInfo* _pPlayerInfo,
CMultiplayerInputDeviceManager::DeviceInfo* _pDeviceInfo,
const DIDEVICEINSTANCE* _pdidi);
};

155
Source/Plugins/Plugin_PadDX9/Src/IniFile.cpp
View File

@ -1,155 +0,0 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
/////////////////////////////////////////////////////////////////////////////////////////////////////
// M O D U L E B E G I N ///////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "IniFile.h"
/////////////////////////////////////////////////////////////////////////////////////////////////////
// I M P L E M E N T A T I O N //////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
// ________________________________________________________________________________________ __________
// constructor
//
IniFile::IniFile(void)
{
}
// ________________________________________________________________________________________ __________
// destructor
//
IniFile::~IniFile(void)
{
}
// ________________________________________________________________________________________ __________
// SetFile
//
void
IniFile::SetFile(const TCHAR* _filename)
{
if (_filename)
{
char path_buffer[_MAX_PATH], drive[_MAX_DRIVE] ,dir[_MAX_DIR];
char fname[_MAX_FNAME],ext[_MAX_EXT];
GetModuleFileName(NULL,path_buffer,sizeof(path_buffer));
_splitpath( path_buffer, drive, dir, fname, ext );
_makepath( filename, drive, dir, _filename, ".ini");
}
}
// ________________________________________________________________________________________ __________
// SetSection
//
void
IniFile::SetSection(const TCHAR *_section)
{
_tcscpy(section,_section);
}
// ________________________________________________________________________________________ __________
// ReadInt
//
int
IniFile::ReadInt(const TCHAR *key, int def)
{
return GetPrivateProfileInt(section, key, def, filename);
}
// ________________________________________________________________________________________ __________
// WriteInt
//
void
IniFile::WriteInt(const TCHAR *key, int value)
{
char temp[256];
WritePrivateProfileString(section, key, _itoa(value,temp,10), filename);
}
// ________________________________________________________________________________________ __________
// ReadBool
//
bool
IniFile::ReadBool(const TCHAR *key, bool def)
{
return ReadInt(key,def?1:0) == 0 ? false : true;
}
// ________________________________________________________________________________________ __________
// WriteBool
//
void
IniFile::WriteBool(const TCHAR *key, bool value)
{
WriteInt(key,value?1:0);
}
// ________________________________________________________________________________________ __________
// ReadString
//
void
IniFile::ReadString(const TCHAR *key, const TCHAR *def, TCHAR *out, int size)
{
GetPrivateProfileString(section, key, def, out, size, filename);
}
// ________________________________________________________________________________________ __________
// WriteString
//
void
IniFile::WriteString(const TCHAR *key, const TCHAR *value)
{
WritePrivateProfileString(section, key, value, filename);
}
// ________________________________________________________________________________________ __________
// ReadStringList
//
void
IniFile::ReadStringList(const TCHAR *key, std::vector<std::string> &list)
{
int count = ReadInt(key);
for (int i=0; i<count; i++)
{
char temp[256], temp2[256];
sprintf(temp,"%s%i",key,i);
ReadString(temp,"",temp2,256);
list.push_back(std::string(temp2));
}
}
// ________________________________________________________________________________________ __________
// WriteStringList
//
void
IniFile::WriteStringList(const TCHAR *key, std::vector<std::string> &list)
{
WriteInt(key,(int)list.size());
int i=0;
for (std::vector<std::string>::iterator iter = list.begin(); iter!=list.end(); iter++)
{
char temp[256];
sprintf(temp,"%s%i",key,i);
WriteString(temp,iter->c_str());
i++;
}
}

48
Source/Plugins/Plugin_PadDX9/Src/IniFile.h
View File

@ -1,48 +0,0 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
/////////////////////////////////////////////////////////////////////////////////////////////////////
// M O D U L E B E G I N ///////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma once
/////////////////////////////////////////////////////////////////////////////////////////////////////
// C L A S S ////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
class IniFile
{
public:
IniFile(void);
~IniFile(void);
void SetFile(const TCHAR *fname);
void SetSection(const TCHAR *section);
int ReadInt (const TCHAR *key, int def = 0);
void WriteInt (const TCHAR *key, int value);
bool ReadBool (const TCHAR *key, bool def = false);
void WriteBool (const TCHAR *key, bool value);
void ReadString (const TCHAR *key, const TCHAR *def, TCHAR *out, int size = 255);
void WriteString(const TCHAR *key, const TCHAR *value);
void ReadStringList (const TCHAR *key, std::vector<std::string> &list);
void WriteStringList(const TCHAR *key, std::vector<std::string> &list);
private:
TCHAR filename[512];
TCHAR section[256];
};

1053
Source/Plugins/Plugin_PadDX9/Src/MultiDI.cpp
View File

File diff suppressed because it is too large Load Diff

146
Source/Plugins/Plugin_PadDX9/Src/MultiDI.h
View File

@ -1,146 +0,0 @@
//-----------------------------------------------------------------------------
// File: MultiDI.h
//
// Desc: Multiple user DirectInput support using action mapping
//
// Copyright (C) Microsoft Corporation. All Rights Reserved.
//-----------------------------------------------------------------------------
#ifndef MULTIDI_H
#define MULTIDI_H
#ifndef DIRECTINPUT_VERSION
#define DIRECTINPUT_VERSION 0x0800
#endif
#include <dinput.h>
//-----------------------------------------------------------------------------
// Miscellaneous helper functions
//-----------------------------------------------------------------------------
#define SAFE_DELETE(p) { if(p) { delete (p); (p)=NULL; } }
#define SAFE_DELETE_ARRAY(p) { if(p) { delete[] (p); (p)=NULL; } }
#define SAFE_RELEASE(p) { if(p) { (p)->Release(); (p)=NULL; } }
HRESULT DXUtil_WriteStringRegKey( HKEY hKey, LPCTSTR strRegName, LPCTSTR strValue );
HRESULT DXUtil_ReadStringRegKeyCch( HKEY hKey, LPCTSTR strRegName, TCHAR* strDest, DWORD cchDest, LPCTSTR strDefault );
HRESULT DXUtil_ConvertGUIDToStringCch( const GUID* pGuidSrc, TCHAR* strDest, int cchDestChar );
HRESULT DXUtil_ConvertWideStringToGenericCch( TCHAR* tstrDestination, const WCHAR* wstrSource, int cchDestChar );
//-----------------------------------------------------------------------------
// Name: DXUtil_Timer()
// Desc: Performs timer opertations. Use the following commands:
// TIMER_RESET - to reset the timer
// TIMER_START - to start the timer
// TIMER_STOP - to stop (or pause) the timer
// TIMER_ADVANCE - to advance the timer by 0.1 seconds
// TIMER_GETABSOLUTETIME - to get the absolute system time
// TIMER_GETAPPTIME - to get the current time
// TIMER_GETELAPSEDTIME - to get the time that elapsed between
// TIMER_GETELAPSEDTIME calls
//-----------------------------------------------------------------------------
enum TIMER_COMMAND { TIMER_RESET, TIMER_START, TIMER_STOP, TIMER_ADVANCE,
TIMER_GETABSOLUTETIME, TIMER_GETAPPTIME, TIMER_GETELAPSEDTIME };
FLOAT __stdcall DXUtil_Timer( TIMER_COMMAND command );
// E_DIUTILERR_PLAYERWITHOUTDEVICE is returned by the manager class after configuring
// device, and there's a player that hasn't been assigned a device.
#define E_DIUTILERR_PLAYERWITHOUTDEVICE MAKE_HRESULT(SEVERITY_ERROR,FACILITY_ITF,997)
// E_DIUTILERR_DEVICESTAKEN is returned by the manager class when one player
// on the machine has enough RECENT devices to prevent other players from
// playing. This return code is needed because this sample attempts to give
// all RECENT devices to that player.
#define E_DIUTILERR_DEVICESTAKEN MAKE_HRESULT(SEVERITY_ERROR,FACILITY_ITF,998)
// E_DIUTILERR_TOOMANYUSERS is returned by the manager class when the number of
// players exceeds the number of devices present on the system. For example,
// if you ask for 4 players on a machine that only has a keyboard and mouse,
// you're 2 short of what you need.
#define E_DIUTILERR_TOOMANYUSERS MAKE_HRESULT(SEVERITY_ERROR,FACILITY_ITF,999)
//-----------------------------------------------------------------------------
// Name: class CMultiplayerInputDeviceManager
// Desc: Input device manager using DX8 action mapping
//-----------------------------------------------------------------------------
class CMultiplayerInputDeviceManager
{
public:
struct PlayerInfo
{
DWORD dwPlayerIndex; // 0-based player number
TCHAR strPlayerName[MAX_PATH]; // player name
DWORD dwMaxDevices; // max number of elements in pDevices array
DWORD dwNumDevices; // current number of elements in pDevices array
BOOL bFoundDeviceForPlayer; // if a device has been found for this player yet
};
struct DeviceInfo
{
LPDIRECTINPUTDEVICE8 pdidDevice; // dinput device pointer
PlayerInfo* pPlayerInfo; // Player who owns this device
BOOL bRelativeAxis; // TRUE if device is using relative axis
BOOL bMapsPri1Actions; // TRUE if device maps pri 1 actions
BOOL bMapsPri2Actions; // TRUE if device maps pri 2 actions
LPVOID pParam; // app defined pointer assoicated with this device
DIDEVICEINSTANCE didi; // device instance info
};
typedef HRESULT (CALLBACK *LPDIMANAGERCALLBACK)(CMultiplayerInputDeviceManager::PlayerInfo* pPlayerInfo, CMultiplayerInputDeviceManager::DeviceInfo* pDeviceInfo, const DIDEVICEINSTANCE* pdidi, LPVOID);
private:
BOOL m_bCleanupCOM;
HWND m_hWnd;
LPDIRECTINPUT8 m_pDI;
DIACTIONFORMAT* m_pdiaf;
PlayerInfo** m_pUsers;
DWORD m_dwNumUsers;
DeviceInfo* m_pDeviceList;
DWORD m_dwNumDevices;
DWORD m_dwMaxDevices;
LPDIMANAGERCALLBACK m_AddDeviceCallback;
LPVOID m_AddDeviceCallbackParam;
TCHAR* m_strKey;
HKEY m_hKey;
public:
static BOOL CALLBACK StaticEnumSuitableDevicesCB( LPCDIDEVICEINSTANCE pdidi, LPDIRECTINPUTDEVICE8 pdidDevice, DWORD dwFlags, DWORD dwRemainingDevices, VOID* pContext );
static BOOL CALLBACK StaticBuildDeviceListCB( LPCDIDEVICEINSTANCE pdidi, VOID* pContext );
// Device control
BOOL EnumDevice( const DIDEVICEINSTANCE* pdidi, LPDIRECTINPUTDEVICE8 pdidDevice, DWORD dwFlags, DWORD dwDeviceRemaining );
BOOL BuildDeviceListCB( LPCDIDEVICEINSTANCE pdidi );
HRESULT AddDevice( DeviceInfo* pDeviceInfo, BOOL bForceReset );
HRESULT GetDevices( DeviceInfo** ppDeviceInfo, DWORD* pdwNumDevices );
HRESULT ConfigureDevices( HWND hWnd, IUnknown* pSurface, VOID* pCallback, DWORD dwFlags, LPVOID pvCBParam );
DWORD GetNumDevices() { return m_dwNumDevices; }
VOID UnacquireDevices();
VOID SetFocus( HWND hWnd );
PlayerInfo* LookupPlayer( TCHAR* strPlayerName );
HRESULT SaveDeviceOwnershipKeys();
VOID DeleteDeviceOwnershipKeys();
HRESULT UpdateDeviceOwnership();
HRESULT AssignDevices();
HRESULT VerifyAssignment();
HRESULT AddAssignedDevices( BOOL bResetMappings );
HRESULT BuildDeviceList();
VOID CleanupDeviceList();
// Construction
HRESULT SetActionFormat( DIACTIONFORMAT* pdiaf, BOOL bReenumerate, BOOL bResetOwnership, BOOL bResetMappings );
HRESULT Create( HWND hWnd, TCHAR* strUserNames[], DWORD dwNumUsers, DIACTIONFORMAT* pdiaf, LPDIMANAGERCALLBACK AddDeviceCallback, LPVOID pCallbackParam, BOOL bResetOwnership, BOOL bResetMappings );
CMultiplayerInputDeviceManager( TCHAR* strRegKey );
~CMultiplayerInputDeviceManager();
VOID Cleanup();
};
#endif

192
Source/Plugins/Plugin_PadDX9/Src/main.cpp
View File

@ -1,192 +0,0 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
/////////////////////////////////////////////////////////////////////////////////////////////////////
// M O D U L E B E G I N ///////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "resource.h"
#include "PluginSpecs_Pad.h"
#include "IniFile.h"
#include "AboutDlg.h"
#include "ConfigDlg.h"
#include "MultiDI.h"
#include "DIHandler.h"
/////////////////////////////////////////////////////////////////////////////////////////////////////
// T Y P E D E F S / D E F I N E S //////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
HINSTANCE g_hInstance = NULL;
SPADInitialize g_PADInitialize;
CDIHandler g_diHandler;
/////////////////////////////////////////////////////////////////////////////////////////////////////
// I M P L E M E N T A T I O N ////////////////////////// ////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
// ________________________________________________________________________________________ __________
// DllMain
//
BOOL APIENTRY DllMain( HINSTANCE _hinstDLL, // DLL module handle
DWORD dwReason, // reason called
LPVOID _lpvReserved) // reserved
{
switch (dwReason)
{
case DLL_PROCESS_ATTACH:
break;
case DLL_PROCESS_DETACH:
break;
default:
break;
}
g_hInstance = _hinstDLL;
return TRUE;
}
// __________________________________________________________________________________________________
// GetDllInfo
//
void GetDllInfo (PLUGIN_INFO* _PluginInfo)
{
_PluginInfo->Version = 0x0100;
_PluginInfo->Type = PLUGIN_TYPE_PAD;
#ifndef _DEBUG
sprintf_s(_PluginInfo->Name, 100, "Pad DirectX9");
#else
sprintf_s(_PluginInfo->Name, 100, "Pad DirectX9 (Debug)");
#endif
}
// __________________________________________________________________________________________________
// DllAbout
//
void DllAbout(HWND _hParent)
{
CAboutDlg aboutDlg;
aboutDlg.DoModal(_hParent);
}
// __________________________________________________________________________________________________
// DllConfig
//
void DllConfig(HWND _hParent)
{
g_diHandler.InitInput(_hParent);
EnableWindow(_hParent, FALSE);
g_diHandler.ConfigInput();
EnableWindow(_hParent, TRUE);
SetForegroundWindow(_hParent);
g_diHandler.CleanupDirectInput();
}
// __________________________________________________________________________________________________
// PAD_Initialize
//
void PAD_Initialize(SPADInitialize _PADInitialize)
{
g_PADInitialize = _PADInitialize;
g_diHandler.InitInput((HWND)_PADInitialize.hWnd);
}
// __________________________________________________________________________________________________
// PAD_Shutdown
//
void PAD_Shutdown(void)
{
g_diHandler.CleanupDirectInput();
}
// __________________________________________________________________________________________________
// PADGetStatus
//
void PAD_GetStatus(u8 _numPAD, SPADStatus* _pPADStatus)
{
// check if all is okay
if ((_numPAD != 0) || // we support just pad 0
(_pPADStatus == NULL))
return;
#ifdef RECORD_REPLAY
*_pPADStatus = PlayRecord();
return;
#endif
int base = 0x80;
// clear pad
memset(_pPADStatus,0,sizeof(SPADStatus));
_pPADStatus->stickY = base;
_pPADStatus->stickX = base;
_pPADStatus->substickX = base;
_pPADStatus->substickY = base;
_pPADStatus->button |= PAD_USE_ORIGIN;
// just update pad on focus
if (g_PADInitialize.hWnd != ::GetForegroundWindow())
return;
//get keys from dinput
g_diHandler.UpdateInput();
const SControllerInput& rInput = g_diHandler.GetControllerInput(_numPAD);
// int mainvalue = (dinput.diks[keyForControl[CTL_HALFMAIN]] &0xFF) ? 40 : 100;
// int subvalue = (dinput.diks[keyForControl[CTL_HALFSUB]] &0xFF) ? 40 : 100;
// int triggervalue = (dinput.diks[keyForControl[CTL_HALFTRIGGER]]&0xFF) ? 100 : 255;
// get the new keys
if (rInput.bButtonStart) _pPADStatus->button |= PAD_BUTTON_START;
if (rInput.bButtonA) {_pPADStatus->button |= PAD_BUTTON_A; _pPADStatus->analogA = 255;}
if (rInput.bButtonB) {_pPADStatus->button |= PAD_BUTTON_B; _pPADStatus->analogB = 255;}
if (rInput.bButtonX) _pPADStatus->button |= PAD_BUTTON_X;
if (rInput.bButtonY) _pPADStatus->button |= PAD_BUTTON_Y;
if (rInput.bButtonZ) _pPADStatus->button |= PAD_TRIGGER_Z;
if (rInput.fDPadLR < 0) _pPADStatus->button |= PAD_BUTTON_UP;
if (rInput.fDPadLR > 0) _pPADStatus->button |= PAD_BUTTON_DOWN;
if (rInput.fDPadUP < 0) _pPADStatus->button |= PAD_BUTTON_LEFT;
if (rInput.fDPadUP > 0) _pPADStatus->button |= PAD_BUTTON_RIGHT;
if (rInput.fTriggerL > 0) {_pPADStatus->button |= PAD_TRIGGER_L; _pPADStatus->triggerLeft = 255;}
if (rInput.fTriggerR > 0) {_pPADStatus->button |= PAD_TRIGGER_R; _pPADStatus->triggerRight = 255;}
_pPADStatus->stickX = 0x80 + (unsigned __int8)(rInput.fMainLR * 127.f);
_pPADStatus->stickY = 0x80 + (unsigned __int8)(rInput.fMainUP * -127.f);
_pPADStatus->substickX = 0x80 + (unsigned __int8)(rInput.fCPadLR * 127.f);
_pPADStatus->substickY = 0x80 + (unsigned __int8)(rInput.fCPadUP * -127.f);
_pPADStatus->err = PAD_ERR_NONE;
}
// __________________________________________________________________________________________________
// PAD_Rumble
//
void PAD_Rumble(u8 _numPAD, unsigned int _uType, unsigned int _uStrength)
{
}

37
Source/Plugins/Plugin_PadDX9/Src/resource.h
View File

@ -1,37 +0,0 @@
//{{NO_DEPENDENCIES}}
// Microsoft Visual C++ generated include file.
// Used by PadPlugin2.rc
//
#define IDD_PADCONFIG 101
#define IDD_ABOUTPAD 104
#define IDC_SETSTART 1003
#define IDC_SETA 1004
#define IDC_SETB 1005
#define IDC_SETX 1006
#define IDC_SETY 1007
#define IDC_SETZ 1008
#define IDC_SETSUBUP 1009
#define IDC_SETSUBLEFT 1010
#define IDC_SETSUBRIGHT 1011
#define IDC_SETSUBDOWN 1012
#define IDC_SETDPADUP 1013
#define IDC_SETDPADLEFT 1014
#define IDC_SETDPADRIGHT 1015
#define IDC_SETDPADDOWN 1016
#define IDC_SETMAINUP 1017
#define IDC_SETMAINLEFT 1018
#define IDC_SETMAINDOWN 1019
#define IDC_SETMAINRIGHT 1020
#define IDC_SETL 1021
#define IDC_SETR 1022
// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE 105
#define _APS_NEXT_COMMAND_VALUE 40001
#define _APS_NEXT_CONTROL_VALUE 1004
#define _APS_NEXT_SYMED_VALUE 101
#endif
#endif

135
Source/Plugins/Plugin_PadDX9/Src/resource.rc
View File

@ -1,135 +0,0 @@
// Microsoft Visual C++ generated resource script.
//
#include "resource.h"
#define APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 2 resource.
//
#include "afxres.h"
/////////////////////////////////////////////////////////////////////////////
#undef APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
// English (U.S.) resources
#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
#ifdef _WIN32
LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
#pragma code_page(1252)
#endif //_WIN32
#ifdef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// TEXTINCLUDE
//
1 TEXTINCLUDE
BEGIN
"resource.h\0"
END
2 TEXTINCLUDE
BEGIN
"#include ""afxres.h""\r\n"
"\0"
END
3 TEXTINCLUDE
BEGIN
"\r\n"
"\0"
END
#endif // APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Dialog
//
IDD_PADCONFIG DIALOGEX 0, 0, 332, 226
STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION |
WS_SYSMENU
CAPTION "Pad configuration"
FONT 8, "MS Shell Dlg", 400, 0, 0x1
BEGIN
DEFPUSHBUTTON "Close",IDOK,275,205,50,14
PUSHBUTTON "start",IDC_SETSTART,141,102,40,14
PUSHBUTTON "a",IDC_SETA,243,82,40,14
PUSHBUTTON "b",IDC_SETB,215,98,40,14
PUSHBUTTON "x",IDC_SETX,200,71,40,14
PUSHBUTTON "y",IDC_SETY,285,90,40,14
PUSHBUTTON "z",IDC_SETZ,241,35,40,14
PUSHBUTTON " ",IDC_SETSUBUP,235,128,40,14
PUSHBUTTON " ",IDC_SETSUBLEFT,193,147,40,14
PUSHBUTTON " ",IDC_SETSUBRIGHT,275,146,40,14
PUSHBUTTON " ",IDC_SETSUBDOWN,236,167,40,14
PUSHBUTTON " ",IDC_SETDPADUP,66,129,40,14
PUSHBUTTON " ",IDC_SETDPADLEFT,23,145,40,14
PUSHBUTTON " ",IDC_SETDPADRIGHT,112,145,40,14
PUSHBUTTON " ",IDC_SETDPADDOWN,67,166,40,14
PUSHBUTTON " ",IDC_SETMAINUP,41,47,40,14
PUSHBUTTON " ",IDC_SETMAINLEFT,7,66,40,14
PUSHBUTTON " ",IDC_SETMAINDOWN,41,86,40,14
PUSHBUTTON " ",IDC_SETMAINRIGHT,79,66,40,14
PUSHBUTTON "l",IDC_SETL,91,16,40,14
PUSHBUTTON "r",IDC_SETR,216,16,40,14
END
IDD_ABOUTPAD DIALOGEX 0, 0, 184, 76
STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION |
WS_SYSMENU
CAPTION "About Dolphin Simple Pad Plugin"
FONT 8, "MS Shell Dlg", 400, 0, 0x1
BEGIN
DEFPUSHBUTTON "OK",IDOK,127,55,50,14
LTEXT "Coded by F|RES and ector",IDC_STATIC,73,7,104,14
END
/////////////////////////////////////////////////////////////////////////////
//
// DESIGNINFO
//
#ifdef APSTUDIO_INVOKED
GUIDELINES DESIGNINFO
BEGIN
IDD_PADCONFIG, DIALOG
BEGIN
LEFTMARGIN, 7
RIGHTMARGIN, 325
TOPMARGIN, 7
BOTTOMMARGIN, 219
END
IDD_ABOUTPAD, DIALOG
BEGIN
LEFTMARGIN, 7
RIGHTMARGIN, 177
TOPMARGIN, 7
BOTTOMMARGIN, 69
END
END
#endif // APSTUDIO_INVOKED
#endif // English (U.S.) resources
/////////////////////////////////////////////////////////////////////////////
#ifndef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 3 resource.
//
/////////////////////////////////////////////////////////////////////////////
#endif // not APSTUDIO_INVOKED

21
Source/Plugins/Plugin_PadDX9/Src/stdafx.cpp
View File

@ -1,21 +0,0 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
/////////////////////////////////////////////////////////////////////////////////////////////////////
// M O D U L E B E G I N ///////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"

41
Source/Plugins/Plugin_PadDX9/Src/stdafx.h
View File

@ -1,41 +0,0 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
/////////////////////////////////////////////////////////////////////////////////////////////////////
// M O D U L E B E G I N ///////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma once
// Insert your headers here
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
#define _CRT_SECURE_NO_DEPRECATE 1
#include <windows.h>
#include <stdio.h>
#include <tchar.h>
#include <vector>
#include <xstring>
// DInput
#define DIRECTINPUT_VERSION 0x0800
#include <dinput.h>
// WTL
#include <atlbase.h>
#include <atlapp.h>
#include <atldlgs.h>
#include <atlctrls.h>