Concurrency::graphics::details::_Texture_base< _Value_type, _Rank > Class Template Reference

#include <amp_graphics.h>

Inheritance diagram for Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >:

Public Types
typedef _Value_type	value_type
typedef _Short_vector_type_traits< _Value_type >::_Scalar_type	scalar_type

Public Member Functions
__declspec(property(get=get_extent)) Concurrency Concurrency::extent< _Rank >	get_extent () const __GPU
	Returns the extent that defines the shape of this texture or texture view. More...
Concurrency::extent< _Rank >	get_mipmap_extent (unsigned int _Mipmap_level) const __CPU_ONLY
	Returns the extent for specific mipmap level of this texture or texture view. More...
Concurrency::extent< _Rank >	get_mipmap_extent (unsigned int _Mipmap_level) const __GPU_ONLY
	Returns the extent for specific mipmap level of this texture or texture view. More...
__declspec(property(get=get_accelerator_view)) Concurrency Concurrency::accelerator_view	get_accelerator_view () const __CPU_ONLY
	Returns the accelerator_view where this texture or texture view is located. More...
	__declspec (property(get=get_bits_per_scalar_element)) unsigned int bits_per_scalar_element
	Returns the number of bits per scalar element More...
unsigned int	get_bits_per_scalar_element () const __CPU_ONLY
	__declspec (property(get=get_mipmap_levels)) unsigned int mipmap_levels
	Query how many mipmap levels are accessible by this texture (or texture view). More...
unsigned int	get_mipmap_levels () const __GPU
	__declspec (property(get=get_data_length)) unsigned int data_length
	Returns the physical data length (in bytes) that is required in order to represent the texture on the host side with its native format. If the texture contains multiple mipmap levels the value represents the sum of physical data length for each accessible mipmap level by this texture (or texture view). More...
unsigned int	get_data_length () const __CPU_ONLY

Static Public Attributes
static const int	rank = _Rank

Protected Types
typedef Concurrency::details::_Texture_descriptor	_Texture_descriptor

Protected Member Functions
	_Texture_base () __CPU_ONLY
	_Texture_base (const Concurrency::extent< _Rank > &_Ext, unsigned int _Mipmap_levels=1) __CPU_ONLY
	_Texture_base (const _Texture_base &_Src) __GPU
	_Texture_base (const _Texture_base &_Src, unsigned int _Most_detailed_mipmap_level, unsigned int _View_mipmap_levels) __CPU_ONLY
	_Texture_base (const _Texture_base &_Src, bool _Flatten_mipmap_levels) __GPU_ONLY
	_Texture_base (const Concurrency::extent< _Rank > &_Ext, const _Texture_descriptor &_Desc) __CPU_ONLY
void	_Copy_to (const _Texture_base &_Dest) const __CPU_ONLY
bool	operator== (const _Texture_base &_Other) const __CPU_ONLY
	~_Texture_base () __GPU
_Ret_ _Texture *	_Get_texture () const __CPU_ONLY
unsigned int	_Get_most_detailed_mipmap_level () const __GPU
bool	_Are_mipmap_levels_overlapping (const _Texture_base &_Other) const __CPU_ONLY

Protected Attributes
Concurrency::extent< _Rank >	_M_extent
_Texture_descriptor	_M_texture_descriptor

Friends
template<typename _T >
const _Texture_descriptor &	Concurrency::details::_Get_texture_descriptor (const _T &_Tex) __GPU
template<typename _T >
_Ret_ _Texture *	Concurrency::details::_Get_texture (const _T &_Tex) __CPU_ONLY
template<typename _Value_type , int _Rank>
_Event	_Copy_async_impl (const _Texture_base< _Value_type, _Rank > &_Src, const index< _Rank > &_Src_offset, const _Texture_base< _Value_type, _Rank > &_Dst, const index< _Rank > &_Dst_offset, const extent< _Rank > &_Copy_extent) __CPU_ONLY

Member Typedef Documentation

template<typename _Value_type, int _Rank>

typedef Concurrency::details::_Texture_descriptor Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::_Texture_descriptor

protected

template<typename _Value_type, int _Rank>

typedef _Short_vector_type_traits<_Value_type>::_Scalar_type Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::scalar_type

