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