omnistereo.h

Go to the documentation of this file.

#ifndef ALLOFW_OMNISTEREO_H
#define ALLOFW_OMNISTEREO_H

// Omnistereo Rendering.
#include "common.h"
#include "config.h"
#include "math/math.h"
#include "opengl.h"

namespace allofw {

    typedef GLuint GLTextureID;

    class OmniStereo {
    public:
        typedef int StereoMode;
        static const int kStereoMode_Mono               =   0;  
        static const int kStereoMode_Left               = 100;  
        static const int kStereoMode_Right              = 101;  
        static const int kStereoMode_Active             = 200;  
        static const int kStereoMode_Dual_LR            = 300;  
        static const int kStereoMode_Dual_RL            = 301;  
        static const int kStereoMode_Anaglyph_Red_Cyan  = 400;  


        typedef int PanoramaMode;
        static const int kPanoramaModeEquirectangular   = 0;    


        typedef int Eye;
        static const int kEye        = 0;   
        static const int kEye_Left   = 0;   
        static const int kEye_Right  = 1;   


        typedef int CompositeMask;
        static const int kCompositeMask_Scene                     = 1 << 0;     
        static const int kCompositeMask_Back                      = 1 << 1;     
        static const int kCompositeMask_Front                     = 1 << 2;     
        static const int kCompositeMask_Panorama                  = 1 << 3;     
        static const int kCompositeMask_Panorama_Equirectangular  = 1 << 4;     
        static const int kCompositeMask_Panorama_Cubemap          = 1 << 5;     
        static const int kCompositeMask_Panorama_Cubemap_YUV420P  = 1 << 6;     


        // Stereo texture.
        struct StereoTexture {
            // In mono mode, we only use L.
            union {
                struct {
                    GLTextureID L;  
                    GLTextureID R;  
                };
                GLTextureID eyes[2]; 
            };
            StereoTexture() : L(0), R(0) { }
        };

        class Delegate {
        public:
            struct CaptureInfo {
                Pose pose;
                Eye eye;
                float eye_separation;
                float sphere_radius;

                Quaternion viewport_rotation;
                float viewport_fovy;
                float viewport_aspect;
                float near;
                float far;

                OmniStereo* omnistereo;

                void setUniforms(GLuint program) const {
                    omnistereo->setUniforms(program, *this);
                }
            };

            virtual void onCaptureViewport(const CaptureInfo& info);

            virtual ~Delegate() { }
        };

        virtual void setResolution(int size = 1024) = 0;

        virtual void setStereoMode(StereoMode stereo_mode) = 0;

        virtual void setPose(const Pose& pose) = 0;
        virtual void setLens(float eye_separation = 0.0f, float sphere_radius = 1.0f) = 0;
        virtual void setClipRange(float near, float far) = 0;

        virtual StereoTexture getCubemapTexture() = 0;

        virtual StereoTexture getDepthCubemapTexture() = 0;

        virtual void capture() = 0;

        struct CompositeInfo {
            CompositeMask mask;
            StereoTexture back, front;
            union {
                StereoTexture panorama;
                StereoTexture panorama_planes[3];
            };
            CompositeInfo() : mask(kCompositeMask_Scene) { }
        };

        virtual void composite(const Rectangle2i& viewport, const CompositeInfo& info = CompositeInfo()) = 0;

        virtual GLuint compositeCustomizeShader(const char* code) = 0;

        virtual void compositeRestoreShader() = 0;

        virtual const char* getShaderCode() = 0;

        virtual void setUniforms(GLuint program, const Delegate::CaptureInfo& info) = 0;

        virtual void setDelegate(Delegate* delegate) = 0;

        static OmniStereo* Create(Configuration* conf);
        static void Destroy(OmniStereo* omnistereo);

    protected:
        virtual ~OmniStereo();
    };

    class WarpBlend {
    public:

        struct WarpData {
            Vector3f* data;
            Size2i size;
        };

        struct BlendData {
            Vector4f* data;
            Size2i size;
        };

        struct ViewportInfo {
            Rectangle2 viewport;
            Size2i screen_resolution;
            bool enforce_aspect_ratio;
            float aspect_ratio;
        };

        virtual int getViewportCount() = 0;

        virtual ViewportInfo getViewport(int viewport_index) = 0;

        virtual BlendData getBlendData(int viewport_index) = 0;

        virtual WarpData getWarpData(int viewport_index) = 0;

        virtual GLTextureID getBlendTexture(int viewport_index) = 0;

        virtual GLTextureID getWarpTexture(int viewport_index) = 0;

        static WarpBlend* CreateEquirectangular(int width, int height);

        static WarpBlend* CreatePerspective(int width, int height, float fov);

        static WarpBlend* LoadAllosphereCalibration(const char* calibration_path, const char* hostname = nullptr);

        static void Destroy(WarpBlend* warpblend);

    protected:
        virtual ~WarpBlend();
    };
}

#endif