pix-engine 0.3.4

// PixEngine {
//     app: A,
//     should_close: bool,
//     state: State,
// }

struct MouseState {
    pos: Point,
    pressed_btns: HashSet<MouseButton>,
}

impl MouseState {
    fn is_pressed(&self) -> bool {
        !self.pressed_btns.is_empty()
    }
    fn is_down(&self, btn: MouseButton) -> bool {
        self.pressed_btns.contains(btn)
    }
}

struct KeyState {
    pressed_keys: HashSet<Key>
}

impl KeyState {
    fn is_pressed(&self) -> bool {
        !self.pressed_keys.is_empty()
    }
    fn is_down(&self, key: Key) -> bool {
        self.pressed_keys.contains(key)
    }
}

State {
    // title: String,
    // renderer: Renderer,
    // events: Vec<PixEvent>,
    // should_loop: bool,

    mouse_state: MouseState,
    pmouse_state: MouseState,
    key_state: KeyState,
    elements: Vec<Element>,??
    loaded_fonts: Vec<>,??
    // state_stack: Vec<StateSettings>,
    // Environment {
    //     focused: bool,
    //     frame_rate: u32,
    //     target_frame_rate: u32,
    //     delta_time: f32,
    //     scale: u32,
    //     display_width: u32,
    //     display_height: u32,
    //     display_density: u32,
        // cursor: Option<CursorType>, // Default CursorType::Arrow
    // },
    // StateSettings {
        // show_frame_rate: bool,

        // Color
        // color_mode: ColorMode, // Default ColorMode::Rgb
        // bg_color: Color, // Default Color::BLACK
        // fill: Option<Color>, // Default None
        // stroke: Option<Color>, // Default None

        // Shapes
        // arc_mode: ArcMode, // Default ArcMode::Pie
        // ellipse_mode: ShapeMode, // Default ShapeMode::Center
        // rect_mode: ShapeMode, // Default ShapeMode::Corner
        // stroke_weight: u32, // Default 0
        // stroke_cap: StrokeCap, // Default StrokeCap::Round
        // stroke_join: StrokeJoin, // Default StrokeJoin::Miter

        // Trig
        // angle_mode: AngleMode, // Default AngleMode::Radians

        // Image
        // image_tint: Option<Color>, // Default None
        // image_mode: ImageMode, // Default ImageMode::Corner

        // Typography
        // text_align_hori: TextAlignHori, // Default TextAlignHori::Left
        // text_align_vert: TextAlignVert, // Default TextAlignVert::Top
        // text_leading: u32, // Default 15
        // text_size: u32, // Default 12
        // text_style: TextStyle, // Default TextStyle::Normal
        // text_font: Font, // Default Font::Arial

        // Rendering
        // blend_mode: BlendMode, // Default BlendMode::Blend
        // blend_factor: f32, // Default 1.0

        // Transformations
        // transformation: Transform,
    // }
}


Color:
    // ColorMode { Rgb, Hsb }

    // State::color_mode() -> ColorMode

    // Color {
    //     red: u8,
    //     green: u8,
    //     blue: u8,
    //     alpha: u8,
    // }

    // Creating & Reading

    // RGB(red: u8, green: u8, blue: u8) -> Color
    // RGBA(red: u8, green: u8, blue: u8, alpha: u8) -> Color

    // Color.red() -> u8
    // Color.set_red(val: u8)

    // Color.green() -> u8
    // Color.set_green(val: u8)

    // Color.blue() -> u8
    // Color.set_blue(val: u8)

    // Color.alpha() -> u8
    // Color.set_alpha(val: u8)

    // impl Display
    // Derive Debug, PartialEq, Eq

    // Setting

    // State::bg_color() -> Color
    // State::set_bg_color(color: Color)
    // State::clear() // Clears to bg_color

    // State::fill() -> Color // Fill color for shapes
    // State::set_fill(color: Color) // Fill color for shapes
    // State::no_fill() // Disable fill color for shapes

    // State::stroke() -> Color // Stroke color for shapes
    // State::set_stroke(color: Color) // Stroke color for shapes
    // State::no_stroke() // Disable stroke for shapes

    // Constants
    // WHITE, BLACK, TRANSPARENT
    // LIGHT_GRAY, GRAY, DARK_GRAY
    // BRIGHT_RED, RED, DARK_RED
    // BRIGHT_ORANGE, ORANGE, DARK_ORANGE
    // BRIGHT_YELLOW, YELLOW, DARK_YELLOW
    // BRIGHT_GREEN, GREEN, DARK_GREEN
    // BRIGHT_CYAN, CYAN, DARK_CYAN
    // BRIGHT_BLUE, BLUE, DARK_BLUE
    // BRIGHT_MAGENTA, MAGENTA, DARK_MAGENTA
    // BRIGHT_VIOLET, VIOLET, DARK_VIOLET

    // FUTURE
    // State::set_color_mode(mode: ColorMode)

    hsb(hue: u8, saturation: u8, brightness: u8) -> Color
    hsl(hue: u8, saturation: u8, lightness: u8) -> Color

    Color.hue() -> u16
    Color.set_hue(val: u16)

    Color.saturation() -> u8
    Color.set_saturation(val: u8)

    Color.brightness() -> u8
    Color.set_brightness(val: u8)

    Color.lightness() -> u8
    Color.set_lightness(val: u8)


