Clean up more space/tab mismatches in AudioCommon, Common, and VideoCommon.

Not planning to touch Core since it's the most actively changed part of the project.

Source/Core/AudioCommon/Src/AlsaSoundStream.cpp

@@ -112,7 +112,7 @@ bool AlsaSound::AlsaInit()
 		return false;
 	}
 
-    err = snd_pcm_hw_params_set_format(handle, hwparams, SND_PCM_FORMAT_S16_LE);
+	err = snd_pcm_hw_params_set_format(handle, hwparams, SND_PCM_FORMAT_S16_LE);
 	if (err < 0) 
 	{
 		ERROR_LOG(AUDIO, "Sample format not available: %s\n", snd_strerror(err));
@@ -127,7 +127,7 @@ bool AlsaSound::AlsaInit()
 		return false;
 	}
 
-    err = snd_pcm_hw_params_set_channels(handle, hwparams, 2);
+	err = snd_pcm_hw_params_set_channels(handle, hwparams, 2);
 	if (err < 0) 
 	{
 		ERROR_LOG(AUDIO, "Channels count not available: %s\n", snd_strerror(err));
@@ -153,7 +153,7 @@ bool AlsaSound::AlsaInit()
 	err = snd_pcm_hw_params(handle, hwparams);
 	if (err < 0) 
 	{
-	    ERROR_LOG(AUDIO, "Unable to install hw params: %s\n", snd_strerror(err));
+		ERROR_LOG(AUDIO, "Unable to install hw params: %s\n", snd_strerror(err));
 		return false;
 	}
 
@@ -176,10 +176,10 @@ bool AlsaSound::AlsaInit()
 	frames_to_deliver = buffer_size / periods;
 	//limit the minimum size. pulseaudio advertises a minimum of 32 samples.
 	if (frames_to_deliver < FRAME_COUNT_MIN)
-	    frames_to_deliver = FRAME_COUNT_MIN;
+		frames_to_deliver = FRAME_COUNT_MIN;
 	//it is probably a bad idea to try to send more than one buffer of data
 	if ((unsigned int)frames_to_deliver > buffer_size)
-	    frames_to_deliver = buffer_size;
+		frames_to_deliver = buffer_size;
 	NOTICE_LOG(AUDIO, "ALSA gave us a %ld sample \"hardware\" buffer with %d periods. Will send %d samples per fragments.\n", buffer_size, periods, frames_to_deliver);
 
 	snd_pcm_sw_params_alloca(&swparams);
@@ -187,21 +187,21 @@ bool AlsaSound::AlsaInit()
 	err = snd_pcm_sw_params_current(handle, swparams);
 	if (err < 0) 
 	{
-	    ERROR_LOG(AUDIO, "cannot init sw params: %s\n", snd_strerror(err));
+		ERROR_LOG(AUDIO, "cannot init sw params: %s\n", snd_strerror(err));
 		return false;
 	}
 
 	err = snd_pcm_sw_params_set_start_threshold(handle, swparams, 0U);
 	if (err < 0) 
 	{
-	    ERROR_LOG(AUDIO, "cannot set start thresh: %s\n", snd_strerror(err));
+		ERROR_LOG(AUDIO, "cannot set start thresh: %s\n", snd_strerror(err));
 		return false;
 	}
 
 	err = snd_pcm_sw_params(handle, swparams);
 	if (err < 0) 
 	{
-	    ERROR_LOG(AUDIO, "cannot set sw params: %s\n", snd_strerror(err));
+		ERROR_LOG(AUDIO, "cannot set sw params: %s\n", snd_strerror(err));
 		return false;
 	}
 

Source/Core/AudioCommon/Src/DPL2Decoder.cpp

@@ -130,15 +130,15 @@ returns 0 if OK, -1 if fail
 */
 float* design_fir(unsigned int *n, float* fc, float opt)
 {
-	unsigned int  o   = *n & 1;            // Indicator for odd filter length
+	unsigned int  o   = *n & 1;              // Indicator for odd filter length
-	unsigned int  end = ((*n + 1) >> 1) - o;       // Loop end
+	unsigned int  end = ((*n + 1) >> 1) - o; // Loop end
-	unsigned int  i;                      // Loop index
+	unsigned int  i;                         // Loop index
 
-	float k1 = 2 * float(M_PI);             // 2*pi*fc1
+	float k1 = 2 * float(M_PI);              // 2*pi*fc1
-	float k2 = 0.5f * (float)(1 - o);// Constant used if the filter has even length
+	float k2 = 0.5f * (float)(1 - o);        // Constant used if the filter has even length
-	float g  = 0.0f;                    // Gain
+	float g  = 0.0f;                         // Gain
-	float t1;                     // Temporary variables
+	float t1;                                // Temporary variables
-	float fc1;                      // Cutoff frequencies
+	float fc1;                               // Cutoff frequencies
 
 	// Sanity check
 	if(*n==0) return NULL;
@@ -241,18 +241,18 @@ void matrix_decode(const float *in, const int k, const int il,
 	float *_rr, float *_cf)
 {
 	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. */
 
 	const int kr = (k + olddelay) % _dlbuflen;
 	float l_gain = (_l_fwr + _r_fwr) / (1 + _l_fwr + _l_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 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);
@@ -275,9 +275,9 @@ void matrix_decode(const float *in, const int k, const int il,
 	if (decode_rear)
 	{
 		_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);
 		_rr[kr] *= (_r_fwr + _r_fwr) / (1 + _l_fwr + _r_fwr);
 	}
@@ -298,16 +298,16 @@ void matrix_decode(const float *in, const int k, const int il,
 	_rf[k] = (lpr_agc - lmr_agc) * (float)M_SQRT1_2;
 
 	/*** CENTER FRONT CANCELLATION ***/
-	/* A heuristic approach exploits that Lt + Rt gain contains the
+	// A heuristic approach exploits that Lt + Rt gain contains the
-	information about Lt, Rt correlation.  This effectively reshapes
+	// information about Lt, Rt correlation.  This effectively reshapes
-	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. */
 	c_gain = 8 * (*_adapt_lpr_gain - 0.67677f);
 	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_agc_cfk = c_gain * _cf[k];
 	_lf[k] -= c_agc_cfk;
@@ -317,7 +317,7 @@ void matrix_decode(const float *in, const int k, const int il,
 
 void dpl2decode(float *samples, int numsamples, float *out)
 {
-	static const unsigned int FWRDURATION = 240;    /* FWR average duration (samples) */
+	static const unsigned int FWRDURATION = 240; // FWR average duration (samples)
 	static const int cfg_delay = 0;
 	static const unsigned int fmt_freq = 48000;
 	static const unsigned int fmt_nchannels = 2; // input channels

Source/Core/AudioCommon/Src/DSoundStream.cpp

@@ -122,7 +122,7 @@ void DSound::SoundLoop()
 bool DSound::Start()
 {
 	if (FAILED(DirectSoundCreate8(0, &ds, 0)))
-        return false;
+		return false;
 	if (hWnd)
 	{
 		HRESULT hr = ds->SetCooperativeLevel((HWND)hWnd, DSSCL_PRIORITY);

Source/Core/AudioCommon/Src/DSoundStream.h

@@ -31,33 +31,33 @@
 class DSound : public SoundStream
 {
 #ifdef _WIN32
-    std::thread thread;
+	std::thread thread;
-    Common::Event soundSyncEvent;
+	Common::Event soundSyncEvent;
-    void  *hWnd;
+	void  *hWnd;
 
-    IDirectSound8* ds;
+	IDirectSound8* ds;
-    IDirectSoundBuffer* dsBuffer;
+	IDirectSoundBuffer* dsBuffer;
 
-    int bufferSize;     //i bytes
+	int bufferSize;     //i bytes
 	int m_volume;
 
-    // playback position
+	// playback position
-    int currentPos;
+	int currentPos;
-    int lastPos;
+	int lastPos;
-    short realtimeBuffer[BUFSIZE / sizeof(short)];
+	short realtimeBuffer[BUFSIZE / sizeof(short)];
 
-    inline int FIX128(int x)
+	inline int FIX128(int x)
 	{
 		return x & (~127);
-    }
+	}
 
-    inline int ModBufferSize(int x)
+	inline int ModBufferSize(int x)
 	{
 		return (x + bufferSize) % bufferSize;
-    }
+	}
 
-    bool CreateBuffer();
+	bool CreateBuffer();
-    bool WriteDataToBuffer(DWORD dwOffset, char* soundData, DWORD dwSoundBytes);
+	bool WriteDataToBuffer(DWORD dwOffset, char* soundData, DWORD dwSoundBytes);
 
 public:
 	DSound(CMixer *mixer, void *_hWnd = NULL)
@@ -70,16 +70,16 @@ public:
 		, hWnd(_hWnd)
 	{}
 
-    virtual ~DSound() {}
+	virtual ~DSound() {}
  
 	virtual bool Start();
-    virtual void SoundLoop();
+	virtual void SoundLoop();
 	virtual void SetVolume(int volume);
-    virtual void Stop();
+	virtual void Stop();
 	virtual void Clear(bool mute);
-    static bool isValid() { return true; }
+	static bool isValid() { return true; }
-    virtual bool usesMixer() const { return true; }
+	virtual bool usesMixer() const { return true; }
-    virtual void Update();
+	virtual void Update();
 
 #else
 public:

Source/Core/AudioCommon/Src/Mixer.cpp

@@ -67,7 +67,7 @@ unsigned int CMixer::Mix(short* samples, unsigned int numSamples)
 			{
 				static const __m128i sr_mask =
 					_mm_set_epi32(0x0C0D0E0FL, 0x08090A0BL,
-						      0x04050607L, 0x00010203L);
+								  0x04050607L, 0x00010203L);
 
 				for (unsigned int i = 0; i < numLeft * 2; i += 8)
 				{
@@ -99,7 +99,6 @@ unsigned int CMixer::Mix(short* samples, unsigned int numSamples)
 				if ((m_indexR2 & INDEX_MASK) == (m_indexW & INDEX_MASK)) //..if it exists
 					m_indexR2 = m_indexR;
 
-				
 				s16 l1 = Common::swap16(m_buffer[m_indexR & INDEX_MASK]); //current
 				s16 l2 = Common::swap16(m_buffer[m_indexR2 & INDEX_MASK]); //next
 				int sampleL = ((l1 << 16) + (l2 - l1) * (u16)frac)  >> 16;
@@ -116,8 +115,6 @@ unsigned int CMixer::Mix(short* samples, unsigned int numSamples)
 			}
 		}
 
-
-
 	} else {
 		numLeft = 0;
 	}

Source/Core/AudioCommon/Src/NullSoundStream.h

@@ -25,24 +25,24 @@
 
 class NullSound : public SoundStream
 {
-    // playback position
+	// playback position
-    short realtimeBuffer[BUF_SIZE / sizeof(short)];
+	short realtimeBuffer[BUF_SIZE / sizeof(short)];
 
 public:
 	NullSound(CMixer *mixer, void *hWnd = NULL)
 		: SoundStream(mixer)
 	{}
 
-    virtual ~NullSound() {}
+	virtual ~NullSound() {}
 
 	virtual bool Start();
-    virtual void SoundLoop();
+	virtual void SoundLoop();
 	virtual void SetVolume(int volume);
-    virtual void Stop();
+	virtual void Stop();
 	virtual void Clear(bool mute);
-    static bool isValid() { return true; }
+	static bool isValid() { return true; }
-    virtual bool usesMixer() const { return true; }
+	virtual bool usesMixer() const { return true; }
-    virtual void Update();
+	virtual void Update();
 };
 
 #endif //_NULLSOUNDSTREAM_H_

Source/Core/AudioCommon/Src/OpenALStream.cpp

@@ -295,7 +295,6 @@ void OpenALStream::SoundLoop()
 						{
 							ERROR_LOG(AUDIO, "Error occurred while buffering float32 data: %08x", err);
 						}
-
 					}
 #endif
 					if (!float32_capable)
@@ -308,7 +307,6 @@ void OpenALStream::SoundLoop()
 							stereo[i * 2 + 1] = (short)((float)sampleBuffer[i * 2 + 1] * (1 << 16));
 						}
 						alBufferData(uiBufferTemp[iBuffersFilled], AL_FORMAT_STEREO16, stereo, nSamples * 2 * 2, ulFrequency);
-
 					}
 				}
 

Source/Core/AudioCommon/Src/SoundStream.h

@@ -27,10 +27,10 @@ class SoundStream
 protected:
 
 	CMixer *m_mixer;
-    // We set this to shut down the sound thread.
+	// We set this to shut down the sound thread.
-    // 0=keep playing, 1=stop playing NOW.
+	// 0=keep playing, 1=stop playing NOW.
-    volatile int threadData;
+	volatile int threadData;
-    bool m_logAudio;
+	bool m_logAudio;
 	WaveFileWriter g_wave_writer;
 	bool m_muted;
 

Source/Core/Common/Src/ArmEmitter.h

@@ -336,9 +336,9 @@ struct FixupBranch
 
 struct LiteralPool
 {
-    s32 loc;
+	s32 loc;
-    u8* ldr_address;
+	u8* ldr_address;
-    u32 val;
+	u32 val;
 };
 
 typedef const u8* JumpTarget;
@@ -468,7 +468,7 @@ public:
 	void BICS(ARMReg dest, ARMReg src, Operand2 op2);
 	void MVN (ARMReg dest,             Operand2 op2);
 	void MVNS(ARMReg dest,             Operand2 op2);
-	void MOVW(ARMReg dest, 			   Operand2 op2);
+	void MOVW(ARMReg dest,             Operand2 op2);
 	void MOVT(ARMReg dest, Operand2 op2, bool TopBits = false);
 
 	// UDIV and SDIV are only available on CPUs that have 

Source/Core/Common/Src/BreakPoints.h

@@ -27,9 +27,9 @@ class DebugInterface;
 
 struct TBreakPoint
 {
-	u32     iAddress;
+	u32		iAddress;
 	bool	bOn;
-	bool    bTemporary;
+	bool	bTemporary;
 };
 
 struct TMemCheck

Source/Core/Common/Src/ChunkFile.h

@@ -129,12 +129,12 @@ public:
 		DoContainer(x);
 	}
 
-    template <typename T>
+	template <typename T>
 	void DoArray(T* x, u32 count)
 	{
 		for (u32 i = 0; i != count; ++i)
 			Do(x[i]);
-    }
+	}
 
 	template <typename T>
 	void Do(T& x)

Source/Core/Common/Src/CommonFuncs.h

@@ -68,9 +68,9 @@ _mm_shuffle_epi8(__m128i a, __m128i mask)
 	#define ARRAYSIZE(A) (sizeof(A)/sizeof((A)[0]))
 
 inline u32 _rotl(u32 x, int shift) {
-    shift &= 31;
+	shift &= 31;
-    if (!shift) return x;
+	if (!shift) return x;
-    return (x << shift) | (x >> (32 - shift));
+	return (x << shift) | (x >> (32 - shift));
 }
 
 inline u64 _rotl64(u64 x, unsigned int shift){
@@ -79,9 +79,9 @@ inline u64 _rotl64(u64 x, unsigned int shift){
 }
 
 inline u32 _rotr(u32 x, int shift) {
-    shift &= 31;
+	shift &= 31;
-    if (!shift) return x;
+	if (!shift) return x;
-    return (x >> shift) | (x << (32 - shift));
+	return (x >> shift) | (x << (32 - shift));
 }
 
 inline u64 _rotr64(u64 x, unsigned int shift){

Source/Core/Common/Src/CommonPaths.h

@@ -127,9 +127,9 @@
 #define GC_MEMCARDA	"MemoryCardA"
 #define GC_MEMCARDB	"MemoryCardB"
 
-#define WII_STATE 	"state.dat"
+#define WII_STATE	"state.dat"
 
-#define WII_SETTING 	"setting.txt"
+#define WII_SETTING		"setting.txt"
 #define WII_EUR_SETTING "setting-eur.txt"
 #define WII_USA_SETTING "setting-usa.txt"
 #define WII_JAP_SETTING "setting-jpn.txt"

Source/Core/Common/Src/ExtendedTrace.h

@@ -25,7 +25,7 @@
 #pragma comment( lib, "imagehlp.lib" )
 
 #define EXTENDEDTRACEINITIALIZE( IniSymbolPath )	InitSymInfo( IniSymbolPath )
-#define EXTENDEDTRACEUNINITIALIZE()			        UninitSymInfo()
+#define EXTENDEDTRACEUNINITIALIZE()					UninitSymInfo()
 #define STACKTRACE(file)							StackTrace( GetCurrentThread(), "", file)
 #define STACKTRACE2(file, eip, esp, ebp) StackTrace(GetCurrentThread(), "", file, eip, esp, ebp)
 // class File;
@@ -43,10 +43,10 @@ extern char g_uefbuf[UEFBUFSIZE];
 
 #else	// not WIN32
 
-#define EXTENDEDTRACEINITIALIZE( IniSymbolPath )   ((void)0)
+#define EXTENDEDTRACEINITIALIZE( IniSymbolPath )	((void)0)
-#define EXTENDEDTRACEUNINITIALIZE()			         ((void)0)
+#define EXTENDEDTRACEUNINITIALIZE()					((void)0)
-#define STACKTRACE(file)						         	   ((void)0)
+#define STACKTRACE(file)							((void)0)
-#define STACKTRACE2(file, eip, esp, ebp) ((void)0)
+#define STACKTRACE2(file, eip, esp, ebp)			((void)0)
 
 #endif	// WIN32
 

Source/Core/Common/Src/FPURoundMode.h

@@ -38,11 +38,12 @@ namespace FPURoundMode
 	
 	void SetSIMDMode(u32 mode);
 
-	/*
+/*
-   There are two different flavors of float to int conversion:
+ * There are two different flavors of float to int conversion:
-   _mm_cvtps_epi32() and _mm_cvttps_epi32(). The first rounds
+ * _mm_cvtps_epi32() and _mm_cvttps_epi32(). 
-   according to the MXCSR rounding bits. The second one always
+ *
-   uses round towards zero.
+ * The first rounds according to the MXCSR rounding bits.
+ * The second one always uses round towards zero.
  */
 	void SaveSIMDState();
 	void LoadSIMDState();

Source/Core/Common/Src/FileUtil.cpp

@@ -605,7 +605,7 @@ std::string GetCurrentDir()
 	if (!(dir = __getcwd(NULL, 0))) {
 
 		ERROR_LOG(COMMON, "GetCurrentDirectory failed: %s",
-				  GetLastErrorMsg());
+				GetLastErrorMsg());
 		return NULL;
 	}
 	std::string strDir = dir;

Source/Core/Common/Src/Hash.cpp

@@ -119,7 +119,7 @@ u32 HashEctor(const u8* ptr, int length)
 
 inline u64 getblock(const u64 * p, int i)
 {
-        return p[i];
+	return p[i];
 }
 
 //----------
@@ -127,25 +127,25 @@ inline u64 getblock(const u64 * p, int i)
 
 inline void bmix64(u64 & h1, u64 & h2, u64 & k1, u64 & k2, u64 & c1, u64 & c2)
 {
-    k1 *= c1; 
+	k1 *= c1; 
-    k1  = _rotl64(k1,23); 
+	k1  = _rotl64(k1,23); 
-    k1 *= c2;
+	k1 *= c2;
-    h1 ^= k1;
+	h1 ^= k1;
-    h1 += h2;
+	h1 += h2;
 
-    h2 = _rotl64(h2,41);
+	h2 = _rotl64(h2,41);
 
-    k2 *= c2; 
+	k2 *= c2; 
-    k2  = _rotl64(k2,23);
+	k2  = _rotl64(k2,23);
-    k2 *= c1;
+	k2 *= c1;
-    h2 ^= k2;
+	h2 ^= k2;
-    h2 += h1;
+	h2 += h1;
 
-    h1 = h1*3+0x52dce729;
+	h1 = h1*3+0x52dce729;
-    h2 = h2*3+0x38495ab5;
+	h2 = h2*3+0x38495ab5;
 
-    c1 = c1*5+0x7b7d159c;
+	c1 = c1*5+0x7b7d159c;
-    c2 = c2*5+0x6bce6396;
+	c2 = c2*5+0x6bce6396;
 }
 
 //----------
@@ -153,87 +153,87 @@ inline void bmix64(u64 & h1, u64 & h2, u64 & k1, u64 & k2, u64 & c1, u64 & c2)
 
 inline u64 fmix64(u64 k)
 {
-    k ^= k >> 33;
+	k ^= k >> 33;
-    k *= 0xff51afd7ed558ccd;
+	k *= 0xff51afd7ed558ccd;
-    k ^= k >> 33;
+	k ^= k >> 33;
-    k *= 0xc4ceb9fe1a85ec53;
+	k *= 0xc4ceb9fe1a85ec53;
-    k ^= k >> 33;
+	k ^= k >> 33;
 
-    return k;
+	return k;
 }
 
 u64 GetMurmurHash3(const u8 *src, int len, u32 samples)
 {
-    const u8 * data = (const u8*)src;
+	const u8 * data = (const u8*)src;
-    const int nblocks = len / 16;
+	const int nblocks = len / 16;
 	u32 Step = (len / 8);
 	if(samples == 0) samples = max(Step, 1u);
 	Step = Step / samples;
 	if(Step < 1) Step = 1;
 
-    u64 h1 = 0x9368e53c2f6af274;
+	u64 h1 = 0x9368e53c2f6af274;
-    u64 h2 = 0x586dcd208f7cd3fd;
+	u64 h2 = 0x586dcd208f7cd3fd;
 
-    u64 c1 = 0x87c37b91114253d5;
+	u64 c1 = 0x87c37b91114253d5;
-    u64 c2 = 0x4cf5ad432745937f;
+	u64 c2 = 0x4cf5ad432745937f;
 
 
-    //----------
+	//----------
-    // body
+	// body
 
-    const u64 * blocks = (const u64 *)(data);
+	const u64 * blocks = (const u64 *)(data);
 
-    for(int i = 0; i < nblocks; i+=Step)
+	for(int i = 0; i < nblocks; i+=Step)
-    {
+	{
-        u64 k1 = getblock(blocks,i*2+0);
+		u64 k1 = getblock(blocks,i*2+0);
-        u64 k2 = getblock(blocks,i*2+1);
+		u64 k2 = getblock(blocks,i*2+1);
 
-        bmix64(h1,h2,k1,k2,c1,c2);
+		bmix64(h1,h2,k1,k2,c1,c2);
-    }
+	}
 
-    //----------
+	//----------
-    // tail
+	// tail
 
-    const u8 * tail = (const u8*)(data + nblocks*16);
+	const u8 * tail = (const u8*)(data + nblocks*16);
 
-    u64 k1 = 0;
+	u64 k1 = 0;
-    u64 k2 = 0;
+	u64 k2 = 0;
 
-    switch(len & 15)
+	switch(len & 15)
-    {
+	{
-    case 15: k2 ^= u64(tail[14]) << 48;
+	case 15: k2 ^= u64(tail[14]) << 48;
-    case 14: k2 ^= u64(tail[13]) << 40;
+	case 14: k2 ^= u64(tail[13]) << 40;
-    case 13: k2 ^= u64(tail[12]) << 32;
+	case 13: k2 ^= u64(tail[12]) << 32;
-    case 12: k2 ^= u64(tail[11]) << 24;
+	case 12: k2 ^= u64(tail[11]) << 24;
-    case 11: k2 ^= u64(tail[10]) << 16;
+	case 11: k2 ^= u64(tail[10]) << 16;
-    case 10: k2 ^= u64(tail[ 9]) << 8;
+	case 10: k2 ^= u64(tail[ 9]) << 8;
-    case  9: k2 ^= u64(tail[ 8]) << 0;
+	case  9: k2 ^= u64(tail[ 8]) << 0;
 
-    case  8: k1 ^= u64(tail[ 7]) << 56;
+	case  8: k1 ^= u64(tail[ 7]) << 56;
-    case  7: k1 ^= u64(tail[ 6]) << 48;
+	case  7: k1 ^= u64(tail[ 6]) << 48;
-    case  6: k1 ^= u64(tail[ 5]) << 40;
+	case  6: k1 ^= u64(tail[ 5]) << 40;
-    case  5: k1 ^= u64(tail[ 4]) << 32;
+	case  5: k1 ^= u64(tail[ 4]) << 32;
-    case  4: k1 ^= u64(tail[ 3]) << 24;
+	case  4: k1 ^= u64(tail[ 3]) << 24;
-    case  3: k1 ^= u64(tail[ 2]) << 16;
+	case  3: k1 ^= u64(tail[ 2]) << 16;
-    case  2: k1 ^= u64(tail[ 1]) << 8;
+	case  2: k1 ^= u64(tail[ 1]) << 8;
-    case  1: k1 ^= u64(tail[ 0]) << 0;
+	case  1: k1 ^= u64(tail[ 0]) << 0;
-             bmix64(h1,h2,k1,k2,c1,c2);
+			bmix64(h1,h2,k1,k2,c1,c2);
-    };
+	};
 
-    //----------
+	//----------
-    // finalization
+	// finalization
 
-    h2 ^= len;
+	h2 ^= len;
 
-    h1 += h2;
+	h1 += h2;
-    h2 += h1;
+	h2 += h1;
 
-    h1 = fmix64(h1);
+	h1 = fmix64(h1);
-    h2 = fmix64(h2);
+	h2 = fmix64(h2);
 
-    h1 += h2;
+	h1 += h2;
 
-    return h1;
+	return h1;
 }
 
 
@@ -262,11 +262,13 @@ u64 GetCRC32(const u8 *src, int len, u32 samples)
 }
 
 
