A texture is a data aggregate on an accelerator_view in the extent domain. It is a collection of variables, one for each element in an extent domain. Each variable holds a value corresponding to C++ primitive type (unsigned int, int, float, double), or scalar type norm, or unorm (defined in concurrency::graphics), or eligible short vector types defined in concurrency::graphics. More...

#include <amp_graphics.h>

Inheritance diagram for Concurrency::graphics::texture< _Value_type, _Rank >:

Public Member Functions
	texture (const Concurrency::extent< _Rank > &_Ext) __CPU_ONLY
	Construct a texture from extents. More...

	texture (int _E0) __CPU_ONLY
	Construct texture<T,1> with the extent _E0 More...

	texture (int _E0, int _E1) __CPU_ONLY
	Construct a texture<T,2> from two integer extents. More...

	texture (int _E0, int _E1, int _E2) __CPU_ONLY
	Construct a texture<T,3> from three integer extents. More...

	texture (const Concurrency::extent< _Rank > &_Ext, const Concurrency::accelerator_view &_Av) __CPU_ONLY
	Construct a texture from extents, bound to a specific accelerator_view. More...

	texture (const Concurrency::extent< _Rank > &_Ext, const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av) __CPU_ONLY
	Construct a staging texture from extents, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture. More...

	texture (int _E0, const Concurrency::accelerator_view &_Av) __CPU_ONLY
	Construct a texture<T,1> with the extent _E0, bound to a specific accelerator_view. More...

	texture (int _E0, const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av) __CPU_ONLY
	Construct a staging texture<T,1> with the extent _E0, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture. More...

	texture (int _E0, int _E1, const Concurrency::accelerator_view &_Av) __CPU_ONLY
	Construct a texture<T,2> from two integer extents, bound to a specific accelerator_view. More...

	texture (int _E0, int _E1, const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av) __CPU_ONLY
	Construct a staging texture<T,2> from two integer extents, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture. More...

	texture (int _E0, int _E1, int _E2, const Concurrency::accelerator_view &_Av) __CPU_ONLY
	Construct a texture<T,3> from three integer extents, bound to a specific accelerator_view. More...

	texture (int _E0, int _E1, int _E2, const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av) __CPU_ONLY
	Construct a staging texture<T,3> from three integer extents, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture. More...

template<typename _Input_iterator >
	texture (const Concurrency::extent< _Rank > &_Ext, _Input_iterator _Src_first, _Input_iterator _Src_last) __CPU_ONLY
	Construct a texture initialized from a pair of iterators into a container. More...

template<typename _Input_iterator >
	texture (int _E0, _Input_iterator _Src_first, _Input_iterator _Src_last) __CPU_ONLY
	Construct a texture<T,1> with the extent _E0 and from a pair of iterators into a container. More...

template<typename _Input_iterator >
	texture (int _E0, int _E1, _Input_iterator _Src_first, _Input_iterator _Src_last) __CPU_ONLY
	Construct a texture<T,2> with two integers and initialized from a pair of iterators into a container. More...

template<typename _Input_iterator >
	texture (int _E0, int _E1, int _E2, _Input_iterator _Src_first, _Input_iterator _Src_last) __CPU_ONLY
	Construct a texture<T,3> with three integers and initialized from a pair of iterators into a container. More...

template<typename _Input_iterator >
	texture (const Concurrency::extent< _Rank > &_Ext, _Input_iterator _Src_first, _Input_iterator _Src_last, const Concurrency::accelerator_view &_Av) __CPU_ONLY
	Construct a texture initialized from a pair of iterators into a container, bound to a specific accelerator_view. More...

template<typename _Input_iterator >
	texture (const Concurrency::extent< _Rank > &_Ext, _Input_iterator _Src_first, _Input_iterator _Src_last, const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av) __CPU_ONLY
	Construct a staging texture initialized from a pair of iterators into a container, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture. More...

template<typename _Input_iterator >
	texture (int _E0, _Input_iterator _Src_first, _Input_iterator _Src_last, const Concurrency::accelerator_view &_Av) __CPU_ONLY
	Construct a texture<T,1> with integer _E0 and initialized from a pair of iterators into a container, bound to a specific accelerator_view. More...

template<typename _Input_iterator >
	texture (int _E0, _Input_iterator _Src_first, _Input_iterator _Src_last, const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av) __CPU_ONLY
	Construct a staging texture<T,1> with integer _E0 and initialized from a pair of iterators into a container, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture. More...

template<typename _Input_iterator >
	texture (int _E0, int _E1, _Input_iterator _Src_first, _Input_iterator _Src_last, const Concurrency::accelerator_view &_Av) __CPU_ONLY
	Construct a texture<T,2> with two integers and initialized from a pair of iterators into a container, bound to a specific accelerator_view. More...

template<typename _Input_iterator >
	texture (int _E0, int _E1, _Input_iterator _Src_first, _Input_iterator _Src_last, const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av) __CPU_ONLY
	Construct a staging texture<T,2> with two integers and initialized from a pair of iterators into a container, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture. More...

template<typename _Input_iterator >
	texture (int _E0, int _E1, int _E2, _Input_iterator _Src_first, _Input_iterator _Src_last, const Concurrency::accelerator_view &_Av) __CPU_ONLY
	Construct a texture<T,3> with three integers and initialized from a pair of iterators into a container, bound to a specific accelerator_view. More...

