cpBody.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 void (*cpBodyVelocityFunc)(cpBody *body, cpVect gravity, cpFloat damping, cpFloat dt);
typedef void (*cpBodyPositionFunc)(cpBody *body, cpFloat dt);

typedef struct cpComponentNode {
  cpBody *root;
  cpBody *next;
  cpFloat idleTime;
} cpComponentNode;

struct cpBody {
  cpBodyVelocityFunc velocity_func;
  
  cpBodyPositionFunc position_func;
  
  cpFloat m;
  cpFloat m_inv;
  
  cpFloat i;
  cpFloat i_inv;
  
  cpVect p;
  cpVect v;
  cpVect f;
  
  cpFloat a;
  cpFloat w;
  cpFloat t;
  
  cpVect rot;
  
  cpDataPointer data;
  
  cpFloat v_limit;
  cpFloat w_limit;
  
  CP_PRIVATE(cpVect v_bias);
  CP_PRIVATE(cpFloat w_bias);
  
  CP_PRIVATE(cpSpace *space);
  
  CP_PRIVATE(cpShape *shapeList);
  CP_PRIVATE(cpArbiter *arbiterList);
  CP_PRIVATE(cpConstraint *constraintList);
  
  CP_PRIVATE(cpComponentNode node);
};

cpBody* cpBodyAlloc(void);
cpBody* cpBodyInit(cpBody *body, cpFloat m, cpFloat i);
cpBody* cpBodyNew(cpFloat m, cpFloat i);

cpBody* cpBodyInitStatic(cpBody *body);
cpBody* cpBodyNewStatic(void);

void cpBodyDestroy(cpBody *body);
void cpBodyFree(cpBody *body);

#ifdef NDEBUG
  #define cpBodyAssertSane(body)
#else
  void cpBodySanityCheck(cpBody *body);
  #define cpBodyAssertSane(body) cpBodySanityCheck(body)
#endif

// Defined in cpSpace.c
void cpBodyActivate(cpBody *body);
void cpBodyActivateStatic(cpBody *body, cpShape *filter);

void cpBodySleep(cpBody *body);
void cpBodySleepWithGroup(cpBody *body, cpBody *group);

static inline cpBool cpBodyIsSleeping(const cpBody *body)
{
  return (CP_PRIVATE(body->node).root != ((cpBody*)0));
}

static inline cpBool cpBodyIsStatic(const cpBody *body)
{
  return CP_PRIVATE(body->node).idleTime == INFINITY;
}

static inline cpBool cpBodyIsRogue(const cpBody *body)
{
  return (body->CP_PRIVATE(space) == ((cpSpace*)0));
}


#define CP_DefineBodyStructGetter(type, member, name) \
static inline type cpBodyGet##name(const cpBody *body){return body->member;}

#define CP_DefineBodyStructSetter(type, member, name) \
static inline void cpBodySet##name(cpBody *body, const type value){ \
  cpBodyActivate(body); \
  cpBodyAssertSane(body); \
  body->member = value; \
}

#define CP_DefineBodyStructProperty(type, member, name) \
CP_DefineBodyStructGetter(type, member, name) \
CP_DefineBodyStructSetter(type, member, name)

CP_DefineBodyStructGetter(cpFloat, m, Mass);
void cpBodySetMass(cpBody *body, cpFloat m);

CP_DefineBodyStructGetter(cpFloat, i, Moment);
void cpBodySetMoment(cpBody *body, cpFloat i);

CP_DefineBodyStructGetter(cpVect, p, Pos);
void cpBodySetPos(cpBody *body, cpVect pos);
CP_DefineBodyStructProperty(cpVect, v, Vel);
CP_DefineBodyStructProperty(cpVect, f, Force);
CP_DefineBodyStructGetter(cpFloat, a, Angle);
void cpBodySetAngle(cpBody *body, cpFloat a);
CP_DefineBodyStructProperty(cpFloat, w, AngVel);
CP_DefineBodyStructProperty(cpFloat, t, Torque);
CP_DefineBodyStructGetter(cpVect, rot, Rot);
CP_DefineBodyStructProperty(cpFloat, v_limit, VelLimit);
CP_DefineBodyStructProperty(cpFloat, w_limit, AngVelLimit);
CP_DefineBodyStructProperty(cpDataPointer, data, UserData);

void cpBodyUpdateVelocity(cpBody *body, cpVect gravity, cpFloat damping, cpFloat dt);
void cpBodyUpdatePosition(cpBody *body, cpFloat dt);

static inline cpVect cpBodyLocal2World(const cpBody *body, const cpVect v)
{
  return cpvadd(body->p, cpvrotate(v, body->rot));
}

static inline cpVect cpBodyWorld2Local(const cpBody *body, const cpVect v)
{
  return cpvunrotate(cpvsub(v, body->p), body->rot);
}

void cpBodyResetForces(cpBody *body);
void cpBodyApplyForce(cpBody *body, const cpVect f, const cpVect r);
void cpBodyApplyImpulse(cpBody *body, const cpVect j, const cpVect r);

cpVect cpBodyGetVelAtWorldPoint(cpBody *body, cpVect point);
cpVect cpBodyGetVelAtLocalPoint(cpBody *body, cpVect point);


static inline cpFloat cpBodyKineticEnergy(const cpBody *body)
{
  // Need to do some fudging to avoid NaNs
  cpFloat vsq = cpvdot(body->v, body->v);
  cpFloat wsq = body->w*body->w;
  return (vsq ? vsq*body->m : 0.0f) + (wsq ? wsq*body->i : 0.0f);
}

typedef void (*cpBodyShapeIteratorFunc)(cpBody *body, cpShape *shape, void *data);
void cpBodyEachShape(cpBody *body, cpBodyShapeIteratorFunc func, void *data);

typedef void (*cpBodyConstraintIteratorFunc)(cpBody *body, cpConstraint *constraint, void *data);
void cpBodyEachConstraint(cpBody *body, cpBodyConstraintIteratorFunc func, void *data);

typedef void (*cpBodyArbiterIteratorFunc)(cpBody *body, cpArbiter *arbiter, void *data);
void cpBodyEachArbiter(cpBody *body, cpBodyArbiterIteratorFunc func, void *data);