Newton 2 wrapper

void onsetdestructor(NewtonBody *body)
{
	ENTITY *entity = (ENTITY*)NewtonBodyGetUserData(body);
	if (entity) {ent_remove(entity);}
}

if (key_x)
{
if (my.skill99!=0) {NewtonDestroyBody(nworld,(NewtonBody*) my.skill99);}
}

void newton_start()
{
	newton_running = 1;
	nworld = NewtonCreate(0, 0);
	
	newton_addstaticcollisiongeometry();
	
	while(newton_running) // newton has to update every frame
	{
		advance = time_frame/16;
		slices = integer((advance / MIN_NEWTON_ADVANCE) + 1);

		for (slices_left = slices; slices_left > 0; slices_left--){
			NewtonUpdate(nworld, advance/slices);
		}
		wait(1);
		proc_mode = PROC_LATE;	

	}
}

#define MAX_NEWTON_ADVANCE 0.01

int advance = time_frame/16;
		int slices = integer((advance / MAX_NEWTON_ADVANCE) + 1);
		int slices_left;

		for (slices_left = slices; slices_left > 0; slices_left--){
			NewtonUpdate(nworld, advance/slices);
		}

target_velocity = mickey.y/(time_frame/16)
acceleration = (target_velocity - actual_velocity)/(time_frame/16)

thing = ent_create("model.mdl", vector(0, 1, 1), NULL);
nthing = newton_addentity(thing, .05, NEWTON_CONVEXHULL, NULL);

joint = NewtonConstraintCreateCorkscrew (nworld, vectorf(0, QUANTTOMETER*1, QUANTTOMETER*1), vectorf(1, 0, 0), nthing, NULL); //no need for an actual second body
NewtonCorkscrewSetUserCallback(joint, movement_callback);

sensitivity = 0.005; //this is used to scale the mouse movement to acceptable velocities.
actual_velocity = NewtonCorkscrewGetJointVeloc(joint);
target_velocity = mickey.y * sensitivity /(time_frame/16) //mickey.y is given by the engine
acceleration = (target_velocity - actual_velocity)/(time_frame/16)

movement_callback (const NewtonJoint* joint, NewtonHingeSliderUpdateDesc* desc){
  desc[0].m_accel = acceleration; //the NewtonHingeSliderUpdateDesc struct was provided, as is, by the wrapper in 1.53
  retCode |= 1; //or with 0x01 to tell newton this axis is active. Don't know if it is still required in 2.0
}

- function NewtonBodyGetAutoFreeze is changed to NewtonBodyGetAutoSleep
- function NewtonBodySetAutoFreeze is changed to NewtonBodySetAutoSleep

void onforceandtorque(NewtonBody* body)
{
	float mass, ixx, iyy, izz;
	NewtonBodyGetMassMatrix(body, &mass, &ixx, &iyy, &izz);
	NewtonBodySetForce(body, vectorf(0, 0, -9.8 * mass));
}

ENTITY* car;
var camerapanmodifier = 0;
void tireUpdate(const NewtonJoint* vehicle)
{
	int tireId;
	float m[16];
	ENTITY* tireModel;
	for (tireId = NewtonVehicleGetFirstTireID (vehicle); tireId!=NULL; tireId = NewtonVehicleGetNextTireID (vehicle, tireId)) 
	{
		tireModel = NewtonVehicleGetTireUserData (vehicle, tireId);
		NewtonVehicleGetTireMatrix( vehicle,tireId, m);
		ent_setmatrix_rb(tireModel,m);
	}
}



action Visual_Car(){
	while(car!=NULL){
		vec_set(my.x,car.x);
		vec_set(my.pan,car.pan);
		wait(1);
	}
}

