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 ExManagerModel

`#include <ExManagerModele.h>`

Graphe d'héritage de la classe ExManagerModel

## Membres publics
ExCAction | InputCommand (ExCCommand Command)
ExCAction | InputAction (ExCAction Action)
void | SetManagerTexture (ExManagerTexture *Texture)
void | SetManagerVertexArrays (ExManagerVertexArrays *VertexArrays)
void | Reset (void)
void | Init (void)
void | Reload (void)
void | List (void)
void | Draw (void)
ExNihilo::ExId | Load (std::string FileName)
ExNihilo::ExId | Load (std::string FileName, std::string ObjectName)
ExCModel * | GetObject (ExNihilo::ExId id)
ExCModel * | GetCurrentObject (void)
void | SetManagerId (ExManagerId *Id)
void | Init (std::string FileName)
bool | Add (ExCModel *object)
bool | Add (std::string FileName)
bool | Remove (ExNihilo::ExId id)
bool | Remove (std::string Name)
bool | RemoveCurrentObject (void)
ExCModel ** | GetObject (std::string Name)
ExCModel ** | GetFirstObject (void)
ExCModel ** | 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
ExManagerModel * | CreateSingleton (void)
## Attributs Publics
std::ostrstream * | Consol
ExCFluxAction * | FluxAction
## Attributs Protégés
std::map< ExNihilo::ExId, ExCModel *, std::less< ExNihilo::ExId > > * | m_Map
std::map< ExNihilo::ExId, ExCModel *, 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
ModelType | FindModelType (std::string FileName)
| ExManagerModel (void)
| ~ExManagerModel (void)
## Attributs Privés
ExManagerTexture * | ManagerTexture
ExManagerVertexArrays * | ManagerVertexArrays
## Attributs Privés Statiques
bool | m_flag = false
ExManagerModel * | m_instance = NULL

## Documentation des contructeurs et destructeurs

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

| Définition à la ligne 41 du fichier ExManagerModele.cpp. Références ExManager::SetAskForCommand(), et ExManager::SetAskForExclusifCommand().
    00042 {
    00043         SetAskForCommand(true);
    00044         SetAskForExclusifCommand(false);
    00045 }

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

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

## Documentation des méthodes

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

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

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;}

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

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

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

| Redéfinie à partir de ExManagerObject< ExCModel * >. Définition à la ligne 97 du fichier ExManagerModele.cpp. Références Draw(), Guard, ExManagerObject< ExCModel * >::m_ItMap, ExManagerObject< ExCModel * >::m_Map, et UnGuard. Référencé par Draw(), et ExManagerOutput::DrawScene().
    00098 {
    00099 Guard(void ExManagerModel::Draw(void))
    00100         try
    00101         {
    00102                 for(m_ItMap=m_Map->begin();m_ItMap!=m_Map->end();m_ItMap++)
    00103                 {
    00104                         m_ItMap->second->Draw();
    00105                 }
    00106         }catch(...){}
    00107 UnGuard
    00108 }

ModelType ExManagerModel::FindModelType | ( | std::string | FileName | ) | `[private]`

| Définition à la ligne 127 du fichier ExManagerModele.cpp. Références FindModelType(), Guard, MODEL_3DS, MODEL_ASC, MODEL_EXM, MODEL_MD2, MODEL_MD3, MODEL_OBJ, MODEL_UNKNOW, ModelType, et UnGuard. Référencé par FindModelType(), et Load().
    00128 {
    00129 Guard(ModelType ExManagerModel::FindModelType(std::string FileName))
    00130         if(FileName.find(".md2")==(FileName.length()-4))return MODEL_MD2;
    00131         if(FileName.find(".md3")==(FileName.length()-4))return MODEL_MD3;
    00132         if(FileName.find(".asc")==(FileName.length()-4))return MODEL_ASC;
    00133         //if(FileName.find(".ase")==(FileName.length()-4))return MODEL_ASE;
    00134         if(FileName.find(".3ds")==(FileName.length()-4))return MODEL_3DS;
    00135         if(FileName.find(".obj")==(FileName.length()-4))return MODEL_OBJ;
    00136         if(FileName.find(".exm")==(FileName.length()-4))return MODEL_EXM;
    00137         return MODEL_UNKNOW;
    00138 UnGuard
    00139 }

