Category: Houdini

Morph Between 3D Objects with Houdini VDB Morph

digm520admin / / Houdini, Tutorial
June 10, 2019

Houdini VDB Morph

Morph Between 3D Objects

Youtube – Houdini Tutorial – 3D Object Morphing using Open VDB Morph and SOP Solver

By: Jeshuran Paul

One of the finishing touches for my frog generator Houdini project that was suggested was morphing between several of the frog objects it is able to create in a single animation. I was already looking into converting some/all of it into VDB objects at some point to help clean up the joint connections in an interesting and organic way, so this VDB morphing seems like it should fit nicely with that.

Frog Body Generator – Houdini Basics of Polywire and Sweep with Ramp

digm520admin / / Class, Houdini
June 10, 2019

Houdini – Polywire and Sweep Nodes

Using with Ramps

Youtube – Houdini Essential:How to control polywire, and sweep node along a curve by ramp parameter. part2

By: Saman khorram

I think this tutorial may finally give me my solution to replace my personally made ramped scaling in Houdini for my frog generator with a more consistent and simple SOP setup. I’ve just needed a way to sweep and then scale separately in the horizontal and vertical direction using a ramp along the line of the sweep.

This ended up just being more about altering the pscale along the line. This just alters the uniform scale of the circles.

Current Fix

I was able to change the vex a bit to give me a more consistent result as of now. I am still using a Sweep of circles over a line and scaling them my own way with a bit of vex, but I’ve just changed how it works.

Initially, I was using this on the circle that I was sweeping:

vector a = set(0, 0, 0);
@N = normalize(a+@P);

v@xScalingVector = set(@N.x, 0, 0);
v@yScalingVector = set(0, @N.y, 0);

I was doing this so that the circles would be able to keep the scaling vector information with them after they were swept to use for the individual axis scaling. This gave me some inconsistent errors though. The body would not be symmetrical, with a bit of a skew.

The scaling was done by using ramps to assign xScale and yScale attribute values to the points of the circle sweep along the path. The scaling was then done with an attribute wrangle and the following VEX:

@P.z += @xScale * v@xScalingVector.x;
@P.y += @yScale * v@yScalingVector.y;

The P.z taking “x” values was because the z values actually dealt with the width of my frog body. This was taking the ramp values and multiplying that with the originally signed scaling vectors and then readding that to the point position. The scaling vector was supposed to help with direction, so the negative values would go more negative and the positive the opposite. However, some points were keeping scaling vector values of the opposite sign, so they would “scale” in the wrong direction and give the weird skew.

While experimenting with some fixes by just using an arc and mirroring it 1 or 2 times, I actually just tried using the normal vectors directly in my wrangle as opposed to the saved values since I thought the saved values may not be working nicely with the curving of my sweep outline. So for the circles pre-sweep, I just kept the initial part of the VEX wrangle:

vector a = set(0, 0, 0);
@N = normalize(a+@P);

And for the scaling wrangle, I just used the @N vector:

@P.z += @xScale * @N.z;
@P.y += @yScale * @N.y;

So far, this at least fixed the issue for now, and has worked with a few variations so I am hopeful this is a decent fix for my issue for now. Random final note, I did have to reverse the normals after skinning when doing it this way for other nodes to work properly (such as the one protruding the ridges on the frog’s back).

Houdini Frog Generator – Controllers and Foot Webbings

digm520admin / / Class, Houdini
June 4, 2019

Houdini Frog Generator

Controllers and Foot Webbing

Foot Webbing

The general concept was to take a line of points and move every other one along its normal to create a general zig-zag pattern. Then, you resample it to make it smoother and wavier. I have another set of points that are along the foot that will create the inner boundary of the webbing. You then use the Add SOP to create a closed polygon between these line boundaries.

To make this more consistent, I wanted to create the line using points from the toes. This way, the webbing will follow the toes around properly as I shift them around. This was easy to accomplish by just adding another point at the tip of the toe geo and setting it to have an id attribute of 0. I could then connect all of the same attribute valued points in a line with the Add SOP.

