Page principale | Liste des namespaces | Hiérarchie des classes | Liste par ordre alphabétique | Liste des composants | Liste des fichiers | Membres des namespaces | Composants | Déclarations

# Référence de la classe ExManagerEntity

`#include <ExManagerEntity.h>`

Graphe d'héritage de la classe ExManagerEntity

## Membres publics
void | Reset (void)
void | Reload (void)
void | Init (void)
void | Draw (void)
void | Load (std::string FileName)
void | LoadGroupe (std::string FileName)
ExCAction | InputCommand (ExCCommand Command)
ExCAction | InputAction (ExCAction Action)
void | SetManagerMesh (ExManagerMesh *Mesh)
void | SetManagerGizmo (ExManagerGizmo *Gizmo)
void | SetManagerModel (ExManagerModel *Model)
ExCEntity * | GetObject (ExNihilo::ExId id)
ExCEntity * | GetCurrentObject ()
void | SetManagerId (ExManagerId *Id)
void | Init (std::string FileName)
void | List (void)
bool | Add (ExCEntity *object)
bool | Add (std::string FileName)
bool | Remove (ExNihilo::ExId id)
bool | Remove (std::string Name)
bool | RemoveCurrentObject (void)
ExCEntity ** | GetObject (std::string Name)
ExCEntity ** | GetFirstObject (void)
ExCEntity ** | 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
ExManagerEntity * | CreateSingleton (void)
## Attributs Publics
std::ostrstream * | Consol
ExCFluxAction * | FluxAction
## Attributs Protégés
std::map< ExNihilo::ExId, ExCEntity *, std::less< ExNihilo::ExId > > * | m_Map
std::map< ExNihilo::ExId, ExCEntity *, 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
| ExManagerEntity (void)
| ~ExManagerEntity (void)
EntityType | GetEntityType (std::string FileName)
## Attributs Privés
ExManagerMesh * | ManagerMesh
ExManagerGizmo * | ManagerGizmo
ExManagerModel * | ManagerModel
std::vector< Groupe > | m_VecGroupe
## Attributs Privés Statiques
bool | m_flag = false
ExManagerEntity * | m_instance = NULL

## Documentation des contructeurs et destructeurs

ExManagerEntity::ExManagerEntity | ( | void |  | ) | `[private]`

| Définition à la ligne 43 du fichier ExManagerEntity.cpp.
    00044 {
    00045 }

ExManagerEntity::~ExManagerEntity | ( | void |  | ) | `[private]`

| Définition à la ligne 47 du fichier ExManagerEntity.cpp.
    00048 {
    00049 }

## Documentation des méthodes

bool ExManagerObject< ExCEntity * >::Add | ( | std::string | FileName | ) | `[inherited]`

bool ExManagerObject< ExCEntity * >::Add | ( | ExCEntity * | object | ) | `[inherited]`

| Référencé par Load(), et LoadGroupe().

bool ExManager::AskForCommand | ( | void |  | ) | `[inline, inherited]`

| Définition à la ligne 89 du fichier ExManager.h. Références ExManager::m_AskForCommand. Référencé par ExManagerCommand::InputCommand().
    00089 {return m_AskForCommand;}

bool ExManager::AskForExclusifCommand | ( | void |  | ) | `[inline, inherited]`

| Définition à la ligne 90 du fichier ExManager.h. Références ExManager::m_Exclusif. Référencé par ExManagerCommand::InputCommand().
    00090 {return m_Exclusif;}

ExManagerEntity * ExManagerEntity::CreateSingleton | ( | void |  | ) | `[static]`

| Définition à la ligne 29 du fichier ExManagerEntity.cpp. Références CreateSingleton(), Guard, m_flag, m_instance, et UnGuard. Référencé par CreateManager(), et CreateSingleton().
    00029                                                      {
    00030 Guard(ExManagerEntity* ExManagerEntity::CreateSingleton(void))
    00031         if(!m_flag)
    00032         {
    00033                 m_flag = true; // We are creating the error log now, so set flag to true
    00034                 m_instance = new ExManagerEntity; // Create the error log
    00035         }else
    00036         {
    00037                 std::cout<<"Error singleton already created"<<std::endl;
    00038         }
    00039         return m_instance;
    00040 UnGuard
    00041 }

void ExManagerEntity::Draw | ( | void |  | ) | `[virtual]`

| Redéfinie à partir de ExManagerObject< ExCEntity * >. Définition à la ligne 72 du fichier ExManagerEntity.cpp. Références ExManagerObject< ExCEntity * >::m_ItMap, et ExManagerObject< ExCEntity * >::m_Map. Référencé par ExManagerPVS::Draw().
    00073 {
    00074         //Draw here only if PVS is not active
    00075         for(m_ItMap=m_Map->begin();m_ItMap!=m_Map->end();m_ItMap++)
    00076         {
    00077                 m_ItMap->second->Draw();
    00078         }
    00079 }

