Struct VItemsBuffer 

pub struct VItemsBuffer {

    pub(crate) item_infos_buffer: WgpuVecBuffer<ItemInfo>,
    pub(crate) planes_buffer: WgpuVecBuffer<PlaneData>,
    pub(crate) clip_boxes_buffer: WgpuVecBuffer<i32>,
    pub(crate) transforms_buffer: WgpuVecBuffer<VitemTransform>,
    pub(crate) points3d_buffer: WgpuVecBuffer<Vec4>,
    pub(crate) points2d_buffer: WgpuVecBuffer<Vec4>,
    pub(crate) fill_rgbas_buffer: WgpuVecBuffer<Rgba>,
    pub(crate) stroke_rgbas_buffer: WgpuVecBuffer<Rgba>,
    pub(crate) stroke_widths_buffer: WgpuVecBuffer<Width>,
    pub(crate) item_count: u32,
    pub(crate) total_points: u32,
    pub(crate) compute_bind_group: Option<BindGroup>,
    pub(crate) render_bind_group: Option<BindGroup>,
}

Merged GPU buffers for all VItems in a frame.

Instead of one set of buffers per VItem, all data is packed into contiguous arrays with an index table (item_infos) that tells shaders where each item’s data lives.

Fields

item_infos_buffer: WgpuVecBuffer<ItemInfo>

Per-item metadata: offsets and counts

planes_buffer: WgpuVecBuffer<PlaneData>

Per-item plane data (normal + origin for vertex shader)

clip_boxes_buffer: WgpuVecBuffer<i32>

Per-item clip boxes (5 i32 each: min_x, max_x, min_y, max_y, max_w)

transforms_buffer: WgpuVecBuffer<VitemTransform>

Per-item local-to-world transforms

points3d_buffer: WgpuVecBuffer<Vec4>

Merged 3D points from all VItems

points2d_buffer: WgpuVecBuffer<Vec4>

Merged 2D projected points (written by compute shader)

fill_rgbas_buffer: WgpuVecBuffer<Rgba>

Merged fill colors

stroke_rgbas_buffer: WgpuVecBuffer<Rgba>

Merged stroke colors

stroke_widths_buffer: WgpuVecBuffer<Width>

Merged stroke widths

item_count: u32

Number of items

total_points: u32

Total number of points across all items

compute_bind_group: Option<BindGroup>

Compute bind group (recreated when buffers resize)

render_bind_group: Option<BindGroup>

Render bind group (recreated when buffers resize)

Implementations

impl VItemsBuffer

pub fn new(ctx: &WgpuContext) -> Self

pub fn update<'a, I>(&mut self, ctx: &WgpuContext, vitems: I)

where I: IntoIterator<Item = (f32, &'a VItem)>, I::IntoIter: ExactSizeIterator + Clone,

Pack all VItems into the merged buffers. Called once per frame.

pub fn item_count(&self) -> u32

pub fn total_points(&self) -> u32

pub fn compute_bind_group_layout(ctx: &WgpuContext) -> BindGroupLayout

pub fn render_bind_group_layout(ctx: &WgpuContext) -> BindGroupLayout

fn create_compute_bind_group(ctx: &WgpuContext, this: &Self) -> BindGroup

fn create_render_bind_group(ctx: &WgpuContext, this: &Self) -> BindGroup

Trait Implementations

impl Component for VItemsBuffer

where Self: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::SparseSet

A constant indicating the storage type used for this component.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have [Component<Mutability = Mutable>], while immutable components will instead have [Component<Mutability = Immutable>].

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn relationship_accessor() -> Option<ComponentRelationshipAccessor<Self>>

Returns [ComponentRelationshipAccessor] required for working with relationships in dynamic contexts.

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add [ComponentHook] for this [Component] if one is defined.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert [ComponentHook] for this [Component] if one is defined.

fn on_discard() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_discard [ComponentHook] for this [Component] if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove [ComponentHook] for this [Component] if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn [ComponentHook] for this [Component] if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given [EntityMapper]. This is used to remap entities in contexts like scenes and entity cloning. When deriving [Component], this is populated by annotating fields containing entities with #[entities]

impl Resource for VItemsBuffer

where Self: Send + Sync + 'static,