Introduced new macros for flow control attributes.

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/API/D3D11.hlsl

 #define CBUFFER_START(name) cbuffer name {
 #define CBUFFER_END };
 
+// flow control attributes
+#define UNITY_BRANCH        [branch]
+#define UNITY_FLATTEN       [flatten]
+#define UNITY_UNROLL        [unroll]
+#define UNITY_UNROLLX(_x)   [unroll(_x)]
+#define UNITY_LOOP          [loop]
+
 // Initialize arbitrary structure with zero values.
 // Do not exist on some platform, in this case we need to have a standard name that call a function that will initialize all parameters to 0
 #define ZERO_INITIALIZE(type, name) name = (type)0;

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/API/PSSL.hlsl

 #define CBUFFER_START(name) cbuffer name {
 #define CBUFFER_END };
 
+// flow control attributes
+#define UNITY_BRANCH        [branch]
+#define UNITY_FLATTEN       [flatten]
+#define UNITY_UNROLL        [unroll]
+#define UNITY_UNROLLX(_x)   [unroll(_x)]
+#define UNITY_LOOP          [loop]
+
 // Initialize arbitrary structure with zero values.
 // Do not exist on some platform, in this case we need to have a standard name that call a function that will initialize all parameters to 0
 #define ZERO_INITIALIZE(type, name) name = (type)0;

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/API/Validate.hlsl

 REQUIRE_DEFINED(INITIALIZE_OUTPUT)
 
 */
+
+
+// Default values for things that have not been defined in the platform headers
+
+// default flow control attributes
+#ifndef UNITY_BRANCH
+#   define UNITY_BRANCH
+#endif
+#ifndef UNITY_FLATTEN
+#   define UNITY_FLATTEN
+#endif
+#ifndef UNITY_UNROLL
+#   define UNITY_UNROLL
+#endif
+#ifndef UNITY_UNROLLX
+#   define UNITY_UNROLLX(_x)
+#endif
+#ifndef UNITY_LOOP
+#   define UNITY_LOOP
+#endif

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/API/XBoxOne.hlsl

 #define CBUFFER_START(name) cbuffer name {
 #define CBUFFER_END };
 
+// flow control attributes
+#define UNITY_BRANCH        [branch]
+#define UNITY_FLATTEN       [flatten]
+#define UNITY_UNROLL        [unroll]
+#define UNITY_UNROLLX(_x)   [unroll(_x)]
+#define UNITY_LOOP          [loop]
+
 // Initialize arbitrary structure with zero values.
 // Do not exist on some platform, in this case we need to have a standard name that call a function that will initialize all parameters to 0
 #define ZERO_INITIALIZE(type, name) name = (type)0;

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/AreaLighting.hlsl

 
         real e = sinSqSigma * cosOmega;
 
