update rpp

TheNumbat · TheNumbat · commit df4a3d4d3904 · 2024-04-09T20:11:41.000-04:00
diff --git a/deps/rpp b/deps/rpp
@@ -1 +1 @@
-Subproject commit e31d0beb568936a0c100dd46ecece6064d4baab0
+Subproject commit 9b08c412b6a00943b12fb50c29ce200bffd90c2b
diff --git a/rvk/acceleration.cpp b/rvk/acceleration.cpp
@@ -82,7 +82,7 @@ Opt<TLAS::Buffers> TLAS::make(Arc<Device_Memory, Alloc>& memory, u32 instances)
 }
 
 TLAS TLAS::build(Arc<Device, Alloc> device, Commands& cmds, Buffers buffers, Buffer gpu_instances,
-                 Slice<Instance> cpu_instances) {
+                 Slice<const Instance> cpu_instances) {
 
     VkAccelerationStructureKHR acceleration_structure = null;
 
@@ -168,7 +168,7 @@ u64 BLAS::gpu_address() {
     return vkGetAccelerationStructureDeviceAddressKHR(*device, &info);
 }
 
-Opt<BLAS::Buffers> BLAS::make(Arc<Device_Memory, Alloc>& memory, Slice<BLAS::Size> sizes) {
+Opt<BLAS::Buffers> BLAS::make(Arc<Device_Memory, Alloc>& memory, Slice<const BLAS::Size> sizes) {
 
     assert(sizes.length());
 
@@ -239,7 +239,7 @@ Opt<BLAS::Buffers> BLAS::make(Arc<Device_Memory, Alloc>& memory, Slice<BLAS::Siz
 }
 
 BLAS BLAS::build(Arc<Device, Alloc> device, Commands& cmds, Buffers buffers, Buffer geometry,
-                 Slice<Offset> offsets) {
+                 Slice<const Offset> offsets) {
 
     assert(offsets.length());
 
diff --git a/rvk/acceleration.h b/rvk/acceleration.h
@@ -41,7 +41,7 @@ struct TLAS {
 
     static Opt<Buffers> make(Arc<Device_Memory, Alloc>& memory, u32 instances);
     static TLAS build(Arc<Device, Alloc> device, Commands& cmds, Buffers buffers,
-                      Buffer gpu_instances, Slice<Instance> cpu_instances);
+                      Buffer gpu_instances, Slice<const Instance> cpu_instances);
 
     Arc<Device, Alloc> device;
 
@@ -86,13 +86,12 @@ struct BLAS {
     }
 
 private:
-    explicit BLAS(Arc<Device, Alloc> device, VkAccelerationStructureKHR structure,
-                  Buffer buffer);
+    explicit BLAS(Arc<Device, Alloc> device, VkAccelerationStructureKHR structure, Buffer buffer);
     friend struct Vk;
 
-    static Opt<Buffers> make(Arc<Device_Memory, Alloc>& memory, Slice<Size> sizes);
+    static Opt<Buffers> make(Arc<Device_Memory, Alloc>& memory, Slice<const Size> sizes);
     static BLAS build(Arc<Device, Alloc> device, Commands& cmds, Buffers buffers, Buffer geometry,
-                      Slice<Offset> offsets);
+                      Slice<const Offset> offsets);
 
     Arc<Device, Alloc> device;
 
diff --git a/rvk/descriptors.cpp b/rvk/descriptors.cpp
@@ -106,7 +106,7 @@ Descriptor_Set::~Descriptor_Set() {
     }
 }
 
-void Descriptor_Set::write(u64 frame_index, Slice<VkWriteDescriptorSet> writes) {
+void Descriptor_Set::write(u64 frame_index, Slice<const VkWriteDescriptorSet> writes) {
     assert(frame_index < sets.length());
 
     Region(R) {
@@ -121,8 +121,8 @@ void Descriptor_Set::write(u64 frame_index, Slice<VkWriteDescriptorSet> writes)
 }
 
 Descriptor_Set_Layout::Descriptor_Set_Layout(Arc<Device, Alloc> D,
-                                             Slice<VkDescriptorSetLayoutBinding> bindings,
-                                             Slice<VkDescriptorBindingFlags> flags)
+                                             Slice<const VkDescriptorSetLayoutBinding> bindings,
+                                             Slice<const VkDescriptorBindingFlags> flags)
     : device(move(D)) {
 
     assert(bindings.length() == flags.length() || flags.length() == 0);
diff --git a/rvk/descriptors.h b/rvk/descriptors.h
@@ -26,8 +26,8 @@ struct Descriptor_Set_Layout {
 
 private:
     explicit Descriptor_Set_Layout(Arc<Device, Alloc> device,
-                                   Slice<VkDescriptorSetLayoutBinding> bindings,
-                                   Slice<VkDescriptorBindingFlags> flags);
+                                   Slice<const VkDescriptorSetLayoutBinding> bindings,
+                                   Slice<const VkDescriptorBindingFlags> flags);
     friend struct Vk;
 
     Arc<Device, Alloc> device;
@@ -48,7 +48,7 @@ struct Descriptor_Set {
     Descriptor_Set(Descriptor_Set&& src) = default;
     Descriptor_Set& operator=(Descriptor_Set&& src) = default;
 
-    void write(u64 frame_index, Slice<VkWriteDescriptorSet> writes);
+    void write(u64 frame_index, Slice<const VkWriteDescriptorSet> writes);
 
     VkDescriptorSet get(u64 frame_index) {
         return sets[frame_index];
diff --git a/rvk/device.cpp b/rvk/device.cpp
@@ -283,14 +283,12 @@ u32 Physical_Device::n_present_modes(VkSurfaceKHR surface) {
 
 void Physical_Device::get_surface_formats(VkSurfaceKHR surface, Slice<VkSurfaceFormatKHR> formats) {
     u32 n = static_cast<u32>(formats.length());
-    RVK_CHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(
-        device, surface, &n, const_cast<VkSurfaceFormatKHR*>(formats.data())));
+    RVK_CHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &n, formats.data()));
 }
 
 void Physical_Device::get_present_modes(VkSurfaceKHR surface, Slice<VkPresentModeKHR> modes) {
     u32 n = static_cast<u32>(modes.length());
-    RVK_CHECK(vkGetPhysicalDeviceSurfacePresentModesKHR(
-        device, surface, &n, const_cast<VkPresentModeKHR*>(modes.data())));
+    RVK_CHECK(vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &n, modes.data()));
 }
 
 u64 Physical_Device::max_allocation() {
@@ -686,7 +684,8 @@ void Device::submit(Commands& cmds, u32 index, Fence& fence) {
     }
 }
 
-void Device::submit(Commands& cmds, u32 index, Slice<Sem_Ref> signal, Slice<Sem_Ref> wait) {
+void Device::submit(Commands& cmds, u32 index, Slice<const Sem_Ref> signal,
+                    Slice<const Sem_Ref> wait) {
 
     Region(R) {
 
@@ -732,8 +731,8 @@ void Device::submit(Commands& cmds, u32 index, Slice<Sem_Ref> signal, Slice<Sem_
     }
 }
 
-void Device::submit(Commands& cmds, u32 index, Slice<Sem_Ref> signal, Slice<Sem_Ref> wait,
-                    Fence& fence) {
+void Device::submit(Commands& cmds, u32 index, Slice<const Sem_Ref> signal,
+                    Slice<const Sem_Ref> wait, Fence& fence) {
 
     Region(R) {
 
@@ -814,7 +813,7 @@ Slice<const char*> Device::baseline_extensions() {
         reinterpret_cast<const char*>(VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME),
 #endif
     };
-    return Slice<const char*>{device};
+    return device.slice();
 }
 
 Slice<const char*> Device::ray_tracing_extensions() {
@@ -826,7 +825,7 @@ Slice<const char*> Device::ray_tracing_extensions() {
         reinterpret_cast<const char*>(VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME),
         reinterpret_cast<const char*>(VK_KHR_RAY_QUERY_EXTENSION_NAME),
     };
-    return Slice<const char*>{device};
+    return device.slice();
 }
 
 } // namespace rvk::impl
diff --git a/rvk/device.h b/rvk/device.h
@@ -109,8 +109,8 @@ struct Device {
 
     void submit(Commands& cmds, u32 index);
     void submit(Commands& cmds, u32 index, Fence& fence);
-    void submit(Commands& cmds, u32 index, Slice<Sem_Ref> wait, Slice<Sem_Ref> signal);
-    void submit(Commands& cmds, u32 index, Slice<Sem_Ref> wait, Slice<Sem_Ref> signal,
+    void submit(Commands& cmds, u32 index, Slice<const Sem_Ref> wait, Slice<const Sem_Ref> signal);
+    void submit(Commands& cmds, u32 index, Slice<const Sem_Ref> wait, Slice<const Sem_Ref> signal,
                 Fence& fence);
 
     operator VkDevice() const {
diff --git a/rvk/instance.cpp b/rvk/instance.cpp
@@ -36,8 +36,8 @@ void crash_dump_callback(const void* dump, u32 dump_size, void*) {
     Region(R) {
         static u64 count = 0;
         auto filename = format<Mregion<R>>("gpu-dump-%.nv-gpudmp"_v, count++);
-        static_cast<void>(Files::write(
-            filename.view(), Slice<u8>{reinterpret_cast<u8*>(const_cast<void*>(dump)), dump_size}));
+        static_cast<void>(
+            Files::write(filename.view(), Slice{reinterpret_cast<const u8*>(dump), dump_size}));
     }
 }
 
@@ -46,9 +46,8 @@ void shader_debug_info_callback(const void* dump, u32 debug_info_size, void*) {
     Region(R) {
         static u64 count = 0;
         auto filename = format<Mregion<R>>("gpu-dump-%.nvdbg"_v, count++);
-        static_cast<void>(
-            Files::write(filename.view(), Slice<u8>{reinterpret_cast<u8*>(const_cast<void*>(dump)),
-                                                    debug_info_size}));
+        static_cast<void>(Files::write(filename.view(),
+                                       Slice{reinterpret_cast<const u8*>(dump), debug_info_size}));
     }
 }
 
@@ -120,10 +119,10 @@ Slice<const char*> Instance::baseline_extensions() {
     static Array<const char*, 1> instance{
         reinterpret_cast<const char*>(VK_EXT_DEBUG_UTILS_EXTENSION_NAME),
     };
-    return Slice<const char*>{instance};
+    return instance.slice();
 }
 
-Instance::Instance(Slice<String_View> extensions, Slice<String_View> layers,
+Instance::Instance(Slice<const String_View> extensions, Slice<const String_View> layers,
                    Function<VkSurfaceKHR(VkInstance)> create_surface, bool validation) {
 
     Profile::Time_Point start = Profile::timestamp();
diff --git a/rvk/instance.h b/rvk/instance.h
@@ -50,7 +50,7 @@ struct Instance {
     static Slice<const char*> baseline_extensions();
 
 private:
-    explicit Instance(Slice<String_View> extensions, Slice<String_View> layers,
+    explicit Instance(Slice<const String_View> extensions, Slice<const String_View> layers,
                       Function<VkSurfaceKHR(VkInstance)> create_surface, bool validation);
     friend struct Arc<Instance, Alloc>;
 
diff --git a/rvk/pipeline.cpp b/rvk/pipeline.cpp
@@ -19,7 +19,7 @@ static VkPipelineBindPoint bind_point(Pipeline::Kind kind) {
     }
 }
 
-Shader::Shader(Arc<Device, Alloc> D, Slice<u8> source) : device(move(D)) {
+Shader::Shader(Arc<Device, Alloc> D, Slice<const u8> source) : device(move(D)) {
 
     VkShaderModuleCreateInfo mod_info = {
         .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
diff --git a/rvk/pipeline.h b/rvk/pipeline.h
@@ -25,7 +25,7 @@ using namespace rpp;
 
 struct Shader {
 
-    explicit Shader(Arc<Device, Alloc> device, Slice<u8> source);
+    explicit Shader(Arc<Device, Alloc> device, Slice<const u8> source);
 
     Shader() = default;
     ~Shader();
@@ -65,10 +65,10 @@ struct Binding_Table {
     };
 
     struct Mapping {
-        Slice<u32> gen;
-        Slice<u32> miss;
-        Slice<u32> hit;
-        Slice<u32> call;
+        Slice<const u32> gen;
+        Slice<const u32> miss;
+        Slice<const u32> hit;
+        Slice<const u32> call;
     };
 
     Binding_Table() = default;
@@ -120,8 +120,8 @@ struct Pipeline {
                                  VkRayTracingPipelineCreateInfoKHR>;
 
     struct Info {
-        Slice<VkPushConstantRange> push_constants;
-        Slice<Ref<Descriptor_Set_Layout>> descriptor_set_layouts;
+        Slice<const VkPushConstantRange> push_constants;
+        Slice<const Ref<Descriptor_Set_Layout>> descriptor_set_layouts;
         VkCreateInfo info;
     };
 
diff --git a/rvk/rvk.cpp b/rvk/rvk.cpp
@@ -144,12 +144,12 @@ struct Vk {
                                   Binding_Table::Mapping mapping);
 
     Opt<TLAS::Buffers> make_tlas(u32 instances);
-    Opt<BLAS::Buffers> make_blas(Slice<BLAS::Size> sizes);
+    Opt<BLAS::Buffers> make_blas(Slice<const BLAS::Size> sizes);
 
     TLAS build_tlas(Commands& cmds, TLAS::Buffers tlas, Buffer gpu_instances,
-                    Slice<TLAS::Instance> cpu_instances);
+                    Slice<const TLAS::Instance> cpu_instances);
     BLAS build_blas(Commands& cmds, BLAS::Buffers blas, Buffer geometry,
-                    Slice<BLAS::Offset> offsets);
+                    Slice<const BLAS::Offset> offsets);
 };
 
 static Opt<Vk> singleton;
@@ -466,7 +466,7 @@ Opt<TLAS::Buffers> Vk::make_tlas(u32 instances) {
     return {};
 }
 
-Opt<BLAS::Buffers> Vk::make_blas(Slice<BLAS::Size> sizes) {
+Opt<BLAS::Buffers> Vk::make_blas(Slice<const BLAS::Size> sizes) {
     for(auto& device_memory : device_memories) {
         if(auto blas = BLAS::make(device_memory, sizes); blas.ok()) {
             return blas;
@@ -476,12 +476,12 @@ Opt<BLAS::Buffers> Vk::make_blas(Slice<BLAS::Size> sizes) {
 }
 
 TLAS Vk::build_tlas(Commands& cmds, TLAS::Buffers tlas, Buffer gpu_instances,
-                    Slice<TLAS::Instance> cpu_instances) {
+                    Slice<const TLAS::Instance> cpu_instances) {
     return TLAS::build(device.dup(), cmds, move(tlas), move(gpu_instances), cpu_instances);
 }
 
 BLAS Vk::build_blas(Commands& cmds, BLAS::Buffers blas, Buffer geometry,
-                    Slice<BLAS::Offset> offsets) {
+                    Slice<const BLAS::Offset> offsets) {
     return BLAS::build(device.dup(), cmds, move(blas), move(geometry), offsets);
 }
 
@@ -618,12 +618,12 @@ Opt<TLAS::Buffers> make_tlas(u32 instances) {
     return impl::singleton->make_tlas(instances);
 }
 
-Opt<BLAS::Buffers> make_blas(Slice<BLAS::Size> sizes) {
+Opt<BLAS::Buffers> make_blas(Slice<const BLAS::Size> sizes) {
     return impl::singleton->make_blas(sizes);
 }
 
 TLAS build_tlas(Commands& cmds, TLAS::Buffers tlas, Buffer gpu_instances,
-                Slice<TLAS::Instance> cpu_instances) {
+                Slice<const TLAS::Instance> cpu_instances) {
     return impl::singleton->build_tlas(cmds, move(tlas), move(gpu_instances), cpu_instances);
 }
 
@@ -639,11 +639,12 @@ void submit(Commands& cmds, u32 index, Fence& fence) {
     impl::singleton->device->submit(cmds, index, fence);
 }
 
-void submit(Commands& cmds, u32 index, Slice<Sem_Ref> wait, Slice<Sem_Ref> signal) {
+void submit(Commands& cmds, u32 index, Slice<const Sem_Ref> wait, Slice<const Sem_Ref> signal) {
     impl::singleton->device->submit(cmds, index, wait, signal);
 }
 
-void submit(Commands& cmds, u32 index, Slice<Sem_Ref> wait, Slice<Sem_Ref> signal, Fence& fence) {
+void submit(Commands& cmds, u32 index, Slice<const Sem_Ref> wait, Slice<const Sem_Ref> signal,
+            Fence& fence) {
     impl::singleton->device->submit(cmds, index, wait, signal, fence);
 }
 
diff --git a/rvk/rvk.h b/rvk/rvk.h
@@ -32,8 +32,8 @@ struct Config {
     u32 frames_in_flight = 2;
     u32 descriptors_per_type = 128;
 
-    Slice<String_View> layers;
-    Slice<String_View> swapchain_extensions;
+    Slice<const String_View> layers;
+    Slice<const String_View> swapchain_extensions;
     Function<VkSurfaceKHR(VkInstance)> create_surface;
 
     u64 host_heap = Math::GB(1);
@@ -74,17 +74,18 @@ Opt<Buffer> make_buffer(u64 size, VkBufferUsageFlags usage);
 Opt<Image> make_image(VkExtent3D extent, VkFormat format, VkImageUsageFlags usage);
 
 Opt<TLAS::Buffers> make_tlas(u32 instances);
-Opt<BLAS::Buffers> make_blas(Slice<BLAS::Size> sizes);
+Opt<BLAS::Buffers> make_blas(Slice<const BLAS::Size> sizes);
 
 TLAS build_tlas(Commands& cmds, TLAS::Buffers tlas, Buffer gpu_instances,
-                Slice<TLAS::Instance> cpu_instances);
-BLAS build_blas(Commands& cmds, BLAS::Buffers blas, Buffer geometry, Slice<BLAS::Offset> offsets);
+                Slice<const TLAS::Instance> cpu_instances);
+BLAS build_blas(Commands& cmds, BLAS::Buffers blas, Buffer geometry,
+                Slice<const BLAS::Offset> offsets);
 
 // Pipelines
 
 template<Type_List L>
     requires(Reflect::All<Is_Binding, L>)
-Descriptor_Set_Layout make_layout(Slice<u32> counts = Slice<u32>{});
+Descriptor_Set_Layout make_layout(Slice<const u32> counts = Slice<const u32>{});
 
 Descriptor_Set make_set(Descriptor_Set_Layout& layout, u32 variable_count = 0);
 
@@ -106,8 +107,9 @@ Opt<Binding_Table> make_table(Commands& cmds, Pipeline& pipeline, Binding_Table:
 
 void submit(Commands& cmds, u32 index);
 void submit(Commands& cmds, u32 index, Fence& fence);
-void submit(Commands& cmds, u32 index, Slice<Sem_Ref> wait, Slice<Sem_Ref> signal);
-void submit(Commands& cmds, u32 index, Slice<Sem_Ref> wait, Slice<Sem_Ref> signal, Fence& fence);
+void submit(Commands& cmds, u32 index, Slice<const Sem_Ref> wait, Slice<const Sem_Ref> signal);
+void submit(Commands& cmds, u32 index, Slice<const Sem_Ref> wait, Slice<const Sem_Ref> signal,
+            Fence& fence);
 
 template<typename F>
     requires Invocable<F, Commands&>
diff --git a/rvk/swapchain.cpp b/rvk/swapchain.cpp
diff --git a/rvk/swapchain.h b/rvk/swapchain.h

Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ Opt<TLAS::Buffers> TLAS::make(Arc<Device_Memory, Alloc>& memory, u32 instances)`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`TLAS TLAS::build(Arc<Device, Alloc> device, Commands& cmds, Buffers buffers, Buffer gpu_instances,`
`85`		`- Slice<Instance> cpu_instances) {`
	`85`	`+ Slice<const Instance> cpu_instances) {`
`86`	`86`
`87`	`87`	`VkAccelerationStructureKHR acceleration_structure = null;`
`88`	`88`
`@@ -168,7 +168,7 @@ u64 BLAS::gpu_address() {`
`168`	`168`	`return vkGetAccelerationStructureDeviceAddressKHR(*device, &info);`
`169`	`169`	`}`
`170`	`170`
`171`		`-Opt<BLAS::Buffers> BLAS::make(Arc<Device_Memory, Alloc>& memory, Slice<BLAS::Size> sizes) {`
	`171`	`+Opt<BLAS::Buffers> BLAS::make(Arc<Device_Memory, Alloc>& memory, Slice<const BLAS::Size> sizes) {`
`172`	`172`
`173`	`173`	`assert(sizes.length());`
`174`	`174`
`@@ -239,7 +239,7 @@ Opt<BLAS::Buffers> BLAS::make(Arc<Device_Memory, Alloc>& memory, Slice<BLAS::Siz`
`239`	`239`	`}`
`240`	`240`
`241`	`241`	`BLAS BLAS::build(Arc<Device, Alloc> device, Commands& cmds, Buffers buffers, Buffer geometry,`
`242`		`- Slice<Offset> offsets) {`
	`242`	`+ Slice<const Offset> offsets) {`
`243`	`243`
`244`	`244`	`assert(offsets.length());`
`245`	`245`
Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ Descriptor_Set::~Descriptor_Set() {`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`
`109`		`-void Descriptor_Set::write(u64 frame_index, Slice<VkWriteDescriptorSet> writes) {`
	`109`	`+void Descriptor_Set::write(u64 frame_index, Slice<const VkWriteDescriptorSet> writes) {`
`110`	`110`	`assert(frame_index < sets.length());`
`111`	`111`
`112`	`112`	`Region(R) {`
`@@ -121,8 +121,8 @@ void Descriptor_Set::write(u64 frame_index, Slice<VkWriteDescriptorSet> writes)`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`Descriptor_Set_Layout::Descriptor_Set_Layout(Arc<Device, Alloc> D,`
`124`		`- Slice<VkDescriptorSetLayoutBinding> bindings,`
`125`		`- Slice<VkDescriptorBindingFlags> flags)`
	`124`	`+ Slice<const VkDescriptorSetLayoutBinding> bindings,`
	`125`	`+ Slice<const VkDescriptorBindingFlags> flags)`
`126`	`126`	`: device(move(D)) {`
`127`	`127`
`128`	`128`	`assert(bindings.length() == flags.length() \|\| flags.length() == 0);`
Original file line number	Diff line number	Diff line change
`@@ -283,14 +283,12 @@ u32 Physical_Device::n_present_modes(VkSurfaceKHR surface) {`
`283`	`283`
`284`	`284`	`void Physical_Device::get_surface_formats(VkSurfaceKHR surface, Slice<VkSurfaceFormatKHR> formats) {`
`285`	`285`	`u32 n = static_cast<u32>(formats.length());`
`286`		`- RVK_CHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(`
`287`		`- device, surface, &n, const_cast<VkSurfaceFormatKHR*>(formats.data())));`
	`286`	`+ RVK_CHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &n, formats.data()));`
`288`	`287`	`}`
`289`	`288`
`290`	`289`	`void Physical_Device::get_present_modes(VkSurfaceKHR surface, Slice<VkPresentModeKHR> modes) {`
`291`	`290`	`u32 n = static_cast<u32>(modes.length());`
`292`		`- RVK_CHECK(vkGetPhysicalDeviceSurfacePresentModesKHR(`
`293`		`- device, surface, &n, const_cast<VkPresentModeKHR*>(modes.data())));`
	`291`	`+ RVK_CHECK(vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &n, modes.data()));`
`294`	`292`	`}`
`295`	`293`
`296`	`294`	`u64 Physical_Device::max_allocation() {`
`@@ -686,7 +684,8 @@ void Device::submit(Commands& cmds, u32 index, Fence& fence) {`
`686`	`684`	`}`
`687`	`685`	`}`
`688`	`686`
`689`		`-void Device::submit(Commands& cmds, u32 index, Slice<Sem_Ref> signal, Slice<Sem_Ref> wait) {`
	`687`	`+void Device::submit(Commands& cmds, u32 index, Slice<const Sem_Ref> signal,`
	`688`	`+ Slice<const Sem_Ref> wait) {`
`690`	`689`
`691`	`690`	`Region(R) {`
`692`	`691`
`@@ -732,8 +731,8 @@ void Device::submit(Commands& cmds, u32 index, Slice<Sem_Ref> signal, Slice<Sem_`
`732`	`731`	`}`
`733`	`732`	`}`
`734`	`733`
`735`		`-void Device::submit(Commands& cmds, u32 index, Slice<Sem_Ref> signal, Slice<Sem_Ref> wait,`
`736`		`- Fence& fence) {`
	`734`	`+void Device::submit(Commands& cmds, u32 index, Slice<const Sem_Ref> signal,`
	`735`	`+ Slice<const Sem_Ref> wait, Fence& fence) {`
`737`	`736`
`738`	`737`	`Region(R) {`
`739`	`738`
`@@ -814,7 +813,7 @@ Slice<const char*> Device::baseline_extensions() {`
`814`	`813`	`reinterpret_cast<const char*>(VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME),`
`815`	`814`	`#endif`
`816`	`815`	`};`
`817`		`- return Slice<const char*>{device};`
	`816`	`+ return device.slice();`
`818`	`817`	`}`
`819`	`818`
`820`	`819`	`Slice<const char*> Device::ray_tracing_extensions() {`
`@@ -826,7 +825,7 @@ Slice<const char*> Device::ray_tracing_extensions() {`
`826`	`825`	`reinterpret_cast<const char*>(VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME),`
`827`	`826`	`reinterpret_cast<const char*>(VK_KHR_RAY_QUERY_EXTENSION_NAME),`
`828`	`827`	`};`
`829`		`- return Slice<const char*>{device};`
	`828`	`+ return device.slice();`
`830`	`829`	`}`
`831`	`830`
`832`	`831`	`} // namespace rvk::impl`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ static VkPipelineBindPoint bind_point(Pipeline::Kind kind) {`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`
`22`		`-Shader::Shader(Arc<Device, Alloc> D, Slice<u8> source) : device(move(D)) {`
	`22`	`+Shader::Shader(Arc<Device, Alloc> D, Slice<const u8> source) : device(move(D)) {`
`23`	`23`
`24`	`24`	`VkShaderModuleCreateInfo mod_info = {`
`25`	`25`	`.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,`