X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Frender%2Finstancearray.cpp;h=eec72f98dc18144c777f8ae61bb5eb3d18677db0;hp=f6a7bb634bd450c0f6f4d4011655331ca72e93ea;hb=HEAD;hpb=c0b7d6ee4a7478f5aecb1504429ec1fc846d64ed

diff --git a/source/render/instancearray.cpp b/source/render/instancearray.cpp
index f6a7bb63..20dcb888 100644
--- a/source/render/instancearray.cpp
+++ b/source/render/instancearray.cpp
@@ -14,11 +14,10 @@ using namespace std;
 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_methods())
@@ -49,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;
+}
 
-	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();
@@ -106,14 +185,27 @@ void InstanceArray::render(Renderer &renderer, Tag tag) const
 		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);
+	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);
+}
+
+
+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