Lanternfish.hpp

#ifndef __FISH_POND_ANEMONEFISH_Lanternfish_HPP
#define __FISH_POND_ANEMONEFISH_Lanternfish_HPP
 
#include "GridAnemone.hpp"
#include <memcore/shared_mutex.hpp>
#include <forward_list>
 
namespace Wizt
{
 
using namespace Fiber;
using namespace Eagle;
 
struct  SeaBed;
 
struct  anemonefish_API Lanternfish : ReferenceBase<Lanternfish>
{
        struct  Fragment
        {
                const RefPtr<FragmentID>                fID;
                const RefPtr<CreativeArrayBase>         CAB;
                const RefPtr<BoundingBox>               myFragmentBoundingBox;
                SkeletonID                              myCurrentSkeletonID;
                const GridAnemone::AnemoneParameters    myAnemoneParameters;
                bool                                    TerminalFragment;
 
                AnemoneCreatorDependency                myDataCreators;
 
                enum class FragmentRenderStatus
                {
                        allDone, underConstruction, IOerror
                };
 
        mutable size_t  MemUsed = 0, NumberOfVertices = 0;
 
                FragmentRenderStatus
                        render(int id,
                               VRenderContext&theContext,
                               const RefPtr<GridAnemone::AnemoneExplorer>&myAnemoneExplorer,
                               const WeakPtr<GridAnemone>&myGridAnemone,
                               const WeakPtr<Fiber::Chart>&theCurrentChart,
                               size_t   current_fragment, size_t max_fragment_number
                        ) const;
 
 
                bool    haveValidAnemone(RenderBasin&theContext,
                                         const RefPtr<Seagrass>&theSeagrass,
                                         const WeakPtr<GridAnemone>&myGridAnemone,
                                         const WeakPtr<Fiber::Chart>&theCurrentChart) const;
 
                bool    haveDataUnderCreation() const;
                void    request(const Fiber::CreativeArrayBase::result&R) const;
 
                void    cancelCreation() const;
        };
 
mutable std::mutex                      FragmentListMutex;
        std::forward_list<Fragment>     fragments;
 
        RefPtr<Fiber::Grid>             myCurrentGrid;
        RefPtr<Fiber::Chart>            myCurrentChart;
 
        std::set<RefPtr<FragmentID>>    myFragmentIDs;
 
        int                     id = 0;
        double                  CreationTime = 0.0;
        MemCore::Timer          myLifetime;
 
        using   creation_result = std::chrono::duration<double>;
        std::future<creation_result>    SeabedCreation;
 
        std::atomic<bool>       creationComplete{false};
 
        double  getDataLoadTime() const;
 
        bool    isCurrentlyUnderCreation() const
        {
                return  SeabedCreation.valid() &&
                        SeabedCreation.wait_for(std::chrono::seconds(0)) != std::future_status::ready;
        }
 
        bool    hasCreationCompleted() const
        {
                return  creationComplete.load(std::memory_order_acquire);
        }
 
 
        bool    isValid() const
        {
                return  hasCreationCompleted() and NumberOfFragmentsUnderCreation()==0 and allFragmentsAreFine();
        }
 
        void    setCompletion();
 
        Lanternfish(const RefPtr<Fiber::Grid> &theCurrentGrid,
                    const RefPtr<Fiber::Chart>&theCurrentChart);
 
        ~Lanternfish();
 
        Lanternfish(const Lanternfish&) = delete;
 
        void    catchFragment(const Fragment&F);
 
        size_t  NumberOfFragments() const;
 
        struct  RenderFragmentInfo
        {
                size_t  Completed  = 0,
                        Incomplete = 0,
 
                        MemUsed = 0, NumberOfVertices = 0;
 
                RenderFragmentInfo(size_t C, size_t IC, size_t aMemUsed = 0, size_t aNumberOfVertices = 0)
                : Completed(C)
                , Incomplete(IC)
                , MemUsed(aMemUsed)
                , NumberOfVertices( aNumberOfVertices )
                {}
        };
 
        unsigned        NumberOfFragmentsUnderCreation() const;
 
        std::string     description() const;
 
        void            request(const Fiber::CreativeArrayBase::result&R) const;
        void            cancelCreation() const;
 
        bool    allFragmentsAreFine() const;
 
        RenderFragmentInfo
                renderFragments(VRenderContext&theContext,
                                const RefPtr<GridAnemone::AnemoneExplorer>&myAnemoneExplorer,
                                const WeakPtr<GridAnemone>&myGridAnemone,
                                double          RenderTimeFactor,
                                bool            ShowTerminalFragmentsOnly,
                                unsigned        MaxNumberOfRenderFragments);
 
 
        RefPtr<BoundingBox> getBoundingBox(unsigned N) const;
 
        // void updateAnemones(VRenderContext&theContext,
        //                     const WeakPtr<GridAnemone>&myGridAnemone,
        //                     const WeakPtr<Fiber::Chart>&theCurrentChart) const;
 
#if     0
        std::tuple<bool, unsigned>
                isRenderAble(VRenderContext&theContext,
                             const RefPtr<Seagrass>&theSeagrass,
                             const WeakPtr<GridAnemone>&theGridanemone,
                             const WeakPtr<Fiber::Chart>&theChart,
                             unsigned   MaxNumberOfRenderFragments) const;
#endif
 
};
 
struct  LevelDisplayConstraints
{
        unsigned DisplayMinLevel = 0,
                 DisplayMaxLevel = 0;
 
        bool    mayDisplay(const SkeletonID&S) const;
};
 
struct  LanternFestivalParameters : LevelDisplayConstraints
{
        Ageable                         myRegionOfInterestAge;
        PhysicalSpace::Frustum          myFrustum;
        VCamera                         myCamera;
        double                          Threshold = 400.0;
        WeakPtr<Chart>                  myChart;
        WeakPtr<CellTensorFunctor>      myCellTensor;
        RenderFields                    myFields;
 
 
        bool    operator==(const LanternFestivalParameters&) const;
        bool    operator!=(const LanternFestivalParameters&) const;
};
 
 
struct  anemonefish_API LanternFestival
{
        using Parameters = LanternFestivalParameters;
 
        struct  LanternView : Parameters
        {
                RefPtr<Lanternfish>     myLantern;
        };
 
        WeakPtr<Fiber::Grid>            myGrid;
        WeakPtr<Chart>                  myChart;
 
        using   LanternViewSequence = std::list<LanternView>;
 
        // TODO: also consider chart
        std::unordered_map<WeakPtr<Grid>, LanternViewSequence>  myLanternView;
        mutable MemCore::shared_mutex                           myLanternView_mutex;
 
        using   lock_readonly = std::shared_lock<MemCore::shared_mutex>;
        using   lock_writable = std::unique_lock<MemCore::shared_mutex>;
 
static  unsigned        LanternsToRemember;
 
        LanternFestival();
        ~LanternFestival();
 
        RefPtr<Lanternfish>     getExactLantern(const Parameters&LFP) const;
 
        RefPtr<Lanternfish>     getBestLantern(const Parameters&LFP) const;
 
        RefPtr<Lanternfish>
                getMostRecentValidLantern() const;
 
        RefPtr<Lanternfish>
                newLantern(const RefPtr<Grid>&G, const RefPtr<Chart>&chart,
                           const LanternFestival::Parameters&LFP);
 
        void    setLanternGrid(const RefPtr<Grid>&G, const RefPtr<Chart>&chart);
 
        bool    hasSameLanternGrid(const RefPtr<Grid>&G, const RefPtr<Chart>&chart) const
        {
                return  myChart == chart and
                        myGrid == G;
        }
};
 
} // namespace Wizt
 
#endif // __FISH_POND_ANEMONEFISH_Lanternfish_HPP