Struct spirv_std::image::Image

source ·
#[repr(C)]
pub struct Image<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32> { /* private fields */ }
Expand description

An opaque image type. Corresponds to OpTypeImage.

You likely want to write this type using the crate::Image! macro helper, as the generic arguments here can get extremely verbose.

See SPIR-V OpTypeImage specification for the meaning of integer parameters.

Implementations§

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32> Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, { _ }, FORMAT, COMPONENTS>

source

pub fn fetch<I>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED> ) -> SampledType::SampleResult
where I: Integer,

Fetch a single texel with a sampler set at compile time

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const SAMPLED: u32, const COMPONENTS: u32> Image<SampledType, DIM, DEPTH, ARRAYED, { _ }, SAMPLED, FORMAT, COMPONENTS>

source

pub fn gather<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, component: u32 ) -> SampledType::Vec4
where Self: HasGather, F: Float,

Gathers the requested component from four texels.

source

pub fn sample<F>( &self, sampler: Sampler, coord: impl ImageCoordinate<F, DIM, ARRAYED> ) -> SampledType::SampleResult
where F: Float,

Sample texels at coord from the image using sampler.

source

pub fn sample_bias<F>( &self, sampler: Sampler, coord: impl ImageCoordinate<F, DIM, ARRAYED>, bias: f32 ) -> SampledType::SampleResult
where F: Float,

Sample texels at coord from the image using sampler, after adding the input bias to the implicit level of detail.

source

pub fn sample_by_lod<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, lod: f32 ) -> SampledType::SampleResult
where F: Float,

Fetch a single texel with a sampler set at compile time Sample the image at a coordinate by a lod

source

pub fn sample_by_gradient<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, gradient_dx: impl ImageCoordinate<F, DIM, { _ }>, gradient_dy: impl ImageCoordinate<F, DIM, { _ }> ) -> SampledType::SampleResult
where F: Float,

Sample the image based on a gradient formed by (dx, dy). Specifically, ([du/dx, dv/dx], [du/dy, dv/dy])

source

pub fn sample_depth_reference<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, depth_reference: f32 ) -> SampledType
where F: Float,

Sample the image’s depth reference

source

pub fn sample_depth_reference_by_lod<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, depth_reference: f32, lod: f32 ) -> SampledType
where F: Float,

Sample the image’s depth reference based on an explicit lod

source

pub fn sample_depth_reference_by_gradient<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, depth_reference: f32, gradient_dx: impl ImageCoordinate<F, DIM, { _ }>, gradient_dy: impl ImageCoordinate<F, DIM, { _ }> ) -> SampledType
where F: Float,

Sample the image’s depth reference based on a gradient formed by (dx, dy). Specifically, ([du/dx, dv/dx], [du/dy, dv/dy])

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32> Image<SampledType, DIM, DEPTH, { _ }, { _ }, SAMPLED, FORMAT, COMPONENTS>

source

pub fn sample_with_project_coordinate<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }> ) -> SampledType::SampleResult
where F: Float,

Sample the image with a project coordinate

source

pub fn sample_with_project_coordinate_by_lod<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, lod: f32 ) -> SampledType::Vec4
where F: Float,

Sample the image with a project coordinate by a lod

source

pub fn sample_with_project_coordinate_by_gradient<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, gradient_dx: impl ImageCoordinate<F, DIM, { _ }>, gradient_dy: impl ImageCoordinate<F, DIM, { _ }> ) -> SampledType::Vec4
where F: Float,

Sample the image with a project coordinate based on a gradient formed by (dx, dy). Specifically, ([du/dx, dv/dx], [du/dy, dv/dy])

source

pub fn sample_depth_reference_with_project_coordinate<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, depth_reference: f32 ) -> SampledType
where F: Float,

Sample the image’s depth reference with the project coordinate

source

pub fn sample_depth_reference_with_project_coordinate_by_lod<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, { _ }>, depth_reference: f32, lod: f32 ) -> SampledType
where F: Float,

Sample the image’s depth reference with the project coordinate based on an explicit lod

source

pub fn sample_depth_reference_with_project_coordinate_by_gradient<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, { _ }>, depth_reference: f32, gradient_dx: impl ImageCoordinate<F, DIM, { _ }>, gradient_dy: impl ImageCoordinate<F, DIM, { _ }> ) -> SampledType
where F: Float,

