Namespace Leap¶

namespace Leap

HandModelBase defines abstract methods as a template for building Leap hand models

Typedefs

TestHandPose = TestHandFactory.TestHandPose

Enums

enum LeapEvent

An enumeration defining the types of Leap Motion events.

Since: 3.0

Values:

EVENT_CONNECTION: A connection event has occurred.

EVENT_CONNECTION_LOST: The connection with the service has been lost.

EVENT_DEVICE: A device event has occurred.

EVENT_DEVICE_FAILURE: A device failure event has occurred.

EVENT_DEVICE_LOST: Event asserted when the underlying device object has been lost.

EVENT_POLICY_CHANGE: A change in policy occurred.

EVENT_CONFIG_RESPONSE: Response to a Config value request.

EVENT_CONFIG_CHANGE: Success response to a Config value change.

EVENT_FRAME: A tracking frame has been received.

EVENT_INTERNAL_FRAME: An internal tracking frame has been received.

EVENT_IMAGE_COMPLETE: A requested image is available.

EVENT_IMAGE_REQUEST_FAILED: A requested image could not be provided.

EVENT_DISTORTION_CHANGE: The distortion matrix used for image correction has changed.

EVENT_LOG_EVENT: A diagnostic event has occurred.

EVENT_INIT

EVENT_DROPPED_FRAME

EVENT_IMAGE: An unrequested image is available.

EVENT_POINT_MAPPING_CHANGE

EVENT_HEAD_POSE

EVENT_FIDUCIAL_POSE

enum MessageSeverity

Reports whether the message is for a severe failure, a recoverable warning, or a status change.

Since: 3.0

Values:

MESSAGE_UNKNOWN

MESSAGE_CRITICAL

MESSAGE_WARNING

MESSAGE_INFORMATION: A verbose, informational message

enum Chirality

Supported chiralities

Values:

Left

Right

enum ModelType

Supported hand model types

Values:

Graphics

Physics

enum TrackingSource

Used to determine the source of the tracking data. NONE - Either not available or has not been detemined yet LEAPC - A direct connection to the Leap Service via LeapC OPENXR - An OpenXR connection, most likely not Ultraleap Tracking OPENXR_LEAP - An OpenXR connection, Ultraleap OpenXR layer is also active

Values:

NONE

LEAPC

OPENXR

OPENXR_LEAP

enum ChiralitySelection

Values:

LEFT

RIGHT

BOTH

NONE

class ActionDetector : public MonoBehaviour: Subclassed by Leap.GrabDetector, Leap.PinchDetector

class Anchor : public MonoBehaviour

class AnchorableBehaviour : public MonoBehaviour

AnchorableBehaviours mix well with InteractionBehaviours you’d like to be able to pick up and place in specific locations, specified by other GameObjects with an Anchor component.

Subclassed by Leap.PhysicalHandsAnchorable

class AnchorGroup : public MonoBehaviour

class AnchorSet : public Leap.SerializableHashSet<Anchor>

class Arm : public Leap.Bone, public IEquatable<Arm>: The Arm class represents the forearm.

struct BeginProfilingBlockArgs

struct BeginProfilingForThreadArgs

class BitConverterNonAlloc

class Bone : public IEquatable<Bone>

The Bone class represents a tracked bone.

All fingers contain 4 bones that make up the anatomy of the finger. Get valid Bone objects from a Finger object.

Bones are ordered from base to tip, indexed from 0 to 3. Additionally, the bone’s Type enum may be used to index a specific bone anatomically.

The thumb does not have a base metacarpal bone and therefore contains a valid, zero length bone at that location.

Since: 2.0

Subclassed by Leap.Arm

class CapsuleHand : public Leap.HandModelBase: The CapsuleHand is a basic Leap hand model that generates a set of spheres and cylinders to render hands using Leap hand data. It is constructed dynamically rather than using pre-existing geometry which allows hand visuals to scale to the size of the users hand and is a reliable way to visualize the raw tracking data.

class Comment : public MonoBehaviour

class Config

The Config class provides access to Leap Motion system configuration information.

Since: 1.0

class ConfigChangeEventArgs : public Leap.LeapEventArgs

Dispatched when a configuration change is completed.

Provides the configuration key, whether the change was successful, and the id of the original change request.

Since: 3.0

class ConnectionEventArgs : public Leap.LeapEventArgs

Dispatched when the connection is established.

Since: 3.0

class ConnectionLostEventArgs : public Leap.LeapEventArgs

Dispatched when the connection is lost.

Since: 3.0

class Controller : public Leap.IController

The Controller class is your main interface to the Leap Motion Controller.

Create an instance of this Controller class to access frames of tracking data and configuration information.Frame data can be polled at any time using the Controller.Frame() function.Call frame() or frame(0) to get the most recent frame.Set the history parameter to a positive integer to access previous frames.A controller stores up to 60 frames in its frame history.

Polling is an appropriate strategy for applications which already have an intrinsic update loop, such as a game. You can also subscribe to the FrameReady event to get tracking frames through an event delegate.

If the current thread implements a SynchronizationContext that contains a message loop, events are posted to that threads message loop. Otherwise, events are called on an independent thread and applications must perform any needed synchronization or marshalling of data between threads. Note that Unity3D does not create an appropriate SynchronizationContext object. Typically, event handlers cannot access any Unity objects.

Since: 1.0

class CopyFromOtherExtensions

class CSharpExtensions

Various C# extensions used by the Leap C# classes.

Since: 3.0

class DebugHand : public Leap.HandModelBase

A HandModel that draws lines for the bones in the hand and its fingers.

The debugs lines are only drawn in the Editor Scene view (when a hand is tracked) and not in the Game view. Use debug hands when you aren’t using visible hands in a scene so that you can see where the hands are in the scene view.

class Device : public IEquatable<Device>

The Device class represents a physically connected device.

The Device class contains information related to a particular connected device such as device id, field of view relative to the device, and the position and orientation of the device in relative coordinates.

The position and orientation describe the alignment of the device relative to the user. The alignment relative to the user is only descriptive. Aligning devices to users provides consistency in the parameters that describe user interactions.

Note that Device objects can be invalid, which means that they do not contain valid device information and do not correspond to a physical device.

Since: 1.0

class DeviceEventArgs : public Leap.LeapEventArgs

Dispatched when a device is plugged in.

Provides the device as an argument.

Since: 3.0

class DeviceFailureEventArgs : public Leap.LeapEventArgs

Dispatched when a device is plugged in, but fails to initialize or when a working device fails in use.

Provides the failure reason and, if available, the serial number.

Since: 3.0

class DeviceList : public List<Device>

The DeviceList class represents a list of Device objects.

Get a DeviceList object by calling Controller.Devices().

Since: 1.0

class DistortionData

The DistortionData class contains the distortion map for correcting the lens distortion of an image.

The distortion data is an array containing a 64x64 grid of floating point pairs. The distortion map for both sides of an image pair are stacked in the Data array the left map first, followed by the right map.

Since: 3.0

class DistortionEventArgs : public Leap.LeapEventArgs

Dispatched when the image distortion map changes.

Provides the new distortion map as an argument.

Since: 3.0

class DroppedFrameEventArgs : public Leap.LeapEventArgs

class EnableDepthBuffer : public MonoBehaviour

struct EndProfilingBlockArgs

struct EndProfilingForThreadArgs

class EnumEventTable : public ISerializationCallbackReceiver

class FailedDevice : public IEquatable<FailedDevice>

The FailedDevice class provides information about Leap Motion hardware that has been physically connected to the client computer, but is not operating correctly.

Failed devices do not provide any tracking data and do not show up in the Controller.Devices() list.

Get the list of failed devices using Controller.FailedDevices().

Since: 3.0

class FailedDeviceList : public List<FailedDevice>

The list of FailedDevice objects contains an entry for every failed Leap Motion hardware device connected to the client computer. FailedDevice objects report the device pnpID string and reason for failure.

Get the list of FailedDevice objects from Controller.FailedDevices().

Since: 3.0

class FiducialPoseEventArgs : public Leap.LeapEventArgs

Dispatched when a Fiducial Marker is tracked

Note: Family and Size are not currently implemented

class Finger

The Finger class represents a tracked finger.

Fingers are objects that the Leap Motion software has classified as a finger. Get valid Finger objects from a Frame or a Hand object.

Since: 1.0

class FingerModel : public MonoBehaviour

The base class for all fingers.

This class serves as the interface between the HandController object, the parent Hand object and the concrete finger objects.

Subclasses of FingerModel must implement InitFinger() and UpdateFinger(). The InitHand() function is typically called by the parent HandModel InitHand() method; likewise, the UpdateFinger() function is typically called by the parent HandModel UpdateHand() function.

class Frame : public IEquatable<Frame>

The Frame class represents a set of hand and finger tracking data detected in a single frame.

The Leap Motion software detects hands, fingers and tools within the tracking area, reporting their positions, orientations, gestures, and motions in frames at the Leap Motion frame rate.

Access Frame objects through an instance of the Controller class.

Since: 1.0

class FrameEventArgs : public Leap.LeapEventArgs

Dispatched when a tracking frame is ready.

Provides the Frame object as an argument.

Since: 3.0

class FromMatrixExtension

class GrabDetector : public Leap.ActionDetector: A lightweight Grab Detector, that calculates a grab value based on the grab strength of the hand. Utilizes hysteresis to have different grab and ungrab thresholds.

class Hand : public IEquatable<Hand>

The Hand class reports the physical characteristics of a detected hand.

Hand tracking data includes a palm position and velocity; vectors for the palm normal and direction to the fingers; and lists of the attached fingers.

Note that Hand objects can be invalid, which means that they do not contain valid tracking data and do not correspond to a physical entity. Invalid Hand objects can be the result of using the default constructor, or modifying the hand data in an incorrect way.

Since: 1.0

class HandEnableDisable : public MonoBehaviour: A component to be attached to a HandModelBase to handle starting and ending of tracking. The parent gameobjet is activated when tracking begins and deactivated when tracking ends.

class HandModel : public Leap.HandModelBase

The base class for all hand models, both graphics and physics.

This class serves as the interface between the LeapProvider and the concrete hand object containing the graphics and physics of a hand.

The UpdateHand() function is called in the Unity Update() phase for graphics HandModel instances; and in the Unity FixedUpdate() phase for physics objects. InitHand() is called once, when the hand is created and is followed by a call to UpdateHand().

class HandModelBase : public MonoBehaviour

HandModelBase defines abstract methods as a template for building hand models. It allows you to receive tracking data for a left or right hand and it can be extended to drive hand visuals or physics representations of hands.

A HandModelBase will automatically subscribe and receive tracking data if there is a provider in the scene. The provider can be overridden (leapProvider).

Subclassed by Leap.CapsuleHand, Leap.DebugHand, Leap.HandModel, Leap.HandsModule.HandBinder

class HandPoseDetector : public MonoBehaviour

class HandPoseEditor : public Leap.LeapProvider

class HandPoseRecorder : public MonoBehaviour

class HandPoseScriptableObject : public ScriptableObject

class HandPoseViewer : public Leap.LeapProvider

class Hands: Static convenience methods and extension methods for getting useful Hand data.

class HandTrackingHintManager

class HandTrackingSourceUtility

class HandUtils: Utility methods for constructing and manipulating Leap hand object data.

class HeadPoseEventArgs : public Leap.LeapEventArgs

interface ICanReportDuplicateInformation: Subclassed by Leap.SerializableHashSet< T >

interface IController : public IDisposable: Subclassed by Leap.Controller

class ImageEventArgs : public Leap.LeapEventArgs

Dispatched when an unrequested Image is ready.

Provides the Image object as an argument.

Since: 4.0

class InternalFrameEventArgs : public Leap.LeapEventArgs

interface IPoolable: Implement this interface to recieve a callback whenever your object is spawned from a pool.

class KabschSolver

class LeapEventArgs : public EventArgs

A generic object with no arguments beyond the event type.

Since: 3.0

Subclassed by Leap.ConfigChangeEventArgs, Leap.ConnectionEventArgs, Leap.ConnectionLostEventArgs, Leap.DeviceEventArgs, Leap.DeviceFailureEventArgs, Leap.DistortionEventArgs, Leap.DroppedFrameEventArgs, Leap.FiducialPoseEventArgs, Leap.FrameEventArgs, Leap.HeadPoseEventArgs, Leap.ImageEventArgs, Leap.InternalFrameEventArgs, Leap.LogEventArgs, Leap.PointMappingChangeEventArgs, Leap.PolicyEventArgs, Leap.SetConfigResponseEventArgs

class LeapImageRetriever : public MonoBehaviour

Acquires images from a LeapServiceProvider and uploads image data as shader global data for use by any shaders that render those images.

Note: To use the LeapImageRetriever, you must be on version 2.1 or newer and you must enable “Allow Images” in your Leap Motion settings.

class LeapProvider : public MonoBehaviour

Provides Frame object data to the Unity application by firing events as soon as Frame data is available. Frames contain all currently tracked Hands in view of the Leap Motion Controller.

LeapProvider defines the basic interface our plugin expects to use to retrieve Frame data. This abstraction allows you to create your own LeapProviders, which is useful when testing or developing in a context where Ultraleap Hand Tracking hardware isn’t immediately available.

