rays 0.1.27 → 0.1.29

data/src/shader.cpp

@@ -1,6 +1,7 @@
 #include "shader.h"
 
 
+#include <regex>
 #include "rays/exception.h"
 #include "opengl.h"
 #include "image.h"
@@ -12,54 +13,21 @@ namespace Rays
 {
 
 
-	static const ShaderSource&
-	get_vertex_shader_source ()
-	{
-		static const ShaderSource SOURCE(
-			GL_VERTEX_SHADER,
-			"attribute vec3 "  ATTRIB_POSITION ";"
-			"varying   vec4 " VARYING_POSITION ";"
-			"uniform   mat4 " UNIFORM_POSITION_MATRIX ";"
-			"attribute vec3 "  ATTRIB_TEXCOORD ";"
-			"varying   vec4 " VARYING_TEXCOORD ";"
-			"uniform   mat4 " UNIFORM_TEXCOORD_MATRIX ";"
-			"attribute vec4 "  ATTRIB_COLOR ";"
-			"varying   vec4 " VARYING_COLOR ";"
-			"void main ()"
-			"{"
-			"  vec4 pos           = vec4(" ATTRIB_POSITION ", 1.0);"
-			"  vec4 texcoord      = vec4(" ATTRIB_TEXCOORD ", 1.0);"
-			   VARYING_POSITION " = pos;"
-			   VARYING_TEXCOORD " = " UNIFORM_TEXCOORD_MATRIX " * texcoord;"
-			   VARYING_COLOR    " = " ATTRIB_COLOR ";"
-			"  gl_Position        = " UNIFORM_POSITION_MATRIX " * pos;"
-			"}");
-		return SOURCE;
-	}
-
-	static ShaderSource
-	make_fragment_shader_source (const char* source)
-	{
-		static String SHARED_HEADER =
-			"#ifdef GL_ES\n"
-			"precision mediump float;\n"
-			"#endif\n"
-			"uniform sampler2D " UNIFORM_TEXTURE ";"
-			"uniform vec2 "      UNIFORM_TEXTURE_SIZE ";"
-			"uniform vec2 "      UNIFORM_TEXCOORD_MIN ";"
-			"uniform vec2 "      UNIFORM_TEXCOORD_MAX ";"
-			"vec2 normalizeTexCoord(vec2 texcoord)"
-			"{"
-			"  vec2 min = " UNIFORM_TEXCOORD_MIN ";"
-			"  vec2 len = " UNIFORM_TEXCOORD_MAX " - min;"
-			"  return (mod(texcoord - min, len) + min) / " UNIFORM_TEXTURE_SIZE ";"
-			"}"
-			"vec4 sampleTexture(vec2 texcoord)"
-			"{"
-			"  return texture2D(" UNIFORM_TEXTURE ", normalizeTexCoord(texcoord));"
-			"}\n";
-		return ShaderSource(GL_FRAGMENT_SHADER, SHARED_HEADER + source);
-	}
+	#define A_POSITION        (names.attribute_position_names[0])
+	#define A_TEXCOORD        (names.attribute_texcoord_names[0])
+	#define A_COLOR           (names.attribute_color_names[0])
+	#define V_POSITION        (names.varying_position_name)
+	#define V_TEXCOORD        (names.varying_texcoord_name)
+	#define V_COLOR           (names.varying_color_name)
+	#define U_POSITION_MATRIX (names.uniform_position_matrix_names[0])
+	#define U_TEXCOORD_MATRIX (names.uniform_texcoord_matrix_names[0])
+	#define U_TEXCOORD_MIN    (names.uniform_texcoord_min_names[0])
+	#define U_TEXCOORD_MAX    (names.uniform_texcoord_max_names[0])
+	#define U_TEXCOORD_OFFSET (names.uniform_texcoord_offset_names[0])
+	#define U_TEXTURE         (names.uniform_texture_names[0])
+
+
+	static ShaderEnv DEFAULT_ENV;
 
 
 	struct Shader::Data
@@ -67,23 +35,157 @@ namespace Rays
 
 		std::unique_ptr<ShaderProgram> program;
 
+		std::unique_ptr<ShaderEnv> env;
+
+		Data (
+			const char* fragment_shader_source,
+			const char*   vertex_shader_source,
+			ShaderEnv* env_)
+		{
+			if (!fragment_shader_source) return;
+
+			if (env_)
+				this->env.reset(new ShaderEnv(*env_));
+
+			program.reset(new ShaderProgram(
+				make_vertex_shader_source(vertex_shader_source),
+				make_fragment_shader_source(fragment_shader_source),
+				env_ ? ShaderEnv_get_flags(*env_) : 0));
+		}
+
+		ShaderSource make_vertex_shader_source (const char* source)
+		{
+			if (source)
+				return ShaderSource(GL_VERTEX_SHADER, source);
+			else
+			{
+				return ShaderEnv_get_default_vertex_shader_source(
+					env ? env.get() : &DEFAULT_ENV);
+			}
+		}
+
+		ShaderSource make_fragment_shader_source (const char* source)
+		{
+			#ifdef IOS
+				static const String SHARED_HEADER = "precision mediump float;\n";
+				static const std::regex PRECISION(R"(^\s*precision\s+\w+p\s+float\s*;)");
+
+				if (!std::regex_search(source, PRECISION))
+					return ShaderSource(GL_FRAGMENT_SHADER, SHARED_HEADER + source);
+				else
+					return ShaderSource(GL_FRAGMENT_SHADER, source);
+			#else
+				return ShaderSource(GL_FRAGMENT_SHADER, source);
+			#endif
+		}
+
 	};// Shader::Data
 
 
