Unity开发者联盟收藏本站
发帖教程新人必读切换到宽版

 找回密码
 立即注册
Unity开发者联盟»论坛 › 3D Answers 技术讨论 › 技术讨论 Technology Answers › 《Unity Shader 入门精要》从Bulit-in 到URP （HLSL）Ch ...
返回列表 发新帖
查看: 244|回复: 0

《Unity Shader 入门精要》从Bulit-in 到URP （HLSL）Chapter14.1-卡通风格的衬着

[复制链接]
发表于 2024-7-15 18:17 | 显示全部楼层 |阅读模式
前言：
已经进入“高级篇”啦，但愿大师多多撑持，多多存眷，这将对我发生非常愉悦的正反馈~

“《Unity Shader 入门精要》从Bulit-in 到URP”是一个辅佐Unity Shader学习者以冯乐乐女神《Unity Shader 入门精要》为基础学习用HLSL语言编写URP着色器的案例教学系列。

作者自学能力有限，抛砖引玉，如有建议和问题请各位大佬和同仁交流斧正。
Bulit-in版：
  1. // Upgrade NOTE: replaced '_Object2World' with 'unity_ObjectToWorld'
  2. // Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'
  4. Shader ”Unity Shaders Book/Chapter 14/Toon Shading” {
  5.         Properties {
  6.                 _Color (”Color Tint”, Color) = (1, 1, 1, 1)
  7.                 _MainTex (”Main Tex”, 2D) = ”white” {}
  8.                 _Ramp (”Ramp Texture”, 2D) = ”white” {}
  9.                 _Outline (”Outline”, Range(0, 1)) = 0.1
  10.                 _OutlineColor (”Outline Color”, Color) = (0, 0, 0, 1)
  11.                 _Specular (”Specular”, Color) = (1, 1, 1, 1)
  12.                 _SpecularScale (”Specular Scale”, Range(0, 0.1)) = 0.01
  13.         }
  14.     SubShader {
  15.                 Tags { ”RenderType”=”Opaque” ”Queue”=”Geometry”}
  16.                
  17.                 Pass {
  18.                         NAME ”OUTLINE”
  19.                        
  20.                         Cull Front
  21.                        
  22.                         CGPROGRAM
  23.                        
  24.                         #pragma vertex vert
  25.                         #pragma fragment frag
  26.                        
  27.                         #include ”UnityCG.cginc”
  28.                        
  29.                         float _Outline;
  30.                         fixed4 _OutlineColor;
  31.                        
  32.                         struct a2v {
  33.                                 float4 vertex : POSITION;
  34.                                 float3 normal : NORMAL;
  35.                         };
  36.                        
  37.                         struct v2f {
  38.                             float4 pos : SV_POSITION;
  39.                         };
  40.                        
  41.                         v2f vert (a2v v) {
  42.                                 v2f o;
  43.                                
  44.                                 float4 pos = mul(UNITY_MATRIX_MV, v.vertex);
  45.                                 float3 normal = mul((float3x3)UNITY_MATRIX_IT_MV, v.normal);  
  46.                                 normal.z = -0.5;
  47.                                 pos = pos + float4(normalize(normal), 0) * _Outline;
  48.                                 o.pos = mul(UNITY_MATRIX_P, pos);
  49.                                
  50.                                 return o;
  51.                         }
  52.                        
  53.                         float4 frag(v2f i) : SV_Target {
  54.                                 return float4(_OutlineColor.rgb, 1);               
  55.                         }
  56.                        
  57.                         ENDCG
  58.                 }
  59.                
  60.                 Pass {
  61.                         Tags { ”LightMode”=”ForwardBase” }
  62.                        
  63.                         Cull Back
  64.                
  65.                         CGPROGRAM
  66.                
  67.                         #pragma vertex vert
  68.                         #pragma fragment frag
  69.                        
  70.                         #pragma multi_compile_fwdbase
  71.                
  72.                         #include ”UnityCG.cginc”
  73.                         #include ”Lighting.cginc”
  74.                         #include ”AutoLight.cginc”
  75.                         #include ”UnityShaderVariables.cginc”
  76.                        
  77.                         fixed4 _Color;
  78.                         sampler2D _MainTex;
  79.                         float4 _MainTex_ST;
  80.                         sampler2D _Ramp;
  81.                         fixed4 _Specular;
  82.                         fixed _SpecularScale;
  83.                
  84.                         struct a2v {
  85.                                 float4 vertex : POSITION;
  86.                                 float3 normal : NORMAL;
  87.                                 float4 texcoord : TEXCOORD0;
  88.                                 float4 tangent : TANGENT;
  89.                         };
  90.                
  91.                         struct v2f {
  92.                                 float4 pos : POSITION;
  93.                                 float2 uv : TEXCOORD0;
  94.                                 float3 worldNormal : TEXCOORD1;
  95.                                 float3 worldPos : TEXCOORD2;
  96.                                 SHADOW_COORDS(3)
  97.                         };
  98.                        
  99.                         v2f vert (a2v v) {
  100.                                 v2f o;
  101.                                
  102.                                 o.pos = UnityObjectToClipPos( v.vertex);
  103.                                 o.uv = TRANSFORM_TEX (v.texcoord, _MainTex);
  104.                                 o.worldNormal  = UnityObjectToWorldNormal(v.normal);
  105.                                 o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
  106.                                
  107.                                 TRANSFER_SHADOW(o);
  108.                                
  109.                                 return o;
  110.                         }
  111.                        
  112.                         float4 frag(v2f i) : SV_Target {
  113.                                 fixed3 worldNormal = normalize(i.worldNormal);
  114.                                 fixed3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos));
  115.                                 fixed3 worldViewDir = normalize(UnityWorldSpaceViewDir(i.worldPos));
  116.                                 fixed3 worldHalfDir = normalize(worldLightDir + worldViewDir);
  117.                                
  118.                                 fixed4 c = tex2D (_MainTex, i.uv);
  119.                                 fixed3 albedo = c.rgb * _Color.rgb;
  120.                                
  121.                                 fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;
  122.                                
  123.                                 UNITY_LIGHT_ATTENUATION(atten, i, i.worldPos);
  124.                                
  125.                                 fixed diff =  dot(worldNormal, worldLightDir);
  126.                                 diff = (diff * 0.5 + 0.5) * atten;
  127.                                
  128.                                 fixed3 diffuse = _LightColor0.rgb * albedo * tex2D(_Ramp, float2(diff, diff)).rgb;
  129.                                
  130.                                 fixed spec = dot(worldNormal, worldHalfDir);
  131.                                 fixed w = fwidth(spec) * 2.0;
  132.                                 fixed3 specular = _Specular.rgb * lerp(0, 1, smoothstep(-w, w, spec + _SpecularScale - 1)) * step(0.0001, _SpecularScale);
  133.                                
  134.                                 return fixed4(ambient + diffuse + specular, 1.0);
  135.                         }
  136.                
  137.                         ENDCG
  138.                 }
  139.         }
  140.         FallBack ”Diffuse”
  141. }
