AnalyzeHDRPLit

Lit

在改动Lit之前有必要详细的逐行分析一下Lit的Shader
虽然类似的文章已经有了，但还是选择自己手敲一遍以加深印象。
版本是14.0.8

Common.hlsl

路径 core/ShaderLibrary/Common.hlsl
untiy为SRP单独抽象出了一个库，com.unity.render-pipelines.core，包含了很多基础的渲染代码，同时被URP和HDRP使用。

约定

首先就规定了一些惯例
坐标系:

• 世界坐标系：Yup左手
• 当从世界空间到视图空间时，视图空间中的单位为右手，矩阵的行列式为负
• 对于立方体贴图采样（反射探针），视图空间仍然是左手（立方体贴图约定）并且行列式为正。
• 单位：一米

然后是变量的后缀的约定

• WS：世界
• RWS：相机相关的世界
• VS：视角
• OS：物体
• CS：齐次裁切
• TS：切线
• TXS：贴图

默认向量都是归一化的，非归一化用un前缀

用大写字母表示常见向量，向量总是指向像素外部。
大写字母也意味着归一化，除非有un的前缀

• V：视角
• L：光线
• N：法线
• H：半程

输入输出的结构体用帕斯卡命名，前缀表示类型
如 AttributesDefault VaryingsDefault
当使用这些结构体时，用input/output作为变量名

常量浮点写作1.0 不是1，1.0f，1.0h
全局变量uniform 使用_前缀，大写，然后驼峰 _LowercaseThenCamelCase

不要使用in，仅使用out或inout关键字，也不要使用inline
当声明out参数时，放到最后

其他shader库不应包含common.hlsl，应放在.shader文件中。

所以全局变量应放在常量缓冲区中。

在C#与hlsl中共享结构定义。
结构要基于float4对齐。
定义数组时，总是使用float4
不要使用 SetGlobalFloatArray 或 SetComputeFloatParams

这个库中的函数都是无状态的，即没有全局声明。
需要显式声明精度的可以使用float与half，同时支持两者的，可以使用real。

real

这里就是依据定义的宏来确定是real的精度，大致看下来在移动端以及switch上，默认会启用half精度。当然可以手动指定REAL_IS_HALF为1。

宏定义

这里定义了一些方便使用的宏
#define SV_POSITION_QUALIFIERS
#define DEPTH_OFFSET_SEMANTIC SV_Depth

然后依据宏选择对应的api
PC就对应了D3D11.hlsl，大致包含了一些采样贴图的方式，等会再回过头来看看这个文件吧
接下来包含了Macros.hlsl与Random.hlsl，顾名思义，前者是主要是一些常量和一些模板方法，后者就是随机数了。

然后是Vulkan支持的Native Renderpass。这里先跳过。

然后是为了支持光追定义的宏

#if (SHADER_STAGE_RAY_TRACING && UNITY_RAY_TRACING_GLOBAL_RESOURCES)
    #define GLOBAL_RESOURCE(type, name, reg) type name : register(reg, space1);
    #define GLOBAL_CBUFFER_START(name, reg) cbuffer name : register(reg, space1) {
#else
    #define GLOBAL_RESOURCE(type, name, reg) type name;
    #define GLOBAL_CBUFFER_START(name, reg) CBUFFER_START(name)
#endif

工具函数

再往下就是存储的工具函数了。、

• 数学函数，如remap01，min，max，HasFlag等。
• 采样贴图
• 深度相关
• 还包含了一个PositionInputs的结构体，
• 并实现了一系列空间变换相关的函数。

D3D.hlsl

路径 core/ShaderLibrary/API/D3D.hlsl

是放到API中的，同级别的还有PSSL、Switch、Vulkan等等。所以可以猜出应该类似与接口一样，实现Unity常见的特定于平台的函数。

常量

首先是用宏定义了一些常量。
如下

#define UNITY_UV_STARTS_AT_TOP 1
#define UNITY_REVERSED_Z 1
#define UNITY_NEAR_CLIP_VALUE (1.0)
// This value will not go through any matrix projection conversion
#define UNITY_RAW_FAR_CLIP_VALUE (0.0)
#define VERTEXID_SEMANTIC SV_VertexID
#define INSTANCEID_SEMANTIC SV_InstanceID
#define FRONT_FACE_SEMANTIC SV_IsFrontFace
#define FRONT_FACE_TYPE bool
#define IS_FRONT_VFACE(VAL, FRONT, BACK) ((VAL) ? (FRONT) : (BACK))