Sample the image’s depth reference with the project coordinate based on a gradient formed by (dx, dy). Specifically, ([du/dx, dv/dx], [du/dy, dv/dy])

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32> Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, { _ }, FORMAT, COMPONENTS>

source

pub fn read<I>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED> ) -> SampledType::SampleResult
where I: Integer,

Read a texel from an image without a sampler.

source

pub unsafe fn write<I, const N: usize>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED>, texels: impl Vector<SampledType, N> )
where I: Integer,

Write a texel to an image without a sampler.

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const COMPONENTS: u32> Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, { _ }, FORMAT, COMPONENTS>

source

pub fn read<I>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED> ) -> SampledType::SampleResult
where I: Integer,

Read a texel from an image without a sampler.

source

pub unsafe fn write<I, const N: usize>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED>, texels: impl Vector<SampledType, N> )
where I: Integer,

Write a texel to an image without a sampler.

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32> Image<SampledType, { _ }, DEPTH, ARRAYED, MULTISAMPLED, { _ }, FORMAT, COMPONENTS>

source

pub fn read_subpass<I>( &self, coordinate: impl ImageCoordinateSubpassData<I, ARRAYED> ) -> SampledType::SampleResult
where I: Integer,

Read a texel from subpass input attachment. Note: Vulkan only allows the read if the first two components of the coordinate are zero.

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32> Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source

pub fn query_levels(&self) -> u32
where Self: HasQueryLevels,

Query the number of mipmap levels.

source

pub fn query_lod( &self, sampler: Sampler, coord: impl ImageCoordinate<f32, DIM, { _ }> ) -> SampledType::Vec2
where Self: HasQueryLevels,

Query the mipmap level and the level of detail for a hypothetical sampling of Image at Coordinate using an implicit level of detail. The first component of the result contains the mipmap array layer. The second component of the result contains the implicit level of detail relative to the base level.

source

pub fn query_size<Size: ImageCoordinate<u32, DIM, ARRAYED> + Default>( &self ) -> Size
where Self: HasQuerySize,

Query the dimensions of Image, with no level of detail.

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32> Image<SampledType, DIM, DEPTH, ARRAYED, { _ }, SAMPLED, FORMAT, COMPONENTS>

source

pub fn query_size_lod<Size: ImageCoordinate<u32, DIM, ARRAYED> + Default>( &self, lod: u32 ) -> Size
where Self: HasQuerySizeLod,

Query the dimensions of Image, with no level of detail.

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const ARRAYED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32> Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, SAMPLED, FORMAT, COMPONENTS>

source

pub fn query_samples(&self) -> u32

Query the number of samples available per texel fetch in a multisample image.

Trait Implementations§

source§

impl<SampledType: Clone + SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32> Clone for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

fn clone( &self ) -> Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32, S> ImageWithMethods<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS, SampleParams<NoneTy, NoneTy, NoneTy, SomeTy<S>>> for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

fn gather_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, component: u32, params: SampleParams<NoneTy, NoneTy, NoneTy, SomeTy<S>> ) -> SampledType::Vec4
where Self: HasGather, F: Float,

Gathers the requested component from four texels.

source§

fn sample_with<F>( &self, sampler: Sampler, coord: impl ImageCoordinate<F, DIM, ARRAYED>, params: SampleParams<NoneTy, NoneTy, NoneTy, SomeTy<S>> ) -> SampledType::SampleResult
where F: Float,

Sample texels at coord from the image using sampler.

source§

fn sample_depth_reference_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, depth_reference: f32, params: SampleParams<NoneTy, NoneTy, NoneTy, SomeTy<S>> ) -> SampledType
where F: Float,

Sample the image’s depth reference

source§

fn sample_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, params: SampleParams<NoneTy, NoneTy, NoneTy, SomeTy<S>> ) -> SampledType::SampleResult
where F: Float,

Sample the image with a project coordinate

source§

fn sample_depth_reference_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, depth_reference: f32, params: SampleParams<NoneTy, NoneTy, NoneTy, SomeTy<S>> ) -> SampledType
where F: Float,

Sample the image’s depth reference with the project coordinate

source§

fn fetch_with<I>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED>, params: SampleParams<NoneTy, NoneTy, NoneTy, SomeTy<S>> ) -> SampledType::SampleResult
where I: Integer,

