遍历网格中对象通过比较函数构建有向图

从场景网格到有向图

 先将center加到有向图

然后比较函数,得出right在center后面,所以形成由right指向center

----

int Compare(const iso::IsoView* a, const iso::IsoView* b) {
        const IsoAABB& aabb1 = a->getWorldAABB();
        const IsoAABB& aabb2 = b->getWorldAABB();
        //底边right永远大于left
        float L1V = aabb1.yMin + (- aabb1.xMax);
        float R1V = aabb1.yMax + (- aabb1.xMin);

        float L2V = aabb2.yMin - aabb2.xMax;
        float R2V = aabb2.yMax - aabb2.xMin;

       // 如果没有水平叠加
        if ((R1V < L2V) || (R2V < L1V))
                return 0;

        // если пустой isoBox
        if ((aabb1.zMin >= aabb1.zMax) || (aabb2.zMin >= aabb2.zMax))
                return 0;

        // 如果对象被插入到一个公共基础中并且这些不是一个对象的层，则按 z 排序
        if (aabb1.hive && (aabb1.hive == aabb2.hive) && 
            (a->getParent() != b->getParent()))
        {
                float d = (aabb1.zMin + aabb1.zMax) - (aabb2.zMin + aabb2.zMax);
                if (d < 0)
                        return -1;
                if (d > 0)
                        return +1;
        }

        float L1U = aabb1.xMax + aabb1.yMin + aabb1.uLeft;
        float R1U = aabb1.xMin + aabb1.yMax + aabb1.uRight;

        float L2U = aabb2.xMax + aabb2.yMin + aabb2.uLeft;
        float R2U = aabb2.xMin + aabb2.yMax + aabb2.uRight;

        // 如果没有垂直叠加
        if (std::max(L1U, R1U) < std::min(L2U, R2U))
                return -1;

        // 如果没有垂直叠加
        if (std::min(L1U, R1U) > std::max(L2U, R2U))
                return +1;

        float D1V = R1V - L1V;
        float D2V = R2V - L2V;
        float D1U = R1U - L1U;
        float D2U = R2U - L2U;

        // k1 - k2
        float DET = D1U * D2V - D2U * D1V;
        if (std::abs(DET) < 0.05f)
        {
                //线段是平行的
                float DV = L2V - L1V;
                float DU = L2U - L1U;

                float d = DV * D1U - DU * D1V;
                if (d < 0)
                        return -1;
                if (d > 0)
                        return +1;

                // 共同的部分
                if (L1V < L2V)
                        return -1;
                if (L1V > L2V)
                        return +1;

                // 谁更宽
                if (R1V > R2V)
                        return -1;
                if (R1V < R2V)
                        return +1;

                return 2;
        }

        float DV = L2V - L1V;
        float DU = L2U - L1U;

        // 坐标在直线[0..1]上，显示交点位置
        float e1 = (D2V * DU - D2U * DV) / DET;
        float e2 = (D1V * DU - D1U * DV) / DET;

        // 链接的延续相交
        // d - 沿 u 坐标的一个线段和第二条直线之间的距离
        float d = 0;

        if (e1 < 0)
        {
                // d = L1U - ((L1V - L2V) / D2V * D2U + L2U);
                d = DV * D2U - DU * D2V;
        }
        else if (e1 > 1)
        {
                // d = R1U - ((R1V - L2V) / D2V * D2U + L2U);
                d = (R1U - L2U) * D2V + (L2V - R1V) * D2U;
        }
        else if (e2 < 0)
        {
                // d = ((L2V - L1V) / D1V * D1U + L1U) - L2U;
                d = DV * D1U - DU * D1V;
        }
        else if (e2 > 1)
        {
                // d = ((R2V - L1V) / D1V * D1U + L1U) - R2U;
                d = (L1U - R2U) * D1V + (R2V - L1V) * D1U;
        }

        if (d < 0)
                return -1;
        if (d > 0)
                return +1;

        // 段本身相交

        // z 的启发式方法
        if (aabb1.zMax <= aabb2.zMin)
                return -1;

        if (aabb2.zMax <= aabb1.zMin)
                return +1;

        float z1 = aabb1.zMax;
        float z2 = aabb2.zMax;

        return (z1 < z2) ? -1 : (z1 > z2) ? +1 : 2;
        }

有向图表现为: