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

Use brute force to link the software plugin. 

Not yet functional.


git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@7050 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
Soren Jorvang 2011-02-03 19:55:30 +00:00
parent 439baff4cc
commit 1619e176ff
50 changed files with 308 additions and 607 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
SConstruct
View File

@ -124,12 +124,15 @@ if sys.platform == 'darwin':
env['CCFLAGS'] += ['-Xarch_i386', '-msse3', '-Xarch_x86_64', '-mssse3'] env['CCFLAGS'] += ['-Xarch_i386', '-msse3', '-Xarch_x86_64', '-mssse3']
env['CC'] = '/Developer/usr/bin/llvm-gcc' env['CC'] = '/Developer/usr/bin/llvm-gcc'
env['CXX'] = '/Developer/usr/bin/llvm-g++' env['CXX'] = '/Developer/usr/bin/llvm-g++'
#env['CC'] = 'clang'
#env['CXX'] = 'clang++'
env['CXXFLAGS'] += ['-x', 'objective-c++'] env['CXXFLAGS'] += ['-x', 'objective-c++']
env['FRAMEWORKS'] += ['AppKit', 'Carbon', 'CoreFoundation', 'CoreServices'] env['FRAMEWORKS'] += ['AppKit', 'Carbon', 'CoreFoundation', 'CoreServices']
env['FRAMEWORKS'] += ['AudioToolbox', 'AudioUnit', 'CoreAudio', 'WebKit'] env['FRAMEWORKS'] += ['AudioToolbox', 'AudioUnit', 'CoreAudio', 'WebKit']
env['FRAMEWORKS'] += ['IOBluetooth', 'IOKit', 'OpenGL'] env['FRAMEWORKS'] += ['IOBluetooth', 'IOKit', 'OpenGL']
env['LIBPATH'] += ['/usr/lib'] # XXX clang
env['LINKFLAGS'] += ccld env['LINKFLAGS'] += ccld
env['LINKFLAGS'] += ['-Wl,-dead_strip'] env['LINKFLAGS'] += ['-Wl,-dead_strip', '-Wl,-dead_strip_dylibs']
env['LINKFLAGS'] += ['-Wl,-pagezero_size,0x1000'] env['LINKFLAGS'] += ['-Wl,-pagezero_size,0x1000']
env['LINKFLAGS'] += ['-Wl,-search_paths_first'] env['LINKFLAGS'] += ['-Wl,-search_paths_first']
@ -149,7 +152,6 @@ if sys.platform == 'darwin':
wxconfig.ParseWXConfig(wxenv) wxconfig.ParseWXConfig(wxenv)
env['CPPDEFINES'] += ['__WXOSX_COCOA__'] env['CPPDEFINES'] += ['__WXOSX_COCOA__']
env['CPPPATH'] += wxenv['CPPPATH'] env['CPPPATH'] += wxenv['CPPPATH']
#env['LIBPATH'] += wxenv['LIBPATH']
env['wxconfiglibs'] = wxenv['LIBS'] env['wxconfiglibs'] = wxenv['LIBS']
env['CPPPATH'] += ['#Externals'] env['CPPPATH'] += ['#Externals']

8
Source/Core/Common/Src/VideoBackendBase.cpp
View File

@ -23,7 +23,9 @@
#include "../../../Plugins/Plugin_VideoDX11/Src/VideoBackend.h" #include "../../../Plugins/Plugin_VideoDX11/Src/VideoBackend.h"
#endif #endif
#include "../../../Plugins/Plugin_VideoOGL/Src/VideoBackend.h" #include "../../../Plugins/Plugin_VideoOGL/Src/VideoBackend.h"
//#include "../Plugins/Plugin_VideoSoftware/Src/VideoBackend.h" #ifndef _WIN32 // XXX
#include "../../../Plugins/Plugin_VideoSoftware/Src/VideoBackend.h"
#endif
std::vector<VideoBackend*> g_available_video_backends; std::vector<VideoBackend*> g_available_video_backends;
VideoBackend* g_video_backend = NULL; VideoBackend* g_video_backend = NULL;
@ -36,7 +38,9 @@ void VideoBackend::PopulateList()
g_available_video_backends.push_back(new DX11::VideoBackend); g_available_video_backends.push_back(new DX11::VideoBackend);
#endif #endif
g_available_video_backends.push_back(new OGL::VideoBackend); g_available_video_backends.push_back(new OGL::VideoBackend);
//g_available_video_backends.push_back(new SW::VideoBackend); #ifndef _WIN32 // XXX
g_available_video_backends.push_back(new SW::VideoBackend);
#endif
g_video_backend = g_available_video_backends.front(); g_video_backend = g_available_video_backends.front();
} }

2
Source/Core/Core/CMakeLists.txt
View File

