Fix disappearing images or panics when hiding and showing a window with wayland

Properly release GL resource when unmapping a window and detect stale
cache indices using a generation count. This fixes the disappearing
images (GL textures would be invalid and need to be re-created) as well
as the panics when an item's cache index ended up being re-used because
some other item was drawn first and allocated that indices. The latter
is fixed by using a generational counter on the cache that's bumped when
clearing, instead of a single "cache_ok" bool.

sixtyfps_runtime/corelib/graphics.rs

@@ -93,8 +93,51 @@ impl<T> CachedGraphicsData<T> {
 /// The RenderingCache, in combination with CachedGraphicsData, allows backends to store data that's either
 /// intensive to compute or has bad CPU locality. Backends typically keep a RenderingCache instance and use
 /// the item's cached_rendering_data() integer as index in the vec_arena::Arena.
-pub type RenderingCache<T> = slab::Slab<CachedGraphicsData<T>>;
+pub struct RenderingCache<T> {
+    slab: slab::Slab<CachedGraphicsData<T>>,
+    generation: usize,
+}
 
+impl<T> Default for RenderingCache<T> {
+    fn default() -> Self {
+        Self { slab: Default::default(), generation: 1 }
+    }
+}
+
+impl<T> RenderingCache<T> {
+    /// Returns the generation of the cache. The generation starts at 1 and is increased
+    /// whenever the cache is cleared, for example when the GL context is lost.
+    pub fn generation(&self) -> usize {
+        self.generation
+    }
+
+    /// Retrieves a mutable reference to the cached graphics data at index.
+    pub fn get_mut(&mut self, index: usize) -> Option<&mut CachedGraphicsData<T>> {
+        self.slab.get_mut(index)
+    }
+
+    /// Inserts data into the cache and returns the index for retrieval later.
+    pub fn insert(&mut self, data: CachedGraphicsData<T>) -> usize {
+        self.slab.insert(data)
+    }
+
+    /// Retrieves an immutable reference to the cached graphics data at index.
+    pub fn get(&self, index: usize) -> Option<&CachedGraphicsData<T>> {
+        self.slab.get(index)
+    }
+
+    /// Removes the cached graphics data at the given index.
+    pub fn remove(&mut self, index: usize) -> CachedGraphicsData<T> {
+        self.slab.remove(index)
+    }
+
+    /// Removes all entries from the cache and increases the cache's generation count, so
+    /// that stale index access can be avoided.
+    pub fn clear(&mut self) {
+        self.slab.clear();
+        self.generation += 1;
+    }
+}
 /// FontRequest collects all the developer-configurable properties for fonts, such as family, weight, etc.
 /// It is submitted as a request to the platform font system (i.e. CoreText on macOS) and in exchange the
 /// backend returns a Box<dyn Font>.