/// <summary> /// Initializes a new instance of the <see cref="DeviceHandlerD3D9"/> class. /// </summary> /// <param name="dxgiAdapter">The target adapter.</param> /// <param name="isSoftwareAdapter">Are we in software mode?</param> /// <param name="debugEnabled">Is debug mode enabled?</param> internal DeviceHandlerD3D9(DXGI.Adapter1 dxgiAdapter, bool isSoftwareAdapter, bool debugEnabled) { // Update member variables m_dxgiAdapter = dxgiAdapter; try { // Just needed when on true hardware if (!isSoftwareAdapter) { //Prepare device creation D3D9.CreateFlags createFlags = D3D9.CreateFlags.HardwareVertexProcessing | D3D9.CreateFlags.PureDevice | D3D9.CreateFlags.FpuPreserve | D3D9.CreateFlags.Multithreaded; D3D9.PresentParameters presentparams = new D3D9.PresentParameters(); presentparams.Windowed = true; presentparams.SwapEffect = D3D9.SwapEffect.Discard; presentparams.DeviceWindowHandle = GetDesktopWindow(); presentparams.PresentationInterval = D3D9.PresentInterval.Default; presentparams.BackBufferCount = 1; //Create the device finally m_direct3DEx = new D3D9.Direct3DEx(); // Try to find the Direct3D9 adapter that maches given DXGI adapter m_adapterIndex = -1; for (int loop = 0; loop < m_direct3DEx.AdapterCount; loop++) { var d3d9AdapterInfo = m_direct3DEx.GetAdapterIdentifier(loop); if (d3d9AdapterInfo.DeviceId == m_dxgiAdapter.Description1.DeviceId) { m_adapterIndex = loop; break; } } // Direct3D 9 is only relevant on the primary device if (m_adapterIndex < 0) { return; } // Try to create the device m_deviceEx = new D3D9.DeviceEx(m_direct3DEx, m_adapterIndex, D3D9.DeviceType.Hardware, IntPtr.Zero, createFlags, presentparams); } else { //Not supported in software mode } } catch (Exception) { // No direct3d 9 interface support GraphicsHelper.SafeDispose(ref m_direct3DEx); GraphicsHelper.SafeDispose(ref m_deviceEx); } }
/// <summary> /// Unloads all resources. /// </summary> internal void UnloadResources() { m_factory = CommonTools.DisposeObject(m_factory); m_adapter = CommonTools.DisposeObject(m_adapter); #if UNIVERSAL m_device = CommonTools.DisposeObject(m_device); #endif }
/// <summary> /// Initializes a new instance of the <see cref="EngineDevice"/> class. /// </summary> internal EngineDevice(GraphicsCore core, GraphicsCoreConfiguration coreConfiguration, DXGI.Adapter1 adapter, bool isSoftwareAdapter, bool debugEnabled) { m_core = core; m_adapter1 = adapter; m_adapterDesc1 = m_adapter1.Description1; m_isSoftwareAdapter = isSoftwareAdapter; m_debugEnabled = debugEnabled; m_configuration = new GraphicsDeviceConfiguration(coreConfiguration); // Set default antialiasing configurations m_sampleDescWithAntialiasing = new DXGI.SampleDescription(1, 0); // Initialize all direct3D APIs try { #if UNIVERSAL m_handlerD3D11 = new DeviceHandlerD3D11(adapter, debugEnabled); m_handlerDXGI = new DeviceHandlerDXGI(adapter, m_handlerD3D11.Device1); #endif #if DESKTOP m_handlerD3D11 = new DeviceHandlerD3D11(adapter, debugEnabled); m_handlerDXGI = new DeviceHandlerDXGI(adapter, m_handlerD3D11.Device1); m_handlerD3D9 = new DeviceHandlerD3D9(adapter, isSoftwareAdapter, debugEnabled); #endif } catch (Exception ex) { m_initializationException = ex; #if UNIVERSAL m_handlerD3D11 = null; m_handlerDXGI = null; #endif #if DESKTOP m_handlerD3D11 = null; m_handlerDXGI = null; m_handlerD3D9 = null; #endif } // Set default configuration m_configuration.TextureQuality = !isSoftwareAdapter && m_handlerD3D11.IsDirect3D10OrUpperHardware ? TextureQuality.Hight : TextureQuality.Low; m_configuration.GeometryQuality = !isSoftwareAdapter && m_handlerD3D11.IsDirect3D10OrUpperHardware ? GeometryQuality.Hight : GeometryQuality.Low; // Initialize handlers for feature support information if (m_initializationException == null) { m_isStandardAntialiasingSupported = CheckIsStandardAntialiasingPossible(); } // Initialize direct2D handler finally if (m_handlerD3D11 != null) { m_handlerD2D = new DeviceHandlerD2D(m_core, this); this.FakeRenderTarget2D = m_handlerD2D.RenderTarget; } }
/// <summary> /// Initializes a new instance of the <see cref="DeviceHandlerDXGI"/> class. /// </summary> internal DeviceHandlerDXGI(DXGI.Adapter1 adapter, D3D11.Device device) { #if UNIVERSAL m_device = device.QueryInterface <DXGI.Device3>(); #endif m_adapter = adapter; m_factory = m_adapter.GetParent <DXGI.Factory2>(); }
internal DXGI.Output GetOutputByOutputInfo(EngineOutputInfo outputInfo) { int adapterCount = m_dxgiFactory.GetAdapterCount1(); if (outputInfo.AdapterIndex >= adapterCount) { throw new SeeingSharpException($"Unable to find adapter with index {outputInfo.AdapterIndex}!"); } using (DXGI.Adapter1 adapter = m_dxgiFactory.GetAdapter1(outputInfo.AdapterIndex)) { int outputCount = adapter.GetOutputCount(); if (outputInfo.OutputIndex >= outputCount) { throw new SeeingSharpException($"Unable to find output with index {outputInfo.OutputIndex} on adapter {outputInfo.AdapterIndex}!"); } return(adapter.GetOutput(outputInfo.OutputIndex)); } }
/// <summary> /// Loads all adapter information and builds up all needed view models in a background thread. /// </summary> private void LoadAdapterInformation() { m_adapters = new List <EngineAdapterInfo>(); int adapterCount = m_dxgiFactory.GetAdapterCount1(); for (int loop = 0; loop < adapterCount; loop++) { try { DXGI.Adapter1 actAdapter = m_dxgiFactory.GetAdapter1(loop); m_adapters.Add(new EngineAdapterInfo(loop, actAdapter)); } catch (Exception) { //No exception handling needed here // .. adapter information simply can not be gathered } } }
/// <summary> /// Initializes a new instance of the <see cref="EngineAdapterInfo" /> class. /// </summary> internal EngineAdapterInfo(int adapterIndex, DXGI.Adapter1 adapter) { m_outputs = new List <EngineOutputInfo>(); m_adapter = adapter; m_adapterIndex = adapterIndex; m_adapterDescription = adapter.Description; m_isSoftware = (m_adapterDescription.Description == "Microsoft Basic Render Driver") || ((!string.IsNullOrEmpty(m_adapterDescription.Description)) && m_adapterDescription.Description.Contains("Software")) || ((!string.IsNullOrEmpty(m_adapterDescription.Description)) && m_adapterDescription.Description.Contains("Microsoft Basic Render Driver")); m_d3d11FeatureLevel = D3D11.Device.GetSupportedFeatureLevel(adapter); //Query for output information DXGI.Output[] outputs = adapter.Outputs; for (int loop = 0; loop < outputs.Length; loop++) { try { DXGI.Output actOutput = outputs[loop]; try { m_outputs.Add(new EngineOutputInfo(adapterIndex, loop, actOutput)); } finally { actOutput.Dispose(); } } catch (Exception) { //Query for output information not possible // .. no special handling needed here } } }
/// <summary> /// Initializes a new instance of the <see cref="GorgonVideoDevice"/> class. /// </summary> /// <param name="adapter">DXGI video adapter.</param> /// <param name="deviceType">Type of video device.</param> /// <param name="index">Index of the device.</param> internal GorgonVideoDevice(GI.Adapter1 adapter, VideoDeviceType deviceType, int index) { VideoDeviceType = deviceType; Index = index; DedicatedSystemMemory = adapter.Description1.DedicatedSystemMemory; DedicatedVideoMemory = adapter.Description1.DedicatedVideoMemory; DeviceID = adapter.Description1.DeviceId; HardwareFeatureLevel = DeviceFeatureLevel.Unsupported; UUID = adapter.Description1.Luid; Revision = adapter.Description1.Revision; SharedSystemMemory = adapter.Description1.SharedSystemMemory; SubSystemID = adapter.Description1.SubsystemId; VendorID = adapter.Description1.VendorId; switch (deviceType) { case VideoDeviceType.Software: Name = Resources.GORGFX_DEVICE_NAME_WARP; HardwareFeatureLevel = SupportedFeatureLevel = DeviceFeatureLevel.SM4_1; break; case VideoDeviceType.ReferenceRasterizer: Name = Resources.GORGFX_DEVICE_NAME_REFRAST; HardwareFeatureLevel = SupportedFeatureLevel = DeviceFeatureLevel.SM5; break; default: Name = adapter.Description1.Description; EnumerateFeatureLevels(D3D.Device.GetSupportedFeatureLevel(adapter)); break; } Outputs = new GorgonNamedObjectReadOnlyCollection <GorgonVideoOutput>(false, new GorgonVideoOutput[] { }); }
private static GraphicsAdapter CreateAdapter(SharpDX.DXGI.Adapter1 device, SharpDX.DXGI.Output monitor) { var adapter = new GraphicsAdapter(); adapter._adapter = device; adapter.DeviceName = monitor.Description.DeviceName.TrimEnd(new char[] { '\0' }); adapter.Description = device.Description1.Description.TrimEnd(new char[] { '\0' }); adapter.DeviceId = device.Description1.DeviceId; adapter.Revision = device.Description1.Revision; adapter.VendorId = device.Description1.VendorId; adapter.SubSystemId = device.Description1.SubsystemId; adapter.MonitorHandle = monitor.Description.MonitorHandle; #if WINDOWS_UAP var desktopWidth = monitor.Description.DesktopBounds.Right - monitor.Description.DesktopBounds.Left; var desktopHeight = monitor.Description.DesktopBounds.Bottom - monitor.Description.DesktopBounds.Top; #else var desktopWidth = monitor.Description.DesktopBounds.Width; var desktopHeight = monitor.Description.DesktopBounds.Height; #endif var modes = new List <DisplayMode>(); foreach (var formatTranslation in FormatTranslations) { SharpDX.DXGI.ModeDescription[] displayModes; // This can fail on headless machines, so just assume the desktop size // is a valid mode and return that... so at least our unit tests work. try { displayModes = monitor.GetDisplayModeList(formatTranslation.Key, 0); } catch (SharpDX.SharpDXException) { var mode = new DisplayMode(desktopWidth, desktopHeight, SurfaceFormat.Color); modes.Add(mode); adapter._currentDisplayMode = mode; break; } foreach (var displayMode in displayModes) { var mode = new DisplayMode(displayMode.Width, displayMode.Height, formatTranslation.Value); // Skip duplicate modes with the same width/height/formats. if (modes.Contains(mode)) { continue; } modes.Add(mode); if (adapter._currentDisplayMode == null) { if (mode.Width == desktopWidth && mode.Height == desktopHeight && mode.Format == SurfaceFormat.Color) { adapter._currentDisplayMode = mode; } } } } adapter._supportedDisplayModes = new DisplayModeCollection(modes); if (adapter._currentDisplayMode == null) //(i.e. desktop mode wasn't found in the available modes) { adapter._currentDisplayMode = new DisplayMode(desktopWidth, desktopHeight, SurfaceFormat.Color); } return(adapter); }
/// <summary> /// Initializes a new instance of the <see cref="DeviceHandlerD3D11"/> class. /// </summary> /// <param name="dxgiAdapter">The tasrget adapter.</param> /// <param name="debugEnabled">Is debug mode enabled?</param> internal DeviceHandlerD3D11(DXGI.Adapter1 dxgiAdapter, bool debugEnabled) { m_dxgiAdapter = dxgiAdapter; // Define possible create flags D3D11.DeviceCreationFlags createFlagsBgra = D3D11.DeviceCreationFlags.BgraSupport; D3D11.DeviceCreationFlags createFlags = D3D11.DeviceCreationFlags.None; if (debugEnabled) { createFlagsBgra |= D3D11.DeviceCreationFlags.Debug; createFlags |= D3D11.DeviceCreationFlags.Debug; } // Define all steps on which we try to initialize Direct3D List <Tuple <D3D.FeatureLevel, D3D11.DeviceCreationFlags, HardwareDriverLevel> > initParameterQueue = new List <Tuple <D3D.FeatureLevel, D3D11.DeviceCreationFlags, HardwareDriverLevel> >(); // Define all trys for hardware initialization initParameterQueue.Add(Tuple.Create( D3D.FeatureLevel.Level_11_1, createFlagsBgra, HardwareDriverLevel.Direct3D11)); initParameterQueue.Add(Tuple.Create( D3D.FeatureLevel.Level_11_0, createFlagsBgra, HardwareDriverLevel.Direct3D11)); initParameterQueue.Add(Tuple.Create( D3D.FeatureLevel.Level_10_0, createFlagsBgra, HardwareDriverLevel.Direct3D10)); initParameterQueue.Add(Tuple.Create( D3D.FeatureLevel.Level_9_3, createFlagsBgra, HardwareDriverLevel.Direct3D9_3)); initParameterQueue.Add(Tuple.Create( D3D.FeatureLevel.Level_9_2, createFlagsBgra, HardwareDriverLevel.Direct3D9_2)); initParameterQueue.Add(Tuple.Create( D3D.FeatureLevel.Level_9_1, createFlagsBgra, HardwareDriverLevel.Direct3D9_1)); initParameterQueue.Add(Tuple.Create( D3D.FeatureLevel.Level_10_0, createFlags, HardwareDriverLevel.Direct3D10)); initParameterQueue.Add(Tuple.Create( D3D.FeatureLevel.Level_9_3, createFlags, HardwareDriverLevel.Direct3D9_3)); initParameterQueue.Add(Tuple.Create( D3D.FeatureLevel.Level_9_2, createFlags, HardwareDriverLevel.Direct3D9_2)); initParameterQueue.Add(Tuple.Create( D3D.FeatureLevel.Level_9_1, createFlags, HardwareDriverLevel.Direct3D9_1)); // Try to create the device, each defined configuration step by step foreach (Tuple <D3D.FeatureLevel, D3D11.DeviceCreationFlags, HardwareDriverLevel> actInitParameters in initParameterQueue) { D3D.FeatureLevel featureLevel = actInitParameters.Item1; D3D11.DeviceCreationFlags direct3D11Flags = actInitParameters.Item2; HardwareDriverLevel actDriverLevel = actInitParameters.Item3; try { // Try to create the device using current parameters using (D3D11.Device device = new D3D11.Device(dxgiAdapter, direct3D11Flags, featureLevel)) { m_device1 = device.QueryInterface <D3D11.Device1>(); m_device3 = CommonTools.TryExecute(() => m_device1.QueryInterface <D3D11.Device3>()); if (m_device3 != null) { m_immediateContext3 = m_device3.ImmediateContext3; } } // Device successfully created, save all parameters and break this loop m_featureLevel = featureLevel; m_creationFlags = direct3D11Flags; m_driverLevel = actDriverLevel; break; } catch (Exception) { } } // Throw exception on failure if (m_device1 == null) { throw new SeeingSharpGraphicsException("Unable to initialize d3d11 device!"); } // Get immediate context from the device m_immediateContext = m_device1.ImmediateContext; }
public D3D12GraphicsDevice(bool validation, PresentationParameters presentationParameters) : base(GraphicsBackend.Direct3D12, presentationParameters) { #if DEBUG SharpDX.Configuration.EnableObjectTracking = true; SharpDX.Configuration.ThrowOnShaderCompileError = false; #endif // Just try to enable debug layer. try { if (validation) { // Enable the D3D12 debug layer. DebugInterface.Get().EnableDebugLayer(); Validation = true; } } catch (SharpDX.SharpDXException) { Validation = false; } // Create factory first. DXGIFactory = new DXGI.Factory4(Validation); var adapterCount = DXGIFactory.GetAdapterCount1(); for (var i = 0; i < adapterCount; i++) { var adapter = DXGIFactory.GetAdapter1(i); var desc = adapter.Description1; // Don't select the Basic Render Driver adapter. if ((desc.Flags & DXGI.AdapterFlags.Software) != DXGI.AdapterFlags.None) { continue; } var tempDevice = new Device(adapter, FeatureLevel.Level_11_0); tempDevice.Dispose(); DXGIAdapter = adapter; } try { Device = new Device(DXGIAdapter, FeatureLevel.Level_11_0); } catch (SharpDXException) { // Create the Direct3D 12 with WARP adapter. var warpAdapter = DXGIFactory.GetWarpAdapter(); Device = new Device(warpAdapter, FeatureLevel.Level_11_0); } if (Validation) { var infoQueue = Device.QueryInterfaceOrNull <InfoQueue>(); if (infoQueue != null) { infoQueue.SetBreakOnSeverity(MessageSeverity.Corruption, true); infoQueue.SetBreakOnSeverity(MessageSeverity.Error, true); infoQueue.AddStorageFilterEntries(new InfoQueueFilter { DenyList = new InfoQueueFilterDescription { Ids = new[] { MessageId.MapInvalidNullRange, MessageId.UnmapInvalidNullRange } } }); infoQueue.Dispose(); } } // Init capabilities. FeatureLevel = Device.CheckMaxSupportedFeatureLevel(s_featureLevels); var D3D12Options = Device.D3D12Options; var dataShaderModel = Device.CheckShaderModel(ShaderModel.Model60); var dataShaderModel1 = Device.CheckShaderModel(ShaderModel.Model61); var dataShaderModel2 = Device.CheckShaderModel(ShaderModel.Model62); var waveIntrinsicsSupport = default(FeatureDataD3D12Options1); Device.CheckFeatureSupport(Feature.D3D12Options1, ref waveIntrinsicsSupport); var featureDataRootSignature = new FeatureDataRootSignature { HighestVersion = RootSignatureVersion.Version11 }; if (!Device.CheckFeatureSupport(Feature.RootSignature, ref featureDataRootSignature)) { featureDataRootSignature.HighestVersion = RootSignatureVersion.Version10; } var gpuVaSupport = Device.GpuVirtualAddressSupport; // Create direct command queue. GraphicsQueue = new D3D12CommandQueue(this, CommandListType.Direct); // Get descriptor heaps size. RTVDescriptorSize = Device.GetDescriptorHandleIncrementSize(DescriptorHeapType.RenderTargetView); DSVDescriptorSize = Device.GetDescriptorHandleIncrementSize(DescriptorHeapType.DepthStencilView); // Create main swap chain. _mainSwapchain = new D3D12Swapchain(this, presentationParameters); }