Mirrors/openrw
1
0
Fork 0
mirror of https://github.com/rwengine/openrw.git synced 2024-11-22 02:12:45 +01:00
Code Issues Projects Releases Activity

Rewrite of camera and character look code

Browse Source 
Make states responsible for interpolating camera transformation
Apply look direction to character orientation
This commit is contained in:
Daniel Evans 2016-11-29 23:28:53 +00:00
parent 04e79a5117
commit ddb62ed3cd
9 changed files with 169 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
rwengine/src/objects/CharacterObject.cpp
View File

@ -319,7 +319,9 @@ void CharacterObject::updateCharacter(float dt) {
glm::vec3 walkDir = updateMovementAnimation(dt);
if (canTurn()) {
rotation = glm::angleAxis(m_look.x, glm::vec3{0.f, 0.f, 1.f});
// Rotation is based on look angles and movement
float yaw = m_look.x + std::atan2(movement.z, movement.x);
rotation = glm::quat(glm::vec3(0.f, 0.f, yaw));
}
walkDir = rotation * walkDir;

21
rwgame/RWGame.cpp
View File

@ -522,17 +522,13 @@ void RWGame::tick(float dt) {
/// @todo this doesn't make sense as the condition
if (state.playerObject) {
nextCam.frustum.update(nextCam.frustum.projection() *
nextCam.getView());
currentCam.frustum.update(currentCam.frustum.projection() *
currentCam.getView());
// Use the current camera position to spawn pedestrians.
world->cleanupTraffic(nextCam);
world->createTraffic(nextCam);
world->cleanupTraffic(currentCam);
world->createTraffic(currentCam);
}
}
// render() needs two cameras to smoothly interpolate between ticks.
lastCam = nextCam;
nextCam = currState->getCamera();
}
void RWGame::render(float alpha, float time) {
@ -540,6 +536,11 @@ void RWGame::render(float alpha, float time) {
getRenderer().getRenderer()->swap();
// Update the camera
if (!StateManager::get().states.empty()) {
currentCam = StateManager::get().states.back()->getCamera(alpha);
}
glm::ivec2 windowSize = getWindow().getSize();
renderer.setViewport(windowSize.x, windowSize.y);
@ -587,9 +588,7 @@ void RWGame::render(float alpha, float time) {
viewCam.rotation = state.cameraRotation;
} else {
// There's no cutscene playing - use the camera returned by the State.
viewCam.position = glm::mix(lastCam.position, nextCam.position, alpha);
viewCam.rotation =
glm::slerp(lastCam.rotation, nextCam.rotation, alpha);
viewCam = currentCam;
}
viewCam.frustum.aspectRatio =

4
rwgame/RWGame.hpp
View File

@ -31,7 +31,7 @@ class RWGame : public GameBase {
std::chrono::steady_clock::time_point last_clock_time;
bool inFocus = true;
ViewCamera lastCam, nextCam;
ViewCamera currentCam;
enum class DebugViewMode {
Disabled,
@ -82,7 +82,7 @@ public:
bool hitWorldRay(glm::vec3& hit, glm::vec3& normal,
GameObject** object = nullptr) {
auto vc = nextCam;
auto vc = currentCam;
glm::vec3 from(vc.position.x, vc.position.y, vc.position.z);
glm::vec3 tmp = vc.rotation * glm::vec3(1000.f, 0.f, 0.f);

4
rwgame/State.cpp
View File

@ -37,7 +37,7 @@ void State::handleEvent(const SDL_Event& e) {
}
}
const ViewCamera& State::getCamera() {
const ViewCamera& State::getCamera(float alpha) {
return defaultView;
}
@ -45,7 +45,7 @@ bool State::shouldWorldUpdate() {
return false;
}
GameWorld* State::getWorld() {
GameWorld* State::getWorld() const {
return game->getWorld();
}

4
rwgame/State.hpp
View File

@ -48,7 +48,7 @@ public:
virtual void handleEvent(const SDL_Event& e);
virtual const ViewCamera& getCamera();
virtual const ViewCamera& getCamera(float alpha);
/**
* Returns false if the game world should not should
@ -56,7 +56,7 @@ public:
*/
virtual bool shouldWorldUpdate();
GameWorld* getWorld();
GameWorld* getWorld() const;
GameWindow& getWindow();
bool hasExited() const {

2
rwgame/states/DebugState.cpp
View File

@ -371,6 +371,6 @@ void DebugState::giveItem(int slot) {
}
}
const ViewCamera& DebugState::getCamera() {
const ViewCamera& DebugState::getCamera(float alpha) {
return _debugCam;
}

2
rwgame/states/DebugState.hpp
View File

@ -35,7 +35,7 @@ public:
void spawnFollower(unsigned int id);
void giveItem(int slot);
const ViewCamera& getCamera();
const ViewCamera& getCamera(float alpha);
};
#endif // DEBUGSTATE_HPP

263
rwgame/states/IngameState.cpp
View File

@ -20,6 +20,7 @@
constexpr float kAutoLookTime = 2.f;
constexpr float kAutolookMinVelocity = 0.2f;
const float kInGameFOV = glm::half_pi<float>();
const float kMaxRotationRate = glm::half_pi<float>();
const float kCameraPitchLimit = glm::quarter_pi<float>() * 0.5f;
const float kVehicleCameraPitch =
@ -35,6 +36,7 @@ IngameState::IngameState(RWGame* game, bool newgame, const std::string& save)
, m_cameraAngles{0.f, glm::half_pi<float>()}
, m_invertedY(game->getConfig().getInputInvertY())
, m_vehicleFreeLook(true) {
_look.frustum.fov = kInGameFOV;
}
void IngameState::startTest() {
@ -43,7 +45,7 @@ void IngameState::startTest() {
getWorld()->state->playerObject = playerChar->getGameObjectID();
glm::vec3 itemspawn(276.5f, -609.f, 36.5f);
for (int i = 1; i < getWorld()->data->weaponData.size(); ++i) {
for (unsigned int i = 1; i < getWorld()->data->weaponData.size(); ++i) {
auto& item = getWorld()->data->weaponData[i];
getWorld()->createPickup(itemspawn, item->modelID,
PickupObject::OnStreet);
@ -141,24 +143,6 @@ void IngameState::tick(float dt) {
return inputEnabled && world->state->input[0].pressed(c);
};
float viewDistance = 4.f;
switch (camMode) {
case IngameState::CAMERA_CLOSE:
viewDistance = 2.f;
break;
case IngameState::CAMERA_NORMAL:
viewDistance = 4.0f;
break;
case IngameState::CAMERA_FAR:
viewDistance = 6.f;
break;
case IngameState::CAMERA_TOPDOWN:
viewDistance = 15.f;
break;
default:
viewDistance = 4.f;
}
auto target = world->pedestrianPool.find(world->state->cameraTarget);
if (target == nullptr) {
@ -170,39 +154,17 @@ void IngameState::tick(float dt) {
targetPosition += glm::vec3(0.f, 0.f, 1.f);
lookTargetPosition += glm::vec3(0.f, 0.f, 0.5f);
btCollisionObject* physTarget = player->getCharacter()->physObject;
auto vehicle =
(target->type() == GameObject::Character)
? static_cast<CharacterObject*>(target)->getCurrentVehicle()
: nullptr;
if (vehicle) {
auto model = vehicle->getModel();
float maxDist = 0.f;
for (auto& g : model->geometries) {
float partSize = glm::length(g->geometryBounds.center) +
g->geometryBounds.radius;
maxDist = std::max(partSize, maxDist);
}
viewDistance = viewDistance + maxDist;
targetPosition = vehicle->getPosition();
lookTargetPosition = targetPosition;
lookTargetPosition.z +=
(vehicle->info->handling.dimensions.z * 0.5f);
targetPosition.z += (vehicle->info->handling.dimensions.z * 0.5f);
physTarget = vehicle->collision->getBulletBody();
if (!m_vehicleFreeLook) {
m_cameraAngles.y = kVehicleCameraPitch;
}
// Rotate the camera to the ideal angle if the player isn't moving
// it
float velocity = vehicle->getVelocity();
if (autolookTimer <= 0.f &&
glm::abs(velocity) > kAutolookMinVelocity) {
auto idealYaw =
-glm::roll(vehicle->getRotation()) + glm::half_pi<float>();
auto idealYaw = glm::roll(vehicle->getRotation());
const auto idealPitch = kVehicleCameraPitch;
if (velocity < 0.f) {
idealYaw = glm::mod(idealYaw - glm::pi<float>(),
@ -225,53 +187,7 @@ void IngameState::tick(float dt) {
}
}
// Non-topdown camera can orbit
if (camMode != IngameState::CAMERA_TOPDOWN) {
bool lookleft = held(GameInputState::LookLeft);
bool lookright = held(GameInputState::LookRight);
if ((lookleft || lookright) && vehicle != nullptr) {
auto rotation = vehicle->getRotation();
if (!lookright) {
rotation *= glm::angleAxis(glm::half_pi<float>(),
glm::vec3(0.f, 0.f, -1.f));
} else if (!lookleft) {
rotation *= glm::angleAxis(glm::half_pi<float>(),
glm::vec3(0.f, 0.f, 1.f));
}
cameraPosition = targetPosition +
rotation * glm::vec3(0.f, viewDistance, 0.f);
} else {
// Determine the "ideal" camera position for the current view
// angles
auto yaw =
glm::angleAxis(m_cameraAngles.x, glm::vec3(0.f, 0.f, -1.f));
auto pitch =
glm::angleAxis(m_cameraAngles.y, glm::vec3(0.f, 1.f, 0.f));
auto cameraOffset =
yaw * pitch * glm::vec3(0.f, 0.f, viewDistance);
cameraPosition = targetPosition + cameraOffset;
}
} else {
cameraPosition = targetPosition + glm::vec3(0.f, 0.f, viewDistance);
}
glm::quat angle;
auto camtotarget = targetPosition - cameraPosition;
auto dir = glm::normalize(camtotarget);
float correction = glm::length(camtotarget) - viewDistance;
if (correction < 0.f) {
float innerDist = viewDistance * 0.1f;
correction = glm::min(0.f, correction + innerDist);
}
cameraPosition += dir * 10.f * correction * dt;
auto lookdir = glm::normalize(lookTargetPosition - cameraPosition);
// Calculate the yaw to look at the target.
float angleYaw = glm::atan(lookdir.y, lookdir.x);
angle = glm::quat(glm::vec3(0.f, 0.f, angleYaw));
glm::vec3 movement;
movement.x = input(GameInputState::GoForward) -
input(GameInputState::GoBackwards);
movement.y =
@ -307,41 +223,14 @@ void IngameState::tick(float dt) {
}
float length = glm::length(movement);
float movementAngle = angleYaw - glm::half_pi<float>();
if (length > 0.1f) {
glm::vec3 direction = glm::normalize(movement);
movementAngle += atan2(direction.y, direction.x);
player->setMoveDirection(glm::vec3(speed, 0.f, 0.f));
auto move = speed * glm::normalize(movement);
player->setMoveDirection(glm::vec3(move.x, 0.f, move.y));
} else {
player->setMoveDirection(glm::vec3(0.f));
}
player->setLookDirection({movementAngle, 0.f});
player->setLookDirection(m_cameraAngles);
}
float len2d = glm::length(glm::vec2(lookdir));
float anglePitch = glm::atan(lookdir.z, len2d);
angle *= glm::quat(glm::vec3(0.f, -anglePitch, 0.f));
// Use rays to ensure target is visible from cameraPosition
auto rayEnd = cameraPosition;
auto rayStart = targetPosition;
auto to = btVector3(rayEnd.x, rayEnd.y, rayEnd.z);
auto from = btVector3(rayStart.x, rayStart.y, rayStart.z);
ClosestNotMeRayResultCallback ray(physTarget, from, to);
world->dynamicsWorld->rayTest(from, to, ray);
if (ray.hasHit() && ray.m_closestHitFraction < 1.f) {
cameraPosition =
glm::vec3(ray.m_hitPointWorld.x(), ray.m_hitPointWorld.y(),
ray.m_hitPointWorld.z());
cameraPosition +=
glm::vec3(ray.m_hitNormalWorld.x(), ray.m_hitNormalWorld.y(),
ray.m_hitNormalWorld.z()) *
0.1f;
}
_look.position = cameraPosition;
_look.rotation = angle;
}
}
@ -424,7 +313,7 @@ void IngameState::handlePlayerInput(const SDL_Event& event) {
if (!m_invertedY) {
mouseMove.y = -mouseMove.y;
}
m_cameraAngles += glm::vec2(mouseMove.x, mouseMove.y);
m_cameraAngles += glm::vec2(-mouseMove.x, mouseMove.y);
m_cameraAngles.y =
glm::clamp(m_cameraAngles.y, kCameraPitchLimit,
glm::pi<float>() - kCameraPitchLimit);
@ -439,6 +328,140 @@ bool IngameState::shouldWorldUpdate() {
return true;
}
const ViewCamera& IngameState::getCamera() {
const ViewCamera& IngameState::getCamera(float alpha) {
auto player = game->getPlayer();
auto world = getWorld();
if (!player) {
return _look;
}
// Force all input to 0 if player input is disabled
/// @todo verify 0ing input is the correct behaviour
const auto inputEnabled = player->isInputEnabled();
auto held = [&](GameInputState::Control c) {
return inputEnabled && world->state->input[0].pressed(c);
};
float viewDistance = getViewDistance();
auto target = getCameraTarget();
bool lookleft = held(GameInputState::LookLeft);
bool lookright = held(GameInputState::LookRight);
btCollisionObject* physTarget = player->getCharacter()->physObject;
auto targetTransform = target->getTimeAdjustedTransform(alpha);
glm::vec3 targetPosition(targetTransform[3]);
glm::vec3 lookTargetPosition(targetPosition);
targetPosition += glm::vec3(0.f, 0.f, 1.f);
lookTargetPosition += glm::vec3(0.f, 0.f, 0.5f);
if (target->type() == GameObject::Vehicle) {
auto vehicle = (VehicleObject*)target;
auto model = vehicle->getModel();
auto maxDist = model->getBoundingRadius() * 2.f;
viewDistance = viewDistance + maxDist;
lookTargetPosition.z += (vehicle->info->handling.dimensions.z * 0.5f);
targetPosition.z += (vehicle->info->handling.dimensions.z * 0.5f);
physTarget = vehicle->collision->getBulletBody();
if (!m_vehicleFreeLook) {
m_cameraAngles.y = kVehicleCameraPitch;
}
}
// Handle top-down camera
if (camMode == CAMERA_TOPDOWN) {
cameraPosition = targetPosition + glm::vec3(0.f, 0.f, viewDistance);
_look.rotation =
glm::angleAxis(glm::half_pi<float>(), glm::vec3(0.f, 1.f, 0.f));
} else if ((lookleft || lookright) &&
target->type() == GameObject::Vehicle) {
auto rotation = target->getRotation();
if (!lookright) {
rotation *= glm::angleAxis(glm::half_pi<float>(),
glm::vec3(0.f, 0.f, -1.f));
} else if (!lookleft) {
rotation *=
glm::angleAxis(glm::half_pi<float>(), glm::vec3(0.f, 0.f, 1.f));
}
cameraPosition =
targetPosition + rotation * glm::vec3(0.f, viewDistance, 0.f);
} else {
// Determine the "ideal" camera position for the current view angles
auto yaw = glm::angleAxis(m_cameraAngles.x - glm::half_pi<float>(),
glm::vec3(0.f, 0.f, 1.f));
auto pitch = glm::angleAxis(m_cameraAngles.y, glm::vec3(0.f, 1.f, 0.f));
auto cameraOffset = yaw * pitch * glm::vec3(0.f, 0.f, viewDistance);
cameraPosition = targetPosition + cameraOffset;
}
auto lookdir = glm::normalize(lookTargetPosition - cameraPosition);
// Calculate the angles to look at the target position
float len2d = glm::length(glm::vec2(lookdir));
float anglePitch = glm::atan(lookdir.z, len2d);
float angleYaw = glm::atan(lookdir.y, lookdir.x);
glm::quat angle(glm::vec3(0.f, -anglePitch, angleYaw));
// Ensure the target position is actually visible
auto rayEnd = cameraPosition;
auto rayStart = targetPosition;
auto to = btVector3(rayEnd.x, rayEnd.y, rayEnd.z);
auto from = btVector3(rayStart.x, rayStart.y, rayStart.z);
ClosestNotMeRayResultCallback ray(physTarget, from, to);
world->dynamicsWorld->rayTest(from, to, ray);
if (ray.hasHit() && ray.m_closestHitFraction < 1.f) {
cameraPosition =
glm::vec3(ray.m_hitPointWorld.x(), ray.m_hitPointWorld.y(),
ray.m_hitPointWorld.z());
cameraPosition +=
glm::vec3(ray.m_hitNormalWorld.x(), ray.m_hitNormalWorld.y(),
ray.m_hitNormalWorld.z()) *
0.1f;
}
_look.position = cameraPosition;
_look.rotation = angle;
return _look;
}
GameObject* IngameState::getCameraTarget() const {
auto target =
getWorld()->pedestrianPool.find(game->getState()->cameraTarget);
if (target == nullptr && game->getPlayer()) {
target = game->getPlayer()->getCharacter();
}
// If the target is a character in a vehicle, make the vehicle the target
if (target && target->type() == GameObject::Character) {
auto vehicle = ((CharacterObject*)target)->getCurrentVehicle();
if (vehicle) {
target = vehicle;
}
}
return target;
}
float IngameState::getViewDistance() const {
float viewDistance = 4.f;
switch (camMode) {
case IngameState::CAMERA_CLOSE:
viewDistance = 2.f;
break;
case IngameState::CAMERA_NORMAL:
viewDistance = 4.0f;
break;
case IngameState::CAMERA_FAR:
viewDistance = 6.f;
break;
case IngameState::CAMERA_TOPDOWN:
viewDistance = 15.f;
break;
default:
viewDistance = 4.f;
}
return viewDistance;
}

6
rwgame/states/IngameState.hpp
View File

@ -32,6 +32,7 @@ class IngameState : public State {
bool m_vehicleFreeLook;
float moneyTimer = 0.f; // Timer used to updated displayed money value
public:
/**
* @brief IngameState
@ -56,7 +57,10 @@ public:
virtual bool shouldWorldUpdate();
const ViewCamera& getCamera();
const ViewCamera& getCamera(float alpha);
private:
GameObject* getCameraTarget() const;
float getViewDistance() const;
};
#endif // INGAMESTATE_HPP