UdonSharp

https://udonsharp.docs.vrchat.com
Admin
UdonSharp is a C# compiler that compiles C# code to Udon assembly for creating interactive scripts...
Tokens:23,570
Snippets:200
Trust Score:9.9
Update:7 months ago
Show doc for...
Tokens:
Raw
### Get All Players with UdonSharp

Source: https://udonsharp.docs.vrchat.com/examples

An example UdonSharp script demonstrating how to retrieve all players currently in the VRChat instance. It uses VRCPlayerApi.GetPlayers and logs their display names.

```csharp
using UdonSharp;
using UnityEngine;
using VRC.SDKBase;

public class GetPlayersExample : UdonSharpBehaviour
{
    // World capacity is 10, so we create a new array with length of 20 (Hard cap)
    VRCPlayerApi[] players = new VRCPlayerApi[20];

    void Start()
    {
        VRCPlayerApi.GetPlayers(players);

        foreach(VRCPlayerApi player in players) {
            if(player == null) continue;
            Debug.Log(player.displayName);
        }
    }
}
```

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

### UdonSharp Script Communication Example

Source: https://udonsharp.docs.vrchat.com/examples

This UdonSharp example illustrates how one UdonSharp behaviour can communicate with another, including accessing public variables and sending custom events. It covers local and network events.

```csharp
using UdonSharp;
using UnityEngine;
using VRC.SDKBase;
using VRC.Udon.Common.Interfaces;

namespace UdonSharpExample
{
    public class Example : UdonSharpBehaviour
    {
        // UdonSharpBehaviour Class (Affects the Inspector)
        [SerializeField] AnotherExample anotherExample;

        void Start()
        {
            // Same as: anotherExample.GetProgramVariable("publicBoolean");
            if(anotherExample.publicBoolean)
            {
                // Same as: anotherExample.SendCustomEvent("RunMethod");
                anotherExample.RunMethod();
            }
        }

        // VRChat Event
        public override void Interact()
        {
            // Same as: SendCustomEvent("DoStuff");
            DoStuff();
        }

        public void DoStuff()
        {
            // This will be sent to all clients and run locally on each one (including the one sending)
            SendCustomNetworkEvent(NetworkEventTarget.All, "NetworkEventStuff");
        }

        public void NetworkEventStuff()
        {
            // Same as: anotherExample.SetProgramVariable("publicBoolean", false);
            anotherExample.publicBoolean = false;

            // Same as: anotherExample.SendCustomEvent("RunMethod");
            anotherExample.RunMethod();

            anotherExample.SendCustomNetworkEvent(NetworkEventTarget.Owner, "DoOwnerStuff");
        }
    }
}
```

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

### Player Settings with UdonSharp

Source: https://udonsharp.docs.vrchat.com/examples

This UdonSharp script allows modification of local player settings such as jump impulse, walk speed, run speed, and gravity. It requires VRChat SDK base.

```csharp
using UnityEngine;
using UdonSharp;
using VRC.SDKBase;

public class PlayerModSettings : UdonSharpBehaviour
{
    VRCPlayerApi playerApi;

    [Header("Player Settings")]
    [SerializeField] float jumpImpulse = 3;
    [SerializeField] float walkSpeed = 2;
    [SerializeField] float runSpeed = 4;
    [SerializeField] float gravityStrengh = 1;

    void Start()
    {
        playerApi = Networking.LocalPlayer;
        playerApi.SetJumpImpulse(jumpImpulse);
        playerApi.SetWalkSpeed(walkSpeed);
        playerApi.SetRunSpeed(runSpeed);
        playerApi.SetGravityStrength(gravityStrengh);
    }
}
```

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

### Teleport Player with UdonSharp

Source: https://udonsharp.docs.vrchat.com/examples

This UdonSharp script allows a player to teleport to a specified target position and rotation upon interaction. It utilizes VRChat SDK base for teleportation.

```csharp
using UdonSharp;
using UnityEngine;
using VRC.SDKBase;

public class TeleportPlayer : UdonSharpBehaviour
{
    [SerializeField] Transform targetPosition;

    public override void Interact()
    {
        Networking.LocalPlayer.TeleportTo(targetPosition.position,
                                          targetPosition.rotation,
                                          VRC_SceneDescriptor.SpawnOrientation.Default,
                                          false);
    }
}
```

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

### UdonBehaviourSyncMode Attribute Example

Source: https://udonsharp.docs.vrchat.com/udonsharp

Shows how to enforce a specific network synchronization mode for a UdonSharp behaviour using the [UdonBehaviourSyncMode] attribute. This example enforces manual synchronization.

```csharp
[UdonBehaviourSyncMode(BehaviourSyncMode.Manual)]
public class Example : UdonSharpBehaviour
{
}
```

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

### RecursiveMethod Attribute Example

Source: https://udonsharp.docs.vrchat.com/udonsharp

Demonstrates marking a method with the [RecursiveMethod] attribute, allowing it to be safely called recursively on the same behaviour. This example calculates the factorial of a number.

```csharp
[RecursiveMethod]
int Factorial(int input)
{
    if (input == 1)
        return 1;

    return input * Factorial(input - 1);
}
```

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

### Velocity and Position/Rotation

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Methods to set and get the player's velocity, position, and rotation.

```APIDOC
## Velocity and Transform API

### Description
Provides direct control over the player's velocity and allows retrieval of their current position and rotation in the world.

### Methods

#### SetVelocity
- **Method**: PUT
- **Endpoint**: `/player/velocity`
- **Description**: Sets the player's current velocity.
- **Parameters**:
  - **velocity** (Vector3) - Required - The desired velocity vector.

#### GetVelocity
- **Method**: GET
- **Endpoint**: `/player/velocity`
- **Description**: Returns the player's current velocity.
- **Returns**: Vector3 - The current velocity vector.

#### GetPosition
- **Method**: GET
- **Endpoint**: `/player/position`
- **Description**: Returns the player's current world-space position.
- **Returns**: Vector3 - The current position.

#### GetRotation
- **Method**: GET
- **Endpoint**: `/player/rotation`
- **Description**: Returns the player's current world-space rotation.
- **Returns**: Quaternion - The current rotation.
```

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