Shapes:
    // 2D Primitives

    State::point(p: Vector)
    State::line(p1: Vector, p2: Vector)

    // ArcMode { Pie, Open, Chord } // Default Pie
    State::arc(p: Vector, w: Num, h: Num, start: Float, stop: Float)

    State::circle(c: Vector, d: Num);
    State::ellipse(c: Vector, w: Num, h: Num);

    State::quad(p1: Vector, p2: Vector, p3: Vector, p4: Vector)

    State::square(p: Vector, s: Num)
    State::square_rounded(p: Vector, s: Num, r: Num)
    State::rect(p: Vector, w: Num, h: Num)
    State::rect_rounded(p: Vector, w: Num, h: Num, r: Num)

    State::triangle(p1: Vector, p2: Vector, p3: Vector)

    // 3D Primitives

    State::geometry_detail(x_count: Num, y_count: Num) // Sets the number of triangle segments for 3D models

    State::point(p: Vector)
    State::line(p1: Vector, p2: Vector)

    State::plane(p1: Vector, p2: Vector)

    State::sphere(c: Vector, d: Num)
    State::ellipsoid(rx: Num, ry: Num, rz: Num)

    State::box_(p: Vector, w: Num, h: Num, d: Num)

    ShapeCap { Both, Top, Bottom }
    State::cylinder(c: Vector, d: Num, h: Num)
    State::cone(c: Vector, d: Num, h: Num)
    State::torus(c: Vector, r: Num, tr: Num)

    // Attributes

    // EllipseMode { Center, Radius, Corner }
    // RectMode { Center, Radius, Corner }
    // StrokeCap { Round, Square, Project }
    // StrokeJoin { Miter, Bevel, Round }

    // State::get_ellipse_mode() -> ShapeMode // Default ShapeMode::Center
    // State::ellipse_mode(mode: ShapeMode)

    // State::get_stroke_cap() -> StrokeCap // Default Round
    // State::stroke_cap(cap: StrokeCap)

    // State::get_stroke_join() -> StrokeJoin // Default Miter
    // State::stroke_join(cap: StrokeJoin)

    // State::get_stroke_weight() -> u32 // Stroke weight for shapes
    // State::stroke_weight(val: u32) // Stroke weight for shapes

    // State::get_rect_mode() -> ShapeMode // Default ShapeMode::Corner
    // State::rect_mode(mode: ShapeMode)

    // FUTURE: Curves - bezier, curve, etc
    // FUTURE: Vertex, begin_shape, end_shape, etc

Math:
    create_vector!(vector)
    create_vector!(x, y)
    create_vector!(x, y, z)

    struct Vector<T>
    where T: Num {
        x: T,
        y: T,
        z: T,
    }

    // - Vector.new(x: f64, y: f64, z: f64) -> Self
    // - Vector.from_angle(angle: f64) -> Self
    // - Vector.random2D() -> Self
    // - Vector.random3D() -> Self

    // - set(x: f64, y: f64)
    // - set_xy(x: f64, y: f64)

    // - mag() -> f64 // sqrt(x*x + y*y + z*z)
    // - mag_sq() -> f64 // x*x + y*y + z*z
    // - set_mag(mag: f64)

    // - dot(v: Vector) -> f64
    // - cross(v: Vector) -> Vector
    // - dist(v: Vector) -> f64

    // - normalize()
    // - limit(max: f64)

    // - heading() -> f64
    // - rotate(angle: f64)
    // - angle_between(v: Vector) -> f64
    // - reflect(normal: Vector)


    // Constants

//     HALF_PI: std::f64::consts::FRAC_PI_2
//     PI: std::f64::consts::PI
//     QUARTER_PI: std::f64::consts::PI_4
//     TAU: std::f64::consts::PI * 2.0
//     TWO_PI: std::f64::consts::PI * 2.0

    // AngleMode { Radians, Degrees }
    // State::angle_mode() -> AngleMode // Default Radians
    // State::set_angle_mode(mode: AngleMode)

