]> git.tdb.fi Git - libs/gl.git/blob - source/framebuffer.cpp
Implement automatic unloading when a total size limit is exceeded
[libs/gl.git] / source / framebuffer.cpp
1 #include <msp/gl/extensions/arb_draw_buffers.h>
2 #include <msp/gl/extensions/ext_framebuffer_blit.h>
3 #include <msp/gl/extensions/ext_framebuffer_object.h>
4 #include "error.h"
5 #include "framebuffer.h"
6 #include "misc.h"
7 #include "renderbuffer.h"
8 #include "texture2d.h"
9
10 using namespace std;
11
12 namespace Msp {
13 namespace GL {
14
15 void operator<<(LexicalConverter &conv, FramebufferStatus status)
16 {
17         switch(status)
18         {
19         case FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
20                 conv.result("incomplete attachment");
21                 break;
22         case FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
23                 conv.result("missing attachment");
24                 break;
25         case FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
26                 conv.result("mismatched attachment dimensions");
27                 break;
28         case FRAMEBUFFER_INCOMPLETE_FORMATS:
29                 conv.result("mismatched attachment formats");
30                 break;
31         case FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
32                 conv.result("missing draw buffer attachment");
33                 break;
34         case FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
35                 conv.result("missing read buffer attachment");
36                 break;
37         case FRAMEBUFFER_UNSUPPORTED:
38                 conv.result("unsupported");
39                 break;
40         default:
41                 conv.result(lexical_cast<string, unsigned>(status, "%#x"));
42                 break;
43         }
44 }
45
46 framebuffer_incomplete::framebuffer_incomplete(FramebufferStatus status):
47         runtime_error(lexical_cast<string>(status))
48 { }
49
50
51 Framebuffer::Framebuffer(unsigned i):
52         id(i),
53         dirty(0)
54 {
55         if(id)
56                 throw invalid_argument("System framebuffer must have id 0");
57
58         glGetIntegerv(GL_VIEWPORT, &view.left);
59         width = view.width;
60         height = view.height;
61 }
62
63 Framebuffer::Framebuffer():
64         width(0),
65         height(0),
66         dirty(0)
67 {
68         static Require _req(EXT_framebuffer_object);
69
70         glGenFramebuffers(1, &id);
71 }
72
73 Framebuffer::~Framebuffer()
74 {
75         if(id)
76                 glDeleteFramebuffers(1, &id);
77         if(current()==this)
78                 unbind();
79 }
80
81 void Framebuffer::update_attachment(unsigned mask) const
82 {
83         if(current()==this)
84         {
85                 std::vector<GLenum> color_bufs;
86                 color_bufs.reserve(attachments.size());
87                 for(unsigned i=0; i<attachments.size(); ++i)
88                 {
89                         const Attachment &attch = attachments[i];
90                         if(mask&(1<<i))
91                         {
92                                 if(attch.type==GL_RENDERBUFFER)
93                                         glFramebufferRenderbuffer(GL_FRAMEBUFFER, attch.attachment, GL_RENDERBUFFER, attch.rbuf->get_id());
94                                 else if(attch.type==GL_TEXTURE_2D)
95                                 {
96                                         static_cast<Texture2D *>(attch.tex)->allocate(attch.level);
97                                         glFramebufferTexture2D(GL_FRAMEBUFFER, attch.attachment, attch.type, attch.tex->get_id(), attch.level);
98                                 }
99                                 else if(attch.type==GL_TEXTURE_CUBE_MAP)
100                                 {
101                                         static_cast<TextureCube *>(attch.tex)->allocate(attch.level);
102                                         glFramebufferTexture2D(GL_FRAMEBUFFER, attch.attachment, attch.cube_face, attch.tex->get_id(), attch.level);
103                                 }
104                                 else
105                                         glFramebufferRenderbuffer(GL_FRAMEBUFFER, attch.attachment, 0, 0);
106                         }
107
108                         if(attch.attachment>=COLOR_ATTACHMENT0 && attch.attachment<=COLOR_ATTACHMENT3)
109                                 color_bufs.push_back(attch.attachment);
110                 }
111
112                 if(color_bufs.empty())
113                 {
114                         glDrawBuffer(GL_NONE);
115                         glReadBuffer(GL_NONE);
116                 }
117                 else if(color_bufs.size()==1)
118                 {
119                         glDrawBuffer(color_bufs.front());
120                         glReadBuffer(color_bufs.front());
121                 }
122                 else
123                 {
124                         static Require _req(ARB_draw_buffers);
125                         glDrawBuffers(color_bufs.size(), &color_bufs[0]);
126                         glReadBuffer(color_bufs.front());
127                 }
128         }
129         else
130                 dirty |= mask;
131 }
132
133 void Framebuffer::check_size()
134 {
135         bool full_viewport = (view.left==0 && view.bottom==0 && view.width==width && view.height==height);
136         for(vector<Attachment>::iterator i=attachments.begin(); i!=attachments.end(); ++i)
137                 if(i->type)
138                 {
139                         if(i->type==GL_RENDERBUFFER)
140                         {
141                                 width = i->rbuf->get_width();
142                                 height = i->rbuf->get_height();
143                         }
144                         else if(i->type==GL_TEXTURE_2D)
145                         {
146                                 Texture2D *tex = static_cast<Texture2D *>(i->tex);
147                                 width = tex->get_width();
148                                 height = tex->get_height();
149                         }
150                         else if(i->type==GL_TEXTURE_CUBE_MAP)
151                         {
152                                 width = static_cast<TextureCube *>(i->tex)->get_size();
153                                 height = width;
154                         }
155                         if(full_viewport)
156                                 reset_viewport();
157                         break;
158                 }
159 }
160
161 unsigned Framebuffer::get_attachment_index(FramebufferAttachment attch)
162 {
163         for(unsigned i=0; i<attachments.size(); ++i)
164                 if(attachments[i].attachment==attch)
165                         return i;
166         attachments.push_back(Attachment(attch));
167         return attachments.size()-1;
168 }
169
170 void Framebuffer::attach(FramebufferAttachment attch, Renderbuffer &rbuf)
171 {
172         if(!id)
173                 throw invalid_operation("Framebuffer::attach");
174
175         unsigned i = get_attachment_index(attch);
176         attachments[i].set(rbuf);
177         update_attachment(1<<i);
178         check_size();
179 }
180
181 void Framebuffer::attach(FramebufferAttachment attch, Texture2D &tex, unsigned level)
182 {
183         if(!id)
184                 throw invalid_operation("Framebuffer::attach");
185
186         unsigned i = get_attachment_index(attch);
187         attachments[i].set(tex, 0, level);
188         update_attachment(1<<i);
189         check_size();
190 }
191
192 void Framebuffer::attach(FramebufferAttachment attch, TextureCube &tex, TextureCubeFace face, unsigned level)
193 {
194         if(!id)
195                 throw invalid_operation("Framebuffer::attach");
196
197         unsigned i = get_attachment_index(attch);
198         attachments[i].set(tex, face, level);
199         update_attachment(1<<i);
200         check_size();
201 }
202
203 void Framebuffer::detach(FramebufferAttachment attch)
204 {
205         if(!id)
206                 throw invalid_operation("Framebuffer::detach");
207
208         unsigned i = get_attachment_index(attch);
209         attachments[i].clear();
210         update_attachment(1<<i);
211         check_size();
212 }
213
214 FramebufferStatus Framebuffer::check_status() const
215 {
216         BindRestore _bind(this);
217         return static_cast<FramebufferStatus>(glCheckFramebufferStatus(GL_FRAMEBUFFER));
218 }
219
220 void Framebuffer::require_complete() const
221 {
222         FramebufferStatus status = check_status();
223         if(status!=FRAMEBUFFER_COMPLETE)
224                 throw framebuffer_incomplete(status);
225 }
226
227 void Framebuffer::viewport(int l, int b, unsigned w, unsigned h)
228 {
229         view.left = l;
230         view.bottom = b;
231         view.width = w;
232         view.height = h;
233
234         if(current()==this)
235                 glViewport(view.left, view.bottom, view.width, view.height);
236 }
237
238 void Framebuffer::reset_viewport()
239 {
240         viewport(0, 0, width, height);
241 }
242
243 void Framebuffer::clear(BufferBits bits)
244 {
245         BindRestore _bind(this);
246         glClear(bits);
247 }
248
249 void Framebuffer::blit_from(const Framebuffer &other, int sx0, int sy0, int sx1, int sy1, int dx0, int dy0, int dx1, int dy1, BufferBits bits, bool filter)
250 {
251         static Require _req(EXT_framebuffer_blit);
252
253         const Framebuffer *old = current();
254         if(set_current(this))
255         {
256                 glBindFramebuffer(GL_DRAW_FRAMEBUFFER, id);
257                 if(dirty)
258                 {
259                         update_attachment(dirty);
260                         dirty = 0;
261                 }
262         }
263         if(old!=&other)
264                 glBindFramebuffer(GL_READ_FRAMEBUFFER, other.id);
265
266         glBlitFramebuffer(sx0, sy0, sx1, sy1, dx0, dy0, dx1, dy1, bits, (filter ? GL_LINEAR : GL_NEAREST));
267
268         set_current(old);
269         glBindFramebuffer(GL_FRAMEBUFFER, (old ? old->id : 0));
270 }
271
272 void Framebuffer::blit_from(const Framebuffer &other, int sx, int sy, unsigned wd, unsigned ht, int dx, int dy, BufferBits bits)
273 {
274         blit_from(other, sx, sy, sx+wd, sy+ht, dx, dy, dx+wd, dy+ht, bits, false);
275 }
276
277 void Framebuffer::blit_from(const Framebuffer &other, BufferBits bits, bool filter)
278 {
279         blit_from(other, 0, 0, other.width, other.height, 0, 0, width, height, bits, filter);
280 }
281
282 void Framebuffer::bind() const
283 {
284         if(set_current(this))
285         {
286                 glBindFramebuffer(GL_FRAMEBUFFER, id);
287                 if(dirty)
288                 {
289                         update_attachment(dirty);
290                         dirty = 0;
291                 }
292
293                 if(width && height)
294                         glViewport(view.left, view.bottom, view.width, view.height);
295         }
296 }
297
298 const Framebuffer *Framebuffer::current()
299 {
300         if(!cur_obj)
301                 cur_obj = &system();
302         return cur_obj;
303 }
304
305 void Framebuffer::unbind()
306 {
307         system().bind();
308 }
309
310 Framebuffer &Framebuffer::system()
311 {
312         static Framebuffer sys_framebuf(0);
313         return sys_framebuf;
314 }
315
316
317 Framebuffer::Attachment::Attachment(FramebufferAttachment a):
318         attachment(a),
319         type(0),
320         level(0)
321 { }
322
323 void Framebuffer::Attachment::set(Renderbuffer &r)
324 {
325         type = GL_RENDERBUFFER;
326         rbuf = &r;
327         level = 0;
328 }
329
330 void Framebuffer::Attachment::set(Texture &t, GLenum f, unsigned l)
331 {
332         type = t.get_target();
333         tex = &t;
334         cube_face = f;
335         level = l;
336 }
337
338 void Framebuffer::Attachment::clear()
339 {
340         type = 0;
341 }
342
343
344 Framebuffer::Viewport::Viewport():
345         left(0),
346         bottom(0),
347         width(0),
348         height(0)
349 { }
350
351 } // namespace GL
352 } // namespace Msp