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

Got rid of all of jp's ////////////////////////////// lines (nearly 500 of them)! 

Yes, I used a script :D

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4169 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
Marcus Wanners 2009-09-02 21:00:45 +00:00
parent c64b1ca5dc
commit 50593397f3
81 changed files with 1049 additions and 1049 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Source/Core/Core/Src/Boot/Boot.cpp
View File

@ -137,7 +137,7 @@ bool CBoot::LoadMapFromFilename(const std::string &_rFilename, const char *_game
}
//////////////////////////////////////////////////////////////////////////////////////////
// Load a GC or Wii BIOS file
bool CBoot::Load_BIOS(const std::string& _rBiosFilename)
{
@ -150,7 +150,7 @@ bool CBoot::Load_BIOS(const std::string& _rBiosFilename)
return true;
}
//////////////////////////////////////////////////////////////////////////////////////////
// Third boot step after BootManager and Core. See Call schedule in BootManager.cpp
bool CBoot::BootUp()
{

2
Source/Core/Core/Src/Boot/ElfTypes.h
View File

@ -60,7 +60,7 @@ enum ElfMachine
#define ELFDATA2MSB 2
/////////////////////
// Sections constants
// Section indexes

22
Source/Core/Core/Src/CoreRerecording.cpp
View File

@ -20,7 +20,7 @@
#ifdef RERECORDING
//////////////////////////////////////////////////////////////////////////////////////////
// Include
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯
#ifdef _WIN32
@ -60,11 +60,11 @@
#include "MemTools.h"
#include "Host.h"
#include "LogManager.h"
////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
// File description: Rerecording Functions
/* ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
@ -83,16 +83,16 @@ namespace Core
{
///////////////////////////////////////////////////////////////////////////////////////////
// Declarations and definitions
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
int g_FrameCounter = 0;
bool g_FrameStep = false;
Common::Timer ReRecTimer;
////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
// Control Run, Pause, Stop and the Timer.
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
@ -160,10 +160,10 @@ void WindBack(int Counter)
// Logging
DEBUG_LOG(CONSOLE, "WindBack: %i %u\n", Counter, (u64)CurrentTimeSeconds);
}
////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
// Frame advance
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
void FrameAdvance()
@ -202,10 +202,10 @@ void FrameStepOnOff()
Core::SetState(Core::CORE_RUN);
}
}
////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
// General functions
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
@ -240,7 +240,7 @@ void FrameUpdate()
// Count one frame
g_FrameCounter++;
}
////////////////////////////////////////
} // Core

12
Source/Core/Core/Src/DolLoader.h
View File

@ -14,17 +14,17 @@
// 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 ///////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
// M O D U L E B E G I N
#pragma once
#include "Common.h"
/////////////////////////////////////////////////////////////////////////////////////////////////////
// C L A S S/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
// C L A S S
class CDolLoader
{

14
Source/Core/Core/Src/HW/EXI_Device.cpp
View File

@ -27,9 +27,9 @@
#include "../Core.h"
#include "../ConfigManager.h"
//////////////////////////////////////////////////////////////////////////
// --- interface IEXIDevice ---
//////////////////////////////////////////////////////////////////////////
void IEXIDevice::ImmWrite(u32 _uData, u32 _uSize)
{
while (_uSize--)
@ -74,9 +74,9 @@ void IEXIDevice::DMARead(u32 _uAddr, u32 _uSize)
}
};
//////////////////////////////////////////////////////////////////////////
// --- class CEXIDummy ---
//////////////////////////////////////////////////////////////////////////
// Just a dummy that logs reads and writes
// to be used for EXI devices we haven't emulated
class CEXIDummy : public IEXIDevice
@ -99,9 +99,9 @@ public:
void DMARead (u32 addr, u32 size) {INFO_LOG(EXPANSIONINTERFACE, "EXI DUMMY %s DMARead: %08x bytes, from device to %08x", m_strName.c_str(), size, addr);}
};
//////////////////////////////////////////////////////////////////////////
// F A C T O R Y /////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// F A C T O R Y
IEXIDevice* EXIDevice_Create(TEXIDevices _EXIDevice)
{

6
Source/Core/Core/Src/HW/EXI_DeviceMic.cpp
View File

@ -41,7 +41,7 @@ void CEXIMic::TransferByte(u8 &byte){}
bool CEXIMic::IsInterruptSet(){return false;}
#else
//////////////////////////////////////////////////////////////////////////
// We use PortAudio for cross-platform audio input.
// It needs the headers and a lib file for the dll
#include <portaudio.h>
@ -95,9 +95,9 @@ int patestCallback( const void *inputBuffer, void *outputBuffer,
return paContinue;
}
//////////////////////////////////////////////////////////////////////////
// EXI Mic Device
//////////////////////////////////////////////////////////////////////////
CEXIMic::CEXIMic(int _Index)
{
Index = _Index;

22
Source/Core/Core/Src/HW/Memmap.cpp
View File

@ -47,10 +47,10 @@ may be redirected here (for example to Read_U32()).
#include "WII_IPC.h"
#include "../ConfigManager.h"
#include "../Debugger/Debugger_SymbolMap.h"
/////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
// Declarations and definitions
// ----------------
namespace Memory
@ -122,10 +122,10 @@ readFn32 hwReadWii32[NUMHWMEMFUN];
readFn64 hwReadWii64[NUMHWMEMFUN];
// ===============
/////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
// Default read and write functions
// ----------------
u32 CheckDTLB(u32 _Address, XCheckTLBFlag _Flag);
@ -143,10 +143,10 @@ void HW_Default_Read(T _Data, const u32 _Address){ ERROR_LOG(MASTER_LOG, "Illega
template <class T, u8* P> void HW_Read_Memory(T &_Data, const u32 _Address) { _Data = *(T*)&P[_Address & PAGE_MASK]; }
template <class T, u8* P> void HW_Write_Memory(T _Data, const u32 _Address) { *(T*)&P[_Address & PAGE_MASK] = _Data; }
/////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/* Create shortcuts to the hardware devices' read and write functions. This can be seen
as an alternative to a switch() or if() table. */
// ----------------
@ -327,11 +327,11 @@ writeFn32 GetHWWriteFun32(const u32 _Address)
{
return hwWrite32[(_Address >> HWSHIFT) & (NUMHWMEMFUN-1)];
}
/////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
// Init and Shutdown
// ----------------
bool IsInitialized()
@ -537,7 +537,7 @@ u32 Read_Instruction(const u32 em_address)
return inst.hex;
}
//////////////////////////////////////////////////////////
@ -677,7 +677,7 @@ void CheckForBadAddresses64(u32 Address, u64 Data, bool Read)
///////////////////////////////////////////////////////////////////////////////////
// Other functions
// ----------------
void WriteBigEData(const u8 *_pData, const u32 _Address, const u32 _iSize)
@ -857,7 +857,7 @@ bool IsRAMAddress(const u32 addr, bool allow_locked_cache)
return false;
}
}
/////////////////////////////
} // namespace

4
Source/Core/Core/Src/HW/MemmapFunctions.cpp
View File

@ -84,7 +84,7 @@ inline u32 bswap(u32 val) {return Common::swap32(val);}
inline u64 bswap(u64 val) {return Common::swap64(val);}
// =================
///////////////////////////////////////////////////////////////////////////////////
// Read and write
// ----------------
// The read and write macros that direct us to the right functions
@ -452,7 +452,7 @@ void WriteUnchecked_U32(const u32 _iValue, const u32 _Address)
}
// =====================
//////////////////////////////////////////////////////////

16
Source/Core/Core/Src/HW/SI.cpp
View File

@ -275,9 +275,9 @@ void Read32(u32& _uReturnValue, const u32 _iAddress)
// registers
switch (_iAddress & 0x3FF)
{
//////////////////////////////////////////////////////////////////////////
// Channel 0
//////////////////////////////////////////////////////////////////////////
case SI_CHANNEL_0_OUT:
_uReturnValue = g_Channel[0].m_Out.Hex;
return;
@ -294,9 +294,9 @@ void Read32(u32& _uReturnValue, const u32 _iAddress)
_uReturnValue = g_Channel[0].m_InLo.Hex;
return;
//////////////////////////////////////////////////////////////////////////
// Channel 1
//////////////////////////////////////////////////////////////////////////
case SI_CHANNEL_1_OUT:
_uReturnValue = g_Channel[1].m_Out.Hex;
return;
@ -313,9 +313,9 @@ void Read32(u32& _uReturnValue, const u32 _iAddress)
_uReturnValue = g_Channel[1].m_InLo.Hex;
return;
//////////////////////////////////////////////////////////////////////////
// Channel 2
//////////////////////////////////////////////////////////////////////////
case SI_CHANNEL_2_OUT:
_uReturnValue = g_Channel[2].m_Out.Hex;
return;
@ -332,9 +332,9 @@ void Read32(u32& _uReturnValue, const u32 _iAddress)
_uReturnValue = g_Channel[2].m_InLo.Hex;
return;
//////////////////////////////////////////////////////////////////////////
// Channel 3
//////////////////////////////////////////////////////////////////////////
case SI_CHANNEL_3_OUT:
_uReturnValue = g_Channel[3].m_Out.Hex;
return;

14
Source/Core/Core/Src/HW/SI_Device.cpp
View File

@ -19,9 +19,9 @@
#include "SI_DeviceGCController.h"
#include "SI_DeviceGBA.h"
//////////////////////////////////////////////////////////////////////////
// --- interface ISIDevice ---
//////////////////////////////////////////////////////////////////////////
int ISIDevice::RunBuffer(u8* _pBuffer, int _iLength)
{
#ifdef _DEBUG
@ -47,9 +47,9 @@ int ISIDevice::RunBuffer(u8* _pBuffer, int _iLength)
return 0;
};
//////////////////////////////////////////////////////////////////////////
// --- class CSIDummy ---
//////////////////////////////////////////////////////////////////////////
// Just a dummy that logs reads and writes
// to be used for SI devices we haven't emulated
// and hopefully as an "emtpy" device
@ -75,9 +75,9 @@ public:
void SendCommand(u32 _Cmd, u8 _Poll){INFO_LOG(SERIALINTERFACE, "SI DUMMY %i SendCommand: %08x", this->m_iDeviceNumber, _Cmd);}
};
//////////////////////////////////////////////////////////////////////////
// F A C T O R Y /////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// F A C T O R Y
ISIDevice* SIDevice_Create(TSIDevices _SIDevice, int _iDeviceNumber)
{

12
Source/Core/Core/Src/HW/SI_DeviceGBA.cpp
View File

@ -19,9 +19,9 @@
#include "SI_DeviceGBA.h"
#include "GBAPipe.h"
//////////////////////////////////////////////////////////////////////////
// --- GameBoy Advance ---
//////////////////////////////////////////////////////////////////////////
CSIDevice_GBA::CSIDevice_GBA(int _iDeviceNumber) :
ISIDevice(_iDeviceNumber)
@ -130,9 +130,9 @@ int CSIDevice_GBA::RunBuffer(u8* _pBuffer, int _iLength)
return iPosition;
}
//////////////////////////////////////////////////////////////////////////
// GetData
//////////////////////////////////////////////////////////////////////////
bool
CSIDevice_GBA::GetData(u32& _Hi, u32& _Low)
{
@ -141,9 +141,9 @@ CSIDevice_GBA::GetData(u32& _Hi, u32& _Low)
return true;
}
//////////////////////////////////////////////////////////////////////////
// SendCommand
//////////////////////////////////////////////////////////////////////////
void
CSIDevice_GBA::SendCommand(u32 _Cmd, u8 _Poll)
{

8
Source/Core/Core/Src/HW/SI_DeviceGBA.h
View File

@ -18,9 +18,9 @@
#ifndef _SI_DEVICEGBA_H
#define _SI_DEVICEGBA_H
//////////////////////////////////////////////////////////////////////////
// GameBoy Advance
//////////////////////////////////////////////////////////////////////////
class CSIDevice_GBA : public ISIDevice
{
@ -51,9 +51,9 @@ private:
};
};
FAKE_JOYSTAT js;
//////////////////////////////////////////////////////////////////////////
//0x4000158 - JOYSTAT - Receive Status Register (R/W) (ON THE GBA)
//////////////////////////////////////////////////////////////////////////
// NOTE: there is a typo in GBATEK!
// in the JOY BUS command descriptions, SIOSTAT==JOYSTAT
//Bit Expl.

