Struct EventLoop

Source

pub struct EventLoop {
    pub event_handler: EventHandler,
    pub window: PWindow,
    pub ui: Imgui,
    pub glfw: Glfw,
    pub now: Instant,
    pub dt: f32,
    pub time: f32,
    pub timescale: f32,
    /* private fields */
}

Fields§

§event_handler: EventHandler§window: PWindow§ui: Imgui§glfw: Glfw§now: Instant§dt: f32§time: f32§timescale: f32

Implementations§

Source §

impl EventLoop

Source

pub fn new(w: u32, h: u32) -> Self

Examples found in repository ?

examples/simple2d.rs (line 9)

8fn main() {
9    let mut el = EventLoop::new(600, 600);
10    let mut renderer = Renderer::new();
11
12    /* default projection type is perspective */
13    renderer.camera.set_projection(ProjectionType::Orthographic);
14    renderer.add_light(Light { position: vec3(0.0, 0.0, 1.0), color: Vec3::ONE })
15        .unwrap();
16
17    /* we'll represent our player using a quad */
18    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
19        .unwrap();
20
21    while !el.window.should_close() {
22        el.update();
23
24        /* we can modify the player by indexing into it in the renderer's meshes */
25        let player = &mut renderer.meshes[player_handle];
26        player.color = vec3(0.5, 0.0, el.time.sin());
27        move_player(&el, &mut player.position);
28    
29        renderer.camera.update(Vec3::ZERO, &el);
30    
31        let frame = el.ui.frame(&mut el.window);
32        frame.text("hello, world! this is imgui");
33
34        unsafe {
35            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
36            ClearColor(0.1, 0.2, 0.3, 1.0);
37            
38            renderer.draw();
39            el.ui.draw();
40        }
41    }
42}

More examples

Hide additional examples

examples/ik.rs (line 8)

7fn main() {
8    let mut el = EventLoop::new(600, 600);
9    let mut renderer = Renderer::new();
10
11    unsafe {
12        Enable(DEPTH_TEST);
13    }
14
15    /* default projection type is perspective */
16    renderer.camera.set_projection(ProjectionType::Orthographic);
17    renderer.add_light(Light { position: vec3(0.0, 0.0, 3.0), color: Vec3::ONE })
18        .unwrap();
19
20    /* we'll represent our player using a quad */
21    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
22        .unwrap();
23
24    renderer.meshes[player_handle].position = Vec3::Z * 2.0; // so the player stays in front of everything
25
26    let mut segments = vec![];
27    for _ in 0..128 {
28        let new_segment = Segment::new(vec3(0.0, 0.0, 0.0), 0.05, &mut renderer);
29
30        segments.push(new_segment);
31    }
32
33    renderer.meshes[segments[0].handle].hidden = true;
34    renderer.meshes[segments[segments.len()-1].handle].hidden = true;
35
36    renderer.meshes[player_handle].hidden = true;
37    
38
39    segments[0].pos = Vec3::new(-2.0, -2.0, 0.0);
40
41    let mut clamped_pos;
42    let mut player_vel;
43    let mut old_pos = Vec3::ZERO;
44
45    while !el.window.should_close() {
46        el.update();
47        renderer.update();
48        
49        segments.iter_mut().for_each(|s| {
50            s.update(&mut renderer);
51        });
52        
53        let player = &mut renderer.meshes[player_handle];
54        let mp = el.event_handler.mouse_pos / el.event_handler.width * 2.0;
55        let clamped_player_pos = {
56            // clamped_pos = lerp(clamped_pos, player.position, 0.1);
57            clamped_pos = player.position;
58
59            vec3(clamped_pos.x, clamped_pos.y, 0.0)
60        };
61        fabrik(&mut segments, {
62            if el.event_handler.lmb {
63                clamped_player_pos + vec3(mp.x, mp.y, 0.0)
64            } else {
65                clamped_player_pos
66            }
67        }, 0.0, 2);
68
69        let first_segment_position = segments[0].pos;
70        let seg_amm = segments.len() as f32;
71        let distance = first_segment_position.distance(segments[segments.len()-1].pos);
72        let len = segments[0].length;
73        if distance > segments.len() as f32 * segments[0].length + segments[0].length {
74            segments[0].pos += ((clamped_player_pos - first_segment_position) / seg_amm) * len * f32::powf(distance, 2.3);
75        }
76
77        player_vel = player.position - old_pos;
78        old_pos = player.position;
79
80        player.color = vec3(0.5, 0.0, el.time.sin());
81        move_player(&el, &mut player.position);
82    
83        renderer.camera.update(lerp(renderer.camera.pos, player.position, 0.125), &el);
84        renderer.camera.mouse_callback(el.event_handler.mouse_pos, &el.window);
85
86        let frame = el.ui.frame(&mut el.window);
87        frame.text("Hello, world! This is imgui.");
88        frame.text(format!("p: {:.1}\nv: {:.3}", player.position, player_vel));
89
90        unsafe {
91            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
92            ClearColor(0.1, 0.2, 0.3, 1.0);
93            
94            renderer.draw();
95            el.ui.draw();
96        }
97    }
98}

