Discussion :

[Waether]

Plop,

Cela fait bientôt quelques heures que je m'arrache les cheveux à la recherche d'informations sur comment exposer une instance de classe c++ dans une script lua et pas moyen de trouver.
Je sais comment exposer une fonction statique, permettre au script Lua de construire une class c++ mais pas ce que je veux.

Ce que j'aimerais faire exactement c'est accèder une instance de LuaClass de façon globale depuis le script lua.
Le but c'est d'avoir quelque chose dans le genre bien que je ne soit pas sur de la syntaxe.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Plop.debug()

Merci d'avance,
Je rajoute quand même mon code au cas ou.

main.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# include "LuaScript.hpp"
# include "LuaClass.hpp"
 
int	main(int ac, char **av)
{
  (void)ac;
  (void)av;
  LuaScript   Test;
  LuaClass    Plop("Debug");
 
  Test.loadFile("files/test.lua");
  Test.call();
  return 0;
}

LuaScript.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include "LuaScript.hpp"
 
LuaScript::LuaScript()
{
  _state = luaL_newstate();
  luaL_openlibs(_state);
}
 
LuaScript::~LuaScript()
{
}
 
bool LuaScript::loadFile(std::string param)
{
  if (luaL_loadfile(_state, param.c_str()) != LUA_OK)
  {
    LuaError();
    return false;
  } else
    return true;
}
 
void LuaScript::call()
{
  if (lua_pcall(_state, 0, LUA_MULTRET, 0) != LUA_OK)
    LuaError();
}
 
void LuaScript::LuaError() const
{
  const char *message = lua_tostring(_state, -1);
  std::cout << message << std::endl;
  lua_pop(_state, 1);
}

LuaScript.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#ifndef LUA_LOADER_LUASCRIPT_HPP
#define LUA_LOADER_LUASCRIPT_HPP
 
# include       <lua5.2/lua.hpp>
# include       <string>
# include       <iostream>
 
class LuaScript
{
private:
  lua_State *_state;
 
public:
  LuaScript();
 
  ~LuaScript();
 
  bool loadFile(std::string);
 
  void  call();
 
  void LuaError() const;
 
};
 
#endif //LUA_LOADER_LUASCRIPT_HPP

LuaClass.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include "LuaClass.hpp"
 
LuaClass::LuaClass(std::string value)
{
  _value = value;
}
 
LuaClass::~LuaClass()
{
}
 
void LuaClass::debug() const
{
  std::cout << "Test : " << _value << std::endl;
}

LuaClass.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#ifndef LUA_LOADER_LUACLASS_HPP
#define LUA_LOADER_LUACLASS_HPP
 
# include   <iostream>
 
class LuaClass
{
private:
  std::string _value;
public:
  LuaClass(std::string);
 
  ~LuaClass();
 
  void debug() const;
};
 
#endif //LUA_LOADER_LUACLASS_HPP

[zobal]

Salut

À mon avis, il vaut mieux utiliser un binding comme https://github.com/ahupowerdns/luawrapper :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 // main.cpp
#include <LuaContext.hpp>
#include <fstream>
#include <iostream>
 
struct Hello {
    void sayHello() { std::cout << "Hello from C++\n"; } 
};
 
