**DigitalInput_NodeRed User Guide**

The DigitalInput_NodeRed script, when dragged onto an image, transforms the image into a clickable button, detecting user input and allowing feedback state adjustments via the control program.

UnityParallaxLibraryMerged.dll, DigitalInput_NodeRed

This user guide explains how to use the DigitalInput_NodeRed script included in the Parallax Unity Library plugin.

This class library provides a Unity component called DigitalInput_NodeRed, which can be attached to a UI Image object in a Unity project. The DigitalInput_NodeRed component receives button press events and changes the image color accordingly, based on the provided feedback value.

1. **Prerequisites**

To use this class library in your Unity project, ensure that the following requirements are met:

• Unity version: The library is compatible with Unity 2019.4 LTS or later.

2. **Import the UnityParallaxLibrary**

To use the UnityParallaxLibrary, first import it into your Unity project:

• Download or clone the UnityParallaxLibrary repository.
• Copy the UnityParallaxLibrary folder into the Assets folder of your Unity project.

3. **Adding DigitalInput_NodeRed to an Image object**

To add the DigitalInput_NodeRed component to an Image object in your Unity project, follow these steps:

• In the Unity Editor, create or select an Image object in your scene.
• Click the "Add Component" button in the Inspector panel.
• Type "DigitalInput_NodeRed" in the search box and click on the "DigitalInput_NodeRed" component that appears in the list.

4. **Configuring DigitalInput_NodeRed**

After adding the DigitalInput_NodeRed component to an Image object, you can configure its properties in the Unity Editor:

• Instance ID: Assign a unique integer identifier to each DigitalInput_NodeRed component in your scene. This ID is used to differentiate between multiple DigitalInput_NodeRed components.
• High Color: Set the color to be displayed when the button is pressed (default: blue).
• Low Color: Set the color to be displayed when the button is not pressed (default: gray).
• Use the color picker to select custom high and low feedback colors.

5. **Using DigitalInput_NodeRed in your project**

To use DigitalInput_NodeRed in your project, follow these steps:

• Run your Unity project, and the DigitalInput_NodeRed components will react to the button press events by changing the color of the associated Image objects. This allows you to also control feedback from the node red dashboard programmatically.

AnalogInputOutput_NodeRed User Guide

Introduction

The AnalogInputOutput_NodeRed script facilitates interaction between a Unity slider and an external system, such as Node-Red, by emitting and receiving analog values.

Getting Started

Step 1: Create a Slider GameObject

In your Unity scene, create a Slider UI element. This is the GameObject where you'll attach the AnalogInputOutput_NodeRed script.

Step 2: Attach the Script

• With the Slider GameObject selected, go to the Inspector panel.
• Click on the "Add Component" button.
• Search for "AnalogInputOutput_NodeRed" and select it to attach the script.

Step 3: Set Parameters

In the Inspector panel, with the script attached:

• Instance ID: Set the ID for this particular slider. This ID will help distinguish between multiple instances if you have several sliders in your scene.

• Slider Min Val: Set the minimum value for the slider.

• Slider Max Val: Set the maximum value for the slider.

Functionality

Events

This script employs an event-driven approach. It listens for dragging events on the slider, and it emits an event when the slider's value changes.

• On Slider Begin Drag: This event is triggered when you start dragging the slider. It will temporarily remove all listeners from the slider to avoid unwanted interactions during dragging.

• On Slider End Drag: This event is triggered when you release the slider after dragging. It adds a listener back to the slider to detect value changes, and emits the OnAnalogValueChanged event to inform external systems of the new value.

Data Reception

The script has a method Processor_NodeRedOnAnalogDataReceived that listens for incoming analog data events. If the instance ID matches, it updates the _analogVal which reflects the current analog value received from the external system.

Update Loop

During the Unity frame update, the script checks if the received _analogVal is different from the current slider value and the last sent value. If there's a mismatch, the slider's value is updated to match _analogVal.

Integration with External Systems

