rays 0.1.28 → 0.1.29

data/src/painter.cpp

@@ -6,6 +6,7 @@
 #include <memory>
 #include <vector>
 #include <algorithm>
+#include <functional>
 #include <glm/gtc/matrix_transform.hpp>
 #include "rays/exception.h"
 #include "rays/point.h"
@@ -93,7 +94,7 @@ namespace Rays
 
 		const Texture& texture;
 
-		Coord2 texcoord_min, texcoord_max;
+		Point texcoord_min, texcoord_max;
 
 		TextureInfo (
 			const Texture& texture,
@@ -236,33 +237,6 @@ namespace Rays
 		return GL_FLOAT;
 	}
 
-	static const Shader&
-	get_default_shader_for_shape ()
-	{
-		static const Shader SHADER(
-			"varying vec4 " VARYING_COLOR ";"
-			"void main ()"
-			"{"
-			"  gl_FragColor = v_Color;"
-			"}");
-		return SHADER;
-	}
-
-	static const Shader&
-	get_default_shader_for_texture ()
-	{
-		static const Shader SHADER(
-			"varying vec4 " VARYING_TEXCOORD ";"
-			"varying vec4 " VARYING_COLOR ";"
-			"vec4 sampleTexture(vec2);"
-			"void main ()"
-			"{"
-			"  vec4 color   = sampleTexture(" VARYING_TEXCOORD ".xy);"
-			"  gl_FragColor = v_Color * color;"
-			"}");
-		return SHADER;
-	}
-
 
 	struct Painter::Data
 	{
@@ -338,7 +312,7 @@ namespace Rays
 			const Coord3* points,           size_t npoints,
 			const uint*   indices   = NULL, size_t nindices = 0,
 			const Coord3* texcoords = NULL,
-			const Shader& default_shader = get_default_shader_for_shape(),
+			const Shader& default_shader = Shader_get_default_shader_for_shape(),
 			const TextureInfo* texinfo = NULL)
 		{
 			if (!points || npoints <= 0)
@@ -347,143 +321,240 @@ namespace Rays
 			if (!painting)
 				invalid_state_error(__FILE__, __LINE__, "'painting' should be true.");
 
-			if (!indices || nindices <= 0)
-			{
-				default_indices.resize(npoints);
-				indices  = default_indices.get();
-				nindices = npoints;
-			}
-
-			if (!texcoords)
-				texcoords = points;
-
-			const ShaderProgram* program = Shader_get_program(state.shader);
-			if (!program || !*program)
-			{
-				program = Shader_get_program(default_shader);
-				if (!program || !*program) return;
-			}
+			const Shader& shader         = state.shader ? state.shader : default_shader;
+			const ShaderProgram* program = Shader_get_program(shader);
+			if (!program || !*program) return;
 
 			ShaderProgram_activate(*program);
-			apply_builtin_uniforms(*program, texinfo);
 
-			GLint a_position = glGetAttribLocation(program->id(), ATTRIB_POSITION);
-			GLint a_texcoord = glGetAttribLocation(program->id(), ATTRIB_TEXCOORD);
-			GLint a_color    = glGetAttribLocation(program->id(), ATTRIB_COLOR);
-			if (a_position < 0 || a_texcoord < 0 || a_color < 0)
-				opengl_error(__FILE__, __LINE__);
-
-			setup_vertices(
-				points, npoints, texcoords, color, a_position, a_texcoord, a_color);
-			//activate_texture(texture);
-
-			glDrawElements(mode, (GLsizei) nindices, GL_UNSIGNED_INT, indices);
-			OpenGL_check_error(__FILE__, __LINE__);
-
-			//deactivate_texture(texture);
-			cleanup_vertices(a_position, a_texcoord);
+			const auto& names = Shader_get_builtin_variable_names(shader);
+			apply_builtin_uniforms(*program, names, texinfo);
+			apply_attributes(*program, names, points, npoints, texcoords, color, [&]() {
+				draw_indices(mode, indices, nindices, npoints);
+			});
 
 			ShaderProgram_deactivate();
 		}
 
 		private:
 