@ -182,7 +182,7 @@ set(SRCS Src/ActionReplay.cpp
Src/PowerPC/JitCommon/JitCache.cpp Src/PowerPC/JitCommon/JitCache.cpp
Src/PowerPC/JitCommon/Jit_Util.cpp) Src/PowerPC/JitCommon/Jit_Util.cpp)
set(LIBS bdisasm inputcommon videoogl lua sfml-network) set(LIBS bdisasm inputcommon videoogl videosoftware lua sfml-network)
if(WIN32) if(WIN32)
set(SRCS ${SRCS} Src/HW/BBA-TAP/TAP_Win32.cpp Src/stdafx.cpp set(SRCS ${SRCS} Src/HW/BBA-TAP/TAP_Win32.cpp Src/stdafx.cpp

7
Source/Core/DolphinWX/Src/SConscript
View File

@ -31,6 +31,7 @@ else:
'ISOFile.cpp', 'ISOFile.cpp',
'ISOProperties.cpp', 'ISOProperties.cpp',
'PatchAddEdit.cpp', 'PatchAddEdit.cpp',
'PHackSettings.cpp',
'CheatsWindow.cpp', 'CheatsWindow.cpp',
'MemcardManager.cpp', 'MemcardManager.cpp',
'MemoryCards/GCMemcard.cpp', 'MemoryCards/GCMemcard.cpp',
@ -49,7 +50,7 @@ else:
libs += ['debwx', 'debugger_ui_util', 'dolphinwx'] libs += ['debwx', 'debugger_ui_util', 'dolphinwx']
libs += ['core', 'common', 'discio', 'plugin_videoogl'] # 'plugin_videosoftware' libs += ['core', 'common', 'discio', 'plugin_videoogl', 'plugin_videosoftware']
if env['HAVE_WX']: if env['HAVE_WX']:
libs += ['videouicommon'] libs += ['videouicommon']
libs += ['audiocommon', 'inputcommon', 'videocommon'] libs += ['audiocommon', 'inputcommon', 'videocommon']
@ -58,8 +59,8 @@ libs += ['GLEW', 'SOIL', 'bdisasm', 'lua', 'lzo2', 'sfml-network', 'z']
if sys.platform == 'win32': if sys.platform == 'win32':
files += [ "stdafx.cpp" ] files += [ "stdafx.cpp" ]
elif sys.platform == 'darwin': elif sys.platform == 'darwin':
ldflags += [ '-Xarch_i386', '-Wl,-framework,QuickTime' ] ldflags += ['-Wl,-framework,QuickTime', '-Wl,-no_arch_warnings']
ldflags += [ '-weak_framework', 'OpenCL' ] ldflags += ['-weak_framework', 'OpenCL']
exe = '#' + env['prefix'] + '/Dolphin.app/Contents/MacOS/Dolphin' exe = '#' + env['prefix'] + '/Dolphin.app/Contents/MacOS/Dolphin'

2
Source/DSPTool/DSPTool.vcproj
View File

@ -510,7 +510,7 @@
</File> </File>
</Filter> </Filter>
<File <File
RelativePath=".\Src\main.cpp" RelativePath=".\Src\DSPTool.cpp"
> >
</File> </File>
<File <File

0
Source/DSPTool/Src/main.cpp → Source/DSPTool/Src/DSPTool.cpp
View File

2
Source/DSPTool/Src/SConscript
View File

@ -4,7 +4,7 @@ Import('env')
import sys import sys
files = [ files = [
'main.cpp', 'DSPTool.cpp',
] ]
libs = [ libs = [

15
Source/Plugins/Plugin_VideoSoftware/CMakeLists.txt
View File

@ -1,25 +1,24 @@
set(SRCS Src/BPMemLoader.cpp set(SRCS Src/BPMemLoader.cpp
Src/Clipper.cpp Src/Clipper.cpp
Src/CommandProcessor.cpp Src/SWCommandProcessor.cpp
Src/CPMemLoader.cpp Src/CPMemLoader.cpp
Src/DebugUtil.cpp Src/DebugUtil.cpp
Src/EfbCopy.cpp Src/EfbCopy.cpp
Src/EfbInterface.cpp Src/EfbInterface.cpp
Src/GLUtil.cpp Src/SWGLUtil.cpp
Src/HwRasterizer.cpp Src/HwRasterizer.cpp
Src/main.cpp Src/SWmain.cpp
Src/OpcodeDecoder.cpp Src/OpcodeDecoder.cpp
Src/PixelEngine.cpp Src/SWPixelEngine.cpp
Src/Rasterizer.cpp Src/Rasterizer.cpp
Src/RasterFont.cpp Src/SWRenderer.cpp
Src/Renderer.cpp
Src/SetupUnit.cpp Src/SetupUnit.cpp
Src/Statistics.cpp Src/SWStatistics.cpp
Src/Tev.cpp Src/Tev.cpp
Src/TextureEncoder.cpp Src/TextureEncoder.cpp
Src/TextureSampler.cpp Src/TextureSampler.cpp
Src/TransformUnit.cpp Src/TransformUnit.cpp
Src/VertexLoader.cpp Src/SWVertexLoader.cpp
Src/SWVideoConfig.cpp Src/SWVideoConfig.cpp
Src/XFMemLoader.cpp) Src/XFMemLoader.cpp)

32
Source/Plugins/Plugin_VideoSoftware/Plugin_VideoSoftware.vcproj
View File

@ -307,14 +307,6 @@
RelativePath="..\..\Core\VideoCommon\Src\OpenCL\OCLTextureDecoder.cpp" RelativePath="..\..\Core\VideoCommon\Src\OpenCL\OCLTextureDecoder.cpp"
> >
</File> </File>
<File
RelativePath=".\Src\RasterFont.cpp"
>
</File>
<File
RelativePath=".\Src\RasterFont.h"
>
</File>
<File <File
RelativePath="..\..\Core\VideoCommon\Src\TextureDecoder.cpp" RelativePath="..\..\Core\VideoCommon\Src\TextureDecoder.cpp"
> >
@ -369,11 +361,11 @@
> >
</File> </File>
<File <File
RelativePath=".\Src\CommandProcessor.cpp" RelativePath=".\Src\SWCommandProcessor.cpp"
> >
</File> </File>
<File <File
RelativePath=".\Src\CommandProcessor.h" RelativePath=".\Src\SWCommandProcessor.h"
> >
</File> </File>
<File <File
@ -409,11 +401,11 @@
> >
</File> </File>
<File <File
RelativePath=".\Src\GLUtil.cpp" RelativePath=".\Src\SWGLUtil.cpp"
> >
</File> </File>
<File <File
RelativePath=".\Src\GLUtil.h" RelativePath=".\Src\SWGLUtil.h"
> >
</File> </File>
<File <File
@ -445,11 +437,11 @@
> >
</File> </File>
<File <File
RelativePath=".\Src\PixelEngine.cpp" RelativePath=".\Src\SWPixelEngine.cpp"
> >
</File> </File>
<File <File
RelativePath=".\Src\PixelEngine.h" RelativePath=".\Src\SWPixelEngine.h"
> >
</File> </File>
<File <File
@ -461,11 +453,11 @@
> >
</File> </File>
<File <File
RelativePath=".\Src\Renderer.cpp" RelativePath=".\Src\SWRenderer.cpp"
> >
</File> </File>
<File <File
RelativePath=".\Src\Renderer.h" RelativePath=".\Src\SWRenderer.h"
> >
</File> </File>
<File <File
@ -477,11 +469,11 @@
> >
</File> </File>
<File <File
RelativePath=".\Src\Statistics.cpp" RelativePath=".\Src\SWStatistics.cpp"
> >
</File> </File>
<File <File
RelativePath=".\Src\Statistics.h" RelativePath=".\Src\SWStatistics.h"
> >
</File> </File>
<File <File
@ -569,11 +561,11 @@
> >
</File> </File>
<File <File
RelativePath=".\Src\VertexLoader.cpp" RelativePath=".\Src\SWVertexLoader.cpp"
> >
</File> </File>
<File <File
RelativePath=".\Src\VertexLoader.h" RelativePath=".\Src\SWVertexLoader.h"
> >
</File> </File>
<File <File

27
Source/Plugins/Plugin_VideoSoftware/Plugin_VideoSoftware.vcxproj
View File

@ -169,21 +169,21 @@
<ItemGroup> <ItemGroup>
<ClCompile Include="Src\BPMemLoader.cpp" /> <ClCompile Include="Src\BPMemLoader.cpp" />
<ClCompile Include="Src\Clipper.cpp" /> <ClCompile Include="Src\Clipper.cpp" />
<ClCompile Include="Src\CommandProcessor.cpp" /> <ClCompile Include="Src\SWCommandProcessor.cpp" />
<ClCompile Include="Src\CPMemLoader.cpp" /> <ClCompile Include="Src\CPMemLoader.cpp" />
<ClCompile Include="Src\DebugUtil.cpp" /> <ClCompile Include="Src\DebugUtil.cpp" />
<ClCompile Include="Src\EfbCopy.cpp" /> <ClCompile Include="Src\EfbCopy.cpp" />
<ClCompile Include="Src\EfbInterface.cpp" /> <ClCompile Include="Src\EfbInterface.cpp" />
<ClCompile Include="Src\GLUtil.cpp" /> <ClCompile Include="Src\SWGLUtil.cpp" />
<ClCompile Include="Src\HwRasterizer.cpp" /> <ClCompile Include="Src\HwRasterizer.cpp" />
<ClCompile Include="Src\main.cpp" /> <ClCompile Include="Src\SWmain.cpp" />
<ClCompile Include="Src\OpcodeDecoder.cpp" /> <ClCompile Include="Src\OpcodeDecoder.cpp" />
<ClCompile Include="Src\PixelEngine.cpp" /> <ClCompile Include="Src\SWPixelEngine.cpp" />
<ClCompile Include="Src\RasterFont.cpp" /> <ClCompile Include="Src\RasterFont.cpp" />
<ClCompile Include="Src\Rasterizer.cpp" /> <ClCompile Include="Src\Rasterizer.cpp" />
<ClCompile Include="Src\Renderer.cpp" /> <ClCompile Include="Src\SWRenderer.cpp" />
<ClCompile Include="Src\SetupUnit.cpp" /> <ClCompile Include="Src\SetupUnit.cpp" />
<ClCompile Include="Src\Statistics.cpp" /> <ClCompile Include="Src\SWStatistics.cpp" />
<ClCompile Include="Src\stdafx.cpp"> <ClCompile Include="Src\stdafx.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader> <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader> <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
@ -195,7 +195,7 @@
<ClCompile Include="Src\TextureEncoder.cpp" /> <ClCompile Include="Src\TextureEncoder.cpp" />
<ClCompile Include="Src\TextureSampler.cpp" /> <ClCompile Include="Src\TextureSampler.cpp" />
<ClCompile Include="Src\TransformUnit.cpp" /> <ClCompile Include="Src\TransformUnit.cpp" />
<ClCompile Include="Src\VertexLoader.cpp" /> <ClCompile Include="Src\SWVertexLoader.cpp" />
<ClCompile Include="Src\VideoConfigDialog.cpp" /> <ClCompile Include="Src\VideoConfigDialog.cpp" />
<ClCompile Include="Src\Win32.cpp" /> <ClCompile Include="Src\Win32.cpp" />
<ClCompile Include="Src\XFMemLoader.cpp" /> <ClCompile Include="Src\XFMemLoader.cpp" />
@ -203,22 +203,21 @@
<ItemGroup> <ItemGroup>
<ClInclude Include="Src\BPMemLoader.h" /> <ClInclude Include="Src\BPMemLoader.h" />
<ClInclude Include="Src\Clipper.h" /> <ClInclude Include="Src\Clipper.h" />
<ClInclude Include="Src\CommandProcessor.h" /> <ClInclude Include="Src\SWCommandProcessor.h" />
<ClInclude Include="Src\CPMemLoader.h" /> <ClInclude Include="Src\CPMemLoader.h" />
<ClInclude Include="Src\DebugUtil.h" /> <ClInclude Include="Src\DebugUtil.h" />
<ClInclude Include="Src\EfbCopy.h" /> <ClInclude Include="Src\EfbCopy.h" />
<ClInclude Include="Src\EfbInterface.h" /> <ClInclude Include="Src\EfbInterface.h" />
<ClInclude Include="Src\GLUtil.h" /> <ClInclude Include="Src\SWGLUtil.h" />
<ClInclude Include="Src\HwRasterizer.h" /> <ClInclude Include="Src\HwRasterizer.h" />
<ClInclude Include="Src\main.h" />
<ClInclude Include="Src\NativeVertexFormat.h" /> <ClInclude Include="Src\NativeVertexFormat.h" />
<ClInclude Include="Src\OpcodeDecoder.h" /> <ClInclude Include="Src\OpcodeDecoder.h" />
<ClInclude Include="Src\PixelEngine.h" /> <ClInclude Include="Src\SWPixelEngine.h" />
<ClInclude Include="Src\RasterFont.h" /> <ClInclude Include="Src\RasterFont.h" />
<ClInclude Include="Src\Rasterizer.h" /> <ClInclude Include="Src\Rasterizer.h" />
<ClInclude Include="Src\Renderer.h" /> <ClInclude Include="Src\SWRenderer.h" />
<ClInclude Include="Src\SetupUnit.h" /> <ClInclude Include="Src\SetupUnit.h" />
<ClInclude Include="Src\Statistics.h" /> <ClInclude Include="Src\SWStatistics.h" />
<ClInclude Include="Src\stdafx.h" /> <ClInclude Include="Src\stdafx.h" />
<ClInclude Include="Src\SWVideoConfig.h" /> <ClInclude Include="Src\SWVideoConfig.h" />
<ClInclude Include="Src\Tev.h" /> <ClInclude Include="Src\Tev.h" />
@ -226,7 +225,7 @@
<ClInclude Include="Src\TextureSampler.h" /> <ClInclude Include="Src\TextureSampler.h" />
<ClInclude Include="Src\TransformUnit.h" /> <ClInclude Include="Src\TransformUnit.h" />
<ClInclude Include="Src\Vec3.h" /> <ClInclude Include="Src\Vec3.h" />
<ClInclude Include="Src\VertexLoader.h" /> <ClInclude Include="Src\SWVertexLoader.h" />
<ClInclude Include="Src\VertexLoader_Position.h" /> <ClInclude Include="Src\VertexLoader_Position.h" />
<ClInclude Include="Src\VideoBackend.h" /> <ClInclude Include="Src\VideoBackend.h" />
<ClInclude Include="Src\VideoConfigDialog.h" /> <ClInclude Include="Src\VideoConfigDialog.h" />

33
Source/Plugins/Plugin_VideoSoftware/Plugin_VideoSoftware.vcxproj.filters
View File

@ -3,54 +3,50 @@
<ItemGroup> <ItemGroup>
<ClCompile Include="Src\BPMemLoader.cpp" /> <ClCompile Include="Src\BPMemLoader.cpp" />
<ClCompile Include="Src\Clipper.cpp" /> <ClCompile Include="Src\Clipper.cpp" />
<ClCompile Include="Src\CommandProcessor.cpp" /> <ClCompile Include="Src\SWCommandProcessor.cpp" />
<ClCompile Include="Src\CPMemLoader.cpp" /> <ClCompile Include="Src\CPMemLoader.cpp" />
<ClCompile Include="Src\DebugUtil.cpp" /> <ClCompile Include="Src\DebugUtil.cpp" />
<ClCompile Include="Src\EfbCopy.cpp" /> <ClCompile Include="Src\EfbCopy.cpp" />
<ClCompile Include="Src\EfbInterface.cpp" /> <ClCompile Include="Src\EfbInterface.cpp" />
<ClCompile Include="Src\GLUtil.cpp" /> <ClCompile Include="Src\SWGLUtil.cpp" />
<ClCompile Include="Src\HwRasterizer.cpp" /> <ClCompile Include="Src\HwRasterizer.cpp" />
<ClCompile Include="Src\main.cpp" /> <ClCompile Include="Src\SWmain.cpp" />
<ClCompile Include="Src\OpcodeDecoder.cpp" /> <ClCompile Include="Src\OpcodeDecoder.cpp" />
<ClCompile Include="Src\PixelEngine.cpp" /> <ClCompile Include="Src\SWPixelEngine.cpp" />
<ClCompile Include="Src\Rasterizer.cpp" /> <ClCompile Include="Src\Rasterizer.cpp" />
<ClCompile Include="Src\Renderer.cpp" /> <ClCompile Include="Src\SWRenderer.cpp" />
<ClCompile Include="Src\SetupUnit.cpp" /> <ClCompile Include="Src\SetupUnit.cpp" />
<ClCompile Include="Src\Statistics.cpp" /> <ClCompile Include="Src\SWStatistics.cpp" />
<ClCompile Include="Src\stdafx.cpp" /> <ClCompile Include="Src\stdafx.cpp" />
<ClCompile Include="Src\SWVideoConfig.cpp" /> <ClCompile Include="Src\SWVideoConfig.cpp" />
<ClCompile Include="Src\Tev.cpp" /> <ClCompile Include="Src\Tev.cpp" />
<ClCompile Include="Src\TextureEncoder.cpp" /> <ClCompile Include="Src\TextureEncoder.cpp" />
<ClCompile Include="Src\TextureSampler.cpp" /> <ClCompile Include="Src\TextureSampler.cpp" />
<ClCompile Include="Src\TransformUnit.cpp" /> <ClCompile Include="Src\TransformUnit.cpp" />
<ClCompile Include="Src\VertexLoader.cpp" /> <ClCompile Include="Src\SWVertexLoader.cpp" />
<ClCompile Include="Src\VideoConfigDialog.cpp" /> <ClCompile Include="Src\VideoConfigDialog.cpp" />
<ClCompile Include="Src\XFMemLoader.cpp" /> <ClCompile Include="Src\XFMemLoader.cpp" />
<ClCompile Include="Src\Win32.cpp"> <ClCompile Include="Src\Win32.cpp">
<Filter>Win32</Filter> <Filter>Win32</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="Src\RasterFont.cpp">
<Filter>Common</Filter>
</ClCompile>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="Src\BPMemLoader.h" /> <ClInclude Include="Src\BPMemLoader.h" />
<ClInclude Include="Src\Clipper.h" /> <ClInclude Include="Src\Clipper.h" />
<ClInclude Include="Src\CommandProcessor.h" /> <ClInclude Include="Src\SWCommandProcessor.h" />
<ClInclude Include="Src\CPMemLoader.h" /> <ClInclude Include="Src\CPMemLoader.h" />
<ClInclude Include="Src\DebugUtil.h" /> <ClInclude Include="Src\DebugUtil.h" />
<ClInclude Include="Src\EfbCopy.h" /> <ClInclude Include="Src\EfbCopy.h" />
<ClInclude Include="Src\EfbInterface.h" /> <ClInclude Include="Src\EfbInterface.h" />
<ClInclude Include="Src\GLUtil.h" /> <ClInclude Include="Src\SWGLUtil.h" />
<ClInclude Include="Src\HwRasterizer.h" /> <ClInclude Include="Src\HwRasterizer.h" />
<ClInclude Include="Src\main.h" />
<ClInclude Include="Src\NativeVertexFormat.h" /> <ClInclude Include="Src\NativeVertexFormat.h" />
<ClInclude Include="Src\OpcodeDecoder.h" /> <ClInclude Include="Src\OpcodeDecoder.h" />
<ClInclude Include="Src\PixelEngine.h" /> <ClInclude Include="Src\SWPixelEngine.h" />
<ClInclude Include="Src\Rasterizer.h" /> <ClInclude Include="Src\Rasterizer.h" />
<ClInclude Include="Src\Renderer.h" /> <ClInclude Include="Src\SWRenderer.h" />
<ClInclude Include="Src\SetupUnit.h" /> <ClInclude Include="Src\SetupUnit.h" />
<ClInclude Include="Src\Statistics.h" /> <ClInclude Include="Src\SWStatistics.h" />
<ClInclude Include="Src\stdafx.h" /> <ClInclude Include="Src\stdafx.h" />
<ClInclude Include="Src\SWVideoConfig.h" /> <ClInclude Include="Src\SWVideoConfig.h" />
<ClInclude Include="Src\Tev.h" /> <ClInclude Include="Src\Tev.h" />
@ -58,16 +54,13 @@
<ClInclude Include="Src\TextureSampler.h" /> <ClInclude Include="Src\TextureSampler.h" />
<ClInclude Include="Src\TransformUnit.h" /> <ClInclude Include="Src\TransformUnit.h" />
<ClInclude Include="Src\Vec3.h" /> <ClInclude Include="Src\Vec3.h" />
<ClInclude Include="Src\VertexLoader.h" /> <ClInclude Include="Src\SWVertexLoader.h" />
<ClInclude Include="Src\VideoBackend.h" /> <ClInclude Include="Src\VideoBackend.h" />
<ClInclude Include="Src\VideoConfigDialog.h" /> <ClInclude Include="Src\VideoConfigDialog.h" />
<ClInclude Include="Src\XFMemLoader.h" /> <ClInclude Include="Src\XFMemLoader.h" />
<ClInclude Include="Src\Win32.h"> <ClInclude Include="Src\Win32.h">
<Filter>Win32</Filter> <Filter>Win32</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="Src\RasterFont.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Src\VertexLoader_Position.h"> <ClInclude Include="Src\VertexLoader_Position.h">
<Filter>Common</Filter> <Filter>Common</Filter>
</ClInclude> </ClInclude>

25
Source/Plugins/Plugin_VideoSoftware/Src/BPMemLoader.cpp
View File

@ -16,12 +16,11 @@
// http://code.google.com/p/dolphin-emu/ // http://code.google.com/p/dolphin-emu/
#include "../../../Core/VideoCommon/Src/VideoCommon.h" #include "../../../Core/VideoCommon/Src/VideoCommon.h"
#include "main.h"
#include "BPMemLoader.h" #include "BPMemLoader.h"
#include "EfbCopy.h" #include "EfbCopy.h"
#include "Rasterizer.h" #include "Rasterizer.h"
#include "PixelEngine.h" #include "SWPixelEngine.h"
#include "Tev.h" #include "Tev.h"
#include "../../../Core/VideoCommon/Src/TextureDecoder.h" #include "../../../Core/VideoCommon/Src/TextureDecoder.h"
#include "HW/Memmap.h" #include "HW/Memmap.h"
@ -35,9 +34,7 @@ void InitBPMemory()
bpmem.bpMask = 0xFFFFFF; bpmem.bpMask = 0xFFFFFF;
} }
void BPWritten(int address, int newvalue); void SWLoadBPReg(u32 value)
void LoadBPReg(u32 value)
{ {
//handle the mask register //handle the mask register
int address = value >> 24; int address = value >> 24;
@ -50,10 +47,10 @@ void LoadBPReg(u32 value)
if (address != 0xFE) if (address != 0xFE)
bpmem.bpMask = 0xFFFFFF; bpmem.bpMask = 0xFFFFFF;
BPWritten(address, newval); SWBPWritten(address, newval);
} }
void BPWritten(int address, int newvalue) void SWBPWritten(int address, int newvalue)
{ {
switch (address) switch (address)
{ {
@ -66,7 +63,7 @@ void BPWritten(int address, int newvalue)
switch (bpmem.drawdone & 0xFF) switch (bpmem.drawdone & 0xFF)
{ {
case 0x02: case 0x02:
PixelEngine::SetFinish(); // may generate interrupt SWPixelEngine::SetFinish(); // may generate interrupt
DEBUG_LOG(VIDEO, "GXSetDrawDone SetPEFinish (value: 0x%02X)", (bpmem.drawdone & 0xFFFF)); DEBUG_LOG(VIDEO, "GXSetDrawDone SetPEFinish (value: 0x%02X)", (bpmem.drawdone & 0xFFFF));
break; break;
@ -77,22 +74,22 @@ void BPWritten(int address, int newvalue)
break; break;
case BPMEM_PE_TOKEN_ID: // Pixel Engine Token ID case BPMEM_PE_TOKEN_ID: // Pixel Engine Token ID
DEBUG_LOG(VIDEO, "SetPEToken 0x%04x", (bpmem.petoken & 0xFFFF)); DEBUG_LOG(VIDEO, "SetPEToken 0x%04x", (bpmem.petoken & 0xFFFF));
PixelEngine::SetToken(static_cast<u16>(bpmem.petokenint & 0xFFFF), false); SWPixelEngine::SetToken(static_cast<u16>(bpmem.petokenint & 0xFFFF), false);
break; break;
case BPMEM_PE_TOKEN_INT_ID: // Pixel Engine Interrupt Token ID case BPMEM_PE_TOKEN_INT_ID: // Pixel Engine Interrupt Token ID
DEBUG_LOG(VIDEO, "SetPEToken + INT 0x%04x", (bpmem.petokenint & 0xFFFF)); DEBUG_LOG(VIDEO, "SetPEToken + INT 0x%04x", (bpmem.petokenint & 0xFFFF));
PixelEngine::SetToken(static_cast<u16>(bpmem.petokenint & 0xFFFF), true); SWPixelEngine::SetToken(static_cast<u16>(bpmem.petokenint & 0xFFFF), true);
break; break;
case BPMEM_TRIGGER_EFB_COPY: case BPMEM_TRIGGER_EFB_COPY:
EfbCopy::CopyEfb(); EfbCopy::CopyEfb();
break; break;
case BPMEM_CLEARBBOX1: case BPMEM_CLEARBBOX1:
PixelEngine::pereg.boxRight = newvalue >> 10; SWPixelEngine::pereg.boxRight = newvalue >> 10;
PixelEngine::pereg.boxLeft = newvalue & 0x3ff; SWPixelEngine::pereg.boxLeft = newvalue & 0x3ff;
break; break;
case BPMEM_CLEARBBOX2: case BPMEM_CLEARBBOX2:
PixelEngine::pereg.boxBottom = newvalue >> 10; SWPixelEngine::pereg.boxBottom = newvalue >> 10;
PixelEngine::pereg.boxTop = newvalue & 0x3ff; SWPixelEngine::pereg.boxTop = newvalue & 0x3ff;
break; break;
case BPMEM_LOADTLUT0: // This one updates bpmem.tlutXferSrc, no need to do anything here. case BPMEM_LOADTLUT0: // This one updates bpmem.tlutXferSrc, no need to do anything here.
break; break;

2
Source/Plugins/Plugin_VideoSoftware/Src/BPMemLoader.h
View File

@ -24,5 +24,7 @@
#include "../../../Core/VideoCommon/Src/BPMemory.h" #include "../../../Core/VideoCommon/Src/BPMemory.h"
void InitBPMemory(); void InitBPMemory();
void SWBPWritten(int address, int newvalue);
void SWLoadBPReg(u32 value);
#endif #endif

4
Source/Plugins/Plugin_VideoSoftware/Src/CPMemLoader.cpp
View File

@ -30,8 +30,7 @@ TMatrixIndexB MatrixIndexB;
TVtxDesc g_VtxDesc; TVtxDesc g_VtxDesc;
VAT g_VtxAttr[8]; VAT g_VtxAttr[8];
void SWLoadCPReg(u32 sub_cmd, u32 value)
void LoadCPReg(u32 sub_cmd, u32 value)
{ {
switch (sub_cmd & 0xF0) switch (sub_cmd & 0xF0)
{ {
@ -79,4 +78,3 @@ void LoadCPReg(u32 sub_cmd, u32 value)
break; break;
} }
} }

1
Source/Plugins/Plugin_VideoSoftware/Src/CPMemLoader.h
View File

@ -23,5 +23,6 @@
#include "../../../Core/VideoCommon/Src/CPMemory.h" #include "../../../Core/VideoCommon/Src/CPMemory.h"
void SWLoadCPReg(u32 sub_cmd, u32 value);
#endif #endif

22
Source/Plugins/Plugin_VideoSoftware/Src/Clipper.cpp
View File

@ -53,7 +53,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "NativeVertexFormat.h" #include "NativeVertexFormat.h"
#include "XFMemLoader.h" #include "XFMemLoader.h"
#include "BPMemLoader.h" #include "BPMemLoader.h"
#include "Statistics.h" #include "SWStatistics.h"
namespace Clipper namespace Clipper
@ -73,8 +73,8 @@ namespace Clipper
void SetViewOffset() void SetViewOffset()
{ {
m_ViewOffset[0] = xfregs.viewport.xOrig - 342; m_ViewOffset[0] = swxfregs.viewport.xOrig - 342;
m_ViewOffset[1] = xfregs.viewport.yOrig - 342; m_ViewOffset[1] = swxfregs.viewport.yOrig - 342;
} }
@ -209,7 +209,7 @@ namespace Clipper
POLY_CLIP(CLIP_POS_Z_BIT, 0, 0, 0, 1); POLY_CLIP(CLIP_POS_Z_BIT, 0, 0, 0, 1);
POLY_CLIP(CLIP_NEG_Z_BIT, 0, 0, 1, 1); POLY_CLIP(CLIP_NEG_Z_BIT, 0, 0, 1, 1);
INCSTAT(stats.thisFrame.numTrianglesClipped); INCSTAT(swstats.thisFrame.numTrianglesClipped);
// transform the poly in inlist into triangles // transform the poly in inlist into triangles
indices[0] = inlist[0]; indices[0] = inlist[0];
@ -273,7 +273,7 @@ namespace Clipper
void ProcessTriangle(OutputVertexData *v0, OutputVertexData *v1, OutputVertexData *v2) void ProcessTriangle(OutputVertexData *v0, OutputVertexData *v1, OutputVertexData *v2)
{ {
INCSTAT(stats.thisFrame.numTrianglesIn) INCSTAT(swstats.thisFrame.numTrianglesIn)
bool backface; bool backface;
@ -395,7 +395,7 @@ namespace Clipper
if(mask) if(mask)
{ {
INCSTAT(stats.thisFrame.numTrianglesRejected) INCSTAT(swstats.thisFrame.numTrianglesRejected)
return false; return false;
} }
@ -415,13 +415,13 @@ namespace Clipper
if ((bpmem.genMode.cullmode & 1) && !backface) // cull frontfacing if ((bpmem.genMode.cullmode & 1) && !backface) // cull frontfacing
{ {
INCSTAT(stats.thisFrame.numTrianglesCulled) INCSTAT(swstats.thisFrame.numTrianglesCulled)
return false; return false;
} }
if ((bpmem.genMode.cullmode & 2) && backface) // cull backfacing if ((bpmem.genMode.cullmode & 2) && backface) // cull backfacing
{ {
INCSTAT(stats.thisFrame.numTrianglesCulled) INCSTAT(swstats.thisFrame.numTrianglesCulled)
return false; return false;
} }
@ -434,9 +434,9 @@ namespace Clipper
Vec3 &screen = vertex->screenPosition; Vec3 &screen = vertex->screenPosition;
float wInverse = 1.0f/projected.w; float wInverse = 1.0f/projected.w;
screen.x = projected.x * wInverse * xfregs.viewport.wd + m_ViewOffset[0]; screen.x = projected.x * wInverse * swxfregs.viewport.wd + m_ViewOffset[0];
screen.y = projected.y * wInverse * xfregs.viewport.ht + m_ViewOffset[1]; screen.y = projected.y * wInverse * swxfregs.viewport.ht + m_ViewOffset[1];
screen.z = projected.z * wInverse * xfregs.viewport.zRange + xfregs.viewport.farZ; screen.z = projected.z * wInverse * swxfregs.viewport.zRange + swxfregs.viewport.farZ;
} }
} }

23
Source/Plugins/Plugin_VideoSoftware/Src/DebugUtil.cpp
View File

@ -17,16 +17,15 @@
#include "Common.h" #include "Common.h"
#include "main.h"
#include "DebugUtil.h" #include "DebugUtil.h"
#include "BPMemLoader.h" #include "BPMemLoader.h"
#include "TextureSampler.h" #include "TextureSampler.h"
#include "SWVideoConfig.h" #include "SWVideoConfig.h"
#include "EfbInterface.h" #include "EfbInterface.h"
#include "Statistics.h" #include "SWStatistics.h"
#include "HwRasterizer.h" #include "HwRasterizer.h"
#include "StringUtil.h" #include "StringUtil.h"
#include "CommandProcessor.h" #include "SWCommandProcessor.h"
#include "../../../Core/VideoCommon/Src/ImageWrite.h" #include "../../../Core/VideoCommon/Src/ImageWrite.h"
#include "FileUtil.h" #include "FileUtil.h"
@ -114,7 +113,7 @@ void DumpActiveTextures()
s32 maxLod = GetMaxTextureLod(texmap); s32 maxLod = GetMaxTextureLod(texmap);
for (s32 mip = 0; mip <= maxLod; ++mip) for (s32 mip = 0; mip <= maxLod; ++mip)
{ {
SaveTexture(StringFromFormat("%star%i_ind%i_map%i_mip%i.tga", File::GetUserPath(D_DUMPTEXTURES_IDX), stats.thisFrame.numDrawnObjects, stageNum, texmap, mip).c_str(), texmap, mip); SaveTexture(StringFromFormat("%star%i_ind%i_map%i_mip%i.tga", File::GetUserPath(D_DUMPTEXTURES_IDX), swstats.thisFrame.numDrawnObjects, stageNum, texmap, mip).c_str(), texmap, mip);
} }
} }
@ -129,7 +128,7 @@ void DumpActiveTextures()
s32 maxLod = GetMaxTextureLod(texmap); s32 maxLod = GetMaxTextureLod(texmap);
for (s32 mip = 0; mip <= maxLod; ++mip) for (s32 mip = 0; mip <= maxLod; ++mip)
{ {
SaveTexture(StringFromFormat("%star%i_stage%i_map%i_mip%i.tga", File::GetUserPath(D_DUMPTEXTURES_IDX), stats.thisFrame.numDrawnObjects, stageNum, texmap, mip).c_str(), texmap, mip); SaveTexture(StringFromFormat("%star%i_stage%i_map%i_mip%i.tga", File::GetUserPath(D_DUMPTEXTURES_IDX), swstats.thisFrame.numDrawnObjects, stageNum, texmap, mip).c_str(), texmap, mip);
} }
} }
} }
@ -216,7 +215,7 @@ void OnObjectBegin()
{ {
if (!g_bSkipCurrentFrame) if (!g_bSkipCurrentFrame)
{ {
if (g_SWVideoConfig.bDumpTextures && stats.thisFrame.numDrawnObjects >= g_SWVideoConfig.drawStart && stats.thisFrame.numDrawnObjects < g_SWVideoConfig.drawEnd) if (g_SWVideoConfig.bDumpTextures && swstats.thisFrame.numDrawnObjects >= g_SWVideoConfig.drawStart && swstats.thisFrame.numDrawnObjects < g_SWVideoConfig.drawEnd)
DumpActiveTextures(); DumpActiveTextures();
if (g_SWVideoConfig.bHwRasterizer) if (g_SWVideoConfig.bHwRasterizer)
@ -231,8 +230,8 @@ void OnObjectEnd()
{ {
if (!g_bSkipCurrentFrame) if (!g_bSkipCurrentFrame)
{ {
if (g_SWVideoConfig.bDumpObjects && stats.thisFrame.numDrawnObjects >= g_SWVideoConfig.drawStart && stats.thisFrame.numDrawnObjects < g_SWVideoConfig.drawEnd) 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), stats.thisFrame.numDrawnObjects).c_str()); DumpEfb(StringFromFormat("%sobject%i.tga", File::GetUserPath(D_DUMPFRAMES_IDX), swstats.thisFrame.numDrawnObjects).c_str());
if (g_SWVideoConfig.bHwRasterizer || drawingHwTriangles) if (g_SWVideoConfig.bHwRasterizer || drawingHwTriangles)
{ {
@ -246,12 +245,12 @@ void OnObjectEnd()
{ {
DrawnToBuffer[i] = false; DrawnToBuffer[i] = false;
(void)SaveTGA(StringFromFormat("%sobject%i_%s(%i).tga", File::GetUserPath(D_DUMPFRAMES_IDX), (void)SaveTGA(StringFromFormat("%sobject%i_%s(%i).tga", File::GetUserPath(D_DUMPFRAMES_IDX),
stats.thisFrame.numDrawnObjects, ObjectBufferName[i], i - BufferBase[i]).c_str(), EFB_WIDTH, EFB_HEIGHT, ObjectBuffer[i]); swstats.thisFrame.numDrawnObjects, ObjectBufferName[i], i - BufferBase[i]).c_str(), EFB_WIDTH, EFB_HEIGHT, ObjectBuffer[i]);
memset(ObjectBuffer[i], 0, sizeof(ObjectBuffer[i])); memset(ObjectBuffer[i], 0, sizeof(ObjectBuffer[i]));
} }
} }
stats.thisFrame.numDrawnObjects++; swstats.thisFrame.numDrawnObjects++;
} }
} }
@ -261,8 +260,8 @@ void OnFrameEnd()
{ {
if (g_SWVideoConfig.bDumpFrames) if (g_SWVideoConfig.bDumpFrames)
{ {
DumpEfb(StringFromFormat("%sframe%i_color.tga", File::GetUserPath(D_DUMPFRAMES_IDX), stats.frameCount).c_str()); DumpEfb(StringFromFormat("%sframe%i_color.tga", File::GetUserPath(D_DUMPFRAMES_IDX), swstats.frameCount).c_str());
DumpDepth(StringFromFormat("%sframe%i_depth.tga", File::GetUserPath(D_DUMPFRAMES_IDX), stats.frameCount).c_str()); DumpDepth(StringFromFormat("%sframe%i_depth.tga", File::GetUserPath(D_DUMPFRAMES_IDX), swstats.frameCount).c_str());
} }
} }
} }

