227 lines
6.7 KiB
C#
227 lines
6.7 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using UltimateWater.Utils;
|
|
using UnityEngine;
|
|
|
|
namespace UltimateWater.Internal
|
|
{
|
|
[Serializable]
|
|
public class WaterRadialGrid : WaterPrimitiveBase
|
|
{
|
|
private static float _WidthCorrection;
|
|
|
|
private static readonly int[][] _HorizontalVerticesToVertexCount;
|
|
|
|
static WaterRadialGrid()
|
|
{
|
|
_WidthCorrection = 5f;
|
|
_HorizontalVerticesToVertexCount = new int[17][];
|
|
for (int i = 0; i < _HorizontalVerticesToVertexCount.Length; i++)
|
|
{
|
|
_HorizontalVerticesToVertexCount[i] = new int[600];
|
|
float num = ((float)(i + 1) * 5f - 1f) * ((float)System.Math.PI / 180f);
|
|
Vector2 normalized = new Vector2(Mathf.Sin(0f - num), Mathf.Cos(0f - num)).normalized;
|
|
for (int j = 0; j < 600; j++)
|
|
{
|
|
int num2 = j + 2;
|
|
float f = num * (2f / (float)(num2 - 1) - 1f);
|
|
Vector2 normalized2 = new Vector2(Mathf.Sin(f), Mathf.Cos(f)).normalized;
|
|
float num3 = 1f;
|
|
int num4 = 0;
|
|
float num5 = Vector2.Distance(normalized, normalized2);
|
|
while (num3 >= 0.005f)
|
|
{
|
|
num4++;
|
|
num3 -= num5 * num3;
|
|
}
|
|
num4 += 2;
|
|
_HorizontalVerticesToVertexCount[i][j] = num2 * num4;
|
|
}
|
|
}
|
|
}
|
|
|
|
public override Mesh[] GetTransformedMeshes(Camera camera, out Matrix4x4 matrix, int vertexCount, bool volume)
|
|
{
|
|
int num2;
|
|
if (camera != null)
|
|
{
|
|
float num = 2f * Mathf.Atan(Mathf.Tan(camera.fieldOfView * 0.5f * ((float)System.Math.PI / 180f)) * camera.aspect) * 57.29578f;
|
|
num2 = ((!camera.orthographic) ? Mathf.CeilToInt(num * 0.5f * 0.2f - 0.8f) : 14);
|
|
if (num2 >= _HorizontalVerticesToVertexCount.Length)
|
|
{
|
|
num2 = _HorizontalVerticesToVertexCount.Length - 1;
|
|
}
|
|
matrix = GetMatrix(camera, ((float)(num2 + 1) * 5f - 1f) * ((float)System.Math.PI / 180f));
|
|
}
|
|
else
|
|
{
|
|
matrix = Matrix4x4.identity;
|
|
num2 = 14;
|
|
}
|
|
int num3 = vertexCount | (num2 << 26);
|
|
if (volume)
|
|
{
|
|
num3 = -num3;
|
|
}
|
|
CachedMeshSet value;
|
|
if (!_Cache.TryGetValue(num3, out value))
|
|
{
|
|
value = (_Cache[num3] = new CachedMeshSet(CreateMeshes(vertexCount, volume, num2)));
|
|
}
|
|
else
|
|
{
|
|
value.Update();
|
|
}
|
|
return value.Meshes;
|
|
}
|
|
|
|
protected override Mesh[] CreateMeshes(int vertexCount, bool volume)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
protected Mesh[] CreateMeshes(int vertexCount, bool volume, int fovIndex)
|
|
{
|
|
int num = 0;
|
|
int[] array = _HorizontalVerticesToVertexCount[fovIndex];
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
if (array[i] > vertexCount)
|
|
{
|
|
num = i + 1;
|
|
break;
|
|
}
|
|
}
|
|
int num2 = Mathf.FloorToInt((float)vertexCount / (float)num);
|
|
int num3 = num2;
|
|
List<Mesh> list = new List<Mesh>();
|
|
List<Vector3> list2 = new List<Vector3>();
|
|
List<int> list3 = new List<int>();
|
|
int num4 = 0;
|
|
int num5 = 0;
|
|
float num6 = ((float)(fovIndex + 1) * 5f - 1f) * ((float)System.Math.PI / 180f);
|
|
Vector2[] array2 = new Vector2[num];
|
|
for (int j = 0; j < num; j++)
|
|
{
|
|
float num7 = (float)j / (float)(num - 1) * 2f - 1f;
|
|
num7 = ((!(num7 >= 0f)) ? (-1f - Mathf.Sin((num7 - 1f) * (float)System.Math.PI * 0.5f)) : (1f + Mathf.Sin((num7 - 1f) * (float)System.Math.PI * 0.5f)));
|
|
num7 *= num6;
|
|
array2[j] = new Vector2(Mathf.Sin(num7), Mathf.Cos(num7)).normalized;
|
|
}
|
|
float num8 = 1f;
|
|
float num9 = 1f;
|
|
float num10 = Vector2.Distance(array2[0], array2[1]);
|
|
if (volume)
|
|
{
|
|
while (num8 > 0.4f)
|
|
{
|
|
num9 = num8;
|
|
num8 -= num10 * num8;
|
|
num3--;
|
|
}
|
|
}
|
|
for (int k = 0; k < num3; k++)
|
|
{
|
|
for (int l = 0; l < num; l++)
|
|
{
|
|
Vector2 vector = array2[l] * num8;
|
|
if (k == num3 - 1)
|
|
{
|
|
list2.Add(new Vector3(0f, 0f, 0f));
|
|
}
|
|
else if (k > 1 || !volume)
|
|
{
|
|
list2.Add(new Vector3(vector.x, 0f, vector.y));
|
|
}
|
|
else if (k == 1)
|
|
{
|
|
vector = array2[l] * (1f - num10);
|
|
list2.Add(new Vector3(vector.x * 10f, -0.9f, vector.y) * 0.5f);
|
|
}
|
|
else
|
|
{
|
|
vector = array2[l];
|
|
list2.Add(new Vector3(vector.x * 10f, -0.9f, vector.y * -10f) * 0.5f);
|
|
}
|
|
if (l != 0 && k != 0 && num4 > num)
|
|
{
|
|
list3.Add(num4);
|
|
list3.Add(num4 - 1);
|
|
list3.Add(num4 - num - 1);
|
|
list3.Add(num4 - num);
|
|
}
|
|
num4++;
|
|
if (num4 == 65000)
|
|
{
|
|
Mesh item = CreateMesh(list2.ToArray(), list3.ToArray(), string.Format("Radial Grid {0}x{1} - {2:00}", num, num2, num5));
|
|
list.Add(item);
|
|
l--;
|
|
k--;
|
|
num8 = num9;
|
|
num4 = 0;
|
|
list2.Clear();
|
|
list3.Clear();
|
|
num5++;
|
|
}
|
|
}
|
|
num9 = num8;
|
|
num8 -= num10 * num8;
|
|
}
|
|
if (num4 != 0)
|
|
{
|
|
Mesh item2 = CreateMesh(list2.ToArray(), list3.ToArray(), string.Format("Radial Grid {0}x{1} - {2:00}", num, num2, num5));
|
|
list.Add(item2);
|
|
}
|
|
return list.ToArray();
|
|
}
|
|
|
|
protected Matrix4x4 GetMatrix(Camera camera, float fov)
|
|
{
|
|
float y = _Water.transform.position.y;
|
|
Vector3 vector = UltimateWater.Utils.Math.ViewportWaterPerpendicular(camera);
|
|
Vector3 vector2 = UltimateWater.Utils.Math.ViewportWaterRight(camera);
|
|
float num;
|
|
if (vector.IsNaN() || vector2.IsNaN())
|
|
{
|
|
num = 2f * camera.worldToCameraMatrix.MultiplyPoint(new Vector3(0f, y, 0f)).magnitude;
|
|
}
|
|
else
|
|
{
|
|
Vector3 vector3 = UltimateWater.Utils.Math.RaycastPlane(camera, y, vector - vector2);
|
|
num = UltimateWater.Utils.Math.RaycastPlane(camera, y, vector + vector2).x - vector3.x;
|
|
if (num < 0f)
|
|
{
|
|
num = 0f - num;
|
|
}
|
|
}
|
|
float f = Mathf.Clamp01(Vector3.Dot(camera.transform.forward, Vector3.down) - 0.5f);
|
|
float value = _WidthCorrection * Mathf.Pow(f, 1f) / camera.aspect;
|
|
num *= 1f + Mathf.Clamp(value, 0f, float.MaxValue);
|
|
float num2 = camera.farClipPlane;
|
|
if (WaterProjectSettings.Instance.ClipWaterCameraRange)
|
|
{
|
|
num2 = Mathf.Min(camera.farClipPlane, WaterProjectSettings.Instance.CameraClipRange);
|
|
}
|
|
Vector3 position = camera.transform.position;
|
|
float num3 = Mathf.Tan(fov * 0.5f);
|
|
float num4 = 0f - (num + Mathf.Max(0f, num2 * 0.005f - camera.nearClipPlane) + (_Water.MaxHorizontalDisplacement + _Water.MaxVerticalDisplacement) / num3);
|
|
if (camera.orthographic)
|
|
{
|
|
num4 -= camera.orthographicSize * 3.2f;
|
|
}
|
|
float y2 = camera.transform.forward.y;
|
|
Vector3 vector4 = ((!(y2 < -0.98f) && !(y2 > 0.98f)) ? camera.transform.forward : (-camera.transform.up));
|
|
float num5 = Mathf.Sqrt(vector4.x * vector4.x + vector4.z * vector4.z);
|
|
vector4.x /= num5;
|
|
vector4.z /= num5;
|
|
float num6 = num2 - num4;
|
|
return Matrix4x4.TRS(new Vector3(position.x + vector4.x * num4, y, position.z + vector4.z * num4), Quaternion.AngleAxis(Mathf.Atan2(vector4.x, vector4.z) * 57.29578f, Vector3.up), new Vector3(num6, num6, num6));
|
|
}
|
|
|
|
protected override Matrix4x4 GetMatrix(Camera camera)
|
|
{
|
|
throw new InvalidOperationException();
|
|
}
|
|
}
|
|
}
|