WindowProxy.hpp

Go to the documentation of this file.

/***********************************
 Copyright 2018 Ravishankar Mathur
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
 
 http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 ***********************************/

#ifndef _OF_WINDOWPROXY_
#define _OF_WINDOWPROXY_

#include <OpenFrames/Export.h>
#include <OpenFrames/RenderRectangle.hpp>
#include <OpenFrames/FramerateLimiter.hpp>
#include <OpenFrames/OpenVRDevice.hpp>
#include <OpenThreads/Thread>
#include <osg/FrameStamp>
#include <osg/Timer>
#include <osg/Referenced>
#include <osg/observer_ptr>
#include <osg/ref_ptr>
#include <osgViewer/CompositeViewer>
#include <osgViewer/GraphicsWindow>
#include <vector>
#include <set>

// Define shortcuts for callback function signatures
#define BASIC_CALLBACK_SIG unsigned int *winID, unsigned int *row, unsigned int *col
#define KEYPRESS_SIG BASIC_CALLBACK_SIG, int *key
#define MOUSEMOTION_SIG BASIC_CALLBACK_SIG, float *x, float *y
#define BUTTON_SIG MOUSEMOTION_SIG, unsigned int *button
#define VR_SIG BASIC_CALLBACK_SIG, const OpenVREvent *vrEvent

namespace OpenFrames
{
  class FrameManager;
  class WindowProxy;
  
  class EmbeddedGraphics : public osgViewer::GraphicsWindow
  {
  public:
    EmbeddedGraphics(int x, int y, int width, int height, WindowProxy *window);
    
    virtual bool isSameKindAs(const Object* object) const { return dynamic_cast<const EmbeddedGraphics*>(object)!=0; }
    virtual const char* libraryName() const { return "OpenFrames"; }
    virtual const char* className() const { return "EmbeddedGraphics"; }
    
    virtual void setWindowName(const std::string& name) { _traits->windowName = name; }
    
    virtual bool makeCurrentImplementation();
    virtual void swapBuffersImplementation();
    
    void setMakeCurrentFunction(void (*fcn)(unsigned int *winID, bool *success));
    
    void setUpdateContextFunction(void (*fcn)(unsigned int *winID, bool *success));
    bool updateContextImplementation();
    
    void setSwapBuffersFunction(void (*fcn)(unsigned int *winID));
    
    virtual bool realizeImplementation();
    virtual bool isRealizedImplementation() const  { return _realized; }
    
    virtual bool valid() const { return true; }
    virtual bool releaseContextImplementation() { return true; }
    virtual void closeImplementation() {}
    virtual void grabFocus() {}
    virtual void grabFocusIfPointerInWindow() {}
    virtual void raiseWindow() {}
    
  protected:
    virtual ~EmbeddedGraphics();
    
    void (*_makeCurrent)(unsigned int *winID, bool *success);
    void (*_updateContext)(unsigned int *winID, bool *success);
    void (*_swapBuffers)(unsigned int *winID);
    
    WindowProxy *_window; // Pointer to the WindowProxy that represents the window
    bool _realized; // Whether this context has been realized
  };

  class OF_EXPORT WindowEventHandler : public osgGA::GUIEventHandler
  {
  public:
    WindowEventHandler(WindowProxy *window);
    
    // Event handler function
    bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);
    
    // Indicate that the associated WindowProxy has been modified in some way
    void windowModified();
    
    // Set the callback functions for various events. These will be called when the corresponding
    // event occurs (ie user presses a key, moves the mouse, etc...).
    void setKeyPressCallback(void (*fcn)(KEYPRESS_SIG)) // Keyboard key press callback
    { _keyPressCallback = fcn; }
    
    void setMouseMotionCallback(void (*fcn)(MOUSEMOTION_SIG)) // Mouse moved callback
    { _mouseMotionCallback = fcn; }
    
    void setButtonPressCallback(void (*fcn)(BUTTON_SIG)) // Mouse button pressed callback
    { _buttonPressCallback = fcn; }
    
    void setButtonReleaseCallback(void (*fcn)(BUTTON_SIG)) // Mouse button released callback
    { _buttonReleaseCallback = fcn; }

    void setVREventCallback(void (*fcn)(VR_SIG)) // VR controller event callback
    { _vrEventCallback = fcn; }
    
