Ananta角色渲染复刻

Shaders/Includes/AnantaCharacterSurface.hlsl · 第 42 行

int MaterialRow(float alpha)
{
    // 67942:10-14 / 68247:30-34. Alpha packs an integer material ID.
    return 15 - min(15, (int)((alpha*255.0+8.5)/17.0));
}

Shaders/Includes/AnantaCharacterSurface.hlsl · 第 58 行

float3 Recolor(float4 baseSample, float4 mask, float4 normalData, int row)
{
    float3 base = baseSample.rgb;
    if (_MaterialType > 1.5 && _MaterialType < 2.5 || _MaterialType > 3.5) return base;
    float3 a=.5, b=.5, c=.5;
    float mixWeight = mask.r, amount = 1;
    if (_MaterialType < .5)
    {
        if (row == 15)
        {
            a = Gamma22(SkinTint(47)); b = Gamma22(SkinTint(63)); c = Gamma22(SkinTint(79));
        }
        else { a = Table(3,row).rgb; b = Table(4,row).rgb; c = Table(5,row).rgb; }
        if (_UseCaptureConstants > .5 && asuint(_CaptureMaterial[31].x) != 0)
            amount = saturate(2-2*baseSample.a);
    }
    else if (_MaterialType < 1.5)
    {
        a = Gamma22(SkinTint(30)); b = Gamma22(SkinTint(31)); c = Gamma22(SkinTint(33));
        mixWeight = normalData.g; amount = baseSample.a;
    }
    else
    {
        // Hair has one two-stage overlay, not the body two-branch recolor.
        return lerp(base, Linear22(Overlay(Overlay(Gamma22(base), Table(3,row).rgb), Table(4,row).rgb)), _PaletteStrength);
    }
    float3 g = Gamma22(base);
    float3 first = Linear22(Overlay(Overlay(g,a),b));
    float3 second = Linear22(Overlay(Overlay(g,c),b));
    return lerp(base, lerp(second,first,mixWeight), amount*_PaletteStrength);
}

Shaders/Includes/AnantaCharacterSurface.hlsl · 第 135 行

float3 DecodeNormal(Varyings i, float4 raw, int row, float faceSign)
{
    float3 n = normalize(i.normalWS);
    // Face and eye surface shader uses the geometric normal; t12 is color data.
    if (_MaterialType > .5 && _MaterialType < 2.5 || _MaterialType > 3.5) return n;
    float scale = _NormalScale;
    if (_UseCaptureConstants > .5)
        scale *= _MaterialType < .5 ? (row == 15 ? CAPTURE_SKIN_NORMAL_SCALE : CAPTURE_BODY_NORMAL_SCALE) : CAPTURE_HAIR_NORMAL_SCALE;
    float2 xy = (raw.ag*2-1)*scale;
    float3 tangent = normalize(i.tangentWS.xyz);
    float3 bitangent = normalize(cross(n,tangent))*i.tangentWS.w;
    // DXBC uses cross(N,T)*sign(T.w), including SV_IsFrontFace for body.
    if (_MaterialType < .5) { n *= faceSign; tangent *= faceSign; bitangent *= faceSign; }
    return normalize(tangent*xy.x + bitangent*xy.y + n*sqrt(1-min(dot(xy,xy),1)));
}

Shaders/Includes/AnantaCharacterPasses.hlsl · 第 2 行

