Struct vmt_hook::VTableHook

pub struct VTableHook<T> { /* private fields */ }

Represents a structure responsible for hooking and managing the virtual function table (VTable) of a given type.

Example

use vmt_hook::VTableHook;

use windows::{
    core::HRESULT,
    Win32::{
        Foundation::{HWND, RECT},
        Graphics::{
            Direct3D9::IDirect3DDevice9,
            Gdi::RGNDATA,
        },
    },
};

type FnPresent = extern "stdcall" fn(
    IDirect3DDevice9,
    *const RECT,
    *const RECT,
    HWND,
    *const RGNDATA,
) -> HRESULT;

static mut ORIGINAL_PRESENT: Option<FnPresent> = None;

extern "stdcall" fn hk_present(
    device: IDirect3DDevice9,
    source_rect: *const RECT,
    dest_rect: *const RECT,
    dest_window_override: HWND,
    dirty_region: *const RGNDATA,
) -> HRESULT {
    // Your code.

    unsafe {
        let original_present = ORIGINAL_PRESENT.unwrap();
        original_present(device, source_rect, dest_rect, dest_window_override, dirty_region)
    }
}

unsafe fn instal_d3d9_hook() {
    let device: *mut IDirect3DDevice9 = /* Your ptr. */;

    // Creating a hook with automatic detection of the number of methods in its VMT.
    // let hook = VTableHook::new(device);

    // If you know the number of methods in the table, you can specify it manually.
    let hook = VTableHook::with_count(device, 119);

    // Getting the original method.
    ORIGINAL_PRESENT = Some(std::mem::transmute(hook.get_original_method(17)));

    // Replacing the method at index 17 in the VMT with our function.
    hook.hook_method(17, hk_present as usize);

    // Getting our hook function.
    let hook_method = hook.get_hook_method(17);
}

Implementations

impl<T> VTableHook<T>

pub unsafe fn new(object: *mut T) -> Self

Creates a new VTableHook instance for the provided object and replaces its VTable with the hooked VTable.

pub unsafe fn with_count(object: *mut T, count: usize) -> Self

Creates a new VTableHook instance for the provided object with a specified method count and replaces its VTable with the hooked VTable.

pub fn get_original_method(&self, id: usize) -> usize

Retrieves the original method address at the specified index in the VTable.

pub fn get_hook_method(&self, id: usize) -> usize

Retrieves the hooked method address at the specified index in the VTable.

pub unsafe fn hook_method(&self, id: usize, func: usize)

Hooks the method at the specified index in the VTable with a new function address.

pub unsafe fn restore_method(&self, id: usize)

Restores the original method at the specified index in the VTable.

pub unsafe fn restore_all_methods(&self)

Restores all methods in the VTable to their original address.

Trait Implementations

impl<T> Drop for VTableHook<T>

fn drop(&mut self)

Restoring the original VTable.