template<typename _Value_type, int _Rank>

typedef _Value_type Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::value_type

Constructor & Destructor Documentation

template<typename _Value_type, int _Rank>

Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::_Texture_base ( )

inlineprotected

    {
        // This default ctor is required to enable move ctor for a derived types,
        // empty _Texture_base is later initialized by move assigment operator
    }

template<typename _Value_type, int _Rank>

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

inlineprotected

        : _M_extent(_Ext), _M_texture_descriptor(/*_Most_detailed_mipmap_level=*/0, _Mipmap_levels)
    {
        _Is_valid_extent(_M_extent);
        _Are_valid_mipmap_parameters(/*_Most_detailed_mipmap_level=*/0, _Mipmap_levels);

        // Validate if we can generate _Mipmap_levels number of mipmap levels given the dimensionality of the texture
        unsigned int _Max_mipmap_levels = _Get_max_mipmap_levels(_M_extent);
        if (_Mipmap_levels > _Max_mipmap_levels)
        {
            std::stringstream _Err_msg;
            _Err_msg << "The texture extent is too small to generate (" << _Mipmap_levels << ") mipmap levels, the maximum allowed is (" << _Max_mipmap_levels << ")";
            throw runtime_exception(_Err_msg.str().c_str(), E_INVALIDARG);
        }
        else if (_Mipmap_levels == 0) 
        {
            // Generate full range of all mipmaps
            // e.g. 2D 10x2 texture would have: 10x2, 5x1, 2x1, 1x1 (4 mipmap levels)
            _Mipmap_levels = _Max_mipmap_levels;
        }
        _M_texture_descriptor._Set_view_mipmap_levels(_Mipmap_levels);
    }

template<typename _Value_type, int _Rank>

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

inlineprotected

        : _M_extent(_Src._M_extent), _M_texture_descriptor(_Src._M_texture_descriptor)
    {
    }

template<typename _Value_type, int _Rank>

Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::_Texture_base ( const _Texture_base< _Value_type, _Rank > &  _Src, unsigned int  _Most_detailed_mipmap_level, unsigned int  _View_mipmap_levels  )

inlineprotected

        : _M_extent(_Get_extent_at_level(_Src.extent, _Most_detailed_mipmap_level)), _M_texture_descriptor(_Src._M_texture_descriptor, _Src._Get_most_detailed_mipmap_level() + _Most_detailed_mipmap_level, _View_mipmap_levels)
    {
        Concurrency::details::_Is_valid_mipmap_range(_Src.get_mipmap_levels(), _Most_detailed_mipmap_level, _View_mipmap_levels);
    }

template<typename _Value_type, int _Rank>

Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::_Texture_base ( const _Texture_base< _Value_type, _Rank > &  _Src, bool  _Flatten_mipmap_levels  )

inlineprotected

        : _M_extent(_Src.extent), _M_texture_descriptor(_Src._M_texture_descriptor, /*_Most_detailed_mipmap_level=*/0, _Flatten_mipmap_levels ? /*_View_mipmap_levels=*/1 : _Src.get_mipmap_levels())
    {
    }

template<typename _Value_type, int _Rank>

Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::_Texture_base ( const Concurrency::extent< _Rank > &  _Ext, const _Texture_descriptor &  _Desc  )

inlineprotected

        : _M_extent(_Ext), _M_texture_descriptor(_Desc)
    {
        Concurrency::details::_Is_valid_extent(_M_extent);
    }

template<typename _Value_type, int _Rank>

Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::~_Texture_base ( )

inlineprotected

    {
    }

Member Function Documentation

template<typename _Value_type, int _Rank>

Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::__declspec

(

property(get=get_bits_per_scalar_element)

)

Returns the number of bits per scalar element

template<typename _Value_type, int _Rank>

Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::__declspec

(

property(get=get_mipmap_levels)

)

Query how many mipmap levels are accessible by this texture (or texture view).

Returns

Returns number of mipmap levels accessible by this texture (or texture view).

template<typename _Value_type, int _Rank>

Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::__declspec

(

property(get=get_data_length)

)

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

template<typename _Value_type, int _Rank>

bool Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::_Are_mipmap_levels_overlapping ( const _Texture_base< _Value_type, _Rank > &  _Other ) const