ExCEntity * ExManagerEntity::GetCurrentObject | ( |  | ) |

| Redéfinie à partir de ExManagerObject< ExCEntity * >. Définition à la ligne 341 du fichier ExManagerEntity.cpp. Références GetCurrentObject(), GetObject(), Guard, ExManagerObject< ExCEntity * >::m_CurrentObjectId, et UnGuard. Référencé par GetCurrentObject(), et InputAction().
    00342 {
    00343 Guard(ExCEntity* ExManagerEntity::GetCurrentObject(void))
    00344                 return GetObject(m_CurrentObjectId);
    00345 UnGuard
    00346 }

EntityType ExManagerEntity::GetEntityType | ( | std::string | FileName | ) | `[private]`

| Définition à la ligne 63 du fichier ExManagerEntity.cpp. Références ENTITY, ENTITY_GROUP, ENTITY_UNKNOWN, EntityType, et ExNihilo::ExtracStringValueFromFile(). Référencé par Load().
    00064 {
    00065         std::string buffstring;
    00066         buffstring=ExNihilo::ExtracStringValueFromFile(FileName,"<Type>","<#Type>");
    00067         if(strcmpi(buffstring.data(),"ExCEntity")==0)return ENTITY;
    00068         if(strcmpi(buffstring.data(),"ExCGroupEntity")==0)return ENTITY_GROUP;
    00069         return ENTITY_UNKNOWN;
    00070 }

ExCEntity * * ExManagerObject< ExCEntity * >::GetFirstObject | ( | void |  | ) | `[inherited]`

ExNihilo::ExId ExManagerObject< ExCEntity * >::GetFirstObjectId | ( | void |  | ) | `[inherited]`

ExNihilo::ExId ExManagerObject< ExCEntity * >::GetLasstObjectId | ( | void |  | ) | `[inherited]`

ExCEntity * * ExManagerObject< ExCEntity * >::GetLastObject | ( | void |  | ) | `[inherited]`

unsigned int ExManagerObject< ExCEntity * >::GetNumberObject | ( | void |  | ) | `[inline, inherited]`

| Définition à la ligne 124 du fichier ExManagerObject.h.
    00124 {return m_Map->size();}

ExCEntity * * ExManagerObject< ExCEntity * >::GetObject | ( | std::string | Name | ) | `[inherited]`

ExCEntity * ExManagerEntity::GetObject | ( | ExNihilo::ExId | id | ) |

| Redéfinie à partir de ExManagerObject< ExCEntity * >. Définition à la ligne 250 du fichier ExManagerEntity.cpp. Références ExNihilo::ExId, GetObject(), Guard, ExManagerObject< ExCEntity * >::m_ItMap, ExManagerObject< ExCEntity * >::m_Map, et UnGuard. Référencé par GetCurrentObject(), GetObject(), et ExCAnimation::LoadFile().
    00251 {
    00252 Guard(ExCEntity *ExManagerEntity::GetObject(ExNihilo::ExId id))
    00253         for(m_ItMap=m_Map->begin();m_ItMap!=m_Map->end();m_ItMap++)
    00254         {
    00255                 if(m_ItMap->second->GetId()==id)return m_ItMap->second;
    00256         }
    00257         return NULL;
    00258 UnGuard
    00259 }

bool ExManager::GetStatus | ( | void |  | ) | `[inline, inherited]`

| Définition à la ligne 85 du fichier ExManager.h. Références ExManager::m_Status. Référencé par ExManagerInterface::Draw(), ExManagerConsole::Draw(), et ExManagerOutput::DrawScene().
    00085 {return m_Status;}

void ExManagerObject< ExCEntity * >::Init | ( | std::string | FileName | ) | `[inherited]`

void ExManagerEntity::Init | ( | void |  | ) | `[virtual]`

| Redéfinie à partir de ExManagerObject< ExCEntity * >. Définition à la ligne 56 du fichier ExManagerEntity.cpp. Références Guard, ExManagerObject< TypeA >::Init(), Init(), et UnGuard. Référencé par Init(), et PreInitManager().
    00057 {
    00058 Guard(void ExManagerEntity::Init(void))
    00059         ExManagerObject<ExCEntity *>::Init();
    00060 UnGuard
    00061 }

ExCAction ExManagerEntity::InputAction | ( | ExCAction | Action | ) | `[virtual]`

