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

Merge branch 'master' into wii-network

This commit is contained in:
Matthew Parlane 2013-02-01 01:32:54 +13:00
parent a0a09ed07a e199d21513
commit 33b0a11747
17 changed files with 127 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
CMakeLists.txt
View File

@ -109,33 +109,41 @@ endif()
# Various compile flags # Various compile flags
add_definitions(-msse2) add_definitions(-msse2)
include(CheckCXXCompilerFlag)
macro(check_and_add_flag var flag)
CHECK_CXX_COMPILER_FLAG(${flag} FLAG_${var})
if(FLAG_${var})
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}")
endif()
endmacro()
# Enabling all warnings in MSVC spams too much # Enabling all warnings in MSVC spams too much
if(NOT MSVC) if(NOT MSVC)
add_definitions(-Wall) add_definitions(-Wall)
# TODO: would like these but they produce overwhelming amounts of warnings
#check_and_add_flag(EXTRA -Wextra)
#check_and_add_flag(MISSING_FIELD_INITIALIZERS -Wmissing-field-initializers)
#check_and_add_flag(SWITCH_DEFAULT -Wswitch-default)
#check_and_add_flag(FLOAT_EQUAL -Wfloat-equal)
#check_and_add_flag(CONVERSION -Wconversion)
#check_and_add_flag(ZERO_AS_NULL_POINTER_CONSTANT -Wzero-as-null-pointer-constant)
check_and_add_flag(TYPE_LIMITS -Wtype-limits)
check_and_add_flag(SIGN_COMPARE -Wsign-compare)
check_and_add_flag(IGNORED_QUALIFIERS -Wignored-qualifiers)
check_and_add_flag(UNINITIALIZED -Wuninitialized)
check_and_add_flag(LOGICAL_OP -Wlogical-op)
check_and_add_flag(SHADOW -Wshadow)
check_and_add_flag(INIT_SELF -Winit-self)
endif(NOT MSVC) endif(NOT MSVC)
# gcc uses some optimizations which might break stuff without this flag # gcc uses some optimizations which might break stuff without this flag
add_definitions(-fno-strict-aliasing -fno-exceptions -Wno-psabi) add_definitions(-fno-strict-aliasing -fno-exceptions)
include(CheckCXXCompilerFlag) check_and_add_flag(VISIBILITY_INLINES_HIDDEN -fvisibility-inlines-hidden)
# We call fread numerous times without checking return values. Hide the
# corresponding compiler warnings if the compiler supports doing so.
CHECK_CXX_COMPILER_FLAG(-Wunused-result NO_UNUSED_RESULT)
if(NO_UNUSED_RESULT)
add_definitions(-Wno-unused-result)
endif(NO_UNUSED_RESULT)
CHECK_CXX_COMPILER_FLAG(-fvisibility-inlines-hidden VISIBILITY_INLINES_HIDDEN)
if(VISIBILITY_INLINES_HIDDEN)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility-inlines-hidden")
endif(VISIBILITY_INLINES_HIDDEN)
if(UNIX AND NOT APPLE) if(UNIX AND NOT APPLE)
CHECK_CXX_COMPILER_FLAG(-fvisibility=hidden VISIBILITY_HIDDEN) check_and_add_flag(VISIBILITY_HIDDEN -fvisibility=hidden)
if(VISIBILITY_HIDDEN)
add_definitions(-fvisibility=hidden)
endif(VISIBILITY_HIDDEN)
endif() endif()
if(APPLE) if(APPLE)

70
Source/Core/AudioCommon/Src/DPL2Decoder.cpp
View File

