シェーダーの書き方をさわりだけやってみる
課題は1つだけ
UVスクロール
hlsl1Shader "Custom/UvScroll" 2{ 3 Properties 4 { 5 [MainColor] _BaseColor("Base Color", Color) = (1, 1, 1, 1) 6 [MainTexture] _BaseMap("Base Map", 2D) = "white" {} 7 _ScrollSpeed("Scroll Speed", Vector) = (0.1, 0, 0, 0) 8 } 9 10 SubShader 11 { 12 Tags {"RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline" } 13 14 Pass 15 { 16 HLSLPROGRAM 17 18 #pragma vertex vert 19 #pragma fragment frag 20 21 #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" 22 23 struct Attributes 24 { 25 float4 positionOS : POSITION; 26 float2 uv : TEXCOORD0; 27 }; 28 29 struct Varyings 30 { 31 float4 positionHCS : SV_POSITION; 32 float2 uv : TEXCOORD0; 33 }; 34 35 TEXTURE2D(_BaseMap); 36 SAMPLER(sampler_BaseMap); 37 38 CBUFFER_START(UnityPerMaterial) 39 half4 _BaseColor; 40 float4 _BaseMap_ST; 41 float2 _ScrollSpeed; 42 CBUFFER_END 43 44 Varyings vert(Attributes IN) 45 { 46 Varyings OUT; 47 OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz); 48 OUT.uv = TRANSFORM_TEX(IN.uv, _BaseMap); 49 return OUT; 50 } 51 52 half4 frag(Varyings IN) : SV_Target 53 { 54 float2 scrolledUv = IN.uv + _Time.y * _ScrollSpeed; 55 half4 color = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, scrolledUv) * _BaseColor; 56 return color; 57 } 58 ENDHLSL 59 } 60 } 61}
テクスチャブレンド
hlsl1Shader "Custom/TextureBlend" 2{ 3 Properties 4 { 5 [MainColor] _BaseColor("Base Color", Color) = (1, 1, 1, 1) 6 [MainTexture] _BaseMap("Base Map", 2D) = "white" {} 7 _BlendTexture("Blend Texture", 2D) = "white" {} 8 _BlendValue("Blend Value", Range(0, 1)) = 1 9 } 10 11 SubShader 12 { 13 Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline" } 14 15 Pass 16 { 17 HLSLPROGRAM 18 19 #pragma vertex vert 20 #pragma fragment frag 21 22 #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" 23 24 struct Attributes 25 { 26 float4 positionOS : POSITION; 27 float2 uv : TEXCOORD0; 28 }; 29 30 struct Varyings 31 { 32 float4 positionHCS : SV_POSITION; 33 float2 uv : TEXCOORD0; 34 float2 uvBlend : TEXCOORD1; 35 }; 36 37 TEXTURE2D(_BaseMap); 38 SAMPLER(sampler_BaseMap); 39 TEXTURE2D(_BlendTexture); 40 SAMPLER(sampler_BlendTexture); 41 42 43 CBUFFER_START(UnityPerMaterial) 44 half4 _BaseColor; 45 float4 _BaseMap_ST; 46 float4 _BlendTexture_ST; 47 float _BlendValue; 48 CBUFFER_END 49 50 Varyings vert(Attributes IN) 51 { 52 Varyings OUT; 53 OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz); 54 OUT.uv = TRANSFORM_TEX(IN.uv, _BaseMap); 55 OUT.uvBlend = TRANSFORM_TEX(IN.uv, _BlendTexture); 56 return OUT; 57 } 58 59 half4 frag(Varyings IN) : SV_Target 60 { 61 half4 baseColor = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, IN.uv); 62 half4 blendColor = SAMPLE_TEXTURE2D(_BlendTexture, sampler_BlendTexture, IN.uv); 63 half4 color = lerp(baseColor, blendColor, _BlendValue); 64 return color * _BaseColor; 65 } 66 ENDHLSL 67 } 68 } 69}
ディゾルブ
hlsl1Shader "Custom/Dissolve" 2{ 3 Properties 4 { 5 [MainColor] _BaseColor("Base Color", Color) = (1, 1, 1, 1) 6 [MainTexture] _BaseMap("Base Map", 2D) = "white" {} 7 _DissolveAmount("Dissolve Amount", Range(0, 1)) = 0 8 _EdgeWidth("Edge Width", Range(0.001, 0.3)) = 0.05 9 _EdgeColor("Edge Color", Color) = (1, 0.5, 0, 1) 10 _EdgeIntensity("Edge Intensity", Range(0, 5)) = 2 11 } 12 13 SubShader 14 { 15 Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline" } 16 17 Pass 18 { 19 HLSLPROGRAM 20 21 #pragma vertex vert 22 #pragma fragment frag 23 24 #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" 25 26 struct Attributes 27 { 28 float4 positionOS : POSITION; 29 float2 uv : TEXCOORD0; 30 }; 31 32 struct Varyings 33 { 34 float4 positionHCS : SV_POSITION; 35 float2 uv : TEXCOORD0; 36 }; 37 38 TEXTURE2D(_BaseMap); 39 SAMPLER(sampler_BaseMap); 40 41 CBUFFER_START(UnityPerMaterial) 42 half4 _BaseColor; 43 float4 _BaseMap_ST; 44 float _DissolveAmount; 45 float _EdgeWidth; 46 half4 _EdgeColor; 47 float _EdgeIntensity; 48 CBUFFER_END 49 50 Varyings vert(Attributes IN) 51 { 52 Varyings OUT; 53 OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz); 54 OUT.uv = TRANSFORM_TEX(IN.uv, _BaseMap); 55 return OUT; 56 } 57 58 half4 frag(Varyings IN) : SV_Target 59 { 60 float dissolveValue = 1 - IN.uv.y; 61 clip(dissolveValue - _DissolveAmount); 62 63 float edge = 1.0 - smoothstep(0.0, _EdgeWidth, dissolveValue - _DissolveAmount); 64 half3 edgeGlow = _EdgeColor.rgb * edge * _EdgeIntensity; 65 66 half4 baseColor = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, IN.uv) * _BaseColor; 67 baseColor.rgb += edgeGlow; 68 69 return baseColor; 70 } 71 ENDHLSL 72 } 73 } 74}
ブロックノイズ
hlsl1Shader "Custom/BlockNoise" 2{ 3 Properties 4 { 5 _NoiseSize("Noise Size", Integer) = 8 6 } 7 8 SubShader 9 { 10 Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline" } 11 12 Pass 13 { 14 HLSLPROGRAM 15 16 #pragma vertex vert 17 #pragma fragment frag 18 19 #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" 20 21 struct Attributes 22 { 23 float4 positionOS : POSITION; 24 float2 uv : TEXCOORD0; 25 }; 26 27 struct Varyings 28 { 29 float4 positionHCS : SV_POSITION; 30 float2 uv : TEXCOORD0; 31 }; 32 33 CBUFFER_START(UnityPerMaterial) 34 int _NoiseSize; 35 CBUFFER_END 36 37 float random (float2 p) 38 { 39 return frac(sin(dot(p, float2(12.9898,78.233))) * 43758.5453); 40 } 41 42 float noise(float2 st) 43 { 44 float2 p = floor(st); 45 return random(p); 46 } 47 48 Varyings vert(Attributes IN) 49 { 50 Varyings OUT; 51 OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz); 52 OUT.uv = IN.uv; 53 return OUT; 54 } 55 56 half4 frag(Varyings IN) : SV_Target 57 { 58 float c = noise( IN.uv * _NoiseSize ); 59 return half4(c, c, c, 1); 60 } 61 62 ENDHLSL 63 } 64 } 65}
パーリンノイズ
hlsl1Shader "Custom/PerlinNoise" 2{ 3 Properties 4 { 5 _NoiseSize("Noise Size", Integer) = 8 6 } 7 8 SubShader 9 { 10 Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline" } 11 12 Pass 13 { 14 HLSLPROGRAM 15 16 #pragma vertex vert 17 #pragma fragment frag 18 19 #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" 20 21 struct Attributes 22 { 23 float4 positionOS : POSITION; 24 float2 uv : TEXCOORD0; 25 }; 26 27 struct Varyings 28 { 29 float4 positionHCS : SV_POSITION; 30 float2 uv : TEXCOORD0; 31 }; 32 33 TEXTURE2D(_BaseMap); 34 SAMPLER(sampler_BaseMap); 35 36 CBUFFER_START(UnityPerMaterial) 37 int _NoiseSize; 38 CBUFFER_END 39 40 float2 random(float2 st){ 41 st = float2( dot(st,float2(127.1,311.7)), 42 dot(st,float2(269.5,183.3)) ); 43 return -1.0 + 2.0*frac(sin(st)*43758.5453123); 44 } 45 46 float perlinNoise(float2 st) 47 { 48 float2 p = floor(st); 49 float2 f = frac(st); 50 float2 u = f*f*(3.0-2.0*f); 51 52 float v00 = random(p+float2(0,0)); 53 float v10 = random(p+float2(1,0)); 54 float v01 = random(p+float2(0,1)); 55 float v11 = random(p+float2(1,1)); 56 57 return lerp( lerp( dot( v00, f - float2(0,0) ), dot( v10, f - float2(1,0) ), u.x ), 58 lerp( dot( v01, f - float2(0,1) ), dot( v11, f - float2(1,1) ), u.x ), 59 u.y)+0.5f; 60 } 61 62 Varyings vert(Attributes IN) 63 { 64 Varyings OUT; 65 OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz); 66 OUT.uv = IN.uv; 67 return OUT; 68 } 69 70 half4 frag(Varyings IN) : SV_Target 71 { 72 float c = perlinNoise( IN.uv * _NoiseSize ); 73 return half4(c, c, c, 1); 74 } 75 ENDHLSL 76 } 77 } 78}
ボロノイノイズ
hlsl1Shader "Custom/VoronoiNoise" 2{ 3 Properties 4 { 5 _Scale("Cell Scale", Float) = 8 6 _Jitter("Jitter", Range(0, 1)) = 1 7 _AnimSpeed("Animation Speed", Range(0,5)) = 1 8 } 9 10 SubShader 11 { 12 Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline" } 13 14 Pass 15 { 16 HLSLPROGRAM 17 18 #pragma vertex vert 19 #pragma fragment frag 20 21 #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" 22 23 struct Attributes 24 { 25 float4 positionOS : POSITION; 26 float2 uv : TEXCOORD0; 27 }; 28 29 struct Varyings 30 { 31 float4 positionHCS : SV_POSITION; 32 float2 uv : TEXCOORD0; 33 }; 34 35 CBUFFER_START(UnityPerMaterial) 36 float _Scale; 37 float _Jitter; 38 float _AnimSpeed; 39 CBUFFER_END 40 41 float2 hash(float2 p) 42 { 43 p = float2(dot(p, float2(127.1, 311.7)), dot(p, float2(269.5, 183.3))); 44 return frac(sin(p) * 43758.5453123); 45 } 46 47 float voronoi(float2 uv, float jitter) 48 { 49 float2 cell = floor(uv); 50 float2 local = frac(uv); 51 float minDist = 2; 52 53 for (int y = -1; y <= 1; y++) 54 { 55 for (int x = -1; x <= 1; x++) 56 { 57 float2 neighbor = float2(x, y); 58 float2 rnd = hash(cell + neighbor); 59 float2 seedPoint = 0.5 + jitter * 0.5 * sin(_Time.y * _AnimSpeed + 6.2831 * rnd); 60 float2 diff = neighbor + seedPoint - local; 61 minDist = min(minDist, length(diff)); 62 } 63 } 64 return minDist; 65 } 66 67 Varyings vert(Attributes IN) 68 { 69 Varyings OUT; 70 OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz); 71 OUT.uv = IN.uv; 72 return OUT; 73 } 74 75 half4 frag(Varyings IN) : SV_Target 76 { 77 float v = voronoi(IN.uv * _Scale, _Jitter); 78 return half4(v, v, v, 1); 79 } 80 ENDHLSL 81 } 82 } 83}
課題
ディゾルブにパーリンノイズ
hlsl1Shader "Custom/DissolveNoise" 2{ 3 Properties 4 { 5 [MainColor] _BaseColor("Base Color", Color) = (1, 1, 1, 1) 6 [MainTexture] _BaseMap("Base Map", 2D) = "white" {} 7 _DissolveAmount("Dissolve Amount", Range(0, 1)) = 0 8 _EdgeWidth("Edge Width", Range(0.001, 0.3)) = 0.05 9 _EdgeColor("Edge Color", Color) = (1, 0.5, 0, 1) 10 _EdgeIntensity("Edge Intensity", Range(0, 5)) = 2 11 _NoiseSize("Noise Size", Integer) = 8 12 } 13 14 SubShader 15 { 16 Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline" } 17 18 Pass 19 { 20 HLSLPROGRAM 21 22 #pragma vertex vert 23 #pragma fragment frag 24 25 #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" 26 27 struct Attributes 28 { 29 float4 positionOS : POSITION; 30 float2 uv : TEXCOORD0; 31 }; 32 33 struct Varyings 34 { 35 float4 positionHCS : SV_POSITION; 36 float2 uv : TEXCOORD0; 37 }; 38 39 TEXTURE2D(_BaseMap); 40 SAMPLER(sampler_BaseMap); 41 42 CBUFFER_START(UnityPerMaterial) 43 half4 _BaseColor; 44 float4 _BaseMap_ST; 45 float _DissolveAmount; 46 float _EdgeWidth; 47 half4 _EdgeColor; 48 float _EdgeIntensity; 49 int _NoiseSize; 50 CBUFFER_END 51 52 float2 random(float2 st){ 53 st = float2( dot(st,float2(127.1,311.7)), 54 dot(st,float2(269.5,183.3)) ); 55 return -1.0 + 2.0*frac(sin(st)*43758.5453123); 56 } 57 58 float perlinNoise(float2 st) 59 { 60 float2 p = floor(st); 61 float2 f = frac(st); 62 float2 u = f*f*(3.0-2.0*f); 63 64 float v00 = random(p+float2(0,0)); 65 float v10 = random(p+float2(1,0)); 66 float v01 = random(p+float2(0,1)); 67 float v11 = random(p+float2(1,1)); 68 69 return lerp( lerp( dot( v00, f - float2(0,0) ), dot( v10, f - float2(1,0) ), u.x ), 70 lerp( dot( v01, f - float2(0,1) ), dot( v11, f - float2(1,1) ), u.x ), 71 u.y)+0.5f; 72 } 73 74 Varyings vert(Attributes IN) 75 { 76 Varyings OUT; 77 OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz); 78 OUT.uv = TRANSFORM_TEX(IN.uv, _BaseMap); 79 return OUT; 80 } 81 82 half4 frag(Varyings IN) : SV_Target 83 { 84 float dissolveValue = perlinNoise( IN.uv * _NoiseSize ); 85 clip(dissolveValue - _DissolveAmount); 86 87 float edge = 1.0 - smoothstep(0.0, _EdgeWidth, dissolveValue - _DissolveAmount); 88 half3 edgeGlow = _EdgeColor.rgb * edge * _EdgeIntensity; 89 90 half4 baseColor = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, IN.uv) * _BaseColor; 91 baseColor.rgb += edgeGlow; 92 93 return baseColor; 94 } 95 ENDHLSL 96 } 97 } 98}
書き換え後
hlsl1Shader "UnlitSample/Dissolve" 2{ 3 Properties 4 { 5 _MainTex ("Texture", 2D) = "white" {} 6 _DissolveAmount("Dissolve Amount", Range(0, 1)) = 0 7 _EdgeWidth("Edge Width", Range(0.001, 0.3)) = 0.05 8 _EdgeColor("Edge Color", Color) = (1, 0.5, 0, 1) 9 _EdgeIntensity("Edge Intensity", Range(0, 5)) = 2 10 } 11 SubShader 12 { 13 Tags { "RenderType"="Opaque" } 14 LOD 100 15 16 Pass 17 { 18 CGPROGRAM 19 #pragma vertex vert 20 #pragma fragment frag 21 // make fog work 22 #pragma multi_compile_fog 23 24 #include "UnityCG.cginc" 25 26 struct appdata 27 { 28 float4 vertex : POSITION; 29 float2 uv : TEXCOORD0; 30 }; 31 32 struct v2f 33 { 34 float2 uv : TEXCOORD0; 35 UNITY_FOG_COORDS(1) 36 float4 vertex : SV_POSITION; 37 }; 38 39 sampler2D _MainTex; 40 float4 _MainTex_ST; 41 float _DissolveAmount; 42 float _EdgeWidth; 43 half4 _EdgeColor; 44 float _EdgeIntensity; 45 46 v2f vert (appdata v) 47 { 48 v2f o; 49 o.vertex = UnityObjectToClipPos(v.vertex); 50 o.uv = TRANSFORM_TEX(v.uv, _MainTex); 51 UNITY_TRANSFER_FOG(o,o.vertex); 52 return o; 53 } 54 55 fixed4 frag (v2f i) : SV_Target 56 { 57 float dissolveValue = 1 - i.uv.y; 58 clip(dissolveValue - _DissolveAmount); 59 60 float edge = 1.0 - smoothstep(0.0, _EdgeWidth, dissolveValue - _DissolveAmount); 61 half3 edgeGlow = _EdgeColor.rgb * edge * _EdgeIntensity; 62 63 half4 baseColor = tex2D(_MainTex, i.uv); 64 baseColor.rgb += edgeGlow; 65 // apply fog 66 UNITY_APPLY_FOG(i.fogCoord, col); 67 return baseColor; 68 } 69 ENDCG 70 } 71 } 72}
hlsl1Shader "Unlit/BlockNoise" 2{ 3 Properties 4 { 5 _NoiseSize("Noise Size", Integer) = 8 6 } 7 SubShader 8 { 9 Tags { "RenderType"="Opaque" } 10 LOD 100 11 12 Pass 13 { 14 CGPROGRAM 15 #pragma vertex vert 16 #pragma fragment frag 17 // make fog work 18 #pragma multi_compile_fog 19 20 #include "UnityCG.cginc" 21 22 struct appdata 23 { 24 float4 vertex : POSITION; 25 float2 uv : TEXCOORD0; 26 }; 27 28 struct v2f 29 { 30 float2 uv : TEXCOORD0; 31 UNITY_FOG_COORDS(1) 32 float4 vertex : SV_POSITION; 33 }; 34 35 int _NoiseSize; 36 37 float random (float2 p) 38 { 39 return frac(sin(dot(p, float2(12.9898,78.233))) * 43758.5453); 40 } 41 42 float noise(float2 st) 43 { 44 float2 p = floor(st); 45 return random(p); 46 } 47 48 v2f vert (appdata v) 49 { 50 v2f o; 51 o.vertex = UnityObjectToClipPos(v.vertex); 52 o.uv = v.uv; 53 UNITY_TRANSFER_FOG(o,o.vertex); 54 return o; 55 } 56 57 fixed4 frag (v2f i) : SV_Target 58 { 59 // sample the texture 60 float c = noise( i.uv * _NoiseSize ); 61 fixed4 col = fixed4(c, c, c, 1); 62 // apply fog 63 UNITY_APPLY_FOG(i.fogCoord, col); 64 return col; 65 } 66 ENDCG 67 } 68 } 69}
hlsl1Shader "UnlitSample/PerlinNoise" 2{ 3 Properties 4 { 5 _NoiseSize("Noise Size", Integer) = 8 6 } 7 SubShader 8 { 9 Tags { "RenderType"="Opaque" } 10 LOD 100 11 12 Pass 13 { 14 CGPROGRAM 15 #pragma vertex vert 16 #pragma fragment frag 17 // make fog work 18 #pragma multi_compile_fog 19 20 #include "UnityCG.cginc" 21 22 struct appdata 23 { 24 float4 vertex : POSITION; 25 float2 uv : TEXCOORD0; 26 }; 27 28 struct v2f 29 { 30 float2 uv : TEXCOORD0; 31 UNITY_FOG_COORDS(1) 32 float4 vertex : SV_POSITION; 33 }; 34 35 int _NoiseSize; 36 37 float2 random(float2 st){ 38 st = float2( dot(st,float2(127.1,311.7)), 39 dot(st,float2(269.5,183.3)) ); 40 return -1.0 + 2.0*frac(sin(st)*43758.5453123); 41 } 42 43 float perlinNoise(float2 st) 44 { 45 float2 p = floor(st); 46 float2 f = frac(st); 47 float2 u = f*f*(3.0-2.0*f); 48 49 float v00 = random(p+float2(0,0)); 50 float v10 = random(p+float2(1,0)); 51 float v01 = random(p+float2(0,1)); 52 float v11 = random(p+float2(1,1)); 53 54 return lerp( lerp( dot( v00, f - float2(0,0) ), dot( v10, f - float2(1,0) ), u.x ), 55 lerp( dot( v01, f - float2(0,1) ), dot( v11, f - float2(1,1) ), u.x ), 56 u.y)+0.5f; 57 } 58 59 v2f vert (appdata v) 60 { 61 v2f o; 62 o.vertex = UnityObjectToClipPos(v.vertex); 63 o.uv = v.uv; 64 UNITY_TRANSFER_FOG(o,o.vertex); 65 return o; 66 } 67 68 fixed4 frag (v2f i) : SV_Target 69 { 70 float c = perlinNoise( i.uv * _NoiseSize ); 71 fixed4 col = fixed4(c, c, c, 1); 72 // apply fog 73 UNITY_APPLY_FOG(i.fogCoord, col); 74 return col; 75 } 76 ENDCG 77 } 78 } 79}
hlsl1Shader "UnlitSample/VoronoiNoise" 2{ 3 Properties 4 { 5 _Scale("Cell Scale", Float) = 8 6 _Jitter("Jitter", Range(0, 1)) = 1 7 _AnimSpeed("Animation Speed", Range(0,5)) = 1 8 } 9 SubShader 10 { 11 Tags { "RenderType"="Opaque" } 12 LOD 100 13 14 Pass 15 { 16 CGPROGRAM 17 #pragma vertex vert 18 #pragma fragment frag 19 // make fog work 20 #pragma multi_compile_fog 21 22 #include "UnityCG.cginc" 23 24 struct appdata 25 { 26 float4 vertex : POSITION; 27 float2 uv : TEXCOORD0; 28 }; 29 30 struct v2f 31 { 32 float2 uv : TEXCOORD0; 33 UNITY_FOG_COORDS(1) 34 float4 vertex : SV_POSITION; 35 }; 36 37 float _Scale; 38 float _Jitter; 39 float _AnimSpeed; 40 41 float2 hash(float2 p) 42 { 43 p = float2(dot(p, float2(127.1, 311.7)), dot(p, float2(269.5, 183.3))); 44 return frac(sin(p) * 43758.5453123); 45 } 46 47 float voronoi(float2 uv, float jitter) 48 { 49 float2 cell = floor(uv); 50 float2 local = frac(uv); 51 float minDist = 2; 52 53 for (int y = -1; y <= 1; y++) 54 { 55 for (int x = -1; x <= 1; x++) 56 { 57 float2 neighbor = float2(x, y); 58 float2 rnd = hash(cell + neighbor); 59 float2 seedPoint = 0.5 + jitter * 0.5 * sin(_Time.y * _AnimSpeed + 6.2831 * rnd); 60 float2 diff = neighbor + seedPoint - local; 61 minDist = min(minDist, length(diff)); 62 } 63 } 64 return minDist; 65 } 66 67 v2f vert (appdata v) 68 { 69 v2f o; 70 o.vertex = UnityObjectToClipPos(v.vertex); 71 o.uv = v.uv; 72 UNITY_TRANSFER_FOG(o,o.vertex); 73 return o; 74 } 75 76 fixed4 frag (v2f i) : SV_Target 77 { 78 float v = voronoi(i.uv * _Scale, _Jitter); 79 fixed4 col = fixed4(v,v,v,1); 80 // apply fog 81 UNITY_APPLY_FOG(i.fogCoord, col); 82 return col; 83 } 84 ENDCG 85 } 86 } 87}