Put Plugins/ in Core/, rename to VideoBackends

Source/Core/VideoBackends/Software/CMakeLists.txt

@@ -0,0 +1,53 @@
+set(SRCS	Src/BPMemLoader.cpp
+			Src/Clipper.cpp
+			Src/SWCommandProcessor.cpp
+			Src/CPMemLoader.cpp
+			Src/DebugUtil.cpp
+			Src/EfbCopy.cpp
+			Src/EfbInterface.cpp
+			Src/HwRasterizer.cpp
+			Src/SWmain.cpp
+			Src/OpcodeDecoder.cpp
+			Src/SWPixelEngine.cpp
+			Src/Rasterizer.cpp
+			Src/SWRenderer.cpp
+			Src/SetupUnit.cpp
+			Src/SWStatistics.cpp
+			Src/Tev.cpp
+			Src/TextureEncoder.cpp
+			Src/TextureSampler.cpp
+			Src/TransformUnit.cpp
+			Src/SWVertexLoader.cpp
+			Src/SWVideoConfig.cpp
+			Src/XFMemLoader.cpp)
+
+if(wxWidgets_FOUND)
+	set(SRCS ${SRCS} Src/VideoConfigDialog.cpp)
+endif(wxWidgets_FOUND)
+
+set(LIBS	videocommon
+			SOIL
+			common
+			${X11_LIBRARIES}
+			${wxWidgets_LIBRARIES})
+if(USE_EGL)
+	set(LIBS ${LIBS}
+		EGL)
+endif()
+
+if(USE_GLES)
+	set(SRCS ${SRCS} ../OGL/Src/GLUtil.cpp)
+	set(LIBS ${LIBS}
+		GLESv2)
+else()
+	set(SRCS ${SRCS} Src/RasterFont.cpp)
+	set(LIBS ${LIBS}
+		GLEW
+		${OPENGL_LIBRARIES})
+endif()
+if(NOT (${CMAKE_SYSTEM_NAME} MATCHES "Darwin"))
+	set(LIBS	${LIBS} clrun)
+endif()
+
+add_library(videosoftware STATIC ${SRCS})
+target_link_libraries(videosoftware ${LIBS})

Source/Core/VideoBackends/Software/Software.vcxproj

@@ -0,0 +1,244 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="DebugFast|Win32">
+      <Configuration>DebugFast</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="DebugFast|x64">
+      <Configuration>DebugFast</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{9E9DA440-E9AD-413C-B648-91030E792211}</ProjectGuid>
+    <RootNamespace>VideoSoftware</RootNamespace>
+    <ProjectName>VideoSoftware</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='DebugFast|Win32'">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='DebugFast|Win32'">
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='DebugFast|x64'">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='DebugFast|x64'">
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\VSProps\Base.props" />
+    <Import Project="..\..\VSProps\PrecompiledHeader.props" />
+    <Import Project="..\..\VSProps\CodeGen_Debug.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\VSProps\Base.props" />
+    <Import Project="..\..\VSProps\PrecompiledHeader.props" />
+    <Import Project="..\..\VSProps\CodeGen_Debug.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\VSProps\Base.props" />
+    <Import Project="..\..\VSProps\CodeGen_Release.props" />
+    <Import Project="..\..\VSProps\PrecompiledHeader.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\VSProps\Base.props" />
+    <Import Project="..\..\VSProps\CodeGen_Release.props" />
+    <Import Project="..\..\VSProps\PrecompiledHeader.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugFast|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\VSProps\Base.props" />
+    <Import Project="..\..\VSProps\CodeGen_DebugFast.props" />
+    <Import Project="..\..\VSProps\PrecompiledHeader.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugFast|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\VSProps\Base.props" />
+    <Import Project="..\..\VSProps\CodeGen_DebugFast.props" />
+    <Import Project="..\..\VSProps\PrecompiledHeader.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>..\..\Core\Common\Src;..\..\Core\Core\Src;..\..\Core\VideoCommon\Src;..\..\Core\DolphinWX\Src;..\..\..\Externals\GLew\include;..\..\..\Externals\wxWidgets3;..\..\..\Externals\wxWidgets3\Include;..\..\..\Externals;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>opengl32.lib;glew32s.lib;glu32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>..\..\..\Externals\GLew;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>..\..\Core\Common\Src;..\..\Core\Core\Src;..\..\Core\VideoCommon\Src;..\..\Core\DolphinWX\Src;..\..\..\Externals\GLew\include;..\..\..\Externals\wxWidgets3;..\..\..\Externals\wxWidgets3\Include;..\..\..\Externals;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>opengl32.lib;glew64s.lib;glu32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>..\..\..\Externals\GLew;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>..\..\Core\Common\Src;..\..\Core\Core\Src;..\..\Core\VideoCommon\Src;..\..\Core\DolphinWX\Src;..\..\..\Externals\GLew\include;..\..\..\Externals\wxWidgets3;..\..\..\Externals\wxWidgets3\Include;..\..\..\Externals;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>opengl32.lib;glew32s.lib;glu32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>..\..\..\Externals\GLew;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>..\..\Core\Common\Src;..\..\Core\Core\Src;..\..\Core\VideoCommon\Src;..\..\Core\DolphinWX\Src;..\..\..\Externals\GLew\include;..\..\..\Externals\wxWidgets3;..\..\..\Externals\wxWidgets3\Include;..\..\..\Externals;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>opengl32.lib;glew64s.lib;glu32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>..\..\..\Externals\GLew;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='DebugFast|Win32'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>..\..\Core\Common\Src;..\..\Core\Core\Src;..\..\Core\VideoCommon\Src;..\..\Core\DolphinWX\Src;..\..\..\Externals\GLew\include;..\..\..\Externals\wxWidgets3;..\..\..\Externals\wxWidgets3\Include;..\..\..\Externals;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='DebugFast|x64'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>..\..\Core\Common\Src;..\..\Core\Core\Src;..\..\Core\VideoCommon\Src;..\..\Core\DolphinWX\Src;..\..\..\Externals\GLew\include;..\..\..\Externals\wxWidgets3;..\..\..\Externals\wxWidgets3\Include;..\..\..\Externals;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="Src\BPMemLoader.cpp" />
+    <ClCompile Include="Src\Clipper.cpp" />
+    <ClCompile Include="Src\SWCommandProcessor.cpp" />
+    <ClCompile Include="Src\CPMemLoader.cpp" />
+    <ClCompile Include="Src\DebugUtil.cpp" />
+    <ClCompile Include="Src\EfbCopy.cpp" />
+    <ClCompile Include="Src\EfbInterface.cpp" />
+    <ClCompile Include="Src\HwRasterizer.cpp" />
+    <ClCompile Include="Src\SWmain.cpp" />
+    <ClCompile Include="Src\OpcodeDecoder.cpp" />
+    <ClCompile Include="Src\SWPixelEngine.cpp" />
+    <ClCompile Include="Src\Rasterizer.cpp" />
+    <ClCompile Include="Src\RasterFont.cpp" />
+    <ClCompile Include="Src\SWRenderer.cpp" />
+    <ClCompile Include="Src\SetupUnit.cpp" />
+    <ClCompile Include="Src\SWStatistics.cpp" />
+    <ClCompile Include="Src\stdafx.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='DebugFast|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='DebugFast|x64'">Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="Src\SWVideoConfig.cpp" />
+    <ClCompile Include="Src\Tev.cpp" />
+    <ClCompile Include="Src\TextureEncoder.cpp" />
+    <ClCompile Include="Src\TextureSampler.cpp" />
+    <ClCompile Include="Src\TransformUnit.cpp" />
+    <ClCompile Include="Src\SWVertexLoader.cpp" />
+    <ClCompile Include="Src\VideoConfigDialog.cpp" />
+    <ClCompile Include="Src\XFMemLoader.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="Src\BPMemLoader.h" />
+    <ClInclude Include="Src\Clipper.h" />
+    <ClInclude Include="Src\SWCommandProcessor.h" />
+    <ClInclude Include="Src\CPMemLoader.h" />
+    <ClInclude Include="Src\DebugUtil.h" />
+    <ClInclude Include="Src\EfbCopy.h" />
+    <ClInclude Include="Src\EfbInterface.h" />
+    <ClInclude Include="Src\HwRasterizer.h" />
+    <ClInclude Include="Src\NativeVertexFormat.h" />
+    <ClInclude Include="Src\OpcodeDecoder.h" />
+    <ClInclude Include="Src\SWPixelEngine.h" />
+    <ClInclude Include="Src\Rasterizer.h" />
+    <ClInclude Include="Src\RasterFont.h" />
+    <ClInclude Include="Src\SWRenderer.h" />
+    <ClInclude Include="Src\SetupUnit.h" />
+    <ClInclude Include="Src\SWStatistics.h" />
+    <ClInclude Include="Src\stdafx.h" />
+    <ClInclude Include="Src\SWVideoConfig.h" />
+    <ClInclude Include="Src\Tev.h" />
+    <ClInclude Include="Src\TextureEncoder.h" />
+    <ClInclude Include="Src\TextureSampler.h" />
+    <ClInclude Include="Src\TransformUnit.h" />
+    <ClInclude Include="Src\Vec3.h" />
+    <ClInclude Include="Src\SWVertexLoader.h" />
+    <ClInclude Include="Src\VideoBackend.h" />
+    <ClInclude Include="Src\VideoConfigDialog.h" />
+    <ClInclude Include="Src\XFMemLoader.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Core\VideoCommon\VideoCommon.vcxproj">
+      <Project>{3e5c4e02-1ba9-4776-bdbe-e3f91ffa34cf}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="CMakeLists.txt" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

Source/Core/VideoBackends/Software/Software.vcxproj.filters

