One sampler per texture

src/game/mod.rs

@@ -141,7 +141,7 @@ impl TestGame {
         }
 
         textures.iter().for_each(|tex| {
-            renderer.upload_texture(tex);
+            renderer.upload_texture(tex, renderer.device.clone());
             self.texture_index_counter += 1;
         });
         mesh_handles

src/game/player.rs

@@ -79,7 +79,7 @@ impl Player {
             camera: Camera::new(),
             movement_mode: FirstPerson,
             movement_speed: 3.0,
-            look_sensitivity: 10.0,
+            look_sensitivity: 30.0,
             height: -1.0,
             cube_mesh: None
         }

src/vulkan/mod.rs

@@ -25,13 +25,13 @@ use winit::window::{Window, WindowBuilder};
 
 use mesh::CPUMesh;
 use pipelines::{Drawcall, LineShader};
-use pipelines::{line_vs::ty::LinePushConstants};
+use pipelines::line_vs::ty::LinePushConstants;
 use pipelines::DefaultShader;
 use pipelines::vs;
 use pipelines::vs::ty::PushConstants;
 
 use crate::config::RenderConfig;
-use crate::vulkan::{gameobject::{GameObject, GameObjectHandle}};
+use crate::vulkan::gameobject::{GameObject, GameObjectHandle};
 
 pub mod pipelines;
 pub mod gameobject;
@@ -83,6 +83,10 @@ pub struct MeshHandle {
 }
 
 pub(crate) type TextureHandle = usize;
+pub struct Texture {
+    pub image: Arc<ImmutableImage<Format>>,
+    pub sampler: Arc<Sampler>
+}
 
 pub struct GameData {
     pub start_time: SystemTime,
@@ -94,7 +98,7 @@ pub struct GameData {
     pub shutdown: bool,
     pub game_objects: Vec<GameObject>,
     pub meshes: Vec<Mesh>,
-    pub textures: Vec<Arc<ImmutableImage<Format>>>,
+    pub textures: Vec<Texture>,
     pub use_line_pipeline: bool,
 }
 
@@ -104,7 +108,6 @@ pub struct VulkanRenderer {
     pub game_data: GameData,
     pub device: Arc<Device>,
     pub framebuffers: Vec<Arc<dyn FramebufferAbstract + Send + Sync>>,
-    pub sampler: Arc<Sampler>,
     pub dynamic_state: DynamicState,
     pub pipelines: Vec<Box<dyn Drawcall>>,
     pub surface: Arc<Surface<Window>>,
@@ -243,10 +246,6 @@ impl VulkanRenderer {
         // Render pass
         let render_pass = renderpass::create_render_pass(device.clone(), &render_config, swapchain.format());
 
-        let sampler = Sampler::new(device.clone(), Filter::Linear, Filter::Linear,
-                                   MipmapMode::Nearest, SamplerAddressMode::Repeat, SamplerAddressMode::Repeat,
-                                   SamplerAddressMode::Repeat, 0.0, 1.0, 0.0, 0.0).unwrap();
-
         let line_vertex_buffer = CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::vertex_buffer(), false, data.line_vertices.iter().cloned()).unwrap();
 
         let pipelines: Vec<Box<dyn Drawcall>> = vec![
@@ -292,7 +291,7 @@ impl VulkanRenderer {
         // that, we store the submission of the previous frame here.
         let previous_frame_end = Some(Box::new(sync::now(device.clone())) as Box<dyn GpuFuture>);
 
-        (VulkanRenderer { game_data: data, device, framebuffers, sampler,
+        (VulkanRenderer { game_data: data, device, framebuffers,
             dynamic_state, pipelines, uniform_buffers,
             surface, swapchain, render_pass, queue,
             recreate_swapchain: false, debug_callback, previous_frame_end,
@@ -348,7 +347,7 @@ impl VulkanRenderer {
 
             self.pipelines = vec![
                 Box::new(DefaultShader::new(self.device.clone(), self.render_pass.clone())),
-                Box::new(LineShader::new(self.device.clone(), self.render_pass.clone(), self.line_vertex_buffer.clone())),
+                // Box::new(LineShader::new(self.device.clone(), self.render_pass.clone(), self.line_vertex_buffer.clone())),
             ];
 
             self.swapchain = new_swapchain;
@@ -432,7 +431,7 @@ impl VulkanRenderer {
         self.game_data.meshes.len() - 1
     }
 
-    pub fn upload_texture(self: &mut Self, texture_data: &gltf::image::Data) {
+    pub fn upload_texture(self: &mut Self, texture_data: &gltf::image::Data, device: Arc<Device>) {
         // Format buffer on cpu for upload
         let buffer: ImageBuffer<Rgb<u8>, Vec<u8>> = image::ImageBuffer::from_raw(texture_data.width, texture_data.height, texture_data.pixels.clone()).unwrap();
         let new_buffer: ImageBuffer<Rgba<u8>, Vec<u8>> = buffer.convert();
@@ -448,7 +447,11 @@ impl VulkanRenderer {
         let (image_view, future) = ImmutableImage::from_buffer(source.clone(), dimensions, MipmapsCount::Log2, Format::R8G8B8A8Unorm, self.queue.clone()).unwrap();
         future.flush().unwrap();
 
-        self.game_data.textures.push(image_view);
+        let sampler = Sampler::new(device.clone(), Filter::Linear, Filter::Linear,
+            MipmapMode::Linear, SamplerAddressMode::Repeat, SamplerAddressMode::Repeat,
+            SamplerAddressMode::Repeat, 0.0, 1.0, 0.0, image_view.mipmap_levels() as f32).unwrap();
+
+        self.game_data.textures.push(Texture { image: image_view, sampler });
     }
 
     pub fn add_game_object(self: &mut Self, mut game_object: GameObject, pipeline_index: usize) -> GameObjectHandle {

src/vulkan/pipelines.rs

@@ -96,10 +96,13 @@ impl Drawcall for DefaultShader {
             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[game_object.texture_index];
+            let normal_map = &renderer.game_data.textures[game_object.normal_map_index];
+
             descriptor_set = Arc::new(builder
                 .add_buffer(uniform_buffer.clone()).unwrap()
-                .add_sampled_image(renderer.game_data.textures[game_object.texture_index].clone(), renderer.sampler.clone()).unwrap()
-                .add_sampled_image(renderer.game_data.textures[game_object.normal_map_index].clone(), renderer.sampler.clone()).unwrap()
+                .add_sampled_image(diffuse.image.clone(), diffuse.sampler.clone()).unwrap()
+                .add_sampled_image(normal_map.image.clone(), normal_map.sampler.clone()).unwrap()
                 .build().unwrap());
 
             descriptor_set