### Spinning Cube with UdonSharp

Source: https://udonsharp.docs.vrchat.com/examples

A simple UdonSharp script that makes the GameObject continuously rotate around the Y-axis. It uses Unity's Update function and deltaTime for smooth rotation.

```csharp
using UnityEngine;
using UdonSharp;

public class RotatingCubeBehaviour : UdonSharpBehaviour
{
    private void Update()
    {
        transform.Rotate(Vector3.up, 90f * Time.deltaTime);
    }
}
```

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

### VRCObjectPool: Manage GameObjects

Source: https://udonsharp.docs.vrchat.com/vrchat-api

VRCObjectPool manages an array of GameObjects, synchronizing their active state. Use TryToSpawn to get an active object and Return to disable and return it to the pool. Supports OnEnable event listeners and late joiner synchronization.

```csharp
public class VRCObjectPool : UdonSharpBehaviour
{
    public GameObject[] Pool;

    public GameObject TryToSpawn()
    {
        // Implementation details for spawning an object from the pool
        return null; // Placeholder
    }

    public void Return(GameObject obj)
    {
        // Implementation details for returning an object to the pool
    }
}
```

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

### Get Player Head Position and Rotation in UdonSharp

Source: https://udonsharp.docs.vrchat.com/frequently-asked-questions

Demonstrates how to retrieve the player's head position and rotation using UdonSharp. This is useful for implementing VR-specific features. It relies on the VRCPlayerApi class.

```csharp
Vector3 headPos = localPlayer.GetTrackingData(TrackingData.Head).position
```

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

### Interactable Object with UdonSharp

Source: https://udonsharp.docs.vrchat.com/examples

A basic UdonSharp script that disables the GameObject when the player interacts with it. This demonstrates the Interact function in UdonSharp.

```csharp
using UnityEngine;
using UdonSharp;

public class ClickMe: UdonSharpBehaviour
{
    public override void Interact()
    {
        gameObject.SetActive(false);
    }
}
```

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

### UdonSynced Attribute Example

Source: https://udonsharp.docs.vrchat.com/udonsharp

Demonstrates how to use the [UdonSynced] attribute to synchronize variables across network instances. It shows basic boolean synchronization and linearly interpolated float synchronization.

```csharp
public class Example : UdonSharpBehaviour
{
    [UdonSynced]
    public bool synchronizedBoolean;

    [UdonSynced(UdonSyncMode.Linear)]
    // This float will be linearly interpolated
    public float synchronizedFloat;
}
```

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

### Get UdonSharp Component(s) in Editor

Source: https://udonsharp.docs.vrchat.com/editor-scripting

Retrieves UdonSharp components from a GameObject or its children. Use GetUdonSharpComponent<T>() for a single component or GetUdonSharpComponentsInChildren<T>() to find all components of a specific type on child GameObjects. These methods automatically update the behavior's proxy.

```csharp
GameObject sourceGameObject = ... // Get some game object from somewhere here
MyComponentType[] myComponents = sourceGameObject.GetUdonSharpComponentsInChildren<MyComponentType>();
```

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

### Get Server Time (Networking)

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Retrieves the current server time in seconds or milliseconds. Also provides a method to calculate the time difference between two server timestamps.

```csharp
// Get current server time in seconds
double serverTimeSeconds = VRC.SDKBase.Networking.GetServerTimeInSeconds();

// Get current server time in milliseconds
int serverTimeMilliseconds = VRC.SDKBase.Networking.GetServerTimeInMilliseconds();

// Calculate time difference
double previousTime = ...;
double deltaTime = VRC.SDKBase.Networking.CalculateServerDeltaTime(serverTimeSeconds, previousTime);

```

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

### FieldChangeCallback Attribute Example

Source: https://udonsharp.docs.vrchat.com/udonsharp

Explains the [FieldChangeCallback] attribute, which allows a specified property's setter to be called instead of directly setting a field when the field is modified via network sync or SetProgramVariable.

```csharp
// Example usage would involve defining a field and a corresponding property
// [FieldChangeCallback("MyProperty")]
// public int myField;
// 
// public int MyProperty
// {
//     set
//     {
//         myField = value;
//         // Additional logic here
//     }
// }
```

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

### Udon Video Events: OnVideoStart

Source: https://udonsharp.docs.vrchat.com/events

The OnVideoStart event is fired when a video begins playing for the first time. This event is distinct from OnVideoPlay and may indicate the initial loading and commencement of playback.

```csharp
public void OnVideoStart() {}
```

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

### Instantiate Local GameObject Copy (VRCInstantiate)

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Creates a local, non-synced copy of a GameObject. This method is useful for instantiating objects that do not require network synchronization. It returns the instantiated GameObject.

```csharp
GameObject original = ...; // The GameObject to instantiate
GameObject instantiatedObject = VRCInstantiate(original);

```

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

### Pickup Component Methods

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Provides methods for controlling pickup objects, including dropping the pickup (with or without specifying an instigator) and generating haptic feedback events for the player's controllers.

```csharp
public void Drop();
public void Drop(VRCPlayerApi instigator);
public void GenerateHapticEvent(float duration, float amplitude, float frequency);
public void PlayHaptics();
```

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

### Bone Data Retrieval

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Methods to get the position and rotation of specific bones in the player's avatar.

