Criar e editar âncoras de forma programática no Geospatial Creator no Unity

Este guia descreve como usar o Geospatial Creator para gravar scripts C# e realizar rapidamente tarefas comuns, como criar e mover objetos ARGeospatialCreatorAnchor no modo de edição do Unity. Isso pode ser útil para criar várias âncoras de uma lista predefinida, como uma planilha ou um arquivo KML.

O Geospatial Creator no Unity permite visualizar o conteúdo geoespacial no Unity Editor. Nosso Guia de início rápido apresenta o Geospatial Creator e ensina como criar sua primeira experiência de RA com geolocalização com programação mínima usando a interface do Editor do Unity. Para projetos mais avançados, é recomendável criar e manipular objetos Geospatial Creator de forma programática em vez de usar a interface do editor do Unity.

Neste guia, pressupo que você já conhece os conceitos básicos do Geospatial Creator apresentados no início rápido e que está pronto para começar a adicionar âncoras do Geospatial Creator a uma cena. Você precisa ativar e configurar o Geospatial Creator com suas chaves de API, além de objetos iniciais de sessão de RA na sua cena. Se você estiver começando do zero, siga o guia de início rápido e incluindo a seção "Ativar o Criador geoespacial" antes de continuar.

Primeiros passos

Neste exemplo, suponha que você tenha um conjunto de locais conhecidos em torno da Prefeitura em São Paulo, na Califórnia, nos EUA, onde quer colocar conteúdo de RA. Você precisa criar objetos de âncora em cada um desses locais e anexar a geometria básica a essas âncoras.

Antes de criar âncoras, especifique um ARGeospatialCreatorOrigin, que é um ponto de referência para converter latitudes, longitudes e altitudes para e de coordenadas mundiais do Unity. A origem também vai conter um subcomponent CesiumGeoreference e um objeto filho Cesium3DTileset, o que permite que o Cesium renderize a área ao redor na visualização de cena do editor do Unity. Para isso, você precisa de uma chave da API Tiles do Google Maps, conforme descrito no Guia de início rápido.

Criar uma origem

A API para o Geospatial Creator inclui um método de fábrica para criar um ARGeospatialCreatorOrigin na cena e adicionar os componentes necessários do Cesium. O código abaixo cria a origem em uma latitude, longitude e altitude próximas e usa a chave da API Map Tiles:

ARGeospatialCreatorOrigin origin =
  GeospatialCreatorCesiumAdapter.CreateOriginWithCesiumGeoreference(
    37.77954, -122.417581, 0.0, "<MAP_TILES_KEY>");

Por padrão, esse objeto é colocado em (0, 0, 0) nas coordenadas do mundo do Unity, o que funciona bem para este exemplo.

Acessar a referência ARAnchorManager

Um ARAnchorManager é necessário para resolver âncoras geoespaciais no momento da execução. Portanto, você também precisa de uma referência ao ARAnchorManager na cena. Se você começou com o aplicativo de exemplo geoespacial incluído nas extensões do ARCore, o gerenciador de âncoras é anexado ao GameObject "AR Session Origin". Supondo que você tenha exatamente um gerenciador de âncoras na cena, é possível acessar uma referência a ele desta forma:

ARAnchorManager anchorManager =
    Resources.FindObjectsOfTypeAll<ARAnchorManager>()[0];

Agora que você tem uma origem e um gerenciador de âncora, pode começar a criar os objetos ARGeospatialCreatorAnchor.

Criar âncoras de terreno

Considere a seguinte matriz bidimensional de valores double, que representa a latitude e a longitude precisas em três pontos no lado leste da Prefeitura de São Francisco, na Califórnia, EUA:

double[,] _cityHallEastPoints = {
    { 37.77936, -122.418617 }, // in front of city hall
    { 37.77965, -122.418680 }, // right of city hall
    { 37.77917, -122.418577 }}; // left of city hall

Suponha que você queira colocar um cubo de um metro em cada um desses locais, no nível do solo, no nosso aplicativo de RA. O código abaixo cria objetos ARGeospatialCreatorAnchor e atribui as propriedades aos valores apropriados:

