mirror of
https://github.com/blawar/GLideN64.git
synced 2024-06-30 08:24:05 +00:00
GLideNUI-wtl: Add language translation for emulation tab
This commit is contained in:
zilmar
Sergey Lipskiy
parent
c185cecb01
commit
dc5ac40007
Binary file not shown.
|
|
@ -80,6 +80,41 @@ void loadDefaultStrings(void)
|
|||
g_defaultStrings.insert(LANG_STRINGS::value_type(VIDEO_DITHERING_MAGIC_SQUARE, "Magic square"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(VIDEO_DITHERING_BLUE_NOISE, "Blue noise"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(VIDEO_LANGUAGE, "Language:"));
|
||||
|
||||
//Emulation Tab
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_USE_PER_GAME, "Use per-game settings"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_USE_PER_GAME_TOOLTIP, "When enabled, all non-default values of settings are stored individually for each game.\nWhen a game is running, settings are displayed and saved for the currently running game.\nNote: GLideN64 already contains settings for the optimal performance of most games. Be careful when altering options on 'Emulation' and 'Frame buffer' tab.\n[Recommended: Checked]"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_N64_STYLE_MIP_MAPPING, "Enable N64-style mip-mapping"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_N64_STYLE_MIP_MAPPING_TOOLTIP, "The N64 uses a unique method of mip-mapping that's difficult to reproduce correctly on PCs. When checked, this option emulates N64-accurate mip-mapping. When unchecked, some games have sharper distant textures.\n[Recommended: Checked]"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_HWLIGHTING, "Enable per-pixel lighting (better quality, HLE only)"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_HWLIGHTING_TOOLTIP, "In N64 games lighting is calculated per vertex. This option enables Phong shading, which provides smoother and more realistic lighting.\n\n[Recommended: Your preference]"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_SHADERS_STORAGE, "Store compiled shaders for performance (recommended)"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_SHADERS_STORAGE_TOOLTIP, "Use persistent storage for compiled shader programs.\nEach game uses a set of combiners. A combiner is an equation that defines how to build output color from various color inputs. GLideN64 translates shaders, and compiles shader programs on the fly. Shaders are large and complex. If the game uses several new combiners, compiling new shaders will take time and result in stuttering. When this option is checked, these shaders are saved so they're not recompiled the next time you run the game.\n[Recommended: Checked]"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_INTERNAL_RES, "Internal resolution"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_INTERNAL_RES_TOOLTIP, "This option sets the output render buffer size. By default, the render buffer is set to the Same as output resolution, but you can set it to the Original N64 resolution or a Multiple of N64 resolution."));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_FACTOR0X, "Same as output resolution"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_FACTOR1X, "Original N64 resolution (most accurate)"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_FACTORXX, "Multiple of N64 resolution:"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_GAMMA, "Gamma"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_GAMMA_TOOLTIP, "Gamma correction.\nSome N64 games use gamma correction. Gamma correction makes image brighter. N64 applies gamma correction in its Video Interface. \nGLideN64 emulates gamma correction as post-processing effect. That is, it works only when frame buffer emulation enabled. Gamma correction enabled automatically for games, which use it on real N64. You may force gamma correction for all games. Default level of gamma correction is 2, as on N64.\n[Recommended: use defaults]"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_GAMMA_CORRECTION, "Custom gamma correction level:"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_GAMMA_INFO, "Selecting this option overrides gamma correction specified by the game."));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_2D_ELEMENTS, "2D elements"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_RENDER_2D_ELEMENTS, "Render 2D elements in N64 resolution (best quality, can be slow):"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_RENDER_2D_TOOLTIP, "When checked, 2D elements are rendered at the N64s resolution before copying them to output. This usually eliminates display issues with 2D elements, but it can be slow. This option uses heuristics to detect adjacent 2D elements that doesn't work for every game.\n[Recommended: Checked, unless you have performance problems]"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_RENDER_DISABLE, "Disable"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_RENDER_ENABLE_OPTIMIZED, "Enable optimized"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_RENDER_ENABLE_UNOPTIMIZED, "Enable unoptimized"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_HALOS_REMOVAL, "Try to remove colored halos around transparent objects"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_FIX_BLACK_LINES, "Fix black lines between 2D elements:"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_FIX_BLACK_LINES_TOOLTIP, "In some games the coordinates for parts of 2D elements are not aligned: there is a half-pixel split between adjacent elements. When rendering at the N64's original resolution it isn't visible, but when the image is scaled up it results in black lines. This option attempts to connect these 2D elements.\nFor adjacent 2D elements: Apply the correction only for polygons that need it. Select this option for games that have issues with black lines.\nAlways: Apply the correction for every 2D element. Select this option when For adjacent 2D elements doesn't help.\nNever: Don't attempt to correct black lines between 2D elements.\n[Recommended: Game dependent, mostly Never]"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_ADJACENT_2D_ELEMENTS, "For adjacent 2D elements"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_ALWAYS, "Always"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_NEVER, "Never"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_BACKGROUND, "Background rendering mode (HLE only):"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_BACKGROUND_TOOLTIP, "Background is a complex macro command used to render large (normally full screen) images. Since background images usually don't fit texture memory, the microcode splits them on narrow strips and renders them one by one. HLE code has two modes to emulate background commands:\nOne piece: The whole background image rendred as one textured rectangle. This method is normally much faster, but the result is not always correct.\nStripped: This method emulates background commands as close as possible to actual microcode implementation. It's slower but more precise. Another problem: some games may have gaps between rendered strips in high resolution. Use "Render 2D elements in N64 resolution" option to remove the gaps.\n[Recommended: Game dependent, mostly Stripped]"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_ONE_PIECE, "One piece"));
|
||||
g_defaultStrings.insert(LANG_STRINGS::value_type(EMULATION_STRIPPED, "Stripped"));
|
||||
}
|
||||
|
||||
LANG_STR GetNextLangString(FILE * file)
|
||||
|
|
|
|||
|
|
@ -66,7 +66,6 @@ enum languageStringID
|
|||
VIDEO_BILINEAR_STANDARD = 2034,
|
||||
VIDEO_BILINEAR_3POINT = 2035,
|
||||
VIDEO_BILINEAR_TOOLTIP = 2036,
|
||||
|
||||
VIDEO_DITHERING_GROUP = 2037,
|
||||
VIDEO_PATTERN = 2038,
|
||||
VIDEO_DITHERING_APPLY_TO_OUTPUT = 2039,
|
||||
|
|
@ -81,6 +80,43 @@ enum languageStringID
|
|||
VIDEO_DITHERING_MAGIC_SQUARE = 2048,
|
||||
VIDEO_DITHERING_BLUE_NOISE = 2049,
|
||||
VIDEO_LANGUAGE = 2050,
|
||||
|
||||
/*********************************************************************************
|
||||
* Emulation Tab *
|
||||
*********************************************************************************/
|
||||
EMULATION_USE_PER_GAME = 3000,
|
||||
EMULATION_USE_PER_GAME_TOOLTIP = 3001,
|
||||
EMULATION_N64_STYLE_MIP_MAPPING = 3002,
|
||||
EMULATION_N64_STYLE_MIP_MAPPING_TOOLTIP = 3003,
|
||||
EMULATION_HWLIGHTING = 3004,
|
||||
EMULATION_HWLIGHTING_TOOLTIP = 3005,
|
||||
EMULATION_SHADERS_STORAGE = 3006,
|
||||
EMULATION_SHADERS_STORAGE_TOOLTIP = 3007,
|
||||
EMULATION_INTERNAL_RES = 3008,
|
||||
EMULATION_INTERNAL_RES_TOOLTIP = 3009,
|
||||
EMULATION_FACTOR0X = 3010,
|
||||
EMULATION_FACTOR1X = 3011,
|
||||
EMULATION_FACTORXX = 3012,
|
||||
EMULATION_GAMMA = 3013,
|
||||
EMULATION_GAMMA_TOOLTIP = 3014,
|
||||
EMULATION_GAMMA_CORRECTION = 3015,
|
||||
EMULATION_GAMMA_INFO = 3016,
|
||||
EMULATION_2D_ELEMENTS = 3017,
|
||||
EMULATION_RENDER_2D_ELEMENTS = 3018,
|
||||
EMULATION_RENDER_2D_TOOLTIP = 3019,
|
||||
EMULATION_RENDER_DISABLE = 3020,
|
||||
EMULATION_RENDER_ENABLE_OPTIMIZED = 3021,
|
||||
EMULATION_RENDER_ENABLE_UNOPTIMIZED = 3022,
|
||||
EMULATION_HALOS_REMOVAL = 3023,
|
||||
EMULATION_FIX_BLACK_LINES = 3024,
|
||||
EMULATION_FIX_BLACK_LINES_TOOLTIP = 3025,
|
||||
EMULATION_ADJACENT_2D_ELEMENTS = 3026,
|
||||
EMULATION_ALWAYS = 3027,
|
||||
EMULATION_NEVER = 3028,
|
||||
EMULATION_BACKGROUND = 3029,
|
||||
EMULATION_BACKGROUND_TOOLTIP = 3030,
|
||||
EMULATION_ONE_PIECE = 3031,
|
||||
EMULATION_STRIPPED = 3032,
|
||||
};
|
||||
|
||||
struct LanguageFile
|
||||
|
|
|
|||
|
|
@ -12,11 +12,14 @@ CEmulationTab::CEmulationTab(CConfigDlg & Dlg) :
|
|||
|
||||
BOOL CEmulationTab::OnInitDialog(CWindow /*wndFocus*/, LPARAM /*lInitParam*/)
|
||||
{
|
||||
TTInit();
|
||||
TTSize(400);
|
||||
|
||||
CComboBox nativeRes2DComboBox(GetDlgItem(IDC_CMB_NATIVE_RES_2D));
|
||||
nativeRes2DComboBox.ResetContent();
|
||||
nativeRes2DComboBox.AddString(L"Disable");
|
||||
nativeRes2DComboBox.AddString(L"Enable optimized");
|
||||
nativeRes2DComboBox.AddString(L"Enable unoptimized");
|
||||
nativeRes2DComboBox.AddString(wGS(EMULATION_RENDER_DISABLE).c_str());
|
||||
nativeRes2DComboBox.AddString(wGS(EMULATION_RENDER_ENABLE_OPTIMIZED).c_str());
|
||||
nativeRes2DComboBox.AddString(wGS(EMULATION_RENDER_ENABLE_UNOPTIMIZED).c_str());
|
||||
|
||||
m_GamaTxt.Attach(GetDlgItem(IDC_GAMMA_VALUE));
|
||||
m_GamaSpin.Attach(GetDlgItem(IDC_GAMMA_SPIN));
|
||||
|
|
@ -48,13 +51,10 @@ LRESULT CEmulationTab::OnColorStatic(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*
|
|||
void CEmulationTab::OnGammaCorrection(UINT /*Code*/, int /*id*/, HWND /*ctl*/)
|
||||
{
|
||||
CButton OverScan(GetDlgItem(IDC_CHK_GAMMA_CORRECTION));
|
||||
if (OverScan.GetCheck() == BST_CHECKED)
|
||||
{
|
||||
if (OverScan.GetCheck() == BST_CHECKED) {
|
||||
GetDlgItem(IDC_GAMMA_ICON).ShowWindow(SW_SHOW);
|
||||
GetDlgItem(IDC_GAMMA_INFO).ShowWindow(SW_SHOW);
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
GetDlgItem(IDC_GAMMA_ICON).ShowWindow(SW_HIDE);
|
||||
GetDlgItem(IDC_GAMMA_INFO).ShowWindow(SW_HIDE);
|
||||
}
|
||||
|
|
@ -67,12 +67,70 @@ void CEmulationTab::OnPerGameSettings(UINT /*Code*/, int /*id*/, HWND /*ctl*/)
|
|||
|
||||
void CEmulationTab::ApplyLanguage(void)
|
||||
{
|
||||
SetDlgItemTextW(IDC_CHK_USE_PER_GAME, wGS(EMULATION_USE_PER_GAME).c_str());
|
||||
SetDlgItemTextW(IDC_CHK_N64_STYLE_MIP_MAPPING, wGS(EMULATION_N64_STYLE_MIP_MAPPING).c_str());
|
||||
SetDlgItemTextW(IDC_CHK_HWLIGHTING, wGS(EMULATION_HWLIGHTING).c_str());
|
||||
SetDlgItemTextW(IDC_CHK_SHADERS_STORAGE, wGS(EMULATION_SHADERS_STORAGE).c_str());
|
||||
SetDlgItemTextW(IDC_INTERNAL_RES_GROUP, wGS(EMULATION_INTERNAL_RES).c_str());
|
||||
SetDlgItemTextW(IDC_FACTOR0X_RADIO, wGS(EMULATION_FACTOR0X).c_str());
|
||||
SetDlgItemTextW(IDC_FACTOR1X_RADIO, wGS(EMULATION_FACTOR1X).c_str());
|
||||
SetDlgItemTextW(IDC_FACTORXX_RADIO, wGS(EMULATION_FACTORXX).c_str());
|
||||
SetDlgItemTextW(IDC_GAMMA_GROUP, wGS(EMULATION_GAMMA).c_str());
|
||||
SetDlgItemTextW(IDC_CHK_GAMMA_CORRECTION, wGS(EMULATION_GAMMA_CORRECTION).c_str());
|
||||
SetDlgItemTextW(IDC_GAMMA_INFO, wGS(EMULATION_GAMMA_INFO).c_str());
|
||||
SetDlgItemTextW(IDC_2D_ELEMENTS_GROUP, wGS(EMULATION_2D_ELEMENTS).c_str());
|
||||
SetDlgItemTextW(IDC_RENDER_2D_ELEMENTS, wGS(EMULATION_RENDER_2D_ELEMENTS).c_str());
|
||||
SetDlgItemTextW(IDC_CHK_HALOS_REMOVAL, wGS(EMULATION_HALOS_REMOVAL).c_str());
|
||||
SetDlgItemTextW(IDC_TXT_FIXBLACK_LINES, wGS(EMULATION_FIX_BLACK_LINES).c_str());
|
||||
SetDlgItemTextW(IDC_FIXTEXRECT_SMART, wGS(EMULATION_ADJACENT_2D_ELEMENTS).c_str());
|
||||
SetDlgItemTextW(IDC_FIXTEXRECT_FORCE, wGS(EMULATION_ALWAYS).c_str());
|
||||
SetDlgItemTextW(IDC_FIXTEXRECT_NEVER, wGS(EMULATION_NEVER).c_str());
|
||||
SetDlgItemTextW(IDC_TXT_BACKGROUND_RENDERING, wGS(EMULATION_BACKGROUND).c_str());
|
||||
SetDlgItemTextW(IDC_BGMODE_ONEPIECE, wGS(EMULATION_ONE_PIECE).c_str());
|
||||
SetDlgItemTextW(IDC_BGMODE_STRIPPED, wGS(EMULATION_STRIPPED).c_str());
|
||||
|
||||
std::wstring tooltip = wGS(EMULATION_USE_PER_GAME_TOOLTIP);
|
||||
TTSetTxt(GetDlgItem(IDC_CHK_USE_PER_GAME), tooltip.c_str());
|
||||
tooltip = wGS(EMULATION_N64_STYLE_MIP_MAPPING_TOOLTIP);
|
||||
TTSetTxt(GetDlgItem(IDC_CHK_N64_STYLE_MIP_MAPPING), tooltip.c_str());
|
||||
tooltip = wGS(EMULATION_HWLIGHTING_TOOLTIP);
|
||||
TTSetTxt(GetDlgItem(IDC_CHK_HWLIGHTING), tooltip.c_str());
|
||||
tooltip = wGS(EMULATION_SHADERS_STORAGE_TOOLTIP);
|
||||
TTSetTxt(GetDlgItem(IDC_CHK_SHADERS_STORAGE), tooltip.c_str());
|
||||
tooltip = wGS(EMULATION_INTERNAL_RES_TOOLTIP);
|
||||
TTSetTxt(GetDlgItem(IDC_INTERNAL_RES_GROUP), tooltip.c_str());
|
||||
TTSetTxt(GetDlgItem(IDC_FACTOR0X_RADIO), tooltip.c_str());
|
||||
TTSetTxt(GetDlgItem(IDC_FACTOR1X_RADIO), tooltip.c_str());
|
||||
TTSetTxt(GetDlgItem(IDC_FACTORXX_RADIO), tooltip.c_str());
|
||||
tooltip = wGS(EMULATION_GAMMA_TOOLTIP);
|
||||
TTSetTxt(GetDlgItem(IDC_GAMMA_GROUP), tooltip.c_str());
|
||||
TTSetTxt(GetDlgItem(IDC_CHK_GAMMA_CORRECTION), tooltip.c_str());
|
||||
tooltip = wGS(EMULATION_RENDER_2D_TOOLTIP);
|
||||
TTSetTxt(GetDlgItem(IDC_RENDER_2D_ELEMENTS), tooltip.c_str());
|
||||
TTSetTxt(GetDlgItem(IDC_CMB_NATIVE_RES_2D), tooltip.c_str());
|
||||
tooltip = wGS(EMULATION_FIX_BLACK_LINES_TOOLTIP);
|
||||
TTSetTxt(GetDlgItem(IDC_TXT_FIXBLACK_LINES), tooltip.c_str());
|
||||
TTSetTxt(GetDlgItem(IDC_FIXTEXRECT_SMART), tooltip.c_str());
|
||||
TTSetTxt(GetDlgItem(IDC_FIXTEXRECT_FORCE), tooltip.c_str());
|
||||
TTSetTxt(GetDlgItem(IDC_FIXTEXRECT_NEVER), tooltip.c_str());
|
||||
tooltip = wGS(EMULATION_BACKGROUND_TOOLTIP);
|
||||
TTSetTxt(GetDlgItem(IDC_TXT_BACKGROUND_RENDERING), tooltip.c_str());
|
||||
TTSetTxt(GetDlgItem(IDC_BGMODE_ONEPIECE), tooltip.c_str());
|
||||
TTSetTxt(GetDlgItem(IDC_BGMODE_STRIPPED), tooltip.c_str());
|
||||
|
||||
CComboBox nativeRes2DComboBox(GetDlgItem(IDC_CMB_NATIVE_RES_2D));
|
||||
int selectedIndx = nativeRes2DComboBox.GetCurSel();
|
||||
nativeRes2DComboBox.ResetContent();
|
||||
nativeRes2DComboBox.AddString(wGS(EMULATION_RENDER_DISABLE).c_str());
|
||||
nativeRes2DComboBox.AddString(wGS(EMULATION_RENDER_ENABLE_OPTIMIZED).c_str());
|
||||
nativeRes2DComboBox.AddString(wGS(EMULATION_RENDER_ENABLE_UNOPTIMIZED).c_str());
|
||||
if (selectedIndx >= 0)
|
||||
nativeRes2DComboBox.SetCurSel(selectedIndx);
|
||||
}
|
||||
|
||||
void CEmulationTab::LoadSettings(bool blockCustomSettings)
|
||||
{
|
||||
if (!blockCustomSettings)
|
||||
{
|
||||
if (!blockCustomSettings) {
|
||||
CButton(GetDlgItem(IDC_CHK_USE_PER_GAME)).SetCheck(config.generalEmulation.enableCustomSettings != 0 ? BST_CHECKED : BST_UNCHECKED);
|
||||
m_Dlg.OnCustomSettingsToggled(config.generalEmulation.enableCustomSettings != 0);
|
||||
}
|
||||
|
|
@ -112,16 +170,11 @@ void CEmulationTab::SaveSettings()
|
|||
config.generalEmulation.enableHWLighting = CButton(GetDlgItem(IDC_CHK_HWLIGHTING)).GetCheck() == BST_CHECKED ? 1 : 0;
|
||||
config.generalEmulation.enableShadersStorage = CButton(GetDlgItem(IDC_CHK_SHADERS_STORAGE)).GetCheck() == BST_CHECKED ? 1 : 0;
|
||||
|
||||
if (CButton(GetDlgItem(IDC_FACTOR0X_RADIO)).GetCheck() == BST_CHECKED)
|
||||
{
|
||||
if (CButton(GetDlgItem(IDC_FACTOR0X_RADIO)).GetCheck() == BST_CHECKED) {
|
||||
config.frameBufferEmulation.nativeResFactor = 0;
|
||||
}
|
||||
else if (CButton(GetDlgItem(IDC_FACTOR1X_RADIO)).GetCheck() == BST_CHECKED)
|
||||
{
|
||||
} else if (CButton(GetDlgItem(IDC_FACTOR1X_RADIO)).GetCheck() == BST_CHECKED) {
|
||||
config.frameBufferEmulation.nativeResFactor = 1;
|
||||
}
|
||||
else if (CButton(GetDlgItem(IDC_FACTORXX_RADIO)).GetCheck() == BST_CHECKED)
|
||||
{
|
||||
} else if (CButton(GetDlgItem(IDC_FACTORXX_RADIO)).GetCheck() == BST_CHECKED) {
|
||||
config.frameBufferEmulation.nativeResFactor = m_N64ResMultiplerSpin.GetPos();
|
||||
}
|
||||
config.gammaCorrection.force = CButton(GetDlgItem(IDC_CHK_GAMMA_CORRECTION)).GetCheck() == BST_CHECKED ? 1 : 0;
|
||||
|
|
@ -129,25 +182,17 @@ void CEmulationTab::SaveSettings()
|
|||
config.graphics2D.enableNativeResTexrects = CComboBox(GetDlgItem(IDC_CMB_NATIVE_RES_2D)).GetCurSel();
|
||||
config.texture.enableHalosRemoval = CButton(GetDlgItem(IDC_CHK_HALOS_REMOVAL)).GetCheck() == BST_CHECKED ? 1 : 0;
|
||||
|
||||
if (CButton(GetDlgItem(IDC_FIXTEXRECT_NEVER)).GetCheck() == BST_CHECKED)
|
||||
{
|
||||
if (CButton(GetDlgItem(IDC_FIXTEXRECT_NEVER)).GetCheck() == BST_CHECKED) {
|
||||
config.graphics2D.correctTexrectCoords = Config::tcDisable;
|
||||
}
|
||||
else if (CButton(GetDlgItem(IDC_FIXTEXRECT_SMART)).GetCheck() == BST_CHECKED)
|
||||
{
|
||||
} else if (CButton(GetDlgItem(IDC_FIXTEXRECT_SMART)).GetCheck() == BST_CHECKED) {
|
||||
config.graphics2D.correctTexrectCoords = Config::tcSmart;
|
||||
}
|
||||
else if (CButton(GetDlgItem(IDC_FIXTEXRECT_FORCE)).GetCheck() == BST_CHECKED)
|
||||
{
|
||||
} else if (CButton(GetDlgItem(IDC_FIXTEXRECT_FORCE)).GetCheck() == BST_CHECKED) {
|
||||
config.graphics2D.correctTexrectCoords = Config::tcForce;
|
||||
}
|
||||
|
||||
if (CButton(GetDlgItem(IDC_BGMODE_ONEPIECE)).GetCheck() == BST_CHECKED)
|
||||
{
|
||||
if (CButton(GetDlgItem(IDC_BGMODE_ONEPIECE)).GetCheck() == BST_CHECKED) {
|
||||
config.graphics2D.bgMode = Config::BGMode::bgOnePiece;
|
||||
}
|
||||
else if (CButton(GetDlgItem(IDC_BGMODE_STRIPPED)).GetCheck() == BST_CHECKED)
|
||||
{
|
||||
} else if (CButton(GetDlgItem(IDC_BGMODE_STRIPPED)).GetCheck() == BST_CHECKED) {
|
||||
config.graphics2D.bgMode = Config::BGMode::bgStripped;
|
||||
}
|
||||
}
|
||||
|
|
@ -155,13 +200,10 @@ void CEmulationTab::SaveSettings()
|
|||
LRESULT CEmulationTab::OnScroll(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/)
|
||||
{
|
||||
LONG CtrlId = CWindow((HWND)lParam).GetWindowLong(GWL_ID);
|
||||
if (CtrlId == IDC_GAMMA_SPIN)
|
||||
{
|
||||
if (CtrlId == IDC_GAMMA_SPIN) {
|
||||
int Pos = m_GamaSpin.GetPos();
|
||||
m_GamaTxt.SetWindowText(FormatStrW(L"%0.1f", (float)Pos / 10.0f).c_str());
|
||||
}
|
||||
else if (CtrlId == IDC_N64_RES_MULTIPLER_SPIN)
|
||||
{
|
||||
} else if (CtrlId == IDC_N64_RES_MULTIPLER_SPIN) {
|
||||
int Pos = m_N64ResMultiplerSpin.GetPos();
|
||||
m_N64ResMultiplerTxt.SetWindowText(FormatStrW(L"%dx", Pos).c_str());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,12 +1,14 @@
|
|||
#pragma once
|
||||
#include "config-tab.h"
|
||||
#include "wtl-BitmapPicture.h"
|
||||
#include "wtl-tooltip.h"
|
||||
#include "resource.h"
|
||||
|
||||
class CConfigDlg;
|
||||
|
||||
class CEmulationTab :
|
||||
public CConfigTab
|
||||
public CConfigTab,
|
||||
public CToolTipDialog<CEmulationTab>
|
||||
{
|
||||
public:
|
||||
BEGIN_MSG_MAP(CEmulationTab)
|
||||
|
|
@ -16,6 +18,7 @@ public:
|
|||
MESSAGE_HANDLER(WM_VSCROLL, OnScroll)
|
||||
COMMAND_HANDLER_EX(IDC_CHK_GAMMA_CORRECTION, BN_CLICKED, OnGammaCorrection)
|
||||
COMMAND_HANDLER_EX(IDC_CHK_USE_PER_GAME, BN_CLICKED, OnPerGameSettings)
|
||||
CHAIN_MSG_MAP(CToolTipDialog<CEmulationTab>)
|
||||
REFLECT_NOTIFICATIONS()
|
||||
END_MSG_MAP()
|
||||
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -60,4 +60,41 @@
|
|||
#2035# "N64-Style 3 Punkt"
|
||||
#2036# "Bilineare Filterung: Texturen verwenden standard PC-Style bilineare Filtering.\nN64-Style 3 point: Texturen werden ähnlich dem N64 gefiltert. Das Resultat sieht nicht so weich aus, entspricht aber ehr dem N64."
|
||||
#2046# "Deaktivieren"
|
||||
#2050# "Sprache:"
|
||||
#2050# "Sprache:"
|
||||
|
||||
/*********************************************************************************
|
||||
* Emulation Tab *
|
||||
*********************************************************************************/
|
||||
#3000# "Spieleinstellungen verwenden"
|
||||
#3001# "Wenn aktiviert, werden alle nicht standardmäßigen Einstellungen für jedes Spiel einzeln gespeichert.\nWenn ein Spiel läuft, werden die Einstellungen für das aktuell laufende Spiel angezeigt und gespeichert.\nHinweis: GLideN64 enthält bereits Einstellungen für die optimale Leistung der meisten Spiele. Sei vorsichtig wenn du Optionen auf den Registerkarten 'Emulation' und 'Frame-Buffer' änderst.\n[Empfehlung: Ausgewählt]"
|
||||
#3002# "Aktiviere N64-Style Mip-Mapping"
|
||||
#3003# "Das N64 verwendet eine einzigartige Art des Mip-Mappings, welche nur schwer auf einem PC nachzustellen ist. Wenn diese Einstellung ausgewählt ist wird N64 Mip-Mapping emuliert. Wenn diese Einstellung nicht ausgewählt ist sehen bei einigen Spielen Texturen in der Ferne schärfer aus.\n[Empfehlung: Ausgewählt]"
|
||||
#3004# "Aktiviere Per-Pixel Lighting (Bessere Qualität, nur HLE)"
|
||||
#3005# "Das N64 berechnet die Beleuchtung per Vertex. Diese Einstellung aktiviert Phong Shading, welches glatterer und realistischer Beleuchtung erzeugt.\n\n[Empfehlung: Eigene Vorliebe]"
|
||||
#3006# "Speichere kompilierte Shader für Geschwindigkeit (Empfehlung)"
|
||||
#3007# "Verwende einen dauerhaften Speicher für kompilierte Shader Programme.\nJedes Spiel verwendet einen Satz an Combinern. Ein Combiner ist eine Gleichung, welche beschreibt wie aus verschiedenen Farbeingängen eine Ausgangsfarbe erzeugt wird. GLideN64 übersetzt und kompiliert Shader während der Laufzeit. Shader sind groß und komplex.Wenn ein Spiel mehrere neue Combiner verwendet dauert das kompilieren neuer Shader einige Zeit, was zu Stottern führen kann. Wenn diese einstellung ausgewählt ist werden diese Shader gesichert, damit sie beim nächsten Mal nicht neu kompiliert werden müssen.\n[Empfehlung: Ausgewählt]"
|
||||
#3008# "Interne Auflösung:"
|
||||
#3009# "Diese Einstellung legt die Render-Buffer-Größe der Ausgabe fest. Standardmäßig ist die Render-Buffer-Größe Wie die Auflösung der Ausgabe, oder alternativ auch die Original N64 Auflösung oder ein Vielfaches der N64 Auflösung."
|
||||
#3010# "Wie Ausgabeauflösung"
|
||||
#3011# "Originale N64 Auflösung (höchste Genauigkeit)"
|
||||
#3012# "Mehrfaches der N64 Auflösung:"
|
||||
#3013# "Gamma"
|
||||
#3014# "Gammakorrektur.\nEinige N64 Spiele verwenden Gammakorrektur. Gammakorrektur macht das Bild heller. Das N64 wendet Gammakorrektur in seinem Video Interface an. \nGLideN64 emuliert Gammakorrektur mit einem Nachbearbeitungseffekt. Das bedeutet, es funktioniert nur, wenn die Frame-Buffer-Emulation aktiviert ist. Gammakorrektur wird automatisch bei Spielen aktiviert, welche dieses Feature auf einem echten N64 verwenden. Du kannst Gammakorrektur für alle Spiele erzwingen. Der Standardwert für Gammakorrektur ist 2, wie auf einem N64.\n[Empfehlung: benutze Standardeinstellung]"
|
||||
#3015# "Benutzerdefinierte Gammakorrekturstufe:"
|
||||
#3016# "Die Auswahl dieser Option setzt die vom Spiel vorgegebene Gammakorrektur außer Kraft."
|
||||
#3017# "2D-Elemente"
|
||||
#3018# "Rendern von 2D-Elementen in N64-Auflösung (beste Qualität, kann langsam sein):"
|
||||
#3019# "Wenn diese Option ausgewählt ist, werden 2D Elemente in der originalen N64 Auflösung gezeichnet, bevor sie zur Ausgabe gegeben werden. Normalerweise werden durch diese Einstellung Anzeigeprobleme von 2D Elementen beseitigt. Die Ausführungsgeschwindigkeit kann aber beeinträchtigt werden. Diese Einstellung verwendet Heuristik um benachbarte 2D Elemente zu erkennen, welche nicht in jedem Spiel funktionieren.\n[Empfehlung: Ausgewählt, außer es bestehen Geschwindigkeitsprobleme]"
|
||||
#3020# "Deaktivieren"
|
||||
#3021# "Aktiviere optimiert"
|
||||
#3022# "Aktiviere nicht optimiert"
|
||||
#3023# "Versuche farbige Halos um transparente Objekte zu entfernen"
|
||||
#3024# "Beseitige schwarze Linien zwischen 2D Elementen:"
|
||||
#3025# "In einigen Spielen sind die Koordinaten von 2D Elemente nicht richtig ausgerichtet. Zwischen zwei benachbarten Elementen besteht eine Lücke von einem halben Pixel. Bei der originalen N64 Auflösung tritt dieses Problem nicht aus. Bei höheren Auflösungen ist aber eine schwarze Linie zwischen den Elementen sichtbar. Diese Einstellung verhindert schwarze Linien zwischen benachbarten 2D Elementen.\nFür benachbarte 2D Elemente: Wendet die Korrektur bei Polygonen an, welche sie benötigen. Bei auswählen, welche Probleme mit schwarzen Linien haben.\nImmer: Wende Korrektur bei allen 2D Elementen an. Wähle diese Einstellung aus, falls Für benachbarte 2D Elemente nicht hilft.\nNiemals: Keine Korrektur von schwarzen Linien zwischen 2D Elementen.\n[Empfehlung: Spielabhängig, in der Regel Niemals]"
|
||||
#3026# "Nur benachbarte 2D Elemente"
|
||||
#3027# "Immer"
|
||||
#3028# "Niemals"
|
||||
#3029# "Hintergrund-Renderingmodus (nur HLE):"
|
||||
#3030# "Hintergrund-Rendering ist ein komplexer Makrobefehl zum Rendern großer (normalerweise bildschirmfüllender) Bilder. Da Hintergrundbilder normalerweise nicht in den Texturspeicher passen, werden sie vom Mikrocode auf schmale Streifen aufgeteilt und einzeln gerendert. HLE-Code hat zwei Modi zur Emulation von Hintergrundbefehlen:\nAn einem Stück: Das gesamte Hintergrundbild wird als ein texturiertes Rechteck dargestellt. Diese Methode ist normalerweise viel schneller, aber das Ergebnis ist nicht immer korrekt.\nIn Streifen: Diese Methode emuliert Hintergrundbefehle so nah wie möglich zur tatsächlichen Mikrocode-Implementierung. Ist langsamer, aber präziser. Ein weiteres Problem: Bei einigen Spielen können Lücken zwischen den gerenderten Streifen in hoher Auflösung auftreten. Verwende die "Rendern von 2D-Elementen in N64-Auflösung" -Option zum Entfernen der Lücken.\n[Empfehlung: Spielabhängig, meistens in Streifen]"
|
||||
#3031# "An einem Stück"
|
||||
#3032# "In Streifen"
|
||||
|
|
|
|||
|
|
@ -72,4 +72,41 @@
|
|||
#2047# "Bayer"
|
||||
#2048# "Magic square"
|
||||
#2049# "Blue noise"
|
||||
#2050# "Language:"
|
||||
#2050# "Language:"
|
||||
|
||||
/*********************************************************************************
|
||||
* Emulation Tab *
|
||||
*********************************************************************************/
|
||||
#3000# "Use per-game settings"
|
||||
#3001# "When enabled, all non-default values of settings are stored individually for each game.\nWhen a game is running, settings are displayed and saved for the currently running game.\nNote: GLideN64 already contains settings for the optimal performance of most games. Be careful when altering options on 'Emulation' and 'Frame buffer' tab.\n[Recommended: Checked]"
|
||||
#3002# "Enable N64-style mip-mapping"
|
||||
#3003# "The N64 uses a unique method of mip-mapping that's difficult to reproduce correctly on PCs. When checked, this option emulates N64-accurate mip-mapping. When unchecked, some games have sharper distant textures.\n[Recommended: Checked]"
|
||||
#3004# "Enable per-pixel lighting (better quality, HLE only)"
|
||||
#3005# "In N64 games lighting is calculated per vertex. This option enables Phong shading, which provides smoother and more realistic lighting.\n\n[Recommended: Your preference]"
|
||||
#3006# "Store compiled shaders for performance (recommended)"
|
||||
#3007# "Use persistent storage for compiled shader programs.\nEach game uses a set of combiners. A combiner is an equation that defines how to build output color from various color inputs. GLideN64 translates shaders, and compiles shader programs on the fly. Shaders are large and complex. If the game uses several new combiners, compiling new shaders will take time and result in stuttering. When this option is checked, these shaders are saved so they're not recompiled the next time you run the game.\n[Recommended: Checked]"
|
||||
#3008# "Internal resolution:"
|
||||
#3009# "This option sets the output render buffer size. By default, the render buffer is set to the Same as output resolution, but you can set it to the Original N64 resolution or a Multiple of N64 resolution."
|
||||
#3010# "Same as output resolution"
|
||||
#3011# "Original N64 resolution (most accurate)"
|
||||
#3012# "Multiple of N64 resolution:"
|
||||
#3013# "Gamma"
|
||||
#3014# "Gamma correction.\nSome N64 games use gamma correction. Gamma correction makes image brighter. N64 applies gamma correction in its Video Interface. \nGLideN64 emulates gamma correction as post-processing effect. That is, it works only when frame buffer emulation enabled. Gamma correction enabled automatically for games, which use it on real N64. You may force gamma correction for all games. Default level of gamma correction is 2, as on N64.\n[Recommended: use defaults]"
|
||||
#3015# "Custom gamma correction level:"
|
||||
#3016# "Selecting this option overrides gamma correction specified by the game."
|
||||
#3017# "2D elements"
|
||||
#3018# "Render 2D elements in N64 resolution (best quality, can be slow):"
|
||||
#3019# "When checked, 2D elements are rendered at the N64s resolution before copying them to output. This usually eliminates display issues with 2D elements, but it can be slow. This option uses heuristics to detect adjacent 2D elements that doesn't work for every game.\n[Recommended: Checked, unless you have performance problems]"
|
||||
#3020# "Disable"
|
||||
#3021# "Enable optimized"
|
||||
#3022# "Enable unoptimized"
|
||||
#3023# "Try to remove colored halos around transparent objects"
|
||||
#3024# "Fix black lines between 2D elements:"
|
||||
#3025# "In some games the coordinates for parts of 2D elements are not aligned: there is a half-pixel split between adjacent elements. When rendering at the N64's original resolution it isn't visible, but when the image is scaled up it results in black lines. This option attempts to connect these 2D elements.\nFor adjacent 2D elements: Apply the correction only for polygons that need it. Select this option for games that have issues with black lines.\nAlways: Apply the correction for every 2D element. Select this option when For adjacent 2D elements doesn't help.\nNever: Don't attempt to correct black lines between 2D elements.\n[Recommended: Game dependent, mostly Never]"
|
||||
#3026# "For adjacent 2D elements"
|
||||
#3027# "Always"
|
||||
#3028# "Never"
|
||||
#3029# "Background rendering mode (HLE only):"
|
||||
#3030# "Background is a complex macro command used to render large (normally full screen) images. Since background images usually don't fit texture memory, the microcode splits them on narrow strips and renders them one by one. HLE code has two modes to emulate background commands:\nOne piece: The whole background image rendred as one textured rectangle. This method is normally much faster, but the result is not always correct.\nStripped: This method emulates background commands as close as possible to actual microcode implementation. It's slower but more precise. Another problem: some games may have gaps between rendered strips in high resolution. Use "Render 2D elements in N64 resolution" option to remove the gaps.\n[Recommended: Game dependent, mostly Stripped]"
|
||||
#3031# "One piece"
|
||||
#3032# "Stripped"
|
||||
|
|
|
|||
|
|
@ -38,4 +38,28 @@
|
|||
#2035# "Tripunto N64"
|
||||
#2036# "Filtrado bilineal: Las texturas utilizarán el filtro bilineal estándar de PC.\nTripunto N64: Las texturas se filtrarán de una forma más parecida a la que hace la N64. El resultado será menos suave, pero más preciso."
|
||||
#2046# "Desactivado"
|
||||
#2050# "Idioma:"
|
||||
#2050# "Idioma:"
|
||||
|
||||
/*********************************************************************************
|
||||
* Emulation Tab *
|
||||
*********************************************************************************/
|
||||
#3002# "Mip-mapping de N64"
|
||||
#3003# "La N64 utiliza un sistema de mip-mapping que es difícil de reproducir correctamente en PCs. Al activar esta opción se emulará el mip-mapping de N64. Si se desactiva, algunos juegos tendrán texturas más definidas a lo lejos.\n[Recomendación: Activado]"
|
||||
#3004# "Iluminación por píxel (mejor calidad, sólo en HLE)"
|
||||
#3005# "La iluminación de los juegos de N64 se calcula según cada vértice. Esta opción activa el sombreado Phong, que da una iluminación más suave y realista.\n\n[Recomendación: Lo que prefieras]"
|
||||
#3006# "Guardar shaders compilados para mejorar el rendimiento (recomendado)"
|
||||
#3007# "Guarda de forma persistente los programas de shaders compilados.\nCada juego utiliza un conjunto de combinadores. Un combinador es una ecuación que define el color que se muestra a partir de varios colores de la imagen original. GLideN64 traduce los shaders y compila los programas de shaders al vuelo. Los shaders ocupan mucho espacio y son complejos. Si una escena nueva utiliza varios combinadores nuevos, se tardará más en compilar un shader nuevo y eso puede provocar trompicones. Al activar esta opción se guardarán los shaders para no tener que recompilarlos la próxima vez que ejecutes el juego.\n[Recomendación: Activado]"
|
||||
#3008# "Resolución interna:"
|
||||
#3009# "Esta opción asigna el tamaño del búfer de renderizado de salida. La configuración prdeterminada del búfer de renderizado es «Idéntica a la resolución de salida», pero puedes utilizar la «Resolución original de N64» o un «Múltiplo de la resolución de N64»."
|
||||
#3010# "Idéntica a la resolución de salida"
|
||||
#3011# "Resolución original de N64 (más precisa)"
|
||||
#3012# "Múltiplo de la resolución de N64:"
|
||||
#3014# "Corrección gamma.\nAlgunos juegos de N64 utilizan la corrección gamma, que hace que la imagen sea más brillante. La N64 aplica la corrección gamma a su interfaz de vídeo. \nGLideN64 emula la corrección gamma como un efecto de posprocesado. Es decir, sólo funciona si se utiliza la emulación del frame buffer. La corrección gamma se activa automáticamente en los juegos que la utilizan en una N64 real. Puedes forzar la corrección gamma en todos los juegos. El nivel predeterminado de corrección es 2, como en una N64 real.\n[Recomendación: Utilizar el valor predeterminado]"
|
||||
#3016# "Al seleccionar esta opción se anulará la corrección de gamma que especifique el juego."
|
||||
#3019# "Si se activa esta opción, el plugin renderizará los elementos 2D en la resolución nativa de N64 y después copiará el resultado al búfer principal. Esto debería eliminar los problemas gráficos en los elementos 2D, pero puede provocar ralentizaciones. Esta opción utiliza heurística para detectar los elementos 2D adyacentes, pero no funcionará en todos los juegos.\n[Recomendación: Activado salvo que tengas problemas de rendimiento]"
|
||||
#3020# "Desactivado"
|
||||
#3024# "Corregir líneas negras entre elementos en 2D:"
|
||||
#3025# "En algunos juegos no se alinean las coordenadas de los elementos en 2D: Hay una separación de medio píxel entre cada elemento adyacente. No es algo visible cuando se renderizan en la resolución nativa de N64, pero provoca líneas negras cuando se escala la imagen. Esta opción intenta unir estos elementos en 2D.\nPara elementos en 2D adyacentes: Aplica la corrección sólo en los polígonos que la necesiten. Selecciona esta opción para los juegos que tengan problemas de líneas negras.\nSiempre: Aplica la corrección en todos los elementos en 2D. Selecciona esta opción cuando «Para elementos adyacentes» no funcione.\nNunca: No corregir las líneas negras entre los elementos en 2D.\n[Recomendación: En función de cada juego, por lo general «Nunca»]"
|
||||
#3026# "Para elementos en 2D adyacentes"
|
||||
#3027# "Siempre"
|
||||
#3028# "Nunca"
|
||||
|
|
@ -38,4 +38,28 @@
|
|||
#2035# "Style N64 3 points"
|
||||
#2036# "Filtrage bilinéaire: les textures vont utiliser le filtrage bilinéaire standard d'un PC.\nStyle N64 3 points: Les textures seront filtrés comme sur la N64. Le résultat est moins lisse mais plus authentique."
|
||||
#2046# "Désactivé"
|
||||
#2050# "Langue :"
|
||||
#2050# "Langue :"
|
||||
|
||||
/*********************************************************************************
|
||||
* Emulation Tab *
|
||||
*********************************************************************************/
|
||||
#3002# "Activer le mip-mapping N64"
|
||||
#3003# "La N64 utilise une méthode unique de mip-mapping qu'il est difficile de reproduire correctement sur les PCs. Quand elle est cochée, cette option émule un mip-mapping N64 précis. Quand elle est décochée, certains jeux ont des textures distantes plus nettes.\n[Recommandé : Activé]"
|
||||
#3004# "Activer l'éclairage matériel (meilleure qualité, HLE seulement)"
|
||||
#3005# "Dans les jeux N64, l'éclairage est calculé par vertex. Cette option active un Shader Phong, qui apporte un éclairage plus doux et plus réaliste.\n\n[Recommandé : Selon votre préférence]"
|
||||
#3006# "Stocker les Shaders compilés pour plus de performance (recommandé)"
|
||||
#3007# "Utiliser un stockage persistent pour compiler les Shaders.\nChaque jeu utilise un ensemble de combinateurs. Un combinateur est une équation qui définie couleur depuis des entrées de couleurs diverses. GLideN64 traduit les Shaders, et les compile à la volée. Les Shaders sont larges et complexes. Si le jeu utilise de nombreux mélangeurs, la compilation des Shaders prendra du temps et engendrera des saccades. Quand cette option est cochée, ces Shaders sont sauvegardés et ne seront donc pas recompilés la prochaine fois que vous lancerez le jeu.\n[Recommandé : Activé]"
|
||||
#3008# "Résolution interne :"
|
||||
#3009# "Cette option définie la taille de rendu du tampon de sortie. Par défaut, le rendu est défini sur Identique à la résolution de sortie, mais vous pouvez la définir comme identique à la Résolution N64 d'origine ou à un Multiple de la résolution N64."
|
||||
#3010# "Identique à la résolution de sortie"
|
||||
#3011# "Résolution N64 d'origine (le plus précis)"
|
||||
#3012# "Multiple de la résolution N64 :"
|
||||
#3014# "Correction gamma.\nCertains jeux N64 utilise la correction gamma. La correction gamma rend l'image plus lumineuse. La N64 applique la correction gamma dans son Interface Vidéo. \nGLideN64 émule la correction gamma tel un effet de post-traitement. C'est pourquoi cela fonctionne uniquement si l'émulation du Tampon Image est activée. La correction gamma est automatiquement activée pour les jeux qui l'utilise nativement sur la N64. Vous pouvez forcer la correction gamma pour tous les jeux. La niveau de correction gamma par défaut est 2, comme sur la N64.\n[Recommandé : valeur par défaut]"
|
||||
#3016# "Sélectionner cette option outrepasse les corrections gamma définies par le jeu."
|
||||
#3019# "Quand cette option est activée, les éléments 2D sont restitués à la même résolution que la N64 avant de les copier vers la sortie. Généralement, cela elimine les erreurs d'affichage avec les éléments 2D, mais cela peut être lent. Cette option utilise des heuristiques pour détecter les éléments 2D adjacents, cela ne fonctionne pas pour tous les jeux.\n[Recommandé : Coché, sauf si vous avez des problèmes de performance]"
|
||||
#3020# "Désactivé"
|
||||
#3024# "Fixer les lignes noires entre les éléments 2D :"
|
||||
#3025# "Dans certains jeux les coordonées des sections d'éléments 2D ne sont pas alignés : il y a un demi-pixel d'écart entre les éléments adjacents. Quand le rendu est défini à la résolution N64 d'origine cela n'est pas visible, mais quand l'image est mise à l'échelle supérieure cela résulte en l'affichage de lignes noires. Cette option tente de connecter les éléments 2D.\nPour les éléments 2D adjacents : Applique la correction seulement pour les polygones qui la nécessite. Sélectionnez cette option pour les jeux qui affiche des lignes noires.\nToujours : Applique la correction pour tous les éléments 2D. Sélectionnez cette option quand Pour les éléments 2D adjacents ne fonctionne pas.\nJamais : N'essaye pas de corriger les lignes noires entre les éléments 2D.\n[Recommandé : En fonction du jeu, généralement Jamais]"
|
||||
#3026# "Pour les éléments 2D adjacents"
|
||||
#3027# "Toujours"
|
||||
#3028# "Jamais"
|
||||
Loading…
Reference in New Issue
Block a user