If you need to execute custom logic during library initialization or manage multiple hooks, you can manually implement DllMain instead of using the macro.

To do this, use the Hudhook::builder() pattern. You should typically spawn a new thread within DLL_PROCESS_ATTACH to run the hook application logic to avoid blocking the loader lock.

Key builder methods:

• .with::<T>(instance): Registers a hook type T with a provided instance implementing ImguiRenderLoop.
• .with_hmodule(hmodule): Provides the library's module handle.
• .build(): Finalizes the builder into a Hudhook instance.
• .apply(): Executes the hook application process.

If .apply() returns an error, you can call eject() to remove the library.

use hudhook::hooks::dx12::ImguiDx12Hooks;
use hudhook::tracing::*;nuse hudhook::windows::Win32::Foundation::HINSTANCE;
use hudhook::windows::Win32::System::SystemServices::DLL_PROCESS_ATTACH;
use hudhook::*;

#[no_mangle]
pub unsafe extern "system" fn DllMain(
    hmodule: HINSTANCE,
    reason: u32,
    _: *mut std::ffi::c_void,
) {
    if reason == DLL_PROCESS_ATTACH {
        trace!("DllMain()");
        let hmodule_raw = hmodule.0 as usize;
        std::thread::spawn(move || {
            let hmodule = HINSTANCE(hmodule_raw as _);
            if let Err(e) = Hudhook::builder()
                .with::<ImguiDx12Hooks>(HelloHud::new())
                .with_hmodule(hmodule)
                .build()
                .apply()
            {
                error!("Couldn't apply hooks: {e:?}");
                eject();
            }
        });
    }
}

DLL proxying is an injection technique where you place a custom DLL with a specific name (e.g., dinput8.dll) in the application's search path. When the application calls LoadLibrary, your DLL is loaded instead of the system version. To ensure the application continues to function, your DLL must export the same functions as the original and forward calls to the real system DLL.

1. Configure Cargo.toml

Set the crate type to cdylib and name the library after the DLL you are proxying.

2. Define Exports

Create an exports.def file listing the functions you need to export. This ensures the linker exports them correctly.

3. Link the DEF file

Use a build.rs script to pass the .def file to the linker.

4. Implement Function Forwarding

In your Rust code:

• Define a type for the original function signature.
• Use a static LazyLock to load the real system DLL (e.g., from C:\Windows\System32\) and retrieve the address of the original function using GetProcAddress.
• Implement the exported function with #[no_mangle] and the correct calling convention (e.g., extern "stdcall").
• Inside the exported function, perform your custom logic (like calling patch()) and then call the original function pointer.

5. Define DllMain

Implement DllMain to initialize your state (e.g., by forcing the LazyLock) when the DLL is attached to the process.

6. Compile

Build the release version of your library.

# Configure Cargo.toml
[lib]
name = "dinput8"
crate-type = ["cdylib"]

# Create exports.def
EXPORTS
  DirectInput8Create

# build.rs
fn main() {
    println!("cargo:rustc-cdylib-link-arg=/DEF:exports.def");
}

# Build the DLL
cargo build --release

To prevent the host application from crashing, your proxy DLL must intercept calls to the original function, execute your custom logic, and then pass the arguments to the real function located in the system DLL.

Example implementation for DirectInput8Create:

type FDirectInput8Create = unsafe extern "stdcall" fn(
    hinst: HINSTANCE,
    dwversion: u32,
    riidltf: *const GUID,
    ppvout: *mut *mut c_void,
    punkouter: HINSTANCE,
) -> HRESULT;

struct State {
    directinput8create: FDirectInput8Create,
}

unsafe impl Send for State {}
unsafe impl Sync for State {}

static STATE: LazyLock<State> = LazyLock::new(|| unsafe {
    let dinput8 = LoadLibraryA(PCSTR(b"C:\\Windows\\System32\\dinput8.dll\0".as_ptr())).unwrap();
    let directinput8create = 
        std::mem::transmute(GetProcAddress(dinput8, PCSTR(b"DirectInput8Create\0".as_ptr())));
    
    State { directinput8create }
});

#[no_mangle]
unsafe extern "stdcall" fn DirectInput8Create(
    hinst: HINSTANCE,
    dwversion: u32,
    riidltf: *const GUID,
    ppvout: *mut *mut c_void,
    punkouter: HINSTANCE,
) -> HRESULT {
    patch(); // Your custom logic

    (STATE.directinput8create)(hinst, dwversion, riidltf, ppvout, punkouter)
}

#[no_mangle]
#[allow(non_snake_case, unused_variables)]
extern "system" fn DllMain(dll_module: HINSTANCE, call_reason: u32, reserved: *mut c_void) -> BOOL {
    match call_reason {
        DLL_PROCESS_ATTACH => LazyLock::force(&STATE),
        DLL_PROCESS_DETACH => (),
        _ => (),
    }
    BOOL::from(true)
}