Water is one of the most challenging materials to simulate in real-time graphics. Its dynamic nature—shifting between smooth glass-like surfaces and choppy, turbulent waves—demands a careful blend of physics-based rendering, artistic intuition, and performance-aware programming. Achieving convincing reflection and refraction on a water surface can elevate a game or visual effects shot from good to breathtaking. This article distills the essential methods used by industry professionals to create water that behaves plausibly under any lighting condition. Whether you are working in Unreal Engine, Unity, or your own renderer, the principles and code-level techniques here will give you a solid foundation.

The Physics of Reflection and Refraction on Water

Before diving into implementation, it is important to understand the physical phenomena we are mimicking. When light hits a water surface, part of it bounces off (reflection) and part penetrates the surface (refraction). The proportion of reflected versus transmitted light depends on the angle of incidence and the water’s refractive index. This angular dependence is known as the Fresnel effect, and it is the reason calm water appears nearly mirror-like at grazing angles but transparent when viewed straight down. Snell’s law describes the bending of light as it passes from one medium (air) to another (water), with the index of refraction (IOR) for water typically taken as 1.333. Additionally, light that penetrates the surface can be scattered or absorbed by suspended particles, giving water its characteristic blue-green tint. A good water shader must account for Fresnel, IOR, and scattering to look natural.

Core Techniques for Realistic Reflection

Reflection Maps and Cubemaps

The simplest and most performant method for water reflections is using pre-baked environment cubemaps. These cube textures capture the surrounding scene from a fixed point and can be sampled in the shader. High-resolution cubemaps significantly improve clarity, but they suffer from parallax issues—the environment does not update as the camera or water moves. For static water features or distant bodies of water, cubemaps remain a solid choice. To improve accuracy, use a local cubemap captured at the center of the water plane, or employ distance-based blending between multiple probes.

Screen Space Reflections (SSR)

Screen Space Reflections are a popular real-time technique that reflects only the pixels already visible on screen. By ray-marching in screen space, SSR can produce dynamic, frame-accurate reflections without pre-computation. The main drawbacks are that objects off-screen will not reflect, and there can be artifacts near screen edges. Most engines allow you to combine SSR with cubemaps as a fallback. For water, SSR works well when the camera is close to the water surface and the scene is not too cluttered. Unreal Engine’s SSR system includes temporal accumulation to reduce noise, which is especially useful for water.

Reflection Probes

Reflection probes capture the environment from a point in 3D space and store it as a cubemap or spherical harmonics. By placing probes around the scene and enabling blending, you can achieve much better local accuracy than a single global cubemap. For water, try placing a reflection probe just above the water surface, and another slightly below to capture underwater reflections. Many engines support real-time reflection probes that update every frame, but they are expensive. A balanced approach is to use static probes for distant environments (sky, mountains) and a single real-time probe for the water’s immediate vicinity.

Planar Reflections vs. Ray Traced Reflections

Planar reflections render the scene again from a camera mirrored against the water plane. This produces perfect reflections (including off-screen objects) but doubles geometry rendering cost. They are feasible for small water surfaces (puddles, small pools). For larger bodies of water, hardware-accelerated ray tracing (NVIDIA RTX, AMD RDNA2+) offers the highest quality. Ray traced reflections (RTR) accurately handle multiple bounces, correct parallax, and reflections of reflections. Unity’s ray tracing support allows you to combine it with screen space methods. However, ray tracing is still expensive and often requires denoising, so it is best reserved for high-end platforms or pre-rendered cinematics.

Core Techniques for Realistic Refraction

Refraction Maps and Normal Distortion

The simplest way to fake refraction is to use a normal map to perturb the screen-space UV coordinates when sampling the background behind the water. This creates the characteristic wobbly view of underwater objects. For better results, combine the normal map with a distortion texture that provides large-scale displacement over time. When using this method, remember to clamp the offset to avoid sampling outside the visible area. Most engines provide a Scene Color node (Unreal) or GrabPass (Unity) to access the rendered frame for distortion.

Index of Refraction (IOR)

