rays 0.3.11 → 0.3.12

data/src/opengl/sdl/opengl.cpp

@@ -60,6 +60,10 @@ namespace Rays
 	static OffscreenContext*
 	get_opengl_offscreen_context ()
 	{
+#ifdef WASM
+		return NULL;
+#endif
+
 		static OffscreenContext* context = NULL;
 		if (!context) context = new OffscreenContext();
 		return context;
@@ -96,6 +100,8 @@ namespace Rays
 	activate_offscreen_context ()
 	{
 		const auto* c = get_opengl_offscreen_context();
+		if (!c) return;
+
 		SDL_GL_MakeCurrent(c->window, c->context);
 	}
 

data/src/opengl/shader.cpp

@@ -14,15 +14,17 @@ namespace Rays
 
 	#define A_POSITION        (names.attribute_position_names[0])
 	#define A_TEXCOORD        (names.attribute_texcoord_names[0])
+	#define A_TEXCOORD_MIN    (names.attribute_texcoord_min_names[0])
+	#define A_TEXCOORD_MAX    (names.attribute_texcoord_max_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_TEXCOORD_MIN    (names.varying_texcoord_min_name)
+	#define V_TEXCOORD_MAX    (names.varying_texcoord_max_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_TEXCOORD_PIXEL  (names.uniform_texcoord_pixel_names[0])
 	#define U_TEXTURE         (names.uniform_texture_names[0])
 
 
@@ -34,22 +36,20 @@ namespace Rays
 
 		std::unique_ptr<ShaderProgram> program;
 
-		std::unique_ptr<ShaderEnv> env;
+		ShaderEnv env;
 
 		Data (
 			const char* fragment_shader_source,
 			const char*   vertex_shader_source,
 			ShaderEnv* env_)
+		:	env(env_ ? *env_ : DEFAULT_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),
 				ShaderSource(GL_FRAGMENT_SHADER, fragment_shader_source),
-				env_ ? ShaderEnv_get_flags(*env_) : 0));
+				env));
 		}
 
 		ShaderSource make_vertex_shader_source (const char* source)
@@ -57,10 +57,7 @@ namespace Rays
 			if (source)
 				return ShaderSource(GL_VERTEX_SHADER, source);
 			else
-			{
-				return ShaderEnv_get_default_vertex_shader_source(
-					env ? env.get() : &DEFAULT_ENV);
-			}
+				return ShaderEnv_get_default_vertex_shader_source(&env);
 		}
 
 	};// Shader::Data
@@ -86,17 +83,17 @@ namespace Rays
 			ShaderEnv_get_builtin_variable_names(DEFAULT_ENV);
 		return Shader(
 			"varying vec4 "      + V_TEXCOORD + ";\n"
+			"varying vec3 "      + V_TEXCOORD_MIN + ";\n"
+			"varying vec3 "      + V_TEXCOORD_MAX + ";\n"
 			"varying vec4 "      + V_COLOR + ";\n"
-			"uniform vec3 "      + U_TEXCOORD_MIN + ";\n"
-			"uniform vec3 "      + U_TEXCOORD_MAX + ";\n"
-			"uniform vec3 "      + U_TEXCOORD_OFFSET + ";\n"
+			"uniform vec3 "      + U_TEXCOORD_PIXEL + ";\n"
 			"uniform sampler2D " + U_TEXTURE + ";\n"
 			"void main ()\n"
 			"{\n"
 			"  vec2 _rays_texcoord = clamp(" +
 				V_TEXCOORD     + ".xy, " +
-				U_TEXCOORD_MIN + ".xy, " +
-				U_TEXCOORD_MAX + ".xy - " + U_TEXCOORD_OFFSET + ".xy);\n"
+				V_TEXCOORD_MIN + ".xy, " +
+				V_TEXCOORD_MAX + ".xy - " + U_TEXCOORD_PIXEL + ".xy);\n"
 			"  vec4 _rays_color    = texture2D(" + U_TEXTURE + ", _rays_texcoord);\n"
 			"  gl_FragColor        = " + V_COLOR + " * _rays_color;\n"
 			"}\n");