Subclassed by Leap.HandPoseEditor, Leap.HandPoseViewer, Leap.LeapServiceProvider, Leap.PhysicalHands.PhysicalHandsManager, Leap.PostProcessProvider, Leap.Tracking.OpenXR.OpenXRLeapProvider, Leap.XRHandsLeapProvider, Leap.XRLeapProviderManager

class LeapProviderExtensions

class LeapServiceProvider : public Leap.LeapProvider

The LeapServiceProvider provides tracked Leap Hand data and images from the device via the Leap service running on the client machine.

It communicates with the Ultraleap Tracking Service running on your platform, and provides Frame objects containing Leap hands to your application. Generally, any class that needs hand tracking data from the camera will need a reference to a LeapServiceProvider to get that data.

Subclassed by Leap.LeapXRServiceProvider

struct LeapTransform

The LeapTransform class represents a transform in three dimensional space.

Note that the LeapTransform class replaces the Leap.Matrix class.

Since: 3.1.2

class LeapXRHandProvider : public XRHandSubsystemProvider

class LeapXRServiceProvider : public Leap.LeapServiceProvider

The LeapXRServiceProvider expands on the standard LeapServiceProvider to account for the offset of the Leap device with respect to the attached HMD and warp tracked hand positions based on the motion of the headset to account for the differing latencies of the two tracking systems.

This component can be placed anywhere in your scene as long as mainCamera references the XR camera.

class LogEventArgs : public Leap.LeapEventArgs

Dispatched when loggable events are generated by the service and the service connection code.

Provides the severity rating, log text, and timestamp as arguments.

Since: 3.0

class MetadataUtil: This class captures information regarding use of the Ultraleap Unity Plugin This data is anonymized and only sent to Ultraleap when you choose to allow it. You can change your analytics preferences in the Ultraleap Tracking Control Panel. “Settings > Help Improve Tracking”

class PhysicalHandsAnchorable : public Leap.AnchorableBehaviour, public Leap.PhysicalHands.IPhysicalHandGrab, public Leap.PhysicalHands.IPhysicalHandHover

class PinchDetector : public Leap.ActionDetector: A lightweight Pinch Detector, that calculates a pinch value based on the distance between the provided finger tip and the thumb tip. Utilizes hysteresis to have different pinch and unpinch thresholds.

struct PointMapping

class PointMappingChangeEventArgs : public Leap.LeapEventArgs

Dispatched when point mapping change events are generated by the service.

Since: 4.0

class PolicyEventArgs : public Leap.LeapEventArgs

Dispatched when a policy change is complete.

Provides the current and previous policies as arguments.

Since: 3.0

class Pool<T>

A very lightweight pool implementation. When you call Spawn, an object of type T will be returned. If the pool was not empty, the T will be taken from the pool. If the pool was empty, a new T will be constructed and returned instead. Calling recycle will return a T to the pool.

It is not required to implement the IPoolable interface to use the Pool class, which allows you to pool types such as List or Dictionary, types which you have no control over. But make sure that you clean up these objects before you recycle them!

Example workflow for types you DO NOT have control over:

// " // (XML fix for Visual Studio)

var obj = Pool\<T\>.Spawn();
obj.Init(stuff);

//Do something with obj

obj.Clear();
Pool\<T\>.Recycle(obj);

// " // (Close XML fix for Visual Studio)

Example workflow for types you DO have control over:

// " // (XML fix for Visual Studio)

var obj = Pool\<T\>.Spawn();
obj.Init(stuff);

// Do something with obj

obj.Dispose(); // e.g. call Recycle(this) in the Dispose() implementation

// " // (Close XML fix for Visual Studio)

class PoseExtensions

class PostProcessProvider : public Leap.LeapProvider: Subclassed by Leap.HandsModule.DistortTrackingDataToVisuals

class ProduceConsumeBuffer<T>

struct ReadonlyHashSet<T>: A simple wrapper around HashSet to provide readonly access. Useful when you want to return a HashSet to someone but you want to make sure they don’t muck it up!

class RingBuffer<T>

class SerializableHashSet<T> : public Leap.SerializableHashSetBase, public Leap.ICanReportDuplicateInformation, public ISerializationCallbackReceiver, public IEnumerable<T>

class SerializableHashSetBase: Subclassed by Leap.SerializableHashSet< T >

class SetConfigResponseEventArgs : public Leap.LeapEventArgs

Dispatched when a configuration change is completed.

Provides the configuration key, whether the change was successful, and the id of the original change request.

