// 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 override 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 override 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 override void FinishSetup();

}

[UnityEngine.InputSystem.Layouts.InputControlLayout(displayName = @"Oculus Headset (w/ on-headset controls)")] [UnityEngine.Scripting.Preserve] public class OculusHMDExtended : 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 override 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 override 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 override 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 override void FinishSetup();

}

}

namespace Unity.XR.OpenVR

{

[UnityEngine.InputSystem.Layouts.InputControlLayout(commonUsages = Mono.Cecil.CustomAttributeArgument[], displayName = @"Handed Vive Tracker")] [UnityEngine.Scripting.Preserve] public class HandedViveTracker : 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 override 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 override 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 override 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 override 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 override 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 override void FinishSetup();

}

}

namespace UnityEngine.InputSystem

{

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

{

public Controls.Vector3Control acceleration { get; }

public static Accelerometer current { get; }

public Accelerometer() {}

protected override void FinishSetup();

public override void MakeCurrent();

protected override void OnRemoved();

}

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

{

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

public static AmbientTemperatureSensor current { get; }

public AmbientTemperatureSensor() {}

protected override void FinishSetup();

public override void MakeCurrent();

protected override void OnRemoved();

}

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

{

public Controls.QuaternionControl attitude { get; }

public static AttitudeSensor current { get; }

public AttitudeSensor() {}

protected override void FinishSetup();

public override void MakeCurrent();

protected override void OnRemoved();

}

public static class CommonUsages

{

public static readonly Utilities.InternedString Back;

public static readonly Utilities.InternedString BatteryStrength;

public static readonly Utilities.InternedString Cancel;

public static readonly Utilities.InternedString Forward;

public static readonly Utilities.InternedString Hatswitch;

public static readonly Utilities.InternedString HighFreqMotor;

public static readonly Utilities.InternedString Horizontal;

public static readonly Utilities.InternedString LeftHand;

public static readonly Utilities.InternedString LowFreqMotor;

public static readonly Utilities.InternedString Menu;

public static readonly Utilities.InternedString Modifier;

public static readonly Utilities.InternedString Orientation;

public static readonly Utilities.InternedString Point;

public static readonly Utilities.InternedString Position;

public static readonly Utilities.InternedString Pressure;

public static readonly Utilities.InternedString Primary2DMotion;

public static readonly Utilities.InternedString PrimaryAction;

public static readonly Utilities.InternedString PrimaryTrigger;

public static readonly Utilities.InternedString RightHand;

public static readonly Utilities.InternedString ScrollHorizontal;

public static readonly Utilities.InternedString ScrollVertical;

public static readonly Utilities.InternedString Secondary2DMotion;

public static readonly Utilities.InternedString SecondaryAction;

public static readonly Utilities.InternedString SecondaryTrigger;

public static readonly Utilities.InternedString Submit;

public static readonly Utilities.InternedString Twist;

public static readonly Utilities.InternedString Vertical;

}

[Layouts.InputControlLayout(isGenericTypeOfDevice = true, stateType = typeof(LowLevel.GamepadState))] [UnityEngine.Scripting.Preserve] public class Gamepad : InputDevice, Haptics.IDualMotorRumble, Haptics.IHaptics

{

public Controls.ButtonControl aButton { get; }

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

public Controls.ButtonControl bButton { get; }

public Controls.ButtonControl buttonEast { get; }

public Controls.ButtonControl buttonNorth { get; }

public Controls.ButtonControl buttonSouth { get; }

public Controls.ButtonControl buttonWest { get; }

public Controls.ButtonControl circleButton { get; }

public Controls.ButtonControl crossButton { get; }

public static Gamepad current { get; }

public Controls.DpadControl dpad { get; }

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

public Controls.ButtonControl leftShoulder { get; }

public Controls.StickControl leftStick { get; }

public Controls.ButtonControl leftStickButton { get; }

public Controls.ButtonControl leftTrigger { get; }

public Controls.ButtonControl rightShoulder { get; }

public Controls.StickControl rightStick { get; }

public Controls.ButtonControl rightStickButton { get; }

public Controls.ButtonControl rightTrigger { get; }

public Controls.ButtonControl selectButton { get; }

public Controls.ButtonControl squareButton { get; }

public Controls.ButtonControl startButton { get; }

public Controls.ButtonControl triangleButton { get; }

public Controls.ButtonControl xButton { get; }

public Controls.ButtonControl yButton { get; }

public Gamepad() {}

protected override void FinishSetup();

public override void MakeCurrent();

protected override void OnAdded();

protected override void OnRemoved();

public virtual void PauseHaptics();

public virtual void ResetHaptics();

public virtual void ResumeHaptics();

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

}

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

{

public static GravitySensor current { get; }

public Controls.Vector3Control gravity { get; }

public GravitySensor() {}

protected override void FinishSetup();

public override void MakeCurrent();

protected override void OnRemoved();

}

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

{

public Controls.Vector3Control angularVelocity { get; }

public static Gyroscope current { get; }

public Gyroscope() {}

protected override void FinishSetup();

public override void MakeCurrent();

protected override void OnRemoved();

}

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

{

public static HumiditySensor current { get; }

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

public HumiditySensor() {}

protected override void FinishSetup();

public override void MakeCurrent();

protected override void OnRemoved();

}

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

{

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

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

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

public bool Contains(InputAction action);

public void Disable();

public void Enable();

}

[UnityEngine.Scripting.Preserve] public interface IInputInteraction

{

public void Process(ref InputInteractionContext context);

public void Reset();

}

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

{

}

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

{

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

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

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

public InputActionMap actionMap { get; }

public InputControl activeControl { get; }

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

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

public UnityEngine.InputSystem.Utilities.ReadOnlyArray<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 InputActionPhase phase { get; }

public string processors { get; }

public bool triggered { get; }

public InputActionType type { get; }

public InputAction() {}

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

public InputAction Clone();

public void Disable();

public void Dispose();

public void Enable();

public TValue ReadValue<TValue>() where TValue : struct, new();

public object ReadValueAsObject();

public override string ToString();

public struct CallbackContext

{

public InputAction action { get; }

public bool canceled { get; }

public InputControl control { get; }

public double duration { get; }

public IInputInteraction interaction { get; }

public bool performed { get; }

public 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 : struct, new();

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

public bool ReadValueAsButton();

public object ReadValueAsObject();

public override string ToString();

}

}

public class InputActionAsset : ScriptableObject, IInputActionCollection, System.Collections.Generic.IEnumerable<InputAction>, System.Collections.IEnumerable

{

public const string Extension = @"inputactions";

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

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

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

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

public bool enabled { get; }

public InputAction this[string actionNameOrId] { get; }

public InputActionAsset() {}

public bool Contains(InputAction action);

public void Disable();

public void Enable();

public InputAction FindAction(System.Guid guid);

public InputAction FindAction(string actionNameOrId, bool throwIfNotFound = false);

public InputActionMap FindActionMap(System.Guid id);

public InputActionMap FindActionMap(string nameOrId, bool throwIfNotFound = false);

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

public int FindControlSchemeIndex(string name);

public static InputActionAsset FromJson(string json);

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

public void LoadFromJson(string json);

public string ToJson();

}

public enum InputActionChange

{

ActionCanceled = 6,

ActionDisabled = 1,

ActionEnabled = 0,

ActionMapDisabled = 3,

ActionMapEnabled = 2,

ActionPerformed = 5,

ActionStarted = 4,

BoundControlsAboutToChange = 7,

BoundControlsChanged = 8,

}

public sealed class InputActionMap : IInputActionCollection, ISerializationCallbackReceiver, System.Collections.Generic.IEnumerable<InputAction>, System.Collections.IEnumerable, System.ICloneable, System.IDisposable

{

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

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

public InputActionAsset asset { get; }

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

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

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

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

public bool enabled { get; }

public System.Guid id { get; }

public InputAction this[string actionNameOrId] { get; }

public string name { get; }

public InputActionMap() {}

public InputActionMap(string name) {}

public InputActionMap Clone();

public bool Contains(InputAction action);

public void Disable();

public void Dispose();

public void Enable();

public InputAction FindAction(System.Guid id);

public InputAction FindAction(string nameOrId, bool throwIfNotFound = false);

public static InputActionMap[] FromJson(string json);

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

public bool IsUsableWithDevice(InputDevice device);

public void OnAfterDeserialize();

public void OnBeforeSerialize();

public string ToJson();

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

public override string ToString();

}

public enum InputActionPhase

{

Canceled = 4,

Disabled = 0,

Performed = 3,

Started = 2,

Waiting = 1,

}

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

{

public InputAction action { get; }

public InputActionReference reference { get; }

public InputActionProperty(InputAction action) {}

public InputActionProperty(InputActionReference reference) {}

public override bool Equals(object obj);

public bool Equals(InputAction other);

public bool Equals(InputActionProperty other);

public bool Equals(InputActionReference other);

public override int GetHashCode();

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

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

}

public static class InputActionRebindingExtensions

{

public static int ApplyBindingOverride(this InputActionMap actionMap, InputBinding bindingOverride);

public static void ApplyBindingOverride(this InputAction action, InputBinding bindingOverride);

public static void ApplyBindingOverride(this InputAction action, int bindingIndex, string path);

public static void ApplyBindingOverride(this InputAction action, int bindingIndex, InputBinding bindingOverride);

public static void ApplyBindingOverride(this InputActionMap actionMap, int bindingIndex, InputBinding bindingOverride);

public static void ApplyBindingOverride(this InputAction action, string newPath, string group = default(string), string path = default(string));

public static void ApplyBindingOverrides(this InputActionMap actionMap, System.Collections.Generic.IEnumerable<InputBinding> overrides);

public static int ApplyBindingOverridesOnMatchingControls(this InputAction action, InputControl control);

public static int ApplyBindingOverridesOnMatchingControls(this InputActionMap actionMap, InputControl control);

public static string GetBindingDisplayString(this InputAction action, int bindingIndex, InputBinding.DisplayStringOptions options = );

public static string GetBindingDisplayString(this InputAction action, InputBinding bindingMask, InputBinding.DisplayStringOptions options = );

public static string GetBindingDisplayString(this InputAction action, InputBinding.DisplayStringOptions options = , string group = default(string));

public static string GetBindingDisplayString(this InputAction action, int bindingIndex, out string deviceLayoutName, out string controlPath, InputBinding.DisplayStringOptions options = );

public static System.Nullable<InputBinding> GetBindingForControl(this InputAction action, InputControl control);

public static int GetBindingIndex(this InputAction action, InputBinding bindingMask);

public static int GetBindingIndex(this InputAction action, string group = default(string), string path = default(string));

public static int GetBindingIndexForControl(this InputAction action, InputControl control);

public static InputActionRebindingExtensions.RebindingOperation PerformInteractiveRebinding(this InputAction action, int bindingIndex = -1);

public static void RemoveAllBindingOverrides(this InputAction action);

public static void RemoveAllBindingOverrides(this InputActionMap actionMap);

public static void RemoveBindingOverride(this InputAction action, int bindingIndex);

public static void RemoveBindingOverride(this InputAction action, InputBinding bindingMask);

public static void RemoveBindingOverrides(this InputActionMap actionMap, System.Collections.Generic.IEnumerable<InputBinding> overrides);

public sealed class RebindingOperation : System.IDisposable

{

public const float kDefaultMagnitudeThreshold = 0.2f;

public InputAction action { get; }

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

public bool canceled { get; }

public UnityEngine.InputSystem.InputControlList<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 InputControl selectedControl { get; }

public bool started { get; }

public double startTime { get; }

public float timeout { get; }

public RebindingOperation() {}

public void AddCandidate(InputControl control, float score, float magnitude = -1f);

public void Cancel();

public void Complete();

public void Dispose();

protected override void Finalize();

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

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

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

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

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

public InputActionRebindingExtensions.RebindingOperation OnMatchWaitForAnother(float seconds);

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

public void RemoveCandidate(InputControl control);

public InputActionRebindingExtensions.RebindingOperation Reset();

public InputActionRebindingExtensions.RebindingOperation Start();

public InputActionRebindingExtensions.RebindingOperation WithAction(InputAction action);

public InputActionRebindingExtensions.RebindingOperation WithBindingGroup(string group);

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

public InputActionRebindingExtensions.RebindingOperation WithCancelingThrough(string binding);

public InputActionRebindingExtensions.RebindingOperation WithCancelingThrough(InputControl control);

public InputActionRebindingExtensions.RebindingOperation WithControlsExcluding(string path);

public InputActionRebindingExtensions.RebindingOperation WithControlsHavingToMatchPath(string path);

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

public InputActionRebindingExtensions.RebindingOperation WithExpectedControlType(string layoutName);

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

public InputActionRebindingExtensions.RebindingOperation WithMagnitudeHavingToBeGreaterThan(float magnitude);

public InputActionRebindingExtensions.RebindingOperation WithMatchingEventsBeingSuppressed(bool value = true);

public InputActionRebindingExtensions.RebindingOperation WithoutGeneralizingPathOfSelectedControl();

public InputActionRebindingExtensions.RebindingOperation WithoutIgnoringNoisyControls();

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

public InputActionRebindingExtensions.RebindingOperation WithTargetBinding(int bindingIndex);

public InputActionRebindingExtensions.RebindingOperation WithTimeout(float timeInSeconds);

}

}

public class InputActionReference : ScriptableObject

{

public InputAction action { get; }

public InputActionAsset asset { get; }

public InputActionReference() {}

public static InputActionReference Create(InputAction action);

public static InputAction op_Implicit(InputActionReference reference);

public void Set(InputAction action);

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

public InputAction ToInputAction();

public override string ToString();

}

public static class InputActionSetupExtensions

{

public static InputAction AddAction(this InputActionMap map, string name, InputActionType type = InputActionType.Value, string binding = default(string), string interactions = default(string), string processors = default(string), string groups = default(string), string expectedControlLayout = default(string));

public static void AddActionMap(this InputActionAsset asset, InputActionMap map);

public static InputActionMap AddActionMap(this InputActionAsset asset, string name);

public static InputActionSetupExtensions.BindingSyntax AddBinding(this InputAction action, InputBinding binding = default(InputBinding));

public static InputActionSetupExtensions.BindingSyntax AddBinding(this InputAction action, InputControl control);

public static InputActionSetupExtensions.BindingSyntax AddBinding(this InputActionMap actionMap, InputBinding binding);

public static InputActionSetupExtensions.BindingSyntax AddBinding(this InputAction action, string path, string interactions = default(string), string processors = default(string), string groups = default(string));

public static InputActionSetupExtensions.BindingSyntax AddBinding(this InputActionMap actionMap, string path, System.Guid action, string interactions = default(string), string groups = default(string));

public static InputActionSetupExtensions.BindingSyntax AddBinding(this InputActionMap actionMap, string path, string interactions = default(string), string groups = default(string), string action = default(string));

public static InputActionSetupExtensions.BindingSyntax AddBinding(this InputActionMap actionMap, string path, InputAction action, string interactions = default(string), string groups = default(string));

public static InputActionSetupExtensions.CompositeSyntax AddCompositeBinding(this InputAction action, string composite, string interactions = default(string), string processors = default(string));

public static void AddControlScheme(this InputActionAsset asset, InputControlScheme controlScheme);

public static InputActionSetupExtensions.ControlSchemeSyntax AddControlScheme(this InputActionAsset asset, string name);

public static InputActionSetupExtensions.BindingSyntax ChangeBinding(this InputAction action, int index);

public static InputActionSetupExtensions.BindingSyntax ChangeBinding(this InputAction action, InputBinding match);

public static InputActionSetupExtensions.BindingSyntax ChangeBindingWithGroup(this InputAction action, string group);

public static InputActionSetupExtensions.BindingSyntax ChangeBindingWithId(this InputAction action, System.Guid id);

public static InputActionSetupExtensions.BindingSyntax ChangeBindingWithId(this InputAction action, string id);

public static InputActionSetupExtensions.BindingSyntax ChangeBindingWithPath(this InputAction action, string path);

public static InputControlScheme OrWithOptionalDevice(this InputControlScheme scheme, string controlPath);

public static InputControlScheme OrWithRequiredDevice(this InputControlScheme scheme, string controlPath);

public static void RemoveAction(this InputAction action);

public static void RemoveAction(this InputActionAsset asset, string nameOrId);

public static void RemoveActionMap(this InputActionAsset asset, string nameOrId);

public static void RemoveActionMap(this InputActionAsset asset, InputActionMap map);

public static void RemoveControlScheme(this InputActionAsset asset, string name);

public static void Rename(this InputAction action, string newName);

public static InputControlScheme WithBindingGroup(this InputControlScheme scheme, string bindingGroup);

public static InputControlScheme WithOptionalDevice(this InputControlScheme scheme, string controlPath);

public static InputControlScheme WithRequiredDevice(this InputControlScheme scheme, string controlPath);

public struct BindingSyntax

{

public void Erase();

public InputActionSetupExtensions.BindingSyntax To(InputBinding binding);

public InputActionSetupExtensions.BindingSyntax Triggering(InputAction action);

public InputActionSetupExtensions.BindingSyntax WithGroup(string group);

public InputActionSetupExtensions.BindingSyntax WithGroups(string groups);

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

public InputActionSetupExtensions.BindingSyntax WithInteraction(string interaction);

public InputActionSetupExtensions.BindingSyntax WithInteractions(string interactions);

public InputActionSetupExtensions.BindingSyntax WithName(string name);

public InputActionSetupExtensions.BindingSyntax WithPath(string path);

public InputActionSetupExtensions.BindingSyntax WithProcessor<TProcessor>();

public InputActionSetupExtensions.BindingSyntax WithProcessor(string processor);

public InputActionSetupExtensions.BindingSyntax WithProcessors(string processors);

}

public struct CompositeSyntax

{

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

}

public struct ControlSchemeSyntax

{

public InputControlScheme Done();

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

public InputActionSetupExtensions.ControlSchemeSyntax OrWithOptionalDevice(string controlPath);

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

public InputActionSetupExtensions.ControlSchemeSyntax OrWithRequiredDevice(string controlPath);

public InputActionSetupExtensions.ControlSchemeSyntax WithBindingGroup(string bindingGroup);

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

public InputActionSetupExtensions.ControlSchemeSyntax WithOptionalDevice(string controlPath);

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

public InputActionSetupExtensions.ControlSchemeSyntax WithRequiredDevice(string controlPath);

}

}

public enum InputActionType

{

Button = 1,

PassThrough = 2,

Value = 0,

}

public struct InputBinding : System.IEquatable<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 override bool Equals(object obj);

public bool Equals(InputBinding other);

public override int GetHashCode();

public string GetNameOfComposite();

public static InputBinding MaskByGroup(string group);

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

public bool Matches(InputBinding binding);

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

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

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

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

public override string ToString();

[System.Flags] public enum DisplayStringOptions

{

DontIncludeInteractions = 4,

DontOmitDevice = 2,

DontUseShortDisplayNames = 1,

IgnoreBindingOverrides = 8,

}

}

