rays 0.1.46 → 0.1.48

data/src/painter.cpp

@@ -49,6 +49,8 @@ namespace Rays
 
 		coord stroke_width;
 
+		float stroke_outset;
+
 		CapType stroke_cap;
 
 		JoinType stroke_join;
@@ -63,6 +65,12 @@ namespace Rays
 
 		Font font;
 
+		Image texture;
+
+		TexCoordMode texcoord_mode;
+
+		TexCoordWrap texcoord_wrap;
+
 		Shader shader;
 
 		void init ()
@@ -71,13 +79,17 @@ namespace Rays
 			colors[FILL]   .reset(1, 1);
 			colors[STROKE] .reset(1, 0);
 			stroke_width   = 0;
+			stroke_outset  = 0;
 			stroke_cap     = CAP_DEFAULT;
 			stroke_join    = JOIN_DEFAULT;
 			miter_limit    = JOIN_DEFAULT_MITER_LIMIT;
 			nsegment       = 0;
 			blend_mode     = BLEND_NORMAL;
 			clip           .reset(-1);
-			font           = default_font();
+			font           = get_default_font();
+			texture        = Image();
+			texcoord_mode  = TEXCOORD_IMAGE;
+			texcoord_wrap  = TEXCOORD_CLAMP;
 			shader         = Shader();
 		}
 
@@ -94,7 +106,7 @@ namespace Rays
 
 		const Texture& texture;
 
-		Point texcoord_min, texcoord_max;
+		Point min, max;
 
 		TextureInfo (
 			const Texture& texture,
@@ -102,16 +114,16 @@ namespace Rays
 			coord x_max, coord y_max)
 		:	texture(texture)
 		{
-			texcoord_min.reset(x_min, y_min);
-			texcoord_max.reset(x_max, y_max);
+			min.reset(x_min, y_min);
+			max.reset(x_max, y_max);
 		}
 
 		operator bool () const
 		{
 			return
 				texture &&
-				texcoord_min.x < texcoord_max.x &&
-				texcoord_min.y < texcoord_max.y;
+				min.x < max.x &&
+				min.y < max.y;
 		}
 
 		bool operator ! () const
@@ -307,13 +319,14 @@ namespace Rays
 			return true;
 		}
 
-		void draw_polygon (
-			GLenum mode, const Color& color,
+		void draw (
+			GLenum mode, const Color* color,
 			const Coord3* points,           size_t npoints,
 			const uint*   indices   = NULL, size_t nindices = 0,
+			const Color*  colors    = NULL,
 			const Coord3* texcoords = NULL,
-			const Shader& default_shader = Shader_get_default_shader_for_shape(),
-			const TextureInfo* texinfo = NULL)
+			const TextureInfo* texinfo = NULL,
+			const Shader* shader       = NULL)
 		{
 			if (!points || npoints <= 0)
 				argument_error(__FILE__, __LINE__);
@@ -321,15 +334,18 @@ namespace Rays
 			if (!painting)
 				invalid_state_error(__FILE__, __LINE__, "'painting' should be true.");
 
-			const Shader& shader         = state.shader ? state.shader : default_shader;
-			const ShaderProgram* program = Shader_get_program(shader);
+			std::unique_ptr<TextureInfo> ptexinfo;
+			texinfo = setup_texinfo(texinfo, ptexinfo);
+			shader  = setup_shader(shader, texinfo);
+
+			const ShaderProgram* program = Shader_get_program(*shader);
 			if (!program || !*program) return;
 
 			ShaderProgram_activate(*program);
 
-			const auto& names = Shader_get_builtin_variable_names(shader);
+			const auto& names = Shader_get_builtin_variable_names(*shader);
 			apply_builtin_uniforms(*program, names, texinfo);
-			apply_attributes(*program, names, points, npoints, texcoords, color);
+			apply_attributes(*program, names, points, npoints, texcoords, color, colors);
 			draw_indices(mode, indices, nindices, npoints);
 			cleanup();
 
@@ -342,6 +358,27 @@ namespace Rays
 
 			std::vector<GLuint> buffers;
 
+			const TextureInfo* setup_texinfo (const TextureInfo* texinfo, auto& ptr)
+			{
+				if (texinfo) return texinfo;
+
+				const Texture* tex =
+					state.texture ? &Image_get_texture(state.texture) : NULL;
+				if (!tex) return NULL;
+
+				ptr.reset(new TextureInfo(*tex, 0, 0, tex->width(), tex->height()));
+				return ptr.get();
+			}
+
+			const Shader* setup_shader (const Shader* shader, bool for_texture)
+			{
+				if (state.shader) return &state.shader;
+				if (shader)       return shader;
+				return for_texture
+					?	&Shader_get_default_shader_for_texture(state.texcoord_wrap)
+					:	&Shader_get_default_shader_for_shape();
+			}
+
 			void apply_builtin_uniforms (
 				const ShaderProgram& program, const ShaderBuiltinVariableNames& names,
 				const TextureInfo* texinfo)
@@ -351,9 +388,10 @@ namespace Rays
 				Matrix texcoord_matrix(1);
 				if (texture && *texture)
 				{
+					bool normal = state.texcoord_mode == TEXCOORD_NORMAL;
 					texcoord_matrix.scale(
-						1.0 / texture->reserved_width(),
-						1.0 / texture->reserved_height());
+						(normal ? texture->width()  : 1.0) / texture->reserved_width(),
+						(normal ? texture->height() : 1.0) / texture->reserved_height());
 				}
 
 				for (const auto& name : names.uniform_position_matrix_names)
