mipmaps?

Cargo.toml

@@ -5,11 +5,11 @@ authors = ["Till <asuro@posteo.de>"]
 edition = "2018"
 
 [dependencies]
-vulkano-shaders = "0.19.0"
+vulkano-shaders = "0.20"
-vulkano = "0.19.0"
+vulkano = "0.20"
-vulkano-win = "0.19.0"
+vulkano-win = "0.20"
 cgmath = "0.17.0"
-winit = "0.22.2"
+winit = "0.24"
 image = "0.23.6"
 serde = "1.0.114"
 serde_json = "1.0.59"

build/renderdoc-settings.cap

@@ -0,0 +1,27 @@
+{
+    "rdocCaptureSettings": 1,
+    "settings": {
+        "autoStart": false,
+        "commandLine": "",
+        "environment": [
+        ],
+        "executable": "D:\\Code\\rust-engine\\target\\debug\\rust-engine.exe",
+        "inject": false,
+        "numQueuedFrames": 0,
+        "options": {
+            "allowFullscreen": true,
+            "allowVSync": true,
+            "apiValidation": false,
+            "captureAllCmdLists": false,
+            "captureCallstacks": false,
+            "captureCallstacksOnlyDraws": false,
+            "debugOutputMute": true,
+            "delayForDebugger": 0,
+            "hookIntoChildren": false,
+            "refAllResources": false,
+            "verifyBufferAccess": false
+        },
+        "queuedFrameCap": 0,
+        "workingDir": "D:/Code/rust-engine"
+    }
+}

src/game/mod.rs

@@ -107,8 +107,6 @@ impl TestGame {
     }
 
     pub fn game_start(self: &mut Self, renderer: &mut VulkanRenderer) {
-        // let plane_mesh = self.load_gltf(renderer, "models/plane.gltf");
-        // self.add_game_object(renderer, plane_mesh[0].clone());
         load_level("levels/test.lvl", self, renderer).unwrap();
         println!("Game loaded!");
     }

src/vulkan/mod.rs

@@ -4,13 +4,13 @@ use std::time::SystemTime;
 use cgmath::{Matrix4, SquareMatrix};
 use image::{ImageBuffer, Rgb, Rgba};
 use image::buffer::ConvertBuffer;
-use vulkano::{buffer::{BufferUsage, CpuAccessibleBuffer}, command_buffer::CommandBuffer, image::{ImageLayout, MipmapsCount}};
+use vulkano::{buffer::{BufferUsage, CpuAccessibleBuffer}, command_buffer::SubpassContents, image::MipmapsCount};
 use vulkano::command_buffer::{AutoCommandBuffer, AutoCommandBufferBuilder, DynamicState};
 use vulkano::descriptor::DescriptorSet;
 use vulkano::device::{Device, DeviceExtensions, Queue};
 use vulkano::format::{ClearValue, Format};
 use vulkano::framebuffer::{RenderPassAbstract, FramebufferAbstract};
-use vulkano::image::{Dimensions, ImageUsage, ImmutableImage};
+use vulkano::image::{Dimensions, ImmutableImage};
 use vulkano::instance::{ApplicationInfo, Instance, InstanceExtensions, PhysicalDevice, Version};
 use vulkano::instance::debug::{DebugCallback, MessageSeverity, MessageType};
 use vulkano::sampler::{Filter, MipmapMode, Sampler, SamplerAddressMode};
@@ -251,7 +251,7 @@ impl VulkanRenderer {
 
         let pipelines: Vec<Box<dyn Drawcall>> = vec![
             Box::new(DefaultShader::new(device.clone(), render_pass.clone())),
-            Box::new(LineShader::new(device.clone(), render_pass.clone(), line_vertex_buffer.clone())),
+            // Box::new(LineShader::new(device.clone(), render_pass.clone(), line_vertex_buffer.clone())),
         ];
 
         // Dynamic viewports allow us to recreate just the viewport when the window is resized
@@ -306,9 +306,9 @@ impl VulkanRenderer {
         let mut builder = AutoCommandBufferBuilder::primary_simultaneous_use(self.device.clone(), self.queue.family()).unwrap();
         builder.update_buffer(self.uniform_buffers[fb_index].clone(), uniform_buffer_data).unwrap();
         if self.render_config.msaa_samples > 0 {
-            builder.begin_render_pass(self.framebuffers[fb_index].clone(), false, vec![ClearValue::None, ClearValue::Float([0.0, 0.0, 0.0, 1.0]), ClearValue::Depth(1.0)]).unwrap();
+            builder.begin_render_pass(self.framebuffers[fb_index].clone(), SubpassContents::Inline, vec![ClearValue::None, ClearValue::Float([0.0, 0.0, 0.0, 1.0]), ClearValue::Depth(1.0)]).unwrap();
         } else {
-            builder.begin_render_pass(self.framebuffers[fb_index].clone(), false, vec![ClearValue::Float([0.0, 0.0, 0.0, 1.0]), ClearValue::Depth(1.0)]).unwrap();
+            builder.begin_render_pass(self.framebuffers[fb_index].clone(), SubpassContents::Inline, vec![ClearValue::Float([0.0, 0.0, 0.0, 1.0]), ClearValue::Depth(1.0)]).unwrap();
         }
 
         // Draw meshes etc.
@@ -445,60 +445,8 @@ impl VulkanRenderer {
             new_buffer.iter().cloned(),
         ).unwrap();
 
-        // Create image
+        let (image_view, future) = ImmutableImage::from_buffer(source.clone(), dimensions, MipmapsCount::Log2, Format::R8G8B8A8Unorm, self.queue.clone()).unwrap();
-        let (image_view, init) = ImmutableImage::uninitialized(
+        future.flush().unwrap();
-            self.device.clone(),
-            dimensions,
-            Format::R8G8B8A8Unorm,
-            MipmapsCount::Log2,
-            ImageUsage {
-                transfer_source: true,
-                transfer_destination: true,
-                sampled: true,
-                ..ImageUsage::none()
-            },
-            ImageLayout::ShaderReadOnlyOptimal,
-            self.device.active_queue_families()
-        ).unwrap();
-
-        // Upload image data
-        let mut command_buffer_builder = AutoCommandBufferBuilder::new(self.device.clone(), self.queue.family()).unwrap();
-        command_buffer_builder.copy_buffer_to_image_dimensions(
-            source,
-            init,
-            [0, 0, 0],
-            dimensions.width_height_depth(),
-            0,
-            dimensions.array_layers_with_cube(),
-            0,
-        ).unwrap();
-
-        // Generate mipmaps
-        // let mut mip_width = image_view.dimensions().width() as i32;
-        // let mut mip_height = image_view.dimensions().height() as i32;
-
-        // for i in 0..image_view.mipmap_levels() {
-        //     command_buffer_builder.blit_image(
-        //         image_view.clone(),
-        //         [0; 3],
-        //         [mip_width, mip_height, 1],
-        //         0,
-        //         i,
-        //         image_view.clone(),
-        //         [0; 3],
-        //         [mip_width / 2, mip_height / 2, 1],
-        //         0,
-        //         i + 1,
-        //         dimensions.array_layers_with_cube(),
-        //         Filter::Linear).unwrap();
-
-        //     if mip_width > 1 { mip_width = mip_width / 2; }
-        //     if mip_height > 1 { mip_height = mip_height / 2; }
-        // }
-
-        let command_buffer = command_buffer_builder.build().unwrap();
-        let command_buffer_future = command_buffer.execute(self.queue.clone()).unwrap();
-        command_buffer_future.flush().unwrap();
 
         self.game_data.textures.push(image_view);
     }