```APIDOC
## Bone Data API

### Description
Retrieve precise positional and rotational data for individual bones within the player's avatar.

### Methods

#### GetBonePosition
- **Method**: GET
- **Endpoint**: `/player/bone/{bone}/position`
- **Description**: Returns the world-space position of a specified bone.
- **Parameters**:
  - **bone** (HumanBodyBones) - Required - The bone to get the position for (e.g., `LeftShoulder`, `RightKnee`).
- **Returns**: Vector3 - The position of the bone.

#### GetBoneRotation
- **Method**: GET
- **Endpoint**: `/player/bone/{bone}/rotation`
- **Description**: Returns the world-space rotation of a specified bone.
- **Parameters**:
  - **bone** (HumanBodyBones) - Required - The bone to get the rotation for (e.g., `Head`, `Spine`).
- **Returns**: Quaternion - The rotation of the bone.
```

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

### Input Manager

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Static methods for managing user input, checking controller status, and enabling object highlighting.

```APIDOC
## Input Manager

### Description
Static methods for managing user input, checking controller status, and enabling object highlighting.

### IsUsingHandController

#### Method
bool

#### Endpoint
`VRC.SDKBase.InputManager.IsUsingHandController()`

#### Summary
Returns whether or not the user is using a hand controller.

### GetLastUsedInputMethod

#### Method
VRCInputMethod

#### Endpoint
`VRC.SDKBase.InputManager.GetLastUsedInputMethod()`

#### Summary
Returns the last input method used, or `VRCInputMethod.Count` if no input method was found.

### EnableObjectHighlight (GameObject)

#### Method
void

#### Endpoint
`VRC.SDKBase.InputManager.EnableObjectHighlight(GameObject obj, bool enable)`

#### Parameters
- **obj** (GameObject) - Required - The GameObject to enable or disable highlighting for.
- **enable** (bool) - Required - True to enable highlighting, false to disable.

### EnableObjectHighlight (Renderer)

#### Method
void

#### Endpoint
`VRC.SDKBase.InputManager.EnableObjectHighlight(Renderer r, bool enable)`

#### Parameters
- **r** (Renderer) - Required - The Renderer to enable or disable highlighting for.
- **enable** (bool) - Required - True to enable highlighting, false to disable.
```

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

### Locomotion and Physics Settings

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Methods to adjust player movement speed, jump impulse, gravity, and immobilization.

```APIDOC
## Locomotion and Physics API

### Description
Fine-tune player movement parameters including run speed, walk speed, strafe speed, jump impulse, and gravity. Also includes options for immobilization and legacy locomotion.

### Methods

#### SetRunSpeed
- **Method**: PUT
- **Endpoint**: `/player/speed/run`
- **Description**: Sets the player's run speed.
- **Parameters**:
  - **speed** (float) - Required - The desired run speed.

#### SetWalkSpeed
- **Method**: PUT
- **Endpoint**: `/player/speed/walk`
- **Description**: Sets the player's walk speed.
- **Parameters**:
  - **speed** (float) - Required - The desired walk speed.

#### SetJumpImpulse
- **Method**: PUT
- **Endpoint**: `/player/jump/impulse`
- **Description**: Sets the player's jump impulse force.
- **Parameters**:
  - **impulse** (float) - Required - The desired jump impulse.

#### SetGravityStrength
- **Method**: PUT
- **Endpoint**: `/player/physics/gravity`
- **Description**: Sets the player's gravity strength.
- **Parameters**:
  - **strength** (float) - Required - The desired gravity strength.

#### SetStrafeSpeed
- **Method**: PUT
- **Endpoint**: `/player/speed/strafe`
- **Description**: Sets the player's strafe speed. The default is 2.0f.
- **Parameters**:
  - **speed** (float) - Required - The desired strafe speed.

#### GetRunSpeed
- **Method**: GET
- **Endpoint**: `/player/speed/run`
- **Description**: Returns the current run speed value.
- **Returns**: float - The current run speed.

#### GetWalkSpeed
- **Method**: GET
- **Endpoint**: `/player/speed/walk`
- **Description**: Returns the current walk speed value.
- **Returns**: float - The current walk speed.

#### GetJumpImpulse
- **Method**: GET
- **Endpoint**: `/player/jump/impulse`
- **Description**: Returns the current jump impulse value.
- **Returns**: float - The current jump impulse.

#### GetGravityStrength
- **Method**: GET
- **Endpoint**: `/player/physics/gravity`
- **Description**: Returns the current gravity strength value.
- **Returns**: float - The current gravity strength.

#### GetStrafeSpeed
- **Method**: GET
- **Endpoint**: `/player/speed/strafe`
- **Description**: Returns the player's current strafe speed.
- **Returns**: float - The current strafe speed.

#### UseLegacyLocomotion
- **Method**: PUT
- **Endpoint**: `/player/locomotion/legacy`
- **Description**: Switches the player's locomotion system to the older, legacy system.

#### Immobilize
- **Method**: PUT
- **Endpoint**: `/player/immobilize`
- **Description**: Prevents the user from moving when set to true.
- **Parameters**:
  - **immobile** (boolean) - Required - True to immobilize, false to allow movement.
```

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

### Player Identification and Retrieval

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Methods for getting player IDs and retrieving player objects by ID or populating player arrays.

```APIDOC
## Player Information API

### Description
Provides methods to get a player's unique instance ID, retrieve a player object using their ID, and fetch an array of all players currently in the instance.

### Methods

#### GetPlayerId
- **Method**: GET
- **Endpoint**: `/player/{playerId}`
- **Description**: Returns the instance ID of a given VRCPlayerApi player.
- **Parameters**:
  - **player** (VRCPlayerApi) - Required - The player object.
- **Returns**: int - The player's instance ID.

#### GetPlayerById
- **Method**: GET
- **Endpoint**: `/player/id/{playerId}`
- **Description**: Returns the VRCPlayerApi object for the player with the specified instance ID.
- **Parameters**:
  - **playerId** (int) - Required - The instance ID of the player.
- **Returns**: VRCPlayerApi - The player object.

#### GetPlayerCount
- **Method**: GET
- **Endpoint**: `/player/count`
- **Description**: Returns the total number of players currently in the instance.
- **Returns**: int - The player count.

#### GetPlayers
- **Method**: GET
- **Endpoint**: `/players`
- **Description**: Populates and returns an array with the current players in the instance. The provided array must be pre-allocated with at least `VRCPlayerApi.GetPlayerCount` elements.
- **Parameters**:
  - **players** (VRCPlayerApi[]) - Required - An array to be populated with player objects.
- **Returns**: VRCPlayerApi[] - The populated array of player objects.
```

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

