void CActorControllerComponent::UpdateLookDirectionRequest(float frameTime)
{
// The angular velocity maximum (Full rotations / second).
const float angularVelocityMax = g_PI2 * 1.5f;
// The catchup speed (Full rotations / second).
const float catchupSpeed = g_PI2 * 1.2f;
// If there's a player controlling us, we can query them for inputs and camera and apply that to our rotation.
if (auto* pPlayer = m_pActorComponent->GetPlayer())
{
auto* pPlayerInput = pPlayer->GetPlayerInput();
// Only allow the character to rotate in first person, and third person if they are moving.
if ((pPlayer->IsViewFirstPerson()) || (!pPlayer->IsViewFirstPerson() && m_movementRequest.len() > FLT_EPSILON))
{
Ang3 facingDir;
if (pPlayer->IsViewFirstPerson())
facingDir = CCamera::CreateAnglesYPR(Matrix33(m_lookOrientation));
else
facingDir = CCamera::CreateAnglesYPR(m_movementRequest.GetNormalizedFast());
// Use their last orientation as their present direction.
// NOTE: I tried it with GetEntity()->GetWorldTM() but that caused crazy jitter issues.
Ang3 ypr = CCamera::CreateAnglesYPR(Matrix33(m_lookOrientation));
// We add in some extra rotation to 'catch up' to the direction they are being moved. This will perform a gradual
// turn on the actor over several frames.
float rotationDelta { 0.0f };
if (std::abs(facingDir.x - ypr.x) > g_PI)
rotationDelta = ypr.x - facingDir.x;
else
rotationDelta = facingDir.x - ypr.x;
// Catchup allows us to step towards the goal direction in even steps using a set angular velocity.
float catchUp { 0.0f };
if (std::abs(rotationDelta) > FLT_EPSILON)
{
if (rotationDelta > 0.0f)
catchUp = std::min(rotationDelta, catchupSpeed * frameTime);
else
catchUp = std::max(rotationDelta, -catchupSpeed * frameTime);
}
// Update angular velocity metrics.
m_yawAngularVelocity = CLAMP(pPlayerInput->GetMouseYawDelta() + catchUp, -angularVelocityMax * frameTime, angularVelocityMax * frameTime);
// Yaw.
ypr.x += m_yawAngularVelocity;
// Roll (zero it).
ypr.z = 0;
// Update the preferred direction we face.
m_lookOrientation = Quat(CCamera::CreateOrientationYPR(ypr));
}
}
}
//------------------------------------------------------------------------
void CVehicleHelper::GetWorldTM(Matrix34& worldTM) const
{
FUNCTION_PROFILER( gEnv->pSystem, PROFILE_ACTION );
const Matrix34& partWorldTM = m_pParentPart->GetWorldTM();
worldTM = Matrix34(Matrix33(partWorldTM) * Matrix33(m_localTM));
worldTM.SetTranslation((partWorldTM * m_localTM).GetTranslation());
}
//------------------------------------------------------------------------
void CVehicleHelper::GetReflectedWorldTM(Matrix34 &reflectedWorldTM) const
{
FUNCTION_PROFILER( gEnv->pSystem, PROFILE_ACTION );
Matrix34 tempMatrix = m_localTM;
tempMatrix.m03 = -tempMatrix.m03; // negate x coord of translation
const Matrix34& partWorldTM = m_pParentPart->GetWorldTM();
reflectedWorldTM = Matrix34(Matrix33(partWorldTM) * Matrix33(tempMatrix));
reflectedWorldTM.SetTranslation((partWorldTM * tempMatrix).GetTranslation());
}
inline Matrix33
make_matrix33_cols (const Vec3 &a, const Vec3 &b, const Vec3 &c)
{
return Matrix33 (a[0], b[0], c[0],
a[1], b[1], c[1],
a[2], b[2], c[2]);
}
bool Noun::read( const InStream & input )
{
if (! NodeTransform::read( input ) )
return false;
// update the frame of this object..
m_Frame = Matrix33( m_vOrientation );
// ensure the parent pointer is set correctly on our traits
for(size_t i=0;i<m_Traits.size();)
{
if (! m_Traits[i].valid() )
{
LOG_ERROR( "Noun", "Noun::read() - NULL Trait object." );
m_Traits.erase( m_Traits.begin() + i );
continue;
}
m_Traits[i]->setParent( this );
++i;
}
// make sure traits are sorted by name
std::sort( m_Traits.begin(), m_Traits.end(), SortTraits );
m_bPostInit = postInitialize();
// set the last position to the current position
setLastPosition( position() );
return true;
}
bool
ShadingSystemImpl::set_colorspace (ustring colorspace)
{
for (int i = 0; colorSystems[i].name; ++i) {
if (colorspace == colorSystems[i].name) {
m_Red.setValue (colorSystems[i].xRed, colorSystems[i].yRed, 0.0f);
m_Green.setValue (colorSystems[i].xGreen, colorSystems[i].yGreen, 0.0f);
m_Blue.setValue (colorSystems[i].xBlue, colorSystems[i].yBlue, 0.0f);
m_White.setValue (colorSystems[i].xWhite, colorSystems[i].yWhite, 0.0f);
// set z values to normalize
m_Red[2] = 1.0f - (m_Red[0] + m_Red[1]);
m_Green[2] = 1.0f - (m_Green[0] + m_Green[1]);
m_Blue[2] = 1.0f - (m_Blue[0] + m_Blue[1]);
m_White[2] = 1.0f - (m_White[0] + m_White[1]);
const Color3 &R(m_Red), &G(m_Green), &B(m_Blue), &W(m_White);
// xyz -> rgb matrix, before scaling to white.
Color3 r (G[1]*B[2] - B[1]*G[2], B[0]*G[2] - G[0]*B[2], G[0]*B[1] - B[0]*G[1]);
Color3 g (B[1]*R[2] - R[1]*B[2], R[0]*B[2] - B[0]*R[2], B[0]*R[1] - R[0]*B[1]);
Color3 b (R[1]*G[2] - G[1]*R[2], G[0]*R[2] - R[0]*G[2], R[0]*G[1] - G[0]*R[1]);
Color3 w (r.dot(W), g.dot(W), b.dot(W)); // White scaling factor
if (W[1] != 0.0f) // divide by W[1] to scale luminance to 1.0
w *= 1.0f/W[1];
// xyz -> rgb matrix, correctly scaled to white.
r /= w[0];
g /= w[1];
b /= w[2];
m_XYZ2RGB = Matrix33 (r[0], g[0], b[0],
r[1], g[1], b[1],
r[2], g[2], b[2]);
m_RGB2XYZ = m_XYZ2RGB.inverse();
m_luminance_scale = Color3 (m_RGB2XYZ[0][1], m_RGB2XYZ[1][1], m_RGB2XYZ[2][1]);
// Precompute a table of blackbody values
m_blackbody_table.clear ();
float lastT = 0;
for (int i = 0; lastT <= BB_MAX_TABLE_RANGE; ++i) {
float T = powf (float(i), BB_TABLE_XPOWER) * BB_TABLE_SPACING + BB_DRAPER;
lastT = T;
bb_spectrum spec (T);
Color3 rgb = XYZ_to_RGB (spectrum_to_XYZ (spec));
clamp_zero (rgb);
rgb = colpow (rgb, 1.0f/BB_TABLE_YPOWER);
m_blackbody_table.push_back (rgb);
// std::cout << "Table[" << i << "; T=" << T << "] = " << rgb << "\n";
}
// std::cout << "Made " << m_blackbody_table.size() << " table entries for blackbody\n";
#if 0
// Sanity checks
std::cout << "m_XYZ2RGB = " << m_XYZ2RGB << "\n";
std::cout << "m_RGB2XYZ = " << m_RGB2XYZ << "\n";
std::cout << "m_luminance_scale = " << m_luminance_scale << "\n";
#endif
return true;
}
}
return false;
}
static Matrix33 RotateZ(float theta)
{
float sinTheta = sinf(theta);
float cosTheta = cosf(theta);
return Matrix33(cosTheta, -sinTheta, 0.0f,
sinTheta, cosTheta, 0.0f,
0.0f, 0.0f, 1.0f);
}
void Matrix33::Scale(Vector3 const &aScale)
{
float values[9] = {aScale.x, 0, 0,
0, aScale.y, 0,
0, 0, aScale.z};
Matrix33 scaleMatrix = Matrix33(values);
(*this) *= scaleMatrix;
}
Matrix33 CameraIntrinsics::getInvKMatrix33() const
{
double invFocal = k / f;
return Matrix33 (
invFocal, 0.0, -center.x() * invFocal,
0.0, invFocal, -center.y() * invFocal,
0.0, 0.0, 1.0
);
}
Matrix33 CameraIntrinsics::getKMatrix33() const
{
double focal = f / k;
return Matrix33 (
focal, 0.0, center.x(),
0.0, focal, center.y(),
0.0, 0.0, 1.0
);
}
void ProfilerViewer_Imp::DrawTextSprite(Vector2DF position, Color color, astring text)
{
m_renderer->AddText(
Matrix33().SetIdentity(),
Matrix33().SetTranslation(position.X, position.Y),
Vector2DF(),
false,
false,
color,
m_font.get(),
text.c_str(),
WritingDirection::Horizontal,
AlphaBlendMode::Blend,
1,
0,
0,
false);
}
//------------------------------------------------------------------------
IMPLEMENT_RMI(CC4Projectile, ClSetPosition)
{
Matrix34 mat;
mat.SetRotation33(Matrix33(params.rot));
mat.SetTranslation(params.pos);
GetEntity()->SetWorldTM(mat);
m_stuck = true;
return true;
}
//------------------------------------------------------------------------
const Matrix33 &CItem::GetSlotHelperRotation(int slot, const char *helper, bool worldSpace, bool relative)
{
static Matrix33 rotation;
rotation.SetIdentity();
IEntity* pEntity = GetEntity();
if(!pEntity)
return rotation;
SEntitySlotInfo info;
if (pEntity->GetSlotInfo(slot, info))
{
if (info.pStatObj)
{
IStatObj *pStatObj = info.pStatObj;
rotation = Matrix33(pStatObj->GetHelperTM(helper));
rotation.OrthonormalizeFast();
rotation = Matrix33(GetEntity()->GetSlotLocalTM(slot, false))*rotation;
}
else if (info.pCharacter)
{
ICharacterInstance *pCharacter = info.pCharacter;
if(!pCharacter)
return rotation;
IAttachment* pAttachment = pCharacter->GetIAttachmentManager()->GetInterfaceByName(helper);
if(pAttachment)
{
rotation = Matrix33(worldSpace ? pAttachment->GetAttWorldAbsolute().q : pAttachment->GetAttModelRelative().q);
return rotation;
}
else
{
ICharacterModelSkeleton* pICharacterModelSkeleton = pCharacter->GetICharacterModel()->GetICharacterModelSkeleton();
ISkeletonPose* pSkeletonPose = pCharacter->GetISkeletonPose();
int16 id = pICharacterModelSkeleton->GetJointIDByName(helper);
if (id > -1)
{
rotation = relative ? Matrix33(pSkeletonPose->GetRelJointByID(id).q) : Matrix33(pSkeletonPose->GetAbsJointByID(id).q);
}
}
if (!relative)
{
rotation = Matrix33(pEntity->GetSlotLocalTM(slot, false)) * rotation;
}
}
}
if (worldSpace)
{
rotation = Matrix33(pEntity->GetWorldTM()) * rotation;
}
return rotation;
}
//-------------------------------------------------------------------------
IMPLEMENT_RMI(CC4Projectile, ClStickToEntity)
{
if(IEntity *pEntity = gEnv->pEntitySystem->GetEntity(params.targetId))
{
Matrix34 localMatrix;
localMatrix.SetRotation33(Matrix33(params.localRotation));
localMatrix.SetTranslation(params.localCollisonPos);
StickToEntity(pEntity,localMatrix);
}
return true;
}
void CPlayerView::ViewThirdPersonDirected(SViewParams &viewParams)
{
if (m_in.thirdPersonYaw>0.001f)
{
viewParams.rotation *= Quat::CreateRotationXYZ(Ang3(0,0,m_in.thirdPersonYaw * gf_PI/180.0f));
m_io.viewQuatFinal = Matrix33(viewParams.rotation);
}
if (m_io.bUsePivot)
viewParams.position += m_io.viewQuatFinal.GetColumn1() * m_in.params_viewDistance + m_io.viewQuatFinal.GetColumn2() * (0.25f + m_in.params_viewHeightOffset);
else
viewParams.position += m_io.viewQuatFinal.GetColumn1() * -m_in.thirdPersonDistance + m_io.viewQuatFinal.GetColumn2() * (0.25f + m_in.params_viewHeightOffset);
}
bool NounShip::read( const InStream & input )
{
if (! NounBody::read( input ) )
return false;
// make sure we have all our traits after serialization
if (! findTrait( TraitReplication::classKey() ) )
attachTrait( new TraitReplication() );
if (! findTrait( TraitMovement::classKey() ) )
attachTrait( new TraitMovement() );
if (! findTrait( TraitOrbit::classKey() ) )
attachTrait( new TraitOrbit() );
m_fHeading = m_fSetHeading = m_vOrientation.m_fYaw;
m_fLastSetHeading = m_fSetHeading;
m_fLastSetVelocity = m_fSetVelocity;
m_fLastYaw = m_fYaw;
// a bug caused these values to go NAN when all the drives were removed from the ship
#if defined(_WIN32)
if ( _isnan( m_fHeading ) )
m_fHeading = 0.0f;
if ( _isnan( m_fVelocity ) )
m_fVelocity = 0.0f;
#else
if ( isnan( m_fHeading ) )
m_fHeading = 0.0f;
if ( isnan( m_fVelocity ) )
m_fVelocity = 0.0f;
#endif
// update the ship frame
m_Frame = Matrix33( m_fPitch, m_fHeading, m_fRoll );
initializeGadgets();
initializeEnhancements();
updateCharacter();
updateDamageBits();
// reset and reapply all modifiers
resetModifiers();
for(int i=0;i<m_Enhancements.size();++i)
m_Enhancements[i]->applyModifiers( true );
// until we add slots for enhancements, just set max to 8
// TODO: Add
m_MaxEnhancements = 8;
m_nIgnoreCollisionTick = 0;
return true;
}
//FIXME:use the animated character view filter for this
void CPlayerView::ViewFollowCharacterFirstPerson(SViewParams &viewParams)
{
viewParams.viewID = 3;
//to avoid clipping
viewParams.nearplane = 0.1f;
viewParams.position = m_in.entityWorldMatrix *m_in.localEyePos;
if (m_in.stats_isRagDoll)
viewParams.position.z += 0.05f;
if (m_in.stats_followCharacterHead)
viewParams.rotation = Quat(Matrix33(m_in.entityWorldMatrix)*m_in.headMtxLocal*Matrix33::CreateRotationY(gf_PI*0.5f));
}
void Run
(
)
{
Vector2 test = Vector2::One();
Vector3 z = Cross(Vector3::Integer<1, 0, 0>(), Vector3::Integer<0, 1, 0>());
Vector1 length = Length(Vector3::Integer<1>());
Assert(length < Vector1::Integer<2>());
Matrix33 testMat = Matrix33(Vector3::Integer<1, 2, 3>(), Vector3::Integer<4, 5, 6>(), Vector3::Integer<7, 8, 9>());
Matrix33 testTran = Transpose(testMat);
}
bool CCannonBall::RayTraceGeometry( const EventPhysCollision* pCollision, const Vec3& pos, const Vec3& hitDirection, SBackHitInfo* pBackHitInfo )
{
FUNCTION_PROFILER(GetISystem(), PROFILE_GAME);
bool exitPointFound = false;
IPhysicalEntity* pCollider = pCollision->pEntity[1];
assert(pCollider);
pe_params_part partParams;
partParams.partid = pCollision->partid[1];
pe_status_pos posStatus;
if (pCollider->GetParams(&partParams) && pCollider->GetStatus(&posStatus))
{
if (partParams.pPhysGeom && partParams.pPhysGeom->pGeom)
{
geom_world_data geomWorldData;
geomWorldData.R = Matrix33(posStatus.q*partParams.q);
geomWorldData.offset = posStatus.pos + (posStatus.q * partParams.pos);
geomWorldData.scale = posStatus.scale * partParams.scale;
geom_contact *pContacts;
intersection_params intersectionParams;
IGeometry* pRayGeometry = s_pRayWrapper->GetRay(pos, hitDirection);
const Vec3 hitDirectionNormalized = hitDirection.GetNormalized();
{ WriteLockCond lock;
const int contactCount = partParams.pPhysGeom->pGeom->IntersectLocked(pRayGeometry,&geomWorldData,0,&intersectionParams,pContacts,lock);
if (contactCount > 0)
{
float bestDistance = 10.0f;
for (int i = (contactCount-1); (i >= 0) && (pContacts[i].t < bestDistance) && ((pContacts[i].n*hitDirectionNormalized) < 0); i--)
{
bestDistance = (float)pContacts[i].t;
pBackHitInfo->pt = pContacts[i].pt;
exitPointFound = true;
}
}
} // lock
}
}
s_pRayWrapper->ResetRay();
return exitPointFound;
}
void NodeScale::preRender( RenderContext & context, const Matrix33 & frame, const Vector3 & position )
{
float t = context.time();
float t2 = t * t;
float x = (m_XV * t) + (( 0.5f * m_XA ) * t2) + 1.0f;
float y = (m_YV * t) + (( 0.5f * m_YA ) * t2) + 1.0f;
float z = (m_ZV * t) + (( 0.5f * m_ZA ) * t2) + 1.0f;
m_Frame = Matrix33( Vector3(1,0,0) * x,
Vector3(0,1,0) * y,
Vector3(0,0,1) * z );
// call the base class
NodeTransform::preRender( context, frame, position );
}
int CScriptBind_Physics::SamplePhysEnvironment(IFunctionHandler *pH)
{
int nEnts,i,nHits=0,objtypes = ent_static|ent_rigid|ent_sleeping_rigid|ent_sort_by_mass;
pe_status_nparts snp;
pe_status_pos sp;
IPhysicalEntity **pEnts;
geom_world_data gwd;
IGeometry *pSphere;
primitives::sphere sph;
intersection_params ip;
geom_contact *pcontacts;
IPhysicalWorld *pWorld = m_pSystem->GetIPhysicalWorld();
IEntity *pEntity;
SmartScriptTable pObj(m_pSS);
ip.bStopAtFirstTri=ip.bNoBorder=ip.bNoAreaContacts = true;
ip.bThreadSafe = true;
if (!pH->GetParams(sph.center,sph.r))
return pH->EndFunction();
if (pH->GetParamCount()>2)
pH->GetParam(3,objtypes);
pSphere = pWorld->GetGeomManager()->CreatePrimitive(primitives::sphere::type,&sph);
nEnts = pWorld->GetEntitiesInBox(sph.center-Vec3(sph.r),sph.center+Vec3(sph.r),pEnts,objtypes);
for(i=0;i<nEnts;i++) for(sp.ipart=pEnts[i]->GetStatus(&snp)-1;sp.ipart>=0;sp.ipart--)
{
sp.partid=-1; pEnts[i]->GetStatus(&sp);
gwd.offset=sp.pos; gwd.R=Matrix33(sp.q); gwd.scale=sp.scale;
WriteLockCond lock;
if ((sp.flagsOR & (geom_colltype0|geom_no_coll_response))==geom_colltype0 && sp.pGeomProxy->IntersectLocked(pSphere,&gwd,0,&ip,pcontacts,lock))
{
++nHits;
if (pEntity = (IEntity*)pEnts[i]->GetForeignData(PHYS_FOREIGN_ID_ENTITY))
pObj->SetAt(nHits*3-2, pEntity->GetScriptTable());
else
pObj->SetNullAt(nHits*3-2);
pObj->SetAt(nHits*3-1, sp.partid);
pObj->SetAt(nHits*3, pWorld->GetPhysicalEntityId(pEnts[i]));
if (pEnts[i]->GetType()!=PE_ARTICULATED)
break;
}
}
pSphere->Release();
return pH->EndFunction(*pObj);
}
//------------------------------------------------------------------------
void CVehicleActionDeployRope::AttachOnRope(IEntity *pEntity)
{
assert(pEntity);
if(!pEntity)
return;
IRopeRenderNode *pRopeUpper = GetRopeRenderNode(m_ropeUpperId);
if(!pRopeUpper)
return;
assert(pRopeUpper->GetPointsCount() >= 2);
IPhysicalEntity *pRopePhys = pRopeUpper->GetPhysics();
assert(pRopePhys);
typedef std::vector <Vec3> TVec3Vector;
TVec3Vector points;
int pointCount;
pe_status_rope ropeStatus;
if(pRopePhys->GetStatus(&ropeStatus))
pointCount = ropeStatus.nSegments + 1;
else
pointCount = 0;
if(pointCount < 2)
return;
points.resize(pointCount);
ropeStatus.pPoints = &points[0];
if(pRopePhys->GetStatus(&ropeStatus))
{
Matrix34 worldTM;
worldTM.SetIdentity();
worldTM = Matrix33(m_pVehicle->GetEntity()->GetWorldTM());
worldTM.SetTranslation(ropeStatus.pPoints[1]);
pEntity->SetWorldTM(worldTM);
}
pRopeUpper->LinkEndEntities(m_pVehicle->GetEntity()->GetPhysics(), pEntity->GetPhysics());
}
//------------------------------------------------------------------------
const Matrix33 &CItem::GetSlotHelperRotation(int slot, const char *helper, bool worldSpace, bool relative)
{
// if mounted force the slot to be 1st person
if(m_stats.mounted)
slot=eIGS_FirstPerson;
static Matrix33 rotation;
rotation.SetIdentity();
IEntity *pEntity = GetEntity();
if(!pEntity)
return rotation;
SEntitySlotInfo info;
if(pEntity->GetSlotInfo(slot, info))
{
if(info.pStatObj)
{
IStatObj *pStatObj = info.pStatObj;
rotation = Matrix33(pStatObj->GetHelperTM(helper));
rotation.OrthonormalizeFast();
rotation = Matrix33(GetEntity()->GetSlotLocalTM(slot, false))*rotation;
}
else if(info.pCharacter)
{
ICharacterInstance *pCharacter = info.pCharacter;
if(!pCharacter)
return rotation;
int16 id = pCharacter->GetISkeletonPose()->GetJointIDByName(helper);
// if (id > -1) rotation = Matrix33(pCharacter->GetISkeleton()->GetAbsJMatrixByID(id));
if(id > -1)
{
if(relative)
rotation = Matrix33(pCharacter->GetISkeletonPose()->GetRelJointByID(id).q);
else
rotation = Matrix33(pCharacter->GetISkeletonPose()->GetAbsJointByID(id).q);
}
if(!relative)
rotation = Matrix33(pEntity->GetSlotLocalTM(slot, false))*rotation;
}
}
if(worldSpace)
rotation=Matrix33(pEntity->GetWorldTM())*rotation;
return rotation;
}
void CubeMapManager::UpdateCameraOrientation( int face )
{
Vector3 vDir, vUp, vRight;
switch(face)
{
case 0: vRight = Vector3( 0, 0,-1); vUp = Vector3( 0, 1, 0); vDir = Vector3( 1, 0, 0); break; // pos-x
case 1: vRight = Vector3( 0, 0, 1); vUp = Vector3( 0, 1, 0); vDir = Vector3(-1, 0, 0); break; // neg-x
case 2: vRight = Vector3( 1, 0, 0); vUp = Vector3( 0, 0,-1); vDir = Vector3( 0, 1, 0); break; // pos-y
case 3: vRight = Vector3( 1, 0, 0); vUp = Vector3( 0, 0, 1); vDir = Vector3( 0,-1, 0); break; // neg-y
case 4: vRight = Vector3( 1, 0, 0); vUp = Vector3( 0, 1, 0); vDir = Vector3( 0, 0, 1); break; // pos-z
case 5: vRight = Vector3(-1, 0, 0); vUp = Vector3( 0, 1, 0); vDir = Vector3( 0, 0,-1); break; // neg-z
default:
break;
}
m_Camera.SetOrientation( Matrix33( vRight, vUp, vDir ) );
}
//------------------------------------------------------------------------
void CVehicleActionEntityAttachment::Update(const float deltaTime)
{
if(m_isAttached)
return;
IEntitySystem *pEntitySystem = gEnv->pEntitySystem;
assert(pEntitySystem);
IEntity *pEntity = pEntitySystem->GetEntity(m_entityId);
if(!pEntity)
return;
IPhysicalEntity *pPhysEntity = pEntity->GetPhysics();
if(!pPhysEntity)
return;
pe_simulation_params paramsSim;
float gravity;
if(pPhysEntity->GetParams(¶msSim))
gravity = abs(paramsSim.gravity.z);
else
gravity = 9.82f;
pe_status_dynamics dyn;
if(pPhysEntity->GetStatus(&dyn))
{
pe_action_impulse impulse;
impulse.impulse = Matrix33(pEntity->GetWorldTM()) * Vec3(0.0f, 0.0f, 1.0f) * g_parachuteForce * gravity;
impulse.impulse = impulse.impulse - dyn.v;
impulse.impulse *= dyn.mass * deltaTime;
impulse.iSource = 3;
pPhysEntity->Action(&impulse);
}
m_timer -= deltaTime;
if(m_timer <= 0.0f || dyn.v.z >= 0.0f)
m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_NoUpdate);
}
void CStickyProjectile::NetSetStuck(CProjectile* pProjectile, bool stuck)
{
if(stuck && ((m_flags&eSF_IsStuck)==0))
{
IEntity* pTargetEntity = gEnv->pEntitySystem->GetEntity(m_parentId);
if(pTargetEntity)
{
if(ICharacterInstance* pTargetCharacter = pTargetEntity->GetCharacter(0))
{
const char* boneName = pTargetCharacter->GetICharacterModel()->GetICharacterModelSkeleton()->GetJointNameByID(m_stuckJoint);
if(AttachToCharacter(pProjectile, *pTargetEntity, *pTargetCharacter, boneName))
{
IActor* pActor = g_pGame->GetIGameFramework()->GetIActorSystem()->GetActor(pTargetEntity->GetId());
m_flags |= eSF_IsStuck;
m_flags |= pActor ? pActor->IsPlayer() ? eSF_StuckToPlayer : eSF_StuckToAI : 0;
m_childId = pProjectile->GetEntityId();
}
}
}
if((m_flags&eSF_IsStuck)==0)
{
IEntity* pProjectileEntity = pProjectile->GetEntity();
AttachTo(pProjectile, pTargetEntity);
m_childId = pProjectileEntity->GetId();
if(pTargetEntity) //If we have a parent then the stuck position/rotation are local to the parent
{
pProjectileEntity->SetPos(m_stuckPos);
pProjectileEntity->SetRotation(m_stuckRot);
}
else if(m_flags&eSF_OrientateToCollNormal)
{
Matrix34 mat;
mat.SetTranslation(m_stuckPos);
mat.SetRotation33(Matrix33(m_stuckRot));
pProjectileEntity->SetWorldTM(mat);
}
else
{
pProjectileEntity->SetPos(m_stuckPos);
}
m_flags |= eSF_IsStuck;
}
}
}
CRRCMath::Matrix33 CRRCMath::Quaternion_002::initFromEuler(CRRCMath::Vector3 eul)
{
Matrix33 mat2;
double s0 = sin(eul.r[0]);
double c0 = cos(eul.r[0]);
double s1 = sin(eul.r[1]);
double c1 = cos(eul.r[1]);
double s2 = sin(eul.r[2]);
double c2 = cos(eul.r[2]);
// Berechnung der Matrix A aus [1], S.12, Formel (2.1)
// Damit gilt mat2 * v_local = v_body
mat2 = Matrix33(c1*c2, s2*c1, -s1,
c2*s1*s0-s2*c0, s2*s1*s0+c2*c0, c1*s0,
c2*s1*c0+s2*s0, s2*s1*c0-c2*s0, c1*c0);
return(mat2);
}
//-----------------------------------------------------------------------
void CVehiclePartLight::UpdateLight(const float frameTime)
{
if (m_slot == -1)
return;
// move to vehicle event change view?
if (m_diffuseMult[0] != m_diffuseMult[1])
{
SEntitySlotInfo info;
if (m_pVehicle->GetEntity()->GetSlotInfo(m_slot, info) && info.pLight)
{
CDLight& light = info.pLight->GetLightProperties();
IActor* pActor = CCryAction::GetCryAction()->GetClientActor();
bool localPlayer = (pActor != NULL) && (pActor->GetLinkedVehicle() == m_pVehicle);
IVehicleSeat* pSeat = pActor ? m_pVehicle->GetSeatForPassenger(pActor->GetEntityId()) : NULL;
IVehicleView* pView = pSeat? pSeat->GetView(pSeat->GetCurrentView()) : NULL;
bool isThirdPersonView = pView? pView->IsThirdPerson() : true;
if (localPlayer && !isThirdPersonView)
light.SetLightColor(ColorF(m_diffuseCol * m_diffuseMult[0], 1.f));
else
light.SetLightColor(ColorF(m_diffuseCol * m_diffuseMult[1], 1.f));
}
}
if (m_pHelper)
{
const static Matrix33 rot(Matrix33::CreateRotationXYZ(Ang3(0.f, 0.f, DEG2RAD(90.f))));
Matrix34 helperTM;
m_pHelper->GetVehicleTM(helperTM);
Matrix34 localTM = Matrix33(helperTM) * rot;
localTM.SetTranslation(helperTM.GetTranslation());
GetEntity()->SetSlotLocalTM(m_slot, localTM);
}
}
void CActorControllerComponent::UpdateAnimation(float frameTime)
{
if (auto* pPlayer = m_pActorComponent->GetPlayer())
{
// Radians / sec
const float angularVelocityMin = 0.174f;
// Update tags and motion parameters used for turning
const bool isTurning = std::abs(m_yawAngularVelocity) > angularVelocityMin;
// Resolve the animation tags.
// HACK: This should be done once on init or on entity changed events or similar. It fails hard if the init order is switched with CAdvancedAnimationComponent.
if ((m_rotateTagId == TAG_ID_INVALID) && (strlen(m_pAdvancedAnimationComponent->GetControllerDefinitionFile()) > 0))
m_rotateTagId = m_pAdvancedAnimationComponent->GetTagId("Rotate");
// Set the tag, if it exists.
if (m_rotateTagId != TAG_ID_INVALID)
m_pAdvancedAnimationComponent->SetTagWithId(m_rotateTagId, isTurning);
if (isTurning)
{
// Expect the turning motion to take approximately one second.
// TODO: Get to work on making this happen more like Blade and Soul.
const float turnDuration = 1.0f;
m_pAdvancedAnimationComponent->SetMotionParameter(eMotionParamID_TurnAngle, m_yawAngularVelocity * turnDuration);
}
// Update entity rotation as the player turns. We only want to affect Z-axis rotation, zero pitch and roll.
// TODO: is there a case where we want to avoid zeroing out pitch and roll?
Ang3 ypr = CCamera::CreateAnglesYPR(Matrix33(m_lookOrientation));
ypr.y = 0;
ypr.z = 0;
const Quat correctedOrientation = Quat(CCamera::CreateOrientationYPR(ypr));
// Send updated transform to the entity, only orientation changes.
GetEntity()->SetPosRotScale(GetEntity()->GetWorldPos(), correctedOrientation, Vec3(1, 1, 1));
}
}
void CBoundingContainer::HideContainedItems()
{
IEntity* pEntity = GetEntity();
if (pEntity)
{
// Proximity query all entities in area
AABB aabbBounds(m_vBoundingMin, m_vBoundingMax);
OBB obbBounds;
Matrix34 worldTM = pEntity->GetWorldTM();
obbBounds.SetOBBfromAABB(Matrix33(worldTM), aabbBounds);
aabbBounds.Reset();
aabbBounds.SetAABBfromOBB(pEntity->GetWorldPos(), obbBounds);
SEntityProximityQuery query;
query.box = aabbBounds;
gEnv->pEntitySystem->QueryProximity(query);
const int iQueryCount = query.nCount;
for (int i = 0; i < iQueryCount; ++i)
{
IEntity* pQueryEntity = query.pEntities[i];
if (pQueryEntity)
{
const EntityId queryEntityId = pQueryEntity->GetId();
if (!stl::find(m_hiddenEntities, queryEntityId)) // Only if not already hidden
{
// Make sure entity type should be hidden and entity pos is also inside, not just an intersection
if (ShouldHide(queryEntityId, pQueryEntity) && aabbBounds.IsContainPoint(pQueryEntity->GetWorldPos()))
{
pQueryEntity->Hide(true);
m_hiddenEntities.push_back(pQueryEntity->GetId());
}
}
}
}
}
}