phase 2 progress

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.cpp

@@ -300,7 +300,7 @@ bool OpenGLComposite::RequestScreenshot(std::string& error)
 
 void OpenGLComposite::renderEffect()
 {
-	if (mRuntimeUpdateController && ProcessRuntimeServiceResults())
+	if (mRuntimeUpdateController)
 		mRuntimeUpdateController->ProcessRuntimeWork();
 	std::vector<RuntimeServices::AppliedOscUpdate> appliedOscUpdates;
 	std::vector<RuntimeServices::CompletedOscCommit> completedOscCommits;
@@ -369,25 +369,6 @@ void OpenGLComposite::renderEffect()
 		historyCap);
 }
 
-bool OpenGLComposite::ProcessRuntimeServiceResults()
-{
-	if (!mRuntimeServices || !mRuntimeUpdateController)
-		return true;
-
-	bool shaderBuildRequested = false;
-	std::vector<RuntimeCoordinatorServiceResult> serviceResults;
-	mRuntimeServices->ConsumeRuntimeCoordinatorResults(serviceResults);
-	for (const RuntimeCoordinatorServiceResult& serviceResult : serviceResults)
-	{
-		shaderBuildRequested = shaderBuildRequested || serviceResult.result.shaderBuildRequested;
-		mRuntimeUpdateController->ApplyRuntimeCoordinatorResult(serviceResult.result);
-		if (serviceResult.failed)
-			return false;
-	}
-
-	return !shaderBuildRequested;
-}
-
 void OpenGLComposite::ProcessScreenshotRequest()
 {
 	if (!mScreenshotRequested.exchange(false))

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.h

@@ -87,7 +87,6 @@ private:
 
 	bool InitOpenGLState();
 	void renderEffect();
-	bool ProcessRuntimeServiceResults();
 	void ProcessScreenshotRequest();
 	std::filesystem::path BuildScreenshotPath() const;
 };

apps/LoopThroughWithOpenGLCompositing/gl/RuntimeUpdateController.cpp

@@ -45,6 +45,9 @@ RuntimeUpdateController::RuntimeUpdateController(
 	mRuntimeEventDispatcher.Subscribe(
 		RuntimeEventType::RuntimeStateBroadcastRequested,
 		[this](const RuntimeEvent& event) { HandleRuntimeStateBroadcastRequested(event); });
+	mRuntimeEventDispatcher.Subscribe(
+		RuntimeEventType::RuntimeReloadRequested,
+		[this](const RuntimeEvent& event) { HandleRuntimeReloadRequested(event); });
 	mRuntimeEventDispatcher.Subscribe(
 		RuntimeEventType::ShaderBuildRequested,
 		[this](const RuntimeEvent& event) { HandleShaderBuildRequested(event); });
@@ -137,6 +140,15 @@ void RuntimeUpdateController::HandleRuntimeStateBroadcastRequested(const Runtime
 	mRuntimeServices.BroadcastState();
 }
 
+void RuntimeUpdateController::HandleRuntimeReloadRequested(const RuntimeEvent& event)
+{
+	const RuntimeReloadRequestedEvent* payload = std::get_if<RuntimeReloadRequestedEvent>(&event.payload);
+	if (!payload)
+		return;
+
+	mRuntimeStore.ClearReloadRequest();
+}
+
 void RuntimeUpdateController::HandleShaderBuildRequested(const RuntimeEvent& event)
 {
 	const ShaderBuildEvent* payload = std::get_if<ShaderBuildEvent>(&event.payload);
@@ -317,16 +329,19 @@ void RuntimeUpdateController::PublishRuntimeEventHealthObservations(const Runtim
 {
 	const RuntimeEventQueueMetrics queueMetrics = mRuntimeEventDispatcher.GetQueueMetrics();
 	if (queueMetrics.depth != mLastReportedRuntimeEventQueueDepth ||
-		queueMetrics.droppedCount != mLastReportedRuntimeEventDroppedCount)
+		queueMetrics.droppedCount != mLastReportedRuntimeEventDroppedCount ||
+		queueMetrics.coalescedCount != mLastReportedRuntimeEventCoalescedCount)
 	{
 		QueueDepthChangedEvent queueDepth;
 		queueDepth.queueName = "runtime-events";
 		queueDepth.depth = queueMetrics.depth;
 		queueDepth.capacity = queueMetrics.capacity;
 		queueDepth.droppedCount = queueMetrics.droppedCount;
+		queueDepth.coalescedCount = queueMetrics.coalescedCount;
 		mRuntimeEventDispatcher.PublishPayload(queueDepth, "HealthTelemetry");
 		mLastReportedRuntimeEventQueueDepth = queueMetrics.depth;
 		mLastReportedRuntimeEventDroppedCount = queueMetrics.droppedCount;
+		mLastReportedRuntimeEventCoalescedCount = queueMetrics.coalescedCount;
 	}
 
 	if (result.handlerInvocations == 0 && result.handlerFailures == 0)

apps/LoopThroughWithOpenGLCompositing/gl/RuntimeUpdateController.h

@@ -35,6 +35,7 @@ public:
 
 private:
 	void HandleRuntimeStateBroadcastRequested(const RuntimeEvent& event);
+	void HandleRuntimeReloadRequested(const RuntimeEvent& event);
 	void HandleShaderBuildRequested(const RuntimeEvent& event);
 	void HandleShaderBuildPrepared(const RuntimeEvent& event);
 	void HandleShaderBuildFailed(const RuntimeEvent& event);
@@ -64,4 +65,5 @@ private:
 	std::size_t mPendingCoordinatorRenderResetEvents = 0;
 	std::size_t mLastReportedRuntimeEventQueueDepth = static_cast<std::size_t>(-1);
 	std::size_t mLastReportedRuntimeEventDroppedCount = static_cast<std::size_t>(-1);
+	std::size_t mLastReportedRuntimeEventCoalescedCount = static_cast<std::size_t>(-1);
 };