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; }
public static MyRenderThread Start(MyGameTimer timer, InitHandler initHandler, MyRenderDeviceSettings?settingsToTry, MyRenderQualityEnum renderQuality, float maxFrameRate) { var result = new MyRenderThread(timer, true, maxFrameRate); result.SystemThread.Start(new StartParams() { InitHandler = initHandler, SettingsToTry = settingsToTry, RenderQuality = renderQuality }); return(result); }
internal static MyRenderDeviceSettings CreateDevice(IntPtr windowHandle, MyRenderDeviceSettings?settingsToTry) { if (Device != null) { Device.Dispose(); Device = null; } FeatureLevel[] featureLevels = { FeatureLevel.Level_11_0 }; DeviceCreationFlags flags = DeviceCreationFlags.None; #if DEBUG_DEVICE flags |= DeviceCreationFlags.Debug; #endif WinApi.DEVMODE mode = new WinApi.DEVMODE(); WinApi.EnumDisplaySettings(null, WinApi.ENUM_REGISTRY_SETTINGS, ref mode); var adapters = GetAdaptersList(); int adapterIndex = settingsToTry.HasValue ? settingsToTry.Value.AdapterOrdinal : -1; bool adapterIndexNotValid = adapterIndex == -1 || adapters.Length <= settingsToTry.Value.AdapterOrdinal || !adapters[settingsToTry.Value.AdapterOrdinal].IsSupported; if (adapterIndexNotValid) { var maxVram = 0ul; for (int i = 0; i < adapters.Length; i++) { if (adapters[i].IsSupported) { maxVram = (ulong)Math.Max(maxVram, adapters[i].VRAM); } } // taking supporting adapter with most VRAM for (int i = 0; i < adapters.Length; i++) { if (adapters[i].IsSupported && adapters[i].VRAM == maxVram) { adapterIndex = i; break; } } } if (adapterIndex == -1) { throw new MyRenderException("No supporting device detected!", MyRenderExceptionEnum.GpuNotSupported); } var settings = settingsToTry ?? new MyRenderDeviceSettings() { AdapterOrdinal = adapterIndex, BackBufferHeight = mode.dmPelsHeight, BackBufferWidth = mode.dmPelsWidth, WindowMode = MyWindowModeEnum.Fullscreen, VSync = false, }; m_settings = settings; Device = new Device(GetFactory().Adapters[adapters[m_settings.AdapterOrdinal].AdapterDeviceId], 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 (ImmediateContext != null) { ImmediateContext.Dispose(); ImmediateContext = null; } ImmediateContext = 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.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); }
public static MyRenderThread StartSync(MyGameTimer timer, IMyRenderWindow renderWindow, MyRenderDeviceSettings?settingsToTry, MyRenderQualityEnum renderQuality, float maxFrameRate) { var result = new MyRenderThread(timer, false, maxFrameRate); result.m_renderWindow = renderWindow; result.m_settings = MyRenderProxy.CreateDevice(result, renderWindow.Handle, settingsToTry); MyRenderProxy.SendCreatedDeviceSettings(result.m_settings); result.m_currentQuality = renderQuality; #if XB1 Debug.Assert(false); #else result.m_form = Control.FromHandle(renderWindow.Handle); #endif result.LoadContent(); result.UpdateSize(); return(result); }
public void SwitchSettings(MyRenderDeviceSettings settings) { Debug.Assert(Thread.CurrentThread == SystemThread); m_newSettings = settings; }
public void ApplyRenderSettings(MyRenderDeviceSettings?settings) { }
private static MyRenderDeviceSettings CreateDeviceInternal(IntPtr windowHandle, MyRenderDeviceSettings?settingsToTry, bool forceDebugDevice) { if (Device != null) { Device.Dispose(); Device = null; } WIC = null; if (settingsToTry != null) { Log.WriteLine("CreateDevice - original settings"); Log.IncreaseIndent(); var originalSettings = settingsToTry.Value; LogSettings(ref originalSettings); } FeatureLevel[] featureLevels = { FeatureLevel.Level_11_0 }; DeviceCreationFlags flags = DeviceCreationFlags.None; //forceDebugDevice |= MyCompilationSymbols.IsDebugBuild; if (forceDebugDevice) { flags |= DeviceCreationFlags.Debug; } #if !XB1 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.FullscreenWindow, RefreshRate = 60000, VSync = false, }; #else var settings = CreateXB1Settings(); #endif settings.AdapterOrdinal = ValidateAdapterIndex(settings.AdapterOrdinal); if (settings.AdapterOrdinal == -1) { throw new MyRenderException("No supported device detected!\nPlease apply windows updates and update to latest graphics drivers.", MyRenderExceptionEnum.GpuNotSupported); } m_settings = settings; Log.WriteLine("CreateDeviceInteral settings"); Log.IncreaseIndent(); LogSettings(ref m_settings); // If this line crashes cmd this: Dism /online /add-capability /capabilityname:Tools.Graphics.DirectX~~~~0.0.1.0 var factory = GetFactory(); var adapters = GetAdaptersList(); if (m_settings.AdapterOrdinal >= adapters.Length) { throw new MyRenderException("No supported device detected!\nPlease apply windows updates and update to latest graphics drivers.", MyRenderExceptionEnum.GpuNotSupported); } var adapterId = adapters[m_settings.AdapterOrdinal].AdapterDeviceId; if (adapterId >= factory.Adapters.Length) { throw new MyRenderException("Invalid adapter id binding!", MyRenderExceptionEnum.GpuNotSupported); } var adapter = factory.Adapters[adapterId]; Log.WriteLine("CreateDeviceInteral TweakSettingsAdapterAdHoc"); TweakSettingsAdapterAdHoc(adapter); Log.WriteLine("CreateDeviceInteral create device"); Device = new Device(adapter, flags, FeatureLevel.Level_11_0); Log.WriteLine("CreateDeviceInteral create ImagingFactory"); WIC = new ImagingFactory(); // HACK: This is required for Steam overlay to work. Apparently they hook only CreateDevice methods with DriverType argument. try { Log.WriteLine("CreateDeviceInteral Steam Overlay integration"); using (new Device(DriverType.Hardware, flags, FeatureLevel.Level_11_0)) { } Log.WriteLine("CreateDeviceInteral Steam Overlay OK"); } catch { Log.WriteLine("CreateDeviceInteral Steam Overlay Failed"); } Log.WriteLine("CreateDeviceInteral InitDebugOutput"); InitDebugOutput(forceDebugDevice); Log.WriteLine("CreateDeviceInteral RC Dispose"); if (RC != null) { RC.Dispose(); RC = null; } Log.WriteLine("CreateDeviceInteral RC Create"); RC = new MyRenderContext(); Log.WriteLine("CreateDeviceInteral RC Initialize"); RC.Initialize(Device.ImmediateContext); m_windowHandle = windowHandle; m_resolution = new Vector2I(m_settings.BackBufferWidth, m_settings.BackBufferHeight); Log.WriteLine("CreateDeviceInteral m_initializedOnce (" + m_initializedOnce + ")"); if (!m_initializedOnce) { InitSubsystemsOnce(); m_initializedOnce = true; } Log.WriteLine("CreateDeviceInteral m_initialized (" + m_initialized + ")"); if (!m_initialized) { OnDeviceReset(); InitSubsystems(); m_initialized = true; } Log.WriteLine("CreateDeviceInteral m_swapchain (" + m_swapchain + ")"); if (m_swapchain != null) { m_swapchain.Dispose(); m_swapchain = null; } Log.WriteLine("CreateDeviceInteral create swapchain"); 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; try { m_swapchain = new SwapChain(factory, Device, scDesc); } catch (Exception ex) { Log.WriteLine("SwapChain factory = " + factory); Log.WriteLine("SwapChain Device = " + Device); Log.WriteLine("SwapChainDescription.BufferCount = " + scDesc.BufferCount); Log.WriteLine("SwapChainDescription.Flags = " + scDesc.Flags); Log.WriteLine("SwapChainDescription.ModeDescription.Format = " + scDesc.ModeDescription.Format); Log.WriteLine("SwapChainDescription.ModeDescription.Height = " + scDesc.ModeDescription.Height); Log.WriteLine("SwapChainDescription.ModeDescription.Width = " + scDesc.ModeDescription.Width); Log.WriteLine("SwapChainDescription.ModeDescription.RefreshRate.Numerator = " + scDesc.ModeDescription.RefreshRate.Numerator); Log.WriteLine("SwapChainDescription.ModeDescription.RefreshRate.Denominator = " + scDesc.ModeDescription.RefreshRate.Denominator); Log.WriteLine("SwapChainDescription.ModeDescription.Scaling = " + scDesc.ModeDescription.Scaling); Log.WriteLine("SwapChainDescription.ModeDescription.ScanlineOrdering = " + scDesc.ModeDescription.ScanlineOrdering); Log.WriteLine("SwapChainDescription.SampleDescription.Count = " + scDesc.SampleDescription.Count); Log.WriteLine("SwapChainDescription.SampleDescription.Quality = " + scDesc.SampleDescription.Quality); Log.WriteLine("SwapChainDescription.BufferCount = " + scDesc.BufferCount); Log.WriteLine("SwapChainDescription.Usage = " + scDesc.Usage); Log.WriteLine("SwapChainDescription.SwapEffect = " + scDesc.SwapEffect); throw ex; } factory.MakeWindowAssociation(m_windowHandle, WindowAssociationFlags.IgnoreAll); } // we start with window always (DXGI recommended) Log.WriteLine("CreateDeviceInteral Apply Settings"); m_settings.WindowMode = MyWindowModeEnum.Window; ApplySettings(settings); Log.WriteLine("CreateDeviceInteral done (" + m_settings + ")"); return(m_settings); }
/// <summary> /// Creates and starts render thread /// </summary> public void Start(MyGameTimer timer, InitHandler windowInitializer, MyRenderDeviceSettings?settingsToTry, MyRenderQualityEnum renderQuality) { RenderThread = MyRenderThread.Start(timer, windowInitializer, settingsToTry, renderQuality); }
public MyRenderDeviceSettings CreateDevice(IntPtr windowHandle, MyRenderDeviceSettings?settingsToTry) { return(default(MyRenderDeviceSettings)); }
internal static MyRenderDeviceSettings CreateDevice(IntPtr windowHandle, MyRenderDeviceSettings?settingsToTry) { MyRenderExceptionEnum exceptionEnum; bool deviceCreated = CreateDeviceInternalSafe(windowHandle, settingsToTry, false, out exceptionEnum); Log.WriteLine("CreateDevice: deviceCreated = " + deviceCreated); Log.WriteLine("CreateDevice: deviceCreated = " + deviceCreated); #if !XB1 if (!settingsToTry.HasValue || !settingsToTry.Value.SettingsMandatory) { if (!deviceCreated) { if (settingsToTry.HasValue && settingsToTry.Value.UseStereoRendering) { Log.WriteLine("CreateDevice: Attempt to create stereo renderer"); var newSettings = settingsToTry.Value; newSettings.UseStereoRendering = false; deviceCreated = CreateDeviceInternalSafe(windowHandle, newSettings, false, out exceptionEnum); } } 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, false, out exceptionEnum); break; } } } } } 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, false, out exceptionEnum); } if (!deviceCreated) { Log.WriteLine("Debug device fallback"); deviceCreated = CreateDeviceInternalSafe(windowHandle, settingsToTry, true, out exceptionEnum); } } #else #if !XB1_SKIPASSERTFORNOW System.Diagnostics.Debug.Assert(false, "simpleSettings is initialized but not used?"); #endif // !XB1_SKIPASSERTFORNOW Log.WriteLine("XB1 res fallback."); var simpleSettings = CreateXB1Settings(); #endif if (!deviceCreated) { // always display user friendly text to update drivers string message = string.Format("Graphics card could not be initialized. Please, apply windows updates and update to the latest graphics drivers."); VRage.Utils.MyMessageBox.Show("Unable to initialize the graphics system", message); throw new MyRenderException("No supported device detected!\nPlease apply windows updates and update to latest graphics drivers.", MyRenderExceptionEnum.GpuNotSupported); } return(m_settings); }
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); }
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); }
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 void ApplyRenderSettings(MyRenderDeviceSettings?settings) { throw new NotImplementedException(); }
public void StartSync(MyGameTimer timer, IMyRenderWindow window, MyRenderDeviceSettings?settings, MyRenderQualityEnum renderQuality) { RenderThread = MyRenderThread.StartSync(timer, window, settings, renderQuality); }
public void CreateRenderDevice(ref MyRenderDeviceSettings?settings, out object deviceInstance, out object swapChain) { throw new NotImplementedException(); }
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) { #if !XB1 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; } #else // XB1 System.Diagnostics.Debug.Assert(false, "XB1 TODO?"); #endif // XB1 } } 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. #if !XB1 MyMessageBox.Show("Unsupported graphics card", "Graphics card is not supported, please see minimum requirements"); #else // XB1 System.Diagnostics.Debug.Assert(false, "Unsupported graphics card"); #endif // XB1 throw; } } SupportsHDR = GetAdaptersList()[m_settings.AdapterOrdinal].HDRSupported; return(m_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 void CreateRenderDevice(ref MyRenderDeviceSettings?settings, out object deviceInstance, out object swapChain) { deviceInstance = null; swapChain = null; }