source/core/texturecube.cpp

   1 #include <msp/datafile/collection.h>
   2 #include <msp/gl/extensions/arb_direct_state_access.h>
   3 #include <msp/gl/extensions/arb_seamless_cube_map.h>
   4 #include <msp/gl/extensions/arb_texture_cube_map.h>
   5 #include <msp/gl/extensions/arb_texture_storage.h>
   6 #include <msp/io/memory.h>
   7 #include <msp/strings/format.h>
   8 #include "error.h"
   9 #include "texturecube.h"
  10
  11 using namespace std;
  12
  13 namespace Msp {
  14 namespace GL {
  15
  16 const Vector3 TextureCube::directions[6] =
  17 {
  18         Vector3(1, 0, 0),
  19         Vector3(-1, 0, 0),
  20         Vector3(0, 1, 0),
  21         Vector3(0, -1, 0),
  22         Vector3(0, 0, 1),
  23         Vector3(0, 0, -1)
  24 };
  25
  26 const unsigned TextureCube::orientations[12] =
  27 {
  28         5, 3,
  29         4, 3,
  30         0, 4,
  31         0, 5,
  32         0, 3,
  33         1, 3
  34 };
  35
  36 TextureCube::TextureCube():
  37         Texture(GL_TEXTURE_CUBE_MAP),
  38         size(0)
  39 {
  40         static Require _req(ARB_texture_cube_map);
  41         if(ARB_seamless_cube_map)
  42         {
  43                 static bool seamless_init = false;
  44                 if(!seamless_init)
  45                 {
  46                         glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
  47                         seamless_init = true;
  48                 }
  49         }
  50 }
  51
  52 void TextureCube::storage(PixelFormat fmt, unsigned sz, unsigned lv)
  53 {
  54         if(size>0)
  55         {
  56                 if(fmt!=format || sz!=size || (lv && lv!=levels))
  57                         throw incompatible_data("TextureCube::storage");
  58                 return;
  59         }
  60         if(sz==0)
  61                 throw invalid_argument("TextureCube::storage");
  62
  63         set_format(fmt);
  64         size = sz;
  65         levels = get_n_levels();
  66         if(lv>0)
  67                 levels = min(levels, lv);
  68
  69         GLenum gl_fmt = get_gl_pixelformat(storage_fmt);
  70         if(ARB_texture_storage)
  71         {
  72                 if(ARB_direct_state_access)
  73                         glTextureStorage2D(id, levels, gl_fmt, size, size);
  74                 else
  75                 {
  76                         bind_scratch();
  77                         glTexStorage2D(target, levels, gl_fmt, size, size);
  78                 }
  79         }
  80         else
  81         {
  82                 bind_scratch();
  83                 GLenum comp = get_gl_components(get_components(storage_fmt));
  84                 GLenum type = get_gl_type(get_component_type(storage_fmt));
  85                 for(unsigned i=0; i<levels; ++i)
  86                 {
  87                         unsigned lv_size = get_level_size(i);
  88                         for(unsigned j=0; j<6; ++j)
  89                                 glTexImage2D(get_gl_cube_face(static_cast<TextureCubeFace>(j)), i, gl_fmt, lv_size, lv_size, 0, comp, type, 0);
  90                 }
  91                 glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, levels-1);
  92         }
  93
  94         apply_swizzle();
  95 }
  96
  97 void TextureCube::image(TextureCubeFace face, unsigned level, const void *data)
  98 {
  99         unsigned lsz = get_level_size(level);
 100         return sub_image(face, level, 0, 0, lsz, lsz, data);
 101 }
 102
 103 void TextureCube::sub_image(TextureCubeFace face, unsigned level, int x, int y, unsigned wd, unsigned ht, const void *data)
 104 {
 105         if(size==0)
 106                 throw invalid_operation("TextureCube::sub_image");
 107         if(level>=levels)
 108                 throw out_of_range("TextureCube::sub_image");
 109
 110         GLenum gl_face = get_gl_cube_face(face);
 111         GLenum comp = get_gl_components(get_components(storage_fmt));
 112         GLenum type = get_gl_type(get_component_type(storage_fmt));
 113         if(ARB_direct_state_access)
 114                 glTextureSubImage3D(id, level, x, y, face, wd, ht, 1, comp, type, data);
 115         else
 116         {
 117                 bind_scratch();
 118                 glTexSubImage2D(gl_face, level, x, y, wd, ht, comp, type, data);
 119         }
 120 }
 121
 122 void TextureCube::image(TextureCubeFace face, const Graphics::Image &img)
 123 {
 124         unsigned w = img.get_width();
 125         unsigned h = img.get_height();
 126         if(w!=h)
 127                 throw incompatible_data("TextureCube::image");
 128
 129         storage(pixelformat_from_image(img, use_srgb_format), w);
 130         image(face, 0, img.get_pixels());
 131 }
 132
 133 void TextureCube::image(const Graphics::Image &img, unsigned lv)
 134 {
 135         unsigned w = img.get_width();
 136         unsigned h = img.get_height();
 137
 138         if(h!=w*6)
 139                 throw incompatible_data("TextureCube::image");
 140         h /= 6;
 141
 142         if(size==0)
 143                 storage(pixelformat_from_image(img, use_srgb_format), w, lv);
 144         else if(w!=size || h!=size)
 145                 throw incompatible_data("TextureCube::image");
 146
 147         const char *pixels = reinterpret_cast<const char *>(img.get_pixels());
 148         unsigned face_size = img.get_stride()*size;
 149         for(unsigned i=0; i<6; ++i)
 150                 image(static_cast<TextureCubeFace>(i), 0, pixels+i*face_size);
 151 }
 152
 153 unsigned TextureCube::get_n_levels() const
 154 {
 155         unsigned n = 0;
 156         for(unsigned s=size; s; s>>=1, ++n) ;
 157         return n;
 158 }
 159
 160 unsigned TextureCube::get_level_size(unsigned level) const
 161 {
 162         return size>>level;
 163 }
 164
 165 const Vector3 &TextureCube::get_face_direction(TextureCubeFace face)
 166 {
 167         return directions[face];
 168 }
 169
 170 const Vector3 &TextureCube::get_s_direction(TextureCubeFace face)
 171 {
 172         return directions[orientations[face*2]];
 173 }
 174
 175 const Vector3 &TextureCube::get_t_direction(TextureCubeFace face)
 176 {
 177         return directions[orientations[face*2+1]];
 178 }
 179
 180 Vector3 TextureCube::get_texel_direction(TextureCubeFace face, unsigned u, unsigned v)
 181 {
 182         float s = (u+0.5f)*2.0f/size-1.0f;
 183         float t = (v+0.5f)*2.0f/size-1.0f;
 184         const Vector3 &fv = get_face_direction(face);
 185         const Vector3 &sv = get_s_direction(face);
 186         const Vector3 &tv = get_t_direction(face);
 187         return fv+s*sv+t*tv;
 188 }
 189
 190 uint64_t TextureCube::get_data_size() const
 191 {
 192         return id ? size*size*6*get_pixel_size(storage_fmt) : 0;
 193 }
 194
 195
 196 TextureCube::Loader::Loader(TextureCube &t):
 197         DataFile::DerivedObjectLoader<TextureCube, Texture::Loader>(t)
 198 {
 199         init();
 200 }
 201
 202 TextureCube::Loader::Loader(TextureCube &t, Collection &c):
 203         DataFile::DerivedObjectLoader<TextureCube, Texture::Loader>(t, c)
 204 {
 205         init();
 206 }
 207
 208 void TextureCube::Loader::init()
 209 {
 210         add("external_image", &Loader::external_image);
 211         add("image_data", &Loader::image_data);
 212         add("raw_data", &Loader::raw_data);
 213         add("storage", &Loader::storage);
 214         add("storage", &Loader::storage_levels);
 215 }
 216
 217 void TextureCube::Loader::external_image(TextureCubeFace face, const string &fn)
 218 {
 219         Graphics::Image img;
 220         RefPtr<IO::Seekable> io = get_collection().open_raw(fn);
 221         img.load_io(*io);
 222
 223         obj.image(face, img);
 224 }
 225
 226 void TextureCube::Loader::image_data(TextureCubeFace face, const string &data)
 227 {
 228         Graphics::Image img;
 229         IO::Memory mem(data.data(), data.size());
 230         img.load_io(mem);
 231
 232         obj.image(face, img);
 233 }
 234
 235 void TextureCube::Loader::raw_data(TextureCubeFace face, const string &data)
 236 {
 237         obj.image(face, 0, data.data());
 238 }
 239
 240 void TextureCube::Loader::storage(PixelFormat fmt, unsigned s)
 241 {
 242         obj.storage(fmt, s);
 243 }
 244
 245 void TextureCube::Loader::storage_levels(PixelFormat fmt, unsigned s, unsigned l)
 246 {
 247         obj.storage(fmt, s, l);
 248 }
 249
 250
 251 unsigned get_gl_cube_face(TextureCubeFace face)
 252 {
 253         switch(face)
 254         {
 255         case POSITIVE_X: return GL_TEXTURE_CUBE_MAP_POSITIVE_X;
 256         case NEGATIVE_X: return GL_TEXTURE_CUBE_MAP_NEGATIVE_X;
 257         case POSITIVE_Y: return GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
 258         case NEGATIVE_Y: return GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;
 259         case POSITIVE_Z: return GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
 260         case NEGATIVE_Z: return GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
 261         default: throw invalid_argument("get_gl_cube_face");
 262         }
 263 }
 264
 265 void operator>>(const LexicalConverter &conv, TextureCubeFace &face)
 266 {
 267         const string &str = conv.get();
 268         if(str=="POSITIVE_X")
 269                 face = POSITIVE_X;
 270         else if(str=="NEGATIVE_X")
 271                 face = NEGATIVE_X;
 272         else if(str=="POSITIVE_Y")
 273                 face = POSITIVE_Y;
 274         else if(str=="NEGATIVE_Y")
 275                 face = NEGATIVE_Y;
 276         else if(str=="POSITIVE_Z")
 277                 face = POSITIVE_Z;
 278         else if(str=="NEGATIVE_Z")
 279                 face = NEGATIVE_Z;
 280         else
 281                 throw lexical_error(format("conversion of '%s' to TextureCubeFace", str));
 282 }
 283
 284 } // namespace GL
 285 } // namespace Msp