RenderFields.hpp

#ifndef __FISH_POND_ANEMONEFISH_RenderFields_HPP
#define __FISH_POND_ANEMONEFISH_RenderFields_HPP
 
#include <pond/bone/FishField.hpp>
#include <ocean/Anemonia/RenderNamespace.hpp>
#include <ocean/Anemonia/Seagrass.hpp>
#include <fiber/field/FragmentIDCollection.hpp>
 
#include <unordered_map>
#include <memcore/shared_mutex.hpp>
 
#include "anemonefishDllApi.h"
 
namespace Wizt
{
 
class   anemonefish_API RenderFields
{
public:
        struct  NamedField
        {
                string                  name;
                WeakPtr<Fiber::Field>   myField;
 
                auto operator<=>(const NamedField&) const = default;
 
                RefPtr<Fiber::Field>    getField() const
                {
#ifdef  HAVE_FADING_OBJECT_REFCOUNT
                        if (myField.isReceivingExtremeUnction())
                                return nullptr;
#endif
                        return myField;
                }
        };
 
 
//      using   NamedField = std::tuple<string, WeakPtr<Fiber::Field> >;
//      using   NamedField = std::tuple<string, RefPtr<Fiber::Field> >;
 
//      using   FieldList_t = std::unordered_map<RenderNamespace::glsl, NamedField >;
        using   RefinementIndex = Fiber::SkeletonID;
 
//      using   RefinedFieldList_t = std::map<RefinementIndex, FieldList_t>;
 
private:
 
        using   RefinedFieldList_t = std::unordered_map<RenderNamespace::glsl, std::map<RefinementIndex, NamedField>>;
 
        RefinedFieldList_t      myCurrentFields;
 
public:
private:
//      using   mutex_t       = std::mutex;
//      mutable mutex_t         FieldMutex;
//      using   lock_t = std::lock_guard<mutex_t>;
 
        mutable MemCore::shared_mutex   FieldMutex;
 
        using   lock_readonly  = std::shared_lock<MemCore::shared_mutex>;
        using   lock_writeable = std::unique_lock<MemCore::shared_mutex>;
 
private:
/*      auto    lock() const
        {
                return std::unique_lock<mutex_t>(FieldMutex);
        }
*/
 
        int     iterate_u(const RefinementIndex&RI,
                          const std::function<bool(const RenderNamespace::glsl&ShaderAttribute,
                                                   const string&Fieldname, const RefPtr<Fiber::Field>&F)>&callback) const;
 
        int     iterate_u(const std::function<bool(const RenderNamespace::glsl&ShaderAttribute,
                                                   const string&Fieldname, const RefPtr<Fiber::Field>&F)>&callback) const;
 
 
public:
        void    resetRenderFields();
 
        RenderFields()
        {}
 
        RenderFields(const RenderFields&RF)
        {
        lock_readonly   lck(RF.FieldMutex);
                myCurrentFields = RF.myCurrentFields;
        }
 
        void    operator=(const RenderFields&RF) = delete;
 
        void    assignRenderFields(const RenderFields&RF)
        {
        lock_readonly   lck(RF.FieldMutex);
        lock_writeable  lck2(FieldMutex);
                myCurrentFields = RF.myCurrentFields;
        }
 
        ~RenderFields();
 
        NamedField      find(const RefinementIndex&Id, const RenderNamespace::glsl&ShaderAttributeName) const;
 
        bool    find(const RefinementIndex&Id) const;
 
 
        void    insert(const NamedField&N, const RefinementIndex&Id, const RenderNamespace::glsl&ShaderAttributeName);
 
        void    insert(const RefinementIndex&Id, const RenderNamespace::glsl&ShaderAttributeName, const NamedField&N)
        {
                insert(N, Id, ShaderAttributeName);
        }
 
        void    erase( const RefinementIndex&Id, const RenderNamespace::glsl&ShaderAttributeName);
 
 
        int     iterate(const RefinementIndex&RI,
                        const std::function<bool(const RenderNamespace::glsl&ShaderAttribute,
                                                 const string&Fieldname, const RefPtr<Fiber::Field>&F)>&callback) const;
 
        int     iterate(const std::function<bool(const RenderNamespace::glsl&ShaderAttribute,
                                                 const string&Fieldname, const RefPtr<Fiber::Field>&F)>&callback) const;
 
 
        bool    checkIfFieldFragmentCreatorsAreNewerThan(const RefinementIndex&RI,
                                                         const RefPtr<AnemoneCreatorBase>&myAnemoneCreator,
                                                         const RefPtr<Fiber::FragmentID>&Fid) const;
 
#if     0
        bool    checkIfFieldFragmentCreatorsAreNewerThan(const RefPtr<AnemoneCreatorBase>&myAnemoneCreator,
                                                         const RefPtr<Fiber::FragmentID>&Fid) const;
#endif
 
        using   result = MemCore::CreatorBase<Fiber::MemBase>::result;
 
        void    request(const RefPtr<Fiber::FragmentID>&myFragmentID, const result&R = nullptr) const;
 
        bool    isUnderCreation(const RefPtr<Fiber::FragmentID>&myFragmentID) const;
 
 
        auto    operator!=(const RenderFields&RF) const
        {
        lock_readonly   lck(FieldMutex);
        lock_readonly   lck2(RF.FieldMutex);
                return  myCurrentFields != RF.myCurrentFields;
        }
 
        auto    operator==(const RenderFields&RF) const
        {
        lock_readonly   lck(FieldMutex);
        lock_readonly   lck2(RF.FieldMutex);
                return  myCurrentFields == RF.myCurrentFields;
        }
 
 
/*
        const FieldList_t&getFieldList() const;
 
        WeakPtr<Fiber::Field> findField(const RefinementIndex&RI, const RenderNamespace::glsl&ShaderAttributeName) const;
 
        WeakPtr<Fiber::Field> operator()(const RefinementIndex&RI, const RenderNamespace::glsl&ShaderAttributeName) const
        {
                return findField( RI, ShaderAttributeName );
        }
*/
};
 
 
} // namespace  Wizt
 
#endif  //  __FISH_POND_ANEMONEFISH_RenderFields_HPP