fbxcel-dom 0.0.10

FBX DOM library
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

//! Primitive types.

use std::convert::TryFrom;

use anyhow::{bail, Error};

use crate::v7400::object::property::{loaders::PrimitiveLoader, LoadProperty, PropertyHandle};

/// Texture wrap mode.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum WrapMode {
    /// Repeat.
    Repeat,
    /// Clamp to edge.
    Clamp,
}

impl TryFrom<i32> for WrapMode {
    type Error = Error;

    fn try_from(v: i32) -> Result<Self, Self::Error> {
        match v {
            0 => Ok(WrapMode::Repeat),
            1 => Ok(WrapMode::Clamp),
            v => bail!("Unexpected `WrapMode` value: {:?}", v),
        }
    }
}

/// `WrapMode` property loader.
#[derive(Default, Debug, Clone, Copy)]
pub(crate) struct WrapModeLoader;

impl<'a> LoadProperty<'a> for WrapModeLoader {
    type Value = WrapMode;
    type Error = Error;

    fn expecting(&self) -> String {
        "`i32` value as wrap mode".into()
    }

    fn load(self, node: &PropertyHandle<'a>) -> Result<Self::Value, Self::Error> {
        if node.data_type()? != "enum" {
            bail!(
                "Unexpected data type: expected \"enum\", but got {:?}",
                node.data_type()
            );
        }
        node.load_value(PrimitiveLoader::<i32>::new())
            .and_then(TryFrom::try_from)
    }
}

/// Texture blend mode.
///
/// See
/// <http://help.autodesk.com/cloudhelp/2019/ENU/FBX-Developer-Help/cpp_ref/class_fbx_texture.html#ae712bb955e55f00dc24eb98c3686dd5a>.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlendMode {
    /// Transparent depending on alpha settings.
    Translucent,
    /// Additive.
    Additive,
    /// Multiply.
    Modulate,
    /// Multiply 2.
    Modulate2,
    /// Opaque.
    Over,
}

impl TryFrom<i32> for BlendMode {
    type Error = Error;

    fn try_from(v: i32) -> Result<Self, Self::Error> {
        match v {
            0 => Ok(BlendMode::Translucent),
            1 => Ok(BlendMode::Additive),
            2 => Ok(BlendMode::Modulate),
            3 => Ok(BlendMode::Modulate2),
            4 => Ok(BlendMode::Over),
            v => bail!("Unexpected `BlendMode` value: {:?}", v),
        }
    }
}

/// `BlendMode` property loader.
#[derive(Default, Debug, Clone, Copy)]
pub(crate) struct BlendModeLoader;

impl<'a> LoadProperty<'a> for BlendModeLoader {
    type Value = BlendMode;
    type Error = Error;

    fn expecting(&self) -> String {
        "`i32` value as blend mode".into()
    }

    fn load(self, node: &PropertyHandle<'a>) -> Result<Self::Value, Self::Error> {
        if node.data_type()? != "enum" {
            bail!(
                "Unexpected data type: expected \"enum\", but got {:?}",
                node.data_type()
            );
        }
        node.load_value(PrimitiveLoader::<i32>::new())
            .and_then(TryFrom::try_from)
    }
}