都可以通过名称来看出含义。

支持的特性

#define PLATFORM_SUPPORTS_EXPLICIT_BINDING
#define PLATFORM_NEEDS_UNORM_UAV_SPECIFIER
#define PLATFORM_SUPPORTS_BUFFER_ATOMICS_IN_PIXEL_SHADER
#define PLATFORM_SUPPORTS_PRIMITIVE_ID_IN_PIXEL_SHADER

采样贴图

这里就顺便看下各种采样的区别吧
Sample 采样
SampleLevel 指定mipmap级别
SampleBias 输入mipmap偏差
SampleGrad 用梯度来选择mip级别
SampleCmpLevelZero 采样后与0比较
以及
Load 仅加载，即不寻址不过滤，使用指定的lod
Gather 收集周围4个像素的R通道

ShaderVariables.hlsl

主要是定义一个名为UnityPerDraw的CBuffer。包含了和材质相关的一些全局变量，如球谐函数参数，renderBox，光照贴图参数，渲染层等等和材质相关的。

还顺便声明了一系列常用的采样器。

再往下就是贴图的声明，如深度，光照，阴影，ProbeVolume。

这里还改了SAMPLE_TEXTURE2D与SAMPLE_TEXTURE2D_BIAS的宏，全局应用_GlobalMipBias

然后是采样这些贴图的工具函数 如 SampleCameraDepth、SampleCameraColor等
接着还是一些关于相机矩阵位置等参数的工具函数，如 GetRawUnityObjectToWorld、GetCameraPositionWS等等。

TextureXR.hlsl

顾名思义，是为了XR的单通道渲染定义的一系列在XR中采样贴图的宏

ShaderVariablesGlobal.cs.hlsl

这是一个由cs代码来自动生成的库文件。
单纯用来定义了一些全局变量，如_ViewMatrix、_ScreenSize、_Time等和材质无关的属性。
由此可以取看看ShaderVariablesGlobal.cs，通过cs代码来生成hlsl在HDRP中很常见。

ShaderVariablesGlobal.cs

这个文件主要就是定义了一个结构体，其内容和hlsl中的cbuffer一模一样，值得注意的是这里的参数的排布应用了float4对齐。

FragInputs.hlsl

一个结构体FragInputs，片元的输入，但这并不是Vert或者Frag的输出和输入，因为unity在传输时会打包再解包。

LitProperties.cs

和材质相关的属性，各种贴图与参数

LightLoopDef.hlsl

光照计算相关的定义

Lit.hlsl

PBR BSDF相关的计算

LightLoop.hlsl

?计算全部光源并汇总？

VaryingMesh.hlsl

顶点与片元的输入与输出，也包含了打包与解包相关函数。

LitData.hlsl

???

ShaderPassForward.hlsl

这里定义了前向渲染的顶点和片元着色器函数Vert与Frag。

Vert

这里倒是意外的简单，常规的坐标变换，打包输出到片元着色器。

Frag

头大的来了。
一行一行看！！！

函数输入输出

输入就是从顶点打包过来的。
这里根据几个宏来判断是否需要多Target输出，
共有虚拟纹理，分光？，运动向量，深度偏移。这些都先不考虑，只看outColor。

FragInputs input = UnpackVaryingsToFragInputs(packedInput);

解包数据
AdjustFragInputsToOffScreenRendering(input, _OffScreenRendering > 0, _OffScreenDownsampleFactor);
离屏渲染？？ 目前没有搞明白有什么作用，大致看起来是用来处理低分辨率的。
uint2 tileIndex = uint2(input.positionSS.xy) / GetTileSize();
获取像素网格坐标int
PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionRWS.xyz, tileIndex);

struct PositionInputs
{
    float3 positionWS;  // World space position (could be camera-relative)
    float2 positionNDC; // Normalized screen coordinates within the viewport    : [0, 1) (with the half-pixel offset)
    uint2  positionSS;  // Screen space pixel coordinates                       : [0, NumPixels)
    uint2  tileCoord;   // Screen tile coordinates                              : [0, NumTiles)
    float  deviceDepth; // Depth from the depth buffer                          : [0, 1] (typically reversed)
    float  linearDepth; // View space Z coordinate                              : [Near, Far]
};

