Merge remote-tracking branch '1vanK/master'

Source/Samples/14_SoundEffects/SoundEffects.cpp

@@ -67,7 +67,7 @@ void SoundEffects::Setup()
 {
     // Modify engine startup parameters
     Sample::Setup();
-    engineParameters_["Sound"] = true;
+    engineParameters_[EP_SOUND] = true;
 }
 
 void SoundEffects::Start()

Source/Samples/29_SoundSynthesis/SoundSynthesis.cpp

@@ -51,7 +51,7 @@ void SoundSynthesis::Setup()
 {
     // Modify engine startup parameters
     Sample::Setup();
-    engineParameters_["Sound"] = true;
+    engineParameters_[EP_SOUND] = true;
 }
 
 void SoundSynthesis::Start()

Source/Samples/Sample.inl

@@ -26,6 +26,7 @@
 #include <Urho3D/UI/Cursor.h>
 #include <Urho3D/Engine/DebugHud.h>
 #include <Urho3D/Engine/Engine.h>
+#include <Urho3D/Engine/EngineDefs.h>
 #include <Urho3D/IO/FileSystem.h>
 #include <Urho3D/Graphics/Graphics.h>
 #include <Urho3D/Input/Input.h>
@@ -56,17 +57,17 @@ Sample::Sample(Context* context) :
 void Sample::Setup()
 {
     // Modify engine startup parameters
-    engineParameters_["WindowTitle"] = GetTypeName();
-    engineParameters_["LogName"]     = GetSubsystem<FileSystem>()->GetAppPreferencesDir("urho3d", "logs") + GetTypeName() + ".log";
-    engineParameters_["FullScreen"]  = false;
-    engineParameters_["Headless"]    = false;
-    engineParameters_["Sound"]       = false;
+    engineParameters_[EP_WINDOW_TITLE] = GetTypeName();
+    engineParameters_[EP_LOG_NAME]     = GetSubsystem<FileSystem>()->GetAppPreferencesDir("urho3d", "logs") + GetTypeName() + ".log";
+    engineParameters_[EP_FULL_SCREEN]  = false;
+    engineParameters_[EP_HEADLESS]     = false;
+    engineParameters_[EP_SOUND]        = false;
 
     // Construct a search path to find the resource prefix with two entries:
     // The first entry is an empty path which will be substituted with program/bin directory -- this entry is for binary when it is still in build tree
     // The second and third entries are possible relative paths from the installed program/bin directory to the asset directory -- these entries are for binary when it is in the Urho3D SDK installation location
-    if (!engineParameters_.Contains("ResourcePrefixPaths"))
-        engineParameters_["ResourcePrefixPaths"] = ";../share/Resources;../share/Urho3D/Resources";
+    if (!engineParameters_.Contains(EP_RESOURCE_PREFIX_PATHS))
+        engineParameters_[EP_RESOURCE_PREFIX_PATHS] = ";../share/Resources;../share/Urho3D/Resources";
 }
 
 void Sample::Start()

Source/Tools/ScriptCompiler/ScriptCompiler.cpp

@@ -25,6 +25,7 @@
 #include <Urho3D/Core/Context.h>
 #include <Urho3D/Core/ProcessUtils.h>
 #include <Urho3D/Engine/Engine.h>
+#include <Urho3D/Engine/EngineDefs.h>
 #include <Urho3D/IO/File.h>
 #include <Urho3D/IO/FileSystem.h>
 #include <Urho3D/IO/Log.h>