@@ -109,14 +106,14 @@ namespace Rays
 			ShaderEnv_get_builtin_variable_names(DEFAULT_ENV);
 		return Shader(
 			"varying vec4 "      + V_TEXCOORD + ";\n"
+			"varying vec3 "      + V_TEXCOORD_MIN + ";\n"
+			"varying vec3 "      + V_TEXCOORD_MAX + ";\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 _rays_min      = " + U_TEXCOORD_MIN + ".xy;\n"
-			"  vec2 _rays_len      = " + U_TEXCOORD_MAX + ".xy - _rays_min;\n"
+			"  vec2 _rays_min      = " + V_TEXCOORD_MIN + ".xy;\n"
+			"  vec2 _rays_len      = " + V_TEXCOORD_MAX + ".xy - _rays_min;\n"
 			"  vec2 _rays_texcoord = mod(" + V_TEXCOORD + ".xy - _rays_min, _rays_len) + _rays_min;\n"
 			"  vec4 _rays_color    = texture2D(" + U_TEXTURE + ", _rays_texcoord);\n"
 			"  gl_FragColor        = " + V_COLOR + " * _rays_color;\n"
@@ -135,7 +132,7 @@ namespace Rays
 			"void main ()\n"
 			"{\n"
 			"  vec4 _rays_col = texture2D(" + U_TEXTURE + ", " + V_TEXCOORD + ".xy);\n"
-			#if defined(OSX) || defined(IOS)
+			#if defined(OSX) || defined(IOS) || defined(LINUX)
 			// restore premultiplied rgb values
 			"  vec3 _rays_rgb = _rays_col.a != 0.0 ? _rays_col.rgb / _rays_col.a : _rays_col.rgb;\n"
 			"  gl_FragColor   = " + V_COLOR + " * vec4(_rays_rgb, _rays_col.a);\n"
@@ -157,8 +154,7 @@ namespace Rays
 	const ShaderBuiltinVariableNames&
 	Shader_get_builtin_variable_names (const Shader& shader)
 	{
-		return ShaderEnv_get_builtin_variable_names(
-			shader.self->env ? *shader.self->env : DEFAULT_ENV);
+		return ShaderEnv_get_builtin_variable_names(shader.self->env);
 	}
 
 	const Shader&
@@ -395,22 +391,26 @@ namespace Rays
 		String make_default_vertex_shader_source_code ()
 		{
 			return
-				"attribute vec3 " + A_POSITION + ";\n"
-				"attribute vec3 " + A_TEXCOORD + ";\n"
+				"attribute vec4 " + A_POSITION + ";\n"
+				"attribute vec4 " + A_TEXCOORD + ";\n"
+				"attribute vec3 " + A_TEXCOORD_MIN + ";\n"
+				"attribute vec3 " + A_TEXCOORD_MAX + ";\n"
 				"attribute vec4 " + A_COLOR + ";\n"
 				"varying vec4 "   + V_POSITION + ";\n"
 				"varying vec4 "   + V_TEXCOORD + ";\n"
+				"varying vec3 "   + V_TEXCOORD_MIN + ";\n"
+				"varying vec3 "   + V_TEXCOORD_MAX + ";\n"
 				"varying vec4 "   + V_COLOR + ";\n"
 				"uniform mat4 "   + U_POSITION_MATRIX + ";\n"
 				"uniform mat4 "   + U_TEXCOORD_MATRIX + ";\n"
 				"void main ()\n"
 				"{\n"
-				"  vec4 _rays_pos      = vec4(" + A_POSITION + ", 1.0);\n"
-				"  vec4 _rays_texcoord = vec4(" + A_TEXCOORD + ", 1.0);\n"
-				"  " + V_POSITION +  " = _rays_pos;\n"
-				"  " + V_TEXCOORD +  " = " + U_TEXCOORD_MATRIX + " * _rays_texcoord;\n"
-				"  " + V_COLOR    +  " = " + A_COLOR + ";\n"
-				"  gl_Position         = " + U_POSITION_MATRIX + " * _rays_pos;\n"
+				"  " + V_POSITION     + " = " + A_POSITION + ";\n"
+				"  " + V_TEXCOORD     + " = " + U_TEXCOORD_MATRIX + " * " + A_TEXCOORD + ";\n"
+				"  " + V_TEXCOORD_MIN + " = " + A_TEXCOORD_MIN + ";\n"
+				"  " + V_TEXCOORD_MAX + " = " + A_TEXCOORD_MAX + ";\n"
+				"  " + V_COLOR        + " = " + A_COLOR + ";\n"
+				"  gl_Position            = " + U_POSITION_MATRIX + " * " + A_POSITION + ";\n"
 				"}\n";
 		}
 
@@ -449,23 +449,34 @@ namespace Rays
 	ShaderEnv::ShaderEnv (
 		const NameList& a_position_names,
 		const NameList& a_texcoord_names,
+		const NameList& a_texcoord_min_names,
+		const NameList& a_texcoord_max_names,
 		const NameList& a_color_names,
 		const char*     v_position_name,
 		const char*     v_texcoord_name,
+		const char*     v_texcoord_min_name,
+		const char*     v_texcoord_max_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_texcoord_pixel_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,
+				a_position_names,
+				a_texcoord_names,
+				a_texcoord_min_names,
+				a_texcoord_max_names,
+				a_color_names,
+				v_position_name,
+				v_texcoord_name,
+				v_texcoord_min_name,
+				v_texcoord_max_name,
+				v_color_name,
+				u_position_matrix_names,
+				u_texcoord_matrix_names,
+				u_texcoord_pixel_names,
 				u_texture_names),
 			flags))
 	{
@@ -502,40 +513,46 @@ namespace Rays
 	ShaderBuiltinVariableNames::ShaderBuiltinVariableNames (
 		const ShaderEnv::NameList& a_position,
 		const ShaderEnv::NameList& a_texcoord,
+		const ShaderEnv::NameList& a_texcoord_min,
+		const ShaderEnv::NameList& a_texcoord_max,
 		const ShaderEnv::NameList& a_color,
 		const char* v_position,
 		const char* v_texcoord,
+		const char* v_texcoord_min,
+		const char* v_texcoord_max,
 		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_texcoord_pixel,
 		const ShaderEnv::NameList& u_texture)
 	:	attribute_position_names(a_position),
 		attribute_texcoord_names(a_texcoord),
+		attribute_texcoord_min_names(a_texcoord_min),
+		attribute_texcoord_max_names(a_texcoord_max),
 		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"),
+		varying_position_name(    v_position     ? v_position     : "v_Position"),
+		varying_texcoord_name(    v_texcoord     ? v_texcoord     : "v_TexCoord"),
+		varying_texcoord_min_name(v_texcoord_min ? v_texcoord_min : "v_TexCoordMin"),
+		varying_texcoord_max_name(v_texcoord_max ? v_texcoord_max : "v_TexCoordMax"),
+		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_texcoord_pixel_names(u_texcoord_pixel),
 		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_texcoord_min_names,  "attribute_texcoord_min",  "a_TexCoordMin");
