source/render/renderer.cpp

   1 #include <msp/gl/extensions/arb_direct_state_access.h>
   2 #include <msp/gl/extensions/ext_framebuffer_blit.h>
   3 #include <msp/gl/extensions/ext_framebuffer_object.h>
   4 #include "batch.h"
   5 #include "buffer.h"
   6 #include "camera.h"
   7 #include "clipping.h"
   8 #include "deviceinfo.h"
   9 #include "error.h"
  10 #include "lighting.h"
  11 #include "material.h"
  12 #include "program.h"
  13 #include "programdata.h"
  14 #include "renderable.h"
  15 #include "renderer.h"
  16 #include "resourcemanager.h"
  17 #include "sampler.h"
  18 #include "texture.h"
  19 #include "vertexarray.h"
  20 #include "vertexsetup.h"
  21
  22 using namespace std;
  23
  24 namespace Msp {
  25 namespace GL {
  26
  27 Renderer::Renderer()
  28 {
  29         state_stack.reserve(16);
  30         state_stack.push_back(State());
  31         shdata_stack.reserve(32);
  32         state = &state_stack.back();
  33         add_shader_data(standard_shdata);
  34 }
  35
  36 Renderer::~Renderer()
  37 {
  38         end();
  39 }
  40
  41 void Renderer::set_camera(const Camera &c)
  42 {
  43         state->camera = &c;
  44         add_shader_data(c.get_shader_data());
  45         set_matrix(Matrix());
  46 }
  47
  48 void Renderer::set_matrix(const Matrix &matrix)
  49 {
  50         state->model_matrix = matrix;
  51         changed |= MATRIX;
  52 }
  53
  54 void Renderer::transform(const Matrix &matrix)
  55 {
  56         state->model_matrix *= matrix;
  57         changed |= MATRIX;
  58 }
  59
  60 void Renderer::set_framebuffer(const Framebuffer *f)
  61 {
  62         state->framebuffer = f;
  63 }
  64
  65 void Renderer::set_viewport(const Rect *v)
  66 {
  67         state->viewport = v;
  68 }
  69
  70 void Renderer::set_scissor(const Rect *s)
  71 {
  72         state->scissor = s;
  73 }
  74
  75 void Renderer::set_texture(Tag tag, const Texture *tex, const Sampler *samp)
  76 {
  77         if(tex)
  78                 if(ResourceManager *res_mgr = tex->get_manager())
  79                         res_mgr->resource_used(*tex);
  80
  81         if(texture_stack.size()>state->texture_count)
  82         {
  83                 BoundTexture &bt = texture_stack[state->texture_count];
  84                 if(bt.tag==tag && bt.texture==tex && bt.sampler==samp)
  85                 {
  86                         ++state->texture_count;
  87                         return;
  88                 }
  89                 else
  90                         flush_textures();
  91         }
  92
  93         for(vector<BoundTexture>::iterator i=texture_stack.end(); i!=texture_stack.begin(); )
  94                 if((--i)->tag==tag)
  95                 {
  96                         i->replaced = texture_stack.size();
  97                         break;
  98                 }
  99
 100         texture_stack.push_back(BoundTexture());
 101         BoundTexture &bound_tex = texture_stack.back();
 102         bound_tex.tag = tag;
 103         bound_tex.texture = tex;
 104         bound_tex.sampler = samp;
 105         state->texture_count = texture_stack.size();
 106 }
 107
 108 void Renderer::flush_textures()
 109 {
 110         for(unsigned i=0; i<state->texture_count; ++i)
 111                 if(texture_stack[i].replaced>=static_cast<int>(state->texture_count))
 112                         texture_stack[i].replaced = -1;
 113
 114         texture_stack.erase(texture_stack.begin()+state->texture_count, texture_stack.end());
 115 }
 116
 117 void Renderer::set_material(const Material *m)
 118 {
 119         if(m)
 120                 add_shader_data(m->get_shader_data());
 121 }
 122
 123 void Renderer::set_lighting(const Lighting *l)
 124 {
 125         if(l)
 126                 add_shader_data(l->get_shader_data());
 127 }
 128
 129 void Renderer::set_clipping(const Clipping *c)
 130 {
 131         state->clipping = c;
 132         if(c)
 133                 add_shader_data(c->get_shader_data());
 134 }
 135
 136 void Renderer::set_shader_program(const Program *p, const ProgramData *d)
 137 {
 138         state->shprog = p;
 139         if(p && d)
 140                 add_shader_data(*d);
 141 }
 142
 143 void Renderer::add_shader_data(const ProgramData &d)
 144 {
 145         if(state->shdata_count<shdata_stack.size())
 146         {
 147                 const BoundProgramData &top = shdata_stack.back();
 148                 if(top.shdata==&d && top.generation==d.get_generation())
 149                 {
 150                         ++state->shdata_count;
 151                         return;
 152                 }
 153         }
 154
 155         flush_shader_data_();
 156         shdata_stack.push_back(&d);
 157         state->shdata_count = shdata_stack.size();
 158         changed |= SHADER_DATA;
 159 }
 160
 161 void Renderer::flush_shader_data_()
 162 {
 163         if(shdata_stack.size()>state->shdata_count)
 164                 shdata_stack.erase(shdata_stack.begin()+state->shdata_count, shdata_stack.end());
 165 }
 166
 167 void Renderer::set_vertex_setup(const VertexSetup *vs)
 168 {
 169         state->vertex_setup = vs;
 170 }
 171
 172 void Renderer::set_front_face(FaceWinding winding)
 173 {
 174         state->front_face = winding;
 175 }
 176
 177 void Renderer::set_face_cull(CullMode cull)
 178 {
 179         state->face_cull = cull;
 180 }
 181
 182 void Renderer::set_depth_test(const DepthTest *dt)
 183 {
 184         state->depth_test = dt;
 185 }
 186
 187 void Renderer::set_stencil_test(const StencilTest *st)
 188 {
 189         state->stencil_test = st;
 190 }
 191
 192 void Renderer::set_blend(const Blend *b)
 193 {
 194         state->blend = b;
 195 }
 196
 197 void Renderer::set_object_lod_bias(unsigned b)
 198 {
 199         state->object_lod_bias = b;
 200 }
 201
 202 void Renderer::push_state()
 203 {
 204         state_stack.push_back(state_stack.back());
 205         state = &state_stack.back();
 206 }
 207
 208 void Renderer::pop_state()
 209 {
 210         if(state_stack.size()==1)
 211                 throw stack_underflow("Renderer::pop_state");
 212
 213         state_stack.pop_back();
 214         state = &state_stack.back();
 215         changed |= MATRIX;
 216 }
 217
 218 void Renderer::end()
 219 {
 220         if(state_stack.size()>1)
 221                 throw invalid_operation("Renderer::end");
 222
 223         *state = State();
 224         shdata_stack.clear();
 225         add_shader_data(standard_shdata);
 226         excluded.clear();
 227
 228         PipelineState::clear();
 229 }
 230
 231 void Renderer::exclude(const Renderable &renderable)
 232 {
 233         excluded.insert(&renderable);
 234 }
 235
 236 void Renderer::include(const Renderable &renderable)
 237 {
 238         excluded.erase(&renderable);
 239 }
 240
 241 void Renderer::render(const Renderable &renderable, Tag tag)
 242 {
 243         if(!excluded.count(&renderable))
 244                 renderable.render(*this, tag);
 245 }
 246
 247 void Renderer::clear()
 248 {
 249         clear(COLOR_BUFFER_BIT|DEPTH_BUFFER_BIT|STENCIL_BUFFER_BIT);
 250 }
 251
 252 void Renderer::clear(BufferBits buffers)
 253 {
 254         pipeline_state.set_framebuffer(state->framebuffer);
 255         pipeline_state.apply();
 256         glClear(buffers);
 257 }
 258
 259 void Renderer::draw(const Batch &batch)
 260 {
 261         apply_state();
 262
 263         batch.draw();
 264 }
 265
 266 void Renderer::draw_instanced(const Batch &batch, unsigned count)
 267 {
 268         apply_state();
 269
 270         batch.draw_instanced(count);
 271 }
 272
 273 void Renderer::resolve_multisample(Framebuffer &target, BufferBits buffers)
 274 {
 275         if(!state->framebuffer)
 276                 throw invalid_operation("Renderer::resolve_multisample");
 277
 278         unsigned width = state->framebuffer->get_width();
 279         unsigned height = state->framebuffer->get_height();
 280         if(target.get_width()!=width || target.get_height()!=height)
 281                 throw incompatible_data("Renderer::resolve_multisample");
 282
 283         if(ARB_direct_state_access)
 284                 glBlitNamedFramebuffer(state->framebuffer->get_id(), target.get_id(), 0, 0, width, height, 0, 0, width, height, buffers, GL_NEAREST);
 285         else
 286         {
 287                 glBindFramebuffer(GL_READ_FRAMEBUFFER, state->framebuffer->get_id());
 288                 glBindFramebuffer(GL_DRAW_FRAMEBUFFER, target.get_id());
 289
 290                 target.refresh();
 291
 292                 glBlitFramebuffer(0, 0, width, height, 0, 0, width, height, buffers, GL_NEAREST);
 293
 294                 glBindFramebuffer(GL_FRAMEBUFFER, 0);
 295                 pipeline_state.set_framebuffer(0);
 296         }
 297 }
 298
 299 void Renderer::apply_state()
 300 {
 301         if(!state->shprog)
 302                 throw invalid_operation("Renderer::apply_state");
 303
 304         if(changed&MATRIX)
 305         {
 306                 standard_shdata.uniform("world_obj_matrix", state->model_matrix);
 307                 LinAl::SquareMatrix<float, 3> nm = state->model_matrix.block<3, 3>(0, 0);
 308                 nm = transpose(invert(nm));
 309                 standard_shdata.uniform("world_obj_normal_matrix", nm);
 310                 changed &= ~MATRIX;
 311         }
 312
 313         pipeline_state.set_framebuffer(state->framebuffer);
 314         pipeline_state.set_viewport(state->viewport);
 315         pipeline_state.set_scissor(state->scissor);
 316
 317         bool shprog_changed = (state->shprog!=pipeline_state.get_shader_program());
 318         pipeline_state.set_shader_program(state->shprog);
 319
 320         if(state->vertex_setup)
 321         {
 322                 if(const VertexArray *array = state->vertex_setup->get_vertex_array())
 323                         array->refresh();
 324                 if(const VertexArray *array = state->vertex_setup->get_instance_array())
 325                         array->refresh();
 326         }
 327         pipeline_state.set_vertex_setup(state->vertex_setup);
 328
 329         pipeline_state.set_front_face(state->front_face);
 330         pipeline_state.set_face_cull(state->face_cull);
 331         pipeline_state.set_enabled_clip_planes(state->clipping ? (1<<state->clipping->get_n_planes())-1 : 0);
 332
 333         if(state->texture_count<texture_stack.size())
 334                 flush_textures();
 335
 336         for(vector<BoundTexture>::const_iterator i=texture_stack.begin(); i!=texture_stack.end(); ++i)
 337         {
 338                 int unit = (i->tag.id ? state->shprog->get_uniform_binding(i->tag) : i->unit);
 339                 if(unit>=0)
 340                         pipeline_state.set_texture(unit, i->texture, i->sampler);
 341         }
 342
 343         bool shdata_changed = changed&SHADER_DATA;
 344         for(vector<BoundProgramData>::const_iterator i=shdata_stack.begin(); (!shdata_changed && i!=shdata_stack.end()); ++i)
 345                 shdata_changed = (i->shdata->get_generation()!=i->generation);
 346         bool extra_shdata = (shdata_stack.size()>state->shdata_count);
 347
 348         if(shdata_changed || shprog_changed || extra_shdata)
 349         {
 350                 if(extra_shdata)
 351                         shdata_stack.erase(shdata_stack.begin()+state->shdata_count, shdata_stack.end());
 352                 for(vector<BoundProgramData>::const_iterator i=shdata_stack.begin(); i!=shdata_stack.end(); ++i)
 353                 {
 354                         i->shdata->apply(*state->shprog, pipeline_state);
 355                         i->generation = i->shdata->get_generation();
 356                 }
 357                 changed &= ~SHADER_DATA;
 358         }
 359
 360         pipeline_state.set_depth_test(state->depth_test);
 361         pipeline_state.set_stencil_test(state->stencil_test);
 362         pipeline_state.set_blend(state->blend);
 363
 364         pipeline_state.apply();
 365 }
 366
 367
 368 Renderer::BoundTexture::BoundTexture():
 369         unit(-1),
 370         texture(0),
 371         sampler(0),
 372         replaced(-1)
 373 { }
 374
 375
 376 Renderer::BoundProgramData::BoundProgramData(const ProgramData *d):
 377         shdata(d),
 378         generation(0)
 379 { }
 380
 381
 382 Renderer::State::State():
 383         camera(0),
 384         framebuffer(0),
 385         viewport(0),
 386         scissor(0),
 387         texture_count(0),
 388         clipping(0),
 389         shprog(0),
 390         shdata_count(0),
 391         vertex_setup(0),
 392         front_face(NON_MANIFOLD),
 393         face_cull(NO_CULL),
 394         depth_test(0),
 395         stencil_test(0),
 396         blend(0),
 397         object_lod_bias(0)
 398 { }
 399
 400 } // namespace GL
 401 } // namespace Msp