23769862947

Committed 30 Mar 2026 10:01PM UTC coverage: 30.548% (+0.007%) from 30.541%

Build # 23769862947

Build Type

push

coveralls.net

Committed by

DemoBytom

Commit Message

Drawing Mandlebrot fractal

Coverage Stats

1276 of 4177 relevant lines covered (30.55%)

0.37 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/Demo.Engine.Platform.DirectX12/ForwardPlusRenderer/PostProcessService.cs

// Copyright © Michał Dembski and contributors.
// Distributed under MIT license. See LICENSE file in the root for more information.

using System.Diagnostics.CodeAnalysis;
using System.Runtime.InteropServices;
using Demo.Engine.Platform.DirectX12.Shaders;
using Microsoft.Extensions.Logging;
using Vortice.Direct3D;
using Vortice.Direct3D12;
using Vortice.DXGI;

namespace Demo.Engine.Platform.DirectX12.ForwardPlusRenderer;

internal sealed class PostProcessService(
    ILogger<PostProcessService> logger,
    ID3D12RenderingEngine renderingEngine,
    IGPassService gPassService,
    IEngineShaderManager engineShaderManager)
    : IPostProcessService,
      IDisposable
{
    private bool _disposedValue;

    private ID3D12RootSignature? _rootSignature = null;
    private ID3D12PipelineState? _pipelineStateObject = null;

    [MemberNotNullWhen(true,
        nameof(_rootSignature),
        nameof(_pipelineStateObject))]
    public bool Initialize()
        => CreateFxPsoAndRootSignature()
        ;

    /// <summary>
    /// Post process method
    /// </summary>
    /// <param name="commandList">command list to execute on</param>
    /// <param name="targetRTV">target render target view</param>
    public void PostProcess(
        ID3D12GraphicsCommandList commandList,
        CpuDescriptorHandle targetRTV)
    {
        commandList.SetGraphicsRootSignature(_rootSignature);
        commandList.SetPipelineState(_pipelineStateObject);

        commandList.SetGraphicsRoot32BitConstant(
            rootParameterIndex: (int)RootParametersIndices.RootConstants,
            srcData: (uint)gPassService.MainBuffer.SRV.Index,
            destOffsetIn32BitValues: 0);
        commandList.SetGraphicsRootDescriptorTable(
            rootParameterIndex: (int)RootParametersIndices.DescriptorTable,
            //                                                      TODO NRT!
            baseDescriptor: renderingEngine.SRVHeapAllocator.GPU_Start!.Value);
        commandList.IASetPrimitiveTopology(PrimitiveTopology.TriangleList);
        commandList.OMSetRenderTargets(1, targetRTV);
        commandList.DrawInstanced(
            vertexCountPerInstance: 3,
            instanceCount: 1,
            startVertexLocation: 0,
            startInstanceLocation: 0);
    }

    [MemberNotNullWhen(true,
        nameof(_rootSignature),
        nameof(_pipelineStateObject))]
    private bool CreateFxPsoAndRootSignature()
    {
        if (_rootSignature is not null)
        {
            throw new InvalidOperationException("Root signature already created!");
        }
        if (_pipelineStateObject is not null)
        {
            throw new InvalidOperationException("Pipeline state object already created!");
        }

        var range = new DescriptorRange1(
            rangeType: DescriptorRangeType.ShaderResourceView,
            numDescriptors: D3D12.DescriptorRangeOffsetAppend,
            baseShaderRegister: 0,
            registerSpace: 0,
            flags: DescriptorRangeFlags.DescriptorsVolatile);

        var parameters = new RootParameter1[(int)RootParametersIndices.Count];

        parameters[(int)RootParametersIndices.RootConstants] = RootParameter1
            .ConstantsRootParameter(
                numConstants: 1,
                visibility: ShaderVisibility.Pixel,
                shaderRegister: 1);
        parameters[(int)RootParametersIndices.DescriptorTable] = RootParameter1
            .DescriptorTableRootParameter(
                visibility: ShaderVisibility.Pixel,
                range);

        //const RootSignatureFlags ROOT_SIGNATURE_FLAGS =
        //   RootSignatureFlags.AllowInputAssemblerInputLayout
        //   | RootSignatureFlags.DenyAmplificationShaderRootAccess
        //   | RootSignatureFlags.DenyDomainShaderRootAccess
        //   | RootSignatureFlags.DenyGeometryShaderRootAccess
        //   | RootSignatureFlags.DenyHullShaderRootAccess
        //   | RootSignatureFlags.DenyMeshShaderRootAccess
        //   ;

        _rootSignature = renderingEngine.Device.CreateRootSignature(
            new RootSignatureDescription1(
                //ROOT_SIGNATURE_FLAGS,
                RootSignatureExtensions.DenyAll
                & ~RootSignatureFlags.DenyPixelShaderRootAccess,
                parameters));

        _rootSignature.NameObject(
            "Post Process FX root signature",
            logger);

        var vertexShader = engineShaderManager.GetShader(ShaderId.FullscreenTriangleVS);
        var pixelShader = engineShaderManager.GetShader(ShaderId.PostProcessPS);
        var primitiveTopology = PrimitiveTopologyType.Triangle;
        var renderTagetFormats = new Format[] { Common.DEFAULT_BACK_BUFFER_FORMAT };

        PipelineStateStream stream = new()
        {

            RootSignature = new(_rootSignature),
            VertexShader = new(vertexShader.ShaderBlob.Span),
            PixelShader = new(pixelShader.ShaderBlob.Span),
            PrimitiveTopology = new(primitiveTopology),
            RenderTargetFormats = new(renderTagetFormats),
            Rasterizer = new(RasterizerDescription.CullNone), // no culling
        };

        _pipelineStateObject = renderingEngine.Device.CreatePipelineState(stream);
        _pipelineStateObject.NameObject(
            "Post Process FX pipeline state object",
            logger);

        return true;
    }

    [StructLayout(LayoutKind.Sequential)]
    private readonly struct PipelineStateStream
    {
        public required PipelineStateSubObjectTypeRootSignature RootSignature { get; init; }
        public required PipelineStateSubObjectTypeVertexShader VertexShader { get; init; }
        public required PipelineStateSubObjectTypePixelShader PixelShader { get; init; }
        public required PipelineStateSubObjectTypePrimitiveTopology PrimitiveTopology { get; init; }
        public required PipelineStateSubObjectTypeRenderTargetFormats RenderTargetFormats { get; init; }
        public required PipelineStateSubObjectTypeRasterizer Rasterizer { get; init; }
    }

    private void Dispose(bool disposing)
    {
        if (!_disposedValue)
        {
            if (disposing)
            {
                _rootSignature?.Dispose();
                _pipelineStateObject?.Dispose();
            }

            _disposedValue = true;
        }
    }

    public void Dispose()
    {
        // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
        Dispose(disposing: true);
        GC.SuppressFinalize(this);
    }

    private enum RootParametersIndices
    {
        RootConstants,
        DescriptorTable,

        // MUST BE LAST! :)
        Count,
    }
}