+	static Shader
+	make_default_shader_for_shape ()
+	{
+		const ShaderBuiltinVariableNames& names =
+			ShaderEnv_get_builtin_variable_names(DEFAULT_ENV);
+		return Shader(
+			"varying vec4 " + V_COLOR + ";\n"
+			"void main ()\n"
+			"{\n"
+			"  gl_FragColor = " + V_COLOR + ";\n"
+			"}\n");
+	}
+
+	static Shader
+	make_default_shader_for_texture ()
+	{
+		const ShaderBuiltinVariableNames& names =
+			ShaderEnv_get_builtin_variable_names(DEFAULT_ENV);
+		return Shader(
+			"varying vec4 "      + V_TEXCOORD + ";\n"
+			"varying vec4 "      + V_COLOR + ";\n"
+			"uniform vec3 "      + U_TEXCOORD_MIN + ";\n"
+			"uniform vec3 "      + U_TEXCOORD_MAX + ";\n"
+			"uniform sampler2D " + U_TEXTURE + ";\n"
+			"void main ()\n"
+			"{\n"
+			"  vec2 min__      = " + U_TEXCOORD_MIN + ".xy;\n"
+			"  vec2 len__      = " + U_TEXCOORD_MAX + ".xy - min__;\n"
+			"  vec2 texcoord__ = mod(" + V_TEXCOORD + ".xy - min__, len__) + min__;\n"
+			"  vec4 color__    = texture2D(" + U_TEXTURE + ", texcoord__);\n"
+			"  gl_FragColor    = " + V_COLOR + " * color__;\n"
+			"}\n");
+	}
+
+	static Shader
+	make_shader_for_text ()
+	{
+		const ShaderBuiltinVariableNames& names =
+			ShaderEnv_get_builtin_variable_names(DEFAULT_ENV);
+		return Shader(
+			"varying vec4 "      + V_TEXCOORD + ";\n"
+			"varying vec4 "      + V_COLOR + ";\n"
+			"uniform sampler2D " + U_TEXTURE + ";\n"
+			"void main ()\n"
+			"{\n"
+			"  vec4 col__   = texture2D(" + U_TEXTURE + ", " + V_TEXCOORD + ".xy);\n"
+			#ifdef OSX
+			// restore premultiplied rgb values
+			"  vec3 rgb__   = col__.a != 0.0 ? col__.rgb / col__.a : col__.rgb;\n"
+			"  gl_FragColor = " + V_COLOR + " * vec4(rgb__, col__.a);\n"
+			#else
+			"  gl_FragColor = " + V_COLOR + " * col__;\n"
+			#endif
+			"}\n");
+	}
+
 	const ShaderProgram*
 	Shader_get_program (const Shader& shader)
 	{
 		return shader.self->program ? shader.self->program.get() : NULL;
 	}
 
