using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using Microsoft.CodeAnalysis;
using Unity.Collections;
using UnityEditor;
using UnityEngine;
using UnityEngine.Experimental.Rendering;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.Video;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("TolianWaterSystem")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("A template for Lethal Company")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+646ca23083ece7cd6b0810d9c33b0fdcd17eeab1")]
[assembly: AssemblyProduct("TolianWaterSystem")]
[assembly: AssemblyTitle("TolianWaterSystem")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
public class FFT_CPU : MonoBehaviour
{
public enum SizeSetting
{
Size_32 = 0x20,
Size_64 = 0x40,
Size_128 = 0x80
}
public class OutputFFTData
{
public Color[] OutputPixels;
}
public bool IsDetailed;
public SizeSetting Size = SizeSetting.Size_64;
[Range(0f, 1f)]
public float WindDirection = 0.3f;
[Range(0.2f, 10f)]
public float WindSpeed = 5f;
[Range(0.25f, 1.5f)]
public float Choppines = 0.85f;
[Range(1f, 100f)]
public float WaterScale = 10f;
[Range(0f, 2f)]
public float TimeScale = 1f;
public Texture2D DisplaceTexture;
public RenderTexture NormalTexture;
public Material WaterMaterial;
private const float DomainSize = 20f;
private float prevWindDirection;
private float prevWindSpeed;
private int prevSize;
private FFT_CPU_Spectrum spectrumCpu;
private OutputFFTData outputFftData;
private FFT_CPU_Simulation fftCpu1;
private FFT_CPU_Simulation fftCpu2;
private FFT_CPU_Simulation fftCpu3;
private Vector2[] butterflyRawData;
private Material normalComputeMaterial;
private Thread t0;
private Thread t1;
private Thread t2;
private Thread t3;
private float currentTime;
private bool canUpdate = true;
private bool isDoneComputeFFT_1;
private bool isDoneComputeFFT_2;
private bool isDoneComputeFFT_3;
private AutoResetEvent[] startHandle;
private void InitializeResources()
{
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Expected O, but got Unknown
//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
//IL_00dc: Expected O, but got Unknown
//IL_0123: Unknown result type (might be due to invalid IL or missing references)
//IL_012d: Expected O, but got Unknown
isDoneComputeFFT_1 = false;
isDoneComputeFFT_2 = false;
isDoneComputeFFT_3 = false;
canUpdate = true;
outputFftData = new OutputFFTData();
fftCpu1 = new FFT_CPU_Simulation((int)Size, outputFftData);
fftCpu2 = new FFT_CPU_Simulation((int)Size, outputFftData);
fftCpu3 = new FFT_CPU_Simulation((int)Size, outputFftData);
prevSize = (int)Size;
prevWindDirection = WindDirection;
prevWindSpeed = WindSpeed;
normalComputeMaterial = new Material(WaterShadersSingleton.Instance.ComputeNormalShader);
if ((Object)(object)NormalTexture != (Object)null)
{
NormalTexture.Release();
}
NormalTexture = new RenderTexture((int)Size, (int)Size, 0, (RenderTextureFormat)2, (RenderTextureReadWrite)1);
((Texture)NormalTexture).filterMode = (FilterMode)1;
((Texture)NormalTexture).wrapMode = (TextureWrapMode)0;
if ((Object)(object)DisplaceTexture != (Object)null)
{
Object.DestroyImmediate((Object)(object)DisplaceTexture);
}
DisplaceTexture = new Texture2D((int)Size, (int)Size, (TextureFormat)17, false, true);
InitializeButterfly((int)Size);
spectrumCpu = new FFT_CPU_Spectrum((int)Size);
spectrumCpu.InitializeSpectrum(20f, WindSpeed, WindDirection, (int)Size);
if (startHandle == null)
{
startHandle = new AutoResetEvent[4];
startHandle[0] = new AutoResetEvent(initialState: true);
startHandle[1] = new AutoResetEvent(initialState: false);
startHandle[2] = new AutoResetEvent(initialState: false);
startHandle[3] = new AutoResetEvent(initialState: false);
}
}
private void InitializeButterfly(int size)
{
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
int num = Mathf.RoundToInt(Mathf.Log((float)size, 2f));
butterflyRawData = (Vector2[])(object)new Vector2[size * num];
int num2 = 1;
int num3 = size >> 1;
for (int i = 0; i < num; i++)
{
int num4 = i * size;
int num5 = 0;
int num6 = 2 * num2;
for (int j = 0; j < num3; j++)
{
float num7 = 0f;
for (int k = num5; k < num6; k += 2)
{
float num8 = MathF.PI * 2f * num7 * (float)num3 / (float)size;
float num9 = Mathf.Cos(num8);
float num10 = Mathf.Sin(num8);
butterflyRawData[num4 + k / 2] = new Vector2(num9, 0f - num10);
butterflyRawData[num4 + k / 2 + num2] = new Vector2(0f - num9, num10);
num7 += 1f;
}
num5 += 4 * num2;
num6 = num5 + 2 * num2;
}
num3 >>= 1;
num2 <<= 1;
}
}
private void StartThreads()
{
if (startHandle != null)
{
startHandle[0].Set();
}
if (t0 == null)
{
t0 = new Thread(thread0);
t0.Start();
}
if (t1 == null)
{
t1 = new Thread(thread1);
t1.Start();
}
if (t2 == null)
{
t2 = new Thread(thread2);
t2.Start();
}
if (t3 == null)
{
t3 = new Thread(thread3);
t3.Start();
}
}
private void RestartCompute()
{
ReleaseAll();
InitializeResources();
StartThreads();
}
private void ReleaseAll()
{
canUpdate = false;
if (t0 != null)
{
t0.Abort();
}
t0 = null;
if (t1 != null)
{
t1.Abort();
}
t1 = null;
if (t2 != null)
{
t2.Abort();
}
t2 = null;
if (t3 != null)
{
t3.Abort();
}
t3 = null;
if ((Object)(object)DisplaceTexture != (Object)null)
{
Object.DestroyImmediate((Object)(object)DisplaceTexture);
}
if ((Object)(object)NormalTexture != (Object)null)
{
NormalTexture.Release();
}
if (IsDetailed)
{
Shader.DisableKeyword("KW_DETAIL_FFT");
}
}
private void thread0()
{
while (canUpdate)
{
startHandle[0].WaitOne();
isDoneComputeFFT_1 = false;
isDoneComputeFFT_2 = false;
isDoneComputeFFT_3 = false;
spectrumCpu.GetUpdatedSpectrum(currentTime, (int)Size);
startHandle[1].Set();
startHandle[2].Set();
startHandle[3].Set();
}
}
private void thread1()
{
while (canUpdate)
{
startHandle[1].WaitOne();
fftCpu1.Compute(spectrumCpu.ResultDisplaceZ, butterflyRawData, 0, (int)Size);
isDoneComputeFFT_1 = true;
}
}
private void thread2()
{
while (canUpdate)
{
startHandle[2].WaitOne();
fftCpu2.Compute(spectrumCpu.ResultHeight, butterflyRawData, 1, (int)Size);
isDoneComputeFFT_2 = true;
}
}
private void thread3()
{
while (canUpdate)
{
startHandle[3].WaitOne();
fftCpu3.Compute(spectrumCpu.ResultDisplaceX, butterflyRawData, 2, (int)Size);
isDoneComputeFFT_3 = true;
}
}
private void ReadThreadsData()
{
if (isDoneComputeFFT_1 && isDoneComputeFFT_2 && isDoneComputeFFT_3)
{
DisplaceTexture.SetPixels(outputFftData.OutputPixels);
DisplaceTexture.Apply();
normalComputeMaterial.SetTexture("_DispTex", (Texture)(object)DisplaceTexture);
int num = Mathf.RoundToInt(Mathf.Log((float)Size, 2f)) - 4;
normalComputeMaterial.SetFloat("_SizeLog", (float)num);
normalComputeMaterial.SetFloat("_Choppines", Choppines);
normalComputeMaterial.SetFloat("_WindSpeed", WindSpeed);
NormalTexture.DiscardContents();
RenderTexture active = RenderTexture.active;
if (!Application.isPlaying)
{
RenderTexture.active = null;
}
Graphics.Blit((Texture)null, NormalTexture, normalComputeMaterial);
if (!Application.isPlaying)
{
RenderTexture.active = active;
}
startHandle[0].Set();
}
}
private void UpdateFFT()
{
//IL_043e: Unknown result type (might be due to invalid IL or missing references)
//IL_043f: Unknown result type (might be due to invalid IL or missing references)
//IL_0425: Unknown result type (might be due to invalid IL or missing references)
//IL_0426: Unknown result type (might be due to invalid IL or missing references)
//IL_027f: Unknown result type (might be due to invalid IL or missing references)
//IL_0280: Unknown result type (might be due to invalid IL or missing references)
//IL_0266: Unknown result type (might be due to invalid IL or missing references)
//IL_0267: Unknown result type (might be due to invalid IL or missing references)
if (prevSize != (int)Size)
{
prevSize = (int)Size;
RestartCompute();
}
else if (Mathf.Abs(prevWindDirection - WindDirection) > 0.001f || Mathf.Abs(prevWindSpeed - WindSpeed) > 0.01f)
{
prevWindDirection = WindDirection;
prevWindSpeed = WindSpeed;
spectrumCpu.InitializeSpectrum(20f, WindSpeed, WindDirection, (int)Size);
}
currentTime += Time.deltaTime * Mathf.Lerp(TimeScale, TimeScale * 0.5f, WaterScale / 100f);
ReadThreadsData();
Vector3 val = default(Vector3);
((Vector3)(ref val))..ctor(WaterScale * Choppines / 20f, 1f, WaterScale * Choppines / 20f);
if (!IsDetailed)
{
if ((Object)(object)WaterMaterial == (Object)null)
{
Shader.SetGlobalTexture("KW_DispTex", (Texture)(object)DisplaceTexture);
}
else
{
WaterMaterial.SetTexture("KW_DispTex", (Texture)(object)DisplaceTexture);
}
if ((Object)(object)WaterMaterial == (Object)null)
{
Shader.SetGlobalTexture("KW_NormTex", (Texture)(object)NormalTexture);
}
else
{
WaterMaterial.SetTexture("KW_NormTex", (Texture)(object)NormalTexture);
}
if ((Object)(object)WaterMaterial == (Object)null)
{
Shader.SetGlobalFloat("KW_WindSpeed", WindSpeed);
}
else
{
WaterMaterial.SetFloat("KW_WindSpeed", WindSpeed);
}
if ((Object)(object)WaterMaterial == (Object)null)
{
Shader.SetGlobalFloat("KW_Choppines", Choppines);
}
else
{
WaterMaterial.SetFloat("KW_Choppines", Choppines);
}
if ((Object)(object)WaterMaterial == (Object)null)
{
Shader.SetGlobalFloat("KW_FFTScale", WaterScale);
}
else
{
WaterMaterial.SetFloat("KW_FFTScale", WaterScale);
}
if ((Object)(object)WaterMaterial == (Object)null)
{
Shader.SetGlobalVector("KW_DisplaceScale", Vector4.op_Implicit(val));
}
else
{
WaterMaterial.SetVector("KW_DisplaceScale", Vector4.op_Implicit(val));
}
int num = Mathf.RoundToInt(Mathf.Log((float)Size, 2f)) - 5;
if ((Object)(object)WaterMaterial == (Object)null)
{
Shader.SetGlobalFloat("KW_NormalLod", (float)num);
}
else
{
WaterMaterial.SetFloat("KW_NormalLod", (float)num);
}
return;
}
if ((Object)(object)WaterMaterial == (Object)null)
{
Shader.SetGlobalTexture("KW_DispTexDetail", (Texture)(object)DisplaceTexture);
}
else
{
WaterMaterial.SetTexture("KW_DispTexDetail", (Texture)(object)DisplaceTexture);
}
if ((Object)(object)WaterMaterial == (Object)null)
{
Shader.SetGlobalTexture("KW_NormTexDetail", (Texture)(object)NormalTexture);
}
else
{
WaterMaterial.SetTexture("KW_NormTexDetail", (Texture)(object)NormalTexture);
}
if ((Object)(object)WaterMaterial == (Object)null)
{
Shader.SetGlobalFloat("KW_WindSpeedDetail", WindSpeed);
}
else
{
WaterMaterial.SetFloat("KW_WindSpeedDetail", WindSpeed);
}
if ((Object)(object)WaterMaterial == (Object)null)
{
Shader.SetGlobalFloat("KW_ChoppinesDetail", Choppines);
}
else
{
WaterMaterial.SetFloat("KW_ChoppinesDetail", Choppines);
}
if ((Object)(object)WaterMaterial == (Object)null)
{
Shader.SetGlobalFloat("KW_FFTScaleDetail", WaterScale);
}
else
{
WaterMaterial.SetFloat("KW_FFTScaleDetail", WaterScale);
}
if ((Object)(object)WaterMaterial == (Object)null)
{
Shader.SetGlobalVector("KW_DisplaceScaleDetail", Vector4.op_Implicit(val));
}
else
{
WaterMaterial.SetVector("KW_DisplaceScaleDetail", Vector4.op_Implicit(val));
}
int num2 = Mathf.RoundToInt(Mathf.Log((float)Size, 2f)) - 5;
if ((Object)(object)WaterMaterial == (Object)null)
{
Shader.SetGlobalFloat("KW_NormalLodDetail", (float)num2);
}
else
{
WaterMaterial.SetFloat("KW_NormalLodDetail", (float)num2);
}
Shader.EnableKeyword("KW_DETAIL_FFT");
}
private void OnEnable()
{
RestartCompute();
}
private void OnDisable()
{
ReleaseAll();
}
private void OnDestroy()
{
ReleaseAll();
}
private void Update()
{
UpdateFFT();
}
}
public class FFT_CPU_Simulation
{
private struct ButterflyHashProperties
{
public int x;
public int y;
public bool pingPong;
public int index;
public ButterflyHashProperties(int X, int Y, bool Pingpong, int Index)
{
x = X;
y = Y;
pingPong = Pingpong;
index = Index;
}
}
private Vector2[] input_H;
private Vector2[] complex_H;
private Vector2[] intermediates_H;
private Vector2[] scratch_H;
private Vector2[] inpButt;
private bool firstThreadDone;
private bool secondThreadDone;
private int passes;
private int size;
private ButterflyHashProperties[,] hashFunction;
private FFT_CPU.OutputFFTData currentBuffer;
public FFT_CPU_Simulation(int Size, FFT_CPU.OutputFFTData outputFftData)
{
currentBuffer = outputFftData;
Initialize(Size);
}
private void Initialize(int Size)
{
size = Size;
passes = Mathf.RoundToInt(Mathf.Log((float)size, 2f));
intermediates_H = (Vector2[])(object)new Vector2[size];
scratch_H = (Vector2[])(object)new Vector2[size];
complex_H = (Vector2[])(object)new Vector2[size * size];
hashFunction = new ButterflyHashProperties[size, passes];
for (int i = 0; i < size; i++)
{
for (int j = 0; j < passes; j++)
{
hashFunction[i, j] = ButteflyHashFunction(i, j);
}
}
if (currentBuffer.OutputPixels == null || currentBuffer.OutputPixels.Length != size * size)
{
currentBuffer.OutputPixels = (Color[])(object)new Color[size * size];
}
}
public void Compute(Vector2[] inpHeight, Vector2[] inpButterfly, int colorChannel, int currentSize)
{
if (currentSize != size)
{
Initialize(currentSize);
}
input_H = inpHeight;
inpButt = inpButterfly;
FFT_H();
FFT_V(colorChannel);
}
private void FFT_H()
{
bool flag = passes % 2 == 0;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
int num = i * size + j;
intermediates_H[j].x = input_H[num].x;
intermediates_H[j].y = 0f - input_H[num].y;
}
for (int k = 0; k < passes; k++)
{
for (int l = 0; l < size; l++)
{
ButterflyHashProperties butterflyHashProperties = hashFunction[l, k];
if (butterflyHashProperties.pingPong)
{
scratch_H[l].x = inpButt[butterflyHashProperties.index].x * intermediates_H[butterflyHashProperties.y].x - inpButt[butterflyHashProperties.index].y * intermediates_H[butterflyHashProperties.y].y + intermediates_H[butterflyHashProperties.x].x;
scratch_H[l].y = inpButt[butterflyHashProperties.index].y * intermediates_H[butterflyHashProperties.y].x + inpButt[butterflyHashProperties.index].x * intermediates_H[butterflyHashProperties.y].y + intermediates_H[butterflyHashProperties.x].y;
}
else
{
intermediates_H[l].x = inpButt[butterflyHashProperties.index].x * scratch_H[butterflyHashProperties.y].x - inpButt[butterflyHashProperties.index].y * scratch_H[butterflyHashProperties.y].y + scratch_H[butterflyHashProperties.x].x;
intermediates_H[l].y = inpButt[butterflyHashProperties.index].y * scratch_H[butterflyHashProperties.y].x + inpButt[butterflyHashProperties.index].x * scratch_H[butterflyHashProperties.y].y + scratch_H[butterflyHashProperties.x].y;
}
}
}
for (int m = 0; m < size; m++)
{
int num = i * size + m;
if (flag)
{
complex_H[num].x = intermediates_H[m].x;
complex_H[num].y = intermediates_H[m].y;
}
else
{
complex_H[num].x = scratch_H[m].x;
complex_H[num].y = scratch_H[m].y;
}
}
}
}
private void FFT_V(int colorChannel)
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
//IL_034a: Unknown result type (might be due to invalid IL or missing references)
//IL_0376: Unknown result type (might be due to invalid IL or missing references)
//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
bool flag = passes % 2 == 0;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
intermediates_H[j] = complex_H[j * size + i];
}
for (int k = 0; k < passes; k++)
{
for (int l = 0; l < size; l++)
{
ButterflyHashProperties butterflyHashProperties = hashFunction[l, k];
if (butterflyHashProperties.pingPong)
{
scratch_H[l].x = inpButt[butterflyHashProperties.index].x * intermediates_H[butterflyHashProperties.y].x - inpButt[butterflyHashProperties.index].y * intermediates_H[butterflyHashProperties.y].y + intermediates_H[butterflyHashProperties.x].x;
scratch_H[l].y = inpButt[butterflyHashProperties.index].y * intermediates_H[butterflyHashProperties.y].x + inpButt[butterflyHashProperties.index].x * intermediates_H[butterflyHashProperties.y].y + intermediates_H[butterflyHashProperties.x].y;
}
else
{
intermediates_H[l].x = inpButt[butterflyHashProperties.index].x * scratch_H[butterflyHashProperties.y].x - inpButt[butterflyHashProperties.index].y * scratch_H[butterflyHashProperties.y].y + scratch_H[butterflyHashProperties.x].x;
intermediates_H[l].y = inpButt[butterflyHashProperties.index].y * scratch_H[butterflyHashProperties.y].x + inpButt[butterflyHashProperties.index].x * scratch_H[butterflyHashProperties.y].y + scratch_H[butterflyHashProperties.x].y;
}
}
}
for (int m = 0; m < size; m++)
{
Vector2 val = (flag ? intermediates_H[m] : scratch_H[m]);
float num = (((i + m) % 2 == 1) ? (-1f) : 1f);
switch (colorChannel)
{
case 0:
currentBuffer.OutputPixels[m * size + i].r = num * val.x;
break;
case 1:
currentBuffer.OutputPixels[m * size + i].g = num * val.x;
break;
case 2:
currentBuffer.OutputPixels[m * size + i].b = num * val.x;
break;
}
}
}
}
private ButterflyHashProperties ButteflyHashFunction(int coord, int passIndex)
{
int num = 1 << passIndex;
int num2;
int num3;
if (coord / num % 2 == 1)
{
num2 = coord - num;
num3 = coord;
}
else
{
num2 = coord;
num3 = coord + num;
}
if (passIndex == 0)
{
num2 = (int)(Reverse(num2) >> 32 - passes);
num3 = (int)(Reverse(num3) >> 32 - passes);
}
bool pingpong = passIndex % 2 == 0;
int index = coord + passIndex * size;
return new ButterflyHashProperties(num2, num3, pingpong, index);
}
private uint Reverse(int x1)
{
uint num = (uint)x1;
uint num2 = 0u;
for (int i = 0; i < 32; i++)
{
num2 <<= 1;
num2 |= num & 1u;
num >>= 1;
}
return num2;
}
}
public class FFT_CPU_Spectrum
{
private struct UpdateSpectrumHashProperties
{
public float k_x;
public float k_y;
public float w;
public int index;
}
private UpdateSpectrumHashProperties[,] hashFunc;
private float[] sinHash;
private float[] cosHash;
private Vector4[] initColors;
public Vector2[] ResultHeight;
public Vector2[] ResultDisplaceX;
public Vector2[] ResultDisplaceZ;
private float INVPI2 = 2f / MathF.PI;
private float HPI = MathF.PI / 2f;
private float PI2 = MathF.PI * 2f;
private float PI4 = 0.33661976f;
private int rngState;
private const float Gravity = 9.81f;
private int size;
private UpdateSpectrumHashProperties hash;
private float scaledTime;
private int index;
private float hX;
private float hY;
private float sw;
private float cw;
public FFT_CPU_Spectrum(int Size)
{
Initialize(Size);
}
private void Initialize(int Size)
{
size = Size;
sinHash = new float[6284];
cosHash = new float[6284];
for (int i = 0; i < 6284; i++)
{
sinHash[i] = Mathf.Sin((float)i / 100f);
cosHash[i] = Mathf.Cos((float)i / 100f);
}
initColors = (Vector4[])(object)new Vector4[size * size];
ResultHeight = (Vector2[])(object)new Vector2[size * size];
ResultDisplaceX = (Vector2[])(object)new Vector2[size * size];
ResultDisplaceZ = (Vector2[])(object)new Vector2[size * size];
}
public void InitializeSpectrum(float domainSize, float windSpeed, float direction, int currentSize)
{
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
if (size != currentSize)
{
Initialize(currentSize);
}
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
int num = size / 2;
int num2 = i - num;
int num3 = j - num;
if (num2 != 0 || num3 != 0)
{
float num4 = PI2 * (float)num2 / domainSize;
float num5 = PI2 * (float)num3 / domainSize;
Vector2 val = new Vector2(num4, num5);
float magnitude = ((Vector2)(ref val)).magnitude;
rngState = WangHash(j * size + i);
float num6 = Mathf.Sqrt(Mathf.Abs(9.81f * magnitude));
float num7 = 9.81f / (2f * num6);
float num8 = PiersonMoskowitzSpectrum(num6, windSpeed);
float num9 = num8;
float num10 = num8;
float num11 = PI2 / domainSize;
float theta = Mathf.Atan2(0f - num5, num4);
float theta2 = Mathf.Atan2(num5, 0f - num4);
num9 *= PosCosSquaredDirectionalSpreading(theta, direction);
num10 *= PosCosSquaredDirectionalSpreading(theta2, direction);
num9 *= num11 * num11 * num7 / magnitude;
num10 *= num11 * num11 * num7 / magnitude;
float num12 = RandGauss() * Mathf.Sqrt(Mathf.Abs(num9) * 2f);
float num13 = RandGauss() * Mathf.Sqrt(Mathf.Abs(num10) * 2f);
float num14 = RandFloat() * PI2;
float num15 = RandFloat() * PI2;
float num16 = num12 * Mathf.Cos(num14);
float num17 = num12 * (0f - Mathf.Sin(num14));
float num18 = num13 * Mathf.Cos(num15);
float num19 = num13 * (0f - Mathf.Sin(num15));
initColors[j * size + i] = new Vector4(num16, num17, num18, num19);
}
}
}
hashFunc = new UpdateSpectrumHashProperties[size, size];
for (int k = 0; k < size; k++)
{
for (int l = 0; l < size; l++)
{
hashFunc[k, l] = UpdateHashFunc(k, l, domainSize);
}
}
}
public void GetUpdatedSpectrum(float time, int currentSize)
{
scaledTime = time / 10f;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
hash = hashFunc[i, j];
index = (int)(hash.w * scaledTime % PI2 * 1000f);
sw = sinHash[index];
cw = cosHash[index];
index = hash.index;
hX = initColors[index].x * cw - initColors[index].y * (0f - sw) + initColors[index].z * cw - initColors[index].w * sw;
hY = initColors[index].x * (0f - sw) + initColors[index].y * cw + initColors[index].z * sw + initColors[index].w * cw;
ResultHeight[index].x = hX;
ResultHeight[index].y = hY;
ResultDisplaceX[index].x = (0f - hY) * hash.k_x;
ResultDisplaceX[index].y = hX * hash.k_x;
ResultDisplaceZ[index].x = (0f - hY) * hash.k_y;
ResultDisplaceZ[index].y = hX * hash.k_y;
}
}
}
private int WangHash(int seed)
{
seed = seed ^ 0x3D ^ (seed >> 16);
seed *= 9;
seed ^= seed >> 4;
seed *= 668265261;
seed ^= seed >> 15;
return seed;
}
private int Rand()
{
rngState ^= rngState << 13;
rngState ^= rngState >> 17;
rngState ^= rngState << 5;
return Mathf.Abs(rngState);
}
private float RandFloat()
{
return (float)Rand() / 4.2949673E+09f;
}
private float RandGauss()
{
float num = RandFloat();
float num2 = RandFloat();
if (num < 1E-06f)
{
num = 1E-06f;
}
return Mathf.Sqrt(-2f * Mathf.Log(num)) * Mathf.Cos(PI2 * num2);
}
private float PiersonMoskowitzSpectrum(float w, float windSpeed)
{
float wm = 8.5347f / windSpeed;
return AlphaBetaSpectrum(0.0081f, 1.291f, 9.81f, w, wm);
}
private float AlphaBetaSpectrum(float A, float B, float g, float w, float wm)
{
return A * g * g / Mathf.Pow(w, 5f) * Mathf.Exp((0f - B) * Mathf.Pow(wm / w, 4f));
}
private float PosCosSquaredDirectionalSpreading(float theta, float direction)
{
if (theta > 0f - HPI && theta < HPI)
{
float num = Mathf.Cos(theta);
return INVPI2 * (num * num) * (1f - direction) + PI4 * direction;
}
return PI4 * direction;
}
private UpdateSpectrumHashProperties UpdateHashFunc(int x, int y, float domainSize)
{
int num = size / 2;
int num2 = x - num;
int num3 = y - num;
float num4 = PI2 * (float)num2 / domainSize;
float num5 = PI2 * (float)num3 / domainSize;
float num6 = Mathf.Sqrt(num4 * num4 + num5 * num5);
float w = Mathf.Sqrt(Mathf.Abs(9.81f * num6));
num6 += 1E-05f;
num4 /= num6;
num5 /= num6;
int num7 = x * size + y;
UpdateSpectrumHashProperties result = default(UpdateSpectrumHashProperties);
result.index = num7;
result.k_x = num4;
result.k_y = num5;
result.w = w;
return result;
}
}
public class FFT_GPU : MonoBehaviour
{
public enum SizeSetting
{
Size_32 = 0x20,
Size_64 = 0x40,
Size_128 = 0x80,
Size_256 = 0x100,
Size_512 = 0x200
}
public enum LodPrefix
{
LOD0,
LOD1,
LOD2
}
public RenderTexture DisplaceTexture;
public RenderTexture NormalTexture;
private RenderTexture spectrumInitRenderTexture;
private RenderTexture spectrumHeight;
private RenderTexture spectrumDisplaceX;
private RenderTexture spectrumDisplaceZ;
private RenderTexture fftTemp1;
private RenderTexture fftTemp2;
private RenderTexture fftTemp3;
private Material normalComputeMaterial;
private ComputeShader spectrumShader;
private ComputeShader shaderFFT;
private Texture2D texButterfly;
private float prevWindTurbulence;
private float prevWindSpeed;
private float prevWindRotation;
private float currentHeightDataDomainScale;
private int kernelSpectrumInit;
private int kernelSpectrumUpdate;
private Color[] butterflyColors;
private bool isInitialized = false;
private int ID_DispTex = Shader.PropertyToID("KW_DispTex");
private int ID_DispTex1 = Shader.PropertyToID("KW_DispTex_LOD1");
private int ID_DispTex2 = Shader.PropertyToID("KW_DispTex_LOD2");
private int ID_NormTex = Shader.PropertyToID("KW_NormTex");
private int ID_LeanTex = Shader.PropertyToID("KW_LeanTex");
private int ID_NormTex1 = Shader.PropertyToID("KW_NormTex_LOD1");
private int ID_NormTex2 = Shader.PropertyToID("KW_NormTex_LOD2");
private int ID_MipCount = Shader.PropertyToID("KW_NormMipCount");
private int ID_MipCount1 = Shader.PropertyToID("KW_NormMipCount_LOD1");
private int ID_MipCount2 = Shader.PropertyToID("KW_NormMipCount_LOD2");
private int ID_FFTDomainSize = Shader.PropertyToID("KW_FFTDomainSize");
private int ID_FFTDomainSize1 = Shader.PropertyToID("KW_FFTDomainSize_LOD1");
private int ID_FFTDomainSize2 = Shader.PropertyToID("KW_FFTDomainSize_LOD2");
private int ID_NormalLod = Shader.PropertyToID("KW_NormalLod");
public void Release()
{
KW_Extensions.SafeDestroy((Object)spectrumShader, (Object)shaderFFT, (Object)texButterfly, (Object)normalComputeMaterial);
KW_Extensions.ReleaseRenderTextures(spectrumInitRenderTexture, spectrumHeight, spectrumDisplaceX, spectrumDisplaceZ, fftTemp1, fftTemp2, fftTemp3, DisplaceTexture, NormalTexture);
prevWindTurbulence = -1f;
prevWindSpeed = -1f;
prevWindRotation = -1f;
isInitialized = false;
}
private void InitializeResources(int size, int anisoLevel)
{
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Expected O, but got Unknown
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Expected O, but got Unknown
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Expected O, but got Unknown
//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
//IL_00cf: Expected O, but got Unknown
//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Expected O, but got Unknown
//IL_0119: Unknown result type (might be due to invalid IL or missing references)
//IL_0123: Expected O, but got Unknown
//IL_0142: Unknown result type (might be due to invalid IL or missing references)
//IL_014c: Expected O, but got Unknown
//IL_016b: Unknown result type (might be due to invalid IL or missing references)
//IL_0175: Expected O, but got Unknown
//IL_0194: Unknown result type (might be due to invalid IL or missing references)
//IL_019e: Expected O, but got Unknown
//IL_01be: Unknown result type (might be due to invalid IL or missing references)
//IL_01c8: Expected O, but got Unknown
//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
//IL_01f1: Expected O, but got Unknown
Release();
spectrumShader = Object.Instantiate<ComputeShader>(WaterShadersSingleton.Instance.SpectrumGPUComputeShader);
kernelSpectrumInit = spectrumShader.FindKernel("SpectrumInitalize");
kernelSpectrumUpdate = spectrumShader.FindKernel("SpectrumUpdate");
shaderFFT = Object.Instantiate<ComputeShader>(WaterShadersSingleton.Instance.FFTComputeShader);
normalComputeMaterial = new Material(WaterShadersSingleton.Instance.ComputeNormalShader);
texButterfly = new Texture2D(size, Mathf.RoundToInt(Mathf.Log((float)size, 2f)), (TextureFormat)20, false, true);
spectrumInitRenderTexture = new RenderTexture(size, size, 0, (RenderTextureFormat)11, (RenderTextureReadWrite)1);
spectrumInitRenderTexture.enableRandomWrite = true;
spectrumInitRenderTexture.Create();
spectrumHeight = new RenderTexture(size, size, 0, (RenderTextureFormat)12, (RenderTextureReadWrite)1);
spectrumHeight.enableRandomWrite = true;
spectrumHeight.Create();
spectrumDisplaceX = new RenderTexture(size, size, 0, (RenderTextureFormat)12, (RenderTextureReadWrite)1);
spectrumDisplaceX.enableRandomWrite = true;
spectrumDisplaceX.Create();
spectrumDisplaceZ = new RenderTexture(size, size, 0, (RenderTextureFormat)12, (RenderTextureReadWrite)1);
spectrumDisplaceZ.enableRandomWrite = true;
spectrumDisplaceZ.Create();
fftTemp1 = new RenderTexture(size, size, 0, (RenderTextureFormat)12);
fftTemp1.enableRandomWrite = true;
fftTemp1.Create();
fftTemp2 = new RenderTexture(size, size, 0, (RenderTextureFormat)12);
fftTemp2.enableRandomWrite = true;
fftTemp2.Create();
fftTemp3 = new RenderTexture(size, size, 0, (RenderTextureFormat)12);
fftTemp3.enableRandomWrite = true;
fftTemp3.Create();
DisplaceTexture = new RenderTexture(size, size, 0, (RenderTextureFormat)11, (RenderTextureReadWrite)1);
DisplaceTexture.enableRandomWrite = true;
DisplaceTexture.Create();
NormalTexture = new RenderTexture(size, size, 0, (RenderTextureFormat)2, (RenderTextureReadWrite)1);
((Texture)NormalTexture).filterMode = (FilterMode)2;
((Texture)NormalTexture).wrapMode = (TextureWrapMode)0;
NormalTexture.useMipMap = true;
((Texture)NormalTexture).anisoLevel = anisoLevel;
InitializeButterfly(size);
isInitialized = true;
}
private void OnDisable()
{
Release();
}
public void ComputeFFT(LodPrefix lodPrefix, int size, int anisoLevel, float domainSize, float windTurbulence, float windSpeed, float windRotation, float timeOffset, List<Material> waterSharedMaterials, Dictionary<ComputeShader, List<int>> waterSharedComputeShaders)
{
if (!isInitialized || ((Texture)DisplaceTexture).width != size || ((Texture)NormalTexture).anisoLevel != anisoLevel)
{
InitializeResources(size, anisoLevel);
}
if (Mathf.Abs(prevWindTurbulence - windTurbulence) > 0.001f || Mathf.Abs(prevWindSpeed - windSpeed) > 0.01f || Mathf.Abs(prevWindRotation - windRotation) > 0.01f)
{
prevWindTurbulence = windTurbulence;
prevWindSpeed = windSpeed;
prevWindRotation = windRotation;
InitializeSpectrum(size, domainSize, windSpeed, windTurbulence, windRotation);
}
UpdateSpectrum(size, timeOffset, windRotation);
DispatchFFT(size, domainSize, windSpeed);
int num = Mathf.RoundToInt(Mathf.Log((float)size, 2f)) - 4;
int num2 = Mathf.RoundToInt(Mathf.Log((float)size, 2f));
foreach (Material waterSharedMaterial in waterSharedMaterials)
{
if (!((Object)(object)waterSharedMaterial == (Object)null))
{
UpdateMaterialParameters(lodPrefix, num, domainSize, num2, waterSharedMaterial);
}
}
foreach (KeyValuePair<ComputeShader, List<int>> waterSharedComputeShader in waterSharedComputeShaders)
{
if (!((Object)(object)waterSharedComputeShader.Key == (Object)null))
{
UpdateComputeParameters(lodPrefix, num, domainSize, num2, waterSharedComputeShader.Key, waterSharedComputeShader.Value);
}
}
}
private void UpdateMaterialParameters(LodPrefix lodPrefix, float normalLodSize, float domainSize, float mipCount, Material material)
{
switch (lodPrefix)
{
case LodPrefix.LOD0:
material.SetTexture(ID_DispTex, (Texture)(object)DisplaceTexture);
material.SetTexture(ID_NormTex, (Texture)(object)NormalTexture);
material.SetFloat(ID_FFTDomainSize, domainSize);
material.SetFloat(ID_NormalLod, normalLodSize);
material.SetFloat(ID_MipCount, mipCount);
break;
case LodPrefix.LOD1:
material.SetTexture(ID_DispTex1, (Texture)(object)DisplaceTexture);
material.SetTexture(ID_NormTex1, (Texture)(object)NormalTexture);
material.SetFloat(ID_FFTDomainSize1, domainSize);
material.SetFloat(ID_MipCount1, mipCount);
break;
case LodPrefix.LOD2:
material.SetTexture(ID_DispTex2, (Texture)(object)DisplaceTexture);
material.SetTexture(ID_NormTex2, (Texture)(object)NormalTexture);
material.SetFloat(ID_FFTDomainSize2, domainSize);
material.SetFloat(ID_MipCount2, mipCount);
break;
}
}
private void UpdateComputeParameters(LodPrefix lodPrefix, float normalLodSize, float domainSize, float mipCount, ComputeShader computeShader, List<int> kernels)
{
foreach (int kernel in kernels)
{
switch (lodPrefix)
{
case LodPrefix.LOD0:
computeShader.SetTexture(kernel, ID_DispTex, (Texture)(object)DisplaceTexture);
computeShader.SetTexture(kernel, ID_NormTex, (Texture)(object)NormalTexture);
computeShader.SetFloat(ID_FFTDomainSize, domainSize);
computeShader.SetFloat(ID_NormalLod, normalLodSize);
computeShader.SetFloat(ID_MipCount, mipCount);
break;
case LodPrefix.LOD1:
computeShader.SetTexture(kernel, ID_DispTex1, (Texture)(object)DisplaceTexture);
computeShader.SetTexture(kernel, ID_NormTex1, (Texture)(object)NormalTexture);
computeShader.SetFloat(ID_FFTDomainSize1, domainSize);
computeShader.SetFloat(ID_MipCount1, mipCount);
break;
case LodPrefix.LOD2:
computeShader.SetTexture(kernel, ID_DispTex2, (Texture)(object)DisplaceTexture);
computeShader.SetTexture(kernel, ID_NormTex2, (Texture)(object)NormalTexture);
computeShader.SetFloat(ID_FFTDomainSize2, domainSize);
computeShader.SetFloat(ID_MipCount2, mipCount);
break;
}
}
}
private void InitializeButterfly(int size)
{
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
int num = Mathf.RoundToInt(Mathf.Log((float)size, 2f));
butterflyColors = (Color[])(object)new Color[size * num];
int num2 = 1;
int num3 = size >> 1;
for (int i = 0; i < num; i++)
{
int num4 = i * size;
int num5 = 0;
int num6 = 2 * num2;
for (int j = 0; j < num3; j++)
{
float num7 = 0f;
for (int k = num5; k < num6; k += 2)
{
float num8 = MathF.PI * 2f * num7 * (float)num3 / (float)size;
float num9 = Mathf.Cos(num8);
float num10 = Mathf.Sin(num8);
butterflyColors[num4 + k / 2] = new Color(num9, 0f - num10, 0f, 1f);
butterflyColors[num4 + k / 2 + num2] = new Color(0f - num9, num10, 0f, 1f);
num7 += 1f;
}
num5 += 4 * num2;
num6 = num5 + 2 * num2;
}
num3 >>= 1;
num2 <<= 1;
}
texButterfly.SetPixels(butterflyColors);
texButterfly.Apply();
}
private void InitializeSpectrum(int size, float domainSize, float windSpeed, float windTurbulence, float windRotation)
{
Graphics.SetRenderTarget(spectrumInitRenderTexture);
spectrumShader.SetInt("size", size);
spectrumShader.SetFloat("domainSize", domainSize);
spectrumShader.SetFloats("turbulence", new float[1] { windTurbulence });
spectrumShader.SetFloat("windSpeed", windSpeed);
spectrumShader.SetFloat("windRotation", windRotation);
spectrumShader.SetTexture(kernelSpectrumInit, "resultInit", (Texture)(object)spectrumInitRenderTexture);
spectrumShader.Dispatch(kernelSpectrumInit, size / 8, size / 8, 1);
}
private void UpdateSpectrum(int size, float timeOffset, float windRotation)
{
Graphics.SetRenderTarget(spectrumHeight);
spectrumShader.SetFloat("time", timeOffset);
spectrumShader.SetTexture(kernelSpectrumUpdate, "init0", (Texture)(object)spectrumInitRenderTexture);
spectrumShader.SetTexture(kernelSpectrumUpdate, "resultHeight", (Texture)(object)spectrumHeight);
spectrumShader.SetTexture(kernelSpectrumUpdate, "resultDisplaceX", (Texture)(object)spectrumDisplaceX);
spectrumShader.SetTexture(kernelSpectrumUpdate, "resultDisplaceZ", (Texture)(object)spectrumDisplaceZ);
spectrumShader.Dispatch(kernelSpectrumUpdate, size / 8, size / 8, 1);
}
private void DispatchFFT(int size, float domainSize, float windSpeed)
{
RenderTexture active = RenderTexture.active;
int num = 0;
switch (size)
{
case 32:
num = 0;
break;
case 64:
num = 2;
break;
case 128:
num = 4;
break;
case 256:
num = 6;
break;
case 512:
num = 8;
break;
}
Graphics.SetRenderTarget(fftTemp1);
shaderFFT.SetTexture(num, "inputH", (Texture)(object)spectrumHeight);
shaderFFT.SetTexture(num, "inputX", (Texture)(object)spectrumDisplaceX);
shaderFFT.SetTexture(num, "inputZ", (Texture)(object)spectrumDisplaceZ);
shaderFFT.SetTexture(num, "inputButterfly", (Texture)(object)texButterfly);
shaderFFT.SetTexture(num, "output1", (Texture)(object)fftTemp1);
shaderFFT.SetTexture(num, "output2", (Texture)(object)fftTemp2);
shaderFFT.SetTexture(num, "output3", (Texture)(object)fftTemp3);
shaderFFT.Dispatch(num, 1, size, 1);
Graphics.SetRenderTarget(DisplaceTexture);
shaderFFT.SetTexture(num + 1, "inputH", (Texture)(object)fftTemp1);
shaderFFT.SetTexture(num + 1, "inputX", (Texture)(object)fftTemp2);
shaderFFT.SetTexture(num + 1, "inputZ", (Texture)(object)fftTemp3);
shaderFFT.SetTexture(num + 1, "inputButterfly", (Texture)(object)texButterfly);
shaderFFT.SetTexture(num + 1, "output", (Texture)(object)DisplaceTexture);
shaderFFT.Dispatch(num + 1, size, 1, 1);
normalComputeMaterial.SetFloat("KW_FFTDomainSize", domainSize);
normalComputeMaterial.SetTexture("_DispTex", (Texture)(object)DisplaceTexture);
int num2 = Mathf.RoundToInt(Mathf.Log((float)size, 2f)) - 4;
normalComputeMaterial.SetFloat("_SizeLog", (float)num2);
normalComputeMaterial.SetFloat("_WindSpeed", windSpeed);
Graphics.SetRenderTarget(NormalTexture);
Graphics.Blit((Texture)null, NormalTexture, normalComputeMaterial, 0);
RenderTexture.active = active;
}
}
[ExecuteInEditMode]
public class KW_AddLightToWaterRendering : MonoBehaviour
{
private Light currentLight;
private LightType lastLightType;
private LightShadows lastLightShadows;
private Color lastLightColor;
private float lastLightRange;
private float lastLightIntencity;
private float lastSpotLightAngle;
private Vector3 lastLightPos;
private Vector3 lastLightDir;
private static readonly int KW_DirLightForward_ID = Shader.PropertyToID("KW_DirLightForward");
private static readonly int KW_DirLightColor_ID = Shader.PropertyToID("KW_DirLightColor");
private KW_WaterVolumetricLighting.VolumeLight currentVolumeLight;
private void OnEnable()
{
if ((Object)(object)currentLight == (Object)null)
{
currentLight = ((Component)this).GetComponent<Light>();
}
if (currentVolumeLight == null)
{
currentVolumeLight = new KW_WaterVolumetricLighting.VolumeLight();
}
currentVolumeLight.Light = currentLight;
currentVolumeLight.RequiredUpdate = true;
KW_WaterVolumetricLighting.ActiveLights.Add(currentVolumeLight);
}
private void OnDisable()
{
KW_WaterVolumetricLighting.ActiveLights.Remove(currentVolumeLight);
if (currentVolumeLight.CopyShadowMapBuffer != null)
{
currentLight.RemoveCommandBuffer((LightEvent)1, currentVolumeLight.CopyShadowMapBuffer);
}
if (currentVolumeLight.LightCommandBuffer != null)
{
currentVolumeLight.Light.RemoveCommandBuffer((LightEvent)2, currentVolumeLight.LightCommandBuffer);
currentVolumeLight.Light.RemoveCommandBuffer((LightEvent)1, currentVolumeLight.LightCommandBuffer);
}
}
private bool IsRequiredLightUpdate()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0108: Unknown result type (might be due to invalid IL or missing references)
//IL_010d: Unknown result type (might be due to invalid IL or missing references)
//IL_0136: Unknown result type (might be due to invalid IL or missing references)
//IL_013b: Unknown result type (might be due to invalid IL or missing references)
//IL_0142: Unknown result type (might be due to invalid IL or missing references)
//IL_0147: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
bool result = false;
Transform transform = ((Component)currentLight).transform;
if (lastLightType != currentLight.type || lastLightShadows != currentLight.shadows || lastLightColor != currentLight.color || Math.Abs(lastLightIntencity - currentLight.intensity) > 0.001f || Math.Abs(lastLightRange - currentLight.range) > 0.001f || Math.Abs(lastSpotLightAngle - currentLight.spotAngle) > 0.001f || lastLightPos != transform.position || lastLightDir != transform.forward)
{
result = true;
}
lastLightType = currentLight.type;
lastLightShadows = currentLight.shadows;
lastLightColor = currentLight.color;
lastLightIntencity = currentLight.intensity;
lastLightRange = currentLight.range;
lastLightPos = transform.position;
lastLightDir = transform.forward;
return result;
}
private void Update()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Invalid comparison between Unknown and I4
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Invalid comparison between Unknown and I4
if ((int)currentLight.type == 0)
{
ComputeSpotLightShadowMatrix();
}
if ((int)currentLight.type == 1)
{
UpdateDirLight();
}
if (IsRequiredLightUpdate())
{
currentVolumeLight.RequiredUpdate = true;
}
}
private void UpdateDirLight()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
Shader.SetGlobalVector(KW_DirLightForward_ID, Vector4.op_Implicit(-((Component)currentLight).transform.forward));
Shader.SetGlobalVector(KW_DirLightColor_ID, Color.op_Implicit(currentLight.color * currentLight.intensity));
}
private void ComputeSpotLightShadowMatrix()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_0120: Unknown result type (might be due to invalid IL or missing references)
//IL_0130: Unknown result type (might be due to invalid IL or missing references)
//IL_0135: Unknown result type (might be due to invalid IL or missing references)
//IL_013a: Unknown result type (might be due to invalid IL or missing references)
//IL_013f: Unknown result type (might be due to invalid IL or missing references)
//IL_0143: Unknown result type (might be due to invalid IL or missing references)
//IL_0148: Unknown result type (might be due to invalid IL or missing references)
//IL_014f: Unknown result type (might be due to invalid IL or missing references)
//IL_0150: Unknown result type (might be due to invalid IL or missing references)
//IL_0151: Unknown result type (might be due to invalid IL or missing references)
//IL_0156: Unknown result type (might be due to invalid IL or missing references)
Matrix4x4 val = Matrix4x4.TRS(new Vector3(0.5f, 0.5f, 0.5f), Quaternion.identity, new Vector3(0.5f, 0.5f, 0.5f));
Matrix4x4 val2 = ((!SystemInfo.usesReversedZBuffer) ? Matrix4x4.Perspective(currentLight.spotAngle, 1f, currentLight.shadowNearPlane, currentLight.range) : Matrix4x4.Perspective(currentLight.spotAngle, 1f, currentLight.range, currentLight.shadowNearPlane));
Matrix4x4 val3 = val * val2;
ref Matrix4x4 reference = ref val3;
((Matrix4x4)(ref reference))[0, 2] = ((Matrix4x4)(ref reference))[0, 2] * -1f;
reference = ref val3;
((Matrix4x4)(ref reference))[1, 2] = ((Matrix4x4)(ref reference))[1, 2] * -1f;
reference = ref val3;
((Matrix4x4)(ref reference))[2, 2] = ((Matrix4x4)(ref reference))[2, 2] * -1f;
reference = ref val3;
((Matrix4x4)(ref reference))[3, 2] = ((Matrix4x4)(ref reference))[3, 2] * -1f;
Matrix4x4 val4 = Matrix4x4.TRS(((Component)currentLight).transform.position, ((Component)currentLight).transform.rotation, Vector3.one);
Matrix4x4 inverse = ((Matrix4x4)(ref val4)).inverse;
currentVolumeLight.SpotMatrix = val3 * inverse;
}
}
[RequireComponent(typeof(Rigidbody))]
[RequireComponent(typeof(Collider))]
public class KW_Buoyancy : MonoBehaviour
{
public enum ModelSourceEnum
{
Collider,
Mesh
}
public ModelSourceEnum VolumeSource = ModelSourceEnum.Mesh;
public Transform OvverideCenterOfMass;
[Range(100f, 1000f)]
public float Density = 450f;
[Range(1f, 6f)]
public int SlicesPerAxisX = 2;
[Range(1f, 6f)]
public int SlicesPerAxisY = 2;
[Range(1f, 6f)]
public int SlicesPerAxisZ = 2;
public bool isConcave = false;
[Range(2f, 32f)]
public int VoxelsLimit = 16;
public float AngularDrag = 0.25f;
public float Drag = 0.25f;
[Range(0f, 1f)]
public float NormalForce = 0.2f;
public bool DebugForces = false;
private const float DAMPFER = 0.1f;
private const float WATER_DENSITY = 1000f;
private Vector3 localArchimedesForce;
private List<Vector3> voxels;
private Vector3[] currentForces;
private bool isMeshCollider;
private List<Vector3[]> debugForces;
private Rigidbody rigidBody;
private Collider collider;
private float bounceMaxSize;
private void OnEnable()
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
//IL_0156: Unknown result type (might be due to invalid IL or missing references)
//IL_0163: Unknown result type (might be due to invalid IL or missing references)
//IL_0194: Unknown result type (might be due to invalid IL or missing references)
//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
KW_WaterDynamicScripts.AddBuoyancyScript(this);
debugForces = new List<Vector3[]>();
rigidBody = ((Component)this).GetComponent<Rigidbody>();
collider = ((Component)this).GetComponent<Collider>();
Quaternion rotation = ((Component)this).transform.rotation;
Vector3 position = ((Component)this).transform.position;
((Component)this).transform.rotation = Quaternion.identity;
((Component)this).transform.position = Vector3.zero;
Bounds bounds = collider.bounds;
bounceMaxSize = Mathf.Max(new float[3]
{
((Bounds)(ref bounds)).size.x,
((Bounds)(ref bounds)).size.y,
((Bounds)(ref bounds)).size.z
});
isMeshCollider = (Object)(object)((Component)this).GetComponent<MeshCollider>() != (Object)null;
if (Object.op_Implicit((Object)(object)OvverideCenterOfMass))
{
rigidBody.centerOfMass = ((Component)this).transform.InverseTransformPoint(((Component)OvverideCenterOfMass).transform.position);
}
rigidBody.angularDrag = AngularDrag;
rigidBody.drag = Drag;
voxels = SliceIntoVoxels(isMeshCollider && isConcave);
currentForces = (Vector3[])(object)new Vector3[voxels.Count];
((Component)this).transform.rotation = rotation;
((Component)this).transform.position = position;
float num = rigidBody.mass / Density;
WeldPoints(voxels, VoxelsLimit);
float num2 = 1000f * Mathf.Abs(Physics.gravity.y) * num;
localArchimedesForce = new Vector3(0f, num2, 0f) / (float)voxels.Count;
}
private void OnDisable()
{
KW_WaterDynamicScripts.RemoveBuoyancyScript(this);
}
private Bounds GetCurrentBounds()
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
Bounds result = default(Bounds);
if (VolumeSource == ModelSourceEnum.Mesh)
{
return ((Component)this).GetComponent<Renderer>().bounds;
}
if (VolumeSource == ModelSourceEnum.Collider)
{
MeshCollider component = ((Component)this).GetComponent<MeshCollider>();
if ((Object)(object)component != (Object)null)
{
return component.sharedMesh.bounds;
}
return ((Component)this).GetComponent<Collider>().bounds;
}
return result;
}
private List<Vector3> SliceIntoVoxels(bool concave)
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0176: Unknown result type (might be due to invalid IL or missing references)
//IL_01af: Unknown result type (might be due to invalid IL or missing references)
//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
//IL_0209: Unknown result type (might be due to invalid IL or missing references)
//IL_0215: Unknown result type (might be due to invalid IL or missing references)
//IL_0240: Unknown result type (might be due to invalid IL or missing references)
//IL_0245: Unknown result type (might be due to invalid IL or missing references)
//IL_024a: Unknown result type (might be due to invalid IL or missing references)
//IL_024d: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
List<Vector3> list = new List<Vector3>(SlicesPerAxisX * SlicesPerAxisY * SlicesPerAxisZ);
Bounds currentBounds = GetCurrentBounds();
if (concave)
{
MeshCollider component = ((Component)this).GetComponent<MeshCollider>();
bool convex = component.convex;
component.convex = false;
for (int i = 0; i < SlicesPerAxisX; i++)
{
for (int j = 0; j < SlicesPerAxisY; j++)
{
for (int k = 0; k < SlicesPerAxisZ; k++)
{
float num = ((Bounds)(ref currentBounds)).min.x + ((Bounds)(ref currentBounds)).size.x / (float)SlicesPerAxisX * (0.5f + (float)i);
float num2 = ((Bounds)(ref currentBounds)).min.y + ((Bounds)(ref currentBounds)).size.y / (float)SlicesPerAxisY * (0.5f + (float)j);
float num3 = ((Bounds)(ref currentBounds)).min.z + ((Bounds)(ref currentBounds)).size.z / (float)SlicesPerAxisZ * (0.5f + (float)k);
Vector3 val = ((Component)this).transform.InverseTransformPoint(new Vector3(num, num2, num3));
if (PointIsInsideMeshCollider((Collider)(object)component, val))
{
list.Add(val);
}
}
}
}
if (list.Count == 0)
{
list.Add(((Bounds)(ref currentBounds)).center);
}
component.convex = convex;
}
else
{
for (int l = 0; l < SlicesPerAxisX; l++)
{
for (int m = 0; m < SlicesPerAxisY; m++)
{
for (int n = 0; n < SlicesPerAxisZ; n++)
{
float num4 = ((Bounds)(ref currentBounds)).min.x + ((Bounds)(ref currentBounds)).size.x / (float)SlicesPerAxisX * (0.5f + (float)l);
float num5 = ((Bounds)(ref currentBounds)).min.y + ((Bounds)(ref currentBounds)).size.y / (float)SlicesPerAxisY * (0.5f + (float)m);
float num6 = ((Bounds)(ref currentBounds)).min.z + ((Bounds)(ref currentBounds)).size.z / (float)SlicesPerAxisZ * (0.5f + (float)n);
Vector3 item = ((Component)this).transform.InverseTransformPoint(new Vector3(num4, num5, num6));
list.Add(item);
}
}
}
}
return list;
}
private static bool PointIsInsideMeshCollider(Collider c, Vector3 p)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
Vector3[] array = (Vector3[])(object)new Vector3[6]
{
Vector3.up,
Vector3.down,
Vector3.left,
Vector3.right,
Vector3.forward,
Vector3.back
};
Vector3[] array2 = array;
RaycastHit val2 = default(RaycastHit);
foreach (Vector3 val in array2)
{
if (!c.Raycast(new Ray(p - val * 1000f, val), ref val2, 1000f))
{
return false;
}
}
return true;
}
private static void FindClosestPoints(IList<Vector3> list, out int firstIndex, out int secondIndex)
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
float num = float.MaxValue;
float num2 = float.MinValue;
firstIndex = 0;
secondIndex = 1;
for (int i = 0; i < list.Count - 1; i++)
{
for (int j = i + 1; j < list.Count; j++)
{
float num3 = Vector3.Distance(list[i], list[j]);
if (num3 < num)
{
num = num3;
firstIndex = i;
secondIndex = j;
}
if (num3 > num2)
{
num2 = num3;
}
}
}
}
private static void WeldPoints(IList<Vector3> list, int targetCount)
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
if (list.Count > 2 && targetCount >= 2)
{
while (list.Count > targetCount)
{
FindClosestPoints(list, out var firstIndex, out var secondIndex);
Vector3 item = (list[firstIndex] + list[secondIndex]) * 0.5f;
list.RemoveAt(secondIndex);
list.RemoveAt(firstIndex);
list.Add(item);
}
}
}
private void FixedUpdate()
{
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_018d: Unknown result type (might be due to invalid IL or missing references)
//IL_0192: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_019b: Unknown result type (might be due to invalid IL or missing references)
//IL_019d: Unknown result type (might be due to invalid IL or missing references)
//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
//IL_0101: Unknown result type (might be due to invalid IL or missing references)
//IL_010b: Unknown result type (might be due to invalid IL or missing references)
//IL_0110: Unknown result type (might be due to invalid IL or missing references)
//IL_0115: Unknown result type (might be due to invalid IL or missing references)
//IL_011a: Unknown result type (might be due to invalid IL or missing references)
//IL_0123: Unknown result type (might be due to invalid IL or missing references)
//IL_0128: Unknown result type (might be due to invalid IL or missing references)
//IL_0133: Unknown result type (might be due to invalid IL or missing references)
//IL_0158: Unknown result type (might be due to invalid IL or missing references)
//IL_017b: Unknown result type (might be due to invalid IL or missing references)
//IL_017d: Unknown result type (might be due to invalid IL or missing references)
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
WaterSystem currentWater = KW_WaterDynamicScripts.GetCurrentWater();
if ((Object)(object)currentWater == (Object)null)
{
return;
}
if (DebugForces)
{
debugForces.Clear();
}
for (int i = 0; i < voxels.Count; i++)
{
Vector3 val = ((Component)this).transform.TransformPoint(voxels[i]);
KW_WaterSurfaceData? waterSurfacePositionNormal = currentWater.GetWaterSurfacePositionNormal(val);
Vector3 zero = Vector3.zero;
if (waterSurfacePositionNormal.HasValue)
{
Vector3 position = waterSurfacePositionNormal.Value.Position;
Vector3 pointVelocity = rigidBody.GetPointVelocity(val);
Vector3 val2 = -pointVelocity * 0.1f * rigidBody.mass;
float num = position.y - val.y;
if (num > 1f)
{
num = 1f;
}
else if (num < 0f)
{
num = 0f;
val2 *= 0.2f;
}
zero = val2 + Mathf.Sqrt(num) * localArchimedesForce;
Vector3 normal = waterSurfacePositionNormal.Value.Normal;
zero.x += normal.x * NormalForce * rigidBody.mass;
zero.z += normal.z * NormalForce * rigidBody.mass;
currentForces[i] = zero;
}
else
{
zero = currentForces[i];
}
rigidBody.AddForceAtPosition(zero, val);
if (DebugForces)
{
debugForces.Add((Vector3[])(object)new Vector3[2] { val, zero });
}
}
}
private void OnDrawGizmos()
{
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_0103: Unknown result type (might be due to invalid IL or missing references)
if (!DebugForces || voxels == null || debugForces == null)
{
return;
}
float num = 0.02f * bounceMaxSize;
Gizmos.color = Color.yellow;
foreach (Vector3 voxel in voxels)
{
Gizmos.DrawCube(((Component)this).transform.TransformPoint(voxel), new Vector3(num, num, num));
}
Gizmos.color = Color.cyan;
foreach (Vector3[] debugForce in debugForces)
{
Gizmos.DrawCube(debugForce[0], new Vector3(num, num, num));
Gizmos.DrawRay(debugForce[0], debugForce[1] / rigidBody.mass * bounceMaxSize * 0.25f);
}
}
}
public class KW_CameraColorTexture : MonoBehaviour
{
public RenderTexture CameraColorTexture;
public RenderTexture CameraColorTexture_Blured;
public RenderTexture CameraColorTextureFinal;
private string cb_Name = "CopyColorTexture";
private string cbFinal_Name = "CopyColorTextureFinal";
private CommandBuffer cb;
private CommandBuffer cbFinal;
private void OnDisable()
{
if ((Object)(object)CameraColorTexture != (Object)null)
{
CameraColorTexture.Release();
}
if ((Object)(object)CameraColorTexture_Blured != (Object)null)
{
CameraColorTexture_Blured.Release();
}
if ((Object)(object)CameraColorTextureFinal != (Object)null)
{
CameraColorTextureFinal.Release();
}
}
public void Release()
{
OnDisable();
}
private void InitializeTextures(int width, int height, bool useHDR)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Expected O, but got Unknown
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Expected O, but got Unknown
if ((Object)(object)CameraColorTexture != (Object)null)
{
CameraColorTexture.Release();
}
CameraColorTexture = new RenderTexture(width, height, 0, (RenderTextureFormat)(useHDR ? 9 : 7));
if ((Object)(object)CameraColorTexture_Blured != (Object)null)
{
CameraColorTexture_Blured.Release();
}
CameraColorTexture_Blured = new RenderTexture(width, height, 0, (RenderTextureFormat)(useHDR ? 9 : 7));
}
private void InitializeFinalTextures(int width, int height, bool useHDR)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Expected O, but got Unknown
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)CameraColorTextureFinal != (Object)null)
{
CameraColorTextureFinal.Release();
}
CameraColorTextureFinal = new RenderTexture(width, height, 0, (RenderTextureFormat)(useHDR ? 9 : 7));
Debug.Log((object)CameraColorTextureFinal.format);
}
public void RenderColorTexture(Camera currentCamera, bool useHDR, bool isScreenSpaceWaterRendering, Dictionary<CommandBuffer, CameraEvent> waterSharedBuffers)
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Expected O, but got Unknown
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
if (cb == null || !waterSharedBuffers.ContainsKey(cb))
{
if (cb == null)
{
cb = new CommandBuffer
{
name = cb_Name
};
}
else
{
cb.Clear();
}
int pixelWidth = currentCamera.pixelWidth;
int pixelHeight = currentCamera.pixelHeight;
InitializeTextures(pixelWidth, pixelHeight, useHDR);
cb.Blit(RenderTargetIdentifier.op_Implicit((BuiltinRenderTextureType)1), RenderTargetIdentifier.op_Implicit((Texture)(object)CameraColorTexture));
cb.SetGlobalTexture("_CameraColorTexture", RenderTargetIdentifier.op_Implicit((Texture)(object)CameraColorTexture));
waterSharedBuffers.Add(cb, (CameraEvent)(isScreenSpaceWaterRendering ? 17 : 16));
}
}
public void RenderColorTextureFinal(Camera currentCamera, bool useHDR, Dictionary<CommandBuffer, CameraEvent> waterSharedBuffers)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Expected O, but got Unknown
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
if (cbFinal == null || !waterSharedBuffers.ContainsKey(cbFinal))
{
if (cbFinal == null)
{
cbFinal = new CommandBuffer
{
name = cbFinal_Name
};
}
else
{
cbFinal.Clear();
}
int pixelWidth = currentCamera.pixelWidth;
int pixelHeight = currentCamera.pixelHeight;
InitializeFinalTextures(pixelWidth, pixelHeight, useHDR);
cbFinal.Blit(RenderTargetIdentifier.op_Implicit((BuiltinRenderTextureType)1), RenderTargetIdentifier.op_Implicit((Texture)(object)CameraColorTextureFinal));
cbFinal.SetGlobalTexture("_CameraColorTextureFinal", RenderTargetIdentifier.op_Implicit((Texture)(object)CameraColorTextureFinal));
waterSharedBuffers.Add(cbFinal, (CameraEvent)19);
}
}
}
public class KW_CameraReflection_HDRP : MonoBehaviour
{
private class PlanarReflectionSettingData
{
private readonly bool _fog;
private readonly int _maxLod;
private readonly float _lodBias;
public PlanarReflectionSettingData()
{
_fog = RenderSettings.fog;
_maxLod = QualitySettings.maximumLODLevel;
_lodBias = QualitySettings.lodBias;
}
public void Set()
{
RenderSettings.fog = false;
QualitySettings.maximumLODLevel += 1;
QualitySettings.lodBias = _lodBias * 0.5f;
}
public void Restore()
{
RenderSettings.fog = _fog;
QualitySettings.maximumLODLevel = _maxLod;
QualitySettings.lodBias = _lodBias;
}
}
private GameObject reflCameraGO;
private Camera reflectionCamera;
public RenderTexture reflectionRT;
public RenderTexture reflectionCubemapRT;
public float m_ClipPlaneOffset = -0.05f;
public float m_planeOffset = -0.05f;
private float currentInterval = 0f;
private int sideIdx = 0;
private int[] cubeMapSides = new int[5] { 0, 1, 2, 4, 5 };
private bool requiredUpdateAllFaces = true;
private int waterCullingMask = -17;
private HDAdditionalCameraData hdData;
private bool lastSkyFix;
public void Release()
{
KW_Extensions.SafeDestroy((Object)reflCameraGO);
KW_Extensions.ReleaseRenderTextures(reflectionRT, reflectionCubemapRT);
currentInterval = 0f;
requiredUpdateAllFaces = true;
}
private void OnDisable()
{
Release();
}
private void InitializeReflectionTexture(int width, int height, bool useMip)
{
reflectionRT = KW_Extensions.ReinitializeRenderTexture(reflectionRT, width, height, 24, (RenderTextureFormat)9, null, useRandomWrite: false, useMip, (TextureWrapMode)0, (FilterMode)1);
}
private void InitializeCubemapTexture(int width, int height)
{
reflectionCubemapRT = KW_Extensions.ReinitializeRenderTexture(reflectionCubemapRT, width, height, 0, (RenderTextureFormat)2, null, useRandomWrite: false, useMipMap: false, (TextureWrapMode)0, (FilterMode)1);
((Texture)reflectionCubemapRT).dimension = (TextureDimension)4;
}
private void CreateCamera()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Expected O, but got Unknown
reflCameraGO = new GameObject("WaterReflectionCamera");
reflCameraGO.transform.parent = ((Component)this).transform;
reflectionCamera = reflCameraGO.AddComponent<Camera>();
reflectionCamera.cameraType = (CameraType)16;
((Behaviour)reflectionCamera).enabled = false;
reflectionCamera.allowMSAA = false;
reflectionCamera.useOcclusionCulling = false;
hdData = reflCameraGO.AddComponent<HDAdditionalCameraData>();
}
private void CopyCameraParams(Camera currentCamera, int cullingMask)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
//IL_0162: Unknown result type (might be due to invalid IL or missing references)
//IL_012b: Unknown result type (might be due to invalid IL or missing references)
//IL_013d: Unknown result type (might be due to invalid IL or missing references)
//IL_014f: Unknown result type (might be due to invalid IL or missing references)
((Component)reflectionCamera).transform.position = ((Component)currentCamera).transform.position;
((Component)reflectionCamera).transform.rotation = ((Component)currentCamera).transform.rotation;
reflectionCamera.fieldOfView = currentCamera.fieldOfView;
reflectionCamera.nearClipPlane = currentCamera.nearClipPlane;
reflectionCamera.farClipPlane = currentCamera.farClipPlane;
reflectionCamera.rect = currentCamera.rect;
reflectionCamera.aspect = currentCamera.aspect;
reflectionCamera.orthographicSize = currentCamera.orthographicSize;
reflectionCamera.renderingPath = currentCamera.renderingPath;
reflectionCamera.allowDynamicResolution = currentCamera.allowDynamicResolution;
reflectionCamera.cullingMask = cullingMask;
reflectionCamera.clearFlags = currentCamera.clearFlags;
reflectionCamera.backgroundColor = currentCamera.backgroundColor;
if (currentCamera.usePhysicalProperties)
{
reflectionCamera.usePhysicalProperties = true;
reflectionCamera.focalLength = currentCamera.focalLength;
reflectionCamera.sensorSize = currentCamera.sensorSize;
reflectionCamera.lensShift = currentCamera.lensShift;
reflectionCamera.gateFit = currentCamera.gateFit;
}
hdData.defaultFrameSettings = (FrameSettingsRenderType)2;
hdData.customRenderingSettings = true;
hdData.hasPersistentHistory = true;
hdData.invertFaceCulling = true;
}
private void RenderCamera(Camera currentCamera, Vector3 waterPosition, Matrix4x4 cameraMatrix)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0101: Unknown result type (might be due to invalid IL or missing references)
//IL_0106: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
//IL_0111: Unknown result type (might be due to invalid IL or missing references)
//IL_0119: Unknown result type (might be due to invalid IL or missing references)
//IL_011b: Unknown result type (might be due to invalid IL or missing references)
//IL_0120: Unknown result type (might be due to invalid IL or missing references)
//IL_0128: Unknown result type (might be due to invalid IL or missing references)
Vector3 val = waterPosition + Vector3.up * m_planeOffset;
Vector3 up = Vector3.up;
float num = 0f - Vector3.Dot(up, val) - m_ClipPlaneOffset;
Vector4 plane = default(Vector4);
((Vector4)(ref plane))..ctor(up.x, up.y, up.z, num);
Matrix4x4 reflectionMat = Matrix4x4.identity;
reflectionMat *= Matrix4x4.Scale(new Vector3(1f, -1f, 1f));
CalculateReflectionMatrix(ref reflectionMat, plane);
((Component)reflectionCamera).transform.forward = Vector3.Scale(((Component)currentCamera).transform.forward, new Vector3(1f, -1f, 1f));
Vector3 position = ((Component)currentCamera).transform.position;
((Component)reflectionCamera).transform.position = ((Matrix4x4)(ref reflectionMat)).MultiplyPoint(position);
reflectionCamera.worldToCameraMatrix = cameraMatrix * reflectionMat;
Vector4 val2 = CameraSpacePlane(reflectionCamera, val - Vector3.up * 0.1f, up, 1f);
Matrix4x4 projectionMatrix = reflectionCamera.CalculateObliqueMatrix(val2);
reflectionCamera.projectionMatrix = projectionMatrix;
PlanarReflectionSettingData planarReflectionSettingData = new PlanarReflectionSettingData();
planarReflectionSettingData.Set();
try
{
reflectionCamera.targetTexture = reflectionRT;
KW_Extensions.CameraRender(reflectionCamera);
}
finally
{
planarReflectionSettingData.Restore();
}
}
public void RenderPlanar(Camera currentCamera, Vector3 waterPosition, float resolutionScale, bool useSkyFix, List<Material> waterShaderMaterials)
{
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)currentCamera == (Object)null)
{
return;
}
if ((Object)(object)reflCameraGO == (Object)null)
{
CreateCamera();
}
CopyCameraParams(currentCamera, waterCullingMask);
UseSkyFix(currentCamera, useSkyFix);
int width = (int)((float)currentCamera.pixelWidth * resolutionScale);
int height = (int)((float)currentCamera.pixelHeight * resolutionScale);
InitializeReflectionTexture(width, height, useMip: true);
RenderCamera(currentCamera, waterPosition, currentCamera.worldToCameraMatrix);
foreach (Material waterShaderMaterial in waterShaderMaterials)
{
if (!((Object)(object)waterShaderMaterial == (Object)null))
{
waterShaderMaterial.SetTexture("KW_PlanarReflection", (Texture)(object)reflectionRT);
}
}
}
public void RenderCubemap(Camera currentCamera, Vector3 waterPosition, float interval, int cullingMask, int texSize, bool useSkyFix, List<Material> waterShaderMaterials)
{
//IL_0113: Unknown result type (might be due to invalid IL or missing references)
//IL_011d: Unknown result type (might be due to invalid IL or missing references)
//IL_0127: Unknown result type (might be due to invalid IL or missing references)
//IL_0131: Unknown result type (might be due to invalid IL or missing references)
//IL_013b: Unknown result type (might be due to invalid IL or missing references)
//IL_017d: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)currentCamera == (Object)null)
{
return;
}
currentInterval += KW_Extensions.DeltaTime();
if (lastSkyFix != useSkyFix)
{
requiredUpdateAllFaces = true;
}
if (!requiredUpdateAllFaces && currentInterval < interval / 6f)
{
return;
}
currentInterval = 0f;
if ((Object)(object)reflCameraGO == (Object)null)
{
CreateCamera();
}
CopyCameraParams(currentCamera, cullingMask);
UseSkyFix(currentCamera, useSkyFix);
InitializeReflectionTexture(texSize, texSize, useMip: false);
InitializeCubemapTexture(texSize, texSize);
float fieldOfView = currentCamera.fieldOfView;
float aspect = currentCamera.aspect;
reflectionCamera.fieldOfView = 90f;
reflectionCamera.aspect = 1f;
m_planeOffset = 0f;
m_ClipPlaneOffset = 0f;
if (requiredUpdateAllFaces || interval < 0.0001f)
{
RenderToCubemapFace(currentCamera, waterPosition, (CubemapFace)1);
RenderToCubemapFace(currentCamera, waterPosition, (CubemapFace)5);
RenderToCubemapFace(currentCamera, waterPosition, (CubemapFace)0);
RenderToCubemapFace(currentCamera, waterPosition, (CubemapFace)2);
RenderToCubemapFace(currentCamera, waterPosition, (CubemapFace)4);
}
else
{
int num = cubeMapSides[sideIdx];
sideIdx = ((sideIdx < 4) ? (++sideIdx) : 0);
RenderToCubemapFace(currentCamera, waterPosition, (CubemapFace)num);
}
requiredUpdateAllFaces = false;
foreach (Material waterShaderMaterial in waterShaderMaterials)
{
if (!((Object)(object)waterShaderMaterial == (Object)null))
{
waterShaderMaterial.SetTexture("KW_ReflectionCube", (Texture)(object)reflectionCubemapRT);
}
}
}
private void UseSkyFix(Camera currentCamera, bool useSkyFix)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
if (useSkyFix)
{
hdData.clearColorMode = (ClearColorMode)1;
hdData.backgroundColorHDR = Color.black;
hdData.SetCameraFrameSetting((FrameSettingsField)27, enabled: false);
}
else
{
HDAdditionalCameraData component = ((Component)currentCamera).GetComponent<HDAdditionalCameraData>();
if ((Object)(object)component != (Object)null)
{
hdData.clearColorMode = component.clearColorMode;
hdData.backgroundColorHDR = component.backgroundColorHDR;
}
else
{
hdData.clearColorMode = (ClearColorMode)0;
}
hdData.SetCameraFrameSetting((FrameSettingsField)27, enabled: true);
}
lastSkyFix = useSkyFix;
}
private void RenderToCubemapFace(Camera currentCamera, Vector3 waterPosition, CubemapFace face)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Expected I4, but got Unknown
Vector3 position = ((Component)currentCamera).transform.position;
Matrix4x4 cameraMatrix = Matrix4x4.Inverse(Matrix4x4.TRS(position, GetRotationByCubeFace(face), new Vector3(1f, 1f, -1f)));
RenderCamera(currentCamera, waterPosition, cameraMatrix);
Graphics.CopyTexture((Texture)(object)reflectionRT, 0, (Texture)(object)reflectionCubemapRT, (int)face);
}
private Quaternion GetRotationByCubeFace(CubemapFace face)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Expected I4, but got Unknown
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_00af: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
return (Quaternion)((int)face switch
{
1 => Quaternion.Euler(0f, -90f, 0f),
0 => Quaternion.Euler(0f, 90f, 0f),
2 => Quaternion.Euler(90f, 0f, 0f),
3 => Quaternion.Euler(-90f, 0f, 0f),
4 => Quaternion.Euler(0f, 0f, 0f),
5 => Quaternion.Euler(0f, -180f, 0f),
_ => Quaternion.identity,
});
}
private static float sgn(float a)
{
if (a > 0f)
{
return 1f;
}
if (a < 0f)
{
return -1f;
}
return 0f;
}
private static Vector3 ReflectPosition(Vector3 pos)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
Vector3 result = default(Vector3);
((Vector3)(ref result))..ctor(pos.x, 0f - pos.y, pos.z);
return result;
}
private Vector4 CameraSpacePlane(Camera cam, Vector3 pos, Vector3 normal, float sideSign)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
Vector3 val = pos + normal * m_ClipPlaneOffset;
Matrix4x4 worldToCameraMatrix = cam.worldToCameraMatrix;
Vector3 val2 = ((Matrix4x4)(ref worldToCameraMatrix)).MultiplyPoint(val);
Vector3 val3 = ((Matrix4x4)(ref worldToCameraMatrix)).MultiplyVector(normal);
Vector3 val4 = ((Vector3)(ref val3)).normalized * sideSign;
return new Vector4(val4.x, val4.y, val4.z, 0f - Vector3.Dot(val2, val4));
}
private static void CalculateReflectionMatrix(ref Matrix4x4 reflectionMat, Vector4 plane)
{
reflectionMat.m00 = 1f - 2f * ((Vector4)(ref plane))[0] * ((Vector4)(ref plane))[0];
reflectionMat.m01 = -2f * ((Vector4)(ref plane))[0] * ((Vector4)(ref plane))[1];
reflectionMat.m02 = -2f * ((Vector4)(ref plane))[0] * ((Vector4)(ref plane))[2];
reflectionMat.m03 = -2f * ((Vector4)(ref plane))[3] * ((Vector4)(ref plane))[0];
reflectionMat.m10 = -2f * ((Vector4)(ref plane))[1] * ((Vector4)(ref plane))[0];
reflectionMat.m11 = 1f - 2f * ((Vector4)(ref plane))[1] * ((Vector4)(ref plane))[1];
reflectionMat.m12 = -2f * ((Vector4)(ref plane))[1] * ((Vector4)(ref plane))[2];
reflectionMat.m13 = -2f * ((Vector4)(ref plane))[3] * ((Vector4)(ref plane))[1];
reflectionMat.m20 = -2f * ((Vector4)(ref plane))[2] * ((Vector4)(ref plane))[0];
reflectionMat.m21 = -2f * ((Vector4)(ref plane))[2] * ((Vector4)(ref plane))[1];
reflectionMat.m22 = 1f - 2f * ((Vector4)(ref plane))[2] * ((Vector4)(ref plane))[2];
reflectionMat.m23 = -2f * ((Vector4)(ref plane))[3] * ((Vector4)(ref plane))[2];
reflectionMat.m30 = 0f;
reflectionMat.m31 = 0f;
reflectionMat.m32 = 0f;
reflectionMat.m33 = 1f;
}
}
public class KW_CausticDecal_CustomPass : CustomPass
{
private string profilerTag;
private Mesh decalMesh;
private Material causticDecalMaterial;
protected override void Setup(ScriptableRenderContext renderContext, CommandBuffer cmd)
{
((CustomPass)this).name = "Water.CausticDecalCustomPass";
}
public void UpdateParams()
{
WaterSystem currentWater = KW_WaterDynamicScripts.GetCurrentWater();
if ((Object)(object)causticDecalMaterial == (Object)null)
{
causticDecalMaterial = KW_Extensions.CreateMaterial(WaterShadersSingleton.Instance.CausticDecalShader);
}
if (!currentWater.waterSharedMaterials.Contains(causticDecalMaterial))
{
currentWater.waterSharedMaterials.Add(causticDecalMaterial);
}
}
protected override void Execute(CustomPassContext ctx)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
Camera camera = ctx.hdCamera.camera;
WaterSystem currentWater = KW_WaterDynamicScripts.GetCurrentWater();
if (KW_Extensions.IsCanExecuteCameraBuffers(camera, currentWater))
{
CommandBuffer cmd = ctx.cmd;
UpdateParams();
Vector3 position = ((Component)camera).transform.position;
position.y = ((Component)currentWater).transform.position.y - 20f;
float num = ((Vector4)(ref KW_CausticRendering.LodSettings))[currentWater.CausticActiveLods - 1] * 2f;
Matrix4x4 val = Matrix4x4.TRS(position, Quaternion.identity, new Vector3(num, 40f, num));
UpdateMaterialParams(currentWater);
if ((Object)(object)decalMesh == (Object)null)
{
decalMesh = CoreUtils.CreateCubeMesh(new Vector3(-0.5f, -0.5f, -0.5f), new Vector3(0.5f, 0.5f, 0.5f));
}
CoreUtils.SetRenderTarget(cmd, ctx.cameraColorBuffer, (ClearFlag)0, 0, (CubemapFace)(-1), -1);
cmd.DrawMesh(decalMesh, val, causticDecalMaterial);
}
}
private void UpdateMaterialParams(WaterSystem water)
{
causticDecalMaterial.SetFloat("KW_CaustisStrength", water.CausticStrength);
float num = 1f - (float)(Mathf.RoundToInt(Mathf.Log((float)water.FFT_SimulationSize, 2f)) - 5) / 4f;
if (water.UseCausticDispersion && num > 0.1f)
{
causticDecalMaterial.EnableKeyword("USE_DISPERSION");
num = Mathf.Lerp(num * 0.25f, num, (float)water.CausticTextureSize / 1024f);
causticDecalMaterial.SetFloat("KW_CausticDispersionStrength", num);
}
else
{
causticDecalMaterial.DisableKeyword("USE_DISPERSION");
}
}
protected override void Cleanup()
{
KW_Extensions.SafeDestroy((Object)causticDecalMaterial);
}
public void Release()
{
((CustomPass)this).Cleanup();
}
}
public class KW_CausticRendering : MonoBehaviour
{
public Texture2D depth_tex;
public RenderTexture causticLod0;
public RenderTexture causticLod1;
public RenderTexture causticLod2;
public RenderTexture causticLod3;
public RenderTexture causticRT;
private Material causticComputeMaterial;
private Material causticDecalMaterial;
private Mesh causticMesh;
private Mesh decalMesh;
private CommandBuffer cb;
private const string path_causticFolder = "CausticMaps";
private const string path_causticDepthTexture = "KW_CausticDepthTexture";
private const string path_causticDepthData = "KW_CausticDepthData";
private int ID_KW_CausticDepth = Shader.PropertyToID("KW_CausticDepthTex");
private int ID_KW_CausticDepthOrthoSize = Shader.PropertyToID("KW_CausticDepthOrthoSize");
private int ID_KW_CausticDepthNearFarDistance = Shader.PropertyToID("KW_CausticDepth_Near_Far_Dist");
private int ID_KW_CausticDepthPos = Shader.PropertyToID("KW_CausticDepthPos");
private const int nearPlaneDepth = -2;
private const int farPlaneDepth = 100;
private int currentMeshResolution;
private bool isDepthTextureInitialized;
public static Vector4 LodSettings = new Vector4(10f, 20f, 40f, 80f);
public void Release()
{
OnDisable();
}
private void OnDisable()
{
KW_Extensions.SafeDestroy((Object)depth_tex, (Object)causticComputeMaterial, (Object)causticDecalMaterial, (Object)causticMesh, (Object)decalMesh);
KW_Extensions.ReleaseRenderTextures(causticLod0, causticLod1, causticLod2, causticLod3, causticRT);
currentMeshResolution = 0;
isDepthTextureInitialized = false;
Sh