### Get UdonBehaviour Component

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Fetches an UdonBehaviour component attached to the same GameObject. Note that `GetComponent<T>()` is not supported; use `GetComponent(typeof(UdonBehaviour))` instead.

```csharp
UdonBehaviour behaviour = (UdonBehaviour)GetComponent(typeof(UdonBehaviour));

```

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

### Get Network Object Owner (Networking.GetOwner)

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Retrieves the VRCPlayerApi object that currently owns a given GameObject. This is useful for understanding and managing network object control.

```csharp
GameObject obj = ...;
VRCPlayerApi owner = VRC.SDKBase.Networking.GetOwner(obj);

```

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

### Haptic Feedback and Pickup

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Methods for playing haptic feedback on controllers and retrieving pickup objects.

```APIDOC
## Haptic Feedback and Pickup

### Description
Methods for playing haptic feedback on controllers and retrieving pickup objects.

### PlayHapticEventInHand

#### Method
void

#### Endpoint
N/A (Udon Behaviour Method)

#### Parameters
- **hand** (PickupHand) - Required - The hand to play haptic feedback on.
- **duration** (float) - Required - The duration of the haptic event in seconds.
- **amplitude** (float) - Required - The amplitude of the haptic feedback (0.0 to 1.0).
- **frequency** (float) - Required - The frequency of the haptic feedback.

### GetPickupInHand

#### Method
VRCPickup

#### Endpoint
N/A (Udon Behaviour Method)

#### Parameters
- **hand** (PickupHand) - Required - The hand to retrieve the pickup object from.

#### Returns
- **VRCPickup** - The pickup object associated with the given hand, or null if none is present.
```

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

### Custom Inspector with Unity Editor Directives

Source: https://udonsharp.docs.vrchat.com/editor-scripting

Demonstrates how to create a custom inspector for a UdonSharpBehaviour using Unity's `UNITY_EDITOR` preprocessor directive. This ensures the editor code is excluded from game builds. It also includes the `COMPILER_UDONSHARP` directive to prevent UdonSharp from parsing editor-specific code within the same file.

```csharp
using UnityEngine;
using VRC.SDK3.Components;
using VRC.SDKBase;
using VRC.Udon;

#if !COMPILER_UDONSHARP && UNITY_EDITOR // These using statements must be wrapped in this check to prevent issues on builds
using UnityEditor;
using UdonSharpEditor;
#endif

namespace UdonSharp.Examples.Inspectors
{
    /// <summary>
    /// Example behaviour that has a custom inspector
    /// </summary>
    public class CustomInspectorBehaviour : UdonSharpBehaviour
    {
        public string stringVal;

        private void Update()
        {
            Debug.Log($"CustomInspectorBehaviour: {stringVal}");
        }
    }

    // Editor scripts must be wrapped in a UNITY_EDITOR check to prevent issues while uploading worlds. The !COMPILER_UDONSHARP check prevents UdonSharp from throwing errors about unsupported code here.
#if !COMPILER_UDONSHARP && UNITY_EDITOR 
    [CustomEditor(typeof(CustomInspectorBehaviour))]
    public class CustomInspectorEditor : Editor
    {
        public override void OnInspectorGUI()
        {
            // Draws the default convert to UdonBehaviour button, program asset field, sync settings, etc.
            if (UdonSharpGUI.DrawDefaultUdonSharpBehaviourHeader(target)) return;

            CustomInspectorBehaviour inspectorBehaviour = (CustomInspectorBehaviour)target;

            EditorGUI.BeginChangeCheck();

            // A simple string field modification with Undo handling
            string newStrVal = EditorGUILayout.TextField("String Val", inspectorBehaviour.stringVal);

            if (EditorGUI.EndChangeCheck())
            {
                Undo.RecordObject(inspectorBehaviour, "Modify string val");

                inspectorBehaviour.stringVal = newStrVal;
            }
        }
    }
#endif
}
```

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

### Sending Networked Events via Photon RPCs in UdonSharp

Source: https://udonsharp.docs.vrchat.com/networking-tips-%26-tricks

Illustrates how to send network events using Photon RPCs in UdonSharp. This allows for communication between UdonBehaviours across the network, targeting specific UdonBehaviours or all players.

```csharp
using UdonSharp;
using VRC.SDKBase;

public class EventSender : UdonSharpBehaviour
{
    public UdonBehaviour targetBehaviour;

    public void SendMyEvent() {
        // Send the event to a specific UdonBehaviour
        object[] args = {}; // Arguments for the event
        targetBehaviour.SendCustomEvent("MyNetworkedEvent");

        // Alternatively, send to all players (if this behaviour is networked)
        // SendCustomNetworkedEvent(NetworkEventTarget.All, "MyNetworkedEvent");
    }

    public void MyNetworkedEvent() {
        // Code to execute when the event is received
        Debug.Log("Received MyNetworkedEvent!");
    }
}
```

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

### DefaultExecutionOrder Attribute Example

Source: https://udonsharp.docs.vrchat.com/udonsharp

Illustrates the use of the [DefaultExecutionOrder] attribute to control the execution order of Update, LateUpdate, and FixedUpdate methods relative to other UdonSharp behaviours. A value of 0 is the default.

```csharp
[DefaultExecutionOrder(0)]
public class Example : UdonSharpBehaviour
{
}
```

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

### UdonInputEventArgs

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Contextual data for an input event within Udon.

