{"id":6547,"date":"2022-07-14T12:29:45","date_gmt":"2022-07-14T19:29:45","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/directx\/?p=6547"},"modified":"2022-08-05T17:06:36","modified_gmt":"2022-08-06T00:06:36","slug":"shader-model-6-7","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/directx\/shader-model-6-7\/","title":{"rendered":"Agility SDK 1.606.3: Shader Model 6.7 is now publicly available!"},"content":{"rendered":"

The DirectX Compiler Team and our partners are pleased to announce the release of Shader Model 6.7!<\/p>\n

Shader Model 6.7 expands texture fetching, quad querying, and wave capabilities to enable ever more complex (and compatible) new shader-driven features!<\/p>\n

Advanced Texture Operations<\/i><\/h2>\n

SM 6.7 adds a collection of useful texture capabilities that fill in gaps the capabilities of existing texture operations as well as adding versatile new ones collectively referred to as Advanced Texture Operations. This will be an optional feature.<\/p>\n

Integer Sampling<\/h3>\n

Textures with integer components can now be sampled. To enable this, we’ve created a new way to describe samplers with integer type border colors.<\/p>\n

typedef struct D3D12_SAMPLER_DESC2 {\r\n  D3D12_FILTER Filter; \/\/ Most of this is the same as D3D12_SAMPLER_DESC\r\n  D3D12_TEXTURE_ADDRESS_MODE AddressU;\r\n  D3D12_TEXTURE_ADDRESS_MODE AddressV;\r\n  D3D12_TEXTURE_ADDRESS_MODE AddressW;\r\n  FLOAT MipLODBias;\r\n  UINT MaxAnisotropy;\r\n  D3D12_COMPARISON_FUNC ComparisonFunc;\r\n  union {\r\n    FLOAT FloatBorderColor[4];\r\n    UINT UintBorderColor[4]; \/\/ <--- This is new!\r\n  }\r\n  FLOAT MinLOD;\r\n  FLOAT MaxLOD;\r\n  D3D12_SAMPLER_FLAGS Flags; \/\/ <-- This indicates you are using the new thing!\r\n} D3D12_SAMPLER_DESC2;<\/pre>\n
Where Flags<\/em> is the enum:<\/p>\n
enum D3D12_SAMPLER_FLAGS {\r\n  D3D12_SAMPLER_FLAG_NONE = 0\r\n  D3D12_SAMPLER_FLAG_UINT_BORDER_COLOR = 0x1\r\n}<\/pre>\n
For static samplers, you can now specify new enum values to\u00a0D3D12_STATIC_BORDER_COLOR<\/em> field in\u00a0D3D12_STATIC_SAMPLER_DESC<\/em>:<\/p>\n
  D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK_UINT,\r\n  D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE_UINT\r\n<\/pre>\n
Raw Gather<\/h3>\n
Previous gather operations grant the ability to retrieve a single channel of the sampled elements. Because the operations were limited to a single channel, retrieving all the channels of an element would require multiple gathers. Additionally, implicit conversions and other processing is done on these elements that the programmer has no control over.<\/p>\n
Raw gathers give the control to the author by retrieving the raw element data including all channels without any conversion. Like other gathers, they draw from the elements that have been sampled with bilinear filtering using Sample.\u00a0<\/em>The elements are retrieved in the form of unsigned integers of sizes matching the size of the full elements with channels packed in as specified for the underlying format.<\/p>\n
Raw gather grants the author full access to the contents of the texture and full control on how to process it.<\/p>\n
Casting Resources to Unsigned Integer Views<\/h4>\n
To glean the full benefit of raw gathers, you’ll need the relaxed format casting D3D12 feature to create unsigned integer views for the underlying formats resources. Its availability is indicated by the presence of D3D12_FEATURE_DATA_D3D12_OPTIONS12::EnhancedBarriersSupported<\/em> and D3D12_FEATURE_DATA_D3D12_OPTIONS12::RelaxedFormatCastingSupported.<\/em> To create the resource to cast to unsigned integer, use the new ID3D12Device10::reateCommittedResource3<\/em> method (or similar CreatePlacedResource2<\/em>\u00a0and CreateReservedResource2<\/em>\u00a0methods) and provide a list of resource view formats it may be cast to using the\u00a0NumCastableFormats<\/em> and\u00a0pCastableFormats <\/em>parameters. The unsigned integer cast target must be of the same size as the full element of the resource created.<\/p>\n
    HRESULT CreateCommittedResource3(\r\n        const D3D12_HEAP_PROPERTIES* pHeapProperties,\r\n        D3D12_HEAP_FLAGS HeapFlags,\r\n        const D3D12_RESOURCE_DESC1* pDesc,\r\n        D3D12_BARRIER_LAYOUT InitialLayout,\r\n        const D3D12_CLEAR_VALUE* pOptimizedClearValue,\r\n        ID3D12ProtectedResourceSession* pProtectedSession,\r\n        UINT32 NumCastableFormats,\r\n        DXGI_FORMAT *pCastableFormats,\r\n        REFIID riidResource,\r\n        void** ppvResource);\r\n<\/pre>\n
These resource views are then used in the shader to retrieve the raw texture data.<\/p>\n
Raw Gather Built-in Shader Function<\/h4>\n
For example, a R32_UINT format resource view could be created for a R8G8B8A8 texture and then within the shader the R32_UINT resource view could then be raw gathered into four 32-bit unsigned integers that represent the raw representation of the R8G8B8A8 data. The author is then able to use that data however they wish.<\/p>\n
The simplest raw gather overload is:<\/p>\n
uint32_t4 TexObj2D.GatherRaw(SamplerState S, float2 location);<\/pre>\n
Where the return type could be a 16, 32, or 64-bit integer and location<\/i>\u2019s type depends on the texture object type<\/p>\n
An example of using it to gather 4 32-bit values for a R8G8B8A8 texture:<\/p>\n
Texture2D<uint32_t> R8G8B8A8Tex : register(t0);\r\n\/\/ R32_UINT SRV aliased to a R8G8B8A8 resource\r\n\r\nSamplerState samp : register(s0);\r\n\r\n...\r\n\r\nuint32_t4 elements = R8G8B8A8Tex.GatherRaw(samp, uv);\r\n\r\n<\/pre>\n
The\u00a0elements<\/em> variable will then contain the four elements sample as determined by the sampler state and\u00a0uv<\/em> location packed into the 32 bit integers as four 8-bit values representing the RGBA channels.\u00a02D texture arrays can also be used. Where 16-bit and 64-bit integers are supported, formats of those sizes can be cast to the corresponding integer views and raw gathered as well using similar shader code. The number of channels and their layout depends on the underlying resource format.<\/p>\n
<\/a>Raw Gather Limitations<\/h4>\n
Raw Gathers require Enhanced Barriers for the full set of formats the feature has been designed to support; see our preview Agility SDK<\/a><\/span> to also get access to Enhanced Barriers. Without Enhanced Barriers and Relaxed Format Casting support, only the following formats that could previously be cast to uint views will be castable:<\/span><\/p>\n\n\n\n\n\n\n\n\n\n\n\n
Format<\/span>\u00a0<\/span><\/td>\nCastable to View Format<\/span>\u00a0<\/span><\/td>\n<\/tr>\n
R32_TYPELESS<\/span>\u00a0<\/span><\/td>\nR32_UINT<\/span>\u00a0<\/span><\/td>\n<\/tr>\n
R32_SINT<\/span>\u00a0<\/span><\/td>\nR32_UINT<\/span>\u00a0<\/span><\/td>\n<\/tr>\n
R16_TYPELESS<\/span>\u00a0<\/span><\/td>\nR16_UINT<\/span>\u00a0<\/span><\/td>\n<\/tr>\n
R16_SINT<\/span>\u00a0<\/span><\/td>\nR16_UINT<\/span>\u00a0<\/span><\/td>\n<\/tr>\n
R16_UNORM<\/span>\u00a0<\/span><\/td>\nR16_UINT<\/span>\u00a0<\/span><\/td>\n<\/tr>\n
R16_SNORM<\/span>\u00a0<\/span><\/td>\nR16_UINT<\/span>\u00a0<\/span><\/td>\n<\/tr>\n
R32G32_TYPELESS<\/span>\u00a0<\/span><\/td>\nR32G32_UINT (Serves as 64-bit uint)<\/span>\u00a0<\/span><\/td>\n<\/tr>\n
R32G32_SINT<\/span>\u00a0<\/span><\/td>\nR32G32_UINT<\/span>\u00a0<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
<\/h3>\n
Programmable Offsets<\/i><\/h3>\n
Existing sample and load operations require their offsets to be immediate integers. Programmers had to decide on the offset values they wanted prior even to shader compile time. To say the least, this made them of limited use.<\/p>\n
Shader Model 6.7 frees offset arguments to the full suite of sample and load operations to be variable values just as they can be in gather operations. The effective range remains [-8,7], by respecting only the 4 least significant bits of the provided offset values. The full list of affected resource methods:<\/p>\n
Load( int2 Location, int2 Offset, [out uint Status] );\r\nSample( SamplerState S, float2 Location, int2 Offset,\r\n        [float Clamp], [out uint Status] );\r\nSampleBias( SamplerState S, float2 Location, float Bias,\r\n            int2 Offset, [float Clamp], [out uint Status] );\r\nSampleCmp( SamplerComparisonState S, float2 Location,\r\n           float CompareValue, int2 Offset, [float Clamp], [out uint Status] );\r\nSampleCmpLevelZero( SamplerComparisonState S, float2 Location,\r\n                    float CompareValue, int2 Offset, [out uint Status] );\r\nSampleGrad( SamplerState S, float2 Location, float DDX, float DDY,\r\n            int2 Offset, [float Clamp], [out uint<N> Status]);\r\nSampleLevel( SamplerState S, float2 Location, float LOD, int2 Offset,\r\n             [out uint Status]);\r\n<\/pre>\n
Note that the above list assumes a Texture2D resource. For other resources, the int2<\/em> and float2<\/em> types for offset<\/em> and location<\/em> might be different sized vectors depending on the method’s object.<\/p>\n
Explicit Sample Compare Level<\/i><\/h3>\n
Previously, to perform same and compare operation, you could either use the default SampleCmp<\/em>, which used a MIP level determined by the location gradients or access the zero level using SampleCmpLevelZero<\/em>. This left an obvious gap in functionality where using smaller MIP levels explicitly indexed would be useful. Shader Model 6.7 adds SampleCmpLevel<\/em> which simply allows you to specify the level you want to sample and compare to:<\/p>\n
SampleCmpLevel( SamplerComparisonState S, float2 Location,\r\n                float CompareValue, float LOD, [int2 Offset], [out uint Status]);\r\n<\/pre>\n
As before, this is the Texture2D method and the vector sizes of Location<\/em> and Offset<\/em> will vary for other resource methods. Along with the pre-existing sample operations, SampleCmpLevel<\/em> includes the programmable offsets feature of 6.7 allowing its offset parameter to be variable as well.<\/p>\n
Cube map variants are also included which take a slightly different method signature:<\/p>\n
Format TextureCube::SampleCmpLevel( SamplerComparisonState S, float3 Location,\r\n                                   float CompareValue, float LOD, [out uint Status]);\r\nFormat TextureCubeArray::SampleCmpLevel( SamplerComparisonState S, float4 Location,\r\n                                        float CompareValue, float LOD, [out uint Status]);<\/pre>\n
Writable Multisampled Textures<\/i><\/h3>\n
We’ve introduced writable multisampled texture types to permit specific multisampled texture alterations beyond use of them as render targets.\u00a0 Previously, multisampled textures could only be bound as render targets or read-only inputs. Expanded multisampled texture writability will allow shader authors to alter sampled texture contents more specifically, perhaps focusing on key areas while leaving areas of less interest to the default behavior.<\/p>\n
The following resource types with corresponding methods can be used to bind and write to multisampled texture information:<\/p>\n
RWTexture2DMS<Type, Samples>\r\nRWTexture2DMSArray<Type, Samples>\r\n<\/pre>\n
The Type<\/em> and Samples<\/em> template variables represent the HLSL type of the resource and the number of samples. Unlike read-only multisampled texture resource types, they are required.<\/p>\n
These new types can be accessed much like their read-only counterparts using a single index operator [loc] <\/em>which references sample index 0 at location\u00a0loc<\/em> or the .sample[samp][loc] <\/em>operator which accesses sample index\u00a0samp<\/em> at location\u00a0loc<\/em>. The difference is that, in addition to being readable as before, they can be assignment targets:<\/p>\n
RWTexture2DMS<float4, 4> g_ms;\r\nfloat4 main(float2 loc : TEXCOORD0) : SV_Target {\r\n  g_ms[loc] = GetZeroSamp(loc);\r\n  g_ms.sample[1][loc] = GetOneSamp(loc);\r\n...<\/pre>\n
QuadAny\/QuadAll<\/i><\/h2>\n
We’ve added two new quad ops to HLSL that allow any and all operations on lanes within a quad. As with all quad operations, this is best illustrated with cats in boxes:<\/p>\n\n\n\n\n\n\n\n\n
\"Image<\/a><\/td>\n\"Image<\/a><\/td>\n<\/tr>\n
IsHelperLane\u00a0\u00a0<\/strong><\/td>\nQuadReadAcrossDiagonal<\/strong><\/td>\n<\/tr>\n
\"Image<\/a><\/td>\n\"Image<\/a><\/td>\n<\/tr>\n
\u00a0QuadReadAcrossX\u00a0\u00a0<\/strong><\/td>\nQuadReadAcrossY<\/strong><\/td>\n<\/tr>\n
\"Image<\/a><\/td>\n\"Image<\/a><\/td>\n<\/tr>\n
QuadAny<\/strong><\/td>\nQuadAll<\/strong><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
 <\/p>\n
 <\/p>\n
(Sorry they don’t look much like cats\ud83d\ude15 Engineer art \ud83d\ude06)<\/p>\n
The bottom row contains the new efficient queries that determine if a given expression is true for any or all of the lanes in the current quad are true.<\/p>\n
Quads can return whether any or all of them evaluate an expression to true<\/p>\n
QuadAny can efficiently resolve non-quad-uniform flow problems:<\/p>\n
float4 main(int x: X, float2 uv : TEXCOORD0) : SV_Target {\r\n  float4 ret = 0;\r\n  float2 temp_uv = modifyuv(uv);\r\n  if (x > SCREEN_X)\r\n    ret = t0.Sample(s0, temp_uv);\r\n  return ret;\r\n}<\/pre>\n
BECOMES<\/p>\n
float4 main(float x : X, float2 uv : TEXCOORD0) : SV_Target {\r\n  float4 ret = 0;\r\n  if (QuadAny(x > SCREEN_X)) {\r\n    float2 temp_uv = modifyuv(uv);\r\n    float4 sampled_result = t0.Sample(s0, temp_uv);\r\n    if (x > SCREEN_X)\r\n      ret = sampled_result;\r\n  }\r\n  return ret;\r\n}<\/pre>\n
Helper Lanes in Wave Ops Mode<\/i><\/h2>\n
Sometimes you need a little help. For those times, Shader Model 6.7 introduces the WaveOpsIncludeHelperlanes Attribute!<\/p>\n
Helper lanes previously only contributed to derivative calculations and not wave operations. That meant that derivative operations that depend on values or control flow that derived from wave operations had undefined results. In combination with the\u00a0IsHelperLane()<\/em>\u00a0query added with Shader Model 6.6, developers will have full control over how wave ops interact and behave on helper lanes. This control will allow derivative operations to be reliably used in the presence of wave operations.<\/p>\n
This is effected by applying the WaveOpsIncludeHelperLanes\u00a0<\/i>attribute to the shader entry function:<\/p>\n
[WaveOpsIncludeHelperLanes] \/\/ Yes, it's just this easy!\r\nvoid func() ...\r\n<\/pre>\n
Lanes will be created as or demoted to helper lanes exactly as they were before. The only effect of this attribute is that they will now contribute to the wave functions and, as such, they will persist until the last wave operation is complete so that they can contribute to those results. So some helper lanes might stick around a bit longer than they used to.<\/p>\n
Great! How Can I Try It Out?<\/h2>\n
I love your enthusiasm! You need three things:<\/p>\n