rays 0.1.47 → 0.1.49

data/src/painter.cpp

@@ -59,12 +59,20 @@ namespace Rays
 
 		uint nsegment;
 
+		coord line_height;
+
 		BlendMode blend_mode;
 
 		Bounds clip;
 
 		Font font;
 
+		Image texture;
+
+		TexCoordMode texcoord_mode;
+
+		TexCoordWrap texcoord_wrap;
+
 		Shader shader;
 
 		void init ()
@@ -78,9 +86,13 @@ namespace Rays
 			stroke_join    = JOIN_DEFAULT;
 			miter_limit    = JOIN_DEFAULT_MITER_LIMIT;
 			nsegment       = 0;
+			line_height    = -1;
 			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();
 		}
 
@@ -97,7 +109,7 @@ namespace Rays
 
 		const Texture& texture;
 
-		Point texcoord_min, texcoord_max;
+		Point min, max;
 
 		TextureInfo (
 			const Texture& texture,
@@ -105,16 +117,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
@@ -310,13 +322,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__);
@@ -324,15 +337,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();
 
@@ -345,6 +361,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)
@@ -354,9 +391,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)
@@ -374,24 +412,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);
 					});
 				}
@@ -412,9 +453,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,
@@ -424,21 +466,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>
@@ -557,52 +608,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);
 	}
 
 
@@ -700,7 +726,13 @@ namespace Rays
 		set_blend_mode(self->state.blend_mode);
 
 		FrameBuffer& fb = self->frame_buffer;
-		if (fb) FrameBuffer_bind(fb.id());
+		if (fb)
+		{
+			FrameBuffer_bind(fb.id());
+
+			Texture& tex = fb.texture();
+			if (tex) tex.set_modified();
+		}
 
 		const Bounds& vp = self->viewport;
 		float density    = self->pixel_density;
@@ -750,12 +782,7 @@ namespace Rays
 		glFinish();
 
 		if (self->frame_buffer)
-		{
 			FrameBuffer_unbind();
-
-			Texture& tex = self->frame_buffer.texture();
-			if (tex) tex.set_modified();
-		}
 	}
 
 	bool
@@ -792,10 +819,7 @@ 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
 	}
@@ -873,6 +897,24 @@ namespace Rays
 			this, polygon, bounds.x, bounds.y, bounds.width, bounds.height, true);
 	}
 
+	void
+	Painter::point (coord x, coord y)
+	{
+		polygon(create_point(x, y));
+	}
+
+	void
+	Painter::point (const Point& point)
+	{
+		polygon(create_point(point));
+	}
+
+	void
+	Painter::points (const Point* points, size_t size)
+	{
+		polygon(create_points(points, size));
+	}
+
 	void
 	Painter::line (coord x1, coord y1, coord x2, coord y2)
 	{
@@ -970,7 +1012,7 @@ namespace Rays
 		coord x3, coord y3, coord x4, coord y4,
 		bool loop)
 	{
-		polygon(create_curve(x1, y1, x2, y2, x3, y3, x4, y4, loop));
+		polygon(create_curve(x1, y1, x2, y2, x3, y3, x4, y4, loop, nsegment()));
 	}
 
 	void
@@ -978,13 +1020,13 @@ namespace Rays
 		const Point& p1, const Point& p2, const Point& p3, const Point& p4,
 		bool loop)
 	{
-		polygon(create_curve(p1, p2, p3, p4, loop));
+		polygon(create_curve(p1, p2, p3, p4, loop, nsegment()));
 	}
 
 	void
 	Painter::curve (const Point* points, size_t size, bool loop)
 	{
-		polygon(create_curve(points, size, loop));
+		polygon(create_curve(points, size, loop, nsegment()));
 	}
 
 	void
@@ -993,7 +1035,7 @@ namespace Rays
 		coord x3, coord y3, coord x4, coord y4,
 		bool loop)
 	{
-		polygon(create_bezier(x1, y1, x2, y2, x3, y3, x4, y4, loop));
+		polygon(create_bezier(x1, y1, x2, y2, x3, y3, x4, y4, loop, nsegment()));
 	}
 
 	void