float3 ShadeDiffuse(Varyings i, Surface s, Light light, out float shade)
{
    float3 l=normalize(light.direction);
    float width=.2;
    if (_UseCaptureConstants>.5)
    {
        width = _MaterialType<.5 && s.row==15 ? _CaptureMaterial[183].z : Table(12,s.row).r;
        if (_MaterialType>.5 && _MaterialType<1.5) width=_CaptureMaterial[21].y;
        float target = s.row==15 ? _CaptureToon[24].x : _CaptureToon[24].y;
        width=lerp(width,target,_CaptureToon[24].z);
    }
    float signedLight=dot(s.normal,l)+clamp(s.mask.g*4-2,-1,1);
    shade=Smooth01(signedLight/max(width,1e-5));
    if (_MaterialType>.5 && _MaterialType<1.5) shade=FaceShadow(i.uv,l);
    if (_MaterialType>1.5 && _MaterialType<2.5 || _MaterialType>3.5)
        shade=_UseCaptureConstants>.5 ? EyeShadow(i.faceUv,l,lerp(_CaptureMaterial[25].w,_CaptureToon[24].x,_CaptureToon[24].z),true) : saturate(dot(s.normal,l));
    shade=min(shade,light.shadowAttenuation*saturate(Luma(light.color)));
    float3 shadowed=s.albedo;
    if (_UseCaptureConstants>.5 && (_MaterialType<1.5 || _MaterialType>2.5 && _MaterialType<3.5))
    {
        float coordinate=min(signedLight+1,light.shadowAttenuation*saturate(Luma(light.color))+.75);
        if (_MaterialType>.5 && _MaterialType<1.5) coordinate=shade;
        float3 ramp=RampColor(coordinate,s.row);
        float amount=_MaterialType<.5 && s.row==15 ? _CaptureMaterial[107].z : Table(10,s.row).b;
        if (_MaterialType>.5 && _MaterialType<1.5) amount=_CaptureMaterial[22].w;
        amount*=_CaptureToon[12].x;
        // Shadow composition switches overlay's selector to the ramp color.
        shadowed=lerp(s.albedo,Linear22(Overlay(Gamma22(ramp),Gamma22(s.albedo))),amount);
        shadowed=lerp(shadowed,s.albedo,shade);
    }
    float3 ambientNormal=s.normal;
    if (_MaterialType>.5 && _MaterialType<1.5 && _UseCaptureConstants>.5 && asuint(_CaptureMaterial[5].z)==0)
        ambientNormal=_CaptureFaceAxes[1].xyz;
    float3 indirect=shadowed*(1-s.metallic)*CapturedAmbient(ambientNormal,s.row);
    if (_MaterialType<.5)
    {
        float ao=lerp(s.mask.b,1,shade);
        if (s.row==15 && _UseCaptureConstants>.5) indirect*=lerp(_CaptureMaterial[0].rgb,1,ao);
        else indirect*=ao;
    }
    float directScale=_UseCaptureConstants>.5 ? _CaptureToon[14].y : .5;
    float3 additional=_UseCaptureConstants>.5 ? AdditionalDiffuse(i,s,SafeNormalize(GetWorldSpaceViewDir(i.positionWS))) : 0;
    float3 view=SafeNormalize(GetWorldSpaceViewDir(i.positionWS));
    float nv=dot(_MaterialType>.5 && _MaterialType<1.5?_CaptureFaceAxes[1].xyz:s.normal,view);
    float3 direct=s.albedo*(1-s.metallic)*shade*light.color*(directScale/PI)*DirectDiffuseEnergy(s,nv);
    if (_DebugView>4.5 && _DebugView<5.5) return indirect;
    if (_DebugView>5.5 && _DebugView<6.5) return additional;
    if (_DebugView>7.5) return additional;
    if (_DebugView>6.5) return direct;
    float3 diffuse = indirect + direct + additional;
    if (_MaterialType > .5 && _MaterialType < 1.5 && _UseCaptureConstants > .5)
        diffuse *= FaceLightingTint(i.uv, view, shade);
    return diffuse;
}

Shaders/Includes/AnantaCharacterLighting.hlsl · 第 17 行

float3 BodySpecular(Surface s, float3 view, float3 l)
{
    float nl=saturate(dot(s.normal,l));
    float nv=min(abs(dot(s.normal,view))+.00001,1);
    float3 h=SafeNormalize(view+l);
    float nh=saturate(dot(s.normal,h)), vh=saturate(dot(view,h));
    float alpha=s.roughness*s.roughness, a2=alpha*alpha;
    float denominator=nh*nh*(a2-1)+1;
    float distribution=a2/max(PI*denominator*denominator,1e-8);
    float visibility=.5/max(nl*(nv*(1-alpha)+alpha)+nv*(nl*(1-alpha)+alpha),1e-8);
    float3 f0=lerp(.04.xxx,s.albedo,s.metallic);
    float fresnel=pow(1-vh,5);
    float3 f=lerp(f0,saturate(f0.g*50).xxx,fresnel);
    return distribution*visibility*f*SpecularEnergy(f0,nv,s.roughness)*nl;
}

Shaders/Includes/AnantaCharacterLighting.hlsl · 第 51 行

float3 EnvironmentSpecular(Surface s, float3 view, float3 environmentColor)
{
    if(_UseCapturedEnvironment<.5 || _UseCapturedBRDF<.5 || _MaterialType<.5 && s.row==15) return 0;
    float nv=dot(s.normal,view);
    float oneMinusR2=1-s.roughness*s.roughness;
    float blend=(s.roughness*s.roughness+sqrt(saturate(oneMinusR2)))*oneMinusR2;
    float3 reflected=2*nv*s.normal-view;
    float3 direction=lerp(s.normal,reflected,blend);
    float visibility=saturate(dot(direction,s.normal)*_CaptureToon[23].w);
    direction=normalize(direction+s.normal*max(-dot(direction,s.normal),0));
    float occlusion=saturate(s.mask.b+pow(max(s.mask.b+nv,1e-6),oneMinusR2)-1);
    float lod=6+1.2*log2(max(s.roughness,.02));
    float3 radiance=max(SAMPLE_TEXTURECUBE_LOD(_CaptureEnvironmentMap,sampler_CaptureEnvironmentMap,direction,lod).rgb,0);
    float3 f0=lerp(.04.xxx,s.albedo,s.metallic);
    float2 integral=SAMPLE_TEXTURE2D_LOD(_CaptureBRDFMap,sampler_CaptureBRDFMap,float2(saturate(nv),1-s.roughness),0).rg;
    float3 integrated=(f0*integral.x+(_CaptureToon[23].z-f0)*integral.y)*SpecularEnergy(f0,nv,s.roughness);
    return integrated*environmentColor*Luma(radiance)*occlusion*visibility;
}