复制代码
URP版：

Unity项目源码：
  1. Shader ”Unlit/Chapter14-ToonShading”
  2. {
  3.     Properties {
  4.                 _Color (”Color Tint”, Color) = (1, 1, 1, 1)
  5.                 _MainTex (”Main Tex”, 2D) = ”white” {}
  6.                 _Ramp (”Ramp Texture”, 2D) = ”white” {}
  7.                 _Outline (”Outline”, Range(0, 1)) = 0.1
  8.                 _OutlineColor (”Outline Color”, Color) = (0, 0, 0, 1)
  9.                 _Specular (”Specular”, Color) = (1, 1, 1, 1)
  10.                 _SpecularScale (”Specular Scale”, Range(0, 0.1)) = 0.01
  11.         }
  12.     SubShader
  13.     {
  14.         Tags {”RenderPipeline” = ”UniversalPipeline” ”RenderType”=”Opaque” ”Queue”=”Geometry”}
  16.         HLSLINCLUDE
  17.         #include ”Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl”
  18.                 #include ”Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl”
  20.         CBUFFER_START(UnityPerMaterial)
  21.             float _Outline;
  22.                         half4 _OutlineColor;
  23.             half4 _Color;
  24.                         float4 _MainTex_ST;
  25.                         half4 _Specular;
  26.                         half _SpecularScale;
  27.         CBUFFER_END
  29.         ENDHLSL
  31.         UsePass ”Universal Render Pipeline/Lit/ShadowCaster”
  32.                
  33.                 Pass {
  34.                         NAME ”OUTLINE”
  35.                        
  36.                         Cull Front
  37.                        
  38.                         HLSLPROGRAM
  39.                        
  40.                         #pragma vertex vert
  41.                         #pragma fragment frag
  42.                        
  43.                         struct a2v {
  44.                                 float4 vertex : POSITION;
  45.                                 float3 normal : NORMAL;
  46.                         };
  47.                        
  48.                         struct v2f {
  49.                             float4 pos : SV_POSITION;
  50.                         };
  51.                        
  52.                         v2f vert (a2v v) {
  53.                                 v2f o;
  54.                                
  55.                                 float4 pos = mul(UNITY_MATRIX_MV, v.vertex);
  56.                                 float3 normal = mul((float3x3)UNITY_MATRIX_IT_MV, v.normal);  
  57.                 //把顶点法线转换到view空间
  58.                                 normal.z = -0.5;
  59.                                 pos = pos + float4(normalize(normal), 0) * _Outline;
  60.                 //在view空间完成顶点扩张
  61.                                 o.pos = mul(UNITY_MATRIX_P, pos);
  62.                                
  63.                                 return o;
  64.                         }
  65.                        
  66.                         float4 frag(v2f i) : SV_Target {
  67.                                 return float4(_OutlineColor.rgb, 1);               
  68.                         }
  69.                        
  70.                         ENDHLSL
  71.                 }
  72.                
  73.                 Pass {
  74.                         Tags { ”LightMode”=”UniversalForward” }
  75.                        
  76.                         Cull Back
  77.                
  78.                         HLSLPROGRAM
  79.                
  80.                         #pragma vertex vert
  81.                         #pragma fragment frag
  83.             TEXTURE2D(_MainTex);       SAMPLER(sampler_MainTex);
  84.             TEXTURE2D(_Ramp);       SAMPLER(sampler_Ramp);
  85.                
  86.                         struct a2v {
  87.                                 float4 vertex : POSITION;
  88.                                 float3 normal : NORMAL;
  89.                                 float4 texcoord : TEXCOORD0;
  90.                                 //float4 tangent : TANGENT;
  91.                         };
  92.                
  93.                         struct v2f {
  94.                                 float4 pos : POSITION;
  95.                                 float2 uv : TEXCOORD0;
  96.                                 float3 worldNormal : TEXCOORD1;
  97.                                 float3 worldPos : TEXCOORD2;
  98.                         };
  99.                        
  100.                         v2f vert (a2v v) {
  101.                                 v2f o;
  102.                                
  103.                 VertexPositionInputs positionInputs = GetVertexPositionInputs(v.vertex.xyz);
  104.                                 //o.pos = TransformObjectToHClip( v.vertex);
  105.                 o.pos = positionInputs.positionCS;
  106.                                 o.uv = TRANSFORM_TEX (v.texcoord, _MainTex);
  107.                                 o.worldNormal  = TransformObjectToWorldNormal(v.normal);
  108.                                 //o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
  109.                                 o.worldPos = positionInputs.positionWS;
  110.                                
  111.                                 return o;
  112.                         }
  113.                        
  114.                         float4 frag(v2f i) : SV_Target {
  115.                                 Light mainLight = GetMainLight();
  116.                                 //获取光源信息的函数
  117.                 half3 worldLightDir = normalize(TransformObjectToWorldDir(mainLight.direction));
  118.                 //half3 worldNormal = normalize(i.worldNormal);
  119.                                 //half3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos));
  120.                                 half3 worldViewDir = normalize(_WorldSpaceCameraPos.xyz - i.worldPos);
  121.                                 half3 worldHalfDir = normalize(worldLightDir + worldViewDir);
  122.                                
  123.                                 half4 c = SAMPLE_TEXTURE2D (_MainTex, sampler_MainTex, i.uv);
  124.                                 half3 albedo = c.rgb * _Color.rgb;
  125.                                
  126.                                 half3 ambient = half3(unity_SHAr.w, unity_SHAg.w, unity_SHAb.w) * albedo;
  127.                 half atten = mainLight.distanceAttenuation;
  128.                                
  129.                                 //UNITY_LIGHT_ATTENUATION(atten, i, i.worldPos);
  130.                                
  131.                                 half diff =  dot(i.worldNormal, worldLightDir);
  132.                                 diff = (diff * 0.5 + 0.5) * atten;
  133.                                
  134.                                 half3 diffuse = mainLight.color * albedo * SAMPLE_TEXTURE2D(_Ramp, sampler_Ramp, float2(diff, diff)).rgb;
  135.                                
  136.                                 half spec = dot(i.worldNormal, worldHalfDir);
  137.                                 half w = fwidth(spec) * 2.0;
  138.                 //此函数计算以下内容： abs (ddx (x) ) + abs (ddy (x) ),即相邻像素点该数值的变化度 。
  139.                                 half3 specular = mainLight.color * _Specular.rgb * lerp(0, 1, smoothstep(-w, w, spec + _SpecularScale - 1)) * step(0.0001, _SpecularScale);
  140.                                
  141.                                 return half4(ambient + diffuse + specular, 1.0);
  142.                         }
  143.                
  144.                         ENDHLSL
  145.                 }
  146.         }
  147.         FallBack ”Packages/com.unity.render-pipelines.universal/FallbackError”
  148. }
复制代码
效果图：




如有收获，请留下“存眷”和“附和”

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

×
回复

使用道具 举报

返回列表 发新帖
懒得打字嘛，点击右侧快捷回复 【右侧内容，后台自定义】
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Unity开发者联盟 ( 粤ICP备20003399号 )

GMT+8, 2024-11-23 16:05 , Processed in 0.102563 second(s), 28 queries .

Powered by Discuz! X3.5 Licensed

© 2001-2024 Discuz! Team.

快速回复 返回顶部 返回列表