// written in the D programming language

module chipmunkd.constraints.cpConstraint;

import chipmunkd.chipmunk;
import chipmunkd.chipmunk_types_h;
import chipmunkd.cpVect,chipmunkd.cpVect_h;
import chipmunkd.cpBody;

alias void function(cpConstraint *constraint, cpFloat dt, cpFloat dt_inv) cpConstraintPreStepFunction;
alias void function(cpConstraint *constraint) cpConstraintApplyImpulseFunction;
alias cpFloat function(cpConstraint *constraint) cpConstraintGetImpulseFunction;

struct cpConstraintClass {
	cpConstraintPreStepFunction preStep;
	cpConstraintApplyImpulseFunction applyImpulse;
	cpConstraintGetImpulseFunction getImpulse;
}



struct cpConstraint {
	cpConstraintClass *klass;
	
	cpBody *a;
	cpBody *b;
	cpFloat maxForce;
	cpFloat biasCoef;
	cpFloat maxBias;
	
	cpDataPointer data;
}

//#ifdef CP_USE_DEPRECATED_API_4
//typedef cpConstraint cpJoint;
//#endif

//void cpConstraintDestroy(cpConstraint *constraint);
//void cpConstraintFree(cpConstraint *constraint);

static void
cpConstraintActivateBodies(cpConstraint *constraint)
{
	cpBody *a = constraint.a; if(a) cpBodyActivate(a);
	cpBody *b = constraint.b; if(b) cpBodyActivate(b);
}

static cpFloat
cpConstraintGetImpulse(cpConstraint *constraint)
{
	return constraint.klass.getImpulse(constraint);
}

template cpConstraintCheckCast(string constraint, string _struct)
{
	enum cpConstraintCheckCast = 
		"assert("~constraint~".klass == "~_struct~"GetClass(), \"Constraint is not a "~_struct~"\");";
}

//#define cpConstraintCheckCast(constraint, struct) \
//	cpAssert(constraint->klass == struct##GetClass(), "Constraint is not a "#struct);

template CP_DefineConstraintGetter(string _struct,string type,string member,string name)
{
	enum CP_DefineConstraintGetter = 
		"static "~type~" "~_struct~"Get"~name~"(cpConstraint *constraint){"~
		cpConstraintCheckCast!("constraint",_struct)~
		"cpConstraintActivateBodies(constraint);"~
		"return (cast("~_struct~"*)constraint)."~member~";"~
		"}";
}

//#define CP_DefineConstraintGetter(struct, type, member, name) \
//static inline type \
//struct##Get##name(const cpConstraint *constraint){ \
//	cpConstraintCheckCast(constraint, struct); \
//	return ((struct *)constraint)->member; \
//} \

template CP_DefineConstraintSetter(string _struct,string type,string member,string name)
{
	enum CP_DefineConstraintSetter = 
		"static void "~_struct~"Set"~name~"(cpConstraint *constraint,"~type~" value){"~
		cpConstraintCheckCast!("constraint",_struct)~
		"cpConstraintActivateBodies(constraint);"~
		"(cast("~_struct~"*)constraint)."~member~" = value;"~
		"}";
}

//#define CP_DefineConstraintSetter(struct, type, member, name) \
//static inline void \
//struct##Set##name(cpConstraint *constraint, type value){ \
//	cpConstraintCheckCast(constraint, struct); \
//	cpConstraintActivateBodies(constraint); \
//	((struct *)constraint)->member = value; \
//} \

template CP_DefineConstraintProperty(string _struct,string type,string member,string name)
{
	enum CP_DefineConstraintProperty = 
		CP_DefineConstraintGetter!(_struct,type,member,name)~CP_DefineConstraintSetter!(_struct,type,member,name);
		
}

//#define CP_DefineConstraintProperty(struct, type, member, name) \
//CP_DefineConstraintGetter(struct, type, member, name) \
//CP_DefineConstraintSetter(struct, type, member, name)
//TODO:
//// Built in Joint types
public import chipmunkd.constraints.cpPinJoint;
public import chipmunkd.constraints.cpSlideJoint;
public import chipmunkd.constraints.cpPivotJoint;
public import chipmunkd.constraints.cpGrooveJoint;
public import chipmunkd.constraints.cpDampedSpring;
public import chipmunkd.constraints.cpDampedRotarySpring;
public import chipmunkd.constraints.cpRotaryLimitJoint;
public import chipmunkd.constraints.cpRatchetJoint;
public import chipmunkd.constraints.cpGearJoint;
public import chipmunkd.constraints.cpSimpleMotor;


cpFloat cp_constraint_bias_coef = 0.1f;

void cpConstraintDestroy(cpConstraint *constraint){}

void
cpConstraintFree(cpConstraint *constraint)
{
	if(constraint){
		cpConstraintDestroy(constraint);
		cpfree(constraint);
	}
}

void
cpConstraintInit(cpConstraint *constraint, /+const+/ cpConstraintClass *klass, cpBody *a, cpBody *b)
{
	constraint.klass = klass;
	constraint.a = a;
	constraint.b = b;
	
	constraint.maxForce = cast(cpFloat)INFINITY;
	constraint.biasCoef = cp_constraint_bias_coef;
	constraint.maxBias = cast(cpFloat)INFINITY;
}