action Newton_Car()
{
	car = me;
	set(my,INVISIBLE);//hide the physical proxy

	while(!newton_running){wait(1);}
	
	NewtonBody* car_body=newton_addentity(me, 100, NEWTON_CONVEXHULL, onforceandtorque);
	NewtonBodySetAutoFreeze( car_body, 0);
	NewtonBodySetLinearDamping(car_body,0.03);
	ent_create("kasa1.mdl",nullvector,Visual_Car);//car model


	float upDirection[] = {0.0, 0.0, 1.0};
	NewtonJoint* car_joint = NewtonConstraintCreateVehicle(nworld, upDirection[0], car_body);
	NewtonVehicleSetTireCallback(car_joint, tireUpdate); 
	
	int tireMass = 10;
	float suspensionLength = 0.1;
	float suspensionSpring =3000.0;
	float suspensionShock = 10.0;
	float wheelradius = 0.5;
	float tirePin[] = {0.0, 1.0, 0.0};
	

	
	D3DXMATRIX tire_offset;
	VECTOR tirepos;
	
	
	vec_for_bone(tirepos,me,"osol");//f left
	vec_sub(tirepos,my.x);
	D3DXMatrixTranslation(&tire_offset, tirepos.x * QUANTTOMETER,tirepos.y * QUANTTOMETER,tirepos.z * QUANTTOMETER);												
	NewtonVehicleAddTire(car_joint, &tire_offset, tirePin[0], tireMass, wheelradius, wheelradius, suspensionShock,suspensionSpring,suspensionLength, ent_create("teker1.mdl",nullvector,NULL), 0);
	
	
	vec_for_bone(tirepos,me,"osag");//f right
	vec_sub(tirepos,my.x);
	D3DXMatrixTranslation(&tire_offset, tirepos.x * QUANTTOMETER,tirepos.y * QUANTTOMETER,tirepos.z * QUANTTOMETER);		
	NewtonVehicleAddTire(car_joint, &tire_offset, tirePin[0], tireMass, wheelradius, wheelradius, suspensionShock,suspensionSpring,suspensionLength, ent_create("teker1.mdl",nullvector,NULL), 1);
	
	vec_for_bone(tirepos,me,"asol");//r left
	vec_sub(tirepos,my.x);
	D3DXMatrixTranslation(&tire_offset, tirepos.x * QUANTTOMETER,tirepos.y * QUANTTOMETER,tirepos.z * QUANTTOMETER);		
	NewtonVehicleAddTire(car_joint, &tire_offset, tirePin[0], tireMass, wheelradius, wheelradius, suspensionShock,suspensionSpring,suspensionLength, ent_create("teker1.mdl",nullvector,NULL), 2);
	
	vec_for_bone(tirepos,me,"asag");//r left
	vec_sub(tirepos,my.x);
	D3DXMatrixTranslation(&tire_offset, tirepos.x * QUANTTOMETER,tirepos.y * QUANTTOMETER,tirepos.z * QUANTTOMETER);		
	NewtonVehicleAddTire(car_joint, &tire_offset, tirePin[0], tireMass, wheelradius, wheelradius, suspensionShock,suspensionSpring,suspensionLength, ent_create("teker1.mdl",nullvector,NULL), 3);
	
	
	while(1){
		wait(1);
		camera.pan = my.pan + camerapanmodifier;
		camerapanmodifier += mouse_force.x*time_step*10;
		camera.x = my.x - 700*cosv(camera.pan);
		camera.y = my.y - sinv(camera.pan)*700;
		camera.z = my.z + 200;
		camera.tilt =-15;
	}
}

var temp_var;
float temp_float;

ENTITY* car;
ENTITY* FLwheelPtr;
ENTITY* FRwheelPtr;
ENTITY* BLwheelPtr;
ENTITY* BRwheelPtr;
ENTITY* tireId;
ENTITY* tireModel;
D3DXMATRIX m;

