source/render/renderer.cpp

   1 #include "batch.h"
   2 #include "buffer.h"
   3 #include "camera.h"
   4 #include "error.h"
   5 #include "framebuffer.h"
   6 #include "lighting.h"
   7 #include "material.h"
   8 #include "program.h"
   9 #include "programdata.h"
  10 #include "renderable.h"
  11 #include "renderer.h"
  12 #include "resourcemanager.h"
  13 #include "sampler.h"
  14 #include "texture.h"
  15 #include "vertexarray.h"
  16 #include "vertexsetup.h"
  17
  18 using namespace std;
  19
  20 namespace Msp {
  21 namespace GL {
  22
  23 Renderer::Renderer()
  24 {
  25         state_stack.reserve(16);
  26         state_stack.push_back(State());
  27         shdata_stack.reserve(32);
  28         state = &state_stack.back();
  29         add_shader_data(standard_shdata);
  30 }
  31
  32 Renderer::~Renderer()
  33 {
  34         end();
  35 }
  36
  37 void Renderer::end()
  38 {
  39         if(state_stack.size()>1)
  40                 throw invalid_operation("Renderer::end");
  41
  42         *state = State();
  43         shdata_stack.clear();
  44         add_shader_data(standard_shdata);
  45
  46         commands.use_pipeline(0);
  47 }
  48
  49 void Renderer::push_state()
  50 {
  51         state_stack.push_back(state_stack.back());
  52         state = &state_stack.back();
  53 }
  54
  55 void Renderer::pop_state()
  56 {
  57         if(state_stack.size()==1)
  58                 throw stack_underflow("Renderer::pop_state");
  59
  60         state_stack.pop_back();
  61         state = &state_stack.back();
  62         changed |= MATRIX;
  63 }
  64
  65 void Renderer::set_camera(const Camera &c)
  66 {
  67         state->camera = &c;
  68         add_shader_data(c.get_shader_data());
  69         set_matrix(Matrix());
  70 }
  71
  72 void Renderer::set_matrix(const Matrix &matrix)
  73 {
  74         state->model_matrix = matrix;
  75         changed |= MATRIX;
  76 }
  77
  78 void Renderer::transform(const Matrix &matrix)
  79 {
  80         state->model_matrix *= matrix;
  81         changed |= MATRIX;
  82 }
  83
  84 void Renderer::set_framebuffer(const Framebuffer *f)
  85 {
  86         state->framebuffer = f;
  87 }
  88
  89 void Renderer::set_viewport(const Rect *v)
  90 {
  91         state->viewport = v;
  92 }
  93
  94 void Renderer::set_scissor(const Rect *s)
  95 {
  96         state->scissor = s;
  97 }
  98
  99 void Renderer::set_shader_program(const Program *p, const ProgramData *d)
 100 {
 101         state->shprog = p;
 102         if(p && d)
 103                 add_shader_data(*d);
 104 }
 105
 106 void Renderer::add_shader_data(const ProgramData &d)
 107 {
 108         if(state->shdata_count<shdata_stack.size())
 109         {
 110                 const BoundProgramData &top = shdata_stack.back();
 111                 if(top.shdata==&d && top.generation==d.get_generation())
 112                 {
 113                         ++state->shdata_count;
 114                         return;
 115                 }
 116         }
 117
 118         flush_shader_data();
 119         shdata_stack.push_back(&d);
 120         state->shdata_count = shdata_stack.size();
 121         changed |= SHADER_DATA;
 122 }
 123
 124 void Renderer::set_texture(Tag tag, const Texture *tex, const Sampler *samp)
 125 {
 126         if(tex)
 127                 if(ResourceManager *res_mgr = tex->get_manager())
 128                         res_mgr->resource_used(*tex);
 129
 130         if(texture_stack.size()>state->texture_count)
 131         {
 132                 BoundTexture &bt = texture_stack[state->texture_count];
 133                 if(bt.tag==tag && bt.texture==tex && bt.sampler==samp)
 134                 {
 135                         ++state->texture_count;
 136                         return;
 137                 }
 138                 else
 139                         flush_textures();
 140         }
 141
 142         for(auto i=texture_stack.end(); i!=texture_stack.begin(); )
 143                 if((--i)->tag==tag)
 144                 {
 145                         i->replaced = texture_stack.size();
 146                         break;
 147                 }
 148
 149         texture_stack.push_back(BoundTexture());
 150         BoundTexture &bound_tex = texture_stack.back();
 151         bound_tex.tag = tag;
 152         bound_tex.texture = tex;
 153         bound_tex.sampler = samp;
 154         state->texture_count = texture_stack.size();
 155 }
 156
 157 void Renderer::flush_shader_data()
 158 {
 159         if(shdata_stack.size()>state->shdata_count)
 160                 shdata_stack.erase(shdata_stack.begin()+state->shdata_count, shdata_stack.end());
 161 }
 162
 163 void Renderer::flush_textures()
 164 {
 165         for(unsigned i=0; i<state->texture_count; ++i)
 166                 if(texture_stack[i].replaced>=static_cast<int>(state->texture_count))
 167                         texture_stack[i].replaced = -1;
 168
 169         texture_stack.erase(texture_stack.begin()+state->texture_count, texture_stack.end());
 170 }
 171
 172 void Renderer::set_vertex_setup(const VertexSetup *vs)
 173 {
 174         state->vertex_setup = vs;
 175 }
 176
 177 void Renderer::set_front_face(FaceWinding winding)
 178 {
 179         state->front_face = winding;
 180 }
 181
 182 void Renderer::set_face_cull(CullMode cull)
 183 {
 184         state->face_cull = cull;
 185 }
 186
 187 void Renderer::set_depth_test(const DepthTest *dt)
 188 {
 189         state->depth_test = dt;
 190 }
 191
 192 void Renderer::set_stencil_test(const StencilTest *st)
 193 {
 194         state->stencil_test = st;
 195 }
 196
 197 void Renderer::set_blend(const Blend *b)
 198 {
 199         state->blend = b;
 200 }
 201
 202 void Renderer::set_object_lod_bias(unsigned b)
 203 {
 204         state->object_lod_bias = b;
 205 }
 206
 207 void Renderer::clear(const ClearValue *values)
 208 {
 209         pipeline_state.set_framebuffer(state->framebuffer);
 210         pipeline_state.set_viewport(state->viewport);
 211         pipeline_state.set_scissor(state->scissor);
 212         commands.use_pipeline(&pipeline_state);
 213         commands.clear(values);
 214 }
 215
 216 void Renderer::draw(const Batch &batch)
 217 {
 218         apply_state();
 219         batch.refresh();
 220         commands.use_pipeline(&pipeline_state);
 221         commands.draw(batch);
 222 }
 223
 224 void Renderer::draw_instanced(const Batch &batch, unsigned count)
 225 {
 226         apply_state();
 227         batch.refresh();
 228         commands.use_pipeline(&pipeline_state);
 229         commands.draw_instanced(batch, count);
 230 }
 231
 232 void Renderer::resolve_multisample(Framebuffer &target)
 233 {
 234         if(!state->framebuffer)
 235                 throw invalid_operation("Renderer::resolve_multisample");
 236
 237         unsigned width = state->framebuffer->get_width();
 238         unsigned height = state->framebuffer->get_height();
 239         if(target.get_width()!=width || target.get_height()!=height)
 240                 throw incompatible_data("Renderer::resolve_multisample");
 241
 242         pipeline_state.set_framebuffer(state->framebuffer);
 243         commands.use_pipeline(&pipeline_state);
 244         commands.resolve_multisample(target);
 245 }
 246
 247 void Renderer::begin_query(const QueryPool &pool, unsigned index)
 248 {
 249         commands.begin_query(pool, index);
 250 }
 251
 252 void Renderer::end_query(const QueryPool &pool, unsigned index)
 253 {
 254         commands.end_query(pool, index);
 255 }
 256
 257 void Renderer::apply_state()
 258 {
 259         if(!state->shprog)
 260                 throw invalid_operation("Renderer::apply_state");
 261
 262         pipeline_state.set_framebuffer(state->framebuffer);
 263         pipeline_state.set_viewport(state->viewport);
 264         pipeline_state.set_scissor(state->scissor);
 265
 266         bool shprog_changed = (state->shprog!=pipeline_state.get_shader_program());
 267         pipeline_state.set_shader_program(state->shprog);
 268
 269         if(changed&MATRIX)
 270         {
 271                 standard_shdata.uniform("world_obj_matrix", state->model_matrix);
 272                 LinAl::SquareMatrix<float, 3> nm = state->model_matrix.block<3, 3>(0, 0);
 273                 nm = transpose(invert(nm));
 274                 standard_shdata.uniform("world_obj_normal_matrix", nm);
 275                 changed &= ~MATRIX;
 276         }
 277
 278         bool shdata_changed = changed&SHADER_DATA;
 279         for(auto i=shdata_stack.begin(); (!shdata_changed && i!=shdata_stack.end()); ++i)
 280                 shdata_changed = (i->shdata->get_generation()!=i->generation);
 281         bool extra_shdata = (shdata_stack.size()>state->shdata_count);
 282
 283         if(shdata_changed || shprog_changed || extra_shdata)
 284         {
 285                 if(extra_shdata)
 286                         shdata_stack.erase(shdata_stack.begin()+state->shdata_count, shdata_stack.end());
 287                 for(const BoundProgramData &d: shdata_stack)
 288                 {
 289                         d.shdata->apply(*state->shprog, pipeline_state);
 290                         d.generation = d.shdata->get_generation();
 291                 }
 292                 changed &= ~SHADER_DATA;
 293         }
 294
 295         if(state->vertex_setup)
 296         {
 297                 if(const VertexArray *array = state->vertex_setup->get_vertex_array())
 298                         array->refresh();
 299                 if(const VertexArray *array = state->vertex_setup->get_instance_array())
 300                         array->refresh();
 301         }
 302         pipeline_state.set_vertex_setup(state->vertex_setup);
 303
 304         pipeline_state.set_front_face(state->front_face);
 305         pipeline_state.set_face_cull(state->face_cull);
 306
 307         if(state->texture_count<texture_stack.size())
 308                 flush_textures();
 309
 310         for(const BoundTexture &t: texture_stack)
 311                 if(t.texture && t.replaced<0)
 312                 {
 313                         if(t.binding<0 || shprog_changed)
 314                                 t.binding = state->shprog->get_uniform_binding(t.tag);
 315                         if(t.binding>=0)
 316                                 pipeline_state.set_texture(t.binding, t.texture, t.sampler);
 317                 }
 318
 319         pipeline_state.set_depth_test(state->depth_test);
 320         pipeline_state.set_stencil_test(state->stencil_test);
 321         pipeline_state.set_blend(state->blend);
 322 }
 323
 324
 325 Renderer::BoundProgramData::BoundProgramData(const ProgramData *d):
 326         shdata(d)
 327 { }
 328
 329 } // namespace GL
 330 } // namespace Msp