Struct AnsweredBuffers 

pub struct AnsweredBuffers<S, F> {
    pub images: S,
    pub answer: F,
    pub reads: Vec<(BufferRead, u32)>,
    pub queries: Vec<(u32, Option<u32>)>,
    /* private fields */
}

A read-only sampler combining image answers (for example super::AnsweredReads) with finite structured views. Successful structured reads retain both request and answer; failed reads stop with the request and reason. Image reads are delegated unchanged. Stores and atomics are refused, even if images could answer them. Buffer lengths come only from extents, never from an image sampler’s absent-view policy.

An undeclared structured view is an error. An element beyond a declared extent reads zero, D3D’s stated view rule, without calling answer. An invalid offset within an element is always refused. The executor may use Sampler::buffer_elements to resolve an out-of-range read before calling structured; queries records those extent requests, while reads records only the structured calls actually made, not a complete instruction trace. Lifted bounds guards can also read a valid element before masking its value away; the caller must answer every requested in-range word, not only the element it expects the final output to use.

Fields

images: S

The sampler that answers image reads.

answer: F

The function that answers each structured read.

reads: Vec<(BufferRead, u32)>

The structured reads made, each with the word answered.

queries: Vec<(u32, Option<u32>)>

The extent requests made: the slot and the element count answered, None for an undeclared view.

Implementations

impl<S, F> AnsweredBuffers<S, F>

pub fn new( images: S, extents: BTreeMap<u32, BufferExtent>, answer: F, ) -> Result<Self, String>

Combine images with the structured views extents declares, by slot. A stride that is zero or not a multiple of 4, or an extent whose word count does not fit 32 bits, is refused.

Trait Implementations

impl<S: Debug, F: Debug> Debug for AnsweredBuffers<S, F>

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

Formats the value using the given formatter.

impl<S: Sampler, F: FnMut(BufferRead) -> Result<u32, String>> Sampler for AnsweredBuffers<S, F>

fn sample(&mut self, request: Sample) -> Result<[f32; 4], String>

Answer a 2D Sample with the texel’s four lanes as floats, or an error that stops the evaluation.

fn load(&mut self, request: Load) -> Result<[u32; 4], String>

The texel’s four lanes as its view returns them: f32 bits for a float view, the integers for a uint or sint one.

fn sample_image( &mut self, request: ImageSample<u32>, ) -> Result<[f32; 4], String>

A sample of any texture: 1D, 3D or cube, with a texel offset, a gather or a comparison. A plain 2D sample (or a 2D array’s layer) goes to Sampler::sample; anything else is refused unless the sampler answers it.

fn load_image(&mut self, request: ImageLoad<u32>) -> Result<[u32; 4], String>

A texel load of any texture. A 2D or 3D one (or a 2D array’s layer) goes to Sampler::load.

fn query_image(&mut self, request: ImageQuery<u32>) -> Result<[u32; 4], String>

A texture’s size, level count, layer count or sample count.

fn structured( &mut self, slot: u32, element: u32, offset: u32, ) -> Result<u32, String>

The 32-bit word at byte offset of element element of the structured buffer at t<slot>.

fn buffer_elements(&mut self, slot: u32) -> Option<u32>

How many elements the buffer view at bind slot slot has, where the sampler knows. A program that reads past the end gets zeros (D3D’s rule) when this is stated; when it is not, no read is taken for out of range.

fn store(&mut self, request: Store) -> Result<(), String>

A store to an unordered-access view (Store): the lanes mask marks of value, at the address the program gives (a structured view’s lanes the consecutive words from the byte offset). Its effect is the caller’s: it reaches none of this evaluation’s outputs.

fn atomic_add(&mut self, request: AtomicAdd) -> Result<u32, String>

An atomic add (AtomicAdd); its result the word as it was before. The add itself is the caller’s effect.

fn atomic_image(&mut self, request: ImageAtomic<u32>) -> Result<u32, String>

An atomic operation on a texel of a single-channel 32-bit unordered-access texture; its result is the word as it was before.

fn store_image(&mut self, request: ImageStore<u32>) -> Result<(), String>

A write to an unordered-access texture; the plain form is Sampler::store.