+			typedef std::vector<GLint> LocationList;
+
 			void apply_builtin_uniforms (
-				const ShaderProgram& program, const TextureInfo* texinfo)
+				const ShaderProgram& program, const ShaderBuiltinVariableNames& names,
+				const TextureInfo* texinfo)
 			{
-				GLint pos_matrix_loc =
-					glGetUniformLocation(program.id(), UNIFORM_POSITION_MATRIX);
-				if (pos_matrix_loc >= 0)
+				const Texture* texture = texinfo ? &texinfo->texture : NULL;
+
+				Matrix texcoord_matrix(1);
+				if (texture && *texture)
 				{
-					glUniformMatrix4fv(
-						pos_matrix_loc, 1, GL_FALSE, position_matrix.array);
-					OpenGL_check_error(__FILE__, __LINE__);
+					texcoord_matrix.scale(
+						1.0 / texture->reserved_width(),
+						1.0 / texture->reserved_height());
 				}
 
-				GLint texcoord_matrix_loc =
-					glGetUniformLocation(program.id(), UNIFORM_TEXCOORD_MATRIX);
-				if (texcoord_matrix_loc >= 0)
+				for (const auto& name : names.uniform_position_matrix_names)
 				{
-					static const Matrix TEXCOORD_MATRIX(1);
-					glUniformMatrix4fv(
-						texcoord_matrix_loc, 1, GL_FALSE, TEXCOORD_MATRIX.array);
-					OpenGL_check_error(__FILE__, __LINE__);
+					apply_uniform(program, name, [&](GLint loc) {
+						glUniformMatrix4fv(loc, 1, GL_FALSE, position_matrix.array);
+					});
+				}
+				for (const auto& name : names.uniform_texcoord_matrix_names)
+				{
+					apply_uniform(program, name, [&](GLint loc) {
+						glUniformMatrix4fv(loc, 1, GL_FALSE, texcoord_matrix.array);
+					});
 				}
 
-				apply_texture_uniforms(program, texinfo);
-			}
+				if (!texinfo || !texture || !*texture) return;
 