```APIDOC
## UdonInputEventArgs

### Description
Contextual data for an input event within Udon.

### Properties

#### eventType

- **Type**: UdonInputEventType
- **Summary**: The type of input event that was fired.

#### boolValue

- **Type**: bool
- **Summary**: The value of the input method when an `InputJump`, `InputUse`, `InputGrab` or `InputDrop` event is fired.

#### floatValue

- **Type**: float
- **Summary**: The value of the input method when an `InputMoveHorizontal`, `InputMoveVertical`, `InputLookHorizontal` or `InputLookVertical` event is fired.

#### handType

- **Type**: HandType
- **Summary**: The hand that the input event occurred on. For desktop users, the keyboard is the left hand and the mouse is the right hand.
```

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

### Default Udon Sharp Script Template

Source: https://udonsharp.docs.vrchat.com/configuration

The default template used when creating new Udon Sharp scripts. It includes necessary Unity and VRChat SDK imports and a basic UdonSharpBehaviour structure. The `<TemplateClassName>` placeholder is replaced with the actual file name.

```csharp
using UdonSharp;
using UnityEngine;
using VRC.SDKBase;
using VRC.Udon;

public class <TemplateClassName> : UdonSharpBehaviour
{
    void Start()
    {
          
    }
}


```

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

### Get Player Tracking Data (TrackingData)

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Accesses the tracking data for a player, including their position and rotation. This is typically used for manipulating or observing player movement and orientation.

```csharp
VRCPlayerApi player = ...;
VRC.SDKBase.VRCPlayerApi.TrackingData tracking = player.GetTrackingData(VRC.Data.TrackingDataType.Head);

Vector3 position = tracking.position;
Quaternion rotation = tracking.rotation;

```

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

### Update UdonSharp Gizmo Proxy

Source: https://udonsharp.docs.vrchat.com/editor-scripting

Ensures the Gizmo proxy behavior is up-to-date by calling either UpdateProxy or CopyUdonToProxy. These methods synchronize changes from the UdonSharp script to its proxy, which is necessary for Gizmos to render correctly in the Unity editor.

```csharp
UdonSharpEditorUtility.CopyUdonToProxy(this);
// Or this
this.UpdateProxy();
```

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

### UdonSharp String and Image Loading Events

Source: https://udonsharp.docs.vrchat.com/events

These UdonSharp events facilitate handling the results of asynchronous string and image downloads. Separate events are provided for success and error conditions, allowing scripts to manage loaded data or report loading failures gracefully. The `result` parameter provides details about the download operation.

```csharp
public void OnImageLoadSuccess(IVRCImageDownload result)
{
    // Code to handle successful image downloads
}

public void OnImageLoadError(IVRCImageDownload result)
{
    // Code to handle failed image downloads
}

public void OnStringLoadSuccess(IVRCStringDownload result)
{
    // Code to handle successful string downloads
}

public void OnStringLoadError(IVRCStringDownload result)
{
    // Code to handle failed string downloads
}
```

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

### Udon Input Events: Jump, Use, Grab, Drop

Source: https://udonsharp.docs.vrchat.com/events

These events handle specific user input actions: InputJump for jumping, InputUse for using an item, InputGrab for picking up an item, and InputDrop for dropping an item. They receive a boolean value indicating the state of the input and event arguments.

```csharp
public void InputJump(bool value, VRC.Udon.Common.UdonInputEventArgs args) {}
public void InputUse(bool value, VRC.Udon.Common.UdonInputEventArgs args) {}
public void InputGrab(bool value, VRC.Udon.Common.UdonInputEventArgs args) {}
public void InputDrop(bool value, VRC.Udon.Common.UdonInputEventArgs args) {}
```

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

### Udon Update Events: PostLateUpdate

Source: https://udonsharp.docs.vrchat.com/events

The PostLateUpdate event is fired near the end of each frame after Inverse Kinematics (IK) calculations. This is the optimal time to retrieve bone positions for the most accurate, up-to-date data, avoiding a one-frame delay.

```csharp
public void PostLateUpdate() {}
```

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

### Udon Video Events: Playback Control

Source: https://udonsharp.docs.vrchat.com/events

These events manage video playback within VRChat. OnVideoPlay is triggered when video playback starts, OnVideoPause when it's paused, and OnVideoEnd when playback finishes. OnVideoLoop fires if looping is enabled.

```csharp
public void OnVideoPlay() {}
public void OnVideoPause() {}
public void OnVideoEnd() {}
public void OnVideoLoop() {}
```

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

### Ownership and Tracking

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Methods to check ownership of GameObjects and retrieve tracking data.

```APIDOC
## Ownership and Tracking API

### Description
These methods allow you to determine if a player owns a specific GameObject and to retrieve various types of tracking data for the player.

### Methods

#### IsOwner
- **Method**: GET
- **Endpoint**: `/object/{objectId}/owner`
- **Description**: Checks if the current player is the owner of a GameObject that has a UdonBehaviour component.
- **Parameters**:
  - **obj** (GameObject) - Required - The GameObject to check ownership for.
- **Returns**: boolean - True if the player is the owner, false otherwise.

#### GetTrackingData
- **Method**: GET
- **Endpoint**: `/player/tracking/{trackingType}`
- **Description**: Returns the tracking data for the specified type.
- **Parameters**:
  - **tt** (TrackingDataType) - Required - The type of tracking data to retrieve (e.g., Head, LeftHand, RightHand).
- **Returns**: TrackingData - The tracking data for the specified type.
```

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

### Udon Video Events: Loading and Errors

Source: https://udonsharp.docs.vrchat.com/events

These events handle the video loading process and potential errors. OnVideoReady is called when the video player has successfully loaded the URL, and OnVideoError is triggered if any error occurs during playback or loading.

```csharp
public void OnVideoReady() {}
public void OnVideoError(VideoError videoError) {}
```

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

### Unity MonoBehaviour Events for UdonSharp

