engine/vulkan: use multi-keyed resourcemaps for sorting resources

engine/src/render/vulkan/mod.rs

@@ -1,4 +1,3 @@
-use std::collections::HashMap;
 use std::sync::Arc;
 use std::time;
 use log;
@@ -164,15 +163,17 @@ impl<WT: 'static + Send + Sync> Instance<WT> {
         let mut buffers: Vec<Box<vc::AutoCommandBuffer>> = vec![];
 
 
-        // Sort renderables by mesh.
-        let mut meshes: ResourceMap<&cgm::Matrix4<f32>> = ResourceMap::new();
-        let mut textures: HashMap<renderable::ResourceID, renderable::ResourceID> = HashMap::new();
+        // Sort renderables by mesh and textureid.
+        let mut meshes: ResourceMap<(renderable::ResourceID, renderable::ResourceID), &cgm::Matrix4<f32>> = ResourceMap::new();
+
+        let ubo = data::UniformBufferObject {
+            view: proj * view,
+        };
 
         profiler.end("mgc.prep");
         for r in renderables {
             if let Some((mesh_id, texture_id, transform)) = r.render_data() {
-                textures.entry(mesh_id).or_insert(texture_id);
-                meshes.add(mesh_id, transform);
+                meshes.add((mesh_id, texture_id), transform);
             }
         }
         profiler.end("mgc.sort");
@@ -183,18 +184,13 @@ impl<WT: 'static + Send + Sync> Instance<WT> {
 
         let pipeline = self.pipeline.as_ref().unwrap().get_pipeline().clone();
 
-        for (mesh_id, transforms) in meshes.resources {
+        for ((mesh_id, texture_id), transforms) in meshes.resources {
             let mesh = rm.mesh(&mesh_id).unwrap();
-            let texture_id = textures.get(&mesh_id).unwrap();
             let texture = rm.texture(&texture_id).unwrap();
 
             let mut builder = vc::AutoCommandBufferBuilder::secondary_graphics_one_time_submit(
                 device.clone(), queue.family(), vf::Subpass::from(rp.clone(), 0).unwrap()).unwrap();
 
-            let ubo = data::UniformBufferObject {
-                view: proj * view,
-            };
-
             let (instancebuffer, future) = vb::immutable::ImmutableBuffer::from_iter(
                 transforms.iter().map(|t| { data::Instance::new(t) }),
                 vb::BufferUsage::vertex_buffer(),

engine/src/util/resourcemap.rs

@@ -1,3 +1,5 @@
+use std::cmp::PartialEq;
+
 use crate::render::renderable::ResourceID;
 
 /// A map from ResourceID to Vec<T>, useful for building up information about
@@ -5,11 +7,11 @@ use crate::render::renderable::ResourceID;
 /// compared to a HashMap as it performs no hashing - just uses ResourceIDs.
 /// In the future, this could be ported over to a tree implemention from the
 /// current naive vector-based implementation.
-pub struct ResourceMap<T> {
-    pub resources: Vec<(ResourceID, Vec<T>)>,
+pub struct ResourceMap<K, V> {
+    pub resources: Vec<(K, Vec<V>)>,
 }
 
-impl<T> ResourceMap<T> {
+impl<K: PartialEq, V> ResourceMap<K, V> {
     pub fn new() -> Self {
         Self {
             resources: vec![],
@@ -18,14 +20,14 @@ impl<T> ResourceMap<T> {
 
     /// Add to a Resource's corresponding vector, creating an empty one first
     /// if needed.
-    pub fn add(&mut self, r: ResourceID, t: T) {
-        for (res, v) in self.resources.iter_mut() {
-            if *res == r {
+    pub fn add(&mut self, k: K, t: V) {
+        for (k2, v) in self.resources.iter_mut() {
+            if *k2 == k {
                 v.push(t);
                 return;
             }
         }
 
-        self.resources.push((r, vec![t]));
+        self.resources.push((k, vec![t]));
     }
 }