@@ -371,24 +409,27 @@ namespace Rays
 
 				if (!texinfo || !texture || !*texture) return;
 
+				coord tw = texture->reserved_width();
+				coord th = texture->reserved_height();
+				Point min(texinfo->min.x / tw, texinfo->min.y / th);
+				Point max(texinfo->max.x / tw, texinfo->max.y / th);
+				Point offset(          1 / tw,              1 / th);
+
 				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);
 					});
 				}
@@ -409,9 +450,10 @@ namespace Rays
 			void apply_attributes (
 				const ShaderProgram& program, const ShaderBuiltinVariableNames& names,
 				const Coord3* points, size_t npoints, const Coord3* texcoords,
-				const Color& color)
+				const Color* color, const Color* colors)
 			{
-				assert(points && npoints > 0);
+				assert(npoints > 0);
+				assert(!!color != !!colors);
 
 				apply_attribute(
 					program, names.attribute_position_names,
@@ -421,21 +463,30 @@ namespace Rays
 					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)
+				if (colors)
 				{
-					apply_attribute(program, name, [&](GLint loc) {
-						glVertexAttrib4fv(loc, color.array);
-					});
+					apply_attribute(
+						program, names.attribute_color_names,
+						colors, npoints);
 				}
+				else if (color)
+				{
+#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)
+					{
+						apply_attribute(program, name, [&](GLint loc) {
+							glVertexAttrib4fv(loc, color->array);
+						});
+					}
 #endif
+				}
 			}
 
 			template <typename CoordN>
@@ -554,52 +605,27 @@ namespace Rays
 	};// Painter::Data
 
 
-	static void
-	draw_polygon (
-		Painter* painter,
-		const GLenum* modes,
-		coord offset_x, coord offset_y,
-		bool nofill, bool nostroke,
-		const Coord3* points,           size_t npoints,
-		const uint*   indices   = NULL, size_t nindices = 0,
-		const Coord3* texcoords = NULL,
-		const Shader& default_shader = Shader_get_default_shader_for_shape(),
-		const TextureInfo* texinfo = NULL)
+	void
+	Painter_draw (
+		Painter* painter, GLenum mode, const Color& color,
+		const Coord3* points,  size_t npoints,
+		const uint*   indices, size_t nindices,
+		const Coord3* texcoords)
 	{
-		assert(painter);
-
-		bool offset = offset_x != 0 || offset_y != 0;
-		if (offset)
-		{
-			painter->push_matrix();
-			painter->translate(offset_x, offset_y);
-		}
-
-		Color color;
-		for (int type = COLOR_TYPE_BEGIN; type < COLOR_TYPE_END; ++type)
-		{
-			if ((nofill && type == FILL) || (nostroke && type == STROKE))
-				continue;
-
-			if (!painter->self->get_color(&color, (ColorType) type))
-				continue;
-
-			painter->self->draw_polygon(
-				modes[type], color, points, npoints, indices, nindices, texcoords,
-				default_shader, texinfo);
-		}
-
-		if (offset)
-			painter->pop_matrix();
+		painter->self->draw(
+			mode, &color, points, npoints, indices, nindices, NULL, texcoords);
 	}
 
 	void