Shaders/Includes/AnantaCharacterSurface.hlsl · 第 174 行

float FaceShadow(float2 uv, float3 lightDir, float widthOverride=0, bool limitElevation=true)
{
    // 67910:33-60 clamps elevation to +/-45 degrees, before face-axis projection.
    float horizontal = max(length(lightDir.xz),1e-6);
    float angle = clamp(atan2(lightDir.y,horizontal),-.785398,.785398);
    float3 limited = limitElevation ? float3(lightDir.x*cos(angle)/horizontal,sin(angle),lightDir.z*cos(angle)/horizontal) : lightDir;
    float3 forward = _UseCaptureConstants>.5 ? CAPTURE_FACE_FORWARD : float3(0,0,1);
    float3 side = _UseCaptureConstants>.5 ? CAPTURE_FACE_SIDE : float3(1,0,0);
    float front = dot(forward, limited);
    float warped = max(abs(front),pow(min(abs(front)*3.333,1),.3)*.667)*sign(front);
    float4 sdf = SAMPLE_TEXTURE2D(_FaceMap,sampler_FaceMap,uv);
    float4 mirrored = SAMPLE_TEXTURE2D(_FaceMap,sampler_FaceMap,float2(1-uv.x,uv.y));
    float selected = dot(side,limited)<0 ? sdf.r : mirrored.r;
    float center = _UseCaptureConstants>.5 ? _CaptureMaterial[21].z : .5;
    float width = _UseCaptureConstants>.5 ? lerp(_CaptureMaterial[21].y,_CaptureToon[24].x,_CaptureToon[24].z) : .2;
    if (widthOverride>0) width=widthOverride;
    float shadow = Smooth01((selected-(center-.5*warped)+.1*width)/max(.2*width,1e-5));
    // The captured face permutation has cb7[7].x=y=0: exclude ID zero.
    return shadow * (abs(sdf.b)>.071429 ? 1 : 0);
}

Shaders/Includes/AnantaCharacterSurface.hlsl · 第 196 行

float3 FaceLightingTint(float2 uv, float3 view, float shade)
{
    if (asuint(_CaptureMaterial[21].w) == 0) return 1;
    float4 sdf = SAMPLE_TEXTURE2D(_FaceMap, sampler_FaceMap, uv);
    float mirrored = SAMPLE_TEXTURE2D(_FaceMap, sampler_FaceMap, float2(1 - uv.x, uv.y)).r;
    float side = dot(view, CAPTURE_FACE_SIDE);
    float sideWeight = min(2 * abs(side), 1);
    float selected = side < 0 ? sdf.r : mirrored;
    float field = lerp(min(sdf.r, mirrored), selected, sideWeight);
    float center = _CaptureMaterial[22].x + .05 * sideWeight;
    float width = (.5 + .5 * sideWeight) * _CaptureMaterial[22].y;
    float faceMask = Smooth01((field - center + .1 * width) / max(.2 * width, 1e-6));
    // The source exempts the packed face category around 0.785714.
    if (abs(sdf.b - .785714) <= .142857) faceMask = 1;
    float shadowWeight = max(.65 - faceMask, 0);
    float weight = lerp(shadowWeight, 1 - faceMask, shade);
    return lerp(1, _CaptureMaterial[24].rgb, weight);
}

Shaders/Includes/AnantaCharacterSurface.hlsl · 第 89 行

