rays 0.1.12 → 0.1.13

data/src/shader.h

@@ -0,0 +1,38 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_SRC_SHADER_H__
+#define __RAYS_SRC_SHADER_H__
+
+
+#include <rays/shader.h>
+
+
+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 ShaderProgram;
+
+
+	const ShaderProgram* Shader_get_program (const Shader& shader);
+
+
+}// Rays
+
+
+#endif//EOH

data/src/shader_program.cpp

@@ -0,0 +1,533 @@
+#include "shader_program.h"
+
+
+#include <assert.h>
+#include <vector>
+#include <memory>
+#include <algorithm>
+#include "rays/exception.h"
+#include "shader_source.h"
+#include "texture.h"
+#include "painter.h"
+
+
+namespace Rays
+{
+
+
+	static GLint
+	get_texture_unit_max ()
+	{
+		static GLint value = -1;
+		if (value < 0)
+		{
+			glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &value);
+			OpenGL_check_error(__FILE__, __LINE__);
+		}
+		return value;
+	}
+
+
+	class UniformValue
+	{
+
+		public:
+
+			virtual ~UniformValue () {}
+
+			virtual void apply (GLint location) const = 0;
+
+	};// UniformValue
+
+
+	template <typename T, int DIMENSION>
+	class UniformValueT : public UniformValue
+	{
+
+		public:
+
+			UniformValueT (T arg1)
+			{
+				assert(DIMENSION == 1);
+				array[0] = arg1;
+			}
+
+			UniformValueT (T arg1, T arg2)
+			{
+				assert(DIMENSION == 2);
+				array[0] = arg1;
+				array[1] = arg2;
+			}
+
+			UniformValueT (T arg1, T arg2, T arg3)
+			{
+				assert(DIMENSION == 3);
+				array[0] = arg1;
+				array[1] = arg2;
+				array[2] = arg3;
+			}
+
+			UniformValueT (T arg1, T arg2, T arg3, T arg4)
+			{
+				assert(DIMENSION == 4);
+				array[0] = arg1;
+				array[1] = arg2;
+				array[2] = arg3;
+				array[3] = arg4;
+			}
+
+			UniformValueT (const T* args, size_t size)
+			{
+				assert(size == DIMENSION);
+				for (size_t i = 0; i < size; ++i)
+					array[i] = args[i];
+			}
+
+			void apply (GLint location) const
+			{
+				apply_value(location);
+				OpenGL_check_error(__FILE__, __LINE__);
+			}
+
+			void apply_value (GLint location) const;
+
+		private:
+
+			T array[DIMENSION];
+
+	};// UniformValueT
+
+
+	template <> void UniformValueT<int, 1>::apply_value (GLint location) const
+	{
+		glUniform1iv(location, 1, array);
+	}
+
+	template <> void UniformValueT<int, 2>::apply_value (GLint location) const
+	{
+		glUniform2iv(location, 1, array);
+	}
+
+	template <> void UniformValueT<int, 3>::apply_value (GLint location) const
+	{
+		glUniform3iv(location, 1, array);
+	}
+
+	template <> void UniformValueT<int, 4>::apply_value (GLint location) const
+	{
+		glUniform4iv(location, 1, array);
+	}
+
+	template <> void UniformValueT<float, 1>::apply_value (GLint location) const
+	{
+		glUniform1fv(location, 1, array);
+	}
+
+	template <> void UniformValueT<float, 2>::apply_value (GLint location) const
+	{
+		glUniform2fv(location, 1, array);
+	}
+
+	template <> void UniformValueT<float, 3>::apply_value (GLint location) const
+	{
+		glUniform3fv(location, 1, array);
+	}
+
+	template <> void UniformValueT<float, 4>::apply_value (GLint location) const
+	{
+		glUniform4fv(location, 1, array);
+	}
+
+
+	class UniformTexture : public UniformValue
+	{
+
+		public:
+
+			UniformTexture (const Texture& texture)
+			:	texture(texture)
+			{
+			}
+
+			void apply (GLint location) const
+			{
+				if (!texture) return;
+
+				GLint unit_max = get_texture_unit_max();
+				GLint unit = unit_max;
+				glGetIntegerv(GL_ACTIVE_TEXTURE, &unit);
+				assert(unit < unit_max);
+
+				glBindTexture(GL_TEXTURE_2D, texture.id());
+				glUniform1i(location, unit);
+				OpenGL_check_error(__FILE__, __LINE__);
+			}
+
+		private:
+
+			Texture texture;
+
+	};// UniformTexture
+
+
+	struct Uniform
+	{
+
+		struct Data
+		{
+
+			String name;
+
+			std::unique_ptr<const UniformValue> value;
+
+			bool applied = false;
+
+		};// Data
+
+		Xot::PSharedImpl<Data> self;
+
+		Uniform (const char* name, const UniformValue* value)
+		{
+			if (!name || name[0] == '\0')
+				argument_error(__FILE__, __LINE__);
+
+			reset(value);
+
+			self->name = name;
+		}
+
+		void reset (const UniformValue* value)
+		{
+			if (!value)
+				argument_error(__FILE__, __LINE__);
+
+			self->value.reset(value);
+			self->applied = false;
+		}
+
+		void apply (const ShaderProgram& program) const
+		{
+			if (!program || self->applied) return;
+			self->applied = true;
+
+			GLint location = glGetUniformLocation(program.id(), self->name);
+			if (location < 0) return;
+
+			self->value->apply(location);
+		}
+
+		bool operator == (const Uniform& rhs) const
+		{
+			return self.get() == rhs.self.get();
+		}
+
+		bool operator != (const Uniform& rhs) const
+		{
+			return !operator==(rhs);
+		}
+
+	};// Uniform
+
+
+	typedef std::vector<Uniform> UniformList;
+
+
+	struct ShaderProgram::Data
+	{
+
+		GLuint id = 0;
+
+		ShaderSource vertex, fragment;
+
+		UniformList uniform_values, uniform_textures;
+
+		mutable bool linked = false, applied = false;
+
+		Data ()
+		{
+			id = glCreateProgram();
+			if (id <= 0)
+				opengl_error(__FILE__, __LINE__, "failed to create program.");
+		}
+
+		~Data ()
+		{
+			if (id > 0) glDeleteProgram(id);
+
+			uniform_values.clear();
+			uniform_textures.clear();
+		}
+
+		void set_uniform_value (const char* name, const UniformValue* value)
+		{
+			set_uniform(&uniform_values, name, value);
+		}
+
+		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.");
+
+			set_uniform(&uniform_textures, name, value);
+		}
+
+		void set_uniform (
+			UniformList* uniforms, const char* name, const UniformValue* value)
+		{
+			assert(uniforms);
+
+			auto it = std::find_if(
+				uniforms->begin(), uniforms->end(), [&](const Uniform& uniform) {
+					return uniform.self->name == name;
+				});
+
+			if (it != uniforms->end())
+				it->reset(value);
+			else
+				uniforms->push_back(Uniform(name, value));
+
+			applied = false;
+		}
+
+		bool is_valid () const
+		{
+			return id > 0 && vertex && fragment;
+		}
+
+		void link () const
+		{
+			if (linked) return;
+			linked = true;
+
+			attach_shader(vertex);
+			attach_shader(fragment);
+
+			glLinkProgram(id);
+			OpenGL_check_error(__FILE__, __LINE__);
+
+			detach_shader(vertex);
+			detach_shader(fragment);
+
+			GLint status = GL_FALSE;
+			glGetProgramiv(id, GL_LINK_STATUS, &status);
+			if (status == GL_FALSE)
+				opengl_error(__FILE__, __LINE__, get_link_log().c_str());
+		}
+
+		void attach_shader (const ShaderSource& source) const
+		{
+			glAttachShader(id, source.id());
+			OpenGL_check_error(__FILE__, __LINE__);
+		}
+
+		void detach_shader (const ShaderSource& source) const
+		{
+			glDetachShader(id, source.id());
+			OpenGL_check_error(__FILE__, __LINE__);
+		}
+
+		String get_link_log () const
+		{
+			int len = 0;
+			glGetProgramiv(id, GL_INFO_LOG_LENGTH, &len);
+			if (len <= 0) return "";
+
+			std::unique_ptr<char[]> buffer(new char[len]);
+			int written = 0;
+			glGetProgramInfoLog(id, len, &written, &buffer[0]);
+			return &buffer[0];
+		}
+
+		void apply_uniforms (const ShaderProgram& program) const
+		{
+			if (applied) return;
+			applied = true;
+
+			for (const auto& value : uniform_values)
+				value.apply(program);
+
+			int unit = 0;
+			for (const auto& texture : uniform_textures)
+			{
+				glActiveTexture(unit++);
+				texture.apply(program);
+			}
+
+			OpenGL_check_error(__FILE__, __LINE__);
+		}
+
+	};// ShaderProgram::Data
+
+
+	void
+	ShaderProgram_activate (const ShaderProgram& program)
+	{
+		ShaderProgram::Data* self = program.self.get();
+
+		if (!self->is_valid()) return;
+
+		self->link();
+
+		glUseProgram(program.id());
+		OpenGL_check_error(__FILE__, __LINE__);
+
+		self->apply_uniforms(program);
+	}
+
+	void
+	ShaderProgram_deactivate ()
+	{
+		glUseProgram(0);
+		OpenGL_check_error(__FILE__, __LINE__);
+	}
+
+
+	ShaderProgram::ShaderProgram (
+		const ShaderSource& vertex, const ShaderSource& fragment)
+	{
+		self->vertex   = vertex;
+		self->fragment = fragment;
+	}
+
+	ShaderProgram::~ShaderProgram ()
+	{
+	}
+
+	void
+	ShaderProgram::set_uniform (const char* name, int arg1)
+	{
+		self->set_uniform_value(name, new UniformValueT<int, 1>(arg1));
+	}
+
+	void
+	ShaderProgram::set_uniform (const char* name, int arg1, int arg2)
+	{
+		self->set_uniform_value(name, new UniformValueT<int, 2>(arg1, arg2));
+	}
+
+	void
+	ShaderProgram::set_uniform (const char* name, int arg1, int arg2, int arg3)
+	{
+		self->set_uniform_value(name, new UniformValueT<int, 3>(arg1, arg2, arg3));
+	}
+
+	void
+	ShaderProgram::set_uniform (
+		const char* name, int arg1, int arg2, int arg3, int arg4)
+	{
+		self->set_uniform_value(
+			name, new UniformValueT<int, 4>(arg1, arg2, arg3, arg4));
+	}
+
+	template <typename T>
+	static UniformValue*
+	create_uniform_value (const T* args, size_t size)
+	{
+		switch (size)
+		{
+			case 1: return new UniformValueT<T, 1>(args, 1);
+			case 2: return new UniformValueT<T, 2>(args, 2);
+			case 3: return new UniformValueT<T, 3>(args, 3);
+			case 4: return new UniformValueT<T, 4>(args, 4);
+
+			default:
+				argument_error(__FILE__, __LINE__, "invalid 'size' value.");
+		}
+
+		return NULL;
+	}
+
+	void
+	ShaderProgram::set_uniform (const char* name, const int* args, size_t size)
+	{
+		self->set_uniform_value(name, create_uniform_value(args, size));
+	}
+
+	void
+	ShaderProgram::set_uniform (const char* name, float arg1)
+	{
+		self->set_uniform_value(name, new UniformValueT<float, 1>(arg1));
+	}
+
+	void
+	ShaderProgram::set_uniform (const char* name, float arg1, float arg2)
+	{
+		self->set_uniform_value(name, new UniformValueT<float, 2>(arg1, arg2));
+	}
+
+	void
+	ShaderProgram::set_uniform (const char* name, float arg1, float arg2, float arg3)
+	{
+		self->set_uniform_value(
+			name, new UniformValueT<float, 3>(arg1, arg2, arg3));
+	}
+
+	void
+	ShaderProgram::set_uniform (
+		const char* name, float arg1, float arg2, float arg3, float arg4)
+	{
+		self->set_uniform_value(
+			name, new UniformValueT<float, 4>(arg1, arg2, arg3, arg4));
+	}
+
+	void
+	ShaderProgram::set_uniform (const char* name, const float* args, size_t size)
+	{
+		self->set_uniform_value(name, create_uniform_value(args, size));
+	}
+
+	void
+	ShaderProgram::set_uniform (const char* name, const Coord2& vec2)
+	{
+		self->set_uniform_value(name, new UniformValueT<float, 2>(vec2.array, 2));
+	}
+
+	void
+	ShaderProgram::set_uniform (const char* name, const Coord3& vec3)
+	{
+		self->set_uniform_value(name, new UniformValueT<float, 3>(vec3.array, 3));
+	}
+
+	void
+	ShaderProgram::set_uniform (const char* name, const Coord4& vec4)
+	{
+		self->set_uniform_value(name, new UniformValueT<float, 4>(vec4.array, 4));
+	}
+
+	void
+	ShaderProgram::set_uniform (const char* name, const Texture& texture)
+	{
+		self->set_uniform_texture(name, new UniformTexture(texture));
+	}
+
+	GLuint
+	ShaderProgram::id () const
+	{
+		return self->id;
+	}
+
+	ShaderProgram::operator bool () const
+	{
+		return self->is_valid();
+	}
+
+	bool
+	ShaderProgram::operator ! () const
+	{
+		return !operator bool();
+	}
+
+	bool
+	operator == (const ShaderProgram& lhs, const ShaderProgram& rhs)
+	{
+		return (!lhs && !rhs) || lhs.self->id == rhs.self->id;
+	}
+
+	bool
+	operator != (const ShaderProgram& lhs, const ShaderProgram& rhs)
+	{
+		return !operator==(lhs, rhs);
+	}
+
+
+}// Rays