Since: 3.0

class SimpleAnchorFeedback : public MonoBehaviour

class SimpleFacingCameraCallbacks : public MonoBehaviour

struct SingleLayer : public IEquatable<SingleLayer>: An object you can use to represent a single Unity layer as a dropdown in the inspector. Can be converted back and forth between the integer representation Unity usually uses in its own methods.

class SmoothedFloat

Time-step independent exponential smoothing.

When moving at a constant speed: speed * delay = Value - SmoothedFloat.value.

class SubsystemStarter

class Swizzle

class TestHandFactory

class TrackingMarker : public MonoBehaviour

class TrackingMarkerObject : public MonoBehaviour

class TransformExtensions

class TransformHistory: Implements a resample-able transform history.

class UltraleapSettings : public ScriptableObject

class Utils

class VisualFOV: Class to generate meshes that can be used for field of view visualization. Set the FOV variables depending on the device type used, call UpdateFOVs() and access the meshes OptimalFOVMesh, NoTrackingFOVMesh and MaxFOVMesh.

class XRHandsLeapProvider : public Leap.LeapProvider: A LeapProvider that converts XRHands Subsystem data to a Leap.Frame for use in features that use Leap.Frame and LeapProviders as a data source.

class XRHandsUtils

class XRLeapProviderManager : public Leap.LeapProvider: XRLeapProviderManager offers a single access point while selecting the most suitable Hand Tracking Data source available at the time of application launch. The order of selection is: UL OpenXR -> Leap Direct -> OpenXR

class XRSupportUtil: Wraps various (but not all) “XR” calls with Unity 5.6-supporting “VR” calls via #ifdefs.

namespace Attachments

Enums

enum AttachmentPointFlags

Flags for attachment points on the hand.

Values:

None

Wrist

Palm

ThumbProximalJoint

ThumbDistalJoint

ThumbTip

IndexKnuckle

IndexMiddleJoint

IndexDistalJoint

IndexTip

MiddleKnuckle

MiddleMiddleJoint

MiddleDistalJoint

MiddleTip

RingKnuckle

RingMiddleJoint

RingDistalJoint

RingTip

PinkyKnuckle

PinkyMiddleJoint

PinkyDistalJoint

PinkyTip

PinchPoint

class AttachmentHand : public MonoBehaviour: This MonoBehaviour is managed by an AttachmentHands component on a parent MonoBehaviour. Instead of adding AttachmentHand directly to a GameObject, add an AttachmentHands component to a parent GameObject to manage the construction and updating of AttachmentHand objects.

class AttachmentHandEnableDisable : public MonoBehaviour

class AttachmentHands : public MonoBehaviour: Add an GameObject with this script to your scene if you would like to have a Transform hierarchy that will follow various important points on a hand, whether for visuals or for logic. The AttachmentHands object will maintain two child objects, one for each of the player’s hands. Use the Inspector to customize which points you’d like to see in the hierarchy beneath the individual AttachmentHand objects.

class AttachmentPointBehaviour : public MonoBehaviour

Simple container class for storing a reference to the attachment point this transform corresponds to within an AttachmentHand. Also contains mappings from a single AttachmentPointFlags flag constant to the relevant bone on a Leap.Hand; these mappings can be accessed statically via GetLeapHandPointData().

Can also be used to refer to a single AttachmentPointFlags flag constant (implicit conversion).

class AttachmentPointFlagsExtensions

namespace Attributes

Typedefs

UnityObject = UnityEngine.Object

class CombinablePropertyAttribute : public PropertyAttribute: Subclassed by Leap.Attributes.DisableAttribute, Leap.Attributes.DisableIfBase, Leap.Attributes.EditTimeOnly, Leap.Attributes.EnumFlags, Leap.Attributes.IndentAttribute, Leap.Attributes.InspectorNameAttribute, Leap.Attributes.MaxValue, Leap.Attributes.MinMax, Leap.Attributes.MinValue, Leap.Attributes.OnEditorChangeAttribute, Leap.Attributes.UnitsAttribute

class DisableAttribute : public Leap.Attributes.CombinablePropertyAttribute, public Leap.Attributes.IPropertyDisabler

class DisableIf : public Leap.Attributes.DisableIfBase

class DisableIfAll : public Leap.Attributes.DisableIfBase

class DisableIfAny : public Leap.Attributes.DisableIfBase

class DisableIfBase : public Leap.Attributes.CombinablePropertyAttribute, public Leap.Attributes.IPropertyDisabler