Source: https://udonsharp.docs.vrchat.com/events

These are standard Unity MonoBehaviour event methods that can be implemented in UdonSharp scripts. They provide hooks into various stages of the Unity engine's lifecycle, such as physics updates, rendering, and object interactions. Refer to the Unity MonoBehaviour documentation for detailed explanations of each event.

```csharp
// Example Unity Events available in UdonSharp

public void FixedUpdate()
{
    // Called every fixed framerate frame
}

public void Start()
{
    // Called on the frame when a script is enabled just before any of the Update methods are called the first time
}

public void Update()
{
    // Called every frame
}

public void OnCollisionEnter(Collision collision)
{
    // Called when this collider/rigidbody has begun touching another rigidbody/collider
}

public void OnTriggerEnter(Collider other)
{
    // Called when the Collider other enters the trigger.
}
```

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

### Udon Player Events: Join, Leave, Respawn

Source: https://udonsharp.docs.vrchat.com/events

These events track player status changes within an instance. OnPlayerJoined is fired when a new player enters, OnPlayerLeft when a player leaves, and OnPlayerRespawn when a player respawns.

```csharp
public void OnPlayerJoined(VRCPlayerApi player) {}
public void OnPlayerLeft(VRCPlayerApi player) {}
public void OnPlayerRespawn(VRCPlayerApi player) {}
```

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

### Transferring GameObject Ownership in UdonSharp

Source: https://udonsharp.docs.vrchat.com/networking-tips-%26-tricks

Demonstrates how to manually transfer ownership of a GameObject to a specific player using UdonSharp's networking capabilities. This is crucial for managing networked object interactions.

```csharp
using UdonSharp;
using VRC.SDKBase;

public class NetworkedObject : UdonSharpBehaviour
{
    public override void Interact() {
        // Get the player interacting with the object
        VRCPlayerApi localPlayer = Networking.LocalPlayer;
        
        // Transfer ownership to the local player
        Networking.SetOwner(localPlayer, gameObject);
    }
}
```

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

### Modify and Apply UdonSharp Behaviour Changes

Source: https://udonsharp.docs.vrchat.com/editor-scripting

Modifies an existing UdonSharp behaviour and applies those changes. First, update the proxy if you are holding a persistent reference using UpdateProxy(). Then, make your modifications to the component's fields. Finally, call ApplyProxyModifications() to synchronize these changes back to the Udon behaviour.

```csharp
MyComponentType myComponent = ...
// We only need to update the proxy if we storing some persistent reference to it
myComponent.UpdateProxy();
// Add 5 to a `float` on our behaviour
myComponent.myFloatField += 5f;
// Apply the changes to myComponent to the Udon copy of it
myComponent.ApplyProxyModifications();
```

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

### Station Interaction

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Method to make the player sit on an attached VRC Station.

```APIDOC
## Station Interaction API

### Description
Allows the player to interact with and sit on a VRC Station component attached to the same GameObject.

### Method

#### UseAttachedStation
- **Method**: POST
- **Endpoint**: `/player/station/use`
- **Description**: Sits the player down on the VRC Station associated with the current GameObject. Requires a `VRC_Station` component on the same GameObject.

### Parameters
None

### Response
None (void)
```

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

### Udon Input Events

Source: https://udonsharp.docs.vrchat.com/events

Events triggered by user input actions.

```APIDOC
## Udon Input Events

### Description
Events that are triggered by various user input actions, such as interacting with objects, jumping, using items, grabbing, moving, and looking.

### Method
`override`

### Endpoint
N/A (These are method overrides within UdonSharpBehaviour)

### Parameters
- **Interact()**: No parameters.
- **InputJump(bool value, VRC.Udon.Common.UdonInputEventArgs args)**: `value` (bool) - Indicates if the jump input is active. `args` (VRC.Udon.Common.UdonInputEventArgs) - Event arguments.
- **InputUse(bool value, VRC.Udon.Common.UdonInputEventArgs args)**: `value` (bool) - Indicates if the use input is active. `args` (VRC.Udon.Common.UdonInputEventArgs) - Event arguments.
- **InputGrab(bool value, VRC.Udon.Common.UdonInputEventArgs args)**: `value` (bool) - Indicates if the grab input is active. `args` (VRC.Udon.Common.UdonInputEventArgs) - Event arguments.
- **InputDrop(bool value, VRC.Udon.Common.UdonInputEventArgs args)**: `value` (bool) - Indicates if the drop input is active. `args` (VRC.Udon.Common.UdonInputEventArgs) - Event arguments.
- **InputMoveHorizontal(float value, VRC.Udon.Common.UdonInputEventArgs args)**: `value` (float) - Horizontal movement input value. `args` (VRC.Udon.Common.UdonInputEventArgs) - Event arguments.
- **InputMoveVertical(float value, VRC.Udon.Common.UdonInputEventArgs args)**: `value` (float) - Vertical movement input value. `args` (VRC.Udon.Common.UdonInputEventArgs) - Event arguments.
- **InputLookHorizontal(float value, VRC.Udon.Common.UdonInputEventArgs args)**: `value` (float) - Horizontal look input value. `args` (VRC.Udon.Common.UdonInputEventArgs) - Event arguments.
- **InputLookVertical(float value, VRC.Udon.Common.UdonInputEventArgs args)**: `value` (float) - Vertical look input value. `args` (VRC.Udon.Common.UdonInputEventArgs) - Event arguments.

### Request Example
```csharp
public override void Interact() {
    // Handle interaction
}

public override void InputJump(bool value, VRC.Udon.Common.UdonInputEventArgs args) {
    // Handle jump input
}
```

### Response
#### Success Response (N/A)
These are method overrides, not API endpoints with direct responses.

#### Response Example
N/A
```

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

### Drawing Default UdonSharp Inspector Header

Source: https://udonsharp.docs.vrchat.com/editor-scripting

