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;

}
巴特西

cocos2dx Vec2

最新文章

热门文章