+	const ShaderBuiltinVariableNames&
+	Shader_get_builtin_variable_names (const Shader& shader)
+	{
+		return ShaderEnv_get_builtin_variable_names(
+			shader.self->env ? *shader.self->env : DEFAULT_ENV);
+	}
+
+	const Shader&
+	Shader_get_default_shader_for_shape ()
+	{
+		static const Shader SHADER = make_default_shader_for_shape();
+		return SHADER;
+	}
+
+	const Shader&
+	Shader_get_default_shader_for_texture ()
+	{
+		static const Shader SHADER = make_default_shader_for_texture();
+		return SHADER;
+	}
+
+	const Shader&
+	Shader_get_shader_for_text ()
+	{
+		static const Shader SHADER = make_shader_for_text();
+		return SHADER;
+	}
 
-	Shader::Shader (const char* source)
+
+	Shader::Shader (
+		const char* fragment_shader_source,
+		const char*   vertex_shader_source)
+	:	self(new Data(fragment_shader_source, vertex_shader_source, NULL))
 	{
-		if (!source) return;
+	}
 
-		self->program.reset(new ShaderProgram(
-			get_vertex_shader_source(),
-			make_fragment_shader_source(source)));
+	Shader::Shader (
+		const char* fragment_shader_source,
+		const char*   vertex_shader_source,
+		ShaderEnv env)
+	:	self(new Data(fragment_shader_source, vertex_shader_source, &env))
+	{
 	}
 
 	Shader::~Shader ()
@@ -217,6 +319,22 @@ namespace Rays
 		self->program->set_uniform(name, Image_get_texture(texture));
 	}
 
+	const char*
+	Shader::vertex_shader_source () const
+	{
+		return self->program
+			? self->program->vertex_shader_source().source()
+			: NULL;
+	}
+
+	const char*
+	Shader::fragment_shader_source () const
+	{
+		return self->program
+			? self->program->fragment_shader_source().source()
+			: NULL;
+	}
+
 	Shader::operator bool () const
 	{
 		return self->program && *self->program;
@@ -241,4 +359,166 @@ namespace Rays
 	}
 
 
