Bubble Soup Rendering with Arnold

I’ve picked up an idea from my social media stream, rendering a bubble soup. for this example, I used the idea from Entagma’s tutorial using a flip simulation for bubble soup movement.  

the Flip simulation is quite simple and needs fixes to get correct with UV Distortion, but focused on the rendering part. the idea is quite simple using Fluids Dynamics to distort the UV on a sphere. a texture mapped on a sphere the UV’s to drive the thickness of thin-film shader. I used the default ThinFilm feature of regular Arnold Shader. This makes the setup super simple, all you need is Spheres is distorted UV’s.

the rendering from Arnold GPU is a little slow for GPU rendering but the Arnold CPU is extremely fast, the render time for HD was 12 seconds on superslow Xeon CPU. it’s by far the fastest thin-film rendering on the CPU, I’ve seen so far. 

raw rendering. I need only AA sample of 1. below is transmission albedo, it quite graphics look on its own.

it almost looks like infrared images from Nasa of Jupiter. 

for the next iteration is will great the type animation / noised structure within the shader only. it should be easy to re-recreate the dynamics with noise fields.

The following Standard Surface shader settings were used to create a soap bubble.

Base: 0
Specular: 1
Specular Color: 1 1 1
Specular Roughness: 0
Specular IOR: 1.0
Transmission: 1
Transmission Color: 1 1 1
Coat: 1
Coat IOR: 1.5
Thin Film: IOR 1.4
Thin Film Thickness: 500 [nm]


the thickness values will be replaced by the thickness attribute multiplied by 500.

Basic AOV and Lightgroups passes with Arnold and Houdini19 Solaris

i made 2 minutes video how to creat AOV passes with Arnold in Solaris. I am using the Arnold ROP node to deal the Variables names and LightPath expression for my own passes in LOP’s

here 2 minutes video how to create Lightgroups asses within LOPs (Solaris). in Houdini 19

Here’s a simple kick trick to get a list of AOVs and LPEs. The -laovs flag lists all the AOVs in the loaded scene, but if you give kick no input, you’ll get a list of all built-in AOVs defined by Arnold. this only works when you have arnoldSDK installed.

For example, on Windows, run :

kick -laovs -i Null  

On Linux or macOS, run :

 kick -laovs -i /dev/null

Available aovs:

<br>
kick -laovs -i Nul<br>
Available aovs:<br>
    Type:    Name:                        LPE:<br>
    --------------------------------------------------------------<br>
    VECTOR2  motionvector (~)<br>
    RGBA     RGBA                         C.*<br>
    VECTOR   N (~)<br>
    FLOAT    Z (~)<br>
    RGB      direct                       C[DSV]L<br>
    RGB      indirect                     C[DSV][DSVOB].*<br>
    VECTOR   Pref (~)<br>
    RGB      albedo                       C[DSV]A<br>
    RGB      emission                     C[LO]<br>
    RGB      diffuse_direct               C&lt;RD&gt;L<br>
    RGB      background                   CB<br>
    RGB      denoise_albedo               ((C&lt;TD&gt;A)|(CVA)|(C&lt;RD&gt;A))<br>
    RGB      sss_albedo                   C&lt;TD&gt;A<br>
    RGB      specular_albedo              C&lt;RS[^'coat''sheen']&gt;A<br>
    RGB      diffuse                      C&lt;RD&gt;.*<br>
    FLOAT    cputime (~)<br>
    RGB      diffuse_indirect             C&lt;RD&gt;[DSVOB].*<br>
    RGB      sss_indirect                 C&lt;TD&gt;[DSVOB].*<br>
    RGB      diffuse_albedo               C&lt;RD&gt;A<br>
    RGBA     shadow_matte<br>
    FLOAT    volume_Z (~)<br>
    RGB      specular                     C&lt;RS[^'coat''sheen']&gt;.*<br>
    RGB      coat_direct                  C&lt;RS'coat'&gt;L<br>
    RGB      specular_direct              C&lt;RS[^'coat''sheen']&gt;L<br>
    RGB      specular_indirect            C&lt;RS[^'coat''sheen']&gt;[DSVOB].*<br>
    RGB      volume_direct                CVL<br>
    RGB      coat                         C&lt;RS'coat'&gt;.*<br>
    RGB      coat_indirect                C&lt;RS'coat'&gt;[DSVOB].*<br>
    RGB      coat_albedo                  C&lt;RS'coat'&gt;A<br>
    RGB      sheen                        C&lt;RS'sheen'&gt;.*<br>
    RGB      transmission                 C&lt;TS&gt;.*<br>
    RGB      transmission_direct          C&lt;TS&gt;L<br>
    RGB      transmission_indirect        C&lt;TS&gt;[DSVOB].*<br>
    VECTOR2  AA_offset (~)<br>
    RGB      transmission_albedo          C&lt;TS&gt;A<br>
    VECTOR   P (~)<br>
    RGB      sheen_direct                 C&lt;RS'sheen'&gt;L<br>
    RGB      volume                       CV.*<br>
    RGB      sheen_indirect               C&lt;RS'sheen'&gt;[DSVOB].*<br>
    NODE     shader (~)<br>
    RGB      sheen_albedo                 C&lt;RS'sheen'&gt;A<br>
    RGB      sss                          C&lt;TD&gt;.*<br>
    RGB      sss_direct                   C&lt;TD&gt;L<br>
    RGB      volume_indirect              CV[DSVOB].*<br>
    RGB      volume_albedo                CVA<br>
    FLOAT    A (~)<br>
    FLOAT    ZBack (~)<br>
    RGB      opacity (~)<br>
    RGB      volume_opacity (~)<br>
    FLOAT    raycount (~)<br>
    UINT     ID (~)<br>
    NODE     object (~)<br>
    FLOAT    AA_inv_density (~)<br>
    RGBA     RGBA_denoise (~)<br>
    --------------------------------------------------------------<br>
    (~) No opacity blending<br>

