CameraTarget.cpp

浏览该文件的文档.

#include "camera/editing/CameraTarget.h"
 
#include <algorithm>
#include <cmath>
#include <set>
#include <utility>
 
namespace eve::camera_editing {
namespace {
const EditorValue* field(const EditorValue& value,const char* key){const auto* object=value.getIf<EditorValue::Object>();if(!object)return nullptr;const auto it=object->find(key);return it==object->end()?nullptr:&it->second;}
EditorValue vec2(glm::vec2 v){return EditorValue::Array{v.x,v.y};}
EditorValue vec3(glm::vec3 v){return EditorValue::Array{v.x,v.y,v.z};}
bool readVec(const EditorValue* value,float* out,std::size_t count){const auto* array=value?value->getIf<EditorValue::Array>():nullptr;if(!array||array->size()!=count)return false;for(std::size_t i=0;i<count;++i){const auto* number=(*array)[i].getIf<double>();if(!number||!std::isfinite(*number))return false;out[i]=static_cast<float>(*number);}return true;}
bool finite(float value){return std::isfinite(value);}
bool modeValid(const std::string& value){return value=="follow"||value=="orbit"||value=="topdown"||value=="firstperson"||value=="cinematic";}
bool propertyValid(const std::string& value){return value=="fov"||value=="radius"||value=="smooth"||value=="compositionX"||value=="compositionY";}
EditorValue rigValue(const CameraRigValue& r){return EditorValue::Object{{"id",r.id.value()},{"name",r.name},{"mode",r.mode},{"priority",int64_t{r.priority}},{"enabled",r.enabled},{"target",vec3(r.target)},{"offset",vec3(r.offset)},{"lookAhead",vec3(r.lookAhead)},{"composition",vec2(r.composition)},{"radius",r.radius},{"azimuth",r.azimuth},{"elevation",r.elevation},{"yaw",r.yaw},{"pitch",r.pitch},{"fov",r.fov},{"smooth",r.smooth},{"maxSpeed",r.maxSpeed}};}
EditorValue keyValue(const CameraTimelineKeyValue& k){return EditorValue::Object{{"id",k.id.value()},{"kind",k.kind},{"time",k.time},{"rig",k.rig.value()},{"blend",k.blend},{"property",k.property},{"value",k.value},{"name",k.name},{"data",k.data}};}
Result<CameraRigValue> parseRig(const EditorValue& value){CameraRigValue r;const auto* id=field(value,"id"),*name=field(value,"name"),*mode=field(value,"mode"),*priority=field(value,"priority"),*enabled=field(value,"enabled");const auto* ids=id?id->getIf<std::string>():nullptr;const auto* names=name?name->getIf<std::string>():nullptr;const auto* modes=mode?mode->getIf<std::string>():nullptr;const auto* priorities=priority?priority->getIf<int64_t>():nullptr;const auto* enableds=enabled?enabled->getIf<bool>():nullptr;if(!ids||ids->empty()||!names||names->empty()||!modes||!priorities||!enableds)return eve::editing::failed<CameraRigValue>(EditorStatus::Rejected, RuleId("editor.camera.rig"), "Camera rig identity fields are invalid");r.id=ObjectId(*ids);r.name=*names;r.mode=*modes;r.priority=static_cast<int>(*priorities);r.enabled=*enableds;if(!readVec(field(value,"target"),&r.target.x,3)||!readVec(field(value,"offset"),&r.offset.x,3)||!readVec(field(value,"lookAhead"),&r.lookAhead.x,3)||!readVec(field(value,"composition"),&r.composition.x,2))return eve::editing::failed<CameraRigValue>(EditorStatus::Rejected, RuleId("editor.camera.vector"), "Camera rig vectors are invalid");float* values[]={&r.radius,&r.azimuth,&r.elevation,&r.yaw,&r.pitch,&r.fov,&r.smooth,&r.maxSpeed};const char* names2[]={"radius","azimuth","elevation","yaw","pitch","fov","smooth","maxSpeed"};for(int i=0;i<8;++i){const auto* v=field(value,names2[i]);const auto* n=v?v->getIf<double>():nullptr;if(!n||!std::isfinite(*n))return eve::editing::failed<CameraRigValue>(EditorStatus::Rejected, RuleId("editor.camera.number"), "Camera rig scalar is invalid");*values[i]=static_cast<float>(*n);}return eve::editing::applied<CameraRigValue>(std::move(r));}
Result<CameraTimelineKeyValue> parseKey(const EditorValue& value){CameraTimelineKeyValue k;const auto* id=field(value,"id"),*kind=field(value,"kind"),*rig=field(value,"rig"),*property=field(value,"property"),*name=field(value,"name"),*data=field(value,"data");const auto* ids=id?id->getIf<std::string>():nullptr;const auto* kinds=kind?kind->getIf<std::string>():nullptr;const auto* rigs=rig?rig->getIf<std::string>():nullptr;const auto* properties=property?property->getIf<std::string>():nullptr;const auto* names=name?name->getIf<std::string>():nullptr;const auto* datas=data?data->getIf<std::string>():nullptr;if(!ids||ids->empty()||!kinds||!rigs||!properties||!names||!datas)return eve::editing::failed<CameraTimelineKeyValue>(EditorStatus::Rejected, RuleId("editor.camera.key"), "Camera timeline key fields are invalid");k.id=ObjectId(*ids);k.kind=*kinds;k.rig=ObjectId(*rigs);k.property=*properties;k.name=*names;k.data=*datas;float* values[]={&k.time,&k.blend,&k.value};const char* fields[]={"time","blend","value"};for(int i=0;i<3;++i){const auto* v=field(value,fields[i]);const auto* n=v?v->getIf<double>():nullptr;if(!n||!std::isfinite(*n))return eve::editing::failed<CameraTimelineKeyValue>(EditorStatus::Rejected, RuleId("editor.camera.key-number"), "Camera timeline scalar is invalid");*values[i]=static_cast<float>(*n);}return eve::editing::applied<CameraTimelineKeyValue>(std::move(k));}
PropertyDescriptor descriptor(std::string path,PropertyType type,EditorValue value,double minimum=-1e9,double maximum=1e9){PropertyDescriptor d;d.path=PropertyPath(path);d.displayNameKey="editor.camera."+path;d.category="camera-rig";d.type=type;d.defaultValue=std::move(value);d.flags=PropertyFlag::Runtime;d.numeric.minimum=minimum;d.numeric.maximum=maximum;return d;}
bool errors(const std::vector<EditorDiagnostic>& values){return std::any_of(values.begin(),values.end(),[](const auto& d){return d.severity()==DiagnosticSeverity::Error;});}
}
 
CameraDocumentTarget::CameraDocumentTarget(std::string id):id_(std::move(id)){}
TargetDescriptor CameraDocumentTarget::describe() const {
    return {
        TargetId(id_), "camera-asset", revisionValue(), false, {CapabilityId("eve.editor.target.camera-properties")}};
}
void* CameraDocumentTarget::queryCapability(const CapabilityId& capability){return capability==CapabilityId("eve.editor.target.camera-properties")?static_cast<IPropertyProvider*>(this):nullptr;}
bool CameraDocumentTarget::matches(const SelectionSnapshot& selection)const{if(selection.items.empty())return false;for(const auto& item:selection.items)if(item.target!=TargetId(id_)||std::none_of(rigs_.begin(),rigs_.end(),[&](const auto& r){return r.id.value()==item.item.value();}))return false;return true;}
eve::Result<eve::Revision> CameraDocumentTarget::currentRevision(const SelectionSnapshot& selection) const {
    if (!matches(selection))
        return eve::Result<eve::Revision>::failure(eve::Diagnostic::error(
            eve::DiagnosticCode::InvalidArgument, "Camera selection mismatch", "editor.camera.selection"));
    return eve::Result<eve::Revision>::success(eve::Revision(revisionValue()));
}
PropertySchema CameraDocumentTarget::schema(const SelectionSnapshot&)const{PropertySchema s;s.typeId="camera.rig";s.properties={descriptor("rig.enabled",PropertyType::Bool,true),descriptor("rig.priority",PropertyType::Int,int64_t{0},-100000,100000),descriptor("rig.mode",PropertyType::Enum,"follow"),descriptor("rig.target",PropertyType::Vec3,vec3({0,0,0})),descriptor("rig.offset",PropertyType::Vec3,vec3({0,2,6})),descriptor("rig.lookAhead",PropertyType::Vec3,vec3({0,0,0})),descriptor("rig.composition",PropertyType::Vec2,vec2({0,0}),-0.9,0.9),descriptor("rig.radius",PropertyType::Float,10.0,0.01,100000),descriptor("rig.azimuth",PropertyType::Float,45.0),descriptor("rig.elevation",PropertyType::Float,30.0,-89,89),descriptor("rig.yaw",PropertyType::Float,0.0),descriptor("rig.pitch",PropertyType::Float,0.0,-89,89),descriptor("rig.fov",PropertyType::Float,60.0,1,179),descriptor("rig.smooth",PropertyType::Float,6.0,0,10000),descriptor("rig.maxSpeed",PropertyType::Float,0.0,0,100000)};s.properties[2].enumItems={"follow","orbit","topdown","firstperson","cinematic"};return s;}
PropertyReadResult CameraDocumentTarget::read(const SelectionSnapshot& selection,const PropertyPath& path)const{if(!matches(selection)||!schema(selection).find(path))return{};std::optional<EditorValue> common;for(const auto& item:selection.items){const auto& r=*std::find_if(rigs_.begin(),rigs_.end(),[&](const auto& v){return v.id.value()==item.item.value();});EditorValue value;if(path==PropertyPath("rig.enabled"))value=r.enabled;else if(path==PropertyPath("rig.priority"))value=int64_t{r.priority};else if(path==PropertyPath("rig.mode"))value=r.mode;else if(path==PropertyPath("rig.target"))value=vec3(r.target);else if(path==PropertyPath("rig.offset"))value=vec3(r.offset);else if(path==PropertyPath("rig.lookAhead"))value=vec3(r.lookAhead);else if(path==PropertyPath("rig.composition"))value=vec2(r.composition);else if(path==PropertyPath("rig.radius"))value=r.radius;else if(path==PropertyPath("rig.azimuth"))value=r.azimuth;else if(path==PropertyPath("rig.elevation"))value=r.elevation;else if(path==PropertyPath("rig.yaw"))value=r.yaw;else if(path==PropertyPath("rig.pitch"))value=r.pitch;else if(path==PropertyPath("rig.fov"))value=r.fov;else if(path==PropertyPath("rig.smooth"))value=r.smooth;else value=r.maxSpeed;if(!common)common=value;else if(*common!=value)return{PropertyReadState::Mixed,{},{}};}return{PropertyReadState::Value,*common,{}};}
EditorValue CameraDocumentTarget::contentValue()const{EditorValue::Array rigs,keys;for(const auto& r:rigs_)rigs.push_back(rigValue(r));for(const auto& k:keys_)keys.push_back(keyValue(k));return EditorValue::Object{{"rigs",std::move(rigs)},{"timeline",std::move(keys)}};}
Result<DomainOperation> CameraDocumentTarget::replacement(EditorValue content,std::string property)const{DomainOperation op;op.type="camera.document.replace.v1";op.inverseType=op.type;op.target=TargetId(id_);op.payload=std::move(content);op.inverse=contentValue();op.hasInverse=true;if(!property.empty())op.affectedProperties.push_back(property);op.mergeKey="camera:"+id_+":"+(property.empty()?"structure":property);return eve::editing::applied<DomainOperation>(std::move(op));}
Result<DomainOperation> CameraDocumentTarget::makeSet(const SelectionSnapshot& selection,const PropertyPath& path,const EditorValue& value,PropertySetMode mode)const{if(mode==PropertySetMode::Reset)return makeReset(selection,path);auto d=schema(selection).find(path);if(!matches(selection)||!d||mode!=PropertySetMode::Absolute||!validatePropertyValue(*d,value).ok())return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.camera.set"), "Camera property edit is invalid");auto candidate=*this;for(const auto& item:selection.items){auto& r=*std::find_if(candidate.rigs_.begin(),candidate.rigs_.end(),[&](const auto& v){return v.id.value()==item.item.value();});if(path==PropertyPath("rig.enabled"))r.enabled=*value.getIf<bool>();else if(path==PropertyPath("rig.priority"))r.priority=static_cast<int>(*value.getIf<int64_t>());else if(path==PropertyPath("rig.mode"))r.mode=*value.getIf<std::string>();else if(path==PropertyPath("rig.target"))readVec(&value,&r.target.x,3);else if(path==PropertyPath("rig.offset"))readVec(&value,&r.offset.x,3);else if(path==PropertyPath("rig.lookAhead"))readVec(&value,&r.lookAhead.x,3);else if(path==PropertyPath("rig.composition"))readVec(&value,&r.composition.x,2);else{const float number=static_cast<float>(*value.getIf<double>());if(path==PropertyPath("rig.radius"))r.radius=number;else if(path==PropertyPath("rig.azimuth"))r.azimuth=number;else if(path==PropertyPath("rig.elevation"))r.elevation=number;else if(path==PropertyPath("rig.yaw"))r.yaw=number;else if(path==PropertyPath("rig.pitch"))r.pitch=number;else if(path==PropertyPath("rig.fov"))r.fov=number;else if(path==PropertyPath("rig.smooth"))r.smooth=number;else r.maxSpeed=number;}}if(errors(candidate.validate()))return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.camera.invalid"), "Camera edit produces an invalid document");return replacement(candidate.contentValue(),path.value());}
Result<DomainOperation> CameraDocumentTarget::makeReset(const SelectionSnapshot& selection,const PropertyPath& path)const{auto d=schema(selection).find(path);if(!d)return eve::editing::failed<DomainOperation>(EditorStatus::Unsupported, RuleId("editor.camera.property"), "Unknown camera property");return makeSet(selection,path,d->defaultValue,PropertySetMode::Absolute);}
Result<DomainOperation> CameraDocumentTarget::makeCreateRig(const CameraRigValue& rig)const{if(rig.id.empty()||std::any_of(rigs_.begin(),rigs_.end(),[&](const auto& v){return v.id==rig.id||v.name==rig.name;}))return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.camera.rig-id"), "Camera rig ID and name must be unique");auto candidate=*this;candidate.rigs_.push_back(rig);if(errors(candidate.validate()))return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.camera.rig"), "Camera rig is invalid");return replacement(candidate.contentValue());}
Result<DomainOperation> CameraDocumentTarget::makeDeleteRig(const ObjectId& id)const{if(std::none_of(rigs_.begin(),rigs_.end(),[&](const auto& r){return r.id==id;}))return eve::editing::failed<DomainOperation>(EditorStatus::NotFound, RuleId("editor.camera.rig"), "Camera rig does not exist");if(std::any_of(keys_.begin(),keys_.end(),[&](const auto& k){return k.kind=="cut"&&k.rig==id;}))return eve::editing::failed<DomainOperation>(EditorStatus::Conflict, RuleId("editor.camera.rig-reference"), "Timeline cuts still reference this rig");auto candidate=*this;std::erase_if(candidate.rigs_,[&](const auto& r){return r.id==id;});return replacement(candidate.contentValue());}
Result<DomainOperation> CameraDocumentTarget::makeCreateKey(const CameraTimelineKeyValue& key)const{if(key.id.empty()||std::any_of(keys_.begin(),keys_.end(),[&](const auto& v){return v.id==key.id;}))return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.camera.key-id"), "Camera key ID must be unique");auto candidate=*this;candidate.keys_.push_back(key);if(errors(candidate.validate()))return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.camera.key"), "Camera timeline key is invalid");return replacement(candidate.contentValue());}
Result<DomainOperation> CameraDocumentTarget::makeDeleteKey(const ObjectId& id)const{if(std::none_of(keys_.begin(),keys_.end(),[&](const auto& k){return k.id==id;}))return eve::editing::failed<DomainOperation>(EditorStatus::NotFound, RuleId("editor.camera.key"), "Camera key does not exist");auto candidate=*this;std::erase_if(candidate.keys_,[&](const auto& k){return k.id==id;});return replacement(candidate.contentValue());}
std::vector<CameraTimelineKeyValue> CameraDocumentTarget::timeline()const{auto out=keys_;std::stable_sort(out.begin(),out.end(),[](const auto& a,const auto& b){return a.time==b.time?a.id.value()<b.id.value():a.time<b.time;});return out;}
std::vector<EditorDiagnostic> CameraDocumentTarget::validate()const{std::vector<EditorDiagnostic> out;if(rigs_.size()>64)out.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,RuleId("editor.camera.rig-budget"),DiagnosticSeverity::Error,"Camera asset exceeds 64 rigs"));if(keys_.size()>4096)out.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,RuleId("editor.camera.key-budget"),DiagnosticSeverity::Error,"Camera asset exceeds 4096 timeline keys"));std::set<std::string> ids,names,keyIds;bool enabled=false;for(const auto& r:rigs_){enabled|=r.enabled;if(r.id.empty()||r.name.empty()||!ids.insert(r.id.value()).second||!names.insert(r.name).second)out.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,RuleId("editor.camera.rig-identity"),DiagnosticSeverity::Error,"Camera rig IDs and names must be non-empty and unique"));if(!modeValid(r.mode)||r.priority < -100000||r.priority>100000||!finite(r.radius)||r.radius<.01f||!finite(r.elevation)||std::abs(r.elevation)>89.f||!finite(r.pitch)||std::abs(r.pitch)>89.f||!finite(r.fov)||r.fov<1.f||r.fov>179.f||!finite(r.smooth)||r.smooth<0||!finite(r.maxSpeed)||r.maxSpeed<0||glm::any(glm::greaterThan(glm::abs(r.composition),glm::vec2(.9f))))out.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,RuleId("editor.camera.rig-range"),DiagnosticSeverity::Error,"Camera rig contains an invalid mode or out-of-range value"));}for(const auto& k:keys_){if(k.id.empty()||!keyIds.insert(k.id.value()).second||!finite(k.time)||k.time<0||k.time>86400||!finite(k.blend)||k.blend<0||!finite(k.value))out.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,RuleId("editor.camera.key-range"),DiagnosticSeverity::Error,"Camera timeline key is invalid or outside the 24-hour budget"));else if(k.kind=="cut"&&!ids.contains(k.rig.value()))out.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,RuleId("editor.camera.cut-rig"),DiagnosticSeverity::Error,"Camera cut references a missing rig"));else if(k.kind=="float"&&!propertyValid(k.property))out.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,RuleId("editor.camera.float-property"),DiagnosticSeverity::Error,"Camera automation property is unsupported"));else if(k.kind=="event"&&k.name.empty())out.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,RuleId("editor.camera.event-name"),DiagnosticSeverity::Error,"Camera event name must not be empty"));else if(k.kind!="cut"&&k.kind!="float"&&k.kind!="event")out.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,RuleId("editor.camera.key-kind"),DiagnosticSeverity::Error,"Camera timeline key kind is unsupported"));}if(rigs_.empty())out.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,RuleId("editor.camera.empty"),DiagnosticSeverity::Warning,"Camera asset has no rigs"));else if(!enabled)out.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,RuleId("editor.camera.no-enabled-rig"),DiagnosticSeverity::Error,"Camera asset must retain at least one enabled rig"));return out;}
Result<void> CameraDocumentTarget::applyDomainOperation(const DomainOperation& operation) {
    if (operation.target != TargetId(id_) || operation.type != "camera.document.replace.v1")
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.camera.operation"), "Camera operation mismatch");
    const auto *rigsValue = field(operation.payload, "rigs"), *keysValue = field(operation.payload, "timeline");
    const auto* rigs = rigsValue ? rigsValue->getIf<EditorValue::Array>() : nullptr;
    const auto* keys = keysValue ? keysValue->getIf<EditorValue::Array>() : nullptr;
    if (!rigs || !keys || rigs->size() > 64 || keys->size() > 4096 ||
        !operation.payload.isWithinLimits(8, 100000, 4 * 1024 * 1024))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.camera.payload"), "Camera document payload exceeds limits");
    CameraDocumentTarget candidate(id_);
    for (const auto& value : *rigs) {
        auto parsed = parseRig(value);
        if (!parsed.ok())
            return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.camera.rig"), "Camera document contains an invalid rig");
        candidate.rigs_.push_back(parsed.value());
    }
    for (const auto& value : *keys) {
        auto parsed = parseKey(value);
        if (!parsed.ok())
            return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.camera.key"), "Camera document contains an invalid key");
        candidate.keys_.push_back(parsed.value());
    }
    if (errors(candidate.validate()))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.camera.invalid"), "Camera document validation failed");
    rigs_ = std::move(candidate.rigs_);
    keys_ = std::move(candidate.keys_);
    bumpRevision();
    widenDirty(0, 0);
    return eve::editing::applied<void>();
}
std::unique_ptr<IDomainOperationTarget> CameraDocumentTarget::cloneDomainState()const{return std::make_unique<CameraDocumentTarget>(*this);}
Result<void> CameraDocumentTarget::commitDomainState(std::unique_ptr<IDomainOperationTarget> candidate){auto* typed=dynamic_cast<CameraDocumentTarget*>(candidate.get());if(!typed||typed->id_!=id_)return eve::editing::failed<void>(EditorStatus::Conflict, RuleId("editor.camera.candidate"), "Camera candidate mismatch");*this=*typed;return eve::editing::applied<void>();}
EditorValue CameraDocumentTarget::snapshotValue()const{return EditorValue::Object{{"schemaVersion",int64_t{1}},{"content",contentValue()}};}
Result<void> CameraDocumentTarget::loadSnapshot(const EditorValue& snapshot) {
    const auto *versionValue = field(snapshot, "schemaVersion"), *content = field(snapshot, "content");
    const auto* version = versionValue ? versionValue->getIf<int64_t>() : nullptr;
    if (!version || *version != 1 || !content)
        return eve::editing::failed<void>(EditorStatus::Unsupported, RuleId("editor.camera.snapshot"), "Unsupported camera snapshot");
    DomainOperation operation;
    operation.target  = TargetId(id_);
    operation.type    = "camera.document.replace.v1";
    operation.payload = *content;
    auto result       = applyDomainOperation(operation);
    if (result.ok()) clearDirtyRegion();
    return result;
}
 
Result<CameraPreviewPose> CameraPreview::evaluate(const CameraDocumentTarget& document,float time)const{if(!finite(time)||time<0||time>86400)return eve::editing::failed<CameraPreviewPose>(EditorStatus::Rejected, RuleId("editor.camera.preview-time"), "Camera preview time is outside the 24-hour budget");const auto diagnostics=document.validate();if(errors(diagnostics))return eve::editing::failed<CameraPreviewPose>(EditorStatus::Rejected, RuleId("editor.camera.preview-invalid"), "Camera document is invalid");if(document.rigs().empty())return eve::editing::failed<CameraPreviewPose>(EditorStatus::NotFound, RuleId("editor.camera.preview-rig"), "Camera preview has no rig");const auto keys=document.timeline();const CameraRigValue* rig=nullptr;for(const auto& key:keys)if(key.time<=time&&key.kind=="cut"){const auto found=std::find_if(document.rigs().begin(),document.rigs().end(),[&](const auto& r){return r.id==key.rig&&r.enabled;});if(found!=document.rigs().end())rig=&*found;}if(!rig){const auto found=std::max_element(document.rigs().begin(),document.rigs().end(),[](const auto& a,const auto& b){if(a.enabled!=b.enabled)return !a.enabled;return a.priority<b.priority;});rig=&*found;}auto sample=[&](const std::string& property,float fallback){const CameraTimelineKeyValue* before=nullptr,*after=nullptr;for(const auto& key:keys){if(key.kind!="float"||key.property!=property)continue;if(key.time<=time)before=&key;else{after=&key;break;}}if(!before)return after?after->value:fallback;if(!after||after->time<=before->time)return before->value;const float alpha=(time-before->time)/(after->time-before->time);return glm::mix(before->value,after->value,alpha);};CameraPreviewPose pose;pose.rig=rig->id;pose.target=rig->target+rig->lookAhead;const float radius=std::max(.01f,sample("radius",rig->radius));const float az=glm::radians(rig->azimuth),el=glm::radians(rig->elevation),yaw=glm::radians(rig->yaw),pitch=glm::radians(rig->pitch);if(rig->mode=="follow")pose.eye=rig->target+rig->offset;else if(rig->mode=="orbit")pose.eye=rig->target+glm::vec3(std::cos(el)*std::sin(az),std::sin(el),std::cos(el)*std::cos(az))*radius;else if(rig->mode=="topdown")pose.eye=rig->target+glm::vec3(0,radius,0);else if(rig->mode=="firstperson"){pose.eye=rig->target;pose.target=pose.eye+glm::vec3(std::cos(pitch)*std::sin(yaw),std::sin(pitch),-std::cos(pitch)*std::cos(yaw));}else pose.eye=rig->target+rig->offset;pose.fov=glm::clamp(sample("fov",rig->fov),1.f,179.f);return eve::editing::applied<CameraPreviewPose>(pose);}
Result<EditorGizmoSnapshot> CameraPreview::gizmo(const CameraDocumentTarget& document,float time)const{auto sampled=evaluate(document,time);if(!sampled.ok()) return Result<EditorGizmoSnapshot>::failure(sampled.status());const auto& pose=sampled.value();const glm::vec3 delta=pose.target-pose.eye;const float length=glm::length(delta);const glm::vec3 direction=length>1e-6f?delta/length:glm::vec3(0,0,-1);EditorGizmoSnapshot snapshot;snapshot.status=EditorStatus::Applied;snapshot.target=document.targetId().value();snapshot.targetRevision=document.revision();EditorGizmoPrimitive camera;camera.id="camera";camera.kind="camera";camera.position={pose.eye.x,pose.eye.y,pose.eye.z};camera.direction={direction.x,direction.y,direction.z};camera.length=length;camera.color={0.2,0.8,1,1};snapshot.primitives.push_back(camera);EditorGizmoPrimitive target;target.id="target";target.kind="point";target.position={pose.target.x,pose.target.y,pose.target.z};target.radius=.15;target.color={1,.7,.1,1};snapshot.primitives.push_back(target);EditorGizmoPrimitive frustum;frustum.id="frustum";frustum.kind="frustum";frustum.position=camera.position;frustum.direction=camera.direction;frustum.length=1;frustum.radius=std::tan(glm::radians(pose.fov*.5f));frustum.color={.2,.8,1,.6};snapshot.primitives.push_back(frustum);return eve::editing::applied<EditorGizmoSnapshot>(std::move(snapshot));}
 
} // namespace eve::camera_editing