@@ -1001,13 +1043,13 @@ namespace Rays
 		const Point& p1, const Point& p2, const Point& p3, const Point& p4,
 		bool loop)
 	{
-		polygon(create_bezier(p1, p2, p3, p4, loop));
+		polygon(create_bezier(p1, p2, p3, p4, loop, nsegment()));
 	}
 
 	void
 	Painter::bezier (const Point* points, size_t size, bool loop)
 	{
-		polygon(create_bezier(points, size, loop));
+		polygon(create_bezier(points, size, loop, nsegment()));
 	}
 
 	static void
@@ -1015,7 +1057,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};
 
@@ -1051,12 +1094,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;
+
+			if (!painter->self->get_color(&color, (ColorType) type))
+				continue;
 
-		draw_polygon(
-			painter, MODES, 0, 0, false, nostroke, points, 4, NULL, 0, texcoords,
-			*shader, &texinfo);
+			painter->self->draw(
+				MODES[type], &color, points, 4, NULL, 0, NULL, texcoords,
+				&texinfo, shader);
+		}
 	}
 
 	void
@@ -1148,7 +1198,7 @@ namespace Rays
 	}
 
 	static inline void
-	debug_draw_text (
+	debug_draw_line (
 		Painter* painter, const Font& font,
 		coord x, coord y, coord str_width, coord str_height)
 	{
@@ -1182,25 +1232,20 @@ namespace Rays
 	}
 
 	static void
-	draw_text (
+	draw_line (
 		Painter* painter, const Font& font,
-		const char* str, coord x, coord y, coord width = 0, coord height = 0)
+		const char* line, coord x, coord y, coord width = 0, coord height = 0)
 	{
 		assert(painter && font && str && *str != '\0');
 
 		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;
-
-		float density = self->pixel_density;
-		coord str_w = Font_get_width(font, density, str);
-		coord str_h = Font_get_height(font, density);
-		int tex_w   = ceil(str_w);
-		int tex_h   = ceil(str_h);
+		float density          = self->pixel_density;
+		const RawFont& rawfont = Font_get_raw(font, density);
+		coord str_w            = rawfont.get_width(line);
+		coord str_h            = rawfont.get_height();
+		int tex_w              = ceil(str_w);
+		int tex_h              = ceil(str_h);
 		const Texture& texture = Image_get_texture(self->text_image);
 		if (
 			texture.width()  < tex_w ||
@@ -1217,8 +1262,7 @@ namespace Rays
 
 		assert(self->text_image.pixel_density() == density);
 
-		Bitmap_draw_string(
-			&self->text_image.bitmap(), Font_get_raw(font, density), str, 0, 0);
+		Bitmap_draw_string(&self->text_image.bitmap(), rawfont, line, 0, 0);
 
 		str_w /= density;
 		str_h /= density;
@@ -1229,9 +1273,40 @@ 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_line(painter, font, x, y, str_w / density, str_h / density);
+	}
 
-		debug_draw_text(painter, font, x, y, str_w / density, str_h / density);
+	static void
+	draw_text (
+		Painter* painter, const Font& font,
+		const char* str, coord x, coord y, coord width = 0, coord height = 0)
+	{
+		assert(painter && font && str && *str != '\0');
+
+		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;
+
+		if (!strchr(str, '\n'))
+			draw_line(painter, font, str, x, y, width, height);
+		else
+		{
+			coord line_height = painter->line_height();
+
+			Xot::StringList lines;
+			split(&lines, str, '\n');
+			for (const auto& line : lines)
+			{
+				draw_line(painter, font, line.c_str(), x, y, width, height);
+				y += line_height;
+			}
+		}
 	}
 
 	void
@@ -1426,6 +1501,21 @@ namespace Rays
 		return self->state.nsegment;
 	}
 
+	void
+	Painter::set_line_height (coord height)
+	{
+		if (height < 0) height = -1;
+		self->state.line_height = height;
+	}
+
+	coord
+	Painter::line_height (bool raw) const
+	{
+		coord height = self->state.line_height;
+		if (!raw && height < 0) height = self->state.font.get_height();
+		return height;
+	}
+
 	void
 	Painter::set_blend_mode (BlendMode mode)
 	{
@@ -1522,7 +1612,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
@@ -1545,6 +1635,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