void tireUpdate(NewtonJoint* vehicle)
{
	// FOR EACH TIRE APPLY THESE VALUES
	for (tireId = NewtonVehicleGetFirstTireID (vehicle); tireId!=NULL; tireId = NewtonVehicleGetNextTireID (vehicle, tireId)) 
	{
		NewtonVehicleSetTireSideSleepCoeficient(vehicle,tireId,0.0);
		NewtonVehicleSetTireMaxSideSleepSpeed (vehicle,tireId,999.0);
		NewtonVehicleSetTireLongitudinalSlideCoeficient(vehicle,tireId,0.0);
		NewtonVehicleSetTireMaxLongitudinalSlideSpeed (vehicle,tireId,999.0);
	}
	
	
	// CALCULATE AVERAGE TIRE SPEED
	tireId = NewtonVehicleGetFirstTireID(vehicle);
	temp_var = NewtonVehicleGetTireLongitudinalSpeed(vehicle,tireId);
	tireId = NewtonVehicleGetNextTireID(vehicle, tireId);
	temp_var += NewtonVehicleGetTireLongitudinalSpeed(vehicle,tireId);
	tireId = NewtonVehicleGetNextTireID(vehicle, tireId);
	temp_var += NewtonVehicleGetTireLongitudinalSpeed(vehicle,tireId);
	tireId = NewtonVehicleGetNextTireID(vehicle, tireId);
	temp_var += NewtonVehicleGetTireLongitudinalSpeed(vehicle,tireId);
	temp_var *= 0.25;
	
	
	if(key_w)
	{
		if(temp_var<-2) //if tires average speed is smaller than -2 and key W pressed  >>>>>> APPLY BRAKE TO ALL TIRES
		{
			tireId = NewtonVehicleGetFirstTireID(vehicle);        //tireId 0   //Front Left
			temp_float = NewtonVehicleTireCalculateMaxBrakeAcceleration(vehicle,tireId) * 0.7;
			NewtonVehicleTireSetBrakeAcceleration(vehicle,tireId,temp_float,temp_float);
			
			tireId = NewtonVehicleGetNextTireID(vehicle, tireId); //tireId 1   //Front Right
			temp_float = NewtonVehicleTireCalculateMaxBrakeAcceleration(vehicle,tireId) * 0.7;
			NewtonVehicleTireSetBrakeAcceleration(vehicle,tireId,temp_float,temp_float);
			
			tireId = NewtonVehicleGetNextTireID(vehicle, tireId); //tireId 2   //Back Left
			temp_float = NewtonVehicleTireCalculateMaxBrakeAcceleration(vehicle,tireId) * 0.7;
			NewtonVehicleTireSetBrakeAcceleration(vehicle,tireId,temp_float,temp_float);
			
			tireId = NewtonVehicleGetNextTireID(vehicle, tireId); //tireId 3   //Back Right
			temp_float = NewtonVehicleTireCalculateMaxBrakeAcceleration(vehicle,tireId) * 0.7;
			NewtonVehicleTireSetBrakeAcceleration(vehicle,tireId,temp_float,temp_float);
		}
		else //else >>>>>> APPLY 1500 TORQUE FORWARD TO REAR TIRES 
		{
			tireId = NewtonVehicleGetFirstTireID(vehicle);        //tireId 0   //Front Left	
			tireId = NewtonVehicleGetNextTireID(vehicle, tireId); //tireId 1   //Front Right
			
			tireId = NewtonVehicleGetNextTireID(vehicle, tireId); //tireId 2   //Back Left
			NewtonVehicleSetTireTorque(vehicle,tireId,1500);
			
			tireId = NewtonVehicleGetNextTireID(vehicle, tireId); //tireId 3   //Back Right
			NewtonVehicleSetTireTorque(vehicle,tireId,1500);
		}
	}
	else if(key_s)
	{
		if(temp_var<2) //if tires average speed is smaller than 2 >>>>>> APPLY 1500 TORQUE BACKWARD TO REAR TIRES 
		{
			tireId = NewtonVehicleGetFirstTireID(vehicle);        //tireId 0   //Front Left	
			tireId = NewtonVehicleGetNextTireID(vehicle, tireId); //tireId 1   //Front Right
			
			tireId = NewtonVehicleGetNextTireID(vehicle, tireId); //tireId 2   //Back Left
			NewtonVehicleSetTireTorque(vehicle,tireId,-1500);
			
			tireId = NewtonVehicleGetNextTireID(vehicle, tireId); //tireId 3   //Back Right
			NewtonVehicleSetTireTorque(vehicle,tireId,-1500);
		}
		else //else >>>>>> APPLY BRAKE TO ALL TIRES
		{
			tireId = NewtonVehicleGetFirstTireID(vehicle);        //tireId 0   //Front Left
			temp_float = NewtonVehicleTireCalculateMaxBrakeAcceleration(vehicle,tireId) * 0.7;
			NewtonVehicleTireSetBrakeAcceleration(vehicle,tireId,temp_float,temp_float);
			
			tireId = NewtonVehicleGetNextTireID(vehicle, tireId); //tireId 1   //Front Right
			temp_float = NewtonVehicleTireCalculateMaxBrakeAcceleration(vehicle,tireId) * 0.7;
			NewtonVehicleTireSetBrakeAcceleration(vehicle,tireId,temp_float,temp_float);
			
			tireId = NewtonVehicleGetNextTireID(vehicle, tireId); //tireId 2   //Back Left
			temp_float = NewtonVehicleTireCalculateMaxBrakeAcceleration(vehicle,tireId) * 0.7;
			NewtonVehicleTireSetBrakeAcceleration(vehicle,tireId,temp_float,temp_float);
			
			tireId = NewtonVehicleGetNextTireID(vehicle, tireId); //tireId 3   //Back Right
			temp_float = NewtonVehicleTireCalculateMaxBrakeAcceleration(vehicle,tireId) * 0.7;
			NewtonVehicleTireSetBrakeAcceleration(vehicle,tireId,temp_float,temp_float);
		}
	}
	
	
	
	if(key_a) //if key A >>>>>> SET FRONT TIRES ANGLE TO 0.35 RADIAN
	{
		tireId = NewtonVehicleGetFirstTireID(vehicle);        //tireId 0   //Front Left
		NewtonVehicleSetTireSteerAngle(vehicle,tireId,0.35);
		
		tireId = NewtonVehicleGetNextTireID(vehicle, tireId); //tireId 1   //Front Right
		NewtonVehicleSetTireSteerAngle(vehicle,tireId,0.35);
	}
	else if(key_d) //if key D >>>>>> SET FRONT TIRES ANGLE TO -0.35 RADIAN
	{
		tireId = NewtonVehicleGetFirstTireID(vehicle);        //tireId 0   //Front Left
		NewtonVehicleSetTireSteerAngle(vehicle,tireId,-0.35);
		
		tireId = NewtonVehicleGetNextTireID(vehicle, tireId); //tireId 1   //Front Right
		NewtonVehicleSetTireSteerAngle(vehicle,tireId,-0.35);
	}
	else //else >>>>>> SET FRONT TIRES ANGLE TO 0.0 RADIAN
	{
		tireId = NewtonVehicleGetFirstTireID(vehicle);        //tireId 0   //Front Left
		NewtonVehicleSetTireSteerAngle(vehicle,tireId,0.0);
		
		tireId = NewtonVehicleGetNextTireID(vehicle, tireId); //tireId 1   //Front Right
		NewtonVehicleSetTireSteerAngle(vehicle,tireId,0.0);
	}
	
}

