//! Merges a point
        public void MergePoint(ref IndexedVector3 point)
        {
            m_min.X = BoxCollision.BT_MIN(m_min.X, point.X);
            m_min.Y = BoxCollision.BT_MIN(m_min.Y, point.Y);
            m_min.Z = BoxCollision.BT_MIN(m_min.Z, point.Z);

            m_max.X = BoxCollision.BT_MAX(m_max.X, point.X);
            m_max.Y = BoxCollision.BT_MAX(m_max.Y, point.Y);
            m_max.Z = BoxCollision.BT_MAX(m_max.Z, point.Z);
        }
        //! Finds the intersecting box between this box and the other.
        public void FindIntersection(ref AABB other, ref AABB intersection)
        {
            intersection.m_min.X = BoxCollision.BT_MAX(other.m_min.X, m_min.X);
            intersection.m_min.Y = BoxCollision.BT_MAX(other.m_min.Y, m_min.Y);
            intersection.m_min.Z = BoxCollision.BT_MAX(other.m_min.Z, m_min.Z);

            intersection.m_max.X = BoxCollision.BT_MIN(other.m_max.X, m_max.X);
            intersection.m_max.Y = BoxCollision.BT_MIN(other.m_max.Y, m_max.Y);
            intersection.m_max.Z = BoxCollision.BT_MIN(other.m_max.Z, m_max.Z);
        }
        public void Merge(ref AABB box)
        {
            m_min.X = BoxCollision.BT_MIN(m_min.X, box.m_min.X);
            m_min.Y = BoxCollision.BT_MIN(m_min.Y, box.m_min.Y);
            m_min.Z = BoxCollision.BT_MIN(m_min.Z, box.m_min.Z);

            m_max.X = BoxCollision.BT_MAX(m_max.X, box.m_max.X);
            m_max.Y = BoxCollision.BT_MAX(m_max.Y, box.m_max.Y);
            m_max.Z = BoxCollision.BT_MAX(m_max.Z, box.m_max.Z);
        }
        public void CalcFromTriangle(ref IndexedVector3 V1, ref IndexedVector3 V2, ref IndexedVector3 V3)
        {
            m_min.X = BoxCollision.BT_MIN3(V1.X, V2.X, V3.X);
            m_min.Y = BoxCollision.BT_MIN3(V1.Y, V2.Y, V3.Y);
            m_min.Z = BoxCollision.BT_MIN3(V1.Z, V2.Z, V3.Z);

            m_max.X = BoxCollision.BT_MAX3(V1.X, V2.X, V3.X);
            m_max.Y = BoxCollision.BT_MAX3(V1.Y, V2.Y, V3.Y);
            m_max.Z = BoxCollision.BT_MAX3(V1.Z, V2.Z, V3.Z);
        }
        public AABB(ref IndexedVector3 V1,
                    ref IndexedVector3 V2,
                    ref IndexedVector3 V3)
        {
            m_min = new IndexedVector3();
            m_max = new IndexedVector3();

            m_min.X = BoxCollision.BT_MIN3(V1.X, V2.X, V3.X);
            m_min.Y = BoxCollision.BT_MIN3(V1.Y, V2.Y, V3.Y);
            m_min.Z = BoxCollision.BT_MIN3(V1.Z, V2.Z, V3.Z);

            m_max.X = BoxCollision.BT_MAX3(V1.X, V2.X, V3.X);
            m_max.Y = BoxCollision.BT_MAX3(V1.Y, V2.Y, V3.Y);
            m_max.Z = BoxCollision.BT_MAX3(V1.Z, V2.Z, V3.Z);
        }
        //! test for a triangle, with edges
        public bool CollideTriangleExact(ref IndexedVector3 p1, ref IndexedVector3 p2, ref IndexedVector3 p3, ref IndexedVector4 triangle_plane)
        {
            if (!CollidePlane(ref triangle_plane))
            {
                return(false);
            }

            IndexedVector3 center, extends;

            GetCenterExtend(out center, out extends);

            IndexedVector3 v1 = (p1 - center);
            IndexedVector3 v2 = (p2 - center);
            IndexedVector3 v3 = (p3 - center);

            //First axis
            IndexedVector3 diff     = (v2 - v1);
            IndexedVector3 abs_diff = diff.Absolute();

            //Test With X axis
            BoxCollision.TEST_CROSS_EDGE_BOX_X_AXIS_MCR(ref diff, ref abs_diff, ref v1, ref v3, ref extends);
            //Test With Y axis
            BoxCollision.TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(ref diff, ref abs_diff, ref v1, ref v3, ref extends);
            //Test With Z axis
            BoxCollision.TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(ref diff, ref abs_diff, ref v1, ref v3, ref extends);


            diff     = v3 - v2;
            abs_diff = diff.Absolute();
            //Test With X axis
            BoxCollision.TEST_CROSS_EDGE_BOX_X_AXIS_MCR(ref diff, ref abs_diff, ref v2, ref v1, ref extends);
            //Test With Y axis
            BoxCollision.TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(ref diff, ref abs_diff, ref v2, ref v1, ref extends);
            //Test With Z axis
            BoxCollision.TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(ref diff, ref abs_diff, ref v2, ref v1, ref extends);

            diff     = v1 - v3;
            abs_diff = diff.Absolute();

            //Test With X axis
            BoxCollision.TEST_CROSS_EDGE_BOX_X_AXIS_MCR(ref diff, ref abs_diff, ref v3, ref v2, ref extends);
            //Test With Y axis
            BoxCollision.TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(ref diff, ref abs_diff, ref v3, ref v2, ref extends);
            //Test With Z axis
            BoxCollision.TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(ref diff, ref abs_diff, ref v3, ref v2, ref extends);

            return(true);
        }
        public void CalcFromTriangleMargin(ref IndexedVector3 V1, ref IndexedVector3 V2, ref IndexedVector3 V3, float margin)
        {
            m_min.X = BoxCollision.BT_MIN3(V1.X, V2.X, V3.X);
            m_min.Y = BoxCollision.BT_MIN3(V1.Y, V2.Y, V3.Y);
            m_min.Z = BoxCollision.BT_MIN3(V1.Z, V2.Z, V3.Z);

            m_max.X = BoxCollision.BT_MAX3(V1.X, V2.X, V3.X);
            m_max.Y = BoxCollision.BT_MAX3(V1.Y, V2.Y, V3.Y);
            m_max.Z = BoxCollision.BT_MAX3(V1.Z, V2.Z, V3.Z);

            m_min.X -= margin;
            m_min.Y -= margin;
            m_min.Z -= margin;
            m_max.X += margin;
            m_max.Y += margin;
            m_max.Z += margin;
        }
        /*! \brief Finds the Ray intersection parameter.
         * \param aabb Aligned box
         * \param vorigin A vec3f with the origin of the ray
         * \param vdir A vec3f with the direction of the ray
         */
        public bool CollideRay(ref IndexedVector3 vorigin, ref IndexedVector3 vdir)
        {
            IndexedVector3 extents, center;

            GetCenterExtend(out center, out extents);

            float Dx = vorigin.X - center.X;

            if (BoxCollision.BT_GREATER(Dx, extents.X) && Dx * vdir.X >= 0.0f)
            {
                return(false);
            }
            float Dy = vorigin.Y - center.Y;

            if (BoxCollision.BT_GREATER(Dy, extents.Y) && Dy * vdir.Y >= 0.0f)
            {
                return(false);
            }
            float Dz = vorigin.Z - center.Z;

            if (BoxCollision.BT_GREATER(Dz, extents.Z) && Dz * vdir.Z >= 0.0f)
            {
                return(false);
            }


            float f = vdir.Y * Dz - vdir.Z * Dy;

            if (Math.Abs(f) > extents.Y * Math.Abs(vdir.Z) + extents.Z * Math.Abs(vdir.Y))
            {
                return(false);
            }
            f = vdir.Z * Dx - vdir.X * Dz;
            if (Math.Abs(f) > extents.X * Math.Abs(vdir.Z) + extents.Z * Math.Abs(vdir.X))
            {
                return(false);
            }
            f = vdir.X * Dy - vdir.Y * Dx;
            if (Math.Abs(f) > extents.X * Math.Abs(vdir.Y) + extents.Y * Math.Abs(vdir.X))
            {
                return(false);
            }
            return(true);
        }
        public AABB(ref IndexedVector3 V1, ref IndexedVector3 V2, ref IndexedVector3 V3, float margin)
        {
            m_min   = new IndexedVector3();
            m_max   = new IndexedVector3();
            m_min.X = BoxCollision.BT_MIN3(V1.X, V2.X, V3.X);
            m_min.Y = BoxCollision.BT_MIN3(V1.Y, V2.Y, V3.Y);
            m_min.Z = BoxCollision.BT_MIN3(V1.Z, V2.Z, V3.Z);

            m_max.X = BoxCollision.BT_MAX3(V1.X, V2.X, V3.X);
            m_max.Y = BoxCollision.BT_MAX3(V1.Y, V2.Y, V3.Y);
            m_max.Z = BoxCollision.BT_MAX3(V1.Z, V2.Z, V3.Z);

            m_min.X -= margin;
            m_min.Y -= margin;
            m_min.Z -= margin;
            m_max.X += margin;
            m_max.Y += margin;
            m_max.Z += margin;
        }
