mii/rust-openvr
1
0
Fork 0
mirror of https://github.com/mii443/rust-openvr.git synced 2025-08-23 16:49:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added drop

Browse Source
This commit is contained in:
Colin Sherratt
2014-02-07 20:50:31 -05:00
parent 768ed4916a
commit 614db39e32
2 changed files with 211 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

137
lib.rs
View File

@ -4,8 +4,9 @@
extern mod cgmath;
use std::libc::{c_float, time_t};
use std::libc::{c_float, time_t, c_void};
use std::c_str::ToCStr;
use std::cast::transmute;
use cgmath::quaternion::Quat;
use cgmath::vector::Vec3;
@ -24,7 +25,7 @@ use cgmath::angle::rad;
extern {}
pub mod ll {
use std::libc::{c_uint, c_int, c_float, c_long, c_char, time_t};
use std::libc::{c_uint, c_int, c_float, c_long, c_char, time_t, c_void};
pub enum DeviceManager {}
pub struct HMDInfo {
@ -47,6 +48,7 @@ pub mod ll {
pub enum HMDDevice {}
pub enum SensorDevice {}
pub enum SensorFusion {}
pub enum MessageHandler {}
pub struct Vector3f {x: c_float, y: c_float, z: c_float}
pub struct Quatf {x: c_float, y: c_float, z: c_float, w: c_float}
@ -55,12 +57,29 @@ pub mod ll {
m31: c_float, m32: c_float, m33: c_float, m34: c_float,
m41: c_float, m42: c_float, m43: c_float, m44: c_float}
pub struct MessageBodyFrame {
Acceleration: Vector3f,
RotationRate: Vector3f,
MagneticField: Vector3f,
Temperature: f32,
TimeDelta: f32,
}
extern "C" {
pub fn OVR_system_init();
pub fn OVR_DeviceManager_Create() -> *DeviceManager;
pub fn OVR_DeviceManager_EnumerateDevices(dm :*DeviceManager) -> *HMDDevice;
pub fn OVR_HDMDevice_GetDeviceInfo(hmd: *HMDDevice) -> HMDInfo;
pub fn OVR_HDMDevice_GetSensor(hmd: *HMDDevice) -> *SensorDevice;
pub fn OVR_DeviceManager_drop(dm: *DeviceManager);
pub fn OVR_HMDDevice_GetDeviceInfo(hmd: *HMDDevice) -> HMDInfo;
pub fn OVR_HMDDevice_GetSensor(hmd: *HMDDevice) -> *SensorDevice;
pub fn OVR_MessageHandler(ptr: *c_void, cb: extern "C" fn(ptr: *c_void, msg: *MessageBodyFrame)) -> *MessageHandler;
pub fn OVR_MessageHandler_move_ptr(mh: *MessageHandler) -> *c_void;
pub fn OVR_MessageHandler_drop(mh: *MessageHandler);
pub fn OVR_SensorDevice_SetMessageHandler(sd: *SensorDevice, mh: *MessageHandler);
pub fn OVR_SensorDevice_drop(sd: *SensorDevice);
pub fn OVR_SensorFusion() -> *SensorFusion;
pub fn OVR_SensorFusion_AttachToSensor(sf: *SensorFusion, sd: *SensorDevice) -> bool;
@ -94,8 +113,9 @@ pub mod ll {
pub fn OVR_SensorFusion_ClearMagCalibration(sf: *SensorFusion);
pub fn OVR_SensorFusion_ClearMagReferences(sf: *SensorFusion, rawMag: *Vector3f);
pub fn OVR_SensorFusion_GetCalibratedMagValue(sf: *SensorFusion) -> Vector3f;
//pub fn OVR_SensorFusion_OnMessage(sf: *SensorFusion, msg: *MessageBodyFrame)
pub fn OVR_SensorFusion_OnMessage(sf: *SensorFusion, msg: *MessageBodyFrame);
//pub fn OVR_SensorFusion_SetDelegateMessageHandler(sf: *SensorFusion, handle: *MessageHandler)
pub fn OVR_SensorFusion_drop(sf: *SensorFusion);
}
}
@ -111,6 +131,15 @@ pub struct DeviceManager {
priv ptr: *ll::DeviceManager
}
impl Drop for DeviceManager {
fn drop(&mut self)
{
unsafe {
ll::OVR_DeviceManager_drop(self.ptr);
}
}
}
impl DeviceManager {
pub fn new() -> Option<DeviceManager>
{
@ -153,7 +182,7 @@ impl HMDDevice {
unsafe {
println!("{:?}", self);
HMDInfo{
dat: ll::OVR_HDMDevice_GetDeviceInfo(self.ptr)
dat: ll::OVR_HMDDevice_GetDeviceInfo(self.ptr)
}
}
}
@ -162,13 +191,14 @@ impl HMDDevice {
{
unsafe {
println!("{:?}", self);
let ptr = ll::OVR_HDMDevice_GetSensor(self.ptr);
let ptr = ll::OVR_HMDDevice_GetSensor(self.ptr);
if ptr.is_null() {
None
} else {
Some(SensorDevice{
ptr: ptr
ptr: ptr,
msg: None
})
}
}
@ -249,6 +279,14 @@ pub struct SensorFusion {
priv ptr: *ll::SensorFusion
}
impl Drop for SensorFusion {
fn drop(&mut self) {
unsafe {
ll::OVR_SensorFusion_drop(self.ptr);
}
}
}
impl SensorFusion {
pub fn new() -> Option<SensorFusion>
{
@ -501,10 +539,91 @@ impl SensorFusion {
Vec3::new(vec.x, vec.y, vec.z)
}
}
pub fn on_message(&self, msg: &Message)
{
unsafe {
match *msg {
MsgBody(ref body) => {
ll::OVR_SensorFusion_OnMessage(self.ptr, transmute(body));
}
}
}
}
}
extern "C" fn chan_callback(chan: *c_void, msg: *ll::MessageBodyFrame)
{
if chan.is_null() || msg.is_null() {
return;
}
unsafe {
let chan: &Chan<Message> = transmute(chan);
let msg: &ll::MessageBodyFrame = transmute(msg);
chan.send(MsgBody(MessageBody::from_raw(msg)));
}
}
pub struct SensorDevice {
priv ptr: *ll::SensorDevice
priv ptr: *ll::SensorDevice,
priv msg: Option<*ll::MessageHandler>
}
impl Drop for SensorDevice
{
fn drop(&mut self)
{
unsafe {
// free chan
match self.msg {
Some(msg) => {
let chan = ll::OVR_MessageHandler_move_ptr(msg);
let _: ~Chan<Message> = transmute(chan);
ll::OVR_MessageHandler_drop(msg);
},
None => ()
}
ll::OVR_SensorDevice_drop(self.ptr);
}
}
}
impl SensorDevice {
pub fn register_chan(&mut self, chan: ~Chan<Message>)
{
if self.msg.is_none() {
unsafe {
self.msg = Some(ll::OVR_MessageHandler(transmute(chan), chan_callback));
let msg = self.msg.as_ref().unwrap();
ll::OVR_SensorDevice_SetMessageHandler(self.ptr, *msg);
}
}
}
}
struct MessageBody {
acceleration: Vec3<f32>,
rotation_rate: Vec3<f32>,
magnetic_field: Vec3<f32>,
temperature: f32,
time_delta: f32
}
impl MessageBody {
fn from_raw(mbf: &ll::MessageBodyFrame) -> MessageBody
{
unsafe {
transmute(*mbf)
}
}
}
pub enum Message {
MsgBody(MessageBody)
}

149
wrapper.cpp
View File

@ -34,6 +34,59 @@ extern "C"
long DisplayId;
};
struct MessageBodyFrame {
struct Vector3f Acceleration;
struct Vector3f RotationRate;
struct Vector3f MagneticField;
float Temperature;
float TimeDelta;
};
class RustMessageHandler : public OVR::MessageHandler
{
public:
RustMessageHandler(void *_ptr, void (*_BodyFrame)(void *ptr, struct MessageBodyFrame *msg)) {
ptr = _ptr;
BodyFrame = _BodyFrame;
}
void OnMessage(const OVR::Message& msg)
{
if (msg.Type == OVR::Message_BodyFrame) {
const OVR::MessageBodyFrame& bf = static_cast<const OVR::MessageBodyFrame&>(msg);
struct MessageBodyFrame mbf = {
{bf.Acceleration.x, bf.Acceleration.y, bf.Acceleration.z},
{bf.RotationRate.x, bf.RotationRate.y, bf.RotationRate.z},
{bf.MagneticField.x, bf.MagneticField.y, bf.MagneticField.z},
bf.Temperature,
bf.TimeDelta
};
BodyFrame(ptr, &mbf);
}
}
void *ptr;
void (*BodyFrame)(void *ptr, struct MessageBodyFrame *msg);
};
RustMessageHandler* OVR_MessageHandler(void *_ptr, void (*_BodyFrame)(void *ptr, struct MessageBodyFrame *msg))
{
return new RustMessageHandler(_ptr, _BodyFrame);
}
void* OVR_MessageHandler_move_ptr(RustMessageHandler* mh)
{
void *ptr = mh->ptr;
mh->ptr = NULL;
return ptr;
}
void OVR_MessageHandler_drop(RustMessageHandler* mh)
{
delete mh;
}
void OVR_system_init(void)
{
OVR::System::Init(OVR::Log::ConfigureDefaultLog(OVR::LogMask_All));
@ -44,12 +97,17 @@ extern "C"
return OVR::DeviceManager::Create();
}
void OVR_DeviceManager_drop(OVR::DeviceManager *dm)
{
delete dm;
}
OVR::HMDDevice* OVR_DeviceManager_EnumerateDevices(OVR::DeviceManager* pManager)
{
return pManager->EnumerateDevices<OVR::HMDDevice>().CreateDevice();
}
struct HMDInfoC OVR_HDMDevice_GetDeviceInfo(OVR::HMDDevice* pHMD)
struct HMDInfoC OVR_HMDDevice_GetDeviceInfo(OVR::HMDDevice* pHMD)
{
OVR::HMDInfo hmd;
struct HMDInfoC out_hmd;
@ -73,11 +131,21 @@ extern "C"
return out_hmd;
}
OVR::SensorDevice* OVR_HDMDevice_GetSensor(OVR::HMDDevice* pHMD)
OVR::SensorDevice* OVR_HMDDevice_GetSensor(OVR::HMDDevice* pHMD)
{
return pHMD->GetSensor();
}
void OVR_SensorDevice_drop(OVR::SensorDevice* sd)
{
delete sd;
}
void OVR_SensorDevice_SetMessageHandler(OVR::SensorDevice* sensor, RustMessageHandler* mh)
{
sensor->SetMessageHandler(mh);
}
OVR::SensorFusion* OVR_SensorFusion(OVR::HMDDevice* pHMD)
{
OVR::SensorFusion* SFusion = new OVR::SensorFusion;
@ -268,73 +336,22 @@ extern "C"
return (*SFusion).AttachToSensor(pSensor);
}
unsigned OVR_HMDInfo_GetScreenHResolution(OVR::HMDInfo* info)
void OVR_SensorFusion_OnMessage(OVR::SensorFusion* SFusion, const MessageBodyFrame *msg)
{
return info->HResolution;
OVR::MessageBodyFrame sensor(NULL);
sensor.TimeDelta = msg->TimeDelta;
sensor.Temperature = msg->Temperature;
sensor.Acceleration = OVR::Vector3f(msg->Acceleration.x, msg->Acceleration.y, msg->Acceleration.z);
sensor.RotationRate = OVR::Vector3f(msg->RotationRate.x, msg->RotationRate.y, msg->RotationRate.z);
sensor.MagneticField = OVR::Vector3f(msg->MagneticField.x, msg->MagneticField.y, msg->MagneticField.z);
SFusion->OnMessage(sensor);
}
unsigned OVR_HMDInfo_GetScreenVResolution(OVR::HMDInfo* info)
void OVR_SensorFusion_drop(OVR::SensorFusion *sf)
{
return info->VResolution;
}
float OVR_HMDInfo_GetHScreenSize(OVR::HMDInfo* info)
{
return info->HScreenSize;
}
float OVR_HMDInfo_GetVScreenSize(OVR::HMDInfo* info)
{
return info->VScreenSize;
}
float OVR_HMDInfo_GetVScreenCenter(OVR::HMDInfo* info)
{
return info->VScreenCenter;
}
float OVR_HMDInfo_GetEyeToScreenDistance(OVR::HMDInfo* info)
{
return info->EyeToScreenDistance;
}
float OVR_HMDInfo_GetLensSeparationDistance(OVR::HMDInfo* info)
{
return info->LensSeparationDistance;
}
float OVR_HMDInfo_GetInterpupillaryDistance(OVR::HMDInfo* info)
{
return info->InterpupillaryDistance;
}
float OVR_HMDInfo_GetDistortionK(OVR::HMDInfo* info, int idx)
{
return info->DistortionK[idx];
}
float OVR_HMDInfo_GetChromaAbCorrection(OVR::HMDInfo* info, int idx)
{
return info->ChromaAbCorrection[idx];
}
unsigned OVR_HMDInfo_GetDesktopX(OVR::HMDInfo* info)
{
return info->HResolution;
}
unsigned OVR_HMDInfo_GetDesktopY(OVR::HMDInfo* info)
{
return info->DesktopY;
}
char* OVR_HMDInfo_GetDisplayDeviceName(OVR::HMDInfo* info)
{
return info->DisplayDeviceName;
}
long OVR_HMDInfo_GetDisplayId(OVR::HMDInfo* info)
{
return info->DisplayId;
delete sf;
}
}