cpSpace.h

/* Copyright (c) 2013 Scott Lembcke and Howling Moon Software
 * 
 * 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.
 */


//MARK: Definitions

typedef cpBool (*cpCollisionBeginFunc)(cpArbiter *arb, cpSpace *space, cpDataPointer userData);
typedef cpBool (*cpCollisionPreSolveFunc)(cpArbiter *arb, cpSpace *space, cpDataPointer userData);
typedef void (*cpCollisionPostSolveFunc)(cpArbiter *arb, cpSpace *space, cpDataPointer userData);
typedef void (*cpCollisionSeparateFunc)(cpArbiter *arb, cpSpace *space, cpDataPointer userData);

struct cpCollisionHandler {
  const cpCollisionType typeA;
  const cpCollisionType typeB;
  cpCollisionBeginFunc beginFunc;
  cpCollisionPreSolveFunc preSolveFunc;
  cpCollisionPostSolveFunc postSolveFunc;
  cpCollisionSeparateFunc separateFunc;
  cpDataPointer userData;
};

// TODO: Make timestep a parameter?


//MARK: Memory and Initialization

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

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


//MARK: Properties

CP_EXPORT int cpSpaceGetIterations(const cpSpace *space);
CP_EXPORT void cpSpaceSetIterations(cpSpace *space, int iterations);

CP_EXPORT cpVect cpSpaceGetGravity(const cpSpace *space);
CP_EXPORT void cpSpaceSetGravity(cpSpace *space, cpVect gravity);

CP_EXPORT cpFloat cpSpaceGetDamping(const cpSpace *space);
CP_EXPORT void cpSpaceSetDamping(cpSpace *space, cpFloat damping);

CP_EXPORT cpFloat cpSpaceGetIdleSpeedThreshold(const cpSpace *space);
CP_EXPORT void cpSpaceSetIdleSpeedThreshold(cpSpace *space, cpFloat idleSpeedThreshold);

CP_EXPORT cpFloat cpSpaceGetSleepTimeThreshold(const cpSpace *space);
CP_EXPORT void cpSpaceSetSleepTimeThreshold(cpSpace *space, cpFloat sleepTimeThreshold);

CP_EXPORT cpFloat cpSpaceGetCollisionSlop(const cpSpace *space);
CP_EXPORT void cpSpaceSetCollisionSlop(cpSpace *space, cpFloat collisionSlop);

CP_EXPORT cpFloat cpSpaceGetCollisionBias(const cpSpace *space);
CP_EXPORT void cpSpaceSetCollisionBias(cpSpace *space, cpFloat collisionBias);

CP_EXPORT cpTimestamp cpSpaceGetCollisionPersistence(const cpSpace *space);
CP_EXPORT void cpSpaceSetCollisionPersistence(cpSpace *space, cpTimestamp collisionPersistence);

CP_EXPORT cpDataPointer cpSpaceGetUserData(const cpSpace *space);
CP_EXPORT void cpSpaceSetUserData(cpSpace *space, cpDataPointer userData);

CP_EXPORT cpBody* cpSpaceGetStaticBody(const cpSpace *space);

CP_EXPORT cpFloat cpSpaceGetCurrentTimeStep(const cpSpace *space);

CP_EXPORT cpBool cpSpaceIsLocked(cpSpace *space);


//MARK: Collision Handlers

CP_EXPORT cpCollisionHandler *cpSpaceAddDefaultCollisionHandler(cpSpace *space);
CP_EXPORT cpCollisionHandler *cpSpaceAddCollisionHandler(cpSpace *space, cpCollisionType a, cpCollisionType b);
CP_EXPORT cpCollisionHandler *cpSpaceAddWildcardHandler(cpSpace *space, cpCollisionType type);


//MARK: Add/Remove objects

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

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

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

//MARK: Post-Step Callbacks

typedef void (*cpPostStepFunc)(cpSpace *space, void *key, void *data);
CP_EXPORT cpBool cpSpaceAddPostStepCallback(cpSpace *space, cpPostStepFunc func, void *key, void *data);


//MARK: Queries

// TODO: Queries and iterators should take a cpSpace parametery.
// TODO: They should also be abortable.