| Redéfinie à partir de ExManager. Définition à la ligne 218 du fichier ExManagerEntity.cpp. Références ExManager::Consol, ENTITY_HIDE, ENTITY_SHOW, GetCurrentObject(), Guard, InputAction(), ExCAction::m_Action, ExCAction::m_NextAction, ExCAction::m_Param, MANAGER_ENTITY_RELOAD, MANAGER_ENTITY_RESET, MANAGER_ENTITY_SET_CURRENT_OBJECT_BY_ID, MANAGER_ENTITY_SET_CURRENT_OBJECT_BY_NAME, NOTHING, Reload(), Reset(), ExManagerObject< ExCEntity * >::SetCurrentObject(), ExCObject3D::SetVisibleState(), et UnGuard. Référencé par InputAction(), et ExManagerCommand::ProcesExCAction().
    00219 {
    00220 Guard(ExCAction ExManagerEntity::InputAction(ExCAction Action))
    00221         switch(Action.m_Action)
    00222         {
    00223         case MANAGER_ENTITY_RELOAD:
    00224                 Reload();
    00225                 break;
    00226         case MANAGER_ENTITY_SET_CURRENT_OBJECT_BY_ID:
    00227                 SetCurrentObject(atoi(Action.m_Param.data()));
    00228                 break;
    00229         case MANAGER_ENTITY_SET_CURRENT_OBJECT_BY_NAME:
    00230                 SetCurrentObject(Action.m_Param);
    00231                 break;
    00232         case ENTITY_HIDE:
    00233                 GetCurrentObject()->SetVisibleState(false);
    00234                 break;
    00235         case ENTITY_SHOW:
    00236                 GetCurrentObject()->SetVisibleState(true);
    00237                 break;
    00238         case MANAGER_ENTITY_RESET:
    00239                 Reset();
    00240                 break;
    00241         default:
    00242                 *Consol<<"Can not file action in ENTITY_ACTION_MAP"<<std::endl;
    00243         break;
    00244         }
    00245         if(Action.m_NextAction){return *Action.m_NextAction;}
    00246         else{return NOTHING;}
    00247 UnGuard
    00248 }

ExCAction ExManagerEntity::InputCommand | ( | ExCCommand | Command | ) | `[virtual]`

| Redéfinie à partir de ExManager. Définition à la ligne 211 du fichier ExManagerEntity.cpp. Références Guard, InputCommand(), NOTHING, et UnGuard. Référencé par InputCommand().
    00212 {
    00213 Guard(ExCAction ExManagerEntity::InputCommand(ExCCommand Command))
    00214                 return NOTHING;
    00215 UnGuard
    00216 }

void ExManagerObject< ExCEntity * >::List | ( | void |  | ) | `[inherited]`

void ExManagerEntity::Load | ( | std::string | FileName | ) |

| Redéfinie à partir de ExManagerObject< ExCEntity * >. Définition à la ligne 82 du fichier ExManagerEntity.cpp. Références ExManagerObject< ExCEntity * >::Add(), ENTITY, ENTITY_GROUP, ENTITY_UNKNOWN, GetEntityType(), Guard, Load(), ExCEntity::LoadFile(), LoadGroupe(), ManagerGizmo, ExManagerObject< ExCEntity * >::ManagerId, ManagerMesh, ManagerModel, ExCObject::SetFileName(), ExCEntity::SetManagerGizmo(), ExCEntity::SetManagerId(), ExCEntity::SetManagerMesh(), ExCEntity::SetManagerModel(), et UnGuard. Référencé par Load().
    00083 {
    00084 Guard(void ExManagerEntity::Load(std::string FileName))
    00085         ExCEntity *Entity;
    00086         switch(GetEntityType(FileName))
    00087         {
    00088         case ENTITY:    Entity= new ExCEntity;break;
    00089         case ENTITY_GROUP:
    00090                 //Entity = new ExCGroupEntity;
    00091                 LoadGroupe(FileName);
    00092                 return;
    00093                 break;
    00094         case ENTITY_UNKNOWN:std::cout<<"Bad file type"<<std::endl;return;
    00095         }
    00096
    00097         Entity->SetManagerGizmo(ManagerGizmo);
    00098
    00099         Entity->SetManagerMesh(ManagerMesh);
    00100
    00101         Entity->SetManagerModel(ManagerModel);
    00102
    00103         Entity->SetManagerId(ManagerId);
    00104
    00105         Entity->SetFileName(FileName);
    00106
    00107         if(Entity->LoadFile(FileName))Add(Entity);
    00108 UnGuard
    00109 }

void ExManagerEntity::LoadGroupe | ( | std::string | FileName | ) |

