Draft: The content on this page is complete, but it has not been reviewed yet.

Property Binders

Property Binders are C# Behaviors you can attach to a GameObject with a Visual Effect Component : these behaviors enable making connections between scene or gameplay values and Exposed Properties for this Visual Effect instance.

For instance : a Sphere Binder can automatically set the position and the radius of a Sphere Exposed Property with the values of a sphere collider that is linked in the scene.

Adding Property Binders

You can add Property Binders through a common MonoBehaviour called VFX Property Binder. This behavior enables the use of one or many Property Bindings. Each property binding is in charge of creating a relationship between an Exposed Property and a runtime or scene element.

Alternatively, you can add directly Property binders through the Add Component Menu. If a VFX Property Binder component is not present, it will be created.

Built-in Property Binders

Visual Effect Graph package comes with the following built-in property binders:

• Audio
  • Audio Spectrum to AttributeMap : Bakes the Audio Spectrum to an Attribute map and binds it to a Texture2D and uint Count properties
• GameObject:
  • Enabled : Binds the Enabled flag of a Game Object to a bool property
• Point Cache
  • Hierarchy to AttributeMap : Binds positions an target positions of a hierarchy of transforms to Texture2Ds AttributeMaps and uint Count
  • Multiple Position Binder: Binds positions of a list of transforms to a Texture2D AttributeMap and uint Count
• Input
  • Axis : Binds the float value of an Input Axis to a float property
  • Button : Binds the bool value of a button press state to a bool property
  • Key : Binds the bool value of a keyboard key press state to a bool property
  • Mouse : Binds the general values of a mouse (Position, Velocity, Clicks) to exposed properties
  • Touch : Binds a input values of a Touch Input (Position, Velocity) to exposed properties
• Utility
  • Light : Binds Light Properties (Color, Brightness, Radius) to exposed properties
  • Plane : Binds Plane Properties (Position, Normal) to exposed properties
  • Terrain : Binds Terrain Properties (Size, Height Map) to exposed properties
• Transform
  • Position: Binds game object position to vector exposed property
  • Position (previous): Binds previous game object position to vector exposed property
  • Transform: Binds game object transform to transform exposed property
  • Velocity: Binds game object velocity to vector exposed property
• Physics
  • Raycast: Performs a Physics Raycast and binds its result values (hasHit, Position, Normal) to exposed properties.
• Collider
  • Sphere: Binds properties of a Sphere Collider to a Sphere exposed property.
• UI
  • Dropdown: Binds the index of a Dropdown to a uint exposed property
  • Slider: Binds the value of a float slider to a uint exposed property
  • Toggle: Binds the bool value of a toggle to a bool exposed property.

Writing Property Binders

You can write property binders by adding new C# classes to your project, and extending the class UnityEngine.VFX.Utility.VFXBinderBase

Extending the VFXBinderBase class will require you to implement the following methods:

• bool IsValid(VisualEffect component) : a method that validates that the binding can be made. The VFX Property Binder component will only perform the UpdateBinding() if this method returns true. You need to implement all checks in this method in order to determine if the binding
• void UpdateBinding(VisualEffect component) : the method that applies the bindings if IsValid returns true.

Example Code

The following example presents a simple Property Binder that sets a float Property value to the distance between the current game object and another (target) Game Object.

using UnityEngine;
using UnityEngine.VFX;
using UnityEngine.VFX.Utility;

// The VFXBinder Attribute will populate this class into the property binding's add menu.
[VFXBinder("Transform/Distance")]
// The class need to extend VFXBinderBase
public class DistanceBinder : VFXBinderBase
{
    // VFXPropertyBinding attributes enables the use of a specific
    // property drawer that populates the VisualEffect properties of a
    // certain type.
    [VFXPropertyBinding("System.Single")]
    public ExposedProperty distanceProperty;

    public Transform target;

    // The IsValid method need to perform the checks and return if the binding
    // can be achieved.
    public override bool IsValid(VisualEffect component)
    {
        return target != null && component.HasFloat(distanceProperty);
    }

    // The UpdateBinding method is the place where you perform the binding,
    // by assuming that it is valid. This method will be called only if
    // IsValid returned true.
    public override void UpdateBinding(VisualEffect component)
    {
        component.SetFloat(distanceProperty, Vector3.Distance(transform.position, target.position));
    }
}```