source/render/renderer.cpp

   1 #include "batch.h"
   2 #include "buffer.h"
   3 #include "camera.h"
   4 #include "clipping.h"
   5 #include "deviceinfo.h"
   6 #include "error.h"
   7 #include "lighting.h"
   8 #include "material.h"
   9 #include "program.h"
  10 #include "programdata.h"
  11 #include "renderable.h"
  12 #include "renderer.h"
  13 #include "resourcemanager.h"
  14 #include "sampler.h"
  15 #include "texture.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()
  26 {
  27         state_stack.reserve(16);
  28         state_stack.push_back(State());
  29         shdata_stack.reserve(32);
  30         state = &state_stack.back();
  31         add_shader_data(standard_shdata);
  32 }
  33
  34 Renderer::~Renderer()
  35 {
  36         end();
  37 }
  38
  39 void Renderer::set_camera(const Camera &c)
  40 {
  41         state->camera = &c;
  42         add_shader_data(c.get_shader_data());
  43         set_matrix(Matrix());
  44 }
  45
  46 void Renderer::set_matrix(const Matrix &matrix)
  47 {
  48         state->model_matrix = matrix;
  49         changed |= MATRIX;
  50 }
  51
  52 void Renderer::transform(const Matrix &matrix)
  53 {
  54         state->model_matrix *= matrix;
  55         changed |= MATRIX;
  56 }
  57
  58 void Renderer::set_texture(Tag tag, const Texture *tex, const Sampler *samp)
  59 {
  60         if(tex)
  61                 if(ResourceManager *res_mgr = tex->get_manager())
  62                         res_mgr->resource_used(*tex);
  63
  64         if(texture_stack.size()>state->texture_count)
  65         {
  66                 BoundTexture &bt = texture_stack[state->texture_count];
  67                 if(bt.tag==tag && bt.texture==tex && bt.sampler==samp)
  68                 {
  69                         ++state->texture_count;
  70                         return;
  71                 }
  72                 else
  73                         flush_textures();
  74         }
  75
  76         for(vector<BoundTexture>::iterator i=texture_stack.end(); i!=texture_stack.begin(); )
  77                 if((--i)->tag==tag)
  78                 {
  79                         i->replaced = texture_stack.size();
  80                         break;
  81                 }
  82
  83         texture_stack.push_back(BoundTexture());
  84         BoundTexture &bound_tex = texture_stack.back();
  85         bound_tex.tag = tag;
  86         bound_tex.texture = tex;
  87         bound_tex.sampler = samp;
  88         state->texture_count = texture_stack.size();
  89 }
  90
  91 void Renderer::flush_textures()
  92 {
  93         for(unsigned i=0; i<state->texture_count; ++i)
  94                 if(texture_stack[i].replaced>=static_cast<int>(state->texture_count))
  95                         texture_stack[i].replaced = -1;
  96
  97         texture_stack.erase(texture_stack.begin()+state->texture_count, texture_stack.end());
  98 }
  99
 100 void Renderer::set_material(const Material *m)
 101 {
 102         if(m)
 103                 add_shader_data(m->get_shader_data());
 104 }
 105
 106 void Renderer::set_lighting(const Lighting *l)
 107 {
 108         if(l)
 109                 add_shader_data(l->get_shader_data());
 110 }
 111
 112 void Renderer::set_clipping(const Clipping *c)
 113 {
 114         state->clipping = c;
 115         if(c)
 116                 add_shader_data(c->get_shader_data());
 117 }
 118
 119 void Renderer::set_shader_program(const Program *p, const ProgramData *d)
 120 {
 121         state->shprog = p;
 122         if(p && d)
 123                 add_shader_data(*d);
 124 }
 125
 126 void Renderer::add_shader_data(const ProgramData &d)
 127 {
 128         if(state->shdata_count<shdata_stack.size())
 129         {
 130                 const BoundProgramData &top = shdata_stack.back();
 131                 if(top.shdata==&d && top.generation==d.get_generation())
 132                 {
 133                         ++state->shdata_count;
 134                         return;
 135                 }
 136         }
 137
 138         flush_shader_data_();
 139         shdata_stack.push_back(&d);
 140         state->shdata_count = shdata_stack.size();
 141         changed |= SHADER_DATA;
 142 }
 143
 144 void Renderer::flush_shader_data_()
 145 {
 146         if(shdata_stack.size()>state->shdata_count)
 147                 shdata_stack.erase(shdata_stack.begin()+state->shdata_count, shdata_stack.end());
 148 }
 149
 150 void Renderer::set_vertex_setup(const VertexSetup *vs)
 151 {
 152         state->vertex_setup = vs;
 153 }
 154
 155 void Renderer::set_winding_test(const WindingTest *w)
 156 {
 157         state->winding_test = w;
 158 }
 159
 160 void Renderer::set_reverse_winding(bool r)
 161 {
 162         state->reverse_winding = r;
 163 }
 164
 165 void Renderer::set_object_lod_bias(unsigned b)
 166 {
 167         state->object_lod_bias = b;
 168 }
 169
 170 void Renderer::push_state()
 171 {
 172         state_stack.push_back(state_stack.back());
 173         state = &state_stack.back();
 174 }
 175
 176 void Renderer::pop_state()
 177 {
 178         if(state_stack.size()==1)
 179                 throw stack_underflow("Renderer::pop_state");
 180
 181         state_stack.pop_back();
 182         state = &state_stack.back();
 183         changed |= MATRIX;
 184 }
 185
 186 void Renderer::end()
 187 {
 188         if(state_stack.size()>1)
 189                 throw invalid_operation("Renderer::end");
 190
 191         *state = State();
 192         shdata_stack.clear();
 193         add_shader_data(standard_shdata);
 194         excluded.clear();
 195
 196         PipelineState::clear();
 197 }
 198
 199 void Renderer::exclude(const Renderable &renderable)
 200 {
 201         excluded.insert(&renderable);
 202 }
 203
 204 void Renderer::include(const Renderable &renderable)
 205 {
 206         excluded.erase(&renderable);
 207 }
 208
 209 void Renderer::render(const Renderable &renderable, Tag tag)
 210 {
 211         if(!excluded.count(&renderable))
 212                 renderable.render(*this, tag);
 213 }
 214
 215 void Renderer::draw(const Batch &batch)
 216 {
 217         apply_state();
 218
 219         batch.draw();
 220 }
 221
 222 void Renderer::draw_instanced(const Batch &batch, unsigned count)
 223 {
 224         apply_state();
 225
 226         batch.draw_instanced(count);
 227 }
 228
 229 void Renderer::apply_state()
 230 {
 231         if(!state->shprog)
 232                 throw invalid_operation("Renderer::apply_state");
 233
 234         if(changed&MATRIX)
 235         {
 236                 standard_shdata.uniform("world_obj_matrix", state->model_matrix);
 237                 LinAl::SquareMatrix<float, 3> nm = state->model_matrix.block<3, 3>(0, 0);
 238                 nm = transpose(invert(nm));
 239                 standard_shdata.uniform("world_obj_normal_matrix", nm);
 240                 changed &= ~MATRIX;
 241         }
 242
 243         bool shprog_changed = (state->shprog!=pipeline_state.get_shader_program());
 244         pipeline_state.set_shader_program(state->shprog);
 245
 246         if(state->vertex_setup)
 247         {
 248                 if(const VertexArray *array = state->vertex_setup->get_vertex_array())
 249                         array->refresh();
 250                 if(const VertexArray *array = state->vertex_setup->get_instance_array())
 251                         array->refresh();
 252         }
 253         pipeline_state.set_vertex_setup(state->vertex_setup);
 254
 255         pipeline_state.set_winding_test((state->winding_test && state->reverse_winding) ? &state->winding_test->get_reverse() : state->winding_test);
 256         pipeline_state.set_enabled_clip_planes(state->clipping ? (1<<state->clipping->get_n_planes())-1 : 0);
 257
 258         if(state->texture_count<texture_stack.size())
 259                 flush_textures();
 260
 261         for(vector<BoundTexture>::const_iterator i=texture_stack.begin(); i!=texture_stack.end(); ++i)
 262         {
 263                 int unit = (i->tag.id ? state->shprog->get_uniform_binding(i->tag) : i->unit);
 264                 if(unit>=0)
 265                         pipeline_state.set_texture(unit, i->texture, i->sampler);
 266         }
 267
 268         bool shdata_changed = changed&SHADER_DATA;
 269         for(vector<BoundProgramData>::const_iterator i=shdata_stack.begin(); (!shdata_changed && i!=shdata_stack.end()); ++i)
 270                 shdata_changed = (i->shdata->get_generation()!=i->generation);
 271         bool extra_shdata = (shdata_stack.size()>state->shdata_count);
 272
 273         if(shdata_changed || shprog_changed || extra_shdata)
 274         {
 275                 if(extra_shdata)
 276                         shdata_stack.erase(shdata_stack.begin()+state->shdata_count, shdata_stack.end());
 277                 for(vector<BoundProgramData>::const_iterator i=shdata_stack.begin(); i!=shdata_stack.end(); ++i)
 278                 {
 279                         i->shdata->apply(*state->shprog, pipeline_state);
 280                         i->generation = i->shdata->get_generation();
 281                 }
 282                 changed &= ~SHADER_DATA;
 283         }
 284
 285         pipeline_state.apply();
 286 }
 287
 288
 289 Renderer::BoundTexture::BoundTexture():
 290         unit(-1),
 291         texture(0),
 292         sampler(0),
 293         replaced(-1)
 294 { }
 295
 296
 297 Renderer::BoundProgramData::BoundProgramData(const ProgramData *d):
 298         shdata(d),
 299         generation(0)
 300 { }
 301
 302
 303 Renderer::State::State():
 304         camera(0),
 305         texture_count(0),
 306         lowest_effect_texunit(Limits::get_global().max_texture_bindings),
 307         clipping(0),
 308         shprog(0),
 309         shdata_count(0),
 310         vertex_setup(0),
 311         winding_test(0),
 312         reverse_winding(false),
 313         object_lod_bias(0)
 314 { }
 315
 316 } // namespace GL
 317 } // namespace Msp