locum 0.1.4

//! Generated by `cargo xtask gen` from the `windows` crate's `ID3D11DeviceContext4_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 `ID3D11DeviceContext4` in vtable order. The defaults forward to the wrapped object [`ContextMethods::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 `ID3D11DeviceContext4`.
pub unsafe trait ContextMethods: Sized {
    /// The wrapped object, an `ID3D11DeviceContext4`.
    fn inner(&self) -> *mut c_void;
    /// Called before commands that perform work, including calls with a manual override.
    fn before_command(&self) {}
    fn recorder(&self) -> Option<&crate::d3d11::recorder::Recorder> {
        None
    }
    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 GetDevice(&self, a0: *mut *mut core::ffi::c_void) {
        unsafe { real::GetDevice(self.inner(), a0) }
    }
    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 VSSetConstantBuffers(&self, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe { real::VSSetConstantBuffers(self.inner(), a0, a1, a2) }
    }
    unsafe fn PSSetShaderResources(&self, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe { real::PSSetShaderResources(self.inner(), a0, a1, a2) }
    }
    unsafe fn PSSetShader(&self, a0: *mut core::ffi::c_void, a1: *const *mut core::ffi::c_void, a2: u32) {
        unsafe { real::PSSetShader(self.inner(), a0, a1, a2) }
    }
    unsafe fn PSSetSamplers(&self, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe { real::PSSetSamplers(self.inner(), a0, a1, a2) }
    }
    unsafe fn VSSetShader(&self, a0: *mut core::ffi::c_void, a1: *const *mut core::ffi::c_void, a2: u32) {
        unsafe { real::VSSetShader(self.inner(), a0, a1, a2) }
    }
    unsafe fn DrawIndexed(&self, a0: u32, a1: u32, a2: i32) {
        unsafe { real::DrawIndexed(self.inner(), a0, a1, a2) }
    }
    unsafe fn Draw(&self, a0: u32, a1: u32) {
        unsafe { real::Draw(self.inner(), a0, a1) }
    }
    unsafe fn Map(
        &self,
        a0: *mut core::ffi::c_void,
        a1: u32,
        a2: windows::Win32::Graphics::Direct3D11::D3D11_MAP,
        a3: u32,
        a4: *mut windows::Win32::Graphics::Direct3D11::D3D11_MAPPED_SUBRESOURCE,
    ) -> windows::core::HRESULT {
        unsafe { real::Map(self.inner(), a0, a1, a2, a3, a4) }
    }
    unsafe fn Unmap(&self, a0: *mut core::ffi::c_void, a1: u32) {
        unsafe { real::Unmap(self.inner(), a0, a1) }
    }
    unsafe fn PSSetConstantBuffers(&self, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe { real::PSSetConstantBuffers(self.inner(), a0, a1, a2) }
    }
    unsafe fn IASetInputLayout(&self, a0: *mut core::ffi::c_void) {
        unsafe { real::IASetInputLayout(self.inner(), a0) }
    }
    unsafe fn IASetVertexBuffers(
        &self,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
        a3: *const u32,
        a4: *const u32,
    ) {
        unsafe { real::IASetVertexBuffers(self.inner(), a0, a1, a2, a3, a4) }
    }
    unsafe fn IASetIndexBuffer(
        &self,
        a0: *mut core::ffi::c_void,
        a1: windows::Win32::Graphics::Dxgi::Common::DXGI_FORMAT,
        a2: u32,
    ) {
        unsafe { real::IASetIndexBuffer(self.inner(), a0, a1, a2) }
    }
    unsafe fn DrawIndexedInstanced(&self, a0: u32, a1: u32, a2: u32, a3: i32, a4: u32) {
        unsafe { real::DrawIndexedInstanced(self.inner(), a0, a1, a2, a3, a4) }
    }
    unsafe fn DrawInstanced(&self, a0: u32, a1: u32, a2: u32, a3: u32) {
        unsafe { real::DrawInstanced(self.inner(), a0, a1, a2, a3) }
    }
    unsafe fn GSSetConstantBuffers(&self, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe { real::GSSetConstantBuffers(self.inner(), a0, a1, a2) }
    }
    unsafe fn GSSetShader(&self, a0: *mut core::ffi::c_void, a1: *const *mut core::ffi::c_void, a2: u32) {
        unsafe { real::GSSetShader(self.inner(), a0, a1, a2) }
    }
    unsafe fn IASetPrimitiveTopology(&self, a0: windows::Win32::Graphics::Direct3D::D3D_PRIMITIVE_TOPOLOGY) {
        unsafe { real::IASetPrimitiveTopology(self.inner(), a0) }
    }
    unsafe fn VSSetShaderResources(&self, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe { real::VSSetShaderResources(self.inner(), a0, a1, a2) }
    }
    unsafe fn VSSetSamplers(&self, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe { real::VSSetSamplers(self.inner(), a0, a1, a2) }
    }
    unsafe fn Begin(&self, a0: *mut core::ffi::c_void) {
        unsafe { real::Begin(self.inner(), a0) }
    }
    unsafe fn End(&self, a0: *mut core::ffi::c_void) {
        unsafe { real::End(self.inner(), a0) }
    }
    unsafe fn GetData(
        &self,
        a0: *mut core::ffi::c_void,
        a1: *mut core::ffi::c_void,
        a2: u32,
        a3: u32,
    ) -> windows::core::HRESULT {
        unsafe { real::GetData(self.inner(), a0, a1, a2, a3) }
    }
    unsafe fn SetPredication(&self, a0: *mut core::ffi::c_void, a1: windows::core::BOOL) {
        unsafe { real::SetPredication(self.inner(), a0, a1) }
    }
    unsafe fn GSSetShaderResources(&self, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe { real::GSSetShaderResources(self.inner(), a0, a1, a2) }
    }
    unsafe fn GSSetSamplers(&self, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe { real::GSSetSamplers(self.inner(), a0, a1, a2) }
    }
    unsafe fn OMSetRenderTargets(
        &self,
        a0: u32,
        a1: *const *mut core::ffi::c_void,
        a2: *mut core::ffi::c_void,
    ) {
        unsafe { real::OMSetRenderTargets(self.inner(), a0, a1, a2) }
    }
    unsafe fn OMSetRenderTargetsAndUnorderedAccessViews(
        &self,
        a0: u32,
        a1: *const *mut core::ffi::c_void,
        a2: *mut core::ffi::c_void,
        a3: u32,
        a4: u32,
        a5: *const *mut core::ffi::c_void,
        a6: *const u32,
    ) {
        unsafe { real::OMSetRenderTargetsAndUnorderedAccessViews(self.inner(), a0, a1, a2, a3, a4, a5, a6) }
    }
    unsafe fn OMSetBlendState(&self, a0: *mut core::ffi::c_void, a1: *const f32, a2: u32) {
        unsafe { real::OMSetBlendState(self.inner(), a0, a1, a2) }
    }
    unsafe fn OMSetDepthStencilState(&self, a0: *mut core::ffi::c_void, a1: u32) {
        unsafe { real::OMSetDepthStencilState(self.inner(), a0, a1) }
    }
    unsafe fn SOSetTargets(&self, a0: u32, a1: *const *mut core::ffi::c_void, a2: *const u32) {
        unsafe { real::SOSetTargets(self.inner(), a0, a1, a2) }
    }
    unsafe fn DrawAuto(&self) {
        unsafe { real::DrawAuto(self.inner()) }
    }
    unsafe fn DrawIndexedInstancedIndirect(&self, a0: *mut core::ffi::c_void, a1: u32) {
        unsafe { real::DrawIndexedInstancedIndirect(self.inner(), a0, a1) }
    }
    unsafe fn DrawInstancedIndirect(&self, a0: *mut core::ffi::c_void, a1: u32) {
        unsafe { real::DrawInstancedIndirect(self.inner(), a0, a1) }
    }
    unsafe fn Dispatch(&self, a0: u32, a1: u32, a2: u32) {
        unsafe { real::Dispatch(self.inner(), a0, a1, a2) }
    }
    unsafe fn DispatchIndirect(&self, a0: *mut core::ffi::c_void, a1: u32) {
        unsafe { real::DispatchIndirect(self.inner(), a0, a1) }
    }
    unsafe fn RSSetState(&self, a0: *mut core::ffi::c_void) {
        unsafe { real::RSSetState(self.inner(), a0) }
    }
    unsafe fn RSSetViewports(
        &self,
        a0: u32,
        a1: *const windows::Win32::Graphics::Direct3D11::D3D11_VIEWPORT,
    ) {
        unsafe { real::RSSetViewports(self.inner(), a0, a1) }
    }
    unsafe fn RSSetScissorRects(&self, a0: u32, a1: *const windows::Win32::Foundation::RECT) {
        unsafe { real::RSSetScissorRects(self.inner(), a0, a1) }
    }
    unsafe fn CopySubresourceRegion(
        &self,
        a0: *mut core::ffi::c_void,
        a1: u32,
        a2: u32,
        a3: u32,
        a4: u32,
        a5: *mut core::ffi::c_void,
        a6: u32,
        a7: *const windows::Win32::Graphics::Direct3D11::D3D11_BOX,
    ) {
        unsafe { real::CopySubresourceRegion(self.inner(), a0, a1, a2, a3, a4, a5, a6, a7) }
    }
    unsafe fn CopyResource(&self, a0: *mut core::ffi::c_void, a1: *mut core::ffi::c_void) {
        unsafe { real::CopyResource(self.inner(), a0, a1) }
    }
    unsafe fn UpdateSubresource(
        &self,
        a0: *mut core::ffi::c_void,
        a1: u32,
        a2: *const windows::Win32::Graphics::Direct3D11::D3D11_BOX,
        a3: *const core::ffi::c_void,
        a4: u32,
        a5: u32,
    ) {
        unsafe { real::UpdateSubresource(self.inner(), a0, a1, a2, a3, a4, a5) }
    }
    unsafe fn CopyStructureCount(&self, a0: *mut core::ffi::c_void, a1: u32, a2: *mut core::ffi::c_void) {
        unsafe { real::CopyStructureCount(self.inner(), a0, a1, a2) }
    }
    unsafe fn ClearRenderTargetView(&self, a0: *mut core::ffi::c_void, a1: *const f32) {
        unsafe { real::ClearRenderTargetView(self.inner(), a0, a1) }
    }
    unsafe fn ClearUnorderedAccessViewUint(&self, a0: *mut core::ffi::c_void, a1: *const u32) {
        unsafe { real::ClearUnorderedAccessViewUint(self.inner(), a0, a1) }
    }
    unsafe fn ClearUnorderedAccessViewFloat(&self, a0: *mut core::ffi::c_void, a1: *const f32) {
        unsafe { real::ClearUnorderedAccessViewFloat(self.inner(), a0, a1) }
    }
    unsafe fn ClearDepthStencilView(&self, a0: *mut core::ffi::c_void, a1: u32, a2: f32, a3: u8) {
        unsafe { real::ClearDepthStencilView(self.inner(), a0, a1, a2, a3) }
    }
    unsafe fn GenerateMips(&self, a0: *mut core::ffi::c_void) {
        unsafe { real::GenerateMips(self.inner(), a0) }
    }
    unsafe fn SetResourceMinLOD(&self, a0: *mut core::ffi::c_void, a1: f32) {
        unsafe { real::SetResourceMinLOD(self.inner(), a0, a1) }
    }
    unsafe fn GetResourceMinLOD(&self, a0: *mut core::ffi::c_void) -> f32 {
        unsafe { real::GetResourceMinLOD(self.inner(), a0) }
    }
    unsafe fn ResolveSubresource(
        &self,
        a0: *mut core::ffi::c_void,
        a1: u32,
        a2: *mut core::ffi::c_void,
        a3: u32,
        a4: windows::Win32::Graphics::Dxgi::Common::DXGI_FORMAT,
    ) {
        unsafe { real::ResolveSubresource(self.inner(), a0, a1, a2, a3, a4) }
    }
    unsafe fn ExecuteCommandList(&self, a0: *mut core::ffi::c_void, a1: windows::core::BOOL) {
        unsafe { real::ExecuteCommandList(self.inner(), a0, a1) }
    }
    unsafe fn HSSetShaderResources(&self, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe { real::HSSetShaderResources(self.inner(), a0, a1, a2) }
    }
    unsafe fn HSSetShader(&self, a0: *mut core::ffi::c_void, a1: *const *mut core::ffi::c_void, a2: u32) {
        unsafe { real::HSSetShader(self.inner(), a0, a1, a2) }
    }
    unsafe fn HSSetSamplers(&self, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe { real::HSSetSamplers(self.inner(), a0, a1, a2) }
    }
    unsafe fn HSSetConstantBuffers(&self, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe { real::HSSetConstantBuffers(self.inner(), a0, a1, a2) }
    }
    unsafe fn DSSetShaderResources(&self, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe { real::DSSetShaderResources(self.inner(), a0, a1, a2) }
    }
    unsafe fn DSSetShader(&self, a0: *mut core::ffi::c_void, a1: *const *mut core::ffi::c_void, a2: u32) {
        unsafe { real::DSSetShader(self.inner(), a0, a1, a2) }
    }
    unsafe fn DSSetSamplers(&self, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe { real::DSSetSamplers(self.inner(), a0, a1, a2) }
    }
    unsafe fn DSSetConstantBuffers(&self, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe { real::DSSetConstantBuffers(self.inner(), a0, a1, a2) }
    }
    unsafe fn CSSetShaderResources(&self, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe { real::CSSetShaderResources(self.inner(), a0, a1, a2) }
    }
    unsafe fn CSSetUnorderedAccessViews(
        &self,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
        a3: *const u32,
    ) {
        unsafe { real::CSSetUnorderedAccessViews(self.inner(), a0, a1, a2, a3) }
    }
    unsafe fn CSSetShader(&self, a0: *mut core::ffi::c_void, a1: *const *mut core::ffi::c_void, a2: u32) {
        unsafe { real::CSSetShader(self.inner(), a0, a1, a2) }
    }
    unsafe fn CSSetSamplers(&self, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe { real::CSSetSamplers(self.inner(), a0, a1, a2) }
    }
    unsafe fn CSSetConstantBuffers(&self, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe { real::CSSetConstantBuffers(self.inner(), a0, a1, a2) }
    }
    unsafe fn VSGetConstantBuffers(&self, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe { real::VSGetConstantBuffers(self.inner(), a0, a1, a2) }
    }
    unsafe fn PSGetShaderResources(&self, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe { real::PSGetShaderResources(self.inner(), a0, a1, a2) }
    }
    unsafe fn PSGetShader(
        &self,
        a0: *mut *mut core::ffi::c_void,
        a1: *mut *mut core::ffi::c_void,
        a2: *mut u32,
    ) {
        unsafe { real::PSGetShader(self.inner(), a0, a1, a2) }
    }
    unsafe fn PSGetSamplers(&self, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe { real::PSGetSamplers(self.inner(), a0, a1, a2) }
    }
    unsafe fn VSGetShader(
        &self,
        a0: *mut *mut core::ffi::c_void,
        a1: *mut *mut core::ffi::c_void,
        a2: *mut u32,
    ) {
        unsafe { real::VSGetShader(self.inner(), a0, a1, a2) }
    }
    unsafe fn PSGetConstantBuffers(&self, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe { real::PSGetConstantBuffers(self.inner(), a0, a1, a2) }
    }
    unsafe fn IAGetInputLayout(&self, a0: *mut *mut core::ffi::c_void) {
        unsafe { real::IAGetInputLayout(self.inner(), a0) }
    }
    unsafe fn IAGetVertexBuffers(
        &self,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
        a3: *mut u32,
        a4: *mut u32,
    ) {
        unsafe { real::IAGetVertexBuffers(self.inner(), a0, a1, a2, a3, a4) }
    }
    unsafe fn IAGetIndexBuffer(
        &self,
        a0: *mut *mut core::ffi::c_void,
        a1: *mut windows::Win32::Graphics::Dxgi::Common::DXGI_FORMAT,
        a2: *mut u32,
    ) {
        unsafe { real::IAGetIndexBuffer(self.inner(), a0, a1, a2) }
    }
    unsafe fn GSGetConstantBuffers(&self, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe { real::GSGetConstantBuffers(self.inner(), a0, a1, a2) }
    }
    unsafe fn GSGetShader(
        &self,
        a0: *mut *mut core::ffi::c_void,
        a1: *mut *mut core::ffi::c_void,
        a2: *mut u32,
    ) {
        unsafe { real::GSGetShader(self.inner(), a0, a1, a2) }
    }
    unsafe fn IAGetPrimitiveTopology(
        &self,
        a0: *mut windows::Win32::Graphics::Direct3D::D3D_PRIMITIVE_TOPOLOGY,
    ) {
        unsafe { real::IAGetPrimitiveTopology(self.inner(), a0) }
    }
    unsafe fn VSGetShaderResources(&self, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe { real::VSGetShaderResources(self.inner(), a0, a1, a2) }
    }
    unsafe fn VSGetSamplers(&self, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe { real::VSGetSamplers(self.inner(), a0, a1, a2) }
    }
    unsafe fn GetPredication(&self, a0: *mut *mut core::ffi::c_void, a1: *mut windows::core::BOOL) {
        unsafe { real::GetPredication(self.inner(), a0, a1) }
    }
    unsafe fn GSGetShaderResources(&self, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe { real::GSGetShaderResources(self.inner(), a0, a1, a2) }
    }
    unsafe fn GSGetSamplers(&self, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe { real::GSGetSamplers(self.inner(), a0, a1, a2) }
    }
    unsafe fn OMGetRenderTargets(
        &self,
        a0: u32,
        a1: *mut *mut core::ffi::c_void,
        a2: *mut *mut core::ffi::c_void,
    ) {
        unsafe { real::OMGetRenderTargets(self.inner(), a0, a1, a2) }
    }
    unsafe fn OMGetRenderTargetsAndUnorderedAccessViews(
        &self,
        a0: u32,
        a1: *mut *mut core::ffi::c_void,
        a2: *mut *mut core::ffi::c_void,
        a3: u32,
        a4: u32,
        a5: *mut *mut core::ffi::c_void,
    ) {
        unsafe { real::OMGetRenderTargetsAndUnorderedAccessViews(self.inner(), a0, a1, a2, a3, a4, a5) }
    }
    unsafe fn OMGetBlendState(&self, a0: *mut *mut core::ffi::c_void, a1: *mut f32, a2: *mut u32) {
        unsafe { real::OMGetBlendState(self.inner(), a0, a1, a2) }
    }
    unsafe fn OMGetDepthStencilState(&self, a0: *mut *mut core::ffi::c_void, a1: *mut u32) {
        unsafe { real::OMGetDepthStencilState(self.inner(), a0, a1) }
    }
    unsafe fn SOGetTargets(&self, a0: u32, a1: *mut *mut core::ffi::c_void) {
        unsafe { real::SOGetTargets(self.inner(), a0, a1) }
    }
    unsafe fn RSGetState(&self, a0: *mut *mut core::ffi::c_void) {
        unsafe { real::RSGetState(self.inner(), a0) }
    }
    unsafe fn RSGetViewports(
        &self,
        a0: *mut u32,
        a1: *mut windows::Win32::Graphics::Direct3D11::D3D11_VIEWPORT,
    ) {
        unsafe { real::RSGetViewports(self.inner(), a0, a1) }
    }
    unsafe fn RSGetScissorRects(&self, a0: *mut u32, a1: *mut windows::Win32::Foundation::RECT) {
        unsafe { real::RSGetScissorRects(self.inner(), a0, a1) }
    }
    unsafe fn HSGetShaderResources(&self, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe { real::HSGetShaderResources(self.inner(), a0, a1, a2) }
    }
    unsafe fn HSGetShader(
        &self,
        a0: *mut *mut core::ffi::c_void,
        a1: *mut *mut core::ffi::c_void,
        a2: *mut u32,
    ) {
        unsafe { real::HSGetShader(self.inner(), a0, a1, a2) }
    }
    unsafe fn HSGetSamplers(&self, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe { real::HSGetSamplers(self.inner(), a0, a1, a2) }
    }
    unsafe fn HSGetConstantBuffers(&self, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe { real::HSGetConstantBuffers(self.inner(), a0, a1, a2) }
    }
    unsafe fn DSGetShaderResources(&self, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe { real::DSGetShaderResources(self.inner(), a0, a1, a2) }
    }
    unsafe fn DSGetShader(
        &self,
        a0: *mut *mut core::ffi::c_void,
        a1: *mut *mut core::ffi::c_void,
        a2: *mut u32,
    ) {
        unsafe { real::DSGetShader(self.inner(), a0, a1, a2) }
    }
    unsafe fn DSGetSamplers(&self, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe { real::DSGetSamplers(self.inner(), a0, a1, a2) }
    }
    unsafe fn DSGetConstantBuffers(&self, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe { real::DSGetConstantBuffers(self.inner(), a0, a1, a2) }
    }
    unsafe fn CSGetShaderResources(&self, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe { real::CSGetShaderResources(self.inner(), a0, a1, a2) }
    }
    unsafe fn CSGetUnorderedAccessViews(&self, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe { real::CSGetUnorderedAccessViews(self.inner(), a0, a1, a2) }
    }
    unsafe fn CSGetShader(
        &self,
        a0: *mut *mut core::ffi::c_void,
        a1: *mut *mut core::ffi::c_void,
        a2: *mut u32,
    ) {
        unsafe { real::CSGetShader(self.inner(), a0, a1, a2) }
    }
    unsafe fn CSGetSamplers(&self, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe { real::CSGetSamplers(self.inner(), a0, a1, a2) }
    }
    unsafe fn CSGetConstantBuffers(&self, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe { real::CSGetConstantBuffers(self.inner(), a0, a1, a2) }
    }
    unsafe fn ClearState(&self) {
        unsafe { real::ClearState(self.inner()) }
    }
    unsafe fn Flush(&self) {
        unsafe { real::Flush(self.inner()) }
    }
    unsafe fn GetType(&self) -> windows::Win32::Graphics::Direct3D11::D3D11_DEVICE_CONTEXT_TYPE {
        unsafe { real::GetType(self.inner()) }
    }
    unsafe fn GetContextFlags(&self) -> u32 {
        unsafe { real::GetContextFlags(self.inner()) }
    }
    unsafe fn FinishCommandList(
        &self,
        a0: windows::core::BOOL,
        a1: *mut *mut core::ffi::c_void,
    ) -> windows::core::HRESULT {
        unsafe { real::FinishCommandList(self.inner(), a0, a1) }
    }
    unsafe fn CopySubresourceRegion1(
        &self,
        a0: *mut core::ffi::c_void,
        a1: u32,
        a2: u32,
        a3: u32,
        a4: u32,
        a5: *mut core::ffi::c_void,
        a6: u32,
        a7: *const windows::Win32::Graphics::Direct3D11::D3D11_BOX,
        a8: u32,
    ) {
        unsafe { real::CopySubresourceRegion1(self.inner(), a0, a1, a2, a3, a4, a5, a6, a7, a8) }
    }
    unsafe fn UpdateSubresource1(
        &self,
        a0: *mut core::ffi::c_void,
        a1: u32,
        a2: *const windows::Win32::Graphics::Direct3D11::D3D11_BOX,
        a3: *const core::ffi::c_void,
        a4: u32,
        a5: u32,
        a6: u32,
    ) {
        unsafe { real::UpdateSubresource1(self.inner(), a0, a1, a2, a3, a4, a5, a6) }
    }
    unsafe fn DiscardResource(&self, a0: *mut core::ffi::c_void) {
        unsafe { real::DiscardResource(self.inner(), a0) }
    }
    unsafe fn DiscardView(&self, a0: *mut core::ffi::c_void) {
        unsafe { real::DiscardView(self.inner(), a0) }
    }
    unsafe fn VSSetConstantBuffers1(
        &self,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
        a3: *const u32,
        a4: *const u32,
    ) {
        unsafe { real::VSSetConstantBuffers1(self.inner(), a0, a1, a2, a3, a4) }
    }
    unsafe fn HSSetConstantBuffers1(
        &self,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
        a3: *const u32,
        a4: *const u32,
    ) {
        unsafe { real::HSSetConstantBuffers1(self.inner(), a0, a1, a2, a3, a4) }
    }
    unsafe fn DSSetConstantBuffers1(
        &self,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
        a3: *const u32,
        a4: *const u32,
    ) {
        unsafe { real::DSSetConstantBuffers1(self.inner(), a0, a1, a2, a3, a4) }
    }
    unsafe fn GSSetConstantBuffers1(
        &self,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
        a3: *const u32,
        a4: *const u32,
    ) {
        unsafe { real::GSSetConstantBuffers1(self.inner(), a0, a1, a2, a3, a4) }
    }
    unsafe fn PSSetConstantBuffers1(
        &self,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
        a3: *const u32,
        a4: *const u32,
    ) {
        unsafe { real::PSSetConstantBuffers1(self.inner(), a0, a1, a2, a3, a4) }
    }
    unsafe fn CSSetConstantBuffers1(
        &self,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
        a3: *const u32,
        a4: *const u32,
    ) {
        unsafe { real::CSSetConstantBuffers1(self.inner(), a0, a1, a2, a3, a4) }
    }
    unsafe fn VSGetConstantBuffers1(
        &self,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
        a3: *mut u32,
        a4: *mut u32,
    ) {
        unsafe { real::VSGetConstantBuffers1(self.inner(), a0, a1, a2, a3, a4) }
    }
    unsafe fn HSGetConstantBuffers1(
        &self,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
        a3: *mut u32,
        a4: *mut u32,
    ) {
        unsafe { real::HSGetConstantBuffers1(self.inner(), a0, a1, a2, a3, a4) }
    }
    unsafe fn DSGetConstantBuffers1(
        &self,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
        a3: *mut u32,
        a4: *mut u32,
    ) {
        unsafe { real::DSGetConstantBuffers1(self.inner(), a0, a1, a2, a3, a4) }
    }
    unsafe fn GSGetConstantBuffers1(
        &self,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
        a3: *mut u32,
        a4: *mut u32,
    ) {
        unsafe { real::GSGetConstantBuffers1(self.inner(), a0, a1, a2, a3, a4) }
    }
    unsafe fn PSGetConstantBuffers1(
        &self,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
        a3: *mut u32,
        a4: *mut u32,
    ) {
        unsafe { real::PSGetConstantBuffers1(self.inner(), a0, a1, a2, a3, a4) }
    }
    unsafe fn CSGetConstantBuffers1(
        &self,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
        a3: *mut u32,
        a4: *mut u32,
    ) {
        unsafe { real::CSGetConstantBuffers1(self.inner(), a0, a1, a2, a3, a4) }
    }
    unsafe fn SwapDeviceContextState(&self, a0: *mut core::ffi::c_void, a1: *mut *mut core::ffi::c_void) {
        unsafe { real::SwapDeviceContextState(self.inner(), a0, a1) }
    }
    unsafe fn ClearView(
        &self,
        a0: *mut core::ffi::c_void,
        a1: *const f32,
        a2: *const windows::Win32::Foundation::RECT,
        a3: u32,
    ) {
        unsafe { real::ClearView(self.inner(), a0, a1, a2, a3) }
    }
    unsafe fn DiscardView1(
        &self,
        a0: *mut core::ffi::c_void,
        a1: *const windows::Win32::Foundation::RECT,
        a2: u32,
    ) {
        unsafe { real::DiscardView1(self.inner(), a0, a1, a2) }
    }
    unsafe fn UpdateTileMappings(
        &self,
        a0: *mut core::ffi::c_void,
        a1: u32,
        a2: *const windows::Win32::Graphics::Direct3D11::D3D11_TILED_RESOURCE_COORDINATE,
        a3: *const windows::Win32::Graphics::Direct3D11::D3D11_TILE_REGION_SIZE,
        a4: *mut core::ffi::c_void,
        a5: u32,
        a6: *const u32,
        a7: *const u32,
        a8: *const u32,
        a9: u32,
    ) -> windows::core::HRESULT {
        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::Direct3D11::D3D11_TILED_RESOURCE_COORDINATE,
        a2: *mut core::ffi::c_void,
        a3: *const windows::Win32::Graphics::Direct3D11::D3D11_TILED_RESOURCE_COORDINATE,
        a4: *const windows::Win32::Graphics::Direct3D11::D3D11_TILE_REGION_SIZE,
        a5: u32,
    ) -> windows::core::HRESULT {
        unsafe { real::CopyTileMappings(self.inner(), a0, a1, a2, a3, a4, a5) }
    }
    unsafe fn CopyTiles(
        &self,
        a0: *mut core::ffi::c_void,
        a1: *const windows::Win32::Graphics::Direct3D11::D3D11_TILED_RESOURCE_COORDINATE,
        a2: *const windows::Win32::Graphics::Direct3D11::D3D11_TILE_REGION_SIZE,
        a3: *mut core::ffi::c_void,
        a4: u64,
        a5: u32,
    ) {
        unsafe { real::CopyTiles(self.inner(), a0, a1, a2, a3, a4, a5) }
    }
    unsafe fn UpdateTiles(
        &self,
        a0: *mut core::ffi::c_void,
        a1: *const windows::Win32::Graphics::Direct3D11::D3D11_TILED_RESOURCE_COORDINATE,
        a2: *const windows::Win32::Graphics::Direct3D11::D3D11_TILE_REGION_SIZE,
        a3: *const core::ffi::c_void,
        a4: u32,
    ) {
        unsafe { real::UpdateTiles(self.inner(), a0, a1, a2, a3, a4) }
    }
    unsafe fn ResizeTilePool(&self, a0: *mut core::ffi::c_void, a1: u64) -> windows::core::HRESULT {
        unsafe { real::ResizeTilePool(self.inner(), a0, a1) }
    }
    unsafe fn TiledResourceBarrier(&self, a0: *mut core::ffi::c_void, a1: *mut core::ffi::c_void) {
        unsafe { real::TiledResourceBarrier(self.inner(), a0, a1) }
    }
    unsafe fn IsAnnotationEnabled(&self) -> windows::core::BOOL {
        unsafe { real::IsAnnotationEnabled(self.inner()) }
    }
    unsafe fn SetMarkerInt(&self, a0: windows::core::PCWSTR, a1: i32) {
        unsafe { real::SetMarkerInt(self.inner(), a0, a1) }
    }
    unsafe fn BeginEventInt(&self, a0: windows::core::PCWSTR, a1: i32) {
        unsafe { real::BeginEventInt(self.inner(), a0, a1) }
    }
    unsafe fn EndEvent(&self) {
        unsafe { real::EndEvent(self.inner()) }
    }
    unsafe fn Flush1(
        &self,
        a0: windows::Win32::Graphics::Direct3D11::D3D11_CONTEXT_TYPE,
        a1: windows::Win32::Foundation::HANDLE,
    ) {
        unsafe { real::Flush1(self.inner(), a0, a1) }
    }
    unsafe fn SetHardwareProtectionState(&self, a0: windows::core::BOOL) {
        unsafe { real::SetHardwareProtectionState(self.inner(), a0) }
    }
    unsafe fn GetHardwareProtectionState(&self, a0: *mut windows::core::BOOL) {
        unsafe { real::GetHardwareProtectionState(self.inner(), a0) }
    }
    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) }
    }
}

