VRExampleEngine.h

Go to the documentation of this file.

#ifndef GlobeEngine_VRExampleEngine_h
#define GlobeEngine_VRExampleEngine_h

#include <math.h>
#include <ctime>
#include <iostream>
#include <stdio.h>
#include <vector>
#include "OpenGL_Includes.h"
#include "Engine.h"
#include "Shader.h"
#include "FlightCamera.h"
#include "Common.h"
#include "CoordinateSystem.h"
#include "SceneStateSet.h"
#include "DrawableComponent.h"
#include "Cube.h"
#include "DebugLogger.h"
#include "Timer.h"
#include "MemoryState.h"
#include "DebugMap.h"
#include "VRExampleComposition.h"
#include "Plane.h"
#include "PointCloud.h"
#include "Mesh.h"

#include <openvr.h>

namespace geVRExample {

    class VRExampleEngine : public ge::Engine
    {
        
    public:
        VRExampleEngine();
        ~VRExampleEngine();
        
        void clear();
        void destroy();
        void create();
        
        // overrides from ge::Engine
        void initializeScene(std::string _projectsrcPath=0);
        void drawScene();
        void resize(int _w, int _h);
        void update();

        void updateFramebufferStandardID();
        void setDebugMapsEnabled(bool _in);

        void drawFrame(std::shared_ptr<ge::Camera> _cam,
                       vr::Hmd_Eye nEye);

        std::string getTrackedDeviceString(vr::IVRSystem *pHmd, vr::TrackedDeviceIndex_t unDevice, vr::TrackedDeviceProperty prop, vr::TrackedPropertyError *peError = NULL);
        bool initVRCompositor();
        void shutdown();
        vmml::Vector2ui getStereoRenderTargets();
        void setupRenderModelForTrackedDevice(vr::TrackedDeviceIndex_t unTrackedDeviceIndex);
        vmml::Matrix4f getHMDMatrixProjectionEye(vr::Hmd_Eye nEye, float _nearClipPlane, float _farClipPlane);
        vmml::Matrix4f getHMDMatrixPoseEye(vr::Hmd_Eye nEye);
        void updateHMDMatrixPose();
        vmml::Matrix4f VRExampleEngine::getCurrentViewProjectionMatrix(vr::Hmd_Eye nEye);

        void nextModel() { currentModel = (currentModel + 1) % pointclouds.size(); }

        void nextRenderMode() { currentRenderMode = RenderMode( (currentRenderMode + 1) % (both + 1) ); }

    private:
        std::shared_ptr<ge::Shader> programForUtilities;
        std::shared_ptr<ge::Shader> programForDebug;
        std::shared_ptr<ge::Shader> programForPointClouds;
        std::shared_ptr<ge::Shader> programForMeshes;
        ge::SceneStateSet sceneStates[4];

        enum RenderMode { cloud, both };

        RenderMode currentRenderMode;
        int currentModel;
        std::vector<std::shared_ptr<geData::PointCloud>> pointclouds;
        std::vector<std::shared_ptr<geData::Mesh>> meshes;
        float rot;
        
        // Debugger functionality
        geUtil::DebugLogger openglDebugLogger;
        ge::Timer openglTimer;
        geUtil::MemoryState openglMemory;
        geUtil::DebugMap debugmaps[2];

        ge::FrameBufferObject earthBuffer;
        
        vr::IVRSystem* hmd;
        vr::IVRRenderModels* renderModels;
        std::string driverString;
        std::string displayString;
        std::string modelString;
        vr::TrackedDevicePose_t trackedDevicePose[vr::k_unMaxTrackedDeviceCount];
        vmml::Matrix4f m_rmat4DevicePose[vr::k_unMaxTrackedDeviceCount];
        bool showTrackedDevice[vr::k_unMaxTrackedDeviceCount];
        float freq;
        int iValidPoseCount;
        int iValidPoseCount_Last;
        std::string poseClassesString;  // what classes we saw poses for this frame
        char devClassChar[vr::k_unMaxTrackedDeviceCount];   // for each device, a character representing its class
        //vmml::Matrix4f convertSteamVRMatrixToVMMLMat4(const vr::HmdMatrix34_t &matPose);

        vmml::Matrix4f mat4HMDPose;
        vmml::Matrix4f mat4eyePosLeft;
        vmml::Matrix4f mat4eyePosRight;

        vmml::Matrix4f projLeft;
        vmml::Matrix4f projRight;

        bool debugMapsEnabled;
        bool debugWithoutVive;

        unsigned int screenWidth;
        unsigned int screenHeight;
    };
}
#endif