Struct pixel_engine::Engine

pub struct Engine {
    pub title: String,
    pub elapsed: f64,
    /* private fields */
}

Bone of the Engine, join everything;

Fields

title: String

Main title of the window, Window’s full title will be “Title - fps”

elapsed: f64

Time between current frame and last frame, usefull for movement’s calculations

Implementations

impl Engine

pub fn size(&self) -> Vu2d

Return the current Target size in pixel

Examples found in repository

src/engine/logic.rs (line 311)

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Engine")
            .field("title", &self.title)
            .field("size", &self.size())
            .field("scale", &self.size.2)
            .field("elapsed", &self.elapsed)
            .finish()
    }

src/engine/decals.rs (line 350)

    fn draw_explicit_decal<P: Into<Vf2d> + Copy>(
        &mut self,
        pos: [P; 4],
        uv: [P; 4],
        decal: &Decal,
        tint: Color,
    ) {
        let pos: [Vf2d; 4] = [pos[0].into(), pos[1].into(), pos[2].into(), pos[3].into()];
        let uv: [Vf2d; 4] = [uv[0].into(), uv[1].into(), uv[2].into(), uv[3].into()];
        let mut di = px_backend::decals::DecalInstances {
            id: decal.0.id(),
            pos: [(0.0, 0.0), (0.0, 0.0), (0.0, 0.0), (0.0, 0.0)],
            uv: [(0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0)],
            w: [1.0; 4],
            tint: tint.into(),
        };
        for i in 0..4 {
            di.pos[i] = (
                (pos[i].x / (self.size().x) as f32) * 2.0 - 1.0,
                ((pos[i].y / (self.size().y) as f32) * 2.0 - 1.0) * -1.0,
            );
            di.uv[i] = (uv[i].x, uv[i].y);
        }
        self.handler.draw_decal_instance(di);
    }
    fn draw_decal<P: Into<Vf2d> + Copy>(&mut self, pos: P, decal: &Decal) {
        self.draw_decal_tinted(pos, decal, Color::WHITE);
    }
    fn draw_decal_scaled<P: Into<Vf2d> + Copy>(&mut self, pos: P, decal: &Decal, scale: P) {
        self.draw_decal_scaled_tinted(pos, decal, scale, Color::WHITE);
    }
    fn draw_partial_decal<P: Into<Vf2d> + Copy>(
        &mut self,
        pos: P,
        decal: &Decal,
        source_pos: P,
        source_size: P,
    ) {
        self.draw_partial_decal_tinted(pos, decal, source_pos, source_size, Color::WHITE);
    }

    fn draw_partial_decal_scaled<P: Into<Vf2d> + Copy>(
        &mut self,
        pos: P,
        decal: &Decal,
        source_pos: P,
        source_size: P,
        scale: P,
    ) {
        self.draw_partial_decal_scaled_tinted(
            pos,
            decal,
            source_pos,
            source_size,
            scale,
            Color::WHITE,
        );
    }
    fn draw_warped_decal<P: Into<Vf2d> + Copy>(&mut self, pos: [P; 4], decal: &Decal) {
        self.draw_warped_decal_tinted(pos, decal, Color::WHITE);
    }

    fn draw_warped_partial_decal<P: Into<Vf2d> + Copy>(
        &mut self,
        pos: [P; 4],
        source_pos: P,
        source_size: P,
        decal: &Decal,
    ) {
        self.draw_warped_partial_decal_tinted(pos, source_pos, source_size, decal, Color::WHITE);
    }

    fn draw_rotated_decal<P: Into<Vf2d> + Copy>(
        &mut self,
        pos: P,
        decal: &Decal,
        angle: f32,
        center: P,
    ) {
        self.draw_rotated_decal_tinted(pos, decal, center, angle, Color::WHITE);
    }
    fn draw_rotated_decal_scaled<P: Into<Vf2d> + Copy>(
        &mut self,
        pos: P,
        decal: &Decal,
        angle: f32,
        center: P,
        scale: P,
    ) {
        self.draw_rotated_decal_scaled_tinted(pos, decal, center, angle, scale, Color::WHITE);
    }
    fn draw_partial_rotated_decal<P: Into<Vf2d> + Copy>(
        &mut self,
        pos: P,
        decal: &Decal,
        angle: f32,
        center: P,
        source_pos: P,
        source_size: P,
    ) {
        self.draw_partial_rotated_decal_tinted(
            pos,
            decal,
            angle,
            center,
            source_pos,
            source_size,
            Color::WHITE,
        );
    }
    fn draw_partial_rotated_decal_scaled<P: Into<Vf2d> + Copy>(
        &mut self,
        pos: P,
        decal: &Decal,
        angle: f32,
        center: P,
        source_pos: P,
        source_size: P,
        scaled: P,
    ) {
        self.draw_partial_rotated_decal_scaled_tinted(
            pos,
            decal,
            angle,
            center,
            source_pos,
            source_size,
            scaled,
            Color::WHITE,
        );
    }

    #[inline]
    fn draw_decal_tinted<P: Into<Vf2d> + Copy>(&mut self, pos: P, decal: &Decal, tint: Color) {
        into!(pos);
        let screen_size: Vf2d = (self.size().x as f32, self.size().y as f32).into();
        let topleft = normalize!(pos, screen_size);
        let bottomright = normalize!(
            {
                pos + Vf2d {
                    x: decal.0.size.0 as f32,
                    y: decal.0.size.1 as f32,
                }
            },
            screen_size
        );
        self.handler
            .draw_decal_instance(px_backend::decals::DecalInstances {
                id: decal.0.id(),
                pos: [
                    (topleft.x, topleft.y),         // A
                    (topleft.x, bottomright.y),     // B
                    (bottomright.x, bottomright.y), // C
                    (bottomright.x, topleft.y),     // D
                ],
                uv: [(0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0)],
                w: [1.0; 4],
                tint: tint.into(),
            });
    }

    fn draw_decal_scaled_tinted<P: Into<Vf2d> + Copy>(
        &mut self,
        pos: P,
        decal: &Decal,
        scale: P,
        tint: Color,
    ) {
        into!(scale, pos);
        let screen_size: Vf2d = (self.size().x as f32, self.size().y as f32).into();
        let topleft = normalize!(pos, screen_size);
        let bottomright = normalize!(
            {
                pos + Vf2d {
                    x: decal.0.size.0 as f32,
                    y: decal.0.size.1 as f32,
                } * scale
            },
            screen_size
        );
        self.handler
            .draw_decal_instance(px_backend::decals::DecalInstances {
                id: decal.0.id(),
                pos: [
                    (topleft.x, topleft.y),         // A
                    (topleft.x, bottomright.y),     // B
                    (bottomright.x, bottomright.y), // C
                    (bottomright.x, topleft.y),     // D
                ],
                uv: [(0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0)],
                w: [1.0; 4],

                tint: tint.into(),
            });
    }

    #[inline]
    fn draw_partial_decal_tinted<P: Into<Vf2d> + Copy>(
        &mut self,
        pos: P,
        decal: &Decal,
        source_pos: P,
        source_size: P,
        tint: Color,
    ) {
        into!(pos, source_pos, source_size);
        let screen_size: Vf2d = (self.size().x as f32, self.size().y as f32).into();
        let topleft = normalize!(pos, screen_size);
        let bottomright = normalize!(
            {
                pos + Vf2d {
                    x: source_size.x,
                    y: source_size.x,
                }
            },
            screen_size
        );
        let mut uv = [(0f32, 0f32); 4];
        let uv_scale: Vf2d = decal.0.uv_scale.into();
        let uv_topleft = source_pos * uv_scale;
        let uv_bottomright = uv_topleft + (source_size * uv_scale);
        uv[0] = (uv_topleft.x, uv_topleft.y);
        uv[1] = (uv_topleft.x, uv_bottomright.y);
        uv[2] = (uv_bottomright.x, uv_bottomright.y);
        uv[3] = (uv_bottomright.x, uv_topleft.y);

        self.handler
            .draw_decal_instance(px_backend::decals::DecalInstances {
                id: decal.0.id(),
                pos: [
                    (topleft.x, topleft.y),         // A
                    (topleft.x, bottomright.y),     // B
                    (bottomright.x, bottomright.y), // C
                    (bottomright.x, topleft.y),     // D
                ],
                uv,
                w: [1.0; 4],
                tint: tint.into(),
            });
    }

    #[inline]
    fn draw_partial_decal_scaled_tinted<P: Into<Vf2d> + Copy>(
        &mut self,
        pos: P,
        decal: &Decal,
        source_pos: P,
        source_size: P,
        scale: P,
        tint: Color,
    ) {
        into!(pos, source_pos, source_size, scale);
        let screen_size: Vf2d = (self.size().x as f32, self.size().y as f32).into();
        let topleft = normalize!(pos, screen_size);
        let bottomright = normalize!(
            {
                pos + Vf2d {
                    x: source_size.x,
                    y: source_size.x,
                } * scale
            },
            screen_size
        );
        let mut uv = [(0f32, 0f32); 4];
        let uv_scale: Vf2d = decal.0.uv_scale.into();
        let uv_topleft = source_pos * uv_scale;
        let uv_bottomright = uv_topleft + (source_size * uv_scale);
        uv[0] = (uv_topleft.x, uv_topleft.y);
        uv[1] = (uv_topleft.x, uv_bottomright.y);
        uv[2] = (uv_bottomright.x, uv_bottomright.y);
        uv[3] = (uv_bottomright.x, uv_topleft.y);

        self.handler
            .draw_decal_instance(px_backend::decals::DecalInstances {
                id: decal.0.id(),
                pos: [
                    (topleft.x, topleft.y),         // A
                    (topleft.x, bottomright.y),     // B
                    (bottomright.x, bottomright.y), // C
                    (bottomright.x, topleft.y),     // D
                ],
                uv,
                w: [1.0; 4],
                tint: tint.into(),
            });
    }

    #[inline]
    fn draw_warped_decal_tinted<P: Into<Vf2d> + Copy>(
        &mut self,
        pos: [P; 4],
        decal: &Decal,
        tint: Color,
    ) {
        const POINT_ONE: usize = 3;
        const POINT_TWO: usize = 0;
        const POINT_THREE: usize = 1;
        const POINT_FOUR: usize = 2;
        let screen_size: Vf2d = (self.size().x as f32, self.size().y as f32).into();
        let pos: [Vf2d; 4] = [pos[0].into(), pos[1].into(), pos[2].into(), pos[3].into()];
        let pos: [Vf2d; 4] = [
            normalize!({ pos[0] }, screen_size),
            normalize!({ pos[1] }, screen_size),
            normalize!({ pos[2] }, screen_size),
            normalize!({ pos[3] }, screen_size),
        ];
        let mut center: Vf2d = (0.0, 0.0).into();
        let mut di = px_backend::decals::DecalInstances {
            id: decal.0.id(),
            pos: [(0.0, 0.0), (0.0, 0.0), (0.0, 0.0), (0.0, 0.0)],
            uv: [(0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0)],
            w: [1.0; 4],
            tint: tint.into(),
        };
        let rd = (pos[POINT_THREE].x - pos[POINT_ONE].x) * (pos[POINT_FOUR].y - pos[POINT_TWO].y)
            - (pos[POINT_FOUR].x - pos[POINT_TWO].x) * (pos[POINT_THREE].y - pos[POINT_ONE].y);
        if rd != 0.0 {
            let rd = 1.0 / rd;
            let rn = ((pos[POINT_FOUR].x - pos[POINT_TWO].x)
                * (pos[POINT_ONE].y - pos[POINT_TWO].y)
                - (pos[POINT_FOUR].y - pos[POINT_TWO].y) * (pos[POINT_ONE].x - pos[POINT_TWO].x))
                * rd;
            let sn = ((pos[POINT_THREE].x - pos[POINT_ONE].x)
                * (pos[POINT_ONE].y - pos[POINT_TWO].y)
                - (pos[POINT_THREE].y - pos[POINT_ONE].y) * (pos[POINT_ONE].x - pos[POINT_TWO].x))
                * rd;
            if !(!(0.0..=1.0).contains(&rn) || !(0.0..=1.0).contains(&sn)) {
                center = pos[POINT_ONE] + (pos[POINT_THREE] - pos[POINT_ONE]) * rn;
            };
            let mut d = [0.0; 4];
            for i in 0..4 {
                d[i] = (pos[i] - center).mag();
            }
            for i in 0..4 {
                let q = if d[i] == 0.0 {
                    1.0
                } else {
                    (d[i] + d[(i + 2) & 3]) / d[(i + 2) & 3]
                };
                di.uv[i].0 *= q;
                di.uv[i].1 *= q;
                di.w[i] *= q;
                di.pos[i] = (pos[i].x, pos[i].y);
            }
            self.handler.draw_decal_instance(di);
        }
    }

    #[inline]
    fn draw_warped_partial_decal_tinted<P: Into<Vf2d> + Copy>(
        &mut self,
        pos: [P; 4],
        source_pos: P,
        source_size: P,
        decal: &Decal,
        tint: Color,
    ) {
        const POINT_ONE: usize = 3;
        const POINT_TWO: usize = 0;
        const POINT_THREE: usize = 1;
        const POINT_FOUR: usize = 2;
        let screen_size: Vf2d = (self.size().x as f32, self.size().y as f32).into();
        into!(source_pos, source_size);
        let pos: [Vf2d; 4] = [pos[0].into(), pos[1].into(), pos[2].into(), pos[3].into()];
        let pos: [Vf2d; 4] = [
            normalize!({ pos[0] }, screen_size),
            normalize!({ pos[1] }, screen_size),
            normalize!({ pos[2] }, screen_size),
            normalize!({ pos[3] }, screen_size),
        ];
        let mut center: Vf2d = (0.0, 0.0).into();
        let mut di = px_backend::decals::DecalInstances {
            id: decal.0.id(),
            pos: [(0.0, 0.0), (0.0, 0.0), (0.0, 0.0), (0.0, 0.0)],
            uv: [(0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0)],
            w: [1.0; 4],
            tint: tint.into(),
        };
        let rd = (pos[POINT_THREE].x - pos[POINT_ONE].x) * (pos[POINT_FOUR].y - pos[POINT_TWO].y)
            - (pos[POINT_FOUR].x - pos[POINT_TWO].x) * (pos[POINT_THREE].y - pos[POINT_ONE].y);
        if rd != 0.0 {
            let uv_scale: Vf2d = decal.0.uv_scale.into();
            let uv_topleft = source_pos * uv_scale;
            let uv_bottomright = uv_topleft + (source_size * uv_scale);
            di.uv[0] = (uv_topleft.x, uv_topleft.y);
            di.uv[1] = (uv_topleft.x, uv_bottomright.y);
            di.uv[2] = (uv_bottomright.x, uv_bottomright.y);
            di.uv[3] = (uv_bottomright.x, uv_topleft.y);

            let rd = 1.0 / rd;
            let rn = ((pos[POINT_FOUR].x - pos[POINT_TWO].x)
                * (pos[POINT_ONE].y - pos[POINT_TWO].y)
                - (pos[POINT_FOUR].y - pos[POINT_TWO].y) * (pos[POINT_ONE].x - pos[POINT_TWO].x))
                * rd;
            let sn = ((pos[POINT_THREE].x - pos[POINT_ONE].x)
                * (pos[POINT_ONE].y - pos[POINT_TWO].y)
                - (pos[POINT_THREE].y - pos[POINT_ONE].y) * (pos[POINT_ONE].x - pos[POINT_TWO].x))
                * rd;
            if !(!(0.0..=1.0).contains(&rn) || !(0.0..=1.0).contains(&sn)) {
                center = pos[POINT_ONE] + (pos[POINT_THREE] - pos[POINT_ONE]) * rn;
            };
            let mut d = [0.0; 4];
            for i in 0..4 {
                d[i] = (pos[i] - center).mag();
            }
            for i in 0..4 {
                let q = if d[i] == 0.0 {
                    1.0
                } else {
                    (d[i] + d[(i + 2) & 3]) / d[(i + 2) & 3]
                };
                di.uv[i].0 *= q;
                di.uv[i].1 *= q;
                di.w[i] *= q;
                di.pos[i] = (pos[i].x, pos[i].y);
            }
            self.handler.draw_decal_instance(di);
        }
    }

    #[inline]
    fn draw_rotated_decal_tinted<P: Into<Vf2d> + Copy>(
        &mut self,
        pos: P,
        decal: &Decal,
        center: P,
        angle: f32,
        tint: Color,
    ) {
        let screen_size: Vf2d = (self.size().x as f32, self.size().y as f32).into();
        into!(pos, center);
        let mut pos_arr = [Vf2d { x: 0.0, y: 0.0 }; 4];
        pos_arr[0] = Vf2d {x:0.0,y:0.0} - center /* * scale*/;
        pos_arr[1] = Vf2d {x: 0.0, y:  decal.size().y as f32} - center /* * scale*/;
        pos_arr[2] = Vf2d {x:decal.size().x as f32, y:decal.size().y as f32} - center/*  * scale*/;
        pos_arr[3] = Vf2d {x:decal.size().x as f32, y: 0.0} - center /* * scale*/;
        let (s, c) = angle.sin_cos();
        for pos_index in &mut pos_arr {
            *pos_index = normalize!(
                {
                    pos + Vf2d {
                        x: pos_index.x * c - pos_index.y * s,
                        y: pos_index.x * s + pos_index.y * c,
                    }
                },
                screen_size
            );
            // *pos_index = pos
            //     + Vf2d {
            //         x: pos_index.x * c - pos_index.y * s,
            //         y: pos_index.x * s + pos_index.y * c,
            //     };
            // *pos_index = *pos_index * screen_size * 2.0 - Vf2d { x: 1.0, y: 1.0 };
            // pos_index.y *= -1.0;
            /*
            di.pos[i] = pos + olc::vf2d(di.pos[i].x * c - di.pos[i].y * s, di.pos[i].x * s + di.pos[i].y * c);
            di.pos[i] = di.pos[i] * vInvScreenSize * 2.0f - olc::vf2d(1.0f, 1.0f);
            di.pos[i].y *= -1.0f;
            di.w[i] = 1;
            */
        }
        self.handler.draw_decal_instance(decals::DecalInstances {
            id: decal.0.id(),
            pos: [
                (pos_arr[0].x, pos_arr[0].y),
                (pos_arr[1].x, pos_arr[1].y),
                (pos_arr[2].x, pos_arr[2].y),
                (pos_arr[3].x, pos_arr[3].y),
            ],
            w: [1.0; 4],
            uv: [(0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0)],
            tint: tint.into(),
        });
    }

    #[inline]
    fn draw_rotated_decal_scaled_tinted<P: Into<Vf2d> + Copy>(
        &mut self,
        pos: P,
        decal: &Decal,
        center: P,
        angle: f32,
        scale: P,
        tint: Color,
    ) {
        let screen_size: Vf2d = (self.size().x as f32, self.size().y as f32).into();
        into!(pos, center, scale);
        let mut pos_arr = [Vf2d { x: 0.0, y: 0.0 }; 4];
        pos_arr[0] = Vf2d {x:0.0,y:0.0} - center /* * scale*/;
        pos_arr[1] = Vf2d {x: 0.0, y:  decal.size().y as f32} - center /* * scale*/;
        pos_arr[2] = Vf2d {x:decal.size().x as f32, y:decal.size().y as f32} - center/*  * scale*/;
        pos_arr[3] = Vf2d {x:decal.size().x as f32, y: 0.0} - center /* * scale*/;
        for p in &mut pos_arr {
            *p = *p * scale;
        }
        let (c, s) = angle.sin_cos();
        for pos_index in &mut pos_arr {
            *pos_index = normalize!(
                {
                    pos + Vf2d {
                        x: pos_index.x * c - pos_index.y * s,
                        y: pos_index.x * s + pos_index.y * c,
                    }
                },
                screen_size
            );
        }
        self.handler.draw_decal_instance(decals::DecalInstances {
            id: decal.0.id(),
            pos: [
                (pos_arr[0].x, pos_arr[0].y),
                (pos_arr[1].x, pos_arr[1].y),
                (pos_arr[2].x, pos_arr[2].y),
                (pos_arr[3].x, pos_arr[3].y),
            ],
            w: [1.0; 4],
            uv: [(0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0)],
            tint: tint.into(),
        });
    }

    #[inline]
    fn draw_partial_rotated_decal_tinted<P: Into<Vf2d> + Copy>(
        &mut self,
        pos: P,
        decal: &Decal,
        angle: f32,
        center: P,
        source_pos: P,
        source_size: P,
        tint: Color,
    ) {
        let screen_size: Vf2d = (self.size().x as f32, self.size().y as f32).into();

        let uv_scale: Vf2d = decal.0.uv_scale.into();
        into!(pos, center, source_pos, source_size);
        let uv_topleft = source_pos * uv_scale;
        let uv_bottomright = uv_topleft + (source_size * uv_scale);
        let mut uv = [(0f32, 0f32); 4];
        uv[0] = (uv_topleft.x, uv_topleft.y);
        uv[1] = (uv_topleft.x, uv_bottomright.y);
        uv[2] = (uv_bottomright.x, uv_bottomright.y);
        uv[3] = (uv_bottomright.x, uv_topleft.y);
        let mut pos_arr = [Vf2d { x: 0.0, y: 0.0 }; 4];
        pos_arr[0] = Vf2d {x:0.0,y:0.0} - center /* * scale*/;
        pos_arr[1] = Vf2d {x: 0.0, y:  source_size.y} - center /* * scale*/;
        pos_arr[2] = Vf2d {x:source_size.x, y: source_size.y } - center/*  * scale*/;
        pos_arr[3] = Vf2d {x:source_size.x, y: 0.0} - center /* * scale*/;
        let (c, s) = angle.sin_cos();
        for pos_index in &mut pos_arr {
            *pos_index = normalize!(
                {
                    pos + Vf2d {
                        x: pos_index.x * c - pos_index.y * s,
                        y: pos_index.x * s + pos_index.y * c,
                    }
                },
                screen_size
            );
        }

        self.handler.draw_decal_instance(decals::DecalInstances {
            id: decal.0.id(),
            pos: [
                (pos_arr[0].x, pos_arr[0].y),
                (pos_arr[1].x, pos_arr[1].y),
                (pos_arr[2].x, pos_arr[2].y),
                (pos_arr[3].x, pos_arr[3].y),
            ],
            uv,
            w: [1.0; 4],
            tint: tint.into(),
        });
    }

    #[inline]
    fn draw_partial_rotated_decal_scaled_tinted<P: Into<Vf2d> + Copy>(
        &mut self,
        pos: P,
        decal: &Decal,
        angle: f32,
        center: P,
        source_pos: P,
        source_size: P,
        scaled: P,
        tint: Color,
    ) {
            into!(pos, center, source_pos, source_size, scaled);
            let screen_size: Vf2d = (self.size().x as f32, self.size().y as f32).into();
            let uv_scale: Vf2d = decal.0.uv_scale.into();
            let uv_topleft = source_pos * uv_scale;
            let uv_bottomright = uv_topleft + (source_size * uv_scale);
            let mut uv = [(0f32, 0f32); 4];
            uv[0] = (uv_topleft.x, uv_topleft.y);
            uv[1] = (uv_topleft.x, uv_bottomright.y);
            uv[2] = (uv_bottomright.x, uv_bottomright.y);
            uv[3] = (uv_bottomright.x, uv_topleft.y);
            let mut pos_arr = [Vf2d { x: 0.0, y: 0.0 }; 4];
            pos_arr[0] = Vf2d {x:0.0,y:0.0} - center /* * scale*/;
            pos_arr[1] = Vf2d {x: 0.0, y:  source_size.y} - center /* * scale*/;
            pos_arr[2] = Vf2d {x:source_size.x, y: source_size.y } - center/*  * scale*/;
            pos_arr[3] = Vf2d {x:source_size.x, y: 0.0} - center /* * scale*/;
            for p in &mut pos_arr {
                *p = *p * scaled;
            }
            let (c, s) = angle.sin_cos();
            for pos_index in &mut pos_arr {
                *pos_index = normalize!(
                    {
                        pos + Vf2d {
                            x: pos_index.x * c - pos_index.y * s,
                            y: pos_index.x * s + pos_index.y * c,
                        }
                    },
                    screen_size
                );
            }
            self.handler.draw_decal_instance(decals::DecalInstances {
                id: decal.0.id(),
                pos: [
                    (pos_arr[0].x, pos_arr[0].y),
                    (pos_arr[1].x, pos_arr[1].y),
                    (pos_arr[2].x, pos_arr[2].y),
                    (pos_arr[3].x, pos_arr[3].y),
                ],
                w: [1.0; 4],
                uv,
                tint: tint.into(),
            });
        }