+	struct ShaderEnv::Data
+	{
+
+		ShaderBuiltinVariableNames names;
+
+		uint flags;
+
+		ShaderSource default_vertex_shader_source;
+
+		Data (const ShaderBuiltinVariableNames& names, uint flags)
+		:	names(names), flags(flags)
+		{
+		}
+
+		String make_default_vertex_shader_source_code ()
+		{
+			return
+				"attribute vec3 " + A_POSITION + ";\n"
+				"attribute vec3 " + A_TEXCOORD + ";\n"
+				"attribute vec4 " + A_COLOR + ";\n"
+				"varying vec4 "   + V_POSITION + ";\n"
+				"varying vec4 "   + V_TEXCOORD + ";\n"
+				"varying vec4 "   + V_COLOR + ";\n"
+				"uniform mat4 "   + U_POSITION_MATRIX + ";\n"
+				"uniform mat4 "   + U_TEXCOORD_MATRIX + ";\n"
+				"void main ()\n"
+				"{\n"
+				"  vec4 pos__      = vec4(" + A_POSITION + ", 1.0);\n"
+				"  vec4 texcoord__ = vec4(" + A_TEXCOORD + ", 1.0);\n"
+				"  " + V_POSITION +  " = pos__;\n"
+				"  " + V_TEXCOORD +  " = " + U_TEXCOORD_MATRIX + " * texcoord__;\n"
+				"  " + V_COLOR    +  " = " + A_COLOR + ";\n"
+				"  gl_Position         = " + U_POSITION_MATRIX + " * pos__;\n"
+				"}\n";
+		}
+
+	};// ShaderEnv::Data
+
+
+	const ShaderBuiltinVariableNames&
+	ShaderEnv_get_builtin_variable_names (const ShaderEnv& env)
+	{
+		return env.self->names;
+	}
+
+	uint
+	ShaderEnv_get_flags (const ShaderEnv& env)
+	{
+		return env.self->flags;
+	}
+
+	const ShaderSource&
+	ShaderEnv_get_default_vertex_shader_source (ShaderEnv* env)
+	{
+		if (!env)
+			argument_error(__FILE__, __LINE__);
+
+		ShaderEnv::Data* self = env->self.get();
+
+		if (!self->default_vertex_shader_source)
+		{
+			self->default_vertex_shader_source = ShaderSource(
+				GL_VERTEX_SHADER, self->make_default_vertex_shader_source_code());
+		}
+		return self->default_vertex_shader_source;
+	}
+
+
+	ShaderEnv::ShaderEnv (
+		const NameList& a_position_names,
+		const NameList& a_texcoord_names,
+		const NameList& a_color_names,
+		const char*     v_position_name,
+		const char*     v_texcoord_name,
+		const char*     v_color_name,
+		const NameList& u_position_matrix_names,
+		const NameList& u_texcoord_matrix_names,
+		const NameList& u_texcoord_min_names,
+		const NameList& u_texcoord_max_names,
+		const NameList& u_texcoord_offset_names,
+		const NameList& u_texture_names,
+		uint flags)
+	:	self(new Data(
+			ShaderBuiltinVariableNames(
+				a_position_names, a_texcoord_names, a_color_names,
+				v_position_name,  v_texcoord_name,  v_color_name,
+				u_position_matrix_names, u_texcoord_matrix_names,
+				u_texcoord_min_names, u_texcoord_max_names, u_texcoord_offset_names,
+				u_texture_names),
+			flags))
+	{
+	}
+
+
+	static void
+	validate_name (const String& name, const char* for_variable)
+	{
+		assert(for_variable);
+
+		if (name.empty())
+		{
+			argument_error(
+				__FILE__, __LINE__,
+				"invalid variable name '%s' for '%s'", name.c_str(), for_variable);
+		}
+	}
+
+	static void
+	validate_names (
+		ShaderEnv::NameList* names,
+		const char* for_variable,
+		const char* default_name)
+	{
+		assert(names && for_variable && default_name);
+
+		if (names->empty()) names->emplace_back(default_name);
+
+		for (const auto& name : *names)
+			validate_name(name, for_variable);
+	}
+
+	ShaderBuiltinVariableNames::ShaderBuiltinVariableNames (
+		const ShaderEnv::NameList& a_position,
+		const ShaderEnv::NameList& a_texcoord,
+		const ShaderEnv::NameList& a_color,
+		const char* v_position,
+		const char* v_texcoord,
+		const char* v_color,
+		const ShaderEnv::NameList& u_position_matrix,
+		const ShaderEnv::NameList& u_texcoord_matrix,
+		const ShaderEnv::NameList& u_texcoord_min,
+		const ShaderEnv::NameList& u_texcoord_max,
+		const ShaderEnv::NameList& u_texcoord_offset,
+		const ShaderEnv::NameList& u_texture)
+	:	attribute_position_names(a_position),
+		attribute_texcoord_names(a_texcoord),
+		attribute_color_names(a_color),
+		varying_position_name(v_position ? v_position : "v_Position"),
+		varying_texcoord_name(v_texcoord ? v_texcoord : "v_TexCoord"),
+		varying_color_name(   v_color    ? v_color    : "v_Color"),
+		uniform_position_matrix_names(u_position_matrix),
+		uniform_texcoord_matrix_names(u_texcoord_matrix),
+		uniform_texcoord_min_names(u_texcoord_min),
+		uniform_texcoord_max_names(u_texcoord_max),
+		uniform_texcoord_offset_names(u_texcoord_offset),
+		uniform_texture_names(u_texture)
+	{
+		validate_names(&attribute_position_names,      "attribute_position",      "a_Position");
+		validate_names(&attribute_texcoord_names,      "attribute_texcoord",      "a_TexCoord");
+		validate_names(&attribute_color_names,         "attribute_color",         "a_Color");
+		validate_name(varying_position_name,           "varying_position");
+		validate_name(varying_texcoord_name,           "varying_texcoord");
+		validate_name(varying_color_name,              "varying_color");
+		validate_names(&uniform_position_matrix_names, "uniform_position_matrix", "u_PositionMatrix");
+		validate_names(&uniform_texcoord_matrix_names, "uniform_texcoord_matrix", "u_TexCoordMatrix");
+		validate_names(&uniform_texcoord_min_names,    "uniform_texcoord_min",    "u_TexCoordMin");
+		validate_names(&uniform_texcoord_max_names,    "uniform_texcoord_max",    "u_TexCoordMax");
+		validate_names(&uniform_texcoord_offset_names, "uniform_texcoord_offset", "u_TexCoordOffset");
+		validate_names(&uniform_texture_names,         "uniform_texture",         "u_Texture");
+	}
+
+
 }// Rays

