Skip to main content
100%

Simple Playable Example

✓ Published0🌍 Public
Aandybak
Last edited Apr 3, 2018
Created on Apr 3, 2018

This example demonstrates a playable graph that toggles a MonoBehaviour component’s enabled state at the start and end of a playable clip. It uses Unity’s Playables API, including `PlayableAsset`, `PlayableBehaviour`, and `ScriptPlayable`, with `ExposedReference` to resolve the target component. The `ToggleComponentAsset` creates a `ToggleComponentPlayable` that sets the component’s `enabled` flag in `OnBehaviourPlay` and `OnBehaviourPause`. The visible behavior is limited to enabling or disabling the component at clip boundaries, driven by the `EnabledOnStart` and `EnabledOnEnd` properties.

AI-generated description

Similar vizzes

Loading thumbnail…

Unity component that keeps the editor scene view active when entering play mode.

This example demonstrates a small Unity editor utility component that refocuses the Scene view when entering Play Mode. The `KeepSceneViewActive` MonoBehaviour, placed on any game object, checks a public boolean `KeepActive` and, during `Start`, calls `UnityEditor.EditorWindow.FocusWindowIfItsOpen` with `UnityEditor.SceneView` as the target type. It relies on the `UNITY_EDITOR` preprocessor directive to ensure the editor-only code is compiled only in the Unity Editor. The behavior is immediate and automatic, requiring no user interaction beyond attaching the component.

MMcNull
55% match
Loading thumbnail…

Gist 3ea286941ac2e64f1214744f80b99beb

This example demonstrates a VR player controller that manages a timeline-driven animation sequence. It uses Unity’s PlayableDirector to play and pause a timeline, while calibrating the player’s position based on XR headset tracking via UnityEngine.XR. The script checks XRDevice.userPresence to automatically start the timeline when a headset is worn, and rewinds it when removed. It also supports manual control through the Submit input button, toggling between rewind-and-pause and rewind-and-play states.

Aandybak
54% match
Loading thumbnail…

Gist b44b034e2ab3689f897d3c0d9d41569a

This example shows a Unity script that animates a post-processing vignette effect on a camera, smoothly fading its intensity in or out based on a boolean input. The code uses the DOTween tweening library to interpolate a `vignIntensity` field over a specified duration, while a `PostProcessingBehaviour` component references its attached `PostProcessingProfile` to update the vignette settings in real time. The animation updates the profile’s `VignetteModel.Settings` each frame, and on completion clears the tween reference. The script reads the profile directly from the camera’s behavior, making it suitable for runtime effects.

Aandybak
53% match
Loading thumbnail…

Gist 163847197f2c33368934a7c89ba711bc

This example visualizes a particle system and its interactions, built with the Unity game engine. It uses Unity's built-in modules for rendering, physics, and user interface elements, including the TextMeshPro and UI systems. The visualization is driven by Unity's component-based architecture, with a manifest that declares the package dependencies. The work does not use typical JavaScript data-visualization libraries like D3 or Three.js; instead, it leverages Unity's own animation, audio, and particle system modules to create the interactive scene.

Aandybak
51% match
Loading thumbnail…

Gist 540bb6cf2f6ceada6387cc673f971498

This example demonstrates how to change an object’s appearance and size at runtime using Unity’s core APIs. It shows a script that accesses a GameObject’s MeshRenderer component to set its material color to red, then modifies the object’s Transform to scale it uniformly to five times its original size. The code relies on Unity’s `GetComponent<MeshRenderer>()` and the `transform.localScale` property, with `Color.red` and `Vector3` supplying the new values. The behavior is triggered directly in the `ChangeStuff()` method, illustrating a simple, immediate state change without animation or external data sources.

Aandybak
49% match
Loading thumbnail…

Gist e8b15841a94b3df4ff4af56774e85370

This example shows a Unity Editor utility that copies and pastes serialized component values between different component types. It adds two menu commands, “Copy Serialized” and “Paste Serialized Values,” to the component context menu. The paste operation first checks if the source and destination components are the same type, using `EditorUtility.CopySerialized` for a direct copy. Otherwise, it iterates through the source’s `SerializedProperty` hierarchy, matching properties by name and type in the destination via `dest.FindProperty`, then copies values with `dest.CopyFromSerializedProperty` and applies changes with `ApplyModifiedProperties`. The code uses Unity’s `SerializedObject`, `SerializedProperty`, and `MenuItem` APIs.

Aandybak
49% match
Loading thumbnail…

Gist c3927fd16c93fc919a74036325faacd4

In a virtual-reality environment built with A-Frame, a video playlist automatically plays two accessibility-themed VR conference talks inside a networked 3D scene. The code defines an array of MP4 URLs hosted on an S3 bucket, creates an `a-entity` with the `media-loader` and `networked` components, and scales it to ten units while positioning it 35 units away. It disables looping and listens for the video’s `ended` event to switch to the next clip, cycling back to the first after the last. A CORS proxy URL prefixes each source, and the playback jumps near the end for testing.

UUtopiah
48% match
Loading thumbnail…

playClip

This example demonstrates a custom method for playing a specific segment of an HTML audio element. It defines `HTMLAudioElement.prototype.playClip`, which takes a start and stop time, sets the current playback position, and uses `setTimeout` to pause the audio after the desired duration. The code relies on the native Web Audio API and DOM methods like `querySelectorAll` to select an audio element and trigger playback. It shows how to extend built-in browser objects for reusable time-based audio control.

Aamundo
48% match