Table of Contents

Accedere ai componenti funzionali AR nella sessione

All'interno di una sessione in esecuzione, è possibile accedere ai vari componenti funzionali tramite la proprietà Assembly. Questo documento spiega come accedere a questi componenti e gli aspetti da considerare durante l'accesso.

Prima di iniziare

Configurare i componenti AR prima dell'avvio o durante la modifica

Alcune opzioni dei componenti (come DesiredFocusMode) devono essere configurate prima dell'avvio del componente. Se non si desidera configurare e avviare manualmente il componente dopo l'avvio della sessione, un metodo semplice consiste nel configurare tutti i potenziali componenti frame source prima dell'assemblaggio della sessione. Il processo di assemblaggio conserverà uno o più di questi componenti e applicherà le relative configurazioni.

È possibile utilizzare metodi Unity di base come FindAnyObjectByType<T>() o GetComponent<T>() per individuare i componenti, quindi configurarli.

Nota

Non è certo se i componenti AR ottenuti con questo metodo saranno inclusi nella sessione durante l'esecuzione. Pertanto, è necessario configurare tutti i casi possibili.

Ad esempio, il codice seguente mostra come modificare la modalità di messa a fuoco di tutti i componenti frame source prima dell'assemblaggio della sessione:

void Awake()
{
    var allFrameSources = Session.GetComponentsInChildren<FrameSource>();
    foreach (var source in allFrameSources)
    {
        if (source is CameraDeviceFrameSource)
        {
            ((CameraDeviceFrameSource)source).DesiredFocusMode = autoFocus ? CameraDeviceFocusMode.Continousauto : CameraDeviceFocusMode.Medium;
        }
        else if (source is MotionTrackerFrameSource)
        {
            ((MotionTrackerFrameSource)source).DesiredFocusMode = autoFocus ? MotionTrackerCameraDeviceFocusMode.Continousauto : MotionTrackerCameraDeviceFocusMode.Medium;
        }
        else if (source is ARCoreFrameSource)
        {
            ((ARCoreFrameSource)source).DesiredFocusMode = autoFocus ? ARCoreCameraDeviceFocusMode.Auto : ARCoreCameraDeviceFocusMode.Fixed;
        }
        else if (source is ARKitFrameSource)
        {
            ((ARKitFrameSource)source).DesiredFocusMode = autoFocus ? ARKitCameraDeviceFocusMode.Auto : ARKitCameraDeviceFocusMode.Fixed;
        }
        else if (source is AREngineFrameSource)
        {
            ((AREngineFrameSource)source).DesiredFocusMode = autoFocus ? AREngineCameraDeviceFocusMode.Auto : AREngineCameraDeviceFocusMode.Fixed;
        }
        else if (source is ThreeDofCameraDeviceFrameSource)
        {
            ((ThreeDofCameraDeviceFrameSource)source).DesiredFocusMode = autoFocus ? ThreeDofCameraDeviceFocusMode.Auto : ThreeDofCameraDeviceFocusMode.Fixed;
        }
        else if (source is InertialCameraDeviceFrameSource)
        {
            ((InertialCameraDeviceFrameSource)source).DesiredFocusMode = autoFocus ? InertialCameraDeviceFocusMode.Auto : InertialCameraDeviceFocusMode.Fixed;
        }
        else if (source is ARFoundationFrameSource)
        {
            cameraManager.autoFocusRequested = autoFocus;
        }
    }
}

Questa procedura può essere eseguita anche nell'editor, configurando comunque tutti i componenti:

testo alternativo

Le configurazioni per i frame source ARCoreARFoundationFrameSource e ARKitARFoundationFrameSource si trovano nel componente della Main Camera.

Avvertenza

I componenti AR ottenuti con questo metodo possono essere utilizzati solo per la configurazione pre-esecuzione.
Poiché il processo di assemblaggio filtra i componenti AR, quelli ottenuti dalla gerarchia della scena potrebbero non essere inclusi nella sessione e non funzionare correttamente.

