void CEffectsController::DetachEffect(const TAttachedEffectId effectId)
{
CRY_ASSERT(m_pOwnerEntity);
TAttachedEffects::iterator effectIt = std::find(m_attachedEffects.begin(), m_attachedEffects.end(), effectId);
if (effectIt != m_attachedEffects.end())
{
const SEffectInfo& effectInfo = *effectIt;
if (effectInfo.entityEffectSlot >= 0)
{
m_pOwnerEntity->FreeSlot(effectInfo.entityEffectSlot);
}
else
{
ICharacterInstance *pCharacter = m_pOwnerEntity->GetCharacter(effectInfo.characterEffectSlot);
if (pCharacter)
{
IAttachmentManager *pAttachmentManager = pCharacter->GetIAttachmentManager();
IAttachment *pAttachment = pAttachmentManager->GetInterfaceByName(effectInfo.helperName.c_str());
if(pAttachment)
{
pAttachment->ClearBinding();
}
}
}
m_attachedEffects.erase(effectIt);
}
}
void CAICorpse::AboutToBeRemoved()
{
IItemSystem* pItemSystem = g_pGame->GetIGameFramework()->GetIItemSystem();
ICharacterInstance* pCharacter = GetEntity()->GetCharacter(0);
IAttachmentManager* pAttachmentManager = (pCharacter != NULL) ? pCharacter->GetIAttachmentManager() : NULL;
for (uint32 i = 0; i < (uint32)m_attachedItemsInfo.size(); ++i)
{
AttachedItem& attachedItem = m_attachedItemsInfo[i];
IItem* pItem = pItemSystem->GetItem( attachedItem.id );
if((pItem != NULL) && ShouldDropOnCorpseRemoval( pItem->GetEntity()->GetClass() ))
{
IAttachment* pAttachment = (pAttachmentManager != NULL) ? pAttachmentManager->GetInterfaceByName( attachedItem.attachmentName.c_str() ) : NULL;
if(pAttachment != NULL)
{
pAttachment->ClearBinding();
}
pItem->Drop( 1.0f, false, true );
pItem->GetEntity()->SetFlags( pItem->GetEntity()->GetFlags() & ~ENTITY_FLAG_NO_SAVE );
attachedItem.id = 0;
}
}
}
//------------------------------------------------------------------------
IParticleEmitter *CItem::GetEffectEmitter(uint32 id) const
{
TEffectInfoMap::const_iterator it = m_effects.find(id);
if (it == m_effects.end())
return 0;
const SEffectInfo &info = it->second;
SEntitySlotInfo slotInfo;
if (GetEntity()->GetSlotInfo(info.slot, slotInfo) && slotInfo.pParticleEmitter)
return slotInfo.pParticleEmitter;
if (GetEntity()->GetSlotInfo(info.characterSlot, slotInfo) && slotInfo.pCharacter)
{
ICharacterInstance *pCharacter = slotInfo.pCharacter;
IAttachmentManager *pAttachmentManager = pCharacter->GetIAttachmentManager();
IAttachment *pAttachment = pAttachmentManager->GetInterfaceByName(info.helper.c_str());
if (pAttachment)
{
CEffectAttachment *pEffectAttachment = static_cast<CEffectAttachment *>(pAttachment->GetIAttachmentObject());
if (!pEffectAttachment)
{
// commenting out for silencer functionality
//GameWarning("CItem::GetEffectEmitter: no effect attachment on %s (helper %s)", GetEntity()->GetName(), info.helper.c_str());
return 0;
}
return pEffectAttachment->GetEmitter();
}
}
return 0;
}
//------------------------------------------------------------------------
void CItem::SetCharacterAttachment(int slot, const char *name, ICharacterInstance *pAttachedCharacter, int flags)
{
ICharacterInstance *pCharacter = GetEntity()->GetCharacter(slot);
if(!pCharacter)
return;
IAttachmentManager *pAttachmentManager = pCharacter->GetIAttachmentManager();
IAttachment *pAttachment = pAttachmentManager->GetInterfaceByName(name);
if(!pAttachment)
{
GameWarning("Item '%s' trying to attach character on '%s' which does not exist!", GetEntity()->GetName(), name);
return;
}
CCHRAttachment *pCharacterAttachment = new CCHRAttachment();
pCharacterAttachment->m_pCharInstance = pAttachedCharacter;
// sub skin ?
if(pAttachment->GetType() == CA_SKIN)
{
pAttachment->AddBinding(pCharacterAttachment);
}
else
{
pAttachment->AddBinding(pCharacterAttachment);
}
}
//------------------------------------------------------------------------
bool CItem::CreateCharacterAttachment(int slot, const char *name, int type, const char *bone)
{
ICharacterInstance *pCharacter = GetEntity()->GetCharacter(slot);
if(!pCharacter)
return false;
IAttachmentManager *pAttachmentManager = pCharacter->GetIAttachmentManager();
IAttachment *pAttachment = pAttachmentManager->GetInterfaceByName(name);
if(pAttachment)
{
// GameWarning("Item '%s' trying to create attachment '%s' which already exists!", GetEntity()->GetName(), name);
return false;
}
pAttachment = pAttachmentManager->CreateAttachment(name, type, bone);
if(!pAttachment)
{
if(type == CA_BONE)
GameWarning("Item '%s' failed to create attachment '%s' on bone '%s'!", GetEntity()->GetName(), name, bone);
return false;
}
return true;
}
bool CStickyProjectile::AttachToCharacter(CProjectile* pProjectile, IEntity& pEntity, ICharacterInstance& pCharacter, const char* boneName)
{
IEntity* pProjectileEntity = pProjectile->GetEntity();
char attachName[16] = "";
sprintf(attachName, "StickyProj_%d", s_attachNameID++);
IAttachment* pCharacterAttachment = pCharacter.GetIAttachmentManager()->CreateAttachment(attachName, CA_BONE, boneName, false);
if(!pCharacterAttachment)
{
CryLogAlways("Could not create attachment for StickyProjectile[%s]. AttachmentName[%s] BoneName[%s]", pProjectileEntity->GetName(), attachName, boneName );
CRY_ASSERT_MESSAGE(pCharacterAttachment, "Could not create attachment for StickyProjectile. This must be fixed.");
return false;
}
m_characterAttachmentCrC = pCharacterAttachment->GetNameCRC();
SetProjectilePhysics(pProjectile, ePT_None);
pCharacterAttachment->SetAttRelativeDefault(QuatT(m_stuckRot, m_stuckPos));
CEntityAttachment *pEntityAttachment = new CEntityAttachment();
pEntityAttachment->SetEntityId(pProjectileEntity->GetId());
pCharacterAttachment->AddBinding(pEntityAttachment);
return true;
}
int CScriptBind_Actor::GetClosestAttachment(IFunctionHandler *pH, int characterSlot, Vec3 testPos, float maxDistance, const char* suffix)
{
CActor *pActor = GetActor(pH);
if (!pActor)
return pH->EndFunction();
IEntity* pEntity = pActor->GetEntity();
ICharacterInstance* pChar = pEntity->GetCharacter(characterSlot);
if (!pChar)
return pH->EndFunction();
//fallback: use nearest attachment
float minDiff = maxDistance*maxDistance;
IAttachment* pClosestAtt = 0;
IAttachmentManager* pMan = pChar->GetIAttachmentManager();
int count = pMan->GetAttachmentCount();
for (int i=0; i<count; ++i)
{
IAttachment* pAtt = pMan->GetInterfaceByIndex(i);
if (pAtt->IsAttachmentHidden() || !pAtt->GetIAttachmentObject())
continue;
AABB bbox(AABB::CreateTransformedAABB(Matrix34(pAtt->GetAttWorldAbsolute()),pAtt->GetIAttachmentObject()->GetAABB()));
//gEnv->pRenderer->GetIRenderAuxGeom()->DrawAABB(bbox,false,ColorB(255,0,0,100),eBBD_Faceted);
//float diff = (testPos - pAtt->GetWMatrix().GetTranslation()).len2();
float diff((testPos - bbox.GetCenter()).len2());
if (diff < minDiff)
{
//CryLogAlways("%s distance: %.1f", pAtt->GetName(), sqrt(diff));
if (suffix[0] && !strstr(pAtt->GetName(), suffix))
continue;
minDiff = diff;
pClosestAtt = pAtt;
}
}
if (!pClosestAtt)
return pH->EndFunction();
//FIXME FIXME: E3 workaround
char attachmentName[64];
strncpy(attachmentName,pClosestAtt->GetName(),63);
attachmentName[63] = 0;
char *pDotChar = strstr(attachmentName,".");
if (pDotChar)
*pDotChar = 0;
strlwr(attachmentName);
//
return pH->EndFunction(attachmentName);
}
//------------------------------------------------------------------------
void CItem::DestroyCharacterAttachment(int slot, const char *name)
{
ICharacterInstance *pCharacter = GetEntity()->GetCharacter(slot);
if (!pCharacter)
return;
IAttachmentManager *pAttachmentManager = pCharacter->GetIAttachmentManager();
pAttachmentManager->RemoveAttachmentByName(name);
}
//------------------------------------------------------------------------
const Matrix33 &CItem::GetSlotHelperRotation(int slot, const char *helper, bool worldSpace, bool relative)
{
static Matrix33 rotation;
rotation.SetIdentity();
IEntity* pEntity = GetEntity();
if(!pEntity)
return rotation;
SEntitySlotInfo info;
if (pEntity->GetSlotInfo(slot, info))
{
if (info.pStatObj)
{
IStatObj *pStatObj = info.pStatObj;
rotation = Matrix33(pStatObj->GetHelperTM(helper));
rotation.OrthonormalizeFast();
rotation = Matrix33(GetEntity()->GetSlotLocalTM(slot, false))*rotation;
}
else if (info.pCharacter)
{
ICharacterInstance *pCharacter = info.pCharacter;
if(!pCharacter)
return rotation;
IAttachment* pAttachment = pCharacter->GetIAttachmentManager()->GetInterfaceByName(helper);
if(pAttachment)
{
rotation = Matrix33(worldSpace ? pAttachment->GetAttWorldAbsolute().q : pAttachment->GetAttModelRelative().q);
return rotation;
}
else
{
ICharacterModelSkeleton* pICharacterModelSkeleton = pCharacter->GetICharacterModel()->GetICharacterModelSkeleton();
ISkeletonPose* pSkeletonPose = pCharacter->GetISkeletonPose();
int16 id = pICharacterModelSkeleton->GetJointIDByName(helper);
if (id > -1)
{
rotation = relative ? Matrix33(pSkeletonPose->GetRelJointByID(id).q) : Matrix33(pSkeletonPose->GetAbsJointByID(id).q);
}
}
if (!relative)
{
rotation = Matrix33(pEntity->GetSlotLocalTM(slot, false)) * rotation;
}
}
}
if (worldSpace)
{
rotation = Matrix33(pEntity->GetWorldTM()) * rotation;
}
return rotation;
}
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;
}
IAttachment* CKVoltEffect::GetScreenAttachment()
{
IEntity* pEntity = m_ownerActor ? m_ownerActor->GetEntity() : NULL;
ICharacterInstance* pCharacter = pEntity ? pEntity->GetCharacter(0) : NULL;
IAttachmentManager* pAttachmentMan = pCharacter ? pCharacter->GetIAttachmentManager() : NULL;
if(pAttachmentMan)
{
return pAttachmentMan->GetInterfaceByName("#camera");
}
return NULL;
}
void CLocalPlayerComponent::UpdateFPBodyPartsVisibility()
{
if (m_rPlayer.m_stats.isThirdPerson == false)
{
ICharacterInstance *pMainCharacter = m_rPlayer.GetEntity()->GetCharacter(0);
IAttachmentManager *pAttachmentManager = pMainCharacter ? pMainCharacter->GetIAttachmentManager() : NULL;
if (pAttachmentManager)
{
CRY_ASSERT(m_rPlayer.HasBoneID(BONE_CALF_L));
CRY_ASSERT(m_rPlayer.HasBoneID(BONE_CALF_R));
const CCamera& camera = gEnv->p3DEngine->GetRenderingCamera();
const Matrix34& playerWorldTM = m_rPlayer.GetEntity()->GetWorldTM();
bool visible = true;
if (m_rPlayer.m_linkStats.linkID == 0)
{
//volatile static float radius = 0.475f;
const float radius = 0.16f;
const Sphere calfSphereL(playerWorldTM.TransformPoint(m_rPlayer.GetBoneTransform(BONE_CALF_L).t), radius);
const Sphere calfSpehreR(playerWorldTM.TransformPoint(m_rPlayer.GetBoneTransform(BONE_CALF_R).t), radius);
visible = camera.IsSphereVisible_F(calfSphereL) || camera.IsSphereVisible_F(calfSpehreR);
}
//const float white[4] = {1.0f, 1.0f, 1.0f, 1.0f};
//gEnv->pRenderer->Draw2dLabel(50.0f, 50.0f, 2.0f, white, false, visible ? "Rendering complete FP body" : "Rendering only arms");
//Early out if no change
if (m_fpCompleteBodyVisible == visible)
return;
//Hide/Unhide certain parts depending on visibility
const int kNumParstToToggle = 2;
const char *tooglePartsTable[kNumParstToToggle] = {"lower_body", "upper_body"};
for (int i=0; i<kNumParstToToggle; i++)
{
IAttachment* pAttachment = pAttachmentManager->GetInterfaceByName(tooglePartsTable[i]);
if (pAttachment)
{
pAttachment->HideAttachment(!visible);
pAttachment->HideInShadow(1);
}
}
m_fpCompleteBodyVisible = visible;
}
}
}
IAttachment* GetAttachment(SActivationInfo* pActInfo)
{
IAttachment *pAttachment = NULL;
if (pActInfo->pEntity)
{
int slot = GetPortInt(pActInfo, eIP_CharacterSlot);
ICharacterInstance *pCharacter = pActInfo->pEntity->GetCharacter(slot);
if (pCharacter)
{
const string &boneName = GetPortString(pActInfo, eIP_BoneName);
IAttachmentManager *pAttachmentManager = pCharacter->GetIAttachmentManager();
pAttachment = pAttachmentManager->GetInterfaceByName(boneName);
}
}
return pAttachment;
}
//------------------------------------------------------------------------
Vec3 CItem::GetSlotHelperPos(int slot, const char *helper, bool worldSpace, bool relative) const
{
Vec3 position(0,0,0);
SEntitySlotInfo info;
if (GetEntity()->GetSlotInfo(slot, info))
{
if (info.pStatObj)
{
IStatObj *pStatsObj = info.pStatObj;
position = pStatsObj->GetHelperPos(helper);
position = GetEntity()->GetSlotLocalTM(slot, false).TransformPoint(position);
}
else if (info.pCharacter)
{
ICharacterInstance *pCharacter = info.pCharacter;
IAttachment* pAttachment = pCharacter->GetIAttachmentManager()->GetInterfaceByName(helper);
if (pAttachment)
{
position = worldSpace ? pAttachment->GetAttWorldAbsolute().t : pAttachment->GetAttModelRelative().t;
return position;
}
else
{
ICharacterModelSkeleton* pICharacterModelSkeleton = pCharacter->GetICharacterModel()->GetICharacterModelSkeleton();
ISkeletonPose* pSkeletonPose = pCharacter->GetISkeletonPose();
int16 id = pICharacterModelSkeleton->GetJointIDByName(helper);
if (id > -1)
{
position = relative ? pSkeletonPose->GetRelJointByID(id).t : pSkeletonPose->GetAbsJointByID(id).t;
}
}
if (!relative)
{
position = GetEntity()->GetSlotLocalTM(slot, false).TransformPoint(position);
}
}
}
if (worldSpace)
{
position = GetWorldTM().TransformPoint(position);
}
return position;
}
//------------------------------------------------------------------------
const char *CItem::GetCharacterAttachmentBone(int slot, const char *name)
{
ICharacterInstance *pCharacter = GetEntity()->GetCharacter(slot);
if (!pCharacter)
return 0;
IAttachmentManager *pAttachmentManager = pCharacter->GetIAttachmentManager();
IAttachment *pAttachment = pAttachmentManager->GetInterfaceByName(name);
if (!pAttachment)
{
GameWarning("Item '%s' trying to get attachment bone on '%s' which does not exist!", GetEntity()->GetName(), name);
return 0;
}
return pCharacter->GetISkeletonPose()->GetJointNameByID(pAttachment->GetBoneID());
}
//------------------------------------------------------------------------
Matrix34 CItem::GetCharacterAttachmentWorldTM(int slot, const char *name)
{
ICharacterInstance *pCharacter = GetEntity()->GetCharacter(slot);
if (!pCharacter)
return Matrix34::CreateIdentity();
IAttachmentManager *pAttachmentManager = pCharacter->GetIAttachmentManager();
IAttachment *pAttachment = pAttachmentManager->GetInterfaceByName(name);
if (!pAttachment)
{
GameWarning("Item '%s' trying to get local TM on attachment '%s' which does not exist!", GetEntity()->GetName(), name);
return Matrix34::CreateIdentity();
}
return Matrix34(pAttachment->GetAttWorldAbsolute());
}
//------------------------------------------------------------------------
int CScriptBind_Actor::AttachVulnerabilityEffect(IFunctionHandler *pH, int characterSlot, int partid, Vec3 hitPos, float radius, const char* effect, const char* attachmentIdentifier)
{
CActor *pActor = GetActor(pH);
if (!pActor)
return pH->EndFunction();
IEntity* pEntity = pActor->GetEntity();
ICharacterInstance* pChar = pEntity->GetCharacter(characterSlot);
if (!pChar || !effect)
return pH->EndFunction();
//fallback: use nearest attachment
float minDiff = radius*radius;
IAttachment* pClosestAtt = 0;
IAttachmentManager* pMan = pChar->GetIAttachmentManager();
for (int i=0; i<pMan->GetAttachmentCount(); ++i)
{
IAttachment* pAtt = pMan->GetInterfaceByIndex(i);
float diff = (hitPos - pAtt->GetAttWorldAbsolute().t).len2();
if (diff < minDiff)
{
// only use specified attachments
if (attachmentIdentifier[0] && !strstr(pAtt->GetName(), attachmentIdentifier))
continue;
minDiff = diff;
pClosestAtt = pAtt;
}
//CryLog("diff: %.2f, att: %s", diff, attName.c_str());
}
if (!pClosestAtt)
return pH->EndFunction();
//CryLog("AttachVulnerabilityEffect: closest att %s, attaching effect %s", pClosestAtt->GetName(), effect);
CEffectAttachment *pEffectAttachment = new CEffectAttachment(effect, Vec3(ZERO), Vec3(0,1,0), 1.f);
pClosestAtt->AddBinding(pEffectAttachment);
pClosestAtt->HideAttachment(0);
return pH->EndFunction(pClosestAtt->GetName());
}
//------------------------------------------------------------------------
void CItem::ResetCharacterAttachment(int slot, const char *name)
{
ICharacterInstance *pCharacter = GetEntity()->GetCharacter(slot);
if (!pCharacter)
return;
IAttachmentManager *pAttachmentManager = pCharacter->GetIAttachmentManager();
IAttachment *pAttachment = pAttachmentManager->GetInterfaceByName(name);
if (!pAttachment)
{
GameWarning("Item '%s' trying to reset attachment '%s' which does not exist!", GetEntity()->GetName(), name);
return;
}
pAttachment->ClearBinding();
}
//------------------------------------------------------------------------
void CItem::SetCharacterAttachmentLocalTM(int slot, const char *name, const Matrix34 &tm)
{
ICharacterInstance *pCharacter = GetEntity()->GetCharacter(slot);
if (!pCharacter)
return;
IAttachmentManager *pAttachmentManager = pCharacter->GetIAttachmentManager();
IAttachment *pAttachment = pAttachmentManager->GetInterfaceByName(name);
if (!pAttachment)
{
GameWarning("Item '%s' trying to set local TM on attachment '%s' which does not exist!", GetEntity()->GetName(), name);
return;
}
pAttachment->SetAttRelativeDefault( QuatT(tm));
}
void CVar::EnableDebugAnimText(IConsoleCmdArgs *args)
{
if (args && args->GetArgCount() > 1)
{
const char* szFilterName = args->GetArg(1);
bool enable = true;
if (args->GetArgCount() > 2)
{
enable = (strcmp(args->GetArg(2), "0") != 0);
}
CEntitySystem* pEntitySystem = GetIEntitySystem();
IEntity *entity = pEntitySystem->FindEntityByName(szFilterName);
if (entity)
{
uint32 numSlots = entity->GetSlotCount();
for (uint32 i=0; i<numSlots; i++)
{
ICharacterInstance *charInst = entity->GetCharacter(i);
if (charInst)
{
charInst->GetISkeletonAnim()->SetDebugging(enable);
IAttachmentManager* pAttachmentManager = charInst->GetIAttachmentManager();
for(int32 attachmentIndex=0; attachmentIndex<pAttachmentManager->GetAttachmentCount(); ++attachmentIndex)
{
IAttachment* pAttachment = pAttachmentManager->GetInterfaceByIndex(attachmentIndex);
assert(pAttachment);
IAttachmentObject* pObject = pAttachment->GetIAttachmentObject();
if (pObject)
{
ICharacterInstance* pObjectCharInst = pObject->GetICharacterInstance();
if (pObjectCharInst)
{
pObjectCharInst->GetISkeletonAnim()->SetDebugging(enable);
}
}
}
}
}
}
}
}
void CAICorpse::PostSerialize()
{
#if AI_CORPSES_ENABLE_SERIALIZE
ICharacterInstance* pCharacterInstance = GetEntity()->GetCharacter(0);
if(pCharacterInstance != NULL)
{
IAttachmentManager* pAttachmentManager = pCharacterInstance->GetIAttachmentManager();
for(uint32 i = 0; i < m_attachedItemsInfo.size(); ++i)
{
AttachedItem& weaponInfo = m_attachedItemsInfo[i];
IAttachment* pAttachment = pAttachmentManager->GetInterfaceByName( weaponInfo.attachmentName.c_str() );
if(pAttachment != NULL)
{
weaponInfo.id = CloneAttachedItem( weaponInfo, pAttachment );
}
}
}
#endif //AI_CORPSES_ENABLE_SERIALIZE
}
//------------------------------------------------------------------------
void CItem::SetCharacterAttachment(int slot, const char *name, IStatObj *pObj, int flags)
{
ICharacterInstance *pCharacter = GetEntity()->GetCharacter(slot);
if (!pCharacter)
return;
IAttachmentManager *pAttachmentManager = pCharacter->GetIAttachmentManager();
IAttachment *pAttachment = pAttachmentManager->GetInterfaceByName(name);
if (!pAttachment)
{
GameWarning("Item '%s' trying to attach static object on '%s' which does not exist!", GetEntity()->GetName(), name);
return;
}
CCGFAttachment *pStatAttachment = new CCGFAttachment();
pStatAttachment->pObj = pObj;
pAttachment->AddBinding(pStatAttachment);
}
//------------------------------------------------------------------------
void CItem::SetCharacterAttachment(int slot, const char *name, IEntity *pEntity, int flags)
{
ICharacterInstance *pCharacter = GetEntity()->GetCharacter(slot);
if (!pCharacter)
return;
IAttachmentManager *pAttachmentManager = pCharacter->GetIAttachmentManager();
IAttachment *pAttachment = pAttachmentManager->GetInterfaceByName(name);
if (!pAttachment)
{
GameWarning("Item '%s' trying to attach entity on '%s' which does not exist!", GetEntity()->GetName(), name);
return;
}
CEntityAttachment *pEntityAttachment = new CEntityAttachment();
pEntityAttachment->SetEntityId(pEntity->GetId());
pAttachment->AddBinding(pEntityAttachment);
pAttachment->HideAttachment(0);
}
void CBodyDestrutibilityInstance::ResetMaterials( IEntity& characterEntity, ICharacterInstance& characterInstance )
{
characterEntity.SetSlotMaterial(0, NULL);
IAttachmentManager *pAttachmentManager = characterInstance.GetIAttachmentManager();
CRY_ASSERT(pAttachmentManager);
const uint32 attachmentCount = (uint32)pAttachmentManager->GetAttachmentCount();
for(TOriginalMaterials::iterator it = m_originalMaterials.begin(); it != m_originalMaterials.end(); ++it)
{
IAttachmentObject *pAttachmentObject = (it->first < attachmentCount) ? pAttachmentManager->GetInterfaceByIndex(it->first)->GetIAttachmentObject() : NULL;
if (pAttachmentObject)
{
pAttachmentObject->SetReplacementMaterial(it->second);
it->second->Release();
}
}
m_originalMaterials.clear();
}
//------------------------------------------------------------------------
void CItem::SetCharacterAttachment(int slot, const char *name, CDLight &light, int flags)
{
ICharacterInstance *pCharacter = GetEntity()->GetCharacter(slot);
if (!pCharacter)
return;
IAttachmentManager *pAttachmentManager = pCharacter->GetIAttachmentManager();
IAttachment *pAttachment = pAttachmentManager->GetInterfaceByName(name);
if (!pAttachment)
{
GameWarning("Item '%s' trying to attach light on '%s' which does not exist!", GetEntity()->GetName(), name);
return;
}
CLightAttachment *pLightAttachment = new CLightAttachment();
pLightAttachment->LoadLight(light);
pAttachment->AddBinding(pLightAttachment);
pAttachment->HideAttachment(0);
}
//------------------------------------------------------------------------
void CItem::SetCharacterAttachmentWorldTM(int slot, const char *name, const Matrix34 &tm)
{
ICharacterInstance *pCharacter = GetEntity()->GetCharacter(slot);
if (!pCharacter)
return;
IAttachmentManager *pAttachmentManager = pCharacter->GetIAttachmentManager();
IAttachment *pAttachment = pAttachmentManager->GetInterfaceByName(name);
if (!pAttachment)
{
GameWarning("Item '%s' trying to set world TM on attachment '%s' which does not exist!", GetEntity()->GetName(), name);
return;
}
// Matrix34 boneWorldMatrix = GetEntity()->GetSlotWorldTM(slot) * pCharacter->GetISkeleton()->GetAbsJMatrixByID(pAttachment->GetBoneID());
Matrix34 boneWorldMatrix = GetEntity()->GetSlotWorldTM(slot) * Matrix34(pCharacter->GetISkeletonPose()->GetAbsJointByID(pAttachment->GetBoneID()) );
Matrix34 localAttachmentMatrix = (boneWorldMatrix.GetInverted()*tm);
pAttachment->SetAttRelativeDefault(QuatT(localAttachmentMatrix));
}
//------------------------------------------------------------------------
int CScriptBind_Actor::ResetVulnerabilityEffects(IFunctionHandler *pH, int characterSlot)
{
CActor *pActor = GetActor(pH);
if (!pActor)
return pH->EndFunction();
IEntity* pEntity = pActor->GetEntity();
ICharacterInstance* pChar = pEntity->GetCharacter(characterSlot);
if (pChar)
{
IAttachmentManager* pMan = pChar->GetIAttachmentManager();
for (int i=0; i<pMan->GetAttachmentCount(); ++i)
{
IAttachment* pAtt = pMan->GetInterfaceByIndex(i);
if (strstr(pAtt->GetName(), "vulnerable"))
pAtt->ClearBinding();
}
}
return pH->EndFunction();
}
void CBodyDestrutibilityInstance::ReplaceMaterial( IEntity& characterEntity, ICharacterInstance& characterInstance, IMaterial& replacementMaterial )
{
IMaterial* pCurrentMaterial = characterInstance.GetIMaterial();
if ((pCurrentMaterial != NULL) && stricmp(pCurrentMaterial->GetName(), replacementMaterial.GetName()))
{
characterEntity.SetSlotMaterial(0, &replacementMaterial);
}
const bool storeOriginalReplacementMaterials = m_originalMaterials.empty();
IAttachmentManager *pAttachmentManager = characterInstance.GetIAttachmentManager();
CRY_ASSERT(pAttachmentManager);
const int attachmentCount = pAttachmentManager->GetAttachmentCount();
for (int attachmentIdx = 0; attachmentIdx < attachmentCount; ++attachmentIdx)
{
IAttachmentObject *pAttachmentObject = pAttachmentManager->GetInterfaceByIndex(attachmentIdx)->GetIAttachmentObject();
if (pAttachmentObject)
{
IMaterial* pAttachMaterial = (IMaterial*)pAttachmentObject->GetBaseMaterial();
if ((pAttachMaterial != NULL) && stricmp(pAttachMaterial->GetName(), replacementMaterial.GetName()))
{
if (storeOriginalReplacementMaterials)
{
IMaterial* pOriginalReplacementMaterial = pAttachmentObject->GetReplacementMaterial();
if(pOriginalReplacementMaterial != NULL)
{
pOriginalReplacementMaterial->AddRef();
m_originalMaterials.push_back(TAttachmentMaterialPair((uint32)attachmentIdx, pOriginalReplacementMaterial));
}
}
pAttachmentObject->SetReplacementMaterial(&replacementMaterial);
}
}
}
}
void CAICorpse::HandleEvent( const SGameObjectEvent& gameObjectEvent )
{
if(gameObjectEvent.event == eCGE_ItemTakenFromCorpse)
{
assert(gameObjectEvent.param != NULL);
bool matchFound = false;
const EntityId itemId = *static_cast<const EntityId*>(gameObjectEvent.param);
for (uint32 i = 0; i < m_attachedItemsInfo.size(); ++i)
{
if(m_attachedItemsInfo[i].id == itemId)
{
ICharacterInstance* pCharacter = GetEntity()->GetCharacter(0);
if(pCharacter != NULL)
{
IAttachment* pAttachment = pCharacter->GetIAttachmentManager()->GetInterfaceByName( m_attachedItemsInfo[i].attachmentName.c_str() );
if(pAttachment != NULL)
{
pAttachment->ClearBinding();
}
}
m_attachedItemsInfo.removeAt(i);
matchFound = true;
break;
}
}
if(matchFound)
{
if(m_attachedItemsInfo.empty())
{
m_priority = 0; //Lower the priority once all attached items have been removed
}
}
}
}
void CHandGrenades::UpdateStowedWeapons()
{
CActor *pOwnerActor = GetOwnerActor();
if (!pOwnerActor)
return;
ICharacterInstance *pOwnerCharacter = pOwnerActor->GetEntity()->GetCharacter(0);
if (!pOwnerCharacter)
return;
IStatObj *pTPObj = GetEntity()->GetStatObj(eIGS_ThirdPerson);
if (!pTPObj)
return;
int ammoCount = m_fm ? pOwnerActor->GetInventory()->GetAmmoCount(m_fm->GetAmmoType()) : 0;
if (IsSelected() && (ammoCount > 0))
{
ammoCount--;
}
if (!pOwnerActor->IsThirdPerson())
{
ammoCount = 0;
}
int numGrenDiff = ammoCount - m_numStowedCopies;
if(numGrenDiff != 0)
{
if (m_stowSlot < 0)
{
m_stowSlot = PickStowSlot(pOwnerCharacter->GetIAttachmentManager(), m_sharedparams->params.bone_attachment_01.c_str(), m_sharedparams->params.bone_attachment_02.c_str());
}
if (m_stowSlot >= 0)
{
bool attach = numGrenDiff > 0;
int tot = abs(numGrenDiff);
IAttachmentManager *pAttachmentManager = pOwnerCharacter->GetIAttachmentManager();
IAttachment *pAttachment = NULL;
for (int i=0; i<tot; i++)
{
//--- Generate the secondary slot from the first by adding one to the attachment name, is all we need at present...
const char *attach1 = (m_stowSlot == 0) ? m_sharedparams->params.bone_attachment_01.c_str() : m_sharedparams->params.bone_attachment_02.c_str();
int lenAttachName = strlen(attach1);
stack_string attach2(attach1, lenAttachName-1);
attach2 += (attach1[lenAttachName-1]+1);
if (attach)
{
pAttachment = pAttachmentManager->GetInterfaceByName(attach1);
if(pAttachment && pAttachment->GetIAttachmentObject())
{
pAttachment = pAttachmentManager->GetInterfaceByName(attach2);
}
if (pAttachment && !pAttachment->GetIAttachmentObject())
{
CCGFAttachment *pCGFAttachment = new CCGFAttachment();
pCGFAttachment->pObj = pTPObj;
pAttachment->AddBinding(pCGFAttachment);
pAttachment->HideAttachment(0);
pAttachment->HideInShadow(0);
m_numStowedCopies++;
}
}
else
{
pAttachment = pAttachmentManager->GetInterfaceByName(attach2);
if(!pAttachment || !pAttachment->GetIAttachmentObject())
{
pAttachment = pAttachmentManager->GetInterfaceByName(attach1);
}
if (pAttachment && pAttachment->GetIAttachmentObject())
{
pAttachment->ClearBinding();
m_numStowedCopies--;
}
}
}
}
}
}
