source/texture2d.cpp

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