Nova UI

https://novaui.io/api
Admin
Nova UI is a framework offering foundational UI components, interaction handling, data binding, and...
Tokens:16,986
Snippets:75
Trust Score:5
Update:1 year ago
Show doc for...
Tokens:
Raw
### Animation Lifecycle and Control Example (C#)

Source: https://context7.com/context7/novaui_io-api/llms.txt

Demonstrates how to create, run, chain, and control animations using `AnimationHandle` in Unity. It shows starting animations, chaining them sequentially, and controlling their playback via methods like `Pause`, `Resume`, `Complete`, and `Cancel`.

```csharp
using Nova;
using UnityEngine;

public class AnimationExample : MonoBehaviour
{
    public UIBlock animatedBlock;
    public UIBlock2D fadeBlock;

    AnimationHandle currentHandle;

    void StartAnimations()
    {
        // Create animation
        var posAnim = new PositionAnimation
        {
            BlockToAnimate = animatedBlock,
            StartPosition = Vector3.zero,
            EndPosition = new Vector3(100, 0, 0)
        };

        // Run animation with duration
        AnimationHandle handle = posAnim.Run(durationInSeconds: 2.0f);

        // Chain multiple animations
        var returnAnim = new PositionAnimation
        {
            BlockToAnimate = animatedBlock,
            StartPosition = new Vector3(100, 0, 0),
            EndPosition = Vector3.zero
        };

        handle.Chain(returnAnim, durationInSeconds: 1.5f);

        // Run fade animation
        var fadeAnim = new FadeAnimation
        {
            Block = fadeBlock,
            StartColor = Color.white,
            EndColor = Color.clear
        };

        currentHandle = fadeAnim.Run(durationInSeconds: 1.0f);
    }

    void ControlAnimations()
    {
        // Pause running animation
        currentHandle.Pause();

        // Resume paused animation
        currentHandle.Resume();

        // Jump to end state
        currentHandle.Complete();

        // Stop and cancel animation
        currentHandle.Cancel();
    }

    void ComplexChain()
    {
        // Create complex animation chain
        var move1 = new PositionAnimation
        {
            BlockToAnimate = animatedBlock,
            StartPosition = Vector3.zero,
            EndPosition = Vector3.right * 100
        };

        var move2 = new PositionAnimation
        {
            BlockToAnimate = animatedBlock,
            StartPosition = Vector3.right * 100,
            EndPosition = Vector3.up * 100
        };

        var move3 = new PositionAnimation
        {
            BlockToAnimate = animatedBlock,
            StartPosition = Vector3.up * 100,
            EndPosition = Vector3.zero
        };

        // Chain animations sequentially
        AnimationHandle handle = move1.Run(1.0f)
            .Chain(move2, 1.0f)
            .Chain(move3, 1.0f);

        // Or include animations in existing chain
        var fadeOut = new FadeAnimation
        {
            Block = fadeBlock,
            StartColor = Color.white,
            EndColor = Color.clear
        };

        handle.Include(fadeOut, 0.5f);
    }
}
```

--------------------------------

### C# ListView Data Binding and Management Example

Source: https://context7.com/context7/novaui_io-api/llms.txt

Demonstrates setting up a ListView in C# with custom data models and visuals. Includes methods for populating data, binding/unbinding, updating data, and manually detaching/reattaching list items for custom management. Handles data pooling and efficient rendering.

```csharp
using Nova;
using UnityEngine;
using System.Collections.Generic;

// Define data model
public struct PlayerData
{
    public string Name;
    public int Score;
    public Color Color;
}

// Define visual component
public class PlayerItemVisuals : ItemVisuals
{
    public TextBlock nameText;
    public TextBlock scoreText;
    public UIBlock2D background;
}

// ListView example
public class PlayerListExample : MonoBehaviour
{
    public ListView listView;
    public List<PlayerData> players = new List<PlayerData>();

    void Start()
    {
        // Populate data
        players.Add(new PlayerData { Name = "Alice", Score = 1000, Color = Color.red });
        players.Add(new PlayerData { Name = "Bob", Score = 850, Color = Color.blue });
        players.Add(new PlayerData { Name = "Charlie", Score = 920, Color = Color.green });

        // Set data source
        listView.SetDataSource(players);

        // Subscribe to binding events
        listView.AddDataBinder<PlayerData, PlayerItemVisuals>(BindPlayerData);
        listView.AddDataUnbinder<PlayerData, PlayerItemVisuals>(UnbindPlayerData);
    }

    void BindPlayerData(Data.OnBind<PlayerData> evt)
    {
        // evt.UserData contains the data being bound
        PlayerData player = evt.UserData;

        // evt.View is the ItemView container
        if (evt.View.TryGetVisuals(out PlayerItemVisuals visuals))
        {
            visuals.nameText.Text = player.Name;
            visuals.scoreText.Text = $"Score: {player.Score}";
            visuals.background.Color = player.Color;
        }
    }

    void UnbindPlayerData(Data.OnUnbind<PlayerData> evt)
    {
        // Clean up when data is detached
        if (evt.View.TryGetVisuals(out PlayerItemVisuals visuals))
        {
            visuals.nameText.Text = "";
            visuals.scoreText.Text = "";
        }
    }

    void UpdateData()
    {
        // Modify data and refresh
        players[0].Score += 100;
        listView.SetDataSource(players);
    }

    void ManageListItems()
    {
        // Manually detach item for custom management
        ItemView item = listView[0];
        Transform customParent = transform.parent;

        if (listView.TryDetach(item, customParent))
        {
            Debug.Log("Item detached successfully");
        }

        // Return item to pool
        if (listView.TryReattach(item))
        {
            Debug.Log("Item returned to pool");
        }
    }
}
```

