Concurrency::graphics Namespace Reference

Namespaces
	details
	direct3d

Classes
class	double_2
	Represent a short vector of 2 doubles. More...
class	double_3
	Represent a short vector of 3 doubles. More...
class	double_4
	Represent a short vector of 4 doubles. More...
class	float_2
	Represent a short vector of 2 floats. More...
class	float_3
	Represent a short vector of 3 floats. More...
class	float_4
	Represent a short vector of 4 floats. More...
class	int_2
	Represent a short vector of 2 ints. More...
class	int_3
	Represent a short vector of 3 ints. More...
class	int_4
	Represent a short vector of 4 ints. More...
class	norm
	Represent a norm number. Each element is a floating point number in the range of [-1.0f, 1.0f]. More...
class	norm_2
	Represent a short vector of 2 norms. More...
class	norm_3
	Represent a short vector of 3 norms. More...
class	norm_4
	Represent a short vector of 4 norms. More...
class	sampler
	A sampler class aggregates sampling configuration information to be used for texture sampling. More...
struct	short_vector
	short_vector provides metaprogramming definitions which are useful for programming short vectors generically. More...
struct	short_vector< double, 1 >
struct	short_vector< double, 2 >
struct	short_vector< double, 3 >
struct	short_vector< double, 4 >
struct	short_vector< float, 1 >
struct	short_vector< float, 2 >
struct	short_vector< float, 3 >
struct	short_vector< float, 4 >
struct	short_vector< int, 1 >
struct	short_vector< int, 2 >
struct	short_vector< int, 3 >
struct	short_vector< int, 4 >
struct	short_vector< norm, 1 >
struct	short_vector< norm, 2 >
struct	short_vector< norm, 3 >
struct	short_vector< norm, 4 >
struct	short_vector< unorm, 1 >
struct	short_vector< unorm, 2 >
struct	short_vector< unorm, 3 >
struct	short_vector< unorm, 4 >
struct	short_vector< unsigned int, 1 >
struct	short_vector< unsigned int, 2 >
struct	short_vector< unsigned int, 3 >
struct	short_vector< unsigned int, 4 >
struct	short_vector_traits
	short_vector_traits allows retrieval of the underlying vector length and scalar type of a short vector type or a scalar type More...
struct	short_vector_traits< double >
struct	short_vector_traits< double_2 >
struct	short_vector_traits< double_3 >
struct	short_vector_traits< double_4 >
struct	short_vector_traits< float >
struct	short_vector_traits< float_2 >
struct	short_vector_traits< float_3 >
struct	short_vector_traits< float_4 >
struct	short_vector_traits< int >
struct	short_vector_traits< int_2 >
struct	short_vector_traits< int_3 >
struct	short_vector_traits< int_4 >
struct	short_vector_traits< norm >
struct	short_vector_traits< norm_2 >
struct	short_vector_traits< norm_3 >
struct	short_vector_traits< norm_4 >
struct	short_vector_traits< uint_2 >
struct	short_vector_traits< uint_3 >
struct	short_vector_traits< uint_4 >
struct	short_vector_traits< unorm >
struct	short_vector_traits< unorm_2 >
struct	short_vector_traits< unorm_3 >
struct	short_vector_traits< unorm_4 >
struct	short_vector_traits< unsigned int >
class	texture
	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...
class	texture_view
	A texture_view provides read and write access to a texture. Note that currently texture_view can only be used to read textures whose value type is int, unsigned int and float with default 32 bit bpse. To read other texture formats, use texture_view<const _Value_type, _Rank>. More...
class	texture_view< const _Value_type, _Rank >
	A texture_view<const _Value_type, _Rank> provides read-only access and sampling capability to a texture. More...
class	uint_2
	Represent a short vector of 2 unsigned ints. More...
class	uint_3
	Represent a short vector of 3 unsigned ints. More...
class	uint_4
	Represent a short vector of 4 unsigned ints. More...
class	unorm
	Represent a unorm number. Each element is a floating point number in the range of [0.0f, 1.0f]. More...
class	unorm_2
	Represent a short vector of 2 unorms. More...
class	unorm_3
	Represent a short vector of 3 unorms. More...
class	unorm_4
	Represent a short vector of 4 unorms. More...
class	writeonly_texture_view

Typedefs
typedef unsigned int	uint

Enumerations
enum	filter_mode { filter_point = 0, filter_linear = 0x15, filter_unknown = 0xFFFFFFFF }
	filter modes supported for texture sampling More...
enum	address_mode {   address_wrap = 1, address_mirror = 2, address_clamp = 3, address_border = 4,   address_unknown = 0xFFFFFFFF }
	address modes supported for texture sampling More...

Functions
template<typename _Value_type , int _Rank>
class	__declspec (deprecated("writeonly_texture_view is deprecated. Please use texture_view instead.")) writeonly_texture_view
	A writeonly_texture_view provides writeonly access to a texture. More...
template<typename _Src_type , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture, void>::type>
void	copy (const _Src_type &_Src, _Out_ void *_Dst, unsigned int _Dst_byte_size)
	Copies the contents of the source texture into the destination host buffer. More...
template<typename _Src_type , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture, void>::type>
void	copy (const _Src_type &_Src, const index< _Src_type::rank > &_Src_offset, const extent< _Src_type::rank > &_Copy_extent, _Out_ void *_Dst, unsigned int _Dst_byte_size)
	Copies the contents of a section of the source texture into the destination host buffer. More...
template<typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Dst_type>::is_texture, void>::type>
void	copy (const void *_Src, unsigned int _Src_byte_size, _Dst_type &_Dst)
	Copies the contents of the source host buffer into the destination texture _Dst. More...
template<typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Dst_type>::is_texture, void>::type>
void	copy (const void *_Src, unsigned int _Src_byte_size, _Dst_type &_Dst, const index< _Dst_type::rank > &_Dst_offset, const extent< _Dst_type::rank > &_Copy_extent)
	Copies the contents of the source host buffer into a section of the destination texture _Dst. More...
template<typename _Src_type , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture, void>::type>
concurrency::completion_future	copy_async (const _Src_type &_Src, _Out_ void *_Dst, unsigned int _Dst_byte_size)
	Asynchronously copies the contents of the source texture into the destination host buffer. More...
template<typename _Src_type , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture, void>::type>
concurrency::completion_future	copy_async (const _Src_type &_Src, const index< _Src_type::rank > &_Src_offset, const extent< _Src_type::rank > &_Copy_extent, _Out_ void *_Dst, unsigned int _Dst_byte_size)
	Asynchronously copies the contents of the provided section of the source texture into the destination host buffer. More...
template<typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Dst_type>::is_texture, void>::type>
concurrency::completion_future	copy_async (const void *_Src, unsigned int _Src_byte_size, _Dst_type &_Dst)
	Asynchronously copies the contents of the source host buffer into the destination texture _Dst. More...
template<typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Dst_type>::is_texture, void>::type>
concurrency::completion_future	copy_async (const void *_Src, unsigned int _Src_byte_size, _Dst_type &_Dst, const index< _Dst_type::rank > &_Dst_offset, const extent< _Dst_type::rank > &_Copy_extent)
	Asynchronously copies the contents of the source host buffer into a section of the destination texture _Dst. More...
template<typename InputIterator , typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Dst_type>::is_texture, void>::type>
void	copy (InputIterator _First, InputIterator _Last, _Dst_type &_Dst)
	Copies data from the pair of source iterators into the destination texture _Dst. More...
template<typename InputIterator , typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Dst_type>::is_texture, void>::type>
void	copy (InputIterator _First, InputIterator _Last, _Dst_type &_Dst, const index< _Dst_type::rank > &_Dst_offset, const extent< _Dst_type::rank > &_Copy_extent)
	Copies data from the pair of source iterators into a section of the destination texture _Dst. More...
template<typename _Src_type , typename OutputIterator , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture && !details::texture_traits<OutputIterator>::is_texture, void>::type>
void	copy (const _Src_type &_Src, OutputIterator _Dst)
	Copies data from the source texture _Src into an output iterator. More...
template<typename _Src_type , typename OutputIterator , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture && !details::texture_traits<OutputIterator>::is_texture, void>::type>
void	copy (const _Src_type &_Src, const index< _Src_type::rank > &_Src_offset, const extent< _Src_type::rank > &_Copy_extent, OutputIterator _Dst)
	Copies data from a section of the source texture _Src into an output iterator. More...
template<typename _Src_type , typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture && details::texture_traits<_Dst_type>::is_texture, void>::type>
void	copy (const _Src_type &_Src, _Dst_type &_Dst)
	Copies data from the source texture _Src into the destination texture _Dst. More...
template<typename _Src_type , typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture && details::texture_traits<_Dst_type>::is_texture, void>::type>
void	copy (const _Src_type &_Src, const index< _Src_type::rank > &_Src_offset, _Dst_type &_Dst, const index< _Dst_type::rank > &_Dst_offset, const extent< _Src_type::rank > &_Copy_extent)
	Copies data from a section of the source texture _Src into a section of the destination texture _Dst. More...
template<typename InputIterator , typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Dst_type>::is_texture, void>::type>
concurrency::completion_future	copy_async (InputIterator _First, InputIterator _Last, _Dst_type &_Dst)
	Asynchronously copies data from the pair of source iterators into the destination texture _Dst. More...
template<typename InputIterator , typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Dst_type>::is_texture, void>::type>
concurrency::completion_future	copy_async (InputIterator _First, InputIterator _Last, _Dst_type &_Dst, const index< _Dst_type::rank > &_Dst_offset, const extent< _Dst_type::rank > &_Copy_extent)
	Asynchronously copies data from the pair of source iterators into a section of the destination texture _Dst. More...
template<typename _Src_type , typename OutputIterator , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture && !details::texture_traits<OutputIterator>::is_texture, void>::type>
concurrency::completion_future	copy_async (_Src_type &_Src, OutputIterator _Dst)
	Asynchronously copies data from the source texture _Src into an output iterator. More...
template<typename _Src_type , typename OutputIterator , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture && !details::texture_traits<OutputIterator>::is_texture, void>::type>
concurrency::completion_future	copy_async (_Src_type &_Src, const index< _Src_type::rank > &_Src_offset, const extent< _Src_type::rank > &_Copy_extent, OutputIterator _Dst)
	Asynchronously copies data from a section of the source texture _Src into an output iterator. More...
template<typename _Src_type , typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture && details::texture_traits<_Dst_type>::is_texture, void>::type>
concurrency::completion_future	copy_async (_Src_type &_Src, _Dst_type &_Dst)
	Asynchronously copies data from the source texture _Src into the destination texture _Dst. More...
template<typename _Src_type , typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture && details::texture_traits<_Dst_type>::is_texture, void>::type>
concurrency::completion_future	copy_async (_Src_type &_Src, const index< _Src_type::rank > &_Src_offset, _Dst_type &_Dst, const index< _Dst_type::rank > &_Dst_offset, const extent< _Src_type::rank > &_Copy_extent)
	Asynchronously copies data from a section of the source texture _Src into the destination texture _Dst. More...