| Définition à la ligne 110 du fichier ExManagerEntity.cpp. Références ExManagerObject< ExCEntity * >::Add(), ExNihilo::ExtractIntValueFromSring(), ExNihilo::ExtracValueFromSring(), ExCObject::GetName(), ExCObject3D::GetPosition(), Guard, ExCEntity::LoadFile(), LoadGroupe(), ExCObject3D::m_Angle, ExCEntity::m_FileGizmo, ExCEntity::m_FileMesh, ExCEntity::m_FileProperty, ExCEntity::m_GroupeName, ExCEntity::m_HasGroupe, Groupe::m_NumberEntity, ExCObject3D::m_Position, ExCEntity::m_Scale, Groupe::m_VecEntity, m_VecGroupe, ManagerGizmo, ExManagerObject< ExCEntity * >::ManagerId, ManagerMesh, ManagerModel, Groupe::PropGroupe, ExCObject::SetFileName(), ExCEntity::SetManagerGizmo(), ExCEntity::SetManagerId(), ExCEntity::SetManagerMesh(), ExCEntity::SetManagerModel(), ExCObject::SetName(), ExCObject3D::SetPosition(), ExCVec3D::SetValue(), et UnGuard. Référencé par Load(), et LoadGroupe().
    00111 {
    00112 Guard(void ExManagerEntity::LoadGroupe(std::string FileName))
    00113         Groupe Gr;
    00114         ExCEntity       TmpEntity,*TmpEntity2;
    00115         Gr.PropGroupe.SetFileName(FileName);
    00116         std::ifstream fin;
    00117         std::string buffstring;
    00118         char b[256];
    00119         fin.open(FileName.data(),std::ios::in);
    00120         if(fin.is_open())
    00121         {
    00122                 try
    00123                 {
    00124                         //----Read Type
    00125
    00126                         memset(b,0,255);fin.getline(b,256,'\n');
    00127                         //----Read File property
    00128                         memset(b,0,255);fin.getline(b,256,'\n');
    00129                         Gr.PropGroupe.m_FileProperty=ExNihilo::ExtracValueFromSring(b,"<ObjectProperty>","<#ObjectProperty>");
    00130                         //----Read File MEsh
    00131                         memset(b,0,255);fin.getline(b,256,'\n');
    00132                         Gr.PropGroupe.m_FileMesh=ExNihilo::ExtracValueFromSring(b,"<ObjectGraphic>","<#ObjectGraphic>");
    00133                         //----Read File Gizmo
    00134                         memset(b,0,255);fin.getline(b,256,'\n');
    00135                         Gr.PropGroupe.m_FileGizmo=ExNihilo::ExtracValueFromSring(b,"<CollisionGizmo>","<#CollisionGizmo>");
    00136                         //read property later in other file
    00137                         //----Read File Name
    00138                         memset(b,0,255);fin.getline(b,256,'\n');
    00139                         Gr.PropGroupe.SetName(ExNihilo::ExtracValueFromSring(b,"<ObjectName>","<#ObjectName>"));
    00140                         //---- Read Position
    00141                         memset(b,0,255);fin.getline(b,256,'\n');
    00142                         buffstring=ExNihilo::ExtracValueFromSring(b,"<Position>","<#Position>");
    00143                         Gr.PropGroupe.m_Position.SetValue(ExNihilo::ExtractFloatValueFromSring(buffstring,"<X>","<#X>"),
    00144                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Y>","<#Y>"),
    00145                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Z>","<#Z>"));
    00146                         //---- Read Angle
    00147                         memset(b,0,255);fin.getline(b,256,'\n');
    00148                         buffstring=ExNihilo::ExtracValueFromSring(b,"<Angle>","<#Angle>");
    00149                         Gr.PropGroupe.m_Angle.SetValue(ExNihilo::ExtractFloatValueFromSring(buffstring,"<X>","<#X>"),
    00150                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Y>","<#Y>"),
    00151                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Z>","<#Z>"));
    00152                         //---- Read scale
    00153                         memset(b,0,255);fin.getline(b,256,'\n');
    00154                         buffstring=ExNihilo::ExtracValueFromSring(b,"<Scale>","<#Scale>");
    00155                         Gr.PropGroupe.m_Scale.SetValue(ExNihilo::ExtractFloatValueFromSring(buffstring,"<X>","<#X>"),
    00156                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Y>","<#Y>"),
    00157                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Z>","<#Z>"));
    00158                         //read number entity
    00159                         memset(b,0,255);fin.getline(b,256,'\n');
    00160                         Gr.m_NumberEntity=ExNihilo::ExtractIntValueFromSring(b,"<NumberEntity>","<#NumberEntity>");
    00161                         //read entity
    00162                         for(int i=0;i<Gr.m_NumberEntity;i++)
    00163                         {
    00164
    00165                                 TmpEntity2= new ExCEntity;
    00166
    00167                                 TmpEntity2->m_HasGroupe=true;
    00168                                 TmpEntity2->m_GroupeName=TmpEntity.GetName();
    00169                                 TmpEntity2->SetManagerGizmo(ManagerGizmo);
    00170
    00171                                 TmpEntity2->SetManagerMesh(ManagerMesh);
    00172
    00173                                 TmpEntity2->SetManagerModel(ManagerModel);
    00174
    00175                                 TmpEntity2->SetManagerId(ManagerId);
    00176
    00177                                 TmpEntity2->SetFileName(FileName);
    00178
    00179                                 TmpEntity2->LoadFile(&fin);
    00180
    00181                                 TmpEntity2->SetPosition(TmpEntity2->GetPosition()+Gr.PropGroupe.GetPosition());
    00182                                 TmpEntity2->m_Angle=TmpEntity2->m_Angle+Gr.PropGroupe.m_Angle;
    00183                                 TmpEntity2->m_Scale=TmpEntity2->m_Scale+Gr.PropGroupe.m_Scale;
    00184
    00185
    00186                                 Add(TmpEntity2);
    00187                                 Gr.m_VecEntity.push_back(TmpEntity2);
    00188                         }
    00189
    00190                         fin.close();
    00191                 }
    00192                 catch(ExCExpStringNotFound)
    00193                 {
    00194                         std::cout<<"ExCExpStringNotFound"<<std::endl;
    00195                 }
    00196                 catch(...)
    00197                 {
    00198                         std::cout<<"ExCExpFileReadError"<<std::endl;
    00199                         throw ExCExpFileReadError();
    00200                 }
    00201         }else throw   ExCExpFileNotFound();
    00202         m_VecGroupe.push_back(Gr);
    00203 UnGuard
    00204 }

ExNihilo::ExId ExManagerObject< ExCEntity * >::NextObject | ( | void |  | ) | `[inherited]`

ExNihilo::ExId ExManagerObject< ExCEntity * >::PreviousObject | ( | void |  | ) | `[inherited]`

void ExManagerEntity::Reload | ( | void |  | ) | `[virtual]`

| Redéfinie à partir de ExManagerObject< ExCEntity * >. Définition à la ligne 261 du fichier ExManagerEntity.cpp. Références ExNihilo::ExtractIntValueFromSring(), ExNihilo::ExtracValueFromSring(), ExCObject3D::GetPosition(), Guard, ExCObject3D::m_Angle, ExManagerObject< ExCEntity * >::m_ItMap, ExManagerObject< ExCEntity * >::m_Map, ExCEntity::m_Scale, m_VecGroupe, Groupe::PropGroupe, Reload(), et UnGuard. Référencé par InputAction(), et Reload().
    00262 {
    00263 Guard(void  ExManagerEntity::Reload(void))
    00264         for(m_ItMap=m_Map->begin();m_ItMap!=m_Map->end();m_ItMap++)
    00265         {
    00266                 if(!m_ItMap->second->m_HasGroupe)
    00267                 {
    00268                         m_ItMap->second->LoadFile(m_ItMap->second->GetFileName());
    00269                 }
    00270         }
    00271         try
    00272         {
    00273                 //chaque groupe
    00274                 for(unsigned int  i=0;i<m_VecGroupe.size();i++)
    00275                 {
    00276                         Groupe oldgr=m_VecGroupe.at(i);
    00277                         //reload groupe
    00278                         std::ifstream fin;
    00279                         std::string buffstring;
    00280                         int m_NumberEntity;
    00281                         char b[256];
    00282                         fin.open(m_VecGroupe.at(i).PropGroupe.GetFileName().data(),std::ios::in);
    00283                         if(fin.is_open())
    00284                         {
    00285
    00286                                 memset(b,0,255);fin.getline(b,256,'\n');//----Read Type
    00287                                 memset(b,0,255);fin.getline(b,256,'\n');//----Read File property
    00288                                 m_VecGroupe.at(i).PropGroupe.m_FileProperty=ExNihilo::ExtracValueFromSring(b,"<ObjectProperty>","<#ObjectProperty>");
    00289                                 memset(b,0,255);fin.getline(b,256,'\n');//----Read File MEsh
    00290                                 m_VecGroupe.at(i).PropGroupe.m_FileMesh=ExNihilo::ExtracValueFromSring(b,"<ObjectGraphic>","<#ObjectGraphic>");
    00291                                 memset(b,0,255);fin.getline(b,256,'\n');//----Read File Gizmo
    00292                                 m_VecGroupe.at(i).PropGroupe.m_FileGizmo=ExNihilo::ExtracValueFromSring(b,"<CollisionGizmo>","<#CollisionGizmo>");
    00293                                 memset(b,0,255);fin.getline(b,256,'\n');//----Read File Name
    00294                                 m_VecGroupe.at(i).PropGroupe.SetName(ExNihilo::ExtracValueFromSring(b,"<ObjectName>","<#ObjectName>"));
    00295                                 memset(b,0,255);fin.getline(b,256,'\n');//---- Read Position
    00296                                 buffstring=ExNihilo::ExtracValueFromSring(b,"<Position>","<#Position>");
    00297                                 m_VecGroupe.at(i).PropGroupe.m_Position.SetValue(ExNihilo::ExtractFloatValueFromSring(buffstring,"<X>","<#X>"),
    00298                                         ExNihilo::ExtractFloatValueFromSring(buffstring,"<Y>","<#Y>"),
    00299                                         ExNihilo::ExtractFloatValueFromSring(buffstring,"<Z>","<#Z>"));
    00300                                 memset(b,0,255);fin.getline(b,256,'\n');//---- Read Angle
    00301                                 buffstring=ExNihilo::ExtracValueFromSring(b,"<Angle>","<#Angle>");
    00302                                 m_VecGroupe.at(i).PropGroupe.m_Angle.SetValue(ExNihilo::ExtractFloatValueFromSring(buffstring,"<X>","<#X>"),
    00303                                         ExNihilo::ExtractFloatValueFromSring(buffstring,"<Y>","<#Y>"),
    00304                                         ExNihilo::ExtractFloatValueFromSring(buffstring,"<Z>","<#Z>"));
    00305                                 memset(b,0,255);fin.getline(b,256,'\n');//---- Read scale
    00306                                 buffstring=ExNihilo::ExtracValueFromSring(b,"<Scale>","<#Scale>");
    00307                                 m_VecGroupe.at(i).PropGroupe.m_Scale.SetValue(ExNihilo::ExtractFloatValueFromSring(buffstring,"<X>","<#X>"),
    00308                                         ExNihilo::ExtractFloatValueFromSring(buffstring,"<Y>","<#Y>"),
    00309                                         ExNihilo::ExtractFloatValueFromSring(buffstring,"<Z>","<#Z>"));
    00310                                 memset(b,0,255);fin.getline(b,256,'\n');//read number entity
    00311                                 m_NumberEntity=ExNihilo::ExtractIntValueFromSring(b,"<NumberEntity>","<#NumberEntity>");
    00312                         }else throw   ExCExpFileNotFound();
    00313                         std::cout<<"Reload group pro ok"<<std::endl;
    00314                         //chaque entite est rechargée
    00315                         for(unsigned int j=0;j<m_VecGroupe.at(i).m_VecEntity.size();j++)
    00316                         {
    00317
    00318                                 for(int k=0;k<m_NumberEntity;k++)
    00319                                 {
    00320                                         /*m_VecGroupe.at(i).m_VecEntity.at(k)->LoadFile(&fin);
    00321                                         m_VecGroupe.at(i).m_VecEntity.at(k)->SetPosition(m_VecGroupe.at(i).m_VecEntity.at(k)->GetPosition()+m_VecGroupe.at(i).PropGroupe.GetPosition());
    00322                                         m_VecGroupe.at(i).m_VecEntity.at(k)->m_Angle=m_VecGroupe.at(i).m_VecEntity.at(k)->m_Angle+m_VecGroupe.at(i).PropGroupe.m_Angle;
    00323                                         m_VecGroupe.at(i).m_VecEntity.at(k)->m_Scale=m_VecGroupe.at(i).m_VecEntity.at(k)->m_Scale+m_VecGroupe.at(i).PropGroupe.m_Scale;
    00324                                         */
    00325                                         m_VecGroupe.at(i).m_VecEntity.at(k)->SetPosition(m_VecGroupe.at(i).m_VecEntity.at(k)->GetPosition()+m_VecGroupe.at(i).PropGroupe.GetPosition()-oldgr.PropGroupe.GetPosition());
    00326                                         m_VecGroupe.at(i).m_VecEntity.at(k)->m_Angle=m_VecGroupe.at(i).m_VecEntity.at(k)->m_Angle+m_VecGroupe.at(i).PropGroupe.m_Angle-oldgr.PropGroupe.m_Angle;
    00327                                         m_VecGroupe.at(i).m_VecEntity.at(k)->m_Scale=m_VecGroupe.at(i).m_VecEntity.at(k)->m_Scale+m_VecGroupe.at(i).PropGroupe.m_Scale-oldgr.PropGroupe.m_Scale;
    00328
    00329                                 }
    00330                         }
    00331                         fin.close();
    00332                 }
    00333         }
    00334         catch(ExCExpStringNotFound){std::cout<<"ExCExpStringNotFound"<<std::endl;}
    00335         catch(...){     std::cout<<"ExCExpFileReadError"<<std::endl;throw ExCExpFileReadError();}
    00336
    00337
    00338 UnGuard
    00339 }

bool ExManagerObject< ExCEntity * >::Remove | ( | std::string | Name | ) | `[inherited]`

bool ExManagerObject< ExCEntity * >::Remove | ( | ExNihilo::ExId | id | ) | `[inherited]`

bool ExManagerObject< ExCEntity * >::RemoveCurrentObject | ( | void |  | ) | `[inherited]`

void ExManagerEntity::Reset | ( | void |  | ) | `[virtual]`

| Redéfinie à partir de ExManagerObject< ExCEntity * >. Définition à la ligne 51 du fichier ExManagerEntity.cpp. Références ExManagerObject< TypeA >::Reset(). Référencé par InputAction(), et ExManagerCommand::ProcesExCAction().
    00052 {
    00053         ExManagerObject<ExCEntity *>::Reset();
    00054 }

void ExManager::SetAskForCommand | ( | bool | status | ) | `[inline, inherited]`

| Définition à la ligne 87 du fichier ExManager.h. Références ExManager::m_AskForCommand. Référencé par ExManagerConsole::ExManagerConsole(), ExManagerModel::ExManagerModel(), ExManagerObjectWindow::Init(), ExManagerNetwork::Init(), ExManagerConsole::InputAction(), ExManagerNetwork::InputCommand(), ExManagerLoad::LoadSetOfFile(), et ExManagerNetwork::Say().
    00087 {m_AskForCommand=status;}

void ExManager::SetAskForExclusifCommand | ( | bool | status | ) | `[inline, inherited]`

| Définition à la ligne 88 du fichier ExManager.h. Références ExManager::m_Exclusif. Référencé par ExManagerConsole::ExManagerConsole(), ExManagerModel::ExManagerModel(), ExManagerObjectWindow::Init(), ExManagerNetwork::Init(), ExManagerConsole::InputAction(), ExManagerNetwork::InputCommand(), et ExManagerNetwork::Say().
    00088 {m_Exclusif=status;}

bool ExManagerObject< ExCEntity * >::SetCurrentObject | ( | std::string | Name | ) | `[inherited]`

bool ExManagerObject< ExCEntity * >::SetCurrentObject | ( | ExNihilo::ExId | id | ) | `[inherited]`

| Référencé par InputAction().

void ExManager::SetFlux | ( | std::ostrstream * | consol,
|  | ExCFluxAction * | action
| ) | `[inherited]`

| Définition à la ligne 35 du fichier ExManager.cpp. Références ExManager::Consol, et ExManager::FluxAction. Référencé par SetManagerLink().
    00036 {
    00037         Consol=consol;
    00038         FluxAction=action;
    00039 }

void ExManagerEntity::SetManagerGizmo | ( | ExManagerGizmo * | Gizmo | ) | `[inline]`

| Définition à la ligne 115 du fichier ExManagerEntity.h. Références ManagerGizmo. Référencé par SetManagerLink().
    00115 {ManagerGizmo = Gizmo;}

void ExManagerObject< ExCEntity * >::SetManagerId | ( | ExManagerId * | Id | ) | `[inline, inherited]`

| Définition à la ligne 94 du fichier ExManagerObject.h. Référencé par SetManagerLink().
    00094 {ManagerId      = Id;}

void ExManagerEntity::SetManagerMesh | ( | ExManagerMesh * | Mesh | ) | `[inline]`

| Définition à la ligne 114 du fichier ExManagerEntity.h. Références ManagerMesh. Référencé par SetManagerLink().
    00114 {ManagerMesh = Mesh;}

void ExManagerEntity::SetManagerModel | ( | ExManagerModel * | Model | ) | `[inline]`

| Définition à la ligne 116 du fichier ExManagerEntity.h. Références ManagerModel. Référencé par SetManagerLink().
    00116 {ManagerModel = Model;}//TO DO remove this one en use only mesh

void ExManager::SetStatus | ( | bool | status | ) | `[inline, inherited]`

| Définition à la ligne 86 du fichier ExManager.h. Références ExManager::m_Status. Référencé par ExManagerConsole::Draw(), ExManagerConsole::ExManagerConsole(), ExManagerObjectWindow::Init(), ExManagerInterface::Init(), ExManagerConsole::InputAction(), ExManagerLoad::LoadSetOfFile(), et ExManagerConsole::SetConsoleState().
    00086 {m_Status=status;}

## Documentation des données imbriquées

std::ostrstream* ExManager::Consol`[inherited]`

| Définition à la ligne 73 du fichier ExManager.h. Référencé par ExManagerObject< TypeA >::Add(), ExManagerConsole::AddStringAction(), ExManagerConsole::ApplyBuffCommand(), ExManagerInputGLUT::CheckInput(), ExManagerSound::DisplayAviableInput(), ExManagerInputGLUT::DisplayAviableInput(), ExManagerLoad::DisplayFileType(), ExManagerLoad::GetFileType(), ExManagerVertexArrays::Init(), ExManagerTexture::Init(), ExManagerSound::Init(), ExManagerFog::Init(), ExManagerSound::InputAction(), ExManagerPVS::InputAction(), ExManagerParticuleSystem::InputAction(), ExManagerModel::InputAction(), ExManagerMesh::InputAction(), ExManagerMap::InputAction(), ExManagerLoad::InputAction(), ExManagerInterface::InputAction(), ExManagerFog::InputAction(), InputAction(), ExManagerConsole::InputAction(), ExManagerCommand::InputAction(), ExManagerCamera::InputAction(), ExManagerAnimation::InputAction(), ExManagerObject< TypeA >::List(), ExManagerModel::List(), ExManagerId::List(), ExManagerConsole::ListConsoleCommand(), ExManagerTexture::Load(), ExManagerParticuleSystem::Load(), ExManagerModel::Load(), ExManagerInterface::Load(), ExManagerTexture::LoadCubeMap(), ExManagerLoad::LoadSetOfFile(), ExManagerSound::LoadSound(), ExManagerSound::PauseSound(), ExManagerSound::PlaySound(), ExManagerCommand::ProcesExCAction(), ExManagerId::RecordObject(), ExManager::SetFlux(), ExManagerSound::SetRepeatSound(), ExManagerSound::StopSound(), ExManagerConsole::UpdateConsolBuffer(), et ExManagerConsole::Write().

ExCFluxAction* ExManager::FluxAction`[inherited]`

| Définition à la ligne 74 du fichier ExManager.h. Référencé par ExManagerWindow::Apply(), ExManagerCommand::ApplyAction(), ExManagerCommand::LoadExecFile(), ExManagerId::RecordObject(), ExManager::SetFlux(), et ExManagerSpecialEffect::Specialeffect().

bool ExManager::m_AskForCommand`[protected, inherited]`

| Définition à la ligne 70 du fichier ExManager.h. Référencé par ExManager::AskForCommand(), ExManagerConsole::ExManagerConsole(), et ExManager::SetAskForCommand().

ExNihilo::ExId ExManagerObject< ExCEntity * >::m_CurrentObjectId`[protected, inherited]`

| Définition à la ligne 79 du fichier ExManagerObject.h. Référencé par GetCurrentObject().

bool ExManager::m_Exclusif`[protected, inherited]`

| Définition à la ligne 71 du fichier ExManager.h. Référencé par ExManager::AskForExclusifCommand(), et ExManager::SetAskForExclusifCommand().

bool ExManagerEntity::m_flag = false`[static, private]`

| Définition à la ligne 26 du fichier ExManagerEntity.cpp. Référencé par CreateSingleton().

ExManagerEntity * ExManagerEntity::m_instance = NULL`[static, private]`

| Définition à la ligne 27 du fichier ExManagerEntity.cpp. Référencé par CreateSingleton().

std::map< ExNihilo::ExId , ExCEntity * , std::less <ExNihilo::ExId > >::iterator ExManagerObject< ExCEntity * >::m_ItMap`[protected, inherited]`

| Définition à la ligne 76 du fichier ExManagerObject.h. Référencé par Draw(), GetObject(), et Reload().

std::map< ExNihilo::ExId , ExCEntity * , std::less <ExNihilo::ExId > >* ExManagerObject< ExCEntity * >::m_Map`[protected, inherited]`

| Définition à la ligne 75 du fichier ExManagerObject.h. Référencé par Draw(), GetObject(), et Reload().

bool ExManager::m_Status`[protected, inherited]`

| Définition à la ligne 69 du fichier ExManager.h. Référencé par ExManager::GetStatus(), et ExManager::SetStatus().

std::vector<Groupe> ExManagerEntity::m_VecGroupe`[private]`

| Définition à la ligne 99 du fichier ExManagerEntity.h. Référencé par LoadGroupe(), et Reload().

ExManagerGizmo* ExManagerEntity::ManagerGizmo`[private]`

| Définition à la ligne 88 du fichier ExManagerEntity.h. Référencé par Load(), LoadGroupe(), et SetManagerGizmo().

ExManagerId* ExManagerObject< ExCEntity * >::ManagerId`[protected, inherited]`

| Définition à la ligne 78 du fichier ExManagerObject.h. Référencé par Load(), et LoadGroupe().

ExManagerMesh* ExManagerEntity::ManagerMesh`[private]`

| Définition à la ligne 87 du fichier ExManagerEntity.h. Référencé par Load(), LoadGroupe(), et SetManagerMesh().

ExManagerModel* ExManagerEntity::ManagerModel`[private]`

| Définition à la ligne 89 du fichier ExManagerEntity.h. Référencé par Load(), LoadGroupe(), et SetManagerModel().

La documentation associée à cette classe a été générée à partir des fichiers suivants :

- ExManagerEntity.h
- ExManagerEntity.cpp