triangleiterator.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
#include <utility/dllexport.h>
#include <vertexattribute.h>
#include <mesh.h>
#include <glm/glm.hpp>
#include <array>
 
namespace nap
{
    class MeshInstance;
    class MeshShape;
 
    template<class T>
    class TriangleData
    {
    public:
        TriangleData(const T& first, const T& second, const T& third) : 
        mData({{first, second, third }} )
        { }
 
        TriangleData() = default;
 
        inline const T& first() const                       { return mData[0]; }
        
        inline void setFirst(const T& data)                 { mData[0] = data; }
 
        inline const T& second() const                      { return mData[1]; }
        
        inline void setSecond(const T& data)                { mData[1] = data; }
 
        inline const T& third() const                       { return mData[2]; }
 
        inline void setThird(const T& data) const           { mData[2] = data; }
 
        T& operator[](std::size_t index)                    { return mData[index]; }
 
        const T& operator[](std::size_t index) const        { return mData[index]; }
 
    private:
        std::array<T, 3> mData;
    };
 
 
    class ShapeTriangle
    {
    public:
        using IndexArray = std::array<int, 3>;
 
        ShapeTriangle(int triangleIndex, int index0, int index1, int index2);
 
        int getTriangleIndex() const                        { return mTriangleIndex; }
 
        IndexArray indices() const                          { return mIndices; }
 
        int firstIndex() const                              { return mIndices[0]; }
        
        int secondIndex() const                             { return mIndices[1]; }
 
        int thirdIndex() const                              { return mIndices[2]; } 
 
        int operator[](std::size_t index) const             { return mIndices[index]; }
 
        IndexArray::const_iterator begin()                  { return mIndices.begin(); }
        IndexArray::const_iterator end()                    { return mIndices.end(); }
 
        template<class T>
        TriangleData<T> getVertexData(const VertexAttribute<T>& attribute) const
        {
            return TriangleData<T>(attribute[mIndices[0]], attribute[mIndices[1]], attribute[mIndices[2]]);
        }
 
        template<class T>
        void setVertexData(VertexAttribute<T>& attribute, const T& firstValue, const T& secondValue, const T& thirdValue)
        {
            attribute[mIndices[0]] = firstValue;
            attribute[mIndices[1]] = secondValue;
            attribute[mIndices[2]] = thirdValue;
        }
 
        template<class T>
        void setVertexData(VertexAttribute<T>& attribute, const T& value)
        {
            setVertexData(attribute, value, value, value);
        }
 
        template<class T>
        void setVertexData(VertexAttribute<T>& attribute, const TriangleData<T>& value)
        {
            setVertexData(value[0], value[1], value[2]);
        }
 
    private:
        IndexArray mIndices;
        int mTriangleIndex;
    };
 
 
    class Triangle : public ShapeTriangle
    {
    public:
        int getShapeIndex() const { return mShapeIndex; }
 
    private:
        friend class TriangleIterator;
 
        Triangle(int shapeIndex, const ShapeTriangle& shapeTriangle);
 
    private:
        int mShapeIndex;
    };
 
 
    class NAPAPI ShapeTriangleIterator
    {
    public:
        ShapeTriangleIterator(const MeshShape& shape, int startIndex);
        virtual ~ShapeTriangleIterator()    {}
 
        bool isDone() const { return mCurrentIndex >= mIndexEnd; }
 
        virtual const ShapeTriangle next() = 0;
 
    protected:
        const uint32*   mCurrentIndex;      
        int mCurrentTriangle = 0;
    
    private:
        const uint32*   mIndexEnd;          
    };
 
 
    class NAPAPI ShapeTriangleListIterator final : public ShapeTriangleIterator
    {
    public:
        ShapeTriangleListIterator(const MeshShape& shape);
 
        virtual const ShapeTriangle next() override;
    };
 
 
    class NAPAPI ShapeTriangleFanIterator final : public ShapeTriangleIterator
    {
    public:
        ShapeTriangleFanIterator(const MeshShape& shape);
 
        virtual const ShapeTriangle next() override;
 
    private:
        uint32  mFanStartIndex;         
    };
 
 
    class NAPAPI ShapeTriangleStripIterator final : public ShapeTriangleIterator
    {
    public:
        ShapeTriangleStripIterator(const MeshShape& shape);
 
        virtual const ShapeTriangle next() override;
    };
 
    class NAPAPI TriangleIterator final
    {
    public:
        TriangleIterator(const MeshInstance& meshInstance);
        ~TriangleIterator();
 
        bool isDone() const                         { return mCurIterator == nullptr; }
 
        const Triangle next();
 
    private:
        void advanceToNextShape();
 
    private:
        const MeshInstance*     mMeshInstance;          
        ShapeTriangleIterator*  mCurIterator;           
        int                     mCurShapeIndex;         
    };
}