12
Source/Core/Core/Src/HW/SI_DeviceGCController.cpp
View File

@ -27,9 +27,9 @@
#include "../OnFrame.h"
//////////////////////////////////////////////////////////////////////////
// --- standard gamecube controller ---
//////////////////////////////////////////////////////////////////////////
CSIDevice_GCController::CSIDevice_GCController(int _iDeviceNumber) :
ISIDevice(_iDeviceNumber)
@ -117,9 +117,9 @@ int CSIDevice_GCController::RunBuffer(u8* _pBuffer, int _iLength)
return iPosition;
}
//////////////////////////////////////////////////////////////////////////
// GetData
//////////////////////////////////////////////////////////////////////////
// Return true on new data (max 7 Bytes and 6 bits ;)
// [00?SYXBA] [1LRZUDRL] [x] [y] [cx] [cy] [l] [r]
// |\_ ERR_LATCH (error latched - check SISR)
@ -219,9 +219,9 @@ CSIDevice_GCController::GetData(u32& _Hi, u32& _Low)
return true;
}
//////////////////////////////////////////////////////////////////////////
// SendCommand
//////////////////////////////////////////////////////////////////////////
void
CSIDevice_GCController::SendCommand(u32 _Cmd, u8 _Poll)
{

4
Source/Core/Core/Src/HW/SI_DeviceGCController.h
View File

@ -21,9 +21,9 @@
#include "../PluginManager.h"
#include "SI_Device.h"
//////////////////////////////////////////////////////////////////////////
// standard gamecube controller
//////////////////////////////////////////////////////////////////////////
class CSIDevice_GCController : public ISIDevice
{

10
Source/Core/Core/Src/HW/SystemTimers.cpp
View File

@ -16,7 +16,7 @@
// http://code.google.com/p/dolphin-emu/
/////////////////////////////////////////////////////////////////////////////
// File description: This file controls all system timers
/* -------------
"Time" is measured in frames, not time: These update frequencies are determined by the passage
@ -57,7 +57,7 @@
//////////////////////////*/
/////////////////////////////////////////////////////////////////////////////
// Inlude
// -------------
#include "Common.h"
@ -77,12 +77,12 @@
#include "Thread.h"
#include "Timer.h"
/////////////////////////////
namespace SystemTimers
{
/////////////////////////////////////////////////////////////////////////////
// Declarations and definitions
// -------------
u32 CPU_CORE_CLOCK = 486000000u; // 486 mhz (its not 485, stop bugging me!)
@ -131,7 +131,7 @@ int
// TODO: make it VI output frame rate compliant (30/60 and 25/50)
// Assuming game's frame-finish-watchdog wait more than 4 emulated frame-period before starting its mess.
FAKE_GP_WATCHDOG_PERIOD;
///////////////////////////////////
u32 GetTicksPerSecond()

32
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_usb.cpp
View File

@ -16,7 +16,7 @@
// http://code.google.com/p/dolphin-emu/
//////////////////////////////////////////////////////////////////////////
// Include
#include "../Core.h" // Local core functions
#include "../Debugger/Debugger_SymbolMap.h"
@ -30,7 +30,7 @@ int g_HCICount = 0;
int g_GlobalHandle = 0;
//////////////////////////////////////////////////////////////////////////
// The device class
CWII_IPC_HLE_Device_usb_oh1_57e_305::CWII_IPC_HLE_Device_usb_oh1_57e_305(u32 _DeviceID, const std::string& _rDeviceName)
: IWII_IPC_HLE_Device(_DeviceID, _rDeviceName)
@ -436,13 +436,13 @@ u32 CWII_IPC_HLE_Device_usb_oh1_57e_305::Update()
}
////////////////////////////////////////////////////////////////////////////////////////////////////
// Events
// -----------------
// This is messages send from the Wiimote to the game, for example RequestConnection()
// or ConnectionComplete().
//
////////////////////////////////////////////////////////////////////////////////////////////////////
void CWII_IPC_HLE_Device_usb_oh1_57e_305::AddEventToQueue(const SQueuedEvent& _event)
{
@ -588,7 +588,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRemoteNameReq(bdaddr_t _bd)
}
/////////////////////////////////////////////////////////////
/* This is called from Update() after ScanEnable has been enabled. */
// ØØØØØØØØØ
bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestConnection(CWII_IPC_HLE_WiiMote& _rWiiMote)
@ -631,7 +631,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestConnection(CWII_IPC_HL
return true;
};
//////////////////////////////
bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestLinkKey(bdaddr_t _bd)
@ -991,13 +991,13 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventDisconnect(u16 _connectionHan
}
////////////////////////////////////////////////////////////////////////////////////////////////////
// Command dispacther
// -----------------
// This is called from the USB_IOCTL_HCI_COMMAND_MESSAGE Ioctlv
//
//
////////////////////////////////////////////////////////////////////////////////////////////////////
void CWII_IPC_HLE_Device_usb_oh1_57e_305::ExecuteHCICommandMessage(const SHCICommandMessage& _rHCICommandMessage)
{
@ -1182,13 +1182,13 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::ExecuteHCICommandMessage(const SHCICom
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
//
//
// --- command helper
//
//
////////////////////////////////////////////////////////////////////////////////////////////////////
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandReset(u8* _Input)
{
@ -1427,7 +1427,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWritePageTimeOut(u8* _Input)
}
/////////////////////////////////////////////////////////////
/* This will enable ScanEnable so that Update() can start the Wiimote. */
// ØØØØØØØØØ
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteScanEnable(u8* _Input)
@ -1456,7 +1456,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteScanEnable(u8* _Input)
SendEventCommandComplete(HCI_CMD_WRITE_SCAN_ENABLE, &Reply, sizeof(hci_write_scan_enable_rp));
}
/////////////////////////////
void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteInquiryMode(u8* _Input)
@ -1907,13 +1907,13 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandLinkKeyRep(u8* _Input)
////////////////////////////////////////////////////////////////////////////////////////////////////
//
//
// --- helper
//
//
////////////////////////////////////////////////////////////////////////////////////////////////////
CWII_IPC_HLE_WiiMote* CWII_IPC_HLE_Device_usb_oh1_57e_305::AccessWiiMote(const bdaddr_t& _rAddr)
{
@ -1951,11 +1951,11 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::LOG_LinkKey(const u8* _pLinkKey)
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// CWII_IPC_HLE_Device_usb_oh0
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CWII_IPC_HLE_Device_usb_oh0::CWII_IPC_HLE_Device_usb_oh0(u32 _DeviceID, const std::string& _rDeviceName)

28
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_WiiMote.cpp
View File

@ -77,7 +77,7 @@ CWII_IPC_HLE_WiiMote::CWII_IPC_HLE_WiiMote(CWII_IPC_HLE_Device_usb_oh1_57e_305*
memset(m_LinkKey, 0xA0 + _Number, 16);
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
//
//
@ -88,7 +88,7 @@ CWII_IPC_HLE_WiiMote::CWII_IPC_HLE_WiiMote(CWII_IPC_HLE_Device_usb_oh1_57e_305*
//
//
//
/////////////////////////////////////////////////////////////////////////////////////////////////
bool CWII_IPC_HLE_WiiMote::Update()
{
@ -149,7 +149,7 @@ bool CWII_IPC_HLE_WiiMote::Update()
return false;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
//
//
@ -160,7 +160,7 @@ bool CWII_IPC_HLE_WiiMote::Update()
//
//
//
/////////////////////////////////////////////////////////////////////////////////////////////////
void CWII_IPC_HLE_WiiMote::EventConnectionAccepted()
{
@ -197,7 +197,7 @@ void CWII_IPC_HLE_WiiMote::EventCommandWriteLinkPolicy()
m_HIDInterruptChannel_ConfigWait = false;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
//
//
@ -208,7 +208,7 @@ void CWII_IPC_HLE_WiiMote::EventCommandWriteLinkPolicy()
//
//
//
/////////////////////////////////////////////////////////////////////////////////////////////////
// ===================================================
@ -390,7 +390,7 @@ void CWII_IPC_HLE_WiiMote::SignalChannel(u8* _pData, u32 _Size)
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
//
//
@ -401,7 +401,7 @@ void CWII_IPC_HLE_WiiMote::SignalChannel(u8* _pData, u32 _Size)
//
//
//
/////////////////////////////////////////////////////////////////////////////////////////////////
void CWII_IPC_HLE_WiiMote::CommandConnectionReq(u8 _Ident, u8* _pData, u32 _Size)
@ -576,7 +576,7 @@ void CWII_IPC_HLE_WiiMote::CommandDisconnectionReq(u8 _Ident, u8* _pData, u32 _S
SendCommandToACL(_Ident, L2CAP_DISCONN_RSP, sizeof(SL2CAP_CommandDisconnectionResponse), (u8*)&Rsp);
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
//
//
@ -587,7 +587,7 @@ void CWII_IPC_HLE_WiiMote::CommandDisconnectionReq(u8 _Ident, u8* _pData, u32 _S
//
//
//
/////////////////////////////////////////////////////////////////////////////////////////////////
void CWII_IPC_HLE_WiiMote::SendConnectionRequest(u16 scid, u16 psm)
@ -669,7 +669,7 @@ void CWII_IPC_HLE_WiiMote::SendConfigurationRequest(u16 scid, u16* MTU, u16* Flu
SendCommandToACL(L2CAP_CONF_REQ, L2CAP_CONF_REQ, Offset, Buffer);
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
//
//
@ -680,7 +680,7 @@ void CWII_IPC_HLE_WiiMote::SendConfigurationRequest(u16 scid, u16* MTU, u16* Flu
//
//
//
/////////////////////////////////////////////////////////////////////////////////////////////////
#define SDP_UINT8 0x08
#define SDP_UINT16 0x09
@ -855,7 +855,7 @@ void CWII_IPC_HLE_WiiMote::HandleSDP(u16 cid, u8* _pData, u32 _Size)
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
//
//
@ -866,7 +866,7 @@ void CWII_IPC_HLE_WiiMote::HandleSDP(u16 cid, u8* _pData, u32 _Size)
//
//
//
/////////////////////////////////////////////////////////////////////////////////////////////////
void CWII_IPC_HLE_WiiMote::SendCommandToACL(u8 _Ident, u8 _Code, u8 _CommandLength, u8* _pCommandData)

4
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_WiiMote.h
View File

@ -188,7 +188,7 @@ public:
virtual ~CWII_IPC_HLE_WiiMote()
{}
//////////////////////////////////////////////////////////////
// ugly Host handling....
// we really have to clean all this code
@ -292,7 +292,7 @@ private:
void CommandConfigurationResponse(u8 _Ident, u8* _pData, u32 _Size);
//////////////////
// some new ugly stuff
//
// should be inside the plugin

26
Source/Core/Core/Src/PluginManager.cpp
View File

@ -16,7 +16,7 @@
// http://code.google.com/p/dolphin-emu/
//////////////////////////////////////////////////////////////////////////////////////////
// File description
/* ¯¯¯¯¯¯¯¯¯¯¯¯
@ -25,7 +25,7 @@
created once when Dolphin starts and is closed when Dolphin is closed.
*/
//////////////////////////////////////////////////////////////////////////////////////////
// Include
// ¯¯¯¯¯¯¯¯¯¯¯¯
#include <string> // System
@ -44,10 +44,10 @@
// Create the plugin manager class
CPluginManager CPluginManager::m_Instance;
/////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// The Plugin Manager Class
// ¯¯¯¯¯¯¯¯¯¯¯¯
@ -96,10 +96,10 @@ CPluginManager::~CPluginManager()
delete m_video;
}
//////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Init and Shutdown Plugins
// ¯¯¯¯¯¯¯¯¯¯¯¯
// Function: Point the m_pad[] and other variables to a certain plugin
@ -200,7 +200,7 @@ void CPluginManager::ShutdownVideoPlugin()
}
////////////////////////////////////////////////////////////////////////////////
// The PluginInfo class: Find Valid Plugins
// ¯¯¯¯¯¯¯¯¯¯¯¯
/* Function: This info is used in ScanForPlugins() to check for valid plugins and and in LoadPlugin() to
@ -229,10 +229,10 @@ CPluginInfo::CPluginInfo(const char *_rFilename)
WARN_LOG(CONSOLE, "PluginInfo: %s is not a valid Dolphin plugin. Ignoring.", _rFilename);
}
}
///////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Supporting functions
// ¯¯¯¯¯¯¯¯¯¯¯¯
@ -369,10 +369,10 @@ void CPluginManager::ScanForPlugins()
}
}
}
/////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
/* Create or return the already created plugin pointers. This will be called
often for the Pad and Wiimote from the SI_.cpp files. And often for the DSP
from the DSP files.
@ -469,10 +469,10 @@ void CPluginManager::FreeWiimote(u32 Wiimote)
m_wiimote[Wiimote] = NULL;
}
}
///////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Call DLL functions
// ¯¯¯¯¯¯¯¯¯¯¯¯

12
Source/Core/Core/Src/PowerPC/Gekko.h
View File

@ -22,9 +22,9 @@
#include "Common.h"
/////////////////////////////////////////////////////////////////////////////////////////////////////
// --- Gekko Instruction ---
//////////////////////////////////////////////////////////////////////////////////////////////////////
union UGeckoInstruction
{
@ -265,11 +265,11 @@ union UGeckoInstruction
};
};
/////////////////////////////////////////////////////////////////////////////////////////////////////
//
// --- Gekko Special Registers ---
//
//////////////////////////////////////////////////////////////////////////////////////////////////////
// GQR Register
union UGQR
@ -531,11 +531,11 @@ union UReg_PTE
u32 Hex32[2];
};
/////////////////////////////////////////////////////////////////////////////////////////////////////
//
// --- Gekko Types and Defs ---
//
//////////////////////////////////////////////////////////////////////////////////////////////////////
// quantize types
enum EQuantizeType

56
Source/Core/Core/Src/PowerPC/Interpreter/Interpreter_Tables.h
View File

@ -1,28 +1,28 @@
// Copyright (C) 2003 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/
#ifndef INTERPRETER_TABLES_H
#define INTERPRETER_TABLES_H
#include "../Gekko.h"
#include "../PPCTables.h"
#include "Interpreter.h"
namespace InterpreterTables
{
void InitTables();
}
#endif
// Copyright (C) 2003 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/
#ifndef INTERPRETER_TABLES_H
#define INTERPRETER_TABLES_H
#include "../Gekko.h"
#include "../PPCTables.h"
#include "Interpreter.h"
namespace InterpreterTables
{
void InitTables();
}
#endif

12
Source/Core/Core/Src/PowerPC/Jit64/Jit.h
View File

@ -28,14 +28,14 @@
// * If flag available, branch code can become absolutely trivial.
//////////////////////////////////////////////////////////////////////////////////////////
// Settings
// ¯¯¯¯¯¯¯¯¯¯
#define JIT_OFF_OPTIONS // Compile with JIT off options
////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Include
// ¯¯¯¯¯¯¯¯¯¯
#if JITTEST
@ -54,10 +54,10 @@
#ifdef _WIN32
#include <windows.h>
#endif
///////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Declarations and definitions
// ¯¯¯¯¯¯¯¯¯¯
@ -84,7 +84,7 @@ void Jit(u32 em_address);
// #define INSTRUCTION_START Default(inst); return;
// #define INSTRUCTION_START PPCTables::CountInstruction(inst);
#define INSTRUCTION_START
///////////////////////////////////
class TrampolineCache : public Gen::XCodeBlock

1030
Source/Core/Core/Src/PowerPC/JitCommon/Jit_Tables.cpp
View File

File diff suppressed because it is too large Load Diff

68
Source/Core/Core/Src/PowerPC/JitCommon/Jit_Tables.h
View File

@ -1,34 +1,34 @@
// Copyright (C) 2003 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/
#ifndef JIT_TABLES_H
#define JIT_TABLES_H
#include "../Gekko.h"
#include "../PPCTables.h"
#if defined JITTEST && JITTEST
#include "../Jit64IL/Jit.h"
#else
#include "../Jit64/Jit.h"
#endif
namespace JitTables
{
void CompileInstruction(UGeckoInstruction _inst);
void InitTables();
}
#endif
// Copyright (C) 2003 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/
#ifndef JIT_TABLES_H
#define JIT_TABLES_H
#include "../Gekko.h"
#include "../PPCTables.h"
#if defined JITTEST && JITTEST
#include "../Jit64IL/Jit.h"
#else
#include "../Jit64/Jit.h"
#endif
namespace JitTables
{
void CompileInstruction(UGeckoInstruction _inst);
void InitTables();
}
#endif

4
Source/Core/Core/Src/State.cpp
View File

@ -32,9 +32,9 @@
#include "minilzo.h"
///////////
// TODO: Investigate a memory leak on save/load state
///////////
#if defined(__LZO_STRICT_16BIT)
#define IN_LEN (8*1024u)

8
Source/Core/DebuggerWX/Src/BreakpointWindow.cpp
View File

@ -176,7 +176,7 @@ void CBreakPointWindow::OnActivated(wxListEvent& event)
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Breakpoint actions
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
@ -227,10 +227,10 @@ void CBreakPointWindow::OnAddBreakPointMany(wxCommandEvent& event)
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Memory check actions
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
void
@ -327,4 +327,4 @@ void CBreakPointWindow::OnAddMemoryCheckMany(wxCommandEvent& event)
wxMessageBox(_T("You have no ") T_FULL_GAMECONFIG_DIR _T("MemoryChecks.ini file"));
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////

20
Source/Core/DebuggerWX/Src/CodeWindow.cpp
View File

@ -74,7 +74,7 @@ class CPluginInfo;
class CPluginManager;
/////////////////////////////////////////////////////////////////////////////////////////////////////
// Main
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
BEGIN_EVENT_TABLE(CCodeWindow, wxPanel)
@ -187,10 +187,10 @@ wxAuiToolBar *CCodeWindow::GetToolBar()
{
return Parent->m_ToolBarDebug;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Events
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
void CCodeWindow::OnKeyDown(wxKeyEvent& event)
@ -414,7 +414,7 @@ void CCodeWindow::UpdateCallstack()
callstack->Append(wxString::FromAscii("invalid callstack"));
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Load these settings before CreateGUIControls()
@ -538,7 +538,7 @@ void CCodeWindow::CreateGUIControls(const SCoreStartupParameter& _LocalCoreStart
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
// Menus
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Create CPU Mode and Views menus
@ -721,10 +721,10 @@ void CCodeWindow::OnJitMenu(wxCommandEvent& event)
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Toolbar
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
void CCodeWindow::InitBitmaps()
@ -766,10 +766,10 @@ void CCodeWindow::PopulateToolbar(wxAuiToolBar* toolBar)
// the changes
toolBar->Realize();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Update GUI
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
@ -916,4 +916,4 @@ void CCodeWindow::OnStatusBar_(wxUpdateUIEvent& event)
//if(event.GetId() != IDM_ADDRBOX) DoTip(wxEmptyString);
#endif
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////

12
Source/Core/DebuggerWX/Src/CodeWindowFunctions.cpp
View File

@ -17,7 +17,7 @@
//////////////////////////////////////////////////////////////////////////////////////////
// Include
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯
#include "Common.h"
@ -76,10 +76,10 @@ extern "C" // Bitmaps
#include "../resources/toolbar_delete.c"
#include "../resources/toolbar_add_breakpoint.c"
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Symbols, JIT, Profiler
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
void CCodeWindow::CreateSymbolsMenu()
@ -318,10 +318,10 @@ void CCodeWindow::OnChangeFont(wxCommandEvent& event)
if ( dialog.ShowModal() == wxID_OK )
DebuggerFont = dialog.GetFontData().GetChosenFont();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Toogle windows
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
@ -538,4 +538,4 @@ void CCodeWindow::OnToggleVideoWindow(bool _show, int i)
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////

2
Source/Core/DiscIO/Src/NANDContentLoader.cpp
View File

@ -215,7 +215,7 @@ bool CNANDContentLoader::CreateFromDirectory(const std::string& _rPath)
memcpy(m_TicketView, pTMD + 0x180, TICKET_VIEW_SIZE);
memcpy(m_TmdHeader, pTMD, TMD_HEADER_SIZE);
//////
m_TileVersion = Common::swap16(pTMD + 0x01dc);
m_numEntries = Common::swap16(pTMD + 0x01de);
m_BootIndex = Common::swap16(pTMD + 0x01e0);

8
Source/Core/DolphinWX/Src/BootManager.cpp
View File

@ -38,7 +38,7 @@
///////////////////////////////////////////////////////////////////////////////////
// Includes
// ----------------
#include <string>
@ -71,10 +71,10 @@ namespace BootManager
#ifdef _WIN32
extern "C" HINSTANCE wxGetInstance();
#endif
/////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
// Boot the ISO or file
// ----------------
bool BootCore(const std::string& _rFilename)
@ -207,7 +207,7 @@ void Stop()
{
Core::Stop();
}
/////////////////////////////////
} // namespace

26
Source/Core/DolphinWX/Src/ConfigMain.cpp
View File

@ -126,7 +126,7 @@ CConfigMain::~CConfigMain()
{
}
//////////////////////////////////////////////////////////////////////////
// Used to restrict changing of some options while emulator is running
void CConfigMain::UpdateGUI()
{
@ -203,7 +203,7 @@ void CConfigMain::CreateGUIControls()
Notebook->AddPage(PluginPage, wxT("Plugins"));
//////////////////////////////////////////////////////////////////////////
// General page
// Core Settings - Basic
@ -347,7 +347,7 @@ void CConfigMain::CreateGUIControls()
sGeneralPage->Layout();
//////////////////////////////////////////////////////////////////////////
// Gamecube page
// IPL settings
sbGamecubeIPLSettings = new wxStaticBoxSizer(wxVERTICAL, GamecubePage, wxT("IPL Settings"));
@ -438,7 +438,7 @@ void CConfigMain::CreateGUIControls()
sGamecube->Layout();
//////////////////////////////////////////////////////////////////////////
// Wii page
sbWiimoteSettings = new wxStaticBoxSizer(wxVERTICAL, WiiPage, wxT("Wiimote Settings"));
arrayStringFor_WiiSensBarPos.Add(wxT("Bottom")); arrayStringFor_WiiSensBarPos.Add(wxT("Top"));
@ -483,7 +483,7 @@ void CConfigMain::CreateGUIControls()
sWii->Layout();
//////////////////////////////////////////////////////////////////////////
// Paths page
sbISOPaths = new wxStaticBoxSizer(wxVERTICAL, PathsPage, wxT("ISO Directories"));
ISOPaths = new wxListBox(PathsPage, ID_ISOPATHS, wxDefaultPosition, wxDefaultSize, arrayStringFor_ISOPaths, wxLB_SINGLE, wxDefaultValidator);
@ -524,7 +524,7 @@ void CConfigMain::CreateGUIControls()
PathsPage->SetSizer(sPaths);
sPaths->Layout();
//////////////////////////////////////////////////////////////////////////
// Plugins page
sbGraphicsPlugin = new wxStaticBoxSizer(wxHORIZONTAL, PluginPage, wxT("Graphics"));
GraphicSelection = new wxChoice(PluginPage, ID_GRAPHIC_CB, wxDefaultPosition, wxDefaultSize, NULL, 0, wxDefaultValidator);
@ -620,7 +620,7 @@ void CConfigMain::CloseClick(wxCommandEvent& WXUNUSED (event))
Close();
}
//////////////////////////////////////////////////////////////////////////
// Core AND Interface settings
void CConfigMain::CoreSettingsChanged(wxCommandEvent& event)
{
@ -687,7 +687,7 @@ void CConfigMain::CoreSettingsChanged(wxCommandEvent& event)
}
}
/////////////////////////////////////////////////////////////////////////////////////
// GC settings
// -----------------------
void CConfigMain::GCSettingsChanged(wxCommandEvent& event)
@ -809,10 +809,10 @@ void CConfigMain::ChooseEXIDevice(std::string deviceName, int deviceNum)
(deviceNum == 2) ? 2 : 0); // SP1 is device 2, slots are device 0
}
}
///////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Wii settings
// -------------------
void CConfigMain::WiiSettingsChanged(wxCommandEvent& event)
@ -842,11 +842,11 @@ void CConfigMain::WiiSettingsChanged(wxCommandEvent& event)
break;
}
}
///////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// Paths settings
// -------------------
void CConfigMain::ISOPathsSelectionChanged(wxCommandEvent& WXUNUSED (event))
@ -912,7 +912,7 @@ void CConfigMain::DVDRootChanged(wxFileDirPickerEvent& WXUNUSED (event))
SConfig::GetInstance().m_LocalCoreStartupParameter.m_strDVDRoot = DVDRoot->GetPath().mb_str();
}
//////////////////////////////////////////////////////////////////////////
// Plugin settings
void CConfigMain::OnSelectionChanged(wxCommandEvent& WXUNUSED (event))
{

8
Source/Core/DolphinWX/Src/Frame.cpp
View File

@ -496,7 +496,7 @@ void CFrame::OnQuit(wxCommandEvent& WXUNUSED (event))
Close(true);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Events
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
@ -794,10 +794,10 @@ void CFrame::Update()
}
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Functions
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
wxPanel* CFrame::CreateEmptyPanel()
@ -827,4 +827,4 @@ void CFrame::DoFullscreen(bool _F)
m_Mgr->LoadPerspective(AuiCurrent, true);
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////

12
Source/Core/DolphinWX/Src/FrameAui.cpp
View File

@ -67,7 +67,7 @@ Core::GetWindowHandle().
#include <wx/datetime.h> // wxWidgets
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Aui events
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
@ -208,10 +208,10 @@ void CFrame::ToggleConsole(bool _show, int i)
// Make sure the check is updated (if wxw isn't calling this func)
//GetMenuBar()->FindItem(IDM_CONSOLEWINDOW)->Check(Show);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Notebooks
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
#ifdef _WIN32
@ -664,11 +664,11 @@ void CFrame::OnDropDownToolbarSelect(wxCommandEvent& event)
break;
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Functions
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
@ -1158,4 +1158,4 @@ void CFrame::AddPane()
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////

18
Source/Core/DolphinWX/Src/FrameTools.cpp
View File

@ -93,7 +93,7 @@ extern "C" {
wxCheatsWindow* CheatsWindow;
wxInfoWindow* InfoWindow;
/////////////////////////////
// Create menu items
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
void CFrame::CreateMenu()
@ -237,10 +237,10 @@ void CFrame::CreateMenu()
// Associate the menu bar with the frame
SetMenuBar(menuBar);
}
/////////////////////////////
/////////////////////////////
// Create toolbar items
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
void CFrame::PopulateToolbar(wxAuiToolBar* ToolBar)
@ -421,10 +421,10 @@ void CFrame::InitBitmaps()
aNormalFile = wxArtProvider::GetBitmap(wxART_NORMAL_FILE, wxART_OTHER, wxSize(16,16));
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Menu items
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
@ -704,7 +704,7 @@ void CFrame::ClearStatusBar()
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Miscellaneous menus
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// NetPlay stuff
@ -829,10 +829,10 @@ void CFrame::OnFrameSkip(wxCommandEvent& event)
Frame::SetFrameSkipping((unsigned int)amount);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// GUI
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
@ -1011,4 +1011,4 @@ void CFrame::OnToggleStatusbar(wxCommandEvent& event)
this->SendSizeEvent();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////

4
Source/Core/DolphinWX/Src/FrameWiimote.cpp
View File

@ -16,7 +16,7 @@
// http://code.google.com/p/dolphin-emu/
////////////////////////////////////////////////////////////////////////////////////////
// Include
// ¯¯¯¯¯¯¯¯¯¯¯¯¯
#include "Globals.h"
@ -39,7 +39,7 @@
#include "AboutDolphin.h"
#include <wx/statusbr.h>
/////////////////////////////////////////
namespace WiimoteLeds

12
Source/Core/DolphinWX/Src/ISOProperties.cpp
View File

@ -290,7 +290,7 @@ void CISOProperties::CreateGUIControls(bool IsWad)
sButtons->Add(m_Close, 0, wxALL, 5);
//////////////////////////////////////////////////////////////////////////
// GameConfig editing - Overrides and emulation state
sbGameConfig = new wxStaticBoxSizer(wxVERTICAL, m_GameConfig, _("Game-Specific Settings"));
OverrideText = new wxStaticText(m_GameConfig, ID_OVERRIDE_TEXT, _("These settings override core Dolphin settings.\nUndetermined means the game uses Dolphin's setting."), wxDefaultPosition, wxDefaultSize);
@ -380,7 +380,7 @@ void CISOProperties::CreateGUIControls(bool IsWad)
m_GameConfig->SetSizer(sConfigPage);
sConfigPage->Layout();
//////////////////////////////////////////////////////////////////////////
// Patches
sPatches = new wxBoxSizer(wxVERTICAL);
Patches = new wxCheckListBox(m_PatchPage, ID_PATCHES_LIST, wxDefaultPosition, wxDefaultSize, arrayStringFor_Patches, wxLB_HSCROLL, wxDefaultValidator);
@ -403,7 +403,7 @@ void CISOProperties::CreateGUIControls(bool IsWad)
m_PatchPage->SetSizer(sPatchPage);
sPatchPage->Layout();
//////////////////////////////////////////////////////////////////////////
// Action Replay Cheats
sCheats = new wxBoxSizer(wxVERTICAL);
Cheats = new wxCheckListBox(m_CheatPage, ID_CHEATS_LIST, wxDefaultPosition, wxDefaultSize, arrayStringFor_Cheats, wxLB_HSCROLL, wxDefaultValidator);
@ -426,7 +426,7 @@ void CISOProperties::CreateGUIControls(bool IsWad)
m_CheatPage->SetSizer(sCheatPage);
sCheatPage->Layout();
//////////////////////////////////////////////////////////////////////////
// ISO Details
sbISODetails = new wxStaticBoxSizer(wxVERTICAL, m_Information, _("ISO Details"));
sISODetails = new wxGridBagSizer(0, 0);
@ -498,7 +498,7 @@ void CISOProperties::CreateGUIControls(bool IsWad)
m_Information->SetSizer(sInfoPage);
sInfoPage->Layout();
//////////////////////////////////////////////////////////////////////////
// Filesystem tree
m_Treectrl = new wxTreeCtrl(m_Filesystem, ID_TREECTRL, wxDefaultPosition, wxDefaultSize, wxTR_DEFAULT_STYLE, wxDefaultValidator);
RootId = m_Treectrl->AddRoot(wxT("Disc"), -1, -1, 0);
@ -513,7 +513,7 @@ void CISOProperties::CreateGUIControls(bool IsWad)
if (IsWad)
m_Notebook->RemovePage(4);
//////////////////////////////////////////////////////////////////////////
// Add notebook and buttons to the dialog
wxBoxSizer* sMain;
sMain = new wxBoxSizer(wxVERTICAL);

4
Source/Core/DolphinWX/Src/Main.cpp
View File

@ -429,7 +429,7 @@ void Host_UpdateBreakPointView()
}
/////////////////////////////////////////////////////////////
// Update Wiimote status bar
// ¯¯¯¯¯¯¯¯¯¯¯¯¯
void Host_UpdateLeds(int led_bits)
@ -466,7 +466,7 @@ void Host_UpdateStatus()
memcpy(main_frame->g_Speakers_, main_frame->g_Speakers, sizeof(main_frame->g_Speakers));
}
}
///////////////////////////
void Host_UpdateMemoryView()

8
Source/Core/DolphinWX/Src/NetSockets.cpp
View File

@ -254,9 +254,9 @@ bool ServerSide::SyncValues(unsigned char socketnb, sf::IPAddress Address)
m_client[socketnb].nick = std::string(buffer);
m_client[socketnb].ready = false;
///////////////////
// Test UDP Socket
///////////////////
if (m_socketUDP.Send((const char*)&m_numplayers, 1, Address, m_client[m_numplayers].port) == sf::Socket::Done)
{
// Test UDP Socket Receive, 2s timeout
@ -525,9 +525,9 @@ bool ClientSide::SyncValues()
m_socket.Receive(buffer, buffer_size + 1, recv_size);
m_hostnick = std::string(buffer);
///////////////////
// Test UDP Socket
///////////////////
if (m_socketUDP.Send((const char*)&m_numplayers, 1, host.c_str(), server_port) == sf::Socket::Done)
{
// Test UDP Socket Receive, 2s timeout

4
Source/Core/DolphinWX/Src/NetWindow.cpp
View File

@ -18,7 +18,7 @@
#include "NetSockets.h"
#include "NetWindow.h"
///////////////////////
// Main Frame window
BEGIN_EVENT_TABLE(NetPlay, wxFrame)
@ -509,7 +509,7 @@ void NetPlay::OnGUIEvent(wxCommandEvent& event)
}
}
/////////////////////////
// GameList popup window
BEGIN_EVENT_TABLE(GameListPopup, wxDialog)

34
Source/Core/InputCommon/Src/Configuration.cpp
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
// Project description
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Name: Input Configuration and Calibration
@ -7,7 +7,7 @@
// Author: Falcon4ever (nJoy@falcon4ever.com, www.multigesture.net), JPeterson etc
// Copyright (C) 2003 Dolphin Project.
//
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -26,11 +26,11 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Include
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
#if defined HAVE_WX && HAVE_WX
@ -43,14 +43,14 @@
#endif
#include "SDL.h" // Local
////////////////////////////////////
namespace InputCommon
{
//////////////////////////////////////////////////////////////////////////////////////////
// Degree to radian and back
// ¯¯¯¯¯¯¯¯¯¯¯¯¯
float Deg2Rad(float Deg)
@ -61,10 +61,10 @@ float Rad2Deg(float Rad)
{
return (Rad * 180.0f) / (float)M_PI;
}
/////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Check if the pad is within the dead zone, we assume the range is 0x8000
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
float CoordinatesToRadius(int x, int y)
@ -85,10 +85,10 @@ bool IsDeadZone(float DeadZone, int x, int y)
else
return false;
}
/////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Scale down stick values from 0x8000 to 0x80
/* ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
The value returned by SDL_JoystickGetAxis is a signed integer s16
@ -114,10 +114,10 @@ int Pad_Convert(int _val)
return _val;
}
/////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Adjust the radius
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
void RadiusAdjustment(int &_x, int &_y, int _pad, std::string SRadius)
@ -138,10 +138,10 @@ void RadiusAdjustment(int &_x, int &_y, int _pad, std::string SRadius)
// Update values
_x = (int)x, _y = (int)y;
}
/////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
/* Convert the stick raidus from a square or rounded box to a circular radius. I don't know what
input values the actual GC controller produce for the GC, it may be a square, a circle or
something in between. But one thing that is certain is that PC pads differ in their output
@ -228,10 +228,10 @@ void Square2Circle(int &_x, int &_y, int _pad, std::string SDiagonal, bool Circl
// Debugging
//Console::Print("%f %f %i", corner_circle_dist, Diagonal, Tmp));
}
/////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Windows Virtual Key Codes Names
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
#ifdef _WIN32
@ -271,7 +271,7 @@ std::string VKToString(int keycode)
#endif
}
#endif
/////////////////////////////////////////////////////////////////////
}

4
Source/Core/InputCommon/Src/DirectInputBase.cpp
View File

@ -16,11 +16,11 @@
// http://code.google.com/p/dolphin-emu/
//////////////////////////////////////////////////////////////////////////////////////////
// Include
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
#include "DirectInputBase.h"
////////////////////////////////////
DInput::DInput()

4
Source/Core/InputCommon/Src/DirectInputBase.h
View File

@ -19,7 +19,7 @@
#define _DIRECTINPUTBASE_H
//////////////////////////////////////////////////////////////////////////////////////////
// Include
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
#include <windows.h> // System
@ -29,7 +29,7 @@
#include <dinput.h>
//#include "ConsoleWindow.h" // Common
///////////////////////////////
class DInput

28
Source/Core/InputCommon/Src/SDL.cpp
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
// Project description
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Name: SDL Input
@ -7,7 +7,7 @@
// Author: Falcon4ever (nJoy@falcon4ever.com, www.multigesture.net), JPeterson etc
// Copyright (C) 2003 Dolphin Project.
//
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -26,36 +26,36 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Include
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
#define _SDL_MAIN_ // Avoid certain declarations in SDL.h
#include "SDL.h" // Local
#include "XInput.h"
////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Definitions
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
int g_LastPad = 0;
////////////////////////////////////
namespace InputCommon
{
//////////////////////////////////////////////////////////////////////////////////////////
// Definitions
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Search attached devices. Populate joyinfo for all attached physical devices.
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
bool SearchDevices(std::vector<CONTROLLER_INFO> &_joyinfo, int &_NumPads, int &_NumGoodPads)
@ -108,10 +108,10 @@ bool SearchDevices(std::vector<CONTROLLER_INFO> &_joyinfo, int &_NumPads, int &_
return true;
}
////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Supporting functions
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
@ -235,12 +235,12 @@ void GetJoyState(CONTROLLER_STATE &_PadState, CONTROLLER_MAPPING _PadMapping, in
);
#endif
}
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Configure button mapping
// ¯¯¯¯¯¯¯¯¯¯

22
Source/Core/InputCommon/Src/SDL.h
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
// Project description
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Name: SDL Input
@ -7,7 +7,7 @@
// Author: Falcon4ever (nJoy@falcon4ever.com, www.multigesture.net), JPeterson etc
// Copyright (C) 2003 Dolphin Project.
//
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -26,12 +26,12 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
#ifndef _SDL_h
#define _SDL_h
//////////////////////////////////////////////////////////////////////////////////////////
// Include
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
#include <iostream> // System
@ -45,20 +45,20 @@
#endif
#include "Common.h" // Common
////////////////////////////
namespace InputCommon
{
//////////////////////////////////////////////////////////////////////////////////////////
// Settings
// ¯¯¯¯¯¯¯¯¯¯
// Show a status window with the detected axes, buttons and so on
//#define SHOW_PAD_STATUS
//////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Structures
/* ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
CONTROLLER_STATE buttons (PadState) = 0 or 1
@ -220,10 +220,10 @@ struct CONTROLLER_MAPPING_NEW // GC PAD MAPPING
bool bRollInvert;
bool bPitchInvert;
};
////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Declarations
// ¯¯¯¯¯¯¯¯¯
@ -247,7 +247,7 @@ std::string VKToString(int keycode);
#ifndef _SDL_MAIN_
extern int g_LastPad;
#endif
////////////////////////////
} // InputCommon

26
Source/Core/InputCommon/Src/XInput.cpp
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -17,10 +17,10 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// File description
/* ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
Function: This file will get the status of the analog triggers of any connected XInput device.
@ -31,21 +31,21 @@
#ifdef _WIN32
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
#include <windows.h>
#include <XInput.h> // XInput API
#include "SDL.h" // Local
///////////////////////////////////////////////
namespace XInput
{
//////////////////////////////////////////////////////////////////////////////////////////
// Declarations
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
@ -57,10 +57,10 @@ struct CONTROLER_STATE
bool bConnected;
};
CONTROLER_STATE g_Controllers[MAX_CONTROLLERS];
///////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Init
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
/* Function: Calculate the number of connected XInput devices
@ -87,10 +87,10 @@ void Init()
}
}
///////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Get the trigger status
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
int GetXI(int Controller, int Button)
@ -113,10 +113,10 @@ int GetXI(int Controller, int Button)
return 0;
}
}
///////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Check if a certain controller is connected
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
bool IsConnected(int Controller)
@ -129,7 +129,7 @@ bool IsConnected(int Controller)
else
return false;
}
///////////////////////////////////////////
} // XInput

12
Source/Core/InputCommon/Src/XInput.h
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -17,28 +17,28 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
#ifdef _WIN32
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
// ¯¯¯¯¯¯¯¯¯¯
#include <iostream>
//////////////////////////////
namespace XInput
{
//////////////////////////////////////////////////////////////////////////////////////////
// Declarations
// ¯¯¯¯¯¯¯¯¯¯
void Init();
int GetXI(int Controller, int Button);
bool IsConnected(int Controller);
//////////////////////////////
} // XInput

24
Source/Core/VideoCommon/Src/BPMemory.h
View File

@ -105,9 +105,9 @@
#define BPMEM_TEV_KSEL 0xF6 // 0xF6 + 8
#define BPMEM_BP_MASK 0xFE
//////////////////////////////////////////////////////////////////////////
// Tev/combiner things
//////////////////////////////////////////////////////////////////////////
#define TEVOP_ADD 0
#define TEVOP_SUB 1
@ -439,9 +439,9 @@ union RAS1_IREF
u32 getTexMap(int i) { return (hex>>(6*i))&3; }
};
//////////////////////////////////////////////////////////////////////////
// Texture structs
//////////////////////////////////////////////////////////////////////////
union TexMode0
{
struct
@ -559,9 +559,9 @@ struct FourTexUnits
};
//////////////////////////////////////////////////////////////////////////
// Geometry/other structs
//////////////////////////////////////////////////////////////////////////
union GenMode
{
struct
@ -611,9 +611,9 @@ union X10Y10
u32 hex;
};
//////////////////////////////////////////////////////////////////////////
// Framebuffer/pixel stuff (incl fog)
//////////////////////////////////////////////////////////////////////////
union BlendMode
{
struct
@ -736,9 +736,9 @@ union PE_CONTROL
u32 hex;
};
//////////////////////////////////////////////////////////////////////////
// Texture coordinate stuff
//////////////////////////////////////////////////////////////////////////
union TCInfo
{
struct
@ -823,9 +823,9 @@ union UPE_Copy
};
};
//////////////////////////////////////////////////////////////////////////
// All of BP memory
//////////////////////////////////////////////////////////////////////////
struct BPCmd
{

6
Source/Core/VideoCommon/Src/TextureDecoder.cpp
View File

@ -35,12 +35,12 @@ extern const unsigned char sfont_raw[][9*10];
// STATE_TO_SAVE
u8 texMem[TMEM_SIZE];
//////////////////////////////////////////////////////////////////////////
// Gamecube/Wii texture decoder
//////////////////////////////////////////////////////////////////////////
// Decodes all known Gamecube/Wii texture formats.
// by ector
//////////////////////////////////////////////////////////////////////////
int TexDecoder_GetTexelSizeInNibbles(int format)
{
switch (format & 0x3f) {

20
Source/Core/VideoCommon/Src/VertexLoader_Color.cpp
View File

@ -65,8 +65,8 @@ void _SetCol565(u16 val)
col |= Convert5To8(val & 0x1F) << BSHIFT;
_SetCol(col | (0xFF << ASHIFT));
}
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
inline u32 _Read24(const u8 *addr)
{
return addr[0] | (addr[1] << 8) | (addr[2] << 16) | 0xFF000000;
@ -77,8 +77,8 @@ inline u32 _Read32(const u8 *addr)
return *(const u32 *)addr;
}
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
void LOADERDECL Color_ReadDirect_24b_888()
{
@ -129,9 +129,9 @@ void LOADERDECL Color_ReadDirect_32b_8888()
_SetCol(col);
}
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
void LOADERDECL Color_ReadIndex8_16b_565()
{
u8 Index = DataReadU8();
@ -169,9 +169,9 @@ void LOADERDECL Color_ReadIndex8_32b_8888()
const u8 *iAddress = cached_arraybases[ARRAY_COLOR+colIndex] + (Index * arraystrides[ARRAY_COLOR+colIndex]);
_SetCol(_Read32(iAddress));
}
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
void LOADERDECL Color_ReadIndex16_16b_565()
{
u16 Index = DataReadU16();

12
Source/Core/VideoCommon/Src/VertexLoader_Normal.cpp
View File

@ -108,9 +108,9 @@ TPipelineFunction VertexLoader_Normal::GetFunction(unsigned int _type, unsigned
return pFunc;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
// --- Direct ---
/////////////////////////////////////////////////////////////////////////////////////////////////////
void LOADERDECL VertexLoader_Normal::Normal_DirectByte()
{
*VertexManager::s_pCurBufferPointer++ = DataReadU8();
@ -178,9 +178,9 @@ void LOADERDECL VertexLoader_Normal::Normal_DirectFloat3()
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
// --- Index8 ---
/////////////////////////////////////////////////////////////////////////////////////////////////////
void LOADERDECL VertexLoader_Normal::Normal_Index8_Byte()
{
u8 Index = DataReadU8();
@ -302,9 +302,9 @@ void LOADERDECL VertexLoader_Normal::Normal_Index8_Float3_Indices3()
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
// --- Index16 ---
/////////////////////////////////////////////////////////////////////////////////////////////////////
void LOADERDECL VertexLoader_Normal::Normal_Index16_Byte()
{

6
Source/Core/VideoCommon/Src/VideoCommon.h
View File

@ -60,7 +60,7 @@ enum
extern SVideoInitialize g_VideoInitialize;
//////////////////////////////////////////////////////////////////////////
inline u8 *Memory_GetPtr(u32 _uAddress)
{
return g_VideoInitialize.pGetMemoryPointer(_uAddress);
@ -80,7 +80,7 @@ inline u32 Memory_Read_U32(u32 _uAddress)
{
return Common::swap32(*(u32*)g_VideoInitialize.pGetMemoryPointer(_uAddress));
}
//////////////////////////////////////////////////////////////////////////
inline u8* Memory_Read_U8_Ptr(u32 _uAddress)
{
return (u8*)g_VideoInitialize.pGetMemoryPointer(_uAddress);
@ -95,7 +95,7 @@ inline u32* Memory_Read_U32_Unswapped_Ptr(u32 _uAddress)
{
return (u32*)g_VideoInitialize.pGetMemoryPointer(_uAddress);
}
//////////////////////////////////////////////////////////////////////////
inline float Memory_Read_Float(u32 _uAddress)
{

4
Source/Core/VideoCommon/Src/XFMemory.h
View File

@ -20,9 +20,9 @@
#include "Common.h"
/////////////
// Lighting
/////////////
#define XF_TEXPROJ_ST 0
#define XF_TEXPROJ_STQ 1

30
Source/PluginSpecs/PluginSpecs.h
View File

@ -1,23 +1,23 @@
//////////////////////////////////////////////////////////////////////////////////////////
//________________________________________________________________________________________
// File description: Common plugin spec, version #1.0 maintained by F|RES
///////////////////////////
#ifndef _PLUGINS_H_INCLUDED__
#define _PLUGINS_H_INCLUDED__
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
// ------------
#ifdef _WIN32
#include <windows.h>
#endif
#include "CommonTypes.h"
///////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
/* Plugin communication. I place this here rather in Common.h since these messages are only received
at one place, by the CPanel in Frame.cpp. That way I don't have to rebuild if any of this is changed */
// -----------------
@ -31,10 +31,10 @@ enum PLUGIN_COMM
INPUT_FRAME_COUNTER, // Wind back the frame counter for rerecording
OPENGL_VIDEO_STOP
};
///////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// System specific declarations and definitions
// ------------
@ -59,10 +59,10 @@ enum PLUGIN_COMM
#if defined(__cplusplus)
extern "C" {
#endif
///////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Global values
// ------------
@ -81,10 +81,10 @@ enum PLUGIN_TYPE {
#define STATE_MODE_WRITE 2
#define STATE_MODE_MEASURE 3
///////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Export structs
// ------------
typedef struct
@ -100,11 +100,11 @@ typedef struct
void *config;
void *logManager;
} PLUGIN_GLOBALS;
///////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// GLOBAL I N T E R F A C E ///////////////////////////////////////////////////
// GLOBAL I N T E R F A C E
// ____________________________________________________________________________
// Function: GetDllInfo
// Purpose: This function allows the emulator to gather information
@ -164,7 +164,7 @@ EXPORT void CALL Shutdown(void);
// input: mode
//
EXPORT void CALL DoState(unsigned char **ptr, int mode);
///////////////////////////////
#if defined(__cplusplus)

4
Source/PluginSpecs/pluginspecs_pad.h
View File

@ -53,8 +53,8 @@ typedef struct
signed char err; // one of PAD_ERR_* number
} SPADStatus;
/////////////////////////////////////////////////////////////////////////////////////////////////////
// I N T E R F A C E ///////////////////////////////////////////////////////////
// I N T E R F A C E
// __________________________________________________________________________________________________
// Function:

6
Source/PluginSpecs/pluginspecs_video.h
View File

@ -94,9 +94,9 @@ typedef struct
} SVideoInitialize;
/////////////////////////////////////////////////////////////////////////////////////////////////////
// I N T E R F A C E ////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
// I N T E R F A C E
// __________________________________________________________________________________________________
// Function: Video_Prepare

6
Source/PluginSpecs/pluginspecs_wiimote.h
View File

@ -24,9 +24,9 @@ typedef struct
TWiimoteInput pWiimoteInput;
} SWiimoteInitialize;
/////////////////////////////////////////////////////////////////////////////////////////////////////
// I N T E R F A C E ////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
// I N T E R F A C E
// __________________________________________________________________________________________________
// Function: Wiimote_Output

8
Source/Plugins/Plugin_DSP_HLE/Src/Debugger/Blocks.cpp
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -17,10 +17,10 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
// -------------
#include <iostream>
@ -38,7 +38,7 @@
#include "StringUtil.h"
#include "FileSearch.h"
//#include "../Logging/File.h" // Write to file
///////////////////////////////
// Make the wxTextCtrls scroll with each other

10
Source/Plugins/Plugin_DSP_HLE/Src/Debugger/Debugger.cpp
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -17,10 +17,10 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
// -------------
// includes
@ -40,7 +40,7 @@
#include "Debugger.h"
#include "PBView.h"
#include "../Debugger/File.h" // Write to file
//////////////////////////////
// =======================================================================================
// Event table and class
@ -228,7 +228,7 @@ void DSPDebuggerHLE::Load(IniFile& _IniFile)
// ===================
//////////////////////////////////////////////////////////////////////////////////////////
// Create GUI controls
// -------------
void DSPDebuggerHLE::CreateGUIControls()

4
Source/Plugins/Plugin_DSP_HLE/Src/Debugger/Debugger.h
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -17,7 +17,7 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
#ifndef __DSPDebuggerHLE_h__
#define __DSPDebuggerHLE_h__

4
Source/Plugins/Plugin_DSP_HLE/Src/Debugger/File.cpp
View File

@ -67,7 +67,7 @@ void StartFile(int width, int height, char* fname)
// ======================
//////////////////////////////////////////////////////////////////////////////////////////
/* Close the file handles */
// -------------
void CloseFile()
@ -78,7 +78,7 @@ void CloseFile()
if(__fStdOut[i]) fclose(__fStdOut[i]);
}
}
//////////////////////////////
// ---------------------------------------------------------------------------------------

4
Source/Plugins/Plugin_DSP_HLE/Src/Debugger/File.h
View File

@ -16,7 +16,7 @@
// http://code.google.com/p/dolphin-emu/
//////////////////////////////////////////////////////////////////////////////////////////
// Declarations and definitions
// -------------
@ -37,5 +37,5 @@ void CloseConsole();
#ifdef _WIN32
HWND GetConsoleHwnd(void);
#endif
/////////////////////////////

12
Source/Plugins/Plugin_DSP_HLE/Src/Debugger/Logging.cpp
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -17,10 +17,10 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
// -------------
@ -43,10 +43,10 @@
#include "../UCodes/UCode_AX.h"
#include "../UCodes/UCode_AXWii.h"
#include "../UCodes/UCode_AX_Voice.h"
//////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Declarations and definitions
// -------------
@ -149,7 +149,7 @@ std::vector<int> numberRunning(NUMBER_OF_PBS);
// Classes
extern DSPDebuggerHLE* m_DebuggerFrame;
//////////////////////////
// =======================================================================================

12
Source/Plugins/Plugin_DSP_HLE/Src/Debugger/Mails.cpp
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -17,10 +17,10 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
// -------------
#include <iostream>
@ -39,15 +39,15 @@
#include "FileUtil.h"
#include "StringUtil.h"
#include "FileSearch.h"
///////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Declarations and definitions
// -------------
extern std::vector<std::string> sMailLog, sMailTime;
extern DSPDebuggerHLE* m_DebuggerFrame;
///////////////////////////////
// =======================================================================================

8
Source/Plugins/Plugin_PadSimple/Src/GUI/ConfigDlg.cpp
View File

@ -87,7 +87,7 @@ PADConfigDialogSimple::~PADConfigDialogSimple()
}
//////////////////////////////////////////////////////////////////////////////////////////
// Create input button controls
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
inline void AddControl(wxPanel *pan, wxButton **button, wxStaticBoxSizer *sizer,
@ -114,7 +114,7 @@ inline void AddControl(wxPanel *pan, wxButton **button, wxStaticBoxSizer *sizer,
hButton->Add(*button, 0, wxALIGN_RIGHT|wxALL);
sizer->Add(hButton, 0, wxALIGN_RIGHT|wxALL);
}
////////////////////////////////////
void PADConfigDialogSimple::CreateGUIControls()
@ -220,7 +220,7 @@ void PADConfigDialogSimple::CreateGUIControls()
// -----------------------------------
/////////////////////////////////////////////////////////////////////////////////////
// Rerecording
// ¯¯¯¯¯¯¯¯¯
#ifdef RERECORDING
@ -257,7 +257,7 @@ void PADConfigDialogSimple::CreateGUIControls()
//DEBUG_LOG(CONSOLE, "m_CheckRecording: %i\n", pad[0].bRecording, pad[0].bPlayback);
#endif
//////////////////////////////////////
// --------------------------------------------------------------------

8
Source/Plugins/Plugin_PadSimple/Src/PadSimple.cpp
View File

@ -16,7 +16,7 @@
// http://code.google.com/p/dolphin-emu/
//////////////////////////////////////////////////////////////////////////
// Include
#include <stdio.h>
#include <math.h>
@ -58,12 +58,12 @@
#endif
//////////////////////////////////////////////////////////////////////////
// Declarations
SPads pad[4];
SPADInitialize g_PADInitialize;
//////////////////////////////////////////////////////////////////////////
// Standard crap to make wxWidgets happy
#ifdef _WIN32
HINSTANCE g_hInstance;
@ -129,7 +129,7 @@ wxWindow* GetParentedWxWindow(HWND Parent)
#endif
//////////////////////////////////////////////////////////////////////////
// Input Recording
// Enable these to record or play back

4
Source/Plugins/Plugin_VideoDX9/Src/Render.cpp
View File

@ -330,7 +330,7 @@ void Renderer::SwapBuffers()
DEBUGGER_PAUSE_COUNT_N_WITHOUT_UPDATE(NEXT_FRAME);
//D3D frame is now over
//////////////////////////////////////////////////////////////////////////
//clean out old stuff from caches
frameCount++;
@ -338,7 +338,7 @@ void Renderer::SwapBuffers()
VertexShaderCache::Cleanup();
TextureCache::Cleanup();
//////////////////////////////////////////////////////////////////////////
//Begin new frame
//Set default viewport and scissor, for the clear to work correctly
stats.ResetFrame();

8
Source/Plugins/Plugin_VideoOGL/Src/GUI/ConfigDlg.cpp
View File

@ -92,7 +92,7 @@ GFXConfigDialogOGL::GFXConfigDialogOGL(wxWindow *parent, wxWindowID id, const wx
g_Config.UpdateProjectionHack();
}
///////////////////////////////////////////////////////////////////////////////////////////////
// Close and unload the window
// ---------------
GFXConfigDialogOGL::~GFXConfigDialogOGL()
@ -127,9 +127,9 @@ void GFXConfigDialogOGL::CloseClick(wxCommandEvent& WXUNUSED (event))
//Close();
CloseWindow();
}
///////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////
// Add avaliable resolutions and other settings
// ---------------
void GFXConfigDialogOGL::AddFSReso(const char *reso)
@ -142,7 +142,7 @@ void GFXConfigDialogOGL::AddWindowReso(const char *reso)
arrayStringFor_WindowResolutionCB.Add(wxString::FromAscii(reso));
}
///////////////////////////////////////
void GFXConfigDialogOGL::CreateGUIControls()

6
Source/Plugins/Plugin_VideoOGL/Src/Render.cpp
View File

@ -74,7 +74,7 @@
#else
#endif
//////////////////////////////////////////////////////////////////////////////////////////
// Declarations and definitions
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
CGcontext g_cgcontext;
@ -646,7 +646,7 @@ GLuint Renderer::ResolveAndGetDepthTarget(const EFBRectangle &source_rect)
}
/////////////////////////////////////////////////////////////////////////////
// Function: This function handles the OpenGL glScissor() function
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Call browser: OpcodeDecoding.cpp ExecuteDisplayList > Decode() > LoadBPReg()
@ -1049,7 +1049,7 @@ void Renderer::Swap(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight)
}
//////////////////////////////////////////////////////////////////////////////////////////
// We can now draw whatever we want on top of the picture. Then we copy the final picture to the output.
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
void Renderer::SwapBuffers()

16
Source/Plugins/Plugin_VideoOGL/Src/Win32Window.cpp
View File

@ -375,9 +375,9 @@ void Win32Window::Cleanup()
}
}
////////////////////////////////////////////////////////////
/// Process a Win32 Event
////////////////////////////////////////////////////////////
void Win32Window::ProcessEvent(UINT Message, WPARAM WParam, LPARAM LParam)
{
// Don't process any message until window is created
@ -628,10 +628,10 @@ void Win32Window::ProcessEvent(UINT Message, WPARAM WParam, LPARAM LParam)
}
}
///////////////////////////////////////////////////////////
/// Check the state of the shift keys on a key sf::Event,
/// and return the corresponding SF key code
////////////////////////////////////////////////////////////
sf::Key::Code Win32Window::GetShiftState(bool KeyDown)
{
static bool LShiftPrevDown = false;
@ -658,9 +658,9 @@ sf::Key::Code Win32Window::GetShiftState(bool KeyDown)
return Code;
}
///////////////////////////////////////////////////////////
/// Convert a Win32 virtual key code to a SFML key code
////////////////////////////////////////////////////////////
sf::Key::Code Win32Window::VirtualKeyCodeToSF(WPARAM VirtualKey, LPARAM Flags)
{
switch (VirtualKey)
@ -768,9 +768,9 @@ sf::Key::Code Win32Window::VirtualKeyCodeToSF(WPARAM VirtualKey, LPARAM Flags)
return sf::Key::Code(0);
}
///////////////////////////////////////////////////////////
/// Win32 Callback for the window class
////////////////////////////////////////////////////////////
LRESULT CALLBACK Win32Window::GlobalOnEvent(HWND Handle, UINT Message, WPARAM WParam, LPARAM LParam)
{
// Associate handle and Window instance when the creation message is received

6
Source/Plugins/Plugin_VideoOGL/Src/nmain.cpp
View File

@ -47,9 +47,9 @@
SVideoInitialize g_VideoInitialize;
PLUGIN_GLOBALS* globals;
//////////////////////////////////////////////////////////////////////////
// Nasty stuff which win32 needs for wxw
//////////////////////////////////////////////////////////////////////////
#if defined(_WIN32) && defined(HAVE_WX) && HAVE_WX
HINSTANCE g_hInstance;
@ -92,7 +92,7 @@ BOOL APIENTRY DllMain(HINSTANCE hinstDLL, // DLL module handle
return TRUE;
}
#endif
//////////////////////////////////////////////////////////////////////////
/* Create debugging window. There's currently a strange crash that occurs whe a game is loaded
if the OpenGL plugin was loaded before. I'll try to fix that. Currently you may have to

2
Source/Plugins/Plugin_Wiimote/Src/ConfigGamepad.cpp
View File

@ -582,7 +582,7 @@ void WiimotePadConfigDialog::PadGetStatus()
WiiMoteEmu::GetJoyState(WiiMoteEmu::PadState[Page], WiiMoteEmu::PadMapping[Page], Page, WiiMoteEmu::joyinfo.at(WiiMoteEmu::PadMapping[Page].ID).NumButtons);
//////////////////////////////////////
// Analog stick
// Set Deadzones perhaps out of function
//int deadzone = (int)(((float)(128.00/100.00)) * (float)(PadMapping[_numPAD].deadzone+1));

12
Source/Plugins/Plugin_nJoy_SDL/Src/Config.cpp
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
// Project description
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Name: nJoy
@ -8,7 +8,7 @@
// Site: www.multigesture.net
// Copyright (C) 2003 Dolphin Project.
//
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -27,10 +27,10 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
// Include
// ¯¯¯¯¯¯¯¯¯
#include "nJoy.h"
@ -40,7 +40,7 @@ Config g_Config;
#if defined(HAVE_WX) && HAVE_WX
extern PADConfigDialognJoy* m_ConfigFrame;
#endif
//////////////////////////////////
// Run when created
@ -92,7 +92,7 @@ void DEBUG_QUIT()
}
/////////////////////////////////////////////////////////////////////////////////////
// Save settings to file
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
void Config::Save(int Slot)

6
Source/Plugins/Plugin_nJoy_SDL/Src/GUI/AboutBox.cpp
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
// Project description
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Name: nJoy
@ -8,7 +8,7 @@
// Site: www.multigesture.net
// Copyright (C) 2003 Dolphin Project.
//
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -27,7 +27,7 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
#include "AboutBox.h"
#include "../nJoy.h"

6
Source/Plugins/Plugin_nJoy_SDL/Src/GUI/AboutBox.h
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
// Project description
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Name: nJoy
@ -8,7 +8,7 @@
// Site: www.multigesture.net
// Copyright (C) 2003 Dolphin Project.
//
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -27,7 +27,7 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
#ifndef __ABOUTBOX_h__
#define __ABOUTBOX_h__

18
Source/Plugins/Plugin_nJoy_SDL/Src/GUI/ConfigAdvanced.cpp
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
// Project description
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Name: nJoy
@ -8,7 +8,7 @@
// Site: www.multigesture.net
// Copyright (C) 2003 Dolphin Project.
//
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -27,10 +27,10 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Include
// ¯¯¯¯¯¯¯¯¯
#include "ConfigBox.h"
@ -38,7 +38,7 @@
#include "Images/controller.xpm"
extern bool g_EmulatorRunning;
////////////////////////
/* If we don't use this hack m_MainSizer->GetMinSize().GetWidth() will not change
when we enable and disable bShowAdvanced */
@ -62,7 +62,7 @@ void PADConfigDialognJoy::PadGetStatus()
int PhysicalDevice = PadMapping[notebookpage].ID;
int TriggerType = PadMapping[notebookpage].triggertype;
//////////////////////////////////////
// Analog stick
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Set Deadzones perhaps out of function
@ -121,7 +121,7 @@ void PADConfigDialognJoy::PadGetStatus()
///////////////////// Analog stick
//////////////////////////////////////
// Triggers
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
int TriggerValue = 255;
@ -318,7 +318,7 @@ void PADConfigDialognJoy::CreateAdvancedControls(int i)
m_bmpDotOutC[i] = new wxStaticBitmap(m_pOutStatusC[i], wxID_ANY, CreateBitmapDot(),
wxPoint(BoxW / 2, BoxH / 2), wxDefaultSize);
/////////////////////////////////////////////////////////////////////////////////////
// Rerecording
// ¯¯¯¯¯¯¯¯¯
#ifdef RERECORDING
@ -355,7 +355,7 @@ void PADConfigDialognJoy::CreateAdvancedControls(int i)
//Console::Print("m_CheckRecording: %i\n", g_Config.bRecording, g_Config.bPlayback);
#endif
//////////////////////////////////////
}

