Lightship VPSを触る

using Niantic.ARDK.Configuration;

// Set the user id associated with the current user.
ArdkGlobalConfig.SetUserIdOnLogin(your_generated_user_ID);

...
private void OnEnable()
{
  ARSessionFactory.SessionInitialized += HandleSessionInitialized;
}

private void OnDisable()
{
  ARSessionFactory.SessionInitialized -= HandleSessionInitialized;
}
...
private void HandleSessionInitialized(AnyARSessionInitializedArgs args)
{
  _statusLog.text = "Session initialized";
  _arSession = args.Session;
  _arSession.Ran += HandleSessionRan;
}

private void HandleSessionRan(ARSessionRanArgs args)
{
  _arSession.Ran -= HandleSessionRan;
  WayspotAnchorService = CreateWayspotAnchorService();
  WayspotAnchorService.LocalizationStateUpdated += OnLocalizationStateUpdated;
  _statusLog.text = "Session running";
}
...

using System;
using System.Collections;
using System.Collections.Generic;
using Niantic.ARDK.AR;
using Niantic.ARDK.AR.ARSessionEventArgs;
using Niantic.ARDK.AR.WayspotAnchors;
using Niantic.ARDK.LocationService;
using UnityEngine;

public class WayspotAnchorManager : MonoBehaviour
{
    private static readonly float desiredAccuracyInMeters = 0.01f;
    private static readonly float updateDistanceInMeters = 0.01f;

    private IARSession _arSession;
    private WayspotAnchorService _wayspotAnchorService;
    private bool _isLocalized;

    private void OnEnable()
    {
        ARSessionFactory.SessionInitialized += HandleSessionInitialized;
    }

    private void OnDisable()
    {
        ARSessionFactory.SessionInitialized -= HandleSessionInitialized;
    }

    private void HandleSessionInitialized(AnyARSessionInitializedArgs args)
    {
        _arSession = args.Session;
        _arSession.Ran += HandleSessionRan;
    }

    private void HandleSessionRan(ARSessionRanArgs args)
    {
        var wayspotAnchorsConfiguration = WayspotAnchorsConfigurationFactory.Create();
        var locationService = LocationServiceFactory.Create(_arSession.RuntimeEnvironment);
        locationService.Start(desiredAccuracyInMeters, updateDistanceInMeters);
        _wayspotAnchorService = new WayspotAnchorService(_arSession, locationService, wayspotAnchorsConfiguration);

        _wayspotAnchorService.LocalizationStateUpdated += LocalizationStateUpdated;
    }

    private void LocalizationStateUpdated(LocalizationStateUpdatedArgs args)
    {
        if (LocalizationState.Localized.Equals(args.State) && !_isLocalized)
        {
            _isLocalized = true;
            // ToDo: Create anchor?
	    }
    }
}

using Niantic.ARDK.Extensions;
using Niantic.ARDK.AR.WayspotAnchors;

private GameObject CreateWayspotAnchorGameObject(IWayspotAnchor anchor, Vector3 position, Quaternion rotation, bool startActive)
{
  var go = Instantiate(_anchorPrefab, position, rotation);

  var tracker = go.GetComponent<WayspotAnchorTracker>();
  if (tracker == null)
  {
    Debug.Log("Anchor prefab was missing WayspotAnchorTracker, so one will be added.");
    tracker = go.AddComponent<WayspotAnchorTracker>();
  }

  tracker.gameObject.SetActive(startActive);
  tracker.AttachAnchor(anchor);
  // ...Add to a local cache of WayspotAnchorTrackers if needed...

  return go;
}

[SerializeField] private GameObject _anchorPrefab;
...
private void LocalizationStateUpdated(LocalizationStateUpdatedArgs args)
{
    if (LocalizationState.Localized.Equals(args.State) && !_isLocalized)
    {
        _isLocalized = true;
        PlaceAnchor(Matrix4x4.zero);
    }
}

private void PlaceAnchor(Matrix4x4 localPose)
{
    var anchors = _wayspotAnchorService.CreateWayspotAnchors(localPose);
    if (anchors.Length == 0)
    {
        return; // error raised in CreateWayspotAnchors
    }

    CreateWayspotAnchorGameObject(
        anchors[0],
        localPose.ToPosition(),
        localPose.ToRotation(),
        true);
}

private GameObject CreateWayspotAnchorGameObject
(
    IWayspotAnchor anchor,
    Vector3 position,
    Quaternion rotation,
    bool startActive
)
{
    var go = Instantiate(_anchorPrefab, position, rotation);

    var tracker = go.GetComponent<WayspotAnchorTracker>();
    if (tracker == null)
    {
        tracker = go.AddComponent<WayspotAnchorTracker>();
    }

    tracker.gameObject.SetActive(startActive);
    tracker.AttachAnchor(anchor);

    return go;
}

{
  "AnchorPayload": "*********",
  "AnchorName": "*********",
  "NodeIdentifier": "*********",
  "LocalizationTargetName": "Private Mesh - *********"
}

[Header("Origin")]
[SerializeField] private string _payload;

...

private void LoadOriginAnchor()
{
    var payload = WayspotAnchorPayload.Deserialize(_payload);
    if (payload == null)
    {
        return; 
    }

    var anchors = _wayspotAnchorService.RestoreWayspotAnchors(payload);
    if (anchors.Length == 0)
    {
        return;
    }

    var anchor = CreateWayspotAnchorGameObject(
        anchors[0],
        Vector3.zero,
        Quaternion.identity,
        true);
}

struct LocationInfo {
    // fields

    readonly double Altitude;
    readonly LatLng Coordinates;
    readonly double HorizontalAccuracy;
    readonly double Timestamp;
    readonly double VerticalAccuracy;

    // methods