float3 EyeAlbedo(Varyings i, float4 baseSample)
{
    // 67945:197-258. The iris and decorative layer have separate parallax.
    float3 n=normalize(i.normalWS), t=normalize(i.tangentWS.xyz);
    float3 b=normalize(cross(n,t))*sign(i.tangentWS.w);
    float3 v=SafeNormalize(GetWorldSpaceViewDir(i.positionWS));
    float2 viewTS=float2(dot(t,v),dot(b,v));
    float radial=saturate(1-length(i.uv-.5)/max(_CaptureMaterial[27].y,1e-5));
    float depth=_CaptureMaterial[27].z*(1-rcp(1+.5*radial));
    float2 mirrorUv=float2(i.tangentWS.w>=0?1-i.uv.x:i.uv.x,i.uv.y);
    float2 maskUv=mirrorUv+depth*float2(-sign(i.tangentWS.w)*viewTS.x,viewTS.y);
    float shiftedMask=SAMPLE_TEXTURE2D(_NormalMap,sampler_NormalMap,maskUv).r;
    float baseMask=SAMPLE_TEXTURE2D(_NormalMap,sampler_NormalMap,i.uv).r;
    float2 irisUv=(i.uv-_CaptureMaterial[26].w*viewTS-.5)*_CaptureMaterial[29].x+.5;
    float4 iris=SAMPLE_TEXTURE2D(_BaseMap,sampler_BaseMap,irisUv);
    float3 irisColor=lerp(_CaptureMaterial[28].rgb,iris.rgb,iris.a);
    // 67945:225-249: the first iris blend is tinted by an angle-dependent
    // factor, then blended back into the base with its alpha a second time.
    float3 lightDir=normalize(_CaptureLightDirection.xyz);
    float horizontal=max(length(lightDir.xz),1e-6);
    float elevation=clamp(atan2(lightDir.y,horizontal),-.785398,.785398);
    lightDir=float3(lightDir.x*cos(elevation)/horizontal,sin(elevation),lightDir.z*cos(elevation)/horizontal);
    float3 localLight=float3(dot(lightDir,_CaptureFaceAxes[0].xyz),abs(dot(lightDir,_CaptureFaceAxes[1].xyz)),dot(lightDir,_CaptureFaceAxes[2].xyz));
    float angle=radians(_CaptureMaterial[5].x), cosine=cos(angle);
    float3 boundary=SafeNormalize(SafeNormalize(float3(localLight.x,0,localLight.z))*tan(angle)+float3(0,1,0));
    float3 bentLight=SafeNormalize(lerp(boundary,localLight,saturate((localLight.y-cosine)/max(cosine,1e-6))));
    float3 projectedLight=float3(dot(bentLight,_CaptureFaceAxes[4].xyz),dot(bentLight,_CaptureFaceAxes[5].xyz),dot(bentLight,_CaptureFaceAxes[6].xyz));
    float3 localNormal=float3(dot(n,_CaptureFaceAxes[0].xyz),dot(n,_CaptureFaceAxes[1].xyz),dot(n,_CaptureFaceAxes[2].xyz));
    localNormal+=float3(_CaptureMaterial[25].y,0,-sign(i.tangentWS.w)*_CaptureMaterial[25].x);
    localNormal=SafeNormalize(localNormal)*float3(-1,1,-1);
    float3 projectedNormal=float3(dot(localNormal,_CaptureFaceAxes[4].xyz),dot(localNormal,_CaptureFaceAxes[5].xyz),dot(localNormal,_CaptureFaceAxes[6].xyz));
    float inverseFacing=1-saturate(dot(projectedNormal,projectedLight));
    float irisAngle=Smooth01((.7*_CaptureMaterial[37].x-(1-.5*inverseFacing))/(-.5-.5*inverseFacing));
    float thresholdLow=.5-(.01+.49*_CaptureMaterial[37].z);
    float thresholdHigh=.51+.49*_CaptureMaterial[37].z;
    float tintWeight=Smooth01((irisAngle-thresholdLow)/max(thresholdHigh-thresholdLow,1e-6));
    tintWeight+=(2*_CaptureMaterial[37].y-1)*(pow(tintWeight,4)-tintWeight);
    float3 irisTint=lerp(_CaptureMaterial[36].rgb,1,tintWeight);
    float3 firstBlend=lerp(baseSample.rgb,irisColor,baseSample.a);
    float3 color=lerp(baseSample.rgb,firstBlend*irisTint,baseSample.a);
    color*=1-max(shiftedMask,baseMask);
    float2 layerUv=(i.uv-_CaptureMaterial[27].x*viewTS-.5)*_CaptureMaterial[29].z+.5;
    float4 layer=SAMPLE_TEXTURE2D(_EyeLayerMap,sampler_EyeLayerMap,layerUv);
    color+=layer.rgb*_CaptureMaterial[30].rgb*exp2(_CaptureMaterial[31].x)*(1-layer.a);
    return lerp(color,layer.rgb*_CaptureMaterial[31].y,layer.a);
}

Shaders/Includes/AnantaCharacterLighting.hlsl · 第 221 行

float3 HairBandTint(Varyings i, Surface s, Light light, float shade, float3 view)
{
    // 68247:645-716,737-749,770,784-785: third band removes overlap
    // with both primary lobes and tints the completed lit hair color.
    float3 authored=SafeNormalize(_CaptureFaceAxes[0].xyz*_CaptureMaterial[35].x+_CaptureFaceAxes[1].xyz*_CaptureMaterial[35].y+_CaptureFaceAxes[2].xyz*_CaptureMaterial[35].z);
    float3 h=SafeNormalize(SafeNormalize(lerp(light.direction,authored,.6))+view);
    float3 b=normalize(cross(normalize(i.normalWS),normalize(i.tangentWS.xyz)))*sign(i.tangentWS.w);
    float bh=dot(b,h);
    float2 noiseUv=i.uv*_CaptureMaterial[12].xy+_CaptureMaterial[12].zw;
    float noise=1-2*SAMPLE_TEXTURE2D(_HairNoise,sampler_HairNoise,noiseUv).g;
    float viewShift=.1*saturate(dot(authored,view));
    float p1=_CaptureMaterial[37].y-bh+noise*_CaptureMaterial[37].z+viewShift;
    float p2=_CaptureMaterial[39].w-bh+noise*_CaptureMaterial[40].x+viewShift;
    float p3=_CaptureMaterial[42].x-bh+noise*_CaptureMaterial[42].y+viewShift;
    float first=HairBand(p1,_CaptureMaterial[36].z,_CaptureMaterial[36].y,_CaptureMaterial[37].x,_CaptureMaterial[36].w);
    float second=HairBand(p2,_CaptureMaterial[38].x,_CaptureMaterial[37].w,_CaptureMaterial[38].z,_CaptureMaterial[38].y);
    float third=HairBand(p3,_CaptureMaterial[41].x,_CaptureMaterial[41].y,_CaptureMaterial[41].z,_CaptureMaterial[41].w)*(1-saturate(first+second));
    float nearEdge=max(_CaptureMaterial[33].w-_CaptureMaterial[34].x,0);
    float fade=Smooth01((dot(s.normal,view)-nearEdge)/max(_CaptureMaterial[33].w+.001-nearEdge,1e-6));
    return lerp(1,_CaptureMaterial[40].yzw,third*s.mask.b*fade*shade);
}

