dxwr 0.4.3

Direct3D12 and DXGI wrapper library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use super::utility::dxgi_factory;
use std::sync::Arc;
use windows::Win32::Foundation::LUID;
use windows::Win32::Graphics::Dxgi::*;
use windows::core::Interface;

#[derive(Clone, PartialEq, Eq, Debug)]
pub struct AdapterId {
    pub vendor_id: u32,
    pub device_id: u32,
    pub sub_sys_id: u32,
    pub revision: u32,
}

#[derive(Clone, PartialEq, Eq, Debug)]
pub struct AdapterMemoryInfo {
    pub dedicate_video_memory: usize,
    pub dedicate_system_memory: usize,
    pub shared_system_memory: usize,
}

#[derive(Clone, Debug)]
pub struct Adapter {
    handle: IDXGIAdapter4,
    desc: Arc<DXGI_ADAPTER_DESC3>,
}

impl Adapter {
    #[inline]
    pub fn description(&self) -> String {
        let len = self
            .desc
            .Description
            .iter()
            .position(|d| *d == 0)
            .unwrap_or(self.desc.Description.len());
        String::from_utf16_lossy(&self.desc.Description[..len])
    }

    #[inline]
    pub fn id(&self) -> AdapterId {
        AdapterId {
            vendor_id: self.desc.VendorId,
            device_id: self.desc.DeviceId,
            sub_sys_id: self.desc.SubSysId,
            revision: self.desc.Revision,
        }
    }

    #[inline]
    pub fn memory_info(&self) -> AdapterMemoryInfo {
        AdapterMemoryInfo {
            dedicate_video_memory: self.desc.DedicatedVideoMemory,
            dedicate_system_memory: self.desc.DedicatedSystemMemory,
            shared_system_memory: self.desc.SharedSystemMemory,
        }
    }

    #[inline]
    pub fn flags(&self) -> DXGI_ADAPTER_FLAG3 {
        self.desc.Flags
    }

    #[inline]
    pub fn luid(&self) -> LUID {
        self.desc.AdapterLuid
    }

    #[inline]
    pub fn graphics_preemption_granularity(&self) -> DXGI_GRAPHICS_PREEMPTION_GRANULARITY {
        self.desc.GraphicsPreemptionGranularity
    }

    #[inline]
    pub fn compute_preemption_granularity(&self) -> DXGI_COMPUTE_PREEMPTION_GRANULARITY {
        self.desc.ComputePreemptionGranularity
    }

    #[inline]
    pub fn handle(&self) -> &IDXGIAdapter4 {
        &self.handle
    }
}

pub fn enum_adapters() -> windows::core::Result<Vec<Adapter>> {
    let factory = dxgi_factory();
    let mut adapters = vec![];
    let mut index = 0;
    unsafe {
        loop {
            let ret = factory.EnumAdapters1(index);
            match ret {
                Ok(adapter) => {
                    let handle = adapter.cast::<IDXGIAdapter4>().unwrap();
                    let desc = handle.GetDesc3()?;
                    adapters.push(Adapter {
                        handle,
                        desc: Arc::new(desc),
                    });
                    index += 1;
                }
                Err(e) if e.code() == DXGI_ERROR_NOT_FOUND => break,
                Err(e) => return Err(e),
            }
        }
    }
    Ok(adapters)
}

#[inline]
pub fn enum_warp_adapter() -> windows::core::Result<Adapter> {
    let factory = dxgi_factory();
    let handle: IDXGIAdapter4 = unsafe { factory.EnumWarpAdapter()? };
    let desc = unsafe { handle.GetDesc3()? };
    Ok(Adapter {
        handle,
        desc: Arc::new(desc),
    })
}