10
Source/Plugins/Plugin_nJoy_SDL/Src/GUI/ConfigBox.h
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
// Project description
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Name: nJoy
@ -8,7 +8,7 @@
// Site: www.multigesture.net
// Copyright (C) 2003 Dolphin Project.
//
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -27,7 +27,7 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
#ifndef __CONFIGBOX_h__
@ -94,7 +94,7 @@ class PADConfigDialognJoy : public wxDialog
wxStaticBoxSizer * m_sKeys[4];
wxBoxSizer *m_sMain[4], *m_sMainLeft[4], *m_sMainRight[4];
/////////////////////////////
// Settings
// ¯¯¯¯¯¯¯¯¯
@ -131,7 +131,7 @@ class PADConfigDialognJoy : public wxDialog
wxStaticBoxSizer *m_gStatusTriggers[4]; // Triggers
wxStaticText *m_TStatusTriggers[4];
/////////////////////////////
// Keys
// ¯¯¯¯¯¯¯¯¯
int g_Pressed; // Keyboard input

12
Source/Plugins/Plugin_nJoy_SDL/Src/GUI/ConfigJoypad.cpp
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
// Project description
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Name: nJoy
@ -8,7 +8,7 @@
// Site: www.multigesture.net
// Copyright (C) 2003 Dolphin Project.
//
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -27,10 +27,10 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Include
// ¯¯¯¯¯¯¯¯¯
#include "math.h" // System
@ -40,7 +40,7 @@
#include "Images/controller.xpm"
extern bool g_EmulatorRunning;
////////////////////////
// Set dialog items from saved values
@ -251,7 +251,7 @@ wxString PADConfigDialognJoy::GetButtonText(int id, int Page)
}
//////////////////////////////////////////////////////////////////////////////////////////
// Configure button mapping
// ¯¯¯¯¯¯¯¯¯¯