+		validate_names(&attribute_texcoord_max_names,  "attribute_texcoord_max",  "a_TexCoordMax");
 		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_texcoord_min_name,       "varying_texcoord_min");
+		validate_name(varying_texcoord_max_name,       "varying_texcoord_max");
 		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_texcoord_pixel_names,  "uniform_texcoord_pixel",  "u_TexCoordPixel");
 		validate_names(&uniform_texture_names,         "uniform_texture",         "u_Texture");
 	}
 

data/src/opengl/shader.h

@@ -20,31 +20,35 @@ namespace Rays
 
 		ShaderEnv::NameList attribute_position_names;
 		ShaderEnv::NameList attribute_texcoord_names;
+		ShaderEnv::NameList attribute_texcoord_min_names;
+		ShaderEnv::NameList attribute_texcoord_max_names;
 		ShaderEnv::NameList attribute_color_names;
 
 		String varying_position_name;
 		String varying_texcoord_name;
+		String varying_texcoord_min_name;
+		String varying_texcoord_max_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_texcoord_pixel_names;
 		ShaderEnv::NameList uniform_texture_names;
 
 		ShaderBuiltinVariableNames (
 			const ShaderEnv::NameList& attribute_position_names,
 			const ShaderEnv::NameList& attribute_texcoord_names,
+			const ShaderEnv::NameList& attribute_texcoord_min_names,
+			const ShaderEnv::NameList& attribute_texcoord_max_names,
 			const ShaderEnv::NameList& attribute_color_names,
 			const char* varying_position_name,
 			const char* varying_texcoord_name,
+			const char* varying_texcoord_min_name,
+			const char* varying_texcoord_max_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_texcoord_pixel_names,
 			const ShaderEnv::NameList& uniform_texture_names);
 
 	};// ShaderBuiltinVariableNames

data/src/opengl/shader_program.cpp

@@ -5,10 +5,10 @@
 #include <vector>
 #include <memory>
 #include <algorithm>
-#include "rays/shader.h"
 #include "rays/exception.h"
 #include "../painter.h"
 #include "texture.h"
+#include "shader.h"
 #include "shader_source.h"
 
 