action Newton_Car()
{	
	car = me;
	while(!newton_running){wait(1);}
	
	NewtonBody* car_body = newton_addentity(me, 1000, NEWTON_CONVEXHULL, tireRubberID, onforceandtorque);
	NewtonBodySetAutoFreeze( car_body, 0);
	NewtonBodySetLinearDamping(car_body,0.005);
//	NewtonBodySetAngularDamping(car_body,vectorf(0.5,0.5,0.5));


	float upDir[3] = {0.0, 0.0, 1.0};
	NewtonJoint* car_joint = NewtonConstraintCreateVehicle(nworld, upDir[0], car_body);
	
	
	int tireMass = 30;
	float suspensionLength = 0.25;
	float suspensionSpring =700.0;
	float suspensionShock = 60.0;
	float wheelradius = 0.4;
	float tirePin[3] = {0.0, 1.0, 0.0};
	D3DXMATRIX tire_offset;
	VECTOR tirepos;
	
	vec_for_bone(tirepos,me,"FLBone");
	vec_sub(tirepos,my.x);
	D3DXMatrixTranslation(&tire_offset, tirepos.x * QUANTTOMETER,tirepos.y * QUANTTOMETER,tirepos.z * QUANTTOMETER);												
	NewtonVehicleAddTire(car_joint, &tire_offset, tirePin[0], tireMass, wheelradius, wheelradius, suspensionShock,suspensionSpring,suspensionLength, FLwheelPtr, 5);
	
	vec_for_bone(tirepos,me,"FRBone");
	vec_sub(tirepos,my.x);
	D3DXMatrixTranslation(&tire_offset, tirepos.x * QUANTTOMETER,tirepos.y * QUANTTOMETER,tirepos.z * QUANTTOMETER);		
	NewtonVehicleAddTire(car_joint, &tire_offset, tirePin[0], tireMass, wheelradius, wheelradius, suspensionShock,suspensionSpring,suspensionLength, FRwheelPtr, 5);
	
	vec_for_bone(tirepos,me,"BLBone");
	vec_sub(tirepos,my.x);
	D3DXMatrixTranslation(&tire_offset, tirepos.x * QUANTTOMETER,tirepos.y * QUANTTOMETER,tirepos.z * QUANTTOMETER);		
	NewtonVehicleAddTire(car_joint, &tire_offset, tirePin[0], tireMass, wheelradius, wheelradius, suspensionShock,suspensionSpring,suspensionLength, BLwheelPtr, 5);
	
	vec_for_bone(tirepos,me,"BRBone");
	vec_sub(tirepos,my.x);
	D3DXMatrixTranslation(&tire_offset, tirepos.x * QUANTTOMETER,tirepos.y * QUANTTOMETER,tirepos.z * QUANTTOMETER);		
	NewtonVehicleAddTire(car_joint, &tire_offset, tirePin[0], tireMass, wheelradius, wheelradius, suspensionShock,suspensionSpring,suspensionLength, BRwheelPtr, 5);
	
	NewtonVehicleSetTireCallback(car_joint, tireUpdate); 
	

	while(me!=NULL)
	{
		// SET ALL TIRES POSITION AND ANGLE [ THESE LINES ARE NOT AT TIRE CALLBACK FUNC. BECAUSE MAKING THAT CAUSES VISUAL TIRES TO UPDATE 1 FRAME LATER THAN NEWTON TIRES ]
		for (tireId = NewtonVehicleGetFirstTireID (car_joint); tireId!=NULL; tireId = NewtonVehicleGetNextTireID (car_joint, tireId)) 
		{
			tireModel = NewtonVehicleGetTireUserData (car_joint, tireId);
			NewtonVehicleGetTireMatrix(car_joint,tireId, m);
			ent_setmatrix_rb(tireModel,m);
		}
		
		wait(1);
	}

}

	FLwheelPtr = ent_create("tekerlekL.mdl",nullvector,NULL);
	FRwheelPtr = ent_create("tekerlekR.mdl",nullvector,NULL);
	BLwheelPtr = ent_create("tekerlekL.mdl",nullvector,NULL);
	BRwheelPtr = ent_create("tekerlekR.mdl",nullvector,NULL);
	
	you = ent_create("350z.mdl",vector(6500,-1200,1100),Newton_Car);

