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;
}
}
}
void CLTag::HideGrenadeAttachment( ICharacterInstance* pWeaponCharacter, const char* attachmentName, bool hide )
{
CRY_ASSERT(pWeaponCharacter);
CCCPOINT_IF(string("newShell") == attachmentName && hide, ltag_hide_newShell);
CCCPOINT_IF(string("newShell") == attachmentName && !hide, ltag_show_newShell);
CCCPOINT_IF(string("currentShell") == attachmentName && hide, ltag_hide_currentShell);
CCCPOINT_IF(string("currentShell") == attachmentName && !hide, ltag_show_currentShell);
IAttachment* pAttachment = pWeaponCharacter->GetIAttachmentManager()->GetInterfaceByName(attachmentName);
if (pAttachment)
{
pAttachment->HideAttachment(hide ? 1 : 0);
}
}
//------------------------------------------------------------------------
void CItem::HideCharacterAttachment(int slot, const char *name, bool hide)
{
ICharacterInstance *pCharacter = GetEntity()->GetCharacter(slot);
if (!pCharacter)
return;
IAttachmentManager *pAttachmentManager = pCharacter->GetIAttachmentManager();
IAttachment *pAttachment = pAttachmentManager->GetInterfaceByName(name);
if (!pAttachment)
{
GameWarning("Item '%s' trying to hide attachment '%s' which does not exist!", GetEntity()->GetName(), name);
return;
}
pAttachment->HideAttachment(hide?1:0);
}
//------------------------------------------------------------------------
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 UnHideAttachment(SActivationInfo* pActInfo)
{
IAttachment* pAttachment = GetAttachment(pActInfo);
if(pAttachment)
{
pAttachment->HideAttachment(0);
IAttachmentObject* pAttachmentObject = pAttachment->GetIAttachmentObject();
if((pAttachmentObject != NULL) && (pAttachmentObject->GetAttachmentType() == IAttachmentObject::eAttachment_Entity))
{
IEntity* pAttachedEntity = gEnv->pEntitySystem->GetEntity( static_cast<CEntityAttachment*>(pAttachmentObject)->GetEntityId() );
if(pAttachedEntity)
{
pAttachedEntity->Hide(false);
}
}
}
}
//------------------------------------------------------------------------
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::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 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--;
}
}
}
}
}
}
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->GetICharacterModel()->GetICharacterModelSkeleton()->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));
}
}
}
//------------------------------------------------------------------------
bool CC4Projectile::StickToCharacter(bool stick,IEntity *pActor)
{
if(!pActor)
return false;
//Check for friendly AI
if(pActor->GetAI())
{
if(CWeapon *pWeapon = GetWeapon())
{
if(CActor *pPlayer = pWeapon->GetOwnerActor())
{
if(IAIObject *pPlayerAI = pPlayer->GetEntity()->GetAI())
{
if(pActor->GetAI()->IsFriendly(pPlayerAI, false))
{
return false;
}
}
}
}
}
ICharacterInstance *pCharacter = pActor->GetCharacter(0);
if(!pCharacter)
return false;
//Actors doesn't support constraints, try to stick as character attachment
IAttachmentManager *pAttachmentManager = pCharacter->GetIAttachmentManager();
IAttachment *pAttachment = NULL;
//Select one of the attachment points
Vec3 charOrientation = pActor->GetRotation().GetColumn1();
Vec3 c4ToChar = pActor->GetWorldPos() - GetEntity()->GetWorldPos();
c4ToChar.Normalize();
//if(c4ToChar.Dot(charOrientation)>0.0f)
//pAttachment = pAttachmentManager->GetInterfaceByName("c4_back");
//else
pAttachment = pAttachmentManager->GetInterfaceByName("c4_front");
if(!pAttachment)
{
GameWarning("No c4 face attachment found in actor");
if(!pAttachment)
return false;
}
if(stick)
{
//Check if there's already one
if(IAttachmentObject *pAO = pAttachment->GetIAttachmentObject())
return false;
CEntityAttachment *pEntityAttachment = new CEntityAttachment();
pEntityAttachment->SetEntityId(GetEntityId());
pAttachment->AddBinding(pEntityAttachment);
pAttachment->HideAttachment(0);
m_stuck = true;
}
else
{
pAttachment->ClearBinding();
m_stuck = false;
}
return true;
}
