Översikt över Scene Understanding SDK

Scenförståelse omvandlar de ostrukturerade miljösensordata som din Mixed Reality samlar in och konverterar dem till en kraftfull abstrakt representation. SDK:n fungerar som kommunikationslagret mellan ditt program och Scene Understanding-körningen. Syftet är 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-efterliknar kommer att mappa till konkreta ramverk, är SceneUnderstanding ramverksoberoende, vilket möjliggör samverkan mellan olika ramverk som interagerar med det. Allt eftersom 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 introducerar vi först avancerade 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 får jag SDK?.

SceneUnderstanding SDK kan laddas ned via Mixed Reality Feature Tool.

Obs! Den senaste versionen beror på förhandsversionspaket och du måste aktivera förhandsversionspaket för att 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 har SceneUnderstanding stöd för Unity in-editor-stöd för barring av SceneObserver, som endast används för att kommunicera 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 trattar 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 enskild sak (till exempel en vägg/ett tak/golv.) Själva scenobjekten är en sammansättning av [SceneComponents, som representerar mer detaljerade delar som utgör det här SceneObject. Exempel på komponenter är quads och nät, men i framtiden kan de representera avgränsande rutor, kollisionsnät, metadata osv.

Processen att konvertera rådata från sensorn till en scen är en potentiellt dyr åtgärd som kan ta sekunder för medelstora utrymmen (~10x10m) till minuter för stora utrymmen (~50 x 50 m) 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 drivrutin). Men även om vi beräknar 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 är sammankopplade med Scene Understanding-körningen.

Processdiagram

På vänster sida 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 få en anledning till 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, den andra appen beräknar och använder två separata sceninstanser. Alla tre scener i det här diagrammet genererar distinkta instanser av kulisserna, 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. 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 bra att känna till och förstå hur körningen representerar komponenter logiskt och fysiskt. Scenen representerar data med en specifik layout som har valts för att vara enkel och samtidigt upprätthålla en underliggande struktur som är anpassningsbar 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 den fysiska och logiska layouten för scenen. Till vänster ser vi den hierarkiska layouten för de data som ditt program ser när scenen räknas upp. Till höger ser vi att scenen består av 12 distinkta komponenter som är tillgängliga individuellt om det behövs. När vi bearbetar en ny scen förväntar vi oss att program ska gå i den här hierarkin logiskt, men när du 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 på hög nivå över konstruktionerna i Scene Understanding. I 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 visas 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ärn sak, till exempel ett nät eller en quad eller en begränsningsruta. SceneComponents är saker som kan uppdateras separat och kan refereras till av andra SceneComponents, och 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 (uppdatering av en scen i förhållande till en annan).

Om du behandlar varje nyuppräknad scen som distinkt och räknar upp alla data i den, så är dina ID:er i stort sett transparenta för dig. Men om du planerar att spåra komponenter över flera uppdateringar använder du -ID:erna 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 egenskapen Kind. SceneObjects är geometriska och har därför funktioner och egenskaper som representerar deras plats i rymden, men de innehåller inte någon 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 kommer programmet troligen att räkna upp scenens SceneObjects för att bearbeta vad det är intresserad av.

SceneObjects kan ha något av följande:

SceneObjectKind Description
BakgrundSceneObject är känt 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änd för att inte vara vägg/golv/tak osv.... medan okänd ännu inte kategoriseras.
VäggenEn fysisk vägg. Väggar antas vara flyttbara miljöstrukturer.
FloorGolv är alla ytor som man kan gå på. Obs! Golven är inte golv. Observera också att golv förutsätter en gångbar yta och därför finns det inget uttryckligt antagande om ett enda golv. Strukturer på flera nivåer, ramper osv. bör 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, räknaren och andra stora vågräta ytor.
VärldenEn reserverad etikett för geometriska data som är agnostiska för etikettering. Nät som genereras genom att ange uppdateringsflaggan EnableWorldMesh klassificeras som world.
OkäntDet här scenobjektet har ännu inte klassificerats och tilldelats en typ. Detta bör inte förväxlas med Background, 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.

SceneMesh

En SceneMesh är en SceneComponent som approximer geometrin för godtyckliga geometriska objekt med hjälp av en triangellista. SceneMeshes används i flera olika kontexter. De kan representera komponenter i den watertight-cellstrukturen eller som WorldMesh, som representerar det obegränsade rumsliga kartnät som är associerat med scenen. Index- och brytpunktsdata som medföljer varje nät använder samma välbekanta layout som brytpunkts- och indexbuffertarna som används för att återge trianglarna i alla moderna renderings-API:er. I Scene Understanding använder nät 32-bitars index och kan behöva delas upp i segment för vissa renderingsmotorer.

Ordningsföljd och koordinatsystem

Alla nät som produceras av Scene Understanding förväntas returnera nät i ett Right-Handed koordinatsystem med hjälp av medurs ordning.

Obs! Operativsystemsbyggen före .191105 kan ha ett känt fel där "World"-nät returnerades i Counter-Clockwise ordningsföljd, som sedan har åtgärdats.

SceneQuad

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-arbetsyta som ska användas av platta appar eller förhöjd UX. 2D-specifika API:er tillhandahålls för quads som gör det enkelt att använda placering och layout, och utveckling (med undantag för rendering) med quads bör kännas mer likna att arbeta med 2d-arbetsyta än 3d-nät.

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 quad kan du använda GETSurfaceMask-API:et för att rendera ytans form till en bildbuffert som du anger. Om SceneObject som har quaden också har ett nät ska nättrianglarna motsvara den renderade bilden. Båda representerar den verkliga geometrin för ytan, antingen i 2d- eller 3d-koordinater.

Scene Understanding SDK-information och referens

Anteckning

När du använder MRTK bör du observera att du kommer att interagera med MRTK:er och därför kan hoppa över det [`WindowsSceneUnderstandingObserver`](xref:Microsoft.MixedReality.Toolkit.WindowsSceneUnderstanding.Experimental.WindowsSceneUnderstandingObserver) här avsnittet i de flesta fall. Mer information finns i [MRTK Scene](/windows/mixed-reality/mrtk-unity/features/spatial-awareness/scene-understanding) Understanding-dokument.

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 programmet får referens till ett Scene-objekt. 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 har beräknats tidigare avser 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 med mixad verklighet.

Scener beräknas med en SceneObserver. Innan du skapar en scen bör programmet fråga enheten för att se till att den stöder SceneUnderstanding, samt för att 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 beräkning av en ny scen. Härnäst ska vi beräkna 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. Att serialisera en scen är nästan identiskt med att beräkna den. Data returneras till ditt program i stället för att deserialiseras lokalt av SDK:n. 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 kommer programmet att titta på och interagera med SceneObjects. Det gör du 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;
    }
}

Komponentuppdatering och omdefiniera komponenter

Det finns en annan funktion som hämtar komponenter i scenen som heter FindComponent. Den här funktionen är användbar när du uppdaterar spårning av objekt 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 ordet 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 Meshes och Quads från scenobjekt

När SceneObjects har hittats vill ditt program troligen komma åt de data som finns i de quads/mesh som det består av. Dessa data nås med egenskaperna Quads _ och _ Meshes . Följande kod kommer att räkna upp alla quads och nät 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 transformeringen som är relativ till scenens ursprung. Detta beror på att SceneObject representerar en instans av en "sak" och är oskadlig i rymden, quads och nät representerar geometri som omvandlas i förhållande till deras överordnade. Det är möjligt för separata SceneObjects att referera till samma SceneMesh/SceneQuad SceneComponents, och det är också möjligt att ett SceneObject har fler än en SceneMesh/SceneQuad.

Hantera transformeringar

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