获取一系列各种空间下的坐标

float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);

计算视线
SurfaceData surfaceData;
BuiltinData builtinData;
GetSurfaceAndBuiltinData(input, V, posInput, surfaceData, builtinData);
这里就为之后的光照计算准备数据了，来源就是采样各个贴图或者预先计算。

struct SurfaceData
{
    uint materialFeatures;
    real3 baseColor;
    real specularOcclusion;
    float3 normalWS;
    real perceptualSmoothness;
    real ambientOcclusion;
    real metallic;
    real coatMask;
    real3 specularColor;
    uint diffusionProfileHash;
    real subsurfaceMask;
    real transmissionMask;
    real thickness;
    float3 tangentWS;
    real anisotropy;
    real iridescenceThickness;
    real iridescenceMask;
    real3 geomNormalWS;
    real ior;
    real3 transmittanceColor;
    real atDistance;
    real transmittanceMask;
};
struct BuiltinData
{
    real opacity;
    real alphaClipTreshold;
    real3 bakeDiffuseLighting;
    real3 backBakeDiffuseLighting;
    real shadowMask0;
    real shadowMask1;
    real shadowMask2;
    real shadowMask3;
    real3 emissiveColor;
    real2 motionVector;
    real2 distortion;
    real distortionBlur;
    uint isLightmap;
    uint renderingLayers;
    float depthOffset;
    #if defined(UNITY_VIRTUAL_TEXTURING)
    real4 vtPackedFeedback;
    #endif
};

看结构体就能知道这里函数的作用是什么了。

那就开看看这个函数

双面法线

前面的和LodFade相关的先略过。
先看看和双面法线相关的
float3 doubleSidedConstants = GetDoubleSidedConstants();

ApplyDoubleSidedFlipOrMirror(input, doubleSidedConstants);

对应材质中的Mirror和Flip。定义了反面法线的朝向。
这里法线存在了input.tangentToWorld[2]中。

UV

LayerTexCoord layerTexCoord;
ZERO_INITIALIZE(LayerTexCoord, layerTexCoord);
GetLayerTexCoord(input, layerTexCoord);

预处理UV。

struct LayerTexCoord
{
#ifndef LAYERED_LIT_SHADER
    UVMapping base;
    UVMapping details;
#else
    // Regular texcoord
    UVMapping base0;
    UVMapping base1;
    UVMapping base2;
    UVMapping base3;

    UVMapping details0;
    UVMapping details1;
    UVMapping details2;
    UVMapping details3;

    // Dedicated for blend mask
    UVMapping blendMask;
#endif

    // Store information that will be share by all UVMapping
    float3 vertexNormalWS; // TODO: store also object normal map for object triplanar
    float3 triplanarWeights;

#ifdef SURFACE_GRADIENT
    // tangent basis for each UVSet - up to 4 for now
    float3 vertexTangentWS0, vertexBitangentWS0;
    float3 vertexTangentWS1, vertexBitangentWS1;
    float3 vertexTangentWS2, vertexBitangentWS2;
    float3 vertexTangentWS3, vertexBitangentWS3;
#endif
};
struct UVMapping
{
    int mappingType;
    float2 uv;  // Current uv or planar uv

    // Triplanar specific
    float2 uvZY;
    float2 uvXZ;
    float2 uvXY;

    float3 normalWS; // vertex normal
    float3 triplanarWeights;

#ifdef SURFACE_GRADIENT
    // tangent basis to use when mappingType is UV_MAPPING_UVSET
    // these are vertex level in world space
    float3 tangentWS;
    float3 bitangentWS;
    // TODO: store also object normal map for object triplanar
#endif
};

LAYERED_LIT_SHADER 是分层，先略过。
所以共有两种UVMapping，base与details。
这也就要求相关的贴图的UV分布要一致。
观察UVMapping能看出这里还考虑了三平面映射UV。

void GetLayerTexCoord(FragInputs input, inout LayerTexCoord layerTexCoord)
{
#ifdef SURFACE_GRADIENT
    GenerateLayerTexCoordBasisTB(input, layerTexCoord);
#endif

    GetLayerTexCoord(   input.texCoord0.xy, input.texCoord1.xy, input.texCoord2.xy, input.texCoord3.xy,
                        input.positionRWS, input.tangentToWorld[2].xyz, layerTexCoord);
}

