//------------------------------------------------------------------------
bool CVehicleWeapon::FilterView(SViewParams& viewParams)
{
if (m_pOwnerSeat != m_pSeatUser)
return false;
if (m_camerastats.animating && !m_camerastats.helper.empty())
{
viewParams.position = GetSlotHelperPos(eIGS_FirstPerson, m_camerastats.helper, true);
viewParams.rotation = Quat(GetSlotHelperRotation(eIGS_FirstPerson, m_camerastats.helper, true));
viewParams.blend = false;
if (g_pGameCVars->v_debugMountedWeapon)
{
Vec3 local = GetSlotHelperPos(eIGS_FirstPerson, m_camerastats.helper, false, true);
Vec3 entity = GetSlotHelperPos(eIGS_FirstPerson, m_camerastats.helper, false, false);
float color[] = {1,1,1,1};
gEnv->pRenderer->Draw2dLabel(50,400,1.3f,color,false,"cam_pos local(%.3f %.3f %.3f), entity(%.3f %.3f %.3f)", local.x, local.y, local.z, entity.x, entity.y, entity.z);
Ang3 angLocal(GetSlotHelperRotation(eIGS_FirstPerson, m_camerastats.helper, false, true));
Ang3 angEntity(GetSlotHelperRotation(eIGS_FirstPerson, m_camerastats.helper, false, true));
gEnv->pRenderer->Draw2dLabel(50,420,1.3f,color,false,"cam_rot local(%.3f %.3f %.3f), entity(%.3f %.3f %.3f)", angLocal.x, angLocal.y, angLocal.z, angEntity.x, angEntity.y, angEntity.z);
}
return true;
}
return false;
}
//------------------------------------------------------------------------
void CGunTurret::OnReset()
{
if(IScriptTable *pScriptTable = GetEntity()->GetScriptTable())
{
SmartScriptTable props;
if(pScriptTable->GetValue("Properties", props))
ReadProperties(props);
}
CItem::OnReset();
Matrix34 tm = GetEntity()->GetSlotLocalTM(eIGS_Aux0,false);
tm.SetTranslation(GetSlotHelperPos(eIGS_Aux0,m_radarHelper.c_str(),false));
GetEntity()->SetSlotLocalTM(eIGS_ThirdPerson,tm);
if(GetEntity()->IsSlotValid(eIGS_Aux1))
{
tm.SetTranslation(GetSlotHelperPos(eIGS_ThirdPerson,m_barrelHelper.c_str(),false));
GetEntity()->SetSlotLocalTM(eIGS_Aux1,tm);
}
m_targetId = 0;
m_destinationId = 0;
m_updateTargetTimer = 0.0f;
m_abandonTargetTimer = 0.0f;
m_goalYaw = 0.0f;
m_goalPitch = 0.0f;
m_burstTimer = 0.0f;
m_pauseTimer = 0.0f;
m_searchHint = 0;
m_fireHint = 1;
m_deviationPos.zero();
m_randoms[eRV_UpdateTarget].Range(m_turretparams.update_target_time * m_fireparams.randomness);
m_randoms[eRV_AbandonTarget].Range(m_turretparams.abandon_target_time * m_fireparams.randomness);
m_randoms[eRV_BurstTime].Range(m_turretparams.burst_time * m_fireparams.randomness);
m_randoms[eRV_BurstPause].Range(m_turretparams.burst_pause * m_fireparams.randomness);
m_lightId = AttachLight(eIGS_ThirdPerson, m_lightId, false);
StopSound(m_lightSound);
m_lightSound = INVALID_SOUNDID;
if(m_turretparams.light_fov > 0.f)
{
m_lightId = AttachLight(eIGS_ThirdPerson, 0, true, m_turretparams.mg_range, m_searchparams.light_color*m_searchparams.light_diffuse_mul, 1.f/m_searchparams.light_diffuse_mul, m_searchparams.light_texture, m_turretparams.light_fov, m_searchparams.light_helper, Vec3(0,0,0), Vec3(-1,0,0), m_searchparams.light_material, m_searchparams.light_hdr_dyn);
m_lightSound = PlayAction(g_pItemStrings->use_light);
}
SetFiringLocator(this);
if(m_fm2)
m_fm2->Activate(true);
EnableUpdate(true, eIUS_General);
}
//------------------------------------------------------------------------
bool CGunTurret::ReadItemParams(const IItemParamsNode *root)
{
//m_tpgeometry.position.Set(0.f, 0.f, 0.f);
//m_aux0geometry.position.Set(0.f, 0.f, 0.f);
if(!CWeapon::ReadItemParams(root))
return false;
string rocket_fire_mode;
const IItemParamsNode *params = root->GetChild("params");
{
CItemParamReader reader(params);
reader.Read("rocket_firemode", rocket_fire_mode);
reader.Read("radar_helper", m_radarHelper);
reader.Read("barrel_helper", m_barrelHelper);
reader.Read("fire_helper", m_fireHelper);
reader.Read("rocket_helper", m_rocketHelper);
/*Matrix34 tm = GetEntity()->GetSlotLocalTM(eIGS_Aux0,false);
tm.SetTranslation(GetSlotHelperPos(eIGS_Aux0,m_radarHelper.c_str(),false));
GetEntity()->SetSlotLocalTM(eIGS_ThirdPerson,tm);
if (GetEntity()->IsSlotValid(eIGS_Aux1))
{
tm.SetTranslation(GetSlotHelperPos(eIGS_ThirdPerson,m_barrelHelper.c_str(),false));
GetEntity()->SetSlotLocalTM(eIGS_Aux1,tm);
}*/
m_radarHelperPos = GetSlotHelperPos(eIGS_Aux0, m_radarHelper.c_str(), false);
m_barrelHelperPos = GetSlotHelperPos(eIGS_ThirdPerson, m_barrelHelper.c_str(), false);
m_fireHelperPos = GetSlotHelperPos(eIGS_ThirdPerson, m_fireHelper.c_str(), false);
m_rocketHelperPos = GetSlotHelperPos(eIGS_ThirdPerson, m_rocketHelper, false);
}
if(const IItemParamsNode *turret = root->GetChild("turret"))
{
if(const IItemParamsNode *search = turret->GetChild("search"))
m_searchparams.Reset(search);
if(const IItemParamsNode *fire = turret->GetChild("fire"))
m_fireparams.Reset(fire);
}
m_fm2=GetFireMode(rocket_fire_mode.c_str());
if(m_fm2)
m_fm2->Activate(true);
return true;
}
//------------------------------------------------------------------------
void CItem::UpdateFPView(float frameTime)
{
if (!m_stats.selected)
return;
CheckViewChange();
if (!m_stats.fp && !m_stats.mounted)
return;
if (GetGameObject()->GetAspectProfile(eEA_Physics)!=eIPhys_NotPhysicalized)
return;
if (m_camerastats.animating)
{
if (m_camerastats.position)
m_camerastats.pos=GetSlotHelperPos(eIGS_FirstPerson, m_camerastats.helper.c_str(), false, true);
if (m_camerastats.rotation)
m_camerastats.rot=Quat(GetSlotHelperRotation(eIGS_FirstPerson, m_camerastats.helper.c_str(), false, true)); //*Quat::CreateRotationZ(-gf_PI);
}
if (!m_stats.mounted)
{
UpdateFPPosition(frameTime);
UpdateFPCharacter(frameTime);
}
if (IItem *pSlave = GetDualWieldSlave())
pSlave->UpdateFPView(frameTime);
//UpdateMounted() is only updated in CItem::Update()
//if (m_stats.mounted && GetOwnerActor() && GetOwnerActor()->IsClient())
//UpdateMounted(frameTime);
}
//------------------------------------------------------------------------
void CItem::PostFilterView(struct SViewParams &viewParams)
{
if (m_camerastats.animating && !m_camerastats.follow)
{
const Matrix34 tm = GetEntity()->GetSlotWorldTM(eIGS_FirstPerson);
Vec3 offset(0.0f,0.0f,0.0f);
offset += tm.GetColumn(0).GetNormalized()*m_camerastats.pos.x;
offset += tm.GetColumn(1).GetNormalized()*m_camerastats.pos.y;
offset += tm.GetColumn(2).GetNormalized()*m_camerastats.pos.z;
viewParams.position+=offset;
viewParams.rotation*=m_camerastats.rot;
viewParams.blend=true;
viewParams.viewID=5;
}
if (m_camerastats.animating && m_stats.mounted && !m_camerastats.helper.empty() && IsOwnerFP())
{
viewParams.position = GetSlotHelperPos(eIGS_FirstPerson, m_camerastats.helper, true);
viewParams.rotation = Quat(GetSlotHelperRotation(eIGS_FirstPerson, m_camerastats.helper, true));
viewParams.blend = true;
viewParams.viewID=5;
viewParams.nearplane = 0.1f;
}
}
//------------------------------------------------------------------------
bool CGunTurret::IsTargetShootable(IEntity *pTarget)
{
// raycast shootability check
Vec3 pos = m_fireHelper.empty() ? GetWeaponPos() : GetSlotHelperPos(eIGS_ThirdPerson, m_fireHelper.c_str(), true);
Vec3 tpos = GetTargetPos(pTarget);
Vec3 dir = tpos - pos;
bool shootable = RayCheck(pTarget, pos, dir);
if(!shootable)
{
// fallback for actors
// todo: also use this for shooting pos!
CActor *pActor = GetActor(pTarget->GetId());
if(pActor && pActor->GetMovementController())
{
SMovementState state;
pActor->GetMovementController()->GetMovementState(state);
dir = state.eyePosition - pos;
shootable = RayCheck(pTarget, pos, dir);
}
}
return shootable;
}
//------------------------------------------------------------------------
void CItem::UpdateIKMounted(IActor* pActor, const Vec3& vGunXAxis)
{
if (!m_mountparams.left_hand_helper.empty() || !m_mountparams.right_hand_helper.empty())
{
Vec3 lhpos=GetSlotHelperPos(eIGS_FirstPerson, m_mountparams.left_hand_helper.c_str(), true);
Vec3 rhpos=GetSlotHelperPos(eIGS_FirstPerson, m_mountparams.right_hand_helper.c_str(), true);
if (pActor)
{
pActor->SetIKPos("leftArm", lhpos-vGunXAxis, 1);
pActor->SetIKPos("rightArm", rhpos+vGunXAxis, 1);
}
// gEnv->pRenderer->GetIRenderAuxGeom()->DrawSphere(lhpos, 0.075f, ColorB(255, 255, 255, 255));
// gEnv->pRenderer->GetIRenderAuxGeom()->DrawSphere(rhpos, 0.075f, ColorB(128, 128, 128, 255));
}
}
void CGunTurret::DrawDebug()
{
IPersistantDebug *pDebug = gEnv->pGame->GetIGameFramework()->GetIPersistantDebug();
pDebug->Begin("CGunTurret::DrawDebug", true);
Vec3 gun(ZERO),rocket(ZERO),radar(ZERO),barrel(ZERO);
gun = GetSlotHelperPos(eIGS_ThirdPerson,m_fireHelper,true);
rocket = GetSlotHelperPos(eIGS_ThirdPerson,m_rocketHelper,true);
barrel = GetSlotHelperPos(eIGS_ThirdPerson,m_barrelHelper,true);
radar = GetSlotHelperPos(eIGS_Aux0,m_radarHelper,true);
pDebug->AddSphere(gun, 0.2f, ColorF(1,0,0,1), 1.f);
pDebug->AddSphere(rocket, 0.2f, ColorF(0,1,0,1), 1.f);
pDebug->AddSphere(radar, 0.2f, ColorF(0,0,1,1), 1.f);
pDebug->AddSphere(barrel, 0.2f, ColorF(1,0,1,1), 1.f);
}
//------------------------------------------------------------------------
void CItem::ReAttachAccessory(const ItemString &name)
{
CItem *pAccessory = GetAccessory(name);
SAccessoryParams *params = GetAccessoryParams(name);
if(pAccessory && params)
{
SetCharacterAttachment(eIGS_FirstPerson, params->attach_helper.c_str(), pAccessory->GetEntity(), eIGS_FirstPerson, 0);
Vec3 position = GetSlotHelperPos(eIGS_ThirdPerson, params->attach_helper.c_str(), false);
GetEntity()->AttachChild(pAccessory->GetEntity());
Matrix34 tm(Matrix34::CreateIdentity());
tm.SetTranslation(position);
pAccessory->GetEntity()->SetLocalTM(tm);
pAccessory->SetParentId(GetEntityId());
pAccessory->Physicalize(false, false);
PlayLayer(params->attach_layer, eIPAF_Default|eIPAF_NoBlend);
}
}
//--------------------------------------------
void CLaser::GetLaserPositionAndDirection(CWeapon* pParentWeapon, Vec3& pos, Vec3& dir)
{
const char* entityLocationHelper = m_laserHelperFP.c_str();
const char* laserTermHelper = "laser_term";
const bool relative = false;
const bool absolute = true;
const int slot = pParentWeapon->IsOwnerFP() ? eIGS_FirstPerson : eIGS_ThirdPerson;
Matrix34 entityLocation =
Matrix34::CreateTranslationMat(pParentWeapon->GetSlotHelperPos(slot, entityLocationHelper, absolute)) *
pParentWeapon->GetSlotHelperRotation(slot, entityLocationHelper, absolute);
Matrix34 helperLocation =
Matrix34::CreateTranslationMat(GetSlotHelperPos(slot, laserTermHelper, relative)) *
GetSlotHelperRotation(slot, laserTermHelper, relative);
Matrix34 finalLocation = entityLocation * helperLocation;
pos = finalLocation.GetTranslation();
dir = finalLocation.GetColumn1();
}
void CJaw::UpdateLaser(const SEntityUpdateContext& ctx)
{
if (!GetEntity()->IsHidden())
{
switch (GetZoomState())
{
case eZS_ZoomedOut:
case eZS_ZoomingOut:
if (m_laserGuider.IsLaserActivated())
{
m_laserGuider.TurnOffLaser();
}
break;
case eZS_ZoomingIn:
case eZS_ZoomedIn:
if (!m_laserGuider.IsLaserActivated())
{
m_laserGuider.TurnOnLaser();
}
break;
}
}
else
{
if (m_laserGuider.IsLaserActivated())
{
m_laserGuider.TurnOffLaser();
}
}
m_laserGuider.UpdateLaser(CLaserBeam::SLaserUpdateDesc(
GetSlotHelperPos(0, "laser_term", true),
GetSlotHelperRotation(0, "laser_term", true).GetColumn1(),
ctx.fFrameTime,
GetEntity()->IsHidden()));
}
//------------------------------------------------------------------------
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;
}
//------------------------------------------------------------------------
void CGunTurret::UpdateOrientation(float deltaTime)
{
FUNCTION_PROFILER(GetISystem(), PROFILE_GAME);
bool changed = false;
bool searching = (m_targetId==0 && m_turretparams.searching);
float speed = searching ? m_turretparams.search_speed : m_turretparams.turn_speed;
assert(m_goalYaw >= 0.f && m_goalYaw <= gf_PI2);
// update turret
Matrix34 turretTM = GetEntity()->GetSlotLocalTM(eIGS_Aux0, false);
Ang3 turretAngles(turretTM);
if(turretAngles.z < 0.0f)
turretAngles.z+=gf_PI2;
if(cry_fabsf(m_goalYaw-turretAngles.z) > gf_PI)
{
if(m_goalYaw >= gf_PI)
turretAngles.z += gf_PI2;
else
turretAngles.z -= gf_PI2;
}
if(m_turretparams.yaw_range < 360.f)
{
// reverse, to avoid forbidden range
if(m_goalYaw > gf_PI && turretAngles.z < gf_PI)
turretAngles.z += gf_PI2;
else if(m_goalYaw < gf_PI && turretAngles.z > gf_PI)
turretAngles.z -= gf_PI2;
}
if(cry_fabsf(turretAngles.z-m_goalYaw) > 0.001f)
{
Interp(turretAngles.z, m_goalYaw, speed, deltaTime, 0.25f*speed);
if(m_turretSound == INVALID_SOUNDID && gEnv->IsClient())
m_turretSound = PlayAction(g_pItemStrings->turret);
changed = true;
}
else if(m_turretSound != INVALID_SOUNDID)
{
StopSound(m_turretSound);
m_turretSound = INVALID_SOUNDID;
}
if(changed)
{
turretTM.SetRotationXYZ(turretAngles,turretTM.GetTranslation());
GetEntity()->SetSlotLocalTM(eIGS_Aux0, turretTM);
}
// update weapon
Matrix34 weaponTM = GetEntity()->GetSlotLocalTM(eIGS_ThirdPerson, false);
Ang3 weaponAngles(weaponTM);
weaponAngles.z = turretAngles.z;
if(cry_fabsf(weaponAngles.x-m_goalPitch) > 0.001f)
{
Interp(weaponAngles.x, m_goalPitch, speed, deltaTime, 0.25f*speed);
if(m_cannonSound == INVALID_SOUNDID && gEnv->IsClient())
m_cannonSound = PlayAction(g_pItemStrings->cannon);
changed = true;
}
else if(m_cannonSound != INVALID_SOUNDID)
{
StopSound(m_cannonSound);
m_cannonSound = INVALID_SOUNDID;
}
if(changed)
{
weaponTM.SetRotationXYZ(weaponAngles);
Vec3 w_trans = turretTM.TransformPoint(m_radarHelperPos);
//Vec3 w_trans = GetSlotHelperPos(eIGS_Aux0,m_radarHelper.c_str(),false);
weaponTM.SetTranslation(w_trans);
GetEntity()->SetSlotLocalTM(eIGS_ThirdPerson, weaponTM);
if(GetEntity()->IsSlotValid(eIGS_Aux1))
{
Vec3 b_trans = weaponTM.TransformPoint(m_barrelHelperPos);
//Vec3 b_trans = GetSlotHelperPos(eIGS_ThirdPerson,m_barrelHelper.c_str(),false);
weaponTM.SetTranslation(b_trans);
GetEntity()->SetSlotLocalTM(eIGS_Aux1, weaponTM*m_barrelRotation);
}
if(gEnv->IsClient())
{
for(TEffectInfoMap::const_iterator it=m_effects.begin(); it!=m_effects.end(); ++it)
{
Matrix34 tm(GetSlotHelperRotation(eIGS_ThirdPerson,it->second.helper.c_str(),true), GetSlotHelperPos(eIGS_ThirdPerson,it->second.helper.c_str(),true));
SetEffectWorldTM(it->first, tm);
}
}
}
UpdatePhysics();
if(g_pGameCVars->i_debug_turrets == eGTD_Basic)
{
DrawDebug();
//gEnv->pRenderer->DrawLabel(GetEntity()->GetWorldPos(), 1.4f, "%s yaw: %.2f, goalYaw: %.2f (%.2f), goalPitch: %.2f (%.2f/%.2f)", searching?"[search]":"", RAD2DEG(turretAngles.z), RAD2DEG(m_goalYaw), 0.5f*(m_turretparams.yaw_range), RAD2DEG(m_goalPitch), m_turretparams.min_pitch, m_turretparams.max_pitch);
}
}
