#include "StdAfx.h"
#include "vtPhysXAll.h"

#include "IParameter.h"

#include "vtStructHelper.h"


static IParameter* gIPar = NULL;

#include "pMisc.h"
#include "pVehicleAll.h"
using namespace vtTools::ParameterTools;


int IParameter::copyTo(pLinearInterpolation& dst,CKParameter*src)
{
	if (!src)
		return false;

	int gear = 0;
	float ratio = 0.0f;


	CKStructHelper sHelper(src);
	if (sHelper.GetMemberCount() ==0 )//happens when dev is being opened and loads a cmo with physic objects.
		return -1;

	for (int i = 0 ; i < sHelper.GetMemberCount() ; i++)
	{
		CK_ID* paramids = static_cast<CK_ID*>(src->GetReadDataPtr());
		CKParameter * sub = static_cast<CKParameterOut*>(GetPMan()->m_Context->GetObject(paramids[i]));
		if (sub)
		{
			
			dst.insert(GetValueFromParameterStruct<float>(sub,0,false),
				GetValueFromParameterStruct<float>(sub,1,false)
				);
		}
	}
	return true;
}


int IParameter::copyTo(pGearBox *dst,CKParameter*src)
{
	if (!src || !dst)
		return false;
	
	int gear = 0;
	float ratio = 0.0f;

	for (int i = 0 ; i < 7 ; i++)
	{
		CK_ID* paramids = static_cast<CK_ID*>(src->GetReadDataPtr());
		CKParameter * sub = static_cast<CKParameterOut*>(GetPMan()->m_Context->GetObject(paramids[i]));
		if (sub)
		{
			dst->gearRatio[i] = 	GetValueFromParameterStruct<float>(sub,0,false);
			dst->gearInertia[i] =	GetValueFromParameterStruct<float>(sub,1,false);

			dst->getGearRatios().insert((float)i,dst->gearRatio[i]);
			dst->getGearTensors().insert((float)i,dst->gearInertia[i]);
		}
	}
	return true;
}

int IParameter::copyTo(pVehicleBrakeTable& dst,CKParameter*src)
{
	
	int result = 0;

	for (int i  = 0 ; i < BREAK_TABLE_ENTRIES ; i ++)
		dst.brakeEntries[i] = GetValueFromParameterStruct<float>(src,i);

	return true;


}
int IParameter::copyTo(CKParameter*dst,pWheelDescr src)
{
	if (!dst)return false;
	using namespace vtTools::ParameterTools;

	int result = 0;

	SetParameterStructureValue<float>(dst,E_WD_SPRING_BIAS,src.springBias,false);
	SetParameterStructureValue<float>(dst,E_WD_SPRING_RES,src.springRestitution,false);
	SetParameterStructureValue<float>(dst,E_WD_DAMP,src.springDamping,false);
	SetParameterStructureValue<float>(dst,E_WD_MAX_BFORCE,src.maxBrakeForce,false);
	SetParameterStructureValue<float>(dst,E_WD_FFRONT,src.frictionToFront,false);
	SetParameterStructureValue<float>(dst,E_WD_FSIDE,src.frictionToSide,false);
	SetParameterStructureValue<int>(dst,E_WD_FLAGS,src.wheelFlags,false);
	SetParameterStructureValue<float>(dst,E_WD_INVERSE_WHEEL_MASS,src.inverseWheelMass,false);
	SetParameterStructureValue<int>(dst,E_WD_SFLAGS,src.wheelShapeFlags,false);
	SetParameterStructureValue<float>(dst,E_WD_SUSPENSION,src.wheelSuspension,false);


    

}

