GraphModel.h

// Copyright (C) Entropy Software LLC - All Rights Reserved
 
#pragma once
 
#include "Agent.h"
#include "Context.h"
#include "Graph.h"
#include "Hash.h"
#include "Matrix.h"
#include "Object.h"
 
namespace SmartEngine
{
 
const float cUpdateEveryFrameRate = 0.0f;
 
const float cUpdateManuallyRate = -1.0f;
 
const float cDefaultUpdateRate = -2.0f;
 
#pragma pack(push, 4)
struct GraphControllerCInfo
{
};
 
struct GraphManagerCInfo
{
    IContext* context = nullptr;
};
 
struct StandardGraphModelCInfo
{
    IGraph* graph = nullptr;
};
 
typedef void (SMARTENGINE_CALLBACK *GraphModel_ClearData_Ptr)(void* userData);
typedef void (SMARTENGINE_CALLBACK *GraphModel_AddData_Ptr)(void* userData, const char* nodeName, ObjPtr data);
typedef void (SMARTENGINE_CALLBACK *GraphModel_RequestOutput_Ptr)(void* userData, int controllerId, const char* nodeName,
                                             int64 expectedRowCount);
typedef void (SMARTENGINE_CALLBACK *GraphModel_Execute_Ptr)(void* userData);
typedef void (SMARTENGINE_CALLBACK *GraphModel_RetrieveOutput_Ptr)(void* userData, int controllerId, ObjPtr modelOut);
typedef void (SMARTENGINE_CALLBACK *GraphModel_Reset_Ptr)(void* userData);
 
struct UserGraphModelCInfo
{
    void* userData = nullptr;
    GraphModel_ClearData_Ptr clearData = nullptr;
    GraphModel_AddData_Ptr addData = nullptr;
    GraphModel_RequestOutput_Ptr requestOutput = nullptr;
    GraphModel_Execute_Ptr execute = nullptr;
    GraphModel_RetrieveOutput_Ptr retrieveOutput = nullptr;
    GraphModel_Reset_Ptr reset = nullptr;
};
#pragma pack(pop)
 
class SMARTENGINE_EXPORT IGraphInputOutput : public virtual IObject
{
public:
    SMARTENGINE_DECLARE_CLASS(IGraphInputOutput)
 
    
    virtual ObjectPtr<IGraphInputOutput> GetGraphComponent(const char* componentNodeName) = 0;
 
    virtual ObjectPtr<IMatrix> GetInput(const char* nodeName) = 0;
 
    virtual void RequestOutput(const char* nodeName, MatrixIndex expectedRowCount = -1) = 0;
 
    virtual ObjectPtr<IMatrix> GetOutput(const char* nodeName) = 0;
};
 
class SMARTENGINE_EXPORT IGraphController : public IGraphInputOutput
{
public:
    SMARTENGINE_DECLARE_CLASS(IGraphController)
 
    
    virtual bool HaveNewOutputData() = 0;
};
 
class SMARTENGINE_EXPORT IGraphModelOutput : public virtual IObject
{
public:
    SMARTENGINE_DECLARE_CLASS(IGraphModelOutput)
 
    
    virtual ObjectPtr<IMatrix> GetOutputRW(const char* nodeName) = 0;
 
    virtual ObjectPtr<IMatrix> GetOutputRW(HashKey nameHash) = 0;
};
 
class SMARTENGINE_EXPORT IGraphModel : public virtual IObject
{
public:
    SMARTENGINE_DECLARE_CLASS(IGraphModel)
 
    
    virtual void ClearData() = 0;
 
    virtual void AddData(const char* nodeName, IMatrix* data) = 0;
 
    virtual void RequestOutput(int controllerId, const char* nodeName, MatrixIndex expectedRowCount) = 0;
 
    virtual void Execute() = 0;
 
    virtual void RetrieveOutput(int controllerId, IGraphModelOutput* modelOut) = 0;
 
    virtual void Reset() = 0;
};
 
class SMARTENGINE_EXPORT IStandardGraphModel : public IGraphModel
{
public:
    SMARTENGINE_DECLARE_CLASS(IStandardGraphModel)
 
    
    virtual ObjectPtr<IGraph> GetGraph() const = 0;
 
    virtual MatrixIndex GetExpectedRowCount(int controllerId, const char* outputName) const = 0;
};
 
class SMARTENGINE_EXPORT IGraphManager : public virtual IObject
{
public:
    SMARTENGINE_DECLARE_CLASS(IGraphManager)
 
    
    virtual void RegisterController(IGraphController* controller, const char* modelName,
                                    float updateRate = cDefaultUpdateRate) = 0;
 
    virtual void UnregisterController(IGraphController* controller) = 0;
 
    virtual bool IsControllerRegistered(IGraphController* controller) const = 0;
 
    virtual void RegisterAgent(IAgent* agent, IGraphController* controller) = 0;
 
    virtual void UnregisterAgent(IAgent* agent) = 0;
 
    virtual void RegisterModel(IGraphModel* model, const char* modelName, float updateRate = cUpdateEveryFrameRate) = 0;
 
    virtual void RegisterModelFromGraph(IGraph* graph, const char* modelName,
                                        float updateRate = cUpdateEveryFrameRate) = 0;
 
    virtual void RegisterModelFromGraphResource(const char* resourceName, const char* modelName,
                                                float updateRate = cUpdateEveryFrameRate) = 0;
 
    virtual void UnregisterModel(const char* modelName) = 0;
 
    virtual void Update(float deltaTime) = 0;
 
    virtual void UpdateController(IGraphController* controller) = 0;
 
