Bonjour a tous !

Je poste ce sujet pour vous annoncer que j'ai un problème depuis que j'utilise les template, mais tout d abord voici les partis de mon code qui nous intéressent :

ElementScene.h

#ifndef ELEMENTSCENE_H_INCLUDED
#define ELEMENTSCENE_H_INCLUDED

#include <iostream>
#include <IRR/irrlicht.h>
#include <FMOD/fmod.h>
#include <Newton/Newton.h>

#include "systemFonction.h"
#include "CEventReceiver.h"
#include "GameEngine.h"


class GameEngine;
template <typename T>
class ElementScene
{
public :
	T getNmodele() const
	{
		return m_Nmodele;
	}
	void setPosition(irr::core::vector3df position)
	{
		m_Nmodele->setPosition(position);
	}
protected :
	T m_Nmodele;
    GameEngine* m_scene;
    irr::video::IVideoDriver *m_driver;
    irr::scene::ISceneManager *m_sceneManager;
    irr::gui::IGUIEnvironment *m_gui;
    irr::IrrlichtDevice* m_device;
    irr::scene::IAnimatedMesh* m_modele;
};
typedef ElementScene<irr::scene::ISceneNode*> A;



#endif // ELEMENTSCENE_H_INCLUDED

#ifndef LIQUIDE_H_INCLUDED
#define LIQUIDE_H_INCLUDED

#include <iostream>
#include <IRR/irrlicht.h>
#include <FMOD/fmod.h>
#include <Newton/Newton.h>

#include "systemFonction.h"
#include "CEventReceiver.h"
#include "GameEngine.h"
#include "ElementScene.h"

class GameEngine;
class Liquide : public ElementScene<irr::scene::ISceneNode*>
{
public :
    Liquide();
    Liquide(GameEngine* scene, char* chemin_texture, irr::core::vector3df position, irr::core::vector3df rotation, long echelle, irr::f32 height, irr::f32 speed, irr::f32 lenght);
	~Liquide();
private :

};

#endif // LIQUIDE_H_INCLUDED

As-tu fait d'autres class dérivées de ton template ? elles mêmes castées en ISceneNode ? Et ça fonctionne?
Il me semble que la redéfinition de setPosition() est dangereuse si tu cast en ISceneNode (conflit).
Essaye peut-être de chager le nom ..
En plus le template est assez dangereux dans ton cas : que se passerait-il si tu castait en en autre chose qu'un ISceneNode ?

m_Nmodele->setPosition(position);

Oui j'ai fait d'autres class dérivé de ElementScene mais castées en IAnimatedMeshSceneNode, mais la non plus, ça ne marche pas.
J'ai changé le nom en setPositionement mais cela ne marche toujours pas.
Voici comment j'appelle la fonction setPositionement() :

scene->getTableauLiquide(0)->setPositionement(irr::core::vector3df(0,50,0));

tu ne doit pas utiliser "public ElementScene<irr::scene::ISceneNode*>" mais plutôt

template <typename T>
class Liquide : public ElementScene<T>

enfin c'est se genre de syntaxe que j'utiliserais après je n'en sais rien
tien d'ailleurs il en parle ici http://www.velocityreviews.com/forums/t291114-derivation-of-a-template-class.html

sinon pourquoi passer par des templates dans cette situation .... tout se que tu as besoins normalement se trouve dans ISceneNode ...

édit : j'avais pas tout lus ... donc oui la syntaxe ses ça ... mais est tu sur que le c++ reconnaisse le type que tu lui donne ?
je veut dire par la les templates sont utiliser pour les variables mais pas trop pour les pointeur excepter les concaténation ou les lists étant donner qu'a la déclaration 'T' peut-être n'importe quoi, ainsi il n'est connue qua la création de la class être peut être "utiliser" que pour des opération de pointeur ( delete/new/memcopy .... )

Magun->J'ai suivis ce que tu a dis, voici le nouveau code.

#ifndef ELEMENTSCENE_H_INCLUDED
#define ELEMENTSCENE_H_INCLUDED

#include <iostream>
#include <IRR/irrlicht.h>
#include <FMOD/fmod.h>
#include <Newton/Newton.h>

#include "systemFonction.h"
#include "CEventReceiver.h"
#include "GameEngine.h"

class GameEngine;

template <typename T>
class ElementScene
{
public :
	T* getNmodele() const
	{
		return m_Nmodele;
	}
	void setPositionement(irr::core::vector3df position)
	{
		m_Nmodele->setPosition(position);
	}
protected :
	T* m_Nmodele;
    GameEngine* m_scene;
    irr::video::IVideoDriver *m_driver;
    irr::scene::ISceneManager *m_sceneManager;
    irr::gui::IGUIEnvironment *m_gui;
    irr::IrrlichtDevice* m_device;
    irr::scene::IAnimatedMesh* m_modele;
};

