bool CVisibleObjectsHelper::CheckObjectViewDist(const Agent& agent, const SVisibleObject &visibleObject) const
{
FUNCTION_PROFILER(GetISystem(), PROFILE_GAME);
assert(agent.IsValid());
bool bInViewDist = true;
IEntitySystem *pEntitySystem = gEnv->pEntitySystem;
assert(pEntitySystem);
IEntity *pAIEntity = pEntitySystem->GetEntity(agent.GetEntityID());
IEntity *pObjectEntity = pEntitySystem->GetEntity(visibleObject.entityId);
IEntityRenderProxy *pObjectRenderProxy = (pAIEntity != NULL && pObjectEntity ? static_cast<IEntityRenderProxy *>(pObjectEntity->GetProxy(ENTITY_PROXY_RENDER)) : NULL);
if (pObjectRenderProxy != NULL)
{
IRenderNode *pObjectRenderNode = pObjectRenderProxy->GetRenderNode();
if (pObjectRenderNode != NULL)
{
const float fDistanceSq = pAIEntity->GetWorldPos().GetSquaredDistance(pObjectEntity->GetWorldPos());
const float fMaxViewDistSq = sqr(pObjectRenderNode->GetMaxViewDist());
bInViewDist = (fDistanceSq <= fMaxViewDistSq);
}
}
return bInViewDist;
}
//------------------------------------------------------------------------
bool CProjectile::Init(IGameObject *pGameObject)
{
SetGameObject(pGameObject);
g_pGame->GetWeaponSystem()->AddProjectile(GetEntity(), this);
if (!GetGameObject()->CaptureProfileManager(this))
return false;
m_pAmmoParams = g_pGame->GetWeaponSystem()->GetAmmoParams(GetEntity()->GetClass());
if (0 == (GetEntity()->GetFlags() & (ENTITY_FLAG_CLIENT_ONLY | ENTITY_FLAG_SERVER_ONLY)))
if (!m_pAmmoParams->predictSpawn)
if (!GetGameObject()->BindToNetwork())
return false;
GetGameObject()->EnablePhysicsEvent(true, eEPE_OnCollisionLogged);
LoadGeometry();
Physicalize();
IEntityRenderProxy *pProxy = static_cast<IEntityRenderProxy *>(GetEntity()->GetProxy(ENTITY_PROXY_RENDER));
if (pProxy && pProxy->GetRenderNode())
{
pProxy->GetRenderNode()->SetViewDistRatio(255);
pProxy->GetRenderNode()->SetLodRatio(255);
}
float lifetime = m_pAmmoParams->lifetime;
if (lifetime > 0.0f)
GetEntity()->SetTimer(ePTIMER_LIFETIME, (int)(lifetime*1000.0f));
float showtime = m_pAmmoParams->showtime;
if (showtime > 0.0f)
{
GetEntity()->SetSlotFlags(0, GetEntity()->GetSlotFlags(0)&(~ENTITY_SLOT_RENDER));
GetEntity()->SetTimer(ePTIMER_SHOWTIME, (int)(showtime*1000.0f));
}
else
GetEntity()->SetSlotFlags(0, GetEntity()->GetSlotFlags(0)|ENTITY_SLOT_RENDER);
// Only for bullets
m_hitPoints = m_pAmmoParams->hitPoints;
m_hitListener = false;
if(m_hitPoints>0)
{
//Only projectiles with hit points are hit listeners
g_pGame->GetGameRules()->AddHitListener(this);
m_hitListener = true;
m_noBulletHits = m_pAmmoParams->noBulletHits;
}
if (m_tracked) // if this is true here, it means m_tracked was serialized from spawn info
{
m_tracked=false;
SetTracked(true);
}
return true;
}
IEntity* CLaserBeam::CreateLaserEntity()
{
IEntity* pLaserEntity = gEnv->pEntitySystem->GetEntity(m_laserEntityId);
if (pLaserEntity)
return pLaserEntity;
IEntity* pOwnerEntity = gEnv->pEntitySystem->GetEntity(m_ownerEntityId);
if (!pOwnerEntity)
return 0;
SEntitySpawnParams spawnParams;
spawnParams.pClass = gEnv->pEntitySystem->GetClassRegistry()->GetDefaultClass();
spawnParams.sName = "LaserBeam";
spawnParams.nFlags = (pOwnerEntity->GetFlags() | ENTITY_FLAG_NO_SAVE) & ~ENTITY_FLAG_CASTSHADOW;
IEntity* pNewEntity = gEnv->pEntitySystem->SpawnEntity(spawnParams);
if(pNewEntity)
{
m_laserEntityId = pNewEntity->GetId();
IEntityRenderProxy *pRenderProxy = (IEntityRenderProxy*)pNewEntity->GetProxy(ENTITY_PROXY_RENDER);
IRenderNode * pRenderNode = pRenderProxy?pRenderProxy->GetRenderNode():NULL;
if(pRenderNode)
pRenderNode->SetRndFlags(ERF_RENDER_ALWAYS,true);
SetLaserEntitySlots(false);
}
return pNewEntity;
}
//--------------------------------------------------------------
void CWeaponSystem::OnGameTokenEvent( EGameTokenEvent event,IGameToken *pGameToken )
{
assert(pGameToken);
if(EGAMETOKEN_EVENT_CHANGE == event)
{
bool handled = false;
if(!strcmp("weapon.effects.ice",pGameToken->GetName()))
{
pGameToken->GetValueAs(m_frozenEnvironment);
handled = true;
}
else if(!strcmp("weapon.effects.wet",pGameToken->GetName()))
{
pGameToken->GetValueAs(m_wetEnvironment);
handled = true;
}
if (handled)
{
IGameFramework* pGF = gEnv->pGame->GetIGameFramework();
IActorSystem* pAS = pGF->GetIActorSystem();
int count = pAS->GetActorCount();
if (count)
{
IActorIteratorPtr it = pAS->CreateActorIterator();
while (CActor* pActor = (CActor*)it->Next())
{
CPlayer *pPlayer = (pActor->GetActorClass() == CPlayer::GetActorClassType()) ? static_cast<CPlayer*>(pActor) : 0;
if (pPlayer && pPlayer->GetNanoSuit())
{
// go through all players and turn their ice effects on/off
IEntityRenderProxy* pRenderProxy = (IEntityRenderProxy*)pPlayer->GetEntity()->GetProxy(ENTITY_PROXY_RENDER);
if (pRenderProxy)
{
uint8 mask = pRenderProxy->GetMaterialLayersMask();
uint32 blend = pRenderProxy->GetMaterialLayersBlend();
mask = IsFrozenEnvironment() ? mask|MTL_LAYER_DYNAMICFROZEN : mask&~MTL_LAYER_DYNAMICFROZEN;
mask = IsWetEnvironment() ? mask|MTL_LAYER_WET : mask&~MTL_LAYER_WET;
pRenderProxy->SetMaterialLayersMask(mask);
pRenderProxy->SetMaterialLayersBlend(blend);
if (CItem* pItem = static_cast<CItem*>(pPlayer->GetCurrentItem(true)))
{
pItem->FrostSync(true);
pItem->WetSync(true);
}
if (COffHand* pOffHand = static_cast<COffHand*>(pPlayer->GetItemByClass(CItem::sOffHandClass)))
{
pOffHand->FrostSync(pOffHand->GetOffHandState() != eOHS_INIT_STATE);
pOffHand->WetSync(pOffHand->GetOffHandState() != eOHS_INIT_STATE);
}
}
}
}
}
}
}
}
void CScriptbind_Entity::SetHUDSilhouettesParams(IEntity *pEntity, float r, float g, float b, float a)
{
IEntityRenderProxy *pRenderProxy = static_cast<IEntityRenderProxy *>(pEntity->GetProxy(ENTITY_PROXY_RENDER));
if(!pRenderProxy)
return;
pRenderProxy->SetVisionParams(r, g, b, a);
}
void EntityEffects::CHeatController::SetThermalVisionParams( const float scale )
{
IEntityRenderProxy *pEntityRenderProxy = static_cast<IEntityRenderProxy *>(m_ownerEntity->GetProxy(ENTITY_PROXY_RENDER));
if(pEntityRenderProxy)
{
pEntityRenderProxy->SetVisionParams(scale, scale, scale, scale);
}
CHeatControllerDebug::DebugInfo(m_ownerEntity, scale);
}
//------------------------------------------------------------------------
void CGameRulesHoldObjectiveBase::UpdateEffect(float frameTime)
{
IEntity *pRingEntity = gEnv->pEntitySystem->GetEntity(m_effectData.ringEntityID);
if(pRingEntity)
{
// Update lerps
m_effectData.materialColorLerp.UpdateLerp(frameTime);
m_effectData.particleColorLerp.UpdateLerp(frameTime);
// Update ring cgf
if(m_effectData.alphaLerp.HasFinishedLerping() == false)
{
if(m_effectData.alphaFadeInDelay > 0.0f)
{
m_effectData.alphaFadeInDelay -= frameTime;
if(m_effectData.alphaFadeInDelay <= 0.0f)
{
m_effectData.alphaFadeInDelay = 0.0f;
float alpha = min(m_effectData.alphaLerp.GetValue(),0.99f);
SetRingAlpha(pRingEntity,alpha);
pRingEntity->Hide(false);
}
}
else
{
m_effectData.alphaLerp.UpdateLerp(frameTime);
float alpha = min(m_effectData.alphaLerp.GetValue(),0.99f);
SetRingAlpha(pRingEntity,alpha);
// Fully faded out, so hide
if(m_effectData.alphaLerp.HasFinishedLerping() && m_effectData.alphaLerp.GetNewValue() == 0.0f)
{
pRingEntity->Hide(true);
SetNewEffectColor(eRPT_Neutral);
}
}
}
// Update Color
float lerpValue = m_effectData.materialColorLerp.GetValue();
Vec3 currentColor = LERP(*m_effectData.pPrevCol,*m_effectData.pDestCol,lerpValue);
// Set ring color
IEntityRenderProxy* pRenderProxy = (IEntityRenderProxy*)pRingEntity->GetProxy(ENTITY_PROXY_RENDER);
if(pRenderProxy)
{
IMaterial* pRingMaterial = pRenderProxy->GetRenderMaterial();
SetMaterialDiffuseColor(pRingMaterial,currentColor);
}
// Set particle geom material color
SetMaterialDiffuseColor(m_effectData.pParticleGeomMaterial,currentColor);
}
}
//------------------------------------------------------------------------
void CGameRulesHoldObjectiveBase::SetRingAlpha(IEntity* pRingEntity,float alpha)
{
if(pRingEntity)
{
IEntityRenderProxy* pRenderProxy = (IEntityRenderProxy*)pRingEntity->GetProxy(ENTITY_PROXY_RENDER);
if(pRenderProxy)
{
IMaterial* pRindMaterial = pRenderProxy->GetRenderMaterial();
SetMaterialDiffuseAlpha(pRindMaterial,alpha);
}
}
}
void CFlock::DeleteEntities( bool bForceDeleteAll )
{
if (m_pEntity)
{
IEntityRenderProxy *pRenderProxy = (IEntityRenderProxy*)m_pEntity->GetProxy(ENTITY_PROXY_RENDER);
if (pRenderProxy)
pRenderProxy->ClearSlots();
}
I3DEngine *engine = gEnv->p3DEngine;
for (Boids::iterator it = m_boids.begin(); it != m_boids.end(); ++it)
{
CBoidObject* boid = *it;
if (boid->m_pickedUp && !bForceDeleteAll) // Do not delete picked up boids.
continue;
// SAFE_RELEASE(boid->m_object);
boid->m_object = 0;
boid->m_noentity = true;
if (boid->m_entity)
{
// Delete entity.
IEntity *pBoidEntity = gEnv->pEntitySystem->GetEntity(boid->m_entity);
if (pBoidEntity)
{
CBoidObjectProxy *pBoidObjectProxy = static_cast<CBoidObjectProxy *>(pBoidEntity->GetProxy(ENTITY_PROXY_BOID_OBJECT));
/* Luciano: old code did this (without getting the existing boid object proxy first), not sure why
if(!pBoidObjectProxy)
{
pBoidObjectProxy = new CBoidObjectProxy(pBoidEntity);
pBoidEntity->SetProxy(ENTITY_PROXY_BOID_OBJECT,pBoidObjectProxy);
}*/
if (pBoidObjectProxy)
pBoidObjectProxy->SetBoid(0);
}
gEnv->pEntitySystem->RemoveEntity(boid->m_entity);
boid->m_entity = 0;
boid->m_pPhysics = 0;
boid->m_physicsControlled = false;
}
}
m_bEntityCreated = false;
}
void CUIEntityDynTexTag::OnAddTaggedEntity(EntityId entityId, const char *uiElementName, const char *entityClass, const char *materialTemplate, const Vec3 &offset, const char *idx)
{
OnRemoveTaggedEntity(entityId, idx);
IEntityClass *pEntClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(entityClass);
if(pEntClass)
{
SEntitySpawnParams params;
params.nFlags = ENTITY_FLAG_CLIENT_ONLY;
params.pClass = pEntClass;
IEntity *pTagEntity = gEnv->pEntitySystem->SpawnEntity(params);
IUIElement *pElement = gEnv->pFlashUI->GetUIElement(uiElementName);
if(pTagEntity && pElement)
{
IMaterial *pMatTemplate = gEnv->p3DEngine->GetMaterialManager()->LoadMaterial(materialTemplate, false);
if(pMatTemplate && pMatTemplate->GetShaderItem().m_pShaderResources->GetTexture(0))
{
pMatTemplate->GetShaderItem().m_pShaderResources->GetTexture(0)->m_Name.Format("%s@%d.ui", uiElementName, entityId);
IMaterial *pMat = gEnv->p3DEngine->GetMaterialManager()->CloneMaterial(pMatTemplate);
pTagEntity->SetMaterial(pMat);
}
IEntityRenderProxy *pRenderProxy = (IEntityRenderProxy *) pTagEntity->GetProxy(ENTITY_PROXY_RENDER);
if(pRenderProxy)
{
IRenderNode *pRenderNode = pRenderProxy->GetRenderNode();
if(pRenderNode)
{
pRenderNode->SetViewDistRatio(256);
}
}
pElement->RemoveEventListener(this); // first remove to avoid assert if already registered!
pElement->AddEventListener(this, "CUIEntityDynTexTag");
gEnv->pEntitySystem->AddEntityEventListener(entityId, ENTITY_EVENT_DONE, this);
m_Tags.push_back(STagInfo(entityId, pTagEntity->GetId(), idx, offset, pElement->GetInstance((uint)entityId)));
}
}
}
//------------------------------------------------------------------------
void CTracer::SetGeometry(const char *name, float scale)
{
if (IEntity *pEntity=gEnv->pEntitySystem->GetEntity(m_entityId))
{
m_geometrySlot =pEntity->LoadGeometry(TRACER_GEOM_SLOT, name);
if (scale!=1.0f)
{
Matrix34 tm=Matrix34::CreateIdentity();
tm.ScaleColumn(Vec3(scale, scale, scale));
pEntity->SetSlotLocalTM(m_geometrySlot, tm);
}
// Set opacity
IEntityRenderProxy *pRenderProxy = (IEntityRenderProxy*)pEntity->GetProxy(ENTITY_PROXY_RENDER);
pRenderProxy->SetOpacity(m_geometryOpacity);
}
}
void CDoorPanel::AssignAsFSCommandHandler()
{
IEntity* pEntity = GetEntity();
if (pEntity)
{
IEntityRenderProxy* pRenderProxy = static_cast<IEntityRenderProxy*>(pEntity->GetProxy(ENTITY_PROXY_RENDER));
if (pRenderProxy)
{
_smart_ptr<IMaterial> pMaterial = pRenderProxy->GetRenderMaterial(DOOR_PANEL_MODEL_NORMAL_SLOT);
IFlashPlayer* pFlashPlayer = CHUDUtils::GetFlashPlayerFromMaterialIncludingSubMaterials(pMaterial, true);
if (pFlashPlayer) // Valid to not have a flash player, since will update when flash setup
{
pFlashPlayer->SetFSCommandHandler(this);
pFlashPlayer->Release();
}
}
}
}
//------------------------------------------------------------------------
bool CProjectile::Init(IGameObject *pGameObject)
{
SetGameObject(pGameObject);
g_pGame->GetWeaponSystem()->AddProjectile(GetEntity(), this);
if(!GetGameObject()->CaptureProfileManager(this))
return false;
m_pAmmoParams = g_pGame->GetWeaponSystem()->GetAmmoParams(GetEntity()->GetClass());
if(0 == (GetEntity()->GetFlags() & (ENTITY_FLAG_CLIENT_ONLY | ENTITY_FLAG_SERVER_ONLY)))
if(!m_pAmmoParams->predictSpawn)
if(!GetGameObject()->BindToNetwork())
return false;
LoadGeometry();
Physicalize();
IEntityRenderProxy *pProxy = static_cast<IEntityRenderProxy *>(GetEntity()->GetProxy(ENTITY_PROXY_RENDER));
if(pProxy && pProxy->GetRenderNode())
{
pProxy->GetRenderNode()->SetViewDistRatio(255);
pProxy->GetRenderNode()->SetLodRatio(255);
}
float lifetime = m_pAmmoParams->lifetime;
if(lifetime > 0.0f)
GetEntity()->SetTimer(ePTIMER_LIFETIME, (int)(lifetime*1000.0f));
float showtime = m_pAmmoParams->showtime;
if(showtime > 0.0f)
{
GetEntity()->SetSlotFlags(0, GetEntity()->GetSlotFlags(0)&(~ENTITY_SLOT_RENDER));
GetEntity()->SetTimer(ePTIMER_SHOWTIME, (int)(showtime*1000.0f));
}
else
GetEntity()->SetSlotFlags(0, GetEntity()->GetSlotFlags(0)|ENTITY_SLOT_RENDER);
return true;
}
//------------------------------------------------------------------------
void CItem::CopyRenderFlags(IEntity *pOwner)
{
if (!pOwner || !GetRenderProxy())
return;
IRenderNode *pRenderNode = GetRenderProxy()->GetRenderNode();
if (pRenderNode)
{
IEntityRenderProxy *pOwnerRenderProxy = (IEntityRenderProxy *)pOwner->GetProxy(ENTITY_PROXY_RENDER);
IRenderNode *pOwnerRenderNode = pOwnerRenderProxy?pOwnerRenderProxy->GetRenderNode():NULL;
if (pOwnerRenderNode)
{
pRenderNode->SetViewDistRatio(pOwnerRenderNode->GetViewDistRatio());
pRenderNode->SetLodRatio(pOwnerRenderNode->GetLodRatio());
uint32 flags = pOwner->GetFlags()&(ENTITY_FLAG_CASTSHADOW);
uint32 mflags = GetEntity()->GetFlags()&(~(ENTITY_FLAG_CASTSHADOW));
GetEntity()->SetFlags(mflags|flags);
}
}
}
void CFlock::UpdateBoidsViewDistRatio()
{
IEntityRenderProxy *pRenderProxy = (IEntityRenderProxy*)m_pEntity->GetProxy(ENTITY_PROXY_RENDER);
if (pRenderProxy)
{
m_nViewDistRatio = pRenderProxy->GetRenderNode()->GetViewDistRatio();
}
for (Boids::iterator it = m_boids.begin(); it != m_boids.end(); ++it)
{
CBoidObject* boid = *it;
IEntity *pBoidEntity = gEnv->pEntitySystem->GetEntity(boid->m_entity);
if (pBoidEntity)
{
pRenderProxy = (IEntityRenderProxy*)pBoidEntity->GetProxy(ENTITY_PROXY_RENDER);
if (pRenderProxy)
{
pRenderProxy->GetRenderNode()->SetViewDistRatio(m_nViewDistRatio);
}
}
}
}
//---------------------------------------------------------------------------
void CLam::CreateLaserEntity()
{
if(m_pLaserEntityId)
{
//Check if entity is valid
IEntity *pEntity = m_pEntitySystem->GetEntity(m_pLaserEntityId);
if(!pEntity)
m_pLaserEntityId = 0;
}
if (!m_pLaserEntityId)
{
SEntitySpawnParams spawnParams;
spawnParams.pClass = gEnv->pEntitySystem->GetClassRegistry()->GetDefaultClass();
spawnParams.sName = "LAMLaser";
spawnParams.nFlags = (GetEntity()->GetFlags() | ENTITY_FLAG_NO_SAVE) & ~ENTITY_FLAG_CASTSHADOW;
IEntity *pNewEntity =gEnv->pEntitySystem->SpawnEntity(spawnParams);
//assert(pNewEntity && "Laser entity could no be spawned!!");
if(pNewEntity)
{
pNewEntity->FreeSlot(0);
pNewEntity->FreeSlot(1);
m_pLaserEntityId = pNewEntity->GetId();
if(IEntity* pEntity = GetEntity())
pEntity->AttachChild(pNewEntity);
IEntityRenderProxy *pRenderProxy = (IEntityRenderProxy*)pNewEntity->GetProxy(ENTITY_PROXY_RENDER);
IRenderNode * pRenderNode = pRenderProxy?pRenderProxy->GetRenderNode():NULL;
if(pRenderNode)
pRenderNode->SetRndFlags(ERF_RENDER_ALWAYS,true);
}
}
}
IMaterial* CDoorPanelBehavior::CreateClonedMaterial( IEntity* pEntity, const int iSlotIndex )
{
CRY_ASSERT( m_pClonedAnimatedMaterial == NULL );
IMaterial* pClonedMaterial = NULL;
IEntityRenderProxy* pRenderProxy = static_cast<IEntityRenderProxy*>(pEntity->GetProxy(ENTITY_PROXY_RENDER));
if (pRenderProxy)
{
IMaterial* pOriginalMaterial = pRenderProxy->GetRenderMaterial(iSlotIndex);
if (pOriginalMaterial)
{
IMaterialManager* pMatManager = gEnv->p3DEngine->GetMaterialManager();
CRY_ASSERT(pMatManager);
pClonedMaterial = pMatManager->CloneMaterial( pOriginalMaterial );
if (pClonedMaterial)
{
m_pClonedAnimatedMaterial = pClonedMaterial;
pClonedMaterial->SetFlags( pClonedMaterial->GetFlags()|MTL_FLAG_PURE_CHILD ); // Notify that its not shared so won't try to remove by name in material manager which removes original material
}
else
{
GameWarning("CDoorPanelBehavior::CreateClonedMaterial: Failed to clone material");
}
}
else
{
GameWarning("CDoorPanelBehavior::CreateClonedMaterial: Failed to get material from slot: %d", DOOR_PANEL_MODEL_NORMAL_SLOT);
}
}
else
{
GameWarning("CDoorPanelBehavior::CreateClonedMaterial: Failed getting render proxy");
}
return pClonedMaterial;
}
void CDoorPanelBehavior::DeinitFlashResources( CDoorPanel& doorPanel )
{
if (m_pFlashObjectRoot)
{
SAFE_RELEASE(m_pFlashObjectRoot);
if (doorPanel.m_sharingMaterialEntity == 0)
{
IEntity* pEntity = doorPanel.GetEntity();
IEntityRenderProxy* pRenderProxy = static_cast<IEntityRenderProxy*>(pEntity->GetProxy(ENTITY_PROXY_RENDER));
if (pRenderProxy)
{
IMaterial* pMaterial = pRenderProxy->GetRenderMaterial(DOOR_PANEL_MODEL_NORMAL_SLOT);
if (pMaterial)
{
IFlashPlayer* pFlashPlayer = CHUDUtils::GetFlashPlayerFromMaterialIncludingSubMaterials(pMaterial, true);
if (pFlashPlayer)
{
pFlashPlayer->SetFSCommandHandler(NULL);
pFlashPlayer->Release();
}
CDoorPanelBehavior::DecrementNumUniqueFlashInstances(pMaterial->GetName());
doorPanel.NotifyScreenSharingEvent(eDoorPanelGameObjectEvent_StopShareScreen);
}
}
if (m_pActualAnimatedMaterial)
{
m_pActualAnimatedMaterial->ActivateDynamicTextureSources(false);
}
}
}
}
//------------------------------------------------------------------------
bool CVehiclePartTread::Init(IVehicle* pVehicle, const CVehicleParams& table, IVehiclePart* parent, CVehicle::SPartInitInfo& initInfo, int partType)
{
if (!CVehiclePartBase::Init(pVehicle, table, parent, initInfo, eVPT_Tread))
return false;
CVehicleParams subTable = table.findChild("Tread"); // Tread subtable
if (!subTable)
return false;
string filename = subTable.getAttr("filename");
if (filename.empty())
return false;
subTable.getAttr("uvSpeedMultiplier", m_uvSpeedMultiplier);
if (table.haveAttr("component"))
{
if (CVehicleComponent* pComponent = static_cast<CVehicleComponent*>(m_pVehicle->GetComponent(table.getAttr("component"))))
pComponent->AddPart(this);
}
m_slot = GetEntity()->LoadCharacter(m_slot, filename);
m_pCharInstance = GetEntity()->GetCharacter(m_slot);
if (!m_pCharInstance)
return false;
if (subTable.haveAttr("materialName"))
{
string materialName = subTable.getAttr("materialName");
materialName.MakeLower();
IMaterial* pMaterial = 0;
const char* subMtlName = 0;
int subMtlSlot = -1;
// find tread material
IEntityRenderProxy *pRenderProxy = (IEntityRenderProxy*)GetEntity()->GetProxy(ENTITY_PROXY_RENDER);
if (pRenderProxy)
{
pMaterial = pRenderProxy->GetRenderMaterial(m_slot);
if (pMaterial)
{
// if matname doesn't fit, look in submaterials
if (string(pMaterial->GetName()).MakeLower().find(materialName) == string::npos)
{
for (int i=0; i < pMaterial->GetSubMtlCount(); ++i)
{
if (string(pMaterial->GetSubMtl(i)->GetName()).MakeLower().find(materialName) != string::npos)
{
subMtlName = pMaterial->GetSubMtl(i)->GetName();
subMtlSlot = i;
break;
}
}
}
}
}
if (pMaterial)
{
// clone
IMaterial *pCloned = pMaterial->GetMaterialManager()->CloneMultiMaterial(pMaterial, subMtlName);
if (pCloned)
{
pRenderProxy->SetSlotMaterial(m_slot, pCloned);
pMaterial = pCloned;
m_pMaterial = pMaterial;
}
if (subMtlSlot > -1)
m_pShaderResources = pMaterial->GetShaderItem(subMtlSlot).m_pShaderResources;
else
m_pShaderResources = pMaterial->GetShaderItem().m_pShaderResources;
}
if (m_pShaderResources)
{
for (int i = 0; i < EFTT_MAX; ++i)
{
if (!m_pShaderResources->GetTexture(i))
continue;
SEfTexModificator& modif = *m_pShaderResources->GetTexture(i)->AddModificator();
modif.SetMember("m_eMoveType[0]", 1.0f); // ETMM_Fixed: u = m_OscRate[0] + sourceU
modif.SetMember("m_OscRate[0]", 0.0f);
}
}
}
char wheelName[256];
IDefaultSkeleton& rIDefaultSkeleton = m_pCharInstance->GetIDefaultSkeleton();
for (int i=0; i<rIDefaultSkeleton.GetJointCount(); ++i)
{
const char* boneName = rIDefaultSkeleton.GetJointNameByID(i);
if (0 != boneName)
{
// extract wheel name
const size_t len = strcspn(boneName, "_");
if (len < strlen(boneName) && len < sizeof(wheelName))
{
cry_strcpy(wheelName, boneName, len);
CVehiclePartSubPartWheel* pWheel = (CVehiclePartSubPartWheel*)m_pVehicle->GetPart(wheelName);
if (pWheel)
{
SWheelInfo wheelInfo;
wheelInfo.slot = pWheel->m_slot;
wheelInfo.jointId = i;
wheelInfo.pWheel = pWheel;
m_wheels.push_back(wheelInfo);
m_lastWheelIndex = pWheel->GetWheelIndex();
}
}
}
}
m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_AlwaysUpdate);
m_state = eVGS_Default;
return true;
}
virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )
{
switch (event)
{
case eFE_Initialize:
break;
case eFE_Activate:
IGameFramework* pGameFramework = gEnv->pGame->GetIGameFramework();
if(IsPortActive(pActInfo, EIP_Cast))
{
// setup ray + optionally skip 1 entity
ray_hit rayHit;
static const float maxRayDist = 100.f;
const unsigned int flags = rwi_stop_at_pierceable|rwi_colltype_any;
IPhysicalEntity *skipList[1];
int skipCount = 0;
IEntity* skipEntity = gEnv->pEntitySystem->GetEntity(GetPortEntityId(pActInfo, EIP_SkipEntity));
if(skipEntity)
{
skipList[0] = skipEntity->GetPhysics();
skipCount = 1;
}
Vec3 rayPos = GetPortVec3(pActInfo, EIP_RayPos);
Vec3 rayDir = GetPortVec3(pActInfo, EIP_RayDir);
// Check if the ray hits an entity
if(gEnv->pSystem->GetIPhysicalWorld()->RayWorldIntersection(rayPos, rayDir * 100, ent_all, flags, &rayHit, 1, skipList, skipCount))
{
int type = rayHit.pCollider->GetiForeignData();
if (type == PHYS_FOREIGN_ID_ENTITY)
{
IEntity* pEntity = (IEntity*)rayHit.pCollider->GetForeignData(PHYS_FOREIGN_ID_ENTITY);
IEntityRenderProxy* pRenderProxy = pEntity ? (IEntityRenderProxy*)pEntity->GetProxy(ENTITY_PROXY_RENDER) : 0;
// Get the renderproxy, and use it to check if the material is a DynTex, and get the UIElement if so
if(pRenderProxy)
{
IRenderNode *pRenderNode = pRenderProxy->GetRenderNode();
IMaterial* pMaterial = pRenderProxy->GetRenderMaterial();
SEfResTexture* texture = 0;
if(pMaterial && pMaterial->GetShaderItem().m_pShaderResources)
texture= pMaterial->GetShaderItem().m_pShaderResources->GetTexture(EFTT_DIFFUSE);
IUIElement* pElement = texture ? gEnv->pFlashUI->GetUIElementByInstanceStr(texture->m_Name) : 0;
if(pElement && pRenderNode)
{
int m_dynTexGeomSlot = 0;
IStatObj* pObj = pRenderNode->GetEntityStatObj(m_dynTexGeomSlot);
// result
bool hasHit = false;
Vec2 uv0, uv1, uv2;
Vec3 p0, p1, p2;
Vec3 hitpos;
// calculate ray dir
CCamera cam = gEnv->pRenderer->GetCamera();
if (pEntity->GetSlotFlags(m_dynTexGeomSlot) & ENTITY_SLOT_RENDER_NEAREST)
{
ICVar *r_drawnearfov = gEnv->pConsole->GetCVar("r_DrawNearFoV");
assert(r_drawnearfov);
cam.SetFrustum(cam.GetViewSurfaceX(),cam.GetViewSurfaceZ(),DEG2RAD(r_drawnearfov->GetFVal()),cam.GetNearPlane(),cam.GetFarPlane(), cam.GetPixelAspectRatio());
}
Vec3 vPos0 = rayPos;
Vec3 vPos1 = rayPos + rayDir;
// translate into object space
const Matrix34 m = pEntity->GetWorldTM().GetInverted();
vPos0 = m * vPos0;
vPos1 = m * vPos1;
// walk through all sub objects
const int objCount = pObj->GetSubObjectCount();
for (int obj = 0; obj <= objCount && !hasHit; ++obj)
{
Vec3 vP0, vP1;
IStatObj* pSubObj = NULL;
if (obj == objCount)
{
vP0 = vPos0;
vP1 = vPos1;
pSubObj = pObj;
}
else
{
IStatObj::SSubObject* pSub = pObj->GetSubObject(obj);
const Matrix34 mm = pSub->tm.GetInverted();
vP0 = mm * vPos0;
vP1 = mm * vPos1;
pSubObj = pSub->pStatObj;
}
IRenderMesh* pMesh = pSubObj ? pSubObj->GetRenderMesh() : NULL;
if (pMesh)
{
const Ray ray(vP0, (vP1-vP0).GetNormalized() * maxRayDist);
hasHit = RayIntersectMesh(pMesh, pMaterial, pElement, ray, hitpos, p0, p1, p2, uv0, uv1, uv2);
}
}
// skip if not hit
if (!hasHit)
{
ActivateOutput(pActInfo, EOP_Failed, 1);
return;
}
// calculate vectors from hitpos to vertices p0, p1 and p2:
const Vec3 v0 = p0-hitpos;
const Vec3 v1 = p1-hitpos;
const Vec3 v2 = p2-hitpos;
// calculate factors
const float h = (p0-p1).Cross(p0-p2).GetLength();
const float f0 = v1.Cross(v2).GetLength() / h;
const float f1 = v2.Cross(v0).GetLength() / h;
const float f2 = v0.Cross(v1).GetLength() / h;
// find the uv corresponding to hitpos
Vec3 uv = uv0 * f0 + uv1 * f1 + uv2 * f2;
// translate to flash space
int x, y, width, height;
float aspect;
pElement->GetFlashPlayer()->GetViewport(x, y, width, height, aspect);
int iX = int_round(uv.x * (float)width);
int iY = int_round(uv.y * (float)height);
// call the function provided if it is present in the UIElement description
string funcName = GetPortString(pActInfo, EIP_CallFunction);
const SUIEventDesc* eventDesc = pElement->GetFunctionDesc(funcName);
if(eventDesc)
{
SUIArguments arg;
arg.AddArgument(iX);
arg.AddArgument(iY);
pElement->CallFunction(eventDesc->sName, arg);
}
ActivateOutput(pActInfo, EOP_Success, 1);
}
}
}
}
ActivateOutput(pActInfo, EOP_Failed, 1);
}
break;
}
}
void CBugsFlock::CreateBoids( SBoidsCreateContext &ctx )
{
CFlock::CreateBoids(ctx);
int i;
if (!m_e_flocks)
return;
if (m_pEntity)
{
IEntityRenderProxy *pRenderProxy = (IEntityRenderProxy*)m_pEntity->GetProxy(ENTITY_PROXY_RENDER);
if (pRenderProxy)
pRenderProxy->ClearSlots();
}
// Different boids.
for (i = 0; i < ctx.boidsCount; i++)
{
CBoidBug *boid = new CBoidBug( m_bc );
float radius = m_bc.fSpawnRadius;
boid->m_pos = m_origin + Vec3(radius*Boid::Frand(),radius*Boid::Frand(),
m_bc.MinHeight+(m_bc.MaxHeight-m_bc.MinHeight)*Boid::Frand() );
boid->m_heading = Vec3(Boid::Frand(),Boid::Frand(),0).GetNormalized();
boid->m_speed = m_bc.MinSpeed + (m_bc.MaxSpeed-m_bc.MinSpeed)*Boid::Frand();
boid->m_scale = m_bc.boidScale + Boid::Frand()*m_bc.boidRandomScale;
/*
//boid->CalcRandomTarget( GetPos(),m_bc );
if (!ctx.characterModel.empty())
{
if (numObj == 0 || (i % (numObj+1) == 0))
{
m_pEntity->LoadCharacter( i,ctx.characterModel );
boid->m_object = m_pEntity->GetCharacter(i);
if (boid->m_object)
{
AABB aabb=boid->m_object->GetAABB();
bbox.Add( aabb.min );
bbox.Add( aabb.max );
if (!ctx.animation.empty())
{
CryCharAnimationParams animParams;
animParams.m_nFlags |= CA_REMOVE_FROM_FIFO;
// Play animation in loop.
boid->m_object->GetISkeleton()->StartAnimation( ctx.animation.c_str(),0, 0,0, animParams );
IAnimationSet* animSet = boid->m_object->GetIAnimationSet();
if (animSet)
{
//Ivo: this is an animation flag in the new system
//boid->m_object->SetLoop( ctx.animation.c_str(), true, 0 );
}
}
}
}
}
if (numObj > 0)
boid->m_objectId = (i % numObj);
else
boid->m_objectId = 0;
if (!boid->m_object)
{
m_pEntity->LoadGeometry( i,ctx.models[boid->m_objectId] );
}
*/
//boid->m_p = gEnv->p3DEngine->MakeCharacter( model.c_str() );
/*
if (boid->m_object)
{
boid->Physicalize(m_bc);
}
*/
AddBoid(boid);
}
}
//------------------------------------------------------------------------
void CTracerManager::Update(float frameTime)
{
CryPrefetch(m_tracerPool);
const CCamera& viewCamera = gEnv->pSystem->GetViewCamera();
const Vec3 cameraPosition = viewCamera.GetPosition();
const float viewCameraFovScale = viewCamera.GetFov() / DEG2RAD(g_pGame->GetFOV());
const int kNumActiveTracers = m_numActiveTracers;
for(int i = 0; i < kNumActiveTracers;)
{
int nextTracerIndex = i + 1;
CTracer& tracer = m_tracerPool[i];
CryPrefetch(&m_tracerPool[nextTracerIndex]);
//Update
const bool stillMoving = tracer.Update(frameTime, cameraPosition, viewCameraFovScale);
//Is it worth putting this in another loop for instruction cache coherency? Profile when PS3 is up and running - Rich S
if(stillMoving || (tracer.m_fadeOutTime > 0.f))
{
tracer.m_tracerFlags |= kTracerFlag_active;
if (!stillMoving)
{
tracer.m_fadeOutTime -= frameTime;
if (tracer.m_effectSlot > -1)
{
if (IEntity *pEntity = gEnv->pEntitySystem->GetEntity(tracer.m_entityId))
{
IParticleEmitter * emitter = pEntity->GetParticleEmitter(tracer.m_effectSlot);
if (emitter)
{
emitter->Activate(false);
}
if (tracer.m_tracerFlags & kTracerFlag_useGeometry)
{
pEntity->SetSlotFlags(tracer.m_geometrySlot, pEntity->GetSlotFlags(tracer.m_geometrySlot) &~ (ENTITY_SLOT_RENDER|ENTITY_SLOT_RENDER_NEAREST));
}
tracer.m_effectSlot = -1;
}
}
if(tracer.m_tracerFlags & kTracerFlag_useGeometry)
{
// Fade out geometry
if((tracer.m_fadeOutTime < tracer.m_startFadeOutTime) && (tracer.m_startFadeOutTime > 0.0f))
{
if (IEntity *pEntity = gEnv->pEntitySystem->GetEntity(tracer.m_entityId))
{
IEntityRenderProxy *pRenderProxy = (IEntityRenderProxy*)pEntity->GetProxy(ENTITY_PROXY_RENDER);
pRenderProxy->SetOpacity(max((tracer.m_fadeOutTime / tracer.m_startFadeOutTime) * tracer.m_geometryOpacity, 0.0f));
}
}
}
}
}
else
{
tracer.m_tracerFlags &= ~kTracerFlag_active;
tracer.m_boundToBulletId = 0;
}
i = nextTracerIndex;
}
//This is where we clear out the inactive tracers, so the counter isn't const
int numActiveTracers = kNumActiveTracers;
CWeaponSystem* pWeaponSystem = g_pGame->GetWeaponSystem();
for(int i = kNumActiveTracers - 1; i >= 0;)
{
int nextIndex = i - 1;
CTracer& tracer = m_tracerPool[i];
CryPrefetch(&m_tracerPool[nextIndex]);
if(!(tracer.m_tracerFlags & kTracerFlag_active))
{
if (IEntity *pEntity=gEnv->pEntitySystem->GetEntity(tracer.m_entityId))
{
pEntity->Hide(true);
pEntity->FreeSlot(TRACER_GEOM_SLOT);
pEntity->FreeSlot(TRACER_FX_SLOT);
}
//Switch the inactive tracer so it's at the end of the array;
const int lastTracer = numActiveTracers - 1;
static CTracer temp;
temp = tracer;
numActiveTracers = lastTracer;
tracer = m_tracerPool[lastTracer];
m_tracerPool[lastTracer] = temp;
//Re-bind index to the corresponding bullet
if (tracer.m_boundToBulletId)
{
CProjectile* pProjectile = pWeaponSystem->GetProjectile(tracer.m_boundToBulletId);
if (pProjectile && pProjectile->IsAlive())
{
if(lastTracer == pProjectile->GetTracerIdx())
{
pProjectile->BindToTracer(i);
}
else if(lastTracer == pProjectile->GetThreatTrailTracerIdx())
{
pProjectile->BindToThreatTrailTracer(i);
}
}
}
}
i = nextIndex;
}
m_numActiveTracers = numActiveTracers;
}
bool CFlock::CreateEntities()
{
if (!m_e_flocks)
return false;
SEntitySpawnParams spawnParams;
spawnParams.pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass("Boid");
if (!spawnParams.pClass)
return false;
spawnParams.nFlags = ENTITY_FLAG_CLIENT_ONLY | ENTITY_FLAG_NO_SAVE | ENTITY_FLAG_NO_PROXIMITY | m_nBoidEntityFlagsAdd;
spawnParams.sName = m_boidEntityName;
m_modelCgf = PathUtil::ReplaceExtension(m_model,"cgf");
bool bHasCgfFile = gEnv->pCryPak->IsFileExist(m_modelCgf) && m_bc.animationMaxDistanceSq > 0;
if(!bHasCgfFile)
m_bc.animationMaxDistanceSq = 0;
bool bAnyCreated = false;
for (Boids::iterator it = m_boids.begin(); it != m_boids.end(); ++it)
{
CBoidObject *boid = *it;/*m_boids[i]*/;
if (boid->m_dead || boid->m_dying)
continue;
spawnParams.vPosition = boid->m_pos;
spawnParams.vScale = Vec3(boid->m_scale,boid->m_scale,boid->m_scale);
spawnParams.id = 0;
IEntity *pBoidEntity = gEnv->pEntitySystem->SpawnEntity( spawnParams );
if (!pBoidEntity)
{
//delete boid;
//it = m_boids.erase(it);
continue;
}
boid->m_noentity = false;
boid->m_entity = pBoidEntity->GetId();
CBoidObjectProxyPtr pBoidObjectProxy = ComponentCreateAndRegister_DeleteWithRelease<CBoidObjectProxy>( IComponent::SComponentInitializer(pBoidEntity), true );
pBoidEntity->SetProxy(ENTITY_PROXY_BOID_OBJECT,pBoidObjectProxy);
pBoidObjectProxy->SetBoid(boid);
// check if character.
if (IsCharacterFile(m_model))
{
if(bHasCgfFile)
pBoidEntity->LoadGeometry(CBoidObject::eSlot_Cgf, m_modelCgf);
pBoidEntity->LoadCharacter( CBoidObject::eSlot_Chr,m_model );
boid->m_object = pBoidEntity->GetCharacter(0);
if (!boid->m_object)
{
gEnv->pEntitySystem->RemoveEntity(boid->m_entity,true);
boid->m_entity = 0;
//delete boid;
//it = m_boids.erase(it);
continue;
}
}
else
{
pBoidEntity->LoadGeometry( 0,m_model );
}
bAnyCreated = true;
// boid->m_object->GetModel()->AddRef();
AABB aabb;
if (boid->m_object)
{
boid->m_object->SetFlags( CS_FLAG_DRAW_MODEL|CS_FLAG_UPDATE );
boid->PlayAnimation( m_boidDefaultAnimName,true );
aabb = boid->m_object->GetAABB();
}
else
{
pBoidEntity->GetLocalBounds(aabb);
}
float fBBoxRadius = ((aabb.max-aabb.min).GetLength()/2.0f);
m_bc.fBoidRadius = max( fBBoxRadius, 0.001f );
m_bc.fBoidThickness = m_bc.fBoidRadius;
if (!m_bc.vEntitySlotOffset.IsZero())
{
pBoidEntity->SetSlotLocalTM(0,Matrix34::CreateTranslationMat(m_bc.vEntitySlotOffset*fBBoxRadius));
}
boid->Physicalize(m_bc);
IEntityRenderProxy *pRenderProxy = (IEntityRenderProxy*)pBoidEntity->GetProxy(ENTITY_PROXY_RENDER);
if (pRenderProxy != NULL && m_bc.fBoidRadius > 0)
{
float r = m_bc.fBoidRadius;
AABB box;
box.min = Vec3(-r,-r,-r);
box.max = Vec3(r,r,r);
pRenderProxy->SetLocalBounds( box,true );
}
IScriptTable *pScriptTable = pBoidEntity->GetScriptTable();
if (pScriptTable)
{
pScriptTable->SetValue( "flock_entity",m_pEntity->GetScriptTable() );
}
}
m_bEntityCreated = true;
return bAnyCreated;
}
void CFlock::Update( CCamera *pCamera )
{
FUNCTION_PROFILER( GetISystem(),PROFILE_ENTITY );
if (!IsFlockActive())
return;
if (!m_e_flocks)
{
if (m_bEntityCreated)
DeleteEntities( true );
return;
}
if(GetISystem()->IsSerializingFile() == 1) //quickloading
return;
if (!m_bEntityCreated)
{
if (!CreateEntities())
return;
}
float dt = gEnv->pTimer->GetFrameTime();
// Make sure delta time is limited.
if (dt > 1.0f)
dt = 0.01f;
if (dt > 0.1f)
dt = 0.1f;
m_bc.fSmoothFactor = 1.f - gEnv->pTimer->GetProfileFrameBlending();
/*
for (Boids::iterator it = m_boids.begin(); it != m_boids.end(); ++it)
{
CBoidObject *boid = *it;
boid->Think();
}
*/
//m_bc.playerPos = m_flockMgr->GetPlayerPos();
m_bc.playerPos = GetISystem()->GetViewCamera().GetMatrix().GetTranslation(); // Player position is position of camera.
m_bc.flockPos = m_origin;
m_bc.waterLevel = m_bc.engine->GetWaterLevel( &m_origin );
m_bounds.min = Vec3(FLT_MAX,FLT_MAX,FLT_MAX);
m_bounds.max = Vec3(-FLT_MAX,-FLT_MAX,-FLT_MAX);
int numBoids = m_boids.size();
if (m_percentEnabled < 100)
{
numBoids = (m_percentEnabled*numBoids)/100;
}
if (!m_pEntity->GetRotation().IsIdentity())
{
// Entity matrix must not have rotation.
//Quat q;
//q.SetIdentity();
//m_pEntity->SetRotation(q);
}
//////////////////////////////////////////////////////////////////////////
// Update flock random center.
//////////////////////////////////////////////////////////////////////////
m_fCenterFloatingTime += gEnv->pTimer->GetFrameTime();
float tc = m_fCenterFloatingTime*0.2f;
m_bc.randomFlockCenter = m_bc.flockPos +
//m_bc.fSpawnRadius*Vec3(sinf(0.9f*m_fCenterFloatingTime),cosf(1.1f*sin(0.9f*m_fCenterFloatingTime)),0.3f*sinf(1.2f*m_fCenterFloatingTime) );
m_bc.fSpawnRadius*Vec3(sinf(tc*0.913f)*cosf(tc*1.12f),sinf(tc*0.931f)*cosf(tc*0.971f),0.4f*sinf(tc*1.045f)*cosf(tc*0.962f) );
//gEnv->pRenderer->GetIRenderAuxGeom()->DrawSphere( m_bc.randomFlockCenter,0.1f,ColorB(255,0,0,255) );
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
IEntityRenderProxy *pRenderProxy = (IEntityRenderProxy*)m_pEntity->GetProxy(ENTITY_PROXY_RENDER);
if (pRenderProxy)
{
if (pRenderProxy->GetRenderNode()->GetViewDistRatio() != m_nViewDistRatio)
UpdateBoidsViewDistRatio();
}
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// Update scare factors.
if (m_bc.scareThreatLevel > 0)
{
m_bc.scareThreatLevel *= 0.95f;
m_bc.scareRatio *= 0.95f;
if (m_bc.scareRatio < 0.01f)
{
m_bc.scareRatio = 0;
m_bc.scareThreatLevel = 0;
}
if (m_e_flocks == 2)
{
int c = (int)(255*m_bc.scareRatio);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawSphere( m_bc.scarePoint,m_bc.scareRadius,ColorB(c,0,0,c),false );
}
}
//////////////////////////////////////////////////////////////////////////
UpdateBoidCollisions();
Vec3 entityPos = m_pEntity->GetWorldPos();
Matrix34 boidTM;
int num = 0;
for (Boids::iterator it = m_boids.begin(); it != m_boids.end(); ++it,num++)
{
if (num > numBoids)
break;
CBoidObject* boid = *it;
m_bc.terrainZ = m_bc.engine->GetTerrainElevation(boid->m_pos.x,boid->m_pos.y);
boid->Update(dt,m_bc);
if (!boid->m_physicsControlled && !boid->m_dead)
{
IEntity *pBoidEntity = gEnv->pEntitySystem->GetEntity(boid->m_entity);
if (pBoidEntity)
{
Quat q(IDENTITY);
boid->CalcOrientation(q);
const Vec3 scaleVector(boid->m_scale,boid->m_scale,boid->m_scale);
pBoidEntity->SetPosRotScale( boid->m_pos, q, scaleVector, ENTITY_XFORM_NO_SEND_TO_ENTITY_SYSTEM );
}
}
}
m_updateFrameID = gEnv->pRenderer->GetFrameID(false);
//gEnv->pLog->Log( "Birds Update" );
}
void CAreaProxy::ProcessEvent( SEntityEvent &event )
{
switch(event.event) {
case ENTITY_EVENT_XFORM:
OnMove();
break;
case ENTITY_EVENT_SCRIPT_EVENT:
{
const char * pName = (const char*)event.nParam[0];
if(!stricmp(pName, "Enable"))
OnEnable(true);
else if(!stricmp(pName, "Disable"))
OnEnable(false);
}
break;
case ENTITY_EVENT_RENDER:
{
if(m_pArea->GetAreaType()==ENTITY_AREA_TYPE_GRAVITYVOLUME)
{
if(!m_bDontDisableInvisible)
{
m_lastFrameTime = gEnv->pTimer->GetCurrTime();
}
if(!m_bIsEnableInternal)
{
m_bIsEnableInternal = true;
OnEnable(m_bIsEnable, false);
m_pEntity->SetTimer(0, 11000);
}
}
}
break;
case ENTITY_EVENT_TIMER:
{
if(m_pArea->GetAreaType()==ENTITY_AREA_TYPE_GRAVITYVOLUME)
{
if(!m_bDontDisableInvisible)
{
bool bOff=false;
if(gEnv->pTimer->GetCurrTime() - m_lastFrameTime > 10.0f)
{
bOff=true;
IEntityRenderProxy * pEntPr = (IEntityRenderProxy *)m_pEntity->GetProxy(ENTITY_PROXY_RENDER);
if(pEntPr)
{
IRenderNode * pRendNode = pEntPr->GetRenderNode();
if(pRendNode)
{
if(pEntPr->IsRenderProxyVisAreaVisible())
bOff = false;
}
}
if(bOff)
{
m_bIsEnableInternal = false;
OnEnable(m_bIsEnable, false);
}
}
if(!bOff)
m_pEntity->SetTimer(0, 11000);
}
}
}
break;
}
}
//------------------------------------------------------------------------
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;
}
