Hi there,
a few more answers from my side. And sorry for the late reply, I am recharging batteries a bit and stayed away from my machine for a bit.
Yes the state manages indeed quite a large number of graphs and a lot of these graphs get created or modified on the fly. That keeps our viewer state flexible fast and light weight. Managing the actual execution via graphs is a big advantage for performance. When it comes to modifying the graphs we execute then its a bit different because we are not running that on every mouse drag on playback, so we have a bit more wiggle room. So you can modify all of those graphs either via python or via other graphs. both ways are legit. Some sections in the viewport are currently managed with python as has been correctly observed.
One of theses graphs that constantly changes depending on what you do in the state is the scheduler graph. That one manages which bits of graphs/rigs are evaluated when. It is in a way the control centre of your interactive state. That scheduler gets especially important as soon as you have dependencies between rigs, e.g. by using constraints. The order of invocations and the updating of the data is all being managed here.
The controls are indeed nothing but graphs that define how the ui event is interpreted and translated to parameters that the rig understands. And every time you interact with a control that control graph is in fact dynamically added to the execution in you scheduler. So first the control graph is being evaluates and updates your current rig input parms and then the rig is being run with the updated parms.
The abstract control and the transform control are currently hard coded in in terms of the management around them. The actual core of them is still just a graph though. The state might be more opened up in the future. Ideally we would support that without the user needing to change the state code. This is what i meant with the fact that we have it on our radar
Coming more to the abstract control and node properties. Properties are nothing but custom metadata stored as a dictionary per node. You can store anything you want there. When the state creates controls then some metadate can be read from the node properties that can help define how that control looks. Configure controls is in the end just updating that dictionary per control node. The configure control node definitely needs the helper card, ill keep you posted once its added early January, when I am back.
Here is a quick description of what you can use to change how your control looks like. A bit rough, but it should give you an idea 😊:
properties: - dict
control: - dict
shapeoverride: str, - defines the shape name you want to assign to you control. the transform control has some default you can choose from. you see them in the dropdown of the configure controls node, you can also provide your own to a character if you pack them up using the second input of the configure controls node.
color: - vector3, matrix, defines the color of your control as a normalized rgb vector
shapeoffset: - matrix4, defines an offset of the shape that allows you to adjust the transformation of the control to fit more to your character
more specific for the abstract control
properties:
control:
parms:
lock_range: - int: 0 or 1: defines if you want to lock the min and max range of you control or if you want to go above it
x_max: defines the max value for the horizontal drag, if lock range is to you can not set a value higher than that. Otherwise it will be used as an orientation for the range when you drag on the given control in the viewport
x_min: defines the min value for the horizontal drag
y_max: defniens the max value for the vertical drag
y_min: defines the min value that can be set using the vertical drag, aka the y value to connected it to in the abstract control node in the rig