inlineprotected

    {
        return _M_texture_descriptor._Are_mipmap_levels_overlapping(&_Other._M_texture_descriptor);
    }

template<typename _Value_type, int _Rank>

void Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::_Copy_to ( const _Texture_base< _Value_type, _Rank > &  _Dest ) const

inlineprotected

    {
        if (!(*this == _Dest))
        {
            _ASSERTE(this->extent == _Dest.extent);
            details::_Copy_async_impl(*this, index<_Rank>(), _Dest, index<_Rank>(), _Dest.extent)._Get();
        }
    }

template<typename _Value_type, int _Rank>

unsigned int Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::_Get_most_detailed_mipmap_level ( ) const

inlineprotected

    {
        return _M_texture_descriptor._Get_most_detailed_mipmap_level();
    }

template<typename _Value_type, int _Rank>

_Ret_ _Texture* Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::_Get_texture ( ) const

inlineprotected

    {
        return _M_texture_descriptor._Get_texture_ptr(); 
    }

template<typename _Value_type, int _Rank>

__declspec (property(get=get_accelerator_view)) Concurrency Concurrency::accelerator_view Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::get_accelerator_view ( ) const

inline

Returns the accelerator_view where this texture or texture view is located.

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

template<typename _Value_type, int _Rank>

unsigned int Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::get_bits_per_scalar_element ( ) const

inline

    {
        unsigned int _Bits_per_channel = _Get_texture()->_Get_bits_per_channel();
        return _Short_vector_type_traits<_Value_type>::_Format_base_type_id == _Double_type ? _Bits_per_channel * (sizeof(double)/sizeof(int)) : _Bits_per_channel;
    }

template<typename _Value_type, int _Rank>

unsigned int Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::get_data_length ( ) const

inline

    {
        return _Get_texture()->_Get_data_length(this->_Get_most_detailed_mipmap_level(), this->get_mipmap_levels());
    }

template<typename _Value_type, int _Rank>

__declspec (property(get=get_extent)) Concurrency Concurrency::extent<_Rank> Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::get_extent ( ) const

inline

Returns the extent that defines the shape of this texture or texture view.

    {
        return _M_extent;
    }

template<typename _Value_type, int _Rank>

Concurrency::extent<_Rank> Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::get_mipmap_extent ( unsigned int  _Mipmap_level ) const

inline

Returns the extent for specific mipmap level of this texture or texture view.

Mipmap level for which extent should be calculated.

    {
        if (_Mipmap_level >= this->get_mipmap_levels())
        {
            std::stringstream _Err_msg;
            _Err_msg << "Value for _Mipmap_level parameter (" << _Mipmap_level 
            << ") cannot be greater than or equal to number of mipmap levels (" 
            << this->get_mipmap_levels() << ") on the texture or texture view";
            
            throw runtime_exception(_Err_msg.str().c_str(), E_INVALIDARG);
        }
        return Concurrency::details::_Get_extent_at_level(_M_extent, _Mipmap_level);
    }

template<typename _Value_type, int _Rank>

Concurrency::extent<_Rank> Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::get_mipmap_extent ( unsigned int  _Mipmap_level ) const

inline

Returns the extent for specific mipmap level of this texture or texture view.

Mipmap level for which extent should be calculated.

    {
        return Concurrency::details::_Get_extent_at_level_unsafe(_M_extent, _Mipmap_level);
    }       

template<typename _Value_type, int _Rank>

unsigned int Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::get_mipmap_levels ( ) const

inline

    {
        return _M_texture_descriptor._Get_view_mipmap_levels();
    }

template<typename _Value_type, int _Rank>

bool Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::operator== ( const _Texture_base< _Value_type, _Rank > &  _Other ) const

inlineprotected

    {
        return _Other._M_extent == _M_extent && _Other._M_texture_descriptor == _M_texture_descriptor;
    }

Friends And Related Function Documentation

template<typename _Value_type, int _Rank>

template<typename _Value_type , int _Rank>

_Event _Copy_async_impl ( const _Texture_base< _Value_type, _Rank > &  _Src, const index< _Rank > &  _Src_offset, const _Texture_base< _Value_type, _Rank > &  _Dst, const index< _Rank > &  _Dst_offset, const extent< _Rank > &  _Copy_extent  )