pub fn scale(&self) -> u32

Return the pixel scale factor

pub fn get_key(&self, keycode: Keycodes) -> Input

Get The status of a key

pub fn get_mouse_btn(&self, btn: MouseBtn) -> Input

Get the status of a Mouse Button

pub fn get_mouse_location(&self) -> (u32, u32)

Get the mouse location (in pixel) on the screen Will be defaulted to (0,0) at the start of the program

pub fn get_mouse_wheel(&self) -> MouseWheel

Get the scroll wheel direction (If Any) during the frame

pub fn get_pressed(&self) -> HashSet<Keycodes>

Get all Keys pressed during the last frame

pub fn get_held(&self) -> HashSet<Keycodes>

Get all the keys that were held during the last frame

pub fn get_released(&self) -> HashSet<Keycodes>

Get all the keys that were released during the last frame

pub fn create_decal(&mut self, sprite: &Sprite) -> Decal

Create a GPU version of Sprite

pub fn start_input(&mut self)

Switch to text input mode, return true if it wasn’t in this mode before

pub fn force_stop_input_mode(&mut self)

This will clear the input buffer, reset the input cursor and stop the input mode

pub fn is_in_input_mode(&self) -> bool

Is the engine in input mode

pub fn end_input_mode(&mut self) -> &str