Utilizzo di componenti AR assemblati durante il runtime

I componenti AR in esecuzione nella sessione sono determinati solo dopo l'assemblaggio. Nessun componente AR può essere utilizzato prima che l'assemblaggio sia completo. I componenti AR assemblati sono accessibili tramite la proprietà Assembly.

Assembly è utilizzabile quando lo stato della sessione è >= Assembled. Nello specifico, la proprietà Assembly viene assegnata solo dopo il completamento del metodo Assemble(), consentendo l'accesso ai componenti della sessione. Dopo che la sessione si arresta o viene danneggiata, la proprietà Assembly viene svuotata e non è più possibile accedere ai componenti.

È possibile verificare lo State della sessione in uno script per determinare se è possibile accedere ai componenti AR in quel momento:

if (Session.State >= ARSession.SessionState.Ready)
{
    // Assembly è utilizzabile
}
else
{
    // Assembly non è utilizzabile
}

È anche possibile iscriversi all'evento StateChanged per ricevere le modifiche dello stato della sessione, accedendo così ai componenti AR al momento opportuno. Generalmente, per catturare lo stato Ready, è necessario iscriversi all'evento StateChanged prima dell'avvio della sessione. Di solito, effettuare l'iscrizione in Awake() è sicuro:

void Awake()
{
    Session.StateChanged += (state) =>
    {
        if (Session.State == ARSession.SessionState.Ready)
        {
            // Assembly è utilizzabile, da questo momento è accessibile fino all'arresto o al danneggiamento della sessione
        }
        else if (Session.State < ARSession.SessionState.Ready)
        {
            // Assembly non è utilizzabile, da questo momento non è accessibile fino al riavvio della sessione
        }
        else
        {
            // Assembly è utilizzabile, generalmente non richiede gestione
        }
    };
}
Attenzione

Se si ottiene un componente AR tramite metodi come FindAnyObjectByType<T>() o GetComponent<T>(), sarà sicuramente incluso nella sessione e può essere usato durante il runtime.
Conservare riferimenti a questi componenti è sicuro, ma durante il loro utilizzo è necessario assicurarsi che la sessione sia in esecuzione e che tali componenti siano correttamente inclusi nella sessione, altrimenti potrebbero verificarsi eccezioni o comportamenti imprevisti.
Questi componenti non funzionano prima dell'avvio e dopo l'arresto della sessione. Si consiglia, anche in questo tipo di utilizzo, di monitorare lo State della sessione e l'evento StateChanged.

Accedere al componente frame source

È possibile accedere al componente frame source utilizzando la proprietà ARAssembly.FrameSource. In una sessione funzionante, ARAssembly.FrameSource ne contiene uno e uno solo.

Durante l'utilizzo della sessione, spesso è necessario accedere a ARAssembly.FrameSource per determinare il tipo effettivo di componente frame source utilizzato in runtime, consentendo così l'accesso a proprietà e metodi specifici di quel componente.

Ad esempio, il seguente codice mostra come utilizzare diversi metodi di rilevamento piani in base al frame source:

void PlaceObject(Vector2 touchPosition)
{
    if (Session.Assembly.FrameSource is MotionTrackerFrameSource)
    {
        Ray ray = Session.Assembly.Camera.ScreenPointToRay(touchPosition);
        if (Physics.Raycast(ray, out var hitInfo))
        {
            TouchRoot.transform.position = hitInfo.point;
        }
    }
    else if (Session.Assembly.FrameSource is ARFoundationFrameSource)
    {
        var raycastManager = Session.Assembly.Origin.Value.GetComponent<UnityEngine.XR.ARFoundation.ARRaycastManager>();
        var hits = new List<UnityEngine.XR.ARFoundation.ARRaycastHit>();
        if (raycastManager.Raycast(touchPosition, hits, UnityEngine.XR.ARSubsystems.TrackableType.PlaneWithinPolygon))
        {
            var hitPose = hits[0].pose;
            TouchRoot.transform.position = hitPose.position;
        }
    }
}