typedef void (*cpSpacePointQueryFunc)(cpShape *shape, cpVect point, cpFloat distance, cpVect gradient, void *data);
CP_EXPORT void cpSpacePointQuery(cpSpace *space, cpVect point, cpFloat maxDistance, cpShapeFilter filter, cpSpacePointQueryFunc func, void *data);
CP_EXPORT cpShape *cpSpacePointQueryNearest(cpSpace *space, cpVect point, cpFloat maxDistance, cpShapeFilter filter, cpPointQueryInfo *out);

typedef void (*cpSpaceSegmentQueryFunc)(cpShape *shape, cpVect point, cpVect normal, cpFloat alpha, void *data);
CP_EXPORT void cpSpaceSegmentQuery(cpSpace *space, cpVect start, cpVect end, cpFloat radius, cpShapeFilter filter, cpSpaceSegmentQueryFunc func, void *data);
CP_EXPORT cpShape *cpSpaceSegmentQueryFirst(cpSpace *space, cpVect start, cpVect end, cpFloat radius, cpShapeFilter filter, cpSegmentQueryInfo *out);

typedef void (*cpSpaceBBQueryFunc)(cpShape *shape, void *data);
CP_EXPORT void cpSpaceBBQuery(cpSpace *space, cpBB bb, cpShapeFilter filter, cpSpaceBBQueryFunc func, void *data);

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


//MARK: Iteration

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

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

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


//MARK: Indexing

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

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


//MARK: Time Stepping

CP_EXPORT void cpSpaceStep(cpSpace *space, cpFloat dt);


//MARK: Debug API

#ifndef CP_SPACE_DISABLE_DEBUG_API

typedef struct cpSpaceDebugColor {
  float r, g, b, a;
} cpSpaceDebugColor;

typedef void (*cpSpaceDebugDrawCircleImpl)(cpVect pos, cpFloat angle, cpFloat radius, cpSpaceDebugColor outlineColor, cpSpaceDebugColor fillColor, cpDataPointer data);
typedef void (*cpSpaceDebugDrawSegmentImpl)(cpVect a, cpVect b, cpSpaceDebugColor color, cpDataPointer data);
typedef void (*cpSpaceDebugDrawFatSegmentImpl)(cpVect a, cpVect b, cpFloat radius, cpSpaceDebugColor outlineColor, cpSpaceDebugColor fillColor, cpDataPointer data);
typedef void (*cpSpaceDebugDrawPolygonImpl)(int count, const cpVect *verts, cpFloat radius, cpSpaceDebugColor outlineColor, cpSpaceDebugColor fillColor, cpDataPointer data);
typedef void (*cpSpaceDebugDrawDotImpl)(cpFloat size, cpVect pos, cpSpaceDebugColor color, cpDataPointer data);
typedef cpSpaceDebugColor (*cpSpaceDebugDrawColorForShapeImpl)(cpShape *shape, cpDataPointer data);

typedef enum cpSpaceDebugDrawFlags {
  CP_SPACE_DEBUG_DRAW_SHAPES = 1<<0,
  CP_SPACE_DEBUG_DRAW_CONSTRAINTS = 1<<1,
  CP_SPACE_DEBUG_DRAW_COLLISION_POINTS = 1<<2,
} cpSpaceDebugDrawFlags;

typedef struct cpSpaceDebugDrawOptions {
  cpSpaceDebugDrawCircleImpl drawCircle;
  cpSpaceDebugDrawSegmentImpl drawSegment;
  cpSpaceDebugDrawFatSegmentImpl drawFatSegment;
  cpSpaceDebugDrawPolygonImpl drawPolygon;
  cpSpaceDebugDrawDotImpl drawDot;
  
  cpSpaceDebugDrawFlags flags;
  cpSpaceDebugColor shapeOutlineColor;
  cpSpaceDebugDrawColorForShapeImpl colorForShape;
  cpSpaceDebugColor constraintColor;
  cpSpaceDebugColor collisionPointColor;
  
  cpDataPointer data;
} cpSpaceDebugDrawOptions;

CP_EXPORT void cpSpaceDebugDraw(cpSpace *space, cpSpaceDebugDrawOptions *options);

#endif