rays 0.1.28 → 0.1.30

data/src/opengl.cpp

@@ -8,10 +8,10 @@ namespace Rays
 {
 
 
-	GLenum
-	OpenGL_get_error ()
+	bool
+	OpenGL_has_error ()
 	{
-		return glGetError();
+		return glGetError() != GL_NO_ERROR;
 	}
 
 	static String
@@ -24,12 +24,12 @@ namespace Rays
 			case GL_INVALID_VALUE:     return "GL_INVALID_VALUE";
 			case GL_INVALID_OPERATION: return "GL_INVALID_OPERATION";
 			case GL_OUT_OF_MEMORY:     return "GL_OUT_OF_MEMORY";
-			#ifndef IOS
+			#if !defined(GL_VERSION_3_0) && !defined(GL_ES_VERSION_2_0)
 				case GL_STACK_OVERFLOW:  return "GL_STACK_OVERFLOW";
 				case GL_STACK_UNDERFLOW: return "GL_STACK_UNDERFLOW";
+				case GL_INVALID_FRAMEBUFFER_OPERATION: return "GL_INVALID_FRAMEBUFFER_OPERATION";
+				case GL_TABLE_TOO_LARGE: return "GL_TABLE_TOO_LARGE";
 			#endif
-			case 0x506:                return "GL_INVALID_FRAMEBUFFER_OPERATION";
-			case 0x8031:               return "GL_TABLE_TOO_LARGE";
 			default:                   return "UNKNOWN ERROR";
 		}
 	}
@@ -37,10 +37,23 @@ namespace Rays
 	void
 	OpenGL_check_error (const char* file, int line)
 	{
-		GLenum e = OpenGL_get_error();
+		GLenum e = glGetError();
 		if (e != GL_NO_ERROR)
 			opengl_error(file, line, "OpenGL error %s", get_error_name(e).c_str());
 	}
 
+	void
+	OpenGL_check_error (const char* file, int line, const char* format, ...)
+	{
+		GLenum e = glGetError();
+		if (e != GL_NO_ERROR)
+		{
+			XOT_STRINGF(format, s);
+			opengl_error(
+				file, line,
+				"OpenGL error %s: %s", get_error_name(e).c_str(), s.c_str());
+		}
+	}
+
 
 }// Rays

data/src/opengl.h

@@ -22,13 +22,15 @@ namespace Rays
 {
 
 
-	void OpenGL_set_context (Context context);
+	void    OpenGL_set_context (Context context);
 
 	Context OpenGL_get_context ();
 
-	GLenum OpenGL_get_error ();
+	bool    OpenGL_has_error ();
 
-	void OpenGL_check_error (const char* file, int line);
+	void    OpenGL_check_error (const char* file, int line);
+
+	void    OpenGL_check_error (const char* file, int line, const char* format, ...);
 
 
 }// Rays

data/src/osx/font.mm

@@ -104,8 +104,6 @@ namespace Rays
 
 		CGRect rect = CGRectMake(x, context_height - height - y, width, height);
 		CGContextClearRect(context, rect);
-		//CGContextSetRGBFillColor(context, 0, 0, 0, 1);
-		//CGContextFillRect(context, rect);
 		CGContextSetRGBFillColor(context, 1, 1, 1, 1);
 
 		CGContextSaveGState(context);

data/src/osx/opengl.mm

@@ -29,8 +29,23 @@ namespace Rays
 		static Context context = NULL;
 		if (!context)
 		{
-			NSOpenGLPixelFormat* pf  = [NSOpenGLView defaultPixelFormat];
-			context = [[NSOpenGLContext alloc] initWithFormat: pf shareContext: nil];
+			NSOpenGLPixelFormatAttribute attribs[] =
+			{
+				//NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion3_2Core,
+				//NSOpenGLPFAAccelerated, NSOpenGLPFANoRecovery,
+				//NSOpenGLPFADoubleBuffer,
+				NSOpenGLPFAAllowOfflineRenderers,
+				NSOpenGLPFAColorSize, 32,
+				NSOpenGLPFADepthSize, 32,
+				//NSOpenGLPFAMultisample,
+				//NSOpenGLPFASampleBuffers, 1,
+				//NSOpenGLPFASamples, 4,
+				0
+			};
+			NSOpenGLPixelFormat* pf = [[[NSOpenGLPixelFormat alloc]
+				initWithAttributes: attribs] autorelease];
+			context = [[[NSOpenGLContext alloc]
+				initWithFormat: pf shareContext: nil] autorelease];
 		}
 		return context;
 	}

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,175 +321,234 @@ 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);
+			cleanup();
 
 			ShaderProgram_deactivate();
 		}
 
 		private:
 