Fetch a single texel with a sampler set at compile time
source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32, G> ImageWithMethods<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS, SampleParams<NoneTy, NoneTy, SomeTy<(G, G)>, NoneTy>> for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

fn gather_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, component: u32, params: SampleParams<NoneTy, NoneTy, SomeTy<(G, G)>, NoneTy> ) -> SampledType::Vec4
where Self: HasGather, F: Float,

Gathers the requested component from four texels.

source§

fn sample_with<F>( &self, sampler: Sampler, coord: impl ImageCoordinate<F, DIM, ARRAYED>, params: SampleParams<NoneTy, NoneTy, SomeTy<(G, G)>, NoneTy> ) -> SampledType::SampleResult
where F: Float,

Sample texels at coord from the image using sampler.

source§

fn sample_depth_reference_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, depth_reference: f32, params: SampleParams<NoneTy, NoneTy, SomeTy<(G, G)>, NoneTy> ) -> SampledType
where F: Float,

Sample the image’s depth reference

source§

fn sample_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, params: SampleParams<NoneTy, NoneTy, SomeTy<(G, G)>, NoneTy> ) -> SampledType::SampleResult
where F: Float,

Sample the image with a project coordinate

source§

fn sample_depth_reference_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, depth_reference: f32, params: SampleParams<NoneTy, NoneTy, SomeTy<(G, G)>, NoneTy> ) -> SampledType
where F: Float,

Sample the image’s depth reference with the project coordinate

source§

fn fetch_with<I>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED>, params: SampleParams<NoneTy, NoneTy, SomeTy<(G, G)>, NoneTy> ) -> SampledType::SampleResult
where I: Integer,

Fetch a single texel with a sampler set at compile time
source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32, G, S> ImageWithMethods<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS, SampleParams<NoneTy, NoneTy, SomeTy<(G, G)>, SomeTy<S>>> for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

fn gather_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, component: u32, params: SampleParams<NoneTy, NoneTy, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType::Vec4
where Self: HasGather, F: Float,

Gathers the requested component from four texels.

source§

fn sample_with<F>( &self, sampler: Sampler, coord: impl ImageCoordinate<F, DIM, ARRAYED>, params: SampleParams<NoneTy, NoneTy, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType::SampleResult
where F: Float,

Sample texels at coord from the image using sampler.

source§

fn sample_depth_reference_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, depth_reference: f32, params: SampleParams<NoneTy, NoneTy, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType
where F: Float,

Sample the image’s depth reference

source§

fn sample_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, params: SampleParams<NoneTy, NoneTy, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType::SampleResult
where F: Float,

Sample the image with a project coordinate

source§

fn sample_depth_reference_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, depth_reference: f32, params: SampleParams<NoneTy, NoneTy, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType
where F: Float,

Sample the image’s depth reference with the project coordinate

source§

fn fetch_with<I>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED>, params: SampleParams<NoneTy, NoneTy, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType::SampleResult
where I: Integer,

Fetch a single texel with a sampler set at compile time
source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32, L> ImageWithMethods<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS, SampleParams<NoneTy, SomeTy<L>, NoneTy, NoneTy>> for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

fn gather_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, component: u32, params: SampleParams<NoneTy, SomeTy<L>, NoneTy, NoneTy> ) -> SampledType::Vec4
where Self: HasGather, F: Float,

Gathers the requested component from four texels.

source§

fn sample_with<F>( &self, sampler: Sampler, coord: impl ImageCoordinate<F, DIM, ARRAYED>, params: SampleParams<NoneTy, SomeTy<L>, NoneTy, NoneTy> ) -> SampledType::SampleResult
where F: Float,

Sample texels at coord from the image using sampler.

source§

fn sample_depth_reference_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, depth_reference: f32, params: SampleParams<NoneTy, SomeTy<L>, NoneTy, NoneTy> ) -> SampledType
where F: Float,

Sample the image’s depth reference

source§

fn sample_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, params: SampleParams<NoneTy, SomeTy<L>, NoneTy, NoneTy> ) -> SampledType::SampleResult
where F: Float,

Sample the image with a project coordinate

source§

fn sample_depth_reference_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, depth_reference: f32, params: SampleParams<NoneTy, SomeTy<L>, NoneTy, NoneTy> ) -> SampledType
where F: Float,

Sample the image’s depth reference with the project coordinate

