source/mesh.cpp

   1 #include "buffer.h"
   2 #include "mesh.h"
   3 #include "renderer.h"
   4
   5 using namespace std;
   6
   7 namespace Msp {
   8 namespace GL {
   9
  10 Mesh::Mesh():
  11         vertices(VERTEX3),
  12         ibuf(0),
  13         defer_ibuf(true),
  14         winding(0)
  15 { }
  16
  17 Mesh::Mesh(const VertexFormat &f):
  18         vertices(f),
  19         ibuf(0),
  20         defer_ibuf(true),
  21         winding(0)
  22 { }
  23
  24 Mesh::~Mesh()
  25 {
  26         delete ibuf;
  27 }
  28
  29 void Mesh::clear()
  30 {
  31         vertices.clear();
  32         batches.clear();
  33 }
  34
  35 void Mesh::use_buffers(bool b)
  36 {
  37         if(b)
  38         {
  39                 vertices.use_vertex_buffer();
  40                 if(!ibuf)
  41                         ibuf = new Buffer(ELEMENT_ARRAY_BUFFER);
  42                 defer_ibuf = false;
  43         }
  44         else
  45         {
  46                 vertices.use_vertex_buffer(0);
  47                 delete ibuf;
  48                 ibuf = 0;
  49                 defer_ibuf = false;
  50         }
  51 }
  52
  53 unsigned Mesh::get_n_vertices() const
  54 {
  55         return vertices.size();
  56 }
  57
  58 float *Mesh::modify_vertex(unsigned i)
  59 {
  60         return vertices.modify(i);
  61 }
  62
  63 void Mesh::add_batch(const Batch &b)
  64 {
  65         if(defer_ibuf)
  66         {
  67                 ibuf = new Buffer(ELEMENT_ARRAY_BUFFER);
  68                 defer_ibuf = false;
  69         }
  70
  71         if(!batches.empty() && batches.back().can_append(b.get_type()))
  72                 batches.back().append(b);
  73         else
  74         {
  75                 Batch *prev = (batches.empty() ? 0 : &batches.back());
  76                 batches.push_back(b);
  77                 if(ibuf)
  78                         batches.back().use_buffer(ibuf, prev);
  79         }
  80 }
  81
  82 void Mesh::set_winding(const WindingTest *w)
  83 {
  84         winding = w;
  85 }
  86
  87 void Mesh::draw() const
  88 {
  89         vertices.apply();
  90
  91         if(ibuf)
  92                 ibuf->bind_to(ELEMENT_ARRAY_BUFFER);
  93         Bind bind_winding(winding);
  94
  95         for(list<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
  96                 i->draw();
  97
  98         if(ibuf)
  99                 Buffer::unbind_from(ELEMENT_ARRAY_BUFFER);
 100 }
 101
 102 void Mesh::draw(Renderer &renderer) const
 103 {
 104         renderer.set_vertex_array(&vertices);
 105         renderer.set_element_buffer(ibuf);
 106         renderer.set_winding_test(winding);
 107
 108         for(list<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
 109                 renderer.draw(*i);
 110
 111         renderer.set_winding_test(0);
 112 }
 113
 114
 115 Mesh::Loader::Loader(Mesh &m):
 116         DataFile::ObjectLoader<Mesh>(m)
 117 {
 118         add("batch",    &Loader::batch);
 119         add("vertices", &Loader::vertices);
 120         add("winding",  &Loader::winding);
 121 }
 122
 123 void Mesh::Loader::vertices(const vector<VertexComponent> &c)
 124 {
 125         if(c.empty())
 126                 throw invalid_argument("No vertex components");
 127
 128         VertexFormat fmt;
 129         for(vector<VertexComponent>::const_iterator i=c.begin(); i!=c.end(); ++i)
 130                 fmt = (fmt, *i);
 131         obj.vertices.reset(fmt);
 132         load_sub(obj.vertices);
 133 }
 134
 135 void Mesh::Loader::batch(PrimitiveType p)
 136 {
 137         Batch btc(p);
 138         load_sub(btc);
 139         obj.add_batch(btc);
 140 }
 141
 142 void Mesh::Loader::winding(FaceWinding w)
 143 {
 144         if(w==CLOCKWISE)
 145                 obj.winding = &WindingTest::clockwise();
 146         else if(w==COUNTERCLOCKWISE)
 147                 obj.winding = &WindingTest::counterclockwise();
 148 }
 149
 150 } // namespace GL
 151 } // namespace Msp