feat: 添加 d3d9 proxy（workspace 改造 + FPS OSD + mod API）

- 改造为 workspace: loader/ (version.dll) + d3d9-proxy/ (d3d9.dll)
- d3d9 proxy: 转发系统 d3d9.dll，拦截 CreateDevice/Present/EndScene
- retour inline hook Present/EndScene，兼容 segatools com_proxy
- FPS OSD: GDI 绘制到游戏窗口（后续改为纯 D3D9 渲染）
- mod API: d3d9proxy_get_api() 导出函数表
- 配置文件: d3d9.toml（分辨率/FPS 显示/帧锁）
- 头文件: include/d3d9proxy.h

Author: Applesaber

Cargo.toml

@@ -1,32 +1,6 @@
-[package]
-name = "chumod-loader"
-version = "1.0.0"
-edition = "2021"
-
-[lib]
-name = "version"
-crate-type = ["cdylib"]
-
-[dependencies]
-windows-sys = { version = "0.59", features = [
-    "Win32_Foundation",
-    "Win32_System_LibraryLoader",
-    "Win32_System_Threading",
-    "Win32_System_Console",
-    "Win32_System_Memory",
-    "Win32_System_SystemInformation",
-    "Win32_System_IO",
-    "Win32_System_Diagnostics_Debug",
-    "Win32_System_Kernel",
-    "Win32_System_ProcessStatus",
-    "Win32_Storage_FileSystem",
-] }
-retour = "0.4.0-alpha.4"
-once_cell = "1"
-toml = "0.8"
-
-[build-dependencies]
-forward-dll = "0.1.11"
+[workspace]
+members = ["loader", "d3d9-proxy"]
+resolver = "2"
 
 [profile.release]
 lto = true

d3d9-proxy/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "d3d9-proxy"
+version = "1.0.0"
+edition = "2021"
+
+[lib]
+name = "d3d9"
+crate-type = ["cdylib"]
+
+[dependencies]
+windows-sys = { version = "0.59", features = [
+    "Win32_Foundation",
+    "Win32_System_LibraryLoader",
+] }
+retour = "0.4.0-alpha.4"

d3d9-proxy/build.rs

@@ -0,0 +1,4 @@
+fn main() {
+    // d3d9.dll 的关键导出只有 Direct3DCreate9，由 lib.rs 手动实现
+    // 不使用 forward-dll，避免跟手动导出冲突
+}

d3d9-proxy/src/config.rs

@@ -0,0 +1,16 @@
+#[derive(Clone)]
+pub struct Config {
+    pub frame_lock: Option<u32>,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            frame_lock: None,
+        }
+    }
+}
+
+pub fn load() -> Config {
+    Config::default()
+}

d3d9-proxy/src/d3d9_wrapper.rs

