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

Este guia descreve como usar o Geospatial Creator para escrever scripts em C#. para 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 explica como criar seu primeiro Experiência de RA com programação geoespacial e mínima programação, usando o IU do editor. Para projetos mais avançados, talvez seja melhor criar e manipular GameObjects do Geospatial Creator de forma programática em vez de usar o Unity IU do editor.

Para usar este guia, é preciso ter familiaridade com os conceitos básicos do Geospatial Creator no Guia de início rápido, e você já pode começar a adicionar APIs Geospatial O criador fixa o conteúdo em 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 estiver começando do zero, siga o Guia de início rápido incluindo a página "Ativar registros Criador antes de continuar.

Primeiros passos

Para este exemplo, suponha que você tem um conjunto de locais conhecidos ao redor da Prefeitura em São Francisco, Califórnia, EUA, em que você quer inserir 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 um mapa do Google Chave da API Tiles conforme descrito no o guia de início rápido

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 descritos são somente leitura ou não estão disponíveis no momento da execução. Para criar cenas de RA dinâmicas durante a execução, recomendamos o uso da API Geospatial APIs diretamente em vez de APIs específicas do Geospatial Creator.

Criar uma origem

A API do Geospatial Creator inclui um método de fábrica para criar uma ARGeospatialCreatorOrigin no cenário e adicione 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 mundiais do Unity, 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 o aplicativo de amostra Geospatial incluído com as extensões do ARCore, o O gerenciador está anexado à "Origem da sessão de RA" GameObject. Supondo que você tenha exatamente um gerente de âncora em sua cena, você pode obter uma referência a ele como isso:

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

Agora que você tem uma origem e um gerenciador de âncora, comece a criar ARGeospatialCreatorAnchor.

Criar âncoras de terreno

Considere a seguinte matriz bidimensional de valores double, representando a latitude e longitude precisas em três pontos no lado leste de Prefeitura em São Francisco, 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 chão 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 automaticamente coloca as âncoras em coordenadas mundiais do Unity, calculando as 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. Geralmente, esse não é o local onde você gostaria de vê-los, então você pode substituir o altitude padrão da âncora na visualização de cena do editor definindo o 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 compilado no app em execução.

Criar uma âncora no telhado

Para nossa próxima âncora, suponha que você queira colocar uma âncora no telhado da Cidade Salão. A âncora pode ser criada exatamente da mesma maneira, exceto que a AltitudeType está 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. Para este exemplo, a altitude WGS84 do do telhado é de aproximadamente 10,7 metros.

Criar uma âncora em uma altitude específica

Nossa última âncora 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. É claro que, se a altura dos blocos de mapa geometria no editor ficou incorreta em comparação com o mundo real, você ainda pode usar a substituição do editor para reposicionar a âncora na cena visualização.