Example #10
0
        //! transcache is the transformation cache from box to this AABB
        public bool OverlappingTransCache(ref AABB box, ref BT_BOX_BOX_TRANSFORM_CACHE transcache, bool fulltest)
        {
            //Taken from OPCODE
            IndexedVector3 ea, eb; //extends
            IndexedVector3 ca, cb; //extends

            GetCenterExtend(out ca, out ea);
            box.GetCenterExtend(out cb, out eb);



            IndexedVector3 T = new IndexedVector3(0, 0, 0);
            float          t, t2;
            int            i;

            // Class I : A's basis vectors

            for (i = 0; i < 3; i++)
            {
                T[i] = transcache.m_R1to0[i].Dot(ref cb) + transcache.m_T1to0[i] - ca[i];
                t    = transcache.m_AR[i].Dot(ref eb) + ea[i];

                if (BoxCollision.BT_GREATER(T[i], t))
                {
                    return(false);
                }
            }
            // Class II : B's basis vectors
            for (i = 0; i < 3; i++)
            {
                t  = Mat3DotCol(ref transcache.m_R1to0, ref T, i);
                t2 = Mat3DotCol(ref transcache.m_AR, ref ea, i) + eb[i];
                if (BoxCollision.BT_GREATER(t, t2))
                {
                    return(false);
                }
            }
            // Class III : 9 cross products
            if (fulltest)
            {
                // check to see if these need to be restored back or are read-only
                float[,] m_R1to0 = MathUtil.BasisMatrixToFloatArray(ref transcache.m_R1to0);
                float[,] m_AR    = MathUtil.BasisMatrixToFloatArray(ref transcache.m_AR);


                int j, m, n, o, p, q, r;
                for (i = 0; i < 3; i++)
                {
                    m = (i + 1) % 3;
                    n = (i + 2) % 3;
                    o = i == 0 ? 1 : 0;
                    p = i == 2 ? 1 : 2;
                    for (j = 0; j < 3; j++)
                    {
                        q  = j == 2 ? 1 : 2;
                        r  = j == 0 ? 1 : 0;
                        t  = T[n] * m_R1to0[m, j] - T[m] * m_R1to0[n, j];
                        t2 = ea[o] * m_AR[p, j] + ea[p] * m_AR[o, j] +
                             eb[r] * m_AR[i, q] + eb[q] * m_AR[i, r];
                        if (BoxCollision.BT_GREATER(t, t2))
                        {
                            return(false);
                        }
                    }
                }
            }
            return(true);
        }