SO3StereoManager.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source is part of the Stereoscopy manager for OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/
-----------------------------------------------------------------------------
* Copyright (c) 2008, Mathieu Le Ber, AXYZ-IMAGES
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*     * Redistributions of source code must retain the above copyright
*       notice, this list of conditions and the following disclaimer.
*     * Redistributions in binary form must reproduce the above copyright
*       notice, this list of conditions and the following disclaimer in the
*       documentation and/or other materials provided with the distribution.
*     * Neither the name of the AXYZ-IMAGES nor the
*       names of its contributors may be used to endorse or promote products
*       derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY Mathieu Le Ber ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL Mathieu Le Ber BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
// Heavily modified by OS3D Team.
*/
 
#ifndef _SO3_STEREO_MANAGER_H_
#define _SO3_STEREO_MANAGER_H_
 
#include "SCOLBasic/SO3Prerequisites.h"
#include "SO3Utils/SO3Point.h"
 
namespace SO3
{
  class StereoManager
        {
        public:
                enum StereoMode
                {
                        SO3_NONE_STEREO                      = 0,
                        SO3_ANAGLYPH_RC_STEREO   = 1, 
                        SO3_ANAGLYPH_YB_STEREO   = 2, 
                        SO3_INTERLACED_V_STEREO  = 3, 
                        SO3_INTERLACED_H_STEREO  = 4, 
                        SO3_INTERLACED_CB_STEREO = 5, 
      SO3_SIDE_BY_SIDE_STEREO  = 6, 
      SO3_UP_DOWN_STEREO       = 7, 
      SO3_QUAD_BUFFER_STEREO   = 8, 
      SO3_OCULUS_STEREO        = 9, 
      SO3_OCULUS2_STEREO       = 10,
      SO3_CARDBOARD_STEREO     = 11,
      SO3_OPENVR_STEREO        = 12,
      SO3_OCULUSM_STEREO       = 13,
      SO3_OPENXR_STEREO        = 14,
      SO3_MONO_STEREO          = 15
                };
  protected:
  private:
    typedef std::unordered_map<std::string, bool> CompositorList;
    typedef std::list<std::string> CompositorIndexList;
    class StereoCameraListener; // Pre-declaration for StereoViewportData.
    class StereoRTTListener;
    class StereoViewportListener;
    class StereoFrameListener;
    struct StereoViewportData
    {
      CompositorList mCompList;
      CompositorIndexList mCompIndexList;
      bool mFlipEyes;
      bool mShadowEnable;
      bool mOverlayEnable;
      bool mSkyEnable;
      Ogre::String mMaterialScheme;
      double frameTime;
      Ogre::ColourValue mOldBackgroundColor;
      Ogre::uint32 mMask;
      Ogre::Vector3 mOldPos;
                        Ogre::Vector2 mOldOffset;
      Ogre::Real mOldRatio;
      Ogre::Radian mOldFOV;
      Ogre::Matrix4 mOldMatrix;
      Ogre::Matrix4 mBaseCameraMatrix;
      bool mOldUseCustomMatrix;
      Ogre::Camera* mCamera;
      StereoCameraListener* leftCameraListener;
      StereoCameraListener* rightCameraListener;
      StereoRTTListener* rttListener;
      StereoViewportListener* viewportListener;
      StereoFrameListener* frameListener;
      Ogre::Viewport* mOriginalViewport;
      Ogre::Vector2 mOriginalViewportSize;
      Ogre::Viewport* mLastLeftViewport;
      Ogre::Viewport* mLastRightViewport;
      Ogre::SceneManager* mScene;
      Ogre::SceneManager* mStereoScene;
      Ogre::Rectangle2D* mRect;
      Ogre::SceneNode* mStereoCameraNode;
      Ogre::Camera* mStereoCamera;
      Ogre::ColourValue mBackgroundColor;
      Ogre::TexturePtr mLeftRenderTexture;
      Ogre::TexturePtr mRightRenderTexture;
      Ogre::Entity* mLeftEntity;
      Ogre::Entity* mRightEntity;
      StereoViewportData() : mFlipEyes(false), mShadowEnable(false), mOverlayEnable(false), mSkyEnable(false), frameTime(0.0), mOldBackgroundColor(Ogre::ColourValue::Black), mMask(0xffffffff), mOldPos(Ogre::Vector3::ZERO), mOldOffset(Ogre::Vector2::ZERO), mOldRatio(0.0f), mOldFOV(Ogre::Radian()), mOldMatrix(Ogre::Matrix4::IDENTITY), mBaseCameraMatrix(Ogre::Matrix4::IDENTITY), mOldUseCustomMatrix(false), mCamera(0), leftCameraListener(0), rightCameraListener(0), rttListener(0), viewportListener(0), frameListener(0), mOriginalViewport(0), mLastLeftViewport(0), mLastRightViewport(0), mScene(0), mStereoScene(0), mRect(0), mStereoCameraNode(0), mStereoCamera(0), mBackgroundColor(Ogre::ColourValue::Black), mLeftRenderTexture(), mRightRenderTexture(), mLeftEntity(0), mRightEntity(0) {}
    };
 