    bool Equals(LocationInfo other);
    override bool Equals(object obj);
    override int GetHashCode();

    LocationInfo(
        double latitude,
        double longitude,
        double altitude = double.NaN,
        double horizontalAccuracy = double.NaN,
        double verticalAccuracy = double.NaN,
        double timestamp = double.NaN
    );

    LocationInfo(LatLng coordinates);
    LocationInfo(UnityEngine.LocationInfo info);
    override string ToString();
    static bool operator != (LocationInfo l1, LocationInfo l2);
    static bool operator == (LocationInfo l1, LocationInfo l2);
};

using Niantic.ARDK.LocationService;

private ILocationService _locationService;

// Default is the Ferry Building in San Francisco
private LatLng _spoofLocation = new LatLng(37.79531921750984, -122.39360429639748);

// Start is called before the first frame update
void Awake()
{

    // ...

    _locationService = LocationServiceFactory.Create();

#if UNITY_EDITOR
    var spoofService = (SpoofLocationService) _locationService;

    // In editor, the specified spoof location will be used.
    spoofService.SetLocation(_spoofLocation);
#endif

    _locationService.LocationUpdated += OnLocationUpdated;
    _locationService.Start();
}

using Niantic.ARDK;
using Niantic.ARDK.VPSCoverage;
using Niantic.ARDK.VirtualStudio.VpsCoverage;

private RuntimeEnvironment _coverageClientRuntime = RuntimeEnvironment.Default;
private ICoverageClient _coverageClient;
private VpsCoverageResponses _mockResponses;

void Awake()
{

    // ...

    // The mockResponses object is a ScriptableObject containing the data that a Mock
    // implementation of the ICoverageClient will return. This is a required argument for using
    // the mock client on a mobile device. It is optional in the Unity Editor; the mock client
    // will simply use the data provided in the ARDK/VirtualStudio/VpsCoverage/VPS Coverage Responses.asset file.
    _coverageClient = CoverageClientFactory.Create(_coverageClientRuntime, _mockResponses);

    // ...
}

public class VPSCoverageManager : MonoBehaviour
{
    [SerializeField]
    private LatLng _spoofLocation = new LatLng(37.79531921750984, -122.39360429639748);

    [SerializeField]
    private RuntimeEnvironment _coverageClientRuntime = RuntimeEnvironment.Default;

    [SerializeField]
    private VpsCoverageResponses _mockResponses;

    [SerializeField]
    [Range(0, 2000)]
    private int _queryRadius = 250;

    private ILocationService _locationService;
    private ICoverageClient _coverageClient;

    private void Awake()
    {
        _locationService = LocationServiceFactory.Create();
        Debug.Log("LocationService create.");

        _coverageClient = CoverageClientFactory.Create(_coverageClientRuntime, _mockResponses);

#if UNITY_EDITOR
        var spoofService = (SpoofLocationService)_locationService;
        spoofService.SetLocation(_spoofLocation);
#endif

        _locationService.LocationUpdated += OnLocationUpdated;
        _locationService.Start();
        Debug.Log("LocationService start.");
    }

    private void OnLocationUpdated(LocationUpdatedArgs args)
    {
        Debug.Log("OnLocationUpdated.");

        _locationService.LocationUpdated -= OnLocationUpdated;
        _coverageClient.RequestCoverageAreas(args.LocationInfo, _queryRadius, ProcessAreasResult);
    }

    private void ProcessAreasResult(CoverageAreasResult result)
    {
        Debug.Log("ProcessAreasResult.");

        if (result.Status != ResponseStatus.Success)
        {
            return;
        }

        foreach (var area in result.Areas)
        {
            Debug.Log(
		        "--------------\n" +
		        $"LocalizationTargetIdentifiers : {string.Join(", ", area.LocalizationTargetIdentifiers)}\n" +
                $"LocalizabilityQuality : {area.LocalizabilityQuality}\n" +
                $"Centroid : {area.Centroid}"
		    );
        }
    }
}

public class VPSCoverageManager : MonoBehaviour
{
...
    [SerializeField]
    private RawImage _targetImage;
...
 private void ProcessAreasResult(CoverageAreasResult result)
    {
        Debug.Log("ProcessAreasResult.");

        if (result.Status != ResponseStatus.Success)
        {
            return;
        }

        var allTargets = new List<string>();
        foreach (var area in result.Areas)
        {
            Debug.Log(
                "--------------\n" +
                $"LocalizationTargetIdentifiers : {string.Join(", ", area.LocalizationTargetIdentifiers)}\n" +
                $"LocalizabilityQuality : {area.LocalizabilityQuality}\n" +
                $"Centroid : {area.Centroid}"
            );

            allTargets.AddRange(area.LocalizationTargetIdentifiers);
        }

        _coverageClient.RequestLocalizationTargets(allTargets.ToArray(), ProcessTargetsResult);
    }

    private void ProcessTargetsResult(LocalizationTargetsResult result)
    {
        Debug.Log("ProcessTargetsResult.");

        if (result.Status != ResponseStatus.Success)
        {
            return;
        }

        if (result.ActivationTargets.Count > 0)
        {
            var imageSize = _targetImage.rectTransform.sizeDelta;
            var firstActivationTarget = result.ActivationTargets.FirstOrDefault();

            Debug.Log(
                "--------------\n" +
                $"Key : {firstActivationTarget.Key}\n" +
                $"Identifier : {firstActivationTarget.Value.Identifier}\n" +
                $"Center: {firstActivationTarget.Value.Center}\n" +
                $"Name : {firstActivationTarget.Value.Name}\n" +
                $"ImageURL : {firstActivationTarget.Value.ImageURL}"
            );

            firstActivationTarget.Value.DownloadImage((int)imageSize.x, (int)imageSize.y, args => _targetImage.texture = args);
        }
    }
}