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