Översikt över SDK för scentolkning

Scentolkning omvandlar ostrukturerade miljösensordata som din Mixed Reality enhet samlar in och konverterar dem till en kraftfull abstrakt representation. SDK fungerar som kommunikationslager mellan ditt program och Scene Understanding-körningen. Det syftar till att efterlikna befintliga standardkonstruktioner, till exempel 3D-scendiagram för 3D-representationer och 2D-rektanglar och paneler för 2D-program. Även om konstruktionerna Scene Understanding härmar mappas till konkreta ramverk, är SceneUnderstanding i allmänhet ramverksoberoende, vilket möjliggör samverkan mellan olika ramverk som interagerar med det. När Scene Understanding utvecklas är SDK:ns roll att säkerställa att nya representationer och funktioner fortsätter att exponeras inom ett enhetligt ramverk. I det här dokumentet introducerar vi först övergripande begrepp som hjälper dig att bekanta dig med utvecklingsmiljön/-användningen och sedan tillhandahålla mer detaljerad dokumentation för specifika klasser och konstruktioner.

Var hämtar jag SDK:t?

SceneUnderstanding SDK kan laddas ned via Mixed Reality Feature Tool.

Obs! Den senaste versionen är beroende av förhandsversionspaket och du måste aktivera förhandsversionspaket för att kunna se dem.

För version 0.5.2022-rc och senare stöder Scene Understanding språkprojektioner för C# och C++ så att program kan utveckla program för Win32- eller UWP-plattformar. Från och med den här versionen har SceneUnderstanding stöd för unity i redigeringsprogrammet, med undantag för SceneObserver, som endast används för kommunikation med HoloLens2.

SceneUnderstanding kräver Windows SDK version 18362 eller senare.

Konceptuell översikt

Scenen

