Visão geral do SDK compreensiva da cena

A compreensão de cena transforma os dados de sensores de ambiente não estruturados que o seu dispositivo de Realidade Mista captura e converte-os numa poderosa representação abstrata. O SDK funciona como a camada de comunicação entre a sua aplicação e o tempo de execução do Encontro de Cena. Destina-se a imitar as construções padrão existentes, tais como gráficos de cena 3D para representações 3D, e retângulos 2D e painéis para aplicações 2D. Enquanto as construções De Modo De Cena imitará vão mapear para estruturas concretas, em geral SceneUnderstanding é agnóstico-quadro permitindo a interoperabilidade entre quadros variados que interagem com ele. À medida que a Compreensão de Cena evolui, o papel do SDK é garantir que novas representações e capacidades continuem expostas dentro de um quadro unificado. Neste documento, vamos primeiro introduzir conceitos de alto nível que o ajudarão a familiarizar-se com o ambiente/utilização de desenvolvimento e, em seguida, fornecer documentação mais detalhada para classes e construções específicas.

Onde consigo o SDK?

O SceneUnderstanding SDK é descarregado através da Ferramenta de Recurso de Realidade Mista.

Nota: a versão mais recente depende de pacotes de pré-visualização e terá de permitir que os pacotes pré-lançamento o vejam.

Para a versão 0.5.2022-rc e posteriormente, o Scene Understanding suporta projeções linguísticas para C# e C++ permitindo que as aplicações desenvolvam aplicações para plataformas Win32 ou UWP. A partir desta versão, o SceneUnderstanding suporta o suporte de unidade no editor, impedindo o SceneObserver, que é usado exclusivamente para comunicar com holoLens2.

SceneUnderstanding requer Windows versão SDK 18362 ou superior.

Visão geral conceptual

A Cena

