/*************************************************************************

 *                                                                       *

 * 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 "object.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