cocos2dx Vec2

//SE是坐标重叠部分
// returns true if segment A-B intersects with segment C-D. S->E is the overlap part
bool isOneDimensionSegmentOverlap(float A, float B, float C, float D, float *S, float * E)
{
    //线段的最长点和最短点的单坐标 x 或 y
    float ABmin = std::min(A, B);
    float ABmax = std::max(A, B);
    float CDmin = std::min(C, D);
    float CDmax = std::max(C, D);

    //不可能相交的情况
    if (ABmax < CDmin || CDmax < ABmin)
    {
        // ABmin->ABmax->CDmin->CDmax or CDmin->CDmax->ABmin->ABmax
        return false;
    }
    else
    {
        //SE表示的是AB向量在CD向量上的投影或者是CD向量在AB向量上的投影
        //单个坐标的排序一共四种情况
        if (ABmin >= CDmin && ABmin <= CDmax)
        {
            // CDmin->ABmin->CDmax->ABmax or CDmin->ABmin->ABmax->CDmax
            if (S != nullptr) *S = ABmin;
            if (E != nullptr) *E = CDmax < ABmax ? CDmax : ABmax;
        }
        else if (ABmax >= CDmin && ABmax <= CDmax)
        {
            // ABmin->CDmin->ABmax->CDmax
            if (S != nullptr) *S = CDmin;
            if (E != nullptr) *E = ABmax;
        }
        else
        {
            // ABmin->CDmin->CDmax->ABmax
            if (S != nullptr) *S = CDmin;
            if (E != nullptr) *E = CDmax;
        }
        return true;
    }
}

//向量的外积 x1y2-x2y1
// cross product of 2 vector. A->B X C->D
float crossProduct2Vector(const Vec2& A, const Vec2& B, const Vec2& C, const Vec2& D)
{
    return (D.y - C.y) * (B.x - A.x) - (D.x - C.x) * (B.y - A.y);
}

//返回两个向量的夹角
float Vec2::angle(const Vec2& v1, const Vec2& v2)
{
    float dz = v1.x * v2.y - v1.y * v2.x;
    return atan2f(fabsf(dz) + MATH_FLOAT_SMALL, dot(v1, v2));
}

//定义了向量的加法
void Vec2::add(const Vec2& v1, const Vec2& v2, Vec2* dst)
{
    GP_ASSERT(dst);

    dst->x = v1.x + v2.x;
    dst->y = v1.y + v2.y;
}

//修改this为重叠部分的x y值  短板效应
void Vec2::clamp(const Vec2& min, const Vec2& max)
{
    GP_ASSERT(!(min.x > max.x || min.y > max.y ));

    // Clamp the x value.
    if (x < min.x)
        x = min.x;
    if (x > max.x)
        x = max.x;

    // Clamp the y value.
    if (y < min.y)
        y = min.y;
    if (y > max.y)
        y = max.y;
}

//与上面的方法只是调用方式不一样
void Vec2::clamp(const Vec2& v, const Vec2& min, const Vec2& max, Vec2* dst)
{
    GP_ASSERT(dst);
    GP_ASSERT(!(min.x > max.x || min.y > max.y ));

    // Clamp the x value.
    dst->x = v.x;
    if (dst->x < min.x)
        dst->x = min.x;
    if (dst->x > max.x)
        dst->x = max.x;

    // Clamp the y value.
    dst->y = v.y;
    if (dst->y < min.y)
        dst->y = min.y;
    if (dst->y > max.y)
        dst->y = max.y;
}

//计算this向量和参数向量的距离
float Vec2::distance(const Vec2& v) const
{
    float dx = v.x - x;
    float dy = v.y - y;

    return std::sqrt(dx * dx + dy * dy);
}

//计算v1v2的点积
float Vec2::dot(const Vec2& v1, const Vec2& v2)
{
    return (v1.x * v2.x + v1.y * v2.y);
}

//计算this向量的长
float Vec2::length() const
{
    return std::sqrt(x * x + y * y);
}

//将向量标准化，使得sqrt(x*x + y*y) == 1
void Vec2::normalize()
{
    //先判断是否已经是标准化的了
    float n = x * x + y * y;
    // Already normalized.
    if (n == 1.0f)
        return;

    n = std::sqrt(n);
    // Too close to zero.
    if (n < MATH_TOLERANCE)
        return;

    n = 1.0f / n;
    x *= n;
    y *= n;
}

//获取标准化向量，不是标准化就转换
Vec2 Vec2::getNormalized() const
{
    Vec2 v(*this);
    v.normalize();
    return v;
}

//以指定的点point旋转angle角（以线段的锚点为中心旋转）
void Vec2::rotate(const Vec2& point, float angle)
{
    float sinAngle = std::sin(angle);
    float cosAngle = std::cos(angle);
    //如果旋转点为（0，0）点
    if (point.isZero())
    {
        float tempX = x * cosAngle - y * sinAngle;
        y = y * cosAngle + x * sinAngle;
        x = tempX;
    }
    //旋转点不在原点
    else
    {
        //先移动到原点
        float tempX = x - point.x;
        float tempY = y - point.y;

        //旋转完再移动回去
        x = tempX * cosAngle - tempY * sinAngle + point.x;
        y = tempY * cosAngle + tempX * sinAngle + point.y;
    }
}

