Struct CompositeUniforms 

pub struct CompositeUniforms {
    pub model: Mat4,
    pub clip_min: Vec2,
    pub clip_max: Vec2,
    pub edge_feather: f32,
    pub pad_a: f32,
    pub pad_b: Vec2,
    pub radius: Vec4,
    pub box_center: Vec2,
    pub box_size: Vec2,
}

Per-quad composite params. Field order matches CompositeParams in composite.wgsl byte for byte (128 bytes; guarded by composite_uniforms_match_the_documented_wgsl_layout). Pad names are digit-free on purpose (the naga-namer constraint, see FilterUniforms).

Fields

model: Mat4

Screen-space model matrix (physical px, homogeneous — the vertex stage keeps the real w for perspective-correct interpolation and flattens z post-transform). Identity for untransformed layers.

clip_min: Vec2

Screen-space ancestor-clip rect the fragment stage tests transformed quads against (open_clip sentinel = unclipped / already CPU-clamped).

clip_max: Vec2

edge_feather: f32

Edge-feather width in screen px for the analytic edge AA of transformed quads (their diagonal silhouettes rasterize without MSAA). 0.0 disables the coverage term entirely — the untransformed path, which must stay pixel-identical (its CPU-clamped UVs sit inside [0,1] at clipped edges, where uv-distance feathering would be wrong).

pad_a: f32

pad_b: Vec2

radius: Vec4

Rounded-corner mask radii, [top_left, top_right, bottom_right, bottom_left] physical px — the node’s layout-resolved ComputedNode.border_radius (already clamped per corner to 0.5 * min(w, h); Bevy’s rule, not the CSS proportional-shrink one — matching what bevy_ui paints is the point: the frost edge must coincide with the node’s own rounded background). All-zero disables the mask term entirely (the edge_feather pattern) — today only backdrop quads set it.

box_center: Vec2

The UNCLIPPED border box the radii round, screen-space physical px. Carried separately because the CPU clip clamps the quad’s geometry — the SDF must still measure against the true box.

box_size: Vec2

Trait Implementations

impl Clone for CompositeUniforms

fn clone(&self) -> CompositeUniforms

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for CompositeUniforms

impl CreateFrom for CompositeUniforms

where Self: ShaderType<ExtraMetadata = StructMetadata<9usize>>, for<'__> Mat4: CreateFrom, for<'__, '__, '__, '__, '__> Vec2: CreateFrom, for<'__, '__> f32: CreateFrom, for<'__> Vec4: CreateFrom,

fn create_from<B: BufferRef>(reader: &mut Reader<B>) -> Self

impl ReadFrom for CompositeUniforms

where Self: ShaderType<ExtraMetadata = StructMetadata<9usize>>, for<'__> Mat4: ReadFrom, for<'__, '__, '__, '__, '__> Vec2: ReadFrom, for<'__, '__> f32: ReadFrom, for<'__> Vec4: ReadFrom,

fn read_from<B: BufferRef>(&mut self, reader: &mut Reader<B>)

impl ShaderSize for CompositeUniforms

where Mat4: ShaderSize, Vec2: ShaderSize, f32: ShaderSize, Vec4: ShaderSize,

const SHADER_SIZE: NonZero<u64> = _

Represents WGSL Size (equivalent to ShaderType::min_size)

impl ShaderType for CompositeUniforms

where Mat4: ShaderType + ShaderSize, Vec2: ShaderType + ShaderSize, f32: ShaderType + ShaderSize, Vec4: ShaderType + ShaderSize,

fn size(&self) -> NonZeroU64

Returns the size of Self at runtime

fn min_size() -> NonZero<u64>

Represents the minimum size of Self (equivalent to GPUBufferBindingLayout.minBindingSize)

fn assert_uniform_compat()

Asserts that Self meets the requirements of the uniform address space restrictions on stored values and the uniform address space layout constraints

impl WriteInto for CompositeUniforms

where Self: ShaderType<ExtraMetadata = StructMetadata<9usize>>, for<'__> Mat4: WriteInto, for<'__, '__, '__, '__, '__> Vec2: WriteInto, for<'__, '__> f32: WriteInto, for<'__> Vec4: WriteInto,

fn write_into<B: BufferMut>(&self, writer: &mut Writer<B>)