From 8003ddd32984142fd6badcc3656a8a20dec0b000 Mon Sep 17 00:00:00 2001 From: Colin Sherratt Date: Tue, 16 Jun 2015 01:18:30 -0400 Subject: [PATCH] Added upto time_since_last_vsync --- examples/test.rs | 26 +++- scripts/gen.py | 14 +- src/lib.rs | 164 +++++++++++++++++++- src/sys/build.rs | 5 +- src/sys/lib.rs | 383 ++++++++++++++++++++++++++++++----------------- 5 files changed, 441 insertions(+), 151 deletions(-) diff --git a/examples/test.rs b/examples/test.rs index 9e37d32..3dd7521 100644 --- a/examples/test.rs +++ b/examples/test.rs @@ -1,6 +1,28 @@ extern crate vr; fn main() { - let vr = vr::IVRSystem::init().unwrap(); - print!("{:?}", vr.bounds()); + let ivr = vr::IVRSystem::init().unwrap(); + println!("bounds: {:?}", ivr.bounds()); + println!("recommended size: {:?}", ivr.recommended_render_target_size()); + println!("eye output: {:?} {:?}", ivr.eye_viewport(vr::Eye::Left), ivr.eye_viewport(vr::Eye::Right)); + println!("projection matrix left {:?}", ivr.projection_matrix(vr::Eye::Left, 0.1, 100.)); + println!("projection matrix right {:?}", ivr.projection_matrix(vr::Eye::Right, 0.1, 100.)); + + for u in 0..4 { + for v in 0..4 { + let pos = ivr.compute_distortion( + vr::Eye::Left, + u as f32 / 4., + v as f32 / 4., + ); + print!("({:2.4}, {:2.4}) ", pos.red[0], pos.red[1]); + } + println!(""); + } + + println!("eye_to_head: {:?}", ivr.eye_to_head_transform(vr::Eye::Left)); + println!("vsync: {:?}", ivr.time_since_last_vsync()); + + + println!("Done! \\o/"); } \ No newline at end of file diff --git a/scripts/gen.py b/scripts/gen.py index f4f46b7..8066918 100644 --- a/scripts/gen.py +++ b/scripts/gen.py @@ -1,4 +1,7 @@ import json +import re + +array = re.compile(r"(.+)\[([0-9]+)\]") data = {} with open("openvr/headers/openvr_api.json") as f: @@ -29,7 +32,6 @@ type_mapping = { 'const struct vr::RenderModel_Vertex_t *': '*const RenderModel_Vertex_t', 'float [3][4]': '[[f32; 4]; 3]', - 'float [4][4]': '[[f32; 4]; 4]', 'float [4]': '[f32; 4]', 'float [3]': '[f32; 3]', 'float [2]': '[f32; 2]', @@ -41,7 +43,7 @@ type_mapping = { def parse_type(s): if s.startswith("struct"): - return parse_type(s.split()[1]) + return parse_type(s[7:]) elif s.startswith("vr::"): return parse_type(s[4:]) elif s.startswith('enum'): @@ -52,6 +54,11 @@ def parse_type(s): return type_mapping[s] elif s[-2:] == ' *': return "*mut " + parse_type(s[:-2]) + elif s[-2:] == ' &': + return "*const " + parse_type(s[:-2]) + elif array.match(s): + m = array.match(s) + return "[%s; %s]" % (parse_type(m.group(1)), m.group(2)) return s def parse_class(s): @@ -107,7 +114,8 @@ for s in data['structs']: continue print "#[repr(C)]\npub struct %s {" % parse_type(s['struct']) for f in s['fields']: - print "\t%s: %s," % (f['fieldname'], parse_type(f['fieldtype'])) + print "\t//%s" % f['fieldtype'] + print "\tpub %s: %s," % (f['fieldname'], parse_type(f['fieldtype'])) print "}" print "extern \"C\" {" diff --git a/src/lib.rs b/src/lib.rs index 7fa9ff2..af9bd7f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -2,11 +2,50 @@ extern crate openvr_sys; -#[derive(Debug)] pub struct IVRSystem(*const ()); +#[derive(Debug, Copy, Clone)] +pub struct Size { + pub width: u32, + pub height: u32 +} + +#[derive(Debug, Copy, Clone)] +pub struct Position { + pub x: i32, + pub y: i32 +} + +#[derive(Debug, Copy, Clone)] +pub struct Rectangle { + pub position: Position, + pub size: Size +} + +#[derive(Debug, Copy, Clone)] +pub struct DistortionCoordinates { + pub red: [f32; 2], + pub green: [f32; 2], + pub blue: [f32; 2], +} + +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum Eye { + Left, Right +} + +impl Eye { + fn to_raw(&self) -> openvr_sys::Hmd_Eye { + match self { + &Eye::Left => openvr_sys::Hmd_Eye::Left, + &Eye::Right => openvr_sys::Hmd_Eye::Right, + } + } +} + + impl IVRSystem { - /// Initalize the IVR System + /// Initialize the IVR System pub fn init() -> Result { let mut err = openvr_sys::HmdError::None; let ptr = unsafe { @@ -20,14 +59,127 @@ impl IVRSystem { } /// Get the window bounds - pub fn bounds(&self) -> ((i32, i32), (u32, u32)) { + pub fn bounds(&self) -> Rectangle { unsafe { - let ((mut x, mut y), (mut w, mut h)) = ((0, 0), (0, 0)); + let mut size = Size{width: 0, height: 0}; + let mut pos = Position{x: 0, y: 0}; openvr_sys::VR_IVRSystem_GetWindowBounds( - self.0, &mut x, &mut y, &mut w, &mut h + self.0, + &mut pos.x, + &mut pos.y, + &mut size.width, + &mut size.height ); - ((x, y), (w, h)) + Rectangle { + position: pos, + size: size + } } } + /// Get the recommended render target size + pub fn recommended_render_target_size(&self) -> Size { + unsafe { + let mut size = Size{width: 0, height: 0}; + openvr_sys::VR_IVRSystem_GetRecommendedRenderTargetSize( + self.0, + &mut size.width, + &mut size.height + ); + size + } + } + + /// Get eye viewport size + pub fn eye_viewport(&self, eye: Eye) -> Rectangle { + use std::mem; + unsafe { + let mut size = Size{width: 0, height: 0}; + let mut pos = Position{x: 0, y: 0}; + openvr_sys::VR_IVRSystem_GetEyeOutputViewport( + self.0, + eye.to_raw(), + mem::transmute(&mut pos.x), + mem::transmute(&mut pos.y), + &mut size.width, + &mut size.height + ); + Rectangle { + position: pos, + size: size + } + } + } + + /// Get the projection matrix for an eye + /// supply the near and the far position + /// assumes opengl conventions + pub fn projection_matrix(&self, eye: Eye, near: f32, far: f32) -> [[f32; 4]; 4] { + unsafe { + let mat = openvr_sys::VR_IVRSystem_GetProjectionMatrix( + self.0, + eye.to_raw(), + near, + far, + openvr_sys::GraphicsAPIConvention::OpenGL + ); + mat.m + } + } + + /// Computes the distortion caused by the optics + pub fn compute_distortion(&self, eye: Eye, u: f32, v: f32) -> DistortionCoordinates { + unsafe { + let coord = openvr_sys::VR_IVRSystem_ComputeDistortion( + self.0, + eye.to_raw(), + u, v + ); + DistortionCoordinates { + red: coord.rfRed, + blue: coord.rfBlue, + green: coord.rfGreen + } + } + } + + /// Computes the distortion caused by the optics + pub fn eye_to_head_transform(&self, eye: Eye) -> [[f32; 4]; 3] { + unsafe { + let mat = openvr_sys::VR_IVRSystem_GetEyeToHeadTransform( + self.0, + eye.to_raw(), + ); + mat.m + } + } + + /// Computes the distortion caused by the optics + pub fn time_since_last_vsync(&self) -> Option<(f32, u64)> { + unsafe { + let mut frame = 0; + let mut sync = 0.; + let found = openvr_sys::VR_IVRSystem_GetTimeSinceLastVsync( + self.0, + &mut sync, + &mut frame + ); + + if found { + Some((sync, frame)) + } else { + None + } + } + } +} + +impl Drop for IVRSystem { + fn drop(&mut self) { + unsafe { + println!("Trying to shutdown openvr"); + openvr_sys::VR_Shutdown(); + println!("Should be done now."); + } + } } \ No newline at end of file diff --git a/src/sys/build.rs b/src/sys/build.rs index bd627d8..b47947e 100644 --- a/src/sys/build.rs +++ b/src/sys/build.rs @@ -5,4 +5,7 @@ fn main() { println!("cargo:rustc-link-search={}/../../openvr/bin/osx32", env!("CARGO_MANIFEST_DIR")); } -//fn main() {} \ No newline at end of file +#[cfg(target_os="linux")] +fn main() { + println!("cargo:rustc-link-search={}/../../openvr/bin/linux64", env!("CARGO_MANIFEST_DIR")); +} \ No newline at end of file diff --git a/src/sys/lib.rs b/src/sys/lib.rs index c4da87a..d844d5c 100755 --- a/src/sys/lib.rs +++ b/src/sys/lib.rs @@ -303,204 +303,309 @@ pub enum VROverlayFlags { #[repr(C)] pub struct HmdMatrix34_t { - m: [[f32; 4]; 3], + //float [3][4] + pub m: [[f32; 4]; 3], } #[repr(C)] pub struct HmdMatrix44_t { - m: [[f32; 4]; 4], + //float [4][4] + pub m: [[f32; 4]; 4], } #[repr(C)] pub struct HmdVector3_t { - v: [f32; 3], + //float [3] + pub v: [f32; 3], } #[repr(C)] pub struct HmdVector3d_t { - v: [f64; 3], + //double [3] + pub v: [f64; 3], } #[repr(C)] pub struct HmdVector2_t { - v: [f32; 2], + //float [2] + pub v: [f32; 2], } #[repr(C)] pub struct HmdQuaternion_t { - w: f64, - x: f64, - y: f64, - z: f64, + //double + pub w: f64, + //double + pub x: f64, + //double + pub y: f64, + //double + pub z: f64, } #[repr(C)] pub struct HmdQuad_t { - vCorners: HmdVector3_t, + //struct vr::HmdVector3_t [4] + pub vCorners: [HmdVector3_t ; 4], } #[repr(C)] pub struct DistortionCoordinates_t { - rfRed: [f32; 2], - rfGreen: [f32; 2], - rfBlue: [f32; 2], + //float [2] + pub rfRed: [f32; 2], + //float [2] + pub rfGreen: [f32; 2], + //float [2] + pub rfBlue: [f32; 2], } #[repr(C)] pub struct TrackedDevicePose_t { - mDeviceToAbsoluteTracking: HmdMatrix34_t, - vVelocity: HmdVector3_t, - vAngularVelocity: HmdVector3_t, - eTrackingResult: HmdTrackingResult, - bPoseIsValid: bool, - bDeviceIsConnected: bool, + //struct vr::HmdMatrix34_t + pub mDeviceToAbsoluteTracking: HmdMatrix34_t, + //struct vr::HmdVector3_t + pub vVelocity: HmdVector3_t, + //struct vr::HmdVector3_t + pub vAngularVelocity: HmdVector3_t, + //enum vr::HmdTrackingResult + pub eTrackingResult: HmdTrackingResult, + //_Bool + pub bPoseIsValid: bool, + //_Bool + pub bDeviceIsConnected: bool, } #[repr(C)] pub struct RenderModel_Vertex_t { - vPosition: HmdVector3_t, - vNormal: HmdVector3_t, - rfTextureCoord: [f32; 2], + //struct vr::HmdVector3_t + pub vPosition: HmdVector3_t, + //struct vr::HmdVector3_t + pub vNormal: HmdVector3_t, + //float [2] + pub rfTextureCoord: [f32; 2], } #[repr(C)] pub struct RenderModel_TextureMap_t { - unWidth: u16, - unHeight: u16, - rubTextureMapData: *mut u8, + //uint16_t + pub unWidth: u16, + //uint16_t + pub unHeight: u16, + //const uint8_t * + pub rubTextureMapData: *mut u8, } #[repr(C)] pub struct RenderModel_t { - ulInternalHandle: u64, - rVertexData: RenderModel_Vertex_t, - unVertexCount: u32, - rIndexData: *mut u16, - unTriangleCount: u32, - diffuseTexture: RenderModel_TextureMap_t, + //uint64_t + pub ulInternalHandle: u64, + //const struct vr::RenderModel_Vertex_t * + pub rVertexData: *mut RenderModel_Vertex_t, + //uint32_t + pub unVertexCount: u32, + //const uint16_t * + pub rIndexData: *mut u16, + //uint32_t + pub unTriangleCount: u32, + //struct vr::RenderModel_TextureMap_t + pub diffuseTexture: RenderModel_TextureMap_t, } #[repr(C)] pub struct VRTextureBounds_t { - uMin: f32, - vMin: f32, - uMax: f32, - vMax: f32, + //float + pub uMin: f32, + //float + pub vMin: f32, + //float + pub uMax: f32, + //float + pub vMax: f32, } #[repr(C)] pub struct VREvent_Controller_t { - button: EVRButtonId, + //enum vr::EVRButtonId + pub button: EVRButtonId, } #[repr(C)] pub struct VREvent_Mouse_t { - x: f32, - y: f32, - button: EVRMouseButton, + //float + pub x: f32, + //float + pub y: f32, + //enum vr::EVRMouseButton + pub button: EVRMouseButton, } #[repr(C)] pub struct VREvent_Notification_t { - x: f32, - y: f32, - notificationId: u32, + //float + pub x: f32, + //float + pub y: f32, + //uint32_t + pub notificationId: u32, } #[repr(C)] pub struct VREvent_Process_t { - pid: u32, - oldPid: u32, + //uint32_t + pub pid: u32, + //uint32_t + pub oldPid: u32, } #[repr(C)] pub struct VREvent_Overlay_t { - overlayHandle: u64, + //uint64_t + pub overlayHandle: u64, } #[repr(C)] pub struct VREvent_Reserved_t { - reserved0: u64, - reserved1: u64, + //uint64_t + pub reserved0: u64, + //uint64_t + pub reserved1: u64, } #[repr(C)] pub struct VREvent_t { - eventType: EVREventType, - trackedDeviceIndex: TrackedDeviceIndex_t, - data: VREvent_Data_t, - eventAgeSeconds: f32, + //enum vr::EVREventType + pub eventType: EVREventType, + //TrackedDeviceIndex_t + pub trackedDeviceIndex: TrackedDeviceIndex_t, + //VREvent_Data_t + pub data: VREvent_Data_t, + //float + pub eventAgeSeconds: f32, } #[repr(C)] pub struct HiddenAreaMesh_t { - pVertexData: HmdVector2_t, - unTriangleCount: u32, + //const struct vr::HmdVector2_t * + pub pVertexData: *mut HmdVector2_t, + //uint32_t + pub unTriangleCount: u32, } #[repr(C)] pub struct VRControllerAxis_t { - x: f32, - y: f32, + //float + pub x: f32, + //float + pub y: f32, } #[repr(C)] pub struct VRControllerState001_t { - unPacketNum: u32, - ulButtonPressed: u64, - ulButtonTouched: u64, - rAxis: VRControllerAxis_t, + //uint32_t + pub unPacketNum: u32, + //uint64_t + pub ulButtonPressed: u64, + //uint64_t + pub ulButtonTouched: u64, + //struct vr::VRControllerAxis_t [5] + pub rAxis: [VRControllerAxis_t ; 5], } #[repr(C)] pub struct Compositor_OverlaySettings { - size: u32, - curved: bool, - antialias: bool, - scale: f32, - distance: f32, - alpha: f32, - uOffset: f32, - vOffset: f32, - uScale: f32, - vScale: f32, - gridDivs: f32, - gridWidth: f32, - gridScale: f32, - transform: HmdMatrix44_t, + //uint32_t + pub size: u32, + //_Bool + pub curved: bool, + //_Bool + pub antialias: bool, + //float + pub scale: f32, + //float + pub distance: f32, + //float + pub alpha: f32, + //float + pub uOffset: f32, + //float + pub vOffset: f32, + //float + pub uScale: f32, + //float + pub vScale: f32, + //float + pub gridDivs: f32, + //float + pub gridWidth: f32, + //float + pub gridScale: f32, + //struct vr::HmdMatrix44_t + pub transform: HmdMatrix44_t, } #[repr(C)] pub struct CameraInfo_t { - width: u32, - height: u32, - depth: u32, - fx: f32, - cx: f32, - fy: f32, - cy: f32, + //uint32_t + pub width: u32, + //uint32_t + pub height: u32, + //uint32_t + pub depth: u32, + //float + pub fx: f32, + //float + pub cx: f32, + //float + pub fy: f32, + //float + pub cy: f32, } #[repr(C)] pub struct CameraImage_t { - frameID: i32, - pose: HmdMatrix34_t, - pBuffer: *const u8, - unBufferLen: u32, - result: CameraImageResult, + //int32_t + pub frameID: i32, + //struct vr::HmdMatrix34_t + pub pose: HmdMatrix34_t, + //unsigned char * + pub pBuffer: *const u8, + //uint32_t + pub unBufferLen: u32, + //enum vr::CameraImageResult + pub result: CameraImageResult, } #[repr(C)] pub struct ChaperoneSoftBoundsInfo_t { - quadCorners: HmdQuad_t, + //struct vr::HmdQuad_t + pub quadCorners: HmdQuad_t, } #[repr(C)] pub struct ChaperoneSeatedBoundsInfo_t { - vSeatedHeadPosition: HmdVector3_t, - vDeskEdgePositions: HmdVector3_t, + //struct vr::HmdVector3_t + pub vSeatedHeadPosition: HmdVector3_t, + //struct vr::HmdVector3_t [2] + pub vDeskEdgePositions: [HmdVector3_t ; 2], } #[repr(C)] pub struct Compositor_FrameTiming { - size: u32, - frameStart: f64, - frameVSync: f32, - droppedFrames: u32, - frameIndex: u32, - pose: TrackedDevicePose_t, + //uint32_t + pub size: u32, + //double + pub frameStart: f64, + //float + pub frameVSync: f32, + //uint32_t + pub droppedFrames: u32, + //uint32_t + pub frameIndex: u32, + //vr::TrackedDevicePose_t + pub pose: TrackedDevicePose_t, } #[repr(C)] pub struct VROverlayIntersectionParams_t { - vSource: HmdVector3_t, - vDirection: HmdVector3_t, - eOrigin: TrackingUniverseOrigin, + //vr::HmdVector3_t + pub vSource: HmdVector3_t, + //vr::HmdVector3_t + pub vDirection: HmdVector3_t, + //enum vr::TrackingUniverseOrigin + pub eOrigin: TrackingUniverseOrigin, } #[repr(C)] pub struct VROverlayIntersectionResults_t { - vPoint: HmdVector3_t, - vNormal: HmdVector3_t, - vUVs: HmdVector2_t, - fDistance: f32, + //vr::HmdVector3_t + pub vPoint: HmdVector3_t, + //vr::HmdVector3_t + pub vNormal: HmdVector3_t, + //vr::HmdVector2_t + pub vUVs: HmdVector2_t, + //float + pub fDistance: f32, } #[repr(C)] pub struct NotificationBitmap { - bytes: *const u8, - width: i32, - height: i32, - depth: i32, + //char * + pub bytes: *const u8, + //int32_t + pub width: i32, + //int32_t + pub height: i32, + //int32_t + pub depth: i32, } extern "C" { pub fn VR_IVRSystem_GetWindowBounds(ptr: *const (), pnX: *mut i32, pnY: *mut i32, pnWidth: *mut u32, pnHeight: *mut u32) ; @@ -514,7 +619,7 @@ extern "C" { pub fn VR_IVRSystem_GetD3D9AdapterIndex(ptr: *const (), ) -> i32; pub fn VR_IVRSystem_GetDXGIOutputInfo(ptr: *const (), pnAdapterIndex: *mut i32, pnAdapterOutputIndex: *mut i32) ; pub fn VR_IVRSystem_AttachToWindow(ptr: *const (), hWnd: *mut ()) -> bool; - pub fn VR_IVRSystem_GetDeviceToAbsoluteTrackingPose(ptr: *const (), eOrigin: TrackingUniverseOrigin, fPredictedSecondsToPhotonsFromNow: f32, pTrackedDevicePoseArray: TrackedDevicePose_t, unTrackedDevicePoseArrayCount: u32) ; + pub fn VR_IVRSystem_GetDeviceToAbsoluteTrackingPose(ptr: *const (), eOrigin: TrackingUniverseOrigin, fPredictedSecondsToPhotonsFromNow: f32, pTrackedDevicePoseArray: *mut TrackedDevicePose_t, unTrackedDevicePoseArrayCount: u32) ; pub fn VR_IVRSystem_ResetSeatedZeroPose(ptr: *const (), ) ; pub fn VR_IVRSystem_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(ptr: *const (), ) -> HmdMatrix34_t; pub fn VR_IVRSystem_GetTrackedDeviceClass(ptr: *const (), unDeviceIndex: TrackedDeviceIndex_t) -> TrackedDeviceClass; @@ -526,12 +631,12 @@ extern "C" { pub fn VR_IVRSystem_GetMatrix34TrackedDeviceProperty(ptr: *const (), unDeviceIndex: TrackedDeviceIndex_t, prop: TrackedDeviceProperty, pError: *mut TrackedPropertyError) -> HmdMatrix34_t; pub fn VR_IVRSystem_GetStringTrackedDeviceProperty(ptr: *const (), unDeviceIndex: TrackedDeviceIndex_t, prop: TrackedDeviceProperty, pchValue: *const u8, unBufferSize: u32, pError: *mut TrackedPropertyError) -> u32; pub fn VR_IVRSystem_GetPropErrorNameFromEnum(ptr: *const (), error: TrackedPropertyError) -> *const u8; - pub fn VR_IVRSystem_PollNextEvent(ptr: *const (), pEvent: VREvent_t) -> bool; + pub fn VR_IVRSystem_PollNextEvent(ptr: *const (), pEvent: *mut VREvent_t) -> bool; pub fn VR_IVRSystem_PollNextEventWithPose(ptr: *const (), eOrigin: TrackingUniverseOrigin, pEvent: *mut VREvent_t, pTrackedDevicePose: *mut TrackedDevicePose_t) -> bool; pub fn VR_IVRSystem_GetEventTypeNameFromEnum(ptr: *const (), eType: EVREventType) -> *const u8; pub fn VR_IVRSystem_GetHiddenAreaMesh(ptr: *const (), eEye: Hmd_Eye) -> HiddenAreaMesh_t; pub fn VR_IVRSystem_GetControllerState(ptr: *const (), unControllerDeviceIndex: TrackedDeviceIndex_t, pControllerState: *mut VRControllerState_t) -> bool; - pub fn VR_IVRSystem_GetControllerStateWithPose(ptr: *const (), eOrigin: TrackingUniverseOrigin, unControllerDeviceIndex: TrackedDeviceIndex_t, pControllerState: *mut VRControllerState_t, pTrackedDevicePose: TrackedDevicePose_t) -> bool; + pub fn VR_IVRSystem_GetControllerStateWithPose(ptr: *const (), eOrigin: TrackingUniverseOrigin, unControllerDeviceIndex: TrackedDeviceIndex_t, pControllerState: *mut VRControllerState_t, pTrackedDevicePose: *mut TrackedDevicePose_t) -> bool; pub fn VR_IVRSystem_TriggerHapticPulse(ptr: *const (), unControllerDeviceIndex: TrackedDeviceIndex_t, unAxisId: u32, usDurationMicroSec: u16) ; pub fn VR_IVRSystem_GetButtonIdNameFromEnum(ptr: *const (), eButtonId: EVRButtonId) -> *const u8; pub fn VR_IVRSystem_GetControllerAxisTypeNameFromEnum(ptr: *const (), eAxisType: EVRControllerAxisType) -> *const u8; @@ -542,27 +647,27 @@ extern "C" { pub fn VR_IVRCameraAccess_GetCameraCount(ptr: *const (), ) -> u32; pub fn VR_IVRCameraAccess_GetCameraId(ptr: *const (), unCameraIndex: u32, pchBuffer: *const u8, unBufferLen: u32) -> u32; pub fn VR_IVRCameraAccess_EnableCamera(ptr: *const (), unCameraIndex: u32, bEnabled: bool) -> bool; - pub fn VR_IVRCameraAccess_GetCameraInfo(ptr: *const (), unCameraIndex: u32, pCameraInfo: CameraInfo_t) -> bool; - pub fn VR_IVRCameraAccess_GetCameraImage(ptr: *const (), unCameraIndex: u32, pCameraImage: CameraImage_t) -> bool; + pub fn VR_IVRCameraAccess_GetCameraInfo(ptr: *const (), unCameraIndex: u32, pCameraInfo: *mut CameraInfo_t) -> bool; + pub fn VR_IVRCameraAccess_GetCameraImage(ptr: *const (), unCameraIndex: u32, pCameraImage: *mut CameraImage_t) -> bool; pub fn VR_IVRChaperone_GetCalibrationState(ptr: *const (), ) -> ChaperoneCalibrationState; - pub fn VR_IVRChaperone_GetSoftBoundsInfo(ptr: *const (), pInfo: ChaperoneSoftBoundsInfo_t) -> bool; - pub fn VR_IVRChaperone_GetHardBoundsInfo(ptr: *const (), pQuadsBuffer: HmdQuad_t, punQuadsCount: *mut u32) -> bool; - pub fn VR_IVRChaperone_GetSeatedBoundsInfo(ptr: *const (), pInfo: ChaperoneSeatedBoundsInfo_t) -> bool; + pub fn VR_IVRChaperone_GetSoftBoundsInfo(ptr: *const (), pInfo: *mut ChaperoneSoftBoundsInfo_t) -> bool; + pub fn VR_IVRChaperone_GetHardBoundsInfo(ptr: *const (), pQuadsBuffer: *mut HmdQuad_t, punQuadsCount: *mut u32) -> bool; + pub fn VR_IVRChaperone_GetSeatedBoundsInfo(ptr: *const (), pInfo: *mut ChaperoneSeatedBoundsInfo_t) -> bool; pub fn VR_IVRChaperoneSetup_CommitWorkingCopy(ptr: *const (), pchCalibrationName: *const u8) -> bool; pub fn VR_IVRChaperoneSetup_RevertWorkingCopy(ptr: *const (), ) ; - pub fn VR_IVRChaperoneSetup_GetWorkingSoftBoundsInfo(ptr: *const (), pInfo: ChaperoneSoftBoundsInfo_t) -> bool; - pub fn VR_IVRChaperoneSetup_GetWorkingHardBoundsInfo(ptr: *const (), pQuadsBuffer: HmdQuad_t, punQuadsCount: *mut u32) -> bool; - pub fn VR_IVRChaperoneSetup_GetWorkingSeatedZeroPoseToRawTrackingPose(ptr: *const (), pmatSeatedZeroPoseToRawTrackingPose: HmdMatrix34_t) -> bool; - pub fn VR_IVRChaperoneSetup_GetWorkingStandingZeroPoseToRawTrackingPose(ptr: *const (), pmatStandingZeroPoseToRawTrackingPose: HmdMatrix34_t) -> bool; - pub fn VR_IVRChaperoneSetup_SetWorkingSoftBoundsInfo(ptr: *const (), pInfo: ChaperoneSoftBoundsInfo_t) ; - pub fn VR_IVRChaperoneSetup_SetWorkingHardBoundsInfo(ptr: *const (), pQuadsBuffer: HmdQuad_t, unQuadsCount: u32) ; - pub fn VR_IVRChaperoneSetup_SetWorkingSeatedZeroPoseToRawTrackingPose(ptr: *const (), matSeatedZeroPoseToRawTrackingPose: HmdMatrix34_t) ; - pub fn VR_IVRChaperoneSetup_SetWorkingStandingZeroPoseToRawTrackingPose(ptr: *const (), matStandingZeroPoseToRawTrackingPose: HmdMatrix34_t) ; - pub fn VR_IVRChaperoneSetup_GetWorkingTagPoses(ptr: *const (), pTagPosesBuffer: HmdMatrix34_t, punTagPosesCount: *mut u32) -> bool; + pub fn VR_IVRChaperoneSetup_GetWorkingSoftBoundsInfo(ptr: *const (), pInfo: *mut ChaperoneSoftBoundsInfo_t) -> bool; + pub fn VR_IVRChaperoneSetup_GetWorkingHardBoundsInfo(ptr: *const (), pQuadsBuffer: *mut HmdQuad_t, punQuadsCount: *mut u32) -> bool; + pub fn VR_IVRChaperoneSetup_GetWorkingSeatedZeroPoseToRawTrackingPose(ptr: *const (), pmatSeatedZeroPoseToRawTrackingPose: *mut HmdMatrix34_t) -> bool; + pub fn VR_IVRChaperoneSetup_GetWorkingStandingZeroPoseToRawTrackingPose(ptr: *const (), pmatStandingZeroPoseToRawTrackingPose: *mut HmdMatrix34_t) -> bool; + pub fn VR_IVRChaperoneSetup_SetWorkingSoftBoundsInfo(ptr: *const (), pInfo: *mut ChaperoneSoftBoundsInfo_t) ; + pub fn VR_IVRChaperoneSetup_SetWorkingHardBoundsInfo(ptr: *const (), pQuadsBuffer: *mut HmdQuad_t, unQuadsCount: u32) ; + pub fn VR_IVRChaperoneSetup_SetWorkingSeatedZeroPoseToRawTrackingPose(ptr: *const (), matSeatedZeroPoseToRawTrackingPose: *const HmdMatrix34_t) ; + pub fn VR_IVRChaperoneSetup_SetWorkingStandingZeroPoseToRawTrackingPose(ptr: *const (), matStandingZeroPoseToRawTrackingPose: *const HmdMatrix34_t) ; + pub fn VR_IVRChaperoneSetup_GetWorkingTagPoses(ptr: *const (), pTagPosesBuffer: *mut HmdMatrix34_t, punTagPosesCount: *mut u32) -> bool; pub fn VR_IVRChaperoneSetup_GetWorkingTagPoseScales(ptr: *const (), pflScaleBuffer: *mut f32, punTagPosesCount: *mut u32) -> bool; pub fn VR_IVRChaperoneSetup_GetWorkingTagPoseNameByIndex(ptr: *const (), nIndex: u32, pchBuffer: *const u8, unBufferSize: u32) -> u32; - pub fn VR_IVRChaperoneSetup_GetWorkingTagPoseByName(ptr: *const (), pchTagName: *const u8, pmatTagPose: HmdMatrix34_t, pflScale: *mut f32) -> bool; - pub fn VR_IVRChaperoneSetup_SetWorkingTagPoseByName(ptr: *const (), pchTagName: *const u8, matSeatedZeroPoseToRawTrackingPose: HmdMatrix34_t, flScale: f32) ; + pub fn VR_IVRChaperoneSetup_GetWorkingTagPoseByName(ptr: *const (), pchTagName: *const u8, pmatTagPose: *mut HmdMatrix34_t, pflScale: *mut f32) -> bool; + pub fn VR_IVRChaperoneSetup_SetWorkingTagPoseByName(ptr: *const (), pchTagName: *const u8, matSeatedZeroPoseToRawTrackingPose: *const HmdMatrix34_t, flScale: f32) ; pub fn VR_IVRChaperoneSetup_RemoveWorkingTagPoseByName(ptr: *const (), pchTagName: *const u8) ; pub fn VR_IVRChaperoneSetup_RemoveAllWorkingTagPoses(ptr: *const (), ) ; pub fn VR_IVRChaperoneSetup_ReloadFromDisk(ptr: *const (), ) ; @@ -572,10 +677,10 @@ extern "C" { pub fn VR_IVRCompositor_SetGamma(ptr: *const (), fGamma: f32) ; pub fn VR_IVRCompositor_GetGamma(ptr: *const (), ) -> f32; pub fn VR_IVRCompositor_SetGraphicsDevice(ptr: *const (), eType: Compositor_DeviceType, pDevice: *mut ()) ; - pub fn VR_IVRCompositor_WaitGetPoses(ptr: *const (), pRenderPoseArray: TrackedDevicePose_t, unRenderPoseArrayCount: u32, pGamePoseArray: TrackedDevicePose_t, unGamePoseArrayCount: u32) -> VRCompositorError; - pub fn VR_IVRCompositor_Submit(ptr: *const (), eEye: Hmd_Eye, pTexture: *mut (), pBounds: VRTextureBounds_t) -> VRCompositorError; + pub fn VR_IVRCompositor_WaitGetPoses(ptr: *const (), pRenderPoseArray: *mut TrackedDevicePose_t, unRenderPoseArrayCount: u32, pGamePoseArray: *mut TrackedDevicePose_t, unGamePoseArrayCount: u32) -> VRCompositorError; + pub fn VR_IVRCompositor_Submit(ptr: *const (), eEye: Hmd_Eye, pTexture: *mut (), pBounds: *mut VRTextureBounds_t) -> VRCompositorError; pub fn VR_IVRCompositor_ClearLastSubmittedFrame(ptr: *const (), ) ; - pub fn VR_IVRCompositor_GetFrameTiming(ptr: *const (), pTiming: Compositor_FrameTiming, unFramesAgo: u32) -> bool; + pub fn VR_IVRCompositor_GetFrameTiming(ptr: *const (), pTiming: *mut Compositor_FrameTiming, unFramesAgo: u32) -> bool; pub fn VR_IVRCompositor_FadeToColor(ptr: *const (), fSeconds: f32, fRed: f32, fGreen: f32, fBlue: f32, fAlpha: f32, bBackground: bool) ; pub fn VR_IVRCompositor_FadeGrid(ptr: *const (), fSeconds: f32, bFadeIn: bool) ; pub fn VR_IVRCompositor_CompositorBringToFront(ptr: *const (), ) ; @@ -600,24 +705,24 @@ extern "C" { pub fn VR_IVROverlay_GetOverlayGamma(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, pfGamma: *mut f32) -> VROverlayError; pub fn VR_IVROverlay_SetOverlayWidthInMeters(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, fWidthInMeters: f32) -> VROverlayError; pub fn VR_IVROverlay_GetOverlayWidthInMeters(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, pfWidthInMeters: *mut f32) -> VROverlayError; - pub fn VR_IVROverlay_SetOverlayTextureBounds(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, pOverlayTextureBounds: VRTextureBounds_t) -> VROverlayError; - pub fn VR_IVROverlay_GetOverlayTextureBounds(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, pOverlayTextureBounds: VRTextureBounds_t) -> VROverlayError; + pub fn VR_IVROverlay_SetOverlayTextureBounds(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, pOverlayTextureBounds: *mut VRTextureBounds_t) -> VROverlayError; + pub fn VR_IVROverlay_GetOverlayTextureBounds(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, pOverlayTextureBounds: *mut VRTextureBounds_t) -> VROverlayError; pub fn VR_IVROverlay_GetOverlayTransformType(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, peTransformType: *mut VROverlayTransformType) -> VROverlayError; - pub fn VR_IVROverlay_SetOverlayTransformAbsolute(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, eTrackingOrigin: TrackingUniverseOrigin, pmatTrackingOriginToOverlayTransform: HmdMatrix34_t) -> VROverlayError; - pub fn VR_IVROverlay_GetOverlayTransformAbsolute(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, peTrackingOrigin: *mut TrackingUniverseOrigin, pmatTrackingOriginToOverlayTransform: HmdMatrix34_t) -> VROverlayError; - pub fn VR_IVROverlay_SetOverlayTransformTrackedDeviceRelative(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, unTrackedDevice: TrackedDeviceIndex_t, pmatTrackedDeviceToOverlayTransform: HmdMatrix34_t) -> VROverlayError; - pub fn VR_IVROverlay_GetOverlayTransformTrackedDeviceRelative(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, punTrackedDevice: *mut TrackedDeviceIndex_t, pmatTrackedDeviceToOverlayTransform: HmdMatrix34_t) -> VROverlayError; + pub fn VR_IVROverlay_SetOverlayTransformAbsolute(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, eTrackingOrigin: TrackingUniverseOrigin, pmatTrackingOriginToOverlayTransform: *mut HmdMatrix34_t) -> VROverlayError; + pub fn VR_IVROverlay_GetOverlayTransformAbsolute(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, peTrackingOrigin: *mut TrackingUniverseOrigin, pmatTrackingOriginToOverlayTransform: *mut HmdMatrix34_t) -> VROverlayError; + pub fn VR_IVROverlay_SetOverlayTransformTrackedDeviceRelative(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, unTrackedDevice: TrackedDeviceIndex_t, pmatTrackedDeviceToOverlayTransform: *mut HmdMatrix34_t) -> VROverlayError; + pub fn VR_IVROverlay_GetOverlayTransformTrackedDeviceRelative(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, punTrackedDevice: *mut TrackedDeviceIndex_t, pmatTrackedDeviceToOverlayTransform: *mut HmdMatrix34_t) -> VROverlayError; pub fn VR_IVROverlay_GetOverlayVisibility(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, peOverlayVisibility: *mut VROverlayVisibility) -> VROverlayError; pub fn VR_IVROverlay_SetOverlayVisibility(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, eOverlayVisibility: VROverlayVisibility) -> VROverlayError; pub fn VR_IVROverlay_ShowOverlay(ptr: *const (), ulOverlayHandle: VROverlayHandle_t) -> VROverlayError; pub fn VR_IVROverlay_HideOverlay(ptr: *const (), ulOverlayHandle: VROverlayHandle_t) -> VROverlayError; pub fn VR_IVROverlay_IsOverlayVisible(ptr: *const (), ulOverlayHandle: VROverlayHandle_t) -> bool; - pub fn VR_IVROverlay_PollNextOverlayEvent(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, pEvent: VREvent_t) -> bool; + pub fn VR_IVROverlay_PollNextOverlayEvent(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, pEvent: *mut VREvent_t) -> bool; pub fn VR_IVROverlay_GetOverlayInputMethod(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, peInputMethod: *mut VROverlayInputMethod) -> VROverlayError; pub fn VR_IVROverlay_SetOverlayInputMethod(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, eInputMethod: VROverlayInputMethod) -> VROverlayError; - pub fn VR_IVROverlay_GetOverlayMouseScale(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, pvecMouseScale: HmdVector2_t) -> VROverlayError; - pub fn VR_IVROverlay_SetOverlayMouseScale(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, pvecMouseScale: HmdVector2_t) -> VROverlayError; - pub fn VR_IVROverlay_ComputeOverlayIntersection(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, pParams: VROverlayIntersectionParams_t, pResults: VROverlayIntersectionResults_t) -> bool; + pub fn VR_IVROverlay_GetOverlayMouseScale(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, pvecMouseScale: *mut HmdVector2_t) -> VROverlayError; + pub fn VR_IVROverlay_SetOverlayMouseScale(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, pvecMouseScale: *mut HmdVector2_t) -> VROverlayError; + pub fn VR_IVROverlay_ComputeOverlayIntersection(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, pParams: *mut VROverlayIntersectionParams_t, pResults: *mut VROverlayIntersectionResults_t) -> bool; pub fn VR_IVROverlay_HandleControllerOverlayInteractionAsMouse(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, unControllerDeviceIndex: TrackedDeviceIndex_t) -> bool; pub fn VR_IVROverlay_SetOverlayTexture(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, pTexture: *mut ()) -> VROverlayError; pub fn VR_IVROverlay_SetOverlayRaw(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, pvBuffer: *mut (), unWidth: u32, unHeight: u32, unDepth: u32) -> VROverlayError; @@ -626,8 +731,8 @@ extern "C" { pub fn VR_IVROverlay_IsActiveSystemOverlay(ptr: *const (), ulOverlayHandle: VROverlayHandle_t) -> bool; pub fn VR_IVROverlay_SetSystemOverlaySceneProcess(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, unProcessId: u32) -> VROverlayError; pub fn VR_IVROverlay_GetSystemOverlaySceneProcess(ptr: *const (), ulOverlayHandle: VROverlayHandle_t, punProcessId: *mut u32) -> VROverlayError; - pub fn VR_IVRRenderModels_LoadRenderModel(ptr: *const (), pchRenderModelName: *const u8, pRenderModel: RenderModel_t) -> bool; - pub fn VR_IVRRenderModels_FreeRenderModel(ptr: *const (), pRenderModel: RenderModel_t) ; + pub fn VR_IVRRenderModels_LoadRenderModel(ptr: *const (), pchRenderModelName: *const u8, pRenderModel: *mut RenderModel_t) -> bool; + pub fn VR_IVRRenderModels_FreeRenderModel(ptr: *const (), pRenderModel: *mut RenderModel_t) ; pub fn VR_IVRRenderModels_GetRenderModelName(ptr: *const (), unRenderModelIndex: u32, pchRenderModelName: *const u8, unRenderModelNameLen: u32) -> u32; pub fn VR_IVRRenderModels_GetRenderModelCount(ptr: *const (), ) -> u32; pub fn VR_IVRNotifications_GetLastError(ptr: *const (), pchBuffer: *const u8, unBufferSize: u32) -> u32;