template<typename _Input_iterator >
	texture (int _E0, int _E1, int _E2, _Input_iterator _Src_first, _Input_iterator _Src_last, const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av) __CPU_ONLY
	Construct a staging texture<T,3> with three integers and initialized from a pair of iterators into a container, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture. More...

	texture (const Concurrency::extent< _Rank > &_Ext, unsigned int _Bits_per_scalar_element) __CPU_ONLY
	Construct a texture from extents and specified bits per scalar element More...

	texture (const Concurrency::extent< _Rank > &_Ext, unsigned int _Bits_per_scalar_element, unsigned int _Mipmap_levels) __CPU_ONLY
	Construct a texture from extents, specified bits per scalar element and number of mipmap levels More...

	texture (int _E0, unsigned int _Bits_per_scalar_element) __CPU_ONLY
	Construct a texture<T,1> with integer _E0 and specified bits per scalar element More...

	texture (int _E0, int _E1, unsigned int _Bits_per_scalar_element) __CPU_ONLY
	Construct a texture<T,2> with two integers and specified bits per scalar element More...

	texture (int _E0, int _E1, int _E2, unsigned int _Bits_per_scalar_element) __CPU_ONLY
	Construct a texture<T,3> with three integers and specified bits per scalar element More...

	texture (const Concurrency::extent< _Rank > &_Ext, unsigned int _Bits_per_scalar_element, const Concurrency::accelerator_view &_Av) __CPU_ONLY
	Construct a texture from extents and specified bits per scalar element, bound to a specific accelerator_view. More...

	texture (const Concurrency::extent< _Rank > &_Ext, unsigned int _Bits_per_scalar_element, unsigned int _Mipmap_levels, const Concurrency::accelerator_view &_Av) __CPU_ONLY
	Construct a texture from extents, specified bits per scalar element and number of mipmap levels More...

	texture (const Concurrency::extent< _Rank > &_Ext, unsigned int _Bits_per_scalar_element, const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av) __CPU_ONLY
	Construct a staging texture from extents and specified bits per scalar element, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture. More...

	texture (int _E0, unsigned int _Bits_per_scalar_element, const Concurrency::accelerator_view &_Av) __CPU_ONLY
	Construct a texture<T, 1> with integer _E0 and specified bits per scalar element, bound to a specific accelerator. More...

	texture (int _E0, unsigned int _Bits_per_scalar_element, const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av) __CPU_ONLY
	Construct a staging texture<T, 1> with integer _E0 and specified bits per scalar element, bound to a specific accelerator and an associated accelerator_view that is the preferred location for copying to/from this texture. More...

	texture (int _E0, int _E1, unsigned int _Bits_per_scalar_element, const Concurrency::accelerator_view &_Av) __CPU_ONLY
	Construct a texture<T,2> with two integers and specified bits per scalar element, bound to a specific accelerator. More...

	texture (int _E0, int _E1, unsigned int _Bits_per_scalar_element, const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av) __CPU_ONLY
	Construct a staging texture<T,2> with two integers and specified bits per scalar element, bound to a specific accelerator and an associated accelerator_view that is the preferred location for copying to/from this texture. More...

	texture (int _E0, int _E1, int _E2, unsigned int _Bits_per_scalar_element, const Concurrency::accelerator_view &_Av) __CPU_ONLY
	Construct a texture<T,3> with three integers and specified bits per scalar element, bound to a specific accelerator. More...

	texture (int _E0, int _E1, int _E2, unsigned int _Bits_per_scalar_element, const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av) __CPU_ONLY
	Construct a staging texture<T,3> with three integers and specified bits per scalar element, bound to a specific accelerator and an associated accelerator_view that is the preferred location for copying to/from this texture. More...

	texture (const Concurrency::extent< _Rank > &_Ext, const void *_Source, unsigned int _Src_byte_size, unsigned int _Bits_per_scalar_element) __CPU_ONLY
	Construct a texture from extents and specified bits per scalar element, initialized from a host buffer. More...

	texture (int _E0, const void *_Source, unsigned int _Src_byte_size, unsigned int _Bits_per_scalar_element) __CPU_ONLY
	Construct a texture<T,1> with integer _E0 and specified bits per scalar element, initialized from a host buffer. More...

	texture (int _E0, int _E1, const void *_Source, unsigned int _Src_byte_size, unsigned int _Bits_per_scalar_element) __CPU_ONLY
	Construct a texture<T,2> with two integers and specified bits per scalar element, initialized from a host buffer. More...

	texture (int _E0, int _E1, int _E2, const void *_Source, unsigned int _Src_byte_size, unsigned int _Bits_per_scalar_element) __CPU_ONLY
	Construct a texture<T,3> with three integers and specified bits per scalar element, initialized from a host buffer. More...

	texture (const Concurrency::extent< _Rank > &_Ext, const void *_Source, unsigned int _Src_byte_size, unsigned int _Bits_per_scalar_element, const Concurrency::accelerator_view &_Av) __CPU_ONLY
	Construct a texture from extents and specified bits per scalar element, initialized from a host buffer, bound to a specific accelerator_view. More...

	texture (const Concurrency::extent< _Rank > &_Ext, const void *_Source, unsigned int _Src_byte_size, unsigned int _Bits_per_scalar_element, const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av) __CPU_ONLY
	Construct a staging texture from extents and specified bits per scalar element, initialized from a host buffer, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture. More...

	texture (int _E0, const void *_Source, unsigned int _Src_byte_size, unsigned int _Bits_per_scalar_element, const Concurrency::accelerator_view &_Av) __CPU_ONLY
	Construct a texture<T, 1> with integer _E0 and specified bits per scalar element, initialized from a host buffer, bound to a specific accelerator_view. More...

	texture (int _E0, const void *_Source, unsigned int _Src_byte_size, unsigned int _Bits_per_scalar_element, const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av) __CPU_ONLY
	Construct a staging texture<T, 1> with integer _E0 and specified bits per scalar element, initialized from a host buffer, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture. More...

	texture (int _E0, int _E1, const void *_Source, unsigned int _Src_byte_size, unsigned int _Bits_per_scalar_element, const Concurrency::accelerator_view &_Av) __CPU_ONLY
	Construct a texture<T, 2> with two integers and specified bits per scalar element, initialized from a host buffer, bound to a specific accelerator_view. More...

	texture (int _E0, int _E1, const void *_Source, unsigned int _Src_byte_size, unsigned int _Bits_per_scalar_element, const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av) __CPU_ONLY
	Construct a staging texture<T, 2> with two integers and specified bits per scalar element, initialized from a host buffer, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture. More...

	texture (int _E0, int _E1, int _E2, const void *_Source, unsigned int _Src_byte_size, unsigned int _Bits_per_scalar_element, const Concurrency::accelerator_view &_Av) __CPU_ONLY
	Construct a texture<T, 3> with three integers and specified bits per scalar element, initialized from a host buffer, bound to a specific accelerator_view. More...

	texture (int _E0, int _E1, int _E2, const void *_Source, unsigned int _Src_byte_size, unsigned int _Bits_per_scalar_element, const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av) __CPU_ONLY
	Construct a staging texture<T, 3> with three integers and specified bits per scalar element, initialized from a host buffer, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture. More...

	texture (const texture_view< _Value_type, _Rank > &_Src)
	Construct a texture from a texture_view. Deep copy More...

	texture (const texture_view< const _Value_type, _Rank > &_Src)
	Construct a texture from a read-only texture_view. Deep copy More...

	texture (const texture_view< _Value_type, _Rank > &_Src, const Concurrency::accelerator_view &_Acc_view)
	Construct a texture from a texture_view on another accelerator_view. Deep copy More...

	texture (const texture_view< const _Value_type, _Rank > &_Src, const Concurrency::accelerator_view &_Acc_view)
	Construct a texture from a read-only texture_view on another accelerator_view. Deep copy More...

	texture (const texture_view< _Value_type, _Rank > &_Src, const Concurrency::accelerator_view &_Acc_view, const Concurrency::accelerator_view &_Associated_av)
	Construct a staging texture from a texture_view on another accelerator_view. Deep copy More...

	texture (const texture_view< const _Value_type, _Rank > &_Src, const Concurrency::accelerator_view &_Acc_view, const Concurrency::accelerator_view &_Associated_av)
	Construct a staging texture from a read-only texture_view on another accelerator_view. Deep copy More...

	texture (const texture &_Src)
	Copy constructor. Deep copy More...

	texture (texture &&_Other)
	Move constructor More...

	texture (const texture &_Src, const Concurrency::accelerator_view &_Av)
	Copy constructor. Deep copy More...

	texture (const texture &_Src, const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av)
	Copy constructor. Deep copy More...

texture &	operator= (const texture &_Other)
	Copy assignment operator. Deep copy More...

texture &	operator= (texture< _Value_type, _Rank > &&_Other)
	Move assignment operator More...

void	copy_to (texture &_Dest) const
	Copy-to, deep copy More...

void	copy_to (const writeonly_texture_view< _Value_type, _Rank > &_Dest) const
	Copy-to, deep copy More...

	~texture () __CPU_ONLY
	Destructor More...

const value_type	operator[] (const index< _Rank > &_Index) const __GPU_ONLY
	Get the element value indexed by _Index. More...

const value_type	operator[] (int _I0) const __GPU_ONLY
	Get the element value indexed by _I. More...

const value_type	operator() (const index< _Rank > &_Index) const __GPU_ONLY
	Get the element value indexed by _Index. More...

const value_type	operator() (int _I0) const __GPU_ONLY
	Get the element value indexed by _I0 More...

const value_type	operator() (int _I0, int _I1) const __GPU_ONLY
	Get the element value indexed by (_I0,_I1) More...

const value_type	operator() (int _I0, int _I1, int _I2) const __GPU_ONLY
	Get the element value indexed by (_I0,_I1,_I2) More...

const value_type	get (const index< _Rank > &_Index) const __GPU_ONLY
	Get the element value indexed by _Index. More...

void	set (const index< _Rank > &_Index, const value_type &_Value) __GPU_ONLY
	Set the element indexed by _Index with value _Value. More...

_Ret_ void *	data () __CPU_ONLY
	Returns a CPU pointer to the raw data of this texture. More...

const void *	data () const __CPU_ONLY
	Returns a CPU pointer to the raw data of this texture. More...

	__declspec (property(get=get_row_pitch)) unsigned int row_pitch
	Returns the row pitch (in bytes) of a 2D or 3D staging texture on the CPU to be used for navigating the staging texture from row to row on the CPU. More...

unsigned int	get_row_pitch () const __CPU_ONLY

	__declspec (property(get=get_depth_pitch)) unsigned int depth_pitch
	Returns the depth pitch (in bytes) of a 3D staging texture on the CPU to be used for navigating the staging texture from depth slice to depth slice on the CPU. More...

unsigned int	get_depth_pitch () const __CPU_ONLY

__declspec(property(get=get_associated_accelerator_view)) Concurrency Concurrency::accelerator_view	get_associated_accelerator_view () const __CPU_ONLY
	Returns the accelerator_view that is the preferred target where this texture can be copied. More...

Public Member Functions inherited from Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >
__declspec(property(get=get_extent)) Concurrency Concurrency::extent< _Rank >	get_extent () const __GPU
	Returns the extent that defines the shape of this texture or texture view. More...

Concurrency::extent< _Rank >	get_mipmap_extent (unsigned int _Mipmap_level) const __CPU_ONLY
	Returns the extent for specific mipmap level of this texture or texture view. More...

Concurrency::extent< _Rank >	get_mipmap_extent (unsigned int _Mipmap_level) const __GPU_ONLY
	Returns the extent for specific mipmap level of this texture or texture view. More...

__declspec(property(get=get_accelerator_view)) Concurrency Concurrency::accelerator_view	get_accelerator_view () const __CPU_ONLY
	Returns the accelerator_view where this texture or texture view is located. More...

	__declspec (property(get=get_bits_per_scalar_element)) unsigned int bits_per_scalar_element
	Returns the number of bits per scalar element More...

unsigned int	get_bits_per_scalar_element () const __CPU_ONLY

	__declspec (property(get=get_mipmap_levels)) unsigned int mipmap_levels
	Query how many mipmap levels are accessible by this texture (or texture view). More...

unsigned int	get_mipmap_levels () const __GPU

	__declspec (property(get=get_data_length)) unsigned int data_length
	Returns the physical data length (in bytes) that is required in order to represent the texture on the host side with its native format. If the texture contains multiple mipmap levels the value represents the sum of physical data length for each accessible mipmap level by this texture (or texture view). More...

unsigned int	get_data_length () const __CPU_ONLY

Private Member Functions
	texture (const Concurrency::extent< _Rank > &_Ext, const _Texture_descriptor &_Descriptor)

bool	_Should_create_staging_texture (const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av)

void	_Initialize (const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av, unsigned int _Bits_per_scalar_element) __CPU_ONLY

void	_Initialize (const Concurrency::accelerator_view &_Av, unsigned int _Bits_per_scalar_element) __CPU_ONLY

void	_Initialize (const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av) __CPU_ONLY

void	_Initialize (const Concurrency::accelerator_view &_Av) __CPU_ONLY

template<typename _Input_iterator >
void	_Initialize (const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av, _Input_iterator _Src_first, _Input_iterator _Src_last) __CPU_ONLY

template<typename _Input_iterator >
void	_Initialize (const Concurrency::accelerator_view &_Av, _Input_iterator _Src_first, _Input_iterator _Src_last) __CPU_ONLY

void	_Initialize (const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av, const void *_Source, unsigned int _Src_byte_size, unsigned int _Bits_per_scalar_element) __CPU_ONLY

