How to Create Realistic Water Physics in Unity

Water physics is an essential component of many games, from simple simulations to complex interactive environments. Creating realistic water behavior can make a game world feel alive, engaging, and immersive. Whether you're developing a small indie game or a large-scale simulation, understanding how to create water physics in Unity is a valuable skill. Unity, with its powerful physics engine, offers several ways to simulate water, but achieving a truly realistic water system requires a solid understanding of both the physics and the artistic components of water simulation.

In this guide, we'll cover how to create realistic water physics in Unity, focusing on essential aspects such as fluid dynamics, buoyancy, waves, interactions with objects, and rendering techniques. While achieving photorealistic water is a complex task, we'll aim for a practical approach that balances realism with performance.

Understanding Fluid Dynamics in Games

Water behaves according to the principles of fluid dynamics, a branch of physics that studies the flow and behavior of liquids and gases. In games, simulating fluid dynamics can be simplified using mathematical models that approximate real-world behavior. Real-time fluid simulation in Unity is computationally expensive, so most games rely on simplified models or hybrid solutions that mix physics calculations with pre-generated animations or shaders.

Key Concepts in Fluid Dynamics for Games:

• Density: The mass per unit volume of the water. The denser an object is than the surrounding water, the more likely it is to sink. The denser the water, the greater the buoyant force exerted on objects.
• Viscosity: The thickness of a liquid, which affects how it moves and how objects interact with it. High viscosity makes water move more slowly and with greater resistance.
• Surface Tension: The force at the surface of a liquid that causes it to behave like a stretched elastic sheet. This concept can be used for effects like splashes or water droplets sticking to objects.
• Buoyancy: The upward force that a fluid exerts on an object submerged in it, counteracting gravity. Buoyancy is critical for simulating the movement of objects in water.

For most games, simulating the entire complexity of fluid dynamics in real time isn't necessary. Instead, focusing on buoyancy, wave generation, and basic fluid flow is typically enough for a satisfying water physics experience.

Setting Up the Water in Unity

Before delving into the physics, it's important to set up a basic water environment in Unity. This involves creating the water surface, adding interactions with objects, and setting up physics for the water's behavior.

Step 1: Setting Up the Scene

1. Create the Water Surface: Start by creating a simple plane or mesh to represent the water surface. This can be a flat plane that will interact with objects. You can also add additional details like waves later on, but for now, a basic flat surface will do.
2. Water Shader: Use a water shader to make the surface look like water. Unity has built-in shaders like the Standard Shader, but there are also advanced water shaders available in the Unity Asset Store or from third-party sources.
3. Water Collider : Attach a collider to the water surface so objects can interact with it. Typically, a BoxCollider or MeshCollider is sufficient. Ensure the collider's bounds are large enough to cover the water area in your scene.

Step 2: Add Rigidbody Components

Water physics interactions often require that objects in the scene respond to the water surface. To do this, objects must have Rigidbody components attached to them. The Rigidbody will interact with Unity's physics engine, allowing objects to float, sink, or be affected by water currents.

• Buoyancy: To make objects float, Unity uses forces applied to their Rigidbody component. This can be modeled with a simple buoyancy force based on the object's volume submerged in water.

{
    public float waterHeight = 0f; // Height of the water surface
    public float buoyancyForce = 10f;

    private Rigidbody rb;

    void Start()
    {
        rb = GetComponent<Rigidbody>();
    }

    void FixedUpdate()
    {
        if (transform.position.y < waterHeight)
        {
            float submergedDepth = waterHeight - transform.position.y;
            Vector3 buoyantForce = Vector3.up * submergedDepth * buoyancyForce;
            rb.AddForce(buoyantForce, ForceMode.Acceleration);
        }
    }
}

In this simple script, the buoyant force is applied to an object based on how much of it is submerged. The waterHeight is the height of the water surface in your scene, and the force will push the object upward.

Simulating Waves and Water Motion

Simulating realistic waves and water movement is an important part of creating water physics in Unity. While complex fluid simulations can be resource-intensive, Unity provides ways to create visually convincing waves and flowing water through shaders, particle systems, and simple mathematical models.

Step 1: Creating Waves with Shaders

You can simulate water waves by manipulating the vertices of your water surface mesh using shaders. A simple wave function can be applied to the y-coordinates of the vertices to simulate the rising and falling of the water surface.

Here's an example of a simple vertex displacement shader that generates a wave effect:

{
    Properties
    {
        _MainTex ("Base (RGB)", 2D) = "white" {}
        _WaveSpeed ("Wave Speed", Float) = 0.1
        _WaveHeight ("Wave Height", Float) = 0.5
    }
    SubShader
    {
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            float _WaveSpeed;
            float _WaveHeight;

            struct appdata
            {
                float4 vertex : POSITION;
            };

            struct v2f
            {
                float4 pos : POSITION;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);

                // Wave function based on sine
                o.pos.y += sin(v.vertex.x * 0.1 + _Time.y * _WaveSpeed) * _WaveHeight;
                return o;
            }

            ENDCG
        }
    }
}

