SoCollisionManager.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-2024 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : Fabien ARNAUD (Jul 1997)
**=======================================================================*/
 
 
#ifndef _SO_COLLISION_MANAGER_
#define _SO_COLLISION_MANAGER_
 
 
//------------------------------------------------------------------------------
// Includes
#include <Inventor/SbBasic.h>
#include <Inventor/SbLinear.h>
 
 
//------------------------------------------------------------------------------
// Types declaration
class SoNode;
class SoGroup;
class SoPath;
class SoTransform;
class SoPrimitiveVertex;
class SoSensor;
class SoDragger;
class SoNodeSensor;
class SoFieldSensor;
class SoCallbackAction;
 
 
//------------------------------------------------------------------------------
// Types definition
typedef SbBool SoFilterCollisionCB (void* userData,
                                    const SoPath* p1,
                                    const SoPath* p2);
typedef void SoBBoxCollisionCB (void* userData, 
                                const SoPath* p1, 
                                const SoPath* p2);
 
struct SoCollidingPrimitive {
  enum PrimitiveType {
    SEGMENT = 2,
    LINE_SEGMENT = 2,
    TRIANGLE = 3
  };
  SoPath*    path; 
  PrimitiveType type;
  SbVec3f    vertex [3];
};
 
 
class  SoCollisionManager
{
 
public :
 
  // Types definitions ---------------------------------------------------------
  enum Resp {
    NEXT_PRIMITIVE,
    NEXT_SHAPE,
    ABORT    
  };
 
  typedef Resp SoCollisionCB (void* userData, 
                              const SoCollidingPrimitive* object,
                              const SoCollidingPrimitive* scene);
 
  SoCollisionManager(SoPath* object,
                     SoGroup* scene,
                     SoTransform* transform);
  ~SoCollisionManager();
 
  void setObject (SoPath* object);
 
  SoPath* getObject () const;
 
  void setScene (SoGroup* scene);
 
  SoGroup* getScene () const;
 
  void setTransform (SoTransform* transform);
 
  SoTransform* getTransform () const;
 
  void setGluingLevel (unsigned int level);
 
  unsigned int getGluingLevel() const;
 
  void setObjectBBoxOnly (SbBool flag = TRUE);
 
  SbBool isObjectBBoxOnly () const;
 
  void setSceneBBoxOnly (SbBool flag = TRUE);
 
  SbBool isSceneBBoxOnly () const;
 
  void setGluing (SbBool flag = TRUE);
 
  SbBool isGluing () const;
 
  void activate (SbBool flag = TRUE);
 
  SbBool isActivated () const;
 
  void setFilterCallback (SoFilterCollisionCB* f, void* userData = NULL);
 
  void addBBoxCollisionCallback (SoBBoxCollisionCB* f, void* userData = NULL);
 
  void removeBBoxCollisionCallback (SoBBoxCollisionCB* f,
                                    void* userData = NULL);
  void addCollisionCallback (SoCollisionCB* f, void* userData = NULL);
 
  void removeCollisionCallback(SoCollisionCB* f, void* userData = NULL);
 
  // Computing types -----------------------------------------------------------
  enum TransformChangeType {
    NONE,
    TRANSLATION,
    SCALE,
    ROTATION,
    ORIENTATION,
    CENTER
  };
 
  enum Axis {
    X_AXIS = 1,
    Y_AXIS = 2,
    Z_AXIS = 4
  };
 
  enum Position {
    BEGIN,
    END
  };
 
#ifndef HIDDEN_FROM_DOC
 
  struct ShapeBBoxInformationItem {
    SoPath*  path;
    float    x_min, y_min, z_min;
    float    x_max, y_max, z_max;
  };
 
  struct PairTableItem {
    int      overlap_flags;
    float    x_min, y_min, z_min;
    float    x_max, y_max, z_max;
  };
 
  struct CompListItem
  {
    int      shape_index;
    Position position;
    SbBool   to_remove;
    float    x, y, z;
  };
 
