EVEngine/PcgPhotoModeValues_8cpp_source.html

#include "ui/PcgPhotoModeValues.h"

#include "common/SquirrelBinding.h"

#include "common/Value.h"

#include <simplesquirrel/simplesquirrel.hpp>

#include <cmath>

#include <limits>

namespace eve::ui { namespace {

const std::vector<PcgPhotoModeField>& fields(){static const std::vector<PcgPhotoModeField> v={

        {"m_isUsingPcgLighting", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{false}},

        {"m_selectedPcgLightingProfile", PcgPhotoModeValueType::Int, PcgPhotoModeValue{int64_t{-1}}},

        {"m_lastSceneName", PcgPhotoModeValueType::String, PcgPhotoModeValue{std::string{}}},

        {"m_screenshotResolution", PcgPhotoModeValueType::Int, PcgPhotoModeValue{int64_t{0}}},

        {"m_screenshotImageFormat", PcgPhotoModeValueType::Int, PcgPhotoModeValue{int64_t{2}}},

        {"m_loadSavedSettings", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{true}},

        {"m_revertOnDisabled", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{true}},

        {"m_showFPS", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{false}},

        {"m_showReticle", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{false}},

        {"m_showRuleOfThirds", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{false}},

        {"m_lodBias", PcgPhotoModeValueType::Float, PcgPhotoModeValue{2.0f}},

        {"m_vSync", PcgPhotoModeValueType::Int, PcgPhotoModeValue{int64_t{0}}},

        {"m_targetFPS", PcgPhotoModeValueType::Int, PcgPhotoModeValue{int64_t{-1}}},

        {"m_antiAliasing", PcgPhotoModeValueType::Int, PcgPhotoModeValue{int64_t{1}}},

        {"m_shadowDistance", PcgPhotoModeValueType::Float, PcgPhotoModeValue{512.0f}},

        {"m_shadowResolution", PcgPhotoModeValueType::Int, PcgPhotoModeValue{int64_t{3}}},

        {"m_shadowCascades", PcgPhotoModeValueType::Int, PcgPhotoModeValue{int64_t{4}}},

        {"m_fieldOfView", PcgPhotoModeValueType::Float, PcgPhotoModeValue{60.0f}},

        {"m_pcgCullinDistance", PcgPhotoModeValueType::Float, PcgPhotoModeValue{0.0f}},

        {"m_cameraAperture", PcgPhotoModeValueType::Float, PcgPhotoModeValue{19.0f}},

        {"m_cameraFocalLength", PcgPhotoModeValueType::Float, PcgPhotoModeValue{50.0f}},

        {"m_globalVolume", PcgPhotoModeValueType::Float, PcgPhotoModeValue{1.0f}},

        {"m_cameraRoll", PcgPhotoModeValueType::Float, PcgPhotoModeValue{0.0f}},

        {"m_farClipPlane", PcgPhotoModeValueType::Float, PcgPhotoModeValue{2000.0f}},

        {"m_pcgLoadRange", PcgPhotoModeValueType::Float, PcgPhotoModeValue{1000.0f}},

        {"m_pcgImpostorRange", PcgPhotoModeValueType::Float, PcgPhotoModeValue{2000.0f}},

        {"m_pcgWeatherEnabled", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{false}},

        {"m_pcgWeatherRain", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{false}},

        {"m_pcgWeatherSnow", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{false}},

        {"m_pcgWindSettingsOverride", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{false}},

        {"m_pcgWindDirection", PcgPhotoModeValueType::Float, PcgPhotoModeValue{0.0f}},

        {"m_pcgWindSpeed", PcgPhotoModeValueType::Float, PcgPhotoModeValue{0.35f}},

        {"m_pcgTime", PcgPhotoModeValueType::Float, PcgPhotoModeValue{15.0f}},

        {"m_pcgTimeOfDayEnabled", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{false}},

        {"m_pcgTimeScale", PcgPhotoModeValueType::Float, PcgPhotoModeValue{1.0f}},

        {"m_pcgAdditionalLinearFog", PcgPhotoModeValueType::Float, PcgPhotoModeValue{0.0f}},

        {"m_pcgAdditionalExponentialFog", PcgPhotoModeValueType::Float, PcgPhotoModeValue{0.0f}},

        {"m_sunRotation", PcgPhotoModeValueType::Float, PcgPhotoModeValue{0.0f}},

        {"m_sunPitch", PcgPhotoModeValueType::Float, PcgPhotoModeValue{75.0f}},

        {"m_fogOverride", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{false}},

        {"m_fogMode", PcgPhotoModeValueType::Int, PcgPhotoModeValue{int64_t{1}}},

        {"m_fogColor", PcgPhotoModeValueType::Color, PcgPhotoModeValue{PcgPhotoModeColor{0,0,0,1}}},

        {"m_fogDensity", PcgPhotoModeValueType::Float, PcgPhotoModeValue{0.01f}},

        {"m_fogStart", PcgPhotoModeValueType::Float, PcgPhotoModeValue{100.0f}},

        {"m_fogEnd", PcgPhotoModeValueType::Float, PcgPhotoModeValue{1000.0f}},

        {"m_skyboxOverride", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{false}},

        {"m_skyboxRotation", PcgPhotoModeValueType::Float, PcgPhotoModeValue{0.0f}},

        {"m_skyboxExposure", PcgPhotoModeValueType::Float, PcgPhotoModeValue{1.0f}},

        {"m_skyboxTint", PcgPhotoModeValueType::Color, PcgPhotoModeValue{PcgPhotoModeColor{0,0,0,1}}},

        {"m_sunOverride", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{false}},

        {"m_sunIntensity", PcgPhotoModeValueType::Float, PcgPhotoModeValue{1.0f}},

        {"m_sunColor", PcgPhotoModeValueType::Color, PcgPhotoModeValue{PcgPhotoModeColor{0,0,0,1}}},

        {"m_sunKelvinValue", PcgPhotoModeValueType::Float, PcgPhotoModeValue{6500.0f}},

        {"m_ambientIntensity", PcgPhotoModeValueType::Float, PcgPhotoModeValue{1.0f}},

        {"m_ambientSkyColor", PcgPhotoModeValueType::Color, PcgPhotoModeValue{PcgPhotoModeColor{0.7027151f,0.881016f,1.001631f,0.4192761f}}},

        {"m_ambientEquatorColor", PcgPhotoModeValueType::Color, PcgPhotoModeValue{PcgPhotoModeColor{0.6302439f,0.7919513f,0.85f,0.0f}}},

        {"m_ambientGroundColor", PcgPhotoModeValueType::Color, PcgPhotoModeValue{PcgPhotoModeColor{0.5f,0.4142857f,0.3321428f,0.0f}}},

        {"m_globalLightIntensityMultiplier", PcgPhotoModeValueType::Float, PcgPhotoModeValue{1.0f}},

        {"m_globalFogDensityMultiplier", PcgPhotoModeValueType::Float, PcgPhotoModeValue{1.0f}},

        {"m_globalShadowDistanceMultiplier", PcgPhotoModeValueType::Float, PcgPhotoModeValue{1.0f}},

        {"m_pcgWaterReflectionEnabled", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{true}},

        {"m_pcgWaterReflectionDistance", PcgPhotoModeValueType::Float, PcgPhotoModeValue{0.0f}},

        {"m_pcgWaterReflectionResolution", PcgPhotoModeValueType::Int, PcgPhotoModeValue{int64_t{2}}},

        {"m_pcgReflectionsLODBias", PcgPhotoModeValueType::Float, PcgPhotoModeValue{1.0f}},

        {"m_pcgUnderwaterFogColor", PcgPhotoModeValueType::Color, PcgPhotoModeValue{PcgPhotoModeColor{0,0,0,1}}},

        {"m_pcgUnderwaterFogDensity", PcgPhotoModeValueType::Float, PcgPhotoModeValue{0.045f}},

        {"m_pcgUnderwaterFogDistance", PcgPhotoModeValueType::Float, PcgPhotoModeValue{45.0f}},

        {"m_pcgUnderwaterVolume", PcgPhotoModeValueType::Float, PcgPhotoModeValue{0.5f}},

        {"m_postFXExposure", PcgPhotoModeValueType::Float, PcgPhotoModeValue{13.5f}},

        {"m_postFXExposureMode", PcgPhotoModeValueType::Int, PcgPhotoModeValue{int64_t{0}}},

        {"m_dofActive", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{true}},

        {"m_autoDOFFocus", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{true}},

        {"m_dofFocusDistance", PcgPhotoModeValueType::Float, PcgPhotoModeValue{100.0f}},

        {"m_dofAperture", PcgPhotoModeValueType::Float, PcgPhotoModeValue{16.0f}},

        {"m_dofFocalLength", PcgPhotoModeValueType::Float, PcgPhotoModeValue{50.0f}},

        {"m_dofKernelSize", PcgPhotoModeValueType::Int, PcgPhotoModeValue{int64_t{1}}},

        {"m_savedDofFocusMode", PcgPhotoModeValueType::Int, PcgPhotoModeValue{int64_t{0}}},

        {"m_dofFocusModeHDRP", PcgPhotoModeValueType::Int, PcgPhotoModeValue{int64_t{0}}},

        {"m_dofFocusModeURP", PcgPhotoModeValueType::Int, PcgPhotoModeValue{int64_t{0}}},

        {"m_dofQualityHDRP", PcgPhotoModeValueType::Int, PcgPhotoModeValue{int64_t{1}}},

        {"m_dofNearBlurStart", PcgPhotoModeValueType::Float, PcgPhotoModeValue{0.0f}},

        {"m_dofNearBlurEnd", PcgPhotoModeValueType::Float, PcgPhotoModeValue{0.1f}},

        {"m_dofFarBlurStart", PcgPhotoModeValueType::Float, PcgPhotoModeValue{200.0f}},

        {"m_dofFarBlurEnd", PcgPhotoModeValueType::Float, PcgPhotoModeValue{2000.0f}},

        {"m_dofStartBlurURP", PcgPhotoModeValueType::Float, PcgPhotoModeValue{2.0f}},

        {"m_dofEndBlurURP", PcgPhotoModeValueType::Float, PcgPhotoModeValue{1000.0f}},

        {"m_dofMaxRadiusBlur", PcgPhotoModeValueType::Float, PcgPhotoModeValue{1.0f}},

        {"m_dofHighQualityURP", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{false}},

        {"m_terrainDetailDensity", PcgPhotoModeValueType::Float, PcgPhotoModeValue{0.5f}},

        {"m_terrainDetailDistance", PcgPhotoModeValueType::Float, PcgPhotoModeValue{150.0f}},

        {"m_terrainPixelError", PcgPhotoModeValueType::Float, PcgPhotoModeValue{5.0f}},

        {"m_terrainBasemapDistance", PcgPhotoModeValueType::Float, PcgPhotoModeValue{1024.0f}},

        {"m_drawInstanced", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{true}},

        {"m_overrideDensityVolume", PcgPhotoModeValueType::Bool, PcgPhotoModeValue{false}},

        {"m_densityVolumeAlbedoColor", PcgPhotoModeValueType::Color, PcgPhotoModeValue{PcgPhotoModeColor{1,1,1,1}}},

        {"m_densityVolumeFogDistance", PcgPhotoModeValueType::Float, PcgPhotoModeValue{250.0f}},

        {"m_densityVolumeEffectType", PcgPhotoModeValueType::Int, PcgPhotoModeValue{int64_t{1}}},

        {"m_densityVolumeTilingResolution", PcgPhotoModeValueType::Int, PcgPhotoModeValue{int64_t{3}}},

        {"m_globalGrassDensity", PcgPhotoModeValueType::Float, PcgPhotoModeValue{1.0f}},

        {"m_globalGrassDistance", PcgPhotoModeValueType::Float, PcgPhotoModeValue{1.0f}},

        {"m_cameraCellDistance", PcgPhotoModeValueType::Float, PcgPhotoModeValue{1.0f}},

        {"m_cameraCellSubdivision", PcgPhotoModeValueType::Int, PcgPhotoModeValue{int64_t{0}}},

    };return v;}

const PcgPhotoModeField* field(const std::string&n){for(const auto&f:fields())if(f.name==n)return &f;return nullptr;}

template<class T> Result<void> setTyped(std::unordered_map<std::string,PcgPhotoModeValue>&v,const std::string&n,PcgPhotoModeValueType t,T x){auto*f=field(n);if(!f)return Result<void>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,"unknown photo-mode field: "+n,{}, {},"ui.pcgPhotoModeValues"));if(f->type!=t)return Result<void>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,"photo-mode field type mismatch: "+n,{}, {},"ui.pcgPhotoModeValues"));v[n]=std::move(x);return Result<void>::success();}

