SO3Engine/SO3Renderer/StereoManager.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.
-----------------------------------------------------------------------------
*/

// Last update jan 19 2010

#ifndef _STEREOMANAGER_H_
#define _STEREOMANAGER_H_

#include "Ogre.h"
#include <map>

namespace Ogre
{
        class StereoManager
        {
        public:
                enum StereoMode
                {
                        SM_NONE,
                        SM_ANAGLYPH_RC,
                        SM_ANAGLYPH_YB,
                        SM_DUALOUTPUT,
                        SM_INTERLACED_V,
                        SM_INTERLACED_H,
                        SM_INTERLACED_CB,


                        SM_LIMIT
                        //SM_SHUTTERGLASSES
                };

                struct StereoModeDescription
                {
                        StereoModeDescription() {}
                        StereoModeDescription(const String &name) :
                                mName(name), mUsesCompositor(false), mMaterialName("") {}
                        StereoModeDescription(const String &name, const String &materialName) :
                                mName(name), mUsesCompositor(true), mMaterialName(materialName) {}
                        StereoModeDescription &operator=(const StereoModeDescription &desc)
                        {
                                mName = desc.mName;
                                mMaterialName = desc.mMaterialName;
                                mUsesCompositor = desc.mUsesCompositor;
                                return *this;
                        }
                        String mName;
                        String mMaterialName;
                        bool mUsesCompositor;
                };

                typedef std::map<StereoMode, StereoModeDescription> StereoModeList;

        protected:
                class StereoCameraListener : public RenderTargetListener
                {
                        Vector3 mOldPos;
                        Vector2 mOldOffset;
                        uint32 mOldVisibilityMask;
                        StereoManager *mStereoMgr;
                        Camera *mCamera;
                        Viewport *mViewport;
                public:
                        bool mIsLeftEye;
                        void init(StereoManager *stereoMgr, Viewport *viewport, bool isLeftCamera);
        //              virtual void preRenderTargetUpdate (const RenderTargetEvent& evt);
        //              virtual void postRenderTargetUpdate  (const RenderTargetEvent& evt);
                        virtual void preViewportUpdate (const RenderTargetViewportEvent &evt);
                        virtual void postViewportUpdate (const RenderTargetViewportEvent &evt);
                };
                friend class StereoCameraListener;

                class DeviceLostListener : public RenderSystem::Listener
                {
                        StereoManager *mStereoMgr;
                public:
                        void init(StereoManager *stereoMgr);
                        virtual void eventOccurred (const String &eventName, const NameValuePairList *parameters);
                };
                friend class DeviceLostListener;

                Camera *mCamera;
                StereoCameraListener mLeftCameraListener, mRightCameraListener;
                DeviceLostListener mDeviceLostListener;
                Viewport *mLeftViewport, *mRightViewport;
                uint32 mLeftMask, mRightMask;
                CompositorInstance *mCompositorInstance;

                /* config */
                StereoModeList mAvailableModes;
                StereoMode mStereoMode;
                Real mEyesSpacing;
                Real mFocalLength;
                bool mFocalLengthInfinite;
                bool mIsFocalPlaneFixed;
                Real mScreenWidth;
                bool mIsInversed;
                bool mIsCustomProjection;
                Matrix4 mLeftCustomProjection, mRightCustomProjection;
                //String mConfigFileName;

                /* members for anaglyph only  */
                bool mAreOverlaysEnabled;
                Viewport *mCompositorViewport;

                /* dependencies */
                typedef std::map<RenderTarget *, bool> RenderTargetList;
                //typedef std::list<RenderTarget *> RenderTargetList;
                RenderTargetList mRenderTargetList;

                /* debug plane */
                SceneManager *mSceneMgr;
                Entity *mDebugPlane;
                SceneNode *mDebugPlaneNode;
                String mLeftMaterialName, mRightMaterialName;

                
                void initCompositor(Viewport *viewport, const String &materialName, Viewport *&out_left, Viewport *&out_right);
                void shutdownCompositor(void);
                void initListeners(Viewport* leftViewport, Viewport* rightViewport);
                void shutdownListeners(void);
                
                void updateCamera(Real delta);

                void init(Viewport* leftViewport, Viewport* rightViewport);

                void updateAllDependentRenderTargets(bool isLeftEye);
                void chooseDebugPlaneMaterial(bool isLeftEye);

        public:
                //--------------init--------------
                StereoManager(void);
                ~StereoManager(void);
                void init(Viewport* leftViewport, Viewport* rightViewport, const String &fileName);
                void init(Viewport* leftViewport, Viewport* rightViewport, StereoMode mode);

                void shutdown(void);

                //--------------dependencies--------------
                void addRenderTargetDependency(RenderTarget *renderTarget);
                void removeRenderTargetDependency(RenderTarget *renderTarget);

                //--------------debug plane--------------
                void createDebugPlane(SceneManager *sceneMgr, const String &leftMaterialName = "", const String &rightMaterialName = "");
                void destroyDebugPlane(void);
                void enableDebugPlane(bool enable);
                void toggleDebugPlane(void);
                void updateDebugPlane(void);

                //--------------accessors--------------
                inline StereoMode getStereoMode(void) const {return mStereoMode;}

                inline Camera *getCamera(void) const {return mCamera;}
                inline void setCamera(Camera *cam) {mCamera = cam;}

                inline Real getEyesSpacing(void) const {return mEyesSpacing;}
                inline void setEyesSpacing(Real l) {mEyesSpacing = l;}

                void setFocalLength(Real l);
                
                Real getFocalLength(void) const;

                void setFocalLengthInfinite(bool isInfinite = true);
                inline bool isFocalLengthInfinite(void) const { return mFocalLengthInfinite; }

                inline void fixFocalPlanePos(bool fix) {mIsFocalPlaneFixed = fix;}
                inline void setScreenWidth(Real w) {mScreenWidth = w;}
                void useScreenWidth(Real w);

                void setCustomProjectonMatrices(bool enable, const Matrix4 &leftMatrix, const Matrix4 &rightMatrix);
                void getCustomProjectonMatrices(bool &enabled, Matrix4 &leftMatrix, Matrix4 &rightMatrix) const;

                void inverseStereo(bool inverse);
                bool isStereoInversed(void) const {return mIsInversed;}

                void setVisibilityMask(uint32 leftMask, uint32 rightMask);
                void getVisibilityMask(uint32 &outLeftMask, uint32 &outRightMask) const;

                Viewport *getLeftViewport(void) const { return mLeftViewport; }
                Viewport *getRightViewport(void) const { return mRightViewport; }

                //--------------config--------------
                void saveConfig(const String &filename) const;
                StereoMode loadConfig(const String &filename);
        };
}

#endif

---