Sistemas de coordenadas no Unity

Windows Mixed Reality dá suporte a aplicativos em uma ampla variedade de escalas de experiência, desde aplicativos somente de orientação e escala de sedados até aplicativos de escala de sala. No HoloLens, você pode ir além e criar aplicativos de escala mundial que permitem que os usuários andem além de 5 metros, explorando um andar inteiro de um prédio e além.

Sua primeira etapa na criação de uma experiência de realidade misturada no Unity é entender os sistemas de coordenadas e escolher a escala de experiência que seu aplicativo terá como destino.

Criando uma experiência somente de orientação ou de escala de seada

Namespace:UnityEngine.XR
Type:XRDevice

Para criar uma experiência somente de orientação ou de escala de setada, você precisa definir o Unity como o tipo de espaço de acompanhamento estacionário. O espaço de acompanhamento estacionário define o sistema de coordenadas do mundo do Unity para acompanhar o quadro estacionário de referência. No modo de acompanhamento estacionário, o conteúdo colocado no editor logo na frente do local padrão da câmera (forward é -Z) aparecerá na frente do usuário quando o aplicativo for lançado.

XRDevice.SetTrackingSpaceType(TrackingSpaceType.Stationary);

Namespace:UnityEngine.XR
Type:InputTracking

Para uma experiência pura somente de orientação, como um visualizador de vídeo de 360 graus (em que as atualizações posicionais de cabeça destruiriam a ilusão), você pode definir XR. InputTracking.disablePositionalTracking como true:

InputTracking.disablePositionalTracking = true;

Para uma experiência de escala de sated, para permitir que o usuário, posteriormente, a origem do seado seja mais recente, você pode chamar o XR. Método InputTracking.Recenter :

InputTracking.Recenter();

Criação de uma experiência de escala permanente ou de escala de sala

Namespace:UnityEngine.XR
Type:XRDevice

Para uma experiência de escala permanente ou de escala de sala, você precisará colocar o conteúdo em relação ao chão. Você explica o andar do usuário usando o estágio espacial, que representa a origem definida no nível do piso do usuário e o limite de sala opcional, configurada durante a primeira executar.

Para garantir que o Unity está operando com seu sistema de coordenadas mundial no nível do chão, você pode definir e testar se o Unity está usando o tipo de espaço de acompanhamento RoomScale:

if (XRDevice.SetTrackingSpaceType(TrackingSpaceType.RoomScale))
{
    // RoomScale mode was set successfully.  App can now assume that y=0 in Unity world coordinate represents the floor.
}
else
{
    // RoomScale mode was not set successfully.  App cannot make assumptions about where the floor plane is.
}
  • Se SetTrackingSpaceType retornar true, o Unity alterna com êxito seu sistema de coordenadas mundial para acompanhar o quadro de estágio de referência.
  • Se SetTrackingSpaceType retornar false, o Unity não poderá alternar para o quadro de estágio de referência, provavelmente porque o usuário não tiver definido um andar em seu ambiente. Embora um valor de retorno falso não seja comum, isso pode acontecer se o estágio estiver definido em uma sala diferente e o dispositivo for movido para a sala atual sem que o usuário configurar um novo estágio.

Depois que o aplicativo define com êxito o tipo de espaço de acompanhamento RoomScale, o conteúdo colocado no plano y=0 será exibido no chão. A origem em 0, 0, 0 será o local específico no chão em que o usuário se juntou durante a instalação da sala, com -Z representando a direção para frente que ele estava enfrentando durante a instalação.

Namespace:UnityEngine.Experimental.XR
Type:Boundary

No código de script, você pode chamar o método TryGetGeometry no tipo UnityEngine.Experimental.XR.Boundary para obter um polígono de limite, especificando um tipo de limite de TrackedArea. Se o usuário definiu um limite (você obter de volta uma lista de vértices), é seguro fornecer uma experiência de escala de sala para o usuário, em que ele pode dar uma olhada na cena que você cria.

Observação

O sistema renderizará automaticamente o limite quando o usuário se aproximar dele. Seu aplicativo não precisa usar esse polígono para renderizar o limite em si. No entanto, você pode optar por estabelecer seus objetos de cena usando esse polígono de limite, para garantir que o usuário possa alcançar fisicamente esses objetos sem fazer alarde:

var vertices = new List<Vector3>();
if (UnityEngine.Experimental.XR.Boundary.TryGetGeometry(vertices, Boundary.Type.TrackedArea))
{
    // Lay out your app's content within the boundary polygon, to ensure that users can reach it without teleporting.
}

Criando uma experiência de escala mundial

Namespace:UnityEngine.XR.WSA
Type:WorldAnchor

