#![allow(non_snake_case, non_camel_case_types, dead_code)]
use core::ffi::c_void;
use crate::sys_win::*;
use crate::sys_win::win_fn_types;
use crate::D3dDriver;
type Slot = *const c_void;
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct Guid { pub a: u32, pub b: u16, pub c: u16, pub d: [u8; 8] }
const IID_IDXGIDevice: Guid = Guid { a: 0x54ec77fa, b: 0x1377, c: 0x44e6, d: [0x8c, 0x32, 0x88, 0xfd, 0x5f, 0x44, 0xc8, 0x4c] };
const IID_IDXGIFactory2: Guid = Guid { a: 0x50c83a1c, b: 0xe072, c: 0x4c48, d: [0x87, 0xb0, 0x36, 0x30, 0xfa, 0x36, 0xa6, 0xd0] };
const IID_IDXGISwapChain2: Guid = Guid { a: 0xa8be2ac4, b: 0x199f, c: 0x4946, d: [0xb3, 0x31, 0x79, 0x59, 0x9f, 0xb9, 0x8d, 0xe7] };
const IID_ID3D11Texture2D: Guid = Guid { a: 0x6f15aaf2, b: 0xd208, c: 0x4e89, d: [0x9a, 0xb4, 0x48, 0x95, 0x35, 0xd3, 0x4f, 0x9c] };
#[repr(C)] #[derive(Clone, Copy, Default)]
pub struct DXGI_SAMPLE_DESC { pub Count: u32, pub Quality: u32 }
#[repr(C)] #[derive(Clone, Copy, Default)]
pub struct DXGI_SWAP_CHAIN_DESC1 {
pub Width: u32, pub Height: u32, pub Format: u32, pub Stereo: BOOL,
pub SampleDesc: DXGI_SAMPLE_DESC, pub BufferUsage: u32, pub BufferCount: u32,
pub Scaling: u32, pub SwapEffect: u32, pub AlphaMode: u32, pub Flags: u32,
}
#[repr(C)] #[derive(Clone, Copy, Default)]
pub struct D3D11_TEXTURE2D_DESC {
pub Width: u32, pub Height: u32, pub MipLevels: u32, pub ArraySize: u32,
pub Format: u32, pub SampleDesc: DXGI_SAMPLE_DESC, pub Usage: u32,
pub BindFlags: u32, pub CPUAccessFlags: u32, pub MiscFlags: u32,
}
#[repr(C)] #[derive(Clone, Copy, Default)]
pub struct D3D11_BOX { pub left: u32, pub top: u32, pub front: u32, pub right: u32, pub bottom: u32, pub back: u32 }
#[repr(C)] #[derive(Clone, Copy, Default)]
pub struct DXGI_FRAME_STATISTICS {
pub PresentCount: u32, pub PresentRefreshCount: u32, pub SyncRefreshCount: u32,
pub SyncQPCTime: i64, pub SyncGPUTime: i64,
}
const DXGI_FORMAT_B8G8R8A8_UNORM: u32 = 87;
const DXGI_USAGE_RENDER_TARGET_OUTPUT: u32 = 0x20;
const DXGI_SCALING_NONE: u32 = 1;
const DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL: u32 = 3;
const DXGI_SWAP_EFFECT_FLIP_DISCARD: u32 = 4;
const DXGI_ALPHA_MODE_IGNORE: u32 = 3;
const DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT: u32 = 0x40;
const DXGI_MWA_NO_ALT_ENTER: u32 = 2;
const D3D_DRIVER_TYPE_HARDWARE: u32 = 1;
const D3D_DRIVER_TYPE_WARP: u32 = 5;
const D3D11_SDK_VERSION: u32 = 7;
const D3D11_USAGE_DEFAULT: u32 = 0;
const DXGI_STATUS_OCCLUDED: i32 = 0x087A0001u32 as i32;
const DXGI_ERROR_DEVICE_REMOVED: i32 = 0x887A0005u32 as i32;
const DXGI_ERROR_DEVICE_RESET: i32 = 0x887A0007u32 as i32;
const DXGI_ERROR_FRAME_STATISTICS_DISJOINT: i32 = 0x887A000Bu32 as i32;
const FEATURE_LEVELS: [u32; 6] = [0xb000, 0xa100, 0xa000, 0x9300, 0x9200, 0x9100];
win_fn_types! {
FnRelease = fn(*mut c_void) -> u32;
FnQueryInterface = fn(*mut c_void, *const Guid, *mut *mut c_void) -> i32;
FnGetParent = fn(*mut c_void, *const Guid, *mut *mut c_void) -> i32;
FnGetAdapter = fn(*mut c_void, *mut *mut c_void) -> i32;
FnCreateTexture2D = fn(*mut c_void, *const D3D11_TEXTURE2D_DESC, *const c_void, *mut *mut c_void) -> i32;
FnUpdateSubresource = fn(*mut c_void, *mut c_void, u32, *const D3D11_BOX, *const c_void, u32, u32);
FnCopySubresourceRegion = fn(*mut c_void, *mut c_void, u32, u32, u32, u32, *mut c_void, u32, *const D3D11_BOX);
FnMakeWindowAssociation = fn(*mut c_void, HWND, u32) -> i32;
FnCreateSwapChainForHwnd = fn(*mut c_void, *mut c_void, HWND, *const DXGI_SWAP_CHAIN_DESC1, *const c_void, *mut c_void, *mut *mut c_void) -> i32;
FnPresent = fn(*mut c_void, u32, u32) -> i32;
FnGetBuffer = fn(*mut c_void, u32, *const Guid, *mut *mut c_void) -> i32;
FnResizeBuffers = fn(*mut c_void, u32, u32, u32, u32, u32) -> i32;
FnGetFrameStatistics = fn(*mut c_void, *mut DXGI_FRAME_STATISTICS) -> i32;
FnSetMaximumFrameLatency = fn(*mut c_void, u32) -> i32;
FnGetFrameLatencyWaitableObject = fn(*mut c_void) -> HANDLE;
FnD3D11CreateDevice = fn(*mut c_void, u32, HMODULE, u32, *const u32, u32, u32, *mut *mut c_void, *mut u32, *mut *mut c_void) -> i32;
}
#[repr(C)]
struct IUnknownVtbl { query_interface: FnQueryInterface, add_ref: Slot, release: FnRelease }
#[repr(C)]
struct IDXGIDeviceVtbl {
base: IUnknownVtbl,
_obj: [Slot; 4], get_adapter: FnGetAdapter, }
#[repr(C)]
struct IDXGIObjectVtbl {
base: IUnknownVtbl,
_priv: [Slot; 3], get_parent: FnGetParent, }
#[repr(C)]
struct IDXGIFactory2Vtbl {
base: IUnknownVtbl,
_obj: [Slot; 4],
_enum_adapters: Slot, make_window_association: FnMakeWindowAssociation, _rest_factory: [Slot; 3], _factory1: [Slot; 2], _stereo: Slot, create_swap_chain_for_hwnd: FnCreateSwapChainForHwnd, }
#[repr(C)]
struct ID3D11DeviceVtbl {
base: IUnknownVtbl,
_create_buffer: Slot, _create_texture1d: Slot, create_texture2d: FnCreateTexture2D, }
#[repr(C)]
struct ID3D11DeviceContextVtbl {
base: IUnknownVtbl,
_child: [Slot; 4], _unused: [Slot; 39], copy_subresource_region: FnCopySubresourceRegion, _copy_resource: Slot, update_subresource: FnUpdateSubresource, }
#[repr(C)]
struct IDXGISwapChain2Vtbl {
base: IUnknownVtbl,
_obj: [Slot; 4], _get_device: Slot, present: FnPresent, get_buffer: FnGetBuffer, _fullscreen: [Slot; 2], _get_desc: Slot, resize_buffers: FnResizeBuffers, _resize_target: Slot, _containing_output: Slot, get_frame_statistics: FnGetFrameStatistics, _last_present_count: Slot, _sc1: [Slot; 11], _source_size: [Slot; 2], set_maximum_frame_latency: FnSetMaximumFrameLatency, _get_max_latency: Slot, get_frame_latency_waitable_object: FnGetFrameLatencyWaitableObject, }
const PTR: usize = core::mem::size_of::<usize>();
const _: () = assert!(core::mem::offset_of!(ID3D11DeviceContextVtbl, copy_subresource_region) == 46 * PTR);
const _: () = assert!(core::mem::offset_of!(ID3D11DeviceContextVtbl, update_subresource) == 48 * PTR);
const _: () = assert!(core::mem::offset_of!(IDXGISwapChain2Vtbl, present) == 8 * PTR);
const _: () = assert!(core::mem::offset_of!(IDXGISwapChain2Vtbl, resize_buffers) == 13 * PTR);
const _: () = assert!(core::mem::offset_of!(IDXGISwapChain2Vtbl, get_frame_statistics) == 16 * PTR);
const _: () = assert!(core::mem::offset_of!(IDXGISwapChain2Vtbl, set_maximum_frame_latency) == 31 * PTR);
const _: () = assert!(core::mem::offset_of!(IDXGISwapChain2Vtbl, get_frame_latency_waitable_object) == 33 * PTR);
const _: () = assert!(core::mem::offset_of!(IDXGIFactory2Vtbl, create_swap_chain_for_hwnd) == 15 * PTR);
const _: () = assert!(core::mem::offset_of!(IDXGIFactory2Vtbl, make_window_association) == 8 * PTR);
const _: () = assert!(core::mem::offset_of!(ID3D11DeviceVtbl, create_texture2d) == 5 * PTR);
const _: () = assert!(core::mem::offset_of!(IDXGIDeviceVtbl, get_adapter) == 7 * PTR);
const _: () = assert!(core::mem::offset_of!(IDXGIObjectVtbl, get_parent) == 6 * PTR);
#[inline]
unsafe fn vt<T>(p: *mut c_void) -> *const T { unsafe { *(p as *const *const T) } }
unsafe fn release(p: *mut c_void) {
if !p.is_null() { unsafe { ((*vt::<IUnknownVtbl>(p)).release)(p) }; }
}
pub struct D3d {
device: *mut c_void,
ctx: *mut c_void,
swap: *mut c_void,
tex: *mut c_void,
tex_side: u32,
pub waitable: HANDLE,
last_refresh: u32,
last_present: u32,
have_refresh: bool,
owed: u64,
submitted: u32,
pub in_flight: u32,
submit_qpc: [i64; 256],
lat_n: u32, lat_sum: i64, lat_min: i64, lat_max: i64,
last_stat_present: u32,
pub occluded: bool,
debug: bool,
dbg_n: u32,
}
unsafe impl Send for D3d {}
impl D3d {
pub fn new(hwnd: HWND, debug: bool, driver: D3dDriver) -> Option<D3d> {
unsafe {
let d3d11 = LoadLibraryW(wide("d3d11.dll").as_ptr());
if d3d11.is_null() { return None; }
let create: Option<FnD3D11CreateDevice> =
core::mem::transmute(GetProcAddress(d3d11, b"D3D11CreateDevice\0".as_ptr()));
let create = create?;
let mut device: *mut c_void = core::ptr::null_mut();
let mut ctx: *mut c_void = core::ptr::null_mut();
let mut got_level: u32 = 0;
let mut hr = -1;
let drivers: &[u32] = match driver {
D3dDriver::Warp => &[D3D_DRIVER_TYPE_WARP],
D3dDriver::Hardware => &[D3D_DRIVER_TYPE_HARDWARE],
D3dDriver::Auto if cfg!(cosmo) => &[D3D_DRIVER_TYPE_WARP],
D3dDriver::Auto => &[D3D_DRIVER_TYPE_HARDWARE, D3D_DRIVER_TYPE_WARP],
};
for &driver in drivers {
hr = create(core::ptr::null_mut(), driver, NULL, 0,
FEATURE_LEVELS.as_ptr(), FEATURE_LEVELS.len() as u32,
D3D11_SDK_VERSION, &mut device, &mut got_level, &mut ctx);
if hr >= 0 { if debug { eprintln!("softer_gui: d3d11 driver {driver}, feature level {got_level:#x}"); } break; }
}
if hr < 0 || device.is_null() || ctx.is_null() { return None; }
let mut dxgi_dev: *mut c_void = core::ptr::null_mut();
if ((*vt::<IUnknownVtbl>(device)).query_interface)(device, &IID_IDXGIDevice, &mut dxgi_dev) < 0 {
release(ctx); release(device); return None;
}
let mut adapter: *mut c_void = core::ptr::null_mut();
let ok = ((*vt::<IDXGIDeviceVtbl>(dxgi_dev)).get_adapter)(dxgi_dev, &mut adapter) >= 0;
release(dxgi_dev);
if !ok { release(ctx); release(device); return None; }
let mut factory: *mut c_void = core::ptr::null_mut();
let ok = ((*vt::<IDXGIObjectVtbl>(adapter)).get_parent)(adapter, &IID_IDXGIFactory2, &mut factory) >= 0;
release(adapter);
if !ok { release(ctx); release(device); return None; }
let mut r = RECT::default();
GetClientRect(hwnd, &mut r);
let (w, h) = ((r.right - r.left).max(1) as u32, (r.bottom - r.top).max(1) as u32);
let mut swap1: *mut c_void = core::ptr::null_mut();
let mut made = false;
for effect in [DXGI_SWAP_EFFECT_FLIP_DISCARD, DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL] {
let desc = DXGI_SWAP_CHAIN_DESC1 {
Width: w, Height: h,
Format: DXGI_FORMAT_B8G8R8A8_UNORM, Stereo: 0,
SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 },
BufferUsage: DXGI_USAGE_RENDER_TARGET_OUTPUT,
BufferCount: 2, Scaling: DXGI_SCALING_NONE,
SwapEffect: effect,
AlphaMode: DXGI_ALPHA_MODE_IGNORE,
Flags: DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT,
};
if ((*vt::<IDXGIFactory2Vtbl>(factory)).create_swap_chain_for_hwnd)(
factory, device, hwnd, &desc, core::ptr::null(), core::ptr::null_mut(), &mut swap1) >= 0 {
made = true;
if debug { eprintln!("softer_gui: swap effect {effect}"); }
break;
}
}
if !made {
((*vt::<IDXGIFactory2Vtbl>(factory)).make_window_association)(factory, hwnd, DXGI_MWA_NO_ALT_ENTER);
release(factory); release(ctx); release(device);
return None;
}
((*vt::<IDXGIFactory2Vtbl>(factory)).make_window_association)(factory, hwnd, DXGI_MWA_NO_ALT_ENTER);
release(factory);
let mut swap: *mut c_void = core::ptr::null_mut();
let hr_qi = ((*vt::<IUnknownVtbl>(swap1)).query_interface)(swap1, &IID_IDXGISwapChain2, &mut swap);
release(swap1);
if hr_qi < 0 {
if debug { eprintln!("softer_gui: IDXGISwapChain2 QI failed hr={hr_qi:#x} (pre-8.1?)"); }
release(ctx); release(device); return None;
}
let scv = vt::<IDXGISwapChain2Vtbl>(swap);
((*scv).set_maximum_frame_latency)(swap, 1);
let waitable = ((*scv).get_frame_latency_waitable_object)(swap);
if waitable.is_null() {
if debug { eprintln!("softer_gui: no frame-latency waitable object"); }
release(swap); release(ctx); release(device); return None;
}
Some(D3d { device, ctx, swap, tex: core::ptr::null_mut(), tex_side: 0,
waitable, last_refresh: 0, last_present: 0, have_refresh: false, owed: 0, submitted: 0, in_flight: 0,
submit_qpc: [0; 256], lat_n: 0, lat_sum: 0, lat_min: i64::MAX, lat_max: 0,
last_stat_present: 0,
occluded: false, debug, dbg_n: 0 })
}
}
unsafe fn ensure_texture(&mut self, side: u32) -> bool {
if !self.tex.is_null() && self.tex_side == side { return true; }
unsafe {
release(self.tex);
self.tex = core::ptr::null_mut();
let desc = D3D11_TEXTURE2D_DESC {
Width: side, Height: side, MipLevels: 1, ArraySize: 1,
Format: DXGI_FORMAT_B8G8R8A8_UNORM,
SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 },
Usage: D3D11_USAGE_DEFAULT, BindFlags: 0, CPUAccessFlags: 0, MiscFlags: 0,
};
let mut tex: *mut c_void = core::ptr::null_mut();
if ((*vt::<ID3D11DeviceVtbl>(self.device)).create_texture2d)(self.device, &desc, core::ptr::null(), &mut tex) < 0 {
return false;
}
self.tex = tex;
self.tex_side = side;
true
}
}
pub fn present(&mut self, pixels: *const u32, side: u32, w: u32, h: u32) -> bool {
if w == 0 || h == 0 { return true; }
unsafe {
if !self.ensure_texture(side) { return false; }
let ctxv = vt::<ID3D11DeviceContextVtbl>(self.ctx);
let box_ = D3D11_BOX { left: 0, top: 0, front: 0, right: w, bottom: h, back: 1 };
((*ctxv).update_subresource)(self.ctx, self.tex, 0, &box_, pixels as *const c_void, side * 4, 0);
let scv = vt::<IDXGISwapChain2Vtbl>(self.swap);
let mut back: *mut c_void = core::ptr::null_mut();
if ((*scv).get_buffer)(self.swap, 0, &IID_ID3D11Texture2D, &mut back) < 0 { return false; }
((*ctxv).copy_subresource_region)(self.ctx, back, 0, 0, 0, 0, self.tex, 0, &box_);
release(back);
self.submit_qpc[(self.submitted.wrapping_add(1) & 255) as usize] = qpc();
let hr = ((*scv).present)(self.swap, 1, 0);
self.submitted = self.submitted.wrapping_add(1);
self.occluded = hr == DXGI_STATUS_OCCLUDED;
if hr == DXGI_ERROR_DEVICE_REMOVED || hr == DXGI_ERROR_DEVICE_RESET { return false; }
true
}
}
pub fn frames_elapsed(&mut self, period_qpc: i64) -> u64 {
unsafe {
let mut st = DXGI_FRAME_STATISTICS::default();
let hr = ((*vt::<IDXGISwapChain2Vtbl>(self.swap)).get_frame_statistics)(self.swap, &mut st);
if hr == DXGI_ERROR_FRAME_STATISTICS_DISJOINT {
self.have_refresh = false;
self.owed = 0;
return 1;
}
if hr >= 0 && st.PresentRefreshCount != 0 {
if self.have_refresh {
let d_ref = st.PresentRefreshCount.wrapping_sub(self.last_refresh) as u64;
let d_pres = st.PresentCount.wrapping_sub(self.last_present) as u64;
if d_ref > d_pres { self.owed += d_ref - d_pres; }
}
self.last_refresh = st.PresentRefreshCount;
self.last_present = st.PresentCount;
self.have_refresh = true;
}
if period_qpc > 0 && st.PresentCount != self.last_stat_present && st.PresentCount != 0 {
self.last_stat_present = st.PresentCount;
let behind = st.SyncRefreshCount as i64 - st.PresentRefreshCount as i64;
if (0..600).contains(&behind) {
let shown_qpc = st.SyncQPCTime - behind * period_qpc;
let sent = self.submit_qpc[(st.PresentCount & 255) as usize];
if sent != 0 && shown_qpc > sent {
let us = (shown_qpc - sent) * 1_000_000 / qpf();
if us < 1_000_000 {
self.lat_n += 1;
self.lat_sum += us;
self.lat_min = self.lat_min.min(us);
self.lat_max = self.lat_max.max(us);
if self.debug && self.lat_n % 8 == 0 {
eprintln!("softer_gui: latency submit->scanout n={} mean={}us min={}us max={}us",
self.lat_n, self.lat_sum / self.lat_n as i64, self.lat_min, self.lat_max);
}
}
}
}
}
let take = self.owed.min(7);
self.owed -= take;
self.in_flight = self.submitted.wrapping_sub(st.PresentCount);
1 + take
}
}
pub fn resize(&mut self, w: u32, h: u32) {
if w == 0 || h == 0 { return; }
unsafe {
let hr = ((*vt::<IDXGISwapChain2Vtbl>(self.swap)).resize_buffers)(
self.swap, 0, w, h, 0, DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT);
let _ = hr;
self.have_refresh = false;
}
}
}
impl Drop for D3d {
fn drop(&mut self) {
unsafe {
release(self.tex);
release(self.swap);
release(self.ctx);
release(self.device);
}
}
}