source/mesh.cpp

   1 #include <msp/gl/extensions/arb_vertex_array_object.h>
   2 #include <msp/gl/extensions/arb_vertex_shader.h>
   3 #include "buffer.h"
   4 #include "mesh.h"
   5 #include "renderer.h"
   6
   7 using namespace std;
   8
   9 namespace Msp {
  10 namespace GL {
  11
  12 Mesh::Mesh():
  13         vertices(VERTEX3),
  14         vbuf(0),
  15         ibuf(0),
  16         vao_id(0),
  17         defer_buffers(true),
  18         dirty(0),
  19         winding(0)
  20 { }
  21
  22 Mesh::Mesh(const VertexFormat &f):
  23         vertices(f),
  24         vbuf(0),
  25         ibuf(0),
  26         vao_id(0),
  27         defer_buffers(true),
  28         dirty(2),
  29         winding(0)
  30 { }
  31
  32 Mesh::~Mesh()
  33 {
  34         delete vbuf;
  35         delete ibuf;
  36         if(vao_id)
  37                 glDeleteVertexArrays(1, &vao_id);
  38 }
  39
  40 void Mesh::clear()
  41 {
  42         vertices.clear();
  43         batches.clear();
  44 }
  45
  46 void Mesh::use_buffers(bool b)
  47 {
  48         defer_buffers = false;
  49         if(b)
  50                 create_buffers();
  51         else
  52         {
  53                 vertices.use_buffer(0);
  54                 delete vbuf;
  55                 vbuf = 0;
  56                 delete ibuf;
  57                 ibuf = 0;
  58         }
  59 }
  60
  61 void Mesh::create_buffers()
  62 {
  63         defer_buffers = false;
  64
  65         if(!vbuf)
  66                 vbuf = new Buffer(ARRAY_BUFFER);
  67         vertices.use_buffer(vbuf);
  68
  69         if(!ibuf)
  70                 ibuf = new Buffer(ELEMENT_ARRAY_BUFFER);
  71
  72         if(ARB_vertex_array_object && !vao_id)
  73                 glGenVertexArrays(1, &vao_id);
  74 }
  75
  76 void Mesh::refresh() const
  77 {
  78         vertices.refresh();
  79         if(dirty)
  80         {
  81                 if(dirty&1)
  82                 {
  83                         for(list<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
  84                                 i->refresh();
  85                 }
  86
  87                 if(dirty&2)
  88                 {
  89                         Bind bind_vbuf(vbuf, ARRAY_BUFFER);
  90
  91                         bool bind_here = !current();
  92                         if(bind_here)
  93                                 glBindVertexArray(vao_id);
  94
  95                         const VertexFormat &fmt = vertices.get_format();
  96                         unsigned stride = get_stride(fmt)*sizeof(float);
  97                         float *ptr = 0;
  98                         for(const unsigned char *c=fmt.begin(); c!=fmt.end(); ++c)
  99                         {
 100                                 unsigned t = get_component_type(*c);
 101                                 if(t>=get_component_type(ATTRIB1))
 102                                         t -= get_component_type(ATTRIB1);
 103                                 unsigned sz = get_component_size(*c);
 104                                 if(*c==COLOR4_UBYTE)
 105                                         glVertexAttribPointer(t, 4, GL_UNSIGNED_BYTE, true, stride, ptr);
 106                                 else
 107                                         glVertexAttribPointer(t, sz, GL_FLOAT, false, stride, ptr);
 108                                 glEnableVertexAttribArray(t);
 109                                 ptr += sz;
 110                         }
 111                         glBindBuffer(ELEMENT_ARRAY_BUFFER, ibuf->get_id());
 112
 113                         if(bind_here)
 114                                 glBindVertexArray(0);
 115                 }
 116
 117                 dirty = 0;
 118         }
 119 }
 120
 121 unsigned Mesh::get_n_vertices() const
 122 {
 123         return vertices.size();
 124 }
 125
 126 float *Mesh::modify_vertex(unsigned i)
 127 {
 128         return vertices.modify(i);
 129 }
 130
 131 void Mesh::add_batch(const Batch &b)
 132 {
 133         if(defer_buffers)
 134                 create_buffers();
 135
 136         dirty |= 1;
 137         if(!batches.empty() && batches.back().can_append(b.get_type()))
 138                 batches.back().append(b);
 139         else
 140         {
 141                 Batch *prev = (batches.empty() ? 0 : &batches.back());
 142                 batches.push_back(b);
 143                 if(ibuf)
 144                         batches.back().use_buffer(ibuf, prev);
 145         }
 146 }
 147
 148 void Mesh::set_winding(const WindingTest *w)
 149 {
 150         winding = w;
 151 }
 152
 153 void Mesh::draw() const
 154 {
 155         refresh();
 156
 157         if(!current())
 158         {
 159                 vertices.apply();
 160                 if(ibuf)
 161                         ibuf->bind_to(ELEMENT_ARRAY_BUFFER);
 162         }
 163
 164         Bind bind_winding(winding);
 165
 166         for(list<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
 167                 i->draw();
 168
 169         if(!current() && ibuf)
 170                 Buffer::unbind_from(ELEMENT_ARRAY_BUFFER);
 171 }
 172
 173 void Mesh::draw(Renderer &renderer) const
 174 {
 175         refresh();
 176
 177         renderer.set_mesh(this);
 178         renderer.set_element_buffer(ibuf);
 179         renderer.set_winding_test(winding);
 180
 181         for(list<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
 182                 renderer.draw(*i);
 183 }
 184
 185 void Mesh::bind() const
 186 {
 187         /* If VAOs are not supported, vao_id is zero and set_current won't get
 188         called.  Thus unbind won't try to call a null function either. */
 189         if(!vao_id)
 190                 unbind();
 191         else if(set_current(this))
 192                 glBindVertexArray(vao_id);
 193 }
 194
 195 void Mesh::unbind()
 196 {
 197         if(set_current(0))
 198                 glBindVertexArray(0);
 199 }
 200
 201
 202 Mesh::Loader::Loader(Mesh &m):
 203         DataFile::ObjectLoader<Mesh>(m)
 204 {
 205         add("batch",    &Loader::batch);
 206         add("vertices", &Loader::vertices);
 207         add("winding",  &Loader::winding);
 208 }
 209
 210 void Mesh::Loader::vertices(const vector<VertexComponent> &c)
 211 {
 212         if(c.empty())
 213                 throw invalid_argument("No vertex components");
 214
 215         VertexFormat fmt;
 216         for(vector<VertexComponent>::const_iterator i=c.begin(); i!=c.end(); ++i)
 217                 fmt = (fmt, *i);
 218         obj.vertices.reset(fmt);
 219         obj.dirty |= 2;
 220         load_sub(obj.vertices);
 221 }
 222
 223 void Mesh::Loader::batch(PrimitiveType p)
 224 {
 225         Batch btc(p);
 226         load_sub(btc);
 227         obj.add_batch(btc);
 228 }
 229
 230 void Mesh::Loader::winding(FaceWinding w)
 231 {
 232         if(w==CLOCKWISE)
 233                 obj.winding = &WindingTest::clockwise();
 234         else if(w==COUNTERCLOCKWISE)
 235                 obj.winding = &WindingTest::counterclockwise();
 236 }
 237
 238 } // namespace GL
 239 } // namespace Msp