20
Source/Plugins/Plugin_nJoy_SDL/Src/ReRecording.cpp
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
// Project description
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Name: nJoy
@ -8,7 +8,7 @@
// Site: www.multigesture.net
// Copyright (C) 2003 Dolphin Project.
//
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -27,10 +27,10 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// File description
/* ¯¯¯¯¯¯¯¯¯
@ -39,13 +39,13 @@ Rerecording options
////////////////////////*/
//////////////////////////////////////////////////////////////////////////////////////////
// Include
// ¯¯¯¯¯¯¯¯¯
#include "nJoy.h"
#include "FileUtil.h"
#include "ChunkFile.h"
/////////////////////////
#ifdef RERECORDING
@ -55,18 +55,18 @@ namespace Recording
{
//////////////////////////////////////////////////////////////////////////////////////////
// Definitions
// ¯¯¯¯¯¯¯¯¯¯¯¯¯
// Pre defined maxium storage limit
#define RECORD_SIZE (1024 * 128)
SPADStatus RecordBuffer[RECORD_SIZE];
int count = 0;
////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Recording functions
// ¯¯¯¯¯¯¯¯¯¯¯¯¯
void RecordInput(const SPADStatus& _rPADStatus)
@ -130,7 +130,7 @@ void Save()
//PanicAlert("SaveRecord()");
//Console::Print("SaveRecord()");
}
////////////////////////////////

