移动端下雨系统的实现

Vector3[] GetCorners(float distance)
    ｛
        Vector3[] corners = new Vector3[4];
        float halfFOV = (Camera.main.fieldOfView * 0.5f) * Mathf.Deg2Rad;
        float aspect = Camera.main.aspect;
        float height = distance * Mathf.Tan(halfFOV);
        float width = height * aspect;
        Transform tx = Camera.main.transform;
        // UpperLeft
        corners[0] = tx.position - (tx.right * width);
        corners[0] += tx.up * height;
        corners[0] += tx.forward * distance;
        // UpperRight
        corners[1] = tx.position + (tx.right * width);
        corners[1] += tx.up * height;
        corners[1] += tx.forward * distance;
        // LowerLeft
        corners[2] = tx.position - (tx.right * width);
        corners[2] -= tx.up * height;
        corners[2] += tx.forward * distance;
        // LowerRight
        corners[3] = tx.position + (tx.right * width);
        corners[3] -= tx.up * height;
        corners[3] += tx.forward * distance;
        return corners;
    ｝

               v2f vert(appdata_full v)
		｛
			v2f o;
			UNITY_SETUP_INSTANCE_ID(v);
			UNITY_TRANSFER_INSTANCE_ID(v, o);
			float3 centerOffs = v.vertex.xyz * float3(_RainX, 1, _RainZ);
			float4 worldPos = mul(unity_ObjectToWorld, v.vertex);
			float3 normalDir = _WorldSpaceCameraPos - worldPos;
			normalDir.y = 0;
			normalDir = normalize(normalDir);
			float3 upDir = float3(0, 1, 0);
			float3 rightdir = cross(upDir, normalDir);
			float3 pos1 = float3(unity_ObjectToWorld[0].w, unity_ObjectToWorld[1].w, unity_ObjectToWorld[2].w);
			worldPos.xyz = pos1  + rightdir * centerOffs.z + upDir * centerOffs.x + normalDir * centerOffs.y;
			o.pos = mul(UNITY_MATRIX_VP, float4(worldPos.xyz, 1));
			o.uv.xy = TRANSFORM_TEX(v.texcoord.xy, _MainTex);
			return o; 
		｝

                      inline float2 ComputeRipple(float2 UV, float CurrentTime, float Weight)
			｛
				float4 Ripple = tex2Dlod(_RippleTex, float4(UV, 0, 0));
				Ripple += tex2Dlod(_RippleTex, float4(UV, 0, 1));
				Ripple *= 0.5;
				Ripple.yz = Ripple.yz * 2 - 1;
				float DropFrac = frac(Ripple.w + CurrentTime);
				float TimeFrac = DropFrac - 1.0f + Ripple.x;
				float DropFactor = saturate(0.2f + Weight * 0.8f - DropFrac);
				float FinalFactor = DropFactor * Ripple.x * sin(clamp(TimeFrac * 9.0f, 0.0f, 3.0f) * 3.141592653589793);
				return Ripple.yz * FinalFactor;
			｝
			inline float3 AddWaterRipples(float3 i_worldPos, float fadeOut)
			｛
				float4 Weights = RainIntensity * 2 - float4(0, 0.25, 0.5, 0.75);
				Weights = saturate(Weights * 4);
				float animSpeed = _Time.y;
				float2 Ripple1 = ComputeRipple(float2(i_worldPos.xz * _RippleTile + float2(0.025f, 0.0f) * _Time.y), animSpeed, Weights.x);
				float2 Ripple2 = ComputeRipple(float2(i_worldPos.xz * _RippleTile + float2(-0.055f, 0.03f) * _Time.y), animSpeed * 0.71, Weights.y);
				float3 rippleNormal = float3(Weights.x * Ripple1.xy + Weights.y * Ripple2.xy, 1);
				return lerp(float3(0, 0, 1), rippleNormal, fadeOut);
			｝

              float3 BRDF3_Direct1(float3 diffColor, float3 specColor, float rlPow4, float smoothness)
			｛
				float LUT_RANGE = 16.0; // must match range in NHxRoughness() function in GeneratedTextures.cpp
									   // Lookup texture to save instructions
				float specular = tex2D(unity_NHxRoughness, float2(rlPow4, SmoothnessToPerceptualRoughness1(smoothness))).UNITY_ATTEN_CHANNEL * LUT_RANGE;
				return diffColor + specular * specColor;
			｝
			float3 BRDF3_Indirect1(float3 diffColor, float3 specColor, float grazingTerm, float fresnelTerm, float r)
			｛
				float3 c = diffColor;
				r = min(r, 0.5);
				c += lerp(specColor, grazingTerm, min(r, fresnelTerm));
				return c;
			｝
			float4 BRDF3_Unity_PBS1(float3 diffColor, float3 specColor,             float oneMinusReflectivity, float smoothness,
				float3 normal, float3 viewDir, float _Roughness1, float reflect1)
			｛
				float3 reflDir = reflect(viewDir, normal);
				float nl = saturate(dot(normal, _WorldSpaceLightPos0.xyz));
				float nv = saturate(dot(normal, viewDir));
				// Vectorize Pow4 to save instructions
				float2 rlPow4AndFresnelTerm = Pow4(float2(dot(reflDir, _WorldSpaceLightPos0.xyz), 1 - nv));  // use R.L instead of N.H to save couple of instructions
				float rlPow4 = rlPow4AndFresnelTerm.x; // power exponent must match kHorizontalWarpExp in NHxRoughness() function in GeneratedTextures.cpp
				float fresnelTerm = rlPow4AndFresnelTerm.y;
				float grazingTerm = saturate(smoothness + (1 - oneMinusReflectivity));
				float3 color = BRDF3_Direct1(diffColor, specColor, rlPow4, smoothness) * 0.7;
				color *= _LightColor0 * nl;
				float3 floatDir = normalize(_WorldSpaceLightPos0.xyz + viewDir);
				float d = max(0, dot(floatDir, normalize(float3(-normal.x, 2, -normal.z))));
				//color += BRDF3_Indirect1(diffColor, specColor, grazingTerm, fresnelTerm, _Roughness1) * 0.15;
				color += color * pow(d, 128 * reflect1) * normal.y * 6 * reflect1;
				return float4(color, 1);
			｝