-/* NOTE: This hash function is used for custom texture loading/dumping, so
+/* 
-   it should not be changed, which would require all custom textures to be
+ * NOTE: This hash function is used for custom texture loading/dumping, so
-   recalculated for their new hash values. If the hashing function is
+ * it should not be changed, which would require all custom textures to be
-   changed, make sure this one is still used when the legacy parameter is
+ * recalculated for their new hash values. If the hashing function is
-   true. */
+ * changed, make sure this one is still used when the legacy parameter is
+ * true.
+ */
 u64 GetHashHiresTexture(const u8 *src, int len, u32 samples)
 {
 	const u64 m = 0xc6a4a7935bd1e995;
@@ -453,9 +455,11 @@ u64 GetMurmurHash3(const u8* src, int len, u32 samples)
 	return *((u64 *)&out);
 }
 
-/* FIXME: The old 32-bit version of this hash made different hashes than the
+/*
-   64-bit version. Until someone can make a new version of the 32-bit one that
+ * FIXME: The old 32-bit version of this hash made different hashes than the
-   makes identical hashes, this is just a c/p of the 64-bit one. */
+ * 64-bit version. Until someone can make a new version of the 32-bit one that
+ * makes identical hashes, this is just a c/p of the 64-bit one.
+ */
 u64 GetHashHiresTexture(const u8 *src, int len, u32 samples)
 {
 	const u64 m = 0xc6a4a7935bd1e995ULL;
@@ -502,7 +506,7 @@ u64 GetHashHiresTexture(const u8 *src, int len, u32 samples)
 
 u64 GetHash64(const u8 *src, int len, u32 samples)
 {
-    return ptrHashFunction(src, len, samples);
+	return ptrHashFunction(src, len, samples);
 }
 
 // sets the hash function used for the texture cache

Source/Core/Common/Src/LogManager.cpp

@@ -45,9 +45,9 @@ LogManager::LogManager()
 	m_Log[LogTypes::MASTER_LOG]			= new LogContainer("*",				"Master Log");
 	m_Log[LogTypes::BOOT]				= new LogContainer("BOOT",			"Boot");
 	m_Log[LogTypes::COMMON]				= new LogContainer("COMMON",		"Common");
-	m_Log[LogTypes::DISCIO]				= new LogContainer("DIO",	    	"Disc IO");
+	m_Log[LogTypes::DISCIO]				= new LogContainer("DIO",			"Disc IO");
 	m_Log[LogTypes::FILEMON]			= new LogContainer("FileMon",		"File Monitor");
-	m_Log[LogTypes::PAD]		        = new LogContainer("PAD",			"Pad");
+	m_Log[LogTypes::PAD]				= new LogContainer("PAD",			"Pad");
 	m_Log[LogTypes::PIXELENGINE]		= new LogContainer("PE",			"PixelEngine");
 	m_Log[LogTypes::COMMANDPROCESSOR]	= new LogContainer("CP",			"CommandProc");
 	m_Log[LogTypes::VIDEOINTERFACE]		= new LogContainer("VI",			"VideoInt");
@@ -63,11 +63,11 @@ LogManager::LogManager()
 	m_Log[LogTypes::AUDIO_INTERFACE]	= new LogContainer("AI",			"AudioInt");
 	m_Log[LogTypes::POWERPC]			= new LogContainer("PowerPC",		"IBM CPU");
 	m_Log[LogTypes::OSHLE]				= new LogContainer("HLE",			"HLE");
-	m_Log[LogTypes::DSPHLE]			    = new LogContainer("DSPHLE",		"DSP HLE");
+	m_Log[LogTypes::DSPHLE]				= new LogContainer("DSPHLE",		"DSP HLE");
-	m_Log[LogTypes::DSPLLE]			    = new LogContainer("DSPLLE",		"DSP LLE");
+	m_Log[LogTypes::DSPLLE]				= new LogContainer("DSPLLE",		"DSP LLE");
-	m_Log[LogTypes::DSP_MAIL]		    = new LogContainer("DSPMails",		"DSP Mails");
+	m_Log[LogTypes::DSP_MAIL]			= new LogContainer("DSPMails",		"DSP Mails");
-	m_Log[LogTypes::VIDEO]			    = new LogContainer("Video",			"Video Backend");
+	m_Log[LogTypes::VIDEO]				= new LogContainer("Video",			"Video Backend");
-	m_Log[LogTypes::AUDIO]			    = new LogContainer("Audio",			"Audio Emulator");
+	m_Log[LogTypes::AUDIO]				= new LogContainer("Audio",			"Audio Emulator");
 	m_Log[LogTypes::DYNA_REC]			= new LogContainer("JIT",			"Dynamic Recompiler");
 	m_Log[LogTypes::CONSOLE]			= new LogContainer("CONSOLE",		"Dolphin Console");
 	m_Log[LogTypes::OSREPORT]			= new LogContainer("OSREPORT",		"OSReport");

Source/Core/Common/Src/LogManager.h

@@ -26,7 +26,7 @@
 #include <set>
 #include <string.h>
 
-#define	MAX_MESSAGES 8000   
+#define MAX_MESSAGES 8000
 #define MAX_MSGLEN  1024
 
 

Source/Core/Common/Src/MathUtil.cpp

@@ -109,18 +109,18 @@ u32 ClassifyFloat(float fvalue)
 
 inline void MatrixMul(int n, const float *a, const float *b, float *result)
 {
-    for (int i = 0; i < n; ++i)
+	for (int i = 0; i < n; ++i)
 	{
-        for (int j = 0; j < n; ++j)
+		for (int j = 0; j < n; ++j)
 		{
-            float temp = 0;
+			float temp = 0;
-            for (int k = 0; k < n; ++k)
+			for (int k = 0; k < n; ++k)
 			{
-                temp += a[i * n + k] * b[k * n + j];
+				temp += a[i * n + k] * b[k * n + j];
-            }
+			}
-            result[i * n + j] = temp;
+			result[i * n + j] = temp;
-        }
+		}
-    }
+	}
 }
 
 // Calculate sum of a float list
@@ -131,94 +131,94 @@ float MathFloatVectorSum(const std::vector<float>& Vec)
 
 void Matrix33::LoadIdentity(Matrix33 &mtx)
 {
-    memset(mtx.data, 0, sizeof(mtx.data));
+	memset(mtx.data, 0, sizeof(mtx.data));
-    mtx.data[0] = 1.0f;
+	mtx.data[0] = 1.0f;
-    mtx.data[4] = 1.0f;
+	mtx.data[4] = 1.0f;
-    mtx.data[8] = 1.0f;
+	mtx.data[8] = 1.0f;
 }
 
 void Matrix33::RotateX(Matrix33 &mtx, float rad)
 {
-    float s = sin(rad);
+	float s = sin(rad);
-    float c = cos(rad);
+	float c = cos(rad);
-    memset(mtx.data, 0, sizeof(mtx.data));
+	memset(mtx.data, 0, sizeof(mtx.data));
-    mtx.data[0] = 1;
+	mtx.data[0] = 1;
-    mtx.data[4] = c;
+	mtx.data[4] = c;
-    mtx.data[5] = -s;
+	mtx.data[5] = -s;
-    mtx.data[7] = s;
+	mtx.data[7] = s;
-    mtx.data[8] = c;
+	mtx.data[8] = c;
 }
 void Matrix33::RotateY(Matrix33 &mtx, float rad)
 {
-    float s = sin(rad);
+	float s = sin(rad);
-    float c = cos(rad);
+	float c = cos(rad);
-    memset(mtx.data, 0, sizeof(mtx.data));
+	memset(mtx.data, 0, sizeof(mtx.data));
-    mtx.data[0] = c;
+	mtx.data[0] = c;
-    mtx.data[2] = s;
+	mtx.data[2] = s;
-    mtx.data[4] = 1;
+	mtx.data[4] = 1;
-    mtx.data[6] = -s;    
+	mtx.data[6] = -s;    
-    mtx.data[8] = c;
+	mtx.data[8] = c;
 }
 
 void Matrix33::Multiply(const Matrix33 &a, const Matrix33 &b, Matrix33 &result)
 {
-    MatrixMul(3, a.data, b.data, result.data);
+	MatrixMul(3, a.data, b.data, result.data);
 }
 
 void Matrix33::Multiply(const Matrix33 &a, const float vec[3], float result[3])
 {
-    for (int i = 0; i < 3; ++i) {
+	for (int i = 0; i < 3; ++i) {
-        result[i] = 0;
+		result[i] = 0;
-        for (int k = 0; k < 3; ++k) {
+		for (int k = 0; k < 3; ++k) {
-            result[i] += a.data[i * 3 + k] * vec[k];
+			result[i] += a.data[i * 3 + k] * vec[k];
-        }
+		}
-    }
+	}
 }
 
 void Matrix44::LoadIdentity(Matrix44 &mtx)
 {
-    memset(mtx.data, 0, sizeof(mtx.data));
+	memset(mtx.data, 0, sizeof(mtx.data));
-    mtx.data[0] = 1.0f;
+	mtx.data[0] = 1.0f;
-    mtx.data[5] = 1.0f;
+	mtx.data[5] = 1.0f;
-    mtx.data[10] = 1.0f;
+	mtx.data[10] = 1.0f;
-    mtx.data[15] = 1.0f;
+	mtx.data[15] = 1.0f;
 }
 
 void Matrix44::LoadMatrix33(Matrix44 &mtx, const Matrix33 &m33)
 {
-    for (int i = 0; i < 3; ++i)
+	for (int i = 0; i < 3; ++i)
 	{
-        for (int j = 0; j < 3; ++j)
+		for (int j = 0; j < 3; ++j)
 		{
-            mtx.data[i * 4 + j] = m33.data[i * 3 + j];
+			mtx.data[i * 4 + j] = m33.data[i * 3 + j];
-        }
+		}
-    }
+	}
 
-    for (int i = 0; i < 3; ++i)
+	for (int i = 0; i < 3; ++i)
 	{
-        mtx.data[i * 4 + 3] = 0;
+		mtx.data[i * 4 + 3] = 0;
-        mtx.data[i + 12] = 0;
+		mtx.data[i + 12] = 0;
-    }
+	}
-    mtx.data[15] = 1.0f;
+	mtx.data[15] = 1.0f;
 }
 
 void Matrix44::Set(Matrix44 &mtx, const float mtxArray[16])
 {
-    for(int i = 0; i < 16; ++i) {
+	for(int i = 0; i < 16; ++i) {
-        mtx.data[i] = mtxArray[i];
+		mtx.data[i] = mtxArray[i];
-    }
+	}
 }
 
 void Matrix44::Translate(Matrix44 &mtx, const float vec[3])
 {
-    LoadIdentity(mtx);
+	LoadIdentity(mtx);
-    mtx.data[3] = vec[0];
+	mtx.data[3] = vec[0];
-    mtx.data[7] = vec[1];
+	mtx.data[7] = vec[1];
-    mtx.data[11] = vec[2];
+	mtx.data[11] = vec[2];
 }
 
 void Matrix44::Multiply(const Matrix44 &a, const Matrix44 &b, Matrix44 &result)
 {
-    MatrixMul(4, a.data, b.data, result.data);
+	MatrixMul(4, a.data, b.data, result.data);
 }
 

Source/Core/Common/Src/MathUtil.h

@@ -182,32 +182,32 @@ inline u64 Log2(u64 val)
 class Matrix33
 {
 public:
-    static void LoadIdentity(Matrix33 &mtx);
+	static void LoadIdentity(Matrix33 &mtx);
 
-    // set mtx to be a rotation matrix around the x axis
+	// set mtx to be a rotation matrix around the x axis
-    static void RotateX(Matrix33 &mtx, float rad);
+	static void RotateX(Matrix33 &mtx, float rad);
-    // set mtx to be a rotation matrix around the y axis
+	// set mtx to be a rotation matrix around the y axis
-    static void RotateY(Matrix33 &mtx, float rad);
+	static void RotateY(Matrix33 &mtx, float rad);
 
-    // set result = a x b
+	// set result = a x b
-    static void Multiply(const Matrix33 &a, const Matrix33 &b, Matrix33 &result);
+	static void Multiply(const Matrix33 &a, const Matrix33 &b, Matrix33 &result);
-    static void Multiply(const Matrix33 &a, const float vec[3], float result[3]);
+	static void Multiply(const Matrix33 &a, const float vec[3], float result[3]);
 
-    float data[9];
+	float data[9];
 };
 
 class Matrix44
 {
 public:
-    static void LoadIdentity(Matrix44 &mtx);
+	static void LoadIdentity(Matrix44 &mtx);
-    static void LoadMatrix33(Matrix44 &mtx, const Matrix33 &m33);
+	static void LoadMatrix33(Matrix44 &mtx, const Matrix33 &m33);
-    static void Set(Matrix44 &mtx, const float mtxArray[16]);
+	static void Set(Matrix44 &mtx, const float mtxArray[16]);
 
-    static void Translate(Matrix44 &mtx, const float vec[3]);
+	static void Translate(Matrix44 &mtx, const float vec[3]);
 
-    static void Multiply(const Matrix44 &a, const Matrix44 &b, Matrix44 &result);
+	static void Multiply(const Matrix44 &a, const Matrix44 &b, Matrix44 &result);
 
-    float data[16];
+	float data[16];
 };
 
 #endif // _MATH_UTIL_H_

Source/Core/Common/Src/MemoryUtil.cpp

@@ -155,9 +155,7 @@ void FreeAlignedMemory(void* ptr)
 	if (ptr)
 	{
 #ifdef _WIN32
-	
+	_aligned_free(ptr);
-		_aligned_free(ptr);
-	
 #else
 	free(ptr);
 #endif

Source/Core/Common/Src/MsgHandler.cpp

@@ -102,15 +102,14 @@ bool MsgAlert(bool yes_no, int Style, const char* format, ...)
 bool DefaultMsgHandler(const char* caption, const char* text, bool yes_no, int Style)
 {
 #ifdef _WIN32
-    int STYLE = MB_ICONINFORMATION;
+	int STYLE = MB_ICONINFORMATION;
-    if (Style == QUESTION) STYLE = MB_ICONQUESTION;
+	if (Style == QUESTION) STYLE = MB_ICONQUESTION;
-    if (Style == WARNING) STYLE = MB_ICONWARNING;
+	if (Style == WARNING) STYLE = MB_ICONWARNING;
-    
-    return IDYES == MessageBox(0, UTF8ToTStr(text).c_str(), UTF8ToTStr(caption).c_str(), STYLE | (yes_no ? MB_YESNO : MB_OK));
 
+	return IDYES == MessageBox(0, UTF8ToTStr(text).c_str(), UTF8ToTStr(caption).c_str(), STYLE | (yes_no ? MB_YESNO : MB_OK));
 #else
-    printf("%s\n", text);
+	printf("%s\n", text);
-    return true;
+	return true;
 #endif
 }
 

Source/Core/Common/Src/x64ABI.cpp

@@ -226,11 +226,11 @@ void XEmitter::ABI_CallFunction(void *func) {
 	u64 distance = u64(func) - (u64(code) + 5);
 	if (distance >= 0x0000000080000000ULL
 	 && distance <  0xFFFFFFFF80000000ULL) {
-	    // Far call
+		// Far call
-	    MOV(64, R(RAX), Imm64((u64)func));
+		MOV(64, R(RAX), Imm64((u64)func));
-	    CALLptr(R(RAX));
+		CALLptr(R(RAX));
 	} else {
-	    CALL(func);
+		CALL(func);
 	}
 }
 
@@ -239,11 +239,11 @@ void XEmitter::ABI_CallFunctionC16(void *func, u16 param1) {
 	u64 distance = u64(func) - (u64(code) + 5);
 	if (distance >= 0x0000000080000000ULL
 	 && distance <  0xFFFFFFFF80000000ULL) {
-	    // Far call
+		// Far call
-	    MOV(64, R(RAX), Imm64((u64)func));
+		MOV(64, R(RAX), Imm64((u64)func));
-	    CALLptr(R(RAX));
+		CALLptr(R(RAX));
 	} else {
-	    CALL(func);
+		CALL(func);
 	}
 }
 
@@ -266,11 +266,11 @@ void XEmitter::ABI_CallFunctionC(void *func, u32 param1) {
 	u64 distance = u64(func) - (u64(code) + 5);
 	if (distance >= 0x0000000080000000ULL
 	 && distance <  0xFFFFFFFF80000000ULL) {
-	    // Far call
+		// Far call
-	    MOV(64, R(RAX), Imm64((u64)func));
+		MOV(64, R(RAX), Imm64((u64)func));
-	    CALLptr(R(RAX));
+		CALLptr(R(RAX));
 	} else {
-	    CALL(func);
+		CALL(func);
 	}
 }
 
@@ -280,11 +280,11 @@ void XEmitter::ABI_CallFunctionCC(void *func, u32 param1, u32 param2) {
 	u64 distance = u64(func) - (u64(code) + 5);
 	if (distance >= 0x0000000080000000ULL
 	 && distance <  0xFFFFFFFF80000000ULL) {
-	    // Far call
+		// Far call
-	    MOV(64, R(RAX), Imm64((u64)func));
+		MOV(64, R(RAX), Imm64((u64)func));
-	    CALLptr(R(RAX));
+		CALLptr(R(RAX));
 	} else {
-	    CALL(func);
+		CALL(func);
 	}
 }
 
@@ -295,11 +295,11 @@ void XEmitter::ABI_CallFunctionCCC(void *func, u32 param1, u32 param2, u32 param
 	u64 distance = u64(func) - (u64(code) + 5);
 	if (distance >= 0x0000000080000000ULL
 	 && distance <  0xFFFFFFFF80000000ULL) {
-	    // Far call
+		// Far call
-	    MOV(64, R(RAX), Imm64((u64)func));
+		MOV(64, R(RAX), Imm64((u64)func));
-	    CALLptr(R(RAX));
+		CALLptr(R(RAX));
 	} else {
-	    CALL(func);
+		CALL(func);
 	}
 }
 
@@ -310,11 +310,11 @@ void XEmitter::ABI_CallFunctionCCP(void *func, u32 param1, u32 param2, void *par
 	u64 distance = u64(func) - (u64(code) + 5);
 	if (distance >= 0x0000000080000000ULL
 	 && distance <  0xFFFFFFFF80000000ULL) {
-	    // Far call
+		// Far call
-	    MOV(64, R(RAX), Imm64((u64)func));
+		MOV(64, R(RAX), Imm64((u64)func));
-	    CALLptr(R(RAX));
+		CALLptr(R(RAX));
 	} else {
-	    CALL(func);
+		CALL(func);
 	}
 }
 
@@ -326,11 +326,11 @@ void XEmitter::ABI_CallFunctionCCCP(void *func, u32 param1, u32 param2, u32 para
 	u64 distance = u64(func) - (u64(code) + 5);
 	if (distance >= 0x0000000080000000ULL
 	 && distance <  0xFFFFFFFF80000000ULL) {
-	    // Far call
+		// Far call
-	    MOV(64, R(RAX), Imm64((u64)func));
+		MOV(64, R(RAX), Imm64((u64)func));
-	    CALLptr(R(RAX));
+		CALLptr(R(RAX));
 	} else {
-	    CALL(func);
+		CALL(func);
 	}
 }
 
@@ -341,11 +341,11 @@ void XEmitter::ABI_CallFunctionPPC(void *func, void *param1, void *param2, u32 p
 	u64 distance = u64(func) - (u64(code) + 5);
 	if (distance >= 0x0000000080000000ULL
 	 && distance <  0xFFFFFFFF80000000ULL) {
-	    // Far call
+		// Far call
-	    MOV(64, R(RAX), Imm64((u64)func));
+		MOV(64, R(RAX), Imm64((u64)func));
-	    CALLptr(R(RAX));
+		CALLptr(R(RAX));
 	} else {
-	    CALL(func);
+		CALL(func);
 	}
 }
 
@@ -356,11 +356,11 @@ void XEmitter::ABI_CallFunctionR(void *func, X64Reg reg1) {
 	u64 distance = u64(func) - (u64(code) + 5);
 	if (distance >= 0x0000000080000000ULL
 	 && distance <  0xFFFFFFFF80000000ULL) {
-	    // Far call
+		// Far call
-	    MOV(64, R(RAX), Imm64((u64)func));
+		MOV(64, R(RAX), Imm64((u64)func));
-	    CALLptr(R(RAX));
+		CALLptr(R(RAX));
 	} else {
-	    CALL(func);
+		CALL(func);
 	}
 }
 
@@ -380,11 +380,11 @@ void XEmitter::ABI_CallFunctionRR(void *func, X64Reg reg1, X64Reg reg2) {
 	u64 distance = u64(func) - (u64(code) + 5);
 	if (distance >= 0x0000000080000000ULL
 	 && distance <  0xFFFFFFFF80000000ULL) {
-	    // Far call
+		// Far call
-	    MOV(64, R(RAX), Imm64((u64)func));
+		MOV(64, R(RAX), Imm64((u64)func));
-	    CALLptr(R(RAX));
+		CALLptr(R(RAX));
 	} else {
-	    CALL(func);
+		CALL(func);
 	}
 }
 
@@ -396,11 +396,11 @@ void XEmitter::ABI_CallFunctionAC(void *func, const Gen::OpArg &arg1, u32 param2
 	u64 distance = u64(func) - (u64(code) + 5);
 	if (distance >= 0x0000000080000000ULL
 	 && distance <  0xFFFFFFFF80000000ULL) {
-	    // Far call
+		// Far call
-	    MOV(64, R(RAX), Imm64((u64)func));
+		MOV(64, R(RAX), Imm64((u64)func));
-	    CALLptr(R(RAX));
+		CALLptr(R(RAX));
 	} else {
-	    CALL(func);
+		CALL(func);
 	}
 }
 
@@ -411,11 +411,11 @@ void XEmitter::ABI_CallFunctionA(void *func, const Gen::OpArg &arg1)
 	u64 distance = u64(func) - (u64(code) + 5);
 	if (distance >= 0x0000000080000000ULL
 	 && distance <  0xFFFFFFFF80000000ULL) {
-	    // Far call
+		// Far call
-	    MOV(64, R(RAX), Imm64((u64)func));
+		MOV(64, R(RAX), Imm64((u64)func));
-	    CALLptr(R(RAX));
+		CALLptr(R(RAX));
 	} else {
-	    CALL(func);
+		CALL(func);
 	}
 }
 

Source/Core/Common/Src/x64Analyzer.cpp