#endif // ELEMENTSCENE_H_INCLUDED

je pensse que tu n'a pas vraiment comprit se que je disais tu ne peut pas utiliser les templates dans ce contexte
par exmples :

en math tu a une variable inconue 'x' ( int x; )
tu ne peut pas connaitre 'x' ( cout << x; te renverras alors un chiffre "aléatoire" )

donc en gros tu essaye de faire des operation "direct" sur un pointeur inconue bien que sont adresse memoire soit connue sont type ne les pas
se que tu as fait ne change rien ... tu utilise toujours les pointeur il faut donc que tu cast 'T' ( ((ISceneNode*)m_Nmodele)->fonction ... ) sinon tu ne peut utiliser '->' ou '.'

class GameEngine;

    T* getNmodele() const
    {
        return m_Nmodele;
    }
    void setPositionement(irr::core::vector3df position)
    {
        ((ISceneNode*)m_Nmodele)->setPosition(position);
    }

Oui mais le problème maintenant (ceci est une supposition) c'est que je suis obligé de fonctionner avec un ISceneNode.
En effet j'avais écris une autre class :

#ifndef OBJET_H_INCLUDED
#define OBJET_H_INCLUDED

#include <iostream>
#include <IRR/irrlicht.h>
#include <FMOD/fmod.h>
#include <Newton/Newton.h>

#include "systemFonction.h"
#include "CEventReceiver.h"
#include "GameEngine.h"
#include "ElementScene.h"

class GameEngine;
class Objet : public ElementScene<irr::scene::IAnimatedMeshSceneNode>
{
public :
    Objet();
    Objet(GameEngine* m_scene, char* chemin_modele, char* chemin_texture, irr::core::vector3df position, irr::core::vector3df RotationDegrees, long echelle, Collision collision);
	Objet(GameEngine* m_scene, char* chemin_modele, char* chemin_texture, irr::core::vector3df position, irr::core::vector3df rotationDegrees, long echelle, Collision collision, int animDebut, int animFin);
    ~Objet();
private :

};

#endif // OBJET_H_INCLUDED

#ifndef ELEMENTSCENE_H_INCLUDED
#define ELEMENTSCENE_H_INCLUDED

#include <iostream>
#include <IRR/irrlicht.h>
#include <FMOD/fmod.h>
#include <Newton/Newton.h>

#include "systemFonction.h"
#include "CEventReceiver.h"
#include "GameEngine.h"

class GameEngine;

template <typename T>
class ElementScene
{
public :
	T getNmodele() const
	{
		return m_Nmodele;
	}
	void setPositionement(irr::core::vector3df position)
	{
		((irr::scene::ISceneNode*)m_Nmodele)->setPosition(position);
	}
protected :
	T m_Nmodele;
    GameEngine* m_scene;
    irr::video::IVideoDriver *m_driver;
    irr::scene::ISceneManager *m_sceneManager;
    irr::gui::IGUIEnvironment *m_gui;
    irr::IrrlichtDevice* m_device;
    irr::scene::IAnimatedMesh* m_modele;
};

#endif // ELEMENTSCENE_H_INCLUDED

Dacord avec Magun, tu ne dois pas caster ce genre d'objets, ils sont trop complexes et hérités de nombreuses fois. Je te conseille de refaire des class dérivées de IAnimatedScenenode* qui sera "rétrocompatible" avec un ISceneNode* classique. Mais les templates sont contre-indiqués pour ce que tu veux faire.

TUpac Ecris:

Je te conseille de refaire des class dérivées de IAnimatedScenenode* qui sera "rétrocompatible" avec un ISceneNode* classique.

Si j'ai bien compris tu veux faire des objets dérivés soit de ISceneNode soit de IAnimatedSceneNode. Etant donné que IAnimatedSceneNode est dérivé de ISceneNode, si tu fait une class dérivé de IAnimatedSceneNode tu pourra faire des fonction communes aux deux types. Ca demande pas des masses de taf, t'as juste les entêtes à modifier.