template<class T> Result<T> getTyped(const std::unordered_map<std::string,PcgPhotoModeValue>&v,const std::string&n,PcgPhotoModeValueType t){auto*f=field(n);if(!f)return Result<T>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,"unknown photo-mode field: "+n,{}, {},"ui.pcgPhotoModeValues"));if(f->type!=t)return Result<T>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,"photo-mode field type mismatch: "+n,{}, {},"ui.pcgPhotoModeValues"));return Result<T>::success(std::get<T>(v.at(n)));}

}

PcgPhotoModeValues::PcgPhotoModeValues(){resetDefaults();}

void PcgPhotoModeValues::resetDefaults(){std::unordered_map<std::string,PcgPhotoModeValue> next;for(const auto&f:fields())next.emplace(f.name,f.defaultValue);values_=std::move(next);selectedColor_={};}

uint64_t PcgPhotoModeValues::getFieldCount()const noexcept{return fields().size();}

Result<std::string> PcgPhotoModeValues::getFieldName(uint64_t i)const{if(i>=fields().size())return Result<std::string>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,"photo-mode field index is out of range",{}, {},"ui.pcgPhotoModeValues"));return Result<std::string>::success(fields()[i].name);}

Result<int> PcgPhotoModeValues::getFieldType(const std::string&n)const{auto*f=field(n);if(!f)return Result<int>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,"unknown photo-mode field: "+n,{}, {},"ui.pcgPhotoModeValues"));return Result<int>::success(static_cast<int>(f->type));}

