@hxa-rn/react-native-gcanvas 6.0.24-beta.1

package/harmony/gcanvas/src/main/cpp/core/src/gcanvas/GPath.cpp

@@ -0,0 +1,1213 @@
+/**
+ * Created by G-Canvas Open Source Team.
+ * Copyright (c) 2017, Alibaba, Inc. All rights reserved.
+ *
+ * This source code is licensed under the Apache Licence 2.0.
+ * For the full copyright and license information, please view
+ * the LICENSE file in the root directory of this source tree.
+ */
+#include "GPath.h"
+#include "GCanvas2dContext.h"
+
+#define G_PATH_RECURSION_LIMIT 8
+#define G_PATH_DISTANCE_EPSILON 1.0f
+#define G_PATH_COLLINEARITY_EPSILON FLT_EPSILON
+#define G_PATH_STEPS_FOR_CIRCLE 48.0f
+#define G_PATH_ANGLE_EPSILON = 0.01;
+
+#define ERROR_DEVIATION 1e-6
+#define PI_1 M_PI
+#define PI_2 2.f * M_PI
+#define DEFAULT_STEP_COUNT 100
+
+static bool isSamePoint(GPoint &p1, GPoint &p2, float min)
+{
+    return abs(p1.x - p2.x) < min && abs(p1.y - p2.y) < min;
+}
+
+static bool isNan(const GPoint &p)
+{
+    return std::isnan(p.x) || std::isnan(p.y);
+}
+
+static bool hasSamePoint(GPoint &p1, GPoint &p2, GPoint &p3, float minValue)
+{
+    return isSamePoint(p1, p2, minValue) || isSamePoint(p2, p3, minValue) || isSamePoint(p1, p3, minValue);
+}
+
+static bool isTrianglePointsValid(GPoint &p1, GPoint &p2, GPoint &p3, float minValue)
+{
+    if (isNan(p1) || isNan(p3) || isNan(p2))
+    {
+        return false;
+    }
+    return hasSamePoint(p1, p2, p3, minValue) ? false : true;
+}
+
+GPath::GPath() { Reset(); }
+
+GPath::GPath(const GPath &other)
+{
+    mDistanceTolerance = other.mDistanceTolerance;
+    mHasInitStartPosition = other.mHasInitStartPosition;
+    mStartPosition = other.mStartPosition;
+    mCurrentPosition = other.mCurrentPosition;
+    mCurPath = other.mCurPath;
+    mPathStack = other.mPathStack;
+    mFillRule = other.mFillRule;
+    mMinPosition = other.mMinPosition;
+    mMaxPosition = other.mMaxPosition;
+}
+
+tSubPath &GPath::GetCurPath()
+{
+    if (mPathStack.empty())
+    {
+        mPathStack.resize(1);
+    }
+
+    return mPathStack[mPathStack.size() - 1];
+}
+
+void GPath::Reset()
+{
+    mPathStack.clear();
+    tSubPath &curPath = GetCurPath();
+    curPath.isClosed = false;
+    curPath.points.clear();
+    mHasInitStartPosition = false;
+
+    mStartPosition = PointMake(0, 0);
+    mCurrentPosition = PointMake(0, 0);
+
+    mFillRule = FILL_RULE_NONZERO;
+    mMinPosition = PointMake(INFINITY, INFINITY);
+    mMaxPosition = PointMake(-INFINITY, -INFINITY);
+}
+
+void GPath::EndSubPath()
+{
+    tSubPath &curPath = GetCurPath();
+    if (!curPath.points.empty())
+        mPathStack.resize(mPathStack.size() + 1);
+
+    GetCurPath().isClosed = false;
+    mStartPosition = mCurrentPosition;
+    mHasInitStartPosition = true;
+}
+
+void GPath::push(GPoint pt) { push(pt.x, pt.y); }
+
+void GPath::push(float x, float y)
+{
+    GPoint p = PointMake(x, y);
+
+    tSubPath &curPath = GetCurPath();
+
+    curPath.points.push_back(p);
+    mCurrentPosition.x = x;
+    mCurrentPosition.y = y;
+    mMinPosition.x = std::min<float>(mMinPosition.x, x);
+    mMinPosition.y = std::min<float>(mMinPosition.y, y);
+    mMaxPosition.x = std::max<float>(mMaxPosition.x, x);
+    mMaxPosition.y = std::max<float>(mMaxPosition.y, y);
+}
+
+void GPath::MoveTo(float x, float y)
+{
+    EndSubPath();
+
+    mStartPosition = PointMake(x, y);
+    mHasInitStartPosition = true;
+    push(x, y);
+}
+
+void GPath::LineTo(float x, float y) { push(x, y); }
+
+void GPath::Close()
+{
+    GetCurPath().isClosed = true;
+    if (mHasInitStartPosition)
+    {
+        push(mStartPosition);
+    }
+    EndSubPath();
+}
+
+void GPath::QuadraticCurveTo(float cpx, float cpy, float x, float y,
+                             float scale)
+{
+    mDistanceTolerance = G_PATH_DISTANCE_EPSILON / scale;
+    mDistanceTolerance *= mDistanceTolerance;
+
+    recursiveQuadratic(mCurrentPosition.x, mCurrentPosition.y, cpx, cpy, x, y, 0);
+
+    push(x, y);
+}
+
+void GPath::recursiveQuadratic(float x1, float y1, float x2, float y2,
+                               float x3, float y3, int level)
+{
+    float x12 = (x1 + x2) / 2;
+    float y12 = (y1 + y2) / 2;
+    float x23 = (x2 + x3) / 2;
+    float y23 = (y2 + y3) / 2;
+    float x123 = (x12 + x23) / 2;
+    float y123 = (y12 + y23) / 2;
+
+    float dx = x3 - x1;
+    float dy = y3 - y1;
+    float d = fabsf(((x2 - x3) * dy - (y2 - y3) * dx));
+
+    if (d > G_PATH_COLLINEARITY_EPSILON)
+    {
+        // Regular care
+        if (d * d <= mDistanceTolerance * (dx * dx + dy * dy))
+        {
+            push(x123, y123);
+            return;
+        }
+    }
+    else
+    {
+        // Collinear case
+        dx = x123 - (x1 + x3) / 2;
+        dy = y123 - (y1 + y3) / 2;
+        if (dx * dx + dy * dy <= mDistanceTolerance)
+        {
+            push(x123, y123);
+            return;
+        }
+    }
+
+    if (level <= G_PATH_RECURSION_LIMIT)
+    {
+        // Continue subdivision
+        recursiveQuadratic(x1, y1, x12, y12, x123, y123, level + 1);
+        recursiveQuadratic(x123, y123, x23, y23, x3, y3, level + 1);
+    }
+}
+
+void GPath::BezierCurveTo(float cp1x, float cp1y, float cp2x, float cp2y,
+                          float x, float y, float scale)
+{
+    mDistanceTolerance = G_PATH_DISTANCE_EPSILON / scale;
+    mDistanceTolerance *= mDistanceTolerance;
+
+    GPoint points[4] = {
+        PointMake(mCurrentPosition.x, mCurrentPosition.y),
+        PointMake(cp1x, cp1y),
+        PointMake(cp2x, cp2y),
+        PointMake(x, y),
+    };
+
+    SubdivideCubicTo(this, points, 4);
+    push(x, y);
+}
+
+void GPath::recursiveBezier(float x1, float y1, float x2, float y2, float x3,
+                            float y3, float x4, float y4, int level)
+{
+    // Based on http://www.antigrain.com/research/adaptive_bezier/index.html
+
+    //     Calculate all the mid-points of the line segments
+    float x12 = (x1 + x2) / 2;
+    float y12 = (y1 + y2) / 2;
+    float x23 = (x2 + x3) / 2;
+    float y23 = (y2 + y3) / 2;
+    float x34 = (x3 + x4) / 2;
+    float y34 = (y3 + y4) / 2;
+    float x123 = (x12 + x23) / 2;
+    float y123 = (y12 + y23) / 2;
+    float x234 = (x23 + x34) / 2;
+    float y234 = (y23 + y34) / 2;
+    float x1234 = (x123 + x234) / 2;
+    float y1234 = (y123 + y234) / 2;
+
+    if (level > 0)
+    {
+        float dx = x4 - x1;
+        float dy = y4 - y1;
+
+        float d2 = fabsf(((x2 - x4) * dy - (y2 - y4) * dx));
+        float d3 = fabsf(((x3 - x4) * dy - (y3 - y4) * dx));
+
+        if (d2 > G_PATH_COLLINEARITY_EPSILON &&
+            d3 > G_PATH_COLLINEARITY_EPSILON)
+        {
+            // Regular care
+            if ((d2 + d3) * (d2 + d3) <=
+                mDistanceTolerance * (dx * dx + dy * dy))
+            {
+                push(x1234, y1234);
+                return;
+            }
+        }
+        else
+        {
+            if (d2 > G_PATH_COLLINEARITY_EPSILON)
+            {
+                // p1,p3,p4 are collinear, p2 is considerable
+                if (d2 * d2 <= mDistanceTolerance * (dx * dx + dy * dy))
+                {
+                    push(x1234, y1234);
+                    return;
+                }
+            }
+            else if (d3 > G_PATH_COLLINEARITY_EPSILON)
+            {
+                // p1,p2,p4 are collinear, p3 is considerable
+                if (d3 * d3 <= mDistanceTolerance * (dx * dx + dy * dy))
+                {
+                    push(x1234, y1234);
+                    return;
+                }
+            }
+            else
+            {
+                // Collinear case
+                dx = x1234 - (x1 + x4) / 2;
+                dy = y1234 - (y1 + y4) / 2;
+                if (dx * dx + dy * dy <= mDistanceTolerance)
+                {
+                    push(x1234, y1234);
+                    return;
+                }
+            }
+        }
+    }
+
+    if (level <= G_PATH_RECURSION_LIMIT)
+    {
+        // Continue subdivision
+        recursiveBezier(x1, y1, x12, y12, x123, y123, x1234, y1234, level + 1);
+        recursiveBezier(x1234, y1234, x234, y234, x34, y34, x4, y4, level + 1);
+    }
+}
+
+void GPath::ArcTo(float x1, float y1, float x2, float y2, float radius)
+{
+    // Lifted from http://code.google.com/p/fxcanvas/
+    GPoint cp = mCurrentPosition;
+
+    float a1 = cp.y - y1;
+    float b1 = cp.x - x1;
+    float a2 = y2 - y1;
+    float b2 = x2 - x1;
+    float mm = fabsf(a1 * b2 - b1 * a2);
+
+    if (mm < 1.0e-8 || radius == 0)
+    {
+        LineTo(x1, y1);
+    }
+    else
+    {
+        float dd = a1 * a1 + b1 * b1;
+        float cc = a2 * a2 + b2 * b2;
+        float tt = a1 * a2 + b1 * b2;
+        float k1 = radius * sqrtf(dd) / mm;
+        float k2 = radius * sqrtf(cc) / mm;
+        float j1 = k1 * tt / dd;
+        float j2 = k2 * tt / cc;
+        float cx = k1 * b2 + k2 * b1;
+        float cy = k1 * a2 + k2 * a1;
+        float px = b1 * (k2 + j1);
+        float py = a1 * (k2 + j1);
+        float qx = b2 * (k1 + j2);
+        float qy = a2 * (k1 + j2);
+        float startAngle = atan2f(py - cy, px - cx);
+        float endAngle = atan2f(qy - cy, qx - cx);
+
+        Arc(cx + x1, cy + y1, radius, startAngle, endAngle,
+            (b1 * a2 > b2 * a1));
+    }
+}
+
+void GPath::Arc(float cx, float cy, float radius, float startAngle,
+                float endAngle, bool antiClockwise)
+{
+    float spanAngle = endAngle - startAngle;
+    if (antiClockwise)
+    {
+        spanAngle = -spanAngle;
+    }
+
+    float spanAngleAbs = fabs(spanAngle);
+    if (spanAngleAbs < ERROR_DEVIATION)
+    { // the same angle,do nothing
+        return;
+    }
+
+    float pi2 = PI_2;
+
+    if (spanAngleAbs > pi2)
+    {
+        spanAngle = pi2;
+    }
+    else
+    {
+        while (spanAngle < 0)
+        {
+            spanAngle += pi2 * 2;
+        }
+        while (spanAngle > pi2)
+        {
+            spanAngle -= pi2;
+        }
+    }
+
+    int stepCount = DEFAULT_STEP_COUNT * (spanAngle / pi2);
+    bool isCircle = (stepCount == DEFAULT_STEP_COUNT);
+
+    if (stepCount < 1)
+    {
+        stepCount = 1;
+    }
+    float deltaAngle = spanAngle / stepCount;
+    if (antiClockwise)
+    {
+        deltaAngle = -deltaAngle;
+    }
+
+    float dx = cosf(deltaAngle);
+    float dy = sinf(deltaAngle);
+
+    float xOffset = radius * cosf(startAngle);
+    float yOffset = radius * sinf(startAngle);
+
+    for (int step = 0; step <= stepCount; ++step)
+    {
+        if (step == 0)
+        {
+
+            if (isCircle)
+            { //remove moveTo while isCircle
+                if (!GetCurPath().isClosed)
+                {
+                    tSubPath &curPath = GetCurPath();
+                    if (curPath.points.size() == 1)
+                    {
+                        curPath.points.pop_back();
+                    }
+                }
+            }
+
+            if (!GetCurPath().isClosed)
+            {
+                tSubPath &curPath = GetCurPath();
+                if (curPath.points.size() == 0)
+                {
+                    mHasInitStartPosition = true;
+                    mStartPosition = PointMake(cx + xOffset, cy + yOffset);
+                }
+            }
+        }
+        push(cx + xOffset, cy + yOffset);
+
+        float oldX = xOffset, oldY = yOffset;
+        xOffset = oldX * dx - oldY * dy;
+        yOffset = oldX * dy + oldY * dx;
+    }
+}
+
+void GPath::ClipRegion(GCanvasContext *context)
+{
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+
+    glEnable(GL_STENCIL_TEST);
+    // clip use high mask bit
+    GLuint mask = 0x80;
+    GLuint ref = 0x80;
+    glStencilMask(mask);
+
+    // use stencil func
+    if (context->HasClipRegion())
+    {
+        glStencilFunc(GL_EQUAL, ref, mask);
+        glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
+    }
+    else
+    {
+        glClear(GL_STENCIL_BUFFER_BIT);
+        glStencilFunc(GL_ALWAYS, ref, mask);
+        glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
+    }
+
+    for (std::vector<tSubPath>::const_iterator pathIter =
+             mPathStack.begin();
+         pathIter != mPathStack.end(); ++pathIter)
+    {
+        const std::vector<GPoint> &path = pathIter->points;
+        if (path.size() < 3)
+        {
+            continue;
+        }
+
+        glVertexAttribPointer(context->PositionSlot(), 2, GL_FLOAT, GL_FALSE,
+                              sizeof(GPoint), &(path.front()));
+        context->mDrawCallCount++;
+        glDrawArrays(GL_TRIANGLE_FAN, 0, (GLsizei)path.size());
+    }
+    context->BindPositionVertexBuffer();
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+
+    // reset stencil
+    SetStencilForClip();
+}
+void GPath::PushTriangleFanPoints(GCanvasContext *context, tSubPath *subPath, GColorRGBA color)
+{
+    std::vector<GPoint> &pts = subPath->points;
+    if (subPath->isClosed)
+    {
+        context->PushTriangleFanPoints(pts, color);
+    }
+    else
+    {
+        // push head point
+        pts.push_back(pts.front());
+        context->PushTriangleFanPoints(pts, color);
+        pts.pop_back();
+    }
+    context->SendVertexBufferToGPU(GL_TRIANGLE_FAN);
+}
+
+void GPath::DrawPolygons2DToContext(GCanvasContext *context, GFillRule rule, GFillTarget target)
+{
+
+    GLint bindFBO = 0;
+    glGetIntegerv(GL_FRAMEBUFFER_BINDING, &bindFBO);
+
+    context->SendVertexBufferToGPU();
+
+    GColorRGBA color = BlendColor(context, context->mCurrentState->mFillColor);
+
+    // Disable drawing to the color buffer, enable the stencil buffer
+    if (context->mCurrentState->mShader)
+    {
+        if (context->mCurrentState->mShader->GetTexcoordSlot() > 0)
+        {
+            glDisableVertexAttribArray((GLuint)context->mCurrentState->mShader->GetTexcoordSlot());
+        }
+        glDisableVertexAttribArray((GLuint)context->mCurrentState->mShader->GetColorSlot());
+    }
+
+    glDisable(GL_BLEND);
+    glEnable(GL_STENCIL_TEST);
+    glStencilMask(0xff);
+
+    glStencilFunc(GL_ALWAYS, 0, 0xff);
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+
+    // Clear the needed area in the stencil buffer
+    glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO);
+    GColorRGBA white = {1, 1, 1, 1};
+
+    GPoint minPos = mMinPosition;
+    GPoint maxPos = mMaxPosition;
+
+    context->PushRectangle(minPos.x, minPos.y, maxPos.x - minPos.x, maxPos.y - minPos.y, 0, 0, 0, 0, white);
+    context->SendVertexBufferToGPU();
+
+    if (rule == FILL_RULE_NONZERO)
+    {
+        glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP);
+        glStencilOpSeparate(GL_BACK, GL_KEEP, GL_KEEP, GL_DECR_WRAP);
+    }
+    else if (rule == FILL_RULE_EVENODD)
+    {
+        glStencilOp(GL_KEEP, GL_KEEP, GL_INVERT);
+    }
+
+    for (std::vector<tSubPath>::iterator iter = mPathStack.begin(); iter != mPathStack.end(); ++iter)
+    {
+        tSubPath path = *iter;
+
+        if (path.points.size() == 0)
+            continue;
+
+        if (context->mCurrentState->mShader)
+        {
+            glVertexAttribPointer((GLuint)context->mCurrentState->mShader->GetPositionSlot(), 2,
+                                  GL_FLOAT, GL_FALSE, 0,
+                                  &(path.points.front()));
+        }
+        context->mDrawCallCount++;
+        glDrawArrays(GL_TRIANGLE_FAN, 0, (int)path.points.size());
+    }
+
+    context->BindVertexBuffer();
+
+    //enable color or depth buffer, push a rect with the correct size and color
+    if (target == FILL_TARGET_DEPTH)
+    {
+        glDepthFunc(GL_ALWAYS);
+        glDepthMask(GL_TRUE);
+        glClear(GL_DEPTH_BUFFER_BIT);
+    }
+    else if (target == FILL_TARGET_COLOR)
+    {
+        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+        glEnable(GL_BLEND);
+    }
+
+    glStencilFunc(GL_NOTEQUAL, 0x00, 0xff);
+    glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO);
+
+    context->PushRectangle(minPos.x, minPos.y, maxPos.x - minPos.x, maxPos.y - minPos.y, 0, 0, 0, 0, color);
+    context->SendVertexBufferToGPU();
+
+    glDisable(GL_STENCIL_TEST);
+
+    if (target == FILL_TARGET_DEPTH)
+    {
+        glDepthMask(GL_FALSE);
+        glDepthFunc(GL_EQUAL);
+
+        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+        glEnable(GL_BLEND);
+    }
+}
+
+void GPath::drawArcToContext(GCanvasContext *context, GPoint point,
+                             GPoint p1, GPoint p2, GColorRGBA color, std::vector<GVertex> *vec, float samePointThreshold)
+{
+    // filter invalid point
+    bool fixAndroidCompatible = false;
+#ifdef ANDROID
+    fixAndroidCompatible = true;
+#endif
+
+    float minValue = samePointThreshold;
+    // LOG_I("drawArcToContext p1(%f,%f),p2(%f,%f),p3(%f,%f)", p1.x, p1.y, p2.x, p2.y, point.x,point.y);
+    if (fixAndroidCompatible && (isSamePoint(point, p1, minValue) || isSamePoint(p1, p2, minValue) || isSamePoint(point, p2, minValue)))
+    {
+        // LOG_I("isSamePoint, exit: ");
+        return;
+    }
+
+    // filter nan pint
+    if (isNan(point) || isNan(p1) || isNan(p2))
+    {
+        // LOG_I("isNan check true");
+        return;
+    }
+
+    float width2 = context->LineWidth();
+    if (width2 * context->GetPixelScale() >= 2)
+    {
+        width2 /= 2.f;
+    }
+
+    GPoint v1 = PointNormalize(PointSub(p1, point)),
+           v2 = PointNormalize(PointSub(p2, point));
+
+    float angle2;
+    if (v1.x == -v2.x && v1.y == -v2.y)
+    {
+        angle2 = M_PI;
+    }
+    else
+    {
+		float v = v1.x * v2.x + v1.y * v2.y;
+		if( v < -1.0 ) {
+			v = -1.0;
+		}
+		else if( v > 1.0 ) {
+			v = 1.0;
+		}
+		angle2 = acosf( v );
+    }
+
+    if (fixAndroidCompatible && std::isnan(angle2))
+    {
+        return;
+    }
+
+    // 1 step per 5 pixel
+    float needStep = (angle2 * width2 * context->GetPixelScale()) / 5.0f;
+    int numSteps = 0;
+    if (fixAndroidCompatible)
+    {
+        if (needStep < minValue)
+        {
+            numSteps = 0;
+        }
+        else if (needStep < 1)
+        {
+            numSteps = 1;
+        }
+        else
+        {
+            numSteps = (int)std::min<float>(64, std::max<float>(20, needStep));
+        }
+    }
+    else
+    {
+        numSteps = (int)std::min<float>(64, std::max<float>(20, needStep));
+    }
+
+    // LOG_E("needStep=%f, steps=%i", needStep, numSteps);
+    if (numSteps > 0)
+    {
+        // calculate angle step
+        float step = (angle2 / numSteps);
+        float angle1 = atan2(1.0f, 0.0f) - atan2(v1.x, -v1.y);
+        // starting point
+        float angle = angle1;
+
+        GPoint arcP1 = {point.x + cosf(angle) * width2,
+                        point.y - sinf(angle) * width2};
+        GPoint arcP2;
+        for (int i = 0; i < numSteps; i++)
+        {
+            angle += step;
+            arcP2 = PointMake(point.x + cosf(angle) * width2,
+                              point.y - sinf(angle) * width2);
+
+            context->PushTriangle(arcP1, point, arcP2, color, vec);
+            arcP1 = arcP2;
+        }
+    }
+}
+
+std::vector<tSubPath> *GPath::DrawLineDash(GCanvasContext *context)
+{
+    std::vector<float> lineDash = context->LineDash();
+    std::vector<float> firstLineDash = context->LineDash();
+    bool firstNeedDraw = true;
+    int firstDashIndex = 0;
+    float lineDashOffset = context->LineDashOffset();
+    // deal offset
+    if (lineDashOffset > 0.1 && lineDashOffset < 50)
+    {
+        float totalLength = 0;
+        for (int i = 0; i < lineDash.size(); i++)
+        {
+            totalLength += lineDash[i];
+        }
+        while (lineDashOffset > totalLength)
+        {
+            lineDashOffset -= totalLength;
+            if (lineDash.size() % 2 == 1)
+            {
+                firstNeedDraw = !firstNeedDraw;
+            }
+        }
+
+        for (int i = 0; i < firstLineDash.size(); i++)
+        {
+            float dash = firstLineDash[i];
+            if (dash > lineDashOffset)
+            {
+                firstLineDash[i] = dash - lineDashOffset;
+                break;
+            }
+            else
+            {
+                firstNeedDraw = !firstNeedDraw;
+                lineDashOffset -= dash;
+                firstLineDash[i] = 0;
+                firstDashIndex++;
+                if (i == firstLineDash.size() - 1)
+                {
+                    // reset
+                    firstDashIndex = 0;
+                    firstLineDash = lineDash;
+                }
+            }
+        }
+    }
+
+    std::vector<tSubPath> *tmpPathStack = new std::vector<tSubPath>;
+    for (std::vector<tSubPath>::const_iterator iter = mPathStack.begin();
+         iter != mPathStack.end(); ++iter)
+    {
+        const std::vector<GPoint> &pts = iter->points;
+        GPoint startPoint, stopPoint;
+        if (pts.size() <= 1)
+        {
+            continue;
+        }
+
+        // dashwidth
+        int dashIndex = firstDashIndex;
+        float dashWidth = firstLineDash[dashIndex];
+        bool needDraw = firstNeedDraw;
+        bool isFirst = true;
+
+        // new tmp path
+        tSubPath tmpPath;
+        tmpPath.isClosed = false;
+        float currentWidth = 0;
+        stopPoint = *(pts.begin());
+        tmpPath.points.push_back(stopPoint);
+
+        for (std::vector<GPoint>::const_iterator ptIter = pts.begin() + 1;
+             ptIter != pts.end();)
+        {
+            startPoint = stopPoint;
+            stopPoint = *ptIter;
+            // calc cur length
+            float deltaX = stopPoint.x - startPoint.x;
+            float deltaY = stopPoint.y - startPoint.y;
+            float length = sqrtf(deltaX * deltaX + deltaY * deltaY);
+
+            if (length + currentWidth > dashWidth)
+            {
+                // insert point
+                float gapWidth = dashWidth - currentWidth;
+                float interDeltaX = deltaX * gapWidth / length;
+                float interDeltaY = deltaY * gapWidth / length;
+                GPoint interPoint = PointMake(interDeltaX + startPoint.x, interDeltaY + startPoint.y);
+                tmpPath.points.push_back(interPoint);
+
+                if (needDraw)
+                {
+                    tmpPathStack->push_back(tmpPath);
+                }
+
+                // new path, update variables
+                tmpPath.points.clear();
+                tmpPath.isClosed = false;
+                needDraw = !needDraw;
+                currentWidth = 0;
+                tmpPath.points.push_back(interPoint);
+                stopPoint = interPoint;
+
+                // update dash
+                if (isFirst)
+                {
+                    dashIndex++;
+                    if (dashIndex >= firstLineDash.size())
+                    {
+                        isFirst = false;
+                        dashIndex = 0;
+                        dashWidth = lineDash[dashIndex];
+                    }
+                    else
+                    {
+                        dashWidth = firstLineDash[dashIndex];
+                    }
+                }
+                else
+                {
+                    dashIndex = (dashIndex + 1) % lineDash.size();
+                    dashWidth = lineDash[dashIndex];
+                }
+
+                continue;
+            }
+            else
+            {
+                tmpPath.points.push_back(stopPoint);
+                currentWidth += length;
+                if (ptIter == pts.end() - 1)
+                {
+                    // finished，push vertex
+                    if (needDraw)
+                    {
+                        tmpPathStack->push_back(tmpPath);
+                    }
+                }
+            }
+            ++ptIter;
+        }
+    }
+    return tmpPathStack;
+}
+
+void GPath::CreateLinesFromPoints(GCanvasContext *context, GColorRGBA color, std::vector<GVertex> *vertexVec)
+{
+    float lineWidth = context->LineWidth() * 0.5;
+    float minValidValue = 0.01;
+    std::vector<tSubPath> *pathStack = &mPathStack;
+    // first deal line dash if needed
+    if (context->LineDash().size() > 0)
+    {
+        pathStack = DrawLineDash(context);
+    }
+    for (std::vector<tSubPath>::iterator iter = pathStack->begin();
+         iter != pathStack->end(); ++iter)
+    {
+        std::vector<GPoint> &pts = iter->points;
+        bool subPathIsClosed = iter->isClosed;
+        bool firstInSub = true;
+        GPoint startPoint, stopPoint;
+        GPoint secondPoint = {0, 0};
+        GPoint miter11, miter12; // Current miter vertices (left, right)
+        GPoint miter21, miter22; // Next miter vertices (left, right)
+        if (pts.size() <= 1)
+        {
+            continue;
+        }
+
+        stopPoint = *(pts.begin());
+        // LOG_E("pathStack pointSize=%f,%f %f,%f %f,%f", pts[0].x, pts[0].y,pts[1].x, pts[1].y,pts[2].x, pts[2].y);
+
+        // filter close point
+        GPoint prePoint = *(pts.begin());
+        for (std::vector<GPoint>::const_iterator ptIter = pts.begin() + 1;
+             ptIter != pts.end();)
+        {
+            float deltaX = (*ptIter).x - prePoint.x;
+            float deltaY = (*ptIter).y - prePoint.y;
+            float length = sqrtf(deltaX * deltaX + deltaY * deltaY);
+            if (length < minValidValue)
+            {
+                ptIter = pts.erase(ptIter);
+            }
+            else
+            {
+                prePoint = *ptIter;
+                ptIter++;
+            }
+        }
+
+        for (std::vector<GPoint>::const_iterator ptIter = pts.begin() + 1;
+             ptIter != pts.end(); ++ptIter)
+        {
+
+            // LOG_E("pathStack iterate point=%f,%f", ptIter->x, ptIter->y);
+            float deltaX = (*ptIter).x - stopPoint.x;
+            float deltaY = (*ptIter).y - stopPoint.y;
+
+            float length = sqrtf(deltaX * deltaX + deltaY * deltaY);
+
+            std::vector<GPoint>::const_iterator nextIter = ptIter + 1;
+
+            startPoint = stopPoint;
+            stopPoint = *ptIter;
+
+            float temp = deltaX;
+            deltaX = deltaY * lineWidth / length;
+            deltaY = temp * lineWidth / length;
+
+            miter11 = PointMake(startPoint.x - deltaX, startPoint.y + deltaY);
+            miter12 = PointMake(startPoint.x + deltaX, startPoint.y - deltaY);
+            miter21 = PointMake(stopPoint.x - deltaX, stopPoint.y + deltaY);
+            miter22 = PointMake(stopPoint.x + deltaX, stopPoint.y - deltaY);
+
+            // step1: draw line
+            context->PushQuad(miter11, miter21, miter22, miter12, color, vertexVec);
+
+            // if display lineWidth (state lineWidth plus pixelRatio and state scale) > 1, draw mitter
+            if (context->LineWidth() * context->GetPixelScale() <= 1)
+            {
+                continue;
+            }
+
+            // step2: draw head cap
+            if (firstInSub)
+            {
+                firstInSub = false;
+                secondPoint = stopPoint;
+                if (!subPathIsClosed)
+                {
+                    drawLineCap(context, startPoint, miter12, miter11, -deltaY,
+                                -deltaX, color, vertexVec);
+                }
+            }
+            // step3: draw tail cap
+            if (nextIter == pts.end() && (!subPathIsClosed))
+            {
+                drawLineCap(context, stopPoint, miter21, miter22, deltaY,
+                            deltaX, color, vertexVec);
+                break;
+            }
+
+            // step4: draw line join
+            GPoint nextCenter;
+            if (nextIter != pts.end())
+            {
+                nextCenter = *nextIter;
+            }
+            else
+            {
+                nextCenter = secondPoint;
+            }
+
+            float nx = nextCenter.x - stopPoint.x;
+            float ny = nextCenter.y - stopPoint.y;
+            float nl = sqrtf(nx * nx + ny * ny);
+            float nt = nx;
+            nx = ny * lineWidth / nl;
+            ny = nt * lineWidth / nl;
+
+            GPoint n11, n12;
+            n11 = PointMake(stopPoint.x - nx, stopPoint.y + ny);
+            n12 = PointMake(stopPoint.x + nx, stopPoint.y - ny);
+
+            float nextAngle = calcPointAngle(nextCenter, stopPoint);
+            float curAngle = calcPointAngle(startPoint, stopPoint);
+            float angleDiff = nextAngle - curAngle;
+            if (angleDiff < 0)
+            {
+                angleDiff += PI_1 * 2;
+            }
+
+            GPoint joinP1, joinP2;
+            if (angleDiff > PI_1)
+            {
+                joinP1 = n12;
+                joinP2 = miter22;
+            }
+            else
+            {
+                joinP1 = miter21;
+                joinP2 = n11;
+            }
+
+            if (context->LineJoin() == LINE_JOIN_ROUND)
+            {
+                drawArcToContext(context, stopPoint, joinP1, joinP2, color, vertexVec, minValidValue);
+            }
+            else if (context->LineJoin() == LINE_JOIN_MITER)
+            {
+                drawLineJoinMiter(context, stopPoint, joinP2, joinP1, color, vertexVec);
+            }
+            else if (context->LineJoin() == LINE_JOIN_BEVEL)
+            {
+                if (isTrianglePointsValid(stopPoint, joinP1, joinP2, minValidValue))
+                {
+                    context->PushTriangle(stopPoint, joinP1, joinP2, color, vertexVec);
+                }
+                else
+                {
+                    //LOG_E("invalid bevel join pointSize=%f,%f %f,%f %f,%f",
+                    //      stopPoint.x, stopPoint.y,joinP1.x, joinP1.y,joinP2.x, joinP2.y);
+                }
+            }
+        }
+    }
+
+    // delete pathStack
+    if (context->LineDash().size() > 0)
+    {
+        delete pathStack;
+    }
+}
+
+void GPath::DrawLinesToContext(GCanvasContext *context)
+{
+    context->SetTexture(InvalidateTextureId);
+    GColorRGBA color = BlendStrokeColor(context);
+
+    std::vector<GVertex> vertexVec;
+
+    if (color.rgba.a < 1.0)
+    { //transparent, use stencil buffer
+        CreateLinesFromPoints(context, color, &vertexVec);
+    }
+    else
+    {
+        CreateLinesFromPoints(context, color, NULL);
+        return;
+    }
+
+    StencilRectForStroke(context, vertexVec);
+}
+
+void GPath::StencilRectForStroke(GCanvasContext *context, std::vector<GVertex> &vertexVec)
+{
+    context->SendVertexBufferToGPU();
+
+    GColorRGBA color = BlendStrokeColor(context);
+
+    //set environment
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+    glEnable(GL_STENCIL_TEST);
+
+    // clear stencil buffer
+    glStencilFunc(GL_ALWAYS, 0, 0xff);
+    glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO);
+    GColorRGBA white = {1, 1, 1, 1};
+
+    float extend = context->MiterLimit() * context->LineWidth();
+    if (extend < context->LineWidth() * 0.5)
+    {
+        extend = context->LineWidth() * 0.5;
+    }
+    GRect rect;
+    rect.x = mMinPosition.x - extend;
+    rect.y = mMinPosition.y - extend;
+    rect.width = mMaxPosition.x - mMinPosition.x + extend * 2;
+    rect.height = mMaxPosition.y - mMinPosition.y + extend * 2;
+    if (rect.height > context->GetHeight() || rect.width > context->GetWidth())
+    {
+        rect.x = 0;
+        rect.y = 0;
+        rect.width = context->GetWidth();
+        rect.height = context->GetHeight();
+    }
+
+    context->PushRectangle(rect.x, rect.y, rect.width, rect.height, 0, 0, 0, 0, white);
+    context->SendVertexBufferToGPU();
+
+    // first draw stencil
+    glStencilFunc(GL_ALWAYS, 0x1, 0xFF);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
+
+    // push vertexs
+    context->PushVertexs(vertexVec);
+    context->SendVertexBufferToGPU();
+
+    // second draw color buffer with stencil buffer
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+    glStencilFunc(GL_NOTEQUAL, 0x00, 0xff);
+    glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO);
+
+    context->PushRectangle(rect.x, rect.y, rect.width, rect.height, 0, 0, 0, 0, color);
+    context->SendVertexBufferToGPU();
+
+    // reset
+    glDisable(GL_STENCIL_TEST);
+}
+
+float GPath::calcPointAngle(const GPoint &director, const GPoint &center)
+{
+    GPoint adjust = PointSub(director, center);
+    return atan2(adjust.y, adjust.x);
+}
+
+void GPath::drawLineJoinMiter(GCanvasContext *context, const GPoint &center,
+                              const GPoint &p1, const GPoint &p2,
+                              GColorRGBA color, std::vector<GVertex> *vec)
+{
+    float angle1 = calcPointAngle(p1, center);
+    float angle2 = calcPointAngle(p2, center);
+
+    float angleGap = (angle2 - angle1);
+    if (angleGap < 0)
+    {
+        angleGap += (PI_1 * 2);
+    }
+    angleGap /= 2;
+    float miterLen = fabsf(1 / cosf(angleGap));
+
+    if (miterLen > context->MiterLimit())
+    {
+        context->PushTriangle(center, p1, p2, color);
+        return;
+    }
+
+    float miterAngle = angle1 + angleGap;
+    float lineWidth = context->LineWidth() * 0.5;
+    GPoint miterPoint = {
+        center.x + cosf(miterAngle) * miterLen * lineWidth,
+        center.y + sinf(miterAngle) * miterLen * lineWidth};
+
+    // LOG_E("drawLineJoinMiter PushQuad=%f,%f %f,%f %f,%f,%f,%f",
+    //      center.x, center.y, p1.x, p1.y, miterPoint.x, miterPoint.y, p2.x, p2.y);
+
+    // filter opengl invalid point( eg:oppo a59 )
+    if (isNan(p1) || isNan(p2) || isNan(center) || isNan(miterPoint))
+    {
+        return;
+    }
+
+    context->PushQuad(center, p1, miterPoint, p2, color, vec);
+}
+
+void GPath::drawLineCap(GCanvasContext *context, const GPoint &center,
+                        const GPoint &p1, const GPoint &p2, float deltaX,
+                        float deltaY, GColorRGBA color, std::vector<GVertex> *vec, float samePointThreshold)
+{
+    if (context->LineCap() == LINE_CAP_SQUARE)
+    {
+        context->PushQuad(p1, p2, PointMake(p2.x + deltaX, p2.y + deltaY),
+                          PointMake(p1.x + deltaX, p1.y + deltaY), color, vec);
+    }
+    else if (context->LineCap() == LINE_CAP_ROUND)
+    {
+        drawArcToContext(context, center, p1, p2, color, vec, samePointThreshold);
+    }
+}
+
+void GPath::SubdivideCubicTo(GPath *path, GPoint points[4], int level)
+{
+    if (--level >= 0)
+    {
+        GPoint tmp[7];
+
+        ChopCubicAt(points, tmp, 0.5f);
+        SubdivideCubicTo(path, &tmp[0], level);
+        SubdivideCubicTo(path, &tmp[3], level);
+    }
+    else
+    {
+        path->push(points[1]);
+        path->push(points[2]);
+        path->push(points[3]);
+    }
+}
+
+void GPath::ChopCubicAt(GPoint src[4], GPoint dst[7], float t)
+{
+
+    GPoint tt = PointMake(t, t);
+
+    GPoint ab = interp(src[0], src[1], tt);
+    GPoint bc = interp(src[1], src[2], tt);
+    GPoint cd = interp(src[2], src[3], tt);
+    GPoint abc = interp(ab, bc, tt);
+    GPoint bcd = interp(bc, cd, tt);
+    GPoint abcd = interp(abc, bcd, tt);
+
+    dst[0] = src[0];
+    dst[1] = ab;
+    dst[2] = abc;
+    dst[3] = abcd;
+    dst[4] = bcd;
+    dst[5] = cd;
+    dst[6] = src[3];
+}
+
+GPoint GPath::interp(const GPoint &v0, const GPoint &v1, const GPoint &t)
+{
+    return PointMake(v0.x + (v1.x - v0.x) * t.x, v0.y + (v1.y - v0.y) * t.y);
+}
+
+void GPath::GetRect(GRectf &rect)
+{
+    rect.leftTop = mMinPosition;
+    rect.bottomRight = mMaxPosition;
+}
+
+void GPath::RestoreStencilForClip(GCanvasContext *context)
+{
+    if (context->HasClipRegion())
+    {
+        // reset stencil
+        glClear(GL_STENCIL_BUFFER_BIT);
+        SetStencilForClip();
+    }
+    else
+    {
+        // disable
+        glStencilMask(0xFF);
+        glClear(GL_STENCIL_BUFFER_BIT);
+        glDisable(GL_STENCIL_TEST);
+    }
+}
+
+void GPath::SetStencilForClip()
+{
+    GLuint mask = 0x80;
+    glStencilMask(mask);
+    glStencilFunc(GL_EQUAL, mask, mask);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
+}
+
+inline double calc_distance(double x1, double y1, double x2, double y2)
+{
+    double dx = x2 - x1;
+    double dy = y2 - y1;
+    return sqrt(dx * dx + dy * dy);
+}
+
+inline double calc_sq_distance(double x1, double y1, double x2, double y2)
+{
+    double dx = x2 - x1;
+    double dy = y2 - y1;
+    return dx * dx + dy * dy;
+}