GridOperatorObject.hpp

#ifndef __FIBER_POND_BONES_GRIDOPERATOROBJECT_HPP
#define __FIBER_POND_BONES_GRIDOPERATOROBJECT_HPP
 
#include <grid/CartesianChart.hpp>
#include <ocean/shrimp/VChart.hpp>
#include "FishSlice.hpp"
#include "FishGrid.hpp"
#include "GridActor.hpp"
 
#include <fiber/bundle/RepresentationInfo.hpp>
 
namespace Wizt
{
 
 
template <class BaseClass = VObject>
struct  GridOperatorObject : public BaseClass
                           , public Fish<Fiber::Slice>
                           , public Fish<Fiber::Grid>
{
        GridOperatorObject(const string&name, int P, const RefPtr<VCreationPreferences>&VP,
                           const string&InputGridNameSlot = "grid", int InputGridNameSlotEL = 2)
        : BaseClass(name, P, VP)
        , Fish<Fiber::Grid>( InputGridNameSlot, InputGridNameSlotEL )
        {
        }
 
        template <class ...BaseArgs>
        GridOperatorObject(const string&name, int P, const RefPtr<VCreationPreferences>&VP,
                           const string&InputGridNameSlot = "grid", int InputGridNameSlotEL = 2,
                           BaseArgs... baseargs)
        : BaseClass(name, P, VP, baseargs...)
        , Fish<Fiber::Grid>( InputGridNameSlot, InputGridNameSlotEL )
        {
        }
};
 
 
template <class BaseClass = VObject>
struct  ChartDependentGridOperatorObject : public GridOperatorObject<BaseClass>
                                         , public VChartDependent
{
        ChartDependentGridOperatorObject(const string&name, int P, const RefPtr<VCreationPreferences>&VP,
                                         const string&InputGridNameSlot = "grid", int InputGridNameSlotEL = 2)
        : GridOperatorObject<BaseClass>(name, P, VP, InputGridNameSlot, InputGridNameSlotEL)
        {
        }
 
        RefPtr<Fiber::Chart> getChart(const RefPtr<Fiber::Grid>&G, const RefPtr<ValuePool>&Context) const
        {
        VChart  theChart;
                myChart << Context >> theChart;
 
                return G->findChart( typeid(Fiber::CartesianChart3D), theChart.Chartname() );
        }
 
 
virtual bool     updateVertexRepresentation(const Fiber::Info<Fiber::Representation>&iR,
                                            VRequest&Context, double p)
        {
                return true;
        }
 
virtual bool     updateGrid(const Fiber::Bundle::GridInfo_t&iG, const RefPtr<Fiber::Chart>&theCurrentChart, VRequest&Context, double p)
        {
        using namespace Fiber;
                if (RefPtr<Skeleton> Vertices = iG.getGrid()->findVertices())
                        if (RefPtr<Representation> R = (*Vertices)(theCurrentChart))
                        {
                                return updateVertexRepresentation( {{iG, Vertices}, R, theCurrentChart}, Context, p);
                        }
 
                return true;
        }
 
        bool     update(VRequest&Context, double p) override
        {
        using namespace Fiber;
 
        Fiber::Bundle::GridInfo_t
                iG = this->findMostRecentGrid(Context);
 
                if (RefPtr<Grid> G = iG)
                {
                VChart  theChart;
                        myChart << Context >> theChart;
 
                RefPtr<Chart> myCurrentChart = G->findChart( typeid(CartesianChart3D), theChart.Chartname() );
                        if (!myCurrentChart) return true;
 
                        return updateGrid(iG, myCurrentChart, Context, p);
                }
                return true;
        }
};
 
} // namespace
 
#endif // __FIBER_POND_BONES_GRIDOPERATOROBJECT_HPP