User:Yosh/sandbox: Difference between revisions

From Resonite Wiki
e
asdasd
Line 51: Line 51:


=== Reading Dynvars ===
=== Reading Dynvars ===
Dynamic variables can be read from like any other field without issue. In ProtoFlux, the [[ProtoFlux:Read Dynamic Variable|Read Dynamic Variable]] node exists as a way to dynamically change what variable should be read by virtue of a slot and a variable name. Additionally, if the slot and variable name are meant to be constant, the [[ProtoFlux:Dynamic Variable Input|Dynamic Variable Input]] node can be used to efficiently and compactly read from a dynamic variable.
In ProtoFlux, the [[ProtoFlux:Read Dynamic Variable|Read Dynamic Variable]] node and [[ProtoFlux:Dynamic Variable Input|Dynamic Variable Input]] nodes exist to read dynamic variables from a slot. The former node is marked as [[ContinuouslyChanging]], which is a performance downgrade if <code>Source</code> and <code>Path</code> are constant. As such, if the dynamic variable and the space it is under are constant, the Dynamic Variable Input node is preferred. The slot that it pulls its space pool from is the node's current slot, and it only updates its value when needed, saving performance.
 
It is also possible to read dynamic variables by sourcing the <code>Value</code> or <code>Reference</code> field of the component directly. This is not recommended, as if the dynamic variable ever gets deleted and remade, the source will break, removing half the functionality of a dynamic variable.


=== Driving from Dynvars ===
=== Driving from Dynvars ===
Line 57: Line 59:


=== Writing to Dynvars ===
=== Writing to Dynvars ===
Dynamic variables should be written to via the [[ProtoFlux:Write Dynamic Variable|Write Dynamic Variable]] or [[ProtoFlux:Write Or Create Dynamic Variable]] ProtoFlux nodes.
Dynamic variables should be written to via the [[ProtoFlux:Write Dynamic Variable|Write Dynamic Variable]] or [[ProtoFlux:Write Or Create Dynamic Variable|Write Or Create Dynamic Variable]] ProtoFlux nodes.
 
If dynamic variables are written to via sourcing the component field and writing, it will incur a delay of 1 frame before the value is propagated to any read nodes. As such, it is not recommended to use this approach.


=== Driving Dynvars ===
=== Driving Dynvars ===
Driving dynamic variables must be done with caution. For one, one must drive the value field of the dynamic variable, which can incur a delay of the value when reading it back. Additionally, if a dynamic variable is being driven, it is <em>crucial</em> that <em>all</em> instances of the same dynamic variable are driven by the same value. Otherwise, clients will fight over which value is the "true" value of the dynamic variable and cause inconsistent behavior.
Driving dynamic variables must be done with caution. For one, one must drive the value field of the dynamic variable component, which incurs a delay of the value when reading it back via ProtoFlux due to drives acting as a local write every frame. Additionally, if a dynamic variable is being driven, it is <em>crucial</em> that <em>all</em> instances of the same dynamic variable are driven by the same value. Otherwise, clients will fight over which value is the "true" value of the dynamic variable and cause inconsistent behavior.


== Best Practices ==
== Best Practices ==
Line 67: Line 71:
* It is highly recommended to have only one instance of a dynamic variable (dynamic variable component with the same name) at any given time.
* It is highly recommended to have only one instance of a dynamic variable (dynamic variable component with the same name) at any given time.
** There aren't any huge problems with having multiple dynamic variable instances if none or all of the instances are being driven, but it allows for cleaner organization of variables.
** There aren't any huge problems with having multiple dynamic variable instances if none or all of the instances are being driven, but it allows for cleaner organization of variables.
* Do <em>not</em> write to the value of the dynamic variable by sourcing the field and using a [[ProtoFlux:Write|Write]] node. Always use the ProtoFlux nodes for writing to a dynamic variable.
** Otherwise, you will need to wait 2+ updates before the variable actually propagates the new value when reading the dynamic variable back.
** Reading can be done in any fashion and will update instantly upon the variable being written to.
* Using variable names that directly bind allows for a clearer overview of what space the variables should be bound to. Indirectly binding variable names are more suited for variables that are dynamically created and/or destroyed as part of an object's function.
* Using variable names that directly bind allows for a clearer overview of what space the variables should be bound to. Indirectly binding variable names are more suited for variables that are dynamically created and/or destroyed as part of an object's function.
** Using <code>OnlyDirectBinding</code> on a DynamicVariableSpace strictly enforces this behavior, which can prevent misbindings and catch errors earlier.
** Using <code>OnlyDirectBinding</code> on a DynamicVariableSpace strictly enforces this behavior, which can prevent misbindings and catch errors earlier.
* DynamicVariableSpaces are not nested. If a system is complex enough, or if a DynamicVariableSpace is being shared by multiple objects, using periods (<code>.</code>) to pseudo-isolate objects or systems from one another is encouraged.
* Dynamic variable spaces are not nested. If a system is complex enough, or if a DynamicVariableSpace is being shared by multiple objects, using periods (<code>.</code>) to pseudo-isolate objects or systems from one another is encouraged.


== Default Spaces ==
== Default Spaces ==

Revision as of 17:41, 12 August 2024

Dynamic variables, commonly shorted to dyn vars or dynvars, is a system of data storage wherein one can store arbitrary, scoped data under slot hierarchies with arbitrary names, akin to that of an associative array. Their usage is usually found in large systems with many moving parts, but can nonetheless be useful as easy "global" values that can be changed on an object.

For a quick-start guide on using dynamic variables, the How To Use Dynamic Variables page serves to be a how-to.

Overview

Dynamic variables are managed with two parts: dynamic variable spaces and dynamic variables. Dynamic variables live under a dynamic variable space, and can be created, modified, and destroyed dynamically.