Result<void> PcgPhotoModeValues::setBool(const std::string&n,bool v){return setTyped(values_,n,PcgPhotoModeValueType::Bool,v);}

Result<void> PcgPhotoModeValues::setInt(const std::string&n,int64_t v){return setTyped(values_,n,PcgPhotoModeValueType::Int,v);}

Result<void> PcgPhotoModeValues::setFloat(const std::string&n,float v){if(!std::isfinite(v))return Result<void>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,"photo-mode float must be finite",{}, {},"ui.pcgPhotoModeValues"));return setTyped(values_,n,PcgPhotoModeValueType::Float,v);}

Result<void> PcgPhotoModeValues::setString(const std::string&n,const std::string&v){return setTyped(values_,n,PcgPhotoModeValueType::String,v);}

Result<void> PcgPhotoModeValues::setColor(const std::string&n,float r,float g,float b,float a){if(!std::isfinite(r)||!std::isfinite(g)||!std::isfinite(b)||!std::isfinite(a))return Result<void>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,"photo-mode color must be finite",{}, {},"ui.pcgPhotoModeValues"));return setTyped(values_,n,PcgPhotoModeValueType::Color,PcgPhotoModeColor{r,g,b,a});}

Result<bool> PcgPhotoModeValues::getBool(const std::string&n)const{return getTyped<bool>(values_,n,PcgPhotoModeValueType::Bool);}

