mxregion.cpp

Go to the documentation of this file.

#include "mxregion.h"
 
#include <limits.h>
 
DECOMP_SIZE_ASSERT(MxRegion, 0x1c)
DECOMP_SIZE_ASSERT(MxSpan, 0x0c)
DECOMP_SIZE_ASSERT(MxSegment, 0x08)
DECOMP_SIZE_ASSERT(MxRegionCursor, 0x18)
 
// FUNCTION: LEGO1 0x100c31c0
// FUNCTION: BETA10 0x10148f00
MxRegion::MxRegion()
{
    m_spanList = new MxSpanList;
    m_boundingRect = MxRect32(INT_MAX, INT_MAX, -1, -1);
}
 
// FUNCTION: LEGO1 0x100c3690
// FUNCTION: BETA10 0x10148fe8
MxRegion::~MxRegion()
{
    delete m_spanList;
}
 
// FUNCTION: LEGO1 0x100c3700
// FUNCTION: BETA10 0x1014907a
void MxRegion::Reset()
{
    m_spanList->DeleteAll();
    m_boundingRect = MxRect32(INT_MAX, INT_MAX, -1, -1);
}
 
// FUNCTION: LEGO1 0x100c3750
// FUNCTION: BETA10 0x101490bd
void MxRegion::AddRect(MxRect32& p_rect)
{
    MxRect32 rect(p_rect);
    MxRect32 newRect;
    MxSpanListCursor cursor(m_spanList);
    MxSpan* span;
 
    while (!rect.Empty() && cursor.Next(span)) {
        if (span->GetMin() >= rect.GetBottom()) {
            MxSpan* newSpan = new MxSpan(rect);
            cursor.Prepend(newSpan);
            rect.SetTop(rect.GetBottom());
        }
        else if (rect.GetTop() < span->GetMax()) {
            if (rect.GetTop() < span->GetMin()) {
                newRect = rect;
                newRect.SetBottom(span->GetMin());
                MxSpan* newSpan = new MxSpan(newRect);
                cursor.Prepend(newSpan);
                rect.SetTop(span->GetMin());
            }
            else if (span->GetMin() < rect.GetTop()) {
                MxSpan* newSpan = span->Clone();
                newSpan->SetMax(rect.GetTop());
                span->SetMin(rect.GetTop());
                cursor.Prepend(newSpan);
            }
 
            if (rect.GetBottom() < span->GetMax()) {
                MxSpan* newSpan = span->Clone();
                newSpan->SetMax(rect.GetBottom());
                span->SetMin(rect.GetBottom());
                newSpan->AddSegment(rect.GetLeft(), rect.GetRight());
                cursor.Prepend(newSpan);
                rect.SetTop(rect.GetBottom());
            }
            else {
                span->AddSegment(rect.GetLeft(), rect.GetRight());
                rect.SetTop(span->GetMax());
            }
        }
    }
 
    if (!rect.Empty()) {
        MxSpan* newSpan = new MxSpan(rect);
        m_spanList->Append(newSpan);
    }
 
    m_boundingRect |= p_rect;
}
 
// FUNCTION: LEGO1 0x100c3e20
// FUNCTION: BETA10 0x10149535
MxBool MxRegion::Intersects(MxRect32& p_rect)
{
    if (!m_boundingRect.Intersects(p_rect)) {
        return FALSE;
    }
 
    MxSpanListCursor cursor(m_spanList);
    MxSpan* span;
 
    while (cursor.Next(span)) {
        if (span->GetMin() >= p_rect.GetBottom()) {
            return FALSE;
        }
 
        if (span->GetMax() > p_rect.GetTop() && span->IntersectsH(p_rect)) {
            return TRUE;
        }
    }
 
    return FALSE;
}
 
// FUNCTION: LEGO1 0x100c3f70
// FUNCTION: BETA10 0x10149663
MxRegionCursor::MxRegionCursor(MxRegion* p_region)
{
    m_region = p_region;
    m_rect = NULL;
    m_spanListCursor = new MxSpanListCursor(m_region->m_spanList);
    m_segListCursor = NULL;
}
 
// FUNCTION: LEGO1 0x100c40b0
MxRegionCursor::~MxRegionCursor()
{
    if (m_rect) {
        delete m_rect;
    }
 
    if (m_spanListCursor) {
        delete m_spanListCursor;
    }
 
    if (m_segListCursor) {
        delete m_segListCursor;
    }
}
 
// FUNCTION: LEGO1 0x100c4140
MxRect32* MxRegionCursor::Head()
{
    m_spanListCursor->Head();
 
    MxSpan* span;
    if (m_spanListCursor->Current(span)) {
        CreateSegmentListCursor(span->m_segList);
 
        MxSegment* segment;
        m_segListCursor->First(segment);
 
        SetRect(segment->GetMin(), span->GetMin(), segment->GetMax(), span->GetMax());
    }
    else {
        Reset();
    }
 
    return m_rect;
}
 
