feat(filewatcher): add hlsli tracking

[alandtse]

Summary by CodeRabbit

• New Features

  • Added shader include dependency tracking to auto-invalidate and recompile affected shaders.
  • Added API to report the current number of failed shader compilations; overlay now reflects this count.

• Bug Fixes

  • Improved dependency-driven cache invalidation and reduced unnecessary work on file events.
  • Hardened include path normalization and reduced noisy directory-change logging for more reliable updates.

[coderabbitai]

📝 Walkthrough

Walkthrough

Adds a thread-safe ShaderFileDependencyTracker and wires it into ShaderCache compilation and the file-watcher; captures shader includes during compilation via a TrackingIncludeHandler, registers dependencies for invalidation, and exposes GetCurrentFailedCount() and dependency accessor APIs.

Changes

Cohort / File(s)	Summary
Forward Declarations src/Globals.h	Added forward declaration class ShaderFileDependencyTracker; in namespace SIE.
Dependency Tracking API src/ShaderFileWatcher.h	New SIE::ShaderFileDependencyTracker class: thread-safe register/unregister of .hlsl → .hlsli mappings, dependents lookup, and clear functionality.
ShaderCache Integration src/ShaderCache.h, src/ShaderCache.cpp	Integrated dependency tracker into ShaderCache lifecycle: new dependencyTracker member, GetDependencyTracker(), GetCurrentFailedCount(); updated CompileShader() signature to accept tracker; added TrackingIncludeHandler to capture includes; UpdateListener now constructed with tracker and uses it to invalidate dependents.
UI Status Update src/Menu/OverlayRenderer.cpp	Replaced ShaderCache::GetFailedTasks() calls with ShaderCache::GetCurrentFailedCount() in rendering/skip logic.

Sequence Diagram

sequenceDiagram
    participant Cache as ShaderCache
    participant Handler as TrackingIncludeHandler
    participant Compiler as D3DCompiler
    participant Tracker as ShaderFileDependencyTracker
    participant Watcher as FileWatcher

    Cache->>Handler: Create TrackingIncludeHandler(baseDir)
    Cache->>Compiler: D3DCompileFromFile(..., pInclude=Handler)
    loop per `#include`
        Compiler->>Handler: Open(includePath)
        Handler->>Handler: Normalize & record include
    end
    Compiler-->>Cache: CompilationResult (success/failure)
    alt includes captured
        Cache->>Tracker: RegisterDependencies(hlslFile, includes)
    else no includes
        Cache->>Tracker: UnregisterDependencies(hlslFile) (on failure/cleanup)
    end
    Watcher->>Tracker: GetDependents(changedInclude)
    Tracker-->>Watcher: dependent .hlsl list
    Watcher->>Cache: Invalidate dependent shaders

Loading

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~25 minutes

Suggested reviewers

• jiayev

Poem

🐰 I hopped through code to track each include,
I caught the files where dependencies grew,
When headers change and make builds frown,
I nudge the cache—recompile and brown! 🎨

🚥 Pre-merge checks | ✅ 2 | ❌ 1

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 3.23% which is insufficient. The required threshold is 80.00%.	Write docstrings for the functions missing them to satisfy the coverage threshold.