Result<int64_t> PcgPhotoModeValues::getInt(const std::string&n)const{return getTyped<int64_t>(values_,n,PcgPhotoModeValueType::Int);}

Result<float> PcgPhotoModeValues::getFloat(const std::string&n)const{return getTyped<float>(values_,n,PcgPhotoModeValueType::Float);}

Result<std::string> PcgPhotoModeValues::getString(const std::string&n)const{return getTyped<std::string>(values_,n,PcgPhotoModeValueType::String);}

Result<PcgPhotoModeValue> PcgPhotoModeValues::getValue(const std::string&n)const{if(!field(n))return Result<PcgPhotoModeValue>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,"unknown photo-mode field: "+n,{}, {},"ui.pcgPhotoModeValues"));return Result<PcgPhotoModeValue>::success(values_.at(n));}

Result<void> PcgPhotoModeValues::selectColor(const std::string&n){auto r=getTyped<PcgPhotoModeColor>(values_,n,PcgPhotoModeValueType::Color);if(!r)return Result<void>::failure(*r.error());selectedColor_=r.value();return Result<void>::success();}


Result<std::string> PcgPhotoModeValues::snapshotJson() const {

    Value::Object encoded;

    for(const auto&f:fields()){const auto&v=values_.at(f.name);switch(f.type){

    case PcgPhotoModeValueType::Bool:encoded[f.name]=std::get<bool>(v);break;

    case PcgPhotoModeValueType::Int:encoded[f.name]=std::get<int64_t>(v);break;

    case PcgPhotoModeValueType::Float:encoded[f.name]=double(std::get<float>(v));break;

    case PcgPhotoModeValueType::String:encoded[f.name]=std::get<std::string>(v);break;

    case PcgPhotoModeValueType::Color:{auto c=std::get<PcgPhotoModeColor>(v);encoded[f.name]=Value::Array{double(c.r),double(c.g),double(c.b),double(c.a)};break;}}}

    return Value(Value::Object{{"schema","eve.ui.pcg-photo-mode-values"},{"values",std::move(encoded)},{"version",int64_t{1}}}).toJson();

}