void	_Initialize (const Concurrency::accelerator_view &_Av, const void *_Source, unsigned int _Src_byte_size, unsigned int _Bits_per_scalar_element) __CPU_ONLY

void	_Initialize (const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av, const void *_Source, unsigned int _Src_byte_size) __CPU_ONLY

void	_Initialize (const Concurrency::accelerator_view &_Av, const void *_Source, unsigned int _Src_byte_size) __CPU_ONLY

void	_Initialize (const Concurrency::accelerator_view &_Av, const Concurrency::accelerator_view &_Associated_av, const details::_Texture_base< _Value_type, _Rank > &_Src) __CPU_ONLY

void	_Initialize (const Concurrency::accelerator_view &_Av, const details::_Texture_base< _Value_type, _Rank > &_Src) __CPU_ONLY

Friends
template<typename _Value_type , int _Rank>
texture< _Value_type, _Rank >	direct3d::make_texture (const Concurrency::accelerator_view &_Av, _In_ IUnknown *_D3D_texture, DXGI_FORMAT _View_format) __CPU_ONLY

Additional Inherited Members
Public Types inherited from Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >
typedef _Value_type	value_type

typedef _Short_vector_type_traits< _Value_type >::_Scalar_type	scalar_type

Static Public Attributes inherited from Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >
static const int	rank = _Rank

Protected Types inherited from Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >
typedef Concurrency::details::_Texture_descriptor	_Texture_descriptor

Protected Member Functions inherited from Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >
	_Texture_base () __CPU_ONLY

	_Texture_base (const Concurrency::extent< _Rank > &_Ext, unsigned int _Mipmap_levels=1) __CPU_ONLY

	_Texture_base (const _Texture_base &_Src) __GPU

	_Texture_base (const _Texture_base &_Src, unsigned int _Most_detailed_mipmap_level, unsigned int _View_mipmap_levels) __CPU_ONLY

	_Texture_base (const _Texture_base &_Src, bool _Flatten_mipmap_levels) __GPU_ONLY

	_Texture_base (const Concurrency::extent< _Rank > &_Ext, const _Texture_descriptor &_Desc) __CPU_ONLY

void	_Copy_to (const _Texture_base &_Dest) const __CPU_ONLY

bool	operator== (const _Texture_base &_Other) const __CPU_ONLY

	~_Texture_base () __GPU

_Ret_ _Texture *	_Get_texture () const __CPU_ONLY

unsigned int	_Get_most_detailed_mipmap_level () const __GPU

bool	_Are_mipmap_levels_overlapping (const _Texture_base &_Other) const __CPU_ONLY

Protected Attributes inherited from Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >
Concurrency::extent< _Rank >	_M_extent

_Texture_descriptor	_M_texture_descriptor

Detailed Description

template<typename _Value_type, int _Rank>
class Concurrency::graphics::texture< _Value_type, _Rank >

A texture is a data aggregate on an accelerator_view in the extent domain. It is a collection of variables, one for each element in an extent domain. Each variable holds a value corresponding to C++ primitive type (unsigned int, int, float, double), or scalar type norm, or unorm (defined in concurrency::graphics), or eligible short vector types defined in concurrency::graphics.

Parameters

_Value_type	The type of the elements in the texture aggregates.
_Rank	The _Rank of the corresponding extent domain.

Constructor & Destructor Documentation

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture ( const Concurrency::extent< _Rank > & _Ext )

inline

Construct a texture from extents.

Parameters