Variable Spaces

By adding a DynamicVariableSpace to a slot, the slot and all of its children become a part of the named variable space. A slot can be part of multiple spaces at once. Spaces are not nested, meaning it is advised to make unique names for variable spaces.

Dynamic Variables

To create a dynamic variable, attach any one of the following components to a slot:

Dynamic variables have a name and a value. A variable's name is its unique identifier within the variable space, while its value is the value of the dynamic variable. This is touched on later in #Binding.

Dynamic Fields

It is possible to "transform" an existing IField on a component into a dynamic variable. This is done by any one of the following components:

Upon attaching the component and dragging the field you want to convert into TargetField, the pointed field can then be interfaced with like any other dynamic variable.

Naming Restrictions

The names of dynamic variables and dynamic variable spaces must not contain symbols, punctuation, or whitespace, except for period (.), underscore (_), and space ( ). To check if a character is unable to be used in a dynamic variable name, one can use the Is Symbol, Is Punctuation, and Is White Space ProtoFlux nodes, taking care of the three exceptions above.

Binding

The process of a dynamic variable being associated with a given space is called binding. A dynamic variable component will traverse up the slot heirarchy, including its current slot, looking for an applicable variable space to bind to. If a dynamic variable does not find a dynamic variable space that it can bind to, it will not be accessible outside of the component itself, essentially reducing to a glorified ValueField. A dynamic variable will go through this binding process every time any part of the component changes.

Direct Vs Indirect Binding

When making a dynamic variable, the VariableName of a dynamic variable component can be one of the following two forms: VariableName or VariableSpaceName/VariableName. The former represents indirect binding, while the latter represents direct binding.

If a dynamic variable is indirectly binding, it will bind to the first dynamic variable space that does not have OnlyDirectBinding set to True. If a dynamic variable is directly binding, it will bind to the first dynamic variable space that matches VariableSpaceName.

For example, in the following setup:

└─ Foo - Variable Space "test"
   └─ Bar - Variable Space "test2"
      └─ Baz - Dynamic Variable "test/var"

The dynamic variable test/var will bind to the variable space test. If the variable was instead named var, it will bind to the variable space test2.

Warning

As of the time of writing, there exist a few instances where created variables do not instantly bind/rebind to a dynamic variable space, requiring a Delay Updates of 2+ updates. These include creating new dynamic reference variables, deleting dynamic variables, changing the name of a dynamic variable or dynamic variable space, and any instance where there is a dynamic variable space change without a component update, such as duplicating slots containing a dynamic variable space or reparenting a slot containing a dynamic variable under a new dynamic variable space. If you find your dynamic variables to be behaving weirdly, try adding a delay of 2 or more updates between such operations.

Interfacing

Reading Dynvars

In ProtoFlux, the Read Dynamic Variable node and Dynamic Variable Input nodes exist to read dynamic variables from a slot. The former node is marked as ContinuouslyChanging, which is a performance downgrade if Source and Path are constant. As such, if the dynamic variable and the space it is under are constant, the Dynamic Variable Input node is preferred. The slot that it pulls its space pool from is the node's current slot, and it only updates its value when needed, saving performance.

It is also possible to read dynamic variables by sourcing the Value or Reference field of the component directly. This is not recommended, as if the dynamic variable ever gets deleted and remade, the source will break, removing half the functionality of a dynamic variable.

Driving from Dynvars

By using a DynamicValueVariableDriver or DynamicReferenceVariableDriver component, you can drive fields using a dynamic variable. This is recommended over traditional methods of driving by virtue of its flexibility and compactness.

Writing to Dynvars

Dynamic variables should be written to via the Write Dynamic Variable or Write Or Create Dynamic Variable ProtoFlux nodes.

If dynamic variables are written to via sourcing the component field and writing, it will incur a delay of 1 frame before the value is propagated to any read nodes. As such, it is not recommended to use this approach.

Driving Dynvars

Driving dynamic variables must be done with caution. For one, one must drive the value field of the dynamic variable component, which incurs a delay of the value when reading it back via ProtoFlux due to drives acting as a local write every frame. Additionally, if a dynamic variable is being driven, it is crucial that all instances of the same dynamic variable are driven by the same value. Otherwise, clients will fight over which value is the "true" value of the dynamic variable and cause inconsistent behavior.

Best Practices

Even though dynamic variables allow for a wide array of freedom, there are a few practices generally considered to be favorable when working with dynamic variables:

  • It is highly recommended to have only one instance of a dynamic variable (dynamic variable component with the same name) at any given time.
    • There aren't any huge problems with having multiple dynamic variable instances if none or all of the instances are being driven, but it allows for cleaner organization of variables.
  • Using variable names that directly bind allows for a clearer overview of what space the variables should be bound to. Indirectly binding variable names are more suited for variables that are dynamically created and/or destroyed as part of an object's function.
    • Using OnlyDirectBinding on a DynamicVariableSpace strictly enforces this behavior, which can prevent misbindings and catch errors earlier.
  • Dynamic variable spaces are not nested. If a system is complex enough, or if a DynamicVariableSpace is being shared by multiple objects, using periods (.) to pseudo-isolate objects or systems from one another is encouraged.

Default Spaces

As of the time of writing, there are three dynamic spaces that exist by default:

  • World, which exists under the Root of the world. This space is OnlyDirectBinding.
    • Useful for things that should globally affect the world or broadcast information throughout the world. Example items that use this space include BeatLink and the Redprint manager.
  • User, which exists under every User's User Root Slot. This space is OnlyDirectBinding.
    • Useful for systems that affect avatars, as they can rely on a standardized space being available for each user to read and write variables on.
  • Dash, which exists under the slot containing the UserspaceRadiantDash in userspace.

Example Usage