Mesh3dTriangleTriangleConstCirculator.h

// Mesh3dTriangleTriangleConstCirculator.h:
// ----------------------------------------
//

#ifndef __IPSDKGEOMETRY_MESH3DTRIANGLETRIANGLECONSTCIRCULATOR_H__
#define __IPSDKGEOMETRY_MESH3DTRIANGLETRIANGLECONSTCIRCULATOR_H__

#include <IPSDKGeometry/IPSDKGeometryExports.h>
#include <IPSDKGeometry/Entity/3d/Mesh/Mesh3dTypes.h>
#include <IPSDKGeometry/Entity/3d/Triangle/Triangle3d.h>
#include <IPSDKUtil/Tools/NumericLimits.h>
#include <IPSDKUtil/Tools/ForceInline.h>

namespace ipsdk {
namespace geom {


template <typename MeshType>
class Mesh3dTriangleTriangleConstCirculator
{
// predefined public types
public:
    typedef typename MeshType::DataType T;

    typedef typename MeshType::VertexType VertexType;
    
    typedef Triangle3d<T> TriangleType;

    typedef Mesh3dTriangleTriangleConstCirculator<MeshType> Iterator;

    typedef std::input_iterator_tag iterator_category;

    typedef TriangleType value_type;

    // difference type for iterator
    typedef ipUInt32 difference_type;

    typedef const TriangleType* pointer;

    // reference type associated to iterator
    typedef const TriangleType& reference;

public:
    Mesh3dTriangleTriangleConstCirculator() :
        _pMesh(0),
        _startHalfEdgeIdx(NumericLimits<ipUInt32>::max()),
        _curHalfEdgeIdx(NumericLimits<ipUInt32>::max())

    {
    }
    Mesh3dTriangleTriangleConstCirculator(const MeshType* pMesh,
                                          const ipUInt32 startTriangleIdx) :
        _pMesh(pMesh),
        _startHalfEdgeIdx(_pMesh->getTriangleToHalfEdgeColl()[startTriangleIdx]),
        _curHalfEdgeIdx(_startHalfEdgeIdx)
    {
        updateData();
    }
    Mesh3dTriangleTriangleConstCirculator(const Iterator& iter) :
        _pMesh(iter._pMesh),
        _startHalfEdgeIdx(iter._startHalfEdgeIdx),
        _curHalfEdgeIdx(iter._curHalfEdgeIdx),
        _triangle(iter._triangle)
    {
    }
    Mesh3dTriangleTriangleConstCirculator& operator= (const Iterator& iter)
    {
        _pMesh = iter._pMesh;
        _startHalfEdgeIdx = iter._startHalfEdgeIdx;
        _curHalfEdgeIdx = iter._curHalfEdgeIdx;
        _triangle = iter._triangle;
    }
    ~Mesh3dTriangleTriangleConstCirculator()
    {
    }

// methods
public:
    const ipUInt32              getStartHalfEdgeIdx() const;

    const ipUInt32              getCurHalfEdgeIdx() const;

    TriangleType                getStartTriangle() const;

    inline Iterator&            operator++();

    inline bool                 operator==(const Iterator& iter) const;
    inline bool                 operator!=(const Iterator& iter) const;

    inline const TriangleType*  operator->() const;

    inline const TriangleType&  operator*() const;

    void                        swap(Iterator& iter);
    
protected:
    inline void                 updateData();

// attributes
protected:
    const MeshType*                 _pMesh;

    ipUInt32                        _startHalfEdgeIdx;

    ipUInt32                        _curHalfEdgeIdx;