Result<void> PcgPhotoModeValues::restoreJson(const std::string&json){

    if(json.size()>1024U*1024U)return Result<void>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,"photo-mode values JSON exceeds size limit",{}, {},"ui.pcgPhotoModeValues"));

    auto decoded=Value::fromJson(json);

    if(!decoded.ok())return Result<void>::failure(decoded.status());

    const auto*root=decoded.value().getIf<Value::Object>();if(!root||root->size()!=3||!root->contains("schema")||!root->contains("version")||!root->contains("values"))return Result<void>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,"photo-mode values has missing or unknown root fields",{}, {},"ui.pcgPhotoModeValues"));

    const auto*schema=root->at("schema").getIf<std::string>();const auto*version=root->at("version").getIf<int64_t>();const auto*object=root->at("values").getIf<Value::Object>();if(!schema||*schema!="eve.ui.pcg-photo-mode-values"||!version||*version!=1||!object||object->size()!=fields().size())return Result<void>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,"photo-mode values has unsupported schema, version or field count",{}, {},"ui.pcgPhotoModeValues"));

    PcgPhotoModeValues candidate;for(const auto&f:fields()){if(!object->contains(f.name))return Result<void>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,"photo-mode values is missing field: "+f.name,{}, {},"ui.pcgPhotoModeValues"));const auto&v=object->at(f.name);switch(f.type){

    case PcgPhotoModeValueType::Bool:{auto*x=v.getIf<bool>();if(!x)return Result<void>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,"invalid bool field: "+f.name,{}, {},"ui.pcgPhotoModeValues"));candidate.values_[f.name]=*x;break;}

    case PcgPhotoModeValueType::Int:{auto*x=v.getIf<int64_t>();if(!x)return Result<void>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,"invalid int field: "+f.name,{}, {},"ui.pcgPhotoModeValues"));candidate.values_[f.name]=*x;break;}

    case PcgPhotoModeValueType::Float:{auto*x=v.getIf<double>();if(!x||!std::isfinite(*x)||*x>std::numeric_limits<float>::max()||*x<-std::numeric_limits<float>::max())return Result<void>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,"invalid float field: "+f.name,{}, {},"ui.pcgPhotoModeValues"));candidate.values_[f.name]=float(*x);break;}

    case PcgPhotoModeValueType::String:{auto*x=v.getIf<std::string>();if(!x)return Result<void>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,"invalid string field: "+f.name,{}, {},"ui.pcgPhotoModeValues"));candidate.values_[f.name]=*x;break;}

    case PcgPhotoModeValueType::Color:{auto*x=v.getIf<Value::Array>();if(!x||x->size()!=4)return Result<void>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,"invalid color field: "+f.name,{}, {},"ui.pcgPhotoModeValues"));double c[4];for(int i=0;i<4;++i){auto*n=(*x)[i].getIf<double>();if(!n||!std::isfinite(*n))return Result<void>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,"invalid color component: "+f.name,{}, {},"ui.pcgPhotoModeValues"));c[i]=*n;}candidate.values_[f.name]=PcgPhotoModeColor{float(c[0]),float(c[1]),float(c[2]),float(c[3])};break;}}

    }values_.swap(candidate.values_);selectedColor_={};return Result<void>::success();

}


