box2iiterator.h

Go to the documentation of this file.

/*
* Copyright 2016 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/

#pragma once

#include "gwnavruntime/math/box2i.h"
#include "gwnavruntime/basesystem/logger.h"

namespace Kaim
{

class Box2iRowMajorIterator
{
    KY_DEFINE_NEW_DELETE_OPERATORS(Stat_Default_Mem)
public:
    // ------------------------------ Functions -----------------------------
    Box2iRowMajorIterator() : m_box(nullptr), m_pos(KyInt32MINVAL, KyInt32MINVAL), m_currentIdx(-1) {}
    Box2iRowMajorIterator(const Box2i& box) : m_box(&box), m_pos(KyInt32MINVAL, KyInt32MINVAL), m_currentIdx(-1)
    {
        if (m_box != nullptr && box.IsValid())
        {
            m_pos = box.Min();
            m_currentIdx = 0;
        }
    }

    bool operator==(const Box2iRowMajorIterator& it) const { return m_box == it.m_box && m_currentIdx == it.m_currentIdx; }
    bool operator!=(const Box2iRowMajorIterator& it) const { return m_box != it.m_box || m_currentIdx != it.m_currentIdx; }

    Box2iRowMajorIterator& operator++()
    {
        if (IsFinished() == false)
        {
            if (m_pos.x < m_box->Max().x)
            {
                ++m_pos.x;
                ++m_currentIdx;
            }
            else if (m_pos.y < m_box->Max().y)
            {
                m_pos.x = m_box->Min().x;
                ++m_pos.y;
                ++m_currentIdx;
            }
            else
            {
                m_currentIdx = -1;
            }
        }
        return *this;
    }

    bool IsFinished() const { return m_currentIdx < 0 || m_box == nullptr; }

    KyInt32 GetRowMajorIndex()  const { return m_currentIdx; }
    const Vec2i& GetPos()       const { return m_pos;        }

    // ------------------------------ Data -----------------------------
    const Box2i* m_box;
    Vec2i m_pos;
    KyInt32 m_currentIdx;
};


class Box2iIteratorInBiggerRowMajorBox
{
public:
    // ------------------------------ Functions -----------------------------

    Box2iIteratorInBiggerRowMajorBox() : m_innerBox(nullptr), m_outerBox(nullptr), m_pos(KyInt32MINVAL, KyInt32MINVAL), m_innerBoxIdx(-1), m_outerBoxIdx(-1) {}

    Box2iIteratorInBiggerRowMajorBox(const Box2i& innerBox, const Box2i& outerBox)
      : m_innerBox(&innerBox), m_outerBox(&outerBox), m_pos(KyInt32MINVAL, KyInt32MINVAL), m_innerBoxIdx(-1), m_outerBoxIdx(-1)
    {
        Init();
    }

    void Init()
    {
        if (m_innerBox != nullptr && m_outerBox != nullptr && m_innerBox->IsValid() && m_outerBox->IsValid())
        {
            KY_LOG_ERROR_IF(m_outerBox->DoesContain(m_innerBox->Min()) == false || m_outerBox->DoesContain(m_innerBox->Max()) == false ,
                ("Error in boxes provided for Box2iRowMajorIterator. the innerBox must be fully included in the outerBox"));
            m_pos = m_innerBox->Min();
            m_innerBoxIdx = 0;
            m_outerBoxIdx = m_outerBox->GetRowMajorIndex(m_pos);
        }
    }

    Box2iIteratorInBiggerRowMajorBox& operator++()
    {
        if (IsFinished() == false)
        {
            if (m_pos.x < m_innerBox->Max().x)
            {
                ++m_pos.x;
                ++m_innerBoxIdx;
                ++m_outerBoxIdx;
                KY_ASSERT(m_outerBoxIdx == m_outerBox->GetRowMajorIndex(m_pos));
                KY_ASSERT(m_innerBoxIdx == m_innerBox->GetRowMajorIndex(m_pos));

            }
            else if (m_pos.y < m_innerBox->Max().y)
            {
                m_pos.x = m_innerBox->Min().x;
                ++m_pos.y;
                ++m_innerBoxIdx;
                m_outerBoxIdx += (m_outerBox->CountX() - m_innerBox->CountX()) + 1;
                KY_ASSERT(m_outerBoxIdx == m_outerBox->GetRowMajorIndex(m_pos));
                KY_ASSERT(m_innerBoxIdx == m_innerBox->GetRowMajorIndex(m_pos));
            }
            else
            {
                m_innerBoxIdx = -1;
                m_outerBoxIdx = -1;
            }
        }
        return *this;
    }

    bool IsFinished() const { return m_innerBoxIdx < 0 || m_outerBoxIdx < 0 || m_innerBox == nullptr || m_outerBox == nullptr; }

    KyInt32 GetInnerBoxRowMajorIndex() const { return m_innerBoxIdx; }
    KyInt32 GetOuterBoxRowMajorIndex() const { return m_outerBoxIdx; }
    const Vec2i& GetPos()              const { return m_pos;        }

private:
    // ------------------------------ Private Data -----------------------------
    const Box2i* m_innerBox;
    const Box2i* m_outerBox;
    Vec2i m_pos;
    KyInt32 m_innerBoxIdx;
    KyInt32 m_outerBoxIdx;
};

}