Stop the input mode right there, and return a &str to the current buffer. This is if you need to leave the mode but retain the input buffer for a later re-entry

pub fn try_get_finished_input(&mut self) -> Option<String>

Return the string when input mode ends (when the key Enter has been pressed) This is different than end_input_mode as it will return the buffer (and create a new empty one). This is used when you want to wait until the user has finished typing

pub fn get_input_buffer(&self) -> &str

Return the current input buffer as a string slice

pub fn get_input_cursor(&self) -> usize

Return the current input cursor position

Trait Implementations

impl Debug for Engine

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl DecalDraw for Engine

fn draw_explicit_decal<P: Into<Vf2d> + Copy>(
    &mut self,
    pos: [P; 4],
    uv: [P; 4],
    decal: &Decal,
    tint: Color
)

Draw A decal with given position and uv (You probably don’t want to use this)

fn draw_decal<P: Into<Vf2d> + Copy>(&mut self, pos: P, decal: &Decal)

Draw a decal from the given position

fn draw_decal_scaled<P: Into<Vf2d> + Copy>(
    &mut self,
    pos: P,
    decal: &Decal,
    scale: P
)

Draw a decal with a given scale

fn draw_partial_decal<P: Into<Vf2d> + Copy>(
    &mut self,
    pos: P,
    decal: &Decal,
    source_pos: P,
    source_size: P
)

