variable number of textures?

src/game/entities.rs

@@ -1,4 +1,6 @@
-use crate::{input::InputState, text::{create_text_object, update_text}, vulkan::{PERF_COUNTER_SIZE, VulkanRenderer, gameobject::{GameObject, GameObjectHandle, Updatable}}};
+use cgmath::{Vector4, vec4};
+
+use crate::{input::InputState, text::{create_text_object, update_text}, vulkan::{MeshHandle, PERF_COUNTER_SIZE, VulkanRenderer, gameobject::{GameObject, GameObjectHandle, Updatable}, mesh::{CPUMesh, CPUVertexList}}};
 
 use super::{GameState, TestGame};
 
@@ -27,4 +29,31 @@ impl Updatable for FpsCounter {
         let text = format!("Update: {:.0}ms\nRender: {:.0}ms\nTotal: {:.0}ms (±{:.1})\nDelta: {:.0}ms", update_duration as f64 / 1000., render_duration as f64 / 1000., other_duration as f64 / 1000., f64::sqrt(other_variance as f64) / 1000., _delta_time * 1000.);
         update_text(self.game_object, &text, 30., renderer, &mut game_state.brush, game_objects);
     }
+}
+
+pub struct UiQuad {
+    pub game_object: GameObjectHandle,
+    pub background_color: Vector4<f32>,
+}
+
+impl UiQuad {
+    pub fn new(game: &mut TestGame, renderer: &mut VulkanRenderer) -> UiQuad {
+        let quad_verts = vec![];
+        let cpu_mesh = CPUMesh { vertices: CPUVertexList::Vertex3D(quad_verts), indices: vec![0, 1, 2, 1, 3, 2], local_texture_index: None, local_normal_map_index: None, name: None };
+        let mesh_index = renderer.upload_mesh(cpu_mesh, None);
+        let mesh_handle = MeshHandle {
+            index: mesh_index,
+            textures: vec![],
+            original_path: None,
+            pipeline_index: 1
+        };
+        let go = game.add_game_object(renderer, mesh_handle);
+        UiQuad { game_object: go, background_color: vec4(0., 0., 255., 0.) }
+    }
+}
+
+impl Updatable for UiQuad {
+    fn update(&mut self, delta_time: f32, input: &InputState, game_state: &mut GameState, game_objects: &mut Vec<GameObject>, renderer: &mut VulkanRenderer) {
+        todo!()
+    }
 }

src/game/mod.rs

@@ -6,7 +6,7 @@ use winit::event::Event;
 use level::{load_level, save_level};
 use player::Player;
 
-use crate::game::components::FpsCounter;
+use crate::game::entities::FpsCounter;
 use crate::text::create_brush;
 use crate::{config::LogConfig, vulkan};
 use crate::input::InputState;
@@ -17,7 +17,7 @@ use crate::vulkan::pipelines::vs::ty::ObjectUniformData;
 
 pub mod player;
 mod level;
