static void Main() { #region Direct3D Initialization // Create the window to render to Form1 form = new Form1(); form.Text = "D3DRendering - Initialize D3D 11.1"; form.Width = 640; form.Height = 480; // Create the device and swapchain Device1 device; SwapChain1 swapChain; // First create a regular D3D11 device using ( var device11 = new Device( SharpDX.Direct3D.DriverType.Hardware, DeviceCreationFlags.None, new [] { SharpDX.Direct3D.FeatureLevel.Level_11_1, SharpDX.Direct3D.FeatureLevel.Level_11_0, })) { // Query device for the Device1 interface (ID3D11Device1) device = device11.QueryInterfaceOrNull<Device1>(); if (device == null) throw new NotSupportedException("SharpDX.Direct3D11.Device1 is not supported"); } // Rather than create a new DXGI Factory we should reuse // the one that has been used internally to create the device using (var dxgi = device.QueryInterface<SharpDX.DXGI.Device2>()) using (var adapter = dxgi.Adapter) using (var factory = adapter.GetParent<Factory2>()) { var desc1 = new SwapChainDescription1() { Width = form.ClientSize.Width, Height = form.ClientSize.Height, Format = Format.R8G8B8A8_UNorm, Stereo = false, SampleDescription = new SampleDescription(1, 0), Usage = Usage.BackBuffer | Usage.RenderTargetOutput, BufferCount = 1, Scaling = Scaling.Stretch, SwapEffect = SwapEffect.Discard, }; swapChain = new SwapChain1(factory, device, form.Handle, ref desc1, new SwapChainFullScreenDescription() { RefreshRate = new Rational(60, 1), Scaling = DisplayModeScaling.Centered, Windowed = true }, // Restrict output to specific Output (monitor) null); } // Create references to backBuffer and renderTargetView var backBuffer = Texture2D.FromSwapChain<Texture2D>(swapChain, 0); var renderTargetView = new RenderTargetView(device, backBuffer); #endregion #region Render loop // Create Clock and FPS counters var clock = new System.Diagnostics.Stopwatch(); var clockFrequency = (double)System.Diagnostics.Stopwatch.Frequency; clock.Start(); var deltaTime = 0.0; var fpsTimer = new System.Diagnostics.Stopwatch(); fpsTimer.Start(); var fps = 0.0; int fpsFrames = 0; // Create and run the render loop RenderLoop.Run(form, () => { // Time in seconds var totalSeconds = clock.ElapsedTicks / clockFrequency; #region FPS and title update fpsFrames++; if (fpsTimer.ElapsedMilliseconds > 1000) { fps = 1000.0 * fpsFrames / fpsTimer.ElapsedMilliseconds; // Update window title with FPS once every second form.Text = string.Format("D3DRendering D3D11.1 - FPS: {0:F2} ({1:F2}ms/frame)", fps, (float)fpsTimer.ElapsedMilliseconds / fpsFrames); // Restart the FPS counter fpsTimer.Reset(); fpsTimer.Start(); fpsFrames = 0; } #endregion // Execute rendering commands here... device.ImmediateContext.ClearRenderTargetView( renderTargetView, Color.LightBlue); // Present the frame swapChain.Present(0, PresentFlags.None, new PresentParameters()); // Determine the time it took to render the frame deltaTime = (clock.ElapsedTicks / clockFrequency) - totalSeconds; }); #endregion #region Direct3D Cleanup // Release the device and any other resources created renderTargetView.Dispose(); backBuffer.Dispose(); device.Dispose(); swapChain.Dispose(); #endregion }
protected override SharpDX.DXGI.SwapChain2 CreateSwapChain(SharpDX.DXGI.Factory2 factory, SharpDX.Direct3D11.Device1 device, SharpDX.DXGI.SwapChainDescription1 desc) { // Creates a SwapChain from a CoreWindow pointer using (var comWindow = new ComObject(window)) using (var swapChain1 = new SwapChain1(factory, device, comWindow, ref desc)) return swapChain1.QueryInterface<SwapChain2>(); }
/// <summary> /// Create all view resources. /// </summary> Tuple <D3D11.Texture2D, D3D11.RenderTargetView, D3D11.Texture2D, D3D11.DepthStencilView, SharpDX.Mathematics.Interop.RawViewportF, Size2, DpiScaling> IRenderLoopHost.OnRenderLoop_CreateViewResources(EngineDevice device) { //Get references to current render device m_device = device.DeviceD3D11_1; m_deviceContext = m_device.ImmediateContext; // Create swapchain and dummy form m_swapChain = GraphicsHelper.CreateSwapChainForFullScreen( m_dummyForm, m_targetOutput, m_targetOutputMode, device, m_renderLoop.ViewConfiguration); // Take width and height out of the render target m_renderTarget = D3D11.Texture2D.FromSwapChain <D3D11.Texture2D>(m_swapChain, 0); m_renderTargetView = new D3D11.RenderTargetView(m_device, m_renderTarget); //Create the depth buffer m_renderTargetDepth = GraphicsHelper.CreateDepthBufferTexture(device, m_targetOutputMode.PixelWidth, m_targetOutputMode.PixelHeight, m_renderLoop.ViewConfiguration); m_renderTargetDepthView = new D3D11.DepthStencilView(m_device, m_renderTargetDepth); //Define the viewport for rendering SharpDX.Mathematics.Interop.RawViewportF viewPort = GraphicsHelper.CreateDefaultViewport(m_targetOutputMode.PixelWidth, m_targetOutputMode.PixelHeight); //Return all generated objects return(Tuple.Create(m_renderTarget, m_renderTargetView, m_renderTargetDepth, m_renderTargetDepthView, viewPort, new Size2(m_targetOutputMode.PixelWidth, m_targetOutputMode.PixelHeight), DpiScaling.Default)); }
private void CreateSwapChain(IntPtr window, bool vsync) { using (SharpDX.DXGI.Factory4 factory = new Factory4()) { //SharpDX.DXGI.Adapter adapter = factory.GetAdapterByLuid(_dev.AdapterLuid); //System.Console.WriteLine($" Adapter: {adapter.Description.Description}"); System.Console.WriteLine($" Adapter: {factory.Adapters[0].Description.Description}"); if (!vsync) { using (SharpDX.DXGI.Factory5 factory5 = factory.QueryInterface <Factory5>()) { if (factory5 != null) { SharpDX.Mathematics.Interop.RawBool tearing = false; GCHandle pinnedInt = GCHandle.Alloc(tearing, GCHandleType.Pinned); IntPtr pointer = pinnedInt.AddrOfPinnedObject(); factory5.CheckFeatureSupport(SharpDX.DXGI.Feature.PresentAllowTearing, pointer, System.Runtime.InteropServices.Marshal.SizeOf(tearing)); if (tearing != false) { _swapChainFlags = SharpDX.DXGI.SwapChainFlags.AllowTearing; _presentFlags = SharpDX.DXGI.PresentFlags.AllowTearing; } pinnedInt.Free(); } } _syncInterval = 0; } else { _syncInterval = 1; } SharpDX.DXGI.SwapChainDescription1 desc = new SharpDX.DXGI.SwapChainDescription1(); desc.Width = 0; desc.Height = 0; desc.Format = SharpDX.DXGI.Format.R8G8B8A8_UNorm; desc.Stereo = false; desc.SampleDescription = new SampleDescription { Count = 1, Quality = 0 }; desc.Usage = SharpDX.DXGI.Usage.RenderTargetOutput; desc.BufferCount = FrameCount; desc.Scaling = SharpDX.DXGI.Scaling.Stretch; desc.SwapEffect = SharpDX.DXGI.SwapEffect.FlipDiscard; desc.AlphaMode = SharpDX.DXGI.AlphaMode.Unspecified; desc.Flags = _swapChainFlags; using (SharpDX.DXGI.SwapChain1 swapChain = new SharpDX.DXGI.SwapChain1(factory, _queue, window, ref desc)) { factory.MakeWindowAssociation(window, WindowAssociationFlags.IgnoreAltEnter); _swapChain = swapChain.QueryInterface <SharpDX.DXGI.SwapChain3>(); } } }
/// <summary> /// Disposes all loaded view resources. /// </summary> void IRenderLoopHost.OnRenderLoop_DisposeViewResources(EngineDevice engineDevice) { m_renderTargetDepth = GraphicsHelper.DisposeObject(m_renderTargetDepth); m_depthBuffer = GraphicsHelper.DisposeObject(m_depthBuffer); m_renderTargetView = GraphicsHelper.DisposeObject(m_renderTargetView); m_backBuffer = GraphicsHelper.DisposeObject(m_backBuffer); m_backBufferMultisampled = GraphicsHelper.DisposeObject(m_backBufferMultisampled); m_swapChain = GraphicsHelper.DisposeObject(m_swapChain); }
void Initialize(ComObject coreWindow, AntiAliasingMode antiAliasingMode) { InitializeInner(antiAliasingMode); var swapChainDesc = device.CreateSwapChainDescription(); DXGI.Factory2 factory = device.QueryInterface <DXGI.Device1>().Adapter.GetParent <DXGI.Factory2>(); swapChain = new DXGI.SwapChain1(factory, device, coreWindow, ref swapChainDesc); }
protected override SharpDX.DXGI.SwapChain1 CreateSwapChain(SharpDX.DXGI.Factory2 factory, SharpDX.Direct3D11.Device1 device, SharpDX.DXGI.SwapChainDescription1 desc) { // Creates the swap chain for XAML composition var swapChain = new SwapChain1(factory, device, ref desc); // Associate the SwapChainBackgroundPanel with the swap chain nativeBackgrounPanel.SwapChain = swapChain; return swapChain; }
public void InitializeDevice(ComObject coreWindow) { D3Device = DirectXTools.CreateD3Device(); { RenderTarget = DirectXTools.CreateRenderTarget(Direct2DFactory, D3Device); _solidBrush = new Direct2D1.SolidColorBrush(RenderTarget, Color.Black); SwapChain = DirectXTools.CreateSwapChainForCoreWindow(D3Device, coreWindow); DirectXTools.CreateDeviceSwapChainBitmap(SwapChain, RenderTarget); Bitmaps.SetRenderTarget(RenderTarget); TextLayouts.SetRenderTarget(RenderTarget); } }
public void InitializeDevice(IntPtr windowHandle) { D3Device = DirectXTools.CreateD3Device(); { RenderTarget = DirectXTools.CreateRenderTarget(Direct2DFactory, D3Device); _solidBrush = new Direct2D1.SolidColorBrush(RenderTarget, Color.Black); SwapChain = DirectXTools.CreateSwapChainForHwnd(D3Device, windowHandle); DirectXTools.CreateDeviceSwapChainBitmap(SwapChain, RenderTarget); Bitmaps.SetRenderTarget(RenderTarget); TextLayouts.SetRenderTarget(RenderTarget); } }
/// <summary> /// Disposes all loaded view resources. /// </summary> void IRenderLoopHost.OnRenderLoop_DisposeViewResources(EngineDevice device) { m_factory = null; m_renderDevice = null; m_renderDeviceContext = null; m_renderTargetDepth = GraphicsHelper.DisposeObject(m_renderTargetDepth); m_depthBuffer = GraphicsHelper.DisposeObject(m_depthBuffer); m_renderTarget = GraphicsHelper.DisposeObject(m_renderTarget); m_backBuffer = GraphicsHelper.DisposeObject(m_backBuffer); m_swapChain = GraphicsHelper.DisposeObject(m_swapChain); }
public void InitializeDeviceGdiCompatible(IntPtr windowHandle, int width, int height) { using (var d3device = DirectXTools.CreateD3Device()) { RenderTarget = DirectXTools.CreateRenderTarget(Direct2DFactory, d3device); _solidBrush = new Direct2D1.SolidColorBrush(RenderTarget, Color.Black); SwapChain = DirectXTools.CreateSwapChainForHwnd(d3device, windowHandle); //DirectXTools.CreateDeviceSwapChainBitmap(SwapChain, RenderTarget); DirectXTools.CreateDeviceContextCPUBitmap(RenderTarget, width, height); Bitmaps.SetRenderTarget(RenderTarget); TextLayouts.SetRenderTarget(RenderTarget); } }
public BasicCapture(IDirect3DDevice d, GraphicsCaptureItem i) { item = i; device = d; d3dDevice = Direct3D11Helper.CreateSharpDXDevice(device); var size = item.Size; if (size.Height == 0 || size.Width == 0) { size = new SizeInt32() { Height = 1, Width = 1 } } ; var dxgiFactory = new SharpDX.DXGI.Factory2(); var description = new SharpDX.DXGI.SwapChainDescription1() { Width = size.Width, Height = size.Height, Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm, Stereo = false, SampleDescription = new SharpDX.DXGI.SampleDescription() { Count = 1, Quality = 0 }, Usage = SharpDX.DXGI.Usage.RenderTargetOutput, BufferCount = 2, Scaling = SharpDX.DXGI.Scaling.Stretch, SwapEffect = SharpDX.DXGI.SwapEffect.FlipSequential, AlphaMode = SharpDX.DXGI.AlphaMode.Premultiplied, Flags = SharpDX.DXGI.SwapChainFlags.None }; swapChain = new SharpDX.DXGI.SwapChain1(dxgiFactory, d3dDevice, ref description); framePool = Direct3D11CaptureFramePool.Create( device, DirectXPixelFormat.B8G8R8A8UIntNormalized, 2, size); session = framePool.CreateCaptureSession(i); lastSize = size; framePool.FrameArrived += OnFrameArrived; }
private void InitializeDirectXResources() { var clientSize = ClientSize; var backBufferDesc = new DXGI.ModeDescription(clientSize.Width, clientSize.Height, new DXGI.Rational(60, 1), DXGI.Format.R8G8B8A8_UNorm); var swapChainDesc = new DXGI.SwapChainDescription() { ModeDescription = backBufferDesc, SampleDescription = new DXGI.SampleDescription(1, 0), Usage = DXGI.Usage.RenderTargetOutput, BufferCount = 1, OutputHandle = Handle, SwapEffect = DXGI.SwapEffect.Discard, IsWindowed = false }; D3D11.Device.CreateWithSwapChain(D3D.DriverType.Hardware, D3D11.DeviceCreationFlags.BgraSupport, new[] { D3D.FeatureLevel.Level_10_0 }, swapChainDesc, out _d3DDevice, out var swapChain); _d3DDeviceContext = _d3DDevice.ImmediateContext; _swapChain = new DXGI.SwapChain1(swapChain.NativePointer); _d2DFactory = new D2D1.Factory(); using (var backBuffer = _swapChain.GetBackBuffer <D3D11.Texture2D>(0)) { _renderTargetView = new D3D11.RenderTargetView(_d3DDevice, backBuffer); _renderTarget = new D2D1.RenderTarget(_d2DFactory, backBuffer.QueryInterface <DXGI.Surface>(), new D2D1.RenderTargetProperties(new D2D1.PixelFormat(DXGI.Format.Unknown, D2D1.AlphaMode.Premultiplied))) { TextAntialiasMode = D2D1.TextAntialiasMode.Cleartype }; } _solidColorBrush = new D2D1.SolidColorBrush(_renderTarget, Color.White); _dwFactory = new DW.Factory(DW.FactoryType.Shared); _textFormat = new DW.TextFormat(_dwFactory, "Arial", DW.FontWeight.Bold, DW.FontStyle.Normal, DW.FontStretch.Normal, 84 * (float)GraphicsUtils.Scale) { TextAlignment = DW.TextAlignment.Center, ParagraphAlignment = DW.ParagraphAlignment.Center }; _bitmap = _paradigm.Config.Gui.UseBitmap ? Properties.Resources.Einstein.ToD2D1Bitmap(_renderTarget) : null; }
public RenderController(IntPtr windowHandle) { writeFactory = new SharpDX.DirectWrite.Factory(); SharpDX.Direct3D11.Device defaultDevice = new SharpDX.Direct3D11.Device ( DriverType.Hardware, DeviceCreationFlags.Debug | DeviceCreationFlags.BgraSupport ); device = defaultDevice.QueryInterface <SharpDX.Direct3D11.Device1>(); SharpDX.DXGI.Device2 dxgiDevice2 = device.QueryInterface <SharpDX.DXGI.Device2>(); SharpDX.DXGI.Adapter dxgiAdapter = dxgiDevice2.Adapter; SharpDX.DXGI.Factory2 dxgiFactory2 = dxgiAdapter.GetParent <SharpDX.DXGI.Factory2>(); SwapChainDescription1 description = new SwapChainDescription1() { Width = 0, Height = 0, Format = Format.B8G8R8A8_UNorm, Stereo = false, SampleDescription = new SampleDescription(1, 0), Usage = Usage.RenderTargetOutput, BufferCount = 2, Scaling = Scaling.None, SwapEffect = SwapEffect.FlipSequential, }; swapChain = new SwapChain1(dxgiFactory2, device, windowHandle, ref description); backBuffer = Surface.FromSwapChain(swapChain, 0); d2dDevice = new SharpDX.Direct2D1.Device(dxgiDevice2); d2dContext = new SharpDX.Direct2D1.DeviceContext(d2dDevice, SharpDX.Direct2D1.DeviceContextOptions.None); properties = new BitmapProperties1 ( new SharpDX.Direct2D1.PixelFormat ( SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied ), 0, 0, BitmapOptions.Target | BitmapOptions.CannotDraw ); d2dTarget = new Bitmap1(d2dContext, backBuffer, properties); d2dContext.Target = d2dTarget; canDraw = true; }
public void InitializeDevice(int width, int height, object swapChainPanel) { var nativePanel = ComObject.As <DXGI.ISwapChainPanelNative>(swapChainPanel); Debug.Assert(nativePanel != null, $"{nameof(swapChainPanel)} should not be null."); D3Device = DirectXTools.CreateD3Device(); { RenderTarget = DirectXTools.CreateRenderTarget(Direct2DFactory, D3Device); _solidBrush = new Direct2D1.SolidColorBrush(RenderTarget, Color.Black); SwapChain = DirectXTools.CreateSwapChain(width, height, D3Device); nativePanel.SwapChain = SwapChain; DirectXTools.CreateDeviceSwapChainBitmap(SwapChain, RenderTarget); Bitmaps.SetRenderTarget(RenderTarget); TextLayouts.SetRenderTarget(RenderTarget); } }
public static void CreateDeviceSwapChainBitmap( DXGI.SwapChain1 swapChain, Direct2D1.DeviceContext target) { using (var surface = swapChain.GetBackBuffer <DXGI.Surface>(0)) { var props = new Direct2D1.BitmapProperties1 { BitmapOptions = Direct2D1.BitmapOptions.Target | Direct2D1.BitmapOptions.CannotDraw, PixelFormat = new Direct2D1.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, Direct2D1.AlphaMode.Ignore) }; using (var bitmap = new Direct2D1.Bitmap1(target, surface, props)) { target.Target = bitmap; } } }
/// <summary> /// Create all view resources. /// </summary> Tuple <D3D11.Texture2D, D3D11.RenderTargetView, D3D11.Texture2D, D3D11.DepthStencilView, SharpDX.Mathematics.Interop.RawViewportF, Size2, DpiScaling> IRenderLoopHost.OnRenderLoop_CreateViewResources(EngineDevice device) { int width = this.Width; int height = this.Height; if (width <= Constants.MIN_VIEW_WIDTH) { width = Constants.MIN_VIEW_WIDTH; } if (height <= Constants.MIN_VIEW_HEIGHT) { height = Constants.MIN_VIEW_HEIGHT; } //Get all factories m_factory = device.FactoryDxgi; //Get all devices m_renderDevice = device.DeviceD3D11_1; m_renderDeviceContext = m_renderDevice.ImmediateContext; //Create the swap chain and the render target m_swapChain = GraphicsHelper.CreateSwapChainForWinForms(this, device, m_renderLoop.ViewConfiguration); m_backBuffer = D3D11.Texture2D.FromSwapChain <D3D11.Texture2D>(m_swapChain, 0); m_renderTarget = new D3D11.RenderTargetView(m_renderDevice, m_backBuffer); //Create the depth buffer m_depthBuffer = GraphicsHelper.CreateDepthBufferTexture(device, width, height, m_renderLoop.ViewConfiguration); m_renderTargetDepth = new D3D11.DepthStencilView(m_renderDevice, m_depthBuffer); //Define the viewport for rendering SharpDX.Mathematics.Interop.RawViewportF viewPort = GraphicsHelper.CreateDefaultViewport(width, height); // Query for current dpi value DpiScaling dpiScaling = DpiScaling.Default; using (Graphics graphics = this.CreateGraphics()) { dpiScaling.DpiX = graphics.DpiX; dpiScaling.DpiY = graphics.DpiY; } //Return all generated objects return(Tuple.Create(m_backBuffer, m_renderTarget, m_depthBuffer, m_renderTargetDepth, viewPort, new Size2(width, height), dpiScaling)); }
/// <summary> /// Disposes all loaded view resources. /// </summary> void IRenderLoopHost.OnRenderLoop_DisposeViewResources(EngineDevice device) { // Switch to fullscreen if (m_isInFullscreen) { m_isInFullscreen = false; m_swapChain.SetFullscreenState(false, null); } m_renderTargetDepthView = GraphicsHelper.DisposeObject(m_renderTargetDepthView); m_renderTargetDepth = GraphicsHelper.DisposeObject(m_renderTargetDepth); m_renderTargetView = GraphicsHelper.DisposeObject(m_renderTargetView); m_renderTarget = GraphicsHelper.DisposeObject(m_renderTarget); m_swapChain = GraphicsHelper.DisposeObject(m_swapChain); m_device = null; m_deviceContext = null; }
/// <summary> /// Create all view resources. /// </summary> Tuple <D3D11.Texture2D, D3D11.RenderTargetView, D3D11.Texture2D, D3D11.DepthStencilView, SharpDX.ViewportF, Size2, DpiScaling> IRenderLoopHost.OnRenderLoop_CreateViewResources(EngineDevice engineDevice) { m_backBufferMultisampled = null; Size2 viewSize = GetTargetRenderPixelSize(); // Create the SwapChain and associate it with the SwapChainBackgroundPanel m_swapChain = GraphicsHelper.CreateSwapChainForComposition(engineDevice, viewSize.Width, viewSize.Height, m_renderLoop.ViewConfiguration); m_targetPanel.SwapChain = m_swapChain; m_compositionScaleChanged = true; // Get the backbuffer from the SwapChain m_backBuffer = D3D11.Texture2D.FromSwapChain <D3D11.Texture2D>(m_swapChain, 0); // Define the render target (in case of multisample an own render target) D3D11.Texture2D backBufferForRenderloop = null; if (m_renderLoop.ViewConfiguration.AntialiasingEnabled) { m_backBufferMultisampled = GraphicsHelper.CreateRenderTargetTexture(engineDevice, viewSize.Width, viewSize.Height, m_renderLoop.ViewConfiguration); m_renderTargetView = new D3D11.RenderTargetView(engineDevice.DeviceD3D11, m_backBufferMultisampled); backBufferForRenderloop = m_backBufferMultisampled; } else { m_renderTargetView = new D3D11.RenderTargetView(engineDevice.DeviceD3D11, m_backBuffer); backBufferForRenderloop = m_backBuffer; } //Create the depth buffer m_depthBuffer = GraphicsHelper.CreateDepthBufferTexture(engineDevice, viewSize.Width, viewSize.Height, m_renderLoop.ViewConfiguration); m_renderTargetDepth = new D3D11.DepthStencilView(engineDevice.DeviceD3D11, m_depthBuffer); //Define the viewport for rendering SharpDX.ViewportF viewPort = GraphicsHelper.CreateDefaultViewport(viewSize.Width, viewSize.Height); m_lastRefreshTargetSize = new Size(viewSize.Width, viewSize.Height); DpiScaling dpiScaling = new DpiScaling(); dpiScaling.DpiX = (float)(96.0 * m_targetPanel.CompositionScaleX); dpiScaling.DpiY = (float)(96.0 * m_targetPanel.CompositionScaleY); return(Tuple.Create(backBufferForRenderloop, m_renderTargetView, m_depthBuffer, m_renderTargetDepth, viewPort, viewSize, dpiScaling)); }
private void InitializeDirectX(GameWindow gameWindow) { using (var defaultDevice = new SharpDX.Direct3D11.Device(DriverType.Hardware, DeviceCreationFlags.BgraSupport)) { _d3dDevice = defaultDevice.QueryInterface <SharpDX.Direct3D11.Device1>(); } var swapChainDesc = new SwapChainDescription1() { Width = 0, Height = 0, Format = Format.B8G8R8A8_UNorm, BufferCount = 2, Usage = Usage.BackBuffer | Usage.RenderTargetOutput, SwapEffect = SwapEffect.FlipSequential, SampleDescription = new SampleDescription(1, 0), Scaling = Scaling.AspectRatioStretch }; using (var dxgiDevice = _d3dDevice.QueryInterface <SharpDX.DXGI.Device2>()) using (var dxgiFactory = dxgiDevice.Adapter.GetParent <SharpDX.DXGI.Factory2>()) { var window = new ComObject(gameWindow.WindowObject); _swapChain = new SwapChain1(dxgiFactory, _d3dDevice, window, ref swapChainDesc); _d2dFactory = new SharpDX.Direct2D1.Factory1(); _d2dDevice = new SharpDX.Direct2D1.Device(_d2dFactory, dxgiDevice); } _deviceContext = new SharpDX.Direct2D1.DeviceContext(_d2dDevice, new DeviceContextOptions()); using (var surface = Surface.FromSwapChain(_swapChain, 0)) { var pixelFormat = new SharpDX.Direct2D1.PixelFormat(Format.Unknown, SharpDX.Direct2D1.AlphaMode.Premultiplied); var bitmapProperties = new BitmapProperties1(pixelFormat, 0, 0, BitmapOptions.Target | BitmapOptions.CannotDraw); _d2dTargetBitmap = new SharpDX.Direct2D1.Bitmap1(_deviceContext, surface, bitmapProperties); _deviceContext.Target = _d2dTargetBitmap; } _dwriteFactory = new SharpDX.DirectWrite.Factory1(); _wicFactory = new ImagingFactory(); _formatConverter = new FormatConverter(_wicFactory); _deviceContext.TextAntialiasMode = SharpDX.Direct2D1.TextAntialiasMode.Cleartype; }
private void InitializeD3D() { using (D3D11.Device defaultDevice = new D3D11.Device(D3D.DriverType.Hardware, D3D11.DeviceCreationFlags.Debug)) this.device = defaultDevice.QueryInterface <D3D11.Device2>(); this.deviceContext = this.device.ImmediateContext2; DXGI.SwapChainDescription1 swapChainDescription = new DXGI.SwapChainDescription1() { AlphaMode = DXGI.AlphaMode.Ignore, BufferCount = 2, Format = DXGI.Format.R8G8B8A8_UNorm, Height = (int)(this.swapChainPanel.RenderSize.Height), Width = (int)(this.swapChainPanel.RenderSize.Width), SampleDescription = new DXGI.SampleDescription(1, 0), Scaling = SharpDX.DXGI.Scaling.Stretch, Stereo = false, SwapEffect = DXGI.SwapEffect.FlipSequential, Usage = DXGI.Usage.RenderTargetOutput }; using (DXGI.Device3 dxgiDevice3 = this.device.QueryInterface <DXGI.Device3>()) using (DXGI.Factory3 dxgiFactory3 = dxgiDevice3.Adapter.GetParent <DXGI.Factory3>()) { DXGI.SwapChain1 swapChain1 = new DXGI.SwapChain1(dxgiFactory3, this.device, ref swapChainDescription); this.swapChain = swapChain1.QueryInterface <DXGI.SwapChain2>(); } using (DXGI.ISwapChainPanelNative nativeObject = ComObject.As <DXGI.ISwapChainPanelNative>(this.swapChainPanel)) nativeObject.SwapChain = this.swapChain; this.backBufferTexture = this.swapChain.GetBackBuffer <D3D11.Texture2D>(0); this.backBufferView = new D3D11.RenderTargetView(this.device, this.backBufferTexture); deviceContext.Rasterizer.SetViewport(0, 0, (int)swapChainPanel.ActualWidth, (int)swapChainPanel.ActualHeight); CompositionTarget.Rendering += CompositionTarget_Rendering; Application.Current.Suspending += Current_Suspending; isDXInitialized = true; }
public Tuple <D3D11.Texture2D, D3D11.RenderTargetView, D3D11.Texture2D, D3D11.DepthStencilView, SDM.RawViewportF, Size2, DpiScaling> OnRenderLoop_CreateViewResources(EngineDevice device) { // Get the pixel size of the screen Size2 viewSize = GetTargetRenderPixelSize(); // Create the SwapChain and associate it with the SwapChainBackgroundPanel using (SharpDX.ComObject targetWindowCom = new SharpDX.ComObject(m_targetWindow)) { m_swapChain = GraphicsHelper.CreateSwapChainForCoreWindow(device, targetWindowCom, viewSize.Width, viewSize.Height, m_renderLoop.ViewConfiguration); } // Get the backbuffer from the SwapChain m_backBuffer = D3D11.Texture2D.FromSwapChain <D3D11.Texture2D>(m_swapChain, 0); // Define the render target (in case of multisample an own render target) D3D11.Texture2D backBufferForRenderloop = null; if (m_renderLoop.ViewConfiguration.AntialiasingEnabled) { m_backBufferMultisampled = GraphicsHelper.CreateRenderTargetTexture(device, viewSize.Width, viewSize.Height, m_renderLoop.ViewConfiguration); m_renderTargetView = new D3D11.RenderTargetView(device.DeviceD3D11_1, m_backBufferMultisampled); backBufferForRenderloop = m_backBufferMultisampled; } else { m_renderTargetView = new D3D11.RenderTargetView(device.DeviceD3D11_1, m_backBuffer); backBufferForRenderloop = m_backBuffer; } //Create the depth buffer m_depthBuffer = GraphicsHelper.CreateDepthBufferTexture(device, viewSize.Width, viewSize.Height, m_renderLoop.ViewConfiguration); m_renderTargetDepth = new D3D11.DepthStencilView(device.DeviceD3D11_1, m_depthBuffer); //Define the viewport for rendering SharpDX.Mathematics.Interop.RawViewportF viewPort = GraphicsHelper.CreateDefaultViewport(viewSize.Width, viewSize.Height); m_lastRefreshTargetSize = new Size(viewSize.Width, viewSize.Height); return(Tuple.Create(backBufferForRenderloop, m_renderTargetView, m_depthBuffer, m_renderTargetDepth, viewPort, viewSize, m_dpiScaling)); }
/// <summary> /// Initializes a new instance of the <see cref="FormRenderer"/> class. /// </summary> /// <param name="form">The form.</param> public FormRenderer(Form1 form) { this.form = form; #if DEBUG var creationFlags = D3D11.DeviceCreationFlags.BgraSupport | D3D11.DeviceCreationFlags.Debug; var debugFactory = true; #else var creationFlags = D3D11.DeviceCreationFlags.BgraSupport; var debugFactory = false; #endif this.device = new D3D11.Device(D3D.DriverType.Hardware, creationFlags); #if DEBUG this.deviceDebug = new D3D11.DeviceDebug(this.device); #endif using (var dxgiDevice = this.device.QueryInterface <DXGI.Device>()) { using (var dxgiFactory = new DXGI.Factory2(debugFactory)) { var desc = new DXGI.SwapChainDescription1() { BufferCount = 2, AlphaMode = DXGI.AlphaMode.Premultiplied, SampleDescription = new DXGI.SampleDescription(1, 0), Usage = DXGI.Usage.RenderTargetOutput, SwapEffect = DXGI.SwapEffect.FlipDiscard, Format = DXGI.Format.B8G8R8A8_UNorm, Width = form.Width, Height = form.Height, }; this.swapChain = new DXGI.SwapChain1(dxgiFactory, dxgiDevice, ref desc, null); this.deviceComp = new DComp.Device(dxgiDevice); this.compositionTarget = DComp.Target.FromHwnd(this.deviceComp, form.Handle, true); using (var visual = new DComp.Visual(this.deviceComp)) { visual.Content = this.swapChain; this.compositionTarget.Root = visual; } this.deviceComp.Commit(); } } using (var device = this.device.QueryInterface <DXGI.Device>()) { this.device2d = new D2D.Device(this.factory2d, device); } this.deviceContext2D = new D2D.DeviceContext(this.device2d, D2D.DeviceContextOptions.None) { DotsPerInch = this.factory2d.DesktopDpi, AntialiasMode = D2D.AntialiasMode.PerPrimitive, }; this.CreateResources(); }
/// <summary> /// Create size dependent resources, in this case the swap chain and render targets /// </summary> /// <param name="app"></param> protected virtual void CreateSizeDependentResources(D3DApplicationBase app) { // Retrieve references to device and context var device = DeviceManager.Direct3DDevice; var context = DeviceManager.Direct3DContext; // Retrieve Direct2D context (for use with text rendering etc) var d2dContext = DeviceManager.Direct2DContext; // Before the swapchain can resize all the buffers must be released RemoveAndDispose(ref _backBuffer); RemoveAndDispose(ref _renderTargetView); RemoveAndDispose(ref _depthStencilView); RemoveAndDispose(ref _depthBuffer); RemoveAndDispose(ref _bitmapTarget); d2dContext.Target = null; #region Initialize Direct3D swap chain and render target // If the swap chain already exists, resize it. if (_swapChain != null) { _swapChain.ResizeBuffers( _swapChain.Description1.BufferCount, Width, Height, _swapChain.Description.ModeDescription.Format, _swapChain.Description.Flags); } // Otherwise, create a new one. else { // SwapChain description var desc = CreateSwapChainDescription(); // Rather than create a new DXGI Factory we should reuse // the one that has been used internally to create the device // First, retrieve the underlying DXGI Device from the D3D Device. // access the adapter used for that device and then create the swap chain using (var dxgiDevice2 = device.QueryInterface<SharpDX.DXGI.Device2>()) using (var dxgiAdapter = dxgiDevice2.Adapter) using (var dxgiFactory2 = dxgiAdapter.GetParent<SharpDX.DXGI.Factory2>()) using (var output = dxgiAdapter.Outputs.First()) { // The CreateSwapChain method is used so we can descend // from this class and implement a swapchain for a desktop // or a Windows 8 AppStore app _swapChain = ToDispose(CreateSwapChain(dxgiFactory2, device, desc)); #if !NETFX_CORE // Retrieve the list of supported display modes DisplayModeList = output.GetDisplayModeList(desc.Format, DisplayModeEnumerationFlags.Scaling); #endif } } // Obtain the backbuffer for this window which will be the final 3D rendertarget. BackBuffer = ToDispose(Texture2D.FromSwapChain<Texture2D>(_swapChain, 0)); // Create a view interface on the rendertarget to use on bind. RenderTargetView = ToDispose(new RenderTargetView(device, BackBuffer)); // Cache the rendertarget dimensions in our helper class for convenient use. var backBufferDesc = BackBuffer.Description; RenderTargetBounds = new SharpDX.Rectangle(0, 0, backBufferDesc.Width, backBufferDesc.Height); // Create a viewport descriptor of the render size. this.Viewport = new SharpDX.ViewportF( (float)RenderTargetBounds.X, (float)RenderTargetBounds.Y, (float)RenderTargetBounds.Width, (float)RenderTargetBounds.Height, 0.0f, // min depth 1.0f); // max depth // Set the current viewport for the rasterizer. context.Rasterizer.SetViewport(Viewport); // Create a descriptor for the depth/stencil buffer. // Allocate a 2-D texture as the depth/stencil buffer. // Create a DSV to use on bind. this.DepthBuffer = ToDispose(new Texture2D(device, new Texture2DDescription() { Format = SharpDX.DXGI.Format.D32_Float_S8X24_UInt, ArraySize = 1, MipLevels = 1, Width = RenderTargetSize.Width, Height = RenderTargetSize.Height, SampleDescription = SwapChain.Description.SampleDescription, BindFlags = BindFlags.DepthStencil, })); this.DepthStencilView = ToDispose( new DepthStencilView( device, DepthBuffer, new DepthStencilViewDescription() { Dimension = (SwapChain.Description.SampleDescription.Count > 1 || SwapChain.Description.SampleDescription.Quality > 0) ? DepthStencilViewDimension.Texture2DMultisampled : DepthStencilViewDimension.Texture2D })); // Set the OutputMerger targets context.OutputMerger.SetTargets(DepthStencilView, RenderTargetView); #endregion #region Initialize Direct2D render target // Now we set up the Direct2D render target bitmap linked to the swapchain. // Whenever we render to this bitmap, it will be directly rendered to the // swapchain associated with the window. var bitmapProperties = new SharpDX.Direct2D1.BitmapProperties1( new SharpDX.Direct2D1.PixelFormat(_swapChain.Description.ModeDescription.Format, SharpDX.Direct2D1.AlphaMode.Premultiplied), DeviceManager.Dpi, DeviceManager.Dpi, SharpDX.Direct2D1.BitmapOptions.Target | SharpDX.Direct2D1.BitmapOptions.CannotDraw); // Direct2D needs the dxgi version of the backbuffer surface pointer. // Get a D2D surface from the DXGI back buffer to use as the D2D render target. using (var dxgiBackBuffer = _swapChain.GetBackBuffer<SharpDX.DXGI.Surface>(0)) BitmapTarget2D = ToDispose(new SharpDX.Direct2D1.Bitmap1(d2dContext, dxgiBackBuffer, bitmapProperties)); // So now we can set the Direct2D render target. d2dContext.Target = BitmapTarget2D; // Set D2D text anti-alias mode to Grayscale to ensure proper rendering of text on intermediate surfaces. d2dContext.TextAntialiasMode = SharpDX.Direct2D1.TextAntialiasMode.Grayscale; #endregion }
private void SwapChainPanel_OnLoaded(object sender, RoutedEventArgs e) { using (var defDevice = new D3D.Device(DriverType.Hardware, D3D.DeviceCreationFlags.Debug)) { _device = defDevice.QueryInterface <D3D.Device3>(); } _context = _device.ImmediateContext3; var pixelScale = DisplayInformation.GetForCurrentView().LogicalDpi / 96.0f; var swapChainDesc = new DXGI.SwapChainDescription1() { AlphaMode = DXGI.AlphaMode.Premultiplied, BufferCount = 2, Flags = DXGI.SwapChainFlags.None, Format = DXGI.Format.B8G8R8A8_UNorm, Width = (int)(panel.RenderSize.Width * pixelScale), Height = (int)(panel.RenderSize.Height * pixelScale), SampleDescription = new DXGI.SampleDescription(1, 0), Scaling = DXGI.Scaling.Stretch, Stereo = false, SwapEffect = DXGI.SwapEffect.FlipSequential, Usage = DXGI.Usage.BackBuffer | DXGI.Usage.RenderTargetOutput }; using (var dxgiDevice = _device.QueryInterface <DXGI.Device3>()) { var factory = dxgiDevice.Adapter.GetParent <DXGI.Factory4>(); using (var tmpSwapChain = new DXGI.SwapChain1(factory, _device, ref swapChainDesc)) { _swapChain = tmpSwapChain.QueryInterface <DXGI.SwapChain3>(); } } using (var nativeObject = ComObject.As <DXGI.ISwapChainPanelNative>(panel)) { nativeObject.SwapChain = _swapChain; } using (var depthBuffer = new D3D.Texture2D(_device, new D3D.Texture2DDescription() { Format = DXGI.Format.D24_UNorm_S8_UInt, ArraySize = 1, MipLevels = 1, Width = swapChainDesc.Width, Height = swapChainDesc.Height, SampleDescription = new DXGI.SampleDescription(1, 0), BindFlags = D3D.BindFlags.DepthStencil, })) { _depthStencilView = new D3D.DepthStencilView(_device, depthBuffer, new D3D.DepthStencilViewDescription() { Dimension = D3D.DepthStencilViewDimension.Texture2D }); } _backBuffer = D3D.Resource.FromSwapChain <D3D.Texture2D>(_swapChain, 0); _renderView = new D3D.RenderTargetView1(_device, _backBuffer); var viewport = new ViewportF(0, 0, (float)panel.RenderSize.Width, (float)panel.RenderSize.Height, 0.0f, 1.0f); _context.Rasterizer.SetViewport(viewport); ShaderBytecode shaderBytecode; using (shaderBytecode = ShaderBytecode.CompileFromFile("shaders.hlsl", "vs", "vs_5_0", ShaderFlags.Debug)) { _vertexShader = new D3D.VertexShader(_device, shaderBytecode); } using (var byteCode = ShaderBytecode.CompileFromFile(@"shaders.hlsl", "ps", "ps_5_0", ShaderFlags.Debug)) { _pixelShader = new D3D.PixelShader(_device, byteCode); } D3D.InputElement[] inputElements = { new D3D.InputElement("POSITION", 0, DXGI.Format.R32G32B32A32_Float, 0, 0), }; _inputLayout = new D3D.InputLayout(_device, shaderBytecode, inputElements); _vertices = new[] { new Vector4(-0.5f, 0.0f, 0.5f, 1.0f), new Vector4(0.0f, 0.5f, 0.5f, 1.0f), new Vector4(0.5f, 0.0f, 0.5f, 1.0f), }; _vertexBuffer = D3D.Buffer.Create(_device, D3D.BindFlags.VertexBuffer, _vertices); _vertexBinding = new D3D.VertexBufferBinding(_vertexBuffer, Utilities.SizeOf <Vector4>(), 0); _constantBuffer = new SharpDX.Direct3D11.Buffer( _device, Utilities.SizeOf <SharpDX.Matrix>(), D3D.ResourceUsage.Default, D3D.BindFlags.ConstantBuffer, D3D.CpuAccessFlags.None, D3D.ResourceOptionFlags.None, 0); _timer = new Stopwatch(); _timer.Start(); CompositionTarget.Rendering += CompositionTarget_Rendering; }
private void InitSwapChain(int width, int height) { if (width <= 0 || height <= 0) throw new ArgumentException("panel must have a valid width or height"); // Create swap chain for composition and bind to panel var desc = new SwapChainDescription1 { Width = width, Height = height, Format = Format.B8G8R8A8_UNorm, Flags = SwapChainFlags.None, BufferCount = 2, AlphaMode = AlphaMode.Unspecified, Stereo = false, Scaling = Scaling.Stretch, SampleDescription = { Count = 1, Quality = 0 }, SwapEffect = SwapEffect.FlipSequential, Usage = Usage.RenderTargetOutput }; _width = width; _height = height; var dxgiDev = ComObject.As<SharpDX.DXGI.Device1>(_device.NativePointer); var adapter = dxgiDev.Adapter; var fact = adapter.GetParent<SharpDX.DXGI.Factory2>(); _swap = fact.CreateSwapChainForComposition(_device, ref desc, null); dxgiDev.MaximumFrameLatency = 1; }
protected override SharpDX.DXGI.SwapChain2 CreateSwapChain(SharpDX.DXGI.Factory2 factory, SharpDX.Direct3D11.Device1 device, SharpDX.DXGI.SwapChainDescription1 desc) { // Creates the swap chain for XAML composition using (var swapChain1 = new SwapChain1(factory, device, ref desc)) { var swapChain2 = swapChain1.QueryInterface<SwapChain2>(); // Associate the SwapChainPanel with the swap chain nativePanel.SwapChain = swapChain2; // Returns the new swap chain return swapChain2; } }
public VideoRenderer(VideoTrack videoTrack, RendererOptions options) { VideoTrack = videoTrack; VideoFrameWidth = options.VideoFrameWidth; VideoFrameHeight = options.VideoFrameHeight; VideoFrameQueueSize = options.VideoFrameQueueSize; videoTrack.LocalVideoFrameProcessed += OnLocalVideoFrameProcessed; // _onMissedFrame = options.OnMissedFrame ?? OnMissedFrame; bool debug = options.CreationFlags.HasFlag(D3D11.DeviceCreationFlags.Debug); FactoryDXGI = new DXGI.Factory2(debug); // Find the requested adapter. using (var adapters = FactoryDXGI.Adapters.ToDisposableList()) { var adapter = adapters.First(a => a.Description.VendorId == options.AdapterVendorId); Device3D = new D3D11.Device(adapter, options.CreationFlags, options.FeatureLevels); DeviceDXGI = Device3D.QueryInterface <DXGI.Device>(); // We need to access D3D11 on multiple threads, so enable multi-threading ThreadLock3D = Device3D.ImmediateContext.QueryInterface <D3D11.Multithread>(); ThreadLock3D.SetMultithreadProtected(true); if (options.PreviewWindowOptions != null) { var width = options.PreviewWindowOptions.Width ?? VideoFrameWidth; var height = options.PreviewWindowOptions.Height ?? width * VideoFrameHeight / VideoFrameWidth; _sdlWindow = new SdlWindow("WebRTC server preview", width, height); // SwapChain description var desc = new DXGI.SwapChainDescription1() { BufferCount = 2, AlphaMode = DXGI.AlphaMode.Unspecified, Format = DXGI.Format.B8G8R8A8_UNorm, Width = VideoFrameWidth, Height = VideoFrameHeight, Scaling = DXGI.Scaling.Stretch, Stereo = false, Flags = DXGI.SwapChainFlags.AllowTearing | DXGI.SwapChainFlags.FrameLatencyWaitAbleObject, Usage = DXGI.Usage.RenderTargetOutput, SampleDescription = new DXGI.SampleDescription(1, 0), SwapEffect = DXGI.SwapEffect.FlipDiscard, }; SwapChain = new DXGI.SwapChain1(FactoryDXGI, Device3D, _sdlWindow.NativeHandle, ref desc); using (var swapChain2 = SwapChain.QueryInterface <DXGI.SwapChain2>()) { var value = swapChain2.MaximumFrameLatency; swapChain2.MaximumFrameLatency = 1; } } } }
/// <summary> /// Now that we have a CoreWindow object, the DirectX device/context can be created. /// </summary> /// <param name="entryPoint"></param> public void Load(string entryPoint) { // Get the default hardware device and enable debugging. Don't care about the available feature level. SharpDX.Direct3D11.Device defaultDevice = new SharpDX.Direct3D11.Device(DriverType.Hardware, DeviceCreationFlags.Debug); // Query the default device for the supported device and context interfaces. device = defaultDevice.QueryInterface<SharpDX.Direct3D11.Device1>(); context = device.ImmediateContext.QueryInterface<DeviceContext1>(); // Query for the adapter and more advanced DXGI objects. SharpDX.DXGI.Device2 dxgiDevice2 = device.QueryInterface<SharpDX.DXGI.Device2>(); SharpDX.DXGI.Adapter dxgiAdapter = dxgiDevice2.Adapter; SharpDX.DXGI.Factory2 dxgiFactory2 = dxgiAdapter.GetParent<SharpDX.DXGI.Factory2>(); // Description for our swap chain settings. SwapChainDescription1 description = new SwapChainDescription1() { // 0 means to use automatic buffer sizing. Width = 0, Height = 0, // 32 bit RGBA color. Format = Format.B8G8R8A8_UNorm, // No stereo (3D) display. Stereo = false, // No multisampling. SampleDescription = new SampleDescription(1, 0), // Use the swap chain as a render target. Usage = Usage.RenderTargetOutput, // Enable double buffering to prevent flickering. BufferCount = 2, // No scaling. Scaling = Scaling.None, // Flip between both buffers. SwapEffect = SwapEffect.FlipSequential, }; // Generate a swap chain for our window based on the specified description. swapChain = dxgiFactory2.CreateSwapChainForCoreWindow(device, new ComObject(window), ref description, null); // Create the texture and render target that will hold our backbuffer. Texture2D backBufferTexture = Texture2D.FromSwapChain<Texture2D>(swapChain, 0); backBuffer = new RenderTargetView(device, backBufferTexture); backBufferTexture.Dispose(); }
/// <summary> /// Creates resources that depend on the current back buffer size. /// </summary> private void CreateSizeDependentResources() { this.ReleaseSizeDependentResources(); if (swapChain != null) { swapChain.ResizeBuffers(2, (int)this.BackBufferSize.Width, (int)this.BackBufferSize.Height, Format.B8G8R8A8_UNorm, SwapChainFlags.None); } else { SwapChainDescription1 swapChainDescription = new SwapChainDescription1() { Width = (int)this.BackBufferSize.Width, Height = (int)this.BackBufferSize.Height, Format = Format.B8G8R8A8_UNorm, Stereo = false, SampleDescription = new SampleDescription(1, 0), Usage = Usage.BackBuffer | Usage.RenderTargetOutput, BufferCount = 2, Scaling = Scaling.Stretch, SwapEffect = SwapEffect.FlipSequential, }; using (SharpDX.DXGI.Device2 dxgiDevice2 = this.D3DDevice.QueryInterface<SharpDX.DXGI.Device2>()) { using (SharpDX.DXGI.Adapter dxgiAdapter = dxgiDevice2.Adapter) { using (SharpDX.DXGI.Factory2 dxgiFactory2 = dxgiAdapter.GetParent<SharpDX.DXGI.Factory2>()) { swapChain = new SwapChain1(dxgiFactory2, this.D3DDevice, ref swapChainDescription); if (this.backgroundPanel != null) { nativeBackgroundPanel.SwapChain = swapChain; } else if (this.panel != null) { nativePanel.SwapChain = swapChain; } dxgiDevice2.MaximumFrameLatency = 1; } } } } this.BackBuffer = Texture2D.FromSwapChain<Texture2D>(swapChain, 0); this.BackBufferView = new RenderTargetView(this.D3DDevice, this.BackBuffer); this.UpdateBackBufferSize(); using (Texture2D depthBuffer = new Texture2D(this.D3DDevice, new Texture2DDescription() { Format = SharpDX.DXGI.Format.D24_UNorm_S8_UInt, ArraySize = 1, MipLevels = 1, Width = (int)this.BackBufferSize.Width, Height = (int)this.BackBufferSize.Height, SampleDescription = new SampleDescription(1, 0), BindFlags = BindFlags.DepthStencil, })) { this.DepthStencilView = new DepthStencilView(this.D3DDevice, depthBuffer, new DepthStencilViewDescription() { Dimension = DepthStencilViewDimension.Texture2D }); } ViewportF viewport = new ViewportF(0, 0, (float)this.BackBufferSize.Width, (float)this.BackBufferSize.Height, 0.0f, 1.0f); this.D3DContext.Rasterizer.SetViewport(viewport); }
private void SwapChainPanel_Loaded(object sender, RoutedEventArgs e) { // Create a new Direct3D hardware device and ask for Direct3D 11.2 support using (D3D11.Device defaultDevice = new D3D11.Device(D3D.DriverType.Hardware, D3D11.DeviceCreationFlags.Debug)) { this.device = defaultDevice.QueryInterface <D3D11.Device2>(); } // Save the context instance this.deviceContext = this.device.ImmediateContext2; Size2 sizeInPixels = RenderSizeToPixelSize(this.SwapChainPanel.RenderSize); // Properties of the swap chain DXGI.SwapChainDescription1 swapChainDescription = new DXGI.SwapChainDescription1() { // No transparency. AlphaMode = DXGI.AlphaMode.Ignore, // Double buffer. BufferCount = 2, // BGRA 32bit pixel format. Format = DXGI.Format.B8G8R8A8_UNorm, // Unlike in CoreWindow swap chains, the dimensions must be set. Height = sizeInPixels.Height, Width = sizeInPixels.Width, // Default multisampling. SampleDescription = new DXGI.SampleDescription(1, 0), // In case the control is resized, stretch the swap chain accordingly. Scaling = DXGI.Scaling.Stretch, // No support for stereo display. Stereo = false, // Sequential displaying for double buffering. SwapEffect = DXGI.SwapEffect.FlipSequential, // This swapchain is going to be used as the back buffer. Usage = DXGI.Usage.BackBuffer | DXGI.Usage.RenderTargetOutput, }; // Retrive the DXGI device associated to the Direct3D device. using (DXGI.Device3 dxgiDevice3 = this.device.QueryInterface <DXGI.Device3>()) { // Get the DXGI factory automatically created when initializing the Direct3D device. using (DXGI.Factory3 dxgiFactory3 = dxgiDevice3.Adapter.GetParent <DXGI.Factory3>()) { // Create the swap chain and get the highest version available. using (DXGI.SwapChain1 swapChain1 = new DXGI.SwapChain1(dxgiFactory3, this.device, ref swapChainDescription)) { this.swapChain = swapChain1.QueryInterface <DXGI.SwapChain2>(); } } } // Obtain a reference to the native COM object of the SwapChainPanel. using (DXGI.ISwapChainPanelNative nativeObject = ComObject.As <DXGI.ISwapChainPanelNative>(this.SwapChainPanel)) { // Set its swap chain. nativeObject.SwapChain = this.swapChain; } // Create a Texture2D from the existing swap chain to use as this.backBufferTexture = D3D11.Texture2D.FromSwapChain <D3D11.Texture2D>(this.swapChain, 0); this.backBufferView = new D3D11.RenderTargetView(this.device, this.backBufferTexture); // This event is fired when the application requests a new frame from the DirectX interop controls. CompositionTarget.Rendering += CompositionTarget_Rendering; // Subscribe to the suspending event Application.Current.Suspending += Application_Suspending; // Mark our resources as initialized isDXInitialized = true; }
private void SetupScreenBuffers() { width = (int) window.Bounds.Width; height = (int) window.Bounds.Height; // If the swap chain already exists, resize it. if (swapChain != null) { swapChain.ResizeBuffers(2, width, height, Format.B8G8R8A8_UNorm, SwapChainFlags.None); } // Otherwise, create a new one. else { // SwapChain description var desc = new SwapChainDescription1 { // Automatic sizing Width = width, Height = height, Format = Format.B8G8R8A8_UNorm, Stereo = false, SampleDescription = new SampleDescription(1, 0), Usage = Usage.BackBuffer | Usage.RenderTargetOutput, // Use two buffers to enable flip effect. BufferCount = 2, Scaling = Scaling.None, SwapEffect = SwapEffect.FlipSequential, }; // Once the desired swap chain description is configured, it must be created on the same adapter as our D3D Device // First, retrieve the underlying DXGI Device from the D3D Device. // Creates the swap chain using (var dxgiDevice2 = graphicsDevice.QueryInterface<Device2>()) using (Adapter dxgiAdapter = dxgiDevice2.Adapter) using (var dxgiFactory2 = dxgiAdapter.GetParent<Factory2>()) { // Creates a SwapChain from a CoreWindow pointer using (var comWindow = new ComObject(window)) swapChain = dxgiFactory2.CreateSwapChainForCoreWindow(graphicsDevice, comWindow, ref desc, null); // Ensure that DXGI does not queue more than one frame at a time. This both reduces // latency and ensures that the application will only render after each VSync, minimizing // power consumption. dxgiDevice2.MaximumFrameLatency = 1; } } // Obtain the backbuffer for this window which will be the final 3D rendertarget. backBuffer = ToDispose(Resource.FromSwapChain<Texture2D>(swapChain, 0)); { // Create a view interface on the rendertarget to use on bind. renderTargetView = ToDispose(new RenderTargetView(graphicsDevice, backBuffer)); } // Create a viewport descriptor of the full window size. var viewport = new Viewport(0, 0, width, height, 0.0f, 1.0f); // Set the current viewport using the descriptor. graphicsDevice.ImmediateContext.Rasterizer.SetViewports(viewport); }
protected void InitializeDirectXResources() { ScaleFactor = (float)GraphicsUtils.Scale; var clientSize = ClientSize; var backBufferDesc = new DXGI.ModeDescription(clientSize.Width, clientSize.Height, new DXGI.Rational(60, 1), DXGI.Format.R8G8B8A8_UNorm); var swapChainDesc = new DXGI.SwapChainDescription() { ModeDescription = backBufferDesc, SampleDescription = new DXGI.SampleDescription(1, 0), Usage = DXGI.Usage.RenderTargetOutput, BufferCount = 1, OutputHandle = Handle, SwapEffect = DXGI.SwapEffect.Discard, IsWindowed = Paradigm.Config.Test.Debug }; D3D11.Device.CreateWithSwapChain(D3D.DriverType.Hardware, D3D11.DeviceCreationFlags.BgraSupport, new[] { D3D.FeatureLevel.Level_10_0 }, swapChainDesc, out D3DDevice, out var swapChain); D3DDeviceContext = D3DDevice.ImmediateContext; SwapChain = new DXGI.SwapChain1(swapChain.NativePointer); D2DFactory = new D2D1.Factory(); using (var backBuffer = SwapChain.GetBackBuffer <D3D11.Texture2D>(0)) { RenderTargetView = new D3D11.RenderTargetView(D3DDevice, backBuffer); RenderTarget = new D2D1.RenderTarget(D2DFactory, backBuffer.QueryInterface <DXGI.Surface>(), new D2D1.RenderTargetProperties(new D2D1.PixelFormat(DXGI.Format.Unknown, D2D1.AlphaMode.Premultiplied))) { TextAntialiasMode = D2D1.TextAntialiasMode.Cleartype }; } DwFactory = new DW.Factory(DW.FactoryType.Shared); _customColorRenderer.AssignResources(RenderTarget, ForegroundBrush); CueTextFormat = new DW.TextFormat(DwFactory, "Arial", DW.FontWeight.Bold, DW.FontStyle.Normal, DW.FontStretch.Normal, 120 * ScaleFactor) { TextAlignment = DW.TextAlignment.Center, ParagraphAlignment = DW.ParagraphAlignment.Center }; SubtitleTextFormat = new DW.TextFormat(DwFactory, "Consolas", DW.FontWeight.Light, DW.FontStyle.Normal, DW.FontStretch.Normal, Paradigm.Config.Gui.InputTextFontSize * ScaleFactor / 2) { TextAlignment = DW.TextAlignment.Center, ParagraphAlignment = DW.ParagraphAlignment.Center }; ButtonLabelTextFormat = new DW.TextFormat(DwFactory, "Consolas", DW.FontWeight.Bold, DW.FontStyle.Normal, DW.FontStretch.Normal, Paradigm.Config.Gui.ButtonFontSize * ScaleFactor) { TextAlignment = DW.TextAlignment.Center, ParagraphAlignment = DW.ParagraphAlignment.Center }; InputTextFormat = new DW.TextFormat(DwFactory, "Consolas", DW.FontWeight.Bold, DW.FontStyle.Normal, DW.FontStretch.Normal, Paradigm.Config.Gui.InputTextFontSize * ScaleFactor) { TextAlignment = DW.TextAlignment.Leading, ParagraphAlignment = DW.ParagraphAlignment.Center }; SharedBrush = new D2D1.SolidColorBrush(RenderTarget, Color.White); BackgroundBrush = new D2D1.SolidColorBrush(RenderTarget, BackgroundColor); ForegroundBrush = new D2D1.SolidColorBrush(RenderTarget, ForegroundColor); CorrectColorBrush = new D2D1.SolidColorBrush(RenderTarget, CorrectTextColor); WrongColorBrush = new D2D1.SolidColorBrush(RenderTarget, WrongTextColor); PostInitDirectXResources(); }
private void CreateSwapChain(ref SwapChainDescription1 swapChainDescription1, Factory4 factory) { using (var sc1 = new SwapChain1(factory, commandQueue, ref swapChainDescription1)) { swapChain = Collect(sc1.QueryInterface<SwapChain3>()); using (var comPtr = new ComObject(panel)) { using (var native = comPtr.QueryInterface<ISwapChainPanelNative>()) { native.SwapChain = swapChain; } } } }
/// <summary> /// Create size dependent resources, in this case the swap chain and render targets /// </summary> /// <param name="app"></param> protected virtual void CreateSizeDependentResources(D3DApplicationBase app) { // Retrieve references to device and context var device = DeviceManager.Direct3DDevice; var context = DeviceManager.Direct3DContext; // Retrieve Direct2D context (for use with text rendering etc) var d2dContext = DeviceManager.Direct2DContext; // Before the swapchain can resize all the buffers must be released RemoveAndDispose(ref _backBuffer); RemoveAndDispose(ref _renderTargetView); RemoveAndDispose(ref _depthStencilView); RemoveAndDispose(ref _depthBuffer); RemoveAndDispose(ref _bitmapTarget); d2dContext.Target = null; #region Initialize Direct3D swap chain and render target // If the swap chain already exists, resize it. if (_swapChain != null) { _swapChain.ResizeBuffers( _swapChain.Description1.BufferCount, Width, Height, _swapChain.Description.ModeDescription.Format, _swapChain.Description.Flags); } // Otherwise, create a new one. else { // SwapChain description var desc = CreateSwapChainDescription(); // Rather than create a new DXGI Factory we should reuse // the one that has been used internally to create the device // First, retrieve the underlying DXGI Device from the D3D Device. // access the adapter used for that device and then create the swap chain using (var dxgiDevice2 = device.QueryInterface <SharpDX.DXGI.Device2>()) using (var dxgiAdapter = dxgiDevice2.Adapter) using (var dxgiFactory2 = dxgiAdapter.GetParent <SharpDX.DXGI.Factory2>()) using (var output = dxgiAdapter.Outputs.First()) { // The CreateSwapChain method is used so we can descend // from this class and implement a swapchain for a desktop // or a Windows 8 AppStore app _swapChain = ToDispose(CreateSwapChain(dxgiFactory2, device, desc)); #if !NETFX_CORE // Retrieve the list of supported display modes DisplayModeList = output.GetDisplayModeList(desc.Format, DisplayModeEnumerationFlags.Scaling); #endif } } // Obtain the backbuffer for this window which will be the final 3D rendertarget. BackBuffer = ToDispose(Texture2D.FromSwapChain <Texture2D>(_swapChain, 0)); // Create a view interface on the rendertarget to use on bind. RenderTargetView = ToDispose(new RenderTargetView(device, BackBuffer)); // Cache the rendertarget dimensions in our helper class for convenient use. var backBufferDesc = BackBuffer.Description; RenderTargetBounds = new SharpDX.Rectangle(0, 0, backBufferDesc.Width, backBufferDesc.Height); // Create a viewport descriptor of the render size. this.Viewport = new SharpDX.ViewportF( (float)RenderTargetBounds.X, (float)RenderTargetBounds.Y, (float)RenderTargetBounds.Width, (float)RenderTargetBounds.Height, 0.0f, // min depth 1.0f); // max depth // Set the current viewport for the rasterizer. context.Rasterizer.SetViewport(Viewport); // Create a descriptor for the depth/stencil buffer. // Allocate a 2-D texture as the depth/stencil buffer. // Create a DSV to use on bind. this.DepthBuffer = ToDispose(new Texture2D(device, new Texture2DDescription() { Format = SharpDX.DXGI.Format.D32_Float_S8X24_UInt, ArraySize = 1, MipLevels = 1, Width = RenderTargetSize.Width, Height = RenderTargetSize.Height, SampleDescription = SwapChain.Description.SampleDescription, BindFlags = BindFlags.DepthStencil, })); this.DepthStencilView = ToDispose( new DepthStencilView( device, DepthBuffer, new DepthStencilViewDescription() { Dimension = (SwapChain.Description.SampleDescription.Count > 1 || SwapChain.Description.SampleDescription.Quality > 0) ? DepthStencilViewDimension.Texture2DMultisampled : DepthStencilViewDimension.Texture2D })); // Set the OutputMerger targets context.OutputMerger.SetTargets(DepthStencilView, RenderTargetView); #endregion #region Initialize Direct2D render target // Now we set up the Direct2D render target bitmap linked to the swapchain. // Whenever we render to this bitmap, it will be directly rendered to the // swapchain associated with the window. var bitmapProperties = new SharpDX.Direct2D1.BitmapProperties1( new SharpDX.Direct2D1.PixelFormat(_swapChain.Description.ModeDescription.Format, SharpDX.Direct2D1.AlphaMode.Premultiplied), DeviceManager.Dpi, DeviceManager.Dpi, SharpDX.Direct2D1.BitmapOptions.Target | SharpDX.Direct2D1.BitmapOptions.CannotDraw); // Direct2D needs the dxgi version of the backbuffer surface pointer. // Get a D2D surface from the DXGI back buffer to use as the D2D render target. using (var dxgiBackBuffer = _swapChain.GetBackBuffer <SharpDX.DXGI.Surface>(0)) BitmapTarget2D = ToDispose(new SharpDX.Direct2D1.Bitmap1(d2dContext, dxgiBackBuffer, bitmapProperties)); // So now we can set the Direct2D render target. d2dContext.Target = BitmapTarget2D; // Set D2D text anti-alias mode to Grayscale to ensure proper rendering of text on intermediate surfaces. d2dContext.TextAntialiasMode = SharpDX.Direct2D1.TextAntialiasMode.Grayscale; #endregion }
/// <summary> /// Create the swap chain used to store rendered scenes. /// </summary> /// <param name="windowHandle">The handle of the window that displays the game.</param> /// <param name="scWidth">The desired width of the swap chain.</param> /// <param name="scHeight">The desired height of the swap chain.</param> private void CreateSwapChain(IntPtr windowHandle, int scWidth, int scHeight) { SwapChainDescription1 scDescription = new SwapChainDescription1() { BufferCount = 1, Flags = SwapChainFlags.AllowModeSwitch, Format = Format.B8G8R8A8_UNorm, Height = scHeight, SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0), Scaling = Scaling.Stretch, Stereo = false, SwapEffect = SwapEffect.Discard, Usage = SharpDX.DXGI.Usage.BackBuffer | SharpDX.DXGI.Usage.RenderTargetOutput, Width = scWidth, }; using (var dxgiDevice = Device3D.QueryInterface<SharpDX.DXGI.Device2>()) using (var dxgiAdapter = dxgiDevice.Adapter) using (var dxgiFactory = dxgiAdapter.GetParent<SharpDX.DXGI.Factory2>()) using (var output = dxgiAdapter.Outputs.First()) { // Create a swap chain for a desktop application SwapChain = ToDispose(new SwapChain1( dxgiFactory, Device3D, windowHandle, ref scDescription, CreateFullScreenDescription(), null)); // Retrieve the list of supported display modes DisplayModeList = output.GetDisplayModeList(scDescription.Format, DisplayModeEnumerationFlags.Scaling); } }
void Initialize(ComObject coreWindow, AntiAliasingMode antiAliasingMode) { InitializeInner(antiAliasingMode); var swapChainDesc = device.CreateSwapChainDescription(); DXGI.Factory2 factory = device.QueryInterface<DXGI.Device1>().Adapter.GetParent<DXGI.Factory2>(); swapChain = new DXGI.SwapChain1(factory, device, coreWindow, ref swapChainDesc); }
// Allocate all memory resources that change on a window SizeChanged event. protected virtual void CreateWindowSizeDependentResources() { _windowBounds = _window.Bounds; if (_swapChain != null) { _swapChain.ResizeBuffers(2, 0, 0, DXGI.Format.B8G8R8A8_UNorm, 0); } else { var swapChainDesc = new DXGI.SwapChainDescription1() { Width = 0, Height = 0, Format = DXGI.Format.B8G8R8A8_UNorm, Stereo = false, Usage = DXGI.Usage.RenderTargetOutput, BufferCount = 2, Scaling = DXGI.Scaling.None, SwapEffect = DXGI.SwapEffect.FlipSequential, SampleDescription = new DXGI.SampleDescription { Count = 1, Quality = 0 }, Flags = 0 }; _swapChain = _window.CreateSwapChain(_device, ref swapChainDesc); // gotta figure out some reasonable way of doing this // dxgiDevice.MaximumFrameLatency = 1; D3D11.Texture2D backBuffer = _swapChain.GetBackBuffer<D3D11.Texture2D>(0); _renderTargetView = new D3D11.RenderTargetView(_device, backBuffer); // Cache the rendertarget dimensions in our helper class for convenient use. _renderTargetSize.Width = backBuffer.Description.Width; _renderTargetSize.Height = backBuffer.Description.Height; // Create a descriptor for the depth/stencil buffer. var depthStencilDesc = new D3D11.Texture2DDescription { Format = DXGI.Format.D24_UNorm_S8_UInt, Width = backBuffer.Description.Width, Height = backBuffer.Description.Height, ArraySize = 1, MipLevels = 1, BindFlags = D3D11.BindFlags.DepthStencil, SampleDescription = new DXGI.SampleDescription { Count = 1 } }; // Allocate a 2-D surface as the depth/stencil buffer. var depthStencil = new D3D11.Texture2D(_device, depthStencilDesc); // Create a DepthStencil view on this surface to use on bind. _depthStencilView = new D3D11.DepthStencilView(_device, depthStencil, new D3D11.DepthStencilViewDescription { Dimension = D3D11.DepthStencilViewDimension.Texture2D }); // Create a viewport descriptor of the full window size. var viewPort = new D3D11.Viewport { TopLeftX = 0.0f, TopLeftY = 0.0f, Width = backBuffer.Description.Width, Height = backBuffer.Description.Height }; // Set the current viewport using the descriptor. _deviceContext.Rasterizer.SetViewports(viewPort); } }
private void SwapChainPanel_Loaded(object sender, RoutedEventArgs e) { var v = ApplicationView.GetForCurrentView(); v.FullScreenSystemOverlayMode = FullScreenSystemOverlayMode.Minimal; v.TryEnterFullScreenMode(); #if DEBUG var debugLevel = D3D11.DeviceCreationFlags.Debug | D3D11.DeviceCreationFlags.BgraSupport; #else var debugLevel = D3D11.DeviceCreationFlags.None | D3D11.DeviceCreationFlags.BgraSupport; #endif using (D3D11.Device defaultDevice = new D3D11.Device(D3D.DriverType.Hardware, debugLevel)) { this.device = defaultDevice.QueryInterface <D3D11.Device2>(); } this.deviceContext = this.device.ImmediateContext2; float pixelScale = Windows.Graphics.Display.DisplayInformation.GetForCurrentView().LogicalDpi / 96.0f; DXGI.SwapChainDescription1 swapChainDescription = new DXGI.SwapChainDescription1() { AlphaMode = DXGI.AlphaMode.Premultiplied, BufferCount = 2, Format = DXGI.Format.B8G8R8A8_UNorm, Height = (int)(this.SwapChainPanel.RenderSize.Height * pixelScale), Width = (int)(this.SwapChainPanel.RenderSize.Width * pixelScale), SampleDescription = new DXGI.SampleDescription(1, 0), Scaling = DXGI.Scaling.Stretch, Stereo = false, SwapEffect = DXGI.SwapEffect.FlipSequential, Usage = DXGI.Usage.BackBuffer | DXGI.Usage.RenderTargetOutput, }; using (DXGI.Device3 dxgiDevice3 = this.device.QueryInterface <DXGI.Device3>()) { using (DXGI.Factory3 dxgiFactory3 = dxgiDevice3.Adapter.GetParent <DXGI.Factory3>()) { using (DXGI.SwapChain1 swapChain1 = new DXGI.SwapChain1(dxgiFactory3, this.device, ref swapChainDescription)) { this.swapChain = swapChain1.QueryInterface <DXGI.SwapChain2>(); } } } using (DXGI.ISwapChainPanelNative nativeObject = ComObject.As <DXGI.ISwapChainPanelNative>(this.SwapChainPanel)) { nativeObject.SwapChain = this.swapChain; } this.backBufferTexture = D3D11.Texture2D.FromSwapChain <D3D11.Texture2D>(this.swapChain, 0); this.backBufferView = new D3D11.RenderTargetView(this.device, this.backBufferTexture); isDXInitialized = true; tw = new TextWirter(device, swapChain, Color.Black, DisplayInformation.GetForCurrentView().LogicalDpi); // #region D2D //#if DEBUG // var debug = SharpDX.Direct2D1.DebugLevel.Error; //#else // var debug = SharpDX.Direct2D1.DebugLevel.None; //#endif // d2dFactory = new SharpDX.Direct2D1.Factory1(SharpDX.Direct2D1.FactoryType.SingleThreaded, debug); // using (var dxgiDevice = device.QueryInterface<SharpDX.DXGI.Device>()) // { // d2dDevice = new SharpDX.Direct2D1.Device(d2dFactory, dxgiDevice); // } // d2dContext = new SharpDX.Direct2D1.DeviceContext(d2dDevice, SharpDX.Direct2D1.DeviceContextOptions.None); // BitmapProperties1 properties = new BitmapProperties1( // new PixelFormat( // SharpDX.DXGI.Format.B8G8R8A8_UNorm, // SharpDX.Direct2D1.AlphaMode.Premultiplied), // DisplayInformation.GetForCurrentView().LogicalDpi, // DisplayInformation.GetForCurrentView().LogicalDpi, // BitmapOptions.Target | BitmapOptions.CannotDraw); // DXGI.Surface backBuffer = swapChain.GetBackBuffer<DXGI.Surface>(0); // d2dTarget = new Bitmap1(d2dContext, backBuffer, properties); // SharpDX.DirectWrite.Factory fontFactory = new SharpDX.DirectWrite.Factory(); // textFormat = new TextFormat(fontFactory, "Segoe UI", 24.0f); // textLayout1 = new TextLayout(fontFactory, "This is an example of a moving TextLayout object with snapped pixel boundaries.", textFormat, 400.0f, 200.0f); // textLayout2 = new TextLayout(fontFactory, "This is an example of a moving TextLayout object with no snapped pixel boundaries.", textFormat, 400.0f, 200.0f); // layoutY = 0.0f; // backgroundBrush = new SharpDX.Direct2D1.SolidColorBrush(d2dContext, Color.White); // textBrush = new SharpDX.Direct2D1.SolidColorBrush(d2dContext, Color.Black); // #endregion CompositionTarget.Rendering += CompositionTarget_Rendering; Application.Current.Suspending += Application_Suspending; }
/// <summary> /// Now that we have a CoreWindow object, the DirectX device/context can be created. /// </summary> /// <param name="entryPoint"></param> public async void Load(string entryPoint) { // Get the default hardware device and enable debugging. Don't care about the available feature level. // DeviceCreationFlags.BgraSupport must be enabled to allow Direct2D interop. SharpDX.Direct3D11.Device defaultDevice = new SharpDX.Direct3D11.Device(DriverType.Hardware, DeviceCreationFlags.Debug | DeviceCreationFlags.BgraSupport); // Query the default device for the supported device and context interfaces. device = defaultDevice.QueryInterface<SharpDX.Direct3D11.Device1>(); d3dContext = device.ImmediateContext.QueryInterface<SharpDX.Direct3D11.DeviceContext1>(); // Query for the adapter and more advanced DXGI objects. SharpDX.DXGI.Device2 dxgiDevice2 = device.QueryInterface<SharpDX.DXGI.Device2>(); SharpDX.DXGI.Adapter dxgiAdapter = dxgiDevice2.Adapter; SharpDX.DXGI.Factory2 dxgiFactory2 = dxgiAdapter.GetParent<SharpDX.DXGI.Factory2>(); // Description for our swap chain settings. SwapChainDescription1 description = new SwapChainDescription1() { // 0 means to use automatic buffer sizing. Width = 0, Height = 0, // 32 bit RGBA color. Format = Format.B8G8R8A8_UNorm, // No stereo (3D) display. Stereo = false, // No multisampling. SampleDescription = new SampleDescription(1, 0), // Use the swap chain as a render target. Usage = Usage.RenderTargetOutput, // Enable double buffering to prevent flickering. BufferCount = 2, // No scaling. Scaling = Scaling.None, // Flip between both buffers. SwapEffect = SwapEffect.FlipSequential, }; // Generate a swap chain for our window based on the specified description. swapChain = dxgiFactory2.CreateSwapChainForCoreWindow(device, new ComObject(window), ref description, null); // Get the default Direct2D device and create a context. SharpDX.Direct2D1.Device d2dDevice = new SharpDX.Direct2D1.Device(dxgiDevice2); d2dContext = new SharpDX.Direct2D1.DeviceContext(d2dDevice, SharpDX.Direct2D1.DeviceContextOptions.None); // Specify the properties for the bitmap that we will use as the target of our Direct2D operations. // We want a 32-bit BGRA surface with premultiplied alpha. BitmapProperties1 properties = new BitmapProperties1(new PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied), DisplayProperties.LogicalDpi, DisplayProperties.LogicalDpi, BitmapOptions.Target | BitmapOptions.CannotDraw); // Get the default surface as a backbuffer and create the Bitmap1 that will hold the Direct2D drawing target. Surface backBuffer = swapChain.GetBackBuffer<Surface>(0); d2dTarget = new Bitmap1(d2dContext, backBuffer, properties); // Create the DirectWrite factory objet. SharpDX.DirectWrite.Factory fontFactory = new SharpDX.DirectWrite.Factory(); // Create a TextFormat object that will use the Segoe UI font with a size of 24 DIPs. textFormat = new TextFormat(fontFactory, "Segoe UI", 24.0f); // Create two TextLayout objects for rendering the moving text. textLayout1 = new TextLayout(fontFactory, "This is an example of a moving TextLayout object with snapped pixel boundaries.", textFormat, 400.0f, 200.0f); textLayout2 = new TextLayout(fontFactory, "This is an example of a moving TextLayout object with no snapped pixel boundaries.", textFormat, 400.0f, 200.0f); // Vertical offset for the moving text. layoutY = 0.0f; // Create the brushes for the text background and text color. backgroundBrush = new SolidColorBrush(d2dContext, Color.White); textBrush = new SolidColorBrush(d2dContext, Color.Black); }
/// <summary> /// Now that we have a CoreWindow object, the DirectX device/context can be created. /// </summary> /// <param name="entryPoint"></param> public void Load(string entryPoint) { // Get the default hardware device and enable debugging. Don't care about the available feature level. // DeviceCreationFlags.BgraSupport must be enabled to allow Direct2D interop. SharpDX.Direct3D11.Device defaultDevice = new SharpDX.Direct3D11.Device(DriverType.Hardware, DeviceCreationFlags.Debug | DeviceCreationFlags.BgraSupport); // Query the default device for the supported device and context interfaces. device = defaultDevice.QueryInterface<SharpDX.Direct3D11.Device1>(); d3dContext = device.ImmediateContext.QueryInterface<SharpDX.Direct3D11.DeviceContext1>(); // Query for the adapter and more advanced DXGI objects. SharpDX.DXGI.Device2 dxgiDevice2 = device.QueryInterface<SharpDX.DXGI.Device2>(); SharpDX.DXGI.Adapter dxgiAdapter = dxgiDevice2.Adapter; SharpDX.DXGI.Factory2 dxgiFactory2 = dxgiAdapter.GetParent<SharpDX.DXGI.Factory2>(); // Description for our swap chain settings. SwapChainDescription1 description = new SwapChainDescription1() { // 0 means to use automatic buffer sizing. Width = 0, Height = 0, // 32 bit RGBA color. Format = Format.B8G8R8A8_UNorm, // No stereo (3D) display. Stereo = false, // No multisampling. SampleDescription = new SampleDescription(1, 0), // Use the swap chain as a render target. Usage = Usage.RenderTargetOutput, // Enable double buffering to prevent flickering. BufferCount = 2, // No scaling. Scaling = Scaling.None, // Flip between both buffers. SwapEffect = SwapEffect.FlipSequential, }; // Generate a swap chain for our window based on the specified description. swapChain = dxgiFactory2.CreateSwapChainForCoreWindow(device, new ComObject(window), ref description, null); // Get the default Direct2D device and create a context. SharpDX.Direct2D1.Device d2dDevice = new SharpDX.Direct2D1.Device(dxgiDevice2); d2dContext = new SharpDX.Direct2D1.DeviceContext(d2dDevice, SharpDX.Direct2D1.DeviceContextOptions.None); // Specify the properties for the bitmap that we will use as the target of our Direct2D operations. // We want a 32-bit BGRA surface with premultiplied alpha. BitmapProperties1 properties = new BitmapProperties1(new PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied), DisplayProperties.LogicalDpi, DisplayProperties.LogicalDpi, BitmapOptions.Target | BitmapOptions.CannotDraw); // Get the default surface as a backbuffer and create the Bitmap1 that will hold the Direct2D drawing target. Surface backBuffer = swapChain.GetBackBuffer<Surface>(0); d2dTarget = new Bitmap1(d2dContext, backBuffer, properties); // Create a solid color brush. solidBrush = new SolidColorBrush(d2dContext, Color.Coral); // Create a linear gradient brush. // Note that the StartPoint and EndPoint values are set as absolute coordinates of the surface you are drawing to, // NOT the geometry we will apply the brush. linearGradientBrush = new LinearGradientBrush(d2dContext, new LinearGradientBrushProperties() { StartPoint = new Vector2(50, 0), EndPoint = new Vector2(450, 0), }, new GradientStopCollection(d2dContext, new GradientStop[] { new GradientStop() { Color = Color.Blue, Position = 0, }, new GradientStop() { Color = Color.Green, Position = 1, } })); // Create a radial gradient brush. // The center is specified in absolute coordinates, too. radialGradientBrush = new RadialGradientBrush(d2dContext, new RadialGradientBrushProperties() { Center = new Vector2(250, 525), RadiusX = 100, RadiusY = 100, }, new GradientStopCollection(d2dContext, new GradientStop[] { new GradientStop() { Color = Color.Yellow, Position = 0, }, new GradientStop() { Color = Color.Red, Position = 1, } })); }
public void Initialize() { if(!_deviceManager.IsInitialized) throw new InvalidOperationException("Device manager is not initialized"); if(Initialized) Uninitialize(); var swapChainDescription = new SwapChainDescription1 { Width = Width, Height = Height, Format = Format.B8G8R8A8_UNorm, Stereo = false, SampleDescription = new SampleDescription(SampleCount, SampleQuality), Usage = Usage.BackBuffer | Usage.RenderTargetOutput, BufferCount = 1, Scaling = Scaling.Stretch, SwapEffect = SwapEffect.Discard, Flags = SwapChainFlags.AllowModeSwitch }; var fullScreenDescription = new SwapChainFullScreenDescription { RefreshRate = new Rational(60, 1), Scaling = DisplayModeScaling.Centered, Windowed = true }; using(var dxgiDevice2 = _deviceManager.Device.QueryInterface<Device2>()) using(var dxgiFactory2 = dxgiDevice2.Adapter.GetParent<Factory2>()) { SwapChain = new SwapChain1(dxgiFactory2, _deviceManager.Device, _windowHandle, ref swapChainDescription, fullScreenDescription); dxgiFactory2.MakeWindowAssociation(_windowHandle, WindowAssociationFlags.IgnoreAll); } Texture = Resource.FromSwapChain<Texture2D>(SwapChain, 0); RenderTargetView = new RenderTargetView(_deviceManager.Device, Texture); Initialized = true; }
public void Dispose() { if (_rtv != null) _rtv.Dispose(); _rtv = null; if (_swap != null) _swap.Dispose(); _swap = null; if (ToolkitDevice != null) ToolkitDevice.Dispose(); ToolkitDevice = null; if (_context != null) _context.Dispose(); _context = null; if (_device != null) _device.Dispose(); _device = null; _width = 0; _height = 0; }
private void SwapChainPanel_Loaded(object sender, RoutedEventArgs e) { // Create a new Direct3D hardware device and ask for Direct3D 11.2 support using (D3D11.Device defaultDevice = new D3D11.Device(D3D.DriverType.Hardware, D3D11.DeviceCreationFlags.Debug)) { this.device = defaultDevice.QueryInterface<D3D11.Device2>(); } // Save the context instance this.deviceContext = this.device.ImmediateContext2; // We have to take into account pixel scaling; Windows Phone 8.1 uses virtual resolutions smaller than the physical screen size. float pixelScale = Windows.Graphics.Display.DisplayInformation.GetForCurrentView().LogicalDpi / 96.0f; // Properties of the swap chain DXGI.SwapChainDescription1 swapChainDescription = new DXGI.SwapChainDescription1() { // No transparency. AlphaMode = DXGI.AlphaMode.Ignore, // Double buffer. BufferCount = 2, // BGRA 32bit pixel format. Format = DXGI.Format.B8G8R8A8_UNorm, // Unlike in CoreWindow swap chains, the dimensions must be set. Height = (int)(this.SwapChainPanel.RenderSize.Height * pixelScale), Width = (int)(this.SwapChainPanel.RenderSize.Width * pixelScale), // Default multisampling. SampleDescription = new DXGI.SampleDescription(1, 0), // In case the control is resized, stretch the swap chain accordingly. Scaling = DXGI.Scaling.Stretch, // No support for stereo display. Stereo = false, // Sequential displaying for double buffering. SwapEffect = DXGI.SwapEffect.FlipSequential, // This swapchain is going to be used as the back buffer. Usage = DXGI.Usage.BackBuffer | DXGI.Usage.RenderTargetOutput, }; // Retrive the DXGI device associated to the Direct3D device. using (DXGI.Device3 dxgiDevice3 = this.device.QueryInterface<DXGI.Device3>()) { // Get the DXGI factory automatically created when initializing the Direct3D device. using (DXGI.Factory3 dxgiFactory3 = dxgiDevice3.Adapter.GetParent<DXGI.Factory3>()) { // Create the swap chain and get the highest version available. using (DXGI.SwapChain1 swapChain1 = new DXGI.SwapChain1(dxgiFactory3, this.device, ref swapChainDescription)) { this.swapChain = swapChain1.QueryInterface<DXGI.SwapChain2>(); } } } // Obtain a reference to the native COM object of the SwapChainPanel. using (DXGI.ISwapChainPanelNative nativeObject = ComObject.As<DXGI.ISwapChainPanelNative>(this.SwapChainPanel)) { // Set its swap chain. nativeObject.SwapChain = this.swapChain; } // Create a Texture2D from the existing swap chain to use as this.backBufferTexture = D3D11.Texture2D.FromSwapChain<D3D11.Texture2D>(this.swapChain, 0); this.backBufferView = new D3D11.RenderTargetView(this.device, this.backBufferTexture); // This event is fired when the application requests a new frame from the DirectX interop controls. CompositionTarget.Rendering += CompositionTarget_Rendering; }
protected virtual void CreateSizeDependentResources(TargetBase renderBase) { var d3dDevice = DeviceManager.DeviceDirect3D; var d3dContext = DeviceManager.ContextDirect3D; var d2dContext = DeviceManager.ContextDirect2D; d2dContext.Target = null; RemoveAndDispose(ref renderTargetView); RemoveAndDispose(ref depthStencilView); RemoveAndDispose(ref bitmapTarget); RemoveAndDispose(ref backBuffer); // If the swap chain already exists, resize it. if (swapChain != null) { swapChain.ResizeBuffers(2, Width, Height, SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.DXGI.SwapChainFlags.None); } // Otherwise, create a new one. else { // SwapChain description var desc = CreateSwapChainDescription(); // Once the desired swap chain description is configured, it must be created on the same adapter as our D3D Device // First, retrieve the underlying DXGI Device from the D3D Device. // Creates the swap chain using (var dxgiDevice2 = d3dDevice.QueryInterface<SharpDX.DXGI.Device2>()) using (var dxgiAdapter = dxgiDevice2.Adapter) using (var dxgiFactory2 = dxgiAdapter.GetParent<SharpDX.DXGI.Factory2>()) { swapChain = ToDispose(CreateSwapChain(dxgiFactory2, d3dDevice, desc)); // Ensure that DXGI does not queue more than one frame at a time. This both reduces // latency and ensures that the application will only render after each VSync, minimizing // power consumption. dxgiDevice2.MaximumFrameLatency = 1; } } // Obtain the backbuffer for this window which will be the final 3D rendertarget. backBuffer = ToDispose(SharpDX.Direct3D11.Texture2D.FromSwapChain<SharpDX.Direct3D11.Texture2D>(swapChain, 0)); { // Create a view interface on the rendertarget to use on bind. renderTargetView = ToDispose(new SharpDX.Direct3D11.RenderTargetView(d3dDevice, BackBuffer)); // Cache the rendertarget dimensions in our helper class for convenient use. var backBufferDesc = BackBuffer.Description; RenderTargetBounds = new Windows.Foundation.Rect(0, 0, backBufferDesc.Width, backBufferDesc.Height); } // Create a descriptor for the depth/stencil buffer. // Allocate a 2-D surface as the depth/stencil buffer. // Create a DepthStencil view on this surface to use on bind. using (var depthBuffer = new SharpDX.Direct3D11.Texture2D(d3dDevice, new SharpDX.Direct3D11.Texture2DDescription() { Format = SharpDX.DXGI.Format.D24_UNorm_S8_UInt, ArraySize = 1, MipLevels = 1, Width = (int)RenderTargetSize.Width, Height = (int)RenderTargetSize.Height, SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0), BindFlags = SharpDX.Direct3D11.BindFlags.DepthStencil, })) depthStencilView = ToDispose(new SharpDX.Direct3D11.DepthStencilView(d3dDevice, depthBuffer, new SharpDX.Direct3D11.DepthStencilViewDescription() { Dimension = SharpDX.Direct3D11.DepthStencilViewDimension.Texture2D })); // Create a viewport descriptor of the full window size. var viewport = new SharpDX.ViewportF((float)RenderTargetBounds.X, (float)RenderTargetBounds.Y, (float)RenderTargetBounds.Width, (float)RenderTargetBounds.Height, 0.0f, 1.0f); // Set the current viewport using the descriptor. d3dContext.Rasterizer.SetViewports(viewport); // Now we set up the Direct2D render target bitmap linked to the swapchain. // Whenever we render to this bitmap, it will be directly rendered to the // swapchain associated with the window. var bitmapProperties = new SharpDX.Direct2D1.BitmapProperties1( new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied), DeviceManager.Dpi, DeviceManager.Dpi, SharpDX.Direct2D1.BitmapOptions.Target | SharpDX.Direct2D1.BitmapOptions.CannotDraw); // Direct2D needs the dxgi version of the backbuffer surface pointer. // Get a D2D surface from the DXGI back buffer to use as the D2D render target. using (var dxgiBackBuffer = swapChain.GetBackBuffer<SharpDX.DXGI.Surface>(0)) bitmapTarget = ToDispose(new SharpDX.Direct2D1.Bitmap1(d2dContext, dxgiBackBuffer, bitmapProperties)); // So now we can set the Direct2D render target. d2dContext.Target = BitmapTarget2D; // Set D2D text anti-alias mode to Grayscale to ensure proper rendering of text on intermediate surfaces. d2dContext.TextAntialiasMode = SharpDX.Direct2D1.TextAntialiasMode.Grayscale; }
protected override SharpDX.DXGI.SwapChain1 CreateSwapChain(SharpDX.DXGI.Factory2 factory, SharpDX.Direct3D11.Device1 device, SharpDX.DXGI.SwapChainDescription1 desc) { // Creates the swap chain for XAML composition var swapChain = new SwapChain1(factory, device, ref desc); //factory.CreateSwapChainForComposition(device, ref desc, null); // Associate the SwapChainPanel with the swap chain nativePanel.SwapChain = swapChain; // Returns the new swap chain return swapChain; }
protected override SharpDX.DXGI.SwapChain1 CreateSwapChain(SharpDX.DXGI.Factory2 factory, SharpDX.Direct3D11.Device1 device, SharpDX.DXGI.SwapChainDescription1 desc) { // Create the swap chain for XAML composition var swapChain = new SwapChain1(factory, device, ref desc); // Attach swap chain to SwapChainPanel nativePanel.SwapChain = swapChain; return swapChain; }
private SwapChain CreateSwapChainForWinRT() { var coreWindow = Description.DeviceWindowHandle as CoreWindow; var swapChainBackgroundPanel = Description.DeviceWindowHandle as SwapChainBackgroundPanel; bufferCount = 2; var description = new SwapChainDescription1 { // Automatic sizing Width = Description.BackBufferWidth, Height = Description.BackBufferHeight, Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm, // TODO: Check if we can use the Description.BackBufferFormat Stereo = false, SampleDescription = new SharpDX.DXGI.SampleDescription((int)Description.MultiSampleCount, 0), Usage = Description.RenderTargetUsage, // Use two buffers to enable flip effect. BufferCount = bufferCount, Scaling = SharpDX.DXGI.Scaling.Stretch, SwapEffect = SharpDX.DXGI.SwapEffect.FlipSequential, }; if (coreWindow != null) { // Creates a SwapChain from a CoreWindow pointer using (var comWindow = new ComObject(coreWindow)) return new SwapChain1((DXGI.Factory2)GraphicsAdapter.Factory, (Direct3D11.Device)GraphicsDevice, comWindow, ref description); } else if (swapChainBackgroundPanel != null) { var nativePanel = ComObject.As<ISwapChainBackgroundPanelNative>(swapChainBackgroundPanel); // Creates the swap chain for XAML composition var swapChain = new SwapChain1((DXGI.Factory2)GraphicsAdapter.Factory, (Direct3D11.Device)GraphicsDevice, ref description); // Associate the SwapChainBackgroundPanel with the swap chain nativePanel.SwapChain = swapChain; return swapChain; } else { #if DIRECTX11_2 using (var comObject = new ComObject(Description.DeviceWindowHandle)) { var swapChainPanel = comObject.QueryInterfaceOrNull<ISwapChainPanelNative>(); if (swapChainPanel != null) { var swapChain = new SwapChain1((DXGI.Factory2)GraphicsAdapter.Factory, (Direct3D11.Device)GraphicsDevice, ref description); swapChainPanel.SwapChain = swapChain; return swapChain; } } #endif throw new NotSupportedException(); } }
protected virtual void CreateSizeDependentResources(object sender, RenderEventArgs e) { var d3dDevice = DirectX.Direct3D.Device; var d3dContext = DirectX.Direct3D.Context; var d2dContext = DirectX.Direct2D.Context; bool isStereoEnabled = deviceManager.Settings.IsStereo; Cleanup(); // If the swap chain already exists, resize it. if (swapChain != null) { swapChain.ResizeBuffers(2, Width, Height, SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.DXGI.SwapChainFlags.None); } // Otherwise, create a new one. else { // SwapChain description var desc = CreateSwapChainDescription(); // Once the desired swap chain description is configured, it must be created on the same adapter as our D3D Device // First, retrieve the underlying DXGI Device from the D3D Device. // Creates the swap chain using (var dxgiDevice2 = d3dDevice.QueryInterface <SharpDX.DXGI.Device2>()) using (var dxgiAdapter = dxgiDevice2.Adapter) using (var dxgiFactory2 = dxgiAdapter.GetParent <SharpDX.DXGI.Factory2>()) { swapChain = ToDispose(CreateSwapChain(dxgiFactory2, d3dDevice, desc)); // Ensure that DXGI does not queue more than one frame at a time. This both reduces // latency and ensures that the application will only render after each VSync, minimizing // power consumption. dxgiDevice2.MaximumFrameLatency = 1; } } // Obtain the backbuffer for this window which will be the final 3D rendertarget. backBuffer = ToDispose(SharpDX.Direct3D11.Texture2D.FromSwapChain <SharpDX.Direct3D11.Texture2D>(swapChain, 0)); { RenderTargetViewDescription rtvDescription = new RenderTargetViewDescription() { Dimension = RenderTargetViewDimension.Texture2DArray, Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm, Texture2DArray = new RenderTargetViewDescription.Texture2DArrayResource() { MipSlice = 0, FirstArraySlice = 0, ArraySize = 1 } }; // Create a view interface on the rendertarget to use on bind. renderTargetView = ToDispose(new SharpDX.Direct3D11.RenderTargetView(d3dDevice, BackBuffer, rtvDescription)); if (IsStereoEnabled) { RenderTargetViewDescription rtvDescriptionRight = new RenderTargetViewDescription() { Dimension = RenderTargetViewDimension.Texture2DArray, Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm, Texture2DArray = new RenderTargetViewDescription.Texture2DArrayResource() { MipSlice = 0, FirstArraySlice = 1, ArraySize = 1 } }; renderTargetViewRight = ToDispose(new SharpDX.Direct3D11.RenderTargetView(d3dDevice, BackBuffer, rtvDescriptionRight)); } // Cache the rendertarget dimensions in our helper class for convenient use. var backBufferDesc = BackBuffer.Description; RenderTargetBounds = new Windows.Foundation.Rect(0, 0, backBufferDesc.Width, backBufferDesc.Height); } // Create a descriptor for the depth/stencil buffer. // Allocate a 2-D surface as the depth/stencil buffer. // Create a DepthStencil view on this surface to use on bind. using (var depthBuffer = new SharpDX.Direct3D11.Texture2D(d3dDevice, new SharpDX.Direct3D11.Texture2DDescription() { Format = SharpDX.DXGI.Format.D24_UNorm_S8_UInt, ArraySize = 1, MipLevels = 1, Width = (int)RenderTargetSize.Width, Height = (int)RenderTargetSize.Height, SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0), BindFlags = SharpDX.Direct3D11.BindFlags.DepthStencil, })) depthStencilView = ToDispose(new SharpDX.Direct3D11.DepthStencilView(d3dDevice, depthBuffer, new SharpDX.Direct3D11.DepthStencilViewDescription() { Dimension = SharpDX.Direct3D11.DepthStencilViewDimension.Texture2D })); // Create a viewport descriptor of the full window size. var viewport = new SharpDX.ViewportF((float)RenderTargetBounds.X, (float)RenderTargetBounds.Y, (float)RenderTargetBounds.Width, (float)RenderTargetBounds.Height, 0.0f, 1.0f); // Set the current viewport using the descriptor. d3dContext.Rasterizer.SetViewport(viewport); // Now we set up the Direct2D render target bitmap linked to the swapchain. // Whenever we render to this bitmap, it will be directly rendered to the // swapchain associated with the window. var bitmapProperties = new SharpDX.Direct2D1.BitmapProperties1( new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied), deviceManager.Dpi, deviceManager.Dpi, SharpDX.Direct2D1.BitmapOptions.Target | SharpDX.Direct2D1.BitmapOptions.CannotDraw); // Direct2D needs the dxgi version of the backbuffer surface pointer. // Get a D2D surface from the DXGI back buffer to use as the D2D render target. if (IsStereoEnabled) { using (var dxgiBackBuffer = swapChain.GetBackBuffer <SharpDX.DXGI.Resource1>(0)) { using (var dxgiSurface = new Surface2(dxgiBackBuffer, 0)) bitmapTarget = ToDispose(new SharpDX.Direct2D1.Bitmap1(d2dContext, dxgiSurface, bitmapProperties)); using (var dxgiSurface = new Surface2(dxgiBackBuffer, 1)) bitmapTargetRight = ToDispose(new SharpDX.Direct2D1.Bitmap1(d2dContext, dxgiSurface, bitmapProperties)); } } else { using (var dxgiBackBuffer = swapChain.GetBackBuffer <SharpDX.DXGI.Surface2>(0)) bitmapTarget = ToDispose(new SharpDX.Direct2D1.Bitmap1(d2dContext, dxgiBackBuffer, bitmapProperties)); } // So now we can set the Direct2D render target. d2dContext.Target = BitmapTarget; // Set D2D text anti-alias mode to Grayscale to ensure proper rendering of text on intermediate surfaces. d2dContext.TextAntialiasMode = SharpDX.Direct2D1.TextAntialiasMode.Grayscale; }
/// <summary> /// Now that we have a CoreWindow object, the DirectX device/context can be created. /// </summary> /// <param name="entryPoint"></param> public void Load(string entryPoint) { // Get the default hardware device and enable debugging. Don't care about the available feature level. // DeviceCreationFlags.BgraSupport must be enabled to allow Direct2D interop. SharpDX.Direct3D11.Device defaultDevice = new SharpDX.Direct3D11.Device(DriverType.Hardware, DeviceCreationFlags.Debug | DeviceCreationFlags.BgraSupport); // Query the default device for the supported device and context interfaces. device = defaultDevice.QueryInterface<SharpDX.Direct3D11.Device1>(); d3dContext = device.ImmediateContext.QueryInterface<SharpDX.Direct3D11.DeviceContext1>(); // Query for the adapter and more advanced DXGI objects. SharpDX.DXGI.Device2 dxgiDevice2 = device.QueryInterface<SharpDX.DXGI.Device2>(); SharpDX.DXGI.Adapter dxgiAdapter = dxgiDevice2.Adapter; SharpDX.DXGI.Factory2 dxgiFactory2 = dxgiAdapter.GetParent<SharpDX.DXGI.Factory2>(); // Description for our swap chain settings. SwapChainDescription1 description = new SwapChainDescription1() { // 0 means to use automatic buffer sizing. Width = 0, Height = 0, // 32 bit RGBA color. Format = Format.B8G8R8A8_UNorm, // No stereo (3D) display. Stereo = false, // No multisampling. SampleDescription = new SampleDescription(1, 0), // Use the swap chain as a render target. Usage = Usage.RenderTargetOutput, // Enable double buffering to prevent flickering. BufferCount = 2, // No scaling. Scaling = Scaling.None, // Flip between both buffers. SwapEffect = SwapEffect.FlipSequential, }; // Generate a swap chain for our window based on the specified description. swapChain = new SwapChain1(dxgiFactory2, device, new ComObject(window), ref description); // Get the default Direct2D device and create a context. SharpDX.Direct2D1.Device d2dDevice = new SharpDX.Direct2D1.Device(dxgiDevice2); d2dContext = new SharpDX.Direct2D1.DeviceContext(d2dDevice, SharpDX.Direct2D1.DeviceContextOptions.None); // Specify the properties for the bitmap that we will use as the target of our Direct2D operations. // We want a 32-bit BGRA surface with premultiplied alpha. BitmapProperties1 properties = new BitmapProperties1(new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied), DisplayProperties.LogicalDpi, DisplayProperties.LogicalDpi, BitmapOptions.Target | BitmapOptions.CannotDraw); // Get the default surface as a backbuffer and create the Bitmap1 that will hold the Direct2D drawing target. Surface backBuffer = swapChain.GetBackBuffer<Surface>(0); d2dTarget = new Bitmap1(d2dContext, backBuffer, properties); // Load bitmap images playerBitmap = this.LoadBitmapFromContentFile("/Assets/Bitmaps/player.png"); terrainBitmap = this.LoadBitmapFromContentFile("/Assets/Bitmaps/terrain.png"); // Create hue rotation effect hueRotationEffect = new SharpDX.Direct2D1.Effects.HueRotation(d2dContext); // Create image shadow effect shadowEffect = new SharpDX.Direct2D1.Effects.Shadow(d2dContext); // Create image transform effect affineTransformEffect = new SharpDX.Direct2D1.Effects.AffineTransform2D(d2dContext); affineTransformEffect.SetInputEffect(0, shadowEffect); affineTransformEffect.TransformMatrix = Matrix3x2.Translation(terrainBitmap.PixelSize.Width * 0.25f, terrainBitmap.PixelSize.Height * 0.25f); // Create composite effect compositeEffect = new SharpDX.Direct2D1.Effects.Composite(d2dContext); compositeEffect.InputCount = 2; compositeEffect.SetInputEffect(0, affineTransformEffect); // Create tiling brush for terrain bitmap terrainBrush = new ImageBrush(d2dContext, terrainBitmap, new ImageBrushProperties() { ExtendModeX = ExtendMode.Wrap, ExtendModeY = ExtendMode.Wrap, SourceRectangle = new RectangleF(0, 0, terrainBitmap.Size.Width, terrainBitmap.Size.Height), }); // Create rendertarget for drawing the tiling brush brushTarget = new Bitmap1(d2dContext, new Size2((int)(terrainBitmap.Size.Width * 10), (int)terrainBitmap.Size.Height), new BitmapProperties1() { PixelFormat = new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied), BitmapOptions = BitmapOptions.Target }); }
private void CreateSwapChain(ref SwapChainDescription1 swapChainDescription1, Factory4 factory) { using (var sc1 = new SwapChain1(factory, commandQueue, form.Handle, ref swapChainDescription1)) swapChain = Collect(sc1.QueryInterface<SwapChain3>()); }
void InitializeDirect2D() { d3dDevice = new D3D.Device(DriverType.Hardware, DeviceCreationFlags.BgraSupport); dxgiDevice = d3dDevice.QueryInterface<DXGI.Device1>(); var desc = new SwapChainDescription1() { Width = 0, Height = 0, Format = Format.B8G8R8A8_UNorm, Stereo = false, SampleDescription = new SampleDescription(1, 0), Usage = Usage.RenderTargetOutput, BufferCount = 3, Scaling = Scaling.None, SwapEffect = SwapEffect.FlipSequential, Flags = SwapChainFlags.None }; DXGI.Factory2 dxgiFactory = dxgiDevice.Adapter.GetParent<DXGI.Factory2>(); swapChain = new SwapChain1(dxgiFactory, d3dDevice, Child.Handle, ref desc); swapChain.BackgroundColor = Color4.White; dxgiFactory.Dispose(); d2dFactory = new D2D.Factory1(FactoryType.SingleThreaded); d2dDevice = new D2D.Device(d2dFactory, dxgiDevice); d2dDeviceContext = new D2D.DeviceContext(d2dDevice, DeviceContextOptions.None); d2dDeviceContext.TextAntialiasMode = TextAntialiasMode.Cleartype; //d2dDeviceContext.DotsPerInch = new Size2F(96, 96); var props = new BitmapProperties1(new PixelFormat(Format.B8G8R8A8_UNorm, D2D.AlphaMode.Ignore), d2dDeviceContext.DotsPerInch.Width, d2dDeviceContext.DotsPerInch.Height, BitmapOptions.Target | BitmapOptions.CannotDraw); Surface1 dxgiSurface = swapChain.GetBackBuffer<Surface1>(0); d2dSurface = new Bitmap1(d2dDeviceContext, dxgiSurface, props); dxgiSurface.Dispose(); d2dDeviceContext.Target = d2dSurface; VertexFillBrush = new SolidColorBrush(d2dDeviceContext, new Color4(1, 0.5f, 0, 1)); VertexDrawBrush = new SolidColorBrush(d2dDeviceContext, new Color4(0.2f, 0.2f, 0.2f, 1)); EdgeDrawBrush = new SolidColorBrush(d2dDeviceContext, Color4.Black); RasterDrawBrush = new SolidColorBrush(d2dDeviceContext, new Color4(0.5f, 0.5f, 0.5f, 1)); }