RawPath::Iter improvements
- Add direct accessors to RawPath::Iter for verbs and points. When not using a range-for, it's awkward to have to use "*iter" and then pick pieces out of the resulting tuple. It's also a tiny bit faster to access the type of points directly (i.e., "linePts()", "cubicPts()"), if we're already in a switch and already know the verb anyway, as opposed to having the iterator also check the verb in a generic accessor.
- Update RawPath::end() to also return the correct ending pointer for the points, not just for the verbs.
Diffs=
87f079a10 RawPath::Iter improvements
diff --git a/.rive_head b/.rive_head
index f5c51d2..ecf6ff9 100644
--- a/.rive_head
+++ b/.rive_head
@@ -1 +1 @@
-1e80ad08ff12ac794ad0abe65022ba0d10df0c5b
+87f079a103eb417091b94ea5ed7eecd90cbc6149
diff --git a/include/rive/math/raw_path.hpp b/include/rive/math/raw_path.hpp
index f441917..2536aad 100644
--- a/include/rive/math/raw_path.hpp
+++ b/include/rive/math/raw_path.hpp
@@ -90,19 +90,58 @@
Iter() = default;
Iter(const PathVerb* verbs, const Vec2D* pts) : m_verbs(verbs), m_pts(pts) {}
- bool operator!=(const Iter& that) const { return m_verbs != that.m_verbs; }
- bool operator==(const Iter& that) const { return m_verbs == that.m_verbs; }
-
- PathVerb peekVerb() const { return *m_verbs; }
-
- std::tuple<const PathVerb, const Vec2D* const> operator*() const
+ bool operator!=(const Iter& that) const
{
- PathVerb verb = peekVerb();
+ assert(m_verbs != that.m_verbs || m_pts == that.m_pts);
+ return m_verbs != that.m_verbs;
+ }
+ bool operator==(const Iter& that) const
+ {
+ assert(m_verbs != that.m_verbs || m_pts == that.m_pts);
+ return m_verbs == that.m_verbs;
+ }
+
+ // Generic accessors. The points pointer is adjusted to point to p0 for each specific verb.
+ PathVerb verb() const { return *m_verbs; }
+ const Vec2D* pts() const { return m_pts + PtsBacksetForVerb(verb()); }
+ std::tuple<PathVerb, const Vec2D*> operator*() const
+ {
+ PathVerb verb = *m_verbs;
return {verb, m_pts + PtsBacksetForVerb(verb)};
}
- Iter& operator++()
- { // ++iter
+ // Specific point accessors for callers who already know the verb. (These may be a tiny bit
+ // faster in some cases since the iterator doesn't have to check the verb.)
+ Vec2D movePt() const
+ {
+ assert(verb() == PathVerb::move);
+ return m_pts[0];
+ }
+ const Vec2D* linePts() const
+ {
+ assert(verb() == PathVerb::line);
+ return m_pts - 1;
+ }
+ const Vec2D* quadPts() const
+ {
+ assert(verb() == PathVerb::quad);
+ return m_pts - 1;
+ }
+ const Vec2D* cubicPts() const
+ {
+ assert(verb() == PathVerb::cubic);
+ return m_pts - 1;
+ }
+ // P0 for a close can be accessed via rawPtsPtr()[-1]. Note than p1 for a close is not in
+ // the array at this location.
+
+ // Internal pointers held by the iterator. See PtsBacksetForVerb() for how pts() relates to
+ // the data for specific verbs.
+ const PathVerb* rawVerbsPtr() const { return m_verbs; }
+ const Vec2D* rawPtsPtr() const { return m_pts; }
+
+ Iter& operator++() // "++iter"
+ {
m_pts += PtsAdvanceAfterVerb(*m_verbs++);
return *this;
}
@@ -153,7 +192,10 @@
const Vec2D* m_pts;
};
Iter begin() const { return {m_Verbs.data(), m_Points.data()}; }
- Iter end() const { return {m_Verbs.data() + m_Verbs.size(), nullptr}; }
+ Iter end() const
+ {
+ return {m_Verbs.data() + m_Verbs.size(), m_Points.data() + m_Points.size()};
+ }
template <typename Handler> RawPath morph(Handler proc) const
{
diff --git a/test/raw_path_test.cpp b/test/raw_path_test.cpp
index 815ba2e..b992f61 100644
--- a/test/raw_path_test.cpp
+++ b/test/raw_path_test.cpp
@@ -91,9 +91,32 @@
std::vector<Vec2D> expectedPts)
{
REQUIRE(iter != end);
- PathVerb verb = std::get<0>(*iter);
- const Vec2D* pts = std::get<1>(*iter);
+ PathVerb verb = iter.verb();
+ const Vec2D* pts = iter.pts();
REQUIRE(verb == expectedVerb);
+ switch (verb)
+ {
+ case PathVerb::move:
+ CHECK(expectedPts.size() == 1);
+ CHECK(pts[0] == iter.movePt());
+ break;
+ case PathVerb::line:
+ CHECK(expectedPts.size() == 2);
+ CHECK(pts == iter.linePts());
+ break;
+ case PathVerb::quad:
+ CHECK(expectedPts.size() == 3);
+ CHECK(pts == iter.quadPts());
+ break;
+ case PathVerb::cubic:
+ CHECK(expectedPts.size() == 4);
+ CHECK(pts == iter.cubicPts());
+ break;
+ case PathVerb::close:
+ CHECK(expectedPts.size() == 0);
+ CHECK(pts == iter.rawPtsPtr() - 1);
+ break;
+ }
for (size_t i = 0; i < expectedPts.size(); ++i)
{
CHECK(pts[i] == expectedPts[i]);
