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