SoDualSceneCollider.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-2019 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : JM Godinaud (Jan 2006)
**=======================================================================*/
 
#ifndef  _SO_DUAL_SCENE_COLLIDER_
#define  _SO_DUAL_SCENE_COLLIDER_
 
#include <Inventor/SbBasic.h>
#include <Inventor/SbLinear.h>
#include <Inventor/sensors/SoNodeSensor.h>
 
class SoNode;
class SoGroup;
class SoPath;
class SoTransform;
 
class SoCmStaticScene;
class SoCmMovingScene;
 
class  SoDualSceneCollider {
 
 public:
 
  SoDualSceneCollider();
  virtual ~SoDualSceneCollider();
 
  void setMovingScene(SoPath* object, int max_triangles_per_leaf=0);
 
  void setStaticScene(SoPath* scene, int max_triangles_per_leaf=0);
 
  void activate(SoTransform* transform);
 
  virtual SbBool checkCollision() const;
 
  virtual SbBool searchNextIntersection() const { return FALSE; }
 
  
  void   setMinEdgeLength(double minEdgeLength);
 
  double getMinEdgeLength() const;
 
  void enableMultiThread(bool enable);
 
  bool isMultiThreadEnabled() const
  { return m_isMultiThread; }
 
 private: protected:
 
  const SoPath* getCollidingStaticPath() const;
 
  const SoPath* getCollidingMovingPath() const;
 
  void getCollidingStaticTriangle(SbVec3f &v0, SbVec3f &v1, SbVec3f &v2) const;
 
  void getCollidingMovingTriangle(SbVec3f &v0, SbVec3f &v1, SbVec3f &v2) const;
 
  void getCommonPoints(SbVec3f &p0, SbVec3f &p1) const;
 
  virtual SbBool isSensitiveStaticObject(const SoPath *object_path) const;
 
  virtual SbBool isSensitiveMovingObject(const SoPath *object_path) const; 
 
  virtual void staticTriangleListBuilt(int num_triangles) const;
 
  virtual void staticLeafBuilt(int num_triangles) const;
 
  virtual void movingTriangleListBuilt(int num_triangles) const;
 
  virtual void movingLeafBuilt(int num_triangles) const;
 
 private:
  //private usage
  void updateMovingScene();
  void triangleListBuilt(int num_triangles) const;
  void leafBuilt(int num_triangles) const; // a new leaf is built : it contains num_triangles
  SbBool isSensitiveObject(const SoPath *object_path) const;
 
  // return true if checkcollision should stop for searching new intersection
  bool isStopIntersectionSearchRequested() const
  { return m_stopSearchingforIntersection; }
  // reset flag the searching flag
  void setStopIntersectionSearchRequested(bool value)
  { m_stopSearchingforIntersection = value; }
 
  // return the octree depth where parallelism should be used
  int getMaxParallelDepth() const
  { return m_maxparallelDepth; }
 
 private:
 
  SoPath            *m_staticPath;
  SoCmStaticScene   *m_staticScene;
  SoCmMovingScene   *m_movingScene;
  SoPath            *m_movingPath;
 
 private:
  SoNodeSensor      m_sensor;
  SoTransform       *m_transform;
  int               m_trianglePerStaticLeaf;
  int               m_trianglePerMovingLeaf;
  SbBool            m_staticSceneBeingBuilt;
  double            m_minEdgeLength;
  bool              m_stopSearchingforIntersection;
  bool              m_isMultiThread;
  int               m_maxparallelDepth;
};
 
inline SbBool
SoDualSceneCollider::isSensitiveStaticObject(const SoPath *) const
{ return TRUE; }
 
inline SbBool
SoDualSceneCollider::isSensitiveMovingObject(const SoPath *) const
{ return TRUE; }
 
inline void 
SoDualSceneCollider::staticTriangleListBuilt(int) const
{}
 
inline void 
SoDualSceneCollider::staticLeafBuilt(int) const
{}
 
inline void 
SoDualSceneCollider::movingTriangleListBuilt(int) const
{}
 
inline void
SoDualSceneCollider::movingLeafBuilt(int) const
{}
 
 
 
#endif // SO_DUAL_SCENE_COLLIDER_