Qasari: Vim-like mode

J'y tiens beaucoup, mais Qasari sera "hackable", un logiciel pour les hackers, on s'en tape des industriels au départ qui ont du fric à balancer dans des machines, nous on fait du prototype dans des tipis à la base, une autre mentalité, l'intérêt est de proposer un logiciel ou l'utilisateur est libre de faire ce qu'il veut avec et le personnaliser comme bon lui semble sans les regles des industriels, un outil tel que Vim ou Nyxt. Donc on fait un peu de retro-ingénierie sur ces logiciels et leurs fonctionnement pour apprendre à intégrer des fonctionnalités. Donc au boulot.

Ce que propose chatGPT 3.5 quand on lui demande une solution:

Créer un logiciel de CAO "hackable" en mode vim-like est une excellente idée pour offrir une interface personnalisable et puissante aux utilisateurs avancés. Voici un plan pour développer un tel logiciel, en intégrant des concepts de Vim et en utilisant les outils modernes de développement.

Plan de Développement d'un Logiciel de CAO Vim-like

1. Choix des Outils et Bibliothèques

Langage : C++ pour ses performances et son écosystème riche.
Interface Utilisateur : Utilisez une combinaison de GLFW pour la gestion des fenêtres et ImGui pour une interface utilisateur personnalisable et interactive.
Rendu 3D : OpenGL ou Vulkan pour le rendu des modèles 3D.
Scriptability : Intégrez Lua pour permettre aux utilisateurs d'écrire des scripts et de personnaliser le comportement du logiciel.
Plugins et Extensibilité : Support pour les plugins avec une API claire.
Configuration et Gestion des Dépendances : Utilisez CMake pour la configuration du projet et Conan pour la gestion des dépendances.

2. Architecture du Projet

Core : Gestion des fonctionnalités principales (chargement de fichiers, rendu, manipulations géométriques).
UI : Interface utilisateur en mode vim-like avec des commandes et des mappings personnalisables.
Scripting : Intégration de Lua pour la personnalisation et l'extension des fonctionnalités.
Plugins : Infrastructure pour les plugins afin de permettre des extensions tierces.

3. Structure du Répertoire

MyCaoProject/
├── CMakeLists.txt
├── conanfile.txt
├── include/
│   └── mycaoproject/
│       ├── core/
│       │   ├── renderer.h
│       │   ├── model.h
│       │   └── ...
│       ├── ui/
│       │   ├── vimlikeui.h
│       │   └── ...
│       ├── scripting/
│       │   ├── luascripting.h
│       │   └── ...
│       └── plugins/
│           ├── plugininterface.h
│           └── ...
├── src/
│   ├── core/
│   │   ├── renderer.cpp
│   │   ├── model.cpp
│   │   └── ...
│   ├── ui/
│   │   ├── vimlikeui.cpp
│   │   └── ...
│   ├── scripting/
│   │   ├── luascripting.cpp
│   │   └── ...
│   └── plugins/
│       ├── plugininterface.cpp
│       └── ...
├── scripts/
│   ├── init.lua
│   └── ...
└── build/

4. Configuration de CMake

Voici un exemple de fichier CMakeLists.txt pour configurer votre projet avec CMake et Conan :

cmake_minimum_required(VERSION 3.10)
project(MyCaoProject)

# Définir le standard C++
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED True)

# Inclure Conan
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
conan_basic_setup()

# Inclure les répertoires des headers
include_directories(${CMAKE_SOURCE_DIR}/include)

# Ajouter tous les fichiers sources
file(GLOB_RECURSE SOURCES "src/*.cpp")

# Créer l'exécutable
add_executable(myapp ${SOURCES})
target_link_libraries(myapp ${CONAN_LIBS})

5. Intégration de Lua pour le Scripting

Ajoutez Lua et les autres dependances dans votre conanfile.txt :

[requires]
glfw/3.3.4
imgui/1.84.2
vulkan-loader/1.2.154
glm/0.9.9.8
assimp/5.0.1
eigen/3.3.9
boost/1.75.0
lua/5.3.5

[generators]
cmake

Et configurez l'intégration de Lua dans votre projet :

