kscriptgraph.h

Go to the documentation of this file.

 
#ifndef KSCRIPTGRAPH_H
#define KSCRIPTGRAPH_H
 
#include "kexport.h"
 
#include <vector>
#include <string>
 
#include <nlohmann/json.hpp>
 
#include "kdatatype.h"
 
namespace kemena
{
    using kJson = nlohmann::json;

    enum class kScriptPinType
    {
        Exec = 0, 
        Float,    
        Bool,     
        String,   
        Vec3,     
        Object,   
    };

    enum class kScriptNodeType
    {
        // --- Events (entry points; one exec output) -------------------------
        EventAwake = 0,   
        EventStart,       
        EventUpdate,      
        EventFixedUpdate, 
        EventLateUpdate,  
        EventOnDestroy,   
 
        // --- Flow ------------------------------------------------------------
        Branch, 
 
        // --- Actions (exec in + exec out) -----------------------------------
        Print,       
        SetPosition, 
        SetRotation, 
        SetScale,    
        Translate,   
        Rotate,      
        SetActive,   
        SetVariable, 
 
        // --- Getters (pure data) --------------------------------------------
        GetSelf,      
        GetPosition,  
        GetRotation,  
        GetScale,     
        GetForward,   
        GetRight,     
        GetUp,        
        GetDeltaTime, 
        GetVariable,  
 
        // --- Literals --------------------------------------------------------
        LiteralFloat,  
        LiteralBool,   
        LiteralString, 
        LiteralVec3,   
 
        // --- Math ------------------------------------------------------------
        Add,      
        Subtract, 
        Multiply, 
        Divide,   
 
        // --- Vector ----------------------------------------------------------
        MakeVec3,  
        BreakVec3, 
        ScaleVec3, 
 
        // --- Compare / logic -------------------------------------------------
        Greater, 
        Less,    
        Equal,   
        And,     
        Or,      
        Not,     
 
        Count 
    };

    KEMENA3D_API const char *kScriptNodeTypeName(kScriptNodeType type);

    struct KEMENA3D_API kScriptGraphPin
    {
        int            id   = 0;                       
        kString        name;                           
        kScriptPinType type = kScriptPinType::Float;    
        bool           isOutput = false;                
 
        // Inline default used when an input data pin is left unconnected.
        float   defFloat  = 0.0f;                       
        float   defVec[3] = { 0.0f, 0.0f, 0.0f };       
        bool    defBool   = false;                      
        kString defStr;                                 
 
        // Cached screen position, refreshed by the editor each frame.
        float uiX = 0.0f, uiY = 0.0f;                   
    };

    struct KEMENA3D_API kScriptGraphNode
    {
        int             id   = 0;                           
        kScriptNodeType type = kScriptNodeType::EventUpdate; 
        kString         name;                                
        float           posX = 0.0f, posY = 0.0f;            
 
        std::vector<kScriptGraphPin> inputs;  
        std::vector<kScriptGraphPin> outputs; 
 
        // Payload for literal and variable nodes.
        float   valueFloat[3] = { 0.0f, 0.0f, 0.0f }; 
        bool    valueBool     = false;                
        kString valueStr;                             
    };

    struct KEMENA3D_API kScriptGraphLink
    {
        int id       = 0;              
        int fromNode = 0, fromPin = 0; 
        int toNode   = 0, toPin   = 0; 
    };

    struct KEMENA3D_API kScriptGraphVar
    {
        kString name;            
        float   defValue = 0.0f; 
    };

    struct KEMENA3D_API kScriptGraph
    {
        kString uuid;  
        kString name;  
 
        std::vector<kScriptGraphNode> nodes;     
        std::vector<kScriptGraphLink> links;     
        std::vector<kScriptGraphVar>  variables; 
 
        int  nextId = 1;       
        bool dirty  = false;   

        int newId() { return nextId++; }

        kScriptGraphNode *findNode(int id);

        const kScriptGraphNode *findNode(int id) const;

        const kScriptGraphLink *incomingLink(int nodeId, int pinId) const;

        const kScriptGraphLink *outgoingLink(int nodeId, int pinId) const;

        bool isPinConnected(int nodeId, int pinId) const;

        void removeLinksByNode(int nodeId);

        void removeLinksByPin(int nodeId, int pinId);

        void removeNode(int nodeId);

        kScriptGraphNode makeNode(kScriptNodeType type, float x, float y);

        kJson toJson() const;

        void fromJson(const kJson &j);
    };

    struct KEMENA3D_API kScriptGraphResult
    {
        bool    success = false; 
        kString error;           
        kString code;            
    };

    namespace kScriptGraphCompiler
    {
        KEMENA3D_API kScriptGraphResult compile(const kScriptGraph &graph);
    }
}
 
#endif // KSCRIPTGRAPH_H