Rain It In

Abstract

Rain It In is a real-time simulation of raindrops falling and splashing upon impact using OpenGL. The system models both particle-level fluid behavior and physical interactions with surfaces. By combining custom teardrop mesh generation, reflection/refraction shaders, and gravity-based dynamics, the project visualizes realistic rain behavior in an interactive 3D environment with skybox lighting and camera control.

Technical Approach

We started with a basic 2D simulation, evolving it into a full 3D OpenGL-based simulation using GLEW, GLFW, and GLM. Each droplet is rendered as a procedurally generated mesh with cosine-based tapering to mimic a teardrop shape. The main shader employs a Fresnel-based blend of reflection and refraction using a cubemap to simulate realistic lighting on water. Droplets are subject to gravity and spawn splash particles upon impact using randomized velocity vectors and size sampled from log-normal distributions, inspired by techniques described in Splash! A Particle-Based Fluid Simulation

Our simulation applied fundamental physics and optical formulas. Droplets fall under Newtonian gravity, updating their position \( \vec{p} \) and velocity \( \vec{v} \) using:

\( \vec{v}(t+\Delta t) = \vec{v}(t) + \vec{g} \cdot \Delta t \),
\( \vec{p}(t+\Delta t) = \vec{p}(t) + \vec{v}(t+\Delta t) \cdot \Delta t \)

To model optical effects like reflection and refraction, we used built-in GLSL functions based on:

• Snell’s Law (for refraction direction):
  \( \eta = \frac{n_1}{n_2} \),
  \( \vec{T} = \eta \cdot \vec{I} + (\eta \cdot \cos\theta_i - \sqrt{1 - \eta^2 (1 - \cos^2\theta_i)}) \cdot \vec{N} \)
• Fresnel Reflectance (Schlick's Approximation):
  \( R(\theta) = R_0 + (1 - R_0)(1 - \cos\theta)^5 \),
  where \( R_0 = \left( \frac{n_1 - n_2}{n_1 + n_2} \right)^2 \)
• Reflection Direction:
  \( \vec{R} = \vec{I} - 2 \cdot (\vec{I} \cdot \vec{N}) \cdot \vec{N} \)

Particle splash sizes were sampled from a log-normal distribution:
\( r \sim \text{LogNormal}(\mu, \sigma^2) \),
where \( \mu = \log(r_{parent} \cdot 0.5) \)

Camera movement is controlled via keyboard (WASD) and mouse (pitch/yaw), and interactions include pausing ('P') and restarting ('R') the simulation. A ground plane is rendered using standard Phong lighting while droplets and particles use environment-mapped shaders.

Our shaders were written in GLSL 330 core. Shader logic was loaded and compiled via utility functions from `ShaderUtils.h/cpp`. We diverged from existing references by crafting our droplet geometry manually, instead of using sphere primitives, and added realistic refraction using the built-in `refract()` function and Schlick approximation for Fresnel reflectance.

Problems Encountered

• Initial droplet geometry lacked realism — fixed using cosine series tapering
• Droplets passed through ground — resolved with collision flags and position clamping
• Particles didn't despawn — addressed using lifetime decay and erasure logic
• Camera movement was jerky — smoothed via mouse state tracking (`firstMouse` logic)
• Sphere mesh lacking fluidity, not compatable for desired pooling effects - implemented life/decay logic to unclog surface
• Reccurssive effect not practicle even for largest initial partale spawn - kept in code just in case but doesnt actually occur

Lessons Learned

• Custom mesh generation adds complexity but greatly improves realism
• Environmental lighting using cubemaps makes a large visual impact
• Separating physics and rendering logic simplifies debugging and iteration
• Shader design is critical for visual fidelity, especially with transparent materials

Results

Our system produces visually compelling animations of falling droplets and splash particles under various lighting conditions.

Contributions

• Sophie Nazarian): Implemented core physics engine, droplet spawning, splash logic
• April Zhang: Implemented 3D simulaiton based off of 2D simulation.
• Andy Wang: GUI, shading, rending, camera movement
• Dmytro Krukovskyi: Implemented fresnel effect to make the dropplets more realistic.

A CS184 Computer Graphics and Imaging Project

View on GitHub