From fa2b4c8a93ebad2497cacfdeaa9a2c20be486520 Mon Sep 17 00:00:00 2001
From: Mikko Rasa <tdb@tdb.fi>
Date: Sat, 10 Apr 2021 15:04:26 +0300
Subject: [PATCH] Use Tag to identify uniforms in Program and ProgramData

Setting uniforms is a common operation and this should be faster than
using strings.
---
 source/core/program.cpp         |  43 +++--
 source/core/program.h           |  10 +-
 source/{render => core}/tag.cpp |   0
 source/{render => core}/tag.h   |   0
 source/materials/renderpass.cpp |   9 +-
 source/materials/renderpass.h   |   4 +-
 source/materials/technique.cpp  |  10 +-
 source/render/programdata.cpp   | 310 ++++++++++++++++----------------
 source/render/programdata.h     | 140 +++++++--------
 source/render/text.cpp          |   8 +-
 10 files changed, 275 insertions(+), 259 deletions(-)
 rename source/{render => core}/tag.cpp (100%)
 rename source/{render => core}/tag.h (100%)

diff --git a/source/core/program.cpp b/source/core/program.cpp
index dd38075a..2c15bc77 100644
--- a/source/core/program.cpp
+++ b/source/core/program.cpp
@@ -372,13 +372,14 @@ void Program::query_uniforms()
 			uniforms.push_back(UniformInfo());
 			UniformInfo &info = uniforms.back();
 			info.name = name;
+			info.tag = name;
 			info.array_size = size;
 			info.type = from_gl_type(type);
 			uniform_names[i] = name;
 		}
 	}
 
-	sort(uniforms, &uniform_name_compare);
+	sort(uniforms, &uniform_tag_compare);
 
 	if(ARB_uniform_buffer_object)
 	{
@@ -386,7 +387,7 @@ void Program::query_uniforms()
 		for(unsigned i=0; i<count; ++i)
 			if(!uniform_names[i].empty())
 				// The element is already known to be present
-				uniforms_by_index[i] = &*lower_bound(uniforms, uniform_names[i], &name_search<UniformInfo>);
+				uniforms_by_index[i] = &*lower_bound(uniforms, Tag(uniform_names[i]), &search<UniformInfo, Tag, &UniformInfo::tag>);
 		query_uniform_blocks(uniforms_by_index);
 	}
 
@@ -531,13 +532,14 @@ void Program::collect_uniforms()
 			uniforms.push_back(UniformInfo());
 			UniformInfo &info = uniforms.back();
 			info.name = i->name;
+			info.tag = i->name;
 			info.location = i->location;
 			info.array_size = i->array_size;
 			info.type = i->type;
 		}
 	}
 
