alex/vello
1
0
Fork 0
mirror of https://github.com/italicsjenga/vello.git synced 2025-01-10 12:41:30 +11:00
Code Issues Packages Projects Releases Wiki Activity

Wire hub to mux

Browse source 
Make the hub abstraction connect to the mux, rather than directly to the
Vulkan back-end.

As of this commit, both command line and winit examples work (on
Vulkan). In theory it should be possible to get them working on Dx12 as
well by translating the shader code, but there's a lot that can go
wrong.

This commit also contains a bunch of changes to mux to make conditional
compilation of match arms work, and new methods to support swapchain.
This commit is contained in:
Raph Levien 2021-05-25 18:06:51 -07:00
parent d15994fe44
commit 2ecfc7a414
11 changed files with 337 additions and 164 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
piet-gpu-hal/examples/collatz.rs
View file

@ -1,16 +1,16 @@
use piet_gpu_hal::hub;
use piet_gpu_hal::vulkan::VkInstance;
use piet_gpu_hal::{BufferUsage, CmdBuf};
use piet_gpu_hal::mux::{Instance, ShaderCode};
use piet_gpu_hal::BufferUsage;
fn main() {
let (instance, _) = VkInstance::new(None).unwrap();
let (instance, _) = Instance::new(None).unwrap();
unsafe {
let device = instance.device(None).unwrap();
let session = hub::Session::new(device);
let usage = BufferUsage::MAP_READ | BufferUsage::STORAGE;
let src = (0..256).map(|x| x + 1).collect::<Vec<u32>>();
let buffer = session.create_buffer_init(&src, usage).unwrap();
let code = include_bytes!("./shader/collatz.spv");
let code = ShaderCode::Spv(include_bytes!("./shader/collatz.spv"));
let pipeline = session.create_simple_compute_pipeline(code, 1).unwrap();
let descriptor_set = session
.create_simple_descriptor_set(&pipeline, &[&buffer])

7
piet-gpu-hal/src/dx12.rs
View file

@ -24,6 +24,9 @@ pub struct Dx12Instance {
// TODO
pub struct Dx12Surface;
// TODO
pub struct Dx12Swapchain;
pub struct Dx12Device {
device: Device,
command_allocator: CommandAllocator,
@ -35,7 +38,7 @@ pub struct Dx12Device {
#[derive(Clone)]
pub struct Buffer {
resource: Resource,
size: u64,
pub size: u64,
}
#[derive(Clone)]
@ -331,7 +334,7 @@ impl crate::Device for Dx12Device {
Ok(())
}
unsafe fn get_fence_status(&self, fence: Self::Fence) -> Result<bool, Error> {
unsafe fn get_fence_status(&self, fence: &Self::Fence) -> Result<bool, Error> {
let fence_val = fence.fence.get_value();
Ok(fence_val == fence.val.get())
}

97
piet-gpu-hal/src/hub.rs
View file

@ -1,35 +1,28 @@
//! A convenience layer on top of raw hal.
//! A somewhat higher level GPU abstraction.
//!
//! This layer takes care of some lifetime and synchronization bookkeeping.
//! It is likely that it will also take care of compile time and runtime
//! negotiation of backends (Vulkan, DX12), but right now it's Vulkan-only.
//! This layer is on top of the lower-level layer that multiplexes different
//! back-ends. It handles details such as managing staging buffers for creating
//! buffers with initial content, deferring dropping of resources until command
//! submission is complete, and a bit more. These conveniences might expand
//! even more in time.
use std::convert::TryInto;
use std::sync::{Arc, Mutex, Weak};
use crate::vulkan;
use crate::CmdBuf as CmdBufTrait;
use crate::DescriptorSetBuilder as DescriptorSetBuilderTrait;
use crate::PipelineBuilder as PipelineBuilderTrait;
use crate::{BufferUsage, Device, Error, GpuInfo, SamplerParams};
use smallvec::SmallVec;
pub type Semaphore = <vulkan::VkDevice as Device>::Semaphore;
pub type Pipeline = <vulkan::VkDevice as Device>::Pipeline;
pub type DescriptorSet = <vulkan::VkDevice as Device>::DescriptorSet;
pub type QueryPool = <vulkan::VkDevice as Device>::QueryPool;
pub type Sampler = <vulkan::VkDevice as Device>::Sampler;
use crate::mux;
type Fence = <vulkan::VkDevice as Device>::Fence;
use crate::{BufferUsage, Error, GpuInfo, SamplerParams};
type VkImage = <vulkan::VkDevice as Device>::Image;
type VkBuffer = <vulkan::VkDevice as Device>::Buffer;
pub use crate::mux::{DescriptorSet, Fence, Pipeline, QueryPool, Sampler, Semaphore, ShaderCode};
#[derive(Clone)]
pub struct Session(Arc<SessionInner>);
struct SessionInner {
device: vulkan::VkDevice,
cmd_buf_pool: Mutex<Vec<(vulkan::CmdBuf, Fence)>>,
device: mux::Device,
cmd_buf_pool: Mutex<Vec<(mux::CmdBuf, Fence)>>,
/// Command buffers that are still pending (so resources can't be freed).
pending: Mutex<Vec<SubmittedCmdBufInner>>,
/// A command buffer that is used for copying from staging buffers.
@ -38,7 +31,7 @@ struct SessionInner {
}
pub struct CmdBuf {
cmd_buf: vulkan::CmdBuf,
cmd_buf: mux::CmdBuf,
fence: Fence,
resources: Vec<RetainResource>,
session: Weak<SessionInner>,
@ -50,7 +43,7 @@ pub struct SubmittedCmdBuf(Option<SubmittedCmdBufInner>, Weak<SessionInner>);
struct SubmittedCmdBufInner {
// It's inconsistent, cmd_buf is unpacked, staging_cmd_buf isn't. Probably
// better to chose one or the other.
cmd_buf: vulkan::CmdBuf,
cmd_buf: mux::CmdBuf,
fence: Fence,
resources: Vec<RetainResource>,
staging_cmd_buf: Option<CmdBuf>,
@ -60,7 +53,7 @@ struct SubmittedCmdBufInner {
pub struct Image(Arc<ImageInner>);
struct ImageInner {
image: VkImage,
image: mux::Image,
session: Weak<SessionInner>,
}
@ -68,13 +61,13 @@ struct ImageInner {
pub struct Buffer(Arc<BufferInner>);
struct BufferInner {
buffer: VkBuffer,
buffer: mux::Buffer,
session: Weak<SessionInner>,
}
pub struct PipelineBuilder(vulkan::PipelineBuilder);
pub struct PipelineBuilder(mux::PipelineBuilder);
pub struct DescriptorSetBuilder(vulkan::DescriptorSetBuilder);
pub struct DescriptorSetBuilder(mux::DescriptorSetBuilder);
/// Data types that can be stored in a GPU buffer.
pub unsafe trait PlainData {}
@ -97,7 +90,7 @@ pub enum RetainResource {
}
impl Session {
pub fn new(device: vulkan::VkDevice) -> Session {
pub fn new(device: mux::Device) -> Session {
let gpu_info = device.query_gpu_info();
Session(Arc::new(SessionInner {
device,
@ -130,7 +123,7 @@ impl Session {
unsafe {
let mut i = 0;
while i < pending.len() {
if let Ok(true) = self.0.device.get_fence_status(pending[i].fence) {
if let Ok(true) = self.0.device.get_fence_status(&pending[i].fence) {
let item = pending.swap_remove(i);
// TODO: wait is superfluous, can just reset
let _ = self.0.device.wait_and_reset(&[&item.fence]);
@ -222,7 +215,7 @@ impl Session {
let create_buf = self.create_buffer(size, create_usage)?;
self.0
.device
.write_buffer(&create_buf.vk_buffer(), contents, 0, size)?;
.write_buffer(&create_buf.mux_buffer(), contents, 0, size)?;
if use_staging_buffer {
let buf = self.create_buffer(size, usage | BufferUsage::COPY_DST)?;
let mut staging_cmd_buf = self.0.staging_cmd_buf.lock().unwrap();
@ -232,8 +225,8 @@ impl Session {
*staging_cmd_buf = Some(cmd_buf);
}
let staging_cmd_buf = staging_cmd_buf.as_mut().unwrap();
// This will ensure the staging buffer is deallocated. It would be nice to
staging_cmd_buf.copy_buffer(create_buf.vk_buffer(), buf.vk_buffer());
// This will ensure the staging buffer is deallocated.
staging_cmd_buf.copy_buffer(create_buf.mux_buffer(), buf.mux_buffer());
staging_cmd_buf.add_resource(create_buf);
Ok(buf)
} else {
@ -256,9 +249,9 @@ impl Session {
/// This creates a pipeline that operates on some buffers and images.
///
/// The descriptor set layout is just some number of storage buffers and storage images (this might change).
pub unsafe fn create_simple_compute_pipeline(
pub unsafe fn create_simple_compute_pipeline<'a>(
&self,
code: &[u8],
code: ShaderCode<'a>,
n_buffers: u32,
) -> Result<Pipeline, Error> {
self.pipeline_builder()
@ -295,7 +288,8 @@ impl Session {
}
pub unsafe fn create_sampler(&self, params: SamplerParams) -> Result<Sampler, Error> {
self.0.device.create_sampler(params)
todo!()
//self.0.device.create_sampler(params)
}
pub fn gpu_info(&self) -> &GpuInfo {
@ -366,10 +360,9 @@ impl Drop for ImageInner {
}
}
/// For now, we deref, but for runtime backend switching we'll need to wrap
/// all methods.
// Probably migrate from deref here to wrapping all methods.
impl std::ops::Deref for CmdBuf {
type Target = vulkan::CmdBuf;
type Target = mux::CmdBuf;
fn deref(&self) -> &Self::Target {
&self.cmd_buf
}
@ -382,13 +375,13 @@ impl std::ops::DerefMut for CmdBuf {
}
impl Image {
pub fn vk_image(&self) -> &vulkan::Image {
pub fn mux_image(&self) -> &mux::Image {
&self.0.image
}
}
impl Buffer {
pub fn vk_buffer(&self) -> &vulkan::Buffer {
pub fn mux_buffer(&self) -> &mux::Buffer {
&self.0.buffer
}
@ -405,7 +398,7 @@ impl Buffer {
Ok(())
}
pub unsafe fn read<T: PlainData>(&self, result: &mut Vec<T>) -> Result<(), Error> {
let size = self.vk_buffer().size;
let size = self.mux_buffer().size();
let len = size as usize / std::mem::size_of::<T>();
if len > result.len() {
result.reserve(len - result.len());
@ -440,10 +433,10 @@ impl PipelineBuilder {
self
}
pub unsafe fn create_compute_pipeline(
pub unsafe fn create_compute_pipeline<'a>(
self,
session: &Session,
code: &[u8],
code: ShaderCode<'a>,
) -> Result<Pipeline, Error> {
self.0.create_compute_pipeline(&session.0.device, code)
}
@ -451,23 +444,29 @@ impl PipelineBuilder {
impl DescriptorSetBuilder {
pub fn add_buffers<'a>(mut self, buffers: impl IntoRefs<'a, Buffer>) -> Self {
let vk_buffers = buffers
let mux_buffers = buffers
.into_refs()
.map(|b| b.vk_buffer())
.collect::<Vec<_>>();
self.0.add_buffers(&vk_buffers);
.map(|b| b.mux_buffer())
.collect::<SmallVec<[_; 8]>>();
self.0.add_buffers(&mux_buffers);
self
}
pub fn add_images<'a>(mut self, images: impl IntoRefs<'a, Image>) -> Self {
let vk_images = images.into_refs().map(|i| i.vk_image()).collect::<Vec<_>>();
self.0.add_images(&vk_images);
let mux_images = images
.into_refs()
.map(|i| i.mux_image())
.collect::<Vec<_>>();
self.0.add_images(&mux_images);
self
}
pub fn add_textures<'a>(mut self, images: impl IntoRefs<'a, Image>) -> Self {
let vk_images = images.into_refs().map(|i| i.vk_image()).collect::<Vec<_>>();
self.0.add_textures(&vk_images);
let mux_images = images
.into_refs()
.map(|i| i.mux_image())
.collect::<Vec<_>>();
self.0.add_textures(&mux_images);
self
}

6
piet-gpu-hal/src/lib.rs
View file

@ -12,11 +12,11 @@ mod macros;
// TODO make this not pub
pub mod mux;
mux! {
mux_cfg! {
#[cfg(vk)]
pub mod vulkan;
}
mux! {
mux_cfg! {
#[cfg(dx12)]
pub mod dx12;
}
@ -229,7 +229,7 @@ pub trait Device: Sized {
unsafe fn create_semaphore(&self) -> Result<Self::Semaphore, Error>;
unsafe fn create_fence(&self, signaled: bool) -> Result<Self::Fence, Error>;
unsafe fn wait_and_reset(&self, fences: &[&Self::Fence]) -> Result<(), Error>;
unsafe fn get_fence_status(&self, fence: Self::Fence) -> Result<bool, Error>;
unsafe fn get_fence_status(&self, fence: &Self::Fence) -> Result<bool, Error>;
unsafe fn create_sampler(&self, params: SamplerParams) -> Result<Self::Sampler, Error>;
}

31
piet-gpu-hal/src/macros.rs
View file

@ -17,7 +17,7 @@
//! Macros, mostly to automate backend selection tedium.
#[macro_export]
macro_rules! mux {
macro_rules! mux_cfg {
( #[cfg(vk)] $($tokens:tt)* ) => {
#[cfg(not(target_os="macos"))] $( $tokens )*
};
@ -41,7 +41,7 @@ macro_rules! mux_enum {
}
impl $name {
$crate::mux! {
$crate::mux_cfg! {
#[cfg(vk)]
#[allow(unused)]
fn vk(&self) -> &$vk {
@ -52,7 +52,7 @@ macro_rules! mux_enum {
}
}
$crate::mux! {
$crate::mux_cfg! {
#[cfg(dx12)]
#[allow(unused)]
fn dx12(&self) -> &$dx12 {
@ -77,3 +77,28 @@ macro_rules! mux_device_enum {
}
}
}
#[macro_export]
macro_rules! mux_match {
( $e:expr ;
$vkname:ident::Vk($vkvar:ident) => $vkblock: block
$dx12name:ident::Dx12($dx12var:ident) => $dx12block: block
) => {
match $e {
#[cfg(not(target_os="macos"))]
$vkname::Vk($vkvar) => $vkblock
#[cfg(target_os="windows")]
$dx12name::Dx12($dx12var) => $dx12block
}
};
( $e:expr ;
$vkname:ident::Vk($vkvar:ident) => $vkblock: expr,
$dx12name:ident::Dx12($dx12var:ident) => $dx12block: expr,
) => {
$crate::mux_match! { $e;
$vkname::Vk($vkvar) => { $vkblock }
$dx12name::Dx12($dx12var) => { $dx12block }
}
};
}

274
piet-gpu-hal/src/mux.rs
View file

@ -18,8 +18,14 @@
use smallvec::SmallVec;
use crate::dx12;
use crate::vulkan;
mux_cfg! {
#[cfg(vk)]
use crate::vulkan;
}
mux_cfg! {
#[cfg(dx12)]
use crate::dx12;
}
use crate::CmdBuf as CmdBufTrait;
use crate::DescriptorSetBuilder as DescriptorSetBuilderTrait;
use crate::Device as DeviceTrait;
@ -50,6 +56,14 @@ mux_enum! {
}
}
mux_enum! {
/// A surface, which can apply to one of multiple backends.
pub enum Swapchain {
Vk(vulkan::VkSwapchain),
Dx12(dx12::Dx12Swapchain),
}
}
mux_device_enum! { Buffer }
mux_device_enum! { Image }
mux_device_enum! { Fence }
@ -60,6 +74,7 @@ mux_device_enum! { DescriptorSetBuilder }
mux_device_enum! { DescriptorSet }
mux_device_enum! { CmdBuf }
mux_device_enum! { QueryPool }
mux_device_enum! { Sampler }
/// The code for a shader, either as source or intermediate representation.
pub enum ShaderCode<'a> {
@ -71,7 +86,7 @@ impl Instance {
pub fn new(
window_handle: Option<&dyn raw_window_handle::HasRawWindowHandle>,
) -> Result<(Instance, Option<Surface>), Error> {
mux! {
mux_cfg! {
#[cfg(vk)]
{
let result = vulkan::VkInstance::new(window_handle);
@ -80,7 +95,7 @@ impl Instance {
}
}
}
mux! {
mux_cfg! {
#[cfg(dx12)]
{
let result = dx12::Dx12Instance::new(window_handle);
@ -94,11 +109,26 @@ impl Instance {
}
pub unsafe fn device(&self, surface: Option<&Surface>) -> Result<Device, Error> {
match self {
mux_match! { self;
Instance::Vk(i) => i.device(surface.map(Surface::vk)).map(Device::Vk),
Instance::Dx12(i) => i.device(surface.map(Surface::dx12)).map(Device::Dx12),
}
}
pub unsafe fn swapchain(
&self,
width: usize,
height: usize,
device: &Device,
surface: &Surface,
) -> Result<Swapchain, Error> {
mux_match! { self;
Instance::Vk(i) => i
.swapchain(width, height, device.vk(), surface.vk())
.map(Swapchain::Vk),
Instance::Dx12(_i) => todo!(),
}
}
}
// This is basically re-exporting the backend device trait, and we could do that,
@ -106,35 +136,49 @@ impl Instance {
// missing functionality).
impl Device {
pub fn query_gpu_info(&self) -> GpuInfo {
match self {
mux_match! { self;
Device::Vk(d) => d.query_gpu_info(),
Device::Dx12(d) => d.query_gpu_info(),
}
}
pub fn create_buffer(&self, size: u64, usage: BufferUsage) -> Result<Buffer, Error> {
match self {
mux_match! { self;
Device::Vk(d) => d.create_buffer(size, usage).map(Buffer::Vk),
Device::Dx12(d) => d.create_buffer(size, usage).map(Buffer::Dx12),
}
}
pub unsafe fn destroy_buffer(&self, buffer: &Buffer) -> Result<(), Error> {
match self {
mux_match! { self;
Device::Vk(d) => d.destroy_buffer(buffer.vk()),
Device::Dx12(d) => d.destroy_buffer(buffer.dx12()),
}
}
pub unsafe fn create_image2d(&self, width: u32, height: u32) -> Result<Image, Error> {
mux_match! { self;
Device::Vk(d) => d.create_image2d(width, height).map(Image::Vk),
Device::Dx12(d) => d.create_image2d(width, height).map(Image::Dx12),
}
}
pub unsafe fn destroy_image(&self, image: &Image) -> Result<(), Error> {
mux_match! { self;
Device::Vk(d) => d.destroy_image(image.vk()),
Device::Dx12(d) => d.destroy_image(image.dx12()),
}
}
pub unsafe fn create_fence(&self, signaled: bool) -> Result<Fence, Error> {
match self {
mux_match! { self;
Device::Vk(d) => d.create_fence(signaled).map(Fence::Vk),
Device::Dx12(d) => d.create_fence(signaled).map(Fence::Dx12),
}
}
pub unsafe fn wait_and_reset(&self, fences: &[&Fence]) -> Result<(), Error> {
match self {
mux_match! { self;
Device::Vk(d) => {
let fences = fences
.iter()
@ -151,41 +195,53 @@ impl Device {
.collect::<SmallVec<[_; 4]>>();
d.wait_and_reset(&*fences)
}
// Probably need to change device trait to accept &Fence
_ => todo!(),
}
}
pub unsafe fn get_fence_status(&self, fence: &Fence) -> Result<bool, Error> {
mux_match! { self;
Device::Vk(d) => d.get_fence_status(fence.vk()),
Device::Dx12(d) => d.get_fence_status(fence.dx12()),
}
}
pub unsafe fn create_semaphore(&self) -> Result<Semaphore, Error> {
mux_match! { self;
Device::Vk(d) => d.create_semaphore().map(Semaphore::Vk),
Device::Dx12(d) => d.create_semaphore().map(Semaphore::Dx12),
}
}
pub unsafe fn pipeline_builder(&self) -> PipelineBuilder {
match self {
mux_match! { self;
Device::Vk(d) => PipelineBuilder::Vk(d.pipeline_builder()),
Device::Dx12(d) => PipelineBuilder::Dx12(d.pipeline_builder()),
}
}
pub unsafe fn descriptor_set_builder(&self) -> DescriptorSetBuilder {
match self {
mux_match! { self;
Device::Vk(d) => DescriptorSetBuilder::Vk(d.descriptor_set_builder()),
Device::Dx12(d) => DescriptorSetBuilder::Dx12(d.descriptor_set_builder()),
}
}
pub fn create_cmd_buf(&self) -> Result<CmdBuf, Error> {
match self {
mux_match! { self;
Device::Vk(d) => d.create_cmd_buf().map(CmdBuf::Vk),
Device::Dx12(d) => d.create_cmd_buf().map(CmdBuf::Dx12),
}
}
pub fn create_query_pool(&self, n_queries: u32) -> Result<QueryPool, Error> {
match self {
mux_match! { self;
Device::Vk(d) => d.create_query_pool(n_queries).map(QueryPool::Vk),
Device::Dx12(d) => d.create_query_pool(n_queries).map(QueryPool::Dx12),
}
}
pub unsafe fn fetch_query_pool(&self, pool: &QueryPool) -> Result<Vec<f64>, Error> {
match self {
mux_match! { self;
Device::Vk(d) => d.fetch_query_pool(pool.vk()),
Device::Dx12(d) => d.fetch_query_pool(pool.dx12()),
}
@ -198,14 +254,22 @@ impl Device {
signal_semaphores: &[&Semaphore],
fence: Option<&Fence>,
) -> Result<(), Error> {
match self {
mux_match! { self;
Device::Vk(d) => d.run_cmd_bufs(
&cmd_bufs
.iter()
.map(|c| c.vk())
.collect::<SmallVec<[_; 4]>>(),
&wait_semaphores.iter().copied().map(Semaphore::vk).collect::<SmallVec<[_; 4]>>(),
&signal_semaphores.iter().copied().map(Semaphore::vk).collect::<SmallVec<[_; 4]>>(),
&wait_semaphores
.iter()
.copied()
.map(Semaphore::vk)
.collect::<SmallVec<[_; 4]>>(),
&signal_semaphores
.iter()
.copied()
.map(Semaphore::vk)
.collect::<SmallVec<[_; 4]>>(),
fence.map(Fence::vk),
),
Device::Dx12(d) => d.run_cmd_bufs(
@ -213,8 +277,16 @@ impl Device {
.iter()
.map(|c| c.dx12())
.collect::<SmallVec<[_; 4]>>(),
&wait_semaphores.iter().copied().map(Semaphore::dx12).collect::<SmallVec<[_; 4]>>(),
&signal_semaphores.iter().copied().map(Semaphore::dx12).collect::<SmallVec<[_; 4]>>(),
&wait_semaphores
.iter()
.copied()
.map(Semaphore::dx12)
.collect::<SmallVec<[_; 4]>>(),
&signal_semaphores
.iter()
.copied()
.map(Semaphore::dx12)
.collect::<SmallVec<[_; 4]>>(),
fence.map(Fence::dx12),
),
}
@ -227,7 +299,7 @@ impl Device {
offset: u64,
size: u64,
) -> Result<(), Error> {
match self {
mux_match! { self;
Device::Vk(d) => d.read_buffer(buffer.vk(), dst, offset, size),
Device::Dx12(d) => d.read_buffer(buffer.dx12(), dst, offset, size),
}
@ -240,7 +312,7 @@ impl Device {
offset: u64,
size: u64,
) -> Result<(), Error> {
match self {
mux_match! { self;
Device::Vk(d) => d.write_buffer(buffer.vk(), contents, offset, size),
Device::Dx12(d) => d.write_buffer(buffer.dx12(), contents, offset, size),
}
@ -249,21 +321,21 @@ impl Device {
impl PipelineBuilder {
pub fn add_buffers(&mut self, n_buffers: u32) {
match self {
mux_match! { self;
PipelineBuilder::Vk(x) => x.add_buffers(n_buffers),
PipelineBuilder::Dx12(x) => x.add_buffers(n_buffers),
}
}
pub fn add_images(&mut self, n_buffers: u32) {
match self {
mux_match! { self;
PipelineBuilder::Vk(x) => x.add_images(n_buffers),
PipelineBuilder::Dx12(x) => x.add_images(n_buffers),
}
}
pub fn add_textures(&mut self, n_buffers: u32) {
match self {
mux_match! { self;
PipelineBuilder::Vk(x) => x.add_textures(n_buffers),
PipelineBuilder::Dx12(x) => x.add_textures(n_buffers),
}
@ -274,7 +346,7 @@ impl PipelineBuilder {
device: &Device,
code: ShaderCode<'a>,
) -> Result<Pipeline, Error> {
match self {
mux_match! { self;
PipelineBuilder::Vk(x) => {
let shader_code = match code {
ShaderCode::Spv(spv) => spv,
@ -298,39 +370,60 @@ impl PipelineBuilder {
}
impl DescriptorSetBuilder {
pub fn add_buffers(&mut self, buffers: &[Buffer]) {
match self {
DescriptorSetBuilder::Vk(x) => {
x.add_buffers(&buffers.iter().map(Buffer::vk).collect::<SmallVec<[_; 8]>>())
}
pub fn add_buffers(&mut self, buffers: &[&Buffer]) {
mux_match! { self;
DescriptorSetBuilder::Vk(x) => x.add_buffers(
&buffers
.iter()
.copied()
.map(Buffer::vk)
.collect::<SmallVec<[_; 8]>>(),
),
DescriptorSetBuilder::Dx12(x) => x.add_buffers(
&buffers
.iter()
.copied()
.map(Buffer::dx12)
.collect::<SmallVec<[_; 8]>>(),
),
}
}
pub fn add_images(&mut self, images: &[Image]) {
match self {
DescriptorSetBuilder::Vk(x) => {
x.add_images(&images.iter().map(Image::vk).collect::<SmallVec<[_; 8]>>())
}
DescriptorSetBuilder::Dx12(x) => {
x.add_images(&images.iter().map(Image::dx12).collect::<SmallVec<[_; 8]>>())
}
pub fn add_images(&mut self, images: &[&Image]) {
mux_match! { self;
DescriptorSetBuilder::Vk(x) => x.add_images(
&images
.iter()
.copied()
.map(Image::vk)
.collect::<SmallVec<[_; 8]>>(),
),
DescriptorSetBuilder::Dx12(x) => x.add_images(
&images
.iter()
.copied()
.map(Image::dx12)
.collect::<SmallVec<[_; 8]>>(),
),
}
}
pub fn add_textures(&mut self, images: &[Image]) {
match self {
DescriptorSetBuilder::Vk(x) => {
x.add_textures(&images.iter().map(Image::vk).collect::<SmallVec<[_; 8]>>())
}
DescriptorSetBuilder::Dx12(x) => {
x.add_textures(&images.iter().map(Image::dx12).collect::<SmallVec<[_; 8]>>())
}
pub fn add_textures(&mut self, images: &[&Image]) {
mux_match! { self;
DescriptorSetBuilder::Vk(x) => x.add_textures(
&images
.iter()
.copied()
.map(Image::vk)
.collect::<SmallVec<[_; 8]>>(),
),
DescriptorSetBuilder::Dx12(x) => x.add_textures(
&images
.iter()
.copied()
.map(Image::dx12)
.collect::<SmallVec<[_; 8]>>(),
),
}
}
@ -339,10 +432,9 @@ impl DescriptorSetBuilder {
device: &Device,
pipeline: &Pipeline,
) -> Result<DescriptorSet, Error> {
match self {
DescriptorSetBuilder::Vk(x) => {
x.build(device.vk(), pipeline.vk()).map(DescriptorSet::Vk)
}
mux_match! { self;
DescriptorSetBuilder::Vk(x) =>
x.build(device.vk(), pipeline.vk()).map(DescriptorSet::Vk),
DescriptorSetBuilder::Dx12(x) => x
.build(device.dx12(), pipeline.dx12())
.map(DescriptorSet::Dx12),
@ -352,14 +444,14 @@ impl DescriptorSetBuilder {
impl CmdBuf {
pub unsafe fn begin(&mut self) {
match self {
mux_match! { self;
CmdBuf::Vk(c) => c.begin(),
CmdBuf::Dx12(c) => c.begin(),
}
}
pub unsafe fn finish(&mut self) {
match self {
mux_match! { self;
CmdBuf::Vk(c) => c.finish(),
CmdBuf::Dx12(c) => c.finish(),
}
@ -371,21 +463,21 @@ impl CmdBuf {
descriptor_set: &DescriptorSet,
size: (u32, u32, u32),
) {
match self {
mux_match! { self;
CmdBuf::Vk(c) => c.dispatch(pipeline.vk(), descriptor_set.vk(), size),
CmdBuf::Dx12(c) => c.dispatch(pipeline.dx12(), descriptor_set.dx12(), size),
}
}
pub unsafe fn memory_barrier(&mut self) {
match self {
mux_match! { self;
CmdBuf::Vk(c) => c.memory_barrier(),
CmdBuf::Dx12(c) => c.memory_barrier(),
}
}
pub unsafe fn host_barrier(&mut self) {
match self {
mux_match! { self;
CmdBuf::Vk(c) => c.host_barrier(),
CmdBuf::Dx12(c) => c.host_barrier(),
}
@ -397,65 +489,113 @@ impl CmdBuf {
src_layout: ImageLayout,
dst_layout: ImageLayout,
) {
match self {
mux_match! { self;
CmdBuf::Vk(c) => c.image_barrier(image.vk(), src_layout, dst_layout),
CmdBuf::Dx12(c) => c.image_barrier(image.dx12(), src_layout, dst_layout),
}
}
pub unsafe fn clear_buffer(&mut self, buffer: &Buffer, size: Option<u64>) {
match self {
mux_match! { self;
CmdBuf::Vk(c) => c.clear_buffer(buffer.vk(), size),
CmdBuf::Dx12(c) => c.clear_buffer(buffer.dx12(), size),
}
}
pub unsafe fn copy_buffer(&mut self, src: &Buffer, dst: &Buffer) {
match self {
mux_match! { self;
CmdBuf::Vk(c) => c.copy_buffer(src.vk(), dst.vk()),
CmdBuf::Dx12(c) => c.copy_buffer(src.dx12(), dst.dx12()),
}
}
pub unsafe fn copy_image_to_buffer(&mut self, src: &Image, dst: &Buffer) {
match self {
mux_match! { self;
CmdBuf::Vk(c) => c.copy_image_to_buffer(src.vk(), dst.vk()),
CmdBuf::Dx12(c) => c.copy_image_to_buffer(src.dx12(), dst.dx12()),
}
}
pub unsafe fn copy_buffer_to_image(&mut self, src: &Buffer, dst: &Image) {
match self {
mux_match! { self;
CmdBuf::Vk(c) => c.copy_buffer_to_image(src.vk(), dst.vk()),
CmdBuf::Dx12(c) => c.copy_buffer_to_image(src.dx12(), dst.dx12()),
}
}
pub unsafe fn blit_image(&mut self, src: &Image, dst: &Image) {
match self {
mux_match! { self;
CmdBuf::Vk(c) => c.blit_image(src.vk(), dst.vk()),
CmdBuf::Dx12(c) => c.blit_image(src.dx12(), dst.dx12()),
}
}
pub unsafe fn reset_query_pool(&mut self, pool: &QueryPool) {
match self {
mux_match! { self;
CmdBuf::Vk(c) => c.reset_query_pool(pool.vk()),
CmdBuf::Dx12(c) => c.reset_query_pool(pool.dx12()),
}
}
pub unsafe fn write_timestamp(&mut self, pool: &QueryPool, query: u32) {
match self {
mux_match! { self;
CmdBuf::Vk(c) => c.write_timestamp(pool.vk(), query),
CmdBuf::Dx12(c) => c.write_timestamp(pool.dx12(), query),
}
}
pub unsafe fn finish_timestamps(&mut self, pool: &QueryPool) {
match self {
mux_match! { self;
CmdBuf::Vk(c) => c.finish_timestamps(pool.vk()),
CmdBuf::Dx12(c) => c.finish_timestamps(pool.dx12()),
}
}
}
impl Buffer {
pub fn size(&self) -> u64 {
mux_match! { self;
Buffer::Vk(b) => b.size,
Buffer::Dx12(b) => b.size,
}
}
}
impl Swapchain {
pub unsafe fn next(&mut self) -> Result<(usize, Semaphore), Error> {
mux_match! { self;
Swapchain::Vk(s) => {
let (idx, sem) = s.next()?;
Ok((idx, Semaphore::Vk(sem)))
}
Swapchain::Dx12(_s) => {
todo!()
}
}
}
pub unsafe fn image(&self, idx: usize) -> Image {
mux_match! { self;
Swapchain::Vk(s) => Image::Vk(s.image(idx)),
Swapchain::Dx12(_s) => todo!(),
}
}
pub unsafe fn present(
&self,
image_idx: usize,
semaphores: &[&Semaphore],
) -> Result<bool, Error> {
mux_match! { self;
Swapchain::Vk(s) => s.present(
image_idx,
&semaphores
.iter()
.copied()
.map(Semaphore::vk)
.collect::<SmallVec<[_; 4]>>(),
),
Swapchain::Dx12(_s) => todo!(),
}
}
}

9
piet-gpu-hal/src/vulkan.rs
View file

@ -631,9 +631,9 @@ impl crate::Device for VkDevice {
Ok(())
}
unsafe fn get_fence_status(&self, fence: Self::Fence) -> Result<bool, Error> {
unsafe fn get_fence_status(&self, fence: &Self::Fence) -> Result<bool, Error> {
let device = &self.device.device;
Ok(device.get_fence_status(fence)?)
Ok(device.get_fence_status(*fence)?)
}
unsafe fn pipeline_builder(&self) -> PipelineBuilder {
@ -1306,14 +1306,15 @@ impl VkSwapchain {
pub unsafe fn present(
&self,
image_idx: usize,
semaphores: &[vk::Semaphore],
semaphores: &[&vk::Semaphore],
) -> Result<bool, Error> {
let semaphores = semaphores.iter().copied().copied().collect::<SmallVec<[_; 4]>>();
Ok(self.swapchain_fn.queue_present(
self.present_queue,
&vk::PresentInfoKHR::builder()
.swapchains(&[self.swapchain])
.image_indices(&[image_idx as u32])
.wait_semaphores(semaphores)
.wait_semaphores(&semaphores)
.build(),
)?)
}

12
piet-gpu/bin/android.rs
View file

@ -12,7 +12,7 @@ use ndk::native_window::NativeWindow;
use ndk_glue::Event;
use piet_gpu_hal::hub;
use piet_gpu_hal::vulkan::{QueryPool, VkInstance, VkSurface, VkSwapchain};
use piet_gpu_hal::mux::{QueryPool, Instance, Surface, Swapchain};
use piet_gpu_hal::{CmdBuf, Error, ImageLayout};
use piet_gpu::{render_scene, PietGpuRenderContext, Renderer};
@ -30,7 +30,7 @@ struct MyHandle {
struct GfxState {
session: hub::Session,
renderer: Renderer,
swapchain: VkSwapchain,
swapchain: Swapchain,
current_frame: usize,
last_frame_idx: usize,
submitted: Option<hub::SubmittedCmdBuf>,
@ -52,7 +52,7 @@ fn my_main() -> Result<(), Error> {
let window = ndk_glue::native_window();
if let Some(window) = &*window {
let handle = get_handle(window);
let (instance, surface) = VkInstance::new(Some(&handle))?;
let (instance, surface) = Instance::new(Some(&handle))?;
gfx_state = Some(GfxState::new(&instance, surface.as_ref())?);
} else {
println!("native window is sadly none");
@ -90,7 +90,7 @@ unsafe impl HasRawWindowHandle for MyHandle {
}
impl GfxState {
fn new(instance: &VkInstance, surface: Option<&VkSurface>) -> Result<GfxState, Error> {
fn new(instance: &Instance, surface: Option<&Surface>) -> Result<GfxState, Error> {
unsafe {
let device = instance.device(surface)?;
let mut swapchain =
@ -151,7 +151,7 @@ impl GfxState {
// Image -> Swapchain
cmd_buf.image_barrier(&swap_image, ImageLayout::Undefined, ImageLayout::BlitDst);
cmd_buf.blit_image(self.renderer.image_dev.vk_image(), &swap_image);
cmd_buf.blit_image(self.renderer.image_dev.mux_image(), &swap_image);
cmd_buf.image_barrier(&swap_image, ImageLayout::BlitDst, ImageLayout::Present);
cmd_buf.finish();
@ -167,7 +167,7 @@ impl GfxState {
self.last_frame_idx = frame_idx;
self.swapchain
.present(image_idx, &[self.present_semaphores[frame_idx]])
.present(image_idx, &[&self.present_semaphores[frame_idx]])
.unwrap();
self.current_frame += 1;

8
piet-gpu/bin/cli.rs
View file

@ -5,8 +5,8 @@ use std::path::Path;
use clap::{App, Arg};
use piet_gpu_hal::hub;
use piet_gpu_hal::vulkan::VkInstance;
use piet_gpu_hal::{BufferUsage, CmdBuf, Error};
use piet_gpu_hal::mux::Instance;
use piet_gpu_hal::{BufferUsage, Error};
use piet_gpu::{render_scene, render_svg, PietGpuRenderContext, Renderer, HEIGHT, WIDTH};
@ -225,7 +225,7 @@ fn main() -> Result<(), Error> {
.takes_value(true),
)
.get_matches();
let (instance, _) = VkInstance::new(None)?;
let (instance, _) = Instance::new(None)?;
unsafe {
let device = instance.device(None)?;
let session = hub::Session::new(device);
@ -258,7 +258,7 @@ fn main() -> Result<(), Error> {
cmd_buf.begin();
renderer.record(&mut cmd_buf, &query_pool);
cmd_buf.copy_image_to_buffer(renderer.image_dev.vk_image(), image_buf.vk_buffer());
cmd_buf.copy_image_to_buffer(renderer.image_dev.mux_image(), image_buf.mux_buffer());
cmd_buf.host_barrier();
cmd_buf.finish();
let start = std::time::Instant::now();

10
piet-gpu/bin/winit.rs
View file

@ -1,6 +1,6 @@
use piet_gpu_hal::hub;
use piet_gpu_hal::vulkan::VkInstance;
use piet_gpu_hal::{CmdBuf, Error, ImageLayout};
use piet_gpu_hal::mux::Instance;
use piet_gpu_hal::{Error, ImageLayout};
use piet_gpu::{render_scene, PietGpuRenderContext, Renderer, HEIGHT, WIDTH};
@ -22,7 +22,7 @@ fn main() -> Result<(), Error> {
.with_resizable(false) // currently not supported
.build(&event_loop)?;
let (instance, surface) = VkInstance::new(Some(&window))?;
let (instance, surface) = Instance::new(Some(&window))?;
unsafe {
let device = instance.device(surface.as_ref())?;
let mut swapchain =
@ -103,7 +103,7 @@ fn main() -> Result<(), Error> {
ImageLayout::Undefined,
ImageLayout::BlitDst,
);
cmd_buf.blit_image(renderer.image_dev.vk_image(), &swap_image);
cmd_buf.blit_image(renderer.image_dev.mux_image(), &swap_image);
cmd_buf.image_barrier(&swap_image, ImageLayout::BlitDst, ImageLayout::Present);
cmd_buf.finish();
@ -117,7 +117,7 @@ fn main() -> Result<(), Error> {
last_frame_idx = frame_idx;
swapchain
.present(image_idx, &[present_semaphores[frame_idx]])
.present(image_idx, &[&present_semaphores[frame_idx]])
.unwrap();
current_frame += 1;

39
piet-gpu/src/lib.rs
View file

@ -13,7 +13,8 @@ use piet::{Color, ImageFormat, RenderContext};
use piet_gpu_types::encoder::Encode;
use piet_gpu_hal::hub;
use piet_gpu_hal::{BufferUsage, CmdBuf, Error, ImageLayout};
use piet_gpu_hal::hub::ShaderCode;
use piet_gpu_hal::{BufferUsage, Error, ImageLayout};
use pico_svg::PicoSvg;
@ -292,35 +293,35 @@ impl Renderer {
let memory_buf_dev = session.create_buffer(128 * 1024 * 1024, dev)?;
memory_buf_host.write(&[alloc as u32, 0 /* Overflow flag */])?;
let el_code = include_bytes!("../shader/elements.spv");
let el_code = ShaderCode::Spv(include_bytes!("../shader/elements.spv"));
let el_pipeline = session.create_simple_compute_pipeline(el_code, 4)?;
let el_ds = session.create_simple_descriptor_set(
&el_pipeline,
&[&memory_buf_dev, &config_buf, &scene_buf, &state_buf],
)?;
let tile_alloc_code = include_bytes!("../shader/tile_alloc.spv");
let tile_alloc_code = ShaderCode::Spv(include_bytes!("../shader/tile_alloc.spv"));
let tile_pipeline = session.create_simple_compute_pipeline(tile_alloc_code, 2)?;
let tile_ds = session
.create_simple_descriptor_set(&tile_pipeline, &[&memory_buf_dev, &config_buf])?;
let path_alloc_code = include_bytes!("../shader/path_coarse.spv");
let path_alloc_code = ShaderCode::Spv(include_bytes!("../shader/path_coarse.spv"));
let path_pipeline = session.create_simple_compute_pipeline(path_alloc_code, 2)?;
let path_ds = session
.create_simple_descriptor_set(&path_pipeline, &[&memory_buf_dev, &config_buf])?;
let backdrop_alloc_code = include_bytes!("../shader/backdrop.spv");
let backdrop_alloc_code = ShaderCode::Spv(include_bytes!("../shader/backdrop.spv"));
let backdrop_pipeline = session.create_simple_compute_pipeline(backdrop_alloc_code, 2)?;
let backdrop_ds = session
.create_simple_descriptor_set(&backdrop_pipeline, &[&memory_buf_dev, &config_buf])?;
// TODO: constants
let bin_code = include_bytes!("../shader/binning.spv");
let bin_code = ShaderCode::Spv(include_bytes!("../shader/binning.spv"));
let bin_pipeline = session.create_simple_compute_pipeline(bin_code, 2)?;
let bin_ds =
session.create_simple_descriptor_set(&bin_pipeline, &[&memory_buf_dev, &config_buf])?;
let coarse_code = include_bytes!("../shader/coarse.spv");
let coarse_code = ShaderCode::Spv(include_bytes!("../shader/coarse.spv"));
let coarse_pipeline = session.create_simple_compute_pipeline(coarse_code, 2)?;
let coarse_ds = session
.create_simple_descriptor_set(&coarse_pipeline, &[&memory_buf_dev, &config_buf])?;
@ -328,10 +329,10 @@ impl Renderer {
let bg_image = Self::make_test_bg_image(&session);
let k4_code = if session.gpu_info().has_descriptor_indexing {
&include_bytes!("../shader/kernel4_idx.spv")[..]
ShaderCode::Spv(include_bytes!("../shader/kernel4_idx.spv"))
} else {
println!("doing non-indexed k4");
&include_bytes!("../shader/kernel4.spv")[..]
ShaderCode::Spv(include_bytes!("../shader/kernel4.spv"))
};
// This is an arbitrary limit on the number of textures that can be referenced by
// the fine rasterizer. To set it for real, we probably want to pay attention both
@ -386,13 +387,13 @@ impl Renderer {
pub unsafe fn record(&self, cmd_buf: &mut hub::CmdBuf, query_pool: &hub::QueryPool) {
cmd_buf.copy_buffer(
self.memory_buf_host.vk_buffer(),
self.memory_buf_dev.vk_buffer(),
self.memory_buf_host.mux_buffer(),
self.memory_buf_dev.mux_buffer(),
);
cmd_buf.clear_buffer(self.state_buf.vk_buffer(), None);
cmd_buf.clear_buffer(self.state_buf.mux_buffer(), None);
cmd_buf.memory_barrier();
cmd_buf.image_barrier(
self.image_dev.vk_image(),
self.image_dev.mux_image(),
ImageLayout::Undefined,
ImageLayout::General,
);
@ -451,7 +452,7 @@ impl Renderer {
cmd_buf.write_timestamp(&query_pool, 7);
cmd_buf.memory_barrier();
cmd_buf.image_barrier(
self.image_dev.vk_image(),
self.image_dev.mux_image(),
ImageLayout::General,
ImageLayout::BlitSrc,
);
@ -475,12 +476,16 @@ impl Renderer {
let mut cmd_buf = session.cmd_buf()?;
cmd_buf.begin();
cmd_buf.image_barrier(
image.vk_image(),
image.mux_image(),
ImageLayout::Undefined,
ImageLayout::BlitDst,
);
cmd_buf.copy_buffer_to_image(buffer.vk_buffer(), image.vk_image());
cmd_buf.image_barrier(image.vk_image(), ImageLayout::BlitDst, ImageLayout::General);
cmd_buf.copy_buffer_to_image(buffer.mux_buffer(), image.mux_image());
cmd_buf.image_barrier(
image.mux_image(),
ImageLayout::BlitDst,
ImageLayout::General,
);
cmd_buf.finish();
// Make sure not to drop the buffer and image until the command buffer completes.
cmd_buf.add_resource(&buffer);