//使用数组初始化xy坐标
void Vec2::set(const float* array)
{
    GP_ASSERT(array);

    x = array[0];
    y = array[1];
}

//a-b=c   得到的向量是从b的末尾指向a的末尾
void Vec2::subtract(const Vec2& v1, const Vec2& v2, Vec2* dst)
{
    GP_ASSERT(dst);

    dst->x = v1.x - v2.x;
    dst->y = v1.y - v2.y;
}

//判断目标向量和this向量是否相等
bool Vec2::equals(const Vec2& target) const
{
    return (std::abs(this->x - target.x) < FLT_EPSILON)
        && (std::abs(this->y - target.y) < FLT_EPSILON);
}

//this向量与目标向量在一定范围内近似相等
bool Vec2::fuzzyEquals(const Vec2& b, float var) const
{
    //判断xy值±var能不能包含b
    if(x - var <= b.x && b.x <= x + var)
        if(y - var <= b.y && b.y <= y + var)
            return true;
    return false;
}

//获取两个向量的夹角
float Vec2::getAngle(const Vec2& other) const
{
    Vec2 a2 = getNormalized();
    Vec2 b2 = other.getNormalized();
    float angle = atan2f(a2.cross(b2), a2.dot(b2));
    if (std::abs(angle) < FLT_EPSILON) return 0.f;
    return angle;
}

//通过角度旋转，传递的参数是旋转的点和角度
Vec2 Vec2::rotateByAngle(const Vec2& pivot, float angle) const
{
    //相当于按照原点旋转然后加上自定义旋转点的坐标
    return pivot + (*this - pivot).rotate(Vec2::forAngle(angle));
}

//检测直线是否相交
bool Vec2::isLineIntersect(const Vec2& A, const Vec2& B,
                            const Vec2& C, const Vec2& D,
                            float *S, float *T)
{
    // FAIL: Line undefined
    if ( (A.x==B.x && A.y==B.y) || (C.x==D.x && C.y==D.y) )
    {
        return false;
    }

    //外积的其中一个意义是两个向量组成的平行四边形的面积
    const float denom = crossProduct2Vector(A, B, C, D);

    //如果面积为零则表明两个向量要么平行要么重叠
    if (denom == 0)
    {
        // Lines parallel or overlap
        return false;
    }

    //外积的面积所占的百分比  在下面的函数里面有进行判断
    if (S != nullptr) *S = crossProduct2Vector(C, D, C, A) / denom;
    if (T != nullptr) *T = crossProduct2Vector(A, B, C, A) / denom;

    return true;
}

//判断是否平行
bool Vec2::isLineParallel(const Vec2& A, const Vec2& B,
                           const Vec2& C, const Vec2& D)
{
    // FAIL: Line undefined
    if ( (A.x==B.x && A.y==B.y) || (C.x==D.x && C.y==D.y) )
    {
        return false;
    }

    if (crossProduct2Vector(A, B, C, D) == 0)
    {
        // line overlap
        if (crossProduct2Vector(C, D, C, A) == 0 || crossProduct2Vector(A, B, C, A) == 0)
        {
            return false;
        }

        return true;
    }

    return false;
}

//判断是否重叠
bool Vec2::isLineOverlap(const Vec2& A, const Vec2& B,
                            const Vec2& C, const Vec2& D)
{
    // FAIL: Line undefined //零向量
    if ( (A.x==B.x && A.y==B.y) || (C.x==D.x && C.y==D.y) )
    {
        return false;
    }

    if (crossProduct2Vector(A, B, C, D) == 0 &&
        (crossProduct2Vector(C, D, C, A) == 0 || crossProduct2Vector(A, B, C, A) == 0))
    {
        return true;
    }

    return false;
}

//判断是否部分重叠
bool Vec2::isSegmentOverlap(const Vec2& A, const Vec2& B, const Vec2& C, const Vec2& D, Vec2* S, Vec2* E)
{

    if (isLineOverlap(A, B, C, D))
    {
        //判断是否相交
        return isOneDimensionSegmentOverlap(A.x, B.x, C.x, D.x, &S->x, &E->x) &&
        isOneDimensionSegmentOverlap(A.y, B.y, C.y, D.y, &S->y, &E->y);
    }  

    return false;
}

//判断线段相交
bool Vec2::isSegmentIntersect(const Vec2& A, const Vec2& B, const Vec2& C, const Vec2& D)
{
    float S, T;

    if (isLineIntersect(A, B, C, D, &S, &T )&&
        (S >= 0.0f && S <= 1.0f && T >= 0.0f && T <= 1.0f))
    {
        return true;
    }

    return false;
}

//获取交点
Vec2 Vec2::getIntersectPoint(const Vec2& A, const Vec2& B, const Vec2& C, const Vec2& D)
{
    float S, T;

    if (isLineIntersect(A, B, C, D, &S, &T))
    {
        // Vec2 of intersection
        //获取交点的坐标
        Vec2 P;
        P.x = A.x + S * (B.x - A.x);
        P.y = A.y + S * (B.y - A.y);
        return P;
    }

    return Vec2::ZERO;
}