16
Source/Plugins/Plugin_nJoy_SDL/Src/Rumble.cpp
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
// Project description
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Name: nJoy
@ -8,7 +8,7 @@
// Site: www.multigesture.net
// Copyright (C) 2003 Dolphin Project.
//
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -27,16 +27,16 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
////////////////////////
// Include
// ¯¯¯¯¯¯¯¯¯
#include "nJoy.h"
//////////////////////////////////////////////////////////////////////////////////////////
// Enable or disable rumble.
// ¯¯¯¯¯¯¯¯¯
@ -72,7 +72,7 @@
bool CanRumble = false;
#endif
//////////////////////
// Use PAD rumble
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯
@ -128,7 +128,7 @@ void Pad_Use_Rumble(u8 _numPAD)
#endif
}
////////////////////////////////////////////////////
// Set PAD rumble. Explanation: Stop = 0, Rumble = 1
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯
@ -187,7 +187,7 @@ void PAD_Rumble(u8 _numPAD, unsigned int _uType, unsigned int _uStrength)
}
#ifdef _WIN32
//////////////////////////////////////////////////////////////////////////////////////////
// Rumble stuff :D!
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
//

32
Source/Plugins/Plugin_nJoy_SDL/Src/nJoy.cpp
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
// Project description
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Name: nJoy
@ -8,7 +8,7 @@
// Site: www.multigesture.net
// Copyright (C) 2003 Dolphin Project.
//
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -27,11 +27,11 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
// Issues
/* ¯¯¯¯¯¯¯¯¯
@ -44,7 +44,7 @@
////////////////////////////////////////////////////////////////////////////////////////
// Variables guide
/* ¯¯¯¯¯¯¯¯¯
@ -65,7 +65,7 @@
//////////////////////////////////////////////////////////////////////////////////////////
// Include
// ¯¯¯¯¯¯¯¯¯
#include "nJoy.h"
@ -75,10 +75,10 @@
#if defined(HAVE_WX) && HAVE_WX
PADConfigDialognJoy* m_ConfigFrame = NULL;
#endif
/////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Variables
// ¯¯¯¯¯¯¯¯¯
@ -165,7 +165,7 @@ wxWindow* GetParentedWxWindow(HWND Parent)
#endif
//////////////////////////////////////////////////////////////////////////////////////////
// Input Plugin Functions (from spec's)
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
@ -416,7 +416,7 @@ void PAD_GetStatus(u8 _numPAD, SPADStatus* _pPADStatus)
int TriggerType = PadMapping[_numPAD].triggertype;
int TriggerValue = PadState[_numPAD].halfpress ? 100 : 255;
///////////////////////////////////////////////////
// The analog controls
// -----------
@ -466,7 +466,7 @@ void PAD_GetStatus(u8 _numPAD, SPADStatus* _pPADStatus)
_pPADStatus->substickY = sub_stick_y;
}
///////////////////////////////////////////////////
// The L and R triggers
// -----------
@ -500,7 +500,7 @@ void PAD_GetStatus(u8 _numPAD, SPADStatus* _pPADStatus)
if (TriggerRight > 0xf0) _pPADStatus->button |= PAD_TRIGGER_R;
///////////////////////////////////////////////////
// The digital buttons
// -----------
if (PadState[_numPAD].buttons[InputCommon::CTL_A_BUTTON])
@ -519,7 +519,7 @@ void PAD_GetStatus(u8 _numPAD, SPADStatus* _pPADStatus)
if (PadState[_numPAD].buttons[InputCommon::CTL_START]) _pPADStatus->button|=PAD_BUTTON_START;
///////////////////////////////////////////////////
// The D-pad
// -----------
if (PadMapping[_numPAD].controllertype == InputCommon::CTL_DPAD_HAT)
@ -593,7 +593,7 @@ void PAD_GetStatus(u8 _numPAD, SPADStatus* _pPADStatus)
//******************************************************************************
//////////////////////////////////////////////////////////////////////////////////////////
// Search for SDL devices
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
bool Search_Devices(std::vector<InputCommon::CONTROLLER_INFO> &_joyinfo, int &_NumPads, int &_NumGoodPads)
@ -622,7 +622,7 @@ bool Search_Devices(std::vector<InputCommon::CONTROLLER_INFO> &_joyinfo, int &_N
}
//////////////////////////////////////////////////////////////////////////////////////////
/* Check if any of the pads failed to open. In Windows there is a strange "IDirectInputDevice2::
SetDataFormat() DirectX error -2147024809" after exactly four SDL_Init() and SDL_Quit() */
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
@ -652,7 +652,7 @@ bool ReloadDLL()
return false;
}
//////////////////////////////////////////////////////////////////////////////////////////
// Check if Dolphin is in focus
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
bool IsFocus()