The IOR controls how much light bends when entering water. While the real IOR of water is 1.333, artists often tune it for aesthetic effect. In a shader, the IOR is used in Snell’s law to compute the refracted direction. In real-time, you can simulate this by computing the refracted ray direction in the pixel shader and then sampling a cubemap or background. For a more accurate simulation, compute the refraction vector and use it to offset UV coordinates for the underwater scene. ShaderToy examples demonstrate how to implement IOR-based refraction with Fresnel blending.

Subsurface Scattering for Shallow Water

Shallow water (e.g., a turquoise tropical shore) looks distinct from deep ocean because light penetrates, scatters off the bottom, and returns. Subsurface scattering (SSS) can be approximated by sampling the water’s normal map multiple times with increasing blur and adding color from a seabed texture or depth map. A simpler alternative is to use a depth-based color gradient where shallow areas receive a brighter, greener hue. For realistic shallow water, combine a bottom albedo texture with a scattering thickness map. Many game engines allow you to set a Scattering or Transmittance parameter in the water shader.

Chromatic Dispersion

Dispersion occurs because different wavelengths of light refract at slightly different angles. On water, this creates subtle rainbow-like color fringes along the edges of refracted objects. While rarely noticeable on still water, it becomes visible in ripples or droplets. To implement this, compute the refraction vector separately for red, green, and blue using slightly different IOR values (e.g., 1.331, 1.333, 1.336). Then sample the background for each channel and combine. Use a small amount of dispersion to avoid an overly chromatic look.

Advanced Shader Programming

Fresnel Effect Implementation

The Fresnel effect determines the mix between reflection and refraction. The standard Schlick approximation works well for water: F = F0 + (1 – F0) * (1 – cos θ)^5, where F0 is the reflectivity at normal incidence (about 0.02 for water) and θ is the angle between the view direction and the surface normal. In a shader, you can compute this factor and use it to lerp between the reflected color and the refracted color. For extra realism, modulate Fresnel with surface roughness—a rough water surface (foam, waves) reduces the impact of the Fresnel effect.

Wave Simulation and Surface Perturbation

Realistic water surfaces are never perfectly flat. Wave simulation can be done with Gerstner waves (for deep, rolling waves), FFT-based ocean simulation (for large bodies of water), or simple sine wave sums (for small lakes or pools). The generated heightfield and normals drive both reflection and refraction. Gerstner waves produce more natural crests and troughs than sine waves. For an open ocean, an FFT approach using ocean spectrum models (Phillips or JONSWAP) yields animated wave patterns that evolve over time. NVIDIA’s GPU Gems chapter on water simulation remains a classic reference. Once you have the normal map from the waves, use it to perturb the reflection and refraction sampling in the shader.

Caustics

Caustics are the bright patterns of focused light that appear on the seabed or underwater surfaces. They are a direct result of refraction through a wavy water surface. To simulate caustics, project a repeating texture (or a procedural pattern) that follows the surface wave motion onto the underwater geometry. A common technique is to use a caustics texture scrolling in two directions, multiplied by a depth fade. For higher quality, render the caustics from the water surface’s point of view using a separate render pass. Many engines provide built-in caustic functions; for custom shaders, you can use the wave height and slope to procedurally generate caustic intensity.

Combining Reflection and Refraction in Custom Shaders

A production water shader must blend reflection and refraction seamlessly. The typical pipeline is:

  1. Sample the wave-normal map and compute the perturbed normal.
  2. Compute the view vector and use it with the Fresnel approximation to get the blend factor.
  3. Compute the reflection direction (reflect the view vector across the normal) and sample the reflection source (cubemap, SSR, or ray traced).
  4. Compute the refraction direction (Snell’s law) and sample the background (scene color or an underwater cubemap). Optionally add depth-based color and scattering.
  5. Lerp between reflected and refracted colors using the Fresnel factor. Then add specular highlights, caustics, and foam.

This approach gives you full control to tune each component separately. Remember to antialias the reflection and refraction samples, especially when using screen-space techniques.

Performance Optimization

Mipmapping and LOD

