rust-gl 0.1.7

Rust wrapper around webgl.
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

use super::GL;
use std::rc::Rc;

pub mod base;
pub use base::*;

pub mod gltype;
pub use gltype::*;
use web_sys::{WebGlActiveInfo, WebGlProgram, WebGlUniformLocation};

type Index = WebGlUniformLocation;

#[derive(Debug, PartialEq, Eq)]
pub enum Member {
    Member(Option<Rc<Member>>, String),
    Index(Rc<Member>, usize),
}

use core::fmt;
impl fmt::Display for Member {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
        match self {
            Member::Member(prev, name) => {
                if let Some(x) = prev {
                    (write! {fmt, "{}.", x})?;
                }
                write! {fmt, "{}", name}
            }
            Member::Index(prev, index) => write! {fmt, "{}[{}]", prev, index},
        }
    }
}

use std::collections::HashMap;

pub trait ToUniform {
    type Output;
    type Error;
    fn to_uniform(
        self,
        gl: Rc<GL>,
        program: &WebGlProgram,
        member: Option<Rc<Member>>,
        map: &mut HashMap<String, WebGlActiveInfo>,
    ) -> Result<Self::Output, Self::Error>;
}

pub trait Uniform<T> {
    fn index(&self) -> &Index;
    fn swap(&mut self, value: T) -> T;
}

use super::NoneError;
impl ToUniform for () {
    type Output = ();
    type Error = NoneError;
    fn to_uniform(
        self,
        _: Rc<GL>,
        _: &WebGlProgram,
        _: Option<Rc<Member>>,
        _: &mut HashMap<String, WebGlActiveInfo>,
    ) -> Result<Self::Output, Self::Error> {
        Ok(())
    }
}