/usr/include/gli/texture.hpp is in libgli-dev 0.8.2.0+ds1-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 | /// @brief Include to use generic textures which can represent any texture target but they don't have target specific built-in caches making accesses slower.
/// @file gli/texture.hpp
#pragma once
#include "image.hpp"
#include "target.hpp"
#include "levels.hpp"
#include <array>
namespace gli
{
/// Genetic texture class. It can support any target.
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;
/// Create an empty texture instance
texture();
/// Create a texture object and allocate a texture storage for it
/// @param Target Type/Shape of the texture storage_linear
/// @param Format Texel format
/// @param Extent Size of the texture: width, height and depth.
/// @param Layers Number of one-dimensional or two-dimensional images of identical size and format
/// @param Faces 6 for cube map textures otherwise 1.
/// @param Levels Number of images in the texture mipmap chain.
/// @param Swizzles A mechanism to swizzle the components of a texture before they are applied according to the texture environment.
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));
/// Create a texture object by sharing an existing texture storage_type from another texture instance.
/// This texture object is effectively a texture view where the layer, the face and the level allows identifying
/// a specific subset of the texture storage_linear source.
/// This texture object is effectively a texture view where the target and format can be reinterpreted
/// with a different compatible texture target and texture format.
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));
/// Create a texture object by sharing an existing texture storage_type from another texture instance.
/// This texture object is effectively a texture view where the target and format can be reinterpreted
/// with a different compatible texture target and texture format.
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(){}
/// Return whether the texture instance is empty, no storage_type or description have been assigned to the instance.
bool empty() const;
/// Return the target of a texture instance.
target_type target() const{return this->Target;}
/// Return the texture instance format
format_type format() const;
swizzles_type swizzles() const;
/// Return the base layer of the texture instance, effectively a memory offset in the actual texture storage_type to identify where to start reading the layers.
size_type base_layer() const;
/// Return the max layer of the texture instance, effectively a memory offset to the beginning of the last layer in the actual texture storage_type that the texture instance can access.
size_type max_layer() const;
/// Return max_layer() - base_layer() + 1
size_type layers() const;
/// Return the base face of the texture instance, effectively a memory offset in the actual texture storage_type to identify where to start reading the faces.
size_type base_face() const;
/// Return the max face of the texture instance, effectively a memory offset to the beginning of the last face in the actual texture storage_type that the texture instance can access.
size_type max_face() const;
/// Return max_face() - base_face() + 1
size_type faces() const;
/// Return the base level of the texture instance, effectively a memory offset in the actual texture storage_type to identify where to start reading the levels.
size_type base_level() const;
/// Return the max level of the texture instance, effectively a memory offset to the beginning of the last level in the actual texture storage_type that the texture instance can access.
size_type max_level() const;
/// Return max_level() - base_level() + 1.
size_type levels() const;
/// Return the size of a texture instance: width, height and depth.
extent_type extent(size_type Level = 0) const;
/// Return the memory size of a texture instance storage_type in bytes.
size_type size() const;
/// Return the number of blocks contained in a texture instance storage_type.
/// genType size must match the block size conresponding to the texture format.
template <typename genType>
size_type size() const;
/// Return the memory size of a specific level identified by Level.
size_type size(size_type Level) const;
/// Return the memory size of a specific level identified by Level.
/// genType size must match the block size conresponding to the texture format.
template <typename gen_type>
size_type size(size_type Level) const;
/// Return a pointer to the beginning of the texture instance data.
void* data();
/// Return a pointer of type genType which size must match the texture format block size
template <typename gen_type>
gen_type* data();
/// Return a pointer to the beginning of the texture instance data.
void const* data() const;
/// Return a pointer of type genType which size must match the texture format block size
template <typename gen_type>
gen_type const* data() const;
/// Return a pointer to the beginning of the texture instance data.
void* data(size_type Layer, size_type Face, size_type Level);
/// Return a pointer to the beginning of the texture instance data.
void const* const data(size_type Layer, size_type Face, size_type Level) const;
/// Return a pointer of type genType which size must match the texture format block size
template <typename gen_type>
gen_type* data(size_type Layer, size_type Face, size_type Level);
/// Return a pointer of type genType which size must match the texture format block size
template <typename gen_type>
gen_type const* const data(size_type Layer, size_type Face, size_type Level) const;
/// Clear the entire texture storage_linear with zeros
void clear();
/// Clear the entire texture storage_linear with Texel which type must match the texture storage_linear format block size
/// If the type of gen_type doesn't match the type of the texture format, no conversion is performed and the data will be reinterpreted as if is was of the texture format.
template <typename gen_type>
void clear(gen_type const& Texel);
/// Clear a specific image of a texture.
template <typename gen_type>
void clear(size_type Layer, size_type Face, size_type Level, gen_type const& BlockData);
/// Clear a subset of a specific image of a texture.
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);
/// Copy a specific image of a texture
void copy(
texture const& TextureSrc,
size_t LayerSrc, size_t FaceSrc, size_t LevelSrc,
size_t LayerDst, size_t FaceDst, size_t LevelDst);
/// Copy a subset of a specific image of a texture
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);
/// Reorder the component in texture memory.
template <typename gen_type>
void swizzle(gli::swizzles const& Swizzles);
/// Fetch a texel from a texture. The texture format must be uncompressed.
template <typename gen_type>
gen_type load(extent_type const & TexelCoord, size_type Layer, size_type Face, size_type Level) const;
/// Write a texel to a texture. The texture format must be uncompressed.
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 Target;
format_type Format;
size_type BaseLayer;
size_type MaxLayer;
size_type BaseFace;
size_type MaxFace;
size_type BaseLevel;
size_type MaxLevel;
swizzles_type 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"
|