data/src/shader.h

@@ -11,26 +11,65 @@ namespace Rays
 {
 
 
-	#define  ATTRIB_POSITION        "a_Position"
-	#define VARYING_POSITION        "v_Position"
-	#define UNIFORM_POSITION_MATRIX "u_PositionMatrix"
-	#define  ATTRIB_TEXCOORD        "a_TexCoord"
-	#define VARYING_TEXCOORD        "v_TexCoord"
-	#define UNIFORM_TEXCOORD_MIN    "u_TexCoordMin"
-	#define UNIFORM_TEXCOORD_MAX    "u_TexCoordMax"
-	#define UNIFORM_TEXCOORD_MATRIX "u_TexCoordMatrix"
-	#define  ATTRIB_COLOR           "a_Color"
-	#define VARYING_COLOR           "v_Color"
-	//#define UNIFORM_COLOR_MATRIX    "u_ColorMatrix"
-	#define UNIFORM_TEXTURE         "u_Texture"
-	#define UNIFORM_TEXTURE_SIZE    "u_TextureSize"
+	class ShaderSource;
+	class ShaderProgram;
 
 
-	class ShaderProgram;
+	struct ShaderBuiltinVariableNames
+	{
+
+		ShaderEnv::NameList attribute_position_names;
+		ShaderEnv::NameList attribute_texcoord_names;
+		ShaderEnv::NameList attribute_color_names;
+
+		String varying_position_name;
+		String varying_texcoord_name;
+		String varying_color_name;
+
+		ShaderEnv::NameList uniform_position_matrix_names;
+		ShaderEnv::NameList uniform_texcoord_matrix_names;
+		ShaderEnv::NameList uniform_texcoord_min_names;
+		ShaderEnv::NameList uniform_texcoord_max_names;
+		ShaderEnv::NameList uniform_texcoord_offset_names;
+		ShaderEnv::NameList uniform_texture_names;
+
+		ShaderBuiltinVariableNames (
+			const ShaderEnv::NameList& attribute_position_names,
+			const ShaderEnv::NameList& attribute_texcoord_names,
+			const ShaderEnv::NameList& attribute_color_names,
+			const char* varying_position_name,
+			const char* varying_texcoord_name,
+			const char* varying_color_name,
+			const ShaderEnv::NameList& uniform_position_matrix_names,
+			const ShaderEnv::NameList& uniform_texcoord_matrix_names,
+			const ShaderEnv::NameList& uniform_texcoord_min_names,
+			const ShaderEnv::NameList& uniform_texcoord_max_names,
+			const ShaderEnv::NameList& uniform_texcoord_offset_names,
+			const ShaderEnv::NameList& uniform_texture_names);
+
+	};// ShaderBuiltinVariableNames
 
 
 	const ShaderProgram* Shader_get_program (const Shader& shader);
 
+	const ShaderBuiltinVariableNames& Shader_get_builtin_variable_names (
+		const Shader& shader);
+
+	const Shader& Shader_get_default_shader_for_shape ();
+
+	const Shader& Shader_get_default_shader_for_texture ();
+
+	const Shader& Shader_get_shader_for_text ();
+
+
+	const ShaderBuiltinVariableNames& ShaderEnv_get_builtin_variable_names (
+		const ShaderEnv& env);
+
+	uint ShaderEnv_get_flags (const ShaderEnv& env);
+
+	const ShaderSource& ShaderEnv_get_default_vertex_shader_source (
+		ShaderEnv* env);
+
 
 }// Rays
 

