private void Draw()
{
d3dDeviceContext.ClearRenderTargetView(renderTargetView, new SharpDX.Color(32, 32, 64));
d3dDeviceContext.ClearDepthStencilView(depthStencilView, D3D11.DepthStencilClearFlags.Depth | D3D11.DepthStencilClearFlags.Stencil, 1.0f, 0);
// Camera
var view = Matrix.LookAtLH(freeCamPos, freeCamPos + freeCamLookDir, new Vector3(0, 1, 0));
var proj = Matrix.PerspectiveFovLH(45.0f * TORAD, (float)width / height, 0.1f, 100.0f);
var viewProj = Matrix.Multiply(view, proj);
var binding = new D3D11.VertexBufferBinding(cubeBuffer, Utilities.SizeOf <Vertex>(), 0);
d3dDeviceContext.InputAssembler.SetVertexBuffers(0, binding);
VertexShaderConstants c;
for (int i = 0; i < renderObjects.Count; i++)
{
var o = renderObjects[i];
c.modelViewProj = o.transform * viewProj;
c.modelViewProj.Transpose();
c.color = o.color.ToVector4();
d3dDeviceContext.UpdateSubresource(ref c, constantBuffer);
d3dDeviceContext.Draw(cubeVertices.Count(), 0);
}
swapChain.Present(1, PresentFlags.None);
}
public void ApplyPostEffect(
D3D11.ShaderResourceView sourceRenderTarget,
D3D11.ShaderResourceView sourceDepthStencil,
D3D11.RenderTargetView destRenderTarget,
PostProcessing.PostEffect effect)
{
D3D11.DeviceContext deviceContext = deviceResources.DeviceContext;
// No rendering directly to DepthStencil
deviceContext.OutputMerger.SetRenderTargets(null, destRenderTarget);
deviceContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleStrip;
deviceContext.InputAssembler.InputLayout = effect.Shader.InputLayout;
deviceContext.VertexShader.Set(effect.Shader.VertexShader);
deviceContext.PixelShader.Set(effect.Shader.PixelShader);
deviceContext.PixelShader.SetShaderResource(0, sourceRenderTarget);
deviceContext.PixelShader.SetShaderResource(1, sourceDepthStencil);
deviceContext.PixelShader.SetSampler(0, sampler);
deviceContext.Draw(4, 0);
// Reset
deviceContext.OutputMerger.SetRenderTargets(
renderTargetHandler.GetDepthStencilView(),
renderTargetHandler.GetRenderTargetView()
);
}
public void Run(D3D11.ShaderResourceView srcSRV, D3D11.ShaderResourceView depthSRV, D3D11.RenderTargetView dstRTV, int width, int height, float time)
{
Viewport viewport = new Viewport(0, 0, width, height);
//Viewport viewport = new Viewport(-width/2, -width/2, width*2, height*4);
int positionSize = Utilities.SizeOf <Vector3>();
int texcoordSize = Utilities.SizeOf <Vector2>();
int vertexCount = trianglePositionVertexBuffer.Description.SizeInBytes / positionSize;
deviceContext.InputAssembler.SetVertexBuffers(0, new D3D11.VertexBufferBinding(trianglePositionVertexBuffer, positionSize, 0));
deviceContext.InputAssembler.SetVertexBuffers(1, new D3D11.VertexBufferBinding(triangleTexcoordVertexBuffer, texcoordSize, 0));
deviceContext.InputAssembler.InputLayout = inputLayout;
deviceContext.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.TriangleList;
deviceContext.VertexShader.Set(vertexShader);
deviceContext.PixelShader.Set(pixelShader);
deviceContext.PixelShader.SetSampler(0, samplerState);
deviceContext.PixelShader.SetShaderResource(0, srcSRV);
deviceContext.PixelShader.SetShaderResource(1, depthSRV);
deviceContext.Rasterizer.SetViewport(viewport);
deviceContext.OutputMerger.SetRenderTargets(dstRTV);
UpdateConstantBuffer(time);
deviceContext.Draw(vertexCount, 0);
deviceContext.OutputMerger.SetRenderTargets(null, (D3D11.RenderTargetView)null);
}
private void RenderDots()
{
LoadData();
d3dDeviceContext.OutputMerger.SetRenderTargets(renderTargetView);
d3dDeviceContext.ClearRenderTargetView(renderTargetView, new SharpDX.Color(32, 103, 178));
swapChain.Present(1, PresentFlags.None);
vertexBuffer = D3D11.Buffer.Create <Vector3>(d3dDevice, D3D11.BindFlags.VertexBuffer, dots.ToArray());
//Shader Code
using (var vertexShaderByteCode = ShaderBytecode.CompileFromFile("vertexShader.hlsl", "main", "vs_4_0", ShaderFlags.Debug))
{
vertexShader = new D3D11.VertexShader(d3dDevice, vertexShaderByteCode);
inputSignature = ShaderSignature.GetInputSignature(vertexShaderByteCode);
}
using (var pixelShaderByteCode = ShaderBytecode.CompileFromFile("pixelShader.hlsl", "main", "ps_4_0", ShaderFlags.Debug))
{
pixelShader = new D3D11.PixelShader(d3dDevice, pixelShaderByteCode);
}
inputLayout = new D3D11.InputLayout(d3dDevice, inputSignature, inputElements);
d3dDeviceContext.InputAssembler.InputLayout = inputLayout;
LoadData();
//DRAW
d3dDeviceContext.OutputMerger.SetRenderTargets(renderTargetView);
d3dDeviceContext.ClearRenderTargetView(renderTargetView, new SharpDX.Color(32, 166, 178));
d3dDeviceContext.InputAssembler.SetVertexBuffers(0, new D3D11.VertexBufferBinding(vertexBuffer, Utilities.SizeOf <Vector3>(), 0));
d3dDeviceContext.Draw(dotsArray.Count(), 0);
swapChain.Present(1, PresentFlags.None);
}
public void Draw(Matrix worldViewProjMatrix, D3D11.Texture2D texture)
{
// Set the shaders to use for the draw operation
d3dDeviceContext.VertexShader.Set(vertexShader);
d3dDeviceContext.PixelShader.Set(pixelShader);
// Set the primitive topology to triangle list
d3dDeviceContext.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.TriangleList;
// Set the input layout of the vertices
d3dDeviceContext.InputAssembler.InputLayout = inputLayout;
// Bind the texture resource to the pixel shader
var textureView = new D3D11.ShaderResourceView(d3dDevice, texture);
d3dDeviceContext.PixelShader.SetShaderResource(0, textureView);
d3dDeviceContext.PixelShader.SetSampler(0, samplerState);
textureView.Dispose();
// Pass the world view projection matrix to the vertex shader
d3dDeviceContext.VertexShader.SetConstantBuffer(0, worldViewProjBuffer);
d3dDeviceContext.UpdateSubresource(ref worldViewProjMatrix, worldViewProjBuffer);
// Draw the rectangle
d3dDeviceContext.InputAssembler.SetVertexBuffers(0, new D3D11.VertexBufferBinding(vertexBuffer, Utilities.SizeOf <VertexXYUV>(), 0));
d3dDeviceContext.Draw(numVertices, 0);
}
private void RenderScene()
{
this.deviceContext.OutputMerger.SetRenderTargets(this.backBufferView);
this.deviceContext.ClearRenderTargetView(this.backBufferView, new RawColor4(red, green, blue, 0));
deviceContext.Draw(verts.Length, 0);
this.swapChain.Present(0, DXGI.PresentFlags.None);
}
private void Draw()
{
d3dDeviceContext.OutputMerger.SetRenderTargets(renderTargetView);
d3dDeviceContext.ClearRenderTargetView(renderTargetView, new Color(32, 103, 178));
d3dDeviceContext.InputAssembler.SetVertexBuffers(0, new D3D11.VertexBufferBinding(triangleVertexBuffer, Utilities.SizeOf <Vector3>(), 0));
d3dDeviceContext.Draw(vertices.Count(), 0);
swapChain.Present(1, PresentFlags.None);
}
void Draw()
{
m_d3d11DeviceContext.OutputMerger.SetRenderTargets(m_renderTargetView);
SharpDX.Mathematics.Interop.RawColor4 color = new SharpDX.Mathematics.Interop.RawColor4(32 / (float)255, 103 / (float)255, 178 / (float)255, 1);
m_d3d11DeviceContext.ClearRenderTargetView(m_renderTargetView, color);
m_d3d11DeviceContext.InputAssembler.SetVertexBuffers(0, new D3D11.VertexBufferBinding(m_triangleVertexBuffer, SharpDX.Utilities.SizeOf <VertexPositionColor>(), 0));
m_d3d11DeviceContext.Draw(m_vertices.Count(), 0);
m_swapChain.Present(1, DXGI.PresentFlags.None);
}
public void PresentFrame(MediaFrame frame = null)
{
// Design Mode Only?
if (device == null)
{
return;
}
// Should work better in case of frame delay (to avoid more delay on screamer)
if (Monitor.TryEnter(device, 4))
{
try
{
if (frame != null)
{
// NV12 | P010
if (frame.textureHW != null)
{
PresentNV12P010(frame);
}
// YUV420P
else if (frame.textureY != null)
{
PresentYUV(frame);
}
// RGB
else if (frame.textureRGB != null)
{
PresentRGB(frame);
}
}
context.OutputMerger.SetRenderTargets(rtv);
context.ClearRenderTargetView(rtv, clearColor);
context.Draw(6, 0);
rtv2d.BeginDraw();
try
{
PresentOSD();
} finally {
rtv2d.EndDraw();
}
swapChain.Present(vsync, PresentFlags.None);
} finally { Monitor.Exit(device); }
}
else
{
Console.WriteLine("[RENDERER] Drop Frame - Lock timeout " + (frame != null ? Utils.TicksToTime(frame.timestamp) : "")); player.ClearVideoFrame(frame);
}
}
void OnRender(IntPtr resourcePtr, bool isNewSurface)
{
if (isNewSurface)
{
// a new surface has been created (e.g. after a resize)
InitializeSharedBackBuffer(resourcePtr);
}
deviceContext.ClearRenderTargetView(renderTargetView, new RawColor4(0, 0, 0, 1));
deviceContext.Draw(3, 0);
deviceContext.Flush();
}
/// <summary>
/// Draw the game.
/// </summary>
private void Draw()
{
// Clear the screen
d3dDeviceContext.ClearRenderTargetView(renderTargetView, new SharpDX.Color(32, 103, 178));
// Set vertex buffer
d3dDeviceContext.InputAssembler.SetVertexBuffers(0, new D3D11.VertexBufferBinding(triangleVertexBuffer, Utilities.SizeOf <Vector3>(), 0));
// Draw the triangle
d3dDeviceContext.Draw(vertices.Count(), 0);
// Swap front and back buffer
swapChain.Present(1, PresentFlags.None);
}
//____________________________________________________________________________________________________________________________________________________________________________________________
private void Draw()
{
InitBuffers(); //MEMORY LEAK -- FIXED???
//d3dDeviceContext.UpdateSubresource(,);
d3dDeviceContext.OutputMerger.SetRenderTargets(renderTargetView); // Set back buffer as current render target view
d3dDeviceContext.ClearRenderTargetView(renderTargetView, new RawColor4(0, 0, 0, 2)); // Clear the screen
d3dDeviceContext.InputAssembler.SetVertexBuffers(0, new D3D11.VertexBufferBinding(screenVertexBuffer, Utilities.SizeOf <VertexPositionColor>(), 0)); // Set vertex buffer
//SYS_STATE();
for (int i = 0; i < 64 * 32; i++)
{
d3dDeviceContext.Draw(4, i * 4);
}
swapChain.Present(0, PresentFlags.None);// Swap front and back buffer
screenVertexBuffer.Dispose();
}
/// <summary>
/// This code first sets the active render target view to the one we just created.
/// Then it clears the render target view (currently our back buffer)
/// and then swaps the back with the front buffer, making the back buffer visible.
/// By specifying 1 as the first parameter to Present(…) we wait for vertical sync of the monitor before we present.
/// This will limit the FPS to the update frequency of the monitor.
/// </summary>
private void Draw()
{
_d3DDeviceContext.OutputMerger.SetRenderTargets(_renderTargetView);
_d3DDeviceContext.ClearRenderTargetView(_renderTargetView, new RawColor4(0.0f, 0.0f, 0.0f, 0.0f));
//The first method tells the device context to use the vertex buffer holding the triangle vertex data,
//with the second parameter specifying the size (in bytes) for the data of each vertex.
//To get this size we use a nice helper method available in SharpDX.
_d3DDeviceContext.InputAssembler.SetVertexBuffers(0, new D3D11.VertexBufferBinding(_triangleVertexBuffer, Utilities.SizeOf <VertexPositionColor>(), 0));
//The Draw() method on the device context draws vertices.Count() many vertices from our vertex buffer.
//The second parameter specifies the offset in our vertex buffer,
//by settings this to 1 for example, the first vertex would be skipped.
_d3DDeviceContext.Draw(_vertices.Count(), 0);
_swapChain.Present(1, PresentFlags.None);
}
/// <summary>
/// Renders all given lines with the given parameters.
/// </summary>
/// <param name="renderState">The render state to be used.</param>
/// <param name="worldViewProj">Current world-view-project transformation.</param>
/// <param name="lineColor">The color for the line.</param>
/// <param name="lineVertexBuffer">The vertex buffer containing all line vertices.</param>
/// <param name="vertexCount">Total count of vertices.</param>
internal void RenderLines(RenderState renderState, Matrix4x4 worldViewProj, Color4 lineColor, D3D11.Buffer lineVertexBuffer, int vertexCount)
{
D3D11.DeviceContext deviceContext = renderState.Device.DeviceImmediateContextD3D11;
//Apply constant buffer data
ConstantBufferData constantData = new ConstantBufferData();
constantData.DiffuseColor = lineColor;
constantData.WorldViewProj = worldViewProj;
m_constantBuffer.SetData(deviceContext, constantData);
//Apply vertex buffer and draw lines
deviceContext.VertexShader.SetConstantBuffer(4, m_constantBuffer.ConstantBuffer);
deviceContext.PixelShader.SetConstantBuffer(4, m_constantBuffer.ConstantBuffer);
deviceContext.InputAssembler.SetVertexBuffers(0, new D3D11.VertexBufferBinding(lineVertexBuffer, LineVertex.Size, 0));
deviceContext.Draw(vertexCount, 0);
}
private void Draw()
{
deviceContext.OutputMerger.SetRenderTargets(renderTargetView);
deviceContext.ClearRenderTargetView(renderTargetView, ColorToRaw4(Color.Coral));
deviceContext.InputAssembler.SetVertexBuffers(0,
new D3D11.VertexBufferBinding(triangleVertexBuffer, Utilities.SizeOf <Vector3>(), 0));
deviceContext.Draw(vertices.Length, 0);
swapChain.Present(1, PresentFlags.None);
RawColor4 ColorToRaw4(Color color)
{
const float n = 255f;
return(new RawColor4(color.R / n, color.G / n, color.B / n, color.A / n));
}
}
/// <summary>
/// displays all drawn content
/// </summary>
public void Display()
{
VertexArray = TriangleList.ToArray();
deviceContext.UpdateSubresource(VertexArray, vertexBuffer);
invCamara = camara.GetInvertedCamaraPosition();
deviceContext.UpdateSubresource(ref invCamara, camaraBuffer);
if (VertexArray.Length != lastVertexArrayLength)
{
vertexBuffer.Dispose();
vertexBuffer = D3D11.Buffer.Create <Vertex>(device, D3D11.BindFlags.VertexBuffer, VertexArray);
deviceContext.InputAssembler.SetVertexBuffers(0, new D3D11.VertexBufferBinding(vertexBuffer, Utilities.SizeOf <Vertex>(), 0));
}
deviceContext.Draw(VertexArray.Count(), 0);
swapChain.Present(1, PresentFlags.None);
}
public static void Render(SharpDX.Direct3D11.DeviceContext context)
{
//we apply wvp here to update z
var origin = (Origin * WVP).TranslationVector;
var direction = (Direction * WVP).TranslationVector;
var ray = new SharpDX.Ray(origin, direction);
//if ray is inside panel, show
if (AdjustmentPanelModel.CheckBounds(ref ray, out var z))
{
var k = Direction.TranslationVector.Length();
vertices[5] = -z * k;
shader.Apply(context);
context.UpdateSubresource(vertices, vertexBuffer);
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.LineList;
context.InputAssembler.SetVertexBuffers(0, vertexBufferBinding);
context.Draw(2, 0);
}
}
/// <summary>
/// Notifies that rendering has finished.
/// </summary>
/// <param name="renderState">The current render state.</param>
/// <param name="passID">The ID of the current pass (starting with 0)</param>
/// <returns>
/// True, if rendering should continue with next pass. False if postprocess effect is finished.
/// </returns>
internal override bool NotifyAfterRender(RenderState renderState, int passID)
{
D3D11.DeviceContext deviceContext = renderState.Device.DeviceImmediateContextD3D11;
// Reset settings made on render state (needed for all passes)
deviceContext.Rasterizer.State = m_defaultResources.RasterStateDefault;
// Reset render target (needed for all passes)
m_renderTarget.PopFromRenderState(renderState);
// Update constant buffer data
m_constantBufferData.ScreenPixelSize = renderState.ViewInformation.CurrentViewSize.ToVector2();
m_constantBufferData.Opacity = 0.9f;
m_constantBufferData.Threshold = 0.2f;
m_constantBufferData.Thickness = m_thickness;
m_constantBufferData.BorderColor = m_borderColor.ToVector3();
m_constantBufferData.OriginalColorAlpha = m_drawOriginalObject ? 1f : 0f;
m_constantBuffer.SetData(deviceContext, m_constantBufferData);
// Render result of current pass to the main render target
switch (passID)
{
case 0:
base.ApplyAlphaBasedSpriteRendering(deviceContext);
try
{
deviceContext.PixelShader.SetShaderResource(0, m_renderTarget.TextureView);
deviceContext.PixelShader.SetSampler(0, m_defaultResources.GetSamplerState(TextureSamplerQualityLevel.Low));
deviceContext.PixelShader.SetConstantBuffer(2, m_constantBuffer.ConstantBuffer);
deviceContext.PixelShader.Set(m_pixelShaderBlur.PixelShader);
deviceContext.Draw(3, 0);
}
finally
{
base.DiscardAlphaBasedSpriteRendering(deviceContext);
}
return(false);
}
return(false);
}
protected override void Draw(DemoTime time)
{
var now = DateTime.Now;
// Don't over-render, it costs CPU and that's energy
var delta = (int)(now - lastFrame).TotalMilliseconds;
if (delta < msPerFrame)
{
System.Threading.Thread.Sleep(msPerFrame - delta);
}
lastFrame = now;
base.Draw(time);
// Update WorldViewProj Matrix
var viewProj = Matrix.Multiply(view, proj);
var worldViewProj = Matrix.Translation(new Vector3(0, (float)(instruments.pitch * 0.5 / Math.PI), 0)) * Matrix.RotationZ(instruments.roll) * viewProj;
// Matrix.RotationX(time) * Matrix.RotationY(time * 2) * Matrix.RotationZ(time * .7f)
worldViewProj.Transpose();
context.UpdateSubresource(ref worldViewProj, contantBuffer);
// var attitude = adhrs.RawRead();
if (attitude.Count() > 0)
{
lastRead = now;
instruments.SetFromAhrs(attitude);
}
if ((now - lastRead).TotalSeconds > 1.2)
{
RenderTarget2D.DrawLine(new Vector2(0, 0), new Vector2(Stock.ClientRectangle.Width, Stock.ClientRectangle.Height), errorBrush, 3.0f);
RenderTarget2D.DrawLine(new Vector2(Stock.ClientRectangle.Width, 0), new Vector2(0, Stock.ClientRectangle.Height), errorBrush, 3.0f);
}
context.Draw(36, 0);
instruments.Draw(RenderTarget2D, instrumentColorBrush);
}
/// <summary>
/// Notifies that rendering has finished.
/// </summary>
/// <param name="renderState">The current render state.</param>
/// <param name="passID">The ID of the current pass (starting with 0)</param>
/// <returns>
/// True, if rendering should continue with next pass. False if postprocess effect is finished.
/// </returns>
internal override bool NotifyAfterRender(RenderState renderState, int passID)
{
D3D11.DeviceContext deviceContext = renderState.Device.DeviceImmediateContextD3D11;
if (renderState.Device.IsHighDetailSupported && (!m_forceSimpleMethod))
{
// Reset settings made on render state (needed for all passes)
deviceContext.Rasterizer.State = m_defaultResources.RasterStateDefault;
deviceContext.OutputMerger.DepthStencilState = m_defaultResources.DepthStencilStateDefault;
renderState.ForceMaterial(null);
// Reset render target (needed for all passes)
m_renderTarget.PopFromRenderState(renderState);
// Clear cached material resource because wie work with shaders directly here
renderState.ClearChachedAppliedMaterial();
// Render result of current pass to the main render target
switch (passID)
{
case 0:
base.ApplyAlphaBasedSpriteRendering(deviceContext);
try
{
deviceContext.PixelShader.SetShaderResource(0, m_renderTarget.TextureView);
deviceContext.PixelShader.SetSampler(0, m_defaultResources.GetSamplerState(TextureSamplerQualityLevel.Low));
deviceContext.PixelShader.SetConstantBuffer(2, m_cbFirstPass.ConstantBuffer);
deviceContext.PixelShader.Set(m_pixelShaderBlur.PixelShader);
deviceContext.Draw(3, 0);
}
finally
{
base.DiscardAlphaBasedSpriteRendering(deviceContext);
}
return(true);
case 1:
base.ApplyAlphaBasedSpriteRendering(deviceContext);
try
{
deviceContext.PixelShader.SetShaderResource(0, m_renderTarget.TextureView);
deviceContext.PixelShader.SetSampler(0, m_defaultResources.GetSamplerState(TextureSamplerQualityLevel.Low));
deviceContext.PixelShader.SetConstantBuffer(2, m_cbSecondPass.ConstantBuffer);
deviceContext.PixelShader.Set(m_pixelShaderBlur.PixelShader);
deviceContext.Draw(3, 0);
}
finally
{
base.DiscardAlphaBasedSpriteRendering(deviceContext);
}
return(false);
}
}
else
{
// Reset changes from before
deviceContext.Rasterizer.State = m_defaultResources.RasterStateDefault;
renderState.ForceMaterial(null);
// Now we ware finished
return(false);
}
return(false);
}
private void ProcessFrame(Direct3D11CaptureFrame frame)
{
// Do proecssing
using (frame)
{
using (var texture = Direct3D11Helper.CreateSharpDXTexture2D(frame.Surface))
{
var hdrMetadata = currentSession.HdrMetadata;
var vertices = new ShaderInputStructure[]
{
// Left-Top
new ShaderInputStructure {
Position = new Vector3(currentSession.DestD3DVsTopLeft.X, currentSession.DestD3DVsTopLeft.Y, 0),
TextureCoord = new Vector2(currentSession.DestD3DPsSamplerTopLeft.X, currentSession.DestD3DPsSamplerTopLeft.Y),
},
// Right-Top
new ShaderInputStructure {
Position = new Vector3(currentSession.DestD3DVsBottomRight.X, currentSession.DestD3DVsTopLeft.Y, 0),
TextureCoord = new Vector2(currentSession.DestD3DPsSamplerBottomRight.X, currentSession.DestD3DPsSamplerTopLeft.Y)
},
// Left-Bottom
new ShaderInputStructure {
Position = new Vector3(currentSession.DestD3DVsTopLeft.X, currentSession.DestD3DVsBottomRight.Y, 0),
TextureCoord = new Vector2(currentSession.DestD3DPsSamplerTopLeft.X, currentSession.DestD3DPsSamplerBottomRight.Y)
},
// Right-Top
new ShaderInputStructure {
Position = new Vector3(currentSession.DestD3DVsBottomRight.X, currentSession.DestD3DVsTopLeft.Y, 0),
TextureCoord = new Vector2(currentSession.DestD3DPsSamplerBottomRight.X, currentSession.DestD3DPsSamplerTopLeft.Y)
},
// Right-Bottom
new ShaderInputStructure {
Position = new Vector3(currentSession.DestD3DVsBottomRight.X, currentSession.DestD3DVsBottomRight.Y, 0),
TextureCoord = new Vector2(currentSession.DestD3DPsSamplerBottomRight.X, currentSession.DestD3DPsSamplerBottomRight.Y)
},
// Left-Bottom
new ShaderInputStructure {
Position = new Vector3(currentSession.DestD3DVsTopLeft.X, currentSession.DestD3DVsBottomRight.Y, 0),
TextureCoord = new Vector2(currentSession.DestD3DPsSamplerTopLeft.X, currentSession.DestD3DPsSamplerBottomRight.Y)
},
};
var triangleVertexBuffer = D3D11.Buffer.Create(d3dDevice, D3D11.BindFlags.VertexBuffer, vertices);
var hdrMetadataBuffer = new D3D11.Buffer(d3dDevice,
Utilities.SizeOf <ShaderHdrMetadata>(),
D3D11.ResourceUsage.Default,
D3D11.BindFlags.ConstantBuffer,
D3D11.CpuAccessFlags.None,
D3D11.ResourceOptionFlags.None,
0);
d3dContext.UpdateSubresource(ref hdrMetadata, hdrMetadataBuffer);
d3dContext.InputAssembler.PrimitiveTopology = D3D.PrimitiveTopology.TriangleList;
d3dContext.InputAssembler.InputLayout = inputLayout;
d3dContext.InputAssembler.SetVertexBuffers(0, new D3D11.VertexBufferBinding(triangleVertexBuffer, Utilities.SizeOf <ShaderInputStructure>(), 0));
d3dContext.VertexShader.Set(vsQuad);
d3dContext.PixelShader.SetConstantBuffer(0, hdrMetadataBuffer);
d3dContext.PixelShader.SetSampler(0, samplerState);
var canvasTexture = new D3D11.Texture2D(d3dDevice, new D3D11.Texture2DDescription
{
Width = texture.Description.Width,
Height = texture.Description.Height,
MipLevels = 1,
ArraySize = 1,
Format = currentSession.HdrMetadata.EnableHdrProcessing ? DXGI.Format.R16G16B16A16_Float : DXGI.Format.B8G8R8A8_UNorm_SRgb,
Usage = D3D11.ResourceUsage.Default,
SampleDescription = new DXGI.SampleDescription(1, 0),
BindFlags = D3D11.BindFlags.ShaderResource,
CpuAccessFlags = D3D11.CpuAccessFlags.None,
OptionFlags = D3D11.ResourceOptionFlags.None,
});
using (canvasTexture)
using (var shaderResView = new D3D11.ShaderResourceView(d3dDevice, canvasTexture))
{
d3dContext.CopyResource(texture, canvasTexture);
d3dContext.PixelShader.SetShaderResource(0, shaderResView);
d3dContext.PixelShader.Set(psToneMapping);
d3dContext.Draw(vertices.Length, 0);
}
triangleVertexBuffer.Dispose();
hdrMetadataBuffer.Dispose();
}
}
// Cleanup and signal event to proceed
currentSession.Session.Dispose();
}
public void Run()
{
if (_userResized)
{
Utilities.Dispose(ref _backBuffer);
Utilities.Dispose(ref _renderView);
Utilities.Dispose(ref _depthBuffer);
Utilities.Dispose(ref _depthView);
_swapChain.ResizeBuffers(_swapChainDescription.BufferCount, _form.ClientSize.Width, _form.ClientSize.Height, Format.Unknown, SwapChainFlags.None);
_backBuffer = D3D11.Resource.FromSwapChain <D3D11.Texture2D>(_swapChain, 0);
_renderView = new D3D11.RenderTargetView(_device, _backBuffer);
_depthBuffer = new D3D11.Texture2D(_device, new D3D11.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 = D3D11.ResourceUsage.Default,
BindFlags = D3D11.BindFlags.DepthStencil,
CpuAccessFlags = D3D11.CpuAccessFlags.None,
OptionFlags = D3D11.ResourceOptionFlags.None
});
_depthView = new D3D11.DepthStencilView(_device, _depthBuffer);
_context.Rasterizer.SetViewport(new Viewport(0, 0, _form.ClientSize.Width, _form.ClientSize.Height, 0.0f, 1.0f));
_context.Rasterizer.State = new D3D11.RasterizerState(_device, new D3D11.RasterizerStateDescription
{
FillMode = D3D11.FillMode.Solid,
CullMode = D3D11.CullMode.Front,
IsFrontCounterClockwise = false,
});
_context.OutputMerger.SetTargets(_depthView, _renderView);
const float rads = (60.0f / 360.0f) * (float)Math.PI * 2.0f;
_proj = Matrix.PerspectiveFovLH(rads, _form.ClientSize.Width / (float)_form.ClientSize.Height, 0.1f, 1000.0f);
_userResized = false;
}
var time = _clock.ElapsedMilliseconds / 1000.0f;
var dt = time - lastTime;
if (key == Keys.W)
{
camera.goForward(dt);
}
if (key == Keys.S)
{
camera.goBack(dt);
}
lastTime = time;
var point = new System.Drawing.Point(_form.Location.X + (_form.Size.Width / 2), _form.Location.Y + (_form.Size.Height / 2));
//Cursor.Position = point;
var modelMatrix = Matrix.RotationX(time) * Matrix.RotationY(time) * Matrix.RotationZ(time) * Matrix.Translation(_primordialObject.Position);
var worldViewProj = modelMatrix * camera.ViewProjectionMatrix;
modelMatrix.Transpose();
worldViewProj.Transpose();
var modelMatrixArray = modelMatrix.ToArray();
var MVPMatrix = worldViewProj.ToArray();
var modelInverse = modelMatrix;
modelInverse.Invert();
//modelInverse.Transpose();
//_primordialObject.Position = new Vector3((float)Math.Cos(time * 2), (float)Math.Sin(time*2), (float)Math.Sin(time * 2)* (float)Math.Cos(time * 2));
var renderTime = _clock.ElapsedMilliseconds;
_context.ClearDepthStencilView(_depthView, D3D11.DepthStencilClearFlags.Depth, 1.0f, 0);
_context.ClearRenderTargetView(_renderView, SharpDX.Color.Black);
_context.UpdateSubresource(MVPMatrix, _contantBuffer);
_context.UpdateSubresource(modelMatrixArray, _contantBuffer2);
_context.UpdateSubresource(modelInverse.ToArray(), _contantBuffer3);
var frameTime = _clock.ElapsedMilliseconds;
_context.Draw(_primordialObject.VertexData.Length, 0);
_swapChain.Present(0, PresentFlags.None);
if ((_clock.ElapsedMilliseconds - frameTime) > 15)
{
File.AppendAllText(fileTitle + ".txt", (_clock.ElapsedMilliseconds - frameTime).ToString() + "\n");
count++;
}
// if(count > 1)
//_form.Close();
if (_clock.Elapsed.TotalSeconds > 105)
{
// _form.Close();
}
}
public void Draw(int vertexCount, int startVertexLocation = 0)
{
NativeDeviceContext.Draw(vertexCount, startVertexLocation);
}
public void PresentFrame(MediaFrame frame = null)
{
if (device == null)
{
return;
}
// Drop Frames | Priority on video frames
bool gotIn = frame == null?Monitor.TryEnter(device, 1) : Monitor.TryEnter(device, 5);
if (gotIn)
{
try
{
if (frame != null)
{
if (decoder.vDecoder.hwAccelSuccess)
{
curSRVs = new ShaderResourceView[2];
curSRVs[0] = new ShaderResourceView(device, frame.textures[0], srvDescR);
curSRVs[1] = new ShaderResourceView(device, frame.textures[0], srvDescRG);
}
else if (decoder.vDecoder.info.PixelFormatType == PixelFormatType.Software_Handled)
{
curSRVs = new ShaderResourceView[3];
curSRVs[0] = new ShaderResourceView(device, frame.textures[0]);
curSRVs[1] = new ShaderResourceView(device, frame.textures[1]);
curSRVs[2] = new ShaderResourceView(device, frame.textures[2]);
}
else
{
curSRVs = new ShaderResourceView[1];
curSRVs[0] = new ShaderResourceView(device, frame.textures[0]);
}
context.PixelShader.Set(curPixelShader);
context.PixelShader.SetShaderResources(0, curSRVs);
}
context.OutputMerger.SetRenderTargets(rtv);
context.ClearRenderTargetView(rtv, cfg.video._ClearColor);
context.Draw(6, 0);
swapChain.Present(cfg.video.VSync, PresentFlags.None);
if (frame != null)
{
if (frame.textures != null)
{
for (int i = 0; i < frame.textures.Length; i++)
{
Utilities.Dispose(ref frame.textures[i]);
}
}
if (curSRVs != null)
{
for (int i = 0; i < curSRVs.Length; i++)
{
Utilities.Dispose(ref curSRVs[i]);
}
curSRVs = null;
}
}
} finally { Monitor.Exit(device); }
}
else
{
Log("Dropped Frame - Lock timeout " + (frame != null ? Utils.TicksToTime(frame.timestamp) : "")); Utils.DisposeVideoFrame(frame);
}
}
internal void Draw(int vertexCount, int startVertexLocation)
{
m_deviceContext.Draw(vertexCount, startVertexLocation);
m_statistics.Draws++;
CheckErrors();
}
public void DrawQuad(int count = 1)
{
context.InputAssembler.InputLayout = null;
context.Draw(4 * count, 0);
}
