Since transparent surfaces do not have any depth, it’s not possible to sort them on a per-pixel basis. This is the case for any transparent shader, not just this water shader.

Instead, transparent material are sorted based on:

• Their position (pivot point distance from camera)
• Material’s render queue value
• Renderer’s sorting group value

This determines which material should draw over the other. For more information see the Unity manual page (also applies to perspective camera setups).

To remedy this:

• Set the “Order in layer” value on the Sprite/Particle System (found in the Rendering section) to a value higher than 0. This way it’ll always draw over the water
• (Or) On the particle material, increase the “Priority” value by one
• (Or) Set the render queue on the water material to 2999 (found under the “Rendering” tab). It’ll render behind everything else.
• Fallback: Enable the “Alpha clipping” option on the transparent material

Alternatively, turn on the “ZWrite” option on the water material, found under the “Rendering” tab.

ZWrite ON: Transparent materials will properly intersect with the water, parts can be above and below the water. As long as they’re on the same render queue.
ZWrite OFF: Transparent materials are sorted based on their position, order in layer and the material’s render queue (labeled “Priority” on URP’s particle shader). They will either render behind or in front of the water.

Caustics are a depth-based effect and rely on URP rendering its depth texture.

This warping typically occurs when rendering the water on an Overlay camera, which isn’t technically possible due to design restrictions of URP’s camera stacking system.

If everything in the reflection appears black, it’s because your scene does not have a reflection probe set up.

This is always the case for brand new scene starting from Unity 2023.1. Go to Window–>Rendering–>Lighting Settings and disable “Baked Global Illumination” check the “Auto generate” checkbox. Wait for the baking to finish, then disable it again.

This will trigger the generation of a “global” reflection probe for the scene and will allow the water to reflect the skybox. It’s only required to do this once per scene.

Alternatively: Go to GameObject–>Light–>Reflection probe. Ensure the reflection probe box at least touches the water.

This only applies when the “Refraction” feature is enabled, which relies on the render pipeline creating an “Opaque texture”, for the shader to then use.

Ensure this option is enabled in your (currently active) pipeline asset:

Without this, the shader receives a gray texture as an input (Unity’s default “null” texture)

Water materials that have River Mode enabled may have the vertex-color transparency option enabled. If your (custom) river mesh is filled with White vertex colors, it will be rendered 100% transparent as a result.

Disable this here:

The River material used in the demo scene has this option enabled, because the geometry used there uses vertex colors. The River material included in the “Materials” folder does not have this enabled, to avoid users encountering seemingly invisible water geometry.

The refraction features make use of the Opaque Texture URP renders. As the name implies, this texture represents the screen’s image right after opaque geometry is drawn but before transparent materials are rendered (including water).

Because of this, transparent materials aren’t captured in this texture, thus can’t be refracted.

First, ensure the “Opaque downsampling” option in the pipeline asset in use is set to “None”. This will mitigate the issue.

Finally, turn down the Chromatic Aberration parameter on the water material (under the Underwater tab)

It’s likely, when the game is running on the device, a different Quality profile is used than in the editor.

If you have different pipeline assets assigned, per quality level, ensure the “Depth Texture” option is also enabled for them.

See the Getting Started page for more details.

The effect relies on the depth texture Unity renders, which provides a means to measure the distance from the water surface to an object’s pixel on screen.

As such, materials that don’t write to the depth texture will not be affected. This usually means:

• Transparent materials (water/particles/etc)
• Unlit materials (before Unity 2021.1)
• Sprites
• UI elements
• Details/grass rendered through the terrain system
• Custom (handwritten) shaders without a DepthOnly pass
• Anything rendered through a custom render loop, without a depth buffer (if you’re developing this, you probably already know this)

This is a known issue, but the exact reason why this happens is still unknown at the time.

The shader code implementation for Forward+ rendering has been copied from Unity’s URP shaders, yet something appears to be wrong or missing. There is absolutely no documentation on how this feature works and how to implement this. Hence, further investigation is necessary.

This error is valid, but ultimately harmless. VFX Graphs always execute right at the start of a frame, at which point the Water Height Prepass hasn’t executed yet, which means the render target called “_WaterHeightBuffer” does not yet exist.

