public void RenderLocalDiffuse(CommandBuffer commandBuffer, DynamicWaterCameraData overlays)
{
for (int i = 0; i < this._Renderers.Length; i++)
{
commandBuffer.DrawRenderer(this._Renderers[i], this._Renderers[i].material);
}
}
private void RenderParticles(DynamicWaterCameraData overlays)
{
Spray component = base.GetComponent <Spray>();
if (component != null && component.ParticlesBuffer != null)
{
Graphics.SetRandomWriteTarget(3, component.ParticlesBuffer);
}
if (!this._Water.ShaderSet.LocalEffectsDebug)
{
Graphics.SetRenderTarget(new RenderBuffer[]
{
overlays.DynamicDisplacementMap.colorBuffer,
overlays.NormalMap.colorBuffer
}, overlays.DynamicDisplacementMap.depthBuffer);
}
else
{
Graphics.SetRenderTarget(new RenderBuffer[]
{
overlays.DynamicDisplacementMap.colorBuffer,
overlays.NormalMap.colorBuffer,
overlays.GetDebugMap(true).colorBuffer
}, overlays.DynamicDisplacementMap.depthBuffer);
}
Shader.SetGlobalMatrix("_ParticlesVP", GL.GetGPUProjectionMatrix(overlays.Camera.PlaneProjectorCamera.projectionMatrix, true) * overlays.Camera.PlaneProjectorCamera.worldToCameraMatrix);
Vector4 localMapsShaderCoords = overlays.Camera.LocalMapsShaderCoords;
float uniformWaterScale = base.GetComponent <Water>().UniformWaterScale;
this._WaterWavesParticlesMaterial.SetFloat("_WaterScale", uniformWaterScale);
this._WaterWavesParticlesMaterial.SetVector("_LocalMapsCoords", localMapsShaderCoords);
this._WaterWavesParticlesMaterial.SetPass((!this._Water.ShaderSet.LocalEffectsDebug) ? 0 : 1);
this._Particles.Render(overlays.Camera.LocalMapsRect);
Graphics.ClearRandomWriteTargets();
}
public void RenderFoam(DynamicWaterCameraData overlays)
{
if (base.enabled)
{
this.RenderParticles(overlays);
}
}
public void RenderOverlays(DynamicWaterCameraData overlays)
{
Spray component = base.GetComponent <Spray>();
if (component != null && component.ParticlesBuffer != null)
{
Graphics.SetRandomWriteTarget(3, component.ParticlesBuffer);
}
this._RenderBuffers[0] = overlays.DynamicDisplacementMap.colorBuffer;
this._RenderBuffers[1] = overlays.NormalMap.colorBuffer;
this._ParticlesRenderMaterial.SetBuffer("_Particles", this._ParticlesA);
this._ParticlesRenderMaterial.SetMatrix("_ParticlesVP", GL.GetGPUProjectionMatrix(overlays.Camera.PlaneProjectorCamera.projectionMatrix, true) * overlays.Camera.PlaneProjectorCamera.worldToCameraMatrix);
if (this._ParticlesRenderMaterial.SetPass(0))
{
Graphics.SetRenderTarget(this._RenderBuffers, overlays.DynamicDisplacementMap.depthBuffer);
Graphics.DrawProceduralIndirect(MeshTopology.Points, this._ParticlesRenderInfo);
Graphics.ClearRandomWriteTargets();
}
if (this._ParticlesRenderMaterial.SetPass(2))
{
Graphics.SetRenderTarget(overlays.DisplacementsMask);
Graphics.DrawProceduralIndirect(MeshTopology.Points, this._ParticlesRenderInfo);
}
Graphics.SetRenderTarget(null);
}
private static void DrawDiffuseRenderers(DynamicWaterCameraData overlays)
{
List <ILocalDiffuseRenderer> localDiffuse = DynamicWater._Renderers.LocalDiffuse;
for (int i = localDiffuse.Count - 1; i >= 0; i--)
{
localDiffuse[i].Enable();
}
Shader.SetGlobalTexture("_CameraDepthTexture", DefaultTextures.Get(Color.white));
Camera cameraComponent = overlays.Camera.CameraComponent;
GL.PushMatrix();
GL.modelview = cameraComponent.worldToCameraMatrix;
GL.LoadProjectionMatrix(cameraComponent.projectionMatrix);
DynamicWater._RenderDiffuseBuffer.Clear();
DynamicWater._RenderDiffuseBuffer.SetRenderTarget(overlays.DiffuseMap);
for (int j = localDiffuse.Count - 1; j >= 0; j--)
{
localDiffuse[j].RenderLocalDiffuse(DynamicWater._RenderDiffuseBuffer, overlays);
}
Graphics.ExecuteCommandBuffer(DynamicWater._RenderDiffuseBuffer);
GL.PopMatrix();
for (int k = localDiffuse.Count - 1; k >= 0; k--)
{
localDiffuse[k].Disable();
}
}
public void RenderLocalMask(CommandBuffer commandBuffer, DynamicWaterCameraData overlays)
{
Vector3 position = this._InteractionMaskRenderer.transform.position;
position.y = overlays.DynamicWater.Water.transform.position.y;
this._InteractionMaskRenderer.transform.position = position;
commandBuffer.DrawMesh(this._InteractionMaskRenderer.GetComponent <MeshFilter>().sharedMesh, this._InteractionMaskRenderer.transform.localToWorldMatrix, this._InteractionMaskMaterial, 0, 0);
}
public void RenderLocalDisplacement(CommandBuffer commandBuffer, DynamicWaterCameraData overlays)
{
if (this._Type != WaterProjector.Type.Displacement || this._Displacement == null)
{
return;
}
for (int i = 0; i < this._Renderers.Length; i++)
{
commandBuffer.DrawRenderer(this._Renderers[i], this._Displacement);
}
}
public void RenderLocalDiffuse(CommandBuffer commandBuffer, DynamicWaterCameraData overlays)
{
if (this._Type != WaterProjector.Type.Diffuse)
{
return;
}
for (int i = 0; i < this._Renderers.Length; i++)
{
commandBuffer.DrawRenderer(this._Renderers[i], this._Renderers[i].sharedMaterial);
}
}
public void RenderFoam(DynamicWaterCameraData overlays)
{
if (this._ParticlesRenderMaterial.SetPass(1))
{
Graphics.SetRenderTarget(overlays.FoamMap);
Graphics.DrawProceduralIndirect(MeshTopology.Points, this._ParticlesRenderInfo);
}
if (this._ParticlesRenderMaterial.SetPass(3))
{
Graphics.DrawProceduralIndirect(MeshTopology.Points, this._ParticlesRenderInfo);
}
}
internal override void OnWaterRender(WaterCamera waterCamera)
{
Camera cameraComponent = waterCamera.CameraComponent;
if (waterCamera.Type != WaterCamera.CameraType.Normal || !Application.isPlaying)
{
return;
}
if (!WaterProjectSettings.Instance.RenderInSceneView && WaterUtilities.IsSceneViewCamera(cameraComponent))
{
return;
}
Shader.SetGlobalVector("_TileSizesInv", this._Water.WindWaves.TileSizesInv);
DynamicWaterCameraData cameraOverlaysData = this.GetCameraOverlaysData(cameraComponent, true);
cameraOverlaysData.SwapFoamMaps();
cameraOverlaysData.ClearOverlays();
DynamicWater.DrawDisplacementMaskRenderers(cameraOverlaysData);
DynamicWater.DrawDisplacementRenderers(cameraOverlaysData);
for (int i = 0; i < this._OverlayRenderers.Length; i++)
{
this._OverlayRenderers[i].RenderOverlays(cameraOverlaysData);
}
if (this._Water.Foam != null)
{
this._Water.Foam.RenderOverlays(cameraOverlaysData);
}
for (int j = 0; j < this._OverlayRenderers.Length; j++)
{
this._OverlayRenderers[j].RenderFoam(cameraOverlaysData);
}
int localDiffuseMap = ShaderVariables.LocalDiffuseMap;
MaterialPropertyBlock propertyBlock = this._Water.Renderer.PropertyBlock;
propertyBlock.SetTexture(ShaderVariables.LocalDisplacementMap, cameraOverlaysData.DynamicDisplacementMap);
propertyBlock.SetTexture(ShaderVariables.LocalNormalMap, cameraOverlaysData.NormalMap);
propertyBlock.SetTexture(ShaderVariables.TotalDisplacementMap, cameraOverlaysData.TotalDisplacementMap);
propertyBlock.SetTexture(ShaderVariables.DisplacementsMask, cameraOverlaysData.DisplacementsMask);
propertyBlock.SetTexture(localDiffuseMap, cameraOverlaysData.DiffuseMap);
Shader.SetGlobalTexture("DIFFUSE", cameraOverlaysData.DiffuseMap);
RenderTexture debugMap = cameraOverlaysData.GetDebugMap(false);
if (debugMap != null)
{
propertyBlock.SetTexture("_LocalDebugMap", debugMap);
}
if (waterCamera.MainWater == this._Water)
{
Shader.SetGlobalTexture(ShaderVariables.TotalDisplacementMap, cameraOverlaysData.TotalDisplacementMap);
}
DynamicWater.DrawFoamRenderers(cameraOverlaysData);
DynamicWater.DrawDiffuseRenderers(cameraOverlaysData);
}
public void RenderFoam(DynamicWaterCameraData overlays)
{
if (!base.enabled)
{
return;
}
this.CheckResources();
if (this._SprayToFoam)
{
this.GenerateLocalFoam(overlays);
}
}
private void GenerateLocalFoam(DynamicWaterCameraData data)
{
RenderTexture temporary = RenderTexture.GetTemporary(512, 512, 0, RenderTextureFormat.RHalf, RenderTextureReadWrite.Linear);
Graphics.SetRenderTarget(temporary);
GL.Clear(false, true, new Color(0f, 0f, 0f, 0f));
this._SprayToFoamMaterial.SetBuffer("_Particles", this._ParticlesA);
this._SprayToFoamMaterial.SetVector("_LocalMapsCoords", data.Camera.LocalMapsShaderCoords);
this._SprayToFoamMaterial.SetFloat("_UniformWaterScale", 50f * this._Water.UniformWaterScale / data.Camera.LocalMapsRect.width);
Vector4 vector = this._SprayMaterial.GetVector("_ParticleParams");
vector.x *= 8f;
vector.z = 1f;
this._SprayToFoamMaterial.SetVector("_ParticleParams", vector);
int num = this._PropertyBlocks.Length;
for (int i = 0; i < num; i++)
{
this._SprayToFoamMaterial.SetFloat("_ParticleOffset", (float)(i * 65535));
if (this._SprayToFoamMaterial.SetPass(0))
{
Graphics.DrawMeshNow(this._Mesh, Matrix4x4.identity, 0);
}
}
Camera planeProjectorCamera = data.Camera.PlaneProjectorCamera;
Rect localMapsRect = data.Camera.LocalMapsRect;
Vector2 center = localMapsRect.center;
float num2 = localMapsRect.width * 0.5f;
Matrix4x4 matrix = new Matrix4x4
{
m03 = center.x,
m13 = this._Water.transform.position.y,
m23 = center.y,
m00 = num2,
m11 = num2,
m22 = num2,
m33 = 1f
};
GL.PushMatrix();
GL.modelview = planeProjectorCamera.worldToCameraMatrix;
GL.LoadProjectionMatrix(planeProjectorCamera.projectionMatrix);
Graphics.SetRenderTarget(data.FoamMap);
this._SprayToFoamMaterial.mainTexture = temporary;
if (this._SprayToFoamMaterial.SetPass(1))
{
Graphics.DrawMeshNow(Quads.BipolarXZ, matrix, 0);
}
GL.PopMatrix();
RenderTexture.ReleaseTemporary(temporary);
}
private static void DrawDisplacementMaskRenderers(DynamicWaterCameraData overlays)
{
Shader.SetGlobalTexture("_CameraDepthTexture", DefaultTextures.Get(Color.white));
Camera cameraComponent = overlays.Camera.CameraComponent;
GL.PushMatrix();
GL.modelview = cameraComponent.worldToCameraMatrix;
GL.LoadProjectionMatrix(cameraComponent.projectionMatrix);
DynamicWater._RenderDisplacementMaskBuffer.Clear();
DynamicWater._RenderDisplacementMaskBuffer.SetRenderTarget(overlays.DisplacementsMask);
List <ILocalDisplacementMaskRenderer> localDisplacementMask = DynamicWater._Renderers.LocalDisplacementMask;
for (int i = localDisplacementMask.Count - 1; i >= 0; i--)
{
localDisplacementMask[i].RenderLocalMask(DynamicWater._RenderDisplacementMaskBuffer, overlays);
}
Graphics.ExecuteCommandBuffer(DynamicWater._RenderDisplacementMaskBuffer);
GL.PopMatrix();
}
private static void DrawDisplacementRenderers(DynamicWaterCameraData overlays)
{
Camera cameraComponent = overlays.Camera.CameraComponent;
DynamicWater._CustomEffectsBuffers[0] = overlays.DynamicDisplacementMap;
DynamicWater._CustomEffectsBuffers[1] = overlays.NormalMap;
GL.PushMatrix();
GL.modelview = cameraComponent.worldToCameraMatrix;
GL.LoadProjectionMatrix(cameraComponent.projectionMatrix);
DynamicWater._RenderDisplacementBuffer.Clear();
DynamicWater._RenderDisplacementBuffer.SetRenderTarget(DynamicWater._CustomEffectsBuffers, overlays.DynamicDisplacementMap);
List <ILocalDisplacementRenderer> localDisplacement = DynamicWater._Renderers.LocalDisplacement;
for (int i = localDisplacement.Count - 1; i >= 0; i--)
{
localDisplacement[i].RenderLocalDisplacement(DynamicWater._RenderDisplacementBuffer, overlays);
}
Graphics.ExecuteCommandBuffer(DynamicWater._RenderDisplacementBuffer);
GL.PopMatrix();
}
private void UpdateParticles()
{
Vector2 vector = this._WindWaves.WindSpeed * 0.0008f;
Vector3 gravity = Physics.gravity;
float deltaTime = Time.deltaTime;
if (this._Overlays != null)
{
DynamicWaterCameraData cameraOverlaysData = this._Overlays.GetCameraOverlaysData(Camera.main, false);
if (cameraOverlaysData != null)
{
this._SprayControllerShader.SetTexture(0, "TotalDisplacementMap", cameraOverlaysData.TotalDisplacementMap);
WaterCamera waterCamera = WaterCamera.GetWaterCamera(Camera.main, false);
if (waterCamera != null)
{
this._SprayControllerShader.SetVector("localMapsCoords", waterCamera.LocalMapsShaderCoords);
}
}
else
{
this._SprayControllerShader.SetTexture(0, "TotalDisplacementMap", this.GetBlankWhiteTex());
}
}
else
{
this._SprayControllerShader.SetTexture(0, "TotalDisplacementMap", this.GetBlankWhiteTex());
}
Vector2 surfaceOffset = this._Water.SurfaceOffset;
this._SprayControllerShader.SetVector("deltaTime", new Vector4(deltaTime, 1f - deltaTime * 0.2f, 0f, 0f));
this._SprayControllerShader.SetVector("externalForces", new Vector3((vector.x + gravity.x) * deltaTime, gravity.y * deltaTime, (vector.y + gravity.z) * deltaTime));
this._SprayControllerShader.SetVector("surfaceOffsetDelta", new Vector3(this._LastSurfaceOffset.x - surfaceOffset.x, 0f, this._LastSurfaceOffset.y - surfaceOffset.y));
this._SprayControllerShader.SetFloat("surfaceOffsetY", base.transform.position.y);
this._SprayControllerShader.SetVector("waterTileSizesInv", this._WindWaves.TileSizesInv);
this._SprayControllerShader.SetBuffer(0, "SourceParticles", this._ParticlesB);
this._SprayControllerShader.SetBuffer(0, "TargetParticles", this._ParticlesA);
this._SprayControllerShader.Dispatch(0, this._MaxParticles / 256, 1, 1);
this._LastSurfaceOffset = surfaceOffset;
}
public void RenderOverlays(DynamicWaterCameraData overlays)
{
}
public void RenderLocalFoam(CommandBuffer commandBuffer, DynamicWaterCameraData overlays)
{
commandBuffer.DrawRenderer(this._RendererComponent, this._FoamMaterial);
}
public void RenderLocalDisplacement(CommandBuffer commandBuffer, DynamicWaterCameraData overlays)
{
commandBuffer.DrawMesh(this._MeshFilter.sharedMesh, base.transform.localToWorldMatrix, this._DisplacementMaterial);
}
public void RenderLocalMask(CommandBuffer commandBuffer, DynamicWaterCameraData overlays)
{
commandBuffer.DrawRenderer(this._RendererComponent, this._DisplacementMaskMaterial);
}
