/// <summary>
/// Initializes a new instance of the <see cref="SeeingSharpCoreWindowPainter"/> class.
/// </summary>
/// <param name="targetWindow">The target window.</param>
public SeeingSharpCoreWindowPainter(CoreWindow targetWindow)
{
// Attach to SizeChanged event (refresh view resources only after a specific time)
m_targetWindow = targetWindow;
m_targetWindow.SizeChanged += OnTargetWindow_SizeChanged;
m_observerSizeChanged = Observable.FromEventPattern <WindowSizeChangedEventArgs>(m_targetWindow, "SizeChanged")
.Throttle(TimeSpan.FromSeconds(0.5))
.ObserveOn(SynchronizationContext.Current)
.Subscribe((eArgs) => OnTargetWindow_ThrottledSizeChanged(eArgs.Sender as CoreWindow, eArgs.EventArgs));
// Attach to display setting changes
m_displayInfo = DisplayInformation.GetForCurrentView();
m_displayInfo.DpiChanged += OnDisplayInfo_DpiChanged;
m_displayInfo.OrientationChanged += OnDisplayInfo_OrientationChanged;
// Store current dpi setting
m_dpiScaling = new DpiScaling(m_displayInfo.LogicalDpi, m_displayInfo.LogicalDpi);
// Create the RenderLoop object
GraphicsCore.Touch();
m_renderLoop = new Core.RenderLoop(SynchronizationContext.Current, this);
m_renderLoop.ClearColor = Color4.CornflowerBlue;
m_renderLoop.CallPresentInUIThread = true;
m_lastRefreshTargetSize = new Size(0.0, 0.0);
UpdateRenderLoopViewSize();
m_renderLoop.RegisterRenderLoop();
}
private void OnDisplayInfo_DpiChanged(DisplayInformation sender, object args)
{
if (m_isDisposed)
{
return;
}
m_dpiScaling = new DpiScaling(m_displayInfo.LogicalDpi, m_displayInfo.LogicalDpi);
this.UpdateRenderLoopViewSize();
}
public static void InitializeBaseSystems()
{
Settings.Load();
PlatformUtils.Initialize();
DpiScaling.Initialize();
Theme.Initialize();
NesApu.Initialize();
#if FAMISTUDIO_WINDOWS
WinUtils.Initialize();
PerformanceCounter.Initialize();
#endif
}
void onResized(CSize newSize, double dpi)
{
dpiScaling = new DpiScaling(dpi);
viewportSize = new Vector2((float)(newSize.cx / dpi), (float)(newSize.cy / dpi));
rootTransform.M11 = (float)(2.0 / viewportSize.X);
rootTransform.M22 = (float)(-2.0 / viewportSize.Y);
foreach (var sub in resized)
{
sub(viewportSize, dpi);
}
swapChain?.destroyTargets();
}
public void ScaleSizeFFromPixelToDpi()
{
// Arrange
var dpiScaling = DpiScaling.GetByScaleFactors(1.5f, 1.5f);
var dpiScalingProvider = A.Fake <IDpiScalingProvider>();
A.CallTo(() => dpiScalingProvider.GetCurrentDpiScaling()).Returns(dpiScaling);
// Act
var sizePixel = new SizeF(750f, 1500f);
var sizeDpi = dpiScalingProvider.TransformSizeFromPixelToDip(sizePixel);
// Assert
Assert.AreEqual(500f, sizeDpi.Width);
Assert.AreEqual(1000f, sizeDpi.Height);
}
public void ScalePointFromDpiToPixel()
{
// Arrange
var dpiScaling = DpiScaling.GetByScaleFactors(1.5f, 1.5f);
var dpiScalingProvider = A.Fake <IDpiScalingProvider>();
A.CallTo(() => dpiScalingProvider.GetCurrentDpiScaling()).Returns(dpiScaling);
// Act
var pointDpi = new Point(500, 1000);
var pointPixel = dpiScalingProvider.TransformPointFromDipToPixel(pointDpi);
// Assert
Assert.AreEqual(750, pointPixel.X);
Assert.AreEqual(1500, pointPixel.Y);
}
public void ScaleSizeFromDpiToPixel()
{
// Arrange
var dpiScaling = DpiScaling.GetByScaleFactors(1.5f, 1.5f);
var dpiScalingProvider = A.Fake <IDpiScalingProvider>();
A.CallTo(() => dpiScalingProvider.GetCurrentDpiScaling()).Returns(dpiScaling);
// Act
var sizeDpi = new Size(500, 1000);
var sizePixel = dpiScalingProvider.TransformSizeFromDipToPixel(sizeDpi);
// Assert
Assert.AreEqual(750, sizePixel.Width);
Assert.AreEqual(1500, sizePixel.Height);
}
public void ScalePointFFromPixelToDpi()
{
// Arrange
var dpiScaling = DpiScaling.GetByScaleFactors(1.5f, 1.5f);
var dpiScalingProvider = A.Fake <IDpiScalingProvider>();
A.CallTo(() => dpiScalingProvider.GetCurrentDpiScaling()).Returns(dpiScaling);
// Act
var pointPixel = new PointF(750f, 1500f);
var pointDpi = dpiScalingProvider.TransformPointFromPixelToDip(pointPixel);
// Assert
Assert.AreEqual(500f, pointDpi.X);
Assert.AreEqual(1000f, pointDpi.Y);
}
/// <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>
/// Gets the current DpiScaling mode.
/// </summary>
public DpiScaling GetDpiScaling()
{
PresentationSource source = PresentationSource.FromVisual(this);
double dpiScaleFactorX = 1.0;
double dpiScaleFactorY = 1.0;
if (source != null)
{
dpiScaleFactorX = source.CompositionTarget.TransformToDevice.M11;
dpiScaleFactorY = source.CompositionTarget.TransformToDevice.M22;
}
DpiScaling result = DpiScaling.Default;
result.DpiX = (float)(result.DpiX * dpiScaleFactorX);
result.DpiY = (float)(result.DpiY * dpiScaleFactorY);
return(result);
}
/// <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));
}