    class StereoRTTListener : public Ogre::Resource::Listener
                {
    public:
    protected:
    private:
                        StereoManager* mStereoMgr;
      StereoManager::StereoViewportData* viewportData;
 
                public:
      StereoRTTListener(StereoManager* stereoMgr, StereoManager::StereoViewportData* stereoViewportData);
 
                        virtual void loadingComplete(Ogre::Resource* resource);
 
      virtual void unloadingComplete(Ogre::Resource* resource);
 
    protected:
    private:
                };
 
    class StereoCameraListener : public Ogre::RenderTargetListener
                {
    public:
    protected:
    private:
                        StereoManager* mStereoMgr;
      StereoManager::StereoViewportData* viewportData;
                        Ogre::Viewport* mOriginalViewport;
      bool mIsLeftEye;
 
                public:
      StereoCameraListener(StereoManager* stereoMgr, bool isLeftCamera, Ogre::Viewport* originalViewport, StereoManager::StereoViewportData* stereoViewportData);
 
                        virtual void preRenderTargetUpdate(const Ogre::RenderTargetEvent& evt);
 
                        virtual void postRenderTargetUpdate(const Ogre::RenderTargetEvent& evt);
 
    protected:
    private:
                };
 
    class StereoViewportListener : public Ogre::RenderTargetListener
                {
    public:
    protected:
    private:
                        StereoManager* mStereoMgr;
      StereoManager::StereoViewportData* viewportData;
 
                public:
      StereoViewportListener(StereoManager* stereoMgr, StereoManager::StereoViewportData* stereoViewportData);
 
                        virtual void preRenderTargetUpdate(const Ogre::RenderTargetEvent& evt);
 
                        virtual void postRenderTargetUpdate(const Ogre::RenderTargetEvent& evt);
 
    protected:
    private:
                };
 
    class StereoFrameListener : public Ogre::FrameListener
                {
    public:
    protected:
    private:
                        StereoManager* mStereoMgr;
      StereoManager::StereoViewportData* viewportData;
 
                public:
      StereoFrameListener(StereoManager* stereoMgr, StereoManager::StereoViewportData* stereoViewportData);
 
                        virtual bool frameStarted(const Ogre::FrameEvent& evt);
 
                        virtual bool frameRenderingQueued(const Ogre::FrameEvent& evt);
 
                        virtual bool frameEnded(const Ogre::FrameEvent& evt);
 
    protected:
    private:
                };
 
    class DeviceLostListener : public Ogre::RenderSystem::Listener
                {
    public:
    protected:
    private:
                        StereoManager* mStereoMgr;
 
                public:
                        DeviceLostListener(StereoManager* stereoMgr);
 
      virtual void eventOccurred(const Ogre::String &eventName, const Ogre::NameValuePairList *parameters);
    protected:
    private:
                };
    typedef std::map<StereoMode, Ogre::String> StereoModeList;
                StereoModeList mAvailableModes;
    typedef std::map<Ogre::Viewport*, StereoViewportData*> StereoViewports;
    StereoViewports stereoViewports;
                DeviceLostListener* mDeviceLostListener;
    StereoMode mStereoMode;
                Ogre::Real mEyesSpacing;
                Ogre::uint32 mLeftMask, mRightMask;
                friend class DeviceLostListener;
                friend class StereoCameraListener;
    friend class StereoViewportListener;
    friend class StereoFrameListener;
 
    SWindow* mBuffer;
                bool mIsCustomProjection;
    bool mIsCustomOffset;
    bool mIsCustomRatio;
    bool mIsCustomFOV;
    bool mIsCustomDistortion;
    bool mIsCustomChromAbCorrection;
    bool mRotateView;
    Ogre::Vector4 mDistortion;
    Ogre::Vector4 mChromAbCorrection;
                Ogre::Matrix4 mLeftCustomProjection, mRightCustomProjection;
    Ogre::Matrix4 mLeftStartWarpMatrix, mLeftEndWarpMatrix;
    Ogre::Matrix4 mRightStartWarpMatrix, mRightEndWarpMatrix;
    Ogre::Real mCenterOffset;
    Ogre::Real mRatio;
    Ogre::Radian mFOV;
    Ogre::Vector2 mLeftUVScale;
    Ogre::Vector2 mLeftUVOffset;
    Ogre::Vector2 mRightUVScale;
    Ogre::Vector2 mRightUVOffset;
    SO3::SPoint<int> mLeftRenderTextureSize;
    SO3::SPoint<int> mRightRenderTextureSize;
    Ogre::MeshPtr mLeftMesh;
    Ogre::MeshPtr mRightMesh;
    bool mHasExternalWindow;
    SO3::SPoint<int> mWindowPos;
    SO3::SPoint<int> mWindowSise;
    int mWindowMonitorIndex;
    Ogre::RenderWindow* mExternalWindow;
    Ogre::Viewport* mExternalViewport;
        public:
                StereoManager(SWindow* buffer);
 
