/// <summary>
/// Pushes a new render target onto the render target stack.
/// </summary>
/// <param name="viewport">The viewport object.</param>
/// <param name="renderTargets">A structure containing all relevant render targets.</param>
/// <param name="camera">The camera for the new render target.</param>
/// <param name="viewInformation">The view information.</param>
/// <exception cref="System.ObjectDisposedException">RenderState</exception>
internal void PushRenderTarget(
RenderTargets renderTargets,
SharpDX.Mathematics.Interop.RawViewportF viewport,
Camera3DBase camera, ViewInformation viewInformation)
{
if (m_disposed)
{
throw new ObjectDisposedException("RenderState");
}
//Build new render stack entry
RenderStackEntry newEntry = new RenderStackEntry();
newEntry.Matrix4Stack = new Matrix4Stack();
newEntry.Camera = camera;
newEntry.RenderTargets = renderTargets;
newEntry.SingleViewport = viewport;
newEntry.ViewInformation = viewInformation;
//Overtake device settings
newEntry.Apply(m_device.DeviceImmediateContextD3D11);
//Push new entry onto the stack
m_renderSettingsStack.Push(m_currentRenderSettings);
m_currentRenderSettings = newEntry;
}
/// <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));
}
/// <summary>
/// Initializes a new instance of the <see cref="RenderTargetTextureResource" /> class.
/// </summary>
/// <param name="creationMode">Tells this object which texture to create.</param>
public RenderTargetTextureResource(RenderTargetCreationMode creationMode)
: base()
{
m_creationMode = creationMode;
m_width = -1;
m_heigth = -1;
m_viewportF = new SharpDX.Mathematics.Interop.RawViewportF();
m_shaderResourceCreated = false;
}
/// <summary>
/// Initializes a new instance of the <see cref="RenderState"/> class.
/// </summary>
internal RenderState(
EngineDevice device,
PerformanceAnalyzer performanceCalculator,
RenderTargets renderTargets,
SharpDX.Mathematics.Interop.RawViewportF viewport,
Camera3DBase camera, ViewInformation viewInformation)
: this(device, performanceCalculator)
{
Reset(renderTargets, viewport, camera, viewInformation);
}
public void SetViewPort(Rectanglef viewPort)
{
//set view port
var viewPortF = new SharpDX.Mathematics.Interop.RawViewportF()
{
X = viewPort.Left,
Y = viewPort.Top,
Width = viewPort.Right - viewPort.Left,
Height = viewPort.Bottom - viewPort.Top,
MinDepth = 0.0f,
MaxDepth = 1.0f
};
ImmediateContext.Rasterizer.SetViewport(viewPortF);
}
public void SetViewPort(float Width, float Height, float X, float Y, float MinDepth = 0.0f, float MaxDepth = 1.0f)
{
var viewPortF = new SharpDX.Mathematics.Interop.RawViewportF()
{
Width = Width,
Height = Height,
X = X,
Y = Y,
MinDepth = MinDepth,
MaxDepth = MaxDepth
};
//set view port
NativeDeviceContext.Rasterizer.SetViewport(viewPortF);
}
/// <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 engineDevice)
{
// Calculate pixel with and high of this visual
Size pixelSize = this.GetPixelSize(new Size(100.0, 100.0));
int width = (int)pixelSize.Width;
int height = (int)pixelSize.Height;
//Get references to current render device
D3D11.Device renderDevice = engineDevice.DeviceD3D11_1;
D3D11.DeviceContext renderDeviceContext = renderDevice.ImmediateContext;
//Create the swap chain and the render target
m_backBufferD3D11 = GraphicsHelper.CreateRenderTargetTexture(engineDevice, width, height, m_renderLoop.ViewConfiguration);
m_backBufferForWpf = GraphicsHelper.CreateSharedTexture(engineDevice, width, height);
m_renderTarget = new D3D11.RenderTargetView(renderDevice, m_backBufferD3D11);
//Create the depth buffer
m_depthBuffer = GraphicsHelper.CreateDepthBufferTexture(engineDevice, width, height, m_renderLoop.ViewConfiguration);
m_renderTargetDepth = new D3D11.DepthStencilView(renderDevice, m_depthBuffer);
//Apply render target size values
m_renderTargetWidth = width;
m_renderTargetHeight = height;
//Define the viewport for rendering
SharpDX.Mathematics.Interop.RawViewportF viewPort = GraphicsHelper.CreateDefaultViewport(width, height);
//Apply new width and height values of the viewport
m_viewportWidth = width;
m_viewportHeight = height;
//Create and apply the image source object
m_d3dImageSource = new HigherD3DImageSource(engineDevice);
m_d3dImageSource.SetRenderTarget(m_backBufferForWpf);
if (this.Source == m_dummyBitmap)
{
this.Source = m_d3dImageSource;
}
m_lastRecreateWidth = width;
m_lastRecreateHeight = height;
//Return all generated objects
return(Tuple.Create(m_backBufferD3D11, m_renderTarget, m_depthBuffer, m_renderTargetDepth, viewPort, new Size2(width, height), GetDpiScaling()));
}
/// <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>
/// Create all view resources.
/// </summary>
Tuple <D3D11.Texture2D, D3D11.RenderTargetView, D3D11.Texture2D, D3D11.DepthStencilView, SharpDX.Mathematics.Interop.RawViewportF, 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_1, m_backBufferMultisampled);
backBufferForRenderloop = m_backBufferMultisampled;
}
else
{
m_renderTargetView = new D3D11.RenderTargetView(engineDevice.DeviceD3D11_1, 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_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);
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));
}
public void Initialize(IntPtr windowHandle, int width, int height)
{
var desc = new SwapChainDescription()
{
BufferCount = 1,
ModeDescription = new ModeDescription(width, height,
new Rational(60, 1), Format.B8G8R8A8_UNorm),
IsWindowed = true,
OutputHandle = windowHandle,
SampleDescription = new SampleDescription(1, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput,
};
_viewPort = new SharpDX.Mathematics.Interop.RawViewportF
{
X = 0,
Y = 0,
Width = width,
Height = height,
};
SharpDX.Direct3D11.Device.CreateWithSwapChain(SharpDX.Direct3D.DriverType.Hardware,
SharpDX.Direct3D11.DeviceCreationFlags.BgraSupport,
new[] { SharpDX.Direct3D.FeatureLevel.Level_10_0 }, desc, out _drawDevice, out _swapChain);
_backBuffer = Texture2D.FromSwapChain <Texture2D>(_swapChain, 0);
_backBufferView = new RenderTargetView(_drawDevice, _backBuffer);
using (SharpDX.Direct2D1.Factory factory = new SharpDX.Direct2D1.Factory())
using (var surface = _backBuffer.QueryInterface <Surface>())
{
_renderTarget2D = new RenderTarget(factory, surface,
new RenderTargetProperties(new SharpDX.Direct2D1.PixelFormat(Format.Unknown, SharpDX.Direct2D1.AlphaMode.Premultiplied)))
{
AntialiasMode = AntialiasMode.PerPrimitive,
};
}
}
/// <summary>
/// Resets the render state.
/// </summary>
/// <param name="viewport">The viewport.</param>
/// <param name="camera">The camera for the new render target.</param>
/// <param name="viewInformation">The view information.</param>
/// <param name="renderTargets">The render targets used for rendering.</param>
internal void Reset(
RenderTargets renderTargets,
SharpDX.Mathematics.Interop.RawViewportF viewport,
Camera3DBase camera, ViewInformation viewInformation)
{
m_renderSettingsStack.Clear();
m_sceneStack.Clear();
m_currentScene = null;
m_world = new Matrix4Stack(Matrix4x4.Identity);
//Inititialize current render properties
m_currentRenderSettings = new RenderStackEntry();
m_currentRenderSettings.Matrix4Stack = new Matrix4Stack();
m_currentRenderSettings.RenderTargets = renderTargets;
m_currentRenderSettings.SingleViewport = viewport;
m_currentRenderSettings.Camera = camera;
m_currentRenderSettings.ViewInformation = viewInformation;
//Apply initial render properties
m_currentRenderSettings.Apply(m_device.DeviceImmediateContextD3D11);
}
/// <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 = m_pixelWidth;
int height = m_pixelHeight;
//Get references to current render device
m_device = device.DeviceD3D11_1;
m_deviceContext = m_device.ImmediateContext;
//Create the swap chain and the render target
m_renderTarget = GraphicsHelper.CreateRenderTargetTexture(device, width, height, m_renderLoop.ViewConfiguration);
m_renderTargetView = new D3D11.RenderTargetView(m_device, m_renderTarget);
//Create the depth buffer
m_renderTargetDepth = GraphicsHelper.CreateDepthBufferTexture(device, width, height, m_renderLoop.ViewConfiguration);
m_renderTargetDepthView = new D3D11.DepthStencilView(m_device, m_renderTargetDepth);
//Define the viewport for rendering
SharpDX.Mathematics.Interop.RawViewportF viewPort = GraphicsHelper.CreateDefaultViewport(width, height);
//Return all generated objects
return(Tuple.Create(m_renderTarget, m_renderTargetView, m_renderTargetDepth, m_renderTargetDepthView, viewPort, new Size2(width, height), DpiScaling.Default));
}
/// <unmanaged>void ID3D12CommandList::RSSetViewports([In] unsigned int Count,[In, Buffer] const D3D11_VIEWPORT* pViewports)</unmanaged>
/// <unmanaged-short>ID3D12CommandList::RSSetViewports</unmanaged-short>
public unsafe void SetViewport(SharpDX.Mathematics.Interop.RawViewportF viewport)
{
SetViewports(1, new IntPtr(&viewport));
}
/// <summary>
/// Applies the given size.
/// </summary>
/// <param name="renderState">The render state used for creating all resources.</param>
public void ApplySize(RenderState renderState)
{
ViewInformation viewInfo = renderState.ViewInformation;
GraphicsViewConfiguration viewConfig = viewInfo.ViewConfiguration;
// Get current view size and antialiasing settings
Size2 currentViewSize = viewInfo.CurrentViewSize;
bool currentAntialiasingEnabled = viewConfig.AntialiasingEnabled;
AntialiasingQualityLevel currentAntialiasingQuality = viewConfig.AntialiasingQuality;
if ((m_width != currentViewSize.Width) ||
(m_heigth != currentViewSize.Height) ||
(m_antialiasingEnabled != currentAntialiasingEnabled) ||
(m_antialiasingQuality != currentAntialiasingQuality))
{
// Dispose color-buffer resources
GraphicsHelper.SafeDispose(ref m_colorBuffer);
GraphicsHelper.SafeDispose(ref m_colorBufferRenderTargetView);
GraphicsHelper.SafeDispose(ref m_colorBufferShaderResourceView);
if (m_shaderResourceCreated)
{
GraphicsHelper.SafeDispose(ref m_colorBufferShaderResource);
}
// Dispose depth-buffer resources
GraphicsHelper.SafeDispose(ref m_depthBufferView);
GraphicsHelper.SafeDispose(ref m_depthBuffer);
// Dispose object-id buffer
GraphicsHelper.SafeDispose(ref m_objectIDBufferRenderTargetView);
GraphicsHelper.SafeDispose(ref m_objectIDBuffer);
// Dispose normal-depth resources
GraphicsHelper.SafeDispose(ref m_normalDepthBuffer);
GraphicsHelper.SafeDispose(ref m_normalDepthBufferRenderTargetView);
GraphicsHelper.SafeDispose(ref m_normalDepthBufferShaderResourceView);
if (m_shaderResourceCreated)
{
GraphicsHelper.SafeDispose(ref m_normalDepthBufferShaderResource);
}
// Create color-buffer resources
if (m_creationMode.HasFlag(RenderTargetCreationMode.Color))
{
m_colorBuffer = GraphicsHelper.CreateRenderTargetTexture(
renderState.Device, currentViewSize.Width, currentViewSize.Height, renderState.ViewInformation.ViewConfiguration);
m_colorBufferShaderResource = m_colorBuffer;
if (renderState.ViewInformation.ViewConfiguration.AntialiasingEnabled)
{
m_colorBufferShaderResource = GraphicsHelper.CreateTexture(renderState.Device, currentViewSize.Width, currentViewSize.Height);
m_shaderResourceCreated = true;
}
else
{
m_shaderResourceCreated = false;
}
m_colorBufferRenderTargetView = new D3D11.RenderTargetView(renderState.Device.DeviceD3D11_1, m_colorBuffer);
m_colorBufferShaderResourceView = new D3D11.ShaderResourceView(renderState.Device.DeviceD3D11_1, m_colorBufferShaderResource);
}
// Create depth-buffer resources
if (m_creationMode.HasFlag(RenderTargetCreationMode.Depth))
{
m_depthBuffer = GraphicsHelper.CreateDepthBufferTexture(
renderState.Device, currentViewSize.Width, currentViewSize.Height, renderState.ViewInformation.ViewConfiguration);
m_depthBufferView = GraphicsHelper.CreateDepthBufferView(renderState.Device, m_depthBuffer);
}
// Create object-id resources
if (m_creationMode.HasFlag(RenderTargetCreationMode.ObjectID))
{
m_objectIDBuffer = GraphicsHelper.CreateRenderTargetTextureObjectIDs(
renderState.Device, currentViewSize.Width, currentViewSize.Height, renderState.ViewInformation.ViewConfiguration);
m_objectIDBufferRenderTargetView = new D3D11.RenderTargetView(renderState.Device.DeviceD3D11_1, m_objectIDBuffer);
}
// Create normal-depth buffer resources
if (m_creationMode.HasFlag(RenderTargetCreationMode.NormalDepth))
{
m_normalDepthBuffer = GraphicsHelper.CreateRenderTargetTextureNormalDepth(
renderState.Device, currentViewSize.Width, currentViewSize.Height, renderState.ViewInformation.ViewConfiguration);
m_normalDepthBufferShaderResource = m_normalDepthBuffer;
if (m_shaderResourceCreated)
{
m_normalDepthBufferShaderResource = GraphicsHelper.CreateTexture(
renderState.Device, currentViewSize.Width, currentViewSize.Height, GraphicsHelper.DEFAULT_TEXTURE_FORMAT_NORMAL_DEPTH);
}
m_normalDepthBufferRenderTargetView = new D3D11.RenderTargetView(renderState.Device.DeviceD3D11_1, m_normalDepthBuffer);
m_normalDepthBufferShaderResourceView = new D3D11.ShaderResourceView(renderState.Device.DeviceD3D11_1, m_normalDepthBufferShaderResource);
}
// Remember values
m_width = currentViewSize.Width;
m_heigth = currentViewSize.Height;
m_antialiasingEnabled = currentAntialiasingEnabled;
m_antialiasingQuality = currentAntialiasingQuality;
m_viewportF = renderState.Viewport;
}
}
