hui 0.1.0-alpha.6

Simple UI library for games and other interactive applications
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
92
93

use derive_setters::Setters;
use glam::vec2;
use crate::{
  draw::{ImageHandle, RoundedCorners, UiDrawCommand},
  element::{MeasureContext, ProcessContext, UiElement},
  layout::{compute_size, Size, Size2d},
  measure::Response,
  rect::{Corners, FillColor},
};

#[derive(Setters)]
#[setters(prefix = "with_")]
pub struct Image {
  /// Image handle to draw
  #[setters(skip)]
  pub image: ImageHandle,

  /// Size of the image.
  ///
  /// - If one of the dimensions is `Size::Auto`, the image will be scaled to fit the other dimension\
  ///   (aspect ratio is preserved)
  /// - If both dimensions are `Size::Auto`, the image will be drawn at its original size
  /// - All other values behave as expected
  #[setters(into)]
  pub size: Size2d,

  /// Color of the image
  ///
  /// Image will get multiplied/tinted by this color or gradient
  #[setters(into)]
  pub color: FillColor,

  /// Corner radius of the image
  #[setters(into)]
  pub corner_radius: Corners<f32>,
}

impl Image {
  pub fn new(handle: ImageHandle) -> Self {
    Self {
      image: handle,
      size: Size2d {
        width: Size::Auto,
        height: Size::Auto,
      },
      color: (1., 1., 1.).into(),
      corner_radius: Corners::all(0.),
    }
  }
}

impl UiElement for Image {
  fn name(&self) -> &'static str {
    "image"
  }

  fn size(&self) -> Option<Size2d> {
    Some(self.size)
  }

  fn measure(&self, ctx: MeasureContext) -> Response {
    let dim = ctx.images.get_size(self.image).expect("invalid image handle");
    let pre_size = compute_size(ctx.layout, self.size, dim.as_vec2());
    Response {
      size: compute_size(ctx.layout, self.size, vec2(
        match self.size.height {
          Size::Auto => dim.x as f32,
          _ => (pre_size.y / dim.y as f32) * dim.x as f32,
        },
        match self.size.height {
          Size::Auto => dim.x as f32,
          _ => (pre_size.y / dim.y as f32) * dim.x as f32,
        },
      )),
      ..Default::default()
    }
  }

  fn process(&self, ctx: ProcessContext) {
    if !self.color.is_transparent() {
      ctx.draw.add(UiDrawCommand::Rectangle {
        position: ctx.layout.position,
        size: ctx.measure.size,
        color: self.color.corners(),
        texture: Some(self.image),
        texture_uv: None,
        rounded_corners: (self.corner_radius.max_f32() > 0.).then_some({
          RoundedCorners::from_radius(self.corner_radius)
        }),
      });
    }
  }
}