                ~StereoManager();
 
    void ReloadStereo();
 
    void RestoreStereoCamera(Ogre::Viewport* ogreViewportInstance);
 
    void UpdateStereoCamera(Ogre::Viewport* ogreViewportInstance, Ogre::Camera* camera);
 
    void UpdateStereoCameraMatrix(Ogre::Viewport* ogreViewportInstance, Ogre::Camera* camera);
 
    /*
    */
    bool UpdateStereoCompositorState(Ogre::Viewport* ogreViewportInstance, const Ogre::String compname, bool state);
 
    void RegisterViewport(SViewPort* viewportInstance);
 
    void UnregisterViewport(SViewPort* viewportInstance);
 
    void SynchViewportSetup(SViewPort* viewportInstance, bool overlay = false, bool shadow = false);
 
    bool IsViewportRegistered(Ogre::Viewport* ogreViewportInstance);
 
    StereoMode GetStereoMode() const;
 
    void SetStereoMode(const StereoMode& newStereoMode);
 
                Ogre::Real GetEyesSpacing() const;
 
    void SetEyesSpacing(Ogre::Real l);
 
    void SetStereoProjectionOffset(Ogre::Real offset);
 
    void SetStereoAspectRatio(Ogre::Real ratio);
 
    Ogre::Real GetStereoAspectRatio();
 
    void SetStereoFOVy(Ogre::Real fov);
 
    void SetRotateView(bool state);
 
    bool GetRotateView();
 
    void SetStereoChromaticAbCorrection(bool enable, Ogre::Vector4 chromAbC);
 
    void SetStereoDistortion(bool enable, Ogre::Vector4 dist);
 
                void SetCustomProjectonMatrices(bool enable, const Ogre::Matrix4 &leftMatrix, const Ogre::Matrix4 &rightMatrix);
                void GetCustomProjectonMatrices(bool &enabled, Ogre::Matrix4 &leftMatrix, Ogre::Matrix4 &rightMatrix) const;
    void SetTimeWarpMatrix(const Ogre::Matrix4 &leftStartMatrix, const Ogre::Matrix4 &leftEndMatrix, const Ogre::Matrix4 &rightStartMatrix, const Ogre::Matrix4 &rightEndMatrix);
 
    void SetStereoMeshUVConfig(Ogre::Vector2 leftuvscale, Ogre::Vector2 leftuvoffset, Ogre::Vector2 rightuvscale, Ogre::Vector2 rightuvoffset);
    void SetStereoMeshRttSize(SO3::SPoint<int> leftsize, SO3::SPoint<int> rightsize);
    void SetStereoMeshLeft(std::vector<Ogre::Vector3> vertices, std::vector<std::vector<Ogre::Vector2> > uvs, std::vector<Ogre::Real> vignetteColor, std::vector<Ogre::Real> warp, std::vector<int> indexs);
    void SetStereoMeshRight(std::vector<Ogre::Vector3> vertices, std::vector<std::vector<Ogre::Vector2> > uvs, std::vector<Ogre::Real> vignetteColor, std::vector<Ogre::Real> warp, std::vector<int> indexs);
    void SetStereoWindow(SO3::SPoint<int> pos, SO3::SPoint<int> size, int index, bool state);
    std::array<SCOL_PTR_TYPE, 2> GetStereoTextures();
    std::array<SO3::SPoint<int>, 2> GetStereoViewportSize();
 
  protected:
    void ReleaseRttTarget(StereoViewportData* viewportData);
 
    void ConstructRttTarget(StereoViewportData* viewportData);
  private:
    void InitializeViewport(Ogre::Viewport* viewport, StereoViewportData* viewportData);
 
    void ShutdownViewport(Ogre::Viewport* viewport, StereoViewportData* viewportData);
 
                void InitializeStereo(Ogre::Viewport* viewport, StereoViewportData* viewportData);
 
    void ShutdownStereo(Ogre::Viewport* viewport, StereoViewportData* viewportData);
 
                void InitializeListeners(Ogre::Viewport* viewport, StereoViewportData* viewportData);
 
                void ShutdownListeners(Ogre::Viewport* viewport, StereoViewportData* viewportData);
        };
}
 
#endif