salut.

J'aimerai implanter dans mon éditeur un système de script pour appeler dynamiquement les fonctions d'irrlicht.

Je n'ai jamais fais ce genre de chose et donc j'aurai aimé avoir quelques conseils : comme par exemple le choix du language et si il existe deja pour irrlicht une librairie ou du code qui permet de faire ca.

merci.

Scripter Irrlicht est un travaille de longue haleine. Pour les script, j'utilise LUA mais je ne sais pas ce que ça vaut niveau performances. LUA est très facile à prendre en main mais irrEdit utilise des scripts Squirrel donc il doit être mieux je pense.
A mon avis, scripter Irrlicht est une mauvaise idée pour deux raisons :
1/ les scripts sont naturellement moins performants que du c++ compilé;
2/ à chaque version d'irrlicht, des modifications seront à apporter.

Je pense qu'il vaut mieux créé une classe avec des fonctions à scripter. Le script n'est pas fait pour écrire un programme, il est fait pour extérioriser le code qui changera selon les projets. C'est-à-dire que tu codes un moteur en c++ avec des appels de scripts au endroits clés puis dans tes scripts tu faits appels à des fonctions genre createNewScene("nom_du_fichier.scene"); et c'est ton moteur qui fera le reste. Car si tu parses ton fichier et créé tes objets avec les scripts ça va prendre des plombes!

Donc pour résumer, afin de gagner en temps et en performances, scriptes des fonctions globales, récurrentes et surtout de haut niveau.

Je ne veux pas tout scripter, juste binder quelques fonctions comme par exemple ajouter un scenenode ou modifier ses attributs, mais rien qui entrera dans la boucle de rendu, en gros faire juste de la préparation de scène, donc ça ne devrait je pense pas ralentir le rendu final.

Est ce tu utilise une lib special pour LUA, genre irrlua (je sais pas si elle est encore d'actualité pour la derniere version d'irrlicht) ?

Dans ce cas l'utilisation que tu veux en faire est bonne. Les langages de scripts ne se soucis pas de ce que tu veux scripter donc pas besoin de irrMachinTruc.^^
J'utilise LUA et Lunar (pour scripter les fonctions membres avec LUA).

Pour télécharger LUA c'est ici.
Pour l'utilisation de LUA et Lunar, c'est ici.
Le tutoriel est vraiment simple, il m'a permis de scripter des fonctions très facilement et rapidement.

Pour Lunar, il n'explique pas bien donc, en fait :
1/ tu vas sur cette page : ici;
2/ tu descends dans la page jusque "lunar.h for Lua 5.0";
3/ tu créé un fichier lunar.h (dans le répertoire des .h de LUA) et tu copies le code de :

extern "C" {
#include "lua.h"
#include "lauxlib.h"
}

jusque :

#define LUNAR_DECLARE_METHOD(Class, Name) {#Name, &Class::Name}

4/ tu as juste à inclure le fichier lunar.h et LUA sera inclu en même temps. Et il y a une lib à linker.

Ah, j'oubliais! Il y a aussi luacgui qui te permet de précompilé tes scripts. Disponible ici.
Maintenant, 1h ou 2 devrait suffir pour te faire la main.

EDIT:

Tiens j'ai retrouvé une classe d'essai que j'avais fait à l'époque. Associée au tuto, tu devrais pouvoir intégrer ça très vite.
Elle te montre comment intégrer LUA et LUNAR, comment créer une classe qui lance des scripts sur demande et une fonction à scripter.
Pour utiliser cette classe, tu créés une instance au début de ton programme, à chaque fois que tu veux lire un script tu utilises la fonction runScript("filename").
Lorsque tu quitte l'application tu détruis l'instance. C'est un exécuteur de script en fait.

ScriptReader.h

#ifndef SCRIPTREADER_H
#define SCRIPTREADER_H

#include "../../LUA/include/lua.hpp"
#include "../../LUA/include/lunar.h"

#include "../../Irrlicht SVN/include/irrlicht.h"
using namespace irr;
using namespace core;
using namespace video;
using namespace scene;
using namespace gui;
using namespace io;


