source/core/texturecube.h

   1 #ifndef MSP_GL_TEXTURECUBE_H_
   2 #define MSP_GL_TEXTURECUBE_H_
   3
   4 #include <msp/graphics/image.h>
   5 #include "texturecube_backend.h"
   6 #include "vector.h"
   7
   8 namespace Msp {
   9 namespace GL {
  10
  11 enum TextureCubeFace
  12 {
  13         POSITIVE_X = 0,
  14         NEGATIVE_X = 1,
  15         POSITIVE_Y = 2,
  16         NEGATIVE_Y = 3,
  17         POSITIVE_Z = 4,
  18         NEGATIVE_Z = 5
  19 };
  20
  21 /**
  22 Cube map texture, consisting of six square faces.
  23
  24 A cube map texture is addressed by three-dimensional texture coordinates.  The
  25 coordinate vector is projected on the unit cube, with the largest coordinate
  26 selecting the face and the remaining two used to sample from the face image.
  27 The images are oriented so that the cross product of the s and t axes will
  28 point into the cube.
  29 */
  30 class TextureCube: public TextureCubeBackend
  31 {
  32         friend TextureCubeBackend;
  33
  34 public:
  35         class Loader: public Msp::DataFile::DerivedObjectLoader<TextureCube, Texture::Loader>
  36         {
  37         public:
  38                 Loader(TextureCube &);
  39                 Loader(TextureCube &, Collection &);
  40         private:
  41                 void init();
  42
  43                 void external_image(TextureCubeFace, const std::string &);
  44                 void image_data(TextureCubeFace, const std::string &);
  45                 void raw_data(TextureCubeFace, const std::string &);
  46                 void storage(PixelFormat, unsigned);
  47                 void storage_levels(PixelFormat, unsigned, unsigned);
  48         };
  49
  50 private:
  51         unsigned size = 0;
  52         unsigned levels = 0;
  53
  54         static const Vector3 directions[6];
  55         static const unsigned orientations[12];
  56
  57 public:
  58         /** Sets storage format and dimensions and allocates memory for the texture.
  59         If lv is zero, a complete mipmap pyramid is automatically created.  Storage
  60         cannot be changed once set. */
  61         void storage(PixelFormat, unsigned size, unsigned lv = 0);
  62
  63         virtual void image(unsigned, const void *);
  64
  65         /** Replaces contents of a single face.  Allocated storage must exist.  The
  66         image data is interpreted according to the storage format and must have size
  67         matching the selected mipmap level. */
  68         void image(TextureCubeFace, unsigned level, const void *);
  69
  70         /** Replaces a rectangular region of a face.  Allocated storage must exist.
  71         The image data is interpreted according to the storage format and the region
  72         must be fully inside the face. */
  73         void sub_image(TextureCubeFace, unsigned level, unsigned x, unsigned y, unsigned w, unsigned h, const void *);
  74
  75         void image(TextureCubeFace, const Graphics::Image &);
  76
  77         /** Sets the texture's contents from an image.  The image is treated as a
  78         stack of square layers and its height must be six times its width.  If
  79         storage has not been allocated yet, it will be set to match the image.
  80         Otherwise the image must be compatible with the existing storage. */
  81         virtual void image(const Graphics::Image &, unsigned = 0);
  82
  83         unsigned get_size() const { return size; }
  84 private:
  85         unsigned get_n_levels() const;
  86         unsigned get_level_size(unsigned) const;
  87
  88 public:
  89         /** Returns a vector pointing out of the face. */
  90         static const Vector3 &get_face_direction(TextureCubeFace);
  91
  92         /** Returns a vector in the direction of the s axis of the face. */
  93         static const Vector3 &get_s_direction(TextureCubeFace);
  94
  95         /** Returns a vector in the direction of the t axis of the face. */
  96         static const Vector3 &get_t_direction(TextureCubeFace);
  97
  98         /** Returns a vector pointing to the center of a texel. */
  99         Vector3 get_texel_direction(TextureCubeFace, unsigned, unsigned);
 100
 101         virtual AsyncLoader *load(IO::Seekable &, const Resources * = 0) { return 0; }
 102         virtual std::size_t get_data_size() const;
 103         virtual void unload() { }
 104 };
 105
 106 void operator>>(const LexicalConverter &, TextureCubeFace &);
 107
 108 } // namespace GL
 109 } // namespace Msp
 110
 111 #endif