-	sort(uniforms, &uniform_name_compare);
+	sort(uniforms, &uniform_tag_compare);
 
 	for(unsigned i=0; i<uniform_blocks.size(); ++i)
 	{
@@ -546,7 +548,7 @@ void Program::collect_uniforms()
 		for(vector<string>::const_iterator j=names.begin(); j!=names.end(); ++j)
 		{
 			// The element is already known to be present
-			UniformInfo &uni = *lower_bound(uniforms, *j, &name_search<UniformInfo>);
+			UniformInfo &uni = *lower_bound(uniforms, Tag(*j), &search<UniformInfo, Tag, &UniformInfo::tag>);
 			block.uniforms.push_back(&uni);
 			uni.block = &block;
 		}
@@ -578,6 +580,7 @@ void Program::collect_block_uniforms(const SpirVModule::Structure &strct, const
 			uniforms.push_back(UniformInfo());
 			UniformInfo &info = uniforms.back();
 			info.name = name;
+			info.tag = name;
 			info.offset = offset;
 			info.array_size = i->array_size;
 			info.array_stride = i->array_stride;
@@ -629,15 +632,15 @@ bool Program::uniform_location_compare(const UniformInfo *uni1, const UniformInf
 	return uni1->location<uni2->location;
 }
 
-bool Program::uniform_name_compare(const UniformInfo &uni1, const UniformInfo &uni2)
+bool Program::uniform_tag_compare(const UniformInfo &uni1, const UniformInfo &uni2)
 {
-	return uni1.name<uni2.name;
+	return uni1.tag<uni2.tag;
 }
 
-template<typename T>
-bool Program::name_search(const T &item, const string &name)
+template<typename T, typename A, A T::*member>
+bool Program::search(const T &item, const A &key)
 {
-	return item.name<name;
+	return item.*member<key;
 }
 
 string Program::get_info_log() const
@@ -659,24 +662,38 @@ const Program::UniformBlockInfo &Program::get_uniform_block_info(const string &n
 
 const Program::UniformInfo &Program::get_uniform_info(const string &name) const
 {
-	vector<UniformInfo>::const_iterator i = lower_bound(uniforms, name, &name_search<UniformInfo>);
+	vector<UniformInfo>::const_iterator i = lower_bound(uniforms, Tag(name), &search<UniformInfo, Tag, &UniformInfo::tag>);
 	if(i==uniforms.end() || i->name!=name)
 		throw key_error(name);
 	return *i;
 }
 
+const Program::UniformInfo &Program::get_uniform_info(Tag tag) const
+{
+	vector<UniformInfo>::const_iterator i = lower_bound(uniforms, tag, &search<UniformInfo, Tag, &UniformInfo::tag>);
+	if(i==uniforms.end() || i->tag!=tag)
+		throw key_error(tag);
+	return *i;
+}
+
 int Program::get_uniform_location(const string &name) const
 {
 	if(name[name.size()-1]==']')
 		throw invalid_argument("Program::get_uniform_location");
 
-	vector<UniformInfo>::const_iterator i = lower_bound(uniforms, name, &name_search<UniformInfo>);
+	vector<UniformInfo>::const_iterator i = lower_bound(uniforms, Tag(name), &search<UniformInfo, Tag, &UniformInfo::tag>);
 	return i!=uniforms.end() && i->name==name && i->block->bind_point<0 ? i->location : -1;
 }
 
+int Program::get_uniform_location(Tag tag) const
+{
+	vector<UniformInfo>::const_iterator i = lower_bound(uniforms, tag, &search<UniformInfo, Tag, &UniformInfo::tag>);
+	return i!=uniforms.end() && i->tag==tag && i->block->bind_point<0 ? i->location : -1;
+}
+
 const Program::AttributeInfo &Program::get_attribute_info(const string &name) const
 {
-	vector<AttributeInfo>::const_iterator i = lower_bound(attributes, name, &name_search<AttributeInfo>);
+	vector<AttributeInfo>::const_iterator i = lower_bound(attributes, name, &search<AttributeInfo, string, &AttributeInfo::name>);
 	if(i==attributes.end() || i->name!=name)
 		throw key_error(name);
 	return *i;
@@ -687,7 +704,7 @@ int Program::get_attribute_location(const string &name) const
 	if(name[name.size()-1]==']')
 		throw invalid_argument("Program::get_attribute_location");
 
-	vector<AttributeInfo>::const_iterator i = lower_bound(attributes, name, &name_search<AttributeInfo>);
+	vector<AttributeInfo>::const_iterator i = lower_bound(attributes, name, &search<AttributeInfo, string, &AttributeInfo::name>);
 	return i!=attributes.end() && i->name==name ? i->location : -1;
 }
 
diff --git a/source/core/program.h b/source/core/program.h
index 6613a134..939521dc 100644
--- a/source/core/program.h
+++ b/source/core/program.h
@@ -8,6 +8,7 @@
 #include "datatype.h"
 #include "gl.h"
 #include "module.h"
+#include "tag.h"
 #include "vertexformat.h"
 
 namespace Msp {
@@ -72,6 +73,7 @@ public:
 		unsigned array_stride;
 		unsigned matrix_stride;
 		DataType type;
+		Tag tag;
 
 		UniformInfo();
 	};
@@ -160,9 +162,9 @@ private:
 	void update_layout_hash();
 	static LayoutHash compute_layout_hash(const std::vector<const UniformInfo *> &);
 	static bool uniform_location_compare(const UniformInfo *, const UniformInfo *);
-	static bool uniform_name_compare(const UniformInfo &, const UniformInfo &);
-	template<typename T>
-	static bool name_search(const T &, const std::string &);
+	static bool uniform_tag_compare(const UniformInfo &, const UniformInfo &);
+	template<typename T, typename A, A T::*>
+	static bool search(const T &, const A &);
 public:
 	bool is_linked() const { return linked; }
 	DEPRECATED std::string get_info_log() const;
@@ -172,7 +174,9 @@ public:
 	const UniformBlockInfo &get_uniform_block_info(const std::string &) const;
 	const std::vector<UniformInfo> &get_uniforms() const { return uniforms; }
 	const UniformInfo &get_uniform_info(const std::string &) const;
+	const UniformInfo &get_uniform_info(Tag) const;
 	int get_uniform_location(const std::string &) const;
+	int get_uniform_location(Tag) const;
 	const std::vector<AttributeInfo> &get_attributes() const { return attributes; }
 	const AttributeInfo &get_attribute_info(const std::string &) const;
 	int get_attribute_location(const std::string &) const;
diff --git a/source/render/tag.cpp b/source/core/tag.cpp
similarity index 100%
rename from source/render/tag.cpp
rename to source/core/tag.cpp
diff --git a/source/render/tag.h b/source/core/tag.h
similarity index 100%
rename from source/render/tag.h
rename to source/core/tag.h
diff --git a/source/materials/renderpass.cpp b/source/materials/renderpass.cpp
index 810b3673..7431a446 100644
--- a/source/materials/renderpass.cpp
+++ b/source/materials/renderpass.cpp
@@ -106,14 +106,11 @@ void RenderPass::set_shader_program(const Program *prog, const ProgramData *data
 		finalize_material(0);
 }
 
-const string &RenderPass::get_slotted_uniform_name(const string &slot) const
+Tag RenderPass::get_slotted_uniform_tag(Tag slot) const
 {
-	map<string, string>::const_iterator i = uniform_slots.find(slot);
+	map<Tag, Tag>::const_iterator i = uniform_slots.find(slot);
 	if(i==uniform_slots.end())
-	{
-		static string empty;
-		return empty;
-	}
+		return Tag();
 	return i->second;
 }
 
diff --git a/source/materials/renderpass.h b/source/materials/renderpass.h
index b674945e..0e8ccdf2 100644
--- a/source/materials/renderpass.h
+++ b/source/materials/renderpass.h
@@ -64,7 +64,7 @@ private:
 	RefPtr<const Program> shprog;
 	bool shprog_from_material;
 	RefPtr<ProgramData> shdata;
-	std::map<std::string, std::string> uniform_slots;
+	std::map<Tag, Tag> uniform_slots;
 	RefPtr<const Material> material;
 	std::string material_slot;
 	Texturing *texturing;
@@ -86,7 +86,7 @@ public:
 	void set_shader_program(const Program *, const ProgramData *);
 	const Program *get_shader_program() const { return shprog.get(); }
 	const ProgramData *get_shader_data() const { return shdata.get(); }
-	const std::string &get_slotted_uniform_name(const std::string &) const;
+	Tag get_slotted_uniform_tag(Tag) const;
 	void set_material(const Material *, DataFile::Collection * = 0);
 	const Material *get_material() const { return material.get(); }
 	const std::string &get_material_slot_name() const { return material_slot; }
diff --git a/source/materials/technique.cpp b/source/materials/technique.cpp
index 22f8f3b6..a382376e 100644
--- a/source/materials/technique.cpp
+++ b/source/materials/technique.cpp
@@ -69,20 +69,20 @@ bool Technique::replace_material(const string &slot, const Material &mat)
 bool Technique::replace_uniforms(const ProgramData &shdata)
 {
 	bool replaced = false;
-	const vector<string> &uniform_names = shdata.get_uniform_names();
+	const vector<Tag> &uniform_tags = shdata.get_uniform_tags();
 	for(PassMap::iterator i=passes.begin(); i!=passes.end(); ++i)
 	{
 		RefPtr<ProgramData> new_shdata;
-		for(vector<string>::const_iterator j=uniform_names.begin(); j!=uniform_names.end(); ++j)
+		for(vector<Tag>::const_iterator j=uniform_tags.begin(); j!=uniform_tags.end(); ++j)
 		{
-			const string &name = i->second.get_slotted_uniform_name(*j);
-			if(name.empty())
+			Tag tag = i->second.get_slotted_uniform_tag(*j);
+			if(!tag.id)
 				continue;
 
 			if(!new_shdata)
 				new_shdata = new ProgramData(*i->second.get_shader_data());
 
-			new_shdata->uniform(name, shdata.get_uniform(*j));
+			new_shdata->uniform(tag, shdata.get_uniform(*j));
 			replaced = true;
 		}
 
diff --git a/source/render/programdata.cpp b/source/render/programdata.cpp
index 401ed189..9c23e8a5 100644
--- a/source/render/programdata.cpp
+++ b/source/render/programdata.cpp
@@ -32,7 +32,7 @@ ProgramData::ProgramData(const ProgramData &other):
 	buffer(0),
 	dirty(0)
 {
-	for(vector<NamedUniform>::iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
+	for(vector<TaggedUniform>::iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
 		i->value = i->value->clone();
 }
 
@@ -44,12 +44,12 @@ ProgramData::ProgramData(const ProgramData &other, const Program *p):
 {
 	if(tied_program)
 	{
-		for(vector<NamedUniform>::const_iterator i=other.uniforms.begin(); i!=other.uniforms.end(); ++i)
-			validate_name(i->name);
+		for(vector<TaggedUniform>::const_iterator i=other.uniforms.begin(); i!=other.uniforms.end(); ++i)
+			validate_tag(i->tag);
 	}
 
 	uniforms = other.uniforms;
-	for(vector<NamedUniform>::iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
+	for(vector<TaggedUniform>::iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
 		i->value = i->value->clone();
 }
 
@@ -58,7 +58,7 @@ ProgramData &ProgramData::operator=(const ProgramData &other)
 	tied_program = other.tied_program;
 
 	uniforms = other.uniforms;
-	for(vector<NamedUniform>::iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
+	for(vector<TaggedUniform>::iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
 		i->value = i->value->clone();
 
 	for(BlockMap::iterator i=blocks.begin(); i!=blocks.end(); ++i)
@@ -74,7 +74,7 @@ ProgramData &ProgramData::operator=(const ProgramData &other)
 
 ProgramData::~ProgramData()
 {
-	for(vector<NamedUniform>::iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
+	for(vector<TaggedUniform>::iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
 		delete i->value;
 	for(BlockMap::iterator i=blocks.begin(); i!=blocks.end(); ++i)
 	{
@@ -85,11 +85,11 @@ ProgramData::~ProgramData()
 	delete buffer;
 }
 
-void ProgramData::uniform(const string &name, Uniform *uni)
+void ProgramData::uniform(Tag tag, Uniform *uni)
 {
 	try
 	{
-		if(!validate_name(name))
+		if(!validate_tag(tag))
 		{
 			delete uni;
 			return;
@@ -101,23 +101,23 @@ void ProgramData::uniform(const string &name, Uniform *uni)
 		throw;
 	}
 
-	int i = find_uniform_index(name);
+	int i = find_uniform_index(tag);
 	if(i<0)
-		return add_uniform(name, uni);
+		return add_uniform(tag, uni);
 
 	uniforms[i].replace_value(uni);
 	dirty |= 1<<i;
 }
 
 template<typename T, typename V>
-void ProgramData::uniform(const string &name, V value)
+void ProgramData::uniform(Tag tag, V value)
 {
-	if(!validate_name(name))
+	if(!validate_tag(tag))
 		return;
 
-	int i = find_uniform_index(name);
+	int i = find_uniform_index(tag);
 	if(i<0)
-		return add_uniform(name, new T(value));
+		return add_uniform(tag, new T(value));
 
 	if(T *uni = dynamic_cast<T *>(uniforms[i].value))
 		uni->set(value);
@@ -128,14 +128,14 @@ void ProgramData::uniform(const string &name, V value)
 }
 
 template<typename T, typename V>
-void ProgramData::uniform_array(const string &name, unsigned n, V value)
+void ProgramData::uniform_array(Tag tag, unsigned n, V value)
 {
-	if(!validate_name(name))
+	if(!validate_tag(tag))
 		return;
 
-	int i = find_uniform_index(name);
+	int i = find_uniform_index(tag);
 	if(i<0)
-		return add_uniform(name, new UniformArray<T>(n, value));
+		return add_uniform(tag, new UniformArray<T>(n, value));
 
 	UniformArray<T> *uni = dynamic_cast<UniformArray<T> *>(uniforms[i].value);
 	if(uni && n==uni->size())
@@ -146,320 +146,318 @@ void ProgramData::uniform_array(const string &name, unsigned n, V value)
 	dirty |= 1<<i;
 }
 
-bool ProgramData::validate_name(const string &name) const
+bool ProgramData::validate_tag(Tag tag) const
 {
 #ifdef DEBUG
 	try
 #endif
 	{
 		if(tied_program)
-			tied_program->get_uniform_info(name);
-		else if(name[name.size()-1]==']')
-			throw invalid_argument("ProgramData::uniform");
+			tied_program->get_uniform_info(tag);
 		return true;
 	}
 #ifdef DEBUG
 	catch(const exception &e)
 	{
-		IO::print(IO::cerr, "Error while setting uniform %s: %s: %s\n", name, Debug::demangle(typeid(e).name()), e.what());
+		IO::print(IO::cerr, "Error while setting uniform %s: %s: %s\n", tag, Debug::demangle(typeid(e).name()), e.what());
 		return false;
 	}
 #endif
 }
 
-void ProgramData::add_uniform(const string &name, Uniform *uni)
+void ProgramData::add_uniform(Tag tag, Uniform *uni)
 {
 	if(uniforms.size()>=MASK_BITS)
 	{
 		delete uni;
-		throw too_many_uniforms(name);
+		throw too_many_uniforms(tag.str());
 	}
 
-	vector<NamedUniform>::iterator j = lower_bound(uniforms.begin(), uniforms.end(), name, uniform_name_compare);
+	vector<TaggedUniform>::iterator j = lower_bound(uniforms.begin(), uniforms.end(), tag, uniform_tag_compare);
 
-	NamedUniform nu;
-	nu.name = name;
+	TaggedUniform nu;
+	nu.tag = tag;
 	nu.value = uni;
 	uniforms.insert(j, nu);
 
 	dirty = ALL_ONES;
 }
 
-void ProgramData::uniform(const string &name, const Uniform &u)
+void ProgramData::uniform(Tag tag, const Uniform &u)
 {
-	uniform(name, u.clone());
+	uniform(tag, u.clone());
 }
 
-void ProgramData::uniform(const string &name, int v)
+void ProgramData::uniform(Tag tag, int v)
 {
-	uniform<Uniform1i>(name, v);
+	uniform<Uniform1i>(tag, v);
 }
 
-void ProgramData::uniform(const string &name, float v)
+void ProgramData::uniform(Tag tag, float v)
 {
-	uniform<Uniform1f>(name, v);
+	uniform<Uniform1f>(tag, v);
 }
 
-void ProgramData::uniform(const string &name, int v0, int v1)
+void ProgramData::uniform(Tag tag, int v0, int v1)
 {
 	int va[2] = { v0, v1 };
-	uniform2(name, va);
+	uniform2(tag, va);
 }
 
-void ProgramData::uniform(const string &name, float v0, float v1)
+void ProgramData::uniform(Tag tag, float v0, float v1)
 {
 	float va[2] = { v0, v1 };
-	uniform2(name, va);
+	uniform2(tag, va);
 }
 
-void ProgramData::uniform2(const string &name, const int *v)
+void ProgramData::uniform2(Tag tag, const int *v)
 {
-	uniform<Uniform2i>(name, v);
+	uniform<Uniform2i>(tag, v);
 }
 
-void ProgramData::uniform2(const string &name, const float *v)
+void ProgramData::uniform2(Tag tag, const float *v)
 {
-	uniform<Uniform2f>(name, v);
+	uniform<Uniform2f>(tag, v);
 }
 
-void ProgramData::uniform(const string &name, int v0, int v1, int v2)
+void ProgramData::uniform(Tag tag, int v0, int v1, int v2)
 {
 	int va[3] = { v0, v1, v2 };
-	uniform3(name, va);
+	uniform3(tag, va);
 }
 
-void ProgramData::uniform(const string &name, float v0, float v1, float v2)
+void ProgramData::uniform(Tag tag, float v0, float v1, float v2)
 {
 	float va[3] = { v0, v1, v2 };
-	uniform3(name, va);
+	uniform3(tag, va);
 }
 
-void ProgramData::uniform(const string &name, const Vector3 &v)
+void ProgramData::uniform(Tag tag, const Vector3 &v)
 {
-	uniform(name, v.x, v.y, v.z);
+	uniform(tag, v.x, v.y, v.z);
 }
 
-void ProgramData::uniform3(const string &name, const int *v)
+void ProgramData::uniform3(Tag tag, const int *v)
 {
-	uniform<Uniform3i>(name, v);
+	uniform<Uniform3i>(tag, v);
 }
 
-void ProgramData::uniform3(const string &name, const float *v)
+void ProgramData::uniform3(Tag tag, const float *v)
 {
-	uniform<Uniform3f>(name, v);
+	uniform<Uniform3f>(tag, v);
 }
 
-void ProgramData::uniform(const string &name, int v0, int v1, int v2, int v3)
+void ProgramData::uniform(Tag tag, int v0, int v1, int v2, int v3)
 {
 	int va[4] = { v0, v1, v2, v3 };
-	uniform4(name, va);
+	uniform4(tag, va);
 }
 
-void ProgramData::uniform(const string &name, float v0, float v1, float v2, float v3)
+void ProgramData::uniform(Tag tag, float v0, float v1, float v2, float v3)
 {
 	float va[4] = { v0, v1, v2, v3 };
-	uniform4(name, va);
+	uniform4(tag, va);
 }
 
-void ProgramData::uniform(const string &name, const Vector4 &v)
+void ProgramData::uniform(Tag tag, const Vector4 &v)
 {
-	uniform(name, v.x, v.y, v.z, v.w);
+	uniform(tag, v.x, v.y, v.z, v.w);
 }
 
-void ProgramData::uniform(const string &name, const Color &c)
+void ProgramData::uniform(Tag tag, const Color &c)
 {
-	uniform(name, c.r, c.g, c.b, c.a);
+	uniform(tag, c.r, c.g, c.b, c.a);
 }
 
-void ProgramData::uniform4(const string &name, const int *v)
+void ProgramData::uniform4(Tag tag, const int *v)
 {
-	uniform<Uniform4i>(name, v);
+	uniform<Uniform4i>(tag, v);
 }
 
-void ProgramData::uniform4(const string &name, const float *v)
+void ProgramData::uniform4(Tag tag, const float *v)
 {
-	uniform<Uniform4f>(name, v);
+	uniform<Uniform4f>(tag, v);
 }
 
-void ProgramData::uniform(const string &name, const LinAl::Matrix<float, 2, 2> &m)
+void ProgramData::uniform(Tag tag, const LinAl::Matrix<float, 2, 2> &m)
 {
-	uniform_matrix2(name, &m(0, 0));
+	uniform_matrix2(tag, &m(0, 0));
 }
 
-void ProgramData::uniform_matrix2(const string &name, const float *v)
+void ProgramData::uniform_matrix2(Tag tag, const float *v)
 {
-	uniform<UniformMatrix2x2f>(name, v);
+	uniform<UniformMatrix2x2f>(tag, v);
 }
 
-void ProgramData::uniform(const string &name, const LinAl::Matrix<float, 2, 3> &m)
+void ProgramData::uniform(Tag tag, const LinAl::Matrix<float, 2, 3> &m)
 {
-	uniform_matrix3x2(name, &m(0, 0));
+	uniform_matrix3x2(tag, &m(0, 0));
 }
 
-void ProgramData::uniform_matrix3x2(const string &name, const float *v)
+void ProgramData::uniform_matrix3x2(Tag tag, const float *v)
 {
-	uniform<UniformMatrix3x2f>(name, v);
+	uniform<UniformMatrix3x2f>(tag, v);
 }
 
-void ProgramData::uniform(const string &name, const LinAl::Matrix<float, 2, 4> &m)
+void ProgramData::uniform(Tag tag, const LinAl::Matrix<float, 2, 4> &m)
 {
-	uniform_matrix4x2(name, &m(0, 0));
+	uniform_matrix4x2(tag, &m(0, 0));
 }
 
-void ProgramData::uniform_matrix4x2(const string &name, const float *v)
+void ProgramData::uniform_matrix4x2(Tag tag, const float *v)
 {
-	uniform<UniformMatrix4x2f>(name, v);
+	uniform<UniformMatrix4x2f>(tag, v);
 }
 
-void ProgramData::uniform(const string &name, const LinAl::Matrix<float, 3, 2> &m)
+void ProgramData::uniform(Tag tag, const LinAl::Matrix<float, 3, 2> &m)
 {
-	uniform_matrix2x3(name, &m(0, 0));
+	uniform_matrix2x3(tag, &m(0, 0));
 }
 
-void ProgramData::uniform_matrix2x3(const string &name, const float *v)
+void ProgramData::uniform_matrix2x3(Tag tag, const float *v)
 {
-	uniform<UniformMatrix2x3f>(name, v);
+	uniform<UniformMatrix2x3f>(tag, v);
 }
 
-void ProgramData::uniform(const string &name, const LinAl::Matrix<float, 3, 3> &m)
+void ProgramData::uniform(Tag tag, const LinAl::Matrix<float, 3, 3> &m)
 {
-	uniform_matrix3(name, &m(0, 0));
+	uniform_matrix3(tag, &m(0, 0));
 }
 
-void ProgramData::uniform_matrix3(const string &name, const float *v)
+void ProgramData::uniform_matrix3(Tag tag, const float *v)
 {
-	uniform<UniformMatrix3x3f>(name, v);
+	uniform<UniformMatrix3x3f>(tag, v);
 }
 
-void ProgramData::uniform(const string &name, const LinAl::Matrix<float, 3, 4> &m)
+void ProgramData::uniform(Tag tag, const LinAl::Matrix<float, 3, 4> &m)
 {
-	uniform_matrix4x3(name, &m(0, 0));
+	uniform_matrix4x3(tag, &m(0, 0));
 }
 
-void ProgramData::uniform_matrix4x3(const string &name, const float *v)
+void ProgramData::uniform_matrix4x3(Tag tag, const float *v)
 {
-	uniform<UniformMatrix4x3f>(name, v);
+	uniform<UniformMatrix4x3f>(tag, v);
 }
 
-void ProgramData::uniform(const string &name, const LinAl::Matrix<float, 4, 2> &m)
+void ProgramData::uniform(Tag tag, const LinAl::Matrix<float, 4, 2> &m)
 {
-	uniform_matrix2x4(name, &m(0, 0));
+	uniform_matrix2x4(tag, &m(0, 0));
 }
 
-void ProgramData::uniform_matrix2x4(const string &name, const float *v)
+void ProgramData::uniform_matrix2x4(Tag tag, const float *v)
 {
-	uniform<UniformMatrix2x4f>(name, v);
+	uniform<UniformMatrix2x4f>(tag, v);
 }
 
-void ProgramData::uniform(const string &name, const LinAl::Matrix<float, 4, 3> &m)
+void ProgramData::uniform(Tag tag, const LinAl::Matrix<float, 4, 3> &m)
 {
-	uniform_matrix3x4(name, &m(0, 0));
+	uniform_matrix3x4(tag, &m(0, 0));
 }
 
-void ProgramData::uniform_matrix3x4(const string &name, const float *v)
+void ProgramData::uniform_matrix3x4(Tag tag, const float *v)
 {
-	uniform<UniformMatrix3x4f>(name, v);
+	uniform<UniformMatrix3x4f>(tag, v);
 }
 
-void ProgramData::uniform(const string &name, const Matrix &m)
+void ProgramData::uniform(Tag tag, const Matrix &m)
 {
-	uniform_matrix4(name, m.data());
+	uniform_matrix4(tag, m.data());
 }
 
-void ProgramData::uniform_matrix4(const string &name, const float *v)
+void ProgramData::uniform_matrix4(Tag tag, const float *v)
 {
-	uniform<UniformMatrix4x4f>(name, v);
+	uniform<UniformMatrix4x4f>(tag, v);
 }
 
-void ProgramData::uniform1_array(const string &name, unsigned n, const int *v)
+void ProgramData::uniform1_array(Tag tag, unsigned n, const int *v)
 {
-	uniform_array<Uniform1i>(name, n, v);
+	uniform_array<Uniform1i>(tag, n, v);
 }
 
-void ProgramData::uniform1_array(const string &name, unsigned n, const float *v)
+void ProgramData::uniform1_array(Tag tag, unsigned n, const float *v)
 {
-	uniform_array<Uniform1f>(name, n, v);
+	uniform_array<Uniform1f>(tag, n, v);
 }
 
-void ProgramData::uniform2_array(const string &name, unsigned n, const int *v)
+void ProgramData::uniform2_array(Tag tag, unsigned n, const int *v)
 {
-	uniform_array<Uniform2i>(name, n, v);
+	uniform_array<Uniform2i>(tag, n, v);
 }
 
-void ProgramData::uniform2_array(const string &name, unsigned n, const float *v)
+void ProgramData::uniform2_array(Tag tag, unsigned n, const float *v)
 {
-	uniform_array<Uniform2f>(name, n, v);
+	uniform_array<Uniform2f>(tag, n, v);
 }
 
-void ProgramData::uniform3_array(const string &name, unsigned n, const int *v)
+void ProgramData::uniform3_array(Tag tag, unsigned n, const int *v)
 {
-	uniform_array<Uniform3i>(name, n, v);
+	uniform_array<Uniform3i>(tag, n, v);
 }
 
-void ProgramData::uniform3_array(const string &name, unsigned n, const float *v)
+void ProgramData::uniform3_array(Tag tag, unsigned n, const float *v)
 {
-	uniform_array<Uniform3f>(name, n, v);
+	uniform_array<Uniform3f>(tag, n, v);
 }
 
-void ProgramData::uniform4_array(const string &name, unsigned n, const int *v)
+void ProgramData::uniform4_array(Tag tag, unsigned n, const int *v)
 {
-	uniform_array<Uniform4i>(name, n, v);
+	uniform_array<Uniform4i>(tag, n, v);
 }
 
-void ProgramData::uniform4_array(const string &name, unsigned n, const float *v)
+void ProgramData::uniform4_array(Tag tag, unsigned n, const float *v)
 {
-	uniform_array<Uniform4f>(name, n, v);
+	uniform_array<Uniform4f>(tag, n, v);
 }
 
-void ProgramData::uniform_matrix2_array(const string &name, unsigned n, const float *v)
+void ProgramData::uniform_matrix2_array(Tag tag, unsigned n, const float *v)
 {
-	uniform_array<UniformMatrix2x2f>(name, n, v);
+	uniform_array<UniformMatrix2x2f>(tag, n, v);
 }
 
-void ProgramData::uniform_matrix3x2_array(const string &name, unsigned n, const float *v)
+void ProgramData::uniform_matrix3x2_array(Tag tag, unsigned n, const float *v)
 {
-	uniform_array<UniformMatrix3x2f>(name, n, v);
+	uniform_array<UniformMatrix3x2f>(tag, n, v);
 }
 
-void ProgramData::uniform_matrix4x2_array(const string &name, unsigned n, const float *v)
+void ProgramData::uniform_matrix4x2_array(Tag tag, unsigned n, const float *v)
 {
-	uniform_array<UniformMatrix4x2f>(name, n, v);
+	uniform_array<UniformMatrix4x2f>(tag, n, v);
 }
 
-void ProgramData::uniform_matrix2x3_array(const string &name, unsigned n, const float *v)
+void ProgramData::uniform_matrix2x3_array(Tag tag, unsigned n, const float *v)
 {
-	uniform_array<UniformMatrix2x3f>(name, n, v);
+	uniform_array<UniformMatrix2x3f>(tag, n, v);
 }
 
-void ProgramData::uniform_matrix3_array(const string &name, unsigned n, const float *v)
+void ProgramData::uniform_matrix3_array(Tag tag, unsigned n, const float *v)
 {
-	uniform_array<UniformMatrix3x3f>(name, n, v);
+	uniform_array<UniformMatrix3x3f>(tag, n, v);
 }
 
-void ProgramData::uniform_matrix4x3_array(const string &name, unsigned n, const float *v)
+void ProgramData::uniform_matrix4x3_array(Tag tag, unsigned n, const float *v)
 {
-	uniform_array<UniformMatrix4x3f>(name, n, v);
+	uniform_array<UniformMatrix4x3f>(tag, n, v);
 }
 
-void ProgramData::uniform_matrix2x4_array(const string &name, unsigned n, const float *v)
+void ProgramData::uniform_matrix2x4_array(Tag tag, unsigned n, const float *v)
 {
-	uniform_array<UniformMatrix2x4f>(name, n, v);
+	uniform_array<UniformMatrix2x4f>(tag, n, v);
 }
 
-void ProgramData::uniform_matrix3x4_array(const string &name, unsigned n, const float *v)
+void ProgramData::uniform_matrix3x4_array(Tag tag, unsigned n, const float *v)
 {
-	uniform_array<UniformMatrix3x4f>(name, n, v);
+	uniform_array<UniformMatrix3x4f>(tag, n, v);
 }
 
-void ProgramData::uniform_matrix4_array(const string &name, unsigned n, const float *v)
+void ProgramData::uniform_matrix4_array(Tag tag, unsigned n, const float *v)
 {
-	uniform_array<UniformMatrix4x4f>(name, n, v);
+	uniform_array<UniformMatrix4x4f>(tag, n, v);
 }
 
-void ProgramData::remove_uniform(const string &name)
+void ProgramData::remove_uniform(Tag tag)
 {
-	vector<NamedUniform>::const_iterator i = lower_bound(uniforms.begin(), uniforms.end(), name, uniform_name_compare);
-	if(i==uniforms.end() || i->name!=name)
+	vector<TaggedUniform>::const_iterator i = lower_bound(uniforms.begin(), uniforms.end(), tag, uniform_tag_compare);
+	if(i==uniforms.end() || i->tag!=tag)
 		return;
 
 	delete i->value;
@@ -468,38 +466,38 @@ void ProgramData::remove_uniform(const string &name)
 	dirty = ALL_ONES;
 }
 
-vector<string> ProgramData::get_uniform_names() const
+vector<Tag> ProgramData::get_uniform_tags() const
 {
-	vector<string> names;
-	names.reserve(uniforms.size());
-	for(vector<NamedUniform>::const_iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
-		names.push_back(i->name);
-	return names;
+	vector<Tag> tags;
+	tags.reserve(uniforms.size());
+	for(vector<TaggedUniform>::const_iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
+		tags.push_back(i->tag);
+	return tags;
 }
 
-const Uniform &ProgramData::get_uniform(const string &name) const
+const Uniform &ProgramData::get_uniform(Tag tag) const
 {
-	int i = find_uniform_index(name);
+	int i = find_uniform_index(tag);
 	if(i<0)
-		throw key_error(name);
+		throw key_error(tag);
 	return *uniforms[i].value;
 }
 
-const Uniform *ProgramData::find_uniform(const string &name) const
+const Uniform *ProgramData::find_uniform(Tag tag) const
 {
-	int i = find_uniform_index(name);
+	int i = find_uniform_index(tag);
 	return (i>=0 ? uniforms[i].value : 0);
 }
 
-bool ProgramData::uniform_name_compare(const NamedUniform &nu, const string &name)
+bool ProgramData::uniform_tag_compare(const TaggedUniform &tu, Tag tag)
 {
-	return nu.name<name;
+	return tu.tag<tag;
 }
 
-int ProgramData::find_uniform_index(const string &name) const
+int ProgramData::find_uniform_index(Tag tag) const
 {
-	vector<NamedUniform>::const_iterator i = lower_bound(uniforms.begin(), uniforms.end(), name, uniform_name_compare);
-	return ((i!=uniforms.end() && i->name==name) ? i-uniforms.begin() : -1);
+	vector<TaggedUniform>::const_iterator i = lower_bound(uniforms.begin(), uniforms.end(), tag, uniform_tag_compare);
+	return ((i!=uniforms.end() && i->tag==tag) ? i-uniforms.begin() : -1);
 }
 
 void ProgramData::update_block_uniform_indices(SharedBlock &block, const Program::UniformBlockInfo &info) const
@@ -518,7 +516,7 @@ void ProgramData::update_block_uniform_indices(SharedBlock &block, const Program
 	block.used = 0;
 	for(unsigned i=0; i<info.uniforms.size(); ++i)
 	{
-		int j = find_uniform_index(info.uniforms[i]->name);
+		int j = find_uniform_index(info.uniforms[i]->tag);
 		if(j>=0)
 		{
 			indices[i] = j;
@@ -679,11 +677,11 @@ void ProgramData::apply() const
 }
 
 
-ProgramData::NamedUniform::NamedUniform():
+ProgramData::TaggedUniform::TaggedUniform():
 	value(0)
 { }
 
-void ProgramData::NamedUniform::replace_value(Uniform *v)
+void ProgramData::TaggedUniform::replace_value(Uniform *v)
 {
 	/* UniformBlock does not copy the uniforms, so existing default blocks
 	will be left with stale pointers.  This is not a problem as long as no
diff --git a/source/render/programdata.h b/source/render/programdata.h
index c772272e..0ed16d6f 100644
--- a/source/render/programdata.h
+++ b/source/render/programdata.h
@@ -7,6 +7,7 @@
 #include "datatype.h"
 #include "matrix.h"
 #include "program.h"
+#include "tag.h"
 #include "vector.h"
 
 namespace Msp {
@@ -97,14 +98,13 @@ private:
 		ALL_ONES = static_cast<Mask>(-1)
 	};
 
-	struct NamedUniform
+	struct TaggedUniform
 	{
-		std::string name;
+		Tag tag;
 		Uniform *value;
 
-		NamedUniform();
+		TaggedUniform();
 
-		bool compare_name(const std::string &, unsigned) const;
 		void replace_value(Uniform *);
 	};
 
@@ -153,7 +153,7 @@ private:
 
 	// XXX All these mutables are a bit silly, but I'm out of better ideas
 	const Program *tied_program;
-	std::vector<NamedUniform> uniforms;
+	std::vector<TaggedUniform> uniforms;
 	mutable BlockMap blocks;
 	mutable ProgramMap programs;
 	mutable UniformBlock *last_block;
@@ -168,76 +168,76 @@ public:
 	~ProgramData();
 
 private:
-	void uniform(const std::string &, Uniform *);
+	void uniform(Tag, Uniform *);
 	template<typename T, typename V>
-	void uniform(const std::string &, V);
+	void uniform(Tag, V);
 	template<typename T, typename V>
-	void uniform_array(const std::string &, unsigned, V);
-	bool validate_name(const std::string &) const;
-	void add_uniform(const std::string &, Uniform *);
+	void uniform_array(Tag, unsigned, V);
+	bool validate_tag(Tag) const;
+	void add_uniform(Tag, Uniform *);
 public:
-	void uniform(const std::string &, const Uniform &);
-	void uniform(const std::string &, int);
-	void uniform(const std::string &, float);
-	void uniform(const std::string &, int, int);
-	void uniform(const std::string &, float, float);
-	void uniform2(const std::string &, const int *);
-	void uniform2(const std::string &, const float *);
-	void uniform(const std::string &, int, int, int);
-	void uniform(const std::string &, float, float, float);
-	void uniform(const std::string &, const Vector3 &);
-	void uniform3(const std::string &, const int *);
-	void uniform3(const std::string &, const float *);
-	void uniform(const std::string &, int, int, int, int);
-	void uniform(const std::string &, float, float, float, float);
-	void uniform(const std::string &, const Vector4 &);
-	void uniform(const std::string &, const Color &);
-	void uniform4(const std::string &, const int *);
-	void uniform4(const std::string &, const float *);
-	void uniform(const std::string &, const LinAl::Matrix<float, 2, 2> &);
-	void uniform_matrix2(const std::string &, const float *);
-	void uniform(const std::string &, const LinAl::Matrix<float, 2, 3> &);
-	void uniform_matrix3x2(const std::string &, const float *);
-	void uniform(const std::string &, const LinAl::Matrix<float, 2, 4> &);
-	void uniform_matrix4x2(const std::string &, const float *);
-	void uniform(const std::string &, const LinAl::Matrix<float, 3, 2> &);
-	void uniform_matrix2x3(const std::string &, const float *);
-	void uniform(const std::string &, const LinAl::Matrix<float, 3, 3> &);
-	void uniform_matrix3(const std::string &, const float *);
-	void uniform(const std::string &, const LinAl::Matrix<float, 3, 4> &);
-	void uniform_matrix4x3(const std::string &, const float *);
-	void uniform(const std::string &, const LinAl::Matrix<float, 4, 2> &);
-	void uniform_matrix2x4(const std::string &, const float *);
-	void uniform(const std::string &, const LinAl::Matrix<float, 4, 3> &);
-	void uniform_matrix3x4(const std::string &, const float *);
-	void uniform(const std::string &, const Matrix &);
-	void uniform_matrix4(const std::string &, const float *);
-	void uniform1_array(const std::string &, unsigned, const int *);
-	void uniform1_array(const std::string &, unsigned, const float *);
-	void uniform2_array(const std::string &, unsigned, const int *);
-	void uniform2_array(const std::string &, unsigned, const float *);
-	void uniform3_array(const std::string &, unsigned, const int *);
-	void uniform3_array(const std::string &, unsigned, const float *);
-	void uniform4_array(const std::string &, unsigned, const int *);
-	void uniform4_array(const std::string &, unsigned, const float *);
-	void uniform_matrix2_array(const std::string &, unsigned, const float *);
-	void uniform_matrix3x2_array(const std::string &, unsigned, const float *);
-	void uniform_matrix4x2_array(const std::string &, unsigned, const float *);
-	void uniform_matrix2x3_array(const std::string &, unsigned, const float *);
-	void uniform_matrix3_array(const std::string &, unsigned, const float *);
-	void uniform_matrix4x3_array(const std::string &, unsigned, const float *);
-	void uniform_matrix2x4_array(const std::string &, unsigned, const float *);
-	void uniform_matrix3x4_array(const std::string &, unsigned, const float *);
-	void uniform_matrix4_array(const std::string &, unsigned, const float *);
-	void remove_uniform(const std::string &);
-
-	std::vector<std::string> get_uniform_names() const;
-	const Uniform &get_uniform(const std::string &) const;
-	const Uniform *find_uniform(const std::string &) const;
+	void uniform(Tag, const Uniform &);
+	void uniform(Tag, int);
+	void uniform(Tag, float);
+	void uniform(Tag, int, int);
+	void uniform(Tag, float, float);
+	void uniform2(Tag, const int *);
+	void uniform2(Tag, const float *);
+	void uniform(Tag, int, int, int);
+	void uniform(Tag, float, float, float);
+	void uniform(Tag, const Vector3 &);
+	void uniform3(Tag, const int *);
+	void uniform3(Tag, const float *);
+	void uniform(Tag, int, int, int, int);
+	void uniform(Tag, float, float, float, float);
+	void uniform(Tag, const Vector4 &);
+	void uniform(Tag, const Color &);
+	void uniform4(Tag, const int *);
+	void uniform4(Tag, const float *);
+	void uniform(Tag, const LinAl::Matrix<float, 2, 2> &);
+	void uniform_matrix2(Tag, const float *);
+	void uniform(Tag, const LinAl::Matrix<float, 2, 3> &);
+	void uniform_matrix3x2(Tag, const float *);
+	void uniform(Tag, const LinAl::Matrix<float, 2, 4> &);
+	void uniform_matrix4x2(Tag, const float *);
+	void uniform(Tag, const LinAl::Matrix<float, 3, 2> &);
+	void uniform_matrix2x3(Tag, const float *);
+	void uniform(Tag, const LinAl::Matrix<float, 3, 3> &);
+	void uniform_matrix3(Tag, const float *);
+	void uniform(Tag, const LinAl::Matrix<float, 3, 4> &);
+	void uniform_matrix4x3(Tag, const float *);
+	void uniform(Tag, const LinAl::Matrix<float, 4, 2> &);
+	void uniform_matrix2x4(Tag, const float *);
+	void uniform(Tag, const LinAl::Matrix<float, 4, 3> &);
+	void uniform_matrix3x4(Tag, const float *);
+	void uniform(Tag, const Matrix &);
+	void uniform_matrix4(Tag, const float *);
+	void uniform1_array(Tag, unsigned, const int *);
+	void uniform1_array(Tag, unsigned, const float *);
+	void uniform2_array(Tag, unsigned, const int *);
+	void uniform2_array(Tag, unsigned, const float *);
+	void uniform3_array(Tag, unsigned, const int *);
+	void uniform3_array(Tag, unsigned, const float *);
+	void uniform4_array(Tag, unsigned, const int *);
+	void uniform4_array(Tag, unsigned, const float *);
+	void uniform_matrix2_array(Tag, unsigned, const float *);
+	void uniform_matrix3x2_array(Tag, unsigned, const float *);
+	void uniform_matrix4x2_array(Tag, unsigned, const float *);
+	void uniform_matrix2x3_array(Tag, unsigned, const float *);
+	void uniform_matrix3_array(Tag, unsigned, const float *);
+	void uniform_matrix4x3_array(Tag, unsigned, const float *);
+	void uniform_matrix2x4_array(Tag, unsigned, const float *);
+	void uniform_matrix3x4_array(Tag, unsigned, const float *);
+	void uniform_matrix4_array(Tag, unsigned, const float *);
+	void remove_uniform(Tag);
+
+	std::vector<Tag> get_uniform_tags() const;
+	const Uniform &get_uniform(Tag) const;
+	const Uniform *find_uniform(Tag) const;
 
 private:
-	static bool uniform_name_compare(const NamedUniform &, const std::string &);
-	int find_uniform_index(const std::string &) const;
+	static bool uniform_tag_compare(const TaggedUniform &, Tag);
+	int find_uniform_index(Tag) const;
 	void update_block_uniform_indices(SharedBlock &, const Program::UniformBlockInfo &) const;
 	void update_block(SharedBlock &, const Program::UniformBlockInfo &) const;
 	SharedBlock *get_shared_block(const Program::UniformBlockInfo &) const;
diff --git a/source/render/text.cpp b/source/render/text.cpp
index 210411a5..3b2380c4 100644
--- a/source/render/text.cpp
+++ b/source/render/text.cpp
@@ -28,13 +28,13 @@ void Text::set_technique(const Technique *tech, const string &ts)
 		if(!*tex_slot && tech->has_pass(Tag()))
 			if(const Program *shprog = tech->get_pass(Tag()).get_shader_program())
 			{
-				if(shprog->get_uniform_location("font_tex")>=0)
+				if(shprog->get_uniform_location(Tag("font_tex"))>=0)
 					tex_slot = "font_tex";
-				else if(shprog->get_uniform_location("color_tex")>=0)
+				else if(shprog->get_uniform_location(Tag("color_tex"))>=0)
 					tex_slot = "color_tex";
-				else if(shprog->get_uniform_location("diffuse_map")>=0)
+				else if(shprog->get_uniform_location(Tag("diffuse_map"))>=0)
 					tex_slot = "diffuse_map";
-				else if(shprog->get_uniform_location("base_color_map")>=0)
+				else if(shprog->get_uniform_location(Tag("base_color_map"))>=0)
 					tex_slot = "base_color_map";
 			}
 
-- 
2.43.0