public ShadowMap(
VisionContent vContent,
int width,
int height,
int nearPlane = 1,
int farPlane = 200)
{
_graphicsDevice = vContent.GraphicsDevice;
ShadowDepthTarget = RenderTarget2D.New(_graphicsDevice, width, height, PixelFormat.R16G16.Float);
DepthStencilTarget = DepthStencilBuffer.New(_graphicsDevice, width, height, DepthFormat.Depth16);
_spriteBatch = new SpriteBatch(_graphicsDevice);
_shadowBlurEffect = vContent.LoadEffect("Effects/Blur");
_shadowBlurEffect.Parameters["dx"].SetValue(1f/width);
_shadowBlurEffect.Parameters["dy"].SetValue(1f/height);
_shadowBlurTarg = RenderTarget2D.New(_graphicsDevice, width, height, PixelFormat.R16G16.Float);
ShadowNearPlane = nearPlane;
ShadowFarPlane = farPlane;
Camera = new Camera(
new Vector2(width, height),
Vector3.Zero,
Vector3.Up,
ShadowNearPlane,
ShadowFarPlane);
UpdateProjection(60, 60);
}
public ShadowMap(
VisionContent vContent,
Camera camera,
int width,
int height,
int nearPlane = 1,
int farPlane = 200)
{
_graphicsDevice = vContent.GraphicsDevice;
RealCamera = camera;
ShadowDepthTarget = RenderTarget2D.New(_graphicsDevice, width, height, PixelFormat.R16G16.Float);
_spriteBatch = new SpriteBatch(_graphicsDevice);
_shadowBlurEffect = vContent.LoadPlainEffect("ShadowEffects/Blur");
_shadowBlurTarg = RenderTarget2D.New(_graphicsDevice, width, height, PixelFormat.R16G16.Float);
ShadowNearPlane = nearPlane;
ShadowFarPlane = farPlane;
Camera = new Camera(
new Vector2(width, height),
Vector3.Zero,
Vector3.Up,
ShadowNearPlane,
ShadowFarPlane);
UpdateProjection(50, 50);
}
public GraphicsDeviceService()
{
System.Windows.Forms.Control control = new System.Windows.Forms.Panel();
deviceInformation = new GraphicsDeviceInformation()
{
GraphicsProfile = FeatureLevel.Level_11_0,
DeviceCreationFlags = SharpDX.Direct3D11.DeviceCreationFlags.Debug,
PresentationParameters = new PresentationParameters()
{
BackBufferFormat = SharpDX.DXGI.Format.R8G8B8A8_UNorm,
DepthStencilFormat = DepthFormat.Depth32,
DepthBufferShaderResource = true,
BackBufferWidth = 1920,
BackBufferHeight = 1080,
IsFullScreen = false,
RenderTargetUsage = SharpDX.DXGI.Usage.RenderTargetOutput,
MultiSampleCount = MSAALevel.None,
DeviceWindowHandle = control
}
};
FindAdapter();
graphicsDevice = GraphicsDevice.New(deviceInformation.Adapter, deviceInformation.DeviceCreationFlags);
renderTarget = RenderTarget2D.New(graphicsDevice, 1920, 1080, PixelFormat.B8G8R8A8.UNorm);
graphicsDevice.Presenter = new RenderTargetGraphicsPresenter(graphicsDevice, renderTarget, DepthFormat.Depth32, false);
dxDevice = (Device)typeof(GraphicsDevice).GetField("Device", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(GraphicsDevice);
dxContext = (DeviceContext)typeof(GraphicsDevice).GetField("Context", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(GraphicsDevice);
if (DeviceCreated != null)
DeviceCreated(this, EventArgs.Empty);
}
public RenderTargetGraphicsPresenter(GraphicsDevice device, RenderTarget2D renderTarget, DepthFormat depthFormat = DepthFormat.None)
: base(device, CreatePresentationParameters(renderTarget, depthFormat))
{
PresentInterval = Description.PresentationInterval;
// Initialize the swap chain
backBuffer = renderTarget;
}
public RenderTargetGraphicsPresenter(GraphicsDevice device, RenderTarget2D backBuffer, DepthFormat depthFormat = DepthFormat.None, bool disposeRenderTarget = false, bool depthAsShaderResource = false)
: base(device, CreatePresentationParameters(backBuffer, depthFormat, depthAsShaderResource))
{
PresentInterval = Description.PresentationInterval;
this.backBuffer = backBuffer;
if (disposeRenderTarget)
ToDispose(this.backBuffer);
}
public SwapChainGraphicsPresenter(GraphicsDevice device, PresentationParameters presentationParameters)
: base(device, presentationParameters)
{
PresentInterval = presentationParameters.PresentationInterval;
// Initialize the swap chain
swapChain = ToDispose(CreateSwapChain());
backBuffer = ToDispose(RenderTarget2D.New(device, swapChain.GetBackBuffer<Direct3D11.Texture2D>(0)));
}
public RenderTargetGraphicsPresenter(GraphicsDevice device, Texture2DDescription renderTargetDescription, DepthFormat depthFormat = DepthFormat.None, bool allowFormatChange = true, bool disposeRenderTarget = false, bool depthAsShaderResource = false)
: base(device, CreatePresentationParameters(renderTargetDescription, depthFormat, depthAsShaderResource))
{
PresentInterval = Description.PresentationInterval;
this.renderTargetDescription = renderTargetDescription;
this.allowFormatChange = allowFormatChange;
allowRecreateBackBuffer = true;
backBuffer = RenderTarget2D.New(device, renderTargetDescription);
if (disposeRenderTarget)
ToDispose(backBuffer);
}
private static PresentationParameters CreatePresentationParameters(RenderTarget2D renderTarget2D)
{
return new PresentationParameters()
{
BackBufferWidth = renderTarget2D.Width,
BackBufferHeight = renderTarget2D.Height,
BackBufferFormat = renderTarget2D.Description.Format,
DeviceWindowHandle = renderTarget2D,
Flags = SwapChainFlags.None,
IsFullScreen = true,
MultiSampleCount = MSAALevel.None,
PresentationInterval = PresentInterval.One,
RefreshRate = new Rational(60, 1),
RenderTargetUsage = Usage.RenderTargetOutput
};
}
public DXImageSource(GraphicsDevice graphics, int width, int height)
{
if (width < 10) width = 10;
if (height < 10) height = 10;
_renderTarget = RenderTarget2D.New(graphics, width, height, SharpDX.Toolkit.Graphics.PixelFormat.B8G8R8A8.UNorm);
_renderTargetView = new RenderTargetView(graphics, (SharpDX.Toolkit.Graphics.GraphicsResource)_renderTarget);
SharpDX.Direct3D11.Texture2D depthBuffer = new SharpDX.Direct3D11.Texture2D(graphics, new Texture2DDescription()
{
Format = SharpDX.DXGI.Format.D24_UNorm_S8_UInt,
ArraySize=1,
MipLevels=0,
Width = width,
Height = height,
SampleDescription = new SharpDX.DXGI.SampleDescription(1,0),
BindFlags = SharpDX.Direct3D11.BindFlags.DepthStencil
});
//_depthStencilBuffer = DepthStencilBuffer.New(graphics,width,height,DepthFormat.Depth24Stencil8);
_depthStencilView = new DepthStencilView(graphics, depthBuffer);
Texture2DDescription description = new Texture2DDescription()
{
Width = width,
Height = height,
MipLevels = 1,
ArraySize = 1,
Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm,
BindFlags = BindFlags.None,
CpuAccessFlags = CpuAccessFlags.Read,
SampleDescription = new SharpDX.DXGI.SampleDescription()
{
Count = 1,
Quality = 0
},
Usage = ResourceUsage.Staging,
OptionFlags = ResourceOptionFlags.None
};
_stagingTexture = SharpDX.Toolkit.Graphics.Texture2D.New(graphics, description);
_buffer = new byte[width * height * 4];
_writeableBitmap = new WriteableBitmap(
width, height, 96, 96, PixelFormats.Bgr32, null);
}
public WarpSceneRenderer(Scene scene, int width, int height)
{
_scene = scene;
_width = width;
_height = height;
_aspectRatio = width / (float)height;
_device = GraphicsDevice.New(DriverType.Warp, DeviceCreationFlags.None, FeatureLevel.Level_10_1);
var serviceProvider = new ServiceProvider();
serviceProvider.AddService<IGraphicsDeviceService>(new GraphicsDeviceService(_device));
_contentManager = new ContentManager(serviceProvider);
_contentManager.Resolvers.Add(new ContentResolver());
var viewport = new Viewport(0, 0, _width, _height);
_device.SetViewports(viewport);
const MSAALevel msaaLevel = MSAALevel.None;
_depthStencilTexture = DepthStencilBuffer.New(_device, _width, _height, msaaLevel, DepthFormat.Depth24Stencil8);
_renderTexture = RenderTarget2D.New(_device, _width, _height, msaaLevel, PixelFormat.R8G8B8A8.UNorm);
Options = new RenderOptions();
_effect = new BasicEffect(_device);
_effect.EnableDefaultLighting();
_inputLayout = VertexInputLayout.New(0, typeof(VertexPositionNormalTexture));
_device.SetVertexInputLayout(_inputLayout);
_meshes = new List<WarpMesh>();
foreach (Mesh mesh in _scene.Meshes)
{
if (!mesh.Positions.Any())
continue;
var warpMesh = new WarpMesh(_device, mesh);
_meshes.Add(warpMesh);
warpMesh.Initialize(_contentManager);
}
}
public unsafe void Commit(RenderTarget2D renderTarget)
{
if (resizing)
return;
recreateStagingResourcesIfNeeded(renderTarget);
renderTarget.GetData(_stagingTexture, _buffer);
Application.Current.Dispatcher.Invoke(new Action(delegate
{
_writeableBitmap.Lock();
fixed (byte* buffer = _buffer)
{
SharpDX.Utilities.CopyMemory(_writeableBitmap.BackBuffer, new IntPtr(buffer), _buffer.Length);
}
_writeableBitmap.AddDirtyRect(new Int32Rect(0, 0, _stagingTexture.Width, _stagingTexture.Height));
_writeableBitmap.Unlock();
}));
}
public void Render(VideoBuffer videoBuffer)
{
if(GraphicsDevice == null)
{
return;
}
if (RenderTarget2D == null)
{
RenderTarget2D = RenderTarget2D.New(GraphicsDevice, videoBuffer.Width, videoBuffer.Height, PixelFormat.B8G8R8A8.UNorm);
}
else if (RenderTarget2D != null && (RenderTarget2D.Width != videoBuffer.Width || RenderTarget2D.Height != videoBuffer.Height))
{
RenderTarget2D.Dispose();
RenderTarget2D = null;
RenderTarget2D = RenderTarget2D.New(GraphicsDevice, videoBuffer.Width, videoBuffer.Height, PixelFormat.B8G8R8A8.UNorm);
}
if (RenderTarget2D != null)
{
var x = 0;
var data = videoBuffer.Plane.Data;
var argb = new int[videoBuffer.Width * videoBuffer.Height];
for (var i = 0; i < argb.Length; i++)
{
var r = data[x++];
var g = data[x++];
var b = data[x++];
var a = data[x++];
argb[i] = ((a & 0xFF) << 24) |
((r & 0xFF) << 16) |
((g & 0xFF) << 8) |
((b & 0xFF) << 0);
}
RenderTarget2D.SetData<int>(argb);
}
}
public void SetBackBuffer(RenderTarget2D backBuffer)
{
this.backBuffer = backBuffer;
}
protected override void Initialize()
{
keyMgr.Initialize();
// Modify the title of the window
Window.Title = "RiftGame";
// Attach HMD to window
var control = (RenderForm)Window.NativeWindow;
control.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
control.StartPosition = System.Windows.Forms.FormStartPosition.Manual;
control.DesktopLocation = new System.Drawing.Point(0, 0);
hmd.AttachToWindow(control.Handle);
// Create our render target
//var renderTargetSize = hmd.GetDefaultRenderTargetSize(1.5f);
var renderTargetSize = hmd.GetDefaultRenderTargetSize();
renderTarget = RenderTarget2D.New(GraphicsDevice, renderTargetSize.Width, renderTargetSize.Height, new MipMapCount(1), PixelFormat.R8G8B8A8.UNorm, TextureFlags.RenderTarget | TextureFlags.ShaderResource);
renderTargetView = (RenderTargetView)renderTarget;
renderTargetSRView = (ShaderResourceView)renderTarget;
// Create a depth stencil buffer for our render target
depthStencilBuffer = DepthStencilBuffer.New(GraphicsDevice, renderTargetSize.Width, renderTargetSize.Height, DepthFormat.Depth32, true);
// Adjust render target size if there were any hardware limitations
renderTargetSize.Width = renderTarget.Width;
renderTargetSize.Height = renderTarget.Height;
// The viewport sizes are re-computed in case renderTargetSize changed
eyeRenderViewport = new Rect[2];
eyeRenderViewport[0] = new Rect(0, 0, renderTargetSize.Width / 2, renderTargetSize.Height);
eyeRenderViewport[1] = new Rect((renderTargetSize.Width + 1) / 2, 0, eyeRenderViewport[0].Width, eyeRenderViewport[0].Height);
// Create our eye texture data
eyeTexture = new D3D11TextureData[2];
eyeTexture[0].Header.API = RenderAPIType.D3D11;
eyeTexture[0].Header.TextureSize = renderTargetSize;
eyeTexture[0].Header.RenderViewport = eyeRenderViewport[0];
eyeTexture[0].pTexture = ((SharpDX.Direct3D11.Texture2D)renderTarget).NativePointer;
eyeTexture[0].pSRView = renderTargetSRView.NativePointer;
// Right eye uses the same texture, but different rendering viewport
eyeTexture[1] = eyeTexture[0];
eyeTexture[1].Header.RenderViewport = eyeRenderViewport[1];
// Configure d3d11
var device = (SharpDX.Direct3D11.Device)GraphicsDevice;
D3D11ConfigData d3d11cfg = new D3D11ConfigData();
d3d11cfg.Header.API = RenderAPIType.D3D11;
d3d11cfg.Header.BackBufferSize = hmd.Resolution;
d3d11cfg.Header.Multisample = 1;
d3d11cfg.pDevice = device.NativePointer;
d3d11cfg.pDeviceContext = device.ImmediateContext.NativePointer;
d3d11cfg.pBackBufferRT = ((RenderTargetView)GraphicsDevice.BackBuffer).NativePointer;
d3d11cfg.pSwapChain = ((SharpDX.DXGI.SwapChain)GraphicsDevice.Presenter.NativePresenter).NativePointer;
// Configure rendering
eyeRenderDesc = new EyeRenderDesc[2];
if (!hmd.ConfigureRendering(d3d11cfg, DistortionCapabilities.Chromatic | DistortionCapabilities.TimeWarp, hmd.DefaultEyeFov, eyeRenderDesc))
{
throw new Exception("Failed to configure rendering");
}
// Set enabled capabilities
hmd.EnabledCaps = HMDCapabilities.LowPersistence | HMDCapabilities.DynamicPrediction;
// Configure tracking
hmd.ConfigureTracking(TrackingCapabilities.Orientation | TrackingCapabilities.Position | TrackingCapabilities.MagYawCorrection, TrackingCapabilities.None);
// Dismiss the Heatlh and Safety Window
hmd.EnableHSWDisplaySDKRender(false);
hmd.DismissHSWDisplay();
// Get HMD output
var adapter = (Adapter)GraphicsDevice.Adapter;
var hmdOutput = adapter.Outputs.FirstOrDefault(o => hmd.DeviceName.StartsWith(o.Description.DeviceName, StringComparison.OrdinalIgnoreCase));
if (hmdOutput != null)
{
control.DesktopLocation = new System.Drawing.Point(hmdOutput.Description.DesktopBounds.Left, hmdOutput.Description.DesktopBounds.Top);
//Window.BeginScreenDeviceChange(true);
// Set game to fullscreen on rift
//var swapChain = (SwapChain)GraphicsDevice.Presenter.NativePresenter;
//var description = swapChain.Description.ModeDescription;
//swapChain.ResizeTarget(ref description);
//swapChain.SetFullscreenState(true, hmdOutput);
//Window.EndScreenDeviceChange();
}
sprite = new SpriteBatch(this.GraphicsDevice);
position = new Vector2(hmd.Resolution.Width / 2, hmd.Resolution.Height / 2);
capture = OpenCV.Net.Capture.CreateCameraCapture(0);
_form = new RenderForm("Normal");
// SwapChain description
var desc = new SwapChainDescription()
{
BufferCount = 1,
ModeDescription =
new ModeDescription(_form.ClientSize.Width, _form.ClientSize.Height,
new Rational(60, 1), Format.R8G8B8A8_UNorm),
IsWindowed = true,
OutputHandle = _form.Handle,
SampleDescription = new SampleDescription(1, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput | Usage.ShaderInput | Usage.BackBuffer
};
// Used for debugging dispose object references
// Configuration.EnableObjectTracking = true;
// Disable throws on shader compilation errors
//Configuration.ThrowOnShaderCompileError = false;
// Create Device and SwapChain
SharpDX.Direct3D11.Device.CreateWithSwapChain(SharpDX.Direct3D.DriverType.Hardware, DeviceCreationFlags.None, desc, out _device, out _swapChain);
_context = _device.ImmediateContext;
_gdevice = GraphicsDevice.New(_device);
_renderTarget = RenderTarget2D.New(_gdevice, renderTargetSize.Width, renderTargetSize.Height, new MipMapCount(1), PixelFormat.R8G8B8A8.UNorm, TextureFlags.RenderTarget | TextureFlags.ShaderResource);
_depthStencilBuffer = DepthStencilBuffer.New(_gdevice, renderTargetSize.Width, renderTargetSize.Height, DepthFormat.Depth32, true);
_sprite = new SpriteBatch(_gdevice);
_swapChain.GetParent<Factory>().MakeWindowAssociation(_form.Handle, WindowAssociationFlags.IgnoreAll);
var backBuffer = SharpDX.Direct3D11.Texture2D.FromSwapChain<SharpDX.Direct3D11.Texture2D>(_swapChain, 0);
// Renderview on the backbuffer
_renderView = new RenderTargetView(_device, backBuffer);
// Create the depth buffer
var depthBuffer = new SharpDX.Direct3D11.Texture2D(_device, new Texture2DDescription()
{
Format = Format.D32_Float_S8X24_UInt,
ArraySize = 1,
MipLevels = 1,
Width = _form.ClientSize.Width,
Height = _form.ClientSize.Height,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
});
// Create the depth buffer view
_depthView = new DepthStencilView(_device, depthBuffer);
model = null;
_model = null;
base.Initialize();
}
public void Build(RenderTarget2D renderTarget)
{
renderTarget.GetData(_stagingTexture, _buffer);
_writeableBitmap.Lock();
Marshal.Copy(_buffer, 0, _writeableBitmap.BackBuffer, _buffer.Length);
_writeableBitmap.AddDirtyRect(new Int32Rect(0, 0, _renderTarget.Width, _renderTarget.Height));
_writeableBitmap.Unlock();
}
void IDrawingSurfaceContentProviderNative.GetTexture(DrawingSizeF surfaceSize, out DrawingSurfaceSynchronizedTexture synchronizedTexture, out RectangleF textureSubRectangle)
{
try
{
if (!Exiting)
{
if (GraphicsDevice == null)
{
GraphicsDevice = GraphicsDevice.New();
var renderTargetDesc = new Texture2DDescription
{
Format = DXGI.Format.B8G8R8A8_UNorm,
Width = (int)surfaceSize.Width,
Height = (int)surfaceSize.Height,
ArraySize = 1,
MipLevels = 1,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
Usage = ResourceUsage.Default,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.SharedKeyedmutex | ResourceOptionFlags.SharedNthandle,
SampleDescription = new DXGI.SampleDescription(1, 0)
};
renderTarget = ToDispose(Graphics.Texture2D.New(GraphicsDevice, renderTargetDesc));
BackBuffer = ToDispose(RenderTarget2D.New(GraphicsDevice, new RenderTargetView(GraphicsDevice, renderTarget)));
graphicsPresenter = new RenderTargetGraphicsPresenter(GraphicsDevice, BackBuffer);
GraphicsDevice.Presenter = graphicsPresenter;
InitCallback();
}
if(this.synchronizedTexture == null)
this.synchronizedTexture = host.CreateSynchronizedTexture((Texture2D)renderTarget);
this.synchronizedTexture.BeginDraw();
RunCallback();
host.RequestAdditionalFrame();
this.synchronizedTexture.EndDraw();
}
}
catch (Exception ex)
{
// TODO: As we are in a callback from a native code, we cannot pass back this exception,
// so how to pass back this exception to the user at an appropriate time?
drawException = ex;
Debug.WriteLine(drawException);
}
// Set output parameters.
textureSubRectangle = new RectangleF(0f, 0f, surfaceSize.Width, surfaceSize.Height);
synchronizedTexture = this.synchronizedTexture;
}
private void GenerateMaxMap(RenderTarget2D texture, GraphicsDevice graphicsDevice)
{
// Save old render setup to restore later.
SharpDX.Direct3D11.DepthStencilView depthStencilBefore;
var renderTargetsBefore = graphicsDevice.GetRenderTargets(out depthStencilBefore);
ViewportF oldViewport = graphicsDevice.GetViewport(0);
numHeightmapMipLevels = 0;
var currentWidth = texture.Width / 2;
var currentHeight = texture.Height / 2;
for (var mipLevel = 1; currentWidth > 0 && currentHeight > 0; ++mipLevel, currentWidth /= 2, currentHeight /= 2)
{
// Generate sampler on-the-fly.
var samplerStateDesc = SharpDX.Direct3D11.SamplerStateDescription.Default();
samplerStateDesc.AddressV = SharpDX.Direct3D11.TextureAddressMode.Clamp;
samplerStateDesc.AddressU = SharpDX.Direct3D11.TextureAddressMode.Clamp;
samplerStateDesc.Filter = SharpDX.Direct3D11.Filter.MinMagMipPoint;
samplerStateDesc.MinimumLod = mipLevel-1;
samplerStateDesc.MaximumLod = mipLevel-1;
samplerStateDesc.MipLodBias = mipLevel-1;
var mipLevelSamplerState = SamplerState.New(graphicsDevice, "MipLevelSampler_" + mipLevel, samplerStateDesc);
// Draw.
maxmapGenShader.Effect.Parameters["NearestSampler"].SetResource(mipLevelSamplerState);
maxmapGenShader.Effect.Parameters["InputTexture"].SetResource(texture.ShaderResourceView[ViewType.Single, 0, mipLevel-1]);
graphicsDevice.SetRenderTargets(texture.RenderTargetView[ViewType.Single, 0, mipLevel]);
graphicsDevice.SetViewport(0, 0, currentWidth, currentHeight);
maxmapGenShader.Effect.CurrentTechnique.Passes[0].Apply();
graphicsDevice.Draw(PrimitiveType.PointList, 1);
maxmapGenShader.Effect.CurrentTechnique.Passes[0].UnApply();
++numHeightmapMipLevels;
}
graphicsDevice.SetRenderTargets(depthStencilBefore, renderTargetsBefore);
graphicsDevice.SetViewport(oldViewport);
}
public void Resize(int width, int height)
{
renderTarget.Dispose();
graphicsDevice.Presenter.Dispose();
renderTarget = RenderTarget2D.New(graphicsDevice, width, height, PixelFormat.B8G8R8A8.UNorm);
graphicsDevice.Presenter = new RenderTargetGraphicsPresenter(graphicsDevice, renderTarget, DepthFormat.Depth24Stencil8, false);
}
public override bool Resize(int width, int height, Format format)
{
if (!base.Resize(width, height, format)) return false;
RemoveAndDispose(ref backBuffer);
swapChain.ResizeBuffers(bufferCount, width, height, format, Description.Flags);
// Recreate the back buffer
backBuffer = ToDispose(RenderTarget2D.New(GraphicsDevice, swapChain.GetBackBuffer<Direct3D11.Texture2D>(0)));
// Reinit the Viewport
DefaultViewport = new ViewportF(0, 0, backBuffer.Width, backBuffer.Height);
return true;
}
private void HandleDeviceChangeEnd(object sender, EventArgs e)
{
var device = _graphicsDeviceManager.GraphicsDevice;
var swapChain = (SwapChain)device.Presenter.NativePresenter;
var d = swapChain.Description;
var d3DDevice = (SharpDX.Direct3D11.Device)device;
using (var dxgiDevice = d3DDevice.QueryInterface<Device3>())
{
var adapter = dxgiDevice.Adapter;
var factory = adapter.GetParent<Factory2>();
var description = new SwapChainDescription1
{
Width = d.ModeDescription.Width,
Height = d.ModeDescription.Height,
Format = d.ModeDescription.Format,
Stereo = false,
SampleDescription = new SampleDescription(1, 0),
Usage = Usage.RenderTargetOutput,
BufferCount = 2,
SwapEffect = SwapEffect.FlipSequential,
Flags = SwapChainFlags.ForegroundLayer,
Scaling = Scaling.None,
AlphaMode = AlphaMode.Premultiplied
};
// create the foreground swap chain for the core window
using (var comWindow = new ComObject(Window.NativeWindow))
_foregroundChain = new SwapChain1(factory, (SharpDX.Direct3D11.Device)device, comWindow, ref description);
// recreate the foreground render target
using (var backBuffer = _foregroundChain.GetBackBuffer<SharpDX.Direct3D11.Texture2D>(0))
_foregroundRenderTarget = RenderTarget2D.New(device, backBuffer);
}
}
void IDrawingSurfaceBackgroundContentProviderNative.Draw(Device device, DeviceContext context, RenderTargetView renderTargetView)
{
try
{
RenderTarget2D localBackBuffer = null;
if (!Exiting)
{
if (GraphicsDevice == null)
{
GraphicsDevice = GraphicsDevice.New(device);
renderTargets[0].NativePointer = renderTargetView.NativePointer;
renderTargets[0].RenderTarget = RenderTarget2D.New(GraphicsDevice, renderTargetView, true);
BackBuffer = renderTargets[0].RenderTarget;
nextRenderTarget++;
graphicsPresenter = new RenderTargetGraphicsPresenter(GraphicsDevice, BackBuffer);
GraphicsDevice.Presenter = graphicsPresenter;
initCallback();
}
else
{
if (((Direct3D11.Device)GraphicsDevice).NativePointer != device.NativePointer || ((Direct3D11.DeviceContext)GraphicsDevice).NativePointer != context.NativePointer)
{
System.Diagnostics.Debugger.Break();
}
// Find any previous render target that was already alocated.
bool foundRenderTarget = false;
foreach (var renderTargetLocal in renderTargets)
{
if (renderTargetLocal.NativePointer == renderTargetView.NativePointer)
{
BackBuffer = renderTargetLocal.RenderTarget;
graphicsPresenter.SetBackBuffer(BackBuffer);
foundRenderTarget = true;
break;
}
}
if (!foundRenderTarget)
{
// Dispose any previous render target.
renderTargets[nextRenderTarget].Dispose();
// Creates the new BackBuffer and associated it to the GraphicsPresenter
BackBuffer = RenderTarget2D.New(GraphicsDevice, renderTargetView, true);
graphicsPresenter.SetBackBuffer(BackBuffer);
renderTargets[nextRenderTarget].NativePointer = renderTargetView.NativePointer;
renderTargets[nextRenderTarget].RenderTarget = BackBuffer;
nextRenderTarget++;
}
// TODO: Check that new device/devicecontext/renderTargetView are the same
// else we need to handle DeviceReset/Remove...etc.
}
tickCallback();
// Aks the host for additional frame
host.RequestAdditionalFrame();
}
} catch (Exception ex)
{
// System.Diagnostics.Debugger.Break();
}
}
protected override void LoadContent()
{
// Instantiate a SpriteBatch
spriteBatch = ToDisposeContent(new SpriteBatch(GraphicsDevice));
// Loads a sprite font
// The [Arial16.xml] file is defined with the build action [ToolkitFont] in the project
arial16Font = Content.Load<SpriteFont>("Arial16");
// Creates a basic effect
basicEffect = ToDisposeContent(new BasicEffect(GraphicsDevice));
basicEffect.DiffuseColor = Color.OrangeRed.ToVector4();
basicEffect.PreferPerPixelLighting = true;
basicEffect.EnableDefaultLighting();
// Creates torus primitive
sphere = ToDisposeContent(GeometricPrimitive.Sphere.New(GraphicsDevice, 1.75f));
pixelTexture = Texture2D.New(GraphicsDevice, 1, 1, GraphicsDevice.BackBuffer.Format);
pixelTexture.SetData<Color>(new Color[] { Color.Green });
occlusionQuery = new OcclusionQuery(GraphicsDevice);
offscreenBuffer = RenderTarget2D.New(GraphicsDevice, 128, 128, GraphicsDevice.BackBuffer.Format);
base.LoadContent();
}
private void blurShadow(RenderTarget2D to, RenderTarget2D from)
{
_graphicsDevice.SetRenderTargets(to);
_graphicsDevice.Clear(Color.Black);
_shadowBlurEffect.Apply();
_spriteBatch.Begin(SpriteSortMode.Deferred, _shadowBlurEffect.Effect);
_spriteBatch.Draw(from, Vector2.Zero, Color.White);
_spriteBatch.End();
_shadowBlurEffect.Texture = null;
}
public override bool Resize(int width, int height, Format format, Rational? refreshRate = null)
{
if (!base.Resize(width, height, format, refreshRate)) return false;
RemoveAndDispose(ref backBuffer);
#if DIRECTX11_2 && WIN8METRO
var swapChainPanel = Description.DeviceWindowHandle as SwapChainPanel;
if (swapChainPanel != null && swapChain2 != null)
{
swapChain2.MatrixTransform = Matrix3x2.Scaling(1f / swapChainPanel.CompositionScaleX, 1f / swapChainPanel.CompositionScaleY);
}
#endif
swapChain.ResizeBuffers(bufferCount, width, height, format, Description.Flags);
// Recreate the back buffer
backBuffer = ToDispose(RenderTarget2D.New(GraphicsDevice, swapChain.GetBackBuffer<Direct3D11.Texture2D>(0)));
// Reinit the Viewport
DefaultViewport = new ViewportF(0, 0, backBuffer.Width, backBuffer.Height);
return true;
}
public override bool Resize(int width, int height, Format format)
{
if (!base.Resize(width, height, format)) return false;
// backbuffer was set externally, do not touch it
if (!allowRecreateBackBuffer) return false;
renderTargetDescription.Width = width;
renderTargetDescription.Height = height;
if (allowFormatChange)
renderTargetDescription.Format = format;
if (backBuffer != null)
{
RemoveAndDispose(ref backBuffer);
backBuffer = RenderTarget2D.New(GraphicsDevice, renderTargetDescription);
}
return true;
}
/// <summary>
/// Creates a <see cref="RenderTargetGraphicsPresenter" /> if not already created based from latest internal device.
/// </summary>
/// <param name="resetPresenter">if set to <c>true</c> [reset presenter].</param>
internal void EnsurePresenter(bool resetPresenter)
{
// Find any previous render target that was already allocated.
if (!resetPresenter)
{
foreach (RenderTargetLocal renderTargetLocal in renderTargets)
{
if (renderTargetLocal.NativePointer == currentRenderTargetView.NativePointer)
{
backBuffer = renderTargetLocal.RenderTarget;
graphicsPresenter.SetBackBuffer(backBuffer);
return;
}
}
}
// Creates the backbuffer
backBuffer = RenderTarget2D.New(graphicsDevice, currentRenderTargetView, true);
currentRenderTargetView.Tag = backBuffer;
// Dispose any previous render target.
renderTargets[nextRenderTarget].Dispose();
renderTargets[nextRenderTarget].NativePointer = currentRenderTargetView.NativePointer;
renderTargets[nextRenderTarget].RenderTarget = backBuffer;
nextRenderTarget = (nextRenderTarget + 1) % renderTargets.Length;
if (resetPresenter)
{
graphicsPresenter = new RenderTargetGraphicsPresenter(graphicsDevice, backBuffer, RequestDepthFormat);
graphicsDevice.Presenter = graphicsPresenter;
}
graphicsPresenter.SetBackBuffer(backBuffer);
}
private void recreateStagingResourcesIfNeeded(RenderTarget2D renderTarget)
{
if (_stagingTexture.Width != renderTarget.Width || _stagingTexture.Height != renderTarget.Height)
{
_stagingTexture.Dispose();
initResources(renderTarget.Width, renderTarget.Height);
}
}
public override void Resize(int width, int height, Format format)
{
base.Resize(width, height, format);
RemoveAndDispose(ref backBuffer);
swapChain.ResizeBuffers(bufferCount, width, height, format, Description.Flags);
// Recreate the back buffer
backBuffer = ToDispose(RenderTarget2D.New(GraphicsDevice, swapChain.GetBackBuffer<Direct3D11.Texture2D>(0)));
}
public WaterSurface(
GraphicsDevice graphicsDevice,
InitInfo initInfo)
{
Effect = new VisionEffect(initInfo.Fx, graphicsDevice.SamplerStates.LinearClamp)
{
SunlightDirection = VisionContent.SunlightDirection - new Vector3(0, VisionContent.SunlightDirection.Y/2, 0)
};
_waveBumpMapVelocity0 = initInfo.waveBumpMapVelocity0;
_waveBumpMapVelocity1 = initInfo.waveBumpMapVelocity1;
_waveDispMapVelocity0 = initInfo.waveDispMapVelocity0;
_waveDispMapVelocity1 = initInfo.waveDispMapVelocity1;
_hiPolyPlane = generatePlane(graphicsDevice, initInfo.SquareSize, initInfo.dx, initInfo.dz,
initInfo.texScale);
_lakePlane = generatePlane(graphicsDevice, 1, initInfo.SquareSize*512, initInfo.SquareSize*512, initInfo.texScale*512);
buildFx(initInfo);
var targetWidth = graphicsDevice.BackBuffer.Width;
var targetHeight = graphicsDevice.BackBuffer.Height;
_reflectionTarget = RenderTarget2D.New(
graphicsDevice,
targetWidth,
targetHeight*11/10, //compensate for displaced waves
graphicsDevice.BackBuffer.Format);
_reflectionCamera = new Camera(
new Vector2(targetWidth, targetHeight),
null,
null,
null,
Vector3.Zero,
Vector3.Up);
Update(10);
}
private void CreateAndBindTargets()
{
if (_device == null)
return;
_d3DSurface.SetRenderTargetDX10(null);
Disposer.RemoveAndDispose(ref _backBuffer);
int width = Math.Max((int) ActualWidth, 100);
int height = Math.Max((int) ActualHeight, 100);
_backBuffer = RenderTarget2D.New(_graphicsDevice, 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
});
_graphicsDevice.Presenter = new RenderTargetGraphicsPresenter(
_graphicsDevice, _backBuffer, DepthFormat.Depth16);
_d3DSurface.SetRenderTargetDX10(_backBuffer);
}