int IParameter::copyTo(pWheelDescr& dst,CKParameter*src)
{
	int result  = 1;
	if (!src)
	{
		return NULL;
	}
	using namespace vtTools::ParameterTools;
	
	dst.wheelSuspension = GetValueFromParameterStruct<float>(src,E_WD_SUSPENSION);
	dst.springRestitution= GetValueFromParameterStruct<float>(src,E_WD_SPRING_RES);
	dst.springBias = GetValueFromParameterStruct<float>(src,E_WD_SPRING_BIAS);
	dst.springDamping= GetValueFromParameterStruct<float>(src,E_WD_DAMP);

	dst.maxBrakeForce= GetValueFromParameterStruct<float>(src,E_WD_MAX_BFORCE);
	dst.frictionToSide= GetValueFromParameterStruct<float>(src,E_WD_FSIDE);
	dst.frictionToFront= GetValueFromParameterStruct<float>(src,E_WD_FFRONT);

	CKParameterOut *pOld  = GetParameterFromStruct(src,E_WD_INVERSE_WHEEL_MASS);
	if (pOld)
	{
		if (pOld->GetGUID()  == CKPGUID_FLOAT)
		{
			dst.inverseWheelMass= GetValueFromParameterStruct<float>(src,E_WD_INVERSE_WHEEL_MASS);
		}

		if (pOld->GetGUID()  == CKPGUID_INT)
		{
			dst.wheelApproximation= GetValueFromParameterStruct<int>(src,E_WD_INVERSE_WHEEL_MASS);
		}
	}

	
	
	dst.wheelFlags= (WheelFlags)GetValueFromParameterStruct<int>(src,E_WD_FLAGS);
	dst.wheelShapeFlags=(WheelShapeFlags) GetValueFromParameterStruct<int>(src,E_WD_SFLAGS);


	CKParameterOut *parLatFunc = GetParameterFromStruct(src,E_WD_LAT_FUNC);
	CKParameterOut *parLongFunc = GetParameterFromStruct(src,E_WD_LONG_FUNC);



	/************************************************************************/
	/* XML Setup ?                                                                     */
	/************************************************************************/
	int xmlLinkId= GetValueFromParameterStruct<int>(src,E_WD_XML);
	bool wIsXML=false;
	bool latIsXML= false;
	bool longIsXML=false;

	XString nodeName;
	if ( xmlLinkId !=0 )
	{
		nodeName = vtAgeia::getEnumDescription(GetPMan()->GetContext()->GetParameterManager(),VTE_XML_WHEEL_SETTINGS,xmlLinkId);
		pFactory::Instance()->loadWheelDescrFromXML(dst,nodeName.CStr(),pFactory::Instance()->getDefaultDocument());
		wIsXML =true;
		if (!dst.isValid())
		{
			xLogger::xLog(XL_START,ELOGERROR,E_LI_MANAGER,"Wheel Description was invalid");
		}
		if (dst.latFunc.xmlLink!=0)
		{
			latIsXML=true;
		}

		if (dst.longFunc.xmlLink!=0)
		{
			longIsXML=true;
		}
	}

	if (!latIsXML)
	{
		dst.latFunc = pFactory::Instance()->createTireFuncFromParameter(parLatFunc);
	}

	if (!longIsXML)
	{
		dst.longFunc= pFactory::Instance()->createTireFuncFromParameter(parLongFunc);
	}

	if (wIsXML)
	{
		IParameter::Instance()->copyTo((CKParameterOut*)src,dst);

	}
	if (longIsXML)
	{
		pFactory::Instance()->copyTo(GetParameterFromStruct(src,E_WD_LONG_FUNC),dst.longFunc);
	}

	if (latIsXML)
	{
		pFactory::Instance()->copyTo(GetParameterFromStruct(src,E_WD_LAT_FUNC),dst.latFunc);
	}

	return result;
}
int IParameter::copyTo(pConvexCylinderSettings& dst,CKParameter*src)
{
	//----------------------------------------------------------------
	//
	// Sanity checks
	//
#ifdef _DEBUG
	assert(src);
#endif 

	using namespace vtTools;
	using namespace vtTools::AttributeTools;
	using namespace vtTools::ParameterTools;

	copyTo(dst.radius, GetParameterFromStruct(src,PS_CC_RADIUS_REFERENCED_VALUE),true);
	copyTo(dst.height, GetParameterFromStruct(src,PS_CC_HEIGHT_REFERENCED_VALUE),true);

	dst.approximation = GetValueFromParameterStruct<int>(src,PS_CC_APPROXIMATION);
	dst.buildLowerHalfOnly = GetValueFromParameterStruct<int>(src,PS_CC_BUILD_LOWER_HALF_ONLY);
	dst.convexFlags = (pConvexFlags)GetValueFromParameterStruct<int>(src,PS_CC_EXTRA_SHAPE_FLAGS);


	//----------------------------------------------------------------
	//
	// Calculate Forward Axis, optionally referenced by an entity 
	//
	dst.forwardAxis = GetValueFromParameterStruct<VxVector>(src,PS_CC_FORWARD_AXIS);
	dst.forwardAxisRef = GetValueFromParameterStruct<CK_ID>(src,PS_CC_FORWARD_AXIS_REF);

	CK3dEntity *f = (CK3dEntity*)GetPMan()->m_Context->GetObject(dst.forwardAxisRef);
	if (f)
	{
		VxVector dir,up,right;
		f->GetOrientation(&dir,&up,&right);
		f->TransformVector(&dst.forwardAxis,&dir);
		dst.forwardAxis.Normalize();
	}


	
	//----------------------------------------------------------------
	//
	// Calculate Down Axis, optionally referenced by an entity 
	//
	dst.downAxis = GetValueFromParameterStruct<VxVector>(src,PS_CC_DOWN_AXIS);
	dst.downAxisRef = GetValueFromParameterStruct<CK_ID>(src,PS_CC_DOWN_AXIS_REF);
	
	CK3dEntity *d = (CK3dEntity*)GetPMan()->m_Context->GetObject(dst.downAxisRef);
	if (d)
	{
		VxVector dir,up,right;
		d->GetOrientation(&dir,&up,&right);
		d->TransformVector(&dst.downAxis,&up);
		dst.downAxis.Normalize();
	}

	
	//----------------------------------------------------------------
	//
	// Calculate Right Axis, optionally referenced by an entity 
	//
	dst.rightAxis = GetValueFromParameterStruct<VxVector>(src,PS_CC_RIGHT_AXIS);
	
	dst.rightAxisRef = GetValueFromParameterStruct<CK_ID>(src,PS_CC_RIGHT_AXIS_REF);
	CK3dEntity *r = (CK3dEntity*)GetPMan()->m_Context->GetObject(dst.rightAxisRef);
	if (r)
	{
		VxVector dir,up,right;
		r->GetOrientation(&dir,&up,&right);
		r->TransformVector(&dst.rightAxis,&right);
		dst.rightAxis.Normalize();
	}


	


	return 1;
}

