ux-dx 0.2.1

3D Graphics Primitives for Angular Rust
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

use crate::glyph::{ab_glyph, GlyphBrushBuilder, Section, Text};
use dx::gles::{core30::gl, enums::*};
use std::error::Error;

fn main() -> Result<(), Box<dyn Error>> {
    env_logger::init();

    // Open window and create a surface
    let event_loop = glutin::event_loop::EventLoop::new();

    let window_builder = glutin::window::WindowBuilder::new().with_resizable(false);

    let context = glutin::ContextBuilder::new()
        .with_vsync(true)
        .build_windowed(window_builder, &event_loop)
        .expect("Open window");

    let context = context.make_current().expect("Make OpenGL context current");

    let mut size = context.window().inner_size();

    // Initialize OpenGL
    let gl = glow::Context::from_loader_function(|s| context.get_proc_address(s) as *const _);

    // Prepare glyph_brush
    let inconsolata = ab_glyph::FontArc::try_from_slice(include_bytes!("Inconsolata-Regular.ttf"))?;

    let mut glyph_brush = GlyphBrushBuilder::using_font(inconsolata).build(&gl);

    // Render loop
    context.window().request_redraw();

    // Enable auto-conversion from/to sRGB
    gl::enable(glow::FRAMEBUFFER_SRGB);

    // Enable alpha blending
    gl::enable(glow::BLEND);
    gl::blend_func(glow::SRC_ALPHA, glow::ONE_MINUS_SRC_ALPHA);

    gl::clear_color(0.4, 0.4, 0.4, 1.0);

    event_loop.run(move |event, _, control_flow| {
        match event {
            glutin::event::Event::WindowEvent {
                event: glutin::event::WindowEvent::CloseRequested,
                ..
            } => *control_flow = glutin::event_loop::ControlFlow::Exit,
            glutin::event::Event::WindowEvent {
                event: glutin::event::WindowEvent::Resized(new_size),
                ..
            } => {
                context.resize(new_size);

                gl::viewport(0, 0, new_size.width as _, new_size.height as _);

                size = new_size;
            }
            glutin::event::Event::RedrawRequested { .. } => {
                gl::clear(GL_COLOR_BUFFER_BIT);

                glyph_brush.queue(Section {
                    screen_position: (30.0, 30.0),
                    bounds: (size.width as f32, size.height as f32),
                    text: vec![Text::default()
                        .with_text("Hello glow_glyph!")
                        .with_color([0.0, 0.0, 0.0, 1.0])
                        .with_scale(40.0)],
                    ..Section::default()
                });

                glyph_brush.queue(Section {
                    screen_position: (30.0, 90.0),
                    bounds: (size.width as f32, size.height as f32),
                    text: vec![Text::default()
                        .with_text("Hello glow_glyph!")
                        .with_color([1.0, 1.0, 1.0, 1.0])
                        .with_scale(40.0)],
                    ..Section::default()
                });

                // Draw the text!
                glyph_brush.draw_queued(size.width, size.height).expect("Draw queued");

                context.swap_buffers().expect("Swap buffers");
            }
            _ => {
                *control_flow = glutin::event_loop::ControlFlow::Wait;
            }
        }
    })
}