39     }

    40 

    41     #[inline]

    42     pub fn transform(self, matrix: &[i32; 4]) -> Self {

    43         Point::new(matrix[0] * self.x + matrix[1] * self.y,

    44                    matrix[2] * self.x + matrix[3] * self.y)

    45     }

    46 }

    47 

    48 #[derive(PartialEq, Eq, Clone, Copy, Debug)]

    49 pub struct Size {

    50     pub width: usize,

    51     pub height: usize,

    52 }

    53 

    54 impl Size {

    55     #[inline]

    56     pub fn new(width: usize, height: usize) -> Self {

    57         Size { width, height }

    58     }

    59 

    60     #[inline]

    61     pub fn square(size: usize) -> Self {

    62         Size { width: size, height: size }

    63     }

    64 

    65     #[inline]

    66     pub fn area(&self) -> usize {

    67         self.width * self.height

    68     }

    69 

    70     #[inline]

    71     pub fn linear_index(&self, x: usize, y: usize) -> usize {

    72         y * self.width + x

    73     }

    74 

    75     #[inline]

    76     pub fn is_power_of_two(&self) -> bool {

    77         self.width.is_power_of_two() && self.height.is_power_of_two()

    78     }

    79 

    80     #[inline]

    81     pub fn next_power_of_two(&self) -> Self {

    82         Self {

    83             width: self.width.next_power_of_two(),

    84             height: self.height.next_power_of_two()

    85         }

    86     }

    87 

    88     #[inline]

    89     pub fn to_mask(&self) -> SizeMask {

    90         SizeMask::new(*self)

    91     }

    92 }

    93 

    94 pub struct SizeMask{ size: Size }

    95 

    96 impl SizeMask {

    97     #[inline]

    98     pub fn new(size: Size) -> Self {

    99         assert!(size.is_power_of_two());

   100         let size = Size {

   101             width: !(size.width - 1),

   102             height: !(size.height - 1)

   103         };

   104         SizeMask { size }

   105     }

   106 

   107     #[inline]

   108     pub fn contains_x<T: Into<usize>>(&self, x: T) -> bool {

   109         (self.size.width & x.into()) == 0

   110     }

   111 

   112     #[inline]

   113     pub fn contains_y<T: Into<usize>>(&self, y: T) -> bool {

   114         (self.size.height & y.into()) == 0

   115     }

   116 

   117     #[inline]

   118     pub fn contains(&self, point: Point) -> bool {

   119         self.contains_x(point.x as usize) && self.contains_y(point.y as usize)