//protected override void Draw()
//{
// ExternalApp.Draw();
// base.Draw();
//}
protected override void Update()
{
#if XB1
System.Diagnostics.Debug.Assert(false);
#else
if (GameRenderComponent.RenderThread != null)
{
var size = m_control.ClientSize;
if ((m_currentSettings.BackBufferWidth != size.Width || m_currentSettings.BackBufferHeight != size.Height) && size.Height > 0 && size.Width > 0)
{
MyRenderDeviceSettings settings = new MyRenderDeviceSettings();
settings.AdapterOrdinal = m_currentSettings.AdapterOrdinal;
settings.RefreshRate = m_currentSettings.RefreshRate;
settings.VSync = m_currentSettings.VSync;
settings.WindowMode = m_currentSettings.WindowMode;
settings.BackBufferHeight = size.Height;
settings.BackBufferWidth = size.Width;
SwitchSettings(settings);
}
GameRenderComponent.RenderThread.TickSync();
}
ExternalApp.Update();
base.Update();
#endif
}
private bool ReadSettingsFromControls(ref MyRenderDeviceSettings deviceSettings)
{
bool changed;
MyRenderDeviceSettings read = new MyRenderDeviceSettings();
var selectedResolution = (int)m_comboResolution.GetSelectedKey();
if ((uint)selectedResolution < (uint)m_resolutions.Count)
{
var resolution = m_resolutions[selectedResolution];
read.BackBufferWidth = resolution.X;
read.BackBufferHeight = resolution.Y;
read.WindowMode = (MyWindowModeEnum)m_comboWindowMode.GetSelectedKey();
read.AdapterOrdinal = (int)m_comboVideoAdapter.GetSelectedKey();
read.VSync = m_checkboxVSync.IsChecked;
read.RefreshRate = 0;
foreach (var displayMode in MyVideoSettingsManager.Adapters[deviceSettings.AdapterOrdinal].SupportedDisplayModes)
{ // Pick the highest refresh rate available (although it might be better to add combobox for refresh rates as well)
if (displayMode.Width == read.BackBufferWidth &&
displayMode.Height == read.BackBufferHeight &&
read.RefreshRate < displayMode.RefreshRate)
{
read.RefreshRate = displayMode.RefreshRate;
}
}
changed = !read.Equals(ref deviceSettings);
deviceSettings = read;
}
else
{ // unsupported display mode selected, so pretend nothing was changed
changed = false;
}
return(changed);
}
private void RenderThreadStart(object param)
{
// TODO: OP! Initialize render log file
ProfilerShort.Autocommit = false;
var startParams = (StartParams)param;
m_renderWindow = startParams.InitHandler();
var control = System.Windows.Forms.Control.FromHandle(m_renderWindow.Handle);
m_settings = MyRenderProxy.CreateDevice(this, m_renderWindow.Handle, startParams.SettingsToTry);
MyRenderProxy.SendCreatedDeviceSettings(m_settings);
m_currentQuality = startParams.RenderQuality;
m_form = control;
LoadContent();
UpdateSize();
//RenderLoop.UseCustomDoEvents = true;
RenderLoop.Run(m_form, RenderCallback);
UnloadContent();
MyRenderProxy.DisposeDevice();
}
public static MyRenderDeviceSettings?Initialize()
{
MyRenderProxy.RequestVideoAdapters();
MyConfig config = MySandboxGame.Config;
RunningGraphicsRenderer = config.GraphicsRenderer;
int?screenWidth = config.ScreenWidth;
int?screenHeight = config.ScreenHeight;
int?nullable3 = new int?(config.VideoAdapter);
if (((nullable3 == null) || (screenWidth == null)) || (screenHeight == null))
{
return(MyPerGameSettings.DefaultRenderDeviceSettings);
}
MyRenderDeviceSettings settings = new MyRenderDeviceSettings {
AdapterOrdinal = nullable3.Value,
NewAdapterOrdinal = nullable3.Value,
BackBufferHeight = screenHeight.Value,
BackBufferWidth = screenWidth.Value,
RefreshRate = config.RefreshRate,
VSync = config.VerticalSync,
WindowMode = config.WindowMode
};
if (MyPerGameSettings.DefaultRenderDeviceSettings != null)
{
settings.UseStereoRendering = MyPerGameSettings.DefaultRenderDeviceSettings.Value.UseStereoRendering;
settings.SettingsMandatory = MyPerGameSettings.DefaultRenderDeviceSettings.Value.SettingsMandatory;
}
return(new MyRenderDeviceSettings?(settings));
}
private void ApplySettingsChanges()
{
if (MyRenderProxy.TestDeviceCooperativeLevel() == MyRenderDeviceCooperativeLevel.Ok)
{
var quality = Interlocked.Exchange(ref m_newQuality, -1);
if (quality != -1)
{
m_currentQuality = (MyRenderQualityEnum)quality;
}
if (m_newSettings.HasValue && MyRenderProxy.SettingsChanged(m_newSettings.Value))
{
m_settings = m_newSettings.Value;
m_newSettings = null;
UnloadContent();
MyRenderProxy.ApplySettings(m_settings);
LoadContent();
UpdateSize();
}
else if (quality != -1)
{
// Quality has changed, but not settings
ProfilerShort.Begin("ReloadContent");
MyRenderProxy.ReloadContent(m_currentQuality);
ProfilerShort.End();
}
}
}
public static MyRenderDeviceSettings?Initialize()
{
// Tell render to supply currently supported video modes.
MyRenderProxy.RequestVideoAdapters();
var config = MySandboxGame.Config;
RunningGraphicsRenderer = config.GraphicsRenderer;
m_currentGraphicsSettings.GraphicsRenderer = config.GraphicsRenderer;
m_currentGraphicsSettings.EnableDamageEffects = config.EnableDamageEffects;
m_currentGraphicsSettings.FieldOfView = config.FieldOfView;
m_currentGraphicsSettings.HardwareCursor = config.HardwareCursor;
m_currentGraphicsSettings.Render.InterpolationEnabled = config.RenderInterpolation;
m_currentGraphicsSettings.Render.GrassDensityFactor = config.GrassDensityFactor;
m_currentGraphicsSettings.VegetationDrawDistance = config.VegetationDrawDistance;
m_currentGraphicsSettings.Render.AntialiasingMode = config.AntialiasingMode ?? DEFAULT_ANTI_ALIASING;
m_currentGraphicsSettings.Render.ShadowQuality = config.ShadowQuality ?? DEFAULT_SHADOW_QUALITY;
//m_currentGraphicsSettings.Render.TonemappingEnabled = config.Tonemapping ?? DEFAULT_TONEMAPPING;
m_currentGraphicsSettings.Render.TextureQuality = config.TextureQuality ?? DEFAULT_TEXTURE_QUALITY;
m_currentGraphicsSettings.Render.AnisotropicFiltering = config.AnisotropicFiltering ?? DEFAULT_ANISOTROPIC_FILTERING;
m_currentGraphicsSettings.Render.FoliageDetails = config.FoliageDetails ?? DEFAULT_FOLIAGE_DETAILS;
m_currentGraphicsSettings.Render.Dx9Quality = config.Dx9RenderQuality ?? MyRenderQualityEnum.HIGH;
m_currentGraphicsSettings.Render.VoxelQuality = config.VoxelQuality ?? MyRenderQualityEnum.HIGH;
SetEnableDamageEffects(config.EnableDamageEffects);
// Need to send both messages as I don't know which one will be used. One of them will be ignored.
MyRenderProxy.SwitchRenderSettings(m_currentGraphicsSettings.Render);
MyRenderProxy.Settings.EnableShadows = (m_currentGraphicsSettings.Render.ShadowQuality != MyShadowsQuality.DISABLED);
// Load previous device settings that will be used for device creation.
// If there are no settings in the config (eg. game is run for the first time), null is returned, leaving the decision up
// to render (it should let us know what settings it used later).
int?screenWidth = config.ScreenWidth;
int?screenHeight = config.ScreenHeight;
int?videoAdapter = config.VideoAdapter;
if (videoAdapter.HasValue && screenWidth.HasValue && screenHeight.HasValue)
{
var settings = new MyRenderDeviceSettings()
{
AdapterOrdinal = videoAdapter.Value,
BackBufferHeight = screenHeight.Value,
BackBufferWidth = screenWidth.Value,
RefreshRate = config.RefreshRate,
VSync = config.VerticalSync,
WindowMode = config.WindowMode,
};
if (MyPerGameSettings.DefaultRenderDeviceSettings.HasValue)
{
settings.UseStereoRendering = MyPerGameSettings.DefaultRenderDeviceSettings.Value.UseStereoRendering;
settings.SettingsMandatory = MyPerGameSettings.DefaultRenderDeviceSettings.Value.SettingsMandatory;
}
return(settings);
}
else
{
return(MyPerGameSettings.DefaultRenderDeviceSettings);
}
}
internal static void OnCreatedDeviceSettings(MyRenderMessageCreatedDeviceSettings message)
{
m_currentDeviceSettings = message.Settings;
float aspectRatio = (float)m_currentDeviceSettings.BackBufferWidth / (float)m_currentDeviceSettings.BackBufferHeight;
m_currentDeviceIsTripleHead = GetAspectRatio(GetClosestAspectRatio(aspectRatio)).IsTripleHead;
}
private void WriteSettingsToControls(MyRenderDeviceSettings deviceSettings)
{
m_comboVideoAdapter.SelectItemByKey(deviceSettings.AdapterOrdinal);
m_comboResolution.SelectItemByKey(m_resolutions.FindIndex(
(res) => res.X == deviceSettings.BackBufferWidth && res.Y == deviceSettings.BackBufferHeight));
m_comboWindowMode.SelectItemByKey((int)deviceSettings.WindowMode);
m_checkboxVSync.IsChecked = deviceSettings.VSync;
}
protected override void StartRenderComponent(MyRenderDeviceSettings?settings)
{
DrawThread = Thread.CurrentThread;
MyRenderWindow wnd = new MyRenderWindow();
#if XB1
System.Diagnostics.Debug.Assert(false);
#else
wnd.Control = Control.FromHandle(WindowHandle);
wnd.TopLevelForm = (Form)wnd.Control.TopLevelControl;
wnd.TopLevelForm.Tag = wnd;
m_bufferedInputSource = wnd;
wnd.TopLevelForm.KeyPress += TopLevelForm_KeyPress;
m_windowCreatedEvent.Set();
((Form)wnd.TopLevelForm).FormClosed += (o, e) => ExitThreadSafe();
#endif
Action showCursor = () =>
{
//if (!wnd.TopLevelForm.IsDisposed)
//wnd.TopLevelForm.ShowCursor = true;
};
Action hideCursor = () =>
{
//if (!wnd.TopLevelForm.IsDisposed)
//wnd.TopLevelForm.ShowCursor = false;
};
m_setMouseVisible = (b) =>
{
// In case of crash, this may be null, don't want subsequent crash
var component = GameRenderComponent;
if (component != null)
{
var renderThread = component.RenderThread;
if (renderThread != null)
{
renderThread.Invoke(b ? showCursor : hideCursor);
}
}
};
if (settings == null)
{
settings = new MyRenderDeviceSettings(0, MyWindowModeEnum.Window, wnd.Control.ClientSize.Width, wnd.Control.ClientSize.Height, 0, false, MyCompilationSymbols.DX11ForceStereo, false);
}
GameRenderComponent.StartSync(m_gameTimer, wnd, settings, MyRenderQualityEnum.NORMAL, MyPerGameSettings.MaxFrameRate);
GameRenderComponent.RenderThread.SizeChanged += RenderThread_SizeChanged;
GameRenderComponent.RenderThread.BeforeDraw += RenderThread_BeforeDraw;
VRageRender.MyViewport vp = new MyViewport(0, 0, wnd.Control.ClientSize.Width, wnd.Control.ClientSize.Height);
RenderThread_SizeChanged(wnd.Control.ClientSize.Width, wnd.Control.ClientSize.Height, vp);
}
protected override void StartRenderComponent(MyRenderDeviceSettings? settings)
{
DrawThread = Thread.CurrentThread;
MyRenderWindow wnd = new MyRenderWindow();
#if XB1
System.Diagnostics.Debug.Assert(false);
#else
wnd.Control = Control.FromHandle(WindowHandle);
wnd.TopLevelForm = (Form)wnd.Control.TopLevelControl;
wnd.TopLevelForm.Tag = wnd;
m_bufferedInputSource = wnd;
wnd.TopLevelForm.KeyPress += TopLevelForm_KeyPress;
m_windowCreatedEvent.Set();
((Form)wnd.TopLevelForm).FormClosed += (o, e) => ExitThreadSafe();
#endif
Action showCursor = () =>
{
//if (!wnd.TopLevelForm.IsDisposed)
//wnd.TopLevelForm.ShowCursor = true;
};
Action hideCursor = () =>
{
//if (!wnd.TopLevelForm.IsDisposed)
//wnd.TopLevelForm.ShowCursor = false;
};
m_setMouseVisible = (b) =>
{
// In case of crash, this may be null, don't want subsequent crash
var component = GameRenderComponent;
if (component != null)
{
var renderThread = component.RenderThread;
if (renderThread != null)
{
renderThread.Invoke(b ? showCursor : hideCursor);
}
}
};
if (settings == null)
{
settings = new MyRenderDeviceSettings(0, MyWindowModeEnum.Window, wnd.Control.ClientSize.Width, wnd.Control.ClientSize.Height, 0, false, MyCompilationSymbols.DX11ForceStereo, false);
}
GameRenderComponent.StartSync(m_gameTimer, wnd, settings, MyRenderQualityEnum.NORMAL, MyPerGameSettings.MaxFrameRate);
GameRenderComponent.RenderThread.SizeChanged += RenderThread_SizeChanged;
GameRenderComponent.RenderThread.BeforeDraw += RenderThread_BeforeDraw;
VRageRender.MyViewport vp = new MyViewport(0, 0, wnd.Control.ClientSize.Width, wnd.Control.ClientSize.Height);
RenderThread_SizeChanged(wnd.Control.ClientSize.Width, wnd.Control.ClientSize.Height, vp);
}
private static void SuffixReadSettingsFromControls(MyGuiScreenOptionsDisplay __instance,
ref bool __result,
ref MyRenderDeviceSettings deviceSettings)
{
if (__instance is MyGuiScreenOptionsDisplayVr gui && gui.m_checkboxEnableVR != null)
{
__result |= gui.m_checkboxEnableVR.IsChecked != deviceSettings.UseStereoRendering;
deviceSettings.UseStereoRendering = true;//gui.m_checkboxEnableVR.IsChecked;
}
}
private bool ReadSettingsFromControls(ref MyRenderDeviceSettings deviceSettings, ref MyGraphicsSettings graphicsSettings)
{
bool changed;
changed = deviceSettings.AdapterOrdinal != (int)m_videoAdapterCombobox.GetSelectedKey();
deviceSettings.AdapterOrdinal = (int)m_videoAdapterCombobox.GetSelectedKey();
var resolution = m_resolutionsForAdapter[(int)m_resolutionCombobox.GetSelectedKey()];
changed = changed || deviceSettings.BackBufferWidth != resolution.X;
deviceSettings.BackBufferWidth = resolution.X;
changed = changed || deviceSettings.BackBufferHeight != resolution.Y;
deviceSettings.BackBufferHeight = resolution.Y;
int refreshRate = 0;
foreach (var displayMode in MyVideoSettingsManager.Adapters[deviceSettings.AdapterOrdinal].SupportedDisplayModes)
{ // Pick the highest refresh rate available (although it might be better to add combobox for refresh rates as well)
if (displayMode.Width == resolution.X &&
displayMode.Height == resolution.Y &&
refreshRate < displayMode.RefreshRate)
{
refreshRate = displayMode.RefreshRate;
}
}
changed = changed || deviceSettings.RefreshRate != refreshRate;
deviceSettings.RefreshRate = refreshRate;
changed = changed || deviceSettings.VSync != m_verticalSyncCheckbox.IsChecked;
deviceSettings.VSync = m_verticalSyncCheckbox.IsChecked;
changed = changed || deviceSettings.WindowMode != (MyWindowModeEnum)m_windowModeCombobox.GetSelectedKey();
deviceSettings.WindowMode = (MyWindowModeEnum)m_windowModeCombobox.GetSelectedKey();
var fov = MathHelper.ToRadians(m_fieldOfViewSlider.Value);
changed = changed || graphicsSettings.FieldOfView != fov;
graphicsSettings.FieldOfView = fov;
changed = changed || graphicsSettings.HardwareCursor != m_hardwareCursorCheckbox.IsChecked;
graphicsSettings.HardwareCursor = m_hardwareCursorCheckbox.IsChecked;
changed = changed || graphicsSettings.EnableDamageEffects != m_enableDamageEffectsCheckbox.IsChecked;
graphicsSettings.EnableDamageEffects = m_enableDamageEffectsCheckbox.IsChecked;
changed = changed || graphicsSettings.RenderInterpolation != m_renderInterpolationCheckbox.IsChecked;
graphicsSettings.RenderInterpolation = m_renderInterpolationCheckbox.IsChecked;
changed = changed || graphicsSettings.RenderQuality != (MyRenderQualityEnum)m_renderQualityCombobox.GetSelectedKey();
graphicsSettings.RenderQuality = (MyRenderQualityEnum)m_renderQualityCombobox.GetSelectedKey();
return(changed);
}
private static void InitStereoMode(MyRenderDeviceSettings settings)
{
if (settings.UseStereoRendering)
{
if (MyOpenVR.Static == null)
{
new MyOpenVR();
}
_stereoStencilMaskInitUsingOVR.Invoke();
}
}
public static ChangeResult ApplyVideoSettings(MyRenderDeviceSettings deviceSettings, MyGraphicsSettings graphicsSettings)
{
ChangeResult result = Apply(deviceSettings);
if (result == ChangeResult.Failed)
{
return(result);
}
ChangeResult result2 = Apply(graphicsSettings);
return((result == ChangeResult.Success) ? result : result2);
}
public static ChangeResult ApplyVideoSettings(MyRenderDeviceSettings deviceSettings, MyGraphicsSettings graphicsSettings)
{
var res = Apply(deviceSettings);
if (res == ChangeResult.Failed)
{
return(res);
}
var res2 = Apply(graphicsSettings);
Debug.Assert(res2 != ChangeResult.Failed, "Changing graphics settings should never fail, only device settings can!");
return(res == ChangeResult.Success ? res : res2);
}
private void RenderThreadStart(object param)
{
// TODO: OP! Initialize render log file
ProfilerShort.Autocommit = false;
var startParams = (StartParams)param;
m_renderWindow = startParams.InitHandler();
#if !XB1
var control = System.Windows.Forms.Control.FromHandle(m_renderWindow.Handle);
#endif
m_settings = MyRenderProxy.CreateDevice(this, m_renderWindow.Handle, startParams.SettingsToTry);
if (m_settings.AdapterOrdinal == -1)
{
return;
}
MyRenderProxy.SendCreatedDeviceSettings(m_settings);
m_currentQuality = startParams.RenderQuality;
#if !XB1
m_form = control;
#else
m_form = m_renderWindow as RenderForm;
#endif
LoadContent();
UpdateSize();
//RenderLoop.UseCustomDoEvents = true;
//RenderLoop.Run(m_form, RenderCallback);
m_form.Show();
while (m_form.Visible)
{
Application.DoEvents();
if (m_form.Visible)
{
RenderCallback();
}
}
UnloadContent();
MyRenderProxy.DisposeDevice();
}
private bool ReadSettingsFromControls(ref MyRenderDeviceSettings deviceSettings)
{
bool changed = false;
MyRenderDeviceSettings read = new MyRenderDeviceSettings
{
AdapterOrdinal = deviceSettings.AdapterOrdinal, // We don't change the value until restarting the game (NewAdapter is loaded from Config)
};
var selectedResolution = (int)m_comboResolution.GetSelectedKey();
if ((uint)selectedResolution < (uint)m_resolutions.Count)
{
var resolution = m_resolutions[selectedResolution];
read.BackBufferWidth = resolution.X;
read.BackBufferHeight = resolution.Y;
read.WindowMode = (MyWindowModeEnum)m_comboWindowMode.GetSelectedKey();
read.NewAdapterOrdinal = (int)m_comboVideoAdapter.GetSelectedKey(); // Setting NewAdapter instead of Adapter -- it is saved to config on game end
changed |= read.NewAdapterOrdinal != read.AdapterOrdinal; // Notify change of adapter (it is not included in Settings' Equals)
read.VSync = m_checkboxVSync.IsChecked;
read.RefreshRate = 0;
if (m_checkboxCaptureMouse.IsChecked != MySandboxGame.Config.CaptureMouse)
{
MySandboxGame.Config.CaptureMouse = m_checkboxCaptureMouse.IsChecked;
MySandboxGame.Static.UpdateMouseCapture();
}
foreach (var displayMode in MyVideoSettingsManager.Adapters[deviceSettings.AdapterOrdinal].SupportedDisplayModes)
{ // Pick the highest refresh rate available (although it might be better to add combobox for refresh rates as well)
if (displayMode.Width == read.BackBufferWidth &&
displayMode.Height == read.BackBufferHeight &&
read.RefreshRate < displayMode.RefreshRate)
{
read.RefreshRate = displayMode.RefreshRate;
}
}
changed = changed || !read.Equals(ref deviceSettings);
deviceSettings = read;
}
return(changed);
}
void WriteSettingsToControls(MyRenderDeviceSettings deviceSettings, MyGraphicsSettings graphicsSettings)
{
m_videoAdapterCombobox.SelectItemByKey(deviceSettings.AdapterOrdinal);
m_resolutionCombobox.SelectItemByKey(m_resolutionsForAdapter.FindIndex(
(res) => res.X == deviceSettings.BackBufferWidth && res.Y == deviceSettings.BackBufferHeight));
m_windowModeCombobox.SelectItemByKey((int)deviceSettings.WindowMode);
m_verticalSyncCheckbox.IsChecked = deviceSettings.VSync;
m_hardwareCursorCheckbox.IsChecked = graphicsSettings.HardwareCursor;
m_enableDamageEffectsCheckbox.IsChecked = graphicsSettings.EnableDamageEffects;
m_renderQualityCombobox.SelectItemByKey((int)graphicsSettings.RenderQuality);
if (m_renderQualityCombobox.GetSelectedKey() == -1)
{
m_renderQualityCombobox.SelectItemByIndex(0);
}
m_fieldOfViewSlider.Value = MathHelper.ToDegrees(graphicsSettings.FieldOfView);
m_renderInterpolationCheckbox.IsChecked = graphicsSettings.RenderInterpolation;
}
public static ChangeResult Apply(MyRenderDeviceSettings settings)
{
MySandboxGame.Log.WriteLine("MyVideoModeManager.Apply(MyRenderDeviceSettings)");
using (MySandboxGame.Log.IndentUsing(LoggingOptions.NONE))
{
ChangeResult nothingChanged;
MySandboxGame.Log.WriteLine("VideoAdapter: " + settings.AdapterOrdinal);
MySandboxGame.Log.WriteLine("Width: " + settings.BackBufferWidth);
MySandboxGame.Log.WriteLine("Height: " + settings.BackBufferHeight);
MySandboxGame.Log.WriteLine("RefreshRate: " + settings.RefreshRate);
MySandboxGame.Log.WriteLine("WindowMode: " + ((settings.WindowMode == MyWindowModeEnum.Fullscreen) ? "Fullscreen" : ((settings.WindowMode == MyWindowModeEnum.Window) ? "Window" : "Fullscreen window")));
MySandboxGame.Log.WriteLine("VerticalSync: " + settings.VSync.ToString());
if (settings.Equals(ref m_currentDeviceSettings) && (settings.NewAdapterOrdinal == settings.AdapterOrdinal))
{
nothingChanged = ChangeResult.NothingChanged;
}
else if (IsSupportedDisplayMode(settings.AdapterOrdinal, settings.BackBufferWidth, settings.BackBufferHeight, settings.WindowMode))
{
float num;
float num2;
m_currentDeviceSettings = settings;
m_currentDeviceSettings.VSync = settings.VSync;
MySandboxGame.Static.SwitchSettings(m_currentDeviceSettings);
float aspectRatio = ((float)m_currentDeviceSettings.BackBufferWidth) / ((float)m_currentDeviceSettings.BackBufferHeight);
m_currentDeviceIsTripleHead = GetAspectRatio(GetClosestAspectRatio(aspectRatio)).IsTripleHead;
GetFovBounds(aspectRatio, out num, out num2);
SetFov(MathHelper.Clamp(m_currentGraphicsSettings.FieldOfView, num, num2));
SetPostProcessingEnabled(m_currentGraphicsSettings.PostProcessingEnabled);
goto TR_0000;
}
else
{
nothingChanged = ChangeResult.Failed;
}
return(nothingChanged);
}
TR_0000:
return(ChangeResult.Success);
}
public static ChangeResult Apply(MyRenderDeviceSettings settings)
{
MySandboxGame.Log.WriteLine("MyVideoModeManager.Apply(MyRenderDeviceSettings)");
using (MySandboxGame.Log.IndentUsing())
{
MySandboxGame.Log.WriteLine("VideoAdapter: " + settings.AdapterOrdinal);
MySandboxGame.Log.WriteLine("Width: " + settings.BackBufferWidth);
MySandboxGame.Log.WriteLine("Height: " + settings.BackBufferHeight);
MySandboxGame.Log.WriteLine("RefreshRate: " + settings.RefreshRate);
MySandboxGame.Log.WriteLine("WindowMode: " + ((settings.WindowMode == MyWindowModeEnum.Fullscreen) ? "Fullscreen" :
(settings.WindowMode == MyWindowModeEnum.Window) ? "Window" : "Fullscreen window"));
MySandboxGame.Log.WriteLine("VerticalSync: " + settings.VSync);
if (settings.Equals(ref m_currentDeviceSettings))
{
return(ChangeResult.NothingChanged);
}
if (!IsSupportedDisplayMode(settings.AdapterOrdinal, settings.BackBufferWidth, settings.BackBufferHeight, settings.WindowMode))
{
return(ChangeResult.Failed);
}
m_currentDeviceSettings = settings;
m_currentDeviceSettings.VSync = m_currentDeviceSettings.VSync && !VRage.MyCompilationSymbols.PerformanceOrMemoryProfiling;
m_currentDeviceSettings.RefreshRate = MySandboxGame.Config.RefreshRate == 0 ? m_currentDeviceSettings.RefreshRate : MySandboxGame.Config.RefreshRate;
MySandboxGame.Static.SwitchSettings(m_currentDeviceSettings);
float aspectRatio = (float)m_currentDeviceSettings.BackBufferWidth / (float)m_currentDeviceSettings.BackBufferHeight;
m_currentDeviceIsTripleHead = GetAspectRatio(GetClosestAspectRatio(aspectRatio)).IsTripleHead;
// Update FoV in case bounds have changed.
float fovMin, fovMax;
GetFovBounds(aspectRatio, out fovMin, out fovMax);
SetFov(MathHelper.Clamp(m_currentGraphicsSettings.FieldOfView, fovMin, fovMax));
}
return(ChangeResult.Success);
}
//protected override void Draw()
//{
// ExternalApp.Draw();
// base.Draw();
//}
protected override void Update()
{
#if XB1
System.Diagnostics.Debug.Assert(false);
#else
if (GameRenderComponent.RenderThread != null)
{
var size = m_control.ClientSize;
if ((m_currentSettings.BackBufferWidth != size.Width || m_currentSettings.BackBufferHeight != size.Height) && size.Height > 0 && size.Width > 0)
{
MyRenderDeviceSettings settings = new MyRenderDeviceSettings();
settings.AdapterOrdinal = m_currentSettings.AdapterOrdinal;
settings.RefreshRate = m_currentSettings.RefreshRate;
settings.VSync = m_currentSettings.VSync;
settings.WindowMode = m_currentSettings.WindowMode;
settings.BackBufferHeight = size.Height;
settings.BackBufferWidth = size.Width;
SwitchSettings(settings);
}
GameRenderComponent.RenderThread.TickSync();
}
ExternalApp.Update();
base.Update();
#endif
}
private static PresentParameters CreatePresentParameters(MyRenderDeviceSettings settings, IntPtr windowHandle)
{
PresentParameters p = new PresentParameters();
p.InitDefaults();
switch (settings.WindowMode)
{
case MyWindowModeEnum.Fullscreen:
p.FullScreenRefreshRateInHz = settings.RefreshRate;
p.BackBufferHeight = settings.BackBufferHeight;
p.BackBufferWidth = settings.BackBufferWidth;
p.Windowed = false;
break;
case MyWindowModeEnum.FullscreenWindow:
{
WinApi.DEVMODE mode = new WinApi.DEVMODE();
WinApi.EnumDisplaySettings(null, WinApi.ENUM_REGISTRY_SETTINGS, ref mode);
p.FullScreenRefreshRateInHz = 0;
p.BackBufferHeight = mode.dmPelsHeight;
p.BackBufferWidth = mode.dmPelsWidth;
p.Windowed = true;
}
break;
case MyWindowModeEnum.Window:
p.FullScreenRefreshRateInHz = 0;
p.BackBufferHeight = settings.BackBufferHeight;
p.BackBufferWidth = settings.BackBufferWidth;
p.Windowed = true;
break;
}
p.DeviceWindowHandle = windowHandle;
p.AutoDepthStencilFormat = Format.D24S8;
p.EnableAutoDepthStencil = true;
p.BackBufferFormat = Format.X8R8G8B8;
p.MultiSampleQuality = 0;
p.PresentationInterval = settings.VSync ? PresentInterval.One : PresentInterval.Immediate;
p.SwapEffect = SwapEffect.Discard;
// PresentFlags.Video may cause crash when driver settings has overridden multisampling
// We don't need it, it's just hint for driver
p.PresentFlags = PresentFlags.DiscardDepthStencil;
return p;
}
public static MyRenderDeviceSettings CreateDevice(MyRenderThread renderThread, IntPtr windowHandle, MyRenderDeviceSettings? settingsToTry)
{
Debug.Assert(RenderThread == null, "Render thread already set, it shouldn't be!");
RenderThread = renderThread;
return m_render.CreateDevice(windowHandle, settingsToTry);
}
public override void RecreateControls(bool constructor)
{
if (!constructor)
return;
base.RecreateControls(constructor);
AddCaption("Display settings");
var tmp = new Vector2(0.268f, 0.145f) * MyGuiConstants.GUI_OPTIMAL_SIZE;
var topLeft = m_size.Value * -0.5f;
var topRight = m_size.Value * new Vector2(0.5f, -0.5f);
Vector2 comboboxSize = new Vector2(600f, 0f) / MyGuiConstants.GUI_OPTIMAL_SIZE;
Vector2 controlsOriginLeft = topLeft + new Vector2(75f, 125f) / MyGuiConstants.GUI_OPTIMAL_SIZE;
Vector2 controlsOriginRight = topRight + new Vector2(-650f, 125f) / MyGuiConstants.GUI_OPTIMAL_SIZE;
const float TEXT_SCALE = Sandbox.Graphics.GUI.MyGuiConstants.DEFAULT_TEXT_SCALE * 0.85f;
var labelVideoAdapter = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.VideoAdapter));
var labelResolution = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.VideoMode));
var labelWindowMode = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.ScreenOptionsVideo_WindowMode));
var labelVSync = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.VerticalSync));
m_comboVideoAdapter = new MyGuiControlCombobox(size: comboboxSize, toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsVideoAdapter));
m_comboResolution = new MyGuiControlCombobox(size: comboboxSize, toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsVideoMode));
m_comboWindowMode = new MyGuiControlCombobox(size: comboboxSize);
m_checkboxVSync = new MyGuiControlCheckbox(toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsVerticalSync));
m_labelUnsupportedAspectRatio = new MyGuiControlLabel(colorMask: MyGuiConstants.LABEL_TEXT_COLOR * 0.9f, textScale: TEXT_SCALE * 0.85f);
m_labelRecommendAspectRatio = new MyGuiControlLabel(colorMask: MyGuiConstants.LABEL_TEXT_COLOR * 0.9f, textScale: TEXT_SCALE * 0.85f);
var hintLineOffset = new Vector2(0f, m_labelUnsupportedAspectRatio.Size.Y);
var hintOffset = new Vector2(0.01f, -0.35f * MyGuiConstants.CONTROLS_DELTA.Y);
labelVideoAdapter.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_comboVideoAdapter.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelResolution.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_comboResolution.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
m_labelUnsupportedAspectRatio.Position = controlsOriginRight + hintOffset;
m_labelRecommendAspectRatio.Position = controlsOriginRight + hintOffset + hintLineOffset;
controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelWindowMode.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_comboWindowMode.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelVSync.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_checkboxVSync.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
Controls.Add(labelVideoAdapter); Controls.Add(m_comboVideoAdapter);
Controls.Add(labelResolution); Controls.Add(m_comboResolution);
Controls.Add(m_labelUnsupportedAspectRatio);
Controls.Add(m_labelRecommendAspectRatio);
Controls.Add(labelWindowMode); Controls.Add(m_comboWindowMode);
Controls.Add(labelVSync); Controls.Add(m_checkboxVSync);
foreach (var control in Controls)
control.OriginAlign = MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_CENTER;
m_labelUnsupportedAspectRatio.Text = string.Format("* {0}", MyTexts.Get(MySpaceTexts.UnsupportedAspectRatio));
{ // AddAdaptersToComboBox
int counter = 0;
foreach (var adapter in MyVideoSettingsManager.Adapters)
{
m_comboVideoAdapter.AddItem(counter++, new StringBuilder(adapter.Name));
}
}
// These options show up if there are no supported display modes
m_comboWindowMode.AddItem((int)MyWindowModeEnum.Window, MySpaceTexts.ScreenOptionsVideo_WindowMode_Window);
m_comboWindowMode.AddItem((int)MyWindowModeEnum.FullscreenWindow, MySpaceTexts.ScreenOptionsVideo_WindowMode_FullscreenWindow);
m_comboVideoAdapter.ItemSelected += ComboVideoAdapter_ItemSelected;
m_comboResolution.ItemSelected += ComboResolution_ItemSelected;
// Buttons Ok and Cancel
Controls.Add(new MyGuiControlButton(
position: Size.Value * new Vector2(-0.5f, 0.5f) + new Vector2(100f, -75f) / MyGuiConstants.GUI_OPTIMAL_SIZE,
size: MyGuiConstants.OK_BUTTON_SIZE,
text: MyTexts.Get(MySpaceTexts.Ok),
onButtonClick: OnOkClick,
originAlign: MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_BOTTOM));
Controls.Add(new MyGuiControlButton(
position: Size.Value * new Vector2(0.5f, 0.5f) + new Vector2(-100f, -75f) / MyGuiConstants.GUI_OPTIMAL_SIZE,
size: MyGuiConstants.OK_BUTTON_SIZE,
text: MyTexts.Get(MySpaceTexts.Cancel),
onButtonClick: OnCancelClick,
originAlign: MyGuiDrawAlignEnum.HORISONTAL_RIGHT_AND_VERTICAL_BOTTOM));
// Update controls with values from config file
m_settingsOld = MyVideoSettingsManager.CurrentDeviceSettings;
m_settingsNew = m_settingsOld;
WriteSettingsToControls(m_settingsOld);
// Update OLD settings
ReadSettingsFromControls(ref m_settingsOld);
ReadSettingsFromControls(ref m_settingsNew);
CloseButtonEnabled = true;
CloseButtonOffset = new Vector2(-50f, 50f) / MyGuiConstants.GUI_OPTIMAL_SIZE;
}
private static bool CreateDeviceInternalSafe(IntPtr windowHandle, MyRenderDeviceSettings? settingsToTry)
{
try
{
CreateDeviceInternal(windowHandle, settingsToTry);
return true;
}
catch (Exception ex)
{
Log.WriteLine("CreateDevice failed: " + ex.ToString());
DisposeDevice();
}
return false;
}
public MyRenderDeviceSettings CreateDevice(IntPtr windowHandle, MyRenderDeviceSettings? settingsToTry)
{
return default(MyRenderDeviceSettings);
}
private bool ReadSettingsFromControls(ref MyRenderDeviceSettings deviceSettings)
{
bool changed;
MyRenderDeviceSettings read;
var selectedResolution = (int)m_comboResolution.GetSelectedKey();
if ((uint)selectedResolution < (uint)m_resolutions.Count)
{
var resolution = m_resolutions[selectedResolution];
read.BackBufferWidth = resolution.X;
read.BackBufferHeight = resolution.Y;
read.WindowMode = (MyWindowModeEnum)m_comboWindowMode.GetSelectedKey();
read.AdapterOrdinal = (int)m_comboVideoAdapter.GetSelectedKey();
read.VSync = m_checkboxVSync.IsChecked;
read.RefreshRate = 0;
foreach (var displayMode in MyVideoSettingsManager.Adapters[deviceSettings.AdapterOrdinal].SupportedDisplayModes)
{ // Pick the highest refresh rate available (although it might be better to add combobox for refresh rates as well)
if (displayMode.Width == read.BackBufferWidth &&
displayMode.Height == read.BackBufferHeight &&
read.RefreshRate < displayMode.RefreshRate)
{
read.RefreshRate = displayMode.RefreshRate;
}
}
changed = !read.Equals(ref deviceSettings);
deviceSettings = read;
}
else
{ // unsupported display mode selected, so pretend nothing was changed
changed = false;
}
return changed;
}
public void ApplySettings(MyRenderDeviceSettings settings)
{
MyRender.ApplySettings(settings);
}
public override void RecreateControls(bool constructor)
{
if (!constructor)
{
return;
}
base.RecreateControls(constructor);
AddCaption(MySpaceTexts.ScreenCaptionVideoOptions);
Vector2 controlsOriginLeft = new Vector2(-m_size.Value.X / 2.0f + 0.05f, -m_size.Value.Y / 2.0f + 0.145f) + new Vector2(0.02f, 0f);
Vector2 controlsOriginRight = new Vector2(-m_size.Value.X / 2.0f + 0.225f, -m_size.Value.Y / 2.0f + 0.145f) + new Vector2(0.043f, 0f);
const float TEXT_SCALE = MyGuiConstants.DEFAULT_TEXT_SCALE * 0.85f;
var labelVideoAdapter = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.VideoAdapter));
var labelVideoMode = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.VideoMode));
var labelWindowMode = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.ScreenOptionsVideo_WindowMode));
var labelVSync = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.VerticalSync));
var labelHwCursor = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.HardwareCursor));
var labelRenderQuality = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.RenderQuality));
var labelFoV = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.FieldOfView));
m_fieldOfViewDefaultLabel = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.DefaultFOV));
var labelRenderInterpolation = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.RenderIterpolation));
var labelEnableDamageEffects = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.EnableDamageEffects));
m_videoAdapterCombobox = new MyGuiControlCombobox(toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsVideoAdapter));
m_resolutionCombobox = new MyGuiControlCombobox(toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsVideoMode));
m_windowModeCombobox = new MyGuiControlCombobox();
m_verticalSyncCheckbox = new MyGuiControlCheckbox(toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsVerticalSync));
m_hardwareCursorCheckbox = new MyGuiControlCheckbox(toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsHardwareCursor));
m_enableDamageEffectsCheckbox = new MyGuiControlCheckbox(toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsEnableDamageEffects));
m_renderQualityCombobox = new MyGuiControlCombobox(toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsRenderQuality));
m_fieldOfViewSlider = new MyGuiControlSlider(toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsFieldOfView),
labelText: new StringBuilder("{0}").ToString(),
labelSpaceWidth: 0.035f,
labelScale: TEXT_SCALE,
labelFont: MyFontEnum.Blue,
minValue: MathHelper.ToDegrees(MyConstants.FIELD_OF_VIEW_CONFIG_MIN),
maxValue: MathHelper.ToDegrees(MyConstants.FIELD_OF_VIEW_CONFIG_MAX),
defaultValue: MathHelper.ToDegrees(MyConstants.FIELD_OF_VIEW_CONFIG_DEFAULT));
m_renderInterpolationCheckbox = new MyGuiControlCheckbox(toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionRenderIterpolation));
m_unsupportedAspectRatioLabel = new MyGuiControlLabel(colorMask: MyGuiConstants.LABEL_TEXT_COLOR * 0.9f, textScale: TEXT_SCALE * 0.85f);
m_recommendAspectRatioLabel = new MyGuiControlLabel(colorMask: MyGuiConstants.LABEL_TEXT_COLOR * 0.9f, textScale: TEXT_SCALE * 0.85f);
var hintLineOffset = new Vector2(0f, m_unsupportedAspectRatioLabel.Size.Y);
var hintOffset = new Vector2(0.01f, -0.35f * MyGuiConstants.CONTROLS_DELTA.Y);
labelVideoAdapter.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_videoAdapterCombobox.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelVideoMode.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_resolutionCombobox.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
m_unsupportedAspectRatioLabel.Position = controlsOriginRight + hintOffset;
m_recommendAspectRatioLabel.Position = controlsOriginRight + hintOffset + hintLineOffset;
controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelWindowMode.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_windowModeCombobox.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelVSync.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_verticalSyncCheckbox.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelHwCursor.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_hardwareCursorCheckbox.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelRenderQuality.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_renderQualityCombobox.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelRenderInterpolation.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_renderInterpolationCheckbox.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelEnableDamageEffects.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_enableDamageEffectsCheckbox.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelFoV.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_fieldOfViewSlider.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
m_fieldOfViewDefaultLabel.Position = controlsOriginRight + hintOffset;
Controls.Add(labelVideoAdapter); Controls.Add(m_videoAdapterCombobox);
Controls.Add(labelVideoMode); Controls.Add(m_resolutionCombobox);
Controls.Add(m_unsupportedAspectRatioLabel);
Controls.Add(m_recommendAspectRatioLabel);
Controls.Add(labelWindowMode); Controls.Add(m_windowModeCombobox);
Controls.Add(labelVSync); Controls.Add(m_verticalSyncCheckbox);
Controls.Add(labelHwCursor); Controls.Add(m_hardwareCursorCheckbox);
Controls.Add(labelRenderQuality); Controls.Add(m_renderQualityCombobox);
Controls.Add(labelRenderInterpolation); Controls.Add(m_renderInterpolationCheckbox);
Controls.Add(labelEnableDamageEffects); Controls.Add(m_enableDamageEffectsCheckbox);
Controls.Add(labelFoV); Controls.Add(m_fieldOfViewSlider);
Controls.Add(m_fieldOfViewDefaultLabel);
foreach (var control in Controls)
{
control.OriginAlign = MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_CENTER;
}
m_unsupportedAspectRatioLabel.Text = string.Format("* {0}", MyTexts.Get(MySpaceTexts.UnsupportedAspectRatio));
AddAdaptersToComboBox();
AddRenderQualitiesToComboBox();
AddWindowModesToComboBox();
m_fieldOfViewDefaultLabel.UpdateFormatParams(MathHelper.ToDegrees(MyConstants.FIELD_OF_VIEW_CONFIG_DEFAULT));
m_videoAdapterCombobox.ItemSelected += OnVideoAdapterSelected;
m_resolutionCombobox.ItemSelected += OnResolutionSelected;
m_windowModeCombobox.ItemSelected += OnWindowModeSelected;
// Buttons APPLY and BACK
Controls.Add(new MyGuiControlButton(
position: new Vector2(-0.05f, 0.31f),
size: MyGuiConstants.OK_BUTTON_SIZE,
text: MyTexts.Get(MySpaceTexts.Ok),
onButtonClick: OnOkClick,
originAlign: MyGuiDrawAlignEnum.HORISONTAL_RIGHT_AND_VERTICAL_CENTER));
Controls.Add(new MyGuiControlButton(
position: new Vector2(0.05f, 0.31f),
size: MyGuiConstants.OK_BUTTON_SIZE,
text: MyTexts.Get(MySpaceTexts.Cancel),
onButtonClick: OnCancelClick,
originAlign: MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_CENTER));
// Update controls with values from config file
m_deviceSettingsOld = MyVideoSettingsManager.CurrentDeviceSettings;
m_graphicsSettingsOld = MyVideoSettingsManager.CurrentGraphicsSettings;
m_deviceSettingsNew = m_deviceSettingsOld;
m_graphicsSettingsNew = m_graphicsSettingsOld;
WriteSettingsToControls(m_deviceSettingsOld, m_graphicsSettingsOld);
// Update OLD settings
ReadSettingsFromControls(ref m_deviceSettingsOld, ref m_graphicsSettingsOld);
ReadSettingsFromControls(ref m_deviceSettingsNew, ref m_graphicsSettingsNew);
CloseButtonEnabled = true;
}
public override void RecreateControls(bool constructor)
{
if (!constructor)
return;
base.RecreateControls(constructor);
AddCaption(MySpaceTexts.ScreenCaptionVideoOptions);
Vector2 controlsOriginLeft = new Vector2(-m_size.Value.X / 2.0f + 0.05f, -m_size.Value.Y / 2.0f + 0.145f) + new Vector2(0.02f, 0f);
Vector2 controlsOriginRight = new Vector2(-m_size.Value.X / 2.0f + 0.225f, -m_size.Value.Y / 2.0f + 0.145f) + new Vector2(0.043f, 0f);
const float TEXT_SCALE = MyGuiConstants.DEFAULT_TEXT_SCALE * 0.85f;
var labelVideoAdapter = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.VideoAdapter));
var labelVideoMode = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.VideoMode));
var labelWindowMode = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.ScreenOptionsVideo_WindowMode));
var labelVSync = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.VerticalSync));
var labelHwCursor = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.HardwareCursor));
var labelRenderQuality = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.RenderQuality));
var labelFoV = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.FieldOfView));
m_fieldOfViewDefaultLabel = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.DefaultFOV));
var labelRenderInterpolation = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.RenderIterpolation));
var labelEnableDamageEffects = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.EnableDamageEffects));
m_videoAdapterCombobox = new MyGuiControlCombobox(toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsVideoAdapter));
m_resolutionCombobox = new MyGuiControlCombobox(toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsVideoMode));
m_windowModeCombobox = new MyGuiControlCombobox();
m_verticalSyncCheckbox = new MyGuiControlCheckbox(toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsVerticalSync));
m_hardwareCursorCheckbox = new MyGuiControlCheckbox(toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsHardwareCursor));
m_enableDamageEffectsCheckbox = new MyGuiControlCheckbox(toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsEnableDamageEffects));
m_renderQualityCombobox = new MyGuiControlCombobox(toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsRenderQuality));
m_fieldOfViewSlider = new MyGuiControlSlider(toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsFieldOfView),
labelText: new StringBuilder("{0}").ToString(),
labelSpaceWidth: 0.035f,
labelScale: TEXT_SCALE,
labelFont: MyFontEnum.Blue,
minValue: MathHelper.ToDegrees(MyConstants.FIELD_OF_VIEW_CONFIG_MIN),
maxValue: MathHelper.ToDegrees(MyConstants.FIELD_OF_VIEW_CONFIG_MAX),
defaultValue: MathHelper.ToDegrees(MyConstants.FIELD_OF_VIEW_CONFIG_DEFAULT));
m_renderInterpolationCheckbox = new MyGuiControlCheckbox(toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionRenderIterpolation));
m_unsupportedAspectRatioLabel = new MyGuiControlLabel(colorMask: MyGuiConstants.LABEL_TEXT_COLOR * 0.9f, textScale: TEXT_SCALE * 0.85f);
m_recommendAspectRatioLabel = new MyGuiControlLabel(colorMask: MyGuiConstants.LABEL_TEXT_COLOR * 0.9f, textScale: TEXT_SCALE * 0.85f);
var hintLineOffset = new Vector2(0f, m_unsupportedAspectRatioLabel.Size.Y);
var hintOffset = new Vector2(0.01f, -0.35f * MyGuiConstants.CONTROLS_DELTA.Y);
labelVideoAdapter.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_videoAdapterCombobox.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelVideoMode.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_resolutionCombobox.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
m_unsupportedAspectRatioLabel.Position = controlsOriginRight + hintOffset;
m_recommendAspectRatioLabel.Position = controlsOriginRight + hintOffset + hintLineOffset;
controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelWindowMode.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_windowModeCombobox.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelVSync.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_verticalSyncCheckbox.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelHwCursor.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_hardwareCursorCheckbox.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelRenderQuality.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_renderQualityCombobox.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelRenderInterpolation.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_renderInterpolationCheckbox.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelEnableDamageEffects.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_enableDamageEffectsCheckbox.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelFoV.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_fieldOfViewSlider.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
m_fieldOfViewDefaultLabel.Position = controlsOriginRight + hintOffset;
Controls.Add(labelVideoAdapter); Controls.Add(m_videoAdapterCombobox);
Controls.Add(labelVideoMode); Controls.Add(m_resolutionCombobox);
Controls.Add(m_unsupportedAspectRatioLabel);
Controls.Add(m_recommendAspectRatioLabel);
Controls.Add(labelWindowMode); Controls.Add(m_windowModeCombobox);
Controls.Add(labelVSync); Controls.Add(m_verticalSyncCheckbox);
Controls.Add(labelHwCursor); Controls.Add(m_hardwareCursorCheckbox);
Controls.Add(labelRenderQuality); Controls.Add(m_renderQualityCombobox);
Controls.Add(labelRenderInterpolation); Controls.Add(m_renderInterpolationCheckbox);
Controls.Add(labelEnableDamageEffects); Controls.Add(m_enableDamageEffectsCheckbox);
Controls.Add(labelFoV); Controls.Add(m_fieldOfViewSlider);
Controls.Add(m_fieldOfViewDefaultLabel);
foreach (var control in Controls)
control.OriginAlign = MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_CENTER;
m_unsupportedAspectRatioLabel.Text = string.Format("* {0}", MyTexts.Get(MySpaceTexts.UnsupportedAspectRatio));
AddAdaptersToComboBox();
AddRenderQualitiesToComboBox();
AddWindowModesToComboBox();
m_fieldOfViewDefaultLabel.UpdateFormatParams(MathHelper.ToDegrees(MyConstants.FIELD_OF_VIEW_CONFIG_DEFAULT));
m_videoAdapterCombobox.ItemSelected += OnVideoAdapterSelected;
m_resolutionCombobox.ItemSelected += OnResolutionSelected;
m_windowModeCombobox.ItemSelected += OnWindowModeSelected;
// Buttons APPLY and BACK
Controls.Add(new MyGuiControlButton(
position: new Vector2(-0.05f, 0.31f),
size: MyGuiConstants.OK_BUTTON_SIZE,
text: MyTexts.Get(MySpaceTexts.Ok),
onButtonClick: OnOkClick,
originAlign: MyGuiDrawAlignEnum.HORISONTAL_RIGHT_AND_VERTICAL_CENTER));
Controls.Add(new MyGuiControlButton(
position: new Vector2(0.05f, 0.31f),
size: MyGuiConstants.OK_BUTTON_SIZE,
text: MyTexts.Get(MySpaceTexts.Cancel),
onButtonClick: OnCancelClick,
originAlign: MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_CENTER));
// Update controls with values from config file
m_deviceSettingsOld = MyVideoSettingsManager.CurrentDeviceSettings;
m_graphicsSettingsOld = MyVideoSettingsManager.CurrentGraphicsSettings;
m_deviceSettingsNew = m_deviceSettingsOld;
m_graphicsSettingsNew = m_graphicsSettingsOld;
WriteSettingsToControls(m_deviceSettingsOld, m_graphicsSettingsOld);
// Update OLD settings
ReadSettingsFromControls(ref m_deviceSettingsOld, ref m_graphicsSettingsOld);
ReadSettingsFromControls(ref m_deviceSettingsNew, ref m_graphicsSettingsNew);
CloseButtonEnabled = true;
}
public static MyRenderThread StartSync(MyGameTimer timer, IMyRenderWindow renderWindow, MyRenderDeviceSettings? settingsToTry, MyRenderQualityEnum renderQuality)
{
var result = new MyRenderThread(timer, false);
result.m_renderWindow = renderWindow;
result.m_settings = MyRenderProxy.CreateDevice(result, renderWindow.Handle, settingsToTry);
MyRenderProxy.SendCreatedDeviceSettings(result.m_settings);
result.m_currentQuality = renderQuality;
result.m_form = System.Windows.Forms.Control.FromHandle(renderWindow.Handle);
result.LoadContent();
result.UpdateSize();
return result;
}
public static MyRenderDeviceSettings CreateDevice(IntPtr windowHandle, MyRenderDeviceSettings? settingsToTry)
{
Debug.Assert(Device == null, "Device was not properly released");
// try first settingsToTry (if available)
// if that doesn't work, try again using desktop fullscreen settings
// if that doesn't work, use fallback settings (800x600 or 640x480 in window) and hope for the best
m_windowHandle = windowHandle;
var deviceType = DeviceType.Hardware;
int adapterOrdinal = 0;
if (settingsToTry.HasValue)
{
adapterOrdinal = settingsToTry.Value.AdapterOrdinal;
}
EnablePerfHUD(m_d3d, ref adapterOrdinal, ref deviceType);
bool deviceCreated = false;
if (settingsToTry.HasValue)
{
try
{
var settings = settingsToTry.Value;
var originalWindowMode = settings.WindowMode;
settings.AdapterOrdinal = adapterOrdinal;
settings.WindowMode = MyWindowModeEnum.Window;
TryCreateDeviceInternal(windowHandle, deviceType, settings, out m_device, out m_parameters);
Debug.Assert(m_device != null);
m_settings = settings;
bool modeExists = false;
foreach(var mode in m_adaptersList[settings.AdapterOrdinal].SupportedDisplayModes)
{
if(mode.Width == m_settings.BackBufferWidth && mode.Height == m_settings.BackBufferHeight && mode.RefreshRate == m_settings.RefreshRate)
{
modeExists = true;
break;
}
}
if(!modeExists)
{
var fallbackMode = m_adaptersList[settings.AdapterOrdinal].SupportedDisplayModes.Last(x => true);
m_settings.BackBufferHeight = fallbackMode.Height;
m_settings.BackBufferWidth = fallbackMode.Width;
m_settings.RefreshRate = fallbackMode.RefreshRate;
}
if (originalWindowMode != m_settings.WindowMode)
{
m_settings.WindowMode = originalWindowMode;
ApplySettings(m_settings);
}
deviceCreated = true;
}
catch
{
/* These settings don't work so we'll try different. Dispose device in case it failed while switching to fullscreen. */
DisposeDevice();
}
}
if (!deviceCreated)
{
// find the best match among supported display modes
var adapters = GetAdaptersList();
int i = 0;
int j = 0;
for (;i < adapters.Length; ++i)
{
for (j = 0; j < adapters[i].SupportedDisplayModes.Length; ++j)
{
var bounds = System.Windows.Forms.Screen.PrimaryScreen.Bounds;
if (adapters[i].SupportedDisplayModes[j].Width == bounds.Width &&
adapters[i].SupportedDisplayModes[j].Height == bounds.Height)
{
goto DISPLAY_MODE_FOUND_LABEL;
}
}
}
DISPLAY_MODE_FOUND_LABEL:
if (i != adapters.Length) // found appropriate display mode
{
var displayMode = adapters[i].SupportedDisplayModes[j];
var bestFitSettings = new MyRenderDeviceSettings()
{
AdapterOrdinal = i,
BackBufferWidth = displayMode.Width,
BackBufferHeight = displayMode.Height,
RefreshRate = displayMode.RefreshRate,
VSync = true,
WindowMode = MyWindowModeEnum.Window, // initially create windowed, we change it to fullscreen afterwards
};
try
{
TryCreateDeviceInternal(windowHandle, deviceType, bestFitSettings, out m_device, out m_parameters);
Debug.Assert(m_device != null);
m_settings = bestFitSettings;
m_settings.WindowMode = MyWindowModeEnum.Fullscreen;
ApplySettings(m_settings);
deviceCreated = true;
}
catch
{
/* Doesn't work again. */
DisposeDevice();
}
}
}
if (!deviceCreated)
{
var simpleSettings = new MyRenderDeviceSettings()
{
AdapterOrdinal = 0,
BackBufferHeight = 480,
BackBufferWidth = 640,
WindowMode = MyWindowModeEnum.Window,
VSync = true,
};
try
{
TryCreateDeviceInternal(windowHandle, deviceType, simpleSettings, out m_device, out m_parameters);
Debug.Assert(m_device != null);
m_settings = simpleSettings;
deviceCreated = true;
}
catch
{
// These settings don't work either so we're done here.
MyMessageBox.Show("Unsupported graphics card", "Graphics card is not supported, please see minimum requirements");
throw;
}
}
SupportsHDR = GetAdaptersList()[m_settings.AdapterOrdinal].HDRSupported;
return m_settings;
}
public static void ApplySettings(MyRenderDeviceSettings settings)
{
bool canReset = m_settings.AdapterOrdinal == settings.AdapterOrdinal;
m_settings = settings;
m_parameters = CreatePresentParameters(m_settings, m_windowHandle);
SupportsHDR = GetAdaptersList()[m_settings.AdapterOrdinal].HDRSupported;
if (canReset)
{
if (!Reset())
Recreate();
}
else
{
Recreate();
}
}
public static bool SettingsChanged(MyRenderDeviceSettings settings)
{
return !m_settings.Equals(ref settings);
}
public override void SwitchSettings(MyRenderDeviceSettings settings)
{
m_currentSettings = settings;
m_currentSettings.WindowMode = MyWindowModeEnum.Window;
base.SwitchSettings(m_currentSettings);
}
private static void SuffixWriteSettingsToControls(MyGuiScreenOptionsDisplay __instance, MyRenderDeviceSettings deviceSettings)
{
if (__instance is MyGuiScreenOptionsDisplayVr gui && gui.m_checkboxEnableVR != null)
{
gui.m_checkboxEnableVR.IsChecked = true;//deviceSettings.UseStereoRendering;
}
}
public void ApplySettings(MyRenderDeviceSettings settings)
{
MyRender11.CheckAdapterChange(settings);
MyRender11.ApplySettings(settings);
}
private bool ReadSettingsFromControls(ref MyRenderDeviceSettings deviceSettings, ref MyGraphicsSettings graphicsSettings)
{
bool changed;
changed = deviceSettings.AdapterOrdinal != (int)m_videoAdapterCombobox.GetSelectedKey();
deviceSettings.AdapterOrdinal = (int)m_videoAdapterCombobox.GetSelectedKey();
var resolution = m_resolutionsForAdapter[(int)m_resolutionCombobox.GetSelectedKey()];
changed = changed || deviceSettings.BackBufferWidth != resolution.X;
deviceSettings.BackBufferWidth = resolution.X;
changed = changed || deviceSettings.BackBufferHeight != resolution.Y;
deviceSettings.BackBufferHeight = resolution.Y;
int refreshRate = 0;
foreach (var displayMode in MyVideoSettingsManager.Adapters[deviceSettings.AdapterOrdinal].SupportedDisplayModes)
{ // Pick the highest refresh rate available (although it might be better to add combobox for refresh rates as well)
if (displayMode.Width == resolution.X &&
displayMode.Height == resolution.Y &&
refreshRate < displayMode.RefreshRate)
refreshRate = displayMode.RefreshRate;
}
changed = changed || deviceSettings.RefreshRate != refreshRate;
deviceSettings.RefreshRate = refreshRate;
changed = changed || deviceSettings.VSync != m_verticalSyncCheckbox.IsChecked;
deviceSettings.VSync = m_verticalSyncCheckbox.IsChecked;
changed = changed || deviceSettings.WindowMode != (MyWindowModeEnum)m_windowModeCombobox.GetSelectedKey();
deviceSettings.WindowMode = (MyWindowModeEnum)m_windowModeCombobox.GetSelectedKey();
var fov = MathHelper.ToRadians(m_fieldOfViewSlider.Value);
changed = changed || graphicsSettings.FieldOfView != fov;
graphicsSettings.FieldOfView = fov;
changed = changed || graphicsSettings.HardwareCursor != m_hardwareCursorCheckbox.IsChecked;
graphicsSettings.HardwareCursor = m_hardwareCursorCheckbox.IsChecked;
changed = changed || graphicsSettings.EnableDamageEffects != m_enableDamageEffectsCheckbox.IsChecked;
graphicsSettings.EnableDamageEffects = m_enableDamageEffectsCheckbox.IsChecked;
changed = changed || graphicsSettings.Render.InterpolationEnabled != m_renderInterpolationCheckbox.IsChecked;
graphicsSettings.Render.InterpolationEnabled = m_renderInterpolationCheckbox.IsChecked;
changed = changed || graphicsSettings.Render.Dx9Quality != (MyRenderQualityEnum)m_renderQualityCombobox.GetSelectedKey();
graphicsSettings.Render.Dx9Quality = (MyRenderQualityEnum)m_renderQualityCombobox.GetSelectedKey();
return changed;
}
public bool SettingsChanged(MyRenderDeviceSettings settings)
{
return true;
}
internal static void OnCreatedDeviceSettings(MyRenderMessageCreatedDeviceSettings message)
{
m_currentDeviceSettings = message.Settings;
}
private void WriteSettingsToControls(MyRenderDeviceSettings deviceSettings)
{
m_comboVideoAdapter.SelectItemByKey(deviceSettings.AdapterOrdinal);
m_comboResolution.SelectItemByKey(m_resolutions.FindIndex(
(res) => res.X == deviceSettings.BackBufferWidth && res.Y == deviceSettings.BackBufferHeight));
m_comboWindowMode.SelectItemByKey((int)deviceSettings.WindowMode);
m_checkboxVSync.IsChecked = deviceSettings.VSync;
}
public static void SendCreatedDeviceSettings(MyRenderDeviceSettings settings)
{
var message = MessagePool.Get<MyRenderMessageCreatedDeviceSettings>(MyRenderMessageEnum.CreatedDeviceSettings);
message.Settings = settings;
EnqueueOutputMessage(message);
}
internal static MyRenderDeviceSettings CreateDevice(IntPtr windowHandle, MyRenderDeviceSettings? settingsToTry)
{
bool deviceCreated = CreateDeviceInternalSafe(windowHandle, settingsToTry);
if (!deviceCreated)
{
Log.WriteLine("Primary desktop size fallback.");
var adapters = GetAdaptersList();
int i = 0;
int j = 0;
for (; i < adapters.Length; ++i)
{
for (j = 0; j < adapters[i].SupportedDisplayModes.Length; ++j)
{
if (adapters[i].IsDx11Supported)
{
var bounds = System.Windows.Forms.Screen.PrimaryScreen.Bounds;
if (adapters[i].SupportedDisplayModes[j].Width == bounds.Width &&
adapters[i].SupportedDisplayModes[j].Height == bounds.Height)
{
var displayMode = adapters[i].SupportedDisplayModes[j];
var newSettings = new MyRenderDeviceSettings()
{
AdapterOrdinal = i,
BackBufferHeight = displayMode.Height,
BackBufferWidth = displayMode.Width,
WindowMode = MyWindowModeEnum.Fullscreen,
RefreshRate = displayMode.RefreshRate,
VSync = true
};
deviceCreated = CreateDeviceInternalSafe(windowHandle, newSettings);
if (deviceCreated)
return m_settings;
}
}
}
}
}
if (!deviceCreated)
{
Log.WriteLine("Lowest res fallback.");
var simpleSettings = new MyRenderDeviceSettings()
{
AdapterOrdinal = 0,
BackBufferHeight = 480,
BackBufferWidth = 640,
WindowMode = MyWindowModeEnum.Window,
VSync = true,
};
deviceCreated = CreateDeviceInternalSafe(windowHandle, simpleSettings);
if (!deviceCreated)
{
VRage.Utils.MyMessageBox.Show("Unsupported graphics card", "Graphics card is not supported, please see minimum requirements");
throw new MyRenderException("No supported device detected!", MyRenderExceptionEnum.GpuNotSupported);
}
}
return m_settings;
}
public static void SwitchDeviceSettings(MyRenderDeviceSettings settings)
{
var message = MessagePool.Get<MyRenderMessageSwitchDeviceSettings>(MyRenderMessageEnum.SwitchDeviceSettings);
message.Settings = settings;
EnqueueMessage(message);
}
private static MyRenderDeviceSettings CreateDeviceInternal(IntPtr windowHandle, MyRenderDeviceSettings? settingsToTry)
{
if (Device != null)
{
Device.Dispose();
Device = null;
}
if (settingsToTry != null)
{
Log.WriteLine("CreateDevice - original settings");
var originalSettings = settingsToTry.Value;
LogSettings(ref originalSettings);
}
FeatureLevel[] featureLevels = { FeatureLevel.Level_11_0 };
DeviceCreationFlags flags = DeviceCreationFlags.None;
#if DEBUG_DEVICE && DEBUG
flags |= DeviceCreationFlags.Debug;
#endif
WinApi.DEVMODE mode = new WinApi.DEVMODE();
WinApi.EnumDisplaySettings(null, WinApi.ENUM_REGISTRY_SETTINGS, ref mode);
var settings = settingsToTry ?? new MyRenderDeviceSettings()
{
AdapterOrdinal = -1,
BackBufferHeight = mode.dmPelsHeight,
BackBufferWidth = mode.dmPelsWidth,
WindowMode = MyWindowModeEnum.Fullscreen,
RefreshRate = 60000,
VSync = false,
};
settings.AdapterOrdinal = ValidateAdapterIndex(settings.AdapterOrdinal);
if (settings.AdapterOrdinal == -1)
{
throw new MyRenderException("No supported device detected!", MyRenderExceptionEnum.GpuNotSupported);
}
m_settings = settings;
Log.WriteLine("CreateDevice settings");
LogSettings(ref m_settings);
// If this line crashes cmd this: Dism /online /add-capability /capabilityname:Tools.Graphics.DirectX~~~~0.0.1.0
var adapters = GetAdaptersList();
if (m_settings.AdapterOrdinal >= adapters.Length)
throw new MyRenderException("No supported device detected!", MyRenderExceptionEnum.GpuNotSupported);
var adapterId = adapters[m_settings.AdapterOrdinal].AdapterDeviceId;
if (adapterId >= GetFactory().Adapters.Length)
throw new MyRenderException("Invalid adapter id binding!", MyRenderExceptionEnum.GpuNotSupported);
var adapter = GetFactory().Adapters[adapterId];
Device = new Device(adapter, flags, FeatureLevel.Level_11_0);
// HACK: This is required for Steam overlay to work. Apparently they hook only CreateDevice methods with DriverType argument.
try
{
using (new Device(DriverType.Hardware, flags, FeatureLevel.Level_11_0)){}
}
catch { }
if (flags.HasFlag(DeviceCreationFlags.Debug))
{
if (DebugDevice != null)
{
DebugDevice.Dispose();
DebugDevice = null;
}
DebugDevice = new DeviceDebug(Device);
DebugInfoQueue = DebugDevice.QueryInterface<InfoQueue>();
new System.Threading.Thread(ProcessDebugOutput).Start();
}
if(DeviceContext != null)
{
DeviceContext.Dispose();
DeviceContext = null;
}
DeviceContext = Device.ImmediateContext;
m_windowHandle = windowHandle;
m_resolution = new Vector2I(m_settings.BackBufferWidth, m_settings.BackBufferHeight);
if (!m_initialized)
{
InitSubsystems();
m_initialized = true;
}
if (m_swapchain != null)
{
m_swapchain.Dispose();
m_swapchain = null;
}
if (m_swapchain == null)
{
SharpDX.DXGI.Device d = Device.QueryInterface<SharpDX.DXGI.Device>();
Adapter a = d.GetParent<Adapter>();
var factory = a.GetParent<Factory>();
var scDesc = new SwapChainDescription();
scDesc.BufferCount = MyRender11Constants.BUFFER_COUNT;
scDesc.Flags = SwapChainFlags.AllowModeSwitch;
scDesc.IsWindowed = true;
scDesc.ModeDescription.Format = MyRender11Constants.DX11_BACKBUFFER_FORMAT;
scDesc.ModeDescription.Height = m_settings.BackBufferHeight;
scDesc.ModeDescription.Width = m_settings.BackBufferWidth;
scDesc.ModeDescription.RefreshRate.Numerator = m_settings.RefreshRate;
scDesc.ModeDescription.RefreshRate.Denominator = 1000;
scDesc.ModeDescription.Scaling = DisplayModeScaling.Unspecified;
scDesc.ModeDescription.ScanlineOrdering = DisplayModeScanlineOrder.Progressive;
scDesc.SampleDescription.Count = 1;
scDesc.SampleDescription.Quality = 0;
scDesc.OutputHandle = m_windowHandle;
scDesc.Usage = Usage.RenderTargetOutput;
scDesc.SwapEffect = SwapEffect.Discard;
m_swapchain = new SwapChain(factory, Device, scDesc);
m_swapchain.GetParent<Factory>().MakeWindowAssociation(m_windowHandle, WindowAssociationFlags.IgnoreAll);
}
// we start with window always (DXGI recommended)
m_settings.WindowMode = MyWindowModeEnum.Window;
ApplySettings(settings);
return m_settings;
}
private static void TryCreateDeviceInternal(IntPtr windowHandle, DeviceType deviceType, MyRenderDeviceSettings settingsToTry, out Device device, out PresentParameters parameters)
{
device = null;
parameters = CreatePresentParameters(settingsToTry, windowHandle);
while (device == null)
{
try
{
// These calls are here to ensure that none of these calls throw exceptions (even if their results are not used).
m_d3d.Dispose();
m_d3d = new Direct3D();
var d3dCaps = m_d3d.GetDeviceCaps(settingsToTry.AdapterOrdinal, DeviceType.Hardware);
device = new Device(m_d3d, settingsToTry.AdapterOrdinal, deviceType, Parameters.DeviceWindowHandle,
CreateFlags.HardwareVertexProcessing | CreateFlags.Multithreaded | CreateFlags.FpuPreserve,
Parameters);
device.Clear(ClearFlags.Target, new SharpDX.ColorBGRA(0, 0, 0, 1), 1.0f, 0);
var caps = Device.Capabilities;
}
catch (SharpDX.SharpDXException e)
{
if (e.ResultCode == ResultCode.NotAvailable ||
(e.ResultCode == ResultCode.InvalidCall && GetForegroundWindow() != Parameters.DeviceWindowHandle))
{
// User has probably Alt+Tabbed or locked his computer before the game has started.
// To counter this, we try creating device again a bit later.
Thread.Sleep(2000);
MyLog.Default.WriteLine("Device creation failed with " + e.Message);
}
else
{
// Either settings or graphics card are not supported.
MyLog.Default.WriteLine(e);
throw;
}
}
try
{
MyLog.Default.WriteLine("Loading adapters");
m_adaptersList = GetAdaptersList(m_d3d);
MyLog.Default.WriteLine("Found adapters");
foreach (var adapter in m_adaptersList)
{
adapter.LogInfo(MyLog.Default.WriteLine);
}
}
catch (Exception e)
{
MyLog.Default.WriteLine(e);
throw;
}
}
}
void WriteSettingsToControls(MyRenderDeviceSettings deviceSettings, MyGraphicsSettings graphicsSettings)
{
m_videoAdapterCombobox.SelectItemByKey(deviceSettings.AdapterOrdinal);
m_resolutionCombobox.SelectItemByKey(m_resolutionsForAdapter.FindIndex(
(res) => res.X == deviceSettings.BackBufferWidth && res.Y == deviceSettings.BackBufferHeight));
m_windowModeCombobox.SelectItemByKey((int)deviceSettings.WindowMode);
m_verticalSyncCheckbox.IsChecked = deviceSettings.VSync;
m_hardwareCursorCheckbox.IsChecked = graphicsSettings.HardwareCursor;
m_enableDamageEffectsCheckbox.IsChecked = graphicsSettings.EnableDamageEffects;
m_renderQualityCombobox.SelectItemByKey((int)graphicsSettings.Render.Dx9Quality);
if (m_renderQualityCombobox.GetSelectedKey() == -1)
m_renderQualityCombobox.SelectItemByIndex(0);
m_fieldOfViewSlider.Value = MathHelper.ToDegrees(graphicsSettings.FieldOfView);
m_renderInterpolationCheckbox.IsChecked = graphicsSettings.Render.InterpolationEnabled;
}
public static void ApplySettings(MyRenderDeviceSettings settings)
{
m_render.ApplySettings(settings);
}
public override void SwitchSettings(MyRenderDeviceSettings settings)
{
m_currentSettings = settings;
m_currentSettings.WindowMode = MyWindowModeEnum.Window;
base.SwitchSettings(m_currentSettings);
}
internal static void OnCreatedDeviceSettings(MyRenderMessageCreatedDeviceSettings message)
{
m_currentDeviceSettings = message.Settings;
m_currentDeviceSettings.NewAdapterOrdinal = m_currentDeviceSettings.AdapterOrdinal;
m_currentDeviceIsTripleHead = GetAspectRatio(GetClosestAspectRatio(((float)m_currentDeviceSettings.BackBufferWidth) / ((float)m_currentDeviceSettings.BackBufferHeight))).IsTripleHead;
}
public override void RecreateControls(bool constructor)
{
if (!constructor)
{
return;
}
base.RecreateControls(constructor);
AddCaption("Display settings");
var tmp = new Vector2(0.268f, 0.145f) * MyGuiConstants.GUI_OPTIMAL_SIZE;
var topLeft = m_size.Value * -0.5f;
var topRight = m_size.Value * new Vector2(0.5f, -0.5f);
Vector2 comboboxSize = new Vector2(600f, 0f) / MyGuiConstants.GUI_OPTIMAL_SIZE;
Vector2 controlsOriginLeft = topLeft + new Vector2(75f, 125f) / MyGuiConstants.GUI_OPTIMAL_SIZE;
Vector2 controlsOriginRight = topRight + new Vector2(-650f, 125f) / MyGuiConstants.GUI_OPTIMAL_SIZE;
const float TEXT_SCALE = Sandbox.Graphics.GUI.MyGuiConstants.DEFAULT_TEXT_SCALE * 0.85f;
var labelVideoAdapter = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.VideoAdapter));
var labelResolution = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.VideoMode));
var labelWindowMode = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.ScreenOptionsVideo_WindowMode));
var labelVSync = new MyGuiControlLabel(textScale: TEXT_SCALE, text: MyTexts.GetString(MySpaceTexts.VerticalSync));
m_comboVideoAdapter = new MyGuiControlCombobox(size: comboboxSize, toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsVideoAdapter));
m_comboResolution = new MyGuiControlCombobox(size: comboboxSize, toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsVideoMode));
m_comboWindowMode = new MyGuiControlCombobox(size: comboboxSize);
m_checkboxVSync = new MyGuiControlCheckbox(toolTip: MyTexts.GetString(MySpaceTexts.ToolTipVideoOptionsVerticalSync));
m_labelUnsupportedAspectRatio = new MyGuiControlLabel(colorMask: MyGuiConstants.LABEL_TEXT_COLOR * 0.9f, textScale: TEXT_SCALE * 0.85f);
m_labelRecommendAspectRatio = new MyGuiControlLabel(colorMask: MyGuiConstants.LABEL_TEXT_COLOR * 0.9f, textScale: TEXT_SCALE * 0.85f);
var hintLineOffset = new Vector2(0f, m_labelUnsupportedAspectRatio.Size.Y);
var hintOffset = new Vector2(0.01f, -0.35f * MyGuiConstants.CONTROLS_DELTA.Y);
labelVideoAdapter.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_comboVideoAdapter.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelResolution.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_comboResolution.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
m_labelUnsupportedAspectRatio.Position = controlsOriginRight + hintOffset;
m_labelRecommendAspectRatio.Position = controlsOriginRight + hintOffset + hintLineOffset;
controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelWindowMode.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_comboWindowMode.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
labelVSync.Position = controlsOriginLeft; controlsOriginLeft += MyGuiConstants.CONTROLS_DELTA;
m_checkboxVSync.Position = controlsOriginRight; controlsOriginRight += MyGuiConstants.CONTROLS_DELTA;
Controls.Add(labelVideoAdapter); Controls.Add(m_comboVideoAdapter);
Controls.Add(labelResolution); Controls.Add(m_comboResolution);
Controls.Add(m_labelUnsupportedAspectRatio);
Controls.Add(m_labelRecommendAspectRatio);
Controls.Add(labelWindowMode); Controls.Add(m_comboWindowMode);
Controls.Add(labelVSync); Controls.Add(m_checkboxVSync);
foreach (var control in Controls)
{
control.OriginAlign = MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_CENTER;
}
m_labelUnsupportedAspectRatio.Text = string.Format("* {0}", MyTexts.Get(MySpaceTexts.UnsupportedAspectRatio));
{ // AddAdaptersToComboBox
int counter = 0;
foreach (var adapter in MyVideoSettingsManager.Adapters)
{
m_comboVideoAdapter.AddItem(counter++, new StringBuilder(adapter.Name));
}
}
// These options show up if there are no supported display modes
m_comboWindowMode.AddItem((int)MyWindowModeEnum.Window, MySpaceTexts.ScreenOptionsVideo_WindowMode_Window);
m_comboWindowMode.AddItem((int)MyWindowModeEnum.FullscreenWindow, MySpaceTexts.ScreenOptionsVideo_WindowMode_FullscreenWindow);
m_comboVideoAdapter.ItemSelected += ComboVideoAdapter_ItemSelected;
m_comboResolution.ItemSelected += ComboResolution_ItemSelected;
// Buttons Ok and Cancel
Controls.Add(new MyGuiControlButton(
position: Size.Value * new Vector2(-0.5f, 0.5f) + new Vector2(100f, -75f) / MyGuiConstants.GUI_OPTIMAL_SIZE,
size: MyGuiConstants.OK_BUTTON_SIZE,
text: MyTexts.Get(MySpaceTexts.Ok),
onButtonClick: OnOkClick,
originAlign: MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_BOTTOM));
Controls.Add(new MyGuiControlButton(
position: Size.Value * new Vector2(0.5f, 0.5f) + new Vector2(-100f, -75f) / MyGuiConstants.GUI_OPTIMAL_SIZE,
size: MyGuiConstants.OK_BUTTON_SIZE,
text: MyTexts.Get(MySpaceTexts.Cancel),
onButtonClick: OnCancelClick,
originAlign: MyGuiDrawAlignEnum.HORISONTAL_RIGHT_AND_VERTICAL_BOTTOM));
// Update controls with values from config file
m_settingsOld = MyVideoSettingsManager.CurrentDeviceSettings;
m_settingsNew = m_settingsOld;
WriteSettingsToControls(m_settingsOld);
// Update OLD settings
ReadSettingsFromControls(ref m_settingsOld);
ReadSettingsFromControls(ref m_settingsNew);
CloseButtonEnabled = true;
CloseButtonOffset = new Vector2(-50f, 50f) / MyGuiConstants.GUI_OPTIMAL_SIZE;
}
public virtual void SwitchSettings(MyRenderDeviceSettings settings)
{
MyRenderProxy.SwitchDeviceSettings(settings);
}
public bool SettingsChanged(MyRenderDeviceSettings settings)
{
return MyRender.SettingsChanged(settings);
}
protected virtual void StartRenderComponent(MyRenderDeviceSettings? settingsToTry)
{
GameRenderComponent.Start(m_gameTimer, InitializeRenderThread, settingsToTry, MyRenderQualityEnum.NORMAL);
GameRenderComponent.RenderThread.SizeChanged += RenderThread_SizeChanged;
GameRenderComponent.RenderThread.BeforeDraw += RenderThread_BeforeDraw;
}
public MyRenderDeviceSettings CreateDevice(IntPtr windowHandle, MyRenderDeviceSettings? settingsToTry)
{
return MyRender.CreateDevice(windowHandle, settingsToTry);
}
public void SwitchSettings(MyRenderDeviceSettings settings)
{
Debug.Assert(Thread.CurrentThread == SystemThread);
m_newSettings = settings;
}
