Inventor/SbViewVolume.h

Go to the documentation of this file.

/*=======================================================================
 *** 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-2014 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;

  SbBox3f getProjectedBbox(const SbMatrix& affineProj, const SbBox3f &box) const;

  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_ */

---

Open Inventor Toolkit reference manual, generated on 15 Mar 2023
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/