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                         unbind();
  84                         for(list<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
  85                                 i->refresh();
  86                 }
  87
  88                 if(dirty&2)
  89                 {
  90                         glBindVertexArray(vao_id);
  91                         Bind bind_vbuf(vbuf, ARRAY_BUFFER);
  92
  93                         const VertexFormat &fmt = vertices.get_format();
  94                         unsigned stride = get_stride(fmt)*sizeof(float);
  95                         float *ptr = 0;
  96                         for(const unsigned char *c=fmt.begin(); c!=fmt.end(); ++c)
  97                         {
  98                                 unsigned t = get_component_type(*c);
  99                                 if(t>=get_component_type(ATTRIB1))
 100                                         t -= get_component_type(ATTRIB1);
 101                                 unsigned sz = get_component_size(*c);
 102                                 if(*c==COLOR4_UBYTE)
 103                                         glVertexAttribPointer(t, 4, GL_UNSIGNED_BYTE, true, stride, ptr);
 104                                 else
 105                                         glVertexAttribPointer(t, sz, GL_FLOAT, false, stride, ptr);
 106                                 glEnableVertexAttribArray(t);
 107                                 ptr += sz;
 108                         }
 109                         glBindBuffer(ELEMENT_ARRAY_BUFFER, ibuf->get_id());
 110                         glBindVertexArray(0);
 111                 }
 112
 113                 dirty = 0;
 114         }
 115 }
 116
 117 unsigned Mesh::get_n_vertices() const
 118 {
 119         return vertices.size();
 120 }
 121
 122 float *Mesh::modify_vertex(unsigned i)
 123 {
 124         return vertices.modify(i);
 125 }
 126
 127 void Mesh::add_batch(const Batch &b)
 128 {
 129         if(defer_buffers)
 130                 create_buffers();
 131
 132         dirty |= 1;
 133         if(!batches.empty() && batches.back().can_append(b.get_type()))
 134                 batches.back().append(b);
 135         else
 136         {
 137                 Batch *prev = (batches.empty() ? 0 : &batches.back());
 138                 batches.push_back(b);
 139                 if(ibuf)
 140                         batches.back().use_buffer(ibuf, prev);
 141         }
 142 }
 143
 144 void Mesh::set_winding(const WindingTest *w)
 145 {
 146         winding = w;
 147 }
 148
 149 void Mesh::draw() const
 150 {
 151         refresh();
 152
 153         if(!current())
 154         {
 155                 vertices.apply();
 156                 if(ibuf)
 157                         ibuf->bind_to(ELEMENT_ARRAY_BUFFER);
 158         }
 159
 160         Bind bind_winding(winding);
 161
 162         for(list<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
 163                 i->draw();
 164
 165         if(!current() && ibuf)
 166                 Buffer::unbind_from(ELEMENT_ARRAY_BUFFER);
 167 }
 168
 169 void Mesh::draw(Renderer &renderer) const
 170 {
 171         refresh();
 172
 173         renderer.set_mesh(this);
 174         renderer.set_element_buffer(ibuf);
 175         renderer.set_winding_test(winding);
 176
 177         for(list<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
 178                 renderer.draw(*i);
 179 }
 180
 181 void Mesh::bind() const
 182 {
 183         /* If VAOs are not supported, vao_id is zero and set_current won't get
 184         called.  Thus unbind won't try to call a null function either. */
 185         if(!vao_id)
 186                 unbind();
 187         else
 188         {
 189                 if(Buffer::current(ELEMENT_ARRAY_BUFFER))
 190                 {
 191                         unbind();
 192                         Buffer::unbind_from(ELEMENT_ARRAY_BUFFER);
 193                 }
 194                 if(set_current(this))
 195                         glBindVertexArray(vao_id);
 196         }
 197 }
 198
 199 void Mesh::unbind()
 200 {
 201         if(set_current(0))
 202                 glBindVertexArray(0);
 203 }
 204
 205
 206 Mesh::Loader::Loader(Mesh &m):
 207         DataFile::ObjectLoader<Mesh>(m)
 208 {
 209         add("batch",    &Loader::batch);
 210         add("vertices", &Loader::vertices);
 211         add("winding",  &Loader::winding);
 212 }
 213
 214 void Mesh::Loader::vertices(const vector<VertexComponent> &c)
 215 {
 216         if(c.empty())
 217                 throw invalid_argument("No vertex components");
 218
 219         VertexFormat fmt;
 220         for(vector<VertexComponent>::const_iterator i=c.begin(); i!=c.end(); ++i)
 221                 fmt = (fmt, *i);
 222         obj.vertices.reset(fmt);
 223         obj.dirty |= 2;
 224         load_sub(obj.vertices);
 225 }
 226
 227 void Mesh::Loader::batch(PrimitiveType p)
 228 {
 229         Batch btc(p);
 230         load_sub(btc);
 231         obj.add_batch(btc);
 232 }
 233
 234 void Mesh::Loader::winding(FaceWinding w)
 235 {
 236         if(w==CLOCKWISE)
 237                 obj.winding = &WindingTest::clockwise();
 238         else if(w==COUNTERCLOCKWISE)
 239                 obj.winding = &WindingTest::counterclockwise();
 240 }
 241
 242 } // namespace GL
 243 } // namespace Msp