The script is designed to work seamlessly with systems like Node-Red. The key is the OnAnalogValueChanged event:

• OnAnalogValueChanged: This static action is triggered whenever the slider's value changes. It sends two pieces of data:

  1. Instance ID: Helps external systems identify which slider instance in Unity emitted the event.
  2. Value: The new value of the slider.

External systems can listen to this event and update their processes based on the received value.

Conclusion

The AnalogInputOutput_NodeRed script provides an interactive bridge between Unity and external analog systems. Through sliders in Unity, users can influence external processes and vice-versa, facilitating a two-way communication channel. Ensure to integrate with an external system (like Node-Red) to fully utilize this script's capabilities.

Scrolling List Setup Using ParallaxUnityLibrary Plugin

The ParallaxUnityLibrary plugin for Unity includes a script named `UIScrollingListController` that helps you create a customizable scrolling list. This could be either horizontal or vertical, depending on your needs. The list will be composed of your custom prefab.

What is a Prefab?

In Unity, a prefab (short for prefabricated object) is essentially a blueprint of a game object. It can be a collection of different components or objects grouped together and saved for future use. This allows you to maintain consistency and efficiency in your design.

Setting Up Your Scrolling List

Here are the steps to create your scrolling list:

1. Open Unity and create a new empty GameObject.
2. Navigate to the ParallaxUnityLibrary plugin and find the `UIScrollingListController` script.
3. Drag and drop the `UIScrollingListController` script into your newly created GameObject.
4. Upon runtime, the `UIScrollingListController` script will automatically configure a scrolling list made up of your custom prefab.

Remember, you can choose whether you want your list to scroll horizontally or vertically. This customization allows you to seamlessly integrate the list into your design.

**Introduction:**
TheDynamicDataArrayHandler script is developed for Unity to manage and update UI elements. It effectively processes data in the form of bool, float, and string, supporting both array and dictionary data structures. It facilitates dynamic UI updates by subscribing to specific events and modifying UI elements when new data is received. This script is highly suitable for dynamically populating multiple objects' values, or even for use with scrolling lists where duplicated prefab instances need updating.

The script is part of the ParallaxUnityLibrary and should be dragged onto the parent GameObject. Below illustrates the Parent/Child/Child-Sibling/Grandchild relationship used in the hierarchy.

Example of the GameObject Hierarchy. The DynamicDataArray script is placed on the Parent.

 Below is an example of using both the DynamicDataArray script with the UIScrollingListController to create and populate data for a scrolling list:

Below the DynamicDataArray as seen in the Unity Inspector

.

**Setup:**
1. Attach the `DynamicDataArrayHandler` script to the parent GameObject of the UI elements that you want to update.
2. This script will traverse through all child and grandchild GameObjects of the parent GameObject.

**Inspector Parameters:**
1. `Tag to Match`: Set this to the tag that you would want your GameObjects to match. Only GameObjects with this tag will be considered for dynamic updates.
2. `Instance ID`: Set the ID that corresponds to the data from the control system for dynamic population.
3.Data Structure Type: Select the desired data structure from the following options: BoolArray, FloatArray, StringArray for arrays, and BoolDictionary, FloatDictionary, StringDictionary for dictionaries. This determines how the data will be managed and updated.

**Use Cases:**
1. If you have multiple TextMeshProUGUI objects in the same prefab and you want only some of them to be considered for dynamic text updates, you can set the 'Tag to Match' for those you want to be updated. This allows you to selectively choose which UI elements are affected by dynamic updates.
2. If you have two TextMeshProUGUI objects and you want each one to populate from different string arrays, you can set different tags for them. This allows each UI element to independently receive and display data.
3. If you have a scrolling list with duplicate prefabs for each row/column, `DynamicDataArrayHandler` can be used to populate all tagged objects in each prefab with the corresponding array data.

**Important Note:**
The order in which data is populated is determined by the GameObject hierarchy. The search for tagged objects starts from the parent object and works its way down through the children. As each tagged object is found, it is added to the list to receive updates.

