Unity Package

Step 1 - Add the HTTP/2 transport

Localization uses gRPC, which needs HTTP/2. Unity’s built-in HttpClient only supports HTTP/1.1, so add YetAnotherHttpHandler and its NuGet dependencies to your project’s Packages/manifest.json:

{
  "scopedRegistries": [
    {
      "name": "Unity NuGet",
      "url": "https://unitynuget-registry.openupm.com",
      "scopes": ["org.nuget"]
    }
  ],
  "dependencies": {
    "com.cysharp.yetanotherhttphandler.dependencies": "https://github.com/Cysharp/YetAnotherHttpHandler.git?path=src/YetAnotherHttpHandler.Dependencies#1.11.6",
    "com.cysharp.yetanotherhttphandler": "https://github.com/Cysharp/YetAnotherHttpHandler.git?path=src/YetAnotherHttpHandler#1.11.6"
  }
}

Merge these entries into your existing file and keep your other dependencies. The SDK detects the package automatically. If it is missing, the build prints a warning and start() fails with an error that names the missing package.

Step 2 - Add the Graffity package

Install the package from the Git URL below with the Package Manager (Window > Package Manager > + > Install package from git URL...). See Unity’s official documentation, Installing from a Git URL.

https://github.com/Graffity-Technologies/graffity-arcloud-unity.git#4.0.0-pre.1

The text after # pins a package version tag. Always pin a version so that every machine on your team resolves the same SDK.

All public types are in the Graffity.ARCloud namespace:

using Graffity.ARCloud;

Step 3 - Enable the AR providers

In Project Settings > XR Plug-in Management, enable ARKit on the iOS tab and/or ARCore on the Android tab. Make sure your URP renderer has the AR Background Renderer Feature so the camera feed is visible.

Step 4 - Add permissions

The SDK uses the camera for localization and the device location (GPS) to find candidate maps.

Step 1 - AR scene setup

• Add an AR Session and an XR Origin (Mobile AR) from GameObject > XR. The XR Origin’s camera must have an ARCameraManager (the menu adds one).
• These objects stay yours. The SDK never moves, resets or destroys the AR Session or XR Origin.

Step 2 - Add the ARCloud session

• Create an empty GameObject, for example Graffity, and add the GraffityARCloudSession component. Keep it outside any map content.
• Assign the AR Session and XR Origin fields.
• Paste the SDK Access Token generated in your Graffity Console project. To keep the token out of source control, leave the field empty and set it from code instead.
• Optional: assign a Navigation Renderer to draw route arrows. See Navigation.

The Inspector reports missing references and other setup problems.

Step 3 - Author content against a map section

• Open Graffity > AR Cloud > Point clouds, select your session, load your places, then pick a place and a section.
• Download the section’s point cloud. The SDK creates a GraffityARMapRoot bound to that section, with an Authored content child, and registers it on your session.
• Place your prefabs and scripts under Authored content, using the point cloud as a guide.

The point cloud is an Editor-only preview and is never included in your build. The SDK keeps Authored content hidden until the device localizes in that section. It then moves the map root so your content lines up with the real world. See Scene Authoring for details.

Step 4 - Start the session

• Tick Start On Enable on the session to start localizing when the scene loads, or call start() from your own script, for example after your app’s onboarding:

using System;
using Graffity.ARCloud;
using UnityEngine;
 
public sealed class StartGraffity : MonoBehaviour, IObserver<GraffityARState>
{
    [SerializeField] private GraffityARCloudSession session;
    private IDisposable subscription;
 
    private void Start()
    {
        session.start();
        subscription = session.sdk.statePublisher.Subscribe(this);
    }
 
    public void OnNext(GraffityARState state)
    {
        if (state.vpsState.kind == GraffityARVPSState.Kind.localized)
            Debug.Log("Localized in section " + state.vpsState.sectionId);
        if (state.lastError != null)
            Debug.LogWarning("Graffity error: " + state.lastError.code);
    }
 
    public void OnError(Exception error) { }
    public void OnCompleted() { }
 
    private void OnDestroy() => subscription?.Dispose();
}

After start():

1. The SDK loads its settings.
2. Active localization begins. sdk.localizationGuidance asks the player to hold the phone level, then to aim the camera at suggested targets. Camera frames stream to VPS until it returns a fix. Show your own prompts, or import the Host integration sample for ready-made ones.
3. The matching GraffityARMapRoot is aligned and its Authored content appears.
4. Continuous re-localization then corrects drift as the player walks. Small differences are ignored, so content doesn’t jump.
5. While Auto Retry Localization is on (the default), a failed attempt retries automatically with backoff. You can also call reset() yourself.

Call SDK APIs on the Unity main thread. The session pauses and resumes with the app.

Step 1 - Project Settings > XR Plug-in Management

Make sure ARKit (iOS) and/or ARCore (Android) is enabled for your target platform.

Step 2 - Check permissions and transport

Make sure the iOS camera and location usage descriptions are set and YetAnotherHttpHandler is installed. The build prints a warning if either is missing.

Step 3 - Build Settings

Build the scene to your device. You don’t need to hide or delete point clouds: previews are Editor-only, and the build fails if point-cloud files end up in player assets.