source§

fn fetch_with<I>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED>, params: SampleParams<NoneTy, SomeTy<L>, NoneTy, NoneTy> ) -> SampledType::SampleResult
where I: Integer,

Fetch a single texel with a sampler set at compile time
source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32, L, S> ImageWithMethods<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS, SampleParams<NoneTy, SomeTy<L>, NoneTy, SomeTy<S>>> for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

fn gather_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, component: u32, params: SampleParams<NoneTy, SomeTy<L>, NoneTy, SomeTy<S>> ) -> SampledType::Vec4
where Self: HasGather, F: Float,

Gathers the requested component from four texels.

source§

fn sample_with<F>( &self, sampler: Sampler, coord: impl ImageCoordinate<F, DIM, ARRAYED>, params: SampleParams<NoneTy, SomeTy<L>, NoneTy, SomeTy<S>> ) -> SampledType::SampleResult
where F: Float,

Sample texels at coord from the image using sampler.

source§

fn sample_depth_reference_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, depth_reference: f32, params: SampleParams<NoneTy, SomeTy<L>, NoneTy, SomeTy<S>> ) -> SampledType
where F: Float,

Sample the image’s depth reference

source§

fn sample_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, params: SampleParams<NoneTy, SomeTy<L>, NoneTy, SomeTy<S>> ) -> SampledType::SampleResult
where F: Float,

Sample the image with a project coordinate

source§

fn sample_depth_reference_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, depth_reference: f32, params: SampleParams<NoneTy, SomeTy<L>, NoneTy, SomeTy<S>> ) -> SampledType
where F: Float,

Sample the image’s depth reference with the project coordinate

source§

fn fetch_with<I>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED>, params: SampleParams<NoneTy, SomeTy<L>, NoneTy, SomeTy<S>> ) -> SampledType::SampleResult
where I: Integer,

Fetch a single texel with a sampler set at compile time
source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32, L, G> ImageWithMethods<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS, SampleParams<NoneTy, SomeTy<L>, SomeTy<(G, G)>, NoneTy>> for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

fn gather_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, component: u32, params: SampleParams<NoneTy, SomeTy<L>, SomeTy<(G, G)>, NoneTy> ) -> SampledType::Vec4
where Self: HasGather, F: Float,

Gathers the requested component from four texels.

source§

fn sample_with<F>( &self, sampler: Sampler, coord: impl ImageCoordinate<F, DIM, ARRAYED>, params: SampleParams<NoneTy, SomeTy<L>, SomeTy<(G, G)>, NoneTy> ) -> SampledType::SampleResult
where F: Float,

Sample texels at coord from the image using sampler.

source§

fn sample_depth_reference_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, depth_reference: f32, params: SampleParams<NoneTy, SomeTy<L>, SomeTy<(G, G)>, NoneTy> ) -> SampledType
where F: Float,

Sample the image’s depth reference

source§

fn sample_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, params: SampleParams<NoneTy, SomeTy<L>, SomeTy<(G, G)>, NoneTy> ) -> SampledType::SampleResult
where F: Float,

Sample the image with a project coordinate

source§

fn sample_depth_reference_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, depth_reference: f32, params: SampleParams<NoneTy, SomeTy<L>, SomeTy<(G, G)>, NoneTy> ) -> SampledType
where F: Float,

Sample the image’s depth reference with the project coordinate

source§

fn fetch_with<I>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED>, params: SampleParams<NoneTy, SomeTy<L>, SomeTy<(G, G)>, NoneTy> ) -> SampledType::SampleResult
where I: Integer,

Fetch a single texel with a sampler set at compile time
source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32, L, G, S> ImageWithMethods<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS, SampleParams<NoneTy, SomeTy<L>, SomeTy<(G, G)>, SomeTy<S>>> for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

fn gather_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, component: u32, params: SampleParams<NoneTy, SomeTy<L>, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType::Vec4
where Self: HasGather, F: Float,

Gathers the requested component from four texels.

source§

