ParaEngineSettings.h

#pragma once
#include "IAttributeFields.h"
#include "util/NetworkAdapter.h"

namespace ParaEngine
{
    using namespace luabind;

    enum class LanguageType
    {
        ENGLISH = 0,
        CHINESE,
        FRENCH,
        ITALIAN,
        GERMAN,
        SPANISH,
        DUTCH,
        RUSSIAN,
        KOREAN,
        JAPANESE,
        HUNGARIAN,
        PORTUGUESE,
        ARABIC,
        NORWEGIAN,
        POLISH
    };

    class ParaEngineSettings : public IAttributeFields
    {
    public:
        ParaEngineSettings(void);
        virtual ~ParaEngineSettings(void);
        static ParaEngineSettings& GetSingleton();
    public:
        // implementation of IAttributeFields
        
        virtual int GetAttributeClassID(){return ATTRIBUTE_CLASSID_ParaEngineSetting;}
        virtual const char* GetAttributeClassName(){static const char name[] = "ParaEngineSettings"; return name;}
        virtual const char* GetAttributeClassDescription(){static const char desc[] = ""; return desc;}
        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

        virtual IAttributeFields* GetChildAttributeObject(const std::string& sName);
        virtual int GetChildAttributeObjectCount(int nColumnIndex = 0);
        virtual int GetChildAttributeColumnCount();
        virtual IAttributeFields* GetChildAttributeObject(int nRowIndex, int nColumnIndex = 0);

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetScriptEditor_s, const char**)  {*p1 = cls->GetScriptEditor().c_str(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetScriptEditor_s, const char*)   {cls->SetScriptEditor(p1); return S_OK;}
        
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetCtorColor_s, Vector3*)     {*p1 = cls->GetCtorColor().ToVector3(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetCtorColor_s, Vector3)      {LinearColor c(p1.x, p1.y,p1.z,1); cls->SetCtorColor(c); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetCtorHeight_s, float*)  {*p1 = cls->GetCtorHeight(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetCtorHeight_s, float)   {cls->SetCtorHeight(p1); return S_OK;}
        
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetCtorSpeed_s, float*)   {*p1 = cls->GetCtorSpeed(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetCtorSpeed_s, float)    {cls->SetCtorSpeed(p1); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetSelectionColor_s, Vector3*)        {*p1 = cls->GetSelectionColor().ToVector3(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetSelectionColor_s, Vector3)     {LinearColor c(p1.x, p1.y,p1.z,1); cls->SetSelectionColor(c); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, IsDebugging_s, bool*) {*p1 = cls->IsDebugging(); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, IsTouchInputting_s, bool*)    { *p1 = cls->IsTouchInputting(); return S_OK; }

        ATTRIBUTE_METHOD1(ParaEngineSettings, IsSlateMode_s, bool*) { *p1 = cls->IsSlateMode(); return S_OK; }

        ATTRIBUTE_METHOD1(ParaEngineSettings, IsServerMode_s, bool*) { *p1 = cls->IsServerMode(); return S_OK; }

        ATTRIBUTE_METHOD1(ParaEngineSettings, IsEditing_s, bool*)   {*p1 = cls->IsEditing(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetEditingMode_s, bool)   {cls->SetEditingMode(p1); return S_OK;}
        
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetLockWindowSize_s, bool)    { cls->SetLockWindowSize(p1); return S_OK; }

        ATTRIBUTE_METHOD1(ParaEngineSettings, IsShowWindowTitleBar_s, bool*)    { *p1 = cls->IsShowWindowTitleBar(); return S_OK; }
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetShowWindowTitleBar_s, bool)    { cls->SetShowWindowTitleBar(p1); return S_OK; }


        ATTRIBUTE_METHOD1(ParaEngineSettings, GetGameEffectSet_s, int*) {*p1 = cls->GetGameEffectSet(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, LoadGameEffectSet_s, int) {cls->LoadGameEffectSet(p1); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetTextureLOD_s, int*)    {*p1 = cls->GetTextureLOD(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetTextureLOD_s, int) {cls->SetTextureLOD(p1); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetLocale_s, const char**)    {*p1 = cls->GetLocale(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetLocale_s, const char*) {cls->SetLocale(p1); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetCurrentLanguage_s, int*)   { *p1 = (int)(cls->GetCurrentLanguage()); return S_OK; }

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetMouseInverse_s1, bool*)    {*p1 = cls->GetMouseInverse(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetMouseInverse_s1, bool) {cls->SetMouseInverse(p1); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetIgnoreWindowSizeChange_s, bool*)   {*p1 = cls->GetIgnoreWindowSizeChange(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetIgnoreWindowSizeChange_s, bool)    {cls->SetIgnoreWindowSizeChange(p1); return S_OK;}
            

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetWindowText1_s, const char**)   {*p1 = cls->GetWindowText1(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetWindowText1_s, const char*)    {cls->SetWindowText1(p1); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, IsWindowClosingAllowed_s, bool*)  {*p1 = cls->IsWindowClosingAllowed(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetAllowWindowClosing_s, bool)    {cls->SetAllowWindowClosing(p1); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, HasClosingRequest_s, bool*)   { *p1 = cls->HasClosingRequest(); return S_OK; }
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetHasClosingRequest_s, bool) { cls->SetHasClosingRequest(p1); return S_OK; }

        ATTRIBUTE_METHOD1(ParaEngineSettings, IsFullScreenMode_s, bool*)    {*p1 = cls->IsFullScreenMode(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetFullScreenMode_s, bool)    {cls->SetFullScreenMode(p1); return S_OK;}

        ATTRIBUTE_METHOD(ParaEngineSettings, BringWindowToTop_s)    {cls->BringWindowToTop(); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, HasNewConfig_s, bool*)    {*p1 = cls->HasNewConfig(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetHasNewConfig_s, bool)  {cls->SetHasNewConfig(p1); return S_OK;}
        
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetScreenResolution_s, Vector2*)      {*p1 = cls->GetScreenResolution(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetScreenResolution_s, Vector2)       {cls->SetScreenResolution(p1); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetMultiSampleType_s, int*)   {*p1 = cls->GetMultiSampleType(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetMultiSampleType_s, int)    {cls->SetMultiSampleType(p1); return S_OK;}
        
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetMultiSampleQuality_s, int*)    {*p1 = cls->GetMultiSampleQuality(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetMultiSampleQuality_s, int) {cls->SetMultiSampleQuality(p1); return S_OK;}

        ATTRIBUTE_METHOD(ParaEngineSettings, UpdateScreenMode_s)    {cls->UpdateScreenMode(); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, SetShowMenu_s, bool)  {cls->ShowMenu(p1); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, IsProfilingEnabled_s, bool*)  {*p1 = cls->IsProfilingEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, EnableProfiling_s, bool)  {cls->EnableProfiling(p1); return S_OK;}
        
        ATTRIBUTE_METHOD1(ParaEngineSettings, Is3DRenderingEnabled_s, bool*)    {*p1 = cls->Is3DRenderingEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, Enable3DRendering_s, bool)    {cls->Enable3DRendering(p1); return S_OK;}
        
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetAsyncLoaderItemsLeft_s, int*)  {*p1 = cls->GetAsyncLoaderItemsLeft(-2); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetAsyncLoaderBytesReceived_s, int*)  {*p1 = cls->GetAsyncLoaderBytesReceived(-2); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetAsyncLoaderRemainingBytes_s, int*) {*p1 = cls->GetAsyncLoaderRemainingBytes(); return S_OK;}
        
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetVertexShaderVersion_s, int*)   {*p1 = cls->GetVertexShaderVersion(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetPixelShaderVersion_s, int*)    {*p1 = cls->GetPixelShaderVersion(); return S_OK;}
        
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetRefreshTimer_s, float*)    {*p1 = cls->GetRefreshTimer(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetRefreshTimer_s, float) {cls->SetRefreshTimer(p1); return S_OK;}
        
        ATTRIBUTE_METHOD(ParaEngineSettings, AllocConsole_s)    {cls->AllocConsole(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetConsoleTextAttribute_s, int)   {cls->SetConsoleTextAttribute(p1); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetAppCount_s, int*)  { *p1 = cls->GetAppCount(); return S_OK; }

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetCoreUsage_s, int*) {*p1 = cls->GetCoreUsage(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetCoreUsage_s, int)  {cls->SetCoreUsage(p1); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetProcessId_s, int*) { *p1 = cls->GetProcessId(); return S_OK; }
        
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetSystemInfoString_s, const char**)  {*p1 = cls->GetSystemInfoString().c_str(); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetMaxMacAddress_s, const char**) {*p1 = cls->GetMaxMacAddress().c_str(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetMaxIPAddress_s, const char**)  { *p1 = cls->GetMaxIPAddress().c_str(); return S_OK; }

        
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetAutoLowerFrameRateWhenNotFocused_s, bool*) {*p1 = cls->GetAutoLowerFrameRateWhenNotFocused(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetAutoLowerFrameRateWhenNotFocused_s, bool)  {cls->SetAutoLowerFrameRateWhenNotFocused(p1); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetToggleSoundWhenNotFocused_s, bool*)    {*p1 = cls->GetToggleSoundWhenNotFocused(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetToggleSoundWhenNotFocused_s, bool) {cls->SetToggleSoundWhenNotFocused(p1); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, Is32bitsTextureEnabled_s, bool*)  {*p1 = cls->Is32bitsTextureEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, Enable32bitsTexture_s, bool)  {cls->Enable32bitsTexture(p1); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetAppHasFocus_s, bool*)  {*p1 = cls->GetAppHasFocus(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetAppHasFocus_s, bool)   {cls->SetAppHasFocus(p1); return S_OK;}

        ATTRIBUTE_METHOD1(ParaEngineSettings, IsMouseCaptured_s, bool*) { *p1 = cls->IsMouseCaptured(); return S_OK; }
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetCaptureMouse_s, bool)  { cls->SetCaptureMouse(p1); return S_OK; }

        ATTRIBUTE_METHOD1(ParaEngineSettings, IsSandboxMode_s, bool*) { *p1 = cls->IsSandboxMode(); return S_OK; }
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetSandboxMode_s, bool) { if(p1) cls->SetSandboxMode(p1); return S_OK; }

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetDisplayMode_s, const char**)   {*p1 = cls->GetDispalyMode().c_str(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetMonitorResolution_s, Vector2*) {*p1 = cls->GetMonitorResolution(); return S_OK;}
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetWindowResolution_s, Vector2*)  { *p1 = cls->GetWindowResolution(); return S_OK; }
        
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetDefaultOpenFileFolder_s, const char*)  { cls->SetDefaultOpenFileFolder(p1); return S_OK; }
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetOpenFolder_s, const char**)    { *p1 = cls->GetOpenFolder(); return S_OK; }

        ATTRIBUTE_METHOD1(ParaEngineSettings, SetIcon_s, const char*)   { cls->SetIcon(p1); return S_OK; }

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetPlatform_s, int*)  { *p1 = cls->GetPlatform(); return S_OK; }
        ATTRIBUTE_METHOD1(ParaEngineSettings, IsMobilePlatform_s, bool*)    { *p1 = cls->IsMobilePlatform(); return S_OK; }
        
        ATTRIBUTE_METHOD1(ParaEngineSettings, Is64BitsSystem_s, bool*)  { *p1 = cls->Is64BitsSystem(); return S_OK; }

        ATTRIBUTE_METHOD(ParaEngineSettings, RecreateRenderer_s)    { cls->RecreateRenderer(); return S_OK; }

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetFPS_s, float*) { *p1 = (float)(cls->GetFPS()); return S_OK; }
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetDrawCallCount_s, int*) { *p1 = cls->GetDrawCallCount(); return S_OK; }
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetTriangleCount_s, int*) { *p1 = cls->GetTriangleCount(); return S_OK; }

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetPeakMemoryUse_s, int*) { *p1 = cls->GetPeakMemoryUse(); return S_OK; }
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetCurrentMemoryUse_s, int*)  { *p1 = cls->GetCurrentMemoryUse(); return S_OK; }
        ATTRIBUTE_METHOD1(ParaEngineSettings, GetVertexBufferPoolTotalBytes_s, int*)    { *p1 = (int)cls->GetVertexBufferPoolTotalBytes(); return S_OK; }

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetWritablePath_s, const char**) { *p1 = cls->GetWritablePath(); return S_OK; }
        ATTRIBUTE_METHOD1(ParaEngineSettings, SetWritablePath_s, const char*) { cls->SetWritablePath(p1); return S_OK; }

        ATTRIBUTE_METHOD1(ParaEngineSettings, GetAppHWND_s, double*) { *p1 = (double)cls->GetAppHWND(); return S_OK; }
    public:
        static bool IsSandboxMode();

        static void SetSandboxMode(bool val);

        static void SetOceanTechnique(DWORD dwTechnique);

        void SetScriptEditor(const string& sEditorFilePath);
        const string& GetScriptEditor();
    
        void SetDefaultOpenFileFolder(const char* sDefaultOpenFileFolder);

        const char* GetOpenFolder();

        void RecreateRenderer();
        //
        // mesh construction settings
        //

        LinearColor GetCtorColor();
        static LinearColor GetCtorColorS(){ return GetSingleton().GetCtorColor();};
        void SetCtorColor(const LinearColor& color);
        static void SetCtorColorS(const LinearColor& color){ GetSingleton().SetCtorColor(color);};

        void AllocConsole();

        void SetConsoleTextAttribute(int wAttributes);
    
        DWORD GetCoreUsage();

        void SetCoreUsage(DWORD dwUsage);

        int GetProcessId();

        LinearColor GetSelectionColor(int nGroupID=0);
        static LinearColor GetSelectionColorS(){ return GetSingleton().GetSelectionColor();};
        void SetSelectionColor(const LinearColor& color,int nGroupID=0);
        static void SetSelectionColorS(const LinearColor& color){ GetSingleton().SetSelectionColor(color);};


        float  GetCtorHeight();
        static float  GetCtorHeightS(){ return GetSingleton().GetCtorHeight();};
        void SetCtorHeight(float fHeight);
        static void SetCtorHeightS(float fHeight){ GetSingleton().SetCtorHeight(fHeight);};

        float  GetCtorSpeed();
        static float  GetCtorSpeedS(){ return GetSingleton().GetCtorSpeed();};

        void SetCtorSpeed(float fSpeed);
        static void SetCtorSpeedS(float fSpeed){ GetSingleton().SetCtorSpeed(fSpeed);};
        
        static void GetClientSize(int* width, int* height);

        static void EnableProfiling(bool bEnable);
        static bool IsProfilingEnabled();

        static string GetStats(DWORD dwFields);

        int GetPeakMemoryUse();

        int GetCurrentMemoryUse();

        static void SetRefreshTimer(float fTimerInterval);

        static float GetRefreshTimer();

        static int GetPlatform();

        static bool IsMobilePlatform();

        static bool Is64BitsSystem();
        //
        // global effect and light settings
        //

        void LoadGameEffectSet(int nSetID);
        int GetGameEffectSet();
        static void LoadGameEffectSetS(int nSetID){ GetSingleton().LoadGameEffectSet(nSetID);};
        static int GetGameEffectSetS(){ return GetSingleton().GetGameEffectSet();};

        
        
        void SetTextureLOD(int nLOD);
        int GetTextureLOD();

        /* get the current number of ParaEngine app running. */
        int GetAppCount();

        int GetDrawCallCount();
        int GetTriangleCount();
        int GetFPS();

        void Enable32bitsTexture(bool bEnable);

        bool Is32bitsTextureEnabled();

        static bool IsDebugging();

        static bool IsTouchInputting();

        static bool IsSlateMode();

        bool HasNewConfig();
        void SetHasNewConfig(bool bHasNewConfig);

        static bool IsEditing();
        static void SetEditingMode(bool bEnable);

        static bool IsServerMode();

        const char* GetLocale();
        static const char* GetLocaleS(){ return GetSingleton().GetLocale();};

        void SetLocale(const char* sLocale);
        static void SetLocaleS(const char* sLocale){ GetSingleton().SetLocale(sLocale);};

        void SetIcon(const char* sIconFile);

        LanguageType GetCurrentLanguage();
        void SetCurrentLanguage(LanguageType lang);
        
        static bool IsProductActivated();
        static bool ActivateProduct(const char* sActivationCode);

        static const char* GetProductKey(const char* sProductName);

        static bool GenerateActivationCodes(const char* sOutputFileName, int nFrom, int nTo);

        void SetFullScreenMode(bool bFullscreen);
        bool IsFullScreenMode();

        void BringWindowToTop();

        Vector2 GetScreenResolution();
        void SetScreenResolution(const Vector2& vSize);

        Vector2 GetWindowResolution();

        int GetMultiSampleType();
        void SetMultiSampleType(int nType);

        int GetMultiSampleQuality();
        void SetMultiSampleQuality(int nType);

        int GetVertexShaderVersion();

        int GetPixelShaderVersion();
        
        const std::string& GetDispalyMode();

        Vector2 GetMonitorResolution();


        const std::string& GetSystemInfoString(bool bRefresh = false);

        void UpdateScreenMode();

        static bool SetWindowedMode(bool bWindowed);

        static bool IsWindowedMode();

        void Enable3DRendering(bool bPause);

        bool Is3DRenderingEnabled();

        static void SetAllowWindowClosing(bool bAllowClosing);

        static bool IsWindowClosingAllowed();

        static void ShowMenu(bool bShow);

        static void SetIgnoreWindowSizeChange(bool bIgnoreSizeChange);

        static bool GetIgnoreWindowSizeChange();


        static void    EnablePassiveRendering(bool bEnable);
        static bool IsPassiveRenderingEnabled();

        static void SetWindowText(const char* pChar);
        void SetWindowText1(const char* pChar){SetWindowText(pChar);};
        static const char* GetWindowText();
        const char* GetWindowText1(){return GetWindowText();};

        static void WriteConfigFile(const char* sFileName);

        void SetMouseInverse(bool bInverse);
        static void SetMouseInverse_s(bool bInverse){GetSingleton().SetMouseInverse(bInverse);};
        bool GetMouseInverse();
        static bool GetMouseInverse_s(){return GetSingleton().GetMouseInverse();};

        static const char* GetAppCommandLine();

        static const char* GetAppCommandLineByParam(const char* pParam, const object& defaultValue);

        static void SetAppCommandLine(const char* pCommandLine);

        int GetAsyncLoaderItemsLeft(int nItemType);
        static int GetAsyncLoaderItemsLeftS(int nItemType) {return GetSingleton().GetAsyncLoaderItemsLeft(nItemType);} ;

        int GetAsyncLoaderBytesReceived(int nItemType);
        static int GetAsyncLoaderBytesReceivedS(int nItemType) {return GetSingleton().GetAsyncLoaderBytesReceived(nItemType);};

        int GetAsyncLoaderRemainingBytes();

        void SetAutoLowerFrameRateWhenNotFocused(bool bEnabled); 
        bool GetAutoLowerFrameRateWhenNotFocused(); 

        void SetToggleSoundWhenNotFocused(bool bEnabled); 
        bool GetToggleSoundWhenNotFocused();

        void SetAppHasFocus(bool bEnabled); 
        bool GetAppHasFocus();

        void SetCaptureMouse(bool bCapture);
        bool IsMouseCaptured();

        void SetLockWindowSize(bool bEnabled);

        void SetShowWindowTitleBar(bool bEnabled);
        bool IsShowWindowTitleBar();

        const std::string& GetMaxMacAddress();

        const std::string& GetMaxIPAddress();

        size_t GetVertexBufferPoolTotalBytes();

        bool HasClosingRequest();
        void SetHasClosingRequest(bool val);

        const char* GetWritablePath();

        void SetWritablePath(const char* sPath);

        static intptr_t GetAppHWND();
    protected:
        void LoadNameIndex();
    private:
        LinearColor m_ctorColor;
        LinearColor m_selectionColor;

        float m_ctorHeight;
        float m_ctorSpeed;
        bool m_bEditingMode;
        static bool m_bSandboxMode;
        string m_sScriptEditorPath;
        bool m_bInverseMouse;
        /* current system language. */
        int m_currentLanguage;

        string m_sLocale;
        string m_displayModes;

        std::map<std::string, int> m_name_to_index;
    };
}