-			void apply_texture_uniforms (
-				const ShaderProgram& program, const TextureInfo* texinfo)
-			{
-				if (!texinfo || !*texinfo) return;
+				for (const auto& name : names.uniform_texcoord_min_names)
+				{
+					apply_uniform(program, name, [&](GLint loc) {
+						Point min = texcoord_matrix * texinfo->texcoord_min;
+						glUniform3fv(loc, 1, min.array);
+					});
+				}
+				for (const auto& name : names.uniform_texcoord_max_names)
+				{
+					apply_uniform(program, name, [&](GLint loc) {
+						Point max = texcoord_matrix * texinfo->texcoord_max;
+						glUniform3fv(loc, 1, max.array);
+					});
+				}
+				for (const auto& name : names.uniform_texcoord_offset_names)
+				{
+					apply_uniform(program, name, [&](GLint loc) {
+						Point offset(1.0 / texture->width(), 1.0 / texture->height());
+						glUniform3fv(loc, 1, offset.array);
+					});
+				}
+				for (const auto& name : names.uniform_texture_names)
+				{
+					apply_uniform(program, name, [&](GLint loc) {
+						glActiveTexture(GL_TEXTURE0);
+						OpenGL_check_error(__FILE__, __LINE__);
 
-				const Texture& texture = texinfo->texture;
+						glBindTexture(GL_TEXTURE_2D, texture->id());
+						OpenGL_check_error(__FILE__, __LINE__);
 
-				GLint texture_loc =
-					glGetUniformLocation(program.id(), UNIFORM_TEXTURE);
-				if (texture_loc >= 0)
-				{
-					glActiveTexture(GL_TEXTURE0);
-					glBindTexture(GL_TEXTURE_2D, texture.id());
+						glUniform1i(loc, 0);
+					});
+				}
+			}
 
-					glUniform1i(texture_loc, 0);
-					OpenGL_check_error(__FILE__, __LINE__);
+			void apply_attributes (
+				const ShaderProgram& program, const ShaderBuiltinVariableNames& names,
+				const Coord3* points, size_t npoints, const Coord3* texcoords, const Color& color,
+				std::function<void()> draw_fun)
+			{
+				assert(points && npoints > 0);
+
+				std::vector<GLuint> buffers;
+				LocationList locations;
+
+				apply_attribute(
+					&buffers, &locations,
+					program, names.attribute_position_names,
+					points, npoints);
+
+				apply_attribute(
+					&buffers, &locations,
+					program, names.attribute_texcoord_names,
+					texcoords ? texcoords : points, npoints);
+
+#if defined(GL_VERSION_2_1) && !defined(GL_VERSION_3_0)
+				// to fix that GL 2.1 with glVertexAttrib4fv() draws nothing
+				// with specific glsl 'attribute' name.
+				std::vector<Color> colors(npoints, color);
+				apply_attribute(
+					&buffers, &locations,
+					program, names.attribute_color_names,
+					(const Coord4*) &colors[0], npoints);
+#else
+				for (const auto& name : names.attribute_color_names)
+				{
+					apply_attribute(NULL, program, name, [&](GLint loc) {
+						glVertexAttrib4fv(loc, color.array);
+					});
 				}
+#endif
 
-				GLint size_loc =
-					glGetUniformLocation(program.id(), UNIFORM_TEXTURE_SIZE);
-				if (size_loc >= 0)
+				draw_fun();
+
+				for (auto loc : locations)
 				{
-					glUniform2f(
-						size_loc, texture.reserved_width(), texture.reserved_height());
+					glDisableVertexAttribArray(loc);
 					OpenGL_check_error(__FILE__, __LINE__);
 				}
 
-				GLint min_loc =
-					glGetUniformLocation(program.id(), UNIFORM_TEXCOORD_MIN);
-				if (min_loc >= 0)
+				glDeleteBuffers((GLsizei) buffers.size(), &buffers[0]);
+				OpenGL_check_error(__FILE__, __LINE__);
+			}
+
+			template <typename CoordN>
+			void apply_attribute(
+				auto* buffers, LocationList* locations,
+				const ShaderProgram& program, const auto& names,
+				const CoordN* values, size_t nvalues)
+			{
+				assert(buffers);
+
+				GLuint buffer = 0;
+				for (const auto& name : names)
 				{
-					glUniform2fv(min_loc, 1, texinfo->texcoord_min.array);
-					OpenGL_check_error(__FILE__, __LINE__);
+					apply_attribute(locations, program, name, [&](GLint loc) {
+						if (buffer == 0)
+						{
+							buffer = create_and_bind_coordn_buffer(values, nvalues);
+							buffers->push_back(buffer);
+						}
+
+						glEnableVertexAttribArray(loc);
+						OpenGL_check_error(__FILE__, __LINE__, "loc: %d %s\n", loc, name.c_str());
+
+						glVertexAttribPointer(
+							loc, CoordN::SIZE, get_gl_type<coord>(),
+							GL_FALSE, sizeof(CoordN), NULL);
+					});
 				}
 
-				GLint max_loc =
-					glGetUniformLocation(program.id(), UNIFORM_TEXCOORD_MAX);
-				if (max_loc >= 0)
+				glBindBuffer(GL_ARRAY_BUFFER, 0);
+				OpenGL_check_error(__FILE__, __LINE__);
+			}
+
+			void apply_attribute (
+				LocationList* locations, const ShaderProgram& program, const char* name,
+				std::function<void(GLint)> apply)
+			{
+				GLint loc = glGetAttribLocation(program.id(), name);
+				if (loc < 0) return;
+
+				apply(loc);
+				OpenGL_check_error(__FILE__, __LINE__);
+
+				if (locations) locations->push_back(loc);
+			}
+
+			void apply_uniform (
+				const ShaderProgram& program, const char* name,
+				std::function<void(GLint)> apply)
+			{
+				GLint loc = glGetUniformLocation(program.id(), name);
+				if (loc < 0) return;
+
+				apply(loc);
+				OpenGL_check_error(__FILE__, __LINE__);
+			}
+
+			void draw_indices (
+				GLenum mode, const uint* indices, size_t nindices, size_t npoints)
+			{
+				if (!indices || nindices <= 0)
 				{
-					glUniform2fv(max_loc, 1, texinfo->texcoord_max.array);
-					OpenGL_check_error(__FILE__, __LINE__);
+					default_indices.resize(npoints);
+					indices  = default_indices.get();
+					nindices = npoints;
 				}
+
+				GLuint buffer = create_buffer();
+				size_t size   = sizeof(uint) * nindices;
+
+				glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
+				OpenGL_check_error(__FILE__, __LINE__);
+
+				glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, indices, GL_STREAM_DRAW);
+				OpenGL_check_error(__FILE__, __LINE__);
+
+				glDrawElements(mode, (GLsizei) nindices, GL_UNSIGNED_INT, NULL);
+				OpenGL_check_error(__FILE__, __LINE__);
+
+				glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+				OpenGL_check_error(__FILE__, __LINE__);
 			}
 
