Bonjour. J'ai un objet drone auquel j'ai attaché une caméra, qui se trouve en fait pas au centre du drone mais un peut en avant pour voir l'extérieur (sinon on verrai l'intérieur du drone). J'ai mis en place une gestion des collisions entre mon décor et mon drone. Tout va bien, sauf lorsqu'il y a collision avec l'arrière du drone. Dans ce cas, la caméra se retrouve à l'intérieur du drone. Voici le code de ma classe (ce qui nous intéresse ici).

#include "stdafx.h"
#include <irrlicht.h>
#include <iostream>
#include <windows.h>
#include <tchar.h>
#include <vector>
#include <exception>
#include <fstream>
#include <string>
#include "Drone.h"

using namespace irr;
using namespace std;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;
using namespace nsSimulateur;

//#pragma comment(lib, "Irrlicht.lib")

#define DRONE nsSimulateur::Drone

DRONE::Drone (char * FichierDrone /*= "drone.x"*/, ISceneManager * Smgr /*=0*/,
	const vector3df PositionInitiale /*= vector3df(0,0,0)*/ )
{
	m_FichierDrone = FichierDrone ;
	m_MeshDrone = Smgr->getMesh(FichierDrone) ;
	m_Drone = Smgr-> addAnimatedMeshSceneNode (m_MeshDrone) ;
	m_Drone->setMaterialFlag(EMF_LIGHTING, false) ; 
	m_Drone->setPosition (PositionInitiale) ;
	m_Drone->setScale (vector3df (0.05f, 0.1f, 0.05f)) ;
	m_Drone->setAnimationSpeed (100.0f) ;
	m_Drone->setFrameLoop (1, 13) ;

	m_Camera = Smgr->addCameraSceneNodeFPS(0, 0, 0);
	m_Camera->setPosition(vector3df (PositionInitiale.X, PositionInitiale.Y + 1.0f, PositionInitiale.Z + 7.0f ));

	m_Angle = 0 ;
	m_Zoom = 1 ;

} // Drone ()

void DRONE::MoveDrone (float RotationX /*=0*/, float RotationY /*=0*/, float RotationZ /*=0*/, 
	float PositionX /*=0*/, float PositionY /*=0*/, float PositionZ /*=0*/)
{
		m_Drone->setPosition (vector3df(PositionX, PositionY, PositionZ) );
		m_Drone->setRotation (vector3df(RotationX, RotationY, RotationZ) );


		float vrRadY = -RotationY / 180 * 3.141592654f;
		float CosTargetX = cos (vrRadY + (3.14f/2.0f));
		float SinTargetZ = sin (vrRadY + (3.14f/2.0f));
		float PasX = (CosTargetX * 7.0f) ;
		float PasZ = (SinTargetZ * 7.0f) ;

		MoveCamera (RotationX, RotationY, RotationZ, m_Angle, PositionX + PasX, PositionY + 1.0f, PositionZ + PasZ);		
} // MoveDrone ()


IAnimatedMeshSceneNode * DRONE::GetDrone (void) const
{
	return m_Drone ;
} // GetDrone ()

void DRONE::MoveCamera (float RotationX /*=0*/, float RotationY /*=0*/, float RotationZ /*=0*/, float RotationInterne /*=0*/,
	float PositionX /*=0*/, float PositionY /*=0*/, float PositionZ /*=0*/)
{
		m_Camera->setPosition(vector3df (PositionX, PositionY, PositionZ));

		vector3df rotation = vector3df(RotationInterne, 0, 0); 
		m_Camera->getAbsoluteTransformation().rotateVect(rotation);
		m_Camera->setRotation(vector3df(RotationX + RotationInterne, RotationY , RotationZ) );

		m_Angle = RotationInterne ;
} // MoveCamera ()

ICameraSceneNode * DRONE::GetCamera (void) const
{
	return m_Camera ;
} // GetCamera ()

void DRONE::Zoom (float CoeffGrossissement) 
{
		m_Camera->setFOV (m_Camera->getFOV() / CoeffGrossissement) ;
		m_Zoom += (CoeffGrossissement > 1) ? CoeffGrossissement : -1/CoeffGrossissement ;
} // Zoom ()

float DRONE::GetAngle (void)
{
	return m_Angle ;
} // GetAngle ()

IAnimatedMesh * DRONE::GetMeshDrone (void) const
{
	return m_MeshDrone ;
} // GetMeshDrone ()

Merci.