Framerate événement indépendant dans Unity3D

Question

J'utilise le package libpd4unity pour communiquer avec Pure Data. Je reçois un coup de Pure Data avec LibPD.Bang. Sur un événement bang, je joue du son par FMOD.

Le problème est que je reçois des bangs fréquemment, par exemple une fois toutes les 500 ms mais que l'événement ne se déclenche pas dans une longueur de trame spécifique. Habituellement, la longueur change 1 frame less or more.

Existe-t-il une solution à ce problème? Par exemple un événement indépendant de framerate? Je veux savoir si event (delegate) dans Unity3D est indépendant ou non.

Parce qu'il y a du tempo pour jouer chaque son et que 1 frame ruine le rythme.

J'ai besoin de synchroniser les sons pour jouer par chaque bang séparé.

Answer 1

En ce qui concerne votre question si les délégués sont dépendants ou indépendants du frégat d'Unity, il n'y a pas de réponse directe. Cela dépend de la façon dont les délégués sont appelés. Sont-ils appelés d'un fil? Sont-ils exécutés dans un fil? Les Coroutines ne sont pas indépendantes du framerate, elles sont exécutées dans la boucle de Unity.

Le script suivant devrait faire la lumière sur la différence entre gérer des délégués dans des coroutines et dans des threads.

using System.Collections; 
using System.Collections.Generic; 
using UnityEngine; 
using System.Threading; 

public class DelegatesAndFramerate : MonoBehaviour { 

    delegate void MyDelegate(); 
    MyDelegate myDelegate1; // done with coroutines 
    MyDelegate myDelegate2; // done with threads 

    Thread thread; 
    bool threadDone = false; 

    private int frameCount = 0; 
    private int delegate1CallCount = 0; 
    private int delegate2CallCount = 0; 
    private int callerLoopsCount_coroutine = 0; 
    private int callerLoopsCount_thread = 0; 

    void Start() { 
     myDelegate1 += Elab1; 
     myDelegate2 += Elab2; 

     StartCoroutine(CallerCoroutine()); 

     thread = new Thread(new ThreadStart(CallerThread)); 
     thread.Start(); 
    } 

    void Update() 
    { 
     frameCount++; 
    } 

    void Elab1() 
    { 
     delegate1CallCount++; 
    } 

    void Elab2() 
    { 
     delegate2CallCount++; 
    } 

    IEnumerator CallerCoroutine() 
    { 
     while(true) 
     { 
      callerLoopsCount_coroutine++; 
      myDelegate1(); 
      yield return null; 
     } 
    } 

    void CallerThread() 
    { 
     while(!threadDone) 
     { 
      callerLoopsCount_thread++; 
      myDelegate2(); 
     } 
    } 

    void OnDestroy() 
    { 
     Debug.Log("Frame Count: " + frameCount); 
     Debug.Log("Delegate Call Count (Coroutine): " + delegate1CallCount); 
     Debug.Log("Delegate Call Count (Thread): " + delegate2CallCount); 
     Debug.Log("Caller Loops Count (Coroutine): " + callerLoopsCount_coroutine); 
     Debug.Log("Caller Loops Count (Thread): " + callerLoopsCount_thread); 

     threadDone = true; 
     thread.Join(); 
    } 
} 

Si vous attachez à un gameobject et laisser jouer l'unité pendant quelques secondes, vous verrez que les temps le délégué a appelé à partir d'un coroutine est égal au nombre de trames exécutées alors que le temps le délégué a appelé à partir du fil sera beaucoup plus grand. J'ai une expérience dans l'interfaçage de logiciels similaire à Pure Data et je pense que vous avez besoin d'un thread (plutôt typique) avec tous vos délégués, créez une file de commandes pour Unity et digérez-la dans la mise à jour d'Unity. Le fait de ne pas connaître libPD dans le cas spécifique n'est peut-être pas la meilleure pratique pour le cas mais c'est une approche largement utilisée. Fondamentalement, le modèle producteur-consommateur.

En se basant sur l'exemple GUITextScript.cs, libPD vous demande seulement de vous abonner aux bons délégués. Vous n'avez pas de contrôle sur quand ils sont exécutés, la bibliothèque a; Donc, si vous continuez à avoir ce problème, il vaut la peine de soumettre un rapport de bogue aux développeurs, je suppose.