void CAICorpseManager::DebugDraw()
{
if(g_pGameCVars->g_aiCorpses_DebugDraw == 0)
return;
IRenderAuxGeom* pRenderAux = gEnv->pRenderer->GetIRenderAuxGeom();
gEnv->pRenderer->Draw2dLabel( 50.0f, 50.0f, 1.5f, Col_White, false, "Corpse count %" PRISIZE_T " - Max %d", m_corpsesArray.size(), m_maxCorpses );
for(size_t i = 0; i < m_corpsesArray.size(); ++i)
{
CorpseInfo& corpse = m_corpsesArray[i];
CAICorpse* pCorpse = corpse.GetCorpse();
if(pCorpse != NULL)
{
AABB corpseBbox;
pCorpse->GetEntity()->GetWorldBounds(corpseBbox);
const Vec3 refPosition = corpseBbox.IsEmpty() ? pCorpse->GetEntity()->GetWorldPos() : corpseBbox.GetCenter();
gEnv->pRenderer->DrawLabel( refPosition, 1.5f, "%s\nPriority %d\n%s\n%s",
pCorpse->GetEntity()->GetName(), pCorpse->GetPriority(),
corpse.flags.AreAnyFlagsActive( CorpseInfo::eFlag_FarAway ) ? "Far away, remove when not visible" : "Not far away",
corpse.flags.AreAllFlagsActive( CorpseInfo::eFlag_PhysicsDisabled) ? "Physics disabled" : "Physics enabled" );
pRenderAux->DrawCone( refPosition + Vec3(0.0f, 0.0f, 1.5f), Vec3(0.0f, 0.0f, -1.0f), 0.3f, 0.8f, Col_Red );
}
}
}
//------------------------------------------------------------------------
void CVehicleMovementStdBoat::DrawImpulse(const pe_action_impulse& action, const Vec3& offset, float scale, const ColorB& col)
{
if (!is_unused(action.impulse) && action.impulse.len2()>0)
{
IRenderAuxGeom* pGeom = gEnv->pRenderer->GetIRenderAuxGeom();
Vec3 start = action.point + offset;
Vec3 end = start - (action.impulse*scale/m_pVehicle->GetMass());
Vec3 dir = (start-end).GetNormalizedSafe();
pGeom->DrawCone(start-1.f*dir, dir, 0.5f, 1.f, col);
pGeom->DrawLine(start, col, end, col);
pGeom->DrawSphere(end, 0.25f, col);
}
}
void SDebugCannonBallPenetration::Update(float frameTime)
{
IRenderAuxGeom* pRenderAux = gEnv->pRenderer->GetIRenderAuxGeom();
SAuxGeomRenderFlags oldFlags = pRenderAux->GetRenderFlags();
SAuxGeomRenderFlags newFlags = e_Def3DPublicRenderflags;
newFlags.SetAlphaBlendMode(e_AlphaBlended);
newFlags.SetDepthTestFlag(e_DepthTestOff);
newFlags.SetCullMode(e_CullModeNone);
pRenderAux->SetRenderFlags(newFlags);
const float baseDebugTimeOut = (g_pGameCVars->g_bulletPenetrationDebugTimeout > 0.0f) ? g_pGameCVars->g_bulletPenetrationDebugTimeout : DEFAULT_DEBUG_CannonBall_HIT_LIFETIME;
for (int i = 0; i < MAX_DEBUG_CannonBall_HITS; ++i)
{
SDebugCannonBallHit& currentHit = m_hitsList[i];
if (currentHit.lifeTime <= 0.0f)
{
continue;
}
currentHit.lifeTime -= frameTime;
//const float alpha = powf((currentHit.lifeTime / baseDebugTimeOut), 4.0f);
// avoid powf whenever possible, for such simple cases, can do with 2 muls
float alpha = (currentHit.lifeTime / baseDebugTimeOut);
alpha *= alpha;
alpha *= alpha;
const ColorB red(255, 0, 0, (uint8)(192 * alpha)), green(0, 255, 0, (uint8)(192 * alpha));
const ColorB& hitColor = currentHit.stoppedCannonBall ? red : green;
const Vec3 coneBase = currentHit.isBackFaceHit ? (currentHit.hitPosition + (currentHit.CannonBallDirection * 0.3f)) : (currentHit.hitPosition - (currentHit.CannonBallDirection * 0.2f)) ;
const Vec3 lineEnd = (coneBase - (currentHit.CannonBallDirection * 0.3f));
pRenderAux->DrawCone(coneBase, currentHit.CannonBallDirection, 0.12f, 0.2f, hitColor);
pRenderAux->DrawLine(coneBase, hitColor, lineEnd, hitColor, 3.0f);
const Vec3 baseText = (currentHit.isBackFaceHit) ? coneBase + (0.2f * currentHit.CannonBallDirection) : lineEnd - (0.3f * currentHit.CannonBallDirection);
const Vec3 textLineOffset(0.0f, 0.0f, 0.14f);
const float textColor[4] = {1.0f, 1.0f, 1.0f, alpha};
gEnv->pRenderer->DrawLabelEx(baseText - (textLineOffset * 2.0f), 1.25f, textColor, true, false, "Damage: %.1f", currentHit.damage);
gEnv->pRenderer->DrawLabelEx(baseText - (textLineOffset * 3.0f), 1.25f, textColor, true, false, "Pierceability: %d", currentHit.surfacePierceability);
gEnv->pRenderer->DrawLabelEx(baseText - (textLineOffset * 4.0f), 1.25f, textColor, true, false, "%s", GetPenetrationLevelByPierceability(currentHit.surfacePierceability));
gEnv->pRenderer->DrawLabelEx(baseText - (textLineOffset * 5.0f), 1.25f, textColor, true, false, currentHit.tooThick ? "Too thick!" : "------");
}
pRenderAux->SetRenderFlags(oldFlags);
}
void CPlayerVisTableDebugDraw::Update()
{
const float currentTime = gEnv->pTimer->GetCurrTime();
const float maxDebugLifeTime = 1.0f;
IRenderAuxGeom* pRenderAux = gEnv->pRenderer->GetIRenderAuxGeom();
const ColorB visibleColor(0, 255, 0, 128);
const ColorB hiddenColor(255, 0, 0, 128);
const float white[4] = {1.0f, 1.0f, 1.0f, 1.0f};
SAuxGeomRenderFlags oldRenderFlags = pRenderAux->GetRenderFlags();
SAuxGeomRenderFlags newRenderFlags = e_Def3DPublicRenderflags;
newRenderFlags.SetAlphaBlendMode(e_AlphaBlended);
newRenderFlags.SetDepthTestFlag(e_DepthTestOff);
newRenderFlags.SetCullMode(e_CullModeNone);
pRenderAux->SetRenderFlags(newRenderFlags);
TDebugTargets::iterator targetIt = m_debugTargets.begin();
while (targetIt != m_debugTargets.end())
{
SDebugInfo& targetInfo = *targetIt;
const float lastUpdateAge = (currentTime - targetInfo.m_lastUpdatedTime);
const bool remove = (lastUpdateAge > maxDebugLifeTime);
if (!remove)
{
IEntity* pTargetEntity = gEnv->pEntitySystem->GetEntity(targetInfo.m_targetId);
if (pTargetEntity)
{
const ColorB& color = targetInfo.m_visible ? visibleColor : hiddenColor;
const Vec3 worldRefPosition = pTargetEntity->GetWorldTM().TransformPoint(targetInfo.m_localTargetPos);
const Vec3 offset(0.0f, 0.0f, 0.4f);
pRenderAux->DrawCone(worldRefPosition + offset, -Vec3Constants<float>::fVec3_OneZ, 0.125f, offset.z, color);
gEnv->pRenderer->DrawLabelEx(worldRefPosition, 1.5f, white, true, false, "%.2f", lastUpdateAge);
}
++targetIt;
}
else
{
TDebugTargets::iterator nextElement = m_debugTargets.erase(targetIt);
targetIt = nextElement;
}
}
pRenderAux->SetRenderFlags(oldRenderFlags);
}
//------------------------------------------------------------------------
void CVehicleMovementTank::Update(const float deltaTime)
{
CVehicleMovementStdWheeled::Update(deltaTime);
#if ENABLE_VEHICLE_DEBUG
if (IsProfilingMovement())
{
if (m_steeringImpulseMin > 0.f && m_wheelContactsLeft != 0 && m_wheelContactsRight != 0)
{
const Matrix34& worldTM = m_pVehicle->GetEntity()->GetWorldTM();
Vec3 localVel = worldTM.GetInvertedFast().TransformVector(m_statusDyn.v);
Vec3 localW = worldTM.GetInvertedFast().TransformVector(m_statusDyn.w);
float speed = m_statusDyn.v.len();
float speedRatio = min(1.f, speed/m_maxSpeed);
const float maxW = 0.3f*gf_PI;
float steer = abs(m_currSteer)>0.001f ? m_currSteer : 0.f;
float desired = steer * maxW;
float curr = -localW.z;
float err = desired - curr; // err>0 means correction to right
Limit(err, -maxW, maxW);
if (abs(err) > 0.01f)
{
float amount = m_steeringImpulseMin + speedRatio*(m_steeringImpulseMax-m_steeringImpulseMin);
float corr = -err * amount * m_statusDyn.mass * deltaTime;
pe_action_impulse imp;
imp.iApplyTime = 1;
imp.angImpulse = worldTM.GetColumn2() * corr;
float color[] = {1,1,1,1};
gEnv->pRenderer->Draw2dLabel(300,300,1.5f,color,false,"err: %.2f ", err);
gEnv->pRenderer->Draw2dLabel(300,320,1.5f,color,false,"corr: %.3f", corr/m_statusDyn.mass);
IRenderAuxGeom* pGeom = gEnv->pRenderer->GetIRenderAuxGeom();
float len = 4.f * imp.angImpulse.len() / deltaTime / m_statusDyn.mass;
Vec3 dir = (float)-sgn(corr) * worldTM.GetColumn0(); //imp.angImpulse.GetNormalized();
pGeom->DrawCone(worldTM.GetTranslation()+Vec3(0,0,5)-(dir*len), dir, 0.5f, len, ColorB(128,0,0,255));
}
}
}
DebugDrawMovement(deltaTime);
#endif
}
int CScriptBind_Game::DebugDrawCone( IFunctionHandler *pH, float x, float y, float z, float radius, float height, int r, int g, int b, int a )
{
IRenderAuxGeom* pRenderAuxGeom = gEnv->pRenderer->GetIRenderAuxGeom();
if (pRenderAuxGeom)
{
SAuxGeomRenderFlags oldFlags = pRenderAuxGeom->GetRenderFlags();
SAuxGeomRenderFlags newFlags = oldFlags;
newFlags.SetCullMode(e_CullModeNone);
newFlags.SetAlphaBlendMode(e_AlphaBlended);
pRenderAuxGeom->SetRenderFlags(newFlags);
pRenderAuxGeom->DrawCone(Vec3(x,y,z), Vec3(0.f, 0.f, 1.f), radius, height, ColorB(r,g,b,a));
pRenderAuxGeom->SetRenderFlags(oldFlags);
}
return pH->EndFunction();
}
void CPersistantDebug::Update( float frameTime )
{
if (m_objects.empty())
return;
IRenderAuxGeom * pAux = gEnv->pRenderer->GetIRenderAuxGeom();
static const int flags3D = e_Mode3D | e_AlphaBlended | e_DrawInFrontOff | e_FillModeSolid | e_CullModeBack | e_DepthWriteOn | e_DepthTestOn;
static const int flags2D = e_Mode2D | e_AlphaBlended;
std::vector<ListObj::iterator> toClear;
std::vector<MapListObj::iterator> toClearMap;
for (MapListObj::iterator iterMap = m_objects.begin(); iterMap != m_objects.end(); ++iterMap)
{
toClear.resize(0);
for (ListObj::iterator iterList = iterMap->second.begin(); iterList != iterMap->second.end(); ++iterList)
{
iterList->timeRemaining -= frameTime;
if (iterList->timeRemaining <= 0.0f && !(iterList->obj == eOT_EntityTag && iterList->columns.size() > 1))
toClear.push_back(iterList);
else
{
ColorF clr = iterList->clr;
clr.a *= iterList->timeRemaining / iterList->totalTime;
switch (iterList->obj)
{
case eOT_Sphere:
pAux->SetRenderFlags( flags3D );
pAux->DrawSphere( iterList->pos, iterList->radius, clr );
break;
case eOT_Quat:
pAux->SetRenderFlags( flags3D );
{
float r = iterList->radius;
Vec3 x = r * iterList->q.GetColumn0();
Vec3 y = r * iterList->q.GetColumn1();
Vec3 z = r * iterList->q.GetColumn2();
Vec3 p = iterList->pos;
OBB obb = OBB::CreateOBB( Matrix33::CreateIdentity(), Vec3(0.05f,0.05f,0.05f), ZERO );
pAux->DrawOBB( obb, p, false, clr, eBBD_Extremes_Color_Encoded );
pAux->DrawLine( p, ColorF(1,0,0,clr.a), p+x, ColorF(1,0,0,clr.a) );
pAux->DrawLine( p, ColorF(0,1,0,clr.a), p+y, ColorF(0,1,0,clr.a) );
pAux->DrawLine( p, ColorF(0,0,1,clr.a), p+z, ColorF(0,0,1,clr.a) );
}
break;
case eOT_Arrow:
pAux->SetRenderFlags( flags3D );
pAux->DrawLine( iterList->pos - iterList->dir * iterList->radius, clr, iterList->pos + iterList->dir * iterList->radius, clr );
pAux->DrawCone( iterList->pos + iterList->dir * iterList->radius, iterList->dir, 0.1f * iterList->radius, 0.3f * iterList->radius, clr );
break;
case eOT_Line:
pAux->SetRenderFlags( flags3D );
pAux->DrawLine( iterList->pos, clr, iterList->pos + iterList->dir, clr );
break;
case eOT_Cone:
pAux->SetRenderFlags( flags3D );
pAux->DrawCone( iterList->pos, iterList->dir, iterList->radius, iterList->radius2, clr );
break;
case eOT_Cylinder:
pAux->SetRenderFlags( flags3D );
pAux->DrawCylinder( iterList->pos, iterList->dir, iterList->radius, iterList->radius2, clr );
break;
case eOT_AABB:
pAux->SetRenderFlags( flags3D );
pAux->DrawAABB( AABB(iterList->pos,iterList->dir), Matrix34(IDENTITY), false, clr, eBBD_Faceted );
break;
case eOT_Line2D:
pAux->SetRenderFlags( flags2D );
pAux->DrawLine( iterList->pos, clr, iterList->dir, clr );
break;
case eOT_Text:
{
float clrAry[4] = {clr.r, clr.g, clr.b, clr.a};
gEnv->pRenderer->Draw2dLabel( iterList->pos.x, iterList->pos.y, iterList->radius, clrAry, false, "%s", iterList->text.c_str() );
}
break;
case eOT_Disc:
{
pAux->SetRenderFlags( flags3D );
vtx_idx indTriQuad[ 6 ] =
{
0, 2, 1,
0, 3, 2
};
vtx_idx indTriTri[ 3 ] =
{
0, 1, 2
};
int steps = (int)(10 * iterList->radius2);
steps = std::max(steps, 10);
float angStep = gf_PI2 / steps;
for (int i=0; i<steps; i++)
{
float a0 = angStep*i;
float a1 = angStep*(i+1);
float c0 = cosf( a0 );
float c1 = cosf( a1 );
float s0 = sinf( a0 );
float s1 = sinf( a1 );
Vec3 pts[4];
int n, n2;
vtx_idx * indTri;
if (iterList->radius)
{
n = 4;
n2 = 6;
pts[0] = iterList->pos + iterList->radius * Vec3( c0, s0, 0 );
pts[1] = iterList->pos + iterList->radius * Vec3( c1, s1, 0 );
pts[2] = iterList->pos + iterList->radius2 * Vec3( c1, s1, 0 );
pts[3] = iterList->pos + iterList->radius2 * Vec3( c0, s0, 0 );
indTri = indTriQuad;
}
else
{
n = 3;
n2 = 3;
pts[0] = iterList->pos;
pts[1] = pts[0] + iterList->radius2 * Vec3( c0, s0, 0 );
pts[2] = pts[0] + iterList->radius2 * Vec3( c1, s1, 0 );
indTri = indTriTri;
}
pAux->DrawTriangles( pts, n, indTri, n2, clr );
}
}
break;
case eOT_EntityTag:
{
UpdateTags(frameTime, *iterList);
}
break;
}
}
}
while (!toClear.empty())
{
iterMap->second.erase(toClear.back());
toClear.pop_back();
}
if (iterMap->second.empty())
toClearMap.push_back(iterMap);
}
while (!toClearMap.empty())
{
m_objects.erase(toClearMap.back());
toClearMap.pop_back();
}
}
//------------------------------------------------------------------------
void CDebugGun::Update( SEntityUpdateContext& ctx, int update)
{
if (!IsSelected())
return;
static float drawColor[4] = {1,1,1,1};
static const int dx = 5;
static const int dy = 15;
static const float font = 1.2f;
static const float fontLarge = 1.4f;
IRenderer* pRenderer = gEnv->pRenderer;
IRenderAuxGeom* pAuxGeom = pRenderer->GetIRenderAuxGeom();
pAuxGeom->SetRenderFlags(e_Def3DPublicRenderflags);
pRenderer->Draw2dLabel(pRenderer->GetWidth()/5.f, pRenderer->GetHeight()-35, fontLarge, drawColor, false, "Firemode: %s (%.1f)", m_fireModes[m_fireMode].first.c_str(), m_fireModes[m_fireMode].second);
ray_hit rayhit;
int hits = 0;
unsigned int flags = rwi_stop_at_pierceable|rwi_colltype_any;
if (m_fireModes[m_fireMode].first == "pierceability")
{
flags = (unsigned int)m_fireModes[m_fireMode].second & rwi_pierceability_mask;
}
// use cam, no need for firing pos/dir
CCamera& cam = GetISystem()->GetViewCamera();
if (hits = gEnv->pPhysicalWorld->RayWorldIntersection(cam.GetPosition()+cam.GetViewdir(), cam.GetViewdir()*HIT_RANGE, ent_all, flags, &rayhit, 1))
{
IMaterialManager* pMatMan = gEnv->p3DEngine->GetMaterialManager();
IActorSystem* pActorSystem = g_pGame->GetIGameFramework()->GetIActorSystem();
IVehicleSystem* pVehicleSystem = g_pGame->GetIGameFramework()->GetIVehicleSystem();
int x = (int)(pRenderer->GetWidth() *0.5f) + dx;
int y = (int)(pRenderer->GetHeight()*0.5f) + dx - dy;
// draw normal
ColorB colNormal(200,0,0,128);
Vec3 end = rayhit.pt + 0.75f*rayhit.n;
pAuxGeom->DrawLine(rayhit.pt, colNormal, end, colNormal);
pAuxGeom->DrawCone(end, rayhit.n, 0.1f, 0.2f, colNormal);
IEntity * pEntity = (IEntity*)rayhit.pCollider->GetForeignData(PHYS_FOREIGN_ID_ENTITY);
if(pEntity)
{
pRenderer->Draw2dLabel(x, y+=dy, fontLarge, drawColor, false, pEntity->GetName());
}
// material
const char* matName = pMatMan->GetSurfaceType(rayhit.surface_idx)->GetName();
if (matName[0])
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "%s (%i)", matName, rayhit.surface_idx);
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "%.1f m", rayhit.dist);
if (pEntity)
{
IScriptTable* pScriptTable = pEntity->GetScriptTable();
// physics
if (IPhysicalEntity* pPhysEnt = pEntity->GetPhysics())
{
pe_status_dynamics status;
if (pPhysEnt->GetStatus(&status))
{
if (status.mass > 0.f)
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "%.1f kg", status.mass);
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "pe_type: %i", pPhysEnt->GetType());
if (status.submergedFraction > 0.f)
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "%.2f submerged", status.submergedFraction);
if (status.v.len2() > 0.0001f)
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "%.2f m/s", status.v.len());
}
}
if (pScriptTable)
{
HSCRIPTFUNCTION func = 0;
if (pScriptTable->GetValue("GetFrozenAmount", func) && func)
{
float frozen = 0.f;
Script::CallReturn(gEnv->pScriptSystem, func, pScriptTable, frozen);
gEnv->pScriptSystem->ReleaseFunc(func);
if (frozen > 0.f)
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "Frozen: %.2f", frozen);
}
}
// class-specific stuff
if (IActor* pActor = pActorSystem->GetActor(pEntity->GetId()))
{
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "%i health", pActor->GetHealth());
}
else if (IVehicle* pVehicle = pVehicleSystem->GetVehicle(pEntity->GetId()))
{
const SVehicleStatus& status = pVehicle->GetStatus();
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "%.0f%% health", 100.f*status.health);
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "%i passengers", status.passengerCount);
if (pVehicle->GetMovement() && pVehicle->GetMovement()->IsPowered())
{
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "Running");
}
}
else
{
if (pScriptTable)
{
HSCRIPTFUNCTION func = 0;
if (pScriptTable->GetValue("GetHealth", func) && func)
{
float health = 0.f;
if (Script::CallReturn(gEnv->pScriptSystem, func, pScriptTable, health))
{
pRenderer->Draw2dLabel(x, y+=dy, font, drawColor, false, "%.0f health", health);
}
gEnv->pScriptSystem->ReleaseFunc(func);
}
}
}
}
}
}
//------------------------------------------------------------------------
void CVehicleMovementStdBoat::UpdateSurfaceEffects(const float deltaTime)
{
FUNCTION_PROFILER( GetISystem(), PROFILE_GAME );
if (0 == g_pGameCVars->v_pa_surface)
{
ResetParticles();
return;
}
IEntity* pEntity = m_pVehicle->GetEntity();
const Matrix34& worldTM = pEntity->GetWorldTM();
float distSq = worldTM.GetTranslation().GetSquaredDistance(gEnv->pRenderer->GetCamera().GetPosition());
if (distSq > sqr(300.f) || (distSq > sqr(50.f) && !m_pVehicle->GetGameObject()->IsProbablyVisible()))
return;
Matrix34 worldTMInv = worldTM.GetInverted();
const SVehicleStatus& status = m_pVehicle->GetStatus();
float velDot = status.vel * worldTM.GetColumn1();
float powerNorm = min(abs(m_movementAction.power), 1.f);
SEnvironmentParticles* envParams = m_pPaParams->GetEnvironmentParticles();
SEnvParticleStatus::TEnvEmitters::iterator end = m_paStats.envStats.emitters.end();
for (SEnvParticleStatus::TEnvEmitters::iterator emitterIt = m_paStats.envStats.emitters.begin(); emitterIt!=end; ++emitterIt)
{
if (emitterIt->layer < 0)
{
assert(0);
continue;
}
const SEnvironmentLayer& layer = envParams->GetLayer(emitterIt->layer);
SEntitySlotInfo info;
info.pParticleEmitter = 0;
pEntity->GetSlotInfo(emitterIt->slot, info);
float countScale = 1.f;
float sizeScale = 1.f;
float speedScale = 1.f;
float speed = 0.f;
// check if helper position is beneath water level
Vec3 emitterWorldPos = worldTM * emitterIt->quatT.t;
float waterLevel = gEnv->p3DEngine->GetWaterLevel(&emitterWorldPos);
int matId = 0;
if (emitterWorldPos.z <= waterLevel+0.1f && m_physStatus[k_mainThread].submergedFraction<0.999f)
{
matId = gEnv->pPhysicalWorld->GetWaterMat();
speed = status.speed;
bool spray = !strcmp(layer.GetName(), "spray");
if (spray)
{
// slip based
speed -= abs(velDot);
}
GetParticleScale(layer, speed, powerNorm, countScale, sizeScale, speedScale);
}
else
{
countScale = 0.f;
}
if (matId && matId != emitterIt->matId)
{
// change effect
IParticleEffect* pEff = 0;
const char* effect = GetEffectByIndex( matId, layer.GetName() );
if (effect && (pEff = gEnv->pParticleManager->FindEffect(effect)))
{
#if ENABLE_VEHICLE_DEBUG
if (DebugParticles())
CryLog("%s changes water sfx to %s (slot %i)", pEntity->GetName(), effect, emitterIt->slot);
#endif
if (info.pParticleEmitter)
{
info.pParticleEmitter->Activate(false);
pEntity->FreeSlot(emitterIt->slot);
}
emitterIt->slot = pEntity->LoadParticleEmitter(emitterIt->slot, pEff);
if (emitterIt->slot != -1)
pEntity->SetSlotLocalTM(emitterIt->slot, Matrix34(emitterIt->quatT));
info.pParticleEmitter = 0;
pEntity->GetSlotInfo(emitterIt->slot, info);
}
else
countScale = 0.f;
}
if (matId)
emitterIt->matId = matId;
if (info.pParticleEmitter)
{
SpawnParams sp;
sp.fSizeScale = sizeScale;
sp.fCountScale = countScale;
sp.fSpeedScale = speedScale;
info.pParticleEmitter->SetSpawnParams(sp);
if (layer.alignToWater && countScale > 0.f)
{
Vec3 worldPos(emitterWorldPos.x, emitterWorldPos.y, waterLevel+0.05f);
Matrix34 localTM(emitterIt->quatT);
localTM.SetTranslation(worldTMInv * worldPos);
pEntity->SetSlotLocalTM(emitterIt->slot, localTM);
}
}
#if ENABLE_VEHICLE_DEBUG
if (DebugParticles() && m_pVehicle->IsPlayerDriving())
{
float color[] = {1,1,1,1};
ColorB red(255,0,0,255);
IRenderAuxGeom* pAuxGeom = gEnv->pRenderer->GetIRenderAuxGeom();
const char* effect = info.pParticleEmitter ? info.pParticleEmitter->GetName() : "";
const Matrix34& slotTM = m_pEntity->GetSlotWorldTM(emitterIt->slot);
Vec3 ppos = slotTM.GetTranslation();
pAuxGeom->DrawSphere(ppos, 0.2f, red);
pAuxGeom->DrawCone(ppos, slotTM.GetColumn1(), 0.1f, 0.5f, red);
gEnv->pRenderer->Draw2dLabel(50.f, (float)(400+10*emitterIt->slot), 1.2f, color, false, "<%s> water fx: slot %i [%s], speed %.1f, sizeScale %.2f, countScale %.2f (pos %.0f,%0.f,%0.f)", pEntity->GetName(), emitterIt->slot, effect, speed, sizeScale, countScale, ppos.x, ppos.y, ppos.z);
}
#endif
}
// generate water splashes
Vec3 wakePos;
if(m_pSplashPos)
{
wakePos = m_pSplashPos->GetWorldSpaceTranslation();
}
else
{
wakePos = worldTM.GetTranslation();
}
float wakeWaterLevel = gEnv->p3DEngine->GetWaterLevel(&wakePos);
const Vec3& localW = m_localSpeed;
if (localW.x >= 0.f)
m_diving = false;
if (!m_diving && localW.x < -0.03f && status.speed > 10.f && wakePos.z < m_lastWakePos.z && wakeWaterLevel+0.1f >= wakePos.z)
{
float speedRatio = min(1.f, status.speed/(m_maxSpeed*m_factorMaxSpeed));
m_diving = true;
if (m_pWaveEffect)
{
if (IParticleEmitter* pEmitter = pEntity->GetParticleEmitter(m_wakeSlot))
{
pEmitter->Activate(false);
pEntity->FreeSlot(m_wakeSlot);
m_wakeSlot = -1;
}
SpawnParams spawnParams;
spawnParams.fSizeScale = spawnParams.fCountScale = 0.5f + 0.25f*speedRatio;
spawnParams.fSizeScale += 0.4f*m_waveRandomMult;
spawnParams.fCountScale += cry_random(0.0f, 0.4f);
m_wakeSlot = pEntity->LoadParticleEmitter(m_wakeSlot, m_pWaveEffect, &spawnParams);
}
// handle splash sound
ExecuteTrigger(eSID_Splash);
SetSoundParam(eSID_Splash, "intensity", 0.2f*speedRatio + 0.5f*m_waveRandomMult);
if (m_rpmPitchDir == 0)
{
m_rpmPitchDir = -1;
m_waveSoundPitch = 0.f;
m_waveSoundAmount = 0.02f + m_waveRandomMult*0.08f;
}
}
if (m_wakeSlot != -1)
{
// update emitter local pos to short above waterlevel
Matrix34 tm;
if(m_pSplashPos)
m_pSplashPos->GetVehicleTM(tm);
else
tm.SetIdentity();
Vec3 pos = tm.GetTranslation();
pos.z = worldTMInv.TransformPoint(Vec3(wakePos.x,wakePos.y,wakeWaterLevel)).z + 0.2f;
tm.SetTranslation(pos);
pEntity->SetSlotLocalTM(m_wakeSlot, tm);
#if ENABLE_VEHICLE_DEBUG
if (IsProfilingMovement())
{
Vec3 wPos = worldTM * tm.GetTranslation();
ColorB col(128, 128, 0, 200);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawSphere(wPos, 0.4f, col);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawLine(wPos, col, wPos+Vec3(0,0,1.5f), col);
}
#endif
}
m_lastWakePos = wakePos;
}
//----------------------------------------------------------------------------
void CHomingMissile::UpdateCruiseMissile(float frameTime)
{
IRenderer* pRenderer = gEnv->pRenderer;
IRenderAuxGeom* pGeom = pRenderer->GetIRenderAuxGeom();
float color[4] = {1,1,1,1};
const static float step = 15.f;
float y = 20.f;
bool bDebug = g_pGameCVars->i_debug_projectiles > 0;
if (m_targetId)
{
IEntity* pTarget = gEnv->pEntitySystem->GetEntity(m_targetId);
if (pTarget)
{
AABB box;
pTarget->GetWorldBounds(box);
SetDestination( box.GetCenter() );
//if (bDebug)
//pRenderer->Draw2dLabel(5.0f, y+=step, 1.5f, color, false, "Target Entity: %s", pTarget->GetName());
}
}
else
{
// update destination pos from weapon
static IItemSystem* pItemSystem = g_pGame->GetIGameFramework()->GetIItemSystem();
IItem* pItem = pItemSystem->GetItem(m_weaponId);
if (pItem && pItem->GetIWeapon())
{
const Vec3& dest = pItem->GetIWeapon()->GetDestination();
SetDestination( dest );
//if (bDebug)
//pRenderer->Draw2dLabel(5.0f, y+=step, 1.5f, color, false, "Weapon Destination: (%.1f %.1f %.1f)", dest.x, dest.y, dest.z);
}
}
pe_status_dynamics status;
if (!GetEntity()->GetPhysics()->GetStatus(&status))
return;
float currentSpeed = status.v.len();
Vec3 currentPos = GetEntity()->GetWorldPos();
Vec3 goalDir(ZERO);
if (!m_destination.IsZero())
{
if((currentPos-m_destination).len2()<(m_detonationRadius*m_detonationRadius))
{
Explode(true, true, m_destination, -status.v.normalized(), status.v, m_targetId);
return;
}
if (bDebug)
pGeom->DrawCone(m_destination, Vec3(0,0,-1), 2.5f, 7.f, ColorB(255,0,0,255));
float heightDiff = (m_cruiseAltitude-m_alignAltitude) - currentPos.z;
if (!m_isCruising && heightDiff * sgn(status.v.z) > 0.f)
{
// if heading towards align altitude (but not yet reached) accelerate to max speed
if (bDebug)
pRenderer->Draw2dLabel(5.0f, y+=step, 1.5f, color, false, "[HomingMissile] accelerating (%.1f / %.1f)", currentSpeed, m_maxSpeed);
}
else if (!m_isCruising && heightDiff * sgnnz(status.v.z) < 0.f && (status.v.z<0 || status.v.z>0.25f))
{
// align to cruise
if (currentSpeed != 0)
{
goalDir = status.v;
goalDir.z = 0;
goalDir.normalize();
}
if (bDebug)
pRenderer->Draw2dLabel(5.0f, y+=step, 1.5f, color, false, "[HomingMissile] aligning");
}
else
{
if (bDebug)
pRenderer->Draw2dLabel(5.0f, y+=step, 1.5f, color, false, "[HomingMissile] cruising...");
// cruise
m_isCruising = true;
if (!m_destination.IsZero())
{
float groundDistSq = m_destination.GetSquaredDistance2D(currentPos);
float distSq = m_destination.GetSquaredDistance(currentPos);
float descendDistSq = sqr(m_descendDistance);
if (m_isDescending || groundDistSq <= descendDistSq)
{
if (bDebug)
pRenderer->Draw2dLabel(5.0f, y+=step, 1.5f, color, false, "[HomingMissile] descending!");
if (distSq != 0)
goalDir = (m_destination - currentPos).normalized();
else
goalDir.zero();
m_isDescending = true;
}
else
{
Vec3 airPos = m_destination;
airPos.z = currentPos.z;
goalDir = airPos - currentPos;
if (goalDir.len2() != 0)
goalDir.Normalize();
}
}
}
}
float desiredSpeed = currentSpeed;
if (currentSpeed < m_maxSpeed-0.1f)
{
desiredSpeed = min(m_maxSpeed, desiredSpeed + m_accel*frameTime);
}
Vec3 currentDir = status.v.GetNormalizedSafe(FORWARD_DIRECTION);
Vec3 dir = currentDir;
if (!goalDir.IsZero())
{
float cosine = max(min(currentDir.Dot(goalDir), 0.999f), -0.999f);
float goalAngle = RAD2DEG(acos_tpl(cosine));
float maxAngle = m_turnSpeed * frameTime;
if (bDebug)
{
pGeom->DrawCone( currentPos, goalDir, 0.4f, 12.f, ColorB(255,0,0,255) );
pRenderer->Draw2dLabel(5.0f, y+=step, 1.5f, color, false, "[HomingMissile] goalAngle: %.2f", goalAngle);
}
if (goalAngle > maxAngle+0.05f)
dir = (Vec3::CreateSlerp(currentDir, goalDir, maxAngle/goalAngle)).normalize();
else //if (goalAngle < 0.005f)
dir = goalDir;
}
pe_action_set_velocity action;
action.v = dir * desiredSpeed;
GetEntity()->GetPhysics()->Action(&action);
if (bDebug)
{
pGeom->DrawCone( currentPos, dir, 0.4f, 12.f, ColorB(128,128,0,255) );
pRenderer->Draw2dLabel(5.0f, y+=step, 1.5f, color, false, "[HomingMissile] currentSpeed: %.1f (max: %.1f)", currentSpeed, m_maxSpeed);
}
}