+			std::vector<GLint> locations;
+
+			std::vector<GLuint> buffers;
+
 			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);
-			}
-
-			void apply_texture_uniforms (
-				const ShaderProgram& program, const TextureInfo* texinfo)
-			{
-				if (!texinfo || !*texinfo) return;
-
-				const Texture& texture = texinfo->texture;
+				if (!texinfo || !texture || !*texture) return;
 
-				GLint texture_loc =
-					glGetUniformLocation(program.id(), UNIFORM_TEXTURE);
-				if (texture_loc >= 0)
+				for (const auto& name : names.uniform_texcoord_min_names)
 				{
-					glActiveTexture(GL_TEXTURE0);
-					glBindTexture(GL_TEXTURE_2D, texture.id());
-
-					glUniform1i(texture_loc, 0);
-					OpenGL_check_error(__FILE__, __LINE__);
+					apply_uniform(program, name, [&](GLint loc) {
+						Point min = texcoord_matrix * texinfo->texcoord_min;
+						glUniform3fv(loc, 1, min.array);
+					});
 				}
-
-				GLint size_loc =
-					glGetUniformLocation(program.id(), UNIFORM_TEXTURE_SIZE);
-				if (size_loc >= 0)
+				for (const auto& name : names.uniform_texcoord_max_names)
 				{
-					glUniform2f(
-						size_loc, texture.reserved_width(), texture.reserved_height());
-					OpenGL_check_error(__FILE__, __LINE__);
+					apply_uniform(program, name, [&](GLint loc) {
+						Point max = texcoord_matrix * texinfo->texcoord_max;
+						glUniform3fv(loc, 1, max.array);
+					});
 				}
-
-				GLint min_loc =
-					glGetUniformLocation(program.id(), UNIFORM_TEXCOORD_MIN);
-				if (min_loc >= 0)
+				for (const auto& name : names.uniform_texcoord_offset_names)
 				{
-					glUniform2fv(min_loc, 1, texinfo->texcoord_min.array);
-					OpenGL_check_error(__FILE__, __LINE__);
+					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__);
+
+						glBindTexture(GL_TEXTURE_2D, texture->id());
+						OpenGL_check_error(__FILE__, __LINE__);
+
+						glUniform1i(loc, 0);
+					});
 				}
+			}
 
-				GLint max_loc =
-					glGetUniformLocation(program.id(), UNIFORM_TEXCOORD_MAX);
-				if (max_loc >= 0)
+			void apply_attributes (
+				const ShaderProgram& program, const ShaderBuiltinVariableNames& names,
+				const Coord3* points, size_t npoints, const Coord3* texcoords,
+				const Color& color)
+			{
+				assert(points && npoints > 0);
+
+				apply_attribute(
+					program, names.attribute_position_names,
+					points, npoints);
+
+				apply_attribute(
+					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(
+					program, names.attribute_color_names,
+					(const Coord4*) &colors[0], npoints);
+#else
+				for (const auto& name : names.attribute_color_names)
 				{
-					glUniform2fv(max_loc, 1, texinfo->texcoord_max.array);
-					OpenGL_check_error(__FILE__, __LINE__);
+					apply_attribute(program, name, [&](GLint loc) {
+						glVertexAttrib4fv(loc, color.array);
+					});
 				}
+#endif
 			}
 
-			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>
+			void apply_attribute(
+				const ShaderProgram& program, const auto& names,
+				const CoordN* values, size_t nvalues)
 			{
-				assert(points && npoints >= 0 && texcoords);
+				GLuint buffer = 0;
+				for (const auto& name : names)
+				{
+					#ifndef IOS
+						if (buffer == 0)
+						{
+							buffer = create_and_bind_buffer(
+								GL_ARRAY_BUFFER, values, sizeof(CoordN) * nvalues);
+							values = 0;
+						}
+					#endif
+
+					apply_attribute(program, name, [&](GLint loc) {
+						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, 0, values);
+
+						locations.push_back(loc);
+					});
+				}
 
-				glEnableVertexAttribArray(a_position);
-				glVertexAttribPointer(
-					a_position, Coord3::SIZE, get_gl_type<coord>(),
-					GL_FALSE, sizeof(Coord3), points);
+				glBindBuffer(GL_ARRAY_BUFFER, 0);
 				OpenGL_check_error(__FILE__, __LINE__);
+			}
 
