diff --git a/Draw-List.md b/Draw-List.md
index 7bcda71..eb2a370 100644
--- a/Draw-List.md
+++ b/Draw-List.md
@@ -111,36 +111,35 @@ When switching from legacy AddLine() values to `AddLineV()`/`AddLineH()` you can
If you have lines that form a continuous shape use the Path functions or `AddPolyline()` instead. They will handle the joins between the lines. They both support `ImDrawFlags_Closed` which will closes the shape by creating a segment automatically between first and last point.
+
+
```
-AddLine({ 1,2 }, { 5,2 })
+A, B) AddLine({ 1,2 }, { 5,2 })
```
**Before**: 0.5px offset, no AA line ends. The start pixel is covered due to the rasterization filling rules, and the end pixel is not for same reason.
-
-
**After**: Offset is removed so the line is centered around the input coordinates. Existing uses will appear blurred since the only half of the pixels are covered.
-**FIXME: Missing a "after" AddLine() example that looks correct, even if also suggesting to use AddLineH().**
-
```
-AddLine({ 1.5,2.5 }, { 5.5,2.5 })
+C) AddLine({ 1.5,2.5 }, { 5.5,2.5 })
```
**After**: If we were to add the 0.5px offset back, then then the line would look crisp as before, but the line ends were blurred, since the line covers only half a pixel on each end.
-
-
-
```
-AddLineH( {1,5}, 2)
+D) AddLine({ 1,2.5 }, { 5,2.5 })
```
-**Migration**: Horizontal and vertical lines are recommended to be replaced with `AddLineH()` and `AddLineV()`. Other use cases might require tweaking. Some use cases we've had to fix already compensated for the 0.5px offset, which can now be removed. Stroke position `ImDrawFlags_StrokeLegacy` can be used in cases which are deemed too tricky to fix, and old behavior should be used.
+**Migration**: The line should cover the pixel we want to fill fully. One way to do that is to draw horizontal lines offset by half the thickness. In this case the thickness is 1, so we offset by 0.5px.
-
+```
+E) AddLineH( {1,5}, 2)
+```
+
+**Migration**: Offsetting the lines can be tedious and a simpler way is to use the stroke offset. You can draw the line using “stroke position = inside”. Then the stroke is expanded to just one side of the line, which allows you to use nice round numbers for defining the geometry, and any integer thickness will look crisp.
@@ -161,21 +160,18 @@ Optimized rendering is used, if the horizontal line is drawn on integer coordina
`AddLineH()` used to be implemented similarly as `AddLine()` and had the same 0.5px offset and missing anti-aliased end caps.
+
+
```
-AddLineH( {1,5}, 2)
+A, B) AddLineH( {1,5}, 2)
```
**Before**:
0.5px offset, no AA line ends. The start pixel is covered due to the rasterization filling rules, and the end pixel is not for same reason.
-
-
-
**After**:
The default stroke position for `AddLineH()` is **Inside**, which means that 1px lines will look the same as before, and thicker lines will grow below the specified line.
-
-
### `AddLineV(x, min_y, max_y, col, thickness, flags)`
@@ -195,20 +191,18 @@ Optimized rendering is used, if the vertical line is drawn on integer coordinate
`AddLineV()` used to have the same 0.5px offset as AddLine(). The offset was removed,.
+
+
```
-AddLineV(2, {1,5})
+A, B) AddLineV(2, {1,5})
```
**Before**:
0.5px offset, no AA line ends
The start pixel is covered due to the rasterization filling rules, and the end pixel is not for same reason.
-
-
**After**:
-The default stroke position for `AddLineV()` is "inside", which means that 1px lines will look the same as before, and thicker lines will grow below the specified line.
-
-
+The default stroke position for `AddLineV()` is **Inside**, which means that 1px lines will look the same as before, and thicker lines will grow below the specified line.
@@ -253,18 +247,18 @@ As the offset was fixed, thicker lines would still render with that half pixel o
The 0.5px offset is now removed, and the user can use the stroke position to place the stroke inside, center, outside of the shape, inside being the default.
+
+
```
-AddRect({ 1,1 }, { 7,7 }, 1)
-AddRect({ 2,2 }, { 6,6 }, 2)
+A) AddRect({ 1,1 }, { 7,7 }, 1)
+B) AddRect({ 2,2 }, { 6,6 }, 2)
```
**Before**:
Fixed 0.5px offset on all thickness. This resulted blurred lines on even thicknesses.
- 
-
```
-AddRect({ 2,2 }, { 6,6 }, 2)
+C) AddRect({ 2,2 }, { 6,6 }, 2)
```
**Migration**:
@@ -272,8 +266,6 @@ By default, the stroke is placed inside the shape.
The uses of `AddRect()` that use 1px thickness will work as before.
Other uses of `AddRect()` should be reviewed to see if the intended use was to draw the stroke at center or inside of the shape.
-
-
### `AddRectFilled(p_min, p_max, col, rounding, flags)`
@@ -289,20 +281,18 @@ Optimized rendering is used when the coordinates are integer, and rounding is sm
`AddRectFilled()` used to always draw non-rounded rectangle without anti-aliasing. Now it renders with anti-aliasing. The optimized rendering case for integer coords matches the previous non-AA rendering.
+
+
```
-AddRectFilled({ 1,1 }, {7,4.5} )
+A,B) AddRectFilled({ 1,1 }, {7,4.5} )
```
**Before**:
Non-rounded rectangles did not have anti-aliasing.
-
-
-
**After**:
Rectangles which are draw on non-integer coordinates are anti-aliased.
-
@@ -312,7 +302,9 @@ Rectangles which are draw on non-integer coordinates are anti-aliased.
-Draws stroked circle at **center** using **radius**, with specified color and thickness. The default thickness is **1.0**, and default stroke position is **Inside**. Stroke Position flags can be used.
+Draws stroked circle at **center** using **radius**, with specified color, segment count, and thickness.
+
+The default segment count is **0** (calculate count automatically based on radius), thickness is **1.0**, and default stroke position is **Inside**. Stroke Position flags can be used.
The rendering code handles corners cases robustly, like stroke thickness that would completely cover the inside of the shape will fallback to rendering to filled circle instead.
@@ -339,7 +331,7 @@ Draws filled circle at **center** using **radius**, with specified color.
Draws stroked ellipse at **center** using **radius** (separate for x, y), with specified rotation, color, segment count and thickness.
-The default rotation is *0*, segment count is *0* (calculate count automatically based on radius), default thickness is **1.0**, and default stroke position is **Inside**. Stroke Position flags can be used.
+The default rotation is **0**, segment count is *0* (calculate count automatically based on radius), default thickness is **1.0**, and default stroke position is **Inside**. Stroke Position flags can be used.
Stroked ellipse drawing is more complicated than other shapes and it does not handle all degenerate inputs, like thick thickness compared to ellipse size, as well as other shapes.
@@ -362,7 +354,7 @@ Draws filled ellipse at **center** using **radius** (separate for x, y), with sp
The default rotation is *0*, segment count is *0* (calculate count automatically based on radius).
-## N-Gons
+## Polygons
### `AddNgon(center, radius, col, num_segments, thickness, flags)`
@@ -392,13 +384,52 @@ The 0.5px offset is now removed, and the user can use the stroke position to pla
Draws filled regular polygon at **center** using circumcircle **radius**, with specified color, and segment count.
+### `AddQuad(p1, p2, p3, p4, col, thickness, flags)`
+
+
+
+Draws arbitrary stroked quad (4 cornered closed polyline) described by **p1**, **p2**, **p3**, **p4**, with specified color, and thickness.
+
+The default thickness is **1.0**, and default stroke position is **Inside**. Stroke Position flags can be used.
+
+The points should be wound counter clockwise and should not self-intersect. Internally calls `AddPolyline()`, see the method for more information.
+
+
+### `AddQuadFilled(p1, p2, p3, p4, col)`
+
+Draws arbitrary filled quad (4 cornered polygon) described by **p1**, **p2**, **p3**, **p4**, with specified color.
+
+The points should be wound counter clockwise and should not self-intersect. Internally calls `AddConvexPolyFilled()`, see the method for more information.
+
+
+### `AddTriangle(p1, p2, p3, col, thickness, flags)`
+
+
+
+Draws arbitrary stroked triangle (3 cornered closed polyline) described by **p1**, **p2**, **p3**, with specified color, and thickness.
+
+The default thickness is **1.0**, and default stroke position is **Inside**. Stroke Position flags can be used.
+
+The points should be wound counter clockwise. Internally calls `AddPolyline()`, see the method for more information.
+
+
+### `AddTriangleFilled(p1, p2, p3, col)`
+
+Draws arbitrary filled triangle (3 cornered polygon) described by **p1**, **p2**, **p3**, with specified color.
+
+The points should be wound counter clockwise. Internally calls `AddPolyline()`, see the method for more information.
+
+
+
## General Polygons
### `AddPolyline(points, num_points, col, thickness, flags)`
-Draws stroked polyline described by **points** and **num_points**, with specified color, and thickness. Stroke Position and Stroke Options flags can be used.
+Draws stroked polyline described by **points** and **num_points**, with specified color, and thickness.
+
+The default thickness is **1.0**, and default stroke position is **Center**. Stroke Position and Stroke Options flags can be used.
@@ -442,7 +473,7 @@ Swapped the trailing parameters `flags` and `thickness`. See `AddRect()` section
The algorithm to render lines got overhauled.
-
+
Previous the polyline rendering would expand the stroke along the normal at each polyline vertex. This caused inconsistent line width, which very noticeable when the polyline has sharper corners.
@@ -452,9 +483,11 @@ The line ends are now anti-aliased. This solves missing pixels at line ends and
### `AddConvexPolyFilled(points, num_points, col)`
-Draws filled polygon described by **points** and **num_points**, with specified color. Stroke Options flags can be used.
+
-The polygon must be wound in clock wise order.
+Draws convex filled polygon described by **points** and **num_points**, with specified color.
+
+The polygon must be wound in clock wise order, the shape must be convex and does not have self-intersections.
The rendering expands small faded fringe around the polygon for anti-aliasing. To keep the expansion robust, the polygon rendering bevels really sharp corners, and clamps long miters in inner corners. As the fringe is 1px wide, it can cause issues when trying to render long thin polygons whose smallest extent is less than 1px.
@@ -471,77 +504,142 @@ The rendering of sharp corners was improved. Earlier there were issues with shar
-
----
-
----
-
----
-
-
### `AddConcavePolyFilled(points, num_points, col)`
+
-### `AddQuad(p1, p2, p3, p4, col, thickness)`
+Draws filled polygon described by **points** and **num_points**, with specified color. Stroke Options flags can be used.
-
+The polygon must be wound in clock wise order and does not have self-intersections.
-Works as before. Support for stroke position was added. Fixes and improvements to `AddPolyline()` also apply.
-
-### `AddQuadFilled(p1, p2, p3, p4, col)` `AddTriangleFilled(p1, p2, p3, col)`
-
-Works as before. Fixes and improvements to `AddConvexPolyFilled()` for sharp corners also apply.
+The concave polygon fill is more expensive than convex one: it has O(N^2) complexity. Provided as a convenience for the user but not used by the main library.
-### `AddTriangle(p1, p2, p3, col, thickness)`
+## Curves
-
-
-Works as before. Support for stroke position was added. Fixes and improvements to `AddPolyline()` also apply.
-
-### `AddTriangleFilled(p1, p2, p3, col)` `AddTriangleFilled(p1, p2, p3, col)`
-
-Works as before. Fixes and improvements to `AddConvexPolyFilled()` for sharp corners also apply.
-
-
-### `AddBezierCubic(p1, p2, p3, p4, col, thickness, num_segments)`
+### `AddBezierCubic(p1, p2, p3, p4, col, thickness, num_segments, flags)`
-Works as before. Support for stroke position was added. Fixes and improvements to `AddPolyline()` also apply.
+Draws stroked cubic bezier curve described by **p1**, **p2**, **p3**, and **p4**, with specified color, thickness, and segment count.
+
+The default thickness is **1.0**, default segment count is **0** (automatic based on error tolerance), and default stroke position is **Center**. Stroke Position and Stroke Options flags can be used.
-### `AddBezierQuadratic(p1, p2, p3, col, thickness, num_segments)`
+### `AddBezierQuadratic(p1, p2, p3, col, thickness, num_segments, flags)`
-Works as before. Support for stroke position was added. Fixes and improvements to `AddPolyline()` also apply.
-
+Draws stroked quadratic bezier curve described by **p1**, **p2**, and **p3**, with specified color, thickness, and segment count.
+
+The default thickness is **1.0**, default segment count is **0** (automatic based on error tolerance), and default stroke position is **Center**. Stroke Position and Stroke Options flags can be used.
+## Images and Gradients
### `AddImageRounded(tex_ref, p_min, p_max, uv_min, uv_max, col, rounding, flags)`
-Works as before.
+Draws rectangle filled with image **ref_ref** from **p_min** (top-left) to **p_max** ( bottom-right), with specified input image UV-coordinates, color, and rounding.
### `AddImage(tex_ref, p_min, p_max, uv_min, uv_max, col)`
+
+Draws rectangle filled with image **ref_ref** from **p_min** (top-left) to **p_max** ( bottom-right), with specified input image UV-coordinates, and color.
+
+The default UV-coordinates are **(0,0) - (1,1)** (the whole input image).
+
+Note: The method renders the image without anti-aliasing.
+
+
### `AddImageQuad(tex_ref, p1, p2, p3, p4, uv1, uv2, uv3, uv4, col)`
+
+Draws quad (4 cornered polygon) filled with image **ref_ref** described by **p1**, **p2**, **p3**, **p4**, with specified input image UV-coordinates, and color.
+
+The points should be wound counter clockwise and should not self-intersect.
+
+Note: The method renders the image without anti-aliasing.
+
+
### `AddRectFilledMultiColor(p_min, p_max, col_upr_left, col_upr_right, col_bot_right, col_bot_left)`
-Works as before. Note: does not support anti-aliasing when non-integer coordinates are passed.
+Draws filled multi-colored rectangle **p_min** (top-left) to **p_max** ( bottom-right), with specified specified colors.
+
+Note: The method renders the image without anti-aliasing.
+
+
+## Paths
+
+The path rendering has stateful API which allows to stage a path one part at a time, and methods that strokes or fills the currently staged path.
+
+**Important**: filled shapes must always use clockwise winding order! The anti-aliasing depends on it. Counter-clockwise shapes will have "inward" anti-aliasing.
+So e.g. `PathArcTo(center, radius, PI * -0.5f, PI)` is ok, whereas `PathArcTo(center, radius, PI, PI * -0.5f)` won't have correct anti-aliasing when followed by `PathFillConvex()`.
+
+
+### `PathClear()`
+
+Clears the currently staged path.
+
+### `PathLineTo(pos)`
+
+Adds point **pos** to the currently staged path. If called on empty path, defines the start of the path.
+
+### `PathLineToMergeDuplicate(pos)`
+
+Adds point **pos** to the currently staged path, if the point is different than the previous one or path is empty.
+
+### `PathArcTo(center, radius, a_min, a_max, num_segments)`
+
+Adds arc segment to the path, centered at **center**, using **radius**, sweeping from **a_min** to **a_max**, with specified number of segments.
+
+The angle is clockwise, 0 degrees at 3 o'clock.
+
+The default segment count is *0* (calculate count automatically based on radius).
+
+### `PathArcToFast(center, radius, a_min_of_12, a_max_of_12)`
+
+Adds arc segment to the path, centered at **center**, using **radius**, sweeping from **a_min_of_12** to **a_max_of_12**.
+
+The angle is clockwise, one of the 12 angles (0-360), 0 degrees at 3 o'clock.
+
+The function uses pre calculated angles, and does not call expensive sin/cos. The number of segments is calculated automatically based on radius.
+
+### `PathEllipticalArcTo(center, radius, rot, a_min, a_max, num_segments)`
+
+Adds elliptic arc segment at **center** using **radius** (separate for x, y), with rotation, sweeping from **a_min** to **a_max**, with specified number of segments..
+
+The angle is clockwise, 0 degrees at 3 o'clock.
+
+The default segment count is *0* (calculate count automatically based on radius).
+
+### `PathBezierCubicCurveTo(p2, p3, p4, num_segments)`
+
+Adds cubic bezier curve described by *last path point*, **p2**, **p3**, and **p4**, with specified number of segments..
+
+The default segment count is *0* (calculate count automatically based on curvature).
+
+### `PathBezierQuadraticCurveTo(p2, p3, num_segments)`
+
+Adds quadratic bezier curve described by *last path point*, **p2**, and **p3**, with specified number of segments..
+
+The default segment count is *0* (calculate count automatically based on curvature).
+
+### `PathRect(rect_min, rect_max, rounding, flags)`
+
+Adds rectangle from **p_min** (top-left) to **p_max** ( bottom-right), rounding.
+
+The default rounding is **0.0**. Corner Rounding flags can be used.
+
+Corner rounding is clamped to fit inside the rectangle bounds.
### `PathStroke(col, thickness, flags)`
-Works as before. Support for stroke position was added. Fixes and improvements to `AddPolyline()` also apply.
-
-### `PathFillConcave(col)`
-
-Works as before.
+Strokes the staged path using `AddPolyline()` and clears the path. See `AddPolyline()` for more information.
### `PathFillConvex(col)`
-Works as before. The general improvements to `AddConvexPolyFilled()` apply to the convex filled path too.
+Fills the staged path using `AddConvexPolyFilled()` and clears the path. See `AddConvexPolyFilled()` for more information.
+### `PathFillConcave(col)`
+Fills the staged path using `AddConcavePolyFilled()` and clears the path. See `AddConcavePolyFilled()` for more information.
diff --git a/drawlist/bezier_cubic_basics.svg b/drawlist/bezier_cubic_basics.svg
index 143731a..ff0df17 100644
--- a/drawlist/bezier_cubic_basics.svg
+++ b/drawlist/bezier_cubic_basics.svg
@@ -1,15 +1,15 @@