_Extent An extent that describes the shape of the texture.

         : _Texture_base(_Ext)
     {
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(Concurrency::details::_Select_default_accelerator().default_view);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture ( int _E0 )

inline

Construct texture<T,1> with the extent _E0

Parameters

_E0	An integer that is the length of this texture (width).

         : _Texture_base(Concurrency::extent<_Rank>(_E0))
     {
         static_assert(_Rank == 1, "texture(int) is only permissible on texture<value_type, 1>.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(Concurrency::details::_Select_default_accelerator().default_view);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1
	)

inline

Construct a texture<T,2> from two integer extents.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (height).
_E1	An integer that is the length of the least-significant dimension of this texture (width).

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1))
     {
         static_assert(_Rank == 2, "texture(int, int) is only permissible on texture<value_type, 2>.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(Concurrency::details::_Select_default_accelerator().default_view);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		int	_E2
	)

inline

Construct a texture<T,3> from three integer extents.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (depth).
_E1	An integer that is the length of the next-to-most-significant dimension of this texture (height).
_E2	An integer that is the length of the least-significant dimension of this texture (width).

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {
         static_assert(_Rank == 3, "texture(int, int, int) is only permissible on texture<value_type, 3>.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(Concurrency::details::_Select_default_accelerator().default_view);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const Concurrency::extent< _Rank > &	_Ext,
		const Concurrency::accelerator_view &	_Av
	)

inline

Construct a texture from extents, bound to a specific accelerator_view.

Parameters

_Extent	An extent that describes the shape of the texture.
_Av	An accelerator_view where this texture resides.

         : _Texture_base(_Ext)
     {
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(_Av);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const Concurrency::extent< _Rank > &	_Ext,
		const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av
	)

inline

Construct a staging texture from extents, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture.

Parameters

_Ext	An extent that describes the shape of the texture.
_Av	An accelerator_view where this texture resides.
_Associated_av	An accelerator_view which specifies the preferred target location for copies to/from the texture.

         : _Texture_base(_Ext)
     {
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(_Av, _Associated_av);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		const Concurrency::accelerator_view &	_Av
	)

inline

Construct a texture<T,1> with the extent _E0, bound to a specific accelerator_view.

Parameters

_E0	An integer that is the length of this texture (width).
_Av	An accelerator_view where this texture resides.

         : _Texture_base(Concurrency::extent<_Rank>(_E0))
     {
         static_assert(_Rank == 1, "texture(int, accelerator_view) is only permissible on texture<value_type, 1>.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(_Av);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av
	)

inline

Construct a staging texture<T,1> with the extent _E0, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture.

Parameters

_E0	An integer that is the length of this texture (width).
_Av	An accelerator_view where this texture resides.
_Associated_av	An accelerator_view which specifies the preferred target location for copies to/from the texture.

         : _Texture_base(Concurrency::extent<_Rank>(_E0))
     {
         static_assert(_Rank == 1, "texture(int, accelerator_view, accelerator_view) is only permissible on texture<value_type, 1>.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(_Av, _Associated_av);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		const Concurrency::accelerator_view &	_Av
	)

inline

Construct a texture<T,2> from two integer extents, bound to a specific accelerator_view.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (height).
_E1	An integer that is the length of the least-significant dimension of this texture (width).
_Av	An accelerator_view where this texture resides.

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1))
     {
         static_assert(_Rank == 2, "texture(int, int, accelerator_view) is only permissible on texture<value_type, 2>.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(_Av);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av
	)

inline

Construct a staging texture<T,2> from two integer extents, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (height).
_E1	An integer that is the length of the least-significant dimension of this texture (width).
_Av	An accelerator_view where this texture resides.
_Associated_av	An accelerator_view which specifies the preferred target location for copies to/from the texture.

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1))
     {
         static_assert(_Rank == 2, "texture(int, int, accelerator_view, accelerator_view) is only permissible on texture<value_type, 2>.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(_Av, _Associated_av);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		int	_E2,
		const Concurrency::accelerator_view &	_Av
	)

inline

Construct a texture<T,3> from three integer extents, bound to a specific accelerator_view.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (depth).
_E1	An integer that is the length of the next-to-most-significant dimension of this texture (height).
_E2	An integer that is the length of the least-significant dimension of this texture (width).
_Av	An accelerator_view where this texture resides.

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {
         static_assert(_Rank == 3, "texture(int, int, int, accelerator_view) is only permissible on texture<value_type, 3>.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(_Av);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		int	_E2,
		const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av
	)

inline

Construct a staging texture<T,3> from three integer extents, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (depth).
_E1	An integer that is the length of the next-to-most-significant dimension of this texture (height).
_E2	An integer that is the length of the least-significant dimension of this texture (width).
_Av	An accelerator_view where this texture resides.
_Associated_av	An accelerator_view which specifies the preferred target location for copies to/from the texture.

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {
         static_assert(_Rank == 3, "texture(int, int, int, accelerator_view, accelerator_view) is only permissible on texture<value_type, 3>.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(_Av, _Associated_av);
     }

template<typename _Value_type, int _Rank>

template<typename _Input_iterator >

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const Concurrency::extent< _Rank > &	_Ext,
		_Input_iterator	_Src_first,
		_Input_iterator	_Src_last
	)

inline

Construct a texture initialized from a pair of iterators into a container.

Parameters

_Ext	An extent that describes the shape of the texture.
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.

         : _Texture_base(_Ext)
     {
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(Concurrency::details::_Select_default_accelerator().default_view, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank>

template<typename _Input_iterator >

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		_Input_iterator	_Src_first,
		_Input_iterator	_Src_last
	)

inline

Construct a texture<T,1> with the extent _E0 and from a pair of iterators into a container.

Parameters

_E0	An integer that is the length of this texture (width).
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.

         : _Texture_base(Concurrency::extent<_Rank>(_E0))
     {
         static_assert(_Rank == 1, "texture(int, iterator, iterator) is only permissible on texture<value_type, 1>.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(Concurrency::details::_Select_default_accelerator().default_view, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank>

template<typename _Input_iterator >

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		_Input_iterator	_Src_first,
		_Input_iterator	_Src_last
	)

inline

Construct a texture<T,2> with two integers and initialized from a pair of iterators into a container.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (height).
_E1	An integer that is the length of the least-significant dimension of this texture (width).
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1))
     {
         static_assert(_Rank == 2, "texture(int, int, iterator, iterator) is only permissible on texture<value_type, 2>.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(Concurrency::details::_Select_default_accelerator().default_view, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank>

template<typename _Input_iterator >

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		int	_E2,
		_Input_iterator	_Src_first,
		_Input_iterator	_Src_last
	)

inline

Construct a texture<T,3> with three integers and initialized from a pair of iterators into a container.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (depth).
_E1	An integer that is the length of the next-to-most-significant dimension of this texture (height).
_E2	An integer that is the length of the least-significant dimension of this texture (width).
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {
         static_assert(_Rank == 3, "texture(int, int, int, iterator, iterator) is only permissible on texture<value_type, 3>.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(Concurrency::details::_Select_default_accelerator().default_view, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank>

template<typename _Input_iterator >

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const Concurrency::extent< _Rank > &	_Ext,
		_Input_iterator	_Src_first,
		_Input_iterator	_Src_last,
		const Concurrency::accelerator_view &	_Av
	)

inline

Construct a texture initialized from a pair of iterators into a container, bound to a specific accelerator_view.

Parameters

_Ext	An extent that describes the shape of the texture.
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.
_Av	An accelerator_view where this texture resides.

         : _Texture_base(_Ext)
     {
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(_Av, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank>

template<typename _Input_iterator >

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const Concurrency::extent< _Rank > &	_Ext,
		_Input_iterator	_Src_first,
		_Input_iterator	_Src_last,
		const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av
	)

inline

Construct a staging texture initialized from a pair of iterators into a container, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture.

Parameters

_Ext	An extent that describes the shape of the texture.
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.
_Av	An accelerator_view where this texture resides.
_Associated_av	An accelerator_view which specifies the preferred target location for copies to/from the texture.

         : _Texture_base(_Ext)
     {
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(_Av, _Associated_av, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank>

template<typename _Input_iterator >

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		_Input_iterator	_Src_first,
		_Input_iterator	_Src_last,
		const Concurrency::accelerator_view &	_Av
	)

inline

Construct a texture<T,1> with integer _E0 and initialized from a pair of iterators into a container, bound to a specific accelerator_view.

Parameters

_E0	An integer that is the length of this texture (width).
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.
_Av	An accelerator_view where this texture resides.

         : _Texture_base(Concurrency::extent<_Rank>(_E0))
     {
         static_assert(_Rank == 1, "texture(int, iterator, iterator, accelerator_view) is only permissible on texture<value_type, 1>.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(_Av, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank>

template<typename _Input_iterator >

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		_Input_iterator	_Src_first,
		_Input_iterator	_Src_last,
		const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av
	)

inline

Construct a staging texture<T,1> with integer _E0 and initialized from a pair of iterators into a container, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture.

Parameters

_E0	An integer that is the length of this texture (width).
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.
_Av	An accelerator_view where this texture resides.
_Associated_av	An accelerator_view which specifies the preferred target location for copies to/from the texture.

         : _Texture_base(Concurrency::extent<_Rank>(_E0))
     {
         static_assert(_Rank == 1, "texture(int, iterator, iterator, accelerator_view, accelerator_view) is only permissible on texture<value_type, 1>.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(_Av, _Associated_av, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank>

template<typename _Input_iterator >

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		_Input_iterator	_Src_first,
		_Input_iterator	_Src_last,
		const Concurrency::accelerator_view &	_Av
	)

inline

Construct a texture<T,2> with two integers and initialized from a pair of iterators into a container, bound to a specific accelerator_view.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (height).
_E1	An integer that is the length of the least-significant dimension of this texture (width).
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.
_Av	An accelerator_view where this texture resides.

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1))
     {
         static_assert(_Rank == 2, "texture(int, int, iterator, iterator, accelerator_view) is only permissible on texture<value_type, 2>.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(_Av, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank>

template<typename _Input_iterator >

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		_Input_iterator	_Src_first,
		_Input_iterator	_Src_last,
		const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av
	)

inline

Construct a staging texture<T,2> with two integers and initialized from a pair of iterators into a container, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (height).
_E1	An integer that is the length of the least-significant dimension of this texture (width).
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.
_Av	An accelerator_view where this texture resides.
_Associated_av	An accelerator_view which specifies the preferred target location for copies to/from the texture.

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1))
     {
         static_assert(_Rank == 2, "texture(int, int, iterator, iterator, accelerator_view, accelerator_view) is only permissible on texture<value_type, 2>.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(_Av, _Associated_av, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank>

template<typename _Input_iterator >

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		int	_E2,
		_Input_iterator	_Src_first,
		_Input_iterator	_Src_last,
		const Concurrency::accelerator_view &	_Av
	)

inline

Construct a texture<T,3> with three integers and initialized from a pair of iterators into a container, bound to a specific accelerator_view.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (depth).
_E1	An integer that is the length of the next-to-most-significant dimension of this texture (height).
_E2	An integer that is the length of the least-significant dimension of this texture (width).
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.
_Av	An accelerator_view where this texture resides.

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {
         static_assert(_Rank == 3, "texture(int, int, int, iterator, iterator, accelerator_view) is only permissible on texture<value_type, 3>.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(_Av, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank>

template<typename _Input_iterator >

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		int	_E2,
		_Input_iterator	_Src_first,
		_Input_iterator	_Src_last,
		const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av
	)

inline

Construct a staging texture<T,3> with three integers and initialized from a pair of iterators into a container, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (depth).
_E1	An integer that is the length of the next-to-most-significant dimension of this texture (height).
_E2	An integer that is the length of the least-significant dimension of this texture (width).
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.
_Av	An accelerator_view where this texture resides.
_Associated_av	An accelerator_view which specifies the preferred target location for copies to/from the texture.

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {
         static_assert(_Rank == 3, "texture(int, int, int, iterator, iterator, accelerator_view, accelerator_view) is only permissible on texture<value_type, 3>.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "texture cannot be constructed from unorm based short vectors via this constructor.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "texture cannot be constructed from norm based short vectors via this constructor.");
         _Initialize(_Av, _Associated_av, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const Concurrency::extent< _Rank > &	_Ext,
		unsigned int	_Bits_per_scalar_element
	)

inline

Construct a texture from extents and specified bits per scalar element

Parameters

_Ext	An extent that describes the shape of the texture.
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures

         : _Texture_base(_Ext)
     {
         _Initialize(Concurrency::details::_Select_default_accelerator().default_view, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const Concurrency::extent< _Rank > &	_Ext,
		unsigned int	_Bits_per_scalar_element,
		unsigned int	_Mipmap_levels
	)

inline

Construct a texture from extents, specified bits per scalar element and number of mipmap levels

Parameters

_Ext	An extent that describes the shape of the texture.
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures
_Mipmap_levels	Number of mipmap levels in the underlying texture. If 0 is specified, the texture will have full range of mipmap levels down to smallest possible size for the given extent.

         : _Texture_base(_Ext, _Mipmap_levels)
     {
         _Initialize(Concurrency::details::_Select_default_accelerator().default_view, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		unsigned int	_Bits_per_scalar_element
	)

inline

Construct a texture<T,1> with integer _E0 and specified bits per scalar element

Parameters

_E0	An integer that is the length of this texture (width).
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures

         : _Texture_base(Concurrency::extent<_Rank>(_E0))
     {
         static_assert(_Rank == 1, "texture(int, unsigned int) is only permissible on texture<value_type, 1>.");
         _Initialize(Concurrency::details::_Select_default_accelerator().default_view, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		unsigned int	_Bits_per_scalar_element
	)

inline

Construct a texture<T,2> with two integers and specified bits per scalar element

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (height).
_E1	An integer that is the length of the least-significant dimension of this texture (width).
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1))
     {
         static_assert(_Rank == 2, "texture(int, int, unsigned int) is only permissible on texture<value_type, 2>.");
         _Initialize(Concurrency::details::_Select_default_accelerator().default_view, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		int	_E2,
		unsigned int	_Bits_per_scalar_element
	)

inline

Construct a texture<T,3> with three integers and specified bits per scalar element

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (depth).
_E1	An integer that is the length of the next-to-most-significant dimension of this texture (height).
_E2	An integer that is the length of the least-significant dimension of this texture (width).
_Src_first	A beginning iterator into the source container.
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {
         static_assert(_Rank == 3, "texture(int, int, int, unsigned int) is only permissible on texture<value_type, 3>.");
         _Initialize(Concurrency::details::_Select_default_accelerator().default_view, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const Concurrency::extent< _Rank > &	_Ext,
		unsigned int	_Bits_per_scalar_element,
		const Concurrency::accelerator_view &	_Av
	)

inline

Construct a texture from extents and specified bits per scalar element, bound to a specific accelerator_view.

Parameters

_Ext	An extent that describes the shape of the texture.
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures
_Av	An accelerator_view where this texture resides.

         : _Texture_base(_Ext)
     {
         _Initialize(_Av, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const Concurrency::extent< _Rank > &	_Ext,
		unsigned int	_Bits_per_scalar_element,
		unsigned int	_Mipmap_levels,
		const Concurrency::accelerator_view &	_Av
	)

inline

Construct a texture from extents, specified bits per scalar element and number of mipmap levels

Parameters

_Ext	An extent that describes the shape of the texture.
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures
_Mipmap_levels	Number of mipmap levels in the underlying texture. If 0 is specified, the texture will have full range of mipmap levels down to smallest possible size for the given extent.
_Av	An accelerator_view where this texture resides.

         : _Texture_base(_Ext, _Mipmap_levels)
     {
         _Initialize(_Av, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const Concurrency::extent< _Rank > &	_Ext,
		unsigned int	_Bits_per_scalar_element,
		const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av
	)

inline

Construct a staging texture from extents and specified bits per scalar element, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture.

Parameters

_Ext	An extent that describes the shape of the texture.
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures
_Av	An accelerator_view where this texture resides.
_Associated_av	An accelerator_view which specifies the preferred target location for copies to/from the texture.

         : _Texture_base(_Ext)
     {
         _Initialize(_Av, _Associated_av, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		unsigned int	_Bits_per_scalar_element,
		const Concurrency::accelerator_view &	_Av
	)

inline

Construct a texture<T, 1> with integer _E0 and specified bits per scalar element, bound to a specific accelerator.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (width).
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures
_Av	An accelerator_view where this texture resides.

         : _Texture_base(Concurrency::extent<_Rank>(_E0))
     {
         static_assert(_Rank == 1, "texture(int, unsigned int, accelerator_view) is only permissible on texture<value_type, 1>.");
         _Initialize(_Av, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		unsigned int	_Bits_per_scalar_element,
		const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av
	)

inline

Construct a staging texture<T, 1> with integer _E0 and specified bits per scalar element, bound to a specific accelerator and an associated accelerator_view that is the preferred location for copying to/from this texture.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (width).
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures
_Av	An accelerator_view where this texture resides.
_Associated_av	An accelerator_view which specifies the preferred target location for copies to/from the texture.

         : _Texture_base(Concurrency::extent<_Rank>(_E0))
     {
         static_assert(_Rank == 1, "texture(int, unsigned int, accelerator_view, accelerator_view) is only permissible on texture<value_type, 1>.");
         _Initialize(_Av, _Associated_av, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		unsigned int	_Bits_per_scalar_element,
		const Concurrency::accelerator_view &	_Av
	)

inline

Construct a texture<T,2> with two integers and specified bits per scalar element, bound to a specific accelerator.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (height).
_E1	An integer that is the length of the least-significant dimension of this texture (width).
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures
_Av	An accelerator_view where this texture resides.

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1))
     {
         static_assert(_Rank == 2, "texture(int, int, unsigned int, accelerator_view) is only permissible on texture<value_type, 2>.");
         _Initialize(_Av, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		unsigned int	_Bits_per_scalar_element,
		const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av
	)

inline

Construct a staging texture<T,2> with two integers and specified bits per scalar element, bound to a specific accelerator and an associated accelerator_view that is the preferred location for copying to/from this texture.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (height).
_E1	An integer that is the length of the least-significant dimension of this texture (width).
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures
_Av	An accelerator_view where this texture resides.
_Associated_av	An accelerator_view which specifies the preferred target location for copies to/from the texture.

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1))
     {
         static_assert(_Rank == 2, "texture(int, int, unsigned int, accelerator_view, accelerator_view) is only permissible on texture<value_type, 2>.");
         _Initialize(_Av, _Associated_av, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		int	_E2,
		unsigned int	_Bits_per_scalar_element,
		const Concurrency::accelerator_view &	_Av
	)

inline

Construct a texture<T,3> with three integers and specified bits per scalar element, bound to a specific accelerator.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (depth).
_E1	An integer that is the length of the least-significant dimension of this texture (height).
_E2	An integer that is the length of the least-significant dimension of this texture (width).
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures
_Av	An accelerator_view where this texture resides.

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {
         static_assert(_Rank == 3, "texture(int, int, int, unsigned int, accelerator_view) is only permissible on texture<value_type, 3>.");
         _Initialize(_Av, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		int	_E2,
		unsigned int	_Bits_per_scalar_element,
		const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av
	)

inline

Construct a staging texture<T,3> with three integers and specified bits per scalar element, bound to a specific accelerator and an associated accelerator_view that is the preferred location for copying to/from this texture.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (depth).
_E1	An integer that is the length of the least-significant dimension of this texture (height).
_E2	An integer that is the length of the least-significant dimension of this texture (width).
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures
_Av	An accelerator_view where this texture resides.
_Associated_av	An accelerator_view which specifies the preferred target location for copies to/from the texture.

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {
         static_assert(_Rank == 3, "texture(int, int, int, unsigned int, accelerator_view, accelerator_view) is only permissible on texture<value_type, 3>.");
         _Initialize(_Av, _Associated_av, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const Concurrency::extent< _Rank > &	_Ext,
		const void *	_Source,
		unsigned int	_Src_byte_size,
		unsigned int	_Bits_per_scalar_element
	)

inline

Construct a texture from extents and specified bits per scalar element, initialized from a host buffer.

Parameters

_Ext	An extent that describes the shape of the texture.
_Source	A pointer to a host buffer.
_Source_byte_size	Number of bytes in the source buffer.
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures

         : _Texture_base(_Ext)
     {
         _Initialize(Concurrency::details::_Select_default_accelerator().default_view, _Source, _Src_byte_size, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		const void *	_Source,
		unsigned int	_Src_byte_size,
		unsigned int	_Bits_per_scalar_element
	)

inline

Construct a texture<T,1> with integer _E0 and specified bits per scalar element, initialized from a host buffer.

Parameters

_E0	An integer that is the length of this texture (width).
_Source	A pointer to a host buffer.
_Source_byte_size	Number of bytes in the source buffer.
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures

         : _Texture_base(Concurrency::extent<_Rank>(_E0))
     {
         static_assert(_Rank == 1, "texture(int, void *, unsigned int, unsigned int) is only permissible on texture<value_type, 1>.");
         _Initialize(Concurrency::details::_Select_default_accelerator().default_view, _Source, _Src_byte_size, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		const void *	_Source,
		unsigned int	_Src_byte_size,
		unsigned int	_Bits_per_scalar_element
	)

inline

Construct a texture<T,2> with two integers and specified bits per scalar element, initialized from a host buffer.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (height).
_E1	An integer that is the length of the least-significant dimension of this texture (width).
_Source	A pointer to a host buffer.
_Source_byte_size	Number of bytes in the source buffer.
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1))
     {
         static_assert(_Rank == 2, "texture(int, int, void *, unsigned int, unsigned int) is only permissible on texture<value_type, 2>.");
         _Initialize(Concurrency::details::_Select_default_accelerator().default_view, _Source, _Src_byte_size, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		int	_E2,
		const void *	_Source,
		unsigned int	_Src_byte_size,
		unsigned int	_Bits_per_scalar_element
	)

inline

Construct a texture<T,3> with three integers and specified bits per scalar element, initialized from a host buffer.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (depth).
_E1	An integer that is the length of the least-significant dimension of this texture (height).
_E2	An integer that is the length of the least-significant dimension of this texture (width).
_Source	A pointer to a host buffer.
_Source_byte_size	Number of bytes in the source buffer.
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {
         static_assert(_Rank == 3, "texture(int, int, int, void *, unsigned int, unsigned int) is only permissible on texture<value_type, 3>.");
         _Initialize(Concurrency::details::_Select_default_accelerator().default_view, _Source, _Src_byte_size, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const Concurrency::extent< _Rank > &	_Ext,
		const void *	_Source,
		unsigned int	_Src_byte_size,
		unsigned int	_Bits_per_scalar_element,
		const Concurrency::accelerator_view &	_Av
	)

inline

Construct a texture from extents and specified bits per scalar element, initialized from a host buffer, bound to a specific accelerator_view.

Parameters

_Ext	An extent that describes the shape of the texture.
_Source	A pointer to a host buffer.
_Source_byte_size	Number of bytes in the source buffer.
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures
_Av	An accelerator_view where this texture resides.

         : _Texture_base(_Ext)
     {
         _Initialize(_Av, _Source, _Src_byte_size, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const Concurrency::extent< _Rank > &	_Ext,
		const void *	_Source,
		unsigned int	_Src_byte_size,
		unsigned int	_Bits_per_scalar_element,
		const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av
	)

inline

Construct a staging texture from extents and specified bits per scalar element, initialized from a host buffer, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture.

Parameters

_Ext	An extent that describes the shape of the texture.
_Source	A pointer to a host buffer.
_Source_byte_size	Number of bytes in the source buffer.
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures
_Av	An accelerator_view where this texture resides.
_Associated_av	An accelerator_view which specifies the preferred target location for copies to/from the texture.

         : _Texture_base(_Ext)
     {
         _Initialize(_Av, _Associated_av, _Source, _Src_byte_size, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		const void *	_Source,
		unsigned int	_Src_byte_size,
		unsigned int	_Bits_per_scalar_element,
		const Concurrency::accelerator_view &	_Av
	)

inline

Construct a texture<T, 1> with integer _E0 and specified bits per scalar element, initialized from a host buffer, bound to a specific accelerator_view.

Parameters

_E0	An integer that is the length of this texture (width).
_Source	A pointer to a host buffer.
_Source_byte_size	Number of bytes in the source buffer.
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures
_Av	An accelerator_view where this texture resides.

         : _Texture_base(Concurrency::extent<_Rank>(_E0))
     {
         static_assert(_Rank == 1, "texture(int, void *, unsigned int, unsigned int, accelerator_view) is only permissible on texture<value_type, 1>.");
         _Initialize(_Av, _Source, _Src_byte_size, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		const void *	_Source,
		unsigned int	_Src_byte_size,
		unsigned int	_Bits_per_scalar_element,
		const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av
	)

inline

Construct a staging texture<T, 1> with integer _E0 and specified bits per scalar element, initialized from a host buffer, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture.

Parameters

_E0	An integer that is the length of this texture (width).
_Source	A pointer to a host buffer.
_Source_byte_size	Number of bytes in the source buffer.
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures
_Av	An accelerator_view where this texture resides.
_Associated_av	An accelerator_view which specifies the preferred target location for copies to/from the texture.

         : _Texture_base(Concurrency::extent<_Rank>(_E0))
     {
         static_assert(_Rank == 1, "texture(int, void *, unsigned int, unsigned int, accelerator_view, accelerator_view) is only permissible on texture<value_type, 1>.");
         _Initialize(_Av, _Associated_av, _Source, _Src_byte_size, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		const void *	_Source,
		unsigned int	_Src_byte_size,
		unsigned int	_Bits_per_scalar_element,
		const Concurrency::accelerator_view &	_Av
	)

inline

Construct a texture<T, 2> with two integers and specified bits per scalar element, initialized from a host buffer, bound to a specific accelerator_view.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (height).
_E1	An integer that is the length of the least-significant dimension of this texture (width).
_Source	A pointer to a host buffer.
_Source_byte_size	Number of bytes in the source buffer.
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures
_Av	An accelerator_view where this texture resides.

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1))
     {
         static_assert(_Rank == 2, "texture(int, int, void *, unsigned int, unsigned int, accelerator_view) is only permissible on texture<value_type, 2>.");
         _Initialize(_Av, _Source, _Src_byte_size, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		const void *	_Source,
		unsigned int	_Src_byte_size,
		unsigned int	_Bits_per_scalar_element,
		const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av
	)

inline

Construct a staging texture<T, 2> with two integers and specified bits per scalar element, initialized from a host buffer, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (height).
_E1	An integer that is the length of the least-significant dimension of this texture (width).
_Source	A pointer to a host buffer.
_Source_byte_size	Number of bytes in the source buffer.
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures
_Av	An accelerator_view where this texture resides.
_Associated_av	An accelerator_view which specifies the preferred target location for copies to/from the texture.

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1))
     {
         static_assert(_Rank == 2, "texture(int, int, void *, unsigned int, unsigned int, accelerator_view, accelerator_view) is only permissible on texture<value_type, 2>.");
         _Initialize(_Av, _Associated_av, _Source, _Src_byte_size, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		int	_E2,
		const void *	_Source,
		unsigned int	_Src_byte_size,
		unsigned int	_Bits_per_scalar_element,
		const Concurrency::accelerator_view &	_Av
	)

inline

Construct a texture<T, 3> with three integers and specified bits per scalar element, initialized from a host buffer, bound to a specific accelerator_view.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (depth).
_E1	An integer that is the length of the least-significant dimension of this texture (height).
_E2	An integer that is the length of the least-significant dimension of this texture (width).
_Source	A pointer to a host buffer.
_Source_byte_size	Number of bytes in the source buffer.
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures
_Av	An accelerator_view where this texture resides.

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {
         static_assert(_Rank == 3, "texture(int, int, int, void *, unsigned int, unsigned int, accelerator_view) is only permissible on texture<value_type, 3>.");
         _Initialize(_Av, _Source, _Src_byte_size, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	int	_E0,
		int	_E1,
		int	_E2,
		const void *	_Source,
		unsigned int	_Src_byte_size,
		unsigned int	_Bits_per_scalar_element,
		const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av
	)

inline

Construct a staging texture<T, 3> with three integers and specified bits per scalar element, initialized from a host buffer, bound to a specific accelerator_view and an associated accelerator_view that is the preferred location for copying to/from this texture.

Parameters

_E0	An integer that is the length of the most-significant dimension of this texture (depth).
_E1	An integer that is the length of the least-significant dimension of this texture (height).
_E2	An integer that is the length of the least-significant dimension of this texture (width).
_Source	A pointer to a host buffer.
_Source_byte_size	Number of bytes in the source buffer.
_Bits_per_scalar_element	Number of bits per each scalar element in the underlying scalar type of the texture. In general, supported value is 8, 16, 32, 64. If 0 is specified, the number of bits picks defaulted value for the underlying scalar_type. 64 is only valid for double based textures
_Av	An accelerator_view where this texture resides.
_Associated_av	An accelerator_view which specifies the preferred target location for copies to/from the texture.

         : _Texture_base(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {
         static_assert(_Rank == 3, "texture(int, int, int, void *, unsigned int, unsigned int, accelerator_view, accelerator_view) is only permissible on texture<value_type, 3>.");
         _Initialize(_Av, _Associated_av, _Source, _Src_byte_size, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture ( const texture_view< _Value_type, _Rank > & _Src )

inline

Construct a texture from a texture_view. Deep copy

Parameters

_Src	The texture_view to copy from.

         : _Texture_base(_Src.extent, _Src.get_mipmap_levels())
     {
         _Initialize(_Src.accelerator_view, _Src);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture ( const texture_view< const _Value_type, _Rank > & _Src )

inline

Construct a texture from a read-only texture_view. Deep copy

Parameters

_Src	The read-only texture_view to copy from.

         : _Texture_base(_Src.extent, _Src.get_mipmap_levels())
     {
         _Initialize(_Src.accelerator_view, _Src);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const texture_view< _Value_type, _Rank > &	_Src,
		const Concurrency::accelerator_view &	_Acc_view
	)

inline

Construct a texture from a texture_view on another accelerator_view. Deep copy

Parameters

_Src	The texture_view to copy from.
_Acc_view	An accelerator_view where this texture resides.

         : _Texture_base(_Src.extent, _Src.get_mipmap_levels())
     {
         _Initialize(_Acc_view, _Src);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const texture_view< const _Value_type, _Rank > &	_Src,
		const Concurrency::accelerator_view &	_Acc_view
	)

inline

Construct a texture from a read-only texture_view on another accelerator_view. Deep copy

Parameters

_Src	The read-only texture_view to copy from.
_Acc_view	An accelerator_view where this texture resides.

         : _Texture_base(_Src.extent, _Src.get_mipmap_levels())
     {
         _Initialize(_Acc_view, _Src);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const texture_view< _Value_type, _Rank > &	_Src,
		const Concurrency::accelerator_view &	_Acc_view,
		const Concurrency::accelerator_view &	_Associated_av
	)

inline

Construct a staging texture from a texture_view on another accelerator_view. Deep copy

Parameters

_Src	The texture_view to copy from.
_Acc_view	An accelerator_view where this texture resides.
_Associated_av	An accelerator_view which specifies the preferred target location for copies to/from the texture.

         : _Texture_base(_Src.extent, _Src.get_mipmap_levels())
     {
         _Initialize(_Acc_view, _Associated_av, _Src);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const texture_view< const _Value_type, _Rank > &	_Src,
		const Concurrency::accelerator_view &	_Acc_view,
		const Concurrency::accelerator_view &	_Associated_av
	)

inline

Construct a staging texture from a read-only texture_view on another accelerator_view. Deep copy

Parameters

_Src	The read-only texture_view to copy from.
_Acc_view	An accelerator_view where this texture resides.
_Associated_av	An accelerator_view which specifies the preferred target location for copies to/from the texture.

         : _Texture_base(_Src.extent, _Src.get_mipmap_levels())
     {
         _Initialize(_Acc_view, _Associated_av, _Src);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture ( const texture< _Value_type, _Rank > & _Src )

inline

Copy constructor. Deep copy

Parameters

_Src	The texture to copy from.

         : _Texture_base(_Src.extent, _Src.get_mipmap_levels())
     {
         _Initialize(_Src.accelerator_view, _Src.associated_accelerator_view, _Src);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture ( texture< _Value_type, _Rank > && _Other )

inline

Move constructor

Parameters

_Other The source texture to move from.

     {
         *this = std::move(_Other);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const texture< _Value_type, _Rank > &	_Src,
		const Concurrency::accelerator_view &	_Av
	)

inline

Copy constructor. Deep copy

Parameters

_Src	The texture to copy from.
_Av	An accelerator_view where this texture resides.

         : _Texture_base(_Src.extent, _Src.get_mipmap_levels())
     {
         _Initialize(_Av, _Src);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const texture< _Value_type, _Rank > &	_Src,
		const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av
	)

inline

Copy constructor. Deep copy

Parameters

_Src	The texture to copy from.
_Av	An accelerator_view where this texture resides.
_Associated_av	An accelerator_view which specifies the preferred target location for copies to/from the texture.

         : _Texture_base(_Src.extent, _Src.get_mipmap_levels())
     {
         _Initialize(_Av, _Associated_av, _Src);
     }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::~texture ( )

inline

Destructor

2194 {

2195 }

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::texture	(	const Concurrency::extent< _Rank > &	_Ext,
		const _Texture_descriptor &	_Descriptor
	)

inlineprivate

         : details::_Texture_base<_Value_type, _Rank>(_Ext, _Descriptor)
     {
     }

Member Function Documentation

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::__declspec ( property(get=get_row_pitch) )

Returns the row pitch (in bytes) of a 2D or 3D staging texture on the CPU to be used for navigating the staging texture from row to row on the CPU.

template<typename _Value_type, int _Rank>

Concurrency::graphics::texture< _Value_type, _Rank >::__declspec ( property(get=get_depth_pitch) )

Returns the depth pitch (in bytes) of a 3D staging texture on the CPU to be used for navigating the staging texture from depth slice to depth slice on the CPU.

template<typename _Value_type, int _Rank>

void Concurrency::graphics::texture< _Value_type, _Rank >::_Initialize	(	const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av,
		unsigned int	_Bits_per_scalar_element
	)

inlineprivate

     {
         if (_Bits_per_scalar_element != 8 && _Bits_per_scalar_element != 16 && 
             _Bits_per_scalar_element != 32 && _Bits_per_scalar_element != 64)
         {
             throw runtime_exception("Invalid _Bits_per_scalar_element argument - it can only be 8, 16, 32, or 64.", E_INVALIDARG);
         }
 
         // special cases for 64 and for double based textures
 
 #pragma warning( push )
 #pragma warning( disable : 4127 ) // conditional expression is constant
         if (_Bits_per_scalar_element == 64 && _Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Double_type)
         {
             throw runtime_exception("Invalid _Bits_per_scalar_element argument - 64 is only valid for texture of double based short vector types.", E_INVALIDARG);
         }
 
         if (_Bits_per_scalar_element != 64 && _Short_vector_type_traits<_Value_type>::_Format_base_type_id == _Double_type)
         {
             throw runtime_exception("Invalid _Bits_per_scalar_element argument - it can only be 64 for texture of double based short vector types.", E_INVALIDARG);
         }
 
         details::_Is_valid_data_length(_M_extent.size(), _Bits_per_scalar_element * _Short_vector_type_traits<_Value_type>::_Num_channels);
 
         // the rest of the check is done by _Texture::_Create_texture, it depends on the underlying supported DXGI formats.
 
         unsigned int _Bits_per_channel = _Bits_per_scalar_element;
 
         if (_Short_vector_type_traits<_Value_type>::_Format_base_type_id == _Double_type)
         {
             _Bits_per_channel = _Short_vector_type_traits<_Value_type>::_Default_bits_per_channel;
         }
 
         std::array<size_t, 3> _Dimensions = Concurrency::graphics::details::_Get_dimensions(_M_extent, /*_Mip_offset=*/0);
 
         // release the old texture first before allocating new one to avoid the chance on hitting OOM
         _M_texture_descriptor._Set_texture_ptr(NULL);
         _Texture_ptr _Tex_ptr = NULL;
 
         // See if we need to allocate a staging texture
         if (_Should_create_staging_texture(_Av, _Associated_av)) {
 
             if (_M_texture_descriptor._Get_view_mipmap_levels() > 1)
             {
                 throw runtime_exception("Creating staging textures with mipmap levels > 1 is not supported", E_INVALIDARG);
             }
 
             _Tex_ptr = _Texture::_Create_stage_texture(
                 _Associated_av, _Av, _Rank, _Dimensions[0], _Dimensions[1], _Dimensions[2], _M_texture_descriptor._Get_view_mipmap_levels(),
                 _Short_vector_type_traits<_Value_type>::_Format_base_type_id == _Double_type ? _Uint_type : _Short_vector_type_traits<_Value_type>::_Format_base_type_id,
                 _Short_vector_type_traits<_Value_type>::_Num_channels,
                 _Bits_per_channel);
 
             // Now map the texture
             _Tex_ptr->_Map_buffer(_Write_access, true /* _Wait */);
         }
         else {
             _Tex_ptr = _Texture::_Create_texture(_Av, _Rank, _Dimensions[0], _Dimensions[1], _Dimensions[2], _M_texture_descriptor._Get_view_mipmap_levels(),
                 _Short_vector_type_traits<_Value_type>::_Format_base_type_id == _Double_type ? _Uint_type : _Short_vector_type_traits<_Value_type>::_Format_base_type_id,
                 _Short_vector_type_traits<_Value_type>::_Num_channels,
                 _Bits_per_channel);
         }
 
         _M_texture_descriptor._Set_texture_ptr(_Tex_ptr);
 #pragma warning( pop )
     }

template<typename _Value_type, int _Rank>

void Concurrency::graphics::texture< _Value_type, _Rank >::_Initialize	(	const Concurrency::accelerator_view &	_Av,
		unsigned int	_Bits_per_scalar_element
	)

inlineprivate

     {
         _Initialize(_Av, _Av, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

void Concurrency::graphics::texture< _Value_type, _Rank >::_Initialize	(	const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av
	)

inlineprivate

     {
         _Initialize(_Av, _Associated_av, Concurrency::graphics::details::_Get_default_bits_per_scalar_element<_Value_type>());
     }

template<typename _Value_type, int _Rank>

void Concurrency::graphics::texture< _Value_type, _Rank >::_Initialize ( const Concurrency::accelerator_view & _Av )

inlineprivate

     {
         _Initialize(_Av, _Av);
     }

template<typename _Value_type, int _Rank>

template<typename _Input_iterator >

void Concurrency::graphics::texture< _Value_type, _Rank >::_Initialize	(	const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av,
		_Input_iterator	_Src_first,
		_Input_iterator	_Src_last
	)

inlineprivate

     {
         _Initialize(_Av, _Associated_av);
 
         auto _Span_id = Concurrency::details::_Get_amp_trace()->_Start_copy_event_helper(nullptr,
                                                                                          Concurrency::details::_Get_texture_descriptor(*this),
                                                                                          this->get_data_length());
 
         Concurrency::graphics::details::_Copy_async_impl(_Src_first, _Src_last, *this, index<_Rank>(), this->extent)._Get();
 
         Concurrency::details::_Get_amp_trace()->_Write_end_event(_Span_id);
     }

template<typename _Value_type, int _Rank>

template<typename _Input_iterator >

void Concurrency::graphics::texture< _Value_type, _Rank >::_Initialize	(	const Concurrency::accelerator_view &	_Av,
		_Input_iterator	_Src_first,
		_Input_iterator	_Src_last
	)

inlineprivate

     {
         _Initialize(_Av, _Av, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank>

void Concurrency::graphics::texture< _Value_type, _Rank >::_Initialize	(	const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av,
		const void *	_Source,
		unsigned int	_Src_byte_size,
		unsigned int	_Bits_per_scalar_element
	)

inlineprivate

     {
         _Initialize(_Av, _Associated_av, _Bits_per_scalar_element);
         Concurrency::graphics::copy(_Source, _Src_byte_size, *this);
     }

template<typename _Value_type, int _Rank>

void Concurrency::graphics::texture< _Value_type, _Rank >::_Initialize	(	const Concurrency::accelerator_view &	_Av,
		const void *	_Source,
		unsigned int	_Src_byte_size,
		unsigned int	_Bits_per_scalar_element
	)

inlineprivate

     {
         _Initialize(_Av, _Av, _Source, _Src_byte_size, _Bits_per_scalar_element);
     }

template<typename _Value_type, int _Rank>

void Concurrency::graphics::texture< _Value_type, _Rank >::_Initialize	(	const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av,
		const void *	_Source,
		unsigned int	_Src_byte_size
	)

inlineprivate

     {
         _Initialize(_Av, _Associated_av);
         Concurrency::graphics::copy(_Source, _Src_byte_size, *this);
     }    

template<typename _Value_type, int _Rank>

void Concurrency::graphics::texture< _Value_type, _Rank >::_Initialize	(	const Concurrency::accelerator_view &	_Av,
		const void *	_Source,
		unsigned int	_Src_byte_size
	)

inlineprivate

     {
         _Initialize(_Av, _Av, _Source, _Src_byte_size);
     }    

template<typename _Value_type, int _Rank>

void Concurrency::graphics::texture< _Value_type, _Rank >::_Initialize	(	const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av,
		const details::_Texture_base< _Value_type, _Rank > &	_Src
	)

inlineprivate

     {
         if (_Src.bits_per_scalar_element != 0) // _Src is not created via interop
         {
             _Initialize(_Av, _Associated_av, _Src.bits_per_scalar_element);
         }
         else // _Src is created via interop, create a new texture with the same properties as the existing one.
         {
             _Texture_ptr _New_tex;
             if (_Should_create_staging_texture(_Av, _Associated_av))
             {
                  _New_tex = _Texture::_Clone_texture(concurrency::details::_Get_texture(_Src), _Associated_av, _Av);
             }
             else
             {
                 _New_tex = _Texture::_Clone_texture(concurrency::details::_Get_texture(_Src),  _Av, _Associated_av);
             }
             _M_texture_descriptor._Set_texture_ptr(_New_tex);
         }
 
         auto _Span_id = Concurrency::details::_Get_amp_trace()->_Start_copy_event_helper(Concurrency::details::_Get_texture_descriptor(_Src),
                                                                                          Concurrency::details::_Get_texture_descriptor(*this),
                                                                                          this->get_data_length());
 
         Concurrency::graphics::details::_Copy_async_impl(_Src, index<_Rank>(), *this, index<_Rank>(), this->extent)._Get();
 
         Concurrency::details::_Get_amp_trace()->_Write_end_event(_Span_id);
     }

template<typename _Value_type, int _Rank>

void Concurrency::graphics::texture< _Value_type, _Rank >::_Initialize	(	const Concurrency::accelerator_view &	_Av,
		const details::_Texture_base< _Value_type, _Rank > &	_Src
	)

inlineprivate

     {
         _Initialize(_Av, _Av, _Src);
     }

template<typename _Value_type, int _Rank>

bool Concurrency::graphics::texture< _Value_type, _Rank >::_Should_create_staging_texture	(	const Concurrency::accelerator_view &	_Av,
		const Concurrency::accelerator_view &	_Associated_av
	)

inlineprivate

     {
         return (_Is_cpu_accelerator(_Av.accelerator) && !_Is_cpu_accelerator(_Associated_av.accelerator));
     }

template<typename _Value_type, int _Rank>

void Concurrency::graphics::texture< _Value_type, _Rank >::copy_to ( texture< _Value_type, _Rank > & _Dest ) const

inline

Copy-to, deep copy

Parameters

_Dest The destination texture to copy to.

     {
         if (this->extent != _Dest.extent)
         {
             throw runtime_exception("The source and destination textures must have the exactly the same extent.", E_INVALIDARG);
         }
 
         auto _Span_id = concurrency::details::_Get_amp_trace()->_Start_copy_event_helper(concurrency::details::_Get_texture_descriptor(*this),
                                                                             concurrency::details::_Get_texture_descriptor(_Dest),
                                                                             this->get_data_length());
 
         _Texture_base::_Copy_to(_Dest);
 
         concurrency::details::_Get_amp_trace()->_Write_end_event(_Span_id);
     }

template<typename _Value_type, int _Rank>

void Concurrency::graphics::texture< _Value_type, _Rank >::copy_to ( const writeonly_texture_view< _Value_type, _Rank > & _Dest ) const

inline

Copy-to, deep copy

Parameters

_Dest The destination writeonly_texture_view to copy to.

     {
         if (this->extent != _Dest.extent)
         {
             throw runtime_exception("The source and destination textures must have the exactly the same extent.", E_INVALIDARG);
         }
 
         auto _Span_id = concurrency::details::_Get_amp_trace()->_Start_copy_event_helper(concurrency::details::_Get_texture_descriptor(*this),
                                                                             concurrency::details::_Get_texture_descriptor(_Dest),
                                                                             this->get_data_length());
 
         _Texture_base::_Copy_to(_Dest);
 
         concurrency::details::_Get_amp_trace()->_Write_end_event(_Span_id);
     }

template<typename _Value_type, int _Rank>

_Ret_ void* Concurrency::graphics::texture< _Value_type, _Rank >::data ( )

inline

Returns a CPU pointer to the raw data of this texture.

     {
         return _Get_texture()->_Get_host_ptr();
     }

template<typename _Value_type, int _Rank>

const void* Concurrency::graphics::texture< _Value_type, _Rank >::data ( ) const

inline

Returns a CPU pointer to the raw data of this texture.

     {
         return _Get_texture()->_Get_host_ptr();
     }

template<typename _Value_type, int _Rank>

const value_type Concurrency::graphics::texture< _Value_type, _Rank >::get ( const index< _Rank > & _Index ) const

inline

Get the element value indexed by _Index.

Parameters

_Index The index.

Returns: The element value indexed by _Index.

     {
         return (*this)[_Index];
     }

template<typename _Value_type, int _Rank>

__declspec (property(get=get_associated_accelerator_view)) Concurrency Concurrency::accelerator_view Concurrency::graphics::texture< _Value_type, _Rank >::get_associated_accelerator_view ( ) const

inline

Returns the accelerator_view that is the preferred target where this texture can be copied.

     {
         return _Get_texture()->_Get_accelerator_view();
     }

template<typename _Value_type, int _Rank>

unsigned int Concurrency::graphics::texture< _Value_type, _Rank >::get_depth_pitch ( ) const

inline

     {
         static_assert(_Rank == 3, "depth_pitch is only applicable to staging textures with rank 3.");
 
         if (!_Get_texture()->_Is_staging()) {
             throw runtime_exception("depth_pitch is only applicable to staging textures.", E_INVALIDARG);
         }
 
         return static_cast<unsigned int>(_Get_texture()->_Get_depth_pitch());
     }

template<typename _Value_type, int _Rank>

unsigned int Concurrency::graphics::texture< _Value_type, _Rank >::get_row_pitch ( ) const

inline

     {
         static_assert(_Rank >= 2, "row_pitch is only applicable to staging textures with rank 2 or higher.");
 
         if (!_Get_texture()->_Is_staging()) {
             throw runtime_exception("row_pitch is only applicable to staging textures.", E_INVALIDARG);
         }
 
         return static_cast<unsigned int>(_Get_texture()->_Get_row_pitch());
     }

template<typename _Value_type, int _Rank>

const value_type Concurrency::graphics::texture< _Value_type, _Rank >::operator() ( const index< _Rank > & _Index ) const

inline

Get the element value indexed by _Index.

Parameters

_Index The index.

Returns: The element value indexed by _Index.

     {
         return (*this)[_Index];
     }

template<typename _Value_type, int _Rank>

const value_type Concurrency::graphics::texture< _Value_type, _Rank >::operator() ( int _I0 ) const

inline

Get the element value indexed by _I0

Parameters

_I0	The index.

Returns: The element value indexed by _I0.

     {
         static_assert(_Rank == 1, "value_type texture::operator()(int) is only permissible on texture<value_type, 1>.");
         return (*this)[index<1>(_I0)];
     }

template<typename _Value_type, int _Rank>

const value_type Concurrency::graphics::texture< _Value_type, _Rank >::operator()	(	int	_I0,
		int	_I1
	)		const

inline

Get the element value indexed by (_I0,_I1)

Parameters

_I0	The most-significant component of the index
_I1	The least-significant component of the index

Returns: The element value indexed by (_I0,_I1)

     {
         static_assert(_Rank == 2, "value_type texture::operator()(int, int) is only permissible on texture<value_type, 2>.");
         return (*this)[index<2>(_I0, _I1)];
     }

template<typename _Value_type, int _Rank>

const value_type Concurrency::graphics::texture< _Value_type, _Rank >::operator()	(	int	_I0,
		int	_I1,
		int	_I2
	)		const

inline

Get the element value indexed by (_I0,_I1,_I2)

Parameters

_I0	The most-significant component of the index
_I1	The next-to-most-significant component of the index
_I2	The least-significant component of the index

Returns: The element value indexed by (_I0,_I1,_I2)

     {
         static_assert(_Rank == 3, "value_type texture::operator()(int, int, int) is only permissible on texture<value_type, 3>.");
         return (*this)[index<3>(_I0, _I1, _I2)];
     }

template<typename _Value_type, int _Rank>

texture& Concurrency::graphics::texture< _Value_type, _Rank >::operator= ( const texture< _Value_type, _Rank > & _Other )

inline

Copy assignment operator. Deep copy

Parameters

_Src	The texture to copy from.

Returns: A reference to this texture.

     {
         if (this != &_Other)
         {
             _M_extent = _Other._M_extent;
             _M_texture_descriptor._Set_view_mipmap_levels(_Other.get_mipmap_levels());
             _Initialize(_Other.accelerator_view, _Other.associated_accelerator_view, _Other);
         }
         return *this;
     }

template<typename _Value_type, int _Rank>

texture& Concurrency::graphics::texture< _Value_type, _Rank >::operator= ( texture< _Value_type, _Rank > && _Other )

inline

Move assignment operator

Parameters

_Other The source texture to move from.

Returns: A reference to this texture.

     {
         if (this != &_Other)
         {
             _M_extent = _Other._M_extent;
             _M_texture_descriptor = _Other._M_texture_descriptor;
 
             _Other._M_texture_descriptor._M_data_ptr = NULL;
             _Other._M_texture_descriptor._Set_texture_ptr(NULL);
         }
         return *this;
     }

template<typename _Value_type, int _Rank>

const value_type Concurrency::graphics::texture< _Value_type, _Rank >::operator[] ( const index< _Rank > & _Index ) const

inline

Get the element value indexed by _Index.

Parameters

_Index The index.

Returns: The element value indexed by _Index.

     {
         value_type _Tmp;
         _Texture_read_helper<index<_Rank>, _Rank>::func(_M_texture_descriptor._M_data_ptr, &_Tmp, _Index, /*_Mip_level=*/0);
         return _Tmp;
     }

template<typename _Value_type, int _Rank>

const value_type Concurrency::graphics::texture< _Value_type, _Rank >::operator[] ( int _I0 ) const

inline

Get the element value indexed by _I.

Parameters

_I	The index.

Returns: The element value indexed by _I.

     {
         static_assert(_Rank == 1, "value_type texture::operator[](int) is only permissible on texture<value_type, 1>.");
         return (*this)[index<1>(_I0)];
     }

template<typename _Value_type, int _Rank>

void Concurrency::graphics::texture< _Value_type, _Rank >::set	(	const index< _Rank > &	_Index,
		const value_type &	_Value
	)

inline

Set the element indexed by _Index with value _Value.

Parameters

_Index	The index.
_Value	The value to be set to the element indexed by _Index.

     {
         static_assert(_Short_vector_type_traits<_Value_type>::_Num_channels == 1, "Invalid value_type for set method.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "Invalid value_type for set method.");
         static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "Invalid value_type for set method.");
         _Texture_write_helper<index<_Rank>, _Rank>::func(_M_texture_descriptor._M_data_ptr, &_Value, _Index);
     }

Friends And Related Function Documentation

template<typename _Value_type, int _Rank>

template<typename _Value_type , int _Rank>

texture<_Value_type,_Rank> direct3d::make_texture	(	const Concurrency::accelerator_view &	_Av,
		_In_ IUnknown *	_D3D_texture,
		DXGI_FORMAT	_View_format
	)

friend

The documentation for this class was generated from the following file:

VS2013/inc/amp_graphics.h

Public Member Functions

Private Member Functions

Friends

Additional Inherited Members

Detailed Description

template<typename _Value_type, int _Rank> class Concurrency::graphics::texture< _Value_type, _Rank >

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

template<typename _Value_type, int _Rank>
class Concurrency::graphics::texture< _Value_type, _Rank >