source/texture2d.cpp

   1 #include <msp/core/raii.h>
   2 #include <msp/gl/extensions/arb_direct_state_access.h>
   3 #include <msp/gl/extensions/arb_texture_storage.h>
   4 #include "bindable.h"
   5 #include "buffer.h"
   6 #include "error.h"
   7 #include "pixelstore.h"
   8 #include "resources.h"
   9 #include "texture2d.h"
  10
  11 using namespace std;
  12
  13 namespace Msp {
  14 namespace GL {
  15
  16 class Texture2D::AsyncLoader: public Resource::AsyncLoader
  17 {
  18 private:
  19         Texture2D &texture;
  20         IO::Seekable &io;
  21         bool srgb_conversion;
  22         Buffer pixel_buffer;
  23         char *mapped_address;
  24         Graphics::Image image;
  25         unsigned n_bytes;
  26         int phase;
  27
  28 public:
  29         AsyncLoader(Texture2D &, IO::Seekable &);
  30
  31         void set_srgb_conversion(bool);
  32         virtual bool needs_sync() const;
  33         virtual bool process();
  34 };
  35
  36
  37 Texture2D::Texture2D(ResourceManager *m):
  38         Texture(GL_TEXTURE_2D, m),
  39         width(0),
  40         height(0),
  41         allocated(0)
  42 { }
  43
  44 Texture2D::~Texture2D()
  45 {
  46         set_manager(0);
  47 }
  48
  49 void Texture2D::storage(PixelFormat fmt, unsigned wd, unsigned ht)
  50 {
  51         if(width>0)
  52                 throw invalid_operation("Texture2D::storage");
  53         if(wd==0 || ht==0)
  54                 throw invalid_argument("Texture2D::storage");
  55
  56         set_internal_format(fmt);
  57         width = wd;
  58         height = ht;
  59 }
  60
  61 void Texture2D::allocate(unsigned level)
  62 {
  63         if(allocated&(1<<level))
  64                 return;
  65
  66         if(ARB_texture_storage)
  67         {
  68                 unsigned n_levels = (is_mipmapped(min_filter) ? get_n_levels() : 1);
  69                 if(ARB_direct_state_access)
  70                         glTextureStorage2D(id, n_levels, ifmt, width, height);
  71                 else
  72                 {
  73                         BindRestore _bind(this);
  74                         glTexStorage2D(target, n_levels, ifmt, width, height);
  75                 }
  76                 allocated |= (1<<n_levels)-1;
  77         }
  78         else
  79         {
  80                 PixelFormat base_fmt = get_base_pixelformat(ifmt);
  81                 image(level, base_fmt, get_alloc_type(base_fmt), 0);
  82         }
  83 }
  84
  85 void Texture2D::image(unsigned level, PixelFormat fmt, DataType type, const void *data)
  86 {
  87         if(width==0 || height==0)
  88                 throw invalid_operation("Texture2D::image");
  89
  90         unsigned w = width;
  91         unsigned h = height;
  92         get_level_size(level, w, h);
  93
  94         if(ARB_texture_storage)
  95                 return sub_image(level, 0, 0, w, h, fmt, type, data);
  96
  97         BindRestore _bind(this);
  98         glTexImage2D(target, level, ifmt, w, h, 0, fmt, type, data);
  99
 100         allocated |= 1<<level;
 101         if(gen_mipmap && level==0)
 102         {
 103                 auto_generate_mipmap();
 104                 allocated |= (1<<get_n_levels())-1;
 105         }
 106 }
 107
 108 void Texture2D::sub_image(unsigned level, int x, int y, unsigned wd, unsigned ht, PixelFormat fmt, DataType type, const void *data)
 109 {
 110         if(width==0 || height==0)
 111                 throw invalid_operation("Texture2D::sub_image");
 112
 113         Conditional<BindRestore> _bind(!ARB_direct_state_access, this);
 114         allocate(level);
 115
 116         if(ARB_direct_state_access)
 117                 glTextureSubImage2D(id, level, x, y, wd, ht, fmt, type, data);
 118         else
 119                 glTexSubImage2D(target, level, x, y, wd, ht, fmt, type, data);
 120
 121         if(gen_mipmap && level==0)
 122                 auto_generate_mipmap();
 123 }
 124
 125 void Texture2D::image(const Graphics::Image &img, bool srgb)
 126 {
 127         image(img, srgb, false);
 128 }
 129
 130 void Texture2D::image(const Graphics::Image &img, bool srgb, bool from_buffer)
 131 {
 132         unsigned w = img.get_width();
 133         unsigned h = img.get_height();
 134         PixelFormat fmt = pixelformat_from_graphics(img.get_format());
 135         if(width==0)
 136                 storage(storage_pixelformat_from_graphics(img.get_format(), srgb), w, h);
 137         else if(w!=width || h!=height)
 138                 throw incompatible_data("Texture2D::image");
 139
 140         PixelStore pstore = PixelStore::from_image(img);
 141         BindRestore _bind_ps(pstore);
 142
 143         image(0, fmt, UNSIGNED_BYTE, from_buffer ? 0 : img.get_data());
 144 }
 145
 146 unsigned Texture2D::get_n_levels() const
 147 {
 148         unsigned n = 0;
 149         for(unsigned s=max(width, height); s; s>>=1, ++n) ;
 150         return n;
 151 }
 152
 153 void Texture2D::get_level_size(unsigned level, unsigned &w, unsigned &h) const
 154 {
 155         w >>= level;
 156         h >>= level;
 157
 158         if(!w && h)
 159                 w = 1;
 160         else if(!h && w)
 161                 h = 1;
 162 }
 163
 164 Resource::AsyncLoader *Texture2D::load(IO::Seekable &io, const Resources *res)
 165 {
 166         AsyncLoader *ldr = new AsyncLoader(*this, io);
 167         if(res)
 168                 ldr->set_srgb_conversion(res->get_srgb_conversion());
 169         return ldr;
 170 }
 171
 172 UInt64 Texture2D::get_data_size() const
 173 {
 174         return id ? width*height*get_pixel_size(ifmt) : 0;
 175 }
 176
 177 void Texture2D::unload()
 178 {
 179         glDeleteTextures(1, &id);
 180         id = 0;
 181         // TODO check which params actually need refreshing
 182         dirty_params = -1;
 183 }
 184
 185
 186 Texture2D::Loader::Loader(Texture2D &t):
 187         DataFile::DerivedObjectLoader<Texture2D, Texture::Loader>(t)
 188 {
 189         init();
 190 }
 191
 192 Texture2D::Loader::Loader(Texture2D &t, Collection &c):
 193         DataFile::DerivedObjectLoader<Texture2D, Texture::Loader>(t, c)
 194 {
 195         init();
 196 }
 197
 198 void Texture2D::Loader::init()
 199 {
 200         add("raw_data", &Loader::raw_data);
 201         add("storage", &Loader::storage);
 202 }
 203
 204 void Texture2D::Loader::raw_data(const string &data)
 205 {
 206         obj.image(0, get_base_pixelformat(obj.ifmt), UNSIGNED_BYTE, data.data());
 207 }
 208
 209 void Texture2D::Loader::storage(PixelFormat fmt, unsigned w, unsigned h)
 210 {
 211         if(srgb)
 212                 fmt = get_srgb_pixelformat(fmt);
 213         obj.storage(fmt, w, h);
 214 }
 215
 216
 217 Texture2D::AsyncLoader::AsyncLoader(Texture2D &t, IO::Seekable &i):
 218         texture(t),
 219         io(i),
 220         srgb_conversion(false),
 221         pixel_buffer(PIXEL_UNPACK_BUFFER),
 222         mapped_address(0),
 223         phase(0)
 224 { }
 225
 226 void Texture2D::AsyncLoader::set_srgb_conversion(bool c)
 227 {
 228         srgb_conversion = c;
 229 }
 230
 231 bool Texture2D::AsyncLoader::needs_sync() const
 232 {
 233         return phase%2;
 234 }
 235
 236 bool Texture2D::AsyncLoader::process()
 237 {
 238         if(phase==0)
 239         {
 240                 /* TODO Enhance the ImageLoader system so that the image can be loaded
 241                 directly to the buffer */
 242                 image.load_io(io);
 243                 n_bytes = image.get_stride()*image.get_height();
 244         }
 245         else if(phase==1)
 246         {
 247                 pixel_buffer.data(n_bytes, 0);
 248                 mapped_address = reinterpret_cast<char *>(pixel_buffer.map(WRITE_ONLY));
 249         }
 250         else if(phase==2)
 251         {
 252                 const char *data = reinterpret_cast<const char *>(image.get_data());
 253                 copy(data, data+n_bytes, mapped_address);
 254         }
 255         else if(phase==3)
 256         {
 257                 Bind _bind_buf(pixel_buffer, PIXEL_UNPACK_BUFFER);
 258                 if(!pixel_buffer.unmap())
 259                 {
 260                         phase = 1;
 261                         return false;
 262                 }
 263
 264                 if(!texture.id)
 265                         glGenTextures(1, &texture.id);
 266                 texture.image(image, srgb_conversion, true);
 267         }
 268
 269         ++phase;
 270         return phase>3;
 271 }
 272
 273 } // namespace GL
 274 } // namespace Msp