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--; } } } } } }