  struct ManagerListItem {
    SoCollisionManager*  manager;
    ManagerListItem*     next;
  };
 
  class  SceneInformationItem {
  public:
    ~SceneInformationItem();
 
    SoGroup*              root;
    SoNodeSensor*             sensor;
    SbBool                    need_refresh;
    SbBool                    one_object_has_changed;
 
    int                 refs;
    ManagerListItem*          manager_list;
    int                       active_manager_count;
 
    int                       shape_count;
    int                       shape_bbox_information_reserved_size;
    ShapeBBoxInformationItem* shape_bbox_information;
 
    int            pair_table_reserved_size;
    PairTableItem*            pair_table;
 
    int            comp_list_size;
    int            comp_list_reserved_size;
    CompListItem*             comp_list;
 
 
    SceneInformationItem*     next;
  };
#endif // HIDDEN_FROM_DOC
 
private : 
 
  // General data --------------------------------------------------------------
  SoPath*      m_object;
  SoGroup*     m_scene;
  SoTransform* m_transform;
  int          m_gluing_level;
 
  // Flags ---------------------------------------------------------------------
  SbBool       m_object_bbox_only;
  SbBool       m_scene_bbox_only;
  SbBool       m_gluing;
  SbBool       m_activated;
 
  // Managing callbacks --------------------------------------------------------
  SoFilterCollisionCB* m_filter_cb;
  void*                m_filter_cb_ud;
  void*                m_bbox_cb_list;
  void*                m_collision_cb_list;
  void invokeBBoxCallbacks (const SoPath* p1, const SoPath* p2);
  Resp invokeCollisionCallbacks (const SoCollidingPrimitive* object,
                                 const SoCollidingPrimitive* scene);
 
  // Computing variables -------------------------------------------------------
  SbBool                       m_need_check;
  SbBool                       m_object_geometry_has_changed;
  int                          m_primitive_count;
  int                          m_num_primitive_reserved;
  SoCollidingPrimitive*        m_primitives; 
  SoPath*                      m_current_shape_path;
  Resp                         m_upper_response;
  SbBool                       m_new_moving;
  SbBool                       m_new_shapes_pair;
  static SceneInformationItem* m_scene_information_list;
  SceneInformationItem*        m_scene_information;
  SbBool                       m_is_a_good_transform;
  SbBool                       m_there_is_a_good_transform;
  SbBool                       m_need_gluing;
  SoTransform*                 m_last_know_good_transform;
  SoTransform*                 m_temporary_transform;
  SoFieldSensor*               m_translation_sensor;
  SoFieldSensor*               m_scale_sensor;
  SoFieldSensor*               m_rotation_sensor;
  SoFieldSensor*               m_orientation_sensor;
  SoFieldSensor*               m_center_sensor;
 
  // Computing functions -------------------------------------------------------
  PairTableItem* pairTableGetItem (int shape1, int shape2);
  void pairTableCompute (int (*fct)(const void*, const void*), Axis axis);
  static int compListXCompare(const void* v1, const void* v2);
  static int compListYCompare(const void* v1, const void* v2);
  static int compListZCompare(const void* v1, const void* v2);
  void refresh ();
  void addPrimitiveToTable (SoPath* p,
                            SoCollidingPrimitive::PrimitiveType type,
                            SbVec3f v1,
                            SbVec3f v2,
                            SbVec3f v3);
  void addPrimitiveToTable (SoPath* p,
                            SoCollidingPrimitive::PrimitiveType type,
                            SbVec3f v1,
                            SbVec3f v2)
  { addPrimitiveToTable (p, type, v1, v2, SbVec3f (0, 0, 0)); }
  void addTriangleToTable (SoCallbackAction* action,
                           const SoPrimitiveVertex* v1,
                           const SoPrimitiveVertex* v2,
                           const SoPrimitiveVertex* v3);
  void addSegmentToTable (SoCallbackAction* action,
                          const SoPrimitiveVertex* v1,
                          const SoPrimitiveVertex* v2);
  void onObjectTriangle (SoCallbackAction* action,
                         const SoPrimitiveVertex* v1,
                         const SoPrimitiveVertex* v2,
                         const SoPrimitiveVertex* v3);
  void onObjectTriangleReal (const SbVec3f v0,
                             const SbVec3f v1,
                             const SbVec3f v2);
  void onObjectSegment (SoCallbackAction* action,
                        const SoPrimitiveVertex* v1,
                        const SoPrimitiveVertex* v2);
  SbBool intersectionTwoTriangles (SoCollidingPrimitive* t1,
                                SoCollidingPrimitive* t2);
  //  int intersectionTriangleAndSegment (SoCollidingPrimitive*  t,
  //                                      SbVec3f s0, SbVec3f s1);
  SbBool onTransformChange(SoSensor *sensor, TransformChangeType type);
  SbBool onTransformChange(SbBool sensorIsNotNULL, TransformChangeType type);
  SbBool checkSensor (SoSensor* sensor);
  static SceneInformationItem* getSceneInformation(SoCollisionManager* manager);
  static void removeSceneInformation (SoCollisionManager* manager);
  static void onSceneChange (void* ud, SoSensor* sensor);
  static void refresh (SceneInformationItem* scene);
  void lastKnowGoodTransformComputing ();
 
