webgl 0.1.0

wasm32 first cross-platform webgl
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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

#![feature(nll)]
#![recursion_limit = "128"]
/* common */
extern crate glenum;

/* wasm32 */
#[cfg(target_arch = "wasm32")]
#[macro_use]
extern crate stdweb;

#[cfg(target_arch = "wasm32")]
mod webgl;
#[cfg(target_arch = "wasm32")]
pub use webgl::*;

/* other than wasm32 */
#[cfg(not(target_arch = "wasm32"))]
extern crate gl;
#[cfg(not(target_arch = "wasm32"))]
mod webgl_native;
#[cfg(not(target_arch = "wasm32"))]
pub use webgl_native::*;

pub use glenum::*;

pub mod common {

    use glenum::*;
    use std::ops::Deref;

    #[cfg(not(target_arch = "wasm32"))]
    use webgl_native::*;
    #[cfg(target_arch = "wasm32")]
    use webgl::*;

    #[derive(Debug, PartialEq)]
    pub struct GLContext {
        pub reference: Reference,
    }

    #[derive(Debug)]
    pub struct WebGLRenderingContext {
        pub common: GLContext,
    }

    #[derive(Debug)]
    pub struct WebGL2RenderingContext {
        pub common: GLContext,
    }

    pub trait AsReference {
        fn as_reference(&self) -> &Reference;
    }

    impl AsReference for GLContext {
        fn as_reference(&self) -> &Reference {
            &self.reference
        }
    }

    impl AsReference for WebGLRenderingContext {
        fn as_reference(&self) -> &Reference {
            &self.common.as_reference()
        }
    }

    impl AsReference for WebGL2RenderingContext {
        fn as_reference(&self) -> &Reference {
            &self.common.as_reference()
        }
    }

    impl Deref for WebGLRenderingContext {
        type Target = GLContext;
        fn deref(&self) -> &GLContext {
            &self.common
        }
    }

    impl Deref for WebGL2RenderingContext {
        type Target = GLContext;
        fn deref(&self) -> &GLContext {
            &self.common
        }
    }

    #[derive(Debug)]
    pub struct WebGLBuffer(pub Reference);

    impl Deref for WebGLBuffer {
        type Target = Reference;
        fn deref(&self) -> &Self::Target {
            &self.0
        }
    }

    #[derive(Debug)]
    pub struct WebGLShader(pub Reference);
    impl Deref for WebGLShader {
        type Target = Reference;
        fn deref(&self) -> &Self::Target {
            &self.0
        }
    }

    #[derive(Debug, PartialEq)]
    pub struct WebGLProgram(pub Reference);
    impl Deref for WebGLProgram {
        type Target = Reference;
        fn deref(&self) -> &Self::Target {
            &self.0
        }
    }

    #[derive(Debug)]
    pub struct WebGLActiveInfo {
        reference: Reference,
        name: String,
        size: u32,
        kind: UniformType,
    }

    impl WebGLActiveInfo {
        pub fn new<T: Into<String>>(
            name: T,
            size: u32,
            kind: UniformType,
            reference: Reference,
        ) -> WebGLActiveInfo {
            let nam = name.into();
            WebGLActiveInfo {
                reference,
                name: nam,
                size,
                kind,
            }
        }
    }

    #[derive(Debug, PartialEq)]
    pub struct WebGLTexture(pub Reference);
    impl Deref for WebGLTexture {
        type Target = Reference;
        fn deref(&self) -> &Self::Target {
            &self.0
        }
    }

    #[derive(Debug)]
    pub struct WebGLVertexArray(pub Reference);
    impl Deref for WebGLVertexArray {
        type Target = Reference;
        fn deref(&self) -> &Self::Target {
            &self.0
        }
    }

    #[derive(Debug, PartialEq)]
    pub struct WebGLUniformLocation(pub Reference);
    impl Deref for WebGLUniformLocation {
        type Target = Reference;
        fn deref(&self) -> &Self::Target {
            &self.0
        }
    }

}

pub use common::*;