cpSpace.h

/* Copyright (c) 2007 Scott Lembcke
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */


typedef struct cpContactBufferHeader cpContactBufferHeader;
typedef void (*cpSpaceArbiterApplyImpulseFunc)(cpArbiter *arb);

struct cpSpace {
  int iterations;
  
  cpVect gravity;
  
  cpFloat damping;
  
  cpFloat idleSpeedThreshold;
  
  cpFloat sleepTimeThreshold;
  
  cpFloat collisionSlop;
  
  cpFloat collisionBias;
  
  cpTimestamp collisionPersistence;
  
  cpBool enableContactGraph;
  
  cpDataPointer data;
  
  cpBody *staticBody;
  
  CP_PRIVATE(cpTimestamp stamp);
  CP_PRIVATE(cpFloat curr_dt);

  CP_PRIVATE(cpArray *bodies);
  CP_PRIVATE(cpArray *rousedBodies);
  CP_PRIVATE(cpArray *sleepingComponents);
  
  CP_PRIVATE(cpSpatialIndex *staticShapes);
  CP_PRIVATE(cpSpatialIndex *activeShapes);
  
  CP_PRIVATE(cpArray *arbiters);
  CP_PRIVATE(cpContactBufferHeader *contactBuffersHead);
  CP_PRIVATE(cpHashSet *cachedArbiters);
  CP_PRIVATE(cpArray *pooledArbiters);
  CP_PRIVATE(cpArray *constraints);
  
  CP_PRIVATE(cpArray *allocatedBuffers);
  CP_PRIVATE(int locked);
  
  CP_PRIVATE(cpHashSet *collisionHandlers);
  CP_PRIVATE(cpCollisionHandler defaultHandler);
  CP_PRIVATE(cpHashSet *postStepCallbacks);
  
  CP_PRIVATE(cpSpaceArbiterApplyImpulseFunc arbiterApplyImpulse);
  
  CP_PRIVATE(cpBody _staticBody);
};

cpSpace* cpSpaceAlloc(void);
cpSpace* cpSpaceInit(cpSpace *space);
cpSpace* cpSpaceNew(void);

void cpSpaceDestroy(cpSpace *space);
void cpSpaceFree(cpSpace *space);

#define CP_DefineSpaceStructGetter(type, member, name) \
static inline type cpSpaceGet##name(const cpSpace *space){return space->member;}

#define CP_DefineSpaceStructSetter(type, member, name) \
static inline void cpSpaceSet##name(cpSpace *space, type value){space->member = value;}

#define CP_DefineSpaceStructProperty(type, member, name) \
CP_DefineSpaceStructGetter(type, member, name) \
CP_DefineSpaceStructSetter(type, member, name)

CP_DefineSpaceStructProperty(int, iterations, Iterations);
CP_DefineSpaceStructProperty(cpVect, gravity, Gravity);
CP_DefineSpaceStructProperty(cpFloat, damping, Damping);
CP_DefineSpaceStructProperty(cpFloat, idleSpeedThreshold, IdleSpeedThreshold);
CP_DefineSpaceStructProperty(cpFloat, sleepTimeThreshold, SleepTimeThreshold);
CP_DefineSpaceStructProperty(cpFloat, collisionSlop, CollisionSlop);
CP_DefineSpaceStructProperty(cpFloat, collisionBias, CollisionBias);
CP_DefineSpaceStructProperty(cpTimestamp, collisionPersistence, CollisionPersistence);
CP_DefineSpaceStructProperty(cpBool, enableContactGraph, EnableContactGraph);
CP_DefineSpaceStructProperty(cpDataPointer, data, UserData);
CP_DefineSpaceStructGetter(cpBody*, staticBody, StaticBody);
CP_DefineSpaceStructGetter(cpFloat, CP_PRIVATE(curr_dt), CurrentTimeStep);

static inline cpBool
cpSpaceIsLocked(cpSpace *space)
{
  return space->CP_PRIVATE(locked);
}

void cpSpaceSetDefaultCollisionHandler(
  cpSpace *space,
  cpCollisionBeginFunc begin,
  cpCollisionPreSolveFunc preSolve,
  cpCollisionPostSolveFunc postSolve,
  cpCollisionSeparateFunc separate,
  void *data
);