Source

pub fn size(&self) -> Vec2

Source

pub fn update(&mut self)

Examples found in repository ?

examples/simple2d.rs (line 22)

8fn main() {
9    let mut el = EventLoop::new(600, 600);
10    let mut renderer = Renderer::new();
11
12    /* default projection type is perspective */
13    renderer.camera.set_projection(ProjectionType::Orthographic);
14    renderer.add_light(Light { position: vec3(0.0, 0.0, 1.0), color: Vec3::ONE })
15        .unwrap();
16
17    /* we'll represent our player using a quad */
18    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
19        .unwrap();
20
21    while !el.window.should_close() {
22        el.update();
23
24        /* we can modify the player by indexing into it in the renderer's meshes */
25        let player = &mut renderer.meshes[player_handle];
26        player.color = vec3(0.5, 0.0, el.time.sin());
27        move_player(&el, &mut player.position);
28    
29        renderer.camera.update(Vec3::ZERO, &el);
30    
31        let frame = el.ui.frame(&mut el.window);
32        frame.text("hello, world! this is imgui");
33
34        unsafe {
35            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
36            ClearColor(0.1, 0.2, 0.3, 1.0);
37            
38            renderer.draw();
39            el.ui.draw();
40        }
41    }
42}

More examples

Hide additional examples

examples/ik.rs (line 46)

