CellTensorFunctor.hpp

#ifndef __FISH_POND_ANEMONEFISH_CellTensorFunctor_HPP
#define __FISH_POND_ANEMONEFISH_CellTensorFunctor_HPP
 
#include <memcore/RefPtr.hpp>
#include <eagle/PhysicalSpace.hpp>
#include <fiber/field/Field.hpp>
#include <fiber/grid/SkeletonID.hpp>
#include <fiber/grid/Grid.hpp>
#include <aerie/BoundingBox.hpp>
#include <plankton/VValue.hpp>
#include <plankton/ValuePool.hpp>
 
#include "anemonefishDllApi.h"
 
namespace Wizt
{
 
class    anemonefish_API CellTensorFunctor : public MemCore::ReferenceBase<CellTensorFunctor>
{
public:
        CellTensorFunctor();
        ~CellTensorFunctor();
 
        using metric33 = Eagle::metric33;
 
        virtual bool computeCellTensor(metric33&theCellTensor,
                                       Fiber::CreativeArrayBase&FragmentData,
                                       const Fiber::SkeletonID&SId,
                                       const RefPtr<Eagle::BoundingBox>&BBox,
                                       const WeakPtr<Fiber::Grid> & myCurrentGrid,
                                       const WeakPtr<Fiber::Chart>& myCurrentChart,
                                       const RefPtr<Fiber::Field>&ContainingField
                                        ) const = 0;
 
        virtual CellTensorFunctor*copy() const = 0;
 
        bool    getCellTensor(metric33&theCellTensor,
                              Fiber::CreativeArrayBase&FragmentData,
                              const Fiber::SkeletonID&SId,
                              const RefPtr<Eagle::BoundingBox>&BBox,
                              const WeakPtr<Fiber::Grid> & myCurrentGrid,
                              const WeakPtr<Fiber::Chart>& myCurrentChart,
                              const RefPtr<Fiber::Field>&ContainingField
                ) const;
 
}; // end CellTensorFunctor class
 
class    anemonefish_API IncapableCellTensorFunctor : public CellTensorFunctor
{
public:
        ~IncapableCellTensorFunctor();
 
        bool    computeCellTensor(metric33&theCellTensor,
                                  Fiber::CreativeArrayBase&FragmentData,
                                  const Fiber::SkeletonID&SId,
                                  const RefPtr<Eagle::BoundingBox>&BBox,
                                  const WeakPtr<Fiber::Grid> & myCurrentGrid,
                                  const WeakPtr<Fiber::Chart>& myCurrentChart,
                                  const RefPtr<Fiber::Field>&ContainingField
                                ) const override;
 
        CellTensorFunctor*copy() const override;
};
 
template <>
struct  anemonefish_API VValueTrait<RefPtr<CellTensorFunctor>>
{
static  bool setValueFromText(RefPtr<CellTensorFunctor>&V, const string&s);
static  string Text(const RefPtr<CellTensorFunctor>&);
 
};
 
 
template <>
        struct  VValueCopyTrait<RefPtr<CellTensorFunctor> >
{
static  RefPtr<CellTensorFunctor> copy(const RefPtr<CellTensorFunctor>&Source)
        {
                if (!Source)
                        return NullPtr();
 
                return RefPtr<CellTensorFunctor>( Source->copy() );
        }
};
 
 
 
} // namespace
 
#endif // __FISH_POND_ANEMONEFISH_CellTensorFunctor_HPP