locum 0.1.4

//! Generated by `cargo xtask gen` from the `windows` crate's `ID3D12CommandQueue_Vtbl`; do not edit.

#![allow(
    non_snake_case,
    clippy::too_many_arguments,
    clippy::missing_safety_doc,
    dead_code
)]

use core::ffi::c_void;

/// Every method of `ID3D12CommandQueue` in vtable order. The defaults forward to the wrapped object [`Queue12Methods::inner`].
///
/// # Safety
/// The implementing type must be `#[repr(C)]` with a pointer to [`vtable`]'s table as its first field,
/// and `inner` must return a live `ID3D12CommandQueue`.
pub unsafe trait Queue12Methods: Sized {
    /// The wrapped object, an `ID3D12CommandQueue`.
    fn inner(&self) -> *mut c_void;
    unsafe fn QueryInterface(
        &self,
        iid: *const windows::core::GUID,
        out: *mut *mut c_void,
    ) -> windows::core::HRESULT;
    unsafe fn AddRef(&self) -> u32;
    unsafe fn Release(&self) -> u32;
    unsafe fn GetPrivateData(
        &self,
        a0: *const windows::core::GUID,
        a1: *mut u32,
        a2: *mut core::ffi::c_void,
    ) -> windows::core::HRESULT {
        unsafe { real::GetPrivateData(self.inner(), a0, a1, a2) }
    }
    unsafe fn SetPrivateData(
        &self,
        a0: *const windows::core::GUID,
        a1: u32,
        a2: *const core::ffi::c_void,
    ) -> windows::core::HRESULT {
        unsafe { real::SetPrivateData(self.inner(), a0, a1, a2) }
    }
    unsafe fn SetPrivateDataInterface(
        &self,
        a0: *const windows::core::GUID,
        a1: *mut core::ffi::c_void,
    ) -> windows::core::HRESULT {
        unsafe { real::SetPrivateDataInterface(self.inner(), a0, a1) }
    }
    unsafe fn SetName(&self, a0: windows::core::PCWSTR) -> windows::core::HRESULT {
        unsafe { real::SetName(self.inner(), a0) }
    }
    unsafe fn GetDevice(
        &self,
        a0: *const windows::core::GUID,
        a1: *mut *mut core::ffi::c_void,
    ) -> windows::core::HRESULT {
        unsafe { real::GetDevice(self.inner(), a0, a1) }
    }
    unsafe fn UpdateTileMappings(
        &self,
        a0: *mut core::ffi::c_void,
        a1: u32,
        a2: *const windows::Win32::Graphics::Direct3D12::D3D12_TILED_RESOURCE_COORDINATE,
        a3: *const windows::Win32::Graphics::Direct3D12::D3D12_TILE_REGION_SIZE,
        a4: *mut core::ffi::c_void,
        a5: u32,
        a6: *const windows::Win32::Graphics::Direct3D12::D3D12_TILE_RANGE_FLAGS,
        a7: *const u32,
        a8: *const u32,
        a9: windows::Win32::Graphics::Direct3D12::D3D12_TILE_MAPPING_FLAGS,
    ) {
        unsafe { real::UpdateTileMappings(self.inner(), a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) }
    }
    unsafe fn CopyTileMappings(
        &self,
        a0: *mut core::ffi::c_void,
        a1: *const windows::Win32::Graphics::Direct3D12::D3D12_TILED_RESOURCE_COORDINATE,
        a2: *mut core::ffi::c_void,
        a3: *const windows::Win32::Graphics::Direct3D12::D3D12_TILED_RESOURCE_COORDINATE,
        a4: *const windows::Win32::Graphics::Direct3D12::D3D12_TILE_REGION_SIZE,
        a5: windows::Win32::Graphics::Direct3D12::D3D12_TILE_MAPPING_FLAGS,
    ) {
        unsafe { real::CopyTileMappings(self.inner(), a0, a1, a2, a3, a4, a5) }
    }
    unsafe fn ExecuteCommandLists(&self, a0: u32, a1: *const *mut core::ffi::c_void) {
        unsafe { real::ExecuteCommandLists(self.inner(), a0, a1) }
    }
    unsafe fn SetMarker(&self, a0: u32, a1: *const core::ffi::c_void, a2: u32) {
        unsafe { real::SetMarker(self.inner(), a0, a1, a2) }
    }
    unsafe fn BeginEvent(&self, a0: u32, a1: *const core::ffi::c_void, a2: u32) {
        unsafe { real::BeginEvent(self.inner(), a0, a1, a2) }
    }
    unsafe fn EndEvent(&self) {
        unsafe { real::EndEvent(self.inner()) }
    }
    unsafe fn Signal(&self, a0: *mut core::ffi::c_void, a1: u64) -> windows::core::HRESULT {
        unsafe { real::Signal(self.inner(), a0, a1) }
    }
    unsafe fn Wait(&self, a0: *mut core::ffi::c_void, a1: u64) -> windows::core::HRESULT {
        unsafe { real::Wait(self.inner(), a0, a1) }
    }
    unsafe fn GetTimestampFrequency(&self, a0: *mut u64) -> windows::core::HRESULT {
        unsafe { real::GetTimestampFrequency(self.inner(), a0) }
    }
    unsafe fn GetClockCalibration(&self, a0: *mut u64, a1: *mut u64) -> windows::core::HRESULT {
        unsafe { real::GetClockCalibration(self.inner(), a0, a1) }
    }
    unsafe fn GetDesc(&self, a0: *mut windows::Win32::Graphics::Direct3D12::D3D12_COMMAND_QUEUE_DESC) {
        unsafe { real::GetDesc(self.inner(), a0) }
    }
}