-        [branch]
+        UNITY_BRANCH
         if (omega < HALF_PI - sigma)
         {
             // No horizon occlusion (case #1).
     #else // Ref: Moving Frostbite to Physically Based Rendering, page 47 (2015, optimized).
         real cosSqOmega = cosOmega * cosOmega;                     // y^2
 
-        [branch]
+        UNITY_BRANCH
         if (cosSqOmega > sinSqSigma)                                // (y^2)>x
         {
             return saturate(sinSqSigma * cosOmega);                 // Clip[x*y,{0,1}]
 real PolygonIrradiance(real4x3 L)
 {
 #ifdef APPROXIMATE_POLY_LIGHT_AS_SPHERE_LIGHT
-    [unroll]
+    UNITY_UNROLL
     for (uint i = 0; i < 4; i++)
     {
         L[i] = normalize(L[i]);
 
-    [unroll]
+    UNITY_UNROLL
     for (uint edge = 0; edge < 4; edge++)
     {
         real3 V1 = L[edge];

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Shadow/Resources/ShadowBlurMoments.compute

 	int2 ldsIdx = (int2) groupThreadId.xy;
 	moment_t hblurredMoments[2];
 
-	[unroll]
+	UNITY_UNROLL
-		[unroll]
+		UNITY_UNROLL
 		for( int iw = 0; iw < 2; iw++ )
 		{
 			if( ldsIdx.x < LDS_STRIDE )
-				[loop]
+				UNITY_LOOP
 				for( uint is = 0; is < sampleCnt; is++ )
 				{
 					float depth = depthTex.Load( min( srcIdx, validSrc ), is ).x;
 
 		hblurredMoments[ih] = 0;
 		int2 idx = { groupThreadId.x + blurBorder, groupThreadId.y };
-		[loop]
+		UNITY_LOOP
 		for( int blurOffset = -blurBorder; blurOffset <= blurBorder; blurOffset++ )
 		{
 			hblurredMoments[ih] += readFromShared( int2( idx.x + blurOffset, idx.y ), LDS_STRIDE ) * blurWeights[abs( blurOffset )];
 	ldsIdx = (int2) groupThreadId.xy + int2( 0, blurBorder );
 	moment_t vblurredMoment = 0.0;
 
-	[unroll]
+	UNITY_UNROLL
 	for( int blurOffset = -blurBorder; blurOffset <= blurBorder; blurOffset++ )
 	{
 		vblurredMoment += readFromShared( int2( ldsIdx.x, ldsIdx.y + blurOffset ), THREADS ) * blurWeights[abs(blurOffset)];

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Shadow/ShadowAlgorithms.hlsl

 {
 	real weight = 1.0;
 
-	[branch]
+	UNITY_BRANCH
 	if( shadowAlgorithm <= GPUSHADOWALGORITHM_PCF_TENT_7X7 )
 	{
 		real3 pos = EvalShadow_ReceiverBiasWeightPos( positionWS, normalWS, L, EvalShadow_WorldTexelSize( sd, L_dist, perspProj ), sd.edgeTolerance, EvalShadow_ReceiverBiasWeightUseNormalFlag( sd.normalBias.w ) );
 	UnpackShadowType( sd.shadowType, shadowType, shadowAlgorithm );
 
 	// load the right shadow data for the current face
-	[branch]
+	UNITY_BRANCH
 	if( shadowType == GPUSHADOWTYPE_POINT )
 	{
 		sd.rot0           = shadowContext.shadowDatas[index + CubeMapFaceID( -L ) + 1].rot0;
 		UnpackShadowType( sd.shadowType, shadowType );																									                                            \
 																																																	\
 		/* load the right shadow data for the current face */																															            \
-		[branch]																																										            \
-		if( shadowType == GPUSHADOWTYPE_POINT )																																			            \
+		UNITY_BRANCH                                                                                                                                                                                \
+		if( shadowType == GPUSHADOWTYPE_POINT )																																		                \
 		{                                                                                                                                                                                           \
 			sd.rot0           = shadowContext.shadowDatas[index + CubeMapFaceID( -L ) + 1].rot0;																					                \
 			sd.rot1           = shadowContext.shadowDatas[index + CubeMapFaceID( -L ) + 1].rot1;																					                \
 		{
 			EvalShadow_LoadCascadeData( shadowContext, index + 1 + shadowSplitIndex, sd );
 			positionWS = EvalShadow_ReceiverBias( sd, orig_pos, normalWS, L, 1.0, recvBiasWeight, false );
-	        real3 posNDC;
+			real3 posNDC;
-			[branch]
+			UNITY_BRANCH
 			if( all( abs( posNDC.xy ) <= (1.0 - sd.texelSizeRcp.zw * 0.5) ) )
 				shadow1 = SampleShadow_SelectAlgorithm( shadowContext, sd, orig_payloadOffset, posTC, sampleBias, shadowAlgorithm, texIdx, sampIdx );
 		}
 			{                                                                                                                                                                                                       \
 				EvalShadow_LoadCascadeData( shadowContext, index + 1 + shadowSplitIndex, sd );																										                \
 				positionWS = EvalShadow_ReceiverBias( sd, orig_pos, normalWS, L, 1.0, recvBiasWeight, false );				                                                                                        \
-		        real3 posNDC;                                                                                                                                                                                       \
+				real3 posNDC;                                                                                                                                                                                       \
-				[branch]                                                                                                                                                                                            \
+				UNITY_BRANCH                                                                                                                                                                                        \
 				if( all( abs( posNDC.xy ) <= (1.0 - sd.texelSizeRcp.zw * 0.5) ) )                                                                                                                                   \
 					shadow1 = SampleShadow_SelectAlgorithm( shadowContext, sd, orig_payloadOffset, posTC, sampleBias, shadowAlgorithms[shadowSplitIndex], tex, samp );                                              \
 			}                                                                                                                                                                                                       \

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Shadow/ShadowSampling.hlsl

 	real2 fetchesUV[4];
 
 	SampleShadow_ComputeSamples_Tent_3x3(shadowMapTexture_TexelSize, coord.xy, fetchesWeights, fetchesUV);
-	[loop] for (int i = 0; i < 4; i++)
+	UNITY_LOOP
+	for( int i = 0; i < 4; i++ )
 	{
 		shadow += fetchesWeights[i] * SampleCompShadow_T2DA( shadowContext, texIdx, sampIdx, real3( fetchesUV[i].xy, coord.z + dot( fetchesUV[i].xy - coord.xy, sampleBias ) ), slice ).x;
 	}
 	real2 fetchesUV[9];
 
 	SampleShadow_ComputeSamples_Tent_5x5( shadowMapTexture_TexelSize, coord.xy, fetchesWeights, fetchesUV );
-	[loop] for (int i = 0; i < 9; i++)
+	UNITY_LOOP
+	for( int i = 0; i < 9; i++ )
 	{
 		shadow += fetchesWeights[i] * SampleCompShadow_T2DA( shadowContext, texIdx, sampIdx, real3( fetchesUV[i].xy, coord.z + dot( fetchesUV[i].xy - coord.xy, sampleBias ) ), slice ).x;
 	}
 #if SHADOW_OPTIMIZE_REGISTER_USAGE == 1 && SHADOW_USE_SAMPLE_BIASING == 0
 	// the loops are only there to prevent the compiler form coalescing all 9 texture fetches which increases register usage
 	int i;
-	[loop]
+	UNITY_LOOP
 	for( i = 0; i < 1; i++ )
 	{
 		shadow += fetchesWeights[ 0] * SAMPLE_TEXTURE2D_ARRAY_SHADOW( tex, compSamp, real3( fetchesUV[ 0].xy, coord.z + dot( fetchesUV[ 0].xy - coord.xy, sampleBias ) ), slice ).x;
 	}
 
-	[loop]
+	UNITY_LOOP
 	for( i = 0; i < 1; i++ )
 	{
 		shadow += fetchesWeights[ 4] * SAMPLE_TEXTURE2D_ARRAY_SHADOW( tex, compSamp, real3( fetchesUV[ 4].xy, coord.z + dot( fetchesUV[ 4].xy - coord.xy, sampleBias ) ), slice ).x;
 	real2 fetchesUV[16];
 
 	SampleShadow_ComputeSamples_Tent_7x7( shadowMapTexture_TexelSize, coord.xy, fetchesWeights, fetchesUV );
-	[loop] for (int i = 0; i < 16; i++)
+	UNITY_LOOP
+	for( int i = 0; i < 16; i++ )
 	{
 		shadow += fetchesWeights[i] * SampleCompShadow_T2DA( shadowContext, texIdx, sampIdx, real3( fetchesUV[i].xy, coord.z + dot( fetchesUV[i].xy - coord.xy, sampleBias ) ), slice ).x;
 	}
 #if SHADOW_OPTIMIZE_REGISTER_USAGE == 1
 	// the loops are only there to prevent the compiler form coalescing all 16 texture fetches which increases register usage
 	int i;
-	[loop]
+	UNITY_LOOP
 	for( i = 0; i < 1; i++ )
 	{
 		shadow += fetchesWeights[ 0] * SAMPLE_TEXTURE2D_ARRAY_SHADOW( tex, compSamp, real3( fetchesUV[ 0].xy, coord.z + dot( fetchesUV[ 0].xy - coord.xy, sampleBias ) ), slice ).x;
 	}
-
-	[loop]
+	UNITY_LOOP
 	for( i = 0; i < 1; i++ )
 	{
 		shadow += fetchesWeights[ 4] * SAMPLE_TEXTURE2D_ARRAY_SHADOW( tex, compSamp, real3( fetchesUV[ 4].xy, coord.z + dot( fetchesUV[ 4].xy - coord.xy, sampleBias ) ), slice ).x;
 	}
-	[loop]
+	UNITY_LOOP
 	for( i = 0; i < 1; i++ )
 	{
 		shadow += fetchesWeights[ 8] * SAMPLE_TEXTURE2D_ARRAY_SHADOW( tex, compSamp, real3( fetchesUV[ 8].xy, coord.z + dot( fetchesUV[ 8].xy - coord.xy, sampleBias ) ), slice ).x;
 	}
-	[loop]
+	UNITY_LOOP
 	for( i = 0; i < 1; i++ )
 	{
 		shadow += fetchesWeights[12] * SAMPLE_TEXTURE2D_ARRAY_SHADOW( tex, compSamp, real3( fetchesUV[12].xy, coord.z + dot( fetchesUV[12].xy - coord.xy, sampleBias ) ), slice ).x;
 	real2 depthScale  = evsmExponents * warpedDepth;
 	real2 minVariance = depthScale * depthScale * varianceBias;
 
-	[branch]
+	UNITY_BRANCH
 	if( fourMoments )
 	{
 		real posContrib = ShadowMoments_ChebyshevsInequality( moments.xz, warpedDepth.x, minVariance.x, lightLeakBias );
 	real2 depthScale  = evsmExponents * warpedDepth;
 	real2 minVariance = depthScale * depthScale * varianceBias;
 
-	[branch]
+	UNITY_BRANCH
 	if( fourMoments )
 	{
 		real posContrib = ShadowMoments_ChebyshevsInequality( moments.xz, warpedDepth.x, minVariance.x, lightLeakBias );
 // helper function to dispatch a specific shadow algorithm
 real SampleShadow_SelectAlgorithm( ShadowContext shadowContext, ShadowData shadowData, inout uint payloadOffset, real3 posTC, real2 sampleBias, uint algorithm, uint texIdx, uint sampIdx )
 {
-	[branch]
+	UNITY_BRANCH
 	switch( algorithm )
 	{
 	case GPUSHADOWALGORITHM_PCF_1TAP		: return SampleShadow_PCF_1tap( shadowContext, payloadOffset, posTC, shadowData.slice, texIdx, sampIdx );
 
 real SampleShadow_SelectAlgorithm( ShadowContext shadowContext, ShadowData shadowData, inout uint payloadOffset, real3 posTC, real2 sampleBias, uint algorithm, Texture2DArray tex, SamplerComparisonState compSamp )
 {
-	[branch]
+	UNITY_BRANCH
 	switch( algorithm )
 	{
 	case GPUSHADOWALGORITHM_PCF_1TAP		: return SampleShadow_PCF_1tap( shadowContext, payloadOffset, posTC, shadowData.slice, tex, compSamp );
 
 real SampleShadow_SelectAlgorithm( ShadowContext shadowContext, ShadowData shadowData, inout uint payloadOffset, real3 posTC, real2 sampleBias, uint algorithm, Texture2DArray tex, SamplerState samp )
 {
-	[branch]
+	UNITY_BRANCH
 	switch( algorithm )
 	{
 	case GPUSHADOWALGORITHM_VSM				: return SampleShadow_VSM_1tap(  shadowContext, payloadOffset, posTC, shadowData.slice, tex, samp );

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Shadow/ShadowTexFetch.hlsl

 		real4 SampleCompShadow_T2DA( ShadowContext ctxt, uint texIdx, uint sampIdx, real3 tcs, real slice )					    \
 		{																														\
 			real4 res = 1.0.xxxx;																								\
-			[unroll] for( uint i = 0; i < _Tex2DArraySlots; i++ )																\
+			UNITY_UNROLL for( uint i = 0; i < _Tex2DArraySlots; i++ )															\
-				[unroll] for( uint j = 0; j < _SamplerCompSlots; j++ )															\
+				UNITY_UNROLL for( uint j = 0; j < _SamplerCompSlots; j++ )														\
-					[branch] if( i == texIdx && j == sampIdx )																	\
+					UNITY_BRANCH if( i == texIdx && j == sampIdx )																\
 					{																											\
 						res = SAMPLE_TEXTURE2D_ARRAY_SHADOW( ctxt.tex2DArray[i], ctxt.compSamplers[j], tcs, slice );			\
 						break;																									\
 		real4 SampleShadow_T2DA( ShadowContext ctxt, uint texIdx, uint sampIdx, real2 tcs, real slice, real lod = 0.0 )		    \
 		{																														\
 			real4 res = 1.0.xxxx;																								\
-			[unroll] for( uint i = 0; i < _Tex2DArraySlots; i++ )																\
+			UNITY_UNROLL for( uint i = 0; i < _Tex2DArraySlots; i++ )															\
-				[unroll] for( uint j = 0; j < _SamplerSlots; j++ )																\
+				UNITY_UNROLL for( uint j = 0; j < _SamplerSlots; j++ )															\
-					[branch] if( i == texIdx && j == sampIdx )																	\
+					UNITY_BRANCH if( i == texIdx && j == sampIdx )																\
 					{																											\
 						res = SAMPLE_TEXTURE2D_ARRAY_LOD( ctxt.tex2DArray[i], ctxt.samplers[j], tcs, slice, lod );				\
 						break;																									\
 		real LoadShadow_T2DA( ShadowContext ctxt, uint texIdx, uint2 tcs, uint slice, uint lod = 0 )		                    \
 		{																														\
 			real res = 1.0;																								        \
-			[unroll] for( uint i = 0; i < _Tex2DArraySlots; i++ )																\
+			UNITY_UNROLL for( uint i = 0; i < _Tex2DArraySlots; i++ )															\
-				[branch] if( i == texIdx )																	                    \
+				UNITY_BRANCH if( i == texIdx )																	                \
 				{																											    \
 					res = LOAD_TEXTURE2D_ARRAY_LOD( ctxt.tex2DArray[i], tcs, slice, lod ).x;				                    \
 					break;																									    \
 		real4 SampleCompShadow_TCA( ShadowContext ctxt, uint texIdx, uint sampIdx, real4 tcs, real cubeIdx )					\
 		{																														\
 			real4 res = 1.0.xxxx;																								\
-			[unroll] for( uint i = 0; i < _TexCubeArraySlots; i++ )																\
+			UNITY_UNROLL for( uint i = 0; i < _TexCubeArraySlots; i++ )															\
-				[unroll] for( uint j = 0; j < _SamplerCompSlots; j++ )															\
+				UNITY_UNROLL for( uint j = 0; j < _SamplerCompSlots; j++ )														\
-					[branch] if( i == texIdx && j == sampIdx )																	\
+					UNITY_BRANCH if( i == texIdx && j == sampIdx )																\
 					{																											\
 						res = SAMPLE_TEXTURECUBE_ARRAY_SHADOW( ctxt.texCubeArray[i], ctxt.compSamplers[j], tcs, cubeIdx );		\
 						break;																									\
 		real4 SampleShadow_TCA( ShadowContext ctxt, uint texIdx, uint sampIdx, real3 tcs, real cubeIdx, real lod = 0.0 )	    \
 		{																														\
 			real4 res = 1.0.xxxx;																								\
-			[unroll] for( uint i = 0; i < _TexCubeArraySlots; i++ )																\
+			UNITY_UNROLL for( uint i = 0; i < _TexCubeArraySlots; i++ )															\
-				[unroll] for( uint j = 0; j < _SamplerSlots; j++ )																\
+				UNITY_UNROLL for( uint j = 0; j < _SamplerSlots; j++ )															\
-					[branch] if( i == texIdx && j == sampIdx )																	\
+					UNITY_BRANCH if( i == texIdx && j == sampIdx )																\
 					{																											\
 						res = SAMPLE_TEXTURECUBE_ARRAY_LOD( ctxt.texCubeArray[i], ctxt.samplers[j], tcs, cubeIdx, lod );		\
 						break;																									\

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightEvaluation.hlsl

     color       = lightData.color;
     attenuation = 1.0; // Note: no volumetric attenuation along shadow rays for directional lights
 
-    [branch] if (lightData.cookieIndex >= 0)
+    UNITY_BRANCH if (lightData.cookieIndex >= 0)
     {
         float3 lightToSample = positionWS - lightData.positionWS;
         float3 cookie = EvaluateCookie_Directional(lightLoopContext, lightData, lightToSample);
     shadow = shadowMask = (lightData.shadowMaskSelector.x >= 0.0) ? dot(bakeLightingData.bakeShadowMask, lightData.shadowMaskSelector) : 1.0;
 #endif
 
-    [branch] if (lightData.shadowIndex >= 0)
+    UNITY_BRANCH if (lightData.shadowIndex >= 0)
     {
 #ifdef USE_DEFERRED_DIRECTIONAL_SHADOWS
         shadow = LOAD_TEXTURE2D(_DeferredShadowTexture, posInput.positionSS).x;
 
     float4 cookie;
 
-    [branch] if (lightType == GPULIGHTTYPE_POINT)
+    UNITY_BRANCH if (lightType == GPULIGHTTYPE_POINT)
     {
         cookie.rgb = SampleCookieCube(lightLoopContext, positionLS, lightData.cookieIndex);
         cookie.a   = 1;
 #endif
 
     // Projector lights always have cookies, so we can perform clipping inside the if().
-    [branch] if (lightData.cookieIndex >= 0)
+    UNITY_BRANCH if (lightData.cookieIndex >= 0)
     {
         float4 cookie = EvaluateCookie_Punctual(lightLoopContext, lightData, lightToSample);
 
     shadow = shadowMask = (lightData.shadowMaskSelector.x >= 0.0) ? dot(bakeLightingData.bakeShadowMask, lightData.shadowMaskSelector) : 1.0;
 #endif
 
-    [branch] if (lightData.shadowIndex >= 0)
+    UNITY_BRANCH if (lightData.shadowIndex >= 0)
     {
         // TODO: make projector lights cast shadows.
         shadow = GetPunctualShadowAttenuation(lightLoopContext.shadowContext, positionWS, N, lightData.shadowIndex, L, distances.x, posInput.positionSS);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/Shadow.hlsl

 	uint shadowType;
 	UnpackShadowType( sd.shadowType, shadowType );
 
-	[branch]
+	UNITY_BRANCH
 	if( shadowType == GPUSHADOWTYPE_POINT )
 	{
 		Texture2DArray			tex      = shadowContext.tex2DArray[SHADOW_DISPATCH_POINT_TEX];

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/lightlistbuild-bigtile.compute

 
 		bool canEnter = idxCoarse<(uint) g_iNrVisibLights;
 		if(canEnter) canEnter = _LightVolumeData[idxCoarse].lightVolume != LIGHTVOLUMETYPE_SPHERE;		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
-		[branch]if(canEnter)
+		UNITY_BRANCH if(canEnter)
 		{
 			SFiniteLightBound lgtDat = g_data[idxCoarse];
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/lightlistbuild-clustered.compute

 		GroupMemoryBarrierWithGroupSync();
 #endif
 		const int idxCoarse = coarseList[l];
-		[branch]if (_LightVolumeData[idxCoarse].lightVolume != LIGHTVOLUMETYPE_SPHERE)		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
+		UNITY_BRANCH if (_LightVolumeData[idxCoarse].lightVolume != LIGHTVOLUMETYPE_SPHERE)		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
 		{
 			SFiniteLightBound lgtDat = g_data[idxCoarse];
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/lightlistbuild.compute

 	float4 vLinDepths;
 	{
 		// Fetch depths and calculate min/max
-		[unroll]
+		UNITY_UNROLL
 		for(int i = 0; i < 4; i++)
 		{
 			int idx = i * NR_THREADS + t;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/materialflags.compute

 	GroupMemoryBarrierWithGroupSync();
 
 	uint materialFeatureFlags = g_BaseFeatureFlags; // Contain all lightFeatures or 0 (depends if we enable light classification or not)
-	[unroll]
+	UNITY_UNROLL
 	for(int i = 0; i < 4; i++)
 	{
 		int idx = i * NR_THREADS + threadID;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Volumetrics/Resources/VolumetricLighting.compute

         tileCoord = WaveReadFirstLane(tileCoord);
     }
 
-    [branch] if (voxelCoord.x >= (uint)_VBufferResolution.x ||
+    UNITY_BRANCH if (voxelCoord.x >= (uint)_VBufferResolution.x ||
                  voxelCoord.y >= (uint)_VBufferResolution.y)
     {
         return;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Volumetrics/VBuffer.hlsl

     // TODO: add the proper sampler support.
     bool isInBounds = Min3(uv.x, uv.y, d) > 0 && Max3(uv.x, uv.y, d) < 1;
 
-    [branch] if (clampToEdge || isInBounds)
+    UNITY_BRANCH if (clampToEdge || isInBounds)
     {
     #if 1
         // Ignore non-linearity (for performance reasons) at the cost of accuracy.

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/LayeredLit/LayeredLitData.hlsl

     // If a top layer doesn't use the full weight, the remaining can be use by the following layer.
     float weightsSum = 0.0;
 
-    [unroll]
+    UNITY_UNROLL
     for (int i = _LAYER_COUNT - 1; i >= 0; --i)
     {
         outWeights[i] = min(masks[i], (1.0 - weightsSum));

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.hlsl

     float intensity = max(0, attenuation * NdotL); // Warning: attenuation can be greater than 1 due to the inverse square attenuation (when position is close to light)
 
     // Note: We use NdotL here to early out, but in case of clear coat this is not correct. But we are ok with this
-    [branch] if (intensity > 0.0)
+    UNITY_BRANCH if (intensity > 0.0)
     {
         BSDF(V, L, NdotL, posInput.positionWS, preLightData, bsdfData, lighting.diffuse, lighting.specular);
 
 
-    [branch] if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
+    UNITY_BRANCH if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
     {
         // We use diffuse lighting for accumulation since it is going to be blurred during the SSS pass.
         lighting.diffuse += EvaluateTransmission(bsdfData, NdotL, ClampNdotV(preLightData.NdotV), attenuation * lightData.diffuseScale);
     float intensity = max(0, attenuation * NdotL); // Warning: attenuation can be greater than 1 due to the inverse square attenuation (when position is close to light)
 
     // Note: We use NdotL here to early out, but in case of clear coat this is not correct. But we are ok with this
-    [branch] if (intensity > 0.0)
+    UNITY_BRANCH if (intensity > 0.0)
     {
         // Simulate a sphere light with this hack
         // Note that it is not correct with our pre-computation of PartLambdaV (mean if we disable the optimization we will not have the
         lighting.specular *= intensity * lightData.specularScale;
     }
 
-    [branch] if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
+    UNITY_BRANCH if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
     {
         // We use diffuse lighting for accumulation since it is going to be blurred during the SSS pass.
         lighting.diffuse += EvaluateTransmission(bsdfData, NdotL, ClampNdotV(preLightData.NdotV), attenuation * lightData.diffuseScale);
     // We don't multiply by 'bsdfData.diffuseColor' here. It's done only once in PostEvaluateBSDF().
     lighting.diffuse = preLightData.ltcMagnitudeDiffuse * ltcValue;
 
-    [branch] if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
+    UNITY_BRANCH if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
     {
         // Flip the view vector and the normal. The bitangent stays the same.
         float3x3 flipMatrix = float3x3(-1,  0,  0,
     // We don't multiply by 'bsdfData.diffuseColor' here. It's done only once in PostEvaluateBSDF().
     lighting.diffuse = preLightData.ltcMagnitudeDiffuse * ltcValue;
 
-    [branch] if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
+    UNITY_BRANCH if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
     {
         // Flip the view vector and the normal. The bitangent stays the same.
         float3x3 flipMatrix = float3x3(-1,  0,  0,

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/LitDataDisplacement.hlsl

         float planeHeight;
 
         // Perform a POM in each direction and modify appropriate texture coordinate
-        [branch] if (layerTexCoord.triplanarWeights.x >= 0.001)
+        UNITY_BRANCH if (layerTexCoord.triplanarWeights.x >= 0.001)
         {
             ppdParam.uv      = layerTexCoord.base.uvZY;
             float3 viewDirTS = float3(uvZY, abs(V.x));
             NdotV  += layerTexCoord.triplanarWeights.x * viewDirTS.z;
         }
 
-        [branch] if (layerTexCoord.triplanarWeights.y >= 0.001)
+        UNITY_BRANCH if (layerTexCoord.triplanarWeights.y >= 0.001)
         {
             ppdParam.uv      = layerTexCoord.base.uvXZ;
             float3 viewDirTS = float3(uvXZ, abs(V.y));
             NdotV  += layerTexCoord.triplanarWeights.y * viewDirTS.z;
         }
 
-        [branch] if (layerTexCoord.triplanarWeights.z >= 0.001)
+        UNITY_BRANCH if (layerTexCoord.triplanarWeights.z >= 0.001)
         {
             ppdParam.uv      = layerTexCoord.base.uvXY;
             float3 viewDirTS = float3(uvXY, abs(V.z));

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/SubsurfaceScattering.compute

     int2 cacheCoord = pixelCoord - cacheOffset;
     bool isInCache  = max((uint)cacheCoord.x, (uint)cacheCoord.y) < TEXTURE_CACHE_SIZE_1D;
 
-    [branch] if (isInCache)
+    UNITY_BRANCH if (isInCache)
     {
         return LoadSampleFromCacheMemory(cacheCoord);
     }
     uint2 pixelCoord  = groupOffset + groupCoord;
     int2  cacheOffset = (int2)groupOffset - TEXTURE_CACHE_BORDER;
 
-    [branch] if (groupThreadId == 0)
+    UNITY_BRANCH if (groupThreadId == 0)
     {
         float stencilRef = STENCILLIGHTINGUSAGE_SPLIT_LIGHTING;
 
     // Wait for the LDS.
     GroupMemoryBarrierWithGroupSync();
 
-    [branch] if (!processGroup) { return; }
+    UNITY_BRANCH if (!processGroup) { return; }
 
     float3 centerIrradiance  = LOAD_TEXTURE2D(_IrradianceSource, pixelCoord).rgb;
     float  centerDepth       = 0;
     // Save some bandwidth by only loading depth values for SSS pixels.
-    [branch] if (passedStencilTest)
+    UNITY_BRANCH if (passedStencilTest)
     {
         centerDepth = LOAD_TEXTURE2D(_DepthTexture, pixelCoord).r;
         centerViewZ = LinearEyeDepth(centerDepth, _ZBufferParams);
     uint numBorderQuadsPerWave = TEXTURE_CACHE_SIZE_1D / 2 - 1;
     uint halfCacheWidthInQuads = TEXTURE_CACHE_SIZE_1D / 4;
 
-    [branch] if (quadIndex < numBorderQuadsPerWave)
+    UNITY_BRANCH if (quadIndex < numBorderQuadsPerWave)
     {
         // Fetch another texel into the LDS.
         uint2 startQuad = halfCacheWidthInQuads * DeinterleaveQuad(waveIndex);
         float  viewZ2      = 0;
 
         // Save some bandwidth by only loading depth values for SSS pixels.
-        [branch] if (TestLightingForSSS(irradiance2))
+        UNITY_BRANCH if (TestLightingForSSS(irradiance2))
         {
             viewZ2 = LinearEyeDepth(LOAD_TEXTURE2D(_DepthTexture, pixelCoord2).r, _ZBufferParams);
         }
     GroupMemoryBarrierWithGroupSync();
 #endif
 
-    [branch] if (!passedStencilTest) { return; }
+    UNITY_BRANCH if (!passedStencilTest) { return; }
 
     PositionInputs posInput = GetPositionInput(pixelCoord, _ScreenSize.zw);
 
     uint   texturingMode = GetSubsurfaceScatteringTexturingMode(profileID);
     float3 albedo        = ApplySubsurfaceScatteringTexturingMode(texturingMode, sssData.diffuseColor);
 
-    [branch] if (distScale == 0 || maxDistInPixels < 1)
+    UNITY_BRANCH if (distScale == 0 || maxDistInPixels < 1)
     {
         #if SSS_DEBUG_LOD
             StoreResult(pixelCoord, float3(0, 0, 1));
 
     int i, n; // Declare once to avoid the warning from the Unity shader compiler.
 
-    [unroll]
+    UNITY_UNROLL
     for (i = 1, n = SSS_N_SAMPLES_FAR_FIELD; i < n; i++)
     {
         // Integrate over the image or tangent plane in the view space.
                        totalIrradiance, totalWeight);
     }
 
-    [branch] if (!useNearFieldKernel)
+    UNITY_BRANCH if (!useNearFieldKernel)
-    [unroll]
+    UNITY_UNROLL
     for (i = SSS_N_SAMPLES_FAR_FIELD, n = SSS_N_SAMPLES_NEAR_FIELD; i < n; i++)
     {
         // Integrate over the image or tangent plane in the view space.

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/SubsurfaceScattering.shader

                 // We use the value of 1 instead of 0.5 as an optimization.
                 float maxDistInPixels = maxDistance * max(pixelsPerCm.x, pixelsPerCm.y);
 
-                [branch]
+                UNITY_BRANCH
                 if (distScale == 0 || maxDistInPixels < 1)
                 {
                     #if SSS_DEBUG_LOD
                 float3 totalIrradiance = sampleWeight * sampleIrradiance;
                 float3 totalWeight     = sampleWeight;
 
-                [unroll]
+                UNITY_UNROLL
                 for (int i = 1; i < SSS_BASIC_N_SAMPLES; i++)
                 {
                     samplePosition   = posInput.positionSS + rotatedDirection * _FilterKernelsBasic[profileID][i].a;

TestbedPipelines/Fptl/LightingTemplate.hlsl

     ind.diffuse = 0;
     ind.specular = 0;
 
-	ShadowContext shadowContext = InitShadowContext();
+    ShadowContext shadowContext = InitShadowContext();
 
     float3 ints = 0;
 
         UnityLight light;
         light.dir.xyz = mul((float3x3) g_mViewToWorld, -lightData.lightAxisZ).xyz;
 
-		int shadowIdx = asint(lightData.shadowLightIndex);
-		[branch]
-		if (shadowIdx >= 0)
-		{
-			float shadow = GetDirectionalShadowAttenuation(shadowContext, vPw, 0.0.xxx, shadowIdx, normalize(light.dir.xyz));
-			atten *= shadow;
-		}
+        int shadowIdx = asint(lightData.shadowLightIndex);
+        UNITY_BRANCH
+        if (shadowIdx >= 0)
+        {
+            float shadow = GetDirectionalShadowAttenuation(shadowContext, vPw, 0.0.xxx, shadowIdx, normalize(light.dir.xyz));
+            atten *= shadow;
+        }
 
         light.color.xyz = lightData.color.xyz * atten;
 
             const bool bHasCookie = (lgtDat.flags&IS_CIRCULAR_SPOT_SHAPE)==0;       // all square spots have cookies
             float d0 = 0.65;
             float4 angularAtt = float4(1,1,1,smoothstep(0.0, 1.0-d0, 1.0-length(cookCoord)));
-            [branch]if(bHasCookie)
+            UNITY_BRANCH if(bHasCookie)
             {
                 cookCoord = cookCoord*0.5 + 0.5;
                 angularAtt = UNITY_SAMPLE_TEX2DARRAY_LOD(_spotCookieTextures, float3(cookCoord, lgtDat.sliceIndex), 0.0);
             UnityLight light;
             light.dir.xyz = mul((float3x3) g_mViewToWorld, vL).xyz;     //unity_CameraToWorld
 
-			int shadowIdx = asint(lgtDat.shadowLightIndex);
-			[branch]
-			if (shadowIdx >= 0)
-			{
-				float shadow = GetPunctualShadowAttenuation(shadowContext, vPw, 0.0.xxx, shadowIdx, normalize(light.dir.xyz), dist);
-				atten *= shadow;
-			}
+            int shadowIdx = asint(lgtDat.shadowLightIndex);
+            UNITY_BRANCH
+            if (shadowIdx >= 0)
+            {
+                float shadow = GetPunctualShadowAttenuation(shadowContext, vPw, 0.0.xxx, shadowIdx, normalize(light.dir.xyz), dist);
+                atten *= shadow;
+            }
 
             light.color.xyz = lgtDat.color.xyz*atten*angularAtt.xyz;
 
             float4 cookieColor = float4(1,1,1,1);
 
             const bool bHasCookie = (lgtDat.flags&HAS_COOKIE_TEXTURE)!=0;
-            [branch]if(bHasCookie)
+            UNITY_BRANCH if(bHasCookie)
             {
                 float3 cookieCoord = -float3(dot(vL, lgtDat.lightAxisX.xyz), dot(vL, lgtDat.lightAxisY.xyz), dot(vL, lgtDat.lightAxisZ.xyz));    // negate to make vL a fromLight vector
                 cookieColor = UNITY_SAMPLE_ABSTRACT_CUBE_ARRAY_LOD(_pointCookieTextures, float4(cookieCoord, lgtDat.sliceIndex), 0.0);
-			int shadowIdx = asint(lgtDat.shadowLightIndex);
-			[branch]
-			if (shadowIdx >= 0)
-			{
-				float shadow = GetPunctualShadowAttenuation(shadowContext, vPw, 0.0.xxx, shadowIdx, vLw, dist);
-				atten *= shadow;
-			}
+            int shadowIdx = asint(lgtDat.shadowLightIndex);
+            UNITY_BRANCH
+            if (shadowIdx >= 0)
+            {
+                float shadow = GetPunctualShadowAttenuation(shadowContext, vPw, 0.0.xxx, shadowIdx, vLw, dist);
+                atten *= shadow;
+            }
 
             UnityLight light;
             light.color.xyz = lgtDat.color.xyz*atten*cookieColor.xyz;

TestbedPipelines/OnTileDeferredPipeline/Shaders/LightingTemplate.hlsl

 
 		float4 uvCookie = mul (unity_WorldToLight, float4(wpos,1));
 		colorCookie = tex2Dlod (_LightTexture0, float4(uvCookie.xy / uvCookie.w, 0, 0));
-		[branch]if (_useLegacyCookies) {
+        UNITY_BRANCH if (_useLegacyCookies) {
 			colorCookie.xyz = 1;
 		}
 
 
 		#if defined (DIRECTIONAL_COOKIE)
 		colorCookie = tex2Dlod (_LightTexture0, float4(mul(unity_WorldToLight, half4(wpos,1)).xy, 0, 0));
-		[branch]if (_useLegacyCookies) {
+        UNITY_BRANCH if (_useLegacyCookies) {
 			colorCookie.xyz = 1;
 		}
 		atten *= colorCookie.w;
 
 		#if defined (POINT_COOKIE)
 			colorCookie = texCUBElod(_LightTexture0, float4(mul(unity_WorldToLight, float4(wpos,1)).xyz, 0));
-			[branch]if (_useLegacyCookies) {
+            UNITY_BRANCH if (_useLegacyCookies) {
 				colorCookie.xyz = 1;
 			}
 			atten *= colorCookie.w;

TestbedPipelines/OnTileDeferredPipeline/Shaders/UnityStandardForwardMobile.cginc

   			float atten = 1;
 
 	  		int shadowIdx = gPerLightData[lightIndex].y;
-			[branch]
+			UNITY_BRANCH
 			if (shadowIdx >= 0 && _transparencyShadows)
 			{
 				float shadow = GetDirectionalShadowAttenuation(shadowContext, vPw, 0.0.xxx, shadowIdx, -gLightDirection[lightIndex].xyz);
 			float4 uvCookie = mul (gLightMatrix[lightIndex], float4(vPw,1));
             float2 cookCoord = uvCookie.xy / uvCookie.w;
 			const bool bHasCookie = gPerLightData[lightIndex].z >= 0;
-            [branch]if(bHasCookie)
+            UNITY_BRANCH if(bHasCookie)
-            [branch]if(_useLegacyCookies)
+            UNITY_BRANCH if(_useLegacyCookies)
             {
             	cookieColor.xyz = 1;
             }
 
             float4 cookieColor = float4(1,1,1,1);
             const bool bHasCookie = gPerLightData[lightIndex].z >= 0;
-            [branch]if(bHasCookie)
+            UNITY_BRANCH if(bHasCookie)
             {
             	float4 uvCookie = mul (gLightMatrix[lightIndex], float4(vLw,1));
             	float3 cookieCoord = -uvCookie.xyz / uvCookie.w;
-            [branch]if(_useLegacyCookies)
+            UNITY_BRANCH if(_useLegacyCookies)
-			[branch]
+			UNITY_BRANCH
 			if (shadowIdx >= 0 && _transparencyShadows)
 			{
 				float shadow = GetPunctualShadowAttenuation(shadowContext, vPw, 0.0.xxx, shadowIdx, vLw, dist);
             float d0 = 0.65;
             float4 angularAtt = float4(1,1,1,smoothstep(0.0, 1.0-d0, 1.0-length(2*cookCoord-1)));
             const bool bHasCookie = gPerLightData[lightIndex].z >= 0;
-            [branch]if(bHasCookie)
+            UNITY_BRANCH if(bHasCookie)
-            [branch]if(_useLegacyCookies)
+            UNITY_BRANCH if(_useLegacyCookies)
             {
             	angularAtt.xyz = 1;
             }
-			[branch]
+			UNITY_BRANCH
 			if (shadowIdx >= 0 && _transparencyShadows)
 			{
 				float shadow = GetPunctualShadowAttenuation(shadowContext, vPw, 0.0.xxx, shadowIdx, vLw, dist);