@@ -0,0 +1,77 @@
+use std::ffi::c_void;
+
+use crate::config::Config;
+use crate::device_wrapper;
+
+// IDirect3D9 vtable index
+const CREATE_DEVICE_INDEX: usize = 16;
+
+static mut ORIG_CREATE_DEVICE: usize = 0;
+static mut D3D9_CONFIG: Option<Config> = None;
+
+pub unsafe fn create(real: *mut c_void, config: Config) -> *mut c_void {
+    D3D9_CONFIG = Some(config);
+    patch_vtable(real);
+    OutputDebugStringA(b"[d3d9proxy] create() called, vtable patched\0".as_ptr());
+    real
+}
+
+unsafe fn patch_vtable(obj: *mut c_void) {
+    let vtable_ptr = *(obj as *mut *mut usize);
+    let slot = vtable_ptr.add(CREATE_DEVICE_INDEX);
+
+    ORIG_CREATE_DEVICE = *slot;
+
+    let mut old_protect = 0u32;
+    VirtualProtect(
+        slot.cast(),
+        std::mem::size_of::<usize>(),
+        0x40, // PAGE_EXECUTE_READWRITE
+        &mut old_protect,
+    );
+    *slot = hooked_create_device as usize;
+    let mut ignored = 0u32;
+    VirtualProtect(
+        slot.cast(),
+        std::mem::size_of::<usize>(),
+        old_protect,
+        &mut ignored,
+    );
+}
+
+// IDirect3D9::CreateDevice(UINT, D3DDEVTYPE, HWND, DWORD, D3DPRESENT_PARAMETERS*, IDirect3DDevice9**)
+unsafe extern "system" fn hooked_create_device(
+    this: *mut c_void,
+    adapter: u32,
+    device_type: u32,
+    focus_window: usize,
+    behavior_flags: u32,
+    present_params: *mut c_void,
+    returned_device: *mut *mut c_void,
+) -> i32 {
+    OutputDebugStringA(b"[d3d9proxy] hooked_create_device ENTERED\0".as_ptr());
+
+    let orig: unsafe extern "system" fn(
+        *mut c_void, u32, u32, usize, u32, *mut c_void, *mut *mut c_void,
+    ) -> i32 = std::mem::transmute(ORIG_CREATE_DEVICE);
+
+    let hr = orig(this, adapter, device_type, focus_window, behavior_flags, present_params, returned_device);
+
+    if hr >= 0 && !returned_device.is_null() && !(*returned_device).is_null() {
+        OutputDebugStringA(b"[d3d9proxy] CreateDevice OK, patching device\0".as_ptr());
+        device_wrapper::GAME_HWND = focus_window;
+        if let Some(cfg) = &D3D9_CONFIG {
+            device_wrapper::patch(*returned_device, cfg.clone());
+        }
+    } else {
+        OutputDebugStringA(b"[d3d9proxy] CreateDevice FAILED\0".as_ptr());
+    }
+
+    hr
+}
+
+#[link(name = "kernel32")]
+extern "system" {
+    fn VirtualProtect(addr: *mut c_void, size: usize, new_protect: u32, old_protect: *mut u32) -> i32;
+    fn OutputDebugStringA(s: *const u8);
+}

d3d9-proxy/src/device_wrapper.rs

@@ -0,0 +1,75 @@
+use std::ffi::c_void;
+
+use retour::GenericDetour;
+
+use crate::config::Config;
+use crate::mod_api;
+use crate::overlay;
+
+// IDirect3DDevice9 vtable index
+const PRESENT_INDEX: usize = 17;
+const END_SCENE_INDEX: usize = 42;
+
+type PresentFn = unsafe extern "system" fn(
+    *mut c_void, *const c_void, *const c_void, usize, *const c_void,
+) -> i32;
+type EndSceneFn = unsafe extern "system" fn(*mut c_void) -> i32;
+
+pub static mut DEVICE_CONFIG: Option<Config> = None;
+pub static mut FPS_STATE: Option<overlay::FpsState> = None;
+pub static mut GAME_HWND: usize = 0;
+
+static mut PRESENT_HOOK: Option<GenericDetour<PresentFn>> = None;
+static mut END_SCENE_HOOK: Option<GenericDetour<EndSceneFn>> = None;
+
+pub unsafe fn patch(device: *mut c_void, mut config: Config) {
+    mod_api::apply_pending(&mut config);
+    let frame_lock = config.frame_lock;
+    DEVICE_CONFIG = Some(config);
+    if frame_lock.is_some() {
+        FPS_STATE = Some(overlay::FpsState::new());
+    }
+    mod_api::set_device(device);
+
+    let vtable = *(device as *const *const usize);
+    let present_addr = *vtable.add(PRESENT_INDEX);
+    let end_scene_addr = *vtable.add(END_SCENE_INDEX);
+
+    let present_fn: PresentFn = std::mem::transmute(present_addr);
+    if let Ok(hook) = GenericDetour::<PresentFn>::new(present_fn, hooked_present) {
+        let _ = hook.enable();
+        PRESENT_HOOK = Some(hook);
+    }
+
+    let end_scene_fn: EndSceneFn = std::mem::transmute(end_scene_addr);
+    if let Ok(hook) = GenericDetour::<EndSceneFn>::new(end_scene_fn, hooked_end_scene) {
+        let _ = hook.enable();
+        END_SCENE_HOOK = Some(hook);
+    }
+}
+
+// IDirect3DDevice9::Present(RECT*, RECT*, HWND, RGNDATA*)
+unsafe extern "system" fn hooked_present(
+    this: *mut c_void,
+    source_rect: *const c_void,
+    dest_rect: *const c_void,
+    dest_window_override: usize,
+    dirty_region: *const c_void,
+) -> i32 {
+    if let Some(state) = &mut FPS_STATE {
+        if let Some(cfg) = &DEVICE_CONFIG {
+            if let Some(target_fps) = cfg.frame_lock {
+                state.frame_lock(target_fps);
+            }
+        }
+    }
+
+    PRESENT_HOOK.as_ref().unwrap().call(this, source_rect, dest_rect, dest_window_override, dirty_region)
+}
+
+// IDirect3DDevice9::EndScene()
+unsafe extern "system" fn hooked_end_scene(this: *mut c_void) -> i32 {
+    mod_api::run_present_callbacks(this);
+
+    END_SCENE_HOOK.as_ref().unwrap().call(this)
+}

