You will notice that there are a set of parameters on the SSF_LoadParticlesFromParticleSystem inspector:

The meaning of these parameters are as follows:

Render Params

Here's some comparisions on differnt paramters.

Q: why my surface is sometimes black?

A:

Bake the scene lighting if you do not see reflection! Because the scripts needs the light reflection data. If not baked, the default reflection data is black.

Or else, you may pass in the particle color as black, or there's no lights in the scene.

Different from prior version , the principle of this plugin is based on the paper A Narrow-Range Filter for Screen-Space Fluid Rendering.

Fluid simulation is generally based on grids or particles. In consideration of real-time performance, the SPH-based method (a particle-based method) is still used.

Unity does not have a very suitable fluid rendering plugin, which is the main reason for this plugin. I also noticed that there is indeed an very old implementation "Screen Space Fluids Pro"on the Asset Store (last update at year 2016).

In the process of using, I feel that I can do better, no matter from the efficiency or visual effects or ease of use and scalability, thus this plugin was born.

Please see this video on URP for a reference on how parameter works.

The files used for fluid shading are in Assets/SSF_Particle2Fluid_ShaderUtil/Shaders/FluidRender.shader

The whole process can be divided into the following steps:

• Read the surface parameters through the map:

TEXTURE2D(_ColorTex);
TEXTURE2D_FLOAT(_EyeDepthTex);
TEXTURE2D(_EyeNormalTex);
TEXTURE2D_FLOAT(_ParticleDataTex);
TEXTURE2D_FLOAT(_ThicknessTex);
StructuredBuffer<SSF_RenderParams> _RenderParams;

....
float fluidEyeDepth = SAMPLE_TEXTURE2D(_EyeDepthTex, sampler_PointClamp, uv).r;
float3 fluidColor = SAMPLE_TEXTURE2D(_ColorTex, sampler_LinearRepeat, uv).xyz;
float thickness = SAMPLE_TEXTURE2D(_ThicknessTex, sampler_LinearRepeat, uv).r;
float3 fluidEyeNormal = SAMPLE_TEXTURE2D(_EyeNormalTex, sampler_LinearRepeat, uv).xyz;
int paramIndex = SAMPLE_TEXTURE2D(_ParticleDataTex, sampler_PointClamp,uv).x;
float smoothness = _RenderParams[paramIndex].smoothness;
float refractiveIndex = _RenderParams[paramIndex].ior;
float fresnelPower = _RenderParams[paramIndex].fresnelPower;
float minReflectionRatio = _RenderParams[paramIndex].minReflectionRatio;
float maxReflectionRatio = _RenderParams[paramIndex].maxReflectionRatio;
float isTransparent = _RenderParams[paramIndex].isTransparent;
float4 ambientColor = _RenderParams[paramIndex].ambientColor;
float4 diffuseColor = _RenderParams[paramIndex].diffuseColor;
float4 specularColor = _RenderParams[paramIndex].specularColor;

• We first filter out the pixels that are not blocked by the fluid particles and return them to the previously rendered color.

Based on the above parameters, you can play with the shader to create different effects.

• For example, I first made a blinn-phong rendering

• In addition, you can use parameters such as thickness, fluid color, IOR, smoothness, etc. to create water rendering effects that include refraction and reflection:

Of course, we can also implement shadow effects, but since Unity's API is not stable and open enough, we will consider updating it later.

1. Create an empty Scene named SSF_Test

2. Create a ParticleSystem

   1. deactivate its Renderer function

Currently, there are two subclasses in the project that inherit from SSF_ParticleSource, namely SSF_LoadParticlesFromParticleSystem and SSF_LoadParticlesFromFile. SSF_ParticleSource represents the source of particle data required for rendering and is also the starting point for extension.

Considering that users may have their own source of particle data, such as a particle solution system running in parallel with the GPU, or imported pre-made particle data, here we will explain how to extend the input of particle data.

Particle Data Struct

The structure of particle data in SSF is as follows:

If you modify the particle’s data structure, you need to pay attention to replacing 32 in particleBuffer = new ComputeBuffer (getParticleNum (), 32); in SSF_ParticleSource.cs with the number of bytes of particle data. At the same time, corresponding changes should be made in DepthColorThickness.shader.

Explain SSF_ParticleSource

The input and update of extended data is to create a new class inheriting from SSF_ParticleSource and implement the corresponding virtual function.

The following two member variables exist in SSF_ParticleSource:

Where particleBuffer is used to provide data to generate related textures for rendering.

You can notice that the following member function modifiers in SSF_ParticleSource are public virtual:

• SetupParticleBufferData ()

• UpdateParticleBufferData ()

In SetupParticleBufferData , ParticlesData needs to be created and assigned, and updated in UpdateParticleBufferData () , neither of these operations need to involve particleBuffer.

You should also implement UpdateBounds() , the bounds is used for culling out of view particles, which saves a lot performance.

Example

You can also refer to SSF_LoadParticlesFromParticleSystem, this is a bit complicated and tedious.

This is a Unity shader plugin, not a fluid physics simulation plugin. It is used to render particle data into a smooth liquid surface. Ideal for rendering simulation systems that use particles as simulation units.

Magic happens when the pure unity particle system gains power through this particle shader plugin.

This version is for HDRP.

It has huge changes compared to the previous version.

• The newly adopted algorithm brings huge performance, performance, and user experience gains:

  • The number of iterations required for smoothing has been reduced from 150 to 3

  • The time required to run the algorithm Reduced (from 5.8ms to 0.5ms) nearly 10x times

  • Higher resolution and finer surface, with clear layers of water droplets and water surface

• New Rendering process brings performance improvements in the following aspects

  • Required Smoothing + rendering Reduced from Per Fluid Surface Per Frame to Once Per Frame

  • Required RenderTextures Reduced from One Set for all RenderSurfaces to One Set Globally
• Introduce new DebugVisualize functionality helps locate data problems or debug parameter effects

• Added down sample option to further reduce bandwidth pressure

• A unified rendering shader while supporting custom visual parameters for each ParticleSource.

Jump right in

First you need to download this plugin from the Unity Asset Store or Fab.

Import

• First , please make sure you are at a Unity version greater or equal to Unity 6000.

• Then, please make sure your project is using universal render pipeline.

• Check google if you do not know how to create a URP unity project , please ~

• Import the package and you will get the folder view like below:

All is set! Party Time~

Open the Scene at Assets/SSF_Particle2Fluid_ShaderUtil/Scenes/Demo_File.unity and enter play mode. You shall see:

SSF_RenderPass

Add the SSF_RenderPass to a CustomPassVolume

By default, it's brought by the SSF_Manager Prefab under the path:

Assets/Particle Water Shader Pro 2024 - HDRP/Prefabs/SSF_Manager.prefab

Check Other Demos

You can check other scene file under the folder Assets/SSF_Particle2Fluid_ShaderUtil/Scenes/

Toggle on the "Debug visualize" on the Renderer Feature to check the output.

Switch the DebugTexture type to see different debug informations.