882 lines
36 KiB
C++
882 lines
36 KiB
C++
#include "camera/CameraController.h"
|
|
|
|
#include "common/CameraObstruction.h"
|
|
#include "common/Capability.h"
|
|
#include "common/Json.h"
|
|
#include "graphics/RenderSystem3D.h"
|
|
#include "platform_event/PlatformEvent.h"
|
|
#include "scene/SceneNodeRef.h"
|
|
|
|
#include <simplesquirrel/simplesquirrel.hpp>
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <limits>
|
|
#include <sstream>
|
|
|
|
namespace eve::camera {
|
|
|
|
namespace {
|
|
|
|
std::string jsonString(const std::string& value) {
|
|
std::ostringstream out;
|
|
out << '"';
|
|
for (const unsigned char c : value) {
|
|
switch (c) {
|
|
case '"': out << "\\\""; break;
|
|
case '\\': out << "\\\\"; break;
|
|
case '\b': out << "\\b"; break;
|
|
case '\f': out << "\\f"; break;
|
|
case '\n': out << "\\n"; break;
|
|
case '\r': out << "\\r"; break;
|
|
case '\t': out << "\\t"; break;
|
|
default:
|
|
if (c < 0x20)
|
|
out << "\\u00" << "0123456789abcdef"[c >> 4] << "0123456789abcdef"[c & 0xf];
|
|
else
|
|
out << static_cast<char>(c);
|
|
}
|
|
}
|
|
out << '"';
|
|
return out.str();
|
|
}
|
|
|
|
glm::vec3 jsonVec3(eve::json::Value value, glm::vec3 fallback) {
|
|
if (!value.isArray() || value.size() != 3) return fallback;
|
|
return {value.at(0).asFloat(fallback.x), value.at(1).asFloat(fallback.y),
|
|
value.at(2).asFloat(fallback.z)};
|
|
}
|
|
|
|
} // namespace
|
|
|
|
Module_IMPL(Camera, new Camera());
|
|
|
|
CameraController::CameraController() = default;
|
|
|
|
void CameraController::setCamera(graphics::Camera3D* cam) { cam_ = cam; }
|
|
|
|
graphics::Camera3D* CameraController::getCamera() const { return cam_; }
|
|
|
|
void CameraController::setTarget(float x, float y, float z) {
|
|
targetNodeHost_.clear();
|
|
targetNodeId_.clear();
|
|
target_ = glm::vec3(x, y, z);
|
|
}
|
|
|
|
void CameraController::setTargetNode(scene::SceneNodeRef* node) {
|
|
targetNodeHost_ = node ? node->getHostName() : std::string();
|
|
targetNodeId_ = node ? node->getNodeId() : std::string();
|
|
}
|
|
|
|
float CameraController::getTargetX() const { return target_.x; }
|
|
float CameraController::getTargetY() const { return target_.y; }
|
|
float CameraController::getTargetZ() const { return target_.z; }
|
|
|
|
void CameraController::setOffset(float x, float y, float z) { offset_ = glm::vec3(x, y, z); }
|
|
|
|
void CameraController::setLookAhead(float x, float y, float z) { lookAhead_ = glm::vec3(x, y, z); }
|
|
|
|
bool CameraController::validMode(const std::string& mode) {
|
|
return mode == "follow" || mode == "orbit" || mode == "topdown" || mode == "firstperson" || mode == "cinematic";
|
|
}
|
|
|
|
void CameraController::setMode(const std::string& mode) {
|
|
if (validMode(mode)) mode_ = mode;
|
|
}
|
|
|
|
std::string CameraController::getMode() const { return mode_; }
|
|
|
|
void CameraController::setRadius(float r) { radius_ = std::max(0.01f, r); }
|
|
void CameraController::setAzimuth(float deg) { azimuthDeg_ = deg; }
|
|
void CameraController::setElevation(float deg) { elevationDeg_ = glm::clamp(deg, -89.f, 89.f); }
|
|
void CameraController::setOrbitSpeed(float degPerSec) { orbitSpeedDeg_ = degPerSec; }
|
|
|
|
void CameraController::setYaw(float deg) { yawDeg_ = deg; }
|
|
void CameraController::setPitch(float deg) { pitchDeg_ = glm::clamp(deg, -89.f, 89.f); }
|
|
void CameraController::addInput(float yawDeltaDeg, float pitchDeltaDeg, float zoomDelta) {
|
|
yawDeg_ += yawDeltaDeg;
|
|
azimuthDeg_ += yawDeltaDeg;
|
|
setPitch(pitchDeg_ + pitchDeltaDeg);
|
|
setElevation(elevationDeg_ + pitchDeltaDeg);
|
|
setRadius(radius_ + zoomDelta);
|
|
}
|
|
|
|
void CameraController::setComposition(float screenX, float screenY) {
|
|
composition_ = glm::clamp(glm::vec2(screenX, screenY), glm::vec2(-0.9f), glm::vec2(0.9f));
|
|
}
|
|
|
|
void CameraController::setDeadZone(float radius) { deadZone_ = std::max(0.f, radius); }
|
|
void CameraController::setFov(float degrees) { fovDeg_ = glm::clamp(degrees, 1.f, 179.f); }
|
|
float CameraController::getFov() const { return fovDeg_; }
|
|
|
|
void CameraController::setSmooth(float damping) {
|
|
smooth_ = std::max(0.f, damping);
|
|
positionSmooth_ = smooth_;
|
|
targetSmooth_ = smooth_;
|
|
}
|
|
void CameraController::setPositionSmooth(float damping) { positionSmooth_ = std::max(0.f, damping); }
|
|
void CameraController::setTargetSmooth(float damping) { targetSmooth_ = std::max(0.f, damping); }
|
|
|
|
void CameraController::setMaxSpeed(float unitsPerSec) { maxSpeed_ = std::max(0.f, unitsPerSec); }
|
|
|
|
void CameraController::setCollisionEnabled(bool enabled) { collisionEnabled_ = enabled; }
|
|
void CameraController::setCollisionRadius(float radius) { collisionRadius_ = std::max(0.f, radius); }
|
|
void CameraController::setCollisionRecovery(float damping) { collisionRecovery_ = std::max(0.f, damping); }
|
|
void CameraController::setCollisionMask(uint64_t maskBits) { collisionMask_ = maskBits; }
|
|
void CameraController::setCollisionIgnoredBody(int bodyId) { collisionIgnoredBody_ = bodyId; }
|
|
void CameraController::clearCollisionBoxes() { collisionBoxes_.clear(); }
|
|
void CameraController::addCollisionBox(float minX, float minY, float minZ, float maxX, float maxY, float maxZ) {
|
|
CollisionBox b;
|
|
b.min = glm::min(glm::vec3(minX, minY, minZ), glm::vec3(maxX, maxY, maxZ));
|
|
b.max = glm::max(glm::vec3(minX, minY, minZ), glm::vec3(maxX, maxY, maxZ));
|
|
collisionBoxes_.push_back(b);
|
|
}
|
|
bool CameraController::isObstructed() const { return obstructed_; }
|
|
int CameraController::getCollisionBodyId() const { return collisionBodyId_; }
|
|
|
|
bool CameraController::addRig(const std::string& name, const std::string& mode, int priority) {
|
|
if (name.empty() || !validMode(mode)) return false;
|
|
for (const auto& rig : rigs_)
|
|
if (rig.name == name) return false;
|
|
Rig rig;
|
|
rig.name = name;
|
|
rig.mode = mode;
|
|
rig.priority = priority;
|
|
rigs_.push_back(rig);
|
|
saveRigState(name);
|
|
directorEnabled_ = true;
|
|
return true;
|
|
}
|
|
|
|
bool CameraController::removeRig(const std::string& name) {
|
|
auto it = std::find_if(rigs_.begin(), rigs_.end(), [&](const Rig& r) { return r.name == name; });
|
|
if (it == rigs_.end()) return false;
|
|
rigs_.erase(it);
|
|
if (activeRig_ == name) activeRig_.clear();
|
|
return true;
|
|
}
|
|
|
|
bool CameraController::setRigPriority(const std::string& name, int priority) {
|
|
for (auto& rig : rigs_)
|
|
if (rig.name == name) {
|
|
rig.priority = priority;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CameraController::setRigEnabled(const std::string& name, bool enabled) {
|
|
for (auto& rig : rigs_)
|
|
if (rig.name == name) {
|
|
rig.enabled = enabled;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CameraController::saveRigState(const std::string& name) {
|
|
for (auto& rig : rigs_) {
|
|
if (rig.name != name) continue;
|
|
rig.target = target_;
|
|
rig.offset = offset_;
|
|
rig.lookAhead = lookAhead_;
|
|
rig.composition = composition_;
|
|
rig.radius = radius_;
|
|
rig.azimuth = azimuthDeg_;
|
|
rig.elevation = elevationDeg_;
|
|
rig.yaw = yawDeg_;
|
|
rig.pitch = pitchDeg_;
|
|
rig.fov = fovDeg_;
|
|
rig.smooth = smooth_;
|
|
rig.maxSpeed = maxSpeed_;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CameraController::activateRig(const std::string& name, float blendTime) {
|
|
auto it = std::find_if(rigs_.begin(), rigs_.end(), [&](const Rig& r) { return r.name == name && r.enabled; });
|
|
if (it == rigs_.end()) return false;
|
|
const View from = initialized_ ? cur_ : desired();
|
|
activeRig_ = name;
|
|
mode_ = it->mode;
|
|
target_ = it->target;
|
|
offset_ = it->offset;
|
|
lookAhead_ = it->lookAhead;
|
|
composition_ = it->composition;
|
|
radius_ = it->radius;
|
|
azimuthDeg_ = it->azimuth;
|
|
elevationDeg_ = it->elevation;
|
|
yawDeg_ = it->yaw;
|
|
pitchDeg_ = it->pitch;
|
|
fovDeg_ = it->fov;
|
|
setSmooth(it->smooth);
|
|
maxSpeed_ = it->maxSpeed;
|
|
const bool wasBlending = blending_;
|
|
blending_ = false;
|
|
const View to = desired();
|
|
blending_ = wasBlending;
|
|
if (blendTime > 0.f) {
|
|
blendFrom_ = from;
|
|
blendTo_ = to;
|
|
blendDur_ = blendTime;
|
|
blendT_ = 0.f;
|
|
blending_ = true;
|
|
} else {
|
|
blending_ = false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
std::string CameraController::getActiveRig() const { return activeRig_; }
|
|
|
|
void CameraController::addImpulse(float positionAmplitude, float rotationAmplitude, float duration, unsigned int seed) {
|
|
if (duration <= 0.f || (positionAmplitude <= 0.f && rotationAmplitude <= 0.f)) return;
|
|
impulses_.push_back({std::max(0.f, positionAmplitude), std::max(0.f, rotationAmplitude), duration, 0.f, seed, 0.f});
|
|
}
|
|
void CameraController::addFovImpulse(float degrees, float duration) {
|
|
if (duration <= 0.f || degrees == 0.f) return;
|
|
impulses_.push_back({0.f, 0.f, duration, 0.f, 0u, degrees});
|
|
}
|
|
void CameraController::clearImpulses() { impulses_.clear(); }
|
|
|
|
void CameraController::addView(const std::string& name, float ex, float ey, float ez, float tx, float ty, float tz) {
|
|
View v;
|
|
v.name = name;
|
|
v.eye = glm::vec3(ex, ey, ez);
|
|
v.target = glm::vec3(tx, ty, tz);
|
|
v.fov = fovDeg_;
|
|
views_.push_back(v);
|
|
}
|
|
|
|
bool CameraController::switchTo(const std::string& name, float blendTime) {
|
|
int idx = -1;
|
|
for (int i = 0; i < static_cast<int>(views_.size()); ++i) {
|
|
if (views_[i].name == name) {
|
|
idx = i;
|
|
break;
|
|
}
|
|
}
|
|
if (idx < 0) return false;
|
|
|
|
if (viewIndex_ >= 0 && viewIndex_ < static_cast<int>(views_.size())) {
|
|
blendFrom_ = views_[viewIndex_];
|
|
} else {
|
|
blendFrom_ = cur_;
|
|
}
|
|
blendTo_ = views_[idx];
|
|
viewIndex_ = idx;
|
|
|
|
if (blendTime > 0.f) {
|
|
blending_ = true;
|
|
blendDur_ = blendTime;
|
|
blendT_ = 0.f;
|
|
} else {
|
|
blending_ = false;
|
|
blendDur_ = 1.f;
|
|
blendT_ = 0.f;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void CameraController::playSequence(float stepTime) {
|
|
playing_ = true;
|
|
stepTime_ = stepTime > 0.f ? stepTime : 1.f;
|
|
timer_ = 0.f;
|
|
if (!blending_ && views_.empty()) return;
|
|
if (viewIndex_ < 0 || viewIndex_ >= static_cast<int>(views_.size())) {
|
|
switchTo(views_.front().name, 0.f);
|
|
}
|
|
}
|
|
|
|
void CameraController::stopSequence() { playing_ = false; }
|
|
|
|
bool CameraController::isPlaying() const { return playing_; }
|
|
|
|
void CameraController::clearTimeline() {
|
|
timelineCuts_.clear();
|
|
timelineEvents_.clear();
|
|
timelineFloats_.clear();
|
|
pendingTimelineEvents_.clear();
|
|
timelineDuration_ = 0.f;
|
|
stopTimeline();
|
|
}
|
|
|
|
bool CameraController::addTimelineFloat(float time, const std::string& property, float value) {
|
|
if (time < 0.f || (property != "fov" && property != "radius" && property != "smooth" &&
|
|
property != "compositionX" && property != "compositionY"))
|
|
return false;
|
|
timelineFloats_.push_back({time, property, value});
|
|
std::stable_sort(timelineFloats_.begin(), timelineFloats_.end(), [](const auto& a, const auto& b) {
|
|
return a.time < b.time;
|
|
});
|
|
timelineDuration_ = std::max(timelineDuration_, time);
|
|
return true;
|
|
}
|
|
|
|
bool CameraController::addTimelineCut(float time, const std::string& rigName, float blendTime) {
|
|
if (time < 0.f || blendTime < 0.f) return false;
|
|
const bool known = std::any_of(rigs_.begin(), rigs_.end(), [&](const Rig& r) { return r.name == rigName; });
|
|
if (!known) return false;
|
|
timelineCuts_.push_back({time, rigName, blendTime, false});
|
|
std::stable_sort(timelineCuts_.begin(), timelineCuts_.end(),
|
|
[](const TimelineCut& a, const TimelineCut& b) { return a.time < b.time; });
|
|
timelineDuration_ = std::max(timelineDuration_, time);
|
|
return true;
|
|
}
|
|
|
|
bool CameraController::addTimelineEvent(float time, const std::string& name, const std::string& data) {
|
|
if (time < 0.f || name.empty()) return false;
|
|
timelineEvents_.push_back({time, name, data, false});
|
|
std::stable_sort(timelineEvents_.begin(), timelineEvents_.end(),
|
|
[](const TimelineEvent& a, const TimelineEvent& b) { return a.time < b.time; });
|
|
timelineDuration_ = std::max(timelineDuration_, time);
|
|
return true;
|
|
}
|
|
|
|
void CameraController::setEventSink(platform_event::PlatformEvent* sink) { eventSink_ = sink; }
|
|
|
|
void CameraController::playTimeline(bool loop) {
|
|
timelineLoop_ = loop;
|
|
timelinePlaying_ = !timelineCuts_.empty() || !timelineEvents_.empty();
|
|
}
|
|
void CameraController::pauseTimeline() { timelinePlaying_ = false; }
|
|
void CameraController::stopTimeline() {
|
|
timelinePlaying_ = false;
|
|
timelineTime_ = 0.f;
|
|
for (auto& cut : timelineCuts_) cut.fired = false;
|
|
for (auto& event : timelineEvents_) event.fired = false;
|
|
}
|
|
void CameraController::seekTimeline(float time, bool fireEvents) {
|
|
timelineTime_ = glm::clamp(time, 0.f, std::max(0.f, timelineDuration_));
|
|
for (auto& cut : timelineCuts_) cut.fired = cut.time <= timelineTime_;
|
|
const TimelineCut* latest = nullptr;
|
|
for (const auto& cut : timelineCuts_)
|
|
if (cut.time <= timelineTime_) latest = &cut;
|
|
if (latest) activateRig(latest->rig, 0.f);
|
|
for (auto& marker : timelineEvents_) {
|
|
marker.fired = marker.time <= timelineTime_;
|
|
if (fireEvents && marker.fired) emitTimelineEvent(marker);
|
|
}
|
|
evaluateTimelineFloats();
|
|
}
|
|
bool CameraController::isTimelinePlaying() const { return timelinePlaying_; }
|
|
float CameraController::getTimelineTime() const { return timelineTime_; }
|
|
std::string CameraController::consumeTimelineEvent() {
|
|
if (pendingTimelineEvents_.empty()) return {};
|
|
auto [out, data] = std::move(pendingTimelineEvents_.front());
|
|
pendingTimelineEvents_.pop_front();
|
|
consumedTimelineEventData_ = std::move(data);
|
|
return out;
|
|
}
|
|
std::string CameraController::getTimelineEventData() const { return consumedTimelineEventData_; }
|
|
int CameraController::getPendingTimelineEventCount() const { return static_cast<int>(pendingTimelineEvents_.size()); }
|
|
float CameraController::getTimelineDuration() const { return timelineDuration_; }
|
|
int CameraController::getRigCount() const { return static_cast<int>(rigs_.size()); }
|
|
|
|
std::string CameraController::serializeAsset() const {
|
|
std::ostringstream out;
|
|
out << "{\"version\":1,\"rigs\":[";
|
|
bool first = true;
|
|
for (const auto& rig : rigs_) {
|
|
if (!first) out << ',';
|
|
first = false;
|
|
out << "{\"name\":" << jsonString(rig.name) << ",\"mode\":" << jsonString(rig.mode)
|
|
<< ",\"priority\":" << rig.priority << ",\"enabled\":" << (rig.enabled ? "true" : "false")
|
|
<< ",\"target\":[" << rig.target.x << ',' << rig.target.y << ',' << rig.target.z
|
|
<< "],\"offset\":[" << rig.offset.x << ',' << rig.offset.y << ',' << rig.offset.z
|
|
<< "],\"lookAhead\":[" << rig.lookAhead.x << ',' << rig.lookAhead.y << ',' << rig.lookAhead.z
|
|
<< "],\"composition\":[" << rig.composition.x << ',' << rig.composition.y << "]"
|
|
<< ",\"radius\":" << rig.radius << ",\"azimuth\":" << rig.azimuth
|
|
<< ",\"elevation\":" << rig.elevation << ",\"yaw\":" << rig.yaw << ",\"pitch\":" << rig.pitch
|
|
<< ",\"fov\":" << rig.fov << ",\"smooth\":" << rig.smooth << ",\"maxSpeed\":" << rig.maxSpeed << '}';
|
|
}
|
|
out << "],\"cuts\":[";
|
|
first = true;
|
|
for (const auto& cut : timelineCuts_) {
|
|
if (!first) out << ',';
|
|
first = false;
|
|
out << "{\"time\":" << cut.time << ",\"rig\":" << jsonString(cut.rig) << ",\"blend\":" << cut.blend << '}';
|
|
}
|
|
out << "],\"events\":[";
|
|
first = true;
|
|
for (const auto& marker : timelineEvents_) {
|
|
if (!first) out << ',';
|
|
first = false;
|
|
out << "{\"time\":" << marker.time << ",\"name\":" << jsonString(marker.name)
|
|
<< ",\"data\":" << jsonString(marker.data) << '}';
|
|
}
|
|
out << "],\"floats\":[";
|
|
first = true;
|
|
for (const auto& key : timelineFloats_) {
|
|
if (!first) out << ',';
|
|
first = false;
|
|
out << "{\"time\":" << key.time << ",\"property\":" << jsonString(key.property)
|
|
<< ",\"value\":" << key.value << '}';
|
|
}
|
|
out << "]}";
|
|
return out.str();
|
|
}
|
|
|
|
bool CameraController::deserializeAsset(const std::string& text) {
|
|
const auto document = eve::json::Document::parse(text);
|
|
const auto root = document.root();
|
|
if (!root.isObject() || root.getInt("version", 0) != 1) return false;
|
|
std::vector<Rig> newRigs;
|
|
const auto rigs = root.get("rigs");
|
|
if (rigs && !rigs.isArray()) return false;
|
|
for (size_t i = 0; i < rigs.size(); ++i) {
|
|
const auto item = rigs.at(i);
|
|
if (!item.isObject()) return false;
|
|
Rig rig;
|
|
rig.name = item.getString("name");
|
|
rig.mode = item.getString("mode");
|
|
if (rig.name.empty() || !validMode(rig.mode)) return false;
|
|
rig.priority = item.getInt("priority");
|
|
rig.enabled = item.getBool("enabled", true);
|
|
rig.target = jsonVec3(item.get("target"), rig.target);
|
|
rig.offset = jsonVec3(item.get("offset"), rig.offset);
|
|
rig.lookAhead = jsonVec3(item.get("lookAhead"), rig.lookAhead);
|
|
const auto composition = item.get("composition");
|
|
if (composition.isArray() && composition.size() == 2)
|
|
rig.composition = {composition.at(0).asFloat(), composition.at(1).asFloat()};
|
|
rig.radius = item.getFloat("radius", rig.radius);
|
|
rig.azimuth = item.getFloat("azimuth", rig.azimuth);
|
|
rig.elevation = item.getFloat("elevation", rig.elevation);
|
|
rig.yaw = item.getFloat("yaw", rig.yaw);
|
|
rig.pitch = item.getFloat("pitch", rig.pitch);
|
|
rig.fov = item.getFloat("fov", rig.fov);
|
|
rig.smooth = item.getFloat("smooth", rig.smooth);
|
|
rig.maxSpeed = item.getFloat("maxSpeed", rig.maxSpeed);
|
|
newRigs.push_back(std::move(rig));
|
|
}
|
|
clearTimeline();
|
|
rigs_ = std::move(newRigs);
|
|
activeRig_.clear();
|
|
directorEnabled_ = !rigs_.empty();
|
|
const auto cuts = root.get("cuts");
|
|
if (cuts && !cuts.isArray()) return false;
|
|
for (size_t i = 0; i < cuts.size(); ++i) {
|
|
const auto item = cuts.at(i);
|
|
if (!item.isObject() || !addTimelineCut(item.getFloat("time", -1.f), item.getString("rig"),
|
|
item.getFloat("blend", 0.f)))
|
|
return false;
|
|
}
|
|
const auto events = root.get("events");
|
|
if (events && !events.isArray()) return false;
|
|
for (size_t i = 0; i < events.size(); ++i) {
|
|
const auto item = events.at(i);
|
|
if (!item.isObject() || !addTimelineEvent(item.getFloat("time", -1.f), item.getString("name"),
|
|
item.getString("data")))
|
|
return false;
|
|
}
|
|
const auto floats = root.get("floats");
|
|
if (floats && !floats.isArray()) return false;
|
|
for (size_t i = 0; i < floats.size(); ++i) {
|
|
const auto item = floats.at(i);
|
|
if (!item.isObject() || !addTimelineFloat(item.getFloat("time", -1.f), item.getString("property"),
|
|
item.getFloat("value")))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void CameraController::emitTimelineEvent(const TimelineEvent& marker) {
|
|
pendingTimelineEvents_.emplace_back(marker.name, marker.data);
|
|
if (eventSink_) eventSink_->pushData(marker.name, marker.data);
|
|
}
|
|
|
|
void CameraController::evaluateTimelineFloats() {
|
|
for (const std::string property : {"fov", "radius", "smooth", "compositionX", "compositionY"}) {
|
|
const TimelineFloat* before = nullptr;
|
|
const TimelineFloat* after = nullptr;
|
|
for (const auto& key : timelineFloats_) {
|
|
if (key.property != property) continue;
|
|
if (key.time <= timelineTime_) before = &key;
|
|
if (key.time >= timelineTime_) {
|
|
after = &key;
|
|
break;
|
|
}
|
|
}
|
|
if (!before && !after) continue;
|
|
if (!before) before = after;
|
|
if (!after) after = before;
|
|
const float span = after->time - before->time;
|
|
const float t = span > 1e-6f ? (timelineTime_ - before->time) / span : 0.f;
|
|
const float value = glm::mix(before->value, after->value, glm::clamp(t, 0.f, 1.f));
|
|
if (property == "fov") setFov(value);
|
|
else if (property == "radius") setRadius(value);
|
|
else if (property == "smooth") setSmooth(value);
|
|
else if (property == "compositionX") setComposition(value, composition_.y);
|
|
else setComposition(composition_.x, value);
|
|
}
|
|
}
|
|
|
|
void CameraController::updateTrackedTarget() {
|
|
if (targetNodeHost_.empty() || targetNodeId_.empty()) return;
|
|
const scene::SceneNodeRef node(targetNodeHost_, targetNodeId_);
|
|
if (!node.isValid()) return;
|
|
const glm::vec3 observed(node.getWorldPositionX(), node.getWorldPositionY(), node.getWorldPositionZ());
|
|
if (!deadZoneInitialized_ || deadZone_ <= 0.f) {
|
|
deadZoneTarget_ = observed;
|
|
deadZoneInitialized_ = true;
|
|
} else {
|
|
const glm::vec3 delta = observed - deadZoneTarget_;
|
|
const float length = glm::length(delta);
|
|
if (length > deadZone_ && length > 1e-6f) deadZoneTarget_ += delta * ((length - deadZone_) / length);
|
|
}
|
|
target_ = deadZoneTarget_;
|
|
}
|
|
|
|
void CameraController::updateDirector() {
|
|
if (!directorEnabled_ || timelinePlaying_) return;
|
|
const Rig* best = nullptr;
|
|
const Rig* active = nullptr;
|
|
for (const auto& rig : rigs_) {
|
|
if (rig.name == activeRig_ && rig.enabled) active = &rig;
|
|
if (rig.enabled && (!best || rig.priority > best->priority)) best = &rig;
|
|
}
|
|
if (active && best && active->priority >= best->priority) best = active;
|
|
if (best && best->name != activeRig_) activateRig(best->name, initialized_ ? 0.25f : 0.f);
|
|
}
|
|
|
|
void CameraController::updateTimeline(float dt) {
|
|
if (!timelinePlaying_) return;
|
|
float remaining = std::max(0.f, dt);
|
|
if (timelineDuration_ <= 0.f) remaining = 0.f;
|
|
timelineTime_ += remaining;
|
|
for (auto& cut : timelineCuts_) {
|
|
if (!cut.fired && cut.time <= timelineTime_) {
|
|
cut.fired = true;
|
|
activateRig(cut.rig, cut.blend);
|
|
}
|
|
}
|
|
for (auto& marker : timelineEvents_) {
|
|
if (!marker.fired && marker.time <= timelineTime_) {
|
|
marker.fired = true;
|
|
emitTimelineEvent(marker);
|
|
}
|
|
}
|
|
evaluateTimelineFloats();
|
|
if (timelineTime_ < timelineDuration_) return;
|
|
if (!timelineLoop_) {
|
|
timelinePlaying_ = false;
|
|
return;
|
|
}
|
|
timelineTime_ = timelineDuration_ > 0.f ? std::fmod(timelineTime_, timelineDuration_) : 0.f;
|
|
for (auto& cut : timelineCuts_) cut.fired = false;
|
|
for (auto& marker : timelineEvents_) marker.fired = false;
|
|
for (auto& cut : timelineCuts_)
|
|
if (cut.time <= timelineTime_) {
|
|
cut.fired = true;
|
|
activateRig(cut.rig, cut.blend);
|
|
}
|
|
for (auto& marker : timelineEvents_)
|
|
if (marker.time <= timelineTime_) {
|
|
marker.fired = true;
|
|
emitTimelineEvent(marker);
|
|
}
|
|
evaluateTimelineFloats();
|
|
}
|
|
|
|
void CameraController::applyCollision(View& v, float dt) {
|
|
obstructed_ = false;
|
|
collisionBodyId_ = -1;
|
|
const glm::vec3 ray = v.eye - v.target;
|
|
const float desiredDistance = glm::length(ray);
|
|
if (!collisionEnabled_ || desiredDistance < 1e-5f) {
|
|
collisionDistance_ = -1.f;
|
|
return;
|
|
}
|
|
const glm::vec3 dir = ray / desiredDistance;
|
|
float nearest = desiredDistance;
|
|
for (const auto& box : collisionBoxes_) {
|
|
const glm::vec3 bmin = box.min - glm::vec3(collisionRadius_);
|
|
const glm::vec3 bmax = box.max + glm::vec3(collisionRadius_);
|
|
float tmin = 0.f;
|
|
float tmax = desiredDistance;
|
|
bool hit = true;
|
|
for (int axis = 0; axis < 3; ++axis) {
|
|
if (std::abs(dir[axis]) < 1e-6f) {
|
|
if (v.target[axis] < bmin[axis] || v.target[axis] > bmax[axis]) {
|
|
hit = false;
|
|
break;
|
|
}
|
|
} else {
|
|
float a = (bmin[axis] - v.target[axis]) / dir[axis];
|
|
float b = (bmax[axis] - v.target[axis]) / dir[axis];
|
|
if (a > b) std::swap(a, b);
|
|
tmin = std::max(tmin, a);
|
|
tmax = std::min(tmax, b);
|
|
if (tmin > tmax) {
|
|
hit = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (hit && tmin >= 0.f && tmin < nearest) nearest = tmin;
|
|
}
|
|
if (auto* query = eve::cap::query<eve::ICameraObstructionQuery>()) {
|
|
eve::CameraObstructionHit hit;
|
|
if (query->sphereCast(v.target.x, v.target.y, v.target.z, v.eye.x, v.eye.y, v.eye.z,
|
|
collisionRadius_, collisionMask_, collisionIgnoredBody_, &hit) &&
|
|
hit.hit) {
|
|
const float distance = desiredDistance * glm::clamp(hit.fraction, 0.f, 1.f);
|
|
if (distance < nearest) {
|
|
nearest = distance;
|
|
collisionBodyId_ = hit.bodyId;
|
|
}
|
|
}
|
|
}
|
|
obstructed_ = nearest < desiredDistance;
|
|
const float safeDistance = obstructed_ ? std::max(0.05f, nearest - 0.02f) : desiredDistance;
|
|
if (collisionDistance_ < 0.f || safeDistance < collisionDistance_)
|
|
collisionDistance_ = safeDistance;
|
|
else {
|
|
const float k = 1.f - std::exp(-collisionRecovery_ * std::max(0.f, dt));
|
|
collisionDistance_ += (safeDistance - collisionDistance_) * k;
|
|
}
|
|
collisionDistance_ = std::min(collisionDistance_, desiredDistance);
|
|
v.eye = v.target + dir * collisionDistance_;
|
|
}
|
|
|
|
void CameraController::applyModifiers(View& v, float dt) {
|
|
for (auto& impulse : impulses_) {
|
|
impulse.age += std::max(0.f, dt);
|
|
const float life = glm::clamp(1.f - impulse.age / impulse.duration, 0.f, 1.f);
|
|
const float phase = impulse.age * 37.f + static_cast<float>(impulse.seed % 997u);
|
|
const glm::vec3 noise(std::sin(phase * 1.13f), std::sin(phase * 1.71f + 2.f), std::sin(phase * 2.07f + 4.f));
|
|
v.eye += noise * (impulse.positionAmplitude * life);
|
|
const glm::vec3 forward = glm::normalize(v.target - v.eye);
|
|
glm::vec3 right = glm::cross(forward, glm::vec3(0.f, 1.f, 0.f));
|
|
if (glm::length(right) > 1e-5f)
|
|
right = glm::normalize(right);
|
|
else
|
|
right = glm::vec3(1.f, 0.f, 0.f);
|
|
const glm::vec3 up = glm::normalize(glm::cross(right, forward));
|
|
const float angular = std::tan(glm::radians(impulse.rotationAmplitude * life));
|
|
v.target += (right * noise.x + up * noise.y) * angular * glm::length(v.target - v.eye);
|
|
v.fov = glm::clamp(v.fov + impulse.fovAmplitude * life, 1.f, 179.f);
|
|
}
|
|
impulses_.erase(
|
|
std::remove_if(impulses_.begin(), impulses_.end(), [](const Impulse& i) { return i.age >= i.duration; }),
|
|
impulses_.end());
|
|
}
|
|
|
|
CameraController::View CameraController::desired() const {
|
|
View v;
|
|
v.fov = fovDeg_;
|
|
if (blending_) {
|
|
float t = blendDur_ > 0.f ? glm::clamp(blendT_ / blendDur_, 0.f, 1.f) : 1.f;
|
|
t = t * t * (3.f - 2.f * t);
|
|
v.eye = glm::mix(blendFrom_.eye, blendTo_.eye, t);
|
|
v.target = glm::mix(blendFrom_.target, blendTo_.target, t);
|
|
v.fov = glm::mix(blendFrom_.fov, blendTo_.fov, t);
|
|
} else if (mode_ == "orbit") {
|
|
const float az = glm::radians(azimuthDeg_);
|
|
const float el = glm::radians(elevationDeg_);
|
|
glm::vec3 dir(std::cos(el) * std::sin(az), std::sin(el), std::cos(el) * std::cos(az));
|
|
v.eye = target_ + dir * radius_;
|
|
v.target = target_;
|
|
} else if (mode_ == "topdown") {
|
|
v.eye = target_ + glm::vec3(0.f, radius_, 0.f);
|
|
v.target = target_;
|
|
} else if (mode_ == "firstperson") {
|
|
v.eye = target_;
|
|
const float yaw = glm::radians(yawDeg_);
|
|
const float pitch = glm::radians(pitchDeg_);
|
|
glm::vec3 dir(std::cos(pitch) * std::sin(yaw), std::sin(pitch), std::cos(pitch) * std::cos(yaw));
|
|
v.target = v.eye + dir * 100.f;
|
|
} else if (mode_ == "cinematic") {
|
|
if (viewIndex_ >= 0 && viewIndex_ < static_cast<int>(views_.size())) {
|
|
v = views_[viewIndex_];
|
|
} else {
|
|
v.target = target_ + lookAhead_;
|
|
v.eye = v.target + offset_;
|
|
}
|
|
} else { // follow (默认)
|
|
v.target = target_ + lookAhead_;
|
|
v.eye = v.target + offset_;
|
|
}
|
|
const glm::vec3 forward = glm::normalize(v.target - v.eye);
|
|
glm::vec3 right = glm::cross(forward, glm::vec3(0.f, 1.f, 0.f));
|
|
if (glm::length(right) < 1e-5f)
|
|
right = glm::vec3(1.f, 0.f, 0.f);
|
|
else
|
|
right = glm::normalize(right);
|
|
glm::vec3 up = glm::normalize(glm::cross(right, forward));
|
|
const float distance = glm::length(v.target - v.eye);
|
|
v.target += (right * composition_.x + up * composition_.y) * distance;
|
|
return v;
|
|
}
|
|
|
|
void CameraController::applyView(const View& v) {
|
|
if (!cam_) return;
|
|
cam_->setEye(v.eye.x, v.eye.y, v.eye.z);
|
|
cam_->setTarget(v.target.x, v.target.y, v.target.z);
|
|
const glm::vec3 forward = glm::normalize(v.target - v.eye);
|
|
glm::vec3 up(0.f, 1.f, 0.f);
|
|
if (std::abs(glm::dot(forward, up)) > 0.999f) up = glm::vec3(0.f, 0.f, -1.f);
|
|
cam_->setUp(up.x, up.y, up.z);
|
|
cam_->setFov(v.fov);
|
|
}
|
|
|
|
void CameraController::easeToward(const View& v, float dt) {
|
|
const float eyeK = 1.f - std::exp(-positionSmooth_ * dt);
|
|
const float targetK = 1.f - std::exp(-targetSmooth_ * dt);
|
|
glm::vec3 deye = (v.eye - cur_.eye) * eyeK;
|
|
glm::vec3 dtgt = (v.target - cur_.target) * targetK;
|
|
if (maxSpeed_ > 0.f && dt > 0.f) {
|
|
const float maxStep = maxSpeed_ * dt;
|
|
const float le = glm::length(deye);
|
|
if (le > maxStep && le > 1e-6f) deye *= maxStep / le;
|
|
const float lt = glm::length(dtgt);
|
|
if (lt > maxStep && lt > 1e-6f) dtgt *= maxStep / lt;
|
|
}
|
|
cur_.eye += deye;
|
|
cur_.target += dtgt;
|
|
cur_.fov += (v.fov - cur_.fov) * eyeK;
|
|
}
|
|
|
|
void CameraController::snap() {
|
|
cur_ = desired();
|
|
initialized_ = true;
|
|
applyView(cur_);
|
|
}
|
|
|
|
void CameraController::update(float dt) {
|
|
if (!cam_) return;
|
|
|
|
dt = std::max(0.f, dt);
|
|
updateTrackedTarget();
|
|
updateTimeline(dt);
|
|
updateDirector();
|
|
|
|
if (mode_ == "cinematic" && playing_ && !views_.empty()) {
|
|
timer_ += dt;
|
|
if (!blending_ && timer_ >= stepTime_) {
|
|
const int next = (viewIndex_ + 1) % static_cast<int>(views_.size());
|
|
switchTo(views_[next].name, blendDur_);
|
|
timer_ = 0.f;
|
|
}
|
|
}
|
|
|
|
if (blending_) {
|
|
blendT_ += dt;
|
|
if (blendT_ >= blendDur_) {
|
|
blending_ = false;
|
|
blendT_ = blendDur_;
|
|
}
|
|
}
|
|
|
|
// orbit 自动盘旋：不断累积方位角
|
|
if (mode_ == "orbit") {
|
|
azimuthDeg_ += orbitSpeedDeg_ * dt;
|
|
}
|
|
|
|
View d = desired();
|
|
applyCollision(d, dt);
|
|
applyModifiers(d, dt);
|
|
|
|
if (!initialized_) {
|
|
cur_ = d;
|
|
initialized_ = true;
|
|
}
|
|
easeToward(d, dt);
|
|
applyView(cur_);
|
|
}
|
|
|
|
void Camera::expose(ssq::Class& cls) {
|
|
// 模块级方法（如需要可在此添加）；当前只通过 eve.CameraController 暴露控制器。
|
|
}
|
|
|
|
void Camera::expose(ssq::Table& table) {
|
|
auto cls = table.addClass(name, Camera::create, false);
|
|
expose(cls);
|
|
|
|
auto cc = table.addClass<CameraController>(
|
|
"CameraController", std::function<CameraController*()>([]() { return new CameraController(); }), true);
|
|
|
|
cc.addFunc("setCamera", &CameraController::setCamera);
|
|
cc.addFunc("getCamera", &CameraController::getCamera);
|
|
|
|
cc.addFunc("setTarget", &CameraController::setTarget);
|
|
cc.addFunc("setTargetNode", &CameraController::setTargetNode);
|
|
cc.addFunc("getTargetX", &CameraController::getTargetX);
|
|
cc.addFunc("getTargetY", &CameraController::getTargetY);
|
|
cc.addFunc("getTargetZ", &CameraController::getTargetZ);
|
|
cc.addFunc("setOffset", &CameraController::setOffset);
|
|
cc.addFunc("setLookAhead", &CameraController::setLookAhead);
|
|
|
|
cc.addFunc("setMode", &CameraController::setMode);
|
|
cc.addFunc("getMode", &CameraController::getMode);
|
|
|
|
cc.addFunc("setRadius", &CameraController::setRadius);
|
|
cc.addFunc("setAzimuth", &CameraController::setAzimuth);
|
|
cc.addFunc("setElevation", &CameraController::setElevation);
|
|
cc.addFunc("setOrbitSpeed", &CameraController::setOrbitSpeed);
|
|
|
|
cc.addFunc("setYaw", &CameraController::setYaw);
|
|
cc.addFunc("setPitch", &CameraController::setPitch);
|
|
cc.addFunc("addInput", &CameraController::addInput);
|
|
cc.addFunc("setComposition", &CameraController::setComposition);
|
|
cc.addFunc("setDeadZone", &CameraController::setDeadZone);
|
|
cc.addFunc("setFov", &CameraController::setFov);
|
|
cc.addFunc("getFov", &CameraController::getFov);
|
|
|
|
cc.addFunc("setSmooth", &CameraController::setSmooth);
|
|
cc.addFunc("setPositionSmooth", &CameraController::setPositionSmooth);
|
|
cc.addFunc("setTargetSmooth", &CameraController::setTargetSmooth);
|
|
cc.addFunc("setMaxSpeed", &CameraController::setMaxSpeed);
|
|
cc.addFunc("snap", &CameraController::snap);
|
|
cc.addFunc("setCollisionEnabled", &CameraController::setCollisionEnabled);
|
|
cc.addFunc("setCollisionRadius", &CameraController::setCollisionRadius);
|
|
cc.addFunc("setCollisionRecovery", &CameraController::setCollisionRecovery);
|
|
cc.addFunc("setCollisionMask", &CameraController::setCollisionMask);
|
|
cc.addFunc("setCollisionIgnoredBody", &CameraController::setCollisionIgnoredBody);
|
|
cc.addFunc("clearCollisionBoxes", &CameraController::clearCollisionBoxes);
|
|
cc.addFunc("addCollisionBox", &CameraController::addCollisionBox);
|
|
cc.addFunc("getCollisionBodyId", &CameraController::getCollisionBodyId);
|
|
cc.addFunc("isObstructed", &CameraController::isObstructed);
|
|
|
|
cc.addFunc("addRig", &CameraController::addRig);
|
|
cc.addFunc("removeRig", &CameraController::removeRig);
|
|
cc.addFunc("setRigPriority", &CameraController::setRigPriority);
|
|
cc.addFunc("setRigEnabled", &CameraController::setRigEnabled);
|
|
cc.addFunc("saveRigState", &CameraController::saveRigState);
|
|
cc.addFunc("activateRig", &CameraController::activateRig);
|
|
cc.addFunc("getActiveRig", &CameraController::getActiveRig);
|
|
cc.addFunc("addImpulse", &CameraController::addImpulse);
|
|
cc.addFunc("addFovImpulse", &CameraController::addFovImpulse);
|
|
cc.addFunc("clearImpulses", &CameraController::clearImpulses);
|
|
|
|
cc.addFunc("addView", &CameraController::addView);
|
|
cc.addFunc("switchTo", &CameraController::switchTo);
|
|
cc.addFunc("playSequence", &CameraController::playSequence);
|
|
cc.addFunc("stopSequence", &CameraController::stopSequence);
|
|
cc.addFunc("isPlaying", &CameraController::isPlaying);
|
|
|
|
cc.addFunc("clearTimeline", &CameraController::clearTimeline);
|
|
cc.addFunc("addTimelineCut", &CameraController::addTimelineCut);
|
|
cc.addFunc("addTimelineEvent", &CameraController::addTimelineEvent);
|
|
cc.addFunc("addTimelineFloat", &CameraController::addTimelineFloat);
|
|
cc.addFunc("setEventSink", &CameraController::setEventSink);
|
|
cc.addFunc("playTimeline", &CameraController::playTimeline);
|
|
cc.addFunc("pauseTimeline", &CameraController::pauseTimeline);
|
|
cc.addFunc("stopTimeline", &CameraController::stopTimeline);
|
|
cc.addFunc("seekTimeline", &CameraController::seekTimeline);
|
|
cc.addFunc("isTimelinePlaying", &CameraController::isTimelinePlaying);
|
|
cc.addFunc("getTimelineTime", &CameraController::getTimelineTime);
|
|
cc.addFunc("consumeTimelineEvent", &CameraController::consumeTimelineEvent);
|
|
cc.addFunc("getTimelineEventData", &CameraController::getTimelineEventData);
|
|
cc.addFunc("getPendingTimelineEventCount", &CameraController::getPendingTimelineEventCount);
|
|
cc.addFunc("getTimelineDuration", &CameraController::getTimelineDuration);
|
|
cc.addFunc("getRigCount", &CameraController::getRigCount);
|
|
cc.addFunc("serializeAsset", &CameraController::serializeAsset);
|
|
cc.addFunc("deserializeAsset", &CameraController::deserializeAsset);
|
|
|
|
cc.addFunc("update", &CameraController::update);
|
|
}
|
|
|
|
} // namespace eve::camera
|