Implement the `Process2DQuadTessFactorsMax` HLSL Function

[ ] Implement Process2DQuadTessFactorsMax clang builtin,
[ ] Link Process2DQuadTessFactorsMax clang builtin with hlsl_intrinsics.h
[ ] Add sema checks for Process2DQuadTessFactorsMax to CheckHLSLBuiltinFunctionCall in SemaChecking.cpp
[ ] Add codegen for Process2DQuadTessFactorsMax to EmitHLSLBuiltinExpr in CGBuiltin.cpp
[ ] Add codegen tests to clang/test/CodeGenHLSL/builtins/Process2DQuadTessFactorsMax.hlsl
[ ] Add sema tests to clang/test/SemaHLSL/BuiltIns/Process2DQuadTessFactorsMax-errors.hlsl
[ ] Create the int_dx_Process2DQuadTessFactorsMax intrinsic in IntrinsicsDirectX.td
[ ] Create the DXILOpMapping of int_dx_Process2DQuadTessFactorsMax to 106 in DXIL.td
[ ] Create the Process2DQuadTessFactorsMax.ll and Process2DQuadTessFactorsMax_errors.ll tests in llvm/test/CodeGen/DirectX/

DirectX

DXIL Opcode	DXIL OpName	Shader Model	Shader Stages
106	StorePatchConstant	6.0	('hull',)

SPIR-V

There is no support for Process2DQuadTessFactorsMax when targeting SPIR-V.

Test Case(s)

Example 1

//dxc Process2DQuadTessFactorsMax_test.hlsl -T hs_6_8 -enable-16bit-types -O0

struct HSPerPatchData
{
    float edges[ 3 ] : SV_TessFactor;
    float inside : SV_InsideTessFactor;
};
struct PSSceneIn {
    float4 pos : SV_Position;
    float2 tex : TEXCOORD0;
    float3 norm : NORMAL;
};
struct HSPerVertexData {
    PSSceneIn v;
};

export HSPerPatchData fn( const InputPatch< PSSceneIn, 3 > points ) {
    HSPerPatchData d;
    float4 edgeFactor;
    float2 insideFactor;float4 p1;
float2 p2;
float4 p3;
float2 p4;
float2 p5;
Process2DQuadTessFactorsMax(p1, p2, p3, p4, p5);

    d.edges[0]=edgeFactor.x;
    d.edges[1]=edgeFactor.y;
    d.edges[2]=edgeFactor.z + edgeFactor.w;
    d.inside = insideFactor.x + insideFactor.y;
    return d;
}

[domain("tri")]
[outputtopology("triangle_cw")]
[patchconstantfunc("fn")]
[outputcontrolpoints(3)]
[partitioning("pow2")]
HSPerVertexData main( const uint id : SV_OutputControlPointID,const InputPatch< PSSceneIn, 3 > points ) {

    HSPerVertexData v;
    v.v = points[ id ];
    return v;
}

HLSL:

Generates the corrected tessellation factors for a quad patch.

Syntax

void Process2DQuadTessFactorsMax(
  in  float4 RawEdgeFactors,
  in  float2 InsideScale,
  out float4 RoundedEdgeTessFactors,
  out float2 RoundedInsideTessFactors,
  out float2 UnroundedInsideTessFactors
);

Parameters

*RawEdgeFactors* \[in\]: Type: **float4** The edge tessellation factors, passed into the tessellator stage.
*InsideScale* \[in\]: Type: **float2** The scale factor applied to the UV tessellation factors computed by the tessellation stage. The allowable range for InsideScale is 0.0 to 1.0.
*RoundedEdgeTessFactors* \[out\]: Type: **float4** The rounded edge-tessellation factors calculated by the tessellator stage.
*RoundedInsideTessFactors* \[out\]: Type: **float2** The rounded tessellation factors calculated by the tessellator stage for inside edges.
*UnroundedInsideTessFactors* \[out\]: Type: **float2** The tessellation factors calculated by the tessellator stage for inside edges.

Return value

This function does not return a value.

Remarks

Generates the corrected tessellation factors for a quad patch, computing the inside tessellation factors as the maximum of the edge tessellation factors. The U and V inside tessellation factors are computed independently using the maximums of opposing sides of the domain, then are scaled by InsideScale. The result is then rounded based on the partitioning mode, but the unrounded results are available using the UnroundedInsideTessFactors parameter.

Minimum Shader Model

This function is supported in the following shader models.

Shader Model	Supported
Shader Model 5 and higher shader models	yes

This function is supported in the following types of shaders:

Vertex	Hull	Domain	Geometry	Pixel	Compute
	x

llvm / llvm-project