ILINE bool InitializePoseAlignerBipedHuman(PoseAligner::CPose& pose, IEntity& entity, ICharacterInstance& character)
{
IDefaultSkeleton& rIDefaultSkeleton = character.GetIDefaultSkeleton();
int jointIndexRoot = rIDefaultSkeleton.GetJointIDByName("Bip01 Pelvis");
if (jointIndexRoot < 0)
return false;
int jointIndexFrontLeft = rIDefaultSkeleton.GetJointIDByName("Bip01 planeTargetLeft");
if (jointIndexFrontLeft < 0)
return false;
int jointIndexFrontRight = rIDefaultSkeleton.GetJointIDByName("Bip01 planeTargetRight");
if (jointIndexFrontRight < 0)
return false;
int jointIndexLeftBlend = rIDefaultSkeleton.GetJointIDByName("Bip01 planeWeightLeft");
int jointIndexRightBlend = rIDefaultSkeleton.GetJointIDByName("Bip01 planeWeightRight");
if (!pose.Initialize(entity, jointIndexRoot))
return false;
pose.SetRootOffsetMinMax(-0.4f, 0.0f);
PoseAligner::SChainDesc chainDesc;
chainDesc.name = "Left";
chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
chainDesc.solver = "LftLeg01";
chainDesc.contactJointIndex = jointIndexFrontLeft;
chainDesc.targetBlendJointIndex = jointIndexLeftBlend;
chainDesc.bBlendProcedural = true;
chainDesc.bTargetSmoothing = true;
chainDesc.offsetMin = Vec3(0.0f, 0.0f, 0.0f);
chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.6f);
if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
{
pContactRaycast->SetLength(1.0f);
chainDesc.pContactReporter = pContactRaycast;
}
if (!pose.CreateChain(chainDesc))
return false;
chainDesc.name = "Right";
chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
chainDesc.solver = "RgtLeg01";
chainDesc.contactJointIndex = jointIndexFrontRight;
chainDesc.targetBlendJointIndex = jointIndexRightBlend;
chainDesc.bBlendProcedural = true;
chainDesc.bTargetSmoothing = true;
chainDesc.offsetMin = Vec3(0.0f, 0.0f, 0.0f);
chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.6f);
if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
{
pContactRaycast->SetLength(1.0f);
chainDesc.pContactReporter = pContactRaycast;
}
if (!pose.CreateChain(chainDesc))
return false;
return pose.GetChainCount() != 0;
}
bool CMFXParticleEffect::AttachToCharacter( IEntity& targetEntity, const SMFXParticleEntry& particleParams, const SMFXRunTimeEffectParams& params, const Vec3& dir, float scale )
{
if (params.partID >= 0)
{
//Assume character is loaded in first slot
//We could iterate through all available slots, but first one should be good enough
ICharacterInstance* pCharacterInstace = targetEntity.GetCharacter(0);
ISkeletonPose* pSkeletonPose = pCharacterInstace ? pCharacterInstace->GetISkeletonPose() : NULL;
if (pSkeletonPose)
{
IDefaultSkeleton& rIDefaultSkeleton = pCharacterInstace->GetIDefaultSkeleton();
//It hit the character, but probably in a physicalized attached part, like armor plates, etc
if (params.partID >= rIDefaultSkeleton.GetJointCount())
{
return false;
}
//It hit some valid joint, create an attachment
const char* boneName = rIDefaultSkeleton.GetJointNameByID(params.partID);
TAttachmentName attachmentName;
GetNextCharacterAttachmentName(attachmentName);
IAttachmentManager* pAttachmentManager = pCharacterInstace->GetIAttachmentManager();
CRY_ASSERT(pAttachmentManager);
//Remove the attachment first (in case was created before)
pAttachmentManager->RemoveAttachmentByName(attachmentName.c_str());
//Create attachment on nearest hit bone
IAttachment* pAttachment = pAttachmentManager->CreateAttachment(attachmentName.c_str(), CA_BONE, boneName, false);
if (pAttachment)
{
//Apply relative offsets
const QuatT boneLocation = pSkeletonPose->GetAbsJointByID(params.partID);
Matrix34 inverseJointTM = targetEntity.GetWorldTM() * Matrix34(boneLocation);
inverseJointTM.Invert();
Vec3 attachmentOffsetPosition = inverseJointTM * params.pos;
Quat attachmentOffsetRotation = Quat(inverseJointTM) * targetEntity.GetRotation();
CRY_ASSERT(attachmentOffsetPosition.IsValid());
//CRY_ASSERT(attachmentOffsetRotation.IsUnit());
pAttachment->SetAttRelativeDefault(QuatT(attachmentOffsetRotation, attachmentOffsetPosition));
//Finally attach the effect
CEffectAttachment* pEffectAttachment = new CEffectAttachment(particleParams.name.c_str(), Vec3(0,0,0), dir, scale);
pAttachment->AddBinding(pEffectAttachment);
return true;
}
}
}
return false;
}
void CProceduralWeaponAnimationContext::Initialize(IScope* pScope)
{
++m_instanceCount;
if (m_pScope != 0)
return;
m_pScope = pScope;
ICharacterInstance* pCharacter = m_pScope->GetCharInst();
if (pCharacter)
{
CryCreateClassInstance("AnimationPoseModifier_OperatorQueue", m_pPoseModifier);
m_params = SParams(pCharacter->GetIDefaultSkeleton());
}
}
//------------------------------------------------------------------------
Vec3 CVehicleViewFirstPerson::GetWorldPosGoal()
{
Vec3 vehiclePos;
if (m_pHelper)
{
vehiclePos = m_pHelper->GetVehicleSpaceTranslation();
}
else if(!m_sCharacterBoneName.empty())
{
Vec3 bonePos;
IEntity* pEntity = gEnv->pEntitySystem->GetEntity(m_pSeat->GetPassenger());
ICharacterInstance* pCharacter = pEntity ? pEntity->GetCharacter(0) : NULL;
if(pCharacter)
{
IDefaultSkeleton& rIDefaultSkeleton = pCharacter->GetIDefaultSkeleton();
uint32 id = rIDefaultSkeleton.GetJointIDByName(m_sCharacterBoneName);
uint32 numJoints = rIDefaultSkeleton.GetJointCount();
if(numJoints > id)
{
bonePos = pCharacter->GetISkeletonPose()->GetAbsJointByID(id).t;
}
}
vehiclePos = pEntity ? pEntity->GetWorldTM() * bonePos : Vec3(0,0,0);
return vehiclePos;
}
else
{
IActor* pActor = CCryAction::GetCryAction()->GetIActorSystem()->GetActor(m_passengerId);
CRY_ASSERT(pActor);
vehiclePos = pActor->GetLocalEyePos() + m_offset;
IEntity* pActorEntity = pActor->GetEntity();
const Matrix34& slotTM = pActorEntity->GetSlotLocalTM(0, false);
vehiclePos = pActorEntity->GetLocalTM() * slotTM * vehiclePos;
}
return m_pVehicle->GetEntity()->GetWorldTM() * vehiclePos;
}
//------------------------------------------------------------------------
void CVehicleViewFirstPerson::OnStartUsing(EntityId passengerId)
{
CVehicleViewBase::OnStartUsing(passengerId);
if(!m_sCharacterBoneName.empty())
{
bool errorOccurred = false;
IEntity* pEntity = gEnv->pEntitySystem->GetEntity(passengerId);
ICharacterInstance* pCharacter = pEntity ? pEntity->GetCharacter(0) : NULL;
if(pCharacter)
{
IDefaultSkeleton& rIDefaultSkeleton = pCharacter->GetIDefaultSkeleton();
uint32 id = rIDefaultSkeleton.GetJointIDByName(m_sCharacterBoneName);
uint32 numJoints = rIDefaultSkeleton.GetJointCount();
if(numJoints <= id)
{
errorOccurred = true;
}
}
else
{
errorOccurred = true;
}
if(errorOccurred)
{
GameWarning("[%s, seat %s]: character Bone name %s not found", m_pVehicle->GetEntity()->GetName(), m_pSeat->GetName().c_str(), m_sCharacterBoneName.c_str());
}
else if (m_pHelper)
{
GameWarning("[%s, seat %s]: helper and character Bone name found, helper will be used (please only use one of these options)", m_pVehicle->GetEntity()->GetName(), m_pSeat->GetName().c_str());
}
}
if (m_hideVehicle)
{
m_slotFlags.clear();
HideEntitySlots(m_pVehicle->GetEntity(), true);
}
if (m_frameSlot != -1)
{
m_pVehicle->GetEntity()->SetSlotFlags(m_frameSlot, m_pVehicle->GetEntity()->GetSlotFlags(m_frameSlot) | ENTITY_SLOT_RENDER|ENTITY_SLOT_RENDER_NEAREST);
}
m_passengerId = passengerId;
m_viewPosition = GetWorldPosGoal();
m_viewRotation = GetWorldRotGoal();
if (m_passengerId && m_pSeat && !m_pSeat->IsDriver() && m_pSeat->IsPassengerShielded())
{
// disable rendering of ocean for passenger of amphibious vehicles (we see water inside the cabin)
if (IVehicleMovement *pMovement=m_pVehicle->GetMovement())
{
if (pMovement->GetMovementType()==IVehicleMovement::eVMT_Amphibious)
{
I3DEngine *p3DEngine=gEnv->p3DEngine;
p3DEngine->SetOceanRenderFlags(OCR_NO_DRAW);
}
}
}
if (m_hidePlayer)
{
if (IEntity* pEntity = gEnv->pEntitySystem->GetEntity(m_passengerId))
HideEntitySlots(pEntity, true);
}
m_pVehicle->RegisterVehicleEventListener(this, "1stPersonView");
}
//--------------------------------------------------------------------------------------------------
// Name: SpawnParticlesOnSkeleton
// Desc: Spawn particles on Skeleton
//--------------------------------------------------------------------------------------------------
void CGameEffect::SpawnParticlesOnSkeleton(IEntity* pEntity, IParticleEmitter* pParticleEmitter, uint32 numParticles,float maxHeightScale) const
{
if((pEntity) && (numParticles>0) && (pParticleEmitter) && (maxHeightScale>0.0f))
{
ICharacterInstance* pCharacter = pEntity->GetCharacter(0);
if(pCharacter)
{
IDefaultSkeleton& rIDefaultSkeleton = pCharacter->GetIDefaultSkeleton();
ISkeletonPose* pPose = pCharacter->GetISkeletonPose();
if(pPose)
{
Vec3 animPos;
Quat animRot;
IActor* pActor = gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(pEntity->GetId());
if(pActor) // First try to get animation data
{
QuatT animLoc = pActor->GetAnimatedCharacter()->GetAnimLocation();
animPos = animLoc.t;
animRot = animLoc.q;
}
else // If no actor, then use entity data
{
animPos = pEntity->GetWorldPos();
animRot = pEntity->GetWorldRotation();
}
animRot.Invert();
AABB bbox;
pEntity->GetLocalBounds(bbox);
float bbHeight = bbox.max.z - bbox.min.z;
// Avoid division by 0
if(bbHeight == 0)
{
bbHeight = 0.0001f;
}
const uint32 numJoints = rIDefaultSkeleton.GetJointCount();
for (uint32 i = 0; i < numParticles; ++i)
{
int id = cry_random(0U, numJoints - 1);
int parentId = rIDefaultSkeleton.GetJointParentIDByID(id);
if(parentId>0)
{
QuatT boneQuat = pPose->GetAbsJointByID(id);
QuatT parentBoneQuat= pPose->GetAbsJointByID(parentId);
float lerpScale = cry_random(0.0f, 1.0f);
QuatTS loc(IDENTITY);
loc.t = LERP(boneQuat.t,parentBoneQuat.t,lerpScale);
float heightScale = ((loc.t.z - bbox.min.z) / bbHeight);
if(heightScale < maxHeightScale)
{
loc.t = loc.t * animRot;
loc.t = loc.t + animPos;
pParticleEmitter->EmitParticle(NULL, NULL, &loc);
}
}
}
}
}
}
}//-------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------
void CSpectacularKill::ReadXmlData( const IItemParamsNode* pRootNode)
{
CRY_ASSERT(pRootNode);
ISharedParamsManager* pSharedParamsManager = gEnv->pGame->GetIGameFramework()->GetISharedParamsManager();
CRY_ASSERT(pSharedParamsManager);
// If we change the SharedParamsManager to accept CRCs on its interface we could compute this once and store
// the name's CRC32 instead of constructing it here each time this method is invoked (it shouldn't be invoked
// too often, though)
const char* szEntityClassName = m_pOwner->GetEntityClassName();
CryFixedStringT<64> sharedParamsName;
sharedParamsName.Format("%s_%s", SSharedSpectacularParams::s_typeInfo.GetName(), szEntityClassName);
ISharedParamsConstPtr pSharedParams = pSharedParamsManager->Get(sharedParamsName);
if (pSharedParams)
{
m_pParams = CastSharedParamsPtr<SSharedSpectacularParams>(pSharedParams);
return;
}
m_pParams.reset();
const IItemParamsNode* pParams = pRootNode->GetChild("SpectacularKill");
if (pParams)
{
SSharedSpectacularParams newParams;
const int childCount = pParams->GetChildCount();
newParams.paramsList.reserve(childCount);
for (int i = 0; i < childCount; ++i)
{
const IItemParamsNode* pTargetParams = pParams->GetChild(i);
CRY_ASSERT(pTargetParams);
IEntityClass* pTargetClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(pTargetParams->GetName());
if (pTargetClass)
{
SSpectacularKillParams targetParams;
const IItemParamsNode* pChildParamsNode = pTargetParams->GetChild("Params");
const IItemParamsNode* pChildAnimsNode = pTargetParams->GetChild("Anims");
targetParams.pEnemyClass = pTargetClass;
if(pChildParamsNode)
{
pChildParamsNode->GetAttribute("impulseScale", targetParams.impulseScale);
const char* szImpulseBone = pChildParamsNode->GetAttributeSafe("impulseBone");
ICharacterInstance* pCharacter = m_pOwner->GetEntity()->GetCharacter(0);
targetParams.impulseBone = pCharacter ? pCharacter->GetIDefaultSkeleton().GetJointIDByName(szImpulseBone) : -1;
}
if(pChildAnimsNode)
{
const int animCount = pChildAnimsNode->GetChildCount();
targetParams.animations.reserve(animCount);
for(int j = 0; j < animCount; j++)
{
const IItemParamsNode* pAnimNode = pChildAnimsNode->GetChild(j);
if(pAnimNode)
{
SSpectacularKillAnimation newAnimation;
newAnimation.victimAnimation = pAnimNode->GetAttributeSafe("victimAnimation");
newAnimation.killerAnimation = pAnimNode->GetAttributeSafe("killerAnimation");
pAnimNode->GetAttribute("optimalDist", newAnimation.optimalDist);
if (pAnimNode->GetAttribute("targetToKillerAngle", newAnimation.targetToKillerAngle))
newAnimation.targetToKillerAngle = DEG2RAD(newAnimation.targetToKillerAngle);
if (pAnimNode->GetAttribute("targetToKillerAngleRange", newAnimation.targetToKillerMinDot))
newAnimation.targetToKillerMinDot = cos_tpl(DEG2RAD(newAnimation.targetToKillerMinDot) / 2.0f);
pAnimNode->GetAttribute("obstacleCheckStartOffset", newAnimation.vKillerObstacleCheckOffset);
pAnimNode->GetAttribute("obstacleCheckLength", newAnimation.fObstacleCheckLength);
targetParams.animations.push_back(newAnimation);
}
}
}
CRY_ASSERT_MESSAGE(targetParams.animations.size() > 0, string().Format("No Animations defined for %s spectacular kill", pTargetClass->GetName()));
newParams.paramsList.push_back(targetParams);
}
#ifdef SPECTACULAR_KILL_DEBUG
else
{
GameWarning("spectacular Kill: Couldn't find entity of class '%s', skipping", pTargetParams->GetName());
}
#endif
}
m_pParams = CastSharedParamsPtr<SSharedSpectacularParams>(pSharedParamsManager->Register(sharedParamsName, newParams));
}
}
//------------------------------------------------------------------------
IStatObj* CVehiclePartAnimated::GetSubGeometry(CVehiclePartBase* pPart, EVehiclePartState state, Matrix34 &localTM, bool removeFromParent)
{
ICharacterInstance* pCharInstance = 0;
string jointName;
pPart->GetGeometryName(state, jointName);
int jointId = -1;
if (state == eVGS_Destroyed)
{
pCharInstance = m_pCharInstanceDestroyed;
if (pCharInstance)
jointId = pCharInstance->GetIDefaultSkeleton().GetJointIDByName(jointName.c_str());
}
else
{
// lookup first on intact, then on destroyed model
pCharInstance = m_pCharInstance;
if (pCharInstance)
jointId = pCharInstance->GetIDefaultSkeleton().GetJointIDByName(jointName.c_str());
if (jointId == -1)
{
pCharInstance = m_pCharInstanceDestroyed;
if (pCharInstance)
jointId = pCharInstance->GetIDefaultSkeleton().GetJointIDByName(jointName.c_str());
}
}
if (jointId != -1)
{
if (ISkeletonPose* pSkeletonPose = pCharInstance->GetISkeletonPose())
{
localTM = Matrix34(pCharInstance->GetISkeletonPose()->GetAbsJointByID(jointId));
if (IStatObj* pStatObj = pSkeletonPose->GetStatObjOnJoint(jointId))
{
if (removeFromParent && (pCharInstance != m_pCharInstanceDestroyed))
{
if (m_intactStatObjs.find(pPart->GetName()) == m_intactStatObjs.end())
{
m_intactStatObjs.insert(TStringStatObjMap::value_type(pPart->GetName(), pStatObj));
}
SetCGASlot(jointId, NULL);
}
if (pPart)
{
m_jointParts.insert(TStringVehiclePartMap::value_type(pPart->GetName(), pPart));
}
return pStatObj;
}
else if ((state == eVGS_Default) && (pPart->GetState() != eVGS_Default))
{
TStringStatObjMap::const_iterator it = m_intactStatObjs.find(pPart->GetName());
if (it != m_intactStatObjs.end())
{
return it->second;
}
}
}
}
return NULL;
}
void CVehicleWeaponControlled::Update(SEntityUpdateContext& ctx, int update)
{
IVehicle *pVehicle = m_vehicleId ? gEnv->pGame->GetIGameFramework()->GetIVehicleSystem()->GetVehicle(m_vehicleId) : NULL;
if (!m_vehicleId && GetEntity()->GetParent())
{
IEntity *entity = GetEntity();
if (entity)
{
IEntity *parent = entity->GetParent();
if (parent)
{
m_vehicleId = parent->GetId();
pVehicle = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem()->GetVehicle(parent->GetId());
}
}
}
if (pVehicle)
{
IVehiclePart *pPart = pVehicle->GetWeaponParentPart(GetEntityId());
if(pPart)
{
if(IVehiclePart *pParentPart = pPart->GetParent())
{
CRY_ASSERT(pVehicle->GetEntity());
if(ICharacterInstance *characterInst = pVehicle->GetEntity()->GetCharacter(pParentPart->GetSlot()))
{
if(ISkeletonPose* pose = characterInst->GetISkeletonPose())
{
IDefaultSkeleton& rIDefaultSkeleton = characterInst->GetIDefaultSkeleton();
int16 joint = rIDefaultSkeleton.GetJointIDByName(pPart->GetName());
const QuatT &jQuat = pose->GetAbsJointByID(joint);
Matrix34 localT(jQuat);
localT.SetTranslation(jQuat.t/* - Vec3(0.0f, 0.75f, 0.0f)*/);
Matrix34 vehicleWorldTm = pVehicle->GetEntity()->GetWorldTM();
Matrix34 mat = vehicleWorldTm * localT;
Vec3 vehicleSide2 = pPart->GetParent()->GetLocalTM(true, true).GetTranslation();
CPlayer *pl = this->GetOwnerPlayer();
Matrix33 mat2;
if (!m_destination.IsEquivalent(ZERO))
{
Vec3 diff = GetDestination() - mat.GetTranslation(); //pPart->GetWorldTM().GetTranslation();
diff.Normalize();
Matrix33 loc(mat);
loc.Invert();
Vec3 diffLocal = loc.TransformVector(diff);
Matrix33 desMat;
desMat.SetRotationVDir(diffLocal, 0.0f);
Vec3 test = GetEntity()->GetLocalTM().GetColumn0();
Ang3 testTM(desMat);
float za = testTM.x - m_Angles.x;
za = (za < 0.0f) ? -gf_PI : gf_PI;
za *= 0.05f * ctx.fFrameTime;
m_Angles.x += za;
Limit(m_Angles.x, -gf_PI * 0.33f, gf_PI * 0.33f);
if (testTM.z > m_Angles.z + 0.05f)
{
m_Angles.z += gf_PI * factor1 * ctx.fFrameTime;
}
else if (testTM.z < m_Angles.z - 0.05f)
{
m_Angles.z -= gf_PI * factor1 * ctx.fFrameTime;
}
else
{
m_Angles.z = testTM.z;
}
Limit(m_Angles.z, -gf_PI * 0.33f, gf_PI * 0.33f);
mat2.SetRotationXYZ(m_Angles);
}
else
{
if (!m_FireBlocked)
{
m_Angles.x = m_Angles.x - ctx.fFrameTime * factor2 * m_Angles.x;
m_Angles.z = m_Angles.z - ctx.fFrameTime * factor2 * m_Angles.z;
}
mat2.SetRotationXYZ(m_Angles);
}
mat = mat * mat2;
GetEntity()->SetWorldTM(mat);
if (pl)
{
Matrix34 worldGunMat = vehicleWorldTm * localT;
if (!pl->IsDead())
{
Vec3 trans = worldGunMat.GetTranslation() - worldGunMat.GetColumn2() * 0.7f;
worldGunMat.SetTranslation(trans);
pl->GetEntity()->SetWorldTM(worldGunMat);
float dot = mat.GetColumn1().dot(worldGunMat.GetColumn0());
Update3PAnim(pl, 0.5f - dot * 0.5f, ctx.fFrameTime, mat);
}
else
{
ICharacterInstance* pCharacter = pl->GetEntity()->GetCharacter(0);
int boneId = pCharacter ? pCharacter->GetIDefaultSkeleton().GetJointIDByName("Spine03") : 7;
pl->LinkToMountedWeapon(0);
if (IVehicleSeat* seat = pVehicle->GetSeatForPassenger(pl->GetEntityId()))
{
seat->Exit(false, true);
}
Matrix33 rot(worldGunMat);
Vec3 offset(0.0f, 0.0f, 0.70f);
Vec3 transformedOff = rot.TransformVector(offset);
Vec3 trans = worldGunMat.GetTranslation();
trans -= transformedOff;
worldGunMat.SetTranslation(trans);
pl->GetEntity()->SetWorldTM(worldGunMat);
pl->GetEntity()->SetPos(worldGunMat.GetTranslation()); //worldGunMat.GetTranslation());
pl->RagDollize(true);
if (boneId > -1)
{
IPhysicalEntity *physEnt = pl->GetEntity()->GetPhysics();
if (physEnt)
{
pe_simulation_params simulationParams;
physEnt->GetParams(&simulationParams);
pe_params_pos pos;
pos.pos = GetEntity()->GetPos();
physEnt->SetParams(&pos);
pe_action_impulse impulse;
impulse.ipart = boneId;
impulse.angImpulse = Vec3(0.0f, 0.0f, 1.0f);
impulse.impulse = worldGunMat.GetColumn1() * -1.5f * simulationParams.mass;
physEnt->Action(&impulse);
}
}
StopUse(GetOwnerId());
SetOwnerId(0);
StopFire();
m_FireBlocked = true;
} // IsDead
} // pl
} // pose
} // characterInst
} // pParentPart
} // pPart
} // pVehicle
Base::Update(ctx, update);
RequireUpdate(eIUS_General);
}
void CLaserBeam::FixAttachment(IEntity* pLaserEntity)
{
m_usingEntityAttachment = false;
IItemSystem* pItemSystem = g_pGame->GetIGameFramework()->GetIItemSystem();
CItem* pOwnerItem = static_cast<CItem*>(pItemSystem->GetItem(m_ownerEntityId));
if (pOwnerItem)
{
IEntity* pOwnerEntity = pOwnerItem->GetEntity();
IEntity* pAttachedEntity = pOwnerEntity;
const char* attach_helper = "laser_term";
Vec3 offset = pOwnerItem->GetSlotHelperPos(m_geometrySlot, attach_helper, false);
if(m_geometrySlot == eIGS_FirstPerson)
{
if(pOwnerItem->IsAccessory())
{
EntityId parentId = pOwnerItem->GetParentId();
if(parentId)
{
if(CItem* pParentItem = static_cast<CItem*>(pItemSystem->GetItem(parentId)))
{
const SAccessoryParams* pParams = pParentItem->GetAccessoryParams(pAttachedEntity->GetClass());
attach_helper = pParams->attach_helper.c_str();
pAttachedEntity = pParentItem->GetEntity();
}
}
}
if(pAttachedEntity)
{
ICharacterInstance *pCharacter = pAttachedEntity->GetCharacter(eIGS_FirstPerson);
if (pCharacter)
{
IAttachmentManager *pAttachmentManager = pCharacter->GetIAttachmentManager();
IAttachment *pLaserAttachment = pAttachmentManager->GetInterfaceByName(LASER_ATTACH_NAME);
if(!pLaserAttachment)
{
IAttachment *pAttachment = pAttachmentManager->GetInterfaceByName(attach_helper);
if(pAttachment)
{
const char* pBone = pCharacter->GetIDefaultSkeleton().GetJointNameByID(pAttachment->GetJointID());
pLaserAttachment = pAttachmentManager->CreateAttachment(LASER_ATTACH_NAME, CA_BONE, pBone);
if(pLaserAttachment)
{
QuatT relative = pAttachment->GetAttRelativeDefault();
if(pOwnerItem->GetEntity() != pAttachedEntity)
{
Matrix34 mtx(relative);
relative.t = relative * offset;
}
pLaserAttachment->SetAttRelativeDefault(relative);
}
}
}
if(pLaserAttachment)
{
CEntityAttachment* pEntAttach = new CEntityAttachment;
pEntAttach->SetEntityId(m_laserEntityId);
pLaserAttachment->AddBinding(pEntAttach);
pLaserAttachment->HideAttachment(0);
m_usingEntityAttachment = true;
}
}
}
}
if(!m_usingEntityAttachment && pOwnerEntity)
{
pOwnerEntity->AttachChild(pLaserEntity);
pLaserEntity->SetLocalTM(Matrix34::CreateTranslationMat(offset));
}
}
}
//------------------------------------------------------------------------
EntityEffects::TAttachedEffectId CItem::AttachEffect(int slot, bool attachToAccessory, const char *effectName, const char *helper, const Vec3 &offset, const Vec3 &dir, float scale, bool prime)
{
if(!g_pGameCVars->i_particleeffects)
{
return 0;
}
Vec3 finalOffset(offset);
string helperName(helper);
if(attachToAccessory)
{
SEntitySlotInfo slotInfo;
QuatT accessoryOffset;
accessoryOffset.SetIdentity();
const char* accessoryHelper = "";
const char* accessoryName = NULL;
const int numAccessories = m_accessories.size();
for (int curIndex = 0; curIndex < numAccessories; curIndex++)
{
IEntity* pAccessory = gEnv->pEntitySystem->GetEntity(m_accessories[curIndex].accessoryId);
if(pAccessory && pAccessory->GetSlotInfo(slot, slotInfo))
{
if(slotInfo.pStatObj)
{
accessoryOffset.t = slotInfo.pStatObj->GetHelperPos(helper);
if(!accessoryOffset.t.IsZero())
{
accessoryOffset.q = pAccessory->GetRotation();
accessoryOffset.t += pAccessory->GetPos();
accessoryName = m_accessories[curIndex].pClass->GetName();
break;
}
}
if(slotInfo.pCharacter)
{
IAttachmentManager *pAttachmentManager = slotInfo.pCharacter->GetIAttachmentManager();
IAttachment *pAttachment = pAttachmentManager->GetInterfaceByName(helper);
if(pAttachment)
{
accessoryHelper = GetAccessoryParams(m_accessories[curIndex].pClass)->attach_helper.c_str();
accessoryName = m_accessories[curIndex].pClass->GetName();
accessoryOffset = pAttachment->GetAttAbsoluteDefault();
break;
}
}
}
}
if(accessoryName)
{
bool validSlot = GetEntity()->GetSlotInfo(slot, slotInfo) && (slotInfo.pCharacter || slotInfo.pStatObj);
if (!validSlot || slotInfo.pStatObj)
{
if (validSlot)
{
Matrix34 mtx = GetEntity()->GetSlotLocalTM(slot, false) * Matrix34(accessoryOffset);
finalOffset += mtx.GetTranslation();
}
EntityEffects::SEffectAttachParams attachParams(finalOffset, dir, scale, prime, eIGS_Last);
return m_effectsController.AttachParticleEffect(effectName, attachParams);
}
else if (slotInfo.pCharacter) // bone attachment
{
ICharacterInstance *pCharacter = slotInfo.pCharacter;
IAttachmentManager *pAttachmentManager = pCharacter->GetIAttachmentManager();
IAttachment *pAttachment = NULL;
helperName = string().Format("%s_%s", helper, accessoryName);
pAttachment = pAttachmentManager->GetInterfaceByName(helperName.c_str());
if(!pAttachment)
{
IAttachment* pAccessoryAttachment = pAttachmentManager->GetInterfaceByName(accessoryHelper);
if(pAccessoryAttachment)
{
const char* bone = pCharacter->GetIDefaultSkeleton().GetJointNameByID(pAccessoryAttachment->GetJointID());
pAttachment = pAttachmentManager->CreateAttachment(helperName.c_str(), CA_BONE, bone);
if (pAttachment)
{
QuatT relative = pAccessoryAttachment->GetAttRelativeDefault();
relative = relative * accessoryOffset;
relative.t = relative * finalOffset;
finalOffset.zero();
pAttachment->SetAttRelativeDefault(relative);
}
}
}
}
}
}
EntityEffects::SEffectAttachParams attachParams(finalOffset, dir, scale, prime, eIGS_Last);
return m_effectsController.AttachParticleEffect(effectName, slot, helperName, attachParams);
}
ILINE bool InitializePoseAlignerDeer(PoseAligner::CPose& pose, IEntity& entity, ICharacterInstance& character)
{
IDefaultSkeleton& rIDefaultSkeleton = character.GetIDefaultSkeleton();
int jointIndexRoot = rIDefaultSkeleton.GetJointIDByName("Def_COG_jnt");
if (jointIndexRoot < 0)
return false;
int jointIndexBackLeft = rIDefaultSkeleton.GetJointIDByName("Def_L_ToeEnd_jnt");
if (jointIndexBackLeft < 0)
return false;
int jointIndexBackRight = rIDefaultSkeleton.GetJointIDByName("Def_R_ToeEnd_jnt");
if (jointIndexBackRight < 0)
return false;
int jointIndexFrontLeft = rIDefaultSkeleton.GetJointIDByName("Def_L_WristEnd_jnt");
if (jointIndexFrontLeft < 0)
return false;
int jointIndexFrontRight = rIDefaultSkeleton.GetJointIDByName("Def_R_WristEnd_jnt");
if (jointIndexFrontRight < 0)
return false;
if (!pose.Initialize(entity, jointIndexRoot))
return false;
pose.SetRootOffsetMinMax(-0.1f, 0.04f);
PoseAligner::SChainDesc chainDesc;
chainDesc.name = "Left";
chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
chainDesc.solver = "LftLeg01";
chainDesc.contactJointIndex = jointIndexBackLeft;
chainDesc.bBlendProcedural = true;
chainDesc.offsetMin = Vec3(0.0f, 0.0f, -0.05f);
chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.4f);
if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
{
pContactRaycast->SetLength(1.0f);
chainDesc.pContactReporter = pContactRaycast;
}
if (!pose.CreateChain(chainDesc))
return false;
chainDesc.name = "Left";
chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
chainDesc.solver = "RgtLeg01";
chainDesc.contactJointIndex = jointIndexBackRight;
chainDesc.bBlendProcedural = true;
chainDesc.offsetMin = Vec3(0.0f, 0.0f, -0.05f);
chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.4f);
if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
{
pContactRaycast->SetLength(1.0f);
chainDesc.pContactReporter = pContactRaycast;
}
if (!pose.CreateChain(chainDesc))
return false;
chainDesc.name = "FrontLeft";
chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
chainDesc.solver = "LftArm01";
chainDesc.contactJointIndex = jointIndexFrontLeft;
chainDesc.bBlendProcedural = true;
chainDesc.offsetMin = Vec3(0.0f, 0.0f, -0.05f);
chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.02f);
if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
{
pContactRaycast->SetLength(1.0f);
chainDesc.pContactReporter = pContactRaycast;
}
if (!pose.CreateChain(chainDesc))
return false;
chainDesc.name = "FrontRight";
chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
chainDesc.solver = "RgtArm01";
chainDesc.contactJointIndex = jointIndexFrontRight;
chainDesc.bBlendProcedural = true;
chainDesc.offsetMin = Vec3(0.0f, 0.0f, -0.05f);
chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.02f);
if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
{
pContactRaycast->SetLength(1.0f);
chainDesc.pContactReporter = pContactRaycast;
}
if (!pose.CreateChain(chainDesc))
return false;
return pose.GetChainCount() != 0;
}
ILINE bool InitializePoseAlignerScorcher(PoseAligner::CPose& pose, IEntity& entity, ICharacterInstance& character)
{
IDefaultSkeleton& rIDefaultSkeleton = character.GetIDefaultSkeleton();
int jointIndexRoot = rIDefaultSkeleton.GetJointIDByName("hips_joint");
if (jointIndexRoot < 0)
return false;
int jointIndexBackLeft = rIDefaultSkeleton.GetJointIDByName("l_bwd_leg_end_joint");
if (jointIndexBackLeft < 0)
return false;
int jointIndexBackLeftBlend = rIDefaultSkeleton.GetJointIDByName("planeLockWeightBackLeft");
if (jointIndexBackLeftBlend < 0)
return false;
int jointIndexBackRight = rIDefaultSkeleton.GetJointIDByName("r_bwd_leg_end_joint");
if (jointIndexBackRight < 0)
return false;
int jointIndexBackRightBlend = rIDefaultSkeleton.GetJointIDByName("planeLockWeightBackRight");
if (jointIndexBackRightBlend < 0)
return false;
int jointIndexFrontLeft = rIDefaultSkeleton.GetJointIDByName("l_fwd_leg_end_joint");
if (jointIndexFrontLeft < 0)
return false;
int jointIndexFrontLeftBlend = rIDefaultSkeleton.GetJointIDByName("planeLockWeightFrontLeft");
if (jointIndexFrontLeftBlend < 0)
return false;
int jointIndexFrontRight = rIDefaultSkeleton.GetJointIDByName("r_fwd_leg_end_joint");
if (jointIndexFrontRight < 0)
return false;
int jointIndexFrontRightBlend = rIDefaultSkeleton.GetJointIDByName("planeLockWeightFrontRight");
if (jointIndexFrontRightBlend < 0)
return false;
if (!pose.Initialize(entity, jointIndexRoot))
return false;
pose.SetRootOffsetMinMax(-1.0f, 1.0f);
PoseAligner::SChainDesc chainDesc;
chainDesc.name = "Left";
chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
chainDesc.solver = "LftLeg01";
chainDesc.contactJointIndex = jointIndexBackLeft;
chainDesc.targetBlendJointIndex = jointIndexBackLeftBlend;
chainDesc.offsetMin = Vec3(0.0f, 0.0f, -1.0f);
chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.15f);
chainDesc.bTargetSmoothing = true;
if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
{
pContactRaycast->SetLength(1.0f);
chainDesc.pContactReporter = pContactRaycast;
}
if (!pose.CreateChain(chainDesc))
return false;
chainDesc.name = "Left";
chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
chainDesc.solver = "RgtLeg01";
chainDesc.contactJointIndex = jointIndexBackRight;
chainDesc.targetBlendJointIndex = jointIndexBackRightBlend;
chainDesc.offsetMin = Vec3(0.0f, 0.0f, -1.0f);
chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.15f);
chainDesc.bTargetSmoothing = true;
if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
{
pContactRaycast->SetLength(1.0f);
chainDesc.pContactReporter = pContactRaycast;
}
if (!pose.CreateChain(chainDesc))
return false;
chainDesc.name = "FrontLeft";
chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
chainDesc.solver = "LftArm01";
chainDesc.contactJointIndex = jointIndexFrontLeft;
chainDesc.targetBlendJointIndex = jointIndexFrontLeftBlend;
chainDesc.offsetMin = Vec3(0.0f, 0.0f, -1.0f);
chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.15f);
chainDesc.bTargetSmoothing = true;
if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
{
pContactRaycast->SetLength(1.0f);
chainDesc.pContactReporter = pContactRaycast;
}
if (!pose.CreateChain(chainDesc))
return false;
chainDesc.name = "FrontRight";
chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
chainDesc.solver = "RgtArm01";
chainDesc.contactJointIndex = jointIndexFrontRight;
chainDesc.targetBlendJointIndex = jointIndexFrontRightBlend;
chainDesc.offsetMin = Vec3(0.0f, 0.0f, -1.0f);
chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.15f);
chainDesc.bTargetSmoothing = true;
if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
{
pContactRaycast->SetLength(1.0f);
chainDesc.pContactReporter = pContactRaycast;
}
if (!pose.CreateChain(chainDesc))
return false;
return pose.GetChainCount() != 0;
}
ILINE bool InitializePoseAlignerPinger(PoseAligner::CPose& pose, IEntity& entity, ICharacterInstance& character)
{
IDefaultSkeleton& rIDefaultSkeleton = character.GetIDefaultSkeleton();
const bool bIsMP = gEnv->bMultiplayer;
IVehicle* pVehicle = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem()->GetVehicle(entity.GetId());
if (bIsMP && !pVehicle)
return false;
#define CREATEPINGERCONTACTREPORTER \
if(bIsMP) \
{ \
if (_smart_ptr<CContactRaycastPinger> pContactRaycast = new CContactRaycastPinger(*pVehicle,3.f)) \
{ \
chainDesc.pContactReporter = pContactRaycast; \
} \
} \
else \
{ \
if (_smart_ptr<PoseAligner::CContactRaycast> pContactRaycast = new PoseAligner::CContactRaycast(entity)) \
{ \
pContactRaycast->SetLength(4.f); \
chainDesc.pContactReporter = pContactRaycast; \
} \
}
int jointIndexRoot = rIDefaultSkeleton.GetJointIDByName("Pelvis");
if (jointIndexRoot < 0)
return false;
int jointIndexFrontLeft = rIDefaultSkeleton.GetJointIDByName("planeAlignerLeft");
if (jointIndexFrontLeft < 0)
return false;
int jointIndexFrontLeftBlend = rIDefaultSkeleton.GetJointIDByName("planeLockWeightLeft");
if (jointIndexFrontLeftBlend < 0)
return false;
int jointIndexFrontRight = rIDefaultSkeleton.GetJointIDByName("planeAlignerRight");
if (jointIndexFrontRight < 0)
return false;
int jointIndexFrontRightBlend = rIDefaultSkeleton.GetJointIDByName("planeLockWeightRight");
if (jointIndexFrontRightBlend < 0)
return false;
int jointIndexFrontCenter = rIDefaultSkeleton.GetJointIDByName("planeAlignerCenter");
if (jointIndexFrontCenter < 0)
return false;
int jointIndexFrontCenterBlend = rIDefaultSkeleton.GetJointIDByName("planeLockWeightCenter");
if (jointIndexFrontCenterBlend < 0)
return false;
if (!pose.Initialize(entity, jointIndexRoot))
return false;
PoseAligner::SChainDesc chainDesc;
chainDesc.name = "Left";
chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
chainDesc.solver = "LftLeg01";
chainDesc.contactJointIndex = jointIndexFrontLeft;
chainDesc.targetBlendJointIndex = jointIndexFrontLeftBlend;
chainDesc.offsetMin = Vec3(0.0f, 0.0f, bIsMP?-1.8f:-1.8f);
chainDesc.offsetMax = Vec3(0.0f, 0.0f, bIsMP?+0.75f:+1.f);
chainDesc.bForceNoIntersection = true;
float rootMax = -chainDesc.offsetMin.z;
float rootMin = -chainDesc.offsetMax.z;
CREATEPINGERCONTACTREPORTER;
if (!pose.CreateChain(chainDesc))
return false;
chainDesc.name = "Right";
chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
chainDesc.solver = "RgtLeg01";
chainDesc.contactJointIndex = jointIndexFrontRight;
chainDesc.targetBlendJointIndex = jointIndexFrontRightBlend;
chainDesc.offsetMin = Vec3(0.0f, 0.0f, bIsMP?-1.8f:-1.8f);
chainDesc.offsetMax = Vec3(0.0f, 0.0f, bIsMP?+0.75f:+1.f);
chainDesc.bForceNoIntersection = true;
rootMax = min(rootMax,-chainDesc.offsetMin.z);
rootMin = max(rootMin,-chainDesc.offsetMax.z);
CREATEPINGERCONTACTREPORTER;
if (!pose.CreateChain(chainDesc))
return false;
chainDesc.name = "Center";
chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
chainDesc.solver = "CtrLeg01";
chainDesc.contactJointIndex = jointIndexFrontCenter;
chainDesc.targetBlendJointIndex = jointIndexFrontCenterBlend;
chainDesc.offsetMin = Vec3(0.0f, 0.0f, bIsMP?-2.f:-2.f);
chainDesc.offsetMax = Vec3(0.0f, 0.0f, bIsMP?+1.3f:+1.6f);
chainDesc.bForceNoIntersection = true;
rootMax = min(rootMax,-chainDesc.offsetMin.z);
rootMin = max(rootMin,-chainDesc.offsetMax.z);
CREATEPINGERCONTACTREPORTER;
pose.SetRootOffsetMinMax(rootMin, rootMax);
pose.SetRootOffsetAverage(!bIsMP);
if (!pose.CreateChain(chainDesc))
return false;
return pose.GetChainCount() != 0;
}
const Vec3& CTacticalManager::GetTacticalIconWorldPos(const EntityId tacticalEntityId, IEntity* pTacticalEntity, bool& inOutIsHeadBone)
{
CRY_ASSERT(tacticalEntityId != 0);
CRY_ASSERT(pTacticalEntity != NULL);
if (pTacticalEntity == NULL)
{
return m_tempVec3.Set(0.0f,0.0f,0.0f);
}
// Try to get pos from headbone if don't have an override pos
TTacticalEntityToOverrideEntities::const_iterator iter = m_tacEntityToOverrideEntities.find(tacticalEntityId);
if (iter == m_tacEntityToOverrideEntities.end())
{
static IEntityClass* s_pTurretEntityClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass("Turret");
IEntityClass* pEntityClass = pTacticalEntity->GetClass();
if (pEntityClass != NULL && pEntityClass == s_pTurretEntityClass)
{
ICharacterInstance* pCharacterInstance = pTacticalEntity->GetCharacter(0);
if (pCharacterInstance != NULL)
{
IDefaultSkeleton& rIDefaultSkeleton = pCharacterInstance->GetIDefaultSkeleton();
ISkeletonPose* pSkeletonPose = pCharacterInstance->GetISkeletonPose();
CRY_ASSERT(pSkeletonPose != NULL);
const int16 jointId = rIDefaultSkeleton.GetJointIDByName("arcjoint");
if (0 <= jointId)
{
QuatT boneLocation = pSkeletonPose->GetAbsJointByID(jointId);
m_tempVec3 = pTacticalEntity->GetWorldTM().TransformPoint(boneLocation.t);
return m_tempVec3;
}
}
}
CUICVars* pCVars = g_pGame->GetUI()->GetCVars();
if (pCVars->hud_InterestPointsAtActorsHeads == 1)
{
CActor* pActor = static_cast<CActor*>(g_pGame->GetIGameFramework()->GetIActorSystem()->GetActor(tacticalEntityId)); // Only want units to go from headbone, since vehicles have headbone as well
if(pActor)
{
if(pActor->HasBoneID(BONE_HEAD))
{
QuatT boneLocation = pActor->GetBoneTransform(BONE_HEAD);
m_tempVec3 = pTacticalEntity->GetWorldTM().TransformPoint(boneLocation.t) + Vec3(0.0f, 0.0f, 0.25f);
inOutIsHeadBone = true;
return m_tempVec3;
}
else if(pActor->HasBoneID(BONE_SPINE))
{
QuatT boneLocation = pActor->GetBoneTransform(BONE_SPINE);
m_tempVec3 = pTacticalEntity->GetWorldTM().TransformPoint(boneLocation.t);
return m_tempVec3;
}
}
}
return GetTacticalIconCenterBBoxWorldPos(pTacticalEntity);
}
else // Override entity exists so it determines position
{
IEntity* pOverrideEntity = gEnv->pEntitySystem->GetEntity(iter->second);
if (pOverrideEntity)
{
m_tempVec3 = pOverrideEntity->GetWorldPos();
return m_tempVec3;
}
else
{
GameWarning("CTacticalManager::GetTacticalIconWorldPos: ID exists in mapping but failed to find entity, defaulting to center bounding box position");
return GetTacticalIconCenterBBoxWorldPos(pTacticalEntity);
}
}
}
bool CVehiclePartSuspensionPart::Init(IVehicle *pVehicle, const CVehicleParams &table, IVehiclePart *pParent, CVehicle::SPartInitInfo &initInfo, int partType)
{
if (!inherited::Init(pVehicle, table, pParent, initInfo, partType))
return false;
m_animatedRoot = CAST_VEHICLEOBJECT(CVehiclePartAnimated, GetParent(true));
m_jointId = -1;
m_ikFlags = 0;
if (m_animatedRoot)
{
if(CVehicleParams subPartTable = table.findChild("SubPart"))
{
// We need to remove this part from the animated root, otherwise we have two parts
// NB: for now we are not doing anything with the physics - infact its preferable
// if we dont have physics on suspension arms!
const char* geoName = subPartTable.getAttr("geometryname");
ICharacterInstance* pCharInstance = m_animatedRoot->GetEntity()->GetCharacter(m_animatedRoot->GetSlot());
if (pCharInstance)
{
IDefaultSkeleton& rIDefaultSkeleton = pCharInstance->GetIDefaultSkeleton();
ISkeletonPose* pSkeletonPose = pCharInstance->GetISkeletonPose();
m_jointId = rIDefaultSkeleton.GetJointIDByName(geoName);
pSkeletonPose->SetStatObjOnJoint(m_jointId, NULL);
}
}
}
else
{
CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "CVehiclePartSuspensionPart: needs to have an AnimatedPart as a parent!");
return false;
}
CVehicleParams ikTable = table.findChild("IK");
if (!ikTable)
return false;
const char* targetPartName = ikTable.getAttr("target");
m_targetPart = static_cast<CVehiclePartBase*>(pVehicle->GetPart(targetPartName));
if (m_targetPart==NULL)
{
CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "CVehiclePartSuspensionPart: couldn't find target part: '%s'", targetPartName);
return false;
}
// Set up the target
m_targetOffset.zero();
const char* targetHelper = ikTable.getAttr("targetHelper");
if (targetHelper && targetHelper[0])
{
if (IVehicleHelper* pHelper = m_pVehicle->GetHelper(targetHelper))
{
// NB: this is in vehicle space, and needs translating in PostInit()
m_targetOffset = pHelper->GetLocalTM().GetTranslation();
m_ikFlags |= k_flagTargetHelper;
}
}
Vec3 offset(0);
ikTable.getAttr("offset", offset);
m_targetOffset += offset;
m_mode = k_modeStretch;
const char* mode = ikTable.getAttr("mode");
if (strcmp(mode,"rotate")==0)
m_mode = k_modeRotate;
if (strcmp(mode,"stretch")==0)
m_mode = k_modeStretch;
if (strcmp(mode,"snap")==0)
m_mode = k_modeSnapToEF;
bool bIgnoreTargetRotation=0;
ikTable.getAttr("ignoreTargetRotation", bIgnoreTargetRotation);
if (bIgnoreTargetRotation)
m_ikFlags |= k_flagIgnoreTargetRotation;
return true;
}