unorm	operator+ (const unorm &_Lhs, const unorm &_Rhs) __GPU
norm	operator+ (const norm &_Lhs, const norm &_Rhs) __GPU
unorm	operator- (const unorm &_Lhs, const unorm &_Rhs) __GPU
norm	operator- (const norm &_Lhs, const norm &_Rhs) __GPU
unorm	operator* (const unorm &_Lhs, const unorm &_Rhs) __GPU
norm	operator* (const norm &_Lhs, const norm &_Rhs) __GPU
unorm	operator/ (const unorm &_Lhs, const unorm &_Rhs) __GPU
norm	operator/ (const norm &_Lhs, const norm &_Rhs) __GPU
bool	operator== (const unorm &_Lhs, const unorm &_Rhs) __GPU
bool	operator== (const norm &_Lhs, const norm &_Rhs) __GPU
bool	operator!= (const unorm &_Lhs, const unorm &_Rhs) __GPU
bool	operator!= (const norm &_Lhs, const norm &_Rhs) __GPU
bool	operator> (const unorm &_Lhs, const unorm &_Rhs) __GPU
bool	operator> (const norm &_Lhs, const norm &_Rhs) __GPU
bool	operator< (const unorm &_Lhs, const unorm &_Rhs) __GPU
bool	operator< (const norm &_Lhs, const norm &_Rhs) __GPU
bool	operator>= (const unorm &_Lhs, const unorm &_Rhs) __GPU
bool	operator>= (const norm &_Lhs, const norm &_Rhs) __GPU
bool	operator<= (const unorm &_Lhs, const unorm &_Rhs) __GPU
bool	operator<= (const norm &_Lhs, const norm &_Rhs) __GPU
uint_2	operator+ (const uint_2 &_Lhs, const uint_2 &_Rhs) __GPU
uint_2	operator- (const uint_2 &_Lhs, const uint_2 &_Rhs) __GPU
uint_2	operator* (const uint_2 &_Lhs, const uint_2 &_Rhs) __GPU
uint_2	operator/ (const uint_2 &_Lhs, const uint_2 &_Rhs) __GPU
bool	operator== (const uint_2 &_Lhs, const uint_2 &_Rhs) __GPU
bool	operator!= (const uint_2 &_Lhs, const uint_2 &_Rhs) __GPU
uint_2	operator% (const uint_2 &_Lhs, const uint_2 &_Rhs) __GPU
uint_2	operator^ (const uint_2 &_Lhs, const uint_2 &_Rhs) __GPU
uint_2	operator| (const uint_2 &_Lhs, const uint_2 &_Rhs) __GPU
uint_2	operator& (const uint_2 &_Lhs, const uint_2 &_Rhs) __GPU
uint_2	operator<< (const uint_2 &_Lhs, const uint_2 &_Rhs) __GPU
uint_2	operator>> (const uint_2 &_Lhs, const uint_2 &_Rhs) __GPU
uint_3	operator+ (const uint_3 &_Lhs, const uint_3 &_Rhs) __GPU
uint_3	operator- (const uint_3 &_Lhs, const uint_3 &_Rhs) __GPU
uint_3	operator* (const uint_3 &_Lhs, const uint_3 &_Rhs) __GPU
uint_3	operator/ (const uint_3 &_Lhs, const uint_3 &_Rhs) __GPU
bool	operator== (const uint_3 &_Lhs, const uint_3 &_Rhs) __GPU
bool	operator!= (const uint_3 &_Lhs, const uint_3 &_Rhs) __GPU
uint_3	operator% (const uint_3 &_Lhs, const uint_3 &_Rhs) __GPU
uint_3	operator^ (const uint_3 &_Lhs, const uint_3 &_Rhs) __GPU
uint_3	operator| (const uint_3 &_Lhs, const uint_3 &_Rhs) __GPU
uint_3	operator& (const uint_3 &_Lhs, const uint_3 &_Rhs) __GPU
uint_3	operator<< (const uint_3 &_Lhs, const uint_3 &_Rhs) __GPU
uint_3	operator>> (const uint_3 &_Lhs, const uint_3 &_Rhs) __GPU
uint_4	operator+ (const uint_4 &_Lhs, const uint_4 &_Rhs) __GPU
uint_4	operator- (const uint_4 &_Lhs, const uint_4 &_Rhs) __GPU
uint_4	operator* (const uint_4 &_Lhs, const uint_4 &_Rhs) __GPU
uint_4	operator/ (const uint_4 &_Lhs, const uint_4 &_Rhs) __GPU
bool	operator== (const uint_4 &_Lhs, const uint_4 &_Rhs) __GPU
bool	operator!= (const uint_4 &_Lhs, const uint_4 &_Rhs) __GPU
uint_4	operator% (const uint_4 &_Lhs, const uint_4 &_Rhs) __GPU
uint_4	operator^ (const uint_4 &_Lhs, const uint_4 &_Rhs) __GPU
uint_4	operator| (const uint_4 &_Lhs, const uint_4 &_Rhs) __GPU
uint_4	operator& (const uint_4 &_Lhs, const uint_4 &_Rhs) __GPU
uint_4	operator<< (const uint_4 &_Lhs, const uint_4 &_Rhs) __GPU
uint_4	operator>> (const uint_4 &_Lhs, const uint_4 &_Rhs) __GPU
int_2	operator+ (const int_2 &_Lhs, const int_2 &_Rhs) __GPU
int_2	operator- (const int_2 &_Lhs, const int_2 &_Rhs) __GPU
int_2	operator* (const int_2 &_Lhs, const int_2 &_Rhs) __GPU
int_2	operator/ (const int_2 &_Lhs, const int_2 &_Rhs) __GPU
bool	operator== (const int_2 &_Lhs, const int_2 &_Rhs) __GPU
bool	operator!= (const int_2 &_Lhs, const int_2 &_Rhs) __GPU
int_2	operator% (const int_2 &_Lhs, const int_2 &_Rhs) __GPU
int_2	operator^ (const int_2 &_Lhs, const int_2 &_Rhs) __GPU
int_2	operator| (const int_2 &_Lhs, const int_2 &_Rhs) __GPU
int_2	operator& (const int_2 &_Lhs, const int_2 &_Rhs) __GPU
int_2	operator<< (const int_2 &_Lhs, const int_2 &_Rhs) __GPU
int_2	operator>> (const int_2 &_Lhs, const int_2 &_Rhs) __GPU
int_3	operator+ (const int_3 &_Lhs, const int_3 &_Rhs) __GPU
int_3	operator- (const int_3 &_Lhs, const int_3 &_Rhs) __GPU
int_3	operator* (const int_3 &_Lhs, const int_3 &_Rhs) __GPU
int_3	operator/ (const int_3 &_Lhs, const int_3 &_Rhs) __GPU
bool	operator== (const int_3 &_Lhs, const int_3 &_Rhs) __GPU
bool	operator!= (const int_3 &_Lhs, const int_3 &_Rhs) __GPU
int_3	operator% (const int_3 &_Lhs, const int_3 &_Rhs) __GPU
int_3	operator^ (const int_3 &_Lhs, const int_3 &_Rhs) __GPU
int_3	operator| (const int_3 &_Lhs, const int_3 &_Rhs) __GPU
int_3	operator& (const int_3 &_Lhs, const int_3 &_Rhs) __GPU
int_3	operator<< (const int_3 &_Lhs, const int_3 &_Rhs) __GPU
int_3	operator>> (const int_3 &_Lhs, const int_3 &_Rhs) __GPU
int_4	operator+ (const int_4 &_Lhs, const int_4 &_Rhs) __GPU
int_4	operator- (const int_4 &_Lhs, const int_4 &_Rhs) __GPU
int_4	operator* (const int_4 &_Lhs, const int_4 &_Rhs) __GPU
int_4	operator/ (const int_4 &_Lhs, const int_4 &_Rhs) __GPU
bool	operator== (const int_4 &_Lhs, const int_4 &_Rhs) __GPU
bool	operator!= (const int_4 &_Lhs, const int_4 &_Rhs) __GPU
int_4	operator% (const int_4 &_Lhs, const int_4 &_Rhs) __GPU
int_4	operator^ (const int_4 &_Lhs, const int_4 &_Rhs) __GPU
int_4	operator| (const int_4 &_Lhs, const int_4 &_Rhs) __GPU
int_4	operator& (const int_4 &_Lhs, const int_4 &_Rhs) __GPU
int_4	operator<< (const int_4 &_Lhs, const int_4 &_Rhs) __GPU
int_4	operator>> (const int_4 &_Lhs, const int_4 &_Rhs) __GPU
float_2	operator+ (const float_2 &_Lhs, const float_2 &_Rhs) __GPU
float_2	operator- (const float_2 &_Lhs, const float_2 &_Rhs) __GPU
float_2	operator* (const float_2 &_Lhs, const float_2 &_Rhs) __GPU
float_2	operator/ (const float_2 &_Lhs, const float_2 &_Rhs) __GPU
bool	operator== (const float_2 &_Lhs, const float_2 &_Rhs) __GPU
bool	operator!= (const float_2 &_Lhs, const float_2 &_Rhs) __GPU
float_3	operator+ (const float_3 &_Lhs, const float_3 &_Rhs) __GPU
float_3	operator- (const float_3 &_Lhs, const float_3 &_Rhs) __GPU
float_3	operator* (const float_3 &_Lhs, const float_3 &_Rhs) __GPU
float_3	operator/ (const float_3 &_Lhs, const float_3 &_Rhs) __GPU
bool	operator== (const float_3 &_Lhs, const float_3 &_Rhs) __GPU
bool	operator!= (const float_3 &_Lhs, const float_3 &_Rhs) __GPU
float_4	operator+ (const float_4 &_Lhs, const float_4 &_Rhs) __GPU
float_4	operator- (const float_4 &_Lhs, const float_4 &_Rhs) __GPU
float_4	operator* (const float_4 &_Lhs, const float_4 &_Rhs) __GPU
float_4	operator/ (const float_4 &_Lhs, const float_4 &_Rhs) __GPU
bool	operator== (const float_4 &_Lhs, const float_4 &_Rhs) __GPU
bool	operator!= (const float_4 &_Lhs, const float_4 &_Rhs) __GPU
unorm_2	operator+ (const unorm_2 &_Lhs, const unorm_2 &_Rhs) __GPU
unorm_2	operator- (const unorm_2 &_Lhs, const unorm_2 &_Rhs) __GPU
unorm_2	operator* (const unorm_2 &_Lhs, const unorm_2 &_Rhs) __GPU
unorm_2	operator/ (const unorm_2 &_Lhs, const unorm_2 &_Rhs) __GPU
bool	operator== (const unorm_2 &_Lhs, const unorm_2 &_Rhs) __GPU
bool	operator!= (const unorm_2 &_Lhs, const unorm_2 &_Rhs) __GPU
unorm_3	operator+ (const unorm_3 &_Lhs, const unorm_3 &_Rhs) __GPU
unorm_3	operator- (const unorm_3 &_Lhs, const unorm_3 &_Rhs) __GPU
unorm_3	operator* (const unorm_3 &_Lhs, const unorm_3 &_Rhs) __GPU
unorm_3	operator/ (const unorm_3 &_Lhs, const unorm_3 &_Rhs) __GPU
bool	operator== (const unorm_3 &_Lhs, const unorm_3 &_Rhs) __GPU
bool	operator!= (const unorm_3 &_Lhs, const unorm_3 &_Rhs) __GPU
unorm_4	operator+ (const unorm_4 &_Lhs, const unorm_4 &_Rhs) __GPU
unorm_4	operator- (const unorm_4 &_Lhs, const unorm_4 &_Rhs) __GPU
unorm_4	operator* (const unorm_4 &_Lhs, const unorm_4 &_Rhs) __GPU
unorm_4	operator/ (const unorm_4 &_Lhs, const unorm_4 &_Rhs) __GPU
bool	operator== (const unorm_4 &_Lhs, const unorm_4 &_Rhs) __GPU
bool	operator!= (const unorm_4 &_Lhs, const unorm_4 &_Rhs) __GPU
norm_2	operator+ (const norm_2 &_Lhs, const norm_2 &_Rhs) __GPU
norm_2	operator- (const norm_2 &_Lhs, const norm_2 &_Rhs) __GPU
norm_2	operator* (const norm_2 &_Lhs, const norm_2 &_Rhs) __GPU
norm_2	operator/ (const norm_2 &_Lhs, const norm_2 &_Rhs) __GPU
bool	operator== (const norm_2 &_Lhs, const norm_2 &_Rhs) __GPU
bool	operator!= (const norm_2 &_Lhs, const norm_2 &_Rhs) __GPU
norm_3	operator+ (const norm_3 &_Lhs, const norm_3 &_Rhs) __GPU
norm_3	operator- (const norm_3 &_Lhs, const norm_3 &_Rhs) __GPU
norm_3	operator* (const norm_3 &_Lhs, const norm_3 &_Rhs) __GPU
norm_3	operator/ (const norm_3 &_Lhs, const norm_3 &_Rhs) __GPU
bool	operator== (const norm_3 &_Lhs, const norm_3 &_Rhs) __GPU
bool	operator!= (const norm_3 &_Lhs, const norm_3 &_Rhs) __GPU
norm_4	operator+ (const norm_4 &_Lhs, const norm_4 &_Rhs) __GPU
norm_4	operator- (const norm_4 &_Lhs, const norm_4 &_Rhs) __GPU
norm_4	operator* (const norm_4 &_Lhs, const norm_4 &_Rhs) __GPU
norm_4	operator/ (const norm_4 &_Lhs, const norm_4 &_Rhs) __GPU
bool	operator== (const norm_4 &_Lhs, const norm_4 &_Rhs) __GPU
bool	operator!= (const norm_4 &_Lhs, const norm_4 &_Rhs) __GPU
double_2	operator+ (const double_2 &_Lhs, const double_2 &_Rhs) __GPU
double_2	operator- (const double_2 &_Lhs, const double_2 &_Rhs) __GPU
double_2	operator* (const double_2 &_Lhs, const double_2 &_Rhs) __GPU
double_2	operator/ (const double_2 &_Lhs, const double_2 &_Rhs) __GPU
bool	operator== (const double_2 &_Lhs, const double_2 &_Rhs) __GPU
bool	operator!= (const double_2 &_Lhs, const double_2 &_Rhs) __GPU
double_3	operator+ (const double_3 &_Lhs, const double_3 &_Rhs) __GPU
double_3	operator- (const double_3 &_Lhs, const double_3 &_Rhs) __GPU
double_3	operator* (const double_3 &_Lhs, const double_3 &_Rhs) __GPU
double_3	operator/ (const double_3 &_Lhs, const double_3 &_Rhs) __GPU
bool	operator== (const double_3 &_Lhs, const double_3 &_Rhs) __GPU
bool	operator!= (const double_3 &_Lhs, const double_3 &_Rhs) __GPU
double_4	operator+ (const double_4 &_Lhs, const double_4 &_Rhs) __GPU
double_4	operator- (const double_4 &_Lhs, const double_4 &_Rhs) __GPU
double_4	operator* (const double_4 &_Lhs, const double_4 &_Rhs) __GPU
double_4	operator/ (const double_4 &_Lhs, const double_4 &_Rhs) __GPU
bool	operator== (const double_4 &_Lhs, const double_4 &_Rhs) __GPU
bool	operator!= (const double_4 &_Lhs, const double_4 &_Rhs) __GPU

Typedef Documentation

typedef unsigned int Concurrency::graphics::uint

Enumeration Type Documentation

enum Concurrency::graphics::address_mode

address modes supported for texture sampling

Enumerator
address_wrap
address_mirror
address_clamp
address_border
address_unknown

{
    address_wrap    = 1,
    address_mirror  = 2,
    address_clamp   = 3,
    address_border  = 4,
    address_unknown = 0xFFFFFFFF,
};

enum Concurrency::graphics::filter_mode

filter modes supported for texture sampling

Enumerator
filter_point
filter_linear
filter_unknown

{
    filter_point    = 0,
    filter_linear   = 0x15,
    filter_unknown  = 0xFFFFFFFF,
};

Function Documentation

template<typename _Value_type , int _Rank>

class Concurrency::graphics::__declspec

