ExNihilo : ExManagerAnimation class Reference

00043 {
00044 Guard(ExManagerAnimation::ExManagerAnimation(void))
00045 UnGuard
00046 }

00049 {
00050 Guard(ExManagerAnimation::~ExManagerAnimation(void))
00051 UnGuard
00052 }

00089 {return m_AskForCommand;}

00090 {return m_Exclusif;}

00028                                                            {
00029 Guard(ExManagerAnimation* ExManagerAnimation::CreateSingleton(void))
00030         if(!m_flag)
00031         {
00032                 m_flag = true; // We are creating the error log now, so set flag to true
00033                 m_instance = new ExManagerAnimation; // Create the error log
00034         }else
00035         {
00036                 std::cout<<"Error singleton already created"<<std::endl;
00037         }
00038         return m_instance; 
00039 UnGuard
00040 }

00099 {
00100 Guard(void ExManagerAnimation::Draw(void))
00101         for(m_ItMap=m_Map->begin();m_ItMap!=m_Map->end();m_ItMap++)
00102         {
00103                 m_ItMap->second.Draw();
00104         }       
00105 UnGuard
00106 }

00170 {
00171 Guard(ExCAnimation* ExManagerAnimation::GetCurrentObject(void))
00172                 return GetObject(m_CurrentObjectId);
00173 UnGuard
00174 }

00124 {return m_Map->size();}

00176 {
00177 Guard(ExCAnimation *ExManagerAnimation::GetObject(ExNihilo::ExId id))
00178                 for(m_ItMap=m_Map->begin();m_ItMap!=m_Map->end();m_ItMap++)
00179                 {
00180                         if(m_ItMap->second.GetId()==id)return &m_ItMap->second;
00181                 }
00182                 return NULL;
00183 UnGuard
00184 }

00085 {return m_Status;}

00088 {
00089 Guard(void ExManagerAnimation::Init(void))
00090         ExManagerObject<ExCAnimation>::Init();
00091         //ExCAnimation Anim1;
00092         //Anim1.m_Object=ManagerModel->GetCurrentObject();
00093         //Anim1.m_Object=ManagerCamera->GetCurrentObject();
00094         //ExManagerObject<ExCAnimation>::Add(Anim1);
00095 UnGuard
00096 }

00120 {
00121 Guard(ExCAction ExManagerAnimation::InputAction(ExCAction Action))
00122         switch(Action.m_Action)
00123         {
00124         case MANAGER_ANIMATION_RELOAD:
00125                 Reload();
00126                 *Consol<<"ExManagerAnimation::Reload sucess"<<std::endl;
00127                 break;
00128         case MANAGER_ANIMATION_PAUSE_ALL_ANIMATION:
00129                 for(m_ItMap=m_Map->begin();m_ItMap!=m_Map->end();m_ItMap++)
00130                 {
00131                         m_ItMap->second.SetPauseState(true);
00132                 }       
00133                 break;
00134         case MANAGER_ANIMATION_UNPAUSE_ALL_ANIMATION:
00135                 for(m_ItMap=m_Map->begin();m_ItMap!=m_Map->end();m_ItMap++)
00136                 {
00137                         m_ItMap->second.SetPauseState(false);
00138                 }       
00139                 break;
00140         case MANAGER_ANIMATION_TOGGLE_PAUSE_ALL_ANIMATION:
00141                 for(m_ItMap=m_Map->begin();m_ItMap!=m_Map->end();m_ItMap++)
00142                 {
00143                         m_ItMap->second.SetPauseState(!m_ItMap->second.GetPauseState());
00144                 }       
00145                 break;
00146         case MANAGER_ANIMATION_PAUSE_ANIMATION:
00147                 GetCurrentObject()->SetPauseState(true);
00148                 break;
00149         case MANAGER_ANIMATION_UNPAUSE_ANIMATION:
00150                 GetCurrentObject()->SetPauseState(false);
00151                 break;
00152         case MANAGER_ANIMATION_TOGGLE_ANIMATION:
00153                 GetCurrentObject()->SetPauseState(GetCurrentObject()->GetPauseState());
00154                 break;
00155         case MANAGER_ANIMATION_SET_CURRENT_OBJECT_BY_ID:
00156                 SetCurrentObject(atoi(Action.m_Param.data()));
00157                 break;
00158         case MANAGER_ANIMATION_SET_CURRENT_OBJECT_BY_NAME:
00159                 SetCurrentObject(Action.m_Param);
00160                 break;
00161         default:
00162                 *Consol<<"Can not file action in ANIMATION_ACTION_MAP"<<std::endl;
00163                 return NOTHING;
00164         }       
00165         return NOTHING;
00166 UnGuard
00167 }

00109 {
00110 Guard(ExCAction ExManagerAnimation::InputCommand(ExCCommand Command))
00111 /*      switch(Command.m_Command)
00112         {
00113                 default :return NOTHING;
00114         }*/
00115         return NOTHING;
00116 UnGuard
00117 }

