RomkaZVO/FC1
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
main
FC1/CryGame/XPlayerCamera.cpp
romkazvo 34d6c5d489 123
2023-08-07 19:29:24 +08:00

679 lines
22 KiB
C++
Raw Permalink Blame History

//////////////////////////////////////////////////////////////////////////
//
// Game Source Code
//
// File: XEntityPlayer.cpp
// Description: Entity player class.
//
// History:
// - October 21,2002: Created by splitting Xplayer.cpp in multiple files
// - August 16, 2001: Created by Petar and Alberto
//
//////////////////////////////////////////////////////////////////////////
#include "StdAfx.h"
#include "XPlayer.h"
#include "XVehicle.h"
//FIXME: remove
#include "WeaponClass.h"
#include "WeaponSystemEx.h"
#include <float.h>
//////////////////////////////////////////////////////////////////////////
/*! Updates the lean angles
*/
void CPlayer::UpdateLean()
{
IEntityCamera *camera = m_pEntity->GetCamera();
if (!camera)
return;
FUNCTION_PROFILER( GetISystem(),PROFILE_GAME );
float frameTime = m_pGame->GetSystem()->GetITimer()->GetFrameTime();
IPhysicalEntity *physEnt = m_pEntity->GetPhysics();
if (physEnt)
{
//get view physics status
pe_status_living status;
if(physEnt->GetStatus(&status))
{
status.camOffset += vectorf(m_walkParams.shakeLOffset);
camera->SetCamOffset(status.camOffset);//Vec3d(0, 0, status.eye_height));
}
//TRACE("Legacy Cam Offset Z: %f", status.cam_offset.z);
//camera->SetCamOffset(Vec3d(0.0f, 0.0f, m_fEyeHeight));
}
m_vEyeAngles=m_pEntity->GetAngles() + m_walkParams.shakeAOffset;// + m_vEyeAnglesBaseOffset;
if(IsMyPlayer() && (IsLeaning() || m_walkParams.fCurrLean!=0))
{
// calculate if we would intersect with something during leaning....
// Vec3d MaxLeanPos = CalcLeanOffset((m_walkParams.fLeanTarget<0.0f ? -0.9f : 0.9f));
float fLeanTarget = IsLeaning() ? m_walkParams.fLeanTarget : m_walkParams.fCurrLean;
Vec3d MaxLeanPos = CalcLeanOffset((fLeanTarget<0.0f ? -1.3f : 1.3f));
Vec3d NormalPos=m_pEntity->GetPos()+camera->GetCamOffset();
Vec3d leanDir = MaxLeanPos - NormalPos;
IPhysicalEntity *skip = m_pEntity->GetPhysics();
ray_hit hits[1];
//int flags = rwi_stop_at_pierceable;
int flags = rwi_stop_at_pierceable | geom_colltype_player<<rwi_colltype_bit;
int goesInside=m_pPhysicalWorld->RayWorldIntersection(NormalPos,leanDir, ent_all, flags,hits,1, skip );
if( goesInside==0 )
{ // check if there is something in front of me
float clipDist = camera->GetCamera().GetZMin();
Vec3d PlayerDir=m_pEntity->GetAngles();
Vec3d dir(0,-1,0);
Matrix44 tm = Matrix44::CreateRotationZYX(-PlayerDir*gf_DEGTORAD); //NOTE: angles in radians and negated
dir = GetTransposed44(tm)*(dir);
//PlayerDir=ConvertToRadAngles(PlayerDir);
PlayerDir=dir;
PlayerDir.Normalize();
PlayerDir *= clipDist*1.8f; // was 5
goesInside=m_pPhysicalWorld->RayWorldIntersection(MaxLeanPos,PlayerDir, ent_all, flags,hits,1, skip );
// also check 'the diagonal' - ray from head to the final test point, to avoid 'hooks' around corners
goesInside += m_pPhysicalWorld->RayWorldIntersection(NormalPos,MaxLeanPos-NormalPos+PlayerDir, ent_all, flags,hits,1, skip );
}
if(goesInside || m_pMountedWeapon) // stop leaning - go inside of something
{
m_walkParams.leanStart=m_walkParams.leanAmount;
m_walkParams.leanEnd=0.0f;
m_walkParams.leanFactor=0.0f;
m_walkParams.fLeanTarget=0;
if (!IsLeaning())
m_walkParams.fCurrLean=0; // if we animate leaning to 0 and encounter an obstacle, just set 0 instantly
}
}
//TRACE("m_walkParams.fLeanTarget=%03f m_walkParams.fCurrLean=%.03f",m_walkParams.fLeanTarget,m_walkParams.fCurrLean);
if (/*IsLeaning( )*/(m_walkParams.fLeanTarget-m_walkParams.fCurrLean!=0) && IsMyPlayer())
{
float fMul=(m_walkParams.fLeanTarget-m_walkParams.fCurrLean>0) ? 1.0f : -1.0f;
float fDiff=(float)fabs((10+m_walkParams.fLeanTarget)-(10+m_walkParams.fCurrLean));
if(m_walkParams.fLeanTarget==0)
{
m_walkParams.fCurrLean+=m_walkParams.fCurrLean<0?min(m_pTimer->GetFrameTime()*(fMul*m_walkParams.leanSpeed*3),fDiff*fMul):max(m_pTimer->GetFrameTime()*(fMul*m_walkParams.leanSpeed*3),fDiff*fMul);
}
else
{
m_walkParams.fCurrLean+=m_walkParams.fLeanTarget>0?min(m_pTimer->GetFrameTime()*(fMul*m_walkParams.leanSpeed*3),fDiff*fMul):max(m_pTimer->GetFrameTime()*(fMul*m_walkParams.leanSpeed*3),fDiff*fMul);
}
//CLIP TO ! BYTE PRECISION
int temp=(int)((m_walkParams.fCurrLean)/(1.f/255));
m_walkParams.fCurrLean=(float)((temp)*(1.f/255));
}
// float fAngle=m_walkParams.fCurrLean*m_pGame->p_lean->GetFVal();
float fAngle=m_walkParams.fCurrLean*m_LeanDegree;
m_vEyeAngles.y+=fAngle;
}
//////////////////////////////////////////////////////////////////////////
Vec3d CPlayer::CalcLeanOffset(float leanAngle)
{
IEntityCamera *camera = m_pEntity->GetCamera();
if (!camera)
return Vec3d(0,0,0);
// when gunner in vehicle - no lean, take into account parent's matrix when adding camera offset
if( m_pVehicle && m_stats.inVehicleState == PVS_GUNNER )
{
Matrix33 VehicleMat = Matrix33::CreateRotationXYZ( m_pVehicle->m_pEntity->GetAngles()*gf_DEGTORAD );
pe_player_dimensions dim;
m_pEntity->GetPhysics()->GetParams( &dim );
Vec3 offset(0.0f,0.0f,dim.heightEye);
Vec3d angl=m_pEntity->GetAngles(1);
Matrix33 SelfMat = Matrix33::CreateRotationXYZ( Vec3d(0,0,angl.z*gf_DEGTORAD) );
// here we offset camera a bit back from weapon (depending on up angle (angl.x))
// to prevent intersection with weapon
angl.x = Snap_s180(angl.x);
offset.y = 1.5f*fabs( angl.x )/60.0f;
if(offset.y > 1.5f)
offset.y = 1.5f;
offset = (VehicleMat*SelfMat)*offset;
Vec3 NormalPos=m_pEntity->GetPos()+offset;
return NormalPos;
}
// if using mounted weapon - try to get camera position from "eyes" bone of weapon
if(m_pMountedWeapon)
{
ICryCharInstance *pChar = m_pMountedWeapon->GetCharInterface()->GetCharacter(0);
if(pChar)
{
ICryBone* pWpnEye=pChar->GetBoneByName("eyes");
if(pWpnEye)
{
Vec3d bPos = pWpnEye->GetBonePosition();
Matrix44 mat=Matrix44::CreateRotationZYX(-m_pEntity->GetAngles()*gf_DEGTORAD); //NOTE: angles in radians and negated
bPos = mat.TransformPointOLD(bPos);
return bPos + m_pMountedWeapon->GetPos();
}
}
}
Vec3d PlayerDir=m_pEntity->GetAngles();
PlayerDir=ConvertToRadAngles(PlayerDir);
PlayerDir.Normalize();
Vec3d Top(0.0f, 0.0f, 1.0f);
Vec3d Tangent=PlayerDir.Cross(Top);
Vec3d offset=camera->GetCamOffset();
IPhysicalEntity *physEnt = m_pEntity->GetPhysics();
if (physEnt)
{
pe_status_living status;
if (physEnt->GetStatus(&status))
{
// m_vEyeAnglesBaseOffset.Set(0.0f,0.0f,0.0f);
// if proning - make eye position dependent on ground normal
//if(m_CurStance == eProne )
// offset = status.groundSlope*offset.z;
/*
if(status.pGroundCollider)
{
pe_status_dynamics baseSt;
status.pGroundCollider->GetStatus(&baseSt);
float baseAngMovementScale = (baseSt.w.x*baseSt.w.x + baseSt.w.y*baseSt.w.y);
// if whatever player is standing on is moving (waiving)
if(baseAngMovementScale > .003f)
{
IEntity* pEnt=(IEntity*)status.pGroundCollider->GetForeignData();
if(pEnt)
{
// if standing on vehicle - add vehicle angles
// not only for vehicle
// CVehicle* pVehicleBelow;
// if(pEnt->GetContainer()->QueryContainerInterface(CIT_IVEHICLE,(void**)&pVehicleBelow))
{
Vec3d angOffs;
angOffs = pEnt->GetAngles();
// m_vEyeAnglesBaseOffset = -angOffs*baseAngMovementScale*3.0f;
m_vEyeAnglesBaseOffset = -angOffs;
if( m_vEyeAnglesBaseOffset.x<-aMax )
m_vEyeAnglesBaseOffset.x=-aMax;
if( m_vEyeAnglesBaseOffset.x<-aMax )
m_vEyeAnglesBaseOffset.x=-aMax;
m_vEyeAnglesBaseOffset.z=0;
}
}
}
}
//*/
}
}
Vec3d NormalPos=m_pEntity->GetPos() + offset;
Vec3d LeanOffset=Tangent*(-leanAngle*m_pGame->p_lean_offset->GetFVal());
LeanOffset.z -= fabsf(leanAngle*m_pGame->p_lean_offset->GetFVal())*.36f;
return NormalPos+LeanOffset;
}
//////////////////////////////////////////////////////////////////////////
bool CPlayer::IsLeaning( )
{
return (m_walkParams.leanEnd!=m_walkParams.leanStart) || (m_walkParams.leanFactor);
}
// Updates the camera associated with the player
//////////////////////////////////////////////////////////////////////////
void CPlayer::UpdateCamera()
{
IEntityCamera *camera = m_pEntity->GetCamera();
if (!camera)
return;
FUNCTION_PROFILER( GetISystem(),PROFILE_GAME );
if (!IsMyPlayer() && !m_pGame->IsMultiplayer())
{
//fixme hack?
camera->SetPos(m_pEntity->GetPos());
return;
}
float frameTime = m_pGame->GetSystem()->GetITimer()->GetFrameTime();
IPhysicalEntity *physEnt = m_pEntity->GetPhysics();
if (physEnt)
{
//get view physics status
pe_status_living status;
if (physEnt->GetStatus(&status))
{
status.camOffset += vectorf(m_walkParams.shakeLOffset);
camera->SetCamOffset(status.camOffset);//Vec3d(0, 0, status.eye_height));
}
//TRACE("Legacy Cam Offset Z: %f", status.cam_offset.z);
//camera->SetCamOffset(Vec3d(0.0f, 0.0f, m_fEyeHeight));
}
// if (IsAlive())
{
m_ValidPos = m_pEntity->GetPos();
m_ValidPos.z += .2f;
m_ValidAngle = m_pEntity->GetAngles();
if (m_bFirstPerson && m_pVehicle)
{
// in vehicle camera
UpdateBoatCamera();
}
else
if (!m_bFirstPerson)
{
//third person camera
Vec3d pos,angles;
pos = m_pEntity->GetPos();
angles = m_pEntity->GetAngles();
//<<FIXME>> if something with the third person camera doesn't work, talk to Petar
if(m_pVehicle && m_pVehicle->GetEntity() ) // in vehicle - third person - skip vehicle physiscs when trace camera
{
IPhysicalEntity *physEntCar = m_pVehicle->GetEntity()->GetPhysics();
float camRange = m_pGame->cl_ThirdPersonRange->GetFVal();
// float waterLevel = m_pGame->GetSystem()->GetI3DEngine()->GetWaterLevel(m_pEntity);
if(m_pVehicle->GetType() == VHT_BOAT || m_pVehicle->GetType() == VHT_PARAGLIDER )//RAGLIDER IsBoat())
// camRange = m_pGame->cl_ThirdPersonRangeBoat->GetFVal();
camRange = m_pVehicle->m_BoatParams.m_fCameraDist;
float camDist = m_pGame->cl_ThirdPersonOffs->GetFVal();
float camAVert = m_pGame->cl_ThirdPersonOffsAngVert->GetFVal();
float camAHor = m_pGame->cl_ThirdPersonOffsAngHor->GetFVal();
Vec3 offset(0.0f,camDist, 0.0f);
Matrix33 targetMt;
targetMt.SetIdentity();
targetMt.SetRotationXYZ((m_pVehicle->GetEntity()->GetAngles()+Vec3(camAVert,0.0f,camAHor))*gf_DEGTORAD);
targetMt.Transpose();
Matrix33 offsetMt;
offsetMt.SetIdentity();
// offsetMt.SetRotationXYZ33((Vec3(camAVert,0.0f,camAHor))*gf_DEGTORAD);
// offsetMt.Transpose33();
// offset = offset*(targetMt*offsetMt);
offset = offset*(targetMt);
// offset.Set(4,0,3);
offset += m_pVehicle->GetEntity()->GetPos();
// offset = m_pVehicle->GetEntity()->GetPos();
float waterLevel = m_pGame->GetSystem()->GetI3DEngine()->GetWaterLevel(&offset);
float terrainLevel = m_pGame->GetSystem()->GetI3DEngine()->GetTerrainZ((int)offset.x, (int)offset.y);
camera->SetThirdPersonMode(offset,
angles,CAMERA_3DPERSON1,frameTime,camRange,!m_bFirstPerson,physEnt,
// NULL,
physEntCar,
m_pGame->GetSystem()->GetI3DEngine());
}
else
camera->SetThirdPersonMode(pos,angles,CAMERA_3DPERSON1,frameTime,m_pGame->cl_ThirdPersonRange->GetFVal(),!m_bFirstPerson,physEnt );
ICryCharInstance *pChar = m_pEntity->GetCharInterface()->GetCharacter(0);
if (m_pGame->cl_ViewFace->GetFVal()>0.0f)
{
camera->SetPos( m_pEntity->GetPos()+Vec3d(0,m_pGame->cl_ViewFace->GetFVal(),1.7f));//camera->GetCamOffset());
camera->SetAngles( Vec3d(0, 0, 0) );
TRACE("%5.5f", m_pEntity->GetPos().z);
if (pChar)
pChar->SetAnimationSpeed(0.00001f);
}
else
{
if (pChar)
pChar->SetAnimationSpeed(1.0f);
}
}
else
{
// first person
if( m_CameraMode == PCM_CASUAL)
{
UpdateCameraTransition( m_vEyePos );
camera->SetPos(m_vCurCamposVhcl);
camera->SetAngles(m_vCurAngleVhcl);
}
else
{
camera->SetPos(m_vEyePos);
camera->SetAngles(m_vEyeAngles);
}
}
}
/*
else
{
// When the player is dead
physEnt = m_pEntity->GetPhysics();
Vec3 vAngles = m_ValidAngle;
vAngles.x = 50; vAngles.y = 0; // fix pitch and roll to prevent weird angles
camera->SetThirdPersonMode( m_ValidPos,vAngles, CAMERA_3DPERSON1, frameTime,8,2,physEnt, 0,1.2f );
}
*/
if (camera)
camera->Update();
}
// sets players EYE position (camera for fpv)
//////////////////////////////////////////////////////////////////////////
void CPlayer::SetEyePos()
{
if( m_pGame->p_HeadCamera->GetIVal())
SetEyePosBone();
else
SetEyePosOffset();
}
// sets players EYE position (camera for fpv)
//////////////////////////////////////////////////////////////////////////
void CPlayer::SetEyePosDead()
{
if (!m_pBoneHead)
return;
SetEyePosBone();
m_vEyePos.z += .3f;
CryQuat qt=m_pBoneHead->GetParentWQuat();
Matrix33 mat(qt);
Vec3 ang=RAD2DEG(Ang3::GetAnglesXYZ( mat ));
// m_vEyeAngles = RAD2DEG(Ang3::GetAnglesXYZ( mat ));
m_vEyeAngles.x = -ang.x;
m_vEyeAngles.y = ang.z;
m_vEyeAngles.z = ang.y;
// m_vEyeAngles.y += 90.0f;
// m_vEyeAngles.z = -m_vEyeAngles.z;
}
// sets players EYE position on head bone (camera for fpv)
//////////////////////////////////////////////////////////////////////////
void CPlayer::SetEyePosBone()
{
if (!m_pBoneHead)
return;
Vec3d bPos = m_pBoneHead->GetBonePosition();
Matrix44 mat;
mat=Matrix44::CreateRotationZYX(-m_pEntity->GetAngles()*gf_DEGTORAD); //NOTE: angles in radians and negated
bPos = mat.TransformPointOLD(bPos);
m_vEyePos = bPos + m_pEntity->GetPos();
}
// sets players EYE position (camera for fpv)
//////////////////////////////////////////////////////////////////////////
void CPlayer::SetEyePosOffset()
{
IEntityCamera *camera = m_pEntity->GetCamera();
if (!camera)
return;
m_vEyePos = CalcLeanOffset(m_walkParams.fCurrLean/*m_walkParams.leanCur*/);
}
// Updates the first person view (eg. shaking of camera while walking)
//////////////////////////////////////////////////////////////////////////
void CPlayer::UpdateFirstPersonView()
{
//IEntity *ce = GetEntity();
IEntityCamera *camera = m_pEntity->GetCamera();
m_walkParams.runPitch = m_pGame->p_bob_pitch->GetFVal();
m_walkParams.runRoll = m_pGame->p_bob_roll->GetFVal();
m_walkParams.stepLength = m_pGame->p_bob_length->GetFVal();
m_walkParams.weaponCycle = m_pGame->p_bob_weapon->GetFVal();
m_walkParams.flyCoeff = m_pGame->p_bob_fcoeff->GetFVal();
// Disable drawing of characters in first person mode.
//m_pEntity->DrawCharacter(PLAYER_MODEL_IDX,0);
//m_pEntity->SetRndFlags(ERF_CASTSHADOWVOLUME|ERF_CASTSHADOWMAPS|ERF_SELFSHADOW|ERF_RECVSHADOWMAPS|ERF_DONOTCHECKVIS, true);
m_pEntity->SetRndFlags(ERF_DONOTCHECKVIS, true);
m_pEntity->SetRndFlags(ERF_RECVSHADOWMAPS|ERF_RECVSHADOWMAPS_ACTIVE, true);
m_pEntity->SetRndFlags(ERF_CASTSHADOWMAPS|ERF_CASTSHADOWVOLUME, false);
m_pEntity->SetRndFlags(ERF_FIRST_PERSON_CAMERA_OWNER, true);
if (m_stats.flying)
{
m_walkParams.speed -= m_FlyTime*m_walkParams.flyCoeff;
if(m_walkParams.speed<0.0f)
m_walkParams.speed = 0.0f;
}
else
{
float dump = .30f - m_LandTime;
if(dump>0)
{
m_walkParams.speed -= dump*m_walkParams.flyCoeff;
if(m_walkParams.speed<0.0f)
m_walkParams.speed = 0.0f;
}
}
m_walkParams.curLength -= m_walkParams.speed*m_pTimer->GetFrameTime();
// do this on animation event
//*
if( m_walkParams.curLength < 0 )
{
m_walkParams.curLength = m_walkParams.stepLength;
// m_pEntity->SendScriptEvent(ScriptEvent_AnimationKey,0);
}
//*/
float f = m_walkParams.curLength/m_walkParams.stepLength;
m_walkParams.prevF = f;
float roll = m_walkParams.runRoll*m_walkParams.speed;
float pitch = m_walkParams.runPitch*m_walkParams.speed;
if(camera)
{
// calculate the camera movement, relative
Vec3 deltaTemp = camera->GetAngles() - m_vPrevCamAngles;
deltaTemp.x = Snap_s180(deltaTemp.x);
deltaTemp.y = Snap_s180(deltaTemp.y);
deltaTemp.z = Snap_s180(deltaTemp.z);
m_vDeltaCamAngles = 0.5f*(deltaTemp) + 0.5f*m_vDeltaCamAngles;
m_vDeltaCamPos = 0.5f*(camera->GetPos() - m_vPrevCamPos) + 0.5f*m_vDeltaCamPos;
//GetISystem()->GetILog()->Log("delta: %f %f %f", m_vDeltaCamAngles.x, m_vDeltaCamAngles.y, m_vDeltaCamAngles.z);
m_vPrevCamAngles = camera->GetAngles();
m_vPrevCamPos = camera->GetPos();
if(m_Dynamics.gravity!=0.0f) // head bobbing only if there is gravity
{
Vec3d cangles = camera->GetAngles();
cangles.x += pitch*cry_sinf(f*gf_PI*2.0f);
cangles.y += roll*cry_sinf(f*gf_PI*2.0f);
camera->SetAngles(cangles);
}
}
if (m_nSelectedWeaponID != -1)
{
//static Vec3 weaponAngles(0,0,0);
Vec3d weaponOffset(0,0,0);
float lazy_intensity = GetGame()->cl_lazy_weapon->GetFVal();
if (lazy_intensity > 1.0f) lazy_intensity = 1.0f;
if (lazy_intensity > 0.0f)
{
float frameTime = m_pTimer->GetFrameTime();
if (frameTime >= 0.0f)
{
if (frameTime > 0.5f)
frameTime = 0.5f;
assert(_finite(frameTime));
float maxAngleMovement = 100.0f * frameTime;
if (m_vDeltaCamAngles.len2()>0.0f || m_vDeltaCamPos.len2()>0.0f)
{
m_vDeltaCamAngles *= lazy_intensity;
m_vDeltaCamPos *= lazy_intensity;
m_vWeaponAngles -= 0.5f*m_vDeltaCamAngles;
if (m_vDeltaCamPos.z>0.0f) m_vDeltaCamPos.z *= 0.3f;
m_vWeaponAngles.x += 30.0f * m_vDeltaCamPos.z;
assert(_finite(m_vDeltaCamAngles.x));
assert(_finite(m_vDeltaCamAngles.z));
assert(_finite(m_vWeaponAngles.x));
assert(_finite(m_vWeaponAngles.z));
m_vWeaponAngles.x = CLAMP(m_vWeaponAngles.x, -10.0f, 10.0f);
m_vWeaponAngles.y = CLAMP(m_vWeaponAngles.y, -10.0f, 10.0f);
m_vWeaponAngles.z = CLAMP(m_vWeaponAngles.z, -10.0f, 10.0f);
// limit to maximum angle
float len2 = m_vWeaponAngles.len2();
maxAngleMovement*=len2/(15.0f*15.0f);
// calculate ammount of movement
Vec3 weaponAngleMovement = -m_vWeaponAngles;
len2 = weaponAngleMovement.len2();
if (len2 > maxAngleMovement*maxAngleMovement)
weaponAngleMovement=0.2f*weaponAngleMovement + 0.7f*(maxAngleMovement)/(cry_sqrtf(len2)) * weaponAngleMovement;
m_vWeaponAngles += weaponAngleMovement;
m_vWeaponAngles.x = fmod(m_vWeaponAngles.x, 360.0f);
m_vWeaponAngles.y = fmod(m_vWeaponAngles.y, 360.0f);
m_vWeaponAngles.z = fmod(m_vWeaponAngles.z, 360.0f);
}
}
}
else
{
//if (lazy_intensity != 0.0)
// GetISystem()->GetILog()->Log("weaponAngles: %f %f %f", m_vWeaponAngles.x, m_vWeaponAngles.y, m_vWeaponAngles.z);
m_vWeaponAngles.Set(0,0,0);
}
CWeaponClass* pSelectedWeapon = GetSelectedWeapon();
if(m_Dynamics.gravity!=0.0f && !m_pVehicle) // weapon sway only if there is gravity
// and not in vehicle
{
weaponOffset.x = cry_sinf(f*gf_PI*2.0f) * m_walkParams.weaponCycle*m_walkParams.speed;
//filippo
weaponOffset.z = cry_sinf(f*gf_PI*4.0f) * m_walkParams.weaponCycle*m_walkParams.speed*0.35f;
//weaponOffset.z = cry_sinf(f*gf_PI*4.0f) * m_walkParams.weaponCycle*m_walkParams.speed;
}
pSelectedWeapon->SetFirstPersonOffset( weaponOffset, m_vWeaponAngles);
pSelectedWeapon->MoveToFirstPersonPos(m_pEntity);
if(m_stats.drawfpweapon)
{
ICryCharInstance *pChar = GetEntity()->GetCharInterface()->GetCharacter(1);
if (pChar)
{
GetEntity()->DrawCharacter(1, CS_FLAG_DRAW_NEAR);
/* PLEASE LEAVE THIS CODE IN HERE
// adjust first person bounding box
Matrix44 matWeapon = Matrix34::GetRotationXYZ34( Deg2Rad(pSelectedWeapon->GetAngles()), pSelectedWeapon->GetPos());
matWeapon.Transpose();
// get object space bbox
Vec3 mins,maxs;
pChar->GetBBox(mins,maxs);
mins *= GetEntity()->GetScale();
maxs *= GetEntity()->GetScale();
// extend this entity's bounding box, by transformed bounding box of weapon
AABB aabb(mins, maxs);
aabb.Transform(matWeapon);
*/
}
}
else
{
GetEntity()->DrawCharacter(1,0);
GetEntity()->ResetAnimations(1);
}
}
m_walkParams.shakeLElapsedTime += m_pTimer->GetFrameTime();
if(m_walkParams.shakeLElapsedTime < m_walkParams.shakeLTime)
{
float amplScale = ( 1.0f - ( m_walkParams.shakeLElapsedTime / m_walkParams.shakeLTime ) );
m_walkParams.shakeLOffset.x = m_walkParams.shakeLAmpl.x*amplScale*cry_sinf(m_walkParams.shakeLElapsedTime*m_walkParams.shakeLFreq.x*6.283185307179586476925286766559f);
m_walkParams.shakeLOffset.y = m_walkParams.shakeLAmpl.y*amplScale*cry_cosf(m_walkParams.shakeLElapsedTime*m_walkParams.shakeLFreq.y*6.283185307179586476925286766559f);
m_walkParams.shakeLOffset.z = m_walkParams.shakeLAmpl.z*amplScale*cry_sinf(m_walkParams.shakeLElapsedTime*m_walkParams.shakeLFreq.z*6.283185307179586476925286766559f + 1.13f);
Vec3d shakeAAmpl=Vec3d(60, 30, 30);
shakeAAmpl = shakeAAmpl*m_walkParams.shakeLAmpl.z;
m_walkParams.shakeAOffset.x = shakeAAmpl.x*amplScale*cry_sinf(m_walkParams.shakeLElapsedTime*m_walkParams.shakeLFreq.x*6.283185307179586476925286766559f);
m_walkParams.shakeAOffset.y = shakeAAmpl.y*amplScale*cry_cosf(m_walkParams.shakeLElapsedTime*m_walkParams.shakeLFreq.y*6.283185307179586476925286766559f);
m_walkParams.shakeAOffset.z = shakeAAmpl.z*amplScale*cry_sinf(m_walkParams.shakeLElapsedTime*m_walkParams.shakeLFreq.z*6.283185307179586476925286766559f + 1.13f);
}
else
{
m_walkParams.shakeAOffset = Vec3d(0,0,0);
m_walkParams.shakeLOffset = Vec3d(0,0,0);
m_walkParams.shakeLElapsedTime = m_walkParams.shakeLTime;
}
}
//so not to do GetBoneByName every frame
//////////////////////////////////////////////////////////////////////////
bool CPlayer::UpdateBonesPtrs( )
{
ICryCharInstance *pChar = m_pEntity->GetCharInterface()->GetCharacter(0);
if (pChar && pChar != m_pLastUsedCharacter)
{
m_pLastUsedCharacter = pChar;
m_pBoneHead = pChar->GetBoneByName("Bip01 Head"); // find bone in the list of bones;
m_pBoneNeck = pChar->GetBoneByName("Bip01 Neck"); // find bone in the list of bones
m_pBoneSpine = pChar->GetBoneByName("Bip01 Spine"); // find bone in the list of bones
m_pBoneSpine1 = pChar->GetBoneByName("Bip01 Spine1"); // find bone in the list of bones
m_pBoneSpine2 = pChar->GetBoneByName("Bip01 Spine2"); // find bone in the list of bones
return true;
}
return false;
}
/*! Updates the third person view (eg. drawing the character)
@param nWeaponIndex weapon-id to retrieve from
@return WeaponInfo if the function succeeds, NULL otherwise
*/
//////////////////////////////////////////////////////////////////////////
void CPlayer::UpdateThirdPersonView( )
{
if(m_nSelectedWeaponID != -1 && IsMyPlayer())
{
GetEntity()->DrawCharacter(1,0);
GetEntity()->ResetAnimations(1);
}
m_pEntity->SetRndFlags(ERF_RECVSHADOWMAPS|ERF_RECVSHADOWMAPS_ACTIVE, false);
m_pEntity->SetRndFlags(ERF_FIRST_PERSON_CAMERA_OWNER, false);
if(IsMyPlayer())
m_pEntity->SetRndFlags(ERF_CASTSHADOWMAPS | ERF_CASTSHADOWVOLUME, true);
}
Reference in New Issue View Git Blame Copy Permalink