(

deprecated("writeonly_texture_view is deprecated. Please use texture_view instead.")

)

A writeonly_texture_view provides writeonly access to a texture.

Parameters

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

Construct a writeonly_texture_view of a texture _Src.

Parameters

_Src	The texture on which the writeonly view is created.

Construct a writeonly_texture_view of a texture _Src.

Parameters

_Src	The texture on which the writeonly view is created.

Construct a writeonly_texture_view from another writeonly_texture_view. Both are views of the same texture.

Parameters

_Src	The writeonly_texture_view from which the current view is created.

Assignment operator. This writeonly_texture_view becomes a view of the same texture which _Other is a view of.

Parameters

_Other

The source writeonly_texture_view.

Destructor

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.

                                                                                                                                                                         : public details::_Texture_base<_Value_type, _Rank>
{
    static_assert(!std::is_const<_Value_type>::value, "const value type is not supported for writeonly_texture_view.");

public:
    writeonly_texture_view(texture<_Value_type, _Rank>& _Src) __CPU_ONLY
        : _Texture_base(_Src, /*_Most_detailed_mipmap_level=*/0, /*_View_mipmap_levels=*/1)
    {
        _Texture* _Tex = this->_Get_texture();
        if ((_Tex->_Get_num_channels() == 3) && (_Tex->_Get_bits_per_channel() == 32)) {
            throw runtime_exception("writeonly_texture_view cannot be created from a 3-channel texture with 32 bits per scalar element.", E_INVALIDARG);
        }
        if (_Tex->_Is_staging()) {
            throw runtime_exception("writeonly_texture_view cannot be created from a staging texture object.", E_INVALIDARG);
        }
    }

    writeonly_texture_view(texture<_Value_type, _Rank>& _Src) __GPU_ONLY
        : _Texture_base(_Src, /*_Flatten_mipmap_levels=*/true)
    {
        static_assert(_Short_vector_type_traits<_Value_type>::_Num_channels == 1, "Invalid value_type for the constructor.");
        static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Unorm_type, "Invalid value_type for the constructor.");
        static_assert(_Short_vector_type_traits<_Value_type>::_Format_base_type_id != _Norm_type, "Invalid value_type for the constructor.");
    }

    writeonly_texture_view(const writeonly_texture_view<_Value_type, _Rank>& _Src) __GPU
        : _Texture_base(_Src)
    {
    }

    writeonly_texture_view<_Value_type, _Rank>& operator=(const writeonly_texture_view<_Value_type, _Rank>& _Other) __GPU
    {
        if (this != &_Other)
        {
            this->_M_extent = _Other._M_extent;
            this->_M_texture_descriptor = _Other._M_texture_descriptor;
        }
        return *this;
    }

    ~writeonly_texture_view() __GPU
    {
    }

    void set(const index<_Rank>& _Index, const _Value_type& _Value) const __GPU_ONLY
    {
        _Texture_write_helper<index<_Rank>, _Rank>::func(this->_M_texture_descriptor._M_data_ptr, &_Value, _Index);
    }
};

template<typename _Src_type , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture, void>::type>

void Concurrency::graphics::copy	(	const _Src_type &	_Src,
		_Out_ void *	_Dst,
		unsigned int	_Dst_byte_size
	)

Copies the contents of the source texture into the destination host buffer.

Parameters

_Rank	The rank of the source texture.
_Value_type	The type of the elements of the source texture.
_Src	The source texture or texture_view.
_Dst	The destination host buffer.
_Dst_byte_size	Number of bytes in the destination buffer.

{
    auto _Span_id = concurrency::details::_Get_amp_trace()->_Start_copy_event_helper(concurrency::details::_Get_texture_descriptor(_Src),
                                                                        nullptr,
                                                                        _Get_section_size(_Src, _Src.extent));

    details::_Copy_async_impl(_Src, index<_Src_type::rank>(), _Src.extent, _Dst, _Dst_byte_size)._Get();

    concurrency::details::_Get_amp_trace()->_Write_end_event(_Span_id);
}

template<typename _Src_type , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture, void>::type>

void Concurrency::graphics::copy	(	const _Src_type &	_Src,
		const index< _Src_type::rank > &	_Src_offset,
		const extent< _Src_type::rank > &	_Copy_extent,
		_Out_ void *	_Dst,
		unsigned int	_Dst_byte_size
	)

Copies the contents of a section of the source texture into the destination host buffer.

Parameters

_Rank	The rank of the source texture.
_Value_type	The type of the elements of the source texture.
_Src	The source texture or texture_view.
_Src_offset	The offset into the source texture from which to begin copying.
_Copy_extent	The extent of the texture section to copy.
_Dst	The destination host buffer.
_Dst_byte_size	Number of bytes in the destination buffer.

{
    auto _Span_id = concurrency::details::_Get_amp_trace()->_Start_copy_event_helper(concurrency::details::_Get_texture_descriptor(_Src),
                                                                        nullptr,
                                                                        _Get_section_size(_Src, _Copy_extent));

    details::_Copy_async_impl(_Src, _Src_offset, _Copy_extent, _Dst, _Dst_byte_size)._Get();

    concurrency::details::_Get_amp_trace()->_Write_end_event(_Span_id);
}

template<typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Dst_type>::is_texture, void>::type>

void Concurrency::graphics::copy	(	const void *	_Src,
		unsigned int	_Src_byte_size,
		_Dst_type &	_Dst
	)

Copies the contents of the source host buffer into the destination texture _Dst.

Parameters

_Rank	The rank of the destination texture.
_Dst_type	The type of the destination texture or texture_view.
_Src	The source host buffer.
_Src_byte_size	Number of bytes in the source buffer.
_Dst	The destination texture or texture_view.

{
    static_assert(details::texture_traits<_Dst_type>::is_writable, "Destination is not a writable texture type.");
    auto _Span_id = concurrency::details::_Get_amp_trace()->_Start_copy_event_helper(nullptr,
                                                                        concurrency::details::_Get_texture_descriptor(_Dst),
                                                                        _Get_section_size(_Dst, _Dst.extent));

    details::_Copy_async_impl(_Src, _Src_byte_size, _Dst, index<_Dst_type::rank>(), _Dst.extent)._Get();

    concurrency::details::_Get_amp_trace()->_Write_end_event(_Span_id);
}

template<typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Dst_type>::is_texture, void>::type>

void Concurrency::graphics::copy	(	const void *	_Src,
		unsigned int	_Src_byte_size,
		_Dst_type &	_Dst,
		const index< _Dst_type::rank > &	_Dst_offset,
		const extent< _Dst_type::rank > &	_Copy_extent
	)

Copies the contents of the source host buffer into a section of the destination texture _Dst.

Parameters

_Dst_type	The type of the destination texture or texture_view.
_Src	The source host buffer.
_Src_byte_size	Number of bytes in the source buffer.
_Dst	The destination texture or texture_view.
_Dst_offset	The offset into the destination texture to which to begin copying.
_Copy_extent	The extent of the texture section to copy.

{
    static_assert(details::texture_traits<_Dst_type>::is_writable, "Destination is not a writable texture type.");
    auto _Span_id = concurrency::details::_Get_amp_trace()->_Start_copy_event_helper(nullptr,
                                                                        concurrency::details::_Get_texture_descriptor(_Dst),
                                                                        _Get_section_size(_Dst, _Copy_extent));

    details::_Copy_async_impl(_Src, _Src_byte_size, _Dst, _Dst_offset, _Copy_extent)._Get();

    concurrency::details::_Get_amp_trace()->_Write_end_event(_Span_id);
}

template<typename InputIterator , typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Dst_type>::is_texture, void>::type>

void Concurrency::graphics::copy	(	InputIterator	_First,
		InputIterator	_Last,
		_Dst_type &	_Dst
	)

Copies data from the pair of source iterators into the destination texture _Dst.

Parameters

InputIterator	The input iterator type.
_Dst_type	The type of the destination texture.
_First	The starting iterator for the copy.
_Last	The ending iterator for the copy.
_Dst	The destination texture or texture_view.

{
    static_assert(details::texture_traits<_Dst_type>::is_writable, "Destination is not a writable texture type.");
    auto _Span_id = concurrency::details::_Get_amp_trace()->_Start_copy_event_helper(nullptr,
                                                                    concurrency::details::_Get_texture_descriptor(_Dst),
                                                                    _Get_section_size(_Dst, _Dst.extent));

    details::_Copy_async_impl(_First, _Last, _Dst, index<_Dst_type::rank>(), _Dst.extent)._Get();

    concurrency::details::_Get_amp_trace()->_Write_end_event(_Span_id);
}

template<typename InputIterator , typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Dst_type>::is_texture, void>::type>

void Concurrency::graphics::copy	(	InputIterator	_First,
		InputIterator	_Last,
		_Dst_type &	_Dst,
		const index< _Dst_type::rank > &	_Dst_offset,
		const extent< _Dst_type::rank > &	_Copy_extent
	)

Copies data from the pair of source iterators into a section of the destination texture _Dst.

Parameters

InputIterator	The input iterator type.
_Dst_type	The type of the destination texture.
_First	The starting iterator for the copy.
_Last	The ending iterator for the copy.
_Dst	The destination texture or texture_view.
_Dst_offset	The offset into the destination texture to which to begin copying.
_Copy_extent	The extent of the texture section to copy.

{
    static_assert(details::texture_traits<_Dst_type>::is_writable, "Destination is not a writable texture type.");
    auto _Span_id = concurrency::details::_Get_amp_trace()->_Start_copy_event_helper(nullptr,
                                                                    concurrency::details::_Get_texture_descriptor(_Dst),
                                                                    _Get_section_size(_Dst, _Copy_extent));

    details::_Copy_async_impl(_First, _Last, _Dst, _Dst_offset, _Copy_extent)._Get();

    concurrency::details::_Get_amp_trace()->_Write_end_event(_Span_id);
}

template<typename _Src_type , typename OutputIterator , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture && !details::texture_traits<OutputIterator>::is_texture, void>::type>

void Concurrency::graphics::copy	(	const _Src_type &	_Src,
		OutputIterator	_Dst
	)

Copies data from the source texture _Src into an output iterator.

Parameters

_Src_type	The type of the source texture.
OutputIterator	The output iterator type.
_Dst	The starting iterator for the copy output.

{
    auto _Span_id = concurrency::details::_Get_amp_trace()->_Start_copy_event_helper(concurrency::details::_Get_texture_descriptor(_Src),
                                                                    nullptr,
                                                                    _Get_section_size(_Src, _Src.extent));

    details::_Copy_async_impl(_Src, index<_Src_type::rank>(), _Src.extent, _Dst)._Get();

    concurrency::details::_Get_amp_trace()->_Write_end_event(_Span_id);
}

template<typename _Src_type , typename OutputIterator , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture && !details::texture_traits<OutputIterator>::is_texture, void>::type>

void Concurrency::graphics::copy	(	const _Src_type &	_Src,
		const index< _Src_type::rank > &	_Src_offset,
		const extent< _Src_type::rank > &	_Copy_extent,
		OutputIterator	_Dst
	)

Copies data from a section of the source texture _Src into an output iterator.

Parameters

_Src_type	The type of the source texture.
OutputIterator	The output iterator type.
_Src_offset	The offset into the source texture from which to begin copying.
_Copy_extent	The extent of the texture section to copy.
_Dst	The starting iterator for the copy output.

{
    auto _Span_id = concurrency::details::_Get_amp_trace()->_Start_copy_event_helper(concurrency::details::_Get_texture_descriptor(_Src),
                                                                    nullptr,
                                                                    _Get_section_size(_Src, _Copy_extent));

    details::_Copy_async_impl(_Src, _Src_offset, _Copy_extent, _Dst)._Get();

    concurrency::details::_Get_amp_trace()->_Write_end_event(_Span_id);
}

template<typename _Src_type , typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture && details::texture_traits<_Dst_type>::is_texture, void>::type>

void Concurrency::graphics::copy	(	const _Src_type &	_Src,
		_Dst_type &	_Dst
	)

Copies data from the source texture _Src into the destination texture _Dst.

Parameters

_Src_type	The type of the source texture.
_Dst_type	The type of the destination texture.
_Src	The source texture from which to copy.
_Dst	The destination texture into which to copy.

{
    static_assert(details::texture_traits<_Dst_type>::is_writable, "Destination is not a writable texture type.");

    if (_Src.extent != _Dst.extent)
    {
        throw runtime_exception("The source and destination textures must have the exactly the same extent for whole-texture copy.", E_INVALIDARG);
    }

    auto _Span_id = concurrency::details::_Get_amp_trace()->_Start_copy_event_helper(concurrency::details::_Get_texture_descriptor(_Src),
                                                                    concurrency::details::_Get_texture_descriptor(_Dst),
                                                                    _Get_section_size(_Dst, _Dst.extent));

    details::_Copy_async_impl(_Src, index<_Src_type::rank>(), _Dst, index<_Dst_type::rank>(), _Dst.extent)._Get();

    concurrency::details::_Get_amp_trace()->_Write_end_event(_Span_id);
}

template<typename _Src_type , typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture && details::texture_traits<_Dst_type>::is_texture, void>::type>

void Concurrency::graphics::copy	(	const _Src_type &	_Src,
		const index< _Src_type::rank > &	_Src_offset,
		_Dst_type &	_Dst,
		const index< _Dst_type::rank > &	_Dst_offset,
		const extent< _Src_type::rank > &	_Copy_extent
	)

Copies data from a section of the source texture _Src into a section of the destination texture _Dst.

Parameters

_Src_type	The type of the source texture.
_Dst_type	The type of the destination texture.
_Src	The source texture from which to copy.
_Src_offset	The offset into the source texture from which to begin copying.
_Dst	The destination texture into which to copy.
_Dst_offset	The offset into the destination texture to which to begin copying.
_Copy_extent	The extent of the texture section to copy.