d3d9-proxy/src/lib.rs

@@ -0,0 +1,79 @@
+#![allow(non_snake_case, non_camel_case_types)]
+
+mod config;
+mod d3d9_wrapper;
+mod device_wrapper;
+mod mod_api;
+mod overlay;
+
+use std::ffi::c_void;
+use std::ptr;
+use windows_sys::Win32::Foundation::{BOOL, HMODULE, TRUE};
+use windows_sys::Win32::System::LibraryLoader::{DisableThreadLibraryCalls, GetProcAddress, LoadLibraryA};
+
+const DLL_PROCESS_ATTACH: u32 = 1;
+
+static mut REAL_D3D9: HMODULE = ptr::null_mut();
+static mut REAL_DIRECT3D_CREATE9: usize = 0;
+static mut REAL_DIRECT3D_CREATE9_EX: usize = 0;
+
+type Direct3DCreate9Fn = unsafe extern "system" fn(u32) -> *mut c_void;
+type Direct3DCreate9ExFn = unsafe extern "system" fn(u32, *mut *mut c_void) -> i32;
+
+unsafe fn load_real_d3d9() -> bool {
+    let sys_dir = std::env::var("SYSTEMDRIVE").unwrap_or("C:".to_string());
+    let path = format!("{}\\Windows\\SysWOW64\\d3d9.dll\0", sys_dir);
+    REAL_D3D9 = LoadLibraryA(path.as_ptr());
+    if REAL_D3D9.is_null() {
+        return false;
+    }
+    let proc = GetProcAddress(REAL_D3D9, b"Direct3DCreate9\0".as_ptr());
+    REAL_DIRECT3D_CREATE9 = proc.map_or(0, |f| f as usize);
+
+    let proc_ex = GetProcAddress(REAL_D3D9, b"Direct3DCreate9Ex\0".as_ptr());
+    REAL_DIRECT3D_CREATE9_EX = proc_ex.map_or(0, |f| f as usize);
+
+    REAL_DIRECT3D_CREATE9 != 0
+}
+
+#[no_mangle]
+pub unsafe extern "system" fn Direct3DCreate9(sdk_version: u32) -> *mut c_void {
+    if REAL_DIRECT3D_CREATE9 == 0 {
+        return ptr::null_mut();
+    }
+
+    let real_create: Direct3DCreate9Fn = std::mem::transmute(REAL_DIRECT3D_CREATE9);
+    let real_d3d9 = real_create(sdk_version);
+    if real_d3d9.is_null() {
+        return ptr::null_mut();
+    }
+
+    let cfg = config::load();
+    d3d9_wrapper::create(real_d3d9, cfg)
+}
+
+#[no_mangle]
+pub unsafe extern "system" fn Direct3DCreate9Ex(sdk_version: u32, ppd3d: *mut *mut c_void) -> i32 {
+    if REAL_DIRECT3D_CREATE9_EX == 0 {
+        return -1; // D3DERR_NOTAVAILABLE
+    }
+
+    let real_create_ex: Direct3DCreate9ExFn = std::mem::transmute(REAL_DIRECT3D_CREATE9_EX);
+    let hr = real_create_ex(sdk_version, ppd3d);
+    if hr >= 0 && !ppd3d.is_null() && !(*ppd3d).is_null() {
+        let cfg = config::load();
+        *ppd3d = d3d9_wrapper::create(*ppd3d, cfg);
+    }
+    hr
+}
+
+#[no_mangle]
+unsafe extern "system" fn DllMain(h_module: HMODULE, reason: u32, _reserved: *mut c_void) -> BOOL {
+    if reason == DLL_PROCESS_ATTACH {
+        DisableThreadLibraryCalls(h_module);
+        if !load_real_d3d9() {
+            return 0;
+        }
+    }
+    TRUE
+}

