servo-webxr-api 0.1.0

A safe Rust API that provides a way to interact with virtual reality and augmented reality devices and integration with OpenXR. The API is inspired by the WebXR Device API (https://www.w3.org/TR/webxr/) but adapted to Rust design patterns.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */

use euclid::RigidTransform3D;
use malloc_size_of_derive::MallocSizeOf;
use serde::{Deserialize, Serialize};

use crate::Native;

#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
pub struct HandSpace;

#[derive(Clone, Debug, Default, Serialize, Deserialize, MallocSizeOf)]
pub struct Hand<J> {
    pub wrist: Option<J>,
    pub thumb_metacarpal: Option<J>,
    pub thumb_phalanx_proximal: Option<J>,
    pub thumb_phalanx_distal: Option<J>,
    pub thumb_phalanx_tip: Option<J>,
    pub index: Finger<J>,
    pub middle: Finger<J>,
    pub ring: Finger<J>,
    pub little: Finger<J>,
}

#[derive(Clone, Debug, Default, Serialize, Deserialize, MallocSizeOf)]
pub struct Finger<J> {
    pub metacarpal: Option<J>,
    pub phalanx_proximal: Option<J>,
    pub phalanx_intermediate: Option<J>,
    pub phalanx_distal: Option<J>,
    pub phalanx_tip: Option<J>,
}

#[derive(Clone, Copy, Debug, Serialize, Deserialize, MallocSizeOf)]
pub struct JointFrame {
    pub pose: RigidTransform3D<f32, HandSpace, Native>,
    pub radius: f32,
}

impl Default for JointFrame {
    fn default() -> Self {
        Self {
            pose: RigidTransform3D::identity(),
            radius: 0.,
        }
    }
}

impl<J> Hand<J> {
    pub fn map<R>(&self, map: impl (Fn(&Option<J>, Joint) -> Option<R>) + Copy) -> Hand<R> {
        Hand {
            wrist: map(&self.wrist, Joint::Wrist),
            thumb_metacarpal: map(&self.thumb_metacarpal, Joint::ThumbMetacarpal),
            thumb_phalanx_proximal: map(&self.thumb_phalanx_proximal, Joint::ThumbPhalanxProximal),
            thumb_phalanx_distal: map(&self.thumb_phalanx_distal, Joint::ThumbPhalanxDistal),
            thumb_phalanx_tip: map(&self.thumb_phalanx_tip, Joint::ThumbPhalanxTip),
            index: self.index.map(|f, j| map(f, Joint::Index(j))),
            middle: self.middle.map(|f, j| map(f, Joint::Middle(j))),
            ring: self.ring.map(|f, j| map(f, Joint::Ring(j))),
            little: self.little.map(|f, j| map(f, Joint::Little(j))),
        }
    }

    pub fn get(&self, joint: Joint) -> Option<&J> {
        match joint {
            Joint::Wrist => self.wrist.as_ref(),
            Joint::ThumbMetacarpal => self.thumb_metacarpal.as_ref(),
            Joint::ThumbPhalanxProximal => self.thumb_phalanx_proximal.as_ref(),
            Joint::ThumbPhalanxDistal => self.thumb_phalanx_distal.as_ref(),
            Joint::ThumbPhalanxTip => self.thumb_phalanx_tip.as_ref(),
            Joint::Index(f) => self.index.get(f),
            Joint::Middle(f) => self.middle.get(f),
            Joint::Ring(f) => self.ring.get(f),
            Joint::Little(f) => self.little.get(f),
        }
    }
}

impl<J> Finger<J> {
    pub fn map<R>(&self, map: impl (Fn(&Option<J>, FingerJoint) -> Option<R>) + Copy) -> Finger<R> {
        Finger {
            metacarpal: map(&self.metacarpal, FingerJoint::Metacarpal),
            phalanx_proximal: map(&self.phalanx_proximal, FingerJoint::PhalanxProximal),
            phalanx_intermediate: map(&self.phalanx_intermediate, FingerJoint::PhalanxIntermediate),
            phalanx_distal: map(&self.phalanx_distal, FingerJoint::PhalanxDistal),
            phalanx_tip: map(&self.phalanx_tip, FingerJoint::PhalanxTip),
        }
    }

    pub fn get(&self, joint: FingerJoint) -> Option<&J> {
        match joint {
            FingerJoint::Metacarpal => self.metacarpal.as_ref(),
            FingerJoint::PhalanxProximal => self.phalanx_proximal.as_ref(),
            FingerJoint::PhalanxIntermediate => self.phalanx_intermediate.as_ref(),
            FingerJoint::PhalanxDistal => self.phalanx_distal.as_ref(),
            FingerJoint::PhalanxTip => self.phalanx_tip.as_ref(),
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub enum FingerJoint {
    Metacarpal,
    PhalanxProximal,
    PhalanxIntermediate,
    PhalanxDistal,
    PhalanxTip,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub enum Joint {
    Wrist,
    ThumbMetacarpal,
    ThumbPhalanxProximal,
    ThumbPhalanxDistal,
    ThumbPhalanxTip,
    Index(FingerJoint),
    Middle(FingerJoint),
    Ring(FingerJoint),
    Little(FingerJoint),
}