aiden/video-shader-toys
1
0
Fork 0
Code Issues Pull Requests Actions Releases 5 Wiki Activity

end point adjsutments
Some checks failed
CI / React UI Build (push) Successful in 11s
Details
CI / Windows Release Package (push) Has been cancelled
Details
CI / Native Windows Build And Tests (push) Has been cancelled
Details

Browse Source
This commit is contained in:
Aiden
2026-05-12 13:50:32 +10:00
parent b44504500a
commit 430cf0733d
11 changed files with 773 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

184
apps/RenderCadenceCompositor/control/RuntimeStateJson.h
View File

@@ -3,10 +3,12 @@
#include "../app/AppConfig.h"
#include "../app/AppConfigProvider.h"
#include "../json/JsonWriter.h"
#include "../runtime/SupportedShaderCatalog.h"
#include "../telemetry/CadenceTelemetryJson.h"
#include <cstdint>
#include <string>
#include <vector>
namespace RenderCadenceCompositor
{
@@ -17,6 +19,10 @@ struct RuntimeStateJsonInput
unsigned short serverPort = 0;
bool videoOutputEnabled = false;
std::string videoOutputStatus;
const std::vector<SupportedShaderSummary>& shaders;
bool runtimeCompileSucceeded = true;
std::string runtimeCompileMessage;
const ShaderPackage* activeShaderPackage = nullptr;
};
inline void WriteVideoIoStatusJson(JsonWriter& writer, const RuntimeStateJsonInput& input)
@@ -33,6 +39,153 @@ inline void WriteVideoIoStatusJson(JsonWriter& writer, const RuntimeStateJsonInp
writer.EndObject();
}
inline void OutputDimensions(const RuntimeStateJsonInput& input, unsigned& width, unsigned& height)
{
VideoFormatDimensions(input.config.outputVideoFormat, width, height);
}
inline const char* ShaderParameterTypeName(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";
case ShaderParameterType::Text: return "text";
case ShaderParameterType::Trigger: return "trigger";
}
return "unknown";
}
inline void WriteNumberArray(JsonWriter& writer, const std::vector<double>& values)
{
writer.BeginArray();
for (double value : values)
writer.Double(value);
writer.EndArray();
}
inline void WriteDefaultParameterValue(JsonWriter& writer, const ShaderParameterDefinition& parameter)
{
switch (parameter.type)
{
case ShaderParameterType::Boolean:
writer.Bool(parameter.defaultBoolean);
return;
case ShaderParameterType::Enum:
writer.String(parameter.defaultEnumValue);
return;
case ShaderParameterType::Text:
writer.String(parameter.defaultTextValue);
return;
case ShaderParameterType::Trigger:
writer.Double(0.0);
return;
case ShaderParameterType::Float:
writer.Double(parameter.defaultNumbers.empty() ? 0.0 : parameter.defaultNumbers.front());
return;
case ShaderParameterType::Vec2:
case ShaderParameterType::Color:
WriteNumberArray(writer, parameter.defaultNumbers);
return;
}
writer.Null();
}
inline void WriteTemporalJson(JsonWriter& writer, const TemporalSettings& temporal)
{
writer.BeginObject();
writer.KeyBool("enabled", temporal.enabled);
writer.KeyString("historySource", "none");
writer.KeyUInt("requestedHistoryLength", temporal.requestedHistoryLength);
writer.KeyUInt("effectiveHistoryLength", temporal.effectiveHistoryLength);
writer.EndObject();
}
inline void WriteFeedbackJson(JsonWriter& writer, const FeedbackSettings& feedback)
{
writer.BeginObject();
writer.KeyBool("enabled", feedback.enabled);
writer.KeyString("writePass", feedback.writePassId);
writer.EndObject();
}
inline void WriteParameterDefinitionJson(JsonWriter& writer, const ShaderParameterDefinition& parameter)
{
writer.BeginObject();
writer.KeyString("id", parameter.id);
writer.KeyString("label", parameter.label.empty() ? parameter.id : parameter.label);
writer.KeyString("description", parameter.description);
writer.KeyString("type", ShaderParameterTypeName(parameter.type));
writer.Key("defaultValue");
WriteDefaultParameterValue(writer, parameter);
writer.Key("value");
WriteDefaultParameterValue(writer, parameter);
if (!parameter.minNumbers.empty())
{
writer.Key("min");
WriteNumberArray(writer, parameter.minNumbers);
}
if (!parameter.maxNumbers.empty())
{
writer.Key("max");
WriteNumberArray(writer, parameter.maxNumbers);
}
if (!parameter.stepNumbers.empty())
{
writer.Key("step");
WriteNumberArray(writer, parameter.stepNumbers);
}
if (parameter.type == ShaderParameterType::Enum)
{
writer.Key("options");
writer.BeginArray();
for (const ShaderParameterOption& option : parameter.enumOptions)
{
writer.BeginObject();
writer.KeyString("value", option.value);
writer.KeyString("label", option.label.empty() ? option.value : option.label);
writer.EndObject();
}
writer.EndArray();
}
if (parameter.type == ShaderParameterType::Text)
{
writer.KeyUInt("maxLength", parameter.maxLength);
if (!parameter.fontId.empty())
writer.KeyString("font", parameter.fontId);
}
writer.EndObject();
}
inline void WriteLayersJson(JsonWriter& writer, const RuntimeStateJsonInput& input)
{
writer.BeginArray();
if (input.activeShaderPackage)
{
const ShaderPackage& shaderPackage = *input.activeShaderPackage;
writer.BeginObject();
writer.KeyString("id", "runtime-layer-1");
writer.KeyString("shaderId", shaderPackage.id);
writer.KeyString("shaderName", shaderPackage.displayName.empty() ? shaderPackage.id : shaderPackage.displayName);
writer.KeyBool("bypass", false);
writer.Key("temporal");
WriteTemporalJson(writer, shaderPackage.temporal);
writer.Key("feedback");
WriteFeedbackJson(writer, shaderPackage.feedback);
writer.Key("parameters");
writer.BeginArray();
for (const ShaderParameterDefinition& parameter : shaderPackage.parameters)
WriteParameterDefinitionJson(writer, parameter);
writer.EndArray();
writer.EndObject();
}
writer.EndArray();
}
inline std::string RuntimeStateToJson(const RuntimeStateJsonInput& input)
{
JsonWriter writer;
@@ -56,17 +209,20 @@ inline std::string RuntimeStateToJson(const RuntimeStateJsonInput& input)
writer.Key("runtime");
writer.BeginObject();
writer.KeyUInt("layerCount", 0);
writer.KeyBool("compileSucceeded", true);
writer.KeyString("compileMessage", "Runtime state is not ported into RenderCadenceCompositor yet.");
writer.KeyUInt("layerCount", input.activeShaderPackage ? 1 : 0);
writer.KeyBool("compileSucceeded", input.runtimeCompileSucceeded);
writer.KeyString("compileMessage", input.runtimeCompileMessage);
writer.EndObject();
writer.Key("video");
writer.BeginObject();
writer.KeyBool("hasSignal", false);
writer.KeyNull("width");
writer.KeyNull("height");
writer.KeyString("modeName", "output-only");
unsigned outputWidth = 0;
unsigned outputHeight = 0;
OutputDimensions(input, outputWidth, outputHeight);
writer.KeyBool("hasSignal", input.videoOutputEnabled);
writer.KeyUInt("width", outputWidth);
writer.KeyUInt("height", outputHeight);
writer.KeyString("modeName", input.config.outputVideoFormat + " output-only");
writer.EndObject();
writer.Key("decklink");
@@ -94,13 +250,23 @@ inline std::string RuntimeStateToJson(const RuntimeStateJsonInput& input)
writer.KeyNull("runtimeEvents");
writer.Key("shaders");
writer.BeginArray();
for (const SupportedShaderSummary& shader : input.shaders)
{
writer.BeginObject();
writer.KeyString("id", shader.id);
writer.KeyString("name", shader.name);
writer.KeyString("description", shader.description);
writer.KeyString("category", shader.category);
writer.KeyBool("available", true);
writer.KeyNull("error");
writer.EndObject();
}
writer.EndArray();
writer.Key("stackPresets");
writer.BeginArray();
writer.EndArray();
writer.Key("layers");
writer.BeginArray();
writer.EndArray();
WriteLayersJson(writer, input);
writer.EndObject();
return writer.StringValue();