@@ -60,18 +60,18 @@ bool DisassembleMov(const unsigned char *codePtr, InstructionInfo &info, int acc
 
 	codeByte = *codePtr++;
 
-    // Skip two-byte opcode byte 
+	// Skip two-byte opcode byte 
-    bool twoByte = false; 
+	bool twoByte = false; 
-    if(codeByte == 0x0F) 
+	if(codeByte == 0x0F) 
-    { 
+	{ 
-        twoByte = true; 
+		twoByte = true; 
 		codeByte2 = *codePtr++;
-    } 
+	} 
 
 	if (!twoByte)
 	{
-        if ((codeByte & 0xF0) == 0x80 || 
+		if ((codeByte & 0xF0) == 0x80 || 
-            ((codeByte & 0xF8) == 0xC0 && (codeByte & 0x0E) != 0x02))
+			((codeByte & 0xF8) == 0xC0 && (codeByte & 0x0E) != 0x02))
 		{
 			modRMbyte = *codePtr++;
 			hasModRM = true;
@@ -79,20 +79,20 @@ bool DisassembleMov(const unsigned char *codePtr, InstructionInfo &info, int acc
 	}
 	else
 	{
-        if (((codeByte2 & 0xF0) == 0x00 && (codeByte2 & 0x0F) >= 0x04 && (codeByte2 & 0x0D) != 0x0D) || 
+		if (((codeByte2 & 0xF0) == 0x00 && (codeByte2 & 0x0F) >= 0x04 && (codeByte2 & 0x0D) != 0x0D) || 
-            (codeByte2 & 0xF0) == 0x30 || 
+			(codeByte2 & 0xF0) == 0x30 || 
-            codeByte2 == 0x77 || 
+			codeByte2 == 0x77 || 
-            (codeByte2 & 0xF0) == 0x80 || 
+			(codeByte2 & 0xF0) == 0x80 || 
-            ((codeByte2 & 0xF0) == 0xA0 && (codeByte2 & 0x07) <= 0x02) || 
+			((codeByte2 & 0xF0) == 0xA0 && (codeByte2 & 0x07) <= 0x02) || 
-            (codeByte2 & 0xF8) == 0xC8) 
+			(codeByte2 & 0xF8) == 0xC8) 
-        { 
+		{ 
-            // No mod R/M byte 
+			// No mod R/M byte 
-        } 
+		} 
-        else 
+		else 
-        { 
+		{ 
 			modRMbyte = *codePtr++;
 			hasModRM = true;
-        } 
+		} 
 	}
 
 	if (hasModRM)

Source/Core/Common/Src/x64Analyzer.h

@@ -51,7 +51,7 @@ enum{
 	MOVZX_SHORT     = 0xB7, //movzx on short
 	MOVSX_BYTE      = 0xBE, //movsx on byte
 	MOVSX_SHORT     = 0xBF, //movsx on short
-	MOVE_8BIT	    = 0xC6, //move 8-bit immediate
+	MOVE_8BIT       = 0xC6, //move 8-bit immediate
 	MOVE_16_32BIT   = 0xC7, //move 16 or 32-bit immediate
 	MOVE_REG_TO_MEM = 0x89, //move reg to memory
 };

Source/Core/Common/Src/x64CPUDetect.cpp

@@ -39,7 +39,7 @@
 #include <machine/cpufunc.h>
 #else
 static inline void do_cpuid(unsigned int *eax, unsigned int *ebx,
-						    unsigned int *ecx, unsigned int *edx)
+							unsigned int *ecx, unsigned int *edx)
 {
 #if defined _M_GENERIC
 	(*eax) = (*ebx) = (*ecx) = (*edx) = 0;

Source/Core/Common/Src/x64Emitter.cpp

@@ -51,13 +51,13 @@ static const NormalOpDef nops[11] =
 
 enum NormalSSEOps
 {
-	sseCMP =         0xC2, 
+	sseCMP =		 0xC2, 
-	sseADD =         0x58, //ADD
+	sseADD =		 0x58, //ADD
 	sseSUB =		 0x5C, //SUB
 	sseAND =		 0x54, //AND
 	sseANDN =		 0x55, //ANDN
-	sseOR  =         0x56, 
+	sseOR  =		 0x56, 
-	sseXOR  =        0x57,
+	sseXOR  =		 0x57,
 	sseMUL =		 0x59, //MUL,
 	sseDIV =		 0x5E, //DIV
 	sseMIN =		 0x5D, //MIN
@@ -143,18 +143,18 @@ void OpArg::WriteRex(XEmitter *emit, int opBits, int bits, int customOp) const
 	if (indexReg & 8)         op |= 2;
 	if (offsetOrBaseReg & 8)  op |= 1; //TODO investigate if this is dangerous
 	if (op != 0x40 ||
-	    (bits == 8 && (offsetOrBaseReg & 0x10c) == 4) ||
+		(bits == 8 && (offsetOrBaseReg & 0x10c) == 4) ||
-	    (opBits == 8 && (customOp & 0x10c) == 4)) {
+		(opBits == 8 && (customOp & 0x10c) == 4)) {
 		emit->Write8(op);
 		_dbg_assert_(DYNA_REC, (offsetOrBaseReg & 0x100) == 0 || bits != 8);
 		_dbg_assert_(DYNA_REC, (customOp & 0x100) == 0 || opBits != 8);
 	} else {
 		_dbg_assert_(DYNA_REC, (offsetOrBaseReg & 0x10c) == 0 ||
-			     (offsetOrBaseReg & 0x10c) == 0x104 ||
+				(offsetOrBaseReg & 0x10c) == 0x104 ||
-			     bits != 8);
+				bits != 8);
 		_dbg_assert_(DYNA_REC, (customOp & 0x10c) == 0 ||
-			     (customOp & 0x10c) == 0x104 ||
+				(customOp & 0x10c) == 0x104 ||
-			     opBits != 8);
+				opBits != 8);
 	}
 
 #else
@@ -969,15 +969,15 @@ void OpArg::WriteNormalOp(XEmitter *emit, bool toRM, NormalOp op, const OpArg &o
 			immToWrite = 8;
 		}
 		else if ((operand.scale == SCALE_IMM16 && bits == 16) ||
-                             (operand.scale == SCALE_IMM32 && bits == 32) || 
+				 (operand.scale == SCALE_IMM32 && bits == 32) || 
-                             (operand.scale == SCALE_IMM32 && bits == 64))
+				 (operand.scale == SCALE_IMM32 && bits == 64))
 		{
 			emit->Write8(nops[op].imm32);
 			immToWrite = bits == 16 ? 16 : 32;
 		}
 		else if ((operand.scale == SCALE_IMM8 && bits == 16) ||
-                             (operand.scale == SCALE_IMM8 && bits == 32) ||
+				 (operand.scale == SCALE_IMM8 && bits == 32) ||
-                             (operand.scale == SCALE_IMM8 && bits == 64))
+				 (operand.scale == SCALE_IMM8 && bits == 64))
 		{
 			emit->Write8(nops[op].simm8);
 			immToWrite = 8;
@@ -1471,142 +1471,142 @@ void XEmitter::RTDSC() { Write8(0x0F); Write8(0x31); }
 // helper routines for setting pointers
 void XEmitter::CallCdeclFunction3(void* fnptr, u32 arg0, u32 arg1, u32 arg2)
 {
-    using namespace Gen;
+	using namespace Gen;
 #ifdef _M_X64
 
 #ifdef _MSC_VER
-    MOV(32, R(RCX), Imm32(arg0));
+	MOV(32, R(RCX), Imm32(arg0));
-    MOV(32, R(RDX), Imm32(arg1));
+	MOV(32, R(RDX), Imm32(arg1));
-    MOV(32, R(R8),  Imm32(arg2));
+	MOV(32, R(R8),  Imm32(arg2));
-    CALL(fnptr);
+	CALL(fnptr);
 #else
-    MOV(32, R(RDI), Imm32(arg0));
+	MOV(32, R(RDI), Imm32(arg0));
-    MOV(32, R(RSI), Imm32(arg1));
+	MOV(32, R(RSI), Imm32(arg1));
-    MOV(32, R(RDX), Imm32(arg2));
+	MOV(32, R(RDX), Imm32(arg2));
-    CALL(fnptr);
+	CALL(fnptr);
 #endif
 
 #else
-    ABI_AlignStack(3 * 4);
+	ABI_AlignStack(3 * 4);
-    PUSH(32, Imm32(arg2));
+	PUSH(32, Imm32(arg2));
-    PUSH(32, Imm32(arg1));
+	PUSH(32, Imm32(arg1));
-    PUSH(32, Imm32(arg0));
+	PUSH(32, Imm32(arg0));
-    CALL(fnptr);
+	CALL(fnptr);
 #ifdef _WIN32
-    // don't inc stack
+	// don't inc stack
 #else
-    ABI_RestoreStack(3 * 4);
+	ABI_RestoreStack(3 * 4);
 #endif
 #endif
 }
 
 void XEmitter::CallCdeclFunction4(void* fnptr, u32 arg0, u32 arg1, u32 arg2, u32 arg3)
 {
-    using namespace Gen;
+	using namespace Gen;
 #ifdef _M_X64
 
 #ifdef _MSC_VER
-    MOV(32, R(RCX), Imm32(arg0));
+	MOV(32, R(RCX), Imm32(arg0));
-    MOV(32, R(RDX), Imm32(arg1));
+	MOV(32, R(RDX), Imm32(arg1));
-    MOV(32, R(R8), Imm32(arg2));
+	MOV(32, R(R8), Imm32(arg2));
-    MOV(32, R(R9), Imm32(arg3));
+	MOV(32, R(R9), Imm32(arg3));
-    CALL(fnptr);
+	CALL(fnptr);
 #else
-    MOV(32, R(RDI), Imm32(arg0));
+	MOV(32, R(RDI), Imm32(arg0));
-    MOV(32, R(RSI), Imm32(arg1));
+	MOV(32, R(RSI), Imm32(arg1));
-    MOV(32, R(RDX), Imm32(arg2));
+	MOV(32, R(RDX), Imm32(arg2));
-    MOV(32, R(RCX), Imm32(arg3));
+	MOV(32, R(RCX), Imm32(arg3));
-    CALL(fnptr);
+	CALL(fnptr);
 #endif
 
 #else
-    ABI_AlignStack(4 * 4);
+	ABI_AlignStack(4 * 4);
-    PUSH(32, Imm32(arg3));
+	PUSH(32, Imm32(arg3));
-    PUSH(32, Imm32(arg2));
+	PUSH(32, Imm32(arg2));
-    PUSH(32, Imm32(arg1));
+	PUSH(32, Imm32(arg1));
-    PUSH(32, Imm32(arg0));
+	PUSH(32, Imm32(arg0));
-    CALL(fnptr);
+	CALL(fnptr);
 #ifdef _WIN32
-    // don't inc stack
+	// don't inc stack
 #else
-    ABI_RestoreStack(4 * 4);
+	ABI_RestoreStack(4 * 4);
 #endif
 #endif
 }
 
 void XEmitter::CallCdeclFunction5(void* fnptr, u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4)
 {
-    using namespace Gen;
+	using namespace Gen;
 #ifdef _M_X64
 
 #ifdef _MSC_VER
-    MOV(32, R(RCX), Imm32(arg0));
+	MOV(32, R(RCX), Imm32(arg0));
-    MOV(32, R(RDX), Imm32(arg1));
+	MOV(32, R(RDX), Imm32(arg1));
-    MOV(32, R(R8),  Imm32(arg2));
+	MOV(32, R(R8),  Imm32(arg2));
-    MOV(32, R(R9),  Imm32(arg3));
+	MOV(32, R(R9),  Imm32(arg3));
 	MOV(32, MDisp(RSP, 0x20), Imm32(arg4));
-    CALL(fnptr);
+	CALL(fnptr);
 #else
-    MOV(32, R(RDI), Imm32(arg0));
+	MOV(32, R(RDI), Imm32(arg0));
-    MOV(32, R(RSI), Imm32(arg1));
+	MOV(32, R(RSI), Imm32(arg1));
-    MOV(32, R(RDX), Imm32(arg2));
+	MOV(32, R(RDX), Imm32(arg2));
-    MOV(32, R(RCX), Imm32(arg3));
+	MOV(32, R(RCX), Imm32(arg3));
-    MOV(32, R(R8),  Imm32(arg4));
+	MOV(32, R(R8),  Imm32(arg4));
-    CALL(fnptr);
+	CALL(fnptr);
 #endif
 
 #else
-    ABI_AlignStack(5 * 4);
+	ABI_AlignStack(5 * 4);
-    PUSH(32, Imm32(arg4));
+	PUSH(32, Imm32(arg4));
-    PUSH(32, Imm32(arg3));
+	PUSH(32, Imm32(arg3));
-    PUSH(32, Imm32(arg2));
+	PUSH(32, Imm32(arg2));
-    PUSH(32, Imm32(arg1));
+	PUSH(32, Imm32(arg1));
-    PUSH(32, Imm32(arg0));
+	PUSH(32, Imm32(arg0));
-    CALL(fnptr);
+	CALL(fnptr);
 #ifdef _WIN32
-    // don't inc stack
+	// don't inc stack
 #else
-    ABI_RestoreStack(5 * 4);
+	ABI_RestoreStack(5 * 4);
 #endif
 #endif
 }
 
 void XEmitter::CallCdeclFunction6(void* fnptr, u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4, u32 arg5)
 {
-    using namespace Gen;
+	using namespace Gen;
 #ifdef _M_X64
 
 #ifdef _MSC_VER
-    MOV(32, R(RCX), Imm32(arg0));
+	MOV(32, R(RCX), Imm32(arg0));
-    MOV(32, R(RDX), Imm32(arg1));
+	MOV(32, R(RDX), Imm32(arg1));
-    MOV(32, R(R8), Imm32(arg2));
+	MOV(32, R(R8), Imm32(arg2));
-    MOV(32, R(R9), Imm32(arg3));
+	MOV(32, R(R9), Imm32(arg3));
 	MOV(32, MDisp(RSP, 0x20), Imm32(arg4));
 	MOV(32, MDisp(RSP, 0x28), Imm32(arg5));
-    CALL(fnptr);
+	CALL(fnptr);
 #else
-    MOV(32, R(RDI), Imm32(arg0));
+	MOV(32, R(RDI), Imm32(arg0));
-    MOV(32, R(RSI), Imm32(arg1));
+	MOV(32, R(RSI), Imm32(arg1));
-    MOV(32, R(RDX), Imm32(arg2));
+	MOV(32, R(RDX), Imm32(arg2));
-    MOV(32, R(RCX), Imm32(arg3));
+	MOV(32, R(RCX), Imm32(arg3));
-    MOV(32, R(R8), Imm32(arg4));
+	MOV(32, R(R8), Imm32(arg4));
-    MOV(32, R(R9), Imm32(arg5));
+	MOV(32, R(R9), Imm32(arg5));
-    CALL(fnptr);
+	CALL(fnptr);
 #endif
 
 #else
-    ABI_AlignStack(6 * 4);
+	ABI_AlignStack(6 * 4);
-    PUSH(32, Imm32(arg5));
+	PUSH(32, Imm32(arg5));
-    PUSH(32, Imm32(arg4));
+	PUSH(32, Imm32(arg4));
-    PUSH(32, Imm32(arg3));
+	PUSH(32, Imm32(arg3));
-    PUSH(32, Imm32(arg2));
+	PUSH(32, Imm32(arg2));
-    PUSH(32, Imm32(arg1));
+	PUSH(32, Imm32(arg1));
-    PUSH(32, Imm32(arg0));
+	PUSH(32, Imm32(arg0));
-    CALL(fnptr);
+	CALL(fnptr);
 #ifdef _WIN32
-    // don't inc stack
+	// don't inc stack
 #else
-    ABI_RestoreStack(6 * 4);
+	ABI_RestoreStack(6 * 4);
 #endif
 #endif
 }
@@ -1615,31 +1615,31 @@ void XEmitter::CallCdeclFunction6(void* fnptr, u32 arg0, u32 arg1, u32 arg2, u32
 
 // See header
 void XEmitter::___CallCdeclImport3(void* impptr, u32 arg0, u32 arg1, u32 arg2) {
-    MOV(32, R(RCX), Imm32(arg0));
+	MOV(32, R(RCX), Imm32(arg0));
-    MOV(32, R(RDX), Imm32(arg1));
+	MOV(32, R(RDX), Imm32(arg1));
-    MOV(32, R(R8), Imm32(arg2));
+	MOV(32, R(R8), Imm32(arg2));
 	CALLptr(M(impptr));
 }
 void XEmitter::___CallCdeclImport4(void* impptr, u32 arg0, u32 arg1, u32 arg2, u32 arg3) {
-    MOV(32, R(RCX), Imm32(arg0));
+	MOV(32, R(RCX), Imm32(arg0));
-    MOV(32, R(RDX), Imm32(arg1));
+	MOV(32, R(RDX), Imm32(arg1));
-    MOV(32, R(R8), Imm32(arg2));
+	MOV(32, R(R8), Imm32(arg2));
-    MOV(32, R(R9), Imm32(arg3));
+	MOV(32, R(R9), Imm32(arg3));
 	CALLptr(M(impptr));
 }
 void XEmitter::___CallCdeclImport5(void* impptr, u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4) {
-    MOV(32, R(RCX), Imm32(arg0));
+	MOV(32, R(RCX), Imm32(arg0));
-    MOV(32, R(RDX), Imm32(arg1));
+	MOV(32, R(RDX), Imm32(arg1));
-    MOV(32, R(R8), Imm32(arg2));
+	MOV(32, R(R8), Imm32(arg2));
-    MOV(32, R(R9), Imm32(arg3));
+	MOV(32, R(R9), Imm32(arg3));
 	MOV(32, MDisp(RSP, 0x20), Imm32(arg4));
 	CALLptr(M(impptr));
 }
 void XEmitter::___CallCdeclImport6(void* impptr, u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4, u32 arg5) {
-    MOV(32, R(RCX), Imm32(arg0));
+	MOV(32, R(RCX), Imm32(arg0));
-    MOV(32, R(RDX), Imm32(arg1));
+	MOV(32, R(RDX), Imm32(arg1));
-    MOV(32, R(R8), Imm32(arg2));
+	MOV(32, R(R8), Imm32(arg2));
-    MOV(32, R(R9), Imm32(arg3));
+	MOV(32, R(R9), Imm32(arg3));
 	MOV(32, MDisp(RSP, 0x20), Imm32(arg4));
 	MOV(32, MDisp(RSP, 0x28), Imm32(arg5));
 	CALLptr(M(impptr));

Source/Core/VideoCommon/Src/CPMemory.h

@@ -25,18 +25,18 @@ enum
 {
 	ARRAY_POSITION	= 0,
 	ARRAY_NORMAL	= 1,
-	ARRAY_COLOR     = 2,
+	ARRAY_COLOR		= 2,
-	ARRAY_COLOR2    = 3,
+	ARRAY_COLOR2	= 3,
-	ARRAY_TEXCOORD0 = 4,
+	ARRAY_TEXCOORD0	= 4,
 };
 
 // Vertex components
 enum
 {
 	NOT_PRESENT = 0,
-	DIRECT = 1,
+	DIRECT		= 1,
-	INDEX8 = 2,
+	INDEX8		= 2,
-	INDEX16 = 3,
+	INDEX16		= 3,
 };
 
 enum
@@ -74,14 +74,14 @@ union TVtxDesc
 		// 0: not present
 		// 1: present
 		u32 PosMatIdx	: 1;
-		u32 Tex0MatIdx 	: 1;
+		u32 Tex0MatIdx	: 1;
-		u32 Tex1MatIdx 	: 1;
+		u32 Tex1MatIdx	: 1;
-		u32 Tex2MatIdx 	: 1;
+		u32 Tex2MatIdx	: 1;
-		u32 Tex3MatIdx 	: 1;
+		u32 Tex3MatIdx	: 1;
-		u32 Tex4MatIdx 	: 1;
+		u32 Tex4MatIdx	: 1;
-		u32 Tex5MatIdx 	: 1;
+		u32 Tex5MatIdx	: 1;
-		u32 Tex6MatIdx 	: 1;
+		u32 Tex6MatIdx	: 1;
-		u32 Tex7MatIdx 	: 1;
+		u32 Tex7MatIdx	: 1;
 
 		// 00: not present 
 		// 01: direct 
@@ -89,156 +89,156 @@ union TVtxDesc
 		// 11: 16 bit index
 		u32 Position	: 2;
 		u32 Normal		: 2;
-		u32 Color0 		: 2;
+		u32 Color0		: 2;
-		u32 Color1 		: 2;
+		u32 Color1		: 2;
-		u32 Tex0Coord 	: 2;
+		u32 Tex0Coord	: 2;
-		u32 Tex1Coord 	: 2;
+		u32 Tex1Coord	: 2;
-		u32 Tex2Coord 	: 2;
+		u32 Tex2Coord	: 2;
-		u32 Tex3Coord 	: 2;
+		u32 Tex3Coord	: 2;
-		u32 Tex4Coord 	: 2;
+		u32 Tex4Coord	: 2;
-		u32 Tex5Coord 	: 2;
+		u32 Tex5Coord	: 2;
-		u32 Tex6Coord 	: 2;
+		u32 Tex6Coord	: 2;
-		u32 Tex7Coord 	: 2;
+		u32 Tex7Coord	: 2;
 		u32				:31;
 	};
-    struct {
+	struct {
-        u32 Hex0, Hex1;
+		u32 Hex0, Hex1;
-    };
+	};
 };
 
 union UVAT_group0
 {
-    u32 Hex;
+	u32 Hex;
-    struct 
+	struct 
-    {
+	{
-        // 0:8
+		// 0:8
-        u32 PosElements			: 1;
+		u32 PosElements			: 1;
-        u32 PosFormat			: 3; 
+		u32 PosFormat			: 3; 
-        u32 PosFrac				: 5; 
+		u32 PosFrac				: 5; 
-        // 9:12
+		// 9:12
-        u32 NormalElements		: 1; 
+		u32 NormalElements		: 1; 
-        u32 NormalFormat		: 3; 
+		u32 NormalFormat		: 3; 
-        // 13:16
+		// 13:16
-        u32 Color0Elements		: 1;
+		u32 Color0Elements		: 1;
-        u32 Color0Comp			: 3; 
+		u32 Color0Comp			: 3; 
-        // 17:20
+		// 17:20
-        u32 Color1Elements		: 1;
+		u32 Color1Elements		: 1;
-        u32 Color1Comp			: 3; 
+		u32 Color1Comp			: 3; 
-        // 21:29
+		// 21:29
-        u32 Tex0CoordElements	: 1;
+		u32 Tex0CoordElements	: 1;
-        u32 Tex0CoordFormat		: 3;
+		u32 Tex0CoordFormat		: 3;
-        u32 Tex0Frac			: 5;
+		u32 Tex0Frac			: 5;
-        // 30:31
+		// 30:31
-        u32 ByteDequant			: 1;
+		u32 ByteDequant			: 1;
-        u32 NormalIndex3		: 1;
+		u32 NormalIndex3		: 1;
-    };
+	};
 };
 
 union UVAT_group1
 {
-    u32 Hex;
+	u32 Hex;
-    struct 
+	struct 
-    {
+	{
-        // 0:8
+		// 0:8
-        u32 Tex1CoordElements	: 1;
+		u32 Tex1CoordElements	: 1;
-        u32 Tex1CoordFormat		: 3;
+		u32 Tex1CoordFormat		: 3;
-        u32 Tex1Frac			: 5;
+		u32 Tex1Frac			: 5;
-        // 9:17
+		// 9:17
-        u32 Tex2CoordElements	: 1;
+		u32 Tex2CoordElements	: 1;
-        u32 Tex2CoordFormat		: 3;
+		u32 Tex2CoordFormat		: 3;
-        u32 Tex2Frac			: 5;
+		u32 Tex2Frac			: 5;
-        // 18:26
+		// 18:26
-        u32 Tex3CoordElements	: 1;
+		u32 Tex3CoordElements	: 1;
-        u32 Tex3CoordFormat		: 3;
+		u32 Tex3CoordFormat		: 3;
-        u32 Tex3Frac			: 5;
+		u32 Tex3Frac			: 5;
-        // 27:30
+		// 27:30
-        u32 Tex4CoordElements	: 1;
+		u32 Tex4CoordElements	: 1;
-        u32 Tex4CoordFormat		: 3;
+		u32 Tex4CoordFormat		: 3;
-        // 
+		// 
-        u32						: 1;
+		u32						: 1;
-    };
+	};
 };
 
 union UVAT_group2
 {
-    u32 Hex;
+	u32 Hex;
-    struct 
+	struct 
-    {
+	{
-        // 0:4
+		// 0:4
-        u32 Tex4Frac			: 5;
+		u32 Tex4Frac			: 5;
-        // 5:13
+		// 5:13
-        u32 Tex5CoordElements	: 1;
+		u32 Tex5CoordElements	: 1;
-        u32 Tex5CoordFormat		: 3;
+		u32 Tex5CoordFormat		: 3;
-        u32 Tex5Frac			: 5;
+		u32 Tex5Frac			: 5;
-        // 14:22
+		// 14:22
-        u32 Tex6CoordElements	: 1;
+		u32 Tex6CoordElements	: 1;
-        u32 Tex6CoordFormat		: 3;
+		u32 Tex6CoordFormat		: 3;
-        u32 Tex6Frac			: 5;
+		u32 Tex6Frac			: 5;
-        // 23:31
+		// 23:31
-        u32 Tex7CoordElements	: 1;
+		u32 Tex7CoordElements	: 1;
-        u32 Tex7CoordFormat		: 3;
+		u32 Tex7CoordFormat		: 3;
-        u32 Tex7Frac			: 5;
+		u32 Tex7Frac			: 5;
-    };
+	};
 };
 
 struct ColorAttr
 {
-    u8 Elements;
+	u8 Elements;
-    u8 Comp;
+	u8 Comp;
 };
 
 struct TexAttr
 {
-    u8 Elements;
+	u8 Elements;
-    u8 Format;
+	u8 Format;
-    u8 Frac;
+	u8 Frac;
 };
 
 struct TVtxAttr
 {
-    u8 PosElements;
+	u8 PosElements;
-    u8 PosFormat; 
+	u8 PosFormat; 
-    u8 PosFrac; 
+	u8 PosFrac; 
-    u8 NormalElements;
+	u8 NormalElements;
-    u8 NormalFormat; 
+	u8 NormalFormat; 
-    ColorAttr color[2];
+	ColorAttr color[2];
-    TexAttr texCoord[8];
+	TexAttr texCoord[8];
-    u8 ByteDequant;
+	u8 ByteDequant;
-    u8 NormalIndex3;
+	u8 NormalIndex3;
 };
 
 // Matrix indices
 union TMatrixIndexA
 {
-    struct
+	struct
-    {
+	{
-        u32 PosNormalMtxIdx : 6;
+		u32 PosNormalMtxIdx : 6;
-        u32 Tex0MtxIdx : 6;
+		u32 Tex0MtxIdx : 6;
-        u32 Tex1MtxIdx : 6;
+		u32 Tex1MtxIdx : 6;
-        u32 Tex2MtxIdx : 6;
+		u32 Tex2MtxIdx : 6;
-        u32 Tex3MtxIdx : 6;
+		u32 Tex3MtxIdx : 6;
-    };
+	};
-    struct
+	struct
-    {
+	{
-        u32 Hex : 30;
+		u32 Hex : 30;
-        u32 unused : 2;
+		u32 unused : 2;
-    };
+	};
 };
 
 union TMatrixIndexB
 {
-    struct
+	struct
-    {
+	{
-        u32 Tex4MtxIdx : 6;
+		u32 Tex4MtxIdx : 6;
-        u32 Tex5MtxIdx : 6;
+		u32 Tex5MtxIdx : 6;
-        u32 Tex6MtxIdx : 6;
+		u32 Tex6MtxIdx : 6;
-        u32 Tex7MtxIdx : 6;
+		u32 Tex7MtxIdx : 6;
-    };
+	};
-    struct
+	struct
-    {
+	{
-        u32 Hex : 24;
+		u32 Hex : 24;
-        u32 unused : 8;
+		u32 unused : 8;
-    };
+	};
 };
 
 #pragma pack()

Source/Core/VideoCommon/Src/CommandProcessor.cpp

@@ -462,7 +462,6 @@ void STACKALIGN GatherPipeBursted()
 				ProcessFifoAllDistance();
 				waitingForPEInterruptDisable = false;
 			}
