rust/lib-hedgewars-engine/src/render/atlas.rs
changeset 14749 069291842d52
parent 14748 2cc36cb1c258
child 14764 731c8406bff0
equal deleted inserted replaced
14748:2cc36cb1c258 14749:069291842d52
   125             })
   125             })
   126             .cloned()
   126             .cloned()
   127             .collect();
   127             .collect();
   128     }
   128     }
   129 
   129 
   130     pub fn insert(&mut self, size: Size) -> Option<Rect> {
   130     fn split_insert(&mut self, rect: Rect) {
   131         let (rect, _) = self.find_position(size)?;
       
   132         let mut splits = vec![];
   131         let mut splits = vec![];
   133 
   132 
   134         for i in (0..self.free_rects.len()).rev() {
   133         for i in (0..self.free_rects.len()).rev() {
   135             if split_rect(self.free_rects[i], rect, &mut splits) {
   134             if split_rect(self.free_rects[i], rect, &mut splits) {
   136                 self.free_rects.swap_remove(i as usize);
   135                 self.free_rects.swap_remove(i as usize);
   137             }
   136             }
   138         }
   137         }
       
   138 
   139         self.free_rects.extend(splits);
   139         self.free_rects.extend(splits);
   140         self.prune();
   140         self.prune();
   141 
       
   142         self.used_rects.push(rect);
   141         self.used_rects.push(rect);
       
   142     }
       
   143 
       
   144     pub fn insert(&mut self, size: Size) -> Option<Rect> {
       
   145         let (rect, _) = self.find_position(size)?;
       
   146         self.split_insert(rect);
   143         Some(rect)
   147         Some(rect)
   144     }
   148     }
   145 
   149 
   146     pub fn insert_set<Iter>(&mut self, sizes: Iter) -> Vec<Rect>
   150     pub fn insert_set<Iter>(&mut self, sizes: Iter) -> Vec<Rect>
   147     where
   151     where
   154             .iter()
   158             .iter()
   155             .enumerate()
   159             .enumerate()
   156             .filter_map(|(i, s)| self.find_position(*s).map(|res| (i, res)))
   160             .filter_map(|(i, s)| self.find_position(*s).map(|res| (i, res)))
   157             .min_by_key(|(_, (_, fit))| fit.clone())
   161             .min_by_key(|(_, (_, fit))| fit.clone())
   158         {
   162         {
       
   163             self.split_insert(rect);
       
   164 
   159             result.push(rect);
   165             result.push(rect);
   160             sizes.swap_remove(index);
   166             sizes.swap_remove(index);
   161         }
   167         }
   162         if sizes.is_empty() {
   168         result
   163             self.used_rects.extend_from_slice(&result);
       
   164             result
       
   165         } else {
       
   166             vec![]
       
   167         }
       
   168     }
   169     }
   169 
   170 
   170     pub fn reset(&mut self) {
   171     pub fn reset(&mut self) {
   171         self.free_rects.clear();
   172         self.free_rects.clear();
   172         self.used_rects.clear();
   173         self.used_rects.clear();