/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2003 Robert Osfield * * This library is open source and may be redistributed and/or modified under * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or * (at your option) any later version. The full license is in LICENSE file * included with this distribution, and on the openscenegraph.org website. * * This library 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 * OpenSceneGraph Public License for more details. */ #ifndef OSG_CAMERA #define OSG_CAMERA 1 #include #include #include #include #include #include #include #include namespace osg { /** Camera class for encapsulating the view position and orientation and * projection (lens) used. Creates a projection and modelview matrices * which can be used to set OpenGL's PROJECTION and MODELVIEW matrices * respectively. */ class SG_EXPORT Camera: public osg::Referenced { public: Camera(DisplaySettings* ds=NULL); Camera(const Camera&); Camera& operator=(const Camera&); /** Range of projection types. * ORTHO2D is a special case of ORTHO where the near and far planes * are equal to -1 and 1 respectively. * PERSPECTIVE is a special case of FRUSTUM where the left & right * and bottom and top and symmetrical.*/ enum ProjectionType { ORTHO, ORTHO2D, FRUSTUM, PERSPECTIVE }; /** Get the projection type set by setOtho,setOtho2D,setFrustum, * and set perspective methods.*/ ProjectionType getProjectionType() const { return _projectionType; } /** Set a orthographic projection. See glOrtho for further details.*/ void setOrtho(double left, double right, double bottom, double top, double zNear, double zFar); /** Set a 2D orthographic projection. See gluOrtho2D for further details.*/ void setOrtho2D(double left, double right, double bottom, double top); /** Set a perspective projection. See glFrustum for further details.*/ void setFrustum(double left, double right, double bottom, double top, double zNear, double zFar); /** Set a symmetrical perspective projection, See gluPerspective for further details. * Aspect ratio is defined as width/height.*/ void setPerspective(double fovy,double aspectRatio, double zNear, double zFar); /** Set a sysmmetical perspective projection using field of view.*/ void setFOV(double fovx,double fovy, double zNear, double zFar); /** Set the near and far clipping planes.*/ void setNearFar(double zNear, double zFar); /** Use in combination with adjustAspectRatio, to control * the change in frustum clipping planes to account for * changes in windows aspect ratio,*/ enum AdjustAspectRatioMode { ADJUST_VERTICAL, ADJUST_HORIZONTAL, ADJUST_NONE }; /** Set the way that the vertical or horizontal dimensions of the window * are adjusted on a resize. */ void setAdjustAspectRatioMode(AdjustAspectRatioMode aam) { _adjustAspectRatioMode = aam; } /** Get the way that the vertical or horizontal dimensions of the window * are adjusted on a resize. */ AdjustAspectRatioMode getAdjustAspectRatioMode() const { return _adjustAspectRatioMode; } /** Adjust the clipping planes to account for a new window aspect ratio. * Typically used after resizing a window. Aspect ratio is defined as * width/height.*/ void adjustAspectRatio(double newAspectRatio) { adjustAspectRatio(newAspectRatio,_adjustAspectRatioMode); } /** Adjust the clipping planes to account for a new window aspect ratio. * Typicall used after resizeing a window. Aspect ratio is defined as * width/height.*/ void adjustAspectRatio(double newAspectRatio, AdjustAspectRatioMode aa); double left() const { return _left; } double right() const { return _right; } double bottom() const { return _bottom; } double top() const { return _top; } double zNear() const { return _zNear; } double zFar() const { return _zFar; } /** Calculate and return the equivalent fovx for the current project setting. * This value is only valid for when a symmetric perspective projection exists. * i.e. getProjectionType()==PERSPECTIVE.*/ double calc_fovy() const; /** Calculate and return the equivalent fovy for the current project setting. * This value is only valid for when a symmetric perspective projection exists. * i.e. getProjectionType()==PERSPECTIVE.*/ double calc_fovx() const; /** Calculate and return the projection aspect ratio. * Aspect ratio is defined as width/height.*/ double calc_aspectRatio() const; enum LookAtType { USE_HOME_POSITION, USE_EYE_AND_QUATERNION, USE_EYE_CENTER_AND_UP }; LookAtType getLookAtType() const { return _lookAtType; } /** * hardwired home view for now, looking straight down the * Z axis at the origin, with 'up' being the y axis. */ void home(); /** * Set the View, the up vector should be orthogonal to the look vector. * setView is now mapped to setLookAt(eye,center,up), and is only * kept for backwards compatibility. */ void setView(const Vec3& eyePoint, const Vec3& lookPoint, const Vec3& upVector); /** set the position and orientation of the camera, using the same convention as * gluLookAt. */ void setLookAt(const Vec3& eye, const Vec3& center, const Vec3& up); /** set the position and orientation of the camera, using the same convention as * gluLookAt. */ void setLookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ); /** post multiple the existing eye point and orientation by matrix. * note, does not affect any ModelTransforms that are applied.*/ void transformLookAt(const Matrix& matrix); void ensureOrthogonalUpVector(); /** get the eye point. */ inline const Vec3& getEyePoint() const { return _eye; } /** get the center point. */ inline const Vec3& getCenterPoint() const { return _center; } /** get the up vector */ inline const Vec3& getUpVector() const { return _up; } /** calculate look vector.*/ Vec3 getLookVector() const; /** calculate side vector.*/ Vec3 getSideVector() const; /** calculate the look distance which is the distance between the eye and the center.*/ inline float getLookDistance() const { return (_center-_eye).length(); } enum TransformMode { EYE_TO_MODEL, MODEL_TO_EYE, NO_ATTACHED_TRANSFORM }; /** Attach a transform matrix which is applied after the camera look at. * The attached matrix can work in two ways, either as transform of the eye * into the model coordinates - EYE_TO_MODEL, or as a transform of the * model to the eye - MODEL_TO_EYE. The former is equivalent to attaching * a camera internal to the scene graph. The later is equivalent to adding * a osg::Transform at root of the scene to move the scene to the eye point. * Typical used in conjunction with the LookAt position set to home, * in which case it is simply treated as a model view matrix. * If the same behavior as IRIS Performer's setViewMat is desired * then set the LookAt to be (0,0,0),(0,1,0),(0,0,1) since Performer's * default direction is along the y axis, unlike OpenGL and the default OSG. * If modelTransfor is NULL then do not use any model transform - just use the * basic LookAt values. * note: Camera internals maintains the both EYE_TO_MODEL and MODEL_TO_EYE * internally and ensures that they are the inverse of one another.*/ void attachTransform(TransformMode mode, RefMatrix* modelTransform=0); Matrix* getTransform(TransformMode mode); const Matrix* getTransform(TransformMode mode) const; enum FusionDistanceMode { PROPORTIONAL_TO_LOOK_DISTANCE, PROPORTIONAL_TO_SCREEN_DISTANCE }; /** Set the mode of the fusion distance function which in use to calculate the * fusion distance used in stereo rendering. Default value is * PROPORTIONAL_TO_LOOK_DISTANCE. Use in conjunction with setFusionDistanceRatio(float).*/ void setFusionDistanceMode(FusionDistanceMode mode) { _fusionDistanceMode = mode; } /** Get the mode of the fusion distance function.*/ FusionDistanceMode getFusionDistanceMode() const { return _fusionDistanceMode; } /** Set the ratio of the fusion distance function which in use to calculate the * fusion distance used in stereo rendering. Default value is 1.0f * Use in conjunction with setFusionDistanceMode(..).*/ void setFusionDistanceRatio(float ratio) { _fusionDistanceRatio = ratio; } /** Get the ratio of the fusion distance function.*/ float getFusionDistanceRatio() const { return _fusionDistanceRatio; } /** Calculate and return the fusion distance, using the FusionDistanceFunction.*/ float getFusionDistance() const; /** Set the physical distance between the viewers eyes and the display system. * Note, only used when rendering in stereo.*/ void setScreenDistance(float screenDistance) { _screenDistance = screenDistance; } /** Get the physical distance between the viewers eyes and the display system.*/ float getScreenDistance() const { return _screenDistance; } /** Get the Projection Matrix.*/ Matrix getProjectionMatrix() const; /** Get the ModelView matrix. * If a ModelTransform is supplied then the ModelView matrix is * created by multiplying the current LookAt by ModelTransform. * Otherwise it is simply created by using the current LookAt, * equivalent to using gluLookAt.*/ Matrix getModelViewMatrix() const; /** Get the camera view frustum.*/ inline Polytope getViewFrustum() const { Polytope cv; cv.setToUnitFrustum(); cv.transformProvidingInverse(getModelViewMatrix()* getProjectionMatrix()); return cv; } protected: virtual ~Camera(); void copy(const Camera&); // projection details. ProjectionType _projectionType; // how the window dimensions should be altered during a window resize. AdjustAspectRatioMode _adjustAspectRatioMode; // note, in Frustum/Perspective mode these values are scaled // by the zNear from when they were initialised to ensure that // subsequent changes in zNear do not affect them. double _left; double _right; double _bottom; double _top; double _zNear; double _zFar; // look at details. LookAtType _lookAtType; Vec3 _eye; Vec3 _center; Vec3 _up; TransformMode _attachedTransformMode; ref_ptr _eyeToModelTransform; ref_ptr _modelToEyeTransform; float _screenDistance; FusionDistanceMode _fusionDistanceMode; float _fusionDistanceRatio; }; } # endif