data/src/shader_program.cpp

@@ -5,6 +5,7 @@
 #include <vector>
 #include <memory>
 #include <algorithm>
+#include "rays/shader.h"
 #include "rays/exception.h"
 #include "shader_source.h"
 #include "texture.h"
@@ -35,7 +36,7 @@ namespace Rays
 
 			virtual ~UniformValue () {}
 
-			virtual void apply (GLint location) const = 0;
+			virtual bool apply (size_t index, GLint location) const = 0;
 
 	};// UniformValue
 
@@ -83,10 +84,10 @@ namespace Rays
 					array[i] = args[i];
 			}
 
-			void apply (GLint location) const
+			bool apply (size_t index, GLint location) const
 			{
 				apply_value(location);
-				OpenGL_check_error(__FILE__, __LINE__);
+				return !OpenGL_has_error();
 			}
 
 			void apply_value (GLint location) const;
@@ -149,18 +150,20 @@ namespace Rays
 			{
 			}
 
-			void apply (GLint location) const
+			bool apply (size_t index, GLint location) const
 			{
-				if (!texture) return;
+				if (!texture)
+					shader_error(__FILE__, __LINE__, "invalid texture");
 
-				GLint unit_max = get_texture_unit_max();
-				GLint unit = unit_max;
-				glGetIntegerv(GL_ACTIVE_TEXTURE, &unit);
-				assert(unit < unit_max);
+				GLint unit = (GLint) (index + 1);// GL_TEXTURE0 is used by apply_builtin_uniforms()
+				GLint max  = get_texture_unit_max();
+				if (unit >= max)
+					shader_error(__FILE__, __LINE__, "texture unit must be less than %d", max);
 
+				glActiveTexture(GL_TEXTURE0 + unit);
 				glBindTexture(GL_TEXTURE_2D, texture.id());
 				glUniform1i(location, unit);
-				OpenGL_check_error(__FILE__, __LINE__);
+				return !OpenGL_has_error();
 			}
 
 		private:
@@ -205,15 +208,20 @@ namespace Rays
 			self->applied = false;
 		}
 
-		void apply (const ShaderProgram& program) const
+		void apply (
+			size_t index, const ShaderProgram& program,
+			bool ignore_no_uniform_location_error) const
 		{
 			if (!program || self->applied) return;
 			self->applied = true;
 
-			GLint location = glGetUniformLocation(program.id(), self->name);
-			if (location < 0) return;
+			const char* name = self->name;
+			GLint location = glGetUniformLocation(program.id(), name);
+			if (location < 0 && !ignore_no_uniform_location_error)
+				shader_error(__FILE__, __LINE__, "uniform location '%s' not found", name);
 
-			self->value->apply(location);
+			if (!self->value->apply(index, location))
+				shader_error(__FILE__, __LINE__, "failed to apply uniform variable '%s'", name);
 		}
 
 		bool operator == (const Uniform& rhs) const