Draw a partial decal from the given position

fn draw_partial_decal_scaled<P: Into<Vf2d> + Copy>(
    &mut self,
    pos: P,
    decal: &Decal,
    source_pos: P,
    source_size: P,
    scale: P
)

Draw a partial decal with a given scale

fn draw_warped_decal<P: Into<Vf2d> + Copy>(&mut self, pos: [P; 4], decal: &Decal)

Draw a decal where all Corner are given, this will set the uv correctly to allow texture warping The points are in order:

fn draw_warped_partial_decal<P: Into<Vf2d> + Copy>(
    &mut self,
    pos: [P; 4],
    source_pos: P,
    source_size: P,
    decal: &Decal
)

Draw a decal where all Corner are given, this will set the uv correctly to allow texture warping The points are in order:

fn draw_rotated_decal<P: Into<Vf2d> + Copy>(
    &mut self,
    pos: P,
    decal: &Decal,
    angle: f32,
    center: P
)

Draw a decal rotated angle radians around center center is an offset in pixel from the top left corner of the decal

fn draw_rotated_decal_scaled<P: Into<Vf2d> + Copy>(
    &mut self,
    pos: P,
    decal: &Decal,
    angle: f32,
    center: P,
    scale: P
)

Same as draw_rotated_decal but with scaling

