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

use agents::app::{App, State};

use anyhow::Result;
use draw2d::{
    camera::{default_camera_controls, OrthoCamera},
    graphics::{
        ext::TextureLoader,
        layer::{Batch, LayerHandle},
        texture_atlas::{TextureAtlas, TextureHandle},
        vertex::Vertex2d,
        Graphics,
    },
};
use glfw::Window;

struct Demo {
    texture: TextureHandle,
    layer: LayerHandle,
    camera: OrthoCamera,
}

impl Demo {
    fn new(window: &mut glfw::Window, graphics: &mut Graphics) -> Result<Self> {
        let (w, h) = window.get_size();
        Ok(Self {
            texture: graphics.add_texture(
                graphics.read_texture_file("assets/example.png")?,
            )?,
            layer: graphics.add_layer_to_top(),
            camera: OrthoCamera::with_viewport(w as f32, w as f32 / h as f32),
        })
    }
}

impl State for Demo {
    fn init(&mut self, _w: &mut Window, graphics: &mut Graphics) -> Result<()> {
        let mut quad = Batch::empty();
        quad.texture_handle = self.texture;

        let size = 200.0;
        quad.vertices.extend_from_slice(&[
            // top left
            Vertex2d {
                pos: [-size, size],
                uv: [0.0, 0.0],
                ..Default::default()
            },
            // top right
            Vertex2d {
                pos: [size, size],
                uv: [1.0, 0.0],
                ..Default::default()
            },
            // bottom right
            Vertex2d {
                pos: [size, -size],
                uv: [1.0, 1.0],
                ..Default::default()
            },
            // top left
            Vertex2d {
                pos: [-size, size],
                uv: [0.0, 0.0],
                ..Default::default()
            },
            // bottom right
            Vertex2d {
                pos: [size, -size],
                uv: [1.0, 1.0],
                ..Default::default()
            },
            // bottom left
            Vertex2d {
                pos: [-size, -size],
                uv: [0.0, 1.0],
                ..Default::default()
            },
        ]);

        let layer = graphics.get_layer_mut(&self.layer);
        layer.set_projection(self.camera.as_matrix());
        layer.push_batch(quad);

        Ok(())
    }

    fn handle_event(
        &mut self,
        window_event: &glfw::WindowEvent,
        _window: &mut glfw::Window,
        graphics: &mut Graphics,
    ) -> Result<()> {
        if default_camera_controls(&mut self.camera, &window_event) {
            graphics
                .get_layer_mut(&self.layer)
                .set_projection(self.camera.as_matrix());
        }
        Ok(())
    }
}

fn main() -> Result<()> {
    App::new(Demo::new)?.main_loop()
}