OpenSceneGraph - Les GUIEventHandler

Une (relative) nouveauté d'OpenSceneGraph est l'ajout d'un framework pour l'interface graphique. J'ai notamment trouvé que les GUIEventHandler étaient à la fois simples et très puissants, puisqu'ils permettent de réagir à tout un tas d'événements de la fenêtre graphique. L'exemple le plus simple est probablement celui-ci, qui est un handler calculant le nombre d'images par secondes. Lors de la création du handler, on lui passe un pointeur sur un flottant, lequel sera mis à jour à chaque rafraîchissement. Le calcul est trivial puisque l'on peut simplement réagir à l'événement "frame", et récupérer le nombre de secondes depuis que le programme tourne.

class FpsHandler : public osgGA::GUIEventHandler
{
public:
  FpsHandler(const boost::shared_ptr<double> & fps):
    m_fps(fps),
    m_previousTime(0)
  {
  }
  
private:
  bool handle(const osgGA::GUIEventAdapter & ea, 
              osgGA::GUIActionAdapter &)
  {
    switch(ea.getEventType())
    {
    case(osgGA::GUIEventAdapter::FRAME):
      {
        double currentTime = ea.getTime();
        double diff = currentTime - m_previousTime;
        if(diff > 0)
        {
          *m_fps = 1 / diff;
        }
        else
        {
          *m_fps = 0;
        }
        m_previousTime = currentTime;
        break;
      }
    default:
      break;
    }
  
    return false;
  }

  boost::shared_ptr<double> m_fps;
  double m_previousTime;
};

Depuis mon programme, j'insère mon FpsHandler dans mon viewer, puis je créé un événement wxWidgets qui va lire ce temps toutes les secondes et l'afficher. Difficile de faire plus simple!

En bonus, ces handlers sont totalement indépendants du reste du code. Alors que j'ai déjà implémenté une multitude de calculateurs d'images par secondes dans les divers frameworks que j'utilise (SDL, Sfml, wxWidgets...), celui-ci peut simplement dormir dans une bibliothèque d'utilitaires OSG, et être utilisé dans n'importe quelle application.

Puisque les handlers s'ajoutent au viewer, il est ainsi possible de concevoir un grand nombre de composants résolvant chacun un problème donné, et de les combiner dans un programme.