SbViewVolume.h

/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2023 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : VSG (MMM YYYY)
**=======================================================================*/
 
 
#ifndef _SB_VIEWVOLUME_
#define _SB_VIEWVOLUME_
 
#include <Inventor/SbBase.h>
#include <Inventor/SbVec.h>
#include <Inventor/SbBox.h>
#include <Inventor/SbPlane.h>
#include <Inventor/SbRotation.h>
#include <Inventor/STL/vector>
 
class SbLine;
class SbMatrix;
class SbPlane;
class SbRotation;
class SbVec2f;
class SbVec3f;
 
class DebugDataSbVolIntersect;
class HomTransfData;
 
//
//  Class: SbViewVolume
//
//  Defines a 3D view volume. For perspective projection, the view
//  volume is a frustum. For orthographic (parallel) projection, the
//  view volume is a rectangular prism.
//
 
 
class  SbViewVolume {
public:
 
  SbViewVolume();
  ~SbViewVolume()     {}
 
  float getMatrices(SbMatrix &affine, SbMatrix &proj) const;
 
  SbMatrix getMatrix() const;
 
  SbMatrix getCameraSpaceMatrix() const;
 
  void projectPointToLine(const SbVec2f &pt, SbLine &line) const;
 
  void projectPointToLine(const SbVec2f &pt,
    SbVec3f &line0,
    SbVec3f &line1) const;
 
  void projectToScreen(const SbVec3f &src, SbVec3f &dst) const;
 
  void projectFromScreen(const SbVec3f &src, SbVec3f &dst) const;
 
  SbPlane getPlane(float distFromEye) const;
 
  SbVec3f getSightPoint(float distFromEye) const;
 
  SbVec3f getPlanePoint(float distFromEye,
    const SbVec2f &normPoint) const;
 
  SbRotation getAlignRotation(SbBool rightAngleOnly = FALSE) const;
 
  float getWorldToScreenScale(const SbVec3f &worldCenter,
    float normRadius) const;
 
  SbVec2f projectBox(const SbBox3f &box) const;
 
  SbBox3f getProjectedBbox(const SbBox3f &box) const;
 
  static SbBox3f getProjectedBbox(const SbMatrix& affineProj, const SbBox3f& box);
 
  SbViewVolume narrow(float left,  float bottom,
    float right, float top) const;
 
  SbViewVolume narrow(const SbBox3f &box) const;
 
  void ortho(float left,   float right,
    float bottom, float top,
    float nearPlane,   float farPlane);
 
  void perspective(float fovy, float aspect,
    float nearPlane, float farPlane);
 
  void rotateCamera(const SbRotation &q);
 
  void translateCamera(const SbVec3f &v);
 
  SbVec3f zVector() const;
 
  SbViewVolume zNarrow(float nearPlane, float farPlane) const;
 
  void scale(float factor);
 
  void scaleWidth(float ratio);
 
  void scaleHeight(float ratio);
 
  enum ProjectionType  {
    ORTHOGRAPHIC,
    PERSPECTIVE
  };
 
  inline ProjectionType getProjectionType() const  { return type; }
 
  inline const SbVec3f &getProjectionPoint() const { return projPoint; }
 
  inline const SbVec3f &getProjectionDirection() const   { return projDir; }
 
  inline float getNearDist() const { return nearDist; }
 
  inline float getWidth() const      { return (lrfO-llfO).length(); }
 
  inline float getHeight() const     { return (ulfO-llfO).length(); }
 
  inline float getDepth() const      { return nearToFar; }
 
  void setStereoAbsoluteAdjustments(SbBool absolute);
 
  SbBool isStereoAbsoluteAdjustments() const;
 
  void  setStereoAdjustment(float adjustment);
 
  float getStereoAdjustment() const;
 
  void  setBalanceAdjustment(float adjustment, SbBool nearFrac = false);
 
  float getBalanceAdjustment() const;
 
  SbBool isBalanceNearFraction() const;
 
  enum StereoMode {
    MONOSCOPIC,
    LEFT_VIEW,
    RIGHT_VIEW
  } ;
 
  inline void setStereoMode(StereoMode mode)  { stereoMode = mode ; }
 
  inline StereoMode getStereoMode() const    { return stereoMode ; }
 
  SbBool equals(const SbViewVolume &v, float tolerance);
 
  private:
  ProjectionType type;
 
  // Note that there is redundant info in this data structure and its
  // elements should not be changed by hand.
  SbVec3f  projPoint;    // "Top" of view frustum pyramid (for perspective), expressed in world space. Correspond in some way to eye location. must be (0,0,0) for ortho
  SbVec3f  projDir;      // Line of sight in world space. Direction from point of view (projPoint) to center of screen.
  float  nearDist;       // distance to near plane in world space
  float  nearToFar;      // distance between z clips in world space
  SbVec3f  llf;          // lower left front corner of view volume (over near clip plane), in world space
  SbVec3f  lrf;          // lower right front corner of view volume (over near clip plane), in world space
  SbVec3f  ulf;          // upper left front corner of view volume (over near clip plane), in world space
  // Points on the near clipping plane.  Add in the projPoint to
  // figure out where they are in world space (llf = llfO + projPoint)
  SbVec3f  llfO;  // x = -w, y = -w, z = -w
  SbVec3f  lrfO;  // x =  w, y = -w, z = -w
  SbVec3f  ulfO;  // x = -w, y =  w, z = -w
 
  // Alternate way to set up a perspective view volume.
  // Parameters are the same as for glFrustum.
  void frustum( float left, float right, float bottom,
                float top, float near_plane, float far_plane );
 