@@ -235,7 +243,9 @@ namespace Rays
 	struct ShaderProgram::Data
 	{
 
-		GLuint id = 0;
+		GLuint id  = 0;
+
+		uint flags = 0;
 
 		ShaderSource vertex, fragment;
 
@@ -266,7 +276,7 @@ namespace Rays
 		void set_uniform_texture (const char* name, const UniformValue* value)
 		{
 			if (uniform_textures.size() >= (size_t) get_texture_unit_max())
-				opengl_error(__FILE__, __LINE__, "too many texture units.");
+				shader_error(__FILE__, __LINE__, "too many texture units.");
 
 			set_uniform(&uniform_textures, name, value);
 		}
@@ -311,7 +321,14 @@ namespace Rays
 			GLint status = GL_FALSE;
 			glGetProgramiv(id, GL_LINK_STATUS, &status);
 			if (status == GL_FALSE)
-				opengl_error(__FILE__, __LINE__, get_link_log().c_str());
+				shader_error(__FILE__, __LINE__, get_link_log().c_str());
+
+			glValidateProgram(id);
+
+			GLint validate = GL_FALSE;
+			glGetProgramiv(id, GL_VALIDATE_STATUS, &validate);
+			if (validate == GL_FALSE)
+				OpenGL_check_error(__FILE__, __LINE__, "shader program validation failed");
 		}
 
 		void attach_shader (const ShaderSource& source) const
@@ -343,17 +360,13 @@ namespace Rays
 			if (applied) return;
 			applied = true;
 
-			for (const auto& value : uniform_values)
-				value.apply(program);
+			bool ignore_no_loc = flags & ShaderEnv::IGNORE_NO_UNIFORM_LOCATION_ERROR;
 
-			int unit = 0;
-			for (const auto& texture : uniform_textures)
-			{
-				glActiveTexture(unit++);
-				texture.apply(program);
-			}
+			for (size_t i = 0; i < uniform_values.size(); ++i)
+				uniform_values[i].apply(i, program, ignore_no_loc);
 
-			OpenGL_check_error(__FILE__, __LINE__);
+			for (size_t i = 0; i < uniform_textures.size(); ++i)
+				uniform_textures[i].apply(i, program, ignore_no_loc);
 		}
 
 	};// ShaderProgram::Data
@@ -383,10 +396,11 @@ namespace Rays
 
 
 	ShaderProgram::ShaderProgram (
-		const ShaderSource& vertex, const ShaderSource& fragment)
+		const ShaderSource& vertex, const ShaderSource& fragment, uint flags)
 	{
 		self->vertex   = vertex;
 		self->fragment = fragment;
+		self->flags    = flags;
 	}
 
 	ShaderProgram::~ShaderProgram ()
@@ -500,6 +514,18 @@ namespace Rays
 		self->set_uniform_texture(name, new UniformTexture(texture));
 	}
 
+	const ShaderSource&
+	ShaderProgram::vertex_shader_source () const
+	{
+		return self->vertex;
+	}
+
+	const ShaderSource&
+	ShaderProgram::fragment_shader_source () const
+	{
+		return self->fragment;
+	}
+
 	GLuint
 	ShaderProgram::id () const
 	{

data/src/shader_program.h

@@ -25,7 +25,10 @@ namespace Rays
 
 		public:
 
-			ShaderProgram (const ShaderSource& vertex, const ShaderSource& fragment);
+			ShaderProgram (
+				const ShaderSource& vertex,
+				const ShaderSource& fragment,
+				uint flags);
 
 			~ShaderProgram ();
 
@@ -59,6 +62,10 @@ namespace Rays
 
 			GLuint id () const;
 
+			const ShaderSource& vertex_shader_source () const;
+
+			const ShaderSource& fragment_shader_source () const;
+
 			operator bool () const;
 
 			bool operator ! () const;