/// Each method called on the real (wrapped) object: the trait's defaults, and overrides that still want the
/// real behaviour.
pub mod real {
    use core::ffi::c_void;

    /// `GetPrivateData` on the real object.
    pub unsafe fn GetPrivateData(
        inner: *mut c_void,
        a0: *const windows::core::GUID,
        a1: *mut u32,
        a2: *mut core::ffi::c_void,
    ) -> windows::core::HRESULT {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D12::ID3D12CommandQueue_Vtbl)))
                .base__
                .base__
                .base__
                .GetPrivateData)(inner, a0, a1, a2)
        }
    }
    /// `SetPrivateData` on the real object.
    pub unsafe fn SetPrivateData(
        inner: *mut c_void,
        a0: *const windows::core::GUID,
        a1: u32,
        a2: *const core::ffi::c_void,
    ) -> windows::core::HRESULT {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D12::ID3D12CommandQueue_Vtbl)))
                .base__
                .base__
                .base__
                .SetPrivateData)(inner, a0, a1, a2)
        }
    }
    /// `SetPrivateDataInterface` on the real object.
    pub unsafe fn SetPrivateDataInterface(
        inner: *mut c_void,
        a0: *const windows::core::GUID,
        a1: *mut core::ffi::c_void,
    ) -> windows::core::HRESULT {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D12::ID3D12CommandQueue_Vtbl)))
                .base__
                .base__
                .base__
                .SetPrivateDataInterface)(inner, a0, a1)
        }
    }
    /// `SetName` on the real object.
    pub unsafe fn SetName(inner: *mut c_void, a0: windows::core::PCWSTR) -> windows::core::HRESULT {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D12::ID3D12CommandQueue_Vtbl)))
                .base__
                .base__
                .base__
                .SetName)(inner, a0)
        }
    }
    /// `GetDevice` on the real object.
    pub unsafe fn GetDevice(
        inner: *mut c_void,
        a0: *const windows::core::GUID,
        a1: *mut *mut core::ffi::c_void,
    ) -> windows::core::HRESULT {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D12::ID3D12CommandQueue_Vtbl)))
                .base__
                .base__
                .GetDevice)(inner, a0, a1)
        }
    }
    /// `UpdateTileMappings` on the real object.
    pub unsafe fn UpdateTileMappings(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: u32,
        a2: *const windows::Win32::Graphics::Direct3D12::D3D12_TILED_RESOURCE_COORDINATE,
        a3: *const windows::Win32::Graphics::Direct3D12::D3D12_TILE_REGION_SIZE,
        a4: *mut core::ffi::c_void,
        a5: u32,
        a6: *const windows::Win32::Graphics::Direct3D12::D3D12_TILE_RANGE_FLAGS,
        a7: *const u32,
        a8: *const u32,
        a9: windows::Win32::Graphics::Direct3D12::D3D12_TILE_MAPPING_FLAGS,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D12::ID3D12CommandQueue_Vtbl)))
                .UpdateTileMappings)(inner, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)
        }
    }
    /// `CopyTileMappings` on the real object.
    pub unsafe fn CopyTileMappings(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: *const windows::Win32::Graphics::Direct3D12::D3D12_TILED_RESOURCE_COORDINATE,
        a2: *mut core::ffi::c_void,
        a3: *const windows::Win32::Graphics::Direct3D12::D3D12_TILED_RESOURCE_COORDINATE,
        a4: *const windows::Win32::Graphics::Direct3D12::D3D12_TILE_REGION_SIZE,
        a5: windows::Win32::Graphics::Direct3D12::D3D12_TILE_MAPPING_FLAGS,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D12::ID3D12CommandQueue_Vtbl)))
                .CopyTileMappings)(inner, a0, a1, a2, a3, a4, a5)
        }
    }
    /// `ExecuteCommandLists` on the real object.
    pub unsafe fn ExecuteCommandLists(inner: *mut c_void, a0: u32, a1: *const *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D12::ID3D12CommandQueue_Vtbl)))
                .ExecuteCommandLists)(inner, a0, a1)
        }
    }
    /// `SetMarker` on the real object.
    pub unsafe fn SetMarker(inner: *mut c_void, a0: u32, a1: *const core::ffi::c_void, a2: u32) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D12::ID3D12CommandQueue_Vtbl)))
                .SetMarker)(inner, a0, a1, a2)
        }
    }
    /// `BeginEvent` on the real object.
    pub unsafe fn BeginEvent(inner: *mut c_void, a0: u32, a1: *const core::ffi::c_void, a2: u32) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D12::ID3D12CommandQueue_Vtbl)))
                .BeginEvent)(inner, a0, a1, a2)
        }
    }
    /// `EndEvent` on the real object.
    pub unsafe fn EndEvent(inner: *mut c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D12::ID3D12CommandQueue_Vtbl)))
                .EndEvent)(inner)
        }
    }
    /// `Signal` on the real object.
    pub unsafe fn Signal(inner: *mut c_void, a0: *mut core::ffi::c_void, a1: u64) -> windows::core::HRESULT {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D12::ID3D12CommandQueue_Vtbl)))
                .Signal)(inner, a0, a1)
        }
    }
    /// `Wait` on the real object.
    pub unsafe fn Wait(inner: *mut c_void, a0: *mut core::ffi::c_void, a1: u64) -> windows::core::HRESULT {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D12::ID3D12CommandQueue_Vtbl)))
                .Wait)(inner, a0, a1)
        }
    }
    /// `GetTimestampFrequency` on the real object.
    pub unsafe fn GetTimestampFrequency(inner: *mut c_void, a0: *mut u64) -> windows::core::HRESULT {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D12::ID3D12CommandQueue_Vtbl)))
                .GetTimestampFrequency)(inner, a0)
        }
    }
    /// `GetClockCalibration` on the real object.
    pub unsafe fn GetClockCalibration(
        inner: *mut c_void,
        a0: *mut u64,
        a1: *mut u64,
    ) -> windows::core::HRESULT {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D12::ID3D12CommandQueue_Vtbl)))
                .GetClockCalibration)(inner, a0, a1)
        }
    }
    /// `GetDesc` on the real object.
    pub unsafe fn GetDesc(
        inner: *mut c_void,
        a0: *mut windows::Win32::Graphics::Direct3D12::D3D12_COMMAND_QUEUE_DESC,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D12::ID3D12CommandQueue_Vtbl)))
                .GetDesc)(inner, a0)
        }
    }
}

