Rörelsekontrollanter i Unity
Det finns två viktiga sätt att vidta åtgärder på din blick i Unity, handgester och rörelsekontrollanter i HoloLens och avancerad HMD. Du kommer åt data för båda källorna för rumsliga indata via samma API:er i Unity.
Unity tillhandahåller två huvudsakliga sätt att komma åt rumsliga indata för Windows Mixed Reality. Vanliga API:er för Input.GetButton/Input.GetAxis fungerar i flera Unity XR-SDK:er, medan API:et InteractionManager/GestureRecognizer som är specifikt för Windows Mixed Reality exponerar den fullständiga uppsättningen rumsliga indata.
Unity XR-indata-API:er
För nya projekt rekommenderar vi att du använder de nya XR-indata-API:erna från början.
Mer information om XR-API:erna finns här.
Unity-knapp/axelmappningstabell
Unitys indatahanterare för Windows Mixed Reality rörelsekontrollanter stöder knapp- och axel-ID:n som anges nedan via API:erna Input.GetButton/GetAxis. Kolumnen "Windows MR-specifik" refererar till egenskaper som är tillgängliga utanför Typen InteractionSourceState . Vart och ett av dessa API:er beskrivs i detalj i avsnitten nedan.
Knapp-/axel-ID-mappningarna för Windows Mixed Reality matchar vanligtvis Oculus-knappen/axel-ID:t.
Knapp-/axel-ID-mappningarna för Windows Mixed Reality skiljer sig från OpenVR:s mappningar på två sätt:
- Mappningen använder pekplatta-ID:n som skiljer sig från tumstickor för att stödja styrenheter med både tumpinnar och pekplattor.
- Mappningen förhindrar att A- och X-knapp-ID:na överbelastas för menyknapparna så att de blir tillgängliga för de fysiska ABXY-knapparna.
| Indata | Vanliga Unity-API:er (Input.GetButton/GetAxis) | Windows MR-specifikt indata-API (XR. WSA. Indata) |
|
|---|---|---|---|
| Vänster hand | Höger hand | ||
| Välj utlösare som har tryckts på | Axel 9 = 1,0 | Axel 10 = 1,0 | selectPressed |
| Välj utlösarens analoga värde | Axel 9 | Axel 10 | selectPressedAmount |
| Välj utlösare delvis nedtryckt | Knapp 14 (gamepad-kompatibilitet) | Knapp 15 (gamepad-kompatibilitet) | selectPressedAmount > 0.0 |
| Menyknapp som har tryckts på | Knapp 6* | Knapp 7* | menyTryckt |
| Gripknapp som har tryckts in | Axel 11 = 1,0 (inga analoga värden) Knapp 4 (gamepad-kompatibilitet) | Axel 12 = 1,0 (inga analoga värden) Knapp 5 (gamepad-kompatibilitet) | Förstått |
| Tumstick X (vänster: -1.0, höger: 1.0) | Axel 1 | Axel 4 | thumbstickPosition.x |
| Tumsticka Y (överkant: -1,0, nederkant: 1,0) | Axel 2 | Axel 5 | thumbstickPosition.y |
| Tumsticka som trycks in | Knapp 8 | Knapp 9 | thumbstickPressed |
| Pekplatta X (vänster: -1.0, höger: 1.0) | Axel 17* | Axel 19* | touchpadPosition.x |
| Pekplatta Y (överkant: -1,0, nederkant: 1,0) | Axel 18* | Axel 20* | touchpadPosition.y |
| Pekplatta vidrörd | Knapp 18* | Knapp 19* | pekplattaTouched |
| Tryck på pekplattan | Knapp 16* | Knapp 17* | pekplattaTryckt |
| 6DoF-greppposition eller pekare | Endast greppposition : XR. InputTracking.GetLocalPosition XR. InputTracking.GetLocalRotation | Skicka Grip eller Pekare som argument: sourceState.sourcePose.TryGetPosition sourceState.sourcePose.TryGetRotation |
|
| Spårningstillstånd | Positionsnoggrannhet och källförlustrisk är endast tillgänglig via MR-specifikt API | sourceState.sourcePose.positionAccuracy sourceState.properties.sourceLossRisk |
|
Anteckning
Dessa knapp-/axel-ID:n skiljer sig från de ID:n som Unity använder för OpenVR på grund av kollisioner i de mappningar som används av gamepads, Oculus Touch och OpenVR.
OpenXR
Om du vill lära dig grunderna om interaktioner med mixad verklighet i Unity går du till Unity Manual for Unity XR Input (Unity Manual för Unity XR-indata). Den här Unity-dokumentationen beskriver mappningar från kontrollantspecifika indata till mer generaliserbara InputFeatureUsages, hur tillgängliga XR-indata kan identifieras och kategoriseras, hur du läser data från dessa indata med mera.
Mixed Reality OpenXR-plugin-programmet innehåller ytterligare interaktionsprofiler för indata som mappas till Standard InputFeatureUsages enligt beskrivningen nedan:
| InputFeatureUsage | HP Reverb G2-styrenhet (OpenXR) | HoloLens Hand (OpenXR) |
|---|---|---|
| primary2DAxis | Joystick | |
| primary2DAxisClick | Joystick - Klicka | |
| Utlösa | Utlösare | |
| Grepp | Grepp | Tryck eller tryck på luft |
| primaryButton | [X/A] - Tryck på | Trycka i luften |
| secondaryButton | [Y/B] - Tryck på | |
| gripButton | Grepp - Tryck på | |
| triggerButton | Utlösare – tryck på | |
| menyKnapp | Meny |
Greppposition jämfört med pekposition
Windows Mixed Reality stöder rörelsekontrollanter i en mängd olika formfaktorer. Varje kontrollants design skiljer sig åt i relationen mellan användarens handposition och den naturliga framåtriktningen som appar bör använda för att peka när kontrollanten återges.
För att bättre representera dessa kontrollanter finns det två typer av poser som du kan undersöka för varje interaktionskälla, grepppositionen och pekaren. Både grepppositionen och pekarens posekoordinater uttrycks av alla Unity-API:er i globala Unity-världskoordinater.
Greppställning
Greppet representerar användarens palmplats, antingen identifierad av en HoloLens eller med en rörelsekontrollant.
På integrerande headset används greppet bäst för att återge användarens hand eller ett objekt som hålls i användarens hand. Greppet används också vid visualisering av en rörelsekontrollant. Den återgivningsbara modellen som tillhandahålls av Windows för en rörelsekontrollant använder greppet som ursprung och rotationscentrum.
Greppet definieras specifikt enligt följande:
- Grippositionen: Handflatans centroid när styrenheten hålls naturligt, justerad åt vänster eller höger för att centrera positionen i greppet. På Windows Mixed Reality rörelsestyrenhet justeras den här positionen vanligtvis med gripknappen.
- Grepporienteringens högra axel: När du öppnar handen helt för att bilda en platt 5-fingerställning, strålen som är normal för handflatan (framåt från vänster handflata, bakåt från höger handflata)
- Greppets orienteringsaxel Framåt: När du stänger handen delvis (som om du höll styrenheten), strålen som pekar "framåt" genom röret som bildas av dina icke-tumme fingrar.
- Handtagsorienteringens Uppåt-axel: Upp-axeln som antyds av definitionerna Höger och Framåt.
Du kan komma åt greppet antingen via Unitys API för indata mellan leverantörer (XR). InputTracking. GetLocalPosition/Rotation) eller via Windows MR-specifika API (sourceState.sourcePose.TryGetPosition/Rotation, som begär posedata för Grip-noden ).
Pekare
Pekaren representerar spetsen på kontrollanten som pekar framåt.
Den pekare som tillhandahålls av systemet används bäst för raycast när du återger själva kontrollantmodellen. Om du återger något annat virtuellt objekt i stället för kontrollanten, till exempel en virtuell pistol, bör du peka med en stråle som är mest naturlig för det virtuella objektet, till exempel en stråle som färdas längs pipan i den appdefinierade vapenmodellen. Eftersom användarna kan se det virtuella objektet och inte den fysiska kontrollanten blir det sannolikt mer naturligt att peka med det virtuella objektet för dem som använder din app.
För närvarande är pekaren endast tillgänglig i Unity via Windows MR-specifika API, sourceState.sourcePose.TryGetPosition/Rotation, och skickar InteractionSourceNode.Pointer som argument.
OpenXR
Du har åtkomst till två uppsättningar poser via OpenXR-indatainteraktioner:
- Greppet utgör för återgivning av objekt i handen
- Syftet innebär att peka in i världen.
Mer information om den här designen och skillnaderna mellan de två poseringarna finns i openxr-specifikationen – indataundersökvägarna.
Poser som tillhandahålls av InputFeatureUsages DevicePosition, DeviceRotation, DeviceVelocity och DeviceAngularVelocity representerar alla OpenXR-greppet. InputFeatureUsages relaterade till greppställningar definieras i Unitys CommonUsages.
Poser som tillhandahålls av InputFeatureUsages PointerPosition, PointerRotation, PointerVelocity och PointerAngularVelocity representerar alla OpenXR-målställningen. Dessa InputFeatureUsages definieras inte i några inkluderade C#-filer, så du måste definiera dina egna InputFeatureUsages enligt följande:
public static readonly InputFeatureUsage<Vector3> PointerPosition = new InputFeatureUsage<Vector3>("PointerPosition");
Haptics
Information om hur du använder haptics i Unitys XR-indatasystem finns i Unity Manual for Unity XR Input - Haptics.
Kontrollantspårningstillstånd
Precis som headseten kräver Windows Mixed Reality rörelsestyrenhet ingen installation av externa spårningssensorer. I stället spåras styrenheterna av sensorer i själva headsetet.
Om användaren flyttar styrenheterna från headsetets synfält fortsätter Windows i de flesta fall att härleda styrenhetspositioner. När kontrollanten har förlorat visuell spårning tillräckligt länge sjunker kontrollantens positioner till positioner med ungefärlig noggrannhet.
I det här läget låser systemet kontrollanten till användaren, spårar användarens position när de rör sig, samtidigt som kontrollantens sanna orientering exponeras med hjälp av dess interna orienteringssensorer. Många appar som använder styrenheter för att peka på och aktivera gränssnittselement kan fungera normalt med en ungefärlig noggrannhet utan att användaren märker det.
Explicit resonemang om spårningstillstånd
Appar som vill hantera positioner på olika sätt baserat på spårningstillstånd kan gå längre och inspektera egenskaper för kontrollantens tillstånd, till exempel SourceLossRisk och PositionAccuracy:
| Spårningstillstånd | SourceLossRisk | PositionAccuracy | TryGetPosition |
|---|---|---|---|
| Hög noggrannhet | < 1.0 | Högt | true |
| Hög noggrannhet (riskerar att förloras) | == 1,0 | Högt | true |
| Ungefärlig noggrannhet | == 1,0 | Ungefärliga | true |
| Ingen position | == 1,0 | Ungefärliga | falskt |
Dessa spårningstillstånd för rörelsekontrollanter definieras på följande sätt:
- Hög noggrannhet: Även om rörelsestyrenheten är inom headsetets synfält, ger den vanligtvis positioner med hög noggrannhet, baserat på visuell spårning. En rörlig styrenhet som tillfälligt lämnar synfältet eller tillfälligt skyms från headsetsensorerna (t.ex. av användarens andra hand) kommer att fortsätta att returnera poser med hög noggrannhet under en kort tid, baserat på inertiell spårning av själva styrenheten.
- Hög noggrannhet (riskerar att förloras): När användaren flyttar rörelsestyrenheten förbi kanten på headsetets synfält kommer headsetet snart inte att kunna spåra styrenhetens position visuellt. Appen vet när kontrollanten har nått den här FOV-gränsen genom att se SourceLossRisk nå 1.0. Då kan appen välja att pausa kontrollantgester som kräver en stadig ström av högkvalitativa poser.
- Ungefärlig noggrannhet: När kontrollanten har förlorat visuell spårning tillräckligt länge sjunker kontrollantens positioner till positioner med ungefärlig noggrannhet. I det här läget låser systemet kontrollanten till användaren, spårar användarens position när de rör sig, samtidigt som kontrollantens sanna orientering exponeras med hjälp av dess interna orienteringssensorer. Många appar som använder styrenheter för att peka på och aktivera gränssnittselement kan fungera som vanligt samtidigt som de är exakta utan att användaren märker det. Appar med tyngre indatakrav kan välja att känna av den här minskningen från Hög noggrannhet till Ungefärlig noggrannhet genom att inspektera egenskapen PositionAccuracy , till exempel för att ge användaren en mer generös hitbox på mål utanför skärmen under den här tiden.
- Ingen position: Kontrollanten kan arbeta med ungefärlig noggrannhet under lång tid, men ibland vet systemet att inte ens en kroppslåst position är meningsfull för tillfället. Till exempel kanske en kontrollant som har aktiverats aldrig har observerats visuellt, eller så kan en användare placera en kontrollant som sedan hämtas av någon annan. Då ger inte systemet någon position till appen och TryGetPosition returnerar falskt.
Vanliga Unity-API:er (Input.GetButton/GetAxis)
Namnområde:UnityEngine, UnityEngine.XR
Typer: Indata, XR. InputTracking
Unity använder för närvarande sina allmänna Input.GetButton/Input.GetAxis-API:er för att exponera indata för Oculus SDK, OpenVR SDK och Windows Mixed Reality, inklusive hand- och rörelsekontrollanter. Om din app använder dessa API:er för indata kan den enkelt stödja rörelsekontrollanter över flera XR SDK:er, inklusive Windows Mixed Reality.
Hämta en logisk knapps tryckläge
Om du vill använda de allmänna API:erna för Unity-indata börjar du vanligtvis med att koppla knappar och axlar till logiska namn i Unity Input Manager, binda en knapp eller axel-ID till varje namn. Du kan sedan skriva kod som refererar till den logiska knappen/axelns namn.
Om du till exempel vill mappa den vänstra rörelsekontrollantens utlösarknapp till åtgärden Skicka går du till Redigera > indata för projektinställningar > i Unity och expanderar egenskaperna för avsnittet Skicka under Axlar. Ändra egenskapen Positiv knapp eller Alternativ positiv knapp för att läsa joystickknappen 14, så här:
Unity InputManager
Skriptet kan sedan söka efter åtgärden Skicka med input.GetButton:
if (Input.GetButton("Submit"))
{
// ...
}
Du kan lägga till fler logiska knappar genom att ändra egenskapen Storlek under Axlar.
Hämta en fysisk knapps tryckningstillstånd direkt
Du kan också komma åt knappar manuellt med deras fullständigt kvalificerade namn med hjälp av Input.GetKey:
if (Input.GetKey("joystick button 8"))
{
// ...
}
Få en hand- eller rörelsekontrollants pose
Du kan komma åt kontrollantens position och rotation med hjälp av XR. InputTracking:
Vector3 leftPosition = InputTracking.GetLocalPosition(XRNode.LeftHand);
Quaternion leftRotation = InputTracking.GetLocalRotation(XRNode.LeftHand);
Anteckning
Ovanstående kod representerar kontrollantens greppposition (där användaren håller kontrollanten), vilket är användbart för att återge ett svärd eller en pistol i användarens hand, eller en modell av själva kontrollanten.
Relationen mellan denna greppposition och pekarens pose (där kontrollantens spets pekar) kan skilja sig åt mellan styrenheterna. Just nu är det bara möjligt att komma åt kontrollantens pekare via det MR-specifika indata-API:et, som beskrivs i avsnitten nedan.
Windows-specifika API:er (XR. WSA. Indata)
Varning
Om ditt projekt använder någon av XR:erna. WSA-API:er, dessa fasas ut till förmån för XR SDK i framtida Unity-versioner. För nya projekt rekommenderar vi att du använder XR SDK från början. Mer information om XR-indatasystemet och API:er finns här.
Namnområde:UnityEngine.XR.WSA.Input
Typer: InteractionManager, InteractionSourceState, InteractionSource, InteractionSourceProperties, InteractionSourceKind, InteractionSourceLocation
Om du vill ha mer detaljerad information om Windows Mixed Reality handindata (för HoloLens) och rörelsekontrollanter kan du välja att använda Windows-specifika rumsliga indata-API:er under namnområdet UnityEngine.XR.WSA.Input. På så sätt kan du komma åt ytterligare information, till exempel positionsnoggrannhet eller källtyp, så att du kan skilja händer och kontrollanter åt.
Avsökning för händer och rörelsekontrollanter
Du kan söka efter den här ramens tillstånd för varje interaktionskälla (hand- eller rörelsekontrollant) med hjälp av metoden GetCurrentReading .
var interactionSourceStates = InteractionManager.GetCurrentReading();
foreach (var interactionSourceState in interactionSourceStates) {
// ...
}
Varje InteractionSourceState som du får tillbaka representerar en interaktionskälla vid den aktuella tidpunkten. InteractionSourceState visar information som:
Vilka typer av pressar som inträffar (Select/Menu/Grasp/Touchpad/Thumbstick)
if (interactionSourceState.selectPressed) { // ... }Andra data som är specifika för rörelsekontrollanter, till exempel pekplattans och/eller tumstickens XY-koordinater och berört tillstånd
if (interactionSourceState.touchpadTouched && interactionSourceState.touchpadPosition.x > 0.5) { // ... }InteractionSourceKind för att veta om källan är en hand eller en rörelsekontrollant
if (interactionSourceState.source.kind == InteractionSourceKind.Hand) { // ... }
Avsökning för framåtsagd återgivningsposer
När du söker efter interaktionskällans data från händer och kontrollanter är de poser du får förutsagda poser för den tidpunkt då den här ramens fotoner kommer att nå användarens ögon. Framåtsagda poser används bäst för återgivning av kontrollanten eller ett hållet objekt varje ram. Om du riktar in dig på en viss press eller utgåva med kontrollanten är det mest korrekt om du använder DE HISTORISKA HÄNDELSE-API:erna som beskrivs nedan.
var sourcePose = interactionSourceState.sourcePose; Vector3 sourceGripPosition; Quaternion sourceGripRotation; if ((sourcePose.TryGetPosition(out sourceGripPosition, InteractionSourceNode.Grip)) && (sourcePose.TryGetRotation(out sourceGripRotation, InteractionSourceNode.Grip))) { // ... }Du kan också få den framåtsagda huvudpositionen för den aktuella ramen. Precis som med källpositionen är detta användbart för att återge en markör, även om det är bäst att rikta in sig på en viss press eller utgåva om du använder de historiska händelse-API:er som beskrivs nedan.
var headPose = interactionSourceState.headPose; var headRay = new Ray(headPose.position, headPose.forward); RaycastHit raycastHit; if (Physics.Raycast(headPose.position, headPose.forward, out raycastHit, 10)) { var cursorPos = raycastHit.point; // ... }
Hantera interaktionskällans händelser
Om du vill hantera indatahändelser när de inträffar med korrekta historiska posedata kan du hantera interaktionskällans händelser i stället för avsökning.
Så här hanterar du interaktionskällans händelser:
Registrera dig för en InteractionManager-indatahändelse . För varje typ av interaktionshändelse som du är intresserad av måste du prenumerera på den.
InteractionManager.InteractionSourcePressed += InteractionManager_InteractionSourcePressed;Hantera händelsen. När du har prenumererat på en interaktionshändelse får du återanropet när det är lämpligt. I Exemplet SourcePressed är detta efter att källan har identifierats och innan den släpps eller går förlorad.
void InteractionManager_InteractionSourceDetected(InteractionSourceDetectedEventArgs args) var interactionSourceState = args.state; // args.state has information about: // targeting head ray at the time when the event was triggered // whether the source is pressed or not // properties like position, velocity, source loss risk // source id (which hand id for example) and source kind like hand, voice, controller or other }
Sluta hantera en händelse
Du måste sluta hantera en händelse när du inte längre är intresserad av händelsen eller om du förstör objektet som prenumererar på händelsen. Om du vill sluta hantera händelsen avbryter du prenumerationen på händelsen.
InteractionManager.InteractionSourcePressed -= InteractionManager_InteractionSourcePressed;
Lista över händelser för interaktionskälla
De tillgängliga interaktionskällans händelser är:
- InteractionSourceDetected (källan blir aktiv)
- InteractionSourceLost (blir inaktiv)
- InteractionSourcePressed (tryck, knapptryckning eller "Välj" yttrat)
- InteractionSourceReleased (slutet av ett tryck, en knapp som släppts eller slutet på "Select" (Välj)
- InteractionSourceUpdated (flyttar eller på annat sätt ändrar något tillstånd)
Händelser för historisk inriktning utgör som bäst matchar ett pressmeddelande eller en utgåva
Avsöknings-API:erna som beskrevs tidigare ger appen förutsagda poser. Även om dessa förutsagda poser är bäst för återgivning av kontrollanten eller ett virtuellt handhållet objekt, är framtida poser inte optimala för mål, av två viktiga skäl:
- När användaren trycker på en knapp på en styrenhet kan det finnas cirka 20 ms trådlös svarstid över Bluetooth innan systemet tar emot pressen.
- Om du sedan använder en förutsagd pose skulle ytterligare 10–20 ms framåtförutsägelse tillämpas för att rikta in dig på den tid då den aktuella ramens fotoner når användarens ögon.
Det innebär att avsökningen ger dig en källposition eller en huvudposition som är 30–40 ms framåt från där användarens huvud och händer faktiskt var tillbaka när pressen eller publiceringen skedde. För HoloLens-handinmatning, även om det inte finns någon trådlös överföringsfördröjning, finns det en liknande bearbetningsfördröjning för att identifiera pressen.
För att korrekt rikta baserat på användarens ursprungliga avsikt för en hand- eller kontrollantpress bör du använda den historiska källpositionen eller huvudställningen från den InteractionSourcePressed - eller InteractionSourceReleased-indatahändelsen .
Du kan rikta ett pressmeddelande med historiska posedata från användarens huvud eller deras kontrollant:
Huvudställningen vid den tidpunkt då en gest eller kontrollantpress inträffade, som kan användas för att rikta in sig på att avgöra vad användaren tittade på:
void InteractionManager_InteractionSourcePressed(InteractionSourcePressedEventArgs args) { var interactionSourceState = args.state; var headPose = interactionSourceState.headPose; RaycastHit raycastHit; if (Physics.Raycast(headPose.position, headPose.forward, out raycastHit, 10)) { var targetObject = raycastHit.collider.gameObject; // ... } }Källpositionen vid den tidpunkt då en rörelsekontrollantstryckning inträffade, som kan användas för att rikta in sig på för att avgöra vad användaren pekade kontrollanten på. Detta kommer att vara tillståndet för den kontrollant som upplevde pressen. Om du återger själva kontrollanten kan du begära pekaren i stället för greppet, för att skjuta målstrålen från vad användaren kommer att betrakta som den naturliga spetsen på den renderade kontrollanten:
void InteractionManager_InteractionSourcePressed(InteractionSourcePressedEventArgs args) { var interactionSourceState = args.state; var sourcePose = interactionSourceState.sourcePose; Vector3 sourceGripPosition; Quaternion sourceGripRotation; if ((sourcePose.TryGetPosition(out sourceGripPosition, InteractionSourceNode.Pointer)) && (sourcePose.TryGetRotation(out sourceGripRotation, InteractionSourceNode.Pointer))) { RaycastHit raycastHit; if (Physics.Raycast(sourceGripPosition, sourceGripRotation * Vector3.forward, out raycastHit, 10)) { var targetObject = raycastHit.collider.gameObject; // ... } } }
Exempel på händelsehanterare
using UnityEngine.XR.WSA.Input;
void Start()
{
InteractionManager.InteractionSourceDetected += InteractionManager_InteractionSourceDetected;
InteractionManager.InteractionSourceLost += InteractionManager_InteractionSourceLost;
InteractionManager.InteractionSourcePressed += InteractionManager_InteractionSourcePressed;
InteractionManager.InteractionSourceReleased += InteractionManager_InteractionSourceReleased;
InteractionManager.InteractionSourceUpdated += InteractionManager_InteractionSourceUpdated;
}
void OnDestroy()
{
InteractionManager.InteractionSourceDetected -= InteractionManager_InteractionSourceDetected;
InteractionManager.InteractionSourceLost -= InteractionManager_InteractionSourceLost;
InteractionManager.InteractionSourcePressed -= InteractionManager_InteractionSourcePressed;
InteractionManager.InteractionSourceReleased -= InteractionManager_InteractionSourceReleased;
InteractionManager.InteractionSourceUpdated -= InteractionManager_InteractionSourceUpdated;
}
void InteractionManager_InteractionSourceDetected(InteractionSourceDetectedEventArgs args)
{
// Source was detected
// args.state has the current state of the source including id, position, kind, etc.
}
void InteractionManager_InteractionSourceLost(InteractionSourceLostEventArgs state)
{
// Source was lost. This will be after a SourceDetected event and no other events for this
// source id will occur until it is Detected again
// args.state has the current state of the source including id, position, kind, etc.
}
void InteractionManager_InteractionSourcePressed(InteractionSourcePressedEventArgs state)
{
// Source was pressed. This will be after the source was detected and before it is
// released or lost
// args.state has the current state of the source including id, position, kind, etc.
}
void InteractionManager_InteractionSourceReleased(InteractionSourceReleasedEventArgs state)
{
// Source was released. The source would have been detected and pressed before this point.
// This event will not fire if the source is lost
// args.state has the current state of the source including id, position, kind, etc.
}
void InteractionManager_InteractionSourceUpdated(InteractionSourceUpdatedEventArgs state)
{
// Source was updated. The source would have been detected before this point
// args.state has the current state of the source including id, position, kind, etc.
}
Rörelsekontrollanter i MRTK
Du kan komma åt gest- och rörelsestyrenheten från indatahanteraren.
Följ med i självstudierna
Stegvisa självstudier med mer detaljerade anpassningsexempel finns i Mixed Reality Academy:
MR-inmatning 213 – rörelsestyrenhet
Nästa kontrollpunkt för utveckling
Om du följer unity-utvecklingsresan som vi har lagt fram är du mitt uppe i att utforska MRTK-kärnbyggstenarna. Härifrån kan du fortsätta till nästa byggblock:
Eller gå vidare till Mixed Reality plattformsfunktioner och API:er:
Du kan alltid gå tillbaka till unity-utvecklingskontrollpunkterna när som helst.