X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fprogramdata.cpp;h=d0de3c05565d182663e099f2fde904afa32ed4b8;hb=9afdf8a0813de5c4d5277b0ccbfe86051af5624e;hp=f75a4ebda945cbadd62de17f2c6c214eca121d0c;hpb=30b779a9542b8e8ae5d23758c8b6da24d22c7fd7;p=libs%2Fgl.git

diff --git a/source/programdata.cpp b/source/programdata.cpp
index f75a4ebd..d0de3c05 100644
--- a/source/programdata.cpp
+++ b/source/programdata.cpp
@@ -366,11 +366,22 @@ ProgramData::ProgramUniforms::ProgramUniforms():
 ProgramData::Loader::Loader(ProgramData &pd):
 	DataFile::ObjectLoader<ProgramData>(pd)
 {
+	add("uniform", &Loader::uniform1i);
 	add("uniform1i", &Loader::uniform1i);
+	add("uniform", &Loader::uniform1f);
 	add("uniform1f", &Loader::uniform1f);
+	add("uniform", &Loader::uniform2f);
 	add("uniform2f", &Loader::uniform2f);
+	add("uniform", &Loader::uniform3f);
 	add("uniform3f", &Loader::uniform3f);
+	add("uniform", &Loader::uniform4f);
 	add("uniform4f", &Loader::uniform4f);
+	add("uniform1i_array", &Loader::uniform1i_array);
+	add("uniform1f_array", &Loader::uniform1f_array);
+	add("uniform2f_array", &Loader::uniform2f_array);
+	add("uniform3f_array", &Loader::uniform3f_array);
+	add("uniform4f_array", &Loader::uniform4f_array);
+	add("uniform_array", &Loader::uniform_array);
 }
 
 void ProgramData::Loader::uniform1i(const string &n, int v)
@@ -398,5 +409,131 @@ void ProgramData::Loader::uniform4f(const string &n, float v0, float v1, float v
 	obj.uniform(n, v0, v1, v2, v3);
 }
 
+void ProgramData::Loader::uniform_array_(const string &n, DataType t, unsigned e)
+{
+	ArrayLoader ldr(t, e);
+	load_sub_with(ldr);
+	unsigned size = ldr.get_size();
+	if(!size)
+		throw logic_error("empty uniform array");
+
+	DataType type = ldr.get_data_type();
+	unsigned elem_size = ldr.get_element_size();
+	if(type==INT)
+	{
+		const int *data = reinterpret_cast<const int *>(ldr.get_data());
+		if(elem_size==1)
+			obj.uniform1_array(n, size, data);
+		else
+			throw logic_error("unsupported combination of array type and element size");
+	}
+	else if(type==FLOAT)
+	{
+		const float *data = reinterpret_cast<const float *>(ldr.get_data());
+		if(elem_size==1)
+			obj.uniform1_array(n, size, data);
+		else if(elem_size==2)
+			obj.uniform2_array(n, size, data);
+		else if(elem_size==3)
+			obj.uniform3_array(n, size, data);
+		else if(elem_size==4)
+			obj.uniform4_array(n, size, data);
+		else
+			throw logic_error("unsupported combination of array type and element size");
+	}
+	else
+		throw logic_error("unsupported array type");
+}
+
+void ProgramData::Loader::uniform1i_array(const string &n)
+{
+	uniform_array_(n, INT, 1);
+}
+
+void ProgramData::Loader::uniform1f_array(const string &n)
+{
+	uniform_array_(n, FLOAT, 1);
+}
+
+void ProgramData::Loader::uniform2f_array(const string &n)
+{
+	uniform_array_(n, FLOAT, 2);
+}
+
+void ProgramData::Loader::uniform3f_array(const string &n)
+{
+	uniform_array_(n, FLOAT, 3);
+}
+
+void ProgramData::Loader::uniform4f_array(const string &n)
+{
+	uniform_array_(n, FLOAT, 4);
+}
+
+void ProgramData::Loader::uniform_array(const string &n)
+{
+	uniform_array_(n, static_cast<DataType>(0), 0);
+}
+
+
+ProgramData::ArrayLoader::ArrayLoader(DataType t, unsigned e):
+	type(t),
+	element_size(e)
+{
+	add("uniform", &ArrayLoader::uniform1i);
+	add("uniform1i", &ArrayLoader::uniform1i);
+	add("uniform", &ArrayLoader::uniform1f);
+	add("uniform1f", &ArrayLoader::uniform1f);
+	add("uniform", &ArrayLoader::uniform2f);
+	add("uniform2f", &ArrayLoader::uniform2f);
+	add("uniform", &ArrayLoader::uniform3f);
+	add("uniform3f", &ArrayLoader::uniform3f);
+	add("uniform", &ArrayLoader::uniform4f);
+	add("uniform4f", &ArrayLoader::uniform4f);
+}
+
+void ProgramData::ArrayLoader::uniform(DataType t, unsigned e, const void *v)
+{
+	if(element_size && (t!=type || e!=element_size))
+		throw logic_error("heterogeneous array contents");
+
+	if(!element_size)
+	{
+		type = t;
+		element_size = e;
+	}
+
+	const char *cv = reinterpret_cast<const char *>(v);
+	data.insert(data.end(), cv, cv+element_size*4);
+}
+
+void ProgramData::ArrayLoader::uniform1i(int v)
+{
+	uniform(INT, 1, &v);
+}
+
+void ProgramData::ArrayLoader::uniform1f(float v)
+{
+	uniform(FLOAT, 1, &v);
+}
+
+void ProgramData::ArrayLoader::uniform2f(float v0, float v1)
+{
+	float va[2] = { v0, v1 };
+	uniform(FLOAT, 2, va);
+}
+
+void ProgramData::ArrayLoader::uniform3f(float v0, float v1, float v2)
+{
+	float va[3] = { v0, v1, v2 };
+	uniform(FLOAT, 3, va);
+}
+
+void ProgramData::ArrayLoader::uniform4f(float v0, float v1, float v2, float v3)
+{
+	float va[4] = { v0, v1, v2, v3 };
+	uniform(FLOAT, 4, va);
+}
+
 } // namespace GL
 } // namespace Msp