rust-webvr 0.2.0

#![allow(non_snake_case)]
#![allow(non_camel_case_types)]
#![allow(dead_code)]
#![allow(non_upper_case_globals)]
// bindgen openvr_capi.h --output binding.rs
/* automatically generated by rust-bindgen */

pub const _SAL_VERSION: ::std::os::raw::c_uint = 20;
pub const __SAL_H_VERSION: ::std::os::raw::c_uint = 180000000;
pub const _USE_DECLSPECS_FOR_SAL: ::std::os::raw::c_uint = 0;
pub const _USE_ATTRIBUTES_FOR_SAL: ::std::os::raw::c_uint = 0;
pub const _CRT_PACKING: ::std::os::raw::c_uint = 8;
pub const _HAS_EXCEPTIONS: ::std::os::raw::c_uint = 1;
pub const WCHAR_MIN: ::std::os::raw::c_uint = 0;
pub const WCHAR_MAX: ::std::os::raw::c_uint = 65535;
pub const WINT_MIN: ::std::os::raw::c_uint = 0;
pub const WINT_MAX: ::std::os::raw::c_uint = 65535;
pub const true_: ::std::os::raw::c_uint = 1;
pub const false_: ::std::os::raw::c_uint = 0;
pub const __bool_true_false_are_defined: ::std::os::raw::c_uint = 1;
pub type va_list = *mut ::std::os::raw::c_char;
extern "C" {
    pub fn __va_start(arg1: *mut va_list, ...);
}
pub type __vcrt_bool = bool;
pub type wchar_t = ::std::os::raw::c_ushort;
extern "C" {
    pub fn __security_init_cookie();
}
extern "C" {
    pub fn __security_check_cookie(_StackCookie: usize);
}
extern "C" {
    pub fn __report_gsfailure(_StackCookie: usize);
}
extern "C" {
    #[link_name = "__security_cookie"]
    pub static mut __security_cookie: usize;
}
pub type int_least8_t = ::std::os::raw::c_char;
pub type int_least16_t = ::std::os::raw::c_short;
pub type int_least32_t = ::std::os::raw::c_int;
pub type int_least64_t = ::std::os::raw::c_longlong;
pub type uint_least8_t = ::std::os::raw::c_uchar;
pub type uint_least16_t = ::std::os::raw::c_ushort;
pub type uint_least32_t = ::std::os::raw::c_uint;
pub type uint_least64_t = ::std::os::raw::c_ulonglong;
pub type int_fast8_t = ::std::os::raw::c_char;
pub type int_fast16_t = ::std::os::raw::c_int;
pub type int_fast32_t = ::std::os::raw::c_int;
pub type int_fast64_t = ::std::os::raw::c_longlong;
pub type uint_fast8_t = ::std::os::raw::c_uchar;
pub type uint_fast16_t = ::std::os::raw::c_uint;
pub type uint_fast32_t = ::std::os::raw::c_uint;
pub type uint_fast64_t = ::std::os::raw::c_ulonglong;
pub type intmax_t = ::std::os::raw::c_longlong;
pub type uintmax_t = ::std::os::raw::c_ulonglong;
pub const k_unMaxDriverDebugResponseSize: ::std::os::raw::c_uint = 32768;
pub const k_unTrackedDeviceIndex_Hmd: ::std::os::raw::c_uint = 0;
pub const k_unMaxTrackedDeviceCount: ::std::os::raw::c_uint = 16;
pub const k_unTrackedDeviceIndexOther: ::std::os::raw::c_uint = 4294967294;
pub const k_unTrackedDeviceIndexInvalid: ::std::os::raw::c_uint = 4294967295;
pub const k_unMaxPropertyStringSize: ::std::os::raw::c_uint = 32768;
pub const k_unControllerStateAxisCount: ::std::os::raw::c_uint = 5;
pub const k_ulOverlayHandleInvalid: ::std::os::raw::c_ulong = 0;
pub const k_unScreenshotHandleInvalid: ::std::os::raw::c_uint = 0;
pub const k_unMaxApplicationKeyLength: ::std::os::raw::c_uint = 128;
pub const k_unVROverlayMaxKeyLength: ::std::os::raw::c_uint = 128;
pub const k_unVROverlayMaxNameLength: ::std::os::raw::c_uint = 128;
pub const k_unMaxOverlayCount: ::std::os::raw::c_uint = 64;
pub const k_unMaxOverlayIntersectionMaskPrimitivesCount:
          ::std::os::raw::c_uint =
    32;
pub const k_unNotificationTextMaxSize: ::std::os::raw::c_uint = 256;
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVREye { EVREye_Eye_Left = 0, EVREye_Eye_Right = 1, }
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EGraphicsAPIConvention {
    EGraphicsAPIConvention_API_DirectX = 0,
    EGraphicsAPIConvention_API_OpenGL = 1,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EColorSpace {
    EColorSpace_ColorSpace_Auto = 0,
    EColorSpace_ColorSpace_Gamma = 1,
    EColorSpace_ColorSpace_Linear = 2,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum ETrackingResult {
    ETrackingResult_TrackingResult_Uninitialized = 1,
    ETrackingResult_TrackingResult_Calibrating_InProgress = 100,
    ETrackingResult_TrackingResult_Calibrating_OutOfRange = 101,
    ETrackingResult_TrackingResult_Running_OK = 200,
    ETrackingResult_TrackingResult_Running_OutOfRange = 201,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum ETrackedDeviceClass {
    ETrackedDeviceClass_TrackedDeviceClass_Invalid = 0,
    ETrackedDeviceClass_TrackedDeviceClass_HMD = 1,
    ETrackedDeviceClass_TrackedDeviceClass_Controller = 2,
    ETrackedDeviceClass_TrackedDeviceClass_TrackingReference = 4,
    ETrackedDeviceClass_TrackedDeviceClass_Count = 5,
    ETrackedDeviceClass_TrackedDeviceClass_Other = 1000,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum ETrackedControllerRole {
    ETrackedControllerRole_TrackedControllerRole_Invalid = 0,
    ETrackedControllerRole_TrackedControllerRole_LeftHand = 1,
    ETrackedControllerRole_TrackedControllerRole_RightHand = 2,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum ETrackingUniverseOrigin {
    ETrackingUniverseOrigin_TrackingUniverseSeated = 0,
    ETrackingUniverseOrigin_TrackingUniverseStanding = 1,
    ETrackingUniverseOrigin_TrackingUniverseRawAndUncalibrated = 2,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum ETrackedDeviceProperty {
    ETrackedDeviceProperty_Prop_TrackingSystemName_String = 1000,
    ETrackedDeviceProperty_Prop_ModelNumber_String = 1001,
    ETrackedDeviceProperty_Prop_SerialNumber_String = 1002,
    ETrackedDeviceProperty_Prop_RenderModelName_String = 1003,
    ETrackedDeviceProperty_Prop_WillDriftInYaw_Bool = 1004,
    ETrackedDeviceProperty_Prop_ManufacturerName_String = 1005,
    ETrackedDeviceProperty_Prop_TrackingFirmwareVersion_String = 1006,
    ETrackedDeviceProperty_Prop_HardwareRevision_String = 1007,
    ETrackedDeviceProperty_Prop_AllWirelessDongleDescriptions_String = 1008,
    ETrackedDeviceProperty_Prop_ConnectedWirelessDongle_String = 1009,
    ETrackedDeviceProperty_Prop_DeviceIsWireless_Bool = 1010,
    ETrackedDeviceProperty_Prop_DeviceIsCharging_Bool = 1011,
    ETrackedDeviceProperty_Prop_DeviceBatteryPercentage_Float = 1012,
    ETrackedDeviceProperty_Prop_StatusDisplayTransform_Matrix34 = 1013,
    ETrackedDeviceProperty_Prop_Firmware_UpdateAvailable_Bool = 1014,
    ETrackedDeviceProperty_Prop_Firmware_ManualUpdate_Bool = 1015,
    ETrackedDeviceProperty_Prop_Firmware_ManualUpdateURL_String = 1016,
    ETrackedDeviceProperty_Prop_HardwareRevision_Uint64 = 1017,
    ETrackedDeviceProperty_Prop_FirmwareVersion_Uint64 = 1018,
    ETrackedDeviceProperty_Prop_FPGAVersion_Uint64 = 1019,
    ETrackedDeviceProperty_Prop_VRCVersion_Uint64 = 1020,
    ETrackedDeviceProperty_Prop_RadioVersion_Uint64 = 1021,
    ETrackedDeviceProperty_Prop_DongleVersion_Uint64 = 1022,
    ETrackedDeviceProperty_Prop_BlockServerShutdown_Bool = 1023,
    ETrackedDeviceProperty_Prop_CanUnifyCoordinateSystemWithHmd_Bool = 1024,
    ETrackedDeviceProperty_Prop_ContainsProximitySensor_Bool = 1025,
    ETrackedDeviceProperty_Prop_DeviceProvidesBatteryStatus_Bool = 1026,
    ETrackedDeviceProperty_Prop_DeviceCanPowerOff_Bool = 1027,
    ETrackedDeviceProperty_Prop_Firmware_ProgrammingTarget_String = 1028,
    ETrackedDeviceProperty_Prop_DeviceClass_Int32 = 1029,
    ETrackedDeviceProperty_Prop_HasCamera_Bool = 1030,
    ETrackedDeviceProperty_Prop_DriverVersion_String = 1031,
    ETrackedDeviceProperty_Prop_Firmware_ForceUpdateRequired_Bool = 1032,
    ETrackedDeviceProperty_Prop_ViveSystemButtonFixRequired_Bool = 1033,
    ETrackedDeviceProperty_Prop_ReportsTimeSinceVSync_Bool = 2000,
    ETrackedDeviceProperty_Prop_SecondsFromVsyncToPhotons_Float = 2001,
    ETrackedDeviceProperty_Prop_DisplayFrequency_Float = 2002,
    ETrackedDeviceProperty_Prop_UserIpdMeters_Float = 2003,
    ETrackedDeviceProperty_Prop_CurrentUniverseId_Uint64 = 2004,
    ETrackedDeviceProperty_Prop_PreviousUniverseId_Uint64 = 2005,
    ETrackedDeviceProperty_Prop_DisplayFirmwareVersion_Uint64 = 2006,
    ETrackedDeviceProperty_Prop_IsOnDesktop_Bool = 2007,
    ETrackedDeviceProperty_Prop_DisplayMCType_Int32 = 2008,
    ETrackedDeviceProperty_Prop_DisplayMCOffset_Float = 2009,
    ETrackedDeviceProperty_Prop_DisplayMCScale_Float = 2010,
    ETrackedDeviceProperty_Prop_EdidVendorID_Int32 = 2011,
    ETrackedDeviceProperty_Prop_DisplayMCImageLeft_String = 2012,
    ETrackedDeviceProperty_Prop_DisplayMCImageRight_String = 2013,
    ETrackedDeviceProperty_Prop_DisplayGCBlackClamp_Float = 2014,
    ETrackedDeviceProperty_Prop_EdidProductID_Int32 = 2015,
    ETrackedDeviceProperty_Prop_CameraToHeadTransform_Matrix34 = 2016,
    ETrackedDeviceProperty_Prop_DisplayGCType_Int32 = 2017,
    ETrackedDeviceProperty_Prop_DisplayGCOffset_Float = 2018,
    ETrackedDeviceProperty_Prop_DisplayGCScale_Float = 2019,
    ETrackedDeviceProperty_Prop_DisplayGCPrescale_Float = 2020,
    ETrackedDeviceProperty_Prop_DisplayGCImage_String = 2021,
    ETrackedDeviceProperty_Prop_LensCenterLeftU_Float = 2022,
    ETrackedDeviceProperty_Prop_LensCenterLeftV_Float = 2023,
    ETrackedDeviceProperty_Prop_LensCenterRightU_Float = 2024,
    ETrackedDeviceProperty_Prop_LensCenterRightV_Float = 2025,
    ETrackedDeviceProperty_Prop_UserHeadToEyeDepthMeters_Float = 2026,
    ETrackedDeviceProperty_Prop_CameraFirmwareVersion_Uint64 = 2027,
    ETrackedDeviceProperty_Prop_CameraFirmwareDescription_String = 2028,
    ETrackedDeviceProperty_Prop_DisplayFPGAVersion_Uint64 = 2029,
    ETrackedDeviceProperty_Prop_DisplayBootloaderVersion_Uint64 = 2030,
    ETrackedDeviceProperty_Prop_DisplayHardwareVersion_Uint64 = 2031,
    ETrackedDeviceProperty_Prop_AudioFirmwareVersion_Uint64 = 2032,
    ETrackedDeviceProperty_Prop_CameraCompatibilityMode_Int32 = 2033,
    ETrackedDeviceProperty_Prop_ScreenshotHorizontalFieldOfViewDegrees_Float =
        2034,
    ETrackedDeviceProperty_Prop_ScreenshotVerticalFieldOfViewDegrees_Float =
        2035,
    ETrackedDeviceProperty_Prop_DisplaySuppressed_Bool = 2036,
    ETrackedDeviceProperty_Prop_DisplayAllowNightMode_Bool = 2037,
    ETrackedDeviceProperty_Prop_AttachedDeviceId_String = 3000,
    ETrackedDeviceProperty_Prop_SupportedButtons_Uint64 = 3001,
    ETrackedDeviceProperty_Prop_Axis0Type_Int32 = 3002,
    ETrackedDeviceProperty_Prop_Axis1Type_Int32 = 3003,
    ETrackedDeviceProperty_Prop_Axis2Type_Int32 = 3004,
    ETrackedDeviceProperty_Prop_Axis3Type_Int32 = 3005,
    ETrackedDeviceProperty_Prop_Axis4Type_Int32 = 3006,
    ETrackedDeviceProperty_Prop_ControllerRoleHint_Int32 = 3007,
    ETrackedDeviceProperty_Prop_FieldOfViewLeftDegrees_Float = 4000,
    ETrackedDeviceProperty_Prop_FieldOfViewRightDegrees_Float = 4001,
    ETrackedDeviceProperty_Prop_FieldOfViewTopDegrees_Float = 4002,
    ETrackedDeviceProperty_Prop_FieldOfViewBottomDegrees_Float = 4003,
    ETrackedDeviceProperty_Prop_TrackingRangeMinimumMeters_Float = 4004,
    ETrackedDeviceProperty_Prop_TrackingRangeMaximumMeters_Float = 4005,
    ETrackedDeviceProperty_Prop_ModeLabel_String = 4006,
    ETrackedDeviceProperty_Prop_IconPathName_String = 5000,
    ETrackedDeviceProperty_Prop_NamedIconPathDeviceOff_String = 5001,
    ETrackedDeviceProperty_Prop_NamedIconPathDeviceSearching_String = 5002,
    ETrackedDeviceProperty_Prop_NamedIconPathDeviceSearchingAlert_String =
        5003,
    ETrackedDeviceProperty_Prop_NamedIconPathDeviceReady_String = 5004,
    ETrackedDeviceProperty_Prop_NamedIconPathDeviceReadyAlert_String = 5005,
    ETrackedDeviceProperty_Prop_NamedIconPathDeviceNotReady_String = 5006,
    ETrackedDeviceProperty_Prop_NamedIconPathDeviceStandby_String = 5007,
    ETrackedDeviceProperty_Prop_NamedIconPathDeviceAlertLow_String = 5008,
    ETrackedDeviceProperty_Prop_VendorSpecific_Reserved_Start = 10000,
    ETrackedDeviceProperty_Prop_VendorSpecific_Reserved_End = 10999,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum ETrackedPropertyError {
    ETrackedPropertyError_TrackedProp_Success = 0,
    ETrackedPropertyError_TrackedProp_WrongDataType = 1,
    ETrackedPropertyError_TrackedProp_WrongDeviceClass = 2,
    ETrackedPropertyError_TrackedProp_BufferTooSmall = 3,
    ETrackedPropertyError_TrackedProp_UnknownProperty = 4,
    ETrackedPropertyError_TrackedProp_InvalidDevice = 5,
    ETrackedPropertyError_TrackedProp_CouldNotContactServer = 6,
    ETrackedPropertyError_TrackedProp_ValueNotProvidedByDevice = 7,
    ETrackedPropertyError_TrackedProp_StringExceedsMaximumLength = 8,
    ETrackedPropertyError_TrackedProp_NotYetAvailable = 9,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRSubmitFlags {
    EVRSubmitFlags_Submit_Default = 0,
    EVRSubmitFlags_Submit_LensDistortionAlreadyApplied = 1,
    EVRSubmitFlags_Submit_GlRenderBuffer = 2,
    EVRSubmitFlags_Submit_VulkanTexture = 4,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRState {
    EVRState_VRState_Undefined = -1,
    EVRState_VRState_Off = 0,
    EVRState_VRState_Searching = 1,
    EVRState_VRState_Searching_Alert = 2,
    EVRState_VRState_Ready = 3,
    EVRState_VRState_Ready_Alert = 4,
    EVRState_VRState_NotReady = 5,
    EVRState_VRState_Standby = 6,
    EVRState_VRState_Ready_Alert_Low = 7,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVREventType {
    EVREventType_VREvent_None = 0,
    EVREventType_VREvent_TrackedDeviceActivated = 100,
    EVREventType_VREvent_TrackedDeviceDeactivated = 101,
    EVREventType_VREvent_TrackedDeviceUpdated = 102,
    EVREventType_VREvent_TrackedDeviceUserInteractionStarted = 103,
    EVREventType_VREvent_TrackedDeviceUserInteractionEnded = 104,
    EVREventType_VREvent_IpdChanged = 105,
    EVREventType_VREvent_EnterStandbyMode = 106,
    EVREventType_VREvent_LeaveStandbyMode = 107,
    EVREventType_VREvent_TrackedDeviceRoleChanged = 108,
    EVREventType_VREvent_WatchdogWakeUpRequested = 109,
    EVREventType_VREvent_LensDistortionChanged = 110,
    EVREventType_VREvent_ButtonPress = 200,
    EVREventType_VREvent_ButtonUnpress = 201,
    EVREventType_VREvent_ButtonTouch = 202,
    EVREventType_VREvent_ButtonUntouch = 203,
    EVREventType_VREvent_MouseMove = 300,
    EVREventType_VREvent_MouseButtonDown = 301,
    EVREventType_VREvent_MouseButtonUp = 302,
    EVREventType_VREvent_FocusEnter = 303,
    EVREventType_VREvent_FocusLeave = 304,
    EVREventType_VREvent_Scroll = 305,
    EVREventType_VREvent_TouchPadMove = 306,
    EVREventType_VREvent_OverlayFocusChanged = 307,
    EVREventType_VREvent_InputFocusCaptured = 400,
    EVREventType_VREvent_InputFocusReleased = 401,
    EVREventType_VREvent_SceneFocusLost = 402,
    EVREventType_VREvent_SceneFocusGained = 403,
    EVREventType_VREvent_SceneApplicationChanged = 404,
    EVREventType_VREvent_SceneFocusChanged = 405,
    EVREventType_VREvent_InputFocusChanged = 406,
    EVREventType_VREvent_SceneApplicationSecondaryRenderingStarted = 407,
    EVREventType_VREvent_HideRenderModels = 410,
    EVREventType_VREvent_ShowRenderModels = 411,
    EVREventType_VREvent_OverlayShown = 500,
    EVREventType_VREvent_OverlayHidden = 501,
    EVREventType_VREvent_DashboardActivated = 502,
    EVREventType_VREvent_DashboardDeactivated = 503,
    EVREventType_VREvent_DashboardThumbSelected = 504,
    EVREventType_VREvent_DashboardRequested = 505,
    EVREventType_VREvent_ResetDashboard = 506,
    EVREventType_VREvent_RenderToast = 507,
    EVREventType_VREvent_ImageLoaded = 508,
    EVREventType_VREvent_ShowKeyboard = 509,
    EVREventType_VREvent_HideKeyboard = 510,
    EVREventType_VREvent_OverlayGamepadFocusGained = 511,
    EVREventType_VREvent_OverlayGamepadFocusLost = 512,
    EVREventType_VREvent_OverlaySharedTextureChanged = 513,
    EVREventType_VREvent_DashboardGuideButtonDown = 514,
    EVREventType_VREvent_DashboardGuideButtonUp = 515,
    EVREventType_VREvent_ScreenshotTriggered = 516,
    EVREventType_VREvent_ImageFailed = 517,
    EVREventType_VREvent_DashboardOverlayCreated = 518,
    EVREventType_VREvent_RequestScreenshot = 520,
    EVREventType_VREvent_ScreenshotTaken = 521,
    EVREventType_VREvent_ScreenshotFailed = 522,
    EVREventType_VREvent_SubmitScreenshotToDashboard = 523,
    EVREventType_VREvent_ScreenshotProgressToDashboard = 524,
    EVREventType_VREvent_Notification_Shown = 600,
    EVREventType_VREvent_Notification_Hidden = 601,
    EVREventType_VREvent_Notification_BeginInteraction = 602,
    EVREventType_VREvent_Notification_Destroyed = 603,
    EVREventType_VREvent_Quit = 700,
    EVREventType_VREvent_ProcessQuit = 701,
    EVREventType_VREvent_QuitAborted_UserPrompt = 702,
    EVREventType_VREvent_QuitAcknowledged = 703,
    EVREventType_VREvent_DriverRequestedQuit = 704,
    EVREventType_VREvent_ChaperoneDataHasChanged = 800,
    EVREventType_VREvent_ChaperoneUniverseHasChanged = 801,
    EVREventType_VREvent_ChaperoneTempDataHasChanged = 802,
    EVREventType_VREvent_ChaperoneSettingsHaveChanged = 803,
    EVREventType_VREvent_SeatedZeroPoseReset = 804,
    EVREventType_VREvent_AudioSettingsHaveChanged = 820,
    EVREventType_VREvent_BackgroundSettingHasChanged = 850,
    EVREventType_VREvent_CameraSettingsHaveChanged = 851,
    EVREventType_VREvent_ReprojectionSettingHasChanged = 852,
    EVREventType_VREvent_ModelSkinSettingsHaveChanged = 853,
    EVREventType_VREvent_EnvironmentSettingsHaveChanged = 854,
    EVREventType_VREvent_PowerSettingsHaveChanged = 855,
    EVREventType_VREvent_StatusUpdate = 900,
    EVREventType_VREvent_MCImageUpdated = 1000,
    EVREventType_VREvent_FirmwareUpdateStarted = 1100,
    EVREventType_VREvent_FirmwareUpdateFinished = 1101,
    EVREventType_VREvent_KeyboardClosed = 1200,
    EVREventType_VREvent_KeyboardCharInput = 1201,
    EVREventType_VREvent_KeyboardDone = 1202,
    EVREventType_VREvent_ApplicationTransitionStarted = 1300,
    EVREventType_VREvent_ApplicationTransitionAborted = 1301,
    EVREventType_VREvent_ApplicationTransitionNewAppStarted = 1302,
    EVREventType_VREvent_ApplicationListUpdated = 1303,
    EVREventType_VREvent_ApplicationMimeTypeLoad = 1304,
    EVREventType_VREvent_Compositor_MirrorWindowShown = 1400,
    EVREventType_VREvent_Compositor_MirrorWindowHidden = 1401,
    EVREventType_VREvent_Compositor_ChaperoneBoundsShown = 1410,
    EVREventType_VREvent_Compositor_ChaperoneBoundsHidden = 1411,
    EVREventType_VREvent_TrackedCamera_StartVideoStream = 1500,
    EVREventType_VREvent_TrackedCamera_StopVideoStream = 1501,
    EVREventType_VREvent_TrackedCamera_PauseVideoStream = 1502,
    EVREventType_VREvent_TrackedCamera_ResumeVideoStream = 1503,
    EVREventType_VREvent_TrackedCamera_EditingSurface = 1550,
    EVREventType_VREvent_PerformanceTest_EnableCapture = 1600,
    EVREventType_VREvent_PerformanceTest_DisableCapture = 1601,
    EVREventType_VREvent_PerformanceTest_FidelityLevel = 1602,
    EVREventType_VREvent_VendorSpecific_Reserved_Start = 10000,
    EVREventType_VREvent_VendorSpecific_Reserved_End = 19999,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EDeviceActivityLevel {
    EDeviceActivityLevel_k_EDeviceActivityLevel_Unknown = -1,
    EDeviceActivityLevel_k_EDeviceActivityLevel_Idle = 0,
    EDeviceActivityLevel_k_EDeviceActivityLevel_UserInteraction = 1,
    EDeviceActivityLevel_k_EDeviceActivityLevel_UserInteraction_Timeout = 2,
    EDeviceActivityLevel_k_EDeviceActivityLevel_Standby = 3,
}
pub const EVRButtonId_EVRButtonId_k_EButton_SteamVR_Touchpad: EVRButtonId =
    EVRButtonId::EVRButtonId_k_EButton_Axis0;
pub const EVRButtonId_EVRButtonId_k_EButton_SteamVR_Trigger: EVRButtonId =
    EVRButtonId::EVRButtonId_k_EButton_Axis1;
pub const EVRButtonId_EVRButtonId_k_EButton_Dashboard_Back: EVRButtonId =
    EVRButtonId::EVRButtonId_k_EButton_Grip;
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRButtonId {
    EVRButtonId_k_EButton_System = 0,
    EVRButtonId_k_EButton_ApplicationMenu = 1,
    EVRButtonId_k_EButton_Grip = 2,
    EVRButtonId_k_EButton_DPad_Left = 3,
    EVRButtonId_k_EButton_DPad_Up = 4,
    EVRButtonId_k_EButton_DPad_Right = 5,
    EVRButtonId_k_EButton_DPad_Down = 6,
    EVRButtonId_k_EButton_A = 7,
    EVRButtonId_k_EButton_ProximitySensor = 31,
    EVRButtonId_k_EButton_Axis0 = 32,
    EVRButtonId_k_EButton_Axis1 = 33,
    EVRButtonId_k_EButton_Axis2 = 34,
    EVRButtonId_k_EButton_Axis3 = 35,
    EVRButtonId_k_EButton_Axis4 = 36,
    EVRButtonId_k_EButton_Max = 64,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRMouseButton {
    EVRMouseButton_VRMouseButton_Left = 1,
    EVRMouseButton_VRMouseButton_Right = 2,
    EVRMouseButton_VRMouseButton_Middle = 4,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EHiddenAreaMeshType {
    EHiddenAreaMeshType_k_eHiddenAreaMesh_Standard = 0,
    EHiddenAreaMeshType_k_eHiddenAreaMesh_Inverse = 1,
    EHiddenAreaMeshType_k_eHiddenAreaMesh_LineLoop = 2,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRControllerAxisType {
    EVRControllerAxisType_k_eControllerAxis_None = 0,
    EVRControllerAxisType_k_eControllerAxis_TrackPad = 1,
    EVRControllerAxisType_k_eControllerAxis_Joystick = 2,
    EVRControllerAxisType_k_eControllerAxis_Trigger = 3,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRControllerEventOutputType {
    EVRControllerEventOutputType_ControllerEventOutput_OSEvents = 0,
    EVRControllerEventOutputType_ControllerEventOutput_VREvents = 1,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum ECollisionBoundsStyle {
    ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_BEGINNER = 0,
    ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_INTERMEDIATE = 1,
    ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_SQUARES = 2,
    ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_ADVANCED = 3,
    ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_NONE = 4,
    ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_COUNT = 5,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVROverlayError {
    EVROverlayError_VROverlayError_None = 0,
    EVROverlayError_VROverlayError_UnknownOverlay = 10,
    EVROverlayError_VROverlayError_InvalidHandle = 11,
    EVROverlayError_VROverlayError_PermissionDenied = 12,
    EVROverlayError_VROverlayError_OverlayLimitExceeded = 13,
    EVROverlayError_VROverlayError_WrongVisibilityType = 14,
    EVROverlayError_VROverlayError_KeyTooLong = 15,
    EVROverlayError_VROverlayError_NameTooLong = 16,
    EVROverlayError_VROverlayError_KeyInUse = 17,
    EVROverlayError_VROverlayError_WrongTransformType = 18,
    EVROverlayError_VROverlayError_InvalidTrackedDevice = 19,
    EVROverlayError_VROverlayError_InvalidParameter = 20,
    EVROverlayError_VROverlayError_ThumbnailCantBeDestroyed = 21,
    EVROverlayError_VROverlayError_ArrayTooSmall = 22,
    EVROverlayError_VROverlayError_RequestFailed = 23,
    EVROverlayError_VROverlayError_InvalidTexture = 24,
    EVROverlayError_VROverlayError_UnableToLoadFile = 25,
    EVROverlayError_VROverlayError_KeyboardAlreadyInUse = 26,
    EVROverlayError_VROverlayError_NoNeighbor = 27,
    EVROverlayError_VROverlayError_TooManyMaskPrimitives = 29,
    EVROverlayError_VROverlayError_BadMaskPrimitive = 30,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRApplicationType {
    EVRApplicationType_VRApplication_Other = 0,
    EVRApplicationType_VRApplication_Scene = 1,
    EVRApplicationType_VRApplication_Overlay = 2,
    EVRApplicationType_VRApplication_Background = 3,
    EVRApplicationType_VRApplication_Utility = 4,
    EVRApplicationType_VRApplication_VRMonitor = 5,
    EVRApplicationType_VRApplication_SteamWatchdog = 6,
    EVRApplicationType_VRApplication_Max = 7,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRFirmwareError {
    EVRFirmwareError_VRFirmwareError_None = 0,
    EVRFirmwareError_VRFirmwareError_Success = 1,
    EVRFirmwareError_VRFirmwareError_Fail = 2,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRNotificationError {
    EVRNotificationError_VRNotificationError_OK = 0,
    EVRNotificationError_VRNotificationError_InvalidNotificationId = 100,
    EVRNotificationError_VRNotificationError_NotificationQueueFull = 101,
    EVRNotificationError_VRNotificationError_InvalidOverlayHandle = 102,
    EVRNotificationError_VRNotificationError_SystemWithUserValueAlreadyExists
        = 103,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRInitError {
    EVRInitError_VRInitError_None = 0,
    EVRInitError_VRInitError_Unknown = 1,
    EVRInitError_VRInitError_Init_InstallationNotFound = 100,
    EVRInitError_VRInitError_Init_InstallationCorrupt = 101,
    EVRInitError_VRInitError_Init_VRClientDLLNotFound = 102,
    EVRInitError_VRInitError_Init_FileNotFound = 103,
    EVRInitError_VRInitError_Init_FactoryNotFound = 104,
    EVRInitError_VRInitError_Init_InterfaceNotFound = 105,
    EVRInitError_VRInitError_Init_InvalidInterface = 106,
    EVRInitError_VRInitError_Init_UserConfigDirectoryInvalid = 107,
    EVRInitError_VRInitError_Init_HmdNotFound = 108,
    EVRInitError_VRInitError_Init_NotInitialized = 109,
    EVRInitError_VRInitError_Init_PathRegistryNotFound = 110,
    EVRInitError_VRInitError_Init_NoConfigPath = 111,
    EVRInitError_VRInitError_Init_NoLogPath = 112,
    EVRInitError_VRInitError_Init_PathRegistryNotWritable = 113,
    EVRInitError_VRInitError_Init_AppInfoInitFailed = 114,
    EVRInitError_VRInitError_Init_Retry = 115,
    EVRInitError_VRInitError_Init_InitCanceledByUser = 116,
    EVRInitError_VRInitError_Init_AnotherAppLaunching = 117,
    EVRInitError_VRInitError_Init_SettingsInitFailed = 118,
    EVRInitError_VRInitError_Init_ShuttingDown = 119,
    EVRInitError_VRInitError_Init_TooManyObjects = 120,
    EVRInitError_VRInitError_Init_NoServerForBackgroundApp = 121,
    EVRInitError_VRInitError_Init_NotSupportedWithCompositor = 122,
    EVRInitError_VRInitError_Init_NotAvailableToUtilityApps = 123,
    EVRInitError_VRInitError_Init_Internal = 124,
    EVRInitError_VRInitError_Init_HmdDriverIdIsNone = 125,
    EVRInitError_VRInitError_Init_HmdNotFoundPresenceFailed = 126,
    EVRInitError_VRInitError_Init_VRMonitorNotFound = 127,
    EVRInitError_VRInitError_Init_VRMonitorStartupFailed = 128,
    EVRInitError_VRInitError_Init_LowPowerWatchdogNotSupported = 129,
    EVRInitError_VRInitError_Init_InvalidApplicationType = 130,
    EVRInitError_VRInitError_Init_NotAvailableToWatchdogApps = 131,
    EVRInitError_VRInitError_Init_WatchdogDisabledInSettings = 132,
    EVRInitError_VRInitError_Driver_Failed = 200,
    EVRInitError_VRInitError_Driver_Unknown = 201,
    EVRInitError_VRInitError_Driver_HmdUnknown = 202,
    EVRInitError_VRInitError_Driver_NotLoaded = 203,
    EVRInitError_VRInitError_Driver_RuntimeOutOfDate = 204,
    EVRInitError_VRInitError_Driver_HmdInUse = 205,
    EVRInitError_VRInitError_Driver_NotCalibrated = 206,
    EVRInitError_VRInitError_Driver_CalibrationInvalid = 207,
    EVRInitError_VRInitError_Driver_HmdDisplayNotFound = 208,
    EVRInitError_VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
    EVRInitError_VRInitError_Driver_HmdDriverIdOutOfBounds = 211,
    EVRInitError_VRInitError_Driver_HmdDisplayMirrored = 212,
    EVRInitError_VRInitError_IPC_ServerInitFailed = 300,
    EVRInitError_VRInitError_IPC_ConnectFailed = 301,
    EVRInitError_VRInitError_IPC_SharedStateInitFailed = 302,
    EVRInitError_VRInitError_IPC_CompositorInitFailed = 303,
    EVRInitError_VRInitError_IPC_MutexInitFailed = 304,
    EVRInitError_VRInitError_IPC_Failed = 305,
    EVRInitError_VRInitError_IPC_CompositorConnectFailed = 306,
    EVRInitError_VRInitError_IPC_CompositorInvalidConnectResponse = 307,
    EVRInitError_VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
    EVRInitError_VRInitError_Compositor_Failed = 400,
    EVRInitError_VRInitError_Compositor_D3D11HardwareRequired = 401,
    EVRInitError_VRInitError_Compositor_FirmwareRequiresUpdate = 402,
    EVRInitError_VRInitError_Compositor_OverlayInitFailed = 403,
    EVRInitError_VRInitError_Compositor_ScreenshotsInitFailed = 404,
    EVRInitError_VRInitError_VendorSpecific_UnableToConnectToOculusRuntime =
        1000,
    EVRInitError_VRInitError_VendorSpecific_HmdFound_CantOpenDevice = 1101,
    EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart
        = 1102,
    EVRInitError_VRInitError_VendorSpecific_HmdFound_NoStoredConfig = 1103,
    EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigTooBig = 1104,
    EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigTooSmall = 1105,
    EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToInitZLib = 1106,
    EVRInitError_VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion =
        1107,
    EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart
        = 1108,
    EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart
        = 1109,
    EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext =
        1110,
    EVRInitError_VRInitError_VendorSpecific_HmdFound_UserDataAddressRange =
        1111,
    EVRInitError_VRInitError_VendorSpecific_HmdFound_UserDataError = 1112,
    EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck =
        1113,
    EVRInitError_VRInitError_Steam_SteamInstallationNotFound = 2000,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRScreenshotType {
    EVRScreenshotType_VRScreenshotType_None = 0,
    EVRScreenshotType_VRScreenshotType_Mono = 1,
    EVRScreenshotType_VRScreenshotType_Stereo = 2,
    EVRScreenshotType_VRScreenshotType_Cubemap = 3,
    EVRScreenshotType_VRScreenshotType_MonoPanorama = 4,
    EVRScreenshotType_VRScreenshotType_StereoPanorama = 5,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRScreenshotPropertyFilenames {
    EVRScreenshotPropertyFilenames_VRScreenshotPropertyFilenames_Preview = 0,
    EVRScreenshotPropertyFilenames_VRScreenshotPropertyFilenames_VR = 1,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRTrackedCameraError {
    EVRTrackedCameraError_VRTrackedCameraError_None = 0,
    EVRTrackedCameraError_VRTrackedCameraError_OperationFailed = 100,
    EVRTrackedCameraError_VRTrackedCameraError_InvalidHandle = 101,
    EVRTrackedCameraError_VRTrackedCameraError_InvalidFrameHeaderVersion =
        102,
    EVRTrackedCameraError_VRTrackedCameraError_OutOfHandles = 103,
    EVRTrackedCameraError_VRTrackedCameraError_IPCFailure = 104,
    EVRTrackedCameraError_VRTrackedCameraError_NotSupportedForThisDevice =
        105,
    EVRTrackedCameraError_VRTrackedCameraError_SharedMemoryFailure = 106,
    EVRTrackedCameraError_VRTrackedCameraError_FrameBufferingFailure = 107,
    EVRTrackedCameraError_VRTrackedCameraError_StreamSetupFailure = 108,
    EVRTrackedCameraError_VRTrackedCameraError_InvalidGLTextureId = 109,
    EVRTrackedCameraError_VRTrackedCameraError_InvalidSharedTextureHandle =
        110,
    EVRTrackedCameraError_VRTrackedCameraError_FailedToGetGLTextureId = 111,
    EVRTrackedCameraError_VRTrackedCameraError_SharedTextureFailure = 112,
    EVRTrackedCameraError_VRTrackedCameraError_NoFrameAvailable = 113,
    EVRTrackedCameraError_VRTrackedCameraError_InvalidArgument = 114,
    EVRTrackedCameraError_VRTrackedCameraError_InvalidFrameBufferSize = 115,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRTrackedCameraFrameType {
    EVRTrackedCameraFrameType_VRTrackedCameraFrameType_Distorted = 0,
    EVRTrackedCameraFrameType_VRTrackedCameraFrameType_Undistorted = 1,
    EVRTrackedCameraFrameType_VRTrackedCameraFrameType_MaximumUndistorted = 2,
    EVRTrackedCameraFrameType_MAX_CAMERA_FRAME_TYPES = 3,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRApplicationError {
    EVRApplicationError_VRApplicationError_None = 0,
    EVRApplicationError_VRApplicationError_AppKeyAlreadyExists = 100,
    EVRApplicationError_VRApplicationError_NoManifest = 101,
    EVRApplicationError_VRApplicationError_NoApplication = 102,
    EVRApplicationError_VRApplicationError_InvalidIndex = 103,
    EVRApplicationError_VRApplicationError_UnknownApplication = 104,
    EVRApplicationError_VRApplicationError_IPCFailed = 105,
    EVRApplicationError_VRApplicationError_ApplicationAlreadyRunning = 106,
    EVRApplicationError_VRApplicationError_InvalidManifest = 107,
    EVRApplicationError_VRApplicationError_InvalidApplication = 108,
    EVRApplicationError_VRApplicationError_LaunchFailed = 109,
    EVRApplicationError_VRApplicationError_ApplicationAlreadyStarting = 110,
    EVRApplicationError_VRApplicationError_LaunchInProgress = 111,
    EVRApplicationError_VRApplicationError_OldApplicationQuitting = 112,
    EVRApplicationError_VRApplicationError_TransitionAborted = 113,
    EVRApplicationError_VRApplicationError_IsTemplate = 114,
    EVRApplicationError_VRApplicationError_BufferTooSmall = 200,
    EVRApplicationError_VRApplicationError_PropertyNotSet = 201,
    EVRApplicationError_VRApplicationError_UnknownProperty = 202,
    EVRApplicationError_VRApplicationError_InvalidParameter = 203,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRApplicationProperty {
    EVRApplicationProperty_VRApplicationProperty_Name_String = 0,
    EVRApplicationProperty_VRApplicationProperty_LaunchType_String = 11,
    EVRApplicationProperty_VRApplicationProperty_WorkingDirectory_String = 12,
    EVRApplicationProperty_VRApplicationProperty_BinaryPath_String = 13,
    EVRApplicationProperty_VRApplicationProperty_Arguments_String = 14,
    EVRApplicationProperty_VRApplicationProperty_URL_String = 15,
    EVRApplicationProperty_VRApplicationProperty_Description_String = 50,
    EVRApplicationProperty_VRApplicationProperty_NewsURL_String = 51,
    EVRApplicationProperty_VRApplicationProperty_ImagePath_String = 52,
    EVRApplicationProperty_VRApplicationProperty_Source_String = 53,
    EVRApplicationProperty_VRApplicationProperty_IsDashboardOverlay_Bool = 60,
    EVRApplicationProperty_VRApplicationProperty_IsTemplate_Bool = 61,
    EVRApplicationProperty_VRApplicationProperty_IsInstanced_Bool = 62,
    EVRApplicationProperty_VRApplicationProperty_LastLaunchTime_Uint64 = 70,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRApplicationTransitionState {
    EVRApplicationTransitionState_VRApplicationTransition_None = 0,
    EVRApplicationTransitionState_VRApplicationTransition_OldAppQuitSent = 10,
    EVRApplicationTransitionState_VRApplicationTransition_WaitingForExternalLaunch
        = 11,
    EVRApplicationTransitionState_VRApplicationTransition_NewAppLaunched = 20,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum ChaperoneCalibrationState {
    ChaperoneCalibrationState_OK = 1,
    ChaperoneCalibrationState_Warning = 100,
    ChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101,
    ChaperoneCalibrationState_Warning_BaseStationRemoved = 102,
    ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103,
    ChaperoneCalibrationState_Error = 200,
    ChaperoneCalibrationState_Error_BaseStationUninitalized = 201,
    ChaperoneCalibrationState_Error_BaseStationConflict = 202,
    ChaperoneCalibrationState_Error_PlayAreaInvalid = 203,
    ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EChaperoneConfigFile {
    EChaperoneConfigFile_Live = 1,
    EChaperoneConfigFile_Temp = 2,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EChaperoneImportFlags {
    EChaperoneImportFlags_EChaperoneImport_BoundsOnly = 1,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRCompositorError {
    EVRCompositorError_VRCompositorError_None = 0,
    EVRCompositorError_VRCompositorError_RequestFailed = 1,
    EVRCompositorError_VRCompositorError_IncompatibleVersion = 100,
    EVRCompositorError_VRCompositorError_DoNotHaveFocus = 101,
    EVRCompositorError_VRCompositorError_InvalidTexture = 102,
    EVRCompositorError_VRCompositorError_IsNotSceneApplication = 103,
    EVRCompositorError_VRCompositorError_TextureIsOnWrongDevice = 104,
    EVRCompositorError_VRCompositorError_TextureUsesUnsupportedFormat = 105,
    EVRCompositorError_VRCompositorError_SharedTexturesNotSupported = 106,
    EVRCompositorError_VRCompositorError_IndexOutOfRange = 107,
    EVRCompositorError_VRCompositorError_AlreadySubmitted = 108,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum VROverlayInputMethod {
    VROverlayInputMethod_None = 0,
    VROverlayInputMethod_Mouse = 1,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum VROverlayTransformType {
    VROverlayTransformType_VROverlayTransform_Absolute = 0,
    VROverlayTransformType_VROverlayTransform_TrackedDeviceRelative = 1,
    VROverlayTransformType_VROverlayTransform_SystemOverlay = 2,
    VROverlayTransformType_VROverlayTransform_TrackedComponent = 3,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum VROverlayFlags {
    VROverlayFlags_None = 0,
    VROverlayFlags_Curved = 1,
    VROverlayFlags_RGSS4X = 2,
    VROverlayFlags_NoDashboardTab = 3,
    VROverlayFlags_AcceptsGamepadEvents = 4,
    VROverlayFlags_ShowGamepadFocus = 5,
    VROverlayFlags_SendVRScrollEvents = 6,
    VROverlayFlags_SendVRTouchpadEvents = 7,
    VROverlayFlags_ShowTouchPadScrollWheel = 8,
    VROverlayFlags_TransferOwnershipToInternalProcess = 9,
    VROverlayFlags_SideBySide_Parallel = 10,
    VROverlayFlags_SideBySide_Crossed = 11,
    VROverlayFlags_Panorama = 12,
    VROverlayFlags_StereoPanorama = 13,
    VROverlayFlags_SortWithNonSceneOverlays = 14,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EGamepadTextInputMode {
    EGamepadTextInputMode_k_EGamepadTextInputModeNormal = 0,
    EGamepadTextInputMode_k_EGamepadTextInputModePassword = 1,
    EGamepadTextInputMode_k_EGamepadTextInputModeSubmit = 2,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EGamepadTextInputLineMode {
    EGamepadTextInputLineMode_k_EGamepadTextInputLineModeSingleLine = 0,
    EGamepadTextInputLineMode_k_EGamepadTextInputLineModeMultipleLines = 1,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EOverlayDirection {
    EOverlayDirection_OverlayDirection_Up = 0,
    EOverlayDirection_OverlayDirection_Down = 1,
    EOverlayDirection_OverlayDirection_Left = 2,
    EOverlayDirection_OverlayDirection_Right = 3,
    EOverlayDirection_OverlayDirection_Count = 4,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVROverlayIntersectionMaskPrimitiveType {
    EVROverlayIntersectionMaskPrimitiveType_OverlayIntersectionPrimitiveType_Rectangle
        = 0,
    EVROverlayIntersectionMaskPrimitiveType_OverlayIntersectionPrimitiveType_Circle
        = 1,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRRenderModelError {
    EVRRenderModelError_VRRenderModelError_None = 0,
    EVRRenderModelError_VRRenderModelError_Loading = 100,
    EVRRenderModelError_VRRenderModelError_NotSupported = 200,
    EVRRenderModelError_VRRenderModelError_InvalidArg = 300,
    EVRRenderModelError_VRRenderModelError_InvalidModel = 301,
    EVRRenderModelError_VRRenderModelError_NoShapes = 302,
    EVRRenderModelError_VRRenderModelError_MultipleShapes = 303,
    EVRRenderModelError_VRRenderModelError_TooManyVertices = 304,
    EVRRenderModelError_VRRenderModelError_MultipleTextures = 305,
    EVRRenderModelError_VRRenderModelError_BufferTooSmall = 306,
    EVRRenderModelError_VRRenderModelError_NotEnoughNormals = 307,
    EVRRenderModelError_VRRenderModelError_NotEnoughTexCoords = 308,
    EVRRenderModelError_VRRenderModelError_InvalidTexture = 400,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRComponentProperty {
    EVRComponentProperty_VRComponentProperty_IsStatic = 1,
    EVRComponentProperty_VRComponentProperty_IsVisible = 2,
    EVRComponentProperty_VRComponentProperty_IsTouched = 4,
    EVRComponentProperty_VRComponentProperty_IsPressed = 8,
    EVRComponentProperty_VRComponentProperty_IsScrolled = 16,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRNotificationType {
    EVRNotificationType_Transient = 0,
    EVRNotificationType_Persistent = 1,
    EVRNotificationType_Transient_SystemWithUserValue = 2,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRNotificationStyle {
    EVRNotificationStyle_None = 0,
    EVRNotificationStyle_Application = 100,
    EVRNotificationStyle_Contact_Disabled = 200,
    EVRNotificationStyle_Contact_Enabled = 201,
    EVRNotificationStyle_Contact_Active = 202,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRSettingsError {
    EVRSettingsError_VRSettingsError_None = 0,
    EVRSettingsError_VRSettingsError_IPCFailed = 1,
    EVRSettingsError_VRSettingsError_WriteFailed = 2,
    EVRSettingsError_VRSettingsError_ReadFailed = 3,
    EVRSettingsError_VRSettingsError_JsonParseFailed = 4,
    EVRSettingsError_VRSettingsError_UnsetSettingHasNoDefault = 5,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EVRScreenshotError {
    EVRScreenshotError_VRScreenshotError_None = 0,
    EVRScreenshotError_VRScreenshotError_RequestFailed = 1,
    EVRScreenshotError_VRScreenshotError_IncompatibleVersion = 100,
    EVRScreenshotError_VRScreenshotError_NotFound = 101,
    EVRScreenshotError_VRScreenshotError_BufferTooSmall = 102,
    EVRScreenshotError_VRScreenshotError_ScreenshotAlreadyInProgress = 108,
}
pub type TrackedDeviceIndex_t = u32;
pub type VRNotificationId = u32;
pub type VROverlayHandle_t = u64;
pub type glSharedTextureHandle_t = *mut ::std::os::raw::c_void;
pub type glInt_t = i32;
pub type glUInt_t = u32;
pub type SharedTextureHandle_t = u64;
pub type TrackedCameraHandle_t = u64;
pub type ScreenshotHandle_t = u32;
pub type VRComponentProperties = u32;
pub type TextureID_t = i32;
pub type HmdError = EVRInitError;
pub type Hmd_Eye = EVREye;
pub type GraphicsAPIConvention = EGraphicsAPIConvention;
pub type ColorSpace = EColorSpace;
pub type HmdTrackingResult = ETrackingResult;
pub type TrackedDeviceClass = ETrackedDeviceClass;
pub type TrackingUniverseOrigin = ETrackingUniverseOrigin;
pub type TrackedDeviceProperty = ETrackedDeviceProperty;
pub type TrackedPropertyError = ETrackedPropertyError;
pub type VRSubmitFlags_t = EVRSubmitFlags;
pub type VRState_t = EVRState;
pub type CollisionBoundsStyle_t = ECollisionBoundsStyle;
pub type VROverlayError = EVROverlayError;
pub type VRFirmwareError = EVRFirmwareError;
pub type VRCompositorError = EVRCompositorError;
pub type VRScreenshotsError = EVRScreenshotError;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct HmdMatrix34_t {
    pub m: [[f32; 4usize]; 3usize],
}
#[test]
fn bindgen_test_layout_HmdMatrix34_t() {
    assert_eq!(::std::mem::size_of::<HmdMatrix34_t>() , 48usize);
    assert_eq!(::std::mem::align_of::<HmdMatrix34_t>() , 4usize);
}
impl Clone for HmdMatrix34_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct HmdMatrix44_t {
    pub m: [[f32; 4usize]; 4usize],
}
#[test]
fn bindgen_test_layout_HmdMatrix44_t() {
    assert_eq!(::std::mem::size_of::<HmdMatrix44_t>() , 64usize);
    assert_eq!(::std::mem::align_of::<HmdMatrix44_t>() , 4usize);
}
impl Clone for HmdMatrix44_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct HmdVector3_t {
    pub v: [f32; 3usize],
}
#[test]
fn bindgen_test_layout_HmdVector3_t() {
    assert_eq!(::std::mem::size_of::<HmdVector3_t>() , 12usize);
    assert_eq!(::std::mem::align_of::<HmdVector3_t>() , 4usize);
}
impl Clone for HmdVector3_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct HmdVector4_t {
    pub v: [f32; 4usize],
}
#[test]
fn bindgen_test_layout_HmdVector4_t() {
    assert_eq!(::std::mem::size_of::<HmdVector4_t>() , 16usize);
    assert_eq!(::std::mem::align_of::<HmdVector4_t>() , 4usize);
}
impl Clone for HmdVector4_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct HmdVector3d_t {
    pub v: [f64; 3usize],
}
#[test]
fn bindgen_test_layout_HmdVector3d_t() {
    assert_eq!(::std::mem::size_of::<HmdVector3d_t>() , 24usize);
    assert_eq!(::std::mem::align_of::<HmdVector3d_t>() , 8usize);
}
impl Clone for HmdVector3d_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct HmdVector2_t {
    pub v: [f32; 2usize],
}
#[test]
fn bindgen_test_layout_HmdVector2_t() {
    assert_eq!(::std::mem::size_of::<HmdVector2_t>() , 8usize);
    assert_eq!(::std::mem::align_of::<HmdVector2_t>() , 4usize);
}
impl Clone for HmdVector2_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct HmdQuaternion_t {
    pub w: f64,
    pub x: f64,
    pub y: f64,
    pub z: f64,
}
#[test]
fn bindgen_test_layout_HmdQuaternion_t() {
    assert_eq!(::std::mem::size_of::<HmdQuaternion_t>() , 32usize);
    assert_eq!(::std::mem::align_of::<HmdQuaternion_t>() , 8usize);
}
impl Clone for HmdQuaternion_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct HmdColor_t {
    pub r: f32,
    pub g: f32,
    pub b: f32,
    pub a: f32,
}
#[test]
fn bindgen_test_layout_HmdColor_t() {
    assert_eq!(::std::mem::size_of::<HmdColor_t>() , 16usize);
    assert_eq!(::std::mem::align_of::<HmdColor_t>() , 4usize);
}
impl Clone for HmdColor_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct HmdQuad_t {
    pub vCorners: [HmdVector3_t; 4usize],
}
#[test]
fn bindgen_test_layout_HmdQuad_t() {
    assert_eq!(::std::mem::size_of::<HmdQuad_t>() , 48usize);
    assert_eq!(::std::mem::align_of::<HmdQuad_t>() , 4usize);
}
impl Clone for HmdQuad_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct HmdRect2_t {
    pub vTopLeft: HmdVector2_t,
    pub vBottomRight: HmdVector2_t,
}
#[test]
fn bindgen_test_layout_HmdRect2_t() {
    assert_eq!(::std::mem::size_of::<HmdRect2_t>() , 16usize);
    assert_eq!(::std::mem::align_of::<HmdRect2_t>() , 4usize);
}
impl Clone for HmdRect2_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct DistortionCoordinates_t {
    pub rfRed: [f32; 2usize],
    pub rfGreen: [f32; 2usize],
    pub rfBlue: [f32; 2usize],
}
#[test]
fn bindgen_test_layout_DistortionCoordinates_t() {
    assert_eq!(::std::mem::size_of::<DistortionCoordinates_t>() , 24usize);
    assert_eq!(::std::mem::align_of::<DistortionCoordinates_t>() , 4usize);
}
impl Clone for DistortionCoordinates_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct Texture_t {
    pub handle: *mut ::std::os::raw::c_void,
    pub eType: EGraphicsAPIConvention,
    pub eColorSpace: EColorSpace,
}
#[test]
fn bindgen_test_layout_Texture_t() {
    assert_eq!(::std::mem::size_of::<Texture_t>() , 16usize);
    assert_eq!(::std::mem::align_of::<Texture_t>() , 8usize);
}
impl Clone for Texture_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct TrackedDevicePose_t {
    pub mDeviceToAbsoluteTracking: HmdMatrix34_t,
    pub vVelocity: HmdVector3_t,
    pub vAngularVelocity: HmdVector3_t,
    pub eTrackingResult: ETrackingResult,
    pub bPoseIsValid: bool,
    pub bDeviceIsConnected: bool,
}
#[test]
fn bindgen_test_layout_TrackedDevicePose_t() {
    assert_eq!(::std::mem::size_of::<TrackedDevicePose_t>() , 80usize);
    assert_eq!(::std::mem::align_of::<TrackedDevicePose_t>() , 4usize);
}
impl Clone for TrackedDevicePose_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VRTextureBounds_t {
    pub uMin: f32,
    pub vMin: f32,
    pub uMax: f32,
    pub vMax: f32,
}
#[test]
fn bindgen_test_layout_VRTextureBounds_t() {
    assert_eq!(::std::mem::size_of::<VRTextureBounds_t>() , 16usize);
    assert_eq!(::std::mem::align_of::<VRTextureBounds_t>() , 4usize);
}
impl Clone for VRTextureBounds_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VulkanData_t {
    pub m_nImage: u64,
    pub m_pDevice: *mut VulkanData_t_VkDevice_T,
    pub m_pPhysicalDevice: *mut VulkanData_t_VkPhysicalDevice_T,
    pub m_pInstance: *mut VulkanData_t_VkInstance_T,
    pub m_pQueue: *mut VulkanData_t_VkQueue_T,
    pub m_nQueueFamilyIndex: u32,
    pub m_nWidth: u32,
    pub m_nHeight: u32,
    pub m_nFormat: u32,
    pub m_nSampleCount: u32,
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VulkanData_t_VkDevice_T {
    pub _address: u8,
}
impl Clone for VulkanData_t_VkDevice_T {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VulkanData_t_VkPhysicalDevice_T {
    pub _address: u8,
}
impl Clone for VulkanData_t_VkPhysicalDevice_T {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VulkanData_t_VkInstance_T {
    pub _address: u8,
}
impl Clone for VulkanData_t_VkInstance_T {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VulkanData_t_VkQueue_T {
    pub _address: u8,
}
impl Clone for VulkanData_t_VkQueue_T {
    fn clone(&self) -> Self { *self }
}
#[test]
fn bindgen_test_layout_VulkanData_t() {
    assert_eq!(::std::mem::size_of::<VulkanData_t>() , 64usize);
    assert_eq!(::std::mem::align_of::<VulkanData_t>() , 8usize);
}
impl Clone for VulkanData_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VREvent_Controller_t {
    pub button: u32,
}
#[test]
fn bindgen_test_layout_VREvent_Controller_t() {
    assert_eq!(::std::mem::size_of::<VREvent_Controller_t>() , 4usize);
    assert_eq!(::std::mem::align_of::<VREvent_Controller_t>() , 4usize);
}
impl Clone for VREvent_Controller_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VREvent_Mouse_t {
    pub x: f32,
    pub y: f32,
    pub button: u32,
}
#[test]
fn bindgen_test_layout_VREvent_Mouse_t() {
    assert_eq!(::std::mem::size_of::<VREvent_Mouse_t>() , 12usize);
    assert_eq!(::std::mem::align_of::<VREvent_Mouse_t>() , 4usize);
}
impl Clone for VREvent_Mouse_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VREvent_Scroll_t {
    pub xdelta: f32,
    pub ydelta: f32,
    pub repeatCount: u32,
}
#[test]
fn bindgen_test_layout_VREvent_Scroll_t() {
    assert_eq!(::std::mem::size_of::<VREvent_Scroll_t>() , 12usize);
    assert_eq!(::std::mem::align_of::<VREvent_Scroll_t>() , 4usize);
}
impl Clone for VREvent_Scroll_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VREvent_TouchPadMove_t {
    pub bFingerDown: bool,
    pub flSecondsFingerDown: f32,
    pub fValueXFirst: f32,
    pub fValueYFirst: f32,
    pub fValueXRaw: f32,
    pub fValueYRaw: f32,
}
#[test]
fn bindgen_test_layout_VREvent_TouchPadMove_t() {
    assert_eq!(::std::mem::size_of::<VREvent_TouchPadMove_t>() , 24usize);
    assert_eq!(::std::mem::align_of::<VREvent_TouchPadMove_t>() , 4usize);
}
impl Clone for VREvent_TouchPadMove_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VREvent_Notification_t {
    pub ulUserValue: u64,
    pub notificationId: u32,
}
#[test]
fn bindgen_test_layout_VREvent_Notification_t() {
    assert_eq!(::std::mem::size_of::<VREvent_Notification_t>() , 16usize);
    assert_eq!(::std::mem::align_of::<VREvent_Notification_t>() , 8usize);
}
impl Clone for VREvent_Notification_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VREvent_Process_t {
    pub pid: u32,
    pub oldPid: u32,
    pub bForced: bool,
}
#[test]
fn bindgen_test_layout_VREvent_Process_t() {
    assert_eq!(::std::mem::size_of::<VREvent_Process_t>() , 12usize);
    assert_eq!(::std::mem::align_of::<VREvent_Process_t>() , 4usize);
}
impl Clone for VREvent_Process_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VREvent_Overlay_t {
    pub overlayHandle: u64,
}
#[test]
fn bindgen_test_layout_VREvent_Overlay_t() {
    assert_eq!(::std::mem::size_of::<VREvent_Overlay_t>() , 8usize);
    assert_eq!(::std::mem::align_of::<VREvent_Overlay_t>() , 8usize);
}
impl Clone for VREvent_Overlay_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VREvent_Status_t {
    pub statusState: u32,
}
#[test]
fn bindgen_test_layout_VREvent_Status_t() {
    assert_eq!(::std::mem::size_of::<VREvent_Status_t>() , 4usize);
    assert_eq!(::std::mem::align_of::<VREvent_Status_t>() , 4usize);
}
impl Clone for VREvent_Status_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VREvent_Keyboard_t {
    pub cNewInput: [*mut ::std::os::raw::c_char; 8usize],
    pub uUserValue: u64,
}
#[test]
fn bindgen_test_layout_VREvent_Keyboard_t() {
    assert_eq!(::std::mem::size_of::<VREvent_Keyboard_t>() , 72usize);
    assert_eq!(::std::mem::align_of::<VREvent_Keyboard_t>() , 8usize);
}
impl Clone for VREvent_Keyboard_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VREvent_Ipd_t {
    pub ipdMeters: f32,
}
#[test]
fn bindgen_test_layout_VREvent_Ipd_t() {
    assert_eq!(::std::mem::size_of::<VREvent_Ipd_t>() , 4usize);
    assert_eq!(::std::mem::align_of::<VREvent_Ipd_t>() , 4usize);
}
impl Clone for VREvent_Ipd_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VREvent_Chaperone_t {
    pub m_nPreviousUniverse: u64,
    pub m_nCurrentUniverse: u64,
}
#[test]
fn bindgen_test_layout_VREvent_Chaperone_t() {
    assert_eq!(::std::mem::size_of::<VREvent_Chaperone_t>() , 16usize);
    assert_eq!(::std::mem::align_of::<VREvent_Chaperone_t>() , 8usize);
}
impl Clone for VREvent_Chaperone_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VREvent_Reserved_t {
    pub reserved0: u64,
    pub reserved1: u64,
}
#[test]
fn bindgen_test_layout_VREvent_Reserved_t() {
    assert_eq!(::std::mem::size_of::<VREvent_Reserved_t>() , 16usize);
    assert_eq!(::std::mem::align_of::<VREvent_Reserved_t>() , 8usize);
}
impl Clone for VREvent_Reserved_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VREvent_PerformanceTest_t {
    pub m_nFidelityLevel: u32,
}
#[test]
fn bindgen_test_layout_VREvent_PerformanceTest_t() {
    assert_eq!(::std::mem::size_of::<VREvent_PerformanceTest_t>() , 4usize);
    assert_eq!(::std::mem::align_of::<VREvent_PerformanceTest_t>() , 4usize);
}
impl Clone for VREvent_PerformanceTest_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VREvent_SeatedZeroPoseReset_t {
    pub bResetBySystemMenu: bool,
}
#[test]
fn bindgen_test_layout_VREvent_SeatedZeroPoseReset_t() {
    assert_eq!(::std::mem::size_of::<VREvent_SeatedZeroPoseReset_t>() ,
               1usize);
    assert_eq!(::std::mem::align_of::<VREvent_SeatedZeroPoseReset_t>() ,
               1usize);
}
impl Clone for VREvent_SeatedZeroPoseReset_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VREvent_Screenshot_t {
    pub handle: u32,
    pub type_: u32,
}
#[test]
fn bindgen_test_layout_VREvent_Screenshot_t() {
    assert_eq!(::std::mem::size_of::<VREvent_Screenshot_t>() , 8usize);
    assert_eq!(::std::mem::align_of::<VREvent_Screenshot_t>() , 4usize);
}
impl Clone for VREvent_Screenshot_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VREvent_ScreenshotProgress_t {
    pub progress: f32,
}
#[test]
fn bindgen_test_layout_VREvent_ScreenshotProgress_t() {
    assert_eq!(::std::mem::size_of::<VREvent_ScreenshotProgress_t>() ,
               4usize);
    assert_eq!(::std::mem::align_of::<VREvent_ScreenshotProgress_t>() ,
               4usize);
}
impl Clone for VREvent_ScreenshotProgress_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VREvent_ApplicationLaunch_t {
    pub pid: u32,
    pub unArgsHandle: u32,
}
#[test]
fn bindgen_test_layout_VREvent_ApplicationLaunch_t() {
    assert_eq!(::std::mem::size_of::<VREvent_ApplicationLaunch_t>() , 8usize);
    assert_eq!(::std::mem::align_of::<VREvent_ApplicationLaunch_t>() ,
               4usize);
}
impl Clone for VREvent_ApplicationLaunch_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VREvent_EditingCameraSurface_t {
    pub overlayHandle: u64,
    pub nVisualMode: u32,
}
#[test]
fn bindgen_test_layout_VREvent_EditingCameraSurface_t() {
    assert_eq!(::std::mem::size_of::<VREvent_EditingCameraSurface_t>() ,
               16usize);
    assert_eq!(::std::mem::align_of::<VREvent_EditingCameraSurface_t>() ,
               8usize);
}
impl Clone for VREvent_EditingCameraSurface_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct HiddenAreaMesh_t {
    pub pVertexData: *mut HmdVector2_t,
    pub unTriangleCount: u32,
}
#[test]
fn bindgen_test_layout_HiddenAreaMesh_t() {
    assert_eq!(::std::mem::size_of::<HiddenAreaMesh_t>() , 16usize);
    assert_eq!(::std::mem::align_of::<HiddenAreaMesh_t>() , 8usize);
}
impl Clone for HiddenAreaMesh_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VRControllerAxis_t {
    pub x: f32,
    pub y: f32,
}
#[test]
fn bindgen_test_layout_VRControllerAxis_t() {
    assert_eq!(::std::mem::size_of::<VRControllerAxis_t>() , 8usize);
    assert_eq!(::std::mem::align_of::<VRControllerAxis_t>() , 4usize);
}
impl Clone for VRControllerAxis_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VRControllerState_t {
    pub unPacketNum: u32,
    pub ulButtonPressed: u64,
    pub ulButtonTouched: u64,
    pub rAxis: [VRControllerAxis_t; 5usize],
}
#[test]
fn bindgen_test_layout_VRControllerState_t() {
    assert_eq!(::std::mem::size_of::<VRControllerState_t>() , 64usize);
    assert_eq!(::std::mem::align_of::<VRControllerState_t>() , 8usize);
}
impl Clone for VRControllerState_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct Compositor_OverlaySettings {
    pub size: u32,
    pub curved: bool,
    pub antialias: bool,
    pub scale: f32,
    pub distance: f32,
    pub alpha: f32,
    pub uOffset: f32,
    pub vOffset: f32,
    pub uScale: f32,
    pub vScale: f32,
    pub gridDivs: f32,
    pub gridWidth: f32,
    pub gridScale: f32,
    pub transform: HmdMatrix44_t,
}
#[test]
fn bindgen_test_layout_Compositor_OverlaySettings() {
    assert_eq!(::std::mem::size_of::<Compositor_OverlaySettings>() ,
               112usize);
    assert_eq!(::std::mem::align_of::<Compositor_OverlaySettings>() , 4usize);
}
impl Clone for Compositor_OverlaySettings {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct CameraVideoStreamFrameHeader_t {
    pub eFrameType: EVRTrackedCameraFrameType,
    pub nWidth: u32,
    pub nHeight: u32,
    pub nBytesPerPixel: u32,
    pub nFrameSequence: u32,
    pub standingTrackedDevicePose: TrackedDevicePose_t,
}
#[test]
fn bindgen_test_layout_CameraVideoStreamFrameHeader_t() {
    assert_eq!(::std::mem::size_of::<CameraVideoStreamFrameHeader_t>() ,
               100usize);
    assert_eq!(::std::mem::align_of::<CameraVideoStreamFrameHeader_t>() ,
               4usize);
}
impl Clone for CameraVideoStreamFrameHeader_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct AppOverrideKeys_t {
    pub pchKey: *mut ::std::os::raw::c_char,
    pub pchValue: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_AppOverrideKeys_t() {
    assert_eq!(::std::mem::size_of::<AppOverrideKeys_t>() , 16usize);
    assert_eq!(::std::mem::align_of::<AppOverrideKeys_t>() , 8usize);
}
impl Clone for AppOverrideKeys_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct Compositor_FrameTiming {
    pub m_nSize: u32,
    pub m_nFrameIndex: u32,
    pub m_nNumFramePresents: u32,
    pub m_nNumMisPresented: u32,
    pub m_nNumDroppedFrames: u32,
    pub m_nReprojectionFlags: u32,
    pub m_flSystemTimeInSeconds: f64,
    pub m_flPreSubmitGpuMs: f32,
    pub m_flPostSubmitGpuMs: f32,
    pub m_flTotalRenderGpuMs: f32,
    pub m_flCompositorRenderGpuMs: f32,
    pub m_flCompositorRenderCpuMs: f32,
    pub m_flCompositorIdleCpuMs: f32,
    pub m_flClientFrameIntervalMs: f32,
    pub m_flPresentCallCpuMs: f32,
    pub m_flWaitForPresentCpuMs: f32,
    pub m_flSubmitFrameMs: f32,
    pub m_flWaitGetPosesCalledMs: f32,
    pub m_flNewPosesReadyMs: f32,
    pub m_flNewFrameReadyMs: f32,
    pub m_flCompositorUpdateStartMs: f32,
    pub m_flCompositorUpdateEndMs: f32,
    pub m_flCompositorRenderStartMs: f32,
    pub m_HmdPose: TrackedDevicePose_t,
}
#[test]
fn bindgen_test_layout_Compositor_FrameTiming() {
    assert_eq!(::std::mem::size_of::<Compositor_FrameTiming>() , 176usize);
    assert_eq!(::std::mem::align_of::<Compositor_FrameTiming>() , 8usize);
}
impl Clone for Compositor_FrameTiming {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct Compositor_CumulativeStats {
    pub m_nPid: u32,
    pub m_nNumFramePresents: u32,
    pub m_nNumDroppedFrames: u32,
    pub m_nNumReprojectedFrames: u32,
    pub m_nNumFramePresentsOnStartup: u32,
    pub m_nNumDroppedFramesOnStartup: u32,
    pub m_nNumReprojectedFramesOnStartup: u32,
    pub m_nNumLoading: u32,
    pub m_nNumFramePresentsLoading: u32,
    pub m_nNumDroppedFramesLoading: u32,
    pub m_nNumReprojectedFramesLoading: u32,
    pub m_nNumTimedOut: u32,
    pub m_nNumFramePresentsTimedOut: u32,
    pub m_nNumDroppedFramesTimedOut: u32,
    pub m_nNumReprojectedFramesTimedOut: u32,
}
#[test]
fn bindgen_test_layout_Compositor_CumulativeStats() {
    assert_eq!(::std::mem::size_of::<Compositor_CumulativeStats>() , 60usize);
    assert_eq!(::std::mem::align_of::<Compositor_CumulativeStats>() , 4usize);
}
impl Clone for Compositor_CumulativeStats {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VROverlayIntersectionParams_t {
    pub vSource: HmdVector3_t,
    pub vDirection: HmdVector3_t,
    pub eOrigin: ETrackingUniverseOrigin,
}
#[test]
fn bindgen_test_layout_VROverlayIntersectionParams_t() {
    assert_eq!(::std::mem::size_of::<VROverlayIntersectionParams_t>() ,
               28usize);
    assert_eq!(::std::mem::align_of::<VROverlayIntersectionParams_t>() ,
               4usize);
}
impl Clone for VROverlayIntersectionParams_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VROverlayIntersectionResults_t {
    pub vPoint: HmdVector3_t,
    pub vNormal: HmdVector3_t,
    pub vUVs: HmdVector2_t,
    pub fDistance: f32,
}
#[test]
fn bindgen_test_layout_VROverlayIntersectionResults_t() {
    assert_eq!(::std::mem::size_of::<VROverlayIntersectionResults_t>() ,
               36usize);
    assert_eq!(::std::mem::align_of::<VROverlayIntersectionResults_t>() ,
               4usize);
}
impl Clone for VROverlayIntersectionResults_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct IntersectionMaskRectangle_t {
    pub m_flTopLeftX: f32,
    pub m_flTopLeftY: f32,
    pub m_flWidth: f32,
    pub m_flHeight: f32,
}
#[test]
fn bindgen_test_layout_IntersectionMaskRectangle_t() {
    assert_eq!(::std::mem::size_of::<IntersectionMaskRectangle_t>() ,
               16usize);
    assert_eq!(::std::mem::align_of::<IntersectionMaskRectangle_t>() ,
               4usize);
}
impl Clone for IntersectionMaskRectangle_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct IntersectionMaskCircle_t {
    pub m_flCenterX: f32,
    pub m_flCenterY: f32,
    pub m_flRadius: f32,
}
#[test]
fn bindgen_test_layout_IntersectionMaskCircle_t() {
    assert_eq!(::std::mem::size_of::<IntersectionMaskCircle_t>() , 12usize);
    assert_eq!(::std::mem::align_of::<IntersectionMaskCircle_t>() , 4usize);
}
impl Clone for IntersectionMaskCircle_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct RenderModel_ComponentState_t {
    pub mTrackingToComponentRenderModel: HmdMatrix34_t,
    pub mTrackingToComponentLocal: HmdMatrix34_t,
    pub uProperties: VRComponentProperties,
}
#[test]
fn bindgen_test_layout_RenderModel_ComponentState_t() {
    assert_eq!(::std::mem::size_of::<RenderModel_ComponentState_t>() ,
               100usize);
    assert_eq!(::std::mem::align_of::<RenderModel_ComponentState_t>() ,
               4usize);
}
impl Clone for RenderModel_ComponentState_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct RenderModel_Vertex_t {
    pub vPosition: HmdVector3_t,
    pub vNormal: HmdVector3_t,
    pub rfTextureCoord: [f32; 2usize],
}
#[test]
fn bindgen_test_layout_RenderModel_Vertex_t() {
    assert_eq!(::std::mem::size_of::<RenderModel_Vertex_t>() , 32usize);
    assert_eq!(::std::mem::align_of::<RenderModel_Vertex_t>() , 4usize);
}
impl Clone for RenderModel_Vertex_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct RenderModel_TextureMap_t {
    pub unWidth: u16,
    pub unHeight: u16,
    pub rubTextureMapData: *mut u8,
}
#[test]
fn bindgen_test_layout_RenderModel_TextureMap_t() {
    assert_eq!(::std::mem::size_of::<RenderModel_TextureMap_t>() , 16usize);
    assert_eq!(::std::mem::align_of::<RenderModel_TextureMap_t>() , 8usize);
}
impl Clone for RenderModel_TextureMap_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct RenderModel_t {
    pub rVertexData: *mut RenderModel_Vertex_t,
    pub unVertexCount: u32,
    pub rIndexData: *mut u16,
    pub unTriangleCount: u32,
    pub diffuseTextureId: TextureID_t,
}
#[test]
fn bindgen_test_layout_RenderModel_t() {
    assert_eq!(::std::mem::size_of::<RenderModel_t>() , 32usize);
    assert_eq!(::std::mem::align_of::<RenderModel_t>() , 8usize);
}
impl Clone for RenderModel_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct RenderModel_ControllerMode_State_t {
    pub bScrollWheelVisible: bool,
}
#[test]
fn bindgen_test_layout_RenderModel_ControllerMode_State_t() {
    assert_eq!(::std::mem::size_of::<RenderModel_ControllerMode_State_t>() ,
               1usize);
    assert_eq!(::std::mem::align_of::<RenderModel_ControllerMode_State_t>() ,
               1usize);
}
impl Clone for RenderModel_ControllerMode_State_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct NotificationBitmap_t {
    pub m_pImageData: *mut ::std::os::raw::c_void,
    pub m_nWidth: i32,
    pub m_nHeight: i32,
    pub m_nBytesPerPixel: i32,
}
#[test]
fn bindgen_test_layout_NotificationBitmap_t() {
    assert_eq!(::std::mem::size_of::<NotificationBitmap_t>() , 24usize);
    assert_eq!(::std::mem::align_of::<NotificationBitmap_t>() , 8usize);
}
impl Clone for NotificationBitmap_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct COpenVRContext {
    pub m_pVRSystem: isize,
    pub m_pVRChaperone: isize,
    pub m_pVRChaperoneSetup: isize,
    pub m_pVRCompositor: isize,
    pub m_pVROverlay: isize,
    pub m_pVRResources: isize,
    pub m_pVRRenderModels: isize,
    pub m_pVRExtendedDisplay: isize,
    pub m_pVRSettings: isize,
    pub m_pVRApplications: isize,
    pub m_pVRTrackedCamera: isize,
    pub m_pVRScreenshots: isize,
}
#[test]
fn bindgen_test_layout_COpenVRContext() {
    assert_eq!(::std::mem::size_of::<COpenVRContext>() , 96usize);
    assert_eq!(::std::mem::align_of::<COpenVRContext>() , 8usize);
}
impl Clone for COpenVRContext {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Copy)]
pub union _bindgen_ty_1 {
    pub reserved: VREvent_Reserved_t,
    pub controller: VREvent_Controller_t,
    pub mouse: VREvent_Mouse_t,
    pub scroll: VREvent_Scroll_t,
    pub process: VREvent_Process_t,
    pub notification: VREvent_Notification_t,
    pub overlay: VREvent_Overlay_t,
    pub status: VREvent_Status_t,
    pub keyboard: VREvent_Keyboard_t,
    pub ipd: VREvent_Ipd_t,
    pub chaperone: VREvent_Chaperone_t,
    pub performanceTest: VREvent_PerformanceTest_t,
    pub touchPadMove: VREvent_TouchPadMove_t,
    pub seatedZeroPoseReset: VREvent_SeatedZeroPoseReset_t,
}
#[test]
fn bindgen_test_layout__bindgen_ty_1() {
    assert_eq!(::std::mem::size_of::<_bindgen_ty_1>() , 72usize);
    assert_eq!(::std::mem::align_of::<_bindgen_ty_1>() , 8usize);
}
impl Clone for _bindgen_ty_1 {
    fn clone(&self) -> Self { *self }
}
pub type VREvent_Data_t = _bindgen_ty_1;
/** An event posted by the server to all running applications */
#[repr(C)]
#[derive(Copy)]
pub struct VREvent_t {
    pub eventType: u32,
    pub trackedDeviceIndex: TrackedDeviceIndex_t,
    pub eventAgeSeconds: f32,
    pub data: VREvent_Data_t,
}
#[test]
fn bindgen_test_layout_VREvent_t() {
    assert_eq!(::std::mem::size_of::<VREvent_t>() , 88usize);
    assert_eq!(::std::mem::align_of::<VREvent_t>() , 8usize);
}
impl Clone for VREvent_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Copy)]
pub union _bindgen_ty_2 {
    pub m_Rectangle: IntersectionMaskRectangle_t,
    pub m_Circle: IntersectionMaskCircle_t,
}
#[test]
fn bindgen_test_layout__bindgen_ty_2() {
    assert_eq!(::std::mem::size_of::<_bindgen_ty_2>() , 16usize);
    assert_eq!(::std::mem::align_of::<_bindgen_ty_2>() , 4usize);
}
impl Clone for _bindgen_ty_2 {
    fn clone(&self) -> Self { *self }
}
pub type VROverlayIntersectionMaskPrimitive_Data_t = _bindgen_ty_2;
#[repr(C)]
#[derive(Copy)]
pub struct VROverlayIntersectionMaskPrimitive_t {
    pub m_nPrimitiveType: EVROverlayIntersectionMaskPrimitiveType,
    pub m_Primitive: VROverlayIntersectionMaskPrimitive_Data_t,
}
#[test]
fn bindgen_test_layout_VROverlayIntersectionMaskPrimitive_t() {
    assert_eq!(::std::mem::size_of::<VROverlayIntersectionMaskPrimitive_t>() ,
               20usize);
    assert_eq!(::std::mem::align_of::<VROverlayIntersectionMaskPrimitive_t>()
               , 4usize);
}
impl Clone for VROverlayIntersectionMaskPrimitive_t {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VR_IVRSystem_FnTable {
    pub GetRecommendedRenderTargetSize: ::std::option::Option<unsafe extern "C" fn(pnWidth:
                                                                                       *mut u32,
                                                                                   pnHeight:
                                                                                       *mut u32)>,
    pub GetProjectionMatrix: ::std::option::Option<unsafe extern "C" fn(eEye:
                                                                            EVREye,
                                                                        fNearZ:
                                                                            f32,
                                                                        fFarZ:
                                                                            f32,
                                                                        eProjType:
                                                                            EGraphicsAPIConvention)
                                                       -> HmdMatrix44_t>,
    pub GetProjectionRaw: ::std::option::Option<unsafe extern "C" fn(eEye:
                                                                         EVREye,
                                                                     pfLeft:
                                                                         *mut f32,
                                                                     pfRight:
                                                                         *mut f32,
                                                                     pfTop:
                                                                         *mut f32,
                                                                     pfBottom:
                                                                         *mut f32)>,
    pub ComputeDistortion: ::std::option::Option<unsafe extern "C" fn(eEye:
                                                                          EVREye,
                                                                      fU: f32,
                                                                      fV: f32,
                                                                      pDistortionCoordinates:
                                                                          *mut DistortionCoordinates_t)
                                                     -> bool>,
    pub GetEyeToHeadTransform: ::std::option::Option<unsafe extern "C" fn(eEye:
                                                                              EVREye)
                                                         -> HmdMatrix34_t>,
    pub GetTimeSinceLastVsync: ::std::option::Option<unsafe extern "C" fn(pfSecondsSinceLastVsync:
                                                                              *mut f32,
                                                                          pulFrameCounter:
                                                                              *mut u64)
                                                         -> bool>,
    pub GetD3D9AdapterIndex: ::std::option::Option<unsafe extern "C" fn()
                                                       ->
                                                           ::std::os::raw::c_int>,
    pub GetDXGIOutputInfo: ::std::option::Option<unsafe extern "C" fn(pnAdapterIndex:
                                                                          *mut i32)>,
    pub IsDisplayOnDesktop: ::std::option::Option<unsafe extern "C" fn()
                                                      -> bool>,
    pub SetDisplayVisibility: ::std::option::Option<unsafe extern "C" fn(bIsVisibleOnDesktop:
                                                                             bool)
                                                        -> bool>,
    pub GetDeviceToAbsoluteTrackingPose: ::std::option::Option<unsafe extern "C" fn(eOrigin:
                                                                                        ETrackingUniverseOrigin,
                                                                                    fPredictedSecondsToPhotonsFromNow:
                                                                                        f32,
                                                                                    pTrackedDevicePoseArray:
                                                                                        *mut TrackedDevicePose_t,
                                                                                    unTrackedDevicePoseArrayCount:
                                                                                        u32)>,
    pub ResetSeatedZeroPose: ::std::option::Option<unsafe extern "C" fn()>,
    pub GetSeatedZeroPoseToStandingAbsoluteTrackingPose: ::std::option::Option<unsafe extern "C" fn()
                                                                                   ->
                                                                                       HmdMatrix34_t>,
    pub GetRawZeroPoseToStandingAbsoluteTrackingPose: ::std::option::Option<unsafe extern "C" fn()
                                                                                ->
                                                                                    HmdMatrix34_t>,
    pub GetSortedTrackedDeviceIndicesOfClass: ::std::option::Option<unsafe extern "C" fn(eTrackedDeviceClass:
                                                                                             ETrackedDeviceClass,
                                                                                         punTrackedDeviceIndexArray:
                                                                                             *mut TrackedDeviceIndex_t,
                                                                                         unTrackedDeviceIndexArrayCount:
                                                                                             u32,
                                                                                         unRelativeToTrackedDeviceIndex:
                                                                                             TrackedDeviceIndex_t)
                                                                        ->
                                                                            ::std::os::raw::c_uint>,
    pub GetTrackedDeviceActivityLevel: ::std::option::Option<unsafe extern "C" fn(unDeviceId:
                                                                                      TrackedDeviceIndex_t)
                                                                 ->
                                                                     EDeviceActivityLevel>,
    pub ApplyTransform: ::std::option::Option<unsafe extern "C" fn(pOutputPose:
                                                                       *mut TrackedDevicePose_t,
                                                                   pTrackedDevicePose:
                                                                       *mut TrackedDevicePose_t,
                                                                   pTransform:
                                                                       *mut HmdMatrix34_t)>,
    pub GetTrackedDeviceIndexForControllerRole: ::std::option::Option<unsafe extern "C" fn(unDeviceType:
                                                                                               ETrackedControllerRole)
                                                                          ->
                                                                              ::std::os::raw::c_uint>,
    pub GetControllerRoleForTrackedDeviceIndex: ::std::option::Option<unsafe extern "C" fn(unDeviceIndex:
                                                                                               TrackedDeviceIndex_t)
                                                                          ->
                                                                              ETrackedControllerRole>,
    pub GetTrackedDeviceClass: ::std::option::Option<unsafe extern "C" fn(unDeviceIndex:
                                                                              TrackedDeviceIndex_t)
                                                         ->
                                                             ETrackedDeviceClass>,
    pub IsTrackedDeviceConnected: ::std::option::Option<unsafe extern "C" fn(unDeviceIndex:
                                                                                 TrackedDeviceIndex_t)
                                                            -> bool>,
    pub GetBoolTrackedDeviceProperty: ::std::option::Option<unsafe extern "C" fn(unDeviceIndex:
                                                                                     TrackedDeviceIndex_t,
                                                                                 prop:
                                                                                     ETrackedDeviceProperty,
                                                                                 pError:
                                                                                     *mut ETrackedPropertyError)
                                                                -> bool>,
    pub GetFloatTrackedDeviceProperty: ::std::option::Option<unsafe extern "C" fn(unDeviceIndex:
                                                                                      TrackedDeviceIndex_t,
                                                                                  prop:
                                                                                      ETrackedDeviceProperty,
                                                                                  pError:
                                                                                      *mut ETrackedPropertyError)
                                                                 -> f32>,
    pub GetInt32TrackedDeviceProperty: ::std::option::Option<unsafe extern "C" fn(unDeviceIndex:
                                                                                      TrackedDeviceIndex_t,
                                                                                  prop:
                                                                                      ETrackedDeviceProperty,
                                                                                  pError:
                                                                                      *mut ETrackedPropertyError)
                                                                 ->
                                                                     ::std::os::raw::c_int>,
    pub GetUint64TrackedDeviceProperty: ::std::option::Option<unsafe extern "C" fn(unDeviceIndex:
                                                                                       TrackedDeviceIndex_t,
                                                                                   prop:
                                                                                       ETrackedDeviceProperty,
                                                                                   pError:
                                                                                       *mut ETrackedPropertyError)
                                                                  ->
                                                                      ::std::os::raw::c_ulonglong>,
    pub GetMatrix34TrackedDeviceProperty: ::std::option::Option<unsafe extern "C" fn(unDeviceIndex:
                                                                                         TrackedDeviceIndex_t,
                                                                                     prop:
                                                                                         ETrackedDeviceProperty,
                                                                                     pError:
                                                                                         *mut ETrackedPropertyError)
                                                                    ->
                                                                        HmdMatrix34_t>,
    pub GetStringTrackedDeviceProperty: ::std::option::Option<unsafe extern "C" fn(unDeviceIndex:
                                                                                       TrackedDeviceIndex_t,
                                                                                   prop:
                                                                                       ETrackedDeviceProperty,
                                                                                   pchValue:
                                                                                       *mut ::std::os::raw::c_char,
                                                                                   unBufferSize:
                                                                                       u32,
                                                                                   pError:
                                                                                       *mut ETrackedPropertyError)
                                                                  ->
                                                                      ::std::os::raw::c_uint>,
    pub GetPropErrorNameFromEnum: ::std::option::Option<unsafe extern "C" fn(error:
                                                                                 ETrackedPropertyError)
                                                            ->
                                                                *mut ::std::os::raw::c_char>,
    pub PollNextEvent: ::std::option::Option<unsafe extern "C" fn(pEvent:
                                                                      *mut VREvent_t,
                                                                  uncbVREvent:
                                                                      u32)
                                                 -> bool>,
    pub PollNextEventWithPose: ::std::option::Option<unsafe extern "C" fn(eOrigin:
                                                                              ETrackingUniverseOrigin,
                                                                          pEvent:
                                                                              *mut VREvent_t,
                                                                          uncbVREvent:
                                                                              u32,
                                                                          pTrackedDevicePose:
                                                                              *mut TrackedDevicePose_t)
                                                         -> bool>,
    pub GetEventTypeNameFromEnum: ::std::option::Option<unsafe extern "C" fn(eType:
                                                                                 EVREventType)
                                                            ->
                                                                *mut ::std::os::raw::c_char>,
    pub GetHiddenAreaMesh: ::std::option::Option<unsafe extern "C" fn(eEye:
                                                                          EVREye,
                                                                      type_:
                                                                          EHiddenAreaMeshType)
                                                     -> HiddenAreaMesh_t>,
    pub GetControllerState: ::std::option::Option<unsafe extern "C" fn(unControllerDeviceIndex:
                                                                           TrackedDeviceIndex_t,
                                                                       pControllerState:
                                                                           *mut VRControllerState_t,
                                                                       unControllerStateSize:
                                                                           u32)
                                                      -> bool>,
    pub GetControllerStateWithPose: ::std::option::Option<unsafe extern "C" fn(eOrigin:
                                                                                   ETrackingUniverseOrigin,
                                                                               unControllerDeviceIndex:
                                                                                   TrackedDeviceIndex_t,
                                                                               pControllerState:
                                                                                   *mut VRControllerState_t,
                                                                               unControllerStateSize:
                                                                                   u32,
                                                                               pTrackedDevicePose:
                                                                                   *mut TrackedDevicePose_t)
                                                              -> bool>,
    pub TriggerHapticPulse: ::std::option::Option<unsafe extern "C" fn(unControllerDeviceIndex:
                                                                           TrackedDeviceIndex_t,
                                                                       unAxisId:
                                                                           u32,
                                                                       usDurationMicroSec:
                                                                           ::std::os::raw::c_ushort)>,
    pub GetButtonIdNameFromEnum: ::std::option::Option<unsafe extern "C" fn(eButtonId:
                                                                                EVRButtonId)
                                                           ->
                                                               *mut ::std::os::raw::c_char>,
    pub GetControllerAxisTypeNameFromEnum: ::std::option::Option<unsafe extern "C" fn(eAxisType:
                                                                                          EVRControllerAxisType)
                                                                     ->
                                                                         *mut ::std::os::raw::c_char>,
    pub CaptureInputFocus: ::std::option::Option<unsafe extern "C" fn()
                                                     -> bool>,
    pub ReleaseInputFocus: ::std::option::Option<unsafe extern "C" fn()>,
    pub IsInputFocusCapturedByAnotherProcess: ::std::option::Option<unsafe extern "C" fn()
                                                                        ->
                                                                            bool>,
    pub DriverDebugRequest: ::std::option::Option<unsafe extern "C" fn(unDeviceIndex:
                                                                           TrackedDeviceIndex_t,
                                                                       pchRequest:
                                                                           *mut ::std::os::raw::c_char,
                                                                       pchResponseBuffer:
                                                                           *mut ::std::os::raw::c_char,
                                                                       unResponseBufferSize:
                                                                           u32)
                                                      ->
                                                          ::std::os::raw::c_uint>,
    pub PerformFirmwareUpdate: ::std::option::Option<unsafe extern "C" fn(unDeviceIndex:
                                                                              TrackedDeviceIndex_t)
                                                         -> EVRFirmwareError>,
    pub AcknowledgeQuit_Exiting: ::std::option::Option<unsafe extern "C" fn()>,
    pub AcknowledgeQuit_UserPrompt: ::std::option::Option<unsafe extern "C" fn()>,
}
#[test]
fn bindgen_test_layout_VR_IVRSystem_FnTable() {
    assert_eq!(::std::mem::size_of::<VR_IVRSystem_FnTable>() , 352usize);
    assert_eq!(::std::mem::align_of::<VR_IVRSystem_FnTable>() , 8usize);
}
impl Clone for VR_IVRSystem_FnTable {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VR_IVRExtendedDisplay_FnTable {
    pub GetWindowBounds: ::std::option::Option<unsafe extern "C" fn(pnX:
                                                                        *mut i32,
                                                                    pnY:
                                                                        *mut i32,
                                                                    pnWidth:
                                                                        *mut u32,
                                                                    pnHeight:
                                                                        *mut u32)>,
    pub GetEyeOutputViewport: ::std::option::Option<unsafe extern "C" fn(eEye:
                                                                             EVREye,
                                                                         pnX:
                                                                             *mut u32,
                                                                         pnY:
                                                                             *mut u32,
                                                                         pnWidth:
                                                                             *mut u32,
                                                                         pnHeight:
                                                                             *mut u32)>,
    pub GetDXGIOutputInfo: ::std::option::Option<unsafe extern "C" fn(pnAdapterIndex:
                                                                          *mut i32,
                                                                      pnAdapterOutputIndex:
                                                                          *mut i32)>,
}
#[test]
fn bindgen_test_layout_VR_IVRExtendedDisplay_FnTable() {
    assert_eq!(::std::mem::size_of::<VR_IVRExtendedDisplay_FnTable>() ,
               24usize);
    assert_eq!(::std::mem::align_of::<VR_IVRExtendedDisplay_FnTable>() ,
               8usize);
}
impl Clone for VR_IVRExtendedDisplay_FnTable {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VR_IVRTrackedCamera_FnTable {
    pub GetCameraErrorNameFromEnum: ::std::option::Option<unsafe extern "C" fn(eCameraError:
                                                                                   EVRTrackedCameraError)
                                                              ->
                                                                  *mut ::std::os::raw::c_char>,
    pub HasCamera: ::std::option::Option<unsafe extern "C" fn(nDeviceIndex:
                                                                  TrackedDeviceIndex_t,
                                                              pHasCamera:
                                                                  *mut bool)
                                             -> EVRTrackedCameraError>,
    pub GetCameraFrameSize: ::std::option::Option<unsafe extern "C" fn(nDeviceIndex:
                                                                           TrackedDeviceIndex_t,
                                                                       eFrameType:
                                                                           EVRTrackedCameraFrameType,
                                                                       pnWidth:
                                                                           *mut u32,
                                                                       pnHeight:
                                                                           *mut u32,
                                                                       pnFrameBufferSize:
                                                                           *mut u32)
                                                      ->
                                                          EVRTrackedCameraError>,
    pub GetCameraIntrinisics: ::std::option::Option<unsafe extern "C" fn(nDeviceIndex:
                                                                             TrackedDeviceIndex_t,
                                                                         eFrameType:
                                                                             EVRTrackedCameraFrameType,
                                                                         pFocalLength:
                                                                             *mut HmdVector2_t,
                                                                         pCenter:
                                                                             *mut HmdVector2_t)
                                                        ->
                                                            EVRTrackedCameraError>,
    pub GetCameraProjection: ::std::option::Option<unsafe extern "C" fn(nDeviceIndex:
                                                                            TrackedDeviceIndex_t,
                                                                        eFrameType:
                                                                            EVRTrackedCameraFrameType,
                                                                        flZNear:
                                                                            f32,
                                                                        flZFar:
                                                                            f32,
                                                                        pProjection:
                                                                            *mut HmdMatrix44_t)
                                                       ->
                                                           EVRTrackedCameraError>,
    pub AcquireVideoStreamingService: ::std::option::Option<unsafe extern "C" fn(nDeviceIndex:
                                                                                     TrackedDeviceIndex_t,
                                                                                 pHandle:
                                                                                     *mut TrackedCameraHandle_t)
                                                                ->
                                                                    EVRTrackedCameraError>,
    pub ReleaseVideoStreamingService: ::std::option::Option<unsafe extern "C" fn(hTrackedCamera:
                                                                                     TrackedCameraHandle_t)
                                                                ->
                                                                    EVRTrackedCameraError>,
    pub GetVideoStreamFrameBuffer: ::std::option::Option<unsafe extern "C" fn(hTrackedCamera:
                                                                                  TrackedCameraHandle_t,
                                                                              eFrameType:
                                                                                  EVRTrackedCameraFrameType,
                                                                              pFrameBuffer:
                                                                                  *mut ::std::os::raw::c_void,
                                                                              nFrameBufferSize:
                                                                                  u32,
                                                                              pFrameHeader:
                                                                                  *mut CameraVideoStreamFrameHeader_t,
                                                                              nFrameHeaderSize:
                                                                                  u32)
                                                             ->
                                                                 EVRTrackedCameraError>,
    pub GetVideoStreamTextureSize: ::std::option::Option<unsafe extern "C" fn(nDeviceIndex:
                                                                                  TrackedDeviceIndex_t,
                                                                              eFrameType:
                                                                                  EVRTrackedCameraFrameType,
                                                                              pTextureBounds:
                                                                                  *mut VRTextureBounds_t,
                                                                              pnWidth:
                                                                                  *mut u32,
                                                                              pnHeight:
                                                                                  *mut u32)
                                                             ->
                                                                 EVRTrackedCameraError>,
    pub GetVideoStreamTextureD3D11: ::std::option::Option<unsafe extern "C" fn(hTrackedCamera:
                                                                                   TrackedCameraHandle_t,
                                                                               eFrameType:
                                                                                   EVRTrackedCameraFrameType,
                                                                               pD3D11DeviceOrResource:
                                                                                   *mut ::std::os::raw::c_void,
                                                                               ppD3D11ShaderResourceView:
                                                                                   *mut *mut ::std::os::raw::c_void,
                                                                               pFrameHeader:
                                                                                   *mut CameraVideoStreamFrameHeader_t,
                                                                               nFrameHeaderSize:
                                                                                   u32)
                                                              ->
                                                                  EVRTrackedCameraError>,
    pub GetVideoStreamTextureGL: ::std::option::Option<unsafe extern "C" fn(hTrackedCamera:
                                                                                TrackedCameraHandle_t,
                                                                            eFrameType:
                                                                                EVRTrackedCameraFrameType,
                                                                            pglTextureId:
                                                                                *mut glUInt_t,
                                                                            pFrameHeader:
                                                                                *mut CameraVideoStreamFrameHeader_t,
                                                                            nFrameHeaderSize:
                                                                                u32)
                                                           ->
                                                               EVRTrackedCameraError>,
    pub ReleaseVideoStreamTextureGL: ::std::option::Option<unsafe extern "C" fn(hTrackedCamera:
                                                                                    TrackedCameraHandle_t,
                                                                                glTextureId:
                                                                                    glUInt_t)
                                                               ->
                                                                   EVRTrackedCameraError>,
}
#[test]
fn bindgen_test_layout_VR_IVRTrackedCamera_FnTable() {
    assert_eq!(::std::mem::size_of::<VR_IVRTrackedCamera_FnTable>() ,
               96usize);
    assert_eq!(::std::mem::align_of::<VR_IVRTrackedCamera_FnTable>() ,
               8usize);
}
impl Clone for VR_IVRTrackedCamera_FnTable {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VR_IVRApplications_FnTable {
    pub AddApplicationManifest: ::std::option::Option<unsafe extern "C" fn(pchApplicationManifestFullPath:
                                                                               *mut ::std::os::raw::c_char,
                                                                           bTemporary:
                                                                               bool)
                                                          ->
                                                              EVRApplicationError>,
    pub RemoveApplicationManifest: ::std::option::Option<unsafe extern "C" fn(pchApplicationManifestFullPath:
                                                                                  *mut ::std::os::raw::c_char)
                                                             ->
                                                                 EVRApplicationError>,
    pub IsApplicationInstalled: ::std::option::Option<unsafe extern "C" fn(pchAppKey:
                                                                               *mut ::std::os::raw::c_char)
                                                          -> bool>,
    pub GetApplicationCount: ::std::option::Option<unsafe extern "C" fn()
                                                       ->
                                                           ::std::os::raw::c_uint>,
    pub GetApplicationKeyByIndex: ::std::option::Option<unsafe extern "C" fn(unApplicationIndex:
                                                                                 u32,
                                                                             pchAppKeyBuffer:
                                                                                 *mut ::std::os::raw::c_char,
                                                                             unAppKeyBufferLen:
                                                                                 u32)
                                                            ->
                                                                EVRApplicationError>,
    pub GetApplicationKeyByProcessId: ::std::option::Option<unsafe extern "C" fn(unProcessId:
                                                                                     u32,
                                                                                 pchAppKeyBuffer:
                                                                                     *mut ::std::os::raw::c_char,
                                                                                 unAppKeyBufferLen:
                                                                                     u32)
                                                                ->
                                                                    EVRApplicationError>,
    pub LaunchApplication: ::std::option::Option<unsafe extern "C" fn(pchAppKey:
                                                                          *mut ::std::os::raw::c_char)
                                                     -> EVRApplicationError>,
    pub LaunchTemplateApplication: ::std::option::Option<unsafe extern "C" fn(pchTemplateAppKey:
                                                                                  *mut ::std::os::raw::c_char,
                                                                              pchNewAppKey:
                                                                                  *mut ::std::os::raw::c_char,
                                                                              pKeys:
                                                                                  *mut AppOverrideKeys_t,
                                                                              unKeys:
                                                                                  u32)
                                                             ->
                                                                 EVRApplicationError>,
    pub LaunchApplicationFromMimeType: ::std::option::Option<unsafe extern "C" fn(pchMimeType:
                                                                                      *mut ::std::os::raw::c_char,
                                                                                  pchArgs:
                                                                                      *mut ::std::os::raw::c_char)
                                                                 ->
                                                                     EVRApplicationError>,
    pub LaunchDashboardOverlay: ::std::option::Option<unsafe extern "C" fn(pchAppKey:
                                                                               *mut ::std::os::raw::c_char)
                                                          ->
                                                              EVRApplicationError>,
    pub CancelApplicationLaunch: ::std::option::Option<unsafe extern "C" fn(pchAppKey:
                                                                                *mut ::std::os::raw::c_char)
                                                           -> bool>,
    pub IdentifyApplication: ::std::option::Option<unsafe extern "C" fn(unProcessId:
                                                                            u32,
                                                                        pchAppKey:
                                                                            *mut ::std::os::raw::c_char)
                                                       ->
                                                           EVRApplicationError>,
    pub GetApplicationProcessId: ::std::option::Option<unsafe extern "C" fn(pchAppKey:
                                                                                *mut ::std::os::raw::c_char)
                                                           ->
                                                               ::std::os::raw::c_uint>,
    pub GetApplicationsErrorNameFromEnum: ::std::option::Option<unsafe extern "C" fn(error:
                                                                                         EVRApplicationError)
                                                                    ->
                                                                        *mut ::std::os::raw::c_char>,
    pub GetApplicationPropertyString: ::std::option::Option<unsafe extern "C" fn(pchAppKey:
                                                                                     *mut ::std::os::raw::c_char,
                                                                                 eProperty:
                                                                                     EVRApplicationProperty,
                                                                                 pchPropertyValueBuffer:
                                                                                     *mut ::std::os::raw::c_char,
                                                                                 unPropertyValueBufferLen:
                                                                                     u32,
                                                                                 peError:
                                                                                     *mut EVRApplicationError)
                                                                ->
                                                                    ::std::os::raw::c_uint>,
    pub GetApplicationPropertyBool: ::std::option::Option<unsafe extern "C" fn(pchAppKey:
                                                                                   *mut ::std::os::raw::c_char,
                                                                               eProperty:
                                                                                   EVRApplicationProperty,
                                                                               peError:
                                                                                   *mut EVRApplicationError)
                                                              -> bool>,
    pub GetApplicationPropertyUint64: ::std::option::Option<unsafe extern "C" fn(pchAppKey:
                                                                                     *mut ::std::os::raw::c_char,
                                                                                 eProperty:
                                                                                     EVRApplicationProperty,
                                                                                 peError:
                                                                                     *mut EVRApplicationError)
                                                                ->
                                                                    ::std::os::raw::c_ulonglong>,
    pub SetApplicationAutoLaunch: ::std::option::Option<unsafe extern "C" fn(pchAppKey:
                                                                                 *mut ::std::os::raw::c_char,
                                                                             bAutoLaunch:
                                                                                 bool)
                                                            ->
                                                                EVRApplicationError>,
    pub GetApplicationAutoLaunch: ::std::option::Option<unsafe extern "C" fn(pchAppKey:
                                                                                 *mut ::std::os::raw::c_char)
                                                            -> bool>,
    pub SetDefaultApplicationForMimeType: ::std::option::Option<unsafe extern "C" fn(pchAppKey:
                                                                                         *mut ::std::os::raw::c_char,
                                                                                     pchMimeType:
                                                                                         *mut ::std::os::raw::c_char)
                                                                    ->
                                                                        EVRApplicationError>,
    pub GetDefaultApplicationForMimeType: ::std::option::Option<unsafe extern "C" fn(pchMimeType:
                                                                                         *mut ::std::os::raw::c_char,
                                                                                     pchAppKeyBuffer:
                                                                                         *mut ::std::os::raw::c_char,
                                                                                     unAppKeyBufferLen:
                                                                                         u32)
                                                                    -> bool>,
    pub GetApplicationSupportedMimeTypes: ::std::option::Option<unsafe extern "C" fn(pchAppKey:
                                                                                         *mut ::std::os::raw::c_char,
                                                                                     pchMimeTypesBuffer:
                                                                                         *mut ::std::os::raw::c_char,
                                                                                     unMimeTypesBuffer:
                                                                                         u32)
                                                                    -> bool>,
    pub GetApplicationsThatSupportMimeType: ::std::option::Option<unsafe extern "C" fn(pchMimeType:
                                                                                           *mut ::std::os::raw::c_char,
                                                                                       pchAppKeysThatSupportBuffer:
                                                                                           *mut ::std::os::raw::c_char,
                                                                                       unAppKeysThatSupportBuffer:
                                                                                           u32)
                                                                      ->
                                                                          ::std::os::raw::c_uint>,
    pub GetApplicationLaunchArguments: ::std::option::Option<unsafe extern "C" fn(unHandle:
                                                                                      u32,
                                                                                  pchArgs:
                                                                                      *mut ::std::os::raw::c_char,
                                                                                  unArgs:
                                                                                      u32)
                                                                 ->
                                                                     ::std::os::raw::c_uint>,
    pub GetStartingApplication: ::std::option::Option<unsafe extern "C" fn(pchAppKeyBuffer:
                                                                               *mut ::std::os::raw::c_char,
                                                                           unAppKeyBufferLen:
                                                                               u32)
                                                          ->
                                                              EVRApplicationError>,
    pub GetTransitionState: ::std::option::Option<unsafe extern "C" fn()
                                                      ->
                                                          EVRApplicationTransitionState>,
    pub PerformApplicationPrelaunchCheck: ::std::option::Option<unsafe extern "C" fn(pchAppKey:
                                                                                         *mut ::std::os::raw::c_char)
                                                                    ->
                                                                        EVRApplicationError>,
    pub GetApplicationsTransitionStateNameFromEnum: ::std::option::Option<unsafe extern "C" fn(state:
                                                                                                   EVRApplicationTransitionState)
                                                                              ->
                                                                                  *mut ::std::os::raw::c_char>,
    pub IsQuitUserPromptRequested: ::std::option::Option<unsafe extern "C" fn()
                                                             -> bool>,
    pub LaunchInternalProcess: ::std::option::Option<unsafe extern "C" fn(pchBinaryPath:
                                                                              *mut ::std::os::raw::c_char,
                                                                          pchArguments:
                                                                              *mut ::std::os::raw::c_char,
                                                                          pchWorkingDirectory:
                                                                              *mut ::std::os::raw::c_char)
                                                         ->
                                                             EVRApplicationError>,
}
#[test]
fn bindgen_test_layout_VR_IVRApplications_FnTable() {
    assert_eq!(::std::mem::size_of::<VR_IVRApplications_FnTable>() ,
               240usize);
    assert_eq!(::std::mem::align_of::<VR_IVRApplications_FnTable>() , 8usize);
}
impl Clone for VR_IVRApplications_FnTable {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VR_IVRChaperone_FnTable {
    pub GetCalibrationState: ::std::option::Option<unsafe extern "C" fn()
                                                       ->
                                                           ChaperoneCalibrationState>,
    pub GetPlayAreaSize: ::std::option::Option<unsafe extern "C" fn(pSizeX:
                                                                        *mut f32,
                                                                    pSizeZ:
                                                                        *mut f32)
                                                   -> bool>,
    pub GetPlayAreaRect: ::std::option::Option<unsafe extern "C" fn(rect:
                                                                        *mut HmdQuad_t)
                                                   -> bool>,
    pub ReloadInfo: ::std::option::Option<unsafe extern "C" fn()>,
    pub SetSceneColor: ::std::option::Option<unsafe extern "C" fn(color:
                                                                      HmdColor_t)>,
    pub GetBoundsColor: ::std::option::Option<unsafe extern "C" fn(pOutputColorArray:
                                                                       *mut HmdColor_t,
                                                                   nNumOutputColors:
                                                                       ::std::os::raw::c_int,
                                                                   flCollisionBoundsFadeDistance:
                                                                       f32,
                                                                   pOutputCameraColor:
                                                                       *mut HmdColor_t)>,
    pub AreBoundsVisible: ::std::option::Option<unsafe extern "C" fn()
                                                    -> bool>,
    pub ForceBoundsVisible: ::std::option::Option<unsafe extern "C" fn(bForce:
                                                                           bool)>,
}
#[test]
fn bindgen_test_layout_VR_IVRChaperone_FnTable() {
    assert_eq!(::std::mem::size_of::<VR_IVRChaperone_FnTable>() , 64usize);
    assert_eq!(::std::mem::align_of::<VR_IVRChaperone_FnTable>() , 8usize);
}
impl Clone for VR_IVRChaperone_FnTable {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VR_IVRChaperoneSetup_FnTable {
    pub CommitWorkingCopy: ::std::option::Option<unsafe extern "C" fn(configFile:
                                                                          EChaperoneConfigFile)
                                                     -> bool>,
    pub RevertWorkingCopy: ::std::option::Option<unsafe extern "C" fn()>,
    pub GetWorkingPlayAreaSize: ::std::option::Option<unsafe extern "C" fn(pSizeX:
                                                                               *mut f32,
                                                                           pSizeZ:
                                                                               *mut f32)
                                                          -> bool>,
    pub GetWorkingPlayAreaRect: ::std::option::Option<unsafe extern "C" fn(rect:
                                                                               *mut HmdQuad_t)
                                                          -> bool>,
    pub GetWorkingCollisionBoundsInfo: ::std::option::Option<unsafe extern "C" fn(pQuadsBuffer:
                                                                                      *mut HmdQuad_t,
                                                                                  punQuadsCount:
                                                                                      *mut u32)
                                                                 -> bool>,
    pub GetLiveCollisionBoundsInfo: ::std::option::Option<unsafe extern "C" fn(pQuadsBuffer:
                                                                                   *mut HmdQuad_t,
                                                                               punQuadsCount:
                                                                                   *mut u32)
                                                              -> bool>,
    pub GetWorkingSeatedZeroPoseToRawTrackingPose: ::std::option::Option<unsafe extern "C" fn(pmatSeatedZeroPoseToRawTrackingPose:
                                                                                                  *mut HmdMatrix34_t)
                                                                             ->
                                                                                 bool>,
    pub GetWorkingStandingZeroPoseToRawTrackingPose: ::std::option::Option<unsafe extern "C" fn(pmatStandingZeroPoseToRawTrackingPose:
                                                                                                    *mut HmdMatrix34_t)
                                                                               ->
                                                                                   bool>,
    pub SetWorkingPlayAreaSize: ::std::option::Option<unsafe extern "C" fn(sizeX:
                                                                               f32,
                                                                           sizeZ:
                                                                               f32)>,
    pub SetWorkingCollisionBoundsInfo: ::std::option::Option<unsafe extern "C" fn(pQuadsBuffer:
                                                                                      *mut HmdQuad_t,
                                                                                  unQuadsCount:
                                                                                      u32)>,
    pub SetWorkingSeatedZeroPoseToRawTrackingPose: ::std::option::Option<unsafe extern "C" fn(pMatSeatedZeroPoseToRawTrackingPose:
                                                                                                  *mut HmdMatrix34_t)>,
    pub SetWorkingStandingZeroPoseToRawTrackingPose: ::std::option::Option<unsafe extern "C" fn(pMatStandingZeroPoseToRawTrackingPose:
                                                                                                    *mut HmdMatrix34_t)>,
    pub ReloadFromDisk: ::std::option::Option<unsafe extern "C" fn(configFile:
                                                                       EChaperoneConfigFile)>,
    pub GetLiveSeatedZeroPoseToRawTrackingPose: ::std::option::Option<unsafe extern "C" fn(pmatSeatedZeroPoseToRawTrackingPose:
                                                                                               *mut HmdMatrix34_t)
                                                                          ->
                                                                              bool>,
    pub SetWorkingCollisionBoundsTagsInfo: ::std::option::Option<unsafe extern "C" fn(pTagsBuffer:
                                                                                          *mut u8,
                                                                                      unTagCount:
                                                                                          u32)>,
    pub GetLiveCollisionBoundsTagsInfo: ::std::option::Option<unsafe extern "C" fn(pTagsBuffer:
                                                                                       *mut u8,
                                                                                   punTagCount:
                                                                                       *mut u32)
                                                                  -> bool>,
    pub SetWorkingPhysicalBoundsInfo: ::std::option::Option<unsafe extern "C" fn(pQuadsBuffer:
                                                                                     *mut HmdQuad_t,
                                                                                 unQuadsCount:
                                                                                     u32)
                                                                -> bool>,
    pub GetLivePhysicalBoundsInfo: ::std::option::Option<unsafe extern "C" fn(pQuadsBuffer:
                                                                                  *mut HmdQuad_t,
                                                                              punQuadsCount:
                                                                                  *mut u32)
                                                             -> bool>,
    pub ExportLiveToBuffer: ::std::option::Option<unsafe extern "C" fn(pBuffer:
                                                                           *mut ::std::os::raw::c_char,
                                                                       pnBufferLength:
                                                                           *mut u32)
                                                      -> bool>,
    pub ImportFromBufferToWorking: ::std::option::Option<unsafe extern "C" fn(pBuffer:
                                                                                  *mut ::std::os::raw::c_char,
                                                                              nImportFlags:
                                                                                  u32)
                                                             -> bool>,
}
#[test]
fn bindgen_test_layout_VR_IVRChaperoneSetup_FnTable() {
    assert_eq!(::std::mem::size_of::<VR_IVRChaperoneSetup_FnTable>() ,
               160usize);
    assert_eq!(::std::mem::align_of::<VR_IVRChaperoneSetup_FnTable>() ,
               8usize);
}
impl Clone for VR_IVRChaperoneSetup_FnTable {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VR_IVRCompositor_FnTable {
    pub SetTrackingSpace: ::std::option::Option<unsafe extern "C" fn(eOrigin:
                                                                         ETrackingUniverseOrigin)>,
    pub GetTrackingSpace: ::std::option::Option<unsafe extern "C" fn()
                                                    ->
                                                        ETrackingUniverseOrigin>,
    pub WaitGetPoses: ::std::option::Option<unsafe extern "C" fn(pRenderPoseArray:
                                                                     *mut TrackedDevicePose_t,
                                                                 unRenderPoseArrayCount:
                                                                     u32,
                                                                 pGamePoseArray:
                                                                     *mut TrackedDevicePose_t,
                                                                 unGamePoseArrayCount:
                                                                     u32)
                                                -> EVRCompositorError>,
    pub GetLastPoses: ::std::option::Option<unsafe extern "C" fn(pRenderPoseArray:
                                                                     *mut TrackedDevicePose_t,
                                                                 unRenderPoseArrayCount:
                                                                     u32,
                                                                 pGamePoseArray:
                                                                     *mut TrackedDevicePose_t,
                                                                 unGamePoseArrayCount:
                                                                     u32)
                                                -> EVRCompositorError>,
    pub GetLastPoseForTrackedDeviceIndex: ::std::option::Option<unsafe extern "C" fn(unDeviceIndex:
                                                                                         TrackedDeviceIndex_t,
                                                                                     pOutputPose:
                                                                                         *mut TrackedDevicePose_t,
                                                                                     pOutputGamePose:
                                                                                         *mut TrackedDevicePose_t)
                                                                    ->
                                                                        EVRCompositorError>,
    pub Submit: ::std::option::Option<unsafe extern "C" fn(eEye: EVREye,
                                                           pTexture:
                                                               *mut Texture_t,
                                                           pBounds:
                                                               *mut VRTextureBounds_t,
                                                           nSubmitFlags:
                                                               EVRSubmitFlags)
                                          -> EVRCompositorError>,
    pub ClearLastSubmittedFrame: ::std::option::Option<unsafe extern "C" fn()>,
    pub PostPresentHandoff: ::std::option::Option<unsafe extern "C" fn()>,
    pub GetFrameTiming: ::std::option::Option<unsafe extern "C" fn(pTiming:
                                                                       *mut Compositor_FrameTiming,
                                                                   unFramesAgo:
                                                                       u32)
                                                  -> bool>,
    pub GetFrameTimings: ::std::option::Option<unsafe extern "C" fn(pTiming:
                                                                        *mut Compositor_FrameTiming,
                                                                    nFrames:
                                                                        u32)
                                                   -> ::std::os::raw::c_uint>,
    pub GetFrameTimeRemaining: ::std::option::Option<unsafe extern "C" fn()
                                                         -> f32>,
    pub GetCumulativeStats: ::std::option::Option<unsafe extern "C" fn(pStats:
                                                                           *mut Compositor_CumulativeStats,
                                                                       nStatsSizeInBytes:
                                                                           u32)>,
    pub FadeToColor: ::std::option::Option<unsafe extern "C" fn(fSeconds: f32,
                                                                fRed: f32,
                                                                fGreen: f32,
                                                                fBlue: f32,
                                                                fAlpha: f32,
                                                                bBackground:
                                                                    bool)>,
    pub GetCurrentFadeColor: ::std::option::Option<unsafe extern "C" fn(bBackground:
                                                                            bool)
                                                       -> HmdColor_t>,
    pub FadeGrid: ::std::option::Option<unsafe extern "C" fn(fSeconds: f32,
                                                             bFadeIn: bool)>,
    pub GetCurrentGridAlpha: ::std::option::Option<unsafe extern "C" fn()
                                                       -> f32>,
    pub SetSkyboxOverride: ::std::option::Option<unsafe extern "C" fn(pTextures:
                                                                          *mut Texture_t,
                                                                      unTextureCount:
                                                                          u32)
                                                     -> EVRCompositorError>,
    pub ClearSkyboxOverride: ::std::option::Option<unsafe extern "C" fn()>,
    pub CompositorBringToFront: ::std::option::Option<unsafe extern "C" fn()>,
    pub CompositorGoToBack: ::std::option::Option<unsafe extern "C" fn()>,
    pub CompositorQuit: ::std::option::Option<unsafe extern "C" fn()>,
    pub IsFullscreen: ::std::option::Option<unsafe extern "C" fn() -> bool>,
    pub GetCurrentSceneFocusProcess: ::std::option::Option<unsafe extern "C" fn()
                                                               ->
                                                                   ::std::os::raw::c_uint>,
    pub GetLastFrameRenderer: ::std::option::Option<unsafe extern "C" fn()
                                                        ->
                                                            ::std::os::raw::c_uint>,
    pub CanRenderScene: ::std::option::Option<unsafe extern "C" fn() -> bool>,
    pub ShowMirrorWindow: ::std::option::Option<unsafe extern "C" fn()>,
    pub HideMirrorWindow: ::std::option::Option<unsafe extern "C" fn()>,
    pub IsMirrorWindowVisible: ::std::option::Option<unsafe extern "C" fn()
                                                         -> bool>,
    pub CompositorDumpImages: ::std::option::Option<unsafe extern "C" fn()>,
    pub ShouldAppRenderWithLowResources: ::std::option::Option<unsafe extern "C" fn()
                                                                   -> bool>,
    pub ForceInterleavedReprojectionOn: ::std::option::Option<unsafe extern "C" fn(bOverride:
                                                                                       bool)>,
    pub ForceReconnectProcess: ::std::option::Option<unsafe extern "C" fn()>,
    pub SuspendRendering: ::std::option::Option<unsafe extern "C" fn(bSuspend:
                                                                         bool)>,
    pub GetMirrorTextureD3D11: ::std::option::Option<unsafe extern "C" fn(eEye:
                                                                              EVREye,
                                                                          pD3D11DeviceOrResource:
                                                                              *mut ::std::os::raw::c_void,
                                                                          ppD3D11ShaderResourceView:
                                                                              *mut *mut ::std::os::raw::c_void)
                                                         ->
                                                             EVRCompositorError>,
    pub GetMirrorTextureGL: ::std::option::Option<unsafe extern "C" fn(eEye:
                                                                           EVREye,
                                                                       pglTextureId:
                                                                           *mut glUInt_t,
                                                                       pglSharedTextureHandle:
                                                                           *mut glSharedTextureHandle_t)
                                                      -> EVRCompositorError>,
    pub ReleaseSharedGLTexture: ::std::option::Option<unsafe extern "C" fn(glTextureId:
                                                                               glUInt_t,
                                                                           glSharedTextureHandle:
                                                                               glSharedTextureHandle_t)
                                                          -> bool>,
    pub LockGLSharedTextureForAccess: ::std::option::Option<unsafe extern "C" fn(glSharedTextureHandle:
                                                                                     glSharedTextureHandle_t)>,
    pub UnlockGLSharedTextureForAccess: ::std::option::Option<unsafe extern "C" fn(glSharedTextureHandle:
                                                                                       glSharedTextureHandle_t)>,
}
#[test]
fn bindgen_test_layout_VR_IVRCompositor_FnTable() {
    assert_eq!(::std::mem::size_of::<VR_IVRCompositor_FnTable>() , 304usize);
    assert_eq!(::std::mem::align_of::<VR_IVRCompositor_FnTable>() , 8usize);
}
impl Clone for VR_IVRCompositor_FnTable {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VR_IVROverlay_FnTable {
    pub FindOverlay: ::std::option::Option<unsafe extern "C" fn(pchOverlayKey:
                                                                    *mut ::std::os::raw::c_char,
                                                                pOverlayHandle:
                                                                    *mut VROverlayHandle_t)
                                               -> EVROverlayError>,
    pub CreateOverlay: ::std::option::Option<unsafe extern "C" fn(pchOverlayKey:
                                                                      *mut ::std::os::raw::c_char,
                                                                  pchOverlayFriendlyName:
                                                                      *mut ::std::os::raw::c_char,
                                                                  pOverlayHandle:
                                                                      *mut VROverlayHandle_t)
                                                 -> EVROverlayError>,
    pub DestroyOverlay: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                       VROverlayHandle_t)
                                                  -> EVROverlayError>,
    pub SetHighQualityOverlay: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                              VROverlayHandle_t)
                                                         -> EVROverlayError>,
    pub GetHighQualityOverlay: ::std::option::Option<unsafe extern "C" fn()
                                                         ->
                                                             ::std::os::raw::c_ulonglong>,
    pub GetOverlayKey: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                      VROverlayHandle_t,
                                                                  pchValue:
                                                                      *mut ::std::os::raw::c_char,
                                                                  unBufferSize:
                                                                      u32,
                                                                  pError:
                                                                      *mut EVROverlayError)
                                                 -> ::std::os::raw::c_uint>,
    pub GetOverlayName: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                       VROverlayHandle_t,
                                                                   pchValue:
                                                                       *mut ::std::os::raw::c_char,
                                                                   unBufferSize:
                                                                       u32,
                                                                   pError:
                                                                       *mut EVROverlayError)
                                                  -> ::std::os::raw::c_uint>,
    pub GetOverlayImageData: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                            VROverlayHandle_t,
                                                                        pvBuffer:
                                                                            *mut ::std::os::raw::c_void,
                                                                        unBufferSize:
                                                                            u32,
                                                                        punWidth:
                                                                            *mut u32,
                                                                        punHeight:
                                                                            *mut u32)
                                                       -> EVROverlayError>,
    pub GetOverlayErrorNameFromEnum: ::std::option::Option<unsafe extern "C" fn(error:
                                                                                    EVROverlayError)
                                                               ->
                                                                   *mut ::std::os::raw::c_char>,
    pub SetOverlayRenderingPid: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                               VROverlayHandle_t,
                                                                           unPID:
                                                                               u32)
                                                          -> EVROverlayError>,
    pub GetOverlayRenderingPid: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                               VROverlayHandle_t)
                                                          ->
                                                              ::std::os::raw::c_uint>,
    pub SetOverlayFlag: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                       VROverlayHandle_t,
                                                                   eOverlayFlag:
                                                                       VROverlayFlags,
                                                                   bEnabled:
                                                                       bool)
                                                  -> EVROverlayError>,
    pub GetOverlayFlag: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                       VROverlayHandle_t,
                                                                   eOverlayFlag:
                                                                       VROverlayFlags,
                                                                   pbEnabled:
                                                                       *mut bool)
                                                  -> EVROverlayError>,
    pub SetOverlayColor: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                        VROverlayHandle_t,
                                                                    fRed: f32,
                                                                    fGreen:
                                                                        f32,
                                                                    fBlue:
                                                                        f32)
                                                   -> EVROverlayError>,
    pub GetOverlayColor: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                        VROverlayHandle_t,
                                                                    pfRed:
                                                                        *mut f32,
                                                                    pfGreen:
                                                                        *mut f32,
                                                                    pfBlue:
                                                                        *mut f32)
                                                   -> EVROverlayError>,
    pub SetOverlayAlpha: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                        VROverlayHandle_t,
                                                                    fAlpha:
                                                                        f32)
                                                   -> EVROverlayError>,
    pub GetOverlayAlpha: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                        VROverlayHandle_t,
                                                                    pfAlpha:
                                                                        *mut f32)
                                                   -> EVROverlayError>,
    pub SetOverlayTexelAspect: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                              VROverlayHandle_t,
                                                                          fTexelAspect:
                                                                              f32)
                                                         -> EVROverlayError>,
    pub GetOverlayTexelAspect: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                              VROverlayHandle_t,
                                                                          pfTexelAspect:
                                                                              *mut f32)
                                                         -> EVROverlayError>,
    pub SetOverlaySortOrder: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                            VROverlayHandle_t,
                                                                        unSortOrder:
                                                                            u32)
                                                       -> EVROverlayError>,
    pub GetOverlaySortOrder: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                            VROverlayHandle_t,
                                                                        punSortOrder:
                                                                            *mut u32)
                                                       -> EVROverlayError>,
    pub SetOverlayWidthInMeters: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                VROverlayHandle_t,
                                                                            fWidthInMeters:
                                                                                f32)
                                                           ->
                                                               EVROverlayError>,
    pub GetOverlayWidthInMeters: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                VROverlayHandle_t,
                                                                            pfWidthInMeters:
                                                                                *mut f32)
                                                           ->
                                                               EVROverlayError>,
    pub SetOverlayAutoCurveDistanceRangeInMeters: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                                 VROverlayHandle_t,
                                                                                             fMinDistanceInMeters:
                                                                                                 f32,
                                                                                             fMaxDistanceInMeters:
                                                                                                 f32)
                                                                            ->
                                                                                EVROverlayError>,
    pub GetOverlayAutoCurveDistanceRangeInMeters: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                                 VROverlayHandle_t,
                                                                                             pfMinDistanceInMeters:
                                                                                                 *mut f32,
                                                                                             pfMaxDistanceInMeters:
                                                                                                 *mut f32)
                                                                            ->
                                                                                EVROverlayError>,
    pub SetOverlayTextureColorSpace: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                    VROverlayHandle_t,
                                                                                eTextureColorSpace:
                                                                                    EColorSpace)
                                                               ->
                                                                   EVROverlayError>,
    pub GetOverlayTextureColorSpace: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                    VROverlayHandle_t,
                                                                                peTextureColorSpace:
                                                                                    *mut EColorSpace)
                                                               ->
                                                                   EVROverlayError>,
    pub SetOverlayTextureBounds: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                VROverlayHandle_t,
                                                                            pOverlayTextureBounds:
                                                                                *mut VRTextureBounds_t)
                                                           ->
                                                               EVROverlayError>,
    pub GetOverlayTextureBounds: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                VROverlayHandle_t,
                                                                            pOverlayTextureBounds:
                                                                                *mut VRTextureBounds_t)
                                                           ->
                                                               EVROverlayError>,
    pub GetOverlayTransformType: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                VROverlayHandle_t,
                                                                            peTransformType:
                                                                                *mut VROverlayTransformType)
                                                           ->
                                                               EVROverlayError>,
    pub SetOverlayTransformAbsolute: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                    VROverlayHandle_t,
                                                                                eTrackingOrigin:
                                                                                    ETrackingUniverseOrigin,
                                                                                pmatTrackingOriginToOverlayTransform:
                                                                                    *mut HmdMatrix34_t)
                                                               ->
                                                                   EVROverlayError>,
    pub GetOverlayTransformAbsolute: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                    VROverlayHandle_t,
                                                                                peTrackingOrigin:
                                                                                    *mut ETrackingUniverseOrigin,
                                                                                pmatTrackingOriginToOverlayTransform:
                                                                                    *mut HmdMatrix34_t)
                                                               ->
                                                                   EVROverlayError>,
    pub SetOverlayTransformTrackedDeviceRelative: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                                 VROverlayHandle_t,
                                                                                             unTrackedDevice:
                                                                                                 TrackedDeviceIndex_t,
                                                                                             pmatTrackedDeviceToOverlayTransform:
                                                                                                 *mut HmdMatrix34_t)
                                                                            ->
                                                                                EVROverlayError>,
    pub GetOverlayTransformTrackedDeviceRelative: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                                 VROverlayHandle_t,
                                                                                             punTrackedDevice:
                                                                                                 *mut TrackedDeviceIndex_t,
                                                                                             pmatTrackedDeviceToOverlayTransform:
                                                                                                 *mut HmdMatrix34_t)
                                                                            ->
                                                                                EVROverlayError>,
    pub SetOverlayTransformTrackedDeviceComponent: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                                  VROverlayHandle_t,
                                                                                              unDeviceIndex:
                                                                                                  TrackedDeviceIndex_t,
                                                                                              pchComponentName:
                                                                                                  *mut ::std::os::raw::c_char)
                                                                             ->
                                                                                 EVROverlayError>,
    pub GetOverlayTransformTrackedDeviceComponent: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                                  VROverlayHandle_t,
                                                                                              punDeviceIndex:
                                                                                                  *mut TrackedDeviceIndex_t,
                                                                                              pchComponentName:
                                                                                                  *mut ::std::os::raw::c_char,
                                                                                              unComponentNameSize:
                                                                                                  u32)
                                                                             ->
                                                                                 EVROverlayError>,
    pub ShowOverlay: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                    VROverlayHandle_t)
                                               -> EVROverlayError>,
    pub HideOverlay: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                    VROverlayHandle_t)
                                               -> EVROverlayError>,
    pub IsOverlayVisible: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                         VROverlayHandle_t)
                                                    -> bool>,
    pub GetTransformForOverlayCoordinates: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                          VROverlayHandle_t,
                                                                                      eTrackingOrigin:
                                                                                          ETrackingUniverseOrigin,
                                                                                      coordinatesInOverlay:
                                                                                          HmdVector2_t,
                                                                                      pmatTransform:
                                                                                          *mut HmdMatrix34_t)
                                                                     ->
                                                                         EVROverlayError>,
    pub PollNextOverlayEvent: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                             VROverlayHandle_t,
                                                                         pEvent:
                                                                             *mut VREvent_t,
                                                                         uncbVREvent:
                                                                             u32)
                                                        -> bool>,
    pub GetOverlayInputMethod: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                              VROverlayHandle_t,
                                                                          peInputMethod:
                                                                              *mut VROverlayInputMethod)
                                                         -> EVROverlayError>,
    pub SetOverlayInputMethod: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                              VROverlayHandle_t,
                                                                          eInputMethod:
                                                                              VROverlayInputMethod)
                                                         -> EVROverlayError>,
    pub GetOverlayMouseScale: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                             VROverlayHandle_t,
                                                                         pvecMouseScale:
                                                                             *mut HmdVector2_t)
                                                        -> EVROverlayError>,
    pub SetOverlayMouseScale: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                             VROverlayHandle_t,
                                                                         pvecMouseScale:
                                                                             *mut HmdVector2_t)
                                                        -> EVROverlayError>,
    pub ComputeOverlayIntersection: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                   VROverlayHandle_t,
                                                                               pParams:
                                                                                   *mut VROverlayIntersectionParams_t,
                                                                               pResults:
                                                                                   *mut VROverlayIntersectionResults_t)
                                                              -> bool>,
    pub HandleControllerOverlayInteractionAsMouse: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                                  VROverlayHandle_t,
                                                                                              unControllerDeviceIndex:
                                                                                                  TrackedDeviceIndex_t)
                                                                             ->
                                                                                 bool>,
    pub IsHoverTargetOverlay: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                             VROverlayHandle_t)
                                                        -> bool>,
    pub GetGamepadFocusOverlay: ::std::option::Option<unsafe extern "C" fn()
                                                          ->
                                                              ::std::os::raw::c_ulonglong>,
    pub SetGamepadFocusOverlay: ::std::option::Option<unsafe extern "C" fn(ulNewFocusOverlay:
                                                                               VROverlayHandle_t)
                                                          -> EVROverlayError>,
    pub SetOverlayNeighbor: ::std::option::Option<unsafe extern "C" fn(eDirection:
                                                                           EOverlayDirection,
                                                                       ulFrom:
                                                                           VROverlayHandle_t,
                                                                       ulTo:
                                                                           VROverlayHandle_t)
                                                      -> EVROverlayError>,
    pub MoveGamepadFocusToNeighbor: ::std::option::Option<unsafe extern "C" fn(eDirection:
                                                                                   EOverlayDirection,
                                                                               ulFrom:
                                                                                   VROverlayHandle_t)
                                                              ->
                                                                  EVROverlayError>,
    pub SetOverlayTexture: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                          VROverlayHandle_t,
                                                                      pTexture:
                                                                          *mut Texture_t)
                                                     -> EVROverlayError>,
    pub ClearOverlayTexture: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                            VROverlayHandle_t)
                                                       -> EVROverlayError>,
    pub SetOverlayRaw: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                      VROverlayHandle_t,
                                                                  pvBuffer:
                                                                      *mut ::std::os::raw::c_void,
                                                                  unWidth:
                                                                      u32,
                                                                  unHeight:
                                                                      u32,
                                                                  unDepth:
                                                                      u32)
                                                 -> EVROverlayError>,
    pub SetOverlayFromFile: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                           VROverlayHandle_t,
                                                                       pchFilePath:
                                                                           *mut ::std::os::raw::c_char)
                                                      -> EVROverlayError>,
    pub GetOverlayTexture: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                          VROverlayHandle_t,
                                                                      pNativeTextureHandle:
                                                                          *mut *mut ::std::os::raw::c_void,
                                                                      pNativeTextureRef:
                                                                          *mut ::std::os::raw::c_void,
                                                                      pWidth:
                                                                          *mut u32,
                                                                      pHeight:
                                                                          *mut u32,
                                                                      pNativeFormat:
                                                                          *mut u32,
                                                                      pAPI:
                                                                          *mut EGraphicsAPIConvention,
                                                                      pColorSpace:
                                                                          *mut EColorSpace)
                                                     -> EVROverlayError>,
    pub ReleaseNativeOverlayHandle: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                   VROverlayHandle_t,
                                                                               pNativeTextureHandle:
                                                                                   *mut ::std::os::raw::c_void)
                                                              ->
                                                                  EVROverlayError>,
    pub GetOverlayTextureSize: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                              VROverlayHandle_t,
                                                                          pWidth:
                                                                              *mut u32,
                                                                          pHeight:
                                                                              *mut u32)
                                                         -> EVROverlayError>,
    pub CreateDashboardOverlay: ::std::option::Option<unsafe extern "C" fn(pchOverlayKey:
                                                                               *mut ::std::os::raw::c_char,
                                                                           pchOverlayFriendlyName:
                                                                               *mut ::std::os::raw::c_char,
                                                                           pMainHandle:
                                                                               *mut VROverlayHandle_t,
                                                                           pThumbnailHandle:
                                                                               *mut VROverlayHandle_t)
                                                          -> EVROverlayError>,
    pub IsDashboardVisible: ::std::option::Option<unsafe extern "C" fn()
                                                      -> bool>,
    pub IsActiveDashboardOverlay: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                 VROverlayHandle_t)
                                                            -> bool>,
    pub SetDashboardOverlaySceneProcess: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                        VROverlayHandle_t,
                                                                                    unProcessId:
                                                                                        u32)
                                                                   ->
                                                                       EVROverlayError>,
    pub GetDashboardOverlaySceneProcess: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                        VROverlayHandle_t,
                                                                                    punProcessId:
                                                                                        *mut u32)
                                                                   ->
                                                                       EVROverlayError>,
    pub ShowDashboard: ::std::option::Option<unsafe extern "C" fn(pchOverlayToShow:
                                                                      *mut ::std::os::raw::c_char)>,
    pub GetPrimaryDashboardDevice: ::std::option::Option<unsafe extern "C" fn()
                                                             ->
                                                                 ::std::os::raw::c_uint>,
    pub ShowKeyboard: ::std::option::Option<unsafe extern "C" fn(eInputMode:
                                                                     EGamepadTextInputMode,
                                                                 eLineInputMode:
                                                                     EGamepadTextInputLineMode,
                                                                 pchDescription:
                                                                     *mut ::std::os::raw::c_char,
                                                                 unCharMax:
                                                                     u32,
                                                                 pchExistingText:
                                                                     *mut ::std::os::raw::c_char,
                                                                 bUseMinimalMode:
                                                                     bool,
                                                                 uUserValue:
                                                                     u64)
                                                -> EVROverlayError>,
    pub ShowKeyboardForOverlay: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                               VROverlayHandle_t,
                                                                           eInputMode:
                                                                               EGamepadTextInputMode,
                                                                           eLineInputMode:
                                                                               EGamepadTextInputLineMode,
                                                                           pchDescription:
                                                                               *mut ::std::os::raw::c_char,
                                                                           unCharMax:
                                                                               u32,
                                                                           pchExistingText:
                                                                               *mut ::std::os::raw::c_char,
                                                                           bUseMinimalMode:
                                                                               bool,
                                                                           uUserValue:
                                                                               u64)
                                                          -> EVROverlayError>,
    pub GetKeyboardText: ::std::option::Option<unsafe extern "C" fn(pchText:
                                                                        *mut ::std::os::raw::c_char,
                                                                    cchText:
                                                                        u32)
                                                   -> ::std::os::raw::c_uint>,
    pub HideKeyboard: ::std::option::Option<unsafe extern "C" fn()>,
    pub SetKeyboardTransformAbsolute: ::std::option::Option<unsafe extern "C" fn(eTrackingOrigin:
                                                                                     ETrackingUniverseOrigin,
                                                                                 pmatTrackingOriginToKeyboardTransform:
                                                                                     *mut HmdMatrix34_t)>,
    pub SetKeyboardPositionForOverlay: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                      VROverlayHandle_t,
                                                                                  avoidRect:
                                                                                      HmdRect2_t)>,
    pub SetOverlayIntersectionMask: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                                   VROverlayHandle_t,
                                                                               pMaskPrimitives:
                                                                                   *mut VROverlayIntersectionMaskPrimitive_t,
                                                                               unNumMaskPrimitives:
                                                                                   u32,
                                                                               unPrimitiveSize:
                                                                                   u32)
                                                              ->
                                                                  EVROverlayError>,
}
#[test]
fn bindgen_test_layout_VR_IVROverlay_FnTable() {
    assert_eq!(::std::mem::size_of::<VR_IVROverlay_FnTable>() , 584usize);
    assert_eq!(::std::mem::align_of::<VR_IVROverlay_FnTable>() , 8usize);
}
impl Clone for VR_IVROverlay_FnTable {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VR_IVRRenderModels_FnTable {
    pub LoadRenderModel_Async: ::std::option::Option<unsafe extern "C" fn(pchRenderModelName:
                                                                              *mut ::std::os::raw::c_char,
                                                                          ppRenderModel:
                                                                              *mut *mut RenderModel_t)
                                                         ->
                                                             EVRRenderModelError>,
    pub FreeRenderModel: ::std::option::Option<unsafe extern "C" fn(pRenderModel:
                                                                        *mut RenderModel_t)>,
    pub LoadTexture_Async: ::std::option::Option<unsafe extern "C" fn(textureId:
                                                                          TextureID_t,
                                                                      ppTexture:
                                                                          *mut *mut RenderModel_TextureMap_t)
                                                     -> EVRRenderModelError>,
    pub FreeTexture: ::std::option::Option<unsafe extern "C" fn(pTexture:
                                                                    *mut RenderModel_TextureMap_t)>,
    pub LoadTextureD3D11_Async: ::std::option::Option<unsafe extern "C" fn(textureId:
                                                                               TextureID_t,
                                                                           pD3D11Device:
                                                                               *mut ::std::os::raw::c_void,
                                                                           ppD3D11Texture2D:
                                                                               *mut *mut ::std::os::raw::c_void)
                                                          ->
                                                              EVRRenderModelError>,
    pub LoadIntoTextureD3D11_Async: ::std::option::Option<unsafe extern "C" fn(textureId:
                                                                                   TextureID_t,
                                                                               pDstTexture:
                                                                                   *mut ::std::os::raw::c_void)
                                                              ->
                                                                  EVRRenderModelError>,
    pub FreeTextureD3D11: ::std::option::Option<unsafe extern "C" fn(pD3D11Texture2D:
                                                                         *mut ::std::os::raw::c_void)>,
    pub GetRenderModelName: ::std::option::Option<unsafe extern "C" fn(unRenderModelIndex:
                                                                           u32,
                                                                       pchRenderModelName:
                                                                           *mut ::std::os::raw::c_char,
                                                                       unRenderModelNameLen:
                                                                           u32)
                                                      ->
                                                          ::std::os::raw::c_uint>,
    pub GetRenderModelCount: ::std::option::Option<unsafe extern "C" fn()
                                                       ->
                                                           ::std::os::raw::c_uint>,
    pub GetComponentCount: ::std::option::Option<unsafe extern "C" fn(pchRenderModelName:
                                                                          *mut ::std::os::raw::c_char)
                                                     ->
                                                         ::std::os::raw::c_uint>,
    pub GetComponentName: ::std::option::Option<unsafe extern "C" fn(pchRenderModelName:
                                                                         *mut ::std::os::raw::c_char,
                                                                     unComponentIndex:
                                                                         u32,
                                                                     pchComponentName:
                                                                         *mut ::std::os::raw::c_char,
                                                                     unComponentNameLen:
                                                                         u32)
                                                    ->
                                                        ::std::os::raw::c_uint>,
    pub GetComponentButtonMask: ::std::option::Option<unsafe extern "C" fn(pchRenderModelName:
                                                                               *mut ::std::os::raw::c_char,
                                                                           pchComponentName:
                                                                               *mut ::std::os::raw::c_char)
                                                          ->
                                                              ::std::os::raw::c_ulonglong>,
    pub GetComponentRenderModelName: ::std::option::Option<unsafe extern "C" fn(pchRenderModelName:
                                                                                    *mut ::std::os::raw::c_char,
                                                                                pchComponentName:
                                                                                    *mut ::std::os::raw::c_char,
                                                                                pchComponentRenderModelName:
                                                                                    *mut ::std::os::raw::c_char,
                                                                                unComponentRenderModelNameLen:
                                                                                    u32)
                                                               ->
                                                                   ::std::os::raw::c_uint>,
    pub GetComponentState: ::std::option::Option<unsafe extern "C" fn(pchRenderModelName:
                                                                          *mut ::std::os::raw::c_char,
                                                                      pchComponentName:
                                                                          *mut ::std::os::raw::c_char,
                                                                      pControllerState:
                                                                          *mut VRControllerState_t,
                                                                      pState:
                                                                          *mut RenderModel_ControllerMode_State_t,
                                                                      pComponentState:
                                                                          *mut RenderModel_ComponentState_t)
                                                     -> bool>,
    pub RenderModelHasComponent: ::std::option::Option<unsafe extern "C" fn(pchRenderModelName:
                                                                                *mut ::std::os::raw::c_char,
                                                                            pchComponentName:
                                                                                *mut ::std::os::raw::c_char)
                                                           -> bool>,
    pub GetRenderModelThumbnailURL: ::std::option::Option<unsafe extern "C" fn(pchRenderModelName:
                                                                                   *mut ::std::os::raw::c_char,
                                                                               pchThumbnailURL:
                                                                                   *mut ::std::os::raw::c_char,
                                                                               unThumbnailURLLen:
                                                                                   u32,
                                                                               peError:
                                                                                   *mut EVRRenderModelError)
                                                              ->
                                                                  ::std::os::raw::c_uint>,
    pub GetRenderModelOriginalPath: ::std::option::Option<unsafe extern "C" fn(pchRenderModelName:
                                                                                   *mut ::std::os::raw::c_char,
                                                                               pchOriginalPath:
                                                                                   *mut ::std::os::raw::c_char,
                                                                               unOriginalPathLen:
                                                                                   u32,
                                                                               peError:
                                                                                   *mut EVRRenderModelError)
                                                              ->
                                                                  ::std::os::raw::c_uint>,
    pub GetRenderModelErrorNameFromEnum: ::std::option::Option<unsafe extern "C" fn(error:
                                                                                        EVRRenderModelError)
                                                                   ->
                                                                       *mut ::std::os::raw::c_char>,
}
#[test]
fn bindgen_test_layout_VR_IVRRenderModels_FnTable() {
    assert_eq!(::std::mem::size_of::<VR_IVRRenderModels_FnTable>() ,
               144usize);
    assert_eq!(::std::mem::align_of::<VR_IVRRenderModels_FnTable>() , 8usize);
}
impl Clone for VR_IVRRenderModels_FnTable {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VR_IVRNotifications_FnTable {
    pub CreateNotification: ::std::option::Option<unsafe extern "C" fn(ulOverlayHandle:
                                                                           VROverlayHandle_t,
                                                                       ulUserValue:
                                                                           u64,
                                                                       type_:
                                                                           EVRNotificationType,
                                                                       pchText:
                                                                           *mut ::std::os::raw::c_char,
                                                                       style:
                                                                           EVRNotificationStyle,
                                                                       pImage:
                                                                           *mut NotificationBitmap_t,
                                                                       pNotificationId:
                                                                           *mut VRNotificationId)
                                                      ->
                                                          EVRNotificationError>,
    pub RemoveNotification: ::std::option::Option<unsafe extern "C" fn(notificationId:
                                                                           VRNotificationId)
                                                      ->
                                                          EVRNotificationError>,
}
#[test]
fn bindgen_test_layout_VR_IVRNotifications_FnTable() {
    assert_eq!(::std::mem::size_of::<VR_IVRNotifications_FnTable>() ,
               16usize);
    assert_eq!(::std::mem::align_of::<VR_IVRNotifications_FnTable>() ,
               8usize);
}
impl Clone for VR_IVRNotifications_FnTable {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VR_IVRSettings_FnTable {
    pub GetSettingsErrorNameFromEnum: ::std::option::Option<unsafe extern "C" fn(eError:
                                                                                     EVRSettingsError)
                                                                ->
                                                                    *mut ::std::os::raw::c_char>,
    pub Sync: ::std::option::Option<unsafe extern "C" fn(bForce: bool,
                                                         peError:
                                                             *mut EVRSettingsError)
                                        -> bool>,
    pub SetBool: ::std::option::Option<unsafe extern "C" fn(pchSection:
                                                                *mut ::std::os::raw::c_char,
                                                            pchSettingsKey:
                                                                *mut ::std::os::raw::c_char,
                                                            bValue: bool,
                                                            peError:
                                                                *mut EVRSettingsError)>,
    pub SetInt32: ::std::option::Option<unsafe extern "C" fn(pchSection:
                                                                 *mut ::std::os::raw::c_char,
                                                             pchSettingsKey:
                                                                 *mut ::std::os::raw::c_char,
                                                             nValue: i32,
                                                             peError:
                                                                 *mut EVRSettingsError)>,
    pub SetFloat: ::std::option::Option<unsafe extern "C" fn(pchSection:
                                                                 *mut ::std::os::raw::c_char,
                                                             pchSettingsKey:
                                                                 *mut ::std::os::raw::c_char,
                                                             flValue: f32,
                                                             peError:
                                                                 *mut EVRSettingsError)>,
    pub SetString: ::std::option::Option<unsafe extern "C" fn(pchSection:
                                                                  *mut ::std::os::raw::c_char,
                                                              pchSettingsKey:
                                                                  *mut ::std::os::raw::c_char,
                                                              pchValue:
                                                                  *mut ::std::os::raw::c_char,
                                                              peError:
                                                                  *mut EVRSettingsError)>,
    pub GetBool: ::std::option::Option<unsafe extern "C" fn(pchSection:
                                                                *mut ::std::os::raw::c_char,
                                                            pchSettingsKey:
                                                                *mut ::std::os::raw::c_char,
                                                            peError:
                                                                *mut EVRSettingsError)
                                           -> bool>,
    pub GetInt32: ::std::option::Option<unsafe extern "C" fn(pchSection:
                                                                 *mut ::std::os::raw::c_char,
                                                             pchSettingsKey:
                                                                 *mut ::std::os::raw::c_char,
                                                             peError:
                                                                 *mut EVRSettingsError)
                                            -> ::std::os::raw::c_int>,
    pub GetFloat: ::std::option::Option<unsafe extern "C" fn(pchSection:
                                                                 *mut ::std::os::raw::c_char,
                                                             pchSettingsKey:
                                                                 *mut ::std::os::raw::c_char,
                                                             peError:
                                                                 *mut EVRSettingsError)
                                            -> f32>,
    pub GetString: ::std::option::Option<unsafe extern "C" fn(pchSection:
                                                                  *mut ::std::os::raw::c_char,
                                                              pchSettingsKey:
                                                                  *mut ::std::os::raw::c_char,
                                                              pchValue:
                                                                  *mut ::std::os::raw::c_char,
                                                              unValueLen: u32,
                                                              peError:
                                                                  *mut EVRSettingsError)>,
    pub RemoveSection: ::std::option::Option<unsafe extern "C" fn(pchSection:
                                                                      *mut ::std::os::raw::c_char,
                                                                  peError:
                                                                      *mut EVRSettingsError)>,
    pub RemoveKeyInSection: ::std::option::Option<unsafe extern "C" fn(pchSection:
                                                                           *mut ::std::os::raw::c_char,
                                                                       pchSettingsKey:
                                                                           *mut ::std::os::raw::c_char,
                                                                       peError:
                                                                           *mut EVRSettingsError)>,
}
#[test]
fn bindgen_test_layout_VR_IVRSettings_FnTable() {
    assert_eq!(::std::mem::size_of::<VR_IVRSettings_FnTable>() , 96usize);
    assert_eq!(::std::mem::align_of::<VR_IVRSettings_FnTable>() , 8usize);
}
impl Clone for VR_IVRSettings_FnTable {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VR_IVRScreenshots_FnTable {
    pub RequestScreenshot: ::std::option::Option<unsafe extern "C" fn(pOutScreenshotHandle:
                                                                          *mut ScreenshotHandle_t,
                                                                      type_:
                                                                          EVRScreenshotType,
                                                                      pchPreviewFilename:
                                                                          *mut ::std::os::raw::c_char,
                                                                      pchVRFilename:
                                                                          *mut ::std::os::raw::c_char)
                                                     -> EVRScreenshotError>,
    pub HookScreenshot: ::std::option::Option<unsafe extern "C" fn(pSupportedTypes:
                                                                       *mut EVRScreenshotType,
                                                                   numTypes:
                                                                       ::std::os::raw::c_int)
                                                  -> EVRScreenshotError>,
    pub GetScreenshotPropertyType: ::std::option::Option<unsafe extern "C" fn(screenshotHandle:
                                                                                  ScreenshotHandle_t,
                                                                              pError:
                                                                                  *mut EVRScreenshotError)
                                                             ->
                                                                 EVRScreenshotType>,
    pub GetScreenshotPropertyFilename: ::std::option::Option<unsafe extern "C" fn(screenshotHandle:
                                                                                      ScreenshotHandle_t,
                                                                                  filenameType:
                                                                                      EVRScreenshotPropertyFilenames,
                                                                                  pchFilename:
                                                                                      *mut ::std::os::raw::c_char,
                                                                                  cchFilename:
                                                                                      u32,
                                                                                  pError:
                                                                                      *mut EVRScreenshotError)
                                                                 ->
                                                                     ::std::os::raw::c_uint>,
    pub UpdateScreenshotProgress: ::std::option::Option<unsafe extern "C" fn(screenshotHandle:
                                                                                 ScreenshotHandle_t,
                                                                             flProgress:
                                                                                 f32)
                                                            ->
                                                                EVRScreenshotError>,
    pub TakeStereoScreenshot: ::std::option::Option<unsafe extern "C" fn(pOutScreenshotHandle:
                                                                             *mut ScreenshotHandle_t,
                                                                         pchPreviewFilename:
                                                                             *mut ::std::os::raw::c_char,
                                                                         pchVRFilename:
                                                                             *mut ::std::os::raw::c_char)
                                                        ->
                                                            EVRScreenshotError>,
    pub SubmitScreenshot: ::std::option::Option<unsafe extern "C" fn(screenshotHandle:
                                                                         ScreenshotHandle_t,
                                                                     type_:
                                                                         EVRScreenshotType,
                                                                     pchSourcePreviewFilename:
                                                                         *mut ::std::os::raw::c_char,
                                                                     pchSourceVRFilename:
                                                                         *mut ::std::os::raw::c_char)
                                                    -> EVRScreenshotError>,
}
#[test]
fn bindgen_test_layout_VR_IVRScreenshots_FnTable() {
    assert_eq!(::std::mem::size_of::<VR_IVRScreenshots_FnTable>() , 56usize);
    assert_eq!(::std::mem::align_of::<VR_IVRScreenshots_FnTable>() , 8usize);
}
impl Clone for VR_IVRScreenshots_FnTable {
    fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct VR_IVRResources_FnTable {
    pub LoadSharedResource: ::std::option::Option<unsafe extern "C" fn(pchResourceName:
                                                                           *mut ::std::os::raw::c_char,
                                                                       pchBuffer:
                                                                           *mut ::std::os::raw::c_char,
                                                                       unBufferLen:
                                                                           u32)
                                                      ->
                                                          ::std::os::raw::c_uint>,
    pub GetResourceFullPath: ::std::option::Option<unsafe extern "C" fn(pchResourceName:
                                                                            *mut ::std::os::raw::c_char,
                                                                        pchResourceTypeDirectory:
                                                                            *mut ::std::os::raw::c_char,
                                                                        pchPathBuffer:
                                                                            *mut ::std::os::raw::c_char,
                                                                        unBufferLen:
                                                                            u32)
                                                       ->
                                                           ::std::os::raw::c_uint>,
}
#[test]
fn bindgen_test_layout_VR_IVRResources_FnTable() {
    assert_eq!(::std::mem::size_of::<VR_IVRResources_FnTable>() , 16usize);
    assert_eq!(::std::mem::align_of::<VR_IVRResources_FnTable>() , 8usize);
}
impl Clone for VR_IVRResources_FnTable {
    fn clone(&self) -> Self { *self }
}