photonic 0.1.1

Dynamic light controller and animator
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

use std::ops::Deref;

use anyhow::Result;

use crate::attr::{Attr, AttrValue, Bounded, Bounds};
use crate::decl::{BoundAttrDecl, FreeAttrDecl};
use crate::{scene, AttrBuilder};

#[derive(Debug)]
pub struct FixedAttr<V>(V)
where V: AttrValue;

impl<V> Attr<V> for FixedAttr<V>
where V: AttrValue
{
    fn update(&mut self, _ctx: &scene::RenderContext) -> V {
        return self.0;
    }
}

impl<V> Deref for FixedAttr<V>
where V: AttrValue
{
    type Target = V;

    fn deref(&self) -> &Self::Target {
        return &self.0;
    }
}

#[derive(Debug)]
pub struct FixedAttrDecl<V>(V)
where V: AttrValue;

impl<V> FreeAttrDecl<V> for FixedAttrDecl<V>
where V: AttrValue
{
    const KIND: &'static str = "fixed";

    type Attr = FixedAttr<V>;

    fn materialize(self, _builder: &mut AttrBuilder) -> Result<Self::Attr> {
        return Ok(FixedAttr(self.0));
    }
}

impl<V> BoundAttrDecl<V> for FixedAttrDecl<V>
where V: AttrValue + Bounded
{
    const KIND: &'static str = "fixed";

    type Attr = FixedAttr<V>;

    fn materialize(self, bounds: Bounds<V>, _builder: &mut AttrBuilder) -> Result<Self::Attr> {
        let value = bounds.ensure(self.0)?;
        return Ok(FixedAttr(value));
    }
}

pub trait AsFixedAttr<V>
where V: AttrValue
{
    fn fixed(self) -> FixedAttrDecl<V>;
}

impl<V, T> AsFixedAttr<V> for T
where V: AttrValue + From<Self>
{
    fn fixed(self) -> FixedAttrDecl<V> {
        return FixedAttrDecl(self.into());
    }
}