--------------------------------

### IAnimationExtensions.Run

Source: https://novaui.io/api/Nova.IAnimationExtensions

Queues an animation to run for a specified duration, starting at the end of the current frame.

```APIDOC
## POST /websites/novaui_io-api/IAnimationExtensions/Run

### Description
Queues an animation to run for `durationInSeconds` starting at the end of the current frame.

### Method
POST

### Endpoint
/websites/novaui_io-api/IAnimationExtensions/Run

### Parameters
#### Path Parameters
None

#### Query Parameters
* **durationInSeconds** (float) - Required - The duration, in seconds, of the animation.

#### Request Body
* **animation** (T) - Required - The IAnimation struct configured to perform the animation via Nova.IAnimation.Update(float).

### Request Example
```json
{
  "animation": "<animation_struct_instance>",
  "durationInSeconds": 1.5
}
```

### Response
#### Success Response (200)
- **AnimationHandle** (AnimationHandle) - An AnimationHandle, which can be used to chain, include, pause, resume, cancel, or complete the animation.

#### Response Example
```json
{
  "handleId": "unique_animation_handle_id"
}
```

#### Error Handling
- **System.ArgumentException**: Throws when `durationInSeconds` is invalid.
```

--------------------------------

### C# GridView Data Binding and Slice Management Example

Source: https://context7.com/context7/novaui_io-api/llms.txt

Illustrates the implementation of a GridView in C# using a 2D grid data structure. Covers creating the grid, populating it with data, setting a data source, configuring slice providers, and binding data to visual elements. Also shows how to update specific grid items and slices, and query loaded slice ranges.

```csharp
using Nova;
using UnityEngine;
using System.Collections.Generic;

public struct ItemData
{
    public string Name;
    public int Quantity;
}

public class ItemVisuals : ItemVisuals
{
    public TextBlock nameLabel;
    public TextBlock quantityLabel;
}

// GridView example
public class InventoryGridExample : MonoBehaviour
{
    public GridView gridView;
    public GridList<ItemData> inventory;

    void Start()
    {
        // Create grid data structure
        int rows = 5;
        int columns = 10;
        inventory = GridList<ItemData>.CreateWithRows(rows, columns);

        // Populate grid
        for (int r = 0; r < rows; r++)
        {
            for (int c = 0; c < columns; c++)
            {
                inventory[r, c] = new ItemData
                {
                    Name = $"Item_{r}_{c}",
                    Quantity = Random.Range(1, 99)
                };
            }
        }

        // Set data source
        gridView.SetDataSource(inventory);

        // Configure grid slice provider
        gridView.SetSliceProvider(ProvideGridSlice);

        // Subscribe to binding
        gridView.AddDataBinder<ItemData, ItemVisuals>(BindItemData);
    }

    void ProvideGridSlice(GridSlice slice)
    {
        // Configure slice visuals/layout
        Debug.Log($"Providing slice at index {slice.Index}");
    }

    void BindItemData(Data.OnBind<ItemData> evt)
    {
        ItemData item = evt.UserData;

        if (evt.View.TryGetVisuals(out ItemVisuals visuals))
        {
            visuals.nameLabel.Text = item.Name;
            visuals.quantityLabel.Text = item.Quantity.ToString();
        }
    }

    void UpdateGridItem()
    {
        // Access by row/column
        inventory[2, 3].Quantity += 10;

        // Access by GridIndex
        GridIndex index = new GridIndex(2, 3);
        inventory[index].Quantity += 5;

        // Update specific slice
        int sliceIndex = 2;
        gridView.UpdateGridSlice(sliceIndex);

        // Query virtual range
        int minLoaded = gridView.MinLoadedSliceIndex;
        int maxLoaded = gridView.MaxLoadedSliceIndex;
        Debug.Log($"Loaded slices: {minLoaded} to {maxLoaded}");
    }
}
```

--------------------------------

### Gesture.OnDrag.RawTranslationLocalSpace

Source: https://novaui.io/api/Nova.Gesture.OnDrag

Provides the total translation from the starting pointer position to the current pointer position, measured in the receiver's local space.

```APIDOC
## Gesture.OnDrag.RawTranslationLocalSpace

### Description
The total translation from `PointerPositions.Start` to `PointerPositions.Current` in Receiver local space.

### Method
GET

### Endpoint
/Gesture/OnDrag/RawTranslationLocalSpace

### Parameters
#### Query Parameters
- None

#### Request Body
- None

### Request Example
```json
{
  "example": "No request body for this endpoint."
}
```

### Response
#### Success Response (200)
- **RawTranslationLocalSpace** (Vector3) - The total translation from `PointerPositions.Start` to `PointerPositions.Current` in Receiver local space.

#### Response Example
```json
{
  "RawTranslationLocalSpace": {
    "x": 0.5,
    "y": -0.2,
    "z": 0.0
  }
}
```

### Remarks
This value is not constrained to the Receiver's local space draggable axes, DraggableAxes.

### Declaration
```csharp
public readonly UnityEngine.Vector3 RawTranslationLocalSpace { get; }
```

### See Also
- GetTranslationInLocalSpace(Transform, Vector3, Vector3)
```

--------------------------------

### Implement IAnimation Update Method in C#

Source: https://novaui.io/api/Nova.IAnimation