fn sample_with<F>( &self, sampler: Sampler, coord: impl ImageCoordinate<F, DIM, ARRAYED>, params: SampleParams<NoneTy, SomeTy<L>, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType::SampleResult
where F: Float,

Sample texels at coord from the image using sampler.

source§

fn sample_depth_reference_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, depth_reference: f32, params: SampleParams<NoneTy, SomeTy<L>, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType
where F: Float,

Sample the image’s depth reference

source§

fn sample_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, params: SampleParams<NoneTy, SomeTy<L>, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType::SampleResult
where F: Float,

Sample the image with a project coordinate

source§

fn sample_depth_reference_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, depth_reference: f32, params: SampleParams<NoneTy, SomeTy<L>, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType
where F: Float,

Sample the image’s depth reference with the project coordinate

source§

fn fetch_with<I>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED>, params: SampleParams<NoneTy, SomeTy<L>, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType::SampleResult
where I: Integer,

Fetch a single texel with a sampler set at compile time
source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32, B> ImageWithMethods<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS, SampleParams<SomeTy<B>, NoneTy, NoneTy, NoneTy>> for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

fn gather_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, component: u32, params: SampleParams<SomeTy<B>, NoneTy, NoneTy, NoneTy> ) -> SampledType::Vec4
where Self: HasGather, F: Float,

Gathers the requested component from four texels.

source§

fn sample_with<F>( &self, sampler: Sampler, coord: impl ImageCoordinate<F, DIM, ARRAYED>, params: SampleParams<SomeTy<B>, NoneTy, NoneTy, NoneTy> ) -> SampledType::SampleResult
where F: Float,

Sample texels at coord from the image using sampler.

source§

fn sample_depth_reference_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, depth_reference: f32, params: SampleParams<SomeTy<B>, NoneTy, NoneTy, NoneTy> ) -> SampledType
where F: Float,

Sample the image’s depth reference

source§

fn sample_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, params: SampleParams<SomeTy<B>, NoneTy, NoneTy, NoneTy> ) -> SampledType::SampleResult
where F: Float,

Sample the image with a project coordinate

source§

fn sample_depth_reference_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, depth_reference: f32, params: SampleParams<SomeTy<B>, NoneTy, NoneTy, NoneTy> ) -> SampledType
where F: Float,

Sample the image’s depth reference with the project coordinate

source§

fn fetch_with<I>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED>, params: SampleParams<SomeTy<B>, NoneTy, NoneTy, NoneTy> ) -> SampledType::SampleResult
where I: Integer,

Fetch a single texel with a sampler set at compile time
source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32, B, S> ImageWithMethods<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS, SampleParams<SomeTy<B>, NoneTy, NoneTy, SomeTy<S>>> for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

fn gather_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, component: u32, params: SampleParams<SomeTy<B>, NoneTy, NoneTy, SomeTy<S>> ) -> SampledType::Vec4
where Self: HasGather, F: Float,

Gathers the requested component from four texels.

source§

fn sample_with<F>( &self, sampler: Sampler, coord: impl ImageCoordinate<F, DIM, ARRAYED>, params: SampleParams<SomeTy<B>, NoneTy, NoneTy, SomeTy<S>> ) -> SampledType::SampleResult
where F: Float,

Sample texels at coord from the image using sampler.

source§

fn sample_depth_reference_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, depth_reference: f32, params: SampleParams<SomeTy<B>, NoneTy, NoneTy, SomeTy<S>> ) -> SampledType
where F: Float,

Sample the image’s depth reference

source§

fn sample_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, params: SampleParams<SomeTy<B>, NoneTy, NoneTy, SomeTy<S>> ) -> SampledType::SampleResult
where F: Float,

Sample the image with a project coordinate

source§

fn sample_depth_reference_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, depth_reference: f32, params: SampleParams<SomeTy<B>, NoneTy, NoneTy, SomeTy<S>> ) -> SampledType
where F: Float,

Sample the image’s depth reference with the project coordinate

source§

fn fetch_with<I>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED>, params: SampleParams<SomeTy<B>, NoneTy, NoneTy, SomeTy<S>> ) -> SampledType::SampleResult
where I: Integer,

Fetch a single texel with a sampler set at compile time
source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32, B, G> ImageWithMethods<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS, SampleParams<SomeTy<B>, NoneTy, SomeTy<(G, G)>, NoneTy>> for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

fn gather_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, component: u32, params: SampleParams<SomeTy<B>, NoneTy, SomeTy<(G, G)>, NoneTy> ) -> SampledType::Vec4
where Self: HasGather, F: Float,

Gathers the requested component from four texels.

source§

