call function from class

[akadjoker]

Hi, is possible to call a function from Scrip with a class Inherited from c class
c:

class GameScript:..
... void update(float dt)
{

script:

class Bunny : GameScript
... func update(dt)

[akadjoker]

all the code ..

#include <stdio.h>
#include <math.h>

#include "gravity_compiler.h"
#include "gravity_macros.h"
#include "gravity_core.h"
#include "gravity_vm.h"
#include "gravity_vmmacros.h"
#include "gravity_opcodes.h"

#include
#include
#include
#include <assert.h>
#include

#include
#include

#include <raylib.h>

Texture2D texBunny;

using namespace std;

static int ENTITY_INDEX = 0;
static int SCRIPT_INDEX =0;

#define MAX_BUNNIES 50000 /
#define MAX_BATCH_ELEMENTS 8192

// error callback
static void report_error (gravity_vm *vm, error_type_t error_type, const char *message,
error_desc_t error_desc, void *xdata) {
#pragma unused(vm, xdata)
const char *type = "N/A";
switch (error_type) {
case GRAVITY_ERROR_NONE: type = "NONE"; break;
case GRAVITY_ERROR_SYNTAX: type = "SYNTAX"; break;
case GRAVITY_ERROR_SEMANTIC: type = "SEMANTIC"; break;
case GRAVITY_ERROR_RUNTIME: type = "RUNTIME"; break;
case GRAVITY_WARNING: type = "WARNING"; break;
case GRAVITY_ERROR_IO: type = "I/O"; break;
}

if (error_type == GRAVITY_ERROR_RUNTIME) printf("RUNTIME ERROR: ");
else printf("%s ERROR on %d (%d,%d): ", type, error_desc.fileid, error_desc.lineno, error_desc.colno);
printf("%s\n", message);

}

class Entity;

class MainClass
{

public:
std::string className;
gravity_class_t *c ;
gravity_instance_t *instance;
int index;

MainClass()
{
  //  cout << "MainClass constructor called." << endl;
    className="MainClass";
    c=NULL;
    instance=NULL;

}

virtual ~MainClass()
{
  //  cout << "MainClass destructor called." << endl;
}

};

class GameScript: public MainClass
{
public:

GameScript()
{
//    cout << "GameScript constructor called." << endl;
    className="GameScript";
    index=++SCRIPT_INDEX;
    entity=nullptr;


}

virtual ~GameScript()
{

// cout << "GameScript destructor called." << endl;
}

 void ready()
{

  // cout << "GameScript ready called ." << endl;
}

void render()
{

   cout << "GameScript render called ." << endl;
}
void update(float dt)
{

 //  cout << "GameScript "<<index<< " " <<dt << endl;
}

Entity *entity;

};

std::vector<Entity*> entitys;

class Entity: public MainClass
{
public:
float x;
float y;
GameScript *gameScript;
bool useScript;

    Entity()
    {
  //  cout << "Entity constructor called." << endl;
    x=GetRandomValue(10,GetScreenWidth()-100);
    y=GetRandomValue(10,GetScreenHeight()-100);
    className="Entity";
    useScript=false;
    gameScript=nullptr;
    index=++ENTITY_INDEX;
    entitys.push_back(this);


}

virtual ~Entity()
{
   // cout << "Entity destructor called." << endl;

 int i = 0;
for (auto& s : entitys)
{
    if (s == this)
    {

         entitys.erase(entitys.begin() + i);
        return;
    }
    i++;
}
}

void update(float dt)
{

  // cout << "Entity update called   x:"<<x<<"  y:"<<y<< " DT:"<<dt << endl;
    //if (useScript)
    if (gameScript)
            gameScript->update(dt);
}
  void render()
{
     // if (gameScript)
       //     gameScript->render();
   // cout << "Entity render called." << endl;
     DrawTexture(texBunny, (int)x, (int)y,WHITE);

// DrawTexture(texBunny, 100,100,WHITE);

}
void setScript(GameScript *script)
{

    gameScript=script;
    useScript=true;

  //  cout << "set GameScript "<<index<< " " <<script->index << endl;
   // script->entity=this;
    script->ready();
}

};

//*******************************************************

static bool gamescrip_create (gravity_vm *vm, gravity_value_t *args, uint16_t nargs, uint32_t rindex)
{
gravity_class_t *c = (gravity_class_t *)GET_VALUE(0).p;
gravity_instance_t *instance = gravity_instance_new(vm, c);
GameScript *r = new GameScript();

 r->c=c;
 r->instance=instance;

 gravity_instance_setxdata(instance, r);
 RETURN_VALUE(VALUE_FROM_OBJECT(instance), rindex);

}

static bool gamescrip_update (gravity_vm *vm, gravity_value_t *args, uint16_t nargs, uint32_t rindex)
{
gravity_instance_t *instance = (gravity_instance_t *)GET_VALUE(0).p;
float dt = VALUE_AS_FLOAT(GET_VALUE(1));
GameScript *r = (GameScript *)instance->xdata;
r->update(dt);
RETURN_NOVALUE();
}

static bool gamescrip_ready (gravity_vm *vm, gravity_value_t *args, uint16_t nargs, uint32_t rindex)
{
gravity_instance_t *instance = (gravity_instance_t *)GET_VALUE(0).p;
GameScript *r = (GameScript *)instance->xdata;
r->ready();
RETURN_NOVALUE();
}
static bool gamescrip_render (gravity_vm *vm, gravity_value_t *args, uint16_t nargs, uint32_t rindex)
{
gravity_instance_t *instance = (gravity_instance_t *)GET_VALUE(0).p;
GameScript *r = (GameScript *)instance->xdata;
r->render();
RETURN_NOVALUE();
}
static bool gamescript_get_entity (gravity_vm *vm, gravity_value_t *args, uint16_t nargs, uint32_t rindex)
{
gravity_instance_t *instance_script = (gravity_instance_t *)GET_VALUE(0).p;
GameScript *gameScript = (GameScript *)instance_script->xdata;
Entity *entity = gameScript->entity;
RETURN_VALUE(VALUE_FROM_OBJECT(entity->instance), rindex);
}

static bool gamescript_set_entity (gravity_vm *vm, gravity_value_t *args, uint16_t nargs, uint32_t rindex)
{
gravity_instance_t *instance_entity = (gravity_instance_t *)GET_VALUE(1).p;
gravity_instance_t *instance_script = (gravity_instance_t *)GET_VALUE(0).p;

Entity *entity = (Entity *)instance_entity->xdata;


GameScript *gameScript = (GameScript *)instance_script->xdata;

// entity->setScript(gameScript);

//cout << "set GameScript "<<Entity->index<< " " <<script->index << endl;
cout << "set entity "<<entity->className<< " " <<entity->index << endl;

cout << "set entity "<className<< " " <index << endl;

RETURN_NOVALUE();

}

void register_gamescript_classes (gravity_vm *vm) {

gravity_class_t *mClass = gravity_class_new_pair(vm, "GameScript", NULL, 0, 0);
gravity_class_t *mMetaClass = gravity_class_get_meta(mClass);

gravity_class_bind(mMetaClass, GRAVITY_INTERNAL_EXEC_NAME, NEW_CLOSURE_VALUE(gamescrip_create));
gravity_class_bind(mClass, "update", NEW_CLOSURE_VALUE(gamescrip_update));
gravity_class_bind(mClass, "ready", NEW_CLOSURE_VALUE(gamescrip_ready));
 gravity_class_bind(mClass, "render", NEW_CLOSURE_VALUE(gamescrip_render));
gravity_class_bind(mClass, "getEntity", NEW_CLOSURE_VALUE(gamescript_get_entity));
gravity_class_bind(mClass, "setEntity", NEW_CLOSURE_VALUE(gamescript_set_entity));

gravity_vm_setvalue(vm, "GameScript", VALUE_FROM_OBJECT(mClass));

}

//*******************************************************

static bool entity_create (gravity_vm *vm, gravity_value_t *args, uint16_t nargs, uint32_t rindex)
{
gravity_class_t *c = (gravity_class_t *)GET_VALUE(0).p;
gravity_instance_t *instance = gravity_instance_new(vm, c);
Entity *r = new Entity();

 r->c=c;
 r->instance=instance;


 gravity_instance_setxdata(instance, r);
 RETURN_VALUE(VALUE_FROM_OBJECT(instance), rindex);

}

static bool entity_set_script (gravity_vm *vm, gravity_value_t *args, uint16_t nargs, uint32_t rindex)
{
gravity_instance_t *instance = (gravity_instance_t *)GET_VALUE(0).p;

Entity *entity = (Entity *)instance->xdata;

gravity_object_t *object = NULL;
if (VALUE_ISA_INSTANCE(GET_VALUE(1)))
{

    object = VALUE_AS_OBJECT(GET_VALUE(0));
    gravity_instance_t *instance_script = (gravity_instance_t *)object;
    GameScript *gameScript = (GameScript *)instance_script->xdata;
  //   cout << "set GameScript "<<gameScript->className<< " " <<gameScript->index << endl;
     entity->setScript(gameScript);



}  else
if  (VALUE_ISA_CLASS(GET_VALUE(1)))
{
   // object = VALUE_AS_OBJECT(GET_VALUE(0));
    printf(" class.\n");
} else
{
    printf("bind method can be applied only to instances or classes.\n");
}



//GameScript *gameScript = (GameScript *)instance_script->xdata;

// entity->setScript(gameScript);

//cout << "set GameScript "<<Entity->index<< " " <<script->index << endl;

/// cout << "set GameScript "<className<< " " <index << endl;

// cout << "set GameScript "<className<< " " <index << endl;

RETURN_NOVALUE();

}

static bool entity_update (gravity_vm *vm, gravity_value_t *args, uint16_t nargs, uint32_t rindex) {
gravity_instance_t *instance = (gravity_instance_t *)GET_VALUE(0).p;
float dt = VALUE_AS_FLOAT(GET_VALUE(1));
Entity *r = (Entity *)instance->xdata;
r->update(dt);
RETURN_NOVALUE();
}

static bool entity_render (gravity_vm *vm, gravity_value_t *args, uint16_t nargs, uint32_t rindex) {
gravity_instance_t *instance = (gravity_instance_t *)GET_VALUE(0).p;
float dt = VALUE_AS_FLOAT(GET_VALUE(1));
Entity *r = (Entity *)instance->xdata;
r->render();
RETURN_NOVALUE();
}

static bool entity_name_get (gravity_vm *vm, gravity_value_t *args, uint16_t nargs, uint32_t rindex) {
gravity_instance_t *instance = (gravity_instance_t *)GET_VALUE(0).p;
Entity *obj = (Entity *)instance->xdata;
RETURN_VALUE(VALUE_FROM_STRING(vm,obj->className.c_str(),strlen(obj->className.c_str())), rindex);
}

static bool entity_name_set (gravity_vm *vm, gravity_value_t *args, uint16_t nargs, uint32_t rindex) {
gravity_instance_t *instance = (gravity_instance_t *)GET_VALUE(0).p;
gravity_value_t value = GET_VALUE(1);
Entity *obj = (Entity *)instance->xdata;
obj->className = std::string(VALUE_AS_CSTRING(value));
RETURN_NOVALUE();
}

static bool entity_x_get (gravity_vm *vm, gravity_value_t *args, uint16_t nargs, uint32_t rindex) {
gravity_instance_t *instance = (gravity_instance_t *)GET_VALUE(0).p;
Entity *obj = (Entity *)instance->xdata;
RETURN_VALUE(VALUE_FROM_FLOAT(obj->x), rindex);
}

static bool entity_x_set (gravity_vm *vm, gravity_value_t *args, uint16_t nargs, uint32_t rindex) {
gravity_instance_t *instance = (gravity_instance_t *)GET_VALUE(0).p;

 Entity *obj = (Entity *)instance->xdata;

gravity_value_t value = GET_VALUE(1);

double d = 0.0f;
if (VALUE_ISA_FLOAT(value)) d = VALUE_AS_FLOAT(value);
else if (VALUE_ISA_INT(value)) d = double(VALUE_AS_INT(value));

obj->x=d;

RETURN_NOVALUE();

}

static bool entity_y_get (gravity_vm *vm, gravity_value_t *args, uint16_t nargs, uint32_t rindex) {
gravity_instance_t *instance = (gravity_instance_t *)GET_VALUE(0).p;
Entity *obj = (Entity *)instance->xdata;
RETURN_VALUE(VALUE_FROM_FLOAT(obj->y), rindex);
}

static bool entity_y_set (gravity_vm *vm, gravity_value_t *args, uint16_t nargs, uint32_t rindex) {
gravity_instance_t *instance = (gravity_instance_t *)GET_VALUE(0).p;
Entity *obj = (Entity *)instance->xdata;

gravity_value_t value = GET_VALUE(1);

double d = 0.0f;
if (VALUE_ISA_FLOAT(value)) d = VALUE_AS_FLOAT(value);
else if (VALUE_ISA_INT(value)) d = double(VALUE_AS_INT(value));

obj->y=d;
RETURN_NOVALUE();

}
void register_entity_classes (gravity_vm *vm) {
gravity_class_t *mClass = gravity_class_new_pair(vm, "Entity", NULL, 0, 0);
gravity_class_t *mMetaClass = gravity_class_get_meta(mClass);

gravity_class_bind(mMetaClass, GRAVITY_INTERNAL_EXEC_NAME, NEW_CLOSURE_VALUE(entity_create));
gravity_class_bind(mClass, "update", NEW_CLOSURE_VALUE(entity_update));
gravity_class_bind(mClass, "render", NEW_CLOSURE_VALUE(entity_render));
gravity_class_bind(mClass, "setScript", NEW_CLOSURE_VALUE(entity_set_script));
gravity_class_bind(mClass, "name", VALUE_FROM_OBJECT(computed_property_create(NULL, NEW_FUNCTION(entity_name_get), NEW_FUNCTION(entity_name_set))));



gravity_class_bind(mClass, "x", VALUE_FROM_OBJECT(computed_property_create(NULL, NEW_FUNCTION(entity_x_get), NEW_FUNCTION(entity_x_set))));
gravity_class_bind(mClass, "y", VALUE_FROM_OBJECT(computed_property_create(NULL, NEW_FUNCTION(entity_y_get), NEW_FUNCTION(entity_y_set))));
gravity_vm_setvalue(vm, "Entity", VALUE_FROM_OBJECT(mClass));

}

//*******************************************

static bool input_mouse_down (gravity_vm *vm, gravity_value_t *args, uint16_t nargs, uint32_t rindex) {
// check nargs (must be 3 because arg[0] is self)

RETURN_VALUE(VALUE_FROM_INT(IsMouseButtonDown( VALUE_AS_INT(GET_VALUE(1)))),rindex);

}
static bool input_mouse_press (gravity_vm *vm, gravity_value_t *args, uint16_t nargs, uint32_t rindex) {
// check nargs (must be 3 because arg[0] is self)

RETURN_VALUE(VALUE_FROM_INT(IsMouseButtonPressed( VALUE_AS_INT(GET_VALUE(1)))),rindex);

}
void setup_input (gravity_vm vm)
{
gravity_class_t c = gravity_class_new_pair (vm, "Mouse", NULL, 0, 0);
gravity_class_bind(c, "isDown", NEW_CLOSURE_VALUE(input_mouse_down));
gravity_class_bind(c, "isPress", NEW_CLOSURE_VALUE(input_mouse_press));
gravity_vm_setvalue(vm, "Mouse", VALUE_FROM_OBJECT(c));
}
///*******************************************************************************************

static void object_free (gravity_vm *vm, gravity_object_t *obj)
{
gravity_instance_t *instance = (gravity_instance_t *)obj;
MainClass *r = (MainClass *)instance->xdata;
delete r;
}

bool RunUpdate(gravity_vm *vm)
{
gravity_value_t funUpdate = gravity_vm_getvalue(vm, "update", (uint32_t)strlen("update"));
if (!VALUE_ISA_CLOSURE(funUpdate))
{
printf("Unable to find update function into Gravity VM.\n");

}else
{

    gravity_closure_t *closureUpdate = VALUE_AS_CLOSURE(funUpdate);
    gravity_value_t dt_value = VALUE_FROM_FLOAT(0.16f);
    gravity_value_t params[] = {dt_value};
    if (gravity_vm_runclosure (vm, closureUpdate, VALUE_FROM_NULL, params, 1))
    {
        gravity_value_t result = gravity_vm_result(vm);
          return VALUE_AS_BOOL(result);
    }
    return false;
}
return false;

}

bool RunReady(gravity_vm *vm)
{
gravity_value_t funReady = gravity_vm_getvalue(vm, "ready", (uint32_t)strlen("ready"));
if (!VALUE_ISA_CLOSURE(funReady))
{
printf("Unable to find ready function into Gravity VM.\n");
} else
{
gravity_closure_t *closureReady = VALUE_AS_CLOSURE(funReady);
gravity_value_t paramsr[] = {0};
if (gravity_vm_runclosure (vm, closureReady, VALUE_FROM_NULL, paramsr, 0))
{
gravity_value_t result = gravity_vm_result(vm);
return VALUE_AS_BOOL(result);
}

}
return false;

}

bool RunRender(gravity_vm *vm)
{

gravity_value_t funRender = gravity_vm_getvalue(vm, "render", (uint32_t)strlen("render"));
if (!VALUE_ISA_CLOSURE(funRender))
{
    printf("Unable to find  render function into Gravity VM.\n");

} else
{
    gravity_closure_t *closureRender = VALUE_AS_CLOSURE(funRender);
    gravity_value_t params2[] = {0};
    if (gravity_vm_runclosure (vm, closureRender, VALUE_FROM_NULL, params2, 0))
    {
        gravity_value_t result = gravity_vm_result(vm);
         return VALUE_AS_BOOL(result);
    }


}

return false;

}

int main(int argc, const char * argv[]) {

const int screenWidth = 900;
const int screenHeight = 850;
InitWindow(screenWidth, screenHeight, "RayGravity");

// setup a minimal delegate
gravity_delegate_t delegate = {
.error_callback = report_error,
.bridge_free = object_free
};

const char* source_code = R"(

extern var Entity;
extern var GameScript;
extern var Mouse;
var mouse = Mouse()

class Bunny : GameScript
{

func init()
{

/// System.print("Bunny instantiated " );

}

func deinit()
{

//System.print("Bunny instance deinitialized");

}

func ready()
{
    System.print("VM script ready")
   // var parent = getEntity()
}
 func update(dt)
{
    System.print("VM update")
}
 func render()
{
    System.print("VM script render")
   // var parent = getEntity()
}

}

func ready()
{
System.print("ready")

var player = Entity()
var script = Bunny()
player.setScript(script)
script.render(1)

return 1
}

func update(dt)
{

if(mouse.isPress(0))
{
    for (var i in 1...100)
    {

       var player = Entity()
       var script = Bunny()

    //    script.setEntity(player)


  //  player.setScript(script)

  }
}

return 1
}

func render()
{

return 1
}
)";

gravity_compiler_t *compiler = gravity_compiler_create(&delegate);
gravity_closure_t *closure = gravity_compiler_run(compiler, source_code, strlen(source_code), 0, true, true);
gravity_vm *vm = gravity_vm_new(&delegate);
gravity_compiler_transfer(compiler, vm);
gravity_compiler_free(compiler);
register_entity_classes(vm);
register_gamescript_classes(vm);
setup_input(vm);
gravity_vm_loadclosure(vm, closure);


texBunny = LoadTexture("resources/wabbit_alpha.png");

bool useReady=false;
bool useUpdate=false;
bool useRender=false;

// gravity_closure_t *closureReady=NULL;

// gravity_closure_t *closureUpdate=NULL;
// gravity_closure_t *closureRender =NULL;

RunReady(vm);

 while (!WindowShouldClose())    // Detect window close button or ESC key
{





    //lua["update"](GetFrameTime());

    if (IsMouseButtonDown(0))
    {
     //-- for (int i=0;i<100;i++)
      ///      auto s = new Sprite();
    }

  //  luaUpdate(GetFrameTime());




        BeginDrawing();
        ClearBackground(RAYWHITE);

           RunUpdate(vm);

            for (auto& s : entitys)
            {
                 s->update(GetFrameTime());
                 s->render();
            }

        DrawRectangle(0, 0, screenWidth, 40, BLACK);
        int bunniesCount = (int)entitys.size();
        DrawText(TextFormat("bunnies: %i", bunniesCount), 120, 10, 20, GREEN);
        DrawText(TextFormat("batched draw calls: %i", 1 + bunniesCount/MAX_BATCH_ELEMENTS), 320, 10, 20, MAROON);

        DrawFPS(10, 10);

    EndDrawing();
    //----------------------------------------------------------------------------------
}

UnloadTexture(texBunny); // Unload bunny texture

CloseWindow();

// free vm and base classes
if (vm) gravity_vm_free(vm);
gravity_core_free();
std::cout<< "::: CLOSE :::"<<std::endl;

}