ExCModel * ExManagerModel::GetCurrentObject | ( | void |  | ) |

| Redéfinie à partir de ExManagerObject< ExCModel * >. Définition à la ligne 279 du fichier ExManagerModele.cpp. Références GetCurrentObject(), GetObject(), Guard, ExManagerObject< ExCModel * >::m_CurrentObjectId, et UnGuard. Référencé par ExCCameraFirst::Draw(), ExCCameraChase::Draw(), GetCurrentObject(), et ExManagerCollision::ResolveCollision().
    00280 {
    00281 Guard(ExCModel* ExManagerModel::GetCurrentObject(void))
    00282         return GetObject(m_CurrentObjectId);
    00283 UnGuard
    00284 }

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

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

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

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

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

| Définition à la ligne 124 du fichier ExManagerObject.h. Référencé par ExManagerCollision::ResolveCollision().
    00124 {return m_Map->size();}

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

ExCModel * ExManagerModel::GetObject | ( | ExNihilo::ExId | id | ) |

| Redéfinie à partir de ExManagerObject< ExCModel * >. Définition à la ligne 268 du fichier ExManagerModele.cpp. Références ExNihilo::ExId, GetObject(), Guard, ExManagerObject< ExCModel * >::m_ItMap, ExManagerObject< ExCModel * >::m_Map, et UnGuard. Référencé par ExCMesh3ds::Draw(), ExCEntity::Draw(), GetCurrentObject(), GetObject(), InputAction(), ExCMesh3ds::Load(), ExCGroupEntity::LoadFile(), ExCEntity::LoadFile(), et ExCAnimation::LoadFile().
    00269 {
    00270 Guard(ExCModel *ExManagerModel::GetObject(ExNihilo::ExId id))
    00271         for(m_ItMap=m_Map->begin();m_ItMap!=m_Map->end();m_ItMap++)
    00272         {
    00273                 if(m_ItMap->second->GetId()==id)return m_ItMap->second;
    00274         }
    00275         return NULL;
    00276 UnGuard
    00277 }

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< ExCModel * >::Init | ( | std::string | FileName | ) | `[inherited]`

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

| Redéfinie à partir de ExManagerObject< ExCModel * >. Définition à la ligne 57 du fichier ExManagerModele.cpp. Références Guard, ExManagerObject< TypeA >::Init(), Init(), et UnGuard. Référencé par ExManagerParticuleSystem::Init(), Init(), PreInitManager(), et Reset().
    00058 {
    00059 Guard(void ExManagerModel::Init(void))
    00060         ExManagerObject<ExCModel *>::Init();
    00061 //      Load("Mur.3ds","MUR");
    00062
    00063         /*Load("ogre.md2","OGRE");
    00064         SetCurrentObject("OGRE");*/
    00065 //      GetCurrentObject()->SetPosition(40.0f,0.0f,0.0f);
    00066 /*
    00067         Load("ogre.md2","OGRE1");
    00068         SetCurrentObject("OGRE1");
    00069         GetCurrentObject()->SetPosition(-40.0f,0.0f,0.0f);
    00070
    00071         Load("ogre.md2","OGRE2");
    00072         SetCurrentObject("OGRE2");
    00073         GetCurrentObject()->SetPosition(0.0f,0.0f,40.0f);
    00074
    00075         Load("ogre.md2","OGRE3");
    00076         SetCurrentObject("OGRE3");
    00077         GetCurrentObject()->SetPosition(0.0f,0.0f,-40.0f);
    00078
    00079         Load("sara.md2","SARA");
    00080         SetCurrentObject("SARA");
    00081         GetCurrentObject()->SetPosition(20.0f,0.0f,20.0f);
    00082 */
    00083         //Load("pknight.md2","KNIGHT");
    00084         //SetCurrentObject("KNIGHT");
    00085
    00086 /*      Load("Fleche.3ds","FLECHES");
    00087         SetCurrentObject("FLECHES");
    00088 */
    00089 /*      Load("orc.3ds","GENERAL");
    00090         SetCurrentObject("GENERAL");
    00091         //GetCurrentObject()->SetPosition(100,50,0);
    00092         GetCurrentObject()->m_AlwaysDraw=true;
    00093         GetCurrentObject()->SetPosition(1995,95,4154);*/
    00094 UnGuard
    00095 }

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