@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="Src\BPMemLoader.cpp" />
+    <ClCompile Include="Src\Clipper.cpp" />
+    <ClCompile Include="Src\SWCommandProcessor.cpp" />
+    <ClCompile Include="Src\CPMemLoader.cpp" />
+    <ClCompile Include="Src\DebugUtil.cpp" />
+    <ClCompile Include="Src\EfbCopy.cpp" />
+    <ClCompile Include="Src\EfbInterface.cpp" />
+    <ClCompile Include="Src\HwRasterizer.cpp" />
+    <ClCompile Include="Src\SWmain.cpp" />
+    <ClCompile Include="Src\OpcodeDecoder.cpp" />
+    <ClCompile Include="Src\SWPixelEngine.cpp" />
+    <ClCompile Include="Src\Rasterizer.cpp" />
+    <ClCompile Include="Src\RasterFont.cpp" />
+    <ClCompile Include="Src\SWRenderer.cpp" />
+    <ClCompile Include="Src\SetupUnit.cpp" />
+    <ClCompile Include="Src\SWStatistics.cpp" />
+    <ClCompile Include="Src\stdafx.cpp" />
+    <ClCompile Include="Src\SWVideoConfig.cpp" />
+    <ClCompile Include="Src\Tev.cpp" />
+    <ClCompile Include="Src\TextureEncoder.cpp" />
+    <ClCompile Include="Src\TextureSampler.cpp" />
+    <ClCompile Include="Src\TransformUnit.cpp" />
+    <ClCompile Include="Src\SWVertexLoader.cpp" />
+    <ClCompile Include="Src\VideoConfigDialog.cpp" />
+    <ClCompile Include="Src\XFMemLoader.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="Src\BPMemLoader.h" />
+    <ClInclude Include="Src\Clipper.h" />
+    <ClInclude Include="Src\SWCommandProcessor.h" />
+    <ClInclude Include="Src\CPMemLoader.h" />
+    <ClInclude Include="Src\DebugUtil.h" />
+    <ClInclude Include="Src\EfbCopy.h" />
+    <ClInclude Include="Src\EfbInterface.h" />
+    <ClInclude Include="Src\HwRasterizer.h" />
+    <ClInclude Include="Src\NativeVertexFormat.h" />
+    <ClInclude Include="Src\OpcodeDecoder.h" />
+    <ClInclude Include="Src\SWPixelEngine.h" />
+    <ClInclude Include="Src\Rasterizer.h" />
+    <ClInclude Include="Src\RasterFont.h" />
+    <ClInclude Include="Src\SWRenderer.h" />
+    <ClInclude Include="Src\SetupUnit.h" />
+    <ClInclude Include="Src\SWStatistics.h" />
+    <ClInclude Include="Src\stdafx.h" />
+    <ClInclude Include="Src\SWVideoConfig.h" />
+    <ClInclude Include="Src\Tev.h" />
+    <ClInclude Include="Src\TextureEncoder.h" />
+    <ClInclude Include="Src\TextureSampler.h" />
+    <ClInclude Include="Src\TransformUnit.h" />
+    <ClInclude Include="Src\Vec3.h" />
+    <ClInclude Include="Src\SWVertexLoader.h" />
+    <ClInclude Include="Src\VideoBackend.h" />
+    <ClInclude Include="Src\VideoConfigDialog.h" />
+    <ClInclude Include="Src\XFMemLoader.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="CMakeLists.txt" />
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="Win32">
+      <UniqueIdentifier>{081288cb-a63b-4ae9-93eb-e668568520b8}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+</Project>

Source/Core/VideoBackends/Software/Src/BPMemLoader.cpp

@@ -0,0 +1,188 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include "VideoCommon.h"
+#include "TextureDecoder.h"
+
+#include "BPMemLoader.h"
+#include "EfbCopy.h"
+#include "Rasterizer.h"
+#include "SWPixelEngine.h"
+#include "Tev.h"
+#include "HW/Memmap.h"
+#include "Core.h"
+
+
+void InitBPMemory()
+{
+	memset(&bpmem, 0, sizeof(bpmem));
+	bpmem.bpMask = 0xFFFFFF;
+}
+
+void SWLoadBPReg(u32 value)
+{
+	//handle the mask register
+	int address = value >> 24;
+	int oldval = ((u32*)&bpmem)[address];
+	int newval = (oldval & ~bpmem.bpMask) | (value & bpmem.bpMask);
+
+	((u32*)&bpmem)[address] = newval;
+
+	//reset the mask register
+	if (address != 0xFE)
+		bpmem.bpMask = 0xFFFFFF;
+
+	SWBPWritten(address, newval);
+}
+
+void SWBPWritten(int address, int newvalue)
+{
+	switch (address)
+	{
+	case BPMEM_SCISSORTL:
+	case BPMEM_SCISSORBR:
+	case BPMEM_SCISSOROFFSET:
+		Rasterizer::SetScissor();
+		break;
+	case BPMEM_SETDRAWDONE: // This is called when the game is done drawing (eg: like in DX: Begin(); Draw(); End();)
+		switch (bpmem.drawdone & 0xFF)
+		{
+		case 0x02:
+			SWPixelEngine::SetFinish(); // may generate interrupt
+			DEBUG_LOG(VIDEO, "GXSetDrawDone SetPEFinish (value: 0x%02X)", (bpmem.drawdone & 0xFFFF));
+			break;
+
+		default:
+			WARN_LOG(VIDEO, "GXSetDrawDone ??? (value 0x%02X)", (bpmem.drawdone & 0xFFFF));
+			break;
+		}
+		break;
+	case BPMEM_PE_TOKEN_ID: // Pixel Engine Token ID
+		DEBUG_LOG(VIDEO, "SetPEToken 0x%04x", (bpmem.petoken & 0xFFFF));
+		SWPixelEngine::SetToken(static_cast<u16>(bpmem.petokenint & 0xFFFF), false);
+		break;
+	case BPMEM_PE_TOKEN_INT_ID: // Pixel Engine Interrupt Token ID
+		DEBUG_LOG(VIDEO, "SetPEToken + INT 0x%04x", (bpmem.petokenint & 0xFFFF));
+		SWPixelEngine::SetToken(static_cast<u16>(bpmem.petokenint & 0xFFFF), true);
+		break;
+	case BPMEM_TRIGGER_EFB_COPY:
+		EfbCopy::CopyEfb();
+		break;
+	case BPMEM_CLEARBBOX1:
+		SWPixelEngine::pereg.boxRight = newvalue >> 10;
+		SWPixelEngine::pereg.boxLeft = newvalue & 0x3ff;
+		break;
+	case BPMEM_CLEARBBOX2:
+		SWPixelEngine::pereg.boxBottom = newvalue >> 10;
+		SWPixelEngine::pereg.boxTop = newvalue & 0x3ff;
+		break;
+	case BPMEM_CLEAR_PIXEL_PERF:
+		// TODO: I didn't test if the value written to this register affects the amount of cleared registers
+		SWPixelEngine::pereg.perfZcompInputZcomplocLo = 0;
+		SWPixelEngine::pereg.perfZcompInputZcomplocHi = 0;
+		SWPixelEngine::pereg.perfZcompOutputZcomplocLo = 0;
+		SWPixelEngine::pereg.perfZcompOutputZcomplocHi = 0;
+		SWPixelEngine::pereg.perfZcompInputLo = 0;
+		SWPixelEngine::pereg.perfZcompInputHi = 0;
+		SWPixelEngine::pereg.perfZcompOutputLo = 0;
+		SWPixelEngine::pereg.perfZcompOutputHi = 0;
+		SWPixelEngine::pereg.perfBlendInputLo = 0;
+		SWPixelEngine::pereg.perfBlendInputHi = 0;
+		SWPixelEngine::pereg.perfEfbCopyClocksLo = 0;
+		SWPixelEngine::pereg.perfEfbCopyClocksHi = 0;
+		break;
+	case BPMEM_LOADTLUT0: // This one updates bpmem.tlutXferSrc, no need to do anything here.
+		break;
+	case BPMEM_LOADTLUT1: // Load a Texture Look Up Table
+		{
+			u32 tlutTMemAddr = (newvalue & 0x3FF) << 9;
+			u32 tlutXferCount = (newvalue & 0x1FFC00) >> 5; 
+
+			u8 *ptr = 0;
+
+			// TODO - figure out a cleaner way.
+			if (Core::g_CoreStartupParameter.bWii)
+				ptr = Memory::GetPointer(bpmem.tmem_config.tlut_src << 5);
+			else
+				ptr = Memory::GetPointer((bpmem.tmem_config.tlut_src & 0xFFFFF) << 5);
+
+			if (ptr)
+				memcpy_gc(texMem + tlutTMemAddr, ptr, tlutXferCount);
+			else
+				PanicAlert("Invalid palette pointer %08x %08x %08x", bpmem.tmem_config.tlut_src, bpmem.tmem_config.tlut_src << 5, (bpmem.tmem_config.tlut_src & 0xFFFFF)<< 5);
+			break;
+		}
+
+	case BPMEM_PRELOAD_MODE:
+		if (newvalue != 0)
+		{
+			// TODO: Not quite sure if this is completely correct (likely not)
+			// NOTE: libogc's implementation of GX_PreloadEntireTexture seems flawed, so it's not necessarily a good reference for RE'ing this feature.
+
+			BPS_TmemConfig& tmem_cfg = bpmem.tmem_config;
+			u8* src_ptr = Memory::GetPointer(tmem_cfg.preload_addr << 5); // TODO: Should we add mask here on GC?
+			u32 size = tmem_cfg.preload_tile_info.count * TMEM_LINE_SIZE;
+			u32 tmem_addr_even = tmem_cfg.preload_tmem_even * TMEM_LINE_SIZE;
+
+			if (tmem_cfg.preload_tile_info.type != 3)
+			{
+				if (tmem_addr_even + size > TMEM_SIZE)
+					size = TMEM_SIZE - tmem_addr_even;
+
+				memcpy(texMem + tmem_addr_even, src_ptr, size);
+			}
+			else // RGBA8 tiles (and CI14, but that might just be stupid libogc!)
+			{
+				// AR and GB tiles are stored in separate TMEM banks => can't use a single memcpy for everything
+				u32 tmem_addr_odd = tmem_cfg.preload_tmem_odd * TMEM_LINE_SIZE;
+
+				for (unsigned int i = 0; i < tmem_cfg.preload_tile_info.count; ++i)
+				{
+					if (tmem_addr_even + TMEM_LINE_SIZE > TMEM_SIZE ||
+						tmem_addr_odd  + TMEM_LINE_SIZE > TMEM_SIZE)
+						break;
+
+					memcpy(texMem + tmem_addr_even, src_ptr, TMEM_LINE_SIZE);
+					memcpy(texMem + tmem_addr_odd, src_ptr + TMEM_LINE_SIZE, TMEM_LINE_SIZE);
+					tmem_addr_even += TMEM_LINE_SIZE;
+					tmem_addr_odd += TMEM_LINE_SIZE;
+					src_ptr += TMEM_LINE_SIZE * 2;
+				}
+			}
+		}
+ 		break;
+
+	case BPMEM_TEV_REGISTER_L:   // Reg 1
+	case BPMEM_TEV_REGISTER_L+2: // Reg 2
+	case BPMEM_TEV_REGISTER_L+4: // Reg 3
+	case BPMEM_TEV_REGISTER_L+6: // Reg 4
+		{
+			int regNum = (address >> 1 ) & 0x3;
+			ColReg& reg = bpmem.tevregs[regNum].low;
+			bool konst = reg.type;
+
+			Rasterizer::SetTevReg(regNum, Tev::ALP_C, konst, reg.b); // A
+			Rasterizer::SetTevReg(regNum, Tev::RED_C, konst, reg.a); // R
+
+			break;
+		}
+
+	case BPMEM_TEV_REGISTER_H:   // Reg 1
+	case BPMEM_TEV_REGISTER_H+2: // Reg 2
+	case BPMEM_TEV_REGISTER_H+4: // Reg 3
+	case BPMEM_TEV_REGISTER_H+6: // Reg 4
+		{
+			int regNum = (address >> 1 ) & 0x3;
+			ColReg& reg = bpmem.tevregs[regNum].high;
+			bool konst = reg.type;
+
+			Rasterizer::SetTevReg(regNum, Tev::GRN_C, konst, reg.b); // G
+			Rasterizer::SetTevReg(regNum, Tev::BLU_C, konst, reg.a); // B
+
+			break;
+		}
+
+	}
+}
+