There is unfortunately no solution for this, Unity has to be provide control over the executing of a VFX Graph, or provide an injection point.

This shader error is specific to Unity 6000.0.8f1 (or older). Update to at least 6000.0.15f1 or newer.

The error is absolutely false, since the file it refers to is actually there. But sometimes Unity’s shader compiler messes up the importing order, or caches too aggressively. 

You can right-click on the Shaders folder and choose “Re-import”, to give the compiler a good kick. You may need to delete the Library/ShaderCache folder from your Unity project (perfectly safe!), in order to really-really clear the faulty compiled shader.

When using the GPU method the water height is fetched on the main thread’s rendering loop. The editor’s UI is also being redrawn at the same time.

This is creating a conflict and causes the height values being read to be invalid, temporarily. Not a problem during gameplay!

On the water material, you’ll notice an error that indicates that the “Depth texture” option is disabled in your URP settings. Click the “Enable” button next to it to enable this. After which, the water will render correctly.

Ensure Dynamic Clipping is enabled:

Alternatively, disabled it and bump up the “Near” value to ~0.5, or select a nearby object (F-key)

In the scene view bar, check if the “Always Refresh” option is enabled.

If not, any kind of shader animation only update when the scene view is refreshed (eg. selecting something or moving the camera).

The color gradient and intersection effects are both based on the depth texture Unity renders. On mobile platforms, this depth texture is of lower precision, so it’s possible any depth-based effect pans out a little differently.

To increase the accuracy of the depth texture:

• Ensure the camera’s far clipping plane value (set on the Camera component) is as small as possible.
  • For orthographic camera’s, move the camera position as close as possible.
• Increase the near plane value. If no objects come near the camera, you can get away with this.

The intersection foam effect is based on the depth texture Unity renders. On mobile platforms, this depth texture may be of lower precision than on PC/Consoles.

Jittering may occur when:

• The camera is very far away from the water surface
• The water is very shallow

In these case the depth value (of any given pixel) may be very close to that of the geometry behind it (eg. 0.98553 vs 0.98554). Typically in very shallow water, such as shorelines. Due to floating point rounding errors, these values may appear to jitter back and forth, which translates to a visual artefact. This is comparable to Z-Fighting.

Solutions:

• Limit the maximum render range by decreasing the camera’s far clipping plane value (set on the Camera component).
• Ensure the water is fairly deep (problematic for beaches)
• Draw the foam/depth effect through Vertex Colors so that it is based on static data (ultimate solution).

This whole ordeal pertains to the general working of 3D rendering and is not something the water shader can circumvent, nor does it mean it’s broken.

The UV coordinates for the water textures (normal map and foam) are animated. Which means the values are offset every frame by a small increment. Over time, these values run up, to the point where floating point rounding errors start to occur.

There is already a technique in place, that greatly reduces this artefact on low end hardware. Though, after ~6 hours this starts to become inevitable.

Solutions:

• Set the “UV Coordinates” (General tab) to “Mesh UV” preferably
• Lower the speed of the animations

This issue is caused by transparency sorting, mobile devices are less accurate in this manner, especially with orthographic cameras.

To rectify this:

• Reduce the “Far clipping plane” on your camera until it starts to clip your geometry. By default this is set to 1000 units, which is overkill for orthographic scenes.
• Increasing the “Near” value.
• Move the camera as close to the environment as possible.

These steps reduce the rendering range for the camera and therefore increase the accuracy of sorting. After which, the water should render correctly.

This is entirely attributed to the result of texture compression.

You can disable compression on the normal map that is being used on the material to resolve this, at the cost of more memory (~4x).

Objects rendered after transparent materials, such as through the Render Objects render feature or Overlay cameras will show these artifacts.

This is because these objects will render after the water has been. As such, when the water shader renders it’ll have no access to the geometry data, and can’t filter them out.

If the “Disable Depth Texture” option is enabled (found under the Rendering tab), these artefacts are also visible.

This scene uses a 16k terrain, where the scene camera is 20.000 units away. At this point you’re inevitably running into floating point precision issues. On water pixels with the skybox directly behind it, depth values are reaching infinity and causes artifacts to show.

In any normal situation, this won’t occur. Otherwise, ensure there is some geometry behind/underneath the water.