-				glEnableVertexAttribArray(a_texcoord);
-				glVertexAttribPointer(
-					a_texcoord, Coord3::SIZE, get_gl_type<coord>(),
-					GL_FALSE, sizeof(Coord3), texcoords);
-				OpenGL_check_error(__FILE__, __LINE__);
+			void apply_attribute (
+				const ShaderProgram& program, const char* name,
+				std::function<void(GLint)> apply_fun)
+			{
+				GLint loc = glGetAttribLocation(program.id(), name);
+				if (loc < 0) return;
 
-				glVertexAttrib4fv(a_color, color.array);
+				apply_fun(loc);
+				OpenGL_check_error(__FILE__, __LINE__);
 			}
 
-			void cleanup_vertices (GLint a_position, GLint a_texcoord)
+			void apply_uniform (
+				const ShaderProgram& program, const char* name,
+				std::function<void(GLint)> apply_fun)
 			{
-				glDisableVertexAttribArray(a_position);
-				glDisableVertexAttribArray(a_texcoord);
+				GLint loc = glGetUniformLocation(program.id(), name);
+				if (loc < 0) return;
+
+				apply_fun(loc);
 				OpenGL_check_error(__FILE__, __LINE__);
 			}
 
-			void activate_texture (const Texture* texture)
+			void draw_indices (
+				GLenum mode, const uint* indices, size_t nindices, size_t npoints)
 			{
-				if (!texture)
+				if (!indices || nindices <= 0)
 				{
-					glDisable(GL_TEXTURE_2D);
-					return;
+					default_indices.resize(npoints);
+					indices  = default_indices.get();
+					nindices = npoints;
 				}
 
-				if (!*texture)
-					argument_error(__FILE__, __LINE__, "invalid texture.");
+				#ifdef IOS
+					glDrawElements(mode, (GLsizei) nindices, GL_UNSIGNED_INT, indices);
+					OpenGL_check_error(__FILE__, __LINE__);
+				#else
+					create_and_bind_buffer(
+						GL_ELEMENT_ARRAY_BUFFER, indices, sizeof(uint) * nindices);
 
-				GLuint id = texture->id();
-				if (id != get_current_texture_id())
-					glBindTexture(GL_TEXTURE_2D, id);
+					glDrawElements(mode, (GLsizei) nindices, GL_UNSIGNED_INT, 0);
+					OpenGL_check_error(__FILE__, __LINE__);
 
-				glEnable(GL_TEXTURE_2D);
+					glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+					OpenGL_check_error(__FILE__, __LINE__);
+				#endif
 			}
 
-			GLuint get_current_texture_id ()
+			GLuint create_and_bind_buffer (
+				GLenum target, const void* data, GLsizeiptr size)
 			{
-				GLint id = 0;
-				glGetIntegerv(GL_TEXTURE_BINDING_2D, &id);
-				return (GLuint) id;
+				GLuint id = 0;
+				glGenBuffers(1, &id);
+				OpenGL_check_error(__FILE__, __LINE__);
+
+				buffers.push_back(id);
+
+				glBindBuffer(target, id);
+				OpenGL_check_error(__FILE__, __LINE__);
+
+				glBufferData(target, size, data, GL_STREAM_DRAW);
+				OpenGL_check_error(__FILE__, __LINE__);
+
+				return id;
 			}
 
-			void deactivate_texture (const Texture* texture)
+			void cleanup ()
 			{
-				if (!texture) return;
+				for (auto loc : locations)
+				{
+					glDisableVertexAttribArray(loc);
+					OpenGL_check_error(__FILE__, __LINE__);
+				}
+
+				glDeleteBuffers((GLsizei) buffers.size(), &buffers[0]);
+				OpenGL_check_error(__FILE__, __LINE__);
 
-				glDisable(GL_TEXTURE_2D);
+				locations.clear();
+				buffers.clear();
 			}
 
 	};// Painter::Data
@@ -530,7 +563,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 +991,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 +1168,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);
 	}