@ -232,70 +232,70 @@ float passive_lock(float x)
void matrix_decode(const float *in, const int k, const int il, void matrix_decode(const float *in, const int k, const int il,
const int ir, bool decode_rear, const int ir, bool decode_rear,
const int dlbuflen, const int _dlbuflen,
float l_fwr, float r_fwr, float _l_fwr, float _r_fwr,
float lpr_fwr, float lmr_fwr, float _lpr_fwr, float _lmr_fwr,
float *adapt_l_gain, float *adapt_r_gain, float *_adapt_l_gain, float *_adapt_r_gain,
float *adapt_lpr_gain, float *adapt_lmr_gain, float *_adapt_lpr_gain, float *_adapt_lmr_gain,
float *lf, float *rf, float *lr, float *_lf, float *_rf, float *_lr,
float *rr, float *cf) float *_rr, float *_cf)
{ {
static const float M9_03DB = 0.3535533906f; static const float M9_03DB = 0.3535533906f;
static const float MATAGCTRIG = 8.0f; /* (Fuzzy) AGC trigger */ static const float MATAGCTRIG = 8.0f; /* (Fuzzy) AGC trigger */
static const float MATAGCDECAY = 1.0f; /* AGC baseline decay rate (1/samp.) */ static const float MATAGCDECAY = 1.0f; /* AGC baseline decay rate (1/samp.) */
static const float MATCOMPGAIN = 0.37f; /* Cross talk compensation gain, 0.50 - 0.55 is full cancellation. */ static const float MATCOMPGAIN = 0.37f; /* Cross talk compensation gain, 0.50 - 0.55 is full cancellation. */
const int kr = (k + olddelay) % dlbuflen; const int kr = (k + olddelay) % _dlbuflen;
float l_gain = (l_fwr + r_fwr) / (1 + l_fwr + l_fwr); float l_gain = (_l_fwr + _r_fwr) / (1 + _l_fwr + _l_fwr);
float r_gain = (l_fwr + r_fwr) / (1 + r_fwr + r_fwr); float r_gain = (_l_fwr + _r_fwr) / (1 + _r_fwr + _r_fwr);
/* The 2nd axis has strong gain fluctuations, and therefore require /* The 2nd axis has strong gain fluctuations, and therefore require
limits. The factor corresponds to the 1 / amplification of (Lt limits. The factor corresponds to the 1 / amplification of (Lt
- Rt) when (Lt, Rt) is strongly correlated. (e.g. during - Rt) when (Lt, Rt) is strongly correlated. (e.g. during
dialogues). It should be bigger than -12 dB to prevent dialogues). It should be bigger than -12 dB to prevent
distortion. */ distortion. */
float lmr_lim_fwr = lmr_fwr > M9_03DB * lpr_fwr ? lmr_fwr : M9_03DB * lpr_fwr; float lmr_lim_fwr = _lmr_fwr > M9_03DB * _lpr_fwr ? _lmr_fwr : M9_03DB * _lpr_fwr;
float lpr_gain = (lpr_fwr + lmr_lim_fwr) / (1 + lpr_fwr + lpr_fwr); float lpr_gain = (_lpr_fwr + lmr_lim_fwr) / (1 + _lpr_fwr + _lpr_fwr);
float lmr_gain = (lpr_fwr + lmr_lim_fwr) / (1 + lmr_lim_fwr + lmr_lim_fwr); float lmr_gain = (_lpr_fwr + lmr_lim_fwr) / (1 + lmr_lim_fwr + lmr_lim_fwr);
float lmr_unlim_gain = (lpr_fwr + lmr_fwr) / (1 + lmr_fwr + lmr_fwr); float lmr_unlim_gain = (_lpr_fwr + _lmr_fwr) / (1 + _lmr_fwr + _lmr_fwr);
float lpr, lmr; float lpr, lmr;
float l_agc, r_agc, lpr_agc, lmr_agc; float l_agc, r_agc, lpr_agc, lmr_agc;
float f, d_gain, c_gain, c_agc_cfk; float f, d_gain, c_gain, c_agc_cfk;
/*** AXIS NO. 1: (Lt, Rt) -> (C, Ls, Rs) ***/ /*** AXIS NO. 1: (Lt, Rt) -> (C, Ls, Rs) ***/
/* AGC adaption */ /* AGC adaption */
d_gain = (fabs(l_gain - *adapt_l_gain) + fabs(r_gain - *adapt_r_gain)) * 0.5f; d_gain = (fabs(l_gain - *_adapt_l_gain) + fabs(r_gain - *_adapt_r_gain)) * 0.5f;
f = d_gain * (1.0f / MATAGCTRIG); f = d_gain * (1.0f / MATAGCTRIG);
f = MATAGCDECAY - MATAGCDECAY / (1 + f * f); f = MATAGCDECAY - MATAGCDECAY / (1 + f * f);
*adapt_l_gain = (1 - f) * *adapt_l_gain + f * l_gain; *_adapt_l_gain = (1 - f) * *_adapt_l_gain + f * l_gain;
*adapt_r_gain = (1 - f) * *adapt_r_gain + f * r_gain; *_adapt_r_gain = (1 - f) * *_adapt_r_gain + f * r_gain;
/* Matrix */ /* Matrix */
l_agc = in[il] * passive_lock(*adapt_l_gain); l_agc = in[il] * passive_lock(*_adapt_l_gain);
r_agc = in[ir] * passive_lock(*adapt_r_gain); r_agc = in[ir] * passive_lock(*_adapt_r_gain);
cf[k] = (l_agc + r_agc) * (float)M_SQRT1_2; _cf[k] = (l_agc + r_agc) * (float)M_SQRT1_2;
if (decode_rear) if (decode_rear)
{ {
lr[kr] = rr[kr] = (l_agc - r_agc) * (float)M_SQRT1_2; _lr[kr] = _rr[kr] = (l_agc - r_agc) * (float)M_SQRT1_2;
/* Stereo rear channel is steered with the same AGC steering as /* Stereo rear channel is steered with the same AGC steering as
the decoding matrix. Note this requires a fast updating AGC the decoding matrix. Note this requires a fast updating AGC
at the order of 20 ms (which is the case here). */ at the order of 20 ms (which is the case here). */
lr[kr] *= (l_fwr + l_fwr) / (1 + l_fwr + r_fwr); _lr[kr] *= (_l_fwr + _l_fwr) / (1 + _l_fwr + _r_fwr);
rr[kr] *= (r_fwr + r_fwr) / (1 + l_fwr + r_fwr); _rr[kr] *= (_r_fwr + _r_fwr) / (1 + _l_fwr + _r_fwr);
} }
/*** AXIS NO. 2: (Lt + Rt, Lt - Rt) -> (L, R) ***/ /*** AXIS NO. 2: (Lt + Rt, Lt - Rt) -> (L, R) ***/
lpr = (in[il] + in[ir]) * (float)M_SQRT1_2; lpr = (in[il] + in[ir]) * (float)M_SQRT1_2;
lmr = (in[il] - in[ir]) * (float)M_SQRT1_2; lmr = (in[il] - in[ir]) * (float)M_SQRT1_2;
/* AGC adaption */ /* AGC adaption */
d_gain = fabs(lmr_unlim_gain - *adapt_lmr_gain); d_gain = fabs(lmr_unlim_gain - *_adapt_lmr_gain);
f = d_gain * (1.0f / MATAGCTRIG); f = d_gain * (1.0f / MATAGCTRIG);
f = MATAGCDECAY - MATAGCDECAY / (1 + f * f); f = MATAGCDECAY - MATAGCDECAY / (1 + f * f);
*adapt_lpr_gain = (1 - f) * *adapt_lpr_gain + f * lpr_gain; *_adapt_lpr_gain = (1 - f) * *_adapt_lpr_gain + f * lpr_gain;
*adapt_lmr_gain = (1 - f) * *adapt_lmr_gain + f * lmr_gain; *_adapt_lmr_gain = (1 - f) * *_adapt_lmr_gain + f * lmr_gain;
/* Matrix */ /* Matrix */
lpr_agc = lpr * passive_lock(*adapt_lpr_gain); lpr_agc = lpr * passive_lock(*_adapt_lpr_gain);
lmr_agc = lmr * passive_lock(*adapt_lmr_gain); lmr_agc = lmr * passive_lock(*_adapt_lmr_gain);
lf[k] = (lpr_agc + lmr_agc) * (float)M_SQRT1_2; _lf[k] = (lpr_agc + lmr_agc) * (float)M_SQRT1_2;
rf[k] = (lpr_agc - lmr_agc) * (float)M_SQRT1_2; _rf[k] = (lpr_agc - lmr_agc) * (float)M_SQRT1_2;
/*** CENTER FRONT CANCELLATION ***/ /*** CENTER FRONT CANCELLATION ***/
/* A heuristic approach exploits that Lt + Rt gain contains the /* A heuristic approach exploits that Lt + Rt gain contains the
@ -303,16 +303,16 @@ void matrix_decode(const float *in, const int k, const int il,
the front and rear "cones" to concentrate Lt + Rt to C and the front and rear "cones" to concentrate Lt + Rt to C and
introduce Lt - Rt in L, R. */ introduce Lt - Rt in L, R. */
/* 0.67677 is the empirical lower bound for lpr_gain. */ /* 0.67677 is the empirical lower bound for lpr_gain. */
c_gain = 8 * (*adapt_lpr_gain - 0.67677f); c_gain = 8 * (*_adapt_lpr_gain - 0.67677f);
c_gain = c_gain > 0 ? c_gain : 0; c_gain = c_gain > 0 ? c_gain : 0;
/* c_gain should not be too high, not even reaching full /* c_gain should not be too high, not even reaching full
cancellation (~ 0.50 - 0.55 at current AGC implementation), or cancellation (~ 0.50 - 0.55 at current AGC implementation), or
the center will sound too narrow. */ the center will sound too narrow. */
c_gain = MATCOMPGAIN / (1 + c_gain * c_gain); c_gain = MATCOMPGAIN / (1 + c_gain * c_gain);
c_agc_cfk = c_gain * cf[k]; c_agc_cfk = c_gain * _cf[k];
lf[k] -= c_agc_cfk; _lf[k] -= c_agc_cfk;
rf[k] -= c_agc_cfk; _rf[k] -= c_agc_cfk;
cf[k] += c_agc_cfk + c_agc_cfk; _cf[k] += c_agc_cfk + c_agc_cfk;
} }
void dpl2decode(float *samples, int numsamples, float *out) void dpl2decode(float *samples, int numsamples, float *out)