| Redéfinie à partir de ExManager. Définition à la ligne 226 du fichier ExManagerModele.cpp. Références ExManager::Consol, GetObject(), Guard, ExCModel::InputAction(), InputAction(), List(), LIST, Load(), ExCAction::m_Action, ExManagerObject< ExCModel * >::m_CurrentObjectId, ExCAction::m_NextAction, ExCAction::m_Param, ExCAction::m_Param1, MANAGER_MODEL_RELOAD, MODEL_LOAD, MODEL_LOAD_WITH_NAME, NOTHING, Reload(), SET_CURRENT_OBJECT_BY_ID, SET_CURRENT_OBJECT_BY_NAME, ExManagerObject< ExCModel * >::SetCurrentObject(), et UnGuard. Référencé par InputAction(), et ExManagerCommand::ProcesExCAction().
    00227 {
    00228 Guard(ExCAction ExManagerModel::InputAction(ExCAction Action))
    00229 //std::cout<<"MANAGER MODEL"<<Action;
    00230         try
    00231         {
    00232                 switch(Action.m_Action)
    00233                 {
    00234                 case LIST:
    00235                         List();
    00236                         break;
    00237                 case SET_CURRENT_OBJECT_BY_ID:
    00238                         SetCurrentObject(atoi(Action.m_Param.data()));
    00239                         break;
    00240                 case SET_CURRENT_OBJECT_BY_NAME:
    00241                         SetCurrentObject(Action.m_Param);
    00242                         break;
    00243                 case MODEL_LOAD_WITH_NAME:
    00244                         Load(Action.m_Param,Action.m_Param1);
    00245                         break;
    00246                 case MODEL_LOAD:
    00247                         Load(Action.m_Param);
    00248                         break;
    00249                 case MANAGER_MODEL_RELOAD:
    00250                         Reload();
    00251                         break;
    00252                 default:
    00253                         //*Consol<<"Can not file action in MODEL_ACTION_MAP"<<std::endl;
    00254                         return GetObject(m_CurrentObjectId)->InputAction(Action);
    00255                 }
    00256
    00257                 if(Action.m_NextAction){return *Action.m_NextAction;}
    00258                 else{return NOTHING;}
    00259         }
    00260         catch(...)
    00261         {
    00262                 *Consol<<"ExManagerModel::ExCeption =>> Error input action"<<std::endl;
    00263                 return NOTHING;
    00264         }
    00265 UnGuard
    00266 }

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

| Redéfinie à partir de ExManager. Définition à la ligne 200 du fichier ExManagerModele.cpp. Références Guard, InputCommand(), KEYBOARD_DOWN_ARROW_DOWN, KEYBOARD_DOWN_ARROW_LEFT, KEYBOARD_DOWN_ARROW_RIGHT, KEYBOARD_DOWN_ARROW_UP, KEYBOARD_UP_ARROW_DOWN, KEYBOARD_UP_ARROW_LEFT, KEYBOARD_UP_ARROW_RIGHT, KEYBOARD_UP_ARROW_UP, ExCCommand::m_Command, NOTHING, et UnGuard. Référencé par InputCommand().
    00201 {
    00202 Guard(ExCAction ExManagerModel::InputCommand(ExCCommand Command))
    00203         switch(Command.m_Command)
    00204         {
    00205         case KEYBOARD_UP_ARROW_DOWN:
    00206                 return NOTHING;
    00207         case KEYBOARD_UP_ARROW_UP:
    00208                 return NOTHING;
    00209         case KEYBOARD_UP_ARROW_LEFT:
    00210                 return NOTHING;
    00211         case KEYBOARD_UP_ARROW_RIGHT:
    00212                 return NOTHING;
    00213         case KEYBOARD_DOWN_ARROW_DOWN:
    00214                 return NOTHING;
    00215         case KEYBOARD_DOWN_ARROW_UP:
    00216                 return NOTHING;
    00217         case KEYBOARD_DOWN_ARROW_LEFT:
    00218                 return NOTHING;
    00219         case KEYBOARD_DOWN_ARROW_RIGHT:
    00220                 return NOTHING;
    00221         default :return NOTHING;
    00222         }
    00223 UnGuard
    00224 }

void ExManagerModel::List | ( | void |  | ) |

