GridAnemone.hpp

#ifndef __FISH_POND_ANEMONEFISH_GridAnemone_HPP
#define __FISH_POND_ANEMONEFISH_GridAnemone_HPP
 
#include <spine/SkeletonOperator.hpp>
#include <ocean/Anemonia/VRenderObject.hpp>
#include <ocean/Anemonia/Seagrass.hpp>
#include <ocean/shrimp/Options.hpp>
#include <ocean/shrimp/PhysicalSpace.hpp>
 
#include <memcore/Timer.hpp>
#include <bone/FishSlice.hpp>
 
#include "CellTensorFunctor.hpp"
#include "ShaderFields.hpp"
#include "AnemoneRenderFields.hpp"
 
#include "RegionOfInterest.hpp"
 
#include "AnemoneCreationContext.hpp"
 
#include "anemonefishDllApi.h"
 
namespace Wizt
{
 
struct  Lanternfish;
struct  LanternFestivalParameters;
struct  SeaBed; // internal class
 
using   AnemoneCreatorDependency = AnemoneRenderFields::AnemoneCreatorDependency;
 
class    anemonefish_API GridAnemoneState;
using RefPtrGridAnemoneState = RefPtr<GridAnemoneState,VObject::State>;
 
 
#if 0
class    anemonefish_API GridAnemone;
struct  anemonefish_API GridAnemone::AnemoneCreationContext;
 
#endif
 
class    anemonefish_API GridAnemone : public virtual Fish<double>
                                     , public GridAnemoneRenderObject
{
 
        bool    renderCachedFragments(VRenderContext&Context,
                                      bool      ShowTerminalOnly) const;
 
        bool    renderLanternfish(VRenderContext&Context,
                                  Lanternfish&theLanternfish,
                                  bool  ShowTerminalOnly) const;
 
//      bool    renderSeabedResult(VRenderContext&Context, const RefPtrGridAnemoneState&GAS) const;
 
 
        in<pRegionOfInterest>   inRegionOfInterest;
        in<bool>                inUseRegionOfInterest;
 
public:
        using   AnemoneParameters       = ::Wizt::AnemoneParameters;
        using   AnemoneCreationContext  = ::Wizt::GridAnemoneCreationContext;
        using   GridAnemoneState        = ::Wizt::GridAnemoneState;
 
        inout<double>   inLevelThreshold;
 
        in<double>      inRenderTimeFactor;
 
        inout<RefPtr<CellTensorFunctor>> inCellTensorFunctor;
 
        in<bool>        inFreeze, inShowTerminalOnly;
 
        inout<int>      inMinLevel, inNumberOfLevels;
 
        inout<int>      inMaxNumberOfRenderFragments,
                        inMinNumberOfElementsPerFragments,
                        inMaxNumberOfElementsPerFragments;
 
        out<VBoundingBox> outVisibleBBox;
        out<Fiber::Grid>  outVisibleGrid;
 
virtual GridSelector getGridFieldSelector(const RefPtr<ValuePool>&Context) const = 0;
 
        Ageable AgeOfRoI(const RefPtr<ValuePool>&Context) const;
 
        pRegionOfInterest
                getRegionOfInterest(const RefPtr<ValuePool>&Context) const;
 
        RefPtr<Fiber::Chart> getCartesianChart(const RefPtr<Fiber::Grid>&G, const RefPtr<ValuePool>&Context) const;
 
        using   SkeletonID = Fiber::SkeletonID;
 
        struct  FieldInfo
        {
                SkeletonID                      myID;
                RefPtr<Fiber::Representation>   myRepresentation;
                RefPtr<Fiber::Field>            myPositions;
 
                FieldInfo()
                : myID( nullptr )
                {}
 
                FieldInfo(const SkeletonID                    &theID,
                          const RefPtr<Fiber::Representation> &theRepresentation,
                          const RefPtr<Fiber::Field>          &thePositions
                        )
                : myID( theID )
                , myRepresentation( theRepresentation )
                , myPositions( thePositions )
                {}
        };
 
        using   FieldHierarchy = map<SkeletonID, FieldInfo>;
 
        using   SkeletonSet = map<SkeletonID, WeakPtr<Fiber::Skeleton>>;
 
        RefPtr<State> newState() const override;
 
        GridAnemone(const string&name, int RenderCategory, const RefPtr<VCreationPreferences>&VP);
 
        ~GridAnemone();
 
        RenderTime      getLastRenderTime(VRenderContext&Context) const override;
 
 
        virtual FieldHierarchy getRenderFields(VRenderContext&Context) const;
 
 
        struct  anemonefish_API CoordinateShift : Interface<CoordinateShift>
        {
                Eagle::tvector3 ShiftToCenter;
 
                CoordinateShift(const Eagle::tvector3&ShiftToCenter);
                ~CoordinateShift();
        };
 
 
        struct  anemonefish_API AnemoneExplorer : ReferenceBase<AnemoneExplorer>
        {
                Timer                           Duration;
                WeakPtr<GridAnemone>            myExplorersGridAnemone;
                RefPtrGridAnemoneState          myGridAnemoneState;
                pRegionOfInterest               myRegionOfInterest;
 
                /*
                  Statistics: Time for creating coordinates such as loading from disk.
                  Such time is likely to be a one-time effort that may no longer occur
                  on next call.
                 */
                double  CoordinateCreationTime = 0.0;
 
                AnemoneExplorer(const WeakPtr<GridAnemone>&theGridAnemone,
                                const RefPtrGridAnemoneState&theGridAnemoneState,
                                const pRegionOfInterest&theRegionOfInterest);
 
                ~AnemoneExplorer();
 
                RefPtr<Fiber::Chart>    getCurrentChart() const;
 
                RefPtr<Fiber::Grid>     getCurrentGrid() const;
 
                RefPtr<Fiber::Representation>   getChartRepresentation(const SkeletonID&SID) const;
                RefPtr<Fiber::Skeleton>         getSkeleton(const SkeletonID&SID) const;
 
                RenderNamespace::glsl   setupRegionOfInterest(VRenderContext&Context, const FloatingAnemone&);
        };
 
        virtual RefPtr<AnemoneExplorer> getAnemoneExplorer(VRenderContext&Context) const;
 
 
        virtual RefPtr<AnemoneCreatorBase> newAnemoneCreator(const Seagrass&theSeaggrass) const;
 
 
static  RefPtr<RenderBasin::VertexAttribute>
        createVertexCoordinates(VRenderContext&Context, const RefPtr<Fiber::MemBase>&Coordinates,
                                bool AllowProceduralCoordinates);
 
        using AnemoneRenderStatus = AnemoneRenderFields::AnemoneRenderStatus;
 
static const char*getAnemoneRenderStatusDescription(AnemoneRenderStatus);
 
        AnemoneRenderStatus renderAnemone    (Anemone&RenderAnemone, const AnemoneCreationContext&ARC, const RefPtr<AnemoneExplorer>&AE,
                                              size_t  current_fragment, size_t max_fragment_number, const RefPtr<BoundingBox>&theFragmentBoundingBox) const;
 
 
        using initializeAnemoneParameters =
                std::tuple<Anemone&, const AnemoneCreationContext&, const RefPtr<AnemoneExplorer>&, AnemoneCreatorDependency&>;
 
        AnemoneRenderStatus raiseAnemone(Anemone&RenderAnemone,
                                         const AnemoneCreationContext&ARC,
                                         const RefPtr<AnemoneExplorer>&AE) const;
 
 
        virtual AnemoneRenderStatus initializeAnemone(Anemone&RenderAnemone,
                                                      const AnemoneCreationContext&ARC,
                                                      const RefPtr<AnemoneExplorer>&AE) const = 0;
 
        virtual bool    isValidAnemone   (const Anemone&RenderAnemone, const AnemoneCreationContext&ARC, const RefPtr<AnemoneExplorer>&AE) const;
 
 
        virtual bool    disabledFragment(VRenderContext&theContext, const AnemoneExplorer&theAnemoneExplorer,
                                         const Fiber::CreativeArrayBase&CAB, const RefPtr<Fiber::FragmentID> &fID,
                                         const RefPtr<BoundingBox>&theFragmentBoundingBox,
                                         const RefPtr<Fiber::Representation>&R) const;
 
        virtual bool    updateAnemone(Anemone&RenderAnemone, const AnemoneCreationContext&ARC, const RefPtr<AnemoneExplorer>&AE) const;
 
        RefPtr<BoundingBall> getTouchableBoundingBall(const RefPtr<ValuePool>&VP) const override;
 
 
static  void    destroyAnemone(RefPtr<Anemone>&Anemone, const AnemoneCreationContext&ARC);
 
        virtual bool  validateInput(VRequest&Context, Fiber::Info<Fiber::Grid>&,
                                    const RefPtrGridAnemoneState&GAS,
                                    const RefPtr<Fiber::Skeleton>&myVertexSkeleton,
                                    const RefPtr<Fiber::Chart>&chart,
                                    string&ValidateInputInfoString) const;
 
        virtual bool    addSupplementaryData(VRequest&Context, Fiber::Info<Fiber::Grid>&,
                                             RenderFields&RF,
                                             const RefPtr<Fiber::Skeleton>&myVertexSkeleton,
                                             const RefPtr<Fiber::Chart>&chart,
                                             string&InfoString);
 
 
        virtual void requestSupplementaryData(VRenderContext&theContext,
                                              const RefPtr<Fiber::FragmentID>&myFragmentID) const;
 
        virtual bool isCreatingSupplementaryData(VRenderContext&theContext,
                                                 const RefPtr<Fiber::FragmentID>&myFragmentID) const;
 
        bool    update(VRequest&R, double precision) override;
 
#if     0
        struct  FragmentSorter : ReferenceBase<FragmentSorter>
        {
                FragmentSorter();
 
                virtual ~FragmentSorter();
 
                virtual double getSortCriteria(const SkeletonID&, const RefPtr<Fiber::FragmentID>&fID) const = 0;
        };
#endif
 
        enum class SortMethod
        {
                None,
                BackToFront,
                FrontToBack,
                MostVisible
        };
 
        SortMethod CurrentSortMethod = SortMethod::None;
 
private:
        bool    renderSeaBed(SeaBed&SB,VRenderContext&Context) const;
 
        std::pair<bool, bool>   renderGrid(const RefPtr<Fiber::Grid>&G,
                                           VRenderContext&Context,
                                           const LanternFestivalParameters&LFP) const;
 
public:
//      virtual RefPtr<FragmentSorter> getFragmentSorter(VRenderContext&Context) const;
 
 
 
        bool    environment_render(VRenderContext&Context) const override;
 
        TouchIndex_t    do_feedback_render(VRenderContext&Context, TouchIndex_t StartIndex) const;
 
        virtual TouchIndex_t getTouchIndexFragmentIndexMultiplicator(VRenderContext&Context, const Fiber::Field&) const;
 
}; // end GridAnemone class
 
inline  std::tuple<Anemone&, VRenderContext&> operator<<(Anemone&A, const GridAnemoneCreationContext&ACC)
{
        return std::tuple<Anemone&, VRenderContext&>(A, ACC.myContext);
}
 
}  // namespace Wizt
 
#endif // __FISH_POND_ANEMONEFISH_GridAnemone_HPP