7fn main() {
8    let mut el = EventLoop::new(600, 600);
9    let mut renderer = Renderer::new();
10
11    unsafe {
12        Enable(DEPTH_TEST);
13    }
14
15    /* default projection type is perspective */
16    renderer.camera.set_projection(ProjectionType::Orthographic);
17    renderer.add_light(Light { position: vec3(0.0, 0.0, 3.0), color: Vec3::ONE })
18        .unwrap();
19
20    /* we'll represent our player using a quad */
21    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
22        .unwrap();
23
24    renderer.meshes[player_handle].position = Vec3::Z * 2.0; // so the player stays in front of everything
25
26    let mut segments = vec![];
27    for _ in 0..128 {
28        let new_segment = Segment::new(vec3(0.0, 0.0, 0.0), 0.05, &mut renderer);
29
30        segments.push(new_segment);
31    }
32
33    renderer.meshes[segments[0].handle].hidden = true;
34    renderer.meshes[segments[segments.len()-1].handle].hidden = true;
35
36    renderer.meshes[player_handle].hidden = true;
37    
38
39    segments[0].pos = Vec3::new(-2.0, -2.0, 0.0);
40
41    let mut clamped_pos;
42    let mut player_vel;
43    let mut old_pos = Vec3::ZERO;
44
45    while !el.window.should_close() {
46        el.update();
47        renderer.update();
48        
49        segments.iter_mut().for_each(|s| {
50            s.update(&mut renderer);
51        });
52        
53        let player = &mut renderer.meshes[player_handle];
54        let mp = el.event_handler.mouse_pos / el.event_handler.width * 2.0;
55        let clamped_player_pos = {
56            // clamped_pos = lerp(clamped_pos, player.position, 0.1);
57            clamped_pos = player.position;
58
59            vec3(clamped_pos.x, clamped_pos.y, 0.0)
60        };
61        fabrik(&mut segments, {
62            if el.event_handler.lmb {
63                clamped_player_pos + vec3(mp.x, mp.y, 0.0)
64            } else {
65                clamped_player_pos
66            }
67        }, 0.0, 2);
68
69        let first_segment_position = segments[0].pos;
70        let seg_amm = segments.len() as f32;
71        let distance = first_segment_position.distance(segments[segments.len()-1].pos);
72        let len = segments[0].length;
73        if distance > segments.len() as f32 * segments[0].length + segments[0].length {
74            segments[0].pos += ((clamped_player_pos - first_segment_position) / seg_amm) * len * f32::powf(distance, 2.3);
75        }
76
77        player_vel = player.position - old_pos;
78        old_pos = player.position;
79
80        player.color = vec3(0.5, 0.0, el.time.sin());
81        move_player(&el, &mut player.position);
82    
83        renderer.camera.update(lerp(renderer.camera.pos, player.position, 0.125), &el);
84        renderer.camera.mouse_callback(el.event_handler.mouse_pos, &el.window);
85
86        let frame = el.ui.frame(&mut el.window);
87        frame.text("Hello, world! This is imgui.");
88        frame.text(format!("p: {:.1}\nv: {:.3}", player.position, player_vel));
89
90        unsafe {
91            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
92            ClearColor(0.1, 0.2, 0.3, 1.0);
93            
94            renderer.draw();
95            el.ui.draw();
96        }
97    }
98}

Source

pub fn is_key_down(&self, key: Key) -> bool

Examples found in repository ?

examples/ik.rs (line 177)

173fn move_player(el: &EventLoop, pos: &mut Vec3) {
174    let mut velocity = Vec3::ZERO; 
175    let mut speed = 1.5;
176
177    if el.is_key_down(Key::LeftShift) {
178        speed *= 1.5;
179    }
180
181    if el.is_key_down(Key::W) {
182        velocity.y+=speed;
183    }
184    if el.is_key_down(Key::S) {
185        velocity.y-=speed;
186    }
187    if el.is_key_down(Key::D) {
188        velocity.x+=speed;
189    }
190    if el.is_key_down(Key::A) {
191        velocity.x-=speed;
192    }
193
194    *pos += velocity * el.dt;
195}

More examples

Hide additional examples

examples/simple2d.rs (line 48)

44fn move_player(el: &EventLoop, pos: &mut Vec3) {
45    let mut velocity = Vec3::ZERO; 
46    let mut speed = 1.5;
47
48    if el.is_key_down(Key::LeftShift) {
49        speed *= 1.5;
50    }
51
52    if el.is_key_down(Key::W) {
53        velocity.y+=speed;
54    }
55    if el.is_key_down(Key::S) {
56        velocity.y-=speed;
57    }
58    if el.is_key_down(Key::D) {
59        velocity.x+=speed;
60    }
61    if el.is_key_down(Key::A) {
62        velocity.x-=speed;
63    }
64
65    *pos += velocity * el.dt;
66}

Source

pub fn is_key_up(&self, key: Key) -> bool

Source

pub fn set_fullscreen(&mut self, fullscreen: &mut bool)

Auto Trait Implementations§

§

impl !UnwindSafe for EventLoop

Blanket Implementations§

Source §

impl<T> Any for T
where T: 'static + ?Sized,

Source §

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

Source §

impl<T> Borrow<T> for T
where T: ?Sized,

Source §

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

Source §

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source §

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

Source §

impl<T> From<T> for T

Source §

fn from(t: T) -> T

Returns the argument unchanged.

Source §

impl<T, U> Into for T
where U: From<T>,

Source §

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source §

impl<T> IntoEither for T

Source §

fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §