source/texture2d.cpp

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