fn draw_partial_rotated_decal<P: Into<Vf2d> + Copy>(
    &mut self,
    pos: P,
    decal: &Decal,
    angle: f32,
    center: P,
    source_pos: P,
    source_size: P
)

Draw a zone of a decal and rotate it

fn draw_partial_rotated_decal_scaled<P: Into<Vf2d> + Copy>(
    &mut self,
    pos: P,
    decal: &Decal,
    angle: f32,
    center: P,
    source_pos: P,
    source_size: P,
    scaled: P
)

Draw a zone of a decal, rotate it and scaled it

fn draw_decal_tinted<P: Into<Vf2d> + Copy>(
    &mut self,
    pos: P,
    decal: &Decal,
    tint: Color
)

Same as the non tinted variant, but with an tint color parameter

fn draw_decal_scaled_tinted<P: Into<Vf2d> + Copy>(
    &mut self,
    pos: P,
    decal: &Decal,
    scale: P,
    tint: Color
)

Same as the non tinted variant, but with an tint color parameter

fn draw_partial_decal_tinted<P: Into<Vf2d> + Copy>(
    &mut self,
    pos: P,
    decal: &Decal,
    source_pos: P,
    source_size: P,
    tint: Color
)

Same as the non tinted variant, but with an tint color parameter

fn draw_partial_decal_scaled_tinted<P: Into<Vf2d> + Copy>(
    &mut self,
    pos: P,
    decal: &Decal,
    source_pos: P,
    source_size: P,
    scale: P,
    tint: Color
)