O seu dispositivo de realidade mista está constantemente a integrar informação sobre o que vê no seu ambiente. A Compreensão de Cena funiliza todas estas fontes de dados e produz uma única abstração coesa. A Compreensão de Cena gera Cenas, que são uma composição de SceneObjects que representam um exemplo de uma única coisa, (por exemplo, uma parede/teto/chão.) Os próprios Objetos de Cena são uma composição de [SceneComponents, que representam mais peças granulares que compõem este SceneObject. Exemplos de componentes são quads e malhas, mas no futuro podem representar caixas de delimitação, malhas de colisão, metadados, etc.

O processo de conversão dos dados do sensor bruto numa Cena é uma operação potencialmente cara que pode demorar segundos para espaços médios (~10x10m) para minutos para espaços grandes (~50x50m) e, portanto, não é algo que esteja a ser calculado pelo dispositivo sem pedido de aplicação. Em vez disso, a geração Scene é desencadeada pela sua aplicação a pedido. A classe SceneObserver tem métodos estáticos que podem Computar ou Deserializar uma cena, com a qual pode enumerar/interagir. A ação "Compute" é executada a pedido e executada no CPU, mas num processo separado (o Condutor de Realidade Mista). No entanto, enquanto calculamos noutro processo, os dados de Cena resultantes são armazenados e mantidos na sua aplicação no objeto Cena.

Abaixo está um diagrama que ilustra este fluxo de processo e mostra exemplos de duas aplicações que interagem com o tempo de execução do Cometo de Cena.

Diagrama de processo

Do lado esquerdo está um diagrama do tempo de funcionamento da realidade mista, que está sempre ligado e a funcionar no seu próprio processo. Este tempo de execução é responsável pela realização de rastreio de dispositivos, mapeamento espacial e outras operações que a Scene Understanding usa para entender e raciocinar sobre o mundo que o rodeia. No lado direito do diagrama, mostramos duas aplicações teóricas que fazem uso da Compreensão de Cena. A primeira aplicação interage com o MRTK , que utiliza o Scene Understanding SDK internamente, a segunda aplicação calcula e utiliza duas instâncias de cena separadas. Todas as três Cenas deste diagrama geram casos distintos das cenas, o condutor não está a seguir o estado global que é partilhado entre aplicações e Objetos de Cena numa cena não são encontrados noutra. A Compreensão de Cena fornece um mecanismo para rastrear ao longo do tempo, mas isso é feito usando o SDK. O código de rastreio já está a ser feito no SDK no processo da sua aplicação.

Uma vez que cada Cena armazena os seus dados no espaço de memória da sua aplicação, pode assumir que todas as funções do objeto Cena ou os seus dados internos são sempre executados no processo da sua aplicação.

Layout

Para trabalhar com a Compreensão de Cena, pode ser valioso saber e entender como o tempo de execução representa componentes logicamente e fisicamente. O Cenário representa dados com um layout específico que foi escolhido para ser simples, mantendo uma estrutura subjacente que é flexível para satisfazer os requisitos futuros sem precisar de grandes revisões. A Cena faz isso armazenando todos os Componentes (blocos de construção para todos os Objetos de Cena) numa lista plana e definindo a hierarquia e composição através de referências onde componentes específicos referenciam outros.

Abaixo apresentamos um exemplo de uma estrutura na sua forma plana e lógica.

Layout lógicoLayout Físico
    Cena
    • 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

Esta ilustração destaca a diferença entre o layout físico e lógico da Cena. À esquerda, vemos o layout hierárquico dos dados que a sua aplicação vê ao enumerar a cena. À direita, vemos que a cena é composta por 12 componentes distintos que são acessíveis individualmente, se necessário. Ao processar uma nova cena, esperamos que as aplicações andem nesta hierarquia logicamente, no entanto, ao rastrear entre atualizações de cena, algumas aplicações só podem estar interessadas em direcionar componentes específicos que são partilhados entre duas cenas.

Descrição geral da API

A secção seguinte fornece uma visão geral de alto nível das construções em Compreensão de Cena. A leitura desta secção irá dar-lhe uma compreensão de como as cenas são representadas e para que os vários componentes fazem/são usados. A próxima secção fornecerá exemplos de código concretos e detalhes adicionais que são ensombrados nesta visão geral.

Todos os tipos descritos abaixo residem no espaço de Microsoft.MixedReality.SceneUnderstanding nomes.

CenaComponentes

Agora que compreende o layout lógico das cenas, podemos apresentar o conceito de SceneComponents e como são usados para compor a hierarquia. SceneComponents são as decomposições mais granulares em SceneUnderstanding representando uma única coisa de núcleo, por exemplo, uma malha ou um quad ou uma caixa de delimitação. SceneComponents são coisas que podem atualizar de forma independente e podem ser referenciadas por outros SceneComponents, daí terem uma única propriedade global, um ID único, que permitem este tipo de mecanismo de rastreio/referenciação. Os IDs são usados para a composição lógica da hierarquia da cena, bem como para a persistência de objetos (o ato de atualizar uma cena em relação a outra).

Se está a tratar cada cena recém-calculada como sendo distinta, e simplesmente enumerando todos os dados dentro dela, então as IDs são em grande parte transparentes para si. No entanto, se planeia rastrear componentes ao longo de várias atualizações, utilizará os IDs para indexar e encontrar SceneComponents entre objetos de cena.

CenaObjects

A SceneObject é um SceneComponent que representa um exemplo de uma "coisa" por exemplo, uma parede, um chão, um teto, etc.... expressa pela sua propriedade Kind. Os CenárioObjects são geométricos e, portanto, têm funções e propriedades que representam a sua localização no espaço, no entanto não contêm nenhuma estrutura geométrica ou lógica. Em vez disso, o SceneObjects refere-se a outros SceneComponents, especificamente SceneQuads, e SceneMeshes, que fornecem as mais variadas representações que são suportadas pelo sistema. Quando uma nova cena é calculada, a sua aplicação provavelmente irá enumerar os SceneObjects da Cena para processar o que está interessado.

SceneObjects pode ter qualquer um dos seguintes:

SceneObjectKind Description
FundoO SceneObject é conhecido por não ser um dos outros tipos reconhecidos de objeto de cena. Esta classe não deve ser confundida com Desconhecido onde o fundo é conhecido por não ser parede/chão/teto etc.... embora desconhecido ainda não é categorizado.
MuroUma parede física. Presume-se que as paredes são estruturas ambientais inamovíveis.
FloorOs pisos são quaisquer superfícies em que se pode andar. Nota: escadas não são pisos. Note-se também que os pisos assumem qualquer superfície ambulante e, portanto, não há nenhuma suposição explícita de um piso singular. Estruturas de vários níveis, rampas, etc.... todos devem classificar como piso.
CeilingA superfície superior de uma sala.
PlataformaUma grande superfície plana sobre a qual você poderia colocar hologramas. Estes tendem a representar mesas, bancadas e outras grandes superfícies horizontais.
InternacionalUm rótulo reservado para dados geométricos que é agnóstico à rotulagem. A malha gerada pela definição da bandeira de atualização EnableWorldMesh seria classificada como mundo.
DesconhecidoEste objeto da cena ainda não foi classificado e atribuído a um tipo. Isto não deve ser confundido com Background, já que este objeto pode ser qualquer coisa, o sistema só não tem uma classificação suficientemente forte para ele ainda.

SceneMesh

A SceneMesh é um SceneComponent que se aproxima da geometria de objetos geométricos arbitrários usando uma lista de triângulos. As SceneMeshes são utilizadas em vários contextos diferentes; podem representar componentes da estrutura celular estanque ou como o WorldMesh, que representa a malha de mapeamento espacial sem limites associada à Cena. Os dados indexados e vértices fornecidos com cada malha utilizam o mesmo layout familiar que os tampões do vértice e do índice que são utilizados para renderizar malhas triangulares em todas as APIs de renderização moderna. No "Compreender a Cena", as malhas utilizam índices de 32 bits e podem ter de ser divididas em pedaços para determinados motores de renderização.

Sistemas de Ordem Sinuosa e De Coordenação

Espera-se que todas as malhas produzidas pela Scene Understanding devolvam as malhas num sistema de coordenadas Right-Handed utilizando a ordem de enrolamento no sentido horário.

Nota: O SO constrói antes de .191105 pode ter um inseto conhecido onde as malhas "World" estavam a regressar Counter-Clockwise ordem de enrolamento, que foi posteriormente corrigida.

SceneQuad

A SceneQuad é um SceneComponent que representa superfícies 2D que ocupam o mundo 3D. Os SceneQuads podem ser usados da mesma forma que arKit ARPlaneAnchor ou ARCore Planes, mas oferecem uma funcionalidade de alto nível como telas 2d para serem usadas por apps planas, ou APIs específicos UX. 2D são fornecidos para quads que tornam a colocação e layout simples de usar, e o desenvolvimento (com exceção de renderização) com quads deve sentir-se mais semelhante a trabalhar com telas 2d do que 3 malhas.

Forma SceneQuad

Os SceneQuads definem uma superfície retangular delimitada em 2d. No entanto, os SceneQuads representam superfícies com formas arbitrárias e potencialmente complexas (por exemplo, uma mesa em forma de donut.) Para representar a forma complexa da superfície de um quad pode utilizar a API GetSurfaceMask para tornar a forma da superfície num tampão de imagem que fornece. Se o SceneObject que tem o quad também tem uma malha, os triângulos de malha devem ser equivalentes a esta imagem renderizada, ambos representam uma geometria real da superfície, quer em coordenadas 2d quer 3d.

Detalhes e referência sdk de compreensão de cena

Nota

Ao utilizar o MRTK, note que estará a interagir com o MRTK ['WindowsSceneUnderstandingObserver'](xref:Microsoft.MixedReality.Toolkit.WindowsSceneUnderstanding.Experimental.WindowsSceneUnderstandingObserver) e assim poderá saltar esta secção na maioria das circunstâncias. Consulte os docs [MRTK Scene Understanding)(/windows/mixed-reality/mrtk-unitity/features/spatial-awareness/scene-understanding) para obter mais informações.

A secção seguinte irá ajudá-lo a conhecer o básico de SceneUnderstanding. Esta secção deve fornecer-lhe o básico, altura em que deve ter contexto suficiente para navegar através das aplicações da amostra para ver como o SceneUnderstanding é usado de forma holisticamente.

Inicialização

O primeiro passo para trabalhar com o SceneUnderstanding é que a sua aplicação ganhe referência a um objeto de Cena. Isto pode ser feito de uma de duas maneiras, uma Cena pode ser calculada pelo condutor, ou uma Cena existente que foi calculada no passado pode ser des serializada. Este último é útil para trabalhar com o SceneUnderstanding durante o desenvolvimento, onde aplicações e experiências podem ser protótipos rapidamente sem um dispositivo de realidade mista.

As cenas são calculadas usando um SceneObserver. Antes de criar um Scene, a sua aplicação deve consultar o seu dispositivo para garantir que suporta o SceneUnderstanding, bem como para solicitar o acesso do utilizador para informações de que o SceneUnderstanding necessita.

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

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

Se o RequestAccessAsync não for chamado, a computação de um novo Scene falhará. Em seguida, vamos calcular uma nova cena que está enraizada em torno dos auscultadores de Realidade Mista e tem um raio de 10 metros.

// 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();

Inicialização a partir de Dados (também conhecido como. O Caminho do PC)

Embora as Cenas possam ser calculadas para consumo direto, também podem ser calculadas em formato serializado para posterior utilização. Isto provou ser útil para o desenvolvimento, pois permite que os desenvolvedores trabalhem e testem a Compreensão de Cena sem a necessidade de um dispositivo. O ato de serializar uma cena é quase idêntico à computação, os dados são devolvidos à sua aplicação em vez de serem desseeriados localmente pelo SDK. Em seguida, pode deserializá-lo por si mesmo ou guardá-lo para uso futuro.

// 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

Enumeração sceneObject

Agora que a sua aplicação tem uma cena, a sua aplicação vai estar a olhar e a interagir com a SceneObjects. Isto é feito acessando a propriedade SceneObjects:

SceneObject firstFloor = null;

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

Componentes de atualização e refinação de componentes

Há outra função que recupera componentes na cena chamada FindComponent. Esta função é útil ao atualizar objetos de rastreio e encontrá-los em cenas posteriores. O seguinte código irá calcular uma nova cena em relação a uma cena anterior e, em seguida, encontrar o chão na nova cena.

// 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
}