Illustrates the essential first step in a custom UdonSharp inspector's `OnInspectorGUI` method. Calling `UdonSharpGUI.DrawDefaultUdonSharpBehaviourHeader(target)` draws the standard UdonSharp header elements and returns `true` if the header was drawn, allowing for early exit.

```csharp
if (UdonSharpGUI.DrawDefaultUdonSharpBehaviourHeader(target)) return;
```

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

### Udon Input Events: Movement and Look

Source: https://udonsharp.docs.vrchat.com/events

These events capture analog input for player movement and camera control. InputMoveHorizontal and InputMoveVertical handle forward/backward and left/right movement, while InputLookHorizontal and InputLookVertical manage horizontal and vertical camera rotation.

```csharp
public void InputMoveHorizontal(float value, VRC.Udon.Common.UdonInputEventArgs args) {}
public void InputMoveVertical(float value, VRC.Udon.Common.UdonInputEventArgs args) {}
public void InputLookHorizontal(float value, VRC.Udon.Common.UdonInputEventArgs args) {}
public void InputLookVertical(float value, VRC.Udon.Common.UdonInputEventArgs args) {}
```

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

### VRCPortalMarker Component

Source: https://udonsharp.docs.vrchat.com/vrchat-api

A component used to create portals to other rooms in VRChat. It allows setting the destination room ID and refreshing the portal's appearance.

```csharp
public string roomId;
public void RefreshPortal();
```

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

### Using Synced Variables in UdonSharp for Networked Data

Source: https://udonsharp.docs.vrchat.com/networking-tips-%26-tricks

Shows how to declare and use synced variables in UdonSharp to synchronize data across the network. These variables are updated by the owner and are subject to VRChat's data restrictions.

```csharp
using UdonSharp;
using VRC.SDKBase;

public class SyncedData : UdonSharpBehaviour
{
    [UdonSynced]
    public int playerScore = 0;

    [UdonSynced]
    public string playerName = "Guest";

    public override void OnDeserialization()
    {
        // This function is called when synced variables are received
        Debug.Log($"Player {playerName} has score: {playerScore}");
    }

    public void UpdateScore(int newScore)
    {
        if (Networking.IsOwner(gameObject))
        {
            playerScore = newScore;
            RequestSerialization(); // Request to send the updated variable
        }
    }

    public void UpdateName(string newName)
    {
        if (Networking.IsOwner(gameObject))
        {
            playerName = newName;
            RequestSerialization(); // Request to send the updated variable
        }
    }
}
```

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

### Pickup and Tag Management

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Methods to enable/disable player interaction with pickups and manage player-specific tags.

```APIDOC
## Pickup and Tagging API

### Description
Control player interaction with world pickups and assign custom string tags to players for identification or state management.

### Methods

#### EnablePickup
- **Method**: PUT
- **Endpoint**: `/player/pickup/enable`
- **Description**: Enables or disables the player's ability to interact with pickups. (_Note: Requires testing_).
- **Parameters**:
  - **enable** (boolean) - Required - True to enable pickups, false to disable.

#### SetPlayerTag
- **Method**: POST
- **Endpoint**: `/player/tag/{tagName}`
- **Description**: Assigns a string value to a player tag. Player tags are not synchronized to remote clients.
- **Parameters**:
  - **tagName** (string) - Required - The name of the tag.
  - **tagValue** (string) - Required - The value to assign to the tag.

#### GetPlayerTag
- **Method**: GET
- **Endpoint**: `/player/tag/{tagName}`
- **Description**: Retrieves the value of a specified player tag. Assigning a null value clears the tag.
- **Parameters**:
  - **tagName** (string) - Required - The name of the tag to retrieve.
- **Returns**: string - The value of the tag, or null if not set.

#### ClearPlayerTags
- **Method**: DELETE
- **Endpoint**: `/player/tags`
- **Description**: Clears all assigned tags for the current player.
```

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

### Check Network Ownership (Networking.IsOwner)

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Verifies if a specific player or the local player is the owner of a given GameObject. Ownership is crucial for network synchronization and controlling object states.

```csharp
GameObject obj = ...;
VRCPlayerApi player = Networking.LocalPlayer;

// Check if local player is owner
bool isLocalOwner = VRC.SDKBase.Networking.IsOwner(obj);

// Check if a specific player is owner
bool isSpecificOwner = VRC.SDKBase.Networking.IsOwner(player, obj);

```

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

### Avatar Audio Settings

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Methods for configuring how avatar audio is heard by other players, including radius and spatialization settings.

```APIDOC
## Avatar Audio Settings

### Description
Methods for configuring how avatar audio is heard by other players, including radius and spatialization settings.

### SetAvatarAudioNearRadius

#### Method
void

#### Endpoint
N/A (Udon Behaviour Method)

#### Parameters
- **distance** (float) - Required - The minimum distance at which the avatar's audio starts to be heard.

### SetAvatarAudioFarRadius

#### Method
void

#### Endpoint
N/A (Udon Behaviour Method)

#### Parameters
- **distance** (float) - Required - The maximum distance at which the avatar's audio can be heard.

### SetAvatarAudioVolumetricRadius

#### Method
void

#### Endpoint
N/A (Udon Behaviour Method)

#### Parameters
- **radius** (float) - Required - The radius around the avatar that its audio source appears to emanate from.

### SetAvatarAudioForceSpatial

#### Method
void

#### Endpoint
N/A (Udon Behaviour Method)

#### Parameters
- **force** (bool) - Required - If true, enables spatialization for avatar audio sources and sets spatialBlend to 1, preventing 2D audio.

### SetAvatarAudioCustomCurve

#### Method
void

#### Endpoint
N/A (Udon Behaviour Method)

#### Parameters
- **allow** (bool) - Required - Sets whether avatar audio sources can use a pre-configured custom curve.
```

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

### VRCPickup: Enable Object Pickup

Source: https://udonsharp.docs.vrchat.com/vrchat-api