  // Real callbacks ------------------------------------------------------------
  static void addTriangleToTableCB (void* ud, SoCallbackAction* action,
                                    const SoPrimitiveVertex* v1,
                                    const SoPrimitiveVertex* v2,
                                    const SoPrimitiveVertex* v3)
  { ((SoCollisionManager*) ud)->addTriangleToTable (action, v1, v2, v3); }
  static void addSegmentToTableCB (void* ud, SoCallbackAction* action,
                                   const SoPrimitiveVertex* v1,
                                   const SoPrimitiveVertex* v2)
  { ((SoCollisionManager*) ud)->addSegmentToTable (action, v1, v2); }
                   
  static void onObjectTriangleCB (void* ud, SoCallbackAction* action,
                                  const SoPrimitiveVertex* v1,
                                  const SoPrimitiveVertex* v2,
                                  const SoPrimitiveVertex* v3)
  { ((SoCollisionManager*) ud)->onObjectTriangle (action, v1, v2, v3); }
  static void onObjectSegmentCB (void* ud, SoCallbackAction* action,
                                 const SoPrimitiveVertex* v1,
                                 const SoPrimitiveVertex* v2)
  { ((SoCollisionManager*) ud)->onObjectSegment (action, v1, v2); }
  static void onTranslationChangeCB (void* ud, SoSensor* sensor)
  { ((SoCollisionManager*) ud)->onTransformChange (sensor, TRANSLATION); }
  static void onScaleChangeCB (void* ud, SoSensor* sensor)
  { ((SoCollisionManager*) ud)->onTransformChange (sensor, SCALE); }
  static void onRotationChangeCB (void* ud, SoSensor* sensor)
  { ((SoCollisionManager*) ud)->onTransformChange (sensor, ROTATION); }
  static void onOrientationChangeCB (void* ud, SoSensor* sensor)
  { ((SoCollisionManager*) ud)->onTransformChange (sensor, ORIENTATION); }
  static void onCenterChangeCB (void* ud, SoSensor* sensor)
  { ((SoCollisionManager*) ud)->onTransformChange (sensor, CENTER); }
  static void onDraggerMotionCB (void* ud, SoDragger *)
  { ((SoCollisionManager*) ud)->onDraggerMotion (); }
 
  // Manipulator features ------------------------------------------------------
  SbVec3f    m_dragger_translation;
  SbRotation m_dragger_rotation;
  SbVec3f    m_dragger_scale_factor;
  SbRotation m_dragger_scale_orientation;
  SbVec3f    m_dragger_center;
  void onDraggerMotion ();
 
  // Miscelaneous --------------------------------------------------------------
  void quickSort(void *array, int nElm, int elmSize,
                 int (*compare)(const void*, const void*),
                 char *tmp);
 
};
 
#endif //_SO_COLLISION_MANAGER_