friend

{
    _Is_valid_section(_Src.extent, _Src_offset, _Copy_extent);
    _Is_valid_section(_Dst.extent, _Dst_offset, _Copy_extent);

    _Texture_descriptor _Src_tex_desc = _Get_texture_descriptor(_Src);
    _Texture_descriptor _Dst_tex_desc = _Get_texture_descriptor(_Dst);

    if (_Src_tex_desc._Get_view_mipmap_levels() != _Dst_tex_desc._Get_view_mipmap_levels())
    {
        throw runtime_exception("The source and destination textures must have the exactly the same number of mipmap levels for texture copy.", E_INVALIDARG);
    }

    bool _Is_whole_texture_copy = (_Src_offset == _Dst_offset && _Src_offset == index<_Rank>() && _Src.extent == _Dst.extent && _Src.extent == _Copy_extent);

    if (_Src_tex_desc._Get_view_mipmap_levels() > 1 && !_Is_whole_texture_copy)
    {
        throw runtime_exception("Sections are not allowed when copy involves multiple mipmap levels", E_INVALIDARG);
    }

    if (_Src_tex_desc._Are_mipmap_levels_overlapping(&_Dst_tex_desc))
    {
        throw runtime_exception("The source and destination are overlapping areas on the same texture", E_INVALIDARG);
    }

    _Texture* _Src_tex = _Get_texture(_Src);
    _Texture* _Dst_tex = _Get_texture(_Dst);

    // Formats must be identical for non-adopted textures.  Textures created through D3D interop are not subject to this test
    // to allow copy between related, but not identical, formats.  Attempting to copy between unrelated formats through interop
    // will result in exceptions in debug mode and undefined behavior in release mode.
    if (!_Src_tex->_Is_adopted() && !_Dst_tex->_Is_adopted() && (_Src_tex->_Get_texture_format() != _Dst_tex->_Get_texture_format()))
    {
        throw runtime_exception("The source and destination textures are not compatible.", E_INVALIDARG);
    }

    std::array<size_t, 3> _Src_offset_arr = _Get_indices(_Src_offset);
    std::array<size_t, 3> _Dst_offset_arr = _Get_indices(_Dst_offset);

    _Event _Copy_event;

    unsigned int _Src_most_detailed_mipmap_level = _Src_tex_desc._Get_most_detailed_mipmap_level();
    unsigned int _Dst_most_detailed_mipmap_level = _Dst_tex_desc._Get_most_detailed_mipmap_level();

    // Copy all mipmap levels from source to destination one by one.
    // Note that the offsets are not allowed therefore only dimensions need to be updated for subsequent mipmap levels
    for (unsigned int _Mip_offset = 0; _Mip_offset < _Src_tex_desc._Get_view_mipmap_levels(); ++_Mip_offset)
    {
        std::array<size_t, 3> _Copy_extent_arr = _Get_dimensions(_Copy_extent, _Mip_offset);

        auto _Step_event = _Copy_async_impl(_Src_tex, _Src_offset_arr.data(), _Src_most_detailed_mipmap_level + _Mip_offset,
                                            _Dst_tex, _Dst_offset_arr.data(), _Dst_most_detailed_mipmap_level + _Mip_offset,
                                            _Copy_extent_arr.data());

        _Copy_event = _Copy_event._Add_event(_Step_event);
    }

    return _Copy_event;
}

template<typename _Value_type, int _Rank>

template<typename _T >

_Ret_ _Texture* Concurrency::details::_Get_texture ( const _T &  _Tex )

friend

template<typename _Value_type, int _Rank>

template<typename _T >

const _Texture_descriptor& Concurrency::details::_Get_texture_descriptor ( const _T &  _Tex )

friend

Member Data Documentation

template<typename _Value_type, int _Rank>

Concurrency::extent<_Rank> Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::_M_extent

protected

template<typename _Value_type, int _Rank>

_Texture_descriptor Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::_M_texture_descriptor

protected

template<typename _Value_type, int _Rank>

const int Concurrency::graphics::details::_Texture_base< _Value_type, _Rank >::rank = _Rank

static

---

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

• VS2013/inc/amp_graphics.h