> For the complete documentation index, see [llms.txt](https://postica.gitbook.io/binding-system-3/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://postica.gitbook.io/binding-system-3/tutorials/samples.md). # Demo Scenes Playable scenes and code you can copy. The package ships samples in two ways. Three scenes live in the package folder itself, so they need no import and can be opened straight from the Project window under `Packages ▸ Binding System ▸ Samples`. The scripts beside them, in `Samples/Scripts`, are always present too.

Scene	What it shows
`Samples/SimpleDemo/BindDemoSimple`	Simple Demo. Sliders, a door, a spawner and a palette asset. The shortest path from "what is a binding" to a scene that does something.
`Samples/CozyNookDemo/CozyNookDemo`	Cozy Nook. Small, and built to be read with the Scene Visualizer on.
`Samples/CourtyardDemo/CourtyardDemo`	Courtyard. A dusk courtyard, seventy odd objects, the whole thing driven from one Time Of Day variable and a slider.

The rest are package samples, so they land in `Assets` only when you ask for them. **Package Manager ▸ Binding System ▸ Samples ▸ Import**

The Samples section of the Package Manager

Sample	What it shows
Bindings Demo	A playable scene built almost entirely out of bindings, with a Built-in and a URP variant.
Additional Converters	Two heavily commented converters.
Additional Modifiers	Six modifiers covering the shapes you are likely to need.

## Simple Demo `Samples/SimpleDemo/BindDemoSimple.unity` The smallest scene that is still a scene. A canvas of sliders drives a spawner, a door and a platform, and a `Palette` ScriptableObject drives the colour of everything on screen. There is no code holding it together. `Spawner` has one `Spawn()` method and `Palette` is a plain asset with four colours and five gradients on it; everything between them is a [proxy binding](/binding-system-3/overview/proxy-bindings.md).

This	follows	Worth noticing
The spawned cube's mass	the SpawnPointMassSlider value	A uGUI control as a source
The spawner's position	the SpawnPointSlider value	The same, through a converter that makes a number into a `Vector3`
The cube's material colour	its own Rigidbody mass	An object binding to itself. The heavier it is, the darker it goes
The first door's opening	the ControlDoor slider	A field on a plain `MonoBehaviour` at the receiving end
The second door's opening	the PlatformSlider lever in the scene	No UI at all. The source is a physical object
The second door's lock	the platform's childCount	A member nobody wrote for this, converted to a `bool`. Put something on the platform and the door unlocks
The button's highlighted, pressed, selected and disabled colours	its own normal colour	One colour to set, four that follow it, each through its own colour modifier
Every readout label	the value it reports	The slider, the cube's mass, the spawner's height, the door's state
Every label colour, material colour, button colour and particle gradient	the `Palette` asset	A `ScriptableObject` as a source. Nothing in the scene owns the theme

Change one colour on the `Palette` asset and the whole scene restyles itself, in the Scene view, with nothing playing. That is the point of the scene: a binding's source does not have to be a component, and an asset is a perfectly good one. ## Cozy Nook `Samples/CozyNookDemo/CozyNookDemo.unity` A garden nook: a table by a window, a sunflower, a pinwheel, a wind chime, a sundial, a reading lamp and a pitcher of water. Fifteen bindings, and not one line of code. It is the smallest scene that draws one of every arrow the [Scene Visualizer](/binding-system-3/project-tools/diagnostics/scene-visualizer.md) knows how to draw, which is what it is for.

The Cozy Nook scene with the Scene Visualizer on

Everything updates at edit time, so the nook responds in the Scene view without entering play mode. There is nothing to press play for. ### How it is wired Three [bind variables](/binding-system-3/overview/bind-variables.md) hold the state of the scene, and almost everything reads one of them.

Variable	What it means	What follows it
Time of Day	The hour, from 0 to 24	The Sun's rotation, and the night ambience volume through an Evaluate Curve
Sunlight	How strong the sun is	The Sunlight intensity, the readout text, and the meter's fill amount through a Remap Range
Breeze	How much wind there is, from 0 to 1	The pinwheel Blades and the chime Tubes rotations, the WindZone main strength, and the falling leaves' gravity and emission rate

The other five bindings are the shapes a variable cannot show you.

This	follows	Why it is here
The sunflower Head's rotation	the Sun's rotation	One object reading another directly, which is the plain case
The lamp Bulb's intensity	the Dimmer slider's value	A uGUI control as a source, through a Math Expression
The lamp Shade's emission colour	the Dimmer slider's value	A fan: two bindings from the same source, and a material property at the other end
The WaterLevel's scale	`UnityEngine.Time.time`	A static source: no object at all
The WaterOnTable's scale	the WaterLevel's scale	Second link in the chain, not a second copy of the first

### Things to try 1. Turn on the [Scene Visualizer](/binding-system-3/project-tools/diagnostics/scene-visualizer.md) and look at the shape of it: three fans where the variables sit, a chain from the water level to the water on the table, and a fan where two bindings share the same slider. 2. Open **Window ▸ Binding System ▸ Bind Variables** and drag **Breeze**. The pinwheel, the chime, the wind zone and the falling leaves all move with it, in the Scene view, stopped. 3. Drag **Time of Day** and watch the sun swing while the ambience volume follows its own curve. 4. Select the **Shade** and look at its binding. It drives `_EmissionColor` on a material, which is a member no component declares. 5. Select the **WaterLevel** and look at its source. It is a type rather than an object. 6. Set the visualizer's **Scope** to **Selection** and click through the objects one at a time. It is the fastest way to read one object's wiring. 7. Right click the **Bulb**'s Light intensity field and choose **Disable Binding**. The lamp stops following the dimmer. Undo. ## Courtyard `Samples/CourtyardDemo/CourtyardDemo.unity` A dusk courtyard, seventy odd objects, driven from one **Time Of Day** [variable](/binding-system-3/overview/bind-variables.md) and a slider: sun angle and colour temperature, lamp intensity, the ambience volume, and nineteen lit windows whose emission colour is read out of a **Windows Light Color** gradient. It is the scene to open when you want to see what a variable is worth. One number moves, and twenty nine bindings answer. ## Bindings Demo A playable scene built almost entirely out of bindings, with a Built-in and a URP variant. Physics, input, UI and audio are wired together without a controller class in sight.

### What to look at

Script	What it shows
`PhysicsBall`	A component whose entire configuration is `ReadOnlyBind<T>` fields, including its physics material and enum settings. Also shows `[Bind]` with `[Range]` below it, so the range applies to the inner value.
`CollisionMousePointer`	Input as bindings: mouse position, button state, camera and layer mask all come in bound rather than being fetched.
`PhysicsPlayerController`	A controller that reads its inputs through bindings, so the same component works with mouse, keyboard or a UI.
`GameManager`, `TriggersManager`	How game state fans out to many listeners without either side naming the other.
`PhysicsImpact`, `PhysicsProp`	Small components whose reactions are configured rather than coded.

The scripts are commented with the reasoning, not just the mechanics. They are the clearest available answer to "how would I actually structure this?" ### Things to try in the scene 1. Open a component and turn a binding off. Type a value by hand. The scene keeps working: bindings are opt in, per instance. 2. Turn on [Live Debug](/binding-system-3/project-tools/diagnostics/live-debug.md) on a physics parameter and play. Watch the pipeline. 3. Open the [Dependency Graph](/binding-system-3/project-tools/diagnostics/dependency-graph.md) with the scene loaded. This is a scene worth seeing as a graph. 4. Open the [Bindings Monitor](/binding-system-3/project-tools/diagnostics/bindings-monitor.md) in play mode and sort by cost. ## Additional Converters Two small, heavily commented [converters](/binding-system-3/reference/extending/converters.md):

Sample	What it shows
`EnumToIntConverter`	The untyped-enum case, which is the interesting one.
`HexColorConverter`	An unsafe conversion done properly, with a fallback.

## Additional Modifiers Six [modifiers](/binding-system-3/reference/extending/modifiers.md) covering the shapes you are likely to need:

Sample	What it shows
`RoundFloatModifier`, `CeilFloatModifier`, `FloorFloatModifier`	The minimum a modifier can be.
`StringPaddingModifier`	Bindable parameters, an enum option, and a real `ShortDataDescription`.
`TrimModifier`	A string modifier with an inverse.
`SampleLogModifier`	A modifier that observes rather than transforms.

## The scripts that ship with the package `Samples/Scripts` is not a package sample: it is part of the package, it always compiles, and it needs no import. It is worth reading for the same reason the demo scripts are.

Script	What it shows
`PIDController`, `Vector3PIDController`	A PID controller written as a modifier, for a float and for a vector.
`Modifiers/PropagateModifier`, `Modifiers/PropagateBoolModifier`	Fanning one value out to many bindings from inside a modifier.
`Common/BindBehaviour`, `Common/BindComponent`	The base classes the demo components are built on.
`Common/PhysicsDoor`, `Common/PhysicsLever`, `Common/PhysicsSlider`	Small, bindable mechanisms. These are what the Simple Demo drives.
`Common/WASDInputProvider`	Input exposed as bindable members rather than polled.
`TextFormatter`, `EaseFunction`, `HitAbsorber`, `RandomDestination`	Odds and ends the demo scenes bind to.

## A five-minute tour If you only have a few minutes and want to understand the point of the package: 1. Open `Samples/SimpleDemo/BindDemoSimple` and change a colour on its `Palette` asset. Nothing is playing, and the scene restyles. 2. Open `Samples/CozyNookDemo/CozyNookDemo` with the [Scene Visualizer](/binding-system-3/project-tools/diagnostics/scene-visualizer.md) on and drag the **Breeze** variable. 3. Import **Bindings Demo**, open the scene, and select a ball prefab. Look at how much of it is bound rather than assigned. 4. Find a component with no `Bind` fields at all, right click one of its fields, choose **Enable Binding** and click the hexagon toggle. That is [proxy binding](/binding-system-3/overview/proxy-bindings.md). 5. Play the scene with the [Bindings Monitor](/binding-system-3/project-tools/diagnostics/bindings-monitor.md) open. ## Related pages * [Scene Visualizer](/binding-system-3/project-tools/diagnostics/scene-visualizer.md): what Cozy Nook is built to show. * [Bind Variables](/binding-system-3/overview/bind-variables.md): what Cozy Nook and Courtyard are built on. * [Your First Binding](/binding-system-3/getting-started/first-binding.md): the same flow, on your own field. * [Extending](/binding-system-3/reference/extending.md): the conventions the samples follow.