From e39875a20db157c86efb6dc7206b0b7555e77d96 Mon Sep 17 00:00:00 2001 From: MewPurPur Date: Sat, 8 Jul 2023 00:22:09 +0300 Subject: [PATCH] Add closed property to Line2D --- doc/classes/Line2D.xml | 13 +- scene/2d/line_2d.cpp | 63 +++---- scene/2d/line_2d.h | 4 + scene/2d/line_builder.cpp | 354 +++++++++++++++++++------------------- scene/2d/line_builder.h | 2 +- 5 files changed, 221 insertions(+), 215 deletions(-) diff --git a/doc/classes/Line2D.xml b/doc/classes/Line2D.xml index 7e02a520a06a..4c444721f4ff 100644 --- a/doc/classes/Line2D.xml +++ b/doc/classes/Line2D.xml @@ -63,16 +63,21 @@ [b]Note:[/b] [Line2D] is not accelerated by batching when being anti-aliased. - The style of the beginning of the polyline. Use [enum LineCapMode] constants. + The style of the beginning of the polyline, if [member closed] is [code]false[/code]. Use [enum LineCapMode] constants. + + + If [code]true[/code] and the polyline has more than 2 points, the last point and the first one will be connected by a segment. + [b]Note:[/b] The shape of the closing segment is not guaranteed to be seamless if a [member width_curve] is provided. + [b]Note:[/b] The joint between the closing segment and the first segment is drawn first and it samples the [member gradient] and the [member width_curve] at the beginning. This is an implementation detail that might change in a future version. The color of the polyline. Will not be used if a gradient is set. - The style of the end of the polyline. Use [enum LineCapMode] constants. + The style of the end of the polyline, if [member closed] is [code]false[/code]. Use [enum LineCapMode] constants. - The gradient is drawn through the whole line from start to finish. The default color will not be used if a gradient is set. + The gradient is drawn through the whole line from start to finish. The [member default_color] will not be used if this property is set. The style of the connections between segments of the polyline. Use [enum LineJointMode] constants. @@ -93,7 +98,7 @@ The style to render the [member texture] of the polyline. Use [enum LineTextureMode] constants. - The polyline's width + The polyline's width. The polyline's width curve. The width of the polyline over its length will be equivalent to the value of the width curve over its domain. diff --git a/scene/2d/line_2d.cpp b/scene/2d/line_2d.cpp index 3a9473d76c04..be58875e0e7c 100644 --- a/scene/2d/line_2d.cpp +++ b/scene/2d/line_2d.cpp @@ -42,12 +42,12 @@ Rect2 Line2D::_edit_get_rect() const { return Rect2(0, 0, 0, 0); } Vector2 d = Vector2(_width, _width); - Rect2 aabb = Rect2(_points[0] - d, 2 * d); + Rect2 bounding_rect = Rect2(_points[0] - d, 2 * d); for (int i = 1; i < _points.size(); i++) { - aabb.expand_to(_points[i] - d); - aabb.expand_to(_points[i] + d); + bounding_rect.expand_to(_points[i] - d); + bounding_rect.expand_to(_points[i] + d); } - return aabb; + return bounding_rect; } bool Line2D::_edit_use_rect() const { @@ -59,7 +59,14 @@ bool Line2D::_edit_is_selected_on_click(const Point2 &p_point, double p_toleranc const Vector2 *points = _points.ptr(); for (int i = 0; i < _points.size() - 1; i++) { Vector2 p = Geometry2D::get_closest_point_to_segment(p_point, &points[i]); - if (p.distance_to(p_point) <= d) { + if (p_point.distance_to(p) <= d) { + return true; + } + } + if (_closed && _points.size() > 2) { + const Vector2 closing_segment[2] = { points[0], points[_points.size() - 1] }; + Vector2 p = Geometry2D::get_closest_point_to_segment(p_point, closing_segment); + if (p_point.distance_to(p) <= d) { return true; } } @@ -73,6 +80,15 @@ void Line2D::set_points(const Vector &p_points) { queue_redraw(); } +void Line2D::set_closed(bool p_closed) { + _closed = p_closed; + queue_redraw(); +} + +bool Line2D::is_closed() const { + return _closed; +} + void Line2D::set_width(float p_width) { if (p_width < 0.0) { p_width = 0.0; @@ -86,14 +102,12 @@ float Line2D::get_width() const { } void Line2D::set_curve(const Ref &p_curve) { - // Cleanup previous connection if any if (_curve.is_valid()) { _curve->disconnect_changed(callable_mp(this, &Line2D::_curve_changed)); } _curve = p_curve; - // Connect to the curve so the line will update when it is changed if (_curve.is_valid()) { _curve->connect_changed(callable_mp(this, &Line2D::_curve_changed)); } @@ -156,14 +170,12 @@ Color Line2D::get_default_color() const { } void Line2D::set_gradient(const Ref &p_gradient) { - // Cleanup previous connection if any if (_gradient.is_valid()) { _gradient->disconnect_changed(callable_mp(this, &Line2D::_gradient_changed)); } _gradient = p_gradient; - // Connect to the gradient so the line will update when the Gradient is changed if (_gradient.is_valid()) { _gradient->connect_changed(callable_mp(this, &Line2D::_gradient_changed)); } @@ -264,20 +276,10 @@ void Line2D::_draw() { return; } - // TODO Is this really needed? - // Copy points for faster access - Vector points; - points.resize(len); - { - const Vector2 *points_read = _points.ptr(); - for (int i = 0; i < len; ++i) { - points.write[i] = points_read[i]; - } - } - // TODO Maybe have it as member rather than copying parameters and allocating memory? LineBuilder lb; - lb.points = points; + lb.points = _points; + lb.closed = _closed; lb.default_color = _default_color; lb.gradient = *_gradient; lb.texture_mode = _texture_mode; @@ -306,13 +308,10 @@ void Line2D::_draw() { lb.uvs, Vector(), Vector(), texture_rid); - // DEBUG - // Draw wireframe - // if(lb.indices.size() % 3 == 0) { - // Color col(0,0,0); - // for(int i = 0; i < lb.indices.size(); i += 3) { - // int vi = lb.indices[i]; - // int lbvsize = lb.vertices.size(); + // DEBUG: Draw wireframe + // if (lb.indices.size() % 3 == 0) { + // Color col(0, 0, 0); + // for (int i = 0; i < lb.indices.size(); i += 3) { // Vector2 a = lb.vertices[lb.indices[i]]; // Vector2 b = lb.vertices[lb.indices[i+1]]; // Vector2 c = lb.vertices[lb.indices[i+2]]; @@ -320,9 +319,9 @@ void Line2D::_draw() { // draw_line(b, c, col); // draw_line(c, a, col); // } - // for(int i = 0; i < lb.vertices.size(); ++i) { + // for (int i = 0; i < lb.vertices.size(); ++i) { // Vector2 p = lb.vertices[i]; - // draw_rect(Rect2(p.x-1, p.y-1, 2, 2), Color(0,0,0,0.5)); + // draw_rect(Rect2(p.x - 1, p.y - 1, 2, 2), Color(0, 0, 0, 0.5)); // } // } } @@ -350,6 +349,9 @@ void Line2D::_bind_methods() { ClassDB::bind_method(D_METHOD("clear_points"), &Line2D::clear_points); + ClassDB::bind_method(D_METHOD("set_closed", "closed"), &Line2D::set_closed); + ClassDB::bind_method(D_METHOD("is_closed"), &Line2D::is_closed); + ClassDB::bind_method(D_METHOD("set_width", "width"), &Line2D::set_width); ClassDB::bind_method(D_METHOD("get_width"), &Line2D::get_width); @@ -387,6 +389,7 @@ void Line2D::_bind_methods() { ClassDB::bind_method(D_METHOD("get_antialiased"), &Line2D::get_antialiased); ADD_PROPERTY(PropertyInfo(Variant::PACKED_VECTOR2_ARRAY, "points"), "set_points", "get_points"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "closed"), "set_closed", "is_closed"); ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "width", PROPERTY_HINT_NONE, "suffix:px"), "set_width", "get_width"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "width_curve", PROPERTY_HINT_RESOURCE_TYPE, "Curve"), "set_curve", "get_curve"); ADD_PROPERTY(PropertyInfo(Variant::COLOR, "default_color"), "set_default_color", "get_default_color"); diff --git a/scene/2d/line_2d.h b/scene/2d/line_2d.h index aa873ca6420d..1d750ca456c9 100644 --- a/scene/2d/line_2d.h +++ b/scene/2d/line_2d.h @@ -76,6 +76,9 @@ public: void add_point(Vector2 pos, int atpos = -1); void remove_point(int i); + void set_closed(bool p_closed); + bool is_closed() const; + void set_width(float width); float get_width() const; @@ -127,6 +130,7 @@ private: LineJointMode _joint_mode = LINE_JOINT_SHARP; LineCapMode _begin_cap_mode = LINE_CAP_NONE; LineCapMode _end_cap_mode = LINE_CAP_NONE; + bool _closed = false; float _width = 10.0; Ref _curve; Color _default_color = Color(1, 1, 1); diff --git a/scene/2d/line_builder.cpp b/scene/2d/line_builder.cpp index 0970325502bc..e898dc7fab2a 100644 --- a/scene/2d/line_builder.cpp +++ b/scene/2d/line_builder.cpp @@ -30,75 +30,25 @@ #include "line_builder.h" -//---------------------------------------------------------------------------- -// Util -//---------------------------------------------------------------------------- - -enum SegmentIntersectionResult { - SEGMENT_PARALLEL = 0, - SEGMENT_NO_INTERSECT = 1, - SEGMENT_INTERSECT = 2 -}; - -static SegmentIntersectionResult segment_intersection( - Vector2 a, Vector2 b, Vector2 c, Vector2 d, - Vector2 *out_intersection) { - // http://paulbourke.net/geometry/pointlineplane/ <-- Good stuff - Vector2 cd = d - c; - Vector2 ab = b - a; - float div = cd.y * ab.x - cd.x * ab.y; - - if (Math::abs(div) > 0.001f) { - float ua = (cd.x * (a.y - c.y) - cd.y * (a.x - c.x)) / div; - float ub = (ab.x * (a.y - c.y) - ab.y * (a.x - c.x)) / div; - *out_intersection = a + ua * ab; - if (ua >= 0.f && ua <= 1.f && - ub >= 0.f && ub <= 1.f) { - return SEGMENT_INTERSECT; - } - return SEGMENT_NO_INTERSECT; - } - - return SEGMENT_PARALLEL; -} - -static float calculate_total_distance(const Vector &points) { - float d = 0.f; - for (int i = 1; i < points.size(); ++i) { - d += points[i].distance_to(points[i - 1]); - } - return d; -} - -static inline Vector2 rotate90(const Vector2 &v) { - // Note: the 2D referential is X-right, Y-down - return Vector2(v.y, -v.x); -} +#include "core/math/geometry_2d.h" +// Utility method. static inline Vector2 interpolate(const Rect2 &r, const Vector2 &v) { return Vector2( Math::lerp(r.position.x, r.position.x + r.get_size().x, v.x), Math::lerp(r.position.y, r.position.y + r.get_size().y, v.y)); } -//---------------------------------------------------------------------------- -// LineBuilder -//---------------------------------------------------------------------------- - LineBuilder::LineBuilder() { } -void LineBuilder::clear_output() { - vertices.clear(); - colors.clear(); - indices.clear(); - uvs.clear(); -} - void LineBuilder::build() { - // Need at least 2 points to draw a line + // Need at least 2 points to draw a line, so clear the output and return. if (points.size() < 2) { - clear_output(); + vertices.clear(); + colors.clear(); + indices.clear(); + uvs.clear(); return; } @@ -107,14 +57,21 @@ void LineBuilder::build() { const float hw = width / 2.f; const float hw_sq = hw * hw; const float sharp_limit_sq = sharp_limit * sharp_limit; - const int len = points.size(); + const int point_count = points.size(); + const bool wrap_around = closed && point_count > 2; + + _interpolate_color = gradient != nullptr; + const bool retrieve_curve = curve != nullptr; + const bool distance_required = _interpolate_color || retrieve_curve || + texture_mode == Line2D::LINE_TEXTURE_TILE || + texture_mode == Line2D::LINE_TEXTURE_STRETCH; // Initial values Vector2 pos0 = points[0]; Vector2 pos1 = points[1]; Vector2 f0 = (pos1 - pos0).normalized(); - Vector2 u0 = rotate90(f0); + Vector2 u0 = f0.orthogonal(); Vector2 pos_up0 = pos0; Vector2 pos_down0 = pos0; @@ -124,32 +81,37 @@ void LineBuilder::build() { float current_distance0 = 0.f; float current_distance1 = 0.f; float total_distance = 0.f; + float width_factor = 1.f; - _interpolate_color = gradient != nullptr; - bool retrieve_curve = curve != nullptr; - bool distance_required = _interpolate_color || - retrieve_curve || - texture_mode == Line2D::LINE_TEXTURE_TILE || - texture_mode == Line2D::LINE_TEXTURE_STRETCH; + float modified_hw = hw; + if (retrieve_curve) { + width_factor = curve->sample_baked(0.f); + modified_hw = hw * width_factor; + } + if (distance_required) { - total_distance = calculate_total_distance(points); - //Adjust totalDistance. - // The line's outer length will be a little higher due to begin and end caps - if (begin_cap_mode == Line2D::LINE_CAP_BOX || begin_cap_mode == Line2D::LINE_CAP_ROUND) { - if (retrieve_curve) { - total_distance += width * curve->sample_baked(0.f) * 0.5f; - } else { - total_distance += width * 0.5f; - } + // Calculate the total distance. + for (int i = 1; i < point_count; ++i) { + total_distance += points[i].distance_to(points[i - 1]); } - if (end_cap_mode == Line2D::LINE_CAP_BOX || end_cap_mode == Line2D::LINE_CAP_ROUND) { - if (retrieve_curve) { - total_distance += width * curve->sample_baked(1.f) * 0.5f; - } else { - total_distance += width * 0.5f; + if (wrap_around) { + total_distance += points[point_count - 1].distance_to(pos0); + } else { + // Adjust the total distance. + // The line's outer length may be a little higher due to the end caps. + if (begin_cap_mode == Line2D::LINE_CAP_BOX || begin_cap_mode == Line2D::LINE_CAP_ROUND) { + total_distance += modified_hw; + } + if (end_cap_mode == Line2D::LINE_CAP_BOX || end_cap_mode == Line2D::LINE_CAP_ROUND) { + if (retrieve_curve) { + total_distance += hw * curve->sample_baked(1.f); + } else { + total_distance += hw; + } } } } + if (_interpolate_color) { color0 = gradient->get_color(0); } else { @@ -159,34 +121,31 @@ void LineBuilder::build() { float uvx0 = 0.f; float uvx1 = 0.f; - if (retrieve_curve) { - width_factor = curve->sample_baked(0.f); - } - - pos_up0 += u0 * hw * width_factor; - pos_down0 -= u0 * hw * width_factor; + pos_up0 += u0 * modified_hw; + pos_down0 -= u0 * modified_hw; // Begin cap - if (begin_cap_mode == Line2D::LINE_CAP_BOX) { - // Push back first vertices a little bit - pos_up0 -= f0 * hw * width_factor; - pos_down0 -= f0 * hw * width_factor; + if (!wrap_around) { + if (begin_cap_mode == Line2D::LINE_CAP_BOX) { + // Push back first vertices a little bit. + pos_up0 -= f0 * modified_hw; + pos_down0 -= f0 * modified_hw; - current_distance0 += hw * width_factor; - current_distance1 = current_distance0; - } else if (begin_cap_mode == Line2D::LINE_CAP_ROUND) { - if (texture_mode == Line2D::LINE_TEXTURE_TILE) { - uvx0 = width_factor * 0.5f / tile_aspect; - } else if (texture_mode == Line2D::LINE_TEXTURE_STRETCH) { - uvx0 = width * width_factor / total_distance; + current_distance0 += modified_hw; + current_distance1 = current_distance0; + } else if (begin_cap_mode == Line2D::LINE_CAP_ROUND) { + if (texture_mode == Line2D::LINE_TEXTURE_TILE) { + uvx0 = width_factor * 0.5f / tile_aspect; + } else if (texture_mode == Line2D::LINE_TEXTURE_STRETCH) { + uvx0 = width * width_factor / total_distance; + } + new_arc(pos0, pos_up0 - pos0, -Math_PI, color0, Rect2(0.f, 0.f, uvx0 * 2, 1.f)); + current_distance0 += modified_hw; + current_distance1 = current_distance0; } - new_arc(pos0, pos_up0 - pos0, -Math_PI, color0, Rect2(0.f, 0.f, uvx0 * 2, 1.f)); - current_distance0 += hw * width_factor; - current_distance1 = current_distance0; + strip_begin(pos_up0, pos_down0, color0, uvx0); } - strip_begin(pos_up0, pos_down0, color0, uvx0); - /* * pos_up0 ------------- pos_up1 -------------------- * | | @@ -200,19 +159,30 @@ void LineBuilder::build() { // http://labs.hyperandroid.com/tag/opengl-lines // (not the same implementation but visuals help a lot) + // If the polyline wraps around, then draw two more segments with joints: + // The last one, which should normally end with an end cap, and the one that matches the end and the beginning. + int segments_count = wrap_around ? point_count : (point_count - 2); + // The wraparound case starts with a "fake walk" from the end of the polyline + // to its beginning, so that its first joint is correct, without drawing anything. + int first_point = wrap_around ? -1 : 1; + + // If the line wraps around, these variables will be used for the final segment. + Vector2 first_pos_up, first_pos_down; + bool is_first_joint_sharp = false; + // For each additional segment - for (int i = 1; i < len - 1; ++i) { - pos1 = points[i]; - Vector2 pos2 = points[i + 1]; + for (int i = first_point; i <= segments_count; ++i) { + pos1 = points[(i == -1) ? point_count - 1 : i % point_count]; // First point. + Vector2 pos2 = points[(i + 1) % point_count]; // Second point. Vector2 f1 = (pos2 - pos1).normalized(); - Vector2 u1 = rotate90(f1); + Vector2 u1 = f1.orthogonal(); - // Determine joint orientation - const float dp = u0.dot(f1); + // Determine joint orientation. + float dp = u0.dot(f1); const Orientation orientation = (dp > 0.f ? UP : DOWN); - if (distance_required) { + if (distance_required && i >= 1) { current_distance1 += pos0.distance_to(pos1); } if (_interpolate_color) { @@ -220,15 +190,14 @@ void LineBuilder::build() { } if (retrieve_curve) { width_factor = curve->sample_baked(current_distance1 / total_distance); + modified_hw = hw * width_factor; } - Vector2 inner_normal0, inner_normal1; - if (orientation == UP) { - inner_normal0 = u0 * hw * width_factor; - inner_normal1 = u1 * hw * width_factor; - } else { - inner_normal0 = -u0 * hw * width_factor; - inner_normal1 = -u1 * hw * width_factor; + Vector2 inner_normal0 = u0 * modified_hw; + Vector2 inner_normal1 = u1 * modified_hw; + if (orientation == DOWN) { + inner_normal0 = -inner_normal0; + inner_normal1 = -inner_normal1; } /* @@ -245,18 +214,18 @@ void LineBuilder::build() { * / */ - // Find inner intersection at the joint + // Find inner intersection at the joint. Vector2 corner_pos_in, corner_pos_out; - SegmentIntersectionResult intersection_result = segment_intersection( + bool is_intersecting = Geometry2D::segment_intersects_segment( pos0 + inner_normal0, pos1 + inner_normal0, pos1 + inner_normal1, pos2 + inner_normal1, &corner_pos_in); - if (intersection_result == SEGMENT_INTERSECT) { - // Inner parts of the segments intersect + if (is_intersecting) { + // Inner parts of the segments intersect. corner_pos_out = 2.f * pos1 - corner_pos_in; } else { - // No intersection, segments are either parallel or too sharp + // No intersection, segments are too sharp or they overlap. corner_pos_in = pos1 + inner_normal0; corner_pos_out = pos1 - inner_normal0; } @@ -273,8 +242,8 @@ void LineBuilder::build() { Line2D::LineJointMode current_joint_mode = joint_mode; Vector2 pos_up1, pos_down1; - if (intersection_result == SEGMENT_INTERSECT) { - // Fallback on bevel if sharp angle is too high (because it would produce very long miters) + if (is_intersecting) { + // Fallback on bevel if sharp angle is too high (because it would produce very long miters). float width_factor_sq = width_factor * width_factor; if (current_joint_mode == Line2D::LINE_JOINT_SHARP && corner_pos_out.distance_squared_to(pos1) / (hw_sq * width_factor_sq) > sharp_limit_sq) { current_joint_mode = Line2D::LINE_JOINT_BEVEL; @@ -288,57 +257,78 @@ void LineBuilder::build() { // Bevel or round if (orientation == UP) { pos_up1 = corner_pos_up; - pos_down1 = pos1 - u0 * hw * width_factor; + pos_down1 = pos1 - u0 * modified_hw; } else { - pos_up1 = pos1 + u0 * hw * width_factor; + pos_up1 = pos1 + u0 * modified_hw; pos_down1 = corner_pos_down; } } } else { // No intersection: fallback if (current_joint_mode == Line2D::LINE_JOINT_SHARP) { - // There is no fallback implementation for LINE_JOINT_SHARP so switch to the LINE_JOINT_BEVEL + // There is no fallback implementation for LINE_JOINT_SHARP so switch to the LINE_JOINT_BEVEL. current_joint_mode = Line2D::LINE_JOINT_BEVEL; } pos_up1 = corner_pos_up; pos_down1 = corner_pos_down; } - // Add current line body quad - // Triangles are clockwise + // Triangles are clockwise. if (texture_mode == Line2D::LINE_TEXTURE_TILE) { uvx1 = current_distance1 / (width * tile_aspect); } else if (texture_mode == Line2D::LINE_TEXTURE_STRETCH) { uvx1 = current_distance1 / total_distance; } - strip_add_quad(pos_up1, pos_down1, color1, uvx1); - - // Swap vars for use in the next line + // Swap vars for use in the next line. color0 = color1; u0 = u1; f0 = f1; pos0 = pos1; - if (intersection_result == SEGMENT_INTERSECT) { + if (is_intersecting) { if (current_joint_mode == Line2D::LINE_JOINT_SHARP) { pos_up0 = pos_up1; pos_down0 = pos_down1; } else { if (orientation == UP) { pos_up0 = corner_pos_up; - pos_down0 = pos1 - u1 * hw * width_factor; + pos_down0 = pos1 - u1 * modified_hw; } else { - pos_up0 = pos1 + u1 * hw * width_factor; + pos_up0 = pos1 + u1 * modified_hw; pos_down0 = corner_pos_down; } } } else { - pos_up0 = pos1 + u1 * hw * width_factor; - pos_down0 = pos1 - u1 * hw * width_factor; + pos_up0 = pos1 + u1 * modified_hw; + pos_down0 = pos1 - u1 * modified_hw; } - // From this point, bu0 and bd0 concern the next segment - // Add joint geometry + // End the "fake pass" in the closed line case before the drawing subroutine. + if (i == -1) { + continue; + } + + // For wrap-around polylines, store some kind of start positions of the first joint for the final connection. + if (wrap_around && i == 0) { + Vector2 first_pos_center = (pos_up1 + pos_down1) / 2; + float lerp_factor = 1.0 / width_factor; + first_pos_up = first_pos_center.lerp(pos_up1, lerp_factor); + first_pos_down = first_pos_center.lerp(pos_down1, lerp_factor); + is_first_joint_sharp = current_joint_mode == Line2D::LINE_JOINT_SHARP; + } + + // Add current line body quad. + if (wrap_around && retrieve_curve && !is_first_joint_sharp && i == segments_count) { + // If the width curve is not seamless, we might need to fetch the line's start points to use them for the final connection. + Vector2 first_pos_center = (first_pos_up + first_pos_down) / 2; + strip_add_quad(first_pos_center.lerp(first_pos_up, width_factor), first_pos_center.lerp(first_pos_down, width_factor), color1, uvx1); + return; + } else { + strip_add_quad(pos_up1, pos_down1, color1, uvx1); + } + + // From this point, bu0 and bd0 concern the next segment. + // Add joint geometry. if (current_joint_mode != Line2D::LINE_JOINT_SHARP) { /* ________________ cbegin * / \ @@ -358,64 +348,68 @@ void LineBuilder::build() { cend = pos_up0; } - if (current_joint_mode == Line2D::LINE_JOINT_BEVEL) { + if (current_joint_mode == Line2D::LINE_JOINT_BEVEL && !(wrap_around && i == segments_count)) { strip_add_tri(cend, orientation); - } else if (current_joint_mode == Line2D::LINE_JOINT_ROUND) { + } else if (current_joint_mode == Line2D::LINE_JOINT_ROUND && !(wrap_around && i == segments_count)) { Vector2 vbegin = cbegin - pos1; Vector2 vend = cend - pos1; strip_add_arc(pos1, vbegin.angle_to(vend), orientation); } - if (intersection_result != SEGMENT_INTERSECT) { + if (!is_intersecting) { // In this case the joint is too corrupted to be re-used, // start again the strip with fallback points strip_begin(pos_up0, pos_down0, color1, uvx1); } } } - // Last (or only) segment - pos1 = points[points.size() - 1]; - if (distance_required) { - current_distance1 += pos0.distance_to(pos1); - } - if (_interpolate_color) { - color1 = gradient->get_color(gradient->get_point_count() - 1); - } - if (retrieve_curve) { - width_factor = curve->sample_baked(1.f); - } + // Draw the last (or only) segment, with its end cap logic. + if (!wrap_around) { + pos1 = points[point_count - 1]; - Vector2 pos_up1 = pos1 + u0 * hw * width_factor; - Vector2 pos_down1 = pos1 - u0 * hw * width_factor; - - // End cap (box) - if (end_cap_mode == Line2D::LINE_CAP_BOX) { - pos_up1 += f0 * hw * width_factor; - pos_down1 += f0 * hw * width_factor; - - current_distance1 += hw * width_factor; - } - - if (texture_mode == Line2D::LINE_TEXTURE_TILE) { - uvx1 = current_distance1 / (width * tile_aspect); - } else if (texture_mode == Line2D::LINE_TEXTURE_STRETCH) { - uvx1 = current_distance1 / total_distance; - } - - strip_add_quad(pos_up1, pos_down1, color1, uvx1); - - // End cap (round) - if (end_cap_mode == Line2D::LINE_CAP_ROUND) { - // Note: color is not used in case we don't interpolate... - Color color = _interpolate_color ? gradient->get_color(gradient->get_point_count() - 1) : Color(0, 0, 0); - float dist = 0; - if (texture_mode == Line2D::LINE_TEXTURE_TILE) { - dist = width_factor / tile_aspect; - } else if (texture_mode == Line2D::LINE_TEXTURE_STRETCH) { - dist = width * width_factor / total_distance; + if (distance_required) { + current_distance1 += pos0.distance_to(pos1); + } + if (_interpolate_color) { + color1 = gradient->get_color(gradient->get_point_count() - 1); + } + if (retrieve_curve) { + width_factor = curve->sample_baked(1.f); + modified_hw = hw * width_factor; + } + + Vector2 pos_up1 = pos1 + u0 * modified_hw; + Vector2 pos_down1 = pos1 - u0 * modified_hw; + + // Add extra distance for a box end cap. + if (end_cap_mode == Line2D::LINE_CAP_BOX) { + pos_up1 += f0 * modified_hw; + pos_down1 += f0 * modified_hw; + + current_distance1 += modified_hw; + } + + if (texture_mode == Line2D::LINE_TEXTURE_TILE) { + uvx1 = current_distance1 / (width * tile_aspect); + } else if (texture_mode == Line2D::LINE_TEXTURE_STRETCH) { + uvx1 = current_distance1 / total_distance; + } + + strip_add_quad(pos_up1, pos_down1, color1, uvx1); + + // Custom drawing for a round end cap. + if (end_cap_mode == Line2D::LINE_CAP_ROUND) { + // Note: color is not used in case we don't interpolate. + Color color = _interpolate_color ? gradient->get_color(gradient->get_point_count() - 1) : Color(0, 0, 0); + float dist = 0; + if (texture_mode == Line2D::LINE_TEXTURE_TILE) { + dist = width_factor / tile_aspect; + } else if (texture_mode == Line2D::LINE_TEXTURE_STRETCH) { + dist = width * width_factor / total_distance; + } + new_arc(pos1, pos_up1 - pos1, Math_PI, color, Rect2(uvx1 - 0.5f * dist, 0.f, dist, 1.f)); } - new_arc(pos1, pos_up1 - pos1, Math_PI, color, Rect2(uvx1 - 0.5f * dist, 0.f, dist, 1.f)); } } diff --git a/scene/2d/line_builder.h b/scene/2d/line_builder.h index 044ff93b4277..3706352d5c7c 100644 --- a/scene/2d/line_builder.h +++ b/scene/2d/line_builder.h @@ -41,6 +41,7 @@ public: Line2D::LineJointMode joint_mode = Line2D::LINE_JOINT_SHARP; Line2D::LineCapMode begin_cap_mode = Line2D::LINE_CAP_NONE; Line2D::LineCapMode end_cap_mode = Line2D::LINE_CAP_NONE; + bool closed = false; float width = 10.0; Curve *curve = nullptr; Color default_color = Color(0.4, 0.5, 1); @@ -61,7 +62,6 @@ public: LineBuilder(); void build(); - void clear_output(); private: enum Orientation {