VAM API

using SimpleJSON;

public override JSONNode GetJSON()
{
    JSONClass jc = new JSONClass();
    jc["customValue"] = "My custom data";
    return jc;
}

    JSONStorableFloat myFloat = new JSONStorableFloat("MyFloat", 0.5f, v => {
        // Callback when value changes
    }, 0f, 1f);
    RegisterFloat(myFloat);

    JSONStorableBool myBool = new JSONStorableBool("MyBool", false, v => {
        // Callback when value changes
    });
    RegisterBool(myBool);

    JSONStorableString myString = new JSONStorableString("MyString", "default", v => {
        // Callback when value changes
    });
    RegisterString(myString);

    JSONStorableAction myAction = new JSONStorableAction("DoSomething", () => {
        // Action code here
    });
    RegisterAction(myAction);

    List<string> options = new List<string> { "Option1", "Option2" };
    JSONStorableStringChooser chooser = new JSONStorableStringChooser("MyChooser", options, options[0], "Label");
    RegisterStringChooser(chooser);

    JSONStorableFloat speed = new JSONStorableFloat("Speed", 1.0f, v => {
        // Update speed logic
    }, 0f, 10f);

    RegisterFloat(speed);

    JSONStorableAction playAction = timelineStorable.GetAction("Play");
    if (playAction != null) {
        playAction.actionCallback.Invoke();
    }

    using SimpleJSON;
    using UnityEngine;

    public class TimelinePlugin : MVRScript {
        private JSONStorableAction _playJSON;

        public override void Init() {
            // Initialize and register the play action
            _playJSON = new JSONStorableAction("Play", () => {
                PlayAnimation();
            });
            RegisterAction(_playJSON);
        }

        private void PlayAnimation() {
            // Logic to play the animation
            SuperController.LogMessage("Animation is playing!");
        }
    }

    // Assuming timelinePlugin is a reference to the TimelinePlugin instance:
    JSONStorableAction playAction = timelinePlugin.GetAction("Play");
    if (playAction != null) {
        playAction.actionCallback.Invoke();
    }

using UnityEngine;

// This plugin demonstrates using three common JSONStorables:
// JSONStorableFloat (slider), JSONStorableBool (toggle), JSONStorableAction (button).
public class JSONStorablesExamplePlugin : MVRScript
{
    // Declare a JSONStorableFloat named "mySpeed" to store a numeric value.
    // It will automatically create a Slider UI element.
    private JSONStorableFloat mySpeed;

    // Declare a JSONStorableBool named "enableFeature" to store a true/false value.
    // It will appear as a checkbox (toggle) in the UI.
    private JSONStorableBool enableFeature;

    // Declare a JSONStorableAction named "logAction" to create a clickable button in UI.
    private JSONStorableAction logAction;

    // The Init method is called once when your plugin is loaded.
    public override void Init()
    {
        // Initialize "mySpeed" JSONStorableFloat with the following parameters:
        // Name = "Speed", Default value = 1.0f, Min = 0, Max = 10.
        // OnSpeedChanged method will be called whenever the slider is moved by the user.
        mySpeed = new JSONStorableFloat("Speed Slider", 1.0f, OnSpeedChanged, 0f, 10f);
        RegisterFloat(mySpeed);  // Register "mySpeed" so Virt-A-Mate can persist and manage it.
        CreateSlider(mySpeed, false);  // Creates a slider UI element bound to "mySpeed".

        // Initialize a checkbox (JSONStorableBool) to let users enable or disable a feature.
        enableFeature = new JSONStorableBool("Enable Feature Checkbox", true, OnEnableFeatureChanged);
        RegisterBool(enableFeature);  // Register "enableFeature" for persistence.
        CreateToggle(enableFeature, false);  // Creates a toggle UI checkbox linked to "enableFeature".

        // Initialize a button action named "LogCurrentSettings".
        logAction = new JSONStorableAction("LogCurrentSettings", LogCurrentSettings);
        RegisterAction(logAction);  // Register "logAction" so Virt-A-Mate can handle the action.
        CreateButton("Log Current Settings", false).button.onClick.AddListener(() => logAction.actionCallback.Invoke());
    }

    // This method is automatically called whenever the user adjusts the slider for "mySpeed".
    private void OnSpeedChanged(float newSpeed)
    {
        // Log the new speed value into VaM's console to inform the user or for debugging.
        SuperController.LogMessage("Speed changed to: " + newSpeed);
    }