**End Notes:**
The DynamicDataArrayHandler script provides a flexible and efficient means to manage array data and dynamically update Unity UI elements based on this data. Its versatility is showcased in its ability to handle different array data types and its compatibility with a range of UI elements and configurations.

## Instructions

1. **Adding the Script to a GameObject**: To start using the `DynamicDataArray` script, you'll first need to add it to a GameObject. To do this, select the GameObject in the Unity Editor's Hierarchy, then in the Inspector, click "Add Component" and search for "DynamicDataArray".

2. **Setting the Tag**: In the Inspector, you'll find an option to set the `Tag To Match`. This tag is used to search for child GameObjects that contain the UI elements you want to update. Only those GameObjects whose tag matches `Tag To Match` will be considered.

Example prefab which has a Text(TMP) object which we have tagged with "textArray". Now the script can identify this text element and add it to the list of Text(TMP) objects to update from programming.

3. **Setting the Instance ID**: The `Instance ID` is used to determine if the data received from the events is meant for this instance of `DynamicDataArray`. When the `Instance ID` matches the ID received from an event, the script will process the data and update the UI.

4. **Setting the Data Type**: You'll need to specify the type of data this `DynamicDataArray` is handling. This can be `BoolArray`, `FloatArray`, `StringArray`, 'BoolDictionary', 'FloatDictionary', 'StringDictionary' and is set in the `Array Data Type` dropdown menu. The choice of data type will determine what kind of UI elements this script will interact with.

5. **Populating the UI**: Populate the child GameObjects (those with the matching tag) with the relevant UI elements:
- If `Array Data Type` is set to `BoolArray`, the script will look for `Button` components and set their `interactable` property based on the received bool array.
- If `Array Data Type` is set to `FloatArray`, the script will look for `Slider` components and set their `value` property based on the received float array.
- If `Array Data Type` is set to `StringArray`, the script will look for `TextMeshProUGUI` components and set their `text` property based on the received string array. 

A similar approach applies to BoolDictionary, FloatDictionary and StringDictionary data types. The scripts will match by the key and assign the associated value

6. **Running the Scene**: Run the scene in Unity. Whenever a new Array or Dictionary is received from the subscribed events and its ID matches the `Instance ID` of your `DynamicDataArray`, the relevant UI elements will be updated.

## Troubleshooting

In case you face issues while using `DynamicDataArray`:

- Ensure that the `Tag To Match` is correctly set and matches the tags of the relevant GameObjects in the hierarchy.
- Check that the `Instance ID` matches the ID being passed in the event data.
- Make sure that the `Data Type` matches the type of data being received in the event.

###Summary of data types used for populating the dynamic fields.

Types:

BOOL_ARRAY

FLOAT_ARRAY

STRING_ARRAY

BOOL_DICTIONARY

FLOAT_DICTIONARY

STRING_DICTIONARY

See Raspberry Pi Programming Section/Feedback Nodes for more information on using the DynamicDataArray to set feedback.

# CanvasFlipper Script

Overview

The `CanvasFlipper` script is designed to toggle between different canvases in Unity. It enables users to specify UI elements like buttons or images that, when clicked, will activate corresponding canvases. Additionally, the script provides the option to highlight the active UI element using a designated color.

## Features

1. **Toggle Canvases**: Activate one canvas and deactivate all others upon clicking a UI element.
2. **UI Element Pairing**: Link each UI element with a specific canvas to be activated.
3. **Color Highlighting**: Optional setting to highlight the active UI element.

## How to Use

### 1. Importing the Script

- Add the `CanvasFlipper` script to a GameObject in your Unity scene.

### 2. Setting Up UI-Canvas Pairs

- In the Unity Inspector, populate the `UIElementCanvasPairs` list with pairs of UI elements (buttons or images) and the canvases you want them to activate.

### 3. Enable/Disable Highlighting

- If you wish to use the highlighting feature, check the `useHighlight` box.
- If `useHighlight` is enabled, set your desired `activeColor`.