{
    static_assert(details::texture_traits<_Dst_type>::is_writable, "Destination is not a writable texture type.");
    auto _Span_id = concurrency::details::_Get_amp_trace()->_Start_copy_event_helper(concurrency::details::_Get_texture_descriptor(_Src),
                                                                    concurrency::details::_Get_texture_descriptor(_Dst),
                                                                    _Get_section_size(_Src, _Copy_extent));

    details::_Copy_async_impl(_Src, _Src_offset, _Dst, _Dst_offset, _Copy_extent)._Get();

    concurrency::details::_Get_amp_trace()->_Write_end_event(_Span_id);
}

template<typename _Src_type , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture, void>::type>

concurrency::completion_future Concurrency::graphics::copy_async	(	const _Src_type &	_Src,
		_Out_ void *	_Dst,
		unsigned int	_Dst_byte_size
	)

Asynchronously copies the contents of the source texture into the destination host buffer.

Parameters

_Rank	The rank of the source texture.
_Src_type	The type of the source texture.
_Src	The source texture or texture_view.
_Dst	The destination host buffer.
_Dst_byte_size	Number of bytes in the destination buffer.

Returns

A future upon which to wait for the operation to complete.

{
    auto _Async_op_id = concurrency::details::_Get_amp_trace()->_Launch_async_copy_event_helper(concurrency::details::_Get_texture_descriptor(_Src),
                                                                                   nullptr,
                                                                                   _Get_section_size(_Src, _Src.extent));

    _Event _Ev = details::_Copy_async_impl(_Src, index<_Src_type::rank>(), _Src.extent, _Dst, _Dst_byte_size);

    return concurrency::details::_Get_amp_trace()->_Start_async_op_wait_event_helper(_Async_op_id, _Ev);
}

template<typename _Src_type , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture, void>::type>

concurrency::completion_future Concurrency::graphics::copy_async	(	const _Src_type &	_Src,
		const index< _Src_type::rank > &	_Src_offset,
		const extent< _Src_type::rank > &	_Copy_extent,
		_Out_ void *	_Dst,
		unsigned int	_Dst_byte_size
	)

Asynchronously copies the contents of the provided section of the source texture into the destination host buffer.

Parameters

_Src_type	The type of the source texture.
_Src	The source texture or texture_view.
_Src_offset	The offset into the source texture from which to begin copying.
_Copy_extent	The extent of the texture section to copy.
_Dst	The destination host buffer.
_Dst_byte_size	Number of bytes in the destination buffer.

Returns

A future upon which to wait for the operation to complete.

{
    auto _Async_op_id = concurrency::details::_Get_amp_trace()->_Launch_async_copy_event_helper(concurrency::details::_Get_texture_descriptor(_Src),
                                                                                   nullptr,
                                                                                   _Get_section_size(_Src, _Copy_extent));

    _Event _Ev = details::_Copy_async_impl(_Src, _Src_offset, _Copy_extent, _Dst, _Dst_byte_size);

    return concurrency::details::_Get_amp_trace()->_Start_async_op_wait_event_helper(_Async_op_id, _Ev);
}

template<typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Dst_type>::is_texture, void>::type>

concurrency::completion_future Concurrency::graphics::copy_async	(	const void *	_Src,
		unsigned int	_Src_byte_size,
		_Dst_type &	_Dst
	)

Asynchronously copies the contents of the source host buffer into the destination texture _Dst.

Parameters

_Dst_type	The type of the destination texture.
_Src	The source host buffer.
_Src_byte_size	Number of bytes in the source buffer.
_Dst	The destination texture or texture_view.

Returns

A future upon which to wait for the operation to complete.

{
    static_assert(details::texture_traits<_Dst_type>::is_writable, "Destination is not a writable texture type.");
    auto _Async_op_id = concurrency::details::_Get_amp_trace()->_Launch_async_copy_event_helper(nullptr,
                                                                                   concurrency::details::_Get_texture_descriptor(_Dst),
                                                                                   _Get_section_size(_Dst, _Dst.extent));

    _Event _Ev = details::_Copy_async_impl(_Src, _Src_byte_size, _Dst, index<_Dst_type::rank>(), _Dst.extent);

    return concurrency::details::_Get_amp_trace()->_Start_async_op_wait_event_helper(_Async_op_id, _Ev);
}

template<typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Dst_type>::is_texture, void>::type>

concurrency::completion_future Concurrency::graphics::copy_async	(	const void *	_Src,
		unsigned int	_Src_byte_size,
		_Dst_type &	_Dst,
		const index< _Dst_type::rank > &	_Dst_offset,
		const extent< _Dst_type::rank > &	_Copy_extent
	)

Asynchronously copies the contents of the source host buffer into a section of the destination texture _Dst.

Parameters

_Dst_type	The type of the elements of the destination texture.
_Src	The source host buffer.
_Src_byte_size	Number of bytes in the source buffer.
_Dst	The destination texture or texture_view.
_Dst_offset	The offset into the destination texture to which to begin copying.
_Copy_extent	The extent of the texture section to copy.

Returns

A future upon which to wait for the operation to complete.

{
    static_assert(details::texture_traits<_Dst_type>::is_writable, "Destination is not a writable texture type.");
    auto _Async_op_id = concurrency::details::_Get_amp_trace()->_Launch_async_copy_event_helper(nullptr,
                                                                                   concurrency::details::_Get_texture_descriptor(_Dst),
                                                                                   _Get_section_size(_Dst, _Copy_extent));

    _Event _Ev = details::_Copy_async_impl(_Src, _Src_byte_size, _Dst, _Dst_offset, _Copy_extent);

    return concurrency::details::_Get_amp_trace()->_Start_async_op_wait_event_helper(_Async_op_id, _Ev);
}

template<typename InputIterator , typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Dst_type>::is_texture, void>::type>

concurrency::completion_future Concurrency::graphics::copy_async	(	InputIterator	_First,
		InputIterator	_Last,
		_Dst_type &	_Dst
	)

Asynchronously copies data from the pair of source iterators into the destination texture _Dst.

Parameters

InputIterator	The input iterator type.
_Dst_type	The type of the destination texture.
_First	The starting iterator for the copy.
_Last	The ending iterator for the copy.
_Dst	The destination texture or texture_view.

Returns

A future upon which to wait for the operation to complete.

{
    static_assert(details::texture_traits<_Dst_type>::is_writable, "Destination is not a writable texture type.");
    auto _Async_op_id = concurrency::details::_Get_amp_trace()->_Launch_async_copy_event_helper(nullptr,
        concurrency::details::_Get_texture_descriptor(_Dst),
        _Get_section_size(_Dst, _Dst.extent));

    _Event _Ev = details::_Copy_async_impl<InputIterator, _Dst_type::value_type, _Dst_type::rank>(_First, _Last, _Dst, index<_Dst_type::rank>(), _Dst.extent);

    return concurrency::details::_Get_amp_trace()->_Start_async_op_wait_event_helper(_Async_op_id, _Ev);
}

template<typename InputIterator , typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Dst_type>::is_texture, void>::type>

concurrency::completion_future Concurrency::graphics::copy_async	(	InputIterator	_First,
		InputIterator	_Last,
		_Dst_type &	_Dst,
		const index< _Dst_type::rank > &	_Dst_offset,
		const extent< _Dst_type::rank > &	_Copy_extent
	)

Asynchronously copies data from the pair of source iterators into a section of the destination texture _Dst.

Parameters

InputIterator	The input iterator type.
_Dst_type	The type of the destination texture.
_First	The starting iterator for the copy.
_Last	The ending iterator for the copy.
_Dst	The destination texture or texture_view.
_Dst_offset	The offset into the destination texture to which to begin copying.
_Copy_extent	The extent of the texture section to copy.

Returns

A future upon which to wait for the operation to complete.

{
    static_assert(details::texture_traits<_Dst_type>::is_writable, "Destination is not a writable texture type.");
    auto _Async_op_id = concurrency::details::_Get_amp_trace()->_Launch_async_copy_event_helper(nullptr,
                                                                                                concurrency::details::_Get_texture_descriptor(_Dst),
                                                                                                _Get_section_size(_Dst, _Copy_extent));

    _Event _Ev = details::_Copy_async_impl<InputIterator, _Dst_type::value_type, _Dst_type::rank>(_First, _Last, _Dst, _Dst_offset, _Copy_extent);

    return concurrency::details::_Get_amp_trace()->_Start_async_op_wait_event_helper(_Async_op_id, _Ev);
}

template<typename _Src_type , typename OutputIterator , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture && !details::texture_traits<OutputIterator>::is_texture, void>::type>

concurrency::completion_future Concurrency::graphics::copy_async	(	_Src_type &	_Src,
		OutputIterator	_Dst
	)

Asynchronously copies data from the source texture _Src into an output iterator.

Parameters

_Src_type	The type of the source texture.
OutputIterator	The output iterator type.
_Dst	The starting iterator for the copy output.

Returns

A future upon which to wait for the operation to complete.

{
    auto _Async_op_id = concurrency::details::_Get_amp_trace()->_Launch_async_copy_event_helper(concurrency::details::_Get_texture_descriptor(_Src),
                                                                    nullptr,
                                                                    _Get_section_size(_Src, _Src.extent));

    _Event _Ev = details::_Copy_async_impl(_Src, index<_Src_type::rank>(), _Src.extent, _Dst);

     return concurrency::details::_Get_amp_trace()->_Start_async_op_wait_event_helper(_Async_op_id, _Ev);
}

template<typename _Src_type , typename OutputIterator , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture && !details::texture_traits<OutputIterator>::is_texture, void>::type>

concurrency::completion_future Concurrency::graphics::copy_async	(	_Src_type &	_Src,
		const index< _Src_type::rank > &	_Src_offset,
		const extent< _Src_type::rank > &	_Copy_extent,
		OutputIterator	_Dst
	)

Asynchronously copies data from a section of the source texture _Src into an output iterator.

Parameters

_Src_type	The type of the source texture.
OutputIterator	The output iterator type.
_Src_offset	The offset into the source texture from which to begin copying.
_Copy_extent	The extent of the texture section to copy.
_Dst	The starting iterator for the copy output.

Returns

A future upon which to wait for the operation to complete.

{
    auto _Async_op_id = concurrency::details::_Get_amp_trace()->_Launch_async_copy_event_helper(concurrency::details::_Get_texture_descriptor(_Src),
                                                                    nullptr,
                                                                    _Get_section_size(_Src, _Copy_extent));

    _Event _Ev = details::_Copy_async_impl(_Src, _Src_offset, _Copy_extent, _Dst);

     return concurrency::details::_Get_amp_trace()->_Start_async_op_wait_event_helper(_Async_op_id, _Ev);
}

template<typename _Src_type , typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture && details::texture_traits<_Dst_type>::is_texture, void>::type>

concurrency::completion_future Concurrency::graphics::copy_async	(	_Src_type &	_Src,
		_Dst_type &	_Dst
	)

Asynchronously copies data from the source texture _Src into the destination texture _Dst.

Parameters

_Src_type	The type of the source texture.
_Dst_type	The type of the destination texture.
_Src	The source texture from which to copy.
_Dst	The destination texture into which to copy.

Returns

A future upon which to wait for the operation to complete.

{
    static_assert(details::texture_traits<_Dst_type>::is_writable, "Destination is not a writable texture type.");

    if (_Src.extent != _Dst.extent)
    {
        throw runtime_exception("The source and destination textures must have the exactly the same extent for whole-texture copy.", E_INVALIDARG);
    }
    auto _Async_op_id = concurrency::details::_Get_amp_trace()->_Launch_async_copy_event_helper(concurrency::details::_Get_texture_descriptor(_Src),
                                                                    concurrency::details::_Get_texture_descriptor(_Dst),
                                                                    _Get_section_size(_Dst, _Dst.extent));

    _Event _Ev = details::_Copy_async_impl(_Src, index<_Src_type::rank>(), _Dst, index<_Dst_type::rank>(), _Dst.extent);

     return concurrency::details::_Get_amp_trace()->_Start_async_op_wait_event_helper(_Async_op_id, _Ev);
}

template<typename _Src_type , typename _Dst_type , typename = typename std::enable_if<details::texture_traits<_Src_type>::is_texture && details::texture_traits<_Dst_type>::is_texture, void>::type>

concurrency::completion_future Concurrency::graphics::copy_async	(	_Src_type &	_Src,
		const index< _Src_type::rank > &	_Src_offset,
		_Dst_type &	_Dst,
		const index< _Dst_type::rank > &	_Dst_offset,
		const extent< _Src_type::rank > &	_Copy_extent
	)

Asynchronously copies data from a section of the source texture _Src into the destination texture _Dst.

Parameters

_Src_type	The type of the source texture.
_Dst_type	The type of the destination texture.
_Src	The source texture from which to copy.
_Src_offset	The offset into the source texture from which to begin copying.
_Dst	The destination texture into which to copy.
_Dst_offset	The offset into the destination texture to which to begin copying.
_Copy_extent	The extent of the texture section to copy.

Returns

A future upon which to wait for the operation to complete.

{
    static_assert(details::texture_traits<_Dst_type>::is_writable, "Destination is not a writable texture type.");

    auto _Async_op_id = concurrency::details::_Get_amp_trace()->_Launch_async_copy_event_helper(concurrency::details::_Get_texture_descriptor(_Src),
                                                                    concurrency::details::_Get_texture_descriptor(_Dst),
                                                                    _Get_section_size(_Src, _Copy_extent));

    _Event _Ev = details::_Copy_async_impl(_Src, _Src_offset, _Dst, _Dst_offset, _Copy_extent);

     return concurrency::details::_Get_amp_trace()->_Start_async_op_wait_event_helper(_Async_op_id, _Ev);
}

