source/texturecube.cpp

   1 #include <msp/gl/extensions/arb_texture_cube_map.h>
   2 #include <msp/io/memory.h>
   3 #include <msp/strings/format.h>
   4 #include "bindable.h"
   5 #include "error.h"
   6 #include "pixelstore.h"
   7 #include "texturecube.h"
   8
   9 using namespace std;
  10
  11 namespace Msp {
  12 namespace GL {
  13
  14 Vector3 TextureCube::directions[6] =
  15 {
  16         Vector3(1, 0, 0),
  17         Vector3(-1, 0, 0),
  18         Vector3(0, 1, 0),
  19         Vector3(0, -1, 0),
  20         Vector3(0, 0, 1),
  21         Vector3(0, 0, -1)
  22 };
  23
  24 TextureCube::TextureCube():
  25         Texture(GL_TEXTURE_CUBE_MAP),
  26         size(0),
  27         allocated(0)
  28 {
  29         static Require _req(ARB_texture_cube_map);
  30 }
  31
  32 void TextureCube::storage(PixelFormat fmt, unsigned sz)
  33 {
  34         if(size>0)
  35                 throw invalid_operation("TextureCube::storage");
  36         if(sz==0)
  37                 throw invalid_argument("TextureCube::storage");
  38         require_pixelformat(fmt);
  39
  40         ifmt = fmt;
  41         size = sz;
  42 }
  43
  44 void TextureCube::allocate(unsigned level)
  45 {
  46         if(allocated&(1<<level))
  47                 return;
  48
  49         for(unsigned i=0; i<6; ++i)
  50                 image(enumerate_faces(i), level, get_base_pixelformat(ifmt), UNSIGNED_BYTE, 0);
  51 }
  52
  53 void TextureCube::image(TextureCubeFace face, unsigned level, PixelFormat fmt, DataType type, const void *data)
  54 {
  55         if(size==0)
  56                 throw invalid_operation("TextureCube::image");
  57
  58         unsigned s = get_level_size(level);
  59         if(s==0)
  60                 throw out_of_range("TextureCube::image");
  61
  62         BindRestore _bind(this);
  63         glTexImage2D(face, level, ifmt, s, s, 0, fmt, type, data);
  64
  65         // XXX Allocation should be tracked per-face, but we'll run out of bits
  66         allocated |= 1<<level;
  67         if(gen_mipmap && level==0)
  68         {
  69                 for(; s; s>>=1, ++level) ;
  70                 allocated |= (1<<level)-1;
  71         }
  72 }
  73
  74 void TextureCube::image(TextureCubeFace face, const Graphics::Image &img, bool srgb)
  75 {
  76         unsigned w = img.get_width();
  77         unsigned h = img.get_height();
  78         PixelFormat fmt = pixelformat_from_graphics(img.get_format());
  79         if(size==0)
  80         {
  81                 if(w!=h)
  82                         throw incompatible_data("TextureCube::image");
  83
  84                 PixelFormat f = storage_pixelformat_from_graphics(img.get_format());
  85                 if(srgb)
  86                         f = get_srgb_pixelformat(f);
  87                 storage(f, w);
  88         }
  89         else if(w!=size || h!=size)
  90                 throw incompatible_data("TextureCube::image");
  91
  92         PixelStore pstore = PixelStore::from_image(img);
  93         BindRestore _bind_ps(pstore);
  94
  95         image(face, 0, fmt, UNSIGNED_BYTE, img.get_data());
  96 }
  97
  98 unsigned TextureCube::get_level_size(unsigned level)
  99 {
 100         return size>>level;
 101 }
 102
 103 TextureCubeFace TextureCube::enumerate_faces(unsigned i)
 104 {
 105         switch(i)
 106         {
 107         case 0: return POSITIVE_X;
 108         case 1: return NEGATIVE_X;
 109         case 2: return POSITIVE_Y;
 110         case 3: return NEGATIVE_Y;
 111         case 4: return POSITIVE_Z;
 112         case 5: return NEGATIVE_Z;
 113         default: throw out_of_range("TextureCube::enumerate_faces");
 114         }
 115 }
 116
 117 const Vector3 &TextureCube::get_face_direction(TextureCubeFace face)
 118 {
 119         switch(face)
 120         {
 121         case POSITIVE_X: return directions[0];
 122         case NEGATIVE_X: return directions[1];
 123         case POSITIVE_Y: return directions[2];
 124         case NEGATIVE_Y: return directions[3];
 125         case POSITIVE_Z: return directions[4];
 126         case NEGATIVE_Z: return directions[5];
 127         default: throw invalid_argument("TextureCube::get_face_direction");
 128         }
 129 }
 130
 131 const Vector3 &TextureCube::get_s_direction(TextureCubeFace face)
 132 {
 133         switch(face)
 134         {
 135         case POSITIVE_X: return directions[5];
 136         case NEGATIVE_X: return directions[4];
 137         case POSITIVE_Y: return directions[0];
 138         case NEGATIVE_Y: return directions[0];
 139         case POSITIVE_Z: return directions[0];
 140         case NEGATIVE_Z: return directions[1];
 141         default: throw invalid_argument("TextureCube::get_s_direction");
 142         }
 143 }
 144
 145 const Vector3 &TextureCube::get_t_direction(TextureCubeFace face)
 146 {
 147         switch(face)
 148         {
 149         case POSITIVE_X: return directions[3];
 150         case NEGATIVE_X: return directions[3];
 151         case POSITIVE_Y: return directions[4];
 152         case NEGATIVE_Y: return directions[5];
 153         case POSITIVE_Z: return directions[3];
 154         case NEGATIVE_Z: return directions[3];
 155         default: throw invalid_argument("TextureCube::get_t_direction");
 156         }
 157 }
 158
 159 Vector3 TextureCube::get_texel_direction(TextureCubeFace face, unsigned u, unsigned v)
 160 {
 161         float s = (u+0.5f)*2.0f/size-1.0f;
 162         float t = (v+0.5f)*2.0f/size-1.0f;
 163         const Vector3 &fv = get_face_direction(face);
 164         const Vector3 &sv = get_s_direction(face);
 165         const Vector3 &tv = get_t_direction(face);
 166         return fv+s*sv+t*tv;
 167 }
 168
 169
 170 TextureCube::Loader::Loader(TextureCube &t):
 171         DataFile::DerivedObjectLoader<TextureCube, Texture::Loader>(t)
 172 {
 173         init();
 174 }
 175
 176 TextureCube::Loader::Loader(TextureCube &t, Collection &c):
 177         DataFile::DerivedObjectLoader<TextureCube, Texture::Loader>(t, c)
 178 {
 179         init();
 180 }
 181
 182 void TextureCube::Loader::init()
 183 {
 184         add("image_data", &Loader::image_data);
 185         add("raw_data", &Loader::raw_data);
 186         add("storage", &Loader::storage);
 187 }
 188
 189 void TextureCube::Loader::image_data(TextureCubeFace face, const string &data)
 190 {
 191         Graphics::Image img;
 192         IO::Memory mem(data.data(), data.size());
 193         img.load_io(mem);
 194
 195         obj.image(face, img, srgb);
 196 }
 197
 198 void TextureCube::Loader::raw_data(TextureCubeFace face, const string &data)
 199 {
 200         obj.image(face, 0, get_base_pixelformat(obj.ifmt), UNSIGNED_BYTE, data.data());
 201 }
 202
 203 void TextureCube::Loader::storage(PixelFormat fmt, unsigned s)
 204 {
 205         if(srgb)
 206                 fmt = get_srgb_pixelformat(fmt);
 207         obj.storage(fmt, s);
 208 }
 209
 210
 211 void operator>>(const LexicalConverter &conv, TextureCubeFace &face)
 212 {
 213         const string &str = conv.get();
 214         if(str=="POSITIVE_X")
 215                 face = POSITIVE_X;
 216         else if(str=="NEGATIVE_X")
 217                 face = NEGATIVE_X;
 218         else if(str=="POSITIVE_Y")
 219                 face = POSITIVE_Y;
 220         else if(str=="NEGATIVE_Y")
 221                 face = NEGATIVE_Y;
 222         else if(str=="POSITIVE_Z")
 223                 face = POSITIVE_Z;
 224         else if(str=="NEGATIVE_Z")
 225                 face = NEGATIVE_Z;
 226         else
 227                 throw lexical_error(format("conversion of '%s' to TextureCubeFace", str));
 228 }
 229
 230 } // namespace GL
 231 } // namespace Msp