SeaBed.hpp

#ifndef __FISH_POND_ANEMONEFISH_Seabed_HPP
#define __FISH_POND_ANEMONEFISH_Seabed_HPP
 
#include "GridAnemone.hpp"
#include <field/Field.hpp>
#include "Lanternfish.hpp"
 
 
namespace Wizt
{
 
using namespace Fiber;
using namespace Eagle;
 
struct  ContextEssence : LanternFestival::Parameters
{
        RefPtr<ValuePool>       myContext;
        RefPtr<Seagrass>        mySeagrass;
        bool                    AsyncLoading;
 
        ContextEssence( const LanternFestival::Parameters&LFP,
                        VRenderContext&Context)
        : LanternFestival::Parameters( LFP )
        , myContext ( Context )
        , mySeagrass( Context.getSeagrassPtr() )
        , AsyncLoading(Context.EnableAsynchronLoading )
        {}
};
 
/*
  The SeaBed iterates over the given field
  and takes care of getting an appropriate Anemone
  that is to be used for rendering.
 */
struct  SeaBed : ContextEssence, Timer
{
        /* TODO: consider using strong pointer here but
           check that this does not lead to recursion,
           only can work if SeaBed is a temporary object.
         */
        using   pGridAnemone_t = WeakPtr<GridAnemone>;
        pGridAnemone_t                  myGridAnemone;
 
using   SkeletonSet = map<SkeletonID, WeakPtr<Fiber::Skeleton>>;
        SkeletonSet             myVertexSkeletons;
 
        RefPtr<Fiber::Chart> myCurrentChart() const;
        RefPtr<Fiber::Grid>  myCurrentGrid() const;
 
        // from GridAnemone::inRenderTimeLimit (currently unused)
        double                  RenderTimeFactor = 0.5;
 
        int     MinNumberOfElementsPerFragments = 0,
                MaxNumberOfElementsPerFragments = 0;
 
//      TouchIndex_t&StartIndex;
 
static  double  invApparentCellSize2(metric33&theCellTensor,
                                     CreativeArrayBase&FragmentData,
                                     const RefPtr<BoundingBox>&BBox,
                                     const VCamera&CurrentCameraSettings,
                                     const CellTensorFunctor&myCellTensorFunctor,
                                     const SkeletonID&SId,
                                     const WeakPtr<Fiber::Grid> & myCurrentGrid,
                                     const WeakPtr<Fiber::Chart>& myCurrentChart,
                                     const RefPtr<Fiber::Field>&ContainingField) ;
 
        double  invApparentCellSize2(metric33&theCellTensor,
                                     CreativeArrayBase&FragmentData,
                                     const RefPtr<BoundingBox>&BBox,
                                     const CellTensorFunctor&myCellTensorFunctor,
                                     const SkeletonID&SId,
                                     const RefPtr<Fiber::Field>&ContainingField) const ;
 
        bool    prepareFragment(const Lanternfish::Fragment&LF);
 
        bool    prepareFragment(const SkeletonID&theSkeletonID,
                                const RefPtr<FragmentID>&theFragmentID,
                                CreativeArrayBase&theFragmentData,
                                const RefPtr<BoundingBox>&BBox,
                                const CellTensorFunctor&theCellTensorFunctor,
                                const RefPtr<Field>&theCurrentField,
                                bool    TerminalFragment
                );
 
        bool    prepareNonTerminalFragment(
                const RefPtr<FragmentID>&theConnectivityFragmentID,
                const RefPtr<CreativeArrayBase>&theConnectivityFragmentCreator,
                const RefPtr<BoundingBox>&theConnectivityFragmentBBox,
                const SkeletonID&CurrentVertexSkeletonID);
 
        bool    prepareTerminalFragment(
                const RefPtr<FragmentID>&theConnectivityFragmentID,
                const RefPtr<CreativeArrayBase>&theConnectivityFragmentCreator,
                const RefPtr<BoundingBox>&theConnectivityFragmentBBox,
                const SkeletonID&CurrentVertexSkeletonID);
 
mutable bool    timeout     = false;
 
        bool    considerFragment(const Lanternfish::Fragment&LF) const;
 
        // reference is fine because this is just an iterator.
        // but need to ensure its called with an alive field hierarchy
        const GridAnemone::FieldHierarchy&myRenderFields;
 
        RefPtr<Lanternfish>     myLanternfish;
 
        AnemoneRenderFields             myRenderFieldDependencies;
 
        string  ErrorMessage;
 
        /*
           Pre-check whether a sufficient number of fragments is renderable.
 
           @param InvalidAnemones On return specifies how many invalid Anemone s have
                                  been found, i.e., data that is complete but not uploaded
                                  to the GPU yet.
         */
//      bool    isRenderAble(int &InvalidAnemones, unsigned     MaxNumberOfRenderFragments) const;
 
        SeaBed (const GridAnemone::FieldHierarchy&theRenderFields,
                const RefPtr<Lanternfish>&theLanternfish,
                const SkeletonSet&theVertexSkeletons,
                const WeakPtr<GridAnemone>&theGridAnemone,
                const ContextEssence&E,
                const RenderFields&theRenderFieldDependencies);
 
        ~SeaBed();
 
        bool    isVisible(const RefPtr<BoundingBox>&BBox) const;
 
        bool    createAnemoneDependency(const AnemoneRenderFields::RefinementIndex&RI, const RefPtr<Fiber::FragmentID>&theFragmentID, AnemoneCreatorDependency&ACD) const;
};
 
} // namespace Wizt
 
#endif  // __FISH_POND_ANEMONEFISH_Seabed_HPP