| Redéfinie à partir de ExManagerObject< ExCModel * >. Définition à la ligne 110 du fichier ExManagerModele.cpp. Références ExManager::Consol, Guard, List(), ExManagerObject< ExCModel * >::m_CurrentObjectId, ExManagerObject< ExCModel * >::m_ItMap, ExManagerObject< ExCModel * >::m_Map, et UnGuard. Référencé par InputAction(), et List().
    00111 {
    00112 Guard(void ExManagerModel::List(void))
    00113         *Consol<<"---------------List of Model--------------"<<std::endl;
    00114         for(m_ItMap=m_Map->begin();m_ItMap!=m_Map->end();m_ItMap++)
    00115         {
    00116                 *Consol<<" Id:"<<m_ItMap->second->GetId()<<" Name :"<<m_ItMap->second->GetName()<<" Type :"<<m_ItMap->second->GetType()<<std::endl;
    00117
    00118         }
    00119         *Consol<<"-----------------------------------------------------------------"<<std::endl;
    00120         *Consol<<" Number Total of Object : "<<m_Map->size()<<std::endl;
    00121         *Consol<<" Current Object Id : "<<m_CurrentObjectId<<std::endl;
    00122         *Consol<<"-----------------------------------------------------------------"<<std::endl;
    00123
    00124 UnGuard
    00125 }

ExNihilo::ExId ExManagerModel::Load | ( | std::string | FileName,
|  | std::string | ObjectName
| ) |

| Définition à la ligne 148 du fichier ExManagerModele.cpp. Références ExManagerObject< TypeA >::Add(), ExManager::Consol, ExNihilo::ExId, FindModelType(), ExCObject::GetId(), Guard, ExCModel::Load(), Load(), ExManagerObject< ExCModel * >::m_ItMap, ExManagerObject< ExCModel * >::m_Map, ManagerTexture, MODEL_3DS, MODEL_ASC, MODEL_EXM, MODEL_MD2, MODEL_MD3, MODEL_OBJ, ExCObject::SetFileName(), ExCModel::SetManagerTexture(), ExCObject::SetName(), et UnGuard.
    00149 {
    00150 Guard(ExNihilo::ExId ExManagerModel::Load(std::string FileName,std::string ObjectName))
    00151         //Check if model already loaded
    00152         try
    00153         {
    00154                 for(m_ItMap=m_Map->begin();m_ItMap!=m_Map->end();m_ItMap++)
    00155                 {
    00156                         if(strcmp(m_ItMap->second->GetName().data(),ObjectName.data())==0)
    00157                         {
    00158                                 return m_ItMap->second->GetId();
    00159                         }
    00160                 }
    00161         }catch(...){}
    00162
    00163         FileName="../Data/Modeles/"+FileName;
    00164         try
    00165         {
    00166                 ExCModel *ModelToLoad;
    00167                 switch(FindModelType(FileName))
    00168                 {
    00169                         case MODEL_MD2:ModelToLoad = new ExCModelMD2;break;
    00170                         case MODEL_MD3:ModelToLoad = new ExCModelMD3;break;
    00171                         case MODEL_ASC:ModelToLoad = new ExCModelASC;break;
    00172                 //      case MODEL_ASE:ModelToLoad = new ExCModelMD2;break;
    00173                         case MODEL_3DS:ModelToLoad = new ExCModel3DS;break;
    00174                         case MODEL_OBJ:ModelToLoad = new ExCModelOBJ;break;
    00175                         case MODEL_EXM:ModelToLoad = new ExCModelEXM;break;
    00176                 }
    00177                 ModelToLoad->SetManagerTexture(ManagerTexture);
    00178                 ModelToLoad->SetFileName(FileName);
    00179                 ModelToLoad->Load(FileName);
    00180                 ModelToLoad->SetName(ObjectName);
    00181                 ExManagerObject<ExCModel *>::Add(ModelToLoad);
    00182                 return ModelToLoad->GetId();
    00183         }
    00184         catch(ExCExpFileNotFound)
    00185         {
    00186                 *Consol<<"ExManagerModel::ExCeption =>"<<FileName<<" File not found"<<std::endl;
    00187         }
    00188         catch(ExCExpFileReadError)
    00189         {
    00190                 *Consol<<"ExManagerModel::ExCeption =>"<<FileName<<" Read file error"<<std::endl;
    00191         }
    00192         catch(...)
    00193         {
    00194                 *Consol<<"ExManagerModel::ExCeption =>"<<FileName<<" Unknow exception"<<std::endl;
    00195         }
    00196         return -1;
    00197 UnGuard
    00198 }