/// 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;

    /// `GetDevice` on the real object.
    pub unsafe fn GetDevice(inner: *mut c_void, a0: *mut *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .base__
                .GetDevice)(inner, a0)
        }
    }
    /// `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::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .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::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .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::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .base__
                .SetPrivateDataInterface)(inner, a0, a1)
        }
    }
    /// `VSSetConstantBuffers` on the real object.
    pub unsafe fn VSSetConstantBuffers(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .VSSetConstantBuffers)(inner, a0, a1, a2)
        }
    }
    /// `PSSetShaderResources` on the real object.
    pub unsafe fn PSSetShaderResources(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .PSSetShaderResources)(inner, a0, a1, a2)
        }
    }
    /// `PSSetShader` on the real object.
    pub unsafe fn PSSetShader(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: *const *mut core::ffi::c_void,
        a2: u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .PSSetShader)(inner, a0, a1, a2)
        }
    }
    /// `PSSetSamplers` on the real object.
    pub unsafe fn PSSetSamplers(inner: *mut c_void, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .PSSetSamplers)(inner, a0, a1, a2)
        }
    }
    /// `VSSetShader` on the real object.
    pub unsafe fn VSSetShader(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: *const *mut core::ffi::c_void,
        a2: u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .VSSetShader)(inner, a0, a1, a2)
        }
    }
    /// `DrawIndexed` on the real object.
    pub unsafe fn DrawIndexed(inner: *mut c_void, a0: u32, a1: u32, a2: i32) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .DrawIndexed)(inner, a0, a1, a2)
        }
    }
    /// `Draw` on the real object.
    pub unsafe fn Draw(inner: *mut c_void, a0: u32, a1: u32) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .Draw)(inner, a0, a1)
        }
    }
    /// `Map` on the real object.
    pub unsafe fn Map(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: u32,
        a2: windows::Win32::Graphics::Direct3D11::D3D11_MAP,
        a3: u32,
        a4: *mut windows::Win32::Graphics::Direct3D11::D3D11_MAPPED_SUBRESOURCE,
    ) -> windows::core::HRESULT {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .Map)(inner, a0, a1, a2, a3, a4)
        }
    }
    /// `Unmap` on the real object.
    pub unsafe fn Unmap(inner: *mut c_void, a0: *mut core::ffi::c_void, a1: u32) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .Unmap)(inner, a0, a1)
        }
    }
    /// `PSSetConstantBuffers` on the real object.
    pub unsafe fn PSSetConstantBuffers(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .PSSetConstantBuffers)(inner, a0, a1, a2)
        }
    }
    /// `IASetInputLayout` on the real object.
    pub unsafe fn IASetInputLayout(inner: *mut c_void, a0: *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .IASetInputLayout)(inner, a0)
        }
    }
    /// `IASetVertexBuffers` on the real object.
    pub unsafe fn IASetVertexBuffers(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
        a3: *const u32,
        a4: *const u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .IASetVertexBuffers)(inner, a0, a1, a2, a3, a4)
        }
    }
    /// `IASetIndexBuffer` on the real object.
    pub unsafe fn IASetIndexBuffer(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: windows::Win32::Graphics::Dxgi::Common::DXGI_FORMAT,
        a2: u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .IASetIndexBuffer)(inner, a0, a1, a2)
        }
    }
    /// `DrawIndexedInstanced` on the real object.
    pub unsafe fn DrawIndexedInstanced(inner: *mut c_void, a0: u32, a1: u32, a2: u32, a3: i32, a4: u32) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .DrawIndexedInstanced)(inner, a0, a1, a2, a3, a4)
        }
    }
    /// `DrawInstanced` on the real object.
    pub unsafe fn DrawInstanced(inner: *mut c_void, a0: u32, a1: u32, a2: u32, a3: u32) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .DrawInstanced)(inner, a0, a1, a2, a3)
        }
    }
    /// `GSSetConstantBuffers` on the real object.
    pub unsafe fn GSSetConstantBuffers(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .GSSetConstantBuffers)(inner, a0, a1, a2)
        }
    }
    /// `GSSetShader` on the real object.
    pub unsafe fn GSSetShader(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: *const *mut core::ffi::c_void,
        a2: u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .GSSetShader)(inner, a0, a1, a2)
        }
    }
    /// `IASetPrimitiveTopology` on the real object.
    pub unsafe fn IASetPrimitiveTopology(
        inner: *mut c_void,
        a0: windows::Win32::Graphics::Direct3D::D3D_PRIMITIVE_TOPOLOGY,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .IASetPrimitiveTopology)(inner, a0)
        }
    }
    /// `VSSetShaderResources` on the real object.
    pub unsafe fn VSSetShaderResources(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .VSSetShaderResources)(inner, a0, a1, a2)
        }
    }
    /// `VSSetSamplers` on the real object.
    pub unsafe fn VSSetSamplers(inner: *mut c_void, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .VSSetSamplers)(inner, a0, a1, a2)
        }
    }
    /// `Begin` on the real object.
    pub unsafe fn Begin(inner: *mut c_void, a0: *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .Begin)(inner, a0)
        }
    }
    /// `End` on the real object.
    pub unsafe fn End(inner: *mut c_void, a0: *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .End)(inner, a0)
        }
    }
    /// `GetData` on the real object.
    pub unsafe fn GetData(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: *mut core::ffi::c_void,
        a2: u32,
        a3: u32,
    ) -> windows::core::HRESULT {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .GetData)(inner, a0, a1, a2, a3)
        }
    }
    /// `SetPredication` on the real object.
    pub unsafe fn SetPredication(inner: *mut c_void, a0: *mut core::ffi::c_void, a1: windows::core::BOOL) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .SetPredication)(inner, a0, a1)
        }
    }
    /// `GSSetShaderResources` on the real object.
    pub unsafe fn GSSetShaderResources(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .GSSetShaderResources)(inner, a0, a1, a2)
        }
    }
    /// `GSSetSamplers` on the real object.
    pub unsafe fn GSSetSamplers(inner: *mut c_void, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .GSSetSamplers)(inner, a0, a1, a2)
        }
    }
    /// `OMSetRenderTargets` on the real object.
    pub unsafe fn OMSetRenderTargets(
        inner: *mut c_void,
        a0: u32,
        a1: *const *mut core::ffi::c_void,
        a2: *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .OMSetRenderTargets)(inner, a0, a1, a2)
        }
    }
    /// `OMSetRenderTargetsAndUnorderedAccessViews` on the real object.
    pub unsafe fn OMSetRenderTargetsAndUnorderedAccessViews(
        inner: *mut c_void,
        a0: u32,
        a1: *const *mut core::ffi::c_void,
        a2: *mut core::ffi::c_void,
        a3: u32,
        a4: u32,
        a5: *const *mut core::ffi::c_void,
        a6: *const u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .OMSetRenderTargetsAndUnorderedAccessViews)(inner, a0, a1, a2, a3, a4, a5, a6)
        }
    }
    /// `OMSetBlendState` on the real object.
    pub unsafe fn OMSetBlendState(inner: *mut c_void, a0: *mut core::ffi::c_void, a1: *const f32, a2: u32) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .OMSetBlendState)(inner, a0, a1, a2)
        }
    }
    /// `OMSetDepthStencilState` on the real object.
    pub unsafe fn OMSetDepthStencilState(inner: *mut c_void, a0: *mut core::ffi::c_void, a1: u32) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .OMSetDepthStencilState)(inner, a0, a1)
        }
    }
    /// `SOSetTargets` on the real object.
    pub unsafe fn SOSetTargets(
        inner: *mut c_void,
        a0: u32,
        a1: *const *mut core::ffi::c_void,
        a2: *const u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .SOSetTargets)(inner, a0, a1, a2)
        }
    }
    /// `DrawAuto` on the real object.
    pub unsafe fn DrawAuto(inner: *mut c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .DrawAuto)(inner)
        }
    }
    /// `DrawIndexedInstancedIndirect` on the real object.
    pub unsafe fn DrawIndexedInstancedIndirect(inner: *mut c_void, a0: *mut core::ffi::c_void, a1: u32) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .DrawIndexedInstancedIndirect)(inner, a0, a1)
        }
    }
    /// `DrawInstancedIndirect` on the real object.
    pub unsafe fn DrawInstancedIndirect(inner: *mut c_void, a0: *mut core::ffi::c_void, a1: u32) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .DrawInstancedIndirect)(inner, a0, a1)
        }
    }
    /// `Dispatch` on the real object.
    pub unsafe fn Dispatch(inner: *mut c_void, a0: u32, a1: u32, a2: u32) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .Dispatch)(inner, a0, a1, a2)
        }
    }
    /// `DispatchIndirect` on the real object.
    pub unsafe fn DispatchIndirect(inner: *mut c_void, a0: *mut core::ffi::c_void, a1: u32) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .DispatchIndirect)(inner, a0, a1)
        }
    }
    /// `RSSetState` on the real object.
    pub unsafe fn RSSetState(inner: *mut c_void, a0: *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .RSSetState)(inner, a0)
        }
    }
    /// `RSSetViewports` on the real object.
    pub unsafe fn RSSetViewports(
        inner: *mut c_void,
        a0: u32,
        a1: *const windows::Win32::Graphics::Direct3D11::D3D11_VIEWPORT,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .RSSetViewports)(inner, a0, a1)
        }
    }
    /// `RSSetScissorRects` on the real object.
    pub unsafe fn RSSetScissorRects(
        inner: *mut c_void,
        a0: u32,
        a1: *const windows::Win32::Foundation::RECT,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .RSSetScissorRects)(inner, a0, a1)
        }
    }
    /// `CopySubresourceRegion` on the real object.
    pub unsafe fn CopySubresourceRegion(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: u32,
        a2: u32,
        a3: u32,
        a4: u32,
        a5: *mut core::ffi::c_void,
        a6: u32,
        a7: *const windows::Win32::Graphics::Direct3D11::D3D11_BOX,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .CopySubresourceRegion)(inner, a0, a1, a2, a3, a4, a5, a6, a7)
        }
    }
    /// `CopyResource` on the real object.
    pub unsafe fn CopyResource(inner: *mut c_void, a0: *mut core::ffi::c_void, a1: *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .CopyResource)(inner, a0, a1)
        }
    }
    /// `UpdateSubresource` on the real object.
    pub unsafe fn UpdateSubresource(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: u32,
        a2: *const windows::Win32::Graphics::Direct3D11::D3D11_BOX,
        a3: *const core::ffi::c_void,
        a4: u32,
        a5: u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .UpdateSubresource)(inner, a0, a1, a2, a3, a4, a5)
        }
    }
    /// `CopyStructureCount` on the real object.
    pub unsafe fn CopyStructureCount(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: u32,
        a2: *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .CopyStructureCount)(inner, a0, a1, a2)
        }
    }
    /// `ClearRenderTargetView` on the real object.
    pub unsafe fn ClearRenderTargetView(inner: *mut c_void, a0: *mut core::ffi::c_void, a1: *const f32) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .ClearRenderTargetView)(inner, a0, a1)
        }
    }
    /// `ClearUnorderedAccessViewUint` on the real object.
    pub unsafe fn ClearUnorderedAccessViewUint(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: *const u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .ClearUnorderedAccessViewUint)(inner, a0, a1)
        }
    }
    /// `ClearUnorderedAccessViewFloat` on the real object.
    pub unsafe fn ClearUnorderedAccessViewFloat(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: *const f32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .ClearUnorderedAccessViewFloat)(inner, a0, a1)
        }
    }
    /// `ClearDepthStencilView` on the real object.
    pub unsafe fn ClearDepthStencilView(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: u32,
        a2: f32,
        a3: u8,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .ClearDepthStencilView)(inner, a0, a1, a2, a3)
        }
    }
    /// `GenerateMips` on the real object.
    pub unsafe fn GenerateMips(inner: *mut c_void, a0: *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .GenerateMips)(inner, a0)
        }
    }
    /// `SetResourceMinLOD` on the real object.
    pub unsafe fn SetResourceMinLOD(inner: *mut c_void, a0: *mut core::ffi::c_void, a1: f32) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .SetResourceMinLOD)(inner, a0, a1)
        }
    }
    /// `GetResourceMinLOD` on the real object.
    pub unsafe fn GetResourceMinLOD(inner: *mut c_void, a0: *mut core::ffi::c_void) -> f32 {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .GetResourceMinLOD)(inner, a0)
        }
    }
    /// `ResolveSubresource` on the real object.
    pub unsafe fn ResolveSubresource(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: u32,
        a2: *mut core::ffi::c_void,
        a3: u32,
        a4: windows::Win32::Graphics::Dxgi::Common::DXGI_FORMAT,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .ResolveSubresource)(inner, a0, a1, a2, a3, a4)
        }
    }
    /// `ExecuteCommandList` on the real object.
    pub unsafe fn ExecuteCommandList(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: windows::core::BOOL,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .ExecuteCommandList)(inner, a0, a1)
        }
    }
    /// `HSSetShaderResources` on the real object.
    pub unsafe fn HSSetShaderResources(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .HSSetShaderResources)(inner, a0, a1, a2)
        }
    }
    /// `HSSetShader` on the real object.
    pub unsafe fn HSSetShader(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: *const *mut core::ffi::c_void,
        a2: u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .HSSetShader)(inner, a0, a1, a2)
        }
    }
    /// `HSSetSamplers` on the real object.
    pub unsafe fn HSSetSamplers(inner: *mut c_void, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .HSSetSamplers)(inner, a0, a1, a2)
        }
    }
    /// `HSSetConstantBuffers` on the real object.
    pub unsafe fn HSSetConstantBuffers(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .HSSetConstantBuffers)(inner, a0, a1, a2)
        }
    }
    /// `DSSetShaderResources` on the real object.
    pub unsafe fn DSSetShaderResources(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .DSSetShaderResources)(inner, a0, a1, a2)
        }
    }
    /// `DSSetShader` on the real object.
    pub unsafe fn DSSetShader(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: *const *mut core::ffi::c_void,
        a2: u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .DSSetShader)(inner, a0, a1, a2)
        }
    }
    /// `DSSetSamplers` on the real object.
    pub unsafe fn DSSetSamplers(inner: *mut c_void, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .DSSetSamplers)(inner, a0, a1, a2)
        }
    }
    /// `DSSetConstantBuffers` on the real object.
    pub unsafe fn DSSetConstantBuffers(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .DSSetConstantBuffers)(inner, a0, a1, a2)
        }
    }
    /// `CSSetShaderResources` on the real object.
    pub unsafe fn CSSetShaderResources(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .CSSetShaderResources)(inner, a0, a1, a2)
        }
    }
    /// `CSSetUnorderedAccessViews` on the real object.
    pub unsafe fn CSSetUnorderedAccessViews(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
        a3: *const u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .CSSetUnorderedAccessViews)(inner, a0, a1, a2, a3)
        }
    }
    /// `CSSetShader` on the real object.
    pub unsafe fn CSSetShader(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: *const *mut core::ffi::c_void,
        a2: u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .CSSetShader)(inner, a0, a1, a2)
        }
    }
    /// `CSSetSamplers` on the real object.
    pub unsafe fn CSSetSamplers(inner: *mut c_void, a0: u32, a1: u32, a2: *const *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .CSSetSamplers)(inner, a0, a1, a2)
        }
    }
    /// `CSSetConstantBuffers` on the real object.
    pub unsafe fn CSSetConstantBuffers(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .CSSetConstantBuffers)(inner, a0, a1, a2)
        }
    }
    /// `VSGetConstantBuffers` on the real object.
    pub unsafe fn VSGetConstantBuffers(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .VSGetConstantBuffers)(inner, a0, a1, a2)
        }
    }
    /// `PSGetShaderResources` on the real object.
    pub unsafe fn PSGetShaderResources(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .PSGetShaderResources)(inner, a0, a1, a2)
        }
    }
    /// `PSGetShader` on the real object.
    pub unsafe fn PSGetShader(
        inner: *mut c_void,
        a0: *mut *mut core::ffi::c_void,
        a1: *mut *mut core::ffi::c_void,
        a2: *mut u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .PSGetShader)(inner, a0, a1, a2)
        }
    }
    /// `PSGetSamplers` on the real object.
    pub unsafe fn PSGetSamplers(inner: *mut c_void, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .PSGetSamplers)(inner, a0, a1, a2)
        }
    }
    /// `VSGetShader` on the real object.
    pub unsafe fn VSGetShader(
        inner: *mut c_void,
        a0: *mut *mut core::ffi::c_void,
        a1: *mut *mut core::ffi::c_void,
        a2: *mut u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .VSGetShader)(inner, a0, a1, a2)
        }
    }
    /// `PSGetConstantBuffers` on the real object.
    pub unsafe fn PSGetConstantBuffers(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .PSGetConstantBuffers)(inner, a0, a1, a2)
        }
    }
    /// `IAGetInputLayout` on the real object.
    pub unsafe fn IAGetInputLayout(inner: *mut c_void, a0: *mut *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .IAGetInputLayout)(inner, a0)
        }
    }
    /// `IAGetVertexBuffers` on the real object.
    pub unsafe fn IAGetVertexBuffers(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
        a3: *mut u32,
        a4: *mut u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .IAGetVertexBuffers)(inner, a0, a1, a2, a3, a4)
        }
    }
    /// `IAGetIndexBuffer` on the real object.
    pub unsafe fn IAGetIndexBuffer(
        inner: *mut c_void,
        a0: *mut *mut core::ffi::c_void,
        a1: *mut windows::Win32::Graphics::Dxgi::Common::DXGI_FORMAT,
        a2: *mut u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .IAGetIndexBuffer)(inner, a0, a1, a2)
        }
    }
    /// `GSGetConstantBuffers` on the real object.
    pub unsafe fn GSGetConstantBuffers(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .GSGetConstantBuffers)(inner, a0, a1, a2)
        }
    }
    /// `GSGetShader` on the real object.
    pub unsafe fn GSGetShader(
        inner: *mut c_void,
        a0: *mut *mut core::ffi::c_void,
        a1: *mut *mut core::ffi::c_void,
        a2: *mut u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .GSGetShader)(inner, a0, a1, a2)
        }
    }
    /// `IAGetPrimitiveTopology` on the real object.
    pub unsafe fn IAGetPrimitiveTopology(
        inner: *mut c_void,
        a0: *mut windows::Win32::Graphics::Direct3D::D3D_PRIMITIVE_TOPOLOGY,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .IAGetPrimitiveTopology)(inner, a0)
        }
    }
    /// `VSGetShaderResources` on the real object.
    pub unsafe fn VSGetShaderResources(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .VSGetShaderResources)(inner, a0, a1, a2)
        }
    }
    /// `VSGetSamplers` on the real object.
    pub unsafe fn VSGetSamplers(inner: *mut c_void, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .VSGetSamplers)(inner, a0, a1, a2)
        }
    }
    /// `GetPredication` on the real object.
    pub unsafe fn GetPredication(
        inner: *mut c_void,
        a0: *mut *mut core::ffi::c_void,
        a1: *mut windows::core::BOOL,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .GetPredication)(inner, a0, a1)
        }
    }
    /// `GSGetShaderResources` on the real object.
    pub unsafe fn GSGetShaderResources(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .GSGetShaderResources)(inner, a0, a1, a2)
        }
    }
    /// `GSGetSamplers` on the real object.
    pub unsafe fn GSGetSamplers(inner: *mut c_void, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .GSGetSamplers)(inner, a0, a1, a2)
        }
    }
    /// `OMGetRenderTargets` on the real object.
    pub unsafe fn OMGetRenderTargets(
        inner: *mut c_void,
        a0: u32,
        a1: *mut *mut core::ffi::c_void,
        a2: *mut *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .OMGetRenderTargets)(inner, a0, a1, a2)
        }
    }
    /// `OMGetRenderTargetsAndUnorderedAccessViews` on the real object.
    pub unsafe fn OMGetRenderTargetsAndUnorderedAccessViews(
        inner: *mut c_void,
        a0: u32,
        a1: *mut *mut core::ffi::c_void,
        a2: *mut *mut core::ffi::c_void,
        a3: u32,
        a4: u32,
        a5: *mut *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .OMGetRenderTargetsAndUnorderedAccessViews)(inner, a0, a1, a2, a3, a4, a5)
        }
    }
    /// `OMGetBlendState` on the real object.
    pub unsafe fn OMGetBlendState(
        inner: *mut c_void,
        a0: *mut *mut core::ffi::c_void,
        a1: *mut f32,
        a2: *mut u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .OMGetBlendState)(inner, a0, a1, a2)
        }
    }
    /// `OMGetDepthStencilState` on the real object.
    pub unsafe fn OMGetDepthStencilState(inner: *mut c_void, a0: *mut *mut core::ffi::c_void, a1: *mut u32) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .OMGetDepthStencilState)(inner, a0, a1)
        }
    }
    /// `SOGetTargets` on the real object.
    pub unsafe fn SOGetTargets(inner: *mut c_void, a0: u32, a1: *mut *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .SOGetTargets)(inner, a0, a1)
        }
    }
    /// `RSGetState` on the real object.
    pub unsafe fn RSGetState(inner: *mut c_void, a0: *mut *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .RSGetState)(inner, a0)
        }
    }
    /// `RSGetViewports` on the real object.
    pub unsafe fn RSGetViewports(
        inner: *mut c_void,
        a0: *mut u32,
        a1: *mut windows::Win32::Graphics::Direct3D11::D3D11_VIEWPORT,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .RSGetViewports)(inner, a0, a1)
        }
    }
    /// `RSGetScissorRects` on the real object.
    pub unsafe fn RSGetScissorRects(
        inner: *mut c_void,
        a0: *mut u32,
        a1: *mut windows::Win32::Foundation::RECT,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .RSGetScissorRects)(inner, a0, a1)
        }
    }
    /// `HSGetShaderResources` on the real object.
    pub unsafe fn HSGetShaderResources(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .HSGetShaderResources)(inner, a0, a1, a2)
        }
    }
    /// `HSGetShader` on the real object.
    pub unsafe fn HSGetShader(
        inner: *mut c_void,
        a0: *mut *mut core::ffi::c_void,
        a1: *mut *mut core::ffi::c_void,
        a2: *mut u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .HSGetShader)(inner, a0, a1, a2)
        }
    }
    /// `HSGetSamplers` on the real object.
    pub unsafe fn HSGetSamplers(inner: *mut c_void, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .HSGetSamplers)(inner, a0, a1, a2)
        }
    }
    /// `HSGetConstantBuffers` on the real object.
    pub unsafe fn HSGetConstantBuffers(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .HSGetConstantBuffers)(inner, a0, a1, a2)
        }
    }
    /// `DSGetShaderResources` on the real object.
    pub unsafe fn DSGetShaderResources(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .DSGetShaderResources)(inner, a0, a1, a2)
        }
    }
    /// `DSGetShader` on the real object.
    pub unsafe fn DSGetShader(
        inner: *mut c_void,
        a0: *mut *mut core::ffi::c_void,
        a1: *mut *mut core::ffi::c_void,
        a2: *mut u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .DSGetShader)(inner, a0, a1, a2)
        }
    }
    /// `DSGetSamplers` on the real object.
    pub unsafe fn DSGetSamplers(inner: *mut c_void, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .DSGetSamplers)(inner, a0, a1, a2)
        }
    }
    /// `DSGetConstantBuffers` on the real object.
    pub unsafe fn DSGetConstantBuffers(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .DSGetConstantBuffers)(inner, a0, a1, a2)
        }
    }
    /// `CSGetShaderResources` on the real object.
    pub unsafe fn CSGetShaderResources(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .CSGetShaderResources)(inner, a0, a1, a2)
        }
    }
    /// `CSGetUnorderedAccessViews` on the real object.
    pub unsafe fn CSGetUnorderedAccessViews(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .CSGetUnorderedAccessViews)(inner, a0, a1, a2)
        }
    }
    /// `CSGetShader` on the real object.
    pub unsafe fn CSGetShader(
        inner: *mut c_void,
        a0: *mut *mut core::ffi::c_void,
        a1: *mut *mut core::ffi::c_void,
        a2: *mut u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .CSGetShader)(inner, a0, a1, a2)
        }
    }
    /// `CSGetSamplers` on the real object.
    pub unsafe fn CSGetSamplers(inner: *mut c_void, a0: u32, a1: u32, a2: *mut *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .CSGetSamplers)(inner, a0, a1, a2)
        }
    }
    /// `CSGetConstantBuffers` on the real object.
    pub unsafe fn CSGetConstantBuffers(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .CSGetConstantBuffers)(inner, a0, a1, a2)
        }
    }
    /// `ClearState` on the real object.
    pub unsafe fn ClearState(inner: *mut c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .ClearState)(inner)
        }
    }
    /// `Flush` on the real object.
    pub unsafe fn Flush(inner: *mut c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .Flush)(inner)
        }
    }
    /// `GetType` on the real object.
    pub unsafe fn GetType(
        inner: *mut c_void,
    ) -> windows::Win32::Graphics::Direct3D11::D3D11_DEVICE_CONTEXT_TYPE {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .GetType)(inner)
        }
    }
    /// `GetContextFlags` on the real object.
    pub unsafe fn GetContextFlags(inner: *mut c_void) -> u32 {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .GetContextFlags)(inner)
        }
    }
    /// `FinishCommandList` on the real object.
    pub unsafe fn FinishCommandList(
        inner: *mut c_void,
        a0: windows::core::BOOL,
        a1: *mut *mut core::ffi::c_void,
    ) -> windows::core::HRESULT {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .base__
                .FinishCommandList)(inner, a0, a1)
        }
    }
    /// `CopySubresourceRegion1` on the real object.
    pub unsafe fn CopySubresourceRegion1(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: u32,
        a2: u32,
        a3: u32,
        a4: u32,
        a5: *mut core::ffi::c_void,
        a6: u32,
        a7: *const windows::Win32::Graphics::Direct3D11::D3D11_BOX,
        a8: u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .CopySubresourceRegion1)(inner, a0, a1, a2, a3, a4, a5, a6, a7, a8)
        }
    }
    /// `UpdateSubresource1` on the real object.
    pub unsafe fn UpdateSubresource1(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: u32,
        a2: *const windows::Win32::Graphics::Direct3D11::D3D11_BOX,
        a3: *const core::ffi::c_void,
        a4: u32,
        a5: u32,
        a6: u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .UpdateSubresource1)(inner, a0, a1, a2, a3, a4, a5, a6)
        }
    }
    /// `DiscardResource` on the real object.
    pub unsafe fn DiscardResource(inner: *mut c_void, a0: *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .DiscardResource)(inner, a0)
        }
    }
    /// `DiscardView` on the real object.
    pub unsafe fn DiscardView(inner: *mut c_void, a0: *mut core::ffi::c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .DiscardView)(inner, a0)
        }
    }
    /// `VSSetConstantBuffers1` on the real object.
    pub unsafe fn VSSetConstantBuffers1(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
        a3: *const u32,
        a4: *const u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .VSSetConstantBuffers1)(inner, a0, a1, a2, a3, a4)
        }
    }
    /// `HSSetConstantBuffers1` on the real object.
    pub unsafe fn HSSetConstantBuffers1(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
        a3: *const u32,
        a4: *const u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .HSSetConstantBuffers1)(inner, a0, a1, a2, a3, a4)
        }
    }
    /// `DSSetConstantBuffers1` on the real object.
    pub unsafe fn DSSetConstantBuffers1(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
        a3: *const u32,
        a4: *const u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .DSSetConstantBuffers1)(inner, a0, a1, a2, a3, a4)
        }
    }
    /// `GSSetConstantBuffers1` on the real object.
    pub unsafe fn GSSetConstantBuffers1(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
        a3: *const u32,
        a4: *const u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .GSSetConstantBuffers1)(inner, a0, a1, a2, a3, a4)
        }
    }
    /// `PSSetConstantBuffers1` on the real object.
    pub unsafe fn PSSetConstantBuffers1(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
        a3: *const u32,
        a4: *const u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .PSSetConstantBuffers1)(inner, a0, a1, a2, a3, a4)
        }
    }
    /// `CSSetConstantBuffers1` on the real object.
    pub unsafe fn CSSetConstantBuffers1(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *const *mut core::ffi::c_void,
        a3: *const u32,
        a4: *const u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .CSSetConstantBuffers1)(inner, a0, a1, a2, a3, a4)
        }
    }
    /// `VSGetConstantBuffers1` on the real object.
    pub unsafe fn VSGetConstantBuffers1(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
        a3: *mut u32,
        a4: *mut u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .VSGetConstantBuffers1)(inner, a0, a1, a2, a3, a4)
        }
    }
    /// `HSGetConstantBuffers1` on the real object.
    pub unsafe fn HSGetConstantBuffers1(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
        a3: *mut u32,
        a4: *mut u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .HSGetConstantBuffers1)(inner, a0, a1, a2, a3, a4)
        }
    }
    /// `DSGetConstantBuffers1` on the real object.
    pub unsafe fn DSGetConstantBuffers1(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
        a3: *mut u32,
        a4: *mut u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .DSGetConstantBuffers1)(inner, a0, a1, a2, a3, a4)
        }
    }
    /// `GSGetConstantBuffers1` on the real object.
    pub unsafe fn GSGetConstantBuffers1(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
        a3: *mut u32,
        a4: *mut u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .GSGetConstantBuffers1)(inner, a0, a1, a2, a3, a4)
        }
    }
    /// `PSGetConstantBuffers1` on the real object.
    pub unsafe fn PSGetConstantBuffers1(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
        a3: *mut u32,
        a4: *mut u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .PSGetConstantBuffers1)(inner, a0, a1, a2, a3, a4)
        }
    }
    /// `CSGetConstantBuffers1` on the real object.
    pub unsafe fn CSGetConstantBuffers1(
        inner: *mut c_void,
        a0: u32,
        a1: u32,
        a2: *mut *mut core::ffi::c_void,
        a3: *mut u32,
        a4: *mut u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .CSGetConstantBuffers1)(inner, a0, a1, a2, a3, a4)
        }
    }
    /// `SwapDeviceContextState` on the real object.
    pub unsafe fn SwapDeviceContextState(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: *mut *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .SwapDeviceContextState)(inner, a0, a1)
        }
    }
    /// `ClearView` on the real object.
    pub unsafe fn ClearView(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: *const f32,
        a2: *const windows::Win32::Foundation::RECT,
        a3: u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .ClearView)(inner, a0, a1, a2, a3)
        }
    }
    /// `DiscardView1` on the real object.
    pub unsafe fn DiscardView1(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: *const windows::Win32::Foundation::RECT,
        a2: u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .base__
                .DiscardView1)(inner, a0, a1, a2)
        }
    }
    /// `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::Direct3D11::D3D11_TILED_RESOURCE_COORDINATE,
        a3: *const windows::Win32::Graphics::Direct3D11::D3D11_TILE_REGION_SIZE,
        a4: *mut core::ffi::c_void,
        a5: u32,
        a6: *const u32,
        a7: *const u32,
        a8: *const u32,
        a9: u32,
    ) -> windows::core::HRESULT {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .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::Direct3D11::D3D11_TILED_RESOURCE_COORDINATE,
        a2: *mut core::ffi::c_void,
        a3: *const windows::Win32::Graphics::Direct3D11::D3D11_TILED_RESOURCE_COORDINATE,
        a4: *const windows::Win32::Graphics::Direct3D11::D3D11_TILE_REGION_SIZE,
        a5: u32,
    ) -> windows::core::HRESULT {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .CopyTileMappings)(inner, a0, a1, a2, a3, a4, a5)
        }
    }
    /// `CopyTiles` on the real object.
    pub unsafe fn CopyTiles(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: *const windows::Win32::Graphics::Direct3D11::D3D11_TILED_RESOURCE_COORDINATE,
        a2: *const windows::Win32::Graphics::Direct3D11::D3D11_TILE_REGION_SIZE,
        a3: *mut core::ffi::c_void,
        a4: u64,
        a5: u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .CopyTiles)(inner, a0, a1, a2, a3, a4, a5)
        }
    }
    /// `UpdateTiles` on the real object.
    pub unsafe fn UpdateTiles(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: *const windows::Win32::Graphics::Direct3D11::D3D11_TILED_RESOURCE_COORDINATE,
        a2: *const windows::Win32::Graphics::Direct3D11::D3D11_TILE_REGION_SIZE,
        a3: *const core::ffi::c_void,
        a4: u32,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .UpdateTiles)(inner, a0, a1, a2, a3, a4)
        }
    }
    /// `ResizeTilePool` on the real object.
    pub unsafe fn ResizeTilePool(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: u64,
    ) -> windows::core::HRESULT {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .ResizeTilePool)(inner, a0, a1)
        }
    }
    /// `TiledResourceBarrier` on the real object.
    pub unsafe fn TiledResourceBarrier(
        inner: *mut c_void,
        a0: *mut core::ffi::c_void,
        a1: *mut core::ffi::c_void,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .TiledResourceBarrier)(inner, a0, a1)
        }
    }
    /// `IsAnnotationEnabled` on the real object.
    pub unsafe fn IsAnnotationEnabled(inner: *mut c_void) -> windows::core::BOOL {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .IsAnnotationEnabled)(inner)
        }
    }
    /// `SetMarkerInt` on the real object.
    pub unsafe fn SetMarkerInt(inner: *mut c_void, a0: windows::core::PCWSTR, a1: i32) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .SetMarkerInt)(inner, a0, a1)
        }
    }
    /// `BeginEventInt` on the real object.
    pub unsafe fn BeginEventInt(inner: *mut c_void, a0: windows::core::PCWSTR, a1: i32) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .BeginEventInt)(inner, a0, a1)
        }
    }
    /// `EndEvent` on the real object.
    pub unsafe fn EndEvent(inner: *mut c_void) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .base__
                .EndEvent)(inner)
        }
    }
    /// `Flush1` on the real object.
    pub unsafe fn Flush1(
        inner: *mut c_void,
        a0: windows::Win32::Graphics::Direct3D11::D3D11_CONTEXT_TYPE,
        a1: windows::Win32::Foundation::HANDLE,
    ) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .Flush1)(inner, a0, a1)
        }
    }
    /// `SetHardwareProtectionState` on the real object.
    pub unsafe fn SetHardwareProtectionState(inner: *mut c_void, a0: windows::core::BOOL) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .SetHardwareProtectionState)(inner, a0)
        }
    }
    /// `GetHardwareProtectionState` on the real object.
    pub unsafe fn GetHardwareProtectionState(inner: *mut c_void, a0: *mut windows::core::BOOL) {
        unsafe {
            ((*(*(inner as *const *const windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .base__
                .GetHardwareProtectionState)(inner, a0)
        }
    }
    /// `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::Direct3D11::ID3D11DeviceContext4_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::Direct3D11::ID3D11DeviceContext4_Vtbl)))
                .Wait)(inner, a0, a1)
        }
    }
}

unsafe extern "system" fn QueryInterface<T: ContextMethods>(
    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: ContextMethods>(this: *mut c_void) -> u32 {
    unsafe { (*(this as *const T)).AddRef() }
}
unsafe extern "system" fn Release<T: ContextMethods>(this: *mut c_void) -> u32 {
    unsafe { (*(this as *const T)).Release() }
}
unsafe extern "system" fn GetDevice<T: ContextMethods>(this: *mut c_void, a0: *mut *mut core::ffi::c_void) {
    unsafe { (*(this as *const T)).GetDevice(a0) }
}
unsafe extern "system" fn GetPrivateData<T: ContextMethods>(
    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: ContextMethods>(
    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: ContextMethods>(
    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 VSSetConstantBuffers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).VSSetConstantBuffers(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.VSSetConstantBuffers(a0, a1, a2) });
    }
}
unsafe extern "system" fn PSSetShaderResources<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).PSSetShaderResources(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.PSSetShaderResources(a0, a1, a2) });
    }
}
unsafe extern "system" fn PSSetShader<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *const *mut core::ffi::c_void,
    a2: u32,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).PSSetShader(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.PSSetShader(a0, a1, a2) });
    }
}
unsafe extern "system" fn PSSetSamplers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).PSSetSamplers(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.PSSetSamplers(a0, a1, a2) });
    }
}
unsafe extern "system" fn VSSetShader<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *const *mut core::ffi::c_void,
    a2: u32,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).VSSetShader(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.VSSetShader(a0, a1, a2) });
    }
}
unsafe extern "system" fn DrawIndexed<T: ContextMethods>(this: *mut c_void, a0: u32, a1: u32, a2: i32) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).DrawIndexed(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.DrawIndexed(a0, a1, a2) });
    }
}
unsafe extern "system" fn Draw<T: ContextMethods>(this: *mut c_void, a0: u32, a1: u32) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).Draw(a0, a1) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.Draw(a0, a1) });
    }
}
unsafe extern "system" fn Map<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: u32,
    a2: windows::Win32::Graphics::Direct3D11::D3D11_MAP,
    a3: u32,
    a4: *mut windows::Win32::Graphics::Direct3D11::D3D11_MAPPED_SUBRESOURCE,
) -> windows::core::HRESULT {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).Map(a0, a1, a2, a3, a4) }
}
unsafe extern "system" fn Unmap<T: ContextMethods>(this: *mut c_void, a0: *mut core::ffi::c_void, a1: u32) {
    unsafe { (*(this as *const T)).before_command() };
    unsafe { (*(this as *const T)).Unmap(a0, a1) }
}
unsafe extern "system" fn PSSetConstantBuffers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).PSSetConstantBuffers(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.PSSetConstantBuffers(a0, a1, a2) });
    }
}
unsafe extern "system" fn IASetInputLayout<T: ContextMethods>(this: *mut c_void, a0: *mut core::ffi::c_void) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).IASetInputLayout(a0) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.IASetInputLayout(a0) });
    }
}
unsafe extern "system" fn IASetVertexBuffers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
    a3: *const u32,
    a4: *const u32,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).IASetVertexBuffers(a0, a1, a2, a3, a4) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.IASetVertexBuffers(a0, a1, a2, a3, a4) });
    }
}
unsafe extern "system" fn IASetIndexBuffer<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: windows::Win32::Graphics::Dxgi::Common::DXGI_FORMAT,
    a2: u32,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).IASetIndexBuffer(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.IASetIndexBuffer(a0, a1, a2) });
    }
}
unsafe extern "system" fn DrawIndexedInstanced<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: u32,
    a3: i32,
    a4: u32,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).DrawIndexedInstanced(a0, a1, a2, a3, a4) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.DrawIndexedInstanced(a0, a1, a2, a3, a4) });
    }
}
unsafe extern "system" fn DrawInstanced<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: u32,
    a3: u32,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).DrawInstanced(a0, a1, a2, a3) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.DrawInstanced(a0, a1, a2, a3) });
    }
}
unsafe extern "system" fn GSSetConstantBuffers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).GSSetConstantBuffers(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.GSSetConstantBuffers(a0, a1, a2) });
    }
}
unsafe extern "system" fn GSSetShader<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *const *mut core::ffi::c_void,
    a2: u32,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).GSSetShader(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.GSSetShader(a0, a1, a2) });
    }
}
unsafe extern "system" fn IASetPrimitiveTopology<T: ContextMethods>(
    this: *mut c_void,
    a0: windows::Win32::Graphics::Direct3D::D3D_PRIMITIVE_TOPOLOGY,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).IASetPrimitiveTopology(a0) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.IASetPrimitiveTopology(a0) });
    }
}
unsafe extern "system" fn VSSetShaderResources<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).VSSetShaderResources(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.VSSetShaderResources(a0, a1, a2) });
    }
}
unsafe extern "system" fn VSSetSamplers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).VSSetSamplers(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.VSSetSamplers(a0, a1, a2) });
    }
}
unsafe extern "system" fn Begin<T: ContextMethods>(this: *mut c_void, a0: *mut core::ffi::c_void) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).Begin(a0) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.Begin(a0) });
    }
}
unsafe extern "system" fn End<T: ContextMethods>(this: *mut c_void, a0: *mut core::ffi::c_void) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).End(a0) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.End(a0) });
    }
}
unsafe extern "system" fn GetData<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *mut core::ffi::c_void,
    a2: u32,
    a3: u32,
) -> windows::core::HRESULT {
    unsafe { (*(this as *const T)).GetData(a0, a1, a2, a3) }
}
unsafe extern "system" fn SetPredication<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: windows::core::BOOL,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).SetPredication(a0, a1) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.SetPredication(a0, a1) });
    }
}
unsafe extern "system" fn GSSetShaderResources<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).GSSetShaderResources(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.GSSetShaderResources(a0, a1, a2) });
    }
}
unsafe extern "system" fn GSSetSamplers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).GSSetSamplers(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.GSSetSamplers(a0, a1, a2) });
    }
}
unsafe extern "system" fn OMSetRenderTargets<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: *const *mut core::ffi::c_void,
    a2: *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).OMSetRenderTargets(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.OMSetRenderTargets(a0, a1, a2) });
    }
}
unsafe extern "system" fn OMSetRenderTargetsAndUnorderedAccessViews<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: *const *mut core::ffi::c_void,
    a2: *mut core::ffi::c_void,
    a3: u32,
    a4: u32,
    a5: *const *mut core::ffi::c_void,
    a6: *const u32,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).OMSetRenderTargetsAndUnorderedAccessViews(a0, a1, a2, a3, a4, a5, a6) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe {
            tape.OMSetRenderTargetsAndUnorderedAccessViews(a0, a1, a2, a3, a4, a5, a6)
        });
    }
}
unsafe extern "system" fn OMSetBlendState<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *const f32,
    a2: u32,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).OMSetBlendState(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.OMSetBlendState(a0, a1, a2) });
    }
}
unsafe extern "system" fn OMSetDepthStencilState<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: u32,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).OMSetDepthStencilState(a0, a1) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.OMSetDepthStencilState(a0, a1) });
    }
}
unsafe extern "system" fn SOSetTargets<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: *const *mut core::ffi::c_void,
    a2: *const u32,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).SOSetTargets(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.SOSetTargets(a0, a1, a2) });
    }
}
unsafe extern "system" fn DrawAuto<T: ContextMethods>(this: *mut c_void) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).DrawAuto() };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.DrawAuto() });
    }
}
unsafe extern "system" fn DrawIndexedInstancedIndirect<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: u32,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).DrawIndexedInstancedIndirect(a0, a1) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.DrawIndexedInstancedIndirect(a0, a1) });
    }
}
unsafe extern "system" fn DrawInstancedIndirect<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: u32,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).DrawInstancedIndirect(a0, a1) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.DrawInstancedIndirect(a0, a1) });
    }
}
unsafe extern "system" fn Dispatch<T: ContextMethods>(this: *mut c_void, a0: u32, a1: u32, a2: u32) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).Dispatch(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.Dispatch(a0, a1, a2) });
    }
}
unsafe extern "system" fn DispatchIndirect<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: u32,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).DispatchIndirect(a0, a1) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.DispatchIndirect(a0, a1) });
    }
}
unsafe extern "system" fn RSSetState<T: ContextMethods>(this: *mut c_void, a0: *mut core::ffi::c_void) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).RSSetState(a0) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.RSSetState(a0) });
    }
}
unsafe extern "system" fn RSSetViewports<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: *const windows::Win32::Graphics::Direct3D11::D3D11_VIEWPORT,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).RSSetViewports(a0, a1) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.RSSetViewports(a0, a1) });
    }
}
unsafe extern "system" fn RSSetScissorRects<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: *const windows::Win32::Foundation::RECT,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).RSSetScissorRects(a0, a1) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.RSSetScissorRects(a0, a1) });
    }
}
unsafe extern "system" fn CopySubresourceRegion<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: u32,
    a2: u32,
    a3: u32,
    a4: u32,
    a5: *mut core::ffi::c_void,
    a6: u32,
    a7: *const windows::Win32::Graphics::Direct3D11::D3D11_BOX,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).CopySubresourceRegion(a0, a1, a2, a3, a4, a5, a6, a7) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.CopySubresourceRegion(a0, a1, a2, a3, a4, a5, a6, a7) });
    }
}
unsafe extern "system" fn CopyResource<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).CopyResource(a0, a1) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.CopyResource(a0, a1) });
    }
}
unsafe extern "system" fn UpdateSubresource<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: u32,
    a2: *const windows::Win32::Graphics::Direct3D11::D3D11_BOX,
    a3: *const core::ffi::c_void,
    a4: u32,
    a5: u32,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).UpdateSubresource(a0, a1, a2, a3, a4, a5) }
}
unsafe extern "system" fn CopyStructureCount<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: u32,
    a2: *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).CopyStructureCount(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.CopyStructureCount(a0, a1, a2) });
    }
}
unsafe extern "system" fn ClearRenderTargetView<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *const f32,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).ClearRenderTargetView(a0, a1) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.ClearRenderTargetView(a0, a1) });
    }
}
unsafe extern "system" fn ClearUnorderedAccessViewUint<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *const u32,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).ClearUnorderedAccessViewUint(a0, a1) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.ClearUnorderedAccessViewUint(a0, a1) });
    }
}
unsafe extern "system" fn ClearUnorderedAccessViewFloat<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *const f32,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).ClearUnorderedAccessViewFloat(a0, a1) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.ClearUnorderedAccessViewFloat(a0, a1) });
    }
}
unsafe extern "system" fn ClearDepthStencilView<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: u32,
    a2: f32,
    a3: u8,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).ClearDepthStencilView(a0, a1, a2, a3) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.ClearDepthStencilView(a0, a1, a2, a3) });
    }
}
unsafe extern "system" fn GenerateMips<T: ContextMethods>(this: *mut c_void, a0: *mut core::ffi::c_void) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).GenerateMips(a0) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.GenerateMips(a0) });
    }
}
unsafe extern "system" fn SetResourceMinLOD<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: f32,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).SetResourceMinLOD(a0, a1) };
    if let Some(r) = recorder {
        r.gap("SetResourceMinLOD cannot be reconstructed exactly");
    }
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.SetResourceMinLOD(a0, a1) });
    }
}
unsafe extern "system" fn GetResourceMinLOD<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
) -> f32 {
    unsafe { (*(this as *const T)).GetResourceMinLOD(a0) }
}
unsafe extern "system" fn ResolveSubresource<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: u32,
    a2: *mut core::ffi::c_void,
    a3: u32,
    a4: windows::Win32::Graphics::Dxgi::Common::DXGI_FORMAT,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).ResolveSubresource(a0, a1, a2, a3, a4) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.ResolveSubresource(a0, a1, a2, a3, a4) });
    }
}
unsafe extern "system" fn ExecuteCommandList<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: windows::core::BOOL,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).ExecuteCommandList(a0, a1) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.ExecuteCommandList(a0, a1) });
    }
}
unsafe extern "system" fn HSSetShaderResources<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).HSSetShaderResources(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.HSSetShaderResources(a0, a1, a2) });
    }
}
unsafe extern "system" fn HSSetShader<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *const *mut core::ffi::c_void,
    a2: u32,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).HSSetShader(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.HSSetShader(a0, a1, a2) });
    }
}
unsafe extern "system" fn HSSetSamplers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).HSSetSamplers(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.HSSetSamplers(a0, a1, a2) });
    }
}
unsafe extern "system" fn HSSetConstantBuffers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).HSSetConstantBuffers(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.HSSetConstantBuffers(a0, a1, a2) });
    }
}
unsafe extern "system" fn DSSetShaderResources<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).DSSetShaderResources(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.DSSetShaderResources(a0, a1, a2) });
    }
}
unsafe extern "system" fn DSSetShader<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *const *mut core::ffi::c_void,
    a2: u32,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).DSSetShader(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.DSSetShader(a0, a1, a2) });
    }
}
unsafe extern "system" fn DSSetSamplers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).DSSetSamplers(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.DSSetSamplers(a0, a1, a2) });
    }
}
unsafe extern "system" fn DSSetConstantBuffers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).DSSetConstantBuffers(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.DSSetConstantBuffers(a0, a1, a2) });
    }
}
unsafe extern "system" fn CSSetShaderResources<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).CSSetShaderResources(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.CSSetShaderResources(a0, a1, a2) });
    }
}
unsafe extern "system" fn CSSetUnorderedAccessViews<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
    a3: *const u32,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).CSSetUnorderedAccessViews(a0, a1, a2, a3) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.CSSetUnorderedAccessViews(a0, a1, a2, a3) });
    }
}
unsafe extern "system" fn CSSetShader<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *const *mut core::ffi::c_void,
    a2: u32,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).CSSetShader(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.CSSetShader(a0, a1, a2) });
    }
}
unsafe extern "system" fn CSSetSamplers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).CSSetSamplers(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.CSSetSamplers(a0, a1, a2) });
    }
}
unsafe extern "system" fn CSSetConstantBuffers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).CSSetConstantBuffers(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.CSSetConstantBuffers(a0, a1, a2) });
    }
}
unsafe extern "system" fn VSGetConstantBuffers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).VSGetConstantBuffers(a0, a1, a2) }
}
unsafe extern "system" fn PSGetShaderResources<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).PSGetShaderResources(a0, a1, a2) }
}
unsafe extern "system" fn PSGetShader<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut *mut core::ffi::c_void,
    a1: *mut *mut core::ffi::c_void,
    a2: *mut u32,
) {
    unsafe { (*(this as *const T)).PSGetShader(a0, a1, a2) }
}
unsafe extern "system" fn PSGetSamplers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).PSGetSamplers(a0, a1, a2) }
}
unsafe extern "system" fn VSGetShader<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut *mut core::ffi::c_void,
    a1: *mut *mut core::ffi::c_void,
    a2: *mut u32,
) {
    unsafe { (*(this as *const T)).VSGetShader(a0, a1, a2) }
}
unsafe extern "system" fn PSGetConstantBuffers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).PSGetConstantBuffers(a0, a1, a2) }
}
unsafe extern "system" fn IAGetInputLayout<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).IAGetInputLayout(a0) }
}
unsafe extern "system" fn IAGetVertexBuffers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
    a3: *mut u32,
    a4: *mut u32,
) {
    unsafe { (*(this as *const T)).IAGetVertexBuffers(a0, a1, a2, a3, a4) }
}
unsafe extern "system" fn IAGetIndexBuffer<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut *mut core::ffi::c_void,
    a1: *mut windows::Win32::Graphics::Dxgi::Common::DXGI_FORMAT,
    a2: *mut u32,
) {
    unsafe { (*(this as *const T)).IAGetIndexBuffer(a0, a1, a2) }
}
unsafe extern "system" fn GSGetConstantBuffers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).GSGetConstantBuffers(a0, a1, a2) }
}
unsafe extern "system" fn GSGetShader<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut *mut core::ffi::c_void,
    a1: *mut *mut core::ffi::c_void,
    a2: *mut u32,
) {
    unsafe { (*(this as *const T)).GSGetShader(a0, a1, a2) }
}
unsafe extern "system" fn IAGetPrimitiveTopology<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut windows::Win32::Graphics::Direct3D::D3D_PRIMITIVE_TOPOLOGY,
) {
    unsafe { (*(this as *const T)).IAGetPrimitiveTopology(a0) }
}
unsafe extern "system" fn VSGetShaderResources<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).VSGetShaderResources(a0, a1, a2) }
}
unsafe extern "system" fn VSGetSamplers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).VSGetSamplers(a0, a1, a2) }
}
unsafe extern "system" fn GetPredication<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut *mut core::ffi::c_void,
    a1: *mut windows::core::BOOL,
) {
    unsafe { (*(this as *const T)).GetPredication(a0, a1) }
}
unsafe extern "system" fn GSGetShaderResources<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).GSGetShaderResources(a0, a1, a2) }
}
unsafe extern "system" fn GSGetSamplers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).GSGetSamplers(a0, a1, a2) }
}
unsafe extern "system" fn OMGetRenderTargets<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: *mut *mut core::ffi::c_void,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).OMGetRenderTargets(a0, a1, a2) }
}
unsafe extern "system" fn OMGetRenderTargetsAndUnorderedAccessViews<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: *mut *mut core::ffi::c_void,
    a2: *mut *mut core::ffi::c_void,
    a3: u32,
    a4: u32,
    a5: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).OMGetRenderTargetsAndUnorderedAccessViews(a0, a1, a2, a3, a4, a5) }
}
unsafe extern "system" fn OMGetBlendState<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut *mut core::ffi::c_void,
    a1: *mut f32,
    a2: *mut u32,
) {
    unsafe { (*(this as *const T)).OMGetBlendState(a0, a1, a2) }
}
unsafe extern "system" fn OMGetDepthStencilState<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut *mut core::ffi::c_void,
    a1: *mut u32,
) {
    unsafe { (*(this as *const T)).OMGetDepthStencilState(a0, a1) }
}
unsafe extern "system" fn SOGetTargets<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).SOGetTargets(a0, a1) }
}
unsafe extern "system" fn RSGetState<T: ContextMethods>(this: *mut c_void, a0: *mut *mut core::ffi::c_void) {
    unsafe { (*(this as *const T)).RSGetState(a0) }
}
unsafe extern "system" fn RSGetViewports<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut u32,
    a1: *mut windows::Win32::Graphics::Direct3D11::D3D11_VIEWPORT,
) {
    unsafe { (*(this as *const T)).RSGetViewports(a0, a1) }
}
unsafe extern "system" fn RSGetScissorRects<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut u32,
    a1: *mut windows::Win32::Foundation::RECT,
) {
    unsafe { (*(this as *const T)).RSGetScissorRects(a0, a1) }
}
unsafe extern "system" fn HSGetShaderResources<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).HSGetShaderResources(a0, a1, a2) }
}
unsafe extern "system" fn HSGetShader<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut *mut core::ffi::c_void,
    a1: *mut *mut core::ffi::c_void,
    a2: *mut u32,
) {
    unsafe { (*(this as *const T)).HSGetShader(a0, a1, a2) }
}
unsafe extern "system" fn HSGetSamplers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).HSGetSamplers(a0, a1, a2) }
}
unsafe extern "system" fn HSGetConstantBuffers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).HSGetConstantBuffers(a0, a1, a2) }
}
unsafe extern "system" fn DSGetShaderResources<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).DSGetShaderResources(a0, a1, a2) }
}
unsafe extern "system" fn DSGetShader<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut *mut core::ffi::c_void,
    a1: *mut *mut core::ffi::c_void,
    a2: *mut u32,
) {
    unsafe { (*(this as *const T)).DSGetShader(a0, a1, a2) }
}
unsafe extern "system" fn DSGetSamplers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).DSGetSamplers(a0, a1, a2) }
}
unsafe extern "system" fn DSGetConstantBuffers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).DSGetConstantBuffers(a0, a1, a2) }
}
unsafe extern "system" fn CSGetShaderResources<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).CSGetShaderResources(a0, a1, a2) }
}
unsafe extern "system" fn CSGetUnorderedAccessViews<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).CSGetUnorderedAccessViews(a0, a1, a2) }
}
unsafe extern "system" fn CSGetShader<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut *mut core::ffi::c_void,
    a1: *mut *mut core::ffi::c_void,
    a2: *mut u32,
) {
    unsafe { (*(this as *const T)).CSGetShader(a0, a1, a2) }
}
unsafe extern "system" fn CSGetSamplers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).CSGetSamplers(a0, a1, a2) }
}
unsafe extern "system" fn CSGetConstantBuffers<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).CSGetConstantBuffers(a0, a1, a2) }
}
unsafe extern "system" fn ClearState<T: ContextMethods>(this: *mut c_void) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).ClearState() };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.ClearState() });
    }
}
unsafe extern "system" fn Flush<T: ContextMethods>(this: *mut c_void) {
    unsafe { (*(this as *const T)).Flush() }
}
unsafe extern "system" fn GetType<T: ContextMethods>(
    this: *mut c_void,
) -> windows::Win32::Graphics::Direct3D11::D3D11_DEVICE_CONTEXT_TYPE {
    unsafe { (*(this as *const T)).GetType() }
}
unsafe extern "system" fn GetContextFlags<T: ContextMethods>(this: *mut c_void) -> u32 {
    unsafe { (*(this as *const T)).GetContextFlags() }
}
unsafe extern "system" fn FinishCommandList<T: ContextMethods>(
    this: *mut c_void,
    a0: windows::core::BOOL,
    a1: *mut *mut core::ffi::c_void,
) -> windows::core::HRESULT {
    unsafe { (*(this as *const T)).FinishCommandList(a0, a1) }
}
unsafe extern "system" fn CopySubresourceRegion1<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: u32,
    a2: u32,
    a3: u32,
    a4: u32,
    a5: *mut core::ffi::c_void,
    a6: u32,
    a7: *const windows::Win32::Graphics::Direct3D11::D3D11_BOX,
    a8: u32,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).CopySubresourceRegion1(a0, a1, a2, a3, a4, a5, a6, a7, a8) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.CopySubresourceRegion1(a0, a1, a2, a3, a4, a5, a6, a7, a8) });
    }
}
unsafe extern "system" fn UpdateSubresource1<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: u32,
    a2: *const windows::Win32::Graphics::Direct3D11::D3D11_BOX,
    a3: *const core::ffi::c_void,
    a4: u32,
    a5: u32,
    a6: u32,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).UpdateSubresource1(a0, a1, a2, a3, a4, a5, a6) }
}
unsafe extern "system" fn DiscardResource<T: ContextMethods>(this: *mut c_void, a0: *mut core::ffi::c_void) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).DiscardResource(a0) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.DiscardResource(a0) });
    }
}
unsafe extern "system" fn DiscardView<T: ContextMethods>(this: *mut c_void, a0: *mut core::ffi::c_void) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).DiscardView(a0) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.DiscardView(a0) });
    }
}
unsafe extern "system" fn VSSetConstantBuffers1<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
    a3: *const u32,
    a4: *const u32,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).VSSetConstantBuffers1(a0, a1, a2, a3, a4) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.VSSetConstantBuffers1(a0, a1, a2, a3, a4) });
    }
}
unsafe extern "system" fn HSSetConstantBuffers1<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
    a3: *const u32,
    a4: *const u32,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).HSSetConstantBuffers1(a0, a1, a2, a3, a4) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.HSSetConstantBuffers1(a0, a1, a2, a3, a4) });
    }
}
unsafe extern "system" fn DSSetConstantBuffers1<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
    a3: *const u32,
    a4: *const u32,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).DSSetConstantBuffers1(a0, a1, a2, a3, a4) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.DSSetConstantBuffers1(a0, a1, a2, a3, a4) });
    }
}
unsafe extern "system" fn GSSetConstantBuffers1<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
    a3: *const u32,
    a4: *const u32,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).GSSetConstantBuffers1(a0, a1, a2, a3, a4) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.GSSetConstantBuffers1(a0, a1, a2, a3, a4) });
    }
}
unsafe extern "system" fn PSSetConstantBuffers1<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
    a3: *const u32,
    a4: *const u32,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).PSSetConstantBuffers1(a0, a1, a2, a3, a4) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.PSSetConstantBuffers1(a0, a1, a2, a3, a4) });
    }
}
unsafe extern "system" fn CSSetConstantBuffers1<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *const *mut core::ffi::c_void,
    a3: *const u32,
    a4: *const u32,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).CSSetConstantBuffers1(a0, a1, a2, a3, a4) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.CSSetConstantBuffers1(a0, a1, a2, a3, a4) });
    }
}
unsafe extern "system" fn VSGetConstantBuffers1<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
    a3: *mut u32,
    a4: *mut u32,
) {
    unsafe { (*(this as *const T)).VSGetConstantBuffers1(a0, a1, a2, a3, a4) }
}
unsafe extern "system" fn HSGetConstantBuffers1<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
    a3: *mut u32,
    a4: *mut u32,
) {
    unsafe { (*(this as *const T)).HSGetConstantBuffers1(a0, a1, a2, a3, a4) }
}
unsafe extern "system" fn DSGetConstantBuffers1<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
    a3: *mut u32,
    a4: *mut u32,
) {
    unsafe { (*(this as *const T)).DSGetConstantBuffers1(a0, a1, a2, a3, a4) }
}
unsafe extern "system" fn GSGetConstantBuffers1<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
    a3: *mut u32,
    a4: *mut u32,
) {
    unsafe { (*(this as *const T)).GSGetConstantBuffers1(a0, a1, a2, a3, a4) }
}
unsafe extern "system" fn PSGetConstantBuffers1<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
    a3: *mut u32,
    a4: *mut u32,
) {
    unsafe { (*(this as *const T)).PSGetConstantBuffers1(a0, a1, a2, a3, a4) }
}
unsafe extern "system" fn CSGetConstantBuffers1<T: ContextMethods>(
    this: *mut c_void,
    a0: u32,
    a1: u32,
    a2: *mut *mut core::ffi::c_void,
    a3: *mut u32,
    a4: *mut u32,
) {
    unsafe { (*(this as *const T)).CSGetConstantBuffers1(a0, a1, a2, a3, a4) }
}
unsafe extern "system" fn SwapDeviceContextState<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *mut *mut core::ffi::c_void,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).SwapDeviceContextState(a0, a1) };
    if let Some(r) = recorder {
        r.gap("SwapDeviceContextState cannot be reconstructed exactly");
    }
}
unsafe extern "system" fn ClearView<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *const f32,
    a2: *const windows::Win32::Foundation::RECT,
    a3: u32,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).ClearView(a0, a1, a2, a3) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.ClearView(a0, a1, a2, a3) });
    }
}
unsafe extern "system" fn DiscardView1<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *const windows::Win32::Foundation::RECT,
    a2: u32,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).DiscardView1(a0, a1, a2) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.DiscardView1(a0, a1, a2) });
    }
}
unsafe extern "system" fn UpdateTileMappings<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: u32,
    a2: *const windows::Win32::Graphics::Direct3D11::D3D11_TILED_RESOURCE_COORDINATE,
    a3: *const windows::Win32::Graphics::Direct3D11::D3D11_TILE_REGION_SIZE,
    a4: *mut core::ffi::c_void,
    a5: u32,
    a6: *const u32,
    a7: *const u32,
    a8: *const u32,
    a9: u32,
) -> windows::core::HRESULT {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    let result = unsafe { (*(this as *const T)).UpdateTileMappings(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) };
    if result.is_ok()
        && let Some(r) = recorder
    {
        r.record(|tape| unsafe { tape.UpdateTileMappings(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) });
    }
    result
}
unsafe extern "system" fn CopyTileMappings<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *const windows::Win32::Graphics::Direct3D11::D3D11_TILED_RESOURCE_COORDINATE,
    a2: *mut core::ffi::c_void,
    a3: *const windows::Win32::Graphics::Direct3D11::D3D11_TILED_RESOURCE_COORDINATE,
    a4: *const windows::Win32::Graphics::Direct3D11::D3D11_TILE_REGION_SIZE,
    a5: u32,
) -> windows::core::HRESULT {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    let result = unsafe { (*(this as *const T)).CopyTileMappings(a0, a1, a2, a3, a4, a5) };
    if result.is_ok()
        && let Some(r) = recorder
    {
        r.record(|tape| unsafe { tape.CopyTileMappings(a0, a1, a2, a3, a4, a5) });
    }
    result
}
unsafe extern "system" fn CopyTiles<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *const windows::Win32::Graphics::Direct3D11::D3D11_TILED_RESOURCE_COORDINATE,
    a2: *const windows::Win32::Graphics::Direct3D11::D3D11_TILE_REGION_SIZE,
    a3: *mut core::ffi::c_void,
    a4: u64,
    a5: u32,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).CopyTiles(a0, a1, a2, a3, a4, a5) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.CopyTiles(a0, a1, a2, a3, a4, a5) });
    }
}
unsafe extern "system" fn UpdateTiles<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *const windows::Win32::Graphics::Direct3D11::D3D11_TILED_RESOURCE_COORDINATE,
    a2: *const windows::Win32::Graphics::Direct3D11::D3D11_TILE_REGION_SIZE,
    a3: *const core::ffi::c_void,
    a4: u32,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).UpdateTiles(a0, a1, a2, a3, a4) }
}
unsafe extern "system" fn ResizeTilePool<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: u64,
) -> windows::core::HRESULT {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    let result = unsafe { (*(this as *const T)).ResizeTilePool(a0, a1) };
    if result.is_ok()
        && let Some(r) = recorder
    {
        r.record(|tape| unsafe { tape.ResizeTilePool(a0, a1) });
    }
    result
}
unsafe extern "system" fn TiledResourceBarrier<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: *mut core::ffi::c_void,
) {
    unsafe { (*(this as *const T)).before_command() };
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).TiledResourceBarrier(a0, a1) };
    if let Some(r) = recorder {
        r.record(|tape| unsafe { tape.TiledResourceBarrier(a0, a1) });
    }
}
unsafe extern "system" fn IsAnnotationEnabled<T: ContextMethods>(this: *mut c_void) -> windows::core::BOOL {
    unsafe { (*(this as *const T)).IsAnnotationEnabled() }
}
unsafe extern "system" fn SetMarkerInt<T: ContextMethods>(
    this: *mut c_void,
    a0: windows::core::PCWSTR,
    a1: i32,
) {
    unsafe { (*(this as *const T)).SetMarkerInt(a0, a1) }
}
unsafe extern "system" fn BeginEventInt<T: ContextMethods>(
    this: *mut c_void,
    a0: windows::core::PCWSTR,
    a1: i32,
) {
    unsafe { (*(this as *const T)).BeginEventInt(a0, a1) }
}
unsafe extern "system" fn EndEvent<T: ContextMethods>(this: *mut c_void) {
    unsafe { (*(this as *const T)).EndEvent() }
}
unsafe extern "system" fn Flush1<T: ContextMethods>(
    this: *mut c_void,
    a0: windows::Win32::Graphics::Direct3D11::D3D11_CONTEXT_TYPE,
    a1: windows::Win32::Foundation::HANDLE,
) {
    unsafe { (*(this as *const T)).Flush1(a0, a1) }
}
unsafe extern "system" fn SetHardwareProtectionState<T: ContextMethods>(
    this: *mut c_void,
    a0: windows::core::BOOL,
) {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    unsafe { (*(this as *const T)).SetHardwareProtectionState(a0) };
    if let Some(r) = recorder {
        r.gap("SetHardwareProtectionState cannot be reconstructed exactly");
    }
}
unsafe extern "system" fn GetHardwareProtectionState<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut windows::core::BOOL,
) {
    unsafe { (*(this as *const T)).GetHardwareProtectionState(a0) }
}
unsafe extern "system" fn Signal<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: u64,
) -> windows::core::HRESULT {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    let result = unsafe { (*(this as *const T)).Signal(a0, a1) };
    if result.is_ok()
        && let Some(r) = recorder
    {
        r.gap("Signal cannot be reconstructed exactly");
    }
    result
}
unsafe extern "system" fn Wait<T: ContextMethods>(
    this: *mut c_void,
    a0: *mut core::ffi::c_void,
    a1: u64,
) -> windows::core::HRESULT {
    let object = unsafe { &*(this as *const T) };
    let recorder = object.recorder();
    if let Some(r) = recorder {
        unsafe { r.begin(object.inner()) };
    }
    let result = unsafe { (*(this as *const T)).Wait(a0, a1) };
    if result.is_ok()
        && let Some(r) = recorder
    {
        r.gap("Wait cannot be reconstructed exactly");
    }
    result
}

/// The `ID3D11DeviceContext4` vtable whose entries call `T`'s methods.
pub const fn vtable<T: ContextMethods>() -> windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl {
    windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext4_Vtbl {
        base__: windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext3_Vtbl {
            base__: windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext2_Vtbl {
                base__: windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext1_Vtbl {
                    base__: windows::Win32::Graphics::Direct3D11::ID3D11DeviceContext_Vtbl {
                        base__: windows::Win32::Graphics::Direct3D11::ID3D11DeviceChild_Vtbl {
                            base__: windows::core::IUnknown_Vtbl {
                                QueryInterface: QueryInterface::<T>,
                                AddRef: AddRef::<T>,
                                Release: Release::<T>,
                            },
                            GetDevice: GetDevice::<T>,
                            GetPrivateData: GetPrivateData::<T>,
                            SetPrivateData: SetPrivateData::<T>,
                            SetPrivateDataInterface: SetPrivateDataInterface::<T>,
                        },
                        VSSetConstantBuffers: VSSetConstantBuffers::<T>,
                        PSSetShaderResources: PSSetShaderResources::<T>,
                        PSSetShader: PSSetShader::<T>,
                        PSSetSamplers: PSSetSamplers::<T>,
                        VSSetShader: VSSetShader::<T>,
                        DrawIndexed: DrawIndexed::<T>,
                        Draw: Draw::<T>,
                        Map: Map::<T>,
                        Unmap: Unmap::<T>,
                        PSSetConstantBuffers: PSSetConstantBuffers::<T>,
                        IASetInputLayout: IASetInputLayout::<T>,
                        IASetVertexBuffers: IASetVertexBuffers::<T>,
                        IASetIndexBuffer: IASetIndexBuffer::<T>,
                        DrawIndexedInstanced: DrawIndexedInstanced::<T>,
                        DrawInstanced: DrawInstanced::<T>,
                        GSSetConstantBuffers: GSSetConstantBuffers::<T>,
                        GSSetShader: GSSetShader::<T>,
                        IASetPrimitiveTopology: IASetPrimitiveTopology::<T>,
                        VSSetShaderResources: VSSetShaderResources::<T>,
                        VSSetSamplers: VSSetSamplers::<T>,
                        Begin: Begin::<T>,
                        End: End::<T>,
                        GetData: GetData::<T>,
                        SetPredication: SetPredication::<T>,
                        GSSetShaderResources: GSSetShaderResources::<T>,
                        GSSetSamplers: GSSetSamplers::<T>,
                        OMSetRenderTargets: OMSetRenderTargets::<T>,
                        OMSetRenderTargetsAndUnorderedAccessViews: OMSetRenderTargetsAndUnorderedAccessViews::<
                            T,
                        >,
                        OMSetBlendState: OMSetBlendState::<T>,
                        OMSetDepthStencilState: OMSetDepthStencilState::<T>,
                        SOSetTargets: SOSetTargets::<T>,
                        DrawAuto: DrawAuto::<T>,
                        DrawIndexedInstancedIndirect: DrawIndexedInstancedIndirect::<T>,
                        DrawInstancedIndirect: DrawInstancedIndirect::<T>,
                        Dispatch: Dispatch::<T>,
                        DispatchIndirect: DispatchIndirect::<T>,
                        RSSetState: RSSetState::<T>,
                        RSSetViewports: RSSetViewports::<T>,
                        RSSetScissorRects: RSSetScissorRects::<T>,
                        CopySubresourceRegion: CopySubresourceRegion::<T>,
                        CopyResource: CopyResource::<T>,
                        UpdateSubresource: UpdateSubresource::<T>,
                        CopyStructureCount: CopyStructureCount::<T>,
                        ClearRenderTargetView: ClearRenderTargetView::<T>,
                        ClearUnorderedAccessViewUint: ClearUnorderedAccessViewUint::<T>,
                        ClearUnorderedAccessViewFloat: ClearUnorderedAccessViewFloat::<T>,
                        ClearDepthStencilView: ClearDepthStencilView::<T>,
                        GenerateMips: GenerateMips::<T>,
                        SetResourceMinLOD: SetResourceMinLOD::<T>,
                        GetResourceMinLOD: GetResourceMinLOD::<T>,
                        ResolveSubresource: ResolveSubresource::<T>,
                        ExecuteCommandList: ExecuteCommandList::<T>,
                        HSSetShaderResources: HSSetShaderResources::<T>,
                        HSSetShader: HSSetShader::<T>,
                        HSSetSamplers: HSSetSamplers::<T>,
                        HSSetConstantBuffers: HSSetConstantBuffers::<T>,
                        DSSetShaderResources: DSSetShaderResources::<T>,
                        DSSetShader: DSSetShader::<T>,
                        DSSetSamplers: DSSetSamplers::<T>,
                        DSSetConstantBuffers: DSSetConstantBuffers::<T>,
                        CSSetShaderResources: CSSetShaderResources::<T>,
                        CSSetUnorderedAccessViews: CSSetUnorderedAccessViews::<T>,
                        CSSetShader: CSSetShader::<T>,
                        CSSetSamplers: CSSetSamplers::<T>,
                        CSSetConstantBuffers: CSSetConstantBuffers::<T>,
                        VSGetConstantBuffers: VSGetConstantBuffers::<T>,
                        PSGetShaderResources: PSGetShaderResources::<T>,
                        PSGetShader: PSGetShader::<T>,
                        PSGetSamplers: PSGetSamplers::<T>,
                        VSGetShader: VSGetShader::<T>,
                        PSGetConstantBuffers: PSGetConstantBuffers::<T>,
                        IAGetInputLayout: IAGetInputLayout::<T>,
                        IAGetVertexBuffers: IAGetVertexBuffers::<T>,
                        IAGetIndexBuffer: IAGetIndexBuffer::<T>,
                        GSGetConstantBuffers: GSGetConstantBuffers::<T>,
                        GSGetShader: GSGetShader::<T>,
                        IAGetPrimitiveTopology: IAGetPrimitiveTopology::<T>,
                        VSGetShaderResources: VSGetShaderResources::<T>,
                        VSGetSamplers: VSGetSamplers::<T>,
                        GetPredication: GetPredication::<T>,
                        GSGetShaderResources: GSGetShaderResources::<T>,
                        GSGetSamplers: GSGetSamplers::<T>,
                        OMGetRenderTargets: OMGetRenderTargets::<T>,
                        OMGetRenderTargetsAndUnorderedAccessViews: OMGetRenderTargetsAndUnorderedAccessViews::<
                            T,
                        >,
                        OMGetBlendState: OMGetBlendState::<T>,
                        OMGetDepthStencilState: OMGetDepthStencilState::<T>,
                        SOGetTargets: SOGetTargets::<T>,
                        RSGetState: RSGetState::<T>,
                        RSGetViewports: RSGetViewports::<T>,
                        RSGetScissorRects: RSGetScissorRects::<T>,
                        HSGetShaderResources: HSGetShaderResources::<T>,
                        HSGetShader: HSGetShader::<T>,
                        HSGetSamplers: HSGetSamplers::<T>,
                        HSGetConstantBuffers: HSGetConstantBuffers::<T>,
                        DSGetShaderResources: DSGetShaderResources::<T>,
                        DSGetShader: DSGetShader::<T>,
                        DSGetSamplers: DSGetSamplers::<T>,
                        DSGetConstantBuffers: DSGetConstantBuffers::<T>,
                        CSGetShaderResources: CSGetShaderResources::<T>,
                        CSGetUnorderedAccessViews: CSGetUnorderedAccessViews::<T>,
                        CSGetShader: CSGetShader::<T>,
                        CSGetSamplers: CSGetSamplers::<T>,
                        CSGetConstantBuffers: CSGetConstantBuffers::<T>,
                        ClearState: ClearState::<T>,
                        Flush: Flush::<T>,
                        GetType: GetType::<T>,
                        GetContextFlags: GetContextFlags::<T>,
                        FinishCommandList: FinishCommandList::<T>,
                    },
                    CopySubresourceRegion1: CopySubresourceRegion1::<T>,
                    UpdateSubresource1: UpdateSubresource1::<T>,
                    DiscardResource: DiscardResource::<T>,
                    DiscardView: DiscardView::<T>,
                    VSSetConstantBuffers1: VSSetConstantBuffers1::<T>,
                    HSSetConstantBuffers1: HSSetConstantBuffers1::<T>,
                    DSSetConstantBuffers1: DSSetConstantBuffers1::<T>,
                    GSSetConstantBuffers1: GSSetConstantBuffers1::<T>,
                    PSSetConstantBuffers1: PSSetConstantBuffers1::<T>,
                    CSSetConstantBuffers1: CSSetConstantBuffers1::<T>,
                    VSGetConstantBuffers1: VSGetConstantBuffers1::<T>,
                    HSGetConstantBuffers1: HSGetConstantBuffers1::<T>,
                    DSGetConstantBuffers1: DSGetConstantBuffers1::<T>,
                    GSGetConstantBuffers1: GSGetConstantBuffers1::<T>,
                    PSGetConstantBuffers1: PSGetConstantBuffers1::<T>,
                    CSGetConstantBuffers1: CSGetConstantBuffers1::<T>,
                    SwapDeviceContextState: SwapDeviceContextState::<T>,
                    ClearView: ClearView::<T>,
                    DiscardView1: DiscardView1::<T>,
                },
                UpdateTileMappings: UpdateTileMappings::<T>,
                CopyTileMappings: CopyTileMappings::<T>,
                CopyTiles: CopyTiles::<T>,
                UpdateTiles: UpdateTiles::<T>,
                ResizeTilePool: ResizeTilePool::<T>,
                TiledResourceBarrier: TiledResourceBarrier::<T>,
                IsAnnotationEnabled: IsAnnotationEnabled::<T>,
                SetMarkerInt: SetMarkerInt::<T>,
                BeginEventInt: BeginEventInt::<T>,
                EndEvent: EndEvent::<T>,
            },
            Flush1: Flush1::<T>,
            SetHardwareProtectionState: SetHardwareProtectionState::<T>,
            GetHardwareProtectionState: GetHardwareProtectionState::<T>,
        },
        Signal: Signal::<T>,
        Wait: Wait::<T>,
    }
}