Shaders/Includes/AnantaCharacterPasses.hlsl · 第 130 行

float4 AnantaHairFrag(Varyings i, FRONT_FACE_TYPE facing : FRONT_FACE_SEMANTIC) : SV_Target
{
    if (_UseCaptureConstants<.5 || _MaterialType<2.5 || _MaterialType>3.5) clip(-1);
    float4 color=AnantaFrag(i,facing);
    float alpha=SAMPLE_TEXTURE2D(_BaseMap,sampler_BaseMap,i.uv).a;
    if (asuint(_CaptureMaterial[325].w)!=0) alpha=saturate(alpha*2);
    alpha=1+_CaptureMaterial[13].w*(alpha-1);
    float3 view=SafeNormalize(GetWorldSpaceViewDir(i.positionWS));
    float2 projected=float2(dot(cross(_CaptureHairAxisA.xyz,_CaptureHairAxisB.xyz),view),dot(_CaptureHairAxisB.xyz,view));
    float projectionLength=length(projected);
    float scaledLength=length(projected/(projectionLength+.001)*_CaptureMaterial[14].zw);
    alpha=lerp(alpha,1,Smooth01((projectionLength-.7*scaledLength)/max(.3*scaledLength,1e-6)));
    // Source s2 is bilinear/clamp and ftou truncates interpolated category bytes.
    uint packed=(uint)(SAMPLE_TEXTURE2D(_AnantaHairClassification,sampler_LinearClamp,GetNormalizedScreenSpaceUV(i.positionCS)).r*255);
    if ((packed>>6)==2 && (packed&63)==(uint)_CaptureCharacterId)
    {
        float axisDepth=dot(_CaptureHairAxisA.xyz,UNITY_MATRIX_V[2].xyz);
        float weight=Smooth01((axisDepth-_CaptureMaterial[14].y)/max(.99-_CaptureMaterial[14].y,1e-6));
        alpha=lerp(alpha,_CaptureMaterial[14].x,weight);
    }
    color.a=alpha;
    return color;
}

Shaders/Includes/AnantaOutlineGeometry.hlsl · 第 39 行

