Table of Contents

Accéder aux composants de fonctionnalité AR dans une session

Dans une session en cours d’exécution, vous pouvez accéder aux différents composants de fonctionnalité via la propriété Assembly. Cet article explique comment accéder à ces composants et les points à surveiller.

Avant de commencer

Configurer les composants AR à l’édition ou avant le démarrage

Parfois, certaines options de composant (comme DesiredFocusMode) doivent être configurées avant le démarrage du composant. Si vous ne souhaitez pas configurer et démarrer manuellement les composants après le démarrage de la session, une méthode simple consiste à configurer à l’avance tous les composants frame source susceptibles d’être utilisés avant l’assemblage de la session. Le processus d’assemblage conservera un ou plusieurs de ces composants et appliquera leur configuration.

À ce moment-là, vous pouvez utiliser n’importe quelle méthode Unity de base, comme FindAnyObjectByType<T>() ou GetComponent<T>(), pour trouver les composants, puis les configurer.

Note

Il n’est pas certain que le composant AR obtenu de cette manière soit finalement inclus dans la session à l’exécution. Il faut donc configurer tous les cas possibles.

Par exemple, le code suivant montre comment modifier le mode de mise au point de tous les composants frame source avant l’assemblage de la session :

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;
        }
    }
}

Le même processus peut aussi être effectué dans l’éditeur, avec la même nécessité de configurer tous les composants :

alt text

Les configurations pour ARCoreARFoundationFrameSource et ARKitARFoundationFrameSource se trouvent sur le composant de Main Camera.

Avertissement

Les composants AR obtenus de cette manière ne peuvent servir qu’à la configuration avant exécution. Comme le processus d’assemblage filtre les composants AR, ceux récupérés depuis l’arborescence de scène peuvent ne pas être inclus dans la session et ne pas fonctionner correctement.

Utiliser les composants AR assemblés pendant l’exécution

Les composants AR exécutés dans une session sont déterminés après l’assemblage. Avant l’assemblage terminé, aucun composant AR ne peut être utilisé. Les composants AR assemblés sont accessibles via la propriété Assembly.

Assembly peut être utilisé lorsque l’état de la session est >= Assembled. Plus précisément, la propriété Assembly n’est assignée qu’après l’exécution de Assemble(), et elle permet alors d’accéder aux composants de la session. Après l’arrêt ou la corruption de la session, la propriété Assembly est réinitialisée et les composants ne sont plus accessibles.

Vous pouvez vérifier l’état de State dans un script pour savoir à quel moment les composants AR sont accessibles :

if (Session.State >= ARSession.SessionState.Ready)
{
    // Assembly peut être utilisé
}
else
{
    // Assembly ne peut pas être utilisé
}

Vous pouvez aussi vous abonner à l’événement StateChanged pour suivre les changements d’état de la session et accéder aux composants AR au bon moment. En général, pour pouvoir capter l’état Ready, il faut s’abonner à StateChanged avant le démarrage de la session. S’abonner dans Awake() est généralement sûr :

void Awake()
{
    Session.StateChanged += (state) =>
    {
        if (Session.State == ARSession.SessionState.Ready)
        {
            // Assembly peut être utilisé, et restera accessible jusqu’à l’arrêt ou à la corruption de la session
        }
        else if (Session.State < ARSession.SessionState.Ready)
        {
            // Assembly ne peut pas être utilisé, et restera inaccessible jusqu’au redémarrage de la session
        }
        else
        {
            // Assembly peut être utilisé, généralement rien à traiter
        }
    };
}
Attention

Si les composants AR obtenus via FindAnyObjectByType<T>() ou GetComponent<T>() sont certains d’être inclus dans la session, ils peuvent aussi être utilisés à l’exécution. Il est sûr de stocker une référence à ces composants, mais lors de leur utilisation il faut s’assurer que la session est en cours d’exécution et que ces composants sont bien inclus dans la session, sinon des exceptions ou un comportement imprévisible peuvent survenir. Avant le démarrage et après l’arrêt de la session, ces composants ne peuvent pas fonctionner. Même dans ce cas d’usage, il est recommandé de suivre l’état State et l’événement StateChanged.

Accéder au composant frame source

Vous pouvez utiliser la propriété ARAssembly.FrameSource pour accéder au composant frame source. Dans une session normale en cours d’exécution, il n’y en a qu’un seul.

Lors de l’utilisation d’une session, il est souvent nécessaire d’accéder à ARAssembly.FrameSource pour déterminer le type réel de frame source utilisé à l’exécution, afin d’accéder à ses propriétés et méthodes spécifiques.

Par exemple, le code suivant montre comment utiliser différentes méthodes de détection de plan selon la 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;
        }
    }
}

Accéder au composant frame filter

Vous pouvez utiliser la propriété ARAssembly.FrameFilters pour accéder aux composants frame filter. Dans une session normale en cours d’exécution, il peut y avoir plusieurs composants de n’importe quel type dans la liste ARAssembly.FrameFilters.

Par exemple, le code suivant montre comment récupérer un MegaTrackerFrameFilter dans la session et enregistrer l’événement correspondant :

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

Accéder au composant camera

Vous pouvez utiliser la propriété ARAssembly.Camera pour accéder au composant camera. S’il y a plusieurs cameras dans la scène, c’est un moyen rapide de trouver la caméra utilisée par AR.

Par exemple, le code suivant montre comment obtenir la caméra dans la session et effectuer un raycast sur les objets de la scène :

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

Accéder au composant origin

Vous pouvez utiliser la propriété ARAssembly.Origin pour accéder au composant origin.

Par exemple, le code suivant montre comment obtenir l’origine de la session et afficher dans la scène un cône représentant la position et l’orientation actuelles de la caméra :

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);
}

Il faut noter qu’ici, il faut d’abord vérifier si ARAssembly.Origin existe.

Note

ARAssembly.Origin n’existe que dans les sessions où le suivi de mouvement est activé.

Accéder au composant CameraImageRenderer

Vous pouvez utiliser la propriété ARAssembly.CameraImageRenderer pour accéder au composant CameraImageRenderer.

Par exemple, le code suivant permet d’obtenir le RenderTexture de l’image de la caméra physique :

RenderTexture renderTexture;

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

Il faut noter qu’ici, il faut d’abord vérifier si ARAssembly.CameraImageRenderer existe.

Note

ARAssembly.CameraImageRenderer n’est valide que dans les sessions où l’image est rendue par EasyAR. En général, il est invalide avec AR Foundation ou sur un casque, où le rendu de l’image de la caméra physique est effectué par AR Foundation ou par le SDK du casque.

Accéder au composant FrameRecorder

Vous pouvez utiliser la propriété ARAssembly.FrameRecorder pour accéder au composant FrameRecorder.

Par exemple, le code suivant permet de démarrer l’enregistrement, et l’emplacement de stockage dépend de la configuration, avec par défaut un stockage dans le répertoire de stockage de l’application :

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

Il faut noter qu’ici, il faut d’abord vérifier si ARAssembly.FrameRecorder existe.

Note

ARAssembly.FrameRecorder n’est pas utilisable dans certains cas, par exemple avec FramePlayer.

Étapes suivantes

Sujets associés