Rename CmdBuffer to CmdEncoder.
Rename MappedBuffer to PersistentBuffer.
let blåhaj_image_data = load_image("bins/narcissus/data/blåhaj.png");
let (blåhaj_vertices, blåhaj_indices) = load_obj("bins/narcissus/data/blåhaj.obj");
- let blåhaj_vertex_buffer = device.create_mapped_buffer_with_data(
+ let blåhaj_vertex_buffer = device.create_persistent_buffer_with_data(
MemoryLocation::Device,
BufferUsageFlags::STORAGE,
blåhaj_vertices.as_slice(),
);
- let blåhaj_index_buffer = device.create_mapped_buffer_with_data(
+ let blåhaj_index_buffer = device.create_persistent_buffer_with_data(
MemoryLocation::Device,
BufferUsageFlags::INDEX,
blåhaj_indices.as_slice(),
blåhaj_image_data.as_slice(),
);
- let mut cmd_buffer = device.create_cmd_buffer(&frame, &thread_token);
+ let mut cmd_encoder = device.request_cmd_encoder(&frame, &thread_token);
+
device.cmd_barrier(
- &mut cmd_buffer,
+ &mut cmd_encoder,
None,
&[
ImageBarrier::layout_optimal(
);
device.cmd_copy_buffer_to_image(
- &mut cmd_buffer,
+ &mut cmd_encoder,
blåhaj_buffer.to_arg(),
blåhaj_image,
ImageLayout::Optimal,
);
device.cmd_barrier(
- &mut cmd_buffer,
+ &mut cmd_encoder,
None,
&[ImageBarrier::layout_optimal(
&[Access::TransferWrite],
)],
);
- device.submit(&frame, cmd_buffer);
+ device.submit(&frame, cmd_encoder);
device.end_frame(frame);
}
}
};
- let mut cmd_buffer = device.create_cmd_buffer(&frame, &thread_token);
+ let mut cmd_buffer = device.request_cmd_encoder(&frame, &thread_token);
if width != depth_width || height != depth_height {
device.destroy_image(&frame, depth_image);
use narcissus_core::{cstr, default, include_bytes_align};
use narcissus_gpu::{
Bind, BindGroupLayout, BindGroupLayoutDesc, BindGroupLayoutEntryDesc, BindingType, BlendMode,
- BufferUsageFlags, CmdBuffer, CompareOp, CullingMode, Device, DeviceExt, Frame, FrontFace,
+ BufferUsageFlags, CmdEncoder, CompareOp, CullingMode, Device, DeviceExt, Frame, FrontFace,
GraphicsPipelineDesc, GraphicsPipelineLayout, Image, ImageFormat, ImageLayout, IndexType,
- MappedBuffer, Pipeline, PolygonMode, Sampler, SamplerAddressMode, SamplerDesc, SamplerFilter,
- ShaderDesc, ShaderStageFlags, ThreadToken, Topology, TypedBind,
+ PersistentBuffer, Pipeline, PolygonMode, Sampler, SamplerAddressMode, SamplerDesc,
+ SamplerFilter, ShaderDesc, ShaderStageFlags, ThreadToken, Topology, TypedBind,
};
use narcissus_maths::{Affine3, Mat4};
device: &(dyn Device + 'static),
frame: &Frame,
thread_token: &ThreadToken,
- cmd_buffer: &mut CmdBuffer,
+ cmd_buffer: &mut CmdEncoder,
basic_uniforms: &BasicUniforms,
- vertex_buffer: &MappedBuffer,
- index_buffer: &MappedBuffer,
+ vertex_buffer: &PersistentBuffer,
+ index_buffer: &PersistentBuffer,
transforms: &[Affine3],
texture: Image,
) {
use narcissus_font::{TouchedGlyph, TouchedGlyphIndex};
use narcissus_gpu::{
Bind, BindGroupLayout, BindGroupLayoutDesc, BindGroupLayoutEntryDesc, BindingType, BlendMode,
- BufferUsageFlags, CmdBuffer, CompareOp, CullingMode, Device, DeviceExt, Frame, FrontFace,
+ BufferUsageFlags, CmdEncoder, CompareOp, CullingMode, Device, DeviceExt, Frame, FrontFace,
GraphicsPipelineDesc, GraphicsPipelineLayout, Image, ImageFormat, ImageLayout, Pipeline,
PolygonMode, Sampler, SamplerAddressMode, SamplerDesc, SamplerFilter, ShaderDesc,
ShaderStageFlags, ThreadToken, Topology, TypedBind,
device: &(dyn Device + 'static),
frame: &Frame,
thread_token: &ThreadToken,
- cmd_buffer: &mut CmdBuffer,
+ cmd_buffer: &mut CmdEncoder,
text_uniforms: &TextUniforms,
primitive_vertices: &[PrimitiveVertex],
touched_glyphs: &[TouchedGlyph],
use crate::{
delay_queue::DelayQueue, frame_counter::FrameCounter, Bind, BindGroupLayout,
BindGroupLayoutDesc, Buffer, BufferArg, BufferDesc, BufferImageCopy, BufferUsageFlags,
- CmdBuffer, ComputePipelineDesc, Device, Extent2d, Extent3d, Frame, GlobalBarrier,
+ CmdEncoder, ComputePipelineDesc, Device, Extent2d, Extent3d, Frame, GlobalBarrier,
GpuConcurrent, GraphicsPipelineDesc, Image, ImageBarrier, ImageBlit, ImageDesc, ImageDimension,
- ImageFormat, ImageLayout, ImageTiling, ImageUsageFlags, ImageViewDesc, IndexType, MappedBuffer,
- MemoryLocation, Offset2d, Offset3d, Pipeline, Sampler, SamplerAddressMode, SamplerCompareOp,
- SamplerDesc, SamplerFilter, SwapchainOutOfDateError, ThreadToken, TransientBuffer, TypedBind,
+ ImageFormat, ImageLayout, ImageTiling, ImageUsageFlags, ImageViewDesc, IndexType,
+ MemoryLocation, Offset2d, Offset3d, PersistentBuffer, Pipeline, Sampler, SamplerAddressMode,
+ SamplerCompareOp, SamplerDesc, SamplerFilter, SwapchainOutOfDateError, ThreadToken,
+ TransientBuffer, TypedBind,
};
mod allocator;
unsafe { &mut *self.frames[frame.frame_index % VULKAN_CONSTANTS.num_frames].get() }
}
- fn cmd_buffer_mut<'a>(&self, cmd_buffer: &'a mut CmdBuffer) -> &'a mut VulkanCmdBuffer {
- // SAFETY: `CmdBuffer`s can't outlive a frame, and the memory for a cmd_buffer
+ fn cmd_buffer_mut<'a>(&self, cmd_encoder: &'a mut CmdEncoder) -> &'a mut VulkanCmdBuffer {
+ // SAFETY: `CmdEncoder`s can't outlive a frame, and the memory for a cmd_buffer
// is reset when the frame ends. So the pointer contained in the cmd_buffer is
// always valid while the `CmdBuffer` is valid. They can't cloned, copied or be
// sent between threads, and we have a mutable reference.
unsafe {
- NonNull::new_unchecked(cmd_buffer.cmd_buffer_addr as *mut VulkanCmdBuffer).as_mut()
+ NonNull::new_unchecked(cmd_encoder.cmd_buffer_addr as *mut VulkanCmdBuffer).as_mut()
}
}
self.request_transient_buffer(frame, thread_token, usage, size as u64)
}
- fn create_cmd_buffer<'a, 'thread>(
+ fn request_cmd_encoder<'a, 'thread>(
&self,
frame: &'a Frame,
- thread_token: &'thread ThreadToken,
- ) -> CmdBuffer<'a, 'thread> {
+ thread_token: &'a ThreadToken,
+ ) -> CmdEncoder<'a> {
let frame = self.frame(frame);
let per_thread = frame.per_thread.get(thread_token);
let mut cmd_buffer_pool = per_thread.cmd_buffer_pool.borrow_mut();
..default()
});
- CmdBuffer {
+ CmdEncoder {
cmd_buffer_addr: vulkan_cmd_buffer as *mut _ as usize,
- _phantom: &PhantomData,
-
thread_token,
phantom_unsend: PhantomUnsend {},
}
fn cmd_barrier(
&self,
- cmd_buffer: &mut CmdBuffer,
+ cmd_encoder: &mut CmdEncoder,
global_barrier: Option<&GlobalBarrier>,
image_barriers: &[ImageBarrier],
) {
vulkan_image_memory_barrier(image_barrier, image, subresource_range)
}));
- let command_buffer = self.cmd_buffer_mut(cmd_buffer).command_buffer;
+ let command_buffer = self.cmd_buffer_mut(cmd_encoder).command_buffer;
unsafe {
self.device_fn.cmd_pipeline_barrier2(
command_buffer,
fn cmd_copy_buffer_to_image(
&self,
- cmd_buffer: &mut CmdBuffer,
+ cmd_encoder: &mut CmdEncoder,
src_buffer: BufferArg,
dst_image: Image,
dst_image_layout: ImageLayout,
ImageLayout::General => vk::ImageLayout::General,
};
- let command_buffer = self.cmd_buffer_mut(cmd_buffer).command_buffer;
+ let command_buffer = self.cmd_buffer_mut(cmd_encoder).command_buffer;
unsafe {
self.device_fn.cmd_copy_buffer_to_image(
command_buffer,
fn cmd_blit_image(
&self,
- cmd_buffer: &mut CmdBuffer,
+ cmd_encoder: &mut CmdEncoder,
src_image: Image,
src_image_layout: ImageLayout,
dst_image: Image,
ImageLayout::General => vk::ImageLayout::General,
};
- let command_buffer = self.cmd_buffer_mut(cmd_buffer).command_buffer;
+ let command_buffer = self.cmd_buffer_mut(cmd_encoder).command_buffer;
unsafe {
self.device_fn.cmd_blit_image(
command_buffer,
fn cmd_set_bind_group(
&self,
frame: &Frame,
- cmd_buffer: &mut CmdBuffer,
+ cmd_encoder: &mut CmdEncoder,
layout: BindGroupLayout,
bind_group_index: u32,
bindings: &[Bind],
let descriptor_set_layout = self.bind_group_layout_pool.lock().get(layout.0).unwrap().0;
let frame = self.frame(frame);
- let per_thread = frame.per_thread.get(cmd_buffer.thread_token);
+ let per_thread = frame.per_thread.get(cmd_encoder.thread_token);
let mut descriptor_pool = per_thread.descriptor_pool.get();
let mut allocated_pool = false;
.update_descriptor_sets(self.device, write_descriptors, &[])
};
- let cmd_buffer = self.cmd_buffer_mut(cmd_buffer);
+ let cmd_buffer = self.cmd_buffer_mut(cmd_encoder);
let VulkanBoundPipeline {
pipeline_layout,
pipeline_bind_point,
fn cmd_set_index_buffer(
&self,
- cmd_buffer: &mut CmdBuffer,
+ cmd_encoder: &mut CmdEncoder,
buffer: BufferArg,
offset: u64,
index_type: IndexType,
) {
let (buffer, base_offset, _range) = self.unwrap_buffer_arg(&buffer);
- let command_buffer = self.cmd_buffer_mut(cmd_buffer).command_buffer;
+ let command_buffer = self.cmd_buffer_mut(cmd_encoder).command_buffer;
let index_type = vulkan_index_type(index_type);
unsafe {
self.device_fn.cmd_bind_index_buffer(
}
}
- fn cmd_set_pipeline(&self, cmd_buffer: &mut CmdBuffer, pipeline: Pipeline) {
- let cmd_buffer = self.cmd_buffer_mut(cmd_buffer);
+ fn cmd_set_pipeline(&self, cmd_encoder: &mut CmdEncoder, pipeline: Pipeline) {
+ let cmd_buffer = self.cmd_buffer_mut(cmd_encoder);
let VulkanPipeline {
pipeline,
};
}
- fn cmd_begin_rendering(&self, cmd_buffer: &mut CmdBuffer, desc: &crate::RenderingDesc) {
+ fn cmd_begin_rendering(&self, cmd_encoder: &mut CmdEncoder, desc: &crate::RenderingDesc) {
let arena = HybridArena::<1024>::new();
- let cmd_buffer = self.cmd_buffer_mut(cmd_buffer);
+ let cmd_buffer = self.cmd_buffer_mut(cmd_encoder);
let color_attachments =
arena.alloc_slice_fill_iter(desc.color_attachments.iter().map(|attachment| {
}
}
- fn cmd_end_rendering(&self, cmd_buffer: &mut CmdBuffer) {
- let command_buffer = self.cmd_buffer_mut(cmd_buffer).command_buffer;
+ fn cmd_end_rendering(&self, cmd_encoder: &mut CmdEncoder) {
+ let command_buffer = self.cmd_buffer_mut(cmd_encoder).command_buffer;
unsafe { self.device_fn.cmd_end_rendering(command_buffer) }
}
- fn cmd_set_viewports(&self, cmd_buffer: &mut CmdBuffer, viewports: &[crate::Viewport]) {
- let command_buffer = self.cmd_buffer_mut(cmd_buffer).command_buffer;
+ fn cmd_set_viewports(&self, cmd_encoder: &mut CmdEncoder, viewports: &[crate::Viewport]) {
+ let command_buffer = self.cmd_buffer_mut(cmd_encoder).command_buffer;
unsafe {
self.device_fn.cmd_set_viewport_with_count(
command_buffer,
}
}
- fn cmd_set_scissors(&self, cmd_buffer: &mut CmdBuffer, scissors: &[crate::Scissor]) {
- let command_buffer = self.cmd_buffer_mut(cmd_buffer).command_buffer;
+ fn cmd_set_scissors(&self, cmd_encoder: &mut CmdEncoder, scissors: &[crate::Scissor]) {
+ let command_buffer = self.cmd_buffer_mut(cmd_encoder).command_buffer;
unsafe {
self.device_fn.cmd_set_scissor_with_count(
command_buffer,
fn cmd_draw(
&self,
- cmd_buffer: &mut CmdBuffer,
+ cmd_encoder: &mut CmdEncoder,
vertex_count: u32,
instance_count: u32,
first_vertex: u32,
first_instance: u32,
) {
- let command_buffer = self.cmd_buffer_mut(cmd_buffer).command_buffer;
+ let command_buffer = self.cmd_buffer_mut(cmd_encoder).command_buffer;
unsafe {
self.device_fn.cmd_draw(
command_buffer,
fn cmd_draw_indexed(
&self,
- cmd_buffer: &mut CmdBuffer,
+ cmd_encoder: &mut CmdEncoder,
index_count: u32,
instance_count: u32,
first_index: u32,
vertex_offset: i32,
first_instance: u32,
) {
- let command_buffer = self.cmd_buffer_mut(cmd_buffer).command_buffer;
+ let command_buffer = self.cmd_buffer_mut(cmd_encoder).command_buffer;
unsafe {
self.device_fn.cmd_draw_indexed(
command_buffer,
fn cmd_dispatch(
&self,
- cmd_buffer: &mut CmdBuffer,
+ cmd_encoder: &mut CmdEncoder,
group_count_x: u32,
group_count_y: u32,
group_count_z: u32,
) {
- let command_buffer = self.cmd_buffer_mut(cmd_buffer).command_buffer;
+ let command_buffer = self.cmd_buffer_mut(cmd_encoder).command_buffer;
unsafe {
self.device_fn
.cmd_dispatch(command_buffer, group_count_x, group_count_y, group_count_z)
}
}
- fn submit(&self, frame: &Frame, mut cmd_buffer: CmdBuffer) {
+ fn submit(&self, frame: &Frame, mut cmd_encoder: CmdEncoder) {
let fence = self.universal_queue_fence.fetch_add(1, Ordering::SeqCst) + 1;
let frame = self.frame(frame);
frame.universal_queue_fence.store(fence, Ordering::Relaxed);
- let cmd_buffer = self.cmd_buffer_mut(&mut cmd_buffer);
+ let cmd_buffer = self.cmd_buffer_mut(&mut cmd_encoder);
for &(image, _) in cmd_buffer.swapchains_touched.values() {
// transition swapchain image from attachment optimal to present src
self.destroy_swapchain(window)
}
- fn create_mapped_buffer<'device>(&'device self, desc: &BufferDesc) -> MappedBuffer<'device> {
+ fn create_persistent_buffer<'device>(
+ &'device self,
+ desc: &BufferDesc,
+ ) -> PersistentBuffer<'device> {
assert!(desc.host_mapped);
let buffer = self.create_buffer(desc);
let ptr = std::ptr::NonNull::new(self.map_buffer(buffer))
.expect("failed to map buffer memory");
- MappedBuffer {
+ PersistentBuffer {
ptr,
len: desc.size,
buffer,
}
}
- fn destroy_mapped_buffer(&self, frame: &Frame, buffer: MappedBuffer) {
+ fn destroy_persistent_buffer(&self, frame: &Frame, buffer: PersistentBuffer) {
unsafe { self.unmap_buffer(buffer.buffer) }
self.destroy_buffer(frame, buffer.buffer)
}
transient.offset,
transient.len as u64,
),
- BufferArg::Mapped(buffer) => (
+ BufferArg::Persistent(buffer) => (
self.buffer_pool.lock().get(buffer.buffer.0).unwrap().buffer,
0,
vk::WHOLE_SIZE,
mod backend;
mod delay_queue;
mod frame_counter;
-mod mapped_memory;
-pub mod tlsf;
+mod mapped_buffer;
+mod tlsf;
-pub use mapped_memory::{MappedBuffer, TransientBuffer};
+pub use mapped_buffer::{PersistentBuffer, TransientBuffer};
pub enum DeviceBackend {
Vulkan,
pub enum BufferArg<'a> {
Unmanaged(Buffer),
- Mapped(&'a MappedBuffer<'a>),
+ Persistent(&'a PersistentBuffer<'a>),
Transient(&'a TransientBuffer<'a>),
}
}
}
-pub struct CmdBuffer<'a, 'thread> {
+pub struct CmdEncoder<'a> {
cmd_buffer_addr: usize,
- thread_token: &'thread ThreadToken,
- _phantom: &'a PhantomData<()>,
+ thread_token: &'a ThreadToken,
phantom_unsend: PhantomUnsend,
}
pub trait Device {
fn create_buffer(&self, desc: &BufferDesc) -> Buffer;
- fn create_mapped_buffer<'device>(&'device self, desc: &BufferDesc) -> MappedBuffer<'device>;
+ fn create_persistent_buffer<'device>(
+ &'device self,
+ desc: &BufferDesc,
+ ) -> PersistentBuffer<'device>;
fn create_image(&self, desc: &ImageDesc) -> Image;
fn create_image_view(&self, desc: &ImageViewDesc) -> Image;
fn create_sampler(&self, desc: &SamplerDesc) -> Sampler;
fn create_compute_pipeline(&self, desc: &ComputePipelineDesc) -> Pipeline;
fn destroy_buffer(&self, frame: &Frame, buffer: Buffer);
- fn destroy_mapped_buffer(&self, frame: &Frame, buffer: MappedBuffer);
+ fn destroy_persistent_buffer(&self, frame: &Frame, buffer: PersistentBuffer);
fn destroy_image(&self, frame: &Frame, image: Image);
fn destroy_sampler(&self, frame: &Frame, sampler: Sampler);
fn destroy_bind_group_layout(&self, frame: &Frame, bind_group_layout: BindGroupLayout);
) -> TransientBuffer<'a>;
#[must_use]
- fn create_cmd_buffer<'a, 'thread>(
+ fn request_cmd_encoder<'a>(
&'a self,
- frame: &'a Frame,
- thread_token: &'thread ThreadToken,
- ) -> CmdBuffer<'a, 'thread>;
+ frame: &'a Frame<'a>,
+ thread_token: &'a ThreadToken,
+ ) -> CmdEncoder<'a>;
fn cmd_set_bind_group(
&self,
frame: &Frame,
- cmd_buffer: &mut CmdBuffer,
+ cmd_encoder: &mut CmdEncoder,
layout: BindGroupLayout,
bind_group_index: u32,
bindings: &[Bind],
fn cmd_set_index_buffer(
&self,
- cmd_buffer: &mut CmdBuffer,
+ cmd_encoder: &mut CmdEncoder,
buffer: BufferArg,
offset: u64,
index_type: IndexType,
);
- fn cmd_set_pipeline(&self, cmd_buffer: &mut CmdBuffer, pipeline: Pipeline);
+ fn cmd_set_pipeline(&self, cmd_encoder: &mut CmdEncoder, pipeline: Pipeline);
- fn cmd_set_viewports(&self, cmd_buffer: &mut CmdBuffer, viewports: &[Viewport]);
+ fn cmd_set_viewports(&self, cmd_encoder: &mut CmdEncoder, viewports: &[Viewport]);
- fn cmd_set_scissors(&self, cmd_buffer: &mut CmdBuffer, scissors: &[Scissor]);
+ fn cmd_set_scissors(&self, cmd_encoder: &mut CmdEncoder, scissors: &[Scissor]);
fn cmd_barrier(
&self,
- cmd_buffer: &mut CmdBuffer,
+ cmd_encoder: &mut CmdEncoder,
global_barrier: Option<&GlobalBarrier>,
image_barriers: &[ImageBarrier],
);
fn cmd_copy_buffer_to_image(
&self,
- cmd_buffer: &mut CmdBuffer,
+ cmd_encoder: &mut CmdEncoder,
src_buffer: BufferArg,
dst_image: Image,
dst_image_layout: ImageLayout,
fn cmd_blit_image(
&self,
- cmd_buffer: &mut CmdBuffer,
+ cmd_encoder: &mut CmdEncoder,
src_image: Image,
src_image_layout: ImageLayout,
dst_image: Image,
regions: &[ImageBlit],
);
- fn cmd_begin_rendering(&self, cmd_buffer: &mut CmdBuffer, desc: &RenderingDesc);
+ fn cmd_begin_rendering(&self, cmd_encoder: &mut CmdEncoder, desc: &RenderingDesc);
- fn cmd_end_rendering(&self, cmd_buffer: &mut CmdBuffer);
+ fn cmd_end_rendering(&self, cmd_encoder: &mut CmdEncoder);
fn cmd_draw(
&self,
- cmd_buffer: &mut CmdBuffer,
+ cmd_encoder: &mut CmdEncoder,
vertex_count: u32,
instance_count: u32,
first_vertex: u32,
fn cmd_draw_indexed(
&self,
- cmd_buffer: &mut CmdBuffer,
+ cmd_encoder: &mut CmdEncoder,
index_count: u32,
instance_count: u32,
first_index: u32,
fn cmd_dispatch(
&self,
- cmd_buffer: &mut CmdBuffer,
+ cmd_encoder: &mut CmdEncoder,
group_count_x: u32,
group_count_y: u32,
group_count_z: u32,
);
- fn submit(&self, frame: &Frame, cmd_buffer: CmdBuffer);
+ fn submit(&self, frame: &Frame, cmd_encoder: CmdEncoder);
fn begin_frame(&self) -> Frame;
}
pub trait DeviceExt: Device {
- fn create_mapped_buffer_with_data<'a, T: ?Sized>(
- &'a self,
- memory_location: MemoryLocation,
- usage: BufferUsageFlags,
- data: &T,
- ) -> MappedBuffer<'a>;
-
- fn request_transient_buffer_with_data<'a, T: ?Sized>(
- &'a self,
- frame: &'a Frame<'a>,
- thread_token: &'a ThreadToken,
- usage: BufferUsageFlags,
- data: &T,
- ) -> TransientBuffer<'a>;
-}
-
-impl DeviceExt for dyn Device {
- fn create_mapped_buffer_with_data<'a, T: ?Sized>(
+ fn create_persistent_buffer_with_data<'a, T: ?Sized>(
&'a self,
memory_location: MemoryLocation,
usage: BufferUsageFlags,
data: &T,
- ) -> MappedBuffer<'a> {
+ ) -> PersistentBuffer<'a> {
let size = std::mem::size_of_val(data);
- let mut mapped_buffer = self.create_mapped_buffer(&BufferDesc {
+ let mut mapped_buffer = self.create_persistent_buffer(&BufferDesc {
memory_location,
host_mapped: true,
usage,
transient_buffer
}
}
+
+impl DeviceExt for dyn Device {}
std::ptr::copy_nonoverlapping(src, dst, count)
}
-/// A mapped buffer is a GPU memory buffer that is persistently mapped into CPU
-/// address space and can be written to at any time.
+/// Persistent mapped buffer.
///
/// Making sure the buffer is not updated while it is concurrently in use by the
/// GPU is the responsibility of the caller.
-pub struct MappedBuffer<'a> {
+pub struct PersistentBuffer<'a> {
pub(crate) ptr: NonNull<u8>,
pub(crate) len: usize,
pub(crate) buffer: Buffer,
pub(crate) phantom: PhantomData<&'a u8>,
}
-impl<'a> MappedBuffer<'a> {
+impl<'a> PersistentBuffer<'a> {
pub fn to_arg(&self) -> BufferArg {
- BufferArg::Mapped(self)
+ BufferArg::Persistent(self)
}
pub fn copy_from<T: ?Sized>(&mut self, src: &T) {
}
}
+/// Transient mapped buffer that is tied to the lifetime of the current frame.
+///
+/// This buffer will be invalidated and recycled at the end of the frame.
pub struct TransientBuffer<'a> {
pub(crate) ptr: NonNull<u8>,
pub(crate) offset: u64,
}
#[cfg(debug_assertions)]
+ #[allow(unused)]
pub fn debug_bitmap_svg(&self, w: &mut dyn std::io::Write) -> Result<(), std::io::Error> {
use narcissus_core::svg::{self, svg_begin, svg_end};
projects / josh / narcissus / commitdiff