Struct HotReloadWatcher 

pub struct HotReloadWatcher { /* private fields */ }

Watches asset files for changes and triggers reloads.

Thread Safety

HotReloadWatcher is Send but NOT Sync. It should be accessed from the main thread and used with AssetServer in the game loop.

Example

use goud_engine::assets::{AssetServer, HotReloadWatcher, HotReloadConfig};
use std::time::Duration;

let mut server = AssetServer::new();
let config = HotReloadConfig::new()
    .with_debounce(Duration::from_millis(200))
    .watch_extension("png")
    .watch_extension("json");

let mut watcher = HotReloadWatcher::with_config(&server, config).unwrap();

// In game loop
loop {
    watcher.process_events(&mut server);
    // ... render, update, etc.
}

Implementations

impl HotReloadWatcher

pub fn new(server: &AssetServer) -> NotifyResult<Self>

Creates a new hot reload watcher for the given asset server.

Uses default configuration (enabled in debug builds).

Errors

Returns an error if the file watcher cannot be initialized.

Example

use goud_engine::assets::{AssetServer, HotReloadWatcher};

let server = AssetServer::new();
let watcher = HotReloadWatcher::new(&server).unwrap();

pub fn with_config( server: &AssetServer, config: HotReloadConfig, ) -> NotifyResult<Self>

Creates a new hot reload watcher with custom configuration.

Errors

Returns an error if the file watcher cannot be initialized.

pub fn watch(&mut self, path: impl AsRef<Path>) -> NotifyResult<()>

Starts watching a directory for changes.

Arguments

• path - Directory to watch (typically the asset root)

Errors

Returns an error if the path cannot be watched.

Example

watcher.watch("assets").unwrap();

pub fn unwatch(&mut self, path: impl AsRef<Path>) -> NotifyResult<()>

Stops watching a directory.

Errors

Returns an error if the path cannot be unwatched.

pub fn is_watching(&self, path: &Path) -> bool

Returns whether a path is currently being watched.

pub fn watched_paths(&self) -> &HashSet<PathBuf>

Returns the set of watched paths.

pub fn config(&self) -> &HotReloadConfig

Returns the configuration.

pub fn config_mut(&mut self) -> &mut HotReloadConfig

Returns a mutable reference to the configuration.

Note: Changing the configuration does not affect already-watched paths.

pub fn process_events(&mut self, server: &mut AssetServer) -> usize

Processes pending file system events and reloads changed assets.

Call this once per frame in your game loop.

Returns

The number of assets that were reloaded.

Example

loop {
    let reloaded = watcher.process_events(&mut server);
    if reloaded > 0 {
        println!("Reloaded {} assets", reloaded);
    }
    // ... rest of game loop
}

pub fn clear_debounce(&mut self)

Clears the debounce map.

Useful for testing or forcing immediate reloads.

Trait Implementations

impl Debug for HotReloadWatcher

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.