// FOR EACH TIRE APPLY THESE VALUES
	for (tireId = NewtonVehicleGetFirstTireID (vehicle); tireId!=NULL; tireId = NewtonVehicleGetNextTireID (vehicle, tireId)) 
	{
		NewtonVehicleSetTireSideSleepCoeficient(vehicle,tireId,0.0);
		NewtonVehicleSetTireMaxSideSleepSpeed (vehicle,tireId,999.0);
		NewtonVehicleSetTireLongitudinalSlideCoeficient(vehicle,tireId,0.0);
		NewtonVehicleSetTireMaxLongitudinalSlideSpeed (vehicle,tireId,999.0);
	}

void onforceandtorque(NewtonBody* body)
{
	float mass, ixx, iyy, izz;
	NewtonBodyGetMassMatrix(body, &mass, &ixx, &iyy, &izz);
	ENTITY *entity = (ENTITY*)NewtonBodyGetUserData(body);
	NewtonBodySetForce(body, vectorf(0,0,gravity_z * mass));
}

ENTITY *entity = (ENTITY*)NewtonBodyGetUserData(body);

void ent_setmatrix_rb(ENTITY *entity, float *m)
{
	float pan, tilt, roll;
	
	if(fabs(m[2]) > 0.9999) // looking straight up or down -> gimbal lock
	{
		pan = atan2(-m[4], m[5]); // -m[4]?
		tilt = 1.570796 * sign(m[2]);
		roll = 0;
	}
	else
	{
		pan = atan2(m[1], m[0]); // swap?
		tilt = atan2(m[2],sqrt(m[1]*m[1] + m[0]*m[0]));
		roll = atan2(m[6], m[10]);
	}
	
	entity->pan = pan * RAD2DEG;
	entity->tilt = tilt * RAD2DEG;
	entity->roll = roll * RAD2DEG;
	
	entity->x = m[12] * METERTOQUANT;
	entity->y = m[13] * METERTOQUANT;
	entity->z = m[14] * METERTOQUANT;
}

vec_for_bone(temp,my,"Bone9");	ent=ent_create("box_a.mdl",vector(temp.x,temp.y,temp.z+20),bone);	bone_t=newton_addentity(ent,0,NEWTON_BOX,onforceandtorque);
you=ent_create("box_a.mdl",vector(temp.x,temp.y10,temp.z20),bone);
ragdoll_ent=newton_addentity(you,70,NEWTON_BOX,onforceandtorque);
NewtonConstraintCreateHinge(nworld,ent.x,vector(0,1,0),bone_t,ragdoll_ent);

dFloat ang_point[3];
   dFloat ang_rotation[3];
vec_for_bone(temp.x,my,"Bone9");
ent=ent_create("box_a.mdl",vector(temp.x,temp.y,temp.z+10),bone);
bone_t = newton_addentity(ent,0,NEWTON_BOX,onforceandtorque);
you=ent_create("box_a.mdl",vector(temp.x,temp.y,temp.z),bone);
	ragdoll_ent=newton_addentity(you,70,NEWTON_BOX,onforceandtorque);
ang_point[0] = temp.x;
ang_point[1] = temp.y;
ang_point[2] = temp.z;
ang_rotation[0] = 0;
ang_rotation[1] = 1;
ang_rotation[2] = 0;	NewtonConstraintCreateHinge(nworld,ang_point[3],ang_rotation,bone_t,ragdoll_ent);

ENTITY* test_unit;

void UserContactRestitution22 (const NewtonJoint* contactJoint, dFloat timestep, int threadIndex)
{
	dFloat Ixx;
	dFloat Iyy;
	dFloat Izz;
	dFloat mass;
	
	const NewtonBody* body;
	const NewtonBody* body0;
	const NewtonBody* body1;

	GenericContactProcess (contactJoint, timestep, threadIndex);

	body0 = NewtonJointGetBody0(contactJoint);
	body1 = NewtonJointGetBody1(contactJoint);

	body = body0;
	NewtonBodyGetMassMatrix (body, &mass, &Ixx, &Iyy, &Izz);
	if (mass == (float)0.0) {
		body = body1;
	}
	
	void* contact;
	for (contact = NewtonContactJointGetFirstContact (contactJoint); contact; contact = NewtonContactJointGetNextContact (contactJoint, contact)) {
		NewtonMaterial* nmaterial;
		nmaterial = NewtonContactGetMaterial (contact);
		
		you = (ENTITY*)NewtonBodyGetUserData(body);
		test_unit = (ENTITY*)NewtonBodyGetUserData(NewtonJointGetBody1(contactJoint));
		//NewtonMaterialSetContactElasticity (nmaterial, (float)you.skill98);
		
		if(test_unit != NULL)
		{
		if(you.skill10 == 1 && test_unit.skill10 == 2)// i have set both you en test_unit to the correct value
		{
		float pos[3], n[3];
		NewtonMaterialGetContactPositionAndNormal(nmaterial, pos, n);
		
		you.skill8 = 8; // add force on a other func else force get duplicated
		
		VECTOR pos_vec;
		VECTOR n_vec;
		vec_set(pos_vec,_vec(pos[0],pos[1],pos[2]));
		vec_scale(pos_vec,METERTOQUANT);
		draw_point3d(pos_vec,vector(0,0,255),100,5);
		}
		}
	}
}

