I have made it, and it's actually not that hard

1. Create a pipeline state for render target with specific MSAA samples and quality, like this (I've removed additional code)
    

   
   DXGI_SAMPLE_DESC samplerDesc;
   samplerDesc.Count = samplesMSAA;
   samplerDesc.Quality = qualityMSAA;
   
   D3D12_GRAPHICS_PIPELINE_STATE_DESC desc = { 0 };
   ...
   desc.SampleDesc = samplerDesc;
   
   device->CreateGraphicsPipelineState(&desc, __uuidof(ID3D12PipelineState), (void**)&pipelineState);

2. Create render target buffers that hold rendered data (for both - color & depth buffers)
    

   
   	D3D12_RESOURCE_DESC desc = DescTex2D(...)
   	desc.SampleDesc.Count = samplesMSAA;
   	desc.SampleDesc.Quality = qualityMSAA;
   
    	....
   
   	CreateTextureResource(...)
   	CreateDerivedViews(...)

3. Next you need to have pipeline state for resolving and I assume you want to resolve into backbuffer for swap chain (so you already have color (& depth) buffers for that). This pipeline state and texture buffers are no-MSAA, so samples count is 1 and sample quality is 0
    
4. Rendering is then straight forward - you render your scene with MSAA pipeline state into MSAA buffers. And during resolve you attach SRV of those buffers and resolve in your shader like for example this (note SamplesMSAA is a define with number of samples used in MSAA):
    

   
   Texture2DMS<float4, SamplesMSAA> msaaTexture : register(t0);
     
   cbuffer msaaDesc : register(b0)
   {
   	uint2 dimensions;
   }
     
   struct Input
   {
   	float4 position : SV_POSITION;
   	float2 texCoord : TEXCOORD0;
   };
   
   Input VS(uint id : SV_VertexID, 
   	float3 position : POSITION,
   	float2 texCoord : TEXCOORD0)
   {
   	Input result;
   
   	result.position = float4(position, 1.0f);
   	result.texCoord = texCoord;
   
   	return result;
   }
   
   float4 PS(Input input)
   {
   	uint2 coord = uint2(input.texCoord.x * dimensions.x, input.texCoord.y * dimensions.y);
   	
   	float4 tex = float4(0.0f, 0.0f, 0.0f, 0.0f);
     
   #if SamplesMSAA == 1
   	tex = diffuse.Load(coord, 0);
   #else
   	for (uint i = 0; i < SamplesMSAA; i++)
   	{
   		tex += diffuse.Load(coord, i);
   	}
   	tex *= 1.0f / SamplesMSAA;
   #endif
   		
   	return tex;
   }

    

I could post working code somewhere, but I have most objects in DX12 wrapped, and whole engine attached to it - so it would probably make no sense and would be overly confusing (my most simple example does MSAA with deferred shading and post-tonemapping resolve... along with voxel cone tracing - that is a LOT of noise around).

Yes, you will need additional: pipeline state (therefore shaders and most likely root signature) and buffers (color and depth).

As for matching msaaTexture - I have a root signature with 1 descriptor table there, that contains 1 descriptor range. This range contains just 1 descriptor of type D3D12_DESCRIPTOR_RANGE_TYPE_SRV.

This SRV is created standardly with CreateShaderResourceView. The resource passed in is committed resource for color buffer. I might read the code later (I just briefly went through - and it doesn't contain additional pipeline state, buffers, etc. yet) - as right now I'm just on short lunch brake in work.

ResolveSubresource and ResolveSubresouceRegion (new to DX12) still exist if you don't want to do your MSAA resolve manually. If your resolve operation is just an average of the N samples then using the Resolve API will be at least as fast as doing it yourself.

You don't need additional command lists, etc. A pipeline state is enough.

You can create 2 pipeline states and in the code use:

ID3D12GraphicsCommandList::SetPipelineState(ID3D12PipelineState* pPipelineState)

In a way that:

if (msaa)
{
    cmdList.SetPipelineState(msaaPSO);
    ... 
}
else
{
    cmdList.SetPipelineState(nonMsaaPSO);
    ...
}

...