Source/Core/VideoBackends/Software/Src/BPMemLoader.h

@@ -0,0 +1,16 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#ifndef _BPMEMLOADER_H_
+#define _BPMEMLOADER_H_
+
+
+#include "Common.h"
+#include "BPMemory.h"
+
+void InitBPMemory();
+void SWBPWritten(int address, int newvalue);
+void SWLoadBPReg(u32 value);
+
+#endif

Source/Core/VideoBackends/Software/Src/CPMemLoader.cpp

@@ -0,0 +1,58 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include "VideoCommon.h"
+
+#include "CPMemLoader.h"
+#include "HW/Memmap.h"
+
+
+void SWLoadCPReg(u32 sub_cmd, u32 value)
+{
+	switch (sub_cmd & 0xF0)
+	{
+	case 0x30:
+		MatrixIndexA.Hex = value;
+		break;
+
+	case 0x40:
+		MatrixIndexB.Hex = value;
+		break;
+
+	case 0x50:
+		g_VtxDesc.Hex &= ~0x1FFFF;  // keep the Upper bits
+		g_VtxDesc.Hex |= value;
+		break;
+
+	case 0x60:
+		g_VtxDesc.Hex &= 0x1FFFF;  // keep the lower 17Bits
+		g_VtxDesc.Hex |= (u64)value << 17;
+		break;
+
+	case 0x70:
+		_assert_((sub_cmd & 0x0F) < 8);
+		g_VtxAttr[sub_cmd & 7].g0.Hex = value;
+		break;
+
+	case 0x80:
+		_assert_((sub_cmd & 0x0F) < 8);
+		g_VtxAttr[sub_cmd & 7].g1.Hex = value;
+		break;
+
+	case 0x90:
+		_assert_((sub_cmd & 0x0F) < 8);
+		g_VtxAttr[sub_cmd & 7].g2.Hex = value;
+		break;
+
+	// Pointers to vertex arrays in GC RAM
+	case 0xA0:
+		arraybases[sub_cmd & 0xF] = value;
+		cached_arraybases[sub_cmd & 0xF] = Memory::GetPointer(value);
+		break;
+
+	case 0xB0:
+		arraystrides[sub_cmd & 0xF] = value & 0xFF;
+		break;
+	}
+}

Source/Core/VideoBackends/Software/Src/CPMemLoader.h

@@ -0,0 +1,14 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#ifndef _CPMEMLOADER_H_
+#define _CPMEMLOADER_H_
+
+
+#include "Common.h"
+#include "CPMemory.h"
+
+void SWLoadCPReg(u32 sub_cmd, u32 value);
+
+#endif

Source/Core/VideoBackends/Software/Src/Clipper.cpp

