Object Collisions?

class AABBox
{
private:
    Vector    m_bbMin;
    Vector    m_bbMax;
    Bool    m_init;
    void GetAABBox(BaseObject *op, Vector *pMin, Vector *pMax);

public:
    Vector GetMin(void)                        { return m_bbMin; }
    Vector GetMax(void)                        { return m_bbMax; }
    void Init(BaseObject *op);
    Bool CollidesWith(BaseObject *op);
    AABBox(BaseObject *op);
    AABBox(void) {    m_init = false; }
    ~AABBox(void) {}
};

AABBox::AABBox(BaseObject *op)
{
    this->Init(op);
}

void AABBox::GetAABBox(BaseObject *op, Vector *pMin, Vector *pMax)
{
    Matrix opgm = op->GetMgn();
    MinMax mm;

    //--------------------------------------------------------------------------------------------
    // With this implementation, if the BaseObject being passed in is an instance of a PointObject,
    // then the OBB will be built from the actual Global-space points... this take longer if there
    // are more than 8 points, but gives a tighter fitting AABBox
    //--------------------------------------------------------------------------------------------
    if( op->IsInstanceOf(Opoint) )
    {
        const Vector *pPoints = ToPoint(op)->GetPointR();
        LONG i, numPoints = ToPoint(op)->GetPointCount();
        mm.Init();
        for(i=0; i<numPoints; i++)
        {
            mm.AddPoint(*pPoints * opgm);
            pPoints++;
        }
    }
    else
    {
        //--------------------------------------------------------------------------------------------
        // ...otherwise, generate an 8 point OBB from the Global-space extent vectors
        //--------------------------------------------------------------------------------------------
        *pMin = op->GetMp() - op->GetRad(); // Bounding-Box minimum extents (Local-space)
        *pMax = op->GetMp() + op->GetRad(); // Bounding-Box maximum extents (Local-space)

        // bottom
        mm.Init(*pMin * opgm);
        mm.AddPoint(Vector(pMin->x, pMin->y, pMax->z) * opgm);
        mm.AddPoint(Vector(pMax->x, pMin->y, pMax->z) * opgm);
        mm.AddPoint(Vector(pMax->x, pMin->y, pMin->z) * opgm);

        // top
        mm.AddPoint(*pMax * opgm);
        mm.AddPoint(Vector(pMax->x, pMax->y, pMin->z) * opgm);
        mm.AddPoint(Vector(pMin->x, pMax->y, pMin->z) * opgm);
        mm.AddPoint(Vector(pMin->x, pMax->y, pMax->z) * opgm);
    }

    // convert to AABBox (described by min/max extent vectors)
    *pMin = mm.GetMin();
    *pMax = mm.GetMax();

//    GePrint(op->GetName()+" bbMin: "+utVecToString(*pMin)+" bbMax: "+utVecToString(*pMax));
}


void AABBox::Init(BaseObject *op)
{
    m_init = false;
    if( !op )    return;

    this->GetAABBox(op, &m_bbMin, &m_bbMax);

    m_init = true;
}

Bool AABBox::CollidesWith(BaseObject *op)
{
    if( !m_init )    return false;

    Vector bbMin; // Bounding-Box minimum extents
    Vector bbMax; // Bounding-Box maximum extents

    this->GetAABBox(op, &bbMin, &bbMax);

    Bool xlap, ylap, zlap;
    if( bbMin.x < m_bbMax.x && bbMax.x > m_bbMin.x )    xlap = true;    else xlap = false;
    if( bbMin.y < m_bbMax.y && bbMax.y > m_bbMin.y )    ylap = true;    else ylap = false;
    if( bbMin.z < m_bbMax.z && bbMax.z > m_bbMin.z )    zlap = true;    else zlap = false;

    String slap = op->GetName();
    slap += " xlap: ";                slap += xlap ? "true" : "false";
    slap += " ylap: ";                slap += ylap ? "true" : "false";
    slap += " zlap: ";                slap += zlap ? "true" : "false";
    slap += " BBox Collision: ";    slap += (xlap && ylap && zlap) ? "true" : "false"; 
    GePrint(slap);

    return (xlap && ylap && zlap);
}

void BBoxTest(BaseObject *op)
{
    if( op )
    {
        AABBox aabb(op);

        BaseObject *op2 = op->GetNext();
        LONG collisions = 0;
        while( op2 )
        {
            collisions += aabb.CollidesWith(op2);
            op2 = op2->GetNext();
        }
    }
}