15
Source/Plugins/Plugin_VideoSoftware/Src/EfbCopy.cpp
View File

@ -15,18 +15,17 @@
// Official SVN repository and contact information can be found at // Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/ // http://code.google.com/p/dolphin-emu/
#include "main.h"
#include "BPMemLoader.h" #include "BPMemLoader.h"
#include "EfbCopy.h" #include "EfbCopy.h"
#include "EfbInterface.h" #include "EfbInterface.h"
#include "Renderer.h" #include "SWRenderer.h"
#include "TextureEncoder.h" #include "TextureEncoder.h"
#include "Statistics.h" #include "SWStatistics.h"
#include "SWVideoConfig.h" #include "SWVideoConfig.h"
#include "DebugUtil.h" #include "DebugUtil.h"
#include "HwRasterizer.h" #include "HwRasterizer.h"
#include "CommandProcessor.h" #include "SWCommandProcessor.h"
#include "GLUtil.h" #include "SWGLUtil.h"
#include "HW/Memmap.h" #include "HW/Memmap.h"
#include "Core.h" #include "Core.h"
@ -40,10 +39,10 @@ namespace EfbCopy
{ {
// copy to open gl for rendering // copy to open gl for rendering
EfbInterface::UpdateColorTexture(); EfbInterface::UpdateColorTexture();
Renderer::DrawTexture(EfbInterface::efbColorTexture, EFB_WIDTH, EFB_HEIGHT); SWRenderer::DrawTexture(EfbInterface::efbColorTexture, EFB_WIDTH, EFB_HEIGHT);
} }
Renderer::SwapBuffer(); SWRenderer::SwapBuffer();
} }
@ -88,7 +87,7 @@ namespace EfbCopy
CopyToXfb(); CopyToXfb();
Core::Callback_VideoCopiedToXFB(false); Core::Callback_VideoCopiedToXFB(false);
stats.frameCount++; swstats.frameCount++;
} }
else else
{ {

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

@ -20,7 +20,7 @@
#include "EfbInterface.h" #include "EfbInterface.h"
#include "BPMemLoader.h" #include "BPMemLoader.h"
#include "../../../Core/VideoCommon/Src/LookUpTables.h" #include "../../../Core/VideoCommon/Src/LookUpTables.h"
#include "PixelEngine.h" #include "SWPixelEngine.h"
u8 efb[EFB_WIDTH*EFB_HEIGHT*6]; u8 efb[EFB_WIDTH*EFB_HEIGHT*6];
@ -434,10 +434,10 @@ namespace EfbInterface
SetPixelAlphaOnly(offset, dstClrPtr[ALP_C]); SetPixelAlphaOnly(offset, dstClrPtr[ALP_C]);
// branchless bounding box update // branchless bounding box update
PixelEngine::pereg.boxLeft = PixelEngine::pereg.boxLeft>x?x:PixelEngine::pereg.boxLeft; SWPixelEngine::pereg.boxLeft = SWPixelEngine::pereg.boxLeft>x?x:SWPixelEngine::pereg.boxLeft;
PixelEngine::pereg.boxRight = PixelEngine::pereg.boxRight<x?x:PixelEngine::pereg.boxRight; SWPixelEngine::pereg.boxRight = SWPixelEngine::pereg.boxRight<x?x:SWPixelEngine::pereg.boxRight;
PixelEngine::pereg.boxTop = PixelEngine::pereg.boxTop>y?y:PixelEngine::pereg.boxTop; SWPixelEngine::pereg.boxTop = SWPixelEngine::pereg.boxTop>y?y:SWPixelEngine::pereg.boxTop;
PixelEngine::pereg.boxBottom = PixelEngine::pereg.boxBottom<y?y:PixelEngine::pereg.boxBottom; SWPixelEngine::pereg.boxBottom = SWPixelEngine::pereg.boxBottom<y?y:SWPixelEngine::pereg.boxBottom;
} }
void SetColor(u16 x, u16 y, u8 *color) void SetColor(u16 x, u16 y, u8 *color)

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