OutlineVaryings OutlineVert(OutlineAttributes v)
{
    OutlineVaryings o;
    // VS 104703/104715/104727: TEXCOORD2 encodes a tangent-space
    // smooth normal, not a displacement in model or screen space.
    float2 xy = v.auxiliaryNormal * 2 - 1;
    float3 smoothNormal = float3(xy, sqrt(saturate(1 - dot(xy, xy))));
    if (_OutlineOctahedral != 0)
    {
        smoothNormal = float3(xy, 1 - abs(xy.x) - abs(xy.y));
        float fold = saturate(-smoothNormal.z);
        smoothNormal.xy += float2(xy.x >= 0 ? -fold : fold, xy.y >= 0 ? -fold : fold);
        smoothNormal = normalize(smoothNormal);
    }
    float3 normalWS = TransformObjectToWorldNormal(v.normalOS, false);
    float3 tangentWS = TransformObjectToWorldDir(v.tangentOS.xyz, false);
    float3 bitangentWS = cross(normalWS, tangentWS) * v.tangentOS.w;
    float3 directionWS = normalize(smoothNormal.x * tangentWS + smoothNormal.y * bitangentWS + smoothNormal.z * normalWS);
    float3 positionWS = TransformObjectToWorld(v.positionOS.xyz);
    if (_OutlineScreenSpace > 0.5)
    {
        float3 positionVS = TransformWorldToView(positionWS);
        float4 originalCS = mul(UNITY_MATRIX_P, float4(positionVS, 1));
        o.positionCS = originalCS;
        if (abs(originalCS.w) > 0.000001)
        {
            float3 directionVS = mul((float3x3)UNITY_MATRIX_V, directionWS);
            float2 viewport = max(GetScaledScreenParams().xy, float2(1, 1));
            // Pixel width sets the silhouette scale. Preserve the projected
            // normal's foreshortening and the same extrusion's depth: forcing
            // tiny face-normal projections to full width distorts inner lips.
            float ndcWidth = 2 * _OutlinePixelWidth * _OutlineGlobalWidth * (2 * v.color.g) / viewport.y;
            float viewWidth = ndcWidth * abs(originalCS.w) / max(abs(UNITY_MATRIX_P._m11), 0.000001);
            float4 expandedCS = mul(UNITY_MATRIX_P, float4(positionVS + directionVS * viewWidth, 1));
            if (abs(expandedCS.w) > 0.000001)
            {
                // Map back using the original w, preserving the NDC path's
                // surface interpolation while updating both XY and depth.
                o.positionCS.xyz = (expandedCS.xyz / expandedCS.w) * originalCS.w;
            }
            if (_MaterialType > 2.5 && abs(positionVS.z) > 0.000001)
            {
                float bias = (saturate(v.color.r - 1.0 / 255.0) * 2 - 1) * _OutlineVertexDepthBias;
                float3 biasedVS = positionVS * ((positionVS.z - bias * 0.005) / positionVS.z);
                float4 biasedCS = mul(UNITY_MATRIX_P, float4(biasedVS, 1));
                // Preserve the explicit hair bias, but leave the screen offset
                // and original clip.w independent of inflated-hull depth.
                if (abs(biasedCS.w) > 0.000001)
                    o.positionCS.z = (biasedCS.z / biasedCS.w) * originalCS.w;
            }
        }
    }
    else
    {
        float viewZ = TransformWorldToView(positionWS).z;
        float width = _OutlineGlobalWidth * _OutlineWidth * 0.002;
        width *= sqrt(abs(viewZ) / abs(UNITY_MATRIX_P._m00)) * (2 * v.color.g);
        float3 expandedVS = TransformWorldToView(positionWS + directionWS * width);
        if (_MaterialType > 2.5)
        {
            float bias = (saturate(v.color.r - 1.0 / 255.0) * 2 - 1) * _OutlineVertexDepthBias;
            expandedVS *= (expandedVS.z - bias * 0.005) / expandedVS.z;
        }
        o.positionCS = mul(UNITY_MATRIX_P, float4(expandedVS, 1));
    }
    o.clipDistance = _OutlineEnabled < 0.5 ? -1 : 1;
    if (_MaterialType < 0.5)
    {
        o.positionCS.z -= _OutlineDepthBias * 0.001 * o.positionCS.w;
        float4 group = float4(v.color.a >= 0 && v.color.a < 0.28,
            v.color.a >= 0.28 && v.color.a < 0.51,
            v.color.a >= 0.51 && v.color.a < 0.79,
            v.color.a >= 0.79 && v.color.a < 0.98);
        if ((dot(group, _OutlineClipThresholds) >= v.color.a && v.color.a <= 0.98) || _OutlineDisabled != 0)
            o.clipDistance = -1;
    }
    o.uv = float2(v.uv.x, lerp(v.uv.y, 1 - v.uv.y, _FlipV));
    return o;
}

