Redesign InstanceArray

[libs/gl.git] / source / render / instancearray.cpp

diff --git a/source/render/instancearray.cpp b/source/render/instancearray.cpp
index a03fbf20dff9ca2766c15067087389e0d2902fd3..0a3d6b685ad3ffb98b9ee6265db0eba2c3328431 100644 (file)
--- a/source/render/instancearray.cpp
+++ b/source/render/instancearray.cpp
@@ -14,8 +14,10 @@ using namespace std;
 namespace Msp {
 namespace GL {
 
-InstanceArray::InstanceArray(const Object &o):
-       object(o)
+InstanceArrayBase::InstanceArrayBase(const Object &o, size_t s):
+       object(o),
+       instance_size(s),
+       default_count(max<size_t>(4096U/instance_size, 8U))
 {
        const Technique *tech = object.get_technique();
        for(const auto &kvp: tech->get_methods())
@@ -46,53 +48,133 @@ InstanceArray::InstanceArray(const Object &o):
        vtx_setup.set_instance_array(instance_data);
 }
 
-InstanceArray::~InstanceArray()
+InstanceArrayBase::~InstanceArrayBase()
 {
-       for(ObjectInstance *i: instances)
-               delete i;
        delete instance_buffer;
+       for(Block &b: storage)
+               delete[] b.begin;
 }
 
-void InstanceArray::append(ObjectInstance *inst)
+void InstanceArrayBase::add_block(size_t count)
 {
-       instances.push_back(inst);
-       if(instance_data.size()<instances.size())
+       storage.emplace_back();
+       Block &block = storage.back();
+       block.begin = new char[count*instance_size];
+       block.end = block.begin+count*instance_size;
+
+       size_t block_index = storage.size()-1;
+       size_t base = slots.size();
+       slots.resize(base+count);
+       for(size_t i=0; i<count; ++i)
+       {
+               Slot &slot = slots[base+i];
+               slot.next_free = base+i+1;
+               slot.block_index = block_index;
+               slot.index_in_block = i;
+       }
+
+       if(first_free>0)
+               slots[last_free].next_free = base;
+       else
+       {
+               first_free = base;
+               last_free = slots.size()-1;
+       }
+
+       slots.back().next_free = first_free;
+}
+
+size_t InstanceArrayBase::allocate()
+{
+       if(first_free<0)
+               add_block(default_count);
+
+       size_t index = first_free;
+       Slot &slot = slots[index];
+       if(first_free==last_free)
+       {
+               first_free = -1;
+               last_free = -1;
+       }
+       else
+       {
+               first_free = slot.next_free;
+               slots[last_free].next_free = first_free;
+       }
+
+       slot.used = true;
+       slot.array_index = instance_count++;
+       if(instance_data.size()<instance_count)
        {
                instance_data.append();
-               unsigned req_size = instance_data.get_required_buffer_size();
-               if(instance_buffer->get_size()>0 && instance_buffer->get_size()<req_size)
-               {
-                       delete instance_buffer;
-                       instance_buffer = new Buffer;
-                       instance_data.use_buffer(instance_buffer);
-               }
+               array_order.push_back(index);
        }
-       update_instance_matrix(instances.size()-1);
+       else
+               array_order[slot.array_index] = index;
+
+       return index;
 }
 
-void InstanceArray::remove(ObjectInstance &inst)
+char *InstanceArrayBase::get_address(size_t index) const
 {
-       auto i = find(instances, &inst);
-       if(i==instances.end())
-               throw key_error(&inst);
+       const Slot &s = slots[index];
+       return storage[s.block_index].begin+s.index_in_block*instance_size;
+}
+
+size_t InstanceArrayBase::find_index(char *addr) const
+{
+       size_t base = 0;
+       for(const Block &b: storage)
+       {
+               if(addr>=b.begin && addr<b.end)
+                       return base+(addr-b.begin)/instance_size;
+               base += (b.end-b.begin)/instance_size;
+       }
 
-       delete *i;
-       *i = instances.back();
-       instances.pop_back();
+       throw out_of_range("InstanceArrayBase::find_index");
 }
 
-void InstanceArray::update_instance_matrix(unsigned index)
+void InstanceArrayBase::release(size_t index)
 {
-       const Matrix &m = *instances[index]->get_matrix();
+       Slot &slot = slots[index];
+
+       --instance_count;
+       if(slot.array_index<instance_count)
+       {
+               size_t swap_index = array_order[instance_count];
+               unsigned stride = instance_data.get_format().stride();
+               const char *src = instance_data[swap_index];
+               char *dst = instance_data.modify(slot.array_index);
+               copy(src, src+stride, dst);
+               slots[swap_index].array_index = slot.array_index;
+               array_order[slot.array_index] = swap_index;
+               array_order[instance_count] = -1;
+       }
 
-       float *d = reinterpret_cast<float *>(instance_data.modify(index)+matrix_offset);
+       slot.used = false;
+       if(first_free>=0)
+       {
+               slot.next_free = first_free;
+               slots[last_free].next_free = index;
+       }
+       else
+       {
+               slot.next_free = index;
+               first_free = index;
+       }
+       last_free = index;
+}
+
+void InstanceArrayBase::update_instance_matrix(size_t index, const Matrix &matrix)
+{
+       float *d = reinterpret_cast<float *>(instance_data.modify(slots[index].array_index)+matrix_offset);
        for(unsigned i=0; i<12; ++i)
-               d[i] = m(i/4, i%4);
+               d[i] = matrix(i/4, i%4);
 }
 
-void InstanceArray::render(Renderer &renderer, Tag tag) const
+void InstanceArrayBase::render(Renderer &renderer, Tag tag) const
 {
-       if(instances.empty())
+       if(!instance_count)
                return;
 
        const Technique *tech = object.get_technique();
@@ -109,7 +191,7 @@ void InstanceArray::render(Renderer &renderer, Tag tag) const
        Renderer::Push push(renderer);
        renderer.set_pipeline_key(this, tag.id);
        method->apply(renderer);
-       mesh->draw_instanced(renderer, vtx_setup, instances.size());
+       mesh->draw_instanced(renderer, vtx_setup, instance_count);
 }
 
 } // namespace GL