@ -22,7 +22,7 @@
#include "BPMemLoader.h" #include "BPMemLoader.h"
#include "HwRasterizer.h" #include "HwRasterizer.h"
#include "GLUtil.h" #include "SWGLUtil.h"
#include "NativeVertexFormat.h" #include "NativeVertexFormat.h"
#include "DebugUtil.h" #include "DebugUtil.h"

2
Source/Plugins/Plugin_VideoSoftware/Src/HwRasterizer.h
View File

@ -21,7 +21,7 @@
#include <map> #include <map>
#include "BPMemLoader.h" #include "BPMemLoader.h"
#include "GLUtil.h" #include "SWGLUtil.h"
struct OutputVertexData; struct OutputVertexData;

30
Source/Plugins/Plugin_VideoSoftware/Src/OpcodeDecoder.cpp
View File

@ -19,15 +19,15 @@
#include "../../../Core/VideoCommon/Src/DataReader.h" #include "../../../Core/VideoCommon/Src/DataReader.h"
#include "main.h"
#include "OpcodeDecoder.h" #include "OpcodeDecoder.h"
#include "BPMemLoader.h" #include "BPMemLoader.h"
#include "CPMemLoader.h" #include "CPMemLoader.h"
#include "XFMemLoader.h" #include "XFMemLoader.h"
#include "VertexLoader.h" #include "SWVertexLoader.h"
#include "Statistics.h" #include "SWStatistics.h"
#include "DebugUtil.h" #include "DebugUtil.h"
#include "CommandProcessor.h" #include "SWCommandProcessor.h"
#include "CPMemLoader.h"
#include "SWVideoConfig.h" #include "SWVideoConfig.h"
#include "HW/Memmap.h" #include "HW/Memmap.h"
@ -38,7 +38,7 @@ u32 minCommandSize;
u16 streamSize; u16 streamSize;
u16 streamAddress; u16 streamAddress;
bool readOpcode; bool readOpcode;
VertexLoader vertexLoader; SWVertexLoader vertexLoader;
bool inObjectStream; bool inObjectStream;
u8 lastPrimCmd; u8 lastPrimCmd;
@ -51,8 +51,8 @@ void DecodePrimitiveStream(u32 iBufferSize)
u32 vertexSize = vertexLoader.GetVertexSize(); u32 vertexSize = vertexLoader.GetVertexSize();
bool skipPrimitives = g_bSkipCurrentFrame || bool skipPrimitives = g_bSkipCurrentFrame ||
stats.thisFrame.numDrawnObjects < g_SWVideoConfig.drawStart || swstats.thisFrame.numDrawnObjects < g_SWVideoConfig.drawStart ||
stats.thisFrame.numDrawnObjects >= g_SWVideoConfig.drawEnd; swstats.thisFrame.numDrawnObjects >= g_SWVideoConfig.drawEnd;
if (skipPrimitives) if (skipPrimitives)
{ {
@ -87,7 +87,7 @@ void ReadXFData(u32 iBufferSize)
u32 pData[16]; u32 pData[16];
for (int i = 0; i < streamSize; i++) for (int i = 0; i < streamSize; i++)
pData[i] = DataReadU32(); pData[i] = DataReadU32();
LoadXFReg(streamSize, streamAddress, pData); SWLoadXFReg(streamSize, streamAddress, pData);
// return to normal command processing // return to normal command processing
ResetDecoding(); ResetDecoding();
@ -149,7 +149,7 @@ void DecodeStandard(u32 bufferSize)
{ {
u32 SubCmd = DataReadU8(); u32 SubCmd = DataReadU8();
u32 Value = DataReadU32(); u32 Value = DataReadU32();
LoadCPReg(SubCmd, Value); SWLoadCPReg(SubCmd, Value);
} }
break; break;
@ -165,16 +165,16 @@ void DecodeStandard(u32 bufferSize)
break; break;
case GX_LOAD_INDX_A: //used for position matrices case GX_LOAD_INDX_A: //used for position matrices
LoadIndexedXF(DataReadU32(), 0xC); SWLoadIndexedXF(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); SWLoadIndexedXF(DataReadU32(), 0xD);
break; break;
case GX_LOAD_INDX_C: //used for postmatrices case GX_LOAD_INDX_C: //used for postmatrices
LoadIndexedXF(DataReadU32(), 0xE); SWLoadIndexedXF(DataReadU32(), 0xE);
break; break;
case GX_LOAD_INDX_D: //used for lights case GX_LOAD_INDX_D: //used for lights
LoadIndexedXF(DataReadU32(), 0xF); SWLoadIndexedXF(DataReadU32(), 0xF);
break; break;
case GX_CMD_CALL_DL: case GX_CMD_CALL_DL:
@ -196,7 +196,7 @@ void DecodeStandard(u32 bufferSize)
case GX_LOAD_BP_REG: //0x61 case GX_LOAD_BP_REG: //0x61
{ {
u32 cmd = DataReadU32(); u32 cmd = DataReadU32();
LoadBPReg(cmd); SWLoadBPReg(cmd);
} }
break; break;
@ -214,7 +214,7 @@ void DecodeStandard(u32 bufferSize)
minCommandSize = vertexLoader.GetVertexSize(); minCommandSize = vertexLoader.GetVertexSize();
readOpcode = false; readOpcode = false;
INCSTAT(stats.thisFrame.numPrimatives); INCSTAT(swstats.thisFrame.numPrimatives);
DEBUG_LOG(VIDEO, "Draw begin"); DEBUG_LOG(VIDEO, "Draw begin");
} }
else else

223
Source/Plugins/Plugin_VideoSoftware/Src/RasterFont.cpp
View File

@ -1,223 +0,0 @@
// Copyright (C) 2003 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
#include "GLUtil.h"
#include <string.h>
#include "RasterFont.h"
// globals
GLubyte rasters[][13] = {
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36},
{0x00, 0x00, 0x00, 0x66, 0x66, 0xff, 0x66, 0x66, 0xff, 0x66, 0x66, 0x00, 0x00},
{0x00, 0x00, 0x18, 0x7e, 0xff, 0x1b, 0x1f, 0x7e, 0xf8, 0xd8, 0xff, 0x7e, 0x18},
{0x00, 0x00, 0x0e, 0x1b, 0xdb, 0x6e, 0x30, 0x18, 0x0c, 0x76, 0xdb, 0xd8, 0x70},
{0x00, 0x00, 0x7f, 0xc6, 0xcf, 0xd8, 0x70, 0x70, 0xd8, 0xcc, 0xcc, 0x6c, 0x38},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x1c, 0x0c, 0x0e},
{0x00, 0x00, 0x0c, 0x18, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x18, 0x0c},
{0x00, 0x00, 0x30, 0x18, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x18, 0x30},
{0x00, 0x00, 0x00, 0x00, 0x99, 0x5a, 0x3c, 0xff, 0x3c, 0x5a, 0x99, 0x00, 0x00},
{0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0xff, 0xff, 0x18, 0x18, 0x18, 0x00, 0x00},
{0x00, 0x00, 0x30, 0x18, 0x1c, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x60, 0x60, 0x30, 0x30, 0x18, 0x18, 0x0c, 0x0c, 0x06, 0x06, 0x03, 0x03},
{0x00, 0x00, 0x3c, 0x66, 0xc3, 0xe3, 0xf3, 0xdb, 0xcf, 0xc7, 0xc3, 0x66, 0x3c},
{0x00, 0x00, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78, 0x38, 0x18},
{0x00, 0x00, 0xff, 0xc0, 0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x03, 0xe7, 0x7e},
{0x00, 0x00, 0x7e, 0xe7, 0x03, 0x03, 0x07, 0x7e, 0x07, 0x03, 0x03, 0xe7, 0x7e},
{0x00, 0x00, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xff, 0xcc, 0x6c, 0x3c, 0x1c, 0x0c},
{0x00, 0x00, 0x7e, 0xe7, 0x03, 0x03, 0x07, 0xfe, 0xc0, 0xc0, 0xc0, 0xc0, 0xff},
{0x00, 0x00, 0x7e, 0xe7, 0xc3, 0xc3, 0xc7, 0xfe, 0xc0, 0xc0, 0xc0, 0xe7, 0x7e},
{0x00, 0x00, 0x30, 0x30, 0x30, 0x30, 0x18, 0x0c, 0x06, 0x03, 0x03, 0x03, 0xff},
{0x00, 0x00, 0x7e, 0xe7, 0xc3, 0xc3, 0xe7, 0x7e, 0xe7, 0xc3, 0xc3, 0xe7, 0x7e},
{0x00, 0x00, 0x7e, 0xe7, 0x03, 0x03, 0x03, 0x7f, 0xe7, 0xc3, 0xc3, 0xe7, 0x7e},
{0x00, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x30, 0x18, 0x1c, 0x1c, 0x00, 0x00, 0x1c, 0x1c, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06},
{0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60},
{0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x18, 0x0c, 0x06, 0x03, 0xc3, 0xc3, 0x7e},
{0x00, 0x00, 0x3f, 0x60, 0xcf, 0xdb, 0xd3, 0xdd, 0xc3, 0x7e, 0x00, 0x00, 0x00},
{0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xff, 0xc3, 0xc3, 0xc3, 0x66, 0x3c, 0x18},
{0x00, 0x00, 0xfe, 0xc7, 0xc3, 0xc3, 0xc7, 0xfe, 0xc7, 0xc3, 0xc3, 0xc7, 0xfe},
{0x00, 0x00, 0x7e, 0xe7, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xe7, 0x7e},
{0x00, 0x00, 0xfc, 0xce, 0xc7, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc7, 0xce, 0xfc},
{0x00, 0x00, 0xff, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xff},
{0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xc0, 0xff},
{0x00, 0x00, 0x7e, 0xe7, 0xc3, 0xc3, 0xcf, 0xc0, 0xc0, 0xc0, 0xc0, 0xe7, 0x7e},
{0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xff, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3},
{0x00, 0x00, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7e},
{0x00, 0x00, 0x7c, 0xee, 0xc6, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06},
{0x00, 0x00, 0xc3, 0xc6, 0xcc, 0xd8, 0xf0, 0xe0, 0xf0, 0xd8, 0xcc, 0xc6, 0xc3},
{0x00, 0x00, 0xff, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0},
{0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xdb, 0xff, 0xff, 0xe7, 0xc3},
{0x00, 0x00, 0xc7, 0xc7, 0xcf, 0xcf, 0xdf, 0xdb, 0xfb, 0xf3, 0xf3, 0xe3, 0xe3},
{0x00, 0x00, 0x7e, 0xe7, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xe7, 0x7e},
{0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfe, 0xc7, 0xc3, 0xc3, 0xc7, 0xfe},
{0x00, 0x00, 0x3f, 0x6e, 0xdf, 0xdb, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x66, 0x3c},
{0x00, 0x00, 0xc3, 0xc6, 0xcc, 0xd8, 0xf0, 0xfe, 0xc7, 0xc3, 0xc3, 0xc7, 0xfe},
{0x00, 0x00, 0x7e, 0xe7, 0x03, 0x03, 0x07, 0x7e, 0xe0, 0xc0, 0xc0, 0xe7, 0x7e},
{0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xff},
{0x00, 0x00, 0x7e, 0xe7, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3},
{0x00, 0x00, 0x18, 0x3c, 0x3c, 0x66, 0x66, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3},
{0x00, 0x00, 0xc3, 0xe7, 0xff, 0xff, 0xdb, 0xdb, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3},
{0x00, 0x00, 0xc3, 0x66, 0x66, 0x3c, 0x3c, 0x18, 0x3c, 0x3c, 0x66, 0x66, 0xc3},
{0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x3c, 0x66, 0x66, 0xc3},
{0x00, 0x00, 0xff, 0xc0, 0xc0, 0x60, 0x30, 0x7e, 0x0c, 0x06, 0x03, 0x03, 0xff},
{0x00, 0x00, 0x3c, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3c},
{0x00, 0x03, 0x03, 0x06, 0x06, 0x0c, 0x0c, 0x18, 0x18, 0x30, 0x30, 0x60, 0x60},
{0x00, 0x00, 0x3c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x3c},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0x66, 0x3c, 0x18},
{0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x38, 0x30, 0x70},
{0x00, 0x00, 0x7f, 0xc3, 0xc3, 0x7f, 0x03, 0xc3, 0x7e, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0xfe, 0xc3, 0xc3, 0xc3, 0xc3, 0xfe, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0},
{0x00, 0x00, 0x7e, 0xc3, 0xc0, 0xc0, 0xc0, 0xc3, 0x7e, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x7f, 0xc3, 0xc3, 0xc3, 0xc3, 0x7f, 0x03, 0x03, 0x03, 0x03, 0x03},
{0x00, 0x00, 0x7f, 0xc0, 0xc0, 0xfe, 0xc3, 0xc3, 0x7e, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0xfc, 0x30, 0x30, 0x30, 0x33, 0x1e},
{0x7e, 0xc3, 0x03, 0x03, 0x7f, 0xc3, 0xc3, 0xc3, 0x7e, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xfe, 0xc0, 0xc0, 0xc0, 0xc0},
{0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x18, 0x00},
{0x38, 0x6c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x00, 0x00, 0x0c, 0x00},
{0x00, 0x00, 0xc6, 0xcc, 0xf8, 0xf0, 0xd8, 0xcc, 0xc6, 0xc0, 0xc0, 0xc0, 0xc0},
{0x00, 0x00, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78},
{0x00, 0x00, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xfe, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xfc, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00},
{0xc0, 0xc0, 0xc0, 0xfe, 0xc3, 0xc3, 0xc3, 0xc3, 0xfe, 0x00, 0x00, 0x00, 0x00},
{0x03, 0x03, 0x03, 0x7f, 0xc3, 0xc3, 0xc3, 0xc3, 0x7f, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xe0, 0xfe, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0xfe, 0x03, 0x03, 0x7e, 0xc0, 0xc0, 0x7f, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x1c, 0x36, 0x30, 0x30, 0x30, 0x30, 0xfc, 0x30, 0x30, 0x30, 0x00},
{0x00, 0x00, 0x7e, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x18, 0x3c, 0x3c, 0x66, 0x66, 0xc3, 0xc3, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0xc3, 0xe7, 0xff, 0xdb, 0xc3, 0xc3, 0xc3, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0xc3, 0x66, 0x3c, 0x18, 0x3c, 0x66, 0xc3, 0x00, 0x00, 0x00, 0x00},
{0xc0, 0x60, 0x60, 0x30, 0x18, 0x3c, 0x66, 0x66, 0xc3, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0xff, 0x60, 0x30, 0x18, 0x0c, 0x06, 0xff, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x0f, 0x18, 0x18, 0x18, 0x38, 0xf0, 0x38, 0x18, 0x18, 0x18, 0x0f},
{0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18},
{0x00, 0x00, 0xf0, 0x18, 0x18, 0x18, 0x1c, 0x0f, 0x1c, 0x18, 0x18, 0x18, 0xf0},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x8f, 0xf1, 0x60, 0x00, 0x00, 0x00}
};
RasterFont::RasterFont()
{
// set GL modes
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
// create the raster font
fontOffset = glGenLists(128);
for (int i = 32; i < 127; i++) {
glNewList(i + fontOffset, GL_COMPILE);
glBitmap(8, 13, 0.0f, 2.0f, 10.0f, 0.0f, rasters[i - 32]);
glEndList();
}
temp_buffer = new char[TEMP_BUFFER_SIZE];
}
RasterFont::~RasterFont()
{
glDeleteLists(fontOffset, 128);
delete [] temp_buffer;
}
void RasterFont::printString(const char *s, double x, double y, double z)
{
int length = (int)strlen(s);
if (!length)
return;
if (length >= TEMP_BUFFER_SIZE)
length = TEMP_BUFFER_SIZE - 1;
// Sanitize string to avoid GL errors.
char *s2 = temp_buffer;
memcpy(s2, s, length);
s2[length] = 0;
for (int i = 0; i < length; i++) {
if (s2[i] < 32 || s2[i] > 126)
s2[i] = '!';
}
// go to the right spot
glRasterPos3d(x, y, z);
GL_REPORT_ERRORD();
glPushAttrib (GL_LIST_BIT);
glListBase(fontOffset);
glCallLists((GLsizei)strlen(s2), GL_UNSIGNED_BYTE, (GLubyte *) s2);
GL_REPORT_ERRORD();
glPopAttrib();
GL_REPORT_ERRORD();
}
void RasterFont::printCenteredString(const char *s, double y, int screen_width, double z)
{
int length = (int)strlen(s);
int x = (int)(screen_width/2.0 - (length/2.0)*char_width);
printString(s, x, y, z);
}
void RasterFont::printMultilineText(const char *text, double start_x, double start_y, double z, int bbWidth, int bbHeight)
{
double x = start_x;
double y = start_y;
char temp[1024];
char *t = temp;
while (*text)
{
if (*text == '\n')
{
*t = 0;
printString(temp, x, y, z);
y -= char_height * 2.0f / bbHeight;
x = start_x;
t = temp;
}
else if (*text == '\r')
{
t = temp;
}
else if (*text == '\t')
{
//todo: add tabs every something like 4*char_width
*t = 0;
int cpos = (int)strlen(temp);
int newpos = (cpos + 4) & (~3);
printString(temp, x, y, z);
x = start_x + (char_width*newpos) * 2.0f / bbWidth;
t = temp;
*t++ = ' ';
}
else
*t++ = *text;
text++;
}
// ????
if (t != text)
{
*t = 0;
printString(temp, x, y, z);
}
}