00072 {
00073 Guard(void ExManagerAnimation::Load(std::string FileName))
00074         ExCAnimation Anim;
00075         Anim.SetManagerCamera(ManagerCamera);
00076         Anim.SetManagerId(ManagerId);
00077         Anim.SetManagerModel(ManagerModel);
00078         Anim.SetManagerEntity(ManagerEntity);
00079         Anim.LoadFile(FileName);
00080         //Anim.m_Object=ManagerModel->GetCurrentObject();
00081         //Anim.m_Object=ManagerCamera->GetCurrentObject();
00082         return ExManagerObject<ExCAnimation>::Add(Anim);
00083 UnGuard
00084 }

00062 {
00063 Guard(void ExManagerAnimation::Reload(void))
00064         for(m_ItMap=m_Map->begin();m_ItMap!=m_Map->end();m_ItMap++)
00065         {
00066                 m_ItMap->second.LoadFile(m_ItMap->second.GetFileName());
00067         }
00068 UnGuard
00069 }

00055 {
00056 Guard(void ExManagerAnimation::Reset(void))
00057         ExManagerObject<ExCAnimation>::Reset();
00058 UnGuard
00059 }

00087 {m_AskForCommand=status;}

00088 {m_Exclusif=status;}

00036 {
00037         Consol=consol;
00038         FluxAction=action;
00039 }

00100 {ManagerCamera = Cam;}

00105 {ManagerEntity = Entity;}

00102 {ManagerGizmo = Gizmo;}

00094 {ManagerId      = Id;}

00104 {ManagerLight = Light;}

00101 {ManagerModel = Model;}

00103 {ManagerParticuleSystem = ParticuleSystem;}

00086 {m_Status=status;}


Membres publics
void	SetManagerCamera (ExManagerCamera *Cam)
void	SetManagerModel (ExManagerModel *Model)
void	SetManagerGizmo (ExManagerGizmo *Gizmo)
void	SetManagerParticuleSystem (ExManagerParticuleSystem *ParticuleSystem)
void	SetManagerLight (ExManagerLight *Light)
void	SetManagerEntity (ExManagerEntity *Entity)
void	Reset (void)
void	Reload (void)
void	Init (void)
void	Draw (void)
bool	Load (std::string FileName)
ExCAction	InputCommand (ExCCommand Command)
ExCAction	InputAction (ExCAction Action)
ExCAnimation *	GetObject (ExNihilo::ExId id)
ExCAnimation *	GetCurrentObject ()
void	SetManagerId (ExManagerId *Id)
void	Init (std::string FileName)
void	List (void)
bool	Add (ExCAnimationobject)
bool	Add (std::string FileName)
bool	Remove (ExNihilo::ExId id)
bool	Remove (std::string Name)
bool	RemoveCurrentObject (void)
ExCAnimation *	GetObject (std::string Name)
ExCAnimation *	GetFirstObject (void)
ExCAnimation *	GetLastObject (void)
ExNihilo::ExId	GetFirstObjectId (void)
ExNihilo::ExId	GetLasstObjectId (void)
bool	SetCurrentObject (ExNihilo::ExId id)
bool	SetCurrentObject (std::string Name)
ExNihilo::ExId	NextObject (void)
ExNihilo::ExId	PreviousObject (void)
unsigned int	GetNumberObject (void)
void	SetFlux (std::ostrstream consol, ExCFluxAction action)
bool	GetStatus (void)
void	SetStatus (bool status)
void	SetAskForCommand (bool status)
void	SetAskForExclusifCommand (bool status)
bool	AskForCommand (void)
bool	AskForExclusifCommand (void)
Membres publics statiques
ExManagerAnimation *	CreateSingleton (void)
Attributs Publics
std::ostrstream *	Consol
ExCFluxAction *	FluxAction
Attributs Protégés
std::map< ExNihilo::ExId, ExCAnimation, std::less< ExNihilo::ExId > > *	m_Map
std::map< ExNihilo::ExId, ExCAnimation, std::less< ExNihilo::ExId > >::iterator	m_ItMap
ExManagerId *	ManagerId
ExNihilo::ExId	m_CurrentObjectId
bool	m_Status
bool	m_AskForCommand
bool	m_Exclusif
Membres privés
	ExManagerAnimation (void)
	~ExManagerAnimation (void)
Attributs Privés
ExManagerCamera *	ManagerCamera
ExManagerModel *	ManagerModel
ExManagerGizmo *	ManagerGizmo
ExManagerParticuleSystem *	ManagerParticuleSystem
ExManagerLight *	ManagerLight
ExManagerEntity *	ManagerEntity
Attributs Privés Statiques
bool	m_flag = false
ExManagerAnimation *	m_instance = NULL

Référence de la classe ExManagerAnimation

Membres publics

Membres publics statiques

Attributs Publics

Attributs Protégés

Membres privés

Attributs Privés

Attributs Privés Statiques

Documentation des contructeurs et destructeurs

Documentation des méthodes

Documentation des données imbriquées