Getting started

Install

Add Udonite Binding from the listing. It brings Udonite and Observables with it.

Then, in a script:

using Udonite.Binding;

Hear a control

Three lines: a field to hold the binding, a Watch to start it, a Poll to keep it going.

public class Lights : UdoniteBehaviour
{
    public Toggle box;
    public GameObject lamp;

    private ToggleBinding switched = new ToggleBinding();

    public override void Start()
    {
        switched.Watch(box);
        switched.OnChanged += Flip;
    }

    public override void Update()
    {
        switched.Poll();
    }

    private void Flip(bool on)
    {
        lamp.SetActive(on);
    }
}

The binding is a field, not a local. It holds the handler, so it has to outlive the method that made it. A local goes out of scope and the control quietly stops working.

Poll() belongs in Update. It is one comparison a frame. Leave it out for a control the player cannot touch, and nothing will be reported.

Show a value

The other half needs no polling. Give a binding an Observable and it writes the control whenever the value changes:

private Observable<int> score = new Observable<int>();

private TextBinding<int> scoreText = new TextBinding<int>();

public override void Start()
{
    scoreText.Bind(label, score, "Score: ", "");
}

public void Goal()
{
    score.Value = score.Value + 1;      // the label updates itself
}

The label shows the value at bind time, not at the next change, so a scoreboard does not sit blank until somebody scores.

Both at once

Bind on a watched control does both: the player moves it and the value follows, code changes the value and the control follows.

private Observable<float> volume = new Observable<float>(0.5f);

private SliderBinding slider = new SliderBinding();

public override void Start()
{
    slider.Bind(volumeSlider, volume);
}

public override void Update()
{
    slider.Poll();
}

They do not chase each other. An observable only notifies when its value actually differs, so the write the binding makes in response to its own poll changes nothing and stops there.

Only the player's changes raise OnChanged. Moving the control by assigning the observable does not, because the code that assigned it already knows.

A handler on another behaviour

A handler does not have to live where the binding does:

public Scoreboard display;

volume.OnChanged += display.Show;

That reaches the other behaviour's Show when the player moves the control. It needs no inspector wiring either, and the method name is one the compiler checks.

Common mistakes

A local instead of a field. The commonest one. Watch returns nothing and the control simply never reports.

Forgetting Poll(). The bind half still works — the control follows the value — so it looks half-broken rather than unwired.

Binding in a Start that runs twice. Harmless: binding again replaces the previous binding rather than adding to it, so you get one, not two.

Expecting a button. There is no ButtonBinding, and there cannot be one. See the reference for why.