2
Source/Core/AudioCommon/Src/Mixer.h
View File

@ -92,7 +92,7 @@ public:
std::mutex& MixerCritical() { return m_csMixing; } std::mutex& MixerCritical() { return m_csMixing; }
volatile float GetCurrentSpeed() const { return m_speed; } float GetCurrentSpeed() const { return m_speed; }
void UpdateSpeed(volatile float val) { m_speed = val; } void UpdateSpeed(volatile float val) { m_speed = val; }
protected: protected:

4
Source/Core/AudioCommon/Src/OpenALStream.cpp
View File

@ -316,7 +316,7 @@ void OpenALStream::SoundLoop()
if (iBuffersFilled == numBuffers) if (iBuffersFilled == numBuffers)
{ {
alSourcePlay(uiSource); alSourcePlay(uiSource);
ALenum err = alGetError(); err = alGetError();
if (err != 0) if (err != 0)
{ {
ERROR_LOG(AUDIO, "Error occurred during playback: %08x", err); ERROR_LOG(AUDIO, "Error occurred during playback: %08x", err);
@ -328,7 +328,7 @@ void OpenALStream::SoundLoop()
{ {
// Buffer underrun occurred, resume playback // Buffer underrun occurred, resume playback
alSourcePlay(uiSource); alSourcePlay(uiSource);
ALenum err = alGetError(); err = alGetError();
if (err != 0) if (err != 0)
{ {
ERROR_LOG(AUDIO, "Error occurred resuming playback: %08x", err); ERROR_LOG(AUDIO, "Error occurred resuming playback: %08x", err);

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

@ -171,9 +171,9 @@ bool InstallCodeHandler()
Memory::Write_U8(1, 0x80001807); Memory::Write_U8(1, 0x80001807);
// Invalidate the icache // Invalidate the icache
for (unsigned int i = 0; i < data.length(); i += 32) for (unsigned int j = 0; j < data.length(); j += 32)
{ {
PowerPC::ppcState.iCache.Invalidate(0x80001800 + i); PowerPC::ppcState.iCache.Invalidate(0x80001800 + j);
} }
return true; return true;
} }

2
Source/Core/Core/Src/HW/EXI_DeviceIPL.h
View File

@ -78,7 +78,7 @@ private:
virtual void TransferByte(u8 &_uByte); virtual void TransferByte(u8 &_uByte);
bool IsWriteCommand() const { return !!(m_uAddress & (1 << 31)); } bool IsWriteCommand() const { return !!(m_uAddress & (1 << 31)); }
const u32 CommandRegion() const { return (m_uAddress & ~(1 << 31)) >> 8; } u32 CommandRegion() const { return (m_uAddress & ~(1 << 31)) >> 8; }
void LoadFileToIPL(std::string filename, u32 offset); void LoadFileToIPL(std::string filename, u32 offset);
}; };

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

@ -144,8 +144,8 @@ void Preset(bool _bNTSC)
m_HorizontalStepping.FbSteps = 40; m_HorizontalStepping.FbSteps = 40;
m_HorizontalStepping.FieldSteps = 40; m_HorizontalStepping.FieldSteps = 40;
m_HBeamPos = 0; m_HBeamPos = -1; // NTSC-U N64 VC games check for a non-zero HBeamPos
m_VBeamPos = 0; m_VBeamPos = 0; // RG4JC0 checks for a zero VBeamPos
// 54MHz, capable of progressive scan // 54MHz, capable of progressive scan
m_Clock = Core::g_CoreStartupParameter.bProgressive; m_Clock = Core::g_CoreStartupParameter.bProgressive;

10
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE.cpp
View File

@ -402,18 +402,18 @@ void ExecuteCommand(u32 _Address)
} }
else else
{ {
IWII_IPC_HLE_Device* pDevice = CreateFileIO(DeviceID, DeviceName); IWII_IPC_HLE_Device* _pDevice = CreateFileIO(DeviceID, DeviceName);
CmdSuccess = pDevice->Open(_Address, Mode); CmdSuccess = _pDevice->Open(_Address, Mode);
INFO_LOG(WII_IPC_FILEIO, "IOP: Open File (Device=%s, ID=%08x, Mode=%i)", INFO_LOG(WII_IPC_FILEIO, "IOP: Open File (Device=%s, ID=%08x, Mode=%i)",
pDevice->GetDeviceName().c_str(), DeviceID, Mode); _pDevice->GetDeviceName().c_str(), DeviceID, Mode);
if (Memory::Read_U32(_Address + 4) == (u32)DeviceID) if (Memory::Read_U32(_Address + 4) == (u32)DeviceID)
{ {
g_FdMap[DeviceID] = pDevice; g_FdMap[DeviceID] = _pDevice;
} }
else else
{ {
delete pDevice; delete _pDevice;
} }
} }

3
Source/Core/Core/Src/PowerPC/Jit64/Jit_LoadStore.cpp
View File

@ -140,13 +140,12 @@ void Jit64::lXXx(UGeckoInstruction inst)
gpr.UnlockAll(); gpr.UnlockAll();
gpr.Flush(FLUSH_ALL); gpr.Flush(FLUSH_ALL);
fpr.Flush(FLUSH_ALL);
// if it's still 0, we can wait until the next event // if it's still 0, we can wait until the next event
TEST(32, R(EAX), R(EAX)); TEST(32, R(EAX), R(EAX));
FixupBranch noIdle = J_CC(CC_NZ); FixupBranch noIdle = J_CC(CC_NZ);
gpr.Flush(FLUSH_ALL);
fpr.Flush(FLUSH_ALL);
ABI_CallFunctionC((void *)&PowerPC::OnIdle, PowerPC::ppcState.gpr[a] + (s32)(s16)inst.SIMM_16); ABI_CallFunctionC((void *)&PowerPC::OnIdle, PowerPC::ppcState.gpr[a] + (s32)(s16)inst.SIMM_16);
// ! we must continue executing of the loop after exception handling, maybe there is still 0 in r0 // ! we must continue executing of the loop after exception handling, maybe there is still 0 in r0

4
Source/Core/Core/Src/PowerPC/Jit64IL/JitILAsm.cpp
View File

@ -71,7 +71,7 @@ void JitILAsmRoutineManager::Generate()
#endif #endif
// INT3(); // INT3();
const u8 *outerLoop = GetCodePtr(); const u8 *outer_loop = GetCodePtr();
ABI_CallFunction(reinterpret_cast<void *>(&CoreTiming::Advance)); ABI_CallFunction(reinterpret_cast<void *>(&CoreTiming::Advance));
FixupBranch skipToRealDispatch = J(); //skip the sync and compare first time FixupBranch skipToRealDispatch = J(); //skip the sync and compare first time
@ -220,7 +220,7 @@ void JitILAsmRoutineManager::Generate()
MOV(32, M(&PC), R(EAX)); MOV(32, M(&PC), R(EAX));
TEST(32, M((void*)PowerPC::GetStatePtr()), Imm32(0xFFFFFFFF)); TEST(32, M((void*)PowerPC::GetStatePtr()), Imm32(0xFFFFFFFF));
J_CC(CC_Z, outerLoop, true); J_CC(CC_Z, outer_loop, true);
//Landing pad for drec space //Landing pad for drec space
ABI_PopAllCalleeSavedRegsAndAdjustStack(); ABI_PopAllCalleeSavedRegsAndAdjustStack();
RET(); RET();

6
Source/Core/DiscIO/Src/VolumeWad.cpp
View File

@ -129,10 +129,10 @@ bool CVolumeWAD::GetWName(std::vector<std::wstring>& _rwNames) const
_rwNames.push_back(L""); _rwNames.push_back(L"");
continue; continue;
} }
for (int i = 0; i < 42; ++i) for (int j = 0; j < 42; ++j)
{ {
u16 t = Common::swap16(temp[i]); u16 t = Common::swap16(temp[j]);
if (t == 0 && i > 0) if (t == 0 && j > 0)
{ {
if (out_temp.at(out_temp.size()-1) != ' ') if (out_temp.at(out_temp.size()-1) != ' ')
out_temp.push_back(' '); out_temp.push_back(' ');

13
Source/Core/DolphinWX/Src/FifoPlayerDlg.cpp
View File

@ -483,8 +483,7 @@ void FifoPlayerDlg::OnBeginSearch(wxCommandEvent& event)
SearchResult result; SearchResult result;
result.frame_idx = frame_idx; result.frame_idx = frame_idx;
int obj_idx = m_objectsList->GetSelection(); result.obj_idx = m_objectsList->GetSelection();
result.obj_idx = obj_idx;
result.cmd_idx = 0; result.cmd_idx = 0;
for (unsigned int cmd_idx = 1; cmd_idx < m_objectCmdOffsets.size(); ++cmd_idx) for (unsigned int cmd_idx = 1; cmd_idx < m_objectCmdOffsets.size(); ++cmd_idx)
{ {
@ -642,8 +641,8 @@ void FifoPlayerDlg::OnObjectListSelectionChanged(wxCommandEvent& event)
{ {
m_objectCmdOffsets.push_back(objectdata - objectdata_start); m_objectCmdOffsets.push_back(objectdata - objectdata_start);
int new_offset = objectdata - &fifo_frame.fifoData[frame.objectStarts[0]]; int new_offset = objectdata - &fifo_frame.fifoData[frame.objectStarts[0]];
int cmd = *objectdata++; int command = *objectdata++;
switch (cmd) switch (command)
{ {
case GX_NOP: case GX_NOP:
newLabel = _("NOP"); newLabel = _("NOP");
@ -691,9 +690,9 @@ void FifoPlayerDlg::OnObjectListSelectionChanged(wxCommandEvent& event)
case GX_LOAD_INDX_C: case GX_LOAD_INDX_C:
case GX_LOAD_INDX_D: case GX_LOAD_INDX_D:
objectdata += 4; objectdata += 4;
newLabel = wxString::Format(wxT("LOAD INDX %s"), (cmd == GX_LOAD_INDX_A) ? _("A") : newLabel = wxString::Format(wxT("LOAD INDX %s"), (command == GX_LOAD_INDX_A) ? _("A") :
(cmd == GX_LOAD_INDX_B) ? _("B") : (command == GX_LOAD_INDX_B) ? _("B") :
(cmd == GX_LOAD_INDX_C) ? _("C") : _("D")); (command == GX_LOAD_INDX_C) ? _("C") : _("D"));
break; break;
case GX_CMD_CALL_DL: case GX_CMD_CALL_DL:

6
Source/Core/DolphinWX/Src/TASInputDlg.cpp
View File

@ -1099,8 +1099,8 @@ wxBitmap TASInputDlg::CreateStickBitmap(int x, int y)
y = y/2; y = y/2;
wxMemoryDC memDC; wxMemoryDC memDC;
wxBitmap bitmap(127, 127); wxBitmap stick_bitmap(127, 127);
memDC.SelectObject(bitmap); memDC.SelectObject(stick_bitmap);
memDC.SetBackground(*wxLIGHT_GREY_BRUSH); memDC.SetBackground(*wxLIGHT_GREY_BRUSH);
memDC.Clear(); memDC.Clear();
memDC.SetBrush(*wxWHITE_BRUSH); memDC.SetBrush(*wxWHITE_BRUSH);
@ -1116,5 +1116,5 @@ wxBitmap TASInputDlg::CreateStickBitmap(int x, int y)
memDC.SetBrush(*wxBLUE_BRUSH); memDC.SetBrush(*wxBLUE_BRUSH);
memDC.DrawCircle(x,y,5); memDC.DrawCircle(x,y,5);
memDC.SelectObject(wxNullBitmap); memDC.SelectObject(wxNullBitmap);
return bitmap; return stick_bitmap;
} }

26
Source/Core/VideoCommon/Src/TextureCacheBase.h
View File

@ -60,26 +60,26 @@ public:
int frameCount; int frameCount;
void SetGeneralParameters(u32 addr, u32 size, u32 format, unsigned int num_mipmaps) void SetGeneralParameters(u32 _addr, u32 _size, u32 _format, unsigned int _num_mipmaps)
{ {
this->addr = addr; addr = _addr;
this->size_in_bytes = size; size_in_bytes = _size;
this->format = format; format = _format;
this->num_mipmaps = num_mipmaps; num_mipmaps = _num_mipmaps;
} }
void SetDimensions(unsigned int native_width, unsigned int native_height, unsigned int virtual_width, unsigned int virtual_height) void SetDimensions(unsigned int _native_width, unsigned int _native_height, unsigned int _virtual_width, unsigned int _virtual_height)
{ {
this->native_width = native_width; native_width = _native_width;
this->native_height = native_height; native_height = _native_height;
this->virtual_width = virtual_width; virtual_width = _virtual_width;
this->virtual_height = virtual_height; virtual_height = _virtual_height;
} }
void SetHashes(u64 hash/*, u32 pal_hash*/) void SetHashes(u64 _hash/*, u32 _pal_hash*/)
{ {
this->hash = hash; hash = _hash;
//this->pal_hash = pal_hash; //pal_hash = _pal_hash;
} }

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

@ -1289,10 +1289,10 @@ void Renderer::Swap(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight,cons
if (FramebufferManagerBase::LastXfbWidth() != fbWidth || FramebufferManagerBase::LastXfbHeight() != fbHeight) if (FramebufferManagerBase::LastXfbWidth() != fbWidth || FramebufferManagerBase::LastXfbHeight() != fbHeight)
{ {
xfbchanged = true; xfbchanged = true;
unsigned int w = (fbWidth < 1 || fbWidth > MAX_XFB_WIDTH) ? MAX_XFB_WIDTH : fbWidth; unsigned int const last_w = (fbWidth < 1 || fbWidth > MAX_XFB_WIDTH) ? MAX_XFB_WIDTH : fbWidth;
unsigned int h = (fbHeight < 1 || fbHeight > MAX_XFB_HEIGHT) ? MAX_XFB_HEIGHT : fbHeight; unsigned int const last_h = (fbHeight < 1 || fbHeight > MAX_XFB_HEIGHT) ? MAX_XFB_HEIGHT : fbHeight;
FramebufferManagerBase::SetLastXfbWidth(w); FramebufferManagerBase::SetLastXfbWidth(last_w);
FramebufferManagerBase::SetLastXfbHeight(h); FramebufferManagerBase::SetLastXfbHeight(last_h);
} }
bool WindowResized = false; bool WindowResized = false;

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

@ -330,15 +330,15 @@ void TextureCache::TCacheEntry::FromRenderTarget(u32 dstAddr, unsigned int dstFo
srcRect); srcRect);
u8* dst = Memory::GetPointer(addr); u8* dst = Memory::GetPointer(addr);
u64 hash = GetHash64(dst,encoded_size,g_ActiveConfig.iSafeTextureCache_ColorSamples); u64 const new_hash = GetHash64(dst,encoded_size,g_ActiveConfig.iSafeTextureCache_ColorSamples);
// Mark texture entries in destination address range dynamic unless caching is enabled and the texture entry is up to date // Mark texture entries in destination address range dynamic unless caching is enabled and the texture entry is up to date
if (!g_ActiveConfig.bEFBCopyCacheEnable) if (!g_ActiveConfig.bEFBCopyCacheEnable)
TextureCache::MakeRangeDynamic(addr,encoded_size); TextureCache::MakeRangeDynamic(addr,encoded_size);
else if (!TextureCache::Find(addr, hash)) else if (!TextureCache::Find(addr, new_hash))
TextureCache::MakeRangeDynamic(addr,encoded_size); TextureCache::MakeRangeDynamic(addr,encoded_size);
this->hash = hash; hash = new_hash;
} }
FramebufferManager::SetFramebuffer(0); FramebufferManager::SetFramebuffer(0);

10
Source/Plugins/Plugin_VideoSoftware/Src/HwRasterizer.cpp
View File

@ -339,17 +339,17 @@ namespace HwRasterizer
texImage3.hex = texUnit.texImage3[0].hex; texImage3.hex = texUnit.texImage3[0].hex;
texTlut.hex = texUnit.texTlut[0].hex; texTlut.hex = texUnit.texTlut[0].hex;
int width = texImage0.width; int image_width = texImage0.width;
int height = texImage0.height; int image_height = texImage0.height;
DebugUtil::GetTextureBGRA(temp, 0, 0, width, height); DebugUtil::GetTextureBGRA(temp, 0, 0, image_width, image_height);
glGenTextures(1, (GLuint *)&texture); glGenTextures(1, (GLuint *)&texture);
glBindTexture(TEX2D, texture); glBindTexture(TEX2D, texture);
#ifdef USE_GLES #ifdef USE_GLES
glTexImage2D(TEX2D, 0, GL_RGBA, (GLsizei)width, (GLsizei)height, 0, GL_RGBA, GL_UNSIGNED_BYTE, temp); glTexImage2D(TEX2D, 0, GL_RGBA, (GLsizei)image_width, (GLsizei)image_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, temp);
#else #else
glTexImage2D(TEX2D, 0, GL_RGBA8, (GLsizei)width, (GLsizei)height, 0, GL_BGRA, GL_UNSIGNED_BYTE, temp); glTexImage2D(TEX2D, 0, GL_RGBA8, (GLsizei)image_width, (GLsizei)image_height, 0, GL_BGRA, GL_UNSIGNED_BYTE, temp);
#endif #endif
GL_REPORT_ERRORD(); GL_REPORT_ERRORD();
} }