void exposePcgPhotoModeValuesBindings(ssq::Table&t){auto vm=t.getHandle();auto c=t.addClass("PcgPhotoModeValues",ssq::Class::Ctor<PcgPhotoModeValues()>());c.addFunc("resetDefaults",[](PcgPhotoModeValues*s){s->resetDefaults();});c.addFunc("getFieldCount",[](const PcgPhotoModeValues*s){return s->getFieldCount();});c.addFunc("getFieldName",[vm](const PcgPhotoModeValues*s,uint64_t i){return eve::script::projectResult(vm,s->getFieldName(i),[](const std::string&v){return v;});});c.addFunc("getFieldType",[vm](const PcgPhotoModeValues*s,const std::string&n){return eve::script::projectResult(vm,s->getFieldType(n),[](int v){return v;});});c.addFunc("setBool",[vm](PcgPhotoModeValues*s,const std::string&n,bool v){return eve::script::projectResult(vm,s->setBool(n,v));});c.addFunc("setInt",[vm](PcgPhotoModeValues*s,const std::string&n,int64_t v){return eve::script::projectResult(vm,s->setInt(n,v));});c.addFunc("setFloat",[vm](PcgPhotoModeValues*s,const std::string&n,float v){return eve::script::projectResult(vm,s->setFloat(n,v));});c.addFunc("setString",[vm](PcgPhotoModeValues*s,const std::string&n,const std::string&v){return eve::script::projectResult(vm,s->setString(n,v));});c.addFunc("setColor",[vm](PcgPhotoModeValues*s,const std::string&n,float r,float g,float b,float a){return eve::script::projectResult(vm,s->setColor(n,r,g,b,a));});c.addFunc("getBool",[vm](const PcgPhotoModeValues*s,const std::string&n){return eve::script::projectResult(vm,s->getBool(n),[](bool v){return v;});});c.addFunc("getInt",[vm](const PcgPhotoModeValues*s,const std::string&n){return eve::script::projectResult(vm,s->getInt(n),[](int64_t v){return v;});});c.addFunc("getFloat",[vm](const PcgPhotoModeValues*s,const std::string&n){return eve::script::projectResult(vm,s->getFloat(n),[](float v){return v;});});c.addFunc("getString",[vm](const PcgPhotoModeValues*s,const std::string&n){return eve::script::projectResult(vm,s->getString(n),[](const std::string&v){return v;});});c.addFunc("selectColor",[vm](PcgPhotoModeValues*s,const std::string&n){return eve::script::projectResult(vm,s->selectColor(n));});c.addFunc("snapshotJson",[vm](const PcgPhotoModeValues*s){return eve::script::projectResult(vm,s->snapshotJson(),[](const std::string&v){return v;});});c.addFunc("restoreJson",[vm](PcgPhotoModeValues*s,const std::string&v){return eve::script::projectResult(vm,s->restoreJson(v));});c.addFunc("getColorR",[](const PcgPhotoModeValues*s){return s->getColorR();});c.addFunc("getColorG",[](const PcgPhotoModeValues*s){return s->getColorG();});c.addFunc("getColorB",[](const PcgPhotoModeValues*s){return s->getColorB();});c.addFunc("getColorA",[](const PcgPhotoModeValues*s){return s->getColorA();});}

}

