Per-engine compositors

.gitignore

@@ -1,3 +1,4 @@
+.env
 Cargo.lock
 /target
 **/*.rs.bk
@@ -8,3 +9,4 @@ Cargo.lock
 /tests/test_sample.exe
 
 .idea
+.cargo

Cargo.toml

@@ -18,7 +18,7 @@ default = ["dx9", "dx11", "dx12", "opengl3", "inject"]
 dx9 = []
 dx11 = []
 dx12 = []
-opengl3 = []
+opengl3 = ["dep:gl_generator"]
 inject = []
 
 [[example]]
@@ -29,6 +29,26 @@ crate-type = ["cdylib"]
 name = "hook_with_image"
 crate-type = ["cdylib"]
 
+[[example]]
+name = "injector"
+crate-type = ["bin"]
+
+[[example]]
+name = "demo_hook_dx12"
+crate-type = ["cdylib"]
+
+[[example]]
+name = "demo_hook_dx11"
+crate-type = ["cdylib"]
+
+[[example]]
+name = "demo_hook_dx9"
+crate-type = ["cdylib"]
+
+[[example]]
+name = "demo_hook_opengl3"
+crate-type = ["cdylib"]
+
 [dependencies]
 imgui = "0.11"
 imgui-opengl = "0.1"
@@ -49,14 +69,19 @@ windows = { version = "0.51.0", features = [
   "Win32_System_WindowsProgramming",
   "Win32_Graphics_Dxgi",
   "Win32_Graphics_Dxgi_Common",
+  "Win32_Graphics_Direct2D",
+  "Win32_Graphics_Direct2D_Common",
   "Win32_Graphics_Direct3D9",
+  "Win32_Graphics_Direct3D11on12",
   "Win32_Graphics_Direct3D11",
   "Win32_Graphics_Direct3D12",
   "Win32_Graphics_Direct3D_Fxc",
   "Win32_Graphics_Direct3D",
   "Win32_Graphics_DirectComposition",
+  "Win32_Graphics_Dwm",
   "Win32_Graphics_Gdi",
   "Win32_Graphics_OpenGL",
+  "Win32_UI_Controls",
   "Win32_UI_Input",
   "Win32_UI_Input_KeyboardAndMouse",
   "Win32_UI_WindowsAndMessaging",
@@ -67,11 +92,13 @@ once_cell = "1.18.0"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 
 [dev-dependencies]
+dotenv = "0.15.0"
 image = "0.24.8"
 tracing-subscriber = "0.3"
 
 [build-dependencies]
 cc = "1.0.72"
+gl_generator = { version = "0.14.0", optional = true }
 
 [profile.test]
 opt-level = 3

build.rs

@@ -31,4 +31,18 @@ fn main() {
 
     println!("cargo:rerun-if-changed=vendor/minhook/src");
     println!("cargo:rustc-link-search=native={}", env::var("OUT_DIR").unwrap());
+
+    #[cfg(feature = "opengl3")]
+    {
+        use std::fs::File;
+
+        use gl_generator::{Api, Fallbacks, Profile, Registry, StructGenerator};
+
+        let dest = env::var("OUT_DIR").unwrap();
+        let mut file = File::create(Path::new(&dest).join("gl_bindings.rs")).unwrap();
+
+        Registry::new(Api::Gl, (3, 3), Profile::Core, Fallbacks::All, [])
+            .write_bindings(StructGenerator, &mut file)
+            .unwrap();
+    }
 }

examples/demo_hook_dx11.rs

@@ -0,0 +1,56 @@
+use hudhook::*;
+use tracing_subscriber::prelude::*;
+use tracing_subscriber::{fmt, EnvFilter};
+
+pub fn setup_tracing() {
+    tracing_subscriber::registry()
+        .with(
+            fmt::layer().event_format(
+                fmt::format()
+                    .with_level(true)
+                    .with_thread_ids(true)
+                    .with_file(true)
+                    .with_line_number(true)
+                    .with_thread_names(true),
+            ),
+        )
+        .with(EnvFilter::from_default_env())
+        .init();
+}
+
+pub struct HookExample(bool);
+
+impl ImguiRenderLoop for HookExample {
+    fn render(&mut self, ui: &mut imgui::Ui) {
+        ui.show_demo_window(&mut self.0);
+    }
+}
+
+/// Entry point created by the `hudhook` library.
+///
+/// # Safety
+///
+/// haha
+#[no_mangle]
+pub unsafe extern "stdcall" fn DllMain(
+    hmodule: ::hudhook::windows::Win32::Foundation::HINSTANCE,
+    reason: u32,
+    _: *mut ::std::ffi::c_void,
+) {
+    if reason == ::hudhook::windows::Win32::System::SystemServices::DLL_PROCESS_ATTACH {
+        setup_tracing();
+        alloc_console().unwrap();
+        ::hudhook::tracing::trace!("DllMain()");
+        ::std::thread::spawn(move || {
+            if let Err(e) = ::hudhook::Hudhook::builder()
+                .with::<hooks::dx11::ImguiDx11Hooks>(HookExample(true))
+                .with_hmodule(hmodule)
+                .build()
+                .apply()
+            {
+                ::hudhook::tracing::error!("Couldn't apply hooks: {e:?}");
+                ::hudhook::eject();
+            }
+        });
+    }
+}

examples/demo_hook_dx12.rs

@@ -0,0 +1,56 @@
+use hudhook::*;
+use tracing_subscriber::prelude::*;
+use tracing_subscriber::{fmt, EnvFilter};
+
+pub fn setup_tracing() {
+    tracing_subscriber::registry()
+        .with(
+            fmt::layer().event_format(
+                fmt::format()
+                    .with_level(true)
+                    .with_thread_ids(true)
+                    .with_file(true)
+                    .with_line_number(true)
+                    .with_thread_names(true),
+            ),
+        )
+        .with(EnvFilter::from_default_env())
+        .init();
+}
+
+pub struct HookExample(bool);
+
+impl ImguiRenderLoop for HookExample {
+    fn render(&mut self, ui: &mut imgui::Ui) {
+        ui.show_demo_window(&mut self.0);
+    }
+}
+
+/// Entry point created by the `hudhook` library.
+///
+/// # Safety
+///
+/// haha
+#[no_mangle]
+pub unsafe extern "stdcall" fn DllMain(
+    hmodule: ::hudhook::windows::Win32::Foundation::HINSTANCE,
+    reason: u32,
+    _: *mut ::std::ffi::c_void,
+) {
+    if reason == ::hudhook::windows::Win32::System::SystemServices::DLL_PROCESS_ATTACH {
+        setup_tracing();
+        alloc_console().unwrap();
+        ::hudhook::tracing::trace!("DllMain()");
+        ::std::thread::spawn(move || {
+            if let Err(e) = ::hudhook::Hudhook::builder()
+                .with::<hooks::dx12::ImguiDx12Hooks>(HookExample(true))
+                .with_hmodule(hmodule)
+                .build()
+                .apply()
+            {
+                ::hudhook::tracing::error!("Couldn't apply hooks: {e:?}");
+                ::hudhook::eject();
+            }
+        });
+    }
+}

examples/demo_hook_dx9.rs

@@ -0,0 +1,56 @@
+use hudhook::*;
+use tracing_subscriber::prelude::*;
+use tracing_subscriber::{fmt, EnvFilter};
+
+pub fn setup_tracing() {
+    tracing_subscriber::registry()
+        .with(
+            fmt::layer().event_format(
+                fmt::format()
+                    .with_level(true)
+                    .with_thread_ids(true)
+                    .with_file(true)
+                    .with_line_number(true)
+                    .with_thread_names(true),
+            ),
+        )
+        .with(EnvFilter::from_default_env())
+        .init();
+}
+
+pub struct HookExample(bool);
+
+impl ImguiRenderLoop for HookExample {
+    fn render(&mut self, ui: &mut imgui::Ui) {
+        ui.show_demo_window(&mut self.0);
+    }
+}
+
+/// Entry point created by the `hudhook` library.
+///
+/// # Safety
+///
+/// haha
+#[no_mangle]
+pub unsafe extern "stdcall" fn DllMain(
+    hmodule: ::hudhook::windows::Win32::Foundation::HINSTANCE,
+    reason: u32,
+    _: *mut ::std::ffi::c_void,
+) {
+    if reason == ::hudhook::windows::Win32::System::SystemServices::DLL_PROCESS_ATTACH {
+        setup_tracing();
+        alloc_console().unwrap();
+        ::hudhook::tracing::trace!("DllMain()");
+        ::std::thread::spawn(move || {
+            if let Err(e) = ::hudhook::Hudhook::builder()
+                .with::<hooks::dx9::ImguiDx9Hooks>(HookExample(true))
+                .with_hmodule(hmodule)
+                .build()
+                .apply()
+            {
+                ::hudhook::tracing::error!("Couldn't apply hooks: {e:?}");
+                ::hudhook::eject();
+            }
+        });
+    }
+}

examples/demo_hook_opengl3.rs

@@ -0,0 +1,56 @@
+use hudhook::*;
+use tracing_subscriber::prelude::*;
+use tracing_subscriber::{fmt, EnvFilter};
+
+pub fn setup_tracing() {
+    tracing_subscriber::registry()
+        .with(
+            fmt::layer().event_format(
+                fmt::format()
+                    .with_level(true)
+                    .with_thread_ids(true)
+                    .with_file(true)
+                    .with_line_number(true)
+                    .with_thread_names(true),
+            ),
+        )
+        .with(EnvFilter::from_default_env())
+        .init();
+}
+
+pub struct HookExample(bool);
+
+impl ImguiRenderLoop for HookExample {
+    fn render(&mut self, ui: &mut imgui::Ui) {
+        ui.show_demo_window(&mut self.0);
+    }
+}
+
+/// Entry point created by the `hudhook` library.
+///
+/// # Safety
+///
+/// haha
+#[no_mangle]
+pub unsafe extern "stdcall" fn DllMain(
+    hmodule: ::hudhook::windows::Win32::Foundation::HINSTANCE,
+    reason: u32,
+    _: *mut ::std::ffi::c_void,
+) {
+    if reason == ::hudhook::windows::Win32::System::SystemServices::DLL_PROCESS_ATTACH {
+        setup_tracing();
+        alloc_console().unwrap();
+        ::hudhook::tracing::trace!("DllMain()");
+        ::std::thread::spawn(move || {
+            if let Err(e) = ::hudhook::Hudhook::builder()
+                .with::<hooks::opengl3::ImguiOpenGl3Hooks>(HookExample(true))
+                .with_hmodule(hmodule)
+                .build()
+                .apply()
+            {
+                ::hudhook::tracing::error!("Couldn't apply hooks: {e:?}");
+                ::hudhook::eject();
+            }
+        });
+    }
+}

examples/hook_with_image.rs

@@ -4,7 +4,7 @@ use hudhook::renderer::RenderEngine;
 use hudhook::ImguiRenderLoop;
 use image::io::Reader as ImageReader;
 use image::{EncodableLayout, RgbaImage};
-use imgui::{Condition, Image, TextureId};
+use imgui::{Condition, Context, Image, TextureId};
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::{fmt, EnvFilter};
 
@@ -49,7 +49,7 @@ impl Default for HookExample {
 }
 
 impl ImguiRenderLoop for HookExample {
-    fn initialize(&mut self, render_engine: &mut RenderEngine) {
+    fn initialize(&mut self, _ctx: &mut Context, render_engine: &mut RenderEngine) {
         self.image_id = render_engine
             .load_image(self.image.as_bytes(), self.image.width() as _, self.image.height() as _)
             .ok();

examples/injector.rs

@@ -0,0 +1,12 @@
+use std::path::PathBuf;
+
+use hudhook::inject::Process;
+
+fn main() {
+    let mut args = std::env::args();
+    args.next().unwrap();
+    let name = args.next().unwrap();
+    let dll: PathBuf = args.next().unwrap().into();
+    let process = Process::by_name(&name).expect("Process by name");
+    process.inject(dll).expect("Inject");
+}