bool Concurrency::graphics::operator!= ( const unorm &  _Lhs, const unorm &  _Rhs  )

inline

        {
            return float(_Lhs) != float(_Rhs);
        }

bool Concurrency::graphics::operator!= ( const norm &  _Lhs, const norm &  _Rhs  )

inline

        {
            return float(_Lhs) != float(_Rhs);
        }

bool Concurrency::graphics::operator!= ( const uint_2 &  _Lhs, const uint_2 &  _Rhs  )

inline

        {
            uint_2 _Value1 = _Lhs;
            uint_2 _Value2 = _Rhs;
            return _Value1.x != _Value2.x || _Value1.y != _Value2.y;
        }

bool Concurrency::graphics::operator!= ( const uint_3 &  _Lhs, const uint_3 &  _Rhs  )

inline

        {
            uint_3 _Value1 = _Lhs;
            uint_3 _Value2 = _Rhs;
            return _Value1.x != _Value2.x || _Value1.y != _Value2.y || _Value1.z != _Value2.z;
        }

bool Concurrency::graphics::operator!= ( const uint_4 &  _Lhs, const uint_4 &  _Rhs  )

inline

        {
            uint_4 _Value1 = _Lhs;
            uint_4 _Value2 = _Rhs;
            return _Value1.x != _Value2.x || _Value1.y != _Value2.y || _Value1.z != _Value2.z || _Value1.w != _Value2.w;
        }

bool Concurrency::graphics::operator!= ( const int_2 &  _Lhs, const int_2 &  _Rhs  )

inline

        {
            int_2 _Value1 = _Lhs;
            int_2 _Value2 = _Rhs;
            return _Value1.x != _Value2.x || _Value1.y != _Value2.y;
        }

bool Concurrency::graphics::operator!= ( const int_3 &  _Lhs, const int_3 &  _Rhs  )

inline

        {
            int_3 _Value1 = _Lhs;
            int_3 _Value2 = _Rhs;
            return _Value1.x != _Value2.x || _Value1.y != _Value2.y || _Value1.z != _Value2.z;
        }

bool Concurrency::graphics::operator!= ( const int_4 &  _Lhs, const int_4 &  _Rhs  )

inline

        {
            int_4 _Value1 = _Lhs;
            int_4 _Value2 = _Rhs;
            return _Value1.x != _Value2.x || _Value1.y != _Value2.y || _Value1.z != _Value2.z || _Value1.w != _Value2.w;
        }

bool Concurrency::graphics::operator!= ( const float_2 &  _Lhs, const float_2 &  _Rhs  )

inline

        {
            float_2 _Value1 = _Lhs;
            float_2 _Value2 = _Rhs;
            return _Value1.x != _Value2.x || _Value1.y != _Value2.y;
        }

bool Concurrency::graphics::operator!= ( const float_3 &  _Lhs, const float_3 &  _Rhs  )

inline

        {
            float_3 _Value1 = _Lhs;
            float_3 _Value2 = _Rhs;
            return _Value1.x != _Value2.x || _Value1.y != _Value2.y || _Value1.z != _Value2.z;
        }

bool Concurrency::graphics::operator!= ( const float_4 &  _Lhs, const float_4 &  _Rhs  )

inline

        {
            float_4 _Value1 = _Lhs;
            float_4 _Value2 = _Rhs;
            return _Value1.x != _Value2.x || _Value1.y != _Value2.y || _Value1.z != _Value2.z || _Value1.w != _Value2.w;
        }

bool Concurrency::graphics::operator!= ( const unorm_2 &  _Lhs, const unorm_2 &  _Rhs  )

inline

        {
            unorm_2 _Value1 = _Lhs;
            unorm_2 _Value2 = _Rhs;
            return _Value1.x != _Value2.x || _Value1.y != _Value2.y;
        }

bool Concurrency::graphics::operator!= ( const unorm_3 &  _Lhs, const unorm_3 &  _Rhs  )

inline

        {
            unorm_3 _Value1 = _Lhs;
            unorm_3 _Value2 = _Rhs;
            return _Value1.x != _Value2.x || _Value1.y != _Value2.y || _Value1.z != _Value2.z;
        }

bool Concurrency::graphics::operator!= ( const unorm_4 &  _Lhs, const unorm_4 &  _Rhs  )

inline

        {
            unorm_4 _Value1 = _Lhs;
            unorm_4 _Value2 = _Rhs;
            return _Value1.x != _Value2.x || _Value1.y != _Value2.y || _Value1.z != _Value2.z || _Value1.w != _Value2.w;
        }

bool Concurrency::graphics::operator!= ( const norm_2 &  _Lhs, const norm_2 &  _Rhs  )

inline

        {
            norm_2 _Value1 = _Lhs;
            norm_2 _Value2 = _Rhs;
            return _Value1.x != _Value2.x || _Value1.y != _Value2.y;
        }

bool Concurrency::graphics::operator!= ( const norm_3 &  _Lhs, const norm_3 &  _Rhs  )

inline

        {
            norm_3 _Value1 = _Lhs;
            norm_3 _Value2 = _Rhs;
            return _Value1.x != _Value2.x || _Value1.y != _Value2.y || _Value1.z != _Value2.z;
        }

bool Concurrency::graphics::operator!= ( const norm_4 &  _Lhs, const norm_4 &  _Rhs  )

inline

        {
            norm_4 _Value1 = _Lhs;
            norm_4 _Value2 = _Rhs;
            return _Value1.x != _Value2.x || _Value1.y != _Value2.y || _Value1.z != _Value2.z || _Value1.w != _Value2.w;
        }

bool Concurrency::graphics::operator!= ( const double_2 &  _Lhs, const double_2 &  _Rhs  )

inline

        {
            double_2 _Value1 = _Lhs;
            double_2 _Value2 = _Rhs;
            return _Value1.x != _Value2.x || _Value1.y != _Value2.y;
        }

bool Concurrency::graphics::operator!= ( const double_3 &  _Lhs, const double_3 &  _Rhs  )

inline

        {
            double_3 _Value1 = _Lhs;
            double_3 _Value2 = _Rhs;
            return _Value1.x != _Value2.x || _Value1.y != _Value2.y || _Value1.z != _Value2.z;
        }

bool Concurrency::graphics::operator!= ( const double_4 &  _Lhs, const double_4 &  _Rhs  )

inline

        {
            double_4 _Value1 = _Lhs;
            double_4 _Value2 = _Rhs;
            return _Value1.x != _Value2.x || _Value1.y != _Value2.y || _Value1.z != _Value2.z || _Value1.w != _Value2.w;
        }

uint_2 Concurrency::graphics::operator% ( const uint_2 &  _Lhs, const uint_2 &  _Rhs  )

inline

        {
            uint_2 _Value1 = _Lhs;
            uint_2 _Value2 = _Rhs;
            return uint_2(_Value1.x % _Value2.x, _Value1.y % _Value2.y);
        }

uint_3 Concurrency::graphics::operator% ( const uint_3 &  _Lhs, const uint_3 &  _Rhs  )

inline

        {
            uint_3 _Value1 = _Lhs;
            uint_3 _Value2 = _Rhs;
            return uint_3(_Value1.x % _Value2.x, _Value1.y % _Value2.y, _Value1.z % _Value2.z);
        }

uint_4 Concurrency::graphics::operator% ( const uint_4 &  _Lhs, const uint_4 &  _Rhs  )

inline

        {
            uint_4 _Value1 = _Lhs;
            uint_4 _Value2 = _Rhs;
            return uint_4(_Value1.x % _Value2.x, _Value1.y % _Value2.y, _Value1.z % _Value2.z, _Value1.w % _Value2.w);
        }

int_2 Concurrency::graphics::operator% ( const int_2 &  _Lhs, const int_2 &  _Rhs  )

inline

        {
            int_2 _Value1 = _Lhs;
            int_2 _Value2 = _Rhs;
            return int_2(_Value1.x % _Value2.x, _Value1.y % _Value2.y);
        }

int_3 Concurrency::graphics::operator% ( const int_3 &  _Lhs, const int_3 &  _Rhs  )

inline

        {
            int_3 _Value1 = _Lhs;
            int_3 _Value2 = _Rhs;
            return int_3(_Value1.x % _Value2.x, _Value1.y % _Value2.y, _Value1.z % _Value2.z);
        }

int_4 Concurrency::graphics::operator% ( const int_4 &  _Lhs, const int_4 &  _Rhs  )

inline

        {
            int_4 _Value1 = _Lhs;
            int_4 _Value2 = _Rhs;
            return int_4(_Value1.x % _Value2.x, _Value1.y % _Value2.y, _Value1.z % _Value2.z, _Value1.w % _Value2.w);
        }

uint_2 Concurrency::graphics::operator& ( const uint_2 &  _Lhs, const uint_2 &  _Rhs  )

inline

        {
            uint_2 _Value1 = _Lhs;
            uint_2 _Value2 = _Rhs;
            return uint_2(_Value1.x & _Value2.x, _Value1.y & _Value2.y);
        }

uint_3 Concurrency::graphics::operator& ( const uint_3 &  _Lhs, const uint_3 &  _Rhs  )

inline

        {
            uint_3 _Value1 = _Lhs;
            uint_3 _Value2 = _Rhs;
            return uint_3(_Value1.x & _Value2.x, _Value1.y & _Value2.y, _Value1.z & _Value2.z);
        }

uint_4 Concurrency::graphics::operator& ( const uint_4 &  _Lhs, const uint_4 &  _Rhs  )

inline

        {
            uint_4 _Value1 = _Lhs;
            uint_4 _Value2 = _Rhs;
            return uint_4(_Value1.x & _Value2.x, _Value1.y & _Value2.y, _Value1.z & _Value2.z, _Value1.w & _Value2.w);
        }

int_2 Concurrency::graphics::operator& ( const int_2 &  _Lhs, const int_2 &  _Rhs  )

inline

        {
            int_2 _Value1 = _Lhs;
            int_2 _Value2 = _Rhs;
            return int_2(_Value1.x & _Value2.x, _Value1.y & _Value2.y);
        }

int_3 Concurrency::graphics::operator& ( const int_3 &  _Lhs, const int_3 &  _Rhs  )

inline

        {
            int_3 _Value1 = _Lhs;
            int_3 _Value2 = _Rhs;
            return int_3(_Value1.x & _Value2.x, _Value1.y & _Value2.y, _Value1.z & _Value2.z);
        }

int_4 Concurrency::graphics::operator& ( const int_4 &  _Lhs, const int_4 &  _Rhs  )

inline

        {
            int_4 _Value1 = _Lhs;
            int_4 _Value2 = _Rhs;
            return int_4(_Value1.x & _Value2.x, _Value1.y & _Value2.y, _Value1.z & _Value2.z, _Value1.w & _Value2.w);
        }

unorm Concurrency::graphics::operator* ( const unorm &  _Lhs, const unorm &  _Rhs  )

inline

        {
            return unorm(float(_Lhs) * float(_Rhs));
        }

norm Concurrency::graphics::operator* ( const norm &  _Lhs, const norm &  _Rhs  )

inline

        {
            return norm(float(_Lhs) * float(_Rhs));
        }

uint_2 Concurrency::graphics::operator* ( const uint_2 &  _Lhs, const uint_2 &  _Rhs  )

inline

        {
            uint_2 _Value1 = _Lhs;
            uint_2 _Value2 = _Rhs;
            return uint_2(_Value1.x * _Value2.x, _Value1.y * _Value2.y);
        }

uint_3 Concurrency::graphics::operator* ( const uint_3 &  _Lhs, const uint_3 &  _Rhs  )

inline

        {
            uint_3 _Value1 = _Lhs;
            uint_3 _Value2 = _Rhs;
            return uint_3(_Value1.x * _Value2.x, _Value1.y * _Value2.y, _Value1.z * _Value2.z);
        }

uint_4 Concurrency::graphics::operator* ( const uint_4 &  _Lhs, const uint_4 &  _Rhs  )

inline

        {
            uint_4 _Value1 = _Lhs;
            uint_4 _Value2 = _Rhs;
            return uint_4(_Value1.x * _Value2.x, _Value1.y * _Value2.y, _Value1.z * _Value2.z, _Value1.w * _Value2.w);
        }

int_2 Concurrency::graphics::operator* ( const int_2 &  _Lhs, const int_2 &  _Rhs  )

inline

        {
            int_2 _Value1 = _Lhs;
            int_2 _Value2 = _Rhs;
            return int_2(_Value1.x * _Value2.x, _Value1.y * _Value2.y);
        }

int_3 Concurrency::graphics::operator* ( const int_3 &  _Lhs, const int_3 &  _Rhs  )

inline

        {
            int_3 _Value1 = _Lhs;
            int_3 _Value2 = _Rhs;
            return int_3(_Value1.x * _Value2.x, _Value1.y * _Value2.y, _Value1.z * _Value2.z);
        }

int_4 Concurrency::graphics::operator* ( const int_4 &  _Lhs, const int_4 &  _Rhs  )

inline

        {
            int_4 _Value1 = _Lhs;
            int_4 _Value2 = _Rhs;
            return int_4(_Value1.x * _Value2.x, _Value1.y * _Value2.y, _Value1.z * _Value2.z, _Value1.w * _Value2.w);
        }

float_2 Concurrency::graphics::operator* ( const float_2 &  _Lhs, const float_2 &  _Rhs  )

inline

        {
            float_2 _Value1 = _Lhs;
            float_2 _Value2 = _Rhs;
            return float_2(_Value1.x * _Value2.x, _Value1.y * _Value2.y);
        }

