// This file is generated. Do not modify by hand.

// XML documentation file not found. To check if public methods have XML comments,

// make sure the XML doc file is present and located next to the scraped dll

namespace Unity.XR.GoogleVr

{

[UnityEngine.InputSystem.Layouts.InputControlLayout(commonUsages = Mono.Cecil.CustomAttributeArgument[], displayName = @"Daydream Controller")] [UnityEngine.Scripting.Preserve] public class DaydreamController : UnityEngine.InputSystem.XR.XRController

{

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl app { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceAcceleration { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl home { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl recentered { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl recentering { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector2Control touchpad { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl touchpadClicked { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl touchpadTouched { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl volumeDown { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl volumeUp { get; }

public DaydreamController() {}

protected virtual void FinishSetup();

}

[UnityEngine.InputSystem.Layouts.InputControlLayout(displayName = @"Daydream Headset")] [UnityEngine.Scripting.Preserve] public class DaydreamHMD : UnityEngine.InputSystem.XR.XRHMD

{

public DaydreamHMD() {}

}

}

namespace Unity.XR.Oculus.Input

{

[UnityEngine.InputSystem.Layouts.InputControlLayout(commonUsages = Mono.Cecil.CustomAttributeArgument[], displayName = @"GearVR Controller")] [UnityEngine.Scripting.Preserve] public class GearVRTrackedController : UnityEngine.InputSystem.XR.XRController

{

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl back { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceAcceleration { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceAngularAcceleration { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceAngularVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector2Control touchpad { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl touchpadClicked { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl touchpadTouched { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.AxisControl trigger { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl triggerPressed { get; }

public GearVRTrackedController() {}

protected virtual void FinishSetup();

}

[UnityEngine.InputSystem.Layouts.InputControlLayout(displayName = @"Oculus Headset")] [UnityEngine.Scripting.Preserve] public class OculusHMD : UnityEngine.InputSystem.XR.XRHMD

{

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control centerEyeAcceleration { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control centerEyeAngularAcceleration { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control centerEyeAngularVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceAcceleration { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceAngularAcceleration { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceAngularVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control leftEyeAcceleration { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control leftEyeAngularAcceleration { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control leftEyeAngularVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control rightEyeAcceleration { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control rightEyeAngularAcceleration { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control rightEyeAngularVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[], layout = @"Button", name = @"isTracked")] [UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[], layout = @"Integer", name = @"trackingState")] [UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl userPresence { get; }

public OculusHMD() {}

protected virtual void FinishSetup();

}

[UnityEngine.InputSystem.Layouts.InputControlLayout(displayName = @"Oculus Headset (w/ on-headset controls)")] [UnityEngine.Scripting.Preserve] public class OculusHMDExtended : Unity.XR.Oculus.Input.OculusHMD

{

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl back { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector2Control touchpad { get; }

public OculusHMDExtended() {}

protected virtual void FinishSetup();

}

[UnityEngine.InputSystem.Layouts.InputControlLayout(displayName = @"Oculus Remote")] [UnityEngine.Scripting.Preserve] public class OculusRemote : UnityEngine.InputSystem.InputDevice

{

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl back { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl start { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector2Control touchpad { get; }

public OculusRemote() {}

protected virtual void FinishSetup();

}

[UnityEngine.InputSystem.Layouts.InputControlLayout(commonUsages = Mono.Cecil.CustomAttributeArgument[], displayName = @"Oculus Touch Controller")] [UnityEngine.Scripting.Preserve] public class OculusTouchController : UnityEngine.InputSystem.XR.XRControllerWithRumble

{

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[], noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceAcceleration { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[], noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceAngularAcceleration { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[], noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceAngularVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[], noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.AxisControl grip { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl gripPressed { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl primaryButton { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl primaryTouched { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl secondaryButton { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl secondaryTouched { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl start { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector2Control thumbstick { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl thumbstickClicked { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[], layout = @"Button", name = @"isTracked")] [UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[], layout = @"Integer", name = @"trackingState")] [UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[], layout = @"Quaternion", name = @"deviceRotation")] [UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[], layout = @"Vector3", name = @"devicePosition")] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl thumbstickTouched { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.AxisControl trigger { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl triggerPressed { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.AxisControl triggerTouched { get; }

public OculusTouchController() {}

protected virtual void FinishSetup();

}

[UnityEngine.Scripting.Preserve] public class OculusTrackingReference : UnityEngine.InputSystem.TrackedDevice

{

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl isTracked { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.IntegerControl trackingState { get; }

public OculusTrackingReference() {}

protected virtual void FinishSetup();

}

}

namespace Unity.XR.OpenVR

{

[UnityEngine.InputSystem.Layouts.InputControlLayout(commonUsages = Mono.Cecil.CustomAttributeArgument[], displayName = @"Handed Vive Tracker")] [UnityEngine.Scripting.Preserve] public class HandedViveTracker : Unity.XR.OpenVR.ViveTracker

{

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.AxisControl grip { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl gripPressed { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl primary { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl trackpadPressed { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl triggerPressed { get; }

public HandedViveTracker() {}

protected virtual void FinishSetup();

}

[UnityEngine.InputSystem.Layouts.InputControlLayout(commonUsages = Mono.Cecil.CustomAttributeArgument[], displayName = @"Windows MR Controller (OpenVR)")] [UnityEngine.Scripting.Preserve] public class OpenVRControllerWMR : UnityEngine.InputSystem.XR.XRController

{

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceAngularVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.AxisControl grip { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl gripPressed { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector2Control joystick { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl menu { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector2Control touchpad { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl touchpadClick { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl touchpadTouch { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.AxisControl trigger { get; }

[UnityEngine.InputSystem.Layouts.InputControl] public UnityEngine.InputSystem.Controls.ButtonControl triggerPressed { get; }

public OpenVRControllerWMR() {}

protected virtual void FinishSetup();

}

[UnityEngine.InputSystem.Layouts.InputControlLayout(displayName = @"OpenVR Headset")] [UnityEngine.Scripting.Preserve] public class OpenVRHMD : UnityEngine.InputSystem.XR.XRHMD

{

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control centerEyeAngularVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control centerEyeVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceAngularVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control leftEyeAngularVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control leftEyeVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control rightEyeAngularVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control rightEyeVelocity { get; }

public OpenVRHMD() {}

protected virtual void FinishSetup();

}

[UnityEngine.InputSystem.Layouts.InputControlLayout(commonUsages = Mono.Cecil.CustomAttributeArgument[], displayName = @"Oculus Touch Controller (OpenVR)")] [UnityEngine.Scripting.Preserve] public class OpenVROculusTouchController : UnityEngine.InputSystem.XR.XRControllerWithRumble

{

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceAngularVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.AxisControl grip { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl gripPressed { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl primaryButton { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl secondaryButton { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector2Control thumbstick { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl thumbstickClicked { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl thumbstickTouched { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.AxisControl trigger { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl triggerPressed { get; }

public OpenVROculusTouchController() {}

protected virtual void FinishSetup();

}

[UnityEngine.InputSystem.Layouts.InputControlLayout(displayName = @"Vive Lighthouse")] [UnityEngine.Scripting.Preserve] public class ViveLighthouse : UnityEngine.InputSystem.TrackedDevice

{

public ViveLighthouse() {}

}

[UnityEngine.InputSystem.Layouts.InputControlLayout(displayName = @"Vive Tracker")] [UnityEngine.Scripting.Preserve] public class ViveTracker : UnityEngine.InputSystem.TrackedDevice

{

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceAngularVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceVelocity { get; }

public ViveTracker() {}

protected virtual void FinishSetup();

}

[UnityEngine.InputSystem.Layouts.InputControlLayout(commonUsages = Mono.Cecil.CustomAttributeArgument[], displayName = @"Vive Wand")] [UnityEngine.Scripting.Preserve] public class ViveWand : UnityEngine.InputSystem.XR.XRControllerWithRumble

{

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceAngularVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl(noisy = true)] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector3Control deviceVelocity { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.AxisControl grip { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl gripPressed { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl primary { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.Vector2Control trackpad { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl trackpadPressed { get; }

[UnityEngine.InputSystem.Layouts.InputControl(aliases = Mono.Cecil.CustomAttributeArgument[])] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl trackpadTouched { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.AxisControl trigger { get; }

[UnityEngine.InputSystem.Layouts.InputControl] [UnityEngine.Scripting.Preserve] public UnityEngine.InputSystem.Controls.ButtonControl triggerPressed { get; }

public ViveWand() {}

protected virtual void FinishSetup();

}

}

namespace UnityEngine.InputSystem

{

[UnityEngine.InputSystem.Layouts.InputControlLayout(stateType = typeof(UnityEngine.InputSystem.LowLevel.AccelerometerState))] [UnityEngine.Scripting.Preserve] public class Accelerometer : UnityEngine.InputSystem.Sensor

{

public UnityEngine.InputSystem.Controls.Vector3Control acceleration { get; }

public static UnityEngine.InputSystem.Accelerometer current { get; }

public Accelerometer() {}

protected virtual void FinishSetup();

public virtual void MakeCurrent();

protected virtual void OnRemoved();

}

[UnityEngine.InputSystem.Layouts.InputControlLayout(displayName = @"Ambient Temperature")] [UnityEngine.Scripting.Preserve] public class AmbientTemperatureSensor : UnityEngine.InputSystem.Sensor

{

[UnityEngine.InputSystem.Layouts.InputControl(displayName = @"Ambient Temperature", noisy = true)] public UnityEngine.InputSystem.Controls.AxisControl ambientTemperature { get; }

public static UnityEngine.InputSystem.AmbientTemperatureSensor current { get; }

public AmbientTemperatureSensor() {}

protected virtual void FinishSetup();

public virtual void MakeCurrent();

protected virtual void OnRemoved();

}

[UnityEngine.InputSystem.Layouts.InputControlLayout(displayName = @"Attitude", stateType = typeof(UnityEngine.InputSystem.LowLevel.AttitudeState))] [UnityEngine.Scripting.Preserve] public class AttitudeSensor : UnityEngine.InputSystem.Sensor

{

public UnityEngine.InputSystem.Controls.QuaternionControl attitude { get; }

public static UnityEngine.InputSystem.AttitudeSensor current { get; }

public AttitudeSensor() {}

protected virtual void FinishSetup();

public virtual void MakeCurrent();

protected virtual void OnRemoved();

}

public static class CommonUsages

{

public static readonly UnityEngine.InputSystem.Utilities.InternedString Back;

public static readonly UnityEngine.InputSystem.Utilities.InternedString BatteryStrength;

public static readonly UnityEngine.InputSystem.Utilities.InternedString Cancel;

public static readonly UnityEngine.InputSystem.Utilities.InternedString Forward;

public static readonly UnityEngine.InputSystem.Utilities.InternedString Hatswitch;

public static readonly UnityEngine.InputSystem.Utilities.InternedString HighFreqMotor;

public static readonly UnityEngine.InputSystem.Utilities.InternedString Horizontal;

public static readonly UnityEngine.InputSystem.Utilities.InternedString LeftHand;

public static readonly UnityEngine.InputSystem.Utilities.InternedString LowFreqMotor;

public static readonly UnityEngine.InputSystem.Utilities.InternedString Menu;

public static readonly UnityEngine.InputSystem.Utilities.InternedString Modifier;

public static readonly UnityEngine.InputSystem.Utilities.InternedString Orientation;

public static readonly UnityEngine.InputSystem.Utilities.InternedString Point;

public static readonly UnityEngine.InputSystem.Utilities.InternedString Position;

public static readonly UnityEngine.InputSystem.Utilities.InternedString Pressure;

public static readonly UnityEngine.InputSystem.Utilities.InternedString Primary2DMotion;

public static readonly UnityEngine.InputSystem.Utilities.InternedString PrimaryAction;

public static readonly UnityEngine.InputSystem.Utilities.InternedString PrimaryTrigger;

public static readonly UnityEngine.InputSystem.Utilities.InternedString RightHand;

public static readonly UnityEngine.InputSystem.Utilities.InternedString ScrollHorizontal;

public static readonly UnityEngine.InputSystem.Utilities.InternedString ScrollVertical;

public static readonly UnityEngine.InputSystem.Utilities.InternedString Secondary2DMotion;

public static readonly UnityEngine.InputSystem.Utilities.InternedString SecondaryAction;

public static readonly UnityEngine.InputSystem.Utilities.InternedString SecondaryTrigger;

public static readonly UnityEngine.InputSystem.Utilities.InternedString Submit;

public static readonly UnityEngine.InputSystem.Utilities.InternedString Twist;

public static readonly UnityEngine.InputSystem.Utilities.InternedString Vertical;

}

[System.Reflection.DefaultMember(@"Item")] [UnityEngine.InputSystem.Layouts.InputControlLayout(isGenericTypeOfDevice = true, stateType = typeof(UnityEngine.InputSystem.LowLevel.GamepadState))] [UnityEngine.Scripting.Preserve] public class Gamepad : UnityEngine.InputSystem.InputDevice, UnityEngine.InputSystem.Haptics.IDualMotorRumble, UnityEngine.InputSystem.Haptics.IHaptics

{

public UnityEngine.InputSystem.Controls.ButtonControl aButton { get; }

public static UnityEngine.InputSystem.Utilities.ReadOnlyArray<UnityEngine.InputSystem.Gamepad> all { get; }

public UnityEngine.InputSystem.Controls.ButtonControl bButton { get; }

public UnityEngine.InputSystem.Controls.ButtonControl buttonEast { get; }

public UnityEngine.InputSystem.Controls.ButtonControl buttonNorth { get; }

public UnityEngine.InputSystem.Controls.ButtonControl buttonSouth { get; }

public UnityEngine.InputSystem.Controls.ButtonControl buttonWest { get; }

public UnityEngine.InputSystem.Controls.ButtonControl circleButton { get; }

public UnityEngine.InputSystem.Controls.ButtonControl crossButton { get; }

public static UnityEngine.InputSystem.Gamepad current { get; }

public UnityEngine.InputSystem.Controls.DpadControl dpad { get; }

public UnityEngine.InputSystem.Controls.ButtonControl this[UnityEngine.InputSystem.LowLevel.GamepadButton button] { get; }

public UnityEngine.InputSystem.Controls.ButtonControl leftShoulder { get; }

public UnityEngine.InputSystem.Controls.StickControl leftStick { get; }

public UnityEngine.InputSystem.Controls.ButtonControl leftStickButton { get; }

public UnityEngine.InputSystem.Controls.ButtonControl leftTrigger { get; }

public UnityEngine.InputSystem.Controls.ButtonControl rightShoulder { get; }

public UnityEngine.InputSystem.Controls.StickControl rightStick { get; }

public UnityEngine.InputSystem.Controls.ButtonControl rightStickButton { get; }

public UnityEngine.InputSystem.Controls.ButtonControl rightTrigger { get; }

public UnityEngine.InputSystem.Controls.ButtonControl selectButton { get; }

public UnityEngine.InputSystem.Controls.ButtonControl squareButton { get; }

public UnityEngine.InputSystem.Controls.ButtonControl startButton { get; }

public UnityEngine.InputSystem.Controls.ButtonControl triangleButton { get; }

public UnityEngine.InputSystem.Controls.ButtonControl xButton { get; }

public UnityEngine.InputSystem.Controls.ButtonControl yButton { get; }

public Gamepad() {}

protected virtual void FinishSetup();

public virtual void MakeCurrent();

protected virtual void OnAdded();

protected virtual void OnRemoved();

public virtual void PauseHaptics();

public virtual void ResetHaptics();

public virtual void ResumeHaptics();

public virtual void SetMotorSpeeds(float lowFrequency, float highFrequency);

}

[UnityEngine.InputSystem.Layouts.InputControlLayout(displayName = @"Gravity", stateType = typeof(UnityEngine.InputSystem.LowLevel.GravityState))] [UnityEngine.Scripting.Preserve] public class GravitySensor : UnityEngine.InputSystem.Sensor

{

public static UnityEngine.InputSystem.GravitySensor current { get; }

public UnityEngine.InputSystem.Controls.Vector3Control gravity { get; }

public GravitySensor() {}

protected virtual void FinishSetup();

public virtual void MakeCurrent();

protected virtual void OnRemoved();

}

[UnityEngine.InputSystem.Layouts.InputControlLayout(stateType = typeof(UnityEngine.InputSystem.LowLevel.GyroscopeState))] [UnityEngine.Scripting.Preserve] public class Gyroscope : UnityEngine.InputSystem.Sensor

{

public UnityEngine.InputSystem.Controls.Vector3Control angularVelocity { get; }

public static UnityEngine.InputSystem.Gyroscope current { get; }

public Gyroscope() {}

protected virtual void FinishSetup();

public virtual void MakeCurrent();

protected virtual void OnRemoved();

}

[UnityEngine.InputSystem.Layouts.InputControlLayout(displayName = @"Humidity")] [UnityEngine.Scripting.Preserve] public class HumiditySensor : UnityEngine.InputSystem.Sensor

{

public static UnityEngine.InputSystem.HumiditySensor current { get; }

[UnityEngine.InputSystem.Layouts.InputControl(displayName = @"Relative Humidity", noisy = true)] public UnityEngine.InputSystem.Controls.AxisControl relativeHumidity { get; }

public HumiditySensor() {}

protected virtual void FinishSetup();

public virtual void MakeCurrent();

protected virtual void OnRemoved();

}

public interface IInputActionCollection : System.Collections.Generic.IEnumerable<UnityEngine.InputSystem.InputAction>, System.Collections.IEnumerable

{

public abstract System.Nullable<UnityEngine.InputSystem.InputBinding> bindingMask { get; set; }

public abstract UnityEngine.InputSystem.Utilities.ReadOnlyArray<UnityEngine.InputSystem.InputControlScheme> controlSchemes { get; }

public abstract System.Nullable<UnityEngine.InputSystem.Utilities.ReadOnlyArray<UnityEngine.InputSystem.InputDevice>> devices { get; set; }

public abstract bool Contains(UnityEngine.InputSystem.InputAction action);

public abstract void Disable();

public abstract void Enable();

}

[UnityEngine.Scripting.Preserve] public interface IInputInteraction

{

public abstract void Process(ref UnityEngine.InputSystem.InputInteractionContext context);

public abstract void Reset();

}

[UnityEngine.Scripting.Preserve] public interface IInputInteraction<TValue> : UnityEngine.InputSystem.IInputInteraction where TValue : System.ValueType, new()

{

}

public sealed class InputAction : System.ICloneable, System.IDisposable

{

public event System.Action<UnityEngine.InputSystem.InputAction.CallbackContext> canceled;

public event System.Action<UnityEngine.InputSystem.InputAction.CallbackContext> performed;

public event System.Action<UnityEngine.InputSystem.InputAction.CallbackContext> started;

public UnityEngine.InputSystem.InputActionMap actionMap { get; }

public UnityEngine.InputSystem.InputControl activeControl { get; }

public System.Nullable<UnityEngine.InputSystem.InputBinding> bindingMask { get; set; }

public UnityEngine.InputSystem.Utilities.ReadOnlyArray<UnityEngine.InputSystem.InputBinding> bindings { get; }

public UnityEngine.InputSystem.Utilities.ReadOnlyArray<UnityEngine.InputSystem.InputControl> controls { get; }

public bool enabled { get; }

public string expectedControlType { get; set; }

public System.Guid id { get; }

public string interactions { get; }

public string name { get; }

public UnityEngine.InputSystem.InputActionPhase phase { get; }

public string processors { get; }

public bool triggered { get; }

public UnityEngine.InputSystem.InputActionType type { get; }

public InputAction() {}

public InputAction(string name = default(string), UnityEngine.InputSystem.InputActionType type = 0, string binding = default(string), string interactions = default(string), string processors = default(string), string expectedControlType = default(string)) {}

public UnityEngine.InputSystem.InputAction Clone();

public void Disable();

public virtual void Dispose();

public void Enable();

public TValue ReadValue<TValue>() where TValue : System.ValueType, new();

public object ReadValueAsObject();

public virtual string ToString();

public struct CallbackContext

{

public UnityEngine.InputSystem.InputAction action { get; }

public bool canceled { get; }

public UnityEngine.InputSystem.InputControl control { get; }

public double duration { get; }

public UnityEngine.InputSystem.IInputInteraction interaction { get; }

public bool performed { get; }

public UnityEngine.InputSystem.InputActionPhase phase { get; }

public bool started { get; }

public double startTime { get; }

public double time { get; }

public int valueSizeInBytes { get; }

public System.Type valueType { get; }

public TValue ReadValue<TValue>() where TValue : System.ValueType, new();

public void ReadValue(void* buffer, int bufferSize);

public bool ReadValueAsButton();

public object ReadValueAsObject();

public virtual string ToString();

}

}

[System.Reflection.DefaultMember(@"Item")] public class InputActionAsset : UnityEngine.ScriptableObject, System.Collections.Generic.IEnumerable<UnityEngine.InputSystem.InputAction>, System.Collections.IEnumerable, UnityEngine.InputSystem.IInputActionCollection

{

public const string Extension = inputactions;

public UnityEngine.InputSystem.Utilities.ReadOnlyArray<UnityEngine.InputSystem.InputActionMap> actionMaps { get; }

public virtual System.Nullable<UnityEngine.InputSystem.InputBinding> bindingMask { get; set; }

public virtual UnityEngine.InputSystem.Utilities.ReadOnlyArray<UnityEngine.InputSystem.InputControlScheme> controlSchemes { get; }

public virtual System.Nullable<UnityEngine.InputSystem.Utilities.ReadOnlyArray<UnityEngine.InputSystem.InputDevice>> devices { get; set; }

public bool enabled { get; }

public UnityEngine.InputSystem.InputAction this[string actionNameOrId] { get; }

public InputActionAsset() {}

public virtual bool Contains(UnityEngine.InputSystem.InputAction action);

public virtual void Disable();

public virtual void Enable();

public UnityEngine.InputSystem.InputAction FindAction(System.Guid guid);

public UnityEngine.InputSystem.InputAction FindAction(string actionNameOrId, bool throwIfNotFound = False);

public UnityEngine.InputSystem.InputActionMap FindActionMap(System.Guid id);

public UnityEngine.InputSystem.InputActionMap FindActionMap(string nameOrId, bool throwIfNotFound = False);

public System.Nullable<UnityEngine.InputSystem.InputControlScheme> FindControlScheme(string name);

public int FindControlSchemeIndex(string name);

public static UnityEngine.InputSystem.InputActionAsset FromJson(string json);

[System.Runtime.CompilerServices.IteratorStateMachine(typeof(UnityEngine.InputSystem.InputActionAsset.<GetEnumerator>d__27))] public virtual System.Collections.Generic.IEnumerator<UnityEngine.InputSystem.InputAction> GetEnumerator();

public void LoadFromJson(string json);

public string ToJson();

}

public enum InputActionChange

{

public const UnityEngine.InputSystem.InputActionChange ActionCanceled = 6;

public const UnityEngine.InputSystem.InputActionChange ActionDisabled = 1;

public const UnityEngine.InputSystem.InputActionChange ActionEnabled = 0;

public const UnityEngine.InputSystem.InputActionChange ActionMapDisabled = 3;

public const UnityEngine.InputSystem.InputActionChange ActionMapEnabled = 2;

public const UnityEngine.InputSystem.InputActionChange ActionPerformed = 5;

public const UnityEngine.InputSystem.InputActionChange ActionStarted = 4;

public const UnityEngine.InputSystem.InputActionChange BoundControlsAboutToChange = 7;

public const UnityEngine.InputSystem.InputActionChange BoundControlsChanged = 8;

public int value__;

}

[System.Reflection.DefaultMember(@"Item")] public sealed class InputActionMap : System.Collections.Generic.IEnumerable<UnityEngine.InputSystem.InputAction>, System.Collections.IEnumerable, System.ICloneable, System.IDisposable, UnityEngine.InputSystem.IInputActionCollection, UnityEngine.ISerializationCallbackReceiver

{

public event System.Action<UnityEngine.InputSystem.InputAction.CallbackContext> actionTriggered;

public UnityEngine.InputSystem.Utilities.ReadOnlyArray<UnityEngine.InputSystem.InputAction> actions { get; }

public UnityEngine.InputSystem.InputActionAsset asset { get; }

public virtual System.Nullable<UnityEngine.InputSystem.InputBinding> bindingMask { get; set; }

public UnityEngine.InputSystem.Utilities.ReadOnlyArray<UnityEngine.InputSystem.InputBinding> bindings { get; }

public virtual UnityEngine.InputSystem.Utilities.ReadOnlyArray<UnityEngine.InputSystem.InputControlScheme> controlSchemes { get; }

public virtual System.Nullable<UnityEngine.InputSystem.Utilities.ReadOnlyArray<UnityEngine.InputSystem.InputDevice>> devices { get; set; }

public bool enabled { get; }

public System.Guid id { get; }

public UnityEngine.InputSystem.InputAction this[string actionNameOrId] { get; }

public string name { get; }

public InputActionMap() {}

public InputActionMap(string name) {}

public UnityEngine.InputSystem.InputActionMap Clone();

public virtual bool Contains(UnityEngine.InputSystem.InputAction action);

public virtual void Disable();

public virtual void Dispose();

public virtual void Enable();

public UnityEngine.InputSystem.InputAction FindAction(System.Guid id);

public UnityEngine.InputSystem.InputAction FindAction(string nameOrId, bool throwIfNotFound = False);

public static UnityEngine.InputSystem.InputActionMap[] FromJson(string json);

public virtual System.Collections.Generic.IEnumerator<UnityEngine.InputSystem.InputAction> GetEnumerator();

public bool IsUsableWithDevice(UnityEngine.InputSystem.InputDevice device);

public virtual void OnAfterDeserialize();

public virtual void OnBeforeSerialize();

public string ToJson();

public static string ToJson(System.Collections.Generic.IEnumerable<UnityEngine.InputSystem.InputActionMap> maps);

public virtual string ToString();

}

public enum InputActionPhase

{

public const UnityEngine.InputSystem.InputActionPhase Canceled = 4;

public const UnityEngine.InputSystem.InputActionPhase Disabled = 0;

public const UnityEngine.InputSystem.InputActionPhase Performed = 3;

public const UnityEngine.InputSystem.InputActionPhase Started = 2;

public int value__;

public const UnityEngine.InputSystem.InputActionPhase Waiting = 1;

}

public struct InputActionProperty : System.IEquatable<UnityEngine.InputSystem.InputAction>, System.IEquatable<UnityEngine.InputSystem.InputActionProperty>, System.IEquatable<UnityEngine.InputSystem.InputActionReference>

{

public UnityEngine.InputSystem.InputAction action { get; }

public UnityEngine.InputSystem.InputActionReference reference { get; }

public InputActionProperty(UnityEngine.InputSystem.InputAction action) {}

public InputActionProperty(UnityEngine.InputSystem.InputActionReference reference) {}

public virtual bool Equals(object obj);

public virtual bool Equals(UnityEngine.InputSystem.InputAction other);

public virtual bool Equals(UnityEngine.InputSystem.InputActionProperty other);

public virtual bool Equals(UnityEngine.InputSystem.InputActionReference other);

public virtual int GetHashCode();

public static bool operator ==(UnityEngine.InputSystem.InputActionProperty left, UnityEngine.InputSystem.InputActionProperty right);

public static bool operator !=(UnityEngine.InputSystem.InputActionProperty left, UnityEngine.InputSystem.InputActionProperty right);

}

[System.Runtime.CompilerServices.Extension] public static class InputActionRebindingExtensions

{

[System.Runtime.CompilerServices.Extension] public static int ApplyBindingOverride(UnityEngine.InputSystem.InputActionMap actionMap, UnityEngine.InputSystem.InputBinding bindingOverride);

[System.Runtime.CompilerServices.Extension] public static void ApplyBindingOverride(UnityEngine.InputSystem.InputAction action, UnityEngine.InputSystem.InputBinding bindingOverride);

[System.Runtime.CompilerServices.Extension] public static void ApplyBindingOverride(UnityEngine.InputSystem.InputAction action, int bindingIndex, string path);

[System.Runtime.CompilerServices.Extension] public static void ApplyBindingOverride(UnityEngine.InputSystem.InputAction action, int bindingIndex, UnityEngine.InputSystem.InputBinding bindingOverride);

[System.Runtime.CompilerServices.Extension] public static void ApplyBindingOverride(UnityEngine.InputSystem.InputActionMap actionMap, int bindingIndex, UnityEngine.InputSystem.InputBinding bindingOverride);

[System.Runtime.CompilerServices.Extension] public static void ApplyBindingOverride(UnityEngine.InputSystem.InputAction action, string newPath, string group = default(string), string path = default(string));

[System.Runtime.CompilerServices.Extension] public static void ApplyBindingOverrides(UnityEngine.InputSystem.InputActionMap actionMap, System.Collections.Generic.IEnumerable<UnityEngine.InputSystem.InputBinding> overrides);

[System.Runtime.CompilerServices.Extension] public static int ApplyBindingOverridesOnMatchingControls(UnityEngine.InputSystem.InputAction action, UnityEngine.InputSystem.InputControl control);

[System.Runtime.CompilerServices.Extension] public static int ApplyBindingOverridesOnMatchingControls(UnityEngine.InputSystem.InputActionMap actionMap, UnityEngine.InputSystem.InputControl control);

[System.Runtime.CompilerServices.Extension] public static string GetBindingDisplayString(UnityEngine.InputSystem.InputAction action, int bindingIndex, UnityEngine.InputSystem.InputBinding.DisplayStringOptions options = 0);

[System.Runtime.CompilerServices.Extension] public static string GetBindingDisplayString(UnityEngine.InputSystem.InputAction action, UnityEngine.InputSystem.InputBinding bindingMask, UnityEngine.InputSystem.InputBinding.DisplayStringOptions options = 0);

[System.Runtime.CompilerServices.Extension] public static string GetBindingDisplayString(UnityEngine.InputSystem.InputAction action, UnityEngine.InputSystem.InputBinding.DisplayStringOptions options = 0, string group = default(string));

[System.Runtime.CompilerServices.Extension] public static string GetBindingDisplayString(UnityEngine.InputSystem.InputAction action, int bindingIndex, out string deviceLayoutName, out string controlPath, UnityEngine.InputSystem.InputBinding.DisplayStringOptions options = 0);

[System.Runtime.CompilerServices.Extension] public static System.Nullable<UnityEngine.InputSystem.InputBinding> GetBindingForControl(UnityEngine.InputSystem.InputAction action, UnityEngine.InputSystem.InputControl control);

[System.Runtime.CompilerServices.Extension] public static int GetBindingIndex(UnityEngine.InputSystem.InputAction action, UnityEngine.InputSystem.InputBinding bindingMask);

[System.Runtime.CompilerServices.Extension] public static int GetBindingIndex(UnityEngine.InputSystem.InputAction action, string group = default(string), string path = default(string));

[System.Runtime.CompilerServices.Extension] public static int GetBindingIndexForControl(UnityEngine.InputSystem.InputAction action, UnityEngine.InputSystem.InputControl control);

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation PerformInteractiveRebinding(UnityEngine.InputSystem.InputAction action, int bindingIndex = -1);

[System.Runtime.CompilerServices.Extension] public static void RemoveAllBindingOverrides(UnityEngine.InputSystem.InputAction action);

[System.Runtime.CompilerServices.Extension] public static void RemoveAllBindingOverrides(UnityEngine.InputSystem.InputActionMap actionMap);

[System.Runtime.CompilerServices.Extension] public static void RemoveBindingOverride(UnityEngine.InputSystem.InputAction action, int bindingIndex);

[System.Runtime.CompilerServices.Extension] public static void RemoveBindingOverride(UnityEngine.InputSystem.InputAction action, UnityEngine.InputSystem.InputBinding bindingMask);

[System.Runtime.CompilerServices.Extension] public static void RemoveBindingOverrides(UnityEngine.InputSystem.InputActionMap actionMap, System.Collections.Generic.IEnumerable<UnityEngine.InputSystem.InputBinding> overrides);

public sealed class RebindingOperation : System.IDisposable

{

public const float kDefaultMagnitudeThreshold = 0.2;

public UnityEngine.InputSystem.InputAction action { get; }

public System.Nullable<UnityEngine.InputSystem.InputBinding> bindingMask { get; }

public bool canceled { get; }

public UnityEngine.InputSystem.InputControlList<UnityEngine.InputSystem.InputControl> candidates { get; }

public bool completed { get; }

public string expectedControlType { get; }

public UnityEngine.InputSystem.Utilities.ReadOnlyArray<float> magnitudes { get; }

public UnityEngine.InputSystem.Utilities.ReadOnlyArray<float> scores { get; }

public UnityEngine.InputSystem.InputControl selectedControl { get; }

public bool started { get; }

public double startTime { get; }

public float timeout { get; }

public RebindingOperation() {}

public void AddCandidate(UnityEngine.InputSystem.InputControl control, float score, float magnitude = -1);

public void Cancel();

public void Complete();

public virtual void Dispose();

protected virtual void Finalize();

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation OnApplyBinding(System.Action<UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation, string> callback);

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation OnCancel(System.Action<UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation> callback);

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation OnComplete(System.Action<UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation> callback);

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation OnComputeScore(System.Func<UnityEngine.InputSystem.InputControl, UnityEngine.InputSystem.LowLevel.InputEventPtr, float> callback);

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation OnGeneratePath(System.Func<UnityEngine.InputSystem.InputControl, string> callback);

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation OnMatchWaitForAnother(float seconds);

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation OnPotentialMatch(System.Action<UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation> callback);

public void RemoveCandidate(UnityEngine.InputSystem.InputControl control);

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation Reset();

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation Start();

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation WithAction(UnityEngine.InputSystem.InputAction action);

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation WithBindingGroup(string group);

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation WithBindingMask(System.Nullable<UnityEngine.InputSystem.InputBinding> bindingMask);

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation WithCancelingThrough(string binding);

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation WithCancelingThrough(UnityEngine.InputSystem.InputControl control);

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation WithControlsExcluding(string path);

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation WithControlsHavingToMatchPath(string path);

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation WithExpectedControlType<TControl>() where TControl : UnityEngine.InputSystem.InputControl;

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation WithExpectedControlType(string layoutName);

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation WithExpectedControlType(System.Type type);

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation WithMagnitudeHavingToBeGreaterThan(float magnitude);

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation WithMatchingEventsBeingSuppressed(bool value = True);

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation WithoutGeneralizingPathOfSelectedControl();

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation WithoutIgnoringNoisyControls();

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation WithRebindAddingNewBinding(string group = default(string));

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation WithTargetBinding(int bindingIndex);

public UnityEngine.InputSystem.InputActionRebindingExtensions.RebindingOperation WithTimeout(float timeInSeconds);

}

}

public class InputActionReference : UnityEngine.ScriptableObject

{

public UnityEngine.InputSystem.InputAction action { get; }

public UnityEngine.InputSystem.InputActionAsset asset { get; }

public InputActionReference() {}

public static UnityEngine.InputSystem.InputActionReference Create(UnityEngine.InputSystem.InputAction action);

public static UnityEngine.InputSystem.InputAction op_Implicit(UnityEngine.InputSystem.InputActionReference reference);

public void Set(UnityEngine.InputSystem.InputAction action);

public void Set(UnityEngine.InputSystem.InputActionAsset asset, string mapName, string actionName);

public UnityEngine.InputSystem.InputAction ToInputAction();

public virtual string ToString();

}

[System.Runtime.CompilerServices.Extension] public static class InputActionSetupExtensions

{

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputAction AddAction(UnityEngine.InputSystem.InputActionMap map, string name, UnityEngine.InputSystem.InputActionType type = 0, string binding = default(string), string interactions = default(string), string processors = default(string), string groups = default(string), string expectedControlLayout = default(string));

[System.Runtime.CompilerServices.Extension] public static void AddActionMap(UnityEngine.InputSystem.InputActionAsset asset, UnityEngine.InputSystem.InputActionMap map);

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputActionMap AddActionMap(UnityEngine.InputSystem.InputActionAsset asset, string name);

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax AddBinding(UnityEngine.InputSystem.InputAction action, UnityEngine.InputSystem.InputBinding binding = default(UnityEngine.InputSystem.InputBinding));

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax AddBinding(UnityEngine.InputSystem.InputAction action, UnityEngine.InputSystem.InputControl control);

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax AddBinding(UnityEngine.InputSystem.InputActionMap actionMap, UnityEngine.InputSystem.InputBinding binding);

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax AddBinding(UnityEngine.InputSystem.InputAction action, string path, string interactions = default(string), string processors = default(string), string groups = default(string));

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax AddBinding(UnityEngine.InputSystem.InputActionMap actionMap, string path, System.Guid action, string interactions = default(string), string groups = default(string));

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax AddBinding(UnityEngine.InputSystem.InputActionMap actionMap, string path, string interactions = default(string), string groups = default(string), string action = default(string));

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax AddBinding(UnityEngine.InputSystem.InputActionMap actionMap, string path, UnityEngine.InputSystem.InputAction action, string interactions = default(string), string groups = default(string));

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputActionSetupExtensions.CompositeSyntax AddCompositeBinding(UnityEngine.InputSystem.InputAction action, string composite, string interactions = default(string), string processors = default(string));

[System.Runtime.CompilerServices.Extension] public static void AddControlScheme(UnityEngine.InputSystem.InputActionAsset asset, UnityEngine.InputSystem.InputControlScheme controlScheme);

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputActionSetupExtensions.ControlSchemeSyntax AddControlScheme(UnityEngine.InputSystem.InputActionAsset asset, string name);

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax ChangeBinding(UnityEngine.InputSystem.InputAction action, int index);

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax ChangeBinding(UnityEngine.InputSystem.InputAction action, UnityEngine.InputSystem.InputBinding match);

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax ChangeBindingWithGroup(UnityEngine.InputSystem.InputAction action, string group);

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax ChangeBindingWithId(UnityEngine.InputSystem.InputAction action, System.Guid id);

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax ChangeBindingWithId(UnityEngine.InputSystem.InputAction action, string id);

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax ChangeBindingWithPath(UnityEngine.InputSystem.InputAction action, string path);

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputControlScheme OrWithOptionalDevice(UnityEngine.InputSystem.InputControlScheme scheme, string controlPath);

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputControlScheme OrWithRequiredDevice(UnityEngine.InputSystem.InputControlScheme scheme, string controlPath);

[System.Runtime.CompilerServices.Extension] public static void RemoveAction(UnityEngine.InputSystem.InputAction action);

[System.Runtime.CompilerServices.Extension] public static void RemoveAction(UnityEngine.InputSystem.InputActionAsset asset, string nameOrId);

[System.Runtime.CompilerServices.Extension] public static void RemoveActionMap(UnityEngine.InputSystem.InputActionAsset asset, string nameOrId);

[System.Runtime.CompilerServices.Extension] public static void RemoveActionMap(UnityEngine.InputSystem.InputActionAsset asset, UnityEngine.InputSystem.InputActionMap map);

[System.Runtime.CompilerServices.Extension] public static void RemoveControlScheme(UnityEngine.InputSystem.InputActionAsset asset, string name);

[System.Runtime.CompilerServices.Extension] public static void Rename(UnityEngine.InputSystem.InputAction action, string newName);

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputControlScheme WithBindingGroup(UnityEngine.InputSystem.InputControlScheme scheme, string bindingGroup);

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputControlScheme WithOptionalDevice(UnityEngine.InputSystem.InputControlScheme scheme, string controlPath);

[System.Runtime.CompilerServices.Extension] public static UnityEngine.InputSystem.InputControlScheme WithRequiredDevice(UnityEngine.InputSystem.InputControlScheme scheme, string controlPath);

public struct BindingSyntax

{

public void Erase();

public UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax To(UnityEngine.InputSystem.InputBinding binding);

public UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax Triggering(UnityEngine.InputSystem.InputAction action);

public UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax WithGroup(string group);

public UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax WithGroups(string groups);

public UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax WithInteraction<TInteraction>() where TInteraction : UnityEngine.InputSystem.IInputInteraction;

public UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax WithInteraction(string interaction);

public UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax WithInteractions(string interactions);

public UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax WithName(string name);

public UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax WithPath(string path);

public UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax WithProcessor<TProcessor>();

public UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax WithProcessor(string processor);

public UnityEngine.InputSystem.InputActionSetupExtensions.BindingSyntax WithProcessors(string processors);

}

public struct CompositeSyntax

{

public UnityEngine.InputSystem.InputActionSetupExtensions.CompositeSyntax With(string name, string binding, string groups = default(string));

}

public struct ControlSchemeSyntax

{

public UnityEngine.InputSystem.InputControlScheme Done();

public UnityEngine.InputSystem.InputActionSetupExtensions.ControlSchemeSyntax OrWithOptionalDevice<TDevice>() where TDevice : UnityEngine.InputSystem.InputDevice;

public UnityEngine.InputSystem.InputActionSetupExtensions.ControlSchemeSyntax OrWithOptionalDevice(string controlPath);

public UnityEngine.InputSystem.InputActionSetupExtensions.ControlSchemeSyntax OrWithRequiredDevice<TDevice>() where TDevice : UnityEngine.InputSystem.InputDevice;

public UnityEngine.InputSystem.InputActionSetupExtensions.ControlSchemeSyntax OrWithRequiredDevice(string controlPath);

public UnityEngine.InputSystem.InputActionSetupExtensions.ControlSchemeSyntax WithBindingGroup(string bindingGroup);

public UnityEngine.InputSystem.InputActionSetupExtensions.ControlSchemeSyntax WithOptionalDevice<TDevice>() where TDevice : UnityEngine.InputSystem.InputDevice;

public UnityEngine.InputSystem.InputActionSetupExtensions.ControlSchemeSyntax WithOptionalDevice(string controlPath);

public UnityEngine.InputSystem.InputActionSetupExtensions.ControlSchemeSyntax WithRequiredDevice<TDevice>() where TDevice : UnityEngine.InputSystem.InputDevice;

public UnityEngine.InputSystem.InputActionSetupExtensions.ControlSchemeSyntax WithRequiredDevice(string controlPath);

}

}

public enum InputActionType

{

public const UnityEngine.InputSystem.InputActionType Button = 1;

public const UnityEngine.InputSystem.InputActionType PassThrough = 2;

public const UnityEngine.InputSystem.InputActionType Value = 0;

public int value__;

}

public struct InputBinding : System.IEquatable<UnityEngine.InputSystem.InputBinding>

{

public const char Separator = ;;

public string action { get; set; }

public string effectiveInteractions { get; }

public string effectivePath { get; }

public string effectiveProcessors { get; }

public string groups { get; set; }

public System.Guid id { get; set; }

public string interactions { get; set; }

public bool isComposite { get; set; }

public bool isPartOfComposite { get; set; }

public string name { get; set; }

public string overrideInteractions { get; set; }

public string overridePath { get; set; }

public string overrideProcessors { get; set; }

public string path { get; set; }

public string processors { get; set; }

public InputBinding(string path, string action = default(string), string groups = default(string), string processors = default(string), string interactions = default(string), string name = default(string)) {}

public virtual bool Equals(object obj);

public virtual bool Equals(UnityEngine.InputSystem.InputBinding other);

public virtual int GetHashCode();

public string GetNameOfComposite();

public static UnityEngine.InputSystem.InputBinding MaskByGroup(string group);

public static UnityEngine.InputSystem.InputBinding MaskByGroups(params string[] groups);

public bool Matches(UnityEngine.InputSystem.InputBinding binding);

public static bool operator ==(UnityEngine.InputSystem.InputBinding left, UnityEngine.InputSystem.InputBinding right);

public static bool operator !=(UnityEngine.InputSystem.InputBinding left, UnityEngine.InputSystem.InputBinding right);

public string ToDisplayString(UnityEngine.InputSystem.InputBinding.DisplayStringOptions options = 0, UnityEngine.InputSystem.InputControl control = default(UnityEngine.InputSystem.InputControl));

public string ToDisplayString(out string deviceLayoutName, out string controlPath, UnityEngine.InputSystem.InputBinding.DisplayStringOptions options = 0, UnityEngine.InputSystem.InputControl control = default(UnityEngine.InputSystem.InputControl));

public virtual string ToString();

[System.Flags] public enum DisplayStringOptions

{

public const UnityEngine.InputSystem.InputBinding.DisplayStringOptions DontIncludeInteractions = 4;

public const UnityEngine.InputSystem.InputBinding.DisplayStringOptions DontOmitDevice = 2;

public const UnityEngine.InputSystem.InputBinding.DisplayStringOptions DontUseShortDisplayNames = 1;

public const UnityEngine.InputSystem.InputBinding.DisplayStringOptions IgnoreBindingOverrides = 8;

public int value__;

}

}

[UnityEngine.Scripting.Preserve] public abstract class InputBindingComposite

{

public abstract int valueSizeInBytes { get; }

public abstract System.Type valueType { get; }

protected InputBindingComposite() {}

public virtual float EvaluateMagnitude(ref UnityEngine.InputSystem.InputBindingCompositeContext context);

public static string GetExpectedControlLayoutName(string composite, string part);

public abstract void ReadValue(ref UnityEngine.InputSystem.InputBindingCompositeContext context, void* buffer, int bufferSize);

public abstract object ReadValueAsObject(ref UnityEngine.InputSystem.InputBindingCompositeContext context);

}

[UnityEngine.Scripting.Preserve] public abstract class InputBindingComposite<TValue> : UnityEngine.InputSystem.InputBindingComposite where TValue : System.ValueType, new()

{

public virtual int valueSizeInBytes { get; }

public virtual System.Type valueType { get; }

protected InputBindingComposite() {}

public abstract TValue ReadValue(ref UnityEngine.InputSystem.InputBindingCompositeContext context);

public virtual void ReadValue(ref UnityEngine.InputSystem.InputBindingCompositeContext context, void* buffer, int bufferSize);

public virtual object ReadValueAsObject(ref UnityEngine.InputSystem.InputBindingCompositeContext context);

}

public struct InputBindingCompositeContext

{

public TValue ReadValue<TValue>(int partNumber) where TValue : System.ValueType, System.IComparable<TValue>, new();

public TValue ReadValue<TValue, TComparer>(int partNumber, TComparer comparer = default(TComparer)) where TValue : System.ValueType, new() where TComparer : System.Collections.Generic.IComparer<TValue>;

public TValue ReadValue<TValue>(int partNumber, out UnityEngine.InputSystem.InputControl sourceControl) where TValue : System.ValueType, System.IComparable<TValue>, new();

public TValue ReadValue<TValue, TComparer>(int partNumber, out UnityEngine.InputSystem.InputControl sourceControl, TComparer comparer = default(TComparer)) where TValue : System.ValueType, new() where TComparer : System.Collections.Generic.IComparer<TValue>;

public bool ReadValueAsButton(int partNumber);

}

[System.Diagnostics.DebuggerDisplay(@"{DebuggerDisplay(),nq}")] [System.Reflection.DefaultMember(@"Item")] [UnityEngine.Scripting.Preserve] public abstract class InputControl

{

protected UnityEngine.InputSystem.LowLevel.InputStateBlock m_StateBlock;

public UnityEngine.InputSystem.Utilities.ReadOnlyArray<UnityEngine.InputSystem.Utilities.InternedString> aliases { get; }

public UnityEngine.InputSystem.Utilities.ReadOnlyArray<UnityEngine.InputSystem.InputControl> children { get; }

protected void* currentStatePtr { get; }

protected void* defaultStatePtr { get; }

public UnityEngine.InputSystem.InputDevice device { get; }

public string displayName { get; protected set; }

public UnityEngine.InputSystem.InputControl this[string path] { get; }

public string layout { get; }

public string name { get; }

protected void* noiseMaskPtr { get; }

public bool noisy { get; }

public UnityEngine.InputSystem.InputControl parent { get; }

public string path { get; }

protected void* previousFrameStatePtr { get; }

public string shortDisplayName { get; protected set; }

public UnityEngine.InputSystem.LowLevel.InputStateBlock stateBlock { get; }

protected System.UInt32 stateOffsetRelativeToDeviceRoot { get; }

public bool synthetic { get; }

public UnityEngine.InputSystem.Utilities.ReadOnlyArray<UnityEngine.InputSystem.Utilities.InternedString> usages { get; }

public abstract int valueSizeInBytes { get; }

public abstract System.Type valueType { get; }

public string variants { get; }

protected InputControl() {}

public abstract bool CompareValue(void* firstStatePtr, void* secondStatePtr);

public float EvaluateMagnitude();

public virtual float EvaluateMagnitude(void* statePtr);

protected virtual void FinishSetup();

public TControl GetChildControl<TControl>(string path) where TControl : UnityEngine.InputSystem.InputControl;

public UnityEngine.InputSystem.InputControl GetChildControl(string path);

public abstract object ReadValueFromBufferAsObject(void* buffer, int bufferSize);

public abstract object ReadValueFromStateAsObject(void* statePtr);

public abstract void ReadValueFromStateIntoBuffer(void* statePtr, void* bufferPtr, int bufferSize);

protected virtual void RefreshConfiguration();

protected void RefreshConfigurationIfNeeded();

public virtual string ToString();

public TControl TryGetChildControl<TControl>(string path) where TControl : UnityEngine.InputSystem.InputControl;

public UnityEngine.InputSystem.InputControl TryGetChildControl(string path);

public virtual void WriteValueFromBufferIntoState(void* bufferPtr, int bufferSize, void* statePtr);

public virtual void WriteValueFromObjectIntoState(object value, void* statePtr);

}

[UnityEngine.Scripting.Preserve] public abstract class InputControl<TValue> : UnityEngine.InputSystem.InputControl where TValue : System.ValueType, new()

{

public virtual int valueSizeInBytes { get; }

public virtual System.Type valueType { get; }

protected InputControl() {}

public virtual bool CompareValue(void* firstStatePtr, void* secondStatePtr);

public TValue ProcessValue(TValue value);

public TValue ReadDefaultValue();

public TValue ReadUnprocessedValue();

public abstract TValue ReadUnprocessedValueFromState(void* statePtr);

public TValue ReadValue();

public virtual object ReadValueFromBufferAsObject(void* buffer, int bufferSize);

public TValue ReadValueFromPreviousFrame();

public TValue ReadValueFromState(void* statePtr);

public virtual object ReadValueFromStateAsObject(void* statePtr);

public virtual void ReadValueFromStateIntoBuffer(void* statePtr, void* bufferPtr, int bufferSize);

public virtual void WriteValueFromBufferIntoState(void* bufferPtr, int bufferSize, void* statePtr);

public virtual void WriteValueFromObjectIntoState(object value, void* statePtr);

public virtual void WriteValueIntoState(TValue value, void* statePtr);

}

[System.Runtime.CompilerServices.Extension] public static class InputControlExtensions

{

[System.Runtime.CompilerServices.Extension] public static void AccumulateValueInEvent(UnityEngine.InputSystem.InputControl<float> control, void* currentStatePtr, UnityEngine.InputSystem.LowLevel.InputEventPtr newState);

[System.Runtime.CompilerServices.Extension] public static bool CheckStateIsAtDefault(UnityEngine.InputSystem.InputControl control);

[System.Runtime.CompilerServices.Extension] public static bool CheckStateIsAtDefault(UnityEngine.InputSystem.InputControl control, void* statePtr, void* maskPtr = default(void*));

[System.Runtime.CompilerServices.Extension] public static bool CheckStateIsAtDefaultIgnoringNoise(UnityEngine.InputSystem.InputControl control);

[System.Runtime.CompilerServices.Extension] public static bool CheckStateIsAtDefaultIgnoringNoise(UnityEngine.InputSystem.InputControl control, void* statePtr);

[System.Runtime.CompilerServices.Extension] public static bool CompareState(UnityEngine.InputSystem.InputControl control, void* statePtr, void* maskPtr = default(void*));

[System.Runtime.CompilerServices.Extension] public static bool CompareState(UnityEngine.InputSystem.InputControl control, void* firstStatePtr, void* secondStatePtr, void* maskPtr = default(void*));

[System.Runtime.CompilerServices.Extension] public static bool CompareStateIgnoringNoise(UnityEngine.InputSystem.InputControl control, void* statePtr);

[System.Runtime.CompilerServices.Extension] public static void CopyState<TState>(UnityEngine.InputSystem.InputDevice device, out TState state) where TState : System.ValueType, UnityEngine.InputSystem.LowLevel.IInputStateTypeInfo, new();

[System.Runtime.CompilerServices.Extension] public static void CopyState(UnityEngine.InputSystem.InputDevice device, void* buffer, int bufferSizeInBytes);

[System.Runtime.CompilerServices.Extension] public static void FindControlsRecursive<TControl>(UnityEngine.InputSystem.InputControl parent, System.Collections.Generic.IList<TControl> controls, System.Func<TControl, bool> predicate) where TControl : UnityEngine.InputSystem.InputControl;

[System.Runtime.CompilerServices.Extension] public static TControl FindInParentChain<TControl>(UnityEngine.InputSystem.InputControl control) where TControl : UnityEngine.InputSystem.InputControl;

[System.Runtime.CompilerServices.Extension] public static void* GetStatePtrFromStateEvent(UnityEngine.InputSystem.InputControl control, UnityEngine.InputSystem.LowLevel.InputEventPtr eventPtr);

[System.Runtime.CompilerServices.Extension] public static bool HasValueChangeInEvent(UnityEngine.InputSystem.InputControl control, UnityEngine.InputSystem.LowLevel.InputEventPtr eventPtr);

[System.Runtime.CompilerServices.Extension] public static bool HasValueChangeInState(UnityEngine.InputSystem.InputControl control, void* statePtr);

[System.Runtime.CompilerServices.Extension] public static bool IsActuated(UnityEngine.InputSystem.InputControl control, float threshold = 0);

[System.Runtime.CompilerServices.Extension] public static bool IsPressed(UnityEngine.InputSystem.InputControl control, float buttonPressPoint = 0);

[System.Runtime.CompilerServices.Extension] public static void QueueValueChange<TValue>(UnityEngine.InputSystem.InputControl<TValue> control, TValue value, double time = -1) where TValue : System.ValueType, new();

[System.Runtime.CompilerServices.Extension] public static object ReadDefaultValueAsObject(UnityEngine.InputSystem.InputControl control);

[System.Runtime.CompilerServices.Extension] public static TValue ReadUnprocessedValueFromEvent<TValue>(UnityEngine.InputSystem.InputControl<TValue> control, UnityEngine.InputSystem.LowLevel.InputEventPtr eventPtr) where TValue : System.ValueType, new();

[System.Runtime.CompilerServices.Extension] public static bool ReadUnprocessedValueFromEvent<TValue>(UnityEngine.InputSystem.InputControl<TValue> control, UnityEngine.InputSystem.LowLevel.InputEventPtr inputEvent, out TValue value) where TValue : System.ValueType, new();

[System.Runtime.CompilerServices.Extension] public static object ReadValueAsObject(UnityEngine.InputSystem.InputControl control);

[System.Runtime.CompilerServices.Extension] public static TValue ReadValueFromEvent<TValue>(UnityEngine.InputSystem.InputControl<TValue> control, UnityEngine.InputSystem.LowLevel.InputEventPtr inputEvent) where TValue : System.ValueType, new();

[System.Runtime.CompilerServices.Extension] public static bool ReadValueFromEvent<TValue>(UnityEngine.InputSystem.InputControl<TValue> control, UnityEngine.InputSystem.LowLevel.InputEventPtr inputEvent, out TValue value) where TValue : System.ValueType, new();

[System.Runtime.CompilerServices.Extension] public static void ReadValueIntoBuffer(UnityEngine.InputSystem.InputControl control, void* buffer, int bufferSize);

[System.Runtime.CompilerServices.Extension] public static void WriteValueFromObjectIntoEvent(UnityEngine.InputSystem.InputControl control, UnityEngine.InputSystem.LowLevel.InputEventPtr eventPtr, object value);

[System.Runtime.CompilerServices.Extension] public static void WriteValueIntoEvent<TValue>(UnityEngine.InputSystem.InputControl control, TValue value, UnityEngine.InputSystem.LowLevel.InputEventPtr eventPtr) where TValue : System.ValueType, new();

[System.Runtime.CompilerServices.Extension] public static void WriteValueIntoEvent<TValue>(UnityEngine.InputSystem.InputControl<TValue> control, TValue value, UnityEngine.InputSystem.LowLevel.InputEventPtr eventPtr) where TValue : System.ValueType, new();

[System.Runtime.CompilerServices.Extension] public static void WriteValueIntoState(UnityEngine.InputSystem.InputControl control, void* statePtr);

[System.Runtime.CompilerServices.Extension] public static void WriteValueIntoState<TValue>(UnityEngine.InputSystem.InputControl<TValue> control, void* statePtr) where TValue : System.ValueType, new();

[System.Runtime.CompilerServices.Extension] public static void WriteValueIntoState<TValue>(UnityEngine.InputSystem.InputControl control, TValue value, void* statePtr) where TValue : System.ValueType, new();

[System.Runtime.CompilerServices.Extension] public static void WriteValueIntoState<TValue>(UnityEngine.InputSystem.InputControl<TValue> control, TValue value, void* statePtr) where TValue : System.ValueType, new();

[System.Runtime.CompilerServices.Extension] public static void WriteValueIntoState<TValue, TState>(UnityEngine.InputSystem.InputControl<TValue> control, TValue value, ref TState state) where TValue : System.ValueType, new() where TState : System.ValueType, UnityEngine.InputSystem.LowLevel.IInputStateTypeInfo, new();

}

public enum InputControlLayoutChange

{

public const UnityEngine.InputSystem.InputControlLayoutChange Added = 0;

public const UnityEngine.InputSystem.InputControlLayoutChange Removed = 1;

public const UnityEngine.InputSystem.InputControlLayoutChange Replaced = 2;

public int value__;

}

[System.Diagnostics.DebuggerDisplay(@"Count = {Count}")] [System.Diagnostics.DebuggerTypeProxy(typeof(UnityEngine.InputSystem.InputControlListDebugView<>))] [System.Reflection.DefaultMember(@"Item")] public struct InputControlList<TControl> : System.Collections.Generic.ICollection<TControl>, System.Collections.Generic.IEnumerable<TControl>, System.Collections.Generic.IList<TControl>, System.Collections.Generic.IReadOnlyCollection<TControl>, System.Collections.Generic.IReadOnlyList<TControl>, System.Collections.IEnumerable, System.IDisposable where TControl : UnityEngine.InputSystem.InputControl

{

public int Capacity { get; set; }

public virtual int Count { get; }

public virtual bool IsReadOnly { get; }

public virtual TControl this[int index] { get; set; }

public InputControlList(params TControl[] values) {}

public InputControlList(System.Collections.Generic.IEnumerable<TControl> values, Unity.Collections.Allocator allocator = 4) {}

public InputControlList(Unity.Collections.Allocator allocator, int initialCapacity = 0) {}

public virtual void Add(TControl item);

public void AddRange(System.Collections.Generic.IEnumerable<TControl> list, int count = -1, int destinationIndex = -1);

public void AddSlice<TList>(TList list, int count = -1, int destinationIndex = -1, int sourceIndex = 0) where TList : System.Collections.Generic.IReadOnlyList<TControl>;

public virtual void Clear();

public virtual bool Contains(TControl item);

public virtual void CopyTo(TControl[] array, int arrayIndex);

public virtual void Dispose();

public virtual System.Collections.Generic.IEnumerator<TControl> GetEnumerator();

public virtual int IndexOf(TControl item);

public virtual void Insert(int index, TControl item);

public virtual bool Remove(TControl item);

public virtual void RemoveAt(int index);

public void Sort<TCompare>(int startIndex, int count, TCompare comparer) where TCompare : System.Collections.Generic.IComparer<TControl>;

public void SwapElements(int index1, int index2);

public TControl[] ToArray(bool dispose = False);

public virtual string ToString();

}

public static class InputControlPath

{

public const string DoubleWildcard = **;

public const char Separator = /;

public const string Wildcard = *;

public static string Combine(UnityEngine.InputSystem.InputControl parent, string path);

public static bool Matches(string expected, UnityEngine.InputSystem.InputControl control);

public static bool MatchesPrefix(string expected, UnityEngine.InputSystem.InputControl control);

public static string ToHumanReadableString(string path, UnityEngine.InputSystem.InputControlPath.HumanReadableStringOptions options = 0, UnityEngine.InputSystem.InputControl control = default(UnityEngine.InputSystem.InputControl));

public static string ToHumanReadableString(string path, out string deviceLayoutName, out string controlPath, UnityEngine.InputSystem.InputControlPath.HumanReadableStringOptions options = 0, UnityEngine.InputSystem.InputControl control = default(UnityEngine.InputSystem.InputControl));

public static TControl TryFindChild<TControl>(UnityEngine.InputSystem.InputControl control, string path, int indexInPath = 0) where TControl : UnityEngine.InputSystem.InputControl;

public static UnityEngine.InputSystem.InputControl TryFindChild(UnityEngine.InputSystem.InputControl control, string path, int indexInPath = 0);

public static TControl TryFindControl<TControl>(UnityEngine.InputSystem.InputControl control, string path, int indexInPath = 0) where TControl : UnityEngine.InputSystem.InputControl;

public static UnityEngine.InputSystem.InputControl TryFindControl(UnityEngine.InputSystem.InputControl control, string path, int indexInPath = 0);

public static UnityEngine.InputSystem.InputControl[] TryFindControls(UnityEngine.InputSystem.InputControl control, string path, int indexInPath = 0);

public static int TryFindControls<TControl>(UnityEngine.InputSystem.InputControl control, string path, int indexInPath, ref UnityEngine.InputSystem.InputControlList<TControl> matches) where TControl : UnityEngine.InputSystem.InputControl;

public static int TryFindControls(UnityEngine.InputSystem.InputControl control, string path, ref UnityEngine.InputSystem.InputControlList<UnityEngine.InputSystem.InputControl> matches, int indexInPath = 0);

public static string TryGetControlLayout(string path);

public static string TryGetDeviceLayout(string path);

public static string[] TryGetDeviceUsages(string path);

[System.Flags] public enum HumanReadableStringOptions

{

public const UnityEngine.InputSystem.InputControlPath.HumanReadableStringOptions None = 0;

public const UnityEngine.InputSystem.InputControlPath.HumanReadableStringOptions OmitDevice = 2;

public const UnityEngine.InputSystem.InputControlPath.HumanReadableStringOptions UseShortNames = 4;

public int value__;

}

}

public struct InputControlScheme : System.IEquatable<UnityEngine.InputSystem.InputControlScheme>

{

public string bindingGroup { get; set; }

public UnityEngine.InputSystem.Utilities.ReadOnlyArray<UnityEngine.InputSystem.InputControlScheme.DeviceRequirement> deviceRequirements { get; }

public string name { get; }

public InputControlScheme(string name, System.Collections.Generic.IEnumerable<UnityEngine.InputSystem.InputControlScheme.DeviceRequirement> devices = default(System.Collections.Generic.IEnumerable<UnityEngine.InputSystem.InputControlScheme.DeviceRequirement>), string bindingGroup = default(string)) {}

public virtual bool Equals(object obj);

public virtual bool Equals(UnityEngine.InputSystem.InputControlScheme other);

public static System.Nullable<UnityEngine.InputSystem.InputControlScheme> FindControlSchemeForDevice<TSchemes>(UnityEngine.InputSystem.InputDevice device, TSchemes schemes) where TSchemes : System.Collections.Generic.IEnumerable<UnityEngine.InputSystem.InputControlScheme>;

public static System.Nullable<UnityEngine.InputSystem.InputControlScheme> FindControlSchemeForDevices<TDevices, TSchemes>(TDevices devices, TSchemes schemes, UnityEngine.InputSystem.InputDevice mustIncludeDevice = default(UnityEngine.InputSystem.InputDevice), bool allowUnsuccesfulMatch = False) where TDevices : System.Collections.Generic.IReadOnlyList<UnityEngine.InputSystem.InputDevice> where TSchemes : System.Collections.Generic.IEnumerable<UnityEngine.InputSystem.InputControlScheme>;

public static bool FindControlSchemeForDevices<TDevices, TSchemes>(TDevices devices, TSchemes schemes, out UnityEngine.InputSystem.InputControlScheme controlScheme, out UnityEngine.InputSystem.InputControlScheme.MatchResult matchResult, UnityEngine.InputSystem.InputDevice mustIncludeDevice = default(UnityEngine.InputSystem.InputDevice), bool allowUnsuccessfulMatch = False) where TDevices : System.Collections.Generic.IReadOnlyList<UnityEngine.InputSystem.InputDevice> where TSchemes : System.Collections.Generic.IEnumerable<UnityEngine.InputSystem.InputControlScheme>;

public virtual int GetHashCode();

public static bool operator ==(UnityEngine.InputSystem.InputControlScheme left, UnityEngine.InputSystem.InputControlScheme right);

public static bool operator !=(UnityEngine.InputSystem.InputControlScheme left, UnityEngine.InputSystem.InputControlScheme right);

public UnityEngine.InputSystem.InputControlScheme.MatchResult PickDevicesFrom<TDevices>(TDevices devices, UnityEngine.InputSystem.InputDevice favorDevice = default(UnityEngine.InputSystem.InputDevice)) where TDevices : System.Collections.Generic.IReadOnlyList<UnityEngine.InputSystem.InputDevice>;

public bool SupportsDevice(UnityEngine.InputSystem.InputDevice device);

public virtual string ToString();

public struct DeviceRequirement : System.IEquatable<UnityEngine.InputSystem.InputControlScheme.DeviceRequirement>

{

public string controlPath { get; set; }

public bool isAND { get; set; }

public bool isOptional { get; set; }

public bool isOR { get; set; }

public virtual bool Equals(object obj);

public virtual bool Equals(UnityEngine.InputSystem.InputControlScheme.DeviceRequirement other);

public virtual int GetHashCode();

public static bool operator ==(UnityEngine.InputSystem.InputControlScheme.DeviceRequirement left, UnityEngine.InputSystem.InputControlScheme.DeviceRequirement right);

public static bool operator !=(UnityEngine.InputSystem.InputControlScheme.DeviceRequirement left, UnityEngine.InputSystem.InputControlScheme.DeviceRequirement right);

public virtual string ToString();

}

[System.Reflection.DefaultMember(@"Item")] public struct MatchResult : System.Collections.Generic.IEnumerable<UnityEngine.InputSystem.InputControlScheme.MatchResult.Match>, System.Collections.IEnumerable, System.IDisposable

{

public UnityEngine.InputSystem.InputControlList<UnityEngine.InputSystem.InputDevice> devices { get; }

public bool hasMissingOptionalDevices { get; }

public bool hasMissingRequiredDevices { get; }

public bool isSuccessfulMatch { get; }

public UnityEngine.InputSystem.InputControlScheme.MatchResult.Match this[int index] { get; }

public float score { get; }

public virtual void Dispose();

public virtual System.Collections.Generic.IEnumerator<UnityEngine.InputSystem.InputControlScheme.MatchResult.Match> GetEnumerator();

public struct Match

{

public UnityEngine.InputSystem.InputControl control { get; }

public UnityEngine.InputSystem.InputDevice device { get; }

public bool isOptional { get; }

public UnityEngine.InputSystem.InputControlScheme.DeviceRequirement requirement { get; }

public int requirementIndex { get; }

}

}

}

[UnityEngine.Scripting.Preserve] public class InputDevice : UnityEngine.InputSystem.InputControl

{

public const int InvalidDeviceId = 0;

public bool added { get; }

[System.Obsolete(@"Use 'InputSystem.devices' instead. (UnityUpgradable) -> InputSystem.devices", false)] public static UnityEngine.InputSystem.Utilities.ReadOnlyArray<UnityEngine.InputSystem.InputDevice> all { get; }

public UnityEngine.InputSystem.Utilities.ReadOnlyArray<UnityEngine.InputSystem.InputControl> allControls { get; }

public bool canRunInBackground { get; }

public UnityEngine.InputSystem.Layouts.InputDeviceDescription description { get; }

public int deviceId { get; }

public bool enabled { get; }

public double lastUpdateTime { get; }

public bool native { get; }

public bool remote { get; }

public bool updateBeforeRender { get; }

public virtual int valueSizeInBytes { get; }

public virtual System.Type valueType { get; }

public bool wasUpdatedThisFrame { get; }

public InputDevice() {}

public virtual bool CompareValue(void* firstStatePtr, void* secondStatePtr);

public long ExecuteCommand<TCommand>(ref TCommand command) where TCommand : System.ValueType, UnityEngine.InputSystem.LowLevel.IInputDeviceCommandInfo, new();

public virtual void MakeCurrent();

protected virtual void OnAdded();

protected virtual void OnRemoved();

public virtual object ReadValueFromBufferAsObject(void* buffer, int bufferSize);

public virtual object ReadValueFromStateAsObject(void* statePtr);

public virtual void ReadValueFromStateIntoBuffer(void* statePtr, void* bufferPtr, int bufferSize);

}

public enum InputDeviceChange

{

public const UnityEngine.InputSystem.InputDeviceChange Added = 0;

public const UnityEngine.InputSystem.InputDeviceChange ConfigurationChanged = 7;

public const UnityEngine.InputSystem.InputDeviceChange Destroyed = 8;

public const UnityEngine.InputSystem.InputDeviceChange Disabled = 5;

public const UnityEngine.InputSystem.InputDeviceChange Disconnected = 2;

public const UnityEngine.InputSystem.InputDeviceChange Enabled = 4;

public const UnityEngine.InputSystem.InputDeviceChange Reconnected = 3;

public const UnityEngine.InputSystem.InputDeviceChange Removed = 1;

public const UnityEngine.InputSystem.InputDeviceChange UsageChanged = 6;

public int value__;

}

[System.Runtime.CompilerServices.Extension] public static class InputExtensions

{

[System.Runtime.CompilerServices.Extension] public static bool IsActive(UnityEngine.InputSystem.TouchPhase phase);

[System.Runtime.CompilerServices.Extension] public static bool IsEndedOrCanceled(UnityEngine.InputSystem.TouchPhase phase);