VRCPickup is a component that enables the functionality for objects to be picked up and held by players in VRChat.

```csharp
using VRC.SDK3.Components;

public class VRCPickup : UdonSharpBehaviour
{
    // Component properties and methods for pickup functionality
}
```

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

### Conditional Editor Code Inclusion

Source: https://udonsharp.docs.vrchat.com/editor-scripting

Shows how to conditionally include editor-specific code using preprocessor directives. The `#if UNITY_EDITOR` block ensures that the code within it is only compiled when running in the Unity Editor, preventing build errors.

```csharp
#if UNITY_EDITOR  
[CustomEditor(typeof(CustomInspectorBehaviour))]  
public class CustomInspectorEditor : Editor  
{
    // Editor-specific code here
}
#endif
```

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

### Udon Update Events

Source: https://udonsharp.docs.vrchat.com/events

Events related to frame updates and IK calculations.

```APIDOC
## Udon Update Events

### Description
Events fired during the frame update process, particularly useful for accessing up-to-date bone positions after IK calculations.

### Method
`override`

### Endpoint
N/A (These are method overrides within UdonSharpBehaviour)

### Parameters
None

### Request Example
```csharp
public override void PostLateUpdate() {
    // Your code here
}
```

### Response
#### Success Response (N/A)
This is a method override, not an API endpoint with a direct response.

#### Response Example
N/A
```

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

### Station Usage (VRCStation)

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Manages player interaction with VRChat stations. Allows players to use and exit stations, with properties to control player mobility, station switching, and animation overrides.

```csharp
VRCStation station = GetComponent<VRCStation>();
VRCPlayerApi player = Networking.LocalPlayer;

// Use the station
station.UseStation(player);

// Exit the station
station.ExitStation(player);

```

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

### Udon Station Events

Source: https://udonsharp.docs.vrchat.com/events

Events related to player interactions with VRChat stations.

```APIDOC
## Udon Station Events

### Description
Events that are triggered when a player enters or exits a VRChat station. These events require the `VRC_Station` component.

### Method
`override`

### Endpoint
N/A (These are method overrides within UdonSharpBehaviour)

### Parameters
- **OnStationEntered(VRCPlayerApi player)**: `player` (VRCPlayerApi) - The player who entered the station.
- **OnStationExited(VRCPlayerApi player)**: `player` (VRCPlayerApi) - The player who exited the station.

### Request Example
```csharp
public override void OnStationEntered(VRCPlayerApi player) {
    // Handle station entry
}

public override void OnStationExited(VRCPlayerApi player) {
    // Handle station exit
}
```

### Response
#### Success Response (N/A)
These are method overrides, not API endpoints with direct responses.

#### Response Example
N/A
```

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

### VRCObjectSync: Sync Transform and Rigidbody

Source: https://udonsharp.docs.vrchat.com/vrchat-api

VRCObjectSync synchronizes the Transform (position, rotation, scale) and Rigidbody (physics) of a GameObject. It provides methods to control kinematic and gravity states, flag discontinuities for immediate updates, teleport, and respawn the object.

```csharp
public class VRCObjectSync : UdonSharpBehaviour
{
    public bool AllowCollisionOwnershipTransfer;

    public void SetKinematic(bool value)
    {
        // Implementation to set kinematic state
    }

    public void SetGravity(bool value)
    {
        // Implementation to set gravity state
    }

    public void FlagDiscontinuity()
    {
        // Implementation to flag discontinuity
    }

    public void TeleportTo(Transform targetLocation)
    {
        // Implementation to teleport the object
    }

    public void Respawn()
    {
        // Implementation to respawn the object
    }
}
```

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

### Udon Pickup Events: OnPickupUseDown, OnPickupUseUp

Source: https://udonsharp.docs.vrchat.com/events

These events handle the primary action associated with a pickup item. OnPickupUseDown fires when the use button is pressed while holding the pickup, and OnPickupUseUp fires when the button is released. They require the VRC_Pickup component.

```csharp
public void OnPickupUseDown() {}
public void OnPickupUseUp() {}
```

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

### Avatar Audio Settings

Source: https://udonsharp.docs.vrchat.com/vrchat-api

Method to adjust the maximum gain allowed for avatar audio.

```APIDOC
## Avatar Audio API

### Description
Adjusts the maximum gain level allowed for audio originating from the player's avatar.

### Method

#### SetAvatarAudioGain
- **Method**: PUT
- **Endpoint**: `/player/avatar/audio/gain`
- **Description**: Sets the maximum gain allowed on Avatar Audio.
- **Parameters**:
  - **gain** (float) - Required - The maximum gain in decibels (Range: 0-10, Default: 10).

### Response
None (void)
```

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

### Detect Player Station Entry/Exit Events in UdonSharp

Source: https://udonsharp.docs.vrchat.com/using-vrc-stations

This code snippet shows how to implement event handlers for when a player enters or exits a VRC Station. The OnStationEntered and OnStationExited methods receive a VRCPlayerApi object representing the player. You can use the 'player.isLocal' property to check if the event pertains to the local player.

```csharp
public override void OnStationEntered(VRCPlayerApi player)
{
}

public override void OnStationExited(VRCPlayerApi player)
{
}
```

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

### Add UdonSharp Component

Source: https://udonsharp.docs.vrchat.com/editor-scripting

Adds a new UdonSharp component of a specified type to a GameObject. This method returns a proxy of the component, allowing direct interaction from editor scripts. For undoable operations, UdonSharpUndo.AddComponent should be used.

```csharp
GameObject targetGameObject = ... // Get some game object from somewhere here
MyComponentType newComponent = targetGameObject.AddUdonSharpComponent<MyComponentType>();
```

```csharp
GameObject targetGameObject = ... // Get some game object from somewhere here
MyComponentType newComponent = UdonSharpUndo.AddComponent<MyComponentType>(targetGameObject);
```
Tokens:
Raw