Graph.h

// Copyright (C) Entropy Software LLC - All Rights Reserved
 
#pragma once
 
#include "Context.h"
#include "GraphNode.h"
#include "Object.h"
#include "Resource.h"
 
namespace SmartEngine
{
 
#pragma pack(push, 4)
struct GraphCInfo : public ResourceCInfo
{
    IContext* context = nullptr;
};
 
struct ComponentInputBinding
{
    const char* componentInputName = nullptr;
 
    IGraphNode* inputNode = nullptr;
};
#pragma pack(pop)
 
class SMARTENGINE_EXPORT IGraph : public IResource
{
public:
    SMARTENGINE_DECLARE_CLASS(IGraph)
 
    
    virtual const char* GetName() const = 0;
 
    virtual ObjectPtr<IContext> GetContext() const = 0;
 
    virtual ObjectPtr<IGraph> DeepCopy() const = 0;
 
    virtual ObjectPtr<IGraph> Instance() = 0;
 
    virtual void BindComponentInputs(const ComponentInputBinding* bindings, int bindingCount) = 0;
 
    virtual void CopyWeightsFrom(IGraph* graph, float percent = 1.0f) = 0;
 
    virtual void SetRandomWeights() = 0;
 
    virtual void AddNode(IGraphNode* node) = 0;
 
    template <typename T> ObjectPtr<T> GetNode(const char* name) const;
 
    virtual ObjectPtr<IGraphNode> GetOutputNode(int index) const = 0;
 
    virtual float GetWeightStandardDeviation() const = 0;
 
    virtual int GetSequenceLength() const = 0;
 
    virtual void SetSequenceLength(int stepCount) = 0;
 
    virtual void ResetNeuronLayers() = 0;
 
    virtual void StepNeuronLayers(bool autoReset = true) = 0;
 
protected:
    virtual ObjectPtr<IGraphNode> GetNodeInternal(const char* name) const = 0;
};
 
SMARTENGINE_EXPORT ObjectPtr<IGraph> CreateEmptyGraph(const GraphCInfo& cinfo);
 
SMARTENGINE_EXPORT ObjectPtr<IGraph> CreateGraphFromDefinition(const GraphCInfo& cinfo, const char* graphDefinition);
 
SMARTENGINE_EXPORT ObjectPtr<IGraph> CreateGraphFromResource(const GraphCInfo& cinfo,
                                                             const char* resourceName = nullptr);
 
extern "C"
{
    SMARTENGINE_EXPORT ObjPtr Graph_CreateEmpty(const GraphCInfo& cinfo);
    SMARTENGINE_EXPORT ObjPtr Graph_CreateFromDefinition(const GraphCInfo& cinfo, const char* graphDefinition);
    SMARTENGINE_EXPORT ObjPtr Graph_CreateFromResource(const GraphCInfo& cinfo, const char* resourceName);
    SMARTENGINE_EXPORT const char* Graph_GetName(ObjPtr object);
    SMARTENGINE_EXPORT ObjPtr Graph_GetContext(ObjPtr object);
    SMARTENGINE_EXPORT ObjPtr Graph_DeepCopy(ObjPtr object);
    SMARTENGINE_EXPORT ObjPtr Graph_Instance(ObjPtr object);
    SMARTENGINE_EXPORT void Graph_BindComponentInputs(ObjPtr object, const ComponentInputBinding* bindings, int bindingCount);
    SMARTENGINE_EXPORT void Graph_CopyWeightsFrom(ObjPtr object, ObjPtr graph, float percent);
    SMARTENGINE_EXPORT void Graph_SetRandomWeights(ObjPtr object);
    SMARTENGINE_EXPORT ObjPtr Graph_GetNode(ObjPtr object, const char* name, const char* type);
    SMARTENGINE_EXPORT ObjPtr Graph_GetOutputNode(ObjPtr object, int index);
    SMARTENGINE_EXPORT float Graph_GetWeightStandardDeviation(ObjPtr object);
    SMARTENGINE_EXPORT void Graph_AddNode(ObjPtr object, ObjPtr node);
    SMARTENGINE_EXPORT int Graph_GetSequenceLength(ObjPtr object);
    SMARTENGINE_EXPORT void Graph_SetSequenceLength(ObjPtr object, int stepCount);
    SMARTENGINE_EXPORT void Graph_ResetNeuronLayers(ObjPtr object);
    SMARTENGINE_EXPORT void Graph_StepNeuronLayers(ObjPtr object, int autoReset);
}
 
template <typename T> ObjectPtr<T> IGraph::GetNode(const char* name) const
{
    return DynamicCast<T>(GetNodeInternal(name));
}
 
} // namespace SmartEngine