float_3 Concurrency::graphics::operator* ( const float_3 &  _Lhs, const float_3 &  _Rhs  )

inline

        {
            float_3 _Value1 = _Lhs;
            float_3 _Value2 = _Rhs;
            return float_3(_Value1.x * _Value2.x, _Value1.y * _Value2.y, _Value1.z * _Value2.z);
        }

float_4 Concurrency::graphics::operator* ( const float_4 &  _Lhs, const float_4 &  _Rhs  )

inline

        {
            float_4 _Value1 = _Lhs;
            float_4 _Value2 = _Rhs;
            return float_4(_Value1.x * _Value2.x, _Value1.y * _Value2.y, _Value1.z * _Value2.z, _Value1.w * _Value2.w);
        }

unorm_2 Concurrency::graphics::operator* ( const unorm_2 &  _Lhs, const unorm_2 &  _Rhs  )

inline

        {
            unorm_2 _Value1 = _Lhs;
            unorm_2 _Value2 = _Rhs;
            return unorm_2(_Value1.x * _Value2.x, _Value1.y * _Value2.y);
        }

unorm_3 Concurrency::graphics::operator* ( const unorm_3 &  _Lhs, const unorm_3 &  _Rhs  )

inline

        {
            unorm_3 _Value1 = _Lhs;
            unorm_3 _Value2 = _Rhs;
            return unorm_3(_Value1.x * _Value2.x, _Value1.y * _Value2.y, _Value1.z * _Value2.z);
        }

unorm_4 Concurrency::graphics::operator* ( const unorm_4 &  _Lhs, const unorm_4 &  _Rhs  )

inline

        {
            unorm_4 _Value1 = _Lhs;
            unorm_4 _Value2 = _Rhs;
            return unorm_4(_Value1.x * _Value2.x, _Value1.y * _Value2.y, _Value1.z * _Value2.z, _Value1.w * _Value2.w);
        }

norm_2 Concurrency::graphics::operator* ( const norm_2 &  _Lhs, const norm_2 &  _Rhs  )

inline

        {
            norm_2 _Value1 = _Lhs;
            norm_2 _Value2 = _Rhs;
            return norm_2(_Value1.x * _Value2.x, _Value1.y * _Value2.y);
        }

norm_3 Concurrency::graphics::operator* ( const norm_3 &  _Lhs, const norm_3 &  _Rhs  )

inline

        {
            norm_3 _Value1 = _Lhs;
            norm_3 _Value2 = _Rhs;
            return norm_3(_Value1.x * _Value2.x, _Value1.y * _Value2.y, _Value1.z * _Value2.z);
        }

norm_4 Concurrency::graphics::operator* ( const norm_4 &  _Lhs, const norm_4 &  _Rhs  )

inline

        {
            norm_4 _Value1 = _Lhs;
            norm_4 _Value2 = _Rhs;
            return norm_4(_Value1.x * _Value2.x, _Value1.y * _Value2.y, _Value1.z * _Value2.z, _Value1.w * _Value2.w);
        }

double_2 Concurrency::graphics::operator* ( const double_2 &  _Lhs, const double_2 &  _Rhs  )

inline

        {
            double_2 _Value1 = _Lhs;
            double_2 _Value2 = _Rhs;
            return double_2(_Value1.x * _Value2.x, _Value1.y * _Value2.y);
        }

double_3 Concurrency::graphics::operator* ( const double_3 &  _Lhs, const double_3 &  _Rhs  )

inline

        {
            double_3 _Value1 = _Lhs;
            double_3 _Value2 = _Rhs;
            return double_3(_Value1.x * _Value2.x, _Value1.y * _Value2.y, _Value1.z * _Value2.z);
        }

double_4 Concurrency::graphics::operator* ( const double_4 &  _Lhs, const double_4 &  _Rhs  )

inline

        {
            double_4 _Value1 = _Lhs;
            double_4 _Value2 = _Rhs;
            return double_4(_Value1.x * _Value2.x, _Value1.y * _Value2.y, _Value1.z * _Value2.z, _Value1.w * _Value2.w);
        }

unorm Concurrency::graphics::operator+ ( const unorm &  _Lhs, const unorm &  _Rhs  )

inline

        {
            return unorm(float(_Lhs) + float(_Rhs));
        }

norm Concurrency::graphics::operator+ ( const norm &  _Lhs, const norm &  _Rhs  )

inline

        {
            return norm(float(_Lhs) + float(_Rhs));
        }

uint_2 Concurrency::graphics::operator+ ( const uint_2 &  _Lhs, const uint_2 &  _Rhs  )

inline

        {
            uint_2 _Value1 = _Lhs;
            uint_2 _Value2 = _Rhs;
            return uint_2(_Value1.x + _Value2.x, _Value1.y + _Value2.y);
        }

uint_3 Concurrency::graphics::operator+ ( const uint_3 &  _Lhs, const uint_3 &  _Rhs  )

inline

        {
            uint_3 _Value1 = _Lhs;
            uint_3 _Value2 = _Rhs;
            return uint_3(_Value1.x + _Value2.x, _Value1.y + _Value2.y, _Value1.z + _Value2.z);
        }

uint_4 Concurrency::graphics::operator+ ( const uint_4 &  _Lhs, const uint_4 &  _Rhs  )

inline

        {
            uint_4 _Value1 = _Lhs;
            uint_4 _Value2 = _Rhs;
            return uint_4(_Value1.x + _Value2.x, _Value1.y + _Value2.y, _Value1.z + _Value2.z, _Value1.w + _Value2.w);
        }

int_2 Concurrency::graphics::operator+ ( const int_2 &  _Lhs, const int_2 &  _Rhs  )

inline

        {
            int_2 _Value1 = _Lhs;
            int_2 _Value2 = _Rhs;
            return int_2(_Value1.x + _Value2.x, _Value1.y + _Value2.y);
        }

int_3 Concurrency::graphics::operator+ ( const int_3 &  _Lhs, const int_3 &  _Rhs  )

inline

        {
            int_3 _Value1 = _Lhs;
            int_3 _Value2 = _Rhs;
            return int_3(_Value1.x + _Value2.x, _Value1.y + _Value2.y, _Value1.z + _Value2.z);
        }

int_4 Concurrency::graphics::operator+ ( const int_4 &  _Lhs, const int_4 &  _Rhs  )

inline

        {
            int_4 _Value1 = _Lhs;
            int_4 _Value2 = _Rhs;
            return int_4(_Value1.x + _Value2.x, _Value1.y + _Value2.y, _Value1.z + _Value2.z, _Value1.w + _Value2.w);
        }

float_2 Concurrency::graphics::operator+ ( const float_2 &  _Lhs, const float_2 &  _Rhs  )

inline

        {
            float_2 _Value1 = _Lhs;
            float_2 _Value2 = _Rhs;
            return float_2(_Value1.x + _Value2.x, _Value1.y + _Value2.y);
        }

float_3 Concurrency::graphics::operator+ ( const float_3 &  _Lhs, const float_3 &  _Rhs  )

inline

        {
            float_3 _Value1 = _Lhs;
            float_3 _Value2 = _Rhs;
            return float_3(_Value1.x + _Value2.x, _Value1.y + _Value2.y, _Value1.z + _Value2.z);
        }

float_4 Concurrency::graphics::operator+ ( const float_4 &  _Lhs, const float_4 &  _Rhs  )

inline

        {
            float_4 _Value1 = _Lhs;
            float_4 _Value2 = _Rhs;
            return float_4(_Value1.x + _Value2.x, _Value1.y + _Value2.y, _Value1.z + _Value2.z, _Value1.w + _Value2.w);
        }

unorm_2 Concurrency::graphics::operator+ ( const unorm_2 &  _Lhs, const unorm_2 &  _Rhs  )

inline

        {
            unorm_2 _Value1 = _Lhs;
            unorm_2 _Value2 = _Rhs;
            return unorm_2(_Value1.x + _Value2.x, _Value1.y + _Value2.y);
        }

unorm_3 Concurrency::graphics::operator+ ( const unorm_3 &  _Lhs, const unorm_3 &  _Rhs  )

inline

        {
            unorm_3 _Value1 = _Lhs;
            unorm_3 _Value2 = _Rhs;
            return unorm_3(_Value1.x + _Value2.x, _Value1.y + _Value2.y, _Value1.z + _Value2.z);
        }

unorm_4 Concurrency::graphics::operator+ ( const unorm_4 &  _Lhs, const unorm_4 &  _Rhs  )

inline

        {
            unorm_4 _Value1 = _Lhs;
            unorm_4 _Value2 = _Rhs;
            return unorm_4(_Value1.x + _Value2.x, _Value1.y + _Value2.y, _Value1.z + _Value2.z, _Value1.w + _Value2.w);
        }

norm_2 Concurrency::graphics::operator+ ( const norm_2 &  _Lhs, const norm_2 &  _Rhs  )

inline

        {
            norm_2 _Value1 = _Lhs;
            norm_2 _Value2 = _Rhs;
            return norm_2(_Value1.x + _Value2.x, _Value1.y + _Value2.y);
        }

norm_3 Concurrency::graphics::operator+ ( const norm_3 &  _Lhs, const norm_3 &  _Rhs  )

inline

        {
            norm_3 _Value1 = _Lhs;
            norm_3 _Value2 = _Rhs;
            return norm_3(_Value1.x + _Value2.x, _Value1.y + _Value2.y, _Value1.z + _Value2.z);
        }

norm_4 Concurrency::graphics::operator+ ( const norm_4 &  _Lhs, const norm_4 &  _Rhs  )

inline

        {
            norm_4 _Value1 = _Lhs;
            norm_4 _Value2 = _Rhs;
            return norm_4(_Value1.x + _Value2.x, _Value1.y + _Value2.y, _Value1.z + _Value2.z, _Value1.w + _Value2.w);
        }

double_2 Concurrency::graphics::operator+ ( const double_2 &  _Lhs, const double_2 &  _Rhs  )

inline

        {
            double_2 _Value1 = _Lhs;
            double_2 _Value2 = _Rhs;
            return double_2(_Value1.x + _Value2.x, _Value1.y + _Value2.y);
        }

double_3 Concurrency::graphics::operator+ ( const double_3 &  _Lhs, const double_3 &  _Rhs  )

inline

        {
            double_3 _Value1 = _Lhs;
            double_3 _Value2 = _Rhs;
            return double_3(_Value1.x + _Value2.x, _Value1.y + _Value2.y, _Value1.z + _Value2.z);
        }

double_4 Concurrency::graphics::operator+ ( const double_4 &  _Lhs, const double_4 &  _Rhs  )

inline

        {
            double_4 _Value1 = _Lhs;
            double_4 _Value2 = _Rhs;
            return double_4(_Value1.x + _Value2.x, _Value1.y + _Value2.y, _Value1.z + _Value2.z, _Value1.w + _Value2.w);
        }

unorm Concurrency::graphics::operator- ( const unorm &  _Lhs, const unorm &  _Rhs  )

inline

        {
            return unorm(float(_Lhs) - float(_Rhs));
        }

norm Concurrency::graphics::operator- ( const norm &  _Lhs, const norm &  _Rhs  )

inline

        {
            return norm(float(_Lhs) - float(_Rhs));
        }

uint_2 Concurrency::graphics::operator- ( const uint_2 &  _Lhs, const uint_2 &  _Rhs  )

inline

        {
            uint_2 _Value1 = _Lhs;
            uint_2 _Value2 = _Rhs;
            return uint_2(_Value1.x - _Value2.x, _Value1.y - _Value2.y);
        }

uint_3 Concurrency::graphics::operator- ( const uint_3 &  _Lhs, const uint_3 &  _Rhs  )

inline

        {
            uint_3 _Value1 = _Lhs;
            uint_3 _Value2 = _Rhs;
            return uint_3(_Value1.x - _Value2.x, _Value1.y - _Value2.y, _Value1.z - _Value2.z);
        }

uint_4 Concurrency::graphics::operator- ( const uint_4 &  _Lhs, const uint_4 &  _Rhs  )

inline

        {
            uint_4 _Value1 = _Lhs;
            uint_4 _Value2 = _Rhs;
            return uint_4(_Value1.x - _Value2.x, _Value1.y - _Value2.y, _Value1.z - _Value2.z, _Value1.w - _Value2.w);
        }

int_2 Concurrency::graphics::operator- ( const int_2 &  _Lhs, const int_2 &  _Rhs  )

inline

        {
            int_2 _Value1 = _Lhs;
            int_2 _Value2 = _Rhs;
            return int_2(_Value1.x - _Value2.x, _Value1.y - _Value2.y);
        }

int_3 Concurrency::graphics::operator- ( const int_3 &  _Lhs, const int_3 &  _Rhs  )

inline

        {
            int_3 _Value1 = _Lhs;
            int_3 _Value2 = _Rhs;
            return int_3(_Value1.x - _Value2.x, _Value1.y - _Value2.y, _Value1.z - _Value2.z);
        }

int_4 Concurrency::graphics::operator- ( const int_4 &  _Lhs, const int_4 &  _Rhs  )

inline

        {
            int_4 _Value1 = _Lhs;
            int_4 _Value2 = _Rhs;
            return int_4(_Value1.x - _Value2.x, _Value1.y - _Value2.y, _Value1.z - _Value2.z, _Value1.w - _Value2.w);
        }

float_2 Concurrency::graphics::operator- ( const float_2 &  _Lhs, const float_2 &  _Rhs  )

inline

        {
            float_2 _Value1 = _Lhs;
            float_2 _Value2 = _Rhs;
            return float_2(_Value1.x - _Value2.x, _Value1.y - _Value2.y);
        }