Ben la j'ai toujours pas compris, la dérivation c'est bien ce qui est traité ici (2° partie) ?
C'est un concepts que je n'ai pas encore étudié, je suis un peut perdu, voici ce que je comprend (dit le moi si j'ai tort) :
Tu veut dire par " Etant donné que IAnimatedSceneNode est dérivé de ISceneNode" que IAnimatedSceneNode hérite de ISceneNode".
Et voici ce que je ne comprend pas :
"si tu fait une class dérivé de IAnimatedSceneNode tu pourra faire des fonction communes aux deux types."

Oui c'est tout à fait ça.

ISceneNode -> IAnimatedSceneNode -> MaClassNode
| | | |
| |---------<---------| |
|---------------------------------<-----------|

Si tu crée un IAnimated, tu crée un Iscenenode, y'a rien de compliqué je crois. Donc pas d'interret évident à caster (chager de type) ta class en l'un ou l'autre, il suffit de la créer en IAnim (le plus haut niveau).
Ca prend surement plus de place en mémoire mais c'est pas grave : on est plus sous To7

Le problème c'est que certaines fonctions (addWaterSurfaceSceneNode() par exemple) semblent ne pas accepter les IAnimatedMeshSceneNode.

C'est la que ça devient plus fastidieux je te l'accorde. En tout cas c'est possible (j'ai quand-même tésté pour pas dire de bétises ).

IAnimatedMeshSceneNode* node = (IAnimatedMeshSceneNode*)smgr->addWaterSurfaceSceneNode(... , ... , ...);

Cool, merci je vais tester ça

EDIT : Rhoo, ça marche toujours pas !!!
Toujours un bug ... a la même instruction.

ElementScene.h

#ifndef ELEMENTSCENE_H_INCLUDED
#define ELEMENTSCENE_H_INCLUDED

#include <iostream>
#include <IRR/irrlicht.h>
#include <FMOD/fmod.h>
#include <Newton/Newton.h>

#include "systemFonction.h"
#include "CEventReceiver.h"
#include "GameEngine.h"

class GameEngine;

class ElementScene
{
public :
	irr::scene::IAnimatedMeshSceneNode* getNmodele() const;
	void setPositionement(irr::core::vector3df position);
protected :
	irr::scene::IAnimatedMeshSceneNode* m_Nmodele;
    GameEngine* m_scene;
    irr::video::IVideoDriver *m_driver;
    irr::scene::ISceneManager *m_sceneManager;
    irr::gui::IGUIEnvironment *m_gui;
    irr::IrrlichtDevice* m_device;
    irr::scene::IAnimatedMesh* m_modele;
};

#endif // ELEMENTSCENE_H_INCLUDED

#include "ElementScene.h"

irr::scene::IAnimatedMeshSceneNode* ElementScene::getNmodele() const
{
	return m_Nmodele;
}
void ElementScene::setPositionement(irr::core::vector3df position)
{
	m_Nmodele->setPosition(position);
}

#ifndef LIQUIDE_H_INCLUDED
#define LIQUIDE_H_INCLUDED

#include <iostream>
#include <IRR/irrlicht.h>
#include <FMOD/fmod.h>
#include <Newton/Newton.h>

#include "systemFonction.h"
#include "CEventReceiver.h"
#include "GameEngine.h"
#include "ElementScene.h"

class GameEngine;
class Liquide : public ElementScene
{
public :
    Liquide();
    Liquide(GameEngine* scene, char* chemin_texture, irr::core::vector3df position, irr::core::vector3df rotation, long echelle, irr::f32 height, irr::f32 speed, irr::f32 lenght);
	~Liquide();
private :

};

#endif // LIQUIDE_H_INCLUDED

#include "Liquide.h"

Liquide::Liquide()
{}
Liquide::Liquide(GameEngine* scene, char* chemin_texture, irr::core::vector3df position, irr::core::vector3df rotation, long echelle, irr::f32 height, irr::f32 speed, irr::f32 lenght)
{
    m_scene = scene;
    m_device = scene->getDevice();
    m_driver = m_device->getVideoDriver ();
    m_sceneManager = m_device->getSceneManager();	

	m_modele = m_sceneManager->addHillPlaneMesh( "myHill",
            irr::core::dimension2d<irr::f32>(20,20),
            irr::core::dimension2d<irr::u32>(40,40), 0, 0,
            irr::core::dimension2d<irr::f32>(0,0),
            irr::core::dimension2d<irr::f32>(10,10));
	m_Nmodele = (irr::scene::IAnimatedMeshSceneNode*)m_sceneManager->addWaterSurfaceSceneNode(m_modele->getMesh(0, height, speed, lenght));
    irr::video::ITexture* textureWater = m_driver->getTexture(chemin_texture);
	m_Nmodele->setPosition(position);
	m_Nmodele->setRotation(rotation);
	m_Nmodele->setScale(irr::core::vector3df(echelle,echelle,echelle));
	m_Nmodele->setMaterialTexture(0, textureWater);
	m_Nmodele->getMaterial(0).MaterialType = irr::video::EMT_TRANSPARENT_ALPHA_CHANNEL;
}
Liquide::~Liquide(){}

très bizzard !! t'as éssayé de rendre to m_Nmodele public ? normalement y'a pas de raison. En tout cas ton organisation est bien bonne.