@@ -85,11 +86,11 @@ int main(int argc, char** argv)
     if (dumpApiMode)
     {
         VariantMap engineParameters;
-        engineParameters["Headless"] = true;
-        engineParameters["WorkerThreads"] = false;
-        engineParameters["LogName"] = String::EMPTY;
-        engineParameters["ResourcePaths"] = String::EMPTY;
-        engineParameters["AutoloadPaths"] = String::EMPTY;
+        engineParameters[EP_HEADLESS] = true;
+        engineParameters[EP_WORKER_THREADS] = false;
+        engineParameters[EP_LOG_NAME] = String::EMPTY;
+        engineParameters[EP_RESOURCE_PATHS] = String::EMPTY;
+        engineParameters[EP_AUTOLOAD_PATHS] = String::EMPTY;
         engine->Initialize(engineParameters);
     #ifdef URHO3D_LUA
         context->RegisterSubsystem(new LuaScript(context));

Source/Tools/Urho3DPlayer/Urho3DPlayer.cpp

@@ -26,6 +26,7 @@
 #endif
 #include <Urho3D/Core/Main.h>
 #include <Urho3D/Engine/Engine.h>
+#include <Urho3D/Engine/EngineDefs.h>
 #include <Urho3D/IO/FileSystem.h>
 #include <Urho3D/IO/Log.h>
 #ifdef URHO3D_LUA
@@ -121,18 +122,18 @@ void Urho3DPlayer::Setup()
     else
     {
         // Use the script file name as the base name for the log file
-        engineParameters_["LogName"] = filesystem->GetAppPreferencesDir("urho3d", "logs") + GetFileNameAndExtension(scriptFileName_) + ".log";
+        engineParameters_[EP_LOG_NAME] = filesystem->GetAppPreferencesDir("urho3d", "logs") + GetFileNameAndExtension(scriptFileName_) + ".log";
     }
 #else
     // On Web platform setup a default windowed resolution similar to the executable samples
-    engineParameters_["FullScreen"]  = false;
+    engineParameters_[EP_FULL_SCREEN]  = false;
 #endif
 
     // Construct a search path to find the resource prefix with two entries:
     // The first entry is an empty path which will be substituted with program/bin directory -- this entry is for binary when it is still in build tree
     // The second and third entries are possible relative paths from the installed program/bin directory to the asset directory -- these entries are for binary when it is in the Urho3D SDK installation location
-    if (!engineParameters_.Contains("ResourcePrefixPaths"))
-        engineParameters_["ResourcePrefixPaths"] = ";../share/Resources;../share/Urho3D/Resources";
+    if (!engineParameters_.Contains(EP_RESOURCE_PREFIX_PATHS))
+        engineParameters_[EP_RESOURCE_PREFIX_PATHS] = ";../share/Resources;../share/Urho3D/Resources";
 }
 
 void Urho3DPlayer::Start()

Source/Urho3D/Audio/Audio.h

@@ -115,7 +115,7 @@ public:
     /// Mix sound sources into the buffer.
     void MixOutput(void* dest, unsigned samples);
 
-    /// Final multiplier for for audio byte conversion
+    /// Final multiplier for for audio byte conversion.
 #ifdef __EMSCRIPTEN__
     static const int SAMPLE_SIZE_MUL = 2;
 #else

Source/Urho3D/Audio/AudioDefs.h