var num = 0;
while ( (ent_getmesh(NULL, num, 0) != NULL) )
{
   newton_treecollisionaddentity(treecollision, NULL, num);
   num ++;
}

void newton_treecollisionaddentity(NewtonCollision* treecollision, ENTITY* entity, var argnum)
{
   var num = 0; 
   if(!entity) 
   {
      num = argnum;
   }
	
   LPD3DXMESH pmesh = (LPD3DXMESH)ent_getmesh(entity, num, 0);
   /* ... */

   if (entity)
   {
   //transform
   }
   else
   {
    // don't transform? 
     // add triangles to collision tree
      for(i = 0; i < numfaces; i++)
      {	
         float v[9];
         v[0] = pvertices[pindices[(i*3)+2]].x * QUANTTOMETER;
         v[1] = pvertices[pindices[(i*3)+2]].y * QUANTTOMETER;
         v[2] = pvertices[pindices[(i*3)+2]].z * QUANTTOMETER;
         v[3] = pvertices[pindices[(i*3)+1]].x * QUANTTOMETER;
         v[4] = pvertices[pindices[(i*3)+1]].y * QUANTTOMETER;
         v[5] = pvertices[pindices[(i*3)+1]].z * QUANTTOMETER;
         v[6] = pvertices[pindices[(i*3)+0]].x * QUANTTOMETER;
         v[7] = pvertices[pindices[(i*3)+0]].y * QUANTTOMETER;
         v[8] = pvertices[pindices[(i*3)+0]].z * QUANTTOMETER;
         NewtonTreeCollisionAddFace(treecollision, 3, v,12,   pattributes[i]);
         }
   }
/* ... */
}

void newton_update()
{
  var newtonFPS = 1000;
  if ((newton_running) && (nworld!=0))
  {
			
  float dt = time_frame / 16;
  var vratio = (dt * newtonFPS);
  var n = integer(vratio) + 1;
  float subDt = dt / n;
  int i;
  for ( i = 0; i < n; i++ )
    NewtonUpdate(nworld, subDt);
    //  proc_mode = PROC_LATE;	
  }	
}

action ball_newt()
{
  wait(3);
  gnBall = newton_addentity(me, 75, NEWTON_SPHERE, onforceandtorque);
  NewtonBodySetContinuousCollisionMode(gnBall, 1); // avoid tunnelling
}

NewtonJoint* newton_getjoint(ENTITY* entBody)
{
	NewtonJoint* psJoint = NULL;
	
	if (entBody->skill98 != 0)
	{
		psJoint = entBody->skill98;
	}
	return psJoint;
}

NewtonBody* newton_getbody(ENTITY* entBody)
{
	NewtonBody* psBody = NULL;
	
	if (entBody->skill99 != 0)
	{
		psBody = entBody->skill99;
	}
	return psBody;
}

NewtonWorld* nworld = NULL;



NewtonWorld* newton_getworld()
{
	return nworld;
}

NewtonJoint* newton_createhinge(VECTOR* vecPivot, VECTOR* vecAxis, ENTITY* entBody1, ENTITY* entBody2, void* fpCallback)
{
	NewtonBody* psBody1 = NULL;
	NewtonBody* psBody2 = NULL;
	NewtonJoint* psJoint;
	float* fpPivot;
	float* fpAxis;
	
	/* get Newton bodies */
	if (entBody1 != NULL)
	{
		psBody1 = entBody1->skill99;
	}
	
	if (entBody2 != NULL)
	{
		psBody2 = entBody2->skill99;
	}

	fpPivot = vectorf(vecPivot);
	fpPivot[0] *= QUANTTOMETER;
	fpPivot[1] *= QUANTTOMETER;
	fpPivot[2] *= QUANTTOMETER;

	fpAxis = vectorf(vecAxis);

	psJoint = NewtonConstraintCreateHinge (psWorld, fpPivot, fpAxis, psBody1, psBody2);
	if (fpCallback != NULL)
	{
		NewtonHingeSetUserCallback (psJoint, fpCallback);
	}


	/* store joint pointers in related objects */
	if (entBody1 != NULL)
	{
		entBody1->skill98 = psJoint;
	}
	
	if (entBody2 != NULL)
	{
		entBody2->skill98 = psJoint;
	}
}