Water surfaces can occupy a large portion of the screen, making texture and cubemap sampling expensive. Use mipmapped cubemaps and enable anisotropic filtering on reflection maps. For refraction, only apply distortion to the screen-space sample when the camera is near the water; far away, the distortion becomes invisible. Implement LOD for wave simulation: use coarse wave grids for distant tiles and fine grids for the region near the camera. Many engines support terrain LOD streaming for water.

Screen-Space Techniques and Temporal Anti-Aliasing

SSR and screen-space refraction can be noisy and flickering. Apply temporal anti-aliasing (TAA) to smooth the reflections over frames. However, TAA can cause ghosting if the water moves fast; use motion vectors to reproject earlier samples. For SSR, reduce the number of ray steps and use a half-resolution pass combined with bilateral upsampling. Also, limit the reflection distance—only trace rays within a few meters of the surface.

Efficient Wave Simulation

Full FFT ocean simulation on the GPU is costly but can be spread across multiple frames. A common technique is to compute the wave height grid using compute shaders once every few frames and interpolate between them. For simpler waves, a sum of a few sine waves (e.g., 8–16) with carefully tuned frequencies and amplitudes can produce convincing motion at negligible GPU cost. Use vertex shaders to displace vertices for distant wave tiles, and pixel shader normals for close-up details.

Tools and Platforms

Unreal Engine Water System

Unreal Engine 5 provides a built-in Water system with support for ocean, lake, and river. It uses a combination of wave simulation, SSR, reflection probes, and a custom shader that handles Fresnel, refraction, and caustics. The system is highly configurable and includes shore-line foam and underwater post-processing. For advanced users, the water shader is editable in the Material Editor. Refer to the official documentation for setup details.

Unity Water

Unity’s High Definition Render Pipeline (HDRP) includes a water system similar to Unreal’s, with GPU-based wave simulation, SSR, and screen-space refraction. The Universal Render Pipeline (URP) has a simpler water shader but can be extended using custom shaders or assets from the Asset Store. For projects requiring custom water, Unity’s Shader Graph combined with C# scripts for wave animation offers a good balance of flexibility and performance.

Houdini and SideFX

For pre-rendered or offline water, Houdini’s FLIP solver is industry-standard for realistic physics simulations. It can generate highly detailed meshes with accurate reflection and refraction for visual effects. While not real-time, the principles of wave behavior and light interaction are directly transferable to real-time shaders.

Real-Time Ray Tracing with Vulkan and DirectX

If you are building your own engine, modern graphics APIs like Vulkan and DirectX 12 Ultimate support ray tracing extensions. You can implement water with ray-traced reflections and refractions using acceleration structures. This gives you the highest possible quality, but it demands careful denoising and performance budgeting. The NVIDIA RTX Developer site provides sample code and best practices for integrating ray tracing into water shaders.

Best Practices and Troubleshooting

  • Start simple, then layer complexity. Build a functional water shader with a single cubemap and basic Fresnel before adding SSR, caustics, or wave simulation.
  • Use the camera distance to fade effects. Far water needs only a simple cubemap reflection; near water can use expensive ray marching.
  • Test under different lighting conditions. Water looks very different under overcast skies, direct sunlight, or at night. Adjust the Fresnel reflectivity based on light intensity.
  • Beware of banding in reflections. Screen-space reflections can show color banding. Use dithering or add noise to break up bands.
  • Check underwater rendering. When the camera goes underwater, the shader should switch to an underwater pass (remove reflections, add fog and caustics). Many engines have automatic underwater post-process.
  • Profile on target hardware. Water shaders are often fill-rate bound. Reduce pixel shader complexity for low-end mobile devices by using lower resolution reflection textures and fewer wave octaves.

By methodically applying these methods, you can create water surfaces that respond dynamically to light and movement. The difference between a generic water shader and a polished one often comes down to the correct blend of Fresnel, the subtle distortion of refraction, and the thoughtful use of performance optimizations. Experimentation is key—adjusting wave speed, IOR, and probe placement will yield unique results for your project’s environment.