//------------------------------------------------------------------------
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;
}
//------------------------------------------------------------------------
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;
}
//
// Extract the various modifiers out into their own function.
//
// Aim is to make the code easier to understand and modify, as
// well as to ease the addition of new modifiers.
//
void CPlayerView::ViewFirstPerson(SViewParams &viewParams)
{
//headbob
Ang3 angOffset(0,0,0);
Vec3 weaponOffset(0,0,0);
Ang3 weaponAngleOffset(0,0,0);
// jump/land spring effect. Adjust the eye and weapon pos as required.
FirstPersonJump(viewParams,weaponOffset,weaponAngleOffset);
//float standSpeed(GetStanceMaxSpeed(STANCE_STAND));
Vec3 vSpeed(0,0,0);
if (m_in.standSpeed>0.001f)
vSpeed = (m_in.stats_velocity / m_in.standSpeed);
float vSpeedLen(vSpeed.len());
if (vSpeedLen>1.5f)
vSpeed = vSpeed / vSpeedLen * 1.5f;
float speedMul(0);
if (m_in.standSpeed>0.001f)
speedMul=(m_in.stats_flatSpeed / m_in.standSpeed * 1.1f);
speedMul = min(1.5f,speedMul);
bool crawling(m_in.stance==STANCE_PRONE /*&& m_in.stats_flatSpeed>0.1f*/ && m_in.stats_onGround>0.1f);
bool weaponZoomed = false;
bool weaponZomming = false;
//Not crawling while in zoom mode
IActor *owner = gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(m_in.entityId);
if(owner && owner->IsPlayer())
{
IItem *pItem = owner->GetCurrentItem();
if(pItem)
{
CWeapon *pWeapon = static_cast<CWeapon*>(pItem->GetIWeapon());
if(pWeapon)
{
weaponZoomed = pWeapon->IsZoomed();
weaponZomming = pWeapon->IsZooming();
if(weaponZoomed||weaponZomming||pWeapon->IsModifying())
crawling = false;
}
}
}
// On the ground.
if (m_in.stats_inAir < 0.1f /*&& m_in.stats_inWater < 0.1f*/)
{
//--- Bobbing.
// bobCycle is a speed varying time step running (looping) from 0 to 1
// this feeds into a sin eqn creating a double horizontal figure of 8.
// ( a lissajous figure with the vertical freq twice the horz freq ).
// To tweak the total speed of the curve:
// To tweak the effect speed has on the curve:
float kSpeedToBobFactor=1.15f;//0.9f
// To tweak the width of the bob:
float kBobWidth=0.1f;
// To tweak the height of the bob:
float kBobHeight=0.05f;
// To tweak the scale of strafing lag: (may need to manually adjust the strafing angle offsets as well.)
const float kStrafeHorzScale=0.05f;
kBobWidth = 0.15f;
kBobHeight = 0.06f;
m_io.stats_bobCycle += m_in.frameTime * kSpeedToBobFactor * speedMul;// * (m_in.bSprinting?1.25f:1.0f);
//if player is standing set the bob to rest. (bobCycle reaches 1.0f within 1 second)
if (speedMul < 0.1f)
m_io.stats_bobCycle = min(m_io.stats_bobCycle + m_in.frameTime * 1.0f,1.0f);
// bobCycle loops between 0 and 1
if (m_io.stats_bobCycle>1.0f)
m_io.stats_bobCycle = m_io.stats_bobCycle - 1.0f;
if (crawling)
kBobWidth *= 2.0f * speedMul;
else if (m_in.bSprinting)
kBobWidth *= 1.25f * speedMul;
//set the bob offset
Vec3 bobDir(cry_sinf(m_io.stats_bobCycle*gf_PI*2.0f)*kBobWidth*speedMul,0,cry_sinf(m_io.stats_bobCycle*gf_PI*4.0f)*kBobHeight*speedMul);
//not the bob offset for the weapon
bobDir *= 0.25f;
//if player is strafing shift a bit the weapon on left/right
if (speedMul > 0.01f)
{
// right vector dot speed vector
float dot(m_io.viewQuatFinal.GetColumn0() * vSpeed);
bobDir.x -= dot * kStrafeHorzScale; // the faster we move right, the more the gun lags to the left and vice versa
//tweak the right strafe for weapon laser
if (dot>0.0f)
weaponAngleOffset.z += dot * 1.5f; // kStrafeHorzScale
else
weaponAngleOffset.z -= dot * 2.0f; // kStrafeHorzScale
weaponAngleOffset.y += dot * 5.0f; // kStrafeHorzScale
}
//CryLogAlways("bobDir.z: %f", bobDir.z);
if (bobDir.z < 0.0f)
{
bobDir.x *= 1.0f;
bobDir.y *= 1.0f;
bobDir.z *= 0.35f;
speedMul *= 0.65f;
}
else
bobDir.z *= 1.85f;
//CryLogAlways("bobDir.z: %f after", bobDir.z);
weaponOffset += m_io.viewQuatFinal * bobDir;
weaponOffset -= m_io.baseQuat.GetColumn2() * 0.035f * speedMul;
weaponAngleOffset.y += cry_sinf(m_io.stats_bobCycle*gf_PI*2.0f) * speedMul * -1.5f;
if (crawling)
weaponAngleOffset.y *= 3.0f;
weaponAngleOffset.x += speedMul * 1.5f;
if (crawling)
weaponAngleOffset.z += cry_sinf(m_io.stats_bobCycle*gf_PI*2.0f) * speedMul * 3.0f;
//FIXME: viewAngles must include all the view offsets, otherwise aiming wont be precise.
angOffset.x += cry_sinf(m_io.stats_bobCycle*gf_PI*4.0f)*0.7f*speedMul;
if (crawling)
{
angOffset.x *= 2.5f;
angOffset.y += cry_sinf(m_io.stats_bobCycle*gf_PI*2.0f)*1.25f*speedMul;
angOffset.z -= cry_sinf(m_io.stats_bobCycle*gf_PI*2.0f)*2.5f*speedMul;
}
else if (m_in.bSprinting)
{
angOffset.x *= 2.5f;
angOffset.y += cry_sinf(m_io.stats_bobCycle*gf_PI*2.0f)*1.0f*speedMul;
angOffset.z -= cry_sinf(m_io.stats_bobCycle*gf_PI*2.0f)*2.25f*speedMul;
}
else if(m_in.stance==STANCE_CROUCH && !weaponZoomed && !weaponZomming)
{
weaponOffset.z += 0.035f;
weaponOffset.y -= m_io.viewQuatFinal.GetColumn1().y * 0.03f;
}
else if(m_in.stance==STANCE_CROUCH && weaponZomming)
{
weaponOffset.z -= 0.07f;
weaponOffset.y += m_io.viewQuatFinal.GetColumn1().y * 0.06f;
}
else
{
//angOffset.x *= 2.25f;
//angOffset.y += cry_sinf(m_io.stats_bobCycle*gf_PI*2.0f)*0.5f*speedMul;
//angOffset.z -= cry_sinf(m_io.stats_bobCycle*gf_PI*2.0f)*1.125f*speedMul;
}
}
else
{
m_io.stats_bobCycle = 0;
//while flying offset a bit the weapon model by the player speed
if (m_in.stats_velocity.len2()>0.001f)
{
float dotFwd(m_io.viewQuatFinal.GetColumn1() * vSpeed);
float dotSide(m_io.viewQuatFinal.GetColumn0() * vSpeed);
float dotUp(m_io.viewQuatFinal.GetColumn2() * vSpeed);
weaponOffset += m_io.viewQuatFinal * Vec3(dotSide * -0.05f,dotFwd * -0.035f,dotUp * -0.05f);
weaponAngleOffset.x += dotUp * 2.0f;
weaponAngleOffset.y += dotSide * 5.0f;
weaponAngleOffset.z -= dotSide * 2.0f;
}
}
//add some inertia to weapon due view direction change.
float deltaDotSide(m_io.vFPWeaponLastDirVec * m_io.viewQuatFinal.GetColumn0());
float deltaDotUp(m_io.vFPWeaponLastDirVec * m_io.viewQuatFinal.GetColumn2());
weaponOffset += m_io.viewQuatFinal * Vec3(deltaDotSide * 0.1f + m_in.stats_leanAmount * 0.05f,0,deltaDotUp * 0.1f - fabs(m_in.stats_leanAmount) * 0.05f) * m_in.params_weaponInertiaMultiplier;
weaponAngleOffset.x -= deltaDotUp * 5.0f * m_in.params_weaponInertiaMultiplier;
weaponAngleOffset.z += deltaDotSide * 5.0f * m_in.params_weaponInertiaMultiplier;
weaponAngleOffset.y += deltaDotSide * 5.0f * m_in.params_weaponInertiaMultiplier;
if(m_in.stats_leanAmount<0.0f)
weaponAngleOffset.y += m_in.stats_leanAmount * 5.0f;
//the weapon model tries to stay parallel to the terrain when the player is freefalling/parachuting
if (m_in.stats_inWater > 0.0f)
weaponOffset -= m_io.viewQuat.GetColumn2() * 0.15f;
if (m_in.stats_inWater>0.1f && !m_in.stats_headUnderWater)
{
Ang3 offset(m_io.viewQuatFinal);
offset.z = 0;
if (offset.x<0.0f)
offset.x = 0;
weaponAngleOffset -= offset*(180.0f/gf_PI)*0.75f;
}
else if (m_io.stats_inFreefall)
{
Ang3 offset(m_io.viewQuatFinal);
offset.z = 0;
weaponAngleOffset -= offset*(180.0f/gf_PI)*0.5f;
}
//same thing with crawling
else if (crawling)
{
//FIXME:to optimize, looks like a bit too expensive
Vec3 forward(m_io.viewQuatFinal.GetColumn1());
Vec3 up(m_io.baseQuat.GetColumn2());
Vec3 right(-(up % forward));
Matrix33 mat;
mat.SetFromVectors(right,up%right,up);
mat.OrthonormalizeFast();
Ang3 offset(m_io.viewQuatFinal.GetInverted() * Quat(mat));
weaponAngleOffset += offset*(180.0f/gf_PI)*0.5f;
float lookDown(m_io.viewQuatFinal.GetColumn1() * m_io.baseQuat.GetColumn2());
weaponOffset += m_io.baseQuat * Vec3(0,-0.5f*max(-lookDown,0.0f),-0.05f);
float scale = 0.5f;;
if(weaponAngleOffset.x>0.0f)
{
scale = min(0.5f,weaponAngleOffset.x/15.0f);
weaponAngleOffset.x *= scale;
}
else
{
scale = min(0.5f,-weaponAngleOffset.x/20.0f);
weaponAngleOffset *= (1.0f-scale);
weaponOffset *= scale;
}
//if(vSpeedLen>0.1f)
//weaponAngleOffset += Ang3(-8.0f,0,-12.5f);
}
else if (m_in.bSprinting && vSpeedLen>0.5f)
{
weaponAngleOffset += Ang3(-20.0f,0,10.0f);
weaponOffset += m_io.viewQuatFinal * Vec3(0.0f, -.01f, .1f);
}
else if (m_in.bLookingAtFriendlyAI && !weaponZomming && !weaponZoomed)
{
weaponAngleOffset += Ang3(-15.0f,0,8.0f);
weaponOffset += m_io.viewQuatFinal * Vec3(0.0f, -.01f, .05f);
}
//apply some multipliers
weaponOffset *= m_in.params_weaponBobbingMultiplier;
angOffset *= m_io.bobMul * 0.25f;
if (m_io.bobMul*m_io.bobMul!=1.0f)
{
weaponOffset *= m_io.bobMul;
weaponAngleOffset *= m_io.bobMul;
}
float bobSpeedMult(1.0f);
if(m_in.stats_inWater>0.1)
bobSpeedMult = 0.75f;
// m_io.viewQuatForWeapon *= Quat::CreateRotationXYZ(Ang3(rx,ry,rz));
Interpolate(m_io.vFPWeaponOffset,weaponOffset,3.95f*bobSpeedMult,m_in.frameTime);
Interpolate(m_io.vFPWeaponAngleOffset,weaponAngleOffset,10.0f*bobSpeedMult,m_in.frameTime);
Interpolate(m_io.vFPWeaponLastDirVec,m_io.viewQuatFinal.GetColumn1(),5.0f*bobSpeedMult,m_in.frameTime);
Interpolate(m_io.angleOffset,angOffset,10.0f,m_in.frameTime,0.002f);
if(weaponZomming)
{
m_io.vFPWeaponLastDirVec = m_io.viewQuatFinal.GetColumn1();
m_io.vFPWeaponOffset.Set(0.0f,0.0f,0.0f);
m_io.vFPWeaponAngleOffset.Set(0.0f,0.0f,0.0f);
m_io.bobOffset.Set(0.0f,0.0f,0.0f);
}
if (m_in.bSprinting)
{
float headBobScale = (m_in.stats_flatSpeed / m_in.standSpeed);
headBobScale = min(1.0f, headBobScale);
m_io.bobOffset = m_io.vFPWeaponOffset * 2.5f * g_pGameCVars->cl_headBob * headBobScale;
float bobLenSq = m_io.bobOffset.GetLengthSquared();
float bobLenLimit = g_pGameCVars->cl_headBobLimit;
if (bobLenSq > bobLenLimit*bobLenLimit)
{
float bobLen = sqrt_tpl(bobLenSq);
m_io.bobOffset *= bobLenLimit/bobLen;
}
viewParams.position += m_io.bobOffset;
}
}
//------------------------------------------------------------------------
void CViewSystem::Update(float frameTime)
{
FUNCTION_PROFILER(GetISystem(), PROFILE_ACTION);
if (gEnv->IsDedicated())
return;
CView* const __restrict pActiveView = static_cast<CView*>(GetActiveView());
TViewMap::const_iterator Iter(m_views.begin());
TViewMap::const_iterator const IterEnd(m_views.end());
for (; Iter != IterEnd; ++Iter)
{
CView* const __restrict pView = Iter->second;
bool const bIsActive = (pView == pActiveView);
pView->Update(frameTime, bIsActive);
if (bIsActive)
{
CCamera &rCamera = pView->GetCamera();
pView->UpdateAudioListener(rCamera.GetMatrix());
SViewParams currentParams = *(pView->GetCurrentParams());
rCamera.SetJustActivated(currentParams.justActivated);
currentParams.justActivated = false;
pView->SetCurrentParams(currentParams);
if (m_bOverridenCameraRotation)
{
// When camera rotation is overridden.
Vec3 pos = rCamera.GetMatrix().GetTranslation();
Matrix34 camTM(m_overridenCameraRotation);
camTM.SetTranslation(pos);
rCamera.SetMatrix(camTM);
}
else
{
// Normal setting of the camera
if (m_fCameraNoise > 0)
{
Matrix33 m = Matrix33(rCamera.GetMatrix());
m.OrthonormalizeFast();
Ang3 aAng1 = Ang3::GetAnglesXYZ(m);
//Ang3 aAng2 = RAD2DEG(aAng1);
Matrix34 camTM = rCamera.GetMatrix();
Vec3 pos = camTM.GetTranslation();
camTM.SetIdentity();
const float fScale = 0.1f;
CPNoise3* pNoise = m_pSystem->GetNoiseGen();
float fRes = pNoise->Noise1D(gEnv->pTimer->GetCurrTime() * m_fCameraNoiseFrequency);
aAng1.x += fRes * m_fCameraNoise * fScale;
pos.z -= fRes * m_fCameraNoise * fScale;
fRes = pNoise->Noise1D(17 + gEnv->pTimer->GetCurrTime() * m_fCameraNoiseFrequency);
aAng1.y -= fRes * m_fCameraNoise * fScale;
//aAng1.z+=fRes*0.025f; // left / right movement should be much less visible
camTM.SetRotationXYZ(aAng1);
camTM.SetTranslation(pos);
rCamera.SetMatrix(camTM);
}
}
m_pSystem->SetViewCamera(rCamera);
}
}
// Display debug info on screen
if (m_nViewSystemDebug)
{
DebugDraw();
}
// perform dynamic color grading
// Beni - Commented for console demo stuff
/******************************************************************************************
if (!IsPlayingCutScene() && gEnv->pAISystem)
{
SAIDetectionLevels detection;
gEnv->pAISystem->GetDetectionLevels(nullptr, detection);
float factor = detection.puppetThreat;
// marcok: magic numbers taken from Maciej's tweaked values (final - initial)
{
float percentage = (0.0851411f - 0.0509998f)/0.0509998f * factor;
float amount = 0.0f;
gEnv->p3DEngine->GetPostEffectParam("ColorGrading_GrainAmount", amount);
gEnv->p3DEngine->SetPostEffectParam("ColorGrading_GrainAmount_Offset", amount*percentage);
}
{
float percentage = (0.405521f - 0.256739f)/0.256739f * factor;
float amount = 0.0f;
gEnv->p3DEngine->GetPostEffectParam("ColorGrading_SharpenAmount", amount);
//gEnv->p3DEngine->SetPostEffectParam("ColorGrading_SharpenAmount_Offset", amount*percentage);
}
{
float percentage = (0.14f - 0.11f)/0.11f * factor;
float amount = 0.0f;
gEnv->p3DEngine->GetPostEffectParam("ColorGrading_PhotoFilterColorDensity", amount);
gEnv->p3DEngine->SetPostEffectParam("ColorGrading_PhotoFilterColorDensity_Offset", amount*percentage);
}
{
float percentage = (234.984f - 244.983f)/244.983f * factor;
float amount = 0.0f;
gEnv->p3DEngine->GetPostEffectParam("ColorGrading_maxInput", amount);
//gEnv->p3DEngine->SetPostEffectParam("ColorGrading_maxInput_Offset", amount*percentage);
}
{
float percentage = (239.984f - 247.209f)/247.209f * factor;
float amount = 0.0f;
gEnv->p3DEngine->GetPostEffectParam("ColorGrading_maxOutput", amount);
//gEnv->p3DEngine->SetPostEffectParam("ColorGrading_maxOutput_Offset", amount*percentage);
}
{
Vec4 dest(0.0f/255.0f, 22.0f/255.0f, 33.0f/255.0f, 1.0f);
Vec4 initial(2.0f/255.0f, 154.0f/255.0f, 226.0f/255.0f, 1.0f);
Vec4 percentage = (dest - initial)/initial * factor;
Vec4 amount;
gEnv->p3DEngine->GetPostEffectParamVec4("clr_ColorGrading_SelectiveColor", amount);
//gEnv->p3DEngine->SetPostEffectParamVec4("clr_ColorGrading_SelectiveColor_Offset", amount*percentage);
}
{
float percentage = (-5.0083 - -1.99999)/-1.99999 * factor;
float amount = 0.0f;
gEnv->p3DEngine->GetPostEffectParam("ColorGrading_SelectiveColorCyans", amount);
//gEnv->p3DEngine->SetPostEffectParam("ColorGrading_SelectiveColorCyans_Offset", amount*percentage);
}
{
float percentage = (10.0166 - -5.99999)/-5.99999 * factor;
float amount = 0.0f;
gEnv->p3DEngine->GetPostEffectParam("ColorGrading_SelectiveColorMagentas", amount);
//gEnv->p3DEngine->SetPostEffectParam("ColorGrading_SelectiveColorMagentas_Offset", amount*percentage);
}
{
float percentage = (10.0166 - 1.99999)/1.99999 * factor;
float amount = 0.0f;
gEnv->p3DEngine->GetPostEffectParam("ColorGrading_SelectiveColorYellows", amount);
//gEnv->p3DEngine->SetPostEffectParam("ColorGrading_SelectiveColorYellows_Offset", amount*percentage);
}
}
********************************************************************************************/
}