This C# code snippet demonstrates how to implement the `Update` method for the `IAnimation` interface. It shows how to use the `percentDone` parameter to interpolate between a start and end position for a UI block. This requires the Nova and UnityEngine namespaces.

```csharp
using Nova;
using UnityEngine;

public struct PositionAnimation : IAnimation
{
    public UIBlock BlockToAnimate;

    public Vector3 StartPosition;
    public Vector3 EndPosition;

    public void Update(float percentDone)
    {
        BlockToAnimate.Position.Value = Vector3.Lerp(StartPosition, EndPosition, percentDone);
    }
}
```

--------------------------------

### Run Animation with Duration (C#)

Source: https://novaui.io/api/Nova.IAnimationExtensions

Queues an animation to run for a specified duration. The animation is executed starting at the end of the current frame. This method requires an IAnimation struct and returns an AnimationHandle for further control.

```csharp
public static AnimationHandle Run<T>(this T animation, float durationInSeconds)
    where T : struct, IAnimation
{
    // Implementation details...
}
```

--------------------------------

### Define Custom Scale Animation with Easing (C#)

Source: https://context7.com/context7/novaui_io-api/llms.txt

Defines a custom struct `ScaleAnimation` implementing `IAnimation` to animate the scale of a `UIBlock`. It incorporates `Mathf.SmoothStep` for easing the interpolation between the start and end scale values.

```csharp
// Scale animation example
public struct ScaleAnimation : IAnimation
{
    public UIBlock Block;
    public Vector3 StartScale;
    public Vector3 EndScale;

    public void Update(float percentDone)
    {
        // Use easing function
        float easedPercent = Mathf.SmoothStep(0, 1, percentDone);
        Block.transform.localScale = Vector3.Lerp(StartScale, EndScale, easedPercent);
    }
}
```

--------------------------------

### Define Custom Position Animation (C#)

Source: https://context7.com/context7/novaui_io-api/llms.txt

Defines a custom struct `PositionAnimation` that implements the `IAnimation` interface to animate the position of a UIBlock. It utilizes `Vector3.Lerp` for smooth interpolation between start and end positions.

```csharp
using Nova;
using UnityEngine;

public struct PositionAnimation : IAnimation
{
    public UIBlock BlockToAnimate;
    public Vector3 StartPosition;
    public Vector3 EndPosition;

    public void Update(float percentDone)
    {
        // percentDone ranges from 0 to 1
        BlockToAnimate.Position.Value = Vector3.Lerp(StartPosition, EndPosition, percentDone);
    }
}
```

--------------------------------

### Define Custom Rotation Animation (C#)

Source: https://context7.com/context7/novaui_io-api/llms.txt

Defines a custom struct `RotationAnimation` implementing `IAnimation` to animate the rotation of a `UIBlock`. It uses `Quaternion.Slerp` for spherical linear interpolation between start and end rotations.

```csharp
// Rotation animation example
public struct RotationAnimation : IAnimation
{
    public UIBlock Block;
    public Quaternion StartRotation;
    public Quaternion EndRotation;

    public void Update(float percentDone)
    {
        Block.transform.rotation = Quaternion.Slerp(StartRotation, EndRotation, percentDone);
    }
}
```

--------------------------------

### Get Focused UIBlock with Navigation.TryGetFocusedUIBlock (C#)

Source: https://novaui.io/api/Nova.Navigation

Retrieves the UIBlock that was most recently navigated to from a specific control ID. This method returns true if a navigable UIBlock is found, and false otherwise. It is useful for managing UI focus and state restoration.

```csharp
public static bool TryGetFocusedUIBlock(uint controlID, out UIBlock focused)
```

--------------------------------

### Implement UI Navigation with Nova UI (C#)

Source: https://context7.com/context7/novaui_io-api/llms.txt

This C# script demonstrates how to set up a navigation system for UI elements using Nova UI. It includes creating navigation links, subscribing to and handling various navigation events (select, deselect, direction, move), and querying the currently focused UI element. This code requires the Nova UI package and a Unity environment.

```csharp
using Nova;
using UnityEngine;

public class NavigationExample : MonoBehaviour
{
    public NavNode menuRoot;
    public UIBlock optionA;
    public UIBlock optionB;
    public UIBlock optionC;

    void Start()
    {
        // Create navigation links between elements
        var linkAtoB = new NavLink
        {
            From = optionA,
            To = optionB,
            Direction = NavDirection.Down
        };

        // Subscribe to navigation events
        optionA.AddGestureHandler<Navigate.OnSelect>(HandleSelect);
        optionA.AddGestureHandler<Navigate.OnDeselect>(HandleDeselect);
        optionB.AddGestureHandler<Navigate.OnDirection>(HandleDirection);
        optionB.AddGestureHandler<Navigate.OnMoveTo>(HandleMoveTo);
        optionC.AddGestureHandler<Navigate.OnMoveFrom>(HandleMoveFrom);
    }

    void HandleSelect(Navigate.OnSelect evt)
    {
        // Element selected/focused
        evt.Receiver.GetComponent<UIBlock2D>().Color = Color.yellow;
    }

    void HandleDeselect(Navigate.OnDeselect evt)
    {
        // Element deselected/unfocused
        evt.Receiver.GetComponent<UIBlock2D>().Color = Color.white;
    }

    void HandleDirection(Navigate.OnDirection evt)
    {
        // Directional input received
        Debug.Log($"Direction input on {evt.Receiver.name}");
    }

    void HandleMoveTo(Navigate.OnMoveTo evt)
    {
        // Navigation target reached
        Debug.Log($"Navigated to {evt.Receiver.name}");
    }

    void HandleMoveFrom(Navigate.OnMoveFrom evt)
    {
        // Navigation source departed
        Debug.Log($"Navigated from {evt.Receiver.name}");
    }

    void Update()
    {
        // Query currently focused element by controller ID
        int controlID = 0;
        if (Navigation.TryGetFocusedUIBlock(controlID, out UIBlock focused, out NavState state))
        {
            Debug.Log($"Focused: {focused.name}, State: {state}");
        }
    }
}
```

