Table of Contents

Accéder aux composants fonctionnels AR dans une session

Dans une session en cours d'exécution, vous pouvez accéder aux différents composants fonctionnels via la propriété Assembly. Cet article explique comment accéder à ces composants et les points à noter lors de l'accès.

Avant de commencer

Configurer les composants AR lors de l'édition ou avant le démarrage

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

Vous pouvez utiliser FindAnyObjectByType<T>() ou GetComponent<T>(), ou toute autre méthode Unity de base, pour trouver les composants, puis les configurer.

Note

Il est incertain si les composants AR obtenus de cette manière seront inclus dans la session lors de l'exécution. Par conséquent, il est nécessaire de 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;
        }
    }
}

Ce processus peut également être effectué dans l'éditeur, nécessitant également la configuration de tous les composants :

alt text

La configuration pour les deux frame sources ARCoreARFoundationFrameSource et ARKitARFoundationFrameSource se trouve sur le composant de la Main Camera.

Avertissement

Les composants AR obtenus de cette manière ne peuvent être utilisés que pour la configuration avant l'exécution.
En raison du processus de filtrage lors de l'assemblage, les composants AR obtenus via la hiérarchie de scène peuvent ne pas être inclus dans la session et ne pas fonctionner correctement.

Utilisation des composants ar assemblés en cours d'exécution

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

Assembly est disponible lorsque l'état de la session est >= Assembled. Plus précisément, la propriété Assembly n'est définie qu'après l'exécution de la méthode Assemble(), permettant ainsi 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 State de la session dans un script pour déterminer si les composants AR sont accessibles à ce moment :

if (Session.State >= ARSession.SessionState.Ready)
{
    // Assembly 可以使用
}
else
{
    // Assembly 不能使用
}

Vous pouvez également vous abonner à l'événement StateChanged pour être informé des changements d'état de la session et ainsi accéder aux composants AR au bon moment. Généralement, pour capturer l'état Ready, il est nécessaire de s'abonner à l'événement StateChanged avant le démarrage de la session. Il est généralement sûr d'effectuer cet abonnement dans la méthode Awake() :

void Awake()
{
    Session.StateChanged += (state) =>
    {
        if (Session.State == ARSession.SessionState.Ready)
        {
            // Assembly 可以使用，在这之后 Assembly 一直可以访问，直至 session 停止或损坏
        }
        else if (Session.State < ARSession.SessionState.Ready)
        {
            // Assembly 不能使用，在这之后 Assembly 一直不可访问，直至 session 重新启动
        }
        else
        {
            // Assembly 可以使用，通常不需要处理
        }
    };
}
Attention

Si vous obtenez des composants AR via des méthodes telles que FindAnyObjectByType<T>() ou GetComponent<T>(), ils seront inclus dans la session et peuvent également être utilisés lors de l'exécution.
Il est sûr de stocker les références à ces composants, mais lors de leur utilisation, vous devez vous assurer que la session est en cours d'exécution et que ces composants sont correctement inclus dans la session, sinon des exceptions ou des comportements inattendus peuvent se produire.
Avant le démarrage de la session et après son arrêt, ces composants ne fonctionnent pas. Il est recommandé, même dans ce type d'utilisation, de surveiller l'état State de la session et les événements StateChanged.

Accéder au composant frame source

Vous pouvez accéder au composant frame source en utilisant la propriété ARAssembly.FrameSource. Dans une session fonctionnant correctement, ARAssembly.FrameSource en a un et un seul.

Lors de l'utilisation d'une session, il est généralement nécessaire d'accéder à ARAssembly.FrameSource pour déterminer le type réel de composant frame source utilisé lors de l'exécution, afin d'accéder aux propriétés et méthodes spécifiques à ce composant.

Par exemple, le code suivant montre comment utiliser différentes méthodes de détection de plan en fonction du 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

Les composants frame filter sont accessibles via la propriété ARAssembly.FrameFilters. Dans une session fonctionnelle, la liste ARAssembly.FrameFilters peut contenir plusieurs instances de chaque type de composant.

Par exemple, ce code montre comment obtenir un MegaTrackerFrameFilter dans la session et enregistrer ses événements :

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 accéder au composant camera en utilisant la propriété ARAssembly.Camera. C'est un raccourci pratique pour trouver la caméra utilisée pour la RA lorsqu'il y a plusieurs caméras dans la scène.

Par exemple, le code suivant montre comment obtenir la camera dans la session et effectuer une détection de rayons 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 accéder au composant origin en utilisant la propriété ARAssembly.Origin.

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

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

Notez qu'il est nécessaire de vérifier au préalable si ARAssembly.Origin existe.

[!REMARQUE] ARAssembly.Origin n'existe que dans les sessions où la fonction de suivi de mouvements est activée.

Accéder au composant CameraImageRenderer

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

Par exemple, ce code récupère la 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);
        }
    };
}

Notez qu'il faut d'abord vérifier si ARAssembly.CameraImageRenderer existe.

Note

ARAssembly.CameraImageRenderer n'est valide que dans les sessions où le rendu est effectué par EasyAR. Généralement, il est invalide lors de l'utilisation d'AR Foundation ou d'un casque, car le rendu de l'image de la caméra physique est alors pris en charge par AR Foundation ou le SDK du casque.

Accéder au composant FrameRecorder

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

Par exemple, le code suivant démarre l'enregistrement. L'emplacement de stockage du fichier dépend de la configuration et est stocké par défaut dans le répertoire de stockage interne de l'application :

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

Notez qu'il est nécessaire de vérifier au préalable si ARAssembly.FrameRecorder existe.

Note

ARAssembly.FrameRecorder n'est pas disponible dans de rares cas, par exemple lors de l'utilisation de FramePlayer.

Prochaines étapes

Sujets connexes