void CJaw::PostSerialize()
{
BaseClass::PostSerialize();
if(m_auxSlotUsed)
{
SetViewMode(0);
DrawSlot(eIGS_ThirdPersonAux,true);
}
else if (GetOwner() != 0 && !IsAttachedToBack() && !IsAttachedToHand())
{
Hide(true);
}
else if (!IsOwnerFP())
{
SetViewMode(eIVM_ThirdPerson);
DrawSlot(eIGS_ThirdPerson, true);
DrawSlot(eIGS_ThirdPersonAux,false);
}
if (m_smokeActive)
{
Pickalize(false, true);
}
if (GetOwner() != 0)
{
CActor* pOwner = GetOwnerActor();
IInventory* pInventory = pOwner ? pOwner->GetInventory() : 0;
UnregisterUsedAmmoWithInventory(pInventory);
RegisterUsedAmmoWithInventory(pInventory);
}
}
void CLaser::Reset()
{
CAccessory::Reset();
DrawSlot(eIGS_ThirdPersonAux, false);
DrawSlot(eIGS_Aux1,false);
m_laserBeam.TurnOffLaser();
}
void CJaw::HideRocket()
{
HideCharacterAttachment(eIGS_FirstPerson, "rocket", true);
HideCharacterAttachment(eIGS_ThirdPerson, "rocket", true);
m_auxSlotUsed = true;
CActor* pOwnerActor = GetOwnerActor();
if (pOwnerActor && pOwnerActor->IsThirdPerson())
{
DrawSlot(eIGS_ThirdPerson, false);
DrawSlot(eIGS_ThirdPersonAux, true);
}
}
//------------------------------------------------------------------------
void CItem::SetViewMode(int mode)
{
m_stats.viewmode = mode;
if(mode & eIVM_FirstPerson)
{
SetHand(m_stats.hand);
if(!m_parentId)
{
uint32 flags = GetEntity()->GetFlags();
if(!m_stats.mounted)
flags &= ~ENTITY_FLAG_CASTSHADOW;
else
flags |= ENTITY_FLAG_CASTSHADOW;
//GetEntity()->SetFlags(flags|ENTITY_FLAG_RECVSHADOW);
DrawSlot(eIGS_FirstPerson, true, !m_stats.mounted);
}
else
DrawSlot(eIGS_FirstPerson, false, false);
}
else
{
SetGeometry(eIGS_FirstPerson, 0);
}
if(mode & eIVM_ThirdPerson)
{
DrawSlot(eIGS_ThirdPerson, true);
if(!m_stats.mounted)
CopyRenderFlags(GetOwner());
}
else
DrawSlot(eIGS_ThirdPerson, false);
for(TAccessoryMap::iterator it = m_accessories.begin(); it != m_accessories.end(); it++)
{
IItem *pItem = m_pGameFramework->GetIItemSystem()->GetItem(it->second);
if(pItem)
{
CItem *pCItem = static_cast<CItem *>(pItem);
if(pCItem)
pCItem->SetViewMode(mode);
}
}
}
//------------------------------------------------------------------------
void CItem::DestroyedGeometry(bool use)
{
if (!m_geometry[eIGS_Destroyed].empty())
{
DrawSlot(eIGS_Destroyed, use);
if (m_stats.viewmode&eIVM_FirstPerson)
DrawSlot(eIGS_FirstPerson, !use);
else
DrawSlot(eIGS_ThirdPerson, !use);
if (use)
GetEntity()->SetSlotLocalTM(eIGS_Destroyed, GetEntity()->GetSlotLocalTM(eIGS_ThirdPerson, false));
}
}
void CDoorPanelBehavior::SwitchSlot( CDoorPanel& doorPanel, const int iSlot )
{
if (m_iCurrentVisibleSlot != -1)
{
DrawSlot(doorPanel, m_iCurrentVisibleSlot, false);
}
DrawSlot(doorPanel, iSlot, true);
m_iCurrentVisibleSlot = iSlot;
SEntityPhysicalizeParams physicalizeParams;
physicalizeParams.nSlot = iSlot;
physicalizeParams.type = PE_STATIC;
doorPanel.GetEntity()->Physicalize( physicalizeParams );
}
//========================================
void CRocketLauncher::OnReset()
{
if(m_stats.backAttachment==eIBA_Unknown)
m_auxSlotUsed = true;
CWeapon::OnReset();
if(m_stats.backAttachment==eIBA_Unknown)
{
SetViewMode(0);
DrawSlot(eIGS_ThirdPersonAux,true);
}
else
m_stats.first_selection = false;
if(m_smokeEffectSlot!=-1)
{
GetEntity()->FreeSlot(m_smokeEffectSlot);
m_smokeEffectSlot = -1;
}
ActivateTPLaser(false);
m_laserFPOn = m_laserTPOn = false;
m_lastLaserHitPt.Set(0.0f,0.0f,0.0f);
m_lastLaserHitSolid = false;
m_smoothLaserLength = -1.0f;
m_firedRockets = 0;
m_listeners.clear();
}
//=======================================
void CRocketLauncher::Select(bool select)
{
if(select && m_auxSlotUsed)
{
DrawSlot(eIGS_ThirdPersonAux,false);
m_auxSlotUsed = false;
}
CWeapon::Select(select);
if(select)
{
if(IsOwnerFP())
{
ActivateLaserDot(true,true);
m_laserFPOn = true;
}
else
{
ActivateTPLaser(true);
m_laserTPOn = true;
}
}
else
{
m_laserFPOn = false;
ActivateTPLaser(false); //Will do the rest (FP and TP)
}
}
//=========================================
void CRocketLauncher::PostSerialize()
{
CWeapon::PostSerialize();
if(m_auxSlotUsed)
{
SetViewMode(0);
DrawSlot( eIGS_ThirdPersonAux,true);
ActivateTPLaser(false);
}
else
DrawSlot( eIGS_ThirdPersonAux,false);
if(m_smokeEffectSlot>-1)
Pickalize(false,true);
}
void CJaw::ProcessEvent(SEntityEvent &event)
{
FUNCTION_PROFILER(gEnv->pSystem, PROFILE_GAME);
BaseClass::ProcessEvent(event);
if(event.event == ENTITY_EVENT_RESET)
{
//Exiting game mode
if(gEnv->IsEditor() && !event.nParam[0])
{
if(!GetOwner())
{
DrawSlot(eIGS_ThirdPerson,true);
DrawSlot(eIGS_ThirdPersonAux,false);
m_auxSlotUsed = false;
}
}
}
}
//=========================================
void CRocketLauncher::ProcessEvent(SEntityEvent &event)
{
FUNCTION_PROFILER(gEnv->pSystem, PROFILE_GAME);
CWeapon::ProcessEvent(event);
if(event.event == ENTITY_EVENT_RESET)
{
//Exiting game mode
if(gEnv->IsEditor() && !event.nParam[0])
{
if(!GetOwner())
{
DrawSlot(eIGS_ThirdPerson,false);
DrawSlot(eIGS_ThirdPersonAux,true);
m_auxSlotUsed = true;
}
ActivateLaserDot(false, false);
}
}
}
//----------------------------------------------------------------------
void CVehicleMountedWeapon::PostSerialize()
{
CHeavyMountedWeapon::PostSerialize();
if (m_vehicleId)
MountAtEntity(m_vehicleId, Vec3(ZERO), Ang3(ZERO));
CActor* pActor = GetOwnerActor();
if((pActor != NULL) && (pActor->IsClient()))
{
SetViewMode( eIVM_FirstPerson );
DrawSlot( eIGS_FirstPerson, true, true );
}
}
//----------------------------------------------------
void CRocketLauncher::ActivateTPLaser(bool activate)
{
if(activate)
{
DrawSlot( eIGS_Aux1,true);
ActivateLaserDot(true,false);
m_laserTPOn = true;
//Force first update
m_lastUpdate = 0.0f;
m_smoothLaserLength = -1.0f;
UpdateTPLaser(0.0f);
RequireUpdate(eIUS_General);
}
else
{
DrawSlot( eIGS_Aux1,false);
GetEntity()->SetSlotLocalTM( eIGS_Aux1,Matrix34::CreateIdentity());
ActivateLaserDot(false,false);
m_laserTPOn = false;
}
}
//========================================
void CRocketLauncher::PickUp(EntityId pickerId, bool sound, bool select, bool keepHistory, const char *setup)
{
CWeapon::PickUp(pickerId,sound,select,keepHistory, setup);
if(m_auxSlotUsed)
{
DrawSlot(eIGS_ThirdPersonAux,false);
m_auxSlotUsed = false;
}
if(GetOwnerActor() && !GetOwnerActor()->IsPlayer())
m_stats.first_selection = false;
}
void CJaw::DropUsed()
{
if (!gEnv->IsEditing())
{
m_dropped = true;
EnableUpdate(true);
Pickalize(false,true);
CreateSmokeEffect();
if (g_pGame->GetTacticalManager())
g_pGame->GetTacticalManager()->RemoveEntity(GetEntityId(), CTacticalManager::eTacticalEntity_Item);
}
if (m_playedDropAction)
{
DrawSlot(eIGS_ThirdPersonAux, true);
DrawSlot(eIGS_ThirdPerson, false);
}
else
{
DrawSlot(eIGS_ThirdPersonAux, false);
DrawSlot(eIGS_ThirdPerson, true);
}
}
void CVicinityDependentObjectMover::SetupEntity()
{
const char* szModelName = VICINITYDEPENDENTOBJECTMOVER_MODEL_NORMAL;
float fMoveToDistance = 10.0f;
float fAreaTriggerRange = 10.0f;
float fBackAreaTriggerRange = 10.0f;
float fForceMoveCompleteDistance = 1.0f;
IEntity* pEntity = GetEntity();
CRY_ASSERT( pEntity != NULL );
IScriptTable* pScriptTable = pEntity->GetScriptTable();
if ( pScriptTable != NULL )
{
SmartScriptTable propertiesTable;
if ( pScriptTable->GetValue( "Properties", propertiesTable) )
{
propertiesTable->GetValue( "objModel", szModelName );
propertiesTable->GetValue( "fMoveToDistance", fMoveToDistance );
propertiesTable->GetValue( "fMoveToSpeed", m_fMoveToSpeed );
propertiesTable->GetValue( "fMoveBackSpeed", m_fMoveBackSpeed );
propertiesTable->GetValue( "fAreaTriggerRange", fAreaTriggerRange );
propertiesTable->GetValue( "fBackAreaTriggerRange", fBackAreaTriggerRange );
propertiesTable->GetValue( "fForceMoveCompleteDistance", fForceMoveCompleteDistance );
propertiesTable->GetValue( "bUseAreaTrigger", m_bUseAreaTrigger );
propertiesTable->GetValue( "bDisableAreaTriggerOnMoveComplete", m_bDisableAreaTriggerOnMoveComplete );
}
}
m_fMoveToDistance = fMoveToDistance;
m_fMoveToDistanceSq = fMoveToDistance*fMoveToDistance;
m_fAreaTriggerRange = fAreaTriggerRange;
m_fAreaTriggerRangeSq = fAreaTriggerRange*fAreaTriggerRange;
m_fBackAreaTriggerRange = fBackAreaTriggerRange;
m_fBackAreaTriggerRangeSq = fBackAreaTriggerRange*fBackAreaTriggerRange;
m_fForceMoveCompleteDistanceSq = fForceMoveCompleteDistance*fForceMoveCompleteDistance;
// Load model
pEntity->LoadGeometry( VICINITYDEPENDENTOBJECTMOVER_MODEL_NORMAL_SLOT, szModelName );
// Draw slot and physicalize it
DrawSlot( VICINITYDEPENDENTOBJECTMOVER_MODEL_NORMAL_SLOT, true );
SEntityPhysicalizeParams physicalizeParams;
physicalizeParams.nSlot = VICINITYDEPENDENTOBJECTMOVER_MODEL_NORMAL_SLOT;
physicalizeParams.type = PE_RIGID;
physicalizeParams.mass = 0;
GetEntity()->Physicalize( physicalizeParams );
}
void CJaw::OnReset()
{
bool attachedToBack = IsAttachedToBack();
if(!attachedToBack)
m_auxSlotUsed = false;
BaseClass::OnReset();
if(!attachedToBack)
{
SetViewMode(eIVM_ThirdPerson);
DrawSlot(eIGS_ThirdPerson, true);
DrawSlot(eIGS_ThirdPersonAux, false);
}
else
m_stats.first_selection = false;
m_forcedTargetId = 0;
m_firedRockets = 0;
m_dropped = false;
m_dropTime = 0.0f;
m_zoomTriggerDown = false;
m_fireTriggerDown = false;
m_firePending = false;
m_playedDropAction = false;
m_fired = false;
m_zoomAlreadyToggled = false;
Hide(false);
SetFiringLocator(this);
m_listeners.Clear();
m_laserGuider.TurnOffLaser();
}
void CHeavyMountedWeapon::StopUse(EntityId userId)
{
UnRegisterAsUser();
if (m_rippedOff || m_rippingOff)
{
CActor *pActor = GetOwnerActor();
m_rippedOff = true;
m_rippingOff = false;
RemoveViewLimits();
BaseClass::StopUse(userId);
if(pActor)
{
pActor->LockInteractor(GetEntityId(), false);
}
}
else
{
CActor *pActor = GetOwnerActor();
if (!pActor)
{
return;
}
if (m_isFiring)
{
StopFire();
}
DoRipOffPrompt(GetOwnerId(), false);
SetViewMode(eIVM_ThirdPerson);
DrawSlot(eIGS_ThirdPerson, true);
if(gEnv->bMultiplayer)
{
HighlightWeapon(true);
}
//The use of CWeapon::StopUse() here and not BaseClass::StopUse() is deliberate; it avoids the '::Drop()' call that CHeavyWeapon makes
CWeapon::StopUse(userId);
}
}
//------------------------------------------------------------------------
void CItem::OnReset()
{
//Hidden entities must have physics disabled
if(!GetEntity()->IsHidden())
GetEntity()->EnablePhysics(true);
DestroyedGeometry(false);
m_stats.health = (float)m_properties.hitpoints;
UpdateDamageLevel();
if(m_sharedparams->params.scopeAttachment)
DrawSlot(eIGS_Aux1,false); //Hide secondary FP scope
if (m_properties.mounted && m_sharedparams->params.mountable)
{
MountAt(GetEntity()->GetWorldPos());
SEntityPhysicalizeParams params;
params.mass = 0;
params.nSlot = -1; // todo: -1 doesn't work for characters
params.type = PE_STATIC;
GetEntity()->Physicalize(params);
}
else
{
SetViewMode(eIVM_ThirdPerson);
if (m_properties.pickable)
{
const bool hasOwner = (GetOwnerId() != 0);
Physicalize(hasOwner ? false : true, m_properties.physics);
Pickalize(true, false);
}
else
Physicalize(m_properties.physics, true);
}
GetEntity()->InvalidateTM();
}
void CJaw::PickUp(EntityId pickerId, bool sound, bool select, bool keepHistory, const char* setup)
{
for (TAmmoVector::iterator it = m_bonusammo.begin(); it != m_bonusammo.end(); ++it)
{
SWeaponAmmo& currentBonusAmmo = *it;
currentBonusAmmo.count = 0;
}
IItemSystem* pItemSystem = gEnv->pGame->GetIGameFramework()->GetIItemSystem();
IActor* pPicketActor = gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(pickerId);
IInventory* pInventory = pPicketActor->GetInventory();
bool giveExtraTube = GiveExtraTubeToInventory(pPicketActor, pItemSystem);
if (pPicketActor->IsClient())
SetAmmoCount(m_fm->GetAmmoType(), 1);
BaseClass::PickUp(pickerId,sound,select,keepHistory, setup);
if (giveExtraTube)
{
int numJaws = m_weaponsharedparams->ammoParams.extraItems;
while(numJaws-- > 0)
{
pItemSystem->GiveItem(pPicketActor, GetEntity()->GetClass()->GetName(), false, false, false);
}
m_extraTubesAdded = true;
}
if(m_auxSlotUsed)
{
DrawSlot(eIGS_ThirdPersonAux,false);
m_auxSlotUsed = false;
}
if(GetOwnerActor() && !GetOwnerActor()->IsPlayer())
m_stats.first_selection = false;
}
//----------------------------------------------------------------------
void CGunTurret::DestroyedGeometry(bool use)
{
m_destroyed = use;
CItem::DestroyedGeometry(use);
if(!m_geometry[eIGS_Destroyed].empty())
{
if(use)
{
GetEntity()->SetSlotLocalTM(eIGS_Destroyed, GetEntity()->GetSlotLocalTM(eIGS_ThirdPerson, false));
}
DrawSlot(eIGS_Aux1,!use);
SetAspectProfile(eEA_Physics, eIPhys_PhysicalizedRigid);
UpdatePhysics();
}
if(use)
{
EnableUpdate(false, eIUS_General);
Quiet();
}
}
void CHeavyMountedWeapon::StartUse(EntityId userId)
{
HighlightWeapon(false);
if(m_rippedOff)
{
m_stats.dropped = false;
BaseClass::StartUse(userId);
}
else
{
CWeapon::StartUse(userId);
if (IsOwnerFP())
{
DrawSlot(eIGS_FirstPerson, true, true);
}
}
RegisterAsUser();
CActor* pOwner = GetOwnerActor();
if (pOwner)
{
CHANGED_NETWORK_STATE(pOwner, CPlayer::ASPECT_CURRENT_ITEM);
if (!m_rippedOff)
{
IPlayerInput* pPlayerInput = pOwner && pOwner->IsPlayer() ? static_cast<CPlayer*>(pOwner)->GetPlayerInput() : 0;
if (pPlayerInput)
pPlayerInput->ClearXIMovement();
}
}
m_expended_ammo = 0;
}
//------------------------------------------------------------------------
bool CItem::SetGeometry(int slot, const ItemString &name, const Vec3 &poffset, const Ang3 &aoffset, float scale, bool forceReload)
{
bool changedfp=false;
switch(slot)
{
case eIGS_Arms:
{
if(!name || forceReload)
{
GetEntity()->FreeSlot(slot);
#ifndef ITEM_USE_SHAREDSTRING
m_geometry[slot].resize(0);
#else
m_geometry[slot].reset();
#endif
}
ResetCharacterAttachment(eIGS_FirstPerson, ITEM_ARMS_ATTACHMENT_NAME);
ICharacterInstance *pCharacter=0;
if(name && name[0])
{
if(name != m_geometry[slot])
GetEntity()->LoadCharacter(slot, name);
DrawSlot(eIGS_Arms, false);
pCharacter = GetEntity()->GetCharacter(eIGS_Arms);
}
else if(m_pForcedArms)
{
pCharacter = m_pForcedArms;
}
else
{
int armsId=m_stats.hand==eIH_Right?0:1;
pCharacter = GetOwnerActor()?GetOwnerActor()->GetFPArms(armsId):0;
}
if(pCharacter)
{
pCharacter->SetFlags(pCharacter->GetFlags()&(~CS_FLAG_UPDATE));
SetCharacterAttachment(eIGS_FirstPerson, ITEM_ARMS_ATTACHMENT_NAME, pCharacter, 0);
}
}
break;
case eIGS_FirstPerson:
case eIGS_ThirdPerson:
default:
{
if(!name || forceReload)
{
GetEntity()->FreeSlot(slot);
#ifndef ITEM_USE_SHAREDSTRING
m_geometry[slot].resize(0);
#else
m_geometry[slot].reset();
#endif
}
DestroyAttachmentHelpers(slot);
if(name && name[0])
{
if(m_geometry[slot] != name)
{
const char *ext = PathUtil::GetExt(name.c_str());
if((stricmp(ext, "chr") == 0) || (stricmp(ext, "cdf") == 0) || (stricmp(ext, "cga") == 0))
GetEntity()->LoadCharacter(slot, name, 0);
else
GetEntity()->LoadGeometry(slot, name, 0, 0);
changedfp=slot==eIGS_FirstPerson;
}
CreateAttachmentHelpers(slot);
SetDefaultIdleAnimation(slot, g_pItemStrings->idle);
}
if(slot == eIGS_FirstPerson)
{
ICharacterInstance *pCharacter = GetEntity()->GetCharacter(eIGS_FirstPerson);
if(pCharacter)
{
pCharacter->SetFlags(pCharacter->GetFlags()&(~CS_FLAG_UPDATE));
}
}
else if(slot == eIGS_Destroyed)
DrawSlot(eIGS_Destroyed, false);
}
break;
}
Matrix34 slotTM;
slotTM = Matrix34::CreateRotationXYZ(aoffset);
slotTM.Scale(Vec3(scale, scale, scale));
slotTM.SetTranslation(poffset);
GetEntity()->SetSlotLocalTM(slot, slotTM);
if(changedfp && m_stats.mounted)
{
PlayAction(m_idleAnimation[eIGS_FirstPerson], 0, true);
ForceSkinning(true);
if(!m_mountparams.pivot.empty())
{
Matrix34 tm=GetEntity()->GetSlotLocalTM(eIGS_FirstPerson, false);
Vec3 pivot = GetSlotHelperPos(eIGS_FirstPerson, m_mountparams.pivot.c_str(), false);
tm.AddTranslation(pivot);
GetEntity()->SetSlotLocalTM(eIGS_FirstPerson, tm);
}
GetEntity()->InvalidateTM();
}
m_geometry[slot] = name ? name : "";
ReAttachAccessories();
return true;
}
//------------------------------------------------------------------------
bool CItem::SetGeometry(int slot, const ItemString& name, const ItemString& material, bool useParentMaterial, const Vec3& poffset, const Ang3& aoffset, float scale, bool forceReload)
{
assert(slot >= 0 && slot < eIGS_Last);
bool changedfp=false;
switch(slot)
{
case eIGS_Owner:
break;
case eIGS_FirstPerson:
case eIGS_ThirdPerson:
default:
{
if (name.empty() || forceReload)
{
GetEntity()->FreeSlot(slot);
#ifndef ITEM_USE_SHAREDSTRING
m_geometry[slot].resize(0);
#else
m_geometry[slot].reset();
#endif
}
DestroyAttachmentHelpers(slot);
if (!name.empty())
{
if (m_geometry[slot] != name)
{
const char* ext = PathUtil::GetExt(name.c_str());
if ((stricmp(ext, "chr") == 0) || (stricmp(ext, "cdf") == 0) || (stricmp(ext, "cga") == 0) )
GetEntity()->LoadCharacter(slot, name.c_str(), 0);
else
GetEntity()->LoadGeometry(slot, name.c_str(), 0, 0);
changedfp=slot==eIGS_FirstPerson;
}
CreateAttachmentHelpers(slot);
}
/* if (slot == eIGS_FirstPerson)
{
ICharacterInstance *pCharacter = GetEntity()->GetCharacter(eIGS_FirstPerson);
if (pCharacter)
{
pCharacter->SetFlags(pCharacter->GetFlags()&(~CS_FLAG_UPDATE));
}
}
else */if (slot == eIGS_Destroyed)
DrawSlot(eIGS_Destroyed, false);
}
break;
}
Matrix34 slotTM;
slotTM = Matrix34::CreateRotationXYZ(aoffset);
slotTM.ScaleColumn(Vec3(scale, scale, scale));
slotTM.SetTranslation(poffset);
GetEntity()->SetSlotLocalTM(slot, slotTM);
if (changedfp && m_stats.mounted)
{
if (m_sharedparams->pMountParams && !m_sharedparams->pMountParams->pivot.empty())
{
Matrix34 tm=GetEntity()->GetSlotLocalTM(eIGS_FirstPerson, false);
Vec3 pivot = GetSlotHelperPos(eIGS_FirstPerson, m_sharedparams->pMountParams->pivot.c_str(), false);
tm.AddTranslation(pivot);
GetEntity()->SetSlotLocalTM(eIGS_FirstPerson, tm);
}
GetEntity()->InvalidateTM();
}
m_geometry[slot] = name ? name : ItemString();
ReAttachAccessories();
IEntity* pParentEntity = gEnv->pEntitySystem->GetEntity(GetParentId());
IMaterial* pOverrideMaterial = 0;
if (!material.empty())
{
pOverrideMaterial = gEnv->p3DEngine->GetMaterialManager()->LoadMaterial(material.c_str());
}
else if (useParentMaterial && pParentEntity)
{
ICharacterInstance* pParentCharacter = pParentEntity->GetCharacter(slot);
IEntityRenderProxy* pParentRenderProxy = static_cast<IEntityRenderProxy*>(pParentEntity->GetProxy(ENTITY_PROXY_RENDER));
if (pParentCharacter)
pOverrideMaterial = pParentCharacter->GetIMaterial();
else if (pParentRenderProxy)
pOverrideMaterial = pParentRenderProxy->GetSlotMaterial(slot);
}
if (pOverrideMaterial)
{
ICharacterInstance* pCharacter = GetEntity()->GetCharacter(slot);
IEntityRenderProxy* pRenderProxy = static_cast<IEntityRenderProxy*>(GetEntity()->GetProxy(ENTITY_PROXY_RENDER));
OverrideAttachmentMaterial(pOverrideMaterial, this, slot);
if (pCharacter)
pCharacter->SetIMaterial_Instance(pOverrideMaterial);
else if (pRenderProxy)
pRenderProxy->SetSlotMaterial(slot, pOverrideMaterial);
}
if(slot == eIGS_FirstPerson && IsSelected())
{
CActor* pOwnerActor = GetOwnerActor();
IActionController *pActionController = GetActionController();
if(pActionController && pOwnerActor && pOwnerActor->IsClient())
{
UpdateScopeContexts(pActionController);
}
}
return true;
}