float_3 Concurrency::graphics::operator- ( const float_3 &  _Lhs, const float_3 &  _Rhs  )

inline

        {
            float_3 _Value1 = _Lhs;
            float_3 _Value2 = _Rhs;
            return float_3(_Value1.x - _Value2.x, _Value1.y - _Value2.y, _Value1.z - _Value2.z);
        }

float_4 Concurrency::graphics::operator- ( const float_4 &  _Lhs, const float_4 &  _Rhs  )

inline

        {
            float_4 _Value1 = _Lhs;
            float_4 _Value2 = _Rhs;
            return float_4(_Value1.x - _Value2.x, _Value1.y - _Value2.y, _Value1.z - _Value2.z, _Value1.w - _Value2.w);
        }

unorm_2 Concurrency::graphics::operator- ( const unorm_2 &  _Lhs, const unorm_2 &  _Rhs  )

inline

        {
            unorm_2 _Value1 = _Lhs;
            unorm_2 _Value2 = _Rhs;
            return unorm_2(_Value1.x - _Value2.x, _Value1.y - _Value2.y);
        }

unorm_3 Concurrency::graphics::operator- ( const unorm_3 &  _Lhs, const unorm_3 &  _Rhs  )

inline

        {
            unorm_3 _Value1 = _Lhs;
            unorm_3 _Value2 = _Rhs;
            return unorm_3(_Value1.x - _Value2.x, _Value1.y - _Value2.y, _Value1.z - _Value2.z);
        }

unorm_4 Concurrency::graphics::operator- ( const unorm_4 &  _Lhs, const unorm_4 &  _Rhs  )

inline

        {
            unorm_4 _Value1 = _Lhs;
            unorm_4 _Value2 = _Rhs;
            return unorm_4(_Value1.x - _Value2.x, _Value1.y - _Value2.y, _Value1.z - _Value2.z, _Value1.w - _Value2.w);
        }

norm_2 Concurrency::graphics::operator- ( const norm_2 &  _Lhs, const norm_2 &  _Rhs  )

inline

        {
            norm_2 _Value1 = _Lhs;
            norm_2 _Value2 = _Rhs;
            return norm_2(_Value1.x - _Value2.x, _Value1.y - _Value2.y);
        }

norm_3 Concurrency::graphics::operator- ( const norm_3 &  _Lhs, const norm_3 &  _Rhs  )

inline

        {
            norm_3 _Value1 = _Lhs;
            norm_3 _Value2 = _Rhs;
            return norm_3(_Value1.x - _Value2.x, _Value1.y - _Value2.y, _Value1.z - _Value2.z);
        }

norm_4 Concurrency::graphics::operator- ( const norm_4 &  _Lhs, const norm_4 &  _Rhs  )

inline

        {
            norm_4 _Value1 = _Lhs;
            norm_4 _Value2 = _Rhs;
            return norm_4(_Value1.x - _Value2.x, _Value1.y - _Value2.y, _Value1.z - _Value2.z, _Value1.w - _Value2.w);
        }

double_2 Concurrency::graphics::operator- ( const double_2 &  _Lhs, const double_2 &  _Rhs  )

inline

        {
            double_2 _Value1 = _Lhs;
            double_2 _Value2 = _Rhs;
            return double_2(_Value1.x - _Value2.x, _Value1.y - _Value2.y);
        }

double_3 Concurrency::graphics::operator- ( const double_3 &  _Lhs, const double_3 &  _Rhs  )

inline

        {
            double_3 _Value1 = _Lhs;
            double_3 _Value2 = _Rhs;
            return double_3(_Value1.x - _Value2.x, _Value1.y - _Value2.y, _Value1.z - _Value2.z);
        }

double_4 Concurrency::graphics::operator- ( const double_4 &  _Lhs, const double_4 &  _Rhs  )

inline

        {
            double_4 _Value1 = _Lhs;
            double_4 _Value2 = _Rhs;
            return double_4(_Value1.x - _Value2.x, _Value1.y - _Value2.y, _Value1.z - _Value2.z, _Value1.w - _Value2.w);
        }

unorm Concurrency::graphics::operator/ ( const unorm &  _Lhs, const unorm &  _Rhs  )

inline

        {
            return unorm(float(_Lhs) / float(_Rhs));
        }

norm Concurrency::graphics::operator/ ( const norm &  _Lhs, const norm &  _Rhs  )

inline

        {
            return norm(float(_Lhs) / float(_Rhs));
        }

uint_2 Concurrency::graphics::operator/ ( const uint_2 &  _Lhs, const uint_2 &  _Rhs  )

inline

        {
            uint_2 _Value1 = _Lhs;
            uint_2 _Value2 = _Rhs;
            return uint_2(_Value1.x / _Value2.x, _Value1.y / _Value2.y);
        }

uint_3 Concurrency::graphics::operator/ ( const uint_3 &  _Lhs, const uint_3 &  _Rhs  )

inline

        {
            uint_3 _Value1 = _Lhs;
            uint_3 _Value2 = _Rhs;
            return uint_3(_Value1.x / _Value2.x, _Value1.y / _Value2.y, _Value1.z / _Value2.z);
        }

uint_4 Concurrency::graphics::operator/ ( const uint_4 &  _Lhs, const uint_4 &  _Rhs  )

inline

        {
            uint_4 _Value1 = _Lhs;
            uint_4 _Value2 = _Rhs;
            return uint_4(_Value1.x / _Value2.x, _Value1.y / _Value2.y, _Value1.z / _Value2.z, _Value1.w / _Value2.w);
        }

int_2 Concurrency::graphics::operator/ ( const int_2 &  _Lhs, const int_2 &  _Rhs  )

inline

        {
            int_2 _Value1 = _Lhs;
            int_2 _Value2 = _Rhs;
            return int_2(_Value1.x / _Value2.x, _Value1.y / _Value2.y);
        }

int_3 Concurrency::graphics::operator/ ( const int_3 &  _Lhs, const int_3 &  _Rhs  )

inline

        {
            int_3 _Value1 = _Lhs;
            int_3 _Value2 = _Rhs;
            return int_3(_Value1.x / _Value2.x, _Value1.y / _Value2.y, _Value1.z / _Value2.z);
        }

int_4 Concurrency::graphics::operator/ ( const int_4 &  _Lhs, const int_4 &  _Rhs  )

inline

        {
            int_4 _Value1 = _Lhs;
            int_4 _Value2 = _Rhs;
            return int_4(_Value1.x / _Value2.x, _Value1.y / _Value2.y, _Value1.z / _Value2.z, _Value1.w / _Value2.w);
        }

float_2 Concurrency::graphics::operator/ ( const float_2 &  _Lhs, const float_2 &  _Rhs  )

inline

        {
            float_2 _Value1 = _Lhs;
            float_2 _Value2 = _Rhs;
            return float_2(_Value1.x / _Value2.x, _Value1.y / _Value2.y);
        }

float_3 Concurrency::graphics::operator/ ( const float_3 &  _Lhs, const float_3 &  _Rhs  )

inline

        {
            float_3 _Value1 = _Lhs;
            float_3 _Value2 = _Rhs;
            return float_3(_Value1.x / _Value2.x, _Value1.y / _Value2.y, _Value1.z / _Value2.z);
        }

float_4 Concurrency::graphics::operator/ ( const float_4 &  _Lhs, const float_4 &  _Rhs  )

inline

        {
            float_4 _Value1 = _Lhs;
            float_4 _Value2 = _Rhs;
            return float_4(_Value1.x / _Value2.x, _Value1.y / _Value2.y, _Value1.z / _Value2.z, _Value1.w / _Value2.w);
        }

unorm_2 Concurrency::graphics::operator/ ( const unorm_2 &  _Lhs, const unorm_2 &  _Rhs  )

inline

        {
            unorm_2 _Value1 = _Lhs;
            unorm_2 _Value2 = _Rhs;
            return unorm_2(_Value1.x / _Value2.x, _Value1.y / _Value2.y);
        }

unorm_3 Concurrency::graphics::operator/ ( const unorm_3 &  _Lhs, const unorm_3 &  _Rhs  )

inline

        {
            unorm_3 _Value1 = _Lhs;
            unorm_3 _Value2 = _Rhs;
            return unorm_3(_Value1.x / _Value2.x, _Value1.y / _Value2.y, _Value1.z / _Value2.z);
        }

unorm_4 Concurrency::graphics::operator/ ( const unorm_4 &  _Lhs, const unorm_4 &  _Rhs  )

inline

        {
            unorm_4 _Value1 = _Lhs;
            unorm_4 _Value2 = _Rhs;
            return unorm_4(_Value1.x / _Value2.x, _Value1.y / _Value2.y, _Value1.z / _Value2.z, _Value1.w / _Value2.w);
        }

norm_2 Concurrency::graphics::operator/ ( const norm_2 &  _Lhs, const norm_2 &  _Rhs  )

inline

        {
            norm_2 _Value1 = _Lhs;
            norm_2 _Value2 = _Rhs;
            return norm_2(_Value1.x / _Value2.x, _Value1.y / _Value2.y);
        }

norm_3 Concurrency::graphics::operator/ ( const norm_3 &  _Lhs, const norm_3 &  _Rhs  )

inline

        {
            norm_3 _Value1 = _Lhs;
            norm_3 _Value2 = _Rhs;
            return norm_3(_Value1.x / _Value2.x, _Value1.y / _Value2.y, _Value1.z / _Value2.z);
        }

norm_4 Concurrency::graphics::operator/ ( const norm_4 &  _Lhs, const norm_4 &  _Rhs  )

inline

        {
            norm_4 _Value1 = _Lhs;
            norm_4 _Value2 = _Rhs;
            return norm_4(_Value1.x / _Value2.x, _Value1.y / _Value2.y, _Value1.z / _Value2.z, _Value1.w / _Value2.w);
        }

double_2 Concurrency::graphics::operator/ ( const double_2 &  _Lhs, const double_2 &  _Rhs  )

inline

        {
            double_2 _Value1 = _Lhs;
            double_2 _Value2 = _Rhs;
            return double_2(_Value1.x / _Value2.x, _Value1.y / _Value2.y);
        }

double_3 Concurrency::graphics::operator/ ( const double_3 &  _Lhs, const double_3 &  _Rhs  )

inline

        {
            double_3 _Value1 = _Lhs;
            double_3 _Value2 = _Rhs;
            return double_3(_Value1.x / _Value2.x, _Value1.y / _Value2.y, _Value1.z / _Value2.z);
        }

double_4 Concurrency::graphics::operator/ ( const double_4 &  _Lhs, const double_4 &  _Rhs  )

inline

        {
            double_4 _Value1 = _Lhs;
            double_4 _Value2 = _Rhs;
            return double_4(_Value1.x / _Value2.x, _Value1.y / _Value2.y, _Value1.z / _Value2.z, _Value1.w / _Value2.w);
        }

bool Concurrency::graphics::operator< ( const unorm &  _Lhs, const unorm &  _Rhs  )

inline

        {
            return float(_Lhs) < float(_Rhs);
        }

bool Concurrency::graphics::operator< ( const norm &  _Lhs, const norm &  _Rhs  )

inline

        {
            return float(_Lhs) < float(_Rhs);
        }

uint_2 Concurrency::graphics::operator<< ( const uint_2 &  _Lhs, const uint_2 &  _Rhs  )

inline

        {
            uint_2 _Value1 = _Lhs;
            uint_2 _Value2 = _Rhs;
            return uint_2(_Value1.x << _Value2.x, _Value1.y << _Value2.y);
        }

uint_3 Concurrency::graphics::operator<< ( const uint_3 &  _Lhs, const uint_3 &  _Rhs  )

inline

        {
            uint_3 _Value1 = _Lhs;
            uint_3 _Value2 = _Rhs;
            return uint_3(_Value1.x << _Value2.x, _Value1.y << _Value2.y, _Value1.z << _Value2.z);
        }

uint_4 Concurrency::graphics::operator<< ( const uint_4 &  _Lhs, const uint_4 &  _Rhs  )

inline

        {
            uint_4 _Value1 = _Lhs;
            uint_4 _Value2 = _Rhs;
            return uint_4(_Value1.x << _Value2.x, _Value1.y << _Value2.y, _Value1.z << _Value2.z, _Value1.w << _Value2.w);
        }

int_2 Concurrency::graphics::operator<< ( const int_2 &  _Lhs, const int_2 &  _Rhs  )

inline

        {
            int_2 _Value1 = _Lhs;
            int_2 _Value2 = _Rhs;
            return int_2(_Value1.x << _Value2.x, _Value1.y << _Value2.y);
        }

int_3 Concurrency::graphics::operator<< ( const int_3 &  _Lhs, const int_3 &  _Rhs  )

inline

        {
            int_3 _Value1 = _Lhs;
            int_3 _Value2 = _Rhs;
            return int_3(_Value1.x << _Value2.x, _Value1.y << _Value2.y, _Value1.z << _Value2.z);
        }

int_4 Concurrency::graphics::operator<< ( const int_4 &  _Lhs, const int_4 &  _Rhs  )

inline

        {
            int_4 _Value1 = _Lhs;
            int_4 _Value2 = _Rhs;
            return int_4(_Value1.x << _Value2.x, _Value1.y << _Value2.y, _Value1.z << _Value2.z, _Value1.w << _Value2.w);
        }

bool Concurrency::graphics::operator<= ( const unorm &  _Lhs, const unorm &  _Rhs  )

inline

        {
            return float(_Lhs) <= float(_Rhs);
        }

bool Concurrency::graphics::operator<= ( const norm &  _Lhs, const norm &  _Rhs  )

inline

        {
            return float(_Lhs) <= float(_Rhs);
        }

