SortedFragmentIterator.hpp

#ifndef __FISHEYE_SortedFragmentIterator_HPP
#define __FISHEYE_SortedFragmentIterator_HPP

#include "fisheyeDllApi.h"
#include <field/Field.hpp>
#include <GL/fiberGL.hpp>
#include <ocean/shrimp/VCamera.hpp>
#include <ocean/aerie/BoundingBox.hpp>

namespace Wizt
{

using namespace Fiber;
using namespace Eagle;


struct  fisheye_API SortedFragmentIterator : public FieldFragmentIterator
{
        const VCamera   &myCamera;
        RefPtr<Field>   Coords; 

        SortedFragmentIterator(const VCamera&Cam, const RefPtr<Field>&Crds)
        : myCamera(Cam)
        , Coords(Crds)
        {} 

        ~SortedFragmentIterator();

        struct  SpatialFragment
        {
                const RefPtr<FragmentID>  ID;
                RefPtr<BoundingBox>       BBox;
                RefPtr<CreativeArrayBase> DataCreator;

                SpatialFragment(const RefPtr<FragmentID>&fid,
                                const RefPtr<BoundingBox>&pBBox,
                                const RefPtr<CreativeArrayBase>&pDataCreator)
                : ID(fid)
                , BBox(pBBox)
                , DataCreator(pDataCreator)
                {}
        };

protected:

        typedef multimap<double, SpatialFragment> FragmentMap_t;

        FragmentMap_t FragmentMap; 

        override bool apply(const RefPtr<FragmentID>&fid, const RefPtr<CreativeArrayBase>&DataCreator); 

public: 
        int     emitFragments();

        virtual bool    apply(const SpatialFragment&VF) = 0;

        void emit(const RefPtr<Field>&theField)
        {
                if (theField)
                {
                        theField->iterate(*this); 
                        emitFragments();
                }
        }
};


} // namespace Wizt

#endif // __FISHEYE_SortedFragmentIterator_HPP