Din enhet för mixad verklighet integrerar ständigt information om vad den ser i din miljö. Scene Understanding tratttar alla dessa datakällor och skapar en enda sammanhängande abstraktion. Scene Understanding genererar scener, som är en sammansättning av SceneObjects som representerar en instans av en enda sak (till exempel en vägg/tak/golv.) Scenobjekt är själva en sammansättning av [SceneComponents, som representerar mer detaljerade bitar som utgör detta SceneObject. Exempel på komponenter är fyrhjulingar och nät, men kan i framtiden representera avgränsningsrutor, kollisionsnät, metadata osv.

Processen att konvertera rådata till en scen är en potentiellt dyr åtgärd som kan ta sekunder för medelstora utrymmen (~10x10m) till minuter för stora utrymmen (~50x50m) och därför är det inte något som beräknas av enheten utan programbegäran. I stället utlöses scengenereringen av ditt program på begäran. Klassen SceneObserver har statiska metoder som kan beräkna eller deserialisera en scen, som du sedan kan räkna upp/interagera med. Åtgärden "Compute" körs på begäran och körs på processorn men i en separat process (Mixed Reality-drivrutinen). Men medan vi beräknar i en annan process lagras och underhålls resulterande scendata i ditt program i Scene-objektet.

Nedan visas ett diagram som illustrerar det här processflödet och visar exempel på två program som samverkar med Scene Understanding-körningen.

Till vänster finns ett diagram över mixed reality-körningen, som alltid är igång och körs i en egen process. Den här körningen ansvarar för att utföra enhetsspårning, rumslig mappning och andra åtgärder som Scene Understanding använder för att förstå och resonera om världen omkring dig. Till höger i diagrammet visar vi två teoretiska program som använder Scene Understanding. Det första programgränssnittet med MRTK, som använder Scene Understanding SDK internt, beräknar den andra appen och använder två separata sceninstanser. Alla tre scenerna i det här diagrammet genererar distinkta instanser av scenerna. Drivrutinen spårar inte globalt tillstånd som delas mellan program och scenobjekt i en scen som inte finns i en annan. Scene Understanding tillhandahåller en mekanism för att spåra över tid, men detta görs med hjälp av SDK: et. Spårningskoden körs redan i SDK:et i appens process.

Eftersom varje scen lagrar sina data i programmets minnesutrymme kan du anta att alla funktioner i scenobjektet eller dess interna data alltid körs i programmets process.

Layout

För att arbeta med Scene Understanding kan det vara värdefullt att känna till och förstå hur körningen representerar komponenter logiskt och fysiskt. Scenen representerar data med en specifik layout som valdes för att vara enkel samtidigt som den underliggande strukturen bibehålls som är smidig för att uppfylla framtida krav utan att behöva större revisioner. Scenen gör detta genom att lagra alla komponenter (byggstenar för alla scenobjekt) i en platt lista och definiera hierarki och sammansättning via referenser där specifika komponenter refererar till andra.

Nedan visar vi ett exempel på en struktur i både dess platta och logiska form.

Logisk layout	Fysisk layout
Scen SceneObject_1 SceneMesh_1 SceneQuad_1 SceneQuad_2 SceneObject_2 SceneQuad_1 SceneQuad_3 SceneObject_3 SceneMesh_3	SceneObject_1 SceneObject_2 SceneObject_3 SceneQuad_1 SceneQuad_2 SceneQuad_3 SceneMesh_1 SceneMesh_2

Den här bilden visar skillnaden mellan scenens fysiska och logiska layout. Till vänster ser vi den hierarkiska layouten för de data som programmet ser när scenen räknas upp. Till höger ser vi att scenen består av 12 olika komponenter som är tillgängliga individuellt om det behövs. När vi bearbetar en ny scen förväntar vi oss att program går den här hierarkin logiskt, men när de spårar mellan scenuppdateringar kanske vissa program bara är intresserade av att rikta in sig på specifika komponenter som delas mellan två scener.

API-översikt

Följande avsnitt innehåller en översikt över konstruktionerna i Scene Understanding. När du läser det här avsnittet får du en förståelse för hur scener representeras och vad de olika komponenterna gör/används till. Nästa avsnitt innehåller konkreta kodexempel och ytterligare information som slätas över i den här översikten.

Alla typer som beskrivs nedan finns i Microsoft.MixedReality.SceneUnderstanding namnområdet.

SceneComponents

Nu när du förstår den logiska layouten för scener kan vi presentera begreppet SceneComponents och hur de används för att skapa hierarki. SceneComponents är de mest detaljerade nedbrytningarna i SceneUnderstanding som representerar en enda kärngrej, till exempel ett nät eller en quad eller en avgränsningsruta. SceneComponents är saker som kan uppdateras oberoende av varandra och som kan refereras av andra SceneComponents, därför har de en enda global egenskap, ett unikt ID, som möjliggör den här typen av spårnings-/referensmekanism. ID:n används för den logiska sammansättningen av scenhierarkin samt objektpersistens (åtgärden att uppdatera en scen i förhållande till en annan).

Om du behandlar varje nyberäknad scen som distinkt och helt enkelt räknar upp alla data i den, är ID:n i stort sett transparenta för dig. Men om du planerar att spåra komponenter över flera uppdateringar använder du ID:na för att indexera och hitta SceneComponents mellan scenobjekt.

SceneObjects

En SceneObject är en SceneComponent som representerar en instans av en "sak", till exempel en vägg, ett golv, ett tak osv.... uttrycks av deras kindegendom. SceneObjects är geometriska och har därför funktioner och egenskaper som representerar deras plats i rymden, men de innehåller ingen geometrisk eller logisk struktur. I stället refererar SceneObjects till andra SceneComponents, särskilt SceneQuads och SceneMeshes, som tillhandahåller de olika representationer som stöds av systemet. När en ny scen beräknas räknar ditt program troligen upp scenens SceneObjects för att bearbeta vad den är intresserad av.

SceneObjects kan ha något av följande:

SceneObjectKind	Description
Bakgrund	SceneObject är känd för att inte vara en av de andra identifierade typerna av scenobjekt. Den här klassen ska inte förväxlas med Okänd där bakgrund är känt för att inte vara vägg/golv/tak osv.... okänt ännu inte har kategoriserats.
Väggen	En fysisk vägg. Väggar antas vara fasta miljöstrukturer.
Floor	Golv är alla ytor som man kan gå på. Observera: trappor är inte golv. Observera också att golv förutsätter någon gångbar yta och därför finns det inget uttryckligt antagande om ett enda golv. Flernivåstrukturer, ramper osv. ska alla klassificeras som golv.
Ceiling	Den övre ytan av ett rum.
Plattform	En stor plan yta där du kan placera hologram. Dessa tenderar att representera tabeller, bänkskivor och andra stora vågräta ytor.
Världen	En reserverad etikett för geometriska data som är oberoende för etikettering. Det nät som genereras genom att ange uppdateringsflaggan EnableWorldMesh klassificeras som världen.
Okänt	Det här scenobjektet har ännu inte klassificerats och tilldelats en typ. Detta bör inte förväxlas med Bakgrund, eftersom det här objektet kan vara vad som helst, systemet har helt enkelt inte kommit fram till en tillräckligt stark klassificering för det ännu.

ScenMesh

En SceneMesh är en SceneComponent som approximerar geometrin för godtyckliga geometriska objekt med hjälp av en triangellista. SceneMeshes används i flera olika sammanhang. de kan representera komponenter i den vattentäta cellstrukturen eller som WorldMesh, som representerar det obundna spatiala mappningsnätet som är associerat med scenen. Index- och hörndata som tillhandahålls med varje nät använder samma välbekanta layout som hörn- och indexbuffertar som används för återgivning av triangelnät i alla moderna renderings-API:er. I Scene Understanding använder nät 32-bitarsindex och kan behöva delas upp i segment för vissa renderingsmotorer.

Lindningsordning och koordinatsystem

Alla nät som produceras av Scene Understanding förväntas returnera nät i ett Right-Handed koordinatsystem medsols lindningsordning.

Obs! OPERATIVSYSTEMversioner före .191105 kan ha en känd bugg där "World"-nät returnerades i Counter-Clockwise lindningsordning, som senare har åtgärdats.

Scenkvalv

En SceneQuad är en SceneComponent som representerar 2D-ytor som upptar 3D-världen. SceneQuads kan användas på samma sätt som ARKit ARPlaneAnchor eller ARCore Planes, men de erbjuder fler funktioner på hög nivå som 2d-arbetsytor som ska användas av flata appar eller förhöjd UX. 2D-specifika API:er tillhandahålls för quads som gör placering och layout enkel att använda och utveckla (med undantag för rendering) med quads bör kännas mer likt att arbeta med 2d-arbetsytor än 3d meshes.

SceneQuad-form

SceneQuads definierar en avgränsad rektangulär yta i 2d. SceneQuads representerar dock ytor med godtyckliga och potentiellt komplexa former (t.ex. en ringformad tabell.) Om du vill representera den komplexa formen på en quads yta kan du använda API:et GetSurfaceMask för att återge ytans form på en bildbuffert som du tillhandahåller. Om SceneObject som har quaden också har ett nät, ska nättrianglarna motsvara den här renderade bilden, de representerar båda ytans verkliga geometri, antingen i 2d- eller 3d-koordinater.

Scentolkning av SDK-information och -referens

Anteckning

När du använder MRTK, Observera att du kommer att interagera med MRTK:s ['WindowsSceneUnderstandingObserver'](xref:Microsoft.MixedReality.Toolkit.WindowsSceneUnderstanding.Experimental.WindowsSceneUnderstandingObserver?view=mixed-reality-toolkit-unity-2020-dotnet-2.8.0&preserve-view=true) och kan därför hoppa över det här avsnittet under de flesta omständigheter. Mer information finns i [MRTK Scene Understanding docs](/windows/mixed-reality/mrtk-unity/features/spatial-awareness/scene-understanding).

Följande avsnitt hjälper dig att bekanta dig med grunderna i SceneUnderstanding. Det här avsnittet bör ge dig grunderna. Då bör du ha tillräckligt med kontext för att bläddra igenom exempelprogrammen för att se hur SceneUnderstanding används holistiskt.

Initiering

Det första steget för att arbeta med SceneUnderstanding är att ditt program ska få referens till ett scenobjekt. Detta kan göras på ett av två sätt, en scen kan antingen beräknas av drivrutinen eller så kan en befintlig scen som tidigare beräknats av-serialiseras. Det senare är användbart för att arbeta med SceneUnderstanding under utveckling, där program och upplevelser kan prototyperas snabbt utan en mixed reality-enhet.

Scener beräknas med hjälp av en SceneObserver. Innan du skapar en scen bör programmet fråga enheten för att se till att den stöder SceneUnderstanding, samt begära användaråtkomst för information som SceneUnderstanding behöver.

if (!SceneObserver.IsSupported())
{
    // Handle the error
}

// This call should grant the access we need.
await SceneObserver.RequestAccessAsync();

Om RequestAccessAsync() inte anropas misslyckas databehandlingen av en ny scen. Därefter beräknar vi en ny scen som är rotad runt Mixed Reality headset och har en radie på 10 meter.

// Create Query settings for the scene update
SceneQuerySettings querySettings;

querySettings.EnableSceneObjectQuads = true;                                       // Requests that the scene updates quads.
querySettings.EnableSceneObjectMeshes = true;                                      // Requests that the scene updates watertight mesh data.
querySettings.EnableOnlyObservedSceneObjects = false;                              // Do not explicitly turn off quad inference.
querySettings.EnableWorldMesh = true;                                              // Requests a static version of the spatial mapping mesh.
querySettings.RequestedMeshLevelOfDetail = SceneMeshLevelOfDetail.Fine;            // Requests the finest LOD of the static spatial mapping mesh.

// Initialize a new Scene
Scene myScene = SceneObserver.ComputeAsync(querySettings, 10.0f).GetAwaiter().GetResult();

Initiering från data (även kallat PC-sökvägen)

Scener kan beräknas för direkt förbrukning, men de kan också beräknas i serialiserad form för senare användning. Detta har visat sig vara användbart för utveckling eftersom det gör det möjligt för utvecklare att arbeta i och testa Scene Understanding utan att behöva en enhet. Serialiseringen av en scen är nästan identisk med att beräkna den. Data returneras till ditt program i stället för att deserialiseras lokalt av SDK:t. Du kan sedan deserialisera den själv eller spara den för framtida användning.

// Create Query settings for the scene update
SceneQuerySettings querySettings;

// Compute a scene but serialized as a byte array
SceneBuffer newSceneBuffer = SceneObserver.ComputeSerializedAsync(querySettings, 10.0f).GetAwaiter().GetResult();

// If we want to use it immediately we can de-serialize the scene ourselves
byte[] newSceneData = new byte[newSceneBuffer.Size];
newSceneBuffer.GetData(newSceneData);
Scene mySceneDeSerialized = Scene.Deserialize(newSceneData);

// Save newSceneData for later

SceneObject-uppräkning

Nu när programmet har en scen tittar programmet på och interagerar med SceneObjects. Detta görs genom att öppna egenskapen SceneObjects :

SceneObject firstFloor = null;

// Find the first floor object
foreach (var sceneObject in myScene.SceneObjects)
{
    if (sceneObject.Kind == SceneObjectKind.Floor)
    {
        firstFloor = sceneObject;
        break;
    }
}

Komponenter för uppdatering och förfining av komponenter

Det finns en annan funktion som hämtar komponenter i scenen med namnet FindComponent. Den här funktionen är användbar när du uppdaterar spårningsobjekt och hittar dem i senare scener. Följande kod beräknar en ny scen i förhållande till en tidigare scen och hittar sedan golvet i den nya scenen.

// Compute a new scene, and tell the system that we want to compute relative to the previous scene
Scene myNextScene = SceneObserver.ComputeAsync(querySettings, 10.0f, myScene).GetAwaiter().GetResult();

// Use the Id for the floor we found last time, and find it again
firstFloor = (SceneObject)myNextScene.FindComponent(firstFloor.Id);

if (firstFloor != null)
{
    // We found it again, we can now update the transforms of all objects we attached to this floor transform
}

Komma åt nät och fyrhjulingar från scenobjekt

När SceneObjects har hittats vill ditt program troligen komma åt de data som finns i de quads/meshes som det består av. Dessa data nås med egenskaperna Quads och Meshes . Följande kod räknar upp alla fyrhjulingar och maskor i vårt golvobjekt.

// Get the transform for the SceneObject
System.Numerics.Matrix4x4 objectToSceneOrigin = firstFloor.GetLocationAsMatrix();

// Enumerate quads
foreach (var quad in firstFloor.Quads)
{
    // Process quads
}

// Enumerate meshes
foreach (var mesh in firstFloor.Meshes)
{
    // Process meshes
}

Observera att det är SceneObject som har transformering som är relativ till scenens ursprung. Detta beror på att SceneObject representerar en instans av en "sak" och är locatable i rymden, quads och nät representerar geometri som transformeras i förhållande till deras överordnade. Det är möjligt att separata SceneObjects refererar till samma SceneMesh/SceneQuad SceneComponents, och det är också möjligt att en SceneObject har mer än en SceneMesh/SceneQuad.

Hantera transformeringar

Scene Understanding har gjort ett avsiktligt försök att anpassa sig till traditionella 3D-scenrepresentationer när det gäller transformeringar. Varje scen är därför begränsad till ett enda koordinatsystem ungefär som de vanligaste 3D-miljörepresentationerna. SceneObjects anger var och en sin plats i förhållande till det koordinatsystemet. Om ditt program hanterar scener som sträcker gränsen för vad ett enda ursprung ger kan det förankra SceneObjects till SpatialAnchors, eller generera flera scener och sammanfoga dem, men för enkelhetens skull antar vi att vattentäta scener finns i deras eget ursprung som lokaliseras av ett NodeId som definieras av Scene.OriginSpatialGraphNodeId.

Följande Unity-kod visar till exempel hur du använder API:er för Windows Perception och Unity för att samordna systemen. Se SpatialCoordinateSystem och SpatialGraphInteropPreview för mer information om API:er för Windows Perception och Mixed Reality interna objekt i Unity för mer information om hur du hämtar ett SpatialCoordinateSystem som motsvarar Unitys ursprung i världen.

private System.Numerics.Matrix4x4? GetSceneToUnityTransformAsMatrix4x4(SceneUnderstanding.Scene scene)
{
    System.Numerics.Matrix4x4? sceneToUnityTransform = System.Numerics.Matrix4x4.Identity;

    
    Windows.Perception.Spatial.SpatialCoordinateSystem sceneCoordinateSystem = Microsoft.Windows.Perception.Spatial.Preview.SpatialGraphInteropPreview.CreateCoordinateSystemForNode(scene.OriginSpatialGraphNodeId);
    Windows.Perception.Spatial.SpatialCoordinateSystem unityCoordinateSystem = Microsoft.Windows.Perception.Spatial.SpatialCoordinateSystem.FromNativePtr(UnityEngine.XR.WindowsMR.WindowsMREnvironment.OriginSpatialCoordinateSystem);

    sceneToUnityTransform = sceneCoordinateSystem.TryGetTransformTo(unityCoordinateSystem);

    if (sceneToUnityTransform != null)
    {
        sceneToUnityTransform = ConvertRightHandedMatrix4x4ToLeftHanded(sceneToUnityTransform.Value);
    }
    else
    {
        return null;
    }
            
    return sceneToUnityTransform;
}

Var och SceneObject en har en transformering som sedan tillämpas på objektet. I Unity konverterar vi till högerhänta koordinater och tilldelar lokala transformeringar så här:

private System.Numerics.Matrix4x4 ConvertRightHandedMatrix4x4ToLeftHanded(System.Numerics.Matrix4x4 matrix)
{
    matrix.M13 = -matrix.M13;
    matrix.M23 = -matrix.M23;
    matrix.M43 = -matrix.M43;

    matrix.M31 = -matrix.M31;
    matrix.M32 = -matrix.M32;
    matrix.M34 = -matrix.M34;

    return matrix;
}

 private void SetUnityTransformFromMatrix4x4(Transform targetTransform, System.Numerics.Matrix4x4 matrix, bool updateLocalTransformOnly = false)
 {
    if(targetTransform == null)
    {
        return;
    }

    Vector3 unityTranslation;
    Quaternion unityQuat;
    Vector3 unityScale;

    System.Numerics.Vector3 vector3;
    System.Numerics.Quaternion quaternion;
    System.Numerics.Vector3 scale;

    System.Numerics.Matrix4x4.Decompose(matrix, out scale, out quaternion, out vector3);

    unityTranslation = new Vector3(vector3.X, vector3.Y, vector3.Z);
    unityQuat        = new Quaternion(quaternion.X, quaternion.Y, quaternion.Z, quaternion.W);
    unityScale       = new Vector3(scale.X, scale.Y, scale.Z);

    if(updateLocalTransformOnly)
    {
        targetTransform.localPosition = unityTranslation;
        targetTransform.localRotation = unityQuat;
    }
    else
    {
        targetTransform.SetPositionAndRotation(unityTranslation, unityQuat);
    }
}

// Assume we have an SU object called suObject and a unity equivalent unityObject

System.Numerics.Matrix4x4 converted4x4LocationMatrix = ConvertRightHandedMatrix4x4ToLeftHanded(suObject.GetLocationAsMatrix());
SetUnityTransformFromMatrix4x4(unityObject.transform, converted4x4LocationMatrix, true);
        

Quad

Quads har utformats för att hjälpa 2D-placeringsscenarier och bör betraktas som tillägg till 2D-arbetsyte-UX-element. Quads är komponenter i SceneObjects och kan renderas i 3D, men Quad-API:erna förutsätter att Quads är 2D-strukturer. De erbjuder information som omfattning, form och tillhandahåller API:er för placering.

Quads har rektangulära omfattningar, men de representerar godtyckligt formade 2D-ytor. För att aktivera placering på dessa 2D-ytor som interagerar med 3D-miljön erbjuder quads verktyg för att göra denna interaktion möjlig. För närvarande tillhandahåller Scene Understanding två sådana funktioner, FindCentermostPlacement och GetSurfaceMask. FindCentermostPlacement är ett högnivå-API som letar upp en position på quaden där ett objekt kan placeras och försöker hitta den bästa platsen för objektet som garanterar att avgränsningsrutan du anger kommer att finnas kvar på den underliggande ytan.

Anteckning

Koordinaterna för utdata är relativa till quaden i "quad space" där det övre vänstra hörnet är (x = 0, y = 0), precis som med andra windows Rect-typer. Var noga med att ta hänsyn till detta när du arbetar med ursprunget till dina egna objekt.

I följande exempel visas hur du hittar den plats som är längst till centrum och fäster ett hologram till quaden.

// This code assumes you already have a "Root" object that attaches the Scene's Origin.

// Find the first quad
foreach (var sceneObject in myScene.SceneObjects)
{
    // Find a wall
    if (sceneObject.Kind == SceneObjectKind.Wall)
    {
        // Get the quad
        var quads = sceneObject.Quads;
        if (quads.Count > 0)
        {
            // Find a good location for a 1mx1m object  
            System.Numerics.Vector2 location;
            if (quads[0].FindCentermostPlacement(new System.Numerics.Vector2(1.0f, 1.0f), out location))
            {
                // We found one, anchor something to the transform
                // Step 1: Create a new game object for the quad itself as a child of the scene root
                // Step 2: Set the local transform from quads[0].Position and quads[0].Orientation
                // Step 3: Create your hologram and set it as a child of the quad's game object
                // Step 4: Set the hologram's local transform to a translation (location.x, location.y, 0)
            }
        }
    }
}

Steg 1–4 är mycket beroende av ditt specifika ramverk/implementering, men temana bör vara liknande. Observera att Quad helt enkelt representerar ett avgränsat 2D-plan som är lokaliserat i rymden. Genom att låta motorn/ramverket veta var quaden är och rota dina objekt i förhållande till quaden, kommer dina hologram att placeras korrekt med avseende på den verkliga världen.

Nät

Maskor representerar geometriska representationer av objekt eller miljöer. Precis som rumslig mappning använder nätindex och hörndata som tillhandahålls med varje rumsligt ytnät samma välbekanta layout som hörn- och indexbuffertar som används för återgivning av triangelnät i alla moderna renderings-API:er. Hörnpositioner tillhandahålls i koordinatsystemet för Scene. De specifika API:er som används för att referera till dessa data är följande:

void GetTriangleIndices(int[] indices);
void GetVertices(System.Numerics.Vector3[] vertices);

Följande kod ger ett exempel på hur du genererar en triangellista från nätstrukturen:

uint[] indices = new uint[mesh.TriangleIndexCount];
System.Numerics.Vector3[] positions = new System.Numerics.Vector3[mesh.VertexCount];

mesh.GetTriangleIndices(indices);
mesh.GetVertexPositions(positions);

Buffertarna för index/hörn måste vara >= index/hörnantal, men annars kan storleksanpassas godtyckligt, vilket möjliggör effektiv återanvändning av minne.

ColliderMesh

Scenobjekt ger åtkomst till nät- och kolliderarnätdata via egenskaperna Meshes och ColliderMeshes. Dessa nät matchar alltid, vilket innebär att i'th-indexet för egenskapen Meshes representerar samma geometri som i'th-indexet för egenskapen ColliderMeshes. Om körningen/objektet har stöd för kolliderarnät får du garanterat den lägsta polygonen, den högsta ordningens uppskattning och det är bra att använda ColliderMeshes varhelst ditt program använder colliders. Om systemet inte stöder kolliderare är Mesh-objektet som returneras i ColliderMeshes samma objekt som det nät som minskar minnesbegränsningarna.

Utveckla med scentolkning

Nu bör du förstå de viktigaste byggstenarna i scentolkningskörningen och SDK:n. Huvuddelen av kraften och komplexiteten ligger i åtkomstmönster, interaktion med 3D-ramverk och verktyg som kan skrivas ovanpå dessa API:er för att utföra mer avancerade uppgifter som rumslig planering, rumsanalys, navigering, fysik och så vidare. Vi hoppas kunna samla in dessa i exempel som förhoppningsvis bör vägleda dig i rätt riktning för att få dina scenarier att skina. Om det finns exempel eller scenarier som vi inte tar upp meddelar du oss så försöker vi dokumentera/göra en prototyp av det du behöver.

Var kan jag hämta exempelkod?

Scentolkning av exempelkod för Unity finns på vår Unity-exempelsida . Med det här programmet kan du kommunicera med enheten och återge de olika scenobjekten, eller så kan du läsa in en serialiserad scen på datorn och uppleva Scentolkning utan enhet.

Var kan jag hämta exempelscener?

Om du har en HoloLens2 kan du spara alla scenarier som du har samlat in genom att spara utdata från ComputeSerializedAsync till filen och avserialisera den när det passar dig.

Om du inte har en HoloLens2-enhet men vill experimentera med Scene Understanding måste du ladda ned en förinställd scen. Scentolkningsexemplet levereras för närvarande med serialiserade scener som kan laddas ned och användas när det passar dig. Du hittar dem här:

Scentolkning – exempelscener

Se även

• Rumslig mappning
• Scentolkning
• Unity-exempel