@@ -27,7 +27,7 @@
 namespace Urho3D
 {
 
-/// SoundSource type defaults
+// SoundSource type defaults
 static const String SOUND_MASTER = "Master";
 static const String SOUND_EFFECT = "Effect";
 static const String SOUND_AMBIENT = "Ambient";

Source/Urho3D/Audio/SoundSource.h

@@ -32,7 +32,7 @@ class Audio;
 class Sound;
 class SoundStream;
 
-// Compressed audio decode buffer length in milliseconds
+/// Compressed audio decode buffer length in milliseconds.
 static const int STREAM_BUFFER_LENGTH = 100;
 
 /// %Sound source component with stereo position. A sound source needs to be created to a node to be considered "enabled" and be able to play, however that node does not need to belong to a scene.

Source/Urho3D/Engine/Engine.cpp

@@ -31,6 +31,7 @@
 #include "../Engine/Console.h"
 #include "../Engine/DebugHud.h"
 #include "../Engine/Engine.h"
+#include "../Engine/EngineDefs.h"
 #include "../Graphics/Graphics.h"
 #include "../Graphics/Renderer.h"
 #include "../Input/Input.h"
@@ -161,7 +162,7 @@ bool Engine::Initialize(const VariantMap& parameters)
     URHO3D_PROFILE(InitEngine);
 
     // Set headless mode
-    headless_ = GetParameter(parameters, "Headless", false).GetBool();
+    headless_ = GetParameter(parameters, EP_HEADLESS, false).GetBool();
 
     // Register the rest of the subsystems
     if (!headless_)
@@ -184,23 +185,23 @@ bool Engine::Initialize(const VariantMap& parameters)
     Log* log = GetSubsystem<Log>();
     if (log)
     {
-        if (HasParameter(parameters, "LogLevel"))
-            log->SetLevel(GetParameter(parameters, "LogLevel").GetInt());
-        log->SetQuiet(GetParameter(parameters, "LogQuiet", false).GetBool());
-        log->Open(GetParameter(parameters, "LogName", "Urho3D.log").GetString());
+        if (HasParameter(parameters, EP_LOG_LEVEL))
+            log->SetLevel(GetParameter(parameters, EP_LOG_LEVEL).GetInt());
+        log->SetQuiet(GetParameter(parameters, EP_LOG_QUIET, false).GetBool());
+        log->Open(GetParameter(parameters, EP_LOG_NAME, "Urho3D.log").GetString());
     }
 
     // Set maximally accurate low res timer
     GetSubsystem<Time>()->SetTimerPeriod(1);
 
     // Configure max FPS
-    if (GetParameter(parameters, "FrameLimiter", true) == false)
+    if (GetParameter(parameters, EP_FRAME_LIMITER, true) == false)
         SetMaxFps(0);
 
     // Set amount of worker threads according to the available physical CPU cores. Using also hyperthreaded cores results in
     // unpredictable extra synchronization overhead. Also reserve one core for the main thread
 #ifdef URHO3D_THREADING
-    unsigned numThreads = GetParameter(parameters, "WorkerThreads", true).GetBool() ? GetNumPhysicalCPUs() - 1 : 0;
+    unsigned numThreads = GetParameter(parameters, EP_WORKER_THREADS, true).GetBool() ? GetNumPhysicalCPUs() - 1 : 0;
     if (numThreads)
     {
         GetSubsystem<WorkQueue>()->CreateThreads(numThreads);
@@ -213,13 +214,13 @@ bool Engine::Initialize(const VariantMap& parameters)
     ResourceCache* cache = GetSubsystem<ResourceCache>();
     FileSystem* fileSystem = GetSubsystem<FileSystem>();
 
-    Vector<String> resourcePrefixPaths = GetParameter(parameters, "ResourcePrefixPaths", String::EMPTY).GetString().Split(';', true);
+    Vector<String> resourcePrefixPaths = GetParameter(parameters, EP_RESOURCE_PREFIX_PATHS, String::EMPTY).GetString().Split(';', true);
     for (unsigned i = 0; i < resourcePrefixPaths.Size(); ++i)
         resourcePrefixPaths[i] = AddTrailingSlash(
             IsAbsolutePath(resourcePrefixPaths[i]) ? resourcePrefixPaths[i] : fileSystem->GetProgramDir() + resourcePrefixPaths[i]);
-    Vector<String> resourcePaths = GetParameter(parameters, "ResourcePaths", "Data;CoreData").GetString().Split(';');
-    Vector<String> resourcePackages = GetParameter(parameters, "ResourcePackages").GetString().Split(';');
-    Vector<String> autoLoadPaths = GetParameter(parameters, "AutoloadPaths", "Autoload").GetString().Split(';');
+    Vector<String> resourcePaths = GetParameter(parameters, EP_RESOURCE_PATHS, "Data;CoreData").GetString().Split(';');
+    Vector<String> resourcePackages = GetParameter(parameters, EP_RESOURCE_PACKAGES).GetString().Split(';');
+    Vector<String> autoLoadPaths = GetParameter(parameters, EP_AUTOLOAD_PATHS, "Autoload").GetString().Split(';');
 
     for (unsigned i = 0; i < resourcePaths.Size(); ++i)
     {
@@ -349,57 +350,57 @@ bool Engine::Initialize(const VariantMap& parameters)
         Graphics* graphics = GetSubsystem<Graphics>();
         Renderer* renderer = GetSubsystem<Renderer>();
 
-        if (HasParameter(parameters, "ExternalWindow"))
-            graphics->SetExternalWindow(GetParameter(parameters, "ExternalWindow").GetVoidPtr());
-        graphics->SetWindowTitle(GetParameter(parameters, "WindowTitle", "Urho3D").GetString());
-        graphics->SetWindowIcon(cache->GetResource<Image>(GetParameter(parameters, "WindowIcon", String::EMPTY).GetString()));
-        graphics->SetFlushGPU(GetParameter(parameters, "FlushGPU", false).GetBool());
-        graphics->SetOrientations(GetParameter(parameters, "Orientations", "LandscapeLeft LandscapeRight").GetString());
+        if (HasParameter(parameters, EP_EXTERNAL_WINDOW))
+            graphics->SetExternalWindow(GetParameter(parameters, EP_EXTERNAL_WINDOW).GetVoidPtr());
+        graphics->SetWindowTitle(GetParameter(parameters, EP_WINDOW_TITLE, "Urho3D").GetString());
+        graphics->SetWindowIcon(cache->GetResource<Image>(GetParameter(parameters, EP_WINDOW_ICON, String::EMPTY).GetString()));
+        graphics->SetFlushGPU(GetParameter(parameters, EP_FLUSH_GPU, false).GetBool());
+        graphics->SetOrientations(GetParameter(parameters, EP_ORIENTATIONS, "LandscapeLeft LandscapeRight").GetString());
 
-        if (HasParameter(parameters, "WindowPositionX") && HasParameter(parameters, "WindowPositionY"))
-            graphics->SetWindowPosition(GetParameter(parameters, "WindowPositionX").GetInt(),
-                GetParameter(parameters, "WindowPositionY").GetInt());
+        if (HasParameter(parameters, EP_WINDOW_POSITION_X) && HasParameter(parameters, EP_WINDOW_POSITION_Y))
+            graphics->SetWindowPosition(GetParameter(parameters, EP_WINDOW_POSITION_X).GetInt(),
+                GetParameter(parameters, EP_WINDOW_POSITION_Y).GetInt());
 
 #ifdef URHO3D_OPENGL
-        if (HasParameter(parameters, "ForceGL2"))
-            graphics->SetForceGL2(GetParameter(parameters, "ForceGL2").GetBool());
+        if (HasParameter(parameters, EP_FORCE_GL2))
+            graphics->SetForceGL2(GetParameter(parameters, EP_FORCE_GL2).GetBool());
 #endif
 
         if (!graphics->SetMode(
-            GetParameter(parameters, "WindowWidth", 0).GetInt(),
-            GetParameter(parameters, "WindowHeight", 0).GetInt(),
-            GetParameter(parameters, "FullScreen", true).GetBool(),
-            GetParameter(parameters, "Borderless", false).GetBool(),
-            GetParameter(parameters, "WindowResizable", false).GetBool(),
-            GetParameter(parameters, "HighDPI", false).GetBool(),
-            GetParameter(parameters, "VSync", false).GetBool(),
-            GetParameter(parameters, "TripleBuffer", false).GetBool(),
-            GetParameter(parameters, "MultiSample", 1).GetInt()
+            GetParameter(parameters, EP_WINDOW_WIDTH, 0).GetInt(),
+            GetParameter(parameters, EP_WINDOW_HEIGHT, 0).GetInt(),
+            GetParameter(parameters, EP_FULL_SCREEN, true).GetBool(),
+            GetParameter(parameters, EP_BORDERLESS, false).GetBool(),
+            GetParameter(parameters, EP_WINDOW_RESIZABLE, false).GetBool(),
+            GetParameter(parameters, EP_HIGH_DPI, false).GetBool(),
+            GetParameter(parameters, EP_VSYNC, false).GetBool(),
+            GetParameter(parameters, EP_TRIPLE_BUFFER, false).GetBool(),
+            GetParameter(parameters, EP_MULTI_SAMPLE, 1).GetInt()
         ))
             return false;
 
-        graphics->SetShaderCacheDir(GetParameter(parameters, "ShaderCacheDir", fileSystem->GetAppPreferencesDir("urho3d", "shadercache")).GetString());
+        graphics->SetShaderCacheDir(GetParameter(parameters, EP_SHADER_CACHE_DIR, fileSystem->GetAppPreferencesDir("urho3d", "shadercache")).GetString());
 
-        if (HasParameter(parameters, "DumpShaders"))
-            graphics->BeginDumpShaders(GetParameter(parameters, "DumpShaders", String::EMPTY).GetString());
-        if (HasParameter(parameters, "RenderPath"))
-            renderer->SetDefaultRenderPath(cache->GetResource<XMLFile>(GetParameter(parameters, "RenderPath").GetString()));
+        if (HasParameter(parameters, EP_DUMP_SHADERS))
+            graphics->BeginDumpShaders(GetParameter(parameters, EP_DUMP_SHADERS, String::EMPTY).GetString());
+        if (HasParameter(parameters, EP_RENDER_PATH))
+            renderer->SetDefaultRenderPath(cache->GetResource<XMLFile>(GetParameter(parameters, EP_RENDER_PATH).GetString()));
 
-        renderer->SetDrawShadows(GetParameter(parameters, "Shadows", true).GetBool());
-        if (renderer->GetDrawShadows() && GetParameter(parameters, "LowQualityShadows", false).GetBool())
+        renderer->SetDrawShadows(GetParameter(parameters, EP_SHADOWS, true).GetBool());
+        if (renderer->GetDrawShadows() && GetParameter(parameters, EP_LOW_QUALITY_SHADOWS, false).GetBool())
             renderer->SetShadowQuality(SHADOWQUALITY_SIMPLE_16BIT);
-        renderer->SetMaterialQuality(GetParameter(parameters, "MaterialQuality", QUALITY_HIGH).GetInt());
-        renderer->SetTextureQuality(GetParameter(parameters, "TextureQuality", QUALITY_HIGH).GetInt());
-        renderer->SetTextureFilterMode((TextureFilterMode)GetParameter(parameters, "TextureFilterMode", FILTER_TRILINEAR).GetInt());
-        renderer->SetTextureAnisotropy(GetParameter(parameters, "TextureAnisotropy", 4).GetInt());
+        renderer->SetMaterialQuality(GetParameter(parameters, EP_MATERIAL_QUALITY, QUALITY_HIGH).GetInt());
+        renderer->SetTextureQuality(GetParameter(parameters, EP_TEXTURE_QUALITY, QUALITY_HIGH).GetInt());
+        renderer->SetTextureFilterMode((TextureFilterMode)GetParameter(parameters, EP_TEXTURE_FILTER_MODE, FILTER_TRILINEAR).GetInt());
+        renderer->SetTextureAnisotropy(GetParameter(parameters, EP_TEXTURE_ANISOTROPY, 4).GetInt());
 
-        if (GetParameter(parameters, "Sound", true).GetBool())
+        if (GetParameter(parameters, EP_SOUND, true).GetBool())
         {
             GetSubsystem<Audio>()->SetMode(
-                GetParameter(parameters, "SoundBuffer", 100).GetInt(),
-                GetParameter(parameters, "SoundMixRate", 44100).GetInt(),
-                GetParameter(parameters, "SoundStereo", true).GetBool(),
-                GetParameter(parameters, "SoundInterpolation", true).GetBool()
+                GetParameter(parameters, EP_SOUND_BUFFER, 100).GetInt(),
+                GetParameter(parameters, EP_SOUND_MIX_RATE, 44100).GetInt(),
+                GetParameter(parameters, EP_SOUND_STEREO, true).GetBool(),
+                GetParameter(parameters, EP_SOUND_INTERPOLATION, true).GetBool()
             );
         }
     }
@@ -408,22 +409,22 @@ bool Engine::Initialize(const VariantMap& parameters)
     InitFPU();
 
     // Initialize input
-    if (HasParameter(parameters, "TouchEmulation"))
-        GetSubsystem<Input>()->SetTouchEmulation(GetParameter(parameters, "TouchEmulation").GetBool());
+    if (HasParameter(parameters, EP_TOUCH_EMULATION))
+        GetSubsystem<Input>()->SetTouchEmulation(GetParameter(parameters, EP_TOUCH_EMULATION).GetBool());
 
     // Initialize network
 #ifdef URHO3D_NETWORK
-    if (HasParameter(parameters, "PackageCacheDir"))
-        GetSubsystem<Network>()->SetPackageCacheDir(GetParameter(parameters, "PackageCacheDir").GetString());
+    if (HasParameter(parameters, EP_PACKAGE_CACHE_DIR))
+        GetSubsystem<Network>()->SetPackageCacheDir(GetParameter(parameters, EP_PACKAGE_CACHE_DIR).GetString());
 #endif
 
 #ifdef URHO3D_TESTING
-    if (HasParameter(parameters, "TimeOut"))
-        timeOut_ = GetParameter(parameters, "TimeOut", 0).GetInt() * 1000000LL;
+    if (HasParameter(parameters, EP_TIME_OUT))
+        timeOut_ = GetParameter(parameters, EP_TIME_OUT, 0).GetInt() * 1000000LL;
 #endif
 
 #ifdef URHO3D_PROFILING
-    if (GetParameter(parameters, "EventProfiler", true).GetBool())
+    if (GetParameter(parameters, EP_EVENT_PROFILER, true).GetBool())
     {
         context_->RegisterSubsystem(new EventProfiler(context_));
         EventProfiler::SetActive(true);
@@ -768,7 +769,7 @@ VariantMap Engine::ParseParameters(const Vector<String>& arguments)
 
     // Pre-initialize the parameters with environment variable values when they are set
     if (const char* paths = getenv("URHO3D_PREFIX_PATH"))
-        ret["ResourcePrefixPaths"] = paths;
+        ret[EP_RESOURCE_PREFIX_PATHS] = paths;
 
     for (unsigned i = 0; i < arguments.Size(); ++i)
     {
@@ -778,138 +779,138 @@ VariantMap Engine::ParseParameters(const Vector<String>& arguments)
             String value = i + 1 < arguments.Size() ? arguments[i + 1] : String::EMPTY;
 
             if (argument == "headless")
-                ret["Headless"] = true;
+                ret[EP_HEADLESS] = true;
             else if (argument == "nolimit")
-                ret["FrameLimiter"] = false;
+                ret[EP_FRAME_LIMITER] = false;
             else if (argument == "flushgpu")
-                ret["FlushGPU"] = true;
+                ret[EP_FLUSH_GPU] = true;
             else if (argument == "gl2")
-                ret["ForceGL2"] = true;
+                ret[EP_FORCE_GL2] = true;
             else if (argument == "landscape")
-                ret["Orientations"] = "LandscapeLeft LandscapeRight " + ret["Orientations"].GetString();
+                ret[EP_ORIENTATIONS] = "LandscapeLeft LandscapeRight " + ret[EP_ORIENTATIONS].GetString();
             else if (argument == "portrait")
-                ret["Orientations"] = "Portrait PortraitUpsideDown " + ret["Orientations"].GetString();
+                ret[EP_ORIENTATIONS] = "Portrait PortraitUpsideDown " + ret[EP_ORIENTATIONS].GetString();
             else if (argument == "nosound")
-                ret["Sound"] = false;
+                ret[EP_SOUND] = false;
             else if (argument == "noip")
-                ret["SoundInterpolation"] = false;
+                ret[EP_SOUND_INTERPOLATION] = false;
             else if (argument == "mono")
-                ret["SoundStereo"] = false;
+                ret[EP_SOUND_STEREO] = false;
             else if (argument == "prepass")
-                ret["RenderPath"] = "RenderPaths/Prepass.xml";
+                ret[EP_RENDER_PATH] = "RenderPaths/Prepass.xml";
             else if (argument == "deferred")
-                ret["RenderPath"] = "RenderPaths/Deferred.xml";
+                ret[EP_RENDER_PATH] = "RenderPaths/Deferred.xml";
             else if (argument == "renderpath" && !value.Empty())
             {
-                ret["RenderPath"] = value;
+                ret[EP_RENDER_PATH] = value;
                 ++i;
             }
             else if (argument == "noshadows")
-                ret["Shadows"] = false;
+                ret[EP_SHADOWS] = false;
             else if (argument == "lqshadows")
-                ret["LowQualityShadows"] = true;
+                ret[EP_LOW_QUALITY_SHADOWS] = true;
             else if (argument == "nothreads")
-                ret["WorkerThreads"] = false;
+                ret[EP_WORKER_THREADS] = false;
             else if (argument == "v")
-                ret["VSync"] = true;
+                ret[EP_VSYNC] = true;
             else if (argument == "t")
-                ret["TripleBuffer"] = true;
+                ret[EP_TRIPLE_BUFFER] = true;
             else if (argument == "w")
-                ret["FullScreen"] = false;
+                ret[EP_FULL_SCREEN] = false;
             else if (argument == "borderless")
-                ret["Borderless"] = true;
+                ret[EP_BORDERLESS] = true;
             else if (argument == "s")
-                ret["WindowResizable"] = true;
+                ret[EP_WINDOW_RESIZABLE] = true;
             else if (argument == "hd")
-                ret["HighDPI"] = true;
+                ret[EP_HIGH_DPI] = true;
             else if (argument == "q")
-                ret["LogQuiet"] = true;
+                ret[EP_LOG_QUIET] = true;
             else if (argument == "log" && !value.Empty())
             {
                 unsigned logLevel = GetStringListIndex(value.CString(), logLevelPrefixes, M_MAX_UNSIGNED);
                 if (logLevel != M_MAX_UNSIGNED)
                 {
-                    ret["LogLevel"] = logLevel;
+                    ret[EP_LOG_LEVEL] = logLevel;
                     ++i;
                 }
             }
             else if (argument == "x" && !value.Empty())
             {
-                ret["WindowWidth"] = ToInt(value);
+                ret[EP_WINDOW_WIDTH] = ToInt(value);
                 ++i;
             }
             else if (argument == "y" && !value.Empty())
             {
-                ret["WindowHeight"] = ToInt(value);
+                ret[EP_WINDOW_HEIGHT] = ToInt(value);
                 ++i;
             }
             else if (argument == "m" && !value.Empty())
             {
-                ret["MultiSample"] = ToInt(value);
+                ret[EP_MULTI_SAMPLE] = ToInt(value);
                 ++i;
             }
             else if (argument == "b" && !value.Empty())
             {
-                ret["SoundBuffer"] = ToInt(value);
+                ret[EP_SOUND_BUFFER] = ToInt(value);
                 ++i;
             }
             else if (argument == "r" && !value.Empty())
             {
-                ret["SoundMixRate"] = ToInt(value);
+                ret[EP_SOUND_MIX_RATE] = ToInt(value);
                 ++i;
             }
             else if (argument == "pp" && !value.Empty())
             {
-                ret["ResourcePrefixPaths"] = value;
+                ret[EP_RESOURCE_PREFIX_PATHS] = value;
                 ++i;
             }
             else if (argument == "p" && !value.Empty())
             {
-                ret["ResourcePaths"] = value;
+                ret[EP_RESOURCE_PATHS] = value;
                 ++i;
             }
             else if (argument == "pf" && !value.Empty())
             {
-                ret["ResourcePackages"] = value;
+                ret[EP_RESOURCE_PACKAGES] = value;
                 ++i;
             }
             else if (argument == "ap" && !value.Empty())
             {
-                ret["AutoloadPaths"] = value;
+                ret[EP_AUTOLOAD_PATHS] = value;
                 ++i;
             }
             else if (argument == "ds" && !value.Empty())
             {
-                ret["DumpShaders"] = value;
+                ret[EP_DUMP_SHADERS] = value;
                 ++i;
             }
             else if (argument == "mq" && !value.Empty())
             {
-                ret["MaterialQuality"] = ToInt(value);
+                ret[EP_MATERIAL_QUALITY] = ToInt(value);
                 ++i;
             }
             else if (argument == "tq" && !value.Empty())
             {
-                ret["TextureQuality"] = ToInt(value);
+                ret[EP_TEXTURE_QUALITY] = ToInt(value);
                 ++i;
             }
             else if (argument == "tf" && !value.Empty())
             {
-                ret["TextureFilterMode"] = ToInt(value);
+                ret[EP_TEXTURE_FILTER_MODE] = ToInt(value);
                 ++i;
             }
             else if (argument == "af" && !value.Empty())
             {
-                ret["TextureFilterMode"] = FILTER_ANISOTROPIC;
-                ret["TextureAnisotropy"] = ToInt(value);
+                ret[EP_TEXTURE_FILTER_MODE] = FILTER_ANISOTROPIC;
+                ret[EP_TEXTURE_ANISOTROPY] = ToInt(value);
                 ++i;
             }
             else if (argument == "touch")
-                ret["TouchEmulation"] = true;
+                ret[EP_TOUCH_EMULATION] = true;
 #ifdef URHO3D_TESTING
             else if (argument == "timeout" && !value.Empty())
             {
-                ret["TimeOut"] = ToInt(value);
+                ret[EP_TIME_OUT] = ToInt(value);
                 ++i;
             }
 #endif

Source/Urho3D/Engine/EngineDefs.h

@@ -0,0 +1,75 @@
+//
+// Copyright (c) 2008-2016 the Urho3D project.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#pragma once
+
+namespace Urho3D
+{
+
+// Engine parameters
+static const String EP_AUTOLOAD_PATHS = "AutoloadPaths";
+static const String EP_BORDERLESS = "Borderless";
+static const String EP_DUMP_SHADERS = "DumpShaders";
+static const String EP_EVENT_PROFILER = "EventProfiler";
+static const String EP_EXTERNAL_WINDOW = "ExternalWindow";
+static const String EP_FLUSH_GPU = "FlushGPU";
+static const String EP_FORCE_GL2 = "ForceGL2";
+static const String EP_FRAME_LIMITER = "FrameLimiter";
+static const String EP_FULL_SCREEN = "FullScreen";
+static const String EP_HEADLESS = "Headless";
+static const String EP_HIGH_DPI = "HighDPI";
+static const String EP_LOG_LEVEL = "LogLevel";
+static const String EP_LOG_NAME = "LogName";
+static const String EP_LOG_QUIET = "LogQuiet";
+static const String EP_LOW_QUALITY_SHADOWS = "LowQualityShadows";
+static const String EP_MATERIAL_QUALITY = "MaterialQuality";
+static const String EP_MULTI_SAMPLE = "MultiSample";
+static const String EP_ORIENTATIONS = "Orientations";
+static const String EP_PACKAGE_CACHE_DIR = "PackageCacheDir";
+static const String EP_RENDER_PATH = "RenderPath";
+static const String EP_RESOURCE_PACKAGES = "ResourcePackages";
+static const String EP_RESOURCE_PATHS = "ResourcePaths";
+static const String EP_RESOURCE_PREFIX_PATHS = "ResourcePrefixPaths";
+static const String EP_SHADER_CACHE_DIR = "ShaderCacheDir";
+static const String EP_SHADOWS = "Shadows";
+static const String EP_SOUND = "Sound";
+static const String EP_SOUND_BUFFER = "SoundBuffer";
+static const String EP_SOUND_INTERPOLATION = "SoundInterpolation";
+static const String EP_SOUND_MIX_RATE = "SoundMixRate";
+static const String EP_SOUND_STEREO = "SoundStereo";
+static const String EP_TEXTURE_ANISOTROPY = "TextureAnisotropy";
+static const String EP_TEXTURE_FILTER_MODE = "TextureFilterMode";
+static const String EP_TEXTURE_QUALITY = "TextureQuality";
+static const String EP_TIME_OUT = "TimeOut";
+static const String EP_TOUCH_EMULATION = "TouchEmulation";
+static const String EP_TRIPLE_BUFFER = "TripleBuffer";
+static const String EP_VSYNC = "VSync";
+static const String EP_WINDOW_HEIGHT = "WindowHeight";
+static const String EP_WINDOW_ICON = "WindowIcon";
+static const String EP_WINDOW_POSITION_X = "WindowPositionX";
+static const String EP_WINDOW_POSITION_Y = "WindowPositionY";
+static const String EP_WINDOW_RESIZABLE = "WindowResizable";
+static const String EP_WINDOW_TITLE = "WindowTitle";
+static const String EP_WINDOW_WIDTH = "WindowWidth";
+static const String EP_WORKER_THREADS = "WorkerThreads";
+
+}

Source/Urho3D/Graphics/GraphicsDefs.cpp

@@ -107,7 +107,7 @@ extern URHO3D_API const VertexElement LEGACY_VERTEXELEMENTS[] =
     VertexElement(TYPE_VECTOR4, SEM_TEXCOORD, 4, true),      // Instancematrix1
     VertexElement(TYPE_VECTOR4, SEM_TEXCOORD, 5, true),      // Instancematrix2
     VertexElement(TYPE_VECTOR4, SEM_TEXCOORD, 6, true),      // Instancematrix3
-    VertexElement(TYPE_INT, SEM_OBJECTINDEX, 0, false)      // Objectindex
+    VertexElement(TYPE_INT, SEM_OBJECTINDEX, 0, false)       // Objectindex
 };
 
 extern URHO3D_API const unsigned ELEMENT_TYPESIZES[] =