Short and sweet OP centric lessons

[kleer001]

Would anyone be interested in short (5-10) minutes videos showing how to use each SOP? (and maybe POPs, DOPs, & the rest later)

Do you think beginners would use them? Do you wish you had had them when you started?

I'm coming up on a break from work. I've been fantasizing about doing tutorials for each SOP. And I wanted to put some feelers out to see how they'd be recieved.

[Guest mantragora]

I would start by checking what Peter Quint covers with his tutorials and start from there. Reinventing the same subject over and over again doesn't make sense.

Edited February 18, 2013 by mantragora

[kleer001]

Oh, I'm quite familar with Peter Quint's work. I've used the material from several of his lessons in my last year of production.

His tutorials are great, if you're already familar with Houdini. His work is actually one of the reasons that I want to make more videos. Not to jump on his shirt tails, but to fill in the gap from starting from zero. I have lots of colleagues from different departments come to me and ask about learning Houdini and I direct them to SESI and to Quint. When I look at the available material from their perspective most of the it seems dense and intimidating.

What I would aim for is much simpler, shorter, and snappier (which I haven't found much of online). What I would aim to do is more of a bottom up approach, getting into detail with all the little bits, as opposed to a top down approach where you start with a final effect and then pick up only the pieces that are needed.

Edited February 19, 2013 by kleer001

[pclaes]

Hi Kleer,

I am about to record some tutorials as well and I agree with the shorter and snappier version. However much of the strength of the nodes comes from 'combos', so consider perhaps teaching 2 or 3 nodes that work really well together. (partition + connectivity, group by edges + polycap, connectivity + name attribute + blast by attribute, cluster sop + wedge rop, foreach + vopsop filter, dopimport as points + instance setup, isooffset-sdf + volume vop + scatter, ...)

Also one of the things that is really lacking a lot in my opinion is specific tutorials and/or example files on useage of vops. In vopsop, volume vop and shop context. Showing users to do specific operations that help speed up basic operations and potentially replace/reduce expression useage.

Things I would like to see more help on and will be creating some tutorials for: pointclouds (opening, filtering, writing), trace/intersect vop, quaternion vops, matrix vops, vector interpolation & manipulation, inline vop and array accessing.

My approach is the following. I will teach a longer tutorial on one of my more extensive setups. -- The file has already been built, so I am not building things from scratch. But at the start of the tutorial I will include a 'core' section. The core is 5-10 minutes long and covers the most advanced aspects of the setup, "the cool and tricky bits". Basically the kind of things a more advanced professional would want to know about, but does not have 1 hour to watch. After the core section at the beginning would come the actual longer tutorial for people that want to see all of it.

Parts of the file will be micro tools, each tool will be covered in a separate tutorial.

Good luck with it!

Peter

[Pazuzu]

Hi Peter!!

Will you sell those tutorials or will be part of some of the existing learning companies?

Thank you!!

Edited February 20, 2013 by Pazuzu

[danylyon]

Sounds great..

I've been doing lots of tutorials, there's really a lot out there.

What I'd love to see more, as somebody who swichted from another app (not a "newbie").. is an indepth explenation of how houdini works "under the hood". There's bits and pieces everywhere.. but most Tutorials center around an effect they want to achief.

Questions like: Where the Attributes get stored, how to get them (in VOP, Python, Expressions), Differences between Primitives / Points / Vertex / Volumes, the different Contexts, especially more general explanations of the DOP / POP contexts.. Solvers and Multisolver.. like an overall Houdini Tutorial but more intermediate to advanced..

I cringe whenever I see somebody use a shelf tool in a tutorial.. (I want to know exactly what's going on)

[old school]

What I'd love to see more, as somebody who swichted from another app (not a "newbie").. is an indepth explenation of how houdini works "under the hood". There's bits and pieces everywhere.. but most Tutorials center around an effect they want to achief.

There is no mystery as to how Houdini works. Anything that gets done in Houdini can be expressed by a node. Whether that node is a coded c++ operator, an operator written in VEX (or using VOP nodes representing vex functions), Python operators or Houdini Digital Assets (HDA's), each node does it's own bit and then caches it's result. There is no lower level than nodes.

The nodes in Houdini are the lowest level atomic routine/function/programme. A SOP node for example takes incoming geometry and processes it all in of itself, then caches it's result which is seen in the viewport, MMB on the node as it's stats and in the Details View to see the specific attribute values. If this is a modifier SOP, it will have a dependency on it's input node. If there is an upstream change, the current node will be forced to evaluate. If there is a parameter reference to another node and the other node is marked "dirty" and affects this node, this node will have been forced to evaluate.

To generalize the cooking structure of a SOP network, for every cook (frame change, parm change, etc), the network starts at the Display/Render node and then walks up the chain looking for nodes with changes and evaluates dependencies for each node also querying those nodes for changes until it hits the top nodes. The nodes marked dirty causing the network to evaluate the dirty nodes top down evaluating the dependencies that were found.

You can set a few options in the Performance Monitor to work in the older H11 way and see this evaluation tree order if you wish. Change that. It is "mandatory" that you do this if you want a deeper understanding of Houdini. You definitely need to use the Performance Monitor if you want to see how the networks have evaluated as it is based on creation order along with the set-up dependencies. Yes deleting and undeleting an object can and will change this evaluation order and can sometimes get you out of a spot with crashing. If you haven't used the Performance Monitor pane, then there you go. Use it. Just remember to turn it off as it does have an overhead performance wise.

Another key is to use the MiddleMouseButton (MMB) on any and all nodes to see what they have cached from the last cook evaluation. Memory usage, attributes currently stored, etc. the MMB wheel on my mouse is as worn in as the LMB as I use it so much. You can see if the node is marked as time dependent or not which will affect how it evaluates and how it will affect it's dependent nodes.

You can RMB on the node and open up the Dependency view for that operator which will list all references and dependencies. You can hit the "d" key in the network and in the parameter display options, in the Dependency tab, enable the various dependency aids (links and halos) in the network to see the dependencies in the network.

Houdini is a file system, in memory, and on disk in the .hip "cpio" archive file. If you want, you can use a shell, and given any .hip file, run the hexpand shell command on the file. This will expand the Houdini file in to a directory structure that you can read and edit if you so wish. Then wrap it back up with hcollapse.

If you really want to see how Houdini works low level, then this how it all ends up, and how it all starts.

It's just hscript Houdini commands that construct the nodes including the folder nodes themselves. Each node is captured as three distinct files: the file that that adds the node and wires it up to other nodes, the parameter file that sets the nodes parameters, and another file that captures additional info on the node. If you locked a SOP, then that binary information will be captured as a fourth file for that node.

It is for this reason that .hip files are very small, that is unless you start locking SOPs and that is not wise. Better to cache to disk than lock but nothing stopping you. When you open up a .hip file, all the nodes are added, wired, parameters modified and nodes cooked/evaluated.

There are different types of node networks and nodes of a specific type can only be worked on in specific directory node types. This forces you to bop all over the place, especially if you still willingly choose to use the Build desktop which I do not prefer. You have to have a tree view up somewhere in the interface to see how the network lays out as you work. It's also very handy for navigating your scene quickly. The Technical Desktop is a good place to start when working on anyone's file as there is a tree view and a few other panes such as the Details View, Render Scheduler and more.

If you want to use the technical desktop and follow a vid done with the Build desktop, simply switch up the Network with the Parameter pane and now the right hand side is the same as Build, but now you can follow the tree view and see where and when other nodes are dropped down.

A new Houdini file is an unread book, full of interesting ideas. Using a desktop that exposes a tree view pane, you can quickly see what the user has been up to in a couple seconds. Again use the Technical Desktop as a start if you are still using Build (if you know me you will know I will force you to have a tree view up).

You can quickly traverse the scene and inspect the networks.

If that isn't enough, you can pop open the Performance Monitor and see what nodes are doing the most work.

You really don't need any videos, ultimately just the .hip file. Helps if the scene is commented and nodes named based on intent.

Questions like: Where the Attributes get stored, how to get them (in VOP, Python, Expressions), Differences between Primitives / Points / Vertex / Volumes, the different Contexts, especially more general explanations of the DOP / POP contexts.. Solvers and Multisolver.. like an overall Houdini Tutorial but more intermediate to advanced..

Let's stick to SOPs.

In Houdini, attributes are an intrinsic part of the geometry that is cached by each SOP. Not some separate entity that needs to be managed. That is what makes SOPs so elegant. That wire between two SOPs is the geometry being piped from one SOP to the next, attributes and all. Not a link per attribute (which in other software can be a geometry attribute, parameter attribute, etc). This makes throwing huge amounts of geometry with lots of attributes a breeze in Houdini. All SOPs will try their best to deal with the attributes accordingly (some better than others and for those others, please submit RFE's or Bugs to Side Effects to see if there is something that can be done).

You can create additional geometry attributes by using specific SOPs:

- Point SOP creates "standard" point attributes

- Vertex SOP creates "standard" vertex attributes

- Primitive SOP creates "standard" Primitive attributes

- Use the Attribute Create SOP to create ad-hoc attributes with varying classes (float, vector, etc) of type point, vertex, primitive or Detail.

- Use VEX/VOPs to create standard and ad-hoc point attributes.

- Use Python SOPs to create any standard or ad-hoc geometry attributes.

One clarification that must be made is the distinction between a "point" and a "vertex" attribute in Houdini. There are other softwares that use the term vertex to mean either point attributes or prim/vertex attributes. Games have latched on to this making the confusion even deeper but alas, it isn't. In Houdini, you need to make the distinction between a point and a vertex attribute very early on. A point attribute is the lowest level attribute any data type can have. For example, vector4 P position (plus weight for NURBs) is a point attribute that locates a point in space. If you want, that is all you need: points. No primitives what so ever. Then instance stuff to them at render time.

You can assign any attribute you want to that point.

To construct a Primitive, you need to have a point for the primitive's vertices to reference as a location and weight. In the case of a polygon, the polygon's vertices is indexing points. You can see this in the Details View when inspecting vertex attributes as the vertex number is indicated as <primitive_number>:<vertex_number> and the first column is the Point Num which shows you which point each vertex is referencing as it's P position and weight.

Obviously you can have multiple vertices referencing a single point and this is what gives you smooth shading by default with no vertex normals (as the point normals will be used and automatically averaged across the vertices sharing this point).

In the case of say a Primitive sphere, there is a single point in space, then a primitive of type sphere with a single vertex that references that point position to locate the sphere. Then there is intrinsic data on the sphere (soon to be made available in the next major release) where you can see the various properties of that sphere such as it's bounds (where you can extrapolate the diameter), area, volume, etc.

Other primitive types that have a single point and vertex are volume primitives, metaball primitives, vdb grid primitives, Alembic Archive primitives, etc.

How does a Transform SOP for example know how to transform a primitive sphere from a polygonal sphere? Answer is that it has been programmed to deal with primitive spheres in a way that is consistent with any polygon geometry. Same goes for Volumes. It has been programmed to deal with Volumes to give the end user the desired result.

This means that all SOPs properly coded will handle any and all primitive types in a consistent fashion. Some SOPs are meant only for Parametric surfaces (Basis SOP, Refine SOP, Carve SOP, etc.) and others for Polygons (PolySplit, etc.) but for the most part, the majority of SOPs can work with all primitive types.

What about attributes? The Carve SOP for example can cut any incoming polygon geometry at any given plane. It will properly bi-lineraly interpolate all attributes present on the incoming geometry and cache the result. It is this automatic behaviour for any and all point, vertex, primitive and detail Attributes that makes working with SOPs a breeze.

How does Houdini know what to do with vertex attributes when position P, velocity v and surface normal N need to be handled differently?

When performing say a rotate with a Transform SOP and the incoming geometry has surface normals N, velocity vector v, and a position cache "rest", each attribute will be treated correctly (well N because it is a known default attribute but for user-defined attributes, you can specify a "hint" to the vector that will tell it to be either vector, 3 float position, or of type surface normal). It is this auto-behaviour with attributes and the fact you don't need to manage attributes makes using SOPs so easy and very powerful without having to resort to code.

Remember that each SOP is a small programme unto it's self. It will have it's own behaviours, it's own local variables if it supports varying attributes in it's code logic, it's own parameters, it's own way of dealing with different primitive types (polygons, NURBs, Beziers, Volumes, VDB grids, Metaballs, etc). If you treat each SOP as it's own plug-in programme, you will be on the right path. Each SOP has it's own help card which if it is authored correctly will explain what this plug-in does, what the parameters do, what local variables are available if at all, some other nodes related to this node, and finally example files that you can load in to the current scene or another scene.

Many hard-core Houdini users picked things up by just trolling the help example files and this is a valid way to learn Houdini as each node is a node and a node is what does the work and if we were to lock geometry in the help cards the Houdini download would be in the Gigabytes so nodes are all that is in the help cards and nodes is what you need to learn.

I'm not going to touch DOPs right now as that is a different type of environment purpose built for simulation work. Invariably a DOP network ends up being referenced by a SOP to fetch the geometry so in the end, it is just geometry which means SOPs.

I cringe whenever I see somebody use a shelf tool in a tutorial.. (I want to know exactly what's going on)

Shelf tools are where it's at but I hear you. Yes there is nothing like being able to wire up a bunch of nodes in various networks and reference them all up. Do that for a scratch FLIP simulation once or twice, fine. Do that umpteen times a week, well that is where the Shelf Tools and HDA's make life quite simple.

But don't be dismayed by Shelf Tools. All of those tools are simply executing scripts that place and wire operators together and set up parameter values for you. No different than when you save out a Houdini .hip scene file. If you are uber-hard-core, then you don't even save .hip files and you wire everything from scratch, every time, each time a bit different, evolving, learning. So with the shelf tool logic you find so objectionable, if you open up an existing .hip scene file, you are also cheating.

Reminds me of the woodworker argument as to what is hand built and what isn't. I say if you use anything other than your teeth and fingernails to work the wood, you are in essence cheating, but we don't do that. Woodworkers put metal or glass against wood because fingernails take too long to grow back and teeth are damaged for ever when chipped. And I digress...

Counter that to power users in other apps that clutch to their code with bare white knuckles always in fear of the next release rendering parts of their routines obsolete. With nodes, you have a type name and parameter names. If they don't change from build to build, they will load just fine. I can load files from before there were .hip files and they were called .mot (from Sage for those that care to remember) from 1995. Still load, well with a few meaningless errors but they still load. A Point SOP is a Point SOP and a Copy SOP is a Copy SOP. No fear of things becoming obsolete. Just type in the "ophide" command in the Houdini textport and you will still find the Limb and Arm SOPs (wtf?). LOL!

First thing I do every morning? Download latest build(s). Read the build journal changes. If there is something interesting in that build, work up something from scratch.

Then read forums time permitting and answer questions from scratch if I can.

All in the name of practice.

Remember from above that a .hip file is simply a collection of script files in a folder system saved on disk. A Houdini HDA is the same thing. A shelf tool again is the same thing: a script that adds and wires nodes and changes parameters. Not pounding a bunch of geometry and saving the results in a shape node never to have known the recipe that got you there.

To help users sort out what created which node, you can use the "N" hotkey in any network and that will toggle the node names from the default label, the tool that added that node and finally nothing. Hitting "N" several times while inspecting a network will toggle the names about. That and turning on the dependency options in the network will help you see just what each shelf tool did to your scene.

Knowing all this, you can now troll through the scene and see what the various shelf tools did to the scene.

If you like to dig even deeper, you can use the Houdini textport pane and use the opcf (aliased to cd), opls (aliased to ls), and oppwf (aliased to oppwd and pwd) to navigate the houdini scene via the textport as you would in a unix shell.

One command I like to show those more interested in understanding how Houdini works is to cd to say /obj then do an opls -al command to see all the nodes with a long listing. You will see stats very similar to those found in a shell listing files or if you RMB on any disk file and inspect it's info or state. Remember Houdini "IS" a file system with additional elaborate dependencies all sorted out for you.

There are user/group/other permissions. Yes you can use opchmod (not aliased to chmod but easily done with the hscript alias command) to change the permission on nodes: like opchmod 000 * will remove read/write/execute permissions on all the nodes in the current directory and guess what? The parameters are no longer available for tweaking. Just remember to either tell your victim or to fix it for them or you may be out of a job yourself. opchmod 777 * gives back the permissions. An opls -al will verify this.

Now you know what our licensing does to node states as you can set the state of a node to be read and execute only but remove the write to any DOP or POP node and you have a Houdini license while a Houdini FX license will enable the write to all nodes in all networks.

Also knowing this, the .hip file truly is a book with a lot of history along with various ways of inspecting who created what node and when, what tool was used to create this node, what dependencies are on this node, is it time dependent, and more, all with a quick inspection.

After all this, learning Houdini simply becomes learning each node in turn and practice, practice, practice. Oh and if you haven't figured out by now, many nodes have a very rich history (some older than 30 years now) and can do multiple things, so suck it up, read the node help cards, study the example files and move forward. The more nodes you master, the more you can see potential pathways of nodes and possibilities in your mind, the faster you work, the better you are. The more you do this, the more efficient your choices will become. The learning curve is endless and boundless. All visual. All wysiwyg.

[sliver]

Nice idea thanks

[magneto]

Thanks old school, really enjoy reading your insights. You should write a book on this or maybe some 5+ hour video series on this sort of rants

Since you explained SOPs in great detail, I am wondering what are your thoughts on POPs? There was a popular thread here that most people use VOPs instead. I know POPs also allow you to use local variables directly, but would it not be possible to have SOPs with variables instead of POPs?

Because from what I see, particles are the best candidate to be thought of as points with attributes == SOPs.

Is this an area that has a bit of story behind or is there more to it than meets the eye?

[kleer001]

Hi Old School, thanks for the learnin! Some of the stuff I already knew, but some was completely new.

I do have some technical hair splitting to do, but I think it's important enough to mention. And maybe you could give me some feedback?

I disagree with your earliest point. Not everything that happens in Houdini can be expressed by a node. There's the whole frame of the interface. There's a whole slew of display settings. There's a wonderful world of windows and contexts and panes and tools and colors and controls and views, etc...

Also I feel that most people do need videos to get a better idea of the rhythm and flow of the creation a scene and an effect. Sure a .hip file is a treasure trove of information (and should be offered with each video), but no .hip was created instantaneously or (at least in my limited experience) created without any mistakes that had to be corrected as the artist went along. A .hip is not a super messy business and there's a lovely trail of bread crumbs, but not everyone leaves the trails that lead to dead ends and those are as important, I think, as the trail forged straight to the end.

You've given me a lot to chew on, thank you for your post.

[trili]

There is no mystery as to how Houdini works. Anything that gets done in Houdini can be expressed by a node. Whether that node is a coded c++ operator, an operator written in VEX (or using VOP nodes representing vex functions), Python

old school, Your comments are best for my leanning houdini, Thanks so much! I have got so much knowledage from your comments here. Though i am new to houdini, but i'm so comfortable with this wonderful tool, love it and will follow it forever if everything is going on like this.

Thank you, old school, and please continue on.....

[Netvudu]

Either what old school wrote is very good, or I´m a real Houdini freak because not only I read the whole thing....I also enjoyed it!

Edited March 23, 2013 by Netvudu

[Guest mantragora]

There is no mystery as to how Houdini works. Anything that gets done in Houdini...

What?! No pictures ? Meh...

[danylyon]

Wow.. great read! Exactly these kind of information helps me understand Houdini.

You would be surprised how many times I tried to do something in Houdini in a compicated way only to realize.. it's a lot easer!

As for the shelf tools.. I do agree, they are definitly powerful, but I think they should be for "advanced users".. If you can't build it from scratch than you don't know how to enhance a shelf tool. Getting stuck really quickly.

I think it would be a great learning experiance to carve wood only with fingernails and theeth.. but only once. After that you would get a whole different understanding for wood.. enabling you to work better with actual tools. (I do mean this seriously!) :-)

[Verville_Pierluc]

Thanks old school! I've learned so much!

[NSugleris]

Old School = Amazing.

Comprehensive

Thanks, for a FX artist who is trying to get used to using Houdini full time... Thanks

Edited March 27, 2013 by morganfreeman

[ryew]

Great reading - thanks Kleer, Peter and Old School for some meaty posts on the subject.

With regards to learning Houdini, one aspect I haven't seen mentioned in this thread is training to learn *why* to use a particular node or combination or nodes.

Houdini - more than most packages, I would say - provides a multitude of different ways of varying efficiency and eloquence to arrive at a similar end result. Some solutions may produce results that are fine as a minor prototype but not scalable efficiently for production use. Others may work but only through chance and happenstance (i.e. "dumb luck").

Digging through help cards and .hip files is all well and good, but understanding when and why particular nodes should be used is a topic that I rarely, if ever, see covered by the major commercial tutorial sites. This is a topic I likewise see a large lack of knowledge about, both in myself and my peers.

Peter Quint often does a great job at explaining not only what nodes he is using but why he has chosen to use them, providing advice and cautions as he goes. If those creating tutorials can follow his lead and share their workflow logic/thought process, it would be of great benefit for us eternal students out here!

[kleer001]

Exactly Ryew! It's all very personal, like the waiting room in the movie Beatlejuice. This is the way he does it, this is the way she does it, and that over there is the way that they do it.

What I hope to provide is a personal view into how I've come to use Houdini. It's funny actually now that I've been using it for a bit longer and have some experience (but always a beginner) I watch tutorials and sometimes think to myself "That's not the way I'd do that." or "Well, that's going to need fixing in a moment." or even "Whoa, what're you thinking? There's a waaay easier way to do that."

Having just recently gotten a new job, yay, and working on finding a new place to live I'm a little stretched for time, but these tutorials are still a priority.

Update: I now have an outline and am working on fleshing it out. Right now it looks like I'll be covering the top 55 (or so) SOPs that I use the most (almost exclusively)... That's 55 out of 300+.

[trili]

Exactly Ryew! It's all very personal, like the waiting room in the movie Beatlejuice. This is the way he does it, this is the way she does it, and that over there is the way that they do it.

What I hope to provide is a personal view into how I've come to use Houdini. It's funny actually now that I've been using it for a bit longer and have some experience (but always a beginner) I watch tutorials and sometimes think to myself "That's not the way I'd do that." or "Well, that's going to need fixing in a moment." or even "Whoa, what're you thinking? There's a waaay easier way to do that."

Having just recently gotten a new job, yay, and working on finding a new place to live I'm a little stretched for time, but these tutorials are still a priority.

Update: I now have an outline and am working on fleshing it out. Right now it looks like I'll be covering the top 55 (or so) SOPs that I use the most (almost exclusively)... That's 55 out of 300+.

Wow... I am looking forward to your tutorials. Thanks, kleer001!

[barad_dur]

I would absolutely watch these. I had been pondering this very concept for awhile now but always found myself in a position of not knowing enough about Houdini to start them up.

In my version of your idea I was including "exercises" after the detailing of a concept.

For example:

Video: 5 - 10 minutes about the Carve SOP.

Exercises (as a text file): 10 problems that can be solved using the Carve SOP of increasing difficulty.

Example Exercise: "You have a Sphere Primitive and would like to use the Carve to keep only the top hemisphere of the Primitive. How would you do this?"

Example Answer: You are not able to use the Carve SOP on a Primitive, the Sphere must be a NURBS, Bezier or Mesh. Therefore to use the Carve SOP to get the top hemisphere only you must change the Sphere "Primitive Type to either NURBS, Bezier or Mesh then check Second V and set to 0.5.

I think the addition of Exercises, while totally "school like" would help to reinforce the concepts and foster critical thinking. I have been wanting something like that for a long time.

Just my 2 cents.