1	// Copyright © Michał Dembski and contributors.
2	// Distributed under MIT license. See LICENSE file in the root for more information.
3
4	using System.Diagnostics.CodeAnalysis;
5	using System.Runtime.InteropServices;
6	using Demo.Engine.Platform.DirectX12.Shaders;
7	using Microsoft.Extensions.Logging;
8	using Vortice.Direct3D;
9	using Vortice.Direct3D12;
10	using Vortice.DXGI;
11
12	namespace Demo.Engine.Platform.DirectX12.ForwardPlusRenderer;
13
14	internal sealed class PostProcessService(	×
15	ILogger<PostProcessService> logger,	×
16	ID3D12RenderingEngine renderingEngine,	×
17	IGPassService gPassService,	×
18	IEngineShaderManager engineShaderManager)	×
19	: IPostProcessService,
20	IDisposable
21	{
22	private bool _disposedValue;
23
24	private ID3D12RootSignature? _rootSignature = null;
25	private ID3D12PipelineState? _pipelineStateObject = null;
26
27	[MemberNotNullWhen(true,
28	nameof(_rootSignature),
29	nameof(_pipelineStateObject))]
30	public bool Initialize()
31	=> CreateFxPsoAndRootSignature()	×
32	;
33
34	/// <summary>
35	/// Post process method
36	/// </summary>
37	/// <param name="commandList">command list to execute on</param>
38	/// <param name="targetRTV">target render target view</param>
39	public void PostProcess(
40	ID3D12GraphicsCommandList commandList,
41	CpuDescriptorHandle targetRTV)
42	{
43	commandList.SetGraphicsRootSignature(_rootSignature);	×
44	commandList.SetPipelineState(_pipelineStateObject);	×
45
46	commandList.SetGraphicsRoot32BitConstant(	×
47	rootParameterIndex: (int)RootParametersIndices.RootConstants,	×
48	srcData: (uint)gPassService.MainBuffer.SRV.Index,	×
49	destOffsetIn32BitValues: 0);	×
50	commandList.SetGraphicsRootDescriptorTable(	×
51	rootParameterIndex: (int)RootParametersIndices.DescriptorTable,	×
52	// TODO NRT!	×
53	baseDescriptor: renderingEngine.SRVHeapAllocator.GPU_Start!.Value);	×
54	commandList.IASetPrimitiveTopology(PrimitiveTopology.TriangleList);	×
55	commandList.OMSetRenderTargets(1, targetRTV);	×
56	commandList.DrawInstanced(	×
57	vertexCountPerInstance: 3,	×
58	instanceCount: 1,	×
59	startVertexLocation: 0,	×
60	startInstanceLocation: 0);	×
61	}	×
62
63	[MemberNotNullWhen(true,
64	nameof(_rootSignature),
65	nameof(_pipelineStateObject))]
66	private bool CreateFxPsoAndRootSignature()
67	{
68	if (_rootSignature is not null)	×
69	{
70	throw new InvalidOperationException("Root signature already created!");	×
71	}
72	if (_pipelineStateObject is not null)	×
73	{
74	throw new InvalidOperationException("Pipeline state object already created!");	×
75	}
76
77	var range = new DescriptorRange1(	×
78	rangeType: DescriptorRangeType.ShaderResourceView,	×
79	numDescriptors: D3D12.DescriptorRangeOffsetAppend,	×
80	baseShaderRegister: 0,	×
81	registerSpace: 0,	×
82	flags: DescriptorRangeFlags.DescriptorsVolatile);	×
83
84	var parameters = new RootParameter1[(int)RootParametersIndices.Count];	×
85
86	parameters[(int)RootParametersIndices.RootConstants] = RootParameter1	×
87	.ConstantsRootParameter(	×
88	numConstants: 1,	×
89	visibility: ShaderVisibility.Pixel,	×
90	shaderRegister: 1);	×
91	parameters[(int)RootParametersIndices.DescriptorTable] = RootParameter1	×
92	.DescriptorTableRootParameter(	×
93	visibility: ShaderVisibility.Pixel,	×
94	range);	×
95
96	//const RootSignatureFlags ROOT_SIGNATURE_FLAGS =
97	// RootSignatureFlags.AllowInputAssemblerInputLayout
98	// \| RootSignatureFlags.DenyAmplificationShaderRootAccess
99	// \| RootSignatureFlags.DenyDomainShaderRootAccess
100	// \| RootSignatureFlags.DenyGeometryShaderRootAccess
101	// \| RootSignatureFlags.DenyHullShaderRootAccess
102	// \| RootSignatureFlags.DenyMeshShaderRootAccess
103	// ;
104
105	_rootSignature = renderingEngine.Device.CreateRootSignature(	×
106	new RootSignatureDescription1(	×
107	//ROOT_SIGNATURE_FLAGS,	×
108	RootSignatureExtensions.DenyAll	×
109	& ~RootSignatureFlags.DenyPixelShaderRootAccess,	×
110	parameters));	×
111
112	_rootSignature.NameObject(	×
113	"Post Process FX root signature",	×
114	logger);	×
115
116	var vertexShader = engineShaderManager.GetShader(ShaderId.FullscreenTriangleVS);	×
117	var pixelShader = engineShaderManager.GetShader(ShaderId.PostProcessPS);	×
118	var primitiveTopology = PrimitiveTopologyType.Triangle;	×
119	var renderTagetFormats = new Format[] { Common.DEFAULT_BACK_BUFFER_FORMAT };	×
120
121	PipelineStateStream stream = new()	×
122	{	×
123		×
124	RootSignature = new(_rootSignature),	×
125	VertexShader = new(vertexShader.ShaderBlob.Span),	×
126	PixelShader = new(pixelShader.ShaderBlob.Span),	×
127	PrimitiveTopology = new(primitiveTopology),	×
128	RenderTargetFormats = new(renderTagetFormats),	×
129	Rasterizer = new(RasterizerDescription.CullNone), // no culling	×
130	};	×
131
132	_pipelineStateObject = renderingEngine.Device.CreatePipelineState(stream);	×
133	_pipelineStateObject.NameObject(	×
134	"Post Process FX pipeline state object",	×
135	logger);	×
136
137	return true;	×
138	}
139
140	[StructLayout(LayoutKind.Sequential)]
141	private readonly struct PipelineStateStream
142	{
143	public required PipelineStateSubObjectTypeRootSignature RootSignature { get; init; }
144	public required PipelineStateSubObjectTypeVertexShader VertexShader { get; init; }
145	public required PipelineStateSubObjectTypePixelShader PixelShader { get; init; }
146	public required PipelineStateSubObjectTypePrimitiveTopology PrimitiveTopology { get; init; }
147	public required PipelineStateSubObjectTypeRenderTargetFormats RenderTargetFormats { get; init; }
148	public required PipelineStateSubObjectTypeRasterizer Rasterizer { get; init; }
149	}
150
151	private void Dispose(bool disposing)
152	{
153	if (!_disposedValue)	×
154	{
155	if (disposing)	×
156	{
157	_rootSignature?.Dispose();	×
158	_pipelineStateObject?.Dispose();	×
159	}
160
161	_disposedValue = true;	×
162	}
163	}	×
164
165	public void Dispose()
166	{
167	// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
168	Dispose(disposing: true);	×
169	GC.SuppressFinalize(this);	×
170	}	×
171
172	private enum RootParametersIndices
173	{
174	RootConstants,
175	DescriptorTable,
176
177	// MUST BE LAST! :)
178	Count,
179	}
180	}

DemoBytom / DemoEngine / 23769862947

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous