tetra3 0.6.0

Rust implementation of Tetra3: Fast and robust star plate solver
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

//! rkyv wrappers for numeris types.
//!
//! These implement `ArchiveWith`/`SerializeWith`/`DeserializeWith` so that structs
//! containing `Matrix2<f32>` or `Quaternion<f32>` can `#[derive(rkyv::Archive, ...)]`
//! by annotating the field with `#[rkyv(with = WrapperType)]`.

use rkyv::with::{ArchiveWith, DeserializeWith, SerializeWith};
use rkyv::{Archive, Deserialize, Place, Serialize};

// ── Matrix2<f32> ↔ [[f32; 2]; 2] ───────────────────────────────────────────

/// rkyv wrapper: serializes `Matrix2<f32>` as `[[f32; 2]; 2]` (row-major).
pub struct AsMatrix2Array;

impl ArchiveWith<numeris::Matrix2<f32>> for AsMatrix2Array {
    type Archived = <[[f32; 2]; 2] as Archive>::Archived;
    type Resolver = <[[f32; 2]; 2] as Archive>::Resolver;

    fn resolve_with(
        field: &numeris::Matrix2<f32>,
        resolver: Self::Resolver,
        out: Place<Self::Archived>,
    ) {
        let arr = [
            [field[(0, 0)], field[(0, 1)]],
            [field[(1, 0)], field[(1, 1)]],
        ];
        arr.resolve(resolver, out);
    }
}

impl<S: rkyv::rancor::Fallible + ?Sized> SerializeWith<numeris::Matrix2<f32>, S> for AsMatrix2Array
where
    [[f32; 2]; 2]: Serialize<S>,
{
    fn serialize_with(
        field: &numeris::Matrix2<f32>,
        serializer: &mut S,
    ) -> Result<Self::Resolver, S::Error> {
        let arr = [
            [field[(0, 0)], field[(0, 1)]],
            [field[(1, 0)], field[(1, 1)]],
        ];
        arr.serialize(serializer)
    }
}

impl<D: rkyv::rancor::Fallible + ?Sized>
    DeserializeWith<<[[f32; 2]; 2] as Archive>::Archived, numeris::Matrix2<f32>, D>
    for AsMatrix2Array
where
    <[[f32; 2]; 2] as Archive>::Archived: Deserialize<[[f32; 2]; 2], D>,
{
    fn deserialize_with(
        field: &<[[f32; 2]; 2] as Archive>::Archived,
        deserializer: &mut D,
    ) -> Result<numeris::Matrix2<f32>, D::Error> {
        let arr: [[f32; 2]; 2] = field.deserialize(deserializer)?;
        Ok(numeris::Matrix2::new([
            [arr[0][0], arr[0][1]],
            [arr[1][0], arr[1][1]],
        ]))
    }
}

// ── Quaternion<f32> ↔ [f32; 4] ─────────────────────────────────────────

/// rkyv wrapper: serializes `Quaternion<f32>` as `[x, y, z, w]`.
pub struct AsQuatArray;

impl ArchiveWith<numeris::Quaternion<f32>> for AsQuatArray {
    type Archived = <[f32; 4] as Archive>::Archived;
    type Resolver = <[f32; 4] as Archive>::Resolver;

    fn resolve_with(
        field: &numeris::Quaternion<f32>,
        resolver: Self::Resolver,
        out: Place<Self::Archived>,
    ) {
        let arr = [field.x, field.y, field.z, field.w];
        arr.resolve(resolver, out);
    }
}

impl<S: rkyv::rancor::Fallible + ?Sized> SerializeWith<numeris::Quaternion<f32>, S>
    for AsQuatArray
where
    [f32; 4]: Serialize<S>,
{
    fn serialize_with(
        field: &numeris::Quaternion<f32>,
        serializer: &mut S,
    ) -> Result<Self::Resolver, S::Error> {
        let arr = [field.x, field.y, field.z, field.w];
        arr.serialize(serializer)
    }
}

impl<D: rkyv::rancor::Fallible + ?Sized>
    DeserializeWith<<[f32; 4] as Archive>::Archived, numeris::Quaternion<f32>, D>
    for AsQuatArray
where
    <[f32; 4] as Archive>::Archived: Deserialize<[f32; 4], D>,
{
    fn deserialize_with(
        field: &<[f32; 4] as Archive>::Archived,
        deserializer: &mut D,
    ) -> Result<numeris::Quaternion<f32>, D::Error> {
        let [x, y, z, w]: [f32; 4] = field.deserialize(deserializer)?;
        Ok(numeris::Quaternion::new(w, x, y, z))
    }
}