@@ -253,12 +253,12 @@ namespace Rays
 	struct ShaderProgram::Data
 	{
 
-		GLuint id  = 0;
-
-		uint flags = 0;
+		GLuint id = 0;
 
 		ShaderSource vertex, fragment;
 
+		ShaderEnv env;
+
 		UniformList uniform_values, uniform_textures;
 
 		mutable bool linked = false, applied = false;
@@ -322,6 +322,18 @@ namespace Rays
 			attach_shader(vertex);
 			attach_shader(fragment);
 
+#ifdef OSX
+			// OpenGL compatibility profile historically aliases attribute
+			// location 0 with gl_Vertex; some drivers refuse to draw when
+			// location 0 is not enabled. Pin position there as a safeguard.
+			for (const auto& name :
+				ShaderEnv_get_builtin_variable_names(env).attribute_position_names)
+			{
+				glBindAttribLocation(id, 0, name.c_str());
+				OpenGL_check_error(__FILE__, __LINE__);
+			}
+#endif
+
 			glLinkProgram(id);
 			OpenGL_check_error(__FILE__, __LINE__);
 
@@ -370,7 +382,8 @@ namespace Rays
 			if (applied) return;
 			applied = true;
 
-			bool ignore_no_loc = flags & ShaderEnv::IGNORE_NO_UNIFORM_LOCATION_ERROR;
+			bool ignore_no_loc =
+				ShaderEnv_get_flags(env) & ShaderEnv::IGNORE_NO_UNIFORM_LOCATION_ERROR;
 
 			for (size_t i = 0; i < uniform_values.size(); ++i)
 				uniform_values[i].apply(i, program, ignore_no_loc);
@@ -406,11 +419,12 @@ namespace Rays
 
 
 	ShaderProgram::ShaderProgram (
-		const ShaderSource& vertex, const ShaderSource& fragment, uint flags)
+		const ShaderSource& vertex, const ShaderSource& fragment,
+		const ShaderEnv& env)
 	{
 		self->vertex   = vertex;
 		self->fragment = fragment;
-		self->flags    = flags;
+		self->env      = env;
 	}
 
 	ShaderProgram::~ShaderProgram ()

data/src/opengl/shader_program.h

@@ -7,6 +7,7 @@
 #include <xot/pimpl.h>
 #include "rays/defs.h"
 #include "rays/coord.h"
+#include "rays/shader.h"
 #include "opengl.h"
 
 
@@ -28,7 +29,7 @@ namespace Rays
 			ShaderProgram (
 				const ShaderSource& vertex,
 				const ShaderSource& fragment,
-				uint flags);
+				const ShaderEnv& env);
 
 			~ShaderProgram ();
 

data/src/opengl/shader_source.cpp

@@ -58,7 +58,7 @@ namespace Rays
 
 		const char* add_headers (GLenum type, const char* source, String* buffer)
 		{
-#ifdef IOS
+#if defined(IOS) || defined(WASM)
 			if (type == GL_FRAGMENT_SHADER)
 			{
 				static const std::regex PRECISION(R"(^\s*precision\s+\w+p\s+float\s*;)");
@@ -69,9 +69,7 @@ namespace Rays
 					source  = buffer->c_str();
 				}
 			}
-#endif
-
-#ifndef IOS
+#else
 			static const std::regex VERSION(R"(^\s*#\s*version\s+\d+)");
 			if (!std::regex_search(source, VERSION))
 			{

data/src/opengl/texture.cpp

@@ -228,6 +228,12 @@ namespace Rays
 		self->modified    = true;
 	}
 
+	GLuint
+	Texture_get_id (const Texture& texture)
+	{
+		return texture.self->id;
+	}
+
 
 	Texture::Texture ()
 	{
@@ -318,12 +324,6 @@ namespace Rays
 		return self->smooth;
 	}
 
-	GLuint
-	Texture_get_id (const Texture& texture)
-	{
-		return texture.self->id;
-	}
-
 	void
 	Texture::set_modified (bool modified)
 	{
@@ -351,5 +351,17 @@ namespace Rays
 		return !operator bool();
 	}
 
+	bool
+	operator == (const Texture& lhs, const Texture& rhs)
+	{
+		return lhs.self->id == rhs.self->id;
+	}
+
+	bool
+	operator != (const Texture& lhs, const Texture& rhs)
+	{
+		return !operator==(lhs, rhs);
+	}
+
 
 }// Rays

data/src/osx/bitmap.mm

@@ -263,7 +263,7 @@ namespace Rays
 
 		NSString* path = [NSString stringWithUTF8String: path_];
 		NSBitmapImageRep* imagerep =
-			[NSBitmapImageRep imageRepWithContentsOfFile: path];
+			(NSBitmapImageRep*) [NSBitmapImageRep imageRepWithContentsOfFile: path];
 		if (!imagerep)
 			rays_error(__FILE__, __LINE__, "[NSBitmapImageRep imageRepWithContentsOfFile] failed.");