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 SetRenderTargets(DeviceContext context, ref RenderParameter parameter)
{
context.OutputMerger.SetTargets(parameter.DepthStencilView, parameter.RenderTargetView);
context.Rasterizer.SetViewport(parameter.ViewportRegion);
context.Rasterizer.SetScissorRectangle(parameter.ScissorRegion.Left, parameter.ScissorRegion.Top,
parameter.ScissorRegion.Right, parameter.ScissorRegion.Bottom);
}
/// <summary>
/// Clear the render targets and depth stencil
/// </summary>
/// <param name="context"></param>
/// <param name="background"></param>
public void Clear(DeviceContext1 context, Color background)
{
context.ClearDepthStencilView(DSV, DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, 1.0f, 0);
foreach (var rtv in RTVs)
context.ClearRenderTargetView(rtv, background);
}
/// <summary>
/// Sets the default render-targets
/// </summary>
public void SetDefaultRenderTargets(DeviceContextProxy context, bool isColorBuffer = true)
{
context.SetRenderTargets(isColorBuffer ? depthStencilBuffer : null, new RenderTargetView[] { isColorBuffer?colorBuffer: backBuffer });
//context.OutputMerger.SetTargets(depthStencilBuffer, new RenderTargetView[] { isColorBuffer ? colorBuffer : backBuffer });
context.SetViewport(0, 0, TargetWidth, TargetHeight, 0.0f, 1.0f);
context.SetScissorRectangle(0, 0, TargetWidth, TargetHeight);
}
/// <summary>
/// Clears the render target.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="clearBackBuffer">if set to <c>true</c> [clear back buffer].</param>
/// <param name="clearDepthStencilBuffer">if set to <c>true</c> [clear depth stencil buffer].</param>
public void ClearRenderTarget(DeviceContext context, bool clearBackBuffer, bool clearDepthStencilBuffer)
{
if (CurrentRenderHost != null)
{
CurrentRenderHost.ClearRenderTarget(context, clearBackBuffer, clearDepthStencilBuffer);
}
}
internal void Initialise()
{
RemoveAndDispose(ref _d2dFactory);
RemoveAndDispose(ref _dwFactory);
_d2dFactory = ToDispose(new SharpDX.Direct2D1.Factory1(FactoryType.SingleThreaded));
_dwFactory = ToDispose(new SharpDX.DirectWrite.Factory(SharpDX.DirectWrite.FactoryType.Shared));
RemoveAndDispose(ref _d3dDevice);
RemoveAndDispose(ref _d3dContext);
RemoveAndDispose(ref _d2dDevice);
RemoveAndDispose(ref _d2dContext);
//var desc = CreateSwapChainDescription();
using (var device = new Device(DriverType.Hardware, DeviceCreationFlags.BgraSupport)) // | DeviceCreationFlags.Debug,
{
_d3dDevice = ToDispose(device.QueryInterface <SharpDX.Direct3D11.Device1>());
}
_d3dContext = ToDispose(_d3dDevice.ImmediateContext.QueryInterface <SharpDX.Direct3D11.DeviceContext1>());
using (var dxgiDevice = _d3dDevice.QueryInterface <SharpDX.DXGI.Device>())
{
_d2dDevice = ToDispose(new SharpDX.Direct2D1.Device(_d2dFactory, dxgiDevice));
}
_d2dContext = ToDispose(new DeviceContext(_d2dDevice, DeviceContextOptions.None));
/*
* D2Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.BgraSupport, new [] { FeatureLevel.Level_10_0 }, desc, out _device, out _swapChain);
*
* ToDispose(_device);
* ToDispose(_swapChain);
*
* var d2dFactory = ToDispose(new SharpDX.Direct2D1.Factory());
*
* Factory factory = ToDispose(_swapChain.GetParent<Factory>());
* factory.MakeWindowAssociation(_outputHandle, WindowAssociationFlags.IgnoreAll);
*
* _backBuffer = ToDispose(Texture2D.FromSwapChain<Texture2D>(_swapChain, 0));
* _renderTargetView = ToDispose(new RenderTargetView(_device, _backBuffer));
* _surface = ToDispose(_backBuffer.QueryInterface<Surface>());
*
* _target = ToDispose(new RenderTarget(d2dFactory, _surface, new RenderTargetProperties(new PixelFormat(Format.Unknown, AlphaMode.Premultiplied))));
*/
InitialiseResources();
RemoveAndDispose(ref _fpsCounter);
_fpsCounter = new FpsCounter();
_fpsCounter.InitialiseGraphics(this);
OnInitialize?.Invoke(this);
}
/// <summary>
/// Create device manager objects
/// </summary>
/// <remarks>
/// This method is called at the initialization of this instance.
/// </remarks>
protected virtual void CreateInstance()
{
// Dispose previous references and set to null
RemoveAndDispose(ref d3dDevice);
RemoveAndDispose(ref d3dContext);
RemoveAndDispose(ref d2dDevice);
RemoveAndDispose(ref d2dContext);
RemoveAndDispose(ref d2dFactory);
RemoveAndDispose(ref dwriteFactory);
RemoveAndDispose(ref wicFactory);
#region Create Direct3D 11.1 device and retrieve device context
// BGRA performs better especially with Direct2D software render targets
var creationFlags = SharpDX.Direct3D11.DeviceCreationFlags.BgraSupport;
#if DEBUG
// Enble D3D device debug layer
creationFlags |= SharpDX.Direct3D11.DeviceCreationFlags.Debug;
#endif
// Retrieve the Direct3D 11.1 device and device context
using (var device = new SharpDX.Direct3D11.Device(DriverType.Hardware,
creationFlags,
D3DFeatureLevel))
{
d3dDevice = ToDispose(device.QueryInterface <Device1>());
}
// Get Direct3D 11.1 immediate context
d3dContext = ToDispose(d3dDevice.ImmediateContext.QueryInterface <DeviceContext1>());
#endregion
#region Create Direct2D device and context
#if DEBUG
var debugLevel = SharpDX.Direct2D1.DebugLevel.Information;
#endif
// Allocate new references
d2dFactory = ToDispose(new SharpDX.Direct2D1.Factory1(SharpDX.Direct2D1.FactoryType.SingleThreaded, debugLevel));
dwriteFactory = ToDispose(new SharpDX.DirectWrite.Factory(SharpDX.DirectWrite.FactoryType.Shared));
wicFactory = ToDispose(new SharpDX.WIC.ImagingFactory2());
// Create Direct2D device
using (var dxgiDevice = d3dDevice.QueryInterface <SharpDX.DXGI.Device>())
{
d2dDevice = ToDispose(new SharpDX.Direct2D1.Device(d2dFactory, dxgiDevice));
}
// Create Direct2D context
d2dContext = ToDispose(new SharpDX.Direct2D1.DeviceContext(d2dDevice,
SharpDX.Direct2D1.DeviceContextOptions.None));
#endregion
}
/// <summary>
/// Clears the buffers with the clear-color
/// </summary>
/// <param name="context"></param>
/// <param name="color"></param>
/// <param name="clearBackBuffer"></param>
/// <param name="clearDepthStencilBuffer"></param>
public void ClearRenderTarget(DeviceContextProxy context, Color4 color, bool clearBackBuffer, bool clearDepthStencilBuffer)
{
if (clearBackBuffer)
{
context.ClearRenderTargetView(colorBuffer, color);
}
if (clearDepthStencilBuffer)
{
context.ClearDepthStencilView(depthStencilBuffer, DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, 1.0f, 0);
}
}
public static void CopyToTexture(DeviceContext1 context, Texture2D source, Texture2D destination, int subResource = 0)
{
if (source.Description.SampleDescription.Count > 1 || source.Description.SampleDescription.Quality > 0)
{
context.ResolveSubresource(source, subResource, destination, 0, destination.Description.Format);
}
else
{
// Not multisampled, so just copy to the destination
context.CopySubresourceRegion(source, subResource, null, destination, 0);
//context.CopyResource(source, destination);
}
}
/// <summary>
/// Set default render target to specify context.
/// </summary>
/// <param name="context"></param>
/// <param name="clear"></param>
/// <returns>Set successful?</returns>
public bool SetDefaultRenderTargets(DeviceContext context, bool clear = true)
{
if (!IsInitialized)
{
return(false);
}
renderBuffer.SetDefaultRenderTargets(context);
if (clear)
{
renderBuffer.ClearRenderTarget(context, ClearColor);
}
return(true);
}
public void Initialise(int width, int height, params SharpDX.Direct3D.FeatureLevel[] featureLevels)
{
// Create device
var dev = new D3D11.Device(SharpDX.Direct3D.DriverType.Hardware, D3D11.DeviceCreationFlags.None,
featureLevels);
_device = ComObject.As <D3D11.Device1>(dev.NativePointer);
_context = _device.ImmediateContext1;
ToolkitDevice = SharpDX.Toolkit.Graphics.GraphicsDevice.New(_device);
InitSwapChain(width, height);
RetrieveSetBuffers();
_ready = true;
}
/// <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>
/// 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);
playerBitmap = this.LoadBitmapFromContentFile("/Assets/Bitmaps/player.png");
terrainBitmap = this.LoadBitmapFromContentFile("/Assets/Bitmaps/terrain.png");
terrainBrush = new BitmapBrush1(d2dContext, terrainBitmap, new BitmapBrushProperties1()
{
ExtendModeX = ExtendMode.Wrap,
ExtendModeY = ExtendMode.Wrap,
});
}
/// <summary>
/// Unbind the render targets
/// </summary>
/// <param name="context"></param>
public void Unbind(DeviceContext1 context)
{
context.OutputMerger.ResetTargets();
}
/// <summary>
/// Clears the render target.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="color">The color.</param>
public void ClearRenderTarget(DeviceContextProxy context, Color4 color)
{
ClearRenderTarget(context, color, true, true);
}
/// <summary>
/// Sets the default render-targets
/// </summary>
public void SetDefaultRenderTargets(DeviceContext context)
{
context.OutputMerger.SetTargets(depthStencilBufferView, colorBufferView);
context.Rasterizer.SetViewport(0, 0, TargetWidth, TargetHeight, 0.0f, 1.0f);
context.Rasterizer.SetScissorRectangle(0, 0, TargetWidth, TargetHeight);
}
/// <summary>
/// Initializes a new deferred context
/// </summary>
/// <param name="device">The device.</param>
public DeviceContextProxy(Device device)
{
deviceContext = Collect(new DeviceContext(device));
this.device = device;
IsDeferred = true;
}
/// <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
});
}
/// <summary>
/// Clears the render target binding.
/// </summary>
/// <param name="context">The context.</param>
public void ClearRenderTargetBinding(DeviceContext context)
{
context.OutputMerger.SetTargets(null, new RenderTargetView[0]);
}
/// <summary>
/// Initializes a new instance of the <see cref="Renderer" /> class.
/// </summary>
/// <param name="gameEngine">The game engine.</param>
/// <param name="form">The form.</param>
/// <param name="width">The primary width of the view in pixels.</param>
/// <param name="height">The primary height of the view in pixels.</param>
public Renderer(IGameEngine gameEngine, GameForm form, int width, int height)
{
if (gameEngine == null)
{
throw new ArgumentNullException(nameof(gameEngine));
}
if (form == null)
{
throw new ArgumentNullException(nameof(form));
}
_form = form;
_resize = false;
_scale = 1.0f;
_width = width;
_height = height;
_dwFactory = new SharpDX.DirectWrite.Factory();
InitFonts();
// 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.
using (var dxgiDevice2 = _device.QueryInterface <SharpDX.DXGI.Device2>())
{
_d2dFactory = new SharpDX.Direct2D1.Factory2(SharpDX.Direct2D1.FactoryType.SingleThreaded);
// Get the default Direct2D device and create a context.
using (var d2dDevice = new SharpDX.Direct2D1.Device1(_d2dFactory, dxgiDevice2))
{
_d2dContext = new SharpDX.Direct2D1.DeviceContext1(d2dDevice, SharpDX.Direct2D1.DeviceContextOptions.None);
}
}
CreateSizeDependentResources();
_d2dContext.TextAntialiasMode = SharpDX.Direct2D1.TextAntialiasMode.Aliased;
_d2dContext.AntialiasMode = AntialiasMode.Aliased;
_d2dContext.UnitMode = UnitMode.Pixels;
_hudYellow = new SolidColorBrush(_d2dContext, new Color4(1.0f, 1.0f, 0.0f, 1.0f));
_hudWhite = new SolidColorBrush(_d2dContext, new Color4(1.0f, 1.0f, 1.0f, 1.0f));
_hudTextFormat = new TextFormat(_dwFactory, "Sonic Genesis/Mega Drive Font", _fontCollection, FontWeight.Normal, FontStyle.Normal, FontStretch.Normal, 14);
// init game stuff
_game = gameEngine;
_texResMan = new TextureResourceManager(gameEngine, _d2dContext);
_spriteResMan = new SpriteResourceManager(gameEngine, _d2dContext);
// get the services
_mapService = _game.GetService <IMapService>();
_varService = _game.GetService <IVariableService>();
_entityService = _game.GetService <IEntityService>();
_renderService = _game.GetService <IRenderService>();
_collisionService = _game.GetService <ICollisionService>();
_varShowCollisionMaps = _varService.GetVar <bool>("r_showcollisionmaps");
_varShowTileFrames = _varService.GetVar <bool>("r_showtileframes");
_varShowEntityOrigins = _varService.GetVar <bool>("r_showentityorigins");
_varShowTraceLines = _varService.GetVar <bool>("r_showtracelines");
_varShowCollisionBoxes = _varService.GetVar <bool>("r_showcollisionboxes");
_rc = new RenderContext();
_spriteRenderList = new List <Animatable>(25);
}
public void Bind(DeviceContext1 context)
{
context.OutputMerger.SetTargets(DSVReadonly, RTV);
}
/// <summary>
/// Creates the render context.
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
protected virtual RenderContext CreateRenderContext(DeviceContext context)
{
return(new RenderContext(this, context));
}
/// <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);
}
public void Initialize(Device1 d3dDevice, DeviceContext1 d3dContext, int capacity = 1024)
{
m_d3dDevice = d3dDevice;
m_d3dContext = d3dContext;
m_capacity = capacity;
var path = Windows.ApplicationModel.Package.Current.InstalledLocation.Path;
var vertexShaderByteCode = NativeFile.ReadAllBytes(path + "\\Assets\\SpriteBatch.vs.cso");
m_vertexShader = new VertexShader(m_d3dDevice, vertexShaderByteCode);
m_pixelShader = new PixelShader(d3dDevice, NativeFile.ReadAllBytes(path + "\\Assets\\SpriteBatch.ps.cso"));
// Layout from VertexShader input signature
m_layout = new InputLayout(d3dDevice, vertexShaderByteCode, new[]
{
new InputElement("POSITION", 0, SharpDX.DXGI.Format.R32G32B32A32_Float,0,0),
new InputElement("TEXCOORD", 0, SharpDX.DXGI.Format.R32G32_Float, 16, 0),
new InputElement("COLOR", 0, SharpDX.DXGI.Format.R32G32B32A32_Float, 24, 0),
});
SamplerStateDescription samplerDesc = SharpDX.Direct3D11.SamplerStateDescription.Default();
m_sampler = new SamplerState(d3dDevice, samplerDesc);
//BlendStateDescription1 blendDesc = new BlendStateDescription1();
//blendDesc.AlphaToCoverageEnable = true; //set to true to get nice blending betweent sprites
//blendDesc.IndependentBlendEnable = false;
//blendDesc.RenderTarget[0].IsBlendEnabled = true;
//blendDesc.RenderTarget[0].IsLogicOperationEnabled = false;
//blendDesc.RenderTarget[0].SourceBlend = BlendOption.SourceColor;
//blendDesc.RenderTarget[0].DestinationBlend = BlendOption.SourceAlphaSaturate;
//blendDesc.RenderTarget[0].BlendOperation = BlendOperation.Add;
//blendDesc.RenderTarget[0].SourceAlphaBlend = BlendOption.One;
//blendDesc.RenderTarget[0].DestinationAlphaBlend = BlendOption.One
//blendDesc.RenderTarget[0].AlphaBlendOperation = BlendOperation.Maximum; // set to maximum to blend 2 sprites nicely over each other
//blendDesc.RenderTarget[0].RenderTargetWriteMask = ColorWriteMaskFlags.All;
//m_blendStateAlpha = new BlendState1(d3dDevice, blendDesc);
var description = BlendStateDescription1.Default();
description.RenderTarget[0].IsBlendEnabled = true;
description.RenderTarget[0].SourceBlend = BlendOption.SourceAlpha;
description.RenderTarget[0].DestinationBlend = BlendOption.One;
description.RenderTarget[0].SourceAlphaBlend = BlendOption.SourceAlpha;
description.RenderTarget[0].DestinationAlphaBlend = BlendOption.One;
description.RenderTarget[0].BlendOperation = BlendOperation.Add;
description.RenderTarget[0].IsLogicOperationEnabled = false;
description.RenderTarget[0].AlphaBlendOperation = BlendOperation.Maximum;
description.RenderTarget[0].RenderTargetWriteMask = ColorWriteMaskFlags.All;
description.AlphaToCoverageEnable = true; //<==RT DOES NOT WORK
description.IndependentBlendEnable = false;
m_blendStateAlpha = new BlendState1(d3dDevice, description);
//[BELOW] Windows RT this does not work
//var description = BlendStateDescription1.Default();
//description.RenderTarget[0].IsBlendEnabled = true;
//description.RenderTarget[0].SourceBlend = BlendOption.SourceColor;
//description.RenderTarget[0].DestinationBlend = BlendOption.SourceAlphaSaturate;
//description.RenderTarget[0].SourceAlphaBlend = BlendOption.One;
//description.RenderTarget[0].DestinationAlphaBlend = BlendOption.One;
//description.RenderTarget[0].BlendOperation = BlendOperation.Add;
//description.RenderTarget[0].IsLogicOperationEnabled = false;
//description.RenderTarget[0].AlphaBlendOperation = BlendOperation.Maximum;
//description.AlphaToCoverageEnable = true;
//description.IndependentBlendEnable = false;
//description.RenderTarget[0].RenderTargetWriteMask = ColorWriteMaskFlags.All;
//m_blendStateAlpha = new BlendState1(d3dDevice, description);
m_constantBufferVS = ToDispose(new SharpDX.Direct3D11.Buffer(d3dDevice, Utilities.SizeOf<Matrix>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
m_constantBufferPS = ToDispose(new SharpDX.Direct3D11.Buffer(d3dDevice, Utilities.SizeOf<Matrix>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
//=======================
// Setup the pipeline
//=======================
m_vertices = ToDispose(BuildVerticesBuffer(d3dDevice, 1.0f, new Vector2(0, 1), new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1)));
m_vertexBufferBinding = new VertexBufferBinding(m_vertices, sizeof(float) * 10, 0);
d3dContext.InputAssembler.SetVertexBuffers(0, m_vertexBufferBinding);
d3dContext.InputAssembler.InputLayout = m_layout;
d3dContext.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.TriangleList;
d3dContext.VertexShader.SetConstantBuffer(0, m_constantBufferVS);
d3dContext.VertexShader.Set(m_vertexShader);
d3dContext.PixelShader.SetConstantBuffer(0, m_constantBufferPS);
d3dContext.PixelShader.SetSampler(0, m_sampler);
d3dContext.PixelShader.Set(m_pixelShader);
d3dContext.OutputMerger.BlendState = m_blendStateAlpha; // m_blendStateAlpha, m_blendStateAdditive;
}
private void RenderParticle(Matrix viewProjection, Vector2 pos, Vector2 size, float opacity, DeviceContext1 d3dContext, ShaderResourceView srv, float rotationVelocity, RectangleF textureRegionToDraw)
{
// update TextureSprite transform
Matrix position = Matrix.Translation(pos.X, -pos.Y, 0); // origin
Matrix scale = Matrix.Scaling(size.X, size.Y, 1); // no scale modifier
//Matrix rotation = Matrix.RotationX(rotationVelocity);
Matrix worldViewProjection = position;
//if (rotationVelocity != 0) worldViewProjection = rotation * position ;
//else worldViewProjection = position;
worldViewProjection = worldViewProjection * scale * viewProjection;
//worldViewProjection = worldViewProjection * viewProjection;
worldViewProjection.Transpose();
// Update VS/GS/PS
d3dContext.PixelShader.SetShaderResource(0, srv);
// Update Constant Buffer
d3dContext.UpdateSubresource(ref worldViewProjection, m_constantBufferVS, 0);
d3dContext.UpdateSubresource(ref opacity, m_constantBufferPS, 0);
if (textureRegionToDraw != RectangleF.Empty) d3dContext.UpdateSubresource<float>(BuildVertices(1.0f, new Vector2(textureRegionToDraw.Left, textureRegionToDraw.Bottom), new Vector2(textureRegionToDraw.Left, textureRegionToDraw.Top), new Vector2(textureRegionToDraw.Right, textureRegionToDraw.Top), new Vector2(textureRegionToDraw.Right, textureRegionToDraw.Bottom)), m_vertices);
// Draw
d3dContext.Draw(12, 0);
//d3dContext.DrawInstanced(12, 1, 0, 0);
//d3dContext.DrawInstanced(12, m_particles.Count, 0, 0);
//d3dContext.DrawInstanced(12, 200, 0, 0);
}
/// <summary>
/// Clears the render target.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="clearBackBuffer">if set to <c>true</c> [clear back buffer].</param>
/// <param name="clearDepthStencilBuffer">if set to <c>true</c> [clear depth stencil buffer].</param>
public void ClearRenderTarget(DeviceContext context, bool clearBackBuffer, bool clearDepthStencilBuffer)
{
renderBuffer?.ClearRenderTarget(context, ClearColor, clearBackBuffer, clearDepthStencilBuffer);
}
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;
}
protected virtual void CreateDeviceResources()
{
var creationFlags = D3D11.DeviceCreationFlags.BgraSupport;
creationFlags |= D3D11.DeviceCreationFlags.Debug;
var device = new D3D11.Device(D3D.DriverType.Hardware, creationFlags,
D3D.FeatureLevel.Level_11_1,
D3D.FeatureLevel.Level_11_0,
D3D.FeatureLevel.Level_10_1,
D3D.FeatureLevel.Level_10_0,
D3D.FeatureLevel.Level_9_3,
D3D.FeatureLevel.Level_9_2,
D3D.FeatureLevel.Level_9_1);
_device = device.QueryInterface<D3D11.Device1>();
_deviceContext = device.ImmediateContext.QueryInterface<D3D11.DeviceContext1>();
}
public void Clear(DeviceContext1 context)
{
context.ClearRenderTargetView(RTV, new Color(0, 0, 0, 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.
// 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,
}
}));
}
/// <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);
}
void InitText(SwapChain3 tempSwapChain)
{
init = true;
device = tempSwapChain.GetDevice <SharpDX.Direct3D11.Device1>();
d3dContext = device.ImmediateContext.QueryInterface <SharpDX.Direct3D11.DeviceContext1>();
var texture2d = tempSwapChain.GetBackBuffer <Texture2D>(0);
SharpDX.DXGI.Device2 dxgiDevice2 = device.QueryInterface <SharpDX.DXGI.Device2>();
SharpDX.DXGI.Adapter dxgiAdapter = dxgiDevice2.Adapter;
SharpDX.DXGI.Factory2 dxgiFactory2 = dxgiAdapter.GetParent <SharpDX.DXGI.Factory2>();
SharpDX.Direct2D1.Device d2dDevice = new SharpDX.Direct2D1.Device(dxgiDevice2);
d2dContext = new SharpDX.Direct2D1.DeviceContext(d2dDevice, SharpDX.Direct2D1.DeviceContextOptions.None);
SharpDX.Direct2D1.BitmapProperties1 properties = new SharpDX.Direct2D1.BitmapProperties1(
new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm,
SharpDX.Direct2D1.AlphaMode.Premultiplied),
96, 96, SharpDX.Direct2D1.BitmapOptions.Target | SharpDX.Direct2D1.BitmapOptions.CannotDraw);
Surface backBuffer = tempSwapChain.GetBackBuffer <Surface>(0);
d2dTarget = new SharpDX.Direct2D1.Bitmap1(d2dContext, new Size2(800, 600), properties);
solidBrush = new SharpDX.Direct2D1.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 SharpDX.Direct2D1.LinearGradientBrush(d2dContext, new SharpDX.Direct2D1.LinearGradientBrushProperties()
{
StartPoint = new Vector2(50, 0),
EndPoint = new Vector2(450, 0),
},
new SharpDX.Direct2D1.GradientStopCollection(d2dContext, new SharpDX.Direct2D1.GradientStop[]
{
new SharpDX.Direct2D1.GradientStop()
{
Color = Color.Blue,
Position = 0,
},
new SharpDX.Direct2D1.GradientStop()
{
Color = Color.Green,
Position = 1,
}
}));
SharpDX.Direct2D1.RadialGradientBrushProperties rgb = new SharpDX.Direct2D1.RadialGradientBrushProperties()
{
Center = new Vector2(250, 525),
RadiusX = 100,
RadiusY = 100,
};
// Create a radial gradient brush.
// The center is specified in absolute coordinates, too.
radialGradientBrush = new SharpDX.Direct2D1.RadialGradientBrush(d2dContext, ref rgb
,
new SharpDX.Direct2D1.GradientStopCollection(d2dContext, new SharpDX.Direct2D1.GradientStop[]
{
new SharpDX.Direct2D1.GradientStop()
{
Color = Color.Yellow,
Position = 0,
},
new SharpDX.Direct2D1.GradientStop()
{
Color = Color.Red,
Position = 1,
}
}));
}
/// <summary>
/// Initializes a new instance of the <see cref="DeviceContextProxy"/> class.
/// </summary>
/// <param name="device">The device.</param>
public DeviceContextProxy(Device device)
{
deviceContext = Collect(new DeviceContext(device));
}
public void Initialise(int width, int height, params SharpDX.Direct3D.FeatureLevel[] featureLevels)
{
// Create device
var dev = new D3D11.Device(SharpDX.Direct3D.DriverType.Hardware, D3D11.DeviceCreationFlags.None,
featureLevels);
_device = ComObject.As<D3D11.Device1>(dev.NativePointer);
_context = _device.ImmediateContext1;
ToolkitDevice = SharpDX.Toolkit.Graphics.GraphicsDevice.New(_device);
InitSwapChain(width, height);
RetrieveSetBuffers();
_ready = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="DeviceContextProxy"/> class.
/// </summary>
/// <param name="context">The context.</param>
public DeviceContextProxy(DeviceContext context)
{
this.deviceContext = context;
}
/// <summary>
/// Muse pass immediate context for this constructor
/// </summary>
/// <param name="context">The context.</param>
/// <param name="device">device</param>
public DeviceContextProxy(DeviceContext context, Device device)
{
deviceContext = context;
this.device = device;
IsDeferred = false;
}
protected void SetContextState(DeviceContext1 context)
{
// Tell the IA what the vertices will look like
context.InputAssembler.InputLayout = vertexLayout;
// Set the vertex shader constant buffers
context.VertexShader.SetConstantBuffer(0, perObjectBuffer);
context.VertexShader.SetConstantBuffer(1, perFrameBuffer);
context.VertexShader.SetConstantBuffer(2, perMaterialBuffer);
context.VertexShader.SetConstantBuffer(3, perArmatureBuffer);
// Set the pixel shader to run
context.VertexShader.Set(vertexShader);
// Set the pixel shader constant buffers
context.PixelShader.SetConstantBuffer(1, perFrameBuffer);
context.PixelShader.SetConstantBuffer(2, perMaterialBuffer);
// Set the pixel shader to run
context.PixelShader.Set(pixelShader);
context.Rasterizer.State = rsCullBack;
// Apply the depth stencil state
context.OutputMerger.DepthStencilState = depthStencilState;
}
/// <summary>
/// Clears the render target binding.
/// </summary>
/// <param name="context">The context.</param>
public void ClearRenderTargetBinding(DeviceContextProxy context)
{
context.ClearRenderTagetBindings();
}
/// <summary>
/// Bind the render targets to the OutputMerger
/// </summary>
/// <param name="context"></param>
public void Bind(DeviceContext1 context)
{
// The empty UnorderedAccessView array is necessary, passing null results in an error
context.OutputMerger.SetTargets(DSV, 0, new UnorderedAccessView [0], RTVs.ToArray());
}
/// <summary>
/// Creates device manager objects
/// </summary>
/// <remarks>
/// This method is called at the initialization of this instance.
/// </remarks>
protected virtual void CreateInstances()
{
// Dispose previous references and set to null
RemoveAndDispose(ref d3dDevice);
RemoveAndDispose(ref d3dContext);
RemoveAndDispose(ref d2dDevice);
RemoveAndDispose(ref d2dContext);
RemoveAndDispose(ref d2dFactory);
RemoveAndDispose(ref dwriteFactory);
RemoveAndDispose(ref wicFactory);
#region Create Direct3D 11.1 device and retrieve device context
// Bgra performs better especially with Direct2D software
// render targets
var creationFlags = DeviceCreationFlags.BgraSupport;
#if DEBUG
// Enable D3D device debug layer
creationFlags |= DeviceCreationFlags.Debug;
#endif
// Retrieve the Direct3D 11.1 device and device context
using (var device = new Device(DriverType.Hardware, creationFlags, Direct3DFeatureLevels))
{
d3dDevice = ToDispose(device.QueryInterface<Device1>());
}
// Get Direct3D 11.1 context
d3dContext = ToDispose(d3dDevice.ImmediateContext.QueryInterface<DeviceContext1>());
#endregion
#region Create Direct2D device and context
#if DEBUG
var debugLevel = SharpDX.Direct2D1.DebugLevel.Information;
#else
var debugLevel = SharpDX.Direct2D1.DebugLevel.None;
#endif
// Allocate new references
d2dFactory = ToDispose(new SharpDX.Direct2D1.Factory1(SharpDX.Direct2D1.FactoryType.SingleThreaded, debugLevel));
dwriteFactory = ToDispose(new SharpDX.DirectWrite.Factory(SharpDX.DirectWrite.FactoryType.Shared));
wicFactory = ToDispose(new SharpDX.WIC.ImagingFactory2());
// Create Direct2D device
using (var dxgiDevice = d3dDevice.QueryInterface<SharpDX.DXGI.Device>())
{
d2dDevice = ToDispose(new SharpDX.Direct2D1.Device(d2dFactory, dxgiDevice));
}
// Create Direct2D context
d2dContext = ToDispose(new SharpDX.Direct2D1.DeviceContext(d2dDevice, SharpDX.Direct2D1.DeviceContextOptions.None));
#endregion
}
/// <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,
}
}));
}
