Merge pull request #494 from GameTechDev/feature/new-inj

New features for flash injection

Author: markgalvan-intel

IntelPresentMon/AppCef/ipm-ui-vue/src/core/preferences.ts

@@ -60,6 +60,9 @@ export interface Preferences {
     flashInjectionBackgroundEnable:boolean;
     flashInjectionBackgroundColor:RgbaColor;
     flashInjectionRightShift:number;
+    flashInjectionFlashDuration:number;
+    flashInjectionUseRainbow:boolean;
+    flashInjectionBackgroundSize:number;
 };
 
 export function makeDefaultPreferences(): Preferences {
@@ -129,6 +132,9 @@ export function makeDefaultPreferences(): Preferences {
             a: 255, 
         },
         flashInjectionRightShift: 0.5,
+        flashInjectionFlashDuration: 0.05,
+        flashInjectionUseRainbow: false,
+        flashInjectionBackgroundSize:0.25,
     };
 }
 

IntelPresentMon/AppCef/ipm-ui-vue/src/views/FlashConfigView.vue

@@ -95,10 +95,20 @@ watch(
         </v-col>
       </v-row>
 
+      <v-row class="mt-8">
+        <v-col cols="3">
+          Rainbow Flash
+          <p class="text-medium-emphasis text-caption mb-0">Cycle through a rainbow of colors instead of using above flash color.</p>
+        </v-col>
+        <v-col cols="9">
+          <v-switch v-model="prefs.preferences.flashInjectionUseRainbow" label="Enable"></v-switch>
+        </v-col>
+      </v-row>
+
       <v-row class="mt-8">
         <v-col cols="3">
           Flash Width
-          <p class="text-medium-emphasis text-caption mb-0">Width of the flash rectangle and background</p>
+          <p class="text-medium-emphasis text-caption mb-0">Width of the flash rectangle</p>
         </v-col>
         <v-col cols="9">
           <v-slider
@@ -111,6 +121,22 @@ watch(
         </v-col>
       </v-row>
 
+      <v-row class="mt-8">
+        <v-col cols="3">
+          Background Width
+          <p class="text-medium-emphasis text-caption mb-0">Width of the background rectangle (if active)</p>
+        </v-col>
+        <v-col cols="9">
+          <v-slider
+            v-model="prefs.preferences.flashInjectionBackgroundSize"
+            :min="0.01"
+            :max="1"
+            :step="0.01"
+            thumb-label="always"
+          ></v-slider>
+        </v-col>
+      </v-row>
+
       <v-row class="mt-8">
         <v-col cols="3">
           Flash Offset
@@ -127,6 +153,22 @@ watch(
         </v-col>
       </v-row>
 
+      <v-row class="mt-8">
+        <v-col cols="3">
+          Flash Duration
+          <p class="text-medium-emphasis text-caption mb-0">Duration of the flash in seconds.</p>
+        </v-col>
+        <v-col cols="9">
+          <v-slider
+            v-model="prefs.preferences.flashInjectionFlashDuration"
+            :min="0"
+            :max="1"
+            :step="0.001"
+            thumb-label="always"
+          ></v-slider>
+        </v-col>
+      </v-row>
+
       <v-row class="mt-4">
         <v-col>
           <h3>Notes</h3>

IntelPresentMon/Core/source/kernel/InjectorComplex.cpp

@@ -45,14 +45,16 @@ namespace p2c::kern
 	{
 		std::lock_guard lk{ mtx_ };
 		if (IsActive(false) && targetModuleName_ != targetModuleName) {
-			pmlog_dbg("Writting new target name to injectors").pmwatch(targetModuleName.value_or(""s));
+			pmlog_dbg("Writing new target name to injectors").pmwatch(targetModuleName.value_or(""s));
 			targetModuleName_ = targetModuleName;
 			pInjector32_->ChangeTarget(targetModuleName);
 			pInjector64_->ChangeTarget(targetModuleName);
 		}
 	}
 	InjectorComplex::InjectorModule_::InjectorModule_(bool is32Bit)
-		: pipeOut_(ioctx_), pipeIn_(ioctx_)
+		:
+		pipeOut_{ ioctx_ },
+		pipeIn_{ ioctx_ }
 	{
 		// Determine the correct injector executable
 		auto exe = is32Bit
@@ -66,7 +68,7 @@ namespace p2c::kern
 			path.string(),
 			/* no args = */ std::vector<std::string>{},
 			bp2::windows::process_creation_flags<CREATE_NO_WINDOW>(),
-			bp2::process_stdio{ pipeIn_, pipeOut_, {} }
+			bp2::process_stdio{ pipeIn_, pipeOut_, nullptr }
 		);
 
 		// Start the listener thread; on stop request we'll call ioctx_.stop()
@@ -86,21 +88,33 @@ namespace p2c::kern
 		if (injectionPointClient_) {
 			PushConfig_();
 		}
-	}
-	void InjectorComplex::InjectorModule_::ChangeTarget(std::optional<std::string> targetModuleName)
+	}void InjectorComplex::InjectorModule_::ChangeTarget(std::optional<std::string> targetModuleName)
 	{
-		// disconnect if connected to an injection point already (previous target)
+		// Drop any prior action client (as you had)
 		{
 			std::lock_guard lk{ actionClientMutex_ };
 			injectionPointClient_.reset();
 		}
 
-		// Format the new line into writeBuffer_
-		std::ostream{ &writeBuffer_ } << targetModuleName.value_or(""s) << std::endl;
-		// Issue async write into the child’s stdin pipe
-		as::async_write(pipeIn_, writeBuffer_, [this](boost::system::error_code ec, std::size_t bytes_transferred) {
+		// Build one message per call; child expects a newline for getline()
+		auto msg = targetModuleName.value_or(std::string{}) + "\n";
+
+		// Always hop to the io_context thread to ensure serialization and buffer (string) lifetime
+		as::post(ioctx_, [this, m = std::move(msg)] {
+			if (!pipeIn_.is_open()) {
+				pmlog_warn("Injector stdin is closed; cannot send target");
+				return;
+			}
+
+			boost::system::error_code ec;
+			const auto n = as::write(pipeIn_, as::buffer(m), ec);
 			if (ec) {
-				pmlog_error("Failed to write target name to injector");
+				// Common Windows pipe errors:
+				// 109 = ERROR_BROKEN_PIPE, 232 = ERROR_NO_DATA, 233 = ERROR_PIPE_NOT_CONNECTED
+				pmlog_error("Sync write to injector failed").pmwatch(ec.value());
+			}
+			else if (n != m.size()) {
+				pmlog_error("Short write to injector").pmwatch(n).pmwatch(m.size());
 			}
 		});
 	}

IntelPresentMon/Core/source/kernel/InjectorComplex.h

@@ -27,15 +27,14 @@ namespace p2c::kern
             void SpawnReadPidTask_();
             void PushConfig_();
             as::io_context ioctx_;
-            as::readable_pipe                  pipeOut_;    // child's stdout to us
             as::writable_pipe                  pipeIn_;     // us to child's stdin
-            std::optional<bp2::process>        injectorProcess_;
+            as::readable_pipe                  pipeOut_;    // child's stdout to us
             as::streambuf                      readBuffer_;
-            as::streambuf                      writeBuffer_;
             std::jthread                       listenerThread_;
             std::mutex                         actionClientMutex_;
             std::optional<iact::ActionClient>  injectionPointClient_;
             GfxLayer::Extension::OverlayConfig config_;
+            std::optional<bp2::process>        injectorProcess_;
         };
     public:
         void SetActive(bool active);

IntelPresentMon/FlashInjectorLibrary/Extension/OverlayConfig.h

@@ -10,5 +10,8 @@ namespace GfxLayer::Extension
 		std::array<float, 4> BarColor = { 1.f, 1.f, 1.f, 1.f };
 		bool  RenderBackground = false;
 		std::array<float, 4> BackgroundColor = { 0.f, 0.f, 0.f, 1.f };
+		float FlashDuration = 0.05f;
+		bool UseRainbow = false;
+		float BackgroundSize = 0.2f;
 	};
 }

