]> git.tdb.fi Git - libs/gl.git/blob - source/rendertarget.cpp
Hide windows.h from public headers
[libs/gl.git] / source / rendertarget.cpp
1 #include <msp/core/maputils.h>
2 #include "error.h"
3 #include "renderbuffer.h"
4 #include "rendertarget.h"
5
6 using namespace std;
7
8 namespace Msp {
9 namespace GL {
10
11 RenderTargetFormat::RenderTargetFormat():
12         count(0)
13 { }
14
15 RenderTargetFormat::RenderTargetFormat(RenderOutput o):
16         count(1)
17 {
18         outputs[0] = o;
19 }
20
21 RenderTargetFormat RenderTargetFormat::operator,(RenderOutput o) const
22 {
23         if(count>=MAX_OUTPUTS)
24                 throw invalid_operation("RenderTargetFormat::operator,");
25
26         RenderTargetFormat result = *this;
27         result.outputs[result.count++] = o;
28
29         return result;
30 }
31
32 RenderTargetFormat RenderTargetFormat::operator,(PixelFormat f) const
33 {
34         if(!count)
35                 throw invalid_operation("RenderTargetFormat::operator,");
36
37         PixelFormat unsized = get_unsized_pixelformat(f);
38         unsigned size = get_component_size(f);
39         unsigned char out = outputs[count-1];
40         if(get_output_type(out)>=get_output_type(RENDER_DEPTH))
41         {
42                 if(unsized!=DEPTH_COMPONENT)
43                         throw invalid_argument("RenderTargetformat::operator,");
44                 if(size>1)
45                         --size;
46         }
47         else
48         {
49                 if(unsized!=RED && unsized!=RG && unsized!=RGB && unsized!=RGBA)
50                         throw invalid_argument("RenderTargetformat::operator,");
51                 if(size>3)
52                         --size;
53         }
54
55         out = (out&~15) | (size<<2) | (get_component_count(f)-1);
56         RenderTargetFormat result = *this;
57         result.outputs[result.count-1] = out;
58
59         return result;
60 }
61
62 int RenderTargetFormat::index(RenderOutput o) const
63 {
64         unsigned type = get_output_type(o);
65         unsigned i = 0;
66         for(const unsigned char *j=begin(); j!=end(); ++j, ++i)
67                 if(get_output_type(*j)==type)
68                         return i;
69         return -1;
70 }
71
72
73 PixelFormat get_output_pixelformat(unsigned char o)
74 {
75         unsigned size = ((o>>2)&3);
76         PixelFormat base;
77         if(get_output_type(o)>=get_output_type(RENDER_DEPTH))
78         {
79                 base = DEPTH_COMPONENT;
80                 if(size)
81                         ++size;
82         }
83         else
84         {
85                 static PixelFormat base_formats[4] = { RED, RG, RGB, RGBA };
86                 base = base_formats[o&3];
87                 if(size==3)
88                         ++size;
89         }
90
91         if(size)
92                 return get_sized_pixelformat(base, size);
93         else
94                 return base;
95 }
96
97
98 RenderTarget::RenderTarget(unsigned w, unsigned h, const RenderTargetFormat &f)
99 {
100         init(w, h, 0, f);
101 }
102
103 RenderTarget::RenderTarget(unsigned w, unsigned h, unsigned s, const RenderTargetFormat &f)
104 {
105         init(w, h, s, f);
106 }
107
108 void RenderTarget::init(unsigned w, unsigned h, unsigned s, const RenderTargetFormat &f)
109 {
110         width = w;
111         height = h;
112         samples = s;
113         format = f;
114
115         for(const unsigned char *i=format.begin(); i!=format.end(); ++i)
116         {
117                 unsigned type = get_output_type(*i);
118                 FramebufferAttachment att;
119                 if(type>=get_output_type(RENDER_DEPTH))
120                         att = DEPTH_ATTACHMENT;
121                 else
122                         att = static_cast<FramebufferAttachment>(COLOR_ATTACHMENT0+type);
123
124                 PixelFormat pf = get_output_pixelformat(*i);
125
126                 TargetBuffer tgt;
127                 if(samples)
128                 {
129                         tgt.buffer = new Renderbuffer;
130                         tgt.buffer->storage_multisample(samples, pf, width, height);
131                         fbo.attach(att, *tgt.buffer);
132                 }
133                 else
134                 {
135                         tgt.texture = new Texture2D;
136                         tgt.texture->storage(pf, width, height, 1);
137                         tgt.texture->set_filter(NEAREST);
138                         tgt.texture->set_wrap(CLAMP_TO_EDGE);
139                         fbo.attach(att, *tgt.texture);
140                 }
141                 buffers.push_back(tgt);
142         }
143
144         fbo.require_complete();
145 }
146
147 RenderTarget::~RenderTarget()
148 {
149         for(vector<TargetBuffer>::iterator i=buffers.begin(); i!=buffers.end(); ++i)
150         {
151                 if(samples)
152                         delete i->buffer;
153                 else
154                         delete i->texture;
155         }
156 }
157
158 void RenderTarget::set_texture_filter(TextureFilter filt)
159 {
160         if(!samples)
161         {
162                 for(vector<TargetBuffer>::iterator i=buffers.begin(); i!=buffers.end(); ++i)
163                         i->texture->set_filter(filt);
164         }
165 }
166
167 const Texture2D &RenderTarget::get_target_texture(unsigned i) const
168 {
169         if(i>=buffers.size())
170                 throw out_of_range("RenderTarget::get_target_texture");
171         if(samples)
172                 throw invalid_operation("RenderTarget::get_target_texture");
173
174         return *buffers[i].texture;
175 }
176
177 const Texture2D &RenderTarget::get_target_texture(RenderOutput o) const
178 {
179         int index = format.index(o);
180         if(index<0)
181                 throw key_error(o);
182
183         return get_target_texture(index);
184 }
185
186 void RenderTarget::blit_from(const RenderTarget &other)
187 {
188         fbo.blit_from(other.fbo, COLOR_BUFFER_BIT|DEPTH_BUFFER_BIT, false);
189 }
190
191 } // namespace GL
192 } // namespace Msp