26
Source/Plugins/Plugin_nJoy_SDL/Src/nJoy.h
View File

@ -1,4 +1,4 @@
//////////////////////////////////////////////////////////////////////////////////////////
// Project description
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// Name: nJoy
@ -8,7 +8,7 @@
// Site: www.multigesture.net
// Copyright (C) 2003 Dolphin Project.
//
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
@ -27,13 +27,13 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
#ifndef __NJOY_h__
#define __NJOY_h__
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
// ¯¯¯¯¯¯¯¯¯¯
#include <vector> // System
@ -75,10 +75,10 @@
#ifdef __linux__
#include <linux/input.h>
#endif
//////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Define
// ¯¯¯¯¯¯¯¯¯¯
@ -90,7 +90,7 @@
#define THANKYOU wxT("`plot`, Absolute0, Aprentice, Bositman, Brice, ChaosCode, CKemu, CoDeX, Dave2001, dn, drk||Raziel, Florin, Gent, Gigaherz, Hacktarux, JegHegy, Linker, Linuzappz, Martin64, Muad, Knuckles, Raziel, Refraction, Rudy_x, Shadowprince, Snake785, Saqib, vEX, yaz0r, Zilmar, Zenogais and ZeZu.")
#define PLUGIN_VER_STR wxT("nJoy v")wxT(INPUT_VERSION)wxT(" by Falcon4ever\nRelease: ") RELDAY wxT("/") RELMONTH wxT("/") RELYEAR wxT("\nwww.multigesture.net")
//////////////////////////////////////////////////////////////////////////////////////////
// Input vector. Todo: Save the configured keys here instead of in joystick
// ¯¯¯¯¯¯¯¯¯
/*
@ -101,7 +101,7 @@ extern std::vector<u8> Keys;
//////////////////////////////////////////////////////////////////////////////////////////
// Variables
// ¯¯¯¯¯¯¯¯¯
#ifndef _EXCLUDE_MAIN_
@ -115,10 +115,10 @@ extern std::vector<u8> Keys;
#endif
extern int NumPads, NumGoodPads, LastPad; // Number of goods pads
#endif
////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Custom Functions
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
bool Search_Devices(std::vector<InputCommon::CONTROLLER_INFO> &_joyinfo, int &_NumPads, int &_NumGoodPads);
@ -130,10 +130,10 @@ bool ReloadDLL();
HRESULT InitRumble(HWND hWnd);
#endif
////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// ReRecording
// ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
#ifdef RERECORDING
@ -148,7 +148,7 @@ namespace Recording
void RecordInput(const SPADStatus& _rPADStatus);
}
#endif
////////////////////////////////
#endif // __NJOY_h__