fn sample_with<F>( &self, sampler: Sampler, coord: impl ImageCoordinate<F, DIM, ARRAYED>, params: SampleParams<SomeTy<B>, NoneTy, SomeTy<(G, G)>, NoneTy> ) -> SampledType::SampleResult
where F: Float,

Sample texels at coord from the image using sampler.

source§

fn sample_depth_reference_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, depth_reference: f32, params: SampleParams<SomeTy<B>, NoneTy, SomeTy<(G, G)>, NoneTy> ) -> SampledType
where F: Float,

Sample the image’s depth reference

source§

fn sample_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, params: SampleParams<SomeTy<B>, NoneTy, SomeTy<(G, G)>, NoneTy> ) -> SampledType::SampleResult
where F: Float,

Sample the image with a project coordinate

source§

fn sample_depth_reference_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, depth_reference: f32, params: SampleParams<SomeTy<B>, NoneTy, SomeTy<(G, G)>, NoneTy> ) -> SampledType
where F: Float,

Sample the image’s depth reference with the project coordinate

source§

fn fetch_with<I>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED>, params: SampleParams<SomeTy<B>, NoneTy, SomeTy<(G, G)>, NoneTy> ) -> SampledType::SampleResult
where I: Integer,

Fetch a single texel with a sampler set at compile time
source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32, B, G, S> ImageWithMethods<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS, SampleParams<SomeTy<B>, NoneTy, SomeTy<(G, G)>, SomeTy<S>>> for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

fn gather_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, component: u32, params: SampleParams<SomeTy<B>, NoneTy, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType::Vec4
where Self: HasGather, F: Float,

Gathers the requested component from four texels.

source§

fn sample_with<F>( &self, sampler: Sampler, coord: impl ImageCoordinate<F, DIM, ARRAYED>, params: SampleParams<SomeTy<B>, NoneTy, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType::SampleResult
where F: Float,

Sample texels at coord from the image using sampler.

source§

fn sample_depth_reference_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, depth_reference: f32, params: SampleParams<SomeTy<B>, NoneTy, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType
where F: Float,

Sample the image’s depth reference

source§

fn sample_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, params: SampleParams<SomeTy<B>, NoneTy, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType::SampleResult
where F: Float,

Sample the image with a project coordinate

source§

fn sample_depth_reference_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, depth_reference: f32, params: SampleParams<SomeTy<B>, NoneTy, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType
where F: Float,

Sample the image’s depth reference with the project coordinate

source§

fn fetch_with<I>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED>, params: SampleParams<SomeTy<B>, NoneTy, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType::SampleResult
where I: Integer,

Fetch a single texel with a sampler set at compile time
source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32, B, L> ImageWithMethods<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS, SampleParams<SomeTy<B>, SomeTy<L>, NoneTy, NoneTy>> for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

fn gather_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, component: u32, params: SampleParams<SomeTy<B>, SomeTy<L>, NoneTy, NoneTy> ) -> SampledType::Vec4
where Self: HasGather, F: Float,

Gathers the requested component from four texels.

source§

fn sample_with<F>( &self, sampler: Sampler, coord: impl ImageCoordinate<F, DIM, ARRAYED>, params: SampleParams<SomeTy<B>, SomeTy<L>, NoneTy, NoneTy> ) -> SampledType::SampleResult
where F: Float,

Sample texels at coord from the image using sampler.

source§

fn sample_depth_reference_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, depth_reference: f32, params: SampleParams<SomeTy<B>, SomeTy<L>, NoneTy, NoneTy> ) -> SampledType
where F: Float,

Sample the image’s depth reference

source§

fn sample_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, params: SampleParams<SomeTy<B>, SomeTy<L>, NoneTy, NoneTy> ) -> SampledType::SampleResult
where F: Float,

Sample the image with a project coordinate

source§

fn sample_depth_reference_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, depth_reference: f32, params: SampleParams<SomeTy<B>, SomeTy<L>, NoneTy, NoneTy> ) -> SampledType
where F: Float,

Sample the image’s depth reference with the project coordinate

source§

fn fetch_with<I>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED>, params: SampleParams<SomeTy<B>, SomeTy<L>, NoneTy, NoneTy> ) -> SampledType::SampleResult
where I: Integer,

Fetch a single texel with a sampler set at compile time
source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32, B, L, S> ImageWithMethods<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS, SampleParams<SomeTy<B>, SomeTy<L>, NoneTy, SomeTy<S>>> for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

