/// <summary>
/// Creates all resources
/// </summary>
private void CreateResources(int viewWidth, int viewHeight, DpiScaling dpiScaling, bool forceInit)
{
// Calculate the screen size in device independent units
Size2F scaledScreenSize = new Size2F(
(float)viewWidth / dpiScaling.ScaleFactorX,
(float)viewHeight / dpiScaling.ScaleFactorY);
// Cancel here if the device does not support 2D rendering
if ((!forceInit) &&
(!m_device.Supports2D))
{
return;
}
if (!m_device.IsUsingFallbackMethodFor2D)
{
// Create the render target
using (DXGI.Surface dxgiSurface = m_renderTarget3D.QueryInterface <DXGI.Surface>())
{
D2D.BitmapProperties1 bitmapProperties = new D2D.BitmapProperties1();
bitmapProperties.DpiX = dpiScaling.DpiX;
bitmapProperties.DpiY = dpiScaling.DpiY;
bitmapProperties.BitmapOptions = D2D.BitmapOptions.Target | D2D.BitmapOptions.CannotDraw;
bitmapProperties.PixelFormat = new D2D.PixelFormat(GraphicsHelper.DEFAULT_TEXTURE_FORMAT, D2D.AlphaMode.Premultiplied);
m_renderTargetBitmap = new SharpDX.Direct2D1.Bitmap1(m_device.DeviceContextD2D, dxgiSurface, bitmapProperties);
m_renderTarget2D = m_device.DeviceContextD2D;
m_graphics2D = new Graphics2D(m_device, m_device.DeviceContextD2D, scaledScreenSize);
}
}
else
{
using (DXGI.Surface dxgiSurface = m_renderTarget3D.QueryInterface <DXGI.Surface>())
{
m_renderTarget2D = new D2D.RenderTarget(
m_device.Core.FactoryD2D,
dxgiSurface,
new D2D.RenderTargetProperties()
{
MinLevel = D2D.FeatureLevel.Level_10,
Type = D2D.RenderTargetType.Default,
Usage = D2D.RenderTargetUsage.ForceBitmapRemoting,
PixelFormat = new D2D.PixelFormat(GraphicsHelper.DEFAULT_TEXTURE_FORMAT, D2D.AlphaMode.Premultiplied),
DpiX = dpiScaling.DpiX,
DpiY = dpiScaling.DpiY
});
m_graphics2D = new Graphics2D(m_device, m_renderTarget2D, scaledScreenSize);
return;
}
}
}
private void InitializeBackBuffer(D2D.DeviceContext deviceContext, SharpDX.Size2F size)
{
this.backBitmap?.Dispose();
Size2 pixelSize = Helpers.GetPixelSize(size, this.Factory.DesktopDpi);
var p = new D2D.BitmapProperties1(
new D2D.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, D2D.AlphaMode.Premultiplied),
this.Factory.DesktopDpi.Width,
this.Factory.DesktopDpi.Height,
D2D.BitmapOptions.Target);
var desc = new D3D11.Texture2DDescription()
{
ArraySize = 1,
BindFlags = D3D11.BindFlags.RenderTarget | D3D11.BindFlags.ShaderResource,
CpuAccessFlags = D3D11.CpuAccessFlags.None,
Format = DXGI.Format.B8G8R8A8_UNorm,
MipLevels = 1,
OptionFlags = D3D11.ResourceOptionFlags.Shared,
Usage = D3D11.ResourceUsage.Default,
SampleDescription = new DXGI.SampleDescription(1, 0),
Width = pixelSize.Width,
Height = pixelSize.Height,
};
using (var buffer = new D3D11.Texture2D(this.Device, desc))
using (var surface = buffer.QueryInterface <DXGI.Surface>())
{
this.backBitmap = new D2D.Bitmap1(this.DeviceContext, surface, p);
}
this.DeviceContext.Target = this.backBitmap;
}
public virtual void OnRender()
{
lock (lockObject)
{
if (isVideoStopped)
{
return;
}
if (mediaEngineEx != null)
{
long pts;
if (mediaEngineEx.OnVideoStreamTick(out pts))
{
if (OutputVideoTexture != null)
{
var desc = OutputVideoTexture.Description;
var dxgiSurface = OutputVideoTexture.QueryInterface <SharpDX.DXGI.Surface>();
var region = new SharpDX.Mathematics.Interop.RawRectangle(0, 0, desc.Width, desc.Height);
try
{
// Blit the frame to the supplied rendertarget
mediaEngineEx.TransferVideoFrame(dxgiSurface, null, region, null);
}
catch (Exception)
{
// This exception can be worked around by using DirectX 9 only (see configuration)
Debug.WriteLine("Exception during TransferVideoFrame");
}
}
}
}
}
}
private IntPtr GetSharedHandle(D3D11.Texture2D texture)
{
using (var resource = texture.QueryInterface <DXGI.Resource>())
{
return(resource.SharedHandle);
}
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Получение указателя общего ресурса с текстуры Direct3D11
/// </summary>
/// <param name="texture">Текстура Direct3D11</param>
/// <returns>Указатель на ресурс</returns>
//---------------------------------------------------------------------------------------------------------
public static IntPtr GetSharedHandle(Direct3D11.Texture2D texture)
{
var resource = texture.QueryInterface <DXGI.Resource>();
var result = resource.SharedHandle;
resource.Dispose();
return(result);
}
/// <summary>
/// Получает карту битов из текстуры.
/// </summary>
/// <param name="texture">Текстура с данными</param>
/// <param name="renderTarger">Рендер таргет который будет рисовать нашу битмапу</param>
/// <returns></returns>
public static SharpDX.Direct2D1.Bitmap GetBitmapFromTexture2D(SharpDX.Direct3D11.Texture2D texture, RenderTarget renderTarger)
{
using (var surface = texture.QueryInterface <Surface>())
{
var bitmap = new SharpDX.Direct2D1.Bitmap(renderTarger, surface, new SharpDX.Direct2D1.BitmapProperties(new SharpDX.Direct2D1.PixelFormat(
Format.R8G8B8A8_UNorm,
SharpDX.Direct2D1.AlphaMode.Premultiplied)));
return(bitmap);
}
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Создание текстуры Direct3D11 для ренденинга
/// </summary>
//---------------------------------------------------------------------------------------------------------
private void CreateAndBindTargets()
{
mD3DSurface.SetRenderTarget(null);
XDisposer.SafeDispose(ref mD2DRenderTarget);
XDisposer.SafeDispose(ref mD3DRenderTarget);
XDisposer.SafeDispose(ref XDirect2DManager.mD2DDevice);
XDisposer.SafeDispose(ref XDirect2DManager.mD2DFactory);
XDisposer.SafeDispose(ref XDirect2DManager.mD2DWriteFactory);
XDisposer.SafeDispose(ref XDirect2DManager.mD2DImagingFactory);
var width = (Int32)Math.Max(ActualWidth, mWidthRenderTargetDip);
var height = (Int32)Math.Max(ActualHeight, mHeightRenderTargetDip);
var colordesc = new Direct3D11.Texture2DDescription
{
BindFlags = Direct3D11.BindFlags.RenderTarget | Direct3D11.BindFlags.ShaderResource,
Format = DXGI.Format.B8G8R8A8_UNorm,
Width = width,
Height = height,
MipLevels = 1,
SampleDescription = new DXGI.SampleDescription(1, 0),
Usage = Direct3D11.ResourceUsage.Default,
OptionFlags = Direct3D11.ResourceOptionFlags.Shared,
CpuAccessFlags = Direct3D11.CpuAccessFlags.None,
ArraySize = 1
};
// Создаем текстуру Direct3D11
mD3DRenderTarget = new Direct3D11.Texture2D(mD3DDevice, colordesc);
var surface = mD3DRenderTarget.QueryInterface <DXGI.Surface>();
// Фабрика ресурсов DirectD2
XDirect2DManager.mD2DFactory = new Direct2D.Factory();
//XNativeD2DFactory.mD2DDevice = new Direct2D.Device(XNativeD2DFactory.mD2DFactory, XNativeD2DFactory.mDXGIDevice);
XDirect2DManager.mD2DWriteFactory = new DirectWrite.Factory(DirectWrite.FactoryType.Shared);
XDirect2DManager.mD2DImagingFactory = new ImagingFactory();
// Создаем поверхность отображения DirectD2
var render_target_properties = new Direct2D.RenderTargetProperties(new Direct2D.PixelFormat(DXGI.Format.Unknown, Direct2D.AlphaMode.Premultiplied));
render_target_properties.Type = Direct2D.RenderTargetType.Default;
render_target_properties.Usage = Direct2D.RenderTargetUsage.None;
mD2DRenderTarget = new Direct2D.RenderTarget(XDirect2DManager.mD2DFactory, surface, render_target_properties);
mD3DSurface.SetRenderTarget(mD3DRenderTarget);
// Определяем область отображения
mD3DDevice.ImmediateContext.Rasterizer.SetViewport(0, 0, width, height, 0.0f, 1.0f);
// Сохраняем
XDirect2DManager.mD2DRenderTarget = mD2DRenderTarget;
}
private void InitializeDevices()
{
try
{
SwapChainDescription = new DXGI.SwapChainDescription();
SwapChainDescription.BufferCount = 2;
SwapChainDescription.SampleDescription = new DXGI.SampleDescription(1, 0);
SwapChainDescription.SwapEffect = DXGI.SwapEffect.Discard;
SwapChainDescription.Usage = DXGI.Usage.BackBuffer | DXGI.Usage.RenderTargetOutput;
SwapChainDescription.IsWindowed = true;
SwapChainDescription.ModeDescription = new DXGI.ModeDescription(GameWindow.Current.WindowParameters.Width, GameWindow.Current.WindowParameters.Height, new DXGI.Rational(60, 1), DXGI.Format.B8G8R8A8_UNorm);
SwapChainDescription.OutputHandle = GameWindowHandle;
D3D11.Device.CreateWithSwapChain(DriverType.Hardware, D3D11.DeviceCreationFlags.BgraSupport, featureLevels, SwapChainDescription, out D3DDefaultDevice, out SwapChain);
DXGI.Factory factory = SwapChain.GetParent <DXGI.Factory>();
factory.MakeWindowAssociation(GameWindowHandle, DXGI.WindowAssociationFlags.IgnoreAll);
D3DDevice = D3DDefaultDevice.QueryInterface <D3D11.Device1>();
Backbuffer = D3D11.Texture2D.FromSwapChain <D3D11.Texture2D>(SwapChain, 0);
RenderTargetView = new D3D11.RenderTargetView(D3DDevice, Backbuffer);
D3DDevice.ImmediateContext.Rasterizer.SetViewport(0, 0, GameWindow.Current.WindowParameters.Width, GameWindow.Current.WindowParameters.Height);
D3DDevice.ImmediateContext.OutputMerger.SetTargets(RenderTargetView);
DXGIDevice = D3DDevice.QueryInterface <DXGI.Device>();
D2DFactory = new D2D1.Factory1(D2D1.FactoryType.MultiThreaded);
D2DDevice = new D2D1.Device(D2DFactory, DXGIDevice);
D2DDeviceContext = new D2D1.DeviceContext(D2DDevice, D2D1.DeviceContextOptions.None);
RenderTargetSurface = Backbuffer.QueryInterface <DXGI.Surface>();
RenderTarget = new D2D1.RenderTarget(D2DFactory, RenderTargetSurface, new D2D1.RenderTargetProperties(new D2D1.PixelFormat(DXGI.Format.Unknown, D2D1.AlphaMode.Premultiplied)));
RenderTarget.AntialiasMode = D2D1.AntialiasMode.PerPrimitive;
// Initialize debug drawings brushes
DrawingBoundsBrush = new D2D1.SolidColorBrush(RenderTarget, new SharpDX.Color(1f, 1f, 0f));
CollisionBoxesBrush = new D2D1.SolidColorBrush(RenderTarget, new SharpDX.Color(1f, 0f, 0f));
RenderFrame = new RenderFrame(RenderTarget);
Clock = Stopwatch.StartNew();
}
catch (Exception ex)
{
throw new DeviceInitializationException("Unable to initialize DirectX device!", ex);
}
}
public SharpDXDevice(Window window)
{
this.window = window;
width = (int)window.ViewportSize.Width;
height = (int)window.ViewportSize.Height;
DxDevice.CreateWithSwapChain(DriverType.Hardware,
#if DEBUG
DeviceCreationFlags.Debug |
#endif
DeviceCreationFlags.BgraSupport,
CreateSwapChainDescription(), out device, out swapChain);
direct2DFactory = new D2dFactory();
backBuffer = Resource.FromSwapChain<Texture2D>(swapChain, 0);
surface = backBuffer.QueryInterface<Surface>();
RenderTarget = new RenderTarget(direct2DFactory, surface, defaultRenderTargetProperties);
window.ViewportSizeChanged += ResetDeviceToNewViewportSize;
Screen = new ScreenSpace(window.ViewportSize);
}
private void createSwapChain()
{
lock (deviceManager.DeviceLock)
{
var factory = new DXGI.Factory();
var description = new DXGI.SwapChainDescription()
{
BufferCount = 1,
ModeDescription =
new DXGI.ModeDescription(
control.ClientSize.Width,
control.ClientSize.Height,
new DXGI.Rational(60, 1),
DXGI.Format.R8G8B8A8_UNorm),
IsWindowed = true,
SampleDescription = new DXGI.SampleDescription(1, 0),
SwapEffect = DXGI.SwapEffect.Discard,
Usage = DXGI.Usage.RenderTargetOutput,
OutputHandle = control.Handle
};
swapChain = new DXGI.SwapChain(factory, deviceContext.Device, description);
backbuffer = D3D11.Texture2D.FromSwapChain <D3D11.Texture2D>(swapChain, 0);
backbufferView = new D3D11.RenderTargetView(deviceContext.Device, backbuffer);
}
var d2dFactory = deviceManager.Direct2dFactory;
var surface = backbuffer.QueryInterface <DXGI.Surface>();
renderTarget = new D2D.RenderTarget(
d2dFactory,
surface,
new D2D.RenderTargetProperties(
new D2D.PixelFormat(
DXGI.Format.Unknown,
D2D.AlphaMode.Premultiplied)));
renderTarget.AntialiasMode = D2D.AntialiasMode.Aliased;
createViewport();
}
internal static IDirect3DSurface CreateDirect3DSurfaceFromSharpDXTexture(SharpDX.Direct3D11.Texture2D texture)
{
IDirect3DSurface surface = null;
// Acquire the DXGI interface for the Direct3D surface.
using (var dxgiSurface = texture.QueryInterface <SharpDX.DXGI.Surface>())
{
// Wrap the native device using a WinRT interop object.
uint hr = CreateDirect3D11SurfaceFromDXGISurface(dxgiSurface.NativePointer, out IntPtr pUnknown);
if (hr == 0)
{
surface = Marshal.GetObjectForIUnknown(pUnknown) as IDirect3DSurface;
Marshal.Release(pUnknown);
}
}
return(surface);
}
private void CreateAndBindTargets()
{
var width = Math.Max((int)ActualWidth, 100);
var height = Math.Max((int)ActualHeight, 100);
var renderDesc = new D3D11.Texture2DDescription
{
BindFlags = D3D11.BindFlags.RenderTarget | D3D11.BindFlags.ShaderResource,
Format = DXGI.Format.B8G8R8A8_UNorm,
Width = width,
Height = height,
MipLevels = 1,
SampleDescription = new DXGI.SampleDescription(1, 0),
Usage = D3D11.ResourceUsage.Default,
OptionFlags = D3D11.ResourceOptionFlags.Shared,
CpuAccessFlags = D3D11.CpuAccessFlags.None,
ArraySize = 1
};
var device = new D3D11.Device(DriverType.Hardware, D3D11.DeviceCreationFlags.BgraSupport);
var renderTarget = new D3D11.Texture2D(device, renderDesc);
var surface = renderTarget.QueryInterface <DXGI.Surface>();
var d2DFactory = new D2D.Factory();
var renderTargetProperties =
new D2D.RenderTargetProperties(new D2D.PixelFormat(DXGI.Format.Unknown, D2D.AlphaMode.Premultiplied));
_d2DRenderTarget = new D2D.RenderTarget(d2DFactory, surface, renderTargetProperties);
SetRenderTarget(renderTarget);
device.ImmediateContext.Rasterizer.SetViewport(0, 0, (int)ActualWidth, (int)ActualHeight);
CompositionTarget.Rendering += CompositionTarget_Rendering;
}
public D2D1.RenderTarget Create(D2D1.Factory factory, GDI.Graphics g, Map map)
{
//Monitor.Enter(_syncRoot);
// Dispose the _renderTexture if it is instantiated and not of the required size
CheckTexture(ref _renderTexture, map.Size);
// Create a new render texture if one is needed
if (_renderTexture == null)
{
_renderTexture = CreateRenderTargetTexture(_d3d11Device, map.Size.Width, map.Size.Height);
}
// Get the surface
var surface = _renderTexture.QueryInterface <DXGI.Surface>();
var res = new D2D1.RenderTarget(factory, surface, new D2D1.RenderTargetProperties(
D2D1.RenderTargetType.Hardware, new D2D1.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, D2D1.AlphaMode.Premultiplied),
g.DpiX, g.DpiY, D2D1.RenderTargetUsage.None, D2D1.FeatureLevel.Level_DEFAULT));
res.BeginDraw();
return(res);
}
public void Run()
{
var form = new RenderForm("2d and 3d combined...it's like magic");
form.KeyDown += (sender, args) => { if (args.KeyCode == Keys.Escape) form.Close(); };
// DirectX DXGI 1.1 factory
var factory1 = new Factory1();
// The 1st graphics adapter
var adapter1 = factory1.GetAdapter1(0);
// ---------------------------------------------------------------------------------------------
// Setup direct 3d version 11. It's context will be used to combine the two elements
// ---------------------------------------------------------------------------------------------
var description = new SwapChainDescription
{
BufferCount = 1,
ModeDescription = new ModeDescription(0, 0, new Rational(60, 1), Format.R8G8B8A8_UNorm),
IsWindowed = true,
OutputHandle = form.Handle,
SampleDescription = new SampleDescription(1, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput,
Flags = SwapChainFlags.AllowModeSwitch
};
Device11 device11;
SwapChain swapChain;
Device11.CreateWithSwapChain(adapter1, DeviceCreationFlags.None, description, out device11, out swapChain);
// create a view of our render target, which is the backbuffer of the swap chain we just created
RenderTargetView renderTargetView;
using (var resource = Resource.FromSwapChain<Texture2D>(swapChain, 0))
renderTargetView = new RenderTargetView(device11, resource);
// setting a viewport is required if you want to actually see anything
var context = device11.ImmediateContext;
var viewport = new Viewport(0.0f, 0.0f, form.ClientSize.Width, form.ClientSize.Height);
context.OutputMerger.SetTargets(renderTargetView);
context.Rasterizer.SetViewports(viewport);
//
// Create the DirectX11 texture2D. This texture will be shared with the DirectX10 device.
//
// The DirectX10 device will be used to render text onto this texture.
// DirectX11 will then draw this texture (blended) onto the screen.
// The KeyedMutex flag is required in order to share this resource between the two devices.
var textureD3D11 = new Texture2D(device11, new Texture2DDescription
{
Width = form.ClientSize.Width,
Height = form.ClientSize.Height,
MipLevels = 1,
ArraySize = 1,
Format = Format.B8G8R8A8_UNorm,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.SharedKeyedmutex
});
// ---------------------------------------------------------------------------------------------
// Setup a direct 3d version 10.1 adapter
// ---------------------------------------------------------------------------------------------
var device10 = new Device10(adapter1, SharpDX.Direct3D10.DeviceCreationFlags.BgraSupport, FeatureLevel.Level_10_0);
// ---------------------------------------------------------------------------------------------
// Setup Direct 2d
// ---------------------------------------------------------------------------------------------
// Direct2D Factory
var factory2D = new SharpDX.Direct2D1.Factory(FactoryType.SingleThreaded, DebugLevel.Information);
// Here we bind the texture we've created on our direct3d11 device through the direct3d10
// to the direct 2d render target....
var sharedResource = textureD3D11.QueryInterface<SharpDX.DXGI.Resource>();
var textureD3D10 = device10.OpenSharedResource<SharpDX.Direct3D10.Texture2D>(sharedResource.SharedHandle);
var surface = textureD3D10.AsSurface();
var rtp = new RenderTargetProperties
{
MinLevel = SharpDX.Direct2D1.FeatureLevel.Level_10,
Type = RenderTargetType.Hardware,
PixelFormat = new PixelFormat(Format.Unknown, AlphaMode.Premultiplied)
};
var renderTarget2D = new RenderTarget(factory2D, surface, rtp);
var solidColorBrush = new SolidColorBrush(renderTarget2D, Colors.Red);
// ---------------------------------------------------------------------------------------------------
// Setup the rendering data
// ---------------------------------------------------------------------------------------------------
// Load Effect. This includes both the vertex and pixel shaders.
// Also can include more than one technique.
ShaderBytecode shaderByteCode = ShaderBytecode.CompileFromFile(
"effectDx11.fx",
"fx_5_0",
ShaderFlags.EnableStrictness);
var effect = new Effect(device11, shaderByteCode);
// create triangle vertex data, making sure to rewind the stream afterward
var verticesTriangle = new DataStream(VertexPositionColor.SizeInBytes * 3, true, true);
verticesTriangle.Write(new VertexPositionColor(new Vector3(0.0f, 0.5f, 0.5f),new Color4(1.0f, 0.0f, 0.0f, 1.0f)));
verticesTriangle.Write(new VertexPositionColor(new Vector3(0.5f, -0.5f, 0.5f),new Color4(0.0f, 1.0f, 0.0f, 1.0f)));
verticesTriangle.Write(new VertexPositionColor(new Vector3(-0.5f, -0.5f, 0.5f),new Color4(0.0f, 0.0f, 1.0f, 1.0f)));
verticesTriangle.Position = 0;
// create the triangle vertex layout and buffer
var layoutColor = new InputLayout(device11, effect.GetTechniqueByName("Color").GetPassByIndex(0).Description.Signature, VertexPositionColor.inputElements);
var vertexBufferColor = new Buffer(device11, verticesTriangle, (int)verticesTriangle.Length, ResourceUsage.Default, BindFlags.VertexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
verticesTriangle.Close();
// create overlay vertex data, making sure to rewind the stream afterward
// Top Left of screen is -1, +1
// Bottom Right of screen is +1, -1
var verticesText = new DataStream(VertexPositionTexture.SizeInBytes * 4, true, true);
verticesText.Write(new VertexPositionTexture(new Vector3(-1, 1, 0),new Vector2(0, 0f)));
verticesText.Write(new VertexPositionTexture(new Vector3(1, 1, 0),new Vector2(1, 0)));
verticesText.Write(new VertexPositionTexture(new Vector3(-1, -1, 0),new Vector2(0, 1)));
verticesText.Write(new VertexPositionTexture(new Vector3(1, -1, 0),new Vector2(1, 1)));
verticesText.Position = 0;
// create the overlay vertex layout and buffer
var layoutOverlay = new InputLayout(device11, effect.GetTechniqueByName("Overlay").GetPassByIndex(0).Description.Signature, VertexPositionTexture.inputElements);
var vertexBufferOverlay = new Buffer(device11, verticesText, (int)verticesText.Length, ResourceUsage.Default, BindFlags.VertexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
verticesText.Close();
// Think of the shared textureD3D10 as an overlay.
// The overlay needs to show the 2d content but let the underlying triangle (or whatever)
// show thru, which is accomplished by blending.
var bsd = new BlendStateDescription();
bsd.RenderTarget[0].IsBlendEnabled = true;
bsd.RenderTarget[0].SourceBlend = BlendOption.SourceColor;
bsd.RenderTarget[0].DestinationBlend = BlendOption.BlendFactor;
bsd.RenderTarget[0].BlendOperation = BlendOperation.Add;
bsd.RenderTarget[0].SourceAlphaBlend = BlendOption.One;
bsd.RenderTarget[0].DestinationAlphaBlend = BlendOption.Zero;
bsd.RenderTarget[0].AlphaBlendOperation = BlendOperation.Add;
bsd.RenderTarget[0].RenderTargetWriteMask = ColorWriteMaskFlags.All;
var blendStateTransparent = new BlendState(device11, bsd);
// ---------------------------------------------------------------------------------------------------
// Create and tesselate an ellipse
// ---------------------------------------------------------------------------------------------------
var center = new DrawingPointF(form.ClientSize.Width/2.0f, form.ClientSize.Height/2.0f);
var ellipse = new EllipseGeometry(factory2D, new Ellipse(center, form.ClientSize.Width / 2.0f, form.ClientSize.Height / 2.0f));
// Populate a PathGeometry from Ellipse tessellation
var tesselatedGeometry = new PathGeometry(factory2D);
_geometrySink = tesselatedGeometry.Open();
// Force RoundLineJoin otherwise the tesselated looks buggy at line joins
_geometrySink.SetSegmentFlags(PathSegment.ForceRoundLineJoin);
// Tesselate the ellipse to our TessellationSink
ellipse.Tessellate(1, this);
_geometrySink.Close();
// ---------------------------------------------------------------------------------------------------
// Acquire the mutexes. These are needed to assure the device in use has exclusive access to the surface
// ---------------------------------------------------------------------------------------------------
var device10Mutex = textureD3D10.QueryInterface<KeyedMutex>();
var device11Mutex = textureD3D11.QueryInterface<KeyedMutex>();
// ---------------------------------------------------------------------------------------------------
// Main rendering loop
// ---------------------------------------------------------------------------------------------------
bool first = true;
RenderLoop
.Run(form,
() =>
{
if(first)
{
form.Activate();
first = false;
}
// clear the render target to black
context.ClearRenderTargetView(renderTargetView, Colors.DarkSlateGray);
// Draw the triangle
context.InputAssembler.InputLayout = layoutColor;
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertexBufferColor, VertexPositionColor.SizeInBytes, 0));
context.OutputMerger.BlendState = null;
var currentTechnique = effect.GetTechniqueByName("Color");
for (var pass = 0; pass < currentTechnique.Description.PassCount; ++pass)
{
using (var effectPass = currentTechnique.GetPassByIndex(pass))
{
System.Diagnostics.Debug.Assert(effectPass.IsValid, "Invalid EffectPass");
effectPass.Apply(context);
}
context.Draw(3, 0);
};
// Draw Ellipse on the shared Texture2D
device10Mutex.Acquire(0, 100);
renderTarget2D.BeginDraw();
renderTarget2D.Clear(Colors.Black);
renderTarget2D.DrawGeometry(tesselatedGeometry, solidColorBrush);
renderTarget2D.DrawEllipse(new Ellipse(center, 200, 200), solidColorBrush, 20, null);
renderTarget2D.EndDraw();
device10Mutex.Release(0);
// Draw the shared texture2D onto the screen, blending the 2d content in
device11Mutex.Acquire(0, 100);
var srv = new ShaderResourceView(device11, textureD3D11);
effect.GetVariableByName("g_Overlay").AsShaderResource().SetResource(srv);
context.InputAssembler.InputLayout = layoutOverlay;
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleStrip;
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertexBufferOverlay, VertexPositionTexture.SizeInBytes, 0));
context.OutputMerger.BlendState = blendStateTransparent;
currentTechnique = effect.GetTechniqueByName("Overlay");
for (var pass = 0; pass < currentTechnique.Description.PassCount; ++pass)
{
using (var effectPass = currentTechnique.GetPassByIndex(pass))
{
System.Diagnostics.Debug.Assert(effectPass.IsValid, "Invalid EffectPass");
effectPass.Apply(context);
}
context.Draw(4, 0);
}
srv.Dispose();
device11Mutex.Release(0);
swapChain.Present(0, PresentFlags.None);
});
// dispose everything
vertexBufferColor.Dispose();
vertexBufferOverlay.Dispose();
layoutColor.Dispose();
layoutOverlay.Dispose();
effect.Dispose();
shaderByteCode.Dispose();
renderTarget2D.Dispose();
swapChain.Dispose();
device11.Dispose();
device10.Dispose();
textureD3D10.Dispose();
textureD3D11.Dispose();
factory1.Dispose();
adapter1.Dispose();
sharedResource.Dispose();
factory2D.Dispose();
surface.Dispose();
solidColorBrush.Dispose();
blendStateTransparent.Dispose();
device10Mutex.Dispose();
device11Mutex.Dispose();
}
void EnsureResources(SharpDX.Direct3D11.Device device, Texture2DDescription description, Rectangle captureRegion, ScreenshotRequest request)
{
if (_device != null && request.Resize != null && (_resizedRT == null || (_resizedRT.Device.NativePointer != _device.NativePointer || _resizedRT.Description.Width != request.Resize.Value.Width || _resizedRT.Description.Height != request.Resize.Value.Height)))
{
// Create/Recreate resources for resizing
RemoveAndDispose(ref _resizedRT);
RemoveAndDispose(ref _resizedRTV);
RemoveAndDispose(ref _saQuad);
_resizedRT = ToDispose(new Texture2D(_device, new Texture2DDescription() {
Format = SharpDX.DXGI.Format.R8G8B8A8_UNorm, // Supports BMP/PNG/etc
Height = request.Resize.Value.Height,
Width = request.Resize.Value.Width,
ArraySize = 1,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
BindFlags = BindFlags.RenderTarget,
MipLevels = 1,
Usage = ResourceUsage.Default,
OptionFlags = ResourceOptionFlags.None
}));
_resizedRTV = ToDispose(new RenderTargetView(_device, _resizedRT));
_saQuad = ToDispose(new DX11.ScreenAlignedQuadRenderer());
_saQuad.Initialize(new DX11.DeviceManager(_device));
}
// Check if _resolvedRT or _finalRT require creation
if (_finalRT != null && _finalRT.Device.NativePointer == _device.NativePointer &&
_finalRT.Description.Height == captureRegion.Height && _finalRT.Description.Width == captureRegion.Width &&
_resolvedRT != null && _resolvedRT.Description.Height == description.Height && _resolvedRT.Description.Width == description.Width &&
_resolvedRT.Device.NativePointer == device.NativePointer && _resolvedRT.Description.Format == description.Format
)
{
return;
}
RemoveAndDispose(ref _query);
RemoveAndDispose(ref _resolvedRT);
RemoveAndDispose(ref _resolvedSharedSRV);
RemoveAndDispose(ref _finalRT);
RemoveAndDispose(ref _resolvedRTShared);
_query = new Query(_device, new QueryDescription()
{
Flags = QueryFlags.None,
Type = QueryType.Event
});
_queryIssued = false;
_resolvedRT = ToDispose(new Texture2D(device, new Texture2DDescription() {
CpuAccessFlags = CpuAccessFlags.None,
Format = description.Format, // for multisampled backbuffer, this must be same format
Height = description.Height,
Usage = ResourceUsage.Default,
Width = description.Width,
ArraySize = 1,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0), // Ensure single sample
BindFlags = BindFlags.ShaderResource,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.SharedKeyedmutex
}));
// Retrieve reference to the keyed mutex
_resolvedRTKeyedMutex = ToDispose(_resolvedRT.QueryInterfaceOrNull<SharpDX.DXGI.KeyedMutex>());
using (var resource = _resolvedRT.QueryInterface<SharpDX.DXGI.Resource>())
{
_resolvedRTShared = ToDispose(_device.OpenSharedResource<Texture2D>(resource.SharedHandle));
_resolvedRTKeyedMutex_Dev2 = ToDispose(_resolvedRTShared.QueryInterfaceOrNull<SharpDX.DXGI.KeyedMutex>());
}
// SRV for use if resizing
_resolvedSharedSRV = ToDispose(new ShaderResourceView(_device, _resolvedRTShared));
_finalRT = ToDispose(new Texture2D(_device, new Texture2DDescription()
{
CpuAccessFlags = CpuAccessFlags.Read,
Format = description.Format,
Height = captureRegion.Height,
Usage = ResourceUsage.Staging,
Width = captureRegion.Width,
ArraySize = 1,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
BindFlags = BindFlags.None,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None
}));
_finalRTMapped = false;
}
private void createSwapChain()
{
lock (deviceManager.DeviceLock)
{
var factory = new DXGI.Factory();
var description = new DXGI.SwapChainDescription()
{
BufferCount = 1,
ModeDescription =
new DXGI.ModeDescription(
control.ClientSize.Width,
control.ClientSize.Height,
new DXGI.Rational(60, 1),
DXGI.Format.R8G8B8A8_UNorm),
IsWindowed = true,
SampleDescription = new DXGI.SampleDescription(1, 0),
SwapEffect = DXGI.SwapEffect.Discard,
Usage = DXGI.Usage.RenderTargetOutput,
OutputHandle = control.Handle
};
swapChain = new DXGI.SwapChain(factory, deviceContext.Device, description);
backbuffer = D3D11.Texture2D.FromSwapChain<D3D11.Texture2D>(swapChain, 0);
backbufferView = new D3D11.RenderTargetView(deviceContext.Device, backbuffer);
}
var d2dFactory = deviceManager.Direct2dFactory;
var surface = backbuffer.QueryInterface<DXGI.Surface>();
renderTarget = new D2D.RenderTarget(
d2dFactory,
surface,
new D2D.RenderTargetProperties(
new D2D.PixelFormat(
DXGI.Format.Unknown,
D2D.AlphaMode.Premultiplied)));
renderTarget.AntialiasMode = D2D.AntialiasMode.Aliased;
createViewport();
}
private void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
var hr = Direct3DCreate9Ex(D3D_SDK_VERSION, out var direct3D9Ex);
m_d3dEx = direct3D9Ex;
var adapterMonitor = direct3D9Ex.GetAdapterMonitor(0);
m_hWnd = GetDesktopWindow();
var param = new D3DPRESENT_PARAMETERS
{
Windowed = 1,
Flags = ((short)D3DPRESENTFLAG.D3DPRESENTFLAG_VIDEO),
/*
* D3DFMT_R8G8B8：表示一个24位像素，从左开始，8位分配给红色，8位分配给绿色，8位分配给蓝色。
*
* D3DFMT_X8R8G8B8：表示一个32位像素，从左开始，8位不用，8位分配给红色，8位分配给绿色，8位分配给蓝色。
*
* D3DFMT_A8R8G8B8：表示一个32位像素，从左开始，8位为ALPHA通道，8位分配给红色，8位分配给绿色，8位分配给蓝色。
*
* D3DFMT_A16B16G16R16F：表示一个64位浮点像素，从左开始，16位为ALPHA通道，16位分配给蓝色，16位分配给绿色，16位分配给红色。
*
* D3DFMT_A32B32G32R32F：表示一个128位浮点像素，从左开始，32位为ALPHA通道，32位分配给蓝色，32位分配给绿色，32位分配给红色。
*/
//BackBufferFormat = D3DFORMAT.D3DFMT_X8R8G8B8,
//SwapEffect = D3DSWAPEFFECT.D3DSWAPEFFECT_COPY
SwapEffect = D3DSWAPEFFECT.D3DSWAPEFFECT_DISCARD,
hDeviceWindow = GetDesktopWindow(), // 添加
PresentationInterval = (int)D3D9.PresentInterval.Default,
};
/* The COM pointer to our D3D Device */
IntPtr dev;
m_d3dEx.CreateDeviceEx(0, D3DDEVTYPE.D3DDEVTYPE_HAL, m_hWnd,
Direct3D.CreateFlags.D3DCREATE_HARDWARE_VERTEXPROCESSING | Direct3D.CreateFlags.D3DCREATE_MULTITHREADED
| Direct3D.CreateFlags.D3DCREATE_FPU_PRESERVE,
ref param, IntPtr.Zero, out dev);
m_device = (IDirect3DDevice9)Marshal.GetObjectForIUnknown(dev);
// 只是减少引用计数而已，现在换成 m_device 了
Marshal.Release(dev);
hr = m_device.TestCooperativeLevel();
var pDevice = dev;
D3D11.Texture2D d3d11Texture2D = CreateRenderTarget();
//SetRenderTarget(d3d11Texture2D);
var format = TranslateFormat(TranslateFormat(d3d11Texture2D));
var dxgiResource = d3d11Texture2D.QueryInterface <DXGI.Resource>();
var pSharedHandle = dxgiResource.SharedHandle;
hr = m_device.CreateTexture(ImageWidth,
ImageHeight,
1,
1,
format,
0,
out m_privateTexture,
ref pSharedHandle);
hr = m_privateTexture.GetSurfaceLevel(0, out m_privateSurface);
var backBuffer = Marshal.GetIUnknownForObject(m_privateSurface);
var surface = new D3D9.Surface(backBuffer);
var queryInterface = surface.QueryInterface <D3D9.Surface>();
//// 只是减少引用计数而已
//Marshal.Release(backBuffer);
//hr = m_device.SetTexture(0, m_privateTexture);
var texturePtr = Marshal.GetIUnknownForObject(m_privateTexture);
//Marshal.Release(texturePtr);
//var byteList = new byte[32 * 10];
//for (int i = 0; i < byteList.Length; i++)
//{
// byteList[i] = (byte)i;
//}
//unsafe
//{
// fixed (void* p = byteList)
// {
// Buffer.MemoryCopy(p, (void*) texturePtr,0,320);
// }
//}
//var d2dFactory = new SharpDX.Direct2D1.Factory();
//Texture2D backBufferTexture2D = new Texture2D(texturePtr);
//var d2dRenderTarget = new RenderTarget(d2dFactory, new SharpDX.DXGI.Surface(backBuffer),
// new RenderTargetProperties(new SharpDX.Direct2D1.PixelFormat(Format.Unknown,AlphaMode.Premultiplied)));
//d2dRenderTarget.BeginDraw();
//d2dRenderTarget.Clear(new RawColor4(1,0,0.5f,1));
//d2dRenderTarget.EndDraw();
D3DImage.Lock();
D3DImage.SetBackBuffer(D3DResourceType.IDirect3DSurface9, backBuffer, true);
D3DImage.Unlock();
Render();
string s = "123";
var stringBuilder = new StringBuilder(s);
stringBuilder.Replace("%", "%25").Replace("#", "%23");
stringBuilder.Insert(0, "123");
stringBuilder.Insert("123".Length, "#");
}
private void ResetDeviceToNewViewportSize(Size newSizeInPixel)
{
backBuffer.Dispose();
surface.Dispose();
RenderTarget.Dispose();
width = (int)newSizeInPixel.Width;
height = (int)newSizeInPixel.Height;
swapChain.ResizeBuffers(BackBufferCount, width, height, BackBufferFormat, SwapChainFlags.None);
backBuffer = Resource.FromSwapChain<Texture2D>(swapChain, 0);
surface = backBuffer.QueryInterface<Surface>();
RenderTarget = new RenderTarget(direct2DFactory, surface, defaultRenderTargetProperties);
Screen = new ScreenSpace(newSizeInPixel);
}
private void CreateAndBindTargets() {
d3DSurface.SetRenderTarget( null );
Disposer.SafeDispose( ref d2DRenderTarget );
Disposer.SafeDispose( ref d2DFactory );
Disposer.SafeDispose( ref renderTarget );
var width = Math.Max((int)ActualWidth , 100);
var height = Math.Max((int)ActualHeight, 100);
var renderDesc = new Texture2DDescription {
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
Format = Format.B8G8R8A8_UNorm,
Width = width,
Height = height,
MipLevels = 1,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
OptionFlags = ResourceOptionFlags.Shared,
CpuAccessFlags = CpuAccessFlags.None,
ArraySize = 1
};
renderTarget = new Texture2D( device, renderDesc );
var surface = renderTarget.QueryInterface<Surface>();
d2DFactory = new SharpDX.Direct2D1.Factory();
var rtp = new RenderTargetProperties(new PixelFormat(Format.Unknown, SharpDX.Direct2D1.AlphaMode.Premultiplied));
d2DRenderTarget = new RenderTarget( d2DFactory, surface, rtp );
resCache.RenderTarget = d2DRenderTarget;
d3DSurface.SetRenderTarget( renderTarget );
device.ImmediateContext.Rasterizer.SetViewport( 0, 0, width, height, 0.0f, 1.0f );
}