Archived post by lwwwwwws

I found if you sop import packed disk VDBs it happily does the right thing and you get instances referencing the original .vdb files, no extra caching required… so if you’ve got packed (non-disk) VDBs as .bgeo you should be able to turn that into a packed disk equivalent: – unpack 1 prim with Apply Transform disabled to get the original VDB – save it as a .vdb, load it back in as a packed disk with a File SOP – use Pack Inject to turn the packed VDB setup into packed disk VDBs – change or delete the path attrib, because packed disks have the file path in there and LOPs will use it to create a transform hierarchy from your on-disk folder structure which is just insanely confusing the first time you see it lmao

Attachments in this post:
http://fx-td.com/houdiniandchill/wp-content/uploads/discord/20264106/10/26/Screenshot_2026-06-10_at_11.41.14.png

Archived post by blacknye

I’m reading through this now, I’ll share some of my insights/experiences too in a bit. We’ll struggle together haha.

> plug the skeleton into the autobilder – says that left side does not match the right but doesn’t tell me what exactly is different * For this particular warning, you can probably ignore it. I agree with you though, it would be really nice to have more details. This warning even pops up when testing the autorig builder on Electra and Otto.
* Since you’re using a mixamo skeleton. I’d make sure to clean up some of the transforms and naming. On the fbx import nodes, make sure to check ‘Normalize Joint Scales’ and ‘Remove Namespaces from Joint Names’. I’d also do a string replace for names containing ‘Left’ and ‘Right’ and replace them with` ‘L_’ and ‘R_’`. Remove the fbx attribs. It probably has a bunch of ‘end’ joints too, I’d blast those or tag them so you can easily hide them later when configuring controls
> takes a couple of seconds to enter the rigbuilder state and then even the state feels a bit sluggish (wasn’t apex supposed to be fast?) * There could be several causes for this, some apex, some viewport, vulkan, opengel, etc. Hi-poly geo, viewport lighting, scene antialias samples. Resetting the viewport can help too.
> dropping components feels nice and powerful but the worldspace controls are finnicky // ie can’t toggle on a click, have to drag, and you eventually drag away from the toggle and the controls close…. * For the ik/fk toggles, you should be able to just left-click on it instead of click+drag, click+drag brings up the on/off switch but that action isn’t needed when switching between ik/fk.
> names of those controls are also not helping * You can rename the controls using a the post process tab in the configure controls sop. If your controls have long names with the mixamo: namespaces, I’d recommend cleaning those up before you even get to the apex stuff.
> and some random things here and there – ie I drop the foot component and the hole rig collapses…. * I’d have to see the skel/hierarchy in your file, I haven’t experienced that behavior.

Just wanted to show the affect polycount still has on viewport performance. I think it’s important to be mindful of this and still use good practices. Also, I find opengl to have better performance over vulkan in this particular case.

@nikolad8022 I’m posting a video below and a scene file that might help you so you can see once you do the setup and cleanup on the mixamo skel before diving into apex, it’s pretty stable:

Attachments in this post:
http://fx-td.com/houdiniandchill/wp-content/uploads/discord/20265605/31/26/apex_polycount_opengl.mp4
http://fx-td.com/houdiniandchill/wp-content/uploads/discord/20265605/31/26/mixamo_prep_for_apex.mp4
http://fx-td.com/houdiniandchill/wp-content/uploads/discord/20265605/31/26/mixamo_prep_for_apex_v001.hiplc

Archived post by mysterypancake

added some info about a method i posted earlier to make a coordinate system along curves: github.com/MysteryPancake/Houdini-Fun/tree/main#coordinate-system-along-curves

Attachments in this post:
http://fx-td.com/houdiniandchill/wp-content/uploads/discord/20265405/31/26/curve_frame_planes.png
http://fx-td.com/houdiniandchill/wp-content/uploads/discord/20265405/31/26/noise_along_curve_volume.webp
http://fx-td.com/houdiniandchill/wp-content/uploads/discord/20265405/31/26/pig_along_curve.webp
http://fx-td.com/houdiniandchill/wp-content/uploads/discord/20265405/31/26/curve_unroll.webp

Archived post by mikael00794

Hehe yep. This is the painful part of working with the Sdf API. Sdf only works on individual layers, not the composed stage. Since you referenced in the .usd file to the /ROOT prim, technically the only defined primitive in the active layer is the /ROOT prim. The child primitives lives in the referenced usd file. So the steps to get the child prims is roughly: Get the /ROOT prim. Check the reference list for the primitive. Compute the absolute path to the reference usd file. Open the reference usd layer. Get the primitive from this layer instead. Something like this ish:
“`python from pxr import Sdf, Usd
node = hou.pwd()
layer = node.editableLayer() print(‘Editable Layer’, layer)
# This prim is defined on the active editable layer root_sdf_path = Sdf.Path(‘/ROOT’) root_prim = layer.GetPrimAtPath(root_sdf_path) print(‘Root Prim’, root_prim)
# Get reference list from prim on active layer root_prim_ref = root_prim.referenceList.GetAddedOrExplicitItems()[0] ref_layer_path = layer.ComputeAbsolutePath(root_prim_ref.assetPath) print(‘Reference Layer Path’, ref_layer_path) # Open reference ref_layer = Sdf.Layer.FindOrOpen(ref_layer_path)
# Get prim from reference usd. This will use the Sdf.Path from the reference usd layer ctrl_prim = ref_layer.GetPrimAtPath(‘/RIG_Main/carBody_CTRL’) print(‘ctrl_prim’, ctrl_prim) “` Fun times

Archived post by inside_the_mind