Shaders/AnantaPost.shader · 第 85 行

        float4 FragScatterBlur(Varyings i) : SV_Target
        {
            int2 pixel = int2(i.texcoord * _AnantaScatterSize.zw);
            float4 center = LOAD_TEXTURE2D(_BlitTexture, pixel);
            if (center.b <= 0) return 0;
            uint profile = min((uint)(center.a * 255 + .5), 15u);
            // Every active character pixel in event 17599 selects profile 8.
            // Other profiles need their own capture data, not this character's kernel.
            if (profile != 8u) return float4(center.rgb, 1);
            float deviceDepth = ScatterDeviceDepth(pixel);
            float centerDepth = ScatterLinearDepth(deviceDepth);
            float distanceFade = saturate(centerDepth / 3.5);
            distanceFade *= distanceFade * (3 - 2 * distanceFade);
            float radiusScale = 1 + 24 * distanceFade; // cb0[45]=(1,25,3.5,0)
            float millimetersPerUnit = 1000 / radiusScale;
            float homogeneousW = 6.1537799835 * deviceDepth + 0.000066389694;
            float worldPixel = max(2 * .3941239119 * _AnantaScatterSize.x / homogeneousW, .0001);
            float pixelsPerMillimeter = rcp(millimetersPerUnit * worldPixel);
            // cb2[32].xy=(1,.1656437665), cb0[44].w=20.
            uint count = min((uint)(pow(pixelsPerMillimeter * .1656437665, 2) * .785398), 20u);
            if (count < 1u) return float4(center.rgb, 1);
            uint hash = ScatterHash((uint)(deviceDepth * 16777216));
            hash = ScatterHash(hash ^ (uint)pixel.y);
            hash = ScatterHash(hash ^ (uint)pixel.x);
            float rotation = (asfloat((hash & 0x007fffffu) | 0x3f800000u) - 1) * 6.283185;
            float rotationSin, rotationCos;
            sincos(rotation, rotationSin, rotationCos);
            float3 sum = 0, weightSum = 0;
            const float3 decay = float3(100, 346.1864319, 324.8656921); // cb2[8].xyz
            [loop] for (uint sampleIndex = 0u; sampleIndex < count; sampleIndex++)
            {
                float u = 1 - (sampleIndex + .5) / count;
                float fourU = 4 * u;
                float q = 1 + fourU * (2 * u + sqrt(1 + fourU * u));
                float reciprocalCubeRoot = exp2(log2(q) * (-1.0 / 3.0));
                float h = reciprocalCubeRoot * reciprocalCubeRoot * q + reciprocalCubeRoot + 1;
                float radius = (log2(h) * 2.079442 - (log2(u) * 2.079442 + 4.158883)) * .01;
                float inversePdf = h * h * h / ((fourU * fourU + h * h) * fourU) * 25.132742 * .01;
                float angle = frac(sampleIndex * .618034) * 6.283185;
                float angleSin, angleCos;
                sincos(angle, angleSin, angleCos);
                float2 direction = float2(rotationCos * angleCos - rotationSin * angleSin,
                                          rotationSin * angleCos + rotationCos * angleSin);
                int2 samplePixel = pixel + int2(round(direction * (pixelsPerMillimeter * radius)));
                if (any(samplePixel < 0) || any(samplePixel >= int2(_AnantaScatterSize.zw))) continue;
                float4 value = LOAD_TEXTURE2D(_BlitTexture, samplePixel);
                uint sampleProfile = value.a > 0 ? min((uint)(value.a * 255 + .5), 15u) : profile;
                if (value.b <= 0 || sampleProfile != profile) continue;
                float depthDelta = (ScatterLinearDepth(ScatterDeviceDepth(samplePixel)) - centerDepth) * millimetersPerUnit;
                float distance = sqrt(radius * radius + depthDelta * depthDelta);
                float3 e = exp2(-.480898 * distance * decay);
                float3 weight = e * (1 + e * e) * (.039789 * decay) * inversePdf;
                if (_AnantaMsaaScatter > .5) weight *= LOAD_TEXTURE2D(_AnantaScatterCoverageDepth,samplePixel).r;
                sum += value.rgb * weight;
                weightSum += weight;
            }
            return float4(sum / max(weightSum, 1e-20), 1);
        }

