This was some RnD before the actual RnD project and at the time I believed Houdini was the right call for sure cause I had the collisions working pretty well all while using a relatively simple POP net and I do think this would be useful in another scenario but for the project at hand it wasn't there yet

This is a simplified overview of the node setup:

- Rain Generation: The Source_first_input node emits the initial rain particles, which are then controlled using POP Collision Behavior to manage how they react when they hit objects.

- Splash Creation: When raindrops hit a surface, the POP Replicate node generates splash particles, and the POP Range adjusts how these particles behave post-collision.

- Running Effect: As raindrops interact with surfaces, they begin to "run" down. A POP Replicate and POP Collision Behavior combination manages this effect, ensuring the drops slide naturally along the surface.

- Trailing Effect: I used another POP Replicate node to create particle trails that simulate water streaks left behind as the drops move. The POP Collision Behavior was set to slide rather than stick

- Physics Simulation: The POP Solver drives the entire simulation, it is pretty much the brain of everything this is where I can place any force I would need to affect the particles would live under

In the Houdini, I did a pretty basic mesh setup using:

- object_merge1: I used this node to import the sim from another network. In this case, it's the data from the `SIM_01/OUT` path.

- delete1: This node helped to filter out unwanted geometry or attributes. I used it to remove particles I wasn't going to utilize.

- trail: The `Trail` node was a pretty big one and was something I used to create trails from points, which made the raindrop streak.

- vdbfromparticles2: This node just converted the particles into a VDB (Volume Data Base) to create a volumetric representation from the particle simulation. It's useful when creating smooth, meshed versions of particle effects like fluid or smoke.

- convertvdb1: As the name implies I used this to convert the VDB back into a polygonal mesh format, so I could render it out as geometry.

- smooth2: I just used this to soften the appearance and remove any sharp edges or noise in the resulting mesh from the `convertvdb1` operation.

For this trial I really wanted to try and get the animation as accurate as possible to what actual rain would be like

For this setup, it was pretty much the same as the initial setup the main change came in the remeshing side of things

- Delete Node: This node removes unwanted particles or geometry, cleaning up the data that is not necessary for the final mesh creation.

- AttribWrangle1: A custom VEX expression that could be modifying the particle attributes like position, velocity, or any other property. It's common to use this node for fine-tuning how the particles behave or look.

TimeBlend Node: Blends the particle positions over time, ensuring smoother transitions between frames. This helps create fluid-like movement, reducing jerky or abrupt changes.

- PointVelocity Node: This node adds or modifies the particles' velocity. This step is essential for simulating realistic movement, giving the particles the proper directional flow that will eventually be transferred to the mesh.

- Trail Node: This node computes the particle trails over time. It generates additional geometry based on particle movement, useful for creating streaks or continuous forms that will contribute to the final mesh.

- PointJitter3 adds randomness to the particle positions, creating more organic and less uniform patterns in the particle distribution and enhancing the natural feel of the mesh.

- VDBfromParticles2: Converts the particle data into a VDB (Volumetric Data) representation. This is the core step in meshing the particles, as VDBs allow you to turn points into a continuous volume, which will later be transformed into a polygon mesh.

- VDBSmooth2: Smooths out the VDB volume, removing harsh edges or noise from the initial conversion. This step is crucial for creating a polished and fluid surface.

- Convert VDB Node: Converts the smoothed VDB volume into polygons, which forms the final mesh geometry.

- Attribute Noise (Mountain1): Applies noise to the mesh, adding a rugged, mountainous feel to the surface. This noise can be used to add more texture and randomness, making the mesh appear more dynamic and less uniform.

- AttributeTransfer1: Transfers attributes (like color or velocity) from the original particles to the final mesh. This ensures that any important properties, such as motion or appearance attributes, are preserved.

- Final FileCache Nodes: The two FileCache nodes are used to save the simulation data at different stages, allowing for efficient playback or re-use of the data without re-running the entire simulation.

To my suprise, I found Cinema 4D’s latest particle system update to be surprisingly effective for my raindrop simulation compared to Houdini. While Houdini is overall more flexible, Cinema 4D beat it out by being more art-directable, making it easier to achieve the specific look I was aiming for. Customizing the raindrop velocities was more intuitive, and applying geometry to the particles proved to be far less computationally demanding. This really showed me that Cinema 4D was the best path for this particular project, though I believe there’s more for me to explore in Houdini's capabilities as well.

The setup looks like it splits the rain particles into two main groups: large and small static particles. Each group is controlled with friction, gravity, and randomized size adjustments with the math effector. The rain particles are programmed to either stick to surfaces or detach based on specific conditions, such as age or size.

The Key components include:

- Particle Separation: Splits particles by size for more natural variation.

- Surface Interaction: Uses Predator Prey and surface attract nodes to manage particle sticking behavior.

- Dynamic Detachment: Active particles can detach, slow down, or leave trails as they interact with the geometry.

- Controlled Deactivation: A system of conditions removes particles when they get too small or too old, simulating raindrops fading away.

The remesher setup for this project was straightforward yet effective. I started with a Volume Builder, setting the particle groups in the Volume Builder to "Scale Based on Particles" and then adjusting the voxel threshold to be between 0.01 and 0.05 for optimal detail. Once the volume was built, I passed it through a Volume Mesher to generate the geometry. To refine the result and remove any jagged edges, I applied a Smooth Deformer, giving the final mesh a clean and polished look.

In this step, I worked with AOV (Arbitrary Output Variables) channels to separate various passes for better control over the composition. This allowed me to adjust specific elements like lighting, reflections, and shadows individually, which could help polish the final image a lot more.

(This step was no longer used however I think it was still pretty useful)

In this phase I imported the 3D camera data into NUKE to synchronize the plate footage with the movement in my 3D scene. This integration was what I tried to use to align the rain simulation accurately within the frame, to maintain the visual flow between the 3D environment and the 2D plate.

I attempted to create motion blur with the motion vector AOV channel becuase it outputs a color channel that shows object movement which was going to be really useful for the raindrops that would be in the foreground but the intial issue I had with this was that the rain footage and the mid ground were render all on the same plate which caused strange blurring or distortions on the mid ground layer but this was a simple fix because I just needed to render the rain seperately

To tackle the issue I had the most when I was stuck with getting proper refractions, I set up a couple of things in my Cinema file, one of them being projections within the lights themselves. This was super useful when it came to creating reflections on the window and in the droplets especially, and all you need to do is just place an image or PNG sequence into your light's texture and then switch over to the animate tab if you're using a PNG sequence.

This is still pretty much the same as the last time I created motion blur I just increased the value of the motion vector to get better motion blur.