// FUNCTION: LEGO1 0x100c41d0
MxRect32* MxRegionCursor::Tail()
{
    m_spanListCursor->Tail();
 
    MxSpan* span;
    if (m_spanListCursor->Current(span)) {
        CreateSegmentListCursor(span->m_segList);
 
        MxSegment* segment;
        m_segListCursor->Last(segment);
 
        SetRect(segment->GetMin(), span->GetMin(), segment->GetMax(), span->GetMax());
    }
    else {
        Reset();
    }
 
    return m_rect;
}
 
// FUNCTION: LEGO1 0x100c4260
MxRect32* MxRegionCursor::Next()
{
    MxSegment* segment;
    MxSpan* span;
 
    if (m_segListCursor && m_segListCursor->Next(segment)) {
        m_spanListCursor->Current(span);
 
        SetRect(segment->GetMin(), span->GetMin(), segment->GetMax(), span->GetMax());
        return m_rect;
    }
 
    if (m_spanListCursor->Next(span)) {
        CreateSegmentListCursor(span->m_segList);
        m_segListCursor->First(segment);
 
        SetRect(segment->GetMin(), span->GetMin(), segment->GetMax(), span->GetMax());
        return m_rect;
    }
 
    Reset();
    return m_rect;
}
 
// FUNCTION: LEGO1 0x100c4360
MxRect32* MxRegionCursor::Prev()
{
    MxSegment* segment;
    MxSpan* span;
 
    if (m_segListCursor && m_segListCursor->Prev(segment)) {
        m_spanListCursor->Current(span);
 
        SetRect(segment->GetMin(), span->GetMin(), segment->GetMax(), span->GetMax());
        return m_rect;
    }
 
    if (m_spanListCursor->Prev(span)) {
        CreateSegmentListCursor(span->m_segList);
        m_segListCursor->Last(segment);
 
        SetRect(segment->GetMin(), span->GetMin(), segment->GetMax(), span->GetMax());
        return m_rect;
    }
 
    Reset();
    return m_rect;
}
 
// FUNCTION: LEGO1 0x100c4460
MxRect32* MxRegionCursor::Head(MxRect32& p_rect)
{
    m_spanListCursor->Reset();
    NextSpan(p_rect);
    return m_rect;
}
 
// FUNCTION: LEGO1 0x100c4480
MxRect32* MxRegionCursor::Tail(MxRect32& p_rect)
{
    m_spanListCursor->Reset();
    PrevSpan(p_rect);
    return m_rect;
}
 
// FUNCTION: LEGO1 0x100c44a0
MxRect32* MxRegionCursor::Next(MxRect32& p_rect)
{
    MxSegment* segment;
 
    if (m_segListCursor && m_segListCursor->Next(segment)) {
        MxSpan* span;
 
        m_spanListCursor->Current(span);
 
        if (span->IntersectsV(p_rect) && segment->IntersectsH(p_rect)) {
            SetRect(segment->GetMin(), span->GetMin(), segment->GetMax(), span->GetMax());
            *m_rect &= p_rect;
        }
        else {
            NextSpan(p_rect);
        }
    }
    else {
        NextSpan(p_rect);
    }
 
    return m_rect;
}
 
// FUNCTION: LEGO1 0x100c4590
MxRect32* MxRegionCursor::Prev(MxRect32& p_rect)
{
    MxSegment* segment;
 
    if (m_segListCursor && m_segListCursor->Prev(segment)) {
        MxSpan* span;
 
        m_spanListCursor->Current(span);
 
        if (span->IntersectsV(p_rect) && segment->IntersectsH(p_rect)) {
            SetRect(segment->GetMin(), span->GetMin(), segment->GetMax(), span->GetMax());
            *m_rect &= p_rect;
        }
        else {
            PrevSpan(p_rect);
        }
    }
    else {
        PrevSpan(p_rect);
    }
 
    return m_rect;
}
 
// FUNCTION: LEGO1 0x100c4680
void MxRegionCursor::Reset()
{
    if (m_rect) {
        delete m_rect;
        m_rect = NULL;
    }
 
    m_spanListCursor->Reset();
 
    if (m_segListCursor) {
        delete m_segListCursor;
        m_segListCursor = NULL;
    }
}
 
// FUNCTION: LEGO1 0x100c46c0
void MxRegionCursor::CreateSegmentListCursor(MxSegmentList* p_segList)
{
    if (m_segListCursor) {
        delete m_segListCursor;
    }
 
    m_segListCursor = new MxSegmentListCursor(p_segList);
}
 
