void CLI::Add(const std::string& path,
const std::string& description,
const std::string& alias,
bool required)
{
po::options_description& desc = CLI::GetSingleton().desc;
// Must make use of boost syntax here.
std::string progOptId = alias.length() ? path + "," + alias : path;
// Add the alias, if necessary
AddAlias(alias, path);
// Add the option to boost program_options.
desc.add_options()(progOptId.c_str(), po::value<T>(), description.c_str());
// Make sure the appropriate metadata is inserted into gmap.
gmap_t& gmap = GetSingleton().globalValues;
ParamData data;
T tmp = T();
data.desc = description;
data.name = path;
data.tname = TYPENAME(T);
data.value = boost::any(tmp);
data.wasPassed = false;
gmap[path] = data;
// If the option is required, add it to the required options list.
if (required)
GetSingleton().requiredOptions.push_front(path);
}
T& CLI::GetParam(const std::string& identifier)
{
// Used to ensure we have a valid value.
T tmp = T();
// Used to index into the globalValues map.
std::string key = std::string(identifier);
gmap_t& gmap = GetSingleton().globalValues;
// Now check if we have an alias.
amap_t& amap = GetSingleton().aliasValues;
if (amap.count(key))
key = amap[key];
// What if we don't actually have any value?
if (!gmap.count(key))
{
gmap[key] = ParamData();
gmap[key].value = boost::any(tmp);
*boost::any_cast<T>(&gmap[key].value) = tmp;
}
// What if we have meta-data, but no data?
boost::any val = gmap[key].value;
if (val.empty())
gmap[key].value = boost::any(tmp);
return *boost::any_cast<T>(&gmap[key].value);
}
T& CLI::GetParam(const std::string& identifier)
{
// Only use the alias if the parameter does not exist as given.
std::string key =
(GetSingleton().parameters.count(identifier) == 0 &&
identifier.length() == 1 && GetSingleton().aliases.count(identifier[0]))
? GetSingleton().aliases[identifier[0]] : identifier;
if (GetSingleton().parameters.count(key) == 0)
Log::Fatal << "Parameter --" << key << " does not exist in this program!"
<< std::endl;
util::ParamData& d = GetSingleton().parameters[key];
// Make sure the types are correct.
if (TYPENAME(T) != d.tname)
Log::Fatal << "Attempted to access parameter --" << key << " as type "
<< TYPENAME(T) << ", but its true type is " << d.tname << "!"
<< std::endl;
// We already know that required options have been passed, so we have a valid
// value to return. Because the parameters held are sometimes different types
// than what the user wants, we must pass through a utility function.
typename util::ParameterType<T>::type& v =
*boost::any_cast<typename util::ParameterType<T>::type>(&d.value);
return util::HandleParameter<T>(v, d);
}
void CLogger::SetFileName( String const & logFilePath, ELogType logLevel )
{
if ( GetSingleton()._impl )
{
GetSingleton().DoSetFileName( logFilePath, logLevel );
}
}
void CLogger::Initialise( CLogger * logger )
{
_counter++;
#if defined( _WIN32 )
if ( _singleton )
{
_counter--;
PARSER_EXCEPT( EShaderParserExceptionCodes_InternalError, ERROR_DB_LOGGER_ALREADY_INITIALISED );
}
else
{
_ownInstance = false;
CLogger & mylogger = GetSingleton();
delete mylogger._impl;
mylogger._impl = logger->_impl;
for ( int i = 0; i < ELogType_COUNT; i++ )
{
mylogger._headers[i] = logger->_headers[i];
}
mylogger._logLevel = logger->_logLevel;
mylogger.DoInitialiseThread();
}
#endif
}
void ezToolsProject::BroadcastSaveAll()
{
ezToolsProjectEvent e;
e.m_pProject = GetSingleton();
e.m_Type = ezToolsProjectEvent::Type::SaveAll;
s_Events.Broadcast(e);
}
void ezToolsProject::BroadcastConfigChanged()
{
ezToolsProjectEvent e;
e.m_pProject = GetSingleton();
e.m_Type = ezToolsProjectEvent::Type::ProjectConfigChanged;
s_Events.Broadcast(e);
}
gameEngine::gameEngine() : m_bQuit(true)
{
if (GetSingleton() == 0) gameEngine::ge_ptr = this;
else
{
}
gi_ptr = 0;
}
void ezToolsProject::CloseProject()
{
if (GetSingleton())
{
GetSingleton()->m_bIsClosing = true;
ezToolsProjectEvent e;
e.m_pProject = GetSingleton();
e.m_Type = ezToolsProjectEvent::Type::ProjectClosing;
s_Events.Broadcast(e);
ezDocumentManager::CloseAllDocuments();
delete GetSingleton();
e.m_Type = ezToolsProjectEvent::Type::ProjectClosed;
s_Events.Broadcast(e);
}
}
static void kill()
{
if (_singleton != NULL)
{
GetSingleton()->clear();
delete _singleton;
_singleton = NULL;
C_Log::GetSingleton()->AddMessage("Singleton Resource killed.");
}
}
void CLogger::Cleanup()
{
GetSingleton().DoCleanupThread();
if ( _counter > 0 )
{
_counter--;
delete _singleton;
_singleton = NULL;
}
}
typename util::ParameterType<T>::type& CLI::GetUnmappedParam(
const std::string& identifier)
{
std::string key =
(identifier.length() == 1 && GetSingleton().aliases.count(identifier[0]))
? GetSingleton().aliases[identifier[0]] : identifier;
if (GetSingleton().parameters.count(key) == 0)
Log::Fatal << "Parameter --" << key << " does not exist in this program!"
<< std::endl;
util::ParamData& d = GetSingleton().parameters[key];
// Make sure the types are correct.
if (TYPENAME(T) != d.tname)
Log::Fatal << "Attempted to access parameter --" << key << " as type "
<< TYPENAME(T) << ", but its true type is " << d.tname << "!"
<< std::endl;
return *boost::any_cast<typename util::ParameterType<T>::type>(&d.value);
}
bool ezToolsProject::CanCloseProject()
{
if (GetSingleton() == nullptr)
return true;
ezToolsProjectRequest e;
e.m_Type = ezToolsProjectRequest::Type::CanCloseProject;
e.m_bCanClose = true;
s_Requests.Broadcast(e, 1); // when the save dialog pops up and the user presses 'Save' we need to allow one more recursion
return e.m_bCanClose;
}
ezStatus ezToolsProject::CreateOrOpenProject(const char* szProjectPath, bool bCreate)
{
CloseProject();
new ezToolsProject(szProjectPath);
ezStatus ret;
if (bCreate)
ret = GetSingleton()->Create();
else
ret = GetSingleton()->Open();
if (ret.m_Result.Failed())
{
delete GetSingleton();
return ret;
}
return ezStatus(EZ_SUCCESS);
}
bool ezToolsProject::CanCloseDocuments(ezArrayPtr<ezDocument*> documents)
{
if (GetSingleton() == nullptr)
return true;
ezToolsProjectRequest e;
e.m_Type = ezToolsProjectRequest::Type::CanCloseDocuments;
e.m_bCanClose = true;
e.m_Documents = documents;
s_Requests.Broadcast(e);
return e.m_bCanClose;
}
LRESULT CALLBACK EventSystem::KeyboardHook( int nCode, WPARAM wParam, LPARAM lParam )
{
if ( nCode >= HC_ACTION )
{
KBDLLHOOKSTRUCT* Message = reinterpret_cast< KBDLLHOOKSTRUCT* >( lParam );
switch ( wParam )
{
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
GetSingleton( )->DispatchKeyPressEvents( Message->vkCode );
break;
case WM_KEYUP:
case WM_SYSKEYUP:
GetSingleton( )->DispatchKeyReleaseEvents( Message->vkCode );
break;
default:
break;
}
}
return CallNextHookEx( GetSingleton( )->KeyboardHookObject, nCode, wParam, lParam );
}
Component* ActorFactory::CreateComponent(const tinyxml2::XMLElement* i_pNode, const char* i_pActorName)
{
if(i_pNode)
{
const char* pComponentID = i_pNode->Value();
Component* pComponent = GetSingleton().m_Factory.Create(ObjectId(pComponentID), i_pActorName);
if (pComponent)
{
if (pComponent->SetupFromXml(i_pNode))
{
return pComponent;
}
}
delete(pComponent);
MGD_LOG::LOGManager::GetSingleton().WriteLog(MGD_LOG::MGD_ERROR, ACTOR_FACTORY_CONTEXT, "Component failed to initialize: %s", pComponentID);
}
return NULL;
}
void CLogger::Initialise( ELogType logLevel )
{
_counter++;
if ( _singleton )
{
PARSER_EXCEPT( EShaderParserExceptionCodes_InternalError, ERROR_DB_LOGGER_ALREADY_INITIALISED );
}
else
{
_ownInstance = true;
CLogger & logger = GetSingleton();
delete logger._impl;
logger._impl = new CLoggerImpl;
logger._impl->Initialise( logger );
logger._logLevel = logLevel;
logger.DoInitialiseThread();
}
}
LRESULT CALLBACK EventSystem::MouseHook( int nCode, WPARAM wParam, LPARAM lParam )
{
if ( nCode >= HC_ACTION )
{
MSLLHOOKSTRUCT* Message = reinterpret_cast< MSLLHOOKSTRUCT* >( lParam );
switch( wParam )
{
case WM_LBUTTONDOWN:
GetSingleton( )->DispatchMouseDownEvents( Message->pt, MouseButton::MOUSE_LEFT );
break;
case WM_MBUTTONDOWN:
GetSingleton( )->DispatchMouseDownEvents( Message->pt, MouseButton::MOUSE_MIDDLE );
break;
case WM_RBUTTONDOWN:
GetSingleton( )->DispatchMouseDownEvents( Message->pt, MouseButton::MOUSE_RIGHT );
break;
case WM_LBUTTONUP:
GetSingleton( )->DispatchMouseUpEvents( Message->pt, MouseButton::MOUSE_LEFT );
break;
case WM_MBUTTONUP:
GetSingleton( )->DispatchMouseUpEvents( Message->pt, MouseButton::MOUSE_MIDDLE );
break;
case WM_RBUTTONUP:
GetSingleton( )->DispatchMouseUpEvents( Message->pt, MouseButton::MOUSE_RIGHT );
break;
case WM_MOUSEMOVE:
GetSingleton( )->DispatchMouseMoveEvents( Message->pt, MouseButton::MOUSE_NONE ); // TODO: Add button states to callback
break;
default:
break;
}
}
return CallNextHookEx( GetSingleton( )->MouseHookObject, nCode, wParam, lParam );
}
void ActorFactory::CreateActorFromTemplate(const char* i_pTemplateActorName, const char* i_pActorName)
{
if (i_pTemplateActorName && strlen(i_pTemplateActorName) > 0 && i_pActorName && strlen(i_pActorName) > 0)
{
MGDVector<Component*> pTemplateComponents;
SystemManager::GetSingleton().GetComponentsFromTemplate(ObjectId(i_pTemplateActorName), pTemplateComponents);
MGDVector<Component*> pNewComponents;
for (uint32 uiIndex = 0; uiIndex < pTemplateComponents.size(); ++uiIndex)
{
Component* pComponent = GetSingleton().m_Factory.Create(pTemplateComponents[uiIndex]->GetID(), i_pActorName, true);
if (pComponent)
{
pComponent->CreateFromTemplate(pTemplateComponents[uiIndex], ObjectId(i_pActorName));
SystemManager::GetSingleton().AddComponent(pComponent, ObjectId(i_pActorName));
pNewComponents.push_back(pComponent);
}
}
InitComponents(pNewComponents);
}
}
bool ImageBridgeChild::IsCreated()
{
return GetSingleton() != nullptr;
}
CLogger * CLogger::GetSingletonPtr()
{
return &GetSingleton();
}
void CLogger::LogError( std::wstring const & msg )
{
GetSingleton().DoPushMessage( ELogType_ERROR, msg );
}
void CLogger::LogWarning( std::wstring const & msg )
{
GetSingleton().DoPushMessage( ELogType_WARNING, msg );
}
void CLogger::LogInfo( std::wstring const & msg )
{
GetSingleton().DoPushMessage( ELogType_INFO, msg );
}
void CLogger::LogDebug( std::wstring const & msg )
{
GetSingleton().DoPushMessage( ELogType_DEBUG, msg );
}
void CLogger::SetLevel( ELogType logLevel )
{
GetSingleton()._logLevel = logLevel;
}
void CLI::Add(const std::string& identifier,
const std::string& description,
const std::string& alias,
const bool required,
const bool input)
{
// Temporarily define color code escape sequences.
#ifndef _WIN32
#define BASH_RED "\033[0;31m"
#define BASH_CLEAR "\033[0m"
#else
#define BASH_RED ""
#define BASH_CLEAR ""
#endif
// Temporary outstream object for detecting duplicate identifiers.
util::PrefixedOutStream outstr(std::cerr,
BASH_RED "[FATAL] " BASH_CLEAR, false, true /* fatal */);
#undef BASH_RED
#undef BASH_CLEAR
// Define identifier and alias maps.
gmap_t& gmap = GetSingleton().globalValues;
amap_t& amap = GetSingleton().aliasValues;
// If found in current map, print fatal error and terminate the program.
if (gmap.count(identifier))
outstr << "Parameter --" << identifier << "(-" << alias << ") "
<< "is defined multiple times with same identifiers." << std::endl;
if (amap.count(alias))
outstr << "Parameter --" << identifier << "(-" << alias << ") "
<< "is defined multiple times with same alias." << std::endl;
po::options_description& desc = CLI::GetSingleton().desc;
// Must make use of boost syntax here.
std::string progOptId =
alias.length() ? identifier + "," + alias : identifier;
// Add the alias, if necessary
AddAlias(alias, identifier);
// Add the option to boost program_options.
desc.add_options()(progOptId.c_str(), po::value<T>(), description.c_str());
// Make sure the appropriate metadata is inserted into gmap.
ParamData data;
T tmp = T();
data.desc = description;
data.name = identifier;
data.tname = TYPENAME(T);
data.value = boost::any(tmp);
data.wasPassed = false;
gmap[identifier] = data;
// If the option is required, add it to the required options list.
if (required)
GetSingleton().requiredOptions.push_front(identifier);
// Depending on whether or not the option is input or output, add it to the
// appropriate list.
if (input)
GetSingleton().inputOptions.push_front(identifier);
else
GetSingleton().outputOptions.push_front(identifier);
}
CDatabase* CDatabase::GetSingletonPtr ( )
{
return &GetSingleton ();
}
void
CompositorLRU::Init()
{
unused << GetSingleton();
}
