hudhook 0.3.0

A graphics API hook with dear imgui render loop. Supports DirectX 11 and 12.
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use std::ptr::null_mut;

use imgui::{DrawListIterator, DrawVert};
use windows::Win32::Graphics::Direct3D11::{
    ID3D11Buffer, D3D11_BIND_CONSTANT_BUFFER, D3D11_BIND_INDEX_BUFFER, D3D11_BIND_VERTEX_BUFFER,
    D3D11_BUFFER_DESC, D3D11_CPU_ACCESS_WRITE, D3D11_USAGE_DYNAMIC,
};

use super::device_and_swapchain::DeviceAndSwapChain;

pub(crate) struct Buffers {
    vtx_buffer: ID3D11Buffer,
    idx_buffer: ID3D11Buffer,
    mtx_buffer: ID3D11Buffer,

    vtx_count: usize,
    idx_count: usize,
}

#[repr(transparent)]
struct VertexConstantBuffer([[f32; 4]; 4]);

impl Buffers {
    pub(crate) fn new(dasc: &DeviceAndSwapChain) -> Self {
        let mtx_buffer = unsafe {
            dasc.dev()
                .CreateBuffer(
                    &D3D11_BUFFER_DESC {
                        ByteWidth: std::mem::size_of::<VertexConstantBuffer>() as u32,
                        Usage: D3D11_USAGE_DYNAMIC,
                        BindFlags: D3D11_BIND_CONSTANT_BUFFER.0,
                        CPUAccessFlags: D3D11_CPU_ACCESS_WRITE.0,
                        MiscFlags: 0,
                        StructureByteStride: 0,
                    } as *const _,
                    null_mut(),
                )
                .expect("CreateBuffer")
        };

        let vtx_buffer = Buffers::create_vertex_buffer(dasc, 1);
        let idx_buffer = Buffers::create_index_buffer(dasc, 1);

        Buffers { vtx_buffer, idx_buffer, mtx_buffer, vtx_count: 1, idx_count: 1 }
    }

    pub(crate) fn set_constant_buffer(&mut self, dasc: &DeviceAndSwapChain, rect: [f32; 4]) {
        let [l, t, r, b] = rect;

        dasc.with_mapped(&self.mtx_buffer, |ms| unsafe {
            std::ptr::copy_nonoverlapping(
                &VertexConstantBuffer([
                    [2. / (r - l), 0., 0., 0.],
                    [0., 2. / (t - b), 0., 0.],
                    [0., 0., 0.5, 0.],
                    [(r + l) / (l - r), (t + b) / (b - t), 0.5, 1.0],
                ]),
                ms.pData as *mut _,
                1,
            );
        })
    }

    pub(crate) fn set_buffers(&mut self, dasc: &DeviceAndSwapChain, meshes: DrawListIterator) {
        let (vertices, indices): (Vec<DrawVert>, Vec<u16>) = meshes
            .map(|m| (m.vtx_buffer().iter(), m.idx_buffer().iter()))
            .fold((Vec::new(), Vec::new()), |(mut ov, mut oi), (v, i)| {
                ov.extend(v);
                oi.extend(i);
                (ov, oi)
            });

        self.resize(dasc, vertices.len(), indices.len());

        dasc.with_mapped(&self.vtx_buffer, |ms| unsafe {
            std::ptr::copy_nonoverlapping(vertices.as_ptr(), ms.pData as _, vertices.len());
        });

        dasc.with_mapped(&self.idx_buffer, |ms| unsafe {
            std::ptr::copy_nonoverlapping(indices.as_ptr(), ms.pData as _, indices.len());
        });
    }

    pub(crate) fn resize(&mut self, dasc: &DeviceAndSwapChain, vtx_count: usize, idx_count: usize) {
        if self.vtx_count <= vtx_count || (self.vtx_count == 0 && vtx_count == 0) {
            // unsafe { self.vtx_buffer.as_ref().Release() };
            self.vtx_count = vtx_count + 4096;
            self.vtx_buffer = Buffers::create_vertex_buffer(dasc, self.vtx_count);
        }

        if self.idx_count <= idx_count || (self.idx_count == 0 && idx_count == 0) {
            // unsafe { self.idx_buffer.as_ref().Release() };
            self.idx_count = idx_count + 4096;
            self.idx_buffer = Buffers::create_index_buffer(dasc, self.idx_count);
        }
    }

    pub(crate) fn create_vertex_buffer(dasc: &DeviceAndSwapChain, size: usize) -> ID3D11Buffer {
        unsafe {
            dasc.dev()
                .CreateBuffer(
                    &D3D11_BUFFER_DESC {
                        Usage: D3D11_USAGE_DYNAMIC,
                        ByteWidth: (size * std::mem::size_of::<imgui::DrawVert>()) as u32,
                        BindFlags: D3D11_BIND_VERTEX_BUFFER.0,
                        CPUAccessFlags: D3D11_CPU_ACCESS_WRITE.0,
                        MiscFlags: 0,
                        StructureByteStride: 0,
                    },
                    null_mut(),
                )
                .expect("CreateBuffer")
        }
    }

    pub(crate) fn create_index_buffer(dasc: &DeviceAndSwapChain, size: usize) -> ID3D11Buffer {
        unsafe {
            dasc.dev()
                .CreateBuffer(
                    &D3D11_BUFFER_DESC {
                        Usage: D3D11_USAGE_DYNAMIC,
                        ByteWidth: (size * std::mem::size_of::<u32>()) as u32,
                        BindFlags: D3D11_BIND_INDEX_BUFFER.0,
                        CPUAccessFlags: D3D11_CPU_ACCESS_WRITE.0,
                        MiscFlags: 0,
                        StructureByteStride: 0,
                    },
                    null_mut(),
                )
                .expect("CreateBuffer")
        }
    }

    pub(crate) fn vtx_buffer(&self) -> ID3D11Buffer {
        self.vtx_buffer.clone()
    }

    pub(crate) fn idx_buffer(&self) -> ID3D11Buffer {
        self.idx_buffer.clone()
    }

    pub(crate) fn mtx_buffer(&self) -> ID3D11Buffer {
        self.mtx_buffer.clone()
    }
}