Drop Id tags and copyright notices from files

[libs/gl.git] / source / mesh.cpp

diff --git a/source/mesh.cpp b/source/mesh.cpp
index 2ca040e6feb68e3eb65239a4c05e4eadfd997053..c5e73ebd2afd625cda3d1d4041e8b7bd03145ed5 100644 (file)
--- a/source/mesh.cpp
+++ b/source/mesh.cpp
@@ -1,12 +1,7 @@
-/* $Id$
-
-This file is part of libmspgl
-Copyright © 2007  Mikko Rasa, Mikkosoft Productions
-Distributed under the LGPL
-*/
-
 #include "buffer.h"
+#include "extension.h"
 #include "mesh.h"
+#include "renderer.h"
 
 using namespace std;
 
@@ -15,94 +10,124 @@ namespace GL {
 
 Mesh::Mesh():
        vertices(VERTEX3),
-       ibuf(0)
+       ibuf(0),
+       defer_ibuf(true),
+       winding(0)
 { }
 
 Mesh::Mesh(const VertexFormat &f):
        vertices(f),
-       ibuf(0)
+       ibuf(0),
+       defer_ibuf(true),
+       winding(0)
 { }
 
-void Mesh::use_vertex_buffer(bool b)
+Mesh::~Mesh()
+{
+       delete ibuf;
+}
+
+void Mesh::clear()
+{
+       vertices.clear();
+       batches.clear();
+}
+
+void Mesh::use_buffers(bool b)
 {
        if(b)
        {
                vertices.use_vertex_buffer();
                if(!ibuf)
-                       ibuf=new Buffer(ELEMENT_ARRAY_BUFFER);
-               update_index_buffer();
+                       ibuf = new Buffer(ELEMENT_ARRAY_BUFFER);
+               defer_ibuf = false;
        }
        else
        {
                vertices.use_vertex_buffer(0);
                delete ibuf;
-               ibuf=0;
+               ibuf = 0;
+               defer_ibuf = false;
        }
 }
 
-float *Mesh::get_vertex(unsigned i)
+unsigned Mesh::get_n_vertices() const
 {
-       return vertices[i];
+       return vertices.size();
 }
 
-void Mesh::add_batch(const Batch &b)
+float *Mesh::modify_vertex(unsigned i)
 {
-       batches.push_back(b);
-       update_index_buffer();
+       return vertices.modify(i);
 }
 
-void Mesh::clear()
+void Mesh::add_batch(const Batch &b)
 {
-       vertices.clear();
-       batches.clear();
-}
+       bool can_append = false;
+       if(!batches.empty())
+       {
+               PrimitiveType type = b.get_type();
+               can_append = (type==batches.back().get_type() &&
+                       type!=LINE_STRIP && type!=LINE_LOOP && type!=POLYGON &&
+                       (type!=TRIANGLE_FAN || is_supported("GL_NV_primitive_restart")));
+       }
 
-void Mesh::draw() const
-{
-       vertices.apply();
-       if(ibuf)
+       if(defer_ibuf)
        {
-               ibuf->bind();
-               unsigned offset=0;
-               for(list<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
-               {
-                       i->draw_with_buffer(offset);
-                       offset+=i->size();
-               }
-               ibuf->unbind();
+               ibuf = new Buffer(ELEMENT_ARRAY_BUFFER);
+               defer_ibuf = false;
        }
+
+       if(can_append)
+               batches.back().append(b);
        else
        {
-               for(list<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
-                       i->draw();
+               Batch *prev = (batches.empty() ? 0 : &batches.back());
+               batches.push_back(b);
+               if(ibuf)
+                       batches.back().use_index_buffer(ibuf, prev);
        }
 }
 
-void Mesh::update_index_buffer()
+void Mesh::set_winding(const WindingTest *w)
 {
-       if(!ibuf)
-               return;
+       winding = w;
+}
+
+void Mesh::draw() const
+{
+       vertices.apply();
+
+       if(ibuf)
+               ibuf->bind_to(ELEMENT_ARRAY_BUFFER);
+       Bind bind_winding(winding);
 
-       unsigned total=0;
        for(list<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
-               total+=i->size();
+               i->draw();
+
+       if(ibuf)
+               Buffer::unbind_from(ELEMENT_ARRAY_BUFFER);
+}
+
+void Mesh::draw(Renderer &renderer) const
+{
+       renderer.set_vertex_array(&vertices);
+       renderer.set_element_buffer(ibuf);
+       renderer.set_winding_test(winding);
 
-       ibuf->data(total*sizeof(unsigned), 0);
-       unsigned offset=0;
        for(list<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
-       {
-               ibuf->sub_data(offset*sizeof(unsigned), i->size()*sizeof(unsigned), &i->get_indices()[0]);
-               offset+=i->size();
-       }
-       ibuf->unbind();
+               renderer.draw(*i);
+
+       renderer.set_winding_test(0);
 }
 
 
 Mesh::Loader::Loader(Mesh &m):
        DataFile::ObjectLoader<Mesh>(m)
 {
-       add("vertices", &Loader::vertices);
        add("batch",    &Loader::batch);
+       add("vertices", &Loader::vertices);
+       add("winding",  &Loader::winding);
 }
 
 void Mesh::Loader::vertices(VertexFormat f)
@@ -113,8 +138,17 @@ void Mesh::Loader::vertices(VertexFormat f)
 
 void Mesh::Loader::batch(PrimitiveType p)
 {
-       obj.batches.push_back(Batch(p));
-       load_sub(obj.batches.back());
+       Batch btc(p);
+       load_sub(btc);
+       obj.add_batch(btc);
+}
+
+void Mesh::Loader::winding(FaceWinding w)
+{
+       if(w==CLOCKWISE)
+               obj.winding = &WindingTest::clockwise();
+       else if(w==COUNTERCLOCKWISE)
+               obj.winding = &WindingTest::counterclockwise();
 }
 
 } // namespace GL