int IParameter::copyTo(CKParameter*dst,pConvexCylinderSettings& src)
{

	copyTo(src.radius, GetParameterFromStruct(dst,PS_CC_RADIUS_REFERENCED_VALUE),true);
	copyTo(src.height, GetParameterFromStruct(dst,PS_CC_HEIGHT_REFERENCED_VALUE),true);

	SetParameterStructureValue<int>(dst,PS_CC_APPROXIMATION,src.approximation,false);
	SetParameterStructureValue<int>(dst,PS_CC_BUILD_LOWER_HALF_ONLY,src.buildLowerHalfOnly,false);
	SetParameterStructureValue<int>(dst,PS_CC_EXTRA_SHAPE_FLAGS,src.convexFlags,false);
	
	SetParameterStructureValue<VxVector>(dst,PS_CC_FORWARD_AXIS,src.forwardAxis,false);
	SetParameterStructureValue<VxVector>(dst,PS_CC_DOWN_AXIS,src.downAxis,false);
	SetParameterStructureValue<VxVector>(dst,PS_CC_RIGHT_AXIS,src.rightAxis,false);

	CK3dEntity *f = (CK3dEntity*)GetPMan()->m_Context->GetObject(src.forwardAxisRef);
	if (f)
		SetParameterStructureValue<CK_ID>(dst,PS_CC_FORWARD_AXIS_REF,f->GetID(),false);

	
	CK3dEntity *d = (CK3dEntity*)GetPMan()->m_Context->GetObject(src.downAxisRef);
	if (d)
		SetParameterStructureValue<CK_ID>(dst,PS_CC_DOWN_AXIS_REF,d->GetID(),false);


	CK3dEntity *r = (CK3dEntity*)GetPMan()->m_Context->GetObject(src.rightAxisRef);
	if (r)
		SetParameterStructureValue<CK_ID>(dst,PS_CC_RIGHT_AXIS_REF,r->GetID(),false);

	return 1;


}

int IParameter::copyTo(pMassSettings& dst,CKParameter*src)
{
	//----------------------------------------------------------------
	//
	// Sanity checks
	//
#ifdef _DEBUG
	assert(src);
#endif 

	using namespace vtTools;
	using namespace vtTools::AttributeTools;
	using namespace vtTools::ParameterTools;

	dst.newDensity= GetValueFromParameterStruct<float>(src,PS_BM_DENSITY,false);
	dst.totalMass= GetValueFromParameterStruct<float>(src,PS_BM_TOTAL_MASS,false);
	dst.localPosition = GetValueFromParameterStruct<VxVector>(src,PS_BM_PIVOT_POS,false);
	dst.localOrientation = GetValueFromParameterStruct<VxVector>(src,PS_BM_PIVOT_ROTATION,false);
	dst.massReference= GetValueFromParameterStruct<CK_ID>(src,PS_BM_PIVOT_REFERENCE,false);
	return 1;
}

int IParameter::copyTo(CKParameter*dst,pMassSettings src)
{
	//----------------------------------------------------------------
	//
	// Sanity checks
	//
#ifdef _DEBUG
	assert(dst);
#endif 

	using namespace vtTools;
	using namespace vtTools::AttributeTools;
	using namespace vtTools::ParameterTools;

	
	SetParameterStructureValue<float>(dst,PS_BM_DENSITY,src.newDensity,false);
	SetParameterStructureValue<float>(dst,PS_BM_TOTAL_MASS,src.totalMass,false);
	SetParameterStructureValue<VxVector>(dst,PS_BM_PIVOT_POS,src.localPosition,false);
	SetParameterStructureValue<VxVector>(dst,PS_BM_PIVOT_ROTATION,src.localOrientation,false);
	SetParameterStructureValue<CK_ID>(dst,PS_BM_PIVOT_REFERENCE,src.massReference,false);

	return 1;

}