The line between all of the toes would then be made up of a number of points equal to the toes. I needed to add a single point between each pair of toes to move to create the wave in the webbing. This could be done with a resample that adds a point in the middle of each polygon.

Controllers

I wanted to practice setting up overall controllers to start making it easier to work with my frog generator from a few ruling nodes.

I first practiced this by setting up a controller for the foot to control the webbing parameters. This controller was tied to: webbing length, webbing curvature, and webbing origin.

The length is how much overall area the webbing covers between the toes. The curvature is how wavy, or how far the inner webbing points are away from the general curve. Finally, the origin just helps move the inner boundary of the webbing around in case it is too far from the foot or too far in.

I then moved on to creating a body controller, which had a lot more parameters. This also required connecting some ramp parameters, which are a bit weird in Houdini.

These parameters include:

  • Body Length
  • Spine Shaping
  • xScaling Body
  • yScaling Body
  • Dorsal Start
  • Dorsal End
  • Dorsal Projection Angle
  • Dorsal Projection Ramp
  • Back Leg Position
  • Back Leg Angle
  • Arms Position
  • Arms Angle
  • Eyes Position
  • Eyes Angle
  • Tympanum Position
  • Tympanum Angle

The body length is just the general overall length of the body shape. The spine shaping is a ramp that lets you add curvature to the body. The xScaling and yScaling are ramps that independantly alter the general width or height of the body throughout.

The dorsal variables control the larger dorsolateral dermal plica on the back of the frog. These are raised ridges a lot of frogs have. These control how far along the frog’s body these ridges go, the radial angle around the body they are projected, and a ramp to control how much it deforms the general body in the normal direction along the ridges.

Finally, all of the positions and angles control the connection point locations for various body parts of the frog to the general body. These select a specific point along the main spine to project out onto the body surface, and the angle determines the radial projection around the body these points are located. These two features together let you place the body parts anywhere on the body very easily.

Creating Houdini Digital Assets

digm520admin / / Houdini, Tutorial
May 28, 2019

Houdini Digital Assets

Youtube – Introduction to Houdini – Chapter 4- making digital assets

By: Rohan Dalvi

Making Digital Assets in Houdini seems to be a core part of creating a procedural model generator, so this tutorial gets into the very basics of setting one of these up.

The practice used here is that you create a Null object off to the side where you “Edit the Paramter Inteferface” under the settings of the node (the gear icon). You select the type of values you want to vary (floats, ints, ramps, vectors, colors, etc.) and add those to this Null object. Specifiying a range here can be helpful to inform the user of useful values. You then “Copy Parameters” from this Null control node, and “Paste Relative Expression” to the nodes/variables that they make sense. This way, when the Null control node has its values changed, they will directly correlate with changing the designated value within your network of nodes.

Procedural Fence Asset in Houdini

digm520admin / / Houdini, Procedural Generation, Tutorial
May 20, 2019

Houdini Procedural Fence Asset

Vimeo – Intro to Procedural Modeling in Houdini: Making a Fence Asset

By: trzanko

