#include <msp/core/algorithm.h>
#include <msp/core/maputils.h>
#include "buffer.h"
-#include "camera.h"
#include "instancearray.h"
#include "mesh.h"
#include "object.h"
namespace Msp {
namespace GL {
-InstanceArray::InstanceArray(const Object &o):
+InstanceArrayBase::InstanceArrayBase(const Object &o, size_t s):
object(o),
- instance_buffer(0),
- matrix_location(-1),
- matrix_offset(0)
+ instance_size(s),
+ default_count(max<size_t>(4096U/instance_size, 8U))
{
const Technique *tech = object.get_technique();
- for(const auto &kvp: tech->get_passes())
+ for(const auto &kvp: tech->get_methods())
{
const Program *shprog = kvp.second.get_shader_program();
if(!shprog)
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;
+}
- delete *i;
- *i = instances.back();
- instances.pop_back();
+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;
+ }
+
+ 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;
+ }
+
+ 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;
+}
- float *d = reinterpret_cast<float *>(instance_data.modify(instances.size()-1)+matrix_offset);
+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();
if(!tech)
throw logic_error("no technique");
- const RenderPass *pass = tech->find_pass(tag);
- if(!pass)
+ const RenderMethod *method = tech->find_method(tag);
+ if(!method)
return;
const Mesh *mesh = object.get_mesh();
- mesh->get_vertices().refresh();
if(instance_buffer->get_size()==0)
- instance_buffer->storage(instance_data.get_required_buffer_size());
- instance_data.refresh();
+ instance_buffer->storage(instance_data.get_required_buffer_size(), STREAMING);
Renderer::Push push(renderer);
- pass->apply(renderer);
- mesh->draw_instanced(renderer, vtx_setup, instances.size());
+ renderer.set_pipeline_key(this, tag.id);
+ method->apply(renderer);
+ mesh->draw_instanced(renderer, vtx_setup, instance_count);
+}
+
+
+DataFile::Loader::ActionMap InstanceArrayBase::Loader::shared_actions;
+
+InstanceArrayBase::Loader::Loader(InstanceArrayBase &o):
+ ObjectLoader<InstanceArrayBase>(o)
+{
+ set_actions(shared_actions);
+}
+
+void InstanceArrayBase::Loader::init_actions()
+{
+ add("instance", &Loader::instance);
}
} // namespace GL
projects / libs / gl.git / blobdiff