Can you not just use a transform2d into a blend with a mask?

If you need them in a grid you can use a stamp points and add an attribute that controls which pattern goes where

Use a layer properties to assign whatever size you want to the stamp points

For anyone interested I submitted and RFE and the initial response was basically what Alex said as far as making segment by connectivity resolution independent. The official response: “`I’m not sure how this could possibly work.
Currently, when ids are collapsed, they will have the segments sorted by their bottom-left-most pixel. This makes for a consistent result cook-to-cook, but cannot possibly remain the same when you change resolution. When you increase resolution you change the shape of islands, that may change the order of the bottom left pixel.
In this case, the green & pink squares swap because the small square is slightly higher than the big square. But at lower resolutions this is not captured and so they tie, so the small square is sorted first. But at 4k, the big square gets the first id as it now is generated a pixel lower than the small square.
Any scheme imaginable will have this sort of tie breaking problem. And this assumes that the change in resolution doesn’t discover new islands that were missing in the low resolution; or join islands that were falsely separated by incomplete lines that now are revealed to not be joined in the high res.
The only solution is to pick an ideal resolution that you determine will author the “official” ids, and copy those into the high resolution segments“` And so I clarified to having a solution that allows the user to create a resolution independent mask that is based upon ID’s. I tried to clarify that this type of workflow is often not reliant on ID numbers as the locations of the masks are unlikely to change and so being able to just select locations where the ID’s reside would be perfectly acceptable and more resolution independent(you can still run into issues if islands are merged at lower resolutions but not at others. But adding an additional location selector would resolve that issue.)

This was the response to that: “`From our developers: The UV Map By ID in “Center” mode will output the center of each of the islands. So one could: a) resample to a fixed canonical size, segment by connectivity and collapse IDs to get the “official” ids. b) UV Map by Id to get the center of each island, layer to points with unqiue values to get a point per island and set its location to the center c) do the segment by connectivity in the high res size, uv map by id to get centers. d) For each segment in c), find the closest segment in b) and copy b’s id number over.
This probably can be made into an asset to make this approachable and deployable. You can still have surprises if the higher resolution causes islands to leak together, however, but it would avoid the re-sorting problem.“`

I felt this was not a great solution and I had already had the idea and started working on a location based solution. What I ended up doing to was basically taking a bunch of positions parms in OCL, looping over them and sampling the ID at that position and then setting any ID that didnt match any of the ID’s that were sampled to -1 and the rest to 1 and then doing a ID to mask with the ID field set to 1 as any ID’s at the selected locations would just be 1. This makes it more resolution independent as the only issue that should arise is if islands are merged at one res and not at a higher res. Simply upresing while selecting positions should totally alleviate this issue

Anyway that’s my ted talk. If you want to not worry about any of that here’s the HDA I built that does all that and also takes an optional point input that allows for some more procedural stuff if you are clever with things

Attachments in this post:
http://fx-td.com/houdiniandchill/wp-content/uploads/discord/20264405/19/26/HouMats-ID_Sample_1.0F.hda

Archived post by flakypastries

yeah I am not sure this is possible either, since the texture is part of a shader evaluation but LPEs deal strictly with rays.

Depends on the Houdini version. In H21 we now have the RaySwitch VOP (finally!), so we can build a shader-based setup like this. If Efficient Emissive Sampling is on, Karma treats this like a light and contributes to direct rays.
Yes it’s hacky but it actually works fairly well. You could expose a bunch of subnet inputs to facilitate later editing on the stage. And also in 21 we can then supply a stencil map via RGS on the card to cut it out. What I have not confirmed is how well Karma does importance sampling with this method (MIS on textured lighting effects has been hit or miss with Karma in my experience)
But this at least gives easy separate controls over camera rays vs scene rays.

@Jonesy you were asking the other day about possible applications of the RaySwitch VOP

on the topc if LPEs, here is a list I have been maintaining of Karma LPEs as they crop up. These syntaxes have been tested in production but if anyone spots a problem please let me know. And if you know of other useful ones, I would love to know what they are. There are all kinds of things you can do.
gist.github.com/tcrowson/5d033817c63cf6cf27f3703e2df9462b

Attachments in this post:
http://fx-td.com/houdiniandchill/wp-content/uploads/discord/20265305/08/26/image.png

Archived post by janhebein

I added a library feature to my little colorpicker tool. You can save colors now, rename them, put them in folders. Its also drag and droppable to sort and organize them.
Maybe its helpful to someone. Since i am colorblind it helps me a lot to identify colors quickly without using a browser tool. Works also with hotkeys 🙂
github.com/janhebein/Iris-ColorPicker

Attachments in this post:
http://fx-td.com/houdiniandchill/wp-content/uploads/discord/20260105/06/26/explorer_K1Rj9nSDzR.mp4

Archived post by benandersen

I made some hair tools. I’m curious to see what the community thinks of them and whether they’d be worth trying to sell. It’s a project I’ve been working on, on and off, since 2017/2018 for christopher robin.
We had this problem where framestore had delivered a final groom without any guides and expected us to deform it, so I started building up these tools to avoid rebuilding the groom from scratch and hoping it matched. I found the default houdini guide deform tools a bit lacking.
These tools can select good representative guides and deform a dense groom, while doing a reasonable job of retaining the shape. It has some tools for post processing/resolving collisions and a husk procedural with the same capture/deformer logic.
If you have any time or inclination to try it out, this zip file has the hdas and a scene that demonstrates some workflows and examples.

Attachments in this post:
http://fx-td.com/houdiniandchill/wp-content/uploads/discord/20264105/04/26/iso.hair.1.12.apprentice.zip