cpSpace.h

/* Copyright (c) 2025 Victor Blomqvist
 * Copyright (c) 2007-2024 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 void (*cpCollisionBeginFunc)(cpArbiter *arb, cpSpace *space, cpDataPointer userData);
typedef void (*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 *cpSpaceAddGlobalCollisionHandler(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;
  cpTransform transform;
 
  cpDataPointer data;
} cpSpaceDebugDrawOptions;
 
CP_EXPORT void cpSpaceDebugDraw(cpSpace *space, cpSpaceDebugDrawOptions *options);
 
#endif