]> git.tdb.fi Git - libs/gl.git/blob - source/core/texturecube.cpp
Change default binding ranges to match lowest OpenGL standard
[libs/gl.git] / source / core / texturecube.cpp
1 #include <msp/datafile/collection.h>
2 #include <msp/io/memory.h>
3 #include <msp/strings/format.h>
4 #include "error.h"
5 #include "texturecube.h"
6
7 using namespace std;
8
9 namespace Msp {
10 namespace GL {
11
12 const Vector3 TextureCube::directions[6] =
13 {
14         Vector3(1, 0, 0),
15         Vector3(-1, 0, 0),
16         Vector3(0, 1, 0),
17         Vector3(0, -1, 0),
18         Vector3(0, 0, 1),
19         Vector3(0, 0, -1)
20 };
21
22 const unsigned TextureCube::orientations[12] =
23 {
24         5, 3,
25         4, 3,
26         0, 4,
27         0, 5,
28         0, 3,
29         1, 3
30 };
31
32 void TextureCube::storage(PixelFormat fmt, unsigned sz, unsigned lv)
33 {
34         if(size>0)
35         {
36                 if(fmt!=format || sz!=size || (lv && lv!=levels))
37                         throw incompatible_data("TextureCube::storage");
38                 return;
39         }
40         if(sz==0)
41                 throw invalid_argument("TextureCube::storage");
42
43         set_format(fmt);
44         size = sz;
45         levels = get_n_levels();
46         if(lv>0)
47                 levels = min(levels, lv);
48
49         allocate();
50 }
51
52 void TextureCube::image(TextureCubeFace face, unsigned level, const void *data)
53 {
54         unsigned lsz = get_level_size(level);
55         return sub_image(face, level, 0, 0, lsz, lsz, data);
56 }
57
58 void TextureCube::sub_image(TextureCubeFace face, unsigned level, int x, int y, unsigned wd, unsigned ht, const void *data)
59 {
60         if(size==0)
61                 throw invalid_operation("TextureCube::sub_image");
62         if(level>=levels)
63                 throw out_of_range("TextureCube::sub_image");
64
65         TextureCubeBackend::sub_image(face, level, x, y, wd, ht, data);
66 }
67
68 void TextureCube::image(TextureCubeFace face, const Graphics::Image &img)
69 {
70         unsigned w = img.get_width();
71         unsigned h = img.get_height();
72         if(w!=h)
73                 throw incompatible_data("TextureCube::image");
74
75         storage(pixelformat_from_image(img, use_srgb_format), w);
76         image(face, 0, img.get_pixels());
77 }
78
79 void TextureCube::image(const Graphics::Image &img, unsigned lv)
80 {
81         unsigned w = img.get_width();
82         unsigned h = img.get_height();
83
84         if(h!=w*6)
85                 throw incompatible_data("TextureCube::image");
86         h /= 6;
87
88         if(size==0)
89                 storage(pixelformat_from_image(img, use_srgb_format), w, lv);
90         else if(w!=size || h!=size)
91                 throw incompatible_data("TextureCube::image");
92
93         const char *pixels = reinterpret_cast<const char *>(img.get_pixels());
94         unsigned face_size = img.get_stride()*size;
95         for(unsigned i=0; i<6; ++i)
96                 image(static_cast<TextureCubeFace>(i), 0, pixels+i*face_size);
97 }
98
99 unsigned TextureCube::get_n_levels() const
100 {
101         unsigned n = 0;
102         for(unsigned s=size; s; s>>=1, ++n) ;
103         return n;
104 }
105
106 unsigned TextureCube::get_level_size(unsigned level) const
107 {
108         return size>>level;
109 }
110
111 const Vector3 &TextureCube::get_face_direction(TextureCubeFace face)
112 {
113         return directions[face];
114 }
115
116 const Vector3 &TextureCube::get_s_direction(TextureCubeFace face)
117 {
118         return directions[orientations[face*2]];
119 }
120
121 const Vector3 &TextureCube::get_t_direction(TextureCubeFace face)
122 {
123         return directions[orientations[face*2+1]];
124 }
125
126 Vector3 TextureCube::get_texel_direction(TextureCubeFace face, unsigned u, unsigned v)
127 {
128         float s = (u+0.5f)*2.0f/size-1.0f;
129         float t = (v+0.5f)*2.0f/size-1.0f;
130         const Vector3 &fv = get_face_direction(face);
131         const Vector3 &sv = get_s_direction(face);
132         const Vector3 &tv = get_t_direction(face);
133         return fv+s*sv+t*tv;
134 }
135
136 uint64_t TextureCube::get_data_size() const
137 {
138         return id ? size*size*6*get_pixel_size(storage_fmt) : 0;
139 }
140
141
142 TextureCube::Loader::Loader(TextureCube &t):
143         DataFile::DerivedObjectLoader<TextureCube, Texture::Loader>(t)
144 {
145         init();
146 }
147
148 TextureCube::Loader::Loader(TextureCube &t, Collection &c):
149         DataFile::DerivedObjectLoader<TextureCube, Texture::Loader>(t, c)
150 {
151         init();
152 }
153
154 void TextureCube::Loader::init()
155 {
156         add("external_image", &Loader::external_image);
157         add("image_data", &Loader::image_data);
158         add("raw_data", &Loader::raw_data);
159         add("storage", &Loader::storage);
160         add("storage", &Loader::storage_levels);
161 }
162
163 void TextureCube::Loader::external_image(TextureCubeFace face, const string &fn)
164 {
165         Graphics::Image img;
166         RefPtr<IO::Seekable> io = get_collection().open_raw(fn);
167         img.load_io(*io);
168
169         obj.image(face, img);
170 }
171
172 void TextureCube::Loader::image_data(TextureCubeFace face, const string &data)
173 {
174         Graphics::Image img;
175         IO::Memory mem(data.data(), data.size());
176         img.load_io(mem);
177
178         obj.image(face, img);
179 }
180
181 void TextureCube::Loader::raw_data(TextureCubeFace face, const string &data)
182 {
183         obj.image(face, 0, data.data());
184 }
185
186 void TextureCube::Loader::storage(PixelFormat fmt, unsigned s)
187 {
188         obj.storage(fmt, s);
189 }
190
191 void TextureCube::Loader::storage_levels(PixelFormat fmt, unsigned s, unsigned l)
192 {
193         obj.storage(fmt, s, l);
194 }
195
196
197 void operator>>(const LexicalConverter &conv, TextureCubeFace &face)
198 {
199         const string &str = conv.get();
200         if(str=="POSITIVE_X")
201                 face = POSITIVE_X;
202         else if(str=="NEGATIVE_X")
203                 face = NEGATIVE_X;
204         else if(str=="POSITIVE_Y")
205                 face = POSITIVE_Y;
206         else if(str=="NEGATIVE_Y")
207                 face = NEGATIVE_Y;
208         else if(str=="POSITIVE_Z")
209                 face = POSITIVE_Z;
210         else if(str=="NEGATIVE_Z")
211                 face = NEGATIVE_Z;
212         else
213                 throw lexical_error(format("conversion of '%s' to TextureCubeFace", str));
214 }
215
216 } // namespace GL
217 } // namespace Msp