mxregion.h

Go to the documentation of this file.

#ifndef __MXREGION_H
#define __MXREGION_H
 
#include "decomp.h"
#include "mxcore.h"
#include "mxgeometry.h"
#include "mxlist.h"
 
// SIZE 0x08
class MxSegment {
protected:
    MxS32 m_min; 
    MxS32 m_max; 
 
public:
    MxSegment(MxS32 p_min, MxS32 p_max)
    {
        m_min = p_min;
        m_max = p_max;
    }
 
    MxS32 GetMin() { return m_min; }
 
    MxS32 GetMax() { return m_max; }
 
    MxSegment* Clone() { return new MxSegment(m_min, m_max); }
 
    MxBool Combine(MxSegment& p_seg);
 
    MxBool Adjacent(MxSegment& p_seg) { return m_max == p_seg.m_min || m_min == p_seg.m_max; }
 
    MxBool IntersectsH(MxRect32& p_rect) { return p_rect.GetRight() > m_min && p_rect.GetTop() < m_max; }
 
    MxBool operator==(MxSegment& p_seg) { return m_min == p_seg.m_min && m_max == p_seg.m_max; }
 
    MxBool operator!=(MxSegment& p_seg) { return !operator==(p_seg); }
};
 
// VTABLE: LEGO1 0x100dcc40
// VTABLE: BETA10 0x101c2628
// class MxCollection<MxSegment *>
 
// VTABLE: LEGO1 0x100dcc58
// VTABLE: BETA10 0x101c2610
// class MxList<MxSegment *>
 
// VTABLE: LEGO1 0x100dcc70
// VTABLE: BETA10 0x101c25f8
// class MxPtrList<MxSegment>
 
// VTABLE: LEGO1 0x100dcc88
// VTABLE: BETA10 0x101c25e0
// SIZE 0x18
class MxSegmentList : public MxPtrList<MxSegment> {
public:
    MxSegmentList() : MxPtrList<MxSegment>(TRUE) {}
 
    // SYNTHETIC: LEGO1 0x100c4e90
    // SYNTHETIC: BETA10 0x1014c1a0
    // MxSegmentList::`scalar deleting destructor'
};
 
// VTABLE: LEGO1 0x100dcbf8
// VTABLE: BETA10 0x101c25b0
// class MxPtrListCursor<MxSegment>
 
// VTABLE: LEGO1 0x100dcc28
// VTABLE: BETA10 0x101c25c8
// class MxListCursor<MxSegment *>
 
// VTABLE: LEGO1 0x100dcc10
// VTABLE: BETA10 0x101c2598
class MxSegmentListCursor : public MxPtrListCursor<MxSegment> {
public:
    MxSegmentListCursor(MxSegmentList* p_list) : MxPtrListCursor<MxSegment>(p_list) {}
};
 
// SIZE 0x0c
class MxSpan {
protected:
    MxS32 m_min;              
    MxS32 m_max;              
    MxSegmentList* m_segList; 
 
public:
    MxSpan(MxS32 p_min, MxS32 p_max);
 
    MxSpan(MxRect32& p_rect);
 
    ~MxSpan() { delete m_segList; }
 
    MxS32 GetMin() { return m_min; }
 
    void SetMin(MxS32 p_min) { m_min = p_min; }
 
    MxS32 GetMax() { return m_max; }
 
    void SetMax(MxS32 p_max) { m_max = p_max; }
 
    MxSpan* Clone();
 
    void Compact();
 
    MxBool Combine(MxSpan& p_span);
 
    MxBool Adjacent(MxSpan& p_span) { return m_max == p_span.m_min || m_min == p_span.m_max; }
 
    MxBool HasSameSegments(MxSpan& p_span);
 
    MxBool IntersectsV(MxRect32& p_rect) { return p_rect.GetBottom() > m_min && p_rect.GetTop() < m_max; }
 
    MxBool IntersectsH(MxRect32& p_rect);
 
    void AddSegment(MxS32 p_min, MxS32 p_max);
 
    MxBool operator==(MxSpan& p_span)
    {
        return m_min == p_span.m_min && m_max == p_span.m_max && HasSameSegments(p_span);
    }
 
    MxBool operator!=(MxSpan& p_span) { return !operator==(p_span); }
 
    friend class MxRegionCursor;
 
    // SYNTHETIC: BETA10 0x1014b0b0
    // MxSpan::`scalar deleting destructor'
};
 
// VTABLE: LEGO1 0x100dcb10
// VTABLE: BETA10 0x101c24f8
// class MxCollection<MxSpan *>
 
// VTABLE: LEGO1 0x100dcb28
// VTABLE: BETA10 0x101c24e0
// class MxList<MxSpan *>
 
// VTABLE: LEGO1 0x100dcb40
// VTABLE: BETA10 0x101c24c8
// class MxPtrList<MxSpan>
 
// VTABLE: LEGO1 0x100dcb58
// VTABLE: BETA10 0x101c24b0
// SIZE 0x18
class MxSpanList : public MxPtrList<MxSpan> {
public:
    MxSpanList() : MxPtrList<MxSpan>(TRUE) {}
 