Vertex:
    struct Vertex<T>
    where T: Num {
        x: T,
        y: T,
        z: T,
        u: T,
        v: T,
    }

Environment:
    // State::frame_count() -> u32 // Number of frames since start
    // State::inc_frame_count()
    // State::frame_rate() -> u32
    // State::set_frame_rate(val: u32)
    // State::target_frame_rate() -> u32
    // State::set_target_frame_rate(val: u32)
    // State::delta_time() -> f32 // Elapsed time from previous frame
    // State::set_delta_time()

    State::display_width() -> u32
    State::display_height() -> u32
    // State::display_density() -> u32

    // State::set_cursor(cursor: Option<CursorType>)

    // Per-window
    State::focused() -> bool // Whether application has focus
    State::scale() -> u32
    State::fullscreen(val: bool)
    State::is_fullscreen() -> bool
    State::screen_width(id: WindowId) -> u32
    State::screen_height(id: WindowId) -> u32

Structure:
    // State::loop()
    // State::no_loop()
    // State::push() // Saves current draw transforms & settings - fill, stroke, etc
    // State::pop()
    // State::update(n: u32) // Calls on_update exactly n times

Rendering:
    // BlendMode { Blend, Add, Replace }
    // Blend: C = A\*factor + B
    // Add: C = A + B
    // Replace: C = B
    // FUTURE: DARKEST, LIGHTEST, DIFFERENCE, EXCLUSION, MULTIPLY, SCREEN, REMOVE, OVERLAY, HARD_LIGHT, SOFT_LIGHT, DODGE, BURN, SUBTRACT
    // State::blend_mode() -> BlendMode
    // State::set_blend_mode(mode: BlendMode)

UI:
    Element trait:
        position(x: i32, y: i32)
        changed() // Callback when element is changed
        input() // Callback when element receives event
        mouse_pressed() // Callback when mouse pressed

    State::create_slider(min: u32, max: u32, value: u32, step: u32) -> Slider
    State::create_button(label: &str, value: &str) -> Button
    State::create_checkbox(label: &str, value: bool) -> Checkbox
    State::create_selectbox(multiple: bool) -> SelectBox
        - add_option(option: &str)
        - selected() -> usize
        - set_selected(index: usize)
        - enable_option(index: usize)
        - disable_option(index: usize)
        - disable() // Disables whole element
    State::create_radio() -> Radio
        - add_option(option: &str)
        - selected() -> usize
        - set_selected(index: usize)
        - enable_option(index: usize)
        - disable_option(index: usize)
        - disable() // Disables whole element
    InputType { Text, Password } // Default Text
    State::create_input(value: &str, type: InputType) -> Input

Transformations:
    State::apply_matrix(a: f32, b: f32, c: f32, d: f32, e: f32, f: f32)
    State::reset_matrix()
    State::rotate(angle: f32)
    State::scale(s: f32) // scales in x and y
    State::scale_x(s: f32)
    State::scale_y(s: f32)
    State::shear_x(angle: f32)
    State::shear_y(angle: f32)
    State::translate(x: i32, y: i32)

    // FUTURE
    State::rotate_3d(angle: f32, axis: Vector)
    State::rotateX(angle: f32)
    State::rotateY(angle: f32)
    State::rotateZ(angle: f32)
    State::scale_z(s: f32)
    State::translate_3d(x: i32, y: i32, z: i32)

State Trait:
    on_start(&mut self, data: &mut State) -> PixEngineResult<bool>
    on_update(&mut self, data: &mut State) -> PixEngineResult<bool>
    on_stop(&mut self, data: &mut State) -> PixEngineResult<bool>

