devbox
喵喵爱编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

URP 简单卡渲_urp smooth

作者：喵喵爱编程 | 2024-07-31 06:50:33

赞

踩

urp smooth

 使用unity版本为2022.2.21f1

shader文件

  1. Shader "Unlit/SRUniversal"
  2. {
  3.     Properties
  4.     {
  5.         [KeywordEnum(None,Face,Hair,UpperBody,LowerBody)] _Area("Material area", Float) = 0
  6.         [HideInInspector] _HeadForward("", Vector) = (0,0,1)
  7.         [HideInInspector] _HeadRight("", Vector) = (1,0,0)
  8.  
  9.         [Header(Base Color)]
  10.         [HideInInspector] _BaseMap("", 2D) = "white"{}
  11.         [NoScaleOffset] _FaceColorMap("Face color map (Default white)", 2D) = "white"{}
  12.         [NoScaleOffset] _HairColorMap("Hair color map (Default white)", 2D) = "white"{}
  13.         [NoScaleOffset] _UpperBodyColorMap("Upper body color map (Default white)", 2D) = "white"{}
  14.         [NoScaleOffset] _LowerBodyColorMap("Lower body color map (Default white)", 2D) = "white"{}
  15.         _FrontFaceTintColor("Front face tint color (Default white)", Color) = (1,1,1)
  16.         _BackFaceTintColor("Back face tint color (Default white)", Color) = (1,1,1)
  17.         _Alpha("Alpha (Default 1)", Range(0, 1)) = 1
  18.         _AlphaClip("Alpha clip (Default 0.333)", Range(0, 1)) = 0.333
  19.  
  20.         [Header(Light Map)]
  21.         [NoScaleOffset] _HairLightMap("Hair light map (Default black)", 2D) = "black"{}
  22.         [NoScaleOffset] _UpperBodyLightMap("Upper body light map (Default black)", 2D) = "black"{}
  23.         [NoScaleOffset] _LowerBodyLightMap("Lower body light map (Default black)", 2D) = "black"{}
  24.  
  25.         [Header(Ramp Map)]
  26.         [NoScaleOffset] _HairCoolRamp("Hair cool ramp (Default white)", 2D) = "white"{}
  27.         [NoScaleOffset] _HairWarmRamp("Hair warm ramp (Default white)", 2D) = "white"{}
  28.         [NoScaleOffset] _BodyCoolRamp("Body cool ramp (Default white)", 2D) = "white"{}
  29.         [NoScaleOffset] _BodyWarmRamp("Body warm ramp (Default white)", 2D) = "white"{}
  30.  
  31.         [Header(Indirect Lighting)]
  32.         _IndirectLightFlattenNormal("Indirect light flatten normal (Default 0)", Range(0, 1)) = 0
  33.         _IndirectLightUsage("Indirect light usage (Default 0.5)", Range(0, 1)) = 0.5
  34.         _IndirectLightOcclusionUsage("Indirect light occlusion usage (Default 0.5)", Range(0, 1)) = 0.5
  35.         _IndirectLightMixBaseColor("Indirect light base color (Default 1)", Range(0, 1)) = 1
  36.  
  37.         [Header(Main Lighting)]
  38.         _MainLightColorUsage("Main light color usage (Default 1)", Range(0, 1)) = 1
  39.         _ShadowThresholdCenter("Shadow threshold center (Default 0)", Range(-1, 1)) = 0
  40.         _ShadowThresholdSoftness("Shadow threshold softness (Default 0.1)", Range(0, 1)) = 0.1
  41.         _ShadowRampOffset("Shadow ramp offset (Default 0.75)", Range(0, 1)) = 0.75
  42.  
  43.         [Header(Face)]
  44.         [NoScaleOffset] _FaceMap("Face map (Default black)", 2D) = "black"{}
  45.         _FaceShadowOffset("Face shadow offset (Default -0.01)", Range(-1, 1)) = -0.01
  46.         _FaceShadowTransitionSoftness("Face shadow transition softness (Default 0.05)", Range(0, 1)) = 0.05
  47.  
  48.         [Header(Specular)]
  49.         _SpecularExpon("Specular exponent (Default 50)", Range(1, 128)) = 50
  50.         _SpecularKsNonMetal("Specular Ks non-metal (Default 0.04)", Range(0, 1)) = 0.04
  51.         _SpecularKsMetal("Specular Ks metal (Default 1)", Range(0, 1)) = 1
  52.         _SpecularBrightness("Specular brightness (Default 1)", Range(0, 10)) = 1
  53.  
  54.         [Header(Sockings)]
  55.         [NoScaleOffset] _UpperBodyStockings("Upper body stockings (Default black)", 2D) = "black"{}
  56.         [NoScaleOffset] _LowerBodyStockings("Lower body stockings (Default black)", 2D) = "black"{}
  57.         _StockingsDarkColor("Stocking dark color (Default black)", Color) = (0,0,0)
  58.         [HDR] _StockingsLightColor("Stocking light color (Default 1.8 1.48299 0.856821)", Color) = (1.8, 1.48299, 0.856821)
  59.         [HDR] _StockingsTransitionColor("Stocking Transition color (Default 0.360381 0.242986 0.358131)", Color) = (0.360381, 0.242986, 0.358131)
  60.         _StockingsTransitionThreshold("Stocking transition threshold (Default 0.58)", Range(0, 1)) = 0.58
  61.         _StockingsTransitionPower("Stocking transition Power (Default 1)", Range(0.1, 50)) = 1
  62.         _StockingsTransitionHardness("Stocking transition hardness (Default 0.4)", Range(0, 1)) = 0.4
  63.         _StockingsTextureUsage("Stocking texture usage (Default 0.1)", Range(0, 1)) = 0.1
  64.  
  65.         [Header(Rim Lighting)]
  66.         _RimLightWidth("Rim light width (Default 1)", Range(0, 10)) = 1
  67.         _RimLightThreshold("Rim light threshold (Default 0.05)", Range(-1, 1)) = 0.05
  68.         _RimLightFadeout("Rim light fadeout (Default 1)", Range(0.01, 1)) = 1
  69.         [HDR] _RimLightTintColor("Rim light tint color (Default white)", Color) = (1,1,1)
  70.         _RimLightBrightness("Rim light brightness (Default 1)", Range(0, 10)) = 1
  71.         _RimLightMixAlbedo("Rim light mix albedo (Default 0.9)", Range(0, 1)) = 0.9
  72.  
  73.         [Header(Emission)]
  74.         [Toggle(_EMISSION_ON)] _UseEmission("Use emission (Default False)", Float) = 0
  75.         _EmissionMixBaseColor("Emission mix base color (Default 1)", Range(0, 1)) = 1
  76.         _EmissionTintColor("Emission tint color (Default white)", Color) = (1,1,1)
  77.         _EmissionIntensity("Emission intensity (Default 1)", Range(0, 100)) = 1
  78.  
  79.         [Header(Outline)]
  80.         [Toggle(_OUTLINE_ON)] _UseOutline("Use outline (Default True)", Float) = 1
  81.         [Toggle(_OUTLINE_VERTEX_COLOR_SMOOTH_NORMAL)] _OutlineUseVertexColorSmoothNormal("Use vertex color smooth normal (Default False)", Float) = 0
  82.         _OutlineWidth("Outline width (Default 1)", Range(0, 10)) = 1
  83.         _OutlineGamma("Outline gamma (Default 16)", Range(1, 255)) = 16
  84.  
  85.         [Header(Surface Options)]
  86.         [Enum(UnityEngine.Rendering.CullMode)] _Cull("Cull (Default back)", Float) = 2
  87.         [Enum(UnityEngine.Rendering.BlendMode)] _SrcBlendMode("Src blend mode (Default One)", Float) = 1
  88.         [Enum(UnityEngine.Rendering.BlendMode)] _DstBlendMode("Dst blend mode (Default Zero)", Float) = 0
  89.         [Enum(UnityEngine.Rendering.BlendOp)] _BlendOp("Blend operation (Default Add)", Float) = 0
  90.         [Enum(Off, 0, On, 1)] _ZWrite("ZWrite (Default On)", Float) = 1
  91.         _StencilRef("Stencil reference (Default 0)", Range(0, 255)) = 0
  92.         [Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp("Stencil comparison (Default disabled)", Int) = 0
  93.         [Enum(UnityEngine.Rendering.StencilOp)] _StencilPassOp("Stencil pass operation (Default keep)", Int) = 0
  94.         [Enum(UnityEngine.Rendering.StencilOp)] _StencilFailOp("Stencil fail operation (Default keep)", Int) = 0
  95.         [Enum(UnityEngine.Rendering.StencilOp)] _StencilZFailOp("Stencil Z fail operation (Default keep)", Int) = 0
  96.  
  97.         [Header(Draw Overlay)]
  98.         [Toggle(_DRAW_OVERLAY_ON)] _UseDrawOverlay("Use draw overlay (Default False)", Float) = 0
  99.         [Enum(UnityEngine.Rendering.BlendMode)] _SrcBlendModeOverlay("Overlay pass src blend mode (Default One)", Float) = 1
  100.         [Enum(UnityEngine.Rendering.BlendMode)] _DstBlendModeOverlay("Overlay pass src blend mode (Default Zero)", Float) = 0
  101.         [Enum(UnityEngine.Rendering.BlendOp)] _BlendOpOverlay("Overlay pass blend operation (Default Add)", Float) = 0
  102.         _StencilRefOverlay("Overlay pass stencil reference (Default 0)", Range(0, 255)) = 0
  103.         [Enum(UnityEngine.Rendering.CompareFunction)] _StencilCompOverlay ("Overlay pass stencil comparison (Default disabled)", Int) = 0
  104.     }
  105.     SubShader
  106.     {
  107.         LOD 100
  108.  
  109.         HLSLINCLUDE
  110.          HLSL code that you want to share goes here
  111.         #pragma shader_feature_local _AREA_FACE
  112.         #pragma shader_feature_local _AREA_HAIR
  113.         #pragma shader_feature_local _AREA_UPPERBODY
  114.         #pragma shader_feature_local _AREA_LOWERBODY
  115.         #pragma shader_feature_local _OUTLINE_ON
  116.         #pragma shader_feature_local _OUTLINE_VERTEX_COLOR_SMOOTH_NORMAL
  117.         #pragma shader_feature_local _DRAW_OVERLAY_ON
  118.         #pragma shader_feature_local _EMISSION_ON
  119.         ENDHLSL
  120.  
  121.  
  122.         Pass
  123.         {
  124.             Name "ShadowCaster"
  125.             Tags{"LightMode" = "ShadowCaster"}  //  阴影贴图
  126.  
  127.             ZWrite [_ZWrite]
  128.             ZTest LEqual
  129.             ColorMask RGBA
  130.             Cull [_Cull]
  131.  
  132.             HLSLPROGRAM
  133.             //#pragma exclude_renders gles gles3 glcore
  134.             #pragma targe 4.5
  135.  
  136.             // -------------------------------------------------------------------------------------------
  137.             // Material Keywords
  138.             #pragma shader_feature_local_fragment _ALPHATEST_ON
  139.             #pragma shader_feature_local_fragment _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
  140.  
  141.             // -------------------------------------------------------------------------------------------
  142.             // GPU Instancing
  143.             #pragma multi_compile_instancing
  144.             #pragma multi_compile _ DOTS_INSTANCING_ON
  145.  
  146.             // -------------------------------------------------------------------------------------------
  147.             // Universial Pipeline keywords
  148.  
  149.             // this is used during shadow map generation to differentiate between directional and punctual light shadows, as they use different formulas to apply Normal Bias
  150.             #pragma multi_compile_vertex _ _CASTING_PUNCTUAL_LIGHT_SHADOW
  151.  
  152.             #pragma vertex ShadowPassVertex
  153.             #pragma fragment ShadowPassFragment
  154.  
  155.             #include "Packages/com.unity.render-pipelines.universal/Shaders/LitInput.hlsl"
  156.             #include "Packages/com.unity.render-pipelines.universal/Shaders/ShadowCasterPass.hlsl"
  157.  
  158.             ENDHLSL
  159.         }
  160.  
  161.         Pass
  162.         {
  163.             Name "DepthOnly"
  164.             Tags{"LightMode" = "DepthOnly" "Queue" = "Transparent" }  //  深度贴图
  165.  
  166.             ZWrite [_ZWrite]
  167.             ColorMask RGBA
  168.             Cull [_Cull]
  169.  
  170.             HLSLPROGRAM
  171.             //#pragma exclude_renders gles gles3 glcore
  172.             #pragma targe 4.5
  173.  
  174.             // -------------------------------------------------------------------------------------------
  175.             // Material Keywords
  176.             #pragma shader_feature_local_fragment _ALPHATEST_ON
  177.             #pragma shader_feature_local_fragment _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
  178.  
  179.             // -------------------------------------------------------------------------------------------
  180.             // GPU Instancing
  181.             #pragma multi_compile_instancing
  182.             #pragma multi_compile _ DOTS_INSTANCING_ON
  183.  
  184.             #pragma Vertex DepthOnlyVertex
  185.             #pragma fragment DepthOnlyFragment
  186.  
  187.             #include "Packages/com.unity.render-pipelines.universal/Shaders/LitInput.hlsl"
  188.             #include "Packages/com.unity.render-pipelines.universal/Shaders/DepthOnlyPass.hlsl"
  189.  
  190.             ENDHLSL
  191.         }
  192.  
  193.         Pass
  194.         {
  195.             Name "DepthNormals"
  196.             Tags{"LightMode" = "DepthNormals"}  //  向SSAO传输值
  197.  
  198.             ZWrite [_ZWrite]
  199.             Cull [_Cull]
  200.  
  201.             HLSLPROGRAM
  202.             //#pragma exclude_renders gles gles3 glcore
  203.             #pragma targe 4.5
  204.  
  205.             // -------------------------------------------------------------------------------------------
  206.             // Material Keywords
  207.             #pragma shader_feature_local _NORMALMAP
  208.             #pragma shader_feature_local _PARALLAXMAP
  209.             #pragma shader_feature_local _ _DETAIL_MULTX2 _DETAIL_SCALED
  210.             #pragma shader_feature_local_fragment _ALPHATEST_ON
  211.             #pragma shader_feature_local_fragment _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
  212.  
  213.             // -------------------------------------------------------------------------------------------
  214.             // GPU Instancing
  215.             #pragma multi_compile_instancing
  216.             #pragma multi_compile _ DOTS_INSTANCING_ON
  217.  
  218.             #include "Packages/com.unity.render-pipelines.universal/Shaders/LitInput.hlsl"
  219.             #include "Packages/com.unity.render-pipelines.universal/Shaders/LitDepthNormalsPass.hlsl"
  220.  
  221.             ENDHLSL
  222.         }
  223.  
  224.         Pass
  225.         {
  226.             Name "DrawCore"
  227.             Tags{ "RenderPipeline" = "UniversalRenderPipeline" "RenderType" = "Opaque" "LightMode" = "SRPDefaultUnlit"}
  228.  
  229.             Cull [_Cull]
  230.             Stencil{
  231.                 Ref [_StencilRef]           //这是传进去的int值(默认0【0，255】注意这是二进制11111111)，如果在测试就用这个值和模板值(如果没有写入过默认0)作比较，受readMask影响、如果在写入就是写入这个值，受writeMask影响
  232.                 Comp [_StencilComp]         //何时通过模板测试，这个和写入没有任何关系，还有CompBack和CompFront专门针对背面和正面，如果存在Comp则会覆盖他们，值为：Never、Less、Equal、LEqual、Greater、NotEqual、GEqual、Always
  233.                 Pass [_StencilPassOp]       //设置对通过模板测试的像素怎么处理，还有PassBack和PassFront专门针对背面和正面，如果存在Pass则会覆盖他们，值为：Keep(保持原值)、Zero(写入模板值0)、Replace(写入Ref值)、IncrSat(加上去但不超过255)、DecrSat(相减但不小于0)、Invert(所有位取反)、IncrWrap(加上去但超过255会从0重新开始)、DecrWrap(相减但小于0会从255重新开始)
  234.                 Fail [_StencilFailOp]       //设置对未通过模板测试的像素怎么处理，还有FailBack和FailFront专门针对背面和正面，如果存在Fail则会覆盖他们，值和Pass的相同
  235.                 ZFail [_StencilZFailOp]     //当像素通过模板测试但未通过深度测试时怎么处理，还有ZFailBack和ZFailFront专门针对背面和正面，如果存在ZFail则会覆盖他们，值和Pass的相同
  236.             }
  237.             Blend [_SrcBlendMode] [_DstBlendMode]
  238.             BlendOp [_BlendOp]
  239.             ZWrite [_ZWrite]
  240.  
  241.             HLSLPROGRAM
  242.             //#pragma exclude_renders gles gles3 glcore
  243.             #pragma targe 4.5
  244.             #pragma multi_compile _MAIN_LIGHT_SHADOWS
  245.             #pragma multi_compile _MAIN_LIGHT_SHADOWS_CASCADE
  246.             #pragma multi_compile _SHADOW_SOFT
  247.  
  248.             #pragma vertex vert
  249.             #pragma fragment frag
  250.  
  251.             #pragma multi_compile_fog
  252.  
  253.             #include "SRUniversalInput.hlsl"
  254.             #include "SRUniversalDrawCorePass.hlsl"
  255.  
  256.             ENDHLSL
  257.         }
  258.  
  259.         Pass
  260.         {
  261.             Name "DrawOutline"
  262.             Tags{ "RenderPipeline" = "UniversalRenderPipeline" "RenderType" = "Opaque" "LightMode" = "UniversalForwardOnly" }
  263.             Cull Front
  264.             ZWrite[_ZWrite]
  265.  
  266.             HLSLPROGRAM
  267.             #pragma vertex vert
  268.             #pragma fragment frag
  269.  
  270.             #pragma multi_compile_fog
  271.  
  272.             #if _OUTLINE_ON
  273.             #include "SRUniversalInput.hlsl"
  274.             #include "SRUniversalDrawOutlinePass.hlsl"
  275.             #else
  276.  
  277.             struct Attribute {};
  278.  
  279.             struct Varyings
  280.             {
  281.                 float4 positionCS : SV_POSITION;
  282.             };
  283.  
  284.             Varyings vert(Attribute input)
  285.             {
  286.                 return (Varyings)0;
  287.             }
  288.  
  289.             float4 frag(Varyings input) : SV_TARGET
  290.             {
  291.                 return 0;
  292.             }
  293.  
  294.             #endif
  295.             ENDHLSL
  296.             
  297.         }
  298.     }
  299.         Fallback Off
  300. }

hlsl文件

SRUniversalInput

  1. #ifndef _SR_UNIVERSAL_INPUT_INCLUDED
  2. #define _SR_UNIVERSAL_INPUT_INCLUDED
  3.  
  4. #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
  5. /*
  6. 包含VertexPositionInputs、VertexNormalInputs结构以及各种基础定义  #define TEXTURE2D_X(textureName)  TEXTURE2D_ARRAY(textureName)
  7. #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
  8. 约定：
  9. unity在世界空间是左手，但是在视图空间为右手。世界到视图空间的矩阵行列式是负的
  10. 对于cubmap捕获(反射探针)，视图空间仍是左手，行列式为正
  11. 	//WS：世界空间
  12. 	//RWS：相机相对世界空间。为了提高精度，已经减去了相机平移的空间
  13. 	//VS：视图空间
  14. 	//OS:对象空间
  15. 	//CS：同构剪辑空间
  16. 	//TS：切线空间
  17. 	//TXS:纹理空间
  18. 大写字母矢量都指向像素位置且归一View vector、Light vector、Light vector、Half vector
  19. out和inout过滤器，当声明函数的“out”参数时，它们总是最后一个
  20. 不要使用SetGlobalFloatArray或SetComputeFloatParams。//数组可以是hlsl中的别名。示例：uniform float4-packedArray[3]；static float unpackedArray[12]=（float[12]）packedArray；
  21. *包含非常多的常用基本函数定义PackHeightmap、GetPositionInput、SinFromCos、Orthonormalize等等*
  22. -----------------------------------------------------------------------------------------------------------------
  23. #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Packing.hlsl"
  24. Unpack888UIntToFloat2(uint3 x)、Unpack8ToFloat2(float f)、PackToR5G6B5(float3 rgb) 看起来是各种格式互转的方法
  25. -----------------------------------------------------------------------------------------------------------------
  26. #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Version.hlsl"
  27. UNITY_VERSION宏
  28. -----------------------------------------------------------------------------------------------------------------
  29. #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl"
  30. InputData结构体、很多常量输入(应该是unity给值，直接拿那种)比如_MainLightPosition
  31. -----------------------------------------------------------------------------------------------------------------
  32. #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderVariablesFunctions.hlsl"
  33. 各种各样的方法，GetWorldSpaceViewDir之类的获取各种输入结构、LinearDepthToEyeDepth变换方法、TransformScreenUV(inout float2 uv)甚至编码解码什么的
  34. */
  35. #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
  36. /*
  37. 各种光照方法LightingLambert、LightingSpecular、LightingPhysicallyBased、VertexLighting、CalculateLightingColor、CalculateBlinnPhong、UniversalFragmentPBR、UniversalFragmentBlinnPhong、UniversalFragmentBakedLit
  38. 结构体LightingData获取各种光照信息
  39. #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/BRDF.hlsl"  光反射模型
  40. 结构体BRDFData、方法：InitializeBRDFData、EnvironmentBRDFSpecular、DirectBRDFSpecular
  41. 	{
  42. 	#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/BSDF.hlsl"  包括BRDF反射、BTDF透射、BDDF衍射
  43. 	#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl"
  44. 	方法：ClampRoughnessForRaytracing、BlendNormal、ConvertRoughnessToAnisotropy材质属性(粗糙度)相关的
  45. 	#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/SurfaceData.hlsl"
  46. 	定义SurfaceData结构体，是物体表面的各种属性摩擦、金属、间接光遮....
  47. 	}
  48. #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Debug/Debugging3D.hlsl"
  49. 方法：CanDebugOverrideOutputColor、CalculateColorForDebugMaterial看起来都是debug用的方法
  50. #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/GlobalIllumination.hlsl"
  51. 方法：SampleProbeVolumePixel、SampleLightmap、GlossyEnvironmentReflection、GlobalIllumination都是一些全局照明所需要的方法
  52. #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RealtimeLights.hlsl"
  53. 定义Light结构、方法：灯光衰减DistanceAttenuation、GetMainLight等
  54. #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/AmbientOcclusion.hlsl"
  55. 定义AmbientOcclusionFactor结构，GetScreenSpaceAmbientOcclusion屏幕空间环境光遮挡
  56. #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DBuffer.hlsl" 看起来是贴花相关的东西
  57. */
  58. #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareDepthTexture.hlsl"
  59. //只是声明深度图，附带采样、读取方法SampleSceneDepth、LoadSceneDepth
  60. #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Shadows.hlsl"
  61. //阴影相关，定义ShadowSamplingData结构体，GetMainLightShadowSamplingData、GetMainLightShadowParams、SampleShadowmap、ApplyShadowBias
  62.  
  63.  
  64. /*
  65. 像这样做就是放在常量缓冲区，下面这种做法是unity宏，确保在支持时使用它们
  66. cbuffer UnityPerFrame {
  67. 	float4x4 unity_MatrixVP;
  68. };
  69. */
  70. CBUFFER_START(UnityPerMaterial)
  71. float3 _HeadForward;
  72. float3 _HeadRight;
  73.  
  74. sampler2D _BaseMap;
  75. float4 _BaseMap_ST;
  76.  
  77. #if _AREA_FACE
  78. 	sampler2D _FaceColorMap;
  79. #elif _AREA_HAIR
  80. 	sampler2D _HairColorMap;
  81. #elif _AREA_UPPERBODY
  82. 	sampler2D _UpperBodyColorMap;
  83. #elif _AREA_LOWERBODY
  84. 	sampler2D _LowerBodyColorMap;
  85. #endif
  86.  
  87. float3 _FrontFaceTintColor;
  88. float3 _BackFaceTintColor;
  89.  
  90. float _Alpha;
  91. float _AlphaClip;
  92.  
  93. #if _AREA_HAIR
  94. 	sampler2D _HairLightMap;
  95. #elif _AREA_UPPERBODY
  96. 	sampler2D _UpperBodyLightMap;
  97. #elif _AREA_LOWERBODY
  98. 	sampler2D _LowerBodyLightMap;
  99. #endif
  100.  
  101. #if _AREA_HAIR
  102. 	sampler2D _HairCoolRamp;
  103. 	sampler2D _HairWarmRamp;
  104. #elif _AREA_FACE || _AREA_UPPERBODY || _AREA_LOWERBODY
  105. 	sampler2D _BodyCoolRamp;
  106. 	sampler2D _BodyWarmRamp;
  107. #endif
  108.  
  109. float _IndirectLightFlattenNormal;
  110. float _IndirectLightUsage;
  111. float _IndirectLightOcclusionUsage;
  112. float _IndirectLightMixBaseColor;
  113.  
  114. float _MainLightColorUsage;
  115. float _ShadowThresholdCenter;
  116. float _ShadowThresholdSoftness;
  117. float _ShadowRampOffset;
  118.  
  119. #if _AREA_FACE
  120. 	sampler2D _FaceMap;
  121. 	float _FaceShadowOffset;
  122. 	float _FaceShadowTransitionSoftness;
  123. #endif
  124.  
  125. #if _AREA_HAIR || _AREA_UPPERBODY || _AREA_LOWERBODY
  126. 	float _SpecularExpon;
  127. 	float _SpecularKsNonMetal;
  128. 	float _SpecularKsMetal;
  129. 	float _SpecularBrightness;
  130. #endif
  131.  
  132. #if _AREA_UPPERBODY || _AREA_LOWERBODY
  133. 	#if _AREA_UPPERBODY
  134. 		sampler2D _UpperBodyStockings;
  135. 	#elif _AREA_LOWERBODY
  136. 		sampler2D _LowerBodyStockings;
  137. 	#endif
  138. 	float3 _StockingsDarkColor;
  139. 	float3 _StockingsLightColor;
  140. 	float3 _StockingsTransitionColor;
  141. 	float _StockingsTransitionThreshold;
  142. 	float _StockingsTransitionPower;
  143. 	float _StockingsTransitionHardness;
  144. 	float _StockingsTextureUsage;
  145. #endif
  146.  
  147. float _RimLightWidth;
  148. float _RimLightThreshold;
  149. float _RimLightFadeout;
  150. float3 _RimLightTintColor;
  151. float _RimLightBrightness;
  152. float _RimLightMixAlbedo;
  153.  
  154. #if _OUTLINE_ON
  155. 	float _OutlineWidth;
  156. 	float _OutlineGamma;
  157. #endif
  158.  
  159. CBUFFER_END
  160.  
  161. #endif

 SRUniversalDrawOutlinePass

  1. struct Attributes 
  2. {
  3.     float3 positionOS   : POSITION;
  4.     float3 normalOS     : NORMAL;
  5.     float4 tangentOS    : TANGENT;
  6.     float4 color        : COLOR;
  7.     float4 uv           : TEXCOORD0;
  8. };
  9.  
  10. struct Varyings
  11. {
  12.     float4 positionCS               : SV_POSITION;
  13.     float2 uv                       : TEXCOORD0;
  14.     float fogFactor                 : TEXCOORD1;
  15.     float4 color                    : TEXCOORD2;
  16.  
  17. };
  18.  
  19. float GetCameraFOV()
  20. {
  21.     //https://answers.unity.com/questions/770838/how-can-i-extract-the-fov-information-from-the-pro.html
  22.     float t = unity_CameraProjection._m11;
  23.     float Rad2Deg = 180 / 3.1415;
  24.     float fov = atan(1.0f / t) * 2.0 * Rad2Deg;
  25.     return fov;
  26. }
  27. float ApplyOutlineDistanceFadeOut(float inputMulFix)
  28. {
  29.     //make outline "fadeout" if character is too small in camera's view
  30.     return saturate(inputMulFix);
  31. }
  32. float GetOutlineCameraFovAndDistanceFixMultiplier(float positionVS_Z)
  33. {
  34.     float cameraMulFix;
  35.     if(unity_OrthoParams.w == 0)
  36.     {
  37.         
  38.         // Perspective camera case
  39.         
  41.         // keep outline similar width on screen accoss all camera distance       
  42.         cameraMulFix = abs(positionVS_Z);
  44.         // can replace to a tonemap function if a smooth stop is needed
  45.         cameraMulFix = ApplyOutlineDistanceFadeOut(cameraMulFix);
  47.         // keep outline similar width on screen accoss all camera fov
  48.         cameraMulFix *= GetCameraFOV();       
  49.     }
  50.     else
  51.     {
  52.         
  53.         // Orthographic camera case
  54.         
  55.         float orthoSize = abs(unity_OrthoParams.y);
  56.         orthoSize = ApplyOutlineDistanceFadeOut(orthoSize);
  57.         cameraMulFix = orthoSize * 50; // 50 is a magic number to match perspective camera's outline width
  58.     }
  59.  
  60.     return cameraMulFix * 0.00005; // mul a const to make return result = default normal expand amount WS
  61. }
  62.  
  63. Varyings vert(Attributes input)
  64. {
  65.     Varyings output = (Varyings)0;
  66.  
  67.     VertexPositionInputs vertexPositionInput = GetVertexPositionInputs(input.positionOS);
  68.     VertexNormalInputs vertexNormalInput = GetVertexNormalInputs(input.normalOS, input.tangentOS);
  69.  
  70.     float width = _OutlineWidth;
  71.     width *= GetOutlineCameraFovAndDistanceFixMultiplier(vertexPositionInput.positionVS.z);
  72.  
  73.     float3 positionWS = vertexPositionInput.positionWS;
  74.     positionWS += vertexNormalInput.normalWS * width;
  75.     output.positionCS = TransformWorldToHClip(positionWS);
  76.  
  77.     output.uv = TRANSFORM_TEX(input.uv, _BaseMap);  //  加偏移
  78.     output.fogFactor = ComputeFogFactor(vertexPositionInput.positionCS.z);
  79.  
  80.     return output;
  81. }
  82.  
  83. float4 frag(Varyings input) : SV_TARGET
  84. {
  85.     //描边加颜色，用的采样出来的Ramp
  86.     float3 coolRamp = 0;
  87.     float warmRamp = 0;
  88.  
  89.     #if _AREA_HAIR
  90.         float2 outlineUV = float2(0, 0.5);
  91.         coolRamp = tex2D(_HairCoolRamp, outlineUV).rgb;
  92.         warmRamp = tex2D(_HairWarmRamp, outlineUV).rgb;
  93.     #elif _AREA_UPPERBODY || _AREA_LOWERBODY
  94.         float4 lightMap = 0;
  95.         #if _AREA_UPPERBODY
  96.             lightMap = tex2D(_UpperBodyLightMap, input.uv);
  97.         #elif _AREA_LOWERBODY
  98.             lightMap = tex2D(_LowerBodyLightMap, input.uv);
  99.         #endif
  100.         float materialEnum = lightMap.a;
  101.         float materialEnumOffset = materialEnum + 0.0425;
  102.         float outlineUVy = lerp(materialEnumOffset, materialEnumOffset + 0.5 > 1 ? materialEnumOffset + 0.5 - 1 : materialEnumOffset + 0.5 , fmod((round(materialEnumOffset/0.0625) - 1)/2, 2));
  103.         float2 outlineUV = float2(0, outlineUVy);
  104.         coolRamp = tex2D(_BodyCoolRamp, outlineUV).rgb;
  105.         warmRamp = tex2D(_BodyWarmRamp, outlineUV).rgb;
  106.     #elif _AREA_FACE
  107.         float2 outlineUV = float2(0, 0.0625);
  108.         coolRamp = tex2D(_BodyCoolRamp, outlineUV).rgb;
  109.         warmRamp = tex2D(_BodyWarmRamp, outlineUV).rgb;
  110.     #endif
  111.  
  112.     float3 ramp = lerp(coolRamp, warmRamp, 0.5);
  113.     float3 albedo = pow(saturate(ramp), _OutlineGamma);
  114.  
  115.     float4 color = float4(albedo,1);
  116.     color.rgb = MixFog(color.rgb, input.fogFactor);
  117.  
  118.     return color;
  119. }

SRUniversalDrawCorePass

  1. #ifndef _SR_UNIVERSAL_DRAW_CORE_PASS_INCLUDED
  2. #define _SR_UNIVERSAL_DRAW_CORE_PASS_INCLUDED
  3.  
  4. struct Attributes
  5. {
  6. 	float3 positionOS	: POSITION;
  7. 	half3 normalOS		: NORMAL;
  8. 	half4 tangentOS		: TANGENT;
  9. 	float2 uv			: TEXCOORD0;
  10. };
  11.  
  12. struct Varyings
  13. {
  14. 	float2 uv						: TEXCOORD0;
  15. 	float4 positionWSAndFogFactor	: TEXCOORD1;  // xyz:positionWS, W:vertex fog factor
  16. 	float3 normalWS					: TEXCOORD2;
  17. 	float3 viewDirectionWS			: TEXCOORD3;
  18. 	float3 SH						: TEXCOORD4;
  19. 	float4 positionCS				: SV_POSITION;
  20. };
  21.  
  22. //去饱和方法
  23. float3 desaturation(float3 colorIn)
  24. {
  25.     float3 grayXfer = float3(0.3, 0.59, 0.11);  //  心理学灰度因子
  26.     float grayf = dot(colorIn, grayXfer);
  27.     return float3(grayf, grayf, grayf);
  28. }
  29.  
  30. struct Gradient
  31. {
  32. 	int colorsLength;
  33. 	float4 colors[8];
  34. };
  35.  
  36. //梯度颜色
  37. Gradient GradientConstruct()
  38. {
  39. 	Gradient g;
  40. 	g.colorsLength = 2;
  41. 	g.colors[0] = float4(1,1,1,0);
  42. 	g.colors[1] = float4(1,1,1,1);
  43. 	g.colors[2] = float4(0,0,0,0);
  44. 	g.colors[3] = float4(0,0,0,0);
  45. 	g.colors[4] = float4(0,0,0,0);
  46. 	g.colors[5] = float4(0,0,0,0);
  47. 	g.colors[6] = float4(0,0,0,0);
  48. 	g.colors[7] = float4(0,0,0,0);
  49. 	return g;
  50. }
  51.  
  52. //渐变采样方法
  53. float3 SampleGradient(Gradient Gradient, float Time)
  54. {
  55.     float3 tempColor = Gradient.colors[0].rgb;
  56.     for (int c = 1; c < Gradient.colorsLength; c++)
  57.     {
  58.         float colorPos = saturate((Time - Gradient.colors[c - 1].w) / (Gradient.colors[c].w - Gradient.colors[c - 1].w)) * step(c, Gradient.colorsLength - 1);
  59.         tempColor = lerp(tempColor, Gradient.colors[c].rgb, colorPos);
  60.     }
  61. #ifdef UNITY_COLORSPACE_GAMMA
  62.     tempColor = LinearToSRGB(tempColor);
  63. #endif
  64. 	return tempColor;
  65. }
  66.  
  67. Varyings vert(Attributes input)
  68. {
  69. 	Varyings output = (Varyings)0;
  70. 	
  71. 	//VertexPositionInputs和VertexNormalInputs两个结构体定义在Core.hlsl中，
  72. 	VertexPositionInputs vertexInput = GetVertexPositionInputs(input.positionOS);  
  73. 	VertexNormalInputs vertexNormalInput = GetVertexNormalInputs(input.normalOS, input.tangentOS);
  74. 	/*
  75. 	这两个方法在ShaderVariablesFunctions文件中，用于获取VertexPositionInputs和VertexNormalInputs，它们包括大部分需求的信息
  76. 	struct VertexPositionInputs
  77. 	{
  78. 		float3 positionWS; // World space position
  79. 		float3 positionVS; // View space position
  80. 		float4 positionCS; // Homogeneous clip space position
  81. 		{
  82. 			input.positionCS.x：通常表示屏幕上的水平位置。其范围通常从0（屏幕的左边缘）到屏幕宽度减1（屏幕的右边缘，以像素为单位）。
  83. 			input.positionCS.y：通常表示屏幕上的垂直位置。其范围通常从0（屏幕的顶部）到屏幕高度减1（屏幕的底部，以像素为单位）。
  84. 			input.positionCS.z：通常表示片段在深度缓冲区中的深度值。其范围通常在0.0到1.0之间，表示从近裁剪平面到远裁剪平面的深度值。
  85. 			input.positionCS.w：通常表示屏幕空间中的透视除法系数。在一般情况下，你不太会直接使用它来进行计算。
  86. 		}
  87. 		float4 positionNDC;// Homogeneous normalized device coordinates
  88. 		{
  89. 			positionNDC.x：通常表示裁剪坐标系中的X坐标，其范围从-1表示裁剪体积的左侧边界，到1表示裁剪体积的右侧边界。
  90. 			positionNDC.y：通常表示裁剪坐标系中的Y坐标，其范围从-1表示裁剪体积的底部边界，到1表示裁剪体积的顶部边界。
  91. 			positionNDC.z：通常表示裁剪坐标系中的Z坐标，其范围从-1表示裁剪体积的近裁剪平面，到1表示裁剪体积的远裁剪平面。
  92. 			positionNDC.w：通常用于执行透视除法，将坐标从裁剪坐标系转换为标准化设备坐标系。它在顶点着色器中通常为非零值，但在片段着色器中可能会变为零，因为透视除法是在顶点着色器中执行的。
  93. 		}
  94. 	};
  95. 	struct VertexNormalInputs
  96. 	{
  97. 		real3 tangentWS;
  98. 		real3 bitangentWS;
  99. 		float3 normalWS;
  100. 	};
  101. 	*/
  102. 	output.uv = TRANSFORM_TEX(input.uv, _BaseMap);
  103. 	/*
  104. 	TRANSFORM_TEX这个宏定义在Macros.hlsl文件中，这个文件中还有还能多定义比如PI:3.1415926、LOG2_E:1.442695
  105. 	#define TRANSFORM_TEX(tex, name) ((tex.xy) * name##_ST.xy + name##_ST.zw) 看起来不过是添加ST控制，不需要的话不做这个操作也可以，比如这里，_BaseMap不过是个白图
  106. 	*/
  107. 	output.positionWSAndFogFactor = float4(vertexInput.positionWS, ComputeFogFactor(vertexInput.positionCS.z));  //  做个组合w分量利用一下，省一点空间
  108. 	output.normalWS = vertexNormalInput.normalWS;
  109. 	
  110. 	output.viewDirectionWS = unity_OrthoParams.w == 0 ? GetCameraPositionWS() - vertexInput.positionWS : GetWorldToViewMatrix()[2].xyz;
  111. 	/*
  112. 	如果不是ortho，直接坐标相减计算视角向量，如果是ortho，GetWorldToViewMatrix返回的是float4x4 UNITY_MATRIX_V，
  113. 	unity_OrthoParams这个量来自StdLib.hlsl文件，这里面也有关于PI的定义，看起来很多量都可以从这里拿
  114. 	float4x4 unity_CameraProjection;
  115. 	float4x4 unity_MatrixVP;
  116. 	float4x4 unity_ObjectToWorld;
  117. 	float4x4 unity_WorldToCamera;
  118. 	float3 _WorldSpaceCameraPos;
  119. 	float4 _ProjectionParams;         // x: 1 (-1 flipped), y: near,     z: far,       w: 1/far
  120. 	float4 unity_ColorSpaceLuminance;
  121. 	float4 unity_DeltaTime;           // x: dt,             y: 1/dt,     z: smoothDt,  w: 1/smoothDt
  122. 	float4 unity_OrthoParams;         // x: width,          y: height,   z: unused,    w: ortho ? 1 : 0
  123. 	float4 _ZBufferParams;            // x: 1-far/near,     y: far/near, z: x/far,     w: y/far   or in case of a reversed depth buffer (UNITY_REVERSED_Z is 1)  x = -1+far/near,  y = 1,  z = x/far,  w = 1/far 这里看来是后者
  124. 	float4 _ScreenParams;             // x: width,          y: height,   z: 1+1/width, w: 1+1/height
  125. 	float4 _Time;                     // x: t/20,           y: t,        z: t*2,       w: t*3
  126. 	float4 _SinTime;                  // x: sin(t/20),      y: sin(t),   z: sin(t*2),  w: sin(t*3)
  127. 	float4 _CosTime;                  // x: cos(t/20),      y: cos(t),   z: cos(t*2),  w: cos(t*3)
  128. 	还有一些方法GradientNoise、LinearEyeDepth。也定义了TRANSFORM_TEX，不止一个地方定义过这个呢
  129. 	*/
  130. 	output.SH = SampleSH(lerp(vertexNormalInput.normalWS, float3(0,0,0), _IndirectLightFlattenNormal));  //  球谐函数，就是传入法线返回unity保存好的漫反射数据中对应位置的颜色，这里加了参数控制，因为卡渲有时不需要太多细节
  131. 	/*
  132. 	half3 SampleSH(half3 normalWS)
  133. {
  134.     // LPPV is not supported in Ligthweight Pipeline
  135.     real4 SHCoefficients[7];
  136.     SHCoefficients[0] = unity_SHAr;
  137.     SHCoefficients[1] = unity_SHAg;
  138.     SHCoefficients[2] = unity_SHAb;
  139.     SHCoefficients[3] = unity_SHBr;
  140.     SHCoefficients[4] = unity_SHBg;
  141.     SHCoefficients[5] = unity_SHBb;
  142.     SHCoefficients[6] = unity_SHC;
  143.  
  144.     return max(half3(0, 0, 0), SampleSH9(SHCoefficients, normalWS));
  145. }
  146. 	*/
  147.  
  148. 	output.positionCS = vertexInput.positionCS;
  149.  
  150. 	return output;
  151. }
  152.  
  153. float4 frag(Varyings input, bool isFrontFace : SV_IsFrontFace): SV_TARGET
  154. {
  155. 	float3 positionWS = input.positionWSAndFogFactor.xyz;
  156. 	float4 shadowCoord = TransformWorldToShadowCoord(positionWS);
  157. 	Light mainLight = GetMainLight(shadowCoord);
  158.  
  159. 	float3 lightDirectionWS = normalize(mainLight.direction);
  160. 	float3 normalWS = normalize(input.normalWS);
  161. 	float3 viewDirectionWS = normalize(input.viewDirectionWS);
  162.  
  163. 	float3 baseColor = tex2D(_BaseMap, input.uv);  //  baseColor是纯白画布
  164. 	float4 areaMap = 0;
  165. 	#if _AREA_FACE
  166. 		areaMap = tex2D(_FaceColorMap, input.uv);
  167. 	#elif _AREA_HAIR
  168. 		areaMap = tex2D(_HairColorMap, input.uv);
  169. 	#elif _AREA_UPPERBODY
  170. 		areaMap = tex2D(_UpperBodyColorMap, input.uv);
  171. 	#elif _AREA_LOWERBODY
  172. 		areaMap = tex2D(_LowerBodyColorMap, input.uv);
  173. 	#endif
  174. 	baseColor = areaMap.rgb;
  175. 	//baseColor *= lerp((1,1,1), (1,1,1), 0.5);
  176. 	baseColor *= lerp(_BackFaceTintColor, _FrontFaceTintColor, isFrontFace);
  177.  
  178. 	float4 lightMap = 0;
  179. 	#if _AREA_HAIR || _AREA_UPPERBODY || _AREA_LOWERBODY
  180. 	{
  181. 		#if _AREA_HAIR
  182. 			lightMap = tex2D(_HairLightMap, input.uv);
  183. 		#elif _AREA_UPPERBODY
  184. 			lightMap = tex2D(_UpperBodyLightMap, input.uv);
  185. 		#elif _AREA_LOWERBODY
  186. 			lightMap = tex2D(_LowerBodyLightMap, input.uv);
  187. 		#endif
  188. 	}
  189. 	#endif
  190. 	float4 faceMap = 0;
  191. 	#if _AREA_FACE
  192. 		faceMap = tex2D(_FaceMap, input.uv);
  193. 	#endif
  194.  
  195. 	//-----------------------------------------------------------------------------------------------------------------
  196. 	//间接光
  197. 	float3 indirectLightColor = input.SH.rgb * _IndirectLightUsage;
  198. 	//  添加光照图细节
  199. 	#if _AREA_HAIR || _AREA_UPPERBODY || _AREA_LOWERBODY
  200. 		indirectLightColor *= lerp(1, lightMap.r, _IndirectLightOcclusionUsage);
  201. 	#elif _AREA_FACE
  202. 		indirectLightColor *= lerp(1, lerp(faceMap.g, 1, step(faceMap.r, 0.01)), _IndirectLightOcclusionUsage);
  203. 	/*
  204. 	注意，step是后面值小于前面值，返回0，反之返回1，别想反了
  205. 	step(faceMap.r, 0.01)分出来是否受距离影响的区域 根据图片，不受距离影响的区域即r通道有值的部分：为嘴巴，眼睛，眉毛等。值为0，反之受影响的为1
  206. 	即lerp(faceMap.g, 1, step(faceMap.r, 0.01))不受距离影响地方r通道有值的部分：用的是faceMap.g的值，受距离影响的r通道没有值的部分是1，也就是正常漫反射光
  207. 	但是g通道有一部分本身即是1，那么根据rg通道的差异，得出的r通道覆盖的区域减去g通道覆盖的区域，也就是只有口部分是0其他部分全为1，这里做这么多只是为了筛选出口部分
  208. 	*/
  209. 	#endif
  210. 	indirectLightColor *= lerp(1, baseColor, _IndirectLightMixBaseColor);
  211. 	//-----------------------------------------------------------------------------------------------------------------
  212. 	//主光
  213. 	float mainLightShadow = 1;
  214. 	float3 mainLightColor = lerp(desaturation(mainLight.color), mainLight.color, _MainLightColorUsage);  //  这里做了降饱和插值提升效果，不然直接=mainLight.color;就行
  215. 	#if _AREA_HAIR || _AREA_UPPERBODY || _AREA_LOWERBODY
  216. 	{
  217. 		float NoL = dot(normalWS, lightDirectionWS);  //  计算法相和主光向量的dot  [-1, 1]
  218. 		float remapNoL = NoL * 0.5 + 0.5; // [0, 1]
  219. 		mainLightShadow = smoothstep(1 - lightMap.g + _ShadowThresholdCenter - _ShadowThresholdSoftness, 1 - lightMap.g + _ShadowThresholdCenter + _ShadowThresholdSoftness, remapNoL);  //  二值化朗伯特
  220. 		//  在光照图的g通道，有很多衣服上阴影的细节，接下来添加上去
  221. 		mainLightShadow *= lightMap.r;
  222. 		//  光照图的r通道，用于标识一些点不亮的也就是所谓的AO区域，直接乘上去，头发上的蝴蝶结就是点不亮的标识区域
  223. 	}
  224. 	#elif _AREA_FACE
  225. 	{
  226. 		float3 headForward = normalize(_HeadForward);
  227. 		float3 headRight = normalize(_HeadRight);
  228. 		float3 headUp = cross(headForward, headRight);
  229.  
  230. 		float3 fixedLightDirectionWS = normalize(lightDirectionWS - dot(lightDirectionWS, headUp) * headUp);  //  看起来是投影，把主光源的光照方向投影在垂直于headUp的平面上
  231. 		/*
  232. 		投影到垂直于headUp的平面上，ws-up*(|ws.y|/|up|)
  233. 		因为ws为单位向量，所以|ws.y| = cosθ、|up| = 1
  234. 		所以简化为ws-up*cosθ。而cosθ=  dot(lightDirectionWS, headUp)
  235. 		故求出投影到垂直于headUp的平面上的向量
  236. 		*/  
  237. 		float2 sdfUV = float2(sign(dot(fixedLightDirectionWS, headRight)), 1) * float2(-1, 1) * input.uv;  //  判断光照在左脸(负)还是右脸(正)  float2(-1, 1)是因为sdf图应该左白右黑，所以反向
  238. 		/*
  239. 		float2(sign(dot(fixedLightDirectionWS, headRight)), 1)如果光照方向是右半就是float2(1,1)，反之float2(-1,1)。只需要处理x是1还是-1，因为按照脸部中心对称
  240. 		但是这张图是左右反过来的，所以我们再反一次* float2(-1, 1)，最后* input.uv。算出脸部修正uv
  241. 		但是在光和headRight夹角为90时，也就是光从正后方打来时，看cos曲线为0，由于sign的特性(-1,0,1)，也就是说sdfUV的x永远为0
  242. 		*/
  243. 		float sdfValue = tex2D(_FaceMap, sdfUV).a;  //  如果是光和headRight夹角为90时，看那张图的a通道，采样的都是最左边白色，都是1，所以即使阈值是1也没办法奈何他
  244. 		//  然后用这个脸部修正uv采样sdf图获取sdf值
  245.  
  246. 		float sdfThreshold = 1 - (dot(fixedLightDirectionWS, headForward) * 0.5 + 0.5);  //主光越接近正面，阈值越接近0，阈值越低表示越容易被点亮 [0,1]
  247. 		sdfThreshold += _FaceShadowOffset;  //  所以为了限制光和headRight夹角为90时sdfUV的x永远为0，采样的都是最左边白色，都是1的情况，把阈值做个小小的偏移，加上一点点0.01就好，只要超过1就行
  248. 		float sdf = smoothstep(sdfThreshold - _FaceShadowTransitionSoftness, sdfThreshold + _FaceShadowTransitionSoftness, sdfValue);
  249. 		mainLightShadow = lerp(faceMap.g, sdf, step(faceMap.r, 0.01));  //  sdf不应该影响ao区域，
  250. 	}
  251. 	#endif
  252. 	//-----------------------------------------------------------------------------------------------------------------
  253. 	//Ramp
  254. 	//计算uv
  255. 	float2 rampUV;
  256.  
  257. 	int rampRowIndex = 0;
  258. 	int rampRowNum = 1;
  259. 	#if _AREA_HAIR
  260. 	{
  261. 		rampRowIndex = 0;
  262. 		rampRowNum = 1;
  263. 	}
  264. 	#elif _AREA_UPPERBODY || _AREA_LOWERBODY
  265. 	{
  266. 		int rawIndex = (round((lightMap.a + 0.0425)/0.0625) - 1)/2; 
  267. 		rampRowIndex = lerp(rawIndex, rawIndex + 4 < 8 ? rawIndex + 4 : rawIndex + 4 - 8, fmod(rawIndex, 2));
  268. 		rampRowNum = 8;
  269. 	}
  270. 	#elif _AREA_FACE
  271. 	{
  272. 		rampRowIndex = 0;
  273. 		rampRowNum = 8;
  274. 	}
  275. 	#endif
  276. 	//  使用预规定的方式计算行数，用于计算采样uv的y坐标，x坐标使用阴影值
  277. 	float rampUVy = (2 * rampRowIndex + 1) * (1.0 / (rampRowNum * 2));
  278. 	float rampUVx =  mainLightShadow * (1 - _ShadowRampOffset) + _ShadowRampOffset;  //  做个映射，[0.75,1]这张图在0.85左右往后就是白色，我感觉不映射直接用mainLightShadow效果差异也不大
  279. 	rampUV = float2(rampUVx, rampUVy);
  280. 	//采样
  281. 	float3 rampColor;
  282.  
  283. 	float3 coolRamp = 1;
  284. 	float3 warmRamp = 1;
  285. 	#if _AREA_HAIR
  286. 	{
  287. 		coolRamp = tex2D(_HairCoolRamp, rampUV).rgb;
  288. 		warmRamp = tex2D(_HairWarmRamp, rampUV).rgb;
  289. 	}
  290. 	#elif _AREA_FACE || _AREA_UPPERBODY || _AREA_LOWERBODY
  291. 	{
  292. 		coolRamp = tex2D(_BodyCoolRamp, rampUV).rgb;
  293. 		warmRamp = tex2D(_BodyWarmRamp, rampUV).rgb;
  294. 	}
  295. 	#endif
  296. 	//根据白天夜晚插值冷暖色
  297. 	float isDay = lightDirectionWS.y * 0.5 + 0.5;
  298. 	rampColor = lerp(coolRamp, warmRamp, 1);
  299. 	//-----------------------------------------------------------------------------------------------------------------
  300. 	//修补主光源
  301. 	float3 fixedMainLightColor = mainLightColor * baseColor * rampColor;
  302. 	//-----------------------------------------------------------------------------------------------------------------
  303. 	//高光
  304. 	float3 specularColor = 0;
  305. 	#if _AREA_HAIR || _AREA_UPPERBODY || _AREA_LOWERBODY
  306. 	{
  307. 		//布林冯，但是直接这样看起来太光滑
  308. 		float3 halfVectorWS = normalize(viewDirectionWS + lightDirectionWS);
  309. 		float NoH = dot(normalWS, halfVectorWS);
  310. 		float blinnPhong = pow(saturate(NoH), _SpecularExpon);
  311. 		//用光照图的蓝色通道作为阈值，超过阈值才会产生高光  这里金属和非金属分别处理
  312. 		//非金属 反射率Ks，固定0.04
  313. 		float nonMetalSpecular = step(1.0 - blinnPhong, lightMap.b) * _SpecularKsNonMetal;
  314. 		//金属 反射率都比较大且差异较大，蓝色通道控制各个金属部分差异
  315. 		float metalSpecular = blinnPhong * lightMap.b * _SpecularKsMetal;
  316. 		//得有一个lerp控制什么时候是金属什么时候是非金属，在光照图的阿尔法通道，0.52灰度值表示金属
  317. 		//找出金属部分，metallic越接近于0就越靠近金属
  318. 		float metallic = 0;
  319. 		#if _AREA_UPPERBODY || _AREA_LOWERBODY
  320. 		{
  321. 			metallic = saturate( (1 - 10 * abs(lightMap.a - 0.52)) );  //  金属影响系数，暂定10
  322. 		}
  323. 		#endif
  324. 		specularColor = lerp(nonMetalSpecular, metalSpecular * baseColor, metallic);
  325. 		specularColor *= mainLight.color;
  326. 		specularColor *= _SpecularBrightness;
  327. 	}
  328. 	#endif
  329. 	//-----------------------------------------------------------------------------------------------------------------
  330. 	//黑丝
  331. 	float3 stockingsEffect = 1;
  332. 	#if _AREA_UPPERBODY || _AREA_LOWERBODY
  333. 	{
  334. 		//红通道是遮罩，绿通道是丝的透光度，蓝通道是丝的细节,uv放大一定倍数采样可以提升细节量
  335. 		//采样
  336. 		float2 stockingsMapRG = 0;
  337. 		float stockingsMapB = 0;
  338. 		#if _AREA_UPPERBODY
  339. 		{
  340. 			stockingsMapRG = tex2D(_UpperBodyStockings, input.uv).rg;
  341. 			stockingsMapB = tex2D(_UpperBodyStockings, input.uv * 20).b;
  342. 		}
  343. 		#elif _AREA_LOWERBODY
  344. 		{
  345. 			stockingsMapRG = tex2D(_LowerBodyStockings, input.uv).rg;
  346. 			stockingsMapB = tex2D(_LowerBodyStockings, input.uv * 20).b;
  347. 		}
  348. 		#endif
  349.  
  350. 		//混入细节
  351. 		float NoV = dot(normalWS, viewDirectionWS);
  352. 		//都不过是为了加控制
  353. 		float fac = pow(saturate(NoV), _StockingsTransitionPower);;
  354. 		fac = saturate( (fac - _StockingsTransitionHardness/2) / (1 - _StockingsTransitionHardness) );
  355. 		fac = fac * (stockingsMapB * _StockingsTextureUsage + (1 - _StockingsTextureUsage));
  356. 		fac = lerp(fac, 1, stockingsMapRG.g);
  357. 		//构造颜色曲线
  358. 		Gradient curve = GradientConstruct();
  359. 		curve.colorsLength = 3;
  360. 		curve.colors[0] = float4(_StockingsDarkColor, 0);
  361. 		curve.colors[1] = float4(_StockingsTransitionColor, _StockingsTransitionThreshold);
  362. 		curve.colors[2] = float4(_StockingsLightColor, 1);
  363. 		//采样渐变
  364. 		float3 stockingsColor = SampleGradient(curve, fac);
  365. 		//加遮罩
  366. 		stockingsEffect = lerp(1, stockingsColor, stockingsMapRG.r);
  367. 	}
  368. 	#endif
  369. 	//-----------------------------------------------------------------------------------------------------------------
  370. 	//鼻尖的描边
  371.     float fakeOutlineEffect = 0;
  372.     float3 fakeOutlineColor = 0;
  373.     #if _AREA_FACE && _OUTLINE_ON
  374.     {
  375.         float4 faceMap = tex2D(_FaceMap, input.uv);
  376.         float fakeOutline = faceMap.b;
  377.         float3 headForward = normalize(_HeadForward);
  378.         fakeOutlineEffect = smoothstep(0.0, 0.25, pow(saturate(dot(headForward, viewDirectionWS)), 20) * fakeOutline);
  379.  
  380.         float2 outlineUV = float2(0, 0.0625);
  381.         float3 coolRamp = tex2D(_BodyCoolRamp, outlineUV).rgb;
  382.         float3 warmRamp = tex2D(_BodyWarmRamp, outlineUV).rgb;
  383.         float3 ramp = lerp(coolRamp, warmRamp, 0.5);
  384.         fakeOutlineColor = pow(ramp, _OutlineGamma);
  385.     }
  386.     #endif
  387. 	//-----------------------------------------------------------------------------------------------------------------
  388. 	//边缘光  打开URP深度图
  389. 	float linearEyeDepth = LinearEyeDepth(input.positionCS.z, _ZBufferParams) / 10;  //  离相机越近就越黑  正确
  390. 	float3 normalVS = mul((float3x3)UNITY_MATRIX_V, normalWS);  //  正确
  391. 	float2 uvOffset = float2(sign(normalVS.x), 0) * _RimLightWidth / (1 + linearEyeDepth);  //  正确
  392. 	int2 loadTexPos = input.positionCS.xy + uvOffset * _ScaledScreenParams.xy;  //  正确
  393. 	float offsetSceneDepth = LoadSceneDepth(loadTexPos) * 5;
  394. 	float offsetLinearEyeDepth = LinearEyeDepth(offsetSceneDepth, _ZBufferParams);
  395. 	float rimLight = saturate(offsetLinearEyeDepth - (linearEyeDepth + _RimLightThreshold)) / _RimLightFadeout;
  396. 	//这里模型的深度图因材质问题搞不定，放置了，之后再说吧
  397. 	//-----------------------------------------------------------------------------------------------------------------
  398. 	float3 albedo = 0;
  399. 	albedo += indirectLightColor;
  400. 	albedo += fixedMainLightColor;
  401. 	albedo += specularColor;
  402. 	albedo *= stockingsEffect;
  403. 	albedo = lerp(albedo, fakeOutlineColor, fakeOutlineEffect);
  404.  
  405. 	float alpha = _Alpha;
  406.  
  407. 	//albedo = viewDirectionWS.rgb;
  408. 	float4 finalColor = float4(albedo, alpha);
  409. 	return finalColor;
  410. }
  411. #endif

 SendVectorToShader脚本

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using Unity.Mathematics;
  5. using Unity.VisualScripting;
  6. using UnityEngine;
  7.  
  8. public class SendVectorToShader : MonoBehaviour
  9. {
  10.     public Transform HeadBoneTransform;
  11.     public Transform HeadForwardTransform;
  12.     public Transform HeadRightTransform;
  13.  
  14.     private Renderer[] allRenderers;
  15.  
  16.     private int HeadForwardID = Shader.PropertyToID("_HeadForward");
  17.     private int HeadRightID = Shader.PropertyToID("_HeadRight");
  18.  
  19. #if UNITY_EDITOR
  20.     private void OnValidate()
  21.     {
  22.         LateUpdate();
  23.     }
  24. #endif
  25.     private void LateUpdate()
  26.     {
  27.         if(allRenderers == null)
  28.         {
  29.             allRenderers = GetComponentsInChildren<Renderer>(true);
  30.         }
  31.         Renderer tempRenderer;
  32.         for (int i = 0; i < allRenderers.Count(); i++)
  33.         {
  34.             tempRenderer = allRenderers[i];
  35.             foreach(Material tempMaterial in tempRenderer.sharedMaterials)
  36.             {
  37.                 if (tempMaterial.shader)
  38.                 {
  39.                     if(tempMaterial.shader.name == "Unlit/SRUniversal")
  40.                     {
  41.                         tempMaterial.SetVector(HeadForwardID, HeadForwardTransform.position - HeadBoneTransform.position);
  42.                         tempMaterial.SetVector(HeadRightID, HeadRightTransform.position - HeadBoneTransform.position);
  43.                     }
  44.  
  45.                 }
  46.             }
  47.         }
  48.     }
  49. }

cg/hlsl语法链接：

Unity URP CG/HLSL精简规范总结_凯尔315的博客-CSDN博客

unitypackage资源链接：
https://download.csdn.net/download/qq_55895529/88370041?spm=1001.2014.3001.5503

原作视频链接：

【Unity/虚幻5/Blender】3种引擎 崩坏: 星穹铁道风格 卡通渲染 从球谐光照到眉毛透过刘海 完整流程_哔哩哔哩_bilibili

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/喵喵爱编程/article/detail/907497?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号