USD Rendertime Procedurals in Production | RISE Visual Effects Studios | FMX HIVE 2024

[Music] hello everybody and uh welcome to this presentation on USD Husk procedurals in render time procedurals in karma my name is f yel and I'm part of the effect team at rise visual effects Studios let's first have a look at uh our recent work and the show real and the recent projects that we've worked on [Music] [Music] [Music] you [Music] [Music] [Music] [Music] [Applause] I think there was some hiccups in the playback I just realized uh sorry about that um so the agenda for today um and what I'm going to talk about is um we look at render time procedurals first we're going to start with the general over overview and look what they are and then we'll look into husk procedurals that are currently available in Houdini and Karma and then we'll have a deeper look into hair procedural and invoke graphs and then also look at um dictionary arrays in in Houdini and then finally have a very short overview over the ocean procedural and see the similarities between those this talk is going to mainly be about hair and fur and character effects but um yeah again it's it's more about the under the hood technology a little bit so um everything before I start the presentation I want to mention the team and the people at rise who contributed or still contribute to the development of all these creature effects work that we do there so it's Leia yunas Luca Lisa and Simon and also all the images and production aset room work that I'm going to show today is um was done and created by Leah so I'm just here sitting presenting the stuff um so what are render time procedurals in general in CG it's um this a short recap so that's just geometry that's being created on render time um and this is done by algorithms applied during this uh render time and then based on the procedural rules and parameters the render engine generates the data and on demand and a very well-known example for example that you all know is a subdivision surface displacement sorry of surface displacement where geometry is being subdivided dynamically at um runtime so um obviously the main advantage is simply resource efficiency you reduce storage which can be a very important and huge factor in in VX production or any production so for example when usually working on many shots across multiple sequences a preframe cache file size can become very huge and it of course also helps reduce iio in Sim times and then it makes uh also efficient use of uh memory and obviously it increases the viewport performance and the feedback while you're working with the asset so for example in the case of the grooming asset that I'm going to show the lowest guide count forur uh which we interacted with in the viewport was like I don't know I think 40,000 curves something like that while the rendered hrus version was up to 4 million in the end I guess something like that so you immediately see the benefits there's only one small slight disadvantage that it is a bit non-interactive since you have a bit of a delayed visual feedback of what you're working with and of the final result but then there's something called USD preview procedurals and Karma which of course help with that which we will have a look at uh in in a minute so yeah uh currently there are these four USD husk procedurals available in karma lobst Solaris so that's a hair procedural that was introduced with 195 and then we have the ocean procedural and then uh since 185 I think was the RBD destruction lob and then also with the recent release of foodini 20 there's the feather procedural we will look at the hair procedural mainly and then have again like I said a small Outlook into the ocean procedural um and then for this preview or the faster feedback that I just mentioned there's these preview procedural lops for interactively previewing your stuff in the viewport and and rendering them already in in karma and see what you get so uh let's look at the hair procedure a little bit and dive inside and see what it does so here on the right side you can see the parameters when you launch the lop and and create it and place it into your not Tre and now we will have a look at each of those and see what they do and um how they can be used actually in typical production workflow so the note itself comes with two different modes first is the generate mode and then there's theform mode the first one the generate uh it just creates what not just but it creates static highis curves based on already existing lowest uh guide curves so that's basically what the head generat so note does if you know that from SS and this can be used for asset creatur work as well as like static environment for example like grass or Moss or any kind of vegetation that you could think of and the other mode is the deform mode uh which deforms existing static highr render curves on one frame based on animated or deforming or even simulated guide curves and a deforming skin geometry like the character or the AET itself and that's typically what you would do in cfx with animated characters or assets and the nice thing is that you can again do deformation on top of simulation there are some attributes and primar required for that to work properly which I wrote down here and uh basically it's it's like the deform mode is more like a wrapper of the hair generate soap and the guide deform swap in one with a little bit more advanced features which we have will have a look but this is the basic core uh of it um then the next parameters are the actual UC prims uh that the hair procedural needs generates and uh works with uh first first one being the procedural primitive which actually is an empty USD primitive that's being populated on render at render time uh with the highrisk render curves and then um we we have the the guide curves which are like I mentioned the the lowris curves uh they're usually coming from zops or the already roomed model itself lobs and then there's the skin primitive which is the asset itself the character which is the mesh geometry that's that holds all that um guide curves and the sorry the and then the high-risk curves that are being generated on on it at U at render time so let's have a look at the uh the Lop itself in in production so here's a actual production screenshot on the left on screen left um you can see the lowrisk guide curves that our artist ler at groomed and created and on the right is an early stage temp version of the highrisk render curves which we created with this technique so what you see is on the left is uh actually what you would uh write out the dis and what you would interact with in the viewport this I think it was 40,000 and then the other one is about 3 million or 4 million I don't know and um the hierarchy and the UC primitive the the not three is very like this is the minimal version of it I reduced it to a bare minimum here to only show what's actually relevant or needed so this is what you have in the USD stage note Network and let's have a look at that in uh in action so in comes the asset the the layer the asset itself there's a light and then you merge in the guide room and then you apply the Houdini procedural assign some materials and then render it in viewport so let's have a look this is the asset and simple dome light and then in Comes the Groom and then you can tumble around in the viewport and um yeah and then you get the apply the Houdini procedural with all the parameters that's needed again the procedural Prim the guide curves and the screen Prim and then uh ha over uh gen um generation overrides and then materials and in the end is the put in preview procedural and if you switch that to Karma actually and let it initialize for a second then you get the iris render curves and this right now is I think I believe yeah 3 million in total uh compared to the 40,000 which were coming in from the guides and then again you can tumble around so I I will let that run for a second before we will have a look at the procedural use the Primitive itself and how it does look under the hood a little bit all right so uh this husk procedural use primitive what what is it like it's it's just an empty Prim right but what does that mean what does it have and which parameters are available on an empty Prim so um husk by the way um the name husk is a command line you for rendering any USD file or for any Hydra render delegate in this case we're looking at Karma obviously so the husk procedural primitive um uh is the one what we're going to look at now and Screen left you can see the path to the empty Prim and on the right there's this uh available parameters that come with it and uh now let's have a look a closer look at the primar in the middle so because obviously they give us the most important information about the USD primitive itself basically all the information that we need so in the middle highlighted in green there's for example a value called hair generate uh hair count with a value of uh this 3 million which I just mentioned and then and the value comes from the right screen right um which is basically the user value but you just um type in and where it says generation and number of hair that's total hair count right so and these are again the the user overrides that then effectively change your primitive at render time and above that you have these two primar called procedural arcs and procedural paths in in uh path in the middle and we will have a closer look on these and um because those two are actually the interesting ones that built the ground for everything to work and make the pro proced what it actually is um we're going to look at them and then if you look at the lower one of those it says invoke graph. pi and this sounds very interesting um and this is the invoke graphs that we're going to talk about because these are the building blocks or the main Foundation of this uh whole systems and we will look at the functionality and the concept behind um so but first let's have a a look at one of its companions which builds the foundation of the invoke graph soap and that's the attribute from Palm soop so this node actually turns all the parameters in the node that you used to from working with udini uh into a dictionary array with some key value Pairs and uh writes that into a detail attribute so for example when you expect it all the parms available on the Taurus are being written into the dictionary detail attribute like radius scale transform whatever you have on the right so and since this is just linear attributes we can change or set or adjust or even overwrite them to our needs so either with a Wrangle or with a so note and one of those so noes is the attribute adjust dick so for example let's see that in action so here is a taorus with some uniform scale of one and now I changed this value and you can inspect the the geometry spread sheet where you really can see the the values being changed but obviously this doesn't affect the Geet because it's coming from Upstream how would it so again this repeats now atorus and then attribute from Palm turns it into this detail attribute with all the parameters dictionary uh array and then you change the values and you can watch these happen in real time in on spreadsheet but of course you want to change it right so there's a way to actually override those parameters and detail attributes afterwards and have that to change and effectively change the geometry so um and the nice thing is you can um change that to any arbitrary geometry which is coming in and this is even more interesting so this is where the spare inputs and the parameter over overrides which you can see on the right side uh come into play Let's see this in action so here I'm just linking the attribute I just dick top with the spare input of a newly created Taurus and now when we change the scale and the attributes they take effect so hence you're just overriding the detail attribute coming from the attribute from palop and the one note which actually does this all for us in a much more interesting and procedural Man U manner sorry is the next note um we going to look at which is the invoke compiled graph so which was introduced with 3d9 the documentation says processes its inputs using operation s defined by a geometry graph but the documentation also says the usefulness of this note is very esoteric and I think that's an understatement you should re re I would rephrase that to this is one of the most powerful Concepts in Houdini out there so and this sentence makes it really interesting to have a deeper look I think so um yes so what it does actually it invokes or calls parameters from a S graph and this graph can be one single note as in this example but it can also be many notes like a whole node Network so the attribute attribute from palop that we just saw in action turns the Box geometry in this case into one single point including the parameters needed to describe the Noe kind of like a recipe for the noes so to speak and then Downstream the invoke graph reads this graph information and recreat creates this geometry on the Fly this is so cool and then the next step of course is then to invoke a whole graph instead of only one single Taos or box node so but in order to do so there's one important thing to to know here the nodes have to be encompassed inside a compile block this is where the name invoke compile graph comes from I guess so the compile block wraps the whole tree into actually kind of one node and you can see that also when you inspect the performance monitor while cooking and this is ideally multi-threaded so it comes with some gain in performance as well which is great and since no each note does not have to hold a copy of the data coming in from Upstream in the memory this is where the performance comes in and then it only holds the information of what the node actually does with the geometry so here for example it just first subdivides and then transforms the incoming goo and again that attribute from Palm uh turns it into a dictionary and um the detail uh attribute and then this graph can then be written to disk so with this graph then your note network is actually converted to a real but abstract form of foodini geometry and then each Noe is being turned into one single point and each node connection are represented by lines and each node parameters are stored as those key value pairs that I mentioned and very important here is the node must be compilable if you want to use it in the compile block and they also referred to as verbs or verified nodes and um non-comparable nodes as I as I show here um have this batch you can immediately recognize by this batch which I made extra large to see for time shift note for example um but that's only a few like I think up to now it's is 95% or so something like of all TOS have been already verified and hence can be uh used in those uh compile blocks so here's a short summary for of the steps again from this workflow for this workflow um so you write your not graph dictionary to a native Houdini B file and basically save this recipe of the node graph to disk and then you read it back invoke this graph recipe with the invoke graph so and this way it loads the recipe from that disk file from the bgo file and then you apply that graph to any arbitrary geometry afterwards and then you can overwrite that dictionary parameters and uh for those who worked with Apex so far uh they might know this invoke workflow since it's also used heavily in the new Apex uh rigging workflows and U framework and that's what we're going to what I'm going to show now and what I'm showing here uh so you write that out as a bgu and then read it back back from dis and invoke it and all node operations from inside the block here like for example the subdivide and the transform node now become a recipe for the whole structure and then can be applied to any arbitrary geometry and then um and please note that there's no absolute or live note connection here between the lower part of the network after the read Noe and the upper part so they are separate and um totally independent so uh let's have a look so here's the compile block with the subdivide in the transform and then it turns that attribute from parm turns it into this dictionary but I just mentioned and now you even have that geometry graph representation in the viewport so now watch what happens if I move around the notes so this is turning the the nodes into a point and the connections into lines this is not esoteric this is cool so um and then you read it back in apply the graph and here I just apply it to a box but of course you could apply it to a Taurus and then it gets subdivided and then even to a utot and then get subdivided and transformed or you can merge those and all of them are being I mean the Taurus obvious the platonic obviously wouldn't be subdivided since it's a subdivision surface nervs uh Nerf surface meesh but um the the uh basic principle I think comes comes over here quite clearly I hope so yeah I repeat that once again so here you can see that it's completely disconnected now and then you just invoke it and apply it to the the operations to the graph uh to the geometry sorry all right so now let's see what the other note inputs input connections can do of this noes they are called inputs but they also really represent the inputs of the compil block of the graph that they operate on so um these inputs can also do overwrite parameters so here for example I'm reading in the graph again applying it to the Taurus and then with a Wrangle and a few lines of Vex code I'm overwriting the parameters I think it's a scale subdivision depth and rotation yes with a few lines of of code and then you can or must in you in this case use spare inputs again in order to make this Palms overridable so I will leave this slide open now and and you can see yourself how the spare input is linked to the to the Note coming from the the right side and then you have this dotted line and see how it's connected so this is the transform this is subdivide and then both are just spare input linked with the uh right input and uh since a few versions now Vex includes uh has a dictionary data type so you can create manipulate and um access dictionary arrays via code where directly and the syntax is quite straightforward the general form is as I show here it's sck and then parentheses key and then you type in the value so the Vex type is sck and the syntax is D at name and in order to to change the value of an index in that array you can do for example D at parms and then in parentheses uh par name and then just apply your value that you want to so for example for rotation or override the scale with this um uh with this with this code so let's see this in action as well change here I'm changing the um the scale and the rotation and all the like the subdivision of uh those different geometries so you just apply any kind of geometry and then apply the operations so and uh while played around with this and doing some testing in R&D what I found out that is you can even chain multiple invol graph SS so kind of similar to a for Loop you can iterate over an arbitrary amount of elements and just return the result and now when you override the Palms again then it takes effect for the whole Loop basically so now but everything that I just showed and that we saw now can be done via pre-render script as well and this is exactly what the husk care procedural and I believe also the other procedurals um do under the hood so the uh setting up the graph that's connected that that's going to be invoked sorry and then you read the inputs and then you read and overwrite the palms and create the geometry or the Primitive and then uh run a pre-render script and uh actually before rendering the final image so let's dive inside the head procedural now and learn from the developers so there's a l note called Define and setup pair procedural Prim and this is where all the magic happens on screen right you can see all the parms and in the lower section there's a python source and if we we're going to inspect the code a little bit now and in it there's everything defined so for example the pro procedural Prim as well as the graph that's being created and the inputs and these things are the building blocks of the whole invoke graph workflow that we just uh looked at and this is where it all comes then together in the end so um here's the procedural Prim and the hair graph this is all on the python script blob and then there's this block of parameters which are the actually the user overrides so to speak and then um for example the total hair count the hair length multipliers and the width scale and and whatnot and uh if you look at the python Source the code itself uh you can do that and and read it if you want to but I just highlighted a few parts of it uh in green these are the input prims that come in from the right upper side that you can see the guide curves and the skin mesh the red part is uh where uh which defines and builds the procedural Prim which is the empty procedural primitive and where the highrisk curves are being generated onto at render time and then it uses the USD geometry USD geom module and the bases curve schema in in USD you can all look that up in the USD documentations and then the purple block is uh this this is where all the um parameter overrides the override pars are defined and finally in white the Houdini her procedural graph that is then being invoked by the script on render time and there's uh in this primar you can see that this hair procedural path and the python script called invok graph and um you can find that script in your Houdini installation folder and have a look I will show the path in a second and um this is where it you can find that that's the path to the location of that script if you want to have a look in Ty inside this is actually the the python script that's being then called before render time I hope I said that correctly now so and then here again is a summary of the steps included to execute and render that procedural so husk basically traverses the whole hierarchy the whole stage and then it looks up and finds all the Primitive with this Houdini procedural API schema applied and then it applies the overrides and runs the python pre-render script at render time and uh this is the case for both the Houdini preview procedural as well as the USD render Rob and in case you have a USD render Downstream then this Houdini preview procedurals is being uh bypassed on render time and um and that one is actually if you look at the parameters that are what just mentioned the Houdini procedural API schema is what I show up here and the that that's there's nothing to to set or change there and um now as promised there's another procedure that I'd like to show really like very briefly and this is more like a short overview and also a little bit to see the similarities between both of these uh procedurals even if they cover completely different areas one is grooming and fur and the other one is ocean but uh it's about water and it's a effects so it's cool and it's the ocean procedure which was introduced with latest Houdini 20 version 20 um so its main features or main workflow steps are you bake or write the ocean Spectra as a bgus SC file um and then there's one cool feature which we will have a look at in a second is the camera Frost and based surface subdivision or dicing and then you have some very nice and neat uh viewport overrides for faster viewport feedback which help a lot for interactively working with the ocean and then uh then you have different things like Spectrum resolution down sampling dicing quality shading and foam all of them as user inputs and overrides so let's have a look at this and uh you will see immediately that the structure is quite similar to the one before and these are the parameters so again there's the procedural the graph on the upper right and then the user overrides in the middle and then again the python source code where all the magic happens in the end and um if you look at this code it's again quite it looks quite similar to the one before and uh you again have the inputs the overrides and finally the Houdini procedural API calls and the path to that graph but there's also one very nice thing about this new note which is again the frost and based icing of the surface let's see that in action so uh on the right uh you can see tile patterns actually I didn't mess around too much with the settings but yeah this is the rendering out of Karma and then on the left you can see the viewport representation the wires and just to get a context so the camera is placed um far screen left and then the dark area in this wires is actually the camera frem subdivided area and um I think that's almost it so before I finish this let's have a quick look at that and see that in motion so this is the rendering on the right and then you can see when I change the camera the viewport add the camera angle then the the um subdivision of this this geometry the surface is being changed accordingly and then you have this ort quality which is really cool where you can change the resolution one would be the native resolution and then I think I use 0.2 of 0 uh 05 here to really lower the resolution the the the the resolution representation of the ocean to have faster feedback but once you put it to one then you have a really highrisk uh ocean surface geometry like the the full spectrum here it's 0.2 and it's all already looking cool but you can go up to one of course and then you have the materials and everything else so I think that concludes my talk for today and uh yeah that was a um this was the two husk procedurals and hopefully some insights into insights into them and if you want to read and learn more about these things um there are two fantastic presentations I want to recommend here one is Jeff L's master class on compile Sops and the other one is by Steven laves I hope I spelled that correctly now um on generative hydro procedurals and converted both to QR codes so if you want to scan them go ahead and uh that's it thank [Applause] you [Music] questions yeah hey um have you tried using the invoke graph concept on other things than the already existing procedur setups that are there like ocean and hair and so on if you try to reuse that filling it with data to get something that was not intended have you experimented in this Direction with the invoke graph soap you mean yeah like that is used in USD because that sounds interesting to me to also you know create anything on the Fly uh geometry wise no I didn't but I think you could you could right yeah of course but there was no need yet for for you to try that I didn't do that right no okay yeah cool other questions yeah lovely presentation love love all the detail uh totally agree that the invoke graphs are not just like a side feature it's like a back of the box um what procedurals are you kind of excited about exploring next like where would you see this applied um kind of other areas in the work that you do at rise to be honest I think and hope that will be more coming and I think procedurals are in general be getting bigger and more like a focused topic to be honest and I I could even imagine thinking of other areas where there could be like developed for crowds top of my list I have no idea about this yeah it seems possible but I like I don't know it just seems like you could do the deformation and then generate the crowd people at time yeah examp what you just mentioned I don't know but maybe yes cool but there in general I think they're getting bigger bigger and more more focused on so that's going to be a topic definitely for the future and we're looking into this of course here other questions going once going twice thank you very much foit you're welcome