--------------------------------

### Create 2D/3D UI Elements with UIBlock Components

Source: https://context7.com/context7/novaui_io-api/llms.txt

Demonstrates how to create and configure basic 2D and 3D UI elements using Nova UI's UIBlock components. It covers setting visibility, render order, size, depth, corner radius, and text rendering. This requires the Nova namespace.

```csharp
using Nova;
using UnityEngine;

// Create a basic 2D UI element
public class ButtonExample : MonoBehaviour
{
    public UIBlock2D buttonBlock;

    void Start()
    {
        // Configure visibility
        buttonBlock.Visible = true;

        // Set render order within sort group
        buttonBlock.ZIndex = 10;

        // Configure size using flexible Length system
        buttonBlock.Size.X = Length.FixedValue(200);
        buttonBlock.Size.Y = Length.Percentage(50); // 50% of parent
    }
}

// Create a 3D volumetric UI element
public class Panel3DExample : MonoBehaviour
{
    public UIBlock3D panel;

    void Start()
    {
        // Set depth
        panel.Size.Z = Length.FixedValue(10);

        // Apply rounded corners (affects all 8 corners)
        panel.CornerRadius = new Length3
        {
            X = Length.FixedValue(5),
            Y = Length.FixedValue(5),
            Z = Length.FixedValue(2)
        };

        // Hide without affecting layout
        panel.Visible = false;
    }
}

// Text rendering
public class LabelExample : MonoBehaviour
{
    public TextBlock label;

    void Setup()
    {
        label.Text = "Score: 100";
        label.ZIndex = 100; // Render above other elements
    }
}
```

--------------------------------

### Configure Layouts with Nova UI

Source: https://context7.com/context7/novaui_io-api/llms.txt

Shows how to use Nova UI's layout system for flexible positioning and sizing of UI elements. It covers using different unit types for Length, scaling lengths, enabling AutoLayout, and adjusting alignment. Requires the Nova namespace.

```csharp
using Nova;
using UnityEngine;

public class LayoutExample : MonoBehaviour
{
    public UIBlock container;
    public UIBlock child1;
    public UIBlock child2;

    void ConfigureLayouts()
    {
        // Length supports fixed, percentage, and calculated values
        container.Size = new Length3
        {
            X = Length.FixedValue(400),
            Y = Length.Percentage(80), // 80% of parent height
            Z = Length.FixedValue(0)
        };

        // Scale lengths with multiplication
        Length baseWidth = Length.FixedValue(100);
        child1.Size.X = baseWidth * 2.0f; // 200 units
        child2.Size.X = 1.5f * baseWidth; // 150 units

        // AutoLayout positions children automatically
        container.AutoLayout = AutoLayout.Axis.X; // Horizontal layout

        // Alignment controls positioning within parent
        child1.Alignment = new Alignment
        {
            X = HorizontalAlignment.Left,
            Y = VerticalAlignment.Center,
            Z = DepthAlignment.Front
        };

        // Convert alignment to/from vectors
        Vector3 alignmentVector = child1.Alignment;
        child2.Alignment = new Vector2(0, 0.5f); // Center X, 50% Y
    }

    void ReadCalculatedValues()
    {
        // Access calculated values after layout pass
        Length.Calculated actualWidth = container.Size.X.Calculated;
        Length.Calculated actualHeight = container.Size.Y.Calculated;

        Debug.Log($"Container size: {actualWidth} x {actualHeight}");
    }
}
```

--------------------------------

### Apply Visual Styles to UI Elements in C#

Source: https://context7.com/context7/novaui_io-api/llms.txt

Demonstrates how to apply various visual styles and effects to UI elements using Nova UI components in C#. This includes setting up surfaces, borders, shadows, gradients, and image adjustments. It requires Unity and the Nova UI package.