int IParameter::copyTo(CKParameter*dst,pPivotSettings src)
{
	//----------------------------------------------------------------
	//
	// Sanity checks
	//
#ifdef _DEBUG
	assert(dst);
#endif 

	using namespace vtTools;
	using namespace vtTools::AttributeTools;
	using namespace vtTools::ParameterTools;

	SetParameterStructureValue<VxVector>(dst,PS_BP_LINEAR,src.localPosition,false);
	SetParameterStructureValue<VxVector>(dst,PS_BP_ANGULAR,src.localOrientation,false);
	SetParameterStructureValue<CK_ID>(dst,PS_BP_REFERENCE,src.pivotReference,false);

	/*
	dst.localPosition = GetValueFromParameterStruct<VxVector>(src,PS_BP_LINEAR,false);
	dst.localOrientation = GetValueFromParameterStruct<VxVector>(src,PS_BP_ANGULAR,false);
	dst.pivotReference = GetValueFromParameterStruct<CK_ID>(src,PS_BP_REFERENCE,false);

	*/

	return 1;

}

int IParameter::copyTo(pPivotSettings& dst,CKParameter*src)
{
	//----------------------------------------------------------------
	//
	// Sanity checks
	//
#ifdef _DEBUG
	assert(src);
#endif 

	using namespace vtTools;
	using namespace vtTools::AttributeTools;
	using namespace vtTools::ParameterTools;

	dst.localPosition = GetValueFromParameterStruct<VxVector>(src,PS_BP_LINEAR,false);
	dst.localOrientation = GetValueFromParameterStruct<VxVector>(src,PS_BP_ANGULAR,false);
	dst.pivotReference = GetValueFromParameterStruct<CK_ID>(src,PS_BP_REFERENCE,false);
	return 1;

}

int IParameter::copyTo(pObjectDescr&dst,CK3dEntity*src,int copyFlags)
{

	pRigidBody *srcBody = GetPMan()->getBody(src);
	NxActor *actor = NULL;
	pObjectDescr*initDescr = NULL;
	NxShape *mainShape= NULL;

	//----------------------------------------------------------------
	//
	// sanity checks
	//
	if (!src || !srcBody || !srcBody->getMainShape())
		return 0;


	initDescr  = srcBody->getInitialDescription();
	actor = srcBody->getActor();
	mainShape = srcBody->getMainShape();



	if (!initDescr || !actor )
		return 0;


	//----------------------------------------------------------------
	//
	// general settings
	//
	dst.hullType = (HullType)vtAgeia::getHullTypeFromShape(srcBody->getMainShape());
    
	
	srcBody->recalculateFlags(0);
	dst.flags = (BodyFlags)srcBody->getFlags();
	dst.worlReference = srcBody->getWorld()->getReference()->GetID();
	dst.density = initDescr->density;
	dst.mask = initDescr->mask;


	//----------------------------------------------------------------
	//
	// specific override : optimization
	//
	if ( (copyFlags & PB_CF_OPTIMIZATION) )
	{

		//----------------------------------------------------------------
		//
		// damping + sleeping
		//
		dst.optimization.angDamping = actor->getAngularDamping();
		dst.optimization.linDamping = actor->getLinearDamping();
		dst.optimization.linSleepVelocity = actor->getSleepLinearVelocity();
		dst.optimization.angSleepVelocity = actor->getSleepAngularVelocity();
		dst.optimization.sleepEnergyThreshold = actor->getSleepEnergyThreshold();

		//----------------------------------------------------------------
		//
		// transformation flags
		//

		dst.optimization.transformationFlags = (BodyLockFlags)srcBody->getTransformationsLockFlags();


		dst.optimization.solverIterations = actor->getSolverIterationCount();
		dst.optimization.dominanceGroup = actor->getDominanceGroup();
		dst.optimization.compartmentGroup = initDescr->optimization.compartmentGroup;
	}
		
	//----------------------------------------------------------------
	//
	// specific override : collision
	//
	//if ( (dst.mask & OD_Optimization ) )
	if ( (copyFlags & PB_CF_COLLISION )  )
	{
		dst.collisionGroup = mainShape->getGroup();

		NxGroupsMask nxMask  = mainShape->getGroupsMask();
		dst.groupsMask.bits0 = nxMask.bits0;
		dst.groupsMask.bits1 = nxMask.bits1;
		dst.groupsMask.bits2 = nxMask.bits2;
		dst.groupsMask.bits3 = nxMask.bits3;
		dst.skinWidth = mainShape->getSkinWidth();
	}

	//----------------------------------------------------------------
	//
	// specific override : ccd
	//
	//if ( (dst.mask & OD_CCD) )
	if ( (copyFlags & OD_CCD ) && (dst.mask & OD_CCD) )
	{

		dst.ccd.flags = initDescr->ccd.flags;
		dst.ccd.meshReference = initDescr->ccd.meshReference;
		dst.ccd.motionThresold = initDescr->ccd.motionThresold;
		dst.ccd.scale =  initDescr->ccd.scale;
	}

	//----------------------------------------------------------------
	//
	// specific override : capsule
	//
	if ( (copyFlags && OD_Capsule) && (dst.mask & OD_Capsule) )
		dst.capsule = initDescr->capsule;

	//----------------------------------------------------------------
	//
	// specific override : convex cylinder
	//
	if ( (copyFlags && OD_ConvexCylinder) && (dst.mask & OD_ConvexCylinder) )
		dst.convexCylinder = initDescr->convexCylinder;

	//----------------------------------------------------------------
	//
	// specific override : material
	//
	if ( (copyFlags && OD_Material) && (dst.mask & OD_Material) )
		dst.material = initDescr->material;

	//----------------------------------------------------------------
	//
	// specific override : pivot
	//
	if ( (copyFlags && OD_Pivot) )
	{
		//dst.pivotOffsetAngular	= getFrom(mainShape->getLocalOrientation() );
		dst.pivotOffsetLinear	= getFrom( mainShape->getLocalPosition() );
		//dst.pivotOffsetReference= initDescr->pivotOffsetReference;
	}

	if ( (copyFlags && PB_CF_MASS_SETTINGS)  )
	{
		//dst.pivotOffsetAngular	= getFrom(mainShape->getLocalOrientation() );
		dst.massOffsetLinear	= getFrom(actor->getCMassLocalPosition());
		//dst.pivotOffsetReference= initDescr->pivotOffsetReference;
	}

	//----------------------------------------------------------------
	//
	// correct data mask :
	//

	DWORD mask  = (DWORD)(dst.mask);
	mask &=~((OD_Pivot));



	if ( !(copyFlags & PB_CF_PIVOT_SETTINGS) )
		mask &=~((OD_Pivot));

	if ( !(copyFlags & PB_CF_MASS_SETTINGS) )
		mask &=~(OD_Mass);

	if ( !(copyFlags & PB_CF_OPTIMIZATION) )
		mask &=~(OD_Optimization);

	if ( !(copyFlags & PB_CF_COLLISION) )
		mask &=~(OD_Collision);

	if ( !(copyFlags & PB_CF_CCD) )
		mask &=~(OD_CCD);

	if ( !(copyFlags & PB_CF_CAPSULE) )
		mask &=~(OD_Capsule);

	
	if ( !(copyFlags & PB_CF_CONVEX_CYLINDER) )
		mask&=~(OD_ConvexCylinder);
	
	if ( !(copyFlags & PB_CF_MATERIAL) )
		mask &=~(OD_Material);

	return 1;
}




