2010-04-25 00:31:27 +00:00
|
|
|
/*
|
2009-02-09 21:15:56 +00:00
|
|
|
* Copyright (C) 2007-2009 Gabest
|
|
|
|
|
* http://www.gabest.org
|
|
|
|
|
*
|
|
|
|
|
* 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; either version 2, or (at your option)
|
|
|
|
|
* any later version.
|
2010-04-25 00:31:27 +00:00
|
|
|
*
|
2009-02-09 21:15:56 +00:00
|
|
|
* 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 for more details.
|
2010-04-25 00:31:27 +00:00
|
|
|
*
|
2009-02-09 21:15:56 +00:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
|
* along with GNU Make; see the file COPYING. If not, write to
|
2012-09-09 18:16:11 +00:00
|
|
|
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA USA.
|
2009-02-09 21:15:56 +00:00
|
|
|
* http://www.gnu.org/copyleft/gpl.html
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "stdafx.h"
|
|
|
|
|
#include "GSdx.h"
|
2015-10-26 21:30:34 +00:00
|
|
|
#include "GS.h"
|
2016-03-28 06:00:48 +00:00
|
|
|
#include "PSX/GPU.h"
|
2009-02-09 21:15:56 +00:00
|
|
|
|
2011-02-19 03:36:30 +00:00
|
|
|
static void* s_hModule;
|
|
|
|
|
|
2016-01-27 15:33:10 +00:00
|
|
|
#ifdef _WIN32
|
2009-06-03 12:09:04 +00:00
|
|
|
|
|
|
|
|
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
|
|
|
|
|
{
|
|
|
|
|
switch(ul_reason_for_call)
|
|
|
|
|
{
|
|
|
|
|
case DLL_PROCESS_ATTACH:
|
|
|
|
|
s_hModule = hModule;
|
|
|
|
|
case DLL_THREAD_ATTACH:
|
|
|
|
|
case DLL_THREAD_DETACH:
|
|
|
|
|
case DLL_PROCESS_DETACH:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
2009-02-09 21:15:56 +00:00
|
|
|
|
2017-04-08 15:54:27 +00:00
|
|
|
bool GSdxApp::LoadResource(int id, std::vector<char>& buff, const char* type)
|
2014-09-15 13:49:16 +00:00
|
|
|
{
|
|
|
|
|
buff.clear();
|
|
|
|
|
HRSRC hRsrc = FindResource((HMODULE)s_hModule, MAKEINTRESOURCE(id), type != NULL ? type : RT_RCDATA);
|
|
|
|
|
if(!hRsrc) return false;
|
|
|
|
|
HGLOBAL hGlobal = ::LoadResource((HMODULE)s_hModule, hRsrc);
|
|
|
|
|
if(!hGlobal) return false;
|
|
|
|
|
DWORD size = SizeofResource((HMODULE)s_hModule, hRsrc);
|
|
|
|
|
if(!size) return false;
|
2017-04-08 22:21:19 +00:00
|
|
|
// On Linux resources are always NULL terminated
|
|
|
|
|
// Add + 1 on size to do the same for compatibility sake (required by GSDeviceOGL)
|
|
|
|
|
buff.resize(size + 1);
|
2014-09-15 13:49:16 +00:00
|
|
|
memcpy(buff.data(), LockResource(hGlobal), size);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-19 03:36:30 +00:00
|
|
|
#else
|
|
|
|
|
|
2017-04-08 15:58:20 +00:00
|
|
|
#include "GSdxResources.h"
|
|
|
|
|
|
2017-04-08 15:54:27 +00:00
|
|
|
bool GSdxApp::LoadResource(int id, std::vector<char>& buff, const char* type)
|
2014-09-15 13:49:16 +00:00
|
|
|
{
|
2017-04-08 15:58:20 +00:00
|
|
|
std::string path;
|
|
|
|
|
switch (id) {
|
2017-04-08 16:14:26 +00:00
|
|
|
case IDR_COMMON_GLSL:
|
|
|
|
|
path = "/GSdx/res/glsl/common_header.glsl";
|
|
|
|
|
break;
|
|
|
|
|
case IDR_CONVERT_GLSL:
|
|
|
|
|
path = "/GSdx/res/glsl/convert.glsl";
|
|
|
|
|
break;
|
|
|
|
|
case IDR_FXAA_FX:
|
|
|
|
|
path = "/GSdx/res/fxaa.fx";
|
|
|
|
|
break;
|
|
|
|
|
case IDR_INTERLACE_GLSL:
|
|
|
|
|
path = "/GSdx/res/glsl/interlace.glsl";
|
|
|
|
|
break;
|
|
|
|
|
case IDR_MERGE_GLSL:
|
|
|
|
|
path = "/GSdx/res/glsl/merge.glsl";
|
|
|
|
|
break;
|
|
|
|
|
case IDR_SHADEBOOST_GLSL:
|
|
|
|
|
path = "/GSdx/res/glsl/shadeboost.glsl";
|
|
|
|
|
break;
|
|
|
|
|
case IDR_TFX_VGS_GLSL:
|
|
|
|
|
path = "/GSdx/res/glsl/tfx_vgs.glsl";
|
|
|
|
|
break;
|
|
|
|
|
case IDR_TFX_FS_GLSL:
|
|
|
|
|
path = "/GSdx/res/glsl/tfx_fs.glsl";
|
|
|
|
|
break;
|
|
|
|
|
case IDR_TFX_CL:
|
|
|
|
|
path = "/GSdx/res/tfx.cl";
|
|
|
|
|
break;
|
2017-04-08 15:58:20 +00:00
|
|
|
default:
|
|
|
|
|
printf("LoadResource not implemented for id %d\n", id);
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
GBytes *bytes = g_resource_lookup_data(GSdx_res_get_resource(), path.c_str(), G_RESOURCE_LOOKUP_FLAGS_NONE, nullptr);
|
|
|
|
|
|
|
|
|
|
size_t size = 0;
|
|
|
|
|
const void* data = g_bytes_get_data(bytes, &size);
|
|
|
|
|
|
|
|
|
|
if (data == nullptr || size == 0) {
|
|
|
|
|
printf("Failed to get data for resource: %d\n", id);
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2014-09-15 13:49:16 +00:00
|
|
|
buff.clear();
|
2017-04-08 15:58:20 +00:00
|
|
|
buff.resize(size + 1);
|
|
|
|
|
memcpy(buff.data(), data, size + 1);
|
|
|
|
|
|
|
|
|
|
g_bytes_unref(bytes);
|
|
|
|
|
|
|
|
|
|
return true;
|
2014-09-15 13:49:16 +00:00
|
|
|
}
|
|
|
|
|
|
2011-04-07 09:41:20 +00:00
|
|
|
size_t GSdxApp::GetPrivateProfileString(const char* lpAppName, const char* lpKeyName, const char* lpDefault, char* lpReturnedString, size_t nSize, const char* lpFileName)
|
2011-02-19 03:36:30 +00:00
|
|
|
{
|
2011-04-07 09:41:20 +00:00
|
|
|
BuildConfigurationMap(lpFileName);
|
|
|
|
|
|
|
|
|
|
std::string key(lpKeyName);
|
|
|
|
|
std::string value = m_configuration_map[key];
|
2011-04-08 17:41:04 +00:00
|
|
|
if (value.empty()) {
|
|
|
|
|
// save the value for futur call
|
|
|
|
|
m_configuration_map[key] = std::string(lpDefault);
|
2011-04-07 09:41:20 +00:00
|
|
|
strcpy(lpReturnedString, lpDefault);
|
2011-04-08 17:41:04 +00:00
|
|
|
} else
|
2011-04-07 09:41:20 +00:00
|
|
|
strcpy(lpReturnedString, value.c_str());
|
2011-02-19 03:36:30 +00:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-04-07 09:41:20 +00:00
|
|
|
bool GSdxApp::WritePrivateProfileString(const char* lpAppName, const char* lpKeyName, const char* pString, const char* lpFileName)
|
2011-02-19 03:36:30 +00:00
|
|
|
{
|
2011-04-07 09:41:20 +00:00
|
|
|
BuildConfigurationMap(lpFileName);
|
|
|
|
|
|
|
|
|
|
std::string key(lpKeyName);
|
|
|
|
|
std::string value(pString);
|
|
|
|
|
m_configuration_map[key] = value;
|
|
|
|
|
|
|
|
|
|
// Save config to a file
|
|
|
|
|
FILE* f = fopen(lpFileName, "w");
|
|
|
|
|
|
|
|
|
|
if (f == NULL) return false; // FIXME print a nice message
|
|
|
|
|
|
|
|
|
|
map<std::string,std::string>::iterator it;
|
|
|
|
|
for (it = m_configuration_map.begin(); it != m_configuration_map.end(); ++it) {
|
|
|
|
|
// Do not save the inifile key which is not an option
|
|
|
|
|
if (it->first.compare("inifile") == 0) continue;
|
|
|
|
|
|
2016-05-24 19:06:47 +00:00
|
|
|
// Only keep option that have a default value (allow to purge old option of the GSdx.ini)
|
|
|
|
|
if (!it->second.empty() && m_default_configuration.find(it->first) != m_default_configuration.end())
|
2011-04-08 17:41:04 +00:00
|
|
|
fprintf(f, "%s = %s\n", it->first.c_str(), it->second.c_str());
|
2011-04-07 09:41:20 +00:00
|
|
|
}
|
|
|
|
|
fclose(f);
|
2011-02-19 03:36:30 +00:00
|
|
|
|
2011-04-07 09:41:20 +00:00
|
|
|
return false;
|
2011-02-19 03:36:30 +00:00
|
|
|
}
|
|
|
|
|
|
2011-04-07 09:41:20 +00:00
|
|
|
int GSdxApp::GetPrivateProfileInt(const char* lpAppName, const char* lpKeyName, int nDefault, const char* lpFileName)
|
2011-02-19 03:36:30 +00:00
|
|
|
{
|
2011-04-07 09:41:20 +00:00
|
|
|
BuildConfigurationMap(lpFileName);
|
2011-02-19 03:36:30 +00:00
|
|
|
|
2011-04-07 09:41:20 +00:00
|
|
|
std::string value = m_configuration_map[std::string(lpKeyName)];
|
2011-04-08 17:41:04 +00:00
|
|
|
if (value.empty()) {
|
|
|
|
|
// save the value for futur call
|
|
|
|
|
SetConfig(lpKeyName, nDefault);
|
2011-04-07 09:41:20 +00:00
|
|
|
return nDefault;
|
2011-04-08 17:41:04 +00:00
|
|
|
} else
|
2011-04-07 09:41:20 +00:00
|
|
|
return atoi(value.c_str());
|
2011-02-19 03:36:30 +00:00
|
|
|
}
|
|
|
|
|
#endif
|
2009-02-09 21:15:56 +00:00
|
|
|
|
2011-02-19 03:36:30 +00:00
|
|
|
GSdxApp theApp;
|
2009-06-03 12:09:04 +00:00
|
|
|
|
2009-02-09 21:15:56 +00:00
|
|
|
GSdxApp::GSdxApp()
|
|
|
|
|
{
|
2016-07-23 22:13:04 +00:00
|
|
|
// Empty constructor causes an illegal instruction exception on an SSE4.2 machine on Windows.
|
|
|
|
|
// Non-empty doesn't, but raises a SIGILL signal when compiled against GCC 6.1.1.
|
|
|
|
|
// So here's a compromise.
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
|
Init();
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void GSdxApp::Init()
|
|
|
|
|
{
|
|
|
|
|
static bool is_initialised = false;
|
|
|
|
|
if (is_initialised)
|
|
|
|
|
return;
|
|
|
|
|
is_initialised = true;
|
|
|
|
|
|
2017-03-24 08:53:33 +00:00
|
|
|
m_current_renderer_type = GSRendererType::Undefined;
|
|
|
|
|
|
2016-08-03 23:42:50 +00:00
|
|
|
if (m_ini.empty())
|
|
|
|
|
m_ini = "inis/GSdx.ini";
|
2011-02-19 03:36:30 +00:00
|
|
|
m_section = "Settings";
|
|
|
|
|
|
2016-01-27 15:33:10 +00:00
|
|
|
#ifdef _WIN32
|
2017-02-23 21:51:10 +00:00
|
|
|
m_gs_renderers.push_back(GSSetting(static_cast<uint32>(GSRendererType::DX9_HW), "Direct3D 9", "Hardware"));
|
|
|
|
|
m_gs_renderers.push_back(GSSetting(static_cast<uint32>(GSRendererType::DX1011_HW), "Direct3D ", "Hardware"));
|
2015-12-30 17:06:54 +00:00
|
|
|
m_gs_renderers.push_back(GSSetting(static_cast<uint32>(GSRendererType::OGL_HW), "OpenGL", "Hardware"));
|
2017-02-23 21:51:10 +00:00
|
|
|
m_gs_renderers.push_back(GSSetting(static_cast<uint32>(GSRendererType::DX9_SW), "Direct3D 9", "Software"));
|
|
|
|
|
m_gs_renderers.push_back(GSSetting(static_cast<uint32>(GSRendererType::DX1011_SW), "Direct3D ", "Software"));
|
2015-12-30 17:06:54 +00:00
|
|
|
m_gs_renderers.push_back(GSSetting(static_cast<uint32>(GSRendererType::OGL_SW), "OpenGL", "Software"));
|
2015-12-30 17:52:01 +00:00
|
|
|
#else // Linux
|
|
|
|
|
m_gs_renderers.push_back(GSSetting(static_cast<uint32>(GSRendererType::OGL_HW), "OpenGL", "Hardware"));
|
|
|
|
|
m_gs_renderers.push_back(GSSetting(static_cast<uint32>(GSRendererType::OGL_SW), "OpenGL", "Software"));
|
2015-12-21 18:30:03 +00:00
|
|
|
#endif
|
2015-12-27 10:24:05 +00:00
|
|
|
|
2015-12-21 18:30:03 +00:00
|
|
|
// The null renderer goes third, it has use for benchmarking purposes in a release build
|
2016-05-01 16:33:53 +00:00
|
|
|
m_gs_renderers.push_back(GSSetting(static_cast<uint32>(GSRendererType::Null), "None", "Core Benchmark"));
|
2015-12-27 10:24:05 +00:00
|
|
|
|
2015-12-14 09:00:28 +00:00
|
|
|
#ifdef ENABLE_OPENCL
|
2015-12-21 18:30:03 +00:00
|
|
|
// OpenCL stuff goes last
|
2015-12-14 09:00:28 +00:00
|
|
|
// FIXME openCL isn't attached to a device (could be impacted by the window management stuff however)
|
2017-02-03 22:31:01 +00:00
|
|
|
#ifdef _WIN32
|
2017-02-23 21:51:10 +00:00
|
|
|
m_gs_renderers.push_back(GSSetting(static_cast<uint32>(GSRendererType::DX9_OpenCL), "Direct3D 9", "OpenCL"));
|
|
|
|
|
m_gs_renderers.push_back(GSSetting(static_cast<uint32>(GSRendererType::DX1011_OpenCL), "Direct3D 11", "OpenCL"));
|
2017-02-03 22:31:01 +00:00
|
|
|
#endif
|
2015-10-26 21:30:34 +00:00
|
|
|
m_gs_renderers.push_back(GSSetting(static_cast<uint32>(GSRendererType::OGL_OpenCL), "OpenGL", "OpenCL"));
|
2015-12-14 09:00:28 +00:00
|
|
|
#endif
|
2011-02-19 03:36:30 +00:00
|
|
|
|
|
|
|
|
m_gs_interlace.push_back(GSSetting(0, "None", ""));
|
|
|
|
|
m_gs_interlace.push_back(GSSetting(1, "Weave tff", "saw-tooth"));
|
|
|
|
|
m_gs_interlace.push_back(GSSetting(2, "Weave bff", "saw-tooth"));
|
|
|
|
|
m_gs_interlace.push_back(GSSetting(3, "Bob tff", "use blend if shaking"));
|
|
|
|
|
m_gs_interlace.push_back(GSSetting(4, "Bob bff", "use blend if shaking"));
|
|
|
|
|
m_gs_interlace.push_back(GSSetting(5, "Blend tff", "slight blur, 1/2 fps"));
|
|
|
|
|
m_gs_interlace.push_back(GSSetting(6, "Blend bff", "slight blur, 1/2 fps"));
|
2012-04-25 08:46:51 +00:00
|
|
|
m_gs_interlace.push_back(GSSetting(7, "Auto", ""));
|
2011-02-19 03:36:30 +00:00
|
|
|
|
|
|
|
|
m_gs_aspectratio.push_back(GSSetting(0, "Stretch", ""));
|
|
|
|
|
m_gs_aspectratio.push_back(GSSetting(1, "4:3", ""));
|
|
|
|
|
m_gs_aspectratio.push_back(GSSetting(2, "16:9", ""));
|
|
|
|
|
|
2015-09-08 12:55:01 +00:00
|
|
|
m_gs_upscale_multiplier.push_back(GSSetting(1, "Native", ""));
|
2011-02-19 03:36:30 +00:00
|
|
|
m_gs_upscale_multiplier.push_back(GSSetting(2, "2x Native", ""));
|
|
|
|
|
m_gs_upscale_multiplier.push_back(GSSetting(3, "3x Native", ""));
|
|
|
|
|
m_gs_upscale_multiplier.push_back(GSSetting(4, "4x Native", ""));
|
|
|
|
|
m_gs_upscale_multiplier.push_back(GSSetting(5, "5x Native", ""));
|
|
|
|
|
m_gs_upscale_multiplier.push_back(GSSetting(6, "6x Native", ""));
|
2015-09-08 15:25:58 +00:00
|
|
|
m_gs_upscale_multiplier.push_back(GSSetting(8, "8x Native", ""));
|
2016-05-01 09:43:18 +00:00
|
|
|
#ifndef __unix__
|
2015-09-21 20:26:00 +00:00
|
|
|
m_gs_upscale_multiplier.push_back(GSSetting(0, "Custom", ""));
|
2016-04-20 07:59:56 +00:00
|
|
|
#endif
|
2011-02-19 03:36:30 +00:00
|
|
|
|
2015-08-11 16:35:45 +00:00
|
|
|
m_gs_max_anisotropy.push_back(GSSetting(0, "Off", ""));
|
GSdx: Anisotropic Filtering.
Fixes a small oversight on my part. Which was setting the maximum anisotropy to (0,1,2,3,4) respectively, instead of (1,2,4,8,16). So when you selected x16 for example, you were actually only getting x4 >.>
Corrected now, and you will be getting the full x16 when selected :)
git-svn-id: http://pcsx2.googlecode.com/svn/trunk@5879 96395faa-99c1-11dd-bbfe-3dabce05a288
2014-02-03 20:06:00 +00:00
|
|
|
m_gs_max_anisotropy.push_back(GSSetting(2, "2x", ""));
|
|
|
|
|
m_gs_max_anisotropy.push_back(GSSetting(4, "4x", ""));
|
|
|
|
|
m_gs_max_anisotropy.push_back(GSSetting(8, "8x", ""));
|
|
|
|
|
m_gs_max_anisotropy.push_back(GSSetting(16, "16x", ""));
|
2014-02-03 16:58:11 +00:00
|
|
|
|
2017-02-24 16:55:39 +00:00
|
|
|
m_gs_bifilter.push_back(GSSetting(static_cast<uint32>(BiFiltering::Nearest), "Nearest", ""));
|
|
|
|
|
m_gs_bifilter.push_back(GSSetting(static_cast<uint32>(BiFiltering::Forced_But_Sprite), "Bilinear", "Forced excluding sprite"));
|
|
|
|
|
m_gs_bifilter.push_back(GSSetting(static_cast<uint32>(BiFiltering::Forced), "Bilinear", "Forced"));
|
|
|
|
|
m_gs_bifilter.push_back(GSSetting(static_cast<uint32>(BiFiltering::PS2), "Bilinear", "PS2"));
|
|
|
|
|
|
|
|
|
|
m_gs_trifilter.push_back(GSSetting(static_cast<uint32>(TriFiltering::None), "None", ""));
|
|
|
|
|
m_gs_trifilter.push_back(GSSetting(static_cast<uint32>(TriFiltering::PS2), "Trilinear", ""));
|
|
|
|
|
m_gs_trifilter.push_back(GSSetting(static_cast<uint32>(TriFiltering::Forced), "Trilinear", "Ultra/Slow"));
|
2015-05-07 18:19:36 +00:00
|
|
|
|
|
|
|
|
m_gs_gl_ext.push_back(GSSetting(-1, "Auto", ""));
|
|
|
|
|
m_gs_gl_ext.push_back(GSSetting(0, "Force-Disabled", ""));
|
|
|
|
|
m_gs_gl_ext.push_back(GSSetting(1, "Force-Enabled", ""));
|
|
|
|
|
|
2015-05-07 20:12:25 +00:00
|
|
|
m_gs_hack.push_back(GSSetting(0, "Off", ""));
|
2015-08-11 22:48:49 +00:00
|
|
|
m_gs_hack.push_back(GSSetting(1, "Half", ""));
|
|
|
|
|
m_gs_hack.push_back(GSSetting(2, "Full", ""));
|
2015-05-07 20:12:25 +00:00
|
|
|
|
2017-02-25 14:35:32 +00:00
|
|
|
m_gs_offset_hack.push_back(GSSetting(0, "Off", ""));
|
|
|
|
|
m_gs_offset_hack.push_back(GSSetting(1, "Normal", "Vertex"));
|
|
|
|
|
m_gs_offset_hack.push_back(GSSetting(2, "Special", "Texture"));
|
|
|
|
|
m_gs_offset_hack.push_back(GSSetting(3, "Special", "Texture - aggressive"));
|
|
|
|
|
|
2016-11-05 16:49:17 +00:00
|
|
|
m_gs_hw_mipmapping.push_back(GSSetting(0, "Off", ""));
|
|
|
|
|
m_gs_hw_mipmapping.push_back(GSSetting(1, "Basic", "Fast"));
|
2017-02-23 21:51:10 +00:00
|
|
|
m_gs_hw_mipmapping.push_back(GSSetting(2, "Full", "Very Slow - Not Recommended)"));
|
2016-11-05 16:49:17 +00:00
|
|
|
|
2016-12-05 21:55:53 +00:00
|
|
|
m_gs_crc_level = {
|
|
|
|
|
GSSetting(CRCHackLevel::Automatic, "Automatic", "Default"),
|
|
|
|
|
GSSetting(CRCHackLevel::None , "None", "Debug"),
|
|
|
|
|
GSSetting(CRCHackLevel::Minimum, "Minimum", "Debug"),
|
|
|
|
|
GSSetting(CRCHackLevel::Partial, "Partial", "OpenGL Recommended"),
|
|
|
|
|
GSSetting(CRCHackLevel::Full, "Full", "Direct3D Recommended"),
|
|
|
|
|
GSSetting(CRCHackLevel::Aggressive, "Aggressive", ""),
|
|
|
|
|
};
|
2015-06-04 16:52:58 +00:00
|
|
|
|
2015-07-19 07:34:06 +00:00
|
|
|
m_gs_acc_blend_level.push_back(GSSetting(0, "None", "Fastest"));
|
2015-07-25 16:20:00 +00:00
|
|
|
m_gs_acc_blend_level.push_back(GSSetting(1, "Basic", "Recommended low-end PC"));
|
2015-07-19 19:40:41 +00:00
|
|
|
m_gs_acc_blend_level.push_back(GSSetting(2, "Medium", ""));
|
2015-07-25 16:20:00 +00:00
|
|
|
m_gs_acc_blend_level.push_back(GSSetting(3, "High", "Recommended high-end PC"));
|
2015-07-19 19:40:41 +00:00
|
|
|
m_gs_acc_blend_level.push_back(GSSetting(4, "Full", "Very Slow"));
|
|
|
|
|
m_gs_acc_blend_level.push_back(GSSetting(5, "Ultra", "Ultra Slow"));
|
2015-07-19 07:34:06 +00:00
|
|
|
|
2015-11-20 13:59:24 +00:00
|
|
|
m_gs_tv_shaders.push_back(GSSetting(0, "None", ""));
|
|
|
|
|
m_gs_tv_shaders.push_back(GSSetting(1, "Scanline filter", ""));
|
|
|
|
|
m_gs_tv_shaders.push_back(GSSetting(2, "Diagonal filter", ""));
|
|
|
|
|
m_gs_tv_shaders.push_back(GSSetting(3, "Triangular filter", ""));
|
|
|
|
|
m_gs_tv_shaders.push_back(GSSetting(4, "Wave filter", ""));
|
|
|
|
|
|
2017-02-23 21:51:10 +00:00
|
|
|
m_gpu_renderers.push_back(GSSetting(static_cast<int8>(GPURendererType::D3D9_SW), "Direct3D 9", "Software"));
|
|
|
|
|
m_gpu_renderers.push_back(GSSetting(static_cast<int8>(GPURendererType::D3D11_SW), "Direct3D 11", "Software"));
|
2016-05-01 16:33:53 +00:00
|
|
|
m_gpu_renderers.push_back(GSSetting(static_cast<int8>(GPURendererType::NULL_Renderer), "Null", ""));
|
2011-02-19 03:36:30 +00:00
|
|
|
|
|
|
|
|
m_gpu_filter.push_back(GSSetting(0, "Nearest", ""));
|
|
|
|
|
m_gpu_filter.push_back(GSSetting(1, "Bilinear (polygons only)", ""));
|
|
|
|
|
m_gpu_filter.push_back(GSSetting(2, "Bilinear", ""));
|
|
|
|
|
|
|
|
|
|
m_gpu_dithering.push_back(GSSetting(0, "Disabled", ""));
|
|
|
|
|
m_gpu_dithering.push_back(GSSetting(1, "Auto", ""));
|
|
|
|
|
|
|
|
|
|
m_gpu_aspectratio.push_back(GSSetting(0, "Stretch", ""));
|
|
|
|
|
m_gpu_aspectratio.push_back(GSSetting(1, "4:3", ""));
|
|
|
|
|
m_gpu_aspectratio.push_back(GSSetting(2, "16:9", ""));
|
|
|
|
|
|
|
|
|
|
m_gpu_scale.push_back(GSSetting(0 | (0 << 2), "H x 1 - V x 1", ""));
|
|
|
|
|
m_gpu_scale.push_back(GSSetting(1 | (0 << 2), "H x 2 - V x 1", ""));
|
|
|
|
|
m_gpu_scale.push_back(GSSetting(0 | (1 << 2), "H x 1 - V x 2", ""));
|
|
|
|
|
m_gpu_scale.push_back(GSSetting(1 | (1 << 2), "H x 2 - V x 2", ""));
|
|
|
|
|
m_gpu_scale.push_back(GSSetting(2 | (1 << 2), "H x 4 - V x 2", ""));
|
|
|
|
|
m_gpu_scale.push_back(GSSetting(1 | (2 << 2), "H x 2 - V x 4", ""));
|
|
|
|
|
m_gpu_scale.push_back(GSSetting(2 | (2 << 2), "H x 4 - V x 4", ""));
|
2016-05-24 19:06:47 +00:00
|
|
|
|
|
|
|
|
// Avoid to clutter the ini file with useless options
|
|
|
|
|
|
|
|
|
|
// PSX option (or DX9). Not supported on linux
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
|
m_default_configuration["dithering"] = "1";
|
|
|
|
|
m_default_configuration["ModeRefreshRate"] = "0";
|
|
|
|
|
m_default_configuration["scale_x"] = "0";
|
|
|
|
|
m_default_configuration["scale_y"] = "0";
|
|
|
|
|
m_default_configuration["windowed"] = "1";
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
// Per OS option
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
|
m_default_configuration["Adapter"] = "default";
|
|
|
|
|
m_default_configuration["CaptureFileName"] = "";
|
|
|
|
|
m_default_configuration["CaptureVideoCodecDisplayName"] = "";
|
|
|
|
|
m_default_configuration["fba"] = "1";
|
|
|
|
|
m_default_configuration["logz"] = "0";
|
|
|
|
|
#else
|
|
|
|
|
m_default_configuration["linux_replay"] = "1";
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
m_default_configuration["aa1"] = "0";
|
|
|
|
|
m_default_configuration["accurate_blending_unit"] = "1";
|
|
|
|
|
m_default_configuration["accurate_date"] = "0";
|
|
|
|
|
m_default_configuration["AspectRatio"] = "1";
|
|
|
|
|
m_default_configuration["capture_enabled"] = "0";
|
|
|
|
|
m_default_configuration["capture_out_dir"] = "/tmp/GSdx_Capture";
|
|
|
|
|
m_default_configuration["capture_threads"] = "4";
|
2016-05-29 15:38:40 +00:00
|
|
|
m_default_configuration["CaptureHeight"] = "480";
|
|
|
|
|
m_default_configuration["CaptureWidth"] = "640";
|
2016-10-06 20:05:03 +00:00
|
|
|
m_default_configuration["clut_load_before_draw"] = "0";
|
2016-12-05 21:55:53 +00:00
|
|
|
m_default_configuration["crc_hack_level"] = std::to_string(static_cast<int8>(CRCHackLevel::Automatic));
|
2016-05-24 19:06:47 +00:00
|
|
|
m_default_configuration["CrcHacksExclusions"] = "";
|
|
|
|
|
m_default_configuration["debug_glsl_shader"] = "0";
|
|
|
|
|
m_default_configuration["debug_opengl"] = "0";
|
2017-01-11 17:43:45 +00:00
|
|
|
m_default_configuration["disable_hw_gl_draw"] = "0";
|
2016-05-24 19:06:47 +00:00
|
|
|
m_default_configuration["dump"] = "0";
|
|
|
|
|
m_default_configuration["extrathreads"] = "2";
|
2016-07-10 15:44:56 +00:00
|
|
|
m_default_configuration["extrathreads_height"] = "4";
|
2017-02-24 16:55:39 +00:00
|
|
|
m_default_configuration["filter"] = to_string(static_cast<int8>(BiFiltering::PS2));
|
2016-06-24 16:41:55 +00:00
|
|
|
m_default_configuration["force_texture_clear"] = "0";
|
2016-05-24 19:06:47 +00:00
|
|
|
m_default_configuration["fxaa"] = "0";
|
|
|
|
|
m_default_configuration["interlace"] = "7";
|
|
|
|
|
m_default_configuration["large_framebuffer"] = "1";
|
2016-08-27 17:23:12 +00:00
|
|
|
m_default_configuration["linear_present"] = "1";
|
2016-05-24 19:06:47 +00:00
|
|
|
m_default_configuration["MaxAnisotropy"] = "0";
|
|
|
|
|
m_default_configuration["mipmap"] = "1";
|
2016-11-05 16:49:17 +00:00
|
|
|
m_default_configuration["mipmap_hw"] = "0";
|
2016-05-24 19:06:47 +00:00
|
|
|
m_default_configuration["ModeHeight"] = "480";
|
|
|
|
|
m_default_configuration["ModeWidth"] = "640";
|
|
|
|
|
m_default_configuration["NTSC_Saturation"] = "1";
|
|
|
|
|
m_default_configuration["ocldev"] = "";
|
2016-09-18 20:42:36 +00:00
|
|
|
#ifdef _WIN32
|
|
|
|
|
m_default_configuration["osd_fontname"] = "C:\\Windows\\Fonts\\tahoma.ttf";
|
|
|
|
|
#else
|
|
|
|
|
m_default_configuration["osd_fontname"] = "/usr/share/fonts/truetype/freefont/FreeSerif.ttf";
|
|
|
|
|
#endif
|
2017-02-23 21:53:02 +00:00
|
|
|
m_default_configuration["osd_fontsize"] = "32";
|
2016-09-18 20:42:36 +00:00
|
|
|
m_default_configuration["osd_indicator_enabled"] = "0";
|
|
|
|
|
m_default_configuration["osd_log_enabled"] = "1";
|
|
|
|
|
m_default_configuration["osd_log_speed"] = "6";
|
|
|
|
|
m_default_configuration["osd_monitor_enabled"] = "0";
|
2017-01-06 15:40:31 +00:00
|
|
|
m_default_configuration["osd_transparency"] = "25";
|
|
|
|
|
m_default_configuration["osd_max_log_messages"] = "3";
|
2016-05-24 19:06:47 +00:00
|
|
|
m_default_configuration["override_geometry_shader"] = "-1";
|
2017-04-05 17:35:00 +00:00
|
|
|
m_default_configuration["override_GL_ARB_copy_image"] = "-1";
|
2016-05-24 19:06:47 +00:00
|
|
|
m_default_configuration["override_GL_ARB_clear_texture"] = "-1";
|
2017-04-04 16:37:26 +00:00
|
|
|
m_default_configuration["override_GL_ARB_clip_control"] = "-1";
|
2017-02-17 16:44:26 +00:00
|
|
|
m_default_configuration["override_GL_ARB_direct_state_access"] = "-1";
|
2016-05-24 19:06:47 +00:00
|
|
|
m_default_configuration["override_GL_ARB_draw_buffers_blend"] = "-1";
|
|
|
|
|
m_default_configuration["override_GL_ARB_get_texture_sub_image"] = "-1";
|
|
|
|
|
m_default_configuration["override_GL_ARB_gpu_shader5"] = "-1";
|
|
|
|
|
m_default_configuration["override_GL_ARB_shader_image_load_store"] = "-1";
|
|
|
|
|
m_default_configuration["override_GL_ARB_viewport_array"] = "-1";
|
2016-10-22 12:44:40 +00:00
|
|
|
m_default_configuration["override_GL_ARB_texture_barrier"] = "-1";
|
2016-05-24 19:06:47 +00:00
|
|
|
m_default_configuration["override_GL_EXT_texture_filter_anisotropic"] = "-1";
|
|
|
|
|
m_default_configuration["paltex"] = "0";
|
|
|
|
|
m_default_configuration["png_compression_level"] = to_string(Z_BEST_SPEED);
|
|
|
|
|
m_default_configuration["preload_frame_with_gs_data"] = "0";
|
2016-06-03 07:39:50 +00:00
|
|
|
m_default_configuration["Renderer"] = to_string(static_cast<int>(GSRendererType::Default));
|
2016-05-24 19:06:47 +00:00
|
|
|
m_default_configuration["resx"] = "1024";
|
|
|
|
|
m_default_configuration["resy"] = "1024";
|
|
|
|
|
m_default_configuration["save"] = "0";
|
|
|
|
|
m_default_configuration["savef"] = "0";
|
|
|
|
|
m_default_configuration["savel"] = "5000";
|
|
|
|
|
m_default_configuration["saven"] = "0";
|
|
|
|
|
m_default_configuration["savet"] = "0";
|
|
|
|
|
m_default_configuration["savez"] = "0";
|
|
|
|
|
m_default_configuration["ShadeBoost"] = "0";
|
|
|
|
|
m_default_configuration["ShadeBoost_Brightness"] = "50";
|
|
|
|
|
m_default_configuration["ShadeBoost_Contrast"] = "50";
|
|
|
|
|
m_default_configuration["ShadeBoost_Saturation"] = "50";
|
|
|
|
|
m_default_configuration["shaderfx"] = "0";
|
|
|
|
|
m_default_configuration["shaderfx_conf"] = "shaders/GSdx_FX_Settings.ini";
|
|
|
|
|
m_default_configuration["shaderfx_glsl"] = "shaders/GSdx.fx";
|
|
|
|
|
m_default_configuration["TVShader"] = "0";
|
|
|
|
|
m_default_configuration["upscale_multiplier"] = "1";
|
|
|
|
|
m_default_configuration["UserHacks"] = "0";
|
|
|
|
|
m_default_configuration["UserHacks_align_sprite_X"] = "0";
|
|
|
|
|
m_default_configuration["UserHacks_AlphaHack"] = "0";
|
|
|
|
|
m_default_configuration["UserHacks_AlphaStencil"] = "0";
|
2016-09-08 15:25:59 +00:00
|
|
|
m_default_configuration["UserHacks_AutoFlush"] = "0";
|
2016-05-24 19:06:47 +00:00
|
|
|
m_default_configuration["UserHacks_DisableDepthSupport"] = "0";
|
2016-05-30 07:29:41 +00:00
|
|
|
m_default_configuration["UserHacks_DisableGsMemClear"] = "0";
|
2016-05-24 19:06:47 +00:00
|
|
|
m_default_configuration["UserHacks_DisablePartialInvalidation"] = "0";
|
|
|
|
|
m_default_configuration["UserHacks_HalfPixelOffset"] = "0";
|
|
|
|
|
m_default_configuration["UserHacks_merge_pp_sprite"] = "0";
|
|
|
|
|
m_default_configuration["UserHacks_MSAA"] = "0";
|
2016-08-21 16:34:03 +00:00
|
|
|
m_default_configuration["UserHacks_unscale_point_line"] = "0";
|
2016-05-24 19:06:47 +00:00
|
|
|
m_default_configuration["UserHacks_round_sprite_offset"] = "0";
|
|
|
|
|
m_default_configuration["UserHacks_SkipDraw"] = "0";
|
|
|
|
|
m_default_configuration["UserHacks_SpriteHack"] = "0";
|
|
|
|
|
m_default_configuration["UserHacks_TCOffset"] = "0";
|
2016-10-09 10:13:37 +00:00
|
|
|
m_default_configuration["UserHacks_TextureInsideRt"] = "0";
|
2017-02-24 16:55:39 +00:00
|
|
|
m_default_configuration["UserHacks_TriFilter"] = to_string(static_cast<int8>(TriFiltering::None));
|
2016-05-24 19:06:47 +00:00
|
|
|
m_default_configuration["UserHacks_WildHack"] = "0";
|
2016-10-25 18:29:38 +00:00
|
|
|
m_default_configuration["wrap_gs_mem"] = "0";
|
2016-05-24 19:06:47 +00:00
|
|
|
m_default_configuration["vsync"] = "0";
|
2009-02-09 21:15:56 +00:00
|
|
|
}
|
|
|
|
|
|
2016-05-01 09:43:18 +00:00
|
|
|
#if defined(__unix__)
|
2013-06-15 15:03:44 +00:00
|
|
|
void GSdxApp::ReloadConfig()
|
|
|
|
|
{
|
2013-09-10 11:41:11 +00:00
|
|
|
if (m_configuration_map.empty()) return;
|
|
|
|
|
|
2013-06-15 15:03:44 +00:00
|
|
|
auto file = m_configuration_map.find("inifile");
|
|
|
|
|
if (file == m_configuration_map.end()) return;
|
|
|
|
|
|
|
|
|
|
// A map was built so reload it
|
2013-09-10 11:41:11 +00:00
|
|
|
std::string filename = file->second;
|
2013-06-15 15:03:44 +00:00
|
|
|
m_configuration_map.clear();
|
2013-09-10 11:41:11 +00:00
|
|
|
BuildConfigurationMap(filename.c_str());
|
2013-06-15 15:03:44 +00:00
|
|
|
}
|
|
|
|
|
|
2011-04-07 09:41:20 +00:00
|
|
|
void GSdxApp::BuildConfigurationMap(const char* lpFileName)
|
|
|
|
|
{
|
|
|
|
|
// Check if the map was already built
|
|
|
|
|
std::string inifile_value(lpFileName);
|
|
|
|
|
if ( inifile_value.compare(m_configuration_map["inifile"]) == 0 ) return;
|
|
|
|
|
m_configuration_map["inifile"] = inifile_value;
|
|
|
|
|
|
|
|
|
|
// Load config from file
|
2015-09-21 15:53:04 +00:00
|
|
|
char value[256];
|
|
|
|
|
char key[256];
|
2011-04-07 09:41:20 +00:00
|
|
|
FILE* f = fopen(lpFileName, "r");
|
|
|
|
|
|
2011-04-07 12:30:29 +00:00
|
|
|
if (f == NULL) return; // FIXME print a nice message
|
2011-04-07 09:41:20 +00:00
|
|
|
|
2015-09-21 15:53:04 +00:00
|
|
|
while( fscanf(f, "%255s = %255s\n", key, value) != EOF ) {
|
2011-04-07 09:41:20 +00:00
|
|
|
std::string key_s(key);
|
|
|
|
|
std::string value_s(value);
|
2016-05-24 19:06:47 +00:00
|
|
|
// Only keep option that have a default value (allow to purge old option of the GSdx.ini)
|
|
|
|
|
if (m_default_configuration.find(key_s) != m_default_configuration.end())
|
|
|
|
|
m_configuration_map[key_s] = value_s;
|
2011-04-07 09:41:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fclose(f);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-02-19 03:36:30 +00:00
|
|
|
void* GSdxApp::GetModuleHandlePtr()
|
2009-02-09 21:15:56 +00:00
|
|
|
{
|
2009-06-03 12:09:04 +00:00
|
|
|
return s_hModule;
|
2009-05-18 11:08:04 +00:00
|
|
|
}
|
|
|
|
|
|
2009-12-19 18:30:56 +00:00
|
|
|
void GSdxApp::SetConfigDir(const char* dir)
|
|
|
|
|
{
|
|
|
|
|
if( dir == NULL )
|
|
|
|
|
{
|
|
|
|
|
m_ini = "inis/GSdx.ini";
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
m_ini = dir;
|
|
|
|
|
|
2011-02-19 03:36:30 +00:00
|
|
|
if(m_ini[m_ini.length() - 1] != DIRECTORY_SEPARATOR)
|
2009-12-19 18:30:56 +00:00
|
|
|
{
|
2011-02-19 03:36:30 +00:00
|
|
|
m_ini += DIRECTORY_SEPARATOR;
|
2009-12-19 18:30:56 +00:00
|
|
|
}
|
2010-04-25 00:31:27 +00:00
|
|
|
|
2009-12-19 18:30:56 +00:00
|
|
|
m_ini += "GSdx.ini";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-24 19:24:03 +00:00
|
|
|
string GSdxApp::GetConfigS(const char* entry)
|
2009-05-18 11:08:04 +00:00
|
|
|
{
|
2009-06-03 12:09:04 +00:00
|
|
|
char buff[4096] = {0};
|
2016-05-24 19:06:47 +00:00
|
|
|
auto def = m_default_configuration.find(entry);
|
2011-02-19 03:36:30 +00:00
|
|
|
|
2016-05-24 19:06:47 +00:00
|
|
|
if (def != m_default_configuration.end()) {
|
|
|
|
|
GetPrivateProfileString(m_section.c_str(), entry, def->second.c_str(), buff, countof(buff), m_ini.c_str());
|
|
|
|
|
} else {
|
|
|
|
|
fprintf(stderr, "Option %s doesn't have a default value\n", entry);
|
|
|
|
|
GetPrivateProfileString(m_section.c_str(), entry, "", buff, countof(buff), m_ini.c_str());
|
|
|
|
|
}
|
2011-02-19 03:36:30 +00:00
|
|
|
|
2009-06-03 12:09:04 +00:00
|
|
|
return string(buff);
|
2009-05-18 11:08:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void GSdxApp::SetConfig(const char* entry, const char* value)
|
|
|
|
|
{
|
2011-02-19 03:36:30 +00:00
|
|
|
WritePrivateProfileString(m_section.c_str(), entry, value, m_ini.c_str());
|
2009-05-18 11:08:04 +00:00
|
|
|
}
|
|
|
|
|
|
2016-05-24 19:24:03 +00:00
|
|
|
int GSdxApp::GetConfigI(const char* entry)
|
2009-05-18 11:08:04 +00:00
|
|
|
{
|
2016-05-24 19:06:47 +00:00
|
|
|
auto def = m_default_configuration.find(entry);
|
|
|
|
|
|
|
|
|
|
if (def != m_default_configuration.end()) {
|
|
|
|
|
return GetPrivateProfileInt(m_section.c_str(), entry, std::stoi(def->second), m_ini.c_str());
|
|
|
|
|
} else {
|
|
|
|
|
fprintf(stderr, "Option %s doesn't have a default value\n", entry);
|
|
|
|
|
return GetPrivateProfileInt(m_section.c_str(), entry, 0, m_ini.c_str());
|
|
|
|
|
}
|
2009-05-18 11:08:04 +00:00
|
|
|
}
|
|
|
|
|
|
2016-05-24 19:24:03 +00:00
|
|
|
bool GSdxApp::GetConfigB(const char* entry)
|
|
|
|
|
{
|
|
|
|
|
return !!GetConfigI(entry);
|
|
|
|
|
}
|
|
|
|
|
|
2009-05-18 11:08:04 +00:00
|
|
|
void GSdxApp::SetConfig(const char* entry, int value)
|
|
|
|
|
{
|
2009-06-03 12:09:04 +00:00
|
|
|
char buff[32] = {0};
|
2011-02-19 03:36:30 +00:00
|
|
|
|
|
|
|
|
sprintf(buff, "%d", value);
|
|
|
|
|
|
2009-06-03 12:09:04 +00:00
|
|
|
SetConfig(entry, buff);
|
2009-05-18 11:08:04 +00:00
|
|
|
}
|
2017-03-24 08:53:33 +00:00
|
|
|
|
|
|
|
|
void GSdxApp::SetCurrentRendererType(GSRendererType type)
|
|
|
|
|
{
|
|
|
|
|
m_current_renderer_type = type;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
GSRendererType GSdxApp::GetCurrentRendererType()
|
|
|
|
|
{
|
|
|
|
|
return m_current_renderer_type;
|
|
|
|
|
}
|