  protected:
    virtual ~WindowEventHandler();
    
    void getRenderRectangle(float x, float y, unsigned int &row, unsigned int &col);
    void selectRenderRectangle(unsigned int row, unsigned int col);
    
    WindowProxy *_window;
    unsigned int _currentRow, _currentCol;
    
    void (*_keyPressCallback)(KEYPRESS_SIG);
    void (*_mouseMotionCallback)(MOUSEMOTION_SIG);
    void (*_buttonPressCallback)(BUTTON_SIG);
    void (*_buttonReleaseCallback)(BUTTON_SIG);
    void (*_vrEventCallback)(VR_SIG);
  };

  class OF_EXPORT WindowProxy : public OpenThreads::Thread, public osg::Referenced
  {
  public:
    // A list of RenderRectangles for each grid position
    typedef std::vector<osg::ref_ptr<RenderRectangle> > RenderList;
    
    WindowProxy(int x, int y,
                unsigned int width, unsigned int height,
                unsigned int nrow, unsigned int ncol,
                bool embedded = false, bool useVR = false);
    
    virtual void cancelCleanup();
    
    void setWindowName(const std::string& name);
    
    unsigned int getWindowWidth() const;
    unsigned int getWindowHeight() const;
    
    bool isEmbedded() const { return _isEmbedded; }
    
    void keyPress(int key);
    void keyRelease(int key);
    void mouseMotion(float x, float y);
    void buttonPress(float x, float y, unsigned int button);
    void buttonRelease(float x, float y, unsigned int button);
    void resizeWindow(int x, int y, unsigned int width, unsigned int height);
    
    void setupGrid(unsigned int width, unsigned int height);
    
    void shutdown() { _viewer->setDone(true); }
    
    void setTime(double time);
    double getTime() const
    {
      if(_timeSyncWinProxy.valid()) return _timeSyncWinProxy->getTime();
      else return _currTime;
    }
    
    void setTimeRange(double tMin, double tMax);
    void getTimeRange(double& tMin, double& tMax) const;
    
    void pauseTime(bool pause);
    bool isTimePaused() const
    {
      if(_timeSyncWinProxy.valid()) return _timeSyncWinProxy->isTimePaused();
      else return _timePaused;
    }
    
    void setTimeScale(double tscale);
    double getTimeScale() const
    {
      if(_timeSyncWinProxy.valid()) return _timeSyncWinProxy->getTimeScale();
      else return _timeScale;
    }
    
    bool synchronizeTime(WindowProxy *winproxy);
    WindowProxy* getTimeSyncWindow() const { return _timeSyncWinProxy.get(); }
    
    enum AnimationState
    {
      IDLE = 0,      // Waiting to initiate animation
      INITIALIZING,  // Initializing animation
      ANIMATING,     // Inside animation loop, and actively rendering
      PAUSED,        // Inside animation loop, but rendering is paused
      FAILED,        // Error during initialization
      SUCCESS        // Successfully finished animating
    };
    
    void pauseAnimation(bool pause);
    
    AnimationState getAnimationState() const { return _animationState; }
    
    bool isAnimating() const { return ((_animationState == ANIMATING) || (_animationState == PAUSED)); }
    
    bool doneAnimating() const { return ((_animationState == FAILED) || (_animationState == SUCCESS)); }
    
    void resetAnimationState() { if(doneAnimating()) _animationState = IDLE; }
    
    inline void setDesiredFramerate(const double &fps)
    { _frameThrottle.setDesiredFramerate(fps); }
    
    inline double getDesiredFramerate()
    { return _frameThrottle.getDesiredFramerate(); }
    
    inline double getFramerate()
    { return _frameThrottle.getFramerate(); }
    
    osgViewer::CompositeViewer* getViewer() const { return _viewer.get(); }
    
    void setGridSize(unsigned int row, unsigned int col);
    inline unsigned int getNumRows() const { return _nRow; }
    inline unsigned int getNumCols() const { return _nCol; }
    
    void setScene(FrameManager *fm, unsigned int row, unsigned int col);
    FrameManager* getScene(unsigned int row, unsigned int col);
    
    RenderRectangle* getGridPosition(unsigned int row, unsigned int col);
    
    void setMakeCurrentFunction(void (*fcn)(unsigned int *winID, bool *success));
    
    void setUpdateContextFunction(void (*fcn)(unsigned int *winID, bool *success));
    
    void setSwapBuffersFunction(void (*fcn)(unsigned int *winID));
    
    void setKeyPressCallback(void (*fcn)(KEYPRESS_SIG))
    { _eventHandler->setKeyPressCallback(fcn); }
    
    void setMouseMotionCallback(void (*fcn)(MOUSEMOTION_SIG))
    { _eventHandler->setMouseMotionCallback(fcn); }
    
    void setButtonPressCallback(void (*fcn)(BUTTON_SIG))
    { _eventHandler->setButtonPressCallback(fcn); }
    
    void setButtonReleaseCallback(void (*fcn)(BUTTON_SIG))
    { _eventHandler->setButtonReleaseCallback(fcn); }

    void setVREventCallback(void (*fcn)(VR_SIG))
    { _eventHandler->setVREventCallback(fcn); }
    
    inline void setID(unsigned int id) { _winID = id; }
    inline unsigned int getID() const { return _winID; }
    
    bool getUseVR() { return _useVR; }

    const OpenVRDevice* getOpenVRDevice() const { return _ovrDevice; }

    void setWorldUnitsPerMeter(double worldUnitsPerMeter)
    {
      if (_useVR) _ovrDevice->setWorldUnitsPerMeter(worldUnitsPerMeter);
    }
    double getWorldUnitsPerMeter()
    {
      if (_useVR) return _ovrDevice->getWorldUnitsPerMeter();
      else return 1.0; // Unused if VR is disabled
    }

    void setWorldUnitsPerMeterLimits(const double& minWorldUnitsPerMeter, const double& maxWorldUnitsPerMeter)
    {
      if (_useVR) _ovrDevice->setWorldUnitsPerMeterLimits(minWorldUnitsPerMeter, maxWorldUnitsPerMeter);
    }
    void getWorldUnitsPerMeterLimits(double &minWorldUnitsPerMeter, double &maxWorldUnitsPerMeter)
    {
      if (_useVR) _ovrDevice->getWorldUnitsPerMeterLimits(minWorldUnitsPerMeter, maxWorldUnitsPerMeter);
    }

    void setUserHeight(const double &height)
    {
      if (_useVR) _ovrDevice->setUserHeight(height);
    }

    virtual void run();
    
    void printInfo();

    void captureWindow();

    void setWindowCaptureFile(const std::string& fname, const std::string& fext);
    
    void setWindowCaptureKey(int key)
    { _screenCaptureHandler->setKeyEventTakeScreenShot(key); }
    
  protected:
    virtual ~WindowProxy();
    
    bool setupWindow();
    void collectScenes();
    void frame();
    
    unsigned int _winID;
    
    unsigned int _nRow, _nCol; // Number of rows/columns in this window's grid
    
    bool _isEmbedded; // True if the user wants to provide their own OpenGL window
    
    RenderList _renderList;  // List of subwindows to be rendered
    
    typedef std::set<FrameManager*> SceneSet;
    SceneSet _scenes; // Set of all unique scenes
    
    osg::ref_ptr<osgViewer::CompositeViewer> _viewer;
    
    osg::ref_ptr<osgViewer::GraphicsWindow> _window;
    
    osg::ref_ptr<EmbeddedGraphics> _embeddedGraphics;
    
    osg::ref_ptr<WindowEventHandler> _eventHandler;
    
    osg::ref_ptr<osgViewer::StatsHandler> _statsHandler;
    
    osg::ref_ptr<osgViewer::ScreenCaptureHandler> _screenCaptureHandler;

    FramerateLimiter _frameThrottle; // Controls animation framerate

    AnimationState _animationState; // Current animation state
    bool _pauseAnimation;           // Indicate that animation should be paused
    bool _timePaused;
    osg::Timer_t _Tref;
    double _currTime, _offsetTime, _timeScale;
    double _minTime, _maxTime;
    osg::observer_ptr<WindowProxy> _timeSyncWinProxy;
    
    bool _useVR; // Whether to use VR rendering
    osg::ref_ptr<OpenVRDevice> _ovrDevice; // OpenVR interface
    osg::ref_ptr<VRTextureBuffer> _vrTextureBuffer; // VR texture buffers
  };

}

#endif