Acesso a Malhas e Quads de Objetos de Cena

Uma vez descobertos os SceneObjects, a sua aplicação irá provavelmente querer aceder aos dados que estão contidos nos quads/malhas de que é composta. Estes dados são acedidos com as propriedades Quads e Meshes. O seguinte código irá enumerar todos os quads e malhas do nosso objeto de chão.


// 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
}

Note que é o SceneObject que tem a transformação que é relativa à origem da Cena. Isto porque o SceneObject representa um exemplo de uma "coisa" e é localizado no espaço, os quads e as malhas representam geometria que se transforma em relação aos seus pais. É possível que cenas separadas Consultes refiram o mesmo SceneMesh/SceneQuad SceneComponents, e também é possível que um SceneObject tenha mais do que um SceneMesh/SceneQuad.

Lidar com Transformações

A Cena Understanding fez uma tentativa deliberada de alinhar-se com as representações tradicionais da cena 3D ao lidar com transformações. Cada Cena está, portanto, confinada a um sistema de coordenadas única, tal como as representações ambientais 3D mais comuns. Os SceneObjects fornecem cada um a sua localização em relação ao sistema de coordenadas. Se a sua aplicação estiver a lidar com Cenas que esticam o limite do que uma única origem fornece, pode ancorar SceneObjects a SpatialAnchors, ou gerar várias cenas e fundi-las juntas, mas para a simplicidade assumimos que cenas estanques existem na sua própria origem que é localizada por um NodeId definido por Scene.OriginSpatialGraphNodeId.

