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