ExNihilo::ExId ExManagerModel::Load | ( | std::string | FileName | ) |

| Redéfinie à partir de ExManagerObject< ExCModel * >. Définition à la ligne 141 du fichier ExManagerModele.cpp. Références ExNihilo::ExId, Guard, Load(), et UnGuard. Référencé par InputAction(), ExManagerLoad::InputAction(), Load(), ExCMesh3ds::Load(), ExCGroupEntity::LoadFile(), ExCEntity::LoadFile(), et ExManagerLoad::LoadSetOfFile().
    00142 {
    00143 Guard(ExNihilo::ExId ExManagerModel::Load(std::string FileName))
    00144         return Load(FileName,FileName);
    00145 UnGuard
    00146 }

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

| Référencé par ExManagerCollision::ResolveCollision().

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

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

| Redéfinie à partir de ExManagerObject< ExCModel * >. Définition à la ligne 286 du fichier ExManagerModele.cpp. Références Guard, ExManagerObject< ExCModel * >::m_ItMap, ExManagerObject< ExCModel * >::m_Map, Reload(), et UnGuard. Référencé par InputAction(), ExManagerCommand::ProcesExCAction(), et Reload().
    00287 {
    00288 Guard(void ExManagerModel::Reload(void))
    00289         for(m_ItMap=m_Map->begin();m_ItMap!=m_Map->end();m_ItMap++)
    00290         {
    00291                 m_ItMap->second->Load(m_ItMap->second->GetFileName());
    00292         }
    00293 UnGuard
    00294 }

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

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

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

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

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

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(), 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(), ExManagerObjectWindow::Init(), ExManagerNetwork::Init(), ExManagerConsole::InputAction(), ExManagerNetwork::InputCommand(), et ExManagerNetwork::Say().
    00088 {m_Exclusif=status;}

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

bool ExManagerObject< ExCModel * >::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 ExManagerObject< ExCModel * >::SetManagerId | ( | ExManagerId * | Id | ) | `[inline, inherited]`

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

void ExManagerModel::SetManagerTexture | ( | ExManagerTexture * | Texture | ) | `[inline]`

| Définition à la ligne 104 du fichier ExManagerModele.h. Références ManagerTexture. Référencé par SetManagerLink().
    00104 {ManagerTexture = Texture;}

void ExManagerModel::SetManagerVertexArrays | ( | ExManagerVertexArrays * | VertexArrays | ) | `[inline]`

| Définition à la ligne 105 du fichier ExManagerModele.h. Références ManagerVertexArrays. Référencé par SetManagerLink().
    00105 {ManagerVertexArrays = VertexArrays;}

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(), InputAction(), ExManagerMesh::InputAction(), ExManagerMap::InputAction(), ExManagerLoad::InputAction(), ExManagerInterface::InputAction(), ExManagerFog::InputAction(), ExManagerEntity::InputAction(), ExManagerConsole::InputAction(), ExManagerCommand::InputAction(), ExManagerCamera::InputAction(), ExManagerAnimation::InputAction(), ExManagerObject< TypeA >::List(), List(), ExManagerId::List(), ExManagerConsole::ListConsoleCommand(), ExManagerTexture::Load(), ExManagerParticuleSystem::Load(), 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< ExCModel * >::m_CurrentObjectId`[protected, inherited]`

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

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 ExManagerModel::m_flag = false`[static, private]`

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

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

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

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

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

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

| Définition à la ligne 75 du fichier ExManagerObject.h. Référencé par Draw(), GetObject(), List(), Load(), 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().

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

| Définition à la ligne 78 du fichier ExManagerObject.h.

ExManagerTexture* ExManagerModel::ManagerTexture`[private]`

| Définition à la ligne 84 du fichier ExManagerModele.h. Référencé par Load(), et SetManagerTexture().

ExManagerVertexArrays* ExManagerModel::ManagerVertexArrays`[private]`

| Définition à la ligne 85 du fichier ExManagerModele.h. Référencé par SetManagerVertexArrays().

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

- ExManagerModele.h
- ExManagerModele.cpp