Conditionally disables a property based on the value of another property. The only condition types that are currently supported are bool types, and enum types. The property has two arguments names ‘equalTo’ and ‘notEqualTo’. Exactly one of them must be specified, like so:

[DisableIf(“myBoolProperty”, isEqualTo: true)] [DisableIf(“myEnumProperty”, isNotEqualTo: MyEnum.Value)] [DisableIfAny(“bool1”, “bool2”, isEqualTo: false)] [DisableIfAll(“cond1”, “cond2”, “cond3”, isNotEqualTo: true)]

Subclassed by Leap.Attributes.DisableIf, Leap.Attributes.DisableIfAll, Leap.Attributes.DisableIfAny, Leap.Attributes.DisableIfEqual, Leap.Attributes.DisableIfNotEqual

class DisableIfEqual : public Leap.Attributes.DisableIfBase

class DisableIfNotEqual : public Leap.Attributes.DisableIfBase

class EditTimeOnly : public Leap.Attributes.CombinablePropertyAttribute, public Leap.Attributes.IPropertyDisabler

class EnumFlags : public Leap.Attributes.CombinablePropertyAttribute, public Leap.Attributes.IFullPropertyDrawer

interface IAdditiveDrawer: Subclassed by Leap.Attributes.IAfterFieldAdditiveDrawer, Leap.Attributes.IAfterLabelAdditiveDrawer, Leap.Attributes.IBeforeFieldAdditiveDrawer, Leap.Attributes.IBeforeLabelAdditiveDrawer

interface IAfterFieldAdditiveDrawer : public Leap.Attributes.IAdditiveDrawer: Subclassed by Leap.Attributes.UnitsAttribute

interface IAfterLabelAdditiveDrawer : public Leap.Attributes.IAdditiveDrawer

interface IBeforeFieldAdditiveDrawer : public Leap.Attributes.IAdditiveDrawer

interface IBeforeLabelAdditiveDrawer : public Leap.Attributes.IAdditiveDrawer: Subclassed by Leap.Attributes.IndentAttribute

interface IFullPropertyDrawer: Subclassed by Leap.Attributes.EnumFlags, Leap.Attributes.InspectorNameAttribute, Leap.Attributes.MinMax

class IndentAttribute : public Leap.Attributes.CombinablePropertyAttribute, public Leap.Attributes.IBeforeLabelAdditiveDrawer

class InspectorNameAttribute : public Leap.Attributes.CombinablePropertyAttribute, public Leap.Attributes.IFullPropertyDrawer

interface IPropertyConstrainer: Subclassed by Leap.Attributes.MaxValue, Leap.Attributes.MinValue

interface IPropertyDisabler: Subclassed by Leap.Attributes.DisableAttribute, Leap.Attributes.DisableIfBase, Leap.Attributes.EditTimeOnly

interface ISupportDragAndDrop

interface ITopPanelDrawer

class MaxValue : public Leap.Attributes.CombinablePropertyAttribute, public Leap.Attributes.IPropertyConstrainer

class MinMax : public Leap.Attributes.CombinablePropertyAttribute, public Leap.Attributes.IFullPropertyDrawer

class MinValue : public Leap.Attributes.CombinablePropertyAttribute, public Leap.Attributes.IPropertyConstrainer

class OnEditorChangeAttribute : public Leap.Attributes.CombinablePropertyAttribute

Use the OnChange attribute to recieve a callback whenever a field is changed. The callback can be in the form of:

A method accepting zero arguments
A method accepting a single argument matching the field type (new value is passed in as the argument)
A property matching the type of the field (the setter is called with the new value)

class UnitsAttribute : public Leap.Attributes.CombinablePropertyAttribute, public Leap.Attributes.IAfterFieldAdditiveDrawer

namespace Encoding

interface IInterpolable<T>: An interface that signifies this class can interpolate via the standard techniques

class VectorHand : public Leap.Encoding.IInterpolable<VectorHand>

A Vector-based encoding of a Leap Hand.

You can Encode a VectorHand from a Leap hand, Decode a VectorHand into a Leap hand, convert the VectorHand to a compressed byte representation using FillBytes, and decompress back into a VectorHand using FromBytes.

class VectorHandExtensions: Defines Utility Extension Methods for a VectorHand

namespace Examples

class IgnoreCollisionsInChildren : public MonoBehaviour

This utility script scans through its Transform’s children and tells PhysX to ignore collisions between all pairs of Colliders it finds. This is particlarly useful, for example, for interfaces, where buttons shouldn’t collide with other buttons.

