source/texturecube.h

   1 #ifndef MSP_GL_TEXTURECUBE_H_
   2 #define MSP_GL_TEXTURECUBE_H_
   3
   4 #include <msp/gl/extensions/arb_texture_cube_map.h>
   5 #include <msp/graphics/image.h>
   6 #include "texture.h"
   7 #include "vector.h"
   8
   9 namespace Msp {
  10 namespace GL {
  11
  12 enum TextureCubeFace
  13 {
  14         POSITIVE_X = GL_TEXTURE_CUBE_MAP_POSITIVE_X,
  15         NEGATIVE_X = GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
  16         POSITIVE_Y = GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
  17         NEGATIVE_Y = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
  18         POSITIVE_Z = GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
  19         NEGATIVE_Z = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
  20 };
  21
  22 /**
  23 Cube map texture, consisting of six square faces.  All of the faces must be of
  24 the same size.  A cube map texture is addressed by three-dimensional texture
  25 coordinates, with a principal range of [-1, 1].  The face is first selected
  26 according to the largest coordinate, and the remaining two coordinates are used
  27 to sample the face image.  The images are oriented so that the cross product of
  28 the s and t axes will point into the cube.
  29
  30 All faces of a cube map texture must be allocated for it to be usable.
  31
  32 Requires OpenGL version 1.3.
  33 */
  34 class TextureCube: public Texture
  35 {
  36 public:
  37         class Loader: public Msp::DataFile::DerivedObjectLoader<TextureCube, Texture::Loader>
  38         {
  39         public:
  40                 Loader(TextureCube &);
  41                 Loader(TextureCube &, Collection &);
  42         private:
  43                 void init();
  44
  45                 void external_image(TextureCubeFace, const std::string &);
  46                 void image_data(TextureCubeFace, const std::string &);
  47                 void raw_data(TextureCubeFace, const std::string &);
  48                 void storage(PixelFormat, unsigned);
  49         };
  50
  51 private:
  52         unsigned size;
  53         unsigned levels;
  54         unsigned allocated;
  55
  56         static TextureCubeFace face_order[6];
  57         static Vector3 directions[6];
  58         static unsigned orientations[12];
  59
  60 public:
  61         TextureCube();
  62
  63         /** Defines storage structure for the texture.  If lv is zero, the number
  64         of mipmap levels is automatically determined from storage dimensions.
  65
  66         Must be called before an image can be uploaded.  Once storage is defined,
  67         it can't be changed. */
  68         void storage(PixelFormat fmt, unsigned size, unsigned lv = 0);
  69
  70         /** Allocates storage for the cube faces.  The contents are initially
  71         undefined.  If storage has already been allocated, does nothing. */
  72         void allocate(unsigned level);
  73
  74         /** Uploads image data to a face.  Storage must be defined beforehand.  The
  75         image data must have dimensions and format compatible with the defined
  76         storage. */
  77         void image(TextureCubeFace face, unsigned level,
  78                 PixelFormat fmt, DataType type, const void *data);
  79
  80         /** Updates a rectangular region of a face.  Storage must be defined and
  81         allocated beforehand.  The update region must be fully inside the texture.
  82         The data format must be compatible with the defined storage. */
  83         void sub_image(TextureCubeFace face, unsigned level,
  84                 int x, int y, unsigned w, unsigned h,
  85                 PixelFormat fmt, DataType type, const void *data);
  86
  87         void image(TextureCubeFace, const Graphics::Image &, bool = false);
  88
  89         virtual void image(const Graphics::Image &, unsigned, bool = false);
  90         using Texture::image;
  91
  92         unsigned get_size() const { return size; }
  93 private:
  94         unsigned get_n_levels() const;
  95         unsigned get_level_size(unsigned) const;
  96
  97 public:
  98         /** Translates indices into face constants.  Valid indices are between 0
  99         and 5, inclusive. */
 100         static TextureCubeFace enumerate_faces(unsigned);
 101
 102         static unsigned get_face_index(TextureCubeFace);
 103
 104         /** Returns a vector pointing out of the face. */
 105         static const Vector3 &get_face_direction(TextureCubeFace);
 106
 107         /** Returns a vector in the direction of the s axis of the face. */
 108         static const Vector3 &get_s_direction(TextureCubeFace);
 109
 110         /** Returns a vector in the direction of the t axis of the face. */
 111         static const Vector3 &get_t_direction(TextureCubeFace);
 112
 113         /** Returns a vector pointing to the center a texel. */
 114         Vector3 get_texel_direction(TextureCubeFace, unsigned, unsigned);
 115
 116         virtual AsyncLoader *load(IO::Seekable &, const Resources * = 0) { return 0; }
 117         virtual UInt64 get_data_size() const;
 118         virtual void unload() { }
 119 };
 120
 121 void operator>>(const LexicalConverter &, TextureCubeFace &);
 122
 123 } // namespace GL
 124 } // namespace Msp
 125
 126 #endif