unsafe extern "system" fn QueryInterface<T: Queue12Methods>(
    this: *mut c_void,
    iid: *const windows::core::GUID,
    out: *mut *mut c_void,
) -> windows::core::HRESULT {
    unsafe { (*(this as *const T)).QueryInterface(iid, out) }
}
unsafe extern "system" fn AddRef<T: Queue12Methods>(this: *mut c_void) -> u32 {
    unsafe { (*(this as *const T)).AddRef() }
}
unsafe extern "system" fn Release<T: Queue12Methods>(this: *mut c_void) -> u32 {
    unsafe { (*(this as *const T)).Release() }
}
unsafe extern "system" fn GetPrivateData<T: Queue12Methods>(
    this: *mut c_void,
    a0: *const windows::core::GUID,
    a1: *mut u32,
    a2: *mut core::ffi::c_void,
) -> windows::core::HRESULT {
    unsafe { (*(this as *const T)).GetPrivateData(a0, a1, a2) }
}
unsafe extern "system" fn SetPrivateData<T: Queue12Methods>(
    this: *mut c_void,
    a0: *const windows::core::GUID,
    a1: u32,
    a2: *const core::ffi::c_void,
) -> windows::core::HRESULT {
    unsafe { (*(this as *const T)).SetPrivateData(a0, a1, a2) }
}
unsafe extern "system" fn SetPrivateDataInterface<T: Queue12Methods>(
    this: *mut c_void,
    a0: *const windows::core::GUID,
    a1: *mut core::ffi::c_void,
) -> windows::core::HRESULT {
    unsafe { (*(this as *const T)).SetPrivateDataInterface(a0, a1) }
}
unsafe extern "system" fn SetName<T: Queue12Methods>(
    this: *mut c_void,
    a0: windows::core::PCWSTR,
) -> windows::core::HRESULT {
    unsafe { (*(this as *const T)).SetName(a0) }
}
unsafe extern "system" fn GetDevice<T: Queue12Methods>(
    this: *mut c_void,
    a0: *const windows::core::GUID,
    a1: *mut *mut core::ffi::c_void,
) -> windows::core::HRESULT {
    unsafe { (*(this as *const T)).GetDevice(a0, a1) }
}
unsafe extern "system" fn UpdateTileMappings<T: Queue12Methods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: u32,
    a2: *const windows::Win32::Graphics::Direct3D12::D3D12_TILED_RESOURCE_COORDINATE,
    a3: *const windows::Win32::Graphics::Direct3D12::D3D12_TILE_REGION_SIZE,
    a4: *mut core::ffi::c_void,
    a5: u32,
    a6: *const windows::Win32::Graphics::Direct3D12::D3D12_TILE_RANGE_FLAGS,
    a7: *const u32,
    a8: *const u32,
    a9: windows::Win32::Graphics::Direct3D12::D3D12_TILE_MAPPING_FLAGS,
) {
    unsafe { (*(this as *const T)).UpdateTileMappings(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) }
}
unsafe extern "system" fn CopyTileMappings<T: Queue12Methods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *const windows::Win32::Graphics::Direct3D12::D3D12_TILED_RESOURCE_COORDINATE,
    a2: *mut core::ffi::c_void,
    a3: *const windows::Win32::Graphics::Direct3D12::D3D12_TILED_RESOURCE_COORDINATE,
    a4: *const windows::Win32::Graphics::Direct3D12::D3D12_TILE_REGION_SIZE,
    a5: windows::Win32::Graphics::Direct3D12::D3D12_TILE_MAPPING_FLAGS,
) {
    unsafe { (*(this as *const T)).CopyTileMappings(a0, a1, a2, a3, a4, a5) }
}
unsafe extern "system" fn ExecuteCommandLists<T: Queue12Methods>(
    this: *mut c_void,
    a0: u32,
    a1: *const *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).ExecuteCommandLists(a0, a1) }
}
unsafe extern "system" fn SetMarker<T: Queue12Methods>(
    this: *mut c_void,
    a0: u32,
    a1: *const core::ffi::c_void,
    a2: u32,
) {
    unsafe { (*(this as *const T)).SetMarker(a0, a1, a2) }
}
unsafe extern "system" fn BeginEvent<T: Queue12Methods>(
    this: *mut c_void,
    a0: u32,
    a1: *const core::ffi::c_void,
    a2: u32,
) {
    unsafe { (*(this as *const T)).BeginEvent(a0, a1, a2) }
}
unsafe extern "system" fn EndEvent<T: Queue12Methods>(this: *mut c_void) {
    unsafe { (*(this as *const T)).EndEvent() }
}
unsafe extern "system" fn Signal<T: Queue12Methods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: u64,
) -> windows::core::HRESULT {
    unsafe { (*(this as *const T)).Signal(a0, a1) }
}
unsafe extern "system" fn Wait<T: Queue12Methods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: u64,
) -> windows::core::HRESULT {
    unsafe { (*(this as *const T)).Wait(a0, a1) }
}
unsafe extern "system" fn GetTimestampFrequency<T: Queue12Methods>(
    this: *mut c_void,
    a0: *mut u64,
) -> windows::core::HRESULT {
    unsafe { (*(this as *const T)).GetTimestampFrequency(a0) }
}
unsafe extern "system" fn GetClockCalibration<T: Queue12Methods>(
    this: *mut c_void,
    a0: *mut u64,
    a1: *mut u64,
) -> windows::core::HRESULT {
    unsafe { (*(this as *const T)).GetClockCalibration(a0, a1) }
}
unsafe extern "system" fn GetDesc<T: Queue12Methods>(
    this: *mut c_void,
    a0: *mut windows::Win32::Graphics::Direct3D12::D3D12_COMMAND_QUEUE_DESC,
) {
    unsafe { (*(this as *const T)).GetDesc(a0) }
}

