SortedFragmentIterator.hpp

#ifndef __FISHEYE_SortedFragmentIterator_HPP
#define __FISHEYE_SortedFragmentIterator_HPP
 
#include "fisheyeDllApi.h"
#include <field/Field.hpp>
#include <grid/Representation.hpp>
#include <GL/fiberGL.hpp>
#include <ocean/shrimp/VCamera.hpp>
#include <aerie/BoundingBox.hpp>
 
namespace Wizt
{
 
using namespace Fiber;
using namespace Eagle;
 
 
struct  fisheye_API SortedFragmentIterator : public FieldFragmentIterator
{
        const VCamera   &myCamera; 
        RefPtr<Representation>  myRepresentation; 
 
        RefPtr<Field>   Coords() const
        {
                return myRepresentation->getPositions(); 
        }
 
        SortedFragmentIterator(const VCamera&Cam, 
                               const RefPtr<Representation>&theRepresentation)
        : myCamera(Cam)
        , myRepresentation(theRepresentation)
        {} 
 
        ~SortedFragmentIterator();
 
        struct  SpatialFragment
        {
                RefPtr<Representation>    myRepresentation;
                const RefPtr<FragmentID>  ID;
                RefPtr<BoundingBox>       BBox;
                RefPtr<CreativeArrayBase> DataCreator;
 
                SpatialFragment(const RefPtr<Representation>&theRepresentation,
                                const RefPtr<FragmentID>&fid,
                                const RefPtr<BoundingBox>&pBBox,
                                const RefPtr<CreativeArrayBase>&pDataCreator)
                : myRepresentation( theRepresentation )
                , ID(fid)
                , BBox(pBBox)
                , DataCreator(pDataCreator)
                {}
        };
 
protected:
 
        typedef multimap<double, SpatialFragment> FragmentMap_t;
 
        FragmentMap_t FragmentMap; 
 
        bool apply(const RefPtr<FragmentID>&fid, const RefPtr<CreativeArrayBase>&DataCreator) override; 
 
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