x
float x
Definition AnimClip.cpp:738

root
int root
Definition AnimSmr.cpp:119

s
const std::string & s
Definition BattleSystem.cpp:57

vm
HSQUIRRELVM vm
Definition ECS.cpp:20

g
tensor::Graph g
Definition GpuGraph.cpp:7

n
glm::vec3 n
Definition Grass.cpp:63

r
double r
Definition GtsMeshSimplifier.cpp:12

v
float v
Definition HexRiverMesh.cpp:19

c
std::int32_t c
Definition HexSphereTopology.cpp:68

name
std::string name
Definition McpScriptTools.cpp:40

b
MeleePoint3 b
Definition MeleeHit.cpp:41

a
MeleePoint3 a
Definition MeleeHit.cpp:40

f
float f
Definition Pathfinder.cpp:335

PcgPhotoModeValues.h

fields
std::vector< std::string > fields
Definition PlayHost.cpp:111

t
float t
Definition PrototypeKit.cpp:110

SquirrelBinding.h
The single Squirrel projection for common Result, Status and Value.

object
Json object
Definition TileConfig.cpp:782

size
float size
Definition TreeMesh.cpp:156

Value.h
Owning, renderer-independent dynamic values.

eve::Diagnostic::error
static Diagnostic error(DiagnosticCode code, std::string message, std::string path={}, DiagnosticDetails details={}, std::string source={})
Construct an error diagnostic with the standard error severity.
Definition Diagnostic.h:125

eve::Result
Move-only operation result carrying either a value or Status.
Definition Result.h:155

eve::Result::success
static Result success(T value)
Construct a successful result owning value.
Definition Result.h:164

eve::Result::failure
static Result failure(Status status)
Construct a failed result from a structured status.
Definition Result.h:175

eve::Value
The canonical owning dynamic value used by data-facing protocols.
Definition Value.h:31

eve::Value::fromJson
static Result< Value > fromJson(std::string_view json)
Parse one strict JSON value into an owning Value.
Definition Value.cpp:57

eve::Value::Object
std::map< std::string, Value > Object
Definition Value.h:34

eve::Value::Array
std::vector< Value > Array
Definition Value.h:33

eve::ui::PcgPhotoModeValues
Complete typed value set from Pcg PhotoModeProfile with exact defaults.
Definition PcgPhotoModeValues.h:20

eve::ui::PcgPhotoModeValues::getFieldType
Result< int > getFieldType(const std::string &name) const
Return field type: bool=0, int=1, float=2, string=3, color=4.
Definition PcgPhotoModeValues.cpp:120

eve::ui::PcgPhotoModeValues::getBool
Result< bool > getBool(const std::string &name) const
Read a typed boolean field.
Definition PcgPhotoModeValues.cpp:126

eve::ui::PcgPhotoModeValues::setBool
Result< void > setBool(const std::string &name, bool value)
Set a typed boolean field.
Definition PcgPhotoModeValues.cpp:121

eve::ui::PcgPhotoModeValues::restoreJson
Result< void > restoreJson(const std::string &json)
Atomically restore schema 1 JSON; unknown or missing fields are rejected.
Definition PcgPhotoModeValues.cpp:142

eve::ui::PcgPhotoModeValues::getFieldCount
uint64_t getFieldCount() const noexcept
Return stable schema field count.
Definition PcgPhotoModeValues.cpp:118