#[allow(clippy::let_and_return)] // Uniform post-call interception in generated methods.
unsafe impl Queue12Methods for crate::d3d12::Object {
    fn inner(&self) -> *mut c_void {
        self.real()
    }
    unsafe fn QueryInterface(
        &self,
        iid: *const windows::core::GUID,
        out: *mut *mut c_void,
    ) -> windows::core::HRESULT {
        unsafe { self.query(iid, out) }
    }
    unsafe fn AddRef(&self) -> u32 {
        self.add_ref()
    }
    unsafe fn Release(&self) -> u32 {
        unsafe { self.release() }
    }
    unsafe fn GetPrivateData(
        &self,
        a0: *const windows::core::GUID,
        a1: *mut u32,
        a2: *mut core::ffi::c_void,
    ) -> windows::core::HRESULT {
        unsafe {
            let result = real::GetPrivateData(self.real(), a0, a1, a2);
            self.private_output(result, a0, a1, a2);
            result
        }
    }
    unsafe fn SetPrivateData(
        &self,
        a0: *const windows::core::GUID,
        a1: u32,
        a2: *const core::ffi::c_void,
    ) -> windows::core::HRESULT {
        unsafe {
            let result = real::SetPrivateData(self.real(), a0, a1, a2);
            if result.is_ok() {
                self.private_interface(a0, false);
            }
            result
        }
    }
    unsafe fn SetPrivateDataInterface(
        &self,
        a0: *const windows::core::GUID,
        a1: *mut core::ffi::c_void,
    ) -> windows::core::HRESULT {
        unsafe {
            let result = real::SetPrivateDataInterface(self.real(), a0, crate::d3d12::unwrap(a1));
            if result.is_ok() {
                self.private_interface(a0, !a1.is_null());
            }
            result
        }
    }
    unsafe fn SetName(&self, a0: windows::core::PCWSTR) -> windows::core::HRESULT {
        unsafe {
            let result = real::SetName(self.real(), a0);
            result
        }
    }
    unsafe fn GetDevice(
        &self,
        a0: *const windows::core::GUID,
        a1: *mut *mut core::ffi::c_void,
    ) -> windows::core::HRESULT {
        unsafe {
            let result = real::GetDevice(self.real(), a0, a1);
            crate::d3d12::wrap_output(result, a0, a1);
            result
        }
    }
    unsafe fn UpdateTileMappings(
        &self,
        a0: *mut core::ffi::c_void,
        a1: u32,
        a2: *const windows::Win32::Graphics::Direct3D12::D3D12_TILED_RESOURCE_COORDINATE,
        a3: *const windows::Win32::Graphics::Direct3D12::D3D12_TILE_REGION_SIZE,
        a4: *mut core::ffi::c_void,
        a5: u32,
        a6: *const windows::Win32::Graphics::Direct3D12::D3D12_TILE_RANGE_FLAGS,
        a7: *const u32,
        a8: *const u32,
        a9: windows::Win32::Graphics::Direct3D12::D3D12_TILE_MAPPING_FLAGS,
    ) {
        unsafe {
            let mut queue_order = self.data.queue_seq.lock().unwrap_or_else(|e| e.into_inner());
            *queue_order += 1;
            real::UpdateTileMappings(
                self.real(),
                crate::d3d12::unwrap(a0),
                a1,
                a2,
                a3,
                crate::d3d12::unwrap(a4),
                a5,
                a6,
                a7,
                a8,
                a9,
            );
            crate::d3d12::tiles::update(&self.data, *queue_order, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
        }
    }
    unsafe fn CopyTileMappings(
        &self,
        a0: *mut core::ffi::c_void,
        a1: *const windows::Win32::Graphics::Direct3D12::D3D12_TILED_RESOURCE_COORDINATE,
        a2: *mut core::ffi::c_void,
        a3: *const windows::Win32::Graphics::Direct3D12::D3D12_TILED_RESOURCE_COORDINATE,
        a4: *const windows::Win32::Graphics::Direct3D12::D3D12_TILE_REGION_SIZE,
        a5: windows::Win32::Graphics::Direct3D12::D3D12_TILE_MAPPING_FLAGS,
    ) {
        unsafe {
            let mut queue_order = self.data.queue_seq.lock().unwrap_or_else(|e| e.into_inner());
            *queue_order += 1;
            real::CopyTileMappings(
                self.real(),
                crate::d3d12::unwrap(a0),
                a1,
                crate::d3d12::unwrap(a2),
                a3,
                a4,
                a5,
            );
            crate::d3d12::tiles::copy(&self.data, *queue_order, a0, a1, a2, a3, a4, a5);
        }
    }
    unsafe fn ExecuteCommandLists(&self, a0: u32, a1: *const *mut core::ffi::c_void) {
        unsafe {
            let mapped1 = crate::d3d12::inputs::objects(a1, a0);
            self.called("ExecuteCommandLists");
            let mut queue_order = self.data.queue_seq.lock().unwrap_or_else(|e| e.into_inner());
            *queue_order += 1;
            let mut submission = crate::d3d12::journal::submit(&self.data, self.real(), *queue_order, a0, a1);
            let (count, lists) = submission.arrange(a0, mapped1.ptr());
            real::ExecuteCommandLists(self.real(), count, lists);
            crate::d3d12::journal::submitted(&self.data, self.real(), submission);
        }
    }
    unsafe fn SetMarker(&self, a0: u32, a1: *const core::ffi::c_void, a2: u32) {
        unsafe {
            real::SetMarker(self.real(), a0, a1, a2);
        }
    }
    unsafe fn BeginEvent(&self, a0: u32, a1: *const core::ffi::c_void, a2: u32) {
        unsafe {
            real::BeginEvent(self.real(), a0, a1, a2);
        }
    }
    unsafe fn EndEvent(&self) {
        unsafe {
            real::EndEvent(self.real());
        }
    }
    unsafe fn Signal(&self, a0: *mut core::ffi::c_void, a1: u64) -> windows::core::HRESULT {
        unsafe {
            let mut queue_order = self.data.queue_seq.lock().unwrap_or_else(|e| e.into_inner());
            *queue_order += 1;
            let result = real::Signal(self.real(), crate::d3d12::unwrap(a0), a1);
            crate::d3d12::journal::sync(&self.data, *queue_order, "Signal", a0, a1, result);
            result
        }
    }
    unsafe fn Wait(&self, a0: *mut core::ffi::c_void, a1: u64) -> windows::core::HRESULT {
        unsafe {
            let mut queue_order = self.data.queue_seq.lock().unwrap_or_else(|e| e.into_inner());
            *queue_order += 1;
            let result = real::Wait(self.real(), crate::d3d12::unwrap(a0), a1);
            crate::d3d12::journal::sync(&self.data, *queue_order, "Wait", a0, a1, result);
            result
        }
    }
    unsafe fn GetTimestampFrequency(&self, a0: *mut u64) -> windows::core::HRESULT {
        unsafe {
            let result = real::GetTimestampFrequency(self.real(), a0);
            result
        }
    }
    unsafe fn GetClockCalibration(&self, a0: *mut u64, a1: *mut u64) -> windows::core::HRESULT {
        unsafe {
            let result = real::GetClockCalibration(self.real(), a0, a1);
            result
        }
    }
    unsafe fn GetDesc(&self, a0: *mut windows::Win32::Graphics::Direct3D12::D3D12_COMMAND_QUEUE_DESC) {
        unsafe {
            real::GetDesc(self.real(), a0);
        }
    }
}

/// The `ID3D12CommandQueue` vtable whose entries call `T`'s methods.
pub const fn vtable<T: Queue12Methods>() -> windows::Win32::Graphics::Direct3D12::ID3D12CommandQueue_Vtbl {
    windows::Win32::Graphics::Direct3D12::ID3D12CommandQueue_Vtbl {
        base__: windows::Win32::Graphics::Direct3D12::ID3D12Pageable_Vtbl {
            base__: windows::Win32::Graphics::Direct3D12::ID3D12DeviceChild_Vtbl {
                base__: windows::Win32::Graphics::Direct3D12::ID3D12Object_Vtbl {
                    base__: windows::core::IUnknown_Vtbl {
                        QueryInterface: QueryInterface::<T>,
                        AddRef: AddRef::<T>,
                        Release: Release::<T>,
                    },
                    GetPrivateData: GetPrivateData::<T>,
                    SetPrivateData: SetPrivateData::<T>,
                    SetPrivateDataInterface: SetPrivateDataInterface::<T>,
                    SetName: SetName::<T>,
                },
                GetDevice: GetDevice::<T>,
            },
        },
        UpdateTileMappings: UpdateTileMappings::<T>,
        CopyTileMappings: CopyTileMappings::<T>,
        ExecuteCommandLists: ExecuteCommandLists::<T>,
        SetMarker: SetMarker::<T>,
        BeginEvent: BeginEvent::<T>,
        EndEvent: EndEvent::<T>,
        Signal: Signal::<T>,
        Wait: Wait::<T>,
        GetTimestampFrequency: GetTimestampFrequency::<T>,
        GetClockCalibration: GetClockCalibration::<T>,
        GetDesc: GetDesc::<T>,
    }
}