```csharp
using Nova;
using UnityEngine;
using UnityEngine.Rendering;

public class StylingExample : MonoBehaviour
{
    public UIBlock2D styledBlock;
    public UIBlock3D panel3D;

    void ApplyStyles()
    {
        // Create rubber surface with Standard lighting
        Surface rubberSurface = Surface.Rubber(
            smoothness: 0.6f,
            metallic: 0.0f,
            shadowCasting: ShadowCastingMode.On,
            receiveShadows: true
        );

        panel3D.Surface = rubberSurface;

        // Create rubber surface with StandardSpecular lighting
        Surface coloredRubber = Surface.Rubber(
            reflectionColor: Color.blue,
            smoothness: 0.5f,
            metallic: 0.0f,
            shadowCasting: ShadowCastingMode.Off,
            receiveShadows: false
        );

        panel3D.Surface = coloredRubber;

        // Configure border
        var border = styledBlock.GetComponent<Border>();
        border.Width = Length.FixedValue(2);
        border.Color = Color.black;

        // Add shadow
        var shadow = styledBlock.GetComponent<Shadow>();
        shadow.Width = Length.FixedValue(5);
        shadow.Color = new Color(0, 0, 0, 0.5f);
        shadow.Offset = new Vector2(2, -2);

        // Apply radial gradient
        var gradient = styledBlock.GetComponent<RadialGradient>();
        gradient.Enabled = true;
        gradient.Center = new Vector2(0.5f, 0.5f);
        gradient.Color = Color.blue;

        // Configure radial fill (progress indicator)
        var radialFill = styledBlock.GetComponent<RadialFill>();
        radialFill.Rotation = 90; // Start from top
        radialFill.FillAngle = 270; // 75% filled
        radialFill.Clockwise = true;

        // Image adjustment for sliced/tiled images
        var imageAdjust = styledBlock.GetComponent<ImageAdjustment>();
        imageAdjust.PixelsPerUnitMultiplier = 2.0f;

        // Clip mask for clipping child content
        var clipMask = styledBlock.GetComponent<ClipMask>();
        clipMask.UIBlock = styledBlock;

        // Sort group for render ordering
        var sortGroup = styledBlock.GetComponent<SortGroup>();
        sortGroup.RenderOverOpaqueGeometry = true; // Screen-space overlay
    }

    void AnimateRadialFill(float progress)
    {
        var radialFill = styledBlock.GetComponent<RadialFill>();
        radialFill.FillAngle = progress * 360f; // 0 to 360 degrees
    }
}

// Lighting model example
public class LightingExample : MonoBehaviour
{
    public UIBlock3D block;

    void SetupLighting()
    {
        // Standard PBR lighting
        block.Surface = Surface.CreateStandard(
            color: Color.white,
            smoothness: 0.8f,
            metallic: 0.5f
        );

        // Standard Specular lighting
        var specular = block.GetComponent<StandardSpecular>();
        specular.SpecularColor = Color.cyan; // Hue of specular reflections

        // Classic Blinn-Phong lighting
        var blinnPhong = block.GetComponent<BlinnPhong>();
        blinnPhong.Specular = 0.7f;
        blinnPhong.Shininess = 32.0f;
    }
}

```

--------------------------------

### POST /Surface/Rubber (Default)

Source: https://novaui.io/api/Nova.Surface

Creates a new, soft rubber surface with default properties. Uses the Standard lighting model.

```APIDOC
## POST /Surface/Rubber (Default)

### Description
Creates a new, soft rubber surface with default properties, using the Standard lighting model.

### Method
POST

### Endpoint
/Surface/Rubber

### Parameters
#### Query Parameters
- **smoothness** (float) - Optional - The Smoothness parameter. Defaults to 0.4.
- **metallic** (float) - Optional - The Metallic parameter. Defaults to 0.
- **shadowCasting** (ShadowCastingMode) - Optional - Value for ShadowCastingMode. Defaults to ShadowCastingMode.Off.
- **receiveShadows** (bool) - Optional - Value for ReceiveShadows. Defaults to false.

### Request Example
```json
{
  "smoothness": 0.4,
  "metallic": 0.0,
  "shadowCasting": "Off",
  "receiveShadows": false
}
```

### Response
#### Success Response (200)
- **Surface** (object) - A new Surface object with a mostly matte, non-metallic effect.

#### Response Example
```json
{
  "type": "Surface",
  "smoothness": 0.4,
  "metallic": 0.0,
  "shadowCasting": "Off",
  "receiveShadows": false
}
```
```

--------------------------------

### Navigate.OnSelect Event Details

Source: https://novaui.io/api/Nova.Navigate

Provides details about the Navigate.OnSelect event, including its properties and implementation.

```APIDOC
## Navigate.OnSelect Event

### Description
Details of a navigation select event. This event is not fired when the Receiver's OnSelect is set to Click. In that case, Gesture.OnClick events are fired instead.

### Implements
- IGestureEvent
- IEvent

### Properties
- **ID** (string) - A unique identifier associated with the event.
- **Interaction** (Interaction) - The interaction update responsible for triggering the event. Created by a Navigation method.
- **Receiver** (UIBlock) - The UIBlock from which the event was invoked.
- **Target** (UIBlock) - An ancestor of the Receiver (or the Receiver itself) holding information pertinent to the event handler.

### See Also
- Navigate
- Interactable
- Scroller
- SelectBehavior
```

--------------------------------

### Nova UI Utility Types and Layout Controls (C#)

Source: https://context7.com/context7/novaui_io-api/llms.txt

Demonstrates the usage of various utility types provided by Nova UI for defining ranges, sizes, and grid structures. It also showcases advanced layout configurations like cross-axis spacing and size constraints, as well as screen space conversion utilities. This code requires the Nova UI package and Unity.