NewtonJoint* newton_createslider(VECTOR* vecPivot, VECTOR* vecDir, ENTITY* entBody1, ENTITY* entBody2, void* fpCallback)
{
	NewtonBody* psBody1 = NULL;
	NewtonBody* psBody2 = NULL;
	NewtonJoint* psJoint;
	float* fpPivot;
	float* fpDir;
	
	/* get Newton bodies */
	if (entBody1 != NULL)
	{
		psBody1 = entBody1->skill99;
	}
	
	if (entBody2 != NULL)
	{
		psBody2 = entBody2->skill99;
	}

	fpPivot = vectorf(vecPivot);
	fpPivot[0] *= QUANTTOMETER;
	fpPivot[1] *= QUANTTOMETER;
	fpPivot[2] *= QUANTTOMETER;

	fpDir = vectorf(vecDir);

	psJoint = NewtonConstraintCreateSlider(psWorld, fpPivot, fpDir, psBody1, psBody2); 
	if (fpCallback != NULL)
	{
		NewtonSliderSetUserCallback (psJoint, fpCallback);
	}
	
	/* store joint pointers in related objects */
	if (entBody1 != NULL)
	{
		entBody1->skill98 = psJoint;
	}
	
	if (entBody2 != NULL)
	{
		entBody2->skill98 = psJoint;
	}
}

void my_onforceandtorque(NewtonBody* body)
{
	float mass, ixx, iyy, izz;
	NewtonBodyGetMassMatrix(body, &mass, &ixx, &iyy, &izz);
	NewtonBodySetForce(body, vectorf(0, 0, 0));
}

