khanat-opennel-code/code/ryzom/client/src/view.cpp
2013-07-31 15:08:35 -07:00

458 lines
13 KiB
C++

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "stdpch.h"
/////////////
// INCLUDE //
/////////////
// Misc
#include "nel/misc/common.h"
#include "nel/misc/hierarchical_timer.h"
// Client
#include "view.h"
#include "entities.h"
#include "time_client.h"
#include "pacs_client.h"
// 3d
#include "nel/3d/u_visual_collision_manager.h"
#include "nel/3d/u_instance_group.h"
#include "nel/pacs/u_global_position.h"
#include "motion/user_controls.h"
using NL3D::UVisualCollisionManager;
extern UVisualCollisionManager *CollisionManager;
using namespace NLMISC;
using namespace std;
////////////
// GLOBAL //
////////////
CView View;
/////////////
// METHODS //
/////////////
//-----------------------------------------------
// CView :
// Constructor.
//-----------------------------------------------
CView::CView()
{
_ViewPos = CVector::Null;
_View = CVector::Null;
_RefinePos = CVector::Null;
_RearView=false;
_CurrentCameraDist = 0.0f;
_CurrentCameraSpeed = 0.0f;
_CurrentCameraHeight = 2.0f;
_MaxCameraHeight = 2.2f;
_MinCameraHeight = 1.0f;
_CollisionCameraDist = FLT_MAX;
_ThirPersonClusterSystem= NULL;
_ForceFirstPersonView= false;
// For 3rd person camera collision
_CameraCollisionDecal= 0.1f;
_CameraCollisionThreshold= 0.2f;
_CurrentCameraDistanceMax = ClientCfg.CameraDistMax;
}// CView //
//-----------------------------------------------
//-----------------------------------------------
void CView::update()
{
if(UserEntity->viewMode() == CUserEntity::FirstPV)
{
_CurrentCameraSpeed = 0.0f;
_CurrentCameraDist = 0.0f;
_CollisionCameraDist = FLT_MAX;
_ForceFirstPersonView= false;
}
else
{
////////////////////////////
// Update Camera Distance //
if(ClientCfg.CameraDistance > _CurrentCameraDist)
{
// Acceleration
_CurrentCameraSpeed += ClientCfg.CameraAccel*DT;
// Speed Limit.
clamp(_CurrentCameraSpeed, ClientCfg.CameraSpeedMin, ClientCfg.CameraSpeedMax);
// Adjust Camera Distance
_CurrentCameraDist += _CurrentCameraSpeed*DT;
if(_CurrentCameraDist > ClientCfg.CameraDistance)
_CurrentCameraDist = ClientCfg.CameraDistance;
}
else if(ClientCfg.CameraDistance < _CurrentCameraDist)
{
// Acceleration
_CurrentCameraSpeed -= ClientCfg.CameraAccel*DT;
// Speed Limit.
clamp(_CurrentCameraSpeed, -ClientCfg.CameraSpeedMax, -ClientCfg.CameraSpeedMin);
// Adjust Camera Distance
_CurrentCameraDist += _CurrentCameraSpeed*DT;
if(_CurrentCameraDist < ClientCfg.CameraDistance)
_CurrentCameraDist = ClientCfg.CameraDistance;
}
//////////////////////////
// Update Camera Height //
if(ClientCfg.CameraHeight > _CurrentCameraHeight)
{
// Acceleration
_CurrentCameraSpeed += ClientCfg.CameraAccel*DT;
// Speed Limit.
clamp(_CurrentCameraSpeed, ClientCfg.CameraSpeedMin, ClientCfg.CameraSpeedMax);
// Adjust Camera Distance
_CurrentCameraHeight += _CurrentCameraSpeed*DT;
if(_CurrentCameraHeight > ClientCfg.CameraHeight)
_CurrentCameraHeight = ClientCfg.CameraHeight;
}
else if(ClientCfg.CameraHeight < _CurrentCameraHeight)
{
// Acceleration
_CurrentCameraSpeed -= ClientCfg.CameraAccel*DT;
// Speed Limit.
clamp(_CurrentCameraSpeed, -ClientCfg.CameraSpeedMax, -ClientCfg.CameraSpeedMin);
// Adjust Camera Distance
_CurrentCameraHeight += _CurrentCameraSpeed*DT;
if(_CurrentCameraHeight < ClientCfg.CameraHeight)
_CurrentCameraHeight = ClientCfg.CameraHeight;
}
}
}// update //
//-----------------------------------------------
// currentViewPos :
// Set the user position.
//-----------------------------------------------
CVector CView::currentViewPos() const
{
// clamp to the collisioned camera distance
float minCamDist= min(_CurrentCameraDist, _CollisionCameraDist);
if(_RearView)
{
CVector v;
if(UserEntity->viewMode() == CUserEntity::FirstPV || _ForceFirstPersonView)
{
CVector headPos;
UserEntity->getHeadPos(headPos);
return headPos;
}
else
{
// get the reverted view
CVector v;
v.x = -UserEntity->front().x;
v.y = -UserEntity->front().y;
v.z = 0.0f;
v.normalize();
// pos
return UserEntity->pos() + CVector(0.0f, 0.0f, 2.0f) - v*minCamDist;
}
}
else
{
if(UserEntity->viewMode() == CUserEntity::FirstPV || _ForceFirstPersonView)
return _ViewPos + CVector(0.0f, 0.0f, UserEntity->eyesHeight());
else
return _ViewPos + CVector(0.0f, 0.0f, _CurrentCameraHeight) - _View*minCamDist;
}
}// currentViewPos //
//-----------------------------------------------
// currentView :
// Set the user position.
//-----------------------------------------------
CVector CView::currentView() const
{
if(_RearView)
{
CVector v;
v.x = -UserEntity->front().x;
v.y = -UserEntity->front().y;
v.z = 0.0f;
v.normalize();
return v;
}
else
return _View;
}// currentView //
//-----------------------------------------------
// currentCameraTarget :
//-----------------------------------------------
CVector CView::currentCameraTarget() const
{
if(UserEntity->viewMode() == CUserEntity::FirstPV || _ForceFirstPersonView)
return currentViewPos();
else
{
if(_RearView)
{
return UserEntity->pos() + CVector(0.0f, 0.0f, 2.0f);
}
else
{
return _ViewPos + CVector(0.0f, 0.0f, _CurrentCameraHeight);
}
}
}
// update the max distance of the camera for player that want to play as dm (camera can be far)
void CView::setCameraDistanceMaxForDm()
{
_CurrentCameraDistanceMax = ClientCfg.DmCameraDistMax;
if (!ClientCfg.FPV)
{
cameraDistance( std::min(ClientCfg.CameraDistance, _CurrentCameraDistanceMax) );
}
}
// update the max distance of the camera for player that want to play as player (camera must be near)
void CView::setCameraDistanceMaxForPlayer()
{
_CurrentCameraDistanceMax = ClientCfg.CameraDistMax;
if (!ClientCfg.FPV)
{
cameraDistance( std::min(ClientCfg.CameraDistance, _CurrentCameraDistanceMax) );
}
}
//-----------------------------------------------
// cameraDistance :
// Change the distance from the user to the camera.
//-----------------------------------------------
void CView::cameraDistance(float dist)
{
// Internal View
if((dist < ClientCfg.CameraDistMin) && (dist <= ClientCfg.CameraDistance))
{
if (UserEntity && !UserEntity->isDead())
UserEntity->viewMode(CUserEntity::FirstPV);
ClientCfg.CameraDistance = dist;
}
// External View
else
{
if (UserEntity && !UserEntity->isDead())
UserEntity->viewMode(CUserEntity::ThirdPV);
dist = std::max(dist, ClientCfg.CameraDistMin);
ClientCfg.CameraDistance = std::min(dist, _CurrentCameraDistanceMax);
}
}// cameraDistance //
//-----------------------------------------------
// changeCameraHeight
// Change the height of the camera
//-----------------------------------------------
void CView::changeCameraHeight(bool up, bool down)
{
// If the user is not inside a building.
if(!UserEntity->forceIndoorFPV())
{
if(up)
{
ClientCfg.CameraHeight += 0.5f;
}
else if(down)
{
ClientCfg.CameraHeight -= 0.2f;
}
// height limit.
clamp(ClientCfg.CameraHeight, _MinCameraHeight, _MaxCameraHeight);
}
}// changeCameraHeight //
//-----------------------------------------------
// changeCameraDist :
// Change the distance of the camera
//-----------------------------------------------
void CView::changeCameraDist(bool forward, bool backward)
{
// If the user is not inside a building.
if(!UserEntity->forceIndoorFPV())
{
if(forward)
decreaseCameraDist();
else if(backward)
increaseCameraDist();
}
}// changeCameraDist //
//-----------------------------------------------
// increaseCameraDist :
// Increase the distance between the user and the camera
//-----------------------------------------------
void CView::increaseCameraDist()
{
// FPV -> just switch to TPV
if(UserEntity->viewMode() == CUserEntity::FirstPV)
cameraDistance(std::max(ClientCfg.CameraDistance, ClientCfg.CameraDistMin));
// Backward
else
cameraDistance(ClientCfg.CameraDistance+ClientCfg.CameraDistStep);
}// increaseCameraDist //
//-----------------------------------------------
// decreaseCameraDist :
// Decrease the distance between the user and the camera
//-----------------------------------------------
void CView::decreaseCameraDist()
{
// Forward only in third-person view
if(UserEntity->viewMode() != CUserEntity::FirstPV)
cameraDistance(ClientCfg.CameraDistance-ClientCfg.CameraDistStep);
}// decreaseCameraDist //
//-----------------------------------------------
// getCamera3rdPersonSetup:
//-----------------------------------------------
void CView::getCamera3rdPersonSetup(CVector &cameraStart, CVector &cameraEnd, CVector &cameraTestStart) const
{
float testStartDecal;
getCamera3rdPersonSetupInternal(cameraStart, cameraEnd, cameraTestStart, testStartDecal);
}
//-----------------------------------------------
// getCamera3rdPersonSetupInternal:
//-----------------------------------------------
void CView::getCamera3rdPersonSetupInternal(CVector &cameraStart, CVector &cameraEnd, CVector &cameraTestStart, float &testStartDecal) const
{
// get the camera path
if(_RearView)
{
CVector v;
v.x = - UserEntity->front().x;
v.y = - UserEntity->front().y;
v.z = 0.f;
v.normalize();
cameraStart= UserEntity->pos()+CVector(0.f,0.f,2.f);
// add the threshold, to avoid discontinuity at f=1, when col start
cameraEnd= cameraStart - v*(_CurrentCameraDist+_CameraCollisionThreshold);
}
else
{
cameraStart= _ViewPos + CVector(0.0f, 0.0f, _CurrentCameraHeight);
// add the threshold, to avoid discontinuity at f=1, when col start
cameraEnd= cameraStart - _View*(_CurrentCameraDist+_CameraCollisionThreshold);
}
// Avoid problem when player too near a wall. move back the start test
CVector vDir= cameraEnd - cameraStart;
float len = vDir.norm();
testStartDecal= min(len, _CameraCollisionDecal);
vDir.normalize();
cameraTestStart= cameraStart + vDir*testStartDecal;
}
//-----------------------------------------------
// updateCameraCollision :
//-----------------------------------------------
void CView::updateCameraCollision()
{
H_AUTO(RZ_Client_updateCameraCollision)
// the radius of the cylinder to test
const float colRadius= 0.4f;
// default
_CollisionCameraDist= FLT_MAX;
bool oldForceFPV= _ForceFirstPersonView;
_ForceFirstPersonView= false;
// if third person mode and CollisionManager available
if( UserEntity->viewMode() != CUserEntity::FirstPV &&
UserControls.mode() != CUserControls::AIMode &&
CollisionManager)
{
// Get the Cluster system where the player (not the camera!) lies
NLPACS::UGlobalPosition gPos;
if(UserEntity->getPrimitive())
UserEntity->getPrimitive()->getGlobalPosition(gPos, dynamicWI);
// get the cluster IG associated to this pacs position
NL3D::UInstanceGroup *pPlayerClusterSystem = getCluster(gPos);
// For "matis serre bug", suppose the player is "inside" if walk on a cluster system
CollisionManager->setPlayerInside(pPlayerClusterSystem!=NULL);
// **** Compute the camera collision ray
// get the camera path
CVector cameraStart, cameraEnd, cameraTestStart;
float testStartDecal;
getCamera3rdPersonSetupInternal(cameraStart, cameraEnd, cameraTestStart, testStartDecal);
// **** First do a single ray test from user to cameraTestStart
// do the test only against landscape, to avoid problems
// Use an approximate "pelvis", instead of getHeadPos(), because sometimes, even the head of the player
// can enter in landscape. Thus this case will be tested, but the player will still see inside the landscape
CVector pelvisPos;
pelvisPos= _ViewPos + CVector(0.f, 0.f, 1.f);
// if collide, then force first person view
if(CollisionManager->getRayCollision(pelvisPos, cameraTestStart, true))
{
_ForceFirstPersonView= true;
}
else
{
_ForceFirstPersonView= false;
// **** Clamp the camera according to collision 3D.
float f= CollisionManager->getCameraCollision(cameraTestStart, cameraEnd, colRadius, true);
// if some collision found
if(f<1)
{
// re-add the decalStart
_CollisionCameraDist= testStartDecal + (cameraEnd-cameraTestStart).norm() * f;
// remove the threshold
_CollisionCameraDist-= _CameraCollisionThreshold;
clamp(_CollisionCameraDist, 0, _CurrentCameraDist);
}
// **** Ensure the position in cluster system
// get the pos from compute above
cameraStart= currentCameraTarget();
cameraEnd= currentViewPos();
// parse this ray against the cluster system
CVector precCameraEnd= cameraEnd;
_ThirPersonClusterSystem= Scene->findCameraClusterSystemFromRay(pPlayerClusterSystem, cameraStart, cameraEnd);
// Then modify the Camera distance
if(precCameraEnd!=cameraEnd)
{
_CollisionCameraDist= (cameraEnd - cameraStart).norm();
clamp(_CollisionCameraDist, 0, _CurrentCameraDist);
}
}
}
// if difference of mode, must update userentity
if(oldForceFPV!=_ForceFirstPersonView)
UserEntity->updateVisualDisplay();
}