1877 lines
62 KiB
C++
1877 lines
62 KiB
C++
#include "stdafx.h"
|
|
#include "RuntimeHost.h"
|
|
#include "RuntimeParameterUtils.h"
|
|
#include "ShaderCompiler.h"
|
|
#include "ShaderPackageRegistry.h"
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <fstream>
|
|
#include <set>
|
|
#include <sstream>
|
|
|
|
namespace
|
|
{
|
|
std::string Trim(const std::string& text)
|
|
{
|
|
std::size_t start = 0;
|
|
while (start < text.size() && std::isspace(static_cast<unsigned char>(text[start])))
|
|
++start;
|
|
|
|
std::size_t end = text.size();
|
|
while (end > start && std::isspace(static_cast<unsigned char>(text[end - 1])))
|
|
--end;
|
|
|
|
return text.substr(start, end - start);
|
|
}
|
|
|
|
bool IsFiniteNumber(double value)
|
|
{
|
|
return std::isfinite(value) != 0;
|
|
}
|
|
|
|
std::string ToLowerCopy(std::string text)
|
|
{
|
|
std::transform(text.begin(), text.end(), text.begin(),
|
|
[](unsigned char ch) { return static_cast<char>(std::tolower(ch)); });
|
|
return text;
|
|
}
|
|
|
|
std::string SimplifyControlKey(const std::string& text)
|
|
{
|
|
std::string simplified;
|
|
for (unsigned char ch : text)
|
|
{
|
|
if (std::isalnum(ch))
|
|
simplified.push_back(static_cast<char>(std::tolower(ch)));
|
|
}
|
|
return simplified;
|
|
}
|
|
|
|
bool MatchesControlKey(const std::string& candidate, const std::string& key)
|
|
{
|
|
return candidate == key || SimplifyControlKey(candidate) == SimplifyControlKey(key);
|
|
}
|
|
|
|
std::vector<double> JsonArrayToNumbers(const JsonValue& value)
|
|
{
|
|
std::vector<double> numbers;
|
|
for (const JsonValue& item : value.asArray())
|
|
{
|
|
if (item.isNumber())
|
|
numbers.push_back(item.asNumber());
|
|
}
|
|
return numbers;
|
|
}
|
|
|
|
bool LooksLikePackagedRuntimeRoot(const std::filesystem::path& candidate)
|
|
{
|
|
return std::filesystem::exists(candidate / "config" / "runtime-host.json") &&
|
|
std::filesystem::exists(candidate / "runtime" / "templates" / "shader_wrapper.slang.in") &&
|
|
std::filesystem::exists(candidate / "shaders");
|
|
}
|
|
|
|
bool LooksLikeRepoRoot(const std::filesystem::path& candidate)
|
|
{
|
|
return std::filesystem::exists(candidate / "CMakeLists.txt") &&
|
|
std::filesystem::exists(candidate / "apps" / "LoopThroughWithOpenGLCompositing");
|
|
}
|
|
|
|
std::filesystem::path FindRepoRootCandidate()
|
|
{
|
|
std::vector<std::filesystem::path> rootsToTry;
|
|
|
|
char currentDirectory[MAX_PATH] = {};
|
|
if (GetCurrentDirectoryA(MAX_PATH, currentDirectory) > 0)
|
|
rootsToTry.push_back(std::filesystem::path(currentDirectory));
|
|
|
|
char modulePath[MAX_PATH] = {};
|
|
DWORD moduleLength = GetModuleFileNameA(NULL, modulePath, MAX_PATH);
|
|
if (moduleLength > 0 && moduleLength < MAX_PATH)
|
|
rootsToTry.push_back(std::filesystem::path(modulePath).parent_path());
|
|
|
|
for (const std::filesystem::path& startPath : rootsToTry)
|
|
{
|
|
std::filesystem::path candidate = startPath;
|
|
for (int depth = 0; depth < 10 && !candidate.empty(); ++depth)
|
|
{
|
|
if (LooksLikePackagedRuntimeRoot(candidate) || LooksLikeRepoRoot(candidate))
|
|
return candidate;
|
|
|
|
candidate = candidate.parent_path();
|
|
}
|
|
}
|
|
|
|
return std::filesystem::path();
|
|
}
|
|
|
|
std::string ShaderParameterTypeToString(ShaderParameterType type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case ShaderParameterType::Float: return "float";
|
|
case ShaderParameterType::Vec2: return "vec2";
|
|
case ShaderParameterType::Color: return "color";
|
|
case ShaderParameterType::Boolean: return "bool";
|
|
case ShaderParameterType::Enum: return "enum";
|
|
}
|
|
return "unknown";
|
|
}
|
|
|
|
bool ParseTemporalHistorySource(const std::string& sourceName, TemporalHistorySource& source)
|
|
{
|
|
if (sourceName == "source")
|
|
{
|
|
source = TemporalHistorySource::Source;
|
|
return true;
|
|
}
|
|
if (sourceName == "preLayerInput")
|
|
{
|
|
source = TemporalHistorySource::PreLayerInput;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool ParseShaderParameterType(const std::string& typeName, ShaderParameterType& type)
|
|
{
|
|
if (typeName == "float")
|
|
{
|
|
type = ShaderParameterType::Float;
|
|
return true;
|
|
}
|
|
if (typeName == "vec2")
|
|
{
|
|
type = ShaderParameterType::Vec2;
|
|
return true;
|
|
}
|
|
if (typeName == "color")
|
|
{
|
|
type = ShaderParameterType::Color;
|
|
return true;
|
|
}
|
|
if (typeName == "bool")
|
|
{
|
|
type = ShaderParameterType::Boolean;
|
|
return true;
|
|
}
|
|
if (typeName == "enum")
|
|
{
|
|
type = ShaderParameterType::Enum;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool TextureAssetsEqual(const std::vector<ShaderTextureAsset>& left, const std::vector<ShaderTextureAsset>& right)
|
|
{
|
|
if (left.size() != right.size())
|
|
return false;
|
|
|
|
for (std::size_t index = 0; index < left.size(); ++index)
|
|
{
|
|
if (left[index].id != right[index].id ||
|
|
left[index].path != right[index].path ||
|
|
left[index].writeTime != right[index].writeTime)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
std::string ManifestPathMessage(const std::filesystem::path& manifestPath)
|
|
{
|
|
return manifestPath.string();
|
|
}
|
|
|
|
bool RequireStringField(const JsonValue& object, const char* fieldName, std::string& value, const std::filesystem::path& manifestPath, std::string& error)
|
|
{
|
|
const JsonValue* fieldValue = object.find(fieldName);
|
|
if (!fieldValue || !fieldValue->isString())
|
|
{
|
|
error = "Shader manifest is missing required string '" + std::string(fieldName) + "' field: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
|
|
value = fieldValue->asString();
|
|
return true;
|
|
}
|
|
|
|
bool RequireNonEmptyStringField(const JsonValue& object, const char* fieldName, std::string& value, const std::filesystem::path& manifestPath, std::string& error)
|
|
{
|
|
if (!RequireStringField(object, fieldName, value, manifestPath, error))
|
|
return false;
|
|
if (Trim(value).empty())
|
|
{
|
|
error = "Shader manifest string '" + std::string(fieldName) + "' must not be empty: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool OptionalStringField(const JsonValue& object, const char* fieldName, std::string& value, const std::string& fallback, const std::filesystem::path& manifestPath, std::string& error)
|
|
{
|
|
const JsonValue* fieldValue = object.find(fieldName);
|
|
if (!fieldValue)
|
|
{
|
|
value = fallback;
|
|
return true;
|
|
}
|
|
if (!fieldValue->isString())
|
|
{
|
|
error = "Shader manifest field '" + std::string(fieldName) + "' must be a string in: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
value = fieldValue->asString();
|
|
return true;
|
|
}
|
|
|
|
bool OptionalArrayField(const JsonValue& object, const char* fieldName, const JsonValue*& value, const std::filesystem::path& manifestPath, std::string& error)
|
|
{
|
|
value = object.find(fieldName);
|
|
if (!value)
|
|
return true;
|
|
if (!value->isArray())
|
|
{
|
|
error = "Shader manifest '" + std::string(fieldName) + "' field must be an array in: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool OptionalObjectField(const JsonValue& object, const char* fieldName, const JsonValue*& value, const std::filesystem::path& manifestPath, std::string& error)
|
|
{
|
|
value = object.find(fieldName);
|
|
if (!value)
|
|
return true;
|
|
if (!value->isObject())
|
|
{
|
|
error = "Shader manifest '" + std::string(fieldName) + "' field must be an object in: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool NumberListFromJsonValue(const JsonValue& value, std::vector<double>& numbers, const std::string& fieldName, const std::filesystem::path& manifestPath, std::string& error)
|
|
{
|
|
if (value.isNumber())
|
|
{
|
|
numbers.push_back(value.asNumber());
|
|
return true;
|
|
}
|
|
if (value.isArray())
|
|
{
|
|
numbers = JsonArrayToNumbers(value);
|
|
if (numbers.size() != value.asArray().size())
|
|
{
|
|
error = "Shader parameter field '" + fieldName + "' must contain only numbers in: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
error = "Shader parameter field '" + fieldName + "' must be a number or array of numbers in: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
|
|
bool ValidateShaderIdentifier(const std::string& identifier, const std::string& fieldName, const std::filesystem::path& manifestPath, std::string& error)
|
|
{
|
|
if (identifier.empty() || !(std::isalpha(static_cast<unsigned char>(identifier.front())) || identifier.front() == '_'))
|
|
{
|
|
error = "Shader manifest field '" + fieldName + "' must be a valid shader identifier in: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
|
|
for (char ch : identifier)
|
|
{
|
|
const unsigned char unsignedCh = static_cast<unsigned char>(ch);
|
|
if (!(std::isalnum(unsignedCh) || ch == '_'))
|
|
{
|
|
error = "Shader manifest field '" + fieldName + "' must be a valid shader identifier in: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ParseShaderMetadata(const JsonValue& manifestJson, ShaderPackage& shaderPackage, const std::filesystem::path& manifestPath, std::string& error)
|
|
{
|
|
if (!RequireStringField(manifestJson, "id", shaderPackage.id, manifestPath, error) ||
|
|
!RequireStringField(manifestJson, "name", shaderPackage.displayName, manifestPath, error) ||
|
|
!OptionalStringField(manifestJson, "description", shaderPackage.description, "", manifestPath, error) ||
|
|
!OptionalStringField(manifestJson, "category", shaderPackage.category, "", manifestPath, error) ||
|
|
!OptionalStringField(manifestJson, "entryPoint", shaderPackage.entryPoint, "shadeVideo", manifestPath, error))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!ValidateShaderIdentifier(shaderPackage.entryPoint, "entryPoint", manifestPath, error))
|
|
return false;
|
|
|
|
shaderPackage.directoryPath = manifestPath.parent_path();
|
|
shaderPackage.shaderPath = shaderPackage.directoryPath / "shader.slang";
|
|
shaderPackage.manifestPath = manifestPath;
|
|
return true;
|
|
}
|
|
|
|
bool ParseTextureAssets(const JsonValue& manifestJson, ShaderPackage& shaderPackage, const std::filesystem::path& manifestPath, std::string& error)
|
|
{
|
|
const JsonValue* texturesValue = nullptr;
|
|
if (!OptionalArrayField(manifestJson, "textures", texturesValue, manifestPath, error))
|
|
return false;
|
|
if (!texturesValue)
|
|
return true;
|
|
|
|
for (const JsonValue& textureJson : texturesValue->asArray())
|
|
{
|
|
if (!textureJson.isObject())
|
|
{
|
|
error = "Shader texture entry must be an object in: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
|
|
std::string textureId;
|
|
std::string texturePath;
|
|
if (!RequireNonEmptyStringField(textureJson, "id", textureId, manifestPath, error) ||
|
|
!RequireNonEmptyStringField(textureJson, "path", texturePath, manifestPath, error))
|
|
{
|
|
error = "Shader texture is missing required 'id' or 'path' in: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
if (!ValidateShaderIdentifier(textureId, "textures[].id", manifestPath, error))
|
|
return false;
|
|
|
|
ShaderTextureAsset textureAsset;
|
|
textureAsset.id = textureId;
|
|
textureAsset.path = shaderPackage.directoryPath / texturePath;
|
|
if (!std::filesystem::exists(textureAsset.path))
|
|
{
|
|
error = "Shader texture asset not found for package " + shaderPackage.id + ": " + textureAsset.path.string();
|
|
return false;
|
|
}
|
|
|
|
textureAsset.writeTime = std::filesystem::last_write_time(textureAsset.path);
|
|
shaderPackage.textureAssets.push_back(textureAsset);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ParseTemporalSettings(const JsonValue& manifestJson, ShaderPackage& shaderPackage, unsigned maxTemporalHistoryFrames, const std::filesystem::path& manifestPath, std::string& error)
|
|
{
|
|
const JsonValue* temporalValue = nullptr;
|
|
if (!OptionalObjectField(manifestJson, "temporal", temporalValue, manifestPath, error))
|
|
return false;
|
|
if (!temporalValue)
|
|
return true;
|
|
|
|
const JsonValue* enabledValue = temporalValue->find("enabled");
|
|
if (!enabledValue || !enabledValue->asBoolean(false))
|
|
return true;
|
|
|
|
std::string historySourceName;
|
|
if (!RequireNonEmptyStringField(*temporalValue, "historySource", historySourceName, manifestPath, error))
|
|
{
|
|
error = "Temporal shader is missing required 'historySource' in: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
|
|
const JsonValue* historyLengthValue = temporalValue->find("historyLength");
|
|
if (!historyLengthValue || !historyLengthValue->isNumber())
|
|
{
|
|
error = "Temporal shader is missing required numeric 'historyLength' in: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
|
|
TemporalHistorySource historySource = TemporalHistorySource::None;
|
|
if (!ParseTemporalHistorySource(historySourceName, historySource))
|
|
{
|
|
error = "Unsupported temporal historySource '" + historySourceName + "' in: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
|
|
const double requestedHistoryLength = historyLengthValue->asNumber();
|
|
if (!IsFiniteNumber(requestedHistoryLength) || requestedHistoryLength <= 0.0 || std::floor(requestedHistoryLength) != requestedHistoryLength)
|
|
{
|
|
error = "Temporal shader 'historyLength' must be a positive integer in: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
|
|
shaderPackage.temporal.enabled = true;
|
|
shaderPackage.temporal.historySource = historySource;
|
|
shaderPackage.temporal.requestedHistoryLength = static_cast<unsigned>(requestedHistoryLength);
|
|
shaderPackage.temporal.effectiveHistoryLength = std::min(shaderPackage.temporal.requestedHistoryLength, maxTemporalHistoryFrames);
|
|
return true;
|
|
}
|
|
|
|
bool ParseParameterNumberField(const JsonValue& parameterJson, const char* fieldName, std::vector<double>& values, const std::filesystem::path& manifestPath, std::string& error)
|
|
{
|
|
if (const JsonValue* fieldValue = parameterJson.find(fieldName))
|
|
return NumberListFromJsonValue(*fieldValue, values, fieldName, manifestPath, error);
|
|
return true;
|
|
}
|
|
|
|
bool ParseParameterDefault(const JsonValue& parameterJson, ShaderParameterDefinition& definition, const std::filesystem::path& manifestPath, std::string& error)
|
|
{
|
|
const JsonValue* defaultValue = parameterJson.find("default");
|
|
if (!defaultValue)
|
|
return true;
|
|
|
|
if (definition.type == ShaderParameterType::Boolean)
|
|
{
|
|
if (!defaultValue->isBoolean())
|
|
{
|
|
error = "Boolean parameter default must be a boolean for: " + definition.id;
|
|
return false;
|
|
}
|
|
definition.defaultBoolean = defaultValue->asBoolean(false);
|
|
return true;
|
|
}
|
|
|
|
if (definition.type == ShaderParameterType::Enum)
|
|
{
|
|
if (!defaultValue->isString())
|
|
{
|
|
error = "Enum parameter default must be a string for: " + definition.id;
|
|
return false;
|
|
}
|
|
definition.defaultEnumValue = defaultValue->asString();
|
|
return true;
|
|
}
|
|
|
|
return NumberListFromJsonValue(*defaultValue, definition.defaultNumbers, "default", manifestPath, error);
|
|
}
|
|
|
|
bool ParseParameterOptions(const JsonValue& parameterJson, ShaderParameterDefinition& definition, const std::filesystem::path& manifestPath, std::string& error)
|
|
{
|
|
const JsonValue* optionsValue = nullptr;
|
|
if (!OptionalArrayField(parameterJson, "options", optionsValue, manifestPath, error) || !optionsValue)
|
|
{
|
|
error = "Enum parameter is missing 'options' in: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
|
|
for (const JsonValue& optionJson : optionsValue->asArray())
|
|
{
|
|
if (!optionJson.isObject())
|
|
{
|
|
error = "Enum parameter option must be an object in: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
|
|
ShaderParameterOption option;
|
|
if (!RequireStringField(optionJson, "value", option.value, manifestPath, error) ||
|
|
!RequireStringField(optionJson, "label", option.label, manifestPath, error))
|
|
{
|
|
error = "Enum parameter option is missing 'value' or 'label' in: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
definition.enumOptions.push_back(option);
|
|
}
|
|
|
|
bool defaultFound = definition.defaultEnumValue.empty();
|
|
for (const ShaderParameterOption& option : definition.enumOptions)
|
|
{
|
|
if (option.value == definition.defaultEnumValue)
|
|
{
|
|
defaultFound = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!defaultFound)
|
|
{
|
|
error = "Enum parameter default is not present in its option list for: " + definition.id;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ParseParameterDefinition(const JsonValue& parameterJson, ShaderParameterDefinition& definition, const std::filesystem::path& manifestPath, std::string& error)
|
|
{
|
|
if (!parameterJson.isObject())
|
|
{
|
|
error = "Shader parameter entry must be an object in: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
|
|
std::string typeName;
|
|
if (!RequireStringField(parameterJson, "id", definition.id, manifestPath, error) ||
|
|
!RequireStringField(parameterJson, "label", definition.label, manifestPath, error) ||
|
|
!RequireStringField(parameterJson, "type", typeName, manifestPath, error))
|
|
{
|
|
error = "Shader parameter is missing required fields in: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
|
|
if (!ParseShaderParameterType(typeName, definition.type))
|
|
{
|
|
error = "Unsupported parameter type '" + typeName + "' in: " + ManifestPathMessage(manifestPath);
|
|
return false;
|
|
}
|
|
if (!ValidateShaderIdentifier(definition.id, "parameters[].id", manifestPath, error))
|
|
return false;
|
|
|
|
if (!ParseParameterDefault(parameterJson, definition, manifestPath, error) ||
|
|
!ParseParameterNumberField(parameterJson, "min", definition.minNumbers, manifestPath, error) ||
|
|
!ParseParameterNumberField(parameterJson, "max", definition.maxNumbers, manifestPath, error) ||
|
|
!ParseParameterNumberField(parameterJson, "step", definition.stepNumbers, manifestPath, error))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (definition.type == ShaderParameterType::Enum)
|
|
return ParseParameterOptions(parameterJson, definition, manifestPath, error);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ParseParameterDefinitions(const JsonValue& manifestJson, ShaderPackage& shaderPackage, const std::filesystem::path& manifestPath, std::string& error)
|
|
{
|
|
const JsonValue* parametersValue = nullptr;
|
|
if (!OptionalArrayField(manifestJson, "parameters", parametersValue, manifestPath, error))
|
|
return false;
|
|
if (!parametersValue)
|
|
return true;
|
|
|
|
for (const JsonValue& parameterJson : parametersValue->asArray())
|
|
{
|
|
ShaderParameterDefinition definition;
|
|
if (!ParseParameterDefinition(parameterJson, definition, manifestPath, error))
|
|
return false;
|
|
shaderPackage.parameters.push_back(definition);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
RuntimeHost::RuntimeHost()
|
|
: mReloadRequested(false),
|
|
mCompileSucceeded(false),
|
|
mHasSignal(false),
|
|
mSignalWidth(0),
|
|
mSignalHeight(0),
|
|
mFrameBudgetMilliseconds(0.0),
|
|
mRenderMilliseconds(0.0),
|
|
mSmoothedRenderMilliseconds(0.0),
|
|
mServerPort(8080),
|
|
mAutoReloadEnabled(true),
|
|
mStartTime(std::chrono::steady_clock::now()),
|
|
mLastScanTime(std::chrono::steady_clock::time_point::min()),
|
|
mFrameCounter(0),
|
|
mNextLayerId(0)
|
|
{
|
|
}
|
|
|
|
bool RuntimeHost::Initialize(std::string& error)
|
|
{
|
|
try
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
|
|
if (!ResolvePaths(error))
|
|
return false;
|
|
if (!LoadConfig(error))
|
|
return false;
|
|
mShaderRoot = mRepoRoot / mConfig.shaderLibrary;
|
|
if (!LoadPersistentState(error))
|
|
return false;
|
|
if (!ScanShaderPackages(error))
|
|
return false;
|
|
|
|
for (LayerPersistentState& layer : mPersistentState.layers)
|
|
{
|
|
auto shaderIt = mPackagesById.find(layer.shaderId);
|
|
if (shaderIt != mPackagesById.end())
|
|
EnsureLayerDefaultsLocked(layer, shaderIt->second);
|
|
}
|
|
|
|
if (mPersistentState.layers.empty() && !mPackageOrder.empty())
|
|
{
|
|
LayerPersistentState layer;
|
|
layer.id = GenerateLayerId();
|
|
layer.shaderId = mPackageOrder.front();
|
|
layer.bypass = false;
|
|
EnsureLayerDefaultsLocked(layer, mPackagesById[layer.shaderId]);
|
|
mPersistentState.layers.push_back(layer);
|
|
}
|
|
|
|
mServerPort = mConfig.serverPort;
|
|
mAutoReloadEnabled = mConfig.autoReload;
|
|
mReloadRequested = true;
|
|
mCompileMessage = "Waiting for shader compile.";
|
|
return true;
|
|
}
|
|
catch (const std::exception& exception)
|
|
{
|
|
error = std::string("RuntimeHost::Initialize exception: ") + exception.what();
|
|
return false;
|
|
}
|
|
catch (...)
|
|
{
|
|
error = "RuntimeHost::Initialize threw a non-standard exception.";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool RuntimeHost::PollFileChanges(bool& registryChanged, bool& reloadRequested, std::string& error)
|
|
{
|
|
try
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
registryChanged = false;
|
|
reloadRequested = false;
|
|
|
|
if (!mAutoReloadEnabled)
|
|
{
|
|
reloadRequested = mReloadRequested;
|
|
return true;
|
|
}
|
|
|
|
const auto now = std::chrono::steady_clock::now();
|
|
if (mLastScanTime != std::chrono::steady_clock::time_point::min() &&
|
|
std::chrono::duration_cast<std::chrono::milliseconds>(now - mLastScanTime).count() < 250)
|
|
{
|
|
reloadRequested = mReloadRequested;
|
|
return true;
|
|
}
|
|
|
|
mLastScanTime = now;
|
|
|
|
std::string scanError;
|
|
std::map<std::string, ShaderPackage> previousPackages = mPackagesById;
|
|
std::vector<std::string> previousOrder = mPackageOrder;
|
|
std::map<std::string, std::pair<std::filesystem::file_time_type, std::filesystem::file_time_type>> previousLayerShaderTimes;
|
|
for (const LayerPersistentState& layer : mPersistentState.layers)
|
|
{
|
|
auto previous = previousPackages.find(layer.shaderId);
|
|
if (previous != previousPackages.end())
|
|
previousLayerShaderTimes[layer.id] = std::make_pair(previous->second.shaderWriteTime, previous->second.manifestWriteTime);
|
|
}
|
|
|
|
if (!ScanShaderPackages(scanError))
|
|
{
|
|
error = scanError;
|
|
return false;
|
|
}
|
|
|
|
registryChanged = previousOrder != mPackageOrder;
|
|
if (!registryChanged && previousPackages.size() == mPackagesById.size())
|
|
{
|
|
for (const auto& item : mPackagesById)
|
|
{
|
|
auto previous = previousPackages.find(item.first);
|
|
if (previous == previousPackages.end())
|
|
{
|
|
registryChanged = true;
|
|
break;
|
|
}
|
|
if (previous->second.shaderWriteTime != item.second.shaderWriteTime ||
|
|
previous->second.manifestWriteTime != item.second.manifestWriteTime ||
|
|
!TextureAssetsEqual(previous->second.textureAssets, item.second.textureAssets))
|
|
{
|
|
registryChanged = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (LayerPersistentState& layer : mPersistentState.layers)
|
|
{
|
|
auto active = mPackagesById.find(layer.shaderId);
|
|
auto previous = previousLayerShaderTimes.find(layer.id);
|
|
if (active == mPackagesById.end())
|
|
continue;
|
|
EnsureLayerDefaultsLocked(layer, active->second);
|
|
if (previous != previousLayerShaderTimes.end())
|
|
{
|
|
auto previousPackage = previousPackages.find(layer.shaderId);
|
|
if (previous->second.first != active->second.shaderWriteTime ||
|
|
previous->second.second != active->second.manifestWriteTime ||
|
|
(previousPackage != previousPackages.end() &&
|
|
!TextureAssetsEqual(previousPackage->second.textureAssets, active->second.textureAssets)))
|
|
{
|
|
mReloadRequested = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
reloadRequested = mReloadRequested;
|
|
return true;
|
|
}
|
|
catch (const std::exception& exception)
|
|
{
|
|
error = std::string("RuntimeHost::PollFileChanges exception: ") + exception.what();
|
|
return false;
|
|
}
|
|
catch (...)
|
|
{
|
|
error = "RuntimeHost::PollFileChanges threw a non-standard exception.";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool RuntimeHost::ManualReloadRequested()
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
return mReloadRequested;
|
|
}
|
|
|
|
void RuntimeHost::ClearReloadRequest()
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
mReloadRequested = false;
|
|
}
|
|
|
|
bool RuntimeHost::AddLayer(const std::string& shaderId, std::string& error)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
auto shaderIt = mPackagesById.find(shaderId);
|
|
if (shaderIt == mPackagesById.end())
|
|
{
|
|
error = "Unknown shader id: " + shaderId;
|
|
return false;
|
|
}
|
|
|
|
LayerPersistentState layer;
|
|
layer.id = GenerateLayerId();
|
|
layer.shaderId = shaderId;
|
|
layer.bypass = false;
|
|
EnsureLayerDefaultsLocked(layer, shaderIt->second);
|
|
mPersistentState.layers.push_back(layer);
|
|
mReloadRequested = true;
|
|
return SavePersistentState(error);
|
|
}
|
|
|
|
bool RuntimeHost::RemoveLayer(const std::string& layerId, std::string& error)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
auto it = std::find_if(mPersistentState.layers.begin(), mPersistentState.layers.end(),
|
|
[&layerId](const LayerPersistentState& layer) { return layer.id == layerId; });
|
|
if (it == mPersistentState.layers.end())
|
|
{
|
|
error = "Unknown layer id: " + layerId;
|
|
return false;
|
|
}
|
|
|
|
mPersistentState.layers.erase(it);
|
|
mReloadRequested = true;
|
|
return SavePersistentState(error);
|
|
}
|
|
|
|
bool RuntimeHost::MoveLayer(const std::string& layerId, int direction, std::string& error)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
auto it = std::find_if(mPersistentState.layers.begin(), mPersistentState.layers.end(),
|
|
[&layerId](const LayerPersistentState& layer) { return layer.id == layerId; });
|
|
if (it == mPersistentState.layers.end())
|
|
{
|
|
error = "Unknown layer id: " + layerId;
|
|
return false;
|
|
}
|
|
|
|
const std::ptrdiff_t index = std::distance(mPersistentState.layers.begin(), it);
|
|
const std::ptrdiff_t newIndex = index + direction;
|
|
if (newIndex < 0 || newIndex >= static_cast<std::ptrdiff_t>(mPersistentState.layers.size()))
|
|
return true;
|
|
|
|
std::swap(mPersistentState.layers[index], mPersistentState.layers[newIndex]);
|
|
mReloadRequested = true;
|
|
return SavePersistentState(error);
|
|
}
|
|
|
|
bool RuntimeHost::MoveLayerToIndex(const std::string& layerId, std::size_t targetIndex, std::string& error)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
auto it = std::find_if(mPersistentState.layers.begin(), mPersistentState.layers.end(),
|
|
[&layerId](const LayerPersistentState& layer) { return layer.id == layerId; });
|
|
if (it == mPersistentState.layers.end())
|
|
{
|
|
error = "Unknown layer id: " + layerId;
|
|
return false;
|
|
}
|
|
|
|
if (mPersistentState.layers.empty())
|
|
return true;
|
|
|
|
if (targetIndex >= mPersistentState.layers.size())
|
|
targetIndex = mPersistentState.layers.size() - 1;
|
|
|
|
const std::size_t sourceIndex = static_cast<std::size_t>(std::distance(mPersistentState.layers.begin(), it));
|
|
if (sourceIndex == targetIndex)
|
|
return true;
|
|
|
|
LayerPersistentState movedLayer = *it;
|
|
mPersistentState.layers.erase(mPersistentState.layers.begin() + static_cast<std::ptrdiff_t>(sourceIndex));
|
|
mPersistentState.layers.insert(mPersistentState.layers.begin() + static_cast<std::ptrdiff_t>(targetIndex), movedLayer);
|
|
mReloadRequested = true;
|
|
return SavePersistentState(error);
|
|
}
|
|
|
|
bool RuntimeHost::SetLayerBypass(const std::string& layerId, bool bypassed, std::string& error)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
LayerPersistentState* layer = FindLayerById(layerId);
|
|
if (!layer)
|
|
{
|
|
error = "Unknown layer id: " + layerId;
|
|
return false;
|
|
}
|
|
|
|
layer->bypass = bypassed;
|
|
mReloadRequested = true;
|
|
return SavePersistentState(error);
|
|
}
|
|
|
|
bool RuntimeHost::SetLayerShader(const std::string& layerId, const std::string& shaderId, std::string& error)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
LayerPersistentState* layer = FindLayerById(layerId);
|
|
if (!layer)
|
|
{
|
|
error = "Unknown layer id: " + layerId;
|
|
return false;
|
|
}
|
|
|
|
auto shaderIt = mPackagesById.find(shaderId);
|
|
if (shaderIt == mPackagesById.end())
|
|
{
|
|
error = "Unknown shader id: " + shaderId;
|
|
return false;
|
|
}
|
|
|
|
layer->shaderId = shaderId;
|
|
layer->parameterValues.clear();
|
|
EnsureLayerDefaultsLocked(*layer, shaderIt->second);
|
|
mReloadRequested = true;
|
|
return SavePersistentState(error);
|
|
}
|
|
|
|
bool RuntimeHost::UpdateLayerParameter(const std::string& layerId, const std::string& parameterId, const JsonValue& newValue, std::string& error)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
|
|
LayerPersistentState* layer = FindLayerById(layerId);
|
|
if (!layer)
|
|
{
|
|
error = "Unknown layer id: " + layerId;
|
|
return false;
|
|
}
|
|
|
|
auto shaderIt = mPackagesById.find(layer->shaderId);
|
|
if (shaderIt == mPackagesById.end())
|
|
{
|
|
error = "Unknown shader id: " + layer->shaderId;
|
|
return false;
|
|
}
|
|
|
|
const ShaderPackage& shaderPackage = shaderIt->second;
|
|
auto parameterIt = std::find_if(shaderPackage.parameters.begin(), shaderPackage.parameters.end(),
|
|
[¶meterId](const ShaderParameterDefinition& definition) { return definition.id == parameterId; });
|
|
if (parameterIt == shaderPackage.parameters.end())
|
|
{
|
|
error = "Unknown parameter id: " + parameterId;
|
|
return false;
|
|
}
|
|
|
|
ShaderParameterValue normalized;
|
|
if (!NormalizeAndValidateValue(*parameterIt, newValue, normalized, error))
|
|
return false;
|
|
|
|
layer->parameterValues[parameterId] = normalized;
|
|
return SavePersistentState(error);
|
|
}
|
|
|
|
bool RuntimeHost::UpdateLayerParameterByControlKey(const std::string& layerKey, const std::string& parameterKey, const JsonValue& newValue, std::string& error)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
|
|
LayerPersistentState* matchedLayer = nullptr;
|
|
const ShaderPackage* matchedPackage = nullptr;
|
|
for (LayerPersistentState& layer : mPersistentState.layers)
|
|
{
|
|
auto shaderIt = mPackagesById.find(layer.shaderId);
|
|
if (shaderIt == mPackagesById.end())
|
|
continue;
|
|
|
|
if (MatchesControlKey(layer.id, layerKey) || MatchesControlKey(shaderIt->second.id, layerKey) ||
|
|
MatchesControlKey(shaderIt->second.displayName, layerKey))
|
|
{
|
|
matchedLayer = &layer;
|
|
matchedPackage = &shaderIt->second;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!matchedLayer || !matchedPackage)
|
|
{
|
|
error = "Unknown OSC layer key: " + layerKey;
|
|
return false;
|
|
}
|
|
|
|
const auto parameterIt = std::find_if(matchedPackage->parameters.begin(), matchedPackage->parameters.end(),
|
|
[¶meterKey](const ShaderParameterDefinition& definition)
|
|
{
|
|
return MatchesControlKey(definition.id, parameterKey) || MatchesControlKey(definition.label, parameterKey);
|
|
});
|
|
if (parameterIt == matchedPackage->parameters.end())
|
|
{
|
|
error = "Unknown OSC parameter key: " + parameterKey;
|
|
return false;
|
|
}
|
|
|
|
ShaderParameterValue normalized;
|
|
if (!NormalizeAndValidateValue(*parameterIt, newValue, normalized, error))
|
|
return false;
|
|
|
|
matchedLayer->parameterValues[parameterIt->id] = normalized;
|
|
return SavePersistentState(error);
|
|
}
|
|
|
|
bool RuntimeHost::ResetLayerParameters(const std::string& layerId, std::string& error)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
|
|
LayerPersistentState* layer = FindLayerById(layerId);
|
|
if (!layer)
|
|
{
|
|
error = "Unknown layer id: " + layerId;
|
|
return false;
|
|
}
|
|
|
|
auto shaderIt = mPackagesById.find(layer->shaderId);
|
|
if (shaderIt == mPackagesById.end())
|
|
{
|
|
error = "Unknown shader id: " + layer->shaderId;
|
|
return false;
|
|
}
|
|
|
|
layer->parameterValues.clear();
|
|
EnsureLayerDefaultsLocked(*layer, shaderIt->second);
|
|
return SavePersistentState(error);
|
|
}
|
|
|
|
bool RuntimeHost::SaveStackPreset(const std::string& presetName, std::string& error) const
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
const std::string safeStem = MakeSafePresetFileStem(presetName);
|
|
if (safeStem.empty())
|
|
{
|
|
error = "Preset name must include at least one letter or number.";
|
|
return false;
|
|
}
|
|
|
|
JsonValue root = JsonValue::MakeObject();
|
|
root.set("version", JsonValue(1.0));
|
|
root.set("name", JsonValue(Trim(presetName)));
|
|
root.set("layers", SerializeLayerStackLocked());
|
|
|
|
return WriteTextFile(mPresetRoot / (safeStem + ".json"), SerializeJson(root, true), error);
|
|
}
|
|
|
|
bool RuntimeHost::LoadStackPreset(const std::string& presetName, std::string& error)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
const std::string safeStem = MakeSafePresetFileStem(presetName);
|
|
if (safeStem.empty())
|
|
{
|
|
error = "Preset name must include at least one letter or number.";
|
|
return false;
|
|
}
|
|
|
|
const std::filesystem::path presetPath = mPresetRoot / (safeStem + ".json");
|
|
std::string presetText = ReadTextFile(presetPath, error);
|
|
if (presetText.empty())
|
|
return false;
|
|
|
|
JsonValue root;
|
|
if (!ParseJson(presetText, root, error))
|
|
return false;
|
|
|
|
const JsonValue* layersValue = root.find("layers");
|
|
if (!layersValue || !layersValue->isArray())
|
|
{
|
|
error = "Preset file is missing a valid 'layers' array.";
|
|
return false;
|
|
}
|
|
|
|
std::vector<LayerPersistentState> nextLayers;
|
|
if (!DeserializeLayerStackLocked(*layersValue, nextLayers, error))
|
|
return false;
|
|
|
|
if (nextLayers.empty())
|
|
{
|
|
error = "Preset does not contain any valid layers.";
|
|
return false;
|
|
}
|
|
|
|
mPersistentState.layers = nextLayers;
|
|
mReloadRequested = true;
|
|
return SavePersistentState(error);
|
|
}
|
|
|
|
void RuntimeHost::SetCompileStatus(bool succeeded, const std::string& message)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
mCompileSucceeded = succeeded;
|
|
mCompileMessage = message;
|
|
}
|
|
|
|
void RuntimeHost::SetSignalStatus(bool hasSignal, unsigned width, unsigned height, const std::string& modeName)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
mHasSignal = hasSignal;
|
|
mSignalWidth = width;
|
|
mSignalHeight = height;
|
|
mSignalModeName = modeName;
|
|
}
|
|
|
|
void RuntimeHost::SetDeckLinkOutputStatus(const std::string& modelName, bool supportsInternalKeying, bool supportsExternalKeying,
|
|
bool keyerInterfaceAvailable, bool externalKeyingRequested, bool externalKeyingActive, const std::string& statusMessage)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
mDeckLinkOutputStatus.modelName = modelName;
|
|
mDeckLinkOutputStatus.supportsInternalKeying = supportsInternalKeying;
|
|
mDeckLinkOutputStatus.supportsExternalKeying = supportsExternalKeying;
|
|
mDeckLinkOutputStatus.keyerInterfaceAvailable = keyerInterfaceAvailable;
|
|
mDeckLinkOutputStatus.externalKeyingRequested = externalKeyingRequested;
|
|
mDeckLinkOutputStatus.externalKeyingActive = externalKeyingActive;
|
|
mDeckLinkOutputStatus.statusMessage = statusMessage;
|
|
}
|
|
|
|
void RuntimeHost::SetPerformanceStats(double frameBudgetMilliseconds, double renderMilliseconds)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
mFrameBudgetMilliseconds = std::max(frameBudgetMilliseconds, 0.0);
|
|
mRenderMilliseconds = std::max(renderMilliseconds, 0.0);
|
|
if (mSmoothedRenderMilliseconds <= 0.0)
|
|
mSmoothedRenderMilliseconds = mRenderMilliseconds;
|
|
else
|
|
mSmoothedRenderMilliseconds = mSmoothedRenderMilliseconds * 0.9 + mRenderMilliseconds * 0.1;
|
|
}
|
|
|
|
void RuntimeHost::SetAudioStatus(const AudioStatusSnapshot& status)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
mAudioStatus = status;
|
|
}
|
|
|
|
void RuntimeHost::AdvanceFrame()
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
++mFrameCounter;
|
|
}
|
|
|
|
bool RuntimeHost::BuildLayerFragmentShaderSource(const std::string& layerId, std::string& fragmentShaderSource, std::string& error)
|
|
{
|
|
try
|
|
{
|
|
ShaderPackage shaderPackage;
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
const LayerPersistentState* layer = FindLayerById(layerId);
|
|
if (!layer)
|
|
{
|
|
error = "Unknown layer id: " + layerId;
|
|
return false;
|
|
}
|
|
|
|
auto it = mPackagesById.find(layer->shaderId);
|
|
if (it == mPackagesById.end())
|
|
{
|
|
error = "Unknown shader id: " + layer->shaderId;
|
|
return false;
|
|
}
|
|
shaderPackage = it->second;
|
|
}
|
|
|
|
ShaderCompiler compiler(mRepoRoot, mWrapperPath, mGeneratedGlslPath, mPatchedGlslPath, mConfig.maxTemporalHistoryFrames);
|
|
return compiler.BuildLayerFragmentShaderSource(shaderPackage, fragmentShaderSource, error);
|
|
}
|
|
catch (const std::exception& exception)
|
|
{
|
|
error = std::string("RuntimeHost::BuildLayerFragmentShaderSource exception: ") + exception.what();
|
|
return false;
|
|
}
|
|
catch (...)
|
|
{
|
|
error = "RuntimeHost::BuildLayerFragmentShaderSource threw a non-standard exception.";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
std::vector<RuntimeRenderState> RuntimeHost::GetLayerRenderStates(unsigned outputWidth, unsigned outputHeight) const
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
std::vector<RuntimeRenderState> states;
|
|
|
|
for (const LayerPersistentState& layer : mPersistentState.layers)
|
|
{
|
|
auto shaderIt = mPackagesById.find(layer.shaderId);
|
|
if (shaderIt == mPackagesById.end())
|
|
continue;
|
|
|
|
RuntimeRenderState state;
|
|
state.layerId = layer.id;
|
|
state.shaderId = layer.shaderId;
|
|
state.timeSeconds = std::chrono::duration_cast<std::chrono::duration<double>>(std::chrono::steady_clock::now() - mStartTime).count();
|
|
state.frameCount = static_cast<double>(mFrameCounter);
|
|
state.mixAmount = 1.0;
|
|
state.bypass = layer.bypass ? 1.0 : 0.0;
|
|
state.inputWidth = mSignalWidth;
|
|
state.inputHeight = mSignalHeight;
|
|
state.outputWidth = outputWidth;
|
|
state.outputHeight = outputHeight;
|
|
state.audioAnalysis = mAudioStatus.analysis;
|
|
state.parameterDefinitions = shaderIt->second.parameters;
|
|
state.textureAssets = shaderIt->second.textureAssets;
|
|
state.isTemporal = shaderIt->second.temporal.enabled;
|
|
state.temporalHistorySource = shaderIt->second.temporal.historySource;
|
|
state.requestedTemporalHistoryLength = shaderIt->second.temporal.requestedHistoryLength;
|
|
state.effectiveTemporalHistoryLength = shaderIt->second.temporal.effectiveHistoryLength;
|
|
|
|
for (const ShaderParameterDefinition& definition : shaderIt->second.parameters)
|
|
{
|
|
ShaderParameterValue value = DefaultValueForDefinition(definition);
|
|
auto valueIt = layer.parameterValues.find(definition.id);
|
|
if (valueIt != layer.parameterValues.end())
|
|
value = valueIt->second;
|
|
state.parameterValues[definition.id] = value;
|
|
}
|
|
|
|
states.push_back(state);
|
|
}
|
|
|
|
return states;
|
|
}
|
|
|
|
std::string RuntimeHost::BuildStateJson() const
|
|
{
|
|
return SerializeJson(BuildStateValue(), true);
|
|
}
|
|
|
|
void RuntimeHost::SetServerPort(unsigned short port)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
mServerPort = port;
|
|
}
|
|
|
|
bool RuntimeHost::LoadConfig(std::string& error)
|
|
{
|
|
if (!std::filesystem::exists(mConfigPath))
|
|
return true;
|
|
|
|
std::string configText = ReadTextFile(mConfigPath, error);
|
|
if (configText.empty())
|
|
return false;
|
|
|
|
JsonValue configJson;
|
|
if (!ParseJson(configText, configJson, error))
|
|
return false;
|
|
|
|
if (const JsonValue* shaderLibraryValue = configJson.find("shaderLibrary"))
|
|
mConfig.shaderLibrary = shaderLibraryValue->asString();
|
|
if (const JsonValue* serverPortValue = configJson.find("serverPort"))
|
|
mConfig.serverPort = static_cast<unsigned short>(serverPortValue->asNumber(mConfig.serverPort));
|
|
if (const JsonValue* oscPortValue = configJson.find("oscPort"))
|
|
mConfig.oscPort = static_cast<unsigned short>(oscPortValue->asNumber(mConfig.oscPort));
|
|
if (const JsonValue* autoReloadValue = configJson.find("autoReload"))
|
|
mConfig.autoReload = autoReloadValue->asBoolean(mConfig.autoReload);
|
|
if (const JsonValue* maxTemporalHistoryFramesValue = configJson.find("maxTemporalHistoryFrames"))
|
|
{
|
|
const double configuredValue = maxTemporalHistoryFramesValue->asNumber(static_cast<double>(mConfig.maxTemporalHistoryFrames));
|
|
mConfig.maxTemporalHistoryFrames = configuredValue <= 0.0 ? 0u : static_cast<unsigned>(configuredValue);
|
|
}
|
|
if (const JsonValue* enableExternalKeyingValue = configJson.find("enableExternalKeying"))
|
|
mConfig.enableExternalKeying = enableExternalKeyingValue->asBoolean(mConfig.enableExternalKeying);
|
|
if (const JsonValue* audioEnabledValue = configJson.find("audioEnabled"))
|
|
mConfig.audioEnabled = audioEnabledValue->asBoolean(mConfig.audioEnabled);
|
|
if (const JsonValue* audioOutputEnabledValue = configJson.find("audioOutputEnabled"))
|
|
mConfig.audioOutputEnabled = audioOutputEnabledValue->asBoolean(mConfig.audioOutputEnabled);
|
|
if (const JsonValue* audioScheduleEnabledValue = configJson.find("audioScheduleEnabled"))
|
|
mConfig.audioScheduleEnabled = audioScheduleEnabledValue->asBoolean(mConfig.audioScheduleEnabled);
|
|
if (const JsonValue* audioPrerollEnabledValue = configJson.find("audioPrerollEnabled"))
|
|
mConfig.audioPrerollEnabled = audioPrerollEnabledValue->asBoolean(mConfig.audioPrerollEnabled);
|
|
if (const JsonValue* audioScheduleSilenceValue = configJson.find("audioScheduleSilence"))
|
|
mConfig.audioScheduleSilence = audioScheduleSilenceValue->asBoolean(mConfig.audioScheduleSilence);
|
|
if (const JsonValue* audioScheduleToneValue = configJson.find("audioScheduleTone"))
|
|
mConfig.audioScheduleTone = audioScheduleToneValue->asBoolean(mConfig.audioScheduleTone);
|
|
if (const JsonValue* audioChannelCountValue = configJson.find("audioChannelCount"))
|
|
mConfig.audioChannelCount = static_cast<unsigned>(audioChannelCountValue->asNumber(static_cast<double>(mConfig.audioChannelCount)));
|
|
if (const JsonValue* audioSampleRateValue = configJson.find("audioSampleRate"))
|
|
mConfig.audioSampleRate = static_cast<unsigned>(audioSampleRateValue->asNumber(static_cast<double>(mConfig.audioSampleRate)));
|
|
if (const JsonValue* audioDelayModeValue = configJson.find("audioDelayMode"))
|
|
{
|
|
if (audioDelayModeValue->isString() && !audioDelayModeValue->asString().empty())
|
|
mConfig.audioDelayMode = audioDelayModeValue->asString();
|
|
}
|
|
if (mConfig.audioChannelCount != kAudioChannelCount)
|
|
mConfig.audioChannelCount = kAudioChannelCount;
|
|
if (mConfig.audioSampleRate != kAudioSampleRate)
|
|
mConfig.audioSampleRate = kAudioSampleRate;
|
|
if (const JsonValue* videoFormatValue = configJson.find("videoFormat"))
|
|
{
|
|
if (videoFormatValue->isString() && !videoFormatValue->asString().empty())
|
|
{
|
|
mConfig.inputVideoFormat = videoFormatValue->asString();
|
|
mConfig.outputVideoFormat = videoFormatValue->asString();
|
|
}
|
|
}
|
|
if (const JsonValue* frameRateValue = configJson.find("frameRate"))
|
|
{
|
|
if (frameRateValue->isString() && !frameRateValue->asString().empty())
|
|
{
|
|
mConfig.inputFrameRate = frameRateValue->asString();
|
|
mConfig.outputFrameRate = frameRateValue->asString();
|
|
}
|
|
else if (frameRateValue->isNumber())
|
|
{
|
|
std::ostringstream stream;
|
|
stream << frameRateValue->asNumber();
|
|
mConfig.inputFrameRate = stream.str();
|
|
mConfig.outputFrameRate = stream.str();
|
|
}
|
|
}
|
|
if (const JsonValue* inputVideoFormatValue = configJson.find("inputVideoFormat"))
|
|
{
|
|
if (inputVideoFormatValue->isString() && !inputVideoFormatValue->asString().empty())
|
|
mConfig.inputVideoFormat = inputVideoFormatValue->asString();
|
|
}
|
|
if (const JsonValue* inputFrameRateValue = configJson.find("inputFrameRate"))
|
|
{
|
|
if (inputFrameRateValue->isString() && !inputFrameRateValue->asString().empty())
|
|
mConfig.inputFrameRate = inputFrameRateValue->asString();
|
|
else if (inputFrameRateValue->isNumber())
|
|
{
|
|
std::ostringstream stream;
|
|
stream << inputFrameRateValue->asNumber();
|
|
mConfig.inputFrameRate = stream.str();
|
|
}
|
|
}
|
|
if (const JsonValue* outputVideoFormatValue = configJson.find("outputVideoFormat"))
|
|
{
|
|
if (outputVideoFormatValue->isString() && !outputVideoFormatValue->asString().empty())
|
|
mConfig.outputVideoFormat = outputVideoFormatValue->asString();
|
|
}
|
|
if (const JsonValue* outputFrameRateValue = configJson.find("outputFrameRate"))
|
|
{
|
|
if (outputFrameRateValue->isString() && !outputFrameRateValue->asString().empty())
|
|
mConfig.outputFrameRate = outputFrameRateValue->asString();
|
|
else if (outputFrameRateValue->isNumber())
|
|
{
|
|
std::ostringstream stream;
|
|
stream << outputFrameRateValue->asNumber();
|
|
mConfig.outputFrameRate = stream.str();
|
|
}
|
|
}
|
|
|
|
mAutoReloadEnabled = mConfig.autoReload;
|
|
return true;
|
|
}
|
|
|
|
bool RuntimeHost::LoadPersistentState(std::string& error)
|
|
{
|
|
if (!std::filesystem::exists(mRuntimeStatePath))
|
|
return true;
|
|
|
|
std::string stateText = ReadTextFile(mRuntimeStatePath, error);
|
|
if (stateText.empty())
|
|
return false;
|
|
|
|
JsonValue root;
|
|
if (!ParseJson(stateText, root, error))
|
|
return false;
|
|
|
|
if (const JsonValue* layersValue = root.find("layers"))
|
|
{
|
|
for (const JsonValue& layerValue : layersValue->asArray())
|
|
{
|
|
if (!layerValue.isObject())
|
|
continue;
|
|
LayerPersistentState layer;
|
|
if (const JsonValue* idValue = layerValue.find("id"))
|
|
layer.id = idValue->asString();
|
|
if (const JsonValue* shaderIdValue = layerValue.find("shaderId"))
|
|
layer.shaderId = shaderIdValue->asString();
|
|
if (const JsonValue* bypassValue = layerValue.find("bypass"))
|
|
layer.bypass = bypassValue->asBoolean(false);
|
|
else if (const JsonValue* enabledValue = layerValue.find("enabled"))
|
|
layer.bypass = !enabledValue->asBoolean(true);
|
|
|
|
if (const JsonValue* parameterValues = layerValue.find("parameterValues"))
|
|
{
|
|
for (const auto& parameterItem : parameterValues->asObject())
|
|
{
|
|
ShaderParameterValue value;
|
|
const JsonValue& jsonValue = parameterItem.second;
|
|
if (jsonValue.isBoolean())
|
|
value.booleanValue = jsonValue.asBoolean();
|
|
else if (jsonValue.isString())
|
|
value.enumValue = jsonValue.asString();
|
|
else if (jsonValue.isNumber())
|
|
value.numberValues.push_back(jsonValue.asNumber());
|
|
else if (jsonValue.isArray())
|
|
value.numberValues = JsonArrayToNumbers(jsonValue);
|
|
layer.parameterValues[parameterItem.first] = value;
|
|
}
|
|
}
|
|
|
|
if (!layer.shaderId.empty())
|
|
mPersistentState.layers.push_back(layer);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Migrate from the older single-shader state shape.
|
|
std::string activeShaderId;
|
|
if (const JsonValue* activeShaderValue = root.find("activeShaderId"))
|
|
activeShaderId = activeShaderValue->asString();
|
|
|
|
if (!activeShaderId.empty())
|
|
{
|
|
LayerPersistentState layer;
|
|
layer.id = GenerateLayerId();
|
|
layer.shaderId = activeShaderId;
|
|
layer.bypass = false;
|
|
|
|
if (const JsonValue* valuesByShader = root.find("parameterValuesByShader"))
|
|
{
|
|
const JsonValue* shaderValues = valuesByShader->find(activeShaderId);
|
|
if (shaderValues)
|
|
{
|
|
for (const auto& parameterItem : shaderValues->asObject())
|
|
{
|
|
ShaderParameterValue value;
|
|
const JsonValue& jsonValue = parameterItem.second;
|
|
if (jsonValue.isBoolean())
|
|
value.booleanValue = jsonValue.asBoolean();
|
|
else if (jsonValue.isString())
|
|
value.enumValue = jsonValue.asString();
|
|
else if (jsonValue.isNumber())
|
|
value.numberValues.push_back(jsonValue.asNumber());
|
|
else if (jsonValue.isArray())
|
|
value.numberValues = JsonArrayToNumbers(jsonValue);
|
|
layer.parameterValues[parameterItem.first] = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
mPersistentState.layers.push_back(layer);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RuntimeHost::SavePersistentState(std::string& error) const
|
|
{
|
|
JsonValue root = JsonValue::MakeObject();
|
|
|
|
JsonValue layers = JsonValue::MakeArray();
|
|
for (const LayerPersistentState& layer : mPersistentState.layers)
|
|
{
|
|
JsonValue layerValue = JsonValue::MakeObject();
|
|
layerValue.set("id", JsonValue(layer.id));
|
|
layerValue.set("shaderId", JsonValue(layer.shaderId));
|
|
layerValue.set("bypass", JsonValue(layer.bypass));
|
|
|
|
JsonValue parameterValues = JsonValue::MakeObject();
|
|
auto packageIt = mPackagesById.find(layer.shaderId);
|
|
for (const auto& parameterItem : layer.parameterValues)
|
|
{
|
|
const ShaderParameterDefinition* definition = nullptr;
|
|
if (packageIt != mPackagesById.end())
|
|
{
|
|
for (const ShaderParameterDefinition& candidate : packageIt->second.parameters)
|
|
{
|
|
if (candidate.id == parameterItem.first)
|
|
{
|
|
definition = &candidate;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (definition)
|
|
parameterValues.set(parameterItem.first, SerializeParameterValue(*definition, parameterItem.second));
|
|
}
|
|
|
|
layerValue.set("parameterValues", parameterValues);
|
|
layers.pushBack(layerValue);
|
|
}
|
|
root.set("layers", layers);
|
|
|
|
return WriteTextFile(mRuntimeStatePath, SerializeJson(root, true), error);
|
|
}
|
|
|
|
bool RuntimeHost::ScanShaderPackages(std::string& error)
|
|
{
|
|
std::map<std::string, ShaderPackage> packagesById;
|
|
std::vector<std::string> packageOrder;
|
|
ShaderPackageRegistry registry(mConfig.maxTemporalHistoryFrames);
|
|
if (!registry.Scan(mShaderRoot, packagesById, packageOrder, error))
|
|
return false;
|
|
|
|
mPackagesById.swap(packagesById);
|
|
mPackageOrder.swap(packageOrder);
|
|
|
|
for (auto it = mPersistentState.layers.begin(); it != mPersistentState.layers.end();)
|
|
{
|
|
if (mPackagesById.find(it->shaderId) == mPackagesById.end())
|
|
it = mPersistentState.layers.erase(it);
|
|
else
|
|
++it;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RuntimeHost::ParseShaderManifest(const std::filesystem::path& manifestPath, ShaderPackage& shaderPackage, std::string& error) const
|
|
{
|
|
const std::string manifestText = ReadTextFile(manifestPath, error);
|
|
if (manifestText.empty())
|
|
return false;
|
|
|
|
JsonValue manifestJson;
|
|
if (!ParseJson(manifestText, manifestJson, error))
|
|
return false;
|
|
if (!manifestJson.isObject())
|
|
{
|
|
error = "Shader manifest root must be an object: " + manifestPath.string();
|
|
return false;
|
|
}
|
|
|
|
if (!ParseShaderMetadata(manifestJson, shaderPackage, manifestPath, error))
|
|
return false;
|
|
|
|
if (!std::filesystem::exists(shaderPackage.shaderPath))
|
|
{
|
|
error = "Shader source not found for package " + shaderPackage.id + ": " + shaderPackage.shaderPath.string();
|
|
return false;
|
|
}
|
|
|
|
shaderPackage.shaderWriteTime = std::filesystem::last_write_time(shaderPackage.shaderPath);
|
|
shaderPackage.manifestWriteTime = std::filesystem::last_write_time(shaderPackage.manifestPath);
|
|
|
|
return ParseTextureAssets(manifestJson, shaderPackage, manifestPath, error) &&
|
|
ParseTemporalSettings(manifestJson, shaderPackage, mConfig.maxTemporalHistoryFrames, manifestPath, error) &&
|
|
ParseParameterDefinitions(manifestJson, shaderPackage, manifestPath, error);
|
|
}
|
|
|
|
bool RuntimeHost::NormalizeAndValidateValue(const ShaderParameterDefinition& definition, const JsonValue& value, ShaderParameterValue& normalizedValue, std::string& error) const
|
|
{
|
|
return NormalizeAndValidateParameterValue(definition, value, normalizedValue, error);
|
|
}
|
|
|
|
ShaderParameterValue RuntimeHost::DefaultValueForDefinition(const ShaderParameterDefinition& definition) const
|
|
{
|
|
return ::DefaultValueForDefinition(definition);
|
|
}
|
|
|
|
void RuntimeHost::EnsureLayerDefaultsLocked(LayerPersistentState& layerState, const ShaderPackage& shaderPackage) const
|
|
{
|
|
for (const ShaderParameterDefinition& definition : shaderPackage.parameters)
|
|
{
|
|
if (layerState.parameterValues.find(definition.id) == layerState.parameterValues.end())
|
|
layerState.parameterValues[definition.id] = DefaultValueForDefinition(definition);
|
|
}
|
|
}
|
|
|
|
std::string RuntimeHost::ReadTextFile(const std::filesystem::path& path, std::string& error) const
|
|
{
|
|
std::ifstream input(path, std::ios::binary);
|
|
if (!input)
|
|
{
|
|
error = "Could not open file: " + path.string();
|
|
return std::string();
|
|
}
|
|
|
|
std::ostringstream buffer;
|
|
buffer << input.rdbuf();
|
|
return buffer.str();
|
|
}
|
|
|
|
bool RuntimeHost::WriteTextFile(const std::filesystem::path& path, const std::string& contents, std::string& error) const
|
|
{
|
|
std::error_code fsError;
|
|
std::filesystem::create_directories(path.parent_path(), fsError);
|
|
|
|
std::ofstream output(path, std::ios::binary);
|
|
if (!output)
|
|
{
|
|
error = "Could not write file: " + path.string();
|
|
return false;
|
|
}
|
|
|
|
output << contents;
|
|
return output.good();
|
|
}
|
|
|
|
bool RuntimeHost::ResolvePaths(std::string& error)
|
|
{
|
|
mRepoRoot = FindRepoRootCandidate();
|
|
if (mRepoRoot.empty())
|
|
{
|
|
error = "Could not locate the repository root from the current runtime path.";
|
|
return false;
|
|
}
|
|
|
|
const std::filesystem::path builtUiRoot = mRepoRoot / "ui" / "dist";
|
|
mUiRoot = std::filesystem::exists(builtUiRoot) ? builtUiRoot : (mRepoRoot / "ui");
|
|
mDocsRoot = mRepoRoot / "docs";
|
|
mConfigPath = mRepoRoot / "config" / "runtime-host.json";
|
|
mShaderRoot = mRepoRoot / mConfig.shaderLibrary;
|
|
mRuntimeRoot = mRepoRoot / "runtime";
|
|
mPresetRoot = mRuntimeRoot / "stack_presets";
|
|
mRuntimeStatePath = mRuntimeRoot / "runtime_state.json";
|
|
mWrapperPath = mRuntimeRoot / "shader_cache" / "active_shader_wrapper.slang";
|
|
mGeneratedGlslPath = mRuntimeRoot / "shader_cache" / "active_shader.raw.frag";
|
|
mPatchedGlslPath = mRuntimeRoot / "shader_cache" / "active_shader.frag";
|
|
|
|
std::error_code fsError;
|
|
std::filesystem::create_directories(mRuntimeRoot / "shader_cache", fsError);
|
|
std::filesystem::create_directories(mPresetRoot, fsError);
|
|
return true;
|
|
}
|
|
|
|
JsonValue RuntimeHost::BuildStateValue() const
|
|
{
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
|
|
JsonValue root = JsonValue::MakeObject();
|
|
|
|
JsonValue app = JsonValue::MakeObject();
|
|
app.set("serverPort", JsonValue(static_cast<double>(mServerPort)));
|
|
app.set("oscPort", JsonValue(static_cast<double>(mConfig.oscPort)));
|
|
app.set("autoReload", JsonValue(mAutoReloadEnabled));
|
|
app.set("maxTemporalHistoryFrames", JsonValue(static_cast<double>(mConfig.maxTemporalHistoryFrames)));
|
|
app.set("enableExternalKeying", JsonValue(mConfig.enableExternalKeying));
|
|
app.set("audioEnabled", JsonValue(mConfig.audioEnabled));
|
|
app.set("audioOutputEnabled", JsonValue(mConfig.audioOutputEnabled));
|
|
app.set("audioScheduleEnabled", JsonValue(mConfig.audioScheduleEnabled));
|
|
app.set("audioPrerollEnabled", JsonValue(mConfig.audioPrerollEnabled));
|
|
app.set("audioScheduleSilence", JsonValue(mConfig.audioScheduleSilence));
|
|
app.set("audioScheduleTone", JsonValue(mConfig.audioScheduleTone));
|
|
app.set("audioChannelCount", JsonValue(static_cast<double>(mConfig.audioChannelCount)));
|
|
app.set("audioSampleRate", JsonValue(static_cast<double>(mConfig.audioSampleRate)));
|
|
app.set("audioDelayMode", JsonValue(mConfig.audioDelayMode));
|
|
app.set("inputVideoFormat", JsonValue(mConfig.inputVideoFormat));
|
|
app.set("inputFrameRate", JsonValue(mConfig.inputFrameRate));
|
|
app.set("outputVideoFormat", JsonValue(mConfig.outputVideoFormat));
|
|
app.set("outputFrameRate", JsonValue(mConfig.outputFrameRate));
|
|
root.set("app", app);
|
|
|
|
JsonValue runtime = JsonValue::MakeObject();
|
|
runtime.set("layerCount", JsonValue(static_cast<double>(mPersistentState.layers.size())));
|
|
runtime.set("compileSucceeded", JsonValue(mCompileSucceeded));
|
|
runtime.set("compileMessage", JsonValue(mCompileMessage));
|
|
root.set("runtime", runtime);
|
|
|
|
JsonValue video = JsonValue::MakeObject();
|
|
video.set("hasSignal", JsonValue(mHasSignal));
|
|
video.set("width", JsonValue(static_cast<double>(mSignalWidth)));
|
|
video.set("height", JsonValue(static_cast<double>(mSignalHeight)));
|
|
video.set("modeName", JsonValue(mSignalModeName));
|
|
root.set("video", video);
|
|
|
|
JsonValue audio = JsonValue::MakeObject();
|
|
audio.set("enabled", JsonValue(mAudioStatus.enabled));
|
|
audio.set("bufferedSampleFrames", JsonValue(static_cast<double>(mAudioStatus.bufferedSampleFrames)));
|
|
audio.set("underrunCount", JsonValue(static_cast<double>(mAudioStatus.underrunCount)));
|
|
JsonValue rms = JsonValue::MakeArray();
|
|
rms.pushBack(JsonValue(static_cast<double>(mAudioStatus.analysis.rms[0])));
|
|
rms.pushBack(JsonValue(static_cast<double>(mAudioStatus.analysis.rms[1])));
|
|
audio.set("rms", rms);
|
|
JsonValue peak = JsonValue::MakeArray();
|
|
peak.pushBack(JsonValue(static_cast<double>(mAudioStatus.analysis.peak[0])));
|
|
peak.pushBack(JsonValue(static_cast<double>(mAudioStatus.analysis.peak[1])));
|
|
audio.set("peak", peak);
|
|
audio.set("monoRms", JsonValue(static_cast<double>(mAudioStatus.analysis.monoRms)));
|
|
audio.set("monoPeak", JsonValue(static_cast<double>(mAudioStatus.analysis.monoPeak)));
|
|
JsonValue bands = JsonValue::MakeArray();
|
|
for (float band : mAudioStatus.analysis.bands)
|
|
bands.pushBack(JsonValue(static_cast<double>(band)));
|
|
audio.set("bands", bands);
|
|
root.set("audio", audio);
|
|
|
|
JsonValue deckLink = JsonValue::MakeObject();
|
|
deckLink.set("modelName", JsonValue(mDeckLinkOutputStatus.modelName));
|
|
deckLink.set("supportsInternalKeying", JsonValue(mDeckLinkOutputStatus.supportsInternalKeying));
|
|
deckLink.set("supportsExternalKeying", JsonValue(mDeckLinkOutputStatus.supportsExternalKeying));
|
|
deckLink.set("keyerInterfaceAvailable", JsonValue(mDeckLinkOutputStatus.keyerInterfaceAvailable));
|
|
deckLink.set("externalKeyingRequested", JsonValue(mDeckLinkOutputStatus.externalKeyingRequested));
|
|
deckLink.set("externalKeyingActive", JsonValue(mDeckLinkOutputStatus.externalKeyingActive));
|
|
deckLink.set("statusMessage", JsonValue(mDeckLinkOutputStatus.statusMessage));
|
|
root.set("decklink", deckLink);
|
|
|
|
JsonValue performance = JsonValue::MakeObject();
|
|
performance.set("frameBudgetMs", JsonValue(mFrameBudgetMilliseconds));
|
|
performance.set("renderMs", JsonValue(mRenderMilliseconds));
|
|
performance.set("smoothedRenderMs", JsonValue(mSmoothedRenderMilliseconds));
|
|
performance.set("budgetUsedPercent", JsonValue(mFrameBudgetMilliseconds > 0.0 ? (mSmoothedRenderMilliseconds / mFrameBudgetMilliseconds) * 100.0 : 0.0));
|
|
root.set("performance", performance);
|
|
|
|
JsonValue shaderLibrary = JsonValue::MakeArray();
|
|
for (const std::string& shaderId : mPackageOrder)
|
|
{
|
|
auto shaderIt = mPackagesById.find(shaderId);
|
|
if (shaderIt == mPackagesById.end())
|
|
continue;
|
|
|
|
JsonValue shader = JsonValue::MakeObject();
|
|
shader.set("id", JsonValue(shaderIt->second.id));
|
|
shader.set("name", JsonValue(shaderIt->second.displayName));
|
|
shader.set("description", JsonValue(shaderIt->second.description));
|
|
shader.set("category", JsonValue(shaderIt->second.category));
|
|
if (shaderIt->second.temporal.enabled)
|
|
{
|
|
JsonValue temporal = JsonValue::MakeObject();
|
|
temporal.set("enabled", JsonValue(true));
|
|
temporal.set("historySource", JsonValue(TemporalHistorySourceToString(shaderIt->second.temporal.historySource)));
|
|
temporal.set("requestedHistoryLength", JsonValue(static_cast<double>(shaderIt->second.temporal.requestedHistoryLength)));
|
|
temporal.set("effectiveHistoryLength", JsonValue(static_cast<double>(shaderIt->second.temporal.effectiveHistoryLength)));
|
|
shader.set("temporal", temporal);
|
|
}
|
|
shaderLibrary.pushBack(shader);
|
|
}
|
|
root.set("shaders", shaderLibrary);
|
|
|
|
JsonValue stackPresets = JsonValue::MakeArray();
|
|
for (const std::string& presetName : GetStackPresetNamesLocked())
|
|
stackPresets.pushBack(JsonValue(presetName));
|
|
root.set("stackPresets", stackPresets);
|
|
|
|
root.set("layers", SerializeLayerStackLocked());
|
|
|
|
return root;
|
|
}
|
|
|
|
JsonValue RuntimeHost::SerializeLayerStackLocked() const
|
|
{
|
|
JsonValue layers = JsonValue::MakeArray();
|
|
for (const LayerPersistentState& layer : mPersistentState.layers)
|
|
{
|
|
auto shaderIt = mPackagesById.find(layer.shaderId);
|
|
if (shaderIt == mPackagesById.end())
|
|
continue;
|
|
|
|
JsonValue layerValue = JsonValue::MakeObject();
|
|
layerValue.set("id", JsonValue(layer.id));
|
|
layerValue.set("shaderId", JsonValue(layer.shaderId));
|
|
layerValue.set("shaderName", JsonValue(shaderIt->second.displayName));
|
|
layerValue.set("bypass", JsonValue(layer.bypass));
|
|
if (shaderIt->second.temporal.enabled)
|
|
{
|
|
JsonValue temporal = JsonValue::MakeObject();
|
|
temporal.set("enabled", JsonValue(true));
|
|
temporal.set("historySource", JsonValue(TemporalHistorySourceToString(shaderIt->second.temporal.historySource)));
|
|
temporal.set("requestedHistoryLength", JsonValue(static_cast<double>(shaderIt->second.temporal.requestedHistoryLength)));
|
|
temporal.set("effectiveHistoryLength", JsonValue(static_cast<double>(shaderIt->second.temporal.effectiveHistoryLength)));
|
|
layerValue.set("temporal", temporal);
|
|
}
|
|
|
|
JsonValue parameters = JsonValue::MakeArray();
|
|
for (const ShaderParameterDefinition& definition : shaderIt->second.parameters)
|
|
{
|
|
JsonValue parameter = JsonValue::MakeObject();
|
|
parameter.set("id", JsonValue(definition.id));
|
|
parameter.set("label", JsonValue(definition.label));
|
|
parameter.set("type", JsonValue(ShaderParameterTypeToString(definition.type)));
|
|
|
|
if (!definition.minNumbers.empty())
|
|
{
|
|
JsonValue minValue = JsonValue::MakeArray();
|
|
for (double number : definition.minNumbers)
|
|
minValue.pushBack(JsonValue(number));
|
|
parameter.set("min", minValue);
|
|
}
|
|
if (!definition.maxNumbers.empty())
|
|
{
|
|
JsonValue maxValue = JsonValue::MakeArray();
|
|
for (double number : definition.maxNumbers)
|
|
maxValue.pushBack(JsonValue(number));
|
|
parameter.set("max", maxValue);
|
|
}
|
|
if (!definition.stepNumbers.empty())
|
|
{
|
|
JsonValue stepValue = JsonValue::MakeArray();
|
|
for (double number : definition.stepNumbers)
|
|
stepValue.pushBack(JsonValue(number));
|
|
parameter.set("step", stepValue);
|
|
}
|
|
if (definition.type == ShaderParameterType::Enum)
|
|
{
|
|
JsonValue options = JsonValue::MakeArray();
|
|
for (const ShaderParameterOption& option : definition.enumOptions)
|
|
{
|
|
JsonValue optionValue = JsonValue::MakeObject();
|
|
optionValue.set("value", JsonValue(option.value));
|
|
optionValue.set("label", JsonValue(option.label));
|
|
options.pushBack(optionValue);
|
|
}
|
|
parameter.set("options", options);
|
|
}
|
|
|
|
ShaderParameterValue value = DefaultValueForDefinition(definition);
|
|
auto valueIt = layer.parameterValues.find(definition.id);
|
|
if (valueIt != layer.parameterValues.end())
|
|
value = valueIt->second;
|
|
parameter.set("value", SerializeParameterValue(definition, value));
|
|
parameters.pushBack(parameter);
|
|
}
|
|
|
|
layerValue.set("parameters", parameters);
|
|
layers.pushBack(layerValue);
|
|
}
|
|
return layers;
|
|
}
|
|
|
|
bool RuntimeHost::DeserializeLayerStackLocked(const JsonValue& layersValue, std::vector<LayerPersistentState>& layers, std::string& error)
|
|
{
|
|
for (const JsonValue& layerValue : layersValue.asArray())
|
|
{
|
|
if (!layerValue.isObject())
|
|
continue;
|
|
|
|
const JsonValue* shaderIdValue = layerValue.find("shaderId");
|
|
if (!shaderIdValue)
|
|
continue;
|
|
|
|
const std::string shaderId = shaderIdValue->asString();
|
|
auto shaderIt = mPackagesById.find(shaderId);
|
|
if (shaderIt == mPackagesById.end())
|
|
{
|
|
error = "Preset references unknown shader id: " + shaderId;
|
|
return false;
|
|
}
|
|
|
|
LayerPersistentState layer;
|
|
layer.id = GenerateLayerId();
|
|
layer.shaderId = shaderId;
|
|
if (const JsonValue* bypassValue = layerValue.find("bypass"))
|
|
layer.bypass = bypassValue->asBoolean(false);
|
|
|
|
if (const JsonValue* parametersValue = layerValue.find("parameters"))
|
|
{
|
|
for (const JsonValue& parameterValue : parametersValue->asArray())
|
|
{
|
|
if (!parameterValue.isObject())
|
|
continue;
|
|
|
|
const JsonValue* parameterIdValue = parameterValue.find("id");
|
|
const JsonValue* valueValue = parameterValue.find("value");
|
|
if (!parameterIdValue || !valueValue)
|
|
continue;
|
|
|
|
const std::string parameterId = parameterIdValue->asString();
|
|
auto definitionIt = std::find_if(shaderIt->second.parameters.begin(), shaderIt->second.parameters.end(),
|
|
[¶meterId](const ShaderParameterDefinition& definition) { return definition.id == parameterId; });
|
|
if (definitionIt == shaderIt->second.parameters.end())
|
|
continue;
|
|
|
|
ShaderParameterValue normalizedValue;
|
|
if (!NormalizeAndValidateValue(*definitionIt, *valueValue, normalizedValue, error))
|
|
return false;
|
|
|
|
layer.parameterValues[parameterId] = normalizedValue;
|
|
}
|
|
}
|
|
|
|
EnsureLayerDefaultsLocked(layer, shaderIt->second);
|
|
layers.push_back(layer);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
std::vector<std::string> RuntimeHost::GetStackPresetNamesLocked() const
|
|
{
|
|
std::vector<std::string> presetNames;
|
|
std::error_code fsError;
|
|
if (!std::filesystem::exists(mPresetRoot, fsError))
|
|
return presetNames;
|
|
|
|
for (const auto& entry : std::filesystem::directory_iterator(mPresetRoot, fsError))
|
|
{
|
|
if (!entry.is_regular_file())
|
|
continue;
|
|
if (ToLowerCopy(entry.path().extension().string()) != ".json")
|
|
continue;
|
|
presetNames.push_back(entry.path().stem().string());
|
|
}
|
|
|
|
std::sort(presetNames.begin(), presetNames.end());
|
|
return presetNames;
|
|
}
|
|
|
|
std::string RuntimeHost::MakeSafePresetFileStem(const std::string& presetName) const
|
|
{
|
|
return ::MakeSafePresetFileStem(presetName);
|
|
}
|
|
|
|
JsonValue RuntimeHost::SerializeParameterValue(const ShaderParameterDefinition& definition, const ShaderParameterValue& value) const
|
|
{
|
|
switch (definition.type)
|
|
{
|
|
case ShaderParameterType::Boolean:
|
|
return JsonValue(value.booleanValue);
|
|
case ShaderParameterType::Enum:
|
|
return JsonValue(value.enumValue);
|
|
case ShaderParameterType::Float:
|
|
return JsonValue(value.numberValues.empty() ? 0.0 : value.numberValues.front());
|
|
case ShaderParameterType::Vec2:
|
|
case ShaderParameterType::Color:
|
|
{
|
|
JsonValue array = JsonValue::MakeArray();
|
|
for (double number : value.numberValues)
|
|
array.pushBack(JsonValue(number));
|
|
return array;
|
|
}
|
|
}
|
|
return JsonValue();
|
|
}
|
|
|
|
std::string RuntimeHost::TemporalHistorySourceToString(TemporalHistorySource source) const
|
|
{
|
|
switch (source)
|
|
{
|
|
case TemporalHistorySource::Source:
|
|
return "source";
|
|
case TemporalHistorySource::PreLayerInput:
|
|
return "preLayerInput";
|
|
case TemporalHistorySource::None:
|
|
default:
|
|
return "none";
|
|
}
|
|
}
|
|
|
|
RuntimeHost::LayerPersistentState* RuntimeHost::FindLayerById(const std::string& layerId)
|
|
{
|
|
auto it = std::find_if(mPersistentState.layers.begin(), mPersistentState.layers.end(),
|
|
[&layerId](const LayerPersistentState& layer) { return layer.id == layerId; });
|
|
return it == mPersistentState.layers.end() ? nullptr : &*it;
|
|
}
|
|
|
|
const RuntimeHost::LayerPersistentState* RuntimeHost::FindLayerById(const std::string& layerId) const
|
|
{
|
|
auto it = std::find_if(mPersistentState.layers.begin(), mPersistentState.layers.end(),
|
|
[&layerId](const LayerPersistentState& layer) { return layer.id == layerId; });
|
|
return it == mPersistentState.layers.end() ? nullptr : &*it;
|
|
}
|
|
|
|
std::string RuntimeHost::GenerateLayerId()
|
|
{
|
|
while (true)
|
|
{
|
|
++mNextLayerId;
|
|
const std::string candidate = "layer-" + std::to_string(mNextLayerId);
|
|
if (!FindLayerById(candidate))
|
|
return candidate;
|
|
}
|
|
}
|