the goal of this project was to find a way to melt a lot of different objects.colors and materials had to melt too.Initial tests in the studio with houdini particle fluids proved to be the way to go.

nevertheless , I decided to have a go with the voxel solvers in houdini to see if similar effects could be achieved.

i spent some time playing with solvers and finally after some struggles with the liquid solver I decided to continue with the sand solver as a base and try to build my stuffs around it.

struggling with the liquid solver:

first i had to inject keyframed animation (velocities) inside the simulation.this was done by blending custom velocity fields inside the simulation with simple y ramps.

the bottom of the shape (the drip ?) was controlled via painted attributes on the surface of the object controlling a mix of tangential and normal forces that would “sculpt” the final surface.

while simulating , the original polygon object was advected in the velocity field and a fluid surface object was created from the advected sand point cloud.

the result of the simulation was used as an obstacle for an additional particle fluid simulation from painted area.

finally I built a simple solver that would mix both velocity of the sand and sph simulations.a lot of points (2 millions) are then scattered on the modelled object and readvected within the final velocities.

uvs are transfered and carefully preserved all along the process.we also advected a material tag that would give us the possibility to blend between different materials.

the final rendering was done with mentalray in xsi . it was quite hard to render refraction correctly from the fluid surface but it seems to be a mental ray problem.finaly more filtering while generating the surface did the trick.

another shot I did :

you can see the final commercial here , directed by FredericPlanchon

this guy is my first attempt at rendering hair in production.
Rendering hair in XSI4 (2004) wasn’t exactly a walk in the parc.
A lot of tools had to be developed inhouse especially in the shading department.

the following is a shading/passes breakdown I did in 2004 for RenderNode, a now defunct online cg magazine.

constant pass : flat colormap transfered to hair from the skin

occlusion : rendermapped skin occlusion transfered to hairs

ambiant : ambient environment lookup (using the hair normal) of a set probe.
the shader uses spherical harmonics

lambert : wrap lambert using precomputed deep shadow maps

skin : the shader uses the chanlum technique to compute illumination .
I used this pass to enhance the “white fur” effect.
It also creates a translucence effect in the ears.

wireframe:

Outputed in 2K for a french spoof movie.

Modelling ManuChapon
MentalRay DeepShadow shader by AloysBaillet
MentalRay HairShader by GuyRabiller

more infos about the film

result with RSMB :

another pattern :

to reinject those vectors back to the deriver I rendermapped the U_basis again

this is the rendertree I used to finally transform the 2d vectors . lmFlowCoords was designed for something else but globally it would transform vectors from a reference to another.

result using the map

a last one for the road

the anisotropic pattern is rendered from a 3d scene (rotating disks instancied on a particle cloud) using lm2dmv

using RSMB

render (animation)

I was looking for a way to synchronize the derivative vectors orientation/patterns and the texture maps used for bump or diffuse to help in the final shading of these kind of materials.
I came up with this idea to use the derivative vectors to drive a 2D directional blur.

Shading is done in XSI/MentalRay using MR physics lib (dgs or mib_glossy_reflection).
All these tests have been done with version 5 of XSI.
Directional Blur is done with ReVisionFX’s RSMBVector inside XSI FXtree.

NoAnisotropy

derivative vectors are defined using the deriver shader. here north pole at (0,0,0)

clean UVs

rendermapping U derivative vector : this is done using a special VectorState shader and applied as the color of the object . this is rendermapped as a .ct texture to keep negative informations intact.

transforming the derivative in the UVbasis : the rendermapped derivative is injected in the bump map slot of the material.

than everything is rendermapped again using rendermap option to render normals in the UVbasis.

if you get rid of the blue component it looks like a typical RSMB vectormap input.

visualising the vectors with lmVectorViewer

creating a noise pattern

applying directional blur with RSMB

using the map in bump and diffuse shaders

part2

for each voxel , I test the length of the normal. if the length is different than zero I assume being at the surface of the volume (ie where density goes from 0 to 1) and continue.
The dot product between the normal and CameraRay is calculated . if > 0 (or bigger than a given positive threshold) , continue.
the last thing to test is self occlusion.this was done by integrating the volume density from P to Camera using integrate3d.
the more density , the less color will be kept.

this is done for each picture and color is accumulated from frame to frame in an i3d.

in my first attempt the colors were screened together.The result was washed out and blurry.