int IParameter::copyTo(pAxisReferencedLength&dst,CKParameter*src,bool evaluate)
{

#ifdef _DEBUG
	assert(src);
#endif

	using namespace vtTools::ParameterTools;


	//################################################################
	//
	// Retrieve the value :
	//
	dst.value = GetValueFromParameterStruct<float>(src,PS_ARL_VALUE);

	dst.referenceAxis = GetValueFromParameterStruct<int>(src,PS_ARL_REF_OBJECT_AXIS);

	//################################################################
	//
	// Calculate the value basing on the given objects local box and an axis. 
	//
	CK_ID idRef= GetValueFromParameterStruct<CK_ID>(src,PS_ARL_REF_OBJECT);
	CKBeObject *object  = (CKBeObject*)GetPMan()->GetContext()->GetObject(idRef);

	if (!object)
		return -1;

	dst.reference = object;

	if (!evaluate)return -1;


	VxVector size(0.0f);
	if (object->GetClassID()  == CKCID_3DOBJECT )
	{
		CK3dEntity *ent3D   = (CK3dEntity*)object;
		if (ent3D)
		{
			size = ent3D->GetBoundingBox(true).GetSize();
		}
	}else if(object->GetClassID()  == CKCID_MESH)
	{
		CKMesh *mesh = (CKMesh*)object;
		if (mesh)
		{
			size = mesh->GetLocalBox().GetSize();
		}
	}
	dst.value = size[dst.referenceAxis];
	return 1;
}

int IParameter::copyTo(CKParameter *dst, pAxisReferencedLength &src, bool evaluate)
{
	SetParameterStructureValue<float>(dst,PS_ARL_VALUE,src.value,false);
	SetParameterStructureValue<int>(dst,PS_ARL_REF_OBJECT_AXIS,src.referenceAxis,false);
	if (src.reference)
	{
		SetParameterStructureValue<CK_ID>(dst,PS_ARL_REF_OBJECT,src.reference->GetID(),false);
	}
	return 1;
}