fn gather_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, component: u32, params: SampleParams<SomeTy<B>, SomeTy<L>, NoneTy, SomeTy<S>> ) -> SampledType::Vec4
where Self: HasGather, F: Float,

Gathers the requested component from four texels.

source§

fn sample_with<F>( &self, sampler: Sampler, coord: impl ImageCoordinate<F, DIM, ARRAYED>, params: SampleParams<SomeTy<B>, SomeTy<L>, NoneTy, SomeTy<S>> ) -> SampledType::SampleResult
where F: Float,

Sample texels at coord from the image using sampler.

source§

fn sample_depth_reference_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, depth_reference: f32, params: SampleParams<SomeTy<B>, SomeTy<L>, NoneTy, SomeTy<S>> ) -> SampledType
where F: Float,

Sample the image’s depth reference

source§

fn sample_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, params: SampleParams<SomeTy<B>, SomeTy<L>, NoneTy, SomeTy<S>> ) -> SampledType::SampleResult
where F: Float,

Sample the image with a project coordinate

source§

fn sample_depth_reference_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, depth_reference: f32, params: SampleParams<SomeTy<B>, SomeTy<L>, NoneTy, SomeTy<S>> ) -> SampledType
where F: Float,

Sample the image’s depth reference with the project coordinate

source§

fn fetch_with<I>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED>, params: SampleParams<SomeTy<B>, SomeTy<L>, NoneTy, SomeTy<S>> ) -> SampledType::SampleResult
where I: Integer,

Fetch a single texel with a sampler set at compile time
source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32, B, L, G> ImageWithMethods<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS, SampleParams<SomeTy<B>, SomeTy<L>, SomeTy<(G, G)>, NoneTy>> for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

fn gather_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, component: u32, params: SampleParams<SomeTy<B>, SomeTy<L>, SomeTy<(G, G)>, NoneTy> ) -> SampledType::Vec4
where Self: HasGather, F: Float,

Gathers the requested component from four texels.

source§

fn sample_with<F>( &self, sampler: Sampler, coord: impl ImageCoordinate<F, DIM, ARRAYED>, params: SampleParams<SomeTy<B>, SomeTy<L>, SomeTy<(G, G)>, NoneTy> ) -> SampledType::SampleResult
where F: Float,

Sample texels at coord from the image using sampler.

source§

fn sample_depth_reference_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, depth_reference: f32, params: SampleParams<SomeTy<B>, SomeTy<L>, SomeTy<(G, G)>, NoneTy> ) -> SampledType
where F: Float,

Sample the image’s depth reference

source§

fn sample_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, params: SampleParams<SomeTy<B>, SomeTy<L>, SomeTy<(G, G)>, NoneTy> ) -> SampledType::SampleResult
where F: Float,

Sample the image with a project coordinate

source§

fn sample_depth_reference_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, depth_reference: f32, params: SampleParams<SomeTy<B>, SomeTy<L>, SomeTy<(G, G)>, NoneTy> ) -> SampledType
where F: Float,

Sample the image’s depth reference with the project coordinate

source§

fn fetch_with<I>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED>, params: SampleParams<SomeTy<B>, SomeTy<L>, SomeTy<(G, G)>, NoneTy> ) -> SampledType::SampleResult
where I: Integer,

Fetch a single texel with a sampler set at compile time
source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32, B, L, G, S> ImageWithMethods<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS, SampleParams<SomeTy<B>, SomeTy<L>, SomeTy<(G, G)>, SomeTy<S>>> for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

fn gather_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, component: u32, params: SampleParams<SomeTy<B>, SomeTy<L>, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType::Vec4
where Self: HasGather, F: Float,

Gathers the requested component from four texels.

source§