O seguinte código de unidade, por exemplo, mostra como usar Windows APIs de Perceção e Unidade para alinhar sistemas de coordenadas em conjunto. Consulte o SpatialCoordinateSystem e o SpatialGraphInteropPreview para obter detalhes sobre as APIs de perceção Windows e objetos nativos da Realidade Mista em Unidade para obter detalhes sobre a obtenção de um Sistema EspacialCoordinate que corresponda à origem mundial da Unidade.

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;
}

Cada SceneObject um tem uma transformação, que é então aplicada a esse objeto. Na Unidade convertemo-nos em coordenadas destros e atribuímos transformações locais como:

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

Os quads foram concebidos para ajudar cenários de colocação 2D e devem ser considerados como extensões a elementos UX de tela 2D. Enquanto os Quads são componentes de SceneObjects e podem ser renderizados em 3D, as próprias APIs quad assumem que os Quads são estruturas 2D. Eles oferecem informações como extensão, forma e fornecer APIs para colocação.

Os quads têm extensões retangulares, mas representam superfícies 2D em forma arbitrária. Para permitir a colocação nestas superfícies 2D que interagem com os quads ambiente 3D oferecem utilitários para tornar esta interação possível. Atualmente, a Apreensão de Cena fornece duas funções, FindCentermostPlacement e GetSurfaceMask. FindCentermostPlacement é uma API de alto nível que localiza uma posição no quad onde um objeto pode ser colocado e tentará encontrar a melhor localização para o seu objeto garantindo que a caixa de delimitação que você fornece permanecerá na superfície subjacente.