This shader creates a sinusoidal wave motion on the water surface by modifying the vertex positions. You can tweak the _WaveSpeed and _WaveHeight properties to control the speed and height of the waves.

Step 2: Adding Flowing Water

For flowing water, you can simulate a current by applying forces to objects that are moving through the water. This can be done by creating invisible flow zones and applying directional forces on objects in those zones.

{
    public Vector3 flowDirection = new Vector3(1, 0, 0); // Direction of the water flow
    public float flowStrength = 5f;

    private Rigidbody rb;

    void Start()
    {
        rb = GetComponent<Rigidbody>();
    }

    void FixedUpdate()
    {
        // Apply a force to objects moving through the flowing water
        if (transform.position.y < waterHeight)
        {
            rb.AddForce(flowDirection * flowStrength, ForceMode.Force);
        }
    }
}

In this script, the flowDirection represents the direction of the water's current, and flowStrength controls how strong the flow is.

Interaction with Objects: Buoyancy and Collision

When creating realistic water physics, it's important that objects interact appropriately with the water. This includes both buoyancy (as mentioned earlier) and collision with water surfaces. Unity's physics engine handles much of this interaction, but additional features can be added to simulate realistic water behavior.

Step 1: Object Interaction

For more realistic interactions, such as water splashes, ripples, or object displacement, consider using particle systems or additional physics forces. When an object enters the water, you can create a particle system to simulate splash effects, or apply additional forces to simulate displacement.

{
    public ParticleSystem splashEffect;
    public float splashThreshold = 0.1f;

    void OnCollisionEnter(Collision collision)
    {
        if (collision.relativeVelocity.magnitude > splashThreshold)
        {
            // Create a splash effect where the object hits the water
            splashEffect.Play();
        }
    }
}

This script will trigger a splash effect whenever an object collides with the water with sufficient velocity, adding realism to the interaction.

Step 2: Water Surface Collision

Objects that interact with the water surface need to be treated with care to ensure realistic behavior. Unity's physics engine allows for objects to be buoyant or sink depending on their mass and volume, but more advanced interactions like floating on the surface can be achieved by adjusting their Rigidbody properties and using triggers.

Rendering Water with Realistic Effects

In addition to physics, rendering realistic water effects is crucial for creating immersive environments. Unity's built-in rendering tools, combined with shaders and particle systems, can help achieve realistic water visuals.

Step 1: Reflective Water Surface

For a realistic water surface, reflection and refraction effects are essential. Unity provides the Reflection Probe system, which can be used to simulate reflective water surfaces.

1. Set up a Reflection Probe: Place a reflection probe in your scene to capture the surrounding environment and reflect it on the water surface.
2. Use a Water Shader: Modify your water shader to include reflection by sampling the reflection probe texture based on the water surface's normals.

{
    Properties
    {
        _MainTex ("Base Texture", 2D) = "white" {}
        _ReflectionTex ("Reflection Texture", Cube) = "_Skybox" {}
    }
    SubShader
    {
        Pass
        {
            CGPROGRAM
            #pragma surface surf Lambert
            #include "UnityCG.cginc"

            samplerCUBE _ReflectionTex;

            struct Input
            {
                float2 uv_MainTex;
                float3 worldPos;
            };

            void surf(Input IN, inout SurfaceOutput o)
            {
                o.Albedo = tex2D(_MainTex, IN.uv_MainTex).rgb;
                o.Emission = texCUBE(_ReflectionTex, IN.worldPos).rgb;
            }
            ENDCG
        }
    }
}

This shader will reflect the surrounding environment on the water surface. The result is a more dynamic and realistic water effect that changes depending on the camera's viewpoint.

Step 2: Add Particle Effects for Splashes and Foam

Particle systems can enhance water interactions by simulating foam, splashes, and ripples. Use Unity's Particle System to create effects like waves crashing on the shore, or splashes when objects hit the water.

{
    public ParticleSystem splashParticles;

    void OnCollisionEnter(Collision collision)
    {
        if (collision.relativeVelocity.magnitude > 1f)
        {
            splashParticles.Play();
        }
    }
}

This script plays a particle effect when objects collide with the water surface, adding realism to the interaction.

Conclusion

Creating realistic water physics in Unity requires a combination of physics, shaders, and artistic design. While true fluid simulation is complex and computationally expensive, Unity provides tools to simulate realistic water behaviors through buoyancy forces, wave functions, object interactions, and particle effects. By focusing on key aspects like buoyancy, wave generation, and rendering, you can create a convincing water system for your game.

By using a combination of physics-based interactions, shaders, and particle systems, you can develop water that looks and feels real, adding an immersive layer of realism to your Unity-based games. As you continue to experiment and refine your water system, you'll be able to create even more advanced and visually stunning water effects.

View Product