source/core/texture.cpp

   1 #include <msp/io/memory.h>
   2 #include "error.h"
   3 #include "resourcemanager.h"
   4 #include "texture.h"
   5
   6 using namespace std;
   7
   8 namespace Msp {
   9 namespace GL {
  10
  11 Texture::Texture(unsigned t, ResourceManager *m):
  12         TextureBackend(t, !m),
  13         format(NO_PIXELFORMAT),
  14         storage_fmt(format),
  15         swizzle(NO_SWIZZLE),
  16         use_srgb_format(false),
  17         auto_gen_mipmap(false)
  18 {
  19         if(m)
  20                 set_manager(m);
  21 }
  22
  23 void Texture::set_format(PixelFormat fmt)
  24 {
  25         PixelComponents comp = get_components(fmt);
  26         PixelComponents st_comp = comp;
  27         FormatSwizzle swiz = NO_SWIZZLE;
  28         switch(comp)
  29         {
  30         case LUMINANCE:
  31                 st_comp = RED;
  32                 swiz = R_TO_LUMINANCE;
  33                 break;
  34         case LUMINANCE_ALPHA:
  35                 st_comp = RG;
  36                 swiz = RG_TO_LUMINANCE_ALPHA;
  37                 break;
  38         case BGR:
  39                 st_comp = RGB;
  40                 swiz = RGB_TO_BGR;
  41                 break;
  42         case BGRA:
  43                 st_comp = RGBA;
  44                 swiz = RGB_TO_BGR;
  45                 break;
  46         default:;
  47         }
  48
  49         PixelFormat st_fmt = make_pixelformat(st_comp, get_component_type(fmt), is_srgb(fmt));
  50         require_pixelformat(st_fmt);
  51         if(swiz!=NO_SWIZZLE)
  52                 require_swizzle();
  53
  54         format = fmt;
  55         storage_fmt = st_fmt;
  56         swizzle = swiz;
  57 }
  58
  59 void Texture::load_image(const string &fn, unsigned lv)
  60 {
  61         Graphics::Image img;
  62         img.load_file(fn);
  63
  64         image(img, lv);
  65 }
  66
  67
  68 Texture::Loader::Loader(Texture &t):
  69         DataFile::CollectionObjectLoader<Texture>(t, 0)
  70 {
  71         init();
  72 }
  73
  74 Texture::Loader::Loader(Texture &t, Collection &c):
  75         DataFile::CollectionObjectLoader<Texture>(t, &c)
  76 {
  77         init();
  78 }
  79
  80 void Texture::Loader::init()
  81 {
  82         levels = 0;
  83
  84         add("external_image", &Loader::external_image);
  85         add("external_image_srgb", &Loader::external_image_srgb);
  86         add("generate_mipmap", &Loader::generate_mipmap);
  87         add("image_data", &Loader::image_data);
  88         add("mipmap_levels", &Loader::mipmap_levels);
  89 }
  90
  91 void Texture::Loader::finish()
  92 {
  93         if(obj.auto_gen_mipmap)
  94                 obj.generate_mipmap();
  95 }
  96
  97 void Texture::Loader::load_external_image(Graphics::Image &img, const string &fn)
  98 {
  99         RefPtr<IO::Seekable> io = get_collection().open_raw(fn);
 100         if(!io)
 101                 throw IO::file_not_found(fn);
 102         img.load_io(*io);
 103 }
 104
 105 void Texture::Loader::external_image(const string &fn)
 106 {
 107         obj.use_srgb_format = false;
 108         external_image_common(fn);
 109 }
 110
 111 void Texture::Loader::external_image_srgb(const string &fn)
 112 {
 113         obj.use_srgb_format = true;
 114         external_image_common(fn);
 115 }
 116
 117 void Texture::Loader::external_image_common(const string &fn)
 118 {
 119         if(obj.manager)
 120                 obj.manager->set_resource_location(obj, get_collection(), fn);
 121         else
 122         {
 123                 Graphics::Image img;
 124                 load_external_image(img, fn);
 125                 obj.image(img, levels);
 126         }
 127 }
 128
 129 void Texture::Loader::generate_mipmap(bool gm)
 130 {
 131         obj.auto_gen_mipmap = gm;
 132 }
 133
 134 void Texture::Loader::image_data(const string &data)
 135 {
 136         if(obj.manager)
 137         {
 138                 obj.set_manager(0);
 139                 if(!obj.id)
 140                         obj.generate_id();
 141         }
 142
 143         Graphics::Image img;
 144         IO::Memory mem(data.data(), data.size());
 145         img.load_io(mem);
 146
 147         obj.image(img, levels);
 148 }
 149
 150 void Texture::Loader::mipmap_levels(unsigned l)
 151 {
 152         levels = l;
 153 }
 154
 155 } // namespace GL
 156 } // namespace Msp