948 lines
32 KiB
C++
948 lines
32 KiB
C++
#include <StdAfx.h>
|
|
#include "vtPhysXAll.h"
|
|
#include "vtAttributeHelper.h"
|
|
|
|
|
|
using namespace xUtils;
|
|
using namespace vtAgeia;
|
|
using namespace vtTools::ParameterTools;
|
|
using namespace vtTools::AttributeTools;
|
|
|
|
|
|
int registerJD6(CK3dEntity *target,int attributeType,bool set,bool isPostJob)
|
|
{
|
|
return 0;
|
|
}
|
|
int registerJD6Drive(CK3dEntity *target,int attributeType,bool set,bool isPostJob)
|
|
{
|
|
return 0;
|
|
}
|
|
int registerJLimitPlane(CK3dEntity *target,int attributeType,bool set,bool isPostJob)
|
|
{
|
|
|
|
|
|
//----------------------------------------------------------------
|
|
//
|
|
// get and check objects
|
|
//
|
|
if (!target)
|
|
return -1;
|
|
|
|
CKParameterOut *attParameter = target->GetAttributeParameter(attributeType);
|
|
if (!attParameter)
|
|
return -1;
|
|
|
|
CKStructHelper sHelper(target->GetAttributeParameter(attributeType));
|
|
if (sHelper.GetMemberCount() ==0 )//happens when dev is being opened and loads a cmo with physic objects.
|
|
return -1;
|
|
|
|
|
|
pRigidBody *body = GetPMan()->getBody(target);
|
|
if (!body)
|
|
return -1;
|
|
|
|
CK_ID bodyBId = GetValueFromParameterStruct<CK_ID>(attParameter,PS_JLP_BODY_B_REF);
|
|
CK3dEntity *bodyBEnt = static_cast<CK3dEntity*>(GetPMan()->GetContext()->GetObject(bodyBId));
|
|
|
|
if (set)
|
|
{
|
|
//----------------------------------------------------------------
|
|
//
|
|
// post pone i ck-start-up or loading
|
|
//
|
|
if (isPostJob && GetPMan()->GetContext()->IsPlaying())
|
|
{
|
|
pAttributePostObject postAttObject(target->GetID(),registerJLimitPlane,attributeType);
|
|
GetPMan()->getAttributePostObjects().PushBack(postAttObject);
|
|
return true;
|
|
}
|
|
|
|
int jointType = GetValueFromParameterStruct<int>(attParameter,PS_JLP_JOINT_TYPE);
|
|
|
|
//try to get the joint
|
|
pJoint *joint = GetPMan()->getJoint(target,bodyBEnt,(JType)jointType);
|
|
if (!joint)
|
|
return -1;
|
|
|
|
//----------------------------------------------------------------
|
|
//
|
|
// we are on ck-play or SetAttribute-BB : Retrieve all parameters from the attribute :
|
|
//
|
|
|
|
VxVector limitPoint = GetValueFromParameterStruct<VxVector>(attParameter,PS_JLP_LIMIT_POINT);
|
|
|
|
CK_ID limitPointRefID = GetValueFromParameterStruct<CK_ID>(attParameter,PS_JLP_LIMIT_POINT_REF);
|
|
CK3dEntity *limiPointRef = static_cast<CK3dEntity*>(GetPMan()->m_Context->GetObject(limitPointRefID));
|
|
if (limiPointRef)
|
|
limiPointRef->Transform(&limitPoint,&limitPoint);
|
|
|
|
|
|
int isOnBodyB = GetValueFromParameterStruct<int>(attParameter,PS_JLP_IS_ON_BODY_B);
|
|
float length = limitPoint.SquareMagnitude();
|
|
if (XAbs(limitPoint.SquareMagnitude()) >=0.01f)
|
|
joint->setLimitPoint(limitPoint,isOnBodyB);
|
|
|
|
|
|
// - Limit Point Normal
|
|
VxVector limitPointNormal = GetValueFromParameterStruct<VxVector>(attParameter,PS_JLP_NORMAL);
|
|
|
|
CK_ID limitPointNormalRefID = GetValueFromParameterStruct<CK_ID>(attParameter,PS_JLP_NORMAL_REF);
|
|
CK3dEntity *limitPointNormalRef = static_cast<CK3dEntity*>(GetPMan()->m_Context->GetObject(limitPointNormalRefID));
|
|
|
|
if (limitPointNormalRef)
|
|
{
|
|
VxVector dir,up,right;
|
|
limitPointNormalRef->GetOrientation(&dir,&up,&right);
|
|
limitPointNormalRef->TransformVector(&limitPointNormal,&up);
|
|
}
|
|
|
|
// - Point in Plane
|
|
VxVector PointInPlane = GetValueFromParameterStruct<VxVector>(attParameter,PS_JLP_PT_IN_PLANE);
|
|
|
|
CK_ID PointInPlaneRefID = GetValueFromParameterStruct<CK_ID>(attParameter,PS_JLP_PT_IN_PLANE_REF);
|
|
CK3dEntity *PointInPlaneRef = static_cast<CK3dEntity*>(GetPMan()->m_Context->GetObject(PointInPlaneRefID));
|
|
if (PointInPlaneRef)
|
|
PointInPlaneRef->Transform(&PointInPlane,&PointInPlane);
|
|
|
|
// - Restitution
|
|
float res = GetValueFromParameterStruct<float>(attParameter,PS_JLP_RESTITUTION);
|
|
|
|
// - Execute
|
|
|
|
int result = joint->addLimitPlane(limitPointNormal,PointInPlane,res);
|
|
return result;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
int registerJPointOnLine(CK3dEntity *target,int attributeType,bool set,bool isPostJob)
|
|
{
|
|
using namespace vtTools::ParameterTools;
|
|
CKParameterOut *pointInPlaneParameter = target->GetAttributeParameter(attributeType);
|
|
|
|
CKStructHelper sHelper(target->GetAttributeParameter(attributeType));
|
|
if (sHelper.GetMemberCount() ==0 )//happens when dev is being opened and loads a cmo with physic objects.
|
|
return -1;
|
|
|
|
if (pointInPlaneParameter )
|
|
{
|
|
|
|
pRigidBody *body = GetPMan()->getBody(target);
|
|
if (!body)return -1;
|
|
|
|
CK_ID bodyBId = GetValueFromParameterStruct<CK_ID>(pointInPlaneParameter,PS_JPOL_BODY_B);
|
|
CK3dEntity *bodyBEnt = static_cast<CK3dEntity*>(GetPMan()->GetContext()->GetObject(bodyBId));
|
|
pRigidBody *bodyB = GetPMan()->getBody(bodyBEnt);
|
|
if (bodyB && bodyB->getWorld() != body->getWorld() )
|
|
return -1;
|
|
if (set)
|
|
{
|
|
|
|
if (isPostJob && GetPMan()->GetContext()->IsPlaying())
|
|
{
|
|
pAttributePostObject postAttObject(target->GetID(),registerJPointOnLine,attributeType);
|
|
GetPMan()->getAttributePostObjects().PushBack(postAttObject);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (bodyB && body->isConnected(bodyBEnt) )
|
|
return -1;
|
|
|
|
VxVector anchor0 = GetValueFromParameterStruct<VxVector>(pointInPlaneParameter,PS_JPOL_ANCHOR);
|
|
CK_ID anchor0RefID = GetValueFromParameterStruct<CK_ID>(pointInPlaneParameter,PS_JPOL_ANCHOR_REF);
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//anchor :
|
|
CK3dEntity *a0Ref = static_cast<CK3dEntity*>(GetPMan()->m_Context->GetObject(anchor0RefID));
|
|
if (a0Ref) a0Ref->Transform(&anchor0,&anchor0);
|
|
int collision = GetValueFromParameterStruct<int>(pointInPlaneParameter,PS_JPOL_COLLISION);
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//axis
|
|
VxVector axis = GetValueFromParameterStruct<VxVector>(pointInPlaneParameter,PS_JPOL_AXIS);
|
|
CK_ID axisRefID = GetValueFromParameterStruct<CK_ID>(pointInPlaneParameter,PS_JPOL_AXIS_REF);
|
|
CK3dEntity *axisRef = static_cast<CK3dEntity*>(GetPMan()->m_Context->GetObject(axisRefID));
|
|
if (axisRef)
|
|
{
|
|
VxVector dir,up,right;
|
|
axisRef->GetOrientation(&dir,&up,&right);
|
|
axisRef->TransformVector(&axis,&up);
|
|
}
|
|
|
|
pJointPointOnLine*joint = static_cast<pJointPointOnLine*>(pFactory::Instance()->createPointOnLineJoint(target,bodyBEnt,anchor0,axis));
|
|
if (joint)
|
|
{
|
|
joint->enableCollision(collision);
|
|
|
|
float maxForce = GetValueFromParameterStruct<float>(pointInPlaneParameter,PS_JPOL_MAX_FORCE);
|
|
float maxTorque = GetValueFromParameterStruct<float>(pointInPlaneParameter,PS_JPOL_MAX_TORQUE);
|
|
joint->setBreakForces(maxForce,maxTorque);
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}else
|
|
{
|
|
|
|
|
|
pJoint *joint = body->isConnected(bodyBEnt);
|
|
if ( joint)
|
|
{
|
|
body->getWorld()->deleteJoint(joint);
|
|
}
|
|
pJoint *joint2 = body->getWorld()->getJoint(target,bodyBEnt,(JType)JT_PointOnLine);
|
|
if (joint2)
|
|
{
|
|
body->getWorld()->deleteJoint(joint);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
int registerJPointInPlane(CK3dEntity *target,int attributeType,bool set,bool isPostJob)
|
|
{
|
|
using namespace vtTools::ParameterTools;
|
|
CKParameterOut *pointInPlaneParameter = target->GetAttributeParameter(attributeType);
|
|
|
|
CKStructHelper sHelper(target->GetAttributeParameter(attributeType));
|
|
if (sHelper.GetMemberCount() ==0 )//happens when dev is being opened and loads a cmo with physic objects.
|
|
return -1;
|
|
|
|
if (pointInPlaneParameter )
|
|
{
|
|
|
|
pRigidBody *body = GetPMan()->getBody(target);
|
|
if (!body)return -1;
|
|
|
|
CK_ID bodyBId = GetValueFromParameterStruct<CK_ID>(pointInPlaneParameter,PS_JPIP_BODY_B);
|
|
CK3dEntity *bodyBEnt = static_cast<CK3dEntity*>(GetPMan()->GetContext()->GetObject(bodyBId));
|
|
pRigidBody *bodyB = GetPMan()->getBody(bodyBEnt);
|
|
if (bodyB && bodyB->getWorld() != body->getWorld() )
|
|
return -1;
|
|
if (set)
|
|
{
|
|
|
|
if (isPostJob && GetPMan()->GetContext()->IsPlaying())
|
|
{
|
|
pAttributePostObject postAttObject(target->GetID(),registerJPointInPlane,attributeType);
|
|
GetPMan()->getAttributePostObjects().PushBack(postAttObject);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (bodyB && body->isConnected(bodyBEnt) )
|
|
return -1;
|
|
|
|
VxVector anchor0 = GetValueFromParameterStruct<VxVector>(pointInPlaneParameter,PS_JPIP_ANCHOR);
|
|
CK_ID anchor0RefID = GetValueFromParameterStruct<CK_ID>(pointInPlaneParameter,PS_JPIP_ANCHOR_REF);
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//anchor :
|
|
CK3dEntity *a0Ref = static_cast<CK3dEntity*>(GetPMan()->m_Context->GetObject(anchor0RefID));
|
|
if (a0Ref) a0Ref->Transform(&anchor0,&anchor0);
|
|
int collision = GetValueFromParameterStruct<int>(pointInPlaneParameter,PS_JPIP_COLLISION);
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//axis
|
|
VxVector axis = GetValueFromParameterStruct<VxVector>(pointInPlaneParameter,PS_JPIP_AXIS);
|
|
CK_ID axisRefID = GetValueFromParameterStruct<CK_ID>(pointInPlaneParameter,PS_JPIP_AXIS_REF);
|
|
CK3dEntity *axisRef = static_cast<CK3dEntity*>(GetPMan()->m_Context->GetObject(axisRefID));
|
|
if (axisRef)
|
|
{
|
|
VxVector dir,up,right;
|
|
axisRef->GetOrientation(&dir,&up,&right);
|
|
axisRef->TransformVector(&axis,&up);
|
|
}
|
|
//pJointCylindrical*pFactory::createCylindricalJoint(CK3dEntity*a,CK3dEntity*b,VxVector anchor,VxVector axis)
|
|
pJointPointInPlane*joint = static_cast<pJointPointInPlane*>(pFactory::Instance()->createPointInPlaneJoint(target,bodyBEnt,anchor0,axis));
|
|
if (joint)
|
|
{
|
|
joint->enableCollision(collision);
|
|
|
|
float maxForce = GetValueFromParameterStruct<float>(pointInPlaneParameter,PS_JPIP_MAX_FORCE);
|
|
float maxTorque = GetValueFromParameterStruct<float>(pointInPlaneParameter,PS_JPIP_MAX_TORQUE);
|
|
joint->setBreakForces(maxForce,maxTorque);
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}else
|
|
{
|
|
|
|
|
|
pJoint *joint = body->isConnected(bodyBEnt);
|
|
if ( joint)
|
|
{
|
|
body->getWorld()->deleteJoint(joint);
|
|
}
|
|
pJoint *joint2 = body->getWorld()->getJoint(target,bodyBEnt,(JType)JT_PointInPlane);
|
|
if (joint2)
|
|
{
|
|
body->getWorld()->deleteJoint(joint);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
int registerJRevolute(CK3dEntity *target,int attributeType,bool set,bool isPostJob)
|
|
{
|
|
|
|
int s = GetPMan()->getAttributePostObjects().Size();
|
|
using namespace vtTools::ParameterTools;
|
|
CKParameterOut *distanceParameter = target->GetAttributeParameter(attributeType);
|
|
|
|
CKStructHelper sHelper(target->GetAttributeParameter(attributeType));
|
|
if (sHelper.GetMemberCount() ==0 )//happens when dev is being opened and loads a cmo with physic objects.
|
|
return -1;
|
|
|
|
if (distanceParameter )
|
|
{
|
|
|
|
pRigidBody *body = GetPMan()->getBody(target);
|
|
if (!body)return -1;
|
|
|
|
CK_ID bodyBId = GetValueFromParameterStruct<CK_ID>(distanceParameter,PS_JREVOLUTE_BODY_B);
|
|
CK3dEntity *bodyBEnt = static_cast<CK3dEntity*>(GetPMan()->GetContext()->GetObject(bodyBId));
|
|
pRigidBody *bodyB = GetPMan()->getBody(bodyBEnt);
|
|
if (bodyB && bodyB->getWorld() != body->getWorld() )
|
|
return -1;
|
|
if (set)
|
|
{
|
|
|
|
if (isPostJob && GetPMan()->GetContext()->IsPlaying())
|
|
{
|
|
pAttributePostObject postAttObject(target->GetID(),registerJRevolute,attributeType);
|
|
GetPMan()->getAttributePostObjects().PushBack(postAttObject);
|
|
return true;
|
|
|
|
}
|
|
|
|
if (bodyB && body->isConnected(bodyBEnt) )
|
|
return -1;
|
|
|
|
VxVector anchor0 = GetValueFromParameterStruct<VxVector>(distanceParameter,PS_JREVOLUTE_ANCHOR);
|
|
CK_ID anchor0RefID = GetValueFromParameterStruct<CK_ID>(distanceParameter,PS_JREVOLUTE_ANCHOR_REF);
|
|
CK3dEntity *a0Ref = static_cast<CK3dEntity*>(GetPMan()->m_Context->GetObject(anchor0RefID));
|
|
if (a0Ref) a0Ref->Transform(&anchor0,&anchor0);
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//axis
|
|
VxVector axis = GetValueFromParameterStruct<VxVector>(distanceParameter,PS_JREVOLUTE_AXIS);
|
|
CK_ID axisRefID = GetValueFromParameterStruct<CK_ID>(distanceParameter,PS_JREVOLUTE_AXIS_REF);
|
|
CK3dEntity *axisRef = static_cast<CK3dEntity*>(GetPMan()->m_Context->GetObject(axisRefID));
|
|
if (axisRef)
|
|
{
|
|
VxVector dir,up,right;
|
|
axisRef->GetOrientation(&dir,&up,&right);
|
|
axisRef->TransformVector(&axis,&up);
|
|
}
|
|
|
|
int collision = GetValueFromParameterStruct<int>(distanceParameter,PS_JREVOLUTE_COLLISION);
|
|
|
|
int projectionMode = GetValueFromParameterStruct<int>(distanceParameter,PS_JREVOLUTE_PROJ_MODE);
|
|
float projectionDistance= GetValueFromParameterStruct<float>(distanceParameter,PS_JREVOLUTE_PROJ_DISTANCE);
|
|
float projectionAngle = GetValueFromParameterStruct<float>(distanceParameter,PS_JREVOLUTE_PROJ_ANGLE);
|
|
|
|
|
|
|
|
pJointLimit limitHigh = pFactory::Instance()->createLimitFromParameter(vtTools::ParameterTools::GetParameterFromStruct(distanceParameter,PS_JREVOLUTE_LIMIT_HIGH));
|
|
pJointLimit limitLow= pFactory::Instance()->createLimitFromParameter(vtTools::ParameterTools::GetParameterFromStruct(distanceParameter,PS_JREVOLUTE_LIMIT_LOW));
|
|
pSpring spring = pFactory::Instance()->createSpringFromParameter(vtTools::ParameterTools::GetParameterFromStruct(distanceParameter,PS_JREVOLUTE_SPRING));
|
|
pMotor motor = pFactory::Instance()->createMotorFromParameter(vtTools::ParameterTools::GetParameterFromStruct(distanceParameter,PS_JREVOLUTE_MOTOR));
|
|
|
|
pJointRevolute*joint = static_cast<pJointRevolute*>(pFactory::Instance()->createRevoluteJoint(target,bodyBEnt,anchor0,axis));
|
|
if (joint)
|
|
{
|
|
|
|
joint->enableCollision(collision);
|
|
joint->setLowLimit(limitLow);
|
|
joint->setHighLimit(limitHigh);
|
|
joint->setSpring(spring);
|
|
|
|
if (projectionMode!=0)
|
|
{
|
|
joint->setProjectionMode((ProjectionMode)projectionMode);
|
|
joint->setProjectionDistance(projectionDistance);
|
|
joint->setProjectionAngle(projectionAngle);
|
|
}
|
|
|
|
float maxForce = GetValueFromParameterStruct<float>(distanceParameter,PS_JREVOLUTE_MAX_FORCE);
|
|
float maxTorque = GetValueFromParameterStruct<float>(distanceParameter,PS_JREVOLUTE_MAX_TORQUE);
|
|
if (maxTorque !=0.0f || maxForce!=0.0f)
|
|
{
|
|
joint->setBreakForces(maxForce,maxTorque);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return 0;
|
|
}else
|
|
{
|
|
|
|
|
|
pJoint *joint = body->isConnected(bodyBEnt);
|
|
if ( joint)
|
|
{
|
|
body->getWorld()->deleteJoint(joint);
|
|
}
|
|
pJoint *joint2 = body->getWorld()->getJoint(target,bodyBEnt,(JType)JT_Revolute);
|
|
if (joint2)
|
|
{
|
|
body->getWorld()->deleteJoint(joint);
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
int registerJCylindrical(CK3dEntity *target,int attributeType,bool set,bool isPostJob)
|
|
{
|
|
|
|
|
|
using namespace vtTools::ParameterTools;
|
|
CKParameterOut *distanceParameter = target->GetAttributeParameter(attributeType);
|
|
|
|
|
|
CKStructHelper sHelper(target->GetAttributeParameter(attributeType));
|
|
if (sHelper.GetMemberCount() ==0 )//happens when dev is being opened and loads a cmo with physic objects.
|
|
return -1;
|
|
|
|
if (distanceParameter )
|
|
{
|
|
|
|
pRigidBody *body = GetPMan()->getBody(target);
|
|
if (!body)return -1;
|
|
|
|
CK_ID bodyBId = GetValueFromParameterStruct<CK_ID>(distanceParameter,PS_JCYLINDRICAL_BODY_B);
|
|
CK3dEntity *bodyBEnt = static_cast<CK3dEntity*>(GetPMan()->GetContext()->GetObject(bodyBId));
|
|
pRigidBody *bodyB = GetPMan()->getBody(bodyBEnt);
|
|
if (bodyB && bodyB->getWorld() != body->getWorld() )
|
|
return -1;
|
|
if (set)
|
|
{
|
|
|
|
if (isPostJob && GetPMan()->GetContext()->IsPlaying())
|
|
{
|
|
pAttributePostObject postAttObject(target->GetID(),registerJCylindrical,attributeType);
|
|
GetPMan()->getAttributePostObjects().PushBack(postAttObject);
|
|
return true;
|
|
|
|
}
|
|
|
|
if (bodyB && body->isConnected(bodyBEnt) )
|
|
return -1;
|
|
|
|
VxVector anchor0 = GetValueFromParameterStruct<VxVector>(distanceParameter,PS_JCYLINDRICAL_ANCHOR);
|
|
CK_ID anchor0RefID = GetValueFromParameterStruct<CK_ID>(distanceParameter,PS_JCYLINDRICAL_ANCHOR_REF);
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//anchor :
|
|
CK3dEntity *a0Ref = static_cast<CK3dEntity*>(GetPMan()->m_Context->GetObject(anchor0RefID));
|
|
if (a0Ref) a0Ref->Transform(&anchor0,&anchor0);
|
|
int collision = GetValueFromParameterStruct<int>(distanceParameter,PS_JCYLINDRICAL_COLLISION);
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//axis
|
|
VxVector axis = GetValueFromParameterStruct<VxVector>(distanceParameter,PS_JCYLINDRICAL_AXIS);
|
|
CK_ID axisRefID = GetValueFromParameterStruct<CK_ID>(distanceParameter,PS_JCYLINDRICAL_AXIS_REF);
|
|
CK3dEntity *axisRef = static_cast<CK3dEntity*>(GetPMan()->m_Context->GetObject(axisRefID));
|
|
if (axisRef)
|
|
{
|
|
VxVector dir,up,right;
|
|
axisRef->GetOrientation(&dir,&up,&right);
|
|
axisRef->TransformVector(&axis,&up);
|
|
}
|
|
//pJointCylindrical*pFactory::createCylindricalJoint(CK3dEntity*a,CK3dEntity*b,VxVector anchor,VxVector axis)
|
|
pJointCylindrical*joint = static_cast<pJointCylindrical*>(pFactory::Instance()->createCylindricalJoint(target,bodyBEnt,anchor0,axis));
|
|
if (joint)
|
|
{
|
|
joint->enableCollision(collision);
|
|
|
|
float maxForce = GetValueFromParameterStruct<float>(distanceParameter,PS_JCYLINDRICAL_MAX_FORCE);
|
|
float maxTorque = GetValueFromParameterStruct<float>(distanceParameter,PS_JCYLINDRICAL_MAX_TORQUE);
|
|
//joint->setBreakForces(maxForce,maxTorque);
|
|
return true;
|
|
}
|
|
|
|
return 0;
|
|
}else
|
|
{
|
|
|
|
|
|
pJoint *joint = body->isConnected(bodyBEnt);
|
|
if ( joint)
|
|
{
|
|
body->getWorld()->deleteJoint(joint);
|
|
}
|
|
pJoint *joint2 = body->getWorld()->getJoint(target,bodyBEnt,(JType)JT_Cylindrical);
|
|
if (joint2)
|
|
{
|
|
body->getWorld()->deleteJoint(joint);
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
int registerJPrismatic(CK3dEntity *target,int attributeType,bool set,bool isPostJob)
|
|
{
|
|
using namespace vtTools::ParameterTools;
|
|
CKParameterOut *distanceParameter = target->GetAttributeParameter(attributeType);
|
|
|
|
CKStructHelper sHelper(target->GetAttributeParameter(attributeType));
|
|
if (sHelper.GetMemberCount() ==0 )//happens when dev is being opened and loads a cmo with physic objects.
|
|
return -1;
|
|
|
|
if (distanceParameter )
|
|
{
|
|
|
|
pRigidBody *body = GetPMan()->getBody(target);
|
|
if (!body)return -1;
|
|
|
|
CK_ID bodyBId = GetValueFromParameterStruct<CK_ID>(distanceParameter,PS_JPRISMATIC_BODY_B);
|
|
CK3dEntity *bodyBEnt = static_cast<CK3dEntity*>(GetPMan()->GetContext()->GetObject(bodyBId));
|
|
pRigidBody *bodyB = GetPMan()->getBody(bodyBEnt);
|
|
if (bodyB && bodyB->getWorld() != body->getWorld() )
|
|
return -1;
|
|
if (set)
|
|
{
|
|
|
|
if (isPostJob && GetPMan()->GetContext()->IsPlaying())
|
|
{
|
|
pAttributePostObject postAttObject(target->GetID(),registerJPrismatic,attributeType);
|
|
GetPMan()->getAttributePostObjects().PushBack(postAttObject);
|
|
return true;
|
|
|
|
}
|
|
|
|
if (bodyB && body->isConnected(bodyBEnt) )
|
|
return -1;
|
|
|
|
VxVector anchor0 = GetValueFromParameterStruct<VxVector>(distanceParameter,PS_JPRISMATIC_ANCHOR);
|
|
CK_ID anchor0RefID = GetValueFromParameterStruct<CK_ID>(distanceParameter,PS_JPRISMATIC_ANCHOR_REF);
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//anchor :
|
|
CK3dEntity *a0Ref = static_cast<CK3dEntity*>(GetPMan()->m_Context->GetObject(anchor0RefID));
|
|
if (a0Ref) a0Ref->Transform(&anchor0,&anchor0);
|
|
int collision = GetValueFromParameterStruct<int>(distanceParameter,PS_JPRISMATIC_COLLISION);
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//axis
|
|
VxVector axis = GetValueFromParameterStruct<VxVector>(distanceParameter,PS_JPRISMATIC_AXIS);
|
|
CK_ID axisRefID = GetValueFromParameterStruct<CK_ID>(distanceParameter,PS_JPRISMATIC_AXIS_REF);
|
|
CK3dEntity *axisRef = static_cast<CK3dEntity*>(GetPMan()->m_Context->GetObject(axisRefID));
|
|
if (axisRef)
|
|
{
|
|
VxVector dir,up,right;
|
|
axisRef->GetOrientation(&dir,&up,&right);
|
|
axisRef->TransformVector(&axis,&up);
|
|
}
|
|
//pJointCylindrical*pFactory::createCylindricalJoint(CK3dEntity*a,CK3dEntity*b,VxVector anchor,VxVector axis)
|
|
pJointCylindrical*joint = static_cast<pJointCylindrical*>(pFactory::Instance()->createCylindricalJoint(target,bodyBEnt,anchor0,axis));
|
|
if (joint)
|
|
{
|
|
joint->enableCollision(collision);
|
|
|
|
float maxForce = GetValueFromParameterStruct<float>(distanceParameter,PS_JCYLINDRICAL_MAX_FORCE);
|
|
float maxTorque = GetValueFromParameterStruct<float>(distanceParameter,PS_JCYLINDRICAL_MAX_TORQUE);
|
|
joint->setBreakForces(maxForce,maxTorque);
|
|
|
|
return true;
|
|
}
|
|
|
|
return 0;
|
|
}else
|
|
{
|
|
|
|
|
|
pJoint *joint = body->isConnected(bodyBEnt);
|
|
if ( joint)
|
|
{
|
|
body->getWorld()->deleteJoint(joint);
|
|
}
|
|
pJoint *joint2 = body->getWorld()->getJoint(target,bodyBEnt,(JType)JT_Prismatic);
|
|
if (joint2)
|
|
{
|
|
body->getWorld()->deleteJoint(joint);
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int registerJBall(CK3dEntity *target,int attributeType,bool set,bool isPostJob)
|
|
{
|
|
using namespace vtTools::ParameterTools;
|
|
CKParameterOut *distanceParameter = target->GetAttributeParameter(attributeType);
|
|
|
|
|
|
CKStructHelper sHelper(target->GetAttributeParameter(attributeType));
|
|
if (sHelper.GetMemberCount() ==0 )//happens when dev is being opened and loads a cmo with physic objects.
|
|
return -1;
|
|
|
|
if (distanceParameter )
|
|
{
|
|
|
|
pRigidBody *body = GetPMan()->getBody(target);
|
|
if (!body)return -1;
|
|
|
|
CK_ID bodyBId = GetValueFromParameterStruct<CK_ID>(distanceParameter,PS_JBALL_BODY_B);
|
|
CK3dEntity *bodyBEnt = static_cast<CK3dEntity*>(GetPMan()->GetContext()->GetObject(bodyBId));
|
|
pRigidBody *bodyB = GetPMan()->getBody(bodyBEnt);
|
|
if (bodyB && bodyB->getWorld() != body->getWorld() )
|
|
return -1;
|
|
if (set)
|
|
{
|
|
|
|
if (isPostJob && GetPMan()->GetContext()->IsPlaying())
|
|
{
|
|
pAttributePostObject postAttObject(target->GetID(),registerJBall,attributeType);
|
|
GetPMan()->getAttributePostObjects().PushBack(postAttObject);
|
|
return true;
|
|
|
|
}
|
|
|
|
if (bodyB && body->isConnected(bodyBEnt) )
|
|
return -1;
|
|
|
|
VxVector anchor0 = GetValueFromParameterStruct<VxVector>(distanceParameter,PS_JBALL_ANCHOR);
|
|
CK_ID anchor0RefID = GetValueFromParameterStruct<CK_ID>(distanceParameter,PS_JBALL_ANCHOR_REF);
|
|
CK3dEntity *a0Ref = static_cast<CK3dEntity*>(GetPMan()->m_Context->GetObject(anchor0RefID));
|
|
if (a0Ref) a0Ref->Transform(&anchor0,&anchor0);
|
|
|
|
VxVector axis = GetValueFromParameterStruct<VxVector>(distanceParameter,PS_JBALL_GLOBAL_AXIS);
|
|
CK_ID axisRefID = GetValueFromParameterStruct<CK_ID>(distanceParameter,PS_JBALL_GLOBAL_AXIS_REF);
|
|
CK3dEntity *axisRef = static_cast<CK3dEntity*>(GetPMan()->m_Context->GetObject(axisRefID));
|
|
if (axisRef)
|
|
{
|
|
VxVector dir,up,right;
|
|
axisRef->GetOrientation(&dir,&up,&right);
|
|
axisRef->TransformVector(&axis,&up);
|
|
}
|
|
|
|
VxVector swingAxis = GetValueFromParameterStruct<VxVector>(distanceParameter,PS_JBALL_LIMIT_SWING_AXIS);
|
|
|
|
int collision = GetValueFromParameterStruct<int>(distanceParameter,PS_JBALL_COLLISION);
|
|
|
|
int projectionMode = GetValueFromParameterStruct<int>(distanceParameter,PS_JBALL_PROJ_MODE);
|
|
float minDist = GetValueFromParameterStruct<float>(distanceParameter,PS_JBALL_PROJ_DISTANCE);
|
|
|
|
pJointLimit swingLimit = pFactory::Instance()->createLimitFromParameter(vtTools::ParameterTools::GetParameterFromStruct(distanceParameter,PS_JBALL_SWING_LIMIT));
|
|
pJointLimit twistHighLimit = pFactory::Instance()->createLimitFromParameter(vtTools::ParameterTools::GetParameterFromStruct(distanceParameter,PS_JBALL_TWIST_HIGH));
|
|
pJointLimit twistHighLow = pFactory::Instance()->createLimitFromParameter(vtTools::ParameterTools::GetParameterFromStruct(distanceParameter,PS_JBALL_TWIST_LOW));
|
|
|
|
pSpring swingSpring = pFactory::Instance()->createSpringFromParameter(vtTools::ParameterTools::GetParameterFromStruct(distanceParameter,PS_JBALL_SWING_SPRING));
|
|
pSpring twistSpring = pFactory::Instance()->createSpringFromParameter(vtTools::ParameterTools::GetParameterFromStruct(distanceParameter,PS_JBALL_TWIST_SPRING));
|
|
pSpring jointSpring = pFactory::Instance()->createSpringFromParameter(vtTools::ParameterTools::GetParameterFromStruct(distanceParameter,PS_JBALL_JOINT_SPRING));
|
|
|
|
pJointBall *joint = static_cast<pJointBall*>(pFactory::Instance()->createBallJoint(target,bodyBEnt,anchor0,swingAxis,axis));
|
|
if (joint)
|
|
{
|
|
|
|
joint->setProjectionMode((ProjectionMode)projectionMode);
|
|
joint->setProjectionDistance(minDist);
|
|
joint->enableCollision(collision);
|
|
|
|
float maxForce = GetValueFromParameterStruct<float>(distanceParameter,PS_JBALL_MAX_FORCE);
|
|
float maxTorque = GetValueFromParameterStruct<float>(distanceParameter,PS_JBALL_MAX_TORQUE);
|
|
joint->setBreakForces(maxForce,maxTorque);
|
|
|
|
|
|
|
|
if (swingLimit.value !=-1.0f)
|
|
{
|
|
joint->setSwingLimit(swingLimit);
|
|
joint->enableFlag(NX_SJF_SWING_LIMIT_ENABLED,true);
|
|
}
|
|
|
|
joint->setSwingLimit(swingLimit);
|
|
|
|
|
|
if (twistHighLimit.value != 0.0f || twistHighLow.value !=0.0f )
|
|
{
|
|
|
|
joint->setTwistHighLimit(twistHighLimit);
|
|
joint->setTwistLowLimit(twistHighLow);
|
|
joint->enableFlag(NX_SJF_TWIST_LIMIT_ENABLED,true);
|
|
}
|
|
|
|
if (swingSpring.spring !=0.0f)
|
|
{
|
|
joint->setSwingSpring(swingSpring);
|
|
joint->enableFlag(NX_SJF_SWING_SPRING_ENABLED,true);
|
|
}
|
|
|
|
|
|
if (twistSpring.spring =0.0f)
|
|
{
|
|
joint->setTwistSpring(twistSpring);
|
|
joint->enableFlag(NX_SJF_TWIST_SPRING_ENABLED,true);
|
|
}
|
|
|
|
if (jointSpring.spring !=0.0f)
|
|
{
|
|
joint->setJointSpring(jointSpring);
|
|
joint->enableFlag(NX_SJF_JOINT_SPRING_ENABLED,true);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return 0;
|
|
}else
|
|
{
|
|
|
|
|
|
pJoint *joint = body->isConnected(bodyBEnt);
|
|
if ( joint)
|
|
{
|
|
body->getWorld()->deleteJoint(joint);
|
|
}
|
|
pJoint *joint2 = body->getWorld()->getJoint(target,bodyBEnt,(JType)JT_Spherical);
|
|
if (joint2)
|
|
{
|
|
body->getWorld()->deleteJoint(joint);
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int registerJFixed(CK3dEntity *target,int attributeType,bool set,bool isPostJob)
|
|
{
|
|
using namespace vtTools::ParameterTools;
|
|
|
|
CKStructHelper sHelper(target->GetAttributeParameter(attributeType));
|
|
if (sHelper.GetMemberCount() ==0 )//happens when dev is being opened and loads a cmo with physic objects.
|
|
return -1;
|
|
|
|
|
|
CKParameterOut *distanceParameter = target->GetAttributeParameter(attributeType);
|
|
if (distanceParameter )
|
|
{
|
|
|
|
pRigidBody *body = GetPMan()->getBody(target);
|
|
if (!body)return -1;
|
|
|
|
CK_ID bodyBId = GetValueFromParameterStruct<CK_ID>(distanceParameter,PS_JFIXED_BODY_B);
|
|
CK3dEntity *bodyBEnt = static_cast<CK3dEntity*>(GetPMan()->GetContext()->GetObject(bodyBId));
|
|
pRigidBody *bodyB = GetPMan()->getBody(bodyBEnt);
|
|
if (bodyB && bodyB->getWorld() != body->getWorld() )
|
|
return -1;
|
|
if (set)
|
|
{
|
|
|
|
if ( isPostJob && GetPMan()->GetContext()->IsPlaying() )
|
|
{
|
|
pAttributePostObject postAttObject(target->GetID(),registerJFixed,attributeType);
|
|
GetPMan()->getAttributePostObjects().PushBack(postAttObject);
|
|
return true;
|
|
|
|
}
|
|
|
|
if (bodyB && body->isConnected(bodyBEnt) )
|
|
return -1;
|
|
|
|
|
|
pJointFixed *joint = static_cast<pJointFixed*>(pFactory::Instance()->createFixedJoint(target,bodyBEnt));
|
|
if (joint)
|
|
{
|
|
|
|
float maxForce = GetValueFromParameterStruct<float>(distanceParameter,PS_JFIXED_MAX_FORCE);
|
|
float maxTorque = GetValueFromParameterStruct<float>(distanceParameter,PS_JFIXED_MAX_TORQUE);
|
|
joint->setBreakForces(maxForce,maxTorque);
|
|
|
|
return true;
|
|
}
|
|
return 0;
|
|
}else
|
|
{
|
|
|
|
|
|
pJoint *joint = body->isConnected(bodyBEnt);
|
|
if ( joint)
|
|
{
|
|
body->getWorld()->deleteJoint(joint);
|
|
}
|
|
pJoint *joint2 = body->getWorld()->getJoint(target,bodyBEnt,(JType)JT_Fixed);
|
|
if (joint2)
|
|
{
|
|
body->getWorld()->deleteJoint(joint);
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
int registerJDistance(CK3dEntity *target,int attributeType,bool set,bool isPostJob)
|
|
{
|
|
using namespace vtTools::ParameterTools;
|
|
|
|
if(!GetPMan()->GetContext()->IsPlaying() && !GetPMan()->isValid() )
|
|
return 0;
|
|
|
|
|
|
CKStructHelper sHelper(target->GetAttributeParameter(attributeType));
|
|
if (sHelper.GetMemberCount() ==0 )//happens when dev is being opened and loads a cmo with physic objects.
|
|
return -1;
|
|
|
|
CKParameterOut *distanceParameter = target->GetAttributeParameter(attributeType);
|
|
if (distanceParameter )
|
|
{
|
|
|
|
pRigidBody *body = GetPMan()->getBody(target);
|
|
if (!body)return -1;
|
|
|
|
CK_ID bodyBId = GetValueFromParameterStruct<CK_ID>(distanceParameter,PS_JDISTANCE_BODY_B);
|
|
CK3dEntity *bodyBEnt = static_cast<CK3dEntity*>(GetPMan()->GetContext()->GetObject(bodyBId));
|
|
pRigidBody *bodyB = GetPMan()->getBody(bodyBEnt);
|
|
if (bodyB && bodyB->getWorld() != body->getWorld() )
|
|
return -1;
|
|
|
|
if (set)
|
|
{
|
|
|
|
if (isPostJob && GetPMan()->GetContext()->IsPlaying())
|
|
{
|
|
pAttributePostObject postAttObject(target->GetID(),registerJDistance,attributeType);
|
|
GetPMan()->getAttributePostObjects().PushBack(postAttObject);
|
|
|
|
int s = GetPMan()->getAttributePostObjects().Size();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (bodyB && body->isConnected(bodyBEnt) )
|
|
return -1;
|
|
|
|
VxVector anchor0 = GetValueFromParameterStruct<VxVector>(distanceParameter,PS_JDISTANCE_LOCAL_ANCHOR_A_POS);
|
|
CK_ID anchor0RefID = GetValueFromParameterStruct<CK_ID>(distanceParameter,PS_JDISTANCE_LOCAL_ANCHOR_A_REF);
|
|
CK3dEntity *a0Ref = static_cast<CK3dEntity*>(GetPMan()->m_Context->GetObject(anchor0RefID));
|
|
if (a0Ref) a0Ref->TransformVector(&anchor0,&anchor0,a0Ref);
|
|
|
|
VxVector anchor1 = GetValueFromParameterStruct<VxVector>(distanceParameter,PS_JDISTANCE_LOCAL_ANCHOR_B_POS);
|
|
CK_ID anchor1RefID = GetValueFromParameterStruct<CK_ID>(distanceParameter,PS_JDISTANCE_LOCAL_ANCHOR_B_REF);
|
|
CK3dEntity *a1Ref = static_cast<CK3dEntity*>(GetPMan()->m_Context->GetObject(anchor1RefID));
|
|
if (a1Ref) a1Ref->TransformVector(&anchor1,&anchor1,a1Ref);
|
|
|
|
float maxDist = GetValueFromParameterStruct<float>(distanceParameter,PS_JDISTANCE_MAX_DISTANCE);
|
|
float minDist = GetValueFromParameterStruct<float>(distanceParameter,PS_JDISTANCE_MIN_DISTANCE);
|
|
|
|
pSpring spring = pFactory::Instance()->createSpringFromParameter( GetParameterFromStruct(distanceParameter,PS_JDISTANCE_SPRING) );
|
|
|
|
int collision = GetValueFromParameterStruct<int>(distanceParameter,PS_JDISTANCE_COLL);
|
|
|
|
|
|
pJointDistance *joint = static_cast<pJointDistance*>(pFactory::Instance()->createDistanceJoint(target,bodyBEnt,anchor0,anchor1,minDist,maxDist,spring));
|
|
if (joint)
|
|
{
|
|
|
|
float maxForce = GetValueFromParameterStruct<float>(distanceParameter,PS_JDISTANCE_MAX_FORCE);
|
|
float maxTorque = GetValueFromParameterStruct<float>(distanceParameter,PS_JDISTANCE_MAX_TORQUE);
|
|
joint->setBreakForces(maxForce,maxTorque);
|
|
joint->enableCollision(collision);
|
|
|
|
|
|
#ifdef _DEBUG
|
|
|
|
XString _errorStr;
|
|
|
|
XString attName = GetPMan()->GetContext()->GetAttributeManager()->GetAttributeNameByType(attributeType);
|
|
|
|
_errorStr << "Distance joint created on " << target->GetName() << " for attribute type : " << attName.Str();
|
|
|
|
xLogger::xLog(XL_START,ELOGINFO,E_LI_MANAGER,_errorStr.Str());
|
|
|
|
#endif
|
|
|
|
return true;
|
|
}
|
|
return 0;
|
|
}else
|
|
{
|
|
|
|
|
|
pJoint *joint = body->isConnected(bodyBEnt);
|
|
if ( joint)
|
|
{
|
|
body->getWorld()->deleteJoint(joint);
|
|
}
|
|
pJoint *joint2 = body->getWorld()->getJoint(target,bodyBEnt,(JType)JT_Distance);
|
|
if (joint2)
|
|
{
|
|
body->getWorld()->deleteJoint(joint);
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
void PObjectAttributeCallbackFunc(int AttribType,CKBOOL Set,CKBeObject *obj,void *arg)
|
|
{
|
|
|
|
CK3dEntity *ent = static_cast<CK3dEntity*>(obj);
|
|
if (!ent)return;
|
|
|
|
ObjectRegisterFunction myFn = static_cast<ObjectRegisterFunction>(arg);
|
|
if (ent , myFn)
|
|
{
|
|
bool isPlaying = GetPMan()->GetContext()->IsPlaying();
|
|
int success = (*myFn)(ent,AttribType,Set,true);
|
|
|
|
if (!success)
|
|
{
|
|
CKAttributeManager* attman = GetPMan()->GetContext()->GetAttributeManager();
|
|
XString error;
|
|
error << "Registration Function failed for attribute" << attman->GetAttributeNameByType(AttribType) << " for Object : " << ent->GetName() ;
|
|
xLogger::xLog(XL_START,ELOGWARNING,E_LI_MANAGER,error.Str());
|
|
}else{
|
|
|
|
CKAttributeManager* attman = GetPMan()->GetContext()->GetAttributeManager();
|
|
XString error;
|
|
error << "Registration Function succeeded for attribute" << attman->GetAttributeNameByType(AttribType) << " for Object : " << ent->GetName() ;
|
|
xLogger::xLog(XL_START,ELOGTRACE,E_LI_MANAGER,error.Str());
|
|
}
|
|
}
|
|
}
|