int main() {
    LuaContext lua;
    lua.registerFunction("sayHello", &Hello::sayHello);
 
    Hello myHello;
    lua.writeVariable("myHello", &myHello);  // exporte l'instance
    std::ifstream ifs("script.lua");
    lua.executeCode(ifs);
 
    return 0;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 -- script.lua
io.write(string.format("Hello from lua\n"))
myHello:sayHello()

[Waether]

Merci ça marche parfaitement !

Du coup voilà la fin du projet si jamais ça tente quelqu'un d'y jeter un coup d'oeil :
C'est pas le truc le plus propre du monde mais ça marche ^^

LuaScript.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#ifndef LUA_LOADER_LUASCRIPT_HPP
#define LUA_LOADER_LUASCRIPT_HPP
 
# include       <LuaClass.hpp>
# include       <string>
# include       <iostream>
# include       <fstream>
 
class LuaScript
{
private:
  LuaContext lua;
  std::ifstream ifs;
 
public:
  LuaScript();
 
  ~LuaScript();
 
  bool loadFile(std::string);
 
  void call();
 
  template<typename T>
  void registerClass(ILuaClass *param, std::string name)
  {
    param->registerFunction(lua);
    lua.writeVariable(name, *(static_cast<T*>(param)));
  }
 
};
 
#endif //LUA_LOADER_LUASCRIPT_HPP

LuaScript.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "LuaScript.hpp"
 
LuaScript::LuaScript()
{
}
 
LuaScript::~LuaScript()
{
}
 
bool LuaScript::loadFile(std::string param)
{
  ifs.open(param.c_str());
  return ifs.is_open();
}
 
void LuaScript::call()
{
  lua.executeCode(ifs);
}

LuaClass.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#ifndef LUA_LOADER_LUACLASS_HPP
#define LUA_LOADER_LUACLASS_HPP
 
# include   <iostream>
# include   <LuaContext.hpp>
 
class ILuaClass
{
public:
  virtual ~ILuaClass() {};
 
  virtual void  registerFunction(LuaContext&) = 0;
};
 
class LuaClass : public ILuaClass
{
private:
  std::string _value;
public:
  LuaClass(std::string);
 
  ~LuaClass();
 
  void debug() const;
 
  virtual void  registerFunction(LuaContext&);
};
 
#endif //LUA_LOADER_LUACLASS_HPP

LuaClass.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "LuaClass.hpp"
 
LuaClass::LuaClass(std::string value)
{
  _value = value;
}
 
LuaClass::~LuaClass()
{
}
 
void LuaClass::debug() const
{
  std::cout << "Test : " << _value << std::endl;
}
 
void LuaClass::registerFunction(LuaContext &lua)
{
  lua.registerFunction("debug", &LuaClass::debug);
}

main.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# include "LuaScript.hpp"
 
int main(int ac, char **av)
{
  (void) ac;
  (void) av;
  LuaScript   Test;
  LuaClass Plop("test");
 
  Test.loadFile("files/test.lua");
  Test.registerClass<LuaClass>(&Plop, "Plop");
  Test.call();
  return 0;
}

test.lua

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
io.write(string.format("Hello from lua\n"))
Plop:debug()

[koala01]

Salut,
Juste quelques petites remarques, pour te permettre de l'améliorer encore :

• Depuis C++11, les fichiers acceptent aussi les std::string... y a plus besoin de demander une chaine C style avec c_str()
• Les chaines de caractères sont décidément géniales, mais la copie est un processus qui prend énormément de temps... Afin d'éviter les copies inutiles, tu devrais les transmettre sous la forme d'une référence (éventuellment constante si la fonction appelée n'est pas destinée à la modifier)
• Plustôt que d'ouvrir un fichier dans une fonction, puis de le garder ouvert jusqu'à la fin (ce qui peut poser certains problèmes), sauvegarde peut être plutot le non de fichier (en faisant au besoin un test pour t'assurer qu'il s'ouvre), et ouvre le dans la (ou les) fonction(s) qui l'utilisent
• la fonction loadFile ne fait pas ce qu'elle prétend ; tu ferais bien de la renommer en quelque chose d'autre, qui indiquerait clairement que le but est de vérifier l'accessibilité du fichier
• Ta class LuaScript fini par avoir quatre responsabilités distinctes:
  
  1. tester l'accessibilité du fichier
  2. garder le fichier ouvert
  3. enregistrer les infos dans le fichier
  4. appeler l'exécution du script
  
  Ca fait au moins trois responsabilités de trop, en vertu du SRP