```csharp
using Nova;
using UnityEngine;

public class AdvancedExample : MonoBehaviour
{
    void UseUtilityTypes()
    {
        // MinMax ranges
        MinMax xRange = new MinMax { Min = 0, Max = 100 };
        MinMax2 xyRange = new MinMax2
        {
            X = new MinMax { Min = 0, Max = 200 },
            Y = new MinMax { Min = 0, Max = 150 }
        };
        MinMax3 xyzRange = new MinMax3
        {
            X = xRange,
            Y = xRange,
            Z = new MinMax { Min = -10, Max = 10 }
        };

        // Bounds with flexible Length values
        LengthBounds sizeBounds = new LengthBounds
        {
            Min = Length.FixedValue(100),
            Max = Length.Percentage(80)
        };

        LengthRect paddingRect = new LengthRect
        {
            Left = Length.FixedValue(10),
            Right = Length.FixedValue(10),
            Top = Length.FixedValue(5),
            Bottom = Length.FixedValue(5)
        };

        // 2D/3D containers with conversions
        TwoD<float> size2D = new TwoD<float> { X = 100, Y = 200 };
        ThreeD<float> size3D = size2D; // Implicit conversion, Z = 0

        TwoD<Length> lengths2D = new TwoD<Length>
        {
            X = Length.FixedValue(100),
            Y = Length.Percentage(50)
        };

        // Grid utilities
        GridIndex cellIndex = new GridIndex(row: 3, column: 5);
        GridSlice slice = new GridSlice { Index = 0, Count = 10 };
        GridSlice2D slice2D = new GridSlice2D { Rows = slice, Columns = slice };
        GridSlice3D slice3D = new GridSlice3D
        {
            Rows = slice,
            Columns = slice,
            Depth = slice
        };

        // Axis indexing
        AxisIndex xAxis = AxisIndex.X;
        AxisIndex yAxis = AxisIndex.Y;
        AxisIndex zAxis = AxisIndex.Z;
    }

    void ConfigureAdvancedLayout()
    {
        UIBlock container = GetComponent<UIBlock>();

        // Cross-axis layout utilities
        var crossLayout = container.GetComponent<CrossLayout>();
        crossLayout.Spacing = Length.FixedValue(10);

        // Min/max size constraints
        MinMaxRect sizeConstraints = new MinMaxRect
        {
            Min = new Vector2(100, 50),
            Max = new Vector2(500, 300)
        };

        container.SizeMinMax = sizeConstraints;

        // Access calculated bounds after layout
        LengthBounds.Calculated calculatedBounds = container.Size.X.Calculated.Bounds;
        Debug.Log($"Final bounds: {calculatedBounds.Min} to {calculatedBounds.Max}");
    }

    void ScreenSpaceUtilities()
    {
        var screenSpace = GetComponent<ScreenSpace>();

        // Convert screen coordinates
        Vector2 screenPos = Input.mousePosition;
        Vector3 worldPos = screenSpace.ScreenToWorld(screenPos);
        Vector2 localPos = screenSpace.ScreenToLocal(screenPos);
    }
}

```

--------------------------------

### Create Rubber Surface (C#)

Source: https://novaui.io/api/Nova.Surface

Creates a new soft rubber surface with default or specified smoothness, metallic, shadow casting, and shadow receiving properties. This method uses the Standard lighting model.

```csharp
public static Surface Rubber(float smoothness = 0.4F, float metallic = 0F, ShadowCastingMode shadowCasting = ShadowCastingMode.Off, bool receiveShadows = false)
```

--------------------------------

### Create Rubber Surface with Reflection Color (C#)

Source: https://novaui.io/api/Nova.Surface

Creates a new soft rubber surface with a specified reflection color, along with customizable smoothness, metallic, shadow casting, and shadow receiving properties. This method uses the StandardSpecular lighting model.

```csharp
public static Surface Rubber(Color reflectionColor, float smoothness = 0.4F, float metallic = 0F, ShadowCastingMode shadowCasting = ShadowCastingMode.Off, bool receiveShadows = false)
```

--------------------------------

### Sphere Constructor (SphereCollider)

Source: https://novaui.io/api/Nova.Sphere

Creates a Sphere in world space from a UnityEngine.SphereCollider.

```APIDOC
## Sphere(SphereCollider)

### Description
Create a Sphere in world space from a UnityEngine.SphereCollider. Because the new Sphere is in world space, this constructor reads from `collider`.UnityEngine.Collider.bounds.

### Method
`public Sphere(SphereCollider collider)`

### Parameters
#### Path Parameters
* None

#### Query Parameters
* None

#### Request Body
* **collider** (SphereCollider) - Required - The collider to read from.

### Request Example
```json
{
  "collider": {"bounds": {"center": {"x": 0.0, "y": 0.0, "z": 0.0}, "extents": {"x": 0.5, "y": 0.5, "z": 0.5}}}
}
```

### Response
#### Success Response (200)
* **Sphere** (object) - The newly created sphere object in world space.

#### Response Example
```json
{
  "center": {"x": 0.0, "y": 0.0, "z": 0.0},
  "radius": 1.0
}
```
```

--------------------------------

### POST /Surface/Rubber (With Reflection Color)

Source: https://novaui.io/api/Nova.Surface

Creates a new, soft rubber surface with a specified specular reflection color. Uses the StandardSpecular lighting model.

```APIDOC
## POST /Surface/Rubber (With Reflection Color)

### Description
Creates a new, soft rubber surface with a given specular reflection color, using the StandardSpecular lighting model.

### Method
POST

### Endpoint
/Surface/Rubber

### Parameters
#### Query Parameters
- **reflectionColor** (Color) - Required - The hue of the surface's specular reflections.
- **smoothness** (float) - Optional - The Smoothness parameter. Defaults to 0.4.
- **metallic** (float) - Optional - The Metallic parameter. Defaults to 0.
- **shadowCasting** (ShadowCastingMode) - Optional - Value for ShadowCastingMode. Defaults to ShadowCastingMode.Off.
- **receiveShadows** (bool) - Optional - Value for ReceiveShadows. Defaults to false.

### Request Example
```json
{
  "reflectionColor": "#FF0000",
  "smoothness": 0.4,
  "metallic": 0.0,
  "shadowCasting": "Off",
  "receiveShadows": false
}
```

### Response
#### Success Response (200)
- **Surface** (object) - A new Surface object with a mostly matte, non-metallic effect.

#### Response Example
```json
{
  "type": "Surface",
  "reflectionColor": "#FF0000",
  "smoothness": 0.4,
  "metallic": 0.0,
  "shadowCasting": "Off",
  "receiveShadows": false
}
```
```