✅ Passed checks (2 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title clearly and concisely summarizes the main objective of the pull request, which is to add hlsli tracking functionality to the filewatcher system.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing touches

• 📝 Generate docstrings

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[github-actions]

Using provided base ref: eaa4776
Using base ref: eaa4776
Base commit date: 2026-02-02T10:11:57-08:00 (Monday, February 02, 2026 10:11 AM)
No actionable suggestions for changed features.

[coderabbitai]

Actionable comments posted: 4

🤖 Fix all issues with AI agents

In `@src/ShaderCache.cpp`:
- Around line 2965-2972: The .hlsli branch is currently nested inside the .hlsl
conditional (making the else if for lowerExtension == ".hlsli" unreachable);
move the else-if that checks lowerExtension == ".hlsli" (the block that calls
deps->GetDependents(filePath.string()) and then cache->Clear(hlsl) for each
dependent) out of the .hlsl branch so it is a sibling conditional at the same
level as the .hlsl handling, and keep the existing filesystem directory check
(!std::filesystem::is_directory(filePath)) to avoid processing directories.

In `@src/ShaderFileWatcher.cpp`:
- Around line 51-60: The StartWatching implementation doesn't capture the
WatchID returned by fileWatcher->addWatch(), leaving the member watchID at 0 and
causing StopWatching() to call removeWatch() with an invalid ID; update
ShaderFileWatcher::StartWatching to assign the return value of
fileWatcher->addWatch(root, this, true) to the class member watchID so
StopWatching() can call fileWatcher->removeWatch(watchID) correctly, ensuring
fileWatcher is non-null and watchID is stored for later removal.
- Around line 51-60: The detached thread started in
ShaderFileWatcher::StartWatching (std::thread([this]{ this->processQueue();
}).detach()) can outlive the object; change to store a joinable std::thread
member (e.g. watcherThread) and start it without detach, ensure processQueue
checks the atomic running flag and waits on a condition_variable (using
queueMutex/queue) so it can be signaled to exit, then join watcherThread in
StopWatching() and the destructor after setting running=false and notifying the
condition_variable; also ensure fileWatcher is stopped/removed before join to
avoid race with file callbacks.
- Around line 23-24: The non-atomic boolean flag "running" is accessed from
multiple threads causing a data race; change its type to std::atomic<bool> in
ShaderFileWatcher (declare atomic<bool> running in ShaderFileWatcher.h and
include <atomic>), update any reads/writes in processQueue(), StartWatching(),
and StopWatching() to use the atomic directly (no extra locking needed for
simple load/store) so that setting running = true/false and reads in
processQueue() are thread-safe. Ensure all translation units include <atomic>
where the type is used.

🧹 Nitpick comments (1)

src/ShaderFileWatcher.h (1)

25-29: Consider making data members private with accessor methods.

The hlslToIncludes, hlsliToHlsl, and mutex members are public but are only accessed internally by the class methods. Making them private would improve encapsulation and prevent external code from accidentally bypassing the mutex-protected methods.

♻️ Suggested encapsulation improvement

 class ShaderFileDependencyTracker
 {
 public:
-	// Map: .hlsl file -> set of included files (usually .hlsli)
-	std::unordered_map<std::string, std::unordered_set<std::string>> hlslToIncludes;
-	// Map: .hlsli file -> set of dependent .hlsl files
-	std::unordered_map<std::string, std::unordered_set<std::string>> hlsliToHlsl;
-	std::mutex mutex;
-
 	// Called after compiling a .hlsl file, with the set of includes used
 	void RegisterDependencies(const std::string& hlslFile, const std::vector<std::string>& includes)
+
+private:
+	// Map: .hlsl file -> set of included files (usually .hlsli)
+	std::unordered_map<std::string, std::unordered_set<std::string>> hlslToIncludes;
+	// Map: .hlsli file -> set of dependent .hlsl files
+	std::unordered_map<std::string, std::unordered_set<std::string>> hlsliToHlsl;
+	std::mutex mutex;
 };

[Copilot]

Pull request overview

This PR adds dependency tracking for .hlsli (HLSL include) files to the shader file watcher system. When a .hlsli file changes, all .hlsl shaders that depend on it are automatically invalidated and marked for recompilation. The implementation introduces a custom TrackingIncludeHandler that captures include dependencies during shader compilation, a ShaderFileDependencyTracker class to maintain bidirectional include relationships, and integrates this tracking into the existing shader cache system. The PR also refactors error reporting by replacing cumulative GetFailedTasks() with GetCurrentFailedCount() that reflects the current state of failed shaders.

Changes:

• Added .hlsli dependency tracking that automatically invalidates dependent .hlsl shaders when include files change
• Introduced custom TrackingIncludeHandler to capture include relationships during compilation
• Replaced cumulative failed task counter with current failed shader count for accurate error reporting

Reviewed changes

Copilot reviewed 6 out of 6 changed files in this pull request and generated 11 comments.

Show a summary per file

File	Description
src/ShaderFileWatcher.h	Defines ShaderFileDependencyTracker for tracking .hlsl/.hlsli relationships and ShaderFileWatcher class (currently unused)
src/ShaderFileWatcher.cpp	Implements file watching and dependency invalidation logic (currently unused)
src/ShaderCache.h	Adds dependencyTracker member, GetCurrentFailedCount() method, and updates UpdateListener constructor
src/ShaderCache.cpp	Integrates TrackingIncludeHandler for dependency capture, adds .hlsli invalidation to UpdateListener, and implements GetCurrentFailedCount()
src/Menu/OverlayRenderer.cpp	Changes from GetFailedTasks() to GetCurrentFailedCount() for accurate current failure display
src/Globals.h	Adds forward declaration for ShaderFileDependencyTracker

[github-actions]

✅ A pre-release build is available for this PR:
Download

[coderabbitai]

Actionable comments posted: 2

🤖 Fix all issues with AI agents

In `@src/ShaderCache.cpp`:
- Around line 47-53: The code uses ifs.tellg() into std::streamsize size and
immediately casts to size_t for the vector, which can overflow if tellg()
returns -1; add a guard after computing size (check if size < 0) and bail out
(return E_FAIL or appropriate error) before casting/allocating; keep the
existing zero-size handling and only construct buf when size > 0 so that the
vector allocation uses a valid non-negative size (refer to the local variable
size and the ifs.read(...) usage in this block).
- Around line 2966-2975: The watcher invalidation misses dependents when .hlsli
casing differs on Windows because TrackingIncludeHandler lowercases include
paths; update the .hlsli handling in the block that computes
canonicalPath/pathStr (used for deps->GetDependents(pathStr) and
cache->Clear(hlsl)) to normalize casing on Windows (e.g., lowercase pathStr when
on Windows) before calling deps->GetDependents so lookups match the tracker;
keep the existing weakly_canonical error fallback logic and only apply the
lowercase conversion for the final pathStr used for dependency lookup.