Följande Unity-kod visar till exempel hur du använder API:Windows Perception och Unity för att samordna system tillsammans. Se SpatialCoordinateSystem och SpatialGraphInteropPreview för mer information om API:erna för Windows Perception och Mixed Reality inbyggda 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);
      HolograhicFrameData holoFrameData =  Marshal.PtrToStructure<HolograhicFrameData>(UnityEngine.XR.XRDevice.GetNativePtr());
      Windows.Perception.Spatial.SpatialCoordinateSystem unityCoordinateSystem = Microsoft.Windows.Perception.Spatial.SpatialCoordinateSystem.FromNativePtr(holoFrameData.ISpatialCoordinateSystemPtr);

      sceneToUnityTransform = sceneCoordinateSystem.TryGetTransformTo(unityCoordinateSystem);

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

    return sceneToUnityTransform;
}

Var SceneObject och en har en transformering som sedan tillämpas på objektet. I Unity konverterar vi till högerhänt 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 ses som tillägg till 2D-arbetsyte-UX-element. Quads är komponenter i SceneObjects och kan återges i 3D, men Quad-API:erna förutsätter själva att Quads är 2D-strukturer. De erbjuder information som omfattning, form och api:er för placering.

Quads har rektangulära delar, men de representerar godtyckligt 2D-ytor. För att möjliggöra placering på dessa 2D-ytor som interagerar med 3D-miljön erbjuder quads verktyg för att möjliggöra den här interaktionen. För närvarande innehå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 den avgränsande rutan som du anger finns 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 det skulle vara med andra windows Rect-typer. Se till att ta hänsyn till detta när du arbetar med ursprung för dina egna objekt.

I följande exempel visas hur du hittar den mittersta platsbara platsen och ankare 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/din implementering, men temana bör vara liknande. Det är viktigt att notera att Quad bara representerar ett avgränsat 2D-plan som är lokaliserat i rymden. Genom att se till att motorn/ramverket vet var quaden är och rotar dina objekt i förhållande till quaden, kommer dina hologram att finnas korrekt med avseende på den verkliga världen.

Nät

Nät representerar geometriska representationer av objekt eller miljöer. Ungefär som spatial mappninganvänder nätindex och hörndata som medföljer varje rumsligt ytnät samma välbekanta layout som brytpunkts- och indexbuffertar som används för rendering av trianglar i alla moderna renderings-API:er. Hörnpositioner anges 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);

Index-/brytpunktsbuffertarna måste vara >= antalet index/hörn, men kan annars vara godtycklig storlek vilket möjliggör effektiv minnesåteranvändning.

ColliderMesh

Scenobjekt ger åtkomst till nät- och kollidernätsdata via meshes- och ColliderMeshes-egenskaperna. Dessa nät matchar alltid, vilket innebär att det i:e indexet för Meshes-egenskapen representerar samma geometri som det i:e indexet för egenskapen ColliderMeshes. Om körnings-/objekt stöder kollisionsnät får du garanterat lägsta polygon, högsta ordningsrimning och det är en bra idé att använda ColliderMeshes oavsett var ditt program skulle använda krockare. Om systemet inte stöder kollisioner är Mesh-objektet som returnerades i ColliderMeshes samma objekt som det nät som minskar minnesbegränsningarna.

Utveckla med scenförståelse

Nu bör du förstå de grundläggande byggstenarna i scenen för att förstå körning och SDK. Den största delen 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 rumsplanering, rumsanalys, navigering, fysik och så vidare. Vi hoppas kunna samla in dessa i exempel som förhoppningsvis kan vägleda dig i rätt riktning så att dina scenarier kommer att bli riktigt bra. Om det finns exempel eller scenarier som vi inte tar upp kan du berätta för oss så försöker vi dokumentera/skapa en prototyp av det du behöver.

Var kan jag få exempelkod?

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

Var kan jag få exempelscener?

Om du har en HoloLens2 kan du spara alla scener som du har avbildat genom att spara utdata från ComputeSerializedAsync till att fila och deserialisera den på egen hand.

Om du inte har en HoloLens2-enhet men vill spela med Scene Understanding måste du ladda ned en förinspelad scen. Scene Understanding-exemplet levereras för närvarande med serialiserade scener som kan laddas ned och användas på egen hand. Du hittar dem här:

Scenförståelse – exempelscenarier

Se även