kscriptmanager.h

Go to the documentation of this file.

 
#ifndef KSCRIPTMANAGER_H
#define KSCRIPTMANAGER_H
 
#include "kexport.h"
 
#include <cassert>
#include <vector>
#include <map>
#include <cstdio>
#include <iostream>
 
#include <angelscript.h>
#include <scriptstdstring/scriptstdstring.h>
#include <scriptbuilder/scriptbuilder.h>
 
#include "kdatatype.h"
 
#define FUNCTION asFUNCTION
 
namespace kemena
{
    class kObject;

    enum kScriptSourceType
    {
        K_SCRIPT_TEXT      = 0, 
        K_SCRIPT_NODEGRAPH = 1, 
    };

    enum kScriptEvent
    {
        K_SCRIPT_AWAKE = 0,   
        K_SCRIPT_START,       
        K_SCRIPT_UPDATE,      
        K_SCRIPT_FIXED_UPDATE,
        K_SCRIPT_LATE_UPDATE, 
        K_SCRIPT_ON_ENABLE,   
        K_SCRIPT_ON_DISABLE,  
        K_SCRIPT_ON_DESTROY,  
        K_SCRIPT_EVENT_COUNT  
    };

    KEMENA3D_API const char *kScriptEventDecl(kScriptEvent evt);

    struct KEMENA3D_API kScript
    {
        kString uuid;              
        kString scriptUuid;        
        kString fileName;          
        kString checksum;          
        bool    isActive = true;   
    };

    struct KEMENA3D_API kScriptAsset
    {
        kString           uuid;                       
        kString           sourcePath;                 
        kString           bytecodePath;               
        kScriptSourceType sourceType = K_SCRIPT_TEXT;  
        kString           checksum;                   
    };

    struct KEMENA3D_API kScriptInstance
    {
        kString            componentUuid;          
        kString            scriptUuid;             
        kString            moduleName;             
        asIScriptModule   *module = nullptr;       
        asIScriptFunction *fn[K_SCRIPT_EVENT_COUNT] = {}; 
        kObject           *owner = nullptr;        
        bool               awakeCalled = false;    
        bool               startCalled = false;    
        bool               valid = false;          
    };

    class KEMENA3D_API kFileByteStream : public asIBinaryStream
    {
    public:
        kFileByteStream(const kString &path, bool writing);

        ~kFileByteStream() override;

        bool isOpen() const { return file != nullptr; }

        int Read(void *ptr, asUINT size) override;

        int Write(const void *ptr, asUINT size) override;
 
    private:
        std::FILE *file = nullptr;
    };

    class KEMENA3D_API kScriptManager
    {
    public:
        kScriptManager();

        virtual ~kScriptManager();

        asIScriptEngine *getEngine() { return engine; }
 
        // --- Script-asset registry ------------------------------------------

        void registerScriptAsset(const kString &uuid, const kString &sourcePath,
                                 kScriptSourceType type = K_SCRIPT_TEXT,
                                 const kString &bytecodePath = "");

        kScriptAsset *getScriptAsset(const kString &uuid);

        void unregisterScriptAsset(const kString &uuid);

        void setBytecodePath(const kString &uuid, const kString &bytecodePath);
 
        // --- Compilation -----------------------------------------------------

        bool compileToBytecode(const kString &scriptUuid, const kString &outPath,
                               bool stripDebug = false);

        bool compileFileToBytecode(const kString &sourcePath, const kString &outPath,
                                   bool stripDebug = false);
 
        // --- Per-object instances -------------------------------------------

        kScriptInstance *createInstance(const kString &componentUuid,
                                        const kString &scriptUuid);

        kScriptInstance *getInstance(const kString &componentUuid);

        void destroyInstance(const kString &componentUuid);

        void destroyAllInstances();
 
        // --- Execution -------------------------------------------------------

        void setActiveObject(kObject *obj) { activeObject = obj; }

        kObject *getActiveObject() const { return activeObject; }

        void setDeltaTime(float dt) { deltaTime = dt; }

        float getDeltaTime() const { return deltaTime; }

        void setFixedDeltaTime(float dt) { fixedDeltaTime = dt; }

        float getFixedDeltaTime() const { return fixedDeltaTime; }

        bool callEvent(kScriptInstance *inst, kScriptEvent evt);
 
        // --- Host bindings ---------------------------------------------------

        void registerGlobalFunction(const kString &declaration, asSFuncPtr func);

        void destroy();
 
    protected:
    private:
        bool buildInstanceModule(kScriptInstance *inst, const kScriptAsset &asset);
        void cacheInstanceFunctions(kScriptInstance *inst);
 
        asIScriptEngine  *engine         = nullptr; 
        asIScriptContext *context        = nullptr; 
        kObject          *activeObject   = nullptr; 
        unsigned int      moduleCounter  = 0;       
        float             deltaTime      = 0.0f;    
        float             fixedDeltaTime = 0.0f;    
 
        std::map<kString, kScriptAsset>     assets;    
        std::map<kString, kScriptInstance*> instances; 
    };
}
 
#endif // KSCRIPTMANAGER_H