This is not the recommended strategy in general: It is much more optimal for your application to put interface objects on a layer and disable self-collision for that layer in your Physics settings (Edit / Project Settings / Physics).

namespace HandsModule

Enums

enum BoundTypes

ENUM types for bones of the hand the hand binder can attach to

Values:

THUMB_METACARPAL

THUMB_PROXIMAL

THUMB_INTERMEDIATE

THUMB_DISTAL

INDEX_METACARPAL

INDEX_PROXIMAL

INDEX_INTERMEDIATE

INDEX_DISTAL

MIDDLE_METACARPAL

MIDDLE_PROXIMAL

MIDDLE_INTERMEDIATE

MIDDLE_DISTAL

RING_METACARPAL

RING_PROXIMAL

RING_INTERMEDIATE

RING_DISTAL

PINKY_METACARPAL

PINKY_PROXIMAL

PINKY_INTERMEDIATE

PINKY_DISTAL

WRIST

ELBOW

class BoneNameDefinitions: Used to define what bones names are valid for each finger

class BoundBone: A data structure to define starting position, an offset and the Transform reference found in the scene

class BoundFinger: A data structure to define a finger

class BoundHand: A data structure to define all the fingers in a hand, the wrist and elbow

class DistortTrackingDataToVisuals : public Leap.PostProcessProvider: A post process provider that allows hand visuals to generate leap hands that can be used to distort tracking data to visuals This should be used in cases where you have visual hands that do not conform to leap data size, e.g. a monster hand that has extra long fingers

class HandBinder : public Leap.HandModelBase: The HandBinder allows you to use your own hand models so that they follow the leap tracking data. You can bind your model by specifying transforms for the different joints and use the debug and fine tuning options to test and adjust it.

class HandBinderAutoBinder

class HandBinderUtilities

class HandModelManager : public MonoBehaviour: A script to manage the active hand models in the scene

class SerializedTransform: A data structure to store information about a transform and a Gameobject

class ShowArm : public MonoBehaviour: This script makes it easy to swap between two hand meshes. It is meant to be used with one hand mesh that includes an arm and one that doesn’t. It attempts to automatically find the meshes based on their names when adding this component or when resetting it.

class TransformStore: A data structure to store a transforms position and rotation

namespace InputActions

class LeapHandInput : public InputDevice: An Input Device generated using two individual hand Input Devices representing left and right hands.

struct LeapHandState : public IInputStateTypeInfo: The structure used to pass hand data to InputDevices

class XRHandsInputActionUpdater: Updates Ultraleap Input Actions with the latest available hand data Must be provided information from a LeapProvider

namespace PhysicalHands

class ContactBone : public MonoBehaviour: Subclassed by Leap.PhysicalHands.HardContactBone, Leap.PhysicalHands.NoContactBone, Leap.PhysicalHands.SoftContactBone

class ContactHand : public MonoBehaviour: Subclassed by Leap.PhysicalHands.HardContactHand, Leap.PhysicalHands.NoContactHand, Leap.PhysicalHands.SoftContactHand

class ContactParent : public MonoBehaviour: Subclassed by Leap.PhysicalHands.HardContactParent, Leap.PhysicalHands.NoContactParent, Leap.PhysicalHands.SoftContactParent

class ContactUtils

class GrabBall : public MonoBehaviour, public Leap.PhysicalHands.IPhysicalHandGrab

A representation of an object with an attached object which can be restricted relative to the users head

Most useful for 3D UI panels to ensure they are reachable

class GrabHelper : public MonoBehaviour

class GrabHelperObject

class HandFadeInAtDistanceFromRealData : public MonoBehaviour

class HardContactBone : public Leap.PhysicalHands.ContactBone

class HardContactHand : public Leap.PhysicalHands.ContactHand

class HardContactParent : public Leap.PhysicalHands.ContactParent

class IgnorePhysicalHands : public MonoBehaviour

interface IPhysicalHandContact

Reports the contact event when any part of the hand is in contact with an interactable rigidbody. This will be called dependant on the contact distance set by the hand.

Subclassed by Leap.PhysicalHands.PhysicalHandEvents, Leap.PhysicalHands.PhysicalHandsButtonHelper, Leap.PhysicalHands.PhysicalHandsSliderHelper

interface IPhysicalHandGrab

Reports the grab event when a grab helper starts or stops grabbing a rigidbody.

Subclassed by Leap.PhysicalHands.GrabBall, Leap.PhysicalHands.PhysicalHandEvents, Leap.PhysicalHands.PhysicalHandsSliderHelper, Leap.PhysicalHandsAnchorable