// FUNCTION: LEGO1 0x100c4980
void MxRegionCursor::SetRect(MxS32 p_left, MxS32 p_top, MxS32 p_right, MxS32 p_bottom)
{
    if (!m_rect) {
        m_rect = new MxRect32;
    }
 
    m_rect->SetLeft(p_left);
    m_rect->SetTop(p_top);
    m_rect->SetRight(p_right);
    m_rect->SetBottom(p_bottom);
}
 
// FUNCTION: LEGO1 0x100c4a20
void MxRegionCursor::NextSpan(MxRect32& p_rect)
{
    MxSpan* span;
    while (m_spanListCursor->Next(span)) {
        if (p_rect.GetBottom() <= span->GetMin()) {
            Reset();
            return;
        }
 
        if (p_rect.GetTop() < span->GetMax()) {
            CreateSegmentListCursor(span->m_segList);
 
            MxSegment* segment;
            while (m_segListCursor->Next(segment)) {
                if (p_rect.GetRight() <= segment->GetMin()) {
                    break;
                }
 
                if (p_rect.GetLeft() < segment->GetMax()) {
                    SetRect(segment->GetMin(), span->GetMin(), segment->GetMax(), span->GetMax());
                    *m_rect &= p_rect;
                    return;
                }
            }
        }
    }
 
    Reset();
}
 
// FUNCTION: LEGO1 0x100c4b50
void MxRegionCursor::PrevSpan(MxRect32& p_rect)
{
    MxSpan* span;
    while (m_spanListCursor->Prev(span)) {
        if (span->GetMax() <= p_rect.GetTop()) {
            Reset();
            return;
        }
 
        if (span->GetMin() < p_rect.GetBottom()) {
            CreateSegmentListCursor(span->m_segList);
 
            MxSegment* segment;
            while (m_segListCursor->Prev(segment)) {
                if (segment->GetMax() <= p_rect.GetLeft()) {
                    break;
                }
 
                if (segment->GetMin() < p_rect.GetRight()) {
                    SetRect(segment->GetMin(), span->GetMin(), segment->GetMax(), span->GetMax());
                    *m_rect &= p_rect;
                    return;
                }
            }
        }
    }
 
    Reset();
}
 
// FUNCTION: LEGO1 0x100c4c90
MxSpan::MxSpan(MxS32 p_min, MxS32 p_max)
{
    m_min = p_min;
    m_max = p_max;
    m_segList = new MxSegmentList;
}
 
// FUNCTION: LEGO1 0x100c50e0
// FUNCTION: BETA10 0x1014a2d6
MxSpan::MxSpan(MxRect32& p_rect)
{
    m_min = p_rect.GetTop();
    m_max = p_rect.GetBottom();
    m_segList = new MxSegmentList;
 
    MxSegment* segment = new MxSegment(p_rect.GetLeft(), p_rect.GetRight());
    m_segList->Append(segment);
}
 
// FUNCTION: LEGO1 0x100c5280
// FUNCTION: BETA10 0x1014a3fc
void MxSpan::AddSegment(MxS32 p_min, MxS32 p_max)
{
    MxSegmentListCursor a(m_segList);
    MxSegmentListCursor b(m_segList);
 
    MxSegment* segment;
    while (a.Next(segment) && segment->GetMax() < p_min) {
        ;
    }
 
    if (a.HasMatch()) {
        if (p_min > segment->GetMin()) {
            p_min = segment->GetMin();
        }
 
        while (segment->GetMin() < p_max) {
            if (p_max < segment->GetMax()) {
                p_max = segment->GetMax();
            }
 
            b = a;
            b.Next();
            a.Destroy();
 
            if (!b.Current(segment)) {
                break;
            }
 
            a = b;
        }
 
        if (a.HasMatch()) {
            MxSegment* copy = new MxSegment(p_min, p_max);
            a.Prepend(copy);
        }
        else {
            MxSegment* copy = new MxSegment(p_min, p_max);
            m_segList->Append(copy);
        }
    }
    else {
        MxSegment* copy = new MxSegment(p_min, p_max);
        m_segList->Append(copy);
    }
}
 
// FUNCTION: LEGO1 0x100c55d0
MxSpan* MxSpan::Clone()
{
    MxSpan* clone = new MxSpan(m_min, m_max);
 
    MxSegmentListCursor cursor(m_segList);
    MxSegment* segment;
 
    while (cursor.Next(segment)) {
        clone->m_segList->Append(segment->Clone());
    }
 
    return clone;
}
 
// FUNCTION: LEGO1 0x100c57b0
// FUNCTION: BETA10 0x1014aa46
MxBool MxSpan::IntersectsH(MxRect32& p_rect)
{
    MxSegmentListCursor cursor(m_segList);
    MxSegment* segment;
 
    while (cursor.Next(segment)) {
        if (p_rect.GetRight() <= segment->GetMin()) {
            return FALSE;
        }
 
        if (segment->GetMax() > p_rect.GetLeft()) {
            return TRUE;
        }
    }
 
    return FALSE;
}