-mod components;
+mod entities;
 
 pub struct GameState {
     pub paused: bool,
@@ -176,8 +176,7 @@ impl TestGame {
             let mesh_id = renderer.upload_mesh(cpu_mesh, Some(gltf_path.to_string()));
             let mesh_handle = MeshHandle {
                 index: mesh_id,
-                diffuse_handle: diffuse_id,
+                textures: vec![diffuse_id, normal_id],
-                normal_handle: Some(normal_id),
                 original_path: Some(gltf_path.to_string()),
                 pipeline_index: 0
             };

src/text.rs

@@ -12,7 +12,8 @@ pub fn update_text(game_object_handle: GameObjectHandle, new_text: &str, new_siz
     let mesh_index = go.mesh_index;
 
     match brush.process_queued(|rect, text_data| {
-        update_text_texture(Some(go.textures.texture_index), renderer, rect, text_data);
+        debug_assert!(go.textures.len() == 1);
+        update_text_texture(Some(go.textures[0]), renderer, rect, text_data);
     }, convert_vertices) {
         Ok(BrushAction::Draw(quads)) => {
             update_text_quads(quads, 420, Some(mesh_index), renderer);
@@ -20,7 +21,8 @@ pub fn update_text(game_object_handle: GameObjectHandle, new_text: &str, new_siz
         Ok(BrushAction::ReDraw) => {},
         Err(BrushError::TextureTooSmall { suggested }) => {
             let size = Dimensions::Dim2d { width: suggested.0, height: suggested.1 };
-            renderer.resize_texture(go, go.textures.texture_index, size);
+            debug_assert!(go.textures.len() == 1);
+            renderer.resize_texture(go, go.textures[0], size);
             brush.resize_texture(suggested.0, suggested.1);
             update_text(game_object_handle, new_text, new_size, renderer, brush, game_objects);
         },
@@ -100,8 +102,7 @@ pub fn update_text_quads(quads: Vec<Vec<TextVertex>>, texture_index: usize, mesh
         let mesh_index = renderer.upload_mesh(mesh, None);
         Some(MeshHandle {
             index: mesh_index,
-            diffuse_handle: texture_index,
+            textures: vec![texture_index],
-            normal_handle: None,
             original_path: None,
             pipeline_index: 1
         })

src/vulkan/gameobject.rs

@@ -12,7 +12,7 @@ use super::pipelines::vs;
 #[derive(Clone)]
 pub struct GameObject {
     pub mesh_index: usize,
-    pub textures: TextureData,
+    pub textures: Vec<TextureHandle>,
     pub position: Vector3<f32>,
     pub rotation: Quaternion<f32>,
     pub scale: Vector3<f32>,
@@ -23,20 +23,9 @@ pub struct GameObject {
     pub visible: bool,
 }
 
-#[derive(Clone)]
-pub struct TextureData {
-    pub texture_index: TextureHandle,
-    pub normal_map_index: TextureHandle,
-}
-
 impl GameObject {
     pub fn new(mesh: MeshHandle) -> GameObject {
-        let textures = TextureData {
+        GameObject { mesh_index: mesh.index, textures: mesh.textures, position: Vector3::new(0.0, 0.0, 0.0),
-            texture_index: mesh.diffuse_handle,
-            normal_map_index: mesh.normal_handle.unwrap_or(0),
-        };
-
-        GameObject { mesh_index: mesh.index, textures, position: Vector3::new(0.0, 0.0, 0.0),
             rotation: Quaternion::new(1.0, 0.0, 0.0, 0.0), scale: Vector3::new(1.0, 1.0, 1.0), children: vec![],
             descriptor_sets: vec![], is_selected: false, pipeline_index: mesh.pipeline_index, visible: true }
     }

src/vulkan/mod.rs

@@ -92,8 +92,7 @@ pub struct Mesh<V> {
 #[derive(Debug, Clone)]
 pub struct MeshHandle {
     pub index: usize,
-    pub diffuse_handle: TextureHandle,
+    pub textures: Vec<TextureHandle>,
-    pub normal_handle: Option<TextureHandle>,
     pub original_path: Option<String>,
     pub pipeline_index: usize
 }

src/vulkan/pipelines.rs

@@ -14,7 +14,7 @@ use crate::vulkan::{LinePoint, Vertex};
 use crate::vulkan::GameData;
 use crate::VulkanRenderer;
 
-use super::gameobject::TextureData;
+use super::TextureHandle;
 
 type RP = Arc<dyn RenderPassAbstract + Send + Sync>;
 type GP = Arc<dyn GraphicsPipelineAbstract + Send + Sync>;
@@ -22,7 +22,7 @@ type DS = Arc<dyn DescriptorSet + Send + Sync>;
 
 pub trait Drawcall {
     fn draw(self: &Self, builder: &mut AutoCommandBufferBuilder, fb_index: usize, game_objects: Vec<&GameObject>, game_data: &GameData, dynamic_state: &DynamicState);
-    fn create_descriptor_set(self: &Self, textures: &TextureData, renderer: &VulkanRenderer) -> Vec<DS>;
+    fn create_descriptor_set(self: &Self, textures: &Vec<TextureHandle>, renderer: &VulkanRenderer) -> Vec<DS>;
     fn recreate_pipeline(self: &mut Self, device: Arc<Device>, render_pass: RP);
     fn get_pipeline(self: &Self) -> &GP;
 }
@@ -155,17 +155,16 @@ impl Drawcall for DefaultShader {
         }
     }
 
-    fn create_descriptor_set(self: &Self, textures: &TextureData, renderer: &VulkanRenderer) -> Vec<DS> {
+    fn create_descriptor_set(self: &Self, textures: &Vec<TextureHandle>, renderer: &VulkanRenderer) -> Vec<DS> {
         let descriptor_set_layout = self.get_pipeline().descriptor_set_layout(0).unwrap().clone();
 
-        println!("Diff: {:?}, Norm: {:?}", textures.texture_index, textures.normal_map_index);
-
         renderer.uniform_buffers.iter().map(|uniform_buffer| {
             let descriptor_set: Arc<(dyn vulkano::descriptor::DescriptorSet + std::marker::Send + std::marker::Sync + 'static)>;
             let builder = PersistentDescriptorSet::start(descriptor_set_layout.clone());
-
+            
-            let diffuse = &renderer.game_data.textures[textures.texture_index];
+            debug_assert!(textures.len() == 2, "Expected diffuse and normal map for object shader!");
-            let normal_map = &renderer.game_data.textures[textures.normal_map_index];
+            let diffuse = &renderer.game_data.textures[textures[0]];
+            let normal_map = &renderer.game_data.textures[textures[1]];
 
             descriptor_set = Arc::new(builder
                 .add_buffer(uniform_buffer.clone()).unwrap()
@@ -241,7 +240,7 @@ impl Drawcall for LineShader {
             game_data.line_push_constants.clone()).unwrap();
     }
 
-    fn create_descriptor_set(self: &Self, _textures: &TextureData, _renderer: &VulkanRenderer) -> Vec<DS> {
+    fn create_descriptor_set(self: &Self, _textures: &Vec<TextureHandle>, _renderer: &VulkanRenderer) -> Vec<DS> {
         vec![]
     }
 
@@ -341,14 +340,15 @@ impl Drawcall for TextShader {
         }
     }
 
-    fn create_descriptor_set(self: &Self, textures: &TextureData, renderer: &VulkanRenderer) -> Vec<DS> {
+    fn create_descriptor_set(self: &Self, textures: &Vec<TextureHandle>, renderer: &VulkanRenderer) -> Vec<DS> {
         let descriptor_set_layout = self.get_pipeline().descriptor_set_layout(0).unwrap().clone();
 
         renderer.uniform_buffers.iter().map(|uniform_buffer| {
             let descriptor_set: Arc<(dyn vulkano::descriptor::DescriptorSet + std::marker::Send + std::marker::Sync + 'static)>;
             let builder = PersistentDescriptorSet::start(descriptor_set_layout.clone());
 
-            let diffuse = &renderer.game_data.textures[textures.texture_index];
+            debug_assert!(textures.len() == 1, "Expected only diffuse map for text shader!");
+            let diffuse = &renderer.game_data.textures[textures[0]];
             println!("Using diffuse image with size {:?}", diffuse.image.dimensions());
 
             descriptor_set = Arc::new(builder