dispatch event intergration

apps/LoopThroughWithOpenGLCompositing/gl/shader/ShaderBuildQueue.cpp

@@ -1,5 +1,7 @@
 #include "ShaderBuildQueue.h"
 
+#include "RuntimeEventDispatcher.h"
+
 #include <chrono>
 #include <utility>
 
@@ -8,8 +10,9 @@ namespace
 constexpr auto kShaderBuildDebounce = std::chrono::milliseconds(400);
 }
 
-ShaderBuildQueue::ShaderBuildQueue(RuntimeSnapshotProvider& runtimeSnapshotProvider) :
+ShaderBuildQueue::ShaderBuildQueue(RuntimeSnapshotProvider& runtimeSnapshotProvider, RuntimeEventDispatcher& runtimeEventDispatcher) :
 	mRuntimeSnapshotProvider(runtimeSnapshotProvider),
+	mRuntimeEventDispatcher(runtimeEventDispatcher),
 	mWorkerThread([this]() { WorkerLoop(); })
 {
 }
@@ -44,6 +47,18 @@ bool ShaderBuildQueue::TryConsumeReadyBuild(PreparedShaderBuild& build)
 	return true;
 }
 
+bool ShaderBuildQueue::TryConsumeReadyBuild(uint64_t expectedGeneration, PreparedShaderBuild& build)
+{
+	std::lock_guard<std::mutex> lock(mMutex);
+	if (!mHasReadyBuild || mReadyBuild.generation != expectedGeneration)
+		return false;
+
+	build = std::move(mReadyBuild);
+	mReadyBuild = PreparedShaderBuild();
+	mHasReadyBuild = false;
+	return true;
+}
+
 void ShaderBuildQueue::Stop()
 {
 	{
@@ -97,13 +112,20 @@ void ShaderBuildQueue::WorkerLoop()
 
 		PreparedShaderBuild build = Build(generation, outputWidth, outputHeight);
 
-		std::lock_guard<std::mutex> lock(mMutex);
-		if (mStopping)
-			return;
-		if (generation != mRequestedGeneration)
-			continue;
-		mReadyBuild = std::move(build);
-		mHasReadyBuild = true;
+		bool shouldPublish = false;
+		{
+			std::lock_guard<std::mutex> lock(mMutex);
+			if (mStopping)
+				return;
+			if (generation != mRequestedGeneration)
+				continue;
+			mReadyBuild = build;
+			mHasReadyBuild = true;
+			shouldPublish = true;
+		}
+
+		if (shouldPublish)
+			PublishBuildLifecycleEvent(build, outputWidth, outputHeight);
 	}
 }
 
@@ -130,3 +152,15 @@ PreparedShaderBuild ShaderBuildQueue::Build(uint64_t generation, unsigned output
 	build.message = "Shader layers prepared successfully.";
 	return build;
 }
+
+void ShaderBuildQueue::PublishBuildLifecycleEvent(const PreparedShaderBuild& build, unsigned outputWidth, unsigned outputHeight) const
+{
+	ShaderBuildEvent event;
+	event.phase = build.succeeded ? RuntimeEventShaderBuildPhase::Prepared : RuntimeEventShaderBuildPhase::Failed;
+	event.generation = build.generation;
+	event.inputWidth = outputWidth;
+	event.inputHeight = outputHeight;
+	event.succeeded = build.succeeded;
+	event.message = build.message;
+	mRuntimeEventDispatcher.PublishPayload(event, "ShaderBuildQueue");
+}

apps/LoopThroughWithOpenGLCompositing/gl/shader/ShaderBuildQueue.h

@@ -10,6 +10,8 @@
 #include <thread>
 #include <vector>
 
+class RuntimeEventDispatcher;
+
 struct PreparedLayerShader
 {
 	RuntimeRenderState state;
@@ -28,7 +30,7 @@ struct PreparedShaderBuild
 class ShaderBuildQueue
 {
 public:
-	explicit ShaderBuildQueue(RuntimeSnapshotProvider& runtimeSnapshotProvider);
+	ShaderBuildQueue(RuntimeSnapshotProvider& runtimeSnapshotProvider, RuntimeEventDispatcher& runtimeEventDispatcher);
 	~ShaderBuildQueue();
 
 	ShaderBuildQueue(const ShaderBuildQueue&) = delete;
@@ -36,13 +38,16 @@ public:
 
 	void RequestBuild(unsigned outputWidth, unsigned outputHeight);
 	bool TryConsumeReadyBuild(PreparedShaderBuild& build);
+	bool TryConsumeReadyBuild(uint64_t expectedGeneration, PreparedShaderBuild& build);
 	void Stop();
 
 private:
 	void WorkerLoop();
 	PreparedShaderBuild Build(uint64_t generation, unsigned outputWidth, unsigned outputHeight);
+	void PublishBuildLifecycleEvent(const PreparedShaderBuild& build, unsigned outputWidth, unsigned outputHeight) const;
 
 	RuntimeSnapshotProvider& mRuntimeSnapshotProvider;
+	RuntimeEventDispatcher& mRuntimeEventDispatcher;
 	std::thread mWorkerThread;
 	std::mutex mMutex;
 	std::condition_variable mCondition;