texture.hpp

Go to the documentation of this file.

#pragma once

#include "image.hpp"
#include "target.hpp"

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::data_type data_type;
                typedef storage::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 genType>
                size_type size(size_type Level) const;

                void* data();

                template <typename genType>
                genType* data();

                void const* data() const;

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

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

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

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

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

                void clear();

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

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

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

        protected:
                size_type base_offset(size_type Layer, size_type Face, size_type Level) const;

                struct cache
                {
                        data_type* Data;
                        size_type Size;
                };

                std::shared_ptr<storage> 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;
                cache Cache;

        private:
                void build_cache();
        };

}//namespace gli

#include "./core/texture.inl"