    TriangleType                    _triangle;
};


template <typename MeshType>
IPSDK_FORCEINLINE const ipUInt32
Mesh3dTriangleTriangleConstCirculator<MeshType>::getStartHalfEdgeIdx() const
{
    return _startHalfEdgeIdx;
}

template <typename MeshType>
IPSDK_FORCEINLINE const ipUInt32
Mesh3dTriangleTriangleConstCirculator<MeshType>::getCurHalfEdgeIdx() const
{
    return _curHalfEdgeIdx;
}

template <typename MeshType>
IPSDK_FORCEINLINE typename Mesh3dTriangleTriangleConstCirculator<MeshType>::TriangleType
Mesh3dTriangleTriangleConstCirculator<MeshType>::getStartTriangle() const
{
    const Mesh3dHalfEdge& startHalfEdge = _pMesh->getHalfEdgeColl()[_startHalfEdgeIdx];
    const Mesh3dHalfEdge& nextHalfEdge = _pMesh->getHalfEdgeColl()[startHalfEdge._nextHalfEdgeIdx];
    const Mesh3dHalfEdge& prevHalfEdge = _pMesh->getHalfEdgeColl()[nextHalfEdge._nextHalfEdgeIdx];
    const VertexType& v0 = _pMesh->getVertexColl()[startHalfEdge._startVertexIdx];
    const VertexType& v1 = _pMesh->getVertexColl()[nextHalfEdge._startVertexIdx];
    const VertexType& v2 = _pMesh->getVertexColl()[prevHalfEdge._startVertexIdx];

    return TriangleType(v0, v1, v2);
}

template <typename MeshType>
IPSDK_FORCEINLINE typename Mesh3dTriangleTriangleConstCirculator<MeshType>::Iterator&
Mesh3dTriangleTriangleConstCirculator<MeshType>::operator++()
{
    // search for next half edge
    const Mesh3dHalfEdge& curHalfEdge = _pMesh->getHalfEdgeColl()[_curHalfEdgeIdx];
    const Mesh3dHalfEdge& oppositeHalfEdge = _pMesh->getHalfEdgeColl()[curHalfEdge._oppositeHalfEdgeIdx];
    _curHalfEdgeIdx = oppositeHalfEdge._nextHalfEdgeIdx;
    if (_curHalfEdgeIdx == _startHalfEdgeIdx)
        _curHalfEdgeIdx = NumericLimits<ipUInt32>::max();
    updateData();

    return *this;
}

template <typename MeshType>
IPSDK_FORCEINLINE bool
Mesh3dTriangleTriangleConstCirculator<MeshType>::operator==(const Iterator& iter) const
{
    return _curHalfEdgeIdx == iter._curHalfEdgeIdx;
}

template <typename MeshType>
IPSDK_FORCEINLINE bool
Mesh3dTriangleTriangleConstCirculator<MeshType>::operator!=(const Iterator& iter) const
{
    return _curHalfEdgeIdx != iter._curHalfEdgeIdx;
}

template <typename MeshType>
IPSDK_FORCEINLINE const typename Mesh3dTriangleTriangleConstCirculator<MeshType>::TriangleType*
Mesh3dTriangleTriangleConstCirculator<MeshType>::operator->() const
{
    return &_triangle;
}

template <typename MeshType>
IPSDK_FORCEINLINE const typename Mesh3dTriangleTriangleConstCirculator<MeshType>::TriangleType&
Mesh3dTriangleTriangleConstCirculator<MeshType>::operator*() const
{
    return _triangle;
}

template <typename MeshType>
IPSDK_FORCEINLINE void
Mesh3dTriangleTriangleConstCirculator<MeshType>::updateData()
{
    const Mesh3dHalfEdge& curHalfEdge = _pMesh->getHalfEdgeColl()[_curHalfEdgeIdx];
    const Mesh3dHalfEdge& oppositeHalfEdge = _pMesh->getHalfEdgeColl()[curHalfEdge._oppositeHalfEdgeIdx];
    const Mesh3dHalfEdge& nextOppositeHalfEdge = _pMesh->getHalfEdgeColl()[oppositeHalfEdge._nextHalfEdgeIdx];
    const Mesh3dHalfEdge& prevOppositeHalfEdge = _pMesh->getHalfEdgeColl()[nextOppositeHalfEdge._nextHalfEdgeIdx];
    const VertexType& v0 = _pMesh->getVertexColl()[oppositeHalfEdge._startVertexIdx];
    const VertexType& v1 = _pMesh->getVertexColl()[nextOppositeHalfEdge._startVertexIdx];
    const VertexType& v2 = _pMesh->getVertexColl()[prevOppositeHalfEdge._startVertexIdx];

    _triangle.setCoords(v0, v1, v2);
}

template <typename MeshType>
inline void
Mesh3dTriangleTriangleConstCirculator<MeshType>::swap(Iterator& iter)
{
    std::swap(_pMesh, iter._pMesh);
    std::swap(_startHalfEdgeIdx, iter._startHalfEdgeIdx);
    std::swap(_curHalfEdgeIdx, iter._curHalfEdgeIdx);
    std::swap(_triangle, iter._triangle);
}


} // end of namespace geom
} // end of namespace ipsdk

#endif // __IPSDKGEOMETRY_MESH3DTRIANGLETRIANGLECONSTCIRCULATOR_H__