GenerateLayerTexCoordBasisTB用来计算切线空间
GetLayerTexCoord用来生成对应的UVMapping

高度图

#if !defined(SHADER_STAGE_RAY_TRACING)
    float depthOffset = ApplyPerPixelDisplacement(input, V, layerTexCoord);
    #ifdef _DEPTHOFFSET_ON
    ApplyDepthOffsetPositionInput(V, depthOffset, GetViewForwardDir(), GetWorldToHClipMatrix(), posInput);
    #endif
#else
    float depthOffset = 0.0;
#endif

深度图相关，包含了深度偏移。

透明度裁切

#if defined(_ALPHATEST_ON)
    float alphaTex = SAMPLE_UVMAPPING_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, layerTexCoord.base).a;
    alphaTex = lerp(_AlphaRemapMin, _AlphaRemapMax, alphaTex);
    float alphaValue = alphaTex * _BaseColor.a;

    // Perform alha test very early to save performance (a killed pixel will not sample textures)
    #if SHADERPASS == SHADERPASS_TRANSPARENT_DEPTH_PREPASS
    float alphaCutoff = _AlphaCutoffPrepass;
    #elif SHADERPASS == SHADERPASS_TRANSPARENT_DEPTH_POSTPASS
    float alphaCutoff = _AlphaCutoffPostpass;
    #elif (SHADERPASS == SHADERPASS_SHADOWS) || (SHADERPASS == SHADERPASS_RAYTRACING_VISIBILITY)
    float alphaCutoff = _UseShadowThreshold ? _AlphaCutoffShadow : _AlphaCutoff;
    #else
    float alphaCutoff = _AlphaCutoff;
    #endif

    GENERIC_ALPHA_TEST(alphaValue, alphaCutoff);
#endif

不是重点先略过

SurfaceData

float3 normalTS;
float3 bentNormalTS;
float3 bentNormalWS;
float alpha = GetSurfaceData(input, layerTexCoord, surfaceData, normalTS, bentNormalTS);

// This need to be init here to quiet the compiler in case of decal, but can be override later.
surfaceData.geomNormalWS = input.tangentToWorld[2];
surfaceData.specularOcclusion = 1.0;

来看看GetSurfaceData这个函数
主要就是采样各种贴图，获取SurfaceData。

贴花

#if HAVE_DECALS && (defined(DECAL_SURFACE_GRADIENT) && defined(SURFACE_GRADIENT))
    if (_EnableDecals)
    {
        DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, input, alpha);
        ApplyDecalToSurfaceData(decalSurfaceData, input.tangentToWorld[2], surfaceData, normalTS);
    }
#endif

也先略过吧。

次法线

#ifdef _BENTNORMALMAP
    GetNormalWS(input, bentNormalTS, bentNormalWS, doubleSidedConstants);
#else
    bentNormalWS = surfaceData.normalWS;
#endif

获取次法线

高光遮挡

#if defined(_SPECULAR_OCCLUSION_FROM_BENT_NORMAL_MAP)
    // If we have bent normal and ambient occlusion, process a specular occlusion
    surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
    // Don't do spec occ from Ambient if there is no mask mask
#elif defined(_MASKMAP) && !defined(_SPECULAR_OCCLUSION_NONE)
    surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(dot(surfaceData.normalWS, V)), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
#endif

如果启用了次法线贴图的镜面遮挡，就修改specularOcclusion属性。

几何高光AA

#if defined(_ENABLE_GEOMETRIC_SPECULAR_AA) && !defined(SHADER_STAGE_RAY_TRACING)
    // Specular AA
    #ifdef PROJECTED_SPACE_NDF_FILTERING
    surfaceData.perceptualSmoothness = ProjectedSpaceGeometricNormalFiltering(surfaceData.perceptualSmoothness, input.tangentToWorld[2], _SpecularAAScreenSpaceVariance, _SpecularAAThreshold);
    #else
    surfaceData.perceptualSmoothness = GeometricNormalFiltering(surfaceData.perceptualSmoothness, input.tangentToWorld[2], _SpecularAAScreenSpaceVariance, _SpecularAAThreshold);
    #endif
#endif

