/// <summary>
/// Construct an EffectsManager
/// </summary>
public DefaultEffectsManager(IRenderTechniquesManager renderTechniquesManager)
{
this.renderTechniquesManager = renderTechniquesManager;
#if DX11
var adapter = GetBestAdapter();
if (adapter != null)
{
if (adapter.Description.VendorId == 0x1414 && adapter.Description.DeviceId == 0x8c)
{
driverType = DriverType.Warp;
device = new global::SharpDX.Direct3D11.Device(adapter, DeviceCreationFlags.BgraSupport, FeatureLevel.Level_10_0);
}
else
{
driverType = DriverType.Hardware;
device = new global::SharpDX.Direct3D11.Device(adapter, DeviceCreationFlags.BgraSupport);
// DeviceCreationFlags.Debug should not be used in productive mode!
// See: http://sharpdx.org/forum/4-general/1774-how-to-debug-a-sharpdxexception
// See: http://stackoverflow.com/questions/19810462/launching-sharpdx-directx-app-with-devicecreationflags-debug
}
}
#else
this.device = new Direct3D11.Device(Direct3D.DriverType.Hardware, DeviceCreationFlags.BgraSupport, Direct3D.FeatureLevel.Level_10_1);
#endif
InitEffects();
}
/// <summary>
///
/// </summary>
private bool StartD3D()
{
if (!loaded || EffectsManager == null || RenderTechniquesManager == null)
{
if (EffectsManager == null)
{
EffectsManager = defaultEffectsManager = new DefaultEffectsManager(new DefaultRenderTechniquesManager());
}
//RenderTechniquesManager = DefaultRenderTechniquesManagerObj.Value;
//EffectsManager = DefaultEffectsManagerObj.Value;
return(false); // StardD3D() is called from DP changed handler
}
this.IsHitTestVisible = false;
surfaceD3D = new RenderControl();
Child = surfaceD3D;
device = EffectsManager.Device;
deferredRenderer = new DeferredRenderer();
renderRenderable.DeferredRenderer = deferredRenderer;
CreateAndBindTargets();
SetDefaultRenderTargets();
//Source = surfaceD3D;
InvalidateRender();
return(true);
}
/// <summary>
///
/// </summary>
public static Direct3D11.Buffer CreateBuffer <T>(this Direct3D11.Device device, BindFlags flags, int sizeofT, T[] range)
where T : struct
{
return(Direct3D11.Buffer.Create <T>(device, range, new BufferDescription()
{
BindFlags = flags,
SizeInBytes = (int)range.Length * sizeofT,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None,
Usage = ResourceUsage.Default,
}));
////sizeofT = sizeofT == 0 ? sizeofT = Marshal.SizeOf(typeof(T)) : sizeofT;
//using (var stream = new DataStream(range.Length * sizeofT, true, true))
//{
// stream.WriteRange(range);
// stream.Position = 0;
// return new Direct3D11.Buffer(device, stream, new BufferDescription
// {
// BindFlags = flags,
// SizeInBytes = (int)stream.Length,
// CpuAccessFlags = CpuAccessFlags.None,
// OptionFlags = ResourceOptionFlags.None,
// Usage = ResourceUsage.Default,
// });
//}
}
/// <summary>
/// Creates a <see cref="SharpDX.Direct3D11.Texture2D"/> from a WIC <see cref="SharpDX.WIC.BitmapSource"/>
/// </summary>
/// <param name="device">The Direct3D11 device</param>
/// <param name="bitmapSource">The WIC bitmap source</param>
/// <returns>A Texture2D</returns>
public static Texture2D CreateTexture2DFromBitmap(Device device, BitmapSource bitmapSource)
{
// Allocate DataStream to receive the WIC image pixels
int stride = bitmapSource.Size.Width * 4;
using (var buffer = new DataStream(bitmapSource.Size.Height * stride, true, true))
{
// Copy the content of the WIC to the buffer
Rectangle rect = new Rectangle();
var methods = bitmapSource.GetType().GetMethods();
bitmapSource.GetType().GetMethods().First(item => item.Name == "CopyPixels").Invoke(bitmapSource, new object[] { stride, buffer });
// bitmapSource.CopyPixels(stride, buffer);
return new Texture2D(device, new Texture2DDescription()
{
Width = bitmapSource.Size.Width,
Height = bitmapSource.Size.Height,
ArraySize = 1,
BindFlags = BindFlags.ShaderResource,
Usage = ResourceUsage.Immutable,
CpuAccessFlags =CpuAccessFlags.None,
Format = Format.R8G8B8A8_UNorm,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0),
}, new DataRectangle(buffer.DataPointer, stride));
}
}
/// <summary>
/// Construct an EffectsManager
/// </summary>
public DefaultEffectsManager(IRenderTechniquesManager renderTechniquesManager)
{
this.renderTechniquesManager = renderTechniquesManager;
#if DX11
var adapter = GetBestAdapter();
if (adapter != null)
{
if (adapter.Description.VendorId == 0x1414 && adapter.Description.DeviceId == 0x8c)
{
driverType = DriverType.Warp;
device = new global::SharpDX.Direct3D11.Device(adapter, DeviceCreationFlags.BgraSupport, FeatureLevel.Level_10_0);
}
else
{
driverType = DriverType.Hardware;
device = new global::SharpDX.Direct3D11.Device(adapter, DeviceCreationFlags.BgraSupport);
// DeviceCreationFlags.Debug should not be used in productive mode!
// See: http://sharpdx.org/forum/4-general/1774-how-to-debug-a-sharpdxexception
// See: http://stackoverflow.com/questions/19810462/launching-sharpdx-directx-app-with-devicecreationflags-debug
}
}
#else
this.device = new Direct3D11.Device(Direct3D.DriverType.Hardware, DeviceCreationFlags.BgraSupport, Direct3D.FeatureLevel.Level_10_1);
#endif
InitEffects();
}
/// <summary>
///
/// </summary>
private bool StartD3D()
{
if (!loaded || EffectsManager == null || RenderTechniquesManager == null)
{
if (EffectsManager == null)
{
EffectsManager = defaultEffectsManager = new DefaultEffectsManager(new DefaultRenderTechniquesManager());
}
//RenderTechniquesManager = DefaultRenderTechniquesManagerObj.Value;
//EffectsManager = DefaultEffectsManagerObj.Value;
return(false); // StardD3D() is called from DP changed handler
}
surfaceD3D = new DX11ImageSource(EffectsManager.AdapterIndex);
surfaceD3D.IsFrontBufferAvailableChanged += OnIsFrontBufferAvailableChanged;
device = EffectsManager.Device;
deferredRenderer = new DeferredRenderer();
renderRenderable.DeferredRenderer = deferredRenderer;
CreateAndBindTargets();
SetDefaultRenderTargets();
Source = surfaceD3D;
InvalidateRender();
return(true);
}
/// <summary>
///
/// </summary>
private void StartD3D()
{
#if DX11
var adapter = GetBestAdapter();
if (adapter == null)
{
System.Windows.MessageBox.Show("No DirectX 10 or higher adapter found, a software adapter will be used!", "Warning");
this.device = new Direct3D11.Device(DriverType.Warp, DeviceCreationFlags.BgraSupport, FeatureLevel.Level_11_0);
}
else
{
this.device = new Direct3D11.Device(adapter, DeviceCreationFlags.BgraSupport);
//this.device = new Direct3D11.Device(Direct3D.DriverType.Hardware, DeviceCreationFlags.BgraSupport, Direct3D.FeatureLevel.Level_11_0);
}
#else
this.device = new Direct3D11.Device(Direct3D.DriverType.Hardware, DeviceCreationFlags.BgraSupport, Direct3D.FeatureLevel.Level_10_1);
#endif
this.surfaceD3D = new DX11ImageSource();
this.surfaceD3D.IsFrontBufferAvailableChanged += this.OnIsFrontBufferAvailableChanged;
this.effects = EffectsManager.Instance;
this.effects.InitEffects(this.device);
this.deferredRenderer = new DeferredRenderer();
this.CreateAndBindTargets();
this.SetDefaultRenderTargets();
this.Source = this.surfaceD3D;
}
/// <summary>
///
/// </summary>
private void StartD3D()
{
this.surfaceD3D = new DX11ImageSource();
this.surfaceD3D.IsFrontBufferAvailableChanged += this.OnIsFrontBufferAvailableChanged;
this.device = EffectsManager.Device;
this.deferredRenderer = new DeferredRenderer();
this.renderRenderable.DeferredRenderer = this.deferredRenderer;
this.CreateAndBindTargets();
this.SetDefaultRenderTargets();
this.Source = this.surfaceD3D;
}
/// <summary>
/// Create buffer
/// </summary>
public static Direct3D11.Buffer CreateBuffer <T>(this Direct3D11.Device device, BindFlags flags, int sizeofT, T[] range, int length)
where T : struct
{
return(Direct3D11.Buffer.Create <T>(device, range, new BufferDescription()
{
BindFlags = flags,
SizeInBytes = length * sizeofT,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None,
Usage = ResourceUsage.Default,
}));
}
public void Dispose()
{
if (data != null)
{
foreach (var item in data)
{
var o = item.Value as IDisposable;
Disposer.RemoveAndDispose(ref o);
}
}
this.device = null;
this.data = null;
}
/// <summary>
/// Free used resources.
/// </summary>
private void CleanResources()
{
this.oxyRenderContext.ResetRenderTarget(null);
this.d3d11Device?.ImmediateContext.ClearState();
this.d3d11Device?.ImmediateContext.Flush();
this.imageSource?.Dispose();
this.d3d9Device?.Dispose();
this.renderTarget?.Dispose();
this.d3d11Device?.Dispose();
this.imageSource = null;
this.d3d9Device = null;
this.renderTarget = null;
this.d3d11Device = null;
}
/// <summary>
///
/// </summary>
public static Direct3D11.Buffer CreateBuffer <T>(this Direct3D11.Device device, BindFlags flags, int sizeofT, T[] range)
where T : struct
{
//sizeofT = sizeofT == 0 ? sizeofT = Marshal.SizeOf(typeof(T)) : sizeofT;
using (var stream = new DataStream(range.Length * sizeofT, true, true))
{
stream.WriteRange(range);
return(new Direct3D11.Buffer(device, stream, new BufferDescription
{
BindFlags = flags,
SizeInBytes = (int)stream.Length,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None,
Usage = ResourceUsage.Default,
}));
}
}
protected override void Initialize(DemoConfiguration demoConfiguration)
{
// SwapChain description
var desc = new SwapChainDescription()
{
BufferCount = 1,
ModeDescription = new ModeDescription(
demoConfiguration.Width,
demoConfiguration.Height,
new Rational(60, 1),
Format.R8G8B8A8_UNorm),
IsWindowed = true,
OutputHandle = this.DisplayHandle,
SampleDescription = new SampleDescription(1, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput
};
// Create Device and SwapChain
FeatureLevel featureLevel = new Device(DriverType.Hardware).FeatureLevel;
if (featureLevel > FeatureLevel.Level_11_0)
{
featureLevel = FeatureLevel.Level_11_0;
}
Device.CreateWithSwapChain(
DriverType.Hardware,
DeviceCreationFlags.BgraSupport | DeviceCreationFlags.Debug,
new[] { featureLevel },
desc,
out this.device,
out this.swapChain);
// Ignore all windows events
var factory = this.swapChain.GetParent <Factory>();
factory.MakeWindowAssociation(this.DisplayHandle, WindowAssociationFlags.IgnoreAll);
this.CreateBackBuffer();
this.CreateStencilBuffer();
}
/// <summary>
///
/// </summary>
private EffectsManager()
{
#if DX11
var adapter = GetBestAdapter();
if (adapter != null)
{
if (adapter.Description.VendorId == 0x1414 && adapter.Description.DeviceId == 0x8c)
{
this.driverType = DriverType.Warp;
this.device = new global::SharpDX.Direct3D11.Device(adapter, DeviceCreationFlags.BgraSupport, FeatureLevel.Level_10_0);
}
else
{
this.driverType = DriverType.Hardware;
this.device = new global::SharpDX.Direct3D11.Device(adapter, DeviceCreationFlags.BgraSupport);
}
}
#else
this.device = new Direct3D11.Device(Direct3D.DriverType.Hardware, DeviceCreationFlags.BgraSupport, Direct3D.FeatureLevel.Level_10_1);
#endif
this.InitEffects();
}
/// <summary>
///
/// </summary>
private void StartD3D()
{
if (EffectsManager == null || RenderTechniquesManager == null)
{
// Make sure both are null
RenderTechniquesManager = null;
EffectsManager = null;
RenderTechniquesManager = new DefaultRenderTechniquesManager();
EffectsManager = new DefaultEffectsManager(RenderTechniquesManager);
return; // StardD3D() is called from DP changed handler
}
surfaceD3D = new DX11ImageSource(EffectsManager.AdapterIndex);
surfaceD3D.IsFrontBufferAvailableChanged += OnIsFrontBufferAvailableChanged;
device = EffectsManager.Device;
deferredRenderer = new DeferredRenderer();
renderRenderable.DeferredRenderer = deferredRenderer;
CreateAndBindTargets();
SetDefaultRenderTargets();
Source = surfaceD3D;
InvalidateRender();
}
public void Dispose()
{
if (data != null)
{
foreach (var item in data)
{
var o = item.Value as IDisposable;
Disposer.RemoveAndDispose(ref o);
}
}
data = null;
Disposer.RemoveAndDispose(ref device);
device = null;
}
/// <summary>
/// Construct an EffectsManager
/// </summary>
public DefaultEffectsManager(IRenderTechniquesManager renderTechniquesManager)
{
this.renderTechniquesManager = renderTechniquesManager;
#if DX11
var adapter = GetBestAdapter();
if (adapter != null)
{
if (adapter.Description.VendorId == 0x1414 && adapter.Description.DeviceId == 0x8c)
{
driverType = DriverType.Warp;
device = new global::SharpDX.Direct3D11.Device(adapter, DeviceCreationFlags.BgraSupport, FeatureLevel.Level_10_0);
}
else
{
driverType = DriverType.Hardware;
device = new global::SharpDX.Direct3D11.Device(adapter, DeviceCreationFlags.BgraSupport | DeviceCreationFlags.Debug);
}
}
#else
this.device = new Direct3D11.Device(Direct3D.DriverType.Hardware, DeviceCreationFlags.BgraSupport, Direct3D.FeatureLevel.Level_10_1);
#endif
InitEffects();
}
public static Texture2D CreateTexture2DFromMediaBitamp(Device device,MediaBitmapSource bitmapSource)
{
int stride = bitmapSource.PixelWidth * 4;
using (var buffer = new DataStream(bitmapSource.PixelHeight * stride, true, true))
{
// Copy the content of the WIC to the buffer
byte[] array = new byte[bitmapSource.PixelHeight * stride];
bitmapSource.CopyPixels(array, stride, 0);
buffer.Write(array, 0, bitmapSource.PixelHeight * stride);
return new Texture2D(device, new Texture2DDescription()
{
Width = bitmapSource.PixelWidth,
Height = bitmapSource.PixelHeight,
ArraySize = 1,
BindFlags = BindFlags.ShaderResource,
Usage = ResourceUsage.Immutable,
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.R8G8B8A8_UNorm,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0),
}, new DataRectangle(buffer.DataPointer, stride));
}
}
/// <summary>
///
/// </summary>
private void StartD3D()
{
if (EffectsManager == null || RenderTechniquesManager == null)
{
// Make sure both are null
RenderTechniquesManager = null;
EffectsManager = null;
RenderTechniquesManager = new DefaultRenderTechniquesManager();
EffectsManager = new DefaultEffectsManager(RenderTechniquesManager);
return; // StardD3D() is called from DP changed handler
}
surfaceD3D = new DX11ImageSource();
surfaceD3D.IsFrontBufferAvailableChanged += OnIsFrontBufferAvailableChanged;
device = EffectsManager.Device;
deferredRenderer = new DeferredRenderer();
renderRenderable.DeferredRenderer = deferredRenderer;
CreateAndBindTargets();
SetDefaultRenderTargets();
Source = surfaceD3D;
InvalidateRender();
}
/// <summary>
///
/// </summary>
private EffectsManager()
{
#if DX11
var adapter = GetBestAdapter();
if (adapter == null)
{
System.Windows.MessageBox.Show("No DirectX 10 or higher adapter found, a software adapter will be used!", "Warning");
this.device = new global::SharpDX.Direct3D11.Device(DriverType.Warp, DeviceCreationFlags.BgraSupport, FeatureLevel.Level_10_0);
}
else
{
this.device = new global::SharpDX.Direct3D11.Device(adapter, DeviceCreationFlags.BgraSupport);
//this.device = new Direct3D11.Device(Direct3D.DriverType.Hardware, DeviceCreationFlags.BgraSupport, Direct3D.FeatureLevel.Level_11_0);
}
#else
this.device = new Direct3D11.Device(Direct3D.DriverType.Hardware, DeviceCreationFlags.BgraSupport, Direct3D.FeatureLevel.Level_10_1);
#endif
this.InitEffects();
}
public void SetRenderDevice(Device device, Texture2D colorBuffer, Texture2D renderTarget)
{
this.renderContext = device.ImmediateContext;
this.colorBuffer = colorBuffer;
this.renderTargetNMS = renderTarget;
}
/// <summary>
///
/// </summary>
private void StartD3D()
{
#if DX11
var adapter = GetBestAdapter();
if (adapter == null)
{
System.Windows.MessageBox.Show("No DirectX 10 or higher adapter found, a software adapter will be used!", "Warning");
this.device = new Direct3D11.Device(DriverType.Warp, DeviceCreationFlags.BgraSupport, FeatureLevel.Level_11_0);
}
else
{
this.device = new Direct3D11.Device( adapter, DeviceCreationFlags.BgraSupport);
//this.device = new Direct3D11.Device(Direct3D.DriverType.Hardware, DeviceCreationFlags.BgraSupport, Direct3D.FeatureLevel.Level_11_0);
}
#else
this.device = new Direct3D11.Device(Direct3D.DriverType.Hardware, DeviceCreationFlags.BgraSupport, Direct3D.FeatureLevel.Level_10_1);
#endif
this.surfaceD3D = new DX11ImageSource();
this.surfaceD3D.IsFrontBufferAvailableChanged += this.OnIsFrontBufferAvailableChanged;
this.effects = EffectsManager.Instance;
this.effects.InitEffects(this.device);
this.deferredRenderer = new DeferredRenderer();
this.CreateAndBindTargets();
this.SetDefaultRenderTargets();
this.Source = this.surfaceD3D;
}
internal void InitEffects(global::SharpDX.Direct3D11.Device device)
{
this.device = device;
var sFlags = ShaderFlags.None;
var eFlags = EffectFlags.None;
#if DEBUG
sFlags |= ShaderFlags.Debug;
eFlags |= EffectFlags.None;
#endif
try
{
// ------------------------------------------------------------------------------------
#if DX11
RegisterEffect(new StreamReader(@"./Shaders/Tessellation.fx").ReadToEnd(),
#else
RegisterEffect(new StreamReader(@"./Shaders/Default.fx").ReadToEnd(),
#endif
new[]
{
// put here the techniques which you want to use with this effect
Techniques.RenderPhong,
Techniques.RenderBlinn,
Techniques.RenderCubeMap,
Techniques.RenderColors,
Techniques.RenderDiffuse,
Techniques.RenderPositions,
Techniques.RenderNormals,
Techniques.RenderTangents,
Techniques.RenderTexCoords,
Techniques.RenderWires,
#if DX11
Techniques.RenderPNTriangs,
Techniques.RenderPNQuads,
#endif
//Techniques.RenderLines,
Techniques.RenderSpineTest
});
// ------------------------------------------------------------------------------------
//RegisterEffect(new StreamReader(@"./Shaders/Lines.fx").ReadToEnd(), //Properties.Resources.Deferred,
// new[]
//{
// Techniques.RenderLines
//});
// ------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------
/*
* RegisterEffect(new StreamReader(@"./Shaders/SpineTest.fx").ReadToEnd(), //Properties.Resources.Deferred,
* new[]
* {
* Techniques.RenderSpineTest
* });
*/
// ------------------------------------------------------------------------------------
RegisterEffect(new StreamReader(@"./Shaders/Deferred.fx").ReadToEnd(), //Properties.Resources.Deferred,
new[]
{
Techniques.RenderDeferred,
Techniques.RenderGBuffer,
});
// ------------------------------------------------------------------------------------
RegisterEffect(new StreamReader(@"./Shaders/DeferredLighting.fx").ReadToEnd(),//Properties.Resources.DeferredLighting,
new[]
{
Techniques.RenderDeferredLighting
});
// ------------------------------------------------------------------------------------
RegisterLayout(
new[]
{
// put here techniques which use the vertex layout below
Techniques.RenderPhong,
Techniques.RenderBlinn,
Techniques.RenderDiffuse,
Techniques.RenderPositions,
Techniques.RenderNormals,
Techniques.RenderTangents,
Techniques.RenderTexCoords,
Techniques.RenderColors,
Techniques.RenderWires,
Techniques.RenderDeferred,
Techniques.RenderGBuffer,
},
new InputLayout(device, this[Techniques.RenderPhong].GetTechniqueByName(Techniques.RenderPhong).GetPassByIndex(0).Description.Signature,
new[]
{
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
new InputElement("COLOR", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
new InputElement("TEXCOORD", 0, Format.R32G32_Float, InputElement.AppendAligned, 0),
new InputElement("NORMAL", 0, Format.R32G32B32_Float, InputElement.AppendAligned, 0),
new InputElement("TANGENT", 0, Format.R32G32B32_Float, InputElement.AppendAligned, 0),
new InputElement("BINORMAL", 0, Format.R32G32B32_Float, InputElement.AppendAligned, 0),
//INSTANCING: die 4 texcoords sind die matrix, die mit jedem buffer reinwandern
new InputElement("TEXCOORD", 1, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
new InputElement("TEXCOORD", 2, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
new InputElement("TEXCOORD", 3, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
new InputElement("TEXCOORD", 4, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
}));
#if DX11
// ------------------------------------------------------------------------------------
var layout = new InputLayout(device, this[Techniques.RenderPNTriangs].GetTechniqueByName(Techniques.RenderPNTriangs).GetPassByIndex(0).Description.Signature,
new[]
{
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
new InputElement("COLOR", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
new InputElement("TEXCOORD", 0, Format.R32G32_Float, InputElement.AppendAligned, 0),
new InputElement("NORMAL", 0, Format.R32G32B32_Float, InputElement.AppendAligned, 0),
new InputElement("TANGENT", 0, Format.R32G32B32_Float, InputElement.AppendAligned, 0),
new InputElement("BINORMAL", 0, Format.R32G32B32_Float, InputElement.AppendAligned, 0),
});
RegisterLayout(
new[]
{
// put here techniques which use the vertex layout below
Techniques.RenderPNTriangs,
Techniques.RenderPNQuads,
},
layout
);
#endif
// ------------------------------------------------------------------------------------
RegisterLayout(
new[]
{
Techniques.RenderCubeMap,
Techniques.RenderDeferredLighting
},
new InputLayout(device, this[Techniques.RenderCubeMap].GetTechniqueByName(Techniques.RenderCubeMap).GetPassByIndex(0).Description.Signature, new[]
{
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
}));
// ------------------------------------------------------------------------------------
RegisterLayout(
new[]
{
//Techniques.RenderLines,
Techniques.RenderSpineTest
},
new InputLayout(device, this[Techniques.RenderSpineTest].GetTechniqueByName(Techniques.RenderSpineTest).GetPassByIndex(0).Description.Signature, new[]
{
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
new InputElement("COLOR", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
//INSTANCING: die 4 texcoords sind die matrix, die mit jedem buffer reinwandern
new InputElement("TEXCOORD", 1, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
new InputElement("TEXCOORD", 2, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
new InputElement("TEXCOORD", 3, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
new InputElement("TEXCOORD", 4, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
}));
// ------------------------------------------------------------------------------------
/*
* RegisterLayout(
* new[]
* {
* Techniques.RenderSpineTest
* },
* new InputLayout(device, this[Techniques.RenderSpineTest].GetTechniqueByName(Techniques.RenderSpineTest).GetPassByIndex(0).Description.Signature, new[]
* {
* new InputElement("POSITION", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
* new InputElement("COLOR", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
*
* //INSTANCING: die 4 texcoords sind die matrix, die mit jedem buffer reinwandern
* new InputElement("TEXCOORD", 1, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
* new InputElement("TEXCOORD", 2, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
* new InputElement("TEXCOORD", 3, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
* new InputElement("TEXCOORD", 4, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
* }));
* */
}
catch (Exception ex)
{
System.Windows.MessageBox.Show(string.Format("Error registering effect: {0}", ex.Message), "Error");
}
}
/// <summary>
/// Initializes DirectX rendering resources.
/// </summary>
private void InitRendering()
{
double dpiScale = 1.0; // default value for 96 dpi
var hwndTarget = PresentationSource.FromVisual(this).CompositionTarget as HwndTarget;
if (hwndTarget != null)
{
dpiScale = hwndTarget.TransformToDevice.M11;
}
int surfWidth = (int)(this.viewport.Width < 0 ? 0 : Math.Ceiling(this.viewport.Width * dpiScale));
int surfHeight = (int)(this.viewport.Height < 0 ? 0 : Math.Ceiling(this.viewport.Height * dpiScale));
var windowHandle = (new System.Windows.Interop.WindowInteropHelper(System.Windows.Window.GetWindow(this))).Handle;
this.d3d11Device = new D3D11Device(
DriverType.Hardware,
DeviceCreationFlags.BgraSupport,
FeatureLevel.Level_11_0,
FeatureLevel.Level_10_1,
FeatureLevel.Level_10_0,
FeatureLevel.Level_9_3,
FeatureLevel.Level_9_2,
FeatureLevel.Level_9_1);
var backBuffer = new Texture2D(
this.d3d11Device,
new Texture2DDescription
{
Height = surfHeight,
Width = surfWidth,
ArraySize = 1,
MipLevels = 1,
Format = Format.B8G8R8A8_UNorm,
SampleDescription = { Count = 1, Quality = 0 },
Usage = ResourceUsage.Default,
OptionFlags = ResourceOptionFlags.Shared,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = 0
});
var surface = backBuffer.QueryInterface<Surface>();
this.renderTarget = new RenderTarget(
this.oxyRenderContext.D2DFactory,
surface,
new RenderTargetProperties(new PixelFormat(Format.Unknown, AlphaMode.Premultiplied)));
this.d3d9Device = new D3D9Device(
new Direct3D(),
0,
D3D9DeviceType.Hardware,
windowHandle,
D3D9CreateFlags.HardwareVertexProcessing | D3D9CreateFlags.Multithreaded | D3D9CreateFlags.FpuPreserve,
new D3D9PresentParameters(surfWidth, surfHeight)
{
PresentationInterval = D3D9PresentInterval.Immediate,
DeviceWindowHandle = windowHandle,
SwapEffect = D3D9SwapEffect.Discard,
Windowed = true
});
this.imageSource = new D3D11Image(this.d3d9Device, backBuffer);
this.oxyRenderContext.ResetRenderTarget(this.renderTarget);
}
/// <summary>
///
/// </summary>
private void StartD3D()
{
this.surfaceD3D = new DX11ImageSource();
this.surfaceD3D.IsFrontBufferAvailableChanged += this.OnIsFrontBufferAvailableChanged;
this.device = EffectsManager.Device;
this.deferredRenderer = new DeferredRenderer();
this.renderRenderable.DeferredRenderer = this.deferredRenderer;
this.CreateAndBindTargets();
this.SetDefaultRenderTargets();
this.Source = this.surfaceD3D;
}
/// <summary>
/// Initializes DirectX rendering resources.
/// </summary>
private void InitRendering()
{
double dpiScale = 1.0; // default value for 96 dpi
var hwndTarget = PresentationSource.FromVisual(this).CompositionTarget as HwndTarget;
if (hwndTarget != null)
{
dpiScale = hwndTarget.TransformToDevice.M11;
}
int surfWidth = (int)(this.viewport.Width < 0 ? 0 : Math.Ceiling(this.viewport.Width * dpiScale));
int surfHeight = (int)(this.viewport.Height < 0 ? 0 : Math.Ceiling(this.viewport.Height * dpiScale));
var windowHandle = (new System.Windows.Interop.WindowInteropHelper(System.Windows.Window.GetWindow(this))).Handle;
this.d3d11Device = new D3D11Device(
DriverType.Hardware,
DeviceCreationFlags.BgraSupport,
FeatureLevel.Level_11_0,
FeatureLevel.Level_10_1,
FeatureLevel.Level_10_0,
FeatureLevel.Level_9_3,
FeatureLevel.Level_9_2,
FeatureLevel.Level_9_1);
var backBuffer = new Texture2D(
this.d3d11Device,
new Texture2DDescription
{
Height = surfHeight,
Width = surfWidth,
ArraySize = 1,
MipLevels = 1,
Format = Format.B8G8R8A8_UNorm,
SampleDescription = { Count = 1, Quality = 0 },
Usage = ResourceUsage.Default,
OptionFlags = ResourceOptionFlags.Shared,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = 0
});
var surface = backBuffer.QueryInterface <Surface>();
this.renderTarget = new RenderTarget(
this.oxyRenderContext.D2DFactory,
surface,
new RenderTargetProperties(new PixelFormat(Format.Unknown, AlphaMode.Premultiplied)));
this.d3d9Device = new D3D9Device(
new Direct3D(),
0,
D3D9DeviceType.Hardware,
windowHandle,
D3D9CreateFlags.HardwareVertexProcessing | D3D9CreateFlags.Multithreaded | D3D9CreateFlags.FpuPreserve,
new D3D9PresentParameters(surfWidth, surfHeight)
{
PresentationInterval = D3D9PresentInterval.Immediate,
DeviceWindowHandle = windowHandle,
SwapEffect = D3D9SwapEffect.Discard,
Windowed = true
});
this.imageSource = new D3D11Image(this.d3d9Device, backBuffer);
this.oxyRenderContext.ResetRenderTarget(this.renderTarget);
}
internal void InitEffects(global::SharpDX.Direct3D11.Device device)
{
this.device = device;
var sFlags = ShaderFlags.None;
var eFlags = EffectFlags.None;
#if DEBUG
sFlags |= ShaderFlags.Debug;
eFlags |= EffectFlags.None;
#endif
try
{
// ------------------------------------------------------------------------------------
#if DX11
RegisterEffect(new StreamReader(@"./Shaders/Tessellation.fx").ReadToEnd(),
#else
RegisterEffect(new StreamReader(@"./Shaders/Default.fx").ReadToEnd(),
#endif
new[]
{
// put here the techniques which you want to use with this effect
Techniques.RenderPhong,
Techniques.RenderBlinn,
Techniques.RenderCubeMap,
Techniques.RenderColors,
Techniques.RenderDiffuse,
Techniques.RenderPositions,
Techniques.RenderNormals,
Techniques.RenderTangents,
Techniques.RenderTexCoords,
Techniques.RenderWires,
#if DX11
Techniques.RenderPNTriangs,
Techniques.RenderPNQuads,
#endif
//Techniques.RenderLines,
Techniques.RenderSpineTest
});
// ------------------------------------------------------------------------------------
//RegisterEffect(new StreamReader(@"./Shaders/Lines.fx").ReadToEnd(), //Properties.Resources.Deferred,
// new[]
//{
// Techniques.RenderLines
//});
// ------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------
/*
RegisterEffect(new StreamReader(@"./Shaders/SpineTest.fx").ReadToEnd(), //Properties.Resources.Deferred,
new[]
{
Techniques.RenderSpineTest
});
*/
// ------------------------------------------------------------------------------------
RegisterEffect(new StreamReader(@"./Shaders/Deferred.fx").ReadToEnd(), //Properties.Resources.Deferred,
new[]
{
Techniques.RenderDeferred,
Techniques.RenderGBuffer,
});
// ------------------------------------------------------------------------------------
RegisterEffect(new StreamReader(@"./Shaders/DeferredLighting.fx").ReadToEnd(),//Properties.Resources.DeferredLighting,
new[]
{
Techniques.RenderDeferredLighting
});
// ------------------------------------------------------------------------------------
RegisterLayout(
new[]
{
// put here techniques which use the vertex layout below
Techniques.RenderPhong,
Techniques.RenderBlinn,
Techniques.RenderDiffuse,
Techniques.RenderPositions,
Techniques.RenderNormals,
Techniques.RenderTangents,
Techniques.RenderTexCoords,
Techniques.RenderColors,
Techniques.RenderWires,
Techniques.RenderDeferred,
Techniques.RenderGBuffer,
},
new InputLayout(device, this[Techniques.RenderPhong].GetTechniqueByName(Techniques.RenderPhong).GetPassByIndex(0).Description.Signature,
new[]
{
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
new InputElement("COLOR", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
new InputElement("TEXCOORD", 0, Format.R32G32_Float, InputElement.AppendAligned, 0),
new InputElement("NORMAL", 0, Format.R32G32B32_Float, InputElement.AppendAligned, 0),
new InputElement("TANGENT", 0, Format.R32G32B32_Float, InputElement.AppendAligned, 0),
new InputElement("BINORMAL", 0, Format.R32G32B32_Float, InputElement.AppendAligned, 0),
//INSTANCING: die 4 texcoords sind die matrix, die mit jedem buffer reinwandern
new InputElement("TEXCOORD", 1, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
new InputElement("TEXCOORD", 2, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
new InputElement("TEXCOORD", 3, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
new InputElement("TEXCOORD", 4, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
}));
#if DX11
// ------------------------------------------------------------------------------------
var layout = new InputLayout(device, this[Techniques.RenderPNTriangs].GetTechniqueByName(Techniques.RenderPNTriangs).GetPassByIndex(0).Description.Signature,
new[]
{
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
new InputElement("COLOR", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
new InputElement("TEXCOORD", 0, Format.R32G32_Float, InputElement.AppendAligned, 0),
new InputElement("NORMAL", 0, Format.R32G32B32_Float, InputElement.AppendAligned, 0),
new InputElement("TANGENT", 0, Format.R32G32B32_Float, InputElement.AppendAligned, 0),
new InputElement("BINORMAL", 0, Format.R32G32B32_Float, InputElement.AppendAligned, 0),
});
RegisterLayout(
new[]
{
// put here techniques which use the vertex layout below
Techniques.RenderPNTriangs,
Techniques.RenderPNQuads,
},
layout
);
#endif
// ------------------------------------------------------------------------------------
RegisterLayout(
new[]
{
Techniques.RenderCubeMap,
Techniques.RenderDeferredLighting
},
new InputLayout(device, this[Techniques.RenderCubeMap].GetTechniqueByName(Techniques.RenderCubeMap).GetPassByIndex(0).Description.Signature, new[]
{
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
}));
// ------------------------------------------------------------------------------------
RegisterLayout(
new[]
{
//Techniques.RenderLines,
Techniques.RenderSpineTest
},
new InputLayout(device, this[Techniques.RenderSpineTest].GetTechniqueByName(Techniques.RenderSpineTest).GetPassByIndex(0).Description.Signature, new[]
{
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
new InputElement("COLOR", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
//INSTANCING: die 4 texcoords sind die matrix, die mit jedem buffer reinwandern
new InputElement("TEXCOORD", 1, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
new InputElement("TEXCOORD", 2, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
new InputElement("TEXCOORD", 3, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
new InputElement("TEXCOORD", 4, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
}));
// ------------------------------------------------------------------------------------
/*
RegisterLayout(
new[]
{
Techniques.RenderSpineTest
},
new InputLayout(device, this[Techniques.RenderSpineTest].GetTechniqueByName(Techniques.RenderSpineTest).GetPassByIndex(0).Description.Signature, new[]
{
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
new InputElement("COLOR", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
//INSTANCING: die 4 texcoords sind die matrix, die mit jedem buffer reinwandern
new InputElement("TEXCOORD", 1, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
new InputElement("TEXCOORD", 2, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
new InputElement("TEXCOORD", 3, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
new InputElement("TEXCOORD", 4, Format.R32G32B32A32_Float, InputElement.AppendAligned, 1, InputClassification.PerInstanceData, 1),
}));
* */
}
catch (Exception ex)
{
System.Windows.MessageBox.Show(string.Format("Error registering effect: {0}", ex.Message), "Error");
}
}
/// <summary>
/// Create buffer
/// </summary>
public static Direct3D11.Buffer CreateBuffer <T>(this Direct3D11.Device device, BindFlags flags, int sizeofT, T[] range)
where T : struct
{
return(CreateBuffer <T>(device, flags, sizeofT, range, range.Length));
}
/// <summary>
///
/// </summary>
private void StartD3D()
{
surfaceD3D = new DX11ImageSource();
surfaceD3D.IsFrontBufferAvailableChanged += OnIsFrontBufferAvailableChanged;
device = EffectsManager.Device;
deferredRenderer = new DeferredRenderer();
renderRenderable.DeferredRenderer = deferredRenderer;
CreateAndBindTargets();
SetDefaultRenderTargets();
Source = surfaceD3D;
InvalidateRender();
}
/// <summary>
/// Free used resources.
/// </summary>
private void CleanResources()
{
this.oxyRenderContext.ResetRenderTarget(null);
this.d3d11Device?.ImmediateContext.ClearState();
this.d3d11Device?.ImmediateContext.Flush();
this.imageSource?.Dispose();
this.d3d9Device?.Dispose();
this.renderTarget?.Dispose();
this.d3d11Device?.Dispose();
this.imageSource = null;
this.d3d9Device = null;
this.renderTarget = null;
this.d3d11Device = null;
}