42
Source/Plugins/Plugin_VideoSoftware/Src/RasterFont.h
View File

@ -1,42 +0,0 @@
// Copyright (C) 2003 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
#ifndef _RASTERFONT_H_
#define _RASTERFONT_H_
class RasterFont {
public:
RasterFont();
~RasterFont(void);
static int debug;
// some useful constants
enum {char_width = 10};
enum {char_height = 15};
// and the happy helper functions
void printString(const char *s, double x, double y, double z=0.0);
void printCenteredString(const char *s, double y, int screen_width, double z=0.0);
void printMultilineText(const char *text, double x, double y, double z, int bbWidth, int bbHeight);
private:
int fontOffset;
char *temp_buffer;
enum {TEMP_BUFFER_SIZE = 64 * 1024};
};
#endif // _RASTERFONT_H_

8
Source/Plugins/Plugin_VideoSoftware/Src/Rasterizer.cpp
View File

@ -23,7 +23,7 @@
#include "BPMemLoader.h" #include "BPMemLoader.h"
#include "XFMemLoader.h" #include "XFMemLoader.h"
#include "Tev.h" #include "Tev.h"
#include "Statistics.h" #include "SWStatistics.h"
#include "SWVideoConfig.h" #include "SWVideoConfig.h"
@ -111,7 +111,7 @@ void SetTevReg(int reg, int comp, bool konst, s16 color)
inline void Draw(s32 x, s32 y, s32 xi, s32 yi) inline void Draw(s32 x, s32 y, s32 xi, s32 yi)
{ {
INCSTAT(stats.thisFrame.rasterizedPixels); INCSTAT(swstats.thisFrame.rasterizedPixels);
float dx = vertexOffsetX + (float)(x - vertex0X); float dx = vertexOffsetX + (float)(x - vertex0X);
float dy = vertexOffsetY + (float)(y - vertex0Y); float dy = vertexOffsetY + (float)(y - vertex0Y);
@ -258,7 +258,7 @@ void BuildBlock(s32 blockX, s32 blockY)
for (unsigned int i = 0; i < bpmem.genMode.numtexgens; i++) for (unsigned int i = 0; i < bpmem.genMode.numtexgens; i++)
{ {
float projection = invW; float projection = invW;
if (xfregs.texMtxInfo[i].projection) if (swxfregs.texMtxInfo[i].projection)
{ {
float q = TexSlopes[i][2].GetValue(dx, dy) * invW; float q = TexSlopes[i][2].GetValue(dx, dy) * invW;
if (q != 0.0f) if (q != 0.0f)
@ -298,7 +298,7 @@ void BuildBlock(s32 blockX, s32 blockY)
void DrawTriangleFrontFace(OutputVertexData *v0, OutputVertexData *v1, OutputVertexData *v2) void DrawTriangleFrontFace(OutputVertexData *v0, OutputVertexData *v1, OutputVertexData *v2)
{ {
INCSTAT(stats.thisFrame.numTrianglesDrawn); INCSTAT(swstats.thisFrame.numTrianglesDrawn);
if (g_SWVideoConfig.bHwRasterizer) if (g_SWVideoConfig.bHwRasterizer)
{ {

15
Source/Plugins/Plugin_VideoSoftware/Src/SConscript
View File

@ -7,26 +7,25 @@ import sys
files = [ files = [
'BPMemLoader.cpp', 'BPMemLoader.cpp',
'Clipper.cpp', 'Clipper.cpp',
'CommandProcessor.cpp', 'SWCommandProcessor.cpp',
'CPMemLoader.cpp', 'CPMemLoader.cpp',
'DebugUtil.cpp', 'DebugUtil.cpp',
'EfbCopy.cpp', 'EfbCopy.cpp',
'EfbInterface.cpp', 'EfbInterface.cpp',
'GLUtil.cpp', 'SWGLUtil.cpp',
'HwRasterizer.cpp', 'HwRasterizer.cpp',
'main.cpp', 'SWmain.cpp',
'OpcodeDecoder.cpp', 'OpcodeDecoder.cpp',
'PixelEngine.cpp', 'SWPixelEngine.cpp',
'Rasterizer.cpp', 'Rasterizer.cpp',
'RasterFont.cpp', 'SWRenderer.cpp',
'Renderer.cpp',
'SetupUnit.cpp', 'SetupUnit.cpp',
'Statistics.cpp', 'SWStatistics.cpp',
'Tev.cpp', 'Tev.cpp',
'TextureEncoder.cpp', 'TextureEncoder.cpp',
'TextureSampler.cpp', 'TextureSampler.cpp',
'TransformUnit.cpp', 'TransformUnit.cpp',
'VertexLoader.cpp', 'SWVertexLoader.cpp',
'SWVideoConfig.cpp', 'SWVideoConfig.cpp',
'XFMemLoader.cpp', 'XFMemLoader.cpp',
] ]

24
Source/Plugins/Plugin_VideoSoftware/Src/CommandProcessor.cpp → Source/Plugins/Plugin_VideoSoftware/Src/SWCommandProcessor.cpp
View File

@ -24,11 +24,11 @@
#include "HW/Memmap.h" #include "HW/Memmap.h"
#include "HW/ProcessorInterface.h" #include "HW/ProcessorInterface.h"
#include "CommandProcessor.h" #include "VideoBackend.h"
#include "SWCommandProcessor.h"
#include "ChunkFile.h" #include "ChunkFile.h"
#include "MathUtil.h" #include "MathUtil.h"
volatile bool g_bSkipCurrentFrame;
bool fifoStateRun; bool fifoStateRun;
// set to 0 if using in video common // set to 0 if using in video common
@ -37,8 +37,6 @@ bool fifoStateRun;
#if (SW_PLUGIN) #if (SW_PLUGIN)
#include "OpcodeDecoder.h" #include "OpcodeDecoder.h"
#include "main.h"
u8* g_pVideoData;
#else #else
@ -49,7 +47,7 @@ extern u8* g_pVideoData;
#endif #endif
namespace CommandProcessor namespace SWCommandProcessor
{ {
enum enum
@ -407,10 +405,10 @@ void SetStatus()
if (SConfig::GetInstance().m_LocalCoreStartupParameter.bCPUThread) if (SConfig::GetInstance().m_LocalCoreStartupParameter.bCPUThread)
{ {
interruptWaiting = true; interruptWaiting = true;
CommandProcessor::UpdateInterruptsFromVideoPlugin(userdata); SWCommandProcessor::UpdateInterruptsFromVideoPlugin(userdata);
} }
else else
CommandProcessor::UpdateInterrupts(userdata); SWCommandProcessor::UpdateInterrupts(userdata);
} }
} }
@ -468,20 +466,20 @@ bool RunBuffer()
return ranDecoder; return ranDecoder;
} }
} // end of namespace CommandProcessor } // end of namespace SWCommandProcessor
// fifo functions // fifo functions
#if (SW_PLUGIN) #if (SW_PLUGIN)
void Fifo_EnterLoop() void SWFifo_EnterLoop()
{ {
fifoStateRun = true; fifoStateRun = true;
while (fifoStateRun) while (fifoStateRun)
{ {
g_video_backend->PeekMessages(); g_video_backend->PeekMessages();
if (!CommandProcessor::RunBuffer()) { if (!SWCommandProcessor::RunBuffer()) {
Common::YieldCPU(); Common::YieldCPU();
} }
} }
@ -508,6 +506,7 @@ void Fifo_EnterLoop(const SVideoInitialize &video_initialize)
#endif #endif
#if 0
void Fifo_ExitLoop() void Fifo_ExitLoop()
{ {
fifoStateRun = false; fifoStateRun = false;
@ -525,10 +524,11 @@ void Fifo_DoState(PointerWrap &p) {}
u8* FAKE_GetFifoStartPtr() u8* FAKE_GetFifoStartPtr()
{ {
return CommandProcessor::commandBuffer; return SWCommandProcessor::commandBuffer;
} }
u8* FAKE_GetFifoEndPtr() u8* FAKE_GetFifoEndPtr()
{ {
return &CommandProcessor::commandBuffer[CommandProcessor::writePos]; return &SWCommandProcessor::commandBuffer[SWCommandProcessor::writePos];
} }
#endif

5
Source/Plugins/Plugin_VideoSoftware/Src/CommandProcessor.h → Source/Plugins/Plugin_VideoSoftware/Src/SWCommandProcessor.h
View File

@ -23,6 +23,7 @@
class PointerWrap; class PointerWrap;
extern volatile bool g_bSkipCurrentFrame; extern volatile bool g_bSkipCurrentFrame;
extern u8* g_pVideoData;
// for compatibility with video common // for compatibility with video common
void Fifo_Init(); void Fifo_Init();
@ -38,7 +39,7 @@ void VideoFifo_CheckSwapRequest();
void VideoFifo_CheckSwapRequestAt(u32 xfbAddr, u32 fbWidth, u32 fbHeight); void VideoFifo_CheckSwapRequestAt(u32 xfbAddr, u32 fbWidth, u32 fbHeight);
void VideoFifo_CheckEFBAccess(); void VideoFifo_CheckEFBAccess();
namespace CommandProcessor namespace SWCommandProcessor
{ {
// internal hardware addresses // internal hardware addresses
enum enum
@ -164,7 +165,7 @@ namespace CommandProcessor
void UpdateInterruptsFromVideoPlugin(u64 userdata); void UpdateInterruptsFromVideoPlugin(u64 userdata);
} // end of namespace CommandProcessor } // end of namespace SWCommandProcessor
#endif #endif

3
Source/Plugins/Plugin_VideoSoftware/Src/GLUtil.cpp → Source/Plugins/Plugin_VideoSoftware/Src/SWGLUtil.cpp
View File

@ -15,7 +15,6 @@
// Official SVN repository and contact information can be found at // Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/ // http://code.google.com/p/dolphin-emu/
#include "main.h"
#include "SWVideoConfig.h" #include "SWVideoConfig.h"
#include "IniFile.h" #include "IniFile.h"
#include "Setup.h" #include "Setup.h"
@ -23,7 +22,7 @@
#include "Core.h" #include "Core.h"
#include "Host.h" #include "Host.h"
#include "GLUtil.h" #include "SWGLUtil.h"
#if defined(_WIN32) #if defined(_WIN32)
#include "Win32.h" #include "Win32.h"

0
Source/Plugins/Plugin_VideoSoftware/Src/GLUtil.h → Source/Plugins/Plugin_VideoSoftware/Src/SWGLUtil.h
View File

8
Source/Plugins/Plugin_VideoSoftware/Src/PixelEngine.cpp → Source/Plugins/Plugin_VideoSoftware/Src/SWPixelEngine.cpp
View File

@ -26,11 +26,11 @@
#include "ConfigManager.h" #include "ConfigManager.h"
#include "HW/ProcessorInterface.h" #include "HW/ProcessorInterface.h"
#include "PixelEngine.h" #include "SWPixelEngine.h"
#include "CommandProcessor.h" #include "SWCommandProcessor.h"
namespace PixelEngine namespace SWPixelEngine
{ {
enum enum
@ -170,4 +170,4 @@ void SetFinish()
INFO_LOG(PIXELENGINE, "VIDEO Set Finish"); INFO_LOG(PIXELENGINE, "VIDEO Set Finish");
} }
} // end of namespace PixelEngine } // end of namespace SWPixelEngine

6
Source/Plugins/Plugin_VideoSoftware/Src/PixelEngine.h → Source/Plugins/Plugin_VideoSoftware/Src/SWPixelEngine.h
View File

@ -22,7 +22,7 @@
class PointerWrap; class PointerWrap;
namespace PixelEngine namespace SWPixelEngine
{ {
// internal hardware addresses // internal hardware addresses
enum enum
@ -148,8 +148,6 @@ namespace PixelEngine
void SetFinish(void); void SetFinish(void);
bool AllowIdleSkipping(); bool AllowIdleSkipping();
} // end of namespace PixelEngine } // end of namespace SWPixelEngine
#endif #endif

55
Source/Plugins/Plugin_VideoSoftware/Src/Renderer.cpp → Source/Plugins/Plugin_VideoSoftware/Src/SWRenderer.cpp
View File

@ -18,11 +18,10 @@
#include "Common.h" #include "Common.h"
#include "Core.h" #include "Core.h"
#include "GLUtil.h" #include "SWGLUtil.h"
#include "Renderer.h" #include "SWRenderer.h"
#include "main.h" #include "SWStatistics.h"
#include "Statistics.h" #include "../../Plugin_VideoOGL/Src/RasterFont.h"
#include "RasterFont.h"
#define VSYNC_ENABLED 0 #define VSYNC_ENABLED 0
@ -30,16 +29,16 @@ static GLuint s_RenderTarget = 0;
RasterFont* s_pfont = NULL; RasterFont* s_pfont = NULL;
void Renderer::Init() void SWRenderer::Init()
{ {
if (!OpenGL_Create(640, 480)) // 640x480 will be the default if all else fails if (!OpenGL_Create(640, 480)) // 640x480 will be the default if all else fails
{ {
Core::Callback_VideoLog("Renderer::Create failed\n"); Core::Callback_VideoLog("SWRenderer::Create failed\n");
return; return;
} }
} }
void Renderer::Shutdown() void SWRenderer::Shutdown()
{ {
glDeleteTextures(1, &s_RenderTarget); glDeleteTextures(1, &s_RenderTarget);
@ -47,7 +46,7 @@ void Renderer::Shutdown()
s_pfont = 0; s_pfont = 0;
} }
void Renderer::Prepare() void SWRenderer::Prepare()
{ {
OpenGL_MakeCurrent(); OpenGL_MakeCurrent();
@ -104,7 +103,7 @@ void Renderer::Prepare()
glEnable(GL_TEXTURE_RECTANGLE_ARB); glEnable(GL_TEXTURE_RECTANGLE_ARB);
} }
void Renderer::RenderText(const char* pstr, int left, int top, u32 color) void SWRenderer::RenderText(const char* pstr, int left, int top, u32 color)
{ {
int nBackbufferWidth = (int)OpenGL_GetBackbufferWidth(); int nBackbufferWidth = (int)OpenGL_GetBackbufferWidth();
int nBackbufferHeight = (int)OpenGL_GetBackbufferHeight(); int nBackbufferHeight = (int)OpenGL_GetBackbufferHeight();
@ -116,7 +115,7 @@ void Renderer::RenderText(const char* pstr, int left, int top, u32 color)
0, nBackbufferWidth, nBackbufferHeight); 0, nBackbufferWidth, nBackbufferHeight);
} }
void Renderer::DrawDebugText() void SWRenderer::DrawDebugText()
{ {
char debugtext_buffer[8192]; char debugtext_buffer[8192];
char *p = debugtext_buffer; char *p = debugtext_buffer;
@ -124,27 +123,27 @@ void Renderer::DrawDebugText()
if (g_SWVideoConfig.bShowStats) if (g_SWVideoConfig.bShowStats)
{ {
p+=sprintf(p,"Objects: %i\n",stats.thisFrame.numDrawnObjects); p+=sprintf(p,"Objects: %i\n",swstats.thisFrame.numDrawnObjects);
p+=sprintf(p,"Primatives: %i\n",stats.thisFrame.numPrimatives); p+=sprintf(p,"Primatives: %i\n",swstats.thisFrame.numPrimatives);
p+=sprintf(p,"Vertices Loaded: %i\n",stats.thisFrame.numVerticesLoaded); p+=sprintf(p,"Vertices Loaded: %i\n",swstats.thisFrame.numVerticesLoaded);
p+=sprintf(p,"Triangles Input: %i\n",stats.thisFrame.numTrianglesIn); p+=sprintf(p,"Triangles Input: %i\n",swstats.thisFrame.numTrianglesIn);
p+=sprintf(p,"Triangles Rejected: %i\n",stats.thisFrame.numTrianglesRejected); p+=sprintf(p,"Triangles Rejected: %i\n",swstats.thisFrame.numTrianglesRejected);
p+=sprintf(p,"Triangles Culled: %i\n",stats.thisFrame.numTrianglesCulled); p+=sprintf(p,"Triangles Culled: %i\n",swstats.thisFrame.numTrianglesCulled);
p+=sprintf(p,"Triangles Clipped: %i\n",stats.thisFrame.numTrianglesClipped); p+=sprintf(p,"Triangles Clipped: %i\n",swstats.thisFrame.numTrianglesClipped);
p+=sprintf(p,"Triangles Drawn: %i\n",stats.thisFrame.numTrianglesDrawn); p+=sprintf(p,"Triangles Drawn: %i\n",swstats.thisFrame.numTrianglesDrawn);
p+=sprintf(p,"Rasterized Pix: %i\n",stats.thisFrame.rasterizedPixels); p+=sprintf(p,"Rasterized Pix: %i\n",swstats.thisFrame.rasterizedPixels);
p+=sprintf(p,"TEV Pix In: %i\n",stats.thisFrame.tevPixelsIn); p+=sprintf(p,"TEV Pix In: %i\n",swstats.thisFrame.tevPixelsIn);
p+=sprintf(p,"TEV Pix Out: %i\n",stats.thisFrame.tevPixelsOut); p+=sprintf(p,"TEV Pix Out: %i\n",swstats.thisFrame.tevPixelsOut);
} }
// Render a shadow, and then the text. // Render a shadow, and then the text.
Renderer::RenderText(debugtext_buffer, 21, 21, 0xDD000000); SWRenderer::RenderText(debugtext_buffer, 21, 21, 0xDD000000);
Renderer::RenderText(debugtext_buffer, 20, 20, 0xFFFFFF00); SWRenderer::RenderText(debugtext_buffer, 20, 20, 0xFFFFFF00);
} }
void Renderer::DrawTexture(u8 *texture, int width, int height) void SWRenderer::DrawTexture(u8 *texture, int width, int height)
{ {
GLsizei glWidth = (GLsizei)OpenGL_GetBackbufferWidth(); GLsizei glWidth = (GLsizei)OpenGL_GetBackbufferWidth();
GLsizei glHeight = (GLsizei)OpenGL_GetBackbufferHeight(); GLsizei glHeight = (GLsizei)OpenGL_GetBackbufferHeight();
@ -173,7 +172,7 @@ void Renderer::DrawTexture(u8 *texture, int width, int height)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0); glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
} }
void Renderer::SwapBuffer() void SWRenderer::SwapBuffer()
{ {
DrawDebugText(); DrawDebugText();
@ -183,7 +182,7 @@ void Renderer::SwapBuffer()
GL_REPORT_ERRORD(); GL_REPORT_ERRORD();
stats.ResetFrame(); swstats.ResetFrame();
// Clear framebuffer // Clear framebuffer
glClearColor(0, 0, 0, 0); glClearColor(0, 0, 0, 0);
@ -192,5 +191,3 @@ void Renderer::SwapBuffer()
GL_REPORT_ERRORD(); GL_REPORT_ERRORD();
} }

2
Source/Plugins/Plugin_VideoSoftware/Src/Renderer.h → Source/Plugins/Plugin_VideoSoftware/Src/SWRenderer.h
View File

@ -20,7 +20,7 @@
#include "CommonTypes.h" #include "CommonTypes.h"
namespace Renderer namespace SWRenderer
{ {
void Init(); void Init();
void Prepare(); void Prepare();

8
Source/Plugins/Plugin_VideoSoftware/Src/Statistics.cpp → Source/Plugins/Plugin_VideoSoftware/Src/SWStatistics.cpp
View File

@ -15,9 +15,9 @@
// Official SVN repository and contact information can be found at // Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/ // http://code.google.com/p/dolphin-emu/
#include "Statistics.h" #include "SWStatistics.h"
Statistics stats; SWStatistics swstats;
template <class T> template <class T>
void Xchg(T& a, T&b) void Xchg(T& a, T&b)
@ -27,12 +27,12 @@ void Xchg(T& a, T&b)
b = c; b = c;
} }
Statistics::Statistics() SWStatistics::SWStatistics()
{ {
frameCount = 0; frameCount = 0;
} }
void Statistics::ResetFrame() void SWStatistics::ResetFrame()
{ {
memset(&thisFrame, 0, sizeof(ThisFrame)); memset(&thisFrame, 0, sizeof(ThisFrame));
} }

6
Source/Plugins/Plugin_VideoSoftware/Src/Statistics.h → Source/Plugins/Plugin_VideoSoftware/Src/SWStatistics.h
View File

@ -21,7 +21,7 @@
#ifndef _STATISTICS_H #ifndef _STATISTICS_H
#define _STATISTICS_H #define _STATISTICS_H
struct Statistics struct SWStatistics
{ {
struct ThisFrame struct ThisFrame
{ {
@ -42,13 +42,13 @@ struct Statistics
}; };
u32 frameCount; u32 frameCount;
Statistics(); SWStatistics();
ThisFrame thisFrame; ThisFrame thisFrame;
void ResetFrame(); void ResetFrame();
}; };
extern Statistics stats; extern SWStatistics swstats;
#if (STATISTICS) #if (STATISTICS)
#define INCSTAT(a) (a)++; #define INCSTAT(a) (a)++;

77
Source/Plugins/Plugin_VideoSoftware/Src/VertexLoader.cpp → Source/Plugins/Plugin_VideoSoftware/Src/SWVertexLoader.cpp
View File

@ -17,7 +17,7 @@
#include "Common.h" #include "Common.h"
#include "VertexLoader.h" #include "SWVertexLoader.h"
#include "VertexLoader_Position.h" #include "VertexLoader_Position.h"
#include "../../../Core/VideoCommon/Src/VertexLoader_Normal.h" #include "../../../Core/VideoCommon/Src/VertexLoader_Normal.h"
#include "../../../Core/VideoCommon/Src/VertexLoader_Color.h" #include "../../../Core/VideoCommon/Src/VertexLoader_Color.h"
@ -28,19 +28,18 @@
#include "TransformUnit.h" #include "TransformUnit.h"
#include "SetupUnit.h" #include "SetupUnit.h"
#include "Statistics.h" #include "SWStatistics.h"
#include "VertexManagerBase.h" #include "VertexManagerBase.h"
#include "../../../Core/VideoCommon/Src/DataReader.h" #include "../../../Core/VideoCommon/Src/DataReader.h"
// Vertex loaders read these // Vertex loaders read these
int tcIndex; static int tcIndex;
int colIndex; static int colIndex;
int colElements[2]; static int colElements[2];
float posScale; static float posScale;
float tcScale[8]; static float tcScale[8];
SWVertexLoader::SWVertexLoader() :
VertexLoader::VertexLoader() :
m_VertexSize(0), m_VertexSize(0),
m_NumAttributeLoaders(0) m_NumAttributeLoaders(0)
{ {
@ -51,13 +50,13 @@ VertexLoader::VertexLoader() :
m_SetupUnit = new SetupUnit; m_SetupUnit = new SetupUnit;
} }
VertexLoader::~VertexLoader() SWVertexLoader::~SWVertexLoader()
{ {
delete m_SetupUnit; delete m_SetupUnit;
m_SetupUnit = NULL; m_SetupUnit = NULL;
} }
void VertexLoader::SetFormat(u8 attributeIndex, u8 primitiveType) void SWVertexLoader::SetFormat(u8 attributeIndex, u8 primitiveType)
{ {
m_CurrentVat = &g_VtxAttr[attributeIndex]; m_CurrentVat = &g_VtxAttr[attributeIndex];
@ -107,15 +106,15 @@ void VertexLoader::SetFormat(u8 attributeIndex, u8 primitiveType)
// Reset vertex // Reset vertex
// matrix index from xf regs or cp memory? // matrix index from xf regs or cp memory?
if (xfregs.MatrixIndexA.PosNormalMtxIdx != MatrixIndexA.PosNormalMtxIdx || if (swxfregs.MatrixIndexA.PosNormalMtxIdx != MatrixIndexA.PosNormalMtxIdx ||
xfregs.MatrixIndexA.Tex0MtxIdx != MatrixIndexA.Tex0MtxIdx || swxfregs.MatrixIndexA.Tex0MtxIdx != MatrixIndexA.Tex0MtxIdx ||
xfregs.MatrixIndexA.Tex1MtxIdx != MatrixIndexA.Tex1MtxIdx || swxfregs.MatrixIndexA.Tex1MtxIdx != MatrixIndexA.Tex1MtxIdx ||
xfregs.MatrixIndexA.Tex2MtxIdx != MatrixIndexA.Tex2MtxIdx || swxfregs.MatrixIndexA.Tex2MtxIdx != MatrixIndexA.Tex2MtxIdx ||
xfregs.MatrixIndexA.Tex3MtxIdx != MatrixIndexA.Tex3MtxIdx || swxfregs.MatrixIndexA.Tex3MtxIdx != MatrixIndexA.Tex3MtxIdx ||
xfregs.MatrixIndexB.Tex4MtxIdx != MatrixIndexB.Tex4MtxIdx || swxfregs.MatrixIndexB.Tex4MtxIdx != MatrixIndexB.Tex4MtxIdx ||
xfregs.MatrixIndexB.Tex5MtxIdx != MatrixIndexB.Tex5MtxIdx || swxfregs.MatrixIndexB.Tex5MtxIdx != MatrixIndexB.Tex5MtxIdx ||
xfregs.MatrixIndexB.Tex6MtxIdx != MatrixIndexB.Tex6MtxIdx || swxfregs.MatrixIndexB.Tex6MtxIdx != MatrixIndexB.Tex6MtxIdx ||
xfregs.MatrixIndexB.Tex7MtxIdx != MatrixIndexB.Tex7MtxIdx) swxfregs.MatrixIndexB.Tex7MtxIdx != MatrixIndexB.Tex7MtxIdx)
{ {
WARN_LOG(VIDEO, "Matrix indices don't match"); WARN_LOG(VIDEO, "Matrix indices don't match");
@ -126,15 +125,15 @@ void VertexLoader::SetFormat(u8 attributeIndex, u8 primitiveType)
} }
#if(1) #if(1)
m_Vertex.posMtx = xfregs.MatrixIndexA.PosNormalMtxIdx; m_Vertex.posMtx = swxfregs.MatrixIndexA.PosNormalMtxIdx;
m_Vertex.texMtx[0] = xfregs.MatrixIndexA.Tex0MtxIdx; m_Vertex.texMtx[0] = swxfregs.MatrixIndexA.Tex0MtxIdx;
m_Vertex.texMtx[1] = xfregs.MatrixIndexA.Tex1MtxIdx; m_Vertex.texMtx[1] = swxfregs.MatrixIndexA.Tex1MtxIdx;
m_Vertex.texMtx[2] = xfregs.MatrixIndexA.Tex2MtxIdx; m_Vertex.texMtx[2] = swxfregs.MatrixIndexA.Tex2MtxIdx;
m_Vertex.texMtx[3] = xfregs.MatrixIndexA.Tex3MtxIdx; m_Vertex.texMtx[3] = swxfregs.MatrixIndexA.Tex3MtxIdx;
m_Vertex.texMtx[4] = xfregs.MatrixIndexB.Tex4MtxIdx; m_Vertex.texMtx[4] = swxfregs.MatrixIndexB.Tex4MtxIdx;
m_Vertex.texMtx[5] = xfregs.MatrixIndexB.Tex5MtxIdx; m_Vertex.texMtx[5] = swxfregs.MatrixIndexB.Tex5MtxIdx;
m_Vertex.texMtx[6] = xfregs.MatrixIndexB.Tex6MtxIdx; m_Vertex.texMtx[6] = swxfregs.MatrixIndexB.Tex6MtxIdx;
m_Vertex.texMtx[7] = xfregs.MatrixIndexB.Tex7MtxIdx; m_Vertex.texMtx[7] = swxfregs.MatrixIndexB.Tex7MtxIdx;
#else #else
m_Vertex.posMtx = MatrixIndexA.PosNormalMtxIdx; m_Vertex.posMtx = MatrixIndexA.PosNormalMtxIdx;
m_Vertex.texMtx[0] = MatrixIndexA.Tex0MtxIdx; m_Vertex.texMtx[0] = MatrixIndexA.Tex0MtxIdx;
@ -245,14 +244,14 @@ void VertexLoader::SetFormat(u8 attributeIndex, u8 primitiveType)
m_TexGenSpecialCase = m_TexGenSpecialCase =
((g_VtxDesc.Hex & 0x60600L) == g_VtxDesc.Hex) && // only pos and tex coord 0 ((g_VtxDesc.Hex & 0x60600L) == g_VtxDesc.Hex) && // only pos and tex coord 0
(g_VtxDesc.Tex0Coord != NOT_PRESENT) && (g_VtxDesc.Tex0Coord != NOT_PRESENT) &&
(xfregs.texMtxInfo[0].projection == XF_TEXPROJ_ST); (swxfregs.texMtxInfo[0].projection == XF_TEXPROJ_ST);
m_SetupUnit->Init(primitiveType); m_SetupUnit->Init(primitiveType);
} }
void VertexLoader::LoadVertex() void SWVertexLoader::LoadVertex()
{ {
for (int i = 0; i < m_NumAttributeLoaders; i++) for (int i = 0; i < m_NumAttributeLoaders; i++)
m_AttributeLoaders[i].loader(this, &m_Vertex, m_AttributeLoaders[i].index); m_AttributeLoaders[i].loader(this, &m_Vertex, m_AttributeLoaders[i].index);
@ -273,39 +272,39 @@ void VertexLoader::LoadVertex()
m_SetupUnit->SetupVertex(); m_SetupUnit->SetupVertex();
INCSTAT(stats.thisFrame.numVerticesLoaded) INCSTAT(swstats.thisFrame.numVerticesLoaded)
} }
void VertexLoader::AddAttributeLoader(AttributeLoader loader, u8 index) void SWVertexLoader::AddAttributeLoader(AttributeLoader loader, u8 index)
{ {
_assert_msg_(VIDEO, m_NumAttributeLoaders < 21, "Too many attribute loaders"); _assert_msg_(VIDEO, m_NumAttributeLoaders < 21, "Too many attribute loaders");
m_AttributeLoaders[m_NumAttributeLoaders].loader = loader; m_AttributeLoaders[m_NumAttributeLoaders].loader = loader;
m_AttributeLoaders[m_NumAttributeLoaders++].index = index; m_AttributeLoaders[m_NumAttributeLoaders++].index = index;
} }
void VertexLoader::LoadPosMtx(VertexLoader *vertexLoader, InputVertexData *vertex, u8 unused) void SWVertexLoader::LoadPosMtx(SWVertexLoader *vertexLoader, InputVertexData *vertex, u8 unused)
{ {
vertex->posMtx = DataReadU8() & 0x3f; vertex->posMtx = DataReadU8() & 0x3f;
} }
void VertexLoader::LoadTexMtx(VertexLoader *vertexLoader, InputVertexData *vertex, u8 index) void SWVertexLoader::LoadTexMtx(SWVertexLoader *vertexLoader, InputVertexData *vertex, u8 index)
{ {
vertex->texMtx[index] = DataReadU8() & 0x3f; vertex->texMtx[index] = DataReadU8() & 0x3f;
} }
void VertexLoader::LoadPosition(VertexLoader *vertexLoader, InputVertexData *vertex, u8 unused) void SWVertexLoader::LoadPosition(SWVertexLoader *vertexLoader, InputVertexData *vertex, u8 unused)
{ {
VertexManager::s_pCurBufferPointer = (u8*)&vertex->position; VertexManager::s_pCurBufferPointer = (u8*)&vertex->position;
vertexLoader->m_positionLoader(); vertexLoader->m_positionLoader();
} }
void VertexLoader::LoadNormal(VertexLoader *vertexLoader, InputVertexData *vertex, u8 unused) void SWVertexLoader::LoadNormal(SWVertexLoader *vertexLoader, InputVertexData *vertex, u8 unused)
{ {
VertexManager::s_pCurBufferPointer = (u8*)&vertex->normal; VertexManager::s_pCurBufferPointer = (u8*)&vertex->normal;
vertexLoader->m_normalLoader(); vertexLoader->m_normalLoader();
} }
void VertexLoader::LoadColor(VertexLoader *vertexLoader, InputVertexData *vertex, u8 index) void SWVertexLoader::LoadColor(SWVertexLoader *vertexLoader, InputVertexData *vertex, u8 index)
{ {
u32 color; u32 color;
VertexManager::s_pCurBufferPointer = (u8*)&color; VertexManager::s_pCurBufferPointer = (u8*)&color;
@ -316,7 +315,7 @@ void VertexLoader::LoadColor(VertexLoader *vertexLoader, InputVertexData *vertex
*(u32*)vertex->color[index] = Common::swap32(color); *(u32*)vertex->color[index] = Common::swap32(color);
} }
void VertexLoader::LoadTexCoord(VertexLoader *vertexLoader, InputVertexData *vertex, u8 index) void SWVertexLoader::LoadTexCoord(SWVertexLoader *vertexLoader, InputVertexData *vertex, u8 index)
{ {
VertexManager::s_pCurBufferPointer = (u8*)&vertex->texCoords[index]; VertexManager::s_pCurBufferPointer = (u8*)&vertex->texCoords[index];
tcIndex = index; tcIndex = index;

20
Source/Plugins/Plugin_VideoSoftware/Src/VertexLoader.h → Source/Plugins/Plugin_VideoSoftware/Src/SWVertexLoader.h
View File

@ -25,7 +25,7 @@
class SetupUnit; class SetupUnit;
class VertexLoader class SWVertexLoader
{ {
u32 m_VertexSize; u32 m_VertexSize;
@ -38,7 +38,7 @@ class VertexLoader
InputVertexData m_Vertex; InputVertexData m_Vertex;
typedef void (*AttributeLoader)(VertexLoader*, InputVertexData*, u8); typedef void (*AttributeLoader)(SWVertexLoader*, InputVertexData*, u8);
struct AttrLoaderCall struct AttrLoaderCall
{ {
AttributeLoader loader; AttributeLoader loader;
@ -49,20 +49,20 @@ class VertexLoader
void AddAttributeLoader(AttributeLoader loader, u8 index=0); void AddAttributeLoader(AttributeLoader loader, u8 index=0);
// attribute loader functions // attribute loader functions
static void LoadPosMtx(VertexLoader *vertexLoader, InputVertexData *vertex, u8 unused); static void LoadPosMtx(SWVertexLoader *vertexLoader, InputVertexData *vertex, u8 unused);
static void LoadTexMtx(VertexLoader *vertexLoader, InputVertexData *vertex, u8 index); static void LoadTexMtx(SWVertexLoader *vertexLoader, InputVertexData *vertex, u8 index);
static void LoadPosition(VertexLoader *vertexLoader, InputVertexData *vertex, u8 unused); static void LoadPosition(SWVertexLoader *vertexLoader, InputVertexData *vertex, u8 unused);
static void LoadNormal(VertexLoader *vertexLoader, InputVertexData *vertex, u8 unused); static void LoadNormal(SWVertexLoader *vertexLoader, InputVertexData *vertex, u8 unused);
static void LoadColor(VertexLoader *vertexLoader, InputVertexData *vertex, u8 index); static void LoadColor(SWVertexLoader *vertexLoader, InputVertexData *vertex, u8 index);
static void LoadTexCoord(VertexLoader *vertexLoader, InputVertexData *vertex, u8 index); static void LoadTexCoord(SWVertexLoader *vertexLoader, InputVertexData *vertex, u8 index);
SetupUnit *m_SetupUnit; SetupUnit *m_SetupUnit;
bool m_TexGenSpecialCase; bool m_TexGenSpecialCase;
public: public:
VertexLoader(); SWVertexLoader();
~VertexLoader(); ~SWVertexLoader();
void SetFormat(u8 attributeIndex, u8 primitiveType); void SetFormat(u8 attributeIndex, u8 primitiveType);

30
Source/Plugins/Plugin_VideoSoftware/Src/main.cpp → Source/Plugins/Plugin_VideoSoftware/Src/SWmain.cpp
View File

@ -22,16 +22,15 @@
#include "VideoConfigDialog.h" #include "VideoConfigDialog.h"
#endif // HAVE_WX #endif // HAVE_WX
#include "CommandProcessor.h" #include "SWCommandProcessor.h"
#include "OpcodeDecoder.h" #include "OpcodeDecoder.h"
#include "SWVideoConfig.h" #include "SWVideoConfig.h"
#include "PixelEngine.h" #include "SWPixelEngine.h"
#include "CommandProcessor.h"
#include "BPMemLoader.h" #include "BPMemLoader.h"
#include "XFMemLoader.h" #include "XFMemLoader.h"
#include "Clipper.h" #include "Clipper.h"
#include "Rasterizer.h" #include "Rasterizer.h"
#include "Renderer.h" #include "SWRenderer.h"
#include "../../../Core/VideoCommon/Src/LookUpTables.h" #include "../../../Core/VideoCommon/Src/LookUpTables.h"
#include "HwRasterizer.h" #include "HwRasterizer.h"
#include "LogManager.h" #include "LogManager.h"
@ -68,13 +67,13 @@ void VideoBackend::Initialize()
InitBPMemory(); InitBPMemory();
InitXFMemory(); InitXFMemory();
CommandProcessor::Init(); SWCommandProcessor::Init();
PixelEngine::Init(); SWPixelEngine::Init();
OpcodeDecoder::Init(); OpcodeDecoder::Init();
Clipper::Init(); Clipper::Init();
Rasterizer::Init(); Rasterizer::Init();
HwRasterizer::Init(); HwRasterizer::Init();
Renderer::Init(); SWRenderer::Init();
DebugUtil::Init(); DebugUtil::Init();
} }
@ -95,14 +94,14 @@ void VideoBackend::EmuStateChange(EMUSTATE_CHANGE newState)
void VideoBackend::Shutdown() void VideoBackend::Shutdown()
{ {
Renderer::Shutdown(); SWRenderer::Shutdown();
OpenGL_Shutdown(); OpenGL_Shutdown();
} }
// This is called after Video_Initialize() from the Core // This is called after Video_Initialize() from the Core
void VideoBackend::Video_Prepare() void VideoBackend::Video_Prepare()
{ {
Renderer::Prepare(); SWRenderer::Prepare();
INFO_LOG(VIDEO, "Video plugin initialized."); INFO_LOG(VIDEO, "Video plugin initialized.");
} }
@ -169,6 +168,10 @@ void VideoBackend::Video_AddMessage(const char* pstr, u32 milliseconds)
{ {
} }
void VideoBackend::Video_ClearMessages()
{
}
void VideoBackend::Video_SetRendering(bool bEnabled) void VideoBackend::Video_SetRendering(bool bEnabled)
{ {
Fifo_SetRendering(bEnabled); Fifo_SetRendering(bEnabled);
@ -176,7 +179,6 @@ void VideoBackend::Video_SetRendering(bool bEnabled)
void VideoBackend::Video_WaitForFrameFinish(void) void VideoBackend::Video_WaitForFrameFinish(void)
{ {
} }
bool VideoBackend::Video_IsFifoBusy(void) bool VideoBackend::Video_IsFifoBusy(void)
@ -186,7 +188,15 @@ bool VideoBackend::Video_IsFifoBusy(void)
void VideoBackend::Video_AbortFrame(void) void VideoBackend::Video_AbortFrame(void)
{ {
}
void VideoBackend::UpdateFPSDisplay(const char*)
{
}
unsigned int VideoBackend::PeekMessages()
{
return 0;
} }
} }

2
Source/Plugins/Plugin_VideoSoftware/Src/SetupUnit.cpp
View File

@ -19,7 +19,7 @@
#include "CPMemLoader.h" #include "CPMemLoader.h"
#include "OpcodeDecoder.h" #include "OpcodeDecoder.h"
#include "Statistics.h" #include "SWStatistics.h"
#include "Clipper.h" #include "Clipper.h"

6
Source/Plugins/Plugin_VideoSoftware/Src/Tev.cpp
View File

@ -20,7 +20,7 @@
#include "Tev.h" #include "Tev.h"
#include "EfbInterface.h" #include "EfbInterface.h"
#include "TextureSampler.h" #include "TextureSampler.h"
#include "Statistics.h" #include "SWStatistics.h"
#include "SWVideoConfig.h" #include "SWVideoConfig.h"
#include "DebugUtil.h" #include "DebugUtil.h"
@ -581,7 +581,7 @@ void Tev::Draw()
_assert_(Position[0] >= 0 && Position[0] < EFB_WIDTH); _assert_(Position[0] >= 0 && Position[0] < EFB_WIDTH);
_assert_(Position[1] >= 0 && Position[1] < EFB_HEIGHT); _assert_(Position[1] >= 0 && Position[1] < EFB_HEIGHT);
INCSTAT(stats.thisFrame.tevPixelsIn); INCSTAT(swstats.thisFrame.tevPixelsIn);
for (unsigned int stageNum = 0; stageNum < bpmem.genMode.numindstages; stageNum++) for (unsigned int stageNum = 0; stageNum < bpmem.genMode.numindstages; stageNum++)
{ {
@ -810,7 +810,7 @@ void Tev::Draw()
} }
#endif #endif
INCSTAT(stats.thisFrame.tevPixelsOut); INCSTAT(swstats.thisFrame.tevPixelsOut);
EfbInterface::BlendTev(Position[0], Position[1], output); EfbInterface::BlendTev(Position[0], Position[1], output);
} }

1
Source/Plugins/Plugin_VideoSoftware/Src/TextureSampler.cpp
View File

@ -16,7 +16,6 @@
#include "TextureSampler.h" #include "TextureSampler.h"
#include "main.h"
#include "BPMemLoader.h" #include "BPMemLoader.h"
#include "../../../Core/VideoCommon/Src/TextureDecoder.h" #include "../../../Core/VideoCommon/Src/TextureDecoder.h"

46
Source/Plugins/Plugin_VideoSoftware/Src/TransformUnit.cpp
View File

@ -85,22 +85,22 @@ void MultipleVec3Ortho(const Vec3 &vec, const float *proj, Vec4 &result)
void TransformPosition(const InputVertexData *src, OutputVertexData *dst) void TransformPosition(const InputVertexData *src, OutputVertexData *dst)
{ {
const float* mat = (const float*)&xfregs.posMatrices[src->posMtx * 4]; const float* mat = (const float*)&swxfregs.posMatrices[src->posMtx * 4];
MultiplyVec3Mat34(src->position, mat, dst->mvPosition); MultiplyVec3Mat34(src->position, mat, dst->mvPosition);
if (xfregs.projection[6] == 0) if (swxfregs.projection[6] == 0)
{ {
MultipleVec3Perspective(dst->mvPosition, xfregs.projection, dst->projectedPosition); MultipleVec3Perspective(dst->mvPosition, swxfregs.projection, dst->projectedPosition);
} }
else else
{ {
MultipleVec3Ortho(dst->mvPosition, xfregs.projection, dst->projectedPosition); MultipleVec3Ortho(dst->mvPosition, swxfregs.projection, dst->projectedPosition);
} }
} }
void TransformNormal(const InputVertexData *src, bool nbt, OutputVertexData *dst) void TransformNormal(const InputVertexData *src, bool nbt, OutputVertexData *dst)
{ {
const float* mat = (const float*)&xfregs.normalMatrices[(src->posMtx & 31) * 3]; const float* mat = (const float*)&swxfregs.normalMatrices[(src->posMtx & 31) * 3];
if (nbt) if (nbt)
{ {
@ -139,7 +139,7 @@ inline void TransformTexCoordRegular(const TexMtxInfo &texinfo, int coordNum, bo
break; break;
} }
const float *mat = (const float*)&xfregs.posMatrices[srcVertex->texMtx[coordNum] * 4]; const float *mat = (const float*)&swxfregs.posMatrices[srcVertex->texMtx[coordNum] * 4];
Vec3 *dst = &dstVertex->texCoords[coordNum]; Vec3 *dst = &dstVertex->texCoords[coordNum];
if (texinfo.projection == XF_TEXPROJ_ST) if (texinfo.projection == XF_TEXPROJ_ST)
@ -159,13 +159,13 @@ inline void TransformTexCoordRegular(const TexMtxInfo &texinfo, int coordNum, bo
MultiplyVec3Mat34(*src, mat, *dst); MultiplyVec3Mat34(*src, mat, *dst);
} }
if (xfregs.dualTexTrans) if (swxfregs.dualTexTrans)
{ {
Vec3 tempCoord; Vec3 tempCoord;
// normalize // normalize
const PostMtxInfo &postInfo = xfregs.postMtxInfo[coordNum]; const PostMtxInfo &postInfo = swxfregs.postMtxInfo[coordNum];
const float *postMat = (const float*)&xfregs.postMatrices[postInfo.index * 4]; const float *postMat = (const float*)&swxfregs.postMatrices[postInfo.index * 4];
if (specialCase) if (specialCase)
{ {
@ -227,7 +227,7 @@ inline float SafeDivide(float n, float d)
void LightColor(const Vec3 &pos, const Vec3 &normal, u8 lightNum, const LitChannel &chan, Vec3 &lightCol) void LightColor(const Vec3 &pos, const Vec3 &normal, u8 lightNum, const LitChannel &chan, Vec3 &lightCol)
{ {
const LightPointer *light = (const LightPointer*)&xfregs.lights[0x10*lightNum]; const LightPointer *light = (const LightPointer*)&swxfregs.lights[0x10*lightNum];
if (!(chan.attnfunc & 1)) { if (!(chan.attnfunc & 1)) {
// atten disabled // atten disabled
@ -304,7 +304,7 @@ void LightColor(const Vec3 &pos, const Vec3 &normal, u8 lightNum, const LitChann
void LightAlpha(const Vec3 &pos, const Vec3 &normal, u8 lightNum, const LitChannel &chan, float &lightCol) void LightAlpha(const Vec3 &pos, const Vec3 &normal, u8 lightNum, const LitChannel &chan, float &lightCol)
{ {
const LightPointer *light = (const LightPointer*)&xfregs.lights[0x10*lightNum]; const LightPointer *light = (const LightPointer*)&swxfregs.lights[0x10*lightNum];
if (!(chan.attnfunc & 1)) { if (!(chan.attnfunc & 1)) {
// atten disabled // atten disabled
@ -377,18 +377,18 @@ void LightAlpha(const Vec3 &pos, const Vec3 &normal, u8 lightNum, const LitChann
void TransformColor(const InputVertexData *src, OutputVertexData *dst) void TransformColor(const InputVertexData *src, OutputVertexData *dst)
{ {
for (u32 chan = 0; chan < xfregs.nNumChans; chan++) for (u32 chan = 0; chan < swxfregs.nNumChans; chan++)
{ {
// abgr // abgr
u8 matcolor[4]; u8 matcolor[4];
u8 chancolor[4]; u8 chancolor[4];
// color // color
LitChannel &colorchan = xfregs.color[chan]; LitChannel &colorchan = swxfregs.color[chan];
if (colorchan.matsource) if (colorchan.matsource)
*(u32*)matcolor = *(u32*)src->color[chan]; // vertex *(u32*)matcolor = *(u32*)src->color[chan]; // vertex
else else
*(u32*)matcolor = xfregs.matColor[chan]; *(u32*)matcolor = swxfregs.matColor[chan];
if (colorchan.enablelighting) if (colorchan.enablelighting)
{ {
@ -402,7 +402,7 @@ void TransformColor(const InputVertexData *src, OutputVertexData *dst)
} }
else else
{ {
u8 *ambColor = (u8*)&xfregs.ambColor[chan]; u8 *ambColor = (u8*)&swxfregs.ambColor[chan];
lightCol.x = ambColor[1]; lightCol.x = ambColor[1];
lightCol.y = ambColor[2]; lightCol.y = ambColor[2];
lightCol.z = ambColor[3]; lightCol.z = ambColor[3];
@ -425,19 +425,19 @@ void TransformColor(const InputVertexData *src, OutputVertexData *dst)
} }
// alpha // alpha
LitChannel &alphachan = xfregs.alpha[chan]; LitChannel &alphachan = swxfregs.alpha[chan];
if (alphachan.matsource) if (alphachan.matsource)
matcolor[0] = src->color[chan][0]; // vertex matcolor[0] = src->color[chan][0]; // vertex
else else
matcolor[0] = xfregs.matColor[chan] & 0xff; matcolor[0] = swxfregs.matColor[chan] & 0xff;
if (xfregs.alpha[chan].enablelighting) if (swxfregs.alpha[chan].enablelighting)
{ {
float lightCol; float lightCol;
if (alphachan.ambsource) if (alphachan.ambsource)
lightCol = src->color[chan][0]; // vertex lightCol = src->color[chan][0]; // vertex
else else
lightCol = (float)(xfregs.ambColor[chan] & 0xff); lightCol = (float)(swxfregs.ambColor[chan] & 0xff);
u8 mask = alphachan.GetFullLightMask(); u8 mask = alphachan.GetFullLightMask();
for (int i = 0; i < 8; ++i) { for (int i = 0; i < 8; ++i) {
@ -459,9 +459,9 @@ void TransformColor(const InputVertexData *src, OutputVertexData *dst)
void TransformTexCoord(const InputVertexData *src, OutputVertexData *dst, bool specialCase) void TransformTexCoord(const InputVertexData *src, OutputVertexData *dst, bool specialCase)
{ {
for (u32 coordNum = 0; coordNum < xfregs.numTexGens; coordNum++) for (u32 coordNum = 0; coordNum < swxfregs.numTexGens; coordNum++)
{ {
const TexMtxInfo &texinfo = xfregs.texMtxInfo[coordNum]; const TexMtxInfo &texinfo = swxfregs.texMtxInfo[coordNum];
switch (texinfo.texgentype) switch (texinfo.texgentype)
{ {
@ -470,7 +470,7 @@ void TransformTexCoord(const InputVertexData *src, OutputVertexData *dst, bool s
break; break;
case XF_TEXGEN_EMBOSS_MAP: case XF_TEXGEN_EMBOSS_MAP:
{ {
const LightPointer *light = (const LightPointer*)&xfregs.lights[0x10*texinfo.embosslightshift]; const LightPointer *light = (const LightPointer*)&swxfregs.lights[0x10*texinfo.embosslightshift];
Vec3 ldir = (light->pos - dst->mvPosition).normalized(); Vec3 ldir = (light->pos - dst->mvPosition).normalized();
float d1 = ldir * dst->normal[1]; float d1 = ldir * dst->normal[1];
@ -500,7 +500,7 @@ void TransformTexCoord(const InputVertexData *src, OutputVertexData *dst, bool s
} }
} }
for (u32 coordNum = 0; coordNum < xfregs.numTexGens; coordNum++) for (u32 coordNum = 0; coordNum < swxfregs.numTexGens; coordNum++)
{ {
dst->texCoords[coordNum][0] *= (bpmem.texcoords[coordNum].s.scale_minus_1 + 1); dst->texCoords[coordNum][0] *= (bpmem.texcoords[coordNum].s.scale_minus_1 + 1);
dst->texCoords[coordNum][1] *= (bpmem.texcoords[coordNum].t.scale_minus_1 + 1); dst->texCoords[coordNum][1] *= (bpmem.texcoords[coordNum].t.scale_minus_1 + 1);

1
Source/Plugins/Plugin_VideoSoftware/Src/VideoBackend.h
View File

@ -29,6 +29,7 @@ class VideoBackend : public VideoBackendLLE
u32 Video_AccessEFB(EFBAccessType, u32, u32, u32); u32 Video_AccessEFB(EFBAccessType, u32, u32, u32);
void Video_AddMessage(const char* pstr, unsigned int milliseconds); void Video_AddMessage(const char* pstr, unsigned int milliseconds);
void Video_ClearMessages();
bool Video_Screenshot(const char* filename); bool Video_Screenshot(const char* filename);
void Video_SetRendering(bool bEnabled); void Video_SetRendering(bool bEnabled);

4
Source/Plugins/Plugin_VideoSoftware/Src/VideoConfigDialog.cpp
View File

@ -22,10 +22,10 @@
#define _connect_macro_(b, f, c, s) (b)->Connect(wxID_ANY, (c), wxCommandEventHandler( f ), (wxObject*)0, (wxEvtHandler*)s) #define _connect_macro_(b, f, c, s) (b)->Connect(wxID_ANY, (c), wxCommandEventHandler( f ), (wxObject*)0, (wxEvtHandler*)s)
// template instantiation // template instantiation
template class BoolSetting<wxCheckBox>; template class _BoolSetting<wxCheckBox>;
template <> template <>
SettingCheckBox::BoolSetting(wxWindow* parent, const wxString& label, bool &setting, bool reverse, long style) : SettingCheckBox::_BoolSetting(wxWindow* parent, const wxString& label, bool &setting, bool reverse, long style) :
wxCheckBox(parent, -1, label, wxDefaultPosition, wxDefaultSize, style), wxCheckBox(parent, -1, label, wxDefaultPosition, wxDefaultSize, style),
m_setting(setting), m_setting(setting),
m_reverse(reverse) m_reverse(reverse)

6
Source/Plugins/Plugin_VideoSoftware/Src/VideoConfigDialog.h
View File

@ -34,10 +34,10 @@
#include <wx/spinctrl.h> #include <wx/spinctrl.h>
template <typename W> template <typename W>
class BoolSetting : public W class _BoolSetting : public W
{ {
public: public:
BoolSetting(wxWindow* parent, const wxString& label, bool &setting, bool reverse = false, long style = 0); _BoolSetting(wxWindow* parent, const wxString& label, bool &setting, bool reverse = false, long style = 0);
void UpdateValue(wxCommandEvent& ev) void UpdateValue(wxCommandEvent& ev)
{ {
@ -64,7 +64,7 @@ private:
T& m_setting; T& m_setting;
}; };
typedef BoolSetting<wxCheckBox> SettingCheckBox; typedef _BoolSetting<wxCheckBox> SettingCheckBox;
typedef IntegerSetting<u32> U32Setting; typedef IntegerSetting<u32> U32Setting;
class VideoConfigDialog : public wxDialog class VideoConfigDialog : public wxDialog

2
Source/Plugins/Plugin_VideoSoftware/Src/Win32.cpp
View File

@ -24,8 +24,8 @@
#include <wx/aboutdlg.h> #include <wx/aboutdlg.h>
#include "ConfigManager.h" #include "ConfigManager.h"
#include "VideoBackend.h"
#include "SWVideoConfig.h" #include "SWVideoConfig.h"
#include "main.h"
#include "Win32.h" #include "Win32.h"
#include "StringUtil.h" #include "StringUtil.h"

14
Source/Plugins/Plugin_VideoSoftware/Src/XFMemLoader.cpp
View File

@ -22,11 +22,11 @@
#include "Clipper.h" #include "Clipper.h"
#include "HW/Memmap.h" #include "HW/Memmap.h"
XFRegisters xfregs; XFRegisters swxfregs;
void InitXFMemory() void InitXFMemory()
{ {
memset(&xfregs, 0, sizeof(xfregs)); memset(&swxfregs, 0, sizeof(swxfregs));
} }
void XFWritten(u32 transferSize, u32 baseAddress) void XFWritten(u32 transferSize, u32 baseAddress)
@ -39,7 +39,7 @@ void XFWritten(u32 transferSize, u32 baseAddress)
// fix lights so invalid values don't trash the lighting computations // fix lights so invalid values don't trash the lighting computations
if (baseAddress <= 0x067f && topAddress >= 0x0604) if (baseAddress <= 0x067f && topAddress >= 0x0604)
{ {
u32* x = xfregs.lights; u32* x = swxfregs.lights;
// go through all lights // go through all lights
for (int light = 0; light < 8; light++) for (int light = 0; light < 8; light++)
@ -61,7 +61,7 @@ void XFWritten(u32 transferSize, u32 baseAddress)
} }
} }
void LoadXFReg(u32 transferSize, u32 baseAddress, u32 *pData) void SWLoadXFReg(u32 transferSize, u32 baseAddress, u32 *pData)
{ {
u32 size = transferSize; u32 size = transferSize;
@ -77,13 +77,13 @@ void LoadXFReg(u32 transferSize, u32 baseAddress, u32 *pData)
} }
if (size > 0) { if (size > 0) {
memcpy_gc( &((u32*)&xfregs)[baseAddress], pData, size * 4); memcpy_gc( &((u32*)&swxfregs)[baseAddress], pData, size * 4);
XFWritten(transferSize, baseAddress); XFWritten(transferSize, baseAddress);
} }
} }
void LoadIndexedXF(u32 val, int array) void SWLoadIndexedXF(u32 val, int array)
{ {
int index = val >> 16; int index = val >> 16;
int address = val & 0xFFF; //check mask int address = val & 0xFFF; //check mask
@ -97,5 +97,5 @@ void LoadIndexedXF(u32 val, int array)
for (int i = 0; i < size; ++i) for (int i = 0; i < size; ++i)
buffer[i] = Common::swap32(*(pData + i)); buffer[i] = Common::swap32(*(pData + i));
LoadXFReg(size, address, buffer); SWLoadXFReg(size, address, buffer);
} }

6
Source/Plugins/Plugin_VideoSoftware/Src/XFMemLoader.h
View File

@ -236,14 +236,14 @@ struct XFRegisters
#define XFMEM_LIGHTS_END 0x680 #define XFMEM_LIGHTS_END 0x680
extern XFRegisters xfregs; extern XFRegisters swxfregs;
void InitXFMemory(); void InitXFMemory();
void XFWritten(u32 transferSize, u32 baseAddress); void XFWritten(u32 transferSize, u32 baseAddress);
void LoadXFReg(u32 transferSize, u32 baseAddress, u32 *pData); void SWLoadXFReg(u32 transferSize, u32 baseAddress, u32 *pData);
void LoadIndexedXF(u32 val, int array); void SWLoadIndexedXF(u32 val, int array);
#endif #endif

23
Source/Plugins/Plugin_VideoSoftware/Src/main.h
View File

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