Accedere al componente frame filter

È possibile accedere ai componenti frame filter utilizzando la proprietà ARAssembly.FrameFilters. In una sessione funzionante, potrebbero essere presenti più componenti di qualsiasi tipo nella lista ARAssembly.FrameFilters.

Ad esempio, il codice seguente mostra come ottenere un MegaTrackerFrameFilter dalla sessione e registrare l'evento corrispondente:

var megaTracker = session.Assembly.FrameFilters.Where(f => f is MegaTrackerFrameFilter).FirstOrDefault() as MegaTrackerFrameFilter;
if (megaTracker)
{
    megaTracker.LocalizationRespond += (response) =>
    {
    };
}

Accedere al componente camera

È possibile accedere al componente camera utilizzando la proprietà ARAssembly.Camera. Se ci sono più telecamere nella scena, questo è un modo rapido per trovare quella utilizzata per la realtà aumentata.

Ad esempio, il seguente codice mostra come ottenere la telecamera nella sessione ed eseguire un rilevamento del raggio sugli oggetti nella scena:

var ray = Session.Assembly.Camera.ScreenPointToRay(screenPoint);
if (Physics.Raycast(ray, out var hitInfo))
{
    TouchRoot.transform.position = hitInfo.point;
};

Accedere al componente origin

È possibile accedere al componente origin utilizzando la proprietà ARAssembly.Origin.

Ad esempio, il seguente codice mostra come ottenere l'origin dalla session e visualizzare un cono che rappresenta la posizione e l'orientamento attuali della fotocamera nella scena:

if (session.Assembly.Origin.OnSome)
{
    GameObject frustum = Instantiate(CameraFrustumPrefab, session.Assembly.Camera.transform.position, session.Assembly.Camera.transform.rotation);
    frustum.transform.SetParent(session.Assembly.Origin.Value.transform);
}

Si noti che è necessario verificare prima se ARAssembly.Origin esiste.

Nota

ARAssembly.Origin esiste solo nelle session in cui è abilitata la funzione di tracciamento del movimento.

Accedere al componente CameraImageRenderer

È possibile accedere al componente CameraImageRenderer utilizzando la proprietà ARAssembly.CameraImageRenderer.

Ad esempio, il seguente codice può ottenere la RenderTexture dell'immagine della fotocamera fisica:

RenderTexture renderTexture;

void Awake()
{
    Session.StateChanged += (state) =>
    {
        if (state == ARSession.SessionState.Ready && Session.Assembly.CameraImageRenderer.OnSome)
        {
            Session.Assembly.CameraImageRenderer.Value.RequestTargetTexture((_, texture) => renderTexture = texture);
        }
    };
}

Si noti che è necessario verificare prima se ARAssembly.CameraImageRenderer esiste.

Nota

ARAssembly.CameraImageRenderer è valido solo nelle sessioni in cui il rendering viene eseguito da EasyAR. In generale, non sarà valido quando si utilizza AR Foundation o un headset, poiché in questi casi il rendering dell'immagine della fotocamera fisica viene gestito da AR Foundation o dall'SDK dell'headset.

Accedere al componente framerecorder

È possibile accedere al componente FrameRecorder utilizzando la proprietà ARAssembly.FrameRecorder.

Ad esempio, il seguente codice avvia la registrazione. La posizione di archiviazione del file dipende dalla configurazione, per impostazione predefinita verrà archiviato nella directory di archiviazione interna dell'app:

if (session.Assembly.FrameRecorder.OnSome)
{
    var frameRecorder = session.Assembly.FrameRecorder.Value;
    frameRecorder.enabled = true;
}

Si noti che è necessario verificare prima se ARAssembly.FrameRecorder esiste.

Nota

ARAssembly.FrameRecorder in alcuni casi, come quando si utilizza FramePlayer, non è disponibile.

Prossimi passi

Argomenti correlati