Image:
    // Image {
    //     width: u32,
    //     height: u32,
    //     channels: usize,
    //     pixel_format: PixelFormat,
    //     data: Vec<u8>,
    // }
    // new(w: u32, h: u32) -> Self
    // rgb(w: u32, h: u32) -> Self
    // rgba(w: u32, h: u32) -> Self
    // from_bytes(w: u32, h: u32, pixel_format: PixelFormat, bytes: &[u8]) -> Self
    // from_pixels(w: u32, h: u32, pixels: &[Color]) -> Self
    // pixel(x: i32, y: i32) -> Color
    // set_pixel(x: i32, y: i32, color: Color)
    // load_pixels()
    // update_pixels()
    // pixel_format() -> PixelFormat
    // dimensions() -> (u32, u32)
    // width() -> u32
    // height() -> u32
    // pixels() -> &Vec<Color>
    // pixels_mut() -> &Vec<Color>
    // bytes() -> &[u8]
    // bytes_mut() -> &mut [u8]
    // load(path: Path)
    // save(path: Path)
    // get_index(x: u32, y: u32) -> usize
    // filter(filter: ImageFilter)
    // sub_image(x: i32, y: i32, w: u32, h: u32) -> Image
    // set_sub_image(x: i32, y: i32, image: &Image)
    // resize(w: u32, h: u32)
    // blend(image: &Image, mode: BlendMode)
    // mask(image: &Image)
    // Image.filtered(image: Image, filter: ImageFilter) -> Image
    // Image.resized(image: Image, w: u32, h: u32) -> Image
    // Image.blended(image: &Image, mode: BlendMode) -> Image
    // Image.mask(image: &Image) -> Image

    // State::create_image(w: u32, h: u32) -> Image
    // State::save_canvas<P: AsRef<Path>>(filename: P)

    // State::draw_image(img: Image, x: i32, y: i32)
    // State::draw_image_resized(img: Image, x: i32, y: i32, w: u32, h: u32)
    // State::draw_image_corners(img: Image, x1: i32, y1: i32, x2: i32, y2: i32)
    // State::draw_image_projected(img: Image, dx: i32, dy: i32, dw: u32, dh: u32, sx: i32, sy: i32, sw: u32, sh: u32)

    // State::image_tint() -> Color
    // State::set_image_tint(color: Color)
    // State::no_image_tint()

    // ImageMode { Corner, Center } // Default Corner
    // State::image_mode() -> ImageMode
    // State::set_image_mode(mode: ImageMode)

    struct Texture {
        id: usize,
        image: Image,
        quad: [Vec2f; 4],
        uv: [Vec2f; 4],
        uv_scale: Vec2f,
        w: [f64; 4],
        tint: Color,
    }

Renderer:
    fn new(title: &str, width: Num, height: Num, fullscreen: bool, vsync: bool)
    fn present()
    fn clear(color: Color)
    fn draw_texture(texture: &Texture)
    fn create_texture(width: Num, height: Num)
    fn update_texture(id: usize, image: Image)
    fn delete_texture(id: usize)
    fn update_viewport(pos: Vec2i, size: Vec2i)


Events:
    impl State {
        // pub fn mouse_pos(&self) -> Point {
        //     self.mouse_state.pos
        // }
        // pub fn pmouse_pos(&self) -> Point {
        //     self.pmouse_state.pos
        // }
        // pub fn mouse_is_pressed(&self) -> bool {
        //     self.mouse_state.is_pressed()
        // }
        pub fn mouse_is_down(&self, btn: MouseButton) -> bool {
            self.mouse_state.is_down(btn)
        }
        pub fn key_is_pressed(&self) -> bool {
            self.key_state.is_pressed()
        }
        pub fn key_is_down(&self, key: Key) -> bool {
            self.key_state.is_down(key)
        }
    }

    trait PixApp {
        // fn on_mouse_pressed(&mut self, s: &mut State) {}
        // fn on_mouse_released(&mut self, s: &mut State) {}
        fn on_mouse_moved(&mut self, s: &mut State) {}
        // fn on_mouse_dragged(&mut self, s: &mut State) {}
        fn on_mouse_clicked(&mut self, s: &mut State) {} // Pressed followed by release
        fn on_mouse_dbl_clicked(&mut self, s: &mut State) {} // 2 Clicks within short time-frame
        fn on_mouse_wheel(&self, s: &mut State, delta: i32) {}

        fn on_key_pressed(&mut self, s: &mut State) {}
        fn on_key_released(&mut self, s: &mut State) {}
    }

    // FUTURE Acceleration

Typography:
    // Loading & Displaying
    Text {
        x: i32,
        y: i32,
        w: u32,
        h: u32,
        text: String,
    }
        - Text.new(text: &str, x: i32, y: i32) -> Self
        - Text.with_size(text: &str, x: i32, y: i32, w: u32, h: u32) -> Self
        - textBounds() -> Rect

    // Attributes

    TextAlignHori { Left, Center, Right }
    State::text_align_hori() -> TextAlignHori
    State::set_text_align_hori(align: TextAlignHori)

    TextAlignVert { Top, Center, Bottom, Baseline }
    State::text_align_vert() -> TextAlignVert
    State::set_text_align_vert(align: TextAlignVert)

    State::text_leading() -> u32
    State::set_text_leading(size: u32)

    State::text_size() -> u32
    State::set_text_size(size: u32)

    TextStyle { Normal, Italic, Bold, BoldItalic }
    State::text_style() -> TextStyle
    State::set_text_style(style: TextStyle)

    State::text_width(str: &str) -> u32

    Font { Arial, Custom(String, PathBuf) }
    State::text_font() -> Font
    State::set_text_font(font: Font)

    State::load_font<P: AsRef<Path>>(name: &str, path: P)

    // FUTURE text_ascent/text_descent