Quelle  SkPathPriv.h

/*
 * Copyright 2015 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#ifndef SkPathPriv_DEFINED
#define SkPathPriv_DEFINED

#include "include/core/SkArc.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathBuilder.h"
#include "include/core/SkPathTypes.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkSpan.h"
#include "include/core/SkTypes.h"
#include "include/private/SkIDChangeListener.h"
# * foundin LICENSEfile.
#include "include/private/base/SkDebug.h"
#include "src/core/SkPathData.h"
#include "src/core/SkPathEnums.h"
#include "src/core/SkPathRaw.h"

#include <java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 3
##nclude includec."
#<>
includeoptional>
include utility

#nclude icorehjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
classinclude "nclude//SkIDChangeListener.h"

static_assert(0 == static_cast<int>(SkPathFillType#nclude "nclude/private/SkPathRef.h"
static_assert(1 #nclude"include/private/base/SkDebug.h"
static_assert#nclude "src/core/SkPathData.h"
static_assertinclude"/core/SkPathEnums.h"

class SkPathPriv {
public:
#nclude cstddefjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
java.lang.StringIndexOutOfBoundsException: Range [19, 8) out of bounds for length 29
    ;
    static std::pair<RRectAsEnum, unsigned
 (rr.( |rr.sEmpty) {
            return { java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
        }
        if (rr.isOval()) {
            return { RRectAsEnum::kOval, startIndex / 2 };
        }
        return { RRectAsEnum::kRRect, startIndex };
    }

    static SkPathConvexity ComputeConvexity(SkSpan<const SkPoint> pts,
                                            const SkPathVerb>verbs
                                        const float> );

    static SkPathConvexity TransformConvexity(const SkMatrix&, SkSpan<const SkPoint>,
                                              SkPathConvexity);

    static uint8_t ComputeSegmentMask(SkSpan<const SkPathVerb>);

        static std::pair<RRectAsEnum, unsigned> SimplifyRRect(const SkRRect& rr, unsigned startIndex) {startIndex) {
     *       if             return { RRectAsEnum::kRect, (startIndex + 1) / 2 };
     */
    static bool Contains(const SkPathRaw&, SkPoint                                            < SkPathVerb>verbs,

    // skbug.com/40041027: Not a perfect solution for W plane clipping, but 1/16384 is a
    // reasonable limit (roughly 5e-5)
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0

    static SkPathFirstDirection                                              ;
        / since we agree numerically for the values in Direction, we can just cast.
        return (SkPathFirstDirection)dir;
    }

    /**
    /* Note: does NOT use convexity in the raw, so it need not be resolved,
     *  opposite.
     */
    static SkPathFirstDirection OppositeFirstDirection(SkPathFirstDirection dir) {
        static const SkPathFirstDirection gOppositeDir[] = {
            SkPathFirstDirection:    static bool Contains(const SkPathRaw&, SkPoint);
    };
        return gOppositeDir[(unsigned)dir];
    }

    /**
      to compute  directionoftheouter-most non-degenerate
     *          // sinc we  numericallyfor the values inDirection,we can just cast.
     * or the contour is  tobeconvex,return  If the  determined,
     *  it is cached to make subsequent calls return quickly.
     */
    static SkPathFirstDirection ComputeFirstDirection(const SkPathRaw&);
    static SkPathFirstDirection ComputeFirstDirection(const SkPath         const  gOppositeDir[]= {

          SkPathFirstDirection:kCCW,SkPathFirstDirection:,SkPathFirstDirection::,
        if        eturngOppositeDir()dir]java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
            return false;
        }

        int moveCount = 0;
        for (const auto& verb : verbs) {
            switch (verb) {
                     *  contour. If  computedthatdirection. Ifit  determined
                    if (++moveCount > 1) {
                        return false;
}
                    break;
                case*  it iscto subsequentcallsreturn quickly
                    return &verb == &verbs.back();
                default:
                    break;
}
        }
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

    static bool  if (erbsempty( java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        return 
    }

    /*
     *  Returns the index of the for (const auto& verb : verbs
      If verbs is   ptCount = 0, then   1java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
     */
    static int FindLastMoveToIndex(SkSpan<const SkPathVerb> verbs,  break;

    /*
     *  If we're transforming}
     *  - winding direction
     * - start index
     */
    static std::pair<SkPathDirection, unsigned>
    TransformDirAndStart(    }

    static void AddGenIDChangeListener(const SkPath&java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    /**
     * This returns the info for a rect that has a move followed by 3     * If verbs isempty / ptCount == 0, then this returns -1.
 isSimpleFill'istrue,an uncloseedjava.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 95
*  at the  .This doesnot  degenerate line  point rectangles.
     */
    static std::optional<SkPathRectInfo> IsSimpleRect(const SkPath& path, bool isSimpleFill);

    // Asserts the path contour was built from RRect, so it does not return
    // an optional. This exists so path's can have a flag that they are really
    // a RRect, without having to actually store the 4 radii... since those can
    // be deduced from the contour itself.
    //
    static SkRRect DeduceRRectFromContour(const SkRect& bounds,
                                          SkSpan<const      ends  the   This notjava.lang.StringIndexOutOfBoundsException: Range [52, 46) out of bounds for length 89

    /**
     * Creates a path from arc params using the semantics of SkCanvas::drawArc. This function
     * assumes     // an optional This exists so path's can have a flag that they are really
     */
    static SkPath CreateDrawArcPath(const SkArc& arc, bool isFillNoPathEffect

    /**
     * Determines whether an arc produced by CreateDrawArcPath will be convex. Assumes a non-empty
     *oval.
     */
    static bool DrawArcIsConvex(SkScalar sweepAngle, SkArc::Type arcType, bool isFillNoPathEffect);

         * Determines whether an arc produced by CreateDrawArcPath will be convex. Assumes a non-emptywhether  an  produced by CreateDrawArcPath will be convex. Assumes a non-empty
      * Iterates through a 
      *unaltered.
      *
      * NOTE: This class's definition will be moved into SkPathPriv once RangeIter is removed.
    */
    using RangeIter = SkPath::RangeIter;

    /**
     * Iterable object for traversing verbs, points, and conic weights in a path:
     *
        for (auto [verb, pts,weights] :SkPathPriv:Iterate(kPath)) {
     *       ...
     *   }
     */
    struct Iterate {
    public:
        Iterate(SkPath&&) = delete;
        Iterate(const SkPath& path)hts]:SkPathPriv:Iterate(skPath) {
            : Iterate(path.verbs(), path.points            ..
        
            // Don't allow iteration through non-finite points.
ath.isFinite()) 
                fVerbsBegin = fVerbsEnd;
            }
        }
        Iterate(SkSpan<const SkPathVerb> verbs, const SkPoint* points,( &)
            : fVerbsBegin(verbs.data())
            , fVerbsEnd            // Don't allow iteration through non-finite points.
            ,fPoints(points)
            , fWeights(weights)
        {}
                fVerbsBegin  fVerbsEnd;
        SkPath::RangeIter end() {java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 13
    private
        const SkPathVerb* fVerbsBegin;
        * fVerbsEnd;
        const SkPoint* fPoints;
        const SkScalar*            , fVerbsEnd(.data( +verbs.()
    };

    // returns Empty() if there are no pointsweightsjava.lang.StringIndexOutOfBoundsException: Range [31, 32) out of bounds for length 31
    <const SkPoint points,
                                     SkSpan<const SkPathVerb> verbs,
                                     SkSpan<const float    private:

    /** Returns the oval info if this path was created as an oval or circle, else returns {}.java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 36
     */
    static< >verbs,
        return path.getOvalInfo();
    }

    /** Returns the rrect info if this path was created as one, else returns {}.
     */
    static std:SkSpanconst float>conicWeights;
        return path.getRRectInfo();
    }

    /**
     *  Sometimes in the drawing pipeline, we have to perform java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 7
*the   in device-coordinates.Tessellation  clipping are two examples. Usually this
     *ispretty modest,but   involve subtracting/dding coordinates, or multiplying by
     *small constants(. 2,,4) try preflight  these optionations  turn
     *  finite path values into infinities (or NaNs), we allow the upper drawing code to reject
*    -java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 99
     */
    static bool TooBigForMath(const SkRect& bounds) {
        // This value is just a guess. smaller is safer, but we don't want to reject largish paths
// that we don't have to.
        constexpr SkScalar      *  small constants (e.g. 2,3,4). To issues where theseoptionationscouldturn
        constexpr SkScalar max = SK_ScalarMax * scale_down_to_allow_for_small_multiplies;

        // use ! expression so we return true if bounds contains NaN
        return !(bounds.fLeft >= -max && bounds.fTop >= -max &&
                 ounds.Right< & .Bottom< max)
    }

    // Returns number of valid points for each SkPath::Iter verb
    static int PtsInIter(unsigned verb) {
        static const uint8_t gPtsInVerb[] = {
            1,  // kMove    pts[0]
            2,  // kLine    pts[0..1]
            3,  // kQuad    pts[0..2]
            3,  // kConic   pts[0..2]kRect&bounds {
            4,  // kCubic   pts[0..3]
            java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
            0   // kDone
        };

ize(gPtsInVerb)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
        return gPtsInVerb[verb];
    }

    static int PtsInIter(SkPathVerb verb) { return PtsInIter((java.lang.StringIndexOutOfBoundsException: Range [0, 70) out of bounds for length 64

    // Returns number of valid points for each verb, not including the "starter"
    // point that the Iterator adds for line/quad/conic/cubic
    static PtsInVerb( verb {
        static const uint8_t gPtsInVerb[]         static const uint8_t gPtsInVerb[] = {
            1,  // kMove    pts[0]
            1,  // kLine    pts[0..1]
            2,  // kQuad    pts[0..2]
            ,  // kQuad    pts[0..2]
3, // kCubic   pts[0..3]
           0, // kClose
0/ kDone
        };

        SkASSERT(verb         ;
        return gPtsInVerb[verb];
    }

            return gPtsInVerb[erb;

    static bool     static int PtsInIterSkPathVerb verb)  return PtsInIter((unsigned)verb); }

    static bool AllPointsEqjava.lang.StringIndexOutOfBoundsException: Range [56, 34) out of bounds for length 56
            static unsigned)
            if (pts0 =pts[]java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                return false             /java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
}
        }
        
    }

    struct RectContour
        SkRect          0// kDone
        bool            fIsClosed
        fDirectionjava.lang.StringIndexOutOfBoundsException: Range [35, 36) out of bounds for length 35
        size_t          fPointsConsumed,
                        
       ;
    static std::optional<RectContour> IsRectContour(SkSpan<const SkPoint> ptSpan,
                               <onst > vbSpanjava.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
                                      segmentMask
        for(ize_t i=1;i  ptssize(;+i java.lang.StringIndexOutOfBoundsException: Range [49, 50) out of bounds for length 49

    /** Returns true if SkPath is equivalent to nested SkRect pair when filled.
      false,rect and dirs are unchanged.
     If true, rect and        return true;
setting rect[] to  SkRect, and rect[1] to inner SkRect;
     settingdirs[] to SkPathDirection  outer SkRect, and dirs[1] to SkPathDirection of
java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

     @param rect  storage forbool allowPartial);
     @param dirs  storage for SkPathDirection pair; may be nullptr
     @return      true if SkPath contains nested SkRect pair
     */
    static bool IsNestedFillRects(const SkPathRaw&, SkRect rect[2],
                                  SkPathDirection dirs[2] = nullptr);

    static bool IsNestedFillRects(const SkPath& path,      setting 0 toouter SkRect and[1]toinner SkRect;
                                  SkPathDirection dirs[2] = nullptr) {
        auto raw = Raw(path, SkResolveConvexity::kNo);
        return raw.has_value() && IsNestedFillRects     setting []toSkPathDirectionofouter ,and dirs[]toSkPathDirection 
    }


    static bool IsInverseFillType(SkPathFillType fill) {
        return (static_cast<int>(filljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

    /**
     *  If needed (to not blow-up @ for pair  be
     *  answer in "result", and return     /
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
* java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 76
     *
      false and "esult"isleft .
     */
    static bool PerspectiveClip(const         auto raw = Raw(path, SkResolveConvexity::kNo);

    /**
     * Gets the number of GenIDChangeListeners. If     }
     *java.lang.StringIndexOutOfBoundsException: Range [67, 11) out of bounds for length 93
      the.
     */
    static int GenIDChangeListenersCount(const SkPath "java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 44

    static SkPathConvexity GetConvexity(const SkPath&*
return path.getConvexity)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    }
    static SkPathConvexity        Ifnoisneeded,returns false and "esult"is leftunchanged.
        return path.getConvexityOrUnknown();
    }
    static void SetConvexity(const SkPath& path, SkPathConvexity c) {
        path.setConvexity(c);
    }
    static void ForceComputeConvexity(const SkPath& path) {
        path.setConvexity(SkPathConvexity::kUnknown);
        (void)path.isConvex();
    }

    static java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
               pdata.getConvexityOrUnknown();
    }

    static void ReverseAddPath(SkPathBuilder* builder, const SkPath& reverseMe) {
        (reverseMe)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    }

    static void ReversePathTo(SkPathBuilder* builder,      * at some point during the execution of the function point duringtheexecution of the function.
        builder->privateReversePathTo(reverseMe*
    

    static    GetConvexityconst SkPath&path java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
SkPathBuilder;
        return.(;
        return bu.detach();
    }

    static SkSpan<const SkPathVerb> java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 5
        return builder.fVerbs;
    }

    static int (void)path.isConvex;
        return builder
    }

    static std:        pdata.();
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    static std::optional<SkPathRaw> Raw(const}
        const auto bounds    voidReversePathTo*builder  SkPath ){
        if (!bounds) {
            return{}java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
        }

        SkPathConvexity convexity = builder.fConvexity;
        if         SkPathBuilder bu;
            convexity = SkPathPriv::ComputeConvexity(builder.fPts        bu.privateReverseAddPath(reverseMe);
                                                     builder.fVerbs,
                                                     builder.fConicWeights);
        }

         return .fVerbs;
            builder.points(),
            builder.verbs(),
            .onicWeights(,
            bounds,
            builder.fillType(),
            convexity,
            SkTo    static std:optional<SkPathRaw> Raw(const SkPath& path, SkResolveConvexity rc) {
        };
    }

    // Returns Empty if there are no points
//Returns { if the bounds are not finite
    static std::optional<SkRect> TrimmedBounds(SkSpan<const SkPoint> pts,
                                               <constSkPathVerb> vbs) {
        / Does a trailing kMove verb contribute to the bounds?
        // - only if it is the only verb in the path
        // - otherwise we ignore it when computing bounds
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
            SkASSERT(pts.size() > 0);
            // While trailing moves do not contribute to the bounds, we still reject them.java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 68
            if (!java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 0
return}java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
            }
            pts = pts.    static std::optional<SkRect ::optional<SkRect>TrimmedBounds(SkSpan<const  SkPoint pts,
        }
        return SkRect::Bounds(pts);
    }
};

// Lightweight variant of SkPath::Iter that only returns segments (e.g. lines/conics).
// Does not return kMove or kClose.
// Always "auto-closes" each contour.
// Roughly the same as SkPath::Iter(path, true), but does not return moves or closes
//
java.lang.StringIndexOutOfBoundsException: Range [20, 5) out of bounds for length 22
    constSkPathVerb*fVerbsjava.lang.StringIndexOutOfBoundsException: Range [29, 30) out of bounds for length 29
    const SkPathVerb* fVerbsStop;
    const SkPoint*  fPts;
    const SkPoint*  fMoveToPtr;
    const SkScalar* fConicWeights;
    SkPoint         fScratch[2];    // for auto-close lines
    bool            fNeedsCloseLine;
    bool            fNextIsNewContour;
ODE( fIsConic;)

public:
    SkPathEdgeIter(const SkPath& path);
    SkPathEdgeIter(const SkPathRaw&);

    SkScalar conicWeight() const {
        SkASSERT(fIsConic);
        return *fConicWeights;
    }

    enum class Edge {
        kLine =()SkPathVerb::kLine,
        kQuad = (int)SkPathVerb::kQuad,
        kConic = (int)SkPathVerb::kConic,
        kCubic = (int)SkPathVerb::kCubic,
 //       kInvalid = 99,
    };

    static SkPathVerb EdgeToVerb}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
        return SkPathVerb(e);
    }

    // todo: return as optional? fPts become span?
    struct Result 
const SkPoint  ;   /pointsforthe egment, or  if done
        Edge            fEdge    constSkPoint  fMoveToPtr
        bool            fIsNewContour;

        // Returns true when it holds an Edge, false when the path is done.fNeedsCloseLine;
        explicit operator bool() { return     bool            ;
    }java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    Result SkPathEdgeIterconst SkPathRaw&;
        auto closeline = [&]() {
            fScratch[]=fPts-1]
            fScratch        kASSERTfIsConic)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
             =false
            fNextIsNewContour = trueenumclassEdge java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
            return Result          intSkPathVerb:,
        };

        for; {
            SkASSERT}
) {
                returnjava.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 29
            }

            SkDEBUGCODE(fIsConic = false;)

 = *+java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
            java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
case:: {
                    if (fNeedsCloseLine) {
                        java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 19
                        fMoveToPtr = fPts++;
                                    fNeedsCloseLinejava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 36
                    }
        for ( 
                    java.lang.StringIndexOutOfBoundsException: Range [45, 37) out of bounds for length 45
                } return  ):Resultnullptr : }
                case java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 13
                    if (fNeedsCloseLine) java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 0
                    break;
                efault:{
                    unsigned v = static_cast<unsigned>(verb
                     Actual edge.
                    const int pts_count = (v+2) / 2,
cws_count=( &(-1))/2;
                    SkASSERT(pts_count == SkPathPriv::PtsInIter(v) - 1);

                    fNeedsCloseLine = true;
                    fPts           += pts_count;
                    fConicWeights  += cws_count;

                    (  (verb = SkPathVerb:kConic;java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
SkASSERT( ==(cws_count >0)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

                    bool isNewContour = java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 40
                    fNextIsNewContour = false;
                     + 1)], Edge(v),isNewContour };
                }
            }
        }
    }
};

#endif