1 files changed, 214 insertions, 0 deletions

diff --git a/libraries/ode-0.9/ode/src/collision_kernel.h b/libraries/ode-0.9/ode/src/collision_kernel.h
new file mode 100644
index 0000000..d5a2bc4
--- /dev/null
+++ b/libraries/ode-0.9/ode/src/collision_kernel.h
@@ -0,0 +1,214 @@
+/*************************************************************************
+ *                                                                       *
+ * Open Dynamics Engine, Copyright (C) 2001-2003 Russell L. Smith.       *
+ * All rights reserved.  Email: russ@q12.org   Web: www.q12.org          *
+ *                                                                       *
+ * This library is free software; you can redistribute it and/or         *
+ * modify it under the terms of EITHER:                                  *
+ *   (1) The GNU Lesser General Public License as published by the Free  *
+ *       Software Foundation; either version 2.1 of the License, or (at  *
+ *       your option) any later version. The text of the GNU Lesser      *
+ *       General Public License is included with this library in the     *
+ *       file LICENSE.TXT.                                               *
+ *   (2) The BSD-style license that is included with this library in     *
+ *       the file LICENSE-BSD.TXT.                                       *
+ *                                                                       *
+ * 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 files    *
+ * LICENSE.TXT and LICENSE-BSD.TXT for more details.                     *
+ *                                                                       *
+ *************************************************************************/
+
+/*
+
+internal data structures and functions for collision detection.
+
+*/
+
+#ifndef _ODE_COLLISION_KERNEL_H_
+#define _ODE_COLLISION_KERNEL_H_
+
+#include <ode/common.h>
+#include <ode/contact.h>
+#include <ode/collision.h>
+#include "objects.h"
+
+//****************************************************************************
+// constants and macros
+
+// mask for the number-of-contacts field in the dCollide() flags parameter
+#define NUMC_MASK (0xffff)
+
+#define IS_SPACE(geom) \
+  ((geom)->type >= dFirstSpaceClass && (geom)->type <= dLastSpaceClass)
+
+//****************************************************************************
+// geometry object base class
+
+
+// geom flags.
+//
+// GEOM_DIRTY means that the space data structures for this geom are
+// potentially not up to date. NOTE THAT all space parents of a dirty geom
+// are themselves dirty. this is an invariant that must be enforced.
+//
+// GEOM_AABB_BAD means that the cached AABB for this geom is not up to date.
+// note that GEOM_DIRTY does not imply GEOM_AABB_BAD, as the geom might
+// recalculate its own AABB but does not know how to update the space data
+// structures for the space it is in. but GEOM_AABB_BAD implies GEOM_DIRTY.
+// the valid combinations are: 
+//              0
+//              GEOM_DIRTY
+//              GEOM_DIRTY|GEOM_AABB_BAD
+//              GEOM_DIRTY|GEOM_AABB_BAD|GEOM_POSR_BAD
+
+enum {
+  GEOM_DIRTY    = 1,    // geom is 'dirty', i.e. position unknown
+  GEOM_POSR_BAD = 2,    // geom's final posr is not valid
+  GEOM_AABB_BAD = 4,    // geom's AABB is not valid
+  GEOM_PLACEABLE = 8,   // geom is placeable
+  GEOM_ENABLED = 16,            // geom is enabled
+
+  // Ray specific
+  RAY_FIRSTCONTACT = 0x10000,
+  RAY_BACKFACECULL = 0x20000,
+  RAY_CLOSEST_HIT  = 0x40000
+};
+
+
+// geometry object base class. pos and R will either point to a separately
+// allocated buffer (if body is 0 - pos points to the dxPosR object) or to
+// the pos and R of the body (if body nonzero).
+// a dGeomID is a pointer to this object.
+
+struct dxGeom : public dBase {
+  int type;             // geom type number, set by subclass constructor
+  int gflags;           // flags used by geom and space
+  void *data;           // user-defined data pointer
+  dBodyID body;         // dynamics body associated with this object (if any)
+  dxGeom *body_next;    // next geom in body's linked list of associated geoms
+  dxPosR *final_posr;   // final position of the geom in world coordinates
+  dxPosR *offset_posr;  // offset from body in local coordinates
+
+  // information used by spaces
+  dxGeom *next;         // next geom in linked list of geoms
+  dxGeom **tome;        // linked list backpointer
+  dxSpace *parent_space;// the space this geom is contained in, 0 if none
+  dReal aabb[6];        // cached AABB for this space
+  unsigned long category_bits,collide_bits;
+
+  dxGeom (dSpaceID _space, int is_placeable);
+  virtual ~dxGeom();
+
+
+  // calculate our new final position from our offset and body
+  void computePosr();
+
+  // recalculate our new final position if needed
+  void recomputePosr()
+  {
+    if (gflags & GEOM_POSR_BAD) {
+      computePosr();
+      gflags &= ~GEOM_POSR_BAD;
+    }
+  }
+
+  virtual void computeAABB()=0;
+  // compute the AABB for this object and put it in aabb. this function
+  // always performs a fresh computation, it does not inspect the
+  // GEOM_AABB_BAD flag.
+
+  virtual int AABBTest (dxGeom *o, dReal aabb[6]);
+  // test whether the given AABB object intersects with this object, return
+  // 1=yes, 0=no. this is used as an early-exit test in the space collision
+  // functions. the default implementation returns 1, which is the correct
+  // behavior if no more detailed implementation can be provided.
+
+  // utility functions
+
+  // compute the AABB only if it is not current. this function manipulates
+  // the GEOM_AABB_BAD flag.
+
+  void recomputeAABB() {
+    if (gflags & GEOM_AABB_BAD) {
+      // our aabb functions assume final_posr is up to date
+      recomputePosr(); 
+      computeAABB();
+      gflags &= ~GEOM_AABB_BAD;
+    }
+  }
+
+  // add and remove this geom from a linked list maintained by a space.
+
+  void spaceAdd (dxGeom **first_ptr) {
+    next = *first_ptr;
+    tome = first_ptr;
+    if (*first_ptr) (*first_ptr)->tome = &next;
+    *first_ptr = this;
+  }
+  void spaceRemove() {
+    if (next) next->tome = tome;
+    *tome = next;
+  }
+
+  // add and remove this geom from a linked list maintained by a body.
+
+  void bodyAdd (dxBody *b) {
+    body = b;
+    body_next = b->geom;
+    b->geom = this;
+  }
+  void bodyRemove();
+};
+
+//****************************************************************************
+// the base space class
+//
+// the contained geoms are divided into two kinds: clean and dirty.
+// the clean geoms have not moved since they were put in the list,
+// and their AABBs are valid. the dirty geoms have changed position, and
+// their AABBs are may not be valid. the two types are distinguished by the
+// GEOM_DIRTY flag. all dirty geoms come *before* all clean geoms in the list.
+
+struct dxSpace : public dxGeom {
+  int count;                    // number of geoms in this space
+  dxGeom *first;                // first geom in list
+  int cleanup;                  // cleanup mode, 1=destroy geoms on exit
+
+  // cached state for getGeom()
+  int current_index;            // only valid if current_geom != 0
+  dxGeom *current_geom;         // if 0 then there is no information
+
+  // locking stuff. the space is locked when it is currently traversing its
+  // internal data structures, e.g. in collide() and collide2(). operations
+  // that modify the contents of the space are not permitted when the space
+  // is locked.
+  int lock_count;
+
+  dxSpace (dSpaceID _space);
+  ~dxSpace();
+
+  void computeAABB();
+
+  void setCleanup (int mode);
+  int getCleanup();
+  int query (dxGeom *geom);
+  int getNumGeoms();
+  virtual dxGeom *getGeom (int i);
+
+  virtual void add (dxGeom *);
+  virtual void remove (dxGeom *);
+  virtual void dirty (dxGeom *);
+
+  virtual void cleanGeoms()=0;
+  // turn all dirty geoms into clean geoms by computing their AABBs and any
+  // other space data structures that are required. this should clear the
+  // GEOM_DIRTY and GEOM_AABB_BAD flags of all geoms.
+
+  virtual void collide (void *data, dNearCallback *callback)=0;
+  virtual void collide2 (void *data, dxGeom *geom, dNearCallback *callback)=0;
+};
+
+
+#endif