### 4. Original Color Preservation

- The script automatically captures and preserves the original colors of your UI elements.

## Fields Explained

- **UIElementCanvasPair**: A serializable class that holds each UI element (either a button or an image) and the canvas that it activates.

- **uiElementCanvasPairs**: A list of `UIElementCanvasPair` objects that define which UI element activates which canvas.

- **useHighlight**: A boolean that, when set to true, enables the color highlighting feature.

- **activeColor**: The color that will be applied to the active UI element when `useHighlight` is enabled.

- **originalColor**: Stores the original color of each UI element. Hidden from the inspector.

## Example Setup

1. Create two canvases: `Canvas1` and `Canvas2`.
2. Create two buttons: `Button1` and `Button2`.
3. Add `CanvasFlipper` script to an empty GameObject.
4. In `UIElementCanvasPairs`, set `Button1` to activate `Canvas1` and `Button2` to activate `Canvas2`.
5. If you wish, enable `useHighlight` and set an `activeColor`.

## Troubleshooting

- If you see a warning in the console like "Either UI Element or Canvas is null. Skipping this pair," ensure that you've set both the UI element and canvas for every pair.

- If the color of the active UI element does not change as expected, make sure that `useHighlight` is checked and that an `activeColor` is specified.

User Guide: UnityParallaxLibrary's CanvasAdder

Introduction

CanvasAdder is a utility component provided by UnityParallaxLibrary to easily set up the necessary components required for using the CanvasFlipper script. The CanvasFlipper script requires the pages be created from a Canvas which also contains a Canvas Group. This script automatically generates the necessary components required when added to an empty GameObject.

How to Use the CanvasAdder Component

1. Adding the Component:

To get started with CanvasAdder:

• Create or select the GameObject where you wish to add UI capabilities.
• Go to the Component menu → UnityParallaxLibrary → CanvasAdder.

2. Required Components:

Once added, CanvasAdder ensures the existence of the following components:

• Canvas: Serves as the area where UI elements are drawn.
• CanvasGroup: Enables interaction with the UI as a whole group.
• RectTransform: Defines properties such as position, size, and pivot of the UI elements.
• CanvasScaler: Ensures the UI scales properly according to different screen sizes.
• GraphicRaycaster: Enables UI interaction, like clicking or dragging.

3. Automatic Configuration:

The component automatically checks for the required components mentioned above. If any of these components are missing, CanvasAdder will add them for you.

By default:

• The Canvas will use RenderMode.ScreenSpaceOverlay, ensuring the UI overlays on top of the game content.

User Guide: Working with the Time Class in Unity Editor

1. Introduction

The Time class from the UnityParallaxLibrary namespace enables you to display the current time on a TextMeshProUGUI element within Unity. This class allows you to show various elements of time such as hours, minutes, seconds, and milliseconds. This guide covers how to set up and use this class from the Unity Editor.

2. Requirements

Software Requirements

• Unity3D with an active project
• TextMeshPro package installed

Component Requirements

• GameObject with a TextMeshProUGUI component

3. Preparing Your Scene

3.1 Import TextMeshPro

If TextMeshPro is not installed:

1. Go to Window > Package Manager.
2. Find TextMeshPro and click Install.

3.2 Create a Canvas and Text Element

1. Right-click in the Hierarchy panel, navigate to UI and select Canvas.
2. Right-click on the newly created Canvas object, navigate to UI and select Text - TextMeshPro.

4. Implementing the Time Class

4.1 Attach the Time Script

1. Select the Text - TextMeshPro GameObject in the Hierarchy.
2. In the Inspector window, click Add Component.
3. Search for Time under UnityParallaxLibrary and attach it.

4.2 Configure Display Options

1. With the Text - TextMeshPro GameObject selected, find the Time component in the Inspector.
2. Under Display Options, you'll find checkboxes for displayHours, displayMinutes, displaySeconds, and displayMilliseconds.
3. Check or uncheck these boxes according to what parts of the time you wish to display.

