dunge 0.3.11

Typesafe and portable 3d render 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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! Shader group types and traits.

use {
    crate::{
        StorageValue,
        buffer::Sampler,
        sl::{Define, Global, GlobalOut, Ret},
        storage::{Storage, Uniform},
        types::{self, MemberData, MemberType, Space},
        value::UniformValue,
    },
    dunge_shade::group::Group,
};

pub use dunge_shade::group::{Projection, Take};

/// Describes a group member type projection.
///
/// The trait is sealed because the derive macro relies on no new types being used.
pub trait MemberProjection: s::Sealed {
    const MEMBER: MemberData;
    type Field;
    fn member_projection(id: u32, binding: u32, out: GlobalOut) -> Self::Field;
}

impl<M> s::Sealed for &M where M: s::Sealed {}

impl<M> MemberProjection for &M
where
    M: MemberProjection,
{
    const MEMBER: MemberData = M::MEMBER;
    type Field = M::Field;

    fn member_projection(id: u32, binding: u32, out: GlobalOut) -> Self::Field {
        M::member_projection(id, binding, out)
    }
}

impl<V> s::Sealed for Uniform<V> where V: UniformValue<Type: types::Member> {}

impl<V> MemberProjection for Uniform<V>
where
    V: UniformValue<Type: types::Member>,
{
    const MEMBER: MemberData = MemberData {
        ty: <V::Type as types::Member>::MEMBER_TYPE,
        space: Space::Uniform,
    };

    type Field = Ret<Global, V::GlobalType>;

    fn member_projection(id: u32, binding: u32, out: GlobalOut) -> Self::Field {
        Global::new(id, binding, out)
    }
}

impl<V> Group for Uniform<V>
where
    Self: MemberProjection<Field: Projection>,
{
    type Projection = <Self as MemberProjection>::Field;
    const DEF: Define<MemberData> = Define::new(&[Self::MEMBER]);
}

impl<V, M> s::Sealed for Storage<V, M>
where
    V: StorageValue + ?Sized,
    M: types::Mutability,
{
}

impl<V, M> MemberProjection for Storage<V, M>
where
    V: StorageValue<Type: types::Member> + ?Sized,
    M: types::Mutability,
{
    const MEMBER: MemberData = MemberData {
        ty: <V::Type as types::Member>::MEMBER_TYPE,
        space: Space::Storage {
            mutable: M::MUTABLE,
        },
    };

    type Field = Ret<Global<M>, V::GlobalType>;

    fn member_projection(id: u32, binding: u32, out: GlobalOut) -> Self::Field {
        Global::new(id, binding, out)
    }
}

impl<V, M> Group for Storage<V, M>
where
    V: ?Sized,
    Self: MemberProjection<Field: Projection>,
{
    type Projection = <Self as MemberProjection>::Field;
    const DEF: Define<MemberData> = Define::new(&[Self::MEMBER]);
}

#[derive(Clone)]
pub struct BoundTexture(pub(crate) wgpu::TextureView);

impl s::Sealed for BoundTexture {}

impl MemberProjection for BoundTexture {
    const MEMBER: MemberData = MemberData {
        ty: MemberType::Tx2df,
        space: Space::Handle,
    };

    type Field = Ret<Global, types::Texture2d<f32>>;

    fn member_projection(id: u32, binding: u32, out: GlobalOut) -> Self::Field {
        Global::new(id, binding, out)
    }
}

impl Group for BoundTexture {
    type Projection = <Self as MemberProjection>::Field;
    const DEF: Define<MemberData> = Define::new(&[Self::MEMBER]);
}

impl s::Sealed for Sampler {}

impl MemberProjection for Sampler {
    const MEMBER: MemberData = MemberData {
        ty: MemberType::Sampl,
        space: Space::Handle,
    };

    type Field = Ret<Global, types::Sampler>;

    fn member_projection(id: u32, binding: u32, out: GlobalOut) -> Self::Field {
        Global::new(id, binding, out)
    }
}

impl Group for Sampler {
    type Projection = <Self as MemberProjection>::Field;
    const DEF: Define<MemberData> = Define::new(&[Self::MEMBER]);
}

mod s {
    pub trait Sealed {}
}