IntelPresentMon/FlashInjectorLibrary/Extension/OverlayRenderer.cpp

@@ -3,8 +3,10 @@
 #include "../Logging.h"
 #include "OverlayConfigPack.h"
 
-namespace GfxLayer::Extension
+namespace GfxLayer::Extension 
 {
+	using namespace std::literals;
+
 	void CheckResult(HRESULT result, const char* pMessage)
 	{
 		if (FAILED(result))
@@ -19,15 +21,17 @@ namespace GfxLayer::Extension
 		m_pSwapChain(pSwapChain)
 	{}
 
-	RECT OverlayRenderer::GetScissorRect() const
+	ScissorRects OverlayRenderer::GetScissorRects() const
 	{
-		const float rectWidth = m_width * m_currentConfig.BarSize;
-		RECT scissor;
-		scissor.left = LONG((m_width - rectWidth) * m_currentConfig.BarRightShift);
-		scissor.top = 0;
-		scissor.right = LONG(scissor.left + rectWidth);
-		scissor.bottom = m_height;
-		return scissor;
+		const float wfg = m_width * m_currentConfig.BarSize;
+		const float wbg = m_width * m_currentConfig.BackgroundSize;
+		const float w = std::max(wfg, wbg);
+		const float c = (m_width - w) * m_currentConfig.BarRightShift + 0.5f * w;
+
+		ScissorRects r{};
+		r.fg = { LONG(c - 0.5f * wfg), 0, LONG(c - 0.5f * wfg + wfg), LONG(m_height) };
+		r.bg = { LONG(c - 0.5f * wbg), 0, LONG(c - 0.5f * wbg + wbg), LONG(m_height) };
+		return r;
 	}
 
 	IDXGISwapChain3* OverlayRenderer::GetSwapChain() const
@@ -50,31 +54,48 @@ namespace GfxLayer::Extension
 			UpdateConfig(m_currentConfig);
 		}
 
-		static unsigned s_frameCounter = 0;
-		static bool s_mouseClicked = false;
-
-		if (GetAsyncKeyState(VK_LBUTTON) & 0x8000)
-		{
-			if (!s_mouseClicked)
-			{
-				s_frameCounter = 16;
+		bool flashStartedThisFrame = false;
+		// we only check mouse state if we're not currently in a flash
+		if (!m_flashStartTime) {
+			if (GetAsyncKeyState(VK_LBUTTON) & 0x8000) {
+				// if lmb is down, start a flash as long as we're not in holdoff
+				if (!m_clickHoldoff) {
+					m_flashStartTime = clock::now();
+					flashStartedThisFrame = true;
+					m_clickHoldoff = true;
+					m_flashFrameIndex = 0;
+				}
+			}
+			else {
+				// if lmb up (and not in flash) remove the holdoff so another flash could begin
+				m_clickHoldoff = false;
 			}
-			s_mouseClicked = true;
 		}
-		else
-		{
-			s_mouseClicked = false;
+		else {
+			// increment frame index for rainbow effect
+			m_flashFrameIndex++;
 		}
-
-		if (s_frameCounter > 0)
-		{
-			Render(true);
-			--s_frameCounter;
+		// if we have a flash start we might need to draw flash
+		if (m_flashStartTime) {
+			// draw flash if initiated this frame OR within flash duration
+			const std::chrono::duration<float> flashDuration{ m_currentConfig.FlashDuration };
+			if (flashStartedThisFrame || (clock::now() - *m_flashStartTime < flashDuration)) {
+				Render(true, m_currentConfig.UseRainbow, m_currentConfig.RenderBackground);
+			}
+			else {
+				// reset flash time if duration lapsed
+				m_flashStartTime.reset();
+			}
 		}
-		else if (m_currentConfig.RenderBackground)
-		{
-			Render(false);
+		// if we're not in flash, we might need to draw background
+		if (!m_flashStartTime && m_currentConfig.RenderBackground) {
+			Render(false, m_currentConfig.UseRainbow, true);
 		}
 	}
+
+	size_t OverlayRenderer::GetRainbowIndex() const
+	{
+		return m_flashFrameIndex % m_rainbowColors.size();
+	}
 }
 

IntelPresentMon/FlashInjectorLibrary/Extension/OverlayRenderer.h

@@ -6,35 +6,82 @@ using Microsoft::WRL::ComPtr;
 #include "../Context.h"
 #include "../NonCopyable.h"
 #include "OverlayConfig.h"
+#include <chrono>
+#include <optional>
 
 namespace GfxLayer::Extension
 {
 	void CheckResult(HRESULT result, const char* pMessage);
 
+	struct ScissorRects
+	{
+		RECT fg;
+		RECT bg;
+	};
+
 	class OverlayRenderer : public NonCopyable
 	{
 	public:
 		OverlayRenderer(const OverlayConfig& cfg, IDXGISwapChain3* pSwapChain);
 		virtual ~OverlayRenderer() = default;
 
 		// called from a hook whenever the host is resizing its render targets
-		virtual void			Resize(unsigned bufferCount, unsigned width, unsigned height) = 0;
+		virtual void Resize(unsigned bufferCount, unsigned width, unsigned height) = 0;
 
-		void					NewFrame();
-		RECT					GetScissorRect() const;
-		IDXGISwapChain3*		GetSwapChain() const;
+		void NewFrame();
+		ScissorRects GetScissorRects() const;
+		IDXGISwapChain3* GetSwapChain() const;
 
 	protected:
-		virtual void			Render(bool renderBar) = 0;
+		virtual void Render(bool renderBar, bool useRainbow, bool enableBackground) = 0;
 		// this is triggered both by Resize and by UpdateConfig
-		virtual void			UpdateViewport(const OverlayConfig& cfg) = 0;
+		virtual void UpdateViewport(const OverlayConfig& cfg) = 0;
 		// called from Render when it is detected that config has changed (via IPC action)
-		virtual void			UpdateConfig(const OverlayConfig& cfg) = 0;
+		virtual void UpdateConfig(const OverlayConfig& cfg) = 0;
+		// get rainbow index for current flash frame
+		size_t GetRainbowIndex() const;
+		// get array of rainbow colors
+		static constexpr const std::array<std::array<float, 4>, 16>& GetRainbowColors()
+		{
+			return m_rainbowColors;
+		}
+		template<class T>
+		static T MakeViewport(const RECT& r)
+		{
+			return T{
+				.TopLeftX = decltype(std::declval<T>().TopLeftX)(r.left),
+				.TopLeftY = decltype(std::declval<T>().TopLeftY)(r.top),
+				.Width = decltype(std::declval<T>().Width)(r.right - r.left),
+				.Height = decltype(std::declval<T>().Height)(r.bottom - r.top),
+			};
+		}
 
 	private:
+		static constexpr std::array<std::array<float, 4>, 16> m_rainbowColors = { {
+			{{1.00f, 0.00f, 0.00f, 1.0f}}, // red
+			{{1.00f, 0.50f, 0.00f, 1.0f}}, // orange
+			{{1.00f, 1.00f, 0.00f, 1.0f}}, // yellow
+			{{0.75f, 1.00f, 0.00f, 1.0f}}, // chartreuse
+			{{0.00f, 1.00f, 0.00f, 1.0f}}, // green
+			{{0.00f, 1.00f, 0.60f, 1.0f}}, // spring green
+			{{0.00f, 1.00f, 1.00f, 1.0f}}, // cyan
+			{{0.00f, 0.60f, 1.00f, 1.0f}}, // azure
+			{{0.00f, 0.00f, 1.00f, 1.0f}}, // blue
+			{{0.40f, 0.00f, 1.00f, 1.0f}}, // indigo
+			{{0.60f, 0.00f, 1.00f, 1.0f}}, // violet
+			{{0.80f, 0.00f, 0.80f, 1.0f}}, // purple
+			{{1.00f, 0.00f, 1.00f, 1.0f}}, // magenta
+			{{1.00f, 0.00f, 0.60f, 1.0f}}, // rose
+			{{1.00f, 0.20f, 0.40f, 1.0f}}, // salmon
+			{{1.00f, 0.40f, 0.60f, 1.0f}}, // pink
+		} };
+		using clock = std::chrono::high_resolution_clock;
 		OverlayConfig			m_currentConfig;
 		ComPtr<IDXGISwapChain3>	m_pSwapChain;
 		unsigned m_width;
 		unsigned m_height;
+		std::optional<clock::time_point> m_flashStartTime;
+		bool m_clickHoldoff = false;
+		size_t m_flashFrameIndex = 0;
 	};
 }