src/Viewer/CameraGroup.hxx

   1 // Copyright (C) 2008  Tim Moore
   2 //
   3 // This program is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU General Public License as
   5 // published by the Free Software Foundation; either version 2 of the
   6 // License, or (at your option) any later version.
   7 //
   8 // This program is distributed in the hope that it will be useful, but
   9 // WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU General Public License
  14 // along with this program; if not, write to the Free Software
  15 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  16
  17 #ifndef CAMERAGROUP_HXX
  18 #define CAMERAGROUP_HXX 1
  19
  20 #include <map>
  21 #include <string>
  22 #include <vector>
  23 #include <memory>
  24
  25 #include <osg/Matrix>
  26 #include <osg/ref_ptr>
  27 #include <osg/Referenced>
  28 #include <osg/Node>
  29 #include <osg/TextureRectangle>
  30 #include <osg/Texture2D>
  31 #include <osg/TexGen>
  32 #include <osgUtil/RenderBin>
  33
  34 // For osgUtil::LineSegmentIntersector::Intersections, which is a typedef.
  35 #include <osgUtil/LineSegmentIntersector>
  36 namespace osg
  37 {
  38 class Camera;
  39 }
  40
  41 namespace osgViewer
  42 {
  43 class Viewer;
  44 }
  45
  46 class SGPropertyNode;
  47
  48 namespace flightgear
  49 {
  50
  51 class GraphicsWindow;
  52 class CameraViewportListener;
  53 class CameraGroupListener;
  54
  55 struct RenderBufferInfo {
  56     RenderBufferInfo(osg::Texture2D* t = 0, float s = 1.0 ) : texture(t), scaleFactor(s) {}
  57     osg::ref_ptr<osg::Texture2D> texture;
  58     float scaleFactor;
  59 };
  60 typedef std::map<std::string,RenderBufferInfo> RenderBufferMap;
  61 typedef std::map<osg::Camera::BufferComponent,std::string> AttachmentMap;
  62
  63 struct RenderStageInfo {
  64     RenderStageInfo(osg::Camera* camera_ = 0, int si = -1, bool fs = false)
  65         : camera(camera_), slaveIndex(si), scaleFactor(1.0f), fullscreen(fs)
  66         , resizable(true)
  67     {
  68     }
  69
  70     osg::ref_ptr<osg::Camera> camera;
  71     AttachmentMap buffers;
  72     int slaveIndex;
  73     float scaleFactor;
  74     bool fullscreen;
  75     bool resizable;
  76 };
  77
  78 extern const char* MAIN_CAMERA;
  79 extern const char* FAR_CAMERA;
  80 extern const char* GEOMETRY_CAMERA;
  81 extern const char* SHADOW_CAMERA;
  82 extern const char* LIGHTING_CAMERA;
  83 extern const char* DISPLAY_CAMERA;
  84
  85 typedef std::map<std::string,RenderStageInfo> CameraMap;
  86
  87 /** A wrapper around osg::Camera that contains some extra information.
  88  */
  89 struct CameraInfo : public osg::Referenced
  90 {
  91     CameraInfo(unsigned flags_)
  92         : flags(flags_),
  93           x(0.0), y(0.0), width(0.0), height(0.0),
  94           physicalWidth(0), physicalHeight(0), bezelHeightTop(0),
  95           bezelHeightBottom(0), bezelWidthLeft(0), bezelWidthRight(0),
  96           relativeCameraParent(~0u),
  97           bufferSize( new osg::Uniform("fg_BufferSize", osg::Vec2f() ) ),
  98           projInverse( new osg::Uniform( "fg_ProjectionMatrixInverse", osg::Matrixf() ) ),
  99           viewInverse( new osg::Uniform( "fg_ViewMatrixInverse",osg::Matrixf() ) ),
 100           view( new osg::Uniform( "fg_ViewMatrix",osg::Matrixf() ) ),
 101           worldPosCart( new osg::Uniform( "fg_CameraPositionCart", osg::Vec3f() ) ),
 102           worldPosGeod( new osg::Uniform( "fg_CameraPositionGeod", osg::Vec3f() ) ),
 103           du( new osg::Uniform( "fg_du",osg::Vec4() ) ),
 104           dv( new osg::Uniform( "fg_dv",osg::Vec4() ) )
 105     {
 106         shadowMatrix[0] = new osg::Uniform("fg_ShadowMatrix_0", osg::Matrixf());
 107         shadowMatrix[1] = new osg::Uniform("fg_ShadowMatrix_1", osg::Matrixf());
 108         shadowMatrix[2] = new osg::Uniform("fg_ShadowMatrix_2", osg::Matrixf());
 109         shadowMatrix[3] = new osg::Uniform("fg_ShadowMatrix_3", osg::Matrixf());
 110     }
 111
 112     ~CameraInfo();
 113
 114     /** Update and resize cameras
 115      */
 116     void updateCameras();
 117     void resized(double w, double h);
 118
 119     /** The name as given in the config file.
 120      */
 121     std::string name;
 122     /** Properties of the camera. @see CameraGroup::Flags.
 123      */
 124     unsigned flags;
 125
 126     /** Viewport parameters.
 127      */
 128     double x;
 129     double y;
 130     double width;
 131     double height;
 132     /** Physical size parameters.
 133      */
 134     double physicalWidth;
 135     double physicalHeight;
 136     double bezelHeightTop;
 137     double bezelHeightBottom;
 138     double bezelWidthLeft;
 139     double bezelWidthRight;
 140     /** The parent camera for relative camera configurations.
 141      */
 142     unsigned relativeCameraParent;
 143
 144     /** the camera objects
 145      */
 146     CameraMap cameras;
 147     void addCamera( const std::string& k, osg::Camera* c, int si = -1, bool fs = false ) { cameras[k].camera = c; cameras[k].slaveIndex = si; cameras[k].fullscreen = fs; }
 148     void addCamera( const std::string& k, osg::Camera* c, bool fs ) { cameras[k].camera = c; cameras[k].fullscreen = fs; }
 149     void addCamera( const std::string& k, osg::Camera* c, float s, bool fs = false ) { cameras[k].camera = c; cameras[k].scaleFactor = s; cameras[k].fullscreen = fs; }
 150     osg::Camera* getCamera(const std::string& k) const;
 151     int getMainSlaveIndex() const;
 152     RenderStageInfo& getRenderStageInfo( const std::string& k ) { return cameras[k]; }
 153
 154     /** the buffer objects
 155      */
 156     RenderBufferMap buffers;
 157     void addBuffer(const std::string& k, osg::Texture2D* tex, float scale = 1.0 ) { buffers[k] = RenderBufferInfo(tex,scale); }
 158     osg::Texture2D* getBuffer(const std::string& k) const;
 159
 160     osg::ref_ptr<osg::Uniform> bufferSize;
 161     osg::ref_ptr<osg::Uniform> projInverse;
 162     osg::ref_ptr<osg::Uniform> viewInverse;
 163     osg::ref_ptr<osg::Uniform> view;
 164     osg::ref_ptr<osg::Uniform> worldPosCart;
 165     osg::ref_ptr<osg::Uniform> worldPosGeod;
 166     osg::ref_ptr<osg::Uniform> du;
 167     osg::ref_ptr<osg::Uniform> dv;
 168     osg::ref_ptr<osg::Uniform> shadowMatrix[4];
 169
 170     std::auto_ptr<CameraViewportListener> viewportListener;
 171
 172     void setMatrices( osg::Camera* c );
 173
 174     osgUtil::RenderBin::RenderBinList savedTransparentBins;
 175     /** The reference points in the parents projection space.
 176      */
 177     osg::Vec2d parentReference[2];
 178     /** The reference points in the current projection space.
 179      */
 180     osg::Vec2d thisReference[2];
 181 };
 182
 183 class CameraGroup : public osg::Referenced
 184 {
 185 public:
 186     /** properties of a camera.
 187      */
 188     enum Flags
 189     {
 190         VIEW_ABSOLUTE = 0x1, /**< The camera view is absolute, not
 191                                 relative to the master camera. */
 192         PROJECTION_ABSOLUTE = 0x2, /**< The projection is absolute. */
 193         ORTHO = 0x4,               /**< The projection is orthographic */
 194         GUI = 0x8,                 /**< Camera draws the GUI. */
 195         DO_INTERSECTION_TEST = 0x10,/**< scene intersection tests this
 196                                        camera. */
 197         FIXED_NEAR_FAR = 0x20,     /**< take the near far values in the
 198                                       projection for real. */
 199         ENABLE_MASTER_ZOOM = 0x40  /**< Can apply the zoom algorithm. */
 200     };
 201     /** Create a camera group associated with an osgViewer::Viewer.
 202      * @param viewer the viewer
 203      */
 204     CameraGroup(osgViewer::Viewer* viewer);
 205
 206     ~CameraGroup();
 207
 208     /** Get the camera group's Viewer.
 209      * @return the viewer
 210      */
 211     osgViewer::Viewer* getViewer() { return _viewer.get(); }
 212     /** Create an osg::Camera from a property node and add it to the
 213      * camera group.
 214      * @param cameraNode the property node.
 215      * @return a CameraInfo object for the camera.
 216      */
 217     CameraInfo* buildCamera(SGPropertyNode* cameraNode);
 218     /** Create a camera from properties that will draw the GUI and add
 219      * it to the camera group.
 220      * @param cameraNode the property node. This can be 0, in which
 221      * case a default GUI camera is created.
 222      * @param window the GraphicsWindow to use for the GUI camera. If
 223      * this is 0, the window is determined from the property node.
 224      * @return a CameraInfo object for the GUI camera.
 225      */
 226     CameraInfo* buildGUICamera(SGPropertyNode* cameraNode,
 227                                GraphicsWindow* window = 0);
 228     /** Update the view for the camera group.
 229      * @param position the world position of the view
 230      * @param orientation the world orientation of the view.
 231      */
 232     void update(const osg::Vec3d& position, const osg::Quat& orientation);
 233     /** Set the parameters of the viewer's master camera. This won't
 234      * affect cameras that have CameraFlags::PROJECTION_ABSOLUTE set.
 235      * XXX Should znear and zfar be settable?
 236      * @param vfov the vertical field of view angle
 237      * @param aspectRatio the master camera's aspect ratio. This
 238      * doesn't actually change the viewport, but should reflect the
 239      * current viewport.
 240      */
 241     void setCameraParameters(float vfov, float aspectRatio);
 242     /** Set the default CameraGroup, which is the only one that
 243      * matters at this time.
 244      * @param group the group to set.
 245      */
 246
 247     static void buildDefaultGroup(osgViewer::Viewer* viewer);
 248
 249     static void setDefault(CameraGroup* group) { _defaultGroup = group; }
 250     /** Get the default CameraGroup.
 251      * @return the default camera group.
 252      */
 253     static CameraGroup* getDefault() { return _defaultGroup.get(); }
 254
 255     typedef std::vector<osg::ref_ptr<CameraInfo> > CameraList;
 256     typedef CameraList::iterator CameraIterator;
 257     typedef CameraList::const_iterator ConstCameraIterator;
 258     /** Get iterator for camera vector. The iterator's value is a ref_ptr.
 259      */
 260     CameraIterator camerasBegin() { return _cameras.begin(); }
 261     /** Get iteator pointing to the end of the camera list.
 262      */
 263     CameraIterator camerasEnd() { return _cameras.end(); }
 264     ConstCameraIterator camerasBegin() const { return _cameras.begin(); }
 265     ConstCameraIterator camerasEnd() const { return _cameras.end(); }
 266     void addCamera(CameraInfo* info) { _cameras.push_back(info); }
 267     /** Set the cull mask on all non-GUI cameras
 268      */
 269     void setCameraCullMasks(osg::Node::NodeMask nm);
 270     /** Update camera properties after a resize event.
 271      */
 272     void resized();
 273
 274     void buildDistortionCamera(const SGPropertyNode* psNode,
 275                                osg::Camera* camera);
 276
 277     /**
 278      * get aspect ratio of master camera's viewport
 279      */
 280     double getMasterAspectRatio() const;
 281
 282     /**
 283      * find the GUI camera if one is defined
 284      */
 285     const CameraInfo* getGUICamera() const;
 286
 287     void setZNear(float f) { _zNear = f; }
 288     void setZFar(float f) { _zFar = f; }
 289     void setNearField(float f) { _nearField = f; }
 290 protected:
 291     CameraList _cameras;
 292     osg::ref_ptr<osgViewer::Viewer> _viewer;
 293     static osg::ref_ptr<CameraGroup> _defaultGroup;
 294     std::auto_ptr<CameraGroupListener> _listener;
 295
 296     // Near, far for the master camera if used.
 297     float _zNear;
 298     float _zFar;
 299     float _nearField;
 300
 301     typedef std::map<std::string, osg::ref_ptr<osg::TextureRectangle> > TextureMap;
 302     TextureMap _textureTargets;
 303
 304     /** Build a complete CameraGroup from a property node.
 305      * @param viewer the viewer associated with this camera group.
 306      * @param the camera group property node.
 307      */
 308     static CameraGroup* buildCameraGroup(osgViewer::Viewer* viewer,
 309                                          SGPropertyNode* node);
 310 };
 311
 312 }
 313
 314 namespace flightgear
 315 {
 316 /** Get the osg::Camera that draws the GUI, if any, from a camera
 317  * group.
 318  * @param cgroup the camera group
 319  * @return the GUI camera or 0
 320  */
 321 osg::Camera* getGUICamera(CameraGroup* cgroup);
 322 /** Choose a camera using an event and do intersection testing on its
 323  * view of the scene. Only cameras with the DO_INTERSECTION_TEST flag
 324  * set are considered.
 325  * @param cgroup the CameraGroup
 326  * @param ea the event containing a window and mouse coordinates
 327  * @param intersections container for the result of intersection
 328  * testing.
 329  * @return true if any intersections are found
 330  */
 331 bool computeIntersections(const CameraGroup* cgroup,
 332                           const osg::Vec2d& windowPos,
 333                           osgUtil::LineSegmentIntersector::Intersections&
 334                           intersections);
 335 /** Warp the pointer to coordinates in the GUI camera of a camera group.
 336  * @param cgroup the camera group
 337  * @param x x window coordinate of pointer
 338  * @param y y window coordinate of pointer, in "y down" coordinates.
 339  */
 340 void warpGUIPointer(CameraGroup* cgroup, int x, int y);
 341 }
 342 #endif