用来处理几何锐角附近的高光锯齿，是通过修改光滑度来实现的，看来这一步可以预先在SP等贴图软件中提前处理，能节省一些性能。

BuiltinData

GetBuiltinData(input, V, posInput, surfaceData, alpha, bentNormalWS, depthOffset, layerTexCoord.base, builtinData);

SurfaceDatas是和表面相关的属性，和材质相关。BuiltinData则是和环境相关，如全局光、阴影、透明度裁切阙值等。

GI有三种方式，光照贴图，球谐函数，还是新退出的用3D贴图来采样的球谐函数。

PostInitBuiltinData

然后是最后的修改，

ModifyBakedDiffuseLighting(V, posInput, surfaceData, builtinData);
float multiplier = GetIndirectDiffuseMultiplier(builtinData.renderingLayers);
builtinData.bakeDiffuseLighting *= multiplier;

都是对GI的修改。

void ModifyBakedDiffuseLighting(float3 V, PositionInputs posInput, SurfaceData surfaceData, inout BuiltinData builtinData)
{
    // Since this is called early at PostInitBuiltinData and we need some fields from bsdfData and preLightData,
    // we get the whole structures redundantly earlier here - compiler should optimize out everything.
    BSDFData bsdfData = ConvertSurfaceDataToBSDFData(posInput.positionSS, surfaceData);
    PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);
    ModifyBakedDiffuseLighting(V, posInput, preLightData, bsdfData, builtinData);
}

又出现了两个结构体

struct BSDFData
{
    uint materialFeatures;
    real3 diffuseColor;
    real3 fresnel0;
    real ambientOcclusion;
    real specularOcclusion;
    float3 normalWS;
    real perceptualRoughness;
    real coatMask;
    uint diffusionProfileIndex;
    real subsurfaceMask;
    real thickness;
    bool useThickObjectMode;
    real3 transmittance;
    float3 tangentWS;
    float3 bitangentWS;
    real roughnessT;
    real roughnessB;
    real anisotropy;
    real iridescenceThickness;
    real iridescenceMask;
    real coatRoughness;
    real3 geomNormalWS;
    real ior;
    real3 absorptionCoefficient;
    real transmittanceMask;
};
struct PreLightData
{
    float NdotV;                     // Could be negative due to normal mapping, use ClampNdotV()

    // GGX
    float partLambdaV;
    float energyCompensation;

    // IBL
    float3 iblR;                     // Reflected specular direction, used for IBL in EvaluateBSDF_Env()
    float  iblPerceptualRoughness;

    float3 specularFGD;              // Store preintegrated BSDF for both specular and diffuse
    float  diffuseFGD;

    // Area lights (17 VGPRs)
    // TODO: 'orthoBasisViewNormal' is just a rotation around the normal and should thus be just 1x VGPR.
    float3x3 orthoBasisViewNormal;   // Right-handed view-dependent orthogonal basis around the normal (6x VGPRs)
    float3x3 ltcTransformDiffuse;    // Inverse transformation for Lambertian or Disney Diffuse        (4x VGPRs)
    float3x3 ltcTransformSpecular;   // Inverse transformation for GGX                                 (4x VGPRs)

    // Clear coat
    float    coatPartLambdaV;
    float3   coatIblR;
    float    coatIblF;               // Fresnel term for view vector
    float    coatReflectionWeight;   // like reflectionHierarchyWeight but used to distinguish coat contribution between SSR/IBL lighting
    float3x3 ltcTransformCoat;       // Inverse transformation for GGX                                 (4x VGPRs)

#if HAS_REFRACTION
    // Refraction
    float3 transparentRefractV;      // refracted view vector after exiting the shape
    float3 transparentPositionWS;    // start of the refracted ray after exiting the shape
    float3 transparentTransmittance; // transmittance due to absorption
    float transparentSSMipLevel;     // mip level of the screen space gaussian pyramid for rough refraction
#endif
};

前者是针对BSDF所需的全部参数的汇总，后者就是光源相关的属性。

来看看这两个结构体的获取

ConvertSurfaceDataToBSDFData

也是顾名思义，填充一些bsdf相关的属性。
如ao，高光，粗糙，金属，菲涅尔等等。

这里还根据材质需求的功能的不同，如是否需要SSS，曲面细分，各向异性，虹彩，清漆来填充不同的属性。