    // SYNTHETIC: LEGO1 0x100c3410
    // SYNTHETIC: BETA10 0x1014af90
    // MxSpanList::`scalar deleting destructor'
};
 
// VTABLE: LEGO1 0x100dcb70
// VTABLE: BETA10 0x101c2528
// class MxPtrListCursor<MxSpan>
 
// VTABLE: LEGO1 0x100dcba0
// VTABLE: BETA10 0x101c2540
// class MxListCursor<MxSpan *>
 
// TODO: The initialize list param type should be MxSpanList, but doing that
// drastically reduced the match percentage for MxRegion::AddRect.
// (developer provided MxRegion.h file also uses MxSpanList*.)
// It also works with MxPtrList, so we'll do that until we figure this out.
 
// VTABLE: LEGO1 0x100dcb88
// VTABLE: BETA10 0x101c2510
class MxSpanListCursor : public MxPtrListCursor<MxSpan> {
public:
    MxSpanListCursor(MxPtrList<MxSpan>* p_list) : MxPtrListCursor<MxSpan>(p_list) {}
};
 
// VTABLE: LEGO1 0x100dcae8
// SIZE 0x1c
class MxRegion : public MxCore {
protected:
    MxSpanList* m_spanList;  
    MxRect32 m_boundingRect; 
 
public:
    MxRegion();
    
    ~MxRegion() override;
 
    MxRect32& GetBoundingRect() { return m_boundingRect; }
 
    virtual void Reset();                        // vtable+0x14
 
    virtual void AddRect(MxRect32& p_rect);      // vtable+0x18
 
    virtual MxBool Intersects(MxRect32& p_rect); // vtable+0x1c
 
    virtual MxBool IsEmpty() { return m_spanList->GetNumElements() == 0; } // vtable+0x20
 
    void Compact();
 
    friend class MxRegionCursor;
 
    // SYNTHETIC: LEGO1 0x100c3670
    // SYNTHETIC: BETA10 0x1014b230
    // MxRegion::`scalar deleting destructor'
};
 
// VTABLE: LEGO1 0x100dcbb8
// SIZE 0x18
class MxRegionCursor : public MxCore {
protected:
    MxRegion* m_region;                   
    MxRect32* m_rect;                     
    MxSpanListCursor* m_spanListCursor;   
    MxSegmentListCursor* m_segListCursor; 
 
    void CreateSegmentListCursor(MxSegmentList* p_segList);
 
    void SetRect(MxS32 p_left, MxS32 p_top, MxS32 p_right, MxS32 p_bottom);
 
    void NextSpan(MxRect32& p_rect);
 
    void PrevSpan(MxRect32& p_rect);
 
public:
    MxRegionCursor(MxRegion* p_region);
 
    ~MxRegionCursor() override;
 
    virtual MxRect32* Head();                 // vtable+0x18
 
    virtual MxRect32* Tail();                 // vtable+0x20
 
    virtual MxRect32* Next();                 // vtable+0x28
 
    virtual MxRect32* Prev();                 // vtable+0x30
 
    virtual MxRect32* Head(MxRect32& p_rect); // vtable+0x14
 
    virtual MxRect32* Tail(MxRect32& p_rect); // vtable+0x1c
 
    virtual MxRect32* Next(MxRect32& p_rect); // vtable+0x24
 
    virtual MxRect32* Prev(MxRect32& p_rect); // vtable+0x2c
 
    virtual MxRect32* GetRect() { return m_rect; } // vtable+0x34
 
    virtual MxBool Valid() { return m_rect != NULL; } // vtable+0x38
 
    virtual void Reset(); // vtable+0x3c
 
    // SYNTHETIC: LEGO1 0x100c4090
    // MxRegionCursor::`scalar deleting destructor'
};
 
#ifdef REGION_SANITY_CHECK
 
class MxRectIntersection {
protected:
    MxRect32 m_rect; 
    MxS32 m_numRects; 
 
public:
    MxRect32& GetRect() { return m_rect; }
 
    void SetRect(MxRect32& p_rect) { m_rect = p_rect; }
 
    MxS32 GetNumRects() { return m_numRects; }
 
    void SetNumRects(MxS32 p_numRects) { m_numRects = p_numRects; }
};
 
class MxRectIntersectionList : public MxPtrList<MxRectIntersection> {
public:
    MxRectIntersectionList() : MxPtrList<MxRectIntersection>(TRUE) {}
};
 
class MxRectIntersectionListCursor : public MxPtrListCursor<MxRectIntersection> {
public:
    MxRectIntersectionListCursor(MxRectIntersectionList* p_list) : MxPtrListCursor<MxRectIntersection>(p_list) {}
};
 
class MxRegionSanityCheck {
protected:
    MxRectIntersectionList* m_rectIntersectionList; 
 
public:
    MxRegionSanityCheck();
 
    ~MxRegionSanityCheck();
 
    void Reset() { m_rectIntersectionList->Delete(); }
 
    void AddRect(MxRect32& p_rect);
 
    MxS32 CalculateArea();
};
 
#endif
 
#endif // __MXREGION_H