int IParameter::copyTo(pCapsuleSettingsEx& dst,CKParameter*src)
{
	//SetParameterStructureValue<float>(dst,PS_BM_DENSITY,src.newDensity,false);

	//----------------------------------------------------------------
	//
	// Sanity checks
	//
	#ifdef _DEBUG
		assert(src);
	#endif 

	using namespace vtTools;
	using namespace vtTools::AttributeTools;
	using namespace vtTools::ParameterTools;

	pFactory::Instance()->copyTo(dst.radius, GetParameterFromStruct(src,PS_BCAPSULE_RADIUS_REFERENCED_VALUE),false);
	pFactory::Instance()->copyTo(dst.height, GetParameterFromStruct(src,PS_PCAPSULE_HEIGHT_REFERENCED_VALUE),false);

	return 1;
}
int IParameter::copyTo(CKParameter*dst,pCapsuleSettingsEx src)
{
	//----------------------------------------------------------------
	//
	// Sanity checks
	//
#ifdef _DEBUG
	assert(dst);
#endif 

	using namespace vtTools;
	using namespace vtTools::AttributeTools;
	using namespace vtTools::ParameterTools;

	copyTo(GetParameterFromStruct(dst,PS_BCAPSULE_RADIUS_REFERENCED_VALUE),src.radius,false);
	copyTo(GetParameterFromStruct(dst,PS_PCAPSULE_HEIGHT_REFERENCED_VALUE),src.height,false);


	return 1;
}

int IParameter::copyTo(pCCDSettings& dst,CKParameter*src)
{
	//----------------------------------------------------------------
	//
	// Sanity checks
	//
#ifdef _DEBUG
	assert(src);
#endif 

	using namespace vtTools;
	using namespace vtTools::AttributeTools;
	using namespace vtTools::ParameterTools;

	//----------------------------------------------------------------

	//
	// general
	//

	dst.flags = GetValueFromParameterStruct<int>(src,PS_B_CCD_FLAGS,false);
	dst.motionThresold = GetValueFromParameterStruct<float>(src,PS_B_CCD_MOTION_THRESHOLD,false);
	dst.scale= GetValueFromParameterStruct<float>(src,PS_B_CCD_SCALE,false);
	dst.meshReference= GetValueFromParameterStruct<CK_ID>(src,PS_B_CCD_MESH_REFERENCE,false);


	return 1;
}

int IParameter::copyTo(pOptimization& dst,CKParameter*src)
{

	//----------------------------------------------------------------
	//
	// Sanity checks
	//
	#ifdef _DEBUG
		assert(src);
	#endif 

	using namespace vtTools;
	using namespace vtTools::AttributeTools;
	using namespace vtTools::ParameterTools;


	//----------------------------------------------------------------
	//
	// Retrieve all sub parameters : 
	//
	CKParameterOut *parSleeping =  GetParameterFromStruct(src,PS_BO_SLEEPING);
	CKParameterOut *parDamping =  GetParameterFromStruct(src,PS_BO_DAMPING);

	//----------------------------------------------------------------
	//
	// general
	//
	
	dst.transformationFlags = (BodyLockFlags) GetValueFromParameterStruct<int>(src,PS_BO_LOCKS,false);
	
	dst.solverIterations = GetValueFromParameterStruct<int>(src,PS_BO_SOLVER_ITERATIONS,false);
	dst.compartmentGroup = GetValueFromParameterStruct<int>(src,PS_BO_COMPARTMENT_ID,false);
	dst.dominanceGroup	= GetValueFromParameterStruct<int>(src,PS_BO_DOMINANCE_GROUP,false);

	//----------------------------------------------------------------
	//
	// Sleeping
	//
	dst.angSleepVelocity = GetValueFromParameterStruct<float>(parSleeping,PS_BS_ANGULAR_SLEEP,false);
	dst.linSleepVelocity = GetValueFromParameterStruct<float>(parSleeping,PS_BS_LINEAR_SLEEP,false);
	dst.sleepEnergyThreshold = GetValueFromParameterStruct<float>(parSleeping,PS_BS_THRESHOLD,false);

	//----------------------------------------------------------------
	//
	// Damping
	//
	dst.angDamping = GetValueFromParameterStruct<float>(parDamping,PS_BD_ANGULAR,false);
	dst.linDamping= GetValueFromParameterStruct<float>(parDamping,PS_BD_LINEAR,false);

	return 1;

}