-	Painter_draw_polygon (
-		Painter* painter, GLenum mode, const Color& color,
+	Painter_draw (
+		Painter* painter, GLenum mode,
 		const Coord3* points,  size_t npoints,
-		const uint*   indices, size_t nindices)
+		const uint*   indices, size_t nindices,
+		const Color*  colors,
+		const Coord3* texcoords)
 	{
-		painter->self->draw_polygon(mode, color, points, npoints, indices, nindices);
+		painter->self->draw(
+			mode, NULL, points, npoints, indices, nindices, colors, texcoords);
 	}
 
 
@@ -789,33 +815,82 @@ namespace Rays
 		if (Polygon_triangulate(&triangles, polygon))
 		{
 			for (size_t i = 0; i < triangles.size(); i += 3)
-			{
-				painter->self->draw_polygon(
-					GL_LINE_LOOP, invert_color, &triangles[i], 3);
-			}
+				painter->self->draw(GL_LINE_LOOP, &invert_color, &triangles[i], 3);
 		}
 #endif
 	}
 
-	void
-	Painter::polygon (const Polygon& polygon)
+	static void
+	draw_polygon (
+		Painter* painter, const Polygon& polygon,
+		coord x, coord y, coord width = 0, coord height = 0, bool resize = false)
 	{
+		Painter::Data* self = painter->self.get();
+
 		if (!self->painting)
 			invalid_state_error(__FILE__, __LINE__, "painting flag should be true.");
 
 		if (!self->state.has_color())
 			return;
 
+		bool translate = x != 0 || y != 0;
+		Matrix matrix(nullptr);
+		bool backup = false;
+
+		if (translate || resize)
+		{
+			matrix = self->position_matrix;
+			backup = true;
+
+			if (translate)
+				self->position_matrix.translate(x, y);
+
+			if (resize)
+			{
+				const Bounds& b = polygon.bounds();
+				self->position_matrix.scale(width / b.width, height / b.height);
+			}
+		}
+
 		Color color;
 
 		if (self->get_color(&color, FILL))
 		{
-			Polygon_fill(polygon, this, color);
-			debug_draw_triangulation(this, polygon, color);
+			Polygon_fill(polygon, painter, color);
+			debug_draw_triangulation(painter, polygon, color);
 		}
 
 		if (self->get_color(&color, STROKE))
-			Polygon_stroke(polygon, this, color);
+			Polygon_stroke(polygon, painter, color);
+
+		if (backup)
+			self->position_matrix = matrix;
+	}
+
+	void
+	Painter::polygon (const Polygon& polygon, const coord x, coord y)
+	{
+		draw_polygon(this, polygon, x, y);
+	}
+
+	void
+	Painter::polygon (const Polygon& polygon, const Point& position)
+	{
+		draw_polygon(this, polygon, position.x, position.y);
+	}
+
+	void
+	Painter::polygon (
+		const Polygon& polygon, coord x, coord y, coord width, coord height)
+	{
+		draw_polygon(this, polygon, x, y, width, height, true);
+	}
+
+	void
+	Painter::polygon (const Polygon& polygon, const Bounds& bounds)
+	{
+		draw_polygon(
+			this, polygon, bounds.x, bounds.y, bounds.width, bounds.height, true);
 	}
 
 	void
@@ -960,7 +1035,8 @@ namespace Rays
 		Painter* painter, const Image& image,
 		coord src_x, coord src_y, coord src_w, coord src_h,
 		coord dst_x, coord dst_y, coord dst_w, coord dst_h,
