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

phase 1 runtime complete
All checks were successful
CI / React UI Build (push) Successful in 11s
Details
CI / Native Windows Build And Tests (push) Successful in 2m46s
Details
CI / Windows Release Package (push) Successful in 2m59s
Details

Browse Source
This commit is contained in:
Aiden
2026-05-11 02:23:01 +10:00
parent cbf1b541dc
commit 9cbb5d8004
20 changed files with 265 additions and 1288 deletions
Download Patch File Download Diff File Expand all files Collapse all files

85
apps/LoopThroughWithOpenGLCompositing/runtime/snapshot/RenderSnapshotBuilder.cpp
View File

@@ -24,19 +24,14 @@ bool RenderSnapshotBuilder::BuildLayerPassFragmentShaderSources(const std::strin
if (!mRuntimeStore.CopyShaderPackageForStoredLayer(layerId, shaderPackage, error))
return false;
std::filesystem::path repoRoot;
std::filesystem::path wrapperPath;
std::filesystem::path generatedGlslPath;
std::filesystem::path patchedGlslPath;
unsigned maxTemporalHistoryFrames = 0;
mRuntimeStore.GetShaderCompilerInputs(repoRoot, wrapperPath, generatedGlslPath, patchedGlslPath, maxTemporalHistoryFrames);
const ShaderCompilerInputs inputs = mRuntimeStore.GetShaderCompilerInputs();
ShaderCompiler compiler(
repoRoot,
wrapperPath,
generatedGlslPath,
patchedGlslPath,
maxTemporalHistoryFrames);
inputs.repoRoot,
inputs.wrapperPath,
inputs.generatedGlslPath,
inputs.patchedGlslPath,
inputs.maxTemporalHistoryFrames);
passSources.clear();
passSources.reserve(shaderPackage.passes.size());
for (const ShaderPassDefinition& pass : shaderPackage.passes)
@@ -83,34 +78,24 @@ void RenderSnapshotBuilder::AdvanceFrame()
void RenderSnapshotBuilder::BuildLayerRenderStates(unsigned outputWidth, unsigned outputHeight, std::vector<RuntimeRenderState>& states) const
{
std::lock_guard<std::mutex> lock(mRuntimeStore.mMutex);
BuildLayerRenderStatesLocked(outputWidth, outputHeight, states);
BuildLayerRenderStates(outputWidth, outputHeight, mRuntimeStore.BuildRenderSnapshotReadModel(), states);
}
bool RenderSnapshotBuilder::TryBuildLayerRenderStates(unsigned outputWidth, unsigned outputHeight, std::vector<RuntimeRenderState>& states) const
{
std::unique_lock<std::mutex> lock(mRuntimeStore.mMutex, std::try_to_lock);
if (!lock.owns_lock())
return false;
BuildLayerRenderStatesLocked(outputWidth, outputHeight, states);
BuildLayerRenderStates(outputWidth, outputHeight, mRuntimeStore.BuildRenderSnapshotReadModel(), states);
return true;
}
bool RenderSnapshotBuilder::TryRefreshLayerParameters(std::vector<RuntimeRenderState>& states) const
{
std::unique_lock<std::mutex> lock(mRuntimeStore.mMutex, std::try_to_lock);
if (!lock.owns_lock())
return false;
RefreshLayerParametersLocked(states);
RefreshLayerParameters(mRuntimeStore.CopyLayerStates(), states);
return true;
}
void RenderSnapshotBuilder::RefreshDynamicRenderStateFields(std::vector<RuntimeRenderState>& states) const
{
std::lock_guard<std::mutex> lock(mRuntimeStore.mMutex);
RefreshDynamicRenderStateFieldsLocked(states);
RefreshDynamicRenderStateFields(mRuntimeStore.GetRenderTimingSnapshot(), states);
}
void RenderSnapshotBuilder::MarkRenderStateDirty()
@@ -124,37 +109,37 @@ void RenderSnapshotBuilder::MarkParameterStateDirty()
mParameterStateVersion.fetch_add(1, std::memory_order_relaxed);
}
void RenderSnapshotBuilder::BuildLayerRenderStatesLocked(unsigned outputWidth, unsigned outputHeight, std::vector<RuntimeRenderState>& states) const
void RenderSnapshotBuilder::BuildLayerRenderStates(unsigned outputWidth, unsigned outputHeight, const RenderSnapshotReadModel& readModel, std::vector<RuntimeRenderState>& states) const
{
states.clear();
const HealthTelemetry::SignalStatusSnapshot signalStatus = mRuntimeStore.mHealthTelemetry.GetSignalStatusSnapshot();
for (const RuntimeStore::LayerPersistentState& layer : mRuntimeStore.mLayerStack.Layers())
for (const LayerStackStore::LayerPersistentState& layer : readModel.layers)
{
const ShaderPackage* shaderPackage = mRuntimeStore.mShaderCatalog.FindPackage(layer.shaderId);
if (!shaderPackage)
auto shaderIt = readModel.packagesById.find(layer.shaderId);
if (shaderIt == readModel.packagesById.end())
continue;
const ShaderPackage& shaderPackage = shaderIt->second;
RuntimeRenderState state;
state.layerId = layer.id;
state.shaderId = layer.shaderId;
state.shaderName = shaderPackage->displayName;
state.shaderName = shaderPackage.displayName;
state.mixAmount = 1.0;
state.bypass = layer.bypass ? 1.0 : 0.0;
state.inputWidth = signalStatus.width;
state.inputHeight = signalStatus.height;
state.inputWidth = readModel.signalStatus.width;
state.inputHeight = readModel.signalStatus.height;
state.outputWidth = outputWidth;
state.outputHeight = outputHeight;
state.parameterDefinitions = shaderPackage->parameters;
state.textureAssets = shaderPackage->textureAssets;
state.fontAssets = shaderPackage->fontAssets;
state.isTemporal = shaderPackage->temporal.enabled;
state.temporalHistorySource = shaderPackage->temporal.historySource;
state.requestedTemporalHistoryLength = shaderPackage->temporal.requestedHistoryLength;
state.effectiveTemporalHistoryLength = shaderPackage->temporal.effectiveHistoryLength;
state.feedback = shaderPackage->feedback;
state.parameterDefinitions = shaderPackage.parameters;
state.textureAssets = shaderPackage.textureAssets;
state.fontAssets = shaderPackage.fontAssets;
state.isTemporal = shaderPackage.temporal.enabled;
state.temporalHistorySource = shaderPackage.temporal.historySource;
state.requestedTemporalHistoryLength = shaderPackage.temporal.requestedHistoryLength;
state.effectiveTemporalHistoryLength = shaderPackage.temporal.effectiveHistoryLength;
state.feedback = shaderPackage.feedback;
for (const ShaderParameterDefinition& definition : shaderPackage->parameters)
for (const ShaderParameterDefinition& definition : shaderPackage.parameters)
{
ShaderParameterValue value = DefaultValueForDefinition(definition);
auto valueIt = layer.parameterValues.find(definition.id);
@@ -166,16 +151,16 @@ void RenderSnapshotBuilder::BuildLayerRenderStatesLocked(unsigned outputWidth, u
states.push_back(state);
}
RefreshDynamicRenderStateFieldsLocked(states);
RefreshDynamicRenderStateFields(readModel.timing, states);
}
void RenderSnapshotBuilder::RefreshLayerParametersLocked(std::vector<RuntimeRenderState>& states) const
void RenderSnapshotBuilder::RefreshLayerParameters(const std::vector<LayerStackStore::LayerPersistentState>& layers, std::vector<RuntimeRenderState>& states) const
{
for (RuntimeRenderState& state : states)
{
const auto layerIt = std::find_if(mRuntimeStore.mLayerStack.Layers().begin(), mRuntimeStore.mLayerStack.Layers().end(),
[&state](const RuntimeStore::LayerPersistentState& layer) { return layer.id == state.layerId; });
if (layerIt == mRuntimeStore.mLayerStack.Layers().end())
const auto layerIt = std::find_if(layers.begin(), layers.end(),
[&state](const LayerStackStore::LayerPersistentState& layer) { return layer.id == state.layerId; });
if (layerIt == layers.end())
continue;
state.bypass = layerIt->bypass ? 1.0 : 0.0;
@@ -191,10 +176,10 @@ void RenderSnapshotBuilder::RefreshLayerParametersLocked(std::vector<RuntimeRend
}
}
void RenderSnapshotBuilder::RefreshDynamicRenderStateFieldsLocked(std::vector<RuntimeRenderState>& states) const
void RenderSnapshotBuilder::RefreshDynamicRenderStateFields(const RenderTimingSnapshot& timing, std::vector<RuntimeRenderState>& states) const
{
const RuntimeClockSnapshot clock = GetRuntimeClockSnapshot();
const double timeSeconds = std::chrono::duration_cast<std::chrono::duration<double>>(std::chrono::steady_clock::now() - mRuntimeStore.mStartTime).count();
const double timeSeconds = std::chrono::duration_cast<std::chrono::duration<double>>(std::chrono::steady_clock::now() - timing.startTime).count();
const double frameCount = static_cast<double>(mFrameCounter.load(std::memory_order_relaxed));
for (RuntimeRenderState& state : states)
@@ -202,7 +187,7 @@ void RenderSnapshotBuilder::RefreshDynamicRenderStateFieldsLocked(std::vector<Ru
state.timeSeconds = timeSeconds;
state.utcTimeSeconds = clock.utcTimeSeconds;
state.utcOffsetSeconds = clock.utcOffsetSeconds;
state.startupRandom = mRuntimeStore.mStartupRandom;
state.startupRandom = timing.startupRandom;
state.frameCount = frameCount;
}
}