al_App.hpp

#ifndef AL_APP_H
#define AL_APP_H
 
#include <cassert>
#include <cstring>
#include <functional>
#include <iostream>
#include <memory>
#include <stack>
#include <vector>
 
#include "al/app/al_AudioDomain.hpp"
#include "al/app/al_ComputationDomain.hpp"
#include "al/app/al_OSCDomain.hpp"
#include "al/app/al_OpenGLGraphicsDomain.hpp"
#include "al/app/al_SimulationDomain.hpp"
#include "al/graphics/al_Graphics.hpp"
 
namespace al {
 
class App {
public:
  App();
 
  virtual ~App() {}
 
  template <class DomainType> std::shared_ptr<DomainType> newDomain() {
    auto newDomain = std::make_shared<DomainType>();
    mDomainList.push_back(newDomain);
    //    if (!newDomain->init()) {
    //      std::cerr << "ERROR initializing domain " << std::endl;
    //    }
    return newDomain;
  }
 
  virtual void onInit() {}
  virtual void onCreate() {}
  virtual void onAnimate(double dt) { (void)dt; }
  virtual void onDraw(Graphics &g) { (void)g; }
  virtual void onSound(AudioIOData &io) { (void)io; }
  virtual void onMessage(osc::Message &m) { (void)m; }
  virtual void onExit() {}
 
  virtual bool onKeyDown(Keyboard const & /*k*/) { return true; }
  virtual bool onKeyUp(Keyboard const & /*k*/) { return true; }
  virtual bool onMouseDown(Mouse const & /*m*/) { return true; }
  virtual bool onMouseUp(Mouse const & /*m*/) { return true; }
  virtual bool onMouseDrag(Mouse const & /*m*/) { return true; }
  virtual bool onMouseMove(Mouse const & /*m*/) { return true; }
  virtual bool onMouseScroll(Mouse const & /*m*/) { return true; }
  virtual void onResize(int /*w*/, int /*h*/) {}
  //  virtual void onVisibility(bool v) {}
 
  void quit(); 
  bool shouldQuit();
 
  // Access to graphics domain properties
  virtual Window &defaultWindow();
  virtual Graphics &graphics();
 
  virtual Viewpoint &view();
  virtual Pose &pose();
  virtual Lens &lens();
  virtual Nav &nav();
  virtual NavInputControl &navControl();
  void fps(double f);
 
  // Access to default window domain
  // These functions are only valid after start() has been called.
  Keyboard &keyboard(); 
  Mouse &mouse();       
 
  double aspect(); 
  bool created();  
  Window::Cursor cursor();             
  bool cursorHide();                   
  Window::Dim dimensions();            
  Window::DisplayMode displayMode();   
  bool enabled(Window::DisplayMode v); 
  bool fullScreen();                   
  const std::string &title();          
  bool visible();                      
  bool vsync();                        
 
  void fullScreenToggle(); 
  void hide();             
  void iconify();          
  // void show(); ///< Show window (if hidden)
 
  int height(); 
  int width();  
 
  // get frambuffer size
  // it will be different from window widht and height
  // if the display is a high resolution one (ex: RETINA display)
  int fbHeight();
  int fbWidth();
 
  float highresFactor();
 
  bool decorated();
  void cursor(Window::Cursor v);               
  void cursorHide(bool v);                     
  void cursorHideToggle();                     
  void dimensions(const Window::Dim &v);       
  void dimensions(int w, int h);               
  void dimensions(int x, int y, int w, int h); 
  void displayMode(Window::DisplayMode v); 
 
  void fullScreen(bool on);
  void title(const std::string &v); 
  void vsync(bool v); 
  void decorated(bool b);
 
  // Event handlers
  [[deprecated("Call through defaultWindow()")]] void
  append(WindowEventHandler &handler);
  [[deprecated("Call through defaultWindow()")]] void
  prepend(WindowEventHandler &handler);
  [[deprecated("Call through defaultWindow()")]] void
  remove(WindowEventHandler &handler);
 
  // Access to audio domain
  AudioIO &audioIO();
 
  void configureAudio(double audioRate = 44100, int audioBlockSize = 512,
                      int audioOutputs = -1, int audioInputs = -1);
 
  void configureAudio(AudioDevice &dev, double audioRate = -1,
                      int audioBlockSize = 512, int audioOutputs = -1,
                      int audioInputs = -1);
 
  // Access to OSC domain
  ParameterServer &parameterServer();
 
  virtual void start();
 
  // Domain access
  std::shared_ptr<OSCDomain> oscDomain() { return mOSCDomain; }
  std::shared_ptr<AudioDomain> audioDomain() { return mAudioDomain; }
  std::shared_ptr<OpenGLGraphicsDomain> graphicsDomain() {
    return mOpenGLGraphicsDomain;
  }
  std::shared_ptr<SimulationDomain> simulationDomain() {
    return mSimulationDomain;
  }
 
  std::shared_ptr<GLFWOpenGLWindowDomain> defaultWindowDomain() {
    return mDefaultWindowDomain;
  }
  struct StandardWindowAppKeyControls : WindowEventHandler {
    bool keyDown(const Keyboard &k);
    App *app;
  };
  StandardWindowAppKeyControls stdControls;
 
  // Modify these with care
  std::shared_ptr<GLFWOpenGLWindowDomain> mDefaultWindowDomain;
 
  std::shared_ptr<OSCDomain> mOSCDomain;
  std::shared_ptr<AudioDomain> mAudioDomain;
  std::shared_ptr<OpenGLGraphicsDomain> mOpenGLGraphicsDomain;
  std::shared_ptr<SimulationDomain> mSimulationDomain;
 
protected:
  void initializeDomains();
 
  std::vector<std::shared_ptr<AsynchronousDomain>> mDomainList;
  std::stack<std::shared_ptr<AsynchronousDomain>> mRunningDomains;
};
 
} // namespace al
 
#endif // AL_APP_H