-			void setup_vertices (
-				const Coord3* points, size_t npoints,
-				const Coord3* texcoords, const Color& color,
-				GLuint a_position, GLuint a_texcoord, GLuint a_color)
+			template <typename CoordN>
+			GLuint create_and_bind_coordn_buffer (const CoordN* values, size_t nvalues)
 			{
-				assert(points && npoints >= 0 && texcoords);
+				GLuint id   = create_buffer();
+				size_t size = sizeof(CoordN) * nvalues;
 
-				glEnableVertexAttribArray(a_position);
-				glVertexAttribPointer(
-					a_position, Coord3::SIZE, get_gl_type<coord>(),
-					GL_FALSE, sizeof(Coord3), points);
+				glBindBuffer(GL_ARRAY_BUFFER, id);
 				OpenGL_check_error(__FILE__, __LINE__);
 
-				glEnableVertexAttribArray(a_texcoord);
-				glVertexAttribPointer(
-					a_texcoord, Coord3::SIZE, get_gl_type<coord>(),
-					GL_FALSE, sizeof(Coord3), texcoords);
+				glBufferData(GL_ARRAY_BUFFER, size, values, GL_STREAM_DRAW);
 				OpenGL_check_error(__FILE__, __LINE__);
 
-				glVertexAttrib4fv(a_color, color.array);
+				return id;
 			}
 
-			void cleanup_vertices (GLint a_position, GLint a_texcoord)
+			GLuint create_buffer ()
 			{
-				glDisableVertexAttribArray(a_position);
-				glDisableVertexAttribArray(a_texcoord);
+				GLuint id;
+				glGenBuffers(1, &id);
 				OpenGL_check_error(__FILE__, __LINE__);
+				return id;
 			}
 
 			void activate_texture (const Texture* texture)
@@ -530,7 +601,7 @@ namespace Rays
 		const Coord3* points,           size_t npoints,
 		const uint*   indices   = NULL, size_t nindices = 0,
 		const Coord3* texcoords = NULL,
-		const Shader& default_shader = get_default_shader_for_shape(),
+		const Shader& default_shader = Shader_get_default_shader_for_shape(),
 		const TextureInfo* texinfo = NULL)
 	{
 		assert(painter);
@@ -958,7 +1029,7 @@ namespace Rays
 		TextureInfo texinfo(texture, src_x, src_y, src_x + src_w, src_y + src_h);
 
 		if (!shader)
-			shader = &get_default_shader_for_texture();
+			shader = &Shader_get_default_shader_for_texture();
 
 		draw_polygon(
 			painter, MODES, 0, 0, false, nostroke, points, 4, NULL, 0, texcoords,
@@ -1135,7 +1206,7 @@ namespace Rays
 			painter, self->text_image,
 			0, 0, str_w, str_h,
 			x, y, str_w, str_h,
-			true, &get_default_shader_for_texture());
+			true, &Shader_get_shader_for_text());
 
 		debug_draw_text(painter, font, x, y, str_w / density, str_h / density);
 	}