class ScriptReader
{
    /// INTEGRATION LUA ET LUNAR
    friend class Lunar<ScriptReader>;
    static const char* className;
    static Lunar<ScriptReader>::RegType methods[];

    public:
        /// CONSTRUCTEUR
        ScriptReader(IrrlichtDevice* device);
        /// DESTRUCTEUR
        virtual ~ScriptReader();

        /// FONCTIONS
        bool runScript(stringc pathfile);

    protected:
        /// CONSTRUCTEUR LUNAR
        ScriptReader(lua_State* state);

        /// MEMBRES
        lua_State* LUAEnv;
        IrrlichtDevice* Device;

        /// FONCTIONS
        void affectFonctionLua();

        /// FONCTIONS RESERVEE AU SCRIPTING
        /** ScriptReader **/
        int SCRIPTREADER_print(lua_State* state);

};


#endif // SCRIPTREADER_H

#include "ScriptReader.h"


/// enregistrement aupres de lunar
const char* ScriptReader::className = "ScriptReader";

/// on initialise le tableau des méthodes de la classe.
Lunar<ScriptReader>::RegType ScriptReader::methods[] =
{
    // ScriptReader Méthodes
    LUNAR_DECLARE_METHOD(ScriptReader, SCRIPTREADER_print),
    // toujours mettre ça
    {0,0}
};

ScriptReader::ScriptReader(IrrlichtDevice* device) : Device(device)
{
    /// créé l'environnement LUA
    LUAEnv = lua_open();
    /// chargement des libs
    luaL_openlibs(LUAEnv);
    /// on enregistre la classe aupres de lua
	Lunar<ScriptReader>::Register(LUAEnv);
    /// affecte les fonctions utilisable dans les scripts
    affectFonctionLua();
}

ScriptReader::ScriptReader(lua_State* state){}

ScriptReader::~ScriptReader()
{
    /// libération mémoire
    lua_close(LUAEnv);
}


bool ScriptReader::runScript( stringc pathfile)
{
        /// lit le fichier script
        if( luaL_dofile(LUAEnv, pathfile.c_str()) != 0 ) { printf("Erreur : %s\
", lua_tostring(LUAEnv,-1)); return false; }
        else return true;
}

/*************************************************
                FONCTIONS PROTEGEES
*************************************************/

void ScriptReader::affectFonctionLua()
{
    /// on enregistre la classe pour que LUA puisse appeler les methode de ScriptReader.
    Lunar<ScriptReader>::push(LUAEnv, this);
    lua_setglobal(LUAEnv, "SR"); // SR pour ScriptReader, ça va plus vite à écrire^^
    /// on enregistre nos fonctions C++ pour qu'elles soient accessibles depuis Lua
   /* pour celle de ScriptReader, c'est fait dans Lunar<ScriptReader>::RegType ScriptReader::methods[] en haut de ce fichier */
}


/*************************************************
        FONCTIONS RESERVEE AU SCRIPTING
*************************************************/
/** ScriptReader **/
// SR:SCRIPTREADER_print("String à affichée");
int ScriptReader::SCRIPTREADER_print(lua_State* state)
{
    if( lua_gettop(state) == 1 )
        if( lua_isstring(state,1) )
        {
            printf("%s\
",lua_tostring(state,1));
            return 0;
        }
    return -1;
}

-- ligne qui affiche un texte dans la console (cette ligne est un commentaire à cause des "--")
SR:SCRIPTREADER_print("Debut du Script : 1-Post_Lancement");

super, merci je vais essayer ca

Tiens j'ai retrouvé une classe d'essai que j'avais fait à l'époque. Associée au tuto, tu devrais pouvoir intégrer ça très vite.
Elle te montre comment intégrer LUA et LUNAR, comment créer une classe qui lance des scripts sur demande et une fonction à scripter.
Pour utiliser cette classe, tu créés une instance au début de ton programme, à chaque fois que tu veux lire un script tu utilises la fonction runScript("filename").
Lorsque tu quitte l'application tu détruis l'instance. C'est un exécuteur de script en fait.