Översikt över Scentolkning av SDK

Scentolkning omvandlar de ostrukturerade miljösensordata som din Mixed Reality enhet samlar in och konverterar dem till en kraftfull abstrakt representation. SDK:t 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 mimics kommer att 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 se till att nya representationer och funktioner fortsätter att exponeras inom ett enhetligt ramverk. I det här dokumentet kommer vi först att introducera ö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 funktionsverktyget.

Obs! Den senaste versionen beror på förhandsversionspaket och du måste aktivera förhandsversionspaket för att kunna se den.

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 stöder SceneUnderstanding unity in-editor-stöd som utesluter SceneObserver, som endast används för kommunikation med HoloLens2.

SceneUnderstanding kräver Windows SDK version 18362 eller senare.

Konceptuell översikt

Scenen

Enheten för mixad verklighet integrerar ständigt information om vad den ser i din miljö. Scene Understanding trattar alla dessa datakällor och skapar en enda sammanhängande abstraktion. Scentolkning 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 denna 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. Scengenerering utlöses i stället 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 Driver). Men medan vi utför beräkning i en annan process lagras och underhålls resulterande scendata i ditt program i scenobjektet.

Nedan visas ett diagram som illustrerar det här processflödet och visar exempel på två program som samverkar med Körningsmiljön för Scene Understanding.

Process Diagram

Till vänster finns ett diagram över mixed reality-körningen, som alltid är på och körs i sin 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. De första programgränssnitten 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 finns inte 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 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 valts för att vara enkel samtidigt som en underliggande struktur 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 layoutFysisk 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 logiskt i den här hierarkin, 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 för. Nästa avsnitt innehåller konkreta kodexempel och ytterligare information som är blankade 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 objektpersistence (åtgärden att uppdatera en scen i förhållande till en annan).

Om du behandlar varje nyberäknad scen som distinkt och bara 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:t 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.... uttryckt av deras sortegenskap. 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äknas förmodligen scenens ScenObjekt upp för att bearbeta det som det är intresserat av.

SceneObjects kan ha något av följande:

SceneObjectKind Description
BakgrundSceneObject är känd för att inte vara en av de andra identifierade typerna av scenobjekt. Den här klassen bör inte förväxlas med Okänd där bakgrund är känd för att inte vara vägg / golv / tak etc.... okänt ännu inte har kategoriserats.
VäggenEn fysisk vägg. Väggar antas vara orubbliga miljöstrukturer.
FloorGolv är alla ytor som man kan gå på. Obs! Trappor är inte våningar. 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. Strukturer på flera nivåer, ramper osv. ska alla klassificeras som golv.
CeilingDen övre ytan i ett rum.
PlattformEn stor plan yta där du kan placera hologram. Dessa tenderar att representera tabeller, bänkskivor och andra stora vågräta ytor.
VärldenEn 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äntDet 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 platta 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 bör 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 ska du interagera med MRTK:s ['WindowsSceneUnderstandingObserver'](xref:Microsoft.MixedReality.Toolkit.WindowsSceneUnderstanding.Experimental.WindowsSceneUnderstandingObserver) 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 enhet för mixad verklighet.

Scener beräknas med hjälp av en SceneObserver. Innan du skapar en scen bör ditt program 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 (kallas även 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 Windows Perception- och Unity-API:er för att samordna systemen. Se SpatialCoordinateSystem och SpatialGraphInteropPreview för mer information om API:erna för Windows perception och Mixed Reality ursprungliga 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 hittar en position på quaden där ett objekt kan placeras och försöker hitta den bästa platsen för ditt objekt som garanterar att avgränsningsrutan du anger kommer att finnas kvar på den underliggande ytan.

Anteckning

Koordinaterna för utdata är i förhållande till quad 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 mest placerbar i mitten 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 storleken vara godtyckligt så att minnesanvändningen kan återanvändas effektivt.

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 meshes-egenskapen 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 approximation och det är bra att använda ColliderMeshes där ditt program skulle använda kolliderare. Om systemet inte stöder kolliderare kommer det Mesh objektet som returneras i ColliderMeshes att vara 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 deserialisera 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