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

Este guia descreve como usar o Geospatial Creator para escrever 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 a partir de uma lista predefinida, como uma planilha ou um KML .

O Geospatial Creator no Unity permite visualizar o conteúdo Geospatial em Editor do Unity. Nosso Guia de início rápido apresenta o Geospatial Creator e ensina como criar sua primeira experiência de RA com tecnologia geoespacial com programação mínima usando a interface do Editor do Unity. Para projetos mais avançados, é recomendável criar e manipular objetos do jogo do 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. Ative o Geospatial Creator e configuradas com suas chaves de API, bem como objetos de sessão de RA iniciais no seu 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 Francisco, Califórnia, EUA, onde quer colocar conteúdo de RA. Você vai precisa criar objetos âncora em cada um desses locais e, em seguida, anexar geometria a essas âncoras.

Antes de poder criar âncoras, você deve especificar uma ARGeospatialCreatorOrigin, que é um ponto de referência para converter latitudes, longitudes e altitudes de e para as coordenadas mundiais do Unity. A origem também vai conter um subcomponente CesiumGeoreference e um Objeto filho Cesium3DTileset, que permite que o Cesium renderize o ambiente circundante na visualização Scene do editor do Unity. Para isso, você precisa de uma chave da API Tiles do Google Maps, conforme descrito no Programa de treinamento.

Observação :as APIs a seguir são destinadas ao uso no modo Editor ao projetar e visualizar suas experiências de RA usando o Geospatial Creator. A maioria das propriedades descritas são somente leitura ou não estão disponíveis no momento da execução. Para criar cenas de RA dinâmicas no momento da execução, recomendamos usar as APIs Geospatial do ARCore diretamente, em vez das APIs específicas do Geospatial Creator.

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 a seguir cria a origem em coordenadas de latitude, longitude e altitude e usando a chave da API Map Tiles fornecida:

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, 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 a seguir cria objetos ARGeospatialCreatorAnchor e atribui as propriedades deles aos valores adequados:

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 Geospatial Creator posiciona automaticamente as âncoras nas coordenadas mundiais adequadas do Unity, calculando a localização em relação ao objeto ARGeospatialCreatorOrigin. Para ajustar o altitude de uma âncora de terreno, defina a propriedade Altitude em metros acima ou abaixo da superfície do terreno.

No tempo de execução, as âncoras de terreno serão resolvidas no nível do solo para o aplicativo de corrida, compensado pela propriedade Altitude. No entanto, na visualização de cena do Editor, são renderizados a uma altitude WGS84 de 0 por padrão, não em relação ao bloco 3D geometria. Muitas vezes, esse não é o local em que você gostaria de vê-las. 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 compilados 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 nas âncoras no terreno, você pode ajustar a altitude de um telhado na visualização de cena do editor usando UseEditorAltitudeOverride e EditorAltitudeOverride propriedades. 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 esta âncora, a altitude precisa é importante, então você a definirá explicitamente pelo usando uma âncora WGS84 em vez de uma âncora no terreno ou no 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 o editor, já que a altitude é especificado de acordo com WGS84. Se a altura da geometria dos blocos do 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.