@@ -0,0 +1,438 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+/*
+Portions of this file are based off work by Markus Trenkwalder.
+Copyright (c) 2007, 2008 Markus Trenkwalder
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, 
+  this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation 
+  and/or other materials provided with the distribution.
+
+* Neither the name of the library's copyright owner nor the names of its 
+  contributors may be used to endorse or promote products derived from this 
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "Clipper.h"
+#include "Rasterizer.h"
+#include "NativeVertexFormat.h"
+#include "XFMemLoader.h"
+#include "BPMemLoader.h"
+#include "SWStatistics.h"
+
+
+namespace Clipper
+{
+	enum { NUM_CLIPPED_VERTICES = 33, NUM_INDICES = NUM_CLIPPED_VERTICES + 3 };
+
+	float m_ViewOffset[2];
+
+	OutputVertexData ClippedVertices[NUM_CLIPPED_VERTICES];
+	OutputVertexData *Vertices[NUM_INDICES];
+
+	void DoState(PointerWrap &p)
+	{
+		p.DoArray(m_ViewOffset,2);
+		for (int i = 0; i< NUM_CLIPPED_VERTICES; ++i)
+			ClippedVertices[i].DoState(p);
+	}
+
+	void Init()
+	{
+		for (int i = 0; i < NUM_CLIPPED_VERTICES; ++i)
+			Vertices[i+3] = &ClippedVertices[i];
+	}
+
+	void SetViewOffset()
+	{
+		m_ViewOffset[0] = swxfregs.viewport.xOrig - 342;
+		m_ViewOffset[1] = swxfregs.viewport.yOrig - 342;
+	}
+
+
+	enum {
+		SKIP_FLAG = -1,
+		CLIP_POS_X_BIT = 0x01,
+		CLIP_NEG_X_BIT = 0x02,
+		CLIP_POS_Y_BIT = 0x04,
+		CLIP_NEG_Y_BIT = 0x08,
+		CLIP_POS_Z_BIT = 0x10,
+		CLIP_NEG_Z_BIT = 0x20
+	};
+
+	static inline int CalcClipMask(OutputVertexData *v)
+	{
+		int cmask = 0;
+		Vec4 pos = v->projectedPosition;
+		if (pos.w - pos.x < 0) cmask |= CLIP_POS_X_BIT;
+		if (pos.x + pos.w < 0) cmask |= CLIP_NEG_X_BIT;
+		if (pos.w - pos.y < 0) cmask |= CLIP_POS_Y_BIT;
+		if (pos.y + pos.w < 0) cmask |= CLIP_NEG_Y_BIT;
+		if (pos.w * pos.z > 0) cmask |= CLIP_POS_Z_BIT;
+		if (pos.z + pos.w < 0) cmask |= CLIP_NEG_Z_BIT;
+		return cmask;
+	}
+
+	static inline void AddInterpolatedVertex(float t, int out, int in, int& numVertices)
+	{
+		Vertices[numVertices]->Lerp(t, Vertices[out], Vertices[in]);
+		numVertices++;
+	}
+
+	#define DIFFERENT_SIGNS(x,y) ((x <= 0 && y > 0) || (x > 0 && y <= 0))
+
+	#define CLIP_DOTPROD(I, A, B, C, D) \
+		(Vertices[I]->projectedPosition.x * A + Vertices[I]->projectedPosition.y * B + Vertices[I]->projectedPosition.z * C + Vertices[I]->projectedPosition.w * D)
+
+	#define POLY_CLIP( PLANE_BIT, A, B, C, D )							\
+	{																	\
+		if (mask & PLANE_BIT) {											\
+			int idxPrev = inlist[0];									\
+			float dpPrev = CLIP_DOTPROD(idxPrev, A, B, C, D );			\
+			int outcount = 0;											\
+																		\
+			inlist[n] = inlist[0];										\
+			for (int j = 1; j <= n; j++) { 								\
+				int idx = inlist[j];									\
+				float dp = CLIP_DOTPROD(idx, A, B, C, D );				\
+				if (dpPrev >= 0) {										\
+					outlist[outcount++] = idxPrev;						\
+				}														\
+																		\
+				if (DIFFERENT_SIGNS(dp, dpPrev)) {						\
+					if (dp < 0) {										\
+						float t = dp / (dp - dpPrev);					\
+						AddInterpolatedVertex(t, idx, idxPrev, numVertices);		\
+					} else {											\
+						float t = dpPrev / (dpPrev - dp);				\
+						AddInterpolatedVertex(t, idxPrev, idx, numVertices);		\
+					}													\
+					outlist[outcount++] = numVertices - 1;				\
+				}														\
+																		\
+				idxPrev = idx;											\
+				dpPrev = dp;											\
+			}															\
+																		\
+			if (outcount < 3)											\
+				continue;												\
+																		\
+	 		{															\
+				int *tmp = inlist;										\
+				inlist = outlist;										\
+				outlist = tmp;											\
+				n = outcount;											\
+			}															\
+		}																\
+	}
+
+	#define LINE_CLIP(PLANE_BIT, A, B, C, D )					\
+	{															\
+		if (mask & PLANE_BIT) {									\
+			const float dp0 = CLIP_DOTPROD( 0, A, B, C, D );	\
+			const float dp1 = CLIP_DOTPROD( 1, A, B, C, D );	\
+			const bool neg_dp0 = dp0 < 0;						\
+			const bool neg_dp1 = dp1 < 0;						\
+																\
+			if (neg_dp0 && neg_dp1)								\
+				return;											\
+																\
+			if (neg_dp1) {										\
+				float t = dp1 / (dp1 - dp0);						\
+				if (t > t1) t1 = t;								\
+			} else if (neg_dp0) {								\
+				float t = dp0 / (dp0 - dp1);						\
+				if (t > t0) t0 = t;								\
+			}													\
+		}														\
+	}
+
+	void ClipTriangle(int *indices, int &numIndices)
+	{
+		int mask = 0;
+
+		mask |= CalcClipMask(Vertices[0]);
+		mask |= CalcClipMask(Vertices[1]);
+		mask |= CalcClipMask(Vertices[2]);
+
+		if (mask != 0)
+		{
+			for(int i = 0; i < 3; i += 3)
+			{
+				int vlist[2][2*6+1];
+				int *inlist = vlist[0], *outlist = vlist[1];
+				int n = 3;
+				int numVertices = 3;
+
+				inlist[0] = 0;
+				inlist[1] = 1;
+				inlist[2] = 2;
+
+				// mark this triangle as unused in case it should be completely 
+				// clipped
+				indices[0] = SKIP_FLAG;
+				indices[1] = SKIP_FLAG;
+				indices[2] = SKIP_FLAG;
+
+				POLY_CLIP(CLIP_POS_X_BIT, -1,  0,  0, 1);
+				POLY_CLIP(CLIP_NEG_X_BIT,  1,  0,  0, 1);
+				POLY_CLIP(CLIP_POS_Y_BIT,  0, -1,  0, 1);
+				POLY_CLIP(CLIP_NEG_Y_BIT,  0,  1,  0, 1);
+				POLY_CLIP(CLIP_POS_Z_BIT,  0,  0,  0, 1);
+				POLY_CLIP(CLIP_NEG_Z_BIT,  0,  0,  1, 1);
+
+				INCSTAT(swstats.thisFrame.numTrianglesClipped);
+
+				// transform the poly in inlist into triangles
+				indices[0] = inlist[0];
+				indices[1] = inlist[1];
+				indices[2] = inlist[2];
+				for (int j = 3; j < n; ++j) {
+					indices[numIndices++] = inlist[0];
+					indices[numIndices++] = inlist[j - 1];
+					indices[numIndices++] = inlist[j];
+				}
+			}
+		}
+	}
+
+	void ClipLine(int *indices)
+	{
+		int mask = 0;
+		int clip_mask[2] = { 0, 0 };
+
+		for (int i = 0; i < 2; ++i)
+		{
+			clip_mask[i] = CalcClipMask(Vertices[i]);
+			mask |= clip_mask[i];
+		}
+
+		if (mask == 0) 
+			return;
+
+		float t0 = 0;
+		float t1 = 0;
+
+		// Mark unused in case of early termination 
+		// of the macros below. (When fully clipped)
+		indices[0] = SKIP_FLAG;
+		indices[1] = SKIP_FLAG;
+
+		LINE_CLIP(CLIP_POS_X_BIT, -1,  0,  0, 1);
+		LINE_CLIP(CLIP_NEG_X_BIT,  1,  0,  0, 1);
+		LINE_CLIP(CLIP_POS_Y_BIT,  0, -1,  0, 1);
+		LINE_CLIP(CLIP_NEG_Y_BIT,  0,  1,  0, 1);
+		LINE_CLIP(CLIP_POS_Z_BIT,  0,  0, -1, 1);
+		LINE_CLIP(CLIP_NEG_Z_BIT,  0,  0,  1, 1);
+
+		// Restore the old values as this line 
+		// was not fully clipped.
+		indices[0] = 0;
+		indices[1] = 1;
+
+		int numVertices = 2;
+
+		if (clip_mask[0])
+		{
+			indices[0] = numVertices;
+			AddInterpolatedVertex(t0, 0, 1, numVertices);
+		}
+
+		if (clip_mask[1])
+		{
+			indices[1] = numVertices;
+			AddInterpolatedVertex(t1, 1, 0, numVertices);
+		}
+	}
+
+	void ProcessTriangle(OutputVertexData *v0, OutputVertexData *v1, OutputVertexData *v2)
+	{
+		INCSTAT(swstats.thisFrame.numTrianglesIn)
+
+		bool backface;
+
+		if(!CullTest(v0, v1, v2, backface))
+			return;
+
+		int indices[NUM_INDICES] = { 0, 1, 2, SKIP_FLAG, SKIP_FLAG, SKIP_FLAG, SKIP_FLAG, SKIP_FLAG, SKIP_FLAG,
+										SKIP_FLAG, SKIP_FLAG, SKIP_FLAG, SKIP_FLAG, SKIP_FLAG, SKIP_FLAG,
+										SKIP_FLAG, SKIP_FLAG, SKIP_FLAG, SKIP_FLAG, SKIP_FLAG, SKIP_FLAG };
+		int numIndices = 3;
+
+		if (backface)
+		{
+			Vertices[0] = v0;
+			Vertices[1] = v2;
+			Vertices[2] = v1;
+		}
+		else
+		{
+			Vertices[0] = v0;
+			Vertices[1] = v1;
+			Vertices[2] = v2;
+		}
+
+		ClipTriangle(indices, numIndices);
+
+		for(int i = 0; i+3 <= numIndices; i+=3)
+		{
+			_assert_(i < NUM_INDICES);
+			if(indices[i] != SKIP_FLAG)
+			{
+				PerspectiveDivide(Vertices[indices[i]]);
+				PerspectiveDivide(Vertices[indices[i+1]]);
+				PerspectiveDivide(Vertices[indices[i+2]]);
+
+				Rasterizer::DrawTriangleFrontFace(Vertices[indices[i]], Vertices[indices[i+1]], Vertices[indices[i+2]]);                
+			}
+		}
+	}
+
+	void CopyVertex(OutputVertexData *dst, OutputVertexData *src, float dx, float dy, unsigned int sOffset)
+	{
+		dst->screenPosition.x = src->screenPosition.x + dx;
+		dst->screenPosition.y = src->screenPosition.y + dy;
+		dst->screenPosition.z = src->screenPosition.z;
+
+		for (int i = 0; i < 3; ++i)
+			dst->normal[i] = src->normal[i];
+
+		for (int i = 0; i < 4; ++i)
+			dst->color[0][i] = src->color[0][i];
+
+		// todo - s offset
+		for (int i = 0; i < 8; ++i)
+			dst->texCoords[i] = src->texCoords[i];
+	}
+
+	void ProcessLine(OutputVertexData *lineV0, OutputVertexData *lineV1)
+	{
+		int indices[4] = { 0, 1, SKIP_FLAG, SKIP_FLAG };
+
+		Vertices[0] = lineV0;
+		Vertices[1] = lineV1;
+
+		// point to a valid vertex to store to when clipping
+		Vertices[2] = &ClippedVertices[17];
+
+		ClipLine(indices);
+
+		if(indices[0] != SKIP_FLAG)
+		{
+			OutputVertexData *v0 = Vertices[indices[0]];
+			OutputVertexData *v1 = Vertices[indices[1]];
+
+			PerspectiveDivide(v0);
+			PerspectiveDivide(v1);
+
+			float dx = v1->screenPosition.x - v0->screenPosition.x;
+			float dy = v1->screenPosition.y - v0->screenPosition.y;
+			
+			float screenDx = 0;
+			float screenDy = 0;
+
+			if(fabsf(dx) > fabsf(dy))
+			{
+				if(dx > 0)
+					screenDy = bpmem.lineptwidth.linesize / -12.0f;
+				else
+					screenDy = bpmem.lineptwidth.linesize / 12.0f;
+			}
+			else
+			{
+				if(dy > 0)
+					screenDx = bpmem.lineptwidth.linesize / 12.0f;
+				else
+					screenDx = bpmem.lineptwidth.linesize / -12.0f;
+			}
+
+			OutputVertexData triangle[3];
+
+			CopyVertex(&triangle[0], v0, screenDx, screenDy, 0);
+			CopyVertex(&triangle[1], v1, screenDx, screenDy, 0);
+			CopyVertex(&triangle[2], v1, -screenDx, -screenDy, bpmem.lineptwidth.lineoff);
+
+			// ccw winding
+			Rasterizer::DrawTriangleFrontFace(&triangle[2], &triangle[1], &triangle[0]);
+
+			CopyVertex(&triangle[1], v0, -screenDx, -screenDy, bpmem.lineptwidth.lineoff);
+
+			Rasterizer::DrawTriangleFrontFace(&triangle[0], &triangle[1], &triangle[2]);
+		}
+	}
+
+	bool CullTest(OutputVertexData *v0, OutputVertexData *v1, OutputVertexData *v2, bool &backface)
+	{
+		int mask = CalcClipMask(v0);
+		mask &= CalcClipMask(v1);
+		mask &= CalcClipMask(v2);
+
+		if(mask)
+		{
+			INCSTAT(swstats.thisFrame.numTrianglesRejected)
+			return false;
+		}
+
+		float x0 = v0->projectedPosition.x;
+		float x1 = v1->projectedPosition.x;
+		float x2 = v2->projectedPosition.x;
+		float y1 = v1->projectedPosition.y;
+		float y0 = v0->projectedPosition.y;
+		float y2 = v2->projectedPosition.y;
+		float w0 = v0->projectedPosition.w;
+		float w1 = v1->projectedPosition.w;
+		float w2 = v2->projectedPosition.w;
+
+		float normalZDir = (x0*w2 - x2*w0)*y1 + (x2*y0 - x0*y2)*w1 + (y2*w0 - y0*w2)*x1; 
+
+		backface = normalZDir <= 0.0f;
+
+		if ((bpmem.genMode.cullmode & 1) && !backface) // cull frontfacing
+		{
+			INCSTAT(swstats.thisFrame.numTrianglesCulled)
+			return false;
+		}
+
+		if ((bpmem.genMode.cullmode & 2) && backface) // cull backfacing
+		{
+			INCSTAT(swstats.thisFrame.numTrianglesCulled)
+			return false;
+		}
+
+		return true;
+	}
+
+	void PerspectiveDivide(OutputVertexData *vertex)
+	{
+		Vec4 &projected = vertex->projectedPosition;
+		Vec3 &screen = vertex->screenPosition;
+
+		float wInverse = 1.0f/projected.w;
+		screen.x = projected.x * wInverse * swxfregs.viewport.wd + m_ViewOffset[0];
+		screen.y = projected.y * wInverse * swxfregs.viewport.ht + m_ViewOffset[1];
+		screen.z = projected.z * wInverse * swxfregs.viewport.zRange + swxfregs.viewport.farZ;
+	}
+
+}

Source/Core/VideoBackends/Software/Src/Clipper.h

@@ -0,0 +1,32 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#ifndef _CLIPPER_H_
+#define _CLIPPER_H_
+
+
+#include "Common.h"
+#include "NativeVertexFormat.h"
+#include "ChunkFile.h"
+
+
+namespace Clipper
+{
+	void Init();
+
+	void SetViewOffset();
+
+	void ProcessTriangle(OutputVertexData *v0, OutputVertexData *v1, OutputVertexData *v2);
+
+	void ProcessLine(OutputVertexData *v0, OutputVertexData *v1);
+
+	bool CullTest(OutputVertexData *v0, OutputVertexData *v1, OutputVertexData *v2, bool &backface);
+
+	void PerspectiveDivide(OutputVertexData *vertex);
+
+	void DoState(PointerWrap &p);
+}
+
+
+#endif

Source/Core/VideoBackends/Software/Src/DebugUtil.cpp

@@ -0,0 +1,276 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include "Common.h"
+
+#include "DebugUtil.h"
+#include "BPMemLoader.h"
+#include "TextureSampler.h"
+#include "SWVideoConfig.h"
+#include "EfbInterface.h"
+#include "SWStatistics.h"
+#include "HwRasterizer.h"
+#include "StringUtil.h"
+#include "SWCommandProcessor.h"
+#include "ImageWrite.h"
+#include "FileUtil.h"
+
+namespace DebugUtil
+{
+
+u32 skipFrames = 0;
+bool drawingHwTriangles = false;
+
+enum { NumObjectBuffers = 40};
+
+u32 ObjectBuffer[NumObjectBuffers][EFB_WIDTH*EFB_HEIGHT];
+u32 TempBuffer[NumObjectBuffers];
+
+bool DrawnToBuffer[NumObjectBuffers];
+const char* ObjectBufferName[NumObjectBuffers];
+int BufferBase[NumObjectBuffers];
+
+void Init()
+{
+	for (int i = 0; i < NumObjectBuffers; i++)
+	{
+		memset(ObjectBuffer[i], 0, sizeof(ObjectBuffer[i]));
+		DrawnToBuffer[i] = false;
+		ObjectBufferName[i] = 0;
+		BufferBase[i] = 0;
+	}
+}
+
+void SaveTexture(const char* filename, u32 texmap, s32 mip)
+{
+	FourTexUnits& texUnit = bpmem.tex[(texmap >> 2) & 1];
+	u8 subTexmap = texmap & 3;
+
+	TexImage0& ti0 = texUnit.texImage0[subTexmap];
+
+	u32 width = ti0.width + 1;
+	u32 height = ti0.height + 1;
+
+	u8 *data = new u8[width * height * 4];
+
+	GetTextureBGRA(data, texmap, mip, width, height);
+
+	(void)SaveTGA(filename, width, height, data);
+
+	delete []data;
+}
+
+void GetTextureBGRA(u8 *dst, u32 texmap, s32 mip, u32 width, u32 height)
+{
+	u8 sample[4];
+
+	for (u32 y = 0; y < height; y++)
+	{
+		for (u32 x = 0; x < width; x++)
+		{
+			TextureSampler::SampleMip(x << 7, y << 7, mip, false, texmap, sample);
+
+			// RGBA to BGRA
+			*(dst++) = sample[2];
+			*(dst++) = sample[1];
+			*(dst++) = sample[0];
+			*(dst++) = sample[3];
+		}
+	}
+}
+
+s32 GetMaxTextureLod(u32 texmap)
+{
+	FourTexUnits& texUnit = bpmem.tex[(texmap >> 2) & 1];
+	u8 subTexmap = texmap & 3;
+
+	u8 maxLod = texUnit.texMode1[subTexmap].max_lod;
+	u8 mip = maxLod >> 4;
+	u8 fract = maxLod & 0xf;
+
+	if(fract)
+		++mip;
+
+	return (s32)mip;
+}
+
+void DumpActiveTextures()
+{
+	for (unsigned int stageNum = 0; stageNum < bpmem.genMode.numindstages; stageNum++)
+	{
+		u32 texmap = bpmem.tevindref.getTexMap(stageNum);
+
+		s32 maxLod = GetMaxTextureLod(texmap);
+		for (s32 mip = 0; mip <= maxLod; ++mip)
+		{
+			SaveTexture(StringFromFormat("%star%i_ind%i_map%i_mip%i.tga",
+						File::GetUserPath(D_DUMPTEXTURES_IDX).c_str(),
+						swstats.thisFrame.numDrawnObjects, stageNum, texmap, mip).c_str(), texmap, mip);
+		}
+	}
+
+	for (unsigned int stageNum = 0; stageNum <= bpmem.genMode.numtevstages; stageNum++)
+	{
+		int stageNum2 = stageNum >> 1;
+		int stageOdd = stageNum&1;
+		TwoTevStageOrders &order = bpmem.tevorders[stageNum2];
+
+		int texmap = order.getTexMap(stageOdd);
+
+		s32 maxLod = GetMaxTextureLod(texmap);
+		for (s32 mip = 0; mip <= maxLod; ++mip)
+		{
+			SaveTexture(StringFromFormat("%star%i_stage%i_map%i_mip%i.tga",
+						File::GetUserPath(D_DUMPTEXTURES_IDX).c_str(),
+						swstats.thisFrame.numDrawnObjects, stageNum, texmap, mip).c_str(), texmap, mip);
+		}
+	}
+}
+
+void DumpEfb(const char* filename)
+{
+	u8 *data = new u8[EFB_WIDTH * EFB_HEIGHT * 4];
+	u8 *writePtr = data;
+	u8 sample[4];
+
+	for (int y = 0; y < EFB_HEIGHT; y++)
+	{
+		for (int x = 0; x < EFB_WIDTH; x++)
+		{
+			EfbInterface::GetColor(x, y, sample);
+			// ABGR to BGRA
+			*(writePtr++) = sample[1];
+			*(writePtr++) = sample[2];
+			*(writePtr++) = sample[3];
+			*(writePtr++) = sample[0];
+		}
+	}
+
+	(void)SaveTGA(filename, EFB_WIDTH, EFB_HEIGHT, data);
+
+	delete []data;
+}
+
+void DumpDepth(const char* filename)
+{
+	u8 *data = new u8[EFB_WIDTH * EFB_HEIGHT * 4];
+	u8 *writePtr = data;
+
+	for (int y = 0; y < EFB_HEIGHT; y++)
+	{
+		for (int x = 0; x < EFB_WIDTH; x++)
+		{
+			u32 depth = EfbInterface::GetDepth(x, y);
+			// depth to bgra
+			*(writePtr++) = (depth >> 16) & 0xff;
+			*(writePtr++) = (depth >> 8) & 0xff;
+			*(writePtr++) = depth & 0xff;
+			*(writePtr++) = 255;
+		}
+	}
+
+	(void)SaveTGA(filename, EFB_WIDTH, EFB_HEIGHT, data);
+
+	delete []data;
+}
+
+void DrawObjectBuffer(s16 x, s16 y, u8 *color, int bufferBase, int subBuffer, const char *name)
+{
+	int buffer = bufferBase + subBuffer;
+
+	u32 offset = (x + y * EFB_WIDTH) * 4;
+	u8 *dst = (u8*)&ObjectBuffer[buffer][offset];
+	*(dst++) = color[2];
+	*(dst++) = color[1];
+	*(dst++) = color[0];
+	*(dst++) = color[3];
+
+	DrawnToBuffer[buffer] = true;
+	ObjectBufferName[buffer] = name;
+	BufferBase[buffer] = bufferBase;
+}
+
+void DrawTempBuffer(u8 *color, int buffer)
+{
+	u8 *dst = (u8*)&TempBuffer[buffer];
+	*(dst++) = color[2];
+	*(dst++) = color[1];
+	*(dst++) = color[0];
+	*(dst++) = color[3];
+}
+
+void CopyTempBuffer(s16 x, s16 y, int bufferBase, int subBuffer, const char *name)
+{
+	int buffer = bufferBase + subBuffer;
+
+	u32 offset = (x + y * EFB_WIDTH);
+	ObjectBuffer[buffer][offset] = TempBuffer[buffer];
+
+	DrawnToBuffer[buffer] = true;
+	ObjectBufferName[buffer] = name;
+	BufferBase[buffer] = bufferBase;
+}
+
+void OnObjectBegin()
+{
+	if (!g_bSkipCurrentFrame)
+	{
+		if (g_SWVideoConfig.bDumpTextures && swstats.thisFrame.numDrawnObjects >= g_SWVideoConfig.drawStart && swstats.thisFrame.numDrawnObjects < g_SWVideoConfig.drawEnd)
+			DumpActiveTextures();
+
+		if (g_SWVideoConfig.bHwRasterizer)
+		{
+			HwRasterizer::BeginTriangles();
+			drawingHwTriangles = true;
+		}
+	}
+}
+
+void OnObjectEnd()
+{
+	if (!g_bSkipCurrentFrame)
+	{
+		if (g_SWVideoConfig.bDumpObjects && swstats.thisFrame.numDrawnObjects >= g_SWVideoConfig.drawStart && swstats.thisFrame.numDrawnObjects < g_SWVideoConfig.drawEnd)
+			DumpEfb(StringFromFormat("%sobject%i.tga",
+						File::GetUserPath(D_DUMPFRAMES_IDX).c_str(),
+						swstats.thisFrame.numDrawnObjects).c_str());
+
+		if (g_SWVideoConfig.bHwRasterizer || drawingHwTriangles)
+		{
+			HwRasterizer::EndTriangles();
+			drawingHwTriangles = false;
+		}
+
+		for (int i = 0; i < NumObjectBuffers; i++)
+		{
+			if (DrawnToBuffer[i])
+			{
+				DrawnToBuffer[i] = false;
+				(void)SaveTGA(StringFromFormat("%sobject%i_%s(%i).tga",
+							File::GetUserPath(D_DUMPFRAMES_IDX).c_str(),
+							swstats.thisFrame.numDrawnObjects, ObjectBufferName[i], i - BufferBase[i]).c_str(),
+						EFB_WIDTH, EFB_HEIGHT, ObjectBuffer[i]);
+				memset(ObjectBuffer[i], 0, sizeof(ObjectBuffer[i]));
+			}
+		}
+
+		swstats.thisFrame.numDrawnObjects++;
+	}
+}
+
+void OnFrameEnd()
+{
+	if (!g_bSkipCurrentFrame)
+	{
+		if (g_SWVideoConfig.bDumpFrames)
+		{
+			DumpEfb(StringFromFormat("%sframe%i_color.tga",
+						File::GetUserPath(D_DUMPFRAMES_IDX).c_str(), swstats.frameCount).c_str());
+			DumpDepth(StringFromFormat("%sframe%i_depth.tga",
+						File::GetUserPath(D_DUMPFRAMES_IDX).c_str(), swstats.frameCount).c_str());
+		}
+	}
+}
+
+}

Source/Core/VideoBackends/Software/Src/DebugUtil.h

@@ -0,0 +1,27 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#ifndef _DEBUGUTIL_H
+#define _DEBUGUTIL_H
+
+namespace DebugUtil
+{
+	void Init();
+
+	void GetTextureBGRA(u8 *dst, u32 texmap, s32 mip, u32 width, u32 height);
+
+	void DumpActiveTextures();
+
+	void OnObjectBegin();
+	void OnObjectEnd();
+
+	void OnFrameEnd();
+
+	void DrawObjectBuffer(s16 x, s16 y, u8 *color, int bufferBase, int subBuffer, const char *name);
+
+	void DrawTempBuffer(u8 *color, int buffer);
+	void CopyTempBuffer(s16 x, s16 y, int bufferBase, int subBuffer, const char *name);
+}
+
+#endif 

Source/Core/VideoBackends/Software/Src/EfbCopy.cpp

@@ -0,0 +1,99 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include "BPMemLoader.h"
+#include "EfbCopy.h"
+#include "EfbInterface.h"
+#include "SWRenderer.h"
+#include "TextureEncoder.h"
+#include "SWStatistics.h"
+#include "SWVideoConfig.h"
+#include "DebugUtil.h"
+#include "HwRasterizer.h"
+#include "SWCommandProcessor.h"
+#include "HW/Memmap.h"
+#include "Core.h"
+
+namespace EfbCopy
+{
+	void CopyToXfb()
+	{
+		GLInterface->Update(); // just updates the render window position and the backbuffer size	
+
+		if (!g_SWVideoConfig.bHwRasterizer)
+		{
+			// copy to open gl for rendering
+			EfbInterface::UpdateColorTexture();
+			SWRenderer::DrawTexture(EfbInterface::efbColorTexture, EFB_WIDTH, EFB_HEIGHT);
+		}
+
+		SWRenderer::SwapBuffer();
+	}
+
+	void CopyToRam()
+	{
+		if (!g_SWVideoConfig.bHwRasterizer)
+		{
+			u8 *dest_ptr = Memory::GetPointer(bpmem.copyTexDest << 5);
+
+			TextureEncoder::Encode(dest_ptr);
+		}
+	}
+
+	void ClearEfb()
+	{
+		u32 clearColor = (bpmem.clearcolorAR & 0xff) << 24 | bpmem.clearcolorGB << 8 | (bpmem.clearcolorAR & 0xff00) >> 8;
+
+		int left   = bpmem.copyTexSrcXY.x;
+		int top    = bpmem.copyTexSrcXY.y;
+		int right  = left + bpmem.copyTexSrcWH.x;
+		int bottom = top + bpmem.copyTexSrcWH.y;
+
+		for (u16 y = top; y <= bottom; y++)
+		{
+			for (u16 x = left; x <= right; x++)
+			{
+				EfbInterface::SetColor(x, y, (u8*)(&clearColor));
+				EfbInterface::SetDepth(x, y, bpmem.clearZValue);
+			}
+		}
+	}
+
+	void CopyEfb()
+	{
+		if (bpmem.triggerEFBCopy.copy_to_xfb)
+			DebugUtil::OnFrameEnd();
+
+		if (!g_bSkipCurrentFrame)
+		{
+			if (bpmem.triggerEFBCopy.copy_to_xfb)
+			{
+				CopyToXfb();
+				Core::Callback_VideoCopiedToXFB(true);
+
+				swstats.frameCount++;
+			}
+			else
+			{
+				CopyToRam();
+			}
+
+			if (bpmem.triggerEFBCopy.clear)
+			{
+				if (g_SWVideoConfig.bHwRasterizer)
+					HwRasterizer::Clear();
+				else
+					ClearEfb();
+			}
+		}
+		else
+		{
+			if (bpmem.triggerEFBCopy.copy_to_xfb)
+			{
+				// no frame rendered but tell that a frame has finished for frame skip counter
+				Core::Callback_VideoCopiedToXFB(false);
+			}
+		}
+	}
+}

Source/Core/VideoBackends/Software/Src/EfbCopy.h

@@ -0,0 +1,19 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#ifndef _EFB_COPY_H_
+#define _EFB_COPY_H_
+
+
+#include "Common.h"
+
+namespace EfbCopy
+{
+	// Copy the EFB to RAM as a texture format or XFB
+	// Clear the EFB if needed
+	void CopyEfb();
+}
+
+
+#endif

Source/Core/VideoBackends/Software/Src/EfbInterface.h

@@ -0,0 +1,40 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#ifndef _EFB_INTERFACE_H_
+#define _EFB_INTERFACE_H_
+
+#include "VideoCommon.h"
+
+namespace EfbInterface
+{
+	const int DEPTH_BUFFER_START = EFB_WIDTH * EFB_HEIGHT * 3;
+
+	enum { ALP_C, BLU_C, GRN_C, RED_C };
+
+	// color order is ABGR in order to emulate RGBA on little-endian hardware
+
+	// does full blending of an incoming pixel
+	void BlendTev(u16 x, u16 y, u8 *color);
+
+	// compare z at location x,y
+	// writes it if it passes
+	// returns result of compare.
+	bool ZCompare(u16 x, u16 y, u32 z);
+
+	// sets the color and alpha
+	void SetColor(u16 x, u16 y, u8 *color);
+	void SetDepth(u16 x, u16 y, u32 depth);
+
+	void GetColor(u16 x, u16 y, u8 *color);
+	u32 GetDepth(u16 x, u16 y);
+
+	u8* GetPixelPointer(u16 x, u16 y, bool depth);
+
+	void UpdateColorTexture();
+	extern u8 efbColorTexture[EFB_WIDTH*EFB_HEIGHT*4]; // RGBA format
+	void DoState(PointerWrap &p);
+}
+
+#endif

Source/Core/VideoBackends/Software/Src/HwRasterizer.cpp

@@ -0,0 +1,369 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include "Common.h"
+#include "MemoryUtil.h"
+
+#include <VideoCommon.h>
+
+#include "BPMemLoader.h"
+#include "HwRasterizer.h"
+#include "NativeVertexFormat.h"
+#include "DebugUtil.h"
+
+#define TEMP_SIZE (1024*1024*4)
+
+namespace HwRasterizer
+{
+	float efbHalfWidth;
+	float efbHalfHeight;
+	bool hasTexture;
+
+	u8 *temp;
+
+	// Programs
+	static GLuint colProg, texProg, clearProg;
+
+	// Color
+	static GLint col_apos = -1, col_atex = -1;
+	// Tex
+	static GLint tex_apos = -1, tex_atex = -1, tex_utex = -1;
+	// Clear shader
+	static GLint clear_apos = -1, clear_ucol = -1;
+
+	void CreateShaders()
+	{
+		// Color Vertices
+		static const char *fragcolText =
+			"varying " PREC " vec4 TexCoordOut;\n"
+			"void main() {\n"
+			"	gl_FragColor = TexCoordOut;\n"
+			"}\n";
+		// Texture Vertices
+		static const char *fragtexText =
+			"varying " PREC " vec4 TexCoordOut;\n"
+			"uniform " TEXTYPE " Texture;\n"
+			"void main() {\n"
+			"	gl_FragColor = " TEXFUNC "(Texture, TexCoordOut.xy);\n"
+			"}\n";
+		// Clear shader
+		static const char *fragclearText =
+			"uniform " PREC " vec4 Color;\n"
+			"void main() {\n"
+			"	gl_FragColor = Color;\n"
+			"}\n";
+		// Generic passthrough vertice shaders
+		static const char *vertShaderText =
+			"attribute vec4 pos;\n"
+			"attribute vec4 TexCoordIn;\n "
+			"varying vec4 TexCoordOut;\n "
+			"void main() {\n"
+			"	gl_Position = pos;\n"
+			"	TexCoordOut = TexCoordIn;\n"
+			"}\n";
+		static const char *vertclearText =
+			"attribute vec4 pos;\n"
+			"void main() {\n"
+			"	gl_Position = pos;\n"
+			"}\n";
+
+		// Color Program
+		colProg = OpenGL_CompileProgram(vertShaderText, fragcolText);
+
+		// Texture Program
+		texProg = OpenGL_CompileProgram(vertShaderText, fragtexText);
+
+		// Clear Program
+		clearProg = OpenGL_CompileProgram(vertclearText, fragclearText);
+
+		// Color attributes
+		col_apos = glGetAttribLocation(colProg, "pos");
+		col_atex = glGetAttribLocation(colProg, "TexCoordIn");
+		// Texture attributes
+		tex_apos = glGetAttribLocation(texProg, "pos");
+		tex_atex = glGetAttribLocation(texProg, "TexCoordIn");
+		tex_utex = glGetUniformLocation(texProg, "Texture");
+		// Clear attributes
+		clear_apos = glGetAttribLocation(clearProg, "pos");
+		clear_ucol = glGetUniformLocation(clearProg, "Color");
+	}
+
+	void Init()
+	{
+		efbHalfWidth = EFB_WIDTH / 2.0f;
+		efbHalfHeight = 480 / 2.0f;
+
+		temp = (u8*)AllocateMemoryPages(TEMP_SIZE);
+	}
+	void Shutdown()
+	{
+		glDeleteProgram(colProg);
+		glDeleteProgram(texProg);
+		glDeleteProgram(clearProg);
+	}
+	void Prepare()
+	{
+		//legacy multitexturing: select texture channel only.
+		glActiveTexture(GL_TEXTURE0);
+		glPixelStorei(GL_UNPACK_ALIGNMENT, 4);  // 4-byte pixel alignment
+#ifndef USE_GLES
+		glShadeModel(GL_SMOOTH);
+		glDisable(GL_BLEND);
+		glClearDepth(1.0f);
+		glEnable(GL_SCISSOR_TEST);
+		glDisable(GL_LIGHTING);
+		glMatrixMode(GL_PROJECTION);
+		glLoadIdentity();
+		glMatrixMode(GL_MODELVIEW);
+		glLoadIdentity();
+
+		glClientActiveTexture(GL_TEXTURE0);
+		glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+		glEnable(GL_TEXTURE_RECTANGLE_ARB);
+		glStencilFunc(GL_ALWAYS, 0, 0);
+		glDisable(GL_STENCIL_TEST);
+#endif
+		// used by hw rasterizer if it enables blending and depth test
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+		glDepthFunc(GL_LEQUAL);
+
+		glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+		
+		CreateShaders();
+		GL_REPORT_ERRORD();
+	}
+	static float width, height;
+	void LoadTexture()
+	{
+		FourTexUnits &texUnit = bpmem.tex[0];
+		u32 imageAddr = texUnit.texImage3[0].image_base;
+		// Texture Rectangle uses pixel coordinates
+		// While GLES uses texture coordinates
+#ifdef USE_GLES	
+		width = texUnit.texImage0[0].width;
+		height = texUnit.texImage0[0].height;
+#else
+		width = 1;
+		height = 1;
+#endif
+		TexCacheEntry &cacheEntry = textures[imageAddr];
+		cacheEntry.Update();
+
+		glBindTexture(TEX2D, cacheEntry.texture);
+		glTexParameteri(TEX2D, GL_TEXTURE_MAG_FILTER, texUnit.texMode0[0].mag_filter ? GL_LINEAR : GL_NEAREST);
+		glTexParameteri(TEX2D, GL_TEXTURE_MIN_FILTER, (texUnit.texMode0[0].min_filter >= 4) ? GL_LINEAR : GL_NEAREST);
+		GL_REPORT_ERRORD();
+	}
+
+	void BeginTriangles()
+	{
+		// disabling depth test sometimes allows more things to be visible
+		glEnable(GL_DEPTH_TEST);
+		glEnable(GL_BLEND);
+
+		hasTexture = bpmem.tevorders[0].enable0;
+
+		if (hasTexture)
+			LoadTexture();
+	}
+
+	void EndTriangles()
+	{
+		glBindTexture(TEX2D, 0);
+		glDisable(GL_DEPTH_TEST);
+		glDisable(GL_BLEND);
+	}
+
+	void DrawColorVertex(OutputVertexData *v0, OutputVertexData *v1, OutputVertexData *v2)
+	{
+		float x0 = (v0->screenPosition.x / efbHalfWidth) - 1.0f;
+		float y0 = 1.0f - (v0->screenPosition.y / efbHalfHeight);
+		float z0 = v0->screenPosition.z / (float)0x00ffffff;
+
+		float x1 = (v1->screenPosition.x / efbHalfWidth) - 1.0f;
+		float y1 = 1.0f - (v1->screenPosition.y / efbHalfHeight);
+		float z1 = v1->screenPosition.z / (float)0x00ffffff;
+
+		float x2 = (v2->screenPosition.x / efbHalfWidth) - 1.0f;
+		float y2 = 1.0f - (v2->screenPosition.y / efbHalfHeight);
+		float z2 = v2->screenPosition.z / (float)0x00ffffff;
+
+		float r0 = v0->color[0][OutputVertexData::RED_C] / 255.0f;
+		float g0 = v0->color[0][OutputVertexData::GRN_C] / 255.0f;
+		float b0 = v0->color[0][OutputVertexData::BLU_C] / 255.0f;
+
+		float r1 = v1->color[0][OutputVertexData::RED_C] / 255.0f;
+		float g1 = v1->color[0][OutputVertexData::GRN_C] / 255.0f;
+		float b1 = v1->color[0][OutputVertexData::BLU_C] / 255.0f;
+
+		float r2 = v2->color[0][OutputVertexData::RED_C] / 255.0f;
+		float g2 = v2->color[0][OutputVertexData::GRN_C] / 255.0f;
+		float b2 = v2->color[0][OutputVertexData::BLU_C] / 255.0f;
+
+		static const GLfloat verts[3][3] = {
+			{ x0, y0, z0 },
+			{ x1, y1, z1 },
+			{ x2, y2, z2 }
+		};
+		static const GLfloat col[3][4] = {
+			{ r0, g0, b0, 1.0f },
+			{ r1, g1, b1, 1.0f },
+			{ r2, g2, b2, 1.0f }
+		};
+		{
+			glUseProgram(colProg);
+			glEnableVertexAttribArray(col_apos);
+			glEnableVertexAttribArray(col_atex);
+
+			glVertexAttribPointer(col_apos, 3, GL_FLOAT, GL_FALSE, 0, verts);
+			glVertexAttribPointer(col_atex, 4, GL_FLOAT, GL_FALSE, 0, col);
+				glDrawArrays(GL_TRIANGLES, 0, 3);
+			glDisableVertexAttribArray(col_atex);
+			glDisableVertexAttribArray(col_apos);
+		}
+		GL_REPORT_ERRORD();
+	}
+
+	void DrawTextureVertex(OutputVertexData *v0, OutputVertexData *v1, OutputVertexData *v2)
+	{
+		float x0 = (v0->screenPosition.x / efbHalfWidth) - 1.0f;
+		float y0 = 1.0f - (v0->screenPosition.y / efbHalfHeight);
+		float z0 = v0->screenPosition.z;
+
+		float x1 = (v1->screenPosition.x / efbHalfWidth) - 1.0f;
+		float y1 = 1.0f - (v1->screenPosition.y / efbHalfHeight);
+		float z1 = v1->screenPosition.z;
+
+		float x2 = (v2->screenPosition.x / efbHalfWidth) - 1.0f;
+		float y2 = 1.0f - (v2->screenPosition.y / efbHalfHeight);
+		float z2 = v2->screenPosition.z;
+
+		float s0 = v0->texCoords[0].x / width;
+		float t0 = v0->texCoords[0].y / height;
+
+		float s1 = v1->texCoords[0].x / width;
+		float t1 = v1->texCoords[0].y / height;
+
+		float s2 = v2->texCoords[0].x / width;
+		float t2 = v2->texCoords[0].y / height;
+
+		static const GLfloat verts[3][3] = {
+			{ x0, y0, z0 },
+			{ x1, y1, z1 },
+			{ x2, y2, z2 }
+		};
+		static const GLfloat tex[3][2] = {
+			{ s0, t0 },
+			{ s1, t1 },
+			{ s2, t2 }
+		};
+		{
+			glUseProgram(texProg);
+			glEnableVertexAttribArray(tex_apos);
+			glEnableVertexAttribArray(tex_atex);
+
+			glVertexAttribPointer(tex_apos, 3, GL_FLOAT, GL_FALSE, 0, verts);
+			glVertexAttribPointer(tex_atex, 2, GL_FLOAT, GL_FALSE, 0, tex);
+				glUniform1i(tex_utex, 0);
+				glDrawArrays(GL_TRIANGLES, 0, 3);
+			glDisableVertexAttribArray(tex_atex);
+			glDisableVertexAttribArray(tex_apos);
+		}
+		GL_REPORT_ERRORD();
+	}
+
+	void DrawTriangleFrontFace(OutputVertexData *v0, OutputVertexData *v1, OutputVertexData *v2)
+	{
+		if (hasTexture)
+			DrawTextureVertex(v0, v1, v2);
+		else
+			DrawColorVertex(v0, v1, v2);
+	}
+
+	void Clear()
+	{
+		u8 r = (bpmem.clearcolorAR & 0x00ff);
+		u8 g = (bpmem.clearcolorGB & 0xff00) >> 8;
+		u8 b = (bpmem.clearcolorGB & 0x00ff);
+		u8 a = (bpmem.clearcolorAR & 0xff00) >> 8;
+
+		GLfloat left   = (GLfloat)bpmem.copyTexSrcXY.x / efbHalfWidth - 1.0f;
+		GLfloat top    = 1.0f - (GLfloat)bpmem.copyTexSrcXY.y / efbHalfHeight;
+		GLfloat right  = (GLfloat)(left + bpmem.copyTexSrcWH.x + 1) / efbHalfWidth - 1.0f;
+		GLfloat bottom = 1.0f - (GLfloat)(top + bpmem.copyTexSrcWH.y + 1) / efbHalfHeight;
+		GLfloat depth = (GLfloat)bpmem.clearZValue / (GLfloat)0x00ffffff;
+		static const GLfloat verts[4][3] = {
+			{ left, top, depth },
+			{ right, top, depth },
+			{ right, bottom, depth },
+			{ left, bottom, depth }
+		};
+		{
+			glUseProgram(clearProg);
+			glVertexAttribPointer(clear_apos, 3, GL_FLOAT, GL_FALSE, 0, verts);
+			glUniform4f(clear_ucol, r, g, b, a);	
+			glEnableVertexAttribArray(col_apos);
+				glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+			glDisableVertexAttribArray(col_apos);
+		}
+		GL_REPORT_ERRORD();
+	}
+
+	TexCacheEntry::TexCacheEntry()
+	{
+		Create();
+	}
+
+	void TexCacheEntry::Create()
+	{
+		FourTexUnits &texUnit = bpmem.tex[0];
+
+		texImage0.hex = texUnit.texImage0[0].hex;
+		texImage1.hex = texUnit.texImage1[0].hex;
+		texImage2.hex = texUnit.texImage2[0].hex;
+		texImage3.hex = texUnit.texImage3[0].hex;
+		texTlut.hex = texUnit.texTlut[0].hex;
+
+		int image_width = texImage0.width;
+		int image_height = texImage0.height;
+
+		DebugUtil::GetTextureBGRA(temp, 0, 0, image_width, image_height);
+
+		glGenTextures(1, (GLuint *)&texture);
+		glBindTexture(TEX2D, texture);
+#ifdef USE_GLES
+		glTexImage2D(TEX2D, 0, GL_RGBA, (GLsizei)image_width, (GLsizei)image_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, temp);
+#else
+		glTexImage2D(TEX2D, 0, GL_RGBA8, (GLsizei)image_width, (GLsizei)image_height, 0, GL_BGRA, GL_UNSIGNED_BYTE, temp);
+#endif
+		GL_REPORT_ERRORD();
+	}
+
+	void TexCacheEntry::Destroy()
+	{
+		if (texture == 0)
+			return;
+
+		glDeleteTextures(1, &texture);
+		texture = 0;
+	}
+
+	void TexCacheEntry::Update()
+	{
+		FourTexUnits &texUnit = bpmem.tex[0];
+
+		// extra checks cause textures to be reloaded much more
+		if (texUnit.texImage0[0].hex != texImage0.hex ||
+		//	texUnit.texImage1[0].hex != texImage1.hex ||
+		//	texUnit.texImage2[0].hex != texImage2.hex ||
+			texUnit.texImage3[0].hex != texImage3.hex ||
+			texUnit.texTlut[0].hex   != texTlut.hex)
+		{
+			Destroy();
+			Create();
+		}
+	}
+}
+

Source/Core/VideoBackends/Software/Src/HwRasterizer.h

@@ -0,0 +1,50 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#ifndef _HW_RASTERIZER_H
+#define _HW_RASTERIZER_H
+
+#include <map>
+
+#include "BPMemLoader.h"
+#include "../../OGL/Src/GLUtil.h"
+
+struct OutputVertexData;
+
+namespace HwRasterizer
+{
+	void Init();
+	void Shutdown();
+
+	void Prepare();
+
+	void BeginTriangles();
+	void EndTriangles();
+
+	void DrawTriangleFrontFace(OutputVertexData *v0, OutputVertexData *v1, OutputVertexData *v2);
+
+	void Clear();
+
+	struct TexCacheEntry
+	{
+		TexImage0 texImage0; 
+		TexImage1 texImage1; 
+		TexImage2 texImage2; 
+		TexImage3 texImage3; 
+		TexTLUT texTlut;
+
+		GLuint texture;
+
+		TexCacheEntry();
+
+		void Create();
+		void Destroy();
+		void Update();
+	};
+
+	typedef std::map<u32, TexCacheEntry> TextureCache;
+	static TextureCache textures;
+}
+
+#endif 

Source/Core/VideoBackends/Software/Src/NativeVertexFormat.h

@@ -0,0 +1,97 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#ifndef _NATIVEVERTEXFORMAT_H
+#define _NATIVEVERTEXFORMAT_H
+
+#include "Vec3.h"
+#include "ChunkFile.h"
+
+#ifdef WIN32
+#define LOADERDECL __cdecl
+#else
+#define LOADERDECL
+#endif
+
+typedef void (LOADERDECL *TPipelineFunction)();
+
+struct Vec4
+{
+	float x;
+	float y;
+	float z;
+	float w;
+};
+
+struct InputVertexData
+{
+	u8 posMtx;
+	u8 texMtx[8];
+
+	Vec3 position;
+	Vec3 normal[3];
+	u8 color[2][4];
+	float texCoords[8][2];
+};
+
+struct OutputVertexData
+{
+	// components in color channels
+	enum { RED_C, GRN_C, BLU_C, ALP_C };
+
+	Vec3 mvPosition;
+	Vec4 projectedPosition;
+	Vec3 screenPosition;
+	Vec3 normal[3];
+	u8 color[2][4];
+	Vec3 texCoords[8];
+
+	void Lerp(float t, OutputVertexData *a, OutputVertexData *b)
+	{
+		#define LINTERP(T, OUT, IN) (OUT) + ((IN - OUT) * T)
+
+		#define LINTERP_INT(T, OUT, IN) (OUT) + (((IN - OUT) * T) >> 8)
+
+		mvPosition = LINTERP(t, a->mvPosition, b->mvPosition);
+
+		projectedPosition.x = LINTERP(t, a->projectedPosition.x, b->projectedPosition.x);
+		projectedPosition.y = LINTERP(t, a->projectedPosition.y, b->projectedPosition.y);
+		projectedPosition.z = LINTERP(t, a->projectedPosition.z, b->projectedPosition.z);
+		projectedPosition.w = LINTERP(t, a->projectedPosition.w, b->projectedPosition.w);
+
+		for (int i = 0; i < 3; ++i)
+		{
+			normal[i] = LINTERP(t, a->normal[i], b->normal[i]);
+		}
+
+		u16 t_int = (u16)(t * 256);
+		for (int i = 0; i < 4; ++i)
+		{
+			color[0][i] = LINTERP_INT(t_int, a->color[0][i], b->color[0][i]);
+			color[1][i] = LINTERP_INT(t_int, a->color[1][i], b->color[1][i]);
+		}
+
+		for (int i = 0; i < 8; ++i)
+		{
+			texCoords[i] = LINTERP(t, a->texCoords[i], b->texCoords[i]);
+		}
+
+		#undef LINTERP
+		#undef LINTERP_INT
+	}
+	void DoState(PointerWrap &p)
+	{
+		mvPosition.DoState(p);
+		p.Do(projectedPosition);
+		screenPosition.DoState(p);
+		for (int i = 0; i < 3;++i)
+			normal[i].DoState(p);
+		p.DoArray(color, sizeof color);
+		for (int i = 0; i < 8;++i)
+			texCoords[i].DoState(p);
+	}
+
+};
+
+#endif

Source/Core/VideoBackends/Software/Src/OpcodeDecoder.cpp

@@ -0,0 +1,305 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include "Common.h"
+
+#include "DataReader.h"
+
+#include "OpcodeDecoder.h"
+#include "BPMemLoader.h"
+#include "CPMemLoader.h"
+#include "XFMemLoader.h"
+#include "SWVertexLoader.h"
+#include "SWStatistics.h"
+#include "DebugUtil.h"
+#include "SWCommandProcessor.h"
+#include "CPMemLoader.h"
+#include "SWVideoConfig.h"
+#include "HW/Memmap.h"
+
+typedef void (*DecodingFunction)(u32);
+
+namespace OpcodeDecoder
+{
+static DecodingFunction currentFunction = NULL;
+static u32 minCommandSize;
+static u16 streamSize;
+static u16 streamAddress;
+static bool readOpcode;
+static SWVertexLoader vertexLoader;
+static bool inObjectStream;
+static u8 lastPrimCmd;
+
+
+void DoState(PointerWrap &p)
+{
+	p.Do(minCommandSize);
+	// Not sure what is wrong with this. Something(s) in here is causing dolphin to crash/hang when loading states saved from another run of dolphin. Doesn't seem too important anyway...
+	//vertexLoader.DoState(p);
+	p.Do(readOpcode);
+	p.Do(inObjectStream);
+	p.Do(lastPrimCmd);
+	p.Do(streamSize);
+	p.Do(streamAddress);
+	if (p.GetMode() == PointerWrap::MODE_READ)
+		  ResetDecoding();
+}
+
+void DecodePrimitiveStream(u32 iBufferSize)
+{
+	u32 vertexSize = vertexLoader.GetVertexSize();
+
+	bool skipPrimitives = g_bSkipCurrentFrame ||
+		 swstats.thisFrame.numDrawnObjects < g_SWVideoConfig.drawStart ||
+		 swstats.thisFrame.numDrawnObjects >= g_SWVideoConfig.drawEnd;
+
+	if (skipPrimitives)
+	{
+		while (streamSize > 0 && iBufferSize >= vertexSize)
+		{
+			g_pVideoData += vertexSize;
+			iBufferSize -= vertexSize;
+			streamSize--;
+		}
+	}
+	else
+	{
+		while (streamSize > 0 && iBufferSize >= vertexSize)
+		{
+			vertexLoader.LoadVertex();
+			iBufferSize -= vertexSize;
+			streamSize--;
+		}
+	}
+
+	if (streamSize == 0)
+	{
+		// return to normal command processing
+		ResetDecoding();
+	}
+}
+
+void ReadXFData(u32 iBufferSize)
+{
+	_assert_msg_(VIDEO, iBufferSize >= (u32)(streamSize * 4), "Underflow during standard opcode decoding"); 
+
+	u32 pData[16];
+	for (int i = 0; i < streamSize; i++)
+		pData[i] = DataReadU32();
+	SWLoadXFReg(streamSize, streamAddress, pData);
+
+	// return to normal command processing
+	ResetDecoding();
+}
+
+void ExecuteDisplayList(u32 addr, u32 count)
+{
+	u8 *videoDataSave = g_pVideoData;
+
+	u8 *dlStart = Memory::GetPointer(addr);
+
+	g_pVideoData = dlStart;
+
+	while (OpcodeDecoder::CommandRunnable(count))
+	{
+		OpcodeDecoder::Run(count);
+
+		// if data was read by the opcode decoder then the video data pointer changed
+		u32 readCount = (u32)(g_pVideoData - dlStart);
+		dlStart = g_pVideoData;
+
+		_assert_msg_(VIDEO, count >= readCount, "Display list underrun"); 
+
+		count -= readCount;
+	}
+
+	g_pVideoData = videoDataSave;
+}
+
+void DecodeStandard(u32 bufferSize)
+{
+	_assert_msg_(VIDEO, CommandRunnable(bufferSize), "Underflow during standard opcode decoding"); 
+
+	int Cmd = DataReadU8();
+
+	if (Cmd == GX_NOP)
+		return;
+	// Causes a SIGBUS error on Android
+	// XXX: Investigate
+#ifndef ANDROID
+	// check if switching in or out of an object
+	// only used for debugging
+	if (inObjectStream && (Cmd & 0x87) != lastPrimCmd)
+	{
+		inObjectStream = false;
+		DebugUtil::OnObjectEnd();
+	}
+	if (Cmd & 0x80 && !inObjectStream)
+	{
+		inObjectStream = true;
+		lastPrimCmd = Cmd & 0x87;
+		DebugUtil::OnObjectBegin();
+	}
+#endif
+	switch(Cmd)
+	{
+	case GX_NOP:
+		break;
+
+	case GX_LOAD_CP_REG: //0x08
+		{
+			u32 SubCmd = DataReadU8();
+			u32 Value = DataReadU32();
+			SWLoadCPReg(SubCmd, Value);
+		}
+		break;
+
+	case GX_LOAD_XF_REG:
+		{
+			u32 Cmd2 = DataReadU32();
+			streamSize = ((Cmd2 >> 16) & 15) + 1;
+			streamAddress = Cmd2 & 0xFFFF;
+			currentFunction = ReadXFData;
+			minCommandSize = streamSize * 4;
+			readOpcode = false;
+		}
+		break;
+
+	case GX_LOAD_INDX_A: //used for position matrices
+		SWLoadIndexedXF(DataReadU32(), 0xC);
+		break;
+	case GX_LOAD_INDX_B: //used for normal matrices
+		SWLoadIndexedXF(DataReadU32(), 0xD);
+		break;
+	case GX_LOAD_INDX_C: //used for postmatrices
+		SWLoadIndexedXF(DataReadU32(), 0xE);
+		break;
+	case GX_LOAD_INDX_D: //used for lights
+		SWLoadIndexedXF(DataReadU32(), 0xF);
+		break;
+
+	case GX_CMD_CALL_DL:
+		{
+			u32 dwAddr  = DataReadU32();
+			u32 dwCount = DataReadU32();
+			ExecuteDisplayList(dwAddr, dwCount);
+		}
+		break;
+
+	case 0x44:
+		// zelda 4 swords calls it and checks the metrics registers after that
+		break;
+
+	case GX_CMD_INVL_VC:// Invalidate	(vertex cache?)	
+		DEBUG_LOG(VIDEO, "Invalidate	(vertex cache?)");
+		break;
+
+	case GX_LOAD_BP_REG: //0x61
+		{
+			u32 cmd = DataReadU32();
+			SWLoadBPReg(cmd);
+		}
+		break;
+
+	// draw primitives 
+	default:
+		if (Cmd & 0x80)
+		{
+			u8 vatIndex = Cmd & GX_VAT_MASK;
+			u8 primitiveType = (Cmd & GX_PRIMITIVE_MASK) >> GX_PRIMITIVE_SHIFT;
+			vertexLoader.SetFormat(vatIndex, primitiveType);
+
+			// switch to primitive processing
+			streamSize = DataReadU16();
+			currentFunction = DecodePrimitiveStream;
+			minCommandSize = vertexLoader.GetVertexSize();
+			readOpcode = false;
+
+			INCSTAT(swstats.thisFrame.numPrimatives);
+			DEBUG_LOG(VIDEO, "Draw begin");
+		}
+		else
+		{
+			PanicAlert("GFX: Unknown Opcode (0x%x).\n", Cmd);
+			break;
+		}
+		break;
+	}
+}
+
+
+void Init()
+{
+	inObjectStream = false;
+	lastPrimCmd = 0;
+	ResetDecoding();
+}
+
+void ResetDecoding()
+{
+	currentFunction = DecodeStandard;
+	minCommandSize = 1;
+	readOpcode = true;
+}
+
+bool CommandRunnable(u32 iBufferSize)
+{
+	if (iBufferSize < minCommandSize)
+		return false;
+
+	if (readOpcode)
+	{
+		u8 Cmd = DataPeek8(0);
+		u32 minSize = 1;
+
+		switch(Cmd)
+		{
+		case GX_LOAD_CP_REG: //0x08
+			minSize = 6;
+			break;
+
+		case GX_LOAD_XF_REG:
+			minSize = 5;
+			break;
+
+		case GX_LOAD_INDX_A: //used for position matrices
+			minSize = 5;
+			break;
+		case GX_LOAD_INDX_B: //used for normal matrices
+			minSize = 5;
+			break;
+		case GX_LOAD_INDX_C: //used for postmatrices
+			minSize = 5;
+			break;
+		case GX_LOAD_INDX_D: //used for lights
+			minSize = 5;
+			break;
+
+		case GX_CMD_CALL_DL:
+			minSize = 9;
+			break;
+
+		case GX_LOAD_BP_REG: //0x61
+			minSize = 5;
+			break;
+
+		// draw primitives 
+		default:
+			if (Cmd & 0x80)
+				minSize = 3;
+			break;
+		}
+
+		return (iBufferSize >= minSize);
+	}
+
+	return true;
+}
+
+void Run(u32 iBufferSize)
+{
+	currentFunction(iBufferSize);
+}
+
+}

Source/Core/VideoBackends/Software/Src/OpcodeDecoder.h

@@ -0,0 +1,51 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#ifndef _OPCODEDECODER_H_
+#define _OPCODEDECODER_H_
+
+#include "CommonTypes.h"
+#include "ChunkFile.h"
+
+namespace OpcodeDecoder
+{
+
+	#define GX_NOP                      0x00
+
+	#define GX_LOAD_BP_REG              0x61
+	#define GX_LOAD_CP_REG              0x08
+	#define GX_LOAD_XF_REG              0x10
+	#define GX_LOAD_INDX_A              0x20
+	#define GX_LOAD_INDX_B              0x28
+	#define GX_LOAD_INDX_C              0x30
+	#define GX_LOAD_INDX_D              0x38
+
+	#define GX_CMD_CALL_DL              0x40
+	#define GX_CMD_INVL_VC              0x48
+
+	#define GX_PRIMITIVE_MASK           0x78
+	#define GX_PRIMITIVE_SHIFT          3
+	#define GX_VAT_MASK                 0x07
+
+	//these are defined 1/8th of their real values and without their top bit
+	#define GX_DRAW_QUADS               0x0   //0x80
+	#define GX_DRAW_TRIANGLES           0x2   //0x90
+	#define GX_DRAW_TRIANGLE_STRIP      0x3   //0x98
+	#define GX_DRAW_TRIANGLE_FAN        0x4   //0xA0
+	#define GX_DRAW_LINES               0x5   //0xA8
+	#define GX_DRAW_LINE_STRIP          0x6   //0xB0
+	#define GX_DRAW_POINTS              0x7   //0xB8
+
+	void Init();
+
+	void ResetDecoding();
+
+	bool CommandRunnable(u32 iBufferSize);
+
+	void Run(u32 iBufferSize);
+
+	void DoState(PointerWrap &p);
+}
+
+#endif