    // This callback is automatically called when the checkbox "enableFeature" is toggled by the user.
    private void OnEnableFeatureChanged(bool enabled)
    {
        // Log the current state of the toggle (enabled or disabled).
        SuperController.LogMessage("Enable Feature changed to: " + enabled);
    }

    // This method runs when the user clicks the button created by "logAction".
    private void LogCurrentSettings()
    {
        // Logs the current stored values of "mySpeed" and "enableFeature" to the Virt-A-Mate console.
        SuperController.LogMessage("Current Speed: " + mySpeed.val + ", Feature Enabled: " + enableFeature.val);
    }
}

using UnityEngine;
using UnityEngine.Events;

// This plugin toggles the "Light On" setting in the Light tab of an atom named "InvisibleLight".
// It demonstrates best practices for accessing an atom's parameters in Virt-A-Mate.
public class ToggleLightOn : MVRScript
{
    // The Init() method is called when the plugin is loaded.
    public override void Init()
    {
        // Create a UI button labeled "Toggle Light On" on the left side.
        // When the button is clicked, the OnButtonPress() method is called.
        SetupButton("Toggle Light On", OnButtonPress, false);
    }
    
    // This method is called when the UI button is pressed.
    private void OnButtonPress()
    {
        // UID stands for "Unique Identifier". Every atom (scene object) in VaM has a UID that uniquely identifies it.
        // In our scene, we have an atom that represents our light. Its UID is set to "InvisibleLight".
        Atom lightAtom = GetAtomById("InvisibleLight");
        
        // A "storable" is a container that holds parameters for an atom, such as booleans, floats, colors, etc.
        // The light component (typically AdjustLightV2) registers its parameters under a specific storable ID.
        // In this case, the light component has registered its container with the ID "Light".
        JSONStorable lightStorable = lightAtom?.GetStorableByID("Light");
        
        // Check if the storable was found.
        if (lightStorable != null)
        {
            // "on" Toggle Explanation:
            // Within the "Light" storable, there is a boolean parameter registered with the key "on".
            // This "on" parameter corresponds to the "Light On" toggle seen in the Light tab of the InvisibleLight atom.
            // Here we retrieve that boolean parameter.
            JSONStorableBool lightOn = lightStorable.GetBoolJSONParam("on");
            
            if (lightOn != null)
            {
                // Toggle the "Light On" state: if the light is currently on, this will turn it off, and vice versa.
                lightOn.val = !lightOn.val;
            }
            else
            {
                // Log an error if the "on" parameter could not be found.
                SuperController.LogError("Could not find the 'on' parameter (Light On toggle) in the Light storable.");
            }
        }
        else
        {
            // Log an error if the storable with ID "Light" was not found on the atom.
            SuperController.LogError("Could not find storable 'Light' on atom 'InvisibleLight'.");
        }
    }
    
    // Helper method to create a UI button.
    // label: the text displayed on the button.
    // callback: the method to call when the button is clicked.
    // rightSide: if true, the button appears on the right side; false for the left.
    private void SetupButton(string label, UnityAction callback, bool rightSide)
    {
        UIDynamicButton button = CreateButton(label, rightSide);
        button.button.onClick.AddListener(callback);
    }
}

/*
Detailed Explanation:
---------------------
1. UID (Unique Identifier):
   - Every atom in Virt-A-Mate has a UID that uniquely identifies it within the scene.
   - In this code, "InvisibleLight" is the UID assigned to the light atom.
   - This is similar to a name you give an object, ensuring you can reference it later.

2. Storable:
   - A JSONStorable is a container for parameters associated with an atom.
   - Components like AdjustLightV2 register their parameters (for example, the light's on/off state, intensity, etc.) inside a storable. 
     similar to:
     this.onJSONParam = new JSONStorableBool("on", this._on, SyncOn);
     this.RegisterBool(this.onJSONParam);
   - The default registration for the light component uses the storable ID "Light".
   - You retrieve this container by calling GetStorableByID("Light") on the atom.

3. "on" Toggle:
   - Inside the "Light" storable, the light's on/off state is controlled by a boolean parameter registered as "on".
   - This is what appears as the "Light On" toggle in the Light tab of the InvisibleLight atom.
   - We access it with GetBoolJSONParam("on") and then toggle its value to switch the light on or off.
   */