Notes: Projecting Curve down onto surface – make sure curve is entirely above surface first – done by transforming this up in y an amount equal to the bounding box of the terrain – can use Ray node – used wrangle – VEXpression to project curve onto terrain: vector rayd = {0, -100, 0}; vector hitP, hitUVW; int hitPrim = intersect(1, @P, rayd, hitP, hitUVW); @P = hitP; – this has every point fire a ray downward and determines where this ray intersects the terrain, and then sets that point’s position to the intersection point Create Orthos – used a Polyframe node – turned off the Normal Name and reassigned the Tangent Name to “N” – this made all the point normals basically follow allong the curve – use VEXpression to direct normal vectors – used wrangle: – VEXpression: vector up = {0, 1, 0}; v@side = normalize(cross(up, @N)); v@up = normalize(cross(@N, v@side)); – Seeing as this did two cross products in a row, I this sets v@side directly perpendicular to the curve (in plane) then v@up creates a vector perpendicular to all of this, including the plane (so this creates a vector that is up from the line) Created the Posts – simple boxes where we polyextruded the top with a bit of an inset Copy Posts to Terrain – Used simple copyToPoints with our post and points along the terrain – this placed their centers at the curve location however, so they were buried half way underground – to fix this, we added another attribute wrangle before the copyToPoints where we moved the points along their v@up vector a distance equal to half of an offsetDistance – the offsetDistance channel then referenced the box sizey so it was always half of the height of the box – this positioned the posts directly onto the surface Starting Fence Links Simple Spread – Made 3 new copies of our offsetDistance wrangle node – the general offset to center the posts went into the first copy – this copy offset was used for the link locations – this copy then went into both of the remaining offset copies – one of these final offset copies had an inverse relative reference to the other’s offset – these were merged – this merge with the combined offsets created a spread, where changing the offset of the one offset corresponded to a reverse offset of the other Creating Separate Staggered Lines – put all of the points of the link lines into a group called cut – used polycut node to turn all of these small line segments between the points into individual prims – used an attribute wrangle with modulus 2 function to basically remove every other primitive – we then used a copy of this setup but with the opposite modulus (when equal to 1 instead of 0) to delete the opposite segments – these were then combined with an offset to give an overall controllable pair of segment groups – this entire setup was then copied to create a second set of links all together Parameterization – Using the offset attribute wrangle we created in several different locations lets us control several dimensions of the fence links – overall distance of links from the ground – distance between the two sets of links – spread distance within a link set itself Creating Links – used a small grid as the base object – used Sweep node to place these all along the link points – used a Polyfill (the polycap they used must be deprecated) to fill in the ends of the links Extra Polish – to make the fence links feel less identical, they added a varied horizontal offset to them – this was done by using another copy of the offset wrangle created, but changing the v@up to v@side – they then added a dir (direction) vector, which used another mod 2 function, but fit the result between -1 and 1 – this was also applied to the offset, so the links would alternate offset directions with each link

More Houdini Tutorials – Procedural Assets and More Basics

digm520admin / / Houdini, Tutorial
May 18, 2019

Houdini Tutorials

Procedural Assets

Vimeo – Intro to Procedural Modeling in Houdini: Making a Fence Asset

By: trzanko

SideFX – Introduction to Procedural Modeling

By: SideFX – Game Tutor

Since my main issues for my procedural modeling project stem from not being familiar with procedural asset tools, I figured I should finally take that approach for my tutorial searches to help learn some new techniques. This led me to this great tutorial on creating a simple fence asset that I think will actually give me some pretty relateable tools when it comes to positioning parts for my frog generator. I am really hoping this helps me control the digits and toes of the frogs in a much nicer way.

The other link is actually a series of small tutorials. I wanted to grab these as well since they cover the basics again, which is something I can still use review on as often as possible, as well as leading into the creation of a procedural stair asset. This seems fairly simple, which is a nice way to start looking into how procedural assets are designed.

Houdini Basics Overview

digm520admin / / Houdini, Tutorial, TutorialList
May 15, 2019

More Houdini Basics

Add Node, Along with Basic SOPS and Loops

Youtube – Houdini add node tutorial (RUS)

By: Houdini Nodes


Houdini – Add geometry node

By: SideFX


Youtube – Houdini Training – Appendix 01 – basic SOPs overview

By: Gianvito Serra


Youtube – Houdini Tutorial – SOP loops

By: 3D Tutorials and News


My procedural modeling class recommended looking into the “Add” SOP to get some webbing for my frog feet generator, and searching for this also led me to some interesting basic overviews concerning SOPs in general in Houdini. Although I don’t speak Russian, the first quick video still makes sense with what is happening visually. The other videos are just really nice overviews for a lot of different SOP options available, which are going to be key for me to have a good understanding of for my frog generator.