CameraGroup.hxx

Go to the documentation of this file.

// Copyright (C) 2008  Tim Moore
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
#ifndef CAMERAGROUP_HXX
#define CAMERAGROUP_HXX 1
 
#include <map>
#include <string>
#include <vector>
#include <memory>
 
#include <osg/Matrix>
#include <osg/ref_ptr>
#include <osg/Referenced>
#include <osg/Node>
#include <osg/TextureRectangle>
#include <osg/Texture2D>
#include <osg/TexGen>
#include <osgUtil/RenderBin>
#include <osgViewer/View>
 
#include <simgear/scene/viewer/Compositor.hxx>
 
namespace osg
{
class Camera;
}
 
namespace osgViewer
{
class Viewer;
}
 
class SGPropertyNode;
 
namespace flightgear
{
 
class CameraGroupListener;
class GraphicsWindow;
class CameraGroup;

struct CameraInfo : public osg::Referenced
{
    enum Flags
    {
        VIEW_ABSOLUTE = 0x1, 
        PROJECTION_ABSOLUTE = 0x2, 
        ORTHO = 0x4,               
        GUI = 0x8,                 
        DO_INTERSECTION_TEST = 0x10,
        FIXED_NEAR_FAR = 0x20,     
        ENABLE_MASTER_ZOOM = 0x40, 
        VR_MIRROR = 0x80,          
        SPLASH = 0x100             
    };
 
    CameraInfo(unsigned flags_)     :
        flags(flags_) { }

    std::string name;
    unsigned flags;
    simgear::compositor::Compositor::MVRInfo mvr;
    double physicalWidth = 0;
    double physicalHeight = 0;
    double bezelHeightTop = 0;
    double bezelHeightBottom = 0;
    double bezelWidthLeft = 0;
    double bezelWidthRight = 0;
    const CameraInfo *relativeCameraParent = nullptr;
    osg::Vec2d parentReference[2];
    osg::Vec2d thisReference[2];
    osg::Matrix viewOffset;
    osg::Matrix projOffset;
    osg::Matrix viewMatrix, projMatrix;
    std::unique_ptr<simgear::compositor::Compositor> compositor;
    std::string compositor_path;
 
    struct ReloadCompositorCallback : public virtual osg::Referenced
    {
        virtual void preReloadCompositor(CameraGroup *, CameraInfo *) = 0;
        virtual void postReloadCompositor(CameraGroup *, CameraInfo *) = 0;
    };
    osg::ref_ptr<ReloadCompositorCallback> reloadCompositorCallback;
 
};
 
class CameraGroup : public osg::Referenced
{
public:
    CameraGroup(osgViewer::View* viewer);
    virtual ~CameraGroup();

    static void buildDefaultGroup(osgViewer::View* view);
    static void setDefault(CameraGroup* group) { _defaultGroup = group; }
    static CameraGroup* getDefault() { return _defaultGroup.get(); }
    osgViewer::View* getView() { return _viewer.get(); }
    CameraInfo* buildCamera(SGPropertyNode* cameraNode);
    void removeCamera(CameraInfo *info);
    void buildSplashCamera(SGPropertyNode* cameraNode,
                           GraphicsWindow* window = 0);
    void buildGUICamera(SGPropertyNode* cameraNode,
                        GraphicsWindow* window = 0);
    void update(const osg::Vec3d& position,
                const osg::Quat& orientation);
    void setCameraParameters(float vfov, float aspectRatio);
    void setCameraCullMasks(osg::Node::NodeMask nm);
    void setLODScale(float scale);
    void resized();

    double getMasterAspectRatio() const;
 
    CameraInfo *getGUICamera() const;
 
    typedef std::vector<osg::ref_ptr<CameraInfo>> CameraList;
    const CameraList& getCameras();
 
protected:
    friend CameraGroupListener;
    friend bool computeIntersections(const CameraGroup* cgroup,
                                     const osg::Vec2d& windowPos,
                                     osgUtil::LineSegmentIntersector::Intersections&
                                     intersections);
    friend void reloadCompositors(CameraGroup *cgroup);
 
    CameraList _cameras;
    osg::ref_ptr<osgViewer::View> _viewer;
    static osg::ref_ptr<CameraGroup> _defaultGroup;
    std::unique_ptr<CameraGroupListener> _listener;
 
    // Near, far for the master camera if used.
    float _zNear;
    float _zFar;
    float _nearField;

    simgear::compositor::Compositor *buildVRMirrorCompositor(osg::GraphicsContext *gc,
                                                             osg::Viewport *viewport);
    static CameraGroup* buildCameraGroup(osgViewer::View* viewer,
                                         SGPropertyNode* node);
};

osg::Camera* getGUICamera(CameraGroup* cgroup);
bool computeIntersections(const CameraGroup* cgroup,
                          const osg::Vec2d& windowPos,
                          osgUtil::LineSegmentIntersector::Intersections&
                          intersections);
void warpGUIPointer(CameraGroup* cgroup, int x, int y);

void reloadCompositors(CameraGroup *cgroup);
 
}
 
#endif