[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 InputBindingCompositeContext context);

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

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

public abstract object ReadValueAsObject(ref InputBindingCompositeContext context);

}

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

{

public override int valueSizeInBytes { get; }

public override System.Type valueType { get; }

protected InputBindingComposite() {}

public abstract TValue ReadValue(ref InputBindingCompositeContext context);

public override void ReadValue(ref InputBindingCompositeContext context, void* buffer, int bufferSize);

public override object ReadValueAsObject(ref InputBindingCompositeContext context);

}

public struct InputBindingCompositeContext

{

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

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

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

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

public bool ReadValueAsButton(int partNumber);

}

[UnityEngine.Scripting.Preserve] public abstract class InputControl

{

protected LowLevel.InputStateBlock m_StateBlock;

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

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

protected void* currentStatePtr { get; }

protected void* defaultStatePtr { get; }

public InputDevice device { get; }

public string displayName { get; protected set; }

public InputControl this[string path] { get; }

public string layout { get; }

public string name { get; }

protected void* noiseMaskPtr { get; }

public bool noisy { get; }

public InputControl parent { get; }

public string path { get; }

protected void* previousFrameStatePtr { get; }

public string shortDisplayName { get; protected set; }

public LowLevel.InputStateBlock stateBlock { get; }

protected System.UInt32 stateOffsetRelativeToDeviceRoot { get; }

public bool synthetic { get; }

public UnityEngine.InputSystem.Utilities.ReadOnlyArray<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 : InputControl;

public 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 override string ToString();

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

public 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> : InputControl where TValue : struct, new()

{

public override int valueSizeInBytes { get; }

public override System.Type valueType { get; }

protected InputControl() {}

public override 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 override object ReadValueFromBufferAsObject(void* buffer, int bufferSize);

public TValue ReadValueFromPreviousFrame();

public TValue ReadValueFromState(void* statePtr);

public override object ReadValueFromStateAsObject(void* statePtr);

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

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

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

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

}

public static class InputControlExtensions

{

public static void AccumulateValueInEvent(this UnityEngine.InputSystem.InputControl<float> control, void* currentStatePtr, LowLevel.InputEventPtr newState);

public static bool CheckStateIsAtDefault(this InputControl control);

public static bool CheckStateIsAtDefault(this InputControl control, void* statePtr, void* maskPtr = default(void*));

public static bool CheckStateIsAtDefaultIgnoringNoise(this InputControl control);

public static bool CheckStateIsAtDefaultIgnoringNoise(this InputControl control, void* statePtr);

public static bool CompareState(this InputControl control, void* statePtr, void* maskPtr = default(void*));

public static bool CompareState(this InputControl control, void* firstStatePtr, void* secondStatePtr, void* maskPtr = default(void*));

public static bool CompareStateIgnoringNoise(this InputControl control, void* statePtr);

public static void CopyState<TState>(this InputDevice device, out TState state) where TState : struct, LowLevel.IInputStateTypeInfo, new();

public static void CopyState(this InputDevice device, void* buffer, int bufferSizeInBytes);

public static void FindControlsRecursive<TControl>(this InputControl parent, System.Collections.Generic.IList<TControl> controls, System.Func<TControl, bool> predicate) where TControl : InputControl;

public static TControl FindInParentChain<TControl>(this InputControl control) where TControl : InputControl;

public static void* GetStatePtrFromStateEvent(this InputControl control, LowLevel.InputEventPtr eventPtr);

public static bool HasValueChangeInEvent(this InputControl control, LowLevel.InputEventPtr eventPtr);

public static bool HasValueChangeInState(this InputControl control, void* statePtr);

public static bool IsActuated(this InputControl control, float threshold = 0f);

public static bool IsPressed(this InputControl control, float buttonPressPoint = 0f);

public static void QueueValueChange<TValue>(this UnityEngine.InputSystem.InputControl<TValue> control, TValue value, double time = -1d) where TValue : struct, new();

public static object ReadDefaultValueAsObject(this InputControl control);

public static TValue ReadUnprocessedValueFromEvent<TValue>(this UnityEngine.InputSystem.InputControl<TValue> control, LowLevel.InputEventPtr eventPtr) where TValue : struct, new();

public static bool ReadUnprocessedValueFromEvent<TValue>(this UnityEngine.InputSystem.InputControl<TValue> control, LowLevel.InputEventPtr inputEvent, out TValue value) where TValue : struct, new();

public static object ReadValueAsObject(this InputControl control);

public static TValue ReadValueFromEvent<TValue>(this UnityEngine.InputSystem.InputControl<TValue> control, LowLevel.InputEventPtr inputEvent) where TValue : struct, new();

public static bool ReadValueFromEvent<TValue>(this UnityEngine.InputSystem.InputControl<TValue> control, LowLevel.InputEventPtr inputEvent, out TValue value) where TValue : struct, new();

public static void ReadValueIntoBuffer(this InputControl control, void* buffer, int bufferSize);

public static void WriteValueFromObjectIntoEvent(this InputControl control, LowLevel.InputEventPtr eventPtr, object value);

public static void WriteValueIntoEvent<TValue>(this InputControl control, TValue value, LowLevel.InputEventPtr eventPtr) where TValue : struct, new();

public static void WriteValueIntoEvent<TValue>(this UnityEngine.InputSystem.InputControl<TValue> control, TValue value, LowLevel.InputEventPtr eventPtr) where TValue : struct, new();

public static void WriteValueIntoState(this InputControl control, void* statePtr);

public static void WriteValueIntoState<TValue>(this UnityEngine.InputSystem.InputControl<TValue> control, void* statePtr) where TValue : struct, new();

public static void WriteValueIntoState<TValue>(this InputControl control, TValue value, void* statePtr) where TValue : struct, new();

public static void WriteValueIntoState<TValue>(this UnityEngine.InputSystem.InputControl<TValue> control, TValue value, void* statePtr) where TValue : struct, new();

public static void WriteValueIntoState<TValue, TState>(this UnityEngine.InputSystem.InputControl<TValue> control, TValue value, ref TState state) where TValue : struct, new() where TState : struct, LowLevel.IInputStateTypeInfo, new();

}

public enum InputControlLayoutChange

{

Added = 0,

Removed = 1,

Replaced = 2,

}

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 : InputControl

{

public int Capacity { get; set; }

public int Count { get; }

public bool IsReadOnly { get; }

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

public InputControlList(params TControl[] values) {}

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

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

public 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 void Clear();

public bool Contains(TControl item);

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

public void Dispose();

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

public int IndexOf(TControl item);

public void Insert(int index, TControl item);

public bool Remove(TControl item);

public 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 override string ToString();

}

public static class InputControlPath

{

public const string DoubleWildcard = @"**";

public const char Separator = /;

public const string Wildcard = @"*";

public static string Combine(InputControl parent, string path);

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

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

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

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

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

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

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

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

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

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

public static int TryFindControls(InputControl control, string path, ref UnityEngine.InputSystem.InputControlList<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

{

None = 0,

OmitDevice = 2,

UseShortNames = 4,

}

}

public struct InputControlScheme : System.IEquatable<InputControlScheme>

{

public string bindingGroup { get; set; }

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

public string name { get; }

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

public override bool Equals(object obj);

public bool Equals(InputControlScheme other);

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

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

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

public override int GetHashCode();

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

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

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

public bool SupportsDevice(InputDevice device);

public override string ToString();

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

{

public string controlPath { get; set; }

public bool isAND { get; set; }

public bool isOptional { get; set; }

public bool isOR { get; set; }

public override bool Equals(object obj);

public bool Equals(InputControlScheme.DeviceRequirement other);

public override int GetHashCode();

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

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

public override string ToString();

}

public struct MatchResult : System.Collections.Generic.IEnumerable<InputControlScheme.MatchResult.Match>, System.Collections.IEnumerable, System.IDisposable

{

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

public bool hasMissingOptionalDevices { get; }

public bool hasMissingRequiredDevices { get; }

public bool isSuccessfulMatch { get; }

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

public float score { get; }

public void Dispose();

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

public struct Match

{

public InputControl control { get; }

public InputDevice device { get; }

public bool isOptional { get; }

public InputControlScheme.DeviceRequirement requirement { get; }

public int requirementIndex { get; }

}

}

}

[UnityEngine.Scripting.Preserve] public class InputDevice : 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<InputDevice> all { get; }

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

public bool canRunInBackground { get; }

public 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 override int valueSizeInBytes { get; }

public override System.Type valueType { get; }

public bool wasUpdatedThisFrame { get; }

public InputDevice() {}

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

public long ExecuteCommand<TCommand>(ref TCommand command) where TCommand : struct, LowLevel.IInputDeviceCommandInfo, new();

public virtual void MakeCurrent();

protected virtual void OnAdded();

protected virtual void OnRemoved();

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

public override object ReadValueFromStateAsObject(void* statePtr);

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

}

public enum InputDeviceChange

{

Added = 0,

ConfigurationChanged = 7,

Destroyed = 8,

Disabled = 5,

Disconnected = 2,

Enabled = 4,

Reconnected = 3,

Removed = 1,

UsageChanged = 6,

}

public static class InputExtensions

{

public static bool IsActive(this TouchPhase phase);

public static bool IsEndedOrCanceled(this TouchPhase phase);

public static bool IsModifierKey(this Key key);

public static bool IsTextInputKey(this Key key);

}

public struct InputInteractionContext

{

public InputAction action { get; }