Bonjour,

Je débute avec Irrlicht. J'essaye de créer une classe héritant de ISceneNode pour pouvoir gérer des déplacements plus facilement.
Seulement le compilateur renvoie une belle erreur lors de la compilation (qui se fait sous Linux). Si j'ai bien compris ce qu'il raconte, c'est parce que la classe MySceneNode est abstraite... alors qu'elle hérite de ISceneNode qu'on peut tout à fait instancier oO

Je met ici juste une fraction de mon code, le reste des méthodes présentes pour le moment dans la classe est quasi indentique à avanceX.

L'erreur :

main.cpp: In function ‘int main()’:
main.cpp:142: erreur: cannot allocate an object of abstract type ‘MySceneNode’
MonVolume.h:10: note:   because the following virtual functions are pure within ‘MySceneNode’:
../include/ISceneNode.h:133: note:      virtual void irr::scene::ISceneNode::render()
../include/ISceneNode.h:168: note:      virtual const irr::core::aabbox3d<float>& irr::scene::ISceneNode::getBoundingBox() const

MySceneNode * node = new MySceneNode(smgr->addSphereSceneNode(30.f));

#ifndef DEF_MYSCENENODE
#define DEF_MYSCENENODE

#include <irrlicht.h>
#include <iostream>

using namespace irr;

class MySceneNode : public irr::scene::ISceneNode
{
	public:

	MySceneNode(ISceneNode * parent,
			     scene::ISceneManager *  mgr,
			     s32  				   id,
		             const core::vector3df & position,
			     const core::vector3df & rotation,
			     const core::vector3df & scale);

	MySceneNode(scene::ISceneNode *);

	~MySceneNode();

	void avanceX(s32 avance);
};

#endif

#include "MonVolume.h"


using namespace irr;

MySceneNode::MySceneNode(	scene::ISceneNode * parent,
						scene::ISceneManager * mgr,
						s32  	id = -1,
						const core::vector3df &  	position = core::vector3df(0,0,0),
						const core::vector3df &  	rotation = core::vector3df(0,0,0),
						const core::vector3df &  	scale = core::vector3df(1.0f, 1.0f, 1.0f)) : irr::scene::ISceneNode::ISceneNode(parent,mgr,id,position,rotation,scale)
{
}

MySceneNode::MySceneNode(scene::ISceneNode * node)
{
	MonVolume(node->getParent(),
			 node->getSceneManager(),
			 node->getID(),
			 node->getPosition(),
			 node->getRotation(),
			 node->getScale())
}

MySceneNode::~MySceneNode()
{
}

void MySceneNode::avanceX(s32 avance)
{
	core::vector3df nodePos = getPosition();
	nodePos.X += avance;
	setPosition(nodePos);
}

En fait, le problème que tu as est très simple.

La classe ISceneNode est abstraite, comme toutes les classes d'Irrlicht qui commence par un I (I = Interface)
Cette classe a donc un certain nombre de fonctions qui sont virtuelles pures. Quand tu définis qui dérive de ISceneNode, tu dois impérativement redefinir ces fonctions, de telles sortes à ce qu'elles ne soient plus virtuelles pures.

Je pense que pour corriger ce problème, tu dois avoir dans ton header :

#ifndef DEF_MYSCENENODE
#define DEF_MYSCENENODE

#include <irrlicht.h>
#include <iostream>

using namespace irr;

class MySceneNode : public irr::scene::ISceneNode
{
    public:

    MySceneNode(ISceneNode * parent,
                 scene::ISceneManager *  mgr,
                 s32                     id,
                     const core::vector3df & position,
                 const core::vector3df & rotation,
                 const core::vector3df & scale);

    MySceneNode(scene::ISceneNode *);

    ~MySceneNode();

    /*Ici tu redéfinies la méthode render de ISceneNode. Elle est virtuelle, au cas où tu veux redériver encore ta classe, mais ce n'est pas obligatoire.*/
    virtual void render();

    /*De même, ici tu redéfinies la méthode getBoundingBox(). */
    virtual const irr::core::aabbox3d<float>& getBoundingBox() const;

    void avanceX(s32 avance);
};

#endif

Merci pour la rapidité de la réponse. Je ne connaissais pas la signification du "I" devant le nom de la classe, pour moi ca voulait juste dire "Irrlicht".

