Struct LineOptions 

pub struct LineOptions {
    pub shader: Option<LineShader>,
    pub hard_edge: bool,
    pub depth_stencil: DepthStencilPolicy,
    pub blend: Option<BlendState>,
    pub write_mask: ColorWrites,
    pub a2c_hint: bool,
}

The policy a caller decides about a built-in line pipeline.

Everything a draw resolves is absent: the instance record, the render target and the device’s storage-buffer answer are facts a draw folds into an LineVariant when it composes a pipeline, not choices a caller can make. The target owns the color format, the sample count and whether there is a depth attachment at all; what is left is what a caller actually picks.

The zero value is the usual stroke: an antialiased edge blended over the frame, testing against the depth the pass holds without writing its own.

Fields

shader: Option<LineShader>

The entry shader this policy draws with, or None for the built-in line.wesl.

A caller’s snippets extend the built-in source and nothing else: the layouts, the instance record and the entry-point names stay the variant’s. See LineShader.

The shader takes part in equality and hashing whole, label included: two options whose shaders differ at all — a name among the differences — build two pipelines, which is the observable difference.

hard_edge: bool

Whether the fragment stage cuts a pixel whose coverage falls below one half instead of blending its partial colour.

An antialiased edge is a veil of partial pixels; a stroke that covers the frame, as an opaque one does, has no colour to veil the background with, so it cuts cleanly at the pixel it covers instead. The cut is a whole-pixel decision, so it works at any sample count — but on a multisampled target the pipeline drops the cut and leaves the edge to the samples: state a2c_hint to have the alpha turned into the sample mask, which smooths the edge the cut would jag. See LineVariant.

depth_stencil: DepthStencilPolicy

How the pipeline tests and writes the depth attachment, for a target that has one.

A target without a depth attachment runs the pipeline without a depth-stencil state at all, whatever this field says. The format is the attachment’s own, which the options cannot know: it is the target’s word, and the variant carries the target.

The default states the stroke convention: the comparison is the renderer’s reverse-z one, and a stroke writes its own depth, which is what lets strokes cover one another. A stroke that blends over the frame instead states the default with the write cleared, so it hides nothing behind it.

blend: Option<BlendState>

The blend state the fragment output composites with, or None to write it unblended.

The common stroke composites with the target’s alpha: the fragment’s coverage rides its alpha, so ALPHA_BLENDING is what makes an edge antialiased rather than jagged. A stroke under a caller’s own policy — an additive energy line, say — states its own.

write_mask: ColorWrites

Which color channels the pipeline writes to the target.

a2c_hint: bool

Whether the fragment’s alpha states coverage, on a multisampled target.

Alpha-to-coverage turns the fragment’s alpha into the sample mask, so an antialiased edge lands as partially covered samples instead of a blend. That is only honest when the alpha is coverage: a wash whose alpha is transparency, blended over the frame, would have its contribution squared — masked to a fraction of the samples and then blended by the same fraction again — so the hint defaults to off and a stroke states it when its alpha means coverage. Nothing happens on a single-sampled target, where there are no samples to spread over.

Implementations

impl LineOptions

pub const fn opaque() -> Self

A stroke that covers the frame: no blend, the depth written.

The cut at half coverage is what keeps its edge from veiling the background with a colour it does not own; see hard_edge. On a multisampled target the cut yields to alpha-to-coverage, which keeps the edge smooth there.

pub const fn blended() -> Self

A stroke blended over the frame, testing depth without writing it.

Trait Implementations

impl Clone for LineOptions

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LineOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for LineOptions

fn default() -> Self

A stroke blended over the frame, testing depth without writing it.

impl Eq for LineOptions

impl Hash for LineOptions

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for LineOptions

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for LineOptions