131 replies to this topic

[eetu]

The light has been on at eetu's lab this weekend, I started figuring out the volumetric spline stuff discussed here earlier.

I'm thinking it's "just" a volumetric tube, but with a deformed coordinate system following along, so that noise/texture will flow along nicely. I built a prototype of that with all SOPs, and it works 'ok', although there are some clear accuracy issues. This is the most 'explicit' way of doing it, as I'm creating all the voxel data inside Houdini. The next step would be to do at the very least the noise or rather the whole coordinate step in the shader, and the other end of the spectrum would be to do it all inside mantra. Doing it all inside SOPs isn't totally stupid though, for example that way you could 'rasterize' many curves into one volume, plus there might of course be other uses for the voxel data.

For this I built a cylindrical coordinate system around the spline, which does let you do some nice-looking things, but for many things I think a deformed cartesian coordinate system would be more practical. An additional problem with the cylindrical coordinate system is that the angular coordinate needs to loop over the 0..1 range, which the typical noises do not do.

Here I'm building actual volumes for the coordinate system, a length-along-spline coordinate volume, a distance-from-spline volume and an angle-about-spline volume. _{(the errors in w are just at the ends)}



After, I apply noise to the density volume using the above volumes' values as the coordinates. For the angular coordinate I used a twisting cosine with two positive lobes, for looping purposes.


1.4MB h264 .mov

I wonder if I'll take the next step with vex or HDK. Or maybe python, as I've been looking for something to test out numpy with..

[magneto]

Looks amazing eetu

[eetu]

I ran into the sneak peek at the next version of HDR Light Studio, and thought that the idea of painting on the mesh and projecting that onto the envmap was a neat one.

I just had to try that in Houdini, here's a live setup that does it with some pointcloud VOPSOPs and Ray'ing.

First I calculate the reflection vectors for the object to painted on (a torus in this hip), with relation to cam1.
After that I transfer the paint to a sphere representing the envmap, by comparing the current point normal to the reflection vectors in the torus, brought in as a pointcloud. The pointcloud is filtered with respect to how well the directions match, and the point color is imported from the filtered points of the pointcloud.

For visualization, a third mesh (teapot here) does simple reflection in a VOPSOP, color is imported from the evn sphere by Ray'ing in the reflection direction from the teapot points. For a more abstract visualization, a plane shows the envmap in the uv-space.

Everything is done with point attributes, and thus at point resolution, so it's not too precise.
Once again, probably not too useful as it is, but these are fun to do



6MB .mov
27MB .avi

Attached Files

•  envpaint_v003.hip   678.39K   109 downloads

[buran13]

Amazing trick!!!
Thank you from the bottom of my heart for this! Very cool!

eetu, on 08 April 2012 - 01:43 AM, said:

After checking out the "classic" Lagoa teaser video, I started thinking if something like the crumbly stuff in the beginning could be done with variable (high)viscosity FLIP fluids.

Well, this falls short of the Lagoa stuff, but it's an interesting look anyway, I think.


(click for anim)

It's quite simple really, I just init the per-pixel viscosities with a VOPSOP noise inside a SOP Solver, behind an Intermittent Solve DOP set to run "Only Once".

Hip attached for inquiring minds.

[eetu]

Here's a take on a cumulative stress map for deforming geometry. It records the maximum curvature a mesh has had in the life of a sim, in relation to it's rest curvature.

1.5 meg .mov

One weird thing: Curvature SOP gives a very different result in SOPs proper, that it gives inside a SOP Solver.
(That's why my rest curvature is initialized in a run-once SOP Solver..)

Attached Files

•  ee_curvature.hipnc   1.14MB   123 downloads

[TommyB]

very generous with your knowledge thank you very muchly mate..keep it up im facinated by the work

[FromHell]

eetu, on 08 April 2012 - 01:43 AM, said:

After checking out the "classic" Lagoa teaser video, I started thinking if something like the crumbly stuff in the beginning could be done with variable (high)viscosity FLIP fluids.

Well, this falls short of the Lagoa stuff, but it's an interesting look anyway, I think.


(click for anim)

It's quite simple really, I just init the per-pixel viscosities with a VOPSOP noise inside a SOP Solver, behind an Intermittent Solve DOP set to run "Only Once".

Hip attached for inquiring minds.

hey cool stuff! may I ask you, how much time did it take for the simulation?

[poco]

cool...wish to share the hip! thanks a lot..

eetu, on 02 February 2009 - 03:19 PM, said:

Playing with SDF's.



A font object is converted to sdf, and some particles spawned inside.
After that, the inverse of the sdf gradient at the point location is copied to the velocity of the point, every frame.

animation

[eetu]

Back to volumes!

Raycasting against a distance field can be pretty fast. Think of it like adaptive step raymarching, but you can get a good estimate of next step size by just reading the sdf value at current point.
Here's an illustrative image stolen from Inigo Quilez:


In essence you just keep stepping forward until the returned sdf value is lower than a user-specified tolerance, or until a set maximum step count is reached.

For a simple case of a 1000x1000 grid and a torus, this takes about 1 second on my machine, while raycasting against the torus polygons takes 4 seconds.

One thing where this could have a qualitative advantage over raycasting is that here you can have a per-point offset for the surface.

I've never actually used this anywhere, but I'm sure there is a use case out there somewhere

Attached Files

•  sdf_trace_v003.hip   141.21K   111 downloads

[symek]

Neat idea, thanks eetu, specially it would be cool to adopt it to vex at render time (it would be awesome to have a vex function which generates at render-time sdf of an object similarly to, say, sample_geometry and point clouds). That would open doors for many interesting solutions like this one (think fast sss for example).

Although I suspect that these particular measurements looks good for sdf because ray tracing is not terrible fast is Sops. Employing something like vray library or embree might revitalize ray casting.

In anyway, this is super idea!

[eetu]

Inspired by the "genus 6 Kandinsky Surface voronoi volume" post on sidefx forums, I thought those should be doable in Houdini alone.
Nothing advanced, just a couple of SOPs, really. I did spend a little extra effort in getting bendy lines, though.

A bit of a worst-case scenario for raytracing, this




PS. If you download the hip, it spends a while subdiving on load..

Attached Files

•  kandinsky_v007.hip   1.13MB   193 downloads

Edited by eetu, 12 January 2013 - 08:21 AM.

[eetu]

A procedural aperture mechanism (leaf shutter).

Attached Files

•  iris_v004.hip   179.01K   99 downloads