-		
 		}
 		return;
 	}
@@ -492,11 +491,11 @@ void STACKALIGN GatherPipeBursted()
 
 void UpdateInterrupts(u64 userdata)
 {
-    if (userdata)
+	if (userdata)
 	{
 		interruptSet = true;
-        INFO_LOG(COMMANDPROCESSOR,"Interrupt set");
+		INFO_LOG(COMMANDPROCESSOR,"Interrupt set");
-        ProcessorInterface::SetInterrupt(INT_CAUSE_CP, true);        
+		ProcessorInterface::SetInterrupt(INT_CAUSE_CP, true);        
 	}
 	else
 	{
@@ -504,7 +503,7 @@ void UpdateInterrupts(u64 userdata)
 		INFO_LOG(COMMANDPROCESSOR,"Interrupt cleared");
 		ProcessorInterface::SetInterrupt(INT_CAUSE_CP, false);        
 	}
-    interruptWaiting = false;
+	interruptWaiting = false;
 }
 
 void UpdateInterruptsFromVideoBackend(u64 userdata)
@@ -520,11 +519,11 @@ void AbortFrame()
 
 void SetCpStatus(bool isCPUThread)
 {
-    // overflow & underflow check
+	// overflow & underflow check
 	fifo.bFF_HiWatermark = (fifo.CPReadWriteDistance > fifo.CPHiWatermark);
-    fifo.bFF_LoWatermark = (fifo.CPReadWriteDistance < fifo.CPLoWatermark);
+	fifo.bFF_LoWatermark = (fifo.CPReadWriteDistance < fifo.CPLoWatermark);
 
-    // breakpoint     
+	// breakpoint     
 	if (!isCPUThread)
 	{
 		if (fifo.bFF_BPEnable)
@@ -562,12 +561,12 @@ void SetCpStatus(bool isCPUThread)
 	isHiWatermarkActive = ovfInt && m_CPCtrlReg.GPReadEnable;
 	isLoWatermarkActive = undfInt && m_CPCtrlReg.GPReadEnable;
 
-    if (interrupt != interruptSet && !interruptWaiting)
+	if (interrupt != interruptSet && !interruptWaiting)
-    {
+	{
-        u64 userdata = interrupt?1:0;
+		u64 userdata = interrupt?1:0;
-        if (IsOnThread())
+		if (IsOnThread())
-        {
+		{
-            if (!interrupt || bpInt || undfInt || ovfInt)
+			if (!interrupt || bpInt || undfInt || ovfInt)
 			{
 				if (!isCPUThread)
 				{
@@ -579,14 +578,14 @@ void SetCpStatus(bool isCPUThread)
 				{
 					// CPU thread:
 					interruptSet = interrupt;
-				    INFO_LOG(COMMANDPROCESSOR,"Interrupt set");
+					INFO_LOG(COMMANDPROCESSOR,"Interrupt set");
-				    ProcessorInterface::SetInterrupt(INT_CAUSE_CP, interrupt);
+					ProcessorInterface::SetInterrupt(INT_CAUSE_CP, interrupt);
 				}
 			}
-        }
+		}
-        else
+		else
-            CommandProcessor::UpdateInterrupts(userdata);
+			CommandProcessor::UpdateInterrupts(userdata);
-    }
+	}
 }
 
 void ProcessFifoToLoWatermark()

Source/Core/VideoCommon/Src/Fifo.cpp

@@ -43,10 +43,10 @@ static int size = 0;
 
 void Fifo_DoState(PointerWrap &p) 
 {
-    p.DoArray(videoBuffer, FIFO_SIZE);
+	p.DoArray(videoBuffer, FIFO_SIZE);
-    p.Do(size);
+	p.Do(size);
-    p.DoPointer(g_pVideoData, videoBuffer);
+	p.DoPointer(g_pVideoData, videoBuffer);
-    p.Do(g_bSkipCurrentFrame);
+	p.Do(g_bSkipCurrentFrame);
 }
 
 void Fifo_PauseAndLock(bool doLock, bool unpauseOnUnlock)
@@ -70,7 +70,7 @@ void Fifo_PauseAndLock(bool doLock, bool unpauseOnUnlock)
 
 void Fifo_Init()
 {
-    videoBuffer = (u8*)AllocateMemoryPages(FIFO_SIZE);
+	videoBuffer = (u8*)AllocateMemoryPages(FIFO_SIZE);
 	size = 0;
 	GpuRunningState = false;
 	Common::AtomicStore(CommandProcessor::VITicks, CommandProcessor::m_cpClockOrigin);
@@ -79,12 +79,12 @@ void Fifo_Init()
 void Fifo_Shutdown()
 {
 	if (GpuRunningState) PanicAlert("Fifo shutting down while active");
-    FreeMemoryPages(videoBuffer, FIFO_SIZE);
+	FreeMemoryPages(videoBuffer, FIFO_SIZE);
 }
 
 u8* GetVideoBufferStartPtr()
 {
-    return videoBuffer;
+	return videoBuffer;
 }
 
 u8* GetVideoBufferEndPtr()
@@ -119,20 +119,20 @@ void EmulatorState(bool running)
 // Description: RunGpuLoop() sends data through this function.
 void ReadDataFromFifo(u8* _uData, u32 len)
 {
-    if (size + len >= FIFO_SIZE)
+	if (size + len >= FIFO_SIZE)
-    {
+	{
 		int pos = (int)(g_pVideoData - videoBuffer);
 		size -= pos;
-        if (size + len > FIFO_SIZE)
+		if (size + len > FIFO_SIZE)
-        {
+		{
-            PanicAlert("FIFO out of bounds (sz = %i, len = %i at %08x)", size, len, pos);
+			PanicAlert("FIFO out of bounds (sz = %i, len = %i at %08x)", size, len, pos);
-        }
+		}
-        memmove(&videoBuffer[0], &videoBuffer[pos], size);
+		memmove(&videoBuffer[0], &videoBuffer[pos], size);
 		g_pVideoData = videoBuffer;
-    }
+	}
 	// Copy new video instructions to videoBuffer for future use in rendering the new picture
-    memcpy(videoBuffer + size, _uData, len);
+	memcpy(videoBuffer + size, _uData, len);
-    size += len;
+	size += len;
 }
 
 void ResetVideoBuffer()
@@ -153,7 +153,7 @@ void RunGpuLoop()
 
 	while (GpuRunningState)
 	{
-        g_video_backend->PeekMessages();
+		g_video_backend->PeekMessages();
 
 		VideoFifo_CheckAsyncRequest();
 

Source/Core/VideoCommon/Src/FramebufferManagerBase.cpp

@@ -60,12 +60,12 @@ const XFBSourceBase* const* FramebufferManagerBase::GetRealXFBSource(u32 xfbAddr
 	m_realXFBSource->texHeight = fbHeight;
 
 	// TODO: stuff only used by OGL... :/
-    // OpenGL texture coordinates originate at the lower left, which is why
+	// OpenGL texture coordinates originate at the lower left, which is why
-    // sourceRc.top = fbHeight and sourceRc.bottom = 0.
+	// sourceRc.top = fbHeight and sourceRc.bottom = 0.
-    m_realXFBSource->sourceRc.left = 0;
+	m_realXFBSource->sourceRc.left = 0;
-    m_realXFBSource->sourceRc.top = fbHeight;
+	m_realXFBSource->sourceRc.top = fbHeight;
-    m_realXFBSource->sourceRc.right = fbWidth;
+	m_realXFBSource->sourceRc.right = fbWidth;
-    m_realXFBSource->sourceRc.bottom = 0;
+	m_realXFBSource->sourceRc.bottom = 0;
 
 	// Decode YUYV data from GameCube RAM
 	m_realXFBSource->DecodeToTexture(xfbAddr, fbWidth, fbHeight);

Source/Core/VideoCommon/Src/GenericTextureDecoder.cpp

@@ -664,14 +664,14 @@ PC_TexFormat TexDecoder_Decode_real(u8 *dst, const u8 *src, int width, int heigh
 		if (tlutfmt == 2)
 		{
 			// Special decoding is required for TLUT format 5A3
-						for (int y = 0; y < height; y += 8)
+			for (int y = 0; y < height; y += 8)
 				for (int x = 0, yStep = (y / 8) * Wsteps8; x < width; x += 8, yStep++)
 					for (int iy = 0, xStep = yStep * 8; iy < 8; iy++, xStep++)
 						decodebytesC4_5A3_To_BGRA32((u32*)dst + (y + iy) * width + x, src + 4 * xStep, tlutaddr);
 		}
 		else
 		{
-						for (int y = 0; y < height; y += 8)
+			for (int y = 0; y < height; y += 8)
 				for (int x = 0, yStep = (y / 8) * Wsteps8; x < width; x += 8, yStep++)
 					for (int iy = 0, xStep = yStep * 8; iy < 8; iy++, xStep++)
 						decodebytesC4_To_Raw16((u16*)dst + (y + iy) * width + x, src + 4 * xStep, tlutaddr);
@@ -679,7 +679,7 @@ PC_TexFormat TexDecoder_Decode_real(u8 *dst, const u8 *src, int width, int heigh
 		return GetPCFormatFromTLUTFormat(tlutfmt);
 	case GX_TF_I4:
 		{
-						for (int y = 0; y < height; y += 8)
+			for (int y = 0; y < height; y += 8)
 				for (int x = 0, yStep = (y / 8) * Wsteps8; x < width; x += 8, yStep++)
 					for (int iy = 0, xStep = yStep * 8 ; iy < 8; iy++,xStep++)
 						for (int ix = 0; ix < 4; ix++)
@@ -692,19 +692,17 @@ PC_TexFormat TexDecoder_Decode_real(u8 *dst, const u8 *src, int width, int heigh
 	   return PC_TEX_FMT_I4_AS_I8;
 	case GX_TF_I8:  // speed critical
 		{
-						for (int y = 0; y < height; y += 4)
+			for (int y = 0; y < height; y += 4)
 				for (int x = 0, yStep = (y / 4) * Wsteps8; x < width; x += 8, yStep++)
 					for (int iy = 0, xStep = 4 * yStep; iy < 4; iy++, xStep++)
-					{
 						((u64*)(dst + (y + iy) * width + x))[0] = ((u64*)(src + 8 * xStep))[0];
-					}
 		}
 		return PC_TEX_FMT_I8;
 	case GX_TF_C8:
 		if (tlutfmt == 2)
 		{
 			// Special decoding is required for TLUT format 5A3
-						for (int y = 0; y < height; y += 4)
+			for (int y = 0; y < height; y += 4)
 				for (int x = 0, yStep = (y / 4) * Wsteps8; x < width; x += 8, yStep++)
 					for (int iy = 0, xStep = 4 * yStep; iy < 4; iy++, xStep++)
 						decodebytesC8_5A3_To_BGRA32((u32*)dst + (y + iy) * width + x, src + 8 * xStep, tlutaddr);
@@ -713,7 +711,7 @@ PC_TexFormat TexDecoder_Decode_real(u8 *dst, const u8 *src, int width, int heigh
 		{
 
 			{
-								for (int y = 0; y < height; y += 4)
+				for (int y = 0; y < height; y += 4)
 					for (int x = 0, yStep = (y / 4) * Wsteps8; x < width; x += 8, yStep++)
 						for (int iy = 0, xStep = 4 * yStep; iy < 4; iy++, xStep++)
 							decodebytesC8_To_Raw16((u16*)dst + (y + iy) * width + x, src  + 8 * xStep, tlutaddr);
@@ -722,7 +720,7 @@ PC_TexFormat TexDecoder_Decode_real(u8 *dst, const u8 *src, int width, int heigh
 		return GetPCFormatFromTLUTFormat(tlutfmt);
 	case GX_TF_IA4:
 		{
-						for (int y = 0; y < height; y += 4)
+			for (int y = 0; y < height; y += 4)
 				for (int x = 0, yStep = (y / 4) * Wsteps8; x < width; x += 8, yStep++)
 					for (int iy = 0, xStep = 4 * yStep; iy < 4; iy++, xStep++)
 						decodebytesIA4((u16*)dst + (y + iy) * width + x, src + 8 * xStep);
@@ -730,7 +728,7 @@ PC_TexFormat TexDecoder_Decode_real(u8 *dst, const u8 *src, int width, int heigh
 		return PC_TEX_FMT_IA4_AS_IA8;
 	case GX_TF_IA8:
 		{
-						for (int y = 0; y < height; y += 4)
+			for (int y = 0; y < height; y += 4)
 				for (int x = 0, yStep = (y / 4) * Wsteps4; x < width; x += 4, yStep++)
 					for (int iy = 0, xStep = yStep * 4; iy < 4; iy++, xStep++)
 					{
@@ -739,21 +737,20 @@ PC_TexFormat TexDecoder_Decode_real(u8 *dst, const u8 *src, int width, int heigh
 						for(int j = 0; j < 4; j++)
 							*ptr++ = Common::swap16(*s++);
 					}
-
 		}
 		return PC_TEX_FMT_IA8;
 	case GX_TF_C14X2: 
 		if (tlutfmt == 2)
 		{
 			// Special decoding is required for TLUT format 5A3
-						for (int y = 0; y < height; y += 4)
+			for (int y = 0; y < height; y += 4)
 				for (int x = 0, yStep = (y / 4) * Wsteps4; x < width; x += 4, yStep++)
 					for (int iy = 0, xStep = 4 * yStep; iy < 4; iy++, xStep++)
 						decodebytesC14X2_5A3_To_BGRA32((u32*)dst + (y + iy) * width + x, (u16*)(src + 8 * xStep), tlutaddr);
 		}
 		else
 		{
-						for (int y = 0; y < height; y += 4)
+			for (int y = 0; y < height; y += 4)
 				for (int x = 0, yStep = (y / 4) * Wsteps4; x < width; x += 4, yStep++)
 					for (int iy = 0, xStep = 4 * yStep; iy < 4; iy++, xStep++)
 						decodebytesC14X2_To_Raw16((u16*)dst + (y + iy) * width + x,(u16*)(src + 8 * xStep), tlutaddr);
@@ -761,7 +758,7 @@ PC_TexFormat TexDecoder_Decode_real(u8 *dst, const u8 *src, int width, int heigh
 		return GetPCFormatFromTLUTFormat(tlutfmt);
 	case GX_TF_RGB565:
 		{
-						for (int y = 0; y < height; y += 4)
+			for (int y = 0; y < height; y += 4)
 				for (int x = 0, yStep = (y / 4) * Wsteps4; x < width; x += 4, yStep++)
 					for (int iy = 0, xStep = 4 * yStep; iy < 4; iy++, xStep++)
 					{
@@ -774,7 +771,7 @@ PC_TexFormat TexDecoder_Decode_real(u8 *dst, const u8 *src, int width, int heigh
 		return PC_TEX_FMT_RGB565;
 	case GX_TF_RGB5A3:
 		{
-						for (int y = 0; y < height; y += 4)
+			for (int y = 0; y < height; y += 4)
 				for (int x = 0, yStep = (y / 4) * Wsteps4; x < width; x += 4, yStep++)
 					for (int iy = 0, xStep = 4 * yStep; iy < 4; iy++, xStep++)
 						//decodebytesRGB5A3((u32*)dst+(y+iy)*width+x, (u16*)src, 4);
@@ -783,15 +780,14 @@ PC_TexFormat TexDecoder_Decode_real(u8 *dst, const u8 *src, int width, int heigh
 		return PC_TEX_FMT_BGRA32;
 	case GX_TF_RGBA8:  // speed critical
 		{
-
+			for (int y = 0; y < height; y += 4)
 			{
-								for (int y = 0; y < height; y += 4)
+				for (int x = 0, yStep = (y / 4) * Wsteps4; x < width; x += 4, yStep++)
-					for (int x = 0, yStep = (y / 4) * Wsteps4; x < width; x += 4, yStep++)
+				{
-					{
+					const u8* src2 = src + 64 * yStep;
-						const u8* src2 = src + 64 * yStep;
+					for (int iy = 0; iy < 4; iy++)
-						for (int iy = 0; iy < 4; iy++)
+						decodebytesARGB8_4((u32*)dst + (y+iy)*width + x, (u16*)src2 + 4 * iy, (u16*)src2 + 4 * iy + 16);
-							decodebytesARGB8_4((u32*)dst + (y+iy)*width + x, (u16*)src2 + 4 * iy, (u16*)src2 + 4 * iy + 16);						
+				}
-					}
 			}
 		}
 		return PC_TEX_FMT_BGRA32;
@@ -817,7 +813,7 @@ PC_TexFormat TexDecoder_Decode_real(u8 *dst, const u8 *src, int width, int heigh
 			}
 			return PC_TEX_FMT_DXT1;
 #else
-						for (int y = 0; y < height; y += 8)
+			for (int y = 0; y < height; y += 8)
 			{
 				for (int x = 0, yStep = (y / 8) * Wsteps8; x < width; x += 8, yStep++)
 				{
@@ -862,22 +858,21 @@ PC_TexFormat TexDecoder_Decode_RGBA(u32 * dst, const u8 * src, int width, int he
 		if (tlutfmt == 2)
 		{
 			// Special decoding is required for TLUT format 5A3
-						for (int y = 0; y < height; y += 8)
+			for (int y = 0; y < height; y += 8)
 				for (int x = 0, yStep = (y / 8) * Wsteps8; x < width; x += 8,yStep++)
 					for (int iy = 0, xStep =  8 * yStep; iy < 8; iy++,xStep++)
 						decodebytesC4_5A3_To_rgba32(dst + (y + iy) * width + x, src + 4 * xStep, tlutaddr);
 		}
 		else if(tlutfmt == 0)
 		{
-						for (int y = 0; y < height; y += 8)
+			for (int y = 0; y < height; y += 8)
 				for (int x = 0, yStep = (y / 8) * Wsteps8; x < width; x += 8,yStep++)
 					for (int iy = 0, xStep =  8 * yStep; iy < 8; iy++,xStep++)
 						decodebytesC4IA8_To_RGBA(dst + (y + iy) * width + x, src + 4 * xStep, tlutaddr);
-				
 		}
 		else
 		{
-						for (int y = 0; y < height; y += 8)
+			for (int y = 0; y < height; y += 8)
 				for (int x = 0, yStep = (y / 8) * Wsteps8; x < width; x += 8,yStep++)
 					for (int iy = 0, xStep =  8 * yStep; iy < 8; iy++,xStep++)
 						decodebytesC4RGB565_To_RGBA(dst + (y + iy) * width + x, src  + 4 * xStep, tlutaddr);
@@ -925,34 +920,33 @@ PC_TexFormat TexDecoder_Decode_RGBA(u32 * dst, const u8 * src, int width, int he
 		if (tlutfmt == 2)
 		{
 			// Special decoding is required for TLUT format 5A3
-						for (int y = 0; y < height; y += 4)
+			for (int y = 0; y < height; y += 4)
 				for (int x = 0, yStep = (y / 4) * Wsteps8; x < width; x += 8, yStep++)
 					for (int iy = 0, xStep = 4 * yStep; iy < 4; iy++, xStep++)
 						decodebytesC8_5A3_To_RGBA32((u32*)dst + (y + iy) * width + x, src + 8 * xStep, tlutaddr);
 		}
 		else if(tlutfmt == 0)
 		{
-						for (int y = 0; y < height; y += 4)
+			for (int y = 0; y < height; y += 4)
-					for (int x = 0, yStep = (y / 4) * Wsteps8; x < width; x += 8, yStep++)
+				for (int x = 0, yStep = (y / 4) * Wsteps8; x < width; x += 8, yStep++)
-						for (int iy = 0, xStep = 4 * yStep; iy < 4; iy++, xStep++)
+					for (int iy = 0, xStep = 4 * yStep; iy < 4; iy++, xStep++)
-							decodebytesC8IA8_To_RGBA(dst + (y + iy) * width + x, src + 8 * xStep, tlutaddr);
+						decodebytesC8IA8_To_RGBA(dst + (y + iy) * width + x, src + 8 * xStep, tlutaddr);
-			
 		}
 		else
 		{
-						for (int y = 0; y < height; y += 4)
+			for (int y = 0; y < height; y += 4)
-					for (int x = 0, yStep = (y / 4) * Wsteps8; x < width; x += 8, yStep++)
+				for (int x = 0, yStep = (y / 4) * Wsteps8; x < width; x += 8, yStep++)
-						for (int iy = 0, xStep = 4 * yStep; iy < 4; iy++, xStep++)
+					for (int iy = 0, xStep = 4 * yStep; iy < 4; iy++, xStep++)
-							decodebytesC8RGB565_To_RGBA(dst + (y + iy) * width + x, src + 8 * xStep, tlutaddr);			
+						decodebytesC8RGB565_To_RGBA(dst + (y + iy) * width + x, src + 8 * xStep, tlutaddr);			
 
 		}
 		break;
 	case GX_TF_IA4:
 		{
-						for (int y = 0; y < height; y += 4)
+			for (int y = 0; y < height; y += 4)
-					for (int x = 0, yStep = (y / 4) * Wsteps8; x < width; x += 8, yStep++)
+				for (int x = 0, yStep = (y / 4) * Wsteps8; x < width; x += 8, yStep++)
-						for (int iy = 0, xStep = 4 * yStep; iy < 4; iy++, xStep++)
+					for (int iy = 0, xStep = 4 * yStep; iy < 4; iy++, xStep++)
-							decodebytesIA4RGBA(dst + (y + iy) * width + x, src + 8 * xStep);
+						decodebytesIA4RGBA(dst + (y + iy) * width + x, src + 8 * xStep);
 		}
 		break;
 	case GX_TF_IA8:
@@ -975,21 +969,21 @@ PC_TexFormat TexDecoder_Decode_RGBA(u32 * dst, const u8 * src, int width, int he
 		if (tlutfmt == 2)
 		{
 			// Special decoding is required for TLUT format 5A3
-						for (int y = 0; y < height; y += 4)
+			for (int y = 0; y < height; y += 4)
 				for (int x = 0, yStep = (y / 4) * Wsteps4; x < width; x += 4, yStep++)
 					for (int iy = 0, xStep = 4 * yStep; iy < 4; iy++, xStep++)
 						decodebytesC14X2_5A3_To_BGRA32(dst + (y + iy) * width + x, (u16*)(src + 8 * xStep), tlutaddr);
 		}
 		else if (tlutfmt == 0)
 		{
-						for (int y = 0; y < height; y += 4)
+			for (int y = 0; y < height; y += 4)
 				for (int x = 0, yStep = (y / 4) * Wsteps4; x < width; x += 4, yStep++)
 					for (int iy = 0, xStep = 4 * yStep; iy < 4; iy++, xStep++)
 						decodebytesC14X2IA8_To_RGBA(dst + (y + iy) * width + x,  (u16*)(src + 8 * xStep), tlutaddr);
 		}
 		else
 		{
-						for (int y = 0; y < height; y += 4)
+			for (int y = 0; y < height; y += 4)
 				for (int x = 0, yStep = (y / 4) * Wsteps4; x < width; x += 4, yStep++)
 					for (int iy = 0, xStep = 4 * yStep; iy < 4; iy++, xStep++)
 						decodebytesC14X2rgb565_To_RGBA(dst + (y + iy) * width + x, (u16*)(src + 8 * xStep), tlutaddr);

Source/Core/VideoCommon/Src/ImageWrite.cpp

@@ -25,22 +25,22 @@
 
 struct TGA_HEADER
 {
-    u8  identsize;          // size of ID field that follows 18 u8 header (0 usually)
+	u8  identsize;          // size of ID field that follows 18 u8 header (0 usually)
-    u8  colourmaptype;      // type of colour map 0=none, 1=has palette
+	u8  colourmaptype;      // type of colour map 0=none, 1=has palette
-    u8  imagetype;          // type of image 0=none,1=indexed,2=rgb,3=grey,+8=rle packed
+	u8  imagetype;          // type of image 0=none,1=indexed,2=rgb,3=grey,+8=rle packed
 
-    s16 colourmapstart;     // first colour map entry in palette
+	s16 colourmapstart;     // first colour map entry in palette
-    s16 colourmaplength;    // number of colours in palette
+	s16 colourmaplength;    // number of colours in palette
-    u8  colourmapbits;      // number of bits per palette entry 15,16,24,32
+	u8  colourmapbits;      // number of bits per palette entry 15,16,24,32
 
-    s16 xstart;             // image x origin
+	s16 xstart;             // image x origin
-    s16 ystart;             // image y origin
+	s16 ystart;             // image y origin
-    s16 width;              // image width in pixels
+	s16 width;              // image width in pixels
-    s16 height;             // image height in pixels
+	s16 height;             // image height in pixels
-    u8  bits;               // image bits per pixel 8,16,24,32
+	u8  bits;               // image bits per pixel 8,16,24,32
-    u8  descriptor;         // image descriptor bits (vh flip bits)
+	u8  descriptor;         // image descriptor bits (vh flip bits)
 	
-    // pixel data follows header
+	// pixel data follows header
 };
 
 #pragma pack(pop)

Source/Core/VideoCommon/Src/IndexGenerator.cpp

@@ -63,7 +63,7 @@ void IndexGenerator::AddIndices(int primitive, u32 numVerts)
 	//case GX_DRAW_TRIANGLES:      IndexGenerator::AddList(numVerts);		break;
 	//case GX_DRAW_TRIANGLE_STRIP: IndexGenerator::AddStrip(numVerts);		break;
 	//case GX_DRAW_TRIANGLE_FAN:   IndexGenerator::AddFan(numVerts);		break;
-	//case GX_DRAW_LINES:		   IndexGenerator::AddLineList(numVerts);	break;
+	//case GX_DRAW_LINES:          IndexGenerator::AddLineList(numVerts);	break;
 	//case GX_DRAW_LINE_STRIP:     IndexGenerator::AddLineStrip(numVerts);	break;
 	//case GX_DRAW_POINTS:         IndexGenerator::AddPoints(numVerts);		break;
 	//}

Source/Core/VideoCommon/Src/OpcodeDecoding.cpp

@@ -123,7 +123,7 @@ void InterpretDisplayList(u32 address, u32 size)
 		Statistics::SwapDL();
 	}
 
-    // reset to the old pointer
+	// reset to the old pointer
 	g_pVideoData = old_pVideoData;
 }
 
@@ -140,14 +140,14 @@ u32 FifoCommandRunnable(u32 &command_size)
 {
 	u32 cycleTime = 0;
 	u32 buffer_size = (u32)(GetVideoBufferEndPtr() - g_pVideoData);
-    if (buffer_size == 0)
+	if (buffer_size == 0)
 		return 0;  // can't peek
 
 	u8 cmd_byte = DataPeek8(0);	
 
-    switch (cmd_byte)
+	switch (cmd_byte)
-    {
+	{
-    case GX_NOP: // Hm, this means that we scan over nop streams pretty slowly...
+	case GX_NOP: // Hm, this means that we scan over nop streams pretty slowly...
 		command_size = 1;
 		cycleTime = 6;
 		break;
@@ -155,30 +155,30 @@ u32 FifoCommandRunnable(u32 &command_size)
 		command_size = 1;
 		cycleTime = 6;
 		break;
-    case GX_CMD_UNKNOWN_METRICS: // zelda 4 swords calls it and checks the metrics registers after that
+	case GX_CMD_UNKNOWN_METRICS: // zelda 4 swords calls it and checks the metrics registers after that
-        command_size = 1;
+		command_size = 1;
 		cycleTime = 6;
-        break;
+		break;
 
 	case GX_LOAD_BP_REG:
-        command_size = 5;
+		command_size = 5;
 		cycleTime = 12;
-        break;
+		break;
 
-    case GX_LOAD_CP_REG:
+	case GX_LOAD_CP_REG:
-        command_size = 6;
+		command_size = 6;
 		cycleTime = 12;
-        break;
+		break;
 
-    case GX_LOAD_INDX_A:
+	case GX_LOAD_INDX_A:
-    case GX_LOAD_INDX_B:
+	case GX_LOAD_INDX_B:
-    case GX_LOAD_INDX_C:
+	case GX_LOAD_INDX_C:
-    case GX_LOAD_INDX_D:
+	case GX_LOAD_INDX_D:
-        command_size = 5;
+		command_size = 5;
 		cycleTime = 6; // TODO
-        break;
+		break;
 
-    case GX_CMD_CALL_DL:
+	case GX_CMD_CALL_DL:
 		{
 			// FIXME: Calculate the cycle time of the display list.
 			//u32 address = DataPeek32(1);
@@ -208,42 +208,42 @@ u32 FifoCommandRunnable(u32 &command_size)
 			command_size = 9;
 			cycleTime = 45;  // This is unverified
 		}
-        break;
+		break;
 
-    case GX_LOAD_XF_REG:
+	case GX_LOAD_XF_REG:
-        {
+		{
-            // check if we can read the header
+			// check if we can read the header
-            if (buffer_size >= 5)
+			if (buffer_size >= 5)
 			{
-                command_size = 1 + 4;
+				command_size = 1 + 4;
-                u32 Cmd2 = DataPeek32(1);
+				u32 Cmd2 = DataPeek32(1);
-                int transfer_size = ((Cmd2 >> 16) & 15) + 1;
+				int transfer_size = ((Cmd2 >> 16) & 15) + 1;
-                command_size += transfer_size * 4;
+				command_size += transfer_size * 4;
 				cycleTime = 18 + 6 * transfer_size;
-            }
+			}
-            else
-			{
-                return 0;
-            }			
-        }
-        break;
-
-    default:
-        if (cmd_byte & 0x80)
-        {				
-            // check if we can read the header
-            if (buffer_size >= 3)
-			{
-                command_size = 1 + 2;
-                u16 numVertices = DataPeek16(1);
-				command_size += numVertices * VertexLoaderManager::GetVertexSize(cmd_byte & GX_VAT_MASK);
-				cycleTime = 1600; // This depends on the number of pixels rendered
-            }
 			else
 			{
-                return 0;
+				return 0;
-            }
+			}
-        }
+		}
+		break;
+
+	default:
+		if (cmd_byte & 0x80)
+		{
+			// check if we can read the header
+			if (buffer_size >= 3)
+			{
+				command_size = 1 + 2;
+				u16 numVertices = DataPeek16(1);
+				command_size += numVertices * VertexLoaderManager::GetVertexSize(cmd_byte & GX_VAT_MASK);
+				cycleTime = 1600; // This depends on the number of pixels rendered
+			}
+			else
+			{
+				return 0;
+			}
+		}
 		else
 		{
 			// TODO(Omega): Maybe dump FIFO to file on this error
@@ -258,7 +258,7 @@ u32 FifoCommandRunnable(u32 &command_size)
 			Host_SysMessage(szTemp);
 			INFO_LOG(VIDEO, "%s", szTemp);
 			{
-                SCPFifoStruct &fifo = CommandProcessor::fifo;
+				SCPFifoStruct &fifo = CommandProcessor::fifo;
 
 				char szTmp[512];
 				// sprintf(szTmp, "Illegal command %02x (at %08x)",cmd_byte,g_pDataReader->GetPtr());
@@ -283,18 +283,18 @@ u32 FifoCommandRunnable(u32 &command_size)
 				Host_SysMessage(szTmp);
 				INFO_LOG(VIDEO, "%s", szTmp);
 			}
-        }
+		}
-        break;
+		break;
-    }
+	}
 
-    if (command_size > buffer_size)
+	if (command_size > buffer_size)
-        return 0;
+		return 0;
 
-    // INFO_LOG("OP detected: cmd_byte 0x%x  size %i  buffer %i",cmd_byte, command_size, buffer_size);
+	// INFO_LOG("OP detected: cmd_byte 0x%x  size %i  buffer %i",cmd_byte, command_size, buffer_size);
 	if (cycleTime == 0)
 		cycleTime = 6;
 
-    return cycleTime;
+	return cycleTime;
 }
 
 u32 FifoCommandRunnable()
@@ -305,92 +305,92 @@ u32 FifoCommandRunnable()
 
 static void Decode()
 {
-    u8 *opcodeStart = g_pVideoData;
+	u8 *opcodeStart = g_pVideoData;
 
-    int cmd_byte = DataReadU8();
+	int cmd_byte = DataReadU8();
-    switch (cmd_byte)
+	switch (cmd_byte)
-    {
+	{
-    case GX_NOP:
+	case GX_NOP:
-        break;
+		break;
 
-    case GX_LOAD_CP_REG: //0x08
+	case GX_LOAD_CP_REG: //0x08
-        {
+		{
-            u8 sub_cmd = DataReadU8();
+			u8 sub_cmd = DataReadU8();
-            u32 value = DataReadU32();
+			u32 value = DataReadU32();
-            LoadCPReg(sub_cmd, value);
+			LoadCPReg(sub_cmd, value);
 			INCSTAT(stats.thisFrame.numCPLoads);
-        }
+		}
-        break;
+		break;
 
-    case GX_LOAD_XF_REG:
+	case GX_LOAD_XF_REG:
-        {
+		{
-            u32 Cmd2 = DataReadU32();
+			u32 Cmd2 = DataReadU32();
-            int transfer_size = ((Cmd2 >> 16) & 15) + 1;
+			int transfer_size = ((Cmd2 >> 16) & 15) + 1;
 			u32 xf_address = Cmd2 & 0xFFFF;
 			GC_ALIGNED128(u32 data_buffer[16]);
 			DataReadU32xFuncs[transfer_size-1](data_buffer);
-            LoadXFReg(transfer_size, xf_address, data_buffer);
+			LoadXFReg(transfer_size, xf_address, data_buffer);
 
 			INCSTAT(stats.thisFrame.numXFLoads);
-        }
+		}
-        break;
+		break;
 
-    case GX_LOAD_INDX_A: //used for position matrices
+	case GX_LOAD_INDX_A: //used for position matrices
-        LoadIndexedXF(DataReadU32(), 0xC);
+		LoadIndexedXF(DataReadU32(), 0xC);
-        break;
+		break;
-    case GX_LOAD_INDX_B: //used for normal matrices
+	case GX_LOAD_INDX_B: //used for normal matrices
-        LoadIndexedXF(DataReadU32(), 0xD);
+		LoadIndexedXF(DataReadU32(), 0xD);
-        break;
+		break;
-    case GX_LOAD_INDX_C: //used for postmatrices
+	case GX_LOAD_INDX_C: //used for postmatrices
-        LoadIndexedXF(DataReadU32(), 0xE);
+		LoadIndexedXF(DataReadU32(), 0xE);
-        break;
+		break;
-    case GX_LOAD_INDX_D: //used for lights
+	case GX_LOAD_INDX_D: //used for lights
-        LoadIndexedXF(DataReadU32(), 0xF);
+		LoadIndexedXF(DataReadU32(), 0xF);
-        break;
+		break;
 
-    case GX_CMD_CALL_DL:
+	case GX_CMD_CALL_DL:
-        {
+		{
-            u32 address = DataReadU32();
+			u32 address = DataReadU32();
-            u32 count = DataReadU32();
+			u32 count = DataReadU32();
-            ExecuteDisplayList(address, count);
+			ExecuteDisplayList(address, count);
-        }			
+		}			
-        break;
+		break;
 
-    case GX_CMD_UNKNOWN_METRICS: // zelda 4 swords calls it and checks the metrics registers after that
+	case GX_CMD_UNKNOWN_METRICS: // zelda 4 swords calls it and checks the metrics registers after that
 		DEBUG_LOG(VIDEO, "GX 0x44: %08x", cmd_byte);
-        break;
+		break;
 
-    case GX_CMD_INVL_VC: // Invalidate Vertex Cache	
+	case GX_CMD_INVL_VC: // Invalidate Vertex Cache	
-        DEBUG_LOG(VIDEO, "Invalidate (vertex cache?)");
+		DEBUG_LOG(VIDEO, "Invalidate (vertex cache?)");
-        break;
+		break;
 
-    case GX_LOAD_BP_REG: //0x61
+	case GX_LOAD_BP_REG: //0x61
-        {
+		{
 			u32 bp_cmd = DataReadU32();
-            LoadBPReg(bp_cmd);
+			LoadBPReg(bp_cmd);
 			INCSTAT(stats.thisFrame.numBPLoads);
-        }
+		}
-        break;
+		break;
 
-    // draw primitives 
+	// draw primitives 
-    default:
+	default:
-        if (cmd_byte & 0x80)
+		if (cmd_byte & 0x80)
-        {
+		{
-            // load vertices (use computed vertex size from FifoCommandRunnable above)
+			// load vertices (use computed vertex size from FifoCommandRunnable above)
 			u16 numVertices = DataReadU16();
 
 			VertexLoaderManager::RunVertices(
 				cmd_byte & GX_VAT_MASK,   // Vertex loader index (0 - 7)
 				(cmd_byte & GX_PRIMITIVE_MASK) >> GX_PRIMITIVE_SHIFT,
 				numVertices);
-        }
+		}
-        else
+		else
-        {
+		{
 			ERROR_LOG(VIDEO, "OpcodeDecoding::Decode: Illegal command %02x", cmd_byte);
-            break;
+			break;
-        }
+		}
-        break;
+		break;
-    }
+	}
 
 	// Display lists get added directly into the FIFO stream
 	if (g_bRecordFifoData && cmd_byte != GX_CMD_CALL_DL)
@@ -399,82 +399,82 @@ static void Decode()
 
 static void DecodeSemiNop()
 {
-    u8 *opcodeStart = g_pVideoData;
+	u8 *opcodeStart = g_pVideoData;
 
-    int cmd_byte = DataReadU8();
+	int cmd_byte = DataReadU8();
-    switch (cmd_byte)
+	switch (cmd_byte)
-    {
+	{
-    case GX_CMD_UNKNOWN_METRICS: // zelda 4 swords calls it and checks the metrics registers after that
+	case GX_CMD_UNKNOWN_METRICS: // zelda 4 swords calls it and checks the metrics registers after that
-    case GX_CMD_INVL_VC: // Invalidate Vertex Cache	
+	case GX_CMD_INVL_VC: // Invalidate Vertex Cache	
-    case GX_NOP:
+	case GX_NOP:
 		break;
 
 	case GX_LOAD_CP_REG: //0x08
 		// We have to let CP writes through because they determine the size of vertices.
-        {
+		{
-            u8 sub_cmd = DataReadU8();
+			u8 sub_cmd = DataReadU8();
-            u32 value = DataReadU32();
+			u32 value = DataReadU32();
-            LoadCPReg(sub_cmd, value);
+			LoadCPReg(sub_cmd, value);
-            INCSTAT(stats.thisFrame.numCPLoads);
+			INCSTAT(stats.thisFrame.numCPLoads);
-        }
+		}
-        break;
+		break;
 
-    case GX_LOAD_XF_REG:
+	case GX_LOAD_XF_REG:
-        {
+		{
-            u32 Cmd2 = DataReadU32();
+			u32 Cmd2 = DataReadU32();
-            int transfer_size = ((Cmd2 >> 16) & 15) + 1;
+			int transfer_size = ((Cmd2 >> 16) & 15) + 1;
-            u32 address = Cmd2 & 0xFFFF;
+			u32 address = Cmd2 & 0xFFFF;
-            GC_ALIGNED128(u32 data_buffer[16]);
+			GC_ALIGNED128(u32 data_buffer[16]);
-            DataReadU32xFuncs[transfer_size-1](data_buffer);
+			DataReadU32xFuncs[transfer_size-1](data_buffer);
-            LoadXFReg(transfer_size, address, data_buffer);
+			LoadXFReg(transfer_size, address, data_buffer);
-            INCSTAT(stats.thisFrame.numXFLoads);
+			INCSTAT(stats.thisFrame.numXFLoads);
-        }
+		}
-        break;
+		break;
 
-    case GX_LOAD_INDX_A: //used for position matrices
+	case GX_LOAD_INDX_A: //used for position matrices
-        LoadIndexedXF(DataReadU32(), 0xC);
+		LoadIndexedXF(DataReadU32(), 0xC);
-        break;
+		break;
-    case GX_LOAD_INDX_B: //used for normal matrices
+	case GX_LOAD_INDX_B: //used for normal matrices
-        LoadIndexedXF(DataReadU32(), 0xD);
+		LoadIndexedXF(DataReadU32(), 0xD);
-        break;
+		break;
-    case GX_LOAD_INDX_C: //used for postmatrices
+	case GX_LOAD_INDX_C: //used for postmatrices
-        LoadIndexedXF(DataReadU32(), 0xE);
+		LoadIndexedXF(DataReadU32(), 0xE);
-        break;
+		break;
-    case GX_LOAD_INDX_D: //used for lights
+	case GX_LOAD_INDX_D: //used for lights
-        LoadIndexedXF(DataReadU32(), 0xF);
+		LoadIndexedXF(DataReadU32(), 0xF);
-        break;
+		break;
 
-    case GX_CMD_CALL_DL:
+	case GX_CMD_CALL_DL:
 		// Hm, wonder if any games put tokens in display lists - in that case, 
 		// we'll have to parse them too.
-        DataSkip(8);
+		DataSkip(8);
-        break;
+		break;
 
-    case GX_LOAD_BP_REG: //0x61
+	case GX_LOAD_BP_REG: //0x61
 		// We have to let BP writes through because they set tokens and stuff.
 		// TODO: Call a much simplified LoadBPReg instead.
-        {
+		{
 			u32 bp_cmd = DataReadU32();
-            LoadBPReg(bp_cmd);
+			LoadBPReg(bp_cmd);
 			INCSTAT(stats.thisFrame.numBPLoads);
-        }
+		}
-        break;
+		break;
 
-    // draw primitives 
+	// draw primitives 
-    default:
+	default:
-        if (cmd_byte & 0x80)
+		if (cmd_byte & 0x80)
-        {
+		{
-            // load vertices (use computed vertex size from FifoCommandRunnable above)
+			// load vertices (use computed vertex size from FifoCommandRunnable above)
 			u16 numVertices = DataReadU16();
 			DataSkip(numVertices * VertexLoaderManager::GetVertexSize(cmd_byte & GX_VAT_MASK));
-        }
+		}
-        else
+		else
-        {
+		{
 			ERROR_LOG(VIDEO, "OpcodeDecoding::Decode: Illegal command %02x", cmd_byte);
-            break;
+			break;
-        }
+		}
-        break;
+		break;
-    }
+	}
 
 	if (g_bRecordFifoData && cmd_byte != GX_CMD_CALL_DL)
 		FifoRecorder::GetInstance().WriteGPCommand(opcodeStart, u32(g_pVideoData - opcodeStart));
@@ -494,8 +494,8 @@ void OpcodeDecoder_Init()
 
 	if (g_Config.bEnableOpenCL)
 	{
-	    OpenCL::Initialize();
+		OpenCL::Initialize();
-	    TexDecoder_OpenCL_Initialize();
+		TexDecoder_OpenCL_Initialize();
 	}
 }
 
@@ -504,8 +504,8 @@ void OpcodeDecoder_Shutdown()
 {
 	if (g_Config.bEnableOpenCL)
 	{
-	    TexDecoder_OpenCL_Shutdown();
+		TexDecoder_OpenCL_Shutdown();
-	    OpenCL::Destroy();
+		OpenCL::Destroy();
 	}
 }
 

Source/Core/VideoCommon/Src/OpcodeDecoding.h

@@ -44,7 +44,7 @@
 #define GX_DRAW_LINES               0x5   // 0xA8
 #define GX_DRAW_LINE_STRIP          0x6   // 0xB0
 #define GX_DRAW_POINTS              0x7   // 0xB8
-#define GX_DRAW_NONE				0x1;  //Tis is a fake value to used in the backends
+#define GX_DRAW_NONE                0x1;  //Tis is a fake value to used in the backends
 
 extern bool g_bRecordFifoData;
 

Source/Core/VideoCommon/Src/OpenCL.cpp

@@ -148,25 +148,25 @@ cl_program CompileProgram(const char *Kernel)
 	// Build the program executable
 	err = clBuildProgram(program , 0, NULL, NULL, NULL, NULL);
 	if(err != CL_SUCCESS) {
-        HandleCLError(err, "Error: failed to build program");
+		HandleCLError(err, "Error: failed to build program");
 
 		char *buildlog = NULL;
-        size_t buildlog_size = 0;
+		size_t buildlog_size = 0;
 
 		clGetProgramBuildInfo(program, OpenCL::device_id, CL_PROGRAM_BUILD_LOG, 0, NULL, &buildlog_size);
-        buildlog = new char[buildlog_size + 1];
+		buildlog = new char[buildlog_size + 1];
-        err = clGetProgramBuildInfo(program, OpenCL::device_id, CL_PROGRAM_BUILD_LOG, buildlog_size, buildlog, NULL);
+		err = clGetProgramBuildInfo(program, OpenCL::device_id, CL_PROGRAM_BUILD_LOG, buildlog_size, buildlog, NULL);
-        buildlog[buildlog_size] = 0;
+		buildlog[buildlog_size] = 0;
 		
-        if(err != CL_SUCCESS)
+		if(err != CL_SUCCESS)
-        {
+		{
-            HandleCLError(err, "Error: can't get build log");
+			HandleCLError(err, "Error: can't get build log");
-        } else
+		} else
-        {
+		{
-		    ERROR_LOG(COMMON, "Error log:\n%s\n", buildlog);
+			ERROR_LOG(COMMON, "Error log:\n%s\n", buildlog);
-        }
+		}
 
-        delete[] buildlog;
+		delete[] buildlog;
 		return NULL;
 	}
 

Source/Core/VideoCommon/Src/PixelEngine.cpp

@@ -126,8 +126,8 @@ bool bbox_active;
 
 enum
 {
-    INT_CAUSE_PE_TOKEN    =  0x200, // GP Token
+	INT_CAUSE_PE_TOKEN    =  0x200, // GP Token
-    INT_CAUSE_PE_FINISH   =  0x400, // GP Finished
+	INT_CAUSE_PE_FINISH   =  0x400, // GP Finished
 };
 
 void DoState(PointerWrap &p)

Source/Core/VideoCommon/Src/PixelEngine.h

@@ -24,13 +24,13 @@ class PointerWrap;
 // internal hardware addresses
 enum
 {
-	PE_ZCONF         = 0x00, // Z Config
+	PE_ZCONF		 = 0x00, // Z Config
-	PE_ALPHACONF     = 0x02, // Alpha Config
+	PE_ALPHACONF	 = 0x02, // Alpha Config
-	PE_DSTALPHACONF  = 0x04, // Destination Alpha Config
+	PE_DSTALPHACONF	 = 0x04, // Destination Alpha Config
-	PE_ALPHAMODE     = 0x06, // Alpha Mode Config
+	PE_ALPHAMODE	 = 0x06, // Alpha Mode Config
-	PE_ALPHAREAD     = 0x08, // Alpha Read
+	PE_ALPHAREAD	 = 0x08, // Alpha Read
 	PE_CTRL_REGISTER = 0x0a, // Control
-	PE_TOKEN_REG     = 0x0e, // Token
+	PE_TOKEN_REG	 = 0x0e, // Token
 	PE_BBOX_LEFT	 = 0x10, // Flip Left
 	PE_BBOX_RIGHT	 = 0x12, // Flip Right
 	PE_BBOX_TOP		 = 0x14, // Flip Top

Source/Core/VideoCommon/Src/PixelShaderGen.cpp

@@ -374,38 +374,38 @@ static const char *tevOpTable[] = { // TEV
 
 static const char *tevCInputTable[] = // CC
 {
-	"(prev.rgb)",               // CPREV,
+	"(prev.rgb)",         // CPREV,
 	"(prev.aaa)",         // APREV,
-	"(c0.rgb)",                 // C0,
+	"(c0.rgb)",           // C0,
 	"(c0.aaa)",           // A0,
-	"(c1.rgb)",                 // C1,
+	"(c1.rgb)",           // C1,
 	"(c1.aaa)",           // A1,
-	"(c2.rgb)",                 // C2,
+	"(c2.rgb)",           // C2,
 	"(c2.aaa)",           // A2,
-	"(textemp.rgb)",            // TEXC,
+	"(textemp.rgb)",      // TEXC,
 	"(textemp.aaa)",      // TEXA,
-	"(rastemp.rgb)",            // RASC,
+	"(rastemp.rgb)",      // RASC,
 	"(rastemp.aaa)",      // RASA,
 	"float3(1.0f, 1.0f, 1.0f)",              // ONE
-	"float3(0.5f, 0.5f, 0.5f)",                 // HALF
+	"float3(0.5f, 0.5f, 0.5f)",              // HALF
-	"(konsttemp.rgb)", //"konsttemp.rgb",        // KONST
+	"(konsttemp.rgb)", //"konsttemp.rgb",    // KONST
 	"float3(0.0f, 0.0f, 0.0f)",              // ZERO
 	///aded extra values to map clamped values
-	"(cprev.rgb)",               // CPREV,
+	"(cprev.rgb)",        // CPREV,
-	"(cprev.aaa)",         // APREV,
+	"(cprev.aaa)",        // APREV,
-	"(cc0.rgb)",                 // C0,
+	"(cc0.rgb)",          // C0,
-	"(cc0.aaa)",           // A0,
+	"(cc0.aaa)",          // A0,
-	"(cc1.rgb)",                 // C1,
+	"(cc1.rgb)",          // C1,
-	"(cc1.aaa)",           // A1,
+	"(cc1.aaa)",          // A1,
-	"(cc2.rgb)",                 // C2,
+	"(cc2.rgb)",          // C2,
-	"(cc2.aaa)",           // A2,
+	"(cc2.aaa)",          // A2,
-	"(textemp.rgb)",            // TEXC,
+	"(textemp.rgb)",      // TEXC,
 	"(textemp.aaa)",      // TEXA,
-	"(crastemp.rgb)",            // RASC,
+	"(crastemp.rgb)",     // RASC,
-	"(crastemp.aaa)",      // RASA,
+	"(crastemp.aaa)",     // RASA,
 	"float3(1.0f, 1.0f, 1.0f)",              // ONE
-	"float3(0.5f, 0.5f, 0.5f)",                 // HALF
+	"float3(0.5f, 0.5f, 0.5f)",              // HALF
-	"(ckonsttemp.rgb)", //"konsttemp.rgb",        // KONST
+	"(ckonsttemp.rgb)", //"konsttemp.rgb",   // KONST
 	"float3(0.0f, 0.0f, 0.0f)",              // ZERO
 	"PADERROR1", "PADERROR2", "PADERROR3", "PADERROR4"
 };
@@ -425,7 +425,7 @@ static const char *tevAInputTable[] = // CA
 	"cc0",              // A0,
 	"cc1",              // A1,
 	"cc2",              // A2,
-	"textemp",         // TEXA,
+	"textemp",          // TEXA,
 	"crastemp",         // RASA,
 	"ckonsttemp",       // KONST,  (hw1 had quarter)
 	"float4(0.0f, 0.0f, 0.0f, 0.0f)", // ZERO

Source/Core/VideoCommon/Src/PixelShaderGen.h

@@ -28,8 +28,8 @@
 #define I_INDTEXSCALE "cindscale"
 #define I_INDTEXMTX   "cindmtx"
 #define I_FOG         "cfog"
-#define I_PLIGHTS	  "cPLights"
+#define I_PLIGHTS     "cPLights"
-#define I_PMATERIALS   "cPmtrl"
+#define I_PMATERIALS  "cPmtrl"
 
 #define C_COLORMATRIX	0						// 0
 #define C_COLORS		0						// 0

Source/Core/VideoCommon/Src/PixelShaderManager.cpp

@@ -87,61 +87,61 @@ void PixelShaderManager::SetConstants()
 {
 	if (g_ActiveConfig.backend_info.APIType == API_OPENGL && !g_ActiveConfig.backend_info.bSupportsGLSLUBO)
 		Dirty();
-    for (int i = 0; i < 2; ++i)
+	for (int i = 0; i < 2; ++i)
 	{
-        if (s_nColorsChanged[i])
+		if (s_nColorsChanged[i])
 		{
-            int baseind = i ? C_KCOLORS : C_COLORS;
+			int baseind = i ? C_KCOLORS : C_COLORS;
-            for (int j = 0; j < 4; ++j)
+			for (int j = 0; j < 4; ++j)
 			{
-                if (s_nColorsChanged[i] & (1 << j))
+				if (s_nColorsChanged[i] & (1 << j))
-                    SetPSConstant4fv(baseind+j, &lastRGBAfull[i][j][0]);
+					SetPSConstant4fv(baseind+j, &lastRGBAfull[i][j][0]);
-            }
+			}
-            s_nColorsChanged[i] = 0;
+			s_nColorsChanged[i] = 0;
-        }
+		}
-    }
+	}
 
-    if (s_nTexDimsChanged)
+	if (s_nTexDimsChanged)
 	{
-        for (int i = 0; i < 8; ++i)
+		for (int i = 0; i < 8; ++i)
 		{
-            if (s_nTexDimsChanged & (1<<i))
+			if (s_nTexDimsChanged & (1<<i))
 				SetPSTextureDims(i);
-        }
+		}
-        s_nTexDimsChanged = 0;
+		s_nTexDimsChanged = 0;
-    }
+	}
 
-    if (s_bAlphaChanged)
+	if (s_bAlphaChanged)
 	{
 		SetPSConstant4f(C_ALPHA, (lastAlpha&0xff)/255.0f, ((lastAlpha>>8)&0xff)/255.0f, 0, ((lastAlpha>>16)&0xff)/255.0f);
 		s_bAlphaChanged = false;
-    }
+	}
 
 	if (s_bZTextureTypeChanged)
 	{
-        float ftemp[4];
+		float ftemp[4];
-        switch (bpmem.ztex2.type)
+		switch (bpmem.ztex2.type)
 		{
-             case 0:
+			 case 0:
-                // 8 bits
+				// 8 bits
-                ftemp[0] = 0; ftemp[1] = 0; ftemp[2] = 0; ftemp[3] = 255.0f/16777215.0f;
+				ftemp[0] = 0; ftemp[1] = 0; ftemp[2] = 0; ftemp[3] = 255.0f/16777215.0f;
-                break;
+				break;
-            case 1:
+			case 1:
-                // 16 bits
+				// 16 bits
-                ftemp[0] = 255.0f/16777215.0f; ftemp[1] = 0; ftemp[2] = 0; ftemp[3] = 65280.0f/16777215.0f;
+				ftemp[0] = 255.0f/16777215.0f; ftemp[1] = 0; ftemp[2] = 0; ftemp[3] = 65280.0f/16777215.0f;
-                break;
+				break;
-            case 2:
+			case 2:
-                // 24 bits
+				// 24 bits
 				ftemp[0] = 16711680.0f/16777215.0f; ftemp[1] = 65280.0f/16777215.0f; ftemp[2] = 255.0f/16777215.0f; ftemp[3] = 0;
-                break;
+				break;
-        }
+		}
 		SetPSConstant4fv(C_ZBIAS, ftemp);
 		s_bZTextureTypeChanged = false;
 	}
 
 	if (s_bZBiasChanged || s_bDepthRangeChanged)
 	{
-        // reversed gxsetviewport(xorig, yorig, width, height, nearz, farz)
+		// reversed gxsetviewport(xorig, yorig, width, height, nearz, farz)
 		// [0] = width/2
 		// [1] = height/2
 		// [2] = 16777215 * (farz - nearz)
@@ -152,78 +152,78 @@ void PixelShaderManager::SetConstants()
 		//ERROR_LOG("pixel=%x,%x, bias=%x\n", bpmem.zcontrol.pixel_format, bpmem.ztex2.type, lastZBias);
 		SetPSConstant4f(C_ZBIAS+1, xfregs.viewport.farZ / 16777216.0f, xfregs.viewport.zRange / 16777216.0f, 0, (float)(lastZBias)/16777215.0f);
 		s_bZBiasChanged = s_bDepthRangeChanged = false;
-    }
+	}
 
-    // indirect incoming texture scales
+	// indirect incoming texture scales
-    if (s_nIndTexScaleChanged)
+	if (s_nIndTexScaleChanged)
 	{
 		// set as two sets of vec4s, each containing S and T of two ind stages.
-        float f[8];
+		float f[8];
 
-        if (s_nIndTexScaleChanged & 0x03)
+		if (s_nIndTexScaleChanged & 0x03)
 		{
-            for (u32 i = 0; i < 2; ++i)
+			for (u32 i = 0; i < 2; ++i)
 			{
-                f[2 * i] = bpmem.texscale[0].getScaleS(i & 1);
+				f[2 * i] = bpmem.texscale[0].getScaleS(i & 1);
-                f[2 * i + 1] = bpmem.texscale[0].getScaleT(i & 1);
+				f[2 * i + 1] = bpmem.texscale[0].getScaleT(i & 1);
-                PRIM_LOG("tex indscale%d: %f %f\n", i, f[2 * i], f[2 * i + 1]);
+				PRIM_LOG("tex indscale%d: %f %f\n", i, f[2 * i], f[2 * i + 1]);
-            }
+			}
 			SetPSConstant4fv(C_INDTEXSCALE, f);
-        }
+		}
 
-        if (s_nIndTexScaleChanged & 0x0c) {
+		if (s_nIndTexScaleChanged & 0x0c) {
-            for (u32 i = 2; i < 4; ++i) {
+			for (u32 i = 2; i < 4; ++i) {
-                f[2 * i] = bpmem.texscale[1].getScaleS(i & 1);
+				f[2 * i] = bpmem.texscale[1].getScaleS(i & 1);
-                f[2 * i + 1] = bpmem.texscale[1].getScaleT(i & 1);
+				f[2 * i + 1] = bpmem.texscale[1].getScaleT(i & 1);
-                PRIM_LOG("tex indscale%d: %f %f\n", i, f[2 * i], f[2 * i + 1]);
+				PRIM_LOG("tex indscale%d: %f %f\n", i, f[2 * i], f[2 * i + 1]);
-            }
+			}
 			SetPSConstant4fv(C_INDTEXSCALE+1, &f[4]);
-        }
+		}
 
-        s_nIndTexScaleChanged = 0;
+		s_nIndTexScaleChanged = 0;
-    }
+	}
 
-    if (s_nIndTexMtxChanged)
+	if (s_nIndTexMtxChanged)
 	{
-        for (int i = 0; i < 3; ++i)
+		for (int i = 0; i < 3; ++i)
 		{
-            if (s_nIndTexMtxChanged & (1 << i))
+			if (s_nIndTexMtxChanged & (1 << i))
 			{
-                int scale = ((u32)bpmem.indmtx[i].col0.s0 << 0) |
+				int scale = ((u32)bpmem.indmtx[i].col0.s0 << 0) |
-					        ((u32)bpmem.indmtx[i].col1.s1 << 2) |
+							((u32)bpmem.indmtx[i].col1.s1 << 2) |
-					        ((u32)bpmem.indmtx[i].col2.s2 << 4);
+							((u32)bpmem.indmtx[i].col2.s2 << 4);
-                float fscale = powf(2.0f, (float)(scale - 17)) / 1024.0f;
+				float fscale = powf(2.0f, (float)(scale - 17)) / 1024.0f;
 
-                // xyz - static matrix
+				// xyz - static matrix
-                // TODO w - dynamic matrix scale / 256...... somehow / 4 works better
+				// TODO w - dynamic matrix scale / 256...... somehow / 4 works better
-                // rev 2972 - now using / 256.... verify that this works
+				// rev 2972 - now using / 256.... verify that this works
 				SetPSConstant4f(C_INDTEXMTX + 2 * i,
-                    bpmem.indmtx[i].col0.ma * fscale,
+					bpmem.indmtx[i].col0.ma * fscale,
 					bpmem.indmtx[i].col1.mc * fscale,
 					bpmem.indmtx[i].col2.me * fscale,
 					fscale * 4.0f);
-                SetPSConstant4f(C_INDTEXMTX + 2 * i + 1,
+				SetPSConstant4f(C_INDTEXMTX + 2 * i + 1,
-                    bpmem.indmtx[i].col0.mb * fscale,
+					bpmem.indmtx[i].col0.mb * fscale,
 					bpmem.indmtx[i].col1.md * fscale,
 					bpmem.indmtx[i].col2.mf * fscale,
 					fscale * 4.0f);
 
-                PRIM_LOG("indmtx%d: scale=%f, mat=(%f %f %f; %f %f %f)\n",
+				PRIM_LOG("indmtx%d: scale=%f, mat=(%f %f %f; %f %f %f)\n",
-                	i, 1024.0f*fscale,
+					i, 1024.0f*fscale,
-                	bpmem.indmtx[i].col0.ma * fscale, bpmem.indmtx[i].col1.mc * fscale, bpmem.indmtx[i].col2.me * fscale,
+					bpmem.indmtx[i].col0.ma * fscale, bpmem.indmtx[i].col1.mc * fscale, bpmem.indmtx[i].col2.me * fscale,
-                	bpmem.indmtx[i].col0.mb * fscale, bpmem.indmtx[i].col1.md * fscale, bpmem.indmtx[i].col2.mf * fscale);
+					bpmem.indmtx[i].col0.mb * fscale, bpmem.indmtx[i].col1.md * fscale, bpmem.indmtx[i].col2.mf * fscale);
-            }
+			}
-        }
+		}
-        s_nIndTexMtxChanged = 0;
+		s_nIndTexMtxChanged = 0;
-    }
+	}
 
-    if (s_bFogColorChanged)
+	if (s_bFogColorChanged)
 	{
 		SetPSConstant4f(C_FOG, bpmem.fog.color.r / 255.0f, bpmem.fog.color.g / 255.0f, bpmem.fog.color.b / 255.0f, 0);
 		s_bFogColorChanged = false;
-    }
+	}
 
-    if (s_bFogParamChanged)
+	if (s_bFogParamChanged)
 	{
 		if(!g_ActiveConfig.bDisableFog)
 		{
@@ -236,8 +236,8 @@ void PixelShaderManager::SetConstants()
 		else
 			SetPSConstant4f(C_FOG + 1, 0.0, 1.0, 0.0, 1.0);
 
-        s_bFogParamChanged = false;
+		s_bFogParamChanged = false;
-    }
+	}
 
 	if (s_bFogRangeAdjustChanged)
 	{
@@ -341,11 +341,11 @@ void PixelShaderManager::SetConstants()
 
 void PixelShaderManager::SetPSTextureDims(int texid)
 {
-    // texdims.xy are reciprocals of the real texture dimensions
+	// texdims.xy are reciprocals of the real texture dimensions
-    // texdims.zw are the scaled dimensions
+	// texdims.zw are the scaled dimensions
-    float fdims[4];
+	float fdims[4];
 
-    TCoordInfo& tc = bpmem.texcoords[texid];
+	TCoordInfo& tc = bpmem.texcoords[texid];
 	fdims[0] = 1.0f / (float)(lastTexDims[texid] & 0xffff);
 	fdims[1] = 1.0f / (float)((lastTexDims[texid] >> 16) & 0xfff);
 	fdims[2] = (float)(tc.s.scale_minus_1 + 1);
@@ -359,7 +359,7 @@ void PixelShaderManager::SetPSTextureDims(int texid)
 // and update it when the shader constant is set, only.
 void PixelShaderManager::SetColorChanged(int type, int num, bool high)
 {
-    float *pf = &lastRGBAfull[type][num][0];
+	float *pf = &lastRGBAfull[type][num][0];
 	if (!high) {
 		int r = bpmem.tevregs[num].low.a;
 		int a = bpmem.tevregs[num].low.b;
@@ -371,45 +371,45 @@ void PixelShaderManager::SetColorChanged(int type, int num, bool high)
 		pf[1] = (float)g * (1.0f / 255.0f);
 		pf[2] = (float)b * (1.0f / 255.0f);
 	}
-    s_nColorsChanged[type] |= 1 << num;
+	s_nColorsChanged[type] |= 1 << num;
-    PRIM_LOG("pixel %scolor%d: %f %f %f %f\n", type?"k":"", num, pf[0], pf[1], pf[2], pf[3]);
+	PRIM_LOG("pixel %scolor%d: %f %f %f %f\n", type?"k":"", num, pf[0], pf[1], pf[2], pf[3]);
 }
 
 void PixelShaderManager::SetAlpha(const AlphaTest& alpha)
 {
-    if ((alpha.hex & 0xffff) != lastAlpha)
+	if ((alpha.hex & 0xffff) != lastAlpha)
 	{
-        lastAlpha = (lastAlpha & ~0xffff) | (alpha.hex & 0xffff);
+		lastAlpha = (lastAlpha & ~0xffff) | (alpha.hex & 0xffff);
-        s_bAlphaChanged = true;
+		s_bAlphaChanged = true;
-    }
+	}
 }
 
 void PixelShaderManager::SetDestAlpha(const ConstantAlpha& alpha)
 {
-    if (alpha.alpha != (lastAlpha >> 16))
+	if (alpha.alpha != (lastAlpha >> 16))
 	{
-        lastAlpha = (lastAlpha & ~0xff0000) | ((alpha.hex & 0xff) << 16);
+		lastAlpha = (lastAlpha & ~0xff0000) | ((alpha.hex & 0xff) << 16);
-        s_bAlphaChanged = true;
+		s_bAlphaChanged = true;
-    }
+	}
 }
 
 void PixelShaderManager::SetTexDims(int texmapid, u32 width, u32 height, u32 wraps, u32 wrapt)
 {
-    u32 wh = width | (height << 16) | (wraps << 28) | (wrapt << 30);
+	u32 wh = width | (height << 16) | (wraps << 28) | (wrapt << 30);
-    if (lastTexDims[texmapid] != wh)
+	if (lastTexDims[texmapid] != wh)
 	{
-        lastTexDims[texmapid] = wh;
+		lastTexDims[texmapid] = wh;
 		s_nTexDimsChanged |= 1 << texmapid;
-    }
+	}
 }
 
 void PixelShaderManager::SetZTextureBias(u32 bias)
 {
-    if (lastZBias != bias)
+	if (lastZBias != bias)
 	{
-        s_bZBiasChanged = true;
+		s_bZBiasChanged = true;
-        lastZBias = bias;
+		lastZBias = bias;
-    }
+	}
 }
 
 void PixelShaderManager::SetViewportChanged()
@@ -420,12 +420,12 @@ void PixelShaderManager::SetViewportChanged()
 
 void PixelShaderManager::SetIndTexScaleChanged(u8 stagemask)
 {
-    s_nIndTexScaleChanged |= stagemask;
+	s_nIndTexScaleChanged |= stagemask;
 }
 
 void PixelShaderManager::SetIndMatrixChanged(int matrixidx)
 {
-    s_nIndTexMtxChanged |= 1 << matrixidx;
+	s_nIndTexMtxChanged |= 1 << matrixidx;
 }
 
 void PixelShaderManager::SetZTextureTypeChanged()
@@ -435,22 +435,22 @@ void PixelShaderManager::SetZTextureTypeChanged()
 
 void PixelShaderManager::SetTexCoordChanged(u8 texmapid)
 {
-    s_nTexDimsChanged |= 1 << texmapid;
+	s_nTexDimsChanged |= 1 << texmapid;
 }
 
 void PixelShaderManager::SetFogColorChanged()
 {
-    s_bFogColorChanged = true;
+	s_bFogColorChanged = true;
 }
 
 void PixelShaderManager::SetFogParamChanged()
 {
-    s_bFogParamChanged = true;
+	s_bFogParamChanged = true;
 }
 
 void PixelShaderManager::SetFogRangeAdjustChanged()
 {
-    s_bFogRangeAdjustChanged = true;
+	s_bFogRangeAdjustChanged = true;
 }
 
 void PixelShaderManager::SetColorMatrix(const float* pmatrix)

Source/Core/VideoCommon/Src/PixelShaderManager.h

@@ -54,7 +54,6 @@ public:
 	static void SetColorMatrix(const float* pmatrix);
 	static void InvalidateXFRange(int start, int end);
 	static void SetMaterialColorChanged(int index);
-	
 };
 
 

Source/Core/VideoCommon/Src/Statistics.cpp

@@ -53,8 +53,8 @@ char *Statistics::ToString(char *ptr)
 	ptr+=sprintf(ptr,"pshaders (unique, delete cache first): %i\n",stats.numUniquePixelShaders);
 	ptr+=sprintf(ptr,"vshaders created: %i\n",stats.numVertexShadersCreated);
 	ptr+=sprintf(ptr,"vshaders alive: %i\n",stats.numVertexShadersAlive);
-    ptr+=sprintf(ptr,"dlists called:    %i\n",stats.numDListsCalled);
+	ptr+=sprintf(ptr,"dlists called:    %i\n",stats.numDListsCalled);
-    ptr+=sprintf(ptr,"dlists called(f): %i\n",stats.thisFrame.numDListsCalled);
+	ptr+=sprintf(ptr,"dlists called(f): %i\n",stats.thisFrame.numDListsCalled);
 	ptr+=sprintf(ptr,"dlists alive:     %i\n",stats.numDListsAlive);
 	ptr+=sprintf(ptr,"primitive joins: %i\n",stats.thisFrame.numPrimitiveJoins);
 	ptr+=sprintf(ptr,"draw calls:       %i\n",stats.thisFrame.numDrawCalls);

Source/Core/VideoCommon/Src/Statistics.h

@@ -24,20 +24,20 @@
 
 struct Statistics
 {
-    int numPixelShadersCreated;
+	int numPixelShadersCreated;
-    int numPixelShadersAlive;
+	int numPixelShadersAlive;
-    int numVertexShadersCreated;
+	int numVertexShadersCreated;
-    int numVertexShadersAlive;
+	int numVertexShadersAlive;
 
-    int numTexturesCreated;
+	int numTexturesCreated;
-    int numTexturesAlive;
+	int numTexturesAlive;
 
-    int numRenderTargetsCreated;
+	int numRenderTargetsCreated;
-    int numRenderTargetsAlive;
+	int numRenderTargetsAlive;
 	
-    int numDListsCalled;
+	int numDListsCalled;
-    int numDListsCreated;
+	int numDListsCreated;
-    int numDListsAlive;
+	int numDListsAlive;
 
 	int numVertexLoaders;
 
@@ -52,30 +52,30 @@ struct Statistics
 
 	std::vector<EFBRectangle> efb_regions;
 
-    struct ThisFrame
+	struct ThisFrame
-    {
+	{
-        int numBPLoads;
+		int numBPLoads;
-        int numCPLoads;
+		int numCPLoads;
-        int numXFLoads;
+		int numXFLoads;
 		
-        int numBPLoadsInDL;
+		int numBPLoadsInDL;
-        int numCPLoadsInDL;
+		int numCPLoadsInDL;
-        int numXFLoadsInDL;
+		int numXFLoadsInDL;
 		
-        int numDLs;
+		int numDLs;
-        int numPrims;
+		int numPrims;
-        int numDLPrims;
+		int numDLPrims;
-        int numShaderChanges;
+		int numShaderChanges;
 
-	    int numPrimitiveJoins;
+		int numPrimitiveJoins;
-	    int numDrawCalls;
+		int numDrawCalls;
-	    int numIndexedDrawCalls;
+		int numIndexedDrawCalls;
-	    int numBufferSplits;
+		int numBufferSplits;
 
 		int numDListsCalled;
-    };
+	};
-    ThisFrame thisFrame;
+	ThisFrame thisFrame;
-    void ResetFrame();
+	void ResetFrame();
 	static void SwapDL();
 
 	// Yeah, this is unsafe, but we really don't wanna faff around allocating

Source/Core/VideoCommon/Src/TextureCacheBase.cpp

@@ -56,7 +56,7 @@ TextureCache::TextureCache()
 	if (!temp)
 		temp = (u8*)AllocateAlignedMemory(temp_size, 16);
 	TexDecoder_SetTexFmtOverlayOptions(g_ActiveConfig.bTexFmtOverlayEnable, g_ActiveConfig.bTexFmtOverlayCenter);
-    if(g_ActiveConfig.bHiresTextures && !g_ActiveConfig.bDumpTextures)
+	if(g_ActiveConfig.bHiresTextures && !g_ActiveConfig.bDumpTextures)
 		HiresTextures::Init(SConfig::GetInstance().m_LocalCoreStartupParameter.m_strUniqueID.c_str());
 	SetHash64Function(g_ActiveConfig.bHiresTextures || g_ActiveConfig.bDumpTextures);
 }

Source/Core/VideoCommon/Src/TextureConversionShader.cpp

@@ -39,23 +39,23 @@ namespace TextureConversionShader
 
 u16 GetEncodedSampleCount(u32 format)
 {
-    switch (format) {    
+	switch (format) {
 	case GX_TF_I4: return 8;
 	case GX_TF_I8: return 4;
 	case GX_TF_IA4: return 4;
-    case GX_TF_IA8: return 2;
+	case GX_TF_IA8: return 2;
 	case GX_TF_RGB565: return 2;
 	case GX_TF_RGB5A3: return 2;
 	case GX_TF_RGBA8: return 1;
 	case GX_CTF_R4: return 8;
-    case GX_CTF_RA4: return 4;
+	case GX_CTF_RA4: return 4;
-    case GX_CTF_RA8: return 2;
+	case GX_CTF_RA8: return 2;
-    case GX_CTF_A8: return 4;
+	case GX_CTF_A8: return 4;
-    case GX_CTF_R8: return 4;
+	case GX_CTF_R8: return 4;
-    case GX_CTF_G8: return 4;
+	case GX_CTF_G8: return 4;
-    case GX_CTF_B8: return 4;
+	case GX_CTF_B8: return 4;
-    case GX_CTF_RG8: return 2;
+	case GX_CTF_RG8: return 2;
-    case GX_CTF_GB8: return 2;
+	case GX_CTF_GB8: return 2;
 	case GX_TF_Z8: return 4;
 	case GX_TF_Z16: return 2;
 	case GX_TF_Z24X8: return 1;
@@ -63,8 +63,8 @@ u16 GetEncodedSampleCount(u32 format)
 	case GX_CTF_Z8M: return 4;
 	case GX_CTF_Z8L: return 4;
 	case GX_CTF_Z16L: return 2;
-    default: return 1;
+	default: return 1;
-    }
+	}
 }
 
 const char* WriteRegister(API_TYPE ApiType, const char *prefix, const u32 num)
@@ -103,7 +103,6 @@ void WriteSwizzler(char*& p, u32 format, API_TYPE ApiType)
 		WRITE(p, "Texture2D Tex0 : register(t0);\n");
 	}
 
-	
 	if (ApiType == API_OPENGL)
 	{
 		WRITE(p, "  out float4 ocol0;\n");
@@ -125,7 +124,7 @@ void WriteSwizzler(char*& p, u32 format, API_TYPE ApiType)
 	}
 
 	WRITE(p, "{\n"    
-    "  float2 sampleUv;\n"
+	"  float2 sampleUv;\n"
 	"  float2 uv1 = floor(uv0);\n");
 
 	WRITE(p, "  uv1.x = uv1.x * %f;\n", samples);
@@ -207,7 +206,7 @@ void Write32BitSwizzler(char*& p, u32 format, API_TYPE ApiType)
 
 
 	WRITE(p, "{\n"    
-    "  float2 sampleUv;\n"
+	"  float2 sampleUv;\n"
 	"  float2 uv1 = floor(uv0);\n");
 
 	WRITE(p, "  float yl = floor(uv1.y / %f);\n", blkH);
@@ -465,8 +464,8 @@ void WriteRGB5A3Encoder(char* p,API_TYPE ApiType)
 
 	WriteSampleColor(p, "rgba", "texSample", ApiType);
 
-    // 0.8784 = 224 / 255 which is the maximum alpha value that can be represented in 3 bits
+	// 0.8784 = 224 / 255 which is the maximum alpha value that can be represented in 3 bits
-    WRITE(p, "if(texSample.a > 0.878f) {\n");
+	WRITE(p, "if(texSample.a > 0.878f) {\n");
 
 	WriteToBitDepth(p, 5, "texSample.g", "color0");
 	WRITE(p, "  gUpper = floor(color0 / 8.0f);\n");
@@ -477,24 +476,24 @@ void WriteRGB5A3Encoder(char* p,API_TYPE ApiType)
 	WriteToBitDepth(p, 5, "texSample.b", "ocol0.g");
 	WRITE(p, "  ocol0.g = ocol0.g + gLower * 32.0f;\n");
 
-    WRITE(p, "} else {\n");
+	WRITE(p, "} else {\n");
 
-    WriteToBitDepth(p, 4, "texSample.r", "ocol0.b");
+	WriteToBitDepth(p, 4, "texSample.r", "ocol0.b");
-    WriteToBitDepth(p, 4, "texSample.b", "ocol0.g");
+	WriteToBitDepth(p, 4, "texSample.b", "ocol0.g");
 
-    WriteToBitDepth(p, 3, "texSample.a", "color0");
+	WriteToBitDepth(p, 3, "texSample.a", "color0");
-    WRITE(p, "ocol0.b = ocol0.b + color0 * 16.0f;\n");
+	WRITE(p, "ocol0.b = ocol0.b + color0 * 16.0f;\n");
 	WriteToBitDepth(p, 4, "texSample.g", "color0");
-    WRITE(p, "ocol0.g = ocol0.g + color0 * 16.0f;\n");
+	WRITE(p, "ocol0.g = ocol0.g + color0 * 16.0f;\n");
 
-    WRITE(p, "}\n");
+	WRITE(p, "}\n");
 
 
 	WriteIncrementSampleX(p, ApiType);
 
 	WriteSampleColor(p, "rgba", "texSample", ApiType);
 
-    WRITE(p, "if(texSample.a > 0.878f) {\n");
+	WRITE(p, "if(texSample.a > 0.878f) {\n");
 
 	WriteToBitDepth(p, 5, "texSample.g", "color0");
 	WRITE(p, "  gUpper = floor(color0 / 8.0f);\n");
@@ -505,17 +504,17 @@ void WriteRGB5A3Encoder(char* p,API_TYPE ApiType)
 	WriteToBitDepth(p, 5, "texSample.b", "ocol0.a");
 	WRITE(p, "  ocol0.a = ocol0.a + gLower * 32.0f;\n");
 
-    WRITE(p, "} else {\n");
+	WRITE(p, "} else {\n");
 
-    WriteToBitDepth(p, 4, "texSample.r", "ocol0.r");
+	WriteToBitDepth(p, 4, "texSample.r", "ocol0.r");
-    WriteToBitDepth(p, 4, "texSample.b", "ocol0.a");
+	WriteToBitDepth(p, 4, "texSample.b", "ocol0.a");
 
-    WriteToBitDepth(p, 3, "texSample.a", "color0");
+	WriteToBitDepth(p, 3, "texSample.a", "color0");
-    WRITE(p, "ocol0.r = ocol0.r + color0 * 16.0f;\n");
+	WRITE(p, "ocol0.r = ocol0.r + color0 * 16.0f;\n");
 	WriteToBitDepth(p, 4, "texSample.g", "color0");
-    WRITE(p, "ocol0.a = ocol0.a + color0 * 16.0f;\n");
+	WRITE(p, "ocol0.a = ocol0.a + color0 * 16.0f;\n");
 
-    WRITE(p, "}\n");
+	WRITE(p, "}\n");
 
 	WRITE(p, "  ocol0 = ocol0 / 255.0f;\n");
 	WriteEncoderEnd(p, ApiType);
@@ -680,96 +679,96 @@ void WriteZ8Encoder(char* p, const char* multiplier,API_TYPE ApiType)
 {
 	WriteSwizzler(p, GX_CTF_Z8M, ApiType);
 
-    WRITE(p, " float depth;\n");
+	WRITE(p, " float depth;\n");
 
 	WriteSampleColor(p, "b", "depth", ApiType);
-    WRITE(p, "ocol0.b = frac(depth * %s);\n", multiplier);
+	WRITE(p, "ocol0.b = frac(depth * %s);\n", multiplier);
 	WriteIncrementSampleX(p, ApiType);
 
-    WriteSampleColor(p, "b", "depth", ApiType);
+	WriteSampleColor(p, "b", "depth", ApiType);
-    WRITE(p, "ocol0.g = frac(depth * %s);\n", multiplier);
+	WRITE(p, "ocol0.g = frac(depth * %s);\n", multiplier);
 	WriteIncrementSampleX(p, ApiType);
 
-    WriteSampleColor(p, "b", "depth", ApiType);
+	WriteSampleColor(p, "b", "depth", ApiType);
-    WRITE(p, "ocol0.r = frac(depth * %s);\n", multiplier);
+	WRITE(p, "ocol0.r = frac(depth * %s);\n", multiplier);
 	WriteIncrementSampleX(p, ApiType);
 
-    WriteSampleColor(p, "b", "depth", ApiType);
+	WriteSampleColor(p, "b", "depth", ApiType);
-    WRITE(p, "ocol0.a = frac(depth * %s);\n", multiplier);
+	WRITE(p, "ocol0.a = frac(depth * %s);\n", multiplier);
 
 	WriteEncoderEnd(p, ApiType);
 }
 
 void WriteZ16Encoder(char* p,API_TYPE ApiType)
 {
-    WriteSwizzler(p, GX_TF_Z16, ApiType);
+	WriteSwizzler(p, GX_TF_Z16, ApiType);
 
-    WRITE(p, "  float depth;\n");
+	WRITE(p, "  float depth;\n");
-    WRITE(p, "  float3 expanded;\n");
+	WRITE(p, "  float3 expanded;\n");
 
-    // byte order is reversed
+	// byte order is reversed
 
-    WriteSampleColor(p, "b", "depth", ApiType);
+	WriteSampleColor(p, "b", "depth", ApiType);
 
-    WRITE(p, "  depth *= 16777215.0f;\n");
+	WRITE(p, "  depth *= 16777215.0f;\n");
-    WRITE(p, "  expanded.r = floor(depth / (256 * 256));\n");
+	WRITE(p, "  expanded.r = floor(depth / (256 * 256));\n");
-    WRITE(p, "  depth -= expanded.r * 256 * 256;\n");
+	WRITE(p, "  depth -= expanded.r * 256 * 256;\n");
-    WRITE(p, "  expanded.g = floor(depth / 256);\n");
+	WRITE(p, "  expanded.g = floor(depth / 256);\n");
 
-    WRITE(p, "  ocol0.b = expanded.g / 255;\n");
+	WRITE(p, "  ocol0.b = expanded.g / 255;\n");
-    WRITE(p, "  ocol0.g = expanded.r / 255;\n");
+	WRITE(p, "  ocol0.g = expanded.r / 255;\n");
 
-    WriteIncrementSampleX(p, ApiType);
+	WriteIncrementSampleX(p, ApiType);
 
-    WriteSampleColor(p, "b", "depth", ApiType);
+	WriteSampleColor(p, "b", "depth", ApiType);
 
-    WRITE(p, "  depth *= 16777215.0f;\n");
+	WRITE(p, "  depth *= 16777215.0f;\n");
-    WRITE(p, "  expanded.r = floor(depth / (256 * 256));\n");
+	WRITE(p, "  expanded.r = floor(depth / (256 * 256));\n");
-    WRITE(p, "  depth -= expanded.r * 256 * 256;\n");
+	WRITE(p, "  depth -= expanded.r * 256 * 256;\n");
-    WRITE(p, "  expanded.g = floor(depth / 256);\n");
+	WRITE(p, "  expanded.g = floor(depth / 256);\n");
 
-    WRITE(p, "  ocol0.r = expanded.g / 255;\n");
+	WRITE(p, "  ocol0.r = expanded.g / 255;\n");
-    WRITE(p, "  ocol0.a = expanded.r / 255;\n");    
+	WRITE(p, "  ocol0.a = expanded.r / 255;\n");
 
-    WriteEncoderEnd(p, ApiType);
+	WriteEncoderEnd(p, ApiType);
 }
 
 void WriteZ16LEncoder(char* p,API_TYPE ApiType)
 {
-    WriteSwizzler(p, GX_CTF_Z16L, ApiType);
+	WriteSwizzler(p, GX_CTF_Z16L, ApiType);
 
-    WRITE(p, "  float depth;\n");
+	WRITE(p, "  float depth;\n");
-    WRITE(p, "  float3 expanded;\n");
+	WRITE(p, "  float3 expanded;\n");
 
-    // byte order is reversed
+	// byte order is reversed
 
-    WriteSampleColor(p, "b", "depth", ApiType);
+	WriteSampleColor(p, "b", "depth", ApiType);
 
-    WRITE(p, "  depth *= 16777215.0f;\n");
+	WRITE(p, "  depth *= 16777215.0f;\n");
-    WRITE(p, "  expanded.r = floor(depth / (256 * 256));\n");
+	WRITE(p, "  expanded.r = floor(depth / (256 * 256));\n");
-    WRITE(p, "  depth -= expanded.r * 256 * 256;\n");
+	WRITE(p, "  depth -= expanded.r * 256 * 256;\n");
-    WRITE(p, "  expanded.g = floor(depth / 256);\n");
+	WRITE(p, "  expanded.g = floor(depth / 256);\n");
-    WRITE(p, "  depth -= expanded.g * 256;\n");
+	WRITE(p, "  depth -= expanded.g * 256;\n");
-    WRITE(p, "  expanded.b = depth;\n");
+	WRITE(p, "  expanded.b = depth;\n");
 
-    WRITE(p, "  ocol0.b = expanded.b / 255;\n");
+	WRITE(p, "  ocol0.b = expanded.b / 255;\n");
-    WRITE(p, "  ocol0.g = expanded.g / 255;\n");
+	WRITE(p, "  ocol0.g = expanded.g / 255;\n");
 
-    WriteIncrementSampleX(p, ApiType);
+	WriteIncrementSampleX(p, ApiType);
 
-    WriteSampleColor(p, "b", "depth", ApiType);
+	WriteSampleColor(p, "b", "depth", ApiType);
 
-    WRITE(p, "  depth *= 16777215.0f;\n");
+	WRITE(p, "  depth *= 16777215.0f;\n");
-    WRITE(p, "  expanded.r = floor(depth / (256 * 256));\n");
+	WRITE(p, "  expanded.r = floor(depth / (256 * 256));\n");
-    WRITE(p, "  depth -= expanded.r * 256 * 256;\n");
+	WRITE(p, "  depth -= expanded.r * 256 * 256;\n");
-    WRITE(p, "  expanded.g = floor(depth / 256);\n");
+	WRITE(p, "  expanded.g = floor(depth / 256);\n");
-    WRITE(p, "  depth -= expanded.g * 256;\n");
+	WRITE(p, "  depth -= expanded.g * 256;\n");
-    WRITE(p, "  expanded.b = depth;\n");
+	WRITE(p, "  expanded.b = depth;\n");
 
-    WRITE(p, "  ocol0.r = expanded.b;\n");
+	WRITE(p, "  ocol0.r = expanded.b;\n");
-    WRITE(p, "  ocol0.a = expanded.g;\n");    
+	WRITE(p, "  ocol0.a = expanded.g;\n");
 
-    WriteEncoderEnd(p, ApiType);
+	WriteEncoderEnd(p, ApiType);
 }
 
 void WriteZ24Encoder(char* p, API_TYPE ApiType)
@@ -779,16 +778,16 @@ void WriteZ24Encoder(char* p, API_TYPE ApiType)
 	WRITE(p, "  float cl = xb - (halfxb * 2);\n");
 
 	WRITE(p, "  float depth0;\n");
-    WRITE(p, "  float depth1;\n");
+	WRITE(p, "  float depth1;\n");
-    WRITE(p, "  float3 expanded0;\n");
+	WRITE(p, "  float3 expanded0;\n");
-    WRITE(p, "  float3 expanded1;\n");
+	WRITE(p, "  float3 expanded1;\n");
 
 	WriteSampleColor(p, "b", "depth0", ApiType);
-    WriteIncrementSampleX(p, ApiType);
+	WriteIncrementSampleX(p, ApiType);
-    WriteSampleColor(p, "b", "depth1", ApiType);
+	WriteSampleColor(p, "b", "depth1", ApiType);
 
-    for (int i = 0; i < 2; i++)
+	for (int i = 0; i < 2; i++)
-    {
+	{
 		WRITE(p, "  depth%i *= 16777215.0f;\n", i);
 
 		WRITE(p, "  expanded%i.r = floor(depth%i / (256 * 256));\n", i, i);
@@ -796,23 +795,23 @@ void WriteZ24Encoder(char* p, API_TYPE ApiType)
 		WRITE(p, "  expanded%i.g = floor(depth%i / 256);\n", i, i);
 		WRITE(p, "  depth%i -= expanded%i.g * 256;\n", i, i);
 		WRITE(p, "  expanded%i.b = depth%i;\n", i, i);
-    }
+	}
 
-    WRITE(p, "  if(cl > 0.5f) {\n");
+	WRITE(p, "  if(cl > 0.5f) {\n");
-    // upper 16
+	// upper 16
-    WRITE(p, "     ocol0.b = expanded0.g / 255;\n");
+	WRITE(p, "     ocol0.b = expanded0.g / 255;\n");
-    WRITE(p, "     ocol0.g = expanded0.b / 255;\n");
+	WRITE(p, "     ocol0.g = expanded0.b / 255;\n");
-    WRITE(p, "     ocol0.r = expanded1.g / 255;\n");
+	WRITE(p, "     ocol0.r = expanded1.g / 255;\n");
-    WRITE(p, "     ocol0.a = expanded1.b / 255;\n");
+	WRITE(p, "     ocol0.a = expanded1.b / 255;\n");
-    WRITE(p, "  } else {\n");
+	WRITE(p, "  } else {\n");
-    // lower 8
+	// lower 8
-    WRITE(p, "     ocol0.b = 1.0f;\n");
+	WRITE(p, "     ocol0.b = 1.0f;\n");
-    WRITE(p, "     ocol0.g = expanded0.r / 255;\n");
+	WRITE(p, "     ocol0.g = expanded0.r / 255;\n");
-    WRITE(p, "     ocol0.r = 1.0f;\n");
+	WRITE(p, "     ocol0.r = 1.0f;\n");
-    WRITE(p, "     ocol0.a = expanded1.r / 255;\n");
+	WRITE(p, "     ocol0.a = expanded1.r / 255;\n");
-    WRITE(p, "  }\n");
+	WRITE(p, "  }\n");
 
-    WriteEncoderEnd(p, ApiType);
+	WriteEncoderEnd(p, ApiType);
 }
 
 const char *GenerateEncodingShader(u32 format,API_TYPE ApiType)
@@ -902,7 +901,7 @@ const char *GenerateEncodingShader(u32 format,API_TYPE ApiType)
 		PanicAlert("TextureConversionShader generator - buffer too small, canary has been eaten!");
 
 	setlocale(LC_NUMERIC, ""); // restore locale
-    return text;
+	return text;
 }
 
 void SetShaderParameters(float width, float height, float offsetX, float offsetY, float widthStride, float heightStride,float buffW,float buffH)

Source/Core/VideoCommon/Src/TextureDecoder.h

@@ -27,41 +27,41 @@ extern  GC_ALIGNED16(u8 texMem[TMEM_SIZE]);
 
 enum TextureFormat
 {
-    GX_TF_I4     = 0x0,
+	GX_TF_I4     = 0x0,
-    GX_TF_I8     = 0x1,
+	GX_TF_I8     = 0x1,
-    GX_TF_IA4    = 0x2,
+	GX_TF_IA4    = 0x2,
-    GX_TF_IA8    = 0x3,
+	GX_TF_IA8    = 0x3,
-    GX_TF_RGB565 = 0x4,
+	GX_TF_RGB565 = 0x4,
-    GX_TF_RGB5A3 = 0x5,
+	GX_TF_RGB5A3 = 0x5,
-    GX_TF_RGBA8  = 0x6,
+	GX_TF_RGBA8  = 0x6,
-    GX_TF_C4     = 0x8,
+	GX_TF_C4     = 0x8,
-    GX_TF_C8     = 0x9,
+	GX_TF_C8     = 0x9,
-    GX_TF_C14X2  = 0xA,
+	GX_TF_C14X2  = 0xA,
-    GX_TF_CMPR   = 0xE,
+	GX_TF_CMPR   = 0xE,
 
-    _GX_TF_CTF   = 0x20,  // copy-texture-format only (simply means linear?)
+	_GX_TF_CTF   = 0x20,  // copy-texture-format only (simply means linear?)
-    _GX_TF_ZTF   = 0x10,  // Z-texture-format
+	_GX_TF_ZTF   = 0x10,  // Z-texture-format
 
-    // these formats are also valid when copying targets
+	// these formats are also valid when copying targets
-    GX_CTF_R4    = 0x0 | _GX_TF_CTF,
+	GX_CTF_R4    = 0x0 | _GX_TF_CTF,
-    GX_CTF_RA4   = 0x2 | _GX_TF_CTF,
+	GX_CTF_RA4   = 0x2 | _GX_TF_CTF,
-    GX_CTF_RA8   = 0x3 | _GX_TF_CTF,
+	GX_CTF_RA8   = 0x3 | _GX_TF_CTF,
-    GX_CTF_YUVA8 = 0x6 | _GX_TF_CTF,
+	GX_CTF_YUVA8 = 0x6 | _GX_TF_CTF,
-    GX_CTF_A8    = 0x7 | _GX_TF_CTF,
+	GX_CTF_A8    = 0x7 | _GX_TF_CTF,
-    GX_CTF_R8    = 0x8 | _GX_TF_CTF,
+	GX_CTF_R8    = 0x8 | _GX_TF_CTF,
-    GX_CTF_G8    = 0x9 | _GX_TF_CTF,
+	GX_CTF_G8    = 0x9 | _GX_TF_CTF,
-    GX_CTF_B8    = 0xA | _GX_TF_CTF,
+	GX_CTF_B8    = 0xA | _GX_TF_CTF,
-    GX_CTF_RG8   = 0xB | _GX_TF_CTF,
+	GX_CTF_RG8   = 0xB | _GX_TF_CTF,
-    GX_CTF_GB8   = 0xC | _GX_TF_CTF,
+	GX_CTF_GB8   = 0xC | _GX_TF_CTF,
 
-    GX_TF_Z8     = 0x1 | _GX_TF_ZTF,
+	GX_TF_Z8     = 0x1 | _GX_TF_ZTF,
-    GX_TF_Z16    = 0x3 | _GX_TF_ZTF,
+	GX_TF_Z16    = 0x3 | _GX_TF_ZTF,
-    GX_TF_Z24X8  = 0x6 | _GX_TF_ZTF,
+	GX_TF_Z24X8  = 0x6 | _GX_TF_ZTF,
 
-    GX_CTF_Z4    = 0x0 | _GX_TF_ZTF | _GX_TF_CTF,
+	GX_CTF_Z4    = 0x0 | _GX_TF_ZTF | _GX_TF_CTF,
-    GX_CTF_Z8M   = 0x9 | _GX_TF_ZTF | _GX_TF_CTF,
+	GX_CTF_Z8M   = 0x9 | _GX_TF_ZTF | _GX_TF_CTF,
-    GX_CTF_Z8L   = 0xA | _GX_TF_ZTF | _GX_TF_CTF,
+	GX_CTF_Z8L   = 0xA | _GX_TF_ZTF | _GX_TF_CTF,
-    GX_CTF_Z16L  = 0xC | _GX_TF_ZTF | _GX_TF_CTF,
+	GX_CTF_Z16L  = 0xC | _GX_TF_ZTF | _GX_TF_CTF,
 };
 
 int TexDecoder_GetTexelSizeInNibbles(int format);

Source/Core/VideoCommon/Src/VertexLoader.cpp

@@ -558,7 +558,7 @@ int VertexLoader::SetupRunVertices(int vtx_attr_group, int primitive, int const
 	m_VtxAttr.texCoord[0].Frac		= g_VtxAttr[vtx_attr_group].g0.Tex0Frac;
 	m_VtxAttr.texCoord[1].Frac		= g_VtxAttr[vtx_attr_group].g1.Tex1Frac;
 	m_VtxAttr.texCoord[2].Frac		= g_VtxAttr[vtx_attr_group].g1.Tex2Frac;
-	m_VtxAttr.texCoord[3].Frac      = g_VtxAttr[vtx_attr_group].g1.Tex3Frac;
+	m_VtxAttr.texCoord[3].Frac		= g_VtxAttr[vtx_attr_group].g1.Tex3Frac;
 	m_VtxAttr.texCoord[4].Frac		= g_VtxAttr[vtx_attr_group].g2.Tex4Frac;
 	m_VtxAttr.texCoord[5].Frac		= g_VtxAttr[vtx_attr_group].g2.Tex5Frac;
 	m_VtxAttr.texCoord[6].Frac		= g_VtxAttr[vtx_attr_group].g2.Tex6Frac;
@@ -645,7 +645,7 @@ void VertexLoader::SetVAT(u32 _group0, u32 _group1, u32 _group2)
 	m_VtxAttr.texCoord[2].Frac		= vat.g1.Tex2Frac;
 	m_VtxAttr.texCoord[3].Elements	= vat.g1.Tex3CoordElements;
 	m_VtxAttr.texCoord[3].Format	= vat.g1.Tex3CoordFormat;
-	m_VtxAttr.texCoord[3].Frac      = vat.g1.Tex3Frac;
+	m_VtxAttr.texCoord[3].Frac		= vat.g1.Tex3Frac;
 	m_VtxAttr.texCoord[4].Elements	= vat.g1.Tex4CoordElements;
 	m_VtxAttr.texCoord[4].Format	= vat.g1.Tex4CoordFormat;
 

Source/Core/VideoCommon/Src/VertexLoader_Normal.h

@@ -25,43 +25,43 @@ class VertexLoader_Normal
 {
 public:
 
-    // Init
+	// Init
-    static void Init(void);
+	static void Init(void);
 
-    // GetSize
+	// GetSize
-    static unsigned int GetSize(unsigned int _type, unsigned int _format,
+	static unsigned int GetSize(unsigned int _type, unsigned int _format,
 		unsigned int _elements, unsigned int _index3);
 
-    // GetFunction
+	// GetFunction
-    static TPipelineFunction GetFunction(unsigned int _type,
+	static TPipelineFunction GetFunction(unsigned int _type,
 		unsigned int _format, unsigned int _elements, unsigned int _index3);
 
 private:
-    enum ENormalType
+	enum ENormalType
-    {
+	{
-        NRM_NOT_PRESENT		= 0,
+		NRM_NOT_PRESENT		= 0,
-        NRM_DIRECT			= 1,
+		NRM_DIRECT			= 1,
-        NRM_INDEX8			= 2,
+		NRM_INDEX8			= 2,
-        NRM_INDEX16			= 3,
+		NRM_INDEX16			= 3,
-        NUM_NRM_TYPE
+		NUM_NRM_TYPE
-    };
+	};
 
-    enum ENormalFormat
+	enum ENormalFormat
-    {
+	{
-        FORMAT_UBYTE		= 0,
+		FORMAT_UBYTE		= 0,
-        FORMAT_BYTE			= 1,
+		FORMAT_BYTE			= 1,
-        FORMAT_USHORT		= 2,
+		FORMAT_USHORT		= 2,
-        FORMAT_SHORT		= 3,
+		FORMAT_SHORT		= 3,
-        FORMAT_FLOAT		= 4,
+		FORMAT_FLOAT		= 4,
-        NUM_NRM_FORMAT
+		NUM_NRM_FORMAT
-    };
+	};
 
-    enum ENormalElements
+	enum ENormalElements
-    {
+	{
-        NRM_NBT				= 0,
+		NRM_NBT				= 0,
-        NRM_NBT3			= 1,
+		NRM_NBT3			= 1,
-        NUM_NRM_ELEMENTS
+		NUM_NRM_ELEMENTS
-    };
+	};
 
 	enum ENormalIndices
 	{

Source/Core/VideoCommon/Src/VertexLoader_Position.h

@@ -21,14 +21,14 @@
 class VertexLoader_Position {
 public:
 
-    // Init
+	// Init
-    static void Init(void);
+	static void Init(void);
 
-    // GetSize
+	// GetSize
-    static unsigned int GetSize(unsigned int _type, unsigned int _format, unsigned int _elements);
+	static unsigned int GetSize(unsigned int _type, unsigned int _format, unsigned int _elements);
 
-    // GetFunction
+	// GetFunction
-    static TPipelineFunction GetFunction(unsigned int _type, unsigned int _format, unsigned int _elements);
+	static TPipelineFunction GetFunction(unsigned int _type, unsigned int _format, unsigned int _elements);
 };
 
 #endif

Source/Core/VideoCommon/Src/VertexLoader_TextCoord.h

@@ -24,18 +24,18 @@ class VertexLoader_TextCoord
 {
 public:
 
-    // Init
+	// Init
-    static void Init(void);
+	static void Init(void);
 
-    // GetSize
+	// GetSize
-    static unsigned int GetSize(unsigned int _type, unsigned int _format, unsigned int _elements);
+	static unsigned int GetSize(unsigned int _type, unsigned int _format, unsigned int _elements);
 
-    // GetFunction
+	// GetFunction
-    static TPipelineFunction GetFunction(unsigned int _type, unsigned int _format, unsigned int _elements);
+	static TPipelineFunction GetFunction(unsigned int _type, unsigned int _format, unsigned int _elements);
 
-    // GetDummyFunction
+	// GetDummyFunction
 	// It is important to synchronize tcIndex.
-    static TPipelineFunction GetDummyFunction();
+	static TPipelineFunction GetDummyFunction();
 };
 
 #endif

Source/Core/VideoCommon/Src/VertexManagerBase.h

@@ -45,10 +45,10 @@ public:
 	virtual void DestroyDeviceObjects(){};
 	
 protected:
- 	u16* GetTriangleIndexBuffer() { return &TIBuffer[0]; }
+	u16* GetTriangleIndexBuffer() { return &TIBuffer[0]; }
- 	u16* GetLineIndexBuffer() { return &LIBuffer[0]; }
+	u16* GetLineIndexBuffer() { return &LIBuffer[0]; }
- 	u16* GetPointIndexBuffer() { return &PIBuffer[0]; }
+	u16* GetPointIndexBuffer() { return &PIBuffer[0]; }
- 	u8* GetVertexBuffer() { return &s_pBaseBufferPointer[0]; }
+	u8* GetVertexBuffer() { return &s_pBaseBufferPointer[0]; }
 
 	virtual void vDoState(PointerWrap& p) { DoStateShared(p); }
 	void DoStateShared(PointerWrap& p);

Source/Core/VideoCommon/Src/VertexShaderGen.cpp

@@ -202,7 +202,6 @@ const char *GenerateVertexShaderCode(u32 components, API_TYPE ApiType)
 	if (g_ActiveConfig.backend_info.bSupportsGLSLUBO)
 		WRITE(p, "};\n");
 
-
 	p = GenerateVSOutputStruct(p, components, ApiType);
 
 	if(ApiType == API_OPENGL)
@@ -335,8 +334,6 @@ const char *GenerateVertexShaderCode(u32 components, API_TYPE ApiType)
 	if (!(components & VB_HAS_NRM0))
 		WRITE(p, "float3 _norm0 = float3(0.0f, 0.0f, 0.0f);\n");
 
-	
-
 	WRITE(p, "o.pos = float4(dot(" I_PROJECTION"[0], pos), dot(" I_PROJECTION"[1], pos), dot(" I_PROJECTION"[2], pos), dot(" I_PROJECTION"[3], pos));\n");
 
 	WRITE(p, "float4 mat, lacc;\n"
@@ -522,26 +519,26 @@ const char *GenerateVertexShaderCode(u32 components, API_TYPE ApiType)
 	}
 	else
 	{
-	    // this results in a scale from -1..0 to -1..1 after perspective
+		// this results in a scale from -1..0 to -1..1 after perspective
-	    // divide
+		// divide
-	    WRITE(p, "o.pos.z = o.pos.w + o.pos.z * 2.0f;\n");
+		WRITE(p, "o.pos.z = o.pos.w + o.pos.z * 2.0f;\n");
 
-	    // Sonic Unleashed puts its final rendering at the near or
+		// Sonic Unleashed puts its final rendering at the near or
-	    // far plane of the viewing frustrum(actually box, they use
+		// far plane of the viewing frustrum(actually box, they use
-	    // orthogonal projection for that), and we end up putting it
+		// orthogonal projection for that), and we end up putting it
-	    // just beyond, and the rendering gets clipped away. (The
+		// just beyond, and the rendering gets clipped away. (The
-	    // primitive gets dropped)
+		// primitive gets dropped)
-	    WRITE(p, "o.pos.z = o.pos.z * 1048575.0f/1048576.0f;\n");
+		WRITE(p, "o.pos.z = o.pos.z * 1048575.0f/1048576.0f;\n");
 
-	    // the next steps of the OGL pipeline are:
+		// the next steps of the OGL pipeline are:
-	    // (x_c,y_c,z_c,w_c) = o.pos  //switch to OGL spec terminology
+		// (x_c,y_c,z_c,w_c) = o.pos  //switch to OGL spec terminology
-	    // clipping to -w_c <= (x_c,y_c,z_c) <= w_c
+		// clipping to -w_c <= (x_c,y_c,z_c) <= w_c
-	    // (x_d,y_d,z_d) = (x_c,y_c,z_c)/w_c//perspective divide
+		// (x_d,y_d,z_d) = (x_c,y_c,z_c)/w_c//perspective divide
-	    // z_w = (f-n)/2*z_d + (n+f)/2
+		// z_w = (f-n)/2*z_d + (n+f)/2
-	    // z_w now contains the value to go to the 0..1 depth buffer
+		// z_w now contains the value to go to the 0..1 depth buffer
 
-	    //trying to get the correct semantic while not using glDepthRange
+		//trying to get the correct semantic while not using glDepthRange
-	    //seems to get rather complicated
+		//seems to get rather complicated
 	}
 
 	if (ApiType & API_D3D9)

Source/Core/VideoCommon/Src/VertexShaderGen.h

@@ -61,7 +61,7 @@
 #define C_NORMALMATRICES        (C_TRANSFORMMATRICES + 64)
 #define C_POSTTRANSFORMMATRICES (C_NORMALMATRICES + 32)
 #define C_DEPTHPARAMS           (C_POSTTRANSFORMMATRICES + 64)
-#define C_VENVCONST_END			(C_DEPTHPARAMS + 1)
+#define C_VENVCONST_END         (C_DEPTHPARAMS + 1)
 const s_svar VSVar_Loc[] = {  {I_POSNORMALMATRIX, C_POSNORMALMATRIX, 6 },
 						{I_PROJECTION , C_PROJECTION, 4  },
 						{I_MATERIALS, C_MATERIALS, 4 },

Source/Core/VideoCommon/Src/VertexShaderManager.h

@@ -43,7 +43,7 @@ public:
 	static void Dirty();
 	static void Shutdown();
 	static void DoState(PointerWrap &p);
-;
+
 	// constant management
 	static void SetConstants();
 

Source/Core/VideoCommon/Src/VideoConfig.h

@@ -172,11 +172,11 @@ struct VideoConfig
 		bool bSupportsGLBaseVertex;
 	} backend_info;
 
-    // Utility
+	// Utility
-    bool RealXFBEnabled() const { return bUseXFB && bUseRealXFB; }
+	bool RealXFBEnabled() const { return bUseXFB && bUseRealXFB; }
-    bool VirtualXFBEnabled() const { return bUseXFB && !bUseRealXFB; }
+	bool VirtualXFBEnabled() const { return bUseXFB && !bUseRealXFB; }
-    bool EFBCopiesToTextureEnabled() const { return bEFBCopyEnable && bCopyEFBToTexture; }
+	bool EFBCopiesToTextureEnabled() const { return bEFBCopyEnable && bCopyEFBToTexture; }
-    bool EFBCopiesToRamEnabled() const { return bEFBCopyEnable && !bCopyEFBToTexture; }
+	bool EFBCopiesToRamEnabled() const { return bEFBCopyEnable && !bCopyEFBToTexture; }
 };
 
 extern VideoConfig g_Config;

Source/Core/VideoCommon/Src/VideoState.cpp

@@ -30,33 +30,33 @@
 
 static void DoState(PointerWrap &p)
 {
-    // BP Memory
+	// BP Memory
-    p.Do(bpmem);
+	p.Do(bpmem);
 	p.DoMarker("BP Memory");
 
 	// CP Memory
-    p.DoArray(arraybases, 16);
+	p.DoArray(arraybases, 16);
-    p.DoArray(arraystrides, 16);
+	p.DoArray(arraystrides, 16);
-    p.Do(MatrixIndexA);
+	p.Do(MatrixIndexA);
-    p.Do(MatrixIndexB);
+	p.Do(MatrixIndexB);
-    p.Do(g_VtxDesc.Hex);
+	p.Do(g_VtxDesc.Hex);
 	p.DoArray(g_VtxAttr, 8);
 	p.DoMarker("CP Memory");
 
-    // XF Memory
+	// XF Memory
-    p.Do(xfregs);
+	p.Do(xfregs);
-    p.DoArray(xfmem, XFMEM_SIZE);
+	p.DoArray(xfmem, XFMEM_SIZE);
 	p.DoMarker("XF Memory");
 
 	// Texture decoder
-    p.DoArray(texMem, TMEM_SIZE);
+	p.DoArray(texMem, TMEM_SIZE);
 	p.DoMarker("texMem");
  
-    // FIFO
+	// FIFO
-    Fifo_DoState(p);
+	Fifo_DoState(p);
 	p.DoMarker("Fifo");
 
-    CommandProcessor::DoState(p);
+	CommandProcessor::DoState(p);
 	p.DoMarker("CommandProcessor");
 
 	PixelEngine::DoState(p);
@@ -77,7 +77,7 @@ static void DoState(PointerWrap &p)
 
 void VideoCommon_DoState(PointerWrap &p)
 {
-    DoState(p);
+	DoState(p);
 }
 
 void VideoCommon_RunLoop(bool enable)

Source/Core/VideoCommon/Src/XFMemory.h

@@ -110,70 +110,70 @@
 
 union LitChannel
 {
-    struct
+	struct
-    {
+	{
-        u32 matsource      : 1;
+		u32 matsource      : 1;
-        u32 enablelighting : 1;
+		u32 enablelighting : 1;
-        u32 lightMask0_3   : 4;
+		u32 lightMask0_3   : 4;
-        u32 ambsource      : 1;
+		u32 ambsource      : 1;
-        u32 diffusefunc    : 2; // LIGHTDIF_X
+		u32 diffusefunc    : 2; // LIGHTDIF_X
-        u32 attnfunc       : 2; // LIGHTATTN_X
+		u32 attnfunc       : 2; // LIGHTATTN_X
-        u32 lightMask4_7   : 4;
+		u32 lightMask4_7   : 4;
-    };
+	};
-    struct
+	struct
-    {
+	{
-        u32 hex : 15;
+		u32 hex : 15;
-        u32 unused : 17;
+		u32 unused : 17;
-    };
+	};
-    struct
+	struct
-    {
+	{
-        u32 dummy0 : 7;
+		u32 dummy0 : 7;
-        u32 lightparams : 4;
+		u32 lightparams : 4;
-        u32 dummy1 : 21;
+		u32 dummy1 : 21;
-    };
+	};
-    unsigned int GetFullLightMask() const
+	unsigned int GetFullLightMask() const
-    {
+	{
-        return enablelighting ? (lightMask0_3 | (lightMask4_7 << 4)) : 0;
+		return enablelighting ? (lightMask0_3 | (lightMask4_7 << 4)) : 0;
-    }
+	}
 };
 
 
 union INVTXSPEC
 {
-    struct
+	struct
-    {
+	{
-        u32 numcolors : 2;
+		u32 numcolors   : 2;
-        u32 numnormals : 2; // 0 - nothing, 1 - just normal, 2 - normals and binormals
+		u32 numnormals  : 2; // 0 - nothing, 1 - just normal, 2 - normals and binormals
-        u32 numtextures : 4;
+		u32 numtextures : 4;
-        u32 unused : 24;
+		u32 unused : 24;
-    };
+	};
-    u32 hex;
+	u32 hex;
 };
 
 union TexMtxInfo
 {
-    struct 
+	struct 
-    {
+	{
-        u32 unknown : 1;
+		u32 unknown    : 1;
-        u32 projection : 1; // XF_TEXPROJ_X
+		u32 projection : 1; // XF_TEXPROJ_X
-        u32 inputform : 2; // XF_TEXINPUT_X
+		u32 inputform  : 2; // XF_TEXINPUT_X
-        u32 texgentype : 3; // XF_TEXGEN_X
+		u32 texgentype : 3; // XF_TEXGEN_X
-        u32 sourcerow : 5; // XF_SRCGEOM_X
+		u32 sourcerow  : 5; // XF_SRCGEOM_X
-        u32 embosssourceshift : 3; // what generated texcoord to use
+		u32 embosssourceshift : 3; // what generated texcoord to use
-        u32 embosslightshift : 3; // light index that is used
+		u32 embosslightshift  : 3; // light index that is used
-    };
+	};
-    u32 hex;
+	u32 hex;
 };
 
 union PostMtxInfo
 {
-    struct 
+	struct 
-    {
+	{
-        u32 index : 6; // base row of dual transform matrix
+		u32 index     : 6; // base row of dual transform matrix
-        u32 unused : 2;
+		u32 unused    : 2;
-        u32 normalize : 1; // normalize before send operation
+		u32 normalize : 1; // normalize before send operation
-    };
+	};
-    u32 hex;
+	u32 hex;
 };
 
 union NumColorChannel
@@ -207,25 +207,25 @@ union DualTexInfo
 
 struct Light
 {
-    u32 useless[3]; 
+	u32 useless[3]; 
-    u32 color;    //rgba
+	u32 color;    //rgba
-    float a0;  //attenuation
+	float a0;  //attenuation
-    float a1; 
+	float a1; 
-    float a2; 
+	float a2; 
-    float k0;  //k stuff
+	float k0;  //k stuff
-    float k1; 
+	float k1; 
-    float k2; 
+	float k2; 
-    union
+	union
-    {
+	{
-        struct {
+		struct {
 			float dpos[3];
-            float ddir[3]; // specular lights only
+			float ddir[3]; // specular lights only
-        };
+		};
-        struct {
+		struct {
-            float sdir[3];
+			float sdir[3];
-            float shalfangle[3]; // specular lights only
+			float shalfangle[3]; // specular lights only
-        };
+		};
-    };
+	};
 };
 
 struct Viewport
@@ -246,35 +246,35 @@ struct Projection
 
 struct XFRegisters
 {
-    u32 error;                      // 0x1000
+	u32 error;                      // 0x1000
-    u32 diag;                       // 0x1001
+	u32 diag;                       // 0x1001
-    u32 state0;                     // 0x1002
+	u32 state0;                     // 0x1002
-    u32 state1;                     // 0x1003
+	u32 state1;                     // 0x1003
-    u32 xfClock;                    // 0x1004
+	u32 xfClock;                    // 0x1004
-    u32 clipDisable;                // 0x1005
+	u32 clipDisable;                // 0x1005
-    u32 perf0;                      // 0x1006
+	u32 perf0;                      // 0x1006
-    u32 perf1;                      // 0x1007
+	u32 perf1;                      // 0x1007
-    INVTXSPEC hostinfo;             // 0x1008 number of textures,colors,normals from vertex input
+	INVTXSPEC hostinfo;             // 0x1008 number of textures,colors,normals from vertex input
-    NumColorChannel numChan;        // 0x1009
+	NumColorChannel numChan;        // 0x1009
-    u32 ambColor[2];                // 0x100a, 0x100b
+	u32 ambColor[2];                // 0x100a, 0x100b
-    u32 matColor[2];                // 0x100c, 0x100d
+	u32 matColor[2];                // 0x100c, 0x100d
-    LitChannel color[2];            // 0x100e, 0x100f
+	LitChannel color[2];            // 0x100e, 0x100f
-    LitChannel alpha[2];            // 0x1010, 0x1011
+	LitChannel alpha[2];            // 0x1010, 0x1011
-    DualTexInfo dualTexTrans;       // 0x1012
+	DualTexInfo dualTexTrans;       // 0x1012
-    u32 unk3;                       // 0x1013
+	u32 unk3;                       // 0x1013
-    u32 unk4;                       // 0x1014
+	u32 unk4;                       // 0x1014
-    u32 unk5;                       // 0x1015
+	u32 unk5;                       // 0x1015
-    u32 unk6;                       // 0x1016
+	u32 unk6;                       // 0x1016
-    u32 unk7;                       // 0x1017
+	u32 unk7;                       // 0x1017
-    u32 MatrixIndexA;               // 0x1018
+	u32 MatrixIndexA;               // 0x1018
-    u32 MatrixIndexB;               // 0x1019
+	u32 MatrixIndexB;               // 0x1019
-    Viewport viewport;              // 0x101a - 0x101f
+	Viewport viewport;              // 0x101a - 0x101f
-    Projection projection;          // 0x1020 - 0x1026
+	Projection projection;          // 0x1020 - 0x1026
-    u32 unk8[24];                   // 0x1027 - 0x103e
+	u32 unk8[24];                   // 0x1027 - 0x103e
-    NumTexGen numTexGen;            // 0x103f
+	NumTexGen numTexGen;            // 0x103f
-    TexMtxInfo texMtxInfo[8];       // 0x1040 - 0x1047
+	TexMtxInfo texMtxInfo[8];       // 0x1040 - 0x1047
-    u32 unk9[8];                    // 0x1048 - 0x104f
+	u32 unk9[8];                    // 0x1048 - 0x104f
-    PostMtxInfo postMtxInfo[8];     // 0x1050 - 0x1057
+	PostMtxInfo postMtxInfo[8];     // 0x1050 - 0x1057
 };
 
 

Source/Core/VideoCommon/Src/XFStructs.cpp

@@ -36,37 +36,37 @@ void XFRegWritten(int transferSize, u32 baseAddress, u32 *pData)
 	u32 address = baseAddress;
 	u32 dataIndex = 0;
 
-    while (transferSize > 0 && address < 0x1058)
+	while (transferSize > 0 && address < 0x1058)
-    {
+	{
-  		u32 newValue = pData[dataIndex];
+		u32 newValue = pData[dataIndex];
 		u32 nextAddress = address + 1;
 
-        switch (address)
+		switch (address)
-        {
+		{
-        case XFMEM_ERROR:
+		case XFMEM_ERROR:
-        case XFMEM_DIAG:
+		case XFMEM_DIAG:
-        case XFMEM_STATE0: // internal state 0
+		case XFMEM_STATE0: // internal state 0
-        case XFMEM_STATE1: // internal state 1
+		case XFMEM_STATE1: // internal state 1
-        case XFMEM_CLOCK:
+		case XFMEM_CLOCK:
 		case XFMEM_SETGPMETRIC:
 			nextAddress = 0x1007;
-            break;
+			break;
 
-        case XFMEM_CLIPDISABLE:
+		case XFMEM_CLIPDISABLE:
 			//if (data & 1) {} // disable clipping detection
 			//if (data & 2) {} // disable trivial rejection
 			//if (data & 4) {} // disable cpoly clipping acceleration
-            break;
+			break;
 
-        case XFMEM_VTXSPECS: //__GXXfVtxSpecs, wrote 0004
+		case XFMEM_VTXSPECS: //__GXXfVtxSpecs, wrote 0004
-            break;
+			break;
 
-        case XFMEM_SETNUMCHAN:
+		case XFMEM_SETNUMCHAN:
 			if (xfregs.numChan.numColorChans != (newValue & 3))
-                VertexManager::Flush();
+				VertexManager::Flush();
-            break;
+			break;
 
-        case XFMEM_SETCHAN0_AMBCOLOR: // Channel Ambient Color
+		case XFMEM_SETCHAN0_AMBCOLOR: // Channel Ambient Color
 		case XFMEM_SETCHAN1_AMBCOLOR:
 			{
 				u8 chan = address - XFMEM_SETCHAN0_AMBCOLOR;
@@ -79,7 +79,7 @@ void XFRegWritten(int transferSize, u32 baseAddress, u32 *pData)
 				break;
 			}
 
-        case XFMEM_SETCHAN0_MATCOLOR: // Channel Material Color
+		case XFMEM_SETCHAN0_MATCOLOR: // Channel Material Color
 		case XFMEM_SETCHAN1_MATCOLOR:
 			{
 				u8 chan = address - XFMEM_SETCHAN0_MATCOLOR;
@@ -92,7 +92,7 @@ void XFRegWritten(int transferSize, u32 baseAddress, u32 *pData)
 				break;
 			}
 
-        case XFMEM_SETCHAN0_COLOR: // Channel Color
+		case XFMEM_SETCHAN0_COLOR: // Channel Color
 		case XFMEM_SETCHAN1_COLOR:
 		case XFMEM_SETCHAN0_ALPHA: // Channel Alpha
 		case XFMEM_SETCHAN1_ALPHA:
@@ -100,20 +100,20 @@ void XFRegWritten(int transferSize, u32 baseAddress, u32 *pData)
 				VertexManager::Flush();
 			break;
 
-        case XFMEM_DUALTEX:
+		case XFMEM_DUALTEX:
 			if (xfregs.dualTexTrans.enabled != (newValue & 1))
-                VertexManager::Flush();
+				VertexManager::Flush();
-            break;
+			break;
 
 
-        case XFMEM_SETMATRIXINDA:
+		case XFMEM_SETMATRIXINDA:
-            //_assert_msg_(GX_XF, 0, "XF matrixindex0");
+			//_assert_msg_(GX_XF, 0, "XF matrixindex0");
 			VertexShaderManager::SetTexMatrixChangedA(newValue);
-            break;
+			break;
-        case XFMEM_SETMATRIXINDB:
+		case XFMEM_SETMATRIXINDB:
-            //_assert_msg_(GX_XF, 0, "XF matrixindex1");
+			//_assert_msg_(GX_XF, 0, "XF matrixindex1");
-            VertexShaderManager::SetTexMatrixChangedB(newValue);
+			VertexShaderManager::SetTexMatrixChangedB(newValue);
-            break;
+			break;
 
 		case XFMEM_SETVIEWPORT:
 		case XFMEM_SETVIEWPORT+1:
@@ -141,10 +141,10 @@ void XFRegWritten(int transferSize, u32 baseAddress, u32 *pData)
 			nextAddress = XFMEM_SETPROJECTION + 7;
 			break;
 
-        case XFMEM_SETNUMTEXGENS: // GXSetNumTexGens
+		case XFMEM_SETNUMTEXGENS: // GXSetNumTexGens
 			if (xfregs.numTexGen.numTexGens != (newValue & 15))
 				VertexManager::Flush();
-            break;
+			break;
 
 		case XFMEM_SETTEXMTXINFO:
 		case XFMEM_SETTEXMTXINFO+1:
@@ -178,47 +178,47 @@ void XFRegWritten(int transferSize, u32 baseAddress, u32 *pData)
 
 		// Maybe these are for Normals?
 		case 0x1048: //xfregs.texcoords[0].nrmmtxinfo.hex = data; break; ??
-        case 0x1049:
+		case 0x1049:
-        case 0x104a:
+		case 0x104a:
-        case 0x104b:
+		case 0x104b:
-        case 0x104c:
+		case 0x104c:
-        case 0x104d:
+		case 0x104d:
-        case 0x104e:
+		case 0x104e:
-        case 0x104f:
+		case 0x104f:
 			DEBUG_LOG(VIDEO, "Possible Normal Mtx XF reg?: %x=%x\n", address, newValue);
 			break;
 
 		case 0x1013:
-        case 0x1014:
+		case 0x1014:
-        case 0x1015:
+		case 0x1015:
-        case 0x1016:
+		case 0x1016:
-        case 0x1017:
+		case 0x1017:
 
-        default:
+		default:
-            WARN_LOG(VIDEO, "Unknown XF Reg: %x=%x\n", address, newValue);
+			WARN_LOG(VIDEO, "Unknown XF Reg: %x=%x\n", address, newValue);
-            break;
+			break;
-        }
+		}
 
 		int transferred = nextAddress - address;
 		address = nextAddress;
 
 		transferSize -= transferred;
 		dataIndex += transferred;
-    }
+	}
 }
 
 void LoadXFReg(u32 transferSize, u32 baseAddress, u32 *pData)
 {
-    // do not allow writes past registers
+	// do not allow writes past registers
-    if (baseAddress + transferSize > 0x1058)
+	if (baseAddress + transferSize > 0x1058)
-    {
+	{
-        INFO_LOG(VIDEO, "xf load exceeds address space: %x %d bytes\n", baseAddress, transferSize);
+		INFO_LOG(VIDEO, "xf load exceeds address space: %x %d bytes\n", baseAddress, transferSize);
 
-        if (baseAddress >= 0x1058)
+		if (baseAddress >= 0x1058)
-            transferSize = 0;
+			transferSize = 0;
-        else
+		else
-            transferSize = 0x1058 - baseAddress;
+			transferSize = 0x1058 - baseAddress;
-    }
+	}
 
 	// write to XF mem
 	if (baseAddress < 0x1000 && transferSize > 0)
@@ -247,11 +247,11 @@ void LoadXFReg(u32 transferSize, u32 baseAddress, u32 *pData)
 	}
 
 	// write to XF regs
-    if (transferSize > 0)
+	if (transferSize > 0)
 	{	
 		XFRegWritten(transferSize, baseAddress, pData);
 		memcpy_gc((u32*)(&xfregs) + (baseAddress - 0x1000), pData, transferSize * 4);        
-    }	
+	}
 }
 
 // TODO - verify that it is correct. Seems to work, though.

Source/Core/VideoCommon/Src/x64DLCache.cpp

@@ -392,7 +392,7 @@ u32 AnalyzeAndRunDisplayList(u32 address, u32 size, CachedDisplayList *dl)
 	dl->num_draw_call = num_draw_call;
 	dl->num_index_xf = num_index_xf;
 	dl->num_xf_reg = num_xf_reg;
-    // reset to the old pointer
+	// reset to the old pointer
 	g_pVideoData = old_pVideoData;	
 	return result;
 }
@@ -539,7 +539,6 @@ void CompileAndRunDisplayList(u32 address, u32 size, CachedDisplayList *dl)
 				if (cmd_byte & 0x80)
 				{
 					// load vertices (use computed vertex size from FifoCommandRunnable above)
-					
 					u16 numVertices = DataReadU16();
 					if(numVertices > 0)
 					{
@@ -577,7 +576,6 @@ void CompileAndRunDisplayList(u32 address, u32 size, CachedDisplayList *dl)
 							}
 						}
 					}
-					
 				}
 				else
 				{
@@ -764,10 +762,9 @@ bool HandleDisplayList(u32 address, u32 size)
 		vdl.VATUsed = dlvatused; 
 		vdl.count = 1;
 		DLCache::dl_map[dl_id] = vdl;
-
 	}
-	return true;
 
+	return true;
 }
 
 void IncrementCheckContextId()