126 lines
3.5 KiB
C++
126 lines
3.5 KiB
C++
#include "RuntimeUpdateController.h"
|
|
|
|
#include "RenderEngine.h"
|
|
#include "RuntimeEventDispatcher.h"
|
|
#include "RuntimeServices.h"
|
|
#include "RuntimeStore.h"
|
|
#include "ShaderBuildQueue.h"
|
|
#include "VideoBackend.h"
|
|
|
|
#include <vector>
|
|
|
|
RuntimeUpdateController::RuntimeUpdateController(
|
|
RuntimeStore& runtimeStore,
|
|
RuntimeCoordinator& runtimeCoordinator,
|
|
RuntimeEventDispatcher& runtimeEventDispatcher,
|
|
RuntimeServices& runtimeServices,
|
|
RenderEngine& renderEngine,
|
|
ShaderBuildQueue& shaderBuildQueue,
|
|
VideoBackend& videoBackend) :
|
|
mRuntimeStore(runtimeStore),
|
|
mRuntimeCoordinator(runtimeCoordinator),
|
|
mRuntimeEventDispatcher(runtimeEventDispatcher),
|
|
mRuntimeServices(runtimeServices),
|
|
mRenderEngine(renderEngine),
|
|
mShaderBuildQueue(shaderBuildQueue),
|
|
mVideoBackend(videoBackend)
|
|
{
|
|
mRuntimeEventDispatcher.Subscribe(
|
|
RuntimeEventType::RuntimeStateBroadcastRequested,
|
|
[this](const RuntimeEvent& event) { HandleRuntimeStateBroadcastRequested(event); });
|
|
}
|
|
|
|
bool RuntimeUpdateController::ApplyRuntimeCoordinatorResult(const RuntimeCoordinatorResult& result, std::string* error)
|
|
{
|
|
if (!result.accepted)
|
|
{
|
|
if (error)
|
|
*error = result.errorMessage;
|
|
return false;
|
|
}
|
|
|
|
if (result.compileStatusChanged)
|
|
mRuntimeStore.SetCompileStatus(result.compileStatusSucceeded, result.compileStatusMessage);
|
|
|
|
if (result.clearReloadRequest)
|
|
mRuntimeStore.ClearReloadRequest();
|
|
|
|
mRuntimeCoordinator.ApplyCommittedStateMode(result.committedStateMode);
|
|
|
|
if (result.clearTransientOscState)
|
|
{
|
|
mRenderEngine.ClearOscOverlayState();
|
|
mRuntimeServices.ClearOscState();
|
|
}
|
|
|
|
mRenderEngine.ApplyRuntimeCoordinatorRenderReset(result.renderResetScope);
|
|
|
|
if (result.shaderBuildRequested)
|
|
RequestShaderBuild();
|
|
|
|
if (result.runtimeStateBroadcastRequired)
|
|
BroadcastRuntimeState();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RuntimeUpdateController::ProcessRuntimeWork()
|
|
{
|
|
mRuntimeEventDispatcher.DispatchPending();
|
|
|
|
bool shaderBuildRequested = false;
|
|
std::vector<RuntimeCoordinatorServiceResult> serviceResults;
|
|
mRuntimeServices.ConsumeRuntimeCoordinatorResults(serviceResults);
|
|
for (const RuntimeCoordinatorServiceResult& serviceResult : serviceResults)
|
|
{
|
|
shaderBuildRequested = shaderBuildRequested || serviceResult.result.shaderBuildRequested;
|
|
ApplyRuntimeCoordinatorResult(serviceResult.result);
|
|
if (serviceResult.failed)
|
|
return false;
|
|
}
|
|
|
|
if (shaderBuildRequested)
|
|
return true;
|
|
|
|
const RenderEngine::PreparedShaderBuildApplyResult buildResult = mRenderEngine.TryApplyReadyShaderBuild(
|
|
mShaderBuildQueue,
|
|
mVideoBackend.InputFrameWidth(),
|
|
mVideoBackend.InputFrameHeight(),
|
|
mRuntimeCoordinator.PreserveFeedbackOnNextShaderBuild());
|
|
if (!buildResult.hadReadyBuild)
|
|
return true;
|
|
|
|
if (!buildResult.applied)
|
|
{
|
|
ApplyRuntimeCoordinatorResult(mRuntimeCoordinator.HandlePreparedShaderBuildFailure(buildResult.errorMessage));
|
|
return false;
|
|
}
|
|
|
|
ApplyRuntimeCoordinatorResult(mRuntimeCoordinator.HandlePreparedShaderBuildSuccess());
|
|
return true;
|
|
}
|
|
|
|
void RuntimeUpdateController::RequestShaderBuild()
|
|
{
|
|
mShaderBuildQueue.RequestBuild(mVideoBackend.InputFrameWidth(), mVideoBackend.InputFrameHeight());
|
|
}
|
|
|
|
void RuntimeUpdateController::BroadcastRuntimeState()
|
|
{
|
|
RuntimeStateBroadcastRequestedEvent event;
|
|
event.reason = "runtime-state-changed";
|
|
if (!mRuntimeEventDispatcher.PublishPayload(event, "RuntimeUpdateController"))
|
|
{
|
|
mRuntimeServices.BroadcastState();
|
|
return;
|
|
}
|
|
|
|
mRuntimeEventDispatcher.DispatchPending();
|
|
}
|
|
|
|
void RuntimeUpdateController::HandleRuntimeStateBroadcastRequested(const RuntimeEvent& event)
|
|
{
|
|
(void)event;
|
|
mRuntimeServices.BroadcastState();
|
|
}
|