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); }