interface IPhysicalHandHover

Reports the hover event, called when a grab helper is created for the hand. This is a relatively low accuracy hover.

Subclassed by Leap.PhysicalHands.PhysicalHandEvents, Leap.PhysicalHands.PhysicalHandsButtonHelper, Leap.PhysicalHandsAnchorable

interface IPhysicalHandPrimaryHover

Reports the primary hover event when a grab helper starts or stops being the primary hover object.

Subclassed by Leap.PhysicalHands.PhysicalHandsButtonHelper

class NoContactBone : public Leap.PhysicalHands.ContactBone

class NoContactHand : public Leap.PhysicalHands.ContactHand

class NoContactParent : public Leap.PhysicalHands.ContactParent

class PhysExts

class PhysicalHandEvents : public MonoBehaviour, public Leap.PhysicalHands.IPhysicalHandHover, public Leap.PhysicalHands.IPhysicalHandContact, public Leap.PhysicalHands.IPhysicalHandGrab

class PhysicalHandsButton : public MonoBehaviour: Subclassed by Leap.PhysicalHands.PhysicalHandsButtonToggle

class PhysicalHandsButtonHelper : public MonoBehaviour, public Leap.PhysicalHands.IPhysicalHandContact, public Leap.PhysicalHands.IPhysicalHandHover, public Leap.PhysicalHands.IPhysicalHandPrimaryHover

class PhysicalHandsButtonToggle : public Leap.PhysicalHands.PhysicalHandsButton: Class for toggling a button using physical hands.

class PhysicalHandsManager : public Leap.LeapProvider

class PhysicalHandsSlider : public MonoBehaviour

class PhysicalHandsSliderHelper : public MonoBehaviour, public Leap.PhysicalHands.IPhysicalHandGrab, public Leap.PhysicalHands.IPhysicalHandContact: This class is purely to get events from the slideable object. You do not need to add this class to your object, it will be added automatically by the slider.

class PhysicalHandUtils

class SoftContactBone : public Leap.PhysicalHands.ContactBone

class SoftContactHand : public Leap.PhysicalHands.ContactHand

class SoftContactParent : public Leap.PhysicalHands.ContactParent

namespace Readme

class SceneReadmePing : public MonoBehaviour

namespace RuntimeGizmos

interface IRuntimeGizmoComponent: Have your MonoBehaviour implement this interface to be able to draw runtime gizmos. You must also have a RuntimeGizmoManager component in the scene to recieve callbacks.

class RuntimeGizmoDrawer

class RuntimeGizmoExtensions

class RuntimeGizmoManager : public MonoBehaviour

class RuntimeGizmoToggle : public MonoBehaviour: This class controls the display of all the runtime gizmos that are either attatched to this gameObject, or a child of this gameObject. Enable this component to allow the gizmos to be drawn, and disable it to hide them.

namespace Tracking

namespace OpenXR

Enums

enum Handedness

Which of the user’s two hands this hand tracker tracks.

Values:

Left: The user’s left hand

Right: The user’s right hand

enum HandJoint

The hand joints according to the OpenXR Specification

Values:

Palm

Wrist

ThumbMetacarpal

ThumbProximal

ThumbDistal

ThumbTip

IndexMetacarpal

IndexProximal

IndexIntermediate

IndexDistal

IndexTip

MiddleMetacarpal

MiddleProximal

MiddleIntermediate

MiddleDistal

MiddleTip

RingMetacarpal

RingProximal

RingIntermediate

RingDistal

RingTip

LittleMetacarpal

LittleProximal

LittleIntermediate

LittleDistal

LittleTip

Elbow

enum HandJointSet

Values:

Default: The Default OpenXR hand set of 26 joints per-hand, including the palm and wrist.

HandWithForearm

Default hand-set with the addition of the elbow joint on the forearm.

This requires the Ultraleap extension

XR_ULTRALEAP_hand_tracking_forearm

struct HandJointLocation: Represents a user’s hand joint with positional and optional velocity information.

class HandTracker: Tracker for a single user’s hand, allow tracking of individual joints.

class HandTrackingFeature : public OpenXRFeature

Enables OpenXR hand-tracking support via the XR_EXT_hand_tracking

OpenXR extension.

class OpenXRLeapProvider : public Leap.LeapProvider

class OpenXRUtility: A utility to pass data to the core plugin through one central entry point

namespace Unity

namespace MRTK

class LeapMRTKSubsystem : public HandsSubsystem