FieldAnemone.hpp

#ifndef __FISH_POND_ANEMONEFISH_FieldAnemone_HPP
#define __FISH_POND_ANEMONEFISH_FieldAnemone_HPP
 
#include <fish/pond/spine/SkeletonOperator.hpp>
#include <ocean/Anemonia/VRenderObject.hpp>
#include <ocean/Anemonia/Seagrass.hpp>
 
#include <fish/pond/bone/FishSlice.hpp>
#include <fish/pond/bone/FishField.hpp>
#include <fish/fiber/baseop/GridField.hpp>
 
#include "GridAnemone.hpp"
#include "GridAnemoneState.hpp"
#include "FieldAnemoneBase.hpp"
#include "ShaderFields.hpp"
 
namespace Wizt
{
 
class    anemonefish_API FieldAnemone : public FieldAnemoneBase, public ShaderFields
{
public:
        std::unordered_map<int, std::string>    TextureUnitNames;
 
        int     getTextureUnit(const string&Name) const;
 
        void    setNamedTextures(const Anemone&, const RefPtr<RenderBasin::Program>&) const;
 
        using FieldAnemoneState = GridAnemoneState;
 
        FieldAnemone(const string&name, int RenderCategory, const RefPtr<VCreationPreferences>&VP);
 
        ~FieldAnemone();
 
 
        virtual string  getShaderAttributeName( const TypedSlot<Fiber::Field>&MyField ) const;
 
        virtual glsl    getShaderPrefix(const FieldAnemone::AnemoneCreationContext&ARC,
                                        const FieldAnemone::AnemoneExplorer&AE) const;
 
        bool    validateInput(VRequest&R, Fiber::Info<Fiber::Grid>&,
                              const RefPtr<GridAnemoneState>&GAS,
                              const RefPtr<Fiber::Skeleton>&myVertexSkeleton,
                              const RefPtr<Fiber::Chart>&chart,
                              string&ValidateInputInfoString) const override;
 
        /*
          Validating fields during update(), possibly compute them.
 
          This function will inspect input type slots of the derived object,
          retrieve a field from it, and compare it with the field that is
          currently stored in the FieldAnemoneState.
 
          The function is called from update().
 
          If any field has changed, the function will return false.
 
 
          The default implementation will work off all slots registered
          in the ShaderFields member variable.
         */
        virtual bool    validateFields(VRequest&Context, Fiber::Info<Fiber::Grid>&iG,
                                       FieldAnemoneState&FAS,
                                       const RefPtr<Fiber::Skeleton>&myVertexSkeleton,
                                       const RefPtr<Fiber::Chart>&chart,
                                       string&ValidateInputInfoString) const;
 
        bool    addSupplementaryData(VRequest&Context, Fiber::Info<Fiber::Grid>&,
                                     RenderFields&RF,
                                     const RefPtr<Fiber::Skeleton>&myVertexSkeleton,
                                     const RefPtr<Fiber::Chart>&chart,
                                     string&InfoString) override;
 
 
 
        void    requestSupplementaryData(VRenderContext&theContext,
                                         const RefPtr<Fiber::FragmentID>&myFragmentID) const override;
 
        bool    isCreatingSupplementaryData(VRenderContext&theContext,
                                            const RefPtr<Fiber::FragmentID>&myFragmentID) const override;
 
 
        /*
          Add fields to the field list during update(), which means
          registering the fields for usage in the shader.
 
          The field may be computed, but probably already has been
          computed by the validateFields() call which comes first.
          However, computation in validateFields() might return
          before checking all fields, whereas in addFields() we now
          know that all fields are needed.
 
          The default implementation will work off all slots registered
          in the ShaderFields member variable.
         */
        virtual bool    addFields(VRequest&, Fiber::Info<Fiber::Grid>&,
                                  RenderFields&RF,
                                  const RefPtr<Fiber::Skeleton>&,
                                  const RefPtr<Fiber::Chart>&,
                                  string&);
 
        bool    requireNewFieldComputation(const RefPtr<Fiber::Field>&Output,
                                           const RefPtr<ValuePool>&Context,
                                           const RefPtr<Fiber::Field>&Input) const;
 
        virtual MemCore::RefPtr<RenderBasin::Painter>
                createPainter(Anemone&RenderAnemone,
                              const AnemoneCreationContext&ARC,
                              const RefPtr<AnemoneExplorer>&,
                              const RefPtr<RenderBasin::VertexAttribute>&Vertices) const;
 
 
        GridAnemone::AnemoneRenderStatus
                initializeAnemone(Anemone&RenderAnemone, const AnemoneCreationContext&ARC,
                                  const RefPtr<AnemoneExplorer>&) const override;
 
 
        bool    isValidAnemone(const Anemone&RenderAnemone,
                               const AnemoneCreationContext&ARC,
                               const RefPtr<AnemoneExplorer>&) const override;
 
 
        virtual bool validateAnemoneData(VRenderContext&theContext,
                                         map<string, RefPtr<MemBase>>&AnemoneData,
                                         const RefPtr<Fiber::FragmentID>&theFragmentID,
                                         const Fiber::SkeletonID&theSkeletonID) const;
 
 
}; // end FieldAnemone  class
 
 
template <class FieldType>
class   TypedFieldAnemone : public FieldAnemone
{
public:
        typedef FieldType       InputTypes;
 
        TypedFieldAnemone(const string&name, int RenderCategory, const RefPtr<VCreationPreferences>&VP)
        : FieldAnemone(name, RenderCategory, VP )
        {
                acceptType<FieldType>();
        }
};
 
typedef TypedFieldAnemone<double> DoubleFieldAnemone;
typedef TypedFieldAnemone<float>  FloatFieldAnemone;
 
// note: doesnt include long double
typedef TypedFieldAnemone<LIST<double, float> > FloatScalarFieldAnemone;
 
typedef TypedFieldAnemone<META::IntegerTypeList>        IntegerScalarFieldAnemone;
 
typedef TypedFieldAnemone<META::NativeTypeList>         GenericScalarFieldAnemone;
 
}  // namespace Wizt
 
#endif // __FISH_POND_ANEMONEFISH_GridAnemone_HPP