-		bool nostroke = false, const Shader* shader = NULL)
+		bool nofill = false, bool nostroke = false,
+		const Shader* shader = NULL)
 	{
 		static const GLenum MODES[] = {GL_TRIANGLE_FAN, GL_LINE_LOOP};
 
@@ -996,12 +1072,19 @@ namespace Rays
 
 		TextureInfo texinfo(texture, src_x, src_y, src_x + src_w, src_y + src_h);
 
-		if (!shader)
-			shader = &Shader_get_default_shader_for_texture();
+		Color color;
+		for (int type = COLOR_TYPE_BEGIN; type < COLOR_TYPE_END; ++type)
+		{
+			if ((nofill && type == FILL) || (nostroke && type == STROKE))
+				continue;
 
-		draw_polygon(
-			painter, MODES, 0, 0, false, nostroke, points, 4, NULL, 0, texcoords,
-			*shader, &texinfo);
+			if (!painter->self->get_color(&color, (ColorType) type))
+				continue;
+
+			painter->self->draw(
+				MODES[type], &color, points, 4, NULL, 0, NULL, texcoords,
+				&texinfo, shader);
+		}
 	}
 
 	void
@@ -1174,7 +1257,7 @@ namespace Rays
 			painter, self->text_image,
 			0, 0, str_w, str_h,
 			x, y, str_w, str_h,
-			true, &Shader_get_shader_for_text());
+			false, true, &Shader_get_shader_for_text());
 
 		debug_draw_text(painter, font, x, y, str_w / density, str_h / density);
 	}
@@ -1310,6 +1393,18 @@ namespace Rays
 		return self->state.stroke_width;
 	}
 
+	void
+	Painter::set_stroke_outset (float outset)
+	{
+		self->state.stroke_outset = outset;
+	}
+
+	float
+	Painter::stroke_outset () const
+	{
+		return self->state.stroke_outset;
+	}
+
 	void
 	Painter::set_stroke_cap (CapType cap)
 	{
@@ -1455,7 +1550,7 @@ namespace Rays
 	{
 		return
 			font.size() == size &&
-			font.name() == (name ? name : default_font().name().c_str());
+			font.name() == (name ? name : get_default_font().name().c_str());
 	}
 
 	void
@@ -1478,6 +1573,48 @@ namespace Rays
 		return self->state.font;
 	}
 
+	void
+	Painter::set_texture (const Image& image)
+	{
+		self->state.texture = image;
+	}
+
+	void
+	Painter::no_texture ()
+	{
+		self->state.texture = Image();
+	}
+
+	const Image&
+	Painter::texture () const
+	{
+		return self->state.texture;
+	}
+
+	void
+	Painter::set_texcoord_mode (TexCoordMode mode)
+	{
+		self->state.texcoord_mode = mode;
+	}
+
+	TexCoordMode
+	Painter::texcoord_mode () const
+	{
+		return self->state.texcoord_mode;
+	}
+
+	void
+	Painter::set_texcoord_wrap (TexCoordWrap wrap)
+	{
+		self->state.texcoord_wrap = wrap;
+	}
+
+	TexCoordWrap
+	Painter::texcoord_wrap () const
+	{
+		return self->state.texcoord_wrap;
+	}
+
 	void
 	Painter::set_shader (const Shader& shader)
 	{

data/src/painter.h

@@ -12,10 +12,18 @@ namespace Rays
 {
 
 
-	void Painter_draw_polygon (
+	void Painter_draw (
 		Painter* painter, GLenum mode, const Color& color,
-		const Coord3* points,         size_t npoints,
-		const uint*   indices = NULL, size_t nindices = 0);
+		const Coord3* points,           size_t npoints,
+		const uint*   indices   = NULL, size_t nindices = 0,
+		const Coord3* texcoords = NULL);
+
+	void Painter_draw (
+		Painter* painter, GLenum mode,
+		const Coord3* points,           size_t npoints,
+		const uint*   indices   = NULL, size_t nindices = 0,
+		const Color*  colors    = NULL,
+		const Coord3* texcoords = NULL);
 
 
 }// Rays