Discussion :

[Invité]

Bonjour, ou bonsoir

Voila, je bosse actuellement sur un petit projet de jeux vidéo, et j'ai un soucis :

J'ai une architecture de classe qui est faite de façon à être le plus modulaire possible :
J'ai notamment la classe "MessageBox", qui est une classe abstraite qui donne la possibilité aux objets de communiquer entre eux, du genre :

La classe IObject hérite de MessageBox, mais aussi la classe Listener, qui récupère les entrées utilisateurs

Donc la classe GraphicsEngine est une classe qui hérite de la classe Engine, qui hérite de IObject.

Voila le problème : tout compile parfaitement, mais au moment du linkage, il y a une erreur parlant de la classe "MessageBoxA". Or, cette classe n'existe tout simplement pas...

Les erreurs se situent dans le fichier GraphicsEngine.o, et les voici :

Code :

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

1
2
3
4
5
6
 
||=== Build: Debug in JV (compiler: GNU GCC Compiler) ===|
obj\Debug\Sources\Engine\GraphicsEngine.o:GraphicsEngine.cpp:(.rdata$_ZTV14GraphicsEngine[__ZTV14GraphicsEngine]+0x10)||undefined reference to `MessageBoxA::send_message(MessageBoxA*, Message&)'|
obj\Debug\Sources\Engine\GraphicsEngine.o:GraphicsEngine.cpp:(.rdata$_ZTV14GraphicsEngine[__ZTV14GraphicsEngine]+0x14)||undefined reference to `MessageBoxA::receive_message(Message&)'|
obj\Debug\Sources\Engine\GraphicsEngine.o:GraphicsEngine.cpp:(.rdata$_ZTV14GraphicsEngine[__ZTV14GraphicsEngine]+0x18)||undefined reference to `MessageBoxA::process_queue()'|
||=== Build failed: 3 error(s), 0 warning(s) (0 minute(s), 22 second(s)) ===|

Voici le code de ma classe MessageBox :
.h

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
#ifndef MESSAGEBOX_H
#define MESSAGEBOX_H
 
#include <string>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/map.hpp>
#include <boost/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <OgreVector3.h>
 
/// \class Message
/// contiend des structures de données utiles pour les messages inter_objets
 
struct Message{
    std::string nom;
    std::map<std::string, int> i_values;
    std::map<std::string, bool> b_values;
    std::map<std::string, std::string> s_values;
    std::map<std::string, float> f_values;
//    std::map<std::string, Ogre::Vector3> v_values;
 
    bool operator==(const Message&);
    template<typename Archive>
    void serialize(Archive& ar, const unsigned int){
        ar & BOOST_SERIALIZATION_NVP(i_values);
        ar & BOOST_SERIALIZATION_NVP(b_values);
        ar & BOOST_SERIALIZATION_NVP(s_values);
        ar & BOOST_SERIALIZATION_NVP(f_values);
//        ar & BOOST_SERIALIZATION_NVP(v_values);
        ar & BOOST_SERIALIZATION_NVP(nom);
 
    }
};
 
 
class MessageBox
{
    public:
        MessageBox();
        virtual ~MessageBox();
 
        virtual void send_message(MessageBox*, Message&);
        virtual void receive_message(Message&);
        virtual void process_queue();
        virtual void process_message(Message&) = 0;
 
        std::string reportMessage(Message& m);
    protected:
        std::queue<Message> _messages;
        boost::mutex _queue_mutex;
};
 
#endif // MESSAGEBOX_H

.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
35
36
37
38
39
40
41
42
43
44
45
46
 
#include "MessageBox.hpp"
 
MessageBox::MessageBox()
{
    //ctor
}
 
MessageBox::~MessageBox()
{
    //dtor
}
 
void MessageBox::receive_message(Message& m){
	_messages.push(m);
}
 
void MessageBox::send_message(MessageBox* to, Message& m){
	to->receive_message(m);
}
 
void MessageBox::process_queue(){
	_queue_mutex.lock();
	while(!_messages.empty()){
		Message m;
		m = _messages.front();
		_messages.pop();
		process_message(m);
	}
	_queue_mutex.unlock();
}
 
std::string MessageBox::reportMessage(Message& m){
    std::ostringstream stream;
    boost::archive::text_oarchive ar(stream);
    ar << m;
    return stream.str();
}
 
bool Message::operator==(const Message &m){
    return (nom == m.nom \
            && i_values == m.i_values \
            && b_values == m.b_values \
            && s_values == m.s_values \
            && f_values == m.f_values);
}

Et le code de ma classe GraphicsEngine (la classe Engine hérite de IObject, qui hérite de MessageBox)

.h

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
35
36
37
 
#ifndef GRAPHICSENGINE_H
#define GRAPHICSENGINE_H
 
#include <iostream>
#include <Ogre.h>
#include <CEGUI.h>
#include <RendererModules\Ogre\CEGUIOgreRenderer.h>
#include "Engine.hpp"
#include "../Graphics/WindowListener.hpp"
#include "../Graphics/GUIListener.hpp"
 
class GraphicsEngine : public Engine {
    public:
        GraphicsEngine(Game*);
        virtual ~GraphicsEngine();
        void initialise();
        void frame();
        void process_message(Message&);
        void createScene();
        void createViewport();
        void createFrameListener();
    private:
        std::map<std::string, Listener*> _listeners;
 
        CEGUI::OgreRenderer* _renderer;
 
        Ogre::Root* _root;
        Ogre::RenderWindow *_window;
        Ogre::SceneManager *_sceneMgr;
        Ogre::Viewport *_viewport;
 
        Ogre::Camera *_camera;
 
};
 
#endif // GRAPHICSENGINE_H

.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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
#include "GraphicsEngine.hpp"
#include "../Game.hpp"
 
GraphicsEngine::GraphicsEngine(Game* g) : Engine(g), _root(nullptr), _window(nullptr), _sceneMgr(nullptr),
    _viewport(nullptr), _camera(nullptr){
    initialise();
}
 
GraphicsEngine::~GraphicsEngine(){
    JLog << std::string("Debut destuction GraphicsEngine");
    delete _root;
    JLog << std::string("Fin destuction GraphicsEngine");
}
 
void GraphicsEngine::initialise(){
    _root = new Ogre::Root("plugins.cfg", "ogre.cfg", "Ogre.log");
 
    Ogre::ConfigFile configFile;
    configFile.load("resources.cfg");
 
    Ogre::ConfigFile::SectionIterator seci = configFile.getSectionIterator();
    Ogre::String secName, typeName, archName;
 
    while(seci.hasMoreElements()){
        secName = seci.peekNextKey();
        Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext();
        Ogre::ConfigFile::SettingsMultiMap::iterator i;
        for(i = settings->begin(); i != settings->end(); ++i){
            typeName = i->first;
            archName = i->second;
            Ogre::ResourceGroupManager::getSingleton().addResourceLocation(archName, typeName, secName);
        }
    }
    if(!(_root->restoreConfig() || _root->showConfigDialog())){
        throw Erreur("Chargement de la config", "Erreur lors du chargement de la configuration du moteur graphique", Tools::CRITICAL);
    }
    _window = _root->initialise(true, "Hello World");
 
    Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);
    Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
 
    _sceneMgr = _root->createSceneManager("DefaultSceneManager", "Mon ScnMgr");
    _sceneMgr->setAmbientLight(Ogre::ColourValue(1.0f, 1.0f, 1.0f));
 
    createScene();
    createViewport();
    createFrameListener();
}
 
void GraphicsEngine::createFrameListener(){
    _listeners["Window"] = new WindowListener(_window);
    _listeners["GUI"] = new GUIListener(_window);
 
    for(auto p : _listeners){
        _root->addFrameListener(p.second);
    }
}
 
void GraphicsEngine::createScene(){
    _camera = _sceneMgr->createCamera("PlayerCam");
    _camera->setPosition(Ogre::Vector3(0,0,100));
    _camera->lookAt(Ogre::Vector3(0,0,0));
    _camera->setNearClipDistance(5);
 
//    Ogre::Light *light = _sceneMgr->createLight("Lum");
//    light->setType(Ogre::Light::LT_POINT);
//    light->setPosition(0, 0, 100);
}
 
void GraphicsEngine::createViewport(){
    _viewport = _window->addViewport(_camera);
    _viewport->setBackgroundColour(Ogre::ColourValue(0, 0, 1.0f));
    _camera->setAspectRatio(Ogre::Real(_viewport->getActualWidth())/Ogre::Real(_viewport->getActualHeight()));
}
 
void GraphicsEngine::process_message(Message& mes){
    if(mes.nom == "afficherModele"){
        std::string nom = mes.s_values["nom"];
        Ogre::SceneNode* node = nullptr;
        if(mes.s_values["parent"] == "root"){
            node = _sceneMgr->getRootSceneNode()->createChildSceneNode((nom+"Node"));
        }else{
            node = _sceneMgr->getSceneNode(mes.s_values["parent"])->createChildSceneNode((nom+"Node"));
        }
        Ogre::Entity *ent = _sceneMgr->createEntity((nom + "Ent"), (nom + ".mesh"));
        node->attachObject(ent);
    }else if(mes.nom == "placerPlan"){
    }else{
    }
}
 
void GraphicsEngine::frame(){
    Ogre::WindowEventUtilities::messagePump();
    if(!_root->renderOneFrame() || _window->isClosed()/* || !_root->_updateAllRenderTargets()*/){
        Message m;
        m.nom = "stop";
        send_message(_parent, m);
    }
    process_queue();
}

Voila... quelqu'un aurait une solution à mon problème ?

Merci d'avance !