float2 depthuv = i.depthuv * 0.5 + 0.5;
#if UNITY_REVERSED_Z 
				depthuv.y = 1 - depthuv.y;
#endif
				float depth = DecodeFloatRGBA(tex2D(DepthTex, depthuv));
#if UNITY_REVERSED_Z 
#else
				depth = depth * 2 - 1;
#endif
				float4 proj = float4(depthuv * 2 - 1, depth, 1);
				float4 world = mul(depthMatV, proj);
				float3 nrml = UnpackNormal(tex2D(_Normal, i.normalUV.xy));
				nrml += UnpackNormal(tex2D(_Normal, i.normalUV.zw));
				float4 uv1 = i.ref;
				uv1.xy += nrml.xy * 0.1;
				float4 refl = tex2Dproj(_ReflectionTex, UNITY_PROJ_COORD(uv1));
				if (i.worldPos.y < world.y / world.w - 1)
				｛
					float diff = world.y / world.w - i.worldPos.y - 1;
					nrml *= max(0, 1 - diff);
					_refract *= max(0, 1 - diff);
				｝
				float4 _Rough = tex2D(_RoughTex, i.uv * 0.5 + nrml.xy * _refract * 0.004);
				float wet = min(1,ComputeWater(_Rough.g, _Rough.ar, _refract) + _Rough.b * _Bump);
				float ref = (1 - wet) * 2.5;
				float4 col = tex2D(_MainTex, i.uv + nrml.xy * _refract * 0.004 * ref);
				float3 specColor = lerp(unity_ColorSpaceDielectricSpec.rgb, col.rgb, _Roughness);
				float oneMinusReflectivity = OneMinusReflectivityFromMetallic1(_Roughness);
				float3 diffColor = col.rgb * oneMinusReflectivity;
				float smoothness = 0.5;
				float dis = distance(_WorldSpaceCameraPos, i.worldPos);
				if (i.worldPos.y < world.y / world.w - 1)
				｛
					float diff1 = world.y / world.w - i.worldPos.y - 1;
					dis += 999999*diff1;
					wet += 0.3 * diff1;
					wet = min(0.7, wet);
				｝

    private void OnWillRenderObject()
    ｛
        if(this.enabled == false)
        ｛
            return;
        ｝
        Camera cam = Camera.current;
        if(!cam || cam != Camera.main)
        ｛
            return;
        ｝
        if(insideWater)
        ｛
            return;
        ｝
        insideWater = true;
        Camera reflectCamera;
        CreateWaterObjects(cam, out reflectCamera);
        Vector3 pos = transform.position;
        Vector3 normal = transform.up;
        UpdateCameraModes(cam, reflectCamera);
        float d = -Vector3.Dot(normal, pos) - clipPlaneOffset;
        Vector4 reflectionPlane = new Vector4(normal.x, normal.y, normal.z, d);
        Matrix4x4 reflection = Matrix4x4.zero;
        CalculateReflectionMatrix(ref reflection, reflectionPlane);
        Vector3 oldpos = cam.transform.position;
        Vector3 newpos = reflection.MultiplyPoint(oldpos);
        reflectCamera.worldToCameraMatrix = cam.worldToCameraMatrix * reflection;
        Vector4 clipPlane = CameraSpacePlane(reflectCamera, pos, normal, 1f);
        reflectCamera.projectionMatrix = cam.CalculateObliqueMatrix(clipPlane);
        reflectCamera.cullingMatrix = cam.projectionMatrix * cam.worldToCameraMatrix;
        reflectCamera.cullingMask = reflectLayers.value;
        reflectCamera.targetTexture = m_reflectionTexture;
        bool oldCulling = GL.invertCulling;
        GL.invertCulling = !oldCulling;
        reflectCamera.transform.position = newpos;
        Vector3 euler = cam.transform.eulerAngles;
        reflectCamera.transform.eulerAngles = new Vector3(-euler.x, euler.y, euler.z);
        reflectCamera.Render();
        reflectCamera.transform.position = oldpos;
        GL.invertCulling = oldCulling;
        render.sharedMaterial.SetTexture("_ReflectionTex", m_reflectionTexture);
        insideWater = false;
    ｝