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