void cpSpaceAddCollisionHandler(
  cpSpace *space,
  cpCollisionType a, cpCollisionType b,
  cpCollisionBeginFunc begin,
  cpCollisionPreSolveFunc preSolve,
  cpCollisionPostSolveFunc postSolve,
  cpCollisionSeparateFunc separate,
  void *data
);

void cpSpaceRemoveCollisionHandler(cpSpace *space, cpCollisionType a, cpCollisionType b);

cpShape* cpSpaceAddShape(cpSpace *space, cpShape *shape);
cpShape* cpSpaceAddStaticShape(cpSpace *space, cpShape *shape);
cpBody* cpSpaceAddBody(cpSpace *space, cpBody *body);
cpConstraint* cpSpaceAddConstraint(cpSpace *space, cpConstraint *constraint);

void cpSpaceRemoveShape(cpSpace *space, cpShape *shape);
void cpSpaceRemoveStaticShape(cpSpace *space, cpShape *shape);
void cpSpaceRemoveBody(cpSpace *space, cpBody *body);
void cpSpaceRemoveConstraint(cpSpace *space, cpConstraint *constraint);

cpBool cpSpaceContainsShape(cpSpace *space, cpShape *shape);
cpBool cpSpaceContainsBody(cpSpace *space, cpBody *body);
cpBool cpSpaceContainsConstraint(cpSpace *space, cpConstraint *constraint);

typedef void (*cpPostStepFunc)(cpSpace *space, void *obj, void *data);
void cpSpaceAddPostStepCallback(cpSpace *space, cpPostStepFunc func, void *obj, void *data);

typedef void (*cpSpacePointQueryFunc)(cpShape *shape, void *data);
void cpSpacePointQuery(cpSpace *space, cpVect point, cpLayers layers, cpGroup group, cpSpacePointQueryFunc func, void *data);
cpShape *cpSpacePointQueryFirst(cpSpace *space, cpVect point, cpLayers layers, cpGroup group);

typedef void (*cpSpaceSegmentQueryFunc)(cpShape *shape, cpFloat t, cpVect n, void *data);
void cpSpaceSegmentQuery(cpSpace *space, cpVect start, cpVect end, cpLayers layers, cpGroup group, cpSpaceSegmentQueryFunc func, void *data);
cpShape *cpSpaceSegmentQueryFirst(cpSpace *space, cpVect start, cpVect end, cpLayers layers, cpGroup group, cpSegmentQueryInfo *out);

typedef void (*cpSpaceBBQueryFunc)(cpShape *shape, void *data);
void cpSpaceBBQuery(cpSpace *space, cpBB bb, cpLayers layers, cpGroup group, cpSpaceBBQueryFunc func, void *data);

typedef void (*cpSpaceShapeQueryFunc)(cpShape *shape, cpContactPointSet *points, void *data);
cpBool cpSpaceShapeQuery(cpSpace *space, cpShape *shape, cpSpaceShapeQueryFunc func, void *data);

void cpSpaceActivateShapesTouchingShape(cpSpace *space, cpShape *shape);


typedef void (*cpSpaceBodyIteratorFunc)(cpBody *body, void *data);
void cpSpaceEachBody(cpSpace *space, cpSpaceBodyIteratorFunc func, void *data);

typedef void (*cpSpaceShapeIteratorFunc)(cpShape *shape, void *data);
void cpSpaceEachShape(cpSpace *space, cpSpaceShapeIteratorFunc func, void *data);

typedef void (*cpSpaceConstraintIteratorFunc)(cpConstraint *constraint, void *data);
void cpSpaceEachConstraint(cpSpace *space, cpSpaceConstraintIteratorFunc func, void *data);

void cpSpaceReindexStatic(cpSpace *space);
void cpSpaceReindexShape(cpSpace *space, cpShape *shape);
void cpSpaceReindexShapesForBody(cpSpace *space, cpBody *body);

void cpSpaceUseSpatialHash(cpSpace *space, cpFloat dim, int count);

void cpSpaceStep(cpSpace *space, cpFloat dt);