Buy Me A Coffee

Arnold operators tricks

if use Arnold operators you can change shading and geometry without any delay in IPR rendering. Operators toegther which Houdini node graph and you have simpler version of Solaris, Katana or Gaffer. the Arnold operators are around for years when even Katana and Gaffer was quite new and long before the idea of Solaris.

Operators allow advanced users to override any part of an Arnold scene and modify the Arnold universe at render time. Probably one of the most common use cases is to override parameters (e.g. shaders) inside a procedural (USD, ASS or Alembic).Here is quite test with 600GB caches file during  Arnold GPU interactive rendering.

as you can see its quite fast to update the interactive rendering. you can the Kick command which used to query possible target node parameter names of a set_parameter node. For example: kick -info or kick -info polymesh. a more detailed tutorial i will do in future posts.

i’ve used a set parameter to change the radius of the foam particles. radius *= 1.3  or change the particle to ‘disc’‘sphere’ or ‘quad’, o change the shader like shader == ‘purple_shader’ .

here more detail talk about usage of arnold operators from autodesk and The Mill. 

video link

Buy Me A Coffee

Chess pieces USD files

Here are some USD Assets and Scenes for free to use for any purpose. Its setup with lights and shaders for Arnold renderer in GafferHQ. I will update the dropbox folder in future with other render engines setups like CyclesX , Karma, Omniverse or Unreal5.

https://www.dropbox.com/sh/8ha3xh4t120qku4/AADDipysw9Hp9xLdvGrObKj8a?dl=0

in this examples it used the gaffer instancer and Arnold fog volume shader which quite fast on the GPU.

Models and Textures are selfmade and HDR is used from iHDRI.com

Buy Me A Coffee

water USD files

Here are free scene files with 3 frames of USD caches for a water simulation for free to use for any purpose. Its setup with lights and shaders for Arnold renderer in GafferHQ. I will update the dropbox folder in future with other render engines setups like CyclesX , Karma, Omniverse or Unreal5.

I am using selfmade velocity blur node inside gaffer to get motionblur on changing point count

link to cache and gaffer files.

https://www.dropbox.com/sh/ifx72nevgkpnh6f/AAA5WpQ87eY2422rJQgYkuPna?dl=0

water shading

recently i did some water rendering in Arnold renderer, which you can see here. the shading worked quite well on the water and whitewater.

after this started to sim a wave Tunnel in Houdini Flips. a huge wave where you actually could surf. But i run into some trouble for water shading and whitewater look, i needed some reference.


I went to beach and took trusty NikonV1 camera with me to shoot some reference Photos. This are tiny Waves (50cm in height), but easy to take some pictures and good enough as shading reference.

the nice shot of miniature breaking wave

a nice snapshot of translucent effects of the wave
here we can see droplets (whitewater) in close up

here we can see more Droplets / Whitewater with sun in out back. a good example for anisotropy effect on shading.

droplets turn white with sunlight, depending on the sun direction.

There multiple Ways to render realistic Water. The old school way is to render a polygon water surface and volume underneath to simulate the light scattering. we did similar things back in 2008 on the Avatar Movie with custom written shaders for Renderman. Sidefx added presets for Houdini for its Ocean setup’s. The render time of this method are modest but the shading can quite difficult depending on camera angle and light situation.

these Days in the age of Path tracers, there 2 ways, rendering it with Sub-Surface Scattering (SSS) or Transmission Depth.

Sub-Surface Scattering simulates the effect of light entering an object and scattering beneath its surface. Not all light reflects from a surface. Some of it will penetrate below the surface of an illuminated object. There it will be absorbed by the material and scattered internally. Some of this scattered light will make its way back out of the surface and become visible to the camera. This is known as ‘sub-surface scattering’ or ‘SSS’. SSS is necessary for the realistic rendering of materials such as marble, skin, leaves, wax, and milk. The SSS component in this shader is calculated using a brute-force raytracing method.

While the Transmission Depth attribute controls volumetric light absorption within the object (fog), the Scatter attribute controls what percentage of the light will be scattered instead of absorbed, effectively creating the murky effect of semi-transparent materials.

Depth Controls the depth into the volume at which the transmission color is realized. Increasing this value makes the volume thinner, which means less absorption and scattering. It is a scale factor so that you can set a transmission_color and then tweak the depth to be appropriate for the size of your object.

Scattering is very import if wanna shader deep Materials like Ocean water. For the scattering effect to work Scatter must have a dominant percentage value, and the Depth attribute must generally be much lower. also the Opaque attribute must be unchecked in the Arnold attributes of the object’s shape node for the light to be able to pass into the mesh and illuminate the volume.

Rendering with refraction Depth is more “physical correct” way, but it does account tiny organism (light blockers) in this case you add textures to simulate plankton in the water.

I choose go with SSS route. The tycial Surface Scattering shading model has a similar volume light scatter look. the look can be limited but it works in case deep Ocean water. the advantage: it full support with current Arnold GPU renderer (Depth transmission is not supported yet) and SSS shading model is also faster to render. In addition, I’ ve added an extra underwater bubble simulation with particles to increase the realism.