--------------------------------

### Sphere Constructor (Vector3, float)

Source: https://novaui.io/api/Nova.Sphere

Creates a new sphere using a center position and a radius.

```APIDOC
## Sphere(Vector3, float)

### Description
Create a new sphere from a center position and radius.

### Method
`public Sphere(Vector3 center, float radius)`

### Parameters
#### Path Parameters
* None

#### Query Parameters
* None

#### Request Body
* **center** (Vector3) - Required - The center position of the sphere.
* **radius** (float) - Required - The radius of the sphere.

### Request Example
```json
{
  "center": {"x": 0.0, "y": 0.0, "z": 0.0},
  "radius": 1.0
}
```

### Response
#### Success Response (200)
* **Sphere** (object) - The newly created sphere object.

#### Response Example
```json
{
  "center": {"x": 0.0, "y": 0.0, "z": 0.0},
  "radius": 1.0
}
```
```

--------------------------------

### Create Sphere with Center and Radius (C#)

Source: https://novaui.io/api/Nova.Sphere

Constructs a new Sphere object by providing its center position as a Vector3 and its radius as a float. This is the primary method for defining a sphere geometrically.

```csharp
public Sphere(Vector3 center, float radius)
```

--------------------------------

### Define Custom Fade Animation with Events (C#)

Source: https://context7.com/context7/novaui_io-api/llms.txt

Defines a custom struct `FadeAnimation` implementing `IAnimationWithEvents` for animating the color of a `UIBlock2D`. It includes lifecycle methods `OnStart`, `OnComplete`, and `OnCancel` for event handling.

```csharp
using Nova;
using UnityEngine;

public struct FadeAnimation : IAnimationWithEvents
{
    public UIBlock2D Block;
    public Color StartColor;
    public Color EndColor;

    public void Update(float percentDone)
    {
        Block.Color = Color.Lerp(StartColor, EndColor, percentDone);
    }

    public void OnStart()
    {
        Debug.Log("Animation started");
    }

    public void OnComplete()
    {
        Debug.Log("Animation completed");
    }

    public void OnCancel()
    {
        Debug.Log("Animation canceled");
    }
}
```

--------------------------------

### ItemView.TryGetVisuals API

Source: https://novaui.io/api/Nova.ItemView

Retrieves visuals associated with an item, attempting to cast them to a specified type.

```APIDOC
## ItemView.TryGetVisuals

### Description
Retrieve Visuals as type `T`.

### Method
`public bool TryGetVisuals<T>(out T visuals)`

### Endpoint
N/A (This appears to be a method signature from a library, not a REST API endpoint.)

### Parameters
#### Type Parameters
- **T** (type) - The type to cast, must inherit from ItemVisuals.

#### Output Parameters
- **visuals** (T) - Visuals casted to type `T`, if it can be casted.

### Returns
- **bool** - `false` if Visuals is not of type `T`.

### Type Parameters
- **T** (type) - The type to cast, must inherit from ItemVisuals.

### Example
```csharp
ItemVisuals myVisuals;
if (itemView.TryGetVisuals<SpecificVisuals>(out myVisuals))
{
    // Use myVisuals
}
```
```

--------------------------------

### Retrieve Visuals by Type (C#)

Source: https://novaui.io/api/Nova.ItemView

The TryGetVisuals<T> method attempts to retrieve the visuals associated with an item, casting them to the specified generic type T. It returns true if the cast is successful and false otherwise. The type T must inherit from ItemVisuals.

```csharp
public bool TryGetVisuals<T>(out T visuals)
    where T : ItemVisuals
```

--------------------------------

### Access GridList Item by Row and Column (C#)

Source: https://novaui.io/api/Nova.GridList-1

Retrieves an element from the GridList<T> using its row and column indices. This requires the grid to be properly initialized. An exception is thrown if the grid is not constructed.

```csharp
public readonly T this[int row, int column] { get; }
```

--------------------------------

### Include<U>(AnimationHandle, U, float, int)

Source: https://novaui.io/api/Nova.AnimationHandleWithEventsExtensions

Runs a new animation simultaneously with an existing animation handle, allowing explicit control over duration and iterations.

```APIDOC
## Include<U>(AnimationHandle, U, float, int)

### Description
Runs the provided `animation` simultaneously with the animation represented by this `handle`.

### Method
`public static AnimationHandle Include<U>(this AnimationHandle handle, U animation, float durationInSeconds, int iterations = 1)
    where U : struct, IAnimationWithEvents`

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **handle** (AnimationHandle) - Required - The handle of the animation to combine `animation` with
- **animation** (U) - Required - The new animation to combine with the animation tied to `handle`
- **durationInSeconds** (float) - Required - The duration, in seconds, to run this new `animation`
- **iterations** (int) - Optional - The number of times to run `animation` before removing it from the animation queue (defaults to 1)

### Request Example
```json
{
  "handle": "...",
  "animation": "...",
  "durationInSeconds": 2.5,
  "iterations": 3
}
```

### Response
#### Success Response (200)
- **AnimationHandle** (AnimationHandle) - An AnimationHandle representing this new animation combination.

#### Response Example
```json
{
  "handle": "..."
}
```

### Type Parameters
- **U**: Not specified in the provided documentation.
```

--------------------------------

### AxisIndex.TryGetIndex

Source: https://novaui.io/api/Nova.AxisIndex

Provides an extension method to safely convert an Axis (X, Y, Z) to its integer index.