bool Concurrency::graphics::operator== ( const unorm &  _Lhs, const unorm &  _Rhs  )

inline

        {
            return float(_Lhs) == float(_Rhs);
        }

bool Concurrency::graphics::operator== ( const norm &  _Lhs, const norm &  _Rhs  )

inline

        {
            return float(_Lhs) == float(_Rhs);
        }

bool Concurrency::graphics::operator== ( const uint_2 &  _Lhs, const uint_2 &  _Rhs  )

inline

        {
            uint_2 _Value1 = _Lhs;
            uint_2 _Value2 = _Rhs;
            return _Value1.x == _Value2.x && _Value1.y == _Value2.y;
        }

bool Concurrency::graphics::operator== ( const uint_3 &  _Lhs, const uint_3 &  _Rhs  )

inline

        {
            uint_3 _Value1 = _Lhs;
            uint_3 _Value2 = _Rhs;
            return _Value1.x == _Value2.x && _Value1.y == _Value2.y && _Value1.z == _Value2.z;
        }

bool Concurrency::graphics::operator== ( const uint_4 &  _Lhs, const uint_4 &  _Rhs  )

inline

        {
            uint_4 _Value1 = _Lhs;
            uint_4 _Value2 = _Rhs;
            return _Value1.x == _Value2.x && _Value1.y == _Value2.y && _Value1.z == _Value2.z && _Value1.w == _Value2.w;
        }

bool Concurrency::graphics::operator== ( const int_2 &  _Lhs, const int_2 &  _Rhs  )

inline

        {
            int_2 _Value1 = _Lhs;
            int_2 _Value2 = _Rhs;
            return _Value1.x == _Value2.x && _Value1.y == _Value2.y;
        }

bool Concurrency::graphics::operator== ( const int_3 &  _Lhs, const int_3 &  _Rhs  )

inline

        {
            int_3 _Value1 = _Lhs;
            int_3 _Value2 = _Rhs;
            return _Value1.x == _Value2.x && _Value1.y == _Value2.y && _Value1.z == _Value2.z;
        }

bool Concurrency::graphics::operator== ( const int_4 &  _Lhs, const int_4 &  _Rhs  )

inline

        {
            int_4 _Value1 = _Lhs;
            int_4 _Value2 = _Rhs;
            return _Value1.x == _Value2.x && _Value1.y == _Value2.y && _Value1.z == _Value2.z && _Value1.w == _Value2.w;
        }

bool Concurrency::graphics::operator== ( const float_2 &  _Lhs, const float_2 &  _Rhs  )

inline

        {
            float_2 _Value1 = _Lhs;
            float_2 _Value2 = _Rhs;
            return _Value1.x == _Value2.x && _Value1.y == _Value2.y;
        }

bool Concurrency::graphics::operator== ( const float_3 &  _Lhs, const float_3 &  _Rhs  )

inline

        {
            float_3 _Value1 = _Lhs;
            float_3 _Value2 = _Rhs;
            return _Value1.x == _Value2.x && _Value1.y == _Value2.y && _Value1.z == _Value2.z;
        }

bool Concurrency::graphics::operator== ( const float_4 &  _Lhs, const float_4 &  _Rhs  )

inline

        {
            float_4 _Value1 = _Lhs;
            float_4 _Value2 = _Rhs;
            return _Value1.x == _Value2.x && _Value1.y == _Value2.y && _Value1.z == _Value2.z && _Value1.w == _Value2.w;
        }

bool Concurrency::graphics::operator== ( const unorm_2 &  _Lhs, const unorm_2 &  _Rhs  )

inline

        {
            unorm_2 _Value1 = _Lhs;
            unorm_2 _Value2 = _Rhs;
            return _Value1.x == _Value2.x && _Value1.y == _Value2.y;
        }

bool Concurrency::graphics::operator== ( const unorm_3 &  _Lhs, const unorm_3 &  _Rhs  )

inline

        {
            unorm_3 _Value1 = _Lhs;
            unorm_3 _Value2 = _Rhs;
            return _Value1.x == _Value2.x && _Value1.y == _Value2.y && _Value1.z == _Value2.z;
        }

bool Concurrency::graphics::operator== ( const unorm_4 &  _Lhs, const unorm_4 &  _Rhs  )

inline

        {
            unorm_4 _Value1 = _Lhs;
            unorm_4 _Value2 = _Rhs;
            return _Value1.x == _Value2.x && _Value1.y == _Value2.y && _Value1.z == _Value2.z && _Value1.w == _Value2.w;
        }

bool Concurrency::graphics::operator== ( const norm_2 &  _Lhs, const norm_2 &  _Rhs  )

inline

        {
            norm_2 _Value1 = _Lhs;
            norm_2 _Value2 = _Rhs;
            return _Value1.x == _Value2.x && _Value1.y == _Value2.y;
        }

bool Concurrency::graphics::operator== ( const norm_3 &  _Lhs, const norm_3 &  _Rhs  )

inline

        {
            norm_3 _Value1 = _Lhs;
            norm_3 _Value2 = _Rhs;
            return _Value1.x == _Value2.x && _Value1.y == _Value2.y && _Value1.z == _Value2.z;
        }

bool Concurrency::graphics::operator== ( const norm_4 &  _Lhs, const norm_4 &  _Rhs  )

inline

        {
            norm_4 _Value1 = _Lhs;
            norm_4 _Value2 = _Rhs;
            return _Value1.x == _Value2.x && _Value1.y == _Value2.y && _Value1.z == _Value2.z && _Value1.w == _Value2.w;
        }

bool Concurrency::graphics::operator== ( const double_2 &  _Lhs, const double_2 &  _Rhs  )

inline

        {
            double_2 _Value1 = _Lhs;
            double_2 _Value2 = _Rhs;
            return _Value1.x == _Value2.x && _Value1.y == _Value2.y;
        }

bool Concurrency::graphics::operator== ( const double_3 &  _Lhs, const double_3 &  _Rhs  )

inline

        {
            double_3 _Value1 = _Lhs;
            double_3 _Value2 = _Rhs;
            return _Value1.x == _Value2.x && _Value1.y == _Value2.y && _Value1.z == _Value2.z;
        }

bool Concurrency::graphics::operator== ( const double_4 &  _Lhs, const double_4 &  _Rhs  )

inline

        {
            double_4 _Value1 = _Lhs;
            double_4 _Value2 = _Rhs;
            return _Value1.x == _Value2.x && _Value1.y == _Value2.y && _Value1.z == _Value2.z && _Value1.w == _Value2.w;
        }

bool Concurrency::graphics::operator> ( const unorm &  _Lhs, const unorm &  _Rhs  )

inline

        {
            return float(_Lhs) > float(_Rhs);
        }

bool Concurrency::graphics::operator> ( const norm &  _Lhs, const norm &  _Rhs  )

inline

        {
            return float(_Lhs) > float(_Rhs);
        }

bool Concurrency::graphics::operator>= ( const unorm &  _Lhs, const unorm &  _Rhs  )

inline

        {
            return float(_Lhs) >= float(_Rhs);
        }

bool Concurrency::graphics::operator>= ( const norm &  _Lhs, const norm &  _Rhs  )

inline

        {
            return float(_Lhs) >= float(_Rhs);
        }

uint_2 Concurrency::graphics::operator>> ( const uint_2 &  _Lhs, const uint_2 &  _Rhs  )

inline

        {
            uint_2 _Value1 = _Lhs;
            uint_2 _Value2 = _Rhs;
            return uint_2(_Value1.x >> _Value2.x, _Value1.y >> _Value2.y);
        }

uint_3 Concurrency::graphics::operator>> ( const uint_3 &  _Lhs, const uint_3 &  _Rhs  )

inline

        {
            uint_3 _Value1 = _Lhs;
            uint_3 _Value2 = _Rhs;
            return uint_3(_Value1.x >> _Value2.x, _Value1.y >> _Value2.y, _Value1.z >> _Value2.z);
        }

uint_4 Concurrency::graphics::operator>> ( const uint_4 &  _Lhs, const uint_4 &  _Rhs  )

inline

        {
            uint_4 _Value1 = _Lhs;
            uint_4 _Value2 = _Rhs;
            return uint_4(_Value1.x >> _Value2.x, _Value1.y >> _Value2.y, _Value1.z >> _Value2.z, _Value1.w >> _Value2.w);
        }

int_2 Concurrency::graphics::operator>> ( const int_2 &  _Lhs, const int_2 &  _Rhs  )

inline

        {
            int_2 _Value1 = _Lhs;
            int_2 _Value2 = _Rhs;
            return int_2(_Value1.x >> _Value2.x, _Value1.y >> _Value2.y);
        }

int_3 Concurrency::graphics::operator>> ( const int_3 &  _Lhs, const int_3 &  _Rhs  )

inline

        {
            int_3 _Value1 = _Lhs;
            int_3 _Value2 = _Rhs;
            return int_3(_Value1.x >> _Value2.x, _Value1.y >> _Value2.y, _Value1.z >> _Value2.z);
        }

int_4 Concurrency::graphics::operator>> ( const int_4 &  _Lhs, const int_4 &  _Rhs  )

inline

        {
            int_4 _Value1 = _Lhs;
            int_4 _Value2 = _Rhs;
            return int_4(_Value1.x >> _Value2.x, _Value1.y >> _Value2.y, _Value1.z >> _Value2.z, _Value1.w >> _Value2.w);
        }

uint_2 Concurrency::graphics::operator^ ( const uint_2 &  _Lhs, const uint_2 &  _Rhs  )

inline

        {
            uint_2 _Value1 = _Lhs;
            uint_2 _Value2 = _Rhs;
            return uint_2(_Value1.x ^ _Value2.x, _Value1.y ^ _Value2.y);
        }

uint_3 Concurrency::graphics::operator^ ( const uint_3 &  _Lhs, const uint_3 &  _Rhs  )

inline

        {
            uint_3 _Value1 = _Lhs;
            uint_3 _Value2 = _Rhs;
            return uint_3(_Value1.x ^ _Value2.x, _Value1.y ^ _Value2.y, _Value1.z ^ _Value2.z);
        }

uint_4 Concurrency::graphics::operator^ ( const uint_4 &  _Lhs, const uint_4 &  _Rhs  )

inline

        {
            uint_4 _Value1 = _Lhs;
            uint_4 _Value2 = _Rhs;
            return uint_4(_Value1.x ^ _Value2.x, _Value1.y ^ _Value2.y, _Value1.z ^ _Value2.z, _Value1.w ^ _Value2.w);
        }

int_2 Concurrency::graphics::operator^ ( const int_2 &  _Lhs, const int_2 &  _Rhs  )

inline

        {
            int_2 _Value1 = _Lhs;
            int_2 _Value2 = _Rhs;
            return int_2(_Value1.x ^ _Value2.x, _Value1.y ^ _Value2.y);
        }

int_3 Concurrency::graphics::operator^ ( const int_3 &  _Lhs, const int_3 &  _Rhs  )

inline

        {
            int_3 _Value1 = _Lhs;
            int_3 _Value2 = _Rhs;
            return int_3(_Value1.x ^ _Value2.x, _Value1.y ^ _Value2.y, _Value1.z ^ _Value2.z);
        }

int_4 Concurrency::graphics::operator^ ( const int_4 &  _Lhs, const int_4 &  _Rhs  )

inline

        {
            int_4 _Value1 = _Lhs;
            int_4 _Value2 = _Rhs;
            return int_4(_Value1.x ^ _Value2.x, _Value1.y ^ _Value2.y, _Value1.z ^ _Value2.z, _Value1.w ^ _Value2.w);
        }

uint_2 Concurrency::graphics::operator| ( const uint_2 &  _Lhs, const uint_2 &  _Rhs  )

inline

        {
            uint_2 _Value1 = _Lhs;
            uint_2 _Value2 = _Rhs;
            return uint_2(_Value1.x | _Value2.x, _Value1.y | _Value2.y);
        }

uint_3 Concurrency::graphics::operator| ( const uint_3 &  _Lhs, const uint_3 &  _Rhs  )

inline

        {
            uint_3 _Value1 = _Lhs;
            uint_3 _Value2 = _Rhs;
            return uint_3(_Value1.x | _Value2.x, _Value1.y | _Value2.y, _Value1.z | _Value2.z);
        }

uint_4 Concurrency::graphics::operator| ( const uint_4 &  _Lhs, const uint_4 &  _Rhs  )

inline

        {
            uint_4 _Value1 = _Lhs;
            uint_4 _Value2 = _Rhs;
            return uint_4(_Value1.x | _Value2.x, _Value1.y | _Value2.y, _Value1.z | _Value2.z, _Value1.w | _Value2.w);
        }

int_2 Concurrency::graphics::operator| ( const int_2 &  _Lhs, const int_2 &  _Rhs  )

inline

        {
            int_2 _Value1 = _Lhs;
            int_2 _Value2 = _Rhs;
            return int_2(_Value1.x | _Value2.x, _Value1.y | _Value2.y);
        }

int_3 Concurrency::graphics::operator| ( const int_3 &  _Lhs, const int_3 &  _Rhs  )

inline

        {
            int_3 _Value1 = _Lhs;
            int_3 _Value2 = _Rhs;
            return int_3(_Value1.x | _Value2.x, _Value1.y | _Value2.y, _Value1.z | _Value2.z);
        }

int_4 Concurrency::graphics::operator| ( const int_4 &  _Lhs, const int_4 &  _Rhs  )

inline

        {
            int_4 _Value1 = _Lhs;
            int_4 _Value2 = _Rhs;
            return int_4(_Value1.x | _Value2.x, _Value1.y | _Value2.y, _Value1.z | _Value2.z, _Value1.w | _Value2.w);
        }