oui, j'ai essayé mais y a pas moyen, ça ne marche pas

Tu as débugué? c'est quoi l'insulte que te lance le compilateur ?

le plus simple reste de nous passer un code minimal avec l`erreur en qestion ..
mais je ne peut t`aider que le weekend

surtout que l`on t`aide depuis le debut sant connaitre ton erreur

Ben le mieux c'est que j'envoie l'archive complète de mon projet comme ça je suis sure de rien oublier. télécharger
Sinon, voici l'insulte du compilo :

Exception de première chance à 0x009cf0d3 dans Jeu1.exe : 0xC0000005: Violation d'accès lors de la lecture de l'emplacement 0xcccccccc.
Exception non gérée à 0x009cf0d3 dans Jeu1.exe : 0xC0000005: Violation d'accès lors de la lecture de l'emplacement 0xcccccccc.

Oki ça sera bien plus simple je regarde ...
Ceci dit l'insulte ici c'est plutôt : "Mais t'es fous ou quoi !! je n'ai pas le droit de lire cet emplacement mémoire"

après test :
Bon j'ai lancé ton jeu aprè avoir téléchargé 200 mo de libs :p
Le jeu fonctionne bien mais je n'ai pas vu de Liquide déclaré ...
J'en ai fait un à la vas-vite dans le main et la mon compilateur me dit : "La classe Liquide n'as pas de constructeur" !!!! lol
J'vais bosser j'y retourne ce soir a+

le Liquide est déclaré ligne 234 de actionEvent.cpp (en fait il est vraiment déclaré dans gameEngine.cpp mais la fonction ajouterLiquide() crée un liquide et revoie un Liquide*)
il est utilisé ligne 265 de actionEvent.cpp
Il est appelé quand tu parle au PNJ de droite (pour la deuxième fois je crois).

On ne peut pas déclarer de Liquide, d'Objet, de Personnage, de CEventReceiver ou bien d'Event sans paramètre (en fait les constructeur par défaut sont juste la pour éviter les message d'erreur du compilo)

Les commandes du jeu sont:
z : avancer
s: reculer
q: tourner a gauche
d: tourner a droite
space: sauter (mon système de saut n'est pas encore tout a fait au point mais pour les tests, je m'en contente)
enter: interagir avec un PNJ
flèche haut: déplacer la caméra vers le haut
flèche bas: déplacer la caméra vers le bas
p: afficher le menu
Je crois que c'est tout

ça compile avec la version 1.6 de irrlicht et fmod

Si tu a besoin d'autre chose, demande moi.
Merci pour ton aide

J'ai utilisé le constructeur avec tout les paramêtres. C'est surement un problème de surcharge.

Bon ben c'est un vrai casse tête ton truc ! Peut-être une piste, cette ligne me pose problème à l'execution.

Event.cpp l-19

m_modele = (irr::scene::IAnimatedMeshMD2*)m_sceneManager->getMesh(chemin_modele);

Bon OK, j'avoue mon code est pas super clair.

Alors la class principale c'est GameEngine, elle gère beaucoup de chose et toutes les autres class en ont besoin pour fonctionner (a part Personnage).
Après il y a la class CEventReceiver qui elle, gère les évenement et les mise a jours de la scène (mise a part les PNJ).
Les class Liquide et Objet gèrent les objets du décor, elles héritent de ElementScene (c'est cette partie que j'ai pas arrête de poster et modifier le long de ce topic).
Dans les fichiers systemFonction, il y a des structures et des fonctions mais je ne pense pas que tu ai besoin de t'en servir.
Après il y a la class qui gère les PNJ c' est Event (c'est vrai ça peut prêter confusion avec CEventReceiver, c'est le therme de RPG Maker).
Chaque objet de type Event a un pointeur sur fonction qui défini ce qu'il fait quand on lui parle, ces fonctions sont dans actionEvent, elles sont inclus dans le boucle principale.
Pour ajouter un Liquide ou un objet, j'ai créé des méthodes dans le GameEngine : ajouterLiquide et ajouterObjet, ces fonctions créent un Liquide ou un Objet et renvoi un pointeur sur ce qui a été créé.
Comme je te l'ai dis précédemment, le Liquide est déclaré ligne 234 de actionEvent.cpp et il est utilisé a la ligne 265 du même fichier.
Ces fonctions sont dans actionEvent donc elles sont donc pointé par un Event et inclus dans la boucle principal.
La fonction ajouterLiquide est appelé quand tu parle au PNJ de droite pour la deuxième fois et sa méthode setPositionement est appelé quand tu lui parle pour la troisième fois.

Voila, si tu ne comprend toujours pas, dis le moi.