  void frustumWorldCoords( const SbVec3f &projPt, const SbVec3f &projDire, 
                           float radius, float near_plane, float far_plane, bool forceNearPlane = false );
 
  // Transforms the view volume by the given matrix. NOTE: if the
  // matrix performs a scale and a rotation, angles between the
  // transformed projection direction and the sides of the view
  // volume may not be preserved.
  void  transform( const SbMatrix &matrix);
 
  // Returns TRUE if view volume contains point
  SbBool  intersect( const SbVec3f &point) const;
 
  // Returns TRUE if view volume contains point, it uses the HomTransfData matrix if provided
  SbBool intersect( const SbVec3f &point, HomTransfData *pHomTData ) const;
 
  // Returns TRUE if line segment between 2 points may intersect
  // volume. Returns closest point on line to center ray of volume
  // if intersection is found.
  SbBool intersectOld( const SbVec3f &p0,
                       const SbVec3f &p1,
                       HomTransfData *pHomTData,
                       SbVec3f &closestPoint,
                       DebugDataSbVolIntersect *pdd = 0 ) const;
 
  // Returns TRUE if line segment between 2 points may intersect
  // volume. Returns closest point on line to center ray of volume
  // if intersection is found.
  SbBool intersect(const SbVec3f &p0,
                   const SbVec3f &p1,
                   HomTransfData *pHomTData,
                   SbVec3f &closestPoint,
                   DebugDataSbVolIntersect *pdd = 0 ) const;
 
  // Returns TRUE if triangle, made by three points, intersects
  // volume. Returns closest point in the triangle to center ray of volume
  // if intersection is found.
  SbBool intersect( const SbVec3f &v0, const SbVec3f &v1, const SbVec3f &v2,
                    HomTransfData *pHomTData,
                        SbVec3f &intersection,
                        SbVec3f &barycentric, SbBool &front, 
                    DebugDataSbVolIntersect *pdd = 0) const;
 
  // Returns TRUE if bounding box may intersect volume
  inline SbBool intersect( const SbBox3f &box) const
  {
    SbXfBox3f xbox(box);
    return intersect(xbox);
  }
 
  // Returns TRUE if bounding box may intersect volume
  SbBool  intersect( const SbXfBox3f &box) const;
 
  void clipFrustum(const SbXfBox3d& box, std::vector<SbVec3d>& points) const;
 
  // Returns TRUE if the bounding box defined by min,max is totally
  // outside plane p.
  SbBool  outsideTest( const SbPlane &p,
                       const SbVec3f &min, const SbVec3f &max) const;
 
  void setCameraOffset(float);
  float getCameraOffset(void) const;
  void unsetCameraOffset(void);
  int isCameraOffsetSet(void) const;
 
  void setClipToFar(SbBool clipToFar);
  void setClipToNear(SbBool clipToNear);
 
  inline const SbBox3f& getFrustumBbox() const;
 
  SbBox3f getRestrictedBbox(float visibilityLength) const ;
 
  SbVec3f getllf() const { return llf; }
 
  SbBool checkRadialDistance( const SbVec3f & pt, float radius ) const;
 
  SbMatrix getAllMatrices( SbMatrix &affine, SbMatrix &proj ) const;
 
private:
 
  // Returns TRUE if triangle, made by three points, intersects
  // volume. Returns closest point in the triangle to center ray of volume
  // if intersection is found.
  SbBool intersect1( const SbVec3f &v0, const SbVec3f &v1, const SbVec3f &v2,
    HomTransfData *pHomTData,
    SbVec3f &intersection,
    SbVec3f &barycentric, SbBool &front, 
    DebugDataSbVolIntersect *pdd = 0) const;
 
  SbBool intersect2( const SbVec3f &v0, const SbVec3f &v1, const SbVec3f &v2,
    HomTransfData *pHomTData,
    SbVec3f &intersection,
    SbVec3f &barycentric, SbBool &front, 
    DebugDataSbVolIntersect *pdd = 0) const;
 
  SbBox3f m_frustumBbox;
 
  SbBool stereoAbsoluteAdjustments;
  float  stereoAdjustment, balanceAdjustment;
  StereoMode stereoMode;
  bool stereoNearFrac;
 
  float mPStereoCameraOffset;
  int mPStereoOffsetSet;
 
  SbBool m_bClipToNear, m_bClipToFar;
};
 
// INLINE METHODS
inline void
SbViewVolume::setClipToFar(SbBool clipToFar)
{
  m_bClipToFar = clipToFar;
}
 
inline void
SbViewVolume::setClipToNear(SbBool  clipToNear)
{
  m_bClipToNear = clipToNear;
}
 
inline SbBool
SbViewVolume::isStereoAbsoluteAdjustments() const
{
  return stereoAbsoluteAdjustments;
}
 
inline void
SbViewVolume::setStereoAdjustment(float adjustment)
{
  stereoAdjustment = adjustment;
}
 
inline float
SbViewVolume::getStereoAdjustment() const
{
  return stereoAdjustment;
}
 
inline void
SbViewVolume::setBalanceAdjustment(float adjustment, SbBool nearFrac)
{
  balanceAdjustment = adjustment;
  stereoNearFrac = (nearFrac!=FALSE);
}
 
inline float
SbViewVolume::getBalanceAdjustment() const
{
  return balanceAdjustment;
}
 
inline SbBool
SbViewVolume::isBalanceNearFraction() const
{
  return stereoNearFrac;
}
 
inline void
SbViewVolume::setStereoAbsoluteAdjustments(SbBool absolute)
{
  stereoAbsoluteAdjustments = absolute;
}
 
const SbBox3f&
SbViewVolume::getFrustumBbox() const
{
  return m_frustumBbox;
}
 
#endif /* _SB_VIEWVOLUME_ */