Jump to content

Leaderboard


Popular Content

Showing most liked content since 12/25/2021 in all areas

  1. 6 points
    Another variant using some more recent nodes. 00_patchwork.hiplc
  2. 4 points
    Shortens edges and line segments by an inset distance. Optionally takes the point scale attribute into account. The shortening distance can be limited to a rest length. konstantin_shorten.hdalc
  3. 3 points
    Thrilled to show a teaser of my future Houdini tutorial. Key topics: - Proceduralism: geometry and animation - Pyro: explosion with love - Karma XPU: pain and joy *99.9% done with Karma XPU Release on gumroad soon.
  4. 3 points
    You do not need to use an attrib transfer btw. You can use a pop collision inside DOPs and you can output a grp for the hit the collision for you to color post sim. Flip is just pts so you can use any of the pop nodes. Here is the scene fixed. ap_flip_colorize_collision.hiplc
  5. 2 points
    This is Procedural Design in Houdini . Everything is generated, on the fly with PDG and custom process and algorithm from the head primitive. This is not a render by the way, just OpenGL capture Sorry after upload , i realized my animated GIF seem not accepted by the server, image is not updating, and i can find a way to delete my post... ________________________________________________________________ Vincent Thomas (VFX and Art since 1998) Senior Env and Lighting artist & Houdini generalist & Creative Concepts http://fr.linkedin.com/in/vincentthomas
  6. 2 points
    Procedural design research, Heads are tricky... Still have issue to creat the cable network. Im using the quasistic mode with no cache history in vellum as every bot is generated every frame so timeshift is not really what im looking for and i need more than 100 frames after to have my sim stable enough for an output... Still fighting with the collision between cables (cables are not shown in my OpenGL capture below) ... Grrrrgrrhh ________________________________________________________________ Vincent Thomas (VFX and Art since 1998) Senior Env and Lighting artist & Houdini generalist & Creative Concepts http://fr.linkedin.com/in/vincentthomas
  7. 2 points
    Here's few bot example the process could give birth ... Actually some details could only be seen in 4k. Screenshot will give you an idea how the geometry built looks like. It was another experimental research, not saying im happy with everything and i will adapt according for the next try. But this is mostly a non technical question. This is kind of network driven by DG will be a good candidate to feed a Machine learning model like i shown on linkedin before with the Skull generation. Click on each image to see HD version.
  8. 2 points
    is because you are using a new OTL 2.0 of the guide groom, you can go back to use version 1.0 if you go to Assets > Asset Manager > Configuration and change asset definition to show always then you can change the OTL version. However, you should be able to do the same with the newest OTL.
  9. 2 points
    You can merge in your collision mesh and colorize it. Then use an attribute transfer to copy the collision color onto the flip particles. ap_flip_colorize_collision.hiplc
  10. 2 points
    With Houdini moving to Python 3, that code no longer works on H19.0.455. I have converted the Python code to version 3, and added a slight randomness to the extrusion of each country. The new code produces a console warning, but the mesh generation still works. houdini_world_map_by_countries.zip
  11. 2 points
    This is my latest personal work in collaboration with Marco Pallini. We tried to recreate three shots from "The Mandalorian" television series. Hope you like it!
  12. 2 points
    With SOPs: Connect adjacent pieces-node, activate length attribute. Blast node set to primitives, group field: @restlength<0.02 With VEX: float radius_min = chf('radius_min'); float radius_max = chf('radius_max'); int pts_max = chi('maximum_points'); float dists[]; int pts[] = pcfind(0, 'P', v@P, radius_max, pts_max, dists); foreach(int i; int pt; pts){ if(dists[i] > radius_min){ addprim(0, 'polyline', i@ptnum, pt); } }
  13. 2 points
    Hi anna, if you target a houdini career, i would definitly not recommand to spend 5 years in a VFX school, you will pay too much for what you need and for what you will get. If you live in latvia, you live in a country with very good computer science guys around you. and i guess there must be some strong academic school in computer science very close to you. So if you target a Houdini TD career , i would start with a 2/3 years generalist computer science gaduation where you will learn Math / Physics / Algortithmic / C/C++/Python / some good OOP methods, if by chance you can have a computer graphics option with OpenGL/GLSL/HLSL course that would be even better. And during your 2 years learning computer science i would eat as much houdini tutorials as i can, trying to do small exercices just to practice with houdini 1 hour everyday. then i would assemble a small reel of what you can do with code and also with houdini during those 2 years and then apply in a school for a 2 years houdini focus training, i would not spend more than 18.000 euros for this. the good things about learning computer science , is that you will be a better houdini artist than anyone in your school cause you have train your brain to solve hard problems doing math and code. and when you will get older and want to leave the vfx circus like many people around 40/45 you will have a strong academic diploma to move to tech companies. people from eastern europe have strong skills with math and code, you had to exploit this to your advantage. for the tutorials to watch in priority : 1- during your computer graphics academic, focus on learning the basics and the vex/vops/sops fundamentals : https://www.hipflask.how/courses -> good start https://entagma.com/ -> best in class to play with code and solver https://www.tokeru.com/cgwiki/?title=Houdini -> best in class to get advanced info https://www.pragmatic-vfx.com -> i don't watch it but friend tell me it's AAA for advanced vex 2 - In VFX school now that you have strong basis with houdini logic on top of your houdini class, you can start mastering the solvers FLIP / PYRO / RBD https://vimeo.com/goprocedural/videos/search:masterclass/sort:date -> sidefx masterclass are AAA https://www.rebelway.net/ -> for pyro / flip / rbd 3 - at anytime For online help : https://forums.odforce.net/ -> THE place to be https://www.sidefx.com/forum/ -> good info too For discord help : Houdini-and-chill -> best houdini artist around Think Procedural -> very good too with this you will be ready to go : 2 years in computer graphics + self training on houdini basics then 2 years in a Houdini TD focus training + self training with advanced tutorials on solvers. Good luck and whatever you do obstinacy and hard work will get you there. Cheers
  14. 2 points
    Here is an example file from Houdini FX Japan that nearly eliminates the mushrooming effect. MicroSolver_Sample.hip
  15. 2 points
  16. 2 points
    this we gonna use soon in Chops for Patterns on Skin (by for-each in Chops). PAttNatOdforce.hiplc
  17. 2 points
    Sorta dodging your question really, but I found you can cheat this by getting 3 samples ($F, $F-0.5, $F-1) and feeding them to a sequence blend shape with cubic interpolation enabled. interpolate_transforms_via_blendshape.hiplc
  18. 2 points
    There's no reliable way to slerp matrices as far as I know, typically people will convert the rotation to quaternion then slerp. You can then store the result as a matrix by converting from quaternion back to matrix. This example shows a lerp of the translates, scales and slerp of rotations with the result converted back to matrix.
  19. 2 points
    Not long ago I was tasked with a simulation of bags of hard candy falling and splitting open on the floor, with the candy of various shapes and sizes spilling out. This turned out to be way harder then I thought. There is really no built in way for vellum and bullet dynamics to interact with each other in Houdini. After searching the internet, I did find one tutorial on kind of faking the interaction, but it seemed overly complicated to me. So after a bit of R&D I came up with this setup. Its very simple and fast, and solves both the vellum and bullet sims in one network at the same time: It basically works by importing the RBD geo into the vellum collision solver, and the vellum geo into the bullet solver. The mass of the RBD has to be faked in somewhat, so it interacts with the cloth in a more realistic way, but that's it! See hip for example: vellum_x_bullet.hip
  20. 2 points
    // Detail wrangle. #define PI 3.1415926535897932384 vector a = point(0, "P", 0); vector b = point(0, "P", 1); vector c = point(0, "P", 2); vector ac = c - a; vector ab = b - a; vector ab_x_ac = cross(ab, ac); vector a_center = (cross(ab_x_ac, ab) * length2(ac) + cross(ac, ab_x_ac) * length2(ab)) / (2.0 * length2(ab_x_ac)); float radius = length(a_center); vector normal = normalize(ab_x_ac); vector center = a + a_center; // Test. vector x, y, z=normal; makebasis(x, y, z); matrix3 r = set(x, y, z); int count = 50; for (int i = 0; i < count; i++) { float angle = 2 * PI / count * i; vector pos = set(sin(angle), cos(angle), 0) * radius; addpoint(0, pos * r + center); } addpoint(0, center); Here is working stuff found there. Add degeneracy testing if you need it. circumcircle.hipnc
  21. 1 point
    No, you need sim all domain with res that your RAM allow you to sim, but each next sim with different seed, then combine and mesh.
  22. 1 point
    Most visual effects are a combination of multiple elements, you may want to use more than one approach. Fast moving in one direction and swirling are kind of opposite requests. You can just shoot particles in a direction and rasterize them into a fog volume. One approach to thick fog is to zero out Cooling Rate and Temperature Diffusion on the smoke solver. ap_atmospheric_dust_mist_102419.hiplc ap_running_through_thick_mist_102519.hiplc
  23. 1 point
    ahah i think i would mix both approach describe previously. - with only pop + gravity then vdb you will miss the swirly pattern of fluid - with a pyro sim + pop advect you will have hard time to get the simple direct gravity pattern - i will start with a pop sims ( maybe pop grain to check if it bring something more granular ) to create the main gravity behavior - then use that sim to emit vel + density in a whispy presets pyro grid - then advect some additional pop in it that pyro grid that will fade fast and render : - pop gravity + pop advected with high motion blur - and whsipy fluid with low density shader
  24. 1 point
    If you set physical parameters back to default values on /obj1/dopnet14/rbdpackedobject1 behavior of constraints is fine. Don't ask me why, I don't know, maybe a bug.
  25. 1 point
    I tried offsetting the prim center by a small amount along the face normal and it worked Thanx Yunus, for taking the time to help Cheers; AJ
  26. 1 point
    Have fun. Found tutorial from some French Dude... OdMott.hiplc
  27. 1 point
    The .sim files are generated by the AutoDopNetwork node. Set the timeline to Play Once, rewind and play the simulation. Click stop around 34 frames. Close Houdini. Reopen the file in Houdini and you should see a blue cache progress bar loaded with the file. Move to frame #34 and press play to continue simulating. You can see in my blue bar, here, that the previous "Checkpoint" cache is a slightly dimmer color. ap_flip_sim_continue.hiplc
  28. 1 point
    Hi, You can use the dihedral function: vector p0 = point ( 1, "P", 0 ); vector p1 = point ( 1, "P", 1 ); @orient = dihedral ( { 0, 1, 0 }, normalize ( p1 - p0 ) ); Position wise it's up to you if you want the tube to sit on point 0 or point 1, be centered to the line, or just rotate.
  29. 1 point
    Simplest difference is this: The @name attribute is a string attribute. (Eg. "foo_0, foo_1") The @class attribute is an integer attribute. (Eg. "0", "1") Both attribute are very similar to groups. You can easily select geometry based on attributes. In the "group" tab in most nodes you can type @name="foo_1", or @class="1". Storing groups as attributes rather than groups are actually more efficient. The name attribute is often used in rbd simulations and other simulations that use constraints. When packing geometry the @name attribute is used to determine how many packed pieces you'll end up with after packing. The @class attribute is pretty much just an attribute created when calculating how many separate 3d islands there are. Both the connectivity node(used to create @class attribute based on primitives) and the assemble node (used to create @names) create their attributes based on how the incoming geometry is connected. 3d islands etc. The @class attribute is often used to create names manually in vex. Eg. s@name = sprintf("foo%d", i@class"); Read more about @class in the documentation here. And read more about @name in the documentation here.
  30. 1 point
    Thank you for the reply. You're actually spot on. I've been focusing a lot on just copying what the person does but then I forget what I even did. I'll try your method. Thank you!!
  31. 1 point
    Usually I just unique the points and then scale each poly down to zero from its center point with Primitive Properties, followed by a Fuse. pointsFromPrims.hiplc
  32. 1 point
    Also, take a look at the sprite node: https://docs.redshift3d.com/display/RSDOCS/Sprite+Node It's meant for exactly this. You'll get better performance than jacking up the max trace depth and avoid some potential artifact-ing.
  33. 1 point
    Hi Tesan, Than you. Yes, it works fine: vector4 q1 = quaternion(@N); vector4 q2 = dihedral(v@N, v@targetVector); vector4 quat = slerp( q1, q2, chf("bias")); v@N = qrotate(quat, v@N);
  34. 1 point
    Hi Masoud, to blend orientations two orthogonal vectors are required for each point: one normal, one up. For this you could use the polyframe node or a cross() product. maketransform() converts these vectors into a matrix that is to be turned into a quaternion(). matrix3 xform = maketransform(v@up, v@N); vector4 orient = quaternion(xform); slerp(), spherical linear interpolation, then blends between both orientations: float blend = chf('blend'); vector4 orient_1 = point(0, 'orient', 1); vector4 orient_2 = point(0, 'orient', 2); p@orient = slerp(orient_1, orient_2, blend); blend_orientations.hiplc
  35. 1 point
    Procedural Modeling in Houdini In this tutorial you will learn the procedural modeling from fundamentals to advanced level. Video Presentation: What's Inside? 40 Video Chapters. 14 Hours of Lessons. Houdini 19 / 18.5 Project Files. Unreal Engine 4.26 Project Files. HDA Procedural Escalator. HDA Cable Generator. Tool Group Select. Format: Narrated, with audio commentary. Download: Gumroad: https://gumroad.com/l/ProceduralModeling ArtStation store: https://www.artstation.com/a/10610308 FREE Sample: https://gumroad.com/l/HBPRh In the first part we will start to create the escalator elements and gradually we will move to more advanced procedural modeling techniques. In this part you will also study: How to create vertex mask in Houdini for UE4 materials. How to add rig and export animated steps. How to add collision, and assign UE4 materials. In the second part you will study more advanced techniques of procedural modeling, tools development (1_Group Select, 2_ProceduralBox With Cables) and procedural uv creation. We will also create procedural uv for trim textures.
  36. 1 point
    To celebrate the yearly anniversary, I decided to share the Limit Surface Sampling chapter from the course (5 separate videos). AFAIK this topic has never been covered by other tutorials, so I hope it proves to be useful for your work! Enjoy! To generate interpolating surfaces for other subdivision schemes we need a method of determining the position and the normal at a set of points on the limit surface. Because the surface is the result of repeated application of a subdivision step, we can analyze the behavior of a small neighborhood of points as they converge to the limit surface in order to determine the surface properties at the point of convergence.
  37. 1 point
    With this work I tried to do a metalic monster with a inverse pipeline..the model exist from the rig, on this case a single line... that is completly procedural.
  38. 1 point
    If you are looking for something out of the box, you can try the "enable air incompressibility" option in the FLIP solver, as described here: https://www.sidefx.com/docs/houdini/fluid/bubbles.html Note that I had to turn on viscosity and surface tension to prevent the air bubbles from collapsing right after they are born.
  39. 1 point
    Many ways to do this. My take: Put a timeshift node after the file node and add foreach point with the copy to points node second input in the loop coming from the line (look at the picture of the graph). Click on the Create Meta Input Node. When it creates the node, rename it to something shorter, which you can find later, for example, "shift_iteration". Go to your timeshift node and add a new integer parameter in your parameter interface (in my case I called it shift). Edit the Frame parameter in the timeshift node - the default is $F, but you can add data which comes from for-loop by using detail function and taking the value of the attribute "itteration" on the Meta Input Node (in this example: "shift_iteration"). You can check the detail function in documentation, but it is very simple - detail("addres_to_the_node", "attribute_name", index). Multiply this value to the offset parameter by using ch() function and delete it from the current frame ($F). The full expression in your timeshift frame parameter will be: $F-detail("../shift_iteration", "iteration", 0)*ch("shift"). By changing the value of the shift parameter on the timeshift node you are making the animation to delay number of frames you define it. If you want them to start at random times, you can either use the sort node at the line, to change the ptnum attribute. Or you can use another expression on the new parameter, by putting shift_iteration into rand function. Good luck
  40. 1 point
    Many thanks @jrockstad. Fixed some minor issues to make it work for h18+. For convenience I also created a gist here. # Houdini Python shelf tool for comparing node networks # Prints changes in networks followed by changes in parameters # Original Author: @jrockstad # https://forums.odforce.net/topic/24410-compare-difference-between-two-networks/ # Usage: Select first network, shift-select second network, launch tool # ----------------------------------------------- # Network comparison functions # ----------------------------------------------- def get_node_names(networks): node_lists = () for network in networks: nodes = network.children() node_lists += (set([node.name() for node in nodes]),) return node_lists def print_added_or_removed_nodes(a_or_r): message = '' if a_or_r == 'added': nodes = list(network_b.difference(network_a)) message = "Nodes added to '{}': \n\n".format(net_b_name) else: nodes = list(network_a.difference(network_b)) message = "Nodes removed in '{}': \n\n".format(net_b_name) if nodes != []: nodes.sort() for node in nodes: message += " {}".format(node) return message def print_added_and_removed_nodes(): message = print_added_or_removed_nodes(a) + '\n' + \ print_added_or_removed_nodes(r) return message # ----------------------------------------------- # Parameter comparison functions # ----------------------------------------------- def get_parms(networks, shared_nodes): parm_dicts = () for network in networks: node_parms = {} nodes = network.children() for node in nodes: if node.name() in shared_nodes: parm_tuple = [(node.name(), node.parmTuples())] node_parms.update(parm_tuple) parm_dicts += (node_parms,) return parm_dicts def compare_parms(parm_dicts, shared_nodes): message = '' a_parms, b_parms = parm_dicts for node in shared_nodes: a_parm_vals = [] b_parm_vals = [] parm_labels = [] for parm_tuple in a_parms[node]: for parm in parm_tuple: a_parm_vals.append(parm.evalAsString()) parm_labels.append(parm.name()) for parm_tuple in b_parms[node]: for parm in parm_tuple: b_parm_vals.append(parm.evalAsString()) if a_parm_vals != b_parm_vals: message += "Changed parameters in node {}:".format(node) + '\n\n' for val in range(0, len(parm_labels) - 1): if a_parm_vals[val] != b_parm_vals[val]: message += " Value in '{}' for '{}': {}".format \ (net_a_name, parm_labels[val], a_parm_vals[val]) + \ '\n' + \ " Value in '{}' for '{}': {}".format \ (net_b_name, parm_labels[val], b_parm_vals[val]) + \ '\n\n' return message # ----------------------------------------------- # Init # ----------------------------------------------- networks = hou.selectedNodes() net_a_name = networks[0].name() net_b_name = networks[1].name() network_a, network_b = get_node_names(networks) nodes_added = network_b.issuperset(network_a) nodes_removed = network_a.issuperset(network_b) shared_nodes = list(network_a.intersection(network_b)) parm_dicts = get_parms(networks, shared_nodes) a = 'added' r = 'removed' if nodes_added: hou.ui.displayMessage(print_added_or_removed_nodes(a)) elif nodes_removed: hou.ui.displayMessage(print_added_or_removed_nodes(r)) else: hou.ui.displayMessage(print_added_and_removed_nodes()) hou.ui.displayMessage(compare_parms(parm_dicts, shared_nodes))
  41. 1 point
    Not sure if you got this working yet or not, but I am using the following and it works well for me. "python.autoComplete.extraPaths": [ "C:\\Program Files\\SideFX\\Houdini18.0.356\\houdini\\python2.7libs", "E:\\_unity\\_projects\\Python_Unity\\Library\\PackageCache\\com.unity.scripting.python@2.0.0-preview.6\\Python\\site-packages" ], "python.autoComplete.preloadModules": [ "hou", "unity_python" ], "terminal.integrated.env.windows": { "PYTHONPATH": "C:\\Program Files\\Side Effects Software\\Houdini18.0.356\\houdini\\python2.7libs;E:\\_unity\\_projects\\Python_Unity\\Library\\PackageCache\\com.unity.scripting.python@2.0.0-preview.6\\Python\\site-packages", "PATH": "${env:PATH};C:\\Program Files\\Side Effects Software\\Houdini18.0.356\\bin" }, "python.pythonPath": "C:\\Python27\\python.exe", "[python]": {}, "terminal.integrated.shell.windows": "C:\\WINDOWS\\System32\\wsl.exe",
  42. 1 point
    yes, to modify initial state properties of the cloth you can do it this way just make sure you set the Bend Stiffness on Vellum Constraint to Scale By Attribute and put your attribute name in there
  43. 1 point
    "Rumis Field" "Out beyond ideas of wrongdoing and rightdoing there is a field. I'll meet you there." Rumi One of my favourite quotes ever... And an organics version: Both created with a custom solver in Houdini 17.5 & rendered in Redshift for High-Rez printing at 18000x12000 (https://www.artstation.com/thomashelzle/prints). Cheers, Tom
  44. 1 point
    'unique points along seams' shouldn't be necessary. Try this file where I've added normals to the geo before it's cut, also having normals on the cutting geo can help. Finally only the inside faces get normals recalculated after it's shattered using the A inside B group. This preserves the smooth normals of the sphere's shell before it's shattered. BooleanSeamless.hipnc
  45. 1 point
    The merge node does work with Redshift but I believe you have to turn off Non-Blocking Current Frame Rendering on the Redshift ROP. There is a thread about this on the Redshift forum as well.
  46. 1 point
    Drop down a Merge node in the OUT network and connect the Mantra nodes in the order you want them to render in. Then click the Render flag on the Merge node to issue the batch render.
  47. 1 point
    Modified version of my script, now including parameter changes: # Houdini Python shelf tool for comparing node networks # Prints changes in networks followed by changes in parameters # Usage: Select first network, shift-select second network, launch tool # Network comparison functions def get_node_names(networks): node_lists = () for network in networks: nodes = network.children() node_lists += (set([node.name() for node in nodes]),) return node_lists def print_added_or_removed_nodes(a_or_r): if a_or_r == 'added': nodes = list(network_b.difference(network_a)) message = "Nodes added to '{}': \n\n".format(net_b_name) else: nodes = list(network_a.difference(network_) message = "Nodes removed in '{}': \n\n".format(net_b_name) if nodes != []: nodes.sort() for node in nodes: message += " " + node + '\n' return message def print_added_and_removed_nodes(): message = print_added_or_removed_nodes(a) + '\n' + \ print_added_or_removed_nodes(r) return message # Parameter comparison functions def get_parms(networks, shared_nodes): parm_dicts = () for network in networks: node_parms = {} nodes = network.children() for node in nodes: if node.name() in shared_nodes: parm_tuple = [(node.name(), node.parmTuples())] node_parms.update(parm_tuple) parm_dicts += (node_parms,) return parm_dicts def compare_parms(parm_dicts, shared_nodes): message = "" a_parms, b_parms = parm_dicts for node in shared_nodes: a_parm_vals = [] b_parm_vals = [] parm_labels = [] for parm_tuple in a_parms[node]: for parm in parm_tuple: a_parm_vals.append(parm.evalAsString()) parm_labels.append(parm.name()) for parm_tuple in b_parms[node]: for parm in parm_tuple: b_parm_vals.append(parm.evalAsString()) if a_parm_vals != b_parm_vals: message += "Changed parameters in node {}:".format(node) + '\n\n' for val in range(0, len(parm_labels) - 1): if a_parm_vals[val] != b_parm_vals[val]: message += " Value in '{}' for '{}': {}".format \ (net_a_name, parm_labels[val], a_parm_vals[val]) + \ '\n' + \ " Value in '{}' for '{}': {}".format \ (net_b_name, parm_labels[val], b_parm_vals[val]) + \ '\n\n' return message # Script start networks = hou.selectedNodes() net_a_name = networks[0].name() net_b_name = networks[1].name() network_a, network_b = get_node_names(networks) nodes_added = network_b.issuperset(network_a) nodes_removed = network_a.issuperset(network_ shared_nodes = list(network_a.intersection(network_) parm_dicts = get_parms(networks, shared_nodes) a = 'added' r = 'removed' if nodes_added: hou.ui.displayMessage(print_added_or_removed_nodes(a)) elif nodes_removed: hou.ui.displayMessage(print_added_or_removed_nodes(r)) else: hou.ui.displayMessage(print_added_and_removed_nodes()) hou.ui.displayMessage(compare_parms(parm_dicts, shared_nodes)) There's definitely a lot of room to polish it up, and in particular I would like to add: - Option for user to choose whether they want to see node changes, parameter changes, or both - Option to print output to file - More efficient / readable output, especially for parameters ...but for now, it does exactly what it says on the tin.
  48. 1 point
    SideFX agrees that writing long function names is time consuming. That's why they added aliases. From the Edit menu select "Aliases and Variables". The first tab, "Aliases" allows you to define an alternate name for hscript commands. So you could shorten "opinputpath" to "opi", and you could shorten "point" to "p". That would allow you to type p(opi(".",0),0,"P",0) You can also add your own pnt() expression that would run point(opinputpath(".", 0), $PT, "P", 0) The aliases and expressions are stored in hou.Session, a Python module that is saved with the HIP file. So there is no problem sharing the HIP file with other people. You can also store Python functions and classes in the current session. For example you could add hou.session.foobar() and use it in Python expressions for parameters. To edit the Python source code for the current session. Select "Windows" then "Python Source Editor" from the menu. In the popup Python editor make sure "hou.session module" is selected as the source file drop down option. All of this is saved in the current HIP file. Allowing you to quickly prototype, etc.. etc.. You can also save a HIP file in the Houdini folder (somewhere under some kind of name), and every time you start a new scene you can get a default set of session stuff preset.
  49. 1 point
    nm... of course the next suggestion is in the gear menu uncheck Prefix Linked Parameter Name with Source Node Name, and Prefix Linked Parameter Label with Source Node Label. This would have help loading parameters from subnets a very, very, very long time ago.... like why it shouldn't be a default if all it will do anyways is just append a number to it...
  50. 1 point
    Hi, in Houdini, similar to Maya as I thought, you can think about two or even three languages: 1. Languages: - Hscript (look for help in Texport via "help") - Expressions (look for help in Texport via "exhelp") - Python -(gosh, lets add the forth: VEX) 2. Differences in use: - Hscript executes commands (add operator, delete, rename, link) - expressions computes a value (compute angle, matrix etx) - (Python does both) - (VEX modifies variable's value like point position, surface colour, pixel value etc) 3. Backticks usage: - backticks allows you to place expressions in hscript... - or execute expression in a parameter that does NOT expect numeric value (like string parameter) for example, in file input path, you could write: op:/`opinputpath(".",0)` or: ./my_great_texture.`padzero($F-10)`.rat since this input file field expect string and it couldn't recognize padzero() as an expression in other way. But in case of translation parameter you need just an expression: fit01(rand($PT), 0.5, 1)) without backticks, since a parameter expects numeric value anyway. So: - using expressions inside hscript requires `` - you also need `` to evaluate an expression in non-numeric neighborhood, like strings, paths etc. - but you don't need it if expression is evaluated in numeric parameter. - you can also in opposite use hscript in expression with "run()" or "execute()" functions. - both expressions and hscript are accessible in Python with hou.hscript() or hou.hscriptExpression() (Unless they have pure equivalents in Python like opadd == hou.createNode() ). hope this helps, Simon. PS There are also expressions returning strings like points(), chs() and they need backticks also to be executed in parameters but not taken "as is".
×