function player()
{
wait(2);
newton_addentity(me, (float)(9), NEWTON_BOX,my_onforceandtorque);

...

function player()
{
wait(2);
newton_addentity(me, (float)(9), NEWTON_BOX,NULL);
...

//about x axis
	float pinPivotMatrix[16] = {1, 0, 0, 0,   0, 1, 0, 0,   0, 0, 1, 0,   0, 0, 0, 1};
		//about y axis
	//float pinPivotMatrix[16] = {0, 1, 0, 0,   1, 0, 0, 0,   0, 0, 1, 0,   0, 0, 0, 1};
		//about z axis
	//float pinPivotMatrix[16] = {0, 0, 1, 0,   1, 0, 0, 0,   0, 1, 0, 0,   0, 0, 0, 1};
	
//Set the position of the pivot point
	pinPivotMatrix[12] = 160*QUANTTOMETER;
	pinPivotMatrix[13] = 147*QUANTTOMETER;
	pinPivotMatrix[14] = 400*QUANTTOMETER;
	
	NewtonUserJoint* nujoint = CreateCustomHinge(pinPivotMatrix, nbodyChild, nbodyParent); 

	HingeEnableLimits (nujoint, 1);
	float ub = 45*DEG2RAD;
	float lb = -45*DEG2RAD;
	HingeSetLimis (nujoint, lb, ub);

//typedef void NewtonUserJointDestructorCallback;
//typedef long NewtonUserJointSubmitConstraintCallback;
typedef void *NewtonUserJointDestructorCallback; 
typedef void *NewtonUserJointSubmitConstraintCallback;

// generic joint functions
...
JOINTLIBRARY_API NewtonJoint* CustomGetNewtonJoint (const NewtonUserJoint *joint); 
...
// Interface for a custom Hinge joint with Limits
JOINTLIBRARY_API dFloat HingeGetJointAngle (const NewtonUserJoint* hingeJoint);  
JOINTLIBRARY_API void HingeGetPinAxis (const NewtonUserJoint* hingeJoint, dFloat* pin); 
JOINTLIBRARY_API dFloat HingeCalculateJointOmega (const NewtonUserJoint* hingeJoint);

// genetic joint functions
...
API (CustomGetNewtonJoint, jointlibrary)
...
// Interface for a custom Hinge joint with Limits
...
API (HingeGetJointAngle, jointlibrary) 
API (HingeGetPinAxis, jointlibrary) 
API (HingeCalculateJointOmega, jointlibrary)

#include <d3d9.h>

/* Newton includes */
#define PRAGMA_PATH "newton"
#define PRAGMA_PLUGIN "newton.dll"

/* 
   1 meter = 32 quants
*/
float QUANTTOMETER = 0.03125;
float METERTOQUANT = 32;




#include "NewtonMain2.18.c"
#include "NewtonAPI2.18.c"

NewtonWorld* nworld = NULL;

#include "matrix.c"
#include "newton_materials.c"
#include "newton_main.c"
#include "newton_debug.c"

//set some level preferences
//load the level
newton_start();
wait(3);
ENTITY* ball = ent_create("kugel.mdl", nullvector, NULL);
newton_addentity(ball, 75, NEWTON_SPHERE, onforceandtorque);
	
while(1){
	newton_update();
	wait(1);
}

ent_create("shells/9mm.mdl", player.x, bullet_phys);

action bullet_phys()
{
	wait(3);
	newton_addentity(me, (float)75, NEWTON_CYLINDER, onforceandtorque);
	//set(me, PASSABLE);
	//pXent_settype(me,PH_RIGID,PH_CAPSULE );
	//pXent_setccdskeleton( me, vector(0, 0, 0), 0 );
	//pXent_setelasticity(my, 10);
}

/*
Containing class vars:
handOrn = target orientation quaternion
hand pos = target position
... interpolated values to follow point in front player camera somewhat smoothly
*/

void AccumulateForce (float timestep)
   {
      //position... (code from older newton demos)

      if (!pickedBody) return;
      float MOUSE_PICK_DAMP = 20.0f;
      float MOUSE_PICK_STIFFNESS = 150.0f;
      float ANGULAR_STIFFNESS = 0.1f;

      float mass;
      float Ixx;
      float Iyy;
      float Izz;
      sVec3 com;
      sVec3 veloc;
      sMat4 matrix;
      BodyGetMatrix(pickedBody, matrix);

      BodyGetVelocity (pickedBody, veloc);
      BodyGetMassMatrix (pickedBody, mass, Ixx, Iyy, Izz);

                sVec3 pickedForce = handPos - matrix[3]; // body position
      float mag2 = pickedForce.SqL();
      if (mag2 > 20.0f * 20.0f) pickedForce *= 20.0f / sqrt (mag2);
      sVec3 force (pickedForce * mass * MOUSE_PICK_STIFFNESS);
      sVec3 dampForce (veloc * mass * MOUSE_PICK_DAMP);
      force -= dampForce;
      sVec3 grav (0.0f, mass * GRAVITY_Y, 0.0f);
      force -= grav;

            
      BodyData *data = (BodyData*) BodyGetUserData (pickedBody); // containing force and torque vectors, which are the applied in the callback
      
      data->force += force;

      // orientation...
      sQuat q;
      BodyGetRotation (pickedBody, q);

      sVec3 curAngVel;
      BodyGetAngVel (pickedBody, curAngVel); // == NewtonBodyGetOmega
      
      sVec3 targetAngVel = AngVelFromAToB (q, handOrn) * (1 / timestep * ANGULAR_STIFFNESS);
      sVec3 torque = ConvertAngVelToTorque (targetAngVel, curAngVel, matrix, timestep, mass, Ixx, Iyy, Izz);
      data->torque += torque;

      BodyActivate (pickedBody);
   }



// utilitys...


// convert rotational offset to angular velocity (divide by time afterwards)
inline sVec3 AngVelFromAToB (const sQuat &qA, const sQuat &qB)
{

   const float matchTolerance = 0.01f;
   const float faultTolerance = 0.05f;

   sQuat q = QuatFromAToB (qA, qB);
   sVec3 *omegaDir = (sVec3*)&q;
   float sql = omegaDir->SqL();
   if (sql   < (matchTolerance * matchTolerance))
      return sVec3 (0, 0, 0);

   float length = sqrt (sql);
   if (q[3] < -1) q[3] = -1;
   if (q[3] >  1) q[3] =  1;
   sVec3 angVel = (*omegaDir / length) * (2.0 * acos(q[3]));
   if (length   < faultTolerance) angVel *= (length - matchTolerance) / (faultTolerance - matchTolerance);
   return angVel;

}

// choose shortest rotation between 2 orientations
inline sQuat QuatFromAToB (const sQuat &qA, const sQuat &qB)
{
   sQuat q;
   if (qA.Dot(qB) < 0.0f)
   {
      q[0] = qA[0]; q[1] = qA[1]; q[2] = qA[2];
      q[3] = -qA[3];
   }
   else
   {
      q[0] = -qA[0]; q[1] = -qA[1]; q[2] = -qA[2];
      q[3] = qA[3];
   }
         
   return qB * q;
}

inline sVec3 ConvertAngVelToTorque (   sVec3 &targetAngVel, sVec3 &currentAngVel, sMat4 &matrix,
                        float timestep, float mass, float Ixx, float Iyy, float Izz)
{
   sVec3 torque = (targetAngVel - currentAngVel) / timestep;
   torque = matrix.Unrotate (torque);
   torque[0] *= Ixx;
   torque[1] *= Iyy;
   torque[2] *= Izz;
   torque = matrix.Rotate (torque);
   return torque;
}

#define NEWTON_MESH 8

//add this code to newton_addentity switch

case NEWTON_MESH:
		
collision = NewtonCreateTreeCollision(nworld, 0);
NewtonTreeCollisionBeginBuild(collision);
//newton_treecollisionaddblocks(collision);
newton_treecollisionaddentity(collision, entity);
NewtonTreeCollisionEndBuild(collision, 0);

break;

action new_mesh_obj()
{
wait(10);
newton_addentity(me, 100, NEWTON_MESH, onforceandtorque);
}