```APIDOC
## AxisIndex.TryGetIndex

### Description
Extension to convert an Axis to an index when applicable. This method attempts to retrieve the integer index corresponding to an Axis value (X, Y, or Z).

### Method
`bool TryGetIndex(Axis axis, out int index)`

### Parameters
#### Path Parameters
* None

#### Query Parameters
* None

#### Request Body
* None

### Request Example
* Not applicable for this extension method.

### Response
#### Success Response (true)
* **index** (int) - The integer index of the `axis` if it's X, Y, or Z.

#### Success Response (false)
* **index** (int) - The value of `index` is undefined when the method returns false.

#### Response Example
```json
{
  "success": true,
  "index": 0 
}
```

```json
{
  "success": false
}
```
```

--------------------------------

### Interaction.SphereCollideAll

Source: https://novaui.io/api/Nova.Interaction

Performs a sphere collision against all active UIBlocks in the scene and populates a list with UIBlockHits for all UIBlocks colliding with the provided sphere. This is handled by the Nova Input System.

```APIDOC
## Interaction.SphereCollideAll

### Description
Performs a sphere collision against all active UIBlocks in the scene and populates the provided list with UIBlockHits for all UIBlocks colliding with the provided `sphere`. This operation is performed by the Nova Input System and is independent of Unity's physics systems.

### Method
`public static void`

### Endpoint
`Interaction.SphereCollideAll`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
// Example usage (conceptual, as this is a static method call)
Sphere mySphere = new Sphere(new Vector3(0, 0, 0), 1.0f);
List<UIBlockHit> collisionHits = new List<UIBlockHit>();
int layerMask = -1; // All layers

Interaction.SphereCollideAll(mySphere, collisionHits, layerMask);
```

### Response
#### Success Response (void)
This method does not return a value directly but populates the `hitsToPopulate` list.

- **hitsToPopulate** (List<UIBlockHit>) - The list provided as an argument, populated with `UIBlockHit` objects for all colliding UI blocks, sorted by rendering order (top-most first).

#### Response Example
```json
// The hitsToPopulate list would be modified in place. Example content:
[
  {
    "uiBlock": "<UIBlock Object>",
    "distance": 0.5,
    "normal": "<Vector3>"
  },
  {
    "uiBlock": "<Another UIBlock Object>",
    "distance": 1.2,
    "normal": "<Vector3>"
  }
]
```

### Exceptions
- **System.ArgumentNullException**: Thrown if the `hitsToPopulate` argument is null.
```

--------------------------------

### Include<T>(AnimationHandle, T)

Source: https://novaui.io/api/Nova.AnimationHandleWithEventsExtensions

Runs a new animation simultaneously with an existing animation handle. The new animation inherits duration and iterations from the existing handle.

```APIDOC
## Include<T>(AnimationHandle, T)

### Description
Runs the provided `animation` simultaneously with the animation represented by this `handle`. The new `animation` will inherit duration and iterations from the already scheduled animation.

### Method
`public static AnimationHandle Include<T>(this AnimationHandle handle, T animation)
    where T : struct, IAnimationWithEvents`

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **handle** (AnimationHandle) - Required - The handle of the animation to combine `animation` with
- **animation** (T) - Required - The new animation to combine with the animation tied to `handle`

### Request Example
```json
{
  "handle": "...",
  "animation": "..."
}
```

### Response
#### Success Response (200)
- **AnimationHandle** (AnimationHandle) - An AnimationHandle representing this new animation combination.

#### Response Example
```json
{
  "handle": "..."
}
```

### Type Parameters
- **T**: The type of the new `animation` struct
```

--------------------------------

### UIBlock3D.CornerRadius API

Source: https://novaui.io/api/Nova.UIBlock3D

Documentation for the CornerRadius property of UIBlock3D, which configures the radius of all eight corners.

```APIDOC
## UIBlock3D.CornerRadius

### Description
The Length configuration used to calculate a corner radius, applies to all eight corners of the body's front and back faces (XY planes).

### Remarks
CornerRadius.Percent is relative to half the minimum dimension (X or Y) of CalculatedSize. Mathematically speaking:  
`float calculatedCornerRadius = CornerRadius.Percent * 0.5f * Mathf.Min(CalculatedSize.X.Value, CalculatedSize.Y.Value)`

### Declaration
```csharp
public ref Length CornerRadius { get; }
```
```

--------------------------------

### Queue Animation to Loop (C#)

Source: https://novaui.io/api/Nova.IAnimationWithEventsExtensions

Queues an animation to loop a specified number of times or indefinitely. The animation plays for a given duration per iteration. Returns an AnimationHandle to manage the animation. Throws ArgumentException if durationInSeconds is invalid.

```csharp
public static AnimationHandle Loop<T>(this T animation, float durationInSeconds, int iterations = -1)
    where T : struct, IAnimationWithEvents
```

--------------------------------

### Create Sphere from Unity SphereCollider (C#)

Source: https://novaui.io/api/Nova.Sphere

Creates a Sphere object in world space based on an existing UnityEngine.SphereCollider. This constructor extracts sphere data from the collider's bounds, useful for physics interactions.

```csharp
public Sphere(SphereCollider collider)
```

--------------------------------

### Include Animation Simultaneously (Generic)

Source: https://novaui.io/api/Nova.AnimationHandleWithEventsExtensions

Runs a new animation simultaneously with an existing one, inheriting its duration and iterations. Requires the animation type `T` to implement `IAnimationWithEvents`.

```csharp
public static AnimationHandle Include<T>(this AnimationHandle handle, T animation)
    where T : struct, IAnimationWithEvents
{
    // Implementation details
}
```
Tokens:
Raw