eve::ui::PcgPhotoModeValues::snapshotJson
Result< std::string > snapshotJson() const
Encode schema 1 JSON containing every field.
Definition PcgPhotoModeValues.cpp:132

eve::ui::PcgPhotoModeValues::getFloat
Result< float > getFloat(const std::string &name) const
Read a typed float field.
Definition PcgPhotoModeValues.cpp:128

eve::ui::PcgPhotoModeValues::getInt
Result< int64_t > getInt(const std::string &name) const
Read a typed integer field.
Definition PcgPhotoModeValues.cpp:127

eve::ui::PcgPhotoModeValues::getValue
Result< PcgPhotoModeValue > getValue(const std::string &name) const
Read a field as its schema-declared native variant.
Definition PcgPhotoModeValues.cpp:130

eve::ui::PcgPhotoModeValues::setString
Result< void > setString(const std::string &name, const std::string &value)
Set a typed string field.
Definition PcgPhotoModeValues.cpp:124

eve::ui::PcgPhotoModeValues::selectColor
Result< void > selectColor(const std::string &name)
Select a color field for component reads.
Definition PcgPhotoModeValues.cpp:131

eve::ui::PcgPhotoModeValues::setColor
Result< void > setColor(const std::string &name, float r, float g, float b, float a)
Set a finite typed RGBA field.
Definition PcgPhotoModeValues.cpp:125

eve::ui::PcgPhotoModeValues::PcgPhotoModeValues
PcgPhotoModeValues()
Pcg photo mode values.
Definition PcgPhotoModeValues.cpp:116

eve::ui::PcgPhotoModeValues::setFloat
Result< void > setFloat(const std::string &name, float value)
Set a finite typed float field.
Definition PcgPhotoModeValues.cpp:123

eve::ui::PcgPhotoModeValues::setInt
Result< void > setInt(const std::string &name, int64_t value)
Set a typed integer or enum field.
Definition PcgPhotoModeValues.cpp:122

eve::ui::PcgPhotoModeValues::getFieldName
Result< std::string > getFieldName(uint64_t index) const
Return schema field name by declaration order.
Definition PcgPhotoModeValues.cpp:119

eve::ui::PcgPhotoModeValues::getString
Result< std::string > getString(const std::string &name) const
Read a typed string field.
Definition PcgPhotoModeValues.cpp:129

eve::ui::PcgPhotoModeValues::resetDefaults
void resetDefaults()
Restore all 102 Pcg defaults atomically.
Definition PcgPhotoModeValues.cpp:117

eve::procgen_editing::detail::field
const EditorValue * field(const EditorValue &value, const char *name)
Definition RoadNetworkEditTarget.cpp:15

eve::script::projectResult
ssq::Table projectResult(HSQUIRRELVM vm, Result< void > &&result)
Consume and project a void native Result using the common schema.
Definition SquirrelBinding.cpp:470

eve::ui
Definition Component.cpp:5

eve::ui::exposePcgPhotoModeValuesBindings
void exposePcgPhotoModeValuesBindings(ssq::Table &t)
Register complete Pcg photo-mode value bindings.
Definition PcgPhotoModeValues.cpp:156

eve::ui::PcgPhotoModeValue
std::variant< bool, int64_t, float, std::string, PcgPhotoModeColor > PcgPhotoModeValue
Definition PcgPhotoModeValues.h:16

eve::ui::PcgPhotoModeValueType
PcgPhotoModeValueType
PcgPhotoModeValueType public API.
Definition PcgPhotoModeValues.h:15

eve::ui::PcgPhotoModeValueType::Int
@ Int

eve::ui::PcgPhotoModeValueType::Float
@ Float

eve::ui::PcgPhotoModeValueType::String
@ String

eve::ui::PcgPhotoModeValueType::Bool
@ Bool

eve::ui::PcgPhotoModeValueType::Color
@ Color

eve::DiagnosticCode::InvalidArgument
@ InvalidArgument

eve::ui::PcgPhotoModeColor
PcgPhotoModeColor public API.
Definition PcgPhotoModeValues.h:13