-
Notifications
You must be signed in to change notification settings - Fork 432
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Fix support for 2D array images (#1803)
* Fix mipmap generation for arrayed images * Add example for texture array * Change ImageView constructor to explicitly require ImageViewType * Revert "Change ImageView constructor to explicitly require ImageViewType" This reverts commit 3ad5571.
- Loading branch information
Showing
5 changed files
with
425 additions
and
42 deletions.
There are no files selected for viewing
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,381 @@ | ||
// Copyright (c) 2016 The vulkano developers | ||
// Licensed under the Apache License, Version 2.0 | ||
// <LICENSE-APACHE or | ||
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT | ||
// license <LICENSE-MIT or https://opensource.org/licenses/MIT>, | ||
// at your option. All files in the project carrying such | ||
// notice may not be copied, modified, or distributed except | ||
// according to those terms. | ||
|
||
use std::io::Cursor; | ||
use std::sync::Arc; | ||
|
||
use png; | ||
use winit::event::{Event, WindowEvent}; | ||
use winit::event_loop::{ControlFlow, EventLoop}; | ||
use winit::window::{Window, WindowBuilder}; | ||
|
||
use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer, TypedBufferAccess}; | ||
use vulkano::command_buffer::{AutoCommandBufferBuilder, CommandBufferUsage, SubpassContents}; | ||
use vulkano::descriptor_set::{PersistentDescriptorSet, WriteDescriptorSet}; | ||
use vulkano::device::{Device, DeviceExtensions, Features}; | ||
use vulkano::device::physical::{PhysicalDevice, PhysicalDeviceType}; | ||
use vulkano::format::Format; | ||
use vulkano::image::{ | ||
ImageDimensions, ImageUsage, ImmutableImage, MipmapsCount, SwapchainImage, view::ImageView, | ||
}; | ||
use vulkano::image::ImageAccess; | ||
use vulkano::instance::Instance; | ||
use vulkano::pipeline::{GraphicsPipeline, Pipeline, PipelineBindPoint}; | ||
use vulkano::pipeline::graphics::color_blend::ColorBlendState; | ||
use vulkano::pipeline::graphics::input_assembly::{InputAssemblyState, PrimitiveTopology}; | ||
use vulkano::pipeline::graphics::vertex_input::BuffersDefinition; | ||
use vulkano::pipeline::graphics::viewport::{Viewport, ViewportState}; | ||
use vulkano::render_pass::{Framebuffer, RenderPass, Subpass}; | ||
use vulkano::sampler::{Filter, Sampler, SamplerAddressMode}; | ||
use vulkano::swapchain::{self, AcquireError, Swapchain, SwapchainCreationError}; | ||
use vulkano::sync::{self, FlushError, GpuFuture}; | ||
use vulkano::Version; | ||
use vulkano_win::VkSurfaceBuild; | ||
|
||
fn main() { | ||
// This example is about this: | ||
// uniform sampler2DArray texture_array; | ||
// And not this: | ||
// uniform sampler2D array_of_textures[42]; | ||
|
||
let required_extensions = vulkano_win::required_extensions(); | ||
let instance = Instance::new(None, Version::V1_1, &required_extensions, None).unwrap(); | ||
|
||
let event_loop = EventLoop::new(); | ||
let surface = WindowBuilder::new() | ||
.build_vk_surface(&event_loop, instance.clone()) | ||
.unwrap(); | ||
|
||
let device_extensions = DeviceExtensions { | ||
khr_swapchain: true, | ||
..DeviceExtensions::none() | ||
}; | ||
let (physical_device, queue_family) = PhysicalDevice::enumerate(&instance) | ||
.filter(|&p| p.supported_extensions().is_superset_of(&device_extensions)) | ||
.filter_map(|p| { | ||
p.queue_families() | ||
.find(|&q| q.supports_graphics() && surface.is_supported(q).unwrap_or(false)) | ||
.map(|q| (p, q)) | ||
}) | ||
.min_by_key(|(p, _)| match p.properties().device_type { | ||
PhysicalDeviceType::DiscreteGpu => 0, | ||
PhysicalDeviceType::IntegratedGpu => 1, | ||
PhysicalDeviceType::VirtualGpu => 2, | ||
PhysicalDeviceType::Cpu => 3, | ||
PhysicalDeviceType::Other => 4, | ||
}) | ||
.unwrap(); | ||
|
||
println!( | ||
"Using device: {} (type: {:?})", | ||
physical_device.properties().device_name, | ||
physical_device.properties().device_type, | ||
); | ||
|
||
let (device, mut queues) = Device::new( | ||
physical_device, | ||
&Features::none(), | ||
&physical_device | ||
.required_extensions() | ||
.union(&device_extensions), | ||
[(queue_family, 0.5)].iter().cloned(), | ||
) | ||
.unwrap(); | ||
let queue = queues.next().unwrap(); | ||
|
||
let (mut swapchain, images) = { | ||
let caps = surface.capabilities(physical_device).unwrap(); | ||
let composite_alpha = caps.supported_composite_alpha.iter().next().unwrap(); | ||
let format = caps.supported_formats[0].0; | ||
let dimensions: [u32; 2] = surface.window().inner_size().into(); | ||
|
||
Swapchain::start(device.clone(), surface.clone()) | ||
.num_images(caps.min_image_count) | ||
.format(format) | ||
.dimensions(dimensions) | ||
.usage(ImageUsage::color_attachment()) | ||
.sharing_mode(&queue) | ||
.composite_alpha(composite_alpha) | ||
.build() | ||
.unwrap() | ||
}; | ||
|
||
#[repr(C)] | ||
#[derive(Default, Debug, Clone)] | ||
struct Vertex { | ||
position: [f32; 2], | ||
} | ||
vulkano::impl_vertex!(Vertex, position); | ||
|
||
let vertex_buffer = CpuAccessibleBuffer::<[Vertex]>::from_iter( | ||
device.clone(), | ||
BufferUsage::all(), | ||
false, | ||
[ | ||
Vertex { | ||
position: [-0.2, -0.5], | ||
}, | ||
Vertex { | ||
position: [-0.5, 0.8], | ||
}, | ||
Vertex { | ||
position: [0.4, -0.5], | ||
}, | ||
Vertex { | ||
position: [0.5, 0.2], | ||
}, | ||
] | ||
.iter() | ||
.cloned(), | ||
) | ||
.unwrap(); | ||
|
||
let vs = vs::load(device.clone()).unwrap(); | ||
let fs = fs::load(device.clone()).unwrap(); | ||
|
||
let render_pass = vulkano::single_pass_renderpass!(device.clone(), | ||
attachments: { | ||
color: { | ||
load: Clear, | ||
store: Store, | ||
format: swapchain.format(), | ||
samples: 1, | ||
} | ||
}, | ||
pass: { | ||
color: [color], | ||
depth_stencil: {} | ||
} | ||
) | ||
.unwrap(); | ||
|
||
let (texture, tex_future) = { | ||
let image_array_data: Vec<_> = vec![include_bytes!("square.png").to_vec(), include_bytes!("star.png").to_vec(), include_bytes!("asterisk.png").to_vec()] | ||
.into_iter().flat_map(|png_bytes| { | ||
let cursor = Cursor::new(png_bytes); | ||
let decoder = png::Decoder::new(cursor); | ||
let mut reader = decoder.read_info().unwrap(); | ||
let info = reader.info(); | ||
let mut image_data = Vec::new(); | ||
image_data.resize((info.width * info.height * 4) as usize, 0); | ||
reader.next_frame(&mut image_data).unwrap(); | ||
image_data | ||
}).collect(); | ||
let dimensions = ImageDimensions::Dim2d { | ||
width: 128, | ||
height: 128, | ||
array_layers: 3, | ||
}; // TODO replace with your actual image array dimensions | ||
let (image, future) = ImmutableImage::from_iter( | ||
image_array_data.iter().cloned(), | ||
dimensions, | ||
MipmapsCount::Log2, | ||
Format::R8G8B8A8_SRGB, | ||
queue.clone(), | ||
) | ||
.unwrap(); | ||
(ImageView::new(image).unwrap(), future) | ||
}; | ||
|
||
let sampler = Sampler::simple_repeat_linear(device.clone()).unwrap(); | ||
|
||
let subpass = Subpass::from(render_pass.clone(), 0).unwrap(); | ||
let pipeline = GraphicsPipeline::start() | ||
.vertex_input_state(BuffersDefinition::new().vertex::<Vertex>()) | ||
.vertex_shader(vs.entry_point("main").unwrap(), ()) | ||
.input_assembly_state(InputAssemblyState::new().topology(PrimitiveTopology::TriangleStrip)) | ||
.viewport_state(ViewportState::viewport_dynamic_scissor_irrelevant()) | ||
.fragment_shader(fs.entry_point("main").unwrap(), ()) | ||
.color_blend_state(ColorBlendState::new(subpass.num_color_attachments()).blend_alpha()) | ||
.render_pass(subpass) | ||
.build(device.clone()) | ||
.unwrap(); | ||
|
||
let layout = pipeline.layout().descriptor_set_layouts().get(0).unwrap(); | ||
let set = PersistentDescriptorSet::new( | ||
layout.clone(), | ||
[WriteDescriptorSet::image_view_sampler( | ||
0, | ||
texture.clone(), | ||
sampler.clone(), | ||
)], | ||
) | ||
.unwrap(); | ||
|
||
let mut viewport = Viewport { | ||
origin: [0.0, 0.0], | ||
dimensions: [0.0, 0.0], | ||
depth_range: 0.0..1.0, | ||
}; | ||
let mut framebuffers = window_size_dependent_setup(&images, render_pass.clone(), &mut viewport); | ||
|
||
let mut recreate_swapchain = false; | ||
let mut previous_frame_end = Some(tex_future.boxed()); | ||
|
||
event_loop.run(move |event, _, control_flow| match event { | ||
Event::WindowEvent { | ||
event: WindowEvent::CloseRequested, | ||
.. | ||
} => { | ||
*control_flow = ControlFlow::Exit; | ||
} | ||
Event::WindowEvent { | ||
event: WindowEvent::Resized(_), | ||
.. | ||
} => { | ||
recreate_swapchain = true; | ||
} | ||
Event::RedrawEventsCleared => { | ||
previous_frame_end.as_mut().unwrap().cleanup_finished(); | ||
|
||
if recreate_swapchain { | ||
let dimensions: [u32; 2] = surface.window().inner_size().into(); | ||
let (new_swapchain, new_images) = | ||
match swapchain.recreate().dimensions(dimensions).build() { | ||
Ok(r) => r, | ||
Err(SwapchainCreationError::UnsupportedDimensions) => return, | ||
Err(e) => panic!("Failed to recreate swapchain: {:?}", e), | ||
}; | ||
|
||
swapchain = new_swapchain; | ||
framebuffers = | ||
window_size_dependent_setup(&new_images, render_pass.clone(), &mut viewport); | ||
recreate_swapchain = false; | ||
} | ||
|
||
let (image_num, suboptimal, acquire_future) = | ||
match swapchain::acquire_next_image(swapchain.clone(), None) { | ||
Ok(r) => r, | ||
Err(AcquireError::OutOfDate) => { | ||
recreate_swapchain = true; | ||
return; | ||
} | ||
Err(e) => panic!("Failed to acquire next image: {:?}", e), | ||
}; | ||
|
||
if suboptimal { | ||
recreate_swapchain = true; | ||
} | ||
|
||
let clear_values = vec![[0.0, 0.0, 1.0, 1.0].into()]; | ||
let mut builder = AutoCommandBufferBuilder::primary( | ||
device.clone(), | ||
queue.family(), | ||
CommandBufferUsage::OneTimeSubmit, | ||
) | ||
.unwrap(); | ||
builder | ||
.begin_render_pass( | ||
framebuffers[image_num].clone(), | ||
SubpassContents::Inline, | ||
clear_values, | ||
) | ||
.unwrap() | ||
.set_viewport(0, [viewport.clone()]) | ||
.bind_pipeline_graphics(pipeline.clone()) | ||
.bind_descriptor_sets( | ||
PipelineBindPoint::Graphics, | ||
pipeline.layout().clone(), | ||
0, | ||
set.clone(), | ||
) | ||
.bind_vertex_buffers(0, vertex_buffer.clone()) | ||
.draw(vertex_buffer.len() as u32, 3, 0, 0) | ||
.unwrap() | ||
.end_render_pass() | ||
.unwrap(); | ||
let command_buffer = builder.build().unwrap(); | ||
|
||
let future = previous_frame_end | ||
.take() | ||
.unwrap() | ||
.join(acquire_future) | ||
.then_execute(queue.clone(), command_buffer) | ||
.unwrap() | ||
.then_swapchain_present(queue.clone(), swapchain.clone(), image_num) | ||
.then_signal_fence_and_flush(); | ||
|
||
match future { | ||
Ok(future) => { | ||
previous_frame_end = Some(future.boxed()); | ||
} | ||
Err(FlushError::OutOfDate) => { | ||
recreate_swapchain = true; | ||
previous_frame_end = Some(sync::now(device.clone()).boxed()); | ||
} | ||
Err(e) => { | ||
println!("Failed to flush future: {:?}", e); | ||
previous_frame_end = Some(sync::now(device.clone()).boxed()); | ||
} | ||
} | ||
} | ||
_ => (), | ||
}); | ||
} | ||
|
||
/// This method is called once during initialization, then again whenever the window is resized | ||
fn window_size_dependent_setup( | ||
images: &[Arc<SwapchainImage<Window>>], | ||
render_pass: Arc<RenderPass>, | ||
viewport: &mut Viewport, | ||
) -> Vec<Arc<Framebuffer>> { | ||
let dimensions = images[0].dimensions().width_height(); | ||
viewport.dimensions = [dimensions[0] as f32, dimensions[1] as f32]; | ||
|
||
images | ||
.iter() | ||
.map(|image| { | ||
let view = ImageView::new(image.clone()).unwrap(); | ||
Framebuffer::start(render_pass.clone()) | ||
.add(view) | ||
.unwrap() | ||
.build() | ||
.unwrap() | ||
}) | ||
.collect::<Vec<_>>() | ||
} | ||
|
||
mod vs { | ||
vulkano_shaders::shader! { | ||
ty: "vertex", | ||
src: " | ||
#version 450 | ||
layout(location = 0) in vec2 position; | ||
layout(location = 0) out vec2 tex_coords; | ||
layout(location = 1) out uint layer; | ||
const float x[4] = float[](0.0, 0.0, 1.0, 1.0); | ||
const float y[4] = float[](0.0, 1.0, 0.0, 1.0); | ||
void main() { | ||
gl_Position = vec4(position, 0.0, 1.0); | ||
tex_coords = vec2(x[gl_VertexIndex], y[gl_VertexIndex]); | ||
layer = gl_InstanceIndex; | ||
}" | ||
} | ||
} | ||
|
||
mod fs { | ||
vulkano_shaders::shader! { | ||
ty: "fragment", | ||
src: " | ||
#version 450 | ||
layout(location = 0) in vec2 tex_coords; | ||
layout(location = 1) flat in uint layer; | ||
layout(location = 0) out vec4 f_color; | ||
layout(set = 0, binding = 0) uniform sampler2DArray tex; | ||
void main() { | ||
f_color = texture(tex, vec3(tex_coords, layer)); | ||
}" | ||
} | ||
} |
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
Oops, something went wrong.