1. A test of how the rolling-debris setup behaves under an extreme timewarp scenario. Note that this is all driven by particles, cached at whole frames (so the timewarped part is being built from like 2-3 cached frames).

    This is a mostly overlooked but still a very important aspect of doing VFX -- what was the last time you saw an action sequence with no time warp in it? (Anyway, seems this debris is ready for Hollywood, baby! :DDD)

    ( see original video here -- vimeo.com/116028418 )

    # vimeo.com/116094755 Uploaded 1,386 Plays 0 Comments
  2. This is a flipbook of the example scene for the Velocity qL SOP node.

    Velocity qL is a SOP node to generate velocity vectors on geometry. Useful for all kinds of simulation-related things, like generating particle emission directions, pyro/smoke emissions or pumps, or RBD fractures' initial velocities (not yet added to this example).

    The node has various modes (velocity trail, velocity from geometry difference, transformation-to-motion). Multiple modes can be used together and can also modify existing velocity vectors.

    # vimeo.com/115935284 Uploaded 1,629 Plays 2 Comments
  3. The blending effect is achieved using a qLib gallery item (SOP Gallery, qLib--SOP/Volumes -> VDB/SDF Geo Blending). In this version I also added a subtle ripple effect (as the heads emerge). It is all pretty easy to do. :)

    Render time was about 1 min per frame (this includes building the geometry for the frame). The following happens in this scene:

    - a poly sphere, where there's a head copied onto each point of the sphere
    - animation: sphere is being scaled up, head geometry rotated slightly
    - a highly subdivided cube with a DOP ripple solver applied so the emerging heads cast waves
    - all geometry is merged together, converted to VDBs, geo blending effect applied, then converted back to polygons
    - shading: regular mantra surface with fully-raytraced subsurface scattering
    - lighting: two spherical area lights (a main one + a dim blueish from the side)
    - there's an invisible ("phantom") ground plane that reflects some diffuse GI lighting back onto the object
    - rendered with mantra (plain raytrace), globillum and DOF enabled

    grab qLib at http://qlab.github.io/qLib/ ( latest "dev" branch: https://github.com/qLab/qLib/archive/dev.zip )
    stay tuned at https://www.facebook.com/qLibHoudini

    # vimeo.com/102580753 Uploaded 5,798 Plays 6 Comments
  4. https://www.facebook.com/qLibHoudini

    Evolution of a flame -- the default "Flames" shelf tool, evolved for 7 generations.

    The idea is that for each generation you select the variants you like -- the next generation will be generated based on that, so it will converge towards a look you prefer.

    0. For the first generation, all relevant parameters are just randomized.
    1. 20 variants (entities) are generated and rendered
    2. You select which variants (entities) you like -- these will be the parents of the new generation
    3. A new generation is created from the entities you selected (another 20 entities)
    4. Select your favourites again and go back to (3)
    5. Repeat until you get a look you really like ;)

    The video shows each generation (with the parents of the next generation highlighted).

    For each generation, I only selected which looks I liked. I never touched a single pyro parameter during the process. ;)

    # vimeo.com/106107277 Uploaded 5,925 Plays 12 Comments
  5. This video illustrates various discarding/clipping techniques with a camera frustrum, using tools from the qLib asset library. (The example has some very simple geometry and animated camera.)

    1. Discard geometry outside the camera view for an entire shot

    We generate the camera frustrum geometry (Camera Frustrum qL SOP), then create an animated snapshot with it using the Bounds qL SOP.

    The bounds node is set to return the bounding box of the frustrum animation (it shows the anim frames as a coloured guide -- I'm toggling that on/off a few times just to show that it's only a display guide, not real geometry).

    Then, there's a Clip by Bounds qL SOP, which gets the input geometry and the bounding box, and _discards_ all primitives outside the box. Note that there's no clipping, just primitive deletion (which is much faster on heavy geometry).

    2. Clip geometry with the camera frustrum

    Next, we simply use another Clip-by-Bounds to actually _clip_ geometry with the camera frustrum (first with its bounding box, then the frustrum polymesh itself). It's pretty straightforward stuff.

    TIP: Even if you're clipping, it's recommended to enable "Delete Outside". It will delete all primitives outside the clipping geo's bounding box, so the actual clipping operation will run faster.

    # vimeo.com/100842611 Uploaded 663 Plays 0 Comments

qLib

Imre Tuske

Videos related to the qLib Houdini asset library.

Browse This Channel

Shout Box

Heads up: the shoutbox will be retiring soon. It’s tired of working, and can’t wait to relax. You can still send a message to the channel owner, though!

Channels are a simple, beautiful way to showcase and watch videos. Browse more Channels.