Shaders/AnantaPost.shader · 第 250 行

        float4 FragTemporal(Varyings i) : SV_Target
        {
            float2 sampleUV = i.texcoord + _AnantaJitter.xy * _AnantaSourceSize.xy;
            if (_AnantaPostParams.z >= 1) return float4(ReadColor(sampleUV), 0);
            int2 motionPixel = clamp((int2)(i.texcoord * _AnantaMotionSize.zw), int2(0, 0), int2(_AnantaMotionSize.zw) - 1);
            float2 motion = LOAD_TEXTURE2D(_AnantaPreparedMotion, motionPixel).rg - _AnantaMotionJitter.xy;
            float2 historyUV = i.texcoord - motion;
            bool historyValid = _AnantaPostParams.w > .5 && all(historyUV >= 0) && all(historyUV <= 1);
            float4 mask = _AnantaHasTemporalRejection > 1.5
                ? SAMPLE_TEXTURE2D(_AnantaRejectionRgba, sampler_AnantaRejectionRgba, sampleUV)
                : float4(0, _AnantaHasTemporalRejection > .5
                    ? SAMPLE_TEXTURE2D(_AnantaTemporalRejection, sampler_AnantaTemporalRejection, sampleUV).r : 0,
                    0, historyValid ? 1 : 0);
            float alpha = round(mask.a * 100) > 1 ? mask.a : 0;
            bool uncovered = alpha == 0;
            float motionPixels = length(motion * (_AnantaSourceSize.zw * 2));
            float survival = min(alpha + saturate(2 * motionPixels) * (.15 - alpha), alpha);
            float radius = 1 + (1.0 / .75 - 1) * min(5 * survival, min(1 - mask.b, 1 - .5 * mask.g));
            float2 pixel = i.texcoord * _AnantaSourceSize.zw + _AnantaJitter.xy - .5;
            // DXBC round_ni at 30159:241 floors the unjittered input position.
            float2 centerPixel = floor(i.texcoord * _AnantaSourceSize.zw);
            float3 sum = 0, mean = 0, secondMoment = 0, low = 1e20, high = -1e20;
            float weight = 0, momentWeight = 0;
            [unroll] for (int y = -1; y <= 1; y++)
            [unroll] for (int x = -1; x <= 1; x++)
            {
                float2 p = centerPixel + float2(x, y);
                float3 c = ToTemporalColor(ReadColor((p + .5) * _AnantaSourceSize.xy), uncovered);
                float2 delta = (p - pixel) * radius;
                float distance2 = min(dot(delta, delta), 4);
                // Captured 30159:567-579 radial reconstruction and moment kernels.
                float polynomial = 1.5625 * pow(.4 * distance2 - 1, 2) - .5625;
                float w = pow(.25 * distance2 - 1, 2) * polynomial;
                float2 momentDelta = p - pixel;
                float mw = exp2(-3.318198 * dot(momentDelta, momentDelta));
                // Optional preview filter: source negative lobes can retain dark
                // ringing on a static captured pose. Keep source mode unchanged.
                if (_AnantaStableTemporalReconstruction > .5) w = mw;
                bool validTap = all(p >= 0) && all(p < _AnantaSourceSize.zw);
                if (validTap)
                {
                    if (!uncovered) { sum += c * w; weight += w; }
                    mean += c * mw; secondMoment += c * c * mw; momentWeight += mw;
                }
                low = min(low, c); high = max(high, c);
            }
            float3 current = uncovered ? DecompressTemporal(mean / max(momentWeight, 0.000061))
                : clamp(sum / max(weight, 0.000061), low, high);
            if (!historyValid) return float4(FromTemporalColor(CompressTemporal(current)), 0);
            float4 historyRGBA = ReadHistory(historyUV);
            float3 history = ToTemporalColor(historyRGBA.rgb, false);
            mean /= momentWeight;
            float3 deviation = sqrt(abs(secondMoment / momentWeight - mean * mean));
            float luminanceConfidence = _AnantaHasTemporalRejection > 1.5
                ? SAMPLE_TEXTURE2D(_AnantaLumaConfidence, sampler_AnantaLumaConfidence, i.texcoord).r : 1;
            float varianceMask = _AnantaHasTemporalRejection > 1.5
                ? SAMPLE_TEXTURE2D(_AnantaVarianceControl, sampler_AnantaVarianceControl, sampleUV).r : 0;
            float maxMask = max(mask.r, max(mask.g, mask.b));
            float reactive = saturate(max(historyRGBA.a - 2 * maxMask, 0) - 1);
            float confidence = min(1, max(luminanceConfidence, reactive) * alpha * (1 - mask.g));
            float varianceFactor = 3 - 2 * max(saturate(motionPixels * .05),
                max(saturate(.75 - .05 * varianceMask), max(sqrt(mask.r), max(mask.b, 1 - mask.a))));
            float3 extent = max(deviation * float3(1.7 * varianceFactor, varianceFactor, varianceFactor), 0.00001);
            float3 offset = (history - mean) / extent;
            float distance = length(offset);
            float3 clipped = distance > 1 ? mean + (history - mean) / distance : history;
            clipped += confidence * (history - clipped);
            float currentNumerator = uncovered ? 1 : weight * .04625;
            float historyWeight = uncovered ? 0 : survival;
            float currentWeight = currentNumerator / max(currentNumerator + historyWeight, .000061);
            float3 blended = lerp(CompressTemporal(clipped), CompressTemporal(current), currentWeight);
            float lockValue = LOAD_TEXTURE2D(_AnantaLock, int2(i.positionCS.xy)).r;
            float nextAlpha = max(min(max(historyRGBA.a - 2 * maxMask, 0) + lockValue * (1 - mask.r), 2)
                                  - (.1 / 14) * (1 - maxMask), 0);
            nextAlpha *= all(i.texcoord + motion >= 0) && all(i.texcoord + motion <= 1) ? 1 : 0;
            return float4(FromTemporalColor(blended), nextAlpha);
        }

Shaders/AnantaPost.shader · 第 444 行

        float4 FragFinal(Varyings i) : SV_Target
        {
            float2 uv = i.texcoord;
            float3 scene = ReadColor(uv);
            float3 bloom = ReadBloom(uv);
            float3 c = max(scene + bloom * _AnantaBloomParams.y, 0);
            float3 encoded = saturate(log2(c + 0.002668) / 14.0 + 0.610727);
            float3 lutUVW = encoded * (31.0 / 32.0) + (0.5 / 32.0);
            float3 graded = LinearToSRGB(saturate(c));
            if (_AnantaLutReady > 0.5)
                graded = lerp(graded, saturate(SAMPLE_TEXTURE3D(_AnantaLut, sampler_AnantaLut, lutUVW).rgb * 1.05), saturate(_AnantaLutIntensity));
            float3 linearColor = SRGBToLinear(graded);
            // Captured cb0[74..77]: black, aspect 1; center .5; intensity 1.2;
            // exponent 1; roundness 0; offsets (.6,.2); identity rotation.
            float2 edge = saturate(abs(uv - _AnantaVignetteParams.zw) * _AnantaVignetteParams.x - float2(0.6, 0.2));
            float vignette = saturate(1 - dot(edge, edge));
            linearColor *= lerp(1.0.xxx, lerp(_AnantaVignetteColor.rgb, 1.0.xxx, vignette), _AnantaVignetteParams.y);
            // The feature writes the scene-linear camera intermediate. URP's
            // final blit / sRGB render target performs the display encoding once.
            return float4(linearColor, 1);
        }