int IParameter::copyTo(CKParameter*dst,pObjectDescr*src)
{

	//----------------------------------------------------------------
	//
	// Sanity checks
	//
	#ifdef _DEBUG
		assert(dst);
		assert(src);
	#endif 

		
	
	using namespace vtTools::AttributeTools;
	using namespace vtTools::ParameterTools;

	//----------------------------------------------------------------
	//
	// Retrieve all sub parameters : 
	//
	CKParameterOut *parBCommon =  GetParameterFromStruct(dst,PS_COMMON_SETTINGS);
	CKParameterOut *parBCollision =  GetParameterFromStruct(dst,PS_COLLISION_SETTINGS);
		//CKParameterOut *parBCCD =  GetParameterFromStruct(parBCollision,PS_BC_CCD_SETUP);
		CKParameterOut *parGroupsMask = GetParameterFromStruct(parBCollision,PS_BC_GROUPSMASK);
	
	#ifdef _DEBUG
		assert(parBCommon);
		//assert(parBPivot);
		//assert(parBCCD);
		assert(parBCollision);
	#endif 

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	//
	//	transfer		
	//


	//----------------------------------------------------------------
	//
	// common 
	//
	SetParameterStructureValue<int>(parBCommon,PS_BC_HULL_TYPE,src->hullType);
	SetParameterStructureValue<float>(parBCommon,PS_BC_DENSITY,src->density);
	SetParameterStructureValue<int>(parBCommon,PS_BC_FLAGS,src->flags);
	SetParameterStructureValue<CK_ID>(parBCommon,PS_BC_WORLD,src->worlReference);

	//----------------------------------------------------------------
	//
	// XML
	//

	//----------------------------------------------------------------
	//
	// Collision
	//
	SetParameterStructureValue<int>(parBCollision,PS_BC_GROUP,src->collisionGroup);
	SetParameterStructureValue<float>(parBCollision,PS_BC_SKINWITDH,src->skinWidth);


	SetParameterStructureValue<int>(parGroupsMask,0,src->groupsMask.bits0);
	SetParameterStructureValue<int>(parGroupsMask,1,src->groupsMask.bits1);
	SetParameterStructureValue<int>(parGroupsMask,2,src->groupsMask.bits2);
	SetParameterStructureValue<int>(parGroupsMask,3,src->groupsMask.bits3);

	//----------------------------------------------------------------
	//
	// CCD
	//

	/*
	SetParameterStructureValue<float>(parBCCD,PS_B_CCD_MOTION_THRESHOLD,src->ccdMotionThresold);
	SetParameterStructureValue<int>(parBCCD,PS_B_CCD_FLAGS,src->ccdFlags);
	SetParameterStructureValue<int>(parBCCD,PS_B_CCD_MESH_REFERENCE,src->ccdMeshReference);
	SetParameterStructureValue<float>(parBCCD,PS_B_CCD_SCALE,src->ccdScale);

	*/
	return 1;

}


int IParameter::copyTo(pCollisionSettings &dst,CKParameter*src)
{

	//----------------------------------------------------------------
	//
	// Sanity checks
	//
	#ifdef _DEBUG
		assert(src);
	#endif 


	using namespace vtTools::AttributeTools;
	using namespace vtTools::ParameterTools;

	CKParameterOut *parGroupsMask = GetParameterFromStruct(src,PS_BC_GROUPSMASK);
	
	// Sanity checks
	#ifdef _DEBUG
		assert(parGroupsMask);
	#endif 
	//----------------------------------------------------------------
	//
	// Collision Setup 
	//
	dst.collisionGroup = GetValueFromParameterStruct<int>(src,PS_BC_GROUP,false);

	//	
	dst.groupsMask.bits0  = GetValueFromParameterStruct<int>(parGroupsMask,0);
	dst.groupsMask.bits1  = GetValueFromParameterStruct<int>(parGroupsMask,1);
	dst.groupsMask.bits2  = GetValueFromParameterStruct<int>(parGroupsMask,2);
	dst.groupsMask.bits3  = GetValueFromParameterStruct<int>(parGroupsMask,3);

	dst.skinWidth = GetValueFromParameterStruct<float>(src,PS_BC_SKINWITDH,false);
	return 1;
}

