Plugins + Scripts SceneDirector

Drivers​

The main new feature of this update is the addition of Drivers, which let you drive any(*) of the component properties by mathematical expressions. Some ideas/examples for use of drivers are shown at the bottom of this update.

Drivers for atom properties are defined on the Components-Drivers tab. For now the expression system supports only scalar values, so drivers are available only for boolean (toggle), int/float (slider) and string properties. Support for colors, vectors (positions) and rotations will be added later.

For more information, check the Variables, Expressions and Drivers documentation (hopefully I will update it before this gets approved and published! )

Atom-scoped Variables​

Closely related to drivers, in addition to the previously existing global variables defined on the main Variables tab, each atom now also has its own Components-Variables tab. The UI is the same, the variables and expressions defined here are visible only for that atom's expressions. It's useful mostly for organizing the variables, removing the global clutter. In the future expressions will be able to reference variables from other atoms too, but now you are limited to:

• Global expressions can reference only other global variables/expressions.
• Atom-scoped expressions can reference either variables/expressions defined at the same atom's scope, or global variables/expressions.

Live Editing​

When a sub-state is applied, and therefore now transitions/sub-state animations are running, editing properties of that sub-state in the plugin's UI will apply them to the scene directly. Just like editing atoms directly in VAM's native UI would work.

Other Changes​

• UIObject component can control the state of slider and toggle values,
• Various tweaks and fixes

Driver Examples​

Example 1 - Blinking Light​

A light source with intensity updated by a driver. In this example it will be blinking at user-controllable amplitude and frequency, using a simple sine-wave shape for the intensity.

Step 1:
Define user-controlled variables. The source being set to Public Value means that the plugin will create a triggerable param for each of them. The sliders have a trigger defined on them, setting the individual values (not shown in the picture)

Step 2:
Define an expression variable at the LightHeart atom. This expression will update the angle to a value between 0 and 360 degrees. Sine of the angle will then later make the intensity blink. This is a bit more complex expressions, showing several features of the expression system:

1. Expressions can reference themselves. The plugin ensures that each variable will be evaluated at most once each frame. This means that we can use the frame's duration and the current variable's value to compute the next frame's value, which results a smooth transition/animation.
2. Expressions support conditional if-statements. In this example:
   • If the user-defined frequency is zero, the angle will smoothly transition towards the zero value. That will effectively stop the blinking, but not stop it at whatever angle it was when the frequency got set to zero, instead if will smoothly return to the neutral intensity.
   • Otherwise advance the angle by the frame's duration multiplied by the frequency, looping at 360 degrees ; the magical 6 multiplication factor is just 360/60, so the angle will advance by 360 per second when the frequency is 60 (and yes that's not Hz, that's beats per minute, I mistyped the slider's label)

Step 3:
Last step defines the actual Driver for the Intensity property of the Light atom. The complex math was all in the angle which drivers the flashing, this just applies the sine-wave multiplied by the amplitude, with the neutral intensity added. Rather simple.

And the video blow shows the result:

Spoiler: Video: User-controller blinking light

Example 2 - Morphs Controlled by Morphs​

This simple example controls the tongue length morph as 10-times the belly bulge 4 morph, which comes from the BodyLanguage plugin.
Realistically you would probably use the penetration depth to control something like this, and use a more complex morph setup. Probably with some kind of smoothing/delay (delay is quite tricky to implement exactly, but slow smoothing would do a similar trick).

Step 1:
Add a variable tracking the bulge's morph value. Remember that the morph must be marked as a "favorite" for it to show in VaM's geometry storable.

Step 2:
Set up drivers for any of the morphs controlled by SceneDirector on the atom. Naturally, you must first set up controlled morphs on the Morphs tab, not shown here. In the scene where I tested this, I already had a group of Face morphs configured, so I just chose the tongue length morph for this example.

And this is the result:

Spoiler: Video: Jackycracky's Tifa being spoiled by a dildo

New Variable Source - Param​

This allows you to track any public storable param of anything in the scene as a variable.
While usage of variables and expressions is still limited mostly to text formatting, you can already use this feature to show any boolean, floating-point or string param value in the scene on UI objects.

Other Changes​

• Support for SexyFluids v10.f4
  • Automatically create a component for each fluid emitter, including custom emitters.
  • Adding/renaming/removing emitters in SexyFluids will automatically refresh that atom's components in SceneDirector.
  • As a side-effect, SceneDirector will no longer take so long to initialize when controlling an atom with SexyFluids attached (it used to wait to see if it might be a female with alt-futa plugin before initializing the fluid components, now it can refresh whenever it needs to).
• Capturing SexyFluids state will now set the preset to none ("no change"), rather than the currently selected fluid preset.