glemu 0.1.1

WebGL (via web_sys) to GL shims for Rust, based on Emscripten's GL emulation layer
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

use crate::state::ContextState;
use crate::types::ContextId;
use std::cell::{Cell, RefCell};
use std::collections::HashMap;
use web_sys::WebGl2RenderingContext as Gl;

thread_local! {
    static GL_CONTEXTS: RefCell<HashMap<ContextId, ContextState>> = RefCell::new(HashMap::new());
    static GL_CURRENT: Cell<Option<ContextId>> = const { Cell::new(None) };
    static GL_NEXT_CONTEXT_ID: Cell<u32> = const { Cell::new(1) };
}

pub fn register_gl_context(gl: Gl) -> ContextId {
    let context_id = GL_NEXT_CONTEXT_ID.with(|next| {
        let raw = next.get();
        next.set(raw.checked_add(1).expect("context id overflowed"));
        ContextId::new(raw).expect("context ids start at one")
    });

    GL_CONTEXTS.with(|contexts| {
        contexts
            .borrow_mut()
            .insert(context_id, ContextState::new(gl));
    });
    GL_CURRENT.with(|current| current.set(Some(context_id)));

    context_id
}

pub fn set_gl_context(context_id: ContextId) -> bool {
    let exists = GL_CONTEXTS.with(|contexts| contexts.borrow().contains_key(&context_id));
    if exists {
        GL_CURRENT.with(|current| current.set(Some(context_id)));
    }
    exists
}

pub fn drop_gl_context(context_id: ContextId) -> bool {
    let removed = GL_CONTEXTS.with(|contexts| contexts.borrow_mut().remove(&context_id));
    if removed.is_some() {
        GL_CURRENT.with(|current| {
            if current.get() == Some(context_id) {
                current.set(None);
            }
        });
    }
    removed.is_some()
}

pub fn current_context_id() -> Option<ContextId> {
    GL_CURRENT.with(Cell::get)
}

pub(crate) fn has_gl_context(context_id: ContextId) -> bool {
    GL_CONTEXTS.with(|contexts| contexts.borrow().contains_key(&context_id))
}

pub(crate) fn with_context<R>(
    context_id: ContextId,
    f: impl FnOnce(&ContextState) -> R,
) -> Option<R> {
    GL_CONTEXTS.with(|contexts| contexts.borrow().get(&context_id).map(f))
}

pub(crate) fn with_context_mut<R>(
    context_id: ContextId,
    f: impl FnOnce(&mut ContextState) -> R,
) -> Option<R> {
    GL_CONTEXTS.with(|contexts| contexts.borrow_mut().get_mut(&context_id).map(f))
}

pub(crate) fn with_current_context_mut<R>(f: impl FnOnce(&mut ContextState) -> R) -> Option<R> {
    let context_id = current_context_id()?;
    with_context_mut(context_id, f)
}