Same as the non tinted variant, but with an tint color parameter

fn draw_warped_decal_tinted<P: Into<Vf2d> + Copy>(
    &mut self,
    pos: [P; 4],
    decal: &Decal,
    tint: Color
)

Same as the non tinted variant, but with an tint color parameter

fn draw_warped_partial_decal_tinted<P: Into<Vf2d> + Copy>(
    &mut self,
    pos: [P; 4],
    source_pos: P,
    source_size: P,
    decal: &Decal,
    tint: Color
)

Same as the non tinted variant, but with an tint color parameter

fn draw_rotated_decal_tinted<P: Into<Vf2d> + Copy>(
    &mut self,
    pos: P,
    decal: &Decal,
    center: P,
    angle: f32,
    tint: Color
)

Same as the non tinted variant, but with an tint color parameter

fn draw_rotated_decal_scaled_tinted<P: Into<Vf2d> + Copy>(
    &mut self,
    pos: P,
    decal: &Decal,
    center: P,
    angle: f32,
    scale: P,
    tint: Color
)

Same as the non tinted variant, but with an tint color parameter

fn draw_partial_rotated_decal_tinted<P: Into<Vf2d> + Copy>(
    &mut self,
    pos: P,
    decal: &Decal,
    angle: f32,
    center: P,
    source_pos: P,
    source_size: P,
    tint: Color
)

