OBase.h

Go to the documentation of this file.

#pragma once
#include <iostream>
#include "FBase.h"
#include "Object.h"
 
#ifdef VK_BACKEND
#include "VkProgram.h"
#endif // VK_BACKEND
 
 
namespace dyno {
 
    typedef std::string FieldID;
    typedef std::string ProgramID;
 
    class OBase : public Object
    {
    public:
        typedef std::vector<FBase*> FieldVector;
        typedef std::map<FieldID, FBase*> FieldMap;
 
#ifdef VK_BACKEND
        typedef std::map<ProgramID, std::shared_ptr<VkProgram>> ProgramMap;
        typedef std::map<ProgramID, std::shared_ptr<VkMultiProgram>> MultiProgramMap;
#endif // VK_BACKEND
 
        OBase() : Object() {};
        ~OBase() override;

        virtual std::string caption();

        virtual bool captionVisible();

        virtual std::string description();
 
        virtual std::string getName();

        bool addField(FBase* data);
        bool addField(FieldID name, FBase* data);
        bool addFieldAlias(FieldID name, FBase* data);
        bool addFieldAlias(FieldID name, FBase* data, FieldMap& fieldAlias);

        bool findField(FBase* data);
        bool findFieldAlias(const FieldID name);
        bool findFieldAlias(const FieldID name, FieldMap& fieldAlias);

        bool removeField(FBase* data);
        bool removeFieldAlias(const FieldID name);
        bool removeFieldAlias(const FieldID name, FieldMap& fieldAlias);

        FBase* getField(const FieldID name);
 
        std::vector<FBase*>& getAllFields();

        virtual bool attachField(FBase* field, std::string name, std::string desc, bool autoDestroy = true);
 
        template<typename T>
        T* getField(FieldID name)
        {
            FieldMap::iterator iter = m_fieldAlias.find(name);
            if (iter != m_fieldAlias.end())
            {
                return dynamic_cast<T*>(iter->second);
            }
            return nullptr;
        }

        bool isAllFieldsReady();
 
        std::vector<FieldID>    getFieldAlias(FBase* data);
        int             getFieldAliasCount(FBase* data);
 
 
        inline void setBlockCoord(float x, float y) { block_x = x; block_y = y; }
 
        inline float bx() { return block_x; }
        inline float by() { return block_y; }
 
 
        bool findInputField(FBase* field);
        bool addInputField(FBase* field);
        bool removeInputField(FBase* field);
 
        std::vector<FBase*>& getInputFields() { return fields_input; }
 
        bool findOutputField(FBase* field);
        bool addOutputField(FBase* field);
        bool addToOutput(FBase* field);
        bool removeOutputField(FBase* field);
        bool removeFromOutput(FBase* field);
 
        std::vector<FBase*>& getOutputFields() { return fields_output; }
 
        bool findParameter(FBase* field);
        bool addParameter(FBase* field);
        bool removeParameter(FBase* field);
 
        std::vector<FBase*>& getParameters() { return fields_param; }
 
#ifdef VK_BACKEND
        std::shared_ptr<VkProgram> addKernel(ProgramID programId, std::shared_ptr<VkProgram> prog);
 
        std::shared_ptr<VkProgram> kernel(ProgramID programId);
 
        VkMultiProgram& createKernelGroup(ProgramID programId);
 
        VkMultiProgram& kernelGroup(ProgramID programId);
 
    protected:
        ProgramMap Kernels;
        MultiProgramMap MultiKernels;
#endif
 
    private:
        float block_x = 0.0f;
        float block_y = 0.0f;
 
        FieldVector m_field;
        FieldMap m_fieldAlias;
 
    protected:
        std::vector<FBase*> fields_input;
        std::vector<FBase*> fields_output;
        std::vector<FBase*> fields_param;
    };
 
}