fn sample_with<F>( &self, sampler: Sampler, coord: impl ImageCoordinate<F, DIM, ARRAYED>, params: SampleParams<SomeTy<B>, SomeTy<L>, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType::SampleResult
where F: Float,

Sample texels at coord from the image using sampler.

source§

fn sample_depth_reference_with<F>( &self, sampler: Sampler, coordinate: impl ImageCoordinate<F, DIM, ARRAYED>, depth_reference: f32, params: SampleParams<SomeTy<B>, SomeTy<L>, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType
where F: Float,

Sample the image’s depth reference

source§

fn sample_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, params: SampleParams<SomeTy<B>, SomeTy<L>, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType::SampleResult
where F: Float,

Sample the image with a project coordinate

source§

fn sample_depth_reference_with_project_coordinate_with<F>( &self, sampler: Sampler, project_coordinate: impl ImageCoordinate<F, DIM, { _ }>, depth_reference: f32, params: SampleParams<SomeTy<B>, SomeTy<L>, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType
where F: Float,

Sample the image’s depth reference with the project coordinate

source§

fn fetch_with<I>( &self, coordinate: impl ImageCoordinate<I, DIM, ARRAYED>, params: SampleParams<SomeTy<B>, SomeTy<L>, SomeTy<(G, G)>, SomeTy<S>> ) -> SampledType::SampleResult
where I: Integer,

Fetch a single texel with a sampler set at compile time
source§

impl<SampledType: Copy + SampleType<FORMAT, COMPONENTS>, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32> Copy for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const SAMPLED: u32, const COMPONENTS: u32> HasGather for Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, SAMPLED, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const SAMPLED: u32, const COMPONENTS: u32> HasGather for Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, SAMPLED, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const SAMPLED: u32, const COMPONENTS: u32> HasGather for Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, SAMPLED, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const COMPONENTS: u32> HasQueryLevels for Image<SampledType, { _ }, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const COMPONENTS: u32> HasQueryLevels for Image<SampledType, { _ }, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const COMPONENTS: u32> HasQueryLevels for Image<SampledType, { _ }, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const COMPONENTS: u32> HasQueryLevels for Image<SampledType, { _ }, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const COMPONENTS: u32> HasQuerySize for Image<SampledType, { _ }, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const COMPONENTS: u32> HasQuerySize for Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, { _ }, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const COMPONENTS: u32> HasQuerySize for Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, { _ }, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const SAMPLED: u32, const COMPONENTS: u32> HasQuerySize for Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, SAMPLED, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const COMPONENTS: u32> HasQuerySize for Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, { _ }, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const COMPONENTS: u32> HasQuerySize for Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, { _ }, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const SAMPLED: u32, const COMPONENTS: u32> HasQuerySize for Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, SAMPLED, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const COMPONENTS: u32> HasQuerySize for Image<SampledType, { _ }, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const COMPONENTS: u32> HasQuerySize for Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, { _ }, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const COMPONENTS: u32> HasQuerySize for Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, { _ }, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const SAMPLED: u32, const COMPONENTS: u32> HasQuerySize for Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, SAMPLED, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const COMPONENTS: u32> HasQuerySize for Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, { _ }, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const COMPONENTS: u32> HasQuerySize for Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, { _ }, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const SAMPLED: u32, const COMPONENTS: u32> HasQuerySize for Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, SAMPLED, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const SAMPLED: u32, const COMPONENTS: u32> HasQuerySizeLod for Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, SAMPLED, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const SAMPLED: u32, const COMPONENTS: u32> HasQuerySizeLod for Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, SAMPLED, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const SAMPLED: u32, const COMPONENTS: u32> HasQuerySizeLod for Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, SAMPLED, FORMAT, COMPONENTS>

source§

impl<SampledType: SampleType<FORMAT, COMPONENTS>, const DEPTH: u32, const FORMAT: u32, const ARRAYED: u32, const SAMPLED: u32, const COMPONENTS: u32> HasQuerySizeLod for Image<SampledType, { _ }, DEPTH, ARRAYED, { _ }, SAMPLED, FORMAT, COMPONENTS>

Auto Trait Implementations§

§

impl<SampledType, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32> Freeze for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>

§

impl<SampledType, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32> RefUnwindSafe for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>
where SampledType: RefUnwindSafe,

§

impl<SampledType, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32> Send for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>
where SampledType: Send,

§

impl<SampledType, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32> Sync for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>
where SampledType: Sync,

§

impl<SampledType, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32> Unpin for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>
where SampledType: Unpin,

§

impl<SampledType, const DIM: u32, const DEPTH: u32, const ARRAYED: u32, const MULTISAMPLED: u32, const SAMPLED: u32, const FORMAT: u32, const COMPONENTS: u32> UnwindSafe for Image<SampledType, DIM, DEPTH, ARRAYED, MULTISAMPLED, SAMPLED, FORMAT, COMPONENTS>
where SampledType: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.