texture.hpp

Go to the documentation of this file.

#pragma once

#include "image.hpp"
#include "target.hpp"
#include "levels.hpp"
#include <array>

namespace gli
{
        class texture
        {
        public:
                typedef size_t size_type;
                typedef gli::target target_type;
                typedef gli::format format_type;
                typedef gli::swizzles swizzles_type;
                typedef storage_linear storage_type;
                typedef storage_type::data_type data_type;
                typedef storage_type::extent_type extent_type;

                texture();

                texture(
                        target_type Target,
                        format_type Format,
                        extent_type const& Extent,
                        size_type Layers,
                        size_type Faces,
                        size_type Levels,
                        swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA));

                texture(
                        texture const& Texture,
                        target_type Target,
                        format_type Format,
                        size_type BaseLayer, size_type MaxLayer,
                        size_type BaseFace, size_type MaxFace,
                        size_type BaseLevel, size_type MaxLevel,
                        swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA));

                texture(
                        texture const& Texture,
                        target_type Target,
                        format_type Format,
                        swizzles_type const& Swizzles = swizzles_type(SWIZZLE_RED, SWIZZLE_GREEN, SWIZZLE_BLUE, SWIZZLE_ALPHA));

                virtual ~texture(){}

                bool empty() const;

                target_type target() const{return this->Target;}

                format_type format() const;

                swizzles_type swizzles() const;

                size_type base_layer() const;

                size_type max_layer() const;

                size_type layers() const;

                size_type base_face() const;

                size_type max_face() const;

                size_type faces() const;

                size_type base_level() const;

                size_type max_level() const;

                size_type levels() const;

                extent_type extent(size_type Level = 0) const;

                size_type size() const;

                template <typename genType>
                size_type size() const;

                size_type size(size_type Level) const;

                template <typename gen_type>
                size_type size(size_type Level) const;

                void* data();

                template <typename gen_type>
                gen_type* data();

                void const* data() const;

                template <typename gen_type>
                gen_type const* data() const;

                void* data(size_type Layer, size_type Face, size_type Level);

                void const* const data(size_type Layer, size_type Face, size_type Level) const;

                template <typename gen_type>
                gen_type* data(size_type Layer, size_type Face, size_type Level);

                template <typename gen_type>
                gen_type const* const data(size_type Layer, size_type Face, size_type Level) const;

                void clear();

                template <typename gen_type>
                void clear(gen_type const& Texel);

                template <typename gen_type>
                void clear(size_type Layer, size_type Face, size_type Level, gen_type const& BlockData);

                template <typename gen_type>
                void clear(size_type Layer, size_type Face, size_type Level, extent_type const& TexelOffset, extent_type const& TexelExtent, gen_type const& BlockData);

                void copy(
                        texture const& TextureSrc,
                        size_t LayerSrc, size_t FaceSrc, size_t LevelSrc,
                        size_t LayerDst, size_t FaceDst, size_t LevelDst);

                void copy(
                        texture const& TextureSrc,
                        size_t LayerSrc, size_t FaceSrc, size_t LevelSrc, extent_type const& OffsetSrc,
                        size_t LayerDst, size_t FaceDst, size_t LevelDst, extent_type const& OffsetDst,
                        extent_type const& Extent);

                template <typename gen_type>
                void swizzle(gli::swizzles const& Swizzles);

                template <typename gen_type>
                gen_type load(extent_type const & TexelCoord, size_type Layer, size_type Face, size_type Level) const;

                template <typename gen_type>
                void store(extent_type const& TexelCoord, size_type Layer, size_type Face, size_type Level, gen_type const& Texel);

        protected:
                std::shared_ptr<storage_type> Storage;
                target_type const Target;
                format_type const Format;
                size_type const BaseLayer;
                size_type const MaxLayer;
                size_type const BaseFace;
                size_type const MaxFace;
                size_type const BaseLevel;
                size_type const MaxLevel;
                swizzles_type const Swizzles;

                // Pre compute at texture instance creation some information for faster access to texels
                struct cache
                {
                public:
                        enum ctor
                        {
                                DEFAULT
                        };

                        explicit cache(ctor)
                        {}

                        cache
                        (
                                storage_type& Storage,
                                format_type Format,
                                size_type BaseLayer, size_type Layers,
                                size_type BaseFace, size_type MaxFace,
                                size_type BaseLevel, size_type MaxLevel
                        )
                                : Faces(MaxFace - BaseFace + 1)
                                , Levels(MaxLevel - BaseLevel + 1)
                        {
                                GLI_ASSERT(static_cast<size_t>(gli::levels(Storage.extent(0))) < this->ImageMemorySize.size());

                                this->BaseAddresses.resize(Layers * this->Faces * this->Levels);

                                for(size_type Layer = 0; Layer < Layers; ++Layer)
                                for(size_type Face = 0; Face < this->Faces; ++Face)
                                for(size_type Level = 0; Level < this->Levels; ++Level)
                                {
                                        size_type const Index = index_cache(Layer, Face, Level);
                                        this->BaseAddresses[Index] = Storage.data() + Storage.base_offset(
                                                BaseLayer + Layer, BaseFace + Face, BaseLevel + Level);
                                }

                                for(size_type Level = 0; Level < this->Levels; ++Level)
                                {
                                        extent_type const& SrcExtent = Storage.extent(BaseLevel + Level);
                                        extent_type const& DstExtent = SrcExtent * block_extent(Format) / Storage.block_extent();

                                        this->ImageExtent[Level] = glm::max(DstExtent, extent_type(1));
                                        this->ImageMemorySize[Level] = Storage.level_size(BaseLevel + Level);
                                }
                                
                                this->GlobalMemorySize = Storage.layer_size(BaseFace, MaxFace, BaseLevel, MaxLevel) * Layers;
                        }

                        // Base addresses of each images of a texture.
                        data_type* get_base_address(size_type Layer, size_type Face, size_type Level) const
                        {
                                return this->BaseAddresses[index_cache(Layer, Face, Level)];
                        }

                        // In texels
                        extent_type get_extent(size_type Level) const
                        {
                                return this->ImageExtent[Level];
                        };

                        // In bytes
                        size_type get_memory_size(size_type Level) const
                        {
                                return this->ImageMemorySize[Level];
                        };

                        // In bytes
                        size_type get_memory_size() const
                        {
                                return this->GlobalMemorySize;
                        };

                private:
                        size_type index_cache(size_type Layer, size_type Face, size_type Level) const
                        {
                                return ((Layer * this->Faces) + Face) * this->Levels + Level;
                        }

                        size_type Faces;
                        size_type Levels;
                        std::vector<data_type*> BaseAddresses;
                        std::array<extent_type, 16> ImageExtent;
                        std::array<size_type, 16> ImageMemorySize;
                        size_type GlobalMemorySize;
                } Cache;
        };
}//namespace gli

#include "./core/texture.inl"