for (int i = 0; i < _cityHallEastPoints.GetLength(0); i++)
{
  ARGeospatialCreatorAnchor anchor =
    new GameObject("City Hall " + i).AddComponent<ARGeospatialCreatorAnchor>();
  anchor.Origin = origin;
  anchor.AnchorManager = anchorManager;
  anchor.Latitude = _cityHallEastPoints[i, 0];
  anchor.Longitude = _cityHallEastPoints[i, 1];
  anchor.AltitudeType = AnchorAltitudeType.Terrain;

  GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
  cube.transform.parent = anchor.transform;
}

Isso cria âncoras de terreno em cada ponto. O Criador geoespacial coloca automaticamente as âncoras nas coordenadas mundiais adequadas do Unity, calculando a localização em relação ao objeto ARGeospatialCreatorOrigin. Para ajustar a altitude de uma âncora de terreno, defina a propriedade Altitude em metros acima ou abaixo da superfície do terreno.

No momento da execução, as âncoras de terreno serão resolvidas no nível do solo para o app em execução, com deslocamento pela propriedade Altitude. Na visualização de cena do editor, no entanto, elas são renderizadas em uma altitude WGS84 de 0 por padrão, não em relação à geometria do bloco 3D. Muitas vezes, esse não é o lugar que você quer que elas apareçam. Portanto, é possível substituir a altitude padrão da âncora na visualização de cena do editor definindo a propriedade UseEditorAltitudeOverride como true e especificando a altitude em metros WGS84 usando a propriedade EditorAltitudeOverride:

anchor.UseEditorAltitudeOverride = true;
anchor.EditorAltitudeOverride = -13.5; // WGS84 altitude at ground level for City Hall plaza

Essas duas propriedades não têm efeito fora do modo Editor e não são compiladas no app em execução.

Criar uma âncora no telhado

Para a próxima âncora, suponha que você queira colocar uma âncora no telhado da prefeitura. A âncora pode ser criada da mesma maneira, exceto que a propriedade AltitudeType é definida como AnchorAltitudeType.Rooftop:

ARGeospatialCreatorAnchor cityHallRoofAnchor =
  new GameObject("City Hall Roof").AddComponent<ARGeospatialCreatorAnchor>();
cityHallRoofAnchor.Origin = origin;
cityHallRoofAnchor.AnchorManager = anchorManager;
cityHallRoofAnchor.Latitude = 37.77959;
cityHallRoofAnchor.Longitude = -122.419006;
cityHallRoofAnchor.AltitudeType = AnchorAltitudeType.Rooftop;

GameObject roofCube = GameObject.CreatePrimitive(PrimitiveType.Cube);
roofCube.transform.parent = cityHallRoofAnchor.transform;

Assim como as âncoras de terreno, é possível ajustar a altitude de uma âncora de telhado na visualização de cena do Editor usando as propriedades UseEditorAltitudeOverride e EditorAltitudeOverride. Neste exemplo, a altitude WGS84 do telhado é de aproximadamente 10,7 metros.

Criar uma âncora em uma altitude específica

A âncora final será colocada no topo da cúpula da prefeitura. Para essa âncora, a altitude precisa é importante. Portanto, defina-a explicitamente usando uma âncora WGS84, em vez de uma âncora de terreno ou de telhado:

ARGeospatialCreatorAnchor cityHallDomeAnchor =
  new GameObject("City Hall Dome").AddComponent<ARGeospatialCreatorAnchor>();
cityHallDomeAnchor.Origin = origin;
cityHallDomeAnchor.AnchorManager = anchorManager;
cityHallDomeAnchor.Latitude = 37.77928;
cityHallDomeAnchor.Longitude = -122.419241;
cityHallDomeAnchor.AltitudeType = AnchorAltitudeType.WGS84;
cityHallDomeAnchor.Altitude = 73;

GameObject domeCube = GameObject.CreatePrimitive(PrimitiveType.Cube);
domeCube.transform.parent = cityHallDomeAnchor.transform;

Não é necessário usar a substituição de altitude somente para editores, porque a altitude já está especificada de acordo com o WGS84. Se a altura da geometria dos blocos de mapa no editor estiver incorreta em comparação com o mundo real, ainda será possível usar a substituição do editor para reposicionar a âncora na visualização de cena.