Effectivement, c'est tout bête. Pourtant cela m'étonne. Avant de créer cette classe, j'instanciais un objet de type ISceneNode dans mon main et ca fonctionnait parfaitement :

scene::ISceneNode * node = smgr->addSphereSceneNode(30.f);

main.cpp:142: erreur: cannot allocate an object of abstract type «MySceneNode»
MonVolume.h:10: note:   because the following virtual functions are pure within «MySceneNode»:
MonVolume.h:25: note:   virtual void MySceneNode::render()
MonVolume.h:28: note:   virtual const irr::core::aabbox3d<float>& MySceneNode::getBoundingBox() const

void render();
const core::aabbox3d<f32>& getBoundingBox() const;

void MySceneNode::render()
{
	video::IVideoDriver* driver = SceneManager->getVideoDriver();

	if (Mesh && driver)
	{
		driver->setMaterial(Mesh->getMeshBuffer(0)->getMaterial());
		driver->setTransform(video::ETS_WORLD, AbsoluteTransformation);
		driver->drawMeshBuffer(Mesh->getMeshBuffer(0));
		if ( DebugDataVisible & scene::EDS_BBOX )
		{
			video::SMaterial m;
			m.Lighting = false;
			driver->setMaterial(m);
			driver->draw3DBox(Mesh->getMeshBuffer(0)->getBoundingBox(), video::SColor(255,255,255,255));
		}
	}
}

const core::aabbox3d<f32>& MySceneNode::getBoundingBox() const
{
	return Mesh ? Mesh->getBoundingBox() : Box;
}

En fait, tu n'instancies jamais un ISceneNode, tu instancies toujours un objet dérivé du ISceneNode (Un CSphereSceneNode par exemple, C voulant dire Concrete, je pense), mais le SceneManager d'irrlicht te renvoie un pointeur vers la super classe (ISceneNode), ce qui peut te permettre, par exemple, de stocker dans un tableau tous les pointeurs vers tes nodes, peut importe le type.
Essaie d'instancier autrement un ISceneNode, par exemple de cette manière :

ISceneNode scenenode(); //Avec les bons arguments quand même, là je ne les ai pas en tête

• A quoi doit servir ton sceneNode ?
• A quoi il va ressembler, une fois rendu dans ton environnement 3D ? (un cube, une sphere, rien, un mesh ?)

Mwai, je me disais bien que j'avais fait une erreur bête...
Je voulais que mon sceneNode puisse se déplacer et tourner dans son propre repère x-y-z, et non par rapport à un repère absolu fixe dans l'environnement (je ne suis pas très clair sans doute). Ce sceneNode est un mesh.

Ce que j'ai jusqu'à présent est un node qui se déplace suivant x-y, avec les touches ZQSD, ce qui pose certains problèmes d'orientation. Mais je me suis rendu compte hier soir que en fait je m'embête à créer ma propre classe peut être pour rien parce que en fait je n'ai pas essayé de faire tourner mon node... et si ca se trouve cela résoudrait mon problème actuel.

Je teste ca dès que j'ai trouvé comment faire tourner Irrlicht sous Windoze, mon Linux est sans internet en ce moment et c'est assez problèmatique

Mais créer MySceneNode (MyMeshSceneNode ?) serait sans doute intéressant pour la suite. (Et même si ca ne me sert pas, au moins j'aurai eu ma vengeance sur cette classe !)

Tiens ! c'est bizzard. d'habitude c'est winbouze qui tombe en panne de net

En ce qui concerne les déplacements et rotation d'un Node, quand tu utilise setRotation/setPosition, tu changes l'orientation/la position de ton node par rapport à son père. Si son père est 0, ou root, alors c'est dans le repère absolu de ton monde 3D.

Ensuite, vu que ton node est un Mesh, je te conseille de faire dériver ta classe de IMeshSceneNode (voire de IAnimatedMeshSceneNode), pour pouvoir appelé render et getBoundingBox de la classe mère.

void MySceneNode::render()
{
    IMeshSceneNode::render();
}

const core::aabbox3d<f32>& MySceneNode::getBoundingBox() const
{
    return IMeshSceneNode::getBoundingBox();
}

yep render et getboundingbox sont virtual. Les IAnimatedMeshSceneNode sont bien cool car on peut y mettre ce qu'on veut : static ou animé. Reste à voir si c'est plus gourmand mais j'en doute.