int IParameter::copyTo(pObjectDescr*dst,CKParameter*src)
{

	//----------------------------------------------------------------
	//
	// Sanity checks
	//
	#ifdef _DEBUG
		assert(dst);
		assert(src);
	#endif 

	//----------------------------------------------------------------
	//
	// Possible this function is invoked due the loading of a cmo file whilst core is not started yet : 
	//
	CKStructHelper sHelper(src);
	if(sHelper.GetMemberCount() == 0)
		return 0;

	using namespace vtTools::AttributeTools;
	using namespace vtTools::ParameterTools;

	//----------------------------------------------------------------
	//
	// Retrieve all sub parameters : 
	//
	CKParameterOut *parBCommon =  GetParameterFromStruct(src,PS_COMMON_SETTINGS);
	//CKParameterOut *parBPivot =  GetParameterFromStruct(src,PS_PIVOT);
	//CKParameterOut *parBMass =  GetParameterFromStruct(src,PS_MASS);
	CKParameterOut *parBCollision =  GetParameterFromStruct(src,PS_COLLISION_SETTINGS);
		//CKParameterOut *parBCCD =  GetParameterFromStruct(parBCollision,PS_BC_CCD_SETUP);
		CKParameterOut *parGroupsMask = GetParameterFromStruct(parBCollision,PS_BC_GROUPSMASK);

	#ifdef _DEBUG
		assert(parBCommon);
		//assert(parBPivot);
		//assert(parBMass);
		assert(parBCollision);
	#endif 


	//----------------------------------------------------------------
	//
	// Common settings as hull type, body flags, ...
	//

	dst->hullType =(HullType)GetValueFromParameterStruct<int>(parBCommon,PS_BC_HULL_TYPE,false);
	dst->flags =  (BodyFlags)GetValueFromParameterStruct<int>(parBCommon,PS_BC_FLAGS,false);
	/*dst->transformationFlags = GetValueFromParameterStruct<int>(parBCommon,PS_BC_TFLAGS,false);*/
	dst->worlReference = GetValueFromParameterStruct<CK_ID>(parBCommon,PS_BC_WORLD,false);
	dst->density = GetValueFromParameterStruct<float>(parBCommon,PS_BC_DENSITY,false);


	//----------------------------------------------------------------
	//
	// Pivot Offset
	//

	/*
	dst->pivotOffsetLinear = GetValueFromParameterStruct<VxVector>(parBPivot,PS_BP_LINEAR,false);
	dst->pivotOffsetAngular = GetValueFromParameterStruct<VxVector>(parBPivot,PS_BP_ANGULAR,false);

	//----------------------------------------------------------------
	//
	// Mass	Offset
	//
	
	dst->density = GetValueFromParameterStruct<float>(parBMass,PS_BM_DENSITY,false);
	dst->totalMass = GetValueFromParameterStruct<float>(parBMass,PS_BM_TOTAL_MASS,false);
	dst->massOffsetLinear = GetValueFromParameterStruct<VxVector>(parBMass,PS_BM_PIVOT_POS,false);
	*/
	//dst->massOffsetAngular = GetValueFromParameterStruct<VxVector>(parBMass,PS_BM_PIVOT_ROTATION,false);


	
	//----------------------------------------------------------------
	//
	// Collision Setup 
	//
	dst->collisionGroup = GetValueFromParameterStruct<int>(parBCollision,PS_BC_GROUP,false);
	
	//	
	dst->groupsMask.bits0  = GetValueFromParameterStruct<int>(parGroupsMask,0);
	dst->groupsMask.bits1  = GetValueFromParameterStruct<int>(parGroupsMask,1);
	dst->groupsMask.bits2  = GetValueFromParameterStruct<int>(parGroupsMask,2);
	dst->groupsMask.bits3  = GetValueFromParameterStruct<int>(parGroupsMask,3);

	dst->skinWidth = GetValueFromParameterStruct<float>(parBCollision,PS_BC_SKINWITDH,false);
	
	dst->collision.groupsMask.bits0 = GetValueFromParameterStruct<int>(parGroupsMask,0);
	dst->collision.groupsMask.bits1 = GetValueFromParameterStruct<int>(parGroupsMask,1);
	dst->collision.groupsMask.bits2 = GetValueFromParameterStruct<int>(parGroupsMask,2);
	dst->collision.groupsMask.bits3 = GetValueFromParameterStruct<int>(parGroupsMask,3);
	
	dst->collision.skinWidth = GetValueFromParameterStruct<float>(parBCollision,PS_BC_SKINWITDH,false);
	dst->collision.collisionGroup = GetValueFromParameterStruct<int>(parBCollision,PS_BC_GROUP,false);

	//----------------------------------------------------------------
	//
	// CCD Settings
	//
	/*dst->ccdFlags = GetValueFromParameterStruct<int>(parBCCD,PS_B_CCD_FLAGS,false);
	dst->ccdMotionThresold= GetValueFromParameterStruct<float>(parBCCD,PS_B_CCD_MOTION_THRESHOLD,false);
	dst->ccdScale = GetValueFromParameterStruct<float>(parBCCD,PS_B_CCD_SCALE,false);
	dst->ccdMeshReference = GetValueFromParameterStruct<CK_ID>(parBCCD,PS_B_CCD_MESH_REFERENCE,false);
	*/

	dst->mask << OD_Collision;

	//----------------------------------------------------------------
	//
	// Misc
	//
	dst->version  = pObjectDescr::E_OD_VERSION::OD_DECR_V1;

	return 1;
}
IParameter* IParameter::Instance()
{
	if (!gIPar)
	{
		gIPar  = new IParameter(GetPMan());
	}
	return gIPar;
}



IParameter::IParameter(PhysicManager*_pManager) : mManager(_pManager)
{
	gIPar = this;

}