5. Running the Scene

• Press the Play button. The Time script will update the TextMeshProUGUI element to display the current time based on your configurations.

6. Troubleshooting

• If the error "No TextMeshProUGUI component found on this GameObject" appears, ensure that the GameObject has a TextMeshProUGUI component attached.
• If the time isn't updating, make sure the GameObject with the Time script is active in the scene.

7. Conclusion

By following this guide, you will have implemented the Time class in your Unity project, allowing for real-time display of various time elements. You can further customize this feature according to your project's needs.

Note: The time displayed will come from the physical device where the run-time program is executed

StringInput_NodeRed Script User Guide for Unity Editor

Overview

The StringInput_NodeRed script is a component of the UnityParallaxLibrary. It acts as an event handler for TextMeshPro Input Fields (TMP_InputField) in Unity. When text is entered and editing is finalized, the script triggers a static OnTextSubmitted event, passing an instanceId and the input string for identification and event handling. This script is particularly useful for projects requiring text input events, especially those that work with Node-Red services.

Steps to Setup

Step 1: Locate the Script in the Project Window

1. Open the Unity Editor and navigate to the Project window.
2. Locate the UnityParallaxLibrary folder.
3. Inside this folder, you'll find the StringInput_NodeRed script.

Step 2: Attach the Script to a GameObject with TMP_InputField

1. In the Hierarchy window, locate the GameObject that has a TextMeshPro Input Field (TMP_InputField).
2. Select this GameObject.
3. In the Inspector window, click the Add Component button.
4. Use the search bar to find StringInput_NodeRed and click it to add it to your GameObject as a component.

Step 3: Configure the instanceId Field

1. With the GameObject still selected, find the StringInput_NodeRed component within the Inspector.
2. You'll notice a field labeled instanceId. Assign a unique integer value to this field for identifying different instances of the script.

Step 4: Subscriptions in the Editor

• While Unity Editor doesn't allow direct event subscriptions, ensure your scripts are set up to subscribe to the OnTextSubmitted event for the intended functionality.

Step 5: Test Your Setup in the Editor

1. Press the Play button in Unity to run your scene.
2. Focus on the TMP_InputField linked to your GameObject.
3. Enter some text and either defocus the input field or hit the return key.
4. If you have scripts that are subscribed to OnTextSubmitted, their respective methods should get invoked.

Conclusion

By following this guide, you should have successfully integrated the StringInput_NodeRed script into your Unity project. This will allow you to effectively handle text input events in Unity, especially if your project interfaces with Node-Red services.

StringOutput_NodeRed Script User Guide for Unity Editor

Overview

The StringOutput_NodeRed script is a part of the UnityParallaxLibrary. It listens to incoming string data events and displays them using a TextMeshPro (TMP_Text) component in Unity. This script is sends the data to the ParallaxProcessor. 

Steps to Setup

Step 1: Locate the Script in the Project Window

1. Open the Unity Editor and go to the Project window.
2. Locate the UnityParallaxLibrary folder.
3. Find the StringOutput_NodeRed script inside this folder.

Step 2: Attach the Script to a GameObject with TMP_Text

1. In the Hierarchy window, locate or create a GameObject with a TextMeshPro (TMP_Text) component.
2. Select this GameObject.
3. In the Inspector window, click the Add Component button.
4. Search for StringOutput_NodeRed and click on it to add it as a component.

Step 3: Configure the instanceId Field

1. With the GameObject still selected, locate the StringOutput_NodeRed component within the Inspector.
2. You will see a field labeled instanceId. Assign a unique integer value to this field to identify different instances of the script.

Step 4: Test Your Setup in the Editor

1. Press the Play button to run your Unity scene.
2. If set up correctly, the TMP_Text component linked to your GameObject should update its text based on the received string data.

Conclusion

By following this guide, you should be able to successfully integrate the StringOutput_NodeRed script into your Unity project. This will allow you to display string data dynamically through a TextMeshPro (TMP_Text) component coming from the ParallaxProcessor.