public void Render(Camera camera, WaterGeometryType geometryType)
{
if (water == null || water.WaterMaterial == null || !water.isActiveAndEnabled)
{
return;
}
if ((camera.cullingMask & (1 << water.gameObject.layer)) == 0)
{
return;
}
var waterCamera = WaterCamera.GetWaterCamera(camera);
if ((!water.Volume.Boundless && water.Volume.HasRenderableAdditiveVolumes) && ((object)waterCamera == null || !waterCamera.RenderVolumes))
{
return;
}
MaterialPropertyBlock propertyBlock;
if ((object)waterCamera == null || !waterCamera.IsEffectCamera || waterCamera.MainCamera == null)
{
propertyBlock = GetMaterialPropertyBlock(camera);
//RenderMasks(camera, waterCamera, propertyBlock);
}
else
{
propertyBlock = GetMaterialPropertyBlock(waterCamera.MainCamera);
}
if ((object)waterCamera != null && water.ReceiveShadows)
{
Vector2 min = new Vector2(0.0f, 0.0f);
Vector2 max = new Vector2(1.0f, 1.0f);
waterCamera.ReportShadowedWaterMinMaxRect(min, max);
}
water.OnWaterRender(camera);
Matrix4x4 matrix;
var meshes = water.Geometry.GetTransformedMeshes(camera, out matrix, geometryType, false, (object)waterCamera != null ? waterCamera.ForcedVertexCount : 0);
for (int i = 0; i < meshes.Length; ++i)
{
Graphics.DrawMesh(meshes[i], matrix, water.WaterMaterial, water.gameObject.layer, camera, 0, propertyBlock, water.ShadowCastingMode, false, reflectionProbeAnchor == null ? water.transform : reflectionProbeAnchor);
if ((object)waterCamera == null || (waterCamera.ContainingWater != null && !waterCamera.IsEffectCamera))
{
Graphics.DrawMesh(meshes[i], matrix, water.WaterBackMaterial, water.gameObject.layer, camera, 0, propertyBlock, water.ShadowCastingMode, false, reflectionProbeAnchor == null ? water.transform : reflectionProbeAnchor);
}
}
}
public Mesh[] GetTransformedMeshes(Camera camera, out Matrix4x4 matrix, WaterGeometryType geometryType, bool volume, int vertexCount = 0)
{
if (vertexCount == 0)
{
vertexCount = this.ComputeVertexCountForCamera(camera);
}
if (this._Type == WaterGeometry.Type.CustomMeshes)
{
geometryType = WaterGeometryType.Auto;
}
switch (geometryType)
{
case WaterGeometryType.Auto:
switch (this._Type)
{
case WaterGeometry.Type.RadialGrid:
return(this._RadialGrid.GetTransformedMeshes(camera, out matrix, vertexCount, volume));
case WaterGeometry.Type.ProjectionGrid:
return(this._ProjectionGrid.GetTransformedMeshes(camera, out matrix, vertexCount, volume));
case WaterGeometry.Type.UniformGrid:
return(this._UniformGrid.GetTransformedMeshes(camera, out matrix, vertexCount, volume));
case WaterGeometry.Type.CustomMeshes:
return(this._CustomSurfaceMeshes.GetTransformedMeshes(null, out matrix, volume));
default:
throw new InvalidOperationException("Unknown water geometry type.");
}
break;
case WaterGeometryType.RadialGrid:
return(this._RadialGrid.GetTransformedMeshes(camera, out matrix, vertexCount, volume));
case WaterGeometryType.ProjectionGrid:
return(this._ProjectionGrid.GetTransformedMeshes(camera, out matrix, vertexCount, volume));
case WaterGeometryType.UniformGrid:
return(this._UniformGrid.GetTransformedMeshes(camera, out matrix, vertexCount, volume));
case WaterGeometryType.QuadGeometry:
return(this._QuadGeometry.GetTransformedMeshes(camera, out matrix, vertexCount, volume));
default:
throw new InvalidOperationException("Unknown water geometry type.");
}
}
public void Render(Camera camera, WaterGeometryType geometryType, CommandBuffer commandBuffer = null, Shader shader = null)
{
if (!this._Water.isActiveAndEnabled || (camera.cullingMask & 1 << this._Water.gameObject.layer) == 0)
{
return;
}
WaterCamera waterCamera = WaterCamera.GetWaterCamera(camera, false);
bool flag = waterCamera != null;
if (!flag || (!this._Water.Volume.Boundless && this._Water.Volume.HasRenderableAdditiveVolumes && !waterCamera.RenderVolumes))
{
return;
}
if (this._Water.ShaderSet.ReceiveShadows)
{
Vector2 min = new Vector2(0f, 0f);
Vector2 max = new Vector2(1f, 1f);
waterCamera.ReportShadowedWaterMinMaxRect(min, max);
}
if (!this._UseSharedMask)
{
this.RenderMasks(camera, waterCamera, this._PropertyBlock);
}
Matrix4x4 matrix;
Mesh[] transformedMeshes = this._Water.Geometry.GetTransformedMeshes(camera, out matrix, geometryType, false, waterCamera.ForcedVertexCount);
if (commandBuffer == null)
{
Camera camera2 = (waterCamera.RenderMode == WaterRenderMode.DefaultQueue) ? camera : waterCamera._WaterRenderCamera;
for (int i = 0; i < transformedMeshes.Length; i++)
{
Graphics.DrawMesh(transformedMeshes[i], matrix, this._Water.Materials.SurfaceMaterial, this._Water.gameObject.layer, camera2, 0, this._PropertyBlock, this._ShadowCastingMode, false, (!(this._ReflectionProbeAnchor != null)) ? this._Water.transform : this._ReflectionProbeAnchor, false);
if (waterCamera.ContainingWater != null && waterCamera.Type == WaterCamera.CameraType.Normal)
{
Graphics.DrawMesh(transformedMeshes[i], matrix, this._Water.Materials.SurfaceBackMaterial, this._Water.gameObject.layer, camera2, 0, this._PropertyBlock, this._ShadowCastingMode, false, (!(this._ReflectionProbeAnchor != null)) ? this._Water.transform : this._ReflectionProbeAnchor, false);
}
}
}
else
{
Material variant = UtilityShaderVariants.Instance.GetVariant(shader, this._Water.Materials.UsedKeywords);
for (int j = 0; j < transformedMeshes.Length; j++)
{
commandBuffer.DrawMesh(transformedMeshes[j], matrix, variant, 0, 0, this._PropertyBlock);
}
}
}
public Mesh[] GetTransformedMeshes(Camera camera, out Matrix4x4 matrix, WaterGeometryType geometryType, bool volume, int vertexCount = 0)
{
if (vertexCount == 0)
{
if (adaptToResolution)
{
vertexCount = Mathf.RoundToInt(thisSystemVertexCount * ((float)(camera.pixelWidth * camera.pixelHeight) / (1920 * 1080)));
}
else
{
vertexCount = thisSystemVertexCount;
}
}
switch (geometryType)
{
case WaterGeometryType.Auto:
{
switch (type)
{
case Type.RadialGrid: return(radialGrid.GetTransformedMeshes(camera, out matrix, vertexCount, volume));
case Type.ProjectionGrid: return(projectionGrid.GetTransformedMeshes(camera, out matrix, vertexCount, volume));
case Type.UniformGrid: return(uniformGrid.GetTransformedMeshes(camera, out matrix, vertexCount, volume));
case Type.CustomMeshes: return(customSurfaceMeshes.GetTransformedMeshes(null, out matrix, volume));
default: throw new System.InvalidOperationException("Unknown water geometry type.");
}
}
case WaterGeometryType.RadialGrid: return(radialGrid.GetTransformedMeshes(camera, out matrix, vertexCount, volume));
case WaterGeometryType.ProjectionGrid: return(projectionGrid.GetTransformedMeshes(camera, out matrix, vertexCount, volume));
case WaterGeometryType.UniformGrid: return(uniformGrid.GetTransformedMeshes(camera, out matrix, vertexCount, volume));
default: throw new System.InvalidOperationException("Unknown water geometry type.");
}
}
public Mesh[] GetMeshes(WaterGeometryType geometryType, int vertexCount, bool volume)
{
if (geometryType == WaterGeometryType.ProjectionGrid)
{
throw new System.InvalidOperationException("Projection grid needs camera to be retrieved. Use GetTransformedMeshes instead.");
}
Matrix4x4 matrix;
switch (geometryType)
{
case WaterGeometryType.Auto:
{
switch (type)
{
case Type.RadialGrid: return(radialGrid.GetTransformedMeshes(null, out matrix, vertexCount, volume));
case Type.ProjectionGrid: return(projectionGrid.GetTransformedMeshes(null, out matrix, vertexCount, volume));
case Type.UniformGrid: return(uniformGrid.GetTransformedMeshes(null, out matrix, vertexCount, volume));
case Type.CustomMeshes: return(customSurfaceMeshes.GetTransformedMeshes(null, out matrix, volume));
default: throw new System.InvalidOperationException("Unknown water geometry type.");
}
}
case WaterGeometryType.RadialGrid: return(radialGrid.GetTransformedMeshes(null, out matrix, vertexCount, volume));
case WaterGeometryType.ProjectionGrid: return(projectionGrid.GetTransformedMeshes(null, out matrix, vertexCount, volume));
case WaterGeometryType.UniformGrid: return(uniformGrid.GetTransformedMeshes(null, out matrix, vertexCount, volume));
default: throw new System.InvalidOperationException("Unknown water geometry type.");
}
}
public Mesh[] GetMeshes(WaterGeometryType geometryType, int vertexCount, bool volume)
{
if (geometryType == WaterGeometryType.ProjectionGrid)
{
throw new InvalidOperationException("Projection grid needs camera to be retrieved. Use GetTransformedMeshes instead.");
}
if (this._Type == WaterGeometry.Type.CustomMeshes)
{
geometryType = WaterGeometryType.Auto;
}
switch (geometryType)
{
case WaterGeometryType.Auto:
switch (this._Type)
{
case WaterGeometry.Type.RadialGrid:
{
Matrix4x4 matrix4x;
return(this._RadialGrid.GetTransformedMeshes(null, out matrix4x, vertexCount, volume));
}
case WaterGeometry.Type.ProjectionGrid:
{
Matrix4x4 matrix4x;
return(this._ProjectionGrid.GetTransformedMeshes(null, out matrix4x, vertexCount, volume));
}
case WaterGeometry.Type.UniformGrid:
{
Matrix4x4 matrix4x;
return(this._UniformGrid.GetTransformedMeshes(null, out matrix4x, vertexCount, volume));
}
case WaterGeometry.Type.CustomMeshes:
{
Matrix4x4 matrix4x;
return(this._CustomSurfaceMeshes.GetTransformedMeshes(null, out matrix4x, volume));
}
default:
throw new InvalidOperationException("Unknown water geometry type.");
}
break;
case WaterGeometryType.RadialGrid:
{
Matrix4x4 matrix4x;
return(this._RadialGrid.GetTransformedMeshes(null, out matrix4x, vertexCount, volume));
}
case WaterGeometryType.ProjectionGrid:
{
Matrix4x4 matrix4x;
return(this._ProjectionGrid.GetTransformedMeshes(null, out matrix4x, vertexCount, volume));
}
case WaterGeometryType.UniformGrid:
{
Matrix4x4 matrix4x;
return(this._UniformGrid.GetTransformedMeshes(null, out matrix4x, vertexCount, volume));
}
case WaterGeometryType.QuadGeometry:
{
Matrix4x4 matrix4x;
return(this._QuadGeometry.GetTransformedMeshes(null, out matrix4x, vertexCount, volume));
}
default:
throw new InvalidOperationException("Unknown water geometry type.");
}
}