d3d9-proxy/src/mod_api.rs

@@ -0,0 +1,85 @@
+use std::ffi::c_void;
+
+use crate::config::Config;
+
+pub type PresentCallbackFn = unsafe extern "C" fn(*mut c_void);
+
+#[repr(C)]
+pub struct D3D9ProxyAPI {
+    pub set_frame_lock: unsafe extern "C" fn(u32),
+    pub get_device: unsafe extern "C" fn() -> *mut c_void,
+    pub get_hwnd: unsafe extern "C" fn() -> usize,
+    pub register_present_callback: unsafe extern "C" fn(PresentCallbackFn),
+}
+
+static API_TABLE: D3D9ProxyAPI = D3D9ProxyAPI {
+    set_frame_lock: api_set_frame_lock,
+    get_device: api_get_device,
+    get_hwnd: api_get_hwnd,
+    register_present_callback: api_register_present_callback,
+};
+
+static mut DEVICE_PTR: *mut c_void = std::ptr::null_mut();
+static mut PRESENT_CALLBACKS: [Option<PresentCallbackFn>; 8] = [None; 8];
+static mut PENDING: PendingConfig = PendingConfig::new();
+
+struct PendingConfig {
+    frame_lock: Option<u32>,
+}
+
+impl PendingConfig {
+    const fn new() -> Self {
+        Self { frame_lock: None }
+    }
+}
+
+pub fn set_device(device: *mut c_void) {
+    unsafe { DEVICE_PTR = device; }
+}
+
+pub fn apply_pending(config: &mut Config) {
+    unsafe {
+        if let Some(fps) = PENDING.frame_lock {
+            config.frame_lock = Some(fps);
+        }
+    }
+}
+
+pub fn run_present_callbacks(device: *mut c_void) {
+    unsafe {
+        for cb in &PRESENT_CALLBACKS {
+            if let Some(f) = cb {
+                f(device);
+            }
+        }
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn d3d9proxy_get_api() -> *const D3D9ProxyAPI {
+    &API_TABLE
+}
+
+unsafe extern "C" fn api_set_frame_lock(fps: u32) {
+    PENDING.frame_lock = if fps > 0 { Some(fps) } else { None };
+    if let Some(cfg) = &mut crate::device_wrapper::DEVICE_CONFIG {
+        cfg.frame_lock = if fps > 0 { Some(fps) } else { None };
+    }
+}
+
+unsafe extern "C" fn api_get_device() -> *mut c_void {
+    DEVICE_PTR
+}
+
+unsafe extern "C" fn api_get_hwnd() -> usize {
+    crate::device_wrapper::GAME_HWND
+}
+
+unsafe extern "C" fn api_register_present_callback(cb: PresentCallbackFn) {
+    for slot in &mut PRESENT_CALLBACKS {
+        if slot.is_none() {
+            *slot = Some(cb);
+            return;
+        }
+    }
+}