// luascripting.cpp
extern "C" {
#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"
}

void executeLuaScript(const std::string& script) {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);

    if (luaL_dofile(L, script.c_str())) {
        std::cerr << "Failed to execute script: " << lua_tostring(L, -1) << std::endl;
    }

    lua_close(L);
}

6. Développement de l'Interface Vim-like

Pour développer une interface utilisateur en mode Vim-like, vous pouvez utiliser des concepts de modes (normal, insert, visual, etc.) et des commandes inspirées de Vim :

// vimlikeui.cpp
#include <iostream>
#include <map>

enum Mode { NORMAL, INSERT, VISUAL };

class VimLikeUI {
public:
    VimLikeUI() : currentMode(NORMAL) {
        // Initialiser les commandes
        commands["q"] = [this]() { quit(); };
        commands["i"] = [this]() { switchMode(INSERT); };
        // Ajouter d'autres commandes
    }

    void handleInput(const std::string& input) {
        if (commands.find(input) != commands.end()) {
            commands[input]();
        } else {
            std::cout << "Unknown command: " << input << std::endl;
        }
    }

    void switchMode(Mode mode) {
        currentMode = mode;
        std::cout << "Switched to mode: " << (mode == NORMAL ? "NORMAL" : mode == INSERT ? "INSERT" : "VISUAL") << std::endl;
    }

    void quit() {
        std::cout << "Quitting..." << std::endl;
        // Implémenter la logique de sortie
    }

private:
    Mode currentMode;
    std::map<std::string, std::function<void()>> commands;
};

7. Plugins et Extensibilité

Créez une interface pour les plugins et chargez-les dynamiquement :

// plugininterface.h
class PluginInterface {
public:
    virtual ~PluginInterface() = default;
    virtual void initialize() = 0;
    virtual void execute() = 0;
};

// pluginmanager.cpp
#include <vector>
#include <memory>

class PluginManager {
public:
    void loadPlugins() {
        // Chargez et initialisez les plugins
    }

    void executePlugins() {
        for (auto& plugin : plugins) {
            plugin->execute();
        }
    }

private:
    std::vector<std::unique_ptr<PluginInterface>> plugins;
};

Voici un exemple de fichier main.cpp qui assemble les différentes parties de votre projet de CAO "hackable" en mode vim-like, incluant l'intégration des différents modules que nous avons discutés (Core, UI, Scripting, Plugins).

#include <iostream>
#include <string>
#include "mycaoproject/core/renderer.h"
#include "mycaoproject/core/model.h"
#include "mycaoproject/ui/vimlikeui.h"
#include "mycaoproject/scripting/luascripting.h"
#include "mycaoproject/plugins/plugininterface.h"

int main(int argc, char* argv[]) {
    // Initialiser le moteur de rendu
    Renderer renderer;
    renderer.initialize();

    // Charger un modèle 3D
    Model model;
    model.loadFromFile("path/to/your/model.obj");

    // Initialiser l'interface utilisateur en mode vim-like
    VimLikeUI vimUI;

    // Initialiser le gestionnaire de plugins
    PluginManager pluginManager;
    pluginManager.loadPlugins();

    // Lancer une boucle principale simple
    std::string input;
    while (true) {
        std::cout << "Enter command: ";
        std::cin >> input;

        if (input == "q") {
            break;
        }

        vimUI.handleInput(input);

        // Exécuter les plugins
        pluginManager.executePlugins();

        // Rendre le modèle
        renderer.render(model);
    }

    // Exécuter un script Lua si fourni en argument
    if (argc > 1) {
        std::string scriptPath = argv[1];
        executeLuaScript(scriptPath);
    }

    // Nettoyer et quitter
    renderer.cleanup();
    return 0;
}

Conclusion

En suivant ces étapes, vous pouvez commencer à développer un logiciel de CAO "hackable" avec une interface en mode Vim-like. Ce type de logiciel offrira une grande flexibilité et une personnalisation poussée pour les utilisateurs avancés. En intégrant des outils modernes et des concepts de développement avancés, vous serez en mesure de créer un produit innovant et puissant. Bonne chance avec votre projet !