OVRWindow.h

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014 Jeremy Othieno.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#ifndef OVRWINDOW_H
#define OVRWINDOW_H
#define GL_GLEXT_PROTOTYPES

#include <OVR_CAPI.h>
#include <QWindow>
#include <QOpenGLFunctions>
#include <QMatrix4x4>


union ovrGLConfig;
union ovrGLTexture_s;
typedef ovrGLTexture_s ovrGLTexture;

class OVRWindow : public QWindow, protected QOpenGLFunctions
{
Q_OBJECT
public:
   enum class Feature : unsigned int
   {
      LowPersistence = ovrHmdCap_LowPersistence,
      LatencyTesting = ovrHmdCap_LatencyTest,
      DynamicPrediction = ovrHmdCap_DynamicPrediction,

      OrientationTracking = ovrSensorCap_Orientation,
      YawCorrection = ovrSensorCap_YawCorrection,
      PositionalTracking = ovrSensorCap_Position,

      ChromaticAberrationCorrection = ovrDistortionCap_Chromatic,
      Timewarp = ovrDistortionCap_TimeWarp,
      Vignette = ovrDistortionCap_Vignette,
   };
   enum class Vision
   {
      Monocular,
      Binocular
   };
   enum class LOD
   {
      Lowest,
      Low,
      Medium,
      High,
      Highest
   };
   struct FrameRenderContext
   {
      QMatrix4x4 view;
      struct
      {
         QMatrix4x4 perspective;
         QMatrix4x4 ortho;
      } projection;
   };
   OVRWindow(const unsigned int& index, const std::initializer_list<OVRWindow::Feature>& features);
   OVRWindow();
   virtual ~OVRWindow();
   bool hasValidGL() const;
   QOpenGLContext& getGL();
   const ovrHmdDesc& getDeviceInfo() const;
   const QSet<OVRWindow::Feature>& getEnabledFeatures() const;
   void enableFeature(const OVRWindow::Feature& feature, const bool enable = true);
   void enableFeatures(const std::initializer_list<OVRWindow::Feature>& features, const bool enable = true);
   bool isFeatureEnabled(const OVRWindow::Feature& feature) const;
   bool isFeatureSupported(const OVRWindow::Feature& feature) const;
   const OVRWindow::Vision& getVision() const;
   void setVision(const OVRWindow::Vision& vision);
   const OVRWindow::LOD& getLOD() const;
   void setLOD(const OVRWindow::LOD& lod);
   void enableDynamicLOD(const bool enable = true);
   float getIPD() const;
   void setIPD(const float& ipd);
   void forceZeroIPD(const bool& force);
   const float& getPixelDensity() const;
   void setPixelDensity(const float& density);
   const float& getNearClippingDistance() const;
   void setNearClippingDistance(const float& near);
   const float& getFarClippingDistance() const;
   void setFarClippingDistance(const float& far);
   bool isMultisamplingEnabled() const;
   void enableMultisampling(const bool enable = true);
protected:
   virtual void initializeGL();
   virtual void paintGL(const OVRWindow::FrameRenderContext& context, const float& dt);
   virtual void resizeGL(const unsigned int& width, const unsigned int& height);
   void makeCurrent();
   void doneCurrent();
   virtual void changeLOD(const OVRWindow::LOD& lod);
private:
   void updateGL();
   void requestUpdateGL();
   void configureGL();
   void paintGL();
   ovrGLConfig& getOvrGlConfig() const;
   ovrGLTexture& getOvrGlTexture(const ovrEyeType& eye) const;
   void sanitizeRenderTargetConfiguration();
   void sanitizeDeviceConfiguration();
   void sanitizeRenderingConfiguration();
   void adjustLOD(const float& dt, const unsigned int& tolerance);
   void resizeEvent(QResizeEvent* const) override final;
   void exposeEvent(QExposeEvent* const) override final;
   bool event(QEvent* const) override final;
   const OVRWindow::FrameRenderContext& getFrameRenderContext(const ovrEyeType& eye, const ovrPosef& pose);
   const ovrHmdDesc _device;
   QSet<OVRWindow::Feature> _enabledFeatures;
   bool _enableDynamicLOD;
   QOpenGLContext _gl;
   bool _pendingUpdateRequest;
   struct
   {
      GLuint fbo;
      GLuint pixel;
      GLuint depth;
      QSize resolution;
   } _renderTarget;
   ovrFovPort _FOV[ovrEye_Count];
   ovrEyeRenderDesc _renderInfo[ovrEye_Count];
   OVRWindow::FrameRenderContext _frameRenderContext[ovrEye_Count];
   float _nearClippingPlaneDistance;
   float _farClippingPlaneDistance;
   bool _forceZeroIPD;
   float _pixelDensity;
   OVRWindow::Vision _vision;
   OVRWindow::LOD _LOD;
   struct
   {
      bool renderTarget;
      bool rendering;
      struct { bool hmd, sensor; } device;
      bool projections[ovrEye_Count];
   } _dirty;
public slots:
   void toggleVision();
   void reduceLOD();
   void increaseLOD();
   void toggleDynamicLOD();
   void toggleMultisampling();
signals:
   void initialized();
   void LODChanged(const OVRWindow::LOD& currentLOD);
};

#endif // OVRWINDOW_H