之前的实现过这个效果，可惜没有记笔记，所以现在有点遗忘，连多个波纹一起在水面上实现的效果都忘记了，所以，查看了下之前实现的代码，现在再记一下笔记。
基础的波纹效果
要实现波纹，首先要知道波纹的中心点，这个位置应该是世界空间坐标系的位置，然后还要知道扩散到了哪里，也需要传入，知道了这两个值以后，就可以实现一个最简易的效果，只需要通过脚本更新这两个值，就可以实现最简单的波纹扩散效果。
波纹中心点我命名为了_HitPos，扩散到了尺寸就命名为HitSize，在片元里面求出世界空间坐标位置和中心点的位置，然后再减去_HitSize，就可以得出一个扩散的圆，调节_HitSize的大小，就可以发现圆会变大变小。
half dis = distance(input.positionWS, _HitPos.xyz);
dis -= _HitSize;
里面黑外面白，用一下反值
里面白外面黑，这样我们就找到了散的边界，我们会返现有一片纯黑和纯白的区域，这一片区域就是大于1和小于0的区域，而边缘渐变的部分就是从0-1的渐变。我们做效果，其实就只需要这个0-1的范围即可，将其定义为波纹的宽度。
然后，我们再命名一个_HitSpread作为扩散范围的调整，用边界值去除以这个值，就去修改，但是我为了保证0-1的范围中心处于边缘，我这里使用smoothstep方法，获取了0到-1的区域，然后使用_HitSpread去控制拾取的范围值。0就是刚好对应尺寸的起点。
half disMask = distance(input.positionWS, _HitPos.xyz);
half range = -clamp((disMask - _HitSize) / _HitSpread, -1, 0);
这样保证了区域的设置。
有了这个值以后，美术可以准确的去设置具体的显示范围，然后我们再给一个贴图，可以去拾取一张渐变图，美术也就可以简单的调节具体如何去渐变。
这里我使用了这张Ramp图片，然后使用上面的值作为采样的x轴，y轴默认0.5，就可以准确拾取过渡值。
half disMask = distance(input.positionWS, _HitPos.xyz);
half range = -clamp((disMask - _HitSize) / _HitSpread, -1, 0);
half2 rampUV = half2(range, 0.5);
half ramp = SAMPLE_TEXTURE2D(_RampTex, sampler_RampTex, rampUV).r;
采样出来的效果就是：
这种方法_HitSpread能准确的控制范围，而且_HitSize也能准确的控制移动的位置
half noise = SAMPLE_TEXTURE2D(_NoiseTex, sampler_NoiseTex, noiseUV).r;
half disMask = distance(input.positionWS, _HitPos.xyz);
half range = -clamp((disMask - _HitSize + noise) / _HitSpread, -1, 0);
half2 rampUV = half2(range, 0.5);
half ramp = SAMPLE_TEXTURE2D(_RampTex, sampler_RampTex, rampUV).r;
再加上一张扰动图进行偏移，让渐变没有这么的平滑
接下来实现了基本的效果，然后我们还需要设置一个终点，到终点位置以后，就渐渐的消失的效果，这个效果的实现，首先就是我们需要设置一个渐变消失位置_HitFadeDistance，然后用之前求出的范围值除以它，然后再设置_HitFadePower和这个值相乘，主要是为了防止它的效果太早的变淡。
half hitFade = saturate((1.0 - disMask / _HitFadeDistance) * _HitFadePower);
这个效果就是这样
然后用这个求出的值，再乘以之前的ramp，就实现了这个效果限制的显示范围。
就实现了我们所需要的效果。
实现脚本控制
既然实现了shader，但是位置和渐变的值需要我们手动传入啊。
为了实现这个效果，我们还需要设置全局变量，方便从脚本向shader传入变量。将_HitPos和_HitSize注销，这两个值我们需要从一个全局变量传入。这个全局变量前三个值设置为_HitPos的值，w通道则设置_HitSize的值，这样用一个四维向量就存储了两个值。
half4 HitParams;
声明一个HitParams，不要写在CBUFFER_START(UnityPerMaterial)里面，因为我们不需要合批，它们只是一个全局变量，然后还需要将Properties里面的值也注销掉，如果哪里设置了值，将会直接传入。
然后在运算前面重新声明它们
half3 _HitPos = HitParams.xyz;
half _HitSize = HitParams.w;
half noise = SAMPLE_TEXTURE2D(_NoiseTex, sampler_NoiseTex, noiseUV).r;
half disMask = distance(input.positionWS, _HitPos.xyz);
half range = -clamp((disMask - _HitSize + noise) / _HitSpread, -1, 0);
half2 rampUV = half2(range, 0.5);
half ramp = SAMPLE_TEXTURE2D(_RampTex, sampler_RampTex, rampUV).r;
half hitFade = saturate((1.0 - disMask / _HitFadeDistance) * _HitFadePower);
half hitResult = hitFade * ramp;
这样，就不用动原来代码，就实现。
接着是脚本，我声明了一个WaterRipple的脚本，
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
[ExecuteInEditMode()] //在编辑模式下也可以运行
public class WaterRipple : MonoBehaviour
{
public string triggerTag = "ForceField";
private Vector4 HitPos;
private float HitSize;
private float clickTimer = 0.0f; //防止频繁触发间隔
void Start()
{
}
void RayCast()
{
RaycastHit hitInfo;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition); //从屏幕点击位置，在相机3D空间中发射一条射线
if (Physics.Raycast(ray, out hitInfo, 1000)) //通过射线拾取物体，拾取到返回true
{
if (hitInfo.transform.CompareTag(triggerTag)) //判断当前拾取到的物体的tag是否正确
{
Vector3 pos = hitInfo.point;
HitPos.x = pos.x;
HitPos.y = pos.y;
HitPos.z = pos.z;
}
}
}
// Update is called once per frame
void Update()
{
clickTimer += Time.deltaTime;
if (Input.GetMouseButtonDown(0))
{
if (clickTimer > 0.5f)
{
clickTimer = 0.0f;
RayCast();
}
}
//设置shader的全局变量
HitPos.w = clickTimer;
Shader.SetGlobalVector("HitParams", HitPos);
}
}
先附上代码，然后讲解里面主要的部分：
在update里面，首先对鼠标是否按下进行了判断，然后用一个数值进行放误触处理，这个值后面也可以设置一个可以修改的变量
clickTimer += Time.deltaTime;
if (Input.GetMouseButtonDown(0))
{
if (clickTimer > 0.5f)
{
clickTimer = 0.0f;
RayCast();
}
}
如果可以触发RayCast函数，那么，将调用此函数
void RayCast()
{
RaycastHit hitInfo;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition); //从屏幕点击位置，在相机3D空间中发射一条射线
if (Physics.Raycast(ray, out hitInfo, 1000)) //通过射线拾取物体，拾取到返回true
{
if (hitInfo.transform.CompareTag(triggerTag)) //判断当前拾取到的物体的tag是否正确
{
Vector3 pos = hitInfo.point;
HitPos.x = pos.x;
HitPos.y = pos.y;
HitPos.z = pos.z;
}
}
}
这个函数里面主要是获取了点击在场景中拾取到的位置，而且设置了一个tag判断，主要是防止不需要触发的物体也会触发此事件问题。
//设置shader的全局变量
HitPos.w = clickTimer;
Shader.SetGlobalVector("HitParams", HitPos);
最后则是在update函数里面设置全局变量，所有的shader只要声明了HitParams，都可以获取到此变量的值。
只要在平面上面设置一个ForceField的Tag，然后设置好材质，点击即可看到效果。但是这种设置，我们只能实现一个效果的点击，如果点击第二个，那么，第一个的效果将直接消失，接下来，我们将实现多个效果一起播放。
多个波纹的实现
在实现多个波纹的需求下，我们还需要继续修改Shader，将之前的参数作为数组传入，这样可以处理多个，然后循环计算得到结果。
int HitAmount;
half4 HitParams[20]; //xyz:pos w:size
首先声明三个新的变量，HitAmount代表循环次数，HitParams直接作为数组传入，就是可以实现当前的操作，然后将循环修改成一个函数：
half Hit(half hitNoise, half3 positionWS)
{
float hitResult;
//循环处理多个点的波纹
for (int i = 0; i < HitAmount; i++)
{
half disMask = distance(positionWS, HitParams[i].xyz);
half range = -clamp((disMask - HitParams[i].w + hitNoise) / _HitSpread, -1, 0);
half2 rampUV = half2(range, 0.5);
half ramp = SAMPLE_TEXTURE2D(_RampTex, sampler_RampTex, rampUV).r;
half hitFade = saturate((1.0 - disMask / _HitFadeDistance) * _HitFadePower);
hitResult += hitFade * ramp;
}
return saturate(hitResult);
}
用来可以实现多个点的波纹，只是将HitPos和HitSize修改成了数组里面的值，这样就可以实现多个相加，然后最后限制到0-1的范围内即可。
然后是脚本修改，这次使用了粒子系统来模拟，渐变，然后获取到渐变的时间，然后乘以设置的大小，传入即可。
粒子系统的设置。
脚本的设置
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
// [ExecuteInEditMode()] //在编辑模式下也可以运行
public class WaterRipple : MonoBehaviour
{
public ParticleSystem PS;
public string triggerTag = "ForceField";
public float HitSize = 1;
public int HitAmount; //当前粒子可以生成的粒子的个数
private Vector4[] HitParams;
private float clickTimer = 0.0f; //防止频繁触发间隔
private ParticleSystem.Particle[] particles; //用于获取粒子系统里面的粒子
void Start()
{
}
void RayCast()
{
RaycastHit hitInfo;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition); //从屏幕点击位置，在相机3D空间中发射一条射线
if (Physics.Raycast(ray, out hitInfo, 1000)) //通过射线拾取物体，拾取到返回true
{
if (hitInfo.transform.CompareTag(triggerTag)) //判断当前拾取到的物体的tag是否正确
{
PS.transform.position = hitInfo.point;
PS.Emit(1);
}
}
}
// Update is called once per frame
void Update()
{
clickTimer += Time.deltaTime;
if (Input.GetMouseButtonDown(0))
{
if (clickTimer > 0.2f)
{
clickTimer = 0.0f;
RayCast();
}
}
ParticleSystem.MainModule PSmain = PS.main;
PSmain.maxParticles = HitAmount; //设置最大粒子数
HitParams = new Vector4[HitAmount];
particles = new ParticleSystem.Particle[HitAmount];
PS.GetParticles(particles);
for (int i = 0; i < HitAmount; i++)
{
Vector3 pos = particles[i].position; //位置
float size = particles[i].GetCurrentSize(PS) * HitSize; //尺寸
HitParams[i].Set(pos.x, pos.y, pos.z, size);
}
Shader.SetGlobalVectorArray("HitParams", HitParams);
Shader.SetGlobalFloat("HitAmount", HitAmount);
}
}
脚本代码，会发现，我增加了一个HitAmount用来设置最多显示波浪的个数，然后从粒子系统拿到粒子的信息生成数组信息，传递给Shader的全局变量，其实我们也可以单独的传给Shader，这里我就不修改了。
下面，我列一下Shader的完整代码，基于URP的Unlit修改的：
Shader "Unlit/WaterRipple"
{
Properties
{
[MainTexture] _BaseMap("Texture", 2D) = "white" {}
[MainColor] _BaseColor("Color", Color) = (1, 1, 1, 1)
_Cutoff("AlphaCutout", Range(0.0, 1.0)) = 0.5
_NoiseTex("扰动图", 2D) = "white" {}
_RampTex("渐变图", 2D) = "white" {}
// _HitPos("点击位置", Vector) = (0, 0, 0, 0)
// _HitSize("波纹尺寸", Float) = 0
_HitSpread("扩散范围", Float) = 1
_HitFadeDistance("范围渐变", Float) = 6
_HitFadePower("范围渐变", Float) = 1
// BlendMode
_Surface("__surface", Float) = 0.0
_Blend("__mode", Float) = 0.0
_Cull("__cull", Float) = 2.0
[ToggleUI] _AlphaClip("__clip", Float) = 0.0
[HideInInspector] _BlendOp("__blendop", Float) = 0.0
[HideInInspector] _SrcBlend("__src", Float) = 1.0
[HideInInspector] _DstBlend("__dst", Float) = 0.0
[HideInInspector] _ZWrite("__zw", Float) = 1.0
}
SubShader
{
Tags {"RenderType" = "Opaque" "IgnoreProjector" = "True" "RenderPipeline" = "UniversalPipeline" "ShaderModel"="3.5"}
LOD 100
Blend [_SrcBlend][_DstBlend]
ZWrite [_ZWrite]
Cull [_Cull]
Pass
{
Name "Unlit"
HLSLPROGRAM
#pragma target 3.5
#pragma shader_feature_local_fragment _SURFACE_TYPE_TRANSPARENT
#pragma shader_feature_local_fragment _ALPHATEST_ON
#pragma shader_feature_local_fragment _ALPHAPREMULTIPLY_ON
// -------------------------------------
// Unity defined keywords
#pragma multi_compile_fog
#pragma multi_compile_instancing
#pragma multi_compile _ DOTS_INSTANCING_ON
#pragma multi_compile_fragment _ _SCREEN_SPACE_OCCLUSION
#pragma multi_compile_fragment _ _DBUFFER_MRT1 _DBUFFER_MRT2 _DBUFFER_MRT3
#pragma multi_compile _ DEBUG_DISPLAY
#pragma vertex UnlitPassVertex
#pragma fragment UnlitPassFragment
#include "./WaterRippleInput.hlsl"
#include "./WaterRippleForwardPass.hlsl"
ENDHLSL
}
Pass
{
Name "DepthOnly"
Tags{"LightMode" = "DepthOnly"}
ZWrite On
ColorMask 0
HLSLPROGRAM
#pragma exclude_renderers gles gles3 glcore
#pragma target 4.5
#pragma vertex DepthOnlyVertex
#pragma fragment DepthOnlyFragment
// -------------------------------------
// Material Keywords
#pragma shader_feature_local_fragment _ALPHATEST_ON
//--------------------------------------
// GPU Instancing
#pragma multi_compile_instancing
#pragma multi_compile _ DOTS_INSTANCING_ON
#include "Packages/com.unity.render-pipelines.universal/Shaders/UnlitInput.hlsl"
#include "Packages/com.unity.render-pipelines.universal/Shaders/DepthOnlyPass.hlsl"
ENDHLSL
}
Pass
{
Name "DepthNormalsOnly"
Tags{"LightMode" = "DepthNormalsOnly"}
ZWrite On
HLSLPROGRAM
#pragma exclude_renderers gles gles3 glcore
#pragma target 4.5
#pragma vertex DepthNormalsVertex
#pragma fragment DepthNormalsFragment
// -------------------------------------
// Material Keywords
#pragma shader_feature_local_fragment _ALPHATEST_ON
// -------------------------------------
// Unity defined keywords
#pragma multi_compile_fragment _ _GBUFFER_NORMALS_OCT // forward-only variant
//--------------------------------------
// GPU Instancing
#pragma multi_compile_instancing
#pragma multi_compile _ DOTS_INSTANCING_ON
#include "Packages/com.unity.render-pipelines.universal/Shaders/UnlitInput.hlsl"
#include "Packages/com.unity.render-pipelines.universal/Shaders/UnlitDepthNormalsPass.hlsl"
ENDHLSL
}
}
FallBack "Hidden/Universal Render Pipeline/FallbackError"
// CustomEditor "UnityEditor.Rendering.Universal.ShaderGUI.UnlitShader"
}
WaterRippleInput.hlsl
#ifndef UNIVERSAL_WATERRIPPLE_INPUT_INCLUDED
#define UNIVERSAL_WATERRIPPLE_INPUT_INCLUDED
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/SurfaceInput.hlsl"
CBUFFER_START(UnityPerMaterial)
float4 _BaseMap_ST;
float4 _NoiseTex_ST;
half4 _BaseColor;
half _Cutoff;
half _Surface;
// half4 _HitPos;
// half _HitSize;
half _HitSpread;
half _HitFadeDistance;
half _HitFadePower;
CBUFFER_END
TEXTURE2D(_NoiseTex); SAMPLER(sampler_NoiseTex);
TEXTURE2D(_RampTex); SAMPLER(sampler_RampTex);
int HitAmount;
half4 HitParams[20]; //xyz:pos w:size
#endif
WaterRippleForwardPass.hlsl
#ifndef URP_WATERRIPPLE_FORWARD_PASS_INCLUDED
#define URP_WATERRIPPLE_FORWARD_PASS_INCLUDED
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Unlit.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
struct Attributes
{
float4 positionOS : POSITION;
float2 uv : TEXCOORD0;
float3 normalOS : NORMAL;
float4 tangentOS : TANGENT;
UNITY_VERTEX_INPUT_INSTANCE_ID
};
struct Varyings
{
float4 uv : TEXCOORD0;
float fogCoord : TEXCOORD1;
float4 positionCS : SV_POSITION;
float3 positionWS : TEXCOORD2;
float3 normalWS : TEXCOORD3;
float3 viewDirWS : TEXCOORD4;
UNITY_VERTEX_INPUT_INSTANCE_ID
UNITY_VERTEX_OUTPUT_STEREO
};
void InitializeInputData(Varyings input, out InputData inputData)
{
inputData = (InputData)0;
inputData.positionWS = input.positionWS;
inputData.normalWS = input.normalWS;
inputData.viewDirectionWS = input.viewDirWS;
inputData.shadowCoord = 0;
inputData.fogCoord = 0;
inputData.vertexLighting = half3(0, 0, 0);
inputData.bakedGI = half3(0, 0, 0);
inputData.normalizedScreenSpaceUV = 0;
inputData.shadowMask = half4(1, 1, 1, 1);
}
Varyings UnlitPassVertex(Attributes input)
{
Varyings output = (Varyings)0;
UNITY_SETUP_INSTANCE_ID(input);
UNITY_TRANSFER_INSTANCE_ID(input, output);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
VertexPositionInputs vertexInput = GetVertexPositionInputs(input.positionOS.xyz);
output.positionCS = vertexInput.positionCS;
output.uv.xy = TRANSFORM_TEX(input.uv, _BaseMap);
output.uv.zw = TRANSFORM_TEX(input.uv, _NoiseTex);
#if defined(_FOG_FRAGMENT)
output.fogCoord = vertexInput.positionVS.z;
#else
output.fogCoord = ComputeFogFactor(vertexInput.positionCS.z);
#endif
VertexNormalInputs normalInput = GetVertexNormalInputs(input.normalOS, input.tangentOS);
half3 viewDirWS = GetWorldSpaceViewDir(vertexInput.positionWS);
// already normalized from normal transform to WS.
output.positionWS = vertexInput.positionWS;
output.normalWS = normalInput.normalWS;
output.viewDirWS = viewDirWS;
return output;
}
half Hit(half hitNoise, half3 positionWS)
{
float hitResult;
//循环处理多个点的波纹
for (int i = 0; i < HitAmount; i++)
{
half disMask = distance(positionWS, HitParams[i].xyz);
half range = -clamp((disMask - HitParams[i].w + hitNoise) / _HitSpread, -1, 0);
half2 rampUV = half2(range, 0.5);
half ramp = SAMPLE_TEXTURE2D(_RampTex, sampler_RampTex, rampUV).r;
half hitFade = saturate((1.0 - disMask / _HitFadeDistance) * _HitFadePower);
hitResult += hitFade * ramp;
}
return saturate(hitResult);
}
half4 UnlitPassFragment(Varyings input) : SV_Target
{
UNITY_SETUP_INSTANCE_ID(input);
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
half2 uv = input.uv.xy;
half2 noiseUV = input.uv.zw;
half4 texColor = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uv);
half3 color = texColor.rgb * _BaseColor.rgb;
half alpha = texColor.a * _BaseColor.a;
AlphaDiscard(alpha, _Cutoff);
#if defined(_ALPHAPREMULTIPLY_ON)
color *= alpha;
#endif
InputData inputData;
InitializeInputData(input, inputData);
SETUP_DEBUG_TEXTURE_DATA(inputData, input.uv, _BaseMap);
#ifdef _DBUFFER
ApplyDecalToBaseColor(input.positionCS, color);
#endif
#if defined(_FOG_FRAGMENT)
#if (defined(FOG_LINEAR) || defined(FOG_EXP) || defined(FOG_EXP2))
float viewZ = -input.fogCoord;
float nearToFarZ = max(viewZ - _ProjectionParams.y, 0);
half fogFactor = ComputeFogFactorZ0ToFar(nearToFarZ);
#else
half fogFactor = 0;
#endif
#else
half fogFactor = input.fogCoord;
#endif
half4 finalColor = UniversalFragmentUnlit(inputData, color, alpha);
half noise = SAMPLE_TEXTURE2D(_NoiseTex, sampler_NoiseTex, noiseUV).r;
// half disMask = distance(input.positionWS, _HitPos.xyz);
// half range = -clamp((disMask - _HitSize + noise) / _HitSpread, -1, 0);
// half2 rampUV = half2(range, 0.5);
// half ramp = SAMPLE_TEXTURE2D(_RampTex, sampler_RampTex, rampUV).r;
// half hitFade = saturate((1.0 - disMask / _HitFadeDistance) * _HitFadePower);
// half hitResult = hitFade * ramp;
half hitResult = Hit(noise, input.positionWS);
finalColor.rgb += hitResult;
finalColor.rgb = MixFog(finalColor.rgb, fogFactor);
// finalColor.rgb = hitFade;
return finalColor;
}
#endif
如果有问题，请及时联系我。