Nota

As coordenadas da saída são relativas ao quad em "espaço quad" com o canto superior esquerdo sendo (x = 0, y = 0), tal como seria com outros tipos de rect janelas. Tenha em conta isto ao trabalhar com as origens dos seus próprios objetos.

O exemplo a seguir mostra como encontrar o local mais central e ancorar um holograma ao quad.

// 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)
            }
        }
    }
}

Os passos 1-4 são altamente dependentes do seu enquadramento/implementação particular, mas os temas devem ser semelhantes. É importante notar que o Quad simplesmente representa um avião 2D delimitado que está localizado no espaço. Ao ter o seu motor/estrutura saber onde está o quad e enraizando os seus objetos em relação ao quad, os seus hologramas serão localizados corretamente em relação ao mundo real.

Malha

As malhas representam representações geométricas de objetos ou ambientes. Tal como o mapeamento espacial,o índice de malha e os dados do vértice fornecidos com cada malha de superfície espacial utiliza o mesmo layout familiar que os tampões do vértice e do índice que são usados para renderizar malhas de triângulo em todas as APIs de renderização moderna. As posições vértice são fornecidas no sistema de coordenadas do Scene . As APIs específicas utilizadas para referenciar estes dados são as seguintes:

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

O seguinte código fornece um exemplo de geração de uma lista de triângulos a partir da estrutura da malha:

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

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

Os amortecedores index/vértice devem ser > = o índice/vértice conta, mas de outra forma pode ser arbitrariamente dimensionado permitindo uma reutilização eficiente da memória.

ColliderMesh

Os objetos de cena fornecem acesso a dados de malha e malha de colisão através das propriedades de Meshes e ColliderMeshes. Estas malhas sempre corresponderão, o que significa que o índice i'th da propriedade Meshes representa a mesma geometria que o i'th index da propriedade ColliderMeshes. Se o tempo de execução/objeto suporta malhas de colisor, é garantido que obtém o polígono mais baixo, a aproximação de ordem mais alta e é uma boa prática usar ColliderMeshes onde quer que a sua aplicação utilize colisões. Se o sistema não suportar colisões, o objeto de malha devolvido no ColliderMeshes será o mesmo objeto que a malha reduzindo as restrições de memória.

Desenvolvimento com compreensão de cena

Neste ponto, deve entender os blocos de construção da cena entendendo o tempo de execução e SDK. A maior parte do poder e complexidade reside nos padrões de acesso, na interação com quadros 3D, e ferramentas que podem ser escritas em cima destas APIs para fazer tarefas mais avançadas como planeamento espacial, análise de salas, navegação, física, e assim por diante. Esperamos capturá-las em amostras que deverão guiá-lo na direção adequada para que os seus cenários brilhem. Se houver amostras ou cenários que não estamos a abordar, avise-nos e tentaremos documentar/protótipo o que precisa.

Onde posso obter o código de amostra?

O código de amostra de compreensão da cena para unidade pode ser encontrado na nossa página de página de amostra de unidade. Esta aplicação permitir-lhe-á comunicar com o seu dispositivo e tornar os vários objetos de cena, ou, permitir-lhe-á carregar uma cena serializada no seu PC e permitir-lhe experimentar a Cena Compreensão sem um dispositivo.

Onde posso arranjar cenas de amostras?

Se tiver um HoloLens2, pode salvar qualquer cena que tenha capturado, guardando a saída de ComputeSerializedAsync para arquivar e dessemalizá-lo à sua conveniência.

Se não tens um dispositivo HoloLens2 mas queres jogar com o Scene Understanding, terás de descarregar uma cena pré-capturada. A amostra de Compreensão de Cena atualmente envia com cenas serializadas que podem ser descarregadas e usadas à sua própria conveniência. Pode encontrá-los aqui:

Cenas de compreensão de cena cenas

Ver também