by keeping only the best Color (ie best dot) per voxel , result is much sharper (but shows discontinuity)

I tried to match (approximately) voxel resolution and picture resolution and ended up with more than 400 Millions voxels in the final i3d.

finally I spent an hour with uvlayout (this is a great software) to get nice and undistorted uv’s and baked the color for Photoshop retouching.

a piece of the final map

there are certainly other techniques to extract/mix colors and hide seams , but this sould be enough to start manual work.

thanks to Juliette’s hard work (during her oneweek school internship) I had a sequence of twenty 3K pictures with their mask to work with.The Giraffe toy has been on my desk forever and I thought it would make a good candidate for reconstruction.
3D cameras were extracted from the pictures using 3DEqualizer and lens distortion was removed using WarpDistort.

masks were created with XSI FxTree.

I started to experiment with PointClouds and Sops but I quickly became limited by the number of points.

the interface was severely crawling over one or two millions points in the UI so I switched to i3d.

Camera Projected UVs were stored in a i3d sequence , so for each voxel a simple lookup of the mask is done and the density is set to the value of the mask. the results are accumulated frame by frame to refine the final object.

you can see the iterative process here . this little piggy guy was a gift I get while working on this project.I started initially my tests with him but he turned out to be more difficult to have nice results than the giraffe. It gave me a good taste of the limitation of the technique …

back with the giraffe.Masks were blurred a little bit (to much maybe) to get more gradient in the density and to “blur” the final reconstruction.

first results with the giraffe.

I used the isosurface node to extract a 3d mesh from the density i3d file.

Correct normals were also extracted using the gradient3d vop node for clean rendering.

the new volume visu in houdini9

next step : Color!

raymarching is now a single line of vex code with an illuminance loop.very cool

It has some kind of strange morbid quality that reminds me of this story

One way to create a volume primitive is to use the isooffset node.

a cookie node is used to have a “closed” object that is easier to convert

the isooffset node generates a sdf (signed distance field) from his inputs.
the sdf can be converted to a mesh (this was the only option in H8)

but now you can also output a volume primitive , which shows up in the view port as a set of slices.

isooffset also give you the option to directly save the sdf values , ie distance from the surface , inside the volume primitive.

volume primitives can be filtered like i3d with the filtertype/filterwidth parameters.

for the moment it’s not possible to create/edit attributes at “voxel” level (from a sop) like you could do with other primitives so I had to switch back to regular i3d to inject colors in my volume.There is a new vex (and vop) command “volumesample” that let you access the volume primitive data.

this is the i3d shader I used to create an i3d file of my previous reconstructions.
it takes the color from a pointcloud , density from the volume object and also use the sdf to fill the inside with a constant color:

#pragma hint ColorPointCloudFile file
#pragma hint VolumeDensityFile file
#pragma hint VolumeSdfFile file
#pragma hint Cd invisible
#pragma hint InsideColor color

image3d
R3DtoI3d
(
string ColorPointCloudFile = “”;
string VolumeDensityFile = “”;
string VolumeSdfFile = “”;
vector InsideColor=1;
float searchradius = 1;
int maxpoints = 10;
export vector Cd = 1;
)
{
//Color
int handle;
handle = pcopen(ColorPointCloudFile, “P”, P , searchradius , maxpoints , “preload”, 1);
Cd = pcfilter(handle, “Cd”);
if ( Cd == {0,0,0} )
{Cd = InsideColor;}

//Sdf
float distance=volumesample(VolumeSdfFile,0,P);

//Density
//density=volumesample(VolumeDensityFile,0,P);
if (distance <= 0)
{density=1;}
else
{density=0;}

//verbose
//printf(“dist:%f dens:%f\n”,distance,density);
}

Volume primitives can now intersect with objects in the scenes , cast shadows correctly

you can also have multiple primitives intersecting with no problems .

I did a lot of volumic work in H8 and all I can say is that I wish I had all this back then !

Next I’m planning to spend some time in the shading department to see what’s new there.

Manipulating PointCloud in XSI was a very frustrating experience back in 2005.

It’s a totally different story in Houdini.
Creating the Mesh/ParticleCloud in Houdini is straightforward.

Rendering of point primitives with constant rgb shader

For the moment Houdini9 is a very pleasant experience .
I’m planning to investigate volume rendering if I have more time.