source/renderer.cpp

   1 #include "batch.h"
   2 #include "buffer.h"
   3 #include "camera.h"
   4 #include "clipping.h"
   5 #include "error.h"
   6 #include "lighting.h"
   7 #include "material.h"
   8 #include "mesh.h"
   9 #include "program.h"
  10 #include "programdata.h"
  11 #include "renderable.h"
  12 #include "renderer.h"
  13 #include "texture.h"
  14 #include "texturing.h"
  15 #include "texunit.h"
  16 #include "vertexarray.h"
  17 #include "windingtest.h"
  18
  19 using namespace std;
  20
  21 namespace Msp {
  22 namespace GL {
  23
  24 Renderer::Renderer(const Camera *c):
  25         changed(0),
  26         matrices_loaded(false),
  27         state_stack(1)
  28 {
  29         state_stack.reserve(16);
  30         shdata_stack.reserve(32);
  31         state = &state_stack.back();
  32
  33         if(c)
  34                 set_camera(*c);
  35         else
  36                 standard_shdata.uniform("projection_matrix", Matrix());
  37 }
  38
  39 Renderer::~Renderer()
  40 {
  41         end();
  42 }
  43
  44 void Renderer::begin(const Camera *c)
  45 {
  46         end();
  47         if(c)
  48                 set_camera(*c);
  49 }
  50
  51 void Renderer::set_camera(const Camera &c)
  52 {
  53         state->camera = &c;
  54         standard_shdata.uniform("projection_matrix", state->camera->get_projection_matrix());
  55         changed |= STANDARD_SHDATA|LEGACY_PROJECTION;
  56         set_matrix(state->camera->get_view_matrix());
  57 }
  58
  59 void Renderer::set_matrix(const Matrix &matrix)
  60 {
  61         state->modelview_matrix = matrix;
  62         changed |= MATRIX;
  63 }
  64
  65 void Renderer::transform(const Matrix &matrix)
  66 {
  67         state->modelview_matrix *= matrix;
  68         changed |= MATRIX;
  69 }
  70
  71 void Renderer::set_texture(const Texture *t)
  72 {
  73         state->texture = t;
  74         state->texturing = 0;
  75 }
  76
  77 void Renderer::set_texturing(const Texturing *t)
  78 {
  79         state->texturing = t;
  80         state->texture = 0;
  81 }
  82
  83 unsigned Renderer::allocate_effect_texunit()
  84 {
  85         return --state->lowest_effect_texunit;
  86 }
  87
  88 void Renderer::set_material(const Material *m)
  89 {
  90         state->material = m;
  91         changed |= MATERIAL_SHDATA;
  92 }
  93
  94 void Renderer::set_lighting(const Lighting *l)
  95 {
  96         state->lighting = l;
  97         state->lighting_matrix = state->modelview_matrix;
  98         if(l)
  99         {
 100                 l->update_shader_data(standard_shdata, state->lighting_matrix);
 101                 changed |= STANDARD_SHDATA;
 102         }
 103         changed |= LEGACY_LIGHTING;
 104 }
 105
 106 void Renderer::set_clipping(const Clipping *c)
 107 {
 108         state->clipping = c;
 109         state->clipping_matrix = state->modelview_matrix;
 110         if(c)
 111         {
 112                 c->update_shader_data(standard_shdata, state->clipping_matrix);
 113                 changed |= STANDARD_SHDATA;
 114         }
 115         changed |= LEGACY_CLIPPING;
 116 }
 117
 118 void Renderer::set_shader_program(const Program *p, const ProgramData *d)
 119 {
 120         state->shprog = p;
 121         if(p && d)
 122                 add_shader_data(*d);
 123 }
 124
 125 void Renderer::add_shader_data(const ProgramData &d)
 126 {
 127         if(state->shdata_count<shdata_stack.size() && shdata_stack[state->shdata_count]==&d)
 128                 ++state->shdata_count;
 129         else
 130         {
 131                 if(shdata_stack.size()>state->shdata_count)
 132                         shdata_stack.erase(shdata_stack.begin()+state->shdata_count, shdata_stack.end());
 133                 shdata_stack.push_back(&d);
 134                 state->shdata_count = shdata_stack.size();
 135                 changed |= SHADER_DATA;
 136         }
 137 }
 138
 139 void Renderer::set_mesh(const Mesh *m)
 140 {
 141         state->mesh = m;
 142 }
 143
 144 void Renderer::set_winding_test(const WindingTest *w)
 145 {
 146         state->winding_test = w;
 147 }
 148
 149 void Renderer::set_reverse_winding(bool r)
 150 {
 151         state->reverse_winding = r;
 152 }
 153
 154 void Renderer::push_state()
 155 {
 156         state_stack.push_back(state_stack.back());
 157         state = &state_stack.back();
 158 }
 159
 160 void Renderer::pop_state()
 161 {
 162         if(state_stack.size()==1)
 163                 throw stack_underflow("Renderer::pop_state");
 164
 165         const Camera *old_camera = state->camera;
 166         const Lighting *old_lighting = state->lighting;
 167         const Clipping *old_clipping = state->clipping;
 168         state_stack.pop_back();
 169         state = &state_stack.back();
 170         changed |= MATRIX;
 171         bool camera_changed = (state->camera!=old_camera);
 172         if(camera_changed)
 173         {
 174                 if(state->camera)
 175                         standard_shdata.uniform("projection_matrix", state->camera->get_projection_matrix());
 176                 else
 177                         standard_shdata.uniform("projection_matrix", Matrix());
 178                 changed |= STANDARD_SHDATA|LEGACY_PROJECTION;
 179         }
 180         /* This actually should compare the relevant matrices rather than check for
 181         camera, but in practice lighting and clipping is set right after the camera
 182         and a boolean check is much faster than matrix comparison. */
 183         if(state->lighting!=old_lighting || camera_changed)
 184         {
 185                 if(state->lighting)
 186                 {
 187                         state->lighting->update_shader_data(standard_shdata, state->lighting_matrix);
 188                         changed |= STANDARD_SHDATA;
 189                 }
 190                 changed |= LEGACY_LIGHTING;
 191         }
 192         if(state->clipping!=old_clipping || camera_changed)
 193         {
 194                 if(state->clipping)
 195                 {
 196                         state->clipping->update_shader_data(standard_shdata, state->clipping_matrix);
 197                         changed |= STANDARD_SHDATA;
 198                 }
 199                 changed |= LEGACY_CLIPPING;
 200         }
 201 }
 202
 203 void Renderer::end()
 204 {
 205         if(state_stack.size()>1)
 206                 throw invalid_operation("Renderer::end");
 207
 208         *state = State();
 209         shdata_stack.clear();
 210         excluded.clear();
 211
 212         Mesh::unbind();
 213         Texturing::unbind();
 214         Texture::unbind_from(0);
 215         Material::unbind();
 216         Lighting::unbind();
 217         Clipping::unbind();
 218         Program::unbind();
 219         Buffer::unbind_from(ELEMENT_ARRAY_BUFFER);
 220         WindingTest::unbind();
 221
 222         if(matrices_loaded)
 223         {
 224                 MatrixStack::projection().pop();
 225                 MatrixStack::modelview().pop();
 226                 matrices_loaded = false;
 227         }
 228 }
 229
 230 void Renderer::exclude(const Renderable &renderable)
 231 {
 232         excluded.insert(&renderable);
 233 }
 234
 235 void Renderer::include(const Renderable &renderable)
 236 {
 237         excluded.erase(&renderable);
 238 }
 239
 240 void Renderer::render(const Renderable &renderable, const Tag &tag)
 241 {
 242         if(!excluded.count(&renderable))
 243                 renderable.render(*this, tag);
 244 }
 245
 246 void Renderer::draw(const Batch &batch)
 247 {
 248         apply_state();
 249
 250         bool legacy_bindings = (!state->shprog || state->shprog->uses_legacy_variables());
 251         if(state->mesh && legacy_bindings)
 252         {
 253                 if(const Buffer *ibuf = state->mesh->get_index_buffer())
 254                         ibuf->bind_to(ELEMENT_ARRAY_BUFFER);
 255                 else
 256                         Buffer::unbind_from(ELEMENT_ARRAY_BUFFER);
 257         }
 258
 259         batch.draw();
 260 }
 261
 262 void Renderer::apply_state()
 263 {
 264         /* We (mostly) let the objects themselves figure out if the binding has
 265         changed */
 266
 267         bool legacy_bindings = (!state->shprog || state->shprog->uses_legacy_variables());
 268         bool legacy_textures = !state->shprog;
 269
 270         if(state->texturing)
 271                 state->texturing->bind(legacy_textures);
 272         else
 273         {
 274                 Texturing::unbind();
 275                 if(state->texture)
 276                         state->texture->bind_to(0, legacy_textures);
 277                 else
 278                         Texture::unbind_from(0);
 279         }
 280
 281         if(legacy_bindings)
 282         {
 283                 if(state->material)
 284                         state->material->bind();
 285                 else
 286                         Material::unbind();
 287
 288                 if(changed&LEGACY_LIGHTING)
 289                 {
 290                         if(state->lighting)
 291                         {
 292                                 MatrixStack::modelview() = state->lighting_matrix;
 293                                 state->lighting->bind();
 294                                 changed = (changed&~LEGACY_LIGHTING)|LEGACY_MATRIX;
 295                         }
 296                         else
 297                                 Lighting::unbind();
 298                 }
 299         }
 300
 301         if(state->clipping)
 302         {
 303                 if(legacy_bindings)
 304                 {
 305                         if(changed&LEGACY_CLIPPING)
 306                         {
 307                                 MatrixStack::modelview() = state->clipping_matrix;
 308                                 state->clipping->bind(true);
 309                                 changed = (changed&~LEGACY_CLIPPING)|LEGACY_MATRIX;
 310                         }
 311                 }
 312                 else
 313                         state->clipping->bind(false);
 314         }
 315         else
 316                 Clipping::unbind();
 317
 318         if(state->shprog)
 319         {
 320                 bool shprog_changed = (state->shprog!=Program::current());
 321                 state->shprog->bind();
 322
 323                 if(!legacy_bindings)
 324                 {
 325                         if(changed&MODERN_MATRIX)
 326                         {
 327                                 standard_shdata.uniform("eye_obj_matrix", state->modelview_matrix);
 328                                 LinAl::SquareMatrix<float, 3> nm = state->modelview_matrix.block<3, 3>(0, 0);
 329                                 nm = transpose(invert(nm));
 330                                 standard_shdata.uniform_matrix3("eye_obj_normal_matrix", &nm(0, 0));
 331                                 changed = (changed&~MODERN_MATRIX)|STANDARD_SHDATA;
 332                         }
 333
 334                         if(state->material && ((changed&MATERIAL_SHDATA) || shprog_changed))
 335                         {
 336                                 state->material->get_shader_data().apply();
 337                                 changed &= ~MATERIAL_SHDATA;
 338                         }
 339
 340                         if((changed&STANDARD_SHDATA) || shprog_changed)
 341                         {
 342                                 standard_shdata.apply();
 343                                 changed &= ~STANDARD_SHDATA;
 344                         }
 345                 }
 346
 347                 bool extra_shdata = (shdata_stack.size()>state->shdata_count);
 348
 349                 if((changed&SHADER_DATA) || shprog_changed || extra_shdata)
 350                 {
 351                         if(extra_shdata)
 352                                 shdata_stack.erase(shdata_stack.begin()+state->shdata_count, shdata_stack.end());
 353                         for(vector<const ProgramData *>::const_iterator i=shdata_stack.begin(); i!=shdata_stack.end(); ++i)
 354                                 (*i)->apply();
 355                         changed &= ~SHADER_DATA;
 356                 }
 357         }
 358         else
 359                 Program::unbind();
 360
 361         if(state->mesh)
 362         {
 363                 if(legacy_bindings)
 364                 {
 365                         Mesh::unbind();
 366                         state->mesh->get_vertices().apply();
 367                 }
 368                 else
 369                         state->mesh->bind();
 370         }
 371         else
 372                 Mesh::unbind();
 373
 374         if(state->winding_test)
 375         {
 376                 if(state->reverse_winding)
 377                         state->winding_test->get_reverse().bind();
 378                 else
 379                         state->winding_test->bind();
 380         }
 381         else
 382                 WindingTest::unbind();
 383
 384         if(legacy_bindings)
 385         {
 386                 if(!matrices_loaded)
 387                 {
 388                         MatrixStack::modelview().push();
 389                         MatrixStack::projection().push();
 390                         matrices_loaded = true;
 391                 }
 392
 393                 if(changed&LEGACY_PROJECTION)
 394                 {
 395                         MatrixStack::projection() = state->camera->get_projection_matrix();
 396                         changed &= ~LEGACY_PROJECTION;
 397                 }
 398
 399                 if(changed&LEGACY_MATRIX)
 400                 {
 401                         MatrixStack::modelview() = state->modelview_matrix;
 402                         changed &= ~LEGACY_MATRIX;
 403                 }
 404         }
 405 }
 406
 407
 408 Renderer::State::State():
 409         camera(0),
 410         texture(0),
 411         texturing(0),
 412         lowest_effect_texunit(TexUnit::get_n_units()),
 413         material(0),
 414         lighting(0),
 415         clipping(0),
 416         shprog(0),
 417         shdata_count(0),
 418         mesh(0),
 419         winding_test(0),
 420         reverse_winding(false)
 421 { }
 422
 423 } // namespace GL
 424 } // namespace Msp