internal void OnWaterRender(WaterCamera waterCamera)
{
Vector2 surfaceOffset = this._Water.SurfaceOffset;
Vector4 vector = new Vector4(surfaceOffset.x, this._Water.transform.position.y, surfaceOffset.y, this._Water.UniformWaterScale);
if (vector.x != this._LastSurfaceOffset.x || vector.y != this._LastSurfaceOffset.y || vector.z != this._LastSurfaceOffset.z || vector.w != this._LastSurfaceOffset.w)
{
this._LastSurfaceOffset = vector;
this._Water.Renderer.PropertyBlock.SetVector(ShaderVariables.SurfaceOffset, vector);
this.UpdateGlobalLookupTexOffset();
}
Shader.SetGlobalColor(WaterMaterials._ParameterHashes[0], this.GetParameterValue(WaterMaterials.ColorParameter.AbsorptionColor));
if (waterCamera.Type == WaterCamera.CameraType.Normal)
{
int num;
if (waterCamera.RenderMode < WaterRenderMode.ImageEffectDeferred)
{
WaterQualityLevel currentQualityLevel = WaterQualitySettings.Instance.CurrentQualityLevel;
bool flag = this._Water.ShaderSet.TransparencyMode == WaterTransparencyMode.Refractive && currentQualityLevel.AllowAlphaBlending;
num = ((!flag) ? 1 : 2);
}
else
{
num = 1;
}
if (this._AlphaBlendMode != num)
{
this.SetBlendMode(num == 2);
}
}
}
public void UpdateSurfaceMaterial()
{
WaterQualityLevel currentQualityLevel = WaterQualitySettings.Instance.CurrentQualityLevel;
this.SurfaceMaterial.SetFloat(ShaderVariables.Cull, 2f);
float b = Mathf.Sqrt(2000000f / (float)Mathf.Min(this._Water.Geometry.TesselatedBaseVertexCount, WaterQualitySettings.Instance.MaxTesselatedVertexCount));
this._Water.Renderer.PropertyBlock.SetFloat("_TesselationFactor", Mathf.Lerp(1f, b, Mathf.Min(this._TesselationFactor, currentQualityLevel.MaxTesselationFactor)));
if (!Application.isPlaying)
{
bool blendMode = this._Water.ShaderSet.TransparencyMode == WaterTransparencyMode.Refractive && currentQualityLevel.AllowAlphaBlending;
if (Camera.main != null)
{
WaterCamera waterCamera = Camera.main.GetComponent <WaterCamera>();
if (waterCamera == null)
{
waterCamera = UnityEngine.Object.FindObjectOfType <WaterCamera>();
}
if (waterCamera != null && waterCamera.RenderMode < WaterRenderMode.ImageEffectDeferred)
{
this.SetBlendMode(blendMode);
}
else
{
this.SetBlendMode(false);
}
}
else
{
this.SetBlendMode(false);
}
}
this._Water.Renderer.PropertyBlock.SetFloat(WaterMaterials._ParameterHashes[23], -1f);
if (this._AlphaBlendMode != 0)
{
this.SetBlendMode(this._AlphaBlendMode == 2);
}
string name = this.SurfaceMaterial.shader.name;
if (name.Contains("_WAVES_FFT"))
{
this.SurfaceMaterial.EnableKeyword("_WAVES_FFT");
}
if (name.Contains("_BOUNDED_WATER"))
{
this.SurfaceMaterial.EnableKeyword("_BOUNDED_WATER");
}
if (name.Contains("_WAVES_ALIGN"))
{
this.SurfaceMaterial.EnableKeyword("_WAVES_ALIGN");
}
if (name.Contains("_WAVES_GERSTNER"))
{
this.SurfaceMaterial.EnableKeyword("_WAVES_GERSTNER");
}
if (this._Water.Geometry.Triangular)
{
this.SurfaceMaterial.EnableKeyword("_TRIANGLES");
}
}
private void BuildShaderVariant(ShaderVariant variant, WaterQualityLevel qualityLevel)
{
bool flag = this._TransparencyMode == WaterTransparencyMode.Refractive && qualityLevel.AllowAlphaBlending;
variant.SetWaterKeyword("_WATER_REFRACTION", flag);
variant.SetWaterKeyword("_CUBEMAP_REFLECTIONS", this._ReflectionProbeUsage != ReflectionProbeUsage.Off);
variant.SetWaterKeyword("_WATER_RECEIVE_SHADOWS", this._ReceiveShadows);
variant.SetWaterKeyword("_ALPHABLEND_ON", flag);
variant.SetWaterKeyword("_ALPHAPREMULTIPLY_ON", !flag);
variant.SetUnityKeyword("_TRIANGLES", this._CustomTriangularGeometry);
if (this._ProjectionGrid)
{
variant.SetAdditionalSurfaceCode("_PROJECTION_GRID", "\t\t\t#pragma multi_compile _PROJECTION_GRID_OFF _PROJECTION_GRID");
}
variant.SetUnityKeyword("_WATER_OVERLAYS", this._LocalEffectsSupported);
variant.SetUnityKeyword("_LOCAL_MAPS_DEBUG", this._LocalEffectsSupported && this._LocalEffectsDebug);
WindWavesRenderMode windWavesRenderMode = this.BuildWindWavesVariant(variant, qualityLevel);
variant.SetWaterKeyword("_WATER_FOAM_WS", this._Foam && !this._LocalEffectsSupported && windWavesRenderMode == WindWavesRenderMode.FullFFT);
variant.SetUnityKeyword("_BOUNDED_WATER", this._DisplayOnlyInAdditiveVolumes);
variant.SetUnityKeyword("_WAVES_ALIGN", this._WavesAlign);
variant.SetWaterKeyword("_NORMALMAP", this._NormalMappingMode == NormalMappingMode.Always || (this._NormalMappingMode == NormalMappingMode.Auto && windWavesRenderMode > WindWavesRenderMode.GerstnerAndFFTNormals));
variant.SetWaterKeyword("_EMISSION", this._SupportEmission);
variant.SetWaterKeyword("_PLANAR_REFLECTIONS", this._PlanarReflections == PlanarReflectionsMode.Normal);
variant.SetWaterKeyword("_PLANAR_REFLECTIONS_HQ", this._PlanarReflections == PlanarReflectionsMode.HighQuality);
}
internal void ResolveFinalSettings(WaterQualityLevel qualityLevel)
{
this._FinalHighQualityNormalMaps = this._Data.HighQualityNormalMaps;
if (!qualityLevel.AllowHighQualityNormalMaps)
{
this._FinalHighQualityNormalMaps = false;
}
if ((this._RenderedMaps & WavesRendererFFT.MapType.Displacement) == (WavesRendererFFT.MapType) 0)
{
this._FinalHighQualityNormalMaps = true;
}
}
private WindWavesRenderMode BuildWindWavesVariant(ShaderVariant variant, WaterQualityLevel qualityLevel)
{
WaterWavesMode wavesMode = qualityLevel.WavesMode;
WindWavesRenderMode windWavesRenderMode;
if (this._WindWavesMode == WindWavesRenderMode.Disabled || wavesMode == WaterWavesMode.DisallowAll)
{
windWavesRenderMode = WindWavesRenderMode.Disabled;
}
else if (this._WindWavesMode == WindWavesRenderMode.FullFFT && wavesMode == WaterWavesMode.AllowAll)
{
windWavesRenderMode = WindWavesRenderMode.FullFFT;
}
else if (this._WindWavesMode <= WindWavesRenderMode.GerstnerAndFFTNormals && wavesMode <= WaterWavesMode.AllowNormalFFT)
{
windWavesRenderMode = WindWavesRenderMode.GerstnerAndFFTNormals;
}
else
{
windWavesRenderMode = WindWavesRenderMode.Gerstner;
}
if (windWavesRenderMode != WindWavesRenderMode.FullFFT)
{
if (windWavesRenderMode != WindWavesRenderMode.GerstnerAndFFTNormals)
{
if (windWavesRenderMode == WindWavesRenderMode.Gerstner)
{
variant.SetUnityKeyword("_WAVES_GERSTNER", true);
}
}
else
{
variant.SetWaterKeyword("_WAVES_FFT_NORMAL", true);
variant.SetUnityKeyword("_WAVES_GERSTNER", true);
}
}
else
{
variant.SetUnityKeyword("_WAVES_FFT", true);
}
if (this._DynamicSmoothnessMode == DynamicSmoothnessMode.Physical)
{
variant.SetWaterKeyword("_INCLUDE_SLOPE_VARIANCE", true);
}
return(windWavesRenderMode);
}
internal void ResolveFinalSettings(WaterQualityLevel quality)
{
this.CreateObjects();
WaterWavesMode wavesMode = quality.WavesMode;
if (wavesMode == WaterWavesMode.DisallowAll)
{
this._WaterWavesFFT.Disable();
this._WaterWavesGerstner.Disable();
return;
}
bool flag = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.ARGBFloat) || SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.ARGBHalf);
int num = Mathf.Min(new int[]
{
this._Data.Resolution,
quality.MaxSpectrumResolution,
SystemInfo.maxTextureSize
});
bool flag2 = this._Data.HighPrecision && quality.AllowHighPrecisionTextures && SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.ARGBFloat);
WindWavesRenderMode windWavesMode = this._Water.ShaderSet.WindWavesMode;
if (windWavesMode == WindWavesRenderMode.FullFFT && wavesMode == WaterWavesMode.AllowAll && flag)
{
this._FinalRenderMode = WaveSpectrumRenderMode.FullFFT;
}
else if (windWavesMode <= WindWavesRenderMode.GerstnerAndFFTNormals && wavesMode <= WaterWavesMode.AllowNormalFFT && flag)
{
this._FinalRenderMode = WaveSpectrumRenderMode.GerstnerAndFFTNormals;
}
else
{
this._FinalRenderMode = WaveSpectrumRenderMode.Gerstner;
}
if (this._FinalResolution != num)
{
lock (this)
{
this._FinalResolution = num;
this._FinalHighPrecision = flag2;
if (this._SpectrumResolver != null)
{
this._SpectrumResolver.OnMapsFormatChanged(true);
}
if (this.ResolutionChanged != null)
{
this.ResolutionChanged.Invoke(this);
}
}
}
else if (this._FinalHighPrecision != flag2)
{
lock (this)
{
this._FinalHighPrecision = flag2;
if (this._SpectrumResolver != null)
{
this._SpectrumResolver.OnMapsFormatChanged(false);
}
}
}
WaveSpectrumRenderMode finalRenderMode = this._FinalRenderMode;
if (finalRenderMode != WaveSpectrumRenderMode.FullFFT)
{
if (finalRenderMode != WaveSpectrumRenderMode.GerstnerAndFFTNormals)
{
if (finalRenderMode == WaveSpectrumRenderMode.Gerstner)
{
this._WaterWavesFFT.Disable();
this._WaterWavesGerstner.Enable();
}
}
else
{
this._WaterWavesFFT.RenderedMaps = WavesRendererFFT.MapType.Normal;
this._WaterWavesFFT.Enable();
this._WaterWavesGerstner.Enable();
}
}
else
{
this._WaterWavesFFT.RenderedMaps = (WavesRendererFFT.MapType.Displacement | WavesRendererFFT.MapType.Normal);
this._WaterWavesFFT.Enable();
this._WaterWavesGerstner.Disable();
}
}
public void BuildShaderVariant(ShaderVariant variant, Water water, WindWaves windWaves, WaterQualityLevel qualityLevel)
{
variant.SetUnityKeyword("_WAVES_GERSTNER", this._Enabled);
}