    virtual void BeginStreaming(IGraphController* controller) = 0;
 
    virtual void PushStreamData(IGraphController* controller) = 0;
 
    virtual MatrixIndex GetStreamingInputRowCount(IGraphController* controller) const = 0;
 
    virtual void EndStreaming(IGraphController* controller) = 0;
 
    virtual void Reset() = 0;
};
 
SMARTENGINE_EXPORT ObjectPtr<IGraphController> CreateGraphController(const GraphControllerCInfo& cinfo);
 
SMARTENGINE_EXPORT ObjectPtr<IStandardGraphModel> CreateStandardGraphModel(const StandardGraphModelCInfo& cinfo);
 
SMARTENGINE_EXPORT ObjectPtr<IGraphModel> CreateUserGraphModel(const UserGraphModelCInfo& cinfo);
 
SMARTENGINE_EXPORT ObjectPtr<IGraphManager> CreateGraphManager(const GraphManagerCInfo& cinfo);
 
extern "C"
{
    SMARTENGINE_EXPORT ObjPtr GraphInputOutput_GetGraphComponent(ObjPtr object, const char* componentNodeName);
    SMARTENGINE_EXPORT ObjPtr GraphInputOutput_GetInput(ObjPtr object, const char* nodeName);
    SMARTENGINE_EXPORT void GraphInputOutput_RequestOutput(ObjPtr object, const char* nodeName, int64 expectedRowCount);
    SMARTENGINE_EXPORT ObjPtr GraphInputOutput_GetOutput(ObjPtr object, const char* nodeName);
 
    SMARTENGINE_EXPORT ObjPtr GraphController_CreateInstance(const GraphControllerCInfo& cinfo);
    SMARTENGINE_EXPORT int GraphController_HaveNewOutputData(ObjPtr object);
 
    SMARTENGINE_EXPORT ObjPtr GraphModelOutput_GetOutputRWString(ObjPtr object, const char* nodeName);
    SMARTENGINE_EXPORT ObjPtr GraphModelOutput_GetOutputRWHash(ObjPtr object, HashKey nameHash);
 
    SMARTENGINE_EXPORT void GraphModel_ClearData(ObjPtr object);
    SMARTENGINE_EXPORT void GraphModel_AddData(ObjPtr object, const char* nodeName, ObjPtr data);
    SMARTENGINE_EXPORT void GraphModel_RequestOutput(ObjPtr object, int controllerId, const char* nodeName,
                                                int64 expectedRowCount);
    SMARTENGINE_EXPORT void GraphModel_Execute(ObjPtr object);
    SMARTENGINE_EXPORT void GraphModel_RetrieveOutput(ObjPtr object, int controllerId, ObjPtr modelOut);
    SMARTENGINE_EXPORT void GraphModel_Reset(ObjPtr object);
 
    SMARTENGINE_EXPORT ObjPtr StandardGraphModel_CreateInstance(const StandardGraphModelCInfo& cinfo);
    SMARTENGINE_EXPORT ObjPtr StandardGraphModel_GetGraph(ObjPtr object);
    SMARTENGINE_EXPORT int64 StandardGraphModel_GetExpectedRowCount(ObjPtr object, int controllerId, const char* outputName);
 
    SMARTENGINE_EXPORT ObjPtr UserGraphModel_CreateInstance(const UserGraphModelCInfo& cinfo);
 
    SMARTENGINE_EXPORT ObjPtr GraphManager_CreateInstance(const GraphManagerCInfo& cinfo);
    SMARTENGINE_EXPORT void GraphManager_RegisterController(ObjPtr object, ObjPtr controller, const char* modelName,
                                                       float updateRate);
    SMARTENGINE_EXPORT void GraphManager_UnregisterController(ObjPtr object, ObjPtr controller);
    SMARTENGINE_EXPORT int GraphManager_IsControllerRegistered(ObjPtr object, ObjPtr controller);
    SMARTENGINE_EXPORT void GraphManager_RegisterAgent(ObjPtr object, ObjPtr agent, ObjPtr controller);
    SMARTENGINE_EXPORT void GraphManager_UnregisterAgent(ObjPtr object, ObjPtr agent);
    SMARTENGINE_EXPORT void GraphManager_RegisterModel(ObjPtr object, ObjPtr model, const char* modelName, float updateRate);
    SMARTENGINE_EXPORT void GraphManager_RegisterModelFromGraph(ObjPtr object, ObjPtr graph, const char* modelName,
                                                           float updateRate);
    SMARTENGINE_EXPORT void GraphManager_RegisterModelFromGraphResource(ObjPtr object, const char* resourceName,
                                                                   const char* modelName, float updateRate);
    SMARTENGINE_EXPORT void GraphManager_UnregisterModel(ObjPtr object, const char* modelName);
    SMARTENGINE_EXPORT void GraphManager_Update(ObjPtr object, float deltaTime);
    SMARTENGINE_EXPORT void GraphManager_UpdateController(ObjPtr object, ObjPtr controller);
    SMARTENGINE_EXPORT void GraphManager_BeginStreaming(ObjPtr object, ObjPtr controller);
    SMARTENGINE_EXPORT void GraphManager_PushStreamData(ObjPtr object, ObjPtr controller);
    SMARTENGINE_EXPORT int64 GraphManager_GetStreamingInputRowCount(ObjPtr object, ObjPtr controller);
    SMARTENGINE_EXPORT void GraphManager_EndStreaming(ObjPtr object, ObjPtr controller);
    SMARTENGINE_EXPORT void GraphManager_Reset(ObjPtr object);
}
 
} // namespace SmartEngine