Para experiências reais de escala mundial HoloLens que permitem que os usuários andem além de 5 metros, você precisará de novas técnicas além daquelas usadas para experiências em escala de espaço. Uma técnica importante que você usará é criar uma âncora espacial para bloquear um cluster de hologramas precisamente no lugar no mundo físico, independentemente da distância em que o usuário fez roaming e, em seguida, encontrar esses hologramas novamente em sessões posteriores.

No Unity, você cria uma âncora espacial adicionando o componente WorldAnchor Unity a um GameObject.

Adicionando uma âncora mundial

Para adicionar uma âncora mundial, chame AddComponentWorldAnchor<>() no objeto do jogo com a transformação que você deseja ancorar no mundo real.

WorldAnchor anchor = gameObject.AddComponent<WorldAnchor>();

Pronto! Esse objeto de jogo agora será ancorado em seu local atual no mundo físico – você pode ver suas coordenadas do mundo do Unity se ajustarem ligeiramente ao longo do tempo para garantir esse alinhamento físico. Use persistência para localizar esse local ancorado novamente em uma sessão futura do aplicativo.

Removendo uma âncora mundial

Se você não quiser mais que o GameObject seja bloqueado em um local do mundo físico e não pretenda movimentação desse quadro, basta chamar Destruir no componente Âncora Mundial.

Destroy(gameObject.GetComponent<WorldAnchor>());

Se você quiser mover o GameObject neste quadro, precisará chamar DestroyImmediate em vez disso.

DestroyImmediate(gameObject.GetComponent<WorldAnchor>());

Movendo um GameObject ancorado mundial

GameObject não pode ser movido enquanto uma Âncora Mundial está nele. Se você precisar mover o GameObject neste quadro, precisará:

  1. DestroyImmediate o componente World Anchor
  2. Mover o GameObject
  3. Adicione um novo componente de Âncora Mundial ao GameObject.
DestroyImmediate(gameObject.GetComponent<WorldAnchor>());
gameObject.transform.position = new Vector3(0, 0, 2);
WorldAnchor anchor = gameObject.AddComponent<WorldAnchor>();

Manipulando alterações de capacidade de locatabilidade

Um WorldAnchor pode não ser localizado no mundo físico em um ponto no tempo. Se isso ocorrer, o Unity não atualizará a transformação do objeto ancorado. Isso também pode mudar enquanto um aplicativo está em execução. A falha ao lidar com a alteração na capacidade de locatabilidade fará com que o objeto não apareça no local físico correto no mundo.

Para ser notificado sobre alterações de capacidade de locatabilidade:

  1. Assinar o evento OnTrackingChanged
  2. Manipular o evento

O evento OnTrackingChanged será chamado sempre que a âncora espacial subjacente mudar entre um estado de ser localizado versus não ser localizado.

anchor.OnTrackingChanged += Anchor_OnTrackingChanged;

Em seguida, manipular o evento:

private void Anchor_OnTrackingChanged(WorldAnchor self, bool located)
{
    // This simply activates/deactivates this object and all children when tracking changes
    self.gameObject.SetActiveRecursively(located);
}

Às vezes, as âncoras são localizadas imediatamente. Nesse caso, essa propriedade isLocated da âncora será definida como true quando AddComponentWorldAnchor<>() retornar. Como resultado, o evento OnTrackingChanged não será disparado. Um padrão limpo seria chamar o manipulador OnTrackingChanged com o estado IsLocated inicial depois de anexar uma âncora.

Anchor_OnTrackingChanged(anchor, anchor.isLocated);

Compartilhando âncoras entre dispositivos

Use Âncoras Espaciais do Azure para criar uma âncora de nuvem durável de um WorldAnchor local, que seu aplicativo pode localizar em vários HoloLens, iOS e Android. Ao compartilhar uma âncora espacial comum entre vários dispositivos, cada usuário pode ver o conteúdo renderizado em relação a essa âncora no mesmo local físico. Isso permite experiências compartilhadas em tempo real.

Para começar a criar experiências compartilhadas no Unity, experimente os inícios rápidos do Unity das Âncoras Espaciais do Azure de 5 minutos.

Quando estiver em execução com as Âncoras Espaciais do Azure, você poderá criar e localizar âncoras no Unity.

Próximo ponto de verificação de desenvolvimento

Se você estiver seguindo o percurso do ponto de verificação de desenvolvimento do Unity que lançamos, você está no meio de explorar os Realidade Misturada principais blocos de construção. Deste ponto, você pode prosseguir para o próximo bloco de construção:

Ou vá diretamente para as funcionalidades e APIs da plataforma de Realidade Misturada:

Você sempre pode voltar para os pontos de verificação de desenvolvimento do Unity a qualquer momento.

Consulte Também