Same as the non tinted variant, but with an tint color parameter

fn draw_partial_rotated_decal_scaled_tinted<P: Into<Vf2d> + Copy>(
    &mut self,
    pos: P,
    decal: &Decal,
    angle: f32,
    center: P,
    source_pos: P,
    source_size: P,
    scaled: P,
    tint: Color
)

Same as the non tinted variant, but with an tint color parameter

impl DecalText for Engine

fn draw_text_decal(
    &mut self,
    pos: impl Into<Vf2d>,
    text: impl AsRef<str>,
    scale: impl Into<Vf2d>,
    color: impl Into<Color>
)

Draw the given string starting at the position given and scaled

impl DrawSpriteTrait for Engine

fn size(&self) -> Vu2d

fn get_pixel(&self, pos: Vi2d) -> Option<Color>

fn set_pixel(&mut self, pos: Vi2d, col: Color)

unsafe fn get_pixel_unchecked(&self, pos: Vu2d) -> Color

Get the pixel at the given location, but bypassing any bounds check

unsafe fn set_pixel_unchecked(&mut self, pos: Vu2d, col: Color)

Set the pixel at the given location, but bypassing any bounds check

impl SmartDrawingTrait for Engine

fn draw<P: Into<Vi2d>>(&mut self, pos: P, col: Color)

Set the pixel data at the given coordinates to the given Color Will use the current PixelMode

fn clear(&mut self, col: Color)

Clear the Sprite With the given Color

fn get_size(&self) -> Vu2d

Get the size of the target

fn set_pixel_mode(&mut self, mode: PixelMode)

Set the PixelMode

fn get_pixel<P: Into<Vi2d>>(&self, pos: P) -> Option<Color>

Get the Pixel Data at the given coordinates

fn set_blend_factor(&mut self, f: f32)

Set the Blend Factor Used for alpha calculations

fn get_textsheet(&self) -> &'static Sprite

Get The textsheet (A Sprite)

fn get_pixel_mode(&self) -> PixelMode

Return the PixelMode

fn get_blend_factor(&self) -> f32

Get the Blend Factor Used for alpha calculations