GetPreLightData

同样的，根据不同的材质，会有针对性的修改，比如为了虹彩和清漆会修改菲涅尔，

这里对于面光源，环境照明，的参数是从一张预处理的贴图中采样的：GetPreIntegratedFGDGGXAndDisneyDiffuse
还有一些奇怪的属性energyCompensation、面光源相关等等，等用到时再回过头来看吧。

LightLoopOutput

获取完大部分的属性后终于来到了光照计算

struct LightLoopOutput
{
    float3 diffuseLighting;
    float3 specularLighting;
};

输出很直接漫反射和高光。

LightLoopContext

 struct LightLoopContext
{
    int sampleReflection;
#ifdef APPLY_FOG_ON_SKY_REFLECTIONS
    float3 positionWS; // For sky reflection, we need position to evalute height base fog
#endif

    HDShadowContext shadowContext;

    uint contactShadow;         // a bit mask of 24 bits that tell if the pixel is in a contact shadow or not
    real contactShadowFade;     // combined fade factor of all contact shadows
    SHADOW_TYPE shadowValue;    // Stores the value of the cascade shadow map
    real splineVisibility;      // Stores the value of the cascade shadow map (unbiased for splines)
};
struct HDShadowContext
{
    StructuredBuffer<HDShadowData>  shadowDatas;
    HDDirectionalShadowData         directionalShadowData;
};
struct HDShadowData
{
    float3 rot0;
    float3 rot1;
    float3 rot2;
    float3 pos;
    float4 proj;
    float2 atlasOffset;
    float worldTexelSize;
    float normalBias;
    real4 zBufferParam;
    float4 shadowMapSize;
    float4 shadowFilterParams0;
    float3 cacheTranslationDelta;
    float isInCachedAtlas;
    float4x4 shadowToWorld;
};
struct HDDirectionalShadowData
{
    float4 sphereCascades[4];
    real4 cascadeDirection;
    real cascadeBorders[4];
};

一层套一层
大部分都是定义的阴影

StructuredBuffer<HDShadowData>              _HDShadowDatas;
// Only the first element is used since we only support one directional light
StructuredBuffer<HDDirectionalShadowData>   _HDDirectionalShadowData;

HDShadowContext InitShadowContext()
{
    HDShadowContext         sc;

    sc.shadowDatas = _HDShadowDatas;
    sc.directionalShadowData = _HDDirectionalShadowData[0];

    return sc;
}

结构体的值是整个获取的。

ApplyCameraRelativeXR(posInput.positionWS);

// Initialize the contactShadow and contactShadowFade fields
InitContactShadow(posInput, context);

适配XR中的摄像机相关世界坐标。
获取级联阴影参数。

平行光阴影

        DirectionalLightData light = _DirectionalLightDatas[_DirectionalShadowIndex];

获取平行光数据
float3 L = -light.forward;
方向
然后就是采样阴影贴图。结果存到shadowValue中。

点光、附加光直接

struct AggregateLighting
{
    DirectLighting   direct;
    IndirectLighting indirect;
};

这里其实存的是全部附加光照的总和。

遍历全部的附加光

        while (v_lightListOffset < lightCount)
#endif
        {
            v_lightIdx = FetchIndex(lightStart, v_lightListOffset);
#if SCALARIZE_LIGHT_LOOP
            uint s_lightIdx = ScalarizeElementIndex(v_lightIdx, fastPath);
#else
            uint s_lightIdx = v_lightIdx;
#endif
            if (s_lightIdx == -1)
                break;

            LightData s_lightData = FetchLight(s_lightIdx);
            // If current scalar and vector light index match, we process the light. The v_lightListOffset for current thread is increased.
            // Note that the following should really be ==, however, since helper lanes are not considered by WaveActiveMin, such helper lanes could
            // end up with a unique v_lightIdx value that is smaller than s_lightIdx hence being stuck in a loop. All the active lanes will not have this problem.
            if (s_lightIdx >= v_lightIdx)
            {
                v_lightListOffset++;
                if (IsMatchingLightLayer(s_lightData.lightLayers, builtinData.renderingLayers))
                {
                    DirectLighting lighting = EvaluateBSDF_Punctual(context, V, posInput, preLightData, s_lightData, bsdfData, builtinData);
                    AccumulateDirectLighting(lighting, aggregateLighting);
                }
            }
        }

遍历完累加到一起。

平行光直接

uint i = 0; // Declare once to avoid the D3D11 compiler warning.
if (featureFlags & LIGHTFEATUREFLAGS_DIRECTIONAL)
{
    for (i = 0; i < _DirectionalLightCount; ++i)
    {
        if (IsMatchingLightLayer(_DirectionalLightDatas[i].lightLayers, builtinData.renderingLayers))
        {
            DirectLighting lighting = EvaluateBSDF_Directional(context, V, posInput, preLightData, _DirectionalLightDatas[i], bsdfData, builtinData);
            AccumulateDirectLighting(lighting, aggregateLighting);
        }
    }
}

循环计算全部的平行光的直接照明

面光源直接

#if SHADEROPTIONS_AREA_LIGHTS
    if (featureFlags & LIGHTFEATUREFLAGS_AREA)
    {
        uint lightCount, lightStart;

    #ifndef LIGHTLOOP_DISABLE_TILE_AND_CLUSTER
        GetCountAndStart(posInput, LIGHTCATEGORY_AREA, lightStart, lightCount);
    #else
        lightCount = _AreaLightCount;
        lightStart = _PunctualLightCount;
    #endif

        // COMPILER BEHAVIOR WARNING!
        // If rectangle lights are before line lights, the compiler will duplicate light matrices in VGPR because they are used differently between the two types of lights.
        // By keeping line lights first we avoid this behavior and save substantial register pressure.
        // TODO: This is based on the current Lit.shader and can be different for any other way of implementing area lights, how to be generic and ensure performance ?

        if (lightCount > 0)
        {
            i = 0;

            uint      last      = lightCount - 1;
            LightData lightData = FetchLight(lightStart, i);

            while (i <= last && lightData.lightType == GPULIGHTTYPE_TUBE)
            {
                lightData.lightType = GPULIGHTTYPE_TUBE; // Enforce constant propagation
                lightData.cookieMode = COOKIEMODE_NONE;  // Enforce constant propagation

                if (IsMatchingLightLayer(lightData.lightLayers, builtinData.renderingLayers))
                {
                    DirectLighting lighting = EvaluateBSDF_Area(context, V, posInput, preLightData, lightData, bsdfData, builtinData);
                    AccumulateDirectLighting(lighting, aggregateLighting);
                }

                lightData = FetchLight(lightStart, min(++i, last));
            }

            while (i <= last) // GPULIGHTTYPE_RECTANGLE
            {
                lightData.lightType = GPULIGHTTYPE_RECTANGLE; // Enforce constant propagation

                if (IsMatchingLightLayer(lightData.lightLayers, builtinData.renderingLayers))
                {
                    DirectLighting lighting = EvaluateBSDF_Area(context, V, posInput, preLightData, lightData, bsdfData, builtinData);
                    AccumulateDirectLighting(lighting, aggregateLighting);
                }

                lightData = FetchLight(lightStart, min(++i, last));
            }
        }
    }
#endif

面光源，先略过吧

直接光照

可以看出直接光照都是在类似
DirectLighting lighting = EvaluateBSDF_Directional(context, V, posInput, preLightData, _DirectionalLightDatas[i], bsdfData, builtinData);
这之类的函数中计算的
然后累加起来，所以这里来看看这个函数
ShadeSurface_Directional

EvaluateLight_Directional
处理雾气和大气相关，修改light颜色

SHADOW_TYPE shadow = EvaluateShadow_Directional(lightLoopContext, posInput, light, builtinData, GetNormalForShadowBias(bsdfData));
float NdotL  = dot(bsdfData.normalWS, L); // No microshadowing when facing away from light (use for thin transmission as well)
shadow *= NdotL >= 0.0 ? ComputeMicroShadowing(GetAmbientOcclusionForMicroShadowing(bsdfData), NdotL, _MicroShadowOpacity) : 1.0;
lightColor.rgb *= ComputeShadowColor(shadow, light.shadowTint, light.penumbraTint);

计算阴影

ShadeSurface_Infinitesimal
处理反射与投射

EvaluateBSDF
到这一步才用到了BSDF函数

总结

为了之后的理解，还是按照HDRP的文件和函数分类结构，在URP中把URP的Lit重写一遍，最终目的是在URP中使用HDRP的Lit。