AS Bindings: Allows using generic calling convention on any platform [cache clear] (#2783)

Docs/GettingStarted.dox

@@ -110,6 +110,7 @@ A number of build options can be defined when invoking the build scripts or when
 |TVOS                 |0|Configure project for targeting tvOS platform (cmake_generic.sh and cmake-gui only)|
 |URHO3D_64BIT         |*|Enable 64-bit build, the default is set based on the native ABI of the chosen compiler toolchain|
 |URHO3D_ANGELSCRIPT   |1|Enable AngelScript scripting support|
+|URHO3D_FORCE_AS_MAX_PORTABILITY|0|Use generic calling convention for AngelScript on any platform|
 |URHO3D_LUA           |1|Enable Lua scripting support|
 |URHO3D_LUAJIT        |1|Enable Lua scripting support using LuaJIT (check LuaJIT's CMakeLists.txt for more options)|
 |URHO3D_LUAJIT_AMALG  |*|Enable LuaJIT amalgamated build (LuaJIT only); default to true when LuaJIT is enabled|

Source/CMakeLists.txt

@@ -74,7 +74,7 @@ endforeach ()
 
 if (URHO3D_ANGELSCRIPT)
     add_subdirectory (ThirdParty/AngelScript)
-    if (WEB OR (ARM AND URHO3D_64BIT))
+    if (WEB OR (ARM AND URHO3D_64BIT) OR URHO3D_FORCE_AS_MAX_PORTABILITY)
         add_subdirectory (ThirdParty/boost)
     endif ()
 endif ()

Source/ThirdParty/AngelScript/CMakeLists.txt

@@ -31,6 +31,10 @@ if (NOT EXCEPTIONS)
     add_definitions (-DAS_NO_EXCEPTIONS)
 endif ()
 
+if (URHO3D_FORCE_AS_MAX_PORTABILITY)
+    add_definitions (-DAS_MAX_PORTABILITY)
+endif ()
+
 # Define source files
 define_source_files (GLOB_CPP_PATTERNS source/*.cpp GLOB_H_PATTERNS include/*.h source/*.h)
 if (ARM)

Source/Tools/BindingGenerator/ASClassBinder.cpp

@@ -248,9 +248,9 @@ static void RegisterStaticFunction(const ClassStaticFunctionAnalyzer& functionAn
     result->reg_ << "    engine->RegisterGlobalFunction(\"" << decl << "\", ";
 
     if (needWrapper)
-        result->reg_ << "asFUNCTION(" << GenerateWrapperName(functionAnalyzer) << "), asCALL_CDECL);\n";
+        result->reg_ << "AS_FUNCTION(" << GenerateWrapperName(functionAnalyzer) << "), AS_CALL_CDECL);\n";
     else
-        result->reg_ << Generate_asFUNCTIONPR(functionAnalyzer) << ", asCALL_CDECL);\n";
+        result->reg_ << Generate_asFUNCTIONPR(functionAnalyzer) << ", AS_CALL_CDECL);\n";
 
     result->reg_ << "    engine->SetDefaultNamespace(\"\");\n";
 }
@@ -337,8 +337,8 @@ static void RegisterRefCountedConstructor(const ClassFunctionAnalyzer& functionA
             "        engine->RegisterObjectBehaviour(className, "
             "asBEHAVE_FACTORY, "
             "declFactory.CString(), "
-            "asFUNCTION(" << wrapperName << "), "
-            "asCALL_CDECL);\n"
+            "AS_FUNCTION(" << wrapperName << "), "
+            "AS_CALL_CDECL);\n"
             "    }\n";
     }
     else
@@ -349,8 +349,8 @@ static void RegisterRefCountedConstructor(const ClassFunctionAnalyzer& functionA
             "\"" << className << "\", "
             "asBEHAVE_FACTORY, "
             "\"" << decl << "\", "
-            "asFUNCTION(" << wrapperName << "), "
-            "asCALL_CDECL);\n";
+            "AS_FUNCTION(" << wrapperName << "), "
+            "AS_CALL_CDECL);\n";
     }
 
     if (!insideDefine.empty())
@@ -433,8 +433,8 @@ static void RegisterValueConstructor(const ClassFunctionAnalyzer& functionAnalyz
         "\"" << className << "\", "
         "asBEHAVE_CONSTRUCT, "
         "\"" << decl << "\", "
-        "asFUNCTION(" << wrapperName << "), "
-        "asCALL_CDECL_OBJFIRST);\n";
+        "AS_FUNCTION_OBJFIRST(" << wrapperName << "), "
+        "AS_CALL_CDECL_OBJFIRST);\n";
 
     if (isDefaultConstructor && !insideDefine.empty())
         reg << "#endif\n";
@@ -505,7 +505,7 @@ static void RegisterComparisonOperator(const ClassAnalyzer& classAnalyzer)
     result->reg_ <<
         "    // " << operatorLessLocation << "\n"
         "    // " << operatorGreaterLocation << "\n"
-        "    engine->RegisterObjectMethod(\"" << className << "\", \"int opCmp(const " << className << "&in) const\", asFUNCTION(" << wrapperName << "), asCALL_CDECL_OBJFIRST);\n";
+        "    engine->RegisterObjectMethod(\"" << className << "\", \"int opCmp(const " << className << "&in) const\", AS_FUNCTION_OBJFIRST(" << wrapperName << "), AS_CALL_CDECL_OBJFIRST);\n";
 }
 
 static void RegisterAddReleaseRef(const ClassFunctionAnalyzer& functionAnalyzer, bool templateVersion)
@@ -520,9 +520,9 @@ static void RegisterAddReleaseRef(const ClassFunctionAnalyzer& functionAnalyzer,
     result->reg_ << "    // " << functionAnalyzer.GetLocation() << "\n";
 
     if (templateVersion)
-        result->reg_ << "    engine->RegisterObjectBehaviour(className, " << behaviour << ", \"void f()\", "  << methodpr << ", asCALL_THISCALL);\n";
+        result->reg_ << "    engine->RegisterObjectBehaviour(className, " << behaviour << ", \"void f()\", "  << methodpr << ", AS_CALL_THISCALL);\n";
     else
-        result->reg_ << "    engine->RegisterObjectBehaviour(\"" << className << "\", " << behaviour << ", \"void f()\", " << methodpr << ", asCALL_THISCALL);\n";
+        result->reg_ << "    engine->RegisterObjectBehaviour(\"" << className << "\", " << behaviour << ", \"void f()\", " << methodpr << ", AS_CALL_THISCALL);\n";
 }
 
 static void RegisterFakeAddReleaseRef(const ClassAnalyzer& classAnalyzer)
@@ -531,8 +531,8 @@ static void RegisterFakeAddReleaseRef(const ClassAnalyzer& classAnalyzer)
     shared_ptr<ASGeneratedFile_Members> result = GetGeneratedFile(className);
 
     result->reg_ <<
-        "    engine->RegisterObjectBehaviour(\"" << className << "\", asBEHAVE_ADDREF, \"void f()\", asFUNCTION(FakeAddRef), asCALL_CDECL_OBJLAST);\n"
-        "    engine->RegisterObjectBehaviour(\"" << className << "\", asBEHAVE_RELEASE, \"void f()\", asFUNCTION(FakeReleaseRef), asCALL_CDECL_OBJLAST);\n";
+        "    engine->RegisterObjectBehaviour(\"" << className << "\", asBEHAVE_ADDREF, \"void f()\", AS_FUNCTION_OBJLAST(FakeAddRef), AS_CALL_CDECL_OBJLAST);\n"
+        "    engine->RegisterObjectBehaviour(\"" << className << "\", asBEHAVE_RELEASE, \"void f()\", AS_FUNCTION_OBJLAST(FakeReleaseRef), AS_CALL_CDECL_OBJLAST);\n";
 }
 
 // https://www.angelcode.com/angelscript/sdk/docs/manual/doc_script_class_ops.html
@@ -838,9 +838,9 @@ static void RegisterMethod(const ClassFunctionAnalyzer& functionAnalyzer, bool t
         result->reg_ << "    engine->RegisterObjectMethod(\"" << functionAnalyzer.GetClassName() << "\", \"" << decl << "\", ";
 
     if (needWrapper)
-        result->reg_ << "asFUNCTION(" << GenerateWrapperName(functionAnalyzer, templateVersion) << "), asCALL_CDECL_OBJFIRST);\n";
+        result->reg_ << "AS_FUNCTION_OBJFIRST(" << GenerateWrapperName(functionAnalyzer, templateVersion) << "), AS_CALL_CDECL_OBJFIRST);\n";
     else
-        result->reg_ << Generate_asMETHODPR(functionAnalyzer, templateVersion) << ", asCALL_THISCALL);\n";
+        result->reg_ << Generate_asMETHODPR(functionAnalyzer, templateVersion) << ", AS_CALL_THISCALL);\n";
 
     // Also register as property if needed
     string propertyMark = GetPropertyMark(functionAnalyzer);
@@ -874,9 +874,9 @@ static void RegisterMethod(const ClassFunctionAnalyzer& functionAnalyzer, bool t
             result->reg_ << "    engine->RegisterObjectMethod(\"" << functionAnalyzer.GetClassName() << "\", \"" << decl << "\", ";
 
         if (needWrapper)
-            result->reg_ << "asFUNCTION(" << GenerateWrapperName(functionAnalyzer, templateVersion) << "), asCALL_CDECL_OBJFIRST);\n";
+            result->reg_ << "AS_FUNCTION_OBJFIRST(" << GenerateWrapperName(functionAnalyzer, templateVersion) << "), AS_CALL_CDECL_OBJFIRST);\n";
         else
-            result->reg_ << Generate_asMETHODPR(functionAnalyzer, templateVersion) << ", asCALL_THISCALL);\n";
+            result->reg_ << Generate_asMETHODPR(functionAnalyzer, templateVersion) << ", AS_CALL_THISCALL);\n";
     }
 }
 

Source/Tools/BindingGenerator/ASClassBinderNew.cpp

@@ -111,7 +111,7 @@ static void RegisterDefaultConstructor(const ClassAnalyzer& classAnalyzer, Proce
         "    new(ptr) " + className + "();\n"
         "}\n";
 
-    result->registration_ = "engine->RegisterObjectBehaviour(\"" + className + "\", asBEHAVE_CONSTRUCT, \"void f()\", asFUNCTION(" + wrapperName + "), asCALL_CDECL_OBJFIRST);";
+    result->registration_ = "engine->RegisterObjectBehaviour(\"" + className + "\", asBEHAVE_CONSTRUCT, \"void f()\", AS_FUNCTION_OBJFIRST(" + wrapperName + "), AS_CALL_CDECL_OBJFIRST);";
 
     shared_ptr<ClassFunctionAnalyzer> defaultConstructor = classAnalyzer.GetDefinedThisDefaultConstructor();
 
@@ -142,13 +142,14 @@ static void RegisterDestructor(const ClassAnalyzer& classAnalyzer, ProcessedClas
 
     result->name_ = "~" + className;
 
+    // TODO: remove glue
     result->glue_ =
         "static void " + wrapperName + "(" + className + "* ptr)\n"
         "{\n"
         "    ptr->~" + className + "();\n"
         "}\n";
 
-    result->registration_ = "engine->RegisterObjectBehaviour(\"" + className + "\", asBEHAVE_DESTRUCT, \"void f()\", asFUNCTION(" + wrapperName + "), asCALL_CDECL_OBJFIRST);";
+    result->registration_ = "engine->RegisterObjectBehaviour(\"" + className + "\", asBEHAVE_DESTRUCT, \"void f()\", AS_DESTRUCTOR(" + className + "), AS_CALL_CDECL_OBJFIRST);";
 
     shared_ptr<ClassFunctionAnalyzer> thisDestructor = classAnalyzer.GetDefinedThisDestructor();
 

Source/Tools/BindingGenerator/ASGlobalFunctionBinder.cpp

@@ -165,9 +165,9 @@ static void BindGlobalFunction(const GlobalFunctionAnalyzer& functionAnalyzer)
     processedGlobalFunction.registration_ = "engine->RegisterGlobalFunction(\"" + decl + "\", ";
 
     if (needWrapper)
-        processedGlobalFunction.registration_ += "asFUNCTION(" + GenerateWrapperName(functionAnalyzer) + "), asCALL_CDECL);";
+        processedGlobalFunction.registration_ += "AS_FUNCTION(" + GenerateWrapperName(functionAnalyzer) + "), AS_CALL_CDECL);";
     else
-        processedGlobalFunction.registration_ += Generate_asFUNCTIONPR(functionAnalyzer) + ", asCALL_CDECL);";
+        processedGlobalFunction.registration_ += Generate_asFUNCTIONPR(functionAnalyzer) + ", AS_CALL_CDECL);";
 
     Result::globalFunctions_.push_back(processedGlobalFunction);
 
@@ -183,9 +183,9 @@ static void BindGlobalFunction(const GlobalFunctionAnalyzer& functionAnalyzer)
         processedGlobalFunction.registration_ = "engine->RegisterGlobalFunction(\"" + decl + "\", ";
 
         if (needWrapper)
-            processedGlobalFunction.registration_ += "asFUNCTION(" + GenerateWrapperName(functionAnalyzer) + "), asCALL_CDECL);";
+            processedGlobalFunction.registration_ += "AS_FUNCTION(" + GenerateWrapperName(functionAnalyzer) + "), AS_CALL_CDECL);";
         else
-            processedGlobalFunction.registration_ += Generate_asFUNCTIONPR(functionAnalyzer) + ", asCALL_CDECL);";
+            processedGlobalFunction.registration_ += Generate_asFUNCTIONPR(functionAnalyzer) + ", AS_CALL_CDECL);";
 
         Result::globalFunctions_.push_back(processedGlobalFunction);
     }

Source/Tools/BindingGenerator/ASResult.cpp

@@ -605,8 +605,8 @@ namespace Result
                 "    Vector<RegisterObjectMethodArgs> methods;\n"
                 "    CollectMembers_" << processedClass.name_ << "(methods);\n"
                 "    const char* asClassName = \"" << processedClass.name_ << "\";\n"
-                "    //for (const RegisterObjectMethodArgs& method : methods)\n"
-                "    //    engine->RegisterObjectMethod(asClassName, method.declaration_.CString(), method.funcPointer_, method.callConv_);\n";
+                "    for (const RegisterObjectMethodArgs& method : methods)\n"
+                "        engine->RegisterObjectMethod(asClassName, method.declaration_.CString(), method.funcPointer_, method.callConv_);\n";
 
             ofs << "}\n";
 

Source/Tools/BindingGenerator/ASUtils.cpp

@@ -791,7 +791,7 @@ string Generate_asFUNCTIONPR(const GlobalFunctionAnalyzer& functionAnalyzer)
     string functionName = functionAnalyzer.GetName();
     string cppParams = "(" + JoinParamsTypes(functionAnalyzer.GetMemberdef(), functionAnalyzer.GetSpecialization()) + ")";
     string returnType = functionAnalyzer.GetReturnType().ToString();
-    return "asFUNCTIONPR(" + functionName + ", " + cppParams + ", " + returnType + ")";
+    return "AS_FUNCTIONPR(" + functionName + ", " + cppParams + ", " + returnType + ")";
 }
 
 string Generate_asFUNCTIONPR(const ClassStaticFunctionAnalyzer& functionAnalyzer)
@@ -800,7 +800,7 @@ string Generate_asFUNCTIONPR(const ClassStaticFunctionAnalyzer& functionAnalyzer
     string functionName = functionAnalyzer.GetName();
     string cppParams = "(" + JoinParamsTypes(functionAnalyzer.GetMemberdef(), functionAnalyzer.GetSpecialization()) + ")";
     string returnType = functionAnalyzer.GetReturnType().ToString();
-    return "asFUNCTIONPR(" + className + "::" + functionName + ", " + cppParams + ", " + returnType + ")";
+    return "AS_FUNCTIONPR(" + className + "::" + functionName + ", " + cppParams + ", " + returnType + ")";
 }
 
 string Generate_asMETHODPR(const ClassFunctionAnalyzer& functionAnalyzer, bool templateVersion)
@@ -816,9 +816,9 @@ string Generate_asMETHODPR(const ClassFunctionAnalyzer& functionAnalyzer, bool t
     string returnType = functionAnalyzer.GetReturnType().ToString();
     
     if (templateVersion)
-        return "asMETHODPR(T, " + functionName + ", " + cppParams + ", " + returnType + ")";
+        return "AS_METHODPR(T, " + functionName + ", " + cppParams + ", " + returnType + ")";
     else
-        return "asMETHODPR(" + className + ", " + functionName + ", " + cppParams + ", " + returnType + ")";
+        return "AS_METHODPR(" + className + ", " + functionName + ", " + cppParams + ", " + returnType + ")";
 }
 
 } // namespace ASBindingGenerator

Source/Urho3D/AngelScript/APITemplates.h

@@ -45,9 +45,10 @@
 #endif
 
 #include <AngelScript/angelscript.h>
-#include "../AngelScript/wrapmacros.h"
 #include <cstring>
 
+#include "../AngelScript/RegistrationMacros.h"
+
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable:4505)
@@ -249,20 +250,20 @@ template <class BaseType, class DerivedType> void RegisterSubclass(asIScriptEngi
         return;
 
     String declReturnBase(String(baseClassName) + "@+ opImplCast()");
-    engine->RegisterObjectMethod(derivedClassName, declReturnBase.CString(), asFUNCTION((RefCast<DerivedType, BaseType>)), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(derivedClassName, declReturnBase.CString(), AS_FUNCTION_OBJLAST((RefCast<DerivedType, BaseType>)), AS_CALL_CDECL_OBJLAST);
 
     String declReturnBaseConst("const " + String(baseClassName) + "@+ opImplCast() const");
-    engine->RegisterObjectMethod(derivedClassName, declReturnBaseConst.CString(), asFUNCTION((RefCast<DerivedType, BaseType>)), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(derivedClassName, declReturnBaseConst.CString(), AS_FUNCTION_OBJLAST((RefCast<DerivedType, BaseType>)), AS_CALL_CDECL_OBJLAST);
 
     // TODO fix all scripts to "cast(derivedClass)"
 
     //String declReturnDerived(String(derivedClassName) + "@+ opCast()");
     String declReturnDerived(String(derivedClassName) + "@+ opImplCast()");
-    engine->RegisterObjectMethod(baseClassName, declReturnDerived.CString(), asFUNCTION((RefCast<BaseType, DerivedType>)), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(baseClassName, declReturnDerived.CString(), AS_FUNCTION_OBJLAST((RefCast<BaseType, DerivedType>)), AS_CALL_CDECL_OBJLAST);
 
     //String declReturnDerivedConst("const " + String(derivedClassName) + "@+ opCast() const");
     String declReturnDerivedConst("const " + String(derivedClassName) + "@+ opImplCast() const");
-    engine->RegisterObjectMethod(baseClassName, declReturnDerivedConst.CString(), asFUNCTION((RefCast<BaseType, DerivedType>)), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(baseClassName, declReturnDerivedConst.CString(), AS_FUNCTION_OBJLAST((RefCast<BaseType, DerivedType>)), AS_CALL_CDECL_OBJLAST);
 }
 
 // ================================================================================
@@ -295,7 +296,7 @@ template<typename classType, typename std::enable_if<std::is_copy_assignable<cla
 void RegisterImplicitlyDeclaredAssignOperatorIfPossible(asIScriptEngine* engine, const String& className)
 {
     String decl = className + "& opAssign(const " + className + "&in)";
-    engine->RegisterObjectMethod(className.CString(), decl.CString(), asMETHODPR(classType, operator=, (const classType&), classType&), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className.CString(), decl.CString(), AS_METHODPR(classType, operator=, (const classType&), classType&), AS_CALL_THISCALL);
 }
 
 // This empty function need to prevent build errors when classType have no assing operator
@@ -385,14 +386,14 @@ template <class T> T* ConstructNamedObject(const String& name)
 template <class T> void RegisterObjectConstructor(asIScriptEngine* engine, const char* className)
 {
     String declFactory(String(className) + "@ f()");
-    engine->RegisterObjectBehaviour(className, asBEHAVE_FACTORY, declFactory.CString(), asFUNCTION(ConstructObject<T>), asCALL_CDECL);
+    engine->RegisterObjectBehaviour(className, asBEHAVE_FACTORY, declFactory.CString(), AS_FUNCTION(ConstructObject<T>), AS_CALL_CDECL);
 }
 
 /// Template function for registering a named constructor for a class derived from Object.
 template <class T> void RegisterNamedObjectConstructor(asIScriptEngine* engine, const char* className)
 {
     String declFactoryWithName(String(className) + "@ f(const String&in)");
-    engine->RegisterObjectBehaviour(className, asBEHAVE_FACTORY, declFactoryWithName.CString(), asFUNCTION(ConstructNamedObject<T>), asCALL_CDECL);
+    engine->RegisterObjectBehaviour(className, asBEHAVE_FACTORY, declFactoryWithName.CString(), AS_FUNCTION(ConstructNamedObject<T>), AS_CALL_CDECL);
 }
 
 static bool SerializableLoad(File* file, Serializable* ptr)

Source/Urho3D/AngelScript/Addons.cpp

@@ -23,6 +23,7 @@
 #include "../Precompiled.h"
 
 #include "../AngelScript/Addons.h"
+#include "../AngelScript/RegistrationMacros.h"
 
 #include <cstring>
 #include <new>
@@ -1629,37 +1630,37 @@ static void ScriptArrayClear(CScriptArray* ptr)
 
 void RegisterArray(asIScriptEngine* engine)
 {
-    engine->RegisterObjectBehaviour("Array<T>", asBEHAVE_TEMPLATE_CALLBACK, "bool f(int&in, bool&out)", asFUNCTION(ScriptArrayTemplateCallback), asCALL_CDECL);
-    engine->RegisterObjectBehaviour("Array<T>", asBEHAVE_FACTORY, "Array<T>@ f(int&in)", asFUNCTIONPR(CScriptArray::Create, (asITypeInfo*), CScriptArray*), asCALL_CDECL);
-    engine->RegisterObjectBehaviour("Array<T>", asBEHAVE_FACTORY, "Array<T>@ f(int&in, uint)", asFUNCTIONPR(CScriptArray::Create, (asITypeInfo*, asUINT), CScriptArray*), asCALL_CDECL);
-    engine->RegisterObjectBehaviour("Array<T>", asBEHAVE_FACTORY, "Array<T>@ f(int&in, uint, const T &in)", asFUNCTIONPR(CScriptArray::Create, (asITypeInfo*, asUINT, void *), CScriptArray*), asCALL_CDECL);
-    engine->RegisterObjectBehaviour("Array<T>", asBEHAVE_LIST_FACTORY, "Array<T>@ f(int&in type, int&in list) {repeat T}", asFUNCTIONPR(CScriptArray::Create, (asITypeInfo*, void*), CScriptArray*), asCALL_CDECL);
-    engine->RegisterObjectBehaviour("Array<T>", asBEHAVE_ADDREF, "void f()", asMETHOD(CScriptArray, AddRef), asCALL_THISCALL);
-    engine->RegisterObjectBehaviour("Array<T>", asBEHAVE_RELEASE, "void f()", asMETHOD(CScriptArray, Release), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "T& opIndex(uint)", asMETHODPR(CScriptArray, At, (unsigned), void*), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "const T& opIndex(uint) const", asMETHODPR(CScriptArray, At, (unsigned), void*), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "Array<T>& opAssign(const Array<T>& in)", asMETHOD(CScriptArray, operator=), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "void Insert(uint, const T& in)", asMETHOD(CScriptArray, InsertAt), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "void Erase(uint)", asMETHOD(CScriptArray, RemoveAt), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "void Push(const T& in)", asMETHOD(CScriptArray, InsertLast), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "void Pop()", asMETHOD(CScriptArray, RemoveLast), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "void Reserve(uint)", asMETHOD(CScriptArray, Reserve), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "void Resize(uint)", asMETHODPR(CScriptArray, Resize, (asUINT), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "void Clear()", asFUNCTION(ScriptArrayClear), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Array<T>", "void Sort()", asMETHODPR(CScriptArray, SortAsc, (), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "void Sort(uint, uint)", asMETHODPR(CScriptArray, SortAsc, (asUINT, asUINT), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "void SortReverse()", asMETHODPR(CScriptArray, SortDesc, (), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "void SortReverse(uint, uint)", asMETHODPR(CScriptArray, SortDesc, (asUINT, asUINT), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "void Reverse()", asMETHOD(CScriptArray, Reverse), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "int Find(const T&in) const", asMETHODPR(CScriptArray, Find, (void*) const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "int Find(uint, const T&in) const", asMETHODPR(CScriptArray, Find, (asUINT, void*) const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "int FindByRef(const T&in) const", asMETHODPR(CScriptArray, FindByRef, (void*) const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "int FindByRef(uint, const T&in) const", asMETHODPR(CScriptArray, FindByRef, (asUINT, void*) const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "bool Swap(Array<T>&inout)", asMETHOD(CScriptArray, Swap), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "bool opEquals(const Array<T>&in) const", asMETHOD(CScriptArray, operator==), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "uint get_length() const", asMETHOD(CScriptArray, GetSize), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "void set_length(uint)", asMETHODPR(CScriptArray, Resize, (asUINT), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Array<T>", "bool get_empty() const", asMETHOD(CScriptArray, IsEmpty), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour("Array<T>", asBEHAVE_TEMPLATE_CALLBACK, "bool f(int&in, bool&out)", AS_FUNCTION(ScriptArrayTemplateCallback), AS_CALL_CDECL);
+    engine->RegisterObjectBehaviour("Array<T>", asBEHAVE_FACTORY, "Array<T>@ f(int&in)", AS_FUNCTIONPR(CScriptArray::Create, (asITypeInfo*), CScriptArray*), AS_CALL_CDECL);
+    engine->RegisterObjectBehaviour("Array<T>", asBEHAVE_FACTORY, "Array<T>@ f(int&in, uint)", AS_FUNCTIONPR(CScriptArray::Create, (asITypeInfo*, asUINT), CScriptArray*), AS_CALL_CDECL);
+    engine->RegisterObjectBehaviour("Array<T>", asBEHAVE_FACTORY, "Array<T>@ f(int&in, uint, const T &in)", AS_FUNCTIONPR(CScriptArray::Create, (asITypeInfo*, asUINT, void *), CScriptArray*), AS_CALL_CDECL);
+    engine->RegisterObjectBehaviour("Array<T>", asBEHAVE_LIST_FACTORY, "Array<T>@ f(int&in type, int&in list) {repeat T}", AS_FUNCTIONPR(CScriptArray::Create, (asITypeInfo*, void*), CScriptArray*), AS_CALL_CDECL);
+    engine->RegisterObjectBehaviour("Array<T>", asBEHAVE_ADDREF, "void f()", AS_METHOD(CScriptArray, AddRef), AS_CALL_THISCALL);
+    engine->RegisterObjectBehaviour("Array<T>", asBEHAVE_RELEASE, "void f()", AS_METHOD(CScriptArray, Release), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "T& opIndex(uint)", AS_METHODPR(CScriptArray, At, (unsigned), void*), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "const T& opIndex(uint) const", AS_METHODPR(CScriptArray, At, (unsigned), void*), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "Array<T>& opAssign(const Array<T>& in)", AS_METHOD(CScriptArray, operator=), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "void Insert(uint, const T& in)", AS_METHOD(CScriptArray, InsertAt), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "void Erase(uint)", AS_METHOD(CScriptArray, RemoveAt), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "void Push(const T& in)", AS_METHOD(CScriptArray, InsertLast), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "void Pop()", AS_METHOD(CScriptArray, RemoveLast), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "void Reserve(uint)", AS_METHOD(CScriptArray, Reserve), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "void Resize(uint)", AS_METHODPR(CScriptArray, Resize, (asUINT), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "void Clear()", AS_FUNCTION_OBJLAST(ScriptArrayClear), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Array<T>", "void Sort()", AS_METHODPR(CScriptArray, SortAsc, (), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "void Sort(uint, uint)", AS_METHODPR(CScriptArray, SortAsc, (asUINT, asUINT), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "void SortReverse()", AS_METHODPR(CScriptArray, SortDesc, (), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "void SortReverse(uint, uint)", AS_METHODPR(CScriptArray, SortDesc, (asUINT, asUINT), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "void Reverse()", AS_METHOD(CScriptArray, Reverse), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "int Find(const T&in) const", AS_METHODPR(CScriptArray, Find, (void*) const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "int Find(uint, const T&in) const", AS_METHODPR(CScriptArray, Find, (asUINT, void*) const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "int FindByRef(const T&in) const", AS_METHODPR(CScriptArray, FindByRef, (void*) const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "int FindByRef(uint, const T&in) const", AS_METHODPR(CScriptArray, FindByRef, (asUINT, void*) const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "bool Swap(Array<T>&inout)", AS_METHOD(CScriptArray, Swap), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "bool opEquals(const Array<T>&in) const", AS_METHOD(CScriptArray, operator==), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "uint get_length() const", AS_METHOD(CScriptArray, GetSize), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "void set_length(uint)", AS_METHODPR(CScriptArray, Resize, (asUINT), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Array<T>", "bool get_empty() const", AS_METHOD(CScriptArray, IsEmpty), AS_CALL_THISCALL);
     engine->RegisterDefaultArrayType("Array<T>");
 }
 
@@ -2289,39 +2290,39 @@ static void ScriptDictionaryGet_Generic(asIScriptGeneric *gen)
 
 void RegisterDictionary(asIScriptEngine *engine)
 {
-    engine->RegisterObjectBehaviour("DictionaryValue", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(CScriptDictValue_Construct), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectBehaviour("DictionaryValue", asBEHAVE_DESTRUCT, "void f()", asFUNCTION(CScriptDictValue_Destruct), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("DictionaryValue", "DictionaryValue &opAssign(double)", asFUNCTIONPR(CScriptDictValue_opAssign, (double, CScriptDictValue*), CScriptDictValue &), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("DictionaryValue", "DictionaryValue &opAssign(int64)", asFUNCTIONPR(CScriptDictValue_opAssign, (asINT64, CScriptDictValue*), CScriptDictValue &), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("DictionaryValue", "int64 opConv()", asFUNCTIONPR(CScriptDictValue_opConvInt, (CScriptDictValue*), asINT64), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("DictionaryValue", "double opConv()", asFUNCTIONPR(CScriptDictValue_opConvDouble, (CScriptDictValue*), double), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectBehaviour("DictionaryValue", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJLAST(CScriptDictValue_Construct), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectBehaviour("DictionaryValue", asBEHAVE_DESTRUCT, "void f()", AS_FUNCTION_OBJLAST(CScriptDictValue_Destruct), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("DictionaryValue", "DictionaryValue &opAssign(double)", AS_FUNCTIONPR_OBJLAST(CScriptDictValue_opAssign, (double, CScriptDictValue*), CScriptDictValue &), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("DictionaryValue", "DictionaryValue &opAssign(int64)", AS_FUNCTIONPR_OBJLAST(CScriptDictValue_opAssign, (asINT64, CScriptDictValue*), CScriptDictValue &), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("DictionaryValue", "int64 opConv()", AS_FUNCTIONPR_OBJLAST(CScriptDictValue_opConvInt, (CScriptDictValue*), asINT64), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("DictionaryValue", "double opConv()", AS_FUNCTIONPR_OBJLAST(CScriptDictValue_opConvDouble, (CScriptDictValue*), double), AS_CALL_CDECL_OBJLAST);
 
     engine->RegisterObjectType("Dictionary", sizeof(CScriptDictionary), asOBJ_REF);
     engine->RegisterObjectBehaviour("Dictionary", asBEHAVE_FACTORY, "Dictionary@ f()", asFUNCTION(ScriptDictionaryFactory_Generic), asCALL_GENERIC);
     engine->RegisterObjectBehaviour("Dictionary", asBEHAVE_LIST_FACTORY, "Dictionary @f(int &in) {repeat {String, ?}}", asFUNCTION(ScriptDictionaryListFactory_Generic), asCALL_GENERIC);
-    engine->RegisterObjectBehaviour("Dictionary", asBEHAVE_ADDREF, "void f()", asMETHOD(CScriptDictionary,AddRef), asCALL_THISCALL);
-    engine->RegisterObjectBehaviour("Dictionary", asBEHAVE_RELEASE, "void f()", asMETHOD(CScriptDictionary,Release), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Dictionary", "Dictionary &opAssign(const Dictionary &in)", asMETHODPR(CScriptDictionary, operator=, (const CScriptDictionary &), CScriptDictionary&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Dictionary", "void Set(const String &in, const int64&in)", asMETHODPR(CScriptDictionary,Set,(const String&,const asINT64&),void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Dictionary", "bool Get(const String &in, int64&out) const", asMETHODPR(CScriptDictionary,Get,(const String&,asINT64&) const,bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Dictionary", "void Set(const String &in, const double&in)", asMETHODPR(CScriptDictionary,Set,(const String&,const double&),void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Dictionary", "bool Get(const String &in, double&out) const", asMETHODPR(CScriptDictionary,Get,(const String&,double&) const,bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Dictionary", "bool Exists(const String &in) const", asMETHOD(CScriptDictionary,Exists), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Dictionary", "bool get_empty() const", asMETHOD(CScriptDictionary, IsEmpty), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Dictionary", "uint get_length() const", asMETHOD(CScriptDictionary, GetSize), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Dictionary", "void Erase(const String &in)", asMETHOD(CScriptDictionary,Delete), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Dictionary", "void Clear()", asMETHOD(CScriptDictionary,DeleteAll), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Dictionary", "Array<String> @get_keys() const", asMETHOD(CScriptDictionary,GetKeys), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Dictionary", "DictionaryValue &opIndex(const String &in)", asMETHODPR(CScriptDictionary, operator[], (const String &), CScriptDictValue*), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Dictionary", "const DictionaryValue &opIndex(const String &in) const", asMETHODPR(CScriptDictionary, operator[], (const String &) const, const CScriptDictValue*), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour("Dictionary", asBEHAVE_ADDREF, "void f()", AS_METHOD(CScriptDictionary,AddRef), AS_CALL_THISCALL);
+    engine->RegisterObjectBehaviour("Dictionary", asBEHAVE_RELEASE, "void f()", AS_METHOD(CScriptDictionary,Release), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Dictionary", "Dictionary &opAssign(const Dictionary &in)", AS_METHODPR(CScriptDictionary, operator=, (const CScriptDictionary &), CScriptDictionary&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Dictionary", "void Set(const String &in, const int64&in)", AS_METHODPR(CScriptDictionary,Set,(const String&,const asINT64&),void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Dictionary", "bool Get(const String &in, int64&out) const", AS_METHODPR(CScriptDictionary,Get,(const String&,asINT64&) const,bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Dictionary", "void Set(const String &in, const double&in)", AS_METHODPR(CScriptDictionary,Set,(const String&,const double&),void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Dictionary", "bool Get(const String &in, double&out) const", AS_METHODPR(CScriptDictionary,Get,(const String&,double&) const,bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Dictionary", "bool Exists(const String &in) const", AS_METHOD(CScriptDictionary,Exists), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Dictionary", "bool get_empty() const", AS_METHOD(CScriptDictionary, IsEmpty), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Dictionary", "uint get_length() const", AS_METHOD(CScriptDictionary, GetSize), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Dictionary", "void Erase(const String &in)", AS_METHOD(CScriptDictionary,Delete), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Dictionary", "void Clear()", AS_METHOD(CScriptDictionary,DeleteAll), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Dictionary", "Array<String> @get_keys() const", AS_METHOD(CScriptDictionary,GetKeys), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Dictionary", "DictionaryValue &opIndex(const String &in)", AS_METHODPR(CScriptDictionary, operator[], (const String &), CScriptDictValue*), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Dictionary", "const DictionaryValue &opIndex(const String &in) const", AS_METHODPR(CScriptDictionary, operator[], (const String &) const, const CScriptDictValue*), AS_CALL_THISCALL);
 
 #ifndef AS_MAX_PORTABILITY
-    engine->RegisterObjectMethod("DictionaryValue", "DictionaryValue &opHndlAssign(const ?&in)", asFUNCTIONPR(CScriptDictValue_opAssign, (void *, int, CScriptDictValue*), CScriptDictValue &), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("DictionaryValue", "DictionaryValue &opAssign(const ?&in)", asFUNCTIONPR(CScriptDictValue_opAssign, (void *, int, CScriptDictValue*), CScriptDictValue &), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("DictionaryValue", "void opCast(?&out)", asFUNCTIONPR(CScriptDictValue_opCast, (void *, int, CScriptDictValue*), void), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("DictionaryValue", "void opConv(?&out)", asFUNCTIONPR(CScriptDictValue_opCast, (void *, int, CScriptDictValue*), void), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Dictionary", "void Set(const String &in, const ?&in)", asMETHODPR(CScriptDictionary, Set, (const String&, void*, int), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Dictionary", "bool Get(const String &in, ?&out) const", asMETHODPR(CScriptDictionary, Get, (const String&, void*, int) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("DictionaryValue", "DictionaryValue &opHndlAssign(const ?&in)", AS_FUNCTIONPR_OBJLAST(CScriptDictValue_opAssign, (void *, int, CScriptDictValue*), CScriptDictValue &), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("DictionaryValue", "DictionaryValue &opAssign(const ?&in)", AS_FUNCTIONPR_OBJLAST(CScriptDictValue_opAssign, (void *, int, CScriptDictValue*), CScriptDictValue &), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("DictionaryValue", "void opCast(?&out)", AS_FUNCTIONPR_OBJLAST(CScriptDictValue_opCast, (void *, int, CScriptDictValue*), void), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("DictionaryValue", "void opConv(?&out)", AS_FUNCTIONPR_OBJLAST(CScriptDictValue_opCast, (void *, int, CScriptDictValue*), void), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Dictionary", "void Set(const String &in, const ?&in)", AS_METHODPR(CScriptDictionary, Set, (const String&, void*, int), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Dictionary", "bool Get(const String &in, ?&out) const", AS_METHODPR(CScriptDictionary, Get, (const String&, void*, int) const, bool), AS_CALL_THISCALL);
 #else
     engine->RegisterObjectMethod("DictionaryValue", "DictionaryValue &opHndlAssign(const ?&in)", asFUNCTION(CScriptDictValue_opAssign_gen), asCALL_GENERIC);
     engine->RegisterObjectMethod("DictionaryValue", "DictionaryValue &opAssign(const ?&in)", asFUNCTION(CScriptDictValue_opAssign_gen), asCALL_GENERIC);

Source/Urho3D/AngelScript/Addons.h

@@ -33,7 +33,6 @@
 #include "../Math/StringHash.h"
 
 #include <AngelScript/angelscript.h>
-#include "../AngelScript/wrapmacros.h"
 
 // Adapted from Angelscript's scriptarray, scriptdictionary & scriptstdstring add-ons, but with garbage collection disabled
 

Source/Urho3D/AngelScript/CoreAPI.cpp

@@ -47,8 +47,8 @@ void ArrayToStringVector(CScriptArray* arr, StringVector& dest)
 
 static void RegisterVariant(asIScriptEngine* engine)
 {
-    engine->RegisterGlobalFunction("VariantType GetVariantTypeFromName(const String&in)", asFUNCTIONPR(Variant::GetTypeFromName, (const String&), VariantType), asCALL_CDECL);
-    engine->RegisterGlobalFunction("String GetVariantTypeName(VariantType)", asFUNCTIONPR(Variant::GetTypeName, (VariantType), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("VariantType GetVariantTypeFromName(const String&in)", AS_FUNCTIONPR(Variant::GetTypeFromName, (const String&), VariantType), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("String GetVariantTypeName(VariantType)", AS_FUNCTIONPR(Variant::GetTypeName, (VariantType), String), AS_CALL_CDECL);
 }
 
 static String StringJoined(CScriptArray* arr, const String& glue)
@@ -59,28 +59,28 @@ static String StringJoined(CScriptArray* arr, const String& glue)
 
 static void RegisterStringUtils(asIScriptEngine* engine)
 {
-    engine->RegisterObjectMethod("String", "bool ToBool() const", asFUNCTIONPR(ToBool, (const String&), bool), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "float ToFloat() const", asFUNCTIONPR(ToFloat, (const String&), float), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "double ToDouble() const", asFUNCTIONPR(ToDouble, (const String&), double), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "int ToInt(int base = 10) const", asFUNCTIONPR(ToInt, (const String&, int), int), asCALL_CDECL_OBJFIRST);
-    engine->RegisterObjectMethod("String", "uint ToUInt(int base = 10) const", asFUNCTIONPR(ToUInt, (const String&, int), unsigned), asCALL_CDECL_OBJFIRST);
-    engine->RegisterObjectMethod("String", "int64 ToInt64(int base = 10) const", asFUNCTIONPR(ToInt64, (const String&, int), long long), asCALL_CDECL_OBJFIRST);
-    engine->RegisterObjectMethod("String", "uint64 ToUInt64(int base = 10) const", asFUNCTIONPR(ToUInt64, (const String&, int), unsigned long long), asCALL_CDECL_OBJFIRST);
-    engine->RegisterObjectMethod("String", "Color ToColor() const", asFUNCTIONPR(ToColor, (const String&), Color), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "IntRect ToIntRect() const", asFUNCTIONPR(ToIntRect, (const String&), IntRect), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "IntVector2 ToIntVector2() const", asFUNCTIONPR(ToIntVector2, (const String&), IntVector2), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "IntVector3 ToIntVector3() const", asFUNCTIONPR(ToIntVector3, (const String&), IntVector3), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "Quaternion ToQuaternion() const", asFUNCTIONPR(ToQuaternion, (const String&), Quaternion), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "Vector2 ToVector2() const", asFUNCTIONPR(ToVector2, (const String&), Vector2), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "Vector3 ToVector3() const", asFUNCTIONPR(ToVector3, (const String&), Vector3), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "Vector4 ToVector4(bool allowMissingCoords = false) const", asFUNCTIONPR(ToVector4, (const String&, bool), Vector4), asCALL_CDECL_OBJFIRST);
-    engine->RegisterObjectMethod("String", "Variant ToVectorVariant() const", asFUNCTIONPR(ToVectorVariant, (const String&), Variant), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "Matrix3 ToMatrix3() const", asFUNCTIONPR(ToMatrix3, (const String&), Matrix3), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "Matrix3x4 ToMatrix3x4() const", asFUNCTIONPR(ToMatrix3x4, (const String&), Matrix3x4), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "Matrix4 ToMatrix4() const", asFUNCTIONPR(ToMatrix4, (const String&), Matrix4), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "bool ToBool() const", AS_FUNCTIONPR_OBJLAST(ToBool, (const String&), bool), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "float ToFloat() const", AS_FUNCTIONPR_OBJLAST(ToFloat, (const String&), float), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "double ToDouble() const", AS_FUNCTIONPR_OBJLAST(ToDouble, (const String&), double), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "int ToInt(int base = 10) const", AS_FUNCTIONPR_OBJLAST(ToInt, (const String&, int), int), AS_CALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod("String", "uint ToUInt(int base = 10) const", AS_FUNCTIONPR_OBJLAST(ToUInt, (const String&, int), unsigned), AS_CALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod("String", "int64 ToInt64(int base = 10) const", AS_FUNCTIONPR_OBJLAST(ToInt64, (const String&, int), long long), AS_CALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod("String", "uint64 ToUInt64(int base = 10) const", AS_FUNCTIONPR_OBJLAST(ToUInt64, (const String&, int), unsigned long long), AS_CALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod("String", "Color ToColor() const", AS_FUNCTIONPR_OBJLAST(ToColor, (const String&), Color), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "IntRect ToIntRect() const", AS_FUNCTIONPR_OBJLAST(ToIntRect, (const String&), IntRect), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "IntVector2 ToIntVector2() const", AS_FUNCTIONPR_OBJLAST(ToIntVector2, (const String&), IntVector2), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "IntVector3 ToIntVector3() const", AS_FUNCTIONPR_OBJLAST(ToIntVector3, (const String&), IntVector3), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "Quaternion ToQuaternion() const", AS_FUNCTIONPR_OBJLAST(ToQuaternion, (const String&), Quaternion), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "Vector2 ToVector2() const", AS_FUNCTIONPR_OBJLAST(ToVector2, (const String&), Vector2), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "Vector3 ToVector3() const", AS_FUNCTIONPR_OBJLAST(ToVector3, (const String&), Vector3), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "Vector4 ToVector4(bool allowMissingCoords = false) const", AS_FUNCTIONPR_OBJLAST(ToVector4, (const String&, bool), Vector4), AS_CALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod("String", "Variant ToVectorVariant() const", AS_FUNCTIONPR_OBJLAST(ToVectorVariant, (const String&), Variant), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "Matrix3 ToMatrix3() const", AS_FUNCTIONPR_OBJLAST(ToMatrix3, (const String&), Matrix3), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "Matrix3x4 ToMatrix3x4() const", AS_FUNCTIONPR_OBJLAST(ToMatrix3x4, (const String&), Matrix3x4), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "Matrix4 ToMatrix4() const", AS_FUNCTIONPR_OBJLAST(ToMatrix4, (const String&), Matrix4), AS_CALL_CDECL_OBJLAST);
 
     //engine->RegisterGlobalFunction("String ToStringHex(int)", asFUNCTION(ToStringHex), asCALL_CDECL);
-    engine->RegisterGlobalFunction("String Join(String[]&, const String&in glue)", asFUNCTION(StringJoined), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String Join(String[]&, const String&in glue)", AS_FUNCTION(StringJoined), AS_CALL_CDECL);
 }
 
 static Object* CreateObject(const String& objectType)
@@ -203,23 +203,23 @@ static VariantMap& GetGlobalVars()
 
 void RegisterObject(asIScriptEngine* engine)
 {
-    engine->RegisterGlobalFunction("Object@ CreateObject(const String&in)", asFUNCTION(CreateObject), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void SendEvent(const String&in, VariantMap& eventData = VariantMap())", asFUNCTION(SendEvent), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void SubscribeToEvent(const String&in, const String&in)", asFUNCTION(SubscribeToEvent), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void SubscribeToEvent(Object@+, const String&in, const String&in)", asFUNCTION(SubscribeToSenderEvent), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void UnsubscribeFromEvent(const String&in)", asFUNCTION(UnsubscribeFromEvent), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void UnsubscribeFromEvent(Object@+, const String&in)", asFUNCTION(UnsubscribeFromSenderEvent), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void UnsubscribeFromEvents(Object@+)", asFUNCTION(UnsubscribeFromSenderEvents), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void UnsubscribeFromAllEvents()", asFUNCTION(UnsubscribeFromAllEvents), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void UnsubscribeFromAllEventsExcept(Array<String>@+)", asFUNCTION(UnsubscribeFromAllEventsExcept), asCALL_CDECL);
-    engine->RegisterGlobalFunction("bool HasSubscribedToEvent(const String&in)", asFUNCTION(HasSubscribedToEvent), asCALL_CDECL);
-    engine->RegisterGlobalFunction("bool HasSubscribedToEvent(Object@+, const String&in)", asFUNCTION(HasSubscribedToSenderEvent), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void RegisterEventName(const String&in)", asFUNCTION(RegisterEventName), asCALL_CDECL);
-    engine->RegisterGlobalFunction("Object@+ GetEventSender()", asFUNCTION(GetEventSender), asCALL_CDECL);
-    engine->RegisterGlobalFunction("const String& GetTypeName(StringHash)", asFUNCTION(GetTypeName), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void SetGlobalVar(const String&in, Variant&in)", asFUNCTION(SetGlobalVar), asCALL_CDECL);
-    engine->RegisterGlobalFunction("Variant GetGlobalVar(const String&in)", asFUNCTION(GetGlobalVar), asCALL_CDECL);
-    engine->RegisterGlobalFunction("VariantMap& get_globalVars()", asFUNCTION(GetGlobalVars), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Object@ CreateObject(const String&in)", AS_FUNCTION(CreateObject), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void SendEvent(const String&in, VariantMap& eventData = VariantMap())", AS_FUNCTION(SendEvent), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void SubscribeToEvent(const String&in, const String&in)", AS_FUNCTION(SubscribeToEvent), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void SubscribeToEvent(Object@+, const String&in, const String&in)", AS_FUNCTION(SubscribeToSenderEvent), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void UnsubscribeFromEvent(const String&in)", AS_FUNCTION(UnsubscribeFromEvent), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void UnsubscribeFromEvent(Object@+, const String&in)", AS_FUNCTION(UnsubscribeFromSenderEvent), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void UnsubscribeFromEvents(Object@+)", AS_FUNCTION(UnsubscribeFromSenderEvents), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void UnsubscribeFromAllEvents()", AS_FUNCTION(UnsubscribeFromAllEvents), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void UnsubscribeFromAllEventsExcept(Array<String>@+)", AS_FUNCTION(UnsubscribeFromAllEventsExcept), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("bool HasSubscribedToEvent(const String&in)", AS_FUNCTION(HasSubscribedToEvent), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("bool HasSubscribedToEvent(Object@+, const String&in)", AS_FUNCTION(HasSubscribedToSenderEvent), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void RegisterEventName(const String&in)", AS_FUNCTION(RegisterEventName), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("Object@+ GetEventSender()", AS_FUNCTION(GetEventSender), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("const String& GetTypeName(StringHash)", AS_FUNCTION(GetTypeName), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void SetGlobalVar(const String&in, Variant&in)", AS_FUNCTION(SetGlobalVar), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("Variant GetGlobalVar(const String&in)", AS_FUNCTION(GetGlobalVar), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("VariantMap& get_globalVars()", AS_FUNCTION(GetGlobalVars), AS_CALL_CDECL);
 }
 
 void RegisterCoreAPI(asIScriptEngine* engine)

Source/Urho3D/AngelScript/GeneratedDefaultConstructors.cpp

@@ -797,395 +797,395 @@ static void Vertex2D_Constructor(Vertex2D* ptr)
 void ASRegisterGeneratedDefaultConstructors(asIScriptEngine* engine)
 {
     // AllocatorBlock::AllocatorBlock() | Implicitly-declared
-    engine->RegisterObjectBehaviour("AllocatorBlock", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(AllocatorBlock_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("AllocatorBlock", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(AllocatorBlock_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // AllocatorNode::AllocatorNode() | Implicitly-declared
-    engine->RegisterObjectBehaviour("AllocatorNode", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(AllocatorNode_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("AllocatorNode", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(AllocatorNode_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // AnimationKeyFrame::AnimationKeyFrame() | File: ../Graphics/Animation.h
-    engine->RegisterObjectBehaviour("AnimationKeyFrame", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(AnimationKeyFrame_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("AnimationKeyFrame", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(AnimationKeyFrame_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // AnimationStateTrack::AnimationStateTrack() | File: ../Graphics/AnimationState.h
-    engine->RegisterObjectBehaviour("AnimationStateTrack", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(AnimationStateTrack_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("AnimationStateTrack", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(AnimationStateTrack_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // AnimationTriggerPoint::AnimationTriggerPoint() | File: ../Graphics/Animation.h
-    engine->RegisterObjectBehaviour("AnimationTriggerPoint", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(AnimationTriggerPoint_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("AnimationTriggerPoint", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(AnimationTriggerPoint_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // AreaAllocator::AreaAllocator() | File: ../Math/AreaAllocator.h
-    engine->RegisterObjectBehaviour("AreaAllocator", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(AreaAllocator_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("AreaAllocator", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(AreaAllocator_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // AsyncProgress::AsyncProgress() | Implicitly-declared
-    engine->RegisterObjectBehaviour("AsyncProgress", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(AsyncProgress_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("AsyncProgress", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(AsyncProgress_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // AttributeInfo::AttributeInfo()=default | File: ../Core/Attribute.h
-    engine->RegisterObjectBehaviour("AttributeInfo", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(AttributeInfo_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("AttributeInfo", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(AttributeInfo_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // BackgroundLoadItem::BackgroundLoadItem() | Implicitly-declared
-    engine->RegisterObjectBehaviour("BackgroundLoadItem", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(BackgroundLoadItem_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("BackgroundLoadItem", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(BackgroundLoadItem_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Batch::Batch()=default | File: ../Graphics/Batch.h
-    engine->RegisterObjectBehaviour("Batch", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Batch_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Batch", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Batch_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // BatchGroup::BatchGroup() | File: ../Graphics/Batch.h
-    engine->RegisterObjectBehaviour("BatchGroup", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(BatchGroup_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("BatchGroup", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(BatchGroup_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // BatchGroupKey::BatchGroupKey()=default | File: ../Graphics/Batch.h
-    engine->RegisterObjectBehaviour("BatchGroupKey", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(BatchGroupKey_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("BatchGroupKey", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(BatchGroupKey_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // BatchQueue::BatchQueue() | Implicitly-declared
-    engine->RegisterObjectBehaviour("BatchQueue", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(BatchQueue_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("BatchQueue", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(BatchQueue_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // BiasParameters::BiasParameters()=default | File: ../Graphics/Light.h
-    engine->RegisterObjectBehaviour("BiasParameters", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(BiasParameters_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("BiasParameters", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(BiasParameters_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // BoundingBox::BoundingBox() noexcept | File: ../Math/BoundingBox.h
-    engine->RegisterObjectBehaviour("BoundingBox", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(BoundingBox_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("BoundingBox", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(BoundingBox_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // CascadeParameters::CascadeParameters()=default | File: ../Graphics/Light.h
-    engine->RegisterObjectBehaviour("CascadeParameters", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(CascadeParameters_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("CascadeParameters", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(CascadeParameters_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // CharLocation::CharLocation() | Implicitly-declared
-    engine->RegisterObjectBehaviour("CharLocation", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(CharLocation_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("CharLocation", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(CharLocation_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Color::Color() noexcept | File: ../Math/Color.h
-    engine->RegisterObjectBehaviour("Color", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Color_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Color", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Color_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // ComponentReplicationState::ComponentReplicationState() | Implicitly-declared
-    engine->RegisterObjectBehaviour("ComponentReplicationState", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ComponentReplicationState_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("ComponentReplicationState", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(ComponentReplicationState_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // CompressedLevel::CompressedLevel() | Implicitly-declared
-    engine->RegisterObjectBehaviour("CompressedLevel", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(CompressedLevel_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("CompressedLevel", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(CompressedLevel_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Condition::Condition() | File: ../Core/Condition.h
-    engine->RegisterObjectBehaviour("Condition", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Condition_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Condition", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Condition_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Controls::Controls() | File: ../Input/Controls.h
-    engine->RegisterObjectBehaviour("Controls", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Controls_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Controls", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Controls_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // CursorShapeInfo::CursorShapeInfo() | File: ../UI/Cursor.h
-    engine->RegisterObjectBehaviour("CursorShapeInfo", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(CursorShapeInfo_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("CursorShapeInfo", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(CursorShapeInfo_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // DebugLine::DebugLine()=default | File: ../Graphics/DebugRenderer.h
-    engine->RegisterObjectBehaviour("DebugLine", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(DebugLine_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("DebugLine", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(DebugLine_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // DebugTriangle::DebugTriangle()=default | File: ../Graphics/DebugRenderer.h
-    engine->RegisterObjectBehaviour("DebugTriangle", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(DebugTriangle_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("DebugTriangle", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(DebugTriangle_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Decal::Decal() | File: ../Graphics/DecalSet.h
-    engine->RegisterObjectBehaviour("Decal", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Decal_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Decal", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Decal_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // DecalVertex::DecalVertex()=default | File: ../Graphics/DecalSet.h
-    engine->RegisterObjectBehaviour("DecalVertex", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(DecalVertex_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("DecalVertex", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(DecalVertex_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // DirtyBits::DirtyBits()=default | File: ../Scene/ReplicationState.h
-    engine->RegisterObjectBehaviour("DirtyBits", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(DirtyBits_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("DirtyBits", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(DirtyBits_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // FileSelectorEntry::FileSelectorEntry() | Implicitly-declared
-    engine->RegisterObjectBehaviour("FileSelectorEntry", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(FileSelectorEntry_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("FileSelectorEntry", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(FileSelectorEntry_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // FocusParameters::FocusParameters()=default | File: ../Graphics/Light.h
-    engine->RegisterObjectBehaviour("FocusParameters", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(FocusParameters_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("FocusParameters", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(FocusParameters_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // FontGlyph::FontGlyph() | Implicitly-declared
-    engine->RegisterObjectBehaviour("FontGlyph", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(FontGlyph_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("FontGlyph", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(FontGlyph_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // FrameInfo::FrameInfo() | Implicitly-declared
-    engine->RegisterObjectBehaviour("FrameInfo", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(FrameInfo_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("FrameInfo", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(FrameInfo_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Frustum::Frustum() noexcept=default | File: ../Math/Frustum.h
-    engine->RegisterObjectBehaviour("Frustum", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Frustum_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Frustum", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Frustum_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // GeometryDesc::GeometryDesc() | Implicitly-declared
-    engine->RegisterObjectBehaviour("GeometryDesc", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(GeometryDesc_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("GeometryDesc", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(GeometryDesc_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // HashBase::HashBase() | File: ../Container/HashBase.h
-    engine->RegisterObjectBehaviour("HashBase", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(HashBase_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("HashBase", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(HashBase_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // HashIteratorBase::HashIteratorBase() | File: ../Container/HashBase.h
-    engine->RegisterObjectBehaviour("HashIteratorBase", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(HashIteratorBase_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("HashIteratorBase", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(HashIteratorBase_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // HashNodeBase::HashNodeBase() | File: ../Container/HashBase.h
-    engine->RegisterObjectBehaviour("HashNodeBase", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(HashNodeBase_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("HashNodeBase", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(HashNodeBase_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // HiresTimer::HiresTimer() | File: ../Core/Timer.h
-    engine->RegisterObjectBehaviour("HiresTimer", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(HiresTimer_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("HiresTimer", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(HiresTimer_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // IndexBufferDesc::IndexBufferDesc() | Implicitly-declared
-    engine->RegisterObjectBehaviour("IndexBufferDesc", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(IndexBufferDesc_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("IndexBufferDesc", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(IndexBufferDesc_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // InstanceData::InstanceData()=default | File: ../Graphics/Batch.h
-    engine->RegisterObjectBehaviour("InstanceData", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(InstanceData_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("InstanceData", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(InstanceData_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // IntRect::IntRect() noexcept | File: ../Math/Rect.h
-    engine->RegisterObjectBehaviour("IntRect", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(IntRect_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("IntRect", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(IntRect_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // IntVector2::IntVector2() noexcept | File: ../Math/Vector2.h
-    engine->RegisterObjectBehaviour("IntVector2", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(IntVector2_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("IntVector2", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(IntVector2_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // IntVector3::IntVector3() noexcept | File: ../Math/Vector3.h
-    engine->RegisterObjectBehaviour("IntVector3", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(IntVector3_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("IntVector3", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(IntVector3_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // JSONValue::JSONValue() | File: ../Resource/JSONValue.h
-    engine->RegisterObjectBehaviour("JSONValue", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(JSONValue_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("JSONValue", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(JSONValue_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // LightBatchQueue::LightBatchQueue() | Implicitly-declared
-    engine->RegisterObjectBehaviour("LightBatchQueue", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(LightBatchQueue_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("LightBatchQueue", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(LightBatchQueue_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // LightQueryResult::LightQueryResult() | Implicitly-declared
-    engine->RegisterObjectBehaviour("LightQueryResult", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(LightQueryResult_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("LightQueryResult", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(LightQueryResult_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // LinkedListNode::LinkedListNode() | File: ../Container/LinkedList.h
-    engine->RegisterObjectBehaviour("LinkedListNode", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(LinkedListNode_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("LinkedListNode", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(LinkedListNode_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // ListBase::ListBase() | File: ../Container/ListBase.h
-    engine->RegisterObjectBehaviour("ListBase", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ListBase_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("ListBase", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(ListBase_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // ListIteratorBase::ListIteratorBase() | File: ../Container/ListBase.h
-    engine->RegisterObjectBehaviour("ListIteratorBase", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ListIteratorBase_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("ListIteratorBase", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(ListIteratorBase_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // ListNodeBase::ListNodeBase() | File: ../Container/ListBase.h
-    engine->RegisterObjectBehaviour("ListNodeBase", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ListNodeBase_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("ListNodeBase", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(ListNodeBase_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // MaterialShaderParameter::MaterialShaderParameter() | Implicitly-declared
-    engine->RegisterObjectBehaviour("MaterialShaderParameter", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(MaterialShaderParameter_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("MaterialShaderParameter", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(MaterialShaderParameter_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Matrix2::Matrix2() noexcept | File: ../Math/Matrix2.h
-    engine->RegisterObjectBehaviour("Matrix2", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Matrix2_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Matrix2", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Matrix2_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Matrix3::Matrix3() noexcept | File: ../Math/Matrix3.h
-    engine->RegisterObjectBehaviour("Matrix3", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Matrix3_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Matrix3", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Matrix3_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Matrix3x4::Matrix3x4() noexcept | File: ../Math/Matrix3x4.h
-    engine->RegisterObjectBehaviour("Matrix3x4", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Matrix3x4_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Matrix3x4", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Matrix3x4_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Matrix4::Matrix4() noexcept | File: ../Math/Matrix4.h
-    engine->RegisterObjectBehaviour("Matrix4", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Matrix4_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Matrix4", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Matrix4_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // ModelMorph::ModelMorph() | Implicitly-declared
-    engine->RegisterObjectBehaviour("ModelMorph", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ModelMorph_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("ModelMorph", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(ModelMorph_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Mutex::Mutex() | File: ../Core/Mutex.h
-    engine->RegisterObjectBehaviour("Mutex", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Mutex_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Mutex", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Mutex_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // NetworkState::NetworkState() | Implicitly-declared
-    engine->RegisterObjectBehaviour("NetworkState", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(NetworkState_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("NetworkState", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(NetworkState_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // NodeImpl::NodeImpl() | Implicitly-declared
-    engine->RegisterObjectBehaviour("NodeImpl", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(NodeImpl_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("NodeImpl", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(NodeImpl_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // NodeReplicationState::NodeReplicationState() | Implicitly-declared
-    engine->RegisterObjectBehaviour("NodeReplicationState", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(NodeReplicationState_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("NodeReplicationState", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(NodeReplicationState_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // OcclusionBatch::OcclusionBatch() | Implicitly-declared
-    engine->RegisterObjectBehaviour("OcclusionBatch", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(OcclusionBatch_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("OcclusionBatch", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(OcclusionBatch_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // OcclusionBufferData::OcclusionBufferData() | Implicitly-declared
-    engine->RegisterObjectBehaviour("OcclusionBufferData", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(OcclusionBufferData_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("OcclusionBufferData", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(OcclusionBufferData_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // OctreeQueryResult::OctreeQueryResult() | File: ../Graphics/OctreeQuery.h
-    engine->RegisterObjectBehaviour("OctreeQueryResult", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(OctreeQueryResult_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("OctreeQueryResult", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(OctreeQueryResult_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Particle::Particle() | Implicitly-declared
-    engine->RegisterObjectBehaviour("Particle", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Particle_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Particle", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Particle_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // PerThreadSceneResult::PerThreadSceneResult() | Implicitly-declared
-    engine->RegisterObjectBehaviour("PerThreadSceneResult", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(PerThreadSceneResult_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("PerThreadSceneResult", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(PerThreadSceneResult_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Plane::Plane() noexcept | File: ../Math/Plane.h
-    engine->RegisterObjectBehaviour("Plane", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Plane_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Plane", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Plane_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Polyhedron::Polyhedron() noexcept=default | File: ../Math/Polyhedron.h
-    engine->RegisterObjectBehaviour("Polyhedron", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Polyhedron_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Polyhedron", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Polyhedron_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Quaternion::Quaternion() noexcept | File: ../Math/Quaternion.h
-    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Quaternion_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Quaternion_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Ray::Ray() noexcept=default | File: ../Math/Ray.h
-    engine->RegisterObjectBehaviour("Ray", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Ray_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Ray", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Ray_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // RayQueryResult::RayQueryResult() | File: ../Graphics/OctreeQuery.h
-    engine->RegisterObjectBehaviour("RayQueryResult", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(RayQueryResult_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("RayQueryResult", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(RayQueryResult_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Rect::Rect() noexcept | File: ../Math/Rect.h
-    engine->RegisterObjectBehaviour("Rect", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Rect_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Rect", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Rect_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // RefCount::RefCount() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour("RefCount", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(RefCount_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("RefCount", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(RefCount_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // RenderPathCommand::RenderPathCommand() | Implicitly-declared
-    engine->RegisterObjectBehaviour("RenderPathCommand", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(RenderPathCommand_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("RenderPathCommand", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(RenderPathCommand_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // RenderTargetInfo::RenderTargetInfo() | Implicitly-declared
-    engine->RegisterObjectBehaviour("RenderTargetInfo", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(RenderTargetInfo_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("RenderTargetInfo", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(RenderTargetInfo_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // ReplicationState::ReplicationState() | Implicitly-declared
-    engine->RegisterObjectBehaviour("ReplicationState", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ReplicationState_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("ReplicationState", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(ReplicationState_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // ResourceGroup::ResourceGroup() | File: ../Resource/ResourceCache.h
-    engine->RegisterObjectBehaviour("ResourceGroup", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ResourceGroup_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("ResourceGroup", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(ResourceGroup_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // ResourceRef::ResourceRef()=default | File: ../Core/Variant.h
-    engine->RegisterObjectBehaviour("ResourceRef", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ResourceRef_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("ResourceRef", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(ResourceRef_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // ResourceRefList::ResourceRefList()=default | File: ../Core/Variant.h
-    engine->RegisterObjectBehaviour("ResourceRefList", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ResourceRefList_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("ResourceRefList", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(ResourceRefList_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // ScenePassInfo::ScenePassInfo() | Implicitly-declared
-    engine->RegisterObjectBehaviour("ScenePassInfo", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ScenePassInfo_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("ScenePassInfo", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(ScenePassInfo_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // SceneReplicationState::SceneReplicationState() | Implicitly-declared
-    engine->RegisterObjectBehaviour("SceneReplicationState", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(SceneReplicationState_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("SceneReplicationState", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(SceneReplicationState_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // SceneResolver::SceneResolver() | File: ../Scene/SceneResolver.h
-    engine->RegisterObjectBehaviour("SceneResolver", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(SceneResolver_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("SceneResolver", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(SceneResolver_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // ScratchBuffer::ScratchBuffer() | File: ../Graphics/Graphics.h
-    engine->RegisterObjectBehaviour("ScratchBuffer", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ScratchBuffer_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("ScratchBuffer", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(ScratchBuffer_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // ScreenModeParams::ScreenModeParams() | Implicitly-declared
-    engine->RegisterObjectBehaviour("ScreenModeParams", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ScreenModeParams_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("ScreenModeParams", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(ScreenModeParams_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // ShaderParameter::ShaderParameter()=default | File: ../Graphics/ShaderVariation.h
-    engine->RegisterObjectBehaviour("ShaderParameter", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ShaderParameter_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("ShaderParameter", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(ShaderParameter_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // ShadowBatchQueue::ShadowBatchQueue() | Implicitly-declared
-    engine->RegisterObjectBehaviour("ShadowBatchQueue", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ShadowBatchQueue_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("ShadowBatchQueue", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(ShadowBatchQueue_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // SourceBatch::SourceBatch() | File: ../Graphics/Drawable.h
-    engine->RegisterObjectBehaviour("SourceBatch", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(SourceBatch_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("SourceBatch", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(SourceBatch_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Sphere::Sphere() noexcept | File: ../Math/Sphere.h
-    engine->RegisterObjectBehaviour("Sphere", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Sphere_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Sphere", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Sphere_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Spline::Spline() | File: ../Core/Spline.h
-    engine->RegisterObjectBehaviour("Spline", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Spline_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Spline", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Spline_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // StaticModelGeometryData::StaticModelGeometryData() | Implicitly-declared
-    engine->RegisterObjectBehaviour("StaticModelGeometryData", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(StaticModelGeometryData_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("StaticModelGeometryData", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(StaticModelGeometryData_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // StoredLogMessage::StoredLogMessage()=default | File: ../IO/Log.h
-    engine->RegisterObjectBehaviour("StoredLogMessage", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(StoredLogMessage_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("StoredLogMessage", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(StoredLogMessage_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // String::String() noexcept | File: ../Container/Str.h
-    engine->RegisterObjectBehaviour("String", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(String_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("String", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(String_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // StringHash::StringHash() noexcept | File: ../Math/StringHash.h
-    engine->RegisterObjectBehaviour("StringHash", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(StringHash_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("StringHash", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(StringHash_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // TechniqueEntry::TechniqueEntry() noexcept | File: ../Graphics/Material.h
-    engine->RegisterObjectBehaviour("TechniqueEntry", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(TechniqueEntry_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("TechniqueEntry", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(TechniqueEntry_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Timer::Timer() | File: ../Core/Timer.h
-    engine->RegisterObjectBehaviour("Timer", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Timer_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Timer", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Timer_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // TrailPoint::TrailPoint()=default | File: ../Graphics/RibbonTrail.h
-    engine->RegisterObjectBehaviour("TrailPoint", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(TrailPoint_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("TrailPoint", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(TrailPoint_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // UIBatch::UIBatch() | File: ../UI/UIBatch.h
-    engine->RegisterObjectBehaviour("UIBatch", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(UIBatch_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("UIBatch", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(UIBatch_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // VAnimEventFrame::VAnimEventFrame() | Implicitly-declared
-    engine->RegisterObjectBehaviour("VAnimEventFrame", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(VAnimEventFrame_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("VAnimEventFrame", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(VAnimEventFrame_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // VAnimKeyFrame::VAnimKeyFrame() | Implicitly-declared
-    engine->RegisterObjectBehaviour("VAnimKeyFrame", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(VAnimKeyFrame_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("VAnimKeyFrame", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(VAnimKeyFrame_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Variant::Variant()=default | File: ../Core/Variant.h
-    engine->RegisterObjectBehaviour("Variant", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Variant_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Variant", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Variant_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Vector2::Vector2() noexcept | File: ../Math/Vector2.h
-    engine->RegisterObjectBehaviour("Vector2", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Vector2_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Vector2", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Vector2_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Vector3::Vector3() noexcept | File: ../Math/Vector3.h
-    engine->RegisterObjectBehaviour("Vector3", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Vector3_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Vector3", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Vector3_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Vector4::Vector4() noexcept | File: ../Math/Vector4.h
-    engine->RegisterObjectBehaviour("Vector4", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Vector4_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Vector4", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Vector4_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // VectorBase::VectorBase() noexcept | File: ../Container/VectorBase.h
-    engine->RegisterObjectBehaviour("VectorBase", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(VectorBase_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("VectorBase", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(VectorBase_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // VectorBuffer::VectorBuffer() | File: ../IO/VectorBuffer.h
-    engine->RegisterObjectBehaviour("VectorBuffer", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(VectorBuffer_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("VectorBuffer", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(VectorBuffer_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // VertexBufferDesc::VertexBufferDesc() | Implicitly-declared
-    engine->RegisterObjectBehaviour("VertexBufferDesc", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(VertexBufferDesc_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("VertexBufferDesc", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(VertexBufferDesc_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // VertexBufferMorph::VertexBufferMorph() | Implicitly-declared
-    engine->RegisterObjectBehaviour("VertexBufferMorph", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(VertexBufferMorph_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("VertexBufferMorph", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(VertexBufferMorph_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // VertexElement::VertexElement() noexcept | File: ../Graphics/GraphicsDefs.h
-    engine->RegisterObjectBehaviour("VertexElement", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(VertexElement_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("VertexElement", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(VertexElement_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // WindowModeParams::WindowModeParams() | Implicitly-declared
-    engine->RegisterObjectBehaviour("WindowModeParams", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(WindowModeParams_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("WindowModeParams", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(WindowModeParams_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // XMLElement::XMLElement() | File: ../Resource/XMLElement.h
-    engine->RegisterObjectBehaviour("XMLElement", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(XMLElement_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("XMLElement", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(XMLElement_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // XPathQuery::XPathQuery() | File: ../Resource/XMLElement.h
-    engine->RegisterObjectBehaviour("XPathQuery", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(XPathQuery_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("XPathQuery", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(XPathQuery_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // XPathResultSet::XPathResultSet() | File: ../Resource/XMLElement.h
-    engine->RegisterObjectBehaviour("XPathResultSet", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(XPathResultSet_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("XPathResultSet", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(XPathResultSet_Constructor), AS_CALL_CDECL_OBJFIRST);
 
 #ifdef URHO3D_NAVIGATION
     // NavAreaStub::NavAreaStub() | Implicitly-declared
-    engine->RegisterObjectBehaviour("NavAreaStub", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(NavAreaStub_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("NavAreaStub", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(NavAreaStub_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // NavBuildData::NavBuildData() | File: ../Navigation/NavBuildData.h
-    engine->RegisterObjectBehaviour("NavBuildData", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(NavBuildData_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("NavBuildData", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(NavBuildData_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // NavigationGeometryInfo::NavigationGeometryInfo() | Implicitly-declared
-    engine->RegisterObjectBehaviour("NavigationGeometryInfo", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(NavigationGeometryInfo_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("NavigationGeometryInfo", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(NavigationGeometryInfo_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // NavigationPathPoint::NavigationPathPoint() | Implicitly-declared
-    engine->RegisterObjectBehaviour("NavigationPathPoint", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(NavigationPathPoint_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("NavigationPathPoint", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(NavigationPathPoint_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // SimpleNavBuildData::SimpleNavBuildData() | File: ../Navigation/NavBuildData.h
-    engine->RegisterObjectBehaviour("SimpleNavBuildData", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(SimpleNavBuildData_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("SimpleNavBuildData", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(SimpleNavBuildData_Constructor), AS_CALL_CDECL_OBJFIRST);
 #endif
 
 #ifdef URHO3D_NETWORK
     // PackageDownload::PackageDownload() | File: ../Network/Connection.h
-    engine->RegisterObjectBehaviour("PackageDownload", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(PackageDownload_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("PackageDownload", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(PackageDownload_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // PackageUpload::PackageUpload() | File: ../Network/Connection.h
-    engine->RegisterObjectBehaviour("PackageUpload", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(PackageUpload_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("PackageUpload", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(PackageUpload_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // RemoteEvent::RemoteEvent() | Implicitly-declared
-    engine->RegisterObjectBehaviour("RemoteEvent", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(RemoteEvent_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("RemoteEvent", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(RemoteEvent_Constructor), AS_CALL_CDECL_OBJFIRST);
 #endif
 
 #ifdef URHO3D_PHYSICS
     // DelayedWorldTransform::DelayedWorldTransform() | Implicitly-declared
-    engine->RegisterObjectBehaviour("DelayedWorldTransform", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(DelayedWorldTransform_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("DelayedWorldTransform", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(DelayedWorldTransform_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // ManifoldPair::ManifoldPair() | File: ../Physics/PhysicsWorld.h
-    engine->RegisterObjectBehaviour("ManifoldPair", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ManifoldPair_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("ManifoldPair", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(ManifoldPair_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // PhysicsRaycastResult::PhysicsRaycastResult() | Implicitly-declared
-    engine->RegisterObjectBehaviour("PhysicsRaycastResult", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(PhysicsRaycastResult_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("PhysicsRaycastResult", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(PhysicsRaycastResult_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // PhysicsWorldConfig::PhysicsWorldConfig() | File: ../Physics/PhysicsWorld.h
-    engine->RegisterObjectBehaviour("PhysicsWorldConfig", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(PhysicsWorldConfig_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("PhysicsWorldConfig", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(PhysicsWorldConfig_Constructor), AS_CALL_CDECL_OBJFIRST);
 #endif
 
 #ifdef URHO3D_URHO2D
     // DelayedWorldTransform2D::DelayedWorldTransform2D() | Implicitly-declared
-    engine->RegisterObjectBehaviour("DelayedWorldTransform2D", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(DelayedWorldTransform2D_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("DelayedWorldTransform2D", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(DelayedWorldTransform2D_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Particle2D::Particle2D() | Implicitly-declared
-    engine->RegisterObjectBehaviour("Particle2D", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Particle2D_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Particle2D", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Particle2D_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // PhysicsRaycastResult2D::PhysicsRaycastResult2D() | Implicitly-declared
-    engine->RegisterObjectBehaviour("PhysicsRaycastResult2D", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(PhysicsRaycastResult2D_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("PhysicsRaycastResult2D", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(PhysicsRaycastResult2D_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // SourceBatch2D::SourceBatch2D() | File: ../Urho2D/Drawable2D.h
-    engine->RegisterObjectBehaviour("SourceBatch2D", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(SourceBatch2D_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("SourceBatch2D", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(SourceBatch2D_Constructor), AS_CALL_CDECL_OBJFIRST);
 
     // Vertex2D::Vertex2D() | Implicitly-declared
-    engine->RegisterObjectBehaviour("Vertex2D", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Vertex2D_Constructor), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Vertex2D", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJFIRST(Vertex2D_Constructor), AS_CALL_CDECL_OBJFIRST);
 #endif
 }
 

Source/Urho3D/AngelScript/GeneratedGlobalFunctions.cpp

@@ -33,13 +33,13 @@ static bool WriteDrawablesToOBJ_PODVectorDrawable_File_bool_bool_bool(CScriptArr
 void ASRegisterGeneratedGlobalFunctions(asIScriptEngine* engine)
 {
     // template<class T> T Abs(T value) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Abs(float)", asFUNCTIONPR(Abs, (float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Abs(float)", AS_FUNCTIONPR(Abs, (float), float), AS_CALL_CDECL);
 
     // template<class T> T Acos(T x) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Acos(float)", asFUNCTIONPR(Acos, (float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Acos(float)", AS_FUNCTIONPR(Acos, (float), float), AS_CALL_CDECL);
 
     // String AddTrailingSlash(const String& pathName) | File: ../IO/FileSystem.h
-    engine->RegisterGlobalFunction("String AddTrailingSlash(const String&in)", asFUNCTIONPR(AddTrailingSlash, (const String&), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String AddTrailingSlash(const String&in)", AS_FUNCTIONPR(AddTrailingSlash, (const String&), String), AS_CALL_CDECL);
 
     // void AllocatorFree(AllocatorBlock* allocator, void* ptr) | File: ../Container/Allocator.h
     // Error: type "AllocatorBlock*" can not automatically bind
@@ -54,53 +54,53 @@ void ASRegisterGeneratedGlobalFunctions(asIScriptEngine* engine)
     // Error: type "AllocatorBlock*" can not automatically bind
 
     // template<class T> T Asin(T x) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Asin(float)", asFUNCTIONPR(Asin, (float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Asin(float)", AS_FUNCTIONPR(Asin, (float), float), AS_CALL_CDECL);
 
     // template<class T> T Atan(T x) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Atan(float)", asFUNCTIONPR(Atan, (float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Atan(float)", AS_FUNCTIONPR(Atan, (float), float), AS_CALL_CDECL);
 
     // template<class T> T Atan2(T y, T x) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Atan2(float, float)", asFUNCTIONPR(Atan2, (float, float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Atan2(float, float)", AS_FUNCTIONPR(Atan2, (float, float), float), AS_CALL_CDECL);
 
     // void BufferToString(String& dest, const void* data, unsigned size) | File: ../Core/StringUtils.h
     // Error: type "const void*" can not automatically bind
 
     // template<class T> T Ceil(T x) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Ceil(float)", asFUNCTIONPR(Ceil, (float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Ceil(float)", AS_FUNCTIONPR(Ceil, (float), float), AS_CALL_CDECL);
 
     // template<class T> int CeilToInt(T x) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("int CeilToInt(float)", asFUNCTIONPR(CeilToInt, (float), int), asCALL_CDECL);
+    engine->RegisterGlobalFunction("int CeilToInt(float)", AS_FUNCTIONPR(CeilToInt, (float), int), AS_CALL_CDECL);
 
     // template<class T> T Clamp(T value, T min, T max) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Clamp(float, float, float)", asFUNCTIONPR(Clamp, (float, float, float), float), asCALL_CDECL);
-    engine->RegisterGlobalFunction("int Clamp(int, int, int)", asFUNCTIONPR(Clamp, (int, int, int), int), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Clamp(float, float, float)", AS_FUNCTIONPR(Clamp, (float, float, float), float), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("int Clamp(int, int, int)", AS_FUNCTIONPR(Clamp, (int, int, int), int), AS_CALL_CDECL);
 
     // unsigned ClosestPowerOfTwo(unsigned value) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("uint ClosestPowerOfTwo(uint)", asFUNCTIONPR(ClosestPowerOfTwo, (unsigned), unsigned), asCALL_CDECL);
+    engine->RegisterGlobalFunction("uint ClosestPowerOfTwo(uint)", AS_FUNCTIONPR(ClosestPowerOfTwo, (unsigned), unsigned), AS_CALL_CDECL);
 
     // void CombineHash(unsigned& result, unsigned hash) | File: ../Container/Hash.h
-    engine->RegisterGlobalFunction("void CombineHash(uint&, uint)", asFUNCTIONPR(CombineHash, (unsigned&, unsigned), void), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void CombineHash(uint&, uint)", AS_FUNCTIONPR(CombineHash, (unsigned&, unsigned), void), AS_CALL_CDECL);
 
     // bool CompareDrawables(Drawable* lhs, Drawable* rhs) | File: ../Graphics/Drawable.h
-    engine->RegisterGlobalFunction("bool CompareDrawables(Drawable@+, Drawable@+)", asFUNCTIONPR(CompareDrawables, (Drawable*, Drawable*), bool), asCALL_CDECL);
+    engine->RegisterGlobalFunction("bool CompareDrawables(Drawable@+, Drawable@+)", AS_FUNCTIONPR(CompareDrawables, (Drawable*, Drawable*), bool), AS_CALL_CDECL);
 
     // bool CompareLights(Light* lhs, Light* rhs) | File: ../Graphics/Light.h
-    engine->RegisterGlobalFunction("bool CompareLights(Light@+, Light@+)", asFUNCTIONPR(CompareLights, (Light*, Light*), bool), asCALL_CDECL);
+    engine->RegisterGlobalFunction("bool CompareLights(Light@+, Light@+)", AS_FUNCTIONPR(CompareLights, (Light*, Light*), bool), AS_CALL_CDECL);
 
     // unsigned CompressData(void* dest, const void* src, unsigned srcSize) | File: ../IO/Compression.h
     // Error: type "void*" can not automatically bind
 
     // bool CompressStream(Serializer& dest, Deserializer& src) | File: ../IO/Compression.h
-    engine->RegisterGlobalFunction("bool CompressStream(Serializer&, Deserializer&)", asFUNCTIONPR(CompressStream, (Serializer&, Deserializer&), bool), asCALL_CDECL);
+    engine->RegisterGlobalFunction("bool CompressStream(Serializer&, Deserializer&)", AS_FUNCTIONPR(CompressStream, (Serializer&, Deserializer&), bool), AS_CALL_CDECL);
 
     // VectorBuffer CompressVectorBuffer(VectorBuffer& src) | File: ../IO/Compression.h
-    engine->RegisterGlobalFunction("VectorBuffer CompressVectorBuffer(VectorBuffer&)", asFUNCTIONPR(CompressVectorBuffer, (VectorBuffer&), VectorBuffer), asCALL_CDECL);
+    engine->RegisterGlobalFunction("VectorBuffer CompressVectorBuffer(VectorBuffer&)", AS_FUNCTIONPR(CompressVectorBuffer, (VectorBuffer&), VectorBuffer), AS_CALL_CDECL);
 
     // template<class T> T Cos(T angle) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Cos(float)", asFUNCTIONPR(Cos, (float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Cos(float)", AS_FUNCTIONPR(Cos, (float), float), AS_CALL_CDECL);
 
     // unsigned CountSetBits(unsigned value) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("uint CountSetBits(uint)", asFUNCTIONPR(CountSetBits, (unsigned), unsigned), asCALL_CDECL);
+    engine->RegisterGlobalFunction("uint CountSetBits(uint)", AS_FUNCTIONPR(CountSetBits, (unsigned), unsigned), AS_CALL_CDECL);
 
     // PODVector<unsigned char> DecodeBase64(String encodedString) | File: ../Core/StringUtils.h
     // Error: type "PODVector<unsigned char>" can not automatically bind
@@ -118,22 +118,22 @@ void ASRegisterGeneratedGlobalFunctions(asIScriptEngine* engine)
     // Error: type "unsigned char*" can not automatically bind
 
     // bool DecompressStream(Serializer& dest, Deserializer& src) | File: ../IO/Compression.h
-    engine->RegisterGlobalFunction("bool DecompressStream(Serializer&, Deserializer&)", asFUNCTIONPR(DecompressStream, (Serializer&, Deserializer&), bool), asCALL_CDECL);
+    engine->RegisterGlobalFunction("bool DecompressStream(Serializer&, Deserializer&)", AS_FUNCTIONPR(DecompressStream, (Serializer&, Deserializer&), bool), AS_CALL_CDECL);
 
     // VectorBuffer DecompressVectorBuffer(VectorBuffer& src) | File: ../IO/Compression.h
-    engine->RegisterGlobalFunction("VectorBuffer DecompressVectorBuffer(VectorBuffer&)", asFUNCTIONPR(DecompressVectorBuffer, (VectorBuffer&), VectorBuffer), asCALL_CDECL);
+    engine->RegisterGlobalFunction("VectorBuffer DecompressVectorBuffer(VectorBuffer&)", AS_FUNCTIONPR(DecompressVectorBuffer, (VectorBuffer&), VectorBuffer), AS_CALL_CDECL);
 
     // template<class T> bool Equals(T lhs, T rhs) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("bool Equals(float, float)", asFUNCTIONPR(Equals, (float, float), bool), asCALL_CDECL);
+    engine->RegisterGlobalFunction("bool Equals(float, float)", AS_FUNCTIONPR(Equals, (float, float), bool), AS_CALL_CDECL);
 
     // void ErrorDialog(const String& title, const String& message) | File: ../Core/ProcessUtils.h
-    engine->RegisterGlobalFunction("void ErrorDialog(const String&in, const String&in)", asFUNCTIONPR(ErrorDialog, (const String&, const String&), void), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void ErrorDialog(const String&in, const String&in)", AS_FUNCTIONPR(ErrorDialog, (const String&, const String&), void), AS_CALL_CDECL);
 
     // void ErrorExit(const String& message=String::EMPTY, int exitCode=EXIT_FAILURE) | File: ../Core/ProcessUtils.h
-    engine->RegisterGlobalFunction("void ErrorExit(const String&in = String::EMPTY, int = EXIT_FAILURE)", asFUNCTIONPR(ErrorExit, (const String&, int), void), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void ErrorExit(const String&in = String::EMPTY, int = EXIT_FAILURE)", AS_FUNCTIONPR(ErrorExit, (const String&, int), void), AS_CALL_CDECL);
 
     // unsigned EstimateCompressBound(unsigned srcSize) | File: ../IO/Compression.h
-    engine->RegisterGlobalFunction("uint EstimateCompressBound(uint)", asFUNCTIONPR(EstimateCompressBound, (unsigned), unsigned), asCALL_CDECL);
+    engine->RegisterGlobalFunction("uint EstimateCompressBound(uint)", AS_FUNCTIONPR(EstimateCompressBound, (unsigned), unsigned), AS_CALL_CDECL);
 
     // void FlipBlockHorizontal(unsigned char* dest, const unsigned char* src, CompressedFormat format) | File: ../Resource/Decompress.h
     // Error: type "unsigned char*" can not automatically bind
@@ -142,91 +142,91 @@ void ASRegisterGeneratedGlobalFunctions(asIScriptEngine* engine)
     // Error: type "unsigned char*" can not automatically bind
 
     // unsigned short FloatToHalf(float value) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("uint16 FloatToHalf(float)", asFUNCTIONPR(FloatToHalf, (float), unsigned short), asCALL_CDECL);
+    engine->RegisterGlobalFunction("uint16 FloatToHalf(float)", AS_FUNCTIONPR(FloatToHalf, (float), unsigned short), AS_CALL_CDECL);
 
     // unsigned FloatToRawIntBits(float value) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("uint FloatToRawIntBits(float)", asFUNCTIONPR(FloatToRawIntBits, (float), unsigned), asCALL_CDECL);
+    engine->RegisterGlobalFunction("uint FloatToRawIntBits(float)", AS_FUNCTIONPR(FloatToRawIntBits, (float), unsigned), AS_CALL_CDECL);
 
     // template<class T> T Floor(T x) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Floor(float)", asFUNCTIONPR(Floor, (float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Floor(float)", AS_FUNCTIONPR(Floor, (float), float), AS_CALL_CDECL);
 
     // template<class T> int FloorToInt(T x) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("int FloorToInt(float)", asFUNCTIONPR(FloorToInt, (float), int), asCALL_CDECL);
+    engine->RegisterGlobalFunction("int FloorToInt(float)", AS_FUNCTIONPR(FloorToInt, (float), int), AS_CALL_CDECL);
 
     // template<class T> T Fract(T value) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Fract(float)", asFUNCTIONPR(Fract, (float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Fract(float)", AS_FUNCTIONPR(Fract, (float), float), AS_CALL_CDECL);
 
     // void GenerateTangents(void* vertexData, unsigned vertexSize, const void* indexData, unsigned indexSize, unsigned indexStart, unsigned indexCount, unsigned normalOffset, unsigned texCoordOffset, unsigned tangentOffset) | File: ../Graphics/Tangent.h
     // Error: type "void*" can not automatically bind
 
     // const Vector<String>& GetArguments() | File: ../Core/ProcessUtils.h
-    engine->RegisterGlobalFunction("Array<String>@ GetArguments()", asFUNCTION(GetArguments_void), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Array<String>@ GetArguments()", AS_FUNCTION(GetArguments_void), AS_CALL_CDECL);
 
     // const char* GetCompilerDefines() | File: ../LibraryInfo.h
     // Error: type "const char*" can not automatically bind
 
     // String GetConsoleInput() | File: ../Core/ProcessUtils.h
-    engine->RegisterGlobalFunction("String GetConsoleInput()", asFUNCTIONPR(GetConsoleInput, (), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String GetConsoleInput()", AS_FUNCTIONPR(GetConsoleInput, (), String), AS_CALL_CDECL);
 
     // StringHashRegister& GetEventNameRegister() | File: ../Core/Object.h
-    engine->RegisterGlobalFunction("StringHashRegister& GetEventNameRegister()", asFUNCTIONPR(GetEventNameRegister, (), StringHashRegister&), asCALL_CDECL);
+    engine->RegisterGlobalFunction("StringHashRegister& GetEventNameRegister()", AS_FUNCTIONPR(GetEventNameRegister, (), StringHashRegister&), AS_CALL_CDECL);
 
     // String GetExtension(const String& fullPath, bool lowercaseExtension=true) | File: ../IO/FileSystem.h
-    engine->RegisterGlobalFunction("String GetExtension(const String&in, bool = true)", asFUNCTIONPR(GetExtension, (const String&, bool), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String GetExtension(const String&in, bool = true)", AS_FUNCTIONPR(GetExtension, (const String&, bool), String), AS_CALL_CDECL);
 
     // String GetFileName(const String& fullPath) | File: ../IO/FileSystem.h
-    engine->RegisterGlobalFunction("String GetFileName(const String&in)", asFUNCTIONPR(GetFileName, (const String&), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String GetFileName(const String&in)", AS_FUNCTIONPR(GetFileName, (const String&), String), AS_CALL_CDECL);
 
     // String GetFileNameAndExtension(const String& fileName, bool lowercaseExtension=false) | File: ../IO/FileSystem.h
-    engine->RegisterGlobalFunction("String GetFileNameAndExtension(const String&in, bool = false)", asFUNCTIONPR(GetFileNameAndExtension, (const String&, bool), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String GetFileNameAndExtension(const String&in, bool = false)", AS_FUNCTIONPR(GetFileNameAndExtension, (const String&, bool), String), AS_CALL_CDECL);
 
     // String GetFileSizeString(unsigned long long memorySize) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("String GetFileSizeString(uint64)", asFUNCTIONPR(GetFileSizeString, (unsigned long long), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String GetFileSizeString(uint64)", AS_FUNCTIONPR(GetFileSizeString, (unsigned long long), String), AS_CALL_CDECL);
 
     // String GetHostName() | File: ../Core/ProcessUtils.h
-    engine->RegisterGlobalFunction("String GetHostName()", asFUNCTIONPR(GetHostName, (), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String GetHostName()", AS_FUNCTIONPR(GetHostName, (), String), AS_CALL_CDECL);
 
     // String GetInternalPath(const String& pathName) | File: ../IO/FileSystem.h
-    engine->RegisterGlobalFunction("String GetInternalPath(const String&in)", asFUNCTIONPR(GetInternalPath, (const String&), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String GetInternalPath(const String&in)", AS_FUNCTIONPR(GetInternalPath, (const String&), String), AS_CALL_CDECL);
 
     // String GetLoginName() | File: ../Core/ProcessUtils.h
-    engine->RegisterGlobalFunction("String GetLoginName()", asFUNCTIONPR(GetLoginName, (), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String GetLoginName()", AS_FUNCTIONPR(GetLoginName, (), String), AS_CALL_CDECL);
 
     // String GetMiniDumpDir() | File: ../Core/ProcessUtils.h
-    engine->RegisterGlobalFunction("String GetMiniDumpDir()", asFUNCTIONPR(GetMiniDumpDir, (), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String GetMiniDumpDir()", AS_FUNCTIONPR(GetMiniDumpDir, (), String), AS_CALL_CDECL);
 
     // String GetNativePath(const String& pathName) | File: ../IO/FileSystem.h
-    engine->RegisterGlobalFunction("String GetNativePath(const String&in)", asFUNCTIONPR(GetNativePath, (const String&), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String GetNativePath(const String&in)", AS_FUNCTIONPR(GetNativePath, (const String&), String), AS_CALL_CDECL);
 
     // unsigned GetNumLogicalCPUs() | File: ../Core/ProcessUtils.h
-    engine->RegisterGlobalFunction("uint GetNumLogicalCPUs()", asFUNCTIONPR(GetNumLogicalCPUs, (), unsigned), asCALL_CDECL);
+    engine->RegisterGlobalFunction("uint GetNumLogicalCPUs()", AS_FUNCTIONPR(GetNumLogicalCPUs, (), unsigned), AS_CALL_CDECL);
 
     // unsigned GetNumPhysicalCPUs() | File: ../Core/ProcessUtils.h
-    engine->RegisterGlobalFunction("uint GetNumPhysicalCPUs()", asFUNCTIONPR(GetNumPhysicalCPUs, (), unsigned), asCALL_CDECL);
+    engine->RegisterGlobalFunction("uint GetNumPhysicalCPUs()", AS_FUNCTIONPR(GetNumPhysicalCPUs, (), unsigned), AS_CALL_CDECL);
 
     // String GetOSVersion() | File: ../Core/ProcessUtils.h
-    engine->RegisterGlobalFunction("String GetOSVersion()", asFUNCTIONPR(GetOSVersion, (), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String GetOSVersion()", AS_FUNCTIONPR(GetOSVersion, (), String), AS_CALL_CDECL);
 
     // String GetParentPath(const String& path) | File: ../IO/FileSystem.h
-    engine->RegisterGlobalFunction("String GetParentPath(const String&in)", asFUNCTIONPR(GetParentPath, (const String&), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String GetParentPath(const String&in)", AS_FUNCTIONPR(GetParentPath, (const String&), String), AS_CALL_CDECL);
 
     // String GetPath(const String& fullPath) | File: ../IO/FileSystem.h
-    engine->RegisterGlobalFunction("String GetPath(const String&in)", asFUNCTIONPR(GetPath, (const String&), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String GetPath(const String&in)", AS_FUNCTIONPR(GetPath, (const String&), String), AS_CALL_CDECL);
 
     // String GetPlatform() | File: ../Core/ProcessUtils.h
-    engine->RegisterGlobalFunction("String GetPlatform()", asFUNCTIONPR(GetPlatform, (), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String GetPlatform()", AS_FUNCTIONPR(GetPlatform, (), String), AS_CALL_CDECL);
 
     // unsigned GetRandomSeed() | File: ../Math/Random.h
-    engine->RegisterGlobalFunction("uint GetRandomSeed()", asFUNCTIONPR(GetRandomSeed, (), unsigned), asCALL_CDECL);
+    engine->RegisterGlobalFunction("uint GetRandomSeed()", AS_FUNCTIONPR(GetRandomSeed, (), unsigned), AS_CALL_CDECL);
 
     // const String& GetResourceName(Resource* resource) | File: ../Resource/Resource.h
-    engine->RegisterGlobalFunction("const String& GetResourceName(Resource@+)", asFUNCTIONPR(GetResourceName, (Resource*), const String&), asCALL_CDECL);
+    engine->RegisterGlobalFunction("const String& GetResourceName(Resource@+)", AS_FUNCTIONPR(GetResourceName, (Resource*), const String&), AS_CALL_CDECL);
 
     // ResourceRef GetResourceRef(Resource* resource, StringHash defaultType) | File: ../Resource/Resource.h
-    engine->RegisterGlobalFunction("ResourceRef GetResourceRef(Resource@+, StringHash)", asFUNCTIONPR(GetResourceRef, (Resource*, StringHash), ResourceRef), asCALL_CDECL);
+    engine->RegisterGlobalFunction("ResourceRef GetResourceRef(Resource@+, StringHash)", AS_FUNCTIONPR(GetResourceRef, (Resource*, StringHash), ResourceRef), AS_CALL_CDECL);
 
     // StringHash GetResourceType(Resource* resource, StringHash defaultType) | File: ../Resource/Resource.h
-    engine->RegisterGlobalFunction("StringHash GetResourceType(Resource@+, StringHash)", asFUNCTIONPR(GetResourceType, (Resource*, StringHash), StringHash), asCALL_CDECL);
+    engine->RegisterGlobalFunction("StringHash GetResourceType(Resource@+, StringHash)", AS_FUNCTIONPR(GetResourceType, (Resource*, StringHash), StringHash), AS_CALL_CDECL);
 
     // const char* GetRevision() | File: ../LibraryInfo.h
     // Error: type "const char*" can not automatically bind
@@ -241,61 +241,61 @@ void ASRegisterGeneratedGlobalFunctions(asIScriptEngine* engine)
     // Error: type "const char*" can not automatically bind
 
     // unsigned long long GetTotalMemory() | File: ../Core/ProcessUtils.h
-    engine->RegisterGlobalFunction("uint64 GetTotalMemory()", asFUNCTIONPR(GetTotalMemory, (), unsigned long long), asCALL_CDECL);
+    engine->RegisterGlobalFunction("uint64 GetTotalMemory()", AS_FUNCTIONPR(GetTotalMemory, (), unsigned long long), AS_CALL_CDECL);
 
     // WString GetWideNativePath(const String& pathName) | File: ../IO/FileSystem.h
     // Error: type "WString" can not automatically bind bacause have @nobind mark
 
     // float HalfToFloat(unsigned short value) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float HalfToFloat(uint16)", asFUNCTIONPR(HalfToFloat, (unsigned short), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float HalfToFloat(uint16)", AS_FUNCTIONPR(HalfToFloat, (unsigned short), float), AS_CALL_CDECL);
 
     // void InitFPU() | File: ../Core/ProcessUtils.h
-    engine->RegisterGlobalFunction("void InitFPU()", asFUNCTIONPR(InitFPU, (), void), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void InitFPU()", AS_FUNCTIONPR(InitFPU, (), void), AS_CALL_CDECL);
 
     // template<class T> T InverseLerp(T lhs, T rhs, T x) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float InverseLerp(float, float, float)", asFUNCTIONPR(InverseLerp, (float, float, float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float InverseLerp(float, float, float)", AS_FUNCTIONPR(InverseLerp, (float, float, float), float), AS_CALL_CDECL);
 
     // bool IsAbsolutePath(const String& pathName) | File: ../IO/FileSystem.h
-    engine->RegisterGlobalFunction("bool IsAbsolutePath(const String&in)", asFUNCTIONPR(IsAbsolutePath, (const String&), bool), asCALL_CDECL);
+    engine->RegisterGlobalFunction("bool IsAbsolutePath(const String&in)", AS_FUNCTIONPR(IsAbsolutePath, (const String&), bool), AS_CALL_CDECL);
 
     // bool IsAlpha(unsigned ch) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("bool IsAlpha(uint)", asFUNCTIONPR(IsAlpha, (unsigned), bool), asCALL_CDECL);
+    engine->RegisterGlobalFunction("bool IsAlpha(uint)", AS_FUNCTIONPR(IsAlpha, (unsigned), bool), AS_CALL_CDECL);
 
     // bool IsDigit(unsigned ch) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("bool IsDigit(uint)", asFUNCTIONPR(IsDigit, (unsigned), bool), asCALL_CDECL);
+    engine->RegisterGlobalFunction("bool IsDigit(uint)", AS_FUNCTIONPR(IsDigit, (unsigned), bool), AS_CALL_CDECL);
 
     // template<class T> bool IsNaN(T value) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("bool IsNaN(double)", asFUNCTIONPR(IsNaN, (double), bool), asCALL_CDECL);
-    engine->RegisterGlobalFunction("bool IsNaN(float)", asFUNCTIONPR(IsNaN, (float), bool), asCALL_CDECL);
+    engine->RegisterGlobalFunction("bool IsNaN(double)", AS_FUNCTIONPR(IsNaN, (double), bool), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("bool IsNaN(float)", AS_FUNCTIONPR(IsNaN, (float), bool), AS_CALL_CDECL);
 
     // bool IsPowerOfTwo(unsigned value) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("bool IsPowerOfTwo(uint)", asFUNCTIONPR(IsPowerOfTwo, (unsigned), bool), asCALL_CDECL);
+    engine->RegisterGlobalFunction("bool IsPowerOfTwo(uint)", AS_FUNCTIONPR(IsPowerOfTwo, (unsigned), bool), AS_CALL_CDECL);
 
     // template<class T, class U> T Lerp(T lhs, T rhs, U t) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Lerp(float, float, float)", asFUNCTIONPR(Lerp, (float, float, float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Lerp(float, float, float)", AS_FUNCTIONPR(Lerp, (float, float, float), float), AS_CALL_CDECL);
 
     // template<class T> T Ln(T x) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Ln(float)", asFUNCTIONPR(Ln, (float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Ln(float)", AS_FUNCTIONPR(Ln, (float), float), AS_CALL_CDECL);
 
     // unsigned LogBaseTwo(unsigned value) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("uint LogBaseTwo(uint)", asFUNCTIONPR(LogBaseTwo, (unsigned), unsigned), asCALL_CDECL);
+    engine->RegisterGlobalFunction("uint LogBaseTwo(uint)", AS_FUNCTIONPR(LogBaseTwo, (unsigned), unsigned), AS_CALL_CDECL);
 
     // template<class T, class U> T Max(T lhs, U rhs) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Max(float, float)", asFUNCTIONPR(Max, (float, float), float), asCALL_CDECL);
-    engine->RegisterGlobalFunction("int Max(int, int)", asFUNCTIONPR(Max, (int, int), int), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Max(float, float)", AS_FUNCTIONPR(Max, (float, float), float), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("int Max(int, int)", AS_FUNCTIONPR(Max, (int, int), int), AS_CALL_CDECL);
 
     // template<class T, class U> T Min(T lhs, U rhs) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Min(float, float)", asFUNCTIONPR(Min, (float, float), float), asCALL_CDECL);
-    engine->RegisterGlobalFunction("int Min(int, int)", asFUNCTIONPR(Min, (int, int), int), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Min(float, float)", AS_FUNCTIONPR(Min, (float, float), float), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("int Min(int, int)", AS_FUNCTIONPR(Min, (int, int), int), AS_CALL_CDECL);
 
     // unsigned NextPowerOfTwo(unsigned value) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("uint NextPowerOfTwo(uint)", asFUNCTIONPR(NextPowerOfTwo, (unsigned), unsigned), asCALL_CDECL);
+    engine->RegisterGlobalFunction("uint NextPowerOfTwo(uint)", AS_FUNCTIONPR(NextPowerOfTwo, (unsigned), unsigned), AS_CALL_CDECL);
 
     // void OpenConsoleWindow() | File: ../Core/ProcessUtils.h
-    engine->RegisterGlobalFunction("void OpenConsoleWindow()", asFUNCTIONPR(OpenConsoleWindow, (), void), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void OpenConsoleWindow()", AS_FUNCTIONPR(OpenConsoleWindow, (), void), AS_CALL_CDECL);
 
     // const Vector<String>& ParseArguments(const String& cmdLine, bool skipFirstArgument=true) | File: ../Core/ProcessUtils.h
-    engine->RegisterGlobalFunction("Array<String>@ ParseArguments(const String&in, bool = true)", asFUNCTION(ParseArguments_String_bool), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Array<String>@ ParseArguments(const String&in, bool = true)", AS_FUNCTION(ParseArguments_String_bool), AS_CALL_CDECL);
 
     // const Vector<String>& ParseArguments(const WString& cmdLine) | File: ../Core/ProcessUtils.h
     // Error: type "WString" can not automatically bind bacause have @nobind mark
@@ -310,46 +310,46 @@ void ASRegisterGeneratedGlobalFunctions(asIScriptEngine* engine)
     // Error: type "char**" can not automatically bind
 
     // template<class T> T Pow(T x, T y) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Pow(float, float)", asFUNCTIONPR(Pow, (float, float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Pow(float, float)", AS_FUNCTIONPR(Pow, (float, float), float), AS_CALL_CDECL);
 
     // void PrintLine(const String& str, bool error=false) | File: ../Core/ProcessUtils.h
-    engine->RegisterGlobalFunction("void PrintLine(const String&in, bool = false)", asFUNCTIONPR(PrintLine, (const String&, bool), void), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void PrintLine(const String&in, bool = false)", AS_FUNCTIONPR(PrintLine, (const String&, bool), void), AS_CALL_CDECL);
 
     // void PrintLine(const char* str, bool error=false) | File: ../Core/ProcessUtils.h
     // Error: type "const char*" can not automatically bind
 
     // void PrintUnicode(const String& str, bool error=false) | File: ../Core/ProcessUtils.h
-    engine->RegisterGlobalFunction("void PrintUnicode(const String&in, bool = false)", asFUNCTIONPR(PrintUnicode, (const String&, bool), void), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void PrintUnicode(const String&in, bool = false)", AS_FUNCTIONPR(PrintUnicode, (const String&, bool), void), AS_CALL_CDECL);
 
     // void PrintUnicodeLine(const String& str, bool error=false) | File: ../Core/ProcessUtils.h
-    engine->RegisterGlobalFunction("void PrintUnicodeLine(const String&in, bool = false)", asFUNCTIONPR(PrintUnicodeLine, (const String&, bool), void), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void PrintUnicodeLine(const String&in, bool = false)", AS_FUNCTIONPR(PrintUnicodeLine, (const String&, bool), void), AS_CALL_CDECL);
 
     // int Rand() | File: ../Math/Random.h
-    engine->RegisterGlobalFunction("int Rand()", asFUNCTIONPR(Rand, (), int), asCALL_CDECL);
-    engine->RegisterGlobalFunction("int RandomInt()", asFUNCTIONPR(Rand, (), int), asCALL_CDECL);
+    engine->RegisterGlobalFunction("int Rand()", AS_FUNCTIONPR(Rand, (), int), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("int RandomInt()", AS_FUNCTIONPR(Rand, (), int), AS_CALL_CDECL);
 
     // float RandStandardNormal() | File: ../Math/Random.h
-    engine->RegisterGlobalFunction("float RandStandardNormal()", asFUNCTIONPR(RandStandardNormal, (), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float RandStandardNormal()", AS_FUNCTIONPR(RandStandardNormal, (), float), AS_CALL_CDECL);
 
     // float Random() | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Random()", asFUNCTIONPR(Random, (), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Random()", AS_FUNCTIONPR(Random, (), float), AS_CALL_CDECL);
 
     // float Random(float min, float max) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Random(float, float)", asFUNCTIONPR(Random, (float, float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Random(float, float)", AS_FUNCTIONPR(Random, (float, float), float), AS_CALL_CDECL);
 
     // float Random(float range) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Random(float)", asFUNCTIONPR(Random, (float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Random(float)", AS_FUNCTIONPR(Random, (float), float), AS_CALL_CDECL);
 
     // int Random(int min, int max) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("int Random(int, int)", asFUNCTIONPR(Random, (int, int), int), asCALL_CDECL);
-    engine->RegisterGlobalFunction("int RandomInt(int, int)", asFUNCTIONPR(Random, (int, int), int), asCALL_CDECL);
+    engine->RegisterGlobalFunction("int Random(int, int)", AS_FUNCTIONPR(Random, (int, int), int), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("int RandomInt(int, int)", AS_FUNCTIONPR(Random, (int, int), int), AS_CALL_CDECL);
 
     // int Random(int range) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("int Random(int)", asFUNCTIONPR(Random, (int), int), asCALL_CDECL);
-    engine->RegisterGlobalFunction("int RandomInt(int)", asFUNCTIONPR(Random, (int), int), asCALL_CDECL);
+    engine->RegisterGlobalFunction("int Random(int)", AS_FUNCTIONPR(Random, (int), int), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("int RandomInt(int)", AS_FUNCTIONPR(Random, (int), int), AS_CALL_CDECL);
 
     // float RandomNormal(float meanValue, float variance) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float RandomNormal(float, float)", asFUNCTIONPR(RandomNormal, (float, float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float RandomNormal(float, float)", AS_FUNCTIONPR(RandomNormal, (float, float), float), AS_CALL_CDECL);
 
     // void RegisterAudioLibrary(Context* context) | File: ../Audio/Audio.h
     // Not registered because have @nobind mark
@@ -367,52 +367,52 @@ void ASRegisterGeneratedGlobalFunctions(asIScriptEngine* engine)
     // Not registered because have @nobind mark
 
     // String RemoveTrailingSlash(const String& pathName) | File: ../IO/FileSystem.h
-    engine->RegisterGlobalFunction("String RemoveTrailingSlash(const String&in)", asFUNCTIONPR(RemoveTrailingSlash, (const String&), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String RemoveTrailingSlash(const String&in)", AS_FUNCTIONPR(RemoveTrailingSlash, (const String&), String), AS_CALL_CDECL);
 
     // String ReplaceExtension(const String& fullPath, const String& newExtension) | File: ../IO/FileSystem.h
-    engine->RegisterGlobalFunction("String ReplaceExtension(const String&in, const String&in)", asFUNCTIONPR(ReplaceExtension, (const String&, const String&), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String ReplaceExtension(const String&in, const String&in)", AS_FUNCTIONPR(ReplaceExtension, (const String&, const String&), String), AS_CALL_CDECL);
 
     // template<class T> T Round(T x) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Round(float)", asFUNCTIONPR(Round, (float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Round(float)", AS_FUNCTIONPR(Round, (float), float), AS_CALL_CDECL);
 
     // template<class T> int RoundToInt(T x) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("int RoundToInt(float)", asFUNCTIONPR(RoundToInt, (float), int), asCALL_CDECL);
+    engine->RegisterGlobalFunction("int RoundToInt(float)", AS_FUNCTIONPR(RoundToInt, (float), int), AS_CALL_CDECL);
 
     // constexpr unsigned SDBMHash(unsigned hash, unsigned char c) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("uint SDBMHash(uint, uint8)", asFUNCTIONPR(SDBMHash, (unsigned, unsigned char), unsigned), asCALL_CDECL);
+    engine->RegisterGlobalFunction("uint SDBMHash(uint, uint8)", AS_FUNCTIONPR(SDBMHash, (unsigned, unsigned char), unsigned), AS_CALL_CDECL);
 
     // void SetMiniDumpDir(const String& pathName) | File: ../Core/ProcessUtils.h
-    engine->RegisterGlobalFunction("void SetMiniDumpDir(const String&in)", asFUNCTIONPR(SetMiniDumpDir, (const String&), void), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void SetMiniDumpDir(const String&in)", AS_FUNCTIONPR(SetMiniDumpDir, (const String&), void), AS_CALL_CDECL);
 
     // void SetRandomSeed(unsigned seed) | File: ../Math/Random.h
-    engine->RegisterGlobalFunction("void SetRandomSeed(uint)", asFUNCTIONPR(SetRandomSeed, (unsigned), void), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void SetRandomSeed(uint)", AS_FUNCTIONPR(SetRandomSeed, (unsigned), void), AS_CALL_CDECL);
 
     // template<class T> T Sign(T value) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Sign(float)", asFUNCTIONPR(Sign, (float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Sign(float)", AS_FUNCTIONPR(Sign, (float), float), AS_CALL_CDECL);
 
     // template<class T> T Sin(T angle) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Sin(float)", asFUNCTIONPR(Sin, (float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Sin(float)", AS_FUNCTIONPR(Sin, (float), float), AS_CALL_CDECL);
 
     // void SinCos(float angle, float& sin, float& cos) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("void SinCos(float, float&, float&)", asFUNCTIONPR(SinCos, (float, float&, float&), void), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void SinCos(float, float&, float&)", AS_FUNCTIONPR(SinCos, (float, float&, float&), void), AS_CALL_CDECL);
 
     // template<class T> T SmoothStep(T lhs, T rhs, T t) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float SmoothStep(float, float, float)", asFUNCTIONPR(SmoothStep, (float, float, float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float SmoothStep(float, float, float)", AS_FUNCTIONPR(SmoothStep, (float, float, float), float), AS_CALL_CDECL);
 
     // void SplitPath(const String& fullPath, String& pathName, String& fileName, String& extension, bool lowercaseExtension=true) | File: ../IO/FileSystem.h
-    engine->RegisterGlobalFunction("void SplitPath(const String&in, String&, String&, String&, bool = true)", asFUNCTIONPR(SplitPath, (const String&, String&, String&, String&, bool), void), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void SplitPath(const String&in, String&, String&, String&, bool = true)", AS_FUNCTIONPR(SplitPath, (const String&, String&, String&, String&, bool), void), AS_CALL_CDECL);
 
     // template<class T> T Sqrt(T x) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Sqrt(float)", asFUNCTIONPR(Sqrt, (float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Sqrt(float)", AS_FUNCTIONPR(Sqrt, (float), float), AS_CALL_CDECL);
 
     // float StableRandom(const Vector2& seed) | File: ../Math/Vector2.h
-    engine->RegisterGlobalFunction("float StableRandom(const Vector2&in)", asFUNCTIONPR(StableRandom, (const Vector2&), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float StableRandom(const Vector2&in)", AS_FUNCTIONPR(StableRandom, (const Vector2&), float), AS_CALL_CDECL);
 
     // float StableRandom(const Vector3& seed) | File: ../Math/Vector3.h
-    engine->RegisterGlobalFunction("float StableRandom(const Vector3&in)", asFUNCTIONPR(StableRandom, (const Vector3&), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float StableRandom(const Vector3&in)", AS_FUNCTIONPR(StableRandom, (const Vector3&), float), AS_CALL_CDECL);
 
     // float StableRandom(float seed) | File: ../Math/Vector2.h
-    engine->RegisterGlobalFunction("float StableRandom(float)", asFUNCTIONPR(StableRandom, (float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float StableRandom(float)", AS_FUNCTIONPR(StableRandom, (float), float), AS_CALL_CDECL);
 
     // void StringToBuffer(PODVector<unsigned char>& dest, const String& source) | File: ../Core/StringUtils.h
     // Error: type "PODVector<unsigned char>&" can not automatically bind
@@ -421,91 +421,91 @@ void ASRegisterGeneratedGlobalFunctions(asIScriptEngine* engine)
     // Error: type "PODVector<unsigned char>&" can not automatically bind
 
     // template<class T> T Tan(T angle) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Tan(float)", asFUNCTIONPR(Tan, (float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Tan(float)", AS_FUNCTIONPR(Tan, (float), float), AS_CALL_CDECL);
 
     // bool ToBool(const String& source) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("bool ToBool(const String&in)", asFUNCTIONPR(ToBool, (const String&), bool), asCALL_CDECL);
+    engine->RegisterGlobalFunction("bool ToBool(const String&in)", AS_FUNCTIONPR(ToBool, (const String&), bool), AS_CALL_CDECL);
 
     // bool ToBool(const char* source) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
 
     // Color ToColor(const String& source) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("Color ToColor(const String&in)", asFUNCTIONPR(ToColor, (const String&), Color), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Color ToColor(const String&in)", AS_FUNCTIONPR(ToColor, (const String&), Color), AS_CALL_CDECL);
 
     // Color ToColor(const char* source) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
 
     // double ToDouble(const String& source) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("double ToDouble(const String&in)", asFUNCTIONPR(ToDouble, (const String&), double), asCALL_CDECL);
+    engine->RegisterGlobalFunction("double ToDouble(const String&in)", AS_FUNCTIONPR(ToDouble, (const String&), double), AS_CALL_CDECL);
 
     // double ToDouble(const char* source) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
 
     // float ToFloat(const String& source) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("float ToFloat(const String&in)", asFUNCTIONPR(ToFloat, (const String&), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float ToFloat(const String&in)", AS_FUNCTIONPR(ToFloat, (const String&), float), AS_CALL_CDECL);
 
     // float ToFloat(const char* source) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
 
     // int ToInt(const String& source, int base=10) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("int ToInt(const String&in, int = 10)", asFUNCTIONPR(ToInt, (const String&, int), int), asCALL_CDECL);
+    engine->RegisterGlobalFunction("int ToInt(const String&in, int = 10)", AS_FUNCTIONPR(ToInt, (const String&, int), int), AS_CALL_CDECL);
 
     // int ToInt(const char* source, int base=10) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
 
     // long long ToInt64(const String& source, int base=10) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("int64 ToInt64(const String&in, int = 10)", asFUNCTIONPR(ToInt64, (const String&, int), long long), asCALL_CDECL);
+    engine->RegisterGlobalFunction("int64 ToInt64(const String&in, int = 10)", AS_FUNCTIONPR(ToInt64, (const String&, int), long long), AS_CALL_CDECL);
 
     // long long ToInt64(const char* source, int base=10) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
 
     // IntRect ToIntRect(const String& source) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("IntRect ToIntRect(const String&in)", asFUNCTIONPR(ToIntRect, (const String&), IntRect), asCALL_CDECL);
+    engine->RegisterGlobalFunction("IntRect ToIntRect(const String&in)", AS_FUNCTIONPR(ToIntRect, (const String&), IntRect), AS_CALL_CDECL);
 
     // IntRect ToIntRect(const char* source) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
 
     // IntVector2 ToIntVector2(const String& source) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("IntVector2 ToIntVector2(const String&in)", asFUNCTIONPR(ToIntVector2, (const String&), IntVector2), asCALL_CDECL);
+    engine->RegisterGlobalFunction("IntVector2 ToIntVector2(const String&in)", AS_FUNCTIONPR(ToIntVector2, (const String&), IntVector2), AS_CALL_CDECL);
 
     // IntVector2 ToIntVector2(const char* source) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
 
     // IntVector3 ToIntVector3(const String& source) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("IntVector3 ToIntVector3(const String&in)", asFUNCTIONPR(ToIntVector3, (const String&), IntVector3), asCALL_CDECL);
+    engine->RegisterGlobalFunction("IntVector3 ToIntVector3(const String&in)", AS_FUNCTIONPR(ToIntVector3, (const String&), IntVector3), AS_CALL_CDECL);
 
     // IntVector3 ToIntVector3(const char* source) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
 
     // unsigned ToLower(unsigned ch) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("uint ToLower(uint)", asFUNCTIONPR(ToLower, (unsigned), unsigned), asCALL_CDECL);
+    engine->RegisterGlobalFunction("uint ToLower(uint)", AS_FUNCTIONPR(ToLower, (unsigned), unsigned), AS_CALL_CDECL);
 
     // Matrix3 ToMatrix3(const String& source) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("Matrix3 ToMatrix3(const String&in)", asFUNCTIONPR(ToMatrix3, (const String&), Matrix3), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Matrix3 ToMatrix3(const String&in)", AS_FUNCTIONPR(ToMatrix3, (const String&), Matrix3), AS_CALL_CDECL);
 
     // Matrix3 ToMatrix3(const char* source) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
 
     // Matrix3x4 ToMatrix3x4(const String& source) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("Matrix3x4 ToMatrix3x4(const String&in)", asFUNCTIONPR(ToMatrix3x4, (const String&), Matrix3x4), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Matrix3x4 ToMatrix3x4(const String&in)", AS_FUNCTIONPR(ToMatrix3x4, (const String&), Matrix3x4), AS_CALL_CDECL);
 
     // Matrix3x4 ToMatrix3x4(const char* source) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
 
     // Matrix4 ToMatrix4(const String& source) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("Matrix4 ToMatrix4(const String&in)", asFUNCTIONPR(ToMatrix4, (const String&), Matrix4), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Matrix4 ToMatrix4(const String&in)", AS_FUNCTIONPR(ToMatrix4, (const String&), Matrix4), AS_CALL_CDECL);
 
     // Matrix4 ToMatrix4(const char* source) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
 
     // Quaternion ToQuaternion(const String& source) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("Quaternion ToQuaternion(const String&in)", asFUNCTIONPR(ToQuaternion, (const String&), Quaternion), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Quaternion ToQuaternion(const String&in)", AS_FUNCTIONPR(ToQuaternion, (const String&), Quaternion), AS_CALL_CDECL);
 
     // Quaternion ToQuaternion(const char* source) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
 
     // Rect ToRect(const String& source) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("Rect ToRect(const String&in)", asFUNCTIONPR(ToRect, (const String&), Rect), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Rect ToRect(const String&in)", AS_FUNCTIONPR(ToRect, (const String&), Rect), AS_CALL_CDECL);
 
     // Rect ToRect(const char* source) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
@@ -517,145 +517,145 @@ void ASRegisterGeneratedGlobalFunctions(asIScriptEngine* engine)
     // Error: type "void*" can not automatically bind
 
     // String ToStringHex(unsigned value) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("String ToStringHex(uint)", asFUNCTIONPR(ToStringHex, (unsigned), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String ToStringHex(uint)", AS_FUNCTIONPR(ToStringHex, (unsigned), String), AS_CALL_CDECL);
 
     // unsigned ToUInt(const String& source, int base=10) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("uint ToUInt(const String&in, int = 10)", asFUNCTIONPR(ToUInt, (const String&, int), unsigned), asCALL_CDECL);
+    engine->RegisterGlobalFunction("uint ToUInt(const String&in, int = 10)", AS_FUNCTIONPR(ToUInt, (const String&, int), unsigned), AS_CALL_CDECL);
 
     // unsigned ToUInt(const char* source, int base=10) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
 
     // unsigned long long ToUInt64(const String& source, int base=10) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("uint64 ToUInt64(const String&in, int = 10)", asFUNCTIONPR(ToUInt64, (const String&, int), unsigned long long), asCALL_CDECL);
+    engine->RegisterGlobalFunction("uint64 ToUInt64(const String&in, int = 10)", AS_FUNCTIONPR(ToUInt64, (const String&, int), unsigned long long), AS_CALL_CDECL);
 
     // unsigned long long ToUInt64(const char* source, int base=10) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
 
     // unsigned ToUpper(unsigned ch) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("uint ToUpper(uint)", asFUNCTIONPR(ToUpper, (unsigned), unsigned), asCALL_CDECL);
+    engine->RegisterGlobalFunction("uint ToUpper(uint)", AS_FUNCTIONPR(ToUpper, (unsigned), unsigned), AS_CALL_CDECL);
 
     // Vector2 ToVector2(const String& source) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("Vector2 ToVector2(const String&in)", asFUNCTIONPR(ToVector2, (const String&), Vector2), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector2 ToVector2(const String&in)", AS_FUNCTIONPR(ToVector2, (const String&), Vector2), AS_CALL_CDECL);
 
     // Vector2 ToVector2(const char* source) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
 
     // Vector3 ToVector3(const String& source) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("Vector3 ToVector3(const String&in)", asFUNCTIONPR(ToVector3, (const String&), Vector3), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector3 ToVector3(const String&in)", AS_FUNCTIONPR(ToVector3, (const String&), Vector3), AS_CALL_CDECL);
 
     // Vector3 ToVector3(const char* source) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
 
     // Vector4 ToVector4(const String& source, bool allowMissingCoords=false) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("Vector4 ToVector4(const String&in, bool = false)", asFUNCTIONPR(ToVector4, (const String&, bool), Vector4), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector4 ToVector4(const String&in, bool = false)", AS_FUNCTIONPR(ToVector4, (const String&, bool), Vector4), AS_CALL_CDECL);
 
     // Vector4 ToVector4(const char* source, bool allowMissingCoords=false) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
 
     // Variant ToVectorVariant(const String& source) | File: ../Core/StringUtils.h
-    engine->RegisterGlobalFunction("Variant ToVectorVariant(const String&in)", asFUNCTIONPR(ToVectorVariant, (const String&), Variant), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Variant ToVectorVariant(const String&in)", AS_FUNCTIONPR(ToVectorVariant, (const String&), Variant), AS_CALL_CDECL);
 
     // Variant ToVectorVariant(const char* source) | File: ../Core/StringUtils.h
     // Error: type "const char*" can not automatically bind
 
     // IntVector2 VectorAbs(const IntVector2& vec) | File: ../Math/Vector2.h
-    engine->RegisterGlobalFunction("IntVector2 VectorAbs(const IntVector2&in)", asFUNCTIONPR(VectorAbs, (const IntVector2&), IntVector2), asCALL_CDECL);
+    engine->RegisterGlobalFunction("IntVector2 VectorAbs(const IntVector2&in)", AS_FUNCTIONPR(VectorAbs, (const IntVector2&), IntVector2), AS_CALL_CDECL);
 
     // IntVector3 VectorAbs(const IntVector3& vec) | File: ../Math/Vector3.h
-    engine->RegisterGlobalFunction("IntVector3 VectorAbs(const IntVector3&in)", asFUNCTIONPR(VectorAbs, (const IntVector3&), IntVector3), asCALL_CDECL);
+    engine->RegisterGlobalFunction("IntVector3 VectorAbs(const IntVector3&in)", AS_FUNCTIONPR(VectorAbs, (const IntVector3&), IntVector3), AS_CALL_CDECL);
 
     // Vector2 VectorAbs(const Vector2& vec) | File: ../Math/Vector2.h
-    engine->RegisterGlobalFunction("Vector2 VectorAbs(const Vector2&in)", asFUNCTIONPR(VectorAbs, (const Vector2&), Vector2), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector2 VectorAbs(const Vector2&in)", AS_FUNCTIONPR(VectorAbs, (const Vector2&), Vector2), AS_CALL_CDECL);
 
     // Vector3 VectorAbs(const Vector3& vec) | File: ../Math/Vector3.h
-    engine->RegisterGlobalFunction("Vector3 VectorAbs(const Vector3&in)", asFUNCTIONPR(VectorAbs, (const Vector3&), Vector3), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector3 VectorAbs(const Vector3&in)", AS_FUNCTIONPR(VectorAbs, (const Vector3&), Vector3), AS_CALL_CDECL);
 
     // Vector2 VectorCeil(const Vector2& vec) | File: ../Math/Vector2.h
-    engine->RegisterGlobalFunction("Vector2 VectorCeil(const Vector2&in)", asFUNCTIONPR(VectorCeil, (const Vector2&), Vector2), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector2 VectorCeil(const Vector2&in)", AS_FUNCTIONPR(VectorCeil, (const Vector2&), Vector2), AS_CALL_CDECL);
 
     // Vector3 VectorCeil(const Vector3& vec) | File: ../Math/Vector3.h
-    engine->RegisterGlobalFunction("Vector3 VectorCeil(const Vector3&in)", asFUNCTIONPR(VectorCeil, (const Vector3&), Vector3), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector3 VectorCeil(const Vector3&in)", AS_FUNCTIONPR(VectorCeil, (const Vector3&), Vector3), AS_CALL_CDECL);
 
     // Vector4 VectorCeil(const Vector4& vec) | File: ../Math/Vector4.h
-    engine->RegisterGlobalFunction("Vector4 VectorCeil(const Vector4&in)", asFUNCTIONPR(VectorCeil, (const Vector4&), Vector4), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector4 VectorCeil(const Vector4&in)", AS_FUNCTIONPR(VectorCeil, (const Vector4&), Vector4), AS_CALL_CDECL);
 
     // IntVector2 VectorCeilToInt(const Vector2& vec) | File: ../Math/Vector2.h
-    engine->RegisterGlobalFunction("IntVector2 VectorCeilToInt(const Vector2&in)", asFUNCTIONPR(VectorCeilToInt, (const Vector2&), IntVector2), asCALL_CDECL);
+    engine->RegisterGlobalFunction("IntVector2 VectorCeilToInt(const Vector2&in)", AS_FUNCTIONPR(VectorCeilToInt, (const Vector2&), IntVector2), AS_CALL_CDECL);
 
     // IntVector3 VectorCeilToInt(const Vector3& vec) | File: ../Math/Vector3.h
-    engine->RegisterGlobalFunction("IntVector3 VectorCeilToInt(const Vector3&in)", asFUNCTIONPR(VectorCeilToInt, (const Vector3&), IntVector3), asCALL_CDECL);
+    engine->RegisterGlobalFunction("IntVector3 VectorCeilToInt(const Vector3&in)", AS_FUNCTIONPR(VectorCeilToInt, (const Vector3&), IntVector3), AS_CALL_CDECL);
 
     // Vector2 VectorFloor(const Vector2& vec) | File: ../Math/Vector2.h
-    engine->RegisterGlobalFunction("Vector2 VectorFloor(const Vector2&in)", asFUNCTIONPR(VectorFloor, (const Vector2&), Vector2), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector2 VectorFloor(const Vector2&in)", AS_FUNCTIONPR(VectorFloor, (const Vector2&), Vector2), AS_CALL_CDECL);
 
     // Vector3 VectorFloor(const Vector3& vec) | File: ../Math/Vector3.h
-    engine->RegisterGlobalFunction("Vector3 VectorFloor(const Vector3&in)", asFUNCTIONPR(VectorFloor, (const Vector3&), Vector3), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector3 VectorFloor(const Vector3&in)", AS_FUNCTIONPR(VectorFloor, (const Vector3&), Vector3), AS_CALL_CDECL);
 
     // Vector4 VectorFloor(const Vector4& vec) | File: ../Math/Vector4.h
-    engine->RegisterGlobalFunction("Vector4 VectorFloor(const Vector4&in)", asFUNCTIONPR(VectorFloor, (const Vector4&), Vector4), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector4 VectorFloor(const Vector4&in)", AS_FUNCTIONPR(VectorFloor, (const Vector4&), Vector4), AS_CALL_CDECL);
 
     // IntVector2 VectorFloorToInt(const Vector2& vec) | File: ../Math/Vector2.h
-    engine->RegisterGlobalFunction("IntVector2 VectorFloorToInt(const Vector2&in)", asFUNCTIONPR(VectorFloorToInt, (const Vector2&), IntVector2), asCALL_CDECL);
+    engine->RegisterGlobalFunction("IntVector2 VectorFloorToInt(const Vector2&in)", AS_FUNCTIONPR(VectorFloorToInt, (const Vector2&), IntVector2), AS_CALL_CDECL);
 
     // IntVector3 VectorFloorToInt(const Vector3& vec) | File: ../Math/Vector3.h
-    engine->RegisterGlobalFunction("IntVector3 VectorFloorToInt(const Vector3&in)", asFUNCTIONPR(VectorFloorToInt, (const Vector3&), IntVector3), asCALL_CDECL);
+    engine->RegisterGlobalFunction("IntVector3 VectorFloorToInt(const Vector3&in)", AS_FUNCTIONPR(VectorFloorToInt, (const Vector3&), IntVector3), AS_CALL_CDECL);
 
     // Vector2 VectorLerp(const Vector2& lhs, const Vector2& rhs, const Vector2& t) | File: ../Math/Vector2.h
-    engine->RegisterGlobalFunction("Vector2 VectorLerp(const Vector2&in, const Vector2&in, const Vector2&in)", asFUNCTIONPR(VectorLerp, (const Vector2&, const Vector2&, const Vector2&), Vector2), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector2 VectorLerp(const Vector2&in, const Vector2&in, const Vector2&in)", AS_FUNCTIONPR(VectorLerp, (const Vector2&, const Vector2&, const Vector2&), Vector2), AS_CALL_CDECL);
 
     // Vector3 VectorLerp(const Vector3& lhs, const Vector3& rhs, const Vector3& t) | File: ../Math/Vector3.h
-    engine->RegisterGlobalFunction("Vector3 VectorLerp(const Vector3&in, const Vector3&in, const Vector3&in)", asFUNCTIONPR(VectorLerp, (const Vector3&, const Vector3&, const Vector3&), Vector3), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector3 VectorLerp(const Vector3&in, const Vector3&in, const Vector3&in)", AS_FUNCTIONPR(VectorLerp, (const Vector3&, const Vector3&, const Vector3&), Vector3), AS_CALL_CDECL);
 
     // Vector4 VectorLerp(const Vector4& lhs, const Vector4& rhs, const Vector4& t) | File: ../Math/Vector4.h
-    engine->RegisterGlobalFunction("Vector4 VectorLerp(const Vector4&in, const Vector4&in, const Vector4&in)", asFUNCTIONPR(VectorLerp, (const Vector4&, const Vector4&, const Vector4&), Vector4), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector4 VectorLerp(const Vector4&in, const Vector4&in, const Vector4&in)", AS_FUNCTIONPR(VectorLerp, (const Vector4&, const Vector4&, const Vector4&), Vector4), AS_CALL_CDECL);
 
     // IntVector2 VectorMax(const IntVector2& lhs, const IntVector2& rhs) | File: ../Math/Vector2.h
-    engine->RegisterGlobalFunction("IntVector2 VectorMax(const IntVector2&in, const IntVector2&in)", asFUNCTIONPR(VectorMax, (const IntVector2&, const IntVector2&), IntVector2), asCALL_CDECL);
+    engine->RegisterGlobalFunction("IntVector2 VectorMax(const IntVector2&in, const IntVector2&in)", AS_FUNCTIONPR(VectorMax, (const IntVector2&, const IntVector2&), IntVector2), AS_CALL_CDECL);
 
     // IntVector3 VectorMax(const IntVector3& lhs, const IntVector3& rhs) | File: ../Math/Vector3.h
-    engine->RegisterGlobalFunction("IntVector3 VectorMax(const IntVector3&in, const IntVector3&in)", asFUNCTIONPR(VectorMax, (const IntVector3&, const IntVector3&), IntVector3), asCALL_CDECL);
+    engine->RegisterGlobalFunction("IntVector3 VectorMax(const IntVector3&in, const IntVector3&in)", AS_FUNCTIONPR(VectorMax, (const IntVector3&, const IntVector3&), IntVector3), AS_CALL_CDECL);
 
     // Vector2 VectorMax(const Vector2& lhs, const Vector2& rhs) | File: ../Math/Vector2.h
-    engine->RegisterGlobalFunction("Vector2 VectorMax(const Vector2&in, const Vector2&in)", asFUNCTIONPR(VectorMax, (const Vector2&, const Vector2&), Vector2), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector2 VectorMax(const Vector2&in, const Vector2&in)", AS_FUNCTIONPR(VectorMax, (const Vector2&, const Vector2&), Vector2), AS_CALL_CDECL);
 
     // Vector3 VectorMax(const Vector3& lhs, const Vector3& rhs) | File: ../Math/Vector3.h
-    engine->RegisterGlobalFunction("Vector3 VectorMax(const Vector3&in, const Vector3&in)", asFUNCTIONPR(VectorMax, (const Vector3&, const Vector3&), Vector3), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector3 VectorMax(const Vector3&in, const Vector3&in)", AS_FUNCTIONPR(VectorMax, (const Vector3&, const Vector3&), Vector3), AS_CALL_CDECL);
 
     // Vector4 VectorMax(const Vector4& lhs, const Vector4& rhs) | File: ../Math/Vector4.h
-    engine->RegisterGlobalFunction("Vector4 VectorMax(const Vector4&in, const Vector4&in)", asFUNCTIONPR(VectorMax, (const Vector4&, const Vector4&), Vector4), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector4 VectorMax(const Vector4&in, const Vector4&in)", AS_FUNCTIONPR(VectorMax, (const Vector4&, const Vector4&), Vector4), AS_CALL_CDECL);
 
     // IntVector2 VectorMin(const IntVector2& lhs, const IntVector2& rhs) | File: ../Math/Vector2.h
-    engine->RegisterGlobalFunction("IntVector2 VectorMin(const IntVector2&in, const IntVector2&in)", asFUNCTIONPR(VectorMin, (const IntVector2&, const IntVector2&), IntVector2), asCALL_CDECL);
+    engine->RegisterGlobalFunction("IntVector2 VectorMin(const IntVector2&in, const IntVector2&in)", AS_FUNCTIONPR(VectorMin, (const IntVector2&, const IntVector2&), IntVector2), AS_CALL_CDECL);
 
     // IntVector3 VectorMin(const IntVector3& lhs, const IntVector3& rhs) | File: ../Math/Vector3.h
-    engine->RegisterGlobalFunction("IntVector3 VectorMin(const IntVector3&in, const IntVector3&in)", asFUNCTIONPR(VectorMin, (const IntVector3&, const IntVector3&), IntVector3), asCALL_CDECL);
+    engine->RegisterGlobalFunction("IntVector3 VectorMin(const IntVector3&in, const IntVector3&in)", AS_FUNCTIONPR(VectorMin, (const IntVector3&, const IntVector3&), IntVector3), AS_CALL_CDECL);
 
     // Vector2 VectorMin(const Vector2& lhs, const Vector2& rhs) | File: ../Math/Vector2.h
-    engine->RegisterGlobalFunction("Vector2 VectorMin(const Vector2&in, const Vector2&in)", asFUNCTIONPR(VectorMin, (const Vector2&, const Vector2&), Vector2), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector2 VectorMin(const Vector2&in, const Vector2&in)", AS_FUNCTIONPR(VectorMin, (const Vector2&, const Vector2&), Vector2), AS_CALL_CDECL);
 
     // Vector3 VectorMin(const Vector3& lhs, const Vector3& rhs) | File: ../Math/Vector3.h
-    engine->RegisterGlobalFunction("Vector3 VectorMin(const Vector3&in, const Vector3&in)", asFUNCTIONPR(VectorMin, (const Vector3&, const Vector3&), Vector3), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector3 VectorMin(const Vector3&in, const Vector3&in)", AS_FUNCTIONPR(VectorMin, (const Vector3&, const Vector3&), Vector3), AS_CALL_CDECL);
 
     // Vector4 VectorMin(const Vector4& lhs, const Vector4& rhs) | File: ../Math/Vector4.h
-    engine->RegisterGlobalFunction("Vector4 VectorMin(const Vector4&in, const Vector4&in)", asFUNCTIONPR(VectorMin, (const Vector4&, const Vector4&), Vector4), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector4 VectorMin(const Vector4&in, const Vector4&in)", AS_FUNCTIONPR(VectorMin, (const Vector4&, const Vector4&), Vector4), AS_CALL_CDECL);
 
     // Vector2 VectorRound(const Vector2& vec) | File: ../Math/Vector2.h
-    engine->RegisterGlobalFunction("Vector2 VectorRound(const Vector2&in)", asFUNCTIONPR(VectorRound, (const Vector2&), Vector2), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector2 VectorRound(const Vector2&in)", AS_FUNCTIONPR(VectorRound, (const Vector2&), Vector2), AS_CALL_CDECL);
 
     // Vector3 VectorRound(const Vector3& vec) | File: ../Math/Vector3.h
-    engine->RegisterGlobalFunction("Vector3 VectorRound(const Vector3&in)", asFUNCTIONPR(VectorRound, (const Vector3&), Vector3), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector3 VectorRound(const Vector3&in)", AS_FUNCTIONPR(VectorRound, (const Vector3&), Vector3), AS_CALL_CDECL);
 
     // Vector4 VectorRound(const Vector4& vec) | File: ../Math/Vector4.h
-    engine->RegisterGlobalFunction("Vector4 VectorRound(const Vector4&in)", asFUNCTIONPR(VectorRound, (const Vector4&), Vector4), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Vector4 VectorRound(const Vector4&in)", AS_FUNCTIONPR(VectorRound, (const Vector4&), Vector4), AS_CALL_CDECL);
 
     // IntVector2 VectorRoundToInt(const Vector2& vec) | File: ../Math/Vector2.h
-    engine->RegisterGlobalFunction("IntVector2 VectorRoundToInt(const Vector2&in)", asFUNCTIONPR(VectorRoundToInt, (const Vector2&), IntVector2), asCALL_CDECL);
+    engine->RegisterGlobalFunction("IntVector2 VectorRoundToInt(const Vector2&in)", AS_FUNCTIONPR(VectorRoundToInt, (const Vector2&), IntVector2), AS_CALL_CDECL);
 
     // IntVector3 VectorRoundToInt(const Vector3& vec) | File: ../Math/Vector3.h
-    engine->RegisterGlobalFunction("IntVector3 VectorRoundToInt(const Vector3&in)", asFUNCTIONPR(VectorRoundToInt, (const Vector3&), IntVector3), asCALL_CDECL);
+    engine->RegisterGlobalFunction("IntVector3 VectorRoundToInt(const Vector3&in)", AS_FUNCTIONPR(VectorRoundToInt, (const Vector3&), IntVector3), AS_CALL_CDECL);
 
     // bool WriteDrawablesToOBJ(const PODVector<Drawable*>& drawables, File* outputFile, bool asZUp, bool asRightHanded, bool writeLightmapUV=false) | File: ../Graphics/Drawable.h
-    engine->RegisterGlobalFunction("bool WriteDrawablesToOBJ(Array<Drawable@>@, File@+, bool, bool, bool = false)", asFUNCTION(WriteDrawablesToOBJ_PODVectorDrawable_File_bool_bool_bool), asCALL_CDECL);
+    engine->RegisterGlobalFunction("bool WriteDrawablesToOBJ(Array<Drawable@>@, File@+, bool, bool, bool = false)", AS_FUNCTION(WriteDrawablesToOBJ_PODVectorDrawable_File_bool_bool_bool), AS_CALL_CDECL);
 
 #ifdef URHO3D_IK
     // void RegisterIKLibrary(Context* context) | File: ../IK/IK.h

Source/Urho3D/AngelScript/Generated_Members_E.cpp

@@ -55,161 +55,161 @@ static EventReceiverGroup* EventReceiverGroup_EventReceiverGroup_void()
 void ASRegisterGenerated_Members_E(asIScriptEngine* engine)
 {
     // void RefCounted::AddRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour("Engine", asBEHAVE_ADDREF, "void f()", asMETHODPR(Engine, AddRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour("Engine", asBEHAVE_ADDREF, "void f()", AS_METHODPR(Engine, AddRef, (), void), AS_CALL_THISCALL);
     // void Engine::ApplyFrameLimit() | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "void ApplyFrameLimit()", asMETHODPR(Engine, ApplyFrameLimit, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void ApplyFrameLimit()", AS_METHODPR(Engine, ApplyFrameLimit, (), void), AS_CALL_THISCALL);
     // template<typename T> T* Object::Cast() | File: ../Core/Object.h
     // Not registered because template
     // template<typename T> const T* Object::Cast() const | File: ../Core/Object.h
     // Not registered because template
     // Console* Engine::CreateConsole() | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "Console@+ CreateConsole()", asMETHODPR(Engine, CreateConsole, (), Console*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "Console@+ CreateConsole()", AS_METHODPR(Engine, CreateConsole, (), Console*), AS_CALL_THISCALL);
     // DebugHud* Engine::CreateDebugHud() | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "DebugHud@+ CreateDebugHud()", asMETHODPR(Engine, CreateDebugHud, (), DebugHud*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "DebugHud@+ CreateDebugHud()", AS_METHODPR(Engine, CreateDebugHud, (), DebugHud*), AS_CALL_THISCALL);
     // void Engine::DumpMemory() | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "void DumpMemory()", asMETHODPR(Engine, DumpMemory, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void DumpMemory()", AS_METHODPR(Engine, DumpMemory, (), void), AS_CALL_THISCALL);
     // void Engine::DumpProfiler() | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "void DumpProfiler()", asMETHODPR(Engine, DumpProfiler, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void DumpProfiler()", AS_METHODPR(Engine, DumpProfiler, (), void), AS_CALL_THISCALL);
     // void Engine::DumpResources(bool dumpFileName=false) | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "void DumpResources(bool = false)", asMETHODPR(Engine, DumpResources, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void DumpResources(bool = false)", AS_METHODPR(Engine, DumpResources, (bool), void), AS_CALL_THISCALL);
     // explicit Engine::Engine(Context* context) | File: ../Engine/Engine.h
-    engine->RegisterObjectBehaviour("Engine", asBEHAVE_FACTORY, "Engine@+ f()", asFUNCTION(Engine_Engine_Context), asCALL_CDECL);
+    engine->RegisterObjectBehaviour("Engine", asBEHAVE_FACTORY, "Engine@+ f()", AS_FUNCTION(Engine_Engine_Context), AS_CALL_CDECL);
     // void Engine::Exit() | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "void Exit()", asMETHODPR(Engine, Exit, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void Exit()", AS_METHODPR(Engine, Exit, (), void), AS_CALL_THISCALL);
     // bool Engine::GetAutoExit() const | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "bool GetAutoExit() const", asMETHODPR(Engine, GetAutoExit, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "bool get_autoExit() const", asMETHODPR(Engine, GetAutoExit, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "bool GetAutoExit() const", AS_METHODPR(Engine, GetAutoExit, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "bool get_autoExit() const", AS_METHODPR(Engine, GetAutoExit, () const, bool), AS_CALL_THISCALL);
     // bool Object::GetBlockEvents() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "bool GetBlockEvents() const", asMETHODPR(Engine, GetBlockEvents, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "bool GetBlockEvents() const", AS_METHODPR(Engine, GetBlockEvents, () const, bool), AS_CALL_THISCALL);
     // const String& Object::GetCategory() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "const String& GetCategory() const", asMETHODPR(Engine, GetCategory, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "const String& get_category() const", asMETHODPR(Engine, GetCategory, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "const String& GetCategory() const", AS_METHODPR(Engine, GetCategory, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "const String& get_category() const", AS_METHODPR(Engine, GetCategory, () const, const String&), AS_CALL_THISCALL);
     // Context* Object::GetContext() const | File: ../Core/Object.h
     // Error: type "Context*" can used only as function parameter
     // VariantMap& Object::GetEventDataMap() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "VariantMap& GetEventDataMap() const", asMETHODPR(Engine, GetEventDataMap, () const, VariantMap&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "VariantMap& GetEventDataMap() const", AS_METHODPR(Engine, GetEventDataMap, () const, VariantMap&), AS_CALL_THISCALL);
     // EventHandler* Object::GetEventHandler() const | File: ../Core/Object.h
     // Error: type "EventHandler*" can not automatically bind
     // Object* Object::GetEventSender() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "Object@+ GetEventSender() const", asMETHODPR(Engine, GetEventSender, () const, Object*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "Object@+ GetEventSender() const", AS_METHODPR(Engine, GetEventSender, () const, Object*), AS_CALL_THISCALL);
     // const Variant& Object::GetGlobalVar(StringHash key) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "const Variant& GetGlobalVar(StringHash) const", asMETHODPR(Engine, GetGlobalVar, (StringHash) const, const Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "const Variant& get_globalVar(StringHash) const", asMETHODPR(Engine, GetGlobalVar, (StringHash) const, const Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "const Variant& GetGlobalVar(StringHash) const", AS_METHODPR(Engine, GetGlobalVar, (StringHash) const, const Variant&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "const Variant& get_globalVar(StringHash) const", AS_METHODPR(Engine, GetGlobalVar, (StringHash) const, const Variant&), AS_CALL_THISCALL);
     // const VariantMap& Object::GetGlobalVars() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "const VariantMap& GetGlobalVars() const", asMETHODPR(Engine, GetGlobalVars, () const, const VariantMap&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "const VariantMap& get_globalVars() const", asMETHODPR(Engine, GetGlobalVars, () const, const VariantMap&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "const VariantMap& GetGlobalVars() const", AS_METHODPR(Engine, GetGlobalVars, () const, const VariantMap&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "const VariantMap& get_globalVars() const", AS_METHODPR(Engine, GetGlobalVars, () const, const VariantMap&), AS_CALL_THISCALL);
     // int Engine::GetMaxFps() const | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "int GetMaxFps() const", asMETHODPR(Engine, GetMaxFps, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "int get_maxFps() const", asMETHODPR(Engine, GetMaxFps, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "int GetMaxFps() const", AS_METHODPR(Engine, GetMaxFps, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "int get_maxFps() const", AS_METHODPR(Engine, GetMaxFps, () const, int), AS_CALL_THISCALL);
     // int Engine::GetMaxInactiveFps() const | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "int GetMaxInactiveFps() const", asMETHODPR(Engine, GetMaxInactiveFps, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "int get_maxInactiveFps() const", asMETHODPR(Engine, GetMaxInactiveFps, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "int GetMaxInactiveFps() const", AS_METHODPR(Engine, GetMaxInactiveFps, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "int get_maxInactiveFps() const", AS_METHODPR(Engine, GetMaxInactiveFps, () const, int), AS_CALL_THISCALL);
     // int Engine::GetMinFps() const | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "int GetMinFps() const", asMETHODPR(Engine, GetMinFps, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "int get_minFps() const", asMETHODPR(Engine, GetMinFps, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "int GetMinFps() const", AS_METHODPR(Engine, GetMinFps, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "int get_minFps() const", AS_METHODPR(Engine, GetMinFps, () const, int), AS_CALL_THISCALL);
     // float Engine::GetNextTimeStep() const | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "float GetNextTimeStep() const", asMETHODPR(Engine, GetNextTimeStep, () const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "float GetNextTimeStep() const", AS_METHODPR(Engine, GetNextTimeStep, () const, float), AS_CALL_THISCALL);
     // static const Variant& Engine::GetParameter(const VariantMap& parameters, const String& parameter, const Variant& defaultValue=Variant::EMPTY) | File: ../Engine/Engine.h
     engine->SetDefaultNamespace("Engine");
-    engine->RegisterGlobalFunction("const Variant& GetParameter(const VariantMap&in, const String&in, const Variant&in = Variant::EMPTY)", asFUNCTIONPR(Engine::GetParameter, (const VariantMap&, const String&, const Variant&), const Variant&), asCALL_CDECL);
+    engine->RegisterGlobalFunction("const Variant& GetParameter(const VariantMap&in, const String&in, const Variant&in = Variant::EMPTY)", AS_FUNCTIONPR(Engine::GetParameter, (const VariantMap&, const String&, const Variant&), const Variant&), AS_CALL_CDECL);
     engine->SetDefaultNamespace("");
     // bool Engine::GetPauseMinimized() const | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "bool GetPauseMinimized() const", asMETHODPR(Engine, GetPauseMinimized, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "bool get_pauseMinimized() const", asMETHODPR(Engine, GetPauseMinimized, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "bool GetPauseMinimized() const", AS_METHODPR(Engine, GetPauseMinimized, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "bool get_pauseMinimized() const", AS_METHODPR(Engine, GetPauseMinimized, () const, bool), AS_CALL_THISCALL);
     // Object* Object::GetSubsystem(StringHash type) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "Object@+ GetSubsystem(StringHash) const", asMETHODPR(Engine, GetSubsystem, (StringHash) const, Object*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "Object@+ GetSubsystem(StringHash) const", AS_METHODPR(Engine, GetSubsystem, (StringHash) const, Object*), AS_CALL_THISCALL);
     // template<class T> T* Object::GetSubsystem() const | File: ../Core/Object.h
     // Not registered because template
     // int Engine::GetTimeStepSmoothing() const | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "int GetTimeStepSmoothing() const", asMETHODPR(Engine, GetTimeStepSmoothing, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "int get_timeStepSmoothing() const", asMETHODPR(Engine, GetTimeStepSmoothing, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "int GetTimeStepSmoothing() const", AS_METHODPR(Engine, GetTimeStepSmoothing, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "int get_timeStepSmoothing() const", AS_METHODPR(Engine, GetTimeStepSmoothing, () const, int), AS_CALL_THISCALL);
     // virtual StringHash Object::GetType() const =0 | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "StringHash GetType() const", asMETHODPR(Engine, GetType, () const, StringHash), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "StringHash get_type() const", asMETHODPR(Engine, GetType, () const, StringHash), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "StringHash GetType() const", AS_METHODPR(Engine, GetType, () const, StringHash), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "StringHash get_type() const", AS_METHODPR(Engine, GetType, () const, StringHash), AS_CALL_THISCALL);
     // virtual const TypeInfo* Object::GetTypeInfo() const =0 | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // static const TypeInfo* Object::GetTypeInfoStatic() | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // virtual const String& Object::GetTypeName() const =0 | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "const String& GetTypeName() const", asMETHODPR(Engine, GetTypeName, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "const String& get_typeName() const", asMETHODPR(Engine, GetTypeName, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "const String& GetTypeName() const", AS_METHODPR(Engine, GetTypeName, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "const String& get_typeName() const", AS_METHODPR(Engine, GetTypeName, () const, const String&), AS_CALL_THISCALL);
     // bool Object::HasEventHandlers() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "bool HasEventHandlers() const", asMETHODPR(Engine, HasEventHandlers, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "bool HasEventHandlers() const", AS_METHODPR(Engine, HasEventHandlers, () const, bool), AS_CALL_THISCALL);
     // static bool Engine::HasParameter(const VariantMap& parameters, const String& parameter) | File: ../Engine/Engine.h
     engine->SetDefaultNamespace("Engine");
-    engine->RegisterGlobalFunction("bool HasParameter(const VariantMap&in, const String&in)", asFUNCTIONPR(Engine::HasParameter, (const VariantMap&, const String&), bool), asCALL_CDECL);
+    engine->RegisterGlobalFunction("bool HasParameter(const VariantMap&in, const String&in)", AS_FUNCTIONPR(Engine::HasParameter, (const VariantMap&, const String&), bool), AS_CALL_CDECL);
     engine->SetDefaultNamespace("");
     // bool Object::HasSubscribedToEvent(StringHash eventType) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "bool HasSubscribedToEvent(StringHash) const", asMETHODPR(Engine, HasSubscribedToEvent, (StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "bool HasSubscribedToEvent(StringHash) const", AS_METHODPR(Engine, HasSubscribedToEvent, (StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::HasSubscribedToEvent(Object* sender, StringHash eventType) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "bool HasSubscribedToEvent(Object@+, StringHash) const", asMETHODPR(Engine, HasSubscribedToEvent, (Object*, StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "bool HasSubscribedToEvent(Object@+, StringHash) const", AS_METHODPR(Engine, HasSubscribedToEvent, (Object*, StringHash) const, bool), AS_CALL_THISCALL);
     // bool Engine::Initialize(const VariantMap& parameters) | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "bool Initialize(const VariantMap&in)", asMETHODPR(Engine, Initialize, (const VariantMap&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "bool Initialize(const VariantMap&in)", AS_METHODPR(Engine, Initialize, (const VariantMap&), bool), AS_CALL_THISCALL);
     // bool Engine::InitializeResourceCache(const VariantMap& parameters, bool removeOld=true) | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "bool InitializeResourceCache(const VariantMap&in, bool = true)", asMETHODPR(Engine, InitializeResourceCache, (const VariantMap&, bool), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "bool InitializeResourceCache(const VariantMap&in, bool = true)", AS_METHODPR(Engine, InitializeResourceCache, (const VariantMap&, bool), bool), AS_CALL_THISCALL);
     // bool Engine::IsExiting() const | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "bool IsExiting() const", asMETHODPR(Engine, IsExiting, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "bool get_exiting() const", asMETHODPR(Engine, IsExiting, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "bool IsExiting() const", AS_METHODPR(Engine, IsExiting, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "bool get_exiting() const", AS_METHODPR(Engine, IsExiting, () const, bool), AS_CALL_THISCALL);
     // bool Engine::IsHeadless() const | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "bool IsHeadless() const", asMETHODPR(Engine, IsHeadless, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "bool get_headless() const", asMETHODPR(Engine, IsHeadless, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "bool IsHeadless() const", AS_METHODPR(Engine, IsHeadless, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "bool get_headless() const", AS_METHODPR(Engine, IsHeadless, () const, bool), AS_CALL_THISCALL);
     // bool Engine::IsInitialized() const | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "bool IsInitialized() const", asMETHODPR(Engine, IsInitialized, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "bool get_initialized() const", asMETHODPR(Engine, IsInitialized, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "bool IsInitialized() const", AS_METHODPR(Engine, IsInitialized, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "bool get_initialized() const", AS_METHODPR(Engine, IsInitialized, () const, bool), AS_CALL_THISCALL);
     // bool Object::IsInstanceOf(StringHash type) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "bool IsInstanceOf(StringHash) const", asMETHODPR(Engine, IsInstanceOf, (StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "bool IsInstanceOf(StringHash) const", AS_METHODPR(Engine, IsInstanceOf, (StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::IsInstanceOf(const TypeInfo* typeInfo) const | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // template<typename T> bool Object::IsInstanceOf() const | File: ../Core/Object.h
     // Not registered because template
     // virtual void Object::OnEvent(Object* sender, StringHash eventType, VariantMap& eventData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "void OnEvent(Object@+, StringHash, VariantMap&)", asMETHODPR(Engine, OnEvent, (Object*, StringHash, VariantMap&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void OnEvent(Object@+, StringHash, VariantMap&)", AS_METHODPR(Engine, OnEvent, (Object*, StringHash, VariantMap&), void), AS_CALL_THISCALL);
     // static VariantMap Engine::ParseParameters(const Vector<String>& arguments) | File: ../Engine/Engine.h
     engine->SetDefaultNamespace("Engine");
-    engine->RegisterGlobalFunction("VariantMap ParseParameters(Array<String>@+)", asFUNCTION(Engine_ParseParameters_VectorString), asCALL_CDECL);
+    engine->RegisterGlobalFunction("VariantMap ParseParameters(Array<String>@+)", AS_FUNCTION(Engine_ParseParameters_VectorString), AS_CALL_CDECL);
     engine->SetDefaultNamespace("");
     // RefCount* RefCounted::RefCountPtr() | File: ../Container/RefCounted.h
     // Error: type "RefCount*" can not automatically bind
     // int RefCounted::Refs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod("Engine", "int Refs() const", asMETHODPR(Engine, Refs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "int get_refs() const", asMETHODPR(Engine, Refs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "int Refs() const", AS_METHODPR(Engine, Refs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "int get_refs() const", AS_METHODPR(Engine, Refs, () const, int), AS_CALL_THISCALL);
     // void RefCounted::ReleaseRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour("Engine", asBEHAVE_RELEASE, "void f()", asMETHODPR(Engine, ReleaseRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour("Engine", asBEHAVE_RELEASE, "void f()", AS_METHODPR(Engine, ReleaseRef, (), void), AS_CALL_THISCALL);
     // void Engine::Render() | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "void Render()", asMETHODPR(Engine, Render, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void Render()", AS_METHODPR(Engine, Render, (), void), AS_CALL_THISCALL);
     // void Engine::RunFrame() | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "void RunFrame()", asMETHODPR(Engine, RunFrame, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void RunFrame()", AS_METHODPR(Engine, RunFrame, (), void), AS_CALL_THISCALL);
     // void Object::SendEvent(StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "void SendEvent(StringHash)", asMETHODPR(Engine, SendEvent, (StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void SendEvent(StringHash)", AS_METHODPR(Engine, SendEvent, (StringHash), void), AS_CALL_THISCALL);
     // void Object::SendEvent(StringHash eventType, VariantMap& eventData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "void SendEvent(StringHash, VariantMap&)", asMETHODPR(Engine, SendEvent, (StringHash, VariantMap&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void SendEvent(StringHash, VariantMap&)", AS_METHODPR(Engine, SendEvent, (StringHash, VariantMap&), void), AS_CALL_THISCALL);
     // template<typename... Args> void Object::SendEvent(StringHash eventType, Args... args) | File: ../Core/Object.h
     // Not registered because template
     // void Engine::SetAutoExit(bool enable) | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "void SetAutoExit(bool)", asMETHODPR(Engine, SetAutoExit, (bool), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "void set_autoExit(bool)", asMETHODPR(Engine, SetAutoExit, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void SetAutoExit(bool)", AS_METHODPR(Engine, SetAutoExit, (bool), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void set_autoExit(bool)", AS_METHODPR(Engine, SetAutoExit, (bool), void), AS_CALL_THISCALL);
     // void Object::SetBlockEvents(bool block) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "void SetBlockEvents(bool)", asMETHODPR(Engine, SetBlockEvents, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void SetBlockEvents(bool)", AS_METHODPR(Engine, SetBlockEvents, (bool), void), AS_CALL_THISCALL);
     // void Object::SetGlobalVar(StringHash key, const Variant& value) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "void SetGlobalVar(StringHash, const Variant&in)", asMETHODPR(Engine, SetGlobalVar, (StringHash, const Variant&), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "void set_globalVar(StringHash, const Variant&in)", asMETHODPR(Engine, SetGlobalVar, (StringHash, const Variant&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void SetGlobalVar(StringHash, const Variant&in)", AS_METHODPR(Engine, SetGlobalVar, (StringHash, const Variant&), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void set_globalVar(StringHash, const Variant&in)", AS_METHODPR(Engine, SetGlobalVar, (StringHash, const Variant&), void), AS_CALL_THISCALL);
     // void Engine::SetMaxFps(int fps) | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "void SetMaxFps(int)", asMETHODPR(Engine, SetMaxFps, (int), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "void set_maxFps(int)", asMETHODPR(Engine, SetMaxFps, (int), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void SetMaxFps(int)", AS_METHODPR(Engine, SetMaxFps, (int), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void set_maxFps(int)", AS_METHODPR(Engine, SetMaxFps, (int), void), AS_CALL_THISCALL);
     // void Engine::SetMaxInactiveFps(int fps) | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "void SetMaxInactiveFps(int)", asMETHODPR(Engine, SetMaxInactiveFps, (int), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "void set_maxInactiveFps(int)", asMETHODPR(Engine, SetMaxInactiveFps, (int), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void SetMaxInactiveFps(int)", AS_METHODPR(Engine, SetMaxInactiveFps, (int), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void set_maxInactiveFps(int)", AS_METHODPR(Engine, SetMaxInactiveFps, (int), void), AS_CALL_THISCALL);
     // void Engine::SetMinFps(int fps) | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "void SetMinFps(int)", asMETHODPR(Engine, SetMinFps, (int), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "void set_minFps(int)", asMETHODPR(Engine, SetMinFps, (int), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void SetMinFps(int)", AS_METHODPR(Engine, SetMinFps, (int), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void set_minFps(int)", AS_METHODPR(Engine, SetMinFps, (int), void), AS_CALL_THISCALL);
     // void Engine::SetNextTimeStep(float seconds) | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "void SetNextTimeStep(float)", asMETHODPR(Engine, SetNextTimeStep, (float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void SetNextTimeStep(float)", AS_METHODPR(Engine, SetNextTimeStep, (float), void), AS_CALL_THISCALL);
     // void Engine::SetPauseMinimized(bool enable) | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "void SetPauseMinimized(bool)", asMETHODPR(Engine, SetPauseMinimized, (bool), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "void set_pauseMinimized(bool)", asMETHODPR(Engine, SetPauseMinimized, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void SetPauseMinimized(bool)", AS_METHODPR(Engine, SetPauseMinimized, (bool), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void set_pauseMinimized(bool)", AS_METHODPR(Engine, SetPauseMinimized, (bool), void), AS_CALL_THISCALL);
     // void Engine::SetTimeStepSmoothing(int frames) | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "void SetTimeStepSmoothing(int)", asMETHODPR(Engine, SetTimeStepSmoothing, (int), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "void set_timeStepSmoothing(int)", asMETHODPR(Engine, SetTimeStepSmoothing, (int), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void SetTimeStepSmoothing(int)", AS_METHODPR(Engine, SetTimeStepSmoothing, (int), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void set_timeStepSmoothing(int)", AS_METHODPR(Engine, SetTimeStepSmoothing, (int), void), AS_CALL_THISCALL);
     // void Object::SubscribeToEvent(StringHash eventType, EventHandler* handler) | File: ../Core/Object.h
     // Error: type "EventHandler*" can not automatically bind
     // void Object::SubscribeToEvent(Object* sender, StringHash eventType, EventHandler* handler) | File: ../Core/Object.h
@@ -219,20 +219,20 @@ void ASRegisterGenerated_Members_E(asIScriptEngine* engine)
     // void Object::SubscribeToEvent(Object* sender, StringHash eventType, const std::function<void(StringHash, VariantMap&)>& function, void* userData=nullptr) | File: ../Core/Object.h
     // Error: type "const std::function<void(StringHash, VariantMap&)>&" can not automatically bind
     // void Object::UnsubscribeFromAllEvents() | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "void UnsubscribeFromAllEvents()", asMETHODPR(Engine, UnsubscribeFromAllEvents, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void UnsubscribeFromAllEvents()", AS_METHODPR(Engine, UnsubscribeFromAllEvents, (), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromAllEventsExcept(const PODVector<StringHash>& exceptions, bool onlyUserData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "void UnsubscribeFromAllEventsExcept(Array<StringHash>@+, bool)", asFUNCTION(Engine_UnsubscribeFromAllEventsExcept_PODVectorStringHash_bool), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod("Engine", "void UnsubscribeFromAllEventsExcept(Array<StringHash>@+, bool)", AS_FUNCTION_OBJFIRST(Engine_UnsubscribeFromAllEventsExcept_PODVectorStringHash_bool), AS_CALL_CDECL_OBJFIRST);
     // void Object::UnsubscribeFromEvent(StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "void UnsubscribeFromEvent(StringHash)", asMETHODPR(Engine, UnsubscribeFromEvent, (StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void UnsubscribeFromEvent(StringHash)", AS_METHODPR(Engine, UnsubscribeFromEvent, (StringHash), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromEvent(Object* sender, StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "void UnsubscribeFromEvent(Object@+, StringHash)", asMETHODPR(Engine, UnsubscribeFromEvent, (Object*, StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void UnsubscribeFromEvent(Object@+, StringHash)", AS_METHODPR(Engine, UnsubscribeFromEvent, (Object*, StringHash), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromEvents(Object* sender) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Engine", "void UnsubscribeFromEvents(Object@+)", asMETHODPR(Engine, UnsubscribeFromEvents, (Object*), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void UnsubscribeFromEvents(Object@+)", AS_METHODPR(Engine, UnsubscribeFromEvents, (Object*), void), AS_CALL_THISCALL);
     // void Engine::Update() | File: ../Engine/Engine.h
-    engine->RegisterObjectMethod("Engine", "void Update()", asMETHODPR(Engine, Update, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "void Update()", AS_METHODPR(Engine, Update, (), void), AS_CALL_THISCALL);
     // int RefCounted::WeakRefs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod("Engine", "int WeakRefs() const", asMETHODPR(Engine, WeakRefs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "int get_weakRefs() const", asMETHODPR(Engine, WeakRefs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "int WeakRefs() const", AS_METHODPR(Engine, WeakRefs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Engine", "int get_weakRefs() const", AS_METHODPR(Engine, WeakRefs, () const, int), AS_CALL_THISCALL);
 #ifdef REGISTER_MANUAL_PART_Object
     REGISTER_MANUAL_PART_Object(Engine, "Engine")
 #endif
@@ -246,102 +246,102 @@ void ASRegisterGenerated_Members_E(asIScriptEngine* engine)
     RegisterSubclass<RefCounted, Engine>(engine, "RefCounted", "Engine");
 
     // void RefCounted::AddRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour("EventProfiler", asBEHAVE_ADDREF, "void f()", asMETHODPR(EventProfiler, AddRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour("EventProfiler", asBEHAVE_ADDREF, "void f()", AS_METHODPR(EventProfiler, AddRef, (), void), AS_CALL_THISCALL);
     // void EventProfiler::BeginBlock(StringHash eventID) | File: ../Core/EventProfiler.h
-    engine->RegisterObjectMethod("EventProfiler", "void BeginBlock(StringHash)", asMETHODPR(EventProfiler, BeginBlock, (StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "void BeginBlock(StringHash)", AS_METHODPR(EventProfiler, BeginBlock, (StringHash), void), AS_CALL_THISCALL);
     // void Profiler::BeginFrame() | File: ../Core/Profiler.h
-    engine->RegisterObjectMethod("EventProfiler", "void BeginFrame()", asMETHODPR(EventProfiler, BeginFrame, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "void BeginFrame()", AS_METHODPR(EventProfiler, BeginFrame, (), void), AS_CALL_THISCALL);
     // void Profiler::BeginInterval() | File: ../Core/Profiler.h
-    engine->RegisterObjectMethod("EventProfiler", "void BeginInterval()", asMETHODPR(EventProfiler, BeginInterval, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "void BeginInterval()", AS_METHODPR(EventProfiler, BeginInterval, (), void), AS_CALL_THISCALL);
     // template<typename T> T* Object::Cast() | File: ../Core/Object.h
     // Not registered because template
     // template<typename T> const T* Object::Cast() const | File: ../Core/Object.h
     // Not registered because template
     // void Profiler::EndBlock() | File: ../Core/Profiler.h
-    engine->RegisterObjectMethod("EventProfiler", "void EndBlock()", asMETHODPR(EventProfiler, EndBlock, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "void EndBlock()", AS_METHODPR(EventProfiler, EndBlock, (), void), AS_CALL_THISCALL);
     // void Profiler::EndFrame() | File: ../Core/Profiler.h
-    engine->RegisterObjectMethod("EventProfiler", "void EndFrame()", asMETHODPR(EventProfiler, EndFrame, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "void EndFrame()", AS_METHODPR(EventProfiler, EndFrame, (), void), AS_CALL_THISCALL);
     // explicit EventProfiler::EventProfiler(Context* context) | File: ../Core/EventProfiler.h
-    engine->RegisterObjectBehaviour("EventProfiler", asBEHAVE_FACTORY, "EventProfiler@+ f()", asFUNCTION(EventProfiler_EventProfiler_Context), asCALL_CDECL);
+    engine->RegisterObjectBehaviour("EventProfiler", asBEHAVE_FACTORY, "EventProfiler@+ f()", AS_FUNCTION(EventProfiler_EventProfiler_Context), AS_CALL_CDECL);
     // bool Object::GetBlockEvents() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "bool GetBlockEvents() const", asMETHODPR(EventProfiler, GetBlockEvents, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "bool GetBlockEvents() const", AS_METHODPR(EventProfiler, GetBlockEvents, () const, bool), AS_CALL_THISCALL);
     // const String& Object::GetCategory() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "const String& GetCategory() const", asMETHODPR(EventProfiler, GetCategory, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("EventProfiler", "const String& get_category() const", asMETHODPR(EventProfiler, GetCategory, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "const String& GetCategory() const", AS_METHODPR(EventProfiler, GetCategory, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "const String& get_category() const", AS_METHODPR(EventProfiler, GetCategory, () const, const String&), AS_CALL_THISCALL);
     // Context* Object::GetContext() const | File: ../Core/Object.h
     // Error: type "Context*" can used only as function parameter
     // const ProfilerBlock* Profiler::GetCurrentBlock() | File: ../Core/Profiler.h
     // Error: type "ProfilerBlock" can not automatically bind bacause have @nobind mark
     // VariantMap& Object::GetEventDataMap() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "VariantMap& GetEventDataMap() const", asMETHODPR(EventProfiler, GetEventDataMap, () const, VariantMap&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "VariantMap& GetEventDataMap() const", AS_METHODPR(EventProfiler, GetEventDataMap, () const, VariantMap&), AS_CALL_THISCALL);
     // EventHandler* Object::GetEventHandler() const | File: ../Core/Object.h
     // Error: type "EventHandler*" can not automatically bind
     // Object* Object::GetEventSender() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "Object@+ GetEventSender() const", asMETHODPR(EventProfiler, GetEventSender, () const, Object*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "Object@+ GetEventSender() const", AS_METHODPR(EventProfiler, GetEventSender, () const, Object*), AS_CALL_THISCALL);
     // const Variant& Object::GetGlobalVar(StringHash key) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "const Variant& GetGlobalVar(StringHash) const", asMETHODPR(EventProfiler, GetGlobalVar, (StringHash) const, const Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("EventProfiler", "const Variant& get_globalVar(StringHash) const", asMETHODPR(EventProfiler, GetGlobalVar, (StringHash) const, const Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "const Variant& GetGlobalVar(StringHash) const", AS_METHODPR(EventProfiler, GetGlobalVar, (StringHash) const, const Variant&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "const Variant& get_globalVar(StringHash) const", AS_METHODPR(EventProfiler, GetGlobalVar, (StringHash) const, const Variant&), AS_CALL_THISCALL);
     // const VariantMap& Object::GetGlobalVars() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "const VariantMap& GetGlobalVars() const", asMETHODPR(EventProfiler, GetGlobalVars, () const, const VariantMap&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("EventProfiler", "const VariantMap& get_globalVars() const", asMETHODPR(EventProfiler, GetGlobalVars, () const, const VariantMap&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "const VariantMap& GetGlobalVars() const", AS_METHODPR(EventProfiler, GetGlobalVars, () const, const VariantMap&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "const VariantMap& get_globalVars() const", AS_METHODPR(EventProfiler, GetGlobalVars, () const, const VariantMap&), AS_CALL_THISCALL);
     // const ProfilerBlock* Profiler::GetRootBlock() | File: ../Core/Profiler.h
     // Error: type "ProfilerBlock" can not automatically bind bacause have @nobind mark
     // Object* Object::GetSubsystem(StringHash type) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "Object@+ GetSubsystem(StringHash) const", asMETHODPR(EventProfiler, GetSubsystem, (StringHash) const, Object*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "Object@+ GetSubsystem(StringHash) const", AS_METHODPR(EventProfiler, GetSubsystem, (StringHash) const, Object*), AS_CALL_THISCALL);
     // template<class T> T* Object::GetSubsystem() const | File: ../Core/Object.h
     // Not registered because template
     // virtual StringHash Object::GetType() const =0 | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "StringHash GetType() const", asMETHODPR(EventProfiler, GetType, () const, StringHash), asCALL_THISCALL);
-    engine->RegisterObjectMethod("EventProfiler", "StringHash get_type() const", asMETHODPR(EventProfiler, GetType, () const, StringHash), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "StringHash GetType() const", AS_METHODPR(EventProfiler, GetType, () const, StringHash), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "StringHash get_type() const", AS_METHODPR(EventProfiler, GetType, () const, StringHash), AS_CALL_THISCALL);
     // virtual const TypeInfo* Object::GetTypeInfo() const =0 | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // static const TypeInfo* Object::GetTypeInfoStatic() | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // virtual const String& Object::GetTypeName() const =0 | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "const String& GetTypeName() const", asMETHODPR(EventProfiler, GetTypeName, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("EventProfiler", "const String& get_typeName() const", asMETHODPR(EventProfiler, GetTypeName, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "const String& GetTypeName() const", AS_METHODPR(EventProfiler, GetTypeName, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "const String& get_typeName() const", AS_METHODPR(EventProfiler, GetTypeName, () const, const String&), AS_CALL_THISCALL);
     // bool Object::HasEventHandlers() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "bool HasEventHandlers() const", asMETHODPR(EventProfiler, HasEventHandlers, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "bool HasEventHandlers() const", AS_METHODPR(EventProfiler, HasEventHandlers, () const, bool), AS_CALL_THISCALL);
     // bool Object::HasSubscribedToEvent(StringHash eventType) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "bool HasSubscribedToEvent(StringHash) const", asMETHODPR(EventProfiler, HasSubscribedToEvent, (StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "bool HasSubscribedToEvent(StringHash) const", AS_METHODPR(EventProfiler, HasSubscribedToEvent, (StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::HasSubscribedToEvent(Object* sender, StringHash eventType) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "bool HasSubscribedToEvent(Object@+, StringHash) const", asMETHODPR(EventProfiler, HasSubscribedToEvent, (Object*, StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "bool HasSubscribedToEvent(Object@+, StringHash) const", AS_METHODPR(EventProfiler, HasSubscribedToEvent, (Object*, StringHash) const, bool), AS_CALL_THISCALL);
     // static bool EventProfiler::IsActive() | File: ../Core/EventProfiler.h
     engine->SetDefaultNamespace("EventProfiler");
-    engine->RegisterGlobalFunction("bool IsActive()", asFUNCTIONPR(EventProfiler::IsActive, (), bool), asCALL_CDECL);
+    engine->RegisterGlobalFunction("bool IsActive()", AS_FUNCTIONPR(EventProfiler::IsActive, (), bool), AS_CALL_CDECL);
     engine->SetDefaultNamespace("");
     // bool Object::IsInstanceOf(StringHash type) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "bool IsInstanceOf(StringHash) const", asMETHODPR(EventProfiler, IsInstanceOf, (StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "bool IsInstanceOf(StringHash) const", AS_METHODPR(EventProfiler, IsInstanceOf, (StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::IsInstanceOf(const TypeInfo* typeInfo) const | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // template<typename T> bool Object::IsInstanceOf() const | File: ../Core/Object.h
     // Not registered because template
     // virtual void Object::OnEvent(Object* sender, StringHash eventType, VariantMap& eventData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "void OnEvent(Object@+, StringHash, VariantMap&)", asMETHODPR(EventProfiler, OnEvent, (Object*, StringHash, VariantMap&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "void OnEvent(Object@+, StringHash, VariantMap&)", AS_METHODPR(EventProfiler, OnEvent, (Object*, StringHash, VariantMap&), void), AS_CALL_THISCALL);
     // const String& Profiler::PrintData(bool showUnused=false, bool showTotal=false, unsigned maxDepth=M_MAX_UNSIGNED) const | File: ../Core/Profiler.h
-    engine->RegisterObjectMethod("EventProfiler", "const String& PrintData(bool = false, bool = false, uint = M_MAX_UNSIGNED) const", asMETHODPR(EventProfiler, PrintData, (bool, bool, unsigned) const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "const String& PrintData(bool = false, bool = false, uint = M_MAX_UNSIGNED) const", AS_METHODPR(EventProfiler, PrintData, (bool, bool, unsigned) const, const String&), AS_CALL_THISCALL);
     // RefCount* RefCounted::RefCountPtr() | File: ../Container/RefCounted.h
     // Error: type "RefCount*" can not automatically bind
     // int RefCounted::Refs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod("EventProfiler", "int Refs() const", asMETHODPR(EventProfiler, Refs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("EventProfiler", "int get_refs() const", asMETHODPR(EventProfiler, Refs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "int Refs() const", AS_METHODPR(EventProfiler, Refs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "int get_refs() const", AS_METHODPR(EventProfiler, Refs, () const, int), AS_CALL_THISCALL);
     // void RefCounted::ReleaseRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour("EventProfiler", asBEHAVE_RELEASE, "void f()", asMETHODPR(EventProfiler, ReleaseRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour("EventProfiler", asBEHAVE_RELEASE, "void f()", AS_METHODPR(EventProfiler, ReleaseRef, (), void), AS_CALL_THISCALL);
     // void Object::SendEvent(StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "void SendEvent(StringHash)", asMETHODPR(EventProfiler, SendEvent, (StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "void SendEvent(StringHash)", AS_METHODPR(EventProfiler, SendEvent, (StringHash), void), AS_CALL_THISCALL);
     // void Object::SendEvent(StringHash eventType, VariantMap& eventData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "void SendEvent(StringHash, VariantMap&)", asMETHODPR(EventProfiler, SendEvent, (StringHash, VariantMap&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "void SendEvent(StringHash, VariantMap&)", AS_METHODPR(EventProfiler, SendEvent, (StringHash, VariantMap&), void), AS_CALL_THISCALL);
     // template<typename... Args> void Object::SendEvent(StringHash eventType, Args... args) | File: ../Core/Object.h
     // Not registered because template
     // static void EventProfiler::SetActive(bool newActive) | File: ../Core/EventProfiler.h
     engine->SetDefaultNamespace("EventProfiler");
-    engine->RegisterGlobalFunction("void SetActive(bool)", asFUNCTIONPR(EventProfiler::SetActive, (bool), void), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void SetActive(bool)", AS_FUNCTIONPR(EventProfiler::SetActive, (bool), void), AS_CALL_CDECL);
     engine->SetDefaultNamespace("");
     // void Object::SetBlockEvents(bool block) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "void SetBlockEvents(bool)", asMETHODPR(EventProfiler, SetBlockEvents, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "void SetBlockEvents(bool)", AS_METHODPR(EventProfiler, SetBlockEvents, (bool), void), AS_CALL_THISCALL);
     // void Object::SetGlobalVar(StringHash key, const Variant& value) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "void SetGlobalVar(StringHash, const Variant&in)", asMETHODPR(EventProfiler, SetGlobalVar, (StringHash, const Variant&), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("EventProfiler", "void set_globalVar(StringHash, const Variant&in)", asMETHODPR(EventProfiler, SetGlobalVar, (StringHash, const Variant&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "void SetGlobalVar(StringHash, const Variant&in)", AS_METHODPR(EventProfiler, SetGlobalVar, (StringHash, const Variant&), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "void set_globalVar(StringHash, const Variant&in)", AS_METHODPR(EventProfiler, SetGlobalVar, (StringHash, const Variant&), void), AS_CALL_THISCALL);
     // void Object::SubscribeToEvent(StringHash eventType, EventHandler* handler) | File: ../Core/Object.h
     // Error: type "EventHandler*" can not automatically bind
     // void Object::SubscribeToEvent(Object* sender, StringHash eventType, EventHandler* handler) | File: ../Core/Object.h
@@ -351,18 +351,18 @@ void ASRegisterGenerated_Members_E(asIScriptEngine* engine)
     // void Object::SubscribeToEvent(Object* sender, StringHash eventType, const std::function<void(StringHash, VariantMap&)>& function, void* userData=nullptr) | File: ../Core/Object.h
     // Error: type "const std::function<void(StringHash, VariantMap&)>&" can not automatically bind
     // void Object::UnsubscribeFromAllEvents() | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "void UnsubscribeFromAllEvents()", asMETHODPR(EventProfiler, UnsubscribeFromAllEvents, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "void UnsubscribeFromAllEvents()", AS_METHODPR(EventProfiler, UnsubscribeFromAllEvents, (), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromAllEventsExcept(const PODVector<StringHash>& exceptions, bool onlyUserData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "void UnsubscribeFromAllEventsExcept(Array<StringHash>@+, bool)", asFUNCTION(EventProfiler_UnsubscribeFromAllEventsExcept_PODVectorStringHash_bool), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod("EventProfiler", "void UnsubscribeFromAllEventsExcept(Array<StringHash>@+, bool)", AS_FUNCTION_OBJFIRST(EventProfiler_UnsubscribeFromAllEventsExcept_PODVectorStringHash_bool), AS_CALL_CDECL_OBJFIRST);
     // void Object::UnsubscribeFromEvent(StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "void UnsubscribeFromEvent(StringHash)", asMETHODPR(EventProfiler, UnsubscribeFromEvent, (StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "void UnsubscribeFromEvent(StringHash)", AS_METHODPR(EventProfiler, UnsubscribeFromEvent, (StringHash), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromEvent(Object* sender, StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "void UnsubscribeFromEvent(Object@+, StringHash)", asMETHODPR(EventProfiler, UnsubscribeFromEvent, (Object*, StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "void UnsubscribeFromEvent(Object@+, StringHash)", AS_METHODPR(EventProfiler, UnsubscribeFromEvent, (Object*, StringHash), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromEvents(Object* sender) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("EventProfiler", "void UnsubscribeFromEvents(Object@+)", asMETHODPR(EventProfiler, UnsubscribeFromEvents, (Object*), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "void UnsubscribeFromEvents(Object@+)", AS_METHODPR(EventProfiler, UnsubscribeFromEvents, (Object*), void), AS_CALL_THISCALL);
     // int RefCounted::WeakRefs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod("EventProfiler", "int WeakRefs() const", asMETHODPR(EventProfiler, WeakRefs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("EventProfiler", "int get_weakRefs() const", asMETHODPR(EventProfiler, WeakRefs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "int WeakRefs() const", AS_METHODPR(EventProfiler, WeakRefs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("EventProfiler", "int get_weakRefs() const", AS_METHODPR(EventProfiler, WeakRefs, () const, int), AS_CALL_THISCALL);
 #ifdef REGISTER_MANUAL_PART_Profiler
     REGISTER_MANUAL_PART_Profiler(EventProfiler, "EventProfiler")
 #endif
@@ -382,27 +382,27 @@ void ASRegisterGenerated_Members_E(asIScriptEngine* engine)
     // PODVector<Object*> EventReceiverGroup::receivers_ | File: ../Core/Context.h
     // Error: type "PODVector<Object*>" can not automatically bind
     // void EventReceiverGroup::Add(Object* object) | File: ../Core/Context.h
-    engine->RegisterObjectMethod("EventReceiverGroup", "void Add(Object@+)", asMETHODPR(EventReceiverGroup, Add, (Object*), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventReceiverGroup", "void Add(Object@+)", AS_METHODPR(EventReceiverGroup, Add, (Object*), void), AS_CALL_THISCALL);
     // void RefCounted::AddRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour("EventReceiverGroup", asBEHAVE_ADDREF, "void f()", asMETHODPR(EventReceiverGroup, AddRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour("EventReceiverGroup", asBEHAVE_ADDREF, "void f()", AS_METHODPR(EventReceiverGroup, AddRef, (), void), AS_CALL_THISCALL);
     // void EventReceiverGroup::BeginSendEvent() | File: ../Core/Context.h
-    engine->RegisterObjectMethod("EventReceiverGroup", "void BeginSendEvent()", asMETHODPR(EventReceiverGroup, BeginSendEvent, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventReceiverGroup", "void BeginSendEvent()", AS_METHODPR(EventReceiverGroup, BeginSendEvent, (), void), AS_CALL_THISCALL);
     // void EventReceiverGroup::EndSendEvent() | File: ../Core/Context.h
-    engine->RegisterObjectMethod("EventReceiverGroup", "void EndSendEvent()", asMETHODPR(EventReceiverGroup, EndSendEvent, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventReceiverGroup", "void EndSendEvent()", AS_METHODPR(EventReceiverGroup, EndSendEvent, (), void), AS_CALL_THISCALL);
     // EventReceiverGroup::EventReceiverGroup() | File: ../Core/Context.h
-    engine->RegisterObjectBehaviour("EventReceiverGroup", asBEHAVE_FACTORY, "EventReceiverGroup@+ f()", asFUNCTION(EventReceiverGroup_EventReceiverGroup_void), asCALL_CDECL);
+    engine->RegisterObjectBehaviour("EventReceiverGroup", asBEHAVE_FACTORY, "EventReceiverGroup@+ f()", AS_FUNCTION(EventReceiverGroup_EventReceiverGroup_void), AS_CALL_CDECL);
     // RefCount* RefCounted::RefCountPtr() | File: ../Container/RefCounted.h
     // Error: type "RefCount*" can not automatically bind
     // int RefCounted::Refs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod("EventReceiverGroup", "int Refs() const", asMETHODPR(EventReceiverGroup, Refs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("EventReceiverGroup", "int get_refs() const", asMETHODPR(EventReceiverGroup, Refs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventReceiverGroup", "int Refs() const", AS_METHODPR(EventReceiverGroup, Refs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("EventReceiverGroup", "int get_refs() const", AS_METHODPR(EventReceiverGroup, Refs, () const, int), AS_CALL_THISCALL);
     // void RefCounted::ReleaseRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour("EventReceiverGroup", asBEHAVE_RELEASE, "void f()", asMETHODPR(EventReceiverGroup, ReleaseRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour("EventReceiverGroup", asBEHAVE_RELEASE, "void f()", AS_METHODPR(EventReceiverGroup, ReleaseRef, (), void), AS_CALL_THISCALL);
     // void EventReceiverGroup::Remove(Object* object) | File: ../Core/Context.h
-    engine->RegisterObjectMethod("EventReceiverGroup", "void Remove(Object@+)", asMETHODPR(EventReceiverGroup, Remove, (Object*), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventReceiverGroup", "void Remove(Object@+)", AS_METHODPR(EventReceiverGroup, Remove, (Object*), void), AS_CALL_THISCALL);
     // int RefCounted::WeakRefs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod("EventReceiverGroup", "int WeakRefs() const", asMETHODPR(EventReceiverGroup, WeakRefs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("EventReceiverGroup", "int get_weakRefs() const", asMETHODPR(EventReceiverGroup, WeakRefs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("EventReceiverGroup", "int WeakRefs() const", AS_METHODPR(EventReceiverGroup, WeakRefs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("EventReceiverGroup", "int get_weakRefs() const", AS_METHODPR(EventReceiverGroup, WeakRefs, () const, int), AS_CALL_THISCALL);
 #ifdef REGISTER_MANUAL_PART_RefCounted
     REGISTER_MANUAL_PART_RefCounted(EventReceiverGroup, "EventReceiverGroup")
 #endif

Source/Urho3D/AngelScript/Generated_Members_H.cpp

@@ -40,13 +40,13 @@ void ASRegisterGenerated_Members_H(asIScriptEngine* engine)
     engine->RegisterGlobalProperty("const uint MIN_BUCKETS", (void*)&HashBase::MIN_BUCKETS);
     engine->SetDefaultNamespace("");
     // bool HashBase::Empty() const | File: ../Container/HashBase.h
-    engine->RegisterObjectMethod("HashBase", "bool Empty() const", asMETHODPR(HashBase, Empty, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HashBase", "bool Empty() const", AS_METHODPR(HashBase, Empty, () const, bool), AS_CALL_THISCALL);
     // unsigned HashBase::NumBuckets() const | File: ../Container/HashBase.h
-    engine->RegisterObjectMethod("HashBase", "uint NumBuckets() const", asMETHODPR(HashBase, NumBuckets, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HashBase", "uint NumBuckets() const", AS_METHODPR(HashBase, NumBuckets, () const, unsigned), AS_CALL_THISCALL);
     // unsigned HashBase::Size() const | File: ../Container/HashBase.h
-    engine->RegisterObjectMethod("HashBase", "uint Size() const", asMETHODPR(HashBase, Size, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HashBase", "uint Size() const", AS_METHODPR(HashBase, Size, () const, unsigned), AS_CALL_THISCALL);
     // void HashBase::Swap(HashBase& rhs) | File: ../Container/HashBase.h
-    engine->RegisterObjectMethod("HashBase", "void Swap(HashBase&)", asMETHODPR(HashBase, Swap, (HashBase&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HashBase", "void Swap(HashBase&)", AS_METHODPR(HashBase, Swap, (HashBase&), void), AS_CALL_THISCALL);
     // HashBase& HashBase::operator=(const HashBase&) | Possible implicitly-declared
     RegisterImplicitlyDeclaredAssignOperatorIfPossible<HashBase>(engine, "HashBase");
 #ifdef REGISTER_MANUAL_PART_HashBase
@@ -55,16 +55,16 @@ void ASRegisterGenerated_Members_H(asIScriptEngine* engine)
 
     // static long long HiresTimer::GetFrequency() | File: ../Core/Timer.h
     engine->SetDefaultNamespace("HiresTimer");
-    engine->RegisterGlobalFunction("int64 GetFrequency()", asFUNCTIONPR(HiresTimer::GetFrequency, (), long long), asCALL_CDECL);
+    engine->RegisterGlobalFunction("int64 GetFrequency()", AS_FUNCTIONPR(HiresTimer::GetFrequency, (), long long), AS_CALL_CDECL);
     engine->SetDefaultNamespace("");
     // long long HiresTimer::GetUSec(bool reset) | File: ../Core/Timer.h
-    engine->RegisterObjectMethod("HiresTimer", "int64 GetUSec(bool)", asMETHODPR(HiresTimer, GetUSec, (bool), long long), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HiresTimer", "int64 GetUSec(bool)", AS_METHODPR(HiresTimer, GetUSec, (bool), long long), AS_CALL_THISCALL);
     // static bool HiresTimer::IsSupported() | File: ../Core/Timer.h
     engine->SetDefaultNamespace("HiresTimer");
-    engine->RegisterGlobalFunction("bool IsSupported()", asFUNCTIONPR(HiresTimer::IsSupported, (), bool), asCALL_CDECL);
+    engine->RegisterGlobalFunction("bool IsSupported()", AS_FUNCTIONPR(HiresTimer::IsSupported, (), bool), AS_CALL_CDECL);
     engine->SetDefaultNamespace("");
     // void HiresTimer::Reset() | File: ../Core/Timer.h
-    engine->RegisterObjectMethod("HiresTimer", "void Reset()", asMETHODPR(HiresTimer, Reset, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HiresTimer", "void Reset()", AS_METHODPR(HiresTimer, Reset, (), void), AS_CALL_THISCALL);
     // HiresTimer& HiresTimer::operator=(const HiresTimer&) | Possible implicitly-declared
     RegisterImplicitlyDeclaredAssignOperatorIfPossible<HiresTimer>(engine, "HiresTimer");
 #ifdef REGISTER_MANUAL_PART_HiresTimer
@@ -73,160 +73,160 @@ void ASRegisterGenerated_Members_H(asIScriptEngine* engine)
 
 #ifdef URHO3D_NETWORK
     // void RefCounted::AddRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour("HttpRequest", asBEHAVE_ADDREF, "void f()", asMETHODPR(HttpRequest, AddRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour("HttpRequest", asBEHAVE_ADDREF, "void f()", AS_METHODPR(HttpRequest, AddRef, (), void), AS_CALL_THISCALL);
     // unsigned HttpRequest::GetAvailableSize() const | File: ../Network/HttpRequest.h
-    engine->RegisterObjectMethod("HttpRequest", "uint GetAvailableSize() const", asMETHODPR(HttpRequest, GetAvailableSize, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("HttpRequest", "uint get_availableSize() const", asMETHODPR(HttpRequest, GetAvailableSize, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "uint GetAvailableSize() const", AS_METHODPR(HttpRequest, GetAvailableSize, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "uint get_availableSize() const", AS_METHODPR(HttpRequest, GetAvailableSize, () const, unsigned), AS_CALL_THISCALL);
     // virtual unsigned Deserializer::GetChecksum() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "uint GetChecksum()", asMETHODPR(HttpRequest, GetChecksum, (), unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("HttpRequest", "uint get_checksum()", asMETHODPR(HttpRequest, GetChecksum, (), unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "uint GetChecksum()", AS_METHODPR(HttpRequest, GetChecksum, (), unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "uint get_checksum()", AS_METHODPR(HttpRequest, GetChecksum, (), unsigned), AS_CALL_THISCALL);
     // static ThreadID Thread::GetCurrentThreadID() | File: ../Core/Thread.h
     // Not registered because have @nobind mark
     // String HttpRequest::GetError() const | File: ../Network/HttpRequest.h
-    engine->RegisterObjectMethod("HttpRequest", "String GetError() const", asMETHODPR(HttpRequest, GetError, () const, String), asCALL_THISCALL);
-    engine->RegisterObjectMethod("HttpRequest", "String get_error() const", asMETHODPR(HttpRequest, GetError, () const, String), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "String GetError() const", AS_METHODPR(HttpRequest, GetError, () const, String), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "String get_error() const", AS_METHODPR(HttpRequest, GetError, () const, String), AS_CALL_THISCALL);
     // virtual const String& Deserializer::GetName() const | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "const String& GetName() const", asMETHODPR(HttpRequest, GetName, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("HttpRequest", "const String& get_name() const", asMETHODPR(HttpRequest, GetName, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "const String& GetName() const", AS_METHODPR(HttpRequest, GetName, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "const String& get_name() const", AS_METHODPR(HttpRequest, GetName, () const, const String&), AS_CALL_THISCALL);
     // unsigned Deserializer::GetPosition() const | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "uint GetPosition() const", asMETHODPR(HttpRequest, GetPosition, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("HttpRequest", "uint get_position() const", asMETHODPR(HttpRequest, GetPosition, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "uint GetPosition() const", AS_METHODPR(HttpRequest, GetPosition, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "uint get_position() const", AS_METHODPR(HttpRequest, GetPosition, () const, unsigned), AS_CALL_THISCALL);
     // unsigned Deserializer::GetSize() const | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "uint GetSize() const", asMETHODPR(HttpRequest, GetSize, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("HttpRequest", "uint get_size() const", asMETHODPR(HttpRequest, GetSize, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "uint GetSize() const", AS_METHODPR(HttpRequest, GetSize, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "uint get_size() const", AS_METHODPR(HttpRequest, GetSize, () const, unsigned), AS_CALL_THISCALL);
     // HttpRequestState HttpRequest::GetState() const | File: ../Network/HttpRequest.h
-    engine->RegisterObjectMethod("HttpRequest", "HttpRequestState GetState() const", asMETHODPR(HttpRequest, GetState, () const, HttpRequestState), asCALL_THISCALL);
-    engine->RegisterObjectMethod("HttpRequest", "HttpRequestState get_state() const", asMETHODPR(HttpRequest, GetState, () const, HttpRequestState), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "HttpRequestState GetState() const", AS_METHODPR(HttpRequest, GetState, () const, HttpRequestState), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "HttpRequestState get_state() const", AS_METHODPR(HttpRequest, GetState, () const, HttpRequestState), AS_CALL_THISCALL);
     // const String& HttpRequest::GetURL() const | File: ../Network/HttpRequest.h
-    engine->RegisterObjectMethod("HttpRequest", "const String& GetURL() const", asMETHODPR(HttpRequest, GetURL, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("HttpRequest", "const String& get_url() const", asMETHODPR(HttpRequest, GetURL, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "const String& GetURL() const", AS_METHODPR(HttpRequest, GetURL, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "const String& get_url() const", AS_METHODPR(HttpRequest, GetURL, () const, const String&), AS_CALL_THISCALL);
     // const String& HttpRequest::GetVerb() const | File: ../Network/HttpRequest.h
-    engine->RegisterObjectMethod("HttpRequest", "const String& GetVerb() const", asMETHODPR(HttpRequest, GetVerb, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("HttpRequest", "const String& get_verb() const", asMETHODPR(HttpRequest, GetVerb, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "const String& GetVerb() const", AS_METHODPR(HttpRequest, GetVerb, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "const String& get_verb() const", AS_METHODPR(HttpRequest, GetVerb, () const, const String&), AS_CALL_THISCALL);
     // HttpRequest::HttpRequest(const String& url, const String& verb, const Vector<String>& headers, const String& postData) | File: ../Network/HttpRequest.h
     // Error: type "const Vector<String>&" can not automatically bind
     // bool HttpRequest::IsEof() const override | File: ../Network/HttpRequest.h
-    engine->RegisterObjectMethod("HttpRequest", "bool IsEof() const", asMETHODPR(HttpRequest, IsEof, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("HttpRequest", "bool get_eof() const", asMETHODPR(HttpRequest, IsEof, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "bool IsEof() const", AS_METHODPR(HttpRequest, IsEof, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "bool get_eof() const", AS_METHODPR(HttpRequest, IsEof, () const, bool), AS_CALL_THISCALL);
     // static bool Thread::IsMainThread() | File: ../Core/Thread.h
     engine->SetDefaultNamespace("HttpRequest");
-    engine->RegisterGlobalFunction("bool IsMainThread()", asFUNCTIONPR(HttpRequest::IsMainThread, (), bool), asCALL_CDECL);
+    engine->RegisterGlobalFunction("bool IsMainThread()", AS_FUNCTIONPR(HttpRequest::IsMainThread, (), bool), AS_CALL_CDECL);
     engine->SetDefaultNamespace("");
     // bool HttpRequest::IsOpen() const | File: ../Network/HttpRequest.h
-    engine->RegisterObjectMethod("HttpRequest", "bool IsOpen() const", asMETHODPR(HttpRequest, IsOpen, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("HttpRequest", "bool get_open() const", asMETHODPR(HttpRequest, IsOpen, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "bool IsOpen() const", AS_METHODPR(HttpRequest, IsOpen, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "bool get_open() const", AS_METHODPR(HttpRequest, IsOpen, () const, bool), AS_CALL_THISCALL);
     // bool Thread::IsStarted() const | File: ../Core/Thread.h
-    engine->RegisterObjectMethod("HttpRequest", "bool IsStarted() const", asMETHODPR(HttpRequest, IsStarted, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "bool IsStarted() const", AS_METHODPR(HttpRequest, IsStarted, () const, bool), AS_CALL_THISCALL);
     // unsigned HttpRequest::Read(void* dest, unsigned size) override | File: ../Network/HttpRequest.h
     // Error: type "void*" can not automatically bind
     // bool Deserializer::ReadBool() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "bool ReadBool()", asMETHODPR(HttpRequest, ReadBool, (), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "bool ReadBool()", AS_METHODPR(HttpRequest, ReadBool, (), bool), AS_CALL_THISCALL);
     // BoundingBox Deserializer::ReadBoundingBox() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "BoundingBox ReadBoundingBox()", asMETHODPR(HttpRequest, ReadBoundingBox, (), BoundingBox), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "BoundingBox ReadBoundingBox()", AS_METHODPR(HttpRequest, ReadBoundingBox, (), BoundingBox), AS_CALL_THISCALL);
     // PODVector<unsigned char> Deserializer::ReadBuffer() | File: ../IO/Deserializer.h
     // Error: type "PODVector<unsigned char>" can not automatically bind
     // signed char Deserializer::ReadByte() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "int8 ReadByte()", asMETHODPR(HttpRequest, ReadByte, (), signed char), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "int8 ReadByte()", AS_METHODPR(HttpRequest, ReadByte, (), signed char), AS_CALL_THISCALL);
     // Color Deserializer::ReadColor() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "Color ReadColor()", asMETHODPR(HttpRequest, ReadColor, (), Color), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "Color ReadColor()", AS_METHODPR(HttpRequest, ReadColor, (), Color), AS_CALL_THISCALL);
     // double Deserializer::ReadDouble() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "double ReadDouble()", asMETHODPR(HttpRequest, ReadDouble, (), double), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "double ReadDouble()", AS_METHODPR(HttpRequest, ReadDouble, (), double), AS_CALL_THISCALL);
     // String Deserializer::ReadFileID() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "String ReadFileID()", asMETHODPR(HttpRequest, ReadFileID, (), String), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "String ReadFileID()", AS_METHODPR(HttpRequest, ReadFileID, (), String), AS_CALL_THISCALL);
     // float Deserializer::ReadFloat() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "float ReadFloat()", asMETHODPR(HttpRequest, ReadFloat, (), float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "float ReadFloat()", AS_METHODPR(HttpRequest, ReadFloat, (), float), AS_CALL_THISCALL);
     // int Deserializer::ReadInt() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "int ReadInt()", asMETHODPR(HttpRequest, ReadInt, (), int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "int ReadInt()", AS_METHODPR(HttpRequest, ReadInt, (), int), AS_CALL_THISCALL);
     // long long Deserializer::ReadInt64() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "int64 ReadInt64()", asMETHODPR(HttpRequest, ReadInt64, (), long long), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "int64 ReadInt64()", AS_METHODPR(HttpRequest, ReadInt64, (), long long), AS_CALL_THISCALL);
     // IntRect Deserializer::ReadIntRect() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "IntRect ReadIntRect()", asMETHODPR(HttpRequest, ReadIntRect, (), IntRect), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "IntRect ReadIntRect()", AS_METHODPR(HttpRequest, ReadIntRect, (), IntRect), AS_CALL_THISCALL);
     // IntVector2 Deserializer::ReadIntVector2() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "IntVector2 ReadIntVector2()", asMETHODPR(HttpRequest, ReadIntVector2, (), IntVector2), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "IntVector2 ReadIntVector2()", AS_METHODPR(HttpRequest, ReadIntVector2, (), IntVector2), AS_CALL_THISCALL);
     // IntVector3 Deserializer::ReadIntVector3() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "IntVector3 ReadIntVector3()", asMETHODPR(HttpRequest, ReadIntVector3, (), IntVector3), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "IntVector3 ReadIntVector3()", AS_METHODPR(HttpRequest, ReadIntVector3, (), IntVector3), AS_CALL_THISCALL);
     // String Deserializer::ReadLine() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "String ReadLine()", asMETHODPR(HttpRequest, ReadLine, (), String), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "String ReadLine()", AS_METHODPR(HttpRequest, ReadLine, (), String), AS_CALL_THISCALL);
     // Matrix3 Deserializer::ReadMatrix3() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "Matrix3 ReadMatrix3()", asMETHODPR(HttpRequest, ReadMatrix3, (), Matrix3), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "Matrix3 ReadMatrix3()", AS_METHODPR(HttpRequest, ReadMatrix3, (), Matrix3), AS_CALL_THISCALL);
     // Matrix3x4 Deserializer::ReadMatrix3x4() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "Matrix3x4 ReadMatrix3x4()", asMETHODPR(HttpRequest, ReadMatrix3x4, (), Matrix3x4), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "Matrix3x4 ReadMatrix3x4()", AS_METHODPR(HttpRequest, ReadMatrix3x4, (), Matrix3x4), AS_CALL_THISCALL);
     // Matrix4 Deserializer::ReadMatrix4() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "Matrix4 ReadMatrix4()", asMETHODPR(HttpRequest, ReadMatrix4, (), Matrix4), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "Matrix4 ReadMatrix4()", AS_METHODPR(HttpRequest, ReadMatrix4, (), Matrix4), AS_CALL_THISCALL);
     // unsigned Deserializer::ReadNetID() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "uint ReadNetID()", asMETHODPR(HttpRequest, ReadNetID, (), unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "uint ReadNetID()", AS_METHODPR(HttpRequest, ReadNetID, (), unsigned), AS_CALL_THISCALL);
     // Quaternion Deserializer::ReadPackedQuaternion() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "Quaternion ReadPackedQuaternion()", asMETHODPR(HttpRequest, ReadPackedQuaternion, (), Quaternion), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "Quaternion ReadPackedQuaternion()", AS_METHODPR(HttpRequest, ReadPackedQuaternion, (), Quaternion), AS_CALL_THISCALL);
     // Vector3 Deserializer::ReadPackedVector3(float maxAbsCoord) | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "Vector3 ReadPackedVector3(float)", asMETHODPR(HttpRequest, ReadPackedVector3, (float), Vector3), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "Vector3 ReadPackedVector3(float)", AS_METHODPR(HttpRequest, ReadPackedVector3, (float), Vector3), AS_CALL_THISCALL);
     // Quaternion Deserializer::ReadQuaternion() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "Quaternion ReadQuaternion()", asMETHODPR(HttpRequest, ReadQuaternion, (), Quaternion), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "Quaternion ReadQuaternion()", AS_METHODPR(HttpRequest, ReadQuaternion, (), Quaternion), AS_CALL_THISCALL);
     // Rect Deserializer::ReadRect() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "Rect ReadRect()", asMETHODPR(HttpRequest, ReadRect, (), Rect), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "Rect ReadRect()", AS_METHODPR(HttpRequest, ReadRect, (), Rect), AS_CALL_THISCALL);
     // ResourceRef Deserializer::ReadResourceRef() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "ResourceRef ReadResourceRef()", asMETHODPR(HttpRequest, ReadResourceRef, (), ResourceRef), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "ResourceRef ReadResourceRef()", AS_METHODPR(HttpRequest, ReadResourceRef, (), ResourceRef), AS_CALL_THISCALL);
     // ResourceRefList Deserializer::ReadResourceRefList() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "ResourceRefList ReadResourceRefList()", asMETHODPR(HttpRequest, ReadResourceRefList, (), ResourceRefList), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "ResourceRefList ReadResourceRefList()", AS_METHODPR(HttpRequest, ReadResourceRefList, (), ResourceRefList), AS_CALL_THISCALL);
     // short Deserializer::ReadShort() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "int16 ReadShort()", asMETHODPR(HttpRequest, ReadShort, (), short), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "int16 ReadShort()", AS_METHODPR(HttpRequest, ReadShort, (), short), AS_CALL_THISCALL);
     // String Deserializer::ReadString() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "String ReadString()", asMETHODPR(HttpRequest, ReadString, (), String), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "String ReadString()", AS_METHODPR(HttpRequest, ReadString, (), String), AS_CALL_THISCALL);
     // StringHash Deserializer::ReadStringHash() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "StringHash ReadStringHash()", asMETHODPR(HttpRequest, ReadStringHash, (), StringHash), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "StringHash ReadStringHash()", AS_METHODPR(HttpRequest, ReadStringHash, (), StringHash), AS_CALL_THISCALL);
     // StringVector Deserializer::ReadStringVector() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "Array<String>@ ReadStringVector()", asFUNCTION(HttpRequest_ReadStringVector_void), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod("HttpRequest", "Array<String>@ ReadStringVector()", AS_FUNCTION_OBJFIRST(HttpRequest_ReadStringVector_void), AS_CALL_CDECL_OBJFIRST);
     // unsigned char Deserializer::ReadUByte() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "uint8 ReadUByte()", asMETHODPR(HttpRequest, ReadUByte, (), unsigned char), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "uint8 ReadUByte()", AS_METHODPR(HttpRequest, ReadUByte, (), unsigned char), AS_CALL_THISCALL);
     // unsigned Deserializer::ReadUInt() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "uint ReadUInt()", asMETHODPR(HttpRequest, ReadUInt, (), unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "uint ReadUInt()", AS_METHODPR(HttpRequest, ReadUInt, (), unsigned), AS_CALL_THISCALL);
     // unsigned long long Deserializer::ReadUInt64() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "uint64 ReadUInt64()", asMETHODPR(HttpRequest, ReadUInt64, (), unsigned long long), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "uint64 ReadUInt64()", AS_METHODPR(HttpRequest, ReadUInt64, (), unsigned long long), AS_CALL_THISCALL);
     // unsigned short Deserializer::ReadUShort() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "uint16 ReadUShort()", asMETHODPR(HttpRequest, ReadUShort, (), unsigned short), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "uint16 ReadUShort()", AS_METHODPR(HttpRequest, ReadUShort, (), unsigned short), AS_CALL_THISCALL);
     // Variant Deserializer::ReadVariant() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "Variant ReadVariant()", asMETHODPR(HttpRequest, ReadVariant, (), Variant), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "Variant ReadVariant()", AS_METHODPR(HttpRequest, ReadVariant, (), Variant), AS_CALL_THISCALL);
     // Variant Deserializer::ReadVariant(VariantType type) | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "Variant ReadVariant(VariantType)", asMETHODPR(HttpRequest, ReadVariant, (VariantType), Variant), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "Variant ReadVariant(VariantType)", AS_METHODPR(HttpRequest, ReadVariant, (VariantType), Variant), AS_CALL_THISCALL);
     // VariantMap Deserializer::ReadVariantMap() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "VariantMap ReadVariantMap()", asMETHODPR(HttpRequest, ReadVariantMap, (), VariantMap), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "VariantMap ReadVariantMap()", AS_METHODPR(HttpRequest, ReadVariantMap, (), VariantMap), AS_CALL_THISCALL);
     // VariantVector Deserializer::ReadVariantVector() | File: ../IO/Deserializer.h
     // Error: type "VariantVector" can not automatically bind
     // Vector2 Deserializer::ReadVector2() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "Vector2 ReadVector2()", asMETHODPR(HttpRequest, ReadVector2, (), Vector2), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "Vector2 ReadVector2()", AS_METHODPR(HttpRequest, ReadVector2, (), Vector2), AS_CALL_THISCALL);
     // Vector3 Deserializer::ReadVector3() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "Vector3 ReadVector3()", asMETHODPR(HttpRequest, ReadVector3, (), Vector3), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "Vector3 ReadVector3()", AS_METHODPR(HttpRequest, ReadVector3, (), Vector3), AS_CALL_THISCALL);
     // Vector4 Deserializer::ReadVector4() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "Vector4 ReadVector4()", asMETHODPR(HttpRequest, ReadVector4, (), Vector4), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "Vector4 ReadVector4()", AS_METHODPR(HttpRequest, ReadVector4, (), Vector4), AS_CALL_THISCALL);
     // unsigned Deserializer::ReadVLE() | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "uint ReadVLE()", asMETHODPR(HttpRequest, ReadVLE, (), unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "uint ReadVLE()", AS_METHODPR(HttpRequest, ReadVLE, (), unsigned), AS_CALL_THISCALL);
     // RefCount* RefCounted::RefCountPtr() | File: ../Container/RefCounted.h
     // Error: type "RefCount*" can not automatically bind
     // int RefCounted::Refs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod("HttpRequest", "int Refs() const", asMETHODPR(HttpRequest, Refs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("HttpRequest", "int get_refs() const", asMETHODPR(HttpRequest, Refs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "int Refs() const", AS_METHODPR(HttpRequest, Refs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "int get_refs() const", AS_METHODPR(HttpRequest, Refs, () const, int), AS_CALL_THISCALL);
     // void RefCounted::ReleaseRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour("HttpRequest", asBEHAVE_RELEASE, "void f()", asMETHODPR(HttpRequest, ReleaseRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour("HttpRequest", asBEHAVE_RELEASE, "void f()", AS_METHODPR(HttpRequest, ReleaseRef, (), void), AS_CALL_THISCALL);
     // bool Thread::Run() | File: ../Core/Thread.h
-    engine->RegisterObjectMethod("HttpRequest", "bool Run()", asMETHODPR(HttpRequest, Run, (), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "bool Run()", AS_METHODPR(HttpRequest, Run, (), bool), AS_CALL_THISCALL);
     // unsigned HttpRequest::Seek(unsigned position) override | File: ../Network/HttpRequest.h
-    engine->RegisterObjectMethod("HttpRequest", "uint Seek(uint)", asMETHODPR(HttpRequest, Seek, (unsigned), unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "uint Seek(uint)", AS_METHODPR(HttpRequest, Seek, (unsigned), unsigned), AS_CALL_THISCALL);
     // unsigned Deserializer::SeekRelative(int delta) | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "uint SeekRelative(int)", asMETHODPR(HttpRequest, SeekRelative, (int), unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "uint SeekRelative(int)", AS_METHODPR(HttpRequest, SeekRelative, (int), unsigned), AS_CALL_THISCALL);
     // static void Thread::SetMainThread() | File: ../Core/Thread.h
     engine->SetDefaultNamespace("HttpRequest");
-    engine->RegisterGlobalFunction("void SetMainThread()", asFUNCTIONPR(HttpRequest::SetMainThread, (), void), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void SetMainThread()", AS_FUNCTIONPR(HttpRequest::SetMainThread, (), void), AS_CALL_CDECL);
     engine->SetDefaultNamespace("");
     // void Thread::SetPriority(int priority) | File: ../Core/Thread.h
-    engine->RegisterObjectMethod("HttpRequest", "void SetPriority(int)", asMETHODPR(HttpRequest, SetPriority, (int), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "void SetPriority(int)", AS_METHODPR(HttpRequest, SetPriority, (int), void), AS_CALL_THISCALL);
     // void Thread::Stop() | File: ../Core/Thread.h
-    engine->RegisterObjectMethod("HttpRequest", "void Stop()", asMETHODPR(HttpRequest, Stop, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "void Stop()", AS_METHODPR(HttpRequest, Stop, (), void), AS_CALL_THISCALL);
     // unsigned Deserializer::Tell() const | File: ../IO/Deserializer.h
-    engine->RegisterObjectMethod("HttpRequest", "uint Tell() const", asMETHODPR(HttpRequest, Tell, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "uint Tell() const", AS_METHODPR(HttpRequest, Tell, () const, unsigned), AS_CALL_THISCALL);
     // void HttpRequest::ThreadFunction() override | File: ../Network/HttpRequest.h
-    engine->RegisterObjectMethod("HttpRequest", "void ThreadFunction()", asMETHODPR(HttpRequest, ThreadFunction, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "void ThreadFunction()", AS_METHODPR(HttpRequest, ThreadFunction, (), void), AS_CALL_THISCALL);
     // int RefCounted::WeakRefs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod("HttpRequest", "int WeakRefs() const", asMETHODPR(HttpRequest, WeakRefs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("HttpRequest", "int get_weakRefs() const", asMETHODPR(HttpRequest, WeakRefs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "int WeakRefs() const", AS_METHODPR(HttpRequest, WeakRefs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("HttpRequest", "int get_weakRefs() const", AS_METHODPR(HttpRequest, WeakRefs, () const, int), AS_CALL_THISCALL);
 #ifdef REGISTER_MANUAL_PART_RefCounted
     REGISTER_MANUAL_PART_RefCounted(HttpRequest, "HttpRequest")
 #endif
@@ -246,13 +246,13 @@ void ASRegisterGenerated_Members_H(asIScriptEngine* engine)
     // HashNodeBase* HashIteratorBase::ptr_ | File: ../Container/HashBase.h
     // HashNodeBase* can not be registered
     // void HashIteratorBase::GotoNext() | File: ../Container/HashBase.h
-    engine->RegisterObjectMethod("HashIteratorBase", "void GotoNext()", asMETHODPR(HashIteratorBase, GotoNext, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HashIteratorBase", "void GotoNext()", AS_METHODPR(HashIteratorBase, GotoNext, (), void), AS_CALL_THISCALL);
     // void HashIteratorBase::GotoPrev() | File: ../Container/HashBase.h
-    engine->RegisterObjectMethod("HashIteratorBase", "void GotoPrev()", asMETHODPR(HashIteratorBase, GotoPrev, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HashIteratorBase", "void GotoPrev()", AS_METHODPR(HashIteratorBase, GotoPrev, (), void), AS_CALL_THISCALL);
     // explicit HashIteratorBase::HashIteratorBase(HashNodeBase* ptr) | File: ../Container/HashBase.h
     // Error: type "HashNodeBase*" can not automatically bind
     // bool HashIteratorBase::operator==(const HashIteratorBase& rhs) const | File: ../Container/HashBase.h
-    engine->RegisterObjectMethod("HashIteratorBase", "bool opEquals(const HashIteratorBase&in) const", asMETHODPR(HashIteratorBase, operator==, (const HashIteratorBase&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HashIteratorBase", "bool opEquals(const HashIteratorBase&in) const", AS_METHODPR(HashIteratorBase, operator==, (const HashIteratorBase&) const, bool), AS_CALL_THISCALL);
     // HashIteratorBase& HashIteratorBase::operator=(const HashIteratorBase&) | Possible implicitly-declared
     RegisterImplicitlyDeclaredAssignOperatorIfPossible<HashIteratorBase>(engine, "HashIteratorBase");
 #ifdef REGISTER_MANUAL_PART_HashIteratorBase
@@ -283,19 +283,19 @@ void ASRegisterGenerated_Members_H(asIScriptEngine* engine)
     // Vector3 HeightfieldData::spacing_ | File: ../Physics/CollisionShape.h
     engine->RegisterObjectProperty("HeightfieldData", "Vector3 spacing", offsetof(HeightfieldData, spacing_));
     // void RefCounted::AddRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour("HeightfieldData", asBEHAVE_ADDREF, "void f()", asMETHODPR(HeightfieldData, AddRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour("HeightfieldData", asBEHAVE_ADDREF, "void f()", AS_METHODPR(HeightfieldData, AddRef, (), void), AS_CALL_THISCALL);
     // HeightfieldData::HeightfieldData(Terrain* terrain, unsigned lodLevel) | File: ../Physics/CollisionShape.h
-    engine->RegisterObjectBehaviour("HeightfieldData", asBEHAVE_FACTORY, "HeightfieldData@+ f(Terrain@+, uint)", asFUNCTION(HeightfieldData_HeightfieldData_Terrain_unsigned), asCALL_CDECL);
+    engine->RegisterObjectBehaviour("HeightfieldData", asBEHAVE_FACTORY, "HeightfieldData@+ f(Terrain@+, uint)", AS_FUNCTION(HeightfieldData_HeightfieldData_Terrain_unsigned), AS_CALL_CDECL);
     // RefCount* RefCounted::RefCountPtr() | File: ../Container/RefCounted.h
     // Error: type "RefCount*" can not automatically bind
     // int RefCounted::Refs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod("HeightfieldData", "int Refs() const", asMETHODPR(HeightfieldData, Refs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("HeightfieldData", "int get_refs() const", asMETHODPR(HeightfieldData, Refs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HeightfieldData", "int Refs() const", AS_METHODPR(HeightfieldData, Refs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("HeightfieldData", "int get_refs() const", AS_METHODPR(HeightfieldData, Refs, () const, int), AS_CALL_THISCALL);
     // void RefCounted::ReleaseRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour("HeightfieldData", asBEHAVE_RELEASE, "void f()", asMETHODPR(HeightfieldData, ReleaseRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour("HeightfieldData", asBEHAVE_RELEASE, "void f()", AS_METHODPR(HeightfieldData, ReleaseRef, (), void), AS_CALL_THISCALL);
     // int RefCounted::WeakRefs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod("HeightfieldData", "int WeakRefs() const", asMETHODPR(HeightfieldData, WeakRefs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("HeightfieldData", "int get_weakRefs() const", asMETHODPR(HeightfieldData, WeakRefs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("HeightfieldData", "int WeakRefs() const", AS_METHODPR(HeightfieldData, WeakRefs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("HeightfieldData", "int get_weakRefs() const", AS_METHODPR(HeightfieldData, WeakRefs, () const, int), AS_CALL_THISCALL);
 #ifdef REGISTER_MANUAL_PART_CollisionGeometryData
     REGISTER_MANUAL_PART_CollisionGeometryData(HeightfieldData, "HeightfieldData")
 #endif

Source/Urho3D/AngelScript/Generated_Members_J.cpp

@@ -91,125 +91,125 @@ static void JSONValue_SetVariantValue_Variant_Context(JSONValue* ptr, const Vari
 void ASRegisterGenerated_Members_J(asIScriptEngine* engine)
 {
     // void RefCounted::AddRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour("JSONFile", asBEHAVE_ADDREF, "void f()", asMETHODPR(JSONFile, AddRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour("JSONFile", asBEHAVE_ADDREF, "void f()", AS_METHODPR(JSONFile, AddRef, (), void), AS_CALL_THISCALL);
     // bool JSONFile::BeginLoad(Deserializer& source) override | File: ../Resource/JSONFile.h
-    engine->RegisterObjectMethod("JSONFile", "bool BeginLoad(Deserializer&)", asMETHODPR(JSONFile, BeginLoad, (Deserializer&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "bool BeginLoad(Deserializer&)", AS_METHODPR(JSONFile, BeginLoad, (Deserializer&), bool), AS_CALL_THISCALL);
     // template<typename T> T* Object::Cast() | File: ../Core/Object.h
     // Not registered because template
     // template<typename T> const T* Object::Cast() const | File: ../Core/Object.h
     // Not registered because template
     // virtual bool Resource::EndLoad() | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("JSONFile", "bool EndLoad()", asMETHODPR(JSONFile, EndLoad, (), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "bool EndLoad()", AS_METHODPR(JSONFile, EndLoad, (), bool), AS_CALL_THISCALL);
     // bool JSONFile::FromString(const String& source) | File: ../Resource/JSONFile.h
-    engine->RegisterObjectMethod("JSONFile", "bool FromString(const String&in)", asMETHODPR(JSONFile, FromString, (const String&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "bool FromString(const String&in)", AS_METHODPR(JSONFile, FromString, (const String&), bool), AS_CALL_THISCALL);
     // AsyncLoadState Resource::GetAsyncLoadState() const | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("JSONFile", "AsyncLoadState GetAsyncLoadState() const", asMETHODPR(JSONFile, GetAsyncLoadState, () const, AsyncLoadState), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "AsyncLoadState GetAsyncLoadState() const", AS_METHODPR(JSONFile, GetAsyncLoadState, () const, AsyncLoadState), AS_CALL_THISCALL);
     // bool Object::GetBlockEvents() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "bool GetBlockEvents() const", asMETHODPR(JSONFile, GetBlockEvents, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "bool GetBlockEvents() const", AS_METHODPR(JSONFile, GetBlockEvents, () const, bool), AS_CALL_THISCALL);
     // const String& Object::GetCategory() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "const String& GetCategory() const", asMETHODPR(JSONFile, GetCategory, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONFile", "const String& get_category() const", asMETHODPR(JSONFile, GetCategory, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "const String& GetCategory() const", AS_METHODPR(JSONFile, GetCategory, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "const String& get_category() const", AS_METHODPR(JSONFile, GetCategory, () const, const String&), AS_CALL_THISCALL);
     // Context* Object::GetContext() const | File: ../Core/Object.h
     // Error: type "Context*" can used only as function parameter
     // VariantMap& Object::GetEventDataMap() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "VariantMap& GetEventDataMap() const", asMETHODPR(JSONFile, GetEventDataMap, () const, VariantMap&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "VariantMap& GetEventDataMap() const", AS_METHODPR(JSONFile, GetEventDataMap, () const, VariantMap&), AS_CALL_THISCALL);
     // EventHandler* Object::GetEventHandler() const | File: ../Core/Object.h
     // Error: type "EventHandler*" can not automatically bind
     // Object* Object::GetEventSender() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "Object@+ GetEventSender() const", asMETHODPR(JSONFile, GetEventSender, () const, Object*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "Object@+ GetEventSender() const", AS_METHODPR(JSONFile, GetEventSender, () const, Object*), AS_CALL_THISCALL);
     // const Variant& Object::GetGlobalVar(StringHash key) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "const Variant& GetGlobalVar(StringHash) const", asMETHODPR(JSONFile, GetGlobalVar, (StringHash) const, const Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONFile", "const Variant& get_globalVar(StringHash) const", asMETHODPR(JSONFile, GetGlobalVar, (StringHash) const, const Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "const Variant& GetGlobalVar(StringHash) const", AS_METHODPR(JSONFile, GetGlobalVar, (StringHash) const, const Variant&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "const Variant& get_globalVar(StringHash) const", AS_METHODPR(JSONFile, GetGlobalVar, (StringHash) const, const Variant&), AS_CALL_THISCALL);
     // const VariantMap& Object::GetGlobalVars() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "const VariantMap& GetGlobalVars() const", asMETHODPR(JSONFile, GetGlobalVars, () const, const VariantMap&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONFile", "const VariantMap& get_globalVars() const", asMETHODPR(JSONFile, GetGlobalVars, () const, const VariantMap&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "const VariantMap& GetGlobalVars() const", AS_METHODPR(JSONFile, GetGlobalVars, () const, const VariantMap&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "const VariantMap& get_globalVars() const", AS_METHODPR(JSONFile, GetGlobalVars, () const, const VariantMap&), AS_CALL_THISCALL);
     // unsigned Resource::GetMemoryUse() const | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("JSONFile", "uint GetMemoryUse() const", asMETHODPR(JSONFile, GetMemoryUse, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONFile", "uint get_memoryUse() const", asMETHODPR(JSONFile, GetMemoryUse, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "uint GetMemoryUse() const", AS_METHODPR(JSONFile, GetMemoryUse, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "uint get_memoryUse() const", AS_METHODPR(JSONFile, GetMemoryUse, () const, unsigned), AS_CALL_THISCALL);
     // const String& Resource::GetName() const | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("JSONFile", "const String& GetName() const", asMETHODPR(JSONFile, GetName, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONFile", "const String& get_name() const", asMETHODPR(JSONFile, GetName, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "const String& GetName() const", AS_METHODPR(JSONFile, GetName, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "const String& get_name() const", AS_METHODPR(JSONFile, GetName, () const, const String&), AS_CALL_THISCALL);
     // StringHash Resource::GetNameHash() const | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("JSONFile", "StringHash GetNameHash() const", asMETHODPR(JSONFile, GetNameHash, () const, StringHash), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "StringHash GetNameHash() const", AS_METHODPR(JSONFile, GetNameHash, () const, StringHash), AS_CALL_THISCALL);
     // JSONValue& JSONFile::GetRoot() | File: ../Resource/JSONFile.h
-    engine->RegisterObjectMethod("JSONFile", "JSONValue& GetRoot()", asMETHODPR(JSONFile, GetRoot, (), JSONValue&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONFile", "JSONValue& get_root()", asMETHODPR(JSONFile, GetRoot, (), JSONValue&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "JSONValue& GetRoot()", AS_METHODPR(JSONFile, GetRoot, (), JSONValue&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "JSONValue& get_root()", AS_METHODPR(JSONFile, GetRoot, (), JSONValue&), AS_CALL_THISCALL);
     // const JSONValue& JSONFile::GetRoot() const | File: ../Resource/JSONFile.h
-    engine->RegisterObjectMethod("JSONFile", "const JSONValue& GetRoot() const", asMETHODPR(JSONFile, GetRoot, () const, const JSONValue&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "const JSONValue& GetRoot() const", AS_METHODPR(JSONFile, GetRoot, () const, const JSONValue&), AS_CALL_THISCALL);
     // Object* Object::GetSubsystem(StringHash type) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "Object@+ GetSubsystem(StringHash) const", asMETHODPR(JSONFile, GetSubsystem, (StringHash) const, Object*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "Object@+ GetSubsystem(StringHash) const", AS_METHODPR(JSONFile, GetSubsystem, (StringHash) const, Object*), AS_CALL_THISCALL);
     // template<class T> T* Object::GetSubsystem() const | File: ../Core/Object.h
     // Not registered because template
     // virtual StringHash Object::GetType() const =0 | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "StringHash GetType() const", asMETHODPR(JSONFile, GetType, () const, StringHash), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONFile", "StringHash get_type() const", asMETHODPR(JSONFile, GetType, () const, StringHash), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "StringHash GetType() const", AS_METHODPR(JSONFile, GetType, () const, StringHash), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "StringHash get_type() const", AS_METHODPR(JSONFile, GetType, () const, StringHash), AS_CALL_THISCALL);
     // virtual const TypeInfo* Object::GetTypeInfo() const =0 | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // static const TypeInfo* Object::GetTypeInfoStatic() | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // virtual const String& Object::GetTypeName() const =0 | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "const String& GetTypeName() const", asMETHODPR(JSONFile, GetTypeName, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONFile", "const String& get_typeName() const", asMETHODPR(JSONFile, GetTypeName, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "const String& GetTypeName() const", AS_METHODPR(JSONFile, GetTypeName, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "const String& get_typeName() const", AS_METHODPR(JSONFile, GetTypeName, () const, const String&), AS_CALL_THISCALL);
     // unsigned Resource::GetUseTimer() | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("JSONFile", "uint GetUseTimer()", asMETHODPR(JSONFile, GetUseTimer, (), unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONFile", "uint get_useTimer()", asMETHODPR(JSONFile, GetUseTimer, (), unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "uint GetUseTimer()", AS_METHODPR(JSONFile, GetUseTimer, (), unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "uint get_useTimer()", AS_METHODPR(JSONFile, GetUseTimer, (), unsigned), AS_CALL_THISCALL);
     // bool Object::HasEventHandlers() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "bool HasEventHandlers() const", asMETHODPR(JSONFile, HasEventHandlers, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "bool HasEventHandlers() const", AS_METHODPR(JSONFile, HasEventHandlers, () const, bool), AS_CALL_THISCALL);
     // bool Object::HasSubscribedToEvent(StringHash eventType) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "bool HasSubscribedToEvent(StringHash) const", asMETHODPR(JSONFile, HasSubscribedToEvent, (StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "bool HasSubscribedToEvent(StringHash) const", AS_METHODPR(JSONFile, HasSubscribedToEvent, (StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::HasSubscribedToEvent(Object* sender, StringHash eventType) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "bool HasSubscribedToEvent(Object@+, StringHash) const", asMETHODPR(JSONFile, HasSubscribedToEvent, (Object*, StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "bool HasSubscribedToEvent(Object@+, StringHash) const", AS_METHODPR(JSONFile, HasSubscribedToEvent, (Object*, StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::IsInstanceOf(StringHash type) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "bool IsInstanceOf(StringHash) const", asMETHODPR(JSONFile, IsInstanceOf, (StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "bool IsInstanceOf(StringHash) const", AS_METHODPR(JSONFile, IsInstanceOf, (StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::IsInstanceOf(const TypeInfo* typeInfo) const | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // template<typename T> bool Object::IsInstanceOf() const | File: ../Core/Object.h
     // Not registered because template
     // explicit JSONFile::JSONFile(Context* context) | File: ../Resource/JSONFile.h
-    engine->RegisterObjectBehaviour("JSONFile", asBEHAVE_FACTORY, "JSONFile@+ f()", asFUNCTION(JSONFile_JSONFile_Context), asCALL_CDECL);
+    engine->RegisterObjectBehaviour("JSONFile", asBEHAVE_FACTORY, "JSONFile@+ f()", AS_FUNCTION(JSONFile_JSONFile_Context), AS_CALL_CDECL);
     // bool Resource::Load(Deserializer& source) | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("JSONFile", "bool Load(Deserializer&)", asMETHODPR(JSONFile, Load, (Deserializer&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "bool Load(Deserializer&)", AS_METHODPR(JSONFile, Load, (Deserializer&), bool), AS_CALL_THISCALL);
     // bool Resource::LoadFile(const String& fileName) | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("JSONFile", "bool LoadFile(const String&in)", asMETHODPR(JSONFile, LoadFile, (const String&), bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONFile", "bool Load(const String&in)", asMETHODPR(JSONFile, LoadFile, (const String&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "bool LoadFile(const String&in)", AS_METHODPR(JSONFile, LoadFile, (const String&), bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "bool Load(const String&in)", AS_METHODPR(JSONFile, LoadFile, (const String&), bool), AS_CALL_THISCALL);
     // virtual void Object::OnEvent(Object* sender, StringHash eventType, VariantMap& eventData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "void OnEvent(Object@+, StringHash, VariantMap&)", asMETHODPR(JSONFile, OnEvent, (Object*, StringHash, VariantMap&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "void OnEvent(Object@+, StringHash, VariantMap&)", AS_METHODPR(JSONFile, OnEvent, (Object*, StringHash, VariantMap&), void), AS_CALL_THISCALL);
     // RefCount* RefCounted::RefCountPtr() | File: ../Container/RefCounted.h
     // Error: type "RefCount*" can not automatically bind
     // int RefCounted::Refs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod("JSONFile", "int Refs() const", asMETHODPR(JSONFile, Refs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONFile", "int get_refs() const", asMETHODPR(JSONFile, Refs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "int Refs() const", AS_METHODPR(JSONFile, Refs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "int get_refs() const", AS_METHODPR(JSONFile, Refs, () const, int), AS_CALL_THISCALL);
     // static void JSONFile::RegisterObject(Context* context) | File: ../Resource/JSONFile.h
     // Not registered because have @nobind mark
     // void RefCounted::ReleaseRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour("JSONFile", asBEHAVE_RELEASE, "void f()", asMETHODPR(JSONFile, ReleaseRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour("JSONFile", asBEHAVE_RELEASE, "void f()", AS_METHODPR(JSONFile, ReleaseRef, (), void), AS_CALL_THISCALL);
     // void Resource::ResetUseTimer() | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("JSONFile", "void ResetUseTimer()", asMETHODPR(JSONFile, ResetUseTimer, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "void ResetUseTimer()", AS_METHODPR(JSONFile, ResetUseTimer, (), void), AS_CALL_THISCALL);
     // bool JSONFile::Save(Serializer& dest) const override | File: ../Resource/JSONFile.h
-    engine->RegisterObjectMethod("JSONFile", "bool Save(Serializer&) const", asMETHODPR(JSONFile, Save, (Serializer&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "bool Save(Serializer&) const", AS_METHODPR(JSONFile, Save, (Serializer&) const, bool), AS_CALL_THISCALL);
     // bool JSONFile::Save(Serializer& dest, const String& indendation) const | File: ../Resource/JSONFile.h
-    engine->RegisterObjectMethod("JSONFile", "bool Save(Serializer&, const String&in) const", asMETHODPR(JSONFile, Save, (Serializer&, const String&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "bool Save(Serializer&, const String&in) const", AS_METHODPR(JSONFile, Save, (Serializer&, const String&) const, bool), AS_CALL_THISCALL);
     // virtual bool Resource::SaveFile(const String& fileName) const | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("JSONFile", "bool SaveFile(const String&in) const", asMETHODPR(JSONFile, SaveFile, (const String&) const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONFile", "bool Save(const String&in) const", asMETHODPR(JSONFile, SaveFile, (const String&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "bool SaveFile(const String&in) const", AS_METHODPR(JSONFile, SaveFile, (const String&) const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "bool Save(const String&in) const", AS_METHODPR(JSONFile, SaveFile, (const String&) const, bool), AS_CALL_THISCALL);
     // void Object::SendEvent(StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "void SendEvent(StringHash)", asMETHODPR(JSONFile, SendEvent, (StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "void SendEvent(StringHash)", AS_METHODPR(JSONFile, SendEvent, (StringHash), void), AS_CALL_THISCALL);
     // void Object::SendEvent(StringHash eventType, VariantMap& eventData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "void SendEvent(StringHash, VariantMap&)", asMETHODPR(JSONFile, SendEvent, (StringHash, VariantMap&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "void SendEvent(StringHash, VariantMap&)", AS_METHODPR(JSONFile, SendEvent, (StringHash, VariantMap&), void), AS_CALL_THISCALL);
     // template<typename... Args> void Object::SendEvent(StringHash eventType, Args... args) | File: ../Core/Object.h
     // Not registered because template
     // void Resource::SetAsyncLoadState(AsyncLoadState newState) | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("JSONFile", "void SetAsyncLoadState(AsyncLoadState)", asMETHODPR(JSONFile, SetAsyncLoadState, (AsyncLoadState), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "void SetAsyncLoadState(AsyncLoadState)", AS_METHODPR(JSONFile, SetAsyncLoadState, (AsyncLoadState), void), AS_CALL_THISCALL);
     // void Object::SetBlockEvents(bool block) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "void SetBlockEvents(bool)", asMETHODPR(JSONFile, SetBlockEvents, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "void SetBlockEvents(bool)", AS_METHODPR(JSONFile, SetBlockEvents, (bool), void), AS_CALL_THISCALL);
     // void Object::SetGlobalVar(StringHash key, const Variant& value) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "void SetGlobalVar(StringHash, const Variant&in)", asMETHODPR(JSONFile, SetGlobalVar, (StringHash, const Variant&), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONFile", "void set_globalVar(StringHash, const Variant&in)", asMETHODPR(JSONFile, SetGlobalVar, (StringHash, const Variant&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "void SetGlobalVar(StringHash, const Variant&in)", AS_METHODPR(JSONFile, SetGlobalVar, (StringHash, const Variant&), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "void set_globalVar(StringHash, const Variant&in)", AS_METHODPR(JSONFile, SetGlobalVar, (StringHash, const Variant&), void), AS_CALL_THISCALL);
     // void Resource::SetMemoryUse(unsigned size) | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("JSONFile", "void SetMemoryUse(uint)", asMETHODPR(JSONFile, SetMemoryUse, (unsigned), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "void SetMemoryUse(uint)", AS_METHODPR(JSONFile, SetMemoryUse, (unsigned), void), AS_CALL_THISCALL);
     // void Resource::SetName(const String& name) | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("JSONFile", "void SetName(const String&in)", asMETHODPR(JSONFile, SetName, (const String&), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONFile", "void set_name(const String&in)", asMETHODPR(JSONFile, SetName, (const String&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "void SetName(const String&in)", AS_METHODPR(JSONFile, SetName, (const String&), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "void set_name(const String&in)", AS_METHODPR(JSONFile, SetName, (const String&), void), AS_CALL_THISCALL);
     // void Object::SubscribeToEvent(StringHash eventType, EventHandler* handler) | File: ../Core/Object.h
     // Error: type "EventHandler*" can not automatically bind
     // void Object::SubscribeToEvent(Object* sender, StringHash eventType, EventHandler* handler) | File: ../Core/Object.h
@@ -219,20 +219,20 @@ void ASRegisterGenerated_Members_J(asIScriptEngine* engine)
     // void Object::SubscribeToEvent(Object* sender, StringHash eventType, const std::function<void(StringHash, VariantMap&)>& function, void* userData=nullptr) | File: ../Core/Object.h
     // Error: type "const std::function<void(StringHash, VariantMap&)>&" can not automatically bind
     // String JSONFile::ToString(const String& indendation="\t") const | File: ../Resource/JSONFile.h
-    engine->RegisterObjectMethod("JSONFile", "String ToString(const String&in = \"\t\") const", asMETHODPR(JSONFile, ToString, (const String&) const, String), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "String ToString(const String&in = \"\t\") const", AS_METHODPR(JSONFile, ToString, (const String&) const, String), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromAllEvents() | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "void UnsubscribeFromAllEvents()", asMETHODPR(JSONFile, UnsubscribeFromAllEvents, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "void UnsubscribeFromAllEvents()", AS_METHODPR(JSONFile, UnsubscribeFromAllEvents, (), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromAllEventsExcept(const PODVector<StringHash>& exceptions, bool onlyUserData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "void UnsubscribeFromAllEventsExcept(Array<StringHash>@+, bool)", asFUNCTION(JSONFile_UnsubscribeFromAllEventsExcept_PODVectorStringHash_bool), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod("JSONFile", "void UnsubscribeFromAllEventsExcept(Array<StringHash>@+, bool)", AS_FUNCTION_OBJFIRST(JSONFile_UnsubscribeFromAllEventsExcept_PODVectorStringHash_bool), AS_CALL_CDECL_OBJFIRST);
     // void Object::UnsubscribeFromEvent(StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "void UnsubscribeFromEvent(StringHash)", asMETHODPR(JSONFile, UnsubscribeFromEvent, (StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "void UnsubscribeFromEvent(StringHash)", AS_METHODPR(JSONFile, UnsubscribeFromEvent, (StringHash), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromEvent(Object* sender, StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "void UnsubscribeFromEvent(Object@+, StringHash)", asMETHODPR(JSONFile, UnsubscribeFromEvent, (Object*, StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "void UnsubscribeFromEvent(Object@+, StringHash)", AS_METHODPR(JSONFile, UnsubscribeFromEvent, (Object*, StringHash), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromEvents(Object* sender) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("JSONFile", "void UnsubscribeFromEvents(Object@+)", asMETHODPR(JSONFile, UnsubscribeFromEvents, (Object*), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "void UnsubscribeFromEvents(Object@+)", AS_METHODPR(JSONFile, UnsubscribeFromEvents, (Object*), void), AS_CALL_THISCALL);
     // int RefCounted::WeakRefs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod("JSONFile", "int WeakRefs() const", asMETHODPR(JSONFile, WeakRefs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONFile", "int get_weakRefs() const", asMETHODPR(JSONFile, WeakRefs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "int WeakRefs() const", AS_METHODPR(JSONFile, WeakRefs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONFile", "int get_weakRefs() const", AS_METHODPR(JSONFile, WeakRefs, () const, int), AS_CALL_THISCALL);
 #ifdef REGISTER_MANUAL_PART_Resource
     REGISTER_MANUAL_PART_Resource(JSONFile, "JSONFile")
 #endif
@@ -272,109 +272,109 @@ void ASRegisterGenerated_Members_J(asIScriptEngine* engine)
     // ConstJSONObjectIterator JSONValue::Begin() const | File: ../Resource/JSONValue.h
     // Error: type "ConstJSONObjectIterator" can not automatically bind
     // void JSONValue::Clear() | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "void Clear()", asMETHODPR(JSONValue, Clear, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "void Clear()", AS_METHODPR(JSONValue, Clear, (), void), AS_CALL_THISCALL);
     // bool JSONValue::Contains(const String& key) const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "bool Contains(const String&in) const", asMETHODPR(JSONValue, Contains, (const String&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "bool Contains(const String&in) const", AS_METHODPR(JSONValue, Contains, (const String&) const, bool), AS_CALL_THISCALL);
     // JSONObjectIterator JSONValue::End() | File: ../Resource/JSONValue.h
     // Error: type "JSONObjectIterator" can not automatically bind
     // ConstJSONObjectIterator JSONValue::End() const | File: ../Resource/JSONValue.h
     // Error: type "ConstJSONObjectIterator" can not automatically bind
     // void JSONValue::Erase(unsigned pos, unsigned length=1) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "void Erase(uint, uint = 1)", asMETHODPR(JSONValue, Erase, (unsigned, unsigned), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "void Erase(uint, uint = 1)", AS_METHODPR(JSONValue, Erase, (unsigned, unsigned), void), AS_CALL_THISCALL);
     // bool JSONValue::Erase(const String& key) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "bool Erase(const String&in)", asMETHODPR(JSONValue, Erase, (const String&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "bool Erase(const String&in)", AS_METHODPR(JSONValue, Erase, (const String&), bool), AS_CALL_THISCALL);
     // const JSONValue& JSONValue::Get(const String& key) const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "const JSONValue& Get(const String&in) const", asMETHODPR(JSONValue, Get, (const String&) const, const JSONValue&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "const JSONValue& Get(const String&in) const", AS_METHODPR(JSONValue, Get, (const String&) const, const JSONValue&), AS_CALL_THISCALL);
     // const JSONArray& JSONValue::GetArray() const | File: ../Resource/JSONValue.h
     // Error: type "const JSONArray&" can not automatically bind
     // bool JSONValue::GetBool(bool defaultValue=false) const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "bool GetBool(bool = false) const", asMETHODPR(JSONValue, GetBool, (bool) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "bool GetBool(bool = false) const", AS_METHODPR(JSONValue, GetBool, (bool) const, bool), AS_CALL_THISCALL);
     // const char* JSONValue::GetCString(const char* defaultValue="") const | File: ../Resource/JSONValue.h
     // Error: type "const char*" can not automatically bind
     // double JSONValue::GetDouble(double defaultValue=0.0) const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "double GetDouble(double = 0.0) const", asMETHODPR(JSONValue, GetDouble, (double) const, double), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "double GetDouble(double = 0.0) const", AS_METHODPR(JSONValue, GetDouble, (double) const, double), AS_CALL_THISCALL);
     // float JSONValue::GetFloat(float defaultValue=0.0f) const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "float GetFloat(float = 0.0f) const", asMETHODPR(JSONValue, GetFloat, (float) const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "float GetFloat(float = 0.0f) const", AS_METHODPR(JSONValue, GetFloat, (float) const, float), AS_CALL_THISCALL);
     // int JSONValue::GetInt(int defaultValue=0) const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "int GetInt(int = 0) const", asMETHODPR(JSONValue, GetInt, (int) const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "int GetInt(int = 0) const", AS_METHODPR(JSONValue, GetInt, (int) const, int), AS_CALL_THISCALL);
     // JSONNumberType JSONValue::GetNumberType() const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "JSONNumberType GetNumberType() const", asMETHODPR(JSONValue, GetNumberType, () const, JSONNumberType), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONValue", "JSONNumberType get_numberType() const", asMETHODPR(JSONValue, GetNumberType, () const, JSONNumberType), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "JSONNumberType GetNumberType() const", AS_METHODPR(JSONValue, GetNumberType, () const, JSONNumberType), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "JSONNumberType get_numberType() const", AS_METHODPR(JSONValue, GetNumberType, () const, JSONNumberType), AS_CALL_THISCALL);
     // static JSONNumberType JSONValue::GetNumberTypeFromName(const String& typeName) | File: ../Resource/JSONValue.h
     engine->SetDefaultNamespace("JSONValue");
-    engine->RegisterGlobalFunction("JSONNumberType GetNumberTypeFromName(const String&in)", asFUNCTIONPR(JSONValue::GetNumberTypeFromName, (const String&), JSONNumberType), asCALL_CDECL);
+    engine->RegisterGlobalFunction("JSONNumberType GetNumberTypeFromName(const String&in)", AS_FUNCTIONPR(JSONValue::GetNumberTypeFromName, (const String&), JSONNumberType), AS_CALL_CDECL);
     engine->SetDefaultNamespace("");
     // static JSONNumberType JSONValue::GetNumberTypeFromName(const char* typeName) | File: ../Resource/JSONValue.h
     // Error: type "const char*" can not automatically bind
     // String JSONValue::GetNumberTypeName() const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "String GetNumberTypeName() const", asMETHODPR(JSONValue, GetNumberTypeName, () const, String), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONValue", "String get_numberTypeName() const", asMETHODPR(JSONValue, GetNumberTypeName, () const, String), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "String GetNumberTypeName() const", AS_METHODPR(JSONValue, GetNumberTypeName, () const, String), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "String get_numberTypeName() const", AS_METHODPR(JSONValue, GetNumberTypeName, () const, String), AS_CALL_THISCALL);
     // static String JSONValue::GetNumberTypeName(JSONNumberType type) | File: ../Resource/JSONValue.h
     engine->SetDefaultNamespace("JSONValue");
-    engine->RegisterGlobalFunction("String GetNumberTypeName(JSONNumberType)", asFUNCTIONPR(JSONValue::GetNumberTypeName, (JSONNumberType), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String GetNumberTypeName(JSONNumberType)", AS_FUNCTIONPR(JSONValue::GetNumberTypeName, (JSONNumberType), String), AS_CALL_CDECL);
     engine->SetDefaultNamespace("");
     // const JSONObject& JSONValue::GetObject() const | File: ../Resource/JSONValue.h
     // Error: type "const JSONObject&" can not automatically bind
     // const String& JSONValue::GetString(const String& defaultValue=String::EMPTY) const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "const String& GetString(const String&in = String::EMPTY) const", asMETHODPR(JSONValue, GetString, (const String&) const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "const String& GetString(const String&in = String::EMPTY) const", AS_METHODPR(JSONValue, GetString, (const String&) const, const String&), AS_CALL_THISCALL);
     // unsigned JSONValue::GetUInt(unsigned defaultValue=0) const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "uint GetUInt(uint = 0) const", asMETHODPR(JSONValue, GetUInt, (unsigned) const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "uint GetUInt(uint = 0) const", AS_METHODPR(JSONValue, GetUInt, (unsigned) const, unsigned), AS_CALL_THISCALL);
     // JSONValueType JSONValue::GetValueType() const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "JSONValueType GetValueType() const", asMETHODPR(JSONValue, GetValueType, () const, JSONValueType), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONValue", "JSONValueType get_valueType() const", asMETHODPR(JSONValue, GetValueType, () const, JSONValueType), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "JSONValueType GetValueType() const", AS_METHODPR(JSONValue, GetValueType, () const, JSONValueType), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "JSONValueType get_valueType() const", AS_METHODPR(JSONValue, GetValueType, () const, JSONValueType), AS_CALL_THISCALL);
     // static JSONValueType JSONValue::GetValueTypeFromName(const String& typeName) | File: ../Resource/JSONValue.h
     engine->SetDefaultNamespace("JSONValue");
-    engine->RegisterGlobalFunction("JSONValueType GetValueTypeFromName(const String&in)", asFUNCTIONPR(JSONValue::GetValueTypeFromName, (const String&), JSONValueType), asCALL_CDECL);
+    engine->RegisterGlobalFunction("JSONValueType GetValueTypeFromName(const String&in)", AS_FUNCTIONPR(JSONValue::GetValueTypeFromName, (const String&), JSONValueType), AS_CALL_CDECL);
     engine->SetDefaultNamespace("");
     // static JSONValueType JSONValue::GetValueTypeFromName(const char* typeName) | File: ../Resource/JSONValue.h
     // Error: type "const char*" can not automatically bind
     // String JSONValue::GetValueTypeName() const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "String GetValueTypeName() const", asMETHODPR(JSONValue, GetValueTypeName, () const, String), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONValue", "String get_valueTypeName() const", asMETHODPR(JSONValue, GetValueTypeName, () const, String), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "String GetValueTypeName() const", AS_METHODPR(JSONValue, GetValueTypeName, () const, String), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "String get_valueTypeName() const", AS_METHODPR(JSONValue, GetValueTypeName, () const, String), AS_CALL_THISCALL);
     // static String JSONValue::GetValueTypeName(JSONValueType type) | File: ../Resource/JSONValue.h
     engine->SetDefaultNamespace("JSONValue");
-    engine->RegisterGlobalFunction("String GetValueTypeName(JSONValueType)", asFUNCTIONPR(JSONValue::GetValueTypeName, (JSONValueType), String), asCALL_CDECL);
+    engine->RegisterGlobalFunction("String GetValueTypeName(JSONValueType)", AS_FUNCTIONPR(JSONValue::GetValueTypeName, (JSONValueType), String), AS_CALL_CDECL);
     engine->SetDefaultNamespace("");
     // Variant JSONValue::GetVariant() const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "Variant GetVariant() const", asMETHODPR(JSONValue, GetVariant, () const, Variant), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "Variant GetVariant() const", AS_METHODPR(JSONValue, GetVariant, () const, Variant), AS_CALL_THISCALL);
     // VariantMap JSONValue::GetVariantMap() const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "VariantMap GetVariantMap() const", asMETHODPR(JSONValue, GetVariantMap, () const, VariantMap), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "VariantMap GetVariantMap() const", AS_METHODPR(JSONValue, GetVariantMap, () const, VariantMap), AS_CALL_THISCALL);
     // Variant JSONValue::GetVariantValue(VariantType type) const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "Variant GetVariantValue(VariantType) const", asMETHODPR(JSONValue, GetVariantValue, (VariantType) const, Variant), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "Variant GetVariantValue(VariantType) const", AS_METHODPR(JSONValue, GetVariantValue, (VariantType) const, Variant), AS_CALL_THISCALL);
     // VariantVector JSONValue::GetVariantVector() const | File: ../Resource/JSONValue.h
     // Error: type "VariantVector" can not automatically bind
     // void JSONValue::Insert(unsigned pos, const JSONValue& value) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "void Insert(uint, const JSONValue&in)", asMETHODPR(JSONValue, Insert, (unsigned, const JSONValue&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "void Insert(uint, const JSONValue&in)", AS_METHODPR(JSONValue, Insert, (unsigned, const JSONValue&), void), AS_CALL_THISCALL);
     // bool JSONValue::IsArray() const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "bool IsArray() const", asMETHODPR(JSONValue, IsArray, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONValue", "bool get_isArray() const", asMETHODPR(JSONValue, IsArray, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "bool IsArray() const", AS_METHODPR(JSONValue, IsArray, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "bool get_isArray() const", AS_METHODPR(JSONValue, IsArray, () const, bool), AS_CALL_THISCALL);
     // bool JSONValue::IsBool() const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "bool IsBool() const", asMETHODPR(JSONValue, IsBool, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONValue", "bool get_isBool() const", asMETHODPR(JSONValue, IsBool, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "bool IsBool() const", AS_METHODPR(JSONValue, IsBool, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "bool get_isBool() const", AS_METHODPR(JSONValue, IsBool, () const, bool), AS_CALL_THISCALL);
     // bool JSONValue::IsNull() const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "bool IsNull() const", asMETHODPR(JSONValue, IsNull, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONValue", "bool get_isNull() const", asMETHODPR(JSONValue, IsNull, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "bool IsNull() const", AS_METHODPR(JSONValue, IsNull, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "bool get_isNull() const", AS_METHODPR(JSONValue, IsNull, () const, bool), AS_CALL_THISCALL);
     // bool JSONValue::IsNumber() const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "bool IsNumber() const", asMETHODPR(JSONValue, IsNumber, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONValue", "bool get_isNumber() const", asMETHODPR(JSONValue, IsNumber, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "bool IsNumber() const", AS_METHODPR(JSONValue, IsNumber, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "bool get_isNumber() const", AS_METHODPR(JSONValue, IsNumber, () const, bool), AS_CALL_THISCALL);
     // bool JSONValue::IsObject() const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "bool IsObject() const", asMETHODPR(JSONValue, IsObject, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONValue", "bool get_isObject() const", asMETHODPR(JSONValue, IsObject, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "bool IsObject() const", AS_METHODPR(JSONValue, IsObject, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "bool get_isObject() const", AS_METHODPR(JSONValue, IsObject, () const, bool), AS_CALL_THISCALL);
     // bool JSONValue::IsString() const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "bool IsString() const", asMETHODPR(JSONValue, IsString, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONValue", "bool get_isString() const", asMETHODPR(JSONValue, IsString, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "bool IsString() const", AS_METHODPR(JSONValue, IsString, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "bool get_isString() const", AS_METHODPR(JSONValue, IsString, () const, bool), AS_CALL_THISCALL);
     // JSONValue::JSONValue(bool value) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectBehaviour("JSONValue", asBEHAVE_CONSTRUCT, "void f(bool)", asFUNCTION(JSONValue_JSONValue_bool), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("JSONValue", asBEHAVE_CONSTRUCT, "void f(bool)", AS_FUNCTION_OBJFIRST(JSONValue_JSONValue_bool), AS_CALL_CDECL_OBJFIRST);
     // JSONValue::JSONValue(int value) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectBehaviour("JSONValue", asBEHAVE_CONSTRUCT, "void f(int)", asFUNCTION(JSONValue_JSONValue_int), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("JSONValue", asBEHAVE_CONSTRUCT, "void f(int)", AS_FUNCTION_OBJFIRST(JSONValue_JSONValue_int), AS_CALL_CDECL_OBJFIRST);
     // JSONValue::JSONValue(unsigned value) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectBehaviour("JSONValue", asBEHAVE_CONSTRUCT, "void f(uint)", asFUNCTION(JSONValue_JSONValue_unsigned), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("JSONValue", asBEHAVE_CONSTRUCT, "void f(uint)", AS_FUNCTION_OBJFIRST(JSONValue_JSONValue_unsigned), AS_CALL_CDECL_OBJFIRST);
     // JSONValue::JSONValue(float value) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectBehaviour("JSONValue", asBEHAVE_CONSTRUCT, "void f(float)", asFUNCTION(JSONValue_JSONValue_float), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("JSONValue", asBEHAVE_CONSTRUCT, "void f(float)", AS_FUNCTION_OBJFIRST(JSONValue_JSONValue_float), AS_CALL_CDECL_OBJFIRST);
     // JSONValue::JSONValue(double value) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectBehaviour("JSONValue", asBEHAVE_CONSTRUCT, "void f(double)", asFUNCTION(JSONValue_JSONValue_double), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("JSONValue", asBEHAVE_CONSTRUCT, "void f(double)", AS_FUNCTION_OBJFIRST(JSONValue_JSONValue_double), AS_CALL_CDECL_OBJFIRST);
     // JSONValue::JSONValue(const String& value) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectBehaviour("JSONValue", asBEHAVE_CONSTRUCT, "void f(const String&in)", asFUNCTION(JSONValue_JSONValue_String), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("JSONValue", asBEHAVE_CONSTRUCT, "void f(const String&in)", AS_FUNCTION_OBJFIRST(JSONValue_JSONValue_String), AS_CALL_CDECL_OBJFIRST);
     // JSONValue::JSONValue(const char* value) | File: ../Resource/JSONValue.h
     // Error: type "const char*" can not automatically bind
     // JSONValue::JSONValue(const JSONArray& value) | File: ../Resource/JSONValue.h
@@ -382,19 +382,19 @@ void ASRegisterGenerated_Members_J(asIScriptEngine* engine)
     // JSONValue::JSONValue(const JSONObject& value) | File: ../Resource/JSONValue.h
     // Error: type "const JSONObject&" can not automatically bind
     // JSONValue::JSONValue(const JSONValue& value) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectBehaviour("JSONValue", asBEHAVE_CONSTRUCT, "void f(const JSONValue&in)", asFUNCTION(JSONValue_JSONValue_JSONValue), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("JSONValue", asBEHAVE_CONSTRUCT, "void f(const JSONValue&in)", AS_FUNCTION_OBJFIRST(JSONValue_JSONValue_JSONValue), AS_CALL_CDECL_OBJFIRST);
     // JSONValue& JSONValue::operator=(bool rhs) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "JSONValue& opAssign(bool)", asMETHODPR(JSONValue, operator=, (bool), JSONValue&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "JSONValue& opAssign(bool)", AS_METHODPR(JSONValue, operator=, (bool), JSONValue&), AS_CALL_THISCALL);
     // JSONValue& JSONValue::operator=(int rhs) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "JSONValue& opAssign(int)", asMETHODPR(JSONValue, operator=, (int), JSONValue&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "JSONValue& opAssign(int)", AS_METHODPR(JSONValue, operator=, (int), JSONValue&), AS_CALL_THISCALL);
     // JSONValue& JSONValue::operator=(unsigned rhs) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "JSONValue& opAssign(uint)", asMETHODPR(JSONValue, operator=, (unsigned), JSONValue&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "JSONValue& opAssign(uint)", AS_METHODPR(JSONValue, operator=, (unsigned), JSONValue&), AS_CALL_THISCALL);
     // JSONValue& JSONValue::operator=(float rhs) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "JSONValue& opAssign(float)", asMETHODPR(JSONValue, operator=, (float), JSONValue&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "JSONValue& opAssign(float)", AS_METHODPR(JSONValue, operator=, (float), JSONValue&), AS_CALL_THISCALL);
     // JSONValue& JSONValue::operator=(double rhs) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "JSONValue& opAssign(double)", asMETHODPR(JSONValue, operator=, (double), JSONValue&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "JSONValue& opAssign(double)", AS_METHODPR(JSONValue, operator=, (double), JSONValue&), AS_CALL_THISCALL);
     // JSONValue& JSONValue::operator=(const String& rhs) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "JSONValue& opAssign(const String&in)", asMETHODPR(JSONValue, operator=, (const String&), JSONValue&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "JSONValue& opAssign(const String&in)", AS_METHODPR(JSONValue, operator=, (const String&), JSONValue&), AS_CALL_THISCALL);
     // JSONValue& JSONValue::operator=(const char* rhs) | File: ../Resource/JSONValue.h
     // Error: type "const char*" can not automatically bind
     // JSONValue& JSONValue::operator=(const JSONArray& rhs) | File: ../Resource/JSONValue.h
@@ -402,36 +402,36 @@ void ASRegisterGenerated_Members_J(asIScriptEngine* engine)
     // JSONValue& JSONValue::operator=(const JSONObject& rhs) | File: ../Resource/JSONValue.h
     // Error: type "const JSONObject&" can not automatically bind
     // JSONValue& JSONValue::operator=(const JSONValue& rhs) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "JSONValue& opAssign(const JSONValue&in)", asMETHODPR(JSONValue, operator=, (const JSONValue&), JSONValue&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "JSONValue& opAssign(const JSONValue&in)", AS_METHODPR(JSONValue, operator=, (const JSONValue&), JSONValue&), AS_CALL_THISCALL);
     // JSONValue& JSONValue::operator[](unsigned index) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "JSONValue& opIndex(uint)", asMETHODPR(JSONValue, operator[], (unsigned), JSONValue&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "JSONValue& opIndex(uint)", AS_METHODPR(JSONValue, operator[], (unsigned), JSONValue&), AS_CALL_THISCALL);
     // const JSONValue& JSONValue::operator[](unsigned index) const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "const JSONValue& opIndex(uint) const", asMETHODPR(JSONValue, operator[], (unsigned) const, const JSONValue&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "const JSONValue& opIndex(uint) const", AS_METHODPR(JSONValue, operator[], (unsigned) const, const JSONValue&), AS_CALL_THISCALL);
     // JSONValue& JSONValue::operator[](const String& key) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "JSONValue& opIndex(const String&in)", asMETHODPR(JSONValue, operator[], (const String&), JSONValue&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "JSONValue& opIndex(const String&in)", AS_METHODPR(JSONValue, operator[], (const String&), JSONValue&), AS_CALL_THISCALL);
     // const JSONValue& JSONValue::operator[](const String& key) const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "const JSONValue& opIndex(const String&in) const", asMETHODPR(JSONValue, operator[], (const String&) const, const JSONValue&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "const JSONValue& opIndex(const String&in) const", AS_METHODPR(JSONValue, operator[], (const String&) const, const JSONValue&), AS_CALL_THISCALL);
     // void JSONValue::Pop() | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "void Pop()", asMETHODPR(JSONValue, Pop, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "void Pop()", AS_METHODPR(JSONValue, Pop, (), void), AS_CALL_THISCALL);
     // void JSONValue::Push(const JSONValue& value) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "void Push(const JSONValue&in)", asMETHODPR(JSONValue, Push, (const JSONValue&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "void Push(const JSONValue&in)", AS_METHODPR(JSONValue, Push, (const JSONValue&), void), AS_CALL_THISCALL);
     // void JSONValue::Resize(unsigned newSize) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "void Resize(uint)", asMETHODPR(JSONValue, Resize, (unsigned), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "void Resize(uint)", AS_METHODPR(JSONValue, Resize, (unsigned), void), AS_CALL_THISCALL);
     // void JSONValue::Set(const String& key, const JSONValue& value) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "void Set(const String&in, const JSONValue&in)", asMETHODPR(JSONValue, Set, (const String&, const JSONValue&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "void Set(const String&in, const JSONValue&in)", AS_METHODPR(JSONValue, Set, (const String&, const JSONValue&), void), AS_CALL_THISCALL);
     // void JSONValue::SetType(JSONValueType valueType, JSONNumberType numberType=JSONNT_NAN) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "void SetType(JSONValueType, JSONNumberType = JSONNT_NAN)", asMETHODPR(JSONValue, SetType, (JSONValueType, JSONNumberType), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "void SetType(JSONValueType, JSONNumberType = JSONNT_NAN)", AS_METHODPR(JSONValue, SetType, (JSONValueType, JSONNumberType), void), AS_CALL_THISCALL);
     // void JSONValue::SetVariant(const Variant& variant, Context* context=nullptr) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "void SetVariant(const Variant&in)", asFUNCTION(JSONValue_SetVariant_Variant_Context), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod("JSONValue", "void SetVariant(const Variant&in)", AS_FUNCTION_OBJFIRST(JSONValue_SetVariant_Variant_Context), AS_CALL_CDECL_OBJFIRST);
     // void JSONValue::SetVariantMap(const VariantMap& variantMap, Context* context=nullptr) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "void SetVariantMap(const VariantMap&in)", asFUNCTION(JSONValue_SetVariantMap_VariantMap_Context), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod("JSONValue", "void SetVariantMap(const VariantMap&in)", AS_FUNCTION_OBJFIRST(JSONValue_SetVariantMap_VariantMap_Context), AS_CALL_CDECL_OBJFIRST);
     // void JSONValue::SetVariantValue(const Variant& variant, Context* context=nullptr) | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "void SetVariantValue(const Variant&in)", asFUNCTION(JSONValue_SetVariantValue_Variant_Context), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod("JSONValue", "void SetVariantValue(const Variant&in)", AS_FUNCTION_OBJFIRST(JSONValue_SetVariantValue_Variant_Context), AS_CALL_CDECL_OBJFIRST);
     // void JSONValue::SetVariantVector(const VariantVector& variantVector, Context* context=nullptr) | File: ../Resource/JSONValue.h
     // Error: type "const VariantVector&" can not automatically bind
     // unsigned JSONValue::Size() const | File: ../Resource/JSONValue.h
-    engine->RegisterObjectMethod("JSONValue", "uint Size() const", asMETHODPR(JSONValue, Size, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JSONValue", "uint get_size() const", asMETHODPR(JSONValue, Size, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "uint Size() const", AS_METHODPR(JSONValue, Size, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JSONValue", "uint get_size() const", AS_METHODPR(JSONValue, Size, () const, unsigned), AS_CALL_THISCALL);
 #ifdef REGISTER_MANUAL_PART_JSONValue
     REGISTER_MANUAL_PART_JSONValue(JSONValue, "JSONValue")
 #endif
@@ -455,37 +455,37 @@ void ASRegisterGenerated_Members_J(asIScriptEngine* engine)
     // UIElement* JoystickState::screenJoystick_ | File: ../Input/Input.h
     // UIElement* can not be registered
     // float JoystickState::GetAxisPosition(unsigned index) const | File: ../Input/Input.h
-    engine->RegisterObjectMethod("JoystickState", "float GetAxisPosition(uint) const", asMETHODPR(JoystickState, GetAxisPosition, (unsigned) const, float), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JoystickState", "float get_axisPosition(uint) const", asMETHODPR(JoystickState, GetAxisPosition, (unsigned) const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JoystickState", "float GetAxisPosition(uint) const", AS_METHODPR(JoystickState, GetAxisPosition, (unsigned) const, float), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JoystickState", "float get_axisPosition(uint) const", AS_METHODPR(JoystickState, GetAxisPosition, (unsigned) const, float), AS_CALL_THISCALL);
     // bool JoystickState::GetButtonDown(unsigned index) const | File: ../Input/Input.h
-    engine->RegisterObjectMethod("JoystickState", "bool GetButtonDown(uint) const", asMETHODPR(JoystickState, GetButtonDown, (unsigned) const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JoystickState", "bool get_buttonDown(uint) const", asMETHODPR(JoystickState, GetButtonDown, (unsigned) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JoystickState", "bool GetButtonDown(uint) const", AS_METHODPR(JoystickState, GetButtonDown, (unsigned) const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JoystickState", "bool get_buttonDown(uint) const", AS_METHODPR(JoystickState, GetButtonDown, (unsigned) const, bool), AS_CALL_THISCALL);
     // bool JoystickState::GetButtonPress(unsigned index) const | File: ../Input/Input.h
-    engine->RegisterObjectMethod("JoystickState", "bool GetButtonPress(uint) const", asMETHODPR(JoystickState, GetButtonPress, (unsigned) const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JoystickState", "bool get_buttonPress(uint) const", asMETHODPR(JoystickState, GetButtonPress, (unsigned) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JoystickState", "bool GetButtonPress(uint) const", AS_METHODPR(JoystickState, GetButtonPress, (unsigned) const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JoystickState", "bool get_buttonPress(uint) const", AS_METHODPR(JoystickState, GetButtonPress, (unsigned) const, bool), AS_CALL_THISCALL);
     // int JoystickState::GetHatPosition(unsigned index) const | File: ../Input/Input.h
-    engine->RegisterObjectMethod("JoystickState", "int GetHatPosition(uint) const", asMETHODPR(JoystickState, GetHatPosition, (unsigned) const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JoystickState", "int get_hatPosition(uint) const", asMETHODPR(JoystickState, GetHatPosition, (unsigned) const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JoystickState", "int GetHatPosition(uint) const", AS_METHODPR(JoystickState, GetHatPosition, (unsigned) const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JoystickState", "int get_hatPosition(uint) const", AS_METHODPR(JoystickState, GetHatPosition, (unsigned) const, int), AS_CALL_THISCALL);
     // unsigned JoystickState::GetNumAxes() const | File: ../Input/Input.h
-    engine->RegisterObjectMethod("JoystickState", "uint GetNumAxes() const", asMETHODPR(JoystickState, GetNumAxes, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JoystickState", "uint get_numAxes() const", asMETHODPR(JoystickState, GetNumAxes, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JoystickState", "uint GetNumAxes() const", AS_METHODPR(JoystickState, GetNumAxes, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JoystickState", "uint get_numAxes() const", AS_METHODPR(JoystickState, GetNumAxes, () const, unsigned), AS_CALL_THISCALL);
     // unsigned JoystickState::GetNumButtons() const | File: ../Input/Input.h
-    engine->RegisterObjectMethod("JoystickState", "uint GetNumButtons() const", asMETHODPR(JoystickState, GetNumButtons, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JoystickState", "uint get_numButtons() const", asMETHODPR(JoystickState, GetNumButtons, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JoystickState", "uint GetNumButtons() const", AS_METHODPR(JoystickState, GetNumButtons, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JoystickState", "uint get_numButtons() const", AS_METHODPR(JoystickState, GetNumButtons, () const, unsigned), AS_CALL_THISCALL);
     // unsigned JoystickState::GetNumHats() const | File: ../Input/Input.h
-    engine->RegisterObjectMethod("JoystickState", "uint GetNumHats() const", asMETHODPR(JoystickState, GetNumHats, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JoystickState", "uint get_numHats() const", asMETHODPR(JoystickState, GetNumHats, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JoystickState", "uint GetNumHats() const", AS_METHODPR(JoystickState, GetNumHats, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JoystickState", "uint get_numHats() const", AS_METHODPR(JoystickState, GetNumHats, () const, unsigned), AS_CALL_THISCALL);
     // void JoystickState::Initialize(unsigned numButtons, unsigned numAxes, unsigned numHats) | File: ../Input/Input.h
-    engine->RegisterObjectMethod("JoystickState", "void Initialize(uint, uint, uint)", asMETHODPR(JoystickState, Initialize, (unsigned, unsigned, unsigned), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JoystickState", "void Initialize(uint, uint, uint)", AS_METHODPR(JoystickState, Initialize, (unsigned, unsigned, unsigned), void), AS_CALL_THISCALL);
     // bool JoystickState::IsController() const | File: ../Input/Input.h
-    engine->RegisterObjectMethod("JoystickState", "bool IsController() const", asMETHODPR(JoystickState, IsController, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("JoystickState", "bool get_controller() const", asMETHODPR(JoystickState, IsController, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JoystickState", "bool IsController() const", AS_METHODPR(JoystickState, IsController, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("JoystickState", "bool get_controller() const", AS_METHODPR(JoystickState, IsController, () const, bool), AS_CALL_THISCALL);
     // void JoystickState::Reset() | File: ../Input/Input.h
-    engine->RegisterObjectMethod("JoystickState", "void Reset()", asMETHODPR(JoystickState, Reset, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("JoystickState", "void Reset()", AS_METHODPR(JoystickState, Reset, (), void), AS_CALL_THISCALL);
     // JoystickState& JoystickState::operator=(const JoystickState&) | Possible implicitly-declared
     RegisterImplicitlyDeclaredAssignOperatorIfPossible<JoystickState>(engine, "JoystickState");
-    engine->RegisterObjectBehaviour("JoystickState", asBEHAVE_ADDREF, "void f()", asFUNCTION(FakeAddRef), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectBehaviour("JoystickState", asBEHAVE_RELEASE, "void f()", asFUNCTION(FakeReleaseRef), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectBehaviour("JoystickState", asBEHAVE_ADDREF, "void f()", AS_FUNCTION_OBJLAST(FakeAddRef), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectBehaviour("JoystickState", asBEHAVE_RELEASE, "void f()", AS_FUNCTION_OBJLAST(FakeReleaseRef), AS_CALL_CDECL_OBJLAST);
 #ifdef REGISTER_MANUAL_PART_JoystickState
     REGISTER_MANUAL_PART_JoystickState(JoystickState, "JoystickState")
 #endif

Source/Urho3D/AngelScript/Generated_Members_Q.cpp

@@ -81,104 +81,104 @@ void ASRegisterGenerated_Members_Q(asIScriptEngine* engine)
     // float Quaternion::z_ | File: ../Math/Quaternion.h
     engine->RegisterObjectProperty("Quaternion", "float z", offsetof(Quaternion, z_));
     // float Quaternion::Angle() const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "float Angle() const", asMETHODPR(Quaternion, Angle, () const, float), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Quaternion", "float get_angle() const", asMETHODPR(Quaternion, Angle, () const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "float Angle() const", AS_METHODPR(Quaternion, Angle, () const, float), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "float get_angle() const", AS_METHODPR(Quaternion, Angle, () const, float), AS_CALL_THISCALL);
     // Vector3 Quaternion::Axis() const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "Vector3 Axis() const", asMETHODPR(Quaternion, Axis, () const, Vector3), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Quaternion", "Vector3 get_axis() const", asMETHODPR(Quaternion, Axis, () const, Vector3), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Vector3 Axis() const", AS_METHODPR(Quaternion, Axis, () const, Vector3), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Vector3 get_axis() const", AS_METHODPR(Quaternion, Axis, () const, Vector3), AS_CALL_THISCALL);
     // Quaternion Quaternion::Conjugate() const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "Quaternion Conjugate() const", asMETHODPR(Quaternion, Conjugate, () const, Quaternion), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Quaternion Conjugate() const", AS_METHODPR(Quaternion, Conjugate, () const, Quaternion), AS_CALL_THISCALL);
     // const float* Quaternion::Data() const | File: ../Math/Quaternion.h
     // Error: type "const float*" can not automatically bind
     // float Quaternion::DotProduct(const Quaternion& rhs) const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "float DotProduct(const Quaternion&in) const", asMETHODPR(Quaternion, DotProduct, (const Quaternion&) const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "float DotProduct(const Quaternion&in) const", AS_METHODPR(Quaternion, DotProduct, (const Quaternion&) const, float), AS_CALL_THISCALL);
     // bool Quaternion::Equals(const Quaternion& rhs) const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "bool Equals(const Quaternion&in) const", asMETHODPR(Quaternion, Equals, (const Quaternion&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "bool Equals(const Quaternion&in) const", AS_METHODPR(Quaternion, Equals, (const Quaternion&) const, bool), AS_CALL_THISCALL);
     // Vector3 Quaternion::EulerAngles() const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "Vector3 EulerAngles() const", asMETHODPR(Quaternion, EulerAngles, () const, Vector3), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Quaternion", "Vector3 get_eulerAngles() const", asMETHODPR(Quaternion, EulerAngles, () const, Vector3), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Vector3 EulerAngles() const", AS_METHODPR(Quaternion, EulerAngles, () const, Vector3), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Vector3 get_eulerAngles() const", AS_METHODPR(Quaternion, EulerAngles, () const, Vector3), AS_CALL_THISCALL);
     // void Quaternion::FromAngleAxis(float angle, const Vector3& axis) | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "void FromAngleAxis(float, const Vector3&in)", asMETHODPR(Quaternion, FromAngleAxis, (float, const Vector3&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "void FromAngleAxis(float, const Vector3&in)", AS_METHODPR(Quaternion, FromAngleAxis, (float, const Vector3&), void), AS_CALL_THISCALL);
     // void Quaternion::FromAxes(const Vector3& xAxis, const Vector3& yAxis, const Vector3& zAxis) | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "void FromAxes(const Vector3&in, const Vector3&in, const Vector3&in)", asMETHODPR(Quaternion, FromAxes, (const Vector3&, const Vector3&, const Vector3&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "void FromAxes(const Vector3&in, const Vector3&in, const Vector3&in)", AS_METHODPR(Quaternion, FromAxes, (const Vector3&, const Vector3&, const Vector3&), void), AS_CALL_THISCALL);
     // void Quaternion::FromEulerAngles(float x, float y, float z) | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "void FromEulerAngles(float, float, float)", asMETHODPR(Quaternion, FromEulerAngles, (float, float, float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "void FromEulerAngles(float, float, float)", AS_METHODPR(Quaternion, FromEulerAngles, (float, float, float), void), AS_CALL_THISCALL);
     // bool Quaternion::FromLookRotation(const Vector3& direction, const Vector3& up=Vector3::UP) | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "bool FromLookRotation(const Vector3&in, const Vector3&in = Vector3::UP)", asMETHODPR(Quaternion, FromLookRotation, (const Vector3&, const Vector3&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "bool FromLookRotation(const Vector3&in, const Vector3&in = Vector3::UP)", AS_METHODPR(Quaternion, FromLookRotation, (const Vector3&, const Vector3&), bool), AS_CALL_THISCALL);
     // void Quaternion::FromRotationMatrix(const Matrix3& matrix) | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "void FromRotationMatrix(const Matrix3&in)", asMETHODPR(Quaternion, FromRotationMatrix, (const Matrix3&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "void FromRotationMatrix(const Matrix3&in)", AS_METHODPR(Quaternion, FromRotationMatrix, (const Matrix3&), void), AS_CALL_THISCALL);
     // void Quaternion::FromRotationTo(const Vector3& start, const Vector3& end) | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "void FromRotationTo(const Vector3&in, const Vector3&in)", asMETHODPR(Quaternion, FromRotationTo, (const Vector3&, const Vector3&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "void FromRotationTo(const Vector3&in, const Vector3&in)", AS_METHODPR(Quaternion, FromRotationTo, (const Vector3&, const Vector3&), void), AS_CALL_THISCALL);
     // Quaternion Quaternion::Inverse() const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "Quaternion Inverse() const", asMETHODPR(Quaternion, Inverse, () const, Quaternion), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Quaternion Inverse() const", AS_METHODPR(Quaternion, Inverse, () const, Quaternion), AS_CALL_THISCALL);
     // bool Quaternion::IsInf() const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "bool IsInf() const", asMETHODPR(Quaternion, IsInf, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "bool IsInf() const", AS_METHODPR(Quaternion, IsInf, () const, bool), AS_CALL_THISCALL);
     // bool Quaternion::IsNaN() const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "bool IsNaN() const", asMETHODPR(Quaternion, IsNaN, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "bool IsNaN() const", AS_METHODPR(Quaternion, IsNaN, () const, bool), AS_CALL_THISCALL);
     // float Quaternion::LengthSquared() const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "float LengthSquared() const", asMETHODPR(Quaternion, LengthSquared, () const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "float LengthSquared() const", AS_METHODPR(Quaternion, LengthSquared, () const, float), AS_CALL_THISCALL);
     // Quaternion Quaternion::Nlerp(const Quaternion& rhs, float t, bool shortestPath=false) const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "Quaternion Nlerp(const Quaternion&in, float, bool = false) const", asMETHODPR(Quaternion, Nlerp, (const Quaternion&, float, bool) const, Quaternion), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Quaternion Nlerp(const Quaternion&in, float, bool = false) const", AS_METHODPR(Quaternion, Nlerp, (const Quaternion&, float, bool) const, Quaternion), AS_CALL_THISCALL);
     // void Quaternion::Normalize() | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "void Normalize()", asMETHODPR(Quaternion, Normalize, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "void Normalize()", AS_METHODPR(Quaternion, Normalize, (), void), AS_CALL_THISCALL);
     // Quaternion Quaternion::Normalized() const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "Quaternion Normalized() const", asMETHODPR(Quaternion, Normalized, () const, Quaternion), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Quaternion Normalized() const", AS_METHODPR(Quaternion, Normalized, () const, Quaternion), AS_CALL_THISCALL);
     // Quaternion Quaternion::operator*(float rhs) const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "Quaternion opMul(float) const", asMETHODPR(Quaternion, operator*, (float) const, Quaternion), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Quaternion opMul(float) const", AS_METHODPR(Quaternion, operator*, (float) const, Quaternion), AS_CALL_THISCALL);
     // Quaternion Quaternion::operator*(const Quaternion& rhs) const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "Quaternion opMul(const Quaternion&in) const", asMETHODPR(Quaternion, operator*, (const Quaternion&) const, Quaternion), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Quaternion opMul(const Quaternion&in) const", AS_METHODPR(Quaternion, operator*, (const Quaternion&) const, Quaternion), AS_CALL_THISCALL);
     // Vector3 Quaternion::operator*(const Vector3& rhs) const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "Vector3 opMul(const Vector3&in) const", asMETHODPR(Quaternion, operator*, (const Vector3&) const, Vector3), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Vector3 opMul(const Vector3&in) const", AS_METHODPR(Quaternion, operator*, (const Vector3&) const, Vector3), AS_CALL_THISCALL);
     // Quaternion& Quaternion::operator*=(float rhs) | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "Quaternion& opMulAssign(float)", asMETHODPR(Quaternion, operator*=, (float), Quaternion&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Quaternion& opMulAssign(float)", AS_METHODPR(Quaternion, operator*=, (float), Quaternion&), AS_CALL_THISCALL);
     // Quaternion Quaternion::operator+(const Quaternion& rhs) const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "Quaternion opAdd(const Quaternion&in) const", asMETHODPR(Quaternion, operator+, (const Quaternion&) const, Quaternion), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Quaternion opAdd(const Quaternion&in) const", AS_METHODPR(Quaternion, operator+, (const Quaternion&) const, Quaternion), AS_CALL_THISCALL);
     // Quaternion& Quaternion::operator+=(const Quaternion& rhs) | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "Quaternion& opAddAssign(const Quaternion&in)", asMETHODPR(Quaternion, operator+=, (const Quaternion&), Quaternion&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Quaternion& opAddAssign(const Quaternion&in)", AS_METHODPR(Quaternion, operator+=, (const Quaternion&), Quaternion&), AS_CALL_THISCALL);
     // Quaternion Quaternion::operator-() const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "Quaternion opNeg() const", asMETHODPR(Quaternion, operator-, () const, Quaternion), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Quaternion opNeg() const", AS_METHODPR(Quaternion, operator-, () const, Quaternion), AS_CALL_THISCALL);
     // Quaternion Quaternion::operator-(const Quaternion& rhs) const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "Quaternion opSub(const Quaternion&in) const", asMETHODPR(Quaternion, operator-, (const Quaternion&) const, Quaternion), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Quaternion opSub(const Quaternion&in) const", AS_METHODPR(Quaternion, operator-, (const Quaternion&) const, Quaternion), AS_CALL_THISCALL);
     // Quaternion& Quaternion::operator=(const Quaternion& rhs) noexcept | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "Quaternion& opAssign(const Quaternion&in)", asMETHODPR(Quaternion, operator=, (const Quaternion&), Quaternion&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Quaternion& opAssign(const Quaternion&in)", AS_METHODPR(Quaternion, operator=, (const Quaternion&), Quaternion&), AS_CALL_THISCALL);
     // bool Quaternion::operator==(const Quaternion& rhs) const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "bool opEquals(const Quaternion&in) const", asMETHODPR(Quaternion, operator==, (const Quaternion&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "bool opEquals(const Quaternion&in) const", AS_METHODPR(Quaternion, operator==, (const Quaternion&) const, bool), AS_CALL_THISCALL);
     // float Quaternion::PitchAngle() const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "float PitchAngle() const", asMETHODPR(Quaternion, PitchAngle, () const, float), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Quaternion", "float get_pitch() const", asMETHODPR(Quaternion, PitchAngle, () const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "float PitchAngle() const", AS_METHODPR(Quaternion, PitchAngle, () const, float), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "float get_pitch() const", AS_METHODPR(Quaternion, PitchAngle, () const, float), AS_CALL_THISCALL);
     // Quaternion::Quaternion(const Quaternion& quat) noexcept | File: ../Math/Quaternion.h
-    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(const Quaternion&in)", asFUNCTION(Quaternion_Quaternion_Quaternion), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(const Quaternion&in)", AS_FUNCTION_OBJFIRST(Quaternion_Quaternion_Quaternion), AS_CALL_CDECL_OBJFIRST);
     // Quaternion::Quaternion(float w, float x, float y, float z) noexcept | File: ../Math/Quaternion.h
-    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(float, float, float, float)", asFUNCTION(Quaternion_Quaternion_float_float_float_float), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(float, float, float, float)", AS_FUNCTION_OBJFIRST(Quaternion_Quaternion_float_float_float_float), AS_CALL_CDECL_OBJFIRST);
     // explicit Quaternion::Quaternion(const float* data) noexcept | File: ../Math/Quaternion.h
     // Error: type "const float*" can not automatically bind
     // Quaternion::Quaternion(float angle, const Vector3& axis) noexcept | File: ../Math/Quaternion.h
-    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(float, const Vector3&in)", asFUNCTION(Quaternion_Quaternion_float_Vector3), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(float, const Vector3&in)", AS_FUNCTION_OBJFIRST(Quaternion_Quaternion_float_Vector3), AS_CALL_CDECL_OBJFIRST);
     // explicit Quaternion::Quaternion(float angle) noexcept | File: ../Math/Quaternion.h
-    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(float)", asFUNCTION(Quaternion_Quaternion_float), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(float)", AS_FUNCTION_OBJFIRST(Quaternion_Quaternion_float), AS_CALL_CDECL_OBJFIRST);
     // Quaternion::Quaternion(float x, float y, float z) noexcept | File: ../Math/Quaternion.h
-    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(float, float, float)", asFUNCTION(Quaternion_Quaternion_float_float_float), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(float, float, float)", AS_FUNCTION_OBJFIRST(Quaternion_Quaternion_float_float_float), AS_CALL_CDECL_OBJFIRST);
     // explicit Quaternion::Quaternion(const Vector3& angles) noexcept | File: ../Math/Quaternion.h
-    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(const Vector3&in)", asFUNCTION(Quaternion_Quaternion_Vector3), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(const Vector3&in)", AS_FUNCTION_OBJFIRST(Quaternion_Quaternion_Vector3), AS_CALL_CDECL_OBJFIRST);
     // Quaternion::Quaternion(const Vector3& start, const Vector3& end) noexcept | File: ../Math/Quaternion.h
-    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(const Vector3&in, const Vector3&in)", asFUNCTION(Quaternion_Quaternion_Vector3_Vector3), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(const Vector3&in, const Vector3&in)", AS_FUNCTION_OBJFIRST(Quaternion_Quaternion_Vector3_Vector3), AS_CALL_CDECL_OBJFIRST);
     // Quaternion::Quaternion(const Vector3& xAxis, const Vector3& yAxis, const Vector3& zAxis) noexcept | File: ../Math/Quaternion.h
-    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(const Vector3&in, const Vector3&in, const Vector3&in)", asFUNCTION(Quaternion_Quaternion_Vector3_Vector3_Vector3), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(const Vector3&in, const Vector3&in, const Vector3&in)", AS_FUNCTION_OBJFIRST(Quaternion_Quaternion_Vector3_Vector3_Vector3), AS_CALL_CDECL_OBJFIRST);
     // explicit Quaternion::Quaternion(const Matrix3& matrix) noexcept | File: ../Math/Quaternion.h
-    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(const Matrix3&in)", asFUNCTION(Quaternion_Quaternion_Matrix3), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("Quaternion", asBEHAVE_CONSTRUCT, "void f(const Matrix3&in)", AS_FUNCTION_OBJFIRST(Quaternion_Quaternion_Matrix3), AS_CALL_CDECL_OBJFIRST);
     // float Quaternion::RollAngle() const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "float RollAngle() const", asMETHODPR(Quaternion, RollAngle, () const, float), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Quaternion", "float get_roll() const", asMETHODPR(Quaternion, RollAngle, () const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "float RollAngle() const", AS_METHODPR(Quaternion, RollAngle, () const, float), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "float get_roll() const", AS_METHODPR(Quaternion, RollAngle, () const, float), AS_CALL_THISCALL);
     // Matrix3 Quaternion::RotationMatrix() const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "Matrix3 RotationMatrix() const", asMETHODPR(Quaternion, RotationMatrix, () const, Matrix3), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Quaternion", "Matrix3 get_rotationMatrix() const", asMETHODPR(Quaternion, RotationMatrix, () const, Matrix3), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Matrix3 RotationMatrix() const", AS_METHODPR(Quaternion, RotationMatrix, () const, Matrix3), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Matrix3 get_rotationMatrix() const", AS_METHODPR(Quaternion, RotationMatrix, () const, Matrix3), AS_CALL_THISCALL);
     // Quaternion Quaternion::Slerp(const Quaternion& rhs, float t) const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "Quaternion Slerp(const Quaternion&in, float) const", asMETHODPR(Quaternion, Slerp, (const Quaternion&, float) const, Quaternion), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "Quaternion Slerp(const Quaternion&in, float) const", AS_METHODPR(Quaternion, Slerp, (const Quaternion&, float) const, Quaternion), AS_CALL_THISCALL);
     // String Quaternion::ToString() const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "String ToString() const", asMETHODPR(Quaternion, ToString, () const, String), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "String ToString() const", AS_METHODPR(Quaternion, ToString, () const, String), AS_CALL_THISCALL);
     // float Quaternion::YawAngle() const | File: ../Math/Quaternion.h
-    engine->RegisterObjectMethod("Quaternion", "float YawAngle() const", asMETHODPR(Quaternion, YawAngle, () const, float), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Quaternion", "float get_yaw() const", asMETHODPR(Quaternion, YawAngle, () const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "float YawAngle() const", AS_METHODPR(Quaternion, YawAngle, () const, float), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Quaternion", "float get_yaw() const", AS_METHODPR(Quaternion, YawAngle, () const, float), AS_CALL_THISCALL);
 #ifdef REGISTER_MANUAL_PART_Quaternion
     REGISTER_MANUAL_PART_Quaternion(Quaternion, "Quaternion")
 #endif

Source/Urho3D/AngelScript/Generated_Members_X.cpp

@@ -72,379 +72,379 @@ void ASRegisterGenerated_Members_X(asIScriptEngine* engine)
     engine->RegisterGlobalProperty("const XMLElement EMPTY", (void*)&XMLElement::EMPTY);
     engine->SetDefaultNamespace("");
     // bool XMLElement::AppendChild(XMLElement element, bool asCopy=false) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool AppendChild(XMLElement, bool = false)", asMETHODPR(XMLElement, AppendChild, (XMLElement, bool), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool AppendChild(XMLElement, bool = false)", AS_METHODPR(XMLElement, AppendChild, (XMLElement, bool), bool), AS_CALL_THISCALL);
     // XMLElement XMLElement::CreateChild(const String& name) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "XMLElement CreateChild(const String&in)", asMETHODPR(XMLElement, CreateChild, (const String&), XMLElement), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "XMLElement CreateChild(const String&in)", AS_METHODPR(XMLElement, CreateChild, (const String&), XMLElement), AS_CALL_THISCALL);
     // XMLElement XMLElement::CreateChild(const char* name) | File: ../Resource/XMLElement.h
     // Error: type "const char*" can not automatically bind
     // String XMLElement::GetAttribute(const String& name=String::EMPTY) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "String GetAttribute(const String&in = String::EMPTY) const", asMETHODPR(XMLElement, GetAttribute, (const String&) const, String), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "String GetAttribute(const String&in = String::EMPTY) const", AS_METHODPR(XMLElement, GetAttribute, (const String&) const, String), AS_CALL_THISCALL);
     // String XMLElement::GetAttribute(const char* name) const | File: ../Resource/XMLElement.h
     // Error: type "const char*" can not automatically bind
     // const char* XMLElement::GetAttributeCString(const char* name) const | File: ../Resource/XMLElement.h
     // Error: type "const char*" can not automatically bind
     // String XMLElement::GetAttributeLower(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "String GetAttributeLower(const String&in) const", asMETHODPR(XMLElement, GetAttributeLower, (const String&) const, String), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "String GetAttributeLower(const String&in) const", AS_METHODPR(XMLElement, GetAttributeLower, (const String&) const, String), AS_CALL_THISCALL);
     // String XMLElement::GetAttributeLower(const char* name) const | File: ../Resource/XMLElement.h
     // Error: type "const char*" can not automatically bind
     // Vector<String> XMLElement::GetAttributeNames() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "Array<String>@ GetAttributeNames() const", asFUNCTION(XMLElement_GetAttributeNames_void), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod("XMLElement", "Array<String>@ GetAttributeNames() const", AS_FUNCTION_OBJFIRST(XMLElement_GetAttributeNames_void), AS_CALL_CDECL_OBJFIRST);
     // String XMLElement::GetAttributeUpper(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "String GetAttributeUpper(const String&in) const", asMETHODPR(XMLElement, GetAttributeUpper, (const String&) const, String), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "String GetAttributeUpper(const String&in) const", AS_METHODPR(XMLElement, GetAttributeUpper, (const String&) const, String), AS_CALL_THISCALL);
     // String XMLElement::GetAttributeUpper(const char* name) const | File: ../Resource/XMLElement.h
     // Error: type "const char*" can not automatically bind
     // bool XMLElement::GetBool(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool GetBool(const String&in) const", asMETHODPR(XMLElement, GetBool, (const String&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool GetBool(const String&in) const", AS_METHODPR(XMLElement, GetBool, (const String&) const, bool), AS_CALL_THISCALL);
     // BoundingBox XMLElement::GetBoundingBox() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "BoundingBox GetBoundingBox() const", asMETHODPR(XMLElement, GetBoundingBox, () const, BoundingBox), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "BoundingBox GetBoundingBox() const", AS_METHODPR(XMLElement, GetBoundingBox, () const, BoundingBox), AS_CALL_THISCALL);
     // PODVector<unsigned char> XMLElement::GetBuffer(const String& name) const | File: ../Resource/XMLElement.h
     // Error: type "PODVector<unsigned char>" can not automatically bind
     // bool XMLElement::GetBuffer(const String& name, void* dest, unsigned size) const | File: ../Resource/XMLElement.h
     // Error: type "void*" can not automatically bind
     // XMLElement XMLElement::GetChild(const String& name=String::EMPTY) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "XMLElement GetChild(const String&in = String::EMPTY) const", asMETHODPR(XMLElement, GetChild, (const String&) const, XMLElement), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "XMLElement GetChild(const String&in = String::EMPTY) const", AS_METHODPR(XMLElement, GetChild, (const String&) const, XMLElement), AS_CALL_THISCALL);
     // XMLElement XMLElement::GetChild(const char* name) const | File: ../Resource/XMLElement.h
     // Error: type "const char*" can not automatically bind
     // Color XMLElement::GetColor(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "Color GetColor(const String&in) const", asMETHODPR(XMLElement, GetColor, (const String&) const, Color), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "Color GetColor(const String&in) const", AS_METHODPR(XMLElement, GetColor, (const String&) const, Color), AS_CALL_THISCALL);
     // double XMLElement::GetDouble(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "double GetDouble(const String&in) const", asMETHODPR(XMLElement, GetDouble, (const String&) const, double), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "double GetDouble(const String&in) const", AS_METHODPR(XMLElement, GetDouble, (const String&) const, double), AS_CALL_THISCALL);
     // XMLFile* XMLElement::GetFile() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "XMLFile@+ GetFile() const", asMETHODPR(XMLElement, GetFile, () const, XMLFile*), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLElement", "XMLFile@+ get_file() const", asMETHODPR(XMLElement, GetFile, () const, XMLFile*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "XMLFile@+ GetFile() const", AS_METHODPR(XMLElement, GetFile, () const, XMLFile*), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "XMLFile@+ get_file() const", AS_METHODPR(XMLElement, GetFile, () const, XMLFile*), AS_CALL_THISCALL);
     // float XMLElement::GetFloat(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "float GetFloat(const String&in) const", asMETHODPR(XMLElement, GetFloat, (const String&) const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "float GetFloat(const String&in) const", AS_METHODPR(XMLElement, GetFloat, (const String&) const, float), AS_CALL_THISCALL);
     // int XMLElement::GetInt(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "int GetInt(const String&in) const", asMETHODPR(XMLElement, GetInt, (const String&) const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "int GetInt(const String&in) const", AS_METHODPR(XMLElement, GetInt, (const String&) const, int), AS_CALL_THISCALL);
     // long long XMLElement::GetInt64(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "int64 GetInt64(const String&in) const", asMETHODPR(XMLElement, GetInt64, (const String&) const, long long), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "int64 GetInt64(const String&in) const", AS_METHODPR(XMLElement, GetInt64, (const String&) const, long long), AS_CALL_THISCALL);
     // IntRect XMLElement::GetIntRect(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "IntRect GetIntRect(const String&in) const", asMETHODPR(XMLElement, GetIntRect, (const String&) const, IntRect), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "IntRect GetIntRect(const String&in) const", AS_METHODPR(XMLElement, GetIntRect, (const String&) const, IntRect), AS_CALL_THISCALL);
     // IntVector2 XMLElement::GetIntVector2(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "IntVector2 GetIntVector2(const String&in) const", asMETHODPR(XMLElement, GetIntVector2, (const String&) const, IntVector2), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "IntVector2 GetIntVector2(const String&in) const", AS_METHODPR(XMLElement, GetIntVector2, (const String&) const, IntVector2), AS_CALL_THISCALL);
     // IntVector3 XMLElement::GetIntVector3(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "IntVector3 GetIntVector3(const String&in) const", asMETHODPR(XMLElement, GetIntVector3, (const String&) const, IntVector3), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "IntVector3 GetIntVector3(const String&in) const", AS_METHODPR(XMLElement, GetIntVector3, (const String&) const, IntVector3), AS_CALL_THISCALL);
     // Matrix3 XMLElement::GetMatrix3(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "Matrix3 GetMatrix3(const String&in) const", asMETHODPR(XMLElement, GetMatrix3, (const String&) const, Matrix3), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "Matrix3 GetMatrix3(const String&in) const", AS_METHODPR(XMLElement, GetMatrix3, (const String&) const, Matrix3), AS_CALL_THISCALL);
     // Matrix3x4 XMLElement::GetMatrix3x4(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "Matrix3x4 GetMatrix3x4(const String&in) const", asMETHODPR(XMLElement, GetMatrix3x4, (const String&) const, Matrix3x4), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "Matrix3x4 GetMatrix3x4(const String&in) const", AS_METHODPR(XMLElement, GetMatrix3x4, (const String&) const, Matrix3x4), AS_CALL_THISCALL);
     // Matrix4 XMLElement::GetMatrix4(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "Matrix4 GetMatrix4(const String&in) const", asMETHODPR(XMLElement, GetMatrix4, (const String&) const, Matrix4), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "Matrix4 GetMatrix4(const String&in) const", AS_METHODPR(XMLElement, GetMatrix4, (const String&) const, Matrix4), AS_CALL_THISCALL);
     // String XMLElement::GetName() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "String GetName() const", asMETHODPR(XMLElement, GetName, () const, String), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLElement", "String get_name() const", asMETHODPR(XMLElement, GetName, () const, String), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "String GetName() const", AS_METHODPR(XMLElement, GetName, () const, String), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "String get_name() const", AS_METHODPR(XMLElement, GetName, () const, String), AS_CALL_THISCALL);
     // XMLElement XMLElement::GetNext(const String& name=String::EMPTY) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "XMLElement GetNext(const String&in = String::EMPTY) const", asMETHODPR(XMLElement, GetNext, (const String&) const, XMLElement), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "XMLElement GetNext(const String&in = String::EMPTY) const", AS_METHODPR(XMLElement, GetNext, (const String&) const, XMLElement), AS_CALL_THISCALL);
     // XMLElement XMLElement::GetNext(const char* name) const | File: ../Resource/XMLElement.h
     // Error: type "const char*" can not automatically bind
     // pugi::xml_node_struct* XMLElement::GetNode() const | File: ../Resource/XMLElement.h
     // Error: type "pugi::xml_node_struct*" can not automatically bind
     // unsigned XMLElement::GetNumAttributes() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "uint GetNumAttributes() const", asMETHODPR(XMLElement, GetNumAttributes, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLElement", "uint get_numAttributes() const", asMETHODPR(XMLElement, GetNumAttributes, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "uint GetNumAttributes() const", AS_METHODPR(XMLElement, GetNumAttributes, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "uint get_numAttributes() const", AS_METHODPR(XMLElement, GetNumAttributes, () const, unsigned), AS_CALL_THISCALL);
     // XMLElement XMLElement::GetOrCreateChild(const String& name) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "XMLElement GetOrCreateChild(const String&in)", asMETHODPR(XMLElement, GetOrCreateChild, (const String&), XMLElement), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "XMLElement GetOrCreateChild(const String&in)", AS_METHODPR(XMLElement, GetOrCreateChild, (const String&), XMLElement), AS_CALL_THISCALL);
     // XMLElement XMLElement::GetOrCreateChild(const char* name) | File: ../Resource/XMLElement.h
     // Error: type "const char*" can not automatically bind
     // XMLElement XMLElement::GetParent() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "XMLElement GetParent() const", asMETHODPR(XMLElement, GetParent, () const, XMLElement), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLElement", "XMLElement get_parent() const", asMETHODPR(XMLElement, GetParent, () const, XMLElement), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "XMLElement GetParent() const", AS_METHODPR(XMLElement, GetParent, () const, XMLElement), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "XMLElement get_parent() const", AS_METHODPR(XMLElement, GetParent, () const, XMLElement), AS_CALL_THISCALL);
     // Quaternion XMLElement::GetQuaternion(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "Quaternion GetQuaternion(const String&in) const", asMETHODPR(XMLElement, GetQuaternion, (const String&) const, Quaternion), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "Quaternion GetQuaternion(const String&in) const", AS_METHODPR(XMLElement, GetQuaternion, (const String&) const, Quaternion), AS_CALL_THISCALL);
     // Rect XMLElement::GetRect(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "Rect GetRect(const String&in) const", asMETHODPR(XMLElement, GetRect, (const String&) const, Rect), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "Rect GetRect(const String&in) const", AS_METHODPR(XMLElement, GetRect, (const String&) const, Rect), AS_CALL_THISCALL);
     // ResourceRef XMLElement::GetResourceRef() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "ResourceRef GetResourceRef() const", asMETHODPR(XMLElement, GetResourceRef, () const, ResourceRef), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "ResourceRef GetResourceRef() const", AS_METHODPR(XMLElement, GetResourceRef, () const, ResourceRef), AS_CALL_THISCALL);
     // ResourceRefList XMLElement::GetResourceRefList() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "ResourceRefList GetResourceRefList() const", asMETHODPR(XMLElement, GetResourceRefList, () const, ResourceRefList), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "ResourceRefList GetResourceRefList() const", AS_METHODPR(XMLElement, GetResourceRefList, () const, ResourceRefList), AS_CALL_THISCALL);
     // StringVector XMLElement::GetStringVector() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "Array<String>@ GetStringVector() const", asFUNCTION(XMLElement_GetStringVector_void), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod("XMLElement", "Array<String>@ GetStringVector() const", AS_FUNCTION_OBJFIRST(XMLElement_GetStringVector_void), AS_CALL_CDECL_OBJFIRST);
     // unsigned XMLElement::GetUInt(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "uint GetUInt(const String&in) const", asMETHODPR(XMLElement, GetUInt, (const String&) const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "uint GetUInt(const String&in) const", AS_METHODPR(XMLElement, GetUInt, (const String&) const, unsigned), AS_CALL_THISCALL);
     // unsigned long long XMLElement::GetUInt64(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "uint64 GetUInt64(const String&in) const", asMETHODPR(XMLElement, GetUInt64, (const String&) const, unsigned long long), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "uint64 GetUInt64(const String&in) const", AS_METHODPR(XMLElement, GetUInt64, (const String&) const, unsigned long long), AS_CALL_THISCALL);
     // String XMLElement::GetValue() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "String GetValue() const", asMETHODPR(XMLElement, GetValue, () const, String), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLElement", "String get_value() const", asMETHODPR(XMLElement, GetValue, () const, String), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "String GetValue() const", AS_METHODPR(XMLElement, GetValue, () const, String), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "String get_value() const", AS_METHODPR(XMLElement, GetValue, () const, String), AS_CALL_THISCALL);
     // Variant XMLElement::GetVariant() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "Variant GetVariant() const", asMETHODPR(XMLElement, GetVariant, () const, Variant), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "Variant GetVariant() const", AS_METHODPR(XMLElement, GetVariant, () const, Variant), AS_CALL_THISCALL);
     // VariantMap XMLElement::GetVariantMap() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "VariantMap GetVariantMap() const", asMETHODPR(XMLElement, GetVariantMap, () const, VariantMap), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "VariantMap GetVariantMap() const", AS_METHODPR(XMLElement, GetVariantMap, () const, VariantMap), AS_CALL_THISCALL);
     // Variant XMLElement::GetVariantValue(VariantType type) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "Variant GetVariantValue(VariantType) const", asMETHODPR(XMLElement, GetVariantValue, (VariantType) const, Variant), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "Variant GetVariantValue(VariantType) const", AS_METHODPR(XMLElement, GetVariantValue, (VariantType) const, Variant), AS_CALL_THISCALL);
     // VariantVector XMLElement::GetVariantVector() const | File: ../Resource/XMLElement.h
     // Error: type "VariantVector" can not automatically bind
     // Vector4 XMLElement::GetVector(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "Vector4 GetVector(const String&in) const", asMETHODPR(XMLElement, GetVector, (const String&) const, Vector4), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "Vector4 GetVector(const String&in) const", AS_METHODPR(XMLElement, GetVector, (const String&) const, Vector4), AS_CALL_THISCALL);
     // Vector2 XMLElement::GetVector2(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "Vector2 GetVector2(const String&in) const", asMETHODPR(XMLElement, GetVector2, (const String&) const, Vector2), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "Vector2 GetVector2(const String&in) const", AS_METHODPR(XMLElement, GetVector2, (const String&) const, Vector2), AS_CALL_THISCALL);
     // Vector3 XMLElement::GetVector3(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "Vector3 GetVector3(const String&in) const", asMETHODPR(XMLElement, GetVector3, (const String&) const, Vector3), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "Vector3 GetVector3(const String&in) const", AS_METHODPR(XMLElement, GetVector3, (const String&) const, Vector3), AS_CALL_THISCALL);
     // Vector4 XMLElement::GetVector4(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "Vector4 GetVector4(const String&in) const", asMETHODPR(XMLElement, GetVector4, (const String&) const, Vector4), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "Vector4 GetVector4(const String&in) const", AS_METHODPR(XMLElement, GetVector4, (const String&) const, Vector4), AS_CALL_THISCALL);
     // Variant XMLElement::GetVectorVariant(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "Variant GetVectorVariant(const String&in) const", asMETHODPR(XMLElement, GetVectorVariant, (const String&) const, Variant), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "Variant GetVectorVariant(const String&in) const", AS_METHODPR(XMLElement, GetVectorVariant, (const String&) const, Variant), AS_CALL_THISCALL);
     // const pugi::xpath_node* XMLElement::GetXPathNode() const | File: ../Resource/XMLElement.h
     // Error: type "const pugi::xpath_node*" can not automatically bind
     // unsigned XMLElement::GetXPathResultIndex() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "uint GetXPathResultIndex() const", asMETHODPR(XMLElement, GetXPathResultIndex, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "uint GetXPathResultIndex() const", AS_METHODPR(XMLElement, GetXPathResultIndex, () const, unsigned), AS_CALL_THISCALL);
     // const XPathResultSet* XMLElement::GetXPathResultSet() const | File: ../Resource/XMLElement.h
     // Error: type "const XPathResultSet*" can not automatically bind
     // bool XMLElement::HasAttribute(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool HasAttribute(const String&in) const", asMETHODPR(XMLElement, HasAttribute, (const String&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool HasAttribute(const String&in) const", AS_METHODPR(XMLElement, HasAttribute, (const String&) const, bool), AS_CALL_THISCALL);
     // bool XMLElement::HasAttribute(const char* name) const | File: ../Resource/XMLElement.h
     // Error: type "const char*" can not automatically bind
     // bool XMLElement::HasChild(const String& name) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool HasChild(const String&in) const", asMETHODPR(XMLElement, HasChild, (const String&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool HasChild(const String&in) const", AS_METHODPR(XMLElement, HasChild, (const String&) const, bool), AS_CALL_THISCALL);
     // bool XMLElement::HasChild(const char* name) const | File: ../Resource/XMLElement.h
     // Error: type "const char*" can not automatically bind
     // bool XMLElement::IsNull() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool IsNull() const", asMETHODPR(XMLElement, IsNull, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLElement", "bool get_isNull() const", asMETHODPR(XMLElement, IsNull, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool IsNull() const", AS_METHODPR(XMLElement, IsNull, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool get_isNull() const", AS_METHODPR(XMLElement, IsNull, () const, bool), AS_CALL_THISCALL);
     // XMLElement XMLElement::NextResult() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "XMLElement NextResult() const", asMETHODPR(XMLElement, NextResult, () const, XMLElement), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLElement", "XMLElement get_nextResult() const", asMETHODPR(XMLElement, NextResult, () const, XMLElement), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "XMLElement NextResult() const", AS_METHODPR(XMLElement, NextResult, () const, XMLElement), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "XMLElement get_nextResult() const", AS_METHODPR(XMLElement, NextResult, () const, XMLElement), AS_CALL_THISCALL);
     // bool XMLElement::NotNull() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool NotNull() const", asMETHODPR(XMLElement, NotNull, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLElement", "bool get_notNull() const", asMETHODPR(XMLElement, NotNull, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool NotNull() const", AS_METHODPR(XMLElement, NotNull, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool get_notNull() const", AS_METHODPR(XMLElement, NotNull, () const, bool), AS_CALL_THISCALL);
     // explicit XMLElement::operator bool() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool opConv() const", asMETHODPR(XMLElement, operator bool, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool opConv() const", AS_METHODPR(XMLElement, operator bool, () const, bool), AS_CALL_THISCALL);
     // XMLElement& XMLElement::operator=(const XMLElement& rhs) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "XMLElement& opAssign(const XMLElement&in)", asMETHODPR(XMLElement, operator=, (const XMLElement&), XMLElement&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "XMLElement& opAssign(const XMLElement&in)", AS_METHODPR(XMLElement, operator=, (const XMLElement&), XMLElement&), AS_CALL_THISCALL);
     // bool XMLElement::Remove() | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool Remove()", asMETHODPR(XMLElement, Remove, (), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool Remove()", AS_METHODPR(XMLElement, Remove, (), bool), AS_CALL_THISCALL);
     // bool XMLElement::RemoveAttribute(const String& name=String::EMPTY) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool RemoveAttribute(const String&in = String::EMPTY)", asMETHODPR(XMLElement, RemoveAttribute, (const String&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool RemoveAttribute(const String&in = String::EMPTY)", AS_METHODPR(XMLElement, RemoveAttribute, (const String&), bool), AS_CALL_THISCALL);
     // bool XMLElement::RemoveAttribute(const char* name) | File: ../Resource/XMLElement.h
     // Error: type "const char*" can not automatically bind
     // bool XMLElement::RemoveChild(const XMLElement& element) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool RemoveChild(const XMLElement&in)", asMETHODPR(XMLElement, RemoveChild, (const XMLElement&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool RemoveChild(const XMLElement&in)", AS_METHODPR(XMLElement, RemoveChild, (const XMLElement&), bool), AS_CALL_THISCALL);
     // bool XMLElement::RemoveChild(const String& name) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool RemoveChild(const String&in)", asMETHODPR(XMLElement, RemoveChild, (const String&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool RemoveChild(const String&in)", AS_METHODPR(XMLElement, RemoveChild, (const String&), bool), AS_CALL_THISCALL);
     // bool XMLElement::RemoveChild(const char* name) | File: ../Resource/XMLElement.h
     // Error: type "const char*" can not automatically bind
     // bool XMLElement::RemoveChildren(const String& name=String::EMPTY) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool RemoveChildren(const String&in = String::EMPTY)", asMETHODPR(XMLElement, RemoveChildren, (const String&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool RemoveChildren(const String&in = String::EMPTY)", AS_METHODPR(XMLElement, RemoveChildren, (const String&), bool), AS_CALL_THISCALL);
     // bool XMLElement::RemoveChildren(const char* name) | File: ../Resource/XMLElement.h
     // Error: type "const char*" can not automatically bind
     // XPathResultSet XMLElement::Select(const String& query, pugi::xpath_variable_set* variables=nullptr) const | File: ../Resource/XMLElement.h
     // Error: type "pugi::xpath_variable_set*" can not automatically bind
     // XPathResultSet XMLElement::SelectPrepared(const XPathQuery& query) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "XPathResultSet SelectPrepared(const XPathQuery&in) const", asMETHODPR(XMLElement, SelectPrepared, (const XPathQuery&) const, XPathResultSet), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "XPathResultSet SelectPrepared(const XPathQuery&in) const", AS_METHODPR(XMLElement, SelectPrepared, (const XPathQuery&) const, XPathResultSet), AS_CALL_THISCALL);
     // XMLElement XMLElement::SelectSingle(const String& query, pugi::xpath_variable_set* variables=nullptr) const | File: ../Resource/XMLElement.h
     // Error: type "pugi::xpath_variable_set*" can not automatically bind
     // XMLElement XMLElement::SelectSinglePrepared(const XPathQuery& query) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "XMLElement SelectSinglePrepared(const XPathQuery&in) const", asMETHODPR(XMLElement, SelectSinglePrepared, (const XPathQuery&) const, XMLElement), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "XMLElement SelectSinglePrepared(const XPathQuery&in) const", AS_METHODPR(XMLElement, SelectSinglePrepared, (const XPathQuery&) const, XMLElement), AS_CALL_THISCALL);
     // bool XMLElement::SetAttribute(const String& name, const String& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetAttribute(const String&in, const String&in)", asMETHODPR(XMLElement, SetAttribute, (const String&, const String&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetAttribute(const String&in, const String&in)", AS_METHODPR(XMLElement, SetAttribute, (const String&, const String&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetAttribute(const char* name, const char* value) | File: ../Resource/XMLElement.h
     // Error: type "const char*" can not automatically bind
     // bool XMLElement::SetAttribute(const String& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetAttribute(const String&in)", asMETHODPR(XMLElement, SetAttribute, (const String&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetAttribute(const String&in)", AS_METHODPR(XMLElement, SetAttribute, (const String&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetAttribute(const char* value) | File: ../Resource/XMLElement.h
     // Error: type "const char*" can not automatically bind
     // bool XMLElement::SetBool(const String& name, bool value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetBool(const String&in, bool)", asMETHODPR(XMLElement, SetBool, (const String&, bool), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetBool(const String&in, bool)", AS_METHODPR(XMLElement, SetBool, (const String&, bool), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetBoundingBox(const BoundingBox& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetBoundingBox(const BoundingBox&in)", asMETHODPR(XMLElement, SetBoundingBox, (const BoundingBox&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetBoundingBox(const BoundingBox&in)", AS_METHODPR(XMLElement, SetBoundingBox, (const BoundingBox&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetBuffer(const String& name, const void* data, unsigned size) | File: ../Resource/XMLElement.h
     // Error: type "const void*" can not automatically bind
     // bool XMLElement::SetBuffer(const String& name, const PODVector<unsigned char>& value) | File: ../Resource/XMLElement.h
     // Error: type "const PODVector<unsigned char>&" can not automatically bind
     // bool XMLElement::SetColor(const String& name, const Color& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetColor(const String&in, const Color&in)", asMETHODPR(XMLElement, SetColor, (const String&, const Color&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetColor(const String&in, const Color&in)", AS_METHODPR(XMLElement, SetColor, (const String&, const Color&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetDouble(const String& name, double value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetDouble(const String&in, double)", asMETHODPR(XMLElement, SetDouble, (const String&, double), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetDouble(const String&in, double)", AS_METHODPR(XMLElement, SetDouble, (const String&, double), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetFloat(const String& name, float value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetFloat(const String&in, float)", asMETHODPR(XMLElement, SetFloat, (const String&, float), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetFloat(const String&in, float)", AS_METHODPR(XMLElement, SetFloat, (const String&, float), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetInt(const String& name, int value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetInt(const String&in, int)", asMETHODPR(XMLElement, SetInt, (const String&, int), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetInt(const String&in, int)", AS_METHODPR(XMLElement, SetInt, (const String&, int), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetInt64(const String& name, long long value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetInt64(const String&in, int64)", asMETHODPR(XMLElement, SetInt64, (const String&, long long), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetInt64(const String&in, int64)", AS_METHODPR(XMLElement, SetInt64, (const String&, long long), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetIntRect(const String& name, const IntRect& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetIntRect(const String&in, const IntRect&in)", asMETHODPR(XMLElement, SetIntRect, (const String&, const IntRect&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetIntRect(const String&in, const IntRect&in)", AS_METHODPR(XMLElement, SetIntRect, (const String&, const IntRect&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetIntVector2(const String& name, const IntVector2& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetIntVector2(const String&in, const IntVector2&in)", asMETHODPR(XMLElement, SetIntVector2, (const String&, const IntVector2&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetIntVector2(const String&in, const IntVector2&in)", AS_METHODPR(XMLElement, SetIntVector2, (const String&, const IntVector2&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetIntVector3(const String& name, const IntVector3& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetIntVector3(const String&in, const IntVector3&in)", asMETHODPR(XMLElement, SetIntVector3, (const String&, const IntVector3&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetIntVector3(const String&in, const IntVector3&in)", AS_METHODPR(XMLElement, SetIntVector3, (const String&, const IntVector3&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetMatrix3(const String& name, const Matrix3& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetMatrix3(const String&in, const Matrix3&in)", asMETHODPR(XMLElement, SetMatrix3, (const String&, const Matrix3&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetMatrix3(const String&in, const Matrix3&in)", AS_METHODPR(XMLElement, SetMatrix3, (const String&, const Matrix3&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetMatrix3x4(const String& name, const Matrix3x4& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetMatrix3x4(const String&in, const Matrix3x4&in)", asMETHODPR(XMLElement, SetMatrix3x4, (const String&, const Matrix3x4&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetMatrix3x4(const String&in, const Matrix3x4&in)", AS_METHODPR(XMLElement, SetMatrix3x4, (const String&, const Matrix3x4&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetMatrix4(const String& name, const Matrix4& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetMatrix4(const String&in, const Matrix4&in)", asMETHODPR(XMLElement, SetMatrix4, (const String&, const Matrix4&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetMatrix4(const String&in, const Matrix4&in)", AS_METHODPR(XMLElement, SetMatrix4, (const String&, const Matrix4&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetQuaternion(const String& name, const Quaternion& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetQuaternion(const String&in, const Quaternion&in)", asMETHODPR(XMLElement, SetQuaternion, (const String&, const Quaternion&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetQuaternion(const String&in, const Quaternion&in)", AS_METHODPR(XMLElement, SetQuaternion, (const String&, const Quaternion&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetRect(const String& name, const Rect& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetRect(const String&in, const Rect&in)", asMETHODPR(XMLElement, SetRect, (const String&, const Rect&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetRect(const String&in, const Rect&in)", AS_METHODPR(XMLElement, SetRect, (const String&, const Rect&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetResourceRef(const ResourceRef& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetResourceRef(const ResourceRef&in)", asMETHODPR(XMLElement, SetResourceRef, (const ResourceRef&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetResourceRef(const ResourceRef&in)", AS_METHODPR(XMLElement, SetResourceRef, (const ResourceRef&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetResourceRefList(const ResourceRefList& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetResourceRefList(const ResourceRefList&in)", asMETHODPR(XMLElement, SetResourceRefList, (const ResourceRefList&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetResourceRefList(const ResourceRefList&in)", AS_METHODPR(XMLElement, SetResourceRefList, (const ResourceRefList&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetString(const String& name, const String& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetString(const String&in, const String&in)", asMETHODPR(XMLElement, SetString, (const String&, const String&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetString(const String&in, const String&in)", AS_METHODPR(XMLElement, SetString, (const String&, const String&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetStringVector(const StringVector& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetStringVector(Array<String>@+)", asFUNCTION(XMLElement_SetStringVector_StringVector), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod("XMLElement", "bool SetStringVector(Array<String>@+)", AS_FUNCTION_OBJFIRST(XMLElement_SetStringVector_StringVector), AS_CALL_CDECL_OBJFIRST);
     // bool XMLElement::SetUInt(const String& name, unsigned value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetUInt(const String&in, uint)", asMETHODPR(XMLElement, SetUInt, (const String&, unsigned), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetUInt(const String&in, uint)", AS_METHODPR(XMLElement, SetUInt, (const String&, unsigned), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetUInt64(const String& name, unsigned long long value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetUInt64(const String&in, uint64)", asMETHODPR(XMLElement, SetUInt64, (const String&, unsigned long long), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetUInt64(const String&in, uint64)", AS_METHODPR(XMLElement, SetUInt64, (const String&, unsigned long long), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetValue(const String& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetValue(const String&in)", asMETHODPR(XMLElement, SetValue, (const String&), bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLElement", "bool set_value(const String&in)", asMETHODPR(XMLElement, SetValue, (const String&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetValue(const String&in)", AS_METHODPR(XMLElement, SetValue, (const String&), bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool set_value(const String&in)", AS_METHODPR(XMLElement, SetValue, (const String&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetValue(const char* value) | File: ../Resource/XMLElement.h
     // Error: type "const char*" can not automatically bind
     // bool XMLElement::SetVariant(const Variant& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetVariant(const Variant&in)", asMETHODPR(XMLElement, SetVariant, (const Variant&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetVariant(const Variant&in)", AS_METHODPR(XMLElement, SetVariant, (const Variant&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetVariantMap(const VariantMap& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetVariantMap(const VariantMap&in)", asMETHODPR(XMLElement, SetVariantMap, (const VariantMap&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetVariantMap(const VariantMap&in)", AS_METHODPR(XMLElement, SetVariantMap, (const VariantMap&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetVariantValue(const Variant& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetVariantValue(const Variant&in)", asMETHODPR(XMLElement, SetVariantValue, (const Variant&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetVariantValue(const Variant&in)", AS_METHODPR(XMLElement, SetVariantValue, (const Variant&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetVariantVector(const VariantVector& value) | File: ../Resource/XMLElement.h
     // Error: type "const VariantVector&" can not automatically bind
     // bool XMLElement::SetVector2(const String& name, const Vector2& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetVector2(const String&in, const Vector2&in)", asMETHODPR(XMLElement, SetVector2, (const String&, const Vector2&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetVector2(const String&in, const Vector2&in)", AS_METHODPR(XMLElement, SetVector2, (const String&, const Vector2&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetVector3(const String& name, const Vector3& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetVector3(const String&in, const Vector3&in)", asMETHODPR(XMLElement, SetVector3, (const String&, const Vector3&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetVector3(const String&in, const Vector3&in)", AS_METHODPR(XMLElement, SetVector3, (const String&, const Vector3&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetVector4(const String& name, const Vector4& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetVector4(const String&in, const Vector4&in)", asMETHODPR(XMLElement, SetVector4, (const String&, const Vector4&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetVector4(const String&in, const Vector4&in)", AS_METHODPR(XMLElement, SetVector4, (const String&, const Vector4&), bool), AS_CALL_THISCALL);
     // bool XMLElement::SetVectorVariant(const String& name, const Variant& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XMLElement", "bool SetVectorVariant(const String&in, const Variant&in)", asMETHODPR(XMLElement, SetVectorVariant, (const String&, const Variant&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLElement", "bool SetVectorVariant(const String&in, const Variant&in)", AS_METHODPR(XMLElement, SetVectorVariant, (const String&, const Variant&), bool), AS_CALL_THISCALL);
     // XMLElement::XMLElement(XMLFile* file, pugi::xml_node_struct* node) | File: ../Resource/XMLElement.h
     // Error: type "pugi::xml_node_struct*" can not automatically bind
     // XMLElement::XMLElement(XMLFile* file, const XPathResultSet* resultSet, const pugi::xpath_node* xpathNode, unsigned xpathResultIndex) | File: ../Resource/XMLElement.h
     // Error: type "const XPathResultSet*" can not automatically bind
     // XMLElement::XMLElement(const XMLElement& rhs) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectBehaviour("XMLElement", asBEHAVE_CONSTRUCT, "void f(const XMLElement&in)", asFUNCTION(XMLElement_XMLElement_XMLElement), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("XMLElement", asBEHAVE_CONSTRUCT, "void f(const XMLElement&in)", AS_FUNCTION_OBJFIRST(XMLElement_XMLElement_XMLElement), AS_CALL_CDECL_OBJFIRST);
 #ifdef REGISTER_MANUAL_PART_XMLElement
     REGISTER_MANUAL_PART_XMLElement(XMLElement, "XMLElement")
 #endif
 
     // void RefCounted::AddRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour("XMLFile", asBEHAVE_ADDREF, "void f()", asMETHODPR(XMLFile, AddRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour("XMLFile", asBEHAVE_ADDREF, "void f()", AS_METHODPR(XMLFile, AddRef, (), void), AS_CALL_THISCALL);
     // bool XMLFile::BeginLoad(Deserializer& source) override | File: ../Resource/XMLFile.h
-    engine->RegisterObjectMethod("XMLFile", "bool BeginLoad(Deserializer&)", asMETHODPR(XMLFile, BeginLoad, (Deserializer&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "bool BeginLoad(Deserializer&)", AS_METHODPR(XMLFile, BeginLoad, (Deserializer&), bool), AS_CALL_THISCALL);
     // template<typename T> T* Object::Cast() | File: ../Core/Object.h
     // Not registered because template
     // template<typename T> const T* Object::Cast() const | File: ../Core/Object.h
     // Not registered because template
     // XMLElement XMLFile::CreateRoot(const String& name) | File: ../Resource/XMLFile.h
-    engine->RegisterObjectMethod("XMLFile", "XMLElement CreateRoot(const String&in)", asMETHODPR(XMLFile, CreateRoot, (const String&), XMLElement), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "XMLElement CreateRoot(const String&in)", AS_METHODPR(XMLFile, CreateRoot, (const String&), XMLElement), AS_CALL_THISCALL);
     // virtual bool Resource::EndLoad() | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("XMLFile", "bool EndLoad()", asMETHODPR(XMLFile, EndLoad, (), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "bool EndLoad()", AS_METHODPR(XMLFile, EndLoad, (), bool), AS_CALL_THISCALL);
     // bool XMLFile::FromString(const String& source) | File: ../Resource/XMLFile.h
-    engine->RegisterObjectMethod("XMLFile", "bool FromString(const String&in)", asMETHODPR(XMLFile, FromString, (const String&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "bool FromString(const String&in)", AS_METHODPR(XMLFile, FromString, (const String&), bool), AS_CALL_THISCALL);
     // AsyncLoadState Resource::GetAsyncLoadState() const | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("XMLFile", "AsyncLoadState GetAsyncLoadState() const", asMETHODPR(XMLFile, GetAsyncLoadState, () const, AsyncLoadState), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "AsyncLoadState GetAsyncLoadState() const", AS_METHODPR(XMLFile, GetAsyncLoadState, () const, AsyncLoadState), AS_CALL_THISCALL);
     // bool Object::GetBlockEvents() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "bool GetBlockEvents() const", asMETHODPR(XMLFile, GetBlockEvents, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "bool GetBlockEvents() const", AS_METHODPR(XMLFile, GetBlockEvents, () const, bool), AS_CALL_THISCALL);
     // const String& Object::GetCategory() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "const String& GetCategory() const", asMETHODPR(XMLFile, GetCategory, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLFile", "const String& get_category() const", asMETHODPR(XMLFile, GetCategory, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "const String& GetCategory() const", AS_METHODPR(XMLFile, GetCategory, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "const String& get_category() const", AS_METHODPR(XMLFile, GetCategory, () const, const String&), AS_CALL_THISCALL);
     // Context* Object::GetContext() const | File: ../Core/Object.h
     // Error: type "Context*" can used only as function parameter
     // pugi::xml_document* XMLFile::GetDocument() const | File: ../Resource/XMLFile.h
     // Error: type "pugi::xml_document*" can not automatically bind
     // VariantMap& Object::GetEventDataMap() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "VariantMap& GetEventDataMap() const", asMETHODPR(XMLFile, GetEventDataMap, () const, VariantMap&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "VariantMap& GetEventDataMap() const", AS_METHODPR(XMLFile, GetEventDataMap, () const, VariantMap&), AS_CALL_THISCALL);
     // EventHandler* Object::GetEventHandler() const | File: ../Core/Object.h
     // Error: type "EventHandler*" can not automatically bind
     // Object* Object::GetEventSender() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "Object@+ GetEventSender() const", asMETHODPR(XMLFile, GetEventSender, () const, Object*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "Object@+ GetEventSender() const", AS_METHODPR(XMLFile, GetEventSender, () const, Object*), AS_CALL_THISCALL);
     // const Variant& Object::GetGlobalVar(StringHash key) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "const Variant& GetGlobalVar(StringHash) const", asMETHODPR(XMLFile, GetGlobalVar, (StringHash) const, const Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLFile", "const Variant& get_globalVar(StringHash) const", asMETHODPR(XMLFile, GetGlobalVar, (StringHash) const, const Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "const Variant& GetGlobalVar(StringHash) const", AS_METHODPR(XMLFile, GetGlobalVar, (StringHash) const, const Variant&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "const Variant& get_globalVar(StringHash) const", AS_METHODPR(XMLFile, GetGlobalVar, (StringHash) const, const Variant&), AS_CALL_THISCALL);
     // const VariantMap& Object::GetGlobalVars() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "const VariantMap& GetGlobalVars() const", asMETHODPR(XMLFile, GetGlobalVars, () const, const VariantMap&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLFile", "const VariantMap& get_globalVars() const", asMETHODPR(XMLFile, GetGlobalVars, () const, const VariantMap&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "const VariantMap& GetGlobalVars() const", AS_METHODPR(XMLFile, GetGlobalVars, () const, const VariantMap&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "const VariantMap& get_globalVars() const", AS_METHODPR(XMLFile, GetGlobalVars, () const, const VariantMap&), AS_CALL_THISCALL);
     // unsigned Resource::GetMemoryUse() const | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("XMLFile", "uint GetMemoryUse() const", asMETHODPR(XMLFile, GetMemoryUse, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLFile", "uint get_memoryUse() const", asMETHODPR(XMLFile, GetMemoryUse, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "uint GetMemoryUse() const", AS_METHODPR(XMLFile, GetMemoryUse, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "uint get_memoryUse() const", AS_METHODPR(XMLFile, GetMemoryUse, () const, unsigned), AS_CALL_THISCALL);
     // const String& Resource::GetName() const | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("XMLFile", "const String& GetName() const", asMETHODPR(XMLFile, GetName, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLFile", "const String& get_name() const", asMETHODPR(XMLFile, GetName, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "const String& GetName() const", AS_METHODPR(XMLFile, GetName, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "const String& get_name() const", AS_METHODPR(XMLFile, GetName, () const, const String&), AS_CALL_THISCALL);
     // StringHash Resource::GetNameHash() const | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("XMLFile", "StringHash GetNameHash() const", asMETHODPR(XMLFile, GetNameHash, () const, StringHash), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "StringHash GetNameHash() const", AS_METHODPR(XMLFile, GetNameHash, () const, StringHash), AS_CALL_THISCALL);
     // XMLElement XMLFile::GetOrCreateRoot(const String& name) | File: ../Resource/XMLFile.h
-    engine->RegisterObjectMethod("XMLFile", "XMLElement GetOrCreateRoot(const String&in)", asMETHODPR(XMLFile, GetOrCreateRoot, (const String&), XMLElement), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "XMLElement GetOrCreateRoot(const String&in)", AS_METHODPR(XMLFile, GetOrCreateRoot, (const String&), XMLElement), AS_CALL_THISCALL);
     // XMLElement XMLFile::GetRoot(const String& name=String::EMPTY) | File: ../Resource/XMLFile.h
-    engine->RegisterObjectMethod("XMLFile", "XMLElement GetRoot(const String&in = String::EMPTY)", asMETHODPR(XMLFile, GetRoot, (const String&), XMLElement), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "XMLElement GetRoot(const String&in = String::EMPTY)", AS_METHODPR(XMLFile, GetRoot, (const String&), XMLElement), AS_CALL_THISCALL);
     // Object* Object::GetSubsystem(StringHash type) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "Object@+ GetSubsystem(StringHash) const", asMETHODPR(XMLFile, GetSubsystem, (StringHash) const, Object*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "Object@+ GetSubsystem(StringHash) const", AS_METHODPR(XMLFile, GetSubsystem, (StringHash) const, Object*), AS_CALL_THISCALL);
     // template<class T> T* Object::GetSubsystem() const | File: ../Core/Object.h
     // Not registered because template
     // virtual StringHash Object::GetType() const =0 | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "StringHash GetType() const", asMETHODPR(XMLFile, GetType, () const, StringHash), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLFile", "StringHash get_type() const", asMETHODPR(XMLFile, GetType, () const, StringHash), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "StringHash GetType() const", AS_METHODPR(XMLFile, GetType, () const, StringHash), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "StringHash get_type() const", AS_METHODPR(XMLFile, GetType, () const, StringHash), AS_CALL_THISCALL);
     // virtual const TypeInfo* Object::GetTypeInfo() const =0 | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // static const TypeInfo* Object::GetTypeInfoStatic() | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // virtual const String& Object::GetTypeName() const =0 | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "const String& GetTypeName() const", asMETHODPR(XMLFile, GetTypeName, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLFile", "const String& get_typeName() const", asMETHODPR(XMLFile, GetTypeName, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "const String& GetTypeName() const", AS_METHODPR(XMLFile, GetTypeName, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "const String& get_typeName() const", AS_METHODPR(XMLFile, GetTypeName, () const, const String&), AS_CALL_THISCALL);
     // unsigned Resource::GetUseTimer() | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("XMLFile", "uint GetUseTimer()", asMETHODPR(XMLFile, GetUseTimer, (), unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLFile", "uint get_useTimer()", asMETHODPR(XMLFile, GetUseTimer, (), unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "uint GetUseTimer()", AS_METHODPR(XMLFile, GetUseTimer, (), unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "uint get_useTimer()", AS_METHODPR(XMLFile, GetUseTimer, (), unsigned), AS_CALL_THISCALL);
     // bool Object::HasEventHandlers() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "bool HasEventHandlers() const", asMETHODPR(XMLFile, HasEventHandlers, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "bool HasEventHandlers() const", AS_METHODPR(XMLFile, HasEventHandlers, () const, bool), AS_CALL_THISCALL);
     // bool Object::HasSubscribedToEvent(StringHash eventType) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "bool HasSubscribedToEvent(StringHash) const", asMETHODPR(XMLFile, HasSubscribedToEvent, (StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "bool HasSubscribedToEvent(StringHash) const", AS_METHODPR(XMLFile, HasSubscribedToEvent, (StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::HasSubscribedToEvent(Object* sender, StringHash eventType) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "bool HasSubscribedToEvent(Object@+, StringHash) const", asMETHODPR(XMLFile, HasSubscribedToEvent, (Object*, StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "bool HasSubscribedToEvent(Object@+, StringHash) const", AS_METHODPR(XMLFile, HasSubscribedToEvent, (Object*, StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::IsInstanceOf(StringHash type) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "bool IsInstanceOf(StringHash) const", asMETHODPR(XMLFile, IsInstanceOf, (StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "bool IsInstanceOf(StringHash) const", AS_METHODPR(XMLFile, IsInstanceOf, (StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::IsInstanceOf(const TypeInfo* typeInfo) const | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // template<typename T> bool Object::IsInstanceOf() const | File: ../Core/Object.h
     // Not registered because template
     // bool Resource::Load(Deserializer& source) | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("XMLFile", "bool Load(Deserializer&)", asMETHODPR(XMLFile, Load, (Deserializer&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "bool Load(Deserializer&)", AS_METHODPR(XMLFile, Load, (Deserializer&), bool), AS_CALL_THISCALL);
     // bool Resource::LoadFile(const String& fileName) | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("XMLFile", "bool LoadFile(const String&in)", asMETHODPR(XMLFile, LoadFile, (const String&), bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLFile", "bool Load(const String&in)", asMETHODPR(XMLFile, LoadFile, (const String&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "bool LoadFile(const String&in)", AS_METHODPR(XMLFile, LoadFile, (const String&), bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "bool Load(const String&in)", AS_METHODPR(XMLFile, LoadFile, (const String&), bool), AS_CALL_THISCALL);
     // virtual void Object::OnEvent(Object* sender, StringHash eventType, VariantMap& eventData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "void OnEvent(Object@+, StringHash, VariantMap&)", asMETHODPR(XMLFile, OnEvent, (Object*, StringHash, VariantMap&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "void OnEvent(Object@+, StringHash, VariantMap&)", AS_METHODPR(XMLFile, OnEvent, (Object*, StringHash, VariantMap&), void), AS_CALL_THISCALL);
     // void XMLFile::Patch(XMLFile* patchFile) | File: ../Resource/XMLFile.h
-    engine->RegisterObjectMethod("XMLFile", "void Patch(XMLFile@+)", asMETHODPR(XMLFile, Patch, (XMLFile*), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "void Patch(XMLFile@+)", AS_METHODPR(XMLFile, Patch, (XMLFile*), void), AS_CALL_THISCALL);
     // void XMLFile::Patch(const XMLElement& patchElement) | File: ../Resource/XMLFile.h
-    engine->RegisterObjectMethod("XMLFile", "void Patch(const XMLElement&in)", asMETHODPR(XMLFile, Patch, (const XMLElement&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "void Patch(const XMLElement&in)", AS_METHODPR(XMLFile, Patch, (const XMLElement&), void), AS_CALL_THISCALL);
     // RefCount* RefCounted::RefCountPtr() | File: ../Container/RefCounted.h
     // Error: type "RefCount*" can not automatically bind
     // int RefCounted::Refs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod("XMLFile", "int Refs() const", asMETHODPR(XMLFile, Refs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLFile", "int get_refs() const", asMETHODPR(XMLFile, Refs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "int Refs() const", AS_METHODPR(XMLFile, Refs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "int get_refs() const", AS_METHODPR(XMLFile, Refs, () const, int), AS_CALL_THISCALL);
     // static void XMLFile::RegisterObject(Context* context) | File: ../Resource/XMLFile.h
     // Not registered because have @nobind mark
     // void RefCounted::ReleaseRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour("XMLFile", asBEHAVE_RELEASE, "void f()", asMETHODPR(XMLFile, ReleaseRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour("XMLFile", asBEHAVE_RELEASE, "void f()", AS_METHODPR(XMLFile, ReleaseRef, (), void), AS_CALL_THISCALL);
     // void Resource::ResetUseTimer() | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("XMLFile", "void ResetUseTimer()", asMETHODPR(XMLFile, ResetUseTimer, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "void ResetUseTimer()", AS_METHODPR(XMLFile, ResetUseTimer, (), void), AS_CALL_THISCALL);
     // bool XMLFile::Save(Serializer& dest) const override | File: ../Resource/XMLFile.h
-    engine->RegisterObjectMethod("XMLFile", "bool Save(Serializer&) const", asMETHODPR(XMLFile, Save, (Serializer&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "bool Save(Serializer&) const", AS_METHODPR(XMLFile, Save, (Serializer&) const, bool), AS_CALL_THISCALL);
     // bool XMLFile::Save(Serializer& dest, const String& indentation) const | File: ../Resource/XMLFile.h
-    engine->RegisterObjectMethod("XMLFile", "bool Save(Serializer&, const String&in) const", asMETHODPR(XMLFile, Save, (Serializer&, const String&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "bool Save(Serializer&, const String&in) const", AS_METHODPR(XMLFile, Save, (Serializer&, const String&) const, bool), AS_CALL_THISCALL);
     // virtual bool Resource::SaveFile(const String& fileName) const | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("XMLFile", "bool SaveFile(const String&in) const", asMETHODPR(XMLFile, SaveFile, (const String&) const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLFile", "bool Save(const String&in) const", asMETHODPR(XMLFile, SaveFile, (const String&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "bool SaveFile(const String&in) const", AS_METHODPR(XMLFile, SaveFile, (const String&) const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "bool Save(const String&in) const", AS_METHODPR(XMLFile, SaveFile, (const String&) const, bool), AS_CALL_THISCALL);
     // void Object::SendEvent(StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "void SendEvent(StringHash)", asMETHODPR(XMLFile, SendEvent, (StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "void SendEvent(StringHash)", AS_METHODPR(XMLFile, SendEvent, (StringHash), void), AS_CALL_THISCALL);
     // void Object::SendEvent(StringHash eventType, VariantMap& eventData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "void SendEvent(StringHash, VariantMap&)", asMETHODPR(XMLFile, SendEvent, (StringHash, VariantMap&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "void SendEvent(StringHash, VariantMap&)", AS_METHODPR(XMLFile, SendEvent, (StringHash, VariantMap&), void), AS_CALL_THISCALL);
     // template<typename... Args> void Object::SendEvent(StringHash eventType, Args... args) | File: ../Core/Object.h
     // Not registered because template
     // void Resource::SetAsyncLoadState(AsyncLoadState newState) | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("XMLFile", "void SetAsyncLoadState(AsyncLoadState)", asMETHODPR(XMLFile, SetAsyncLoadState, (AsyncLoadState), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "void SetAsyncLoadState(AsyncLoadState)", AS_METHODPR(XMLFile, SetAsyncLoadState, (AsyncLoadState), void), AS_CALL_THISCALL);
     // void Object::SetBlockEvents(bool block) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "void SetBlockEvents(bool)", asMETHODPR(XMLFile, SetBlockEvents, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "void SetBlockEvents(bool)", AS_METHODPR(XMLFile, SetBlockEvents, (bool), void), AS_CALL_THISCALL);
     // void Object::SetGlobalVar(StringHash key, const Variant& value) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "void SetGlobalVar(StringHash, const Variant&in)", asMETHODPR(XMLFile, SetGlobalVar, (StringHash, const Variant&), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLFile", "void set_globalVar(StringHash, const Variant&in)", asMETHODPR(XMLFile, SetGlobalVar, (StringHash, const Variant&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "void SetGlobalVar(StringHash, const Variant&in)", AS_METHODPR(XMLFile, SetGlobalVar, (StringHash, const Variant&), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "void set_globalVar(StringHash, const Variant&in)", AS_METHODPR(XMLFile, SetGlobalVar, (StringHash, const Variant&), void), AS_CALL_THISCALL);
     // void Resource::SetMemoryUse(unsigned size) | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("XMLFile", "void SetMemoryUse(uint)", asMETHODPR(XMLFile, SetMemoryUse, (unsigned), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "void SetMemoryUse(uint)", AS_METHODPR(XMLFile, SetMemoryUse, (unsigned), void), AS_CALL_THISCALL);
     // void Resource::SetName(const String& name) | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod("XMLFile", "void SetName(const String&in)", asMETHODPR(XMLFile, SetName, (const String&), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLFile", "void set_name(const String&in)", asMETHODPR(XMLFile, SetName, (const String&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "void SetName(const String&in)", AS_METHODPR(XMLFile, SetName, (const String&), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "void set_name(const String&in)", AS_METHODPR(XMLFile, SetName, (const String&), void), AS_CALL_THISCALL);
     // void Object::SubscribeToEvent(StringHash eventType, EventHandler* handler) | File: ../Core/Object.h
     // Error: type "EventHandler*" can not automatically bind
     // void Object::SubscribeToEvent(Object* sender, StringHash eventType, EventHandler* handler) | File: ../Core/Object.h
@@ -454,22 +454,22 @@ void ASRegisterGenerated_Members_X(asIScriptEngine* engine)
     // void Object::SubscribeToEvent(Object* sender, StringHash eventType, const std::function<void(StringHash, VariantMap&)>& function, void* userData=nullptr) | File: ../Core/Object.h
     // Error: type "const std::function<void(StringHash, VariantMap&)>&" can not automatically bind
     // String XMLFile::ToString(const String& indentation="\t") const | File: ../Resource/XMLFile.h
-    engine->RegisterObjectMethod("XMLFile", "String ToString(const String&in = \"\t\") const", asMETHODPR(XMLFile, ToString, (const String&) const, String), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "String ToString(const String&in = \"\t\") const", AS_METHODPR(XMLFile, ToString, (const String&) const, String), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromAllEvents() | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "void UnsubscribeFromAllEvents()", asMETHODPR(XMLFile, UnsubscribeFromAllEvents, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "void UnsubscribeFromAllEvents()", AS_METHODPR(XMLFile, UnsubscribeFromAllEvents, (), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromAllEventsExcept(const PODVector<StringHash>& exceptions, bool onlyUserData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "void UnsubscribeFromAllEventsExcept(Array<StringHash>@+, bool)", asFUNCTION(XMLFile_UnsubscribeFromAllEventsExcept_PODVectorStringHash_bool), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod("XMLFile", "void UnsubscribeFromAllEventsExcept(Array<StringHash>@+, bool)", AS_FUNCTION_OBJFIRST(XMLFile_UnsubscribeFromAllEventsExcept_PODVectorStringHash_bool), AS_CALL_CDECL_OBJFIRST);
     // void Object::UnsubscribeFromEvent(StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "void UnsubscribeFromEvent(StringHash)", asMETHODPR(XMLFile, UnsubscribeFromEvent, (StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "void UnsubscribeFromEvent(StringHash)", AS_METHODPR(XMLFile, UnsubscribeFromEvent, (StringHash), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromEvent(Object* sender, StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "void UnsubscribeFromEvent(Object@+, StringHash)", asMETHODPR(XMLFile, UnsubscribeFromEvent, (Object*, StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "void UnsubscribeFromEvent(Object@+, StringHash)", AS_METHODPR(XMLFile, UnsubscribeFromEvent, (Object*, StringHash), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromEvents(Object* sender) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("XMLFile", "void UnsubscribeFromEvents(Object@+)", asMETHODPR(XMLFile, UnsubscribeFromEvents, (Object*), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "void UnsubscribeFromEvents(Object@+)", AS_METHODPR(XMLFile, UnsubscribeFromEvents, (Object*), void), AS_CALL_THISCALL);
     // int RefCounted::WeakRefs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod("XMLFile", "int WeakRefs() const", asMETHODPR(XMLFile, WeakRefs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XMLFile", "int get_weakRefs() const", asMETHODPR(XMLFile, WeakRefs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "int WeakRefs() const", AS_METHODPR(XMLFile, WeakRefs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XMLFile", "int get_weakRefs() const", AS_METHODPR(XMLFile, WeakRefs, () const, int), AS_CALL_THISCALL);
     // explicit XMLFile::XMLFile(Context* context) | File: ../Resource/XMLFile.h
-    engine->RegisterObjectBehaviour("XMLFile", asBEHAVE_FACTORY, "XMLFile@+ f()", asFUNCTION(XMLFile_XMLFile_Context), asCALL_CDECL);
+    engine->RegisterObjectBehaviour("XMLFile", asBEHAVE_FACTORY, "XMLFile@+ f()", AS_FUNCTION(XMLFile_XMLFile_Context), AS_CALL_CDECL);
 #ifdef REGISTER_MANUAL_PART_Resource
     REGISTER_MANUAL_PART_Resource(XMLFile, "XMLFile")
 #endif
@@ -487,38 +487,38 @@ void ASRegisterGenerated_Members_X(asIScriptEngine* engine)
     RegisterSubclass<RefCounted, XMLFile>(engine, "RefCounted", "XMLFile");
 
     // void XPathQuery::Bind() | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XPathQuery", "void Bind()", asMETHODPR(XPathQuery, Bind, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XPathQuery", "void Bind()", AS_METHODPR(XPathQuery, Bind, (), void), AS_CALL_THISCALL);
     // void XPathQuery::Clear() | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XPathQuery", "void Clear()", asMETHODPR(XPathQuery, Clear, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XPathQuery", "void Clear()", AS_METHODPR(XPathQuery, Clear, (), void), AS_CALL_THISCALL);
     // XPathResultSet XPathQuery::Evaluate(const XMLElement& element) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XPathQuery", "XPathResultSet Evaluate(const XMLElement&in) const", asMETHODPR(XPathQuery, Evaluate, (const XMLElement&) const, XPathResultSet), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XPathQuery", "XPathResultSet Evaluate(const XMLElement&in) const", AS_METHODPR(XPathQuery, Evaluate, (const XMLElement&) const, XPathResultSet), AS_CALL_THISCALL);
     // bool XPathQuery::EvaluateToBool(const XMLElement& element) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XPathQuery", "bool EvaluateToBool(const XMLElement&in) const", asMETHODPR(XPathQuery, EvaluateToBool, (const XMLElement&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XPathQuery", "bool EvaluateToBool(const XMLElement&in) const", AS_METHODPR(XPathQuery, EvaluateToBool, (const XMLElement&) const, bool), AS_CALL_THISCALL);
     // float XPathQuery::EvaluateToFloat(const XMLElement& element) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XPathQuery", "float EvaluateToFloat(const XMLElement&in) const", asMETHODPR(XPathQuery, EvaluateToFloat, (const XMLElement&) const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XPathQuery", "float EvaluateToFloat(const XMLElement&in) const", AS_METHODPR(XPathQuery, EvaluateToFloat, (const XMLElement&) const, float), AS_CALL_THISCALL);
     // String XPathQuery::EvaluateToString(const XMLElement& element) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XPathQuery", "String EvaluateToString(const XMLElement&in) const", asMETHODPR(XPathQuery, EvaluateToString, (const XMLElement&) const, String), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XPathQuery", "String EvaluateToString(const XMLElement&in) const", AS_METHODPR(XPathQuery, EvaluateToString, (const XMLElement&) const, String), AS_CALL_THISCALL);
     // String XPathQuery::GetQuery() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XPathQuery", "String GetQuery() const", asMETHODPR(XPathQuery, GetQuery, () const, String), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XPathQuery", "String get_query() const", asMETHODPR(XPathQuery, GetQuery, () const, String), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XPathQuery", "String GetQuery() const", AS_METHODPR(XPathQuery, GetQuery, () const, String), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XPathQuery", "String get_query() const", AS_METHODPR(XPathQuery, GetQuery, () const, String), AS_CALL_THISCALL);
     // pugi::xpath_query* XPathQuery::GetXPathQuery() const | File: ../Resource/XMLElement.h
     // Error: type "pugi::xpath_query*" can not automatically bind
     // pugi::xpath_variable_set* XPathQuery::GetXPathVariableSet() const | File: ../Resource/XMLElement.h
     // Error: type "pugi::xpath_variable_set*" can not automatically bind
     // bool XPathQuery::SetQuery(const String& queryString, const String& variableString=String::EMPTY, bool bind=true) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XPathQuery", "bool SetQuery(const String&in, const String&in = String::EMPTY, bool = true)", asMETHODPR(XPathQuery, SetQuery, (const String&, const String&, bool), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XPathQuery", "bool SetQuery(const String&in, const String&in = String::EMPTY, bool = true)", AS_METHODPR(XPathQuery, SetQuery, (const String&, const String&, bool), bool), AS_CALL_THISCALL);
     // bool XPathQuery::SetVariable(const String& name, bool value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XPathQuery", "bool SetVariable(const String&in, bool)", asMETHODPR(XPathQuery, SetVariable, (const String&, bool), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XPathQuery", "bool SetVariable(const String&in, bool)", AS_METHODPR(XPathQuery, SetVariable, (const String&, bool), bool), AS_CALL_THISCALL);
     // bool XPathQuery::SetVariable(const String& name, float value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XPathQuery", "bool SetVariable(const String&in, float)", asMETHODPR(XPathQuery, SetVariable, (const String&, float), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XPathQuery", "bool SetVariable(const String&in, float)", AS_METHODPR(XPathQuery, SetVariable, (const String&, float), bool), AS_CALL_THISCALL);
     // bool XPathQuery::SetVariable(const String& name, const String& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XPathQuery", "bool SetVariable(const String&in, const String&in)", asMETHODPR(XPathQuery, SetVariable, (const String&, const String&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XPathQuery", "bool SetVariable(const String&in, const String&in)", AS_METHODPR(XPathQuery, SetVariable, (const String&, const String&), bool), AS_CALL_THISCALL);
     // bool XPathQuery::SetVariable(const char* name, const char* value) | File: ../Resource/XMLElement.h
     // Error: type "const char*" can not automatically bind
     // bool XPathQuery::SetVariable(const String& name, const XPathResultSet& value) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XPathQuery", "bool SetVariable(const String&in, const XPathResultSet&in)", asMETHODPR(XPathQuery, SetVariable, (const String&, const XPathResultSet&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XPathQuery", "bool SetVariable(const String&in, const XPathResultSet&in)", AS_METHODPR(XPathQuery, SetVariable, (const String&, const XPathResultSet&), bool), AS_CALL_THISCALL);
     // explicit XPathQuery::XPathQuery(const String& queryString, const String& variableString=String::EMPTY) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectBehaviour("XPathQuery", asBEHAVE_CONSTRUCT, "void f(const String&in, const String&in = String::EMPTY)", asFUNCTION(XPathQuery_XPathQuery_String_String), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("XPathQuery", asBEHAVE_CONSTRUCT, "void f(const String&in, const String&in = String::EMPTY)", AS_FUNCTION_OBJFIRST(XPathQuery_XPathQuery_String_String), AS_CALL_CDECL_OBJFIRST);
     // XPathQuery& XPathQuery::operator=(const XPathQuery&) | Possible implicitly-declared
     RegisterImplicitlyDeclaredAssignOperatorIfPossible<XPathQuery>(engine, "XPathQuery");
 #ifdef REGISTER_MANUAL_PART_XPathQuery
@@ -526,24 +526,24 @@ void ASRegisterGenerated_Members_X(asIScriptEngine* engine)
 #endif
 
     // bool XPathResultSet::Empty() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XPathResultSet", "bool Empty() const", asMETHODPR(XPathResultSet, Empty, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XPathResultSet", "bool get_empty() const", asMETHODPR(XPathResultSet, Empty, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XPathResultSet", "bool Empty() const", AS_METHODPR(XPathResultSet, Empty, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XPathResultSet", "bool get_empty() const", AS_METHODPR(XPathResultSet, Empty, () const, bool), AS_CALL_THISCALL);
     // XMLElement XPathResultSet::FirstResult() | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XPathResultSet", "XMLElement FirstResult()", asMETHODPR(XPathResultSet, FirstResult, (), XMLElement), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XPathResultSet", "XMLElement get_firstResult()", asMETHODPR(XPathResultSet, FirstResult, (), XMLElement), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XPathResultSet", "XMLElement FirstResult()", AS_METHODPR(XPathResultSet, FirstResult, (), XMLElement), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XPathResultSet", "XMLElement get_firstResult()", AS_METHODPR(XPathResultSet, FirstResult, (), XMLElement), AS_CALL_THISCALL);
     // pugi::xpath_node_set* XPathResultSet::GetXPathNodeSet() const | File: ../Resource/XMLElement.h
     // Error: type "pugi::xpath_node_set*" can not automatically bind
     // XPathResultSet& XPathResultSet::operator=(const XPathResultSet& rhs) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XPathResultSet", "XPathResultSet& opAssign(const XPathResultSet&in)", asMETHODPR(XPathResultSet, operator=, (const XPathResultSet&), XPathResultSet&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XPathResultSet", "XPathResultSet& opAssign(const XPathResultSet&in)", AS_METHODPR(XPathResultSet, operator=, (const XPathResultSet&), XPathResultSet&), AS_CALL_THISCALL);
     // XMLElement XPathResultSet::operator[](unsigned index) const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XPathResultSet", "XMLElement opIndex(uint) const", asMETHODPR(XPathResultSet, operator[], (unsigned) const, XMLElement), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XPathResultSet", "XMLElement opIndex(uint) const", AS_METHODPR(XPathResultSet, operator[], (unsigned) const, XMLElement), AS_CALL_THISCALL);
     // unsigned XPathResultSet::Size() const | File: ../Resource/XMLElement.h
-    engine->RegisterObjectMethod("XPathResultSet", "uint Size() const", asMETHODPR(XPathResultSet, Size, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("XPathResultSet", "uint get_size() const", asMETHODPR(XPathResultSet, Size, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("XPathResultSet", "uint Size() const", AS_METHODPR(XPathResultSet, Size, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("XPathResultSet", "uint get_size() const", AS_METHODPR(XPathResultSet, Size, () const, unsigned), AS_CALL_THISCALL);
     // XPathResultSet::XPathResultSet(XMLFile* file, pugi::xpath_node_set* resultSet) | File: ../Resource/XMLElement.h
     // Error: type "pugi::xpath_node_set*" can not automatically bind
     // XPathResultSet::XPathResultSet(const XPathResultSet& rhs) | File: ../Resource/XMLElement.h
-    engine->RegisterObjectBehaviour("XPathResultSet", asBEHAVE_CONSTRUCT, "void f(const XPathResultSet&in)", asFUNCTION(XPathResultSet_XPathResultSet_XPathResultSet), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectBehaviour("XPathResultSet", asBEHAVE_CONSTRUCT, "void f(const XPathResultSet&in)", AS_FUNCTION_OBJFIRST(XPathResultSet_XPathResultSet_XPathResultSet), AS_CALL_CDECL_OBJFIRST);
 #ifdef REGISTER_MANUAL_PART_XPathResultSet
     REGISTER_MANUAL_PART_XPathResultSet(XPathResultSet, "XPathResultSet")
 #endif

Source/Urho3D/AngelScript/Generated_Members_Z.cpp

@@ -42,17 +42,17 @@ static Zone* Zone_Zone_Context()
 void ASRegisterGenerated_Members_Z(asIScriptEngine* engine)
 {
     // void Drawable::AddLight(Light* light) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void AddLight(Light@+)", asMETHODPR(Zone, AddLight, (Light*), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void AddLight(Light@+)", AS_METHODPR(Zone, AddLight, (Light*), void), AS_CALL_THISCALL);
     // void RefCounted::AddRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour("Zone", asBEHAVE_ADDREF, "void f()", asMETHODPR(Zone, AddRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour("Zone", asBEHAVE_ADDREF, "void f()", AS_METHODPR(Zone, AddRef, (), void), AS_CALL_THISCALL);
     // void Component::AddReplicationState(ComponentReplicationState* state) | File: ../Scene/Component.h
     // Error: type "ComponentReplicationState*" can not automatically bind
     // void Drawable::AddVertexLight(Light* light) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void AddVertexLight(Light@+)", asMETHODPR(Zone, AddVertexLight, (Light*), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void AddVertexLight(Light@+)", AS_METHODPR(Zone, AddVertexLight, (Light*), void), AS_CALL_THISCALL);
     // void Serializable::AllocateNetworkState() | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "void AllocateNetworkState()", asMETHODPR(Zone, AllocateNetworkState, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void AllocateNetworkState()", AS_METHODPR(Zone, AllocateNetworkState, (), void), AS_CALL_THISCALL);
     // virtual void Serializable::ApplyAttributes() | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "void ApplyAttributes()", asMETHODPR(Zone, ApplyAttributes, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void ApplyAttributes()", AS_METHODPR(Zone, ApplyAttributes, (), void), AS_CALL_THISCALL);
     // template<typename T> T* Object::Cast() | File: ../Core/Object.h
     // Not registered because template
     // template<typename T> const T* Object::Cast() const | File: ../Core/Object.h
@@ -60,59 +60,59 @@ void ASRegisterGenerated_Members_Z(asIScriptEngine* engine)
     // void Component::CleanupConnection(Connection* connection) | File: ../Scene/Component.h
     // Not registered because have @manualbind mark
     // void Zone::DrawDebugGeometry(DebugRenderer* debug, bool depthTest) override | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "void DrawDebugGeometry(DebugRenderer@+, bool)", asMETHODPR(Zone, DrawDebugGeometry, (DebugRenderer*, bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void DrawDebugGeometry(DebugRenderer@+, bool)", AS_METHODPR(Zone, DrawDebugGeometry, (DebugRenderer*, bool), void), AS_CALL_THISCALL);
     // virtual bool Drawable::DrawOcclusion(OcclusionBuffer* buffer) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "bool DrawOcclusion(OcclusionBuffer@+)", asMETHODPR(Zone, DrawOcclusion, (OcclusionBuffer*), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool DrawOcclusion(OcclusionBuffer@+)", AS_METHODPR(Zone, DrawOcclusion, (OcclusionBuffer*), bool), AS_CALL_THISCALL);
     // const Color& Zone::GetAmbientColor() const | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "const Color& GetAmbientColor() const", asMETHODPR(Zone, GetAmbientColor, () const, const Color&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "const Color& get_ambientColor() const", asMETHODPR(Zone, GetAmbientColor, () const, const Color&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const Color& GetAmbientColor() const", AS_METHODPR(Zone, GetAmbientColor, () const, const Color&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const Color& get_ambientColor() const", AS_METHODPR(Zone, GetAmbientColor, () const, const Color&), AS_CALL_THISCALL);
     // const Color& Zone::GetAmbientEndColor() | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "const Color& GetAmbientEndColor()", asMETHODPR(Zone, GetAmbientEndColor, (), const Color&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "const Color& get_ambientEndColor()", asMETHODPR(Zone, GetAmbientEndColor, (), const Color&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const Color& GetAmbientEndColor()", AS_METHODPR(Zone, GetAmbientEndColor, (), const Color&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const Color& get_ambientEndColor()", AS_METHODPR(Zone, GetAmbientEndColor, (), const Color&), AS_CALL_THISCALL);
     // bool Zone::GetAmbientGradient() const | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "bool GetAmbientGradient() const", asMETHODPR(Zone, GetAmbientGradient, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "bool get_ambientGradient() const", asMETHODPR(Zone, GetAmbientGradient, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool GetAmbientGradient() const", AS_METHODPR(Zone, GetAmbientGradient, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool get_ambientGradient() const", AS_METHODPR(Zone, GetAmbientGradient, () const, bool), AS_CALL_THISCALL);
     // const Color& Zone::GetAmbientStartColor() | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "const Color& GetAmbientStartColor()", asMETHODPR(Zone, GetAmbientStartColor, (), const Color&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "const Color& get_ambientStartColor()", asMETHODPR(Zone, GetAmbientStartColor, (), const Color&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const Color& GetAmbientStartColor()", AS_METHODPR(Zone, GetAmbientStartColor, (), const Color&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const Color& get_ambientStartColor()", AS_METHODPR(Zone, GetAmbientStartColor, (), const Color&), AS_CALL_THISCALL);
     // bool Animatable::GetAnimationEnabled() const | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod("Zone", "bool GetAnimationEnabled() const", asMETHODPR(Zone, GetAnimationEnabled, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "bool get_animationEnabled() const", asMETHODPR(Zone, GetAnimationEnabled, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool GetAnimationEnabled() const", AS_METHODPR(Zone, GetAnimationEnabled, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool get_animationEnabled() const", AS_METHODPR(Zone, GetAnimationEnabled, () const, bool), AS_CALL_THISCALL);
     // Variant Serializable::GetAttribute(unsigned index) const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "Variant GetAttribute(uint) const", asMETHODPR(Zone, GetAttribute, (unsigned) const, Variant), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "Variant get_attributes(uint) const", asMETHODPR(Zone, GetAttribute, (unsigned) const, Variant), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "Variant GetAttribute(uint) const", AS_METHODPR(Zone, GetAttribute, (unsigned) const, Variant), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "Variant get_attributes(uint) const", AS_METHODPR(Zone, GetAttribute, (unsigned) const, Variant), AS_CALL_THISCALL);
     // Variant Serializable::GetAttribute(const String& name) const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "Variant GetAttribute(const String&in) const", asMETHODPR(Zone, GetAttribute, (const String&) const, Variant), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "Variant GetAttribute(const String&in) const", AS_METHODPR(Zone, GetAttribute, (const String&) const, Variant), AS_CALL_THISCALL);
     // ValueAnimation* Animatable::GetAttributeAnimation(const String& name) const | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod("Zone", "ValueAnimation@+ GetAttributeAnimation(const String&in) const", asMETHODPR(Zone, GetAttributeAnimation, (const String&) const, ValueAnimation*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "ValueAnimation@+ GetAttributeAnimation(const String&in) const", AS_METHODPR(Zone, GetAttributeAnimation, (const String&) const, ValueAnimation*), AS_CALL_THISCALL);
     // float Animatable::GetAttributeAnimationSpeed(const String& name) const | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod("Zone", "float GetAttributeAnimationSpeed(const String&in) const", asMETHODPR(Zone, GetAttributeAnimationSpeed, (const String&) const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float GetAttributeAnimationSpeed(const String&in) const", AS_METHODPR(Zone, GetAttributeAnimationSpeed, (const String&) const, float), AS_CALL_THISCALL);
     // float Animatable::GetAttributeAnimationTime(const String& name) const | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod("Zone", "float GetAttributeAnimationTime(const String&in) const", asMETHODPR(Zone, GetAttributeAnimationTime, (const String&) const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float GetAttributeAnimationTime(const String&in) const", AS_METHODPR(Zone, GetAttributeAnimationTime, (const String&) const, float), AS_CALL_THISCALL);
     // WrapMode Animatable::GetAttributeAnimationWrapMode(const String& name) const | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod("Zone", "WrapMode GetAttributeAnimationWrapMode(const String&in) const", asMETHODPR(Zone, GetAttributeAnimationWrapMode, (const String&) const, WrapMode), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "WrapMode GetAttributeAnimationWrapMode(const String&in) const", AS_METHODPR(Zone, GetAttributeAnimationWrapMode, (const String&) const, WrapMode), AS_CALL_THISCALL);
     // Variant Serializable::GetAttributeDefault(unsigned index) const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "Variant GetAttributeDefault(uint) const", asMETHODPR(Zone, GetAttributeDefault, (unsigned) const, Variant), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "Variant get_attributeDefaults(uint) const", asMETHODPR(Zone, GetAttributeDefault, (unsigned) const, Variant), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "Variant GetAttributeDefault(uint) const", AS_METHODPR(Zone, GetAttributeDefault, (unsigned) const, Variant), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "Variant get_attributeDefaults(uint) const", AS_METHODPR(Zone, GetAttributeDefault, (unsigned) const, Variant), AS_CALL_THISCALL);
     // Variant Serializable::GetAttributeDefault(const String& name) const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "Variant GetAttributeDefault(const String&in) const", asMETHODPR(Zone, GetAttributeDefault, (const String&) const, Variant), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "Variant GetAttributeDefault(const String&in) const", AS_METHODPR(Zone, GetAttributeDefault, (const String&) const, Variant), AS_CALL_THISCALL);
     // virtual const Vector<AttributeInfo>* Serializable::GetAttributes() const | File: ../Scene/Serializable.h
     // Error: type "const Vector<AttributeInfo>*" can not automatically bind
     // const Vector<SourceBatch>& Drawable::GetBatches() const | File: ../Graphics/Drawable.h
     // Error: type "const Vector<SourceBatch>&" can not automatically bind
     // bool Object::GetBlockEvents() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "bool GetBlockEvents() const", asMETHODPR(Zone, GetBlockEvents, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool GetBlockEvents() const", AS_METHODPR(Zone, GetBlockEvents, () const, bool), AS_CALL_THISCALL);
     // const BoundingBox& Drawable::GetBoundingBox() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "const BoundingBox& GetBoundingBox() const", asMETHODPR(Zone, GetBoundingBox, () const, const BoundingBox&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "const BoundingBox& get_boundingBox() const", asMETHODPR(Zone, GetBoundingBox, () const, const BoundingBox&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const BoundingBox& GetBoundingBox() const", AS_METHODPR(Zone, GetBoundingBox, () const, const BoundingBox&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const BoundingBox& get_boundingBox() const", AS_METHODPR(Zone, GetBoundingBox, () const, const BoundingBox&), AS_CALL_THISCALL);
     // bool Drawable::GetCastShadows() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "bool GetCastShadows() const", asMETHODPR(Zone, GetCastShadows, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "bool get_castShadows() const", asMETHODPR(Zone, GetCastShadows, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool GetCastShadows() const", AS_METHODPR(Zone, GetCastShadows, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool get_castShadows() const", AS_METHODPR(Zone, GetCastShadows, () const, bool), AS_CALL_THISCALL);
     // const String& Object::GetCategory() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "const String& GetCategory() const", asMETHODPR(Zone, GetCategory, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "const String& get_category() const", asMETHODPR(Zone, GetCategory, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const String& GetCategory() const", AS_METHODPR(Zone, GetCategory, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const String& get_category() const", AS_METHODPR(Zone, GetCategory, () const, const String&), AS_CALL_THISCALL);
     // Component* Component::GetComponent(StringHash type) const | File: ../Scene/Component.h
-    engine->RegisterObjectMethod("Zone", "Component@+ GetComponent(StringHash) const", asMETHODPR(Zone, GetComponent, (StringHash) const, Component*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "Component@+ GetComponent(StringHash) const", AS_METHODPR(Zone, GetComponent, (StringHash) const, Component*), AS_CALL_THISCALL);
     // template<class T> T* Component::GetComponent() const | File: ../Scene/Component.h
     // Not registered because template
     // void Component::GetComponents(PODVector<Component*>& dest, StringHash type) const | File: ../Scene/Component.h
@@ -124,370 +124,370 @@ void ASRegisterGenerated_Members_Z(asIScriptEngine* engine)
     // virtual void Component::GetDependencyNodes(PODVector<Node*>& dest) | File: ../Scene/Component.h
     // Error: type "PODVector<Node*>&" can not automatically bind
     // float Drawable::GetDistance() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "float GetDistance() const", asMETHODPR(Zone, GetDistance, () const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float GetDistance() const", AS_METHODPR(Zone, GetDistance, () const, float), AS_CALL_THISCALL);
     // unsigned char Drawable::GetDrawableFlags() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "uint8 GetDrawableFlags() const", asMETHODPR(Zone, GetDrawableFlags, () const, unsigned char), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "uint8 GetDrawableFlags() const", AS_METHODPR(Zone, GetDrawableFlags, () const, unsigned char), AS_CALL_THISCALL);
     // float Drawable::GetDrawDistance() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "float GetDrawDistance() const", asMETHODPR(Zone, GetDrawDistance, () const, float), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "float get_drawDistance() const", asMETHODPR(Zone, GetDrawDistance, () const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float GetDrawDistance() const", AS_METHODPR(Zone, GetDrawDistance, () const, float), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float get_drawDistance() const", AS_METHODPR(Zone, GetDrawDistance, () const, float), AS_CALL_THISCALL);
     // VariantMap& Object::GetEventDataMap() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "VariantMap& GetEventDataMap() const", asMETHODPR(Zone, GetEventDataMap, () const, VariantMap&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "VariantMap& GetEventDataMap() const", AS_METHODPR(Zone, GetEventDataMap, () const, VariantMap&), AS_CALL_THISCALL);
     // EventHandler* Object::GetEventHandler() const | File: ../Core/Object.h
     // Error: type "EventHandler*" can not automatically bind
     // Object* Object::GetEventSender() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "Object@+ GetEventSender() const", asMETHODPR(Zone, GetEventSender, () const, Object*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "Object@+ GetEventSender() const", AS_METHODPR(Zone, GetEventSender, () const, Object*), AS_CALL_THISCALL);
     // Light* Drawable::GetFirstLight() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "Light@+ GetFirstLight() const", asMETHODPR(Zone, GetFirstLight, () const, Light*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "Light@+ GetFirstLight() const", AS_METHODPR(Zone, GetFirstLight, () const, Light*), AS_CALL_THISCALL);
     // const Color& Zone::GetFogColor() const | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "const Color& GetFogColor() const", asMETHODPR(Zone, GetFogColor, () const, const Color&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "const Color& get_fogColor() const", asMETHODPR(Zone, GetFogColor, () const, const Color&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const Color& GetFogColor() const", AS_METHODPR(Zone, GetFogColor, () const, const Color&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const Color& get_fogColor() const", AS_METHODPR(Zone, GetFogColor, () const, const Color&), AS_CALL_THISCALL);
     // float Zone::GetFogEnd() const | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "float GetFogEnd() const", asMETHODPR(Zone, GetFogEnd, () const, float), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "float get_fogEnd() const", asMETHODPR(Zone, GetFogEnd, () const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float GetFogEnd() const", AS_METHODPR(Zone, GetFogEnd, () const, float), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float get_fogEnd() const", AS_METHODPR(Zone, GetFogEnd, () const, float), AS_CALL_THISCALL);
     // float Zone::GetFogHeight() const | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "float GetFogHeight() const", asMETHODPR(Zone, GetFogHeight, () const, float), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "float get_fogHeight() const", asMETHODPR(Zone, GetFogHeight, () const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float GetFogHeight() const", AS_METHODPR(Zone, GetFogHeight, () const, float), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float get_fogHeight() const", AS_METHODPR(Zone, GetFogHeight, () const, float), AS_CALL_THISCALL);
     // float Zone::GetFogHeightScale() const | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "float GetFogHeightScale() const", asMETHODPR(Zone, GetFogHeightScale, () const, float), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "float get_fogHeightScale() const", asMETHODPR(Zone, GetFogHeightScale, () const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float GetFogHeightScale() const", AS_METHODPR(Zone, GetFogHeightScale, () const, float), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float get_fogHeightScale() const", AS_METHODPR(Zone, GetFogHeightScale, () const, float), AS_CALL_THISCALL);
     // float Zone::GetFogStart() const | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "float GetFogStart() const", asMETHODPR(Zone, GetFogStart, () const, float), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "float get_fogStart() const", asMETHODPR(Zone, GetFogStart, () const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float GetFogStart() const", AS_METHODPR(Zone, GetFogStart, () const, float), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float get_fogStart() const", AS_METHODPR(Zone, GetFogStart, () const, float), AS_CALL_THISCALL);
     // const Variant& Object::GetGlobalVar(StringHash key) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "const Variant& GetGlobalVar(StringHash) const", asMETHODPR(Zone, GetGlobalVar, (StringHash) const, const Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "const Variant& get_globalVar(StringHash) const", asMETHODPR(Zone, GetGlobalVar, (StringHash) const, const Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const Variant& GetGlobalVar(StringHash) const", AS_METHODPR(Zone, GetGlobalVar, (StringHash) const, const Variant&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const Variant& get_globalVar(StringHash) const", AS_METHODPR(Zone, GetGlobalVar, (StringHash) const, const Variant&), AS_CALL_THISCALL);
     // const VariantMap& Object::GetGlobalVars() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "const VariantMap& GetGlobalVars() const", asMETHODPR(Zone, GetGlobalVars, () const, const VariantMap&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "const VariantMap& get_globalVars() const", asMETHODPR(Zone, GetGlobalVars, () const, const VariantMap&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const VariantMap& GetGlobalVars() const", AS_METHODPR(Zone, GetGlobalVars, () const, const VariantMap&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const VariantMap& get_globalVars() const", AS_METHODPR(Zone, GetGlobalVars, () const, const VariantMap&), AS_CALL_THISCALL);
     // bool Zone::GetHeightFog() const | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "bool GetHeightFog() const", asMETHODPR(Zone, GetHeightFog, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "bool get_heightFog() const", asMETHODPR(Zone, GetHeightFog, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool GetHeightFog() const", AS_METHODPR(Zone, GetHeightFog, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool get_heightFog() const", AS_METHODPR(Zone, GetHeightFog, () const, bool), AS_CALL_THISCALL);
     // unsigned Component::GetID() const | File: ../Scene/Component.h
-    engine->RegisterObjectMethod("Zone", "uint GetID() const", asMETHODPR(Zone, GetID, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "uint get_id() const", asMETHODPR(Zone, GetID, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "uint GetID() const", AS_METHODPR(Zone, GetID, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "uint get_id() const", AS_METHODPR(Zone, GetID, () const, unsigned), AS_CALL_THISCALL);
     // bool Serializable::GetInterceptNetworkUpdate(const String& attributeName) const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "bool GetInterceptNetworkUpdate(const String&in) const", asMETHODPR(Zone, GetInterceptNetworkUpdate, (const String&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool GetInterceptNetworkUpdate(const String&in) const", AS_METHODPR(Zone, GetInterceptNetworkUpdate, (const String&) const, bool), AS_CALL_THISCALL);
     // const Matrix3x4& Zone::GetInverseWorldTransform() const | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "const Matrix3x4& GetInverseWorldTransform() const", asMETHODPR(Zone, GetInverseWorldTransform, () const, const Matrix3x4&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "const Matrix3x4& get_inverseWorldTransform() const", asMETHODPR(Zone, GetInverseWorldTransform, () const, const Matrix3x4&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const Matrix3x4& GetInverseWorldTransform() const", AS_METHODPR(Zone, GetInverseWorldTransform, () const, const Matrix3x4&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const Matrix3x4& get_inverseWorldTransform() const", AS_METHODPR(Zone, GetInverseWorldTransform, () const, const Matrix3x4&), AS_CALL_THISCALL);
     // unsigned Drawable::GetLightMask() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "uint GetLightMask() const", asMETHODPR(Zone, GetLightMask, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "uint get_lightMask() const", asMETHODPR(Zone, GetLightMask, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "uint GetLightMask() const", AS_METHODPR(Zone, GetLightMask, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "uint get_lightMask() const", AS_METHODPR(Zone, GetLightMask, () const, unsigned), AS_CALL_THISCALL);
     // const PODVector<Light*>& Drawable::GetLights() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "Array<Light@>@ GetLights() const", asFUNCTION(Zone_GetLights_void), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod("Zone", "Array<Light@>@ GetLights() const", AS_FUNCTION_OBJFIRST(Zone_GetLights_void), AS_CALL_CDECL_OBJFIRST);
     // float Drawable::GetLodBias() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "float GetLodBias() const", asMETHODPR(Zone, GetLodBias, () const, float), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "float get_lodBias() const", asMETHODPR(Zone, GetLodBias, () const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float GetLodBias() const", AS_METHODPR(Zone, GetLodBias, () const, float), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float get_lodBias() const", AS_METHODPR(Zone, GetLodBias, () const, float), AS_CALL_THISCALL);
     // float Drawable::GetLodDistance() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "float GetLodDistance() const", asMETHODPR(Zone, GetLodDistance, () const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float GetLodDistance() const", AS_METHODPR(Zone, GetLodDistance, () const, float), AS_CALL_THISCALL);
     // virtual Geometry* Drawable::GetLodGeometry(unsigned batchIndex, unsigned level) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "Geometry@+ GetLodGeometry(uint, uint)", asMETHODPR(Zone, GetLodGeometry, (unsigned, unsigned), Geometry*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "Geometry@+ GetLodGeometry(uint, uint)", AS_METHODPR(Zone, GetLodGeometry, (unsigned, unsigned), Geometry*), AS_CALL_THISCALL);
     // unsigned Drawable::GetMaxLights() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "uint GetMaxLights() const", asMETHODPR(Zone, GetMaxLights, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "uint get_maxLights() const", asMETHODPR(Zone, GetMaxLights, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "uint GetMaxLights() const", AS_METHODPR(Zone, GetMaxLights, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "uint get_maxLights() const", AS_METHODPR(Zone, GetMaxLights, () const, unsigned), AS_CALL_THISCALL);
     // float Drawable::GetMaxZ() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "float GetMaxZ() const", asMETHODPR(Zone, GetMaxZ, () const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float GetMaxZ() const", AS_METHODPR(Zone, GetMaxZ, () const, float), AS_CALL_THISCALL);
     // float Drawable::GetMinZ() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "float GetMinZ() const", asMETHODPR(Zone, GetMinZ, () const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float GetMinZ() const", AS_METHODPR(Zone, GetMinZ, () const, float), AS_CALL_THISCALL);
     // virtual const Vector<AttributeInfo>* Serializable::GetNetworkAttributes() const | File: ../Scene/Serializable.h
     // Error: type "const Vector<AttributeInfo>*" can not automatically bind
     // NetworkState* Serializable::GetNetworkState() const | File: ../Scene/Serializable.h
     // Error: type "NetworkState*" can not automatically bind
     // Node* Component::GetNode() const | File: ../Scene/Component.h
-    engine->RegisterObjectMethod("Zone", "Node@+ GetNode() const", asMETHODPR(Zone, GetNode, () const, Node*), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "Node@+ get_node() const", asMETHODPR(Zone, GetNode, () const, Node*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "Node@+ GetNode() const", AS_METHODPR(Zone, GetNode, () const, Node*), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "Node@+ get_node() const", AS_METHODPR(Zone, GetNode, () const, Node*), AS_CALL_THISCALL);
     // unsigned Serializable::GetNumAttributes() const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "uint GetNumAttributes() const", asMETHODPR(Zone, GetNumAttributes, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "uint get_numAttributes() const", asMETHODPR(Zone, GetNumAttributes, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "uint GetNumAttributes() const", AS_METHODPR(Zone, GetNumAttributes, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "uint get_numAttributes() const", AS_METHODPR(Zone, GetNumAttributes, () const, unsigned), AS_CALL_THISCALL);
     // unsigned Serializable::GetNumNetworkAttributes() const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "uint GetNumNetworkAttributes() const", asMETHODPR(Zone, GetNumNetworkAttributes, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "uint GetNumNetworkAttributes() const", AS_METHODPR(Zone, GetNumNetworkAttributes, () const, unsigned), AS_CALL_THISCALL);
     // virtual unsigned Drawable::GetNumOccluderTriangles() | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "uint GetNumOccluderTriangles()", asMETHODPR(Zone, GetNumOccluderTriangles, (), unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "uint GetNumOccluderTriangles()", AS_METHODPR(Zone, GetNumOccluderTriangles, (), unsigned), AS_CALL_THISCALL);
     // ObjectAnimation* Animatable::GetObjectAnimation() const | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod("Zone", "ObjectAnimation@+ GetObjectAnimation() const", asMETHODPR(Zone, GetObjectAnimation, () const, ObjectAnimation*), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "ObjectAnimation@+ get_objectAnimation() const", asMETHODPR(Zone, GetObjectAnimation, () const, ObjectAnimation*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "ObjectAnimation@+ GetObjectAnimation() const", AS_METHODPR(Zone, GetObjectAnimation, () const, ObjectAnimation*), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "ObjectAnimation@+ get_objectAnimation() const", AS_METHODPR(Zone, GetObjectAnimation, () const, ObjectAnimation*), AS_CALL_THISCALL);
     // ResourceRef Animatable::GetObjectAnimationAttr() const | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod("Zone", "ResourceRef GetObjectAnimationAttr() const", asMETHODPR(Zone, GetObjectAnimationAttr, () const, ResourceRef), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "ResourceRef GetObjectAnimationAttr() const", AS_METHODPR(Zone, GetObjectAnimationAttr, () const, ResourceRef), AS_CALL_THISCALL);
     // Octant* Drawable::GetOctant() const | File: ../Graphics/Drawable.h
     // Error: type "Octant" can not automatically bind bacause have @nobind mark
     // bool Zone::GetOverride() const | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "bool GetOverride() const", asMETHODPR(Zone, GetOverride, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "bool get_override() const", asMETHODPR(Zone, GetOverride, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool GetOverride() const", AS_METHODPR(Zone, GetOverride, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool get_override() const", AS_METHODPR(Zone, GetOverride, () const, bool), AS_CALL_THISCALL);
     // int Zone::GetPriority() const | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "int GetPriority() const", asMETHODPR(Zone, GetPriority, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "int get_priority() const", asMETHODPR(Zone, GetPriority, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "int GetPriority() const", AS_METHODPR(Zone, GetPriority, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "int get_priority() const", AS_METHODPR(Zone, GetPriority, () const, int), AS_CALL_THISCALL);
     // Scene* Component::GetScene() const | File: ../Scene/Component.h
-    engine->RegisterObjectMethod("Zone", "Scene@+ GetScene() const", asMETHODPR(Zone, GetScene, () const, Scene*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "Scene@+ GetScene() const", AS_METHODPR(Zone, GetScene, () const, Scene*), AS_CALL_THISCALL);
     // float Drawable::GetShadowDistance() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "float GetShadowDistance() const", asMETHODPR(Zone, GetShadowDistance, () const, float), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "float get_shadowDistance() const", asMETHODPR(Zone, GetShadowDistance, () const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float GetShadowDistance() const", AS_METHODPR(Zone, GetShadowDistance, () const, float), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float get_shadowDistance() const", AS_METHODPR(Zone, GetShadowDistance, () const, float), AS_CALL_THISCALL);
     // unsigned Drawable::GetShadowMask() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "uint GetShadowMask() const", asMETHODPR(Zone, GetShadowMask, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "uint get_shadowMask() const", asMETHODPR(Zone, GetShadowMask, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "uint GetShadowMask() const", AS_METHODPR(Zone, GetShadowMask, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "uint get_shadowMask() const", AS_METHODPR(Zone, GetShadowMask, () const, unsigned), AS_CALL_THISCALL);
     // float Drawable::GetSortValue() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "float GetSortValue() const", asMETHODPR(Zone, GetSortValue, () const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "float GetSortValue() const", AS_METHODPR(Zone, GetSortValue, () const, float), AS_CALL_THISCALL);
     // Object* Object::GetSubsystem(StringHash type) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "Object@+ GetSubsystem(StringHash) const", asMETHODPR(Zone, GetSubsystem, (StringHash) const, Object*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "Object@+ GetSubsystem(StringHash) const", AS_METHODPR(Zone, GetSubsystem, (StringHash) const, Object*), AS_CALL_THISCALL);
     // template<class T> T* Object::GetSubsystem() const | File: ../Core/Object.h
     // Not registered because template
     // virtual StringHash Object::GetType() const =0 | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "StringHash GetType() const", asMETHODPR(Zone, GetType, () const, StringHash), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "StringHash get_type() const", asMETHODPR(Zone, GetType, () const, StringHash), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "StringHash GetType() const", AS_METHODPR(Zone, GetType, () const, StringHash), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "StringHash get_type() const", AS_METHODPR(Zone, GetType, () const, StringHash), AS_CALL_THISCALL);
     // virtual const TypeInfo* Object::GetTypeInfo() const =0 | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // static const TypeInfo* Object::GetTypeInfoStatic() | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // virtual const String& Object::GetTypeName() const =0 | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "const String& GetTypeName() const", asMETHODPR(Zone, GetTypeName, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "const String& get_typeName() const", asMETHODPR(Zone, GetTypeName, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const String& GetTypeName() const", AS_METHODPR(Zone, GetTypeName, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const String& get_typeName() const", AS_METHODPR(Zone, GetTypeName, () const, const String&), AS_CALL_THISCALL);
     // virtual UpdateGeometryType Drawable::GetUpdateGeometryType() | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "UpdateGeometryType GetUpdateGeometryType()", asMETHODPR(Zone, GetUpdateGeometryType, (), UpdateGeometryType), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "UpdateGeometryType GetUpdateGeometryType()", AS_METHODPR(Zone, GetUpdateGeometryType, (), UpdateGeometryType), AS_CALL_THISCALL);
     // const PODVector<Light*>& Drawable::GetVertexLights() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "Array<Light@>@ GetVertexLights() const", asFUNCTION(Zone_GetVertexLights_void), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod("Zone", "Array<Light@>@ GetVertexLights() const", AS_FUNCTION_OBJFIRST(Zone_GetVertexLights_void), AS_CALL_CDECL_OBJFIRST);
     // unsigned Drawable::GetViewMask() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "uint GetViewMask() const", asMETHODPR(Zone, GetViewMask, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "uint get_viewMask() const", asMETHODPR(Zone, GetViewMask, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "uint GetViewMask() const", AS_METHODPR(Zone, GetViewMask, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "uint get_viewMask() const", AS_METHODPR(Zone, GetViewMask, () const, unsigned), AS_CALL_THISCALL);
     // const BoundingBox& Drawable::GetWorldBoundingBox() | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "const BoundingBox& GetWorldBoundingBox()", asMETHODPR(Zone, GetWorldBoundingBox, (), const BoundingBox&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "const BoundingBox& get_worldBoundingBox()", asMETHODPR(Zone, GetWorldBoundingBox, (), const BoundingBox&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const BoundingBox& GetWorldBoundingBox()", AS_METHODPR(Zone, GetWorldBoundingBox, (), const BoundingBox&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "const BoundingBox& get_worldBoundingBox()", AS_METHODPR(Zone, GetWorldBoundingBox, (), const BoundingBox&), AS_CALL_THISCALL);
     // Zone* Drawable::GetZone() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "Zone@+ GetZone() const", asMETHODPR(Zone, GetZone, () const, Zone*), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "Zone@+ get_zone() const", asMETHODPR(Zone, GetZone, () const, Zone*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "Zone@+ GetZone() const", AS_METHODPR(Zone, GetZone, () const, Zone*), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "Zone@+ get_zone() const", AS_METHODPR(Zone, GetZone, () const, Zone*), AS_CALL_THISCALL);
     // unsigned Drawable::GetZoneMask() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "uint GetZoneMask() const", asMETHODPR(Zone, GetZoneMask, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "uint get_zoneMask() const", asMETHODPR(Zone, GetZoneMask, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "uint GetZoneMask() const", AS_METHODPR(Zone, GetZoneMask, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "uint get_zoneMask() const", AS_METHODPR(Zone, GetZoneMask, () const, unsigned), AS_CALL_THISCALL);
     // Texture* Zone::GetZoneTexture() const | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "Texture@+ GetZoneTexture() const", asMETHODPR(Zone, GetZoneTexture, () const, Texture*), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "Texture@+ get_zoneTexture() const", asMETHODPR(Zone, GetZoneTexture, () const, Texture*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "Texture@+ GetZoneTexture() const", AS_METHODPR(Zone, GetZoneTexture, () const, Texture*), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "Texture@+ get_zoneTexture() const", AS_METHODPR(Zone, GetZoneTexture, () const, Texture*), AS_CALL_THISCALL);
     // ResourceRef Zone::GetZoneTextureAttr() const | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "ResourceRef GetZoneTextureAttr() const", asMETHODPR(Zone, GetZoneTextureAttr, () const, ResourceRef), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "ResourceRef GetZoneTextureAttr() const", AS_METHODPR(Zone, GetZoneTextureAttr, () const, ResourceRef), AS_CALL_THISCALL);
     // bool Drawable::HasBasePass(unsigned batchIndex) const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "bool HasBasePass(uint) const", asMETHODPR(Zone, HasBasePass, (unsigned) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool HasBasePass(uint) const", AS_METHODPR(Zone, HasBasePass, (unsigned) const, bool), AS_CALL_THISCALL);
     // bool Object::HasEventHandlers() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "bool HasEventHandlers() const", asMETHODPR(Zone, HasEventHandlers, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool HasEventHandlers() const", AS_METHODPR(Zone, HasEventHandlers, () const, bool), AS_CALL_THISCALL);
     // bool Object::HasSubscribedToEvent(StringHash eventType) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "bool HasSubscribedToEvent(StringHash) const", asMETHODPR(Zone, HasSubscribedToEvent, (StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool HasSubscribedToEvent(StringHash) const", AS_METHODPR(Zone, HasSubscribedToEvent, (StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::HasSubscribedToEvent(Object* sender, StringHash eventType) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "bool HasSubscribedToEvent(Object@+, StringHash) const", asMETHODPR(Zone, HasSubscribedToEvent, (Object*, StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool HasSubscribedToEvent(Object@+, StringHash) const", AS_METHODPR(Zone, HasSubscribedToEvent, (Object*, StringHash) const, bool), AS_CALL_THISCALL);
     // bool Component::IsEnabled() const | File: ../Scene/Component.h
-    engine->RegisterObjectMethod("Zone", "bool IsEnabled() const", asMETHODPR(Zone, IsEnabled, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "bool get_enabled() const", asMETHODPR(Zone, IsEnabled, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool IsEnabled() const", AS_METHODPR(Zone, IsEnabled, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool get_enabled() const", AS_METHODPR(Zone, IsEnabled, () const, bool), AS_CALL_THISCALL);
     // bool Component::IsEnabledEffective() const | File: ../Scene/Component.h
-    engine->RegisterObjectMethod("Zone", "bool IsEnabledEffective() const", asMETHODPR(Zone, IsEnabledEffective, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "bool get_enabledEffective() const", asMETHODPR(Zone, IsEnabledEffective, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool IsEnabledEffective() const", AS_METHODPR(Zone, IsEnabledEffective, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool get_enabledEffective() const", AS_METHODPR(Zone, IsEnabledEffective, () const, bool), AS_CALL_THISCALL);
     // bool Zone::IsInside(const Vector3& point) const | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "bool IsInside(const Vector3&in) const", asMETHODPR(Zone, IsInside, (const Vector3&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool IsInside(const Vector3&in) const", AS_METHODPR(Zone, IsInside, (const Vector3&) const, bool), AS_CALL_THISCALL);
     // bool Object::IsInstanceOf(StringHash type) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "bool IsInstanceOf(StringHash) const", asMETHODPR(Zone, IsInstanceOf, (StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool IsInstanceOf(StringHash) const", AS_METHODPR(Zone, IsInstanceOf, (StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::IsInstanceOf(const TypeInfo* typeInfo) const | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // template<typename T> bool Object::IsInstanceOf() const | File: ../Core/Object.h
     // Not registered because template
     // bool Drawable::IsInView() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "bool IsInView() const", asMETHODPR(Zone, IsInView, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "bool get_inView() const", asMETHODPR(Zone, IsInView, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool IsInView() const", AS_METHODPR(Zone, IsInView, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool get_inView() const", AS_METHODPR(Zone, IsInView, () const, bool), AS_CALL_THISCALL);
     // bool Drawable::IsInView(Camera* camera) const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "bool IsInView(Camera@+) const", asMETHODPR(Zone, IsInView, (Camera*) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool IsInView(Camera@+) const", AS_METHODPR(Zone, IsInView, (Camera*) const, bool), AS_CALL_THISCALL);
     // bool Drawable::IsInView(const FrameInfo& frame, bool anyCamera=false) const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "bool IsInView(const FrameInfo&in, bool = false) const", asMETHODPR(Zone, IsInView, (const FrameInfo&, bool) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool IsInView(const FrameInfo&in, bool = false) const", AS_METHODPR(Zone, IsInView, (const FrameInfo&, bool) const, bool), AS_CALL_THISCALL);
     // bool Drawable::IsOccludee() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "bool IsOccludee() const", asMETHODPR(Zone, IsOccludee, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "bool get_occludee() const", asMETHODPR(Zone, IsOccludee, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool IsOccludee() const", AS_METHODPR(Zone, IsOccludee, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool get_occludee() const", AS_METHODPR(Zone, IsOccludee, () const, bool), AS_CALL_THISCALL);
     // bool Drawable::IsOccluder() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "bool IsOccluder() const", asMETHODPR(Zone, IsOccluder, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "bool get_occluder() const", asMETHODPR(Zone, IsOccluder, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool IsOccluder() const", AS_METHODPR(Zone, IsOccluder, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool get_occluder() const", AS_METHODPR(Zone, IsOccluder, () const, bool), AS_CALL_THISCALL);
     // bool Component::IsReplicated() const | File: ../Scene/Component.h
-    engine->RegisterObjectMethod("Zone", "bool IsReplicated() const", asMETHODPR(Zone, IsReplicated, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "bool get_replicated() const", asMETHODPR(Zone, IsReplicated, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool IsReplicated() const", AS_METHODPR(Zone, IsReplicated, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool get_replicated() const", AS_METHODPR(Zone, IsReplicated, () const, bool), AS_CALL_THISCALL);
     // bool Serializable::IsTemporary() const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "bool IsTemporary() const", asMETHODPR(Zone, IsTemporary, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "bool get_temporary() const", asMETHODPR(Zone, IsTemporary, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool IsTemporary() const", AS_METHODPR(Zone, IsTemporary, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool get_temporary() const", AS_METHODPR(Zone, IsTemporary, () const, bool), AS_CALL_THISCALL);
     // bool Drawable::IsZoneDirty() const | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "bool IsZoneDirty() const", asMETHODPR(Zone, IsZoneDirty, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool IsZoneDirty() const", AS_METHODPR(Zone, IsZoneDirty, () const, bool), AS_CALL_THISCALL);
     // void Drawable::LimitLights() | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void LimitLights()", asMETHODPR(Zone, LimitLights, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void LimitLights()", AS_METHODPR(Zone, LimitLights, (), void), AS_CALL_THISCALL);
     // void Drawable::LimitVertexLights(bool removeConvertedLights) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void LimitVertexLights(bool)", asMETHODPR(Zone, LimitVertexLights, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void LimitVertexLights(bool)", AS_METHODPR(Zone, LimitVertexLights, (bool), void), AS_CALL_THISCALL);
     // virtual bool Serializable::Load(Deserializer& source) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "bool Load(Deserializer&)", asMETHODPR(Zone, Load, (Deserializer&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool Load(Deserializer&)", AS_METHODPR(Zone, Load, (Deserializer&), bool), AS_CALL_THISCALL);
     // bool Animatable::LoadJSON(const JSONValue& source) override | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod("Zone", "bool LoadJSON(const JSONValue&in)", asMETHODPR(Zone, LoadJSON, (const JSONValue&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool LoadJSON(const JSONValue&in)", AS_METHODPR(Zone, LoadJSON, (const JSONValue&), bool), AS_CALL_THISCALL);
     // bool Animatable::LoadXML(const XMLElement& source) override | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod("Zone", "bool LoadXML(const XMLElement&in)", asMETHODPR(Zone, LoadXML, (const XMLElement&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool LoadXML(const XMLElement&in)", AS_METHODPR(Zone, LoadXML, (const XMLElement&), bool), AS_CALL_THISCALL);
     // void Drawable::MarkForUpdate() | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void MarkForUpdate()", asMETHODPR(Zone, MarkForUpdate, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void MarkForUpdate()", AS_METHODPR(Zone, MarkForUpdate, (), void), AS_CALL_THISCALL);
     // void Drawable::MarkInView(const FrameInfo& frame) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void MarkInView(const FrameInfo&in)", asMETHODPR(Zone, MarkInView, (const FrameInfo&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void MarkInView(const FrameInfo&in)", AS_METHODPR(Zone, MarkInView, (const FrameInfo&), void), AS_CALL_THISCALL);
     // void Drawable::MarkInView(unsigned frameNumber) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void MarkInView(uint)", asMETHODPR(Zone, MarkInView, (unsigned), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void MarkInView(uint)", AS_METHODPR(Zone, MarkInView, (unsigned), void), AS_CALL_THISCALL);
     // void Component::MarkNetworkUpdate() override | File: ../Scene/Component.h
-    engine->RegisterObjectMethod("Zone", "void MarkNetworkUpdate()", asMETHODPR(Zone, MarkNetworkUpdate, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void MarkNetworkUpdate()", AS_METHODPR(Zone, MarkNetworkUpdate, (), void), AS_CALL_THISCALL);
     // virtual void Object::OnEvent(Object* sender, StringHash eventType, VariantMap& eventData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "void OnEvent(Object@+, StringHash, VariantMap&)", asMETHODPR(Zone, OnEvent, (Object*, StringHash, VariantMap&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void OnEvent(Object@+, StringHash, VariantMap&)", AS_METHODPR(Zone, OnEvent, (Object*, StringHash, VariantMap&), void), AS_CALL_THISCALL);
     // virtual void Serializable::OnGetAttribute(const AttributeInfo& attr, Variant& dest) const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "void OnGetAttribute(const AttributeInfo&in, Variant&) const", asMETHODPR(Zone, OnGetAttribute, (const AttributeInfo&, Variant&) const, void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void OnGetAttribute(const AttributeInfo&in, Variant&) const", AS_METHODPR(Zone, OnGetAttribute, (const AttributeInfo&, Variant&) const, void), AS_CALL_THISCALL);
     // virtual void Serializable::OnSetAttribute(const AttributeInfo& attr, const Variant& src) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "void OnSetAttribute(const AttributeInfo&in, const Variant&in)", asMETHODPR(Zone, OnSetAttribute, (const AttributeInfo&, const Variant&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void OnSetAttribute(const AttributeInfo&in, const Variant&in)", AS_METHODPR(Zone, OnSetAttribute, (const AttributeInfo&, const Variant&), void), AS_CALL_THISCALL);
     // void Drawable::OnSetEnabled() override | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void OnSetEnabled()", asMETHODPR(Zone, OnSetEnabled, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void OnSetEnabled()", AS_METHODPR(Zone, OnSetEnabled, (), void), AS_CALL_THISCALL);
     // void Component::PrepareNetworkUpdate() | File: ../Scene/Component.h
-    engine->RegisterObjectMethod("Zone", "void PrepareNetworkUpdate()", asMETHODPR(Zone, PrepareNetworkUpdate, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void PrepareNetworkUpdate()", AS_METHODPR(Zone, PrepareNetworkUpdate, (), void), AS_CALL_THISCALL);
     // virtual void Drawable::ProcessRayQuery(const RayOctreeQuery& query, PODVector<RayQueryResult>& results) | File: ../Graphics/Drawable.h
     // Error: type "RayOctreeQuery" can not automatically bind bacause have @nobind mark
     // bool Serializable::ReadDeltaUpdate(Deserializer& source) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "bool ReadDeltaUpdate(Deserializer&)", asMETHODPR(Zone, ReadDeltaUpdate, (Deserializer&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool ReadDeltaUpdate(Deserializer&)", AS_METHODPR(Zone, ReadDeltaUpdate, (Deserializer&), bool), AS_CALL_THISCALL);
     // bool Serializable::ReadLatestDataUpdate(Deserializer& source) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "bool ReadLatestDataUpdate(Deserializer&)", asMETHODPR(Zone, ReadLatestDataUpdate, (Deserializer&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool ReadLatestDataUpdate(Deserializer&)", AS_METHODPR(Zone, ReadLatestDataUpdate, (Deserializer&), bool), AS_CALL_THISCALL);
     // RefCount* RefCounted::RefCountPtr() | File: ../Container/RefCounted.h
     // Error: type "RefCount*" can not automatically bind
     // int RefCounted::Refs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod("Zone", "int Refs() const", asMETHODPR(Zone, Refs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "int get_refs() const", asMETHODPR(Zone, Refs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "int Refs() const", AS_METHODPR(Zone, Refs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "int get_refs() const", AS_METHODPR(Zone, Refs, () const, int), AS_CALL_THISCALL);
     // static void Zone::RegisterObject(Context* context) | File: ../Graphics/Zone.h
     // Not registered because have @nobind mark
     // void RefCounted::ReleaseRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour("Zone", asBEHAVE_RELEASE, "void f()", asMETHODPR(Zone, ReleaseRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour("Zone", asBEHAVE_RELEASE, "void f()", AS_METHODPR(Zone, ReleaseRef, (), void), AS_CALL_THISCALL);
     // void Component::Remove() | File: ../Scene/Component.h
-    engine->RegisterObjectMethod("Zone", "void Remove()", asMETHODPR(Zone, Remove, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void Remove()", AS_METHODPR(Zone, Remove, (), void), AS_CALL_THISCALL);
     // void Animatable::RemoveAttributeAnimation(const String& name) | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod("Zone", "void RemoveAttributeAnimation(const String&in)", asMETHODPR(Zone, RemoveAttributeAnimation, (const String&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void RemoveAttributeAnimation(const String&in)", AS_METHODPR(Zone, RemoveAttributeAnimation, (const String&), void), AS_CALL_THISCALL);
     // void Serializable::RemoveInstanceDefault() | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "void RemoveInstanceDefault()", asMETHODPR(Zone, RemoveInstanceDefault, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void RemoveInstanceDefault()", AS_METHODPR(Zone, RemoveInstanceDefault, (), void), AS_CALL_THISCALL);
     // void Animatable::RemoveObjectAnimation() | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod("Zone", "void RemoveObjectAnimation()", asMETHODPR(Zone, RemoveObjectAnimation, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void RemoveObjectAnimation()", AS_METHODPR(Zone, RemoveObjectAnimation, (), void), AS_CALL_THISCALL);
     // void Serializable::ResetToDefault() | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "void ResetToDefault()", asMETHODPR(Zone, ResetToDefault, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void ResetToDefault()", AS_METHODPR(Zone, ResetToDefault, (), void), AS_CALL_THISCALL);
     // bool Component::Save(Serializer& dest) const override | File: ../Scene/Component.h
-    engine->RegisterObjectMethod("Zone", "bool Save(Serializer&) const", asMETHODPR(Zone, Save, (Serializer&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool Save(Serializer&) const", AS_METHODPR(Zone, Save, (Serializer&) const, bool), AS_CALL_THISCALL);
     // virtual bool Serializable::SaveDefaultAttributes() const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "bool SaveDefaultAttributes() const", asMETHODPR(Zone, SaveDefaultAttributes, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool SaveDefaultAttributes() const", AS_METHODPR(Zone, SaveDefaultAttributes, () const, bool), AS_CALL_THISCALL);
     // bool Component::SaveJSON(JSONValue& dest) const override | File: ../Scene/Component.h
-    engine->RegisterObjectMethod("Zone", "bool SaveJSON(JSONValue&) const", asMETHODPR(Zone, SaveJSON, (JSONValue&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool SaveJSON(JSONValue&) const", AS_METHODPR(Zone, SaveJSON, (JSONValue&) const, bool), AS_CALL_THISCALL);
     // bool Component::SaveXML(XMLElement& dest) const override | File: ../Scene/Component.h
-    engine->RegisterObjectMethod("Zone", "bool SaveXML(XMLElement&) const", asMETHODPR(Zone, SaveXML, (XMLElement&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool SaveXML(XMLElement&) const", AS_METHODPR(Zone, SaveXML, (XMLElement&) const, bool), AS_CALL_THISCALL);
     // void Object::SendEvent(StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "void SendEvent(StringHash)", asMETHODPR(Zone, SendEvent, (StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SendEvent(StringHash)", AS_METHODPR(Zone, SendEvent, (StringHash), void), AS_CALL_THISCALL);
     // void Object::SendEvent(StringHash eventType, VariantMap& eventData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "void SendEvent(StringHash, VariantMap&)", asMETHODPR(Zone, SendEvent, (StringHash, VariantMap&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SendEvent(StringHash, VariantMap&)", AS_METHODPR(Zone, SendEvent, (StringHash, VariantMap&), void), AS_CALL_THISCALL);
     // template<typename... Args> void Object::SendEvent(StringHash eventType, Args... args) | File: ../Core/Object.h
     // Not registered because template
     // void Zone::SetAmbientColor(const Color& color) | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "void SetAmbientColor(const Color&in)", asMETHODPR(Zone, SetAmbientColor, (const Color&), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_ambientColor(const Color&in)", asMETHODPR(Zone, SetAmbientColor, (const Color&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetAmbientColor(const Color&in)", AS_METHODPR(Zone, SetAmbientColor, (const Color&), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_ambientColor(const Color&in)", AS_METHODPR(Zone, SetAmbientColor, (const Color&), void), AS_CALL_THISCALL);
     // void Zone::SetAmbientGradient(bool enable) | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "void SetAmbientGradient(bool)", asMETHODPR(Zone, SetAmbientGradient, (bool), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_ambientGradient(bool)", asMETHODPR(Zone, SetAmbientGradient, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetAmbientGradient(bool)", AS_METHODPR(Zone, SetAmbientGradient, (bool), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_ambientGradient(bool)", AS_METHODPR(Zone, SetAmbientGradient, (bool), void), AS_CALL_THISCALL);
     // void Animatable::SetAnimationEnabled(bool enable) | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod("Zone", "void SetAnimationEnabled(bool)", asMETHODPR(Zone, SetAnimationEnabled, (bool), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_animationEnabled(bool)", asMETHODPR(Zone, SetAnimationEnabled, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetAnimationEnabled(bool)", AS_METHODPR(Zone, SetAnimationEnabled, (bool), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_animationEnabled(bool)", AS_METHODPR(Zone, SetAnimationEnabled, (bool), void), AS_CALL_THISCALL);
     // void Animatable::SetAnimationTime(float time) | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod("Zone", "void SetAnimationTime(float)", asMETHODPR(Zone, SetAnimationTime, (float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetAnimationTime(float)", AS_METHODPR(Zone, SetAnimationTime, (float), void), AS_CALL_THISCALL);
     // bool Serializable::SetAttribute(unsigned index, const Variant& value) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "bool SetAttribute(uint, const Variant&in)", asMETHODPR(Zone, SetAttribute, (unsigned, const Variant&), bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "bool set_attributes(uint, const Variant&in)", asMETHODPR(Zone, SetAttribute, (unsigned, const Variant&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool SetAttribute(uint, const Variant&in)", AS_METHODPR(Zone, SetAttribute, (unsigned, const Variant&), bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool set_attributes(uint, const Variant&in)", AS_METHODPR(Zone, SetAttribute, (unsigned, const Variant&), bool), AS_CALL_THISCALL);
     // bool Serializable::SetAttribute(const String& name, const Variant& value) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "bool SetAttribute(const String&in, const Variant&in)", asMETHODPR(Zone, SetAttribute, (const String&, const Variant&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "bool SetAttribute(const String&in, const Variant&in)", AS_METHODPR(Zone, SetAttribute, (const String&, const Variant&), bool), AS_CALL_THISCALL);
     // void Animatable::SetAttributeAnimation(const String& name, ValueAnimation* attributeAnimation, WrapMode wrapMode=WM_LOOP, float speed=1.0f) | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod("Zone", "void SetAttributeAnimation(const String&in, ValueAnimation@+, WrapMode = WM_LOOP, float = 1.0f)", asMETHODPR(Zone, SetAttributeAnimation, (const String&, ValueAnimation*, WrapMode, float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetAttributeAnimation(const String&in, ValueAnimation@+, WrapMode = WM_LOOP, float = 1.0f)", AS_METHODPR(Zone, SetAttributeAnimation, (const String&, ValueAnimation*, WrapMode, float), void), AS_CALL_THISCALL);
     // void Animatable::SetAttributeAnimationSpeed(const String& name, float speed) | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod("Zone", "void SetAttributeAnimationSpeed(const String&in, float)", asMETHODPR(Zone, SetAttributeAnimationSpeed, (const String&, float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetAttributeAnimationSpeed(const String&in, float)", AS_METHODPR(Zone, SetAttributeAnimationSpeed, (const String&, float), void), AS_CALL_THISCALL);
     // void Animatable::SetAttributeAnimationTime(const String& name, float time) | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod("Zone", "void SetAttributeAnimationTime(const String&in, float)", asMETHODPR(Zone, SetAttributeAnimationTime, (const String&, float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetAttributeAnimationTime(const String&in, float)", AS_METHODPR(Zone, SetAttributeAnimationTime, (const String&, float), void), AS_CALL_THISCALL);
     // void Animatable::SetAttributeAnimationWrapMode(const String& name, WrapMode wrapMode) | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod("Zone", "void SetAttributeAnimationWrapMode(const String&in, WrapMode)", asMETHODPR(Zone, SetAttributeAnimationWrapMode, (const String&, WrapMode), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetAttributeAnimationWrapMode(const String&in, WrapMode)", AS_METHODPR(Zone, SetAttributeAnimationWrapMode, (const String&, WrapMode), void), AS_CALL_THISCALL);
     // void Drawable::SetBasePass(unsigned batchIndex) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void SetBasePass(uint)", asMETHODPR(Zone, SetBasePass, (unsigned), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetBasePass(uint)", AS_METHODPR(Zone, SetBasePass, (unsigned), void), AS_CALL_THISCALL);
     // void Object::SetBlockEvents(bool block) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "void SetBlockEvents(bool)", asMETHODPR(Zone, SetBlockEvents, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetBlockEvents(bool)", AS_METHODPR(Zone, SetBlockEvents, (bool), void), AS_CALL_THISCALL);
     // void Zone::SetBoundingBox(const BoundingBox& box) | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "void SetBoundingBox(const BoundingBox&in)", asMETHODPR(Zone, SetBoundingBox, (const BoundingBox&), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_boundingBox(const BoundingBox&in)", asMETHODPR(Zone, SetBoundingBox, (const BoundingBox&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetBoundingBox(const BoundingBox&in)", AS_METHODPR(Zone, SetBoundingBox, (const BoundingBox&), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_boundingBox(const BoundingBox&in)", AS_METHODPR(Zone, SetBoundingBox, (const BoundingBox&), void), AS_CALL_THISCALL);
     // void Drawable::SetCastShadows(bool enable) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void SetCastShadows(bool)", asMETHODPR(Zone, SetCastShadows, (bool), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_castShadows(bool)", asMETHODPR(Zone, SetCastShadows, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetCastShadows(bool)", AS_METHODPR(Zone, SetCastShadows, (bool), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_castShadows(bool)", AS_METHODPR(Zone, SetCastShadows, (bool), void), AS_CALL_THISCALL);
     // void Drawable::SetDrawDistance(float distance) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void SetDrawDistance(float)", asMETHODPR(Zone, SetDrawDistance, (float), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_drawDistance(float)", asMETHODPR(Zone, SetDrawDistance, (float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetDrawDistance(float)", AS_METHODPR(Zone, SetDrawDistance, (float), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_drawDistance(float)", AS_METHODPR(Zone, SetDrawDistance, (float), void), AS_CALL_THISCALL);
     // void Component::SetEnabled(bool enable) | File: ../Scene/Component.h
-    engine->RegisterObjectMethod("Zone", "void SetEnabled(bool)", asMETHODPR(Zone, SetEnabled, (bool), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_enabled(bool)", asMETHODPR(Zone, SetEnabled, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetEnabled(bool)", AS_METHODPR(Zone, SetEnabled, (bool), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_enabled(bool)", AS_METHODPR(Zone, SetEnabled, (bool), void), AS_CALL_THISCALL);
     // void Zone::SetFogColor(const Color& color) | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "void SetFogColor(const Color&in)", asMETHODPR(Zone, SetFogColor, (const Color&), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_fogColor(const Color&in)", asMETHODPR(Zone, SetFogColor, (const Color&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetFogColor(const Color&in)", AS_METHODPR(Zone, SetFogColor, (const Color&), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_fogColor(const Color&in)", AS_METHODPR(Zone, SetFogColor, (const Color&), void), AS_CALL_THISCALL);
     // void Zone::SetFogEnd(float end) | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "void SetFogEnd(float)", asMETHODPR(Zone, SetFogEnd, (float), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_fogEnd(float)", asMETHODPR(Zone, SetFogEnd, (float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetFogEnd(float)", AS_METHODPR(Zone, SetFogEnd, (float), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_fogEnd(float)", AS_METHODPR(Zone, SetFogEnd, (float), void), AS_CALL_THISCALL);
     // void Zone::SetFogHeight(float height) | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "void SetFogHeight(float)", asMETHODPR(Zone, SetFogHeight, (float), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_fogHeight(float)", asMETHODPR(Zone, SetFogHeight, (float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetFogHeight(float)", AS_METHODPR(Zone, SetFogHeight, (float), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_fogHeight(float)", AS_METHODPR(Zone, SetFogHeight, (float), void), AS_CALL_THISCALL);
     // void Zone::SetFogHeightScale(float scale) | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "void SetFogHeightScale(float)", asMETHODPR(Zone, SetFogHeightScale, (float), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_fogHeightScale(float)", asMETHODPR(Zone, SetFogHeightScale, (float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetFogHeightScale(float)", AS_METHODPR(Zone, SetFogHeightScale, (float), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_fogHeightScale(float)", AS_METHODPR(Zone, SetFogHeightScale, (float), void), AS_CALL_THISCALL);
     // void Zone::SetFogStart(float start) | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "void SetFogStart(float)", asMETHODPR(Zone, SetFogStart, (float), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_fogStart(float)", asMETHODPR(Zone, SetFogStart, (float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetFogStart(float)", AS_METHODPR(Zone, SetFogStart, (float), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_fogStart(float)", AS_METHODPR(Zone, SetFogStart, (float), void), AS_CALL_THISCALL);
     // void Object::SetGlobalVar(StringHash key, const Variant& value) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "void SetGlobalVar(StringHash, const Variant&in)", asMETHODPR(Zone, SetGlobalVar, (StringHash, const Variant&), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_globalVar(StringHash, const Variant&in)", asMETHODPR(Zone, SetGlobalVar, (StringHash, const Variant&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetGlobalVar(StringHash, const Variant&in)", AS_METHODPR(Zone, SetGlobalVar, (StringHash, const Variant&), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_globalVar(StringHash, const Variant&in)", AS_METHODPR(Zone, SetGlobalVar, (StringHash, const Variant&), void), AS_CALL_THISCALL);
     // void Zone::SetHeightFog(bool enable) | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "void SetHeightFog(bool)", asMETHODPR(Zone, SetHeightFog, (bool), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_heightFog(bool)", asMETHODPR(Zone, SetHeightFog, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetHeightFog(bool)", AS_METHODPR(Zone, SetHeightFog, (bool), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_heightFog(bool)", AS_METHODPR(Zone, SetHeightFog, (bool), void), AS_CALL_THISCALL);
     // void Serializable::SetInstanceDefault(bool enable) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "void SetInstanceDefault(bool)", asMETHODPR(Zone, SetInstanceDefault, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetInstanceDefault(bool)", AS_METHODPR(Zone, SetInstanceDefault, (bool), void), AS_CALL_THISCALL);
     // void Serializable::SetInterceptNetworkUpdate(const String& attributeName, bool enable) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "void SetInterceptNetworkUpdate(const String&in, bool)", asMETHODPR(Zone, SetInterceptNetworkUpdate, (const String&, bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetInterceptNetworkUpdate(const String&in, bool)", AS_METHODPR(Zone, SetInterceptNetworkUpdate, (const String&, bool), void), AS_CALL_THISCALL);
     // void Drawable::SetLightMask(unsigned mask) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void SetLightMask(uint)", asMETHODPR(Zone, SetLightMask, (unsigned), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_lightMask(uint)", asMETHODPR(Zone, SetLightMask, (unsigned), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetLightMask(uint)", AS_METHODPR(Zone, SetLightMask, (unsigned), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_lightMask(uint)", AS_METHODPR(Zone, SetLightMask, (unsigned), void), AS_CALL_THISCALL);
     // void Drawable::SetLodBias(float bias) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void SetLodBias(float)", asMETHODPR(Zone, SetLodBias, (float), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_lodBias(float)", asMETHODPR(Zone, SetLodBias, (float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetLodBias(float)", AS_METHODPR(Zone, SetLodBias, (float), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_lodBias(float)", AS_METHODPR(Zone, SetLodBias, (float), void), AS_CALL_THISCALL);
     // void Drawable::SetMaxLights(unsigned num) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void SetMaxLights(uint)", asMETHODPR(Zone, SetMaxLights, (unsigned), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_maxLights(uint)", asMETHODPR(Zone, SetMaxLights, (unsigned), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetMaxLights(uint)", AS_METHODPR(Zone, SetMaxLights, (unsigned), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_maxLights(uint)", AS_METHODPR(Zone, SetMaxLights, (unsigned), void), AS_CALL_THISCALL);
     // void Drawable::SetMinMaxZ(float minZ, float maxZ) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void SetMinMaxZ(float, float)", asMETHODPR(Zone, SetMinMaxZ, (float, float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetMinMaxZ(float, float)", AS_METHODPR(Zone, SetMinMaxZ, (float, float), void), AS_CALL_THISCALL);
     // void Animatable::SetObjectAnimation(ObjectAnimation* objectAnimation) | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod("Zone", "void SetObjectAnimation(ObjectAnimation@+)", asMETHODPR(Zone, SetObjectAnimation, (ObjectAnimation*), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_objectAnimation(ObjectAnimation@+)", asMETHODPR(Zone, SetObjectAnimation, (ObjectAnimation*), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetObjectAnimation(ObjectAnimation@+)", AS_METHODPR(Zone, SetObjectAnimation, (ObjectAnimation*), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_objectAnimation(ObjectAnimation@+)", AS_METHODPR(Zone, SetObjectAnimation, (ObjectAnimation*), void), AS_CALL_THISCALL);
     // void Animatable::SetObjectAnimationAttr(const ResourceRef& value) | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod("Zone", "void SetObjectAnimationAttr(const ResourceRef&in)", asMETHODPR(Zone, SetObjectAnimationAttr, (const ResourceRef&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetObjectAnimationAttr(const ResourceRef&in)", AS_METHODPR(Zone, SetObjectAnimationAttr, (const ResourceRef&), void), AS_CALL_THISCALL);
     // void Drawable::SetOccludee(bool enable) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void SetOccludee(bool)", asMETHODPR(Zone, SetOccludee, (bool), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_occludee(bool)", asMETHODPR(Zone, SetOccludee, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetOccludee(bool)", AS_METHODPR(Zone, SetOccludee, (bool), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_occludee(bool)", AS_METHODPR(Zone, SetOccludee, (bool), void), AS_CALL_THISCALL);
     // void Drawable::SetOccluder(bool enable) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void SetOccluder(bool)", asMETHODPR(Zone, SetOccluder, (bool), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_occluder(bool)", asMETHODPR(Zone, SetOccluder, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetOccluder(bool)", AS_METHODPR(Zone, SetOccluder, (bool), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_occluder(bool)", AS_METHODPR(Zone, SetOccluder, (bool), void), AS_CALL_THISCALL);
     // void Zone::SetOverride(bool enable) | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "void SetOverride(bool)", asMETHODPR(Zone, SetOverride, (bool), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_override(bool)", asMETHODPR(Zone, SetOverride, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetOverride(bool)", AS_METHODPR(Zone, SetOverride, (bool), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_override(bool)", AS_METHODPR(Zone, SetOverride, (bool), void), AS_CALL_THISCALL);
     // void Zone::SetPriority(int priority) | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "void SetPriority(int)", asMETHODPR(Zone, SetPriority, (int), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_priority(int)", asMETHODPR(Zone, SetPriority, (int), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetPriority(int)", AS_METHODPR(Zone, SetPriority, (int), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_priority(int)", AS_METHODPR(Zone, SetPriority, (int), void), AS_CALL_THISCALL);
     // void Drawable::SetShadowDistance(float distance) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void SetShadowDistance(float)", asMETHODPR(Zone, SetShadowDistance, (float), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_shadowDistance(float)", asMETHODPR(Zone, SetShadowDistance, (float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetShadowDistance(float)", AS_METHODPR(Zone, SetShadowDistance, (float), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_shadowDistance(float)", AS_METHODPR(Zone, SetShadowDistance, (float), void), AS_CALL_THISCALL);
     // void Drawable::SetShadowMask(unsigned mask) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void SetShadowMask(uint)", asMETHODPR(Zone, SetShadowMask, (unsigned), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_shadowMask(uint)", asMETHODPR(Zone, SetShadowMask, (unsigned), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetShadowMask(uint)", AS_METHODPR(Zone, SetShadowMask, (unsigned), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_shadowMask(uint)", AS_METHODPR(Zone, SetShadowMask, (unsigned), void), AS_CALL_THISCALL);
     // void Drawable::SetSortValue(float value) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void SetSortValue(float)", asMETHODPR(Zone, SetSortValue, (float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetSortValue(float)", AS_METHODPR(Zone, SetSortValue, (float), void), AS_CALL_THISCALL);
     // void Serializable::SetTemporary(bool enable) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "void SetTemporary(bool)", asMETHODPR(Zone, SetTemporary, (bool), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_temporary(bool)", asMETHODPR(Zone, SetTemporary, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetTemporary(bool)", AS_METHODPR(Zone, SetTemporary, (bool), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_temporary(bool)", AS_METHODPR(Zone, SetTemporary, (bool), void), AS_CALL_THISCALL);
     // void Drawable::SetViewMask(unsigned mask) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void SetViewMask(uint)", asMETHODPR(Zone, SetViewMask, (unsigned), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_viewMask(uint)", asMETHODPR(Zone, SetViewMask, (unsigned), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetViewMask(uint)", AS_METHODPR(Zone, SetViewMask, (unsigned), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_viewMask(uint)", AS_METHODPR(Zone, SetViewMask, (unsigned), void), AS_CALL_THISCALL);
     // void Drawable::SetZone(Zone* zone, bool temporary=false) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void SetZone(Zone@+, bool = false)", asMETHODPR(Zone, SetZone, (Zone*, bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetZone(Zone@+, bool = false)", AS_METHODPR(Zone, SetZone, (Zone*, bool), void), AS_CALL_THISCALL);
     // void Drawable::SetZoneMask(unsigned mask) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void SetZoneMask(uint)", asMETHODPR(Zone, SetZoneMask, (unsigned), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_zoneMask(uint)", asMETHODPR(Zone, SetZoneMask, (unsigned), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetZoneMask(uint)", AS_METHODPR(Zone, SetZoneMask, (unsigned), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_zoneMask(uint)", AS_METHODPR(Zone, SetZoneMask, (unsigned), void), AS_CALL_THISCALL);
     // void Zone::SetZoneTexture(Texture* texture) | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "void SetZoneTexture(Texture@+)", asMETHODPR(Zone, SetZoneTexture, (Texture*), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "void set_zoneTexture(Texture@+)", asMETHODPR(Zone, SetZoneTexture, (Texture*), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetZoneTexture(Texture@+)", AS_METHODPR(Zone, SetZoneTexture, (Texture*), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void set_zoneTexture(Texture@+)", AS_METHODPR(Zone, SetZoneTexture, (Texture*), void), AS_CALL_THISCALL);
     // void Zone::SetZoneTextureAttr(const ResourceRef& value) | File: ../Graphics/Zone.h
-    engine->RegisterObjectMethod("Zone", "void SetZoneTextureAttr(const ResourceRef&in)", asMETHODPR(Zone, SetZoneTextureAttr, (const ResourceRef&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void SetZoneTextureAttr(const ResourceRef&in)", AS_METHODPR(Zone, SetZoneTextureAttr, (const ResourceRef&), void), AS_CALL_THISCALL);
     // void Object::SubscribeToEvent(StringHash eventType, EventHandler* handler) | File: ../Core/Object.h
     // Error: type "EventHandler*" can not automatically bind
     // void Object::SubscribeToEvent(Object* sender, StringHash eventType, EventHandler* handler) | File: ../Core/Object.h
@@ -497,32 +497,32 @@ void ASRegisterGenerated_Members_Z(asIScriptEngine* engine)
     // void Object::SubscribeToEvent(Object* sender, StringHash eventType, const std::function<void(StringHash, VariantMap&)>& function, void* userData=nullptr) | File: ../Core/Object.h
     // Error: type "const std::function<void(StringHash, VariantMap&)>&" can not automatically bind
     // void Object::UnsubscribeFromAllEvents() | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "void UnsubscribeFromAllEvents()", asMETHODPR(Zone, UnsubscribeFromAllEvents, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void UnsubscribeFromAllEvents()", AS_METHODPR(Zone, UnsubscribeFromAllEvents, (), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromAllEventsExcept(const PODVector<StringHash>& exceptions, bool onlyUserData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "void UnsubscribeFromAllEventsExcept(Array<StringHash>@+, bool)", asFUNCTION(Zone_UnsubscribeFromAllEventsExcept_PODVectorStringHash_bool), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod("Zone", "void UnsubscribeFromAllEventsExcept(Array<StringHash>@+, bool)", AS_FUNCTION_OBJFIRST(Zone_UnsubscribeFromAllEventsExcept_PODVectorStringHash_bool), AS_CALL_CDECL_OBJFIRST);
     // void Object::UnsubscribeFromEvent(StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "void UnsubscribeFromEvent(StringHash)", asMETHODPR(Zone, UnsubscribeFromEvent, (StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void UnsubscribeFromEvent(StringHash)", AS_METHODPR(Zone, UnsubscribeFromEvent, (StringHash), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromEvent(Object* sender, StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "void UnsubscribeFromEvent(Object@+, StringHash)", asMETHODPR(Zone, UnsubscribeFromEvent, (Object*, StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void UnsubscribeFromEvent(Object@+, StringHash)", AS_METHODPR(Zone, UnsubscribeFromEvent, (Object*, StringHash), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromEvents(Object* sender) | File: ../Core/Object.h
-    engine->RegisterObjectMethod("Zone", "void UnsubscribeFromEvents(Object@+)", asMETHODPR(Zone, UnsubscribeFromEvents, (Object*), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void UnsubscribeFromEvents(Object@+)", AS_METHODPR(Zone, UnsubscribeFromEvents, (Object*), void), AS_CALL_THISCALL);
     // virtual void Drawable::Update(const FrameInfo& frame) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void Update(const FrameInfo&in)", asMETHODPR(Zone, Update, (const FrameInfo&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void Update(const FrameInfo&in)", AS_METHODPR(Zone, Update, (const FrameInfo&), void), AS_CALL_THISCALL);
     // virtual void Drawable::UpdateBatches(const FrameInfo& frame) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void UpdateBatches(const FrameInfo&in)", asMETHODPR(Zone, UpdateBatches, (const FrameInfo&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void UpdateBatches(const FrameInfo&in)", AS_METHODPR(Zone, UpdateBatches, (const FrameInfo&), void), AS_CALL_THISCALL);
     // virtual void Drawable::UpdateGeometry(const FrameInfo& frame) | File: ../Graphics/Drawable.h
-    engine->RegisterObjectMethod("Zone", "void UpdateGeometry(const FrameInfo&in)", asMETHODPR(Zone, UpdateGeometry, (const FrameInfo&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void UpdateGeometry(const FrameInfo&in)", AS_METHODPR(Zone, UpdateGeometry, (const FrameInfo&), void), AS_CALL_THISCALL);
     // int RefCounted::WeakRefs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod("Zone", "int WeakRefs() const", asMETHODPR(Zone, WeakRefs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Zone", "int get_weakRefs() const", asMETHODPR(Zone, WeakRefs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "int WeakRefs() const", AS_METHODPR(Zone, WeakRefs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "int get_weakRefs() const", AS_METHODPR(Zone, WeakRefs, () const, int), AS_CALL_THISCALL);
     // void Serializable::WriteDeltaUpdate(Serializer& dest, const DirtyBits& attributeBits, unsigned char timeStamp) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "void WriteDeltaUpdate(Serializer&, const DirtyBits&in, uint8)", asMETHODPR(Zone, WriteDeltaUpdate, (Serializer&, const DirtyBits&, unsigned char), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void WriteDeltaUpdate(Serializer&, const DirtyBits&in, uint8)", AS_METHODPR(Zone, WriteDeltaUpdate, (Serializer&, const DirtyBits&, unsigned char), void), AS_CALL_THISCALL);
     // void Serializable::WriteInitialDeltaUpdate(Serializer& dest, unsigned char timeStamp) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "void WriteInitialDeltaUpdate(Serializer&, uint8)", asMETHODPR(Zone, WriteInitialDeltaUpdate, (Serializer&, unsigned char), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void WriteInitialDeltaUpdate(Serializer&, uint8)", AS_METHODPR(Zone, WriteInitialDeltaUpdate, (Serializer&, unsigned char), void), AS_CALL_THISCALL);
     // void Serializable::WriteLatestDataUpdate(Serializer& dest, unsigned char timeStamp) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod("Zone", "void WriteLatestDataUpdate(Serializer&, uint8)", asMETHODPR(Zone, WriteLatestDataUpdate, (Serializer&, unsigned char), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Zone", "void WriteLatestDataUpdate(Serializer&, uint8)", AS_METHODPR(Zone, WriteLatestDataUpdate, (Serializer&, unsigned char), void), AS_CALL_THISCALL);
     // explicit Zone::Zone(Context* context) | File: ../Graphics/Zone.h
-    engine->RegisterObjectBehaviour("Zone", asBEHAVE_FACTORY, "Zone@+ f()", asFUNCTION(Zone_Zone_Context), asCALL_CDECL);
+    engine->RegisterObjectBehaviour("Zone", asBEHAVE_FACTORY, "Zone@+ f()", AS_FUNCTION(Zone_Zone_Context), AS_CALL_CDECL);
 #ifdef REGISTER_MANUAL_PART_Drawable
     REGISTER_MANUAL_PART_Drawable(Zone, "Zone")
 #endif

Source/Urho3D/AngelScript/Generated_Templates.h

@@ -53,13 +53,13 @@ template <class T> void RegisterComponent(asIScriptEngine* engine, const char* c
     // class Component | File: ../Scene/Component.h
     engine->RegisterObjectType(className, 0, asOBJ_REF);
     // void RefCounted::AddRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour(className, asBEHAVE_ADDREF, "void f()", asMETHODPR(T, AddRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour(className, asBEHAVE_ADDREF, "void f()", AS_METHODPR(T, AddRef, (), void), AS_CALL_THISCALL);
     // void Component::AddReplicationState(ComponentReplicationState* state) | File: ../Scene/Component.h
     // Error: type "ComponentReplicationState*" can not automatically bind
     // void Serializable::AllocateNetworkState() | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "void AllocateNetworkState()", asMETHODPR(T, AllocateNetworkState, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void AllocateNetworkState()", AS_METHODPR(T, AllocateNetworkState, (), void), AS_CALL_THISCALL);
     // virtual void Serializable::ApplyAttributes() | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "void ApplyAttributes()", asMETHODPR(T, ApplyAttributes, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void ApplyAttributes()", AS_METHODPR(T, ApplyAttributes, (), void), AS_CALL_THISCALL);
     // template<typename T> T* Object::Cast() | File: ../Core/Object.h
     // Not registered because template
     // template<typename T> const T* Object::Cast() const | File: ../Core/Object.h
@@ -69,40 +69,40 @@ template <class T> void RegisterComponent(asIScriptEngine* engine, const char* c
     // explicit Component::Component(Context* context) | File: ../Scene/Component.h
     {
         String declFactory(String(className) + "@ f()");
-        engine->RegisterObjectBehaviour(className, asBEHAVE_FACTORY, declFactory.CString(), asFUNCTION(Component_Component_Context_template), asCALL_CDECL);
+        engine->RegisterObjectBehaviour(className, asBEHAVE_FACTORY, declFactory.CString(), AS_FUNCTION(Component_Component_Context_template), AS_CALL_CDECL);
     }
     // virtual void Component::DrawDebugGeometry(DebugRenderer* debug, bool depthTest) | File: ../Scene/Component.h
-    engine->RegisterObjectMethod(className, "void DrawDebugGeometry(DebugRenderer@+, bool)", asMETHODPR(T, DrawDebugGeometry, (DebugRenderer*, bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void DrawDebugGeometry(DebugRenderer@+, bool)", AS_METHODPR(T, DrawDebugGeometry, (DebugRenderer*, bool), void), AS_CALL_THISCALL);
     // bool Animatable::GetAnimationEnabled() const | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod(className, "bool GetAnimationEnabled() const", asMETHODPR(T, GetAnimationEnabled, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "bool get_animationEnabled() const", asMETHODPR(T, GetAnimationEnabled, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool GetAnimationEnabled() const", AS_METHODPR(T, GetAnimationEnabled, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool get_animationEnabled() const", AS_METHODPR(T, GetAnimationEnabled, () const, bool), AS_CALL_THISCALL);
     // Variant Serializable::GetAttribute(unsigned index) const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "Variant GetAttribute(uint) const", asMETHODPR(T, GetAttribute, (unsigned) const, Variant), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "Variant get_attributes(uint) const", asMETHODPR(T, GetAttribute, (unsigned) const, Variant), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "Variant GetAttribute(uint) const", AS_METHODPR(T, GetAttribute, (unsigned) const, Variant), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "Variant get_attributes(uint) const", AS_METHODPR(T, GetAttribute, (unsigned) const, Variant), AS_CALL_THISCALL);
     // Variant Serializable::GetAttribute(const String& name) const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "Variant GetAttribute(const String&in) const", asMETHODPR(T, GetAttribute, (const String&) const, Variant), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "Variant GetAttribute(const String&in) const", AS_METHODPR(T, GetAttribute, (const String&) const, Variant), AS_CALL_THISCALL);
     // ValueAnimation* Animatable::GetAttributeAnimation(const String& name) const | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod(className, "ValueAnimation@+ GetAttributeAnimation(const String&in) const", asMETHODPR(T, GetAttributeAnimation, (const String&) const, ValueAnimation*), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "ValueAnimation@+ GetAttributeAnimation(const String&in) const", AS_METHODPR(T, GetAttributeAnimation, (const String&) const, ValueAnimation*), AS_CALL_THISCALL);
     // float Animatable::GetAttributeAnimationSpeed(const String& name) const | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod(className, "float GetAttributeAnimationSpeed(const String&in) const", asMETHODPR(T, GetAttributeAnimationSpeed, (const String&) const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "float GetAttributeAnimationSpeed(const String&in) const", AS_METHODPR(T, GetAttributeAnimationSpeed, (const String&) const, float), AS_CALL_THISCALL);
     // float Animatable::GetAttributeAnimationTime(const String& name) const | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod(className, "float GetAttributeAnimationTime(const String&in) const", asMETHODPR(T, GetAttributeAnimationTime, (const String&) const, float), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "float GetAttributeAnimationTime(const String&in) const", AS_METHODPR(T, GetAttributeAnimationTime, (const String&) const, float), AS_CALL_THISCALL);
     // WrapMode Animatable::GetAttributeAnimationWrapMode(const String& name) const | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod(className, "WrapMode GetAttributeAnimationWrapMode(const String&in) const", asMETHODPR(T, GetAttributeAnimationWrapMode, (const String&) const, WrapMode), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "WrapMode GetAttributeAnimationWrapMode(const String&in) const", AS_METHODPR(T, GetAttributeAnimationWrapMode, (const String&) const, WrapMode), AS_CALL_THISCALL);
     // Variant Serializable::GetAttributeDefault(unsigned index) const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "Variant GetAttributeDefault(uint) const", asMETHODPR(T, GetAttributeDefault, (unsigned) const, Variant), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "Variant get_attributeDefaults(uint) const", asMETHODPR(T, GetAttributeDefault, (unsigned) const, Variant), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "Variant GetAttributeDefault(uint) const", AS_METHODPR(T, GetAttributeDefault, (unsigned) const, Variant), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "Variant get_attributeDefaults(uint) const", AS_METHODPR(T, GetAttributeDefault, (unsigned) const, Variant), AS_CALL_THISCALL);
     // Variant Serializable::GetAttributeDefault(const String& name) const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "Variant GetAttributeDefault(const String&in) const", asMETHODPR(T, GetAttributeDefault, (const String&) const, Variant), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "Variant GetAttributeDefault(const String&in) const", AS_METHODPR(T, GetAttributeDefault, (const String&) const, Variant), AS_CALL_THISCALL);
     // virtual const Vector<AttributeInfo>* Serializable::GetAttributes() const | File: ../Scene/Serializable.h
     // Error: type "const Vector<AttributeInfo>*" can not automatically bind
     // bool Object::GetBlockEvents() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "bool GetBlockEvents() const", asMETHODPR(T, GetBlockEvents, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool GetBlockEvents() const", AS_METHODPR(T, GetBlockEvents, () const, bool), AS_CALL_THISCALL);
     // const String& Object::GetCategory() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "const String& GetCategory() const", asMETHODPR(T, GetCategory, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "const String& get_category() const", asMETHODPR(T, GetCategory, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const String& GetCategory() const", AS_METHODPR(T, GetCategory, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const String& get_category() const", AS_METHODPR(T, GetCategory, () const, const String&), AS_CALL_THISCALL);
     // Component* Component::GetComponent(StringHash type) const | File: ../Scene/Component.h
-    engine->RegisterObjectMethod(className, "Component@+ GetComponent(StringHash) const", asMETHODPR(T, GetComponent, (StringHash) const, Component*), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "Component@+ GetComponent(StringHash) const", AS_METHODPR(T, GetComponent, (StringHash) const, Component*), AS_CALL_THISCALL);
     // template<class T> T* Component::GetComponent() const | File: ../Scene/Component.h
     // Not registered because template
     // void Component::GetComponents(PODVector<Component*>& dest, StringHash type) const | File: ../Scene/Component.h
@@ -114,172 +114,172 @@ template <class T> void RegisterComponent(asIScriptEngine* engine, const char* c
     // virtual void Component::GetDependencyNodes(PODVector<Node*>& dest) | File: ../Scene/Component.h
     // Error: type "PODVector<Node*>&" can not automatically bind
     // VariantMap& Object::GetEventDataMap() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "VariantMap& GetEventDataMap() const", asMETHODPR(T, GetEventDataMap, () const, VariantMap&), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "VariantMap& GetEventDataMap() const", AS_METHODPR(T, GetEventDataMap, () const, VariantMap&), AS_CALL_THISCALL);
     // EventHandler* Object::GetEventHandler() const | File: ../Core/Object.h
     // Error: type "EventHandler*" can not automatically bind
     // Object* Object::GetEventSender() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "Object@+ GetEventSender() const", asMETHODPR(T, GetEventSender, () const, Object*), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "Object@+ GetEventSender() const", AS_METHODPR(T, GetEventSender, () const, Object*), AS_CALL_THISCALL);
     // const Variant& Object::GetGlobalVar(StringHash key) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "const Variant& GetGlobalVar(StringHash) const", asMETHODPR(T, GetGlobalVar, (StringHash) const, const Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "const Variant& get_globalVar(StringHash) const", asMETHODPR(T, GetGlobalVar, (StringHash) const, const Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const Variant& GetGlobalVar(StringHash) const", AS_METHODPR(T, GetGlobalVar, (StringHash) const, const Variant&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const Variant& get_globalVar(StringHash) const", AS_METHODPR(T, GetGlobalVar, (StringHash) const, const Variant&), AS_CALL_THISCALL);
     // const VariantMap& Object::GetGlobalVars() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "const VariantMap& GetGlobalVars() const", asMETHODPR(T, GetGlobalVars, () const, const VariantMap&), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "const VariantMap& get_globalVars() const", asMETHODPR(T, GetGlobalVars, () const, const VariantMap&), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const VariantMap& GetGlobalVars() const", AS_METHODPR(T, GetGlobalVars, () const, const VariantMap&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const VariantMap& get_globalVars() const", AS_METHODPR(T, GetGlobalVars, () const, const VariantMap&), AS_CALL_THISCALL);
     // unsigned Component::GetID() const | File: ../Scene/Component.h
-    engine->RegisterObjectMethod(className, "uint GetID() const", asMETHODPR(T, GetID, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "uint get_id() const", asMETHODPR(T, GetID, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "uint GetID() const", AS_METHODPR(T, GetID, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "uint get_id() const", AS_METHODPR(T, GetID, () const, unsigned), AS_CALL_THISCALL);
     // bool Serializable::GetInterceptNetworkUpdate(const String& attributeName) const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "bool GetInterceptNetworkUpdate(const String&in) const", asMETHODPR(T, GetInterceptNetworkUpdate, (const String&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool GetInterceptNetworkUpdate(const String&in) const", AS_METHODPR(T, GetInterceptNetworkUpdate, (const String&) const, bool), AS_CALL_THISCALL);
     // virtual const Vector<AttributeInfo>* Serializable::GetNetworkAttributes() const | File: ../Scene/Serializable.h
     // Error: type "const Vector<AttributeInfo>*" can not automatically bind
     // NetworkState* Serializable::GetNetworkState() const | File: ../Scene/Serializable.h
     // Error: type "NetworkState*" can not automatically bind
     // Node* Component::GetNode() const | File: ../Scene/Component.h
-    engine->RegisterObjectMethod(className, "Node@+ GetNode() const", asMETHODPR(T, GetNode, () const, Node*), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "Node@+ get_node() const", asMETHODPR(T, GetNode, () const, Node*), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "Node@+ GetNode() const", AS_METHODPR(T, GetNode, () const, Node*), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "Node@+ get_node() const", AS_METHODPR(T, GetNode, () const, Node*), AS_CALL_THISCALL);
     // unsigned Serializable::GetNumAttributes() const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "uint GetNumAttributes() const", asMETHODPR(T, GetNumAttributes, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "uint get_numAttributes() const", asMETHODPR(T, GetNumAttributes, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "uint GetNumAttributes() const", AS_METHODPR(T, GetNumAttributes, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "uint get_numAttributes() const", AS_METHODPR(T, GetNumAttributes, () const, unsigned), AS_CALL_THISCALL);
     // unsigned Serializable::GetNumNetworkAttributes() const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "uint GetNumNetworkAttributes() const", asMETHODPR(T, GetNumNetworkAttributes, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "uint GetNumNetworkAttributes() const", AS_METHODPR(T, GetNumNetworkAttributes, () const, unsigned), AS_CALL_THISCALL);
     // ObjectAnimation* Animatable::GetObjectAnimation() const | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod(className, "ObjectAnimation@+ GetObjectAnimation() const", asMETHODPR(T, GetObjectAnimation, () const, ObjectAnimation*), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "ObjectAnimation@+ get_objectAnimation() const", asMETHODPR(T, GetObjectAnimation, () const, ObjectAnimation*), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "ObjectAnimation@+ GetObjectAnimation() const", AS_METHODPR(T, GetObjectAnimation, () const, ObjectAnimation*), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "ObjectAnimation@+ get_objectAnimation() const", AS_METHODPR(T, GetObjectAnimation, () const, ObjectAnimation*), AS_CALL_THISCALL);
     // ResourceRef Animatable::GetObjectAnimationAttr() const | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod(className, "ResourceRef GetObjectAnimationAttr() const", asMETHODPR(T, GetObjectAnimationAttr, () const, ResourceRef), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "ResourceRef GetObjectAnimationAttr() const", AS_METHODPR(T, GetObjectAnimationAttr, () const, ResourceRef), AS_CALL_THISCALL);
     // Scene* Component::GetScene() const | File: ../Scene/Component.h
-    engine->RegisterObjectMethod(className, "Scene@+ GetScene() const", asMETHODPR(T, GetScene, () const, Scene*), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "Scene@+ GetScene() const", AS_METHODPR(T, GetScene, () const, Scene*), AS_CALL_THISCALL);
     // Object* Object::GetSubsystem(StringHash type) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "Object@+ GetSubsystem(StringHash) const", asMETHODPR(T, GetSubsystem, (StringHash) const, Object*), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "Object@+ GetSubsystem(StringHash) const", AS_METHODPR(T, GetSubsystem, (StringHash) const, Object*), AS_CALL_THISCALL);
     // template<class T> T* Object::GetSubsystem() const | File: ../Core/Object.h
     // Not registered because template
     // virtual StringHash Object::GetType() const =0 | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "StringHash GetType() const", asMETHODPR(T, GetType, () const, StringHash), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "StringHash get_type() const", asMETHODPR(T, GetType, () const, StringHash), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "StringHash GetType() const", AS_METHODPR(T, GetType, () const, StringHash), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "StringHash get_type() const", AS_METHODPR(T, GetType, () const, StringHash), AS_CALL_THISCALL);
     // virtual const TypeInfo* Object::GetTypeInfo() const =0 | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // static const TypeInfo* Object::GetTypeInfoStatic() | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // virtual const String& Object::GetTypeName() const =0 | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "const String& GetTypeName() const", asMETHODPR(T, GetTypeName, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "const String& get_typeName() const", asMETHODPR(T, GetTypeName, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const String& GetTypeName() const", AS_METHODPR(T, GetTypeName, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const String& get_typeName() const", AS_METHODPR(T, GetTypeName, () const, const String&), AS_CALL_THISCALL);
     // bool Object::HasEventHandlers() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "bool HasEventHandlers() const", asMETHODPR(T, HasEventHandlers, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool HasEventHandlers() const", AS_METHODPR(T, HasEventHandlers, () const, bool), AS_CALL_THISCALL);
     // bool Object::HasSubscribedToEvent(StringHash eventType) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "bool HasSubscribedToEvent(StringHash) const", asMETHODPR(T, HasSubscribedToEvent, (StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool HasSubscribedToEvent(StringHash) const", AS_METHODPR(T, HasSubscribedToEvent, (StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::HasSubscribedToEvent(Object* sender, StringHash eventType) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "bool HasSubscribedToEvent(Object@+, StringHash) const", asMETHODPR(T, HasSubscribedToEvent, (Object*, StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool HasSubscribedToEvent(Object@+, StringHash) const", AS_METHODPR(T, HasSubscribedToEvent, (Object*, StringHash) const, bool), AS_CALL_THISCALL);
     // bool Component::IsEnabled() const | File: ../Scene/Component.h
-    engine->RegisterObjectMethod(className, "bool IsEnabled() const", asMETHODPR(T, IsEnabled, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "bool get_enabled() const", asMETHODPR(T, IsEnabled, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool IsEnabled() const", AS_METHODPR(T, IsEnabled, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool get_enabled() const", AS_METHODPR(T, IsEnabled, () const, bool), AS_CALL_THISCALL);
     // bool Component::IsEnabledEffective() const | File: ../Scene/Component.h
-    engine->RegisterObjectMethod(className, "bool IsEnabledEffective() const", asMETHODPR(T, IsEnabledEffective, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "bool get_enabledEffective() const", asMETHODPR(T, IsEnabledEffective, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool IsEnabledEffective() const", AS_METHODPR(T, IsEnabledEffective, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool get_enabledEffective() const", AS_METHODPR(T, IsEnabledEffective, () const, bool), AS_CALL_THISCALL);
     // bool Object::IsInstanceOf(StringHash type) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "bool IsInstanceOf(StringHash) const", asMETHODPR(T, IsInstanceOf, (StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool IsInstanceOf(StringHash) const", AS_METHODPR(T, IsInstanceOf, (StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::IsInstanceOf(const TypeInfo* typeInfo) const | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // template<typename T> bool Object::IsInstanceOf() const | File: ../Core/Object.h
     // Not registered because template
     // bool Component::IsReplicated() const | File: ../Scene/Component.h
-    engine->RegisterObjectMethod(className, "bool IsReplicated() const", asMETHODPR(T, IsReplicated, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "bool get_replicated() const", asMETHODPR(T, IsReplicated, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool IsReplicated() const", AS_METHODPR(T, IsReplicated, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool get_replicated() const", AS_METHODPR(T, IsReplicated, () const, bool), AS_CALL_THISCALL);
     // bool Serializable::IsTemporary() const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "bool IsTemporary() const", asMETHODPR(T, IsTemporary, () const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "bool get_temporary() const", asMETHODPR(T, IsTemporary, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool IsTemporary() const", AS_METHODPR(T, IsTemporary, () const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool get_temporary() const", AS_METHODPR(T, IsTemporary, () const, bool), AS_CALL_THISCALL);
     // virtual bool Serializable::Load(Deserializer& source) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "bool Load(Deserializer&)", asMETHODPR(T, Load, (Deserializer&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool Load(Deserializer&)", AS_METHODPR(T, Load, (Deserializer&), bool), AS_CALL_THISCALL);
     // bool Animatable::LoadJSON(const JSONValue& source) override | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod(className, "bool LoadJSON(const JSONValue&in)", asMETHODPR(T, LoadJSON, (const JSONValue&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool LoadJSON(const JSONValue&in)", AS_METHODPR(T, LoadJSON, (const JSONValue&), bool), AS_CALL_THISCALL);
     // bool Animatable::LoadXML(const XMLElement& source) override | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod(className, "bool LoadXML(const XMLElement&in)", asMETHODPR(T, LoadXML, (const XMLElement&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool LoadXML(const XMLElement&in)", AS_METHODPR(T, LoadXML, (const XMLElement&), bool), AS_CALL_THISCALL);
     // void Component::MarkNetworkUpdate() override | File: ../Scene/Component.h
-    engine->RegisterObjectMethod(className, "void MarkNetworkUpdate()", asMETHODPR(T, MarkNetworkUpdate, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void MarkNetworkUpdate()", AS_METHODPR(T, MarkNetworkUpdate, (), void), AS_CALL_THISCALL);
     // virtual void Object::OnEvent(Object* sender, StringHash eventType, VariantMap& eventData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void OnEvent(Object@+, StringHash, VariantMap&)", asMETHODPR(T, OnEvent, (Object*, StringHash, VariantMap&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void OnEvent(Object@+, StringHash, VariantMap&)", AS_METHODPR(T, OnEvent, (Object*, StringHash, VariantMap&), void), AS_CALL_THISCALL);
     // virtual void Serializable::OnGetAttribute(const AttributeInfo& attr, Variant& dest) const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "void OnGetAttribute(const AttributeInfo&in, Variant&) const", asMETHODPR(T, OnGetAttribute, (const AttributeInfo&, Variant&) const, void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void OnGetAttribute(const AttributeInfo&in, Variant&) const", AS_METHODPR(T, OnGetAttribute, (const AttributeInfo&, Variant&) const, void), AS_CALL_THISCALL);
     // virtual void Serializable::OnSetAttribute(const AttributeInfo& attr, const Variant& src) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "void OnSetAttribute(const AttributeInfo&in, const Variant&in)", asMETHODPR(T, OnSetAttribute, (const AttributeInfo&, const Variant&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void OnSetAttribute(const AttributeInfo&in, const Variant&in)", AS_METHODPR(T, OnSetAttribute, (const AttributeInfo&, const Variant&), void), AS_CALL_THISCALL);
     // virtual void Component::OnSetEnabled() | File: ../Scene/Component.h
-    engine->RegisterObjectMethod(className, "void OnSetEnabled()", asMETHODPR(T, OnSetEnabled, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void OnSetEnabled()", AS_METHODPR(T, OnSetEnabled, (), void), AS_CALL_THISCALL);
     // void Component::PrepareNetworkUpdate() | File: ../Scene/Component.h
-    engine->RegisterObjectMethod(className, "void PrepareNetworkUpdate()", asMETHODPR(T, PrepareNetworkUpdate, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void PrepareNetworkUpdate()", AS_METHODPR(T, PrepareNetworkUpdate, (), void), AS_CALL_THISCALL);
     // bool Serializable::ReadDeltaUpdate(Deserializer& source) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "bool ReadDeltaUpdate(Deserializer&)", asMETHODPR(T, ReadDeltaUpdate, (Deserializer&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool ReadDeltaUpdate(Deserializer&)", AS_METHODPR(T, ReadDeltaUpdate, (Deserializer&), bool), AS_CALL_THISCALL);
     // bool Serializable::ReadLatestDataUpdate(Deserializer& source) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "bool ReadLatestDataUpdate(Deserializer&)", asMETHODPR(T, ReadLatestDataUpdate, (Deserializer&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool ReadLatestDataUpdate(Deserializer&)", AS_METHODPR(T, ReadLatestDataUpdate, (Deserializer&), bool), AS_CALL_THISCALL);
     // RefCount* RefCounted::RefCountPtr() | File: ../Container/RefCounted.h
     // Error: type "RefCount*" can not automatically bind
     // int RefCounted::Refs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod(className, "int Refs() const", asMETHODPR(T, Refs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "int get_refs() const", asMETHODPR(T, Refs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "int Refs() const", AS_METHODPR(T, Refs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "int get_refs() const", AS_METHODPR(T, Refs, () const, int), AS_CALL_THISCALL);
     // static void Animatable::RegisterObject(Context* context) | File: ../Scene/Animatable.h
     // Not registered because have @nobind mark
     // void RefCounted::ReleaseRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour(className, asBEHAVE_RELEASE, "void f()", asMETHODPR(T, ReleaseRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour(className, asBEHAVE_RELEASE, "void f()", AS_METHODPR(T, ReleaseRef, (), void), AS_CALL_THISCALL);
     // void Component::Remove() | File: ../Scene/Component.h
-    engine->RegisterObjectMethod(className, "void Remove()", asMETHODPR(T, Remove, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void Remove()", AS_METHODPR(T, Remove, (), void), AS_CALL_THISCALL);
     // void Animatable::RemoveAttributeAnimation(const String& name) | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod(className, "void RemoveAttributeAnimation(const String&in)", asMETHODPR(T, RemoveAttributeAnimation, (const String&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void RemoveAttributeAnimation(const String&in)", AS_METHODPR(T, RemoveAttributeAnimation, (const String&), void), AS_CALL_THISCALL);
     // void Serializable::RemoveInstanceDefault() | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "void RemoveInstanceDefault()", asMETHODPR(T, RemoveInstanceDefault, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void RemoveInstanceDefault()", AS_METHODPR(T, RemoveInstanceDefault, (), void), AS_CALL_THISCALL);
     // void Animatable::RemoveObjectAnimation() | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod(className, "void RemoveObjectAnimation()", asMETHODPR(T, RemoveObjectAnimation, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void RemoveObjectAnimation()", AS_METHODPR(T, RemoveObjectAnimation, (), void), AS_CALL_THISCALL);
     // void Serializable::ResetToDefault() | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "void ResetToDefault()", asMETHODPR(T, ResetToDefault, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void ResetToDefault()", AS_METHODPR(T, ResetToDefault, (), void), AS_CALL_THISCALL);
     // bool Component::Save(Serializer& dest) const override | File: ../Scene/Component.h
-    engine->RegisterObjectMethod(className, "bool Save(Serializer&) const", asMETHODPR(T, Save, (Serializer&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool Save(Serializer&) const", AS_METHODPR(T, Save, (Serializer&) const, bool), AS_CALL_THISCALL);
     // virtual bool Serializable::SaveDefaultAttributes() const | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "bool SaveDefaultAttributes() const", asMETHODPR(T, SaveDefaultAttributes, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool SaveDefaultAttributes() const", AS_METHODPR(T, SaveDefaultAttributes, () const, bool), AS_CALL_THISCALL);
     // bool Component::SaveJSON(JSONValue& dest) const override | File: ../Scene/Component.h
-    engine->RegisterObjectMethod(className, "bool SaveJSON(JSONValue&) const", asMETHODPR(T, SaveJSON, (JSONValue&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool SaveJSON(JSONValue&) const", AS_METHODPR(T, SaveJSON, (JSONValue&) const, bool), AS_CALL_THISCALL);
     // bool Component::SaveXML(XMLElement& dest) const override | File: ../Scene/Component.h
-    engine->RegisterObjectMethod(className, "bool SaveXML(XMLElement&) const", asMETHODPR(T, SaveXML, (XMLElement&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool SaveXML(XMLElement&) const", AS_METHODPR(T, SaveXML, (XMLElement&) const, bool), AS_CALL_THISCALL);
     // void Object::SendEvent(StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void SendEvent(StringHash)", asMETHODPR(T, SendEvent, (StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SendEvent(StringHash)", AS_METHODPR(T, SendEvent, (StringHash), void), AS_CALL_THISCALL);
     // void Object::SendEvent(StringHash eventType, VariantMap& eventData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void SendEvent(StringHash, VariantMap&)", asMETHODPR(T, SendEvent, (StringHash, VariantMap&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SendEvent(StringHash, VariantMap&)", AS_METHODPR(T, SendEvent, (StringHash, VariantMap&), void), AS_CALL_THISCALL);
     // template<typename... Args> void Object::SendEvent(StringHash eventType, Args... args) | File: ../Core/Object.h
     // Not registered because template
     // void Animatable::SetAnimationEnabled(bool enable) | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod(className, "void SetAnimationEnabled(bool)", asMETHODPR(T, SetAnimationEnabled, (bool), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "void set_animationEnabled(bool)", asMETHODPR(T, SetAnimationEnabled, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetAnimationEnabled(bool)", AS_METHODPR(T, SetAnimationEnabled, (bool), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void set_animationEnabled(bool)", AS_METHODPR(T, SetAnimationEnabled, (bool), void), AS_CALL_THISCALL);
     // void Animatable::SetAnimationTime(float time) | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod(className, "void SetAnimationTime(float)", asMETHODPR(T, SetAnimationTime, (float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetAnimationTime(float)", AS_METHODPR(T, SetAnimationTime, (float), void), AS_CALL_THISCALL);
     // bool Serializable::SetAttribute(unsigned index, const Variant& value) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "bool SetAttribute(uint, const Variant&in)", asMETHODPR(T, SetAttribute, (unsigned, const Variant&), bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "bool set_attributes(uint, const Variant&in)", asMETHODPR(T, SetAttribute, (unsigned, const Variant&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool SetAttribute(uint, const Variant&in)", AS_METHODPR(T, SetAttribute, (unsigned, const Variant&), bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool set_attributes(uint, const Variant&in)", AS_METHODPR(T, SetAttribute, (unsigned, const Variant&), bool), AS_CALL_THISCALL);
     // bool Serializable::SetAttribute(const String& name, const Variant& value) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "bool SetAttribute(const String&in, const Variant&in)", asMETHODPR(T, SetAttribute, (const String&, const Variant&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool SetAttribute(const String&in, const Variant&in)", AS_METHODPR(T, SetAttribute, (const String&, const Variant&), bool), AS_CALL_THISCALL);
     // void Animatable::SetAttributeAnimation(const String& name, ValueAnimation* attributeAnimation, WrapMode wrapMode=WM_LOOP, float speed=1.0f) | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod(className, "void SetAttributeAnimation(const String&in, ValueAnimation@+, WrapMode = WM_LOOP, float = 1.0f)", asMETHODPR(T, SetAttributeAnimation, (const String&, ValueAnimation*, WrapMode, float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetAttributeAnimation(const String&in, ValueAnimation@+, WrapMode = WM_LOOP, float = 1.0f)", AS_METHODPR(T, SetAttributeAnimation, (const String&, ValueAnimation*, WrapMode, float), void), AS_CALL_THISCALL);
     // void Animatable::SetAttributeAnimationSpeed(const String& name, float speed) | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod(className, "void SetAttributeAnimationSpeed(const String&in, float)", asMETHODPR(T, SetAttributeAnimationSpeed, (const String&, float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetAttributeAnimationSpeed(const String&in, float)", AS_METHODPR(T, SetAttributeAnimationSpeed, (const String&, float), void), AS_CALL_THISCALL);
     // void Animatable::SetAttributeAnimationTime(const String& name, float time) | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod(className, "void SetAttributeAnimationTime(const String&in, float)", asMETHODPR(T, SetAttributeAnimationTime, (const String&, float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetAttributeAnimationTime(const String&in, float)", AS_METHODPR(T, SetAttributeAnimationTime, (const String&, float), void), AS_CALL_THISCALL);
     // void Animatable::SetAttributeAnimationWrapMode(const String& name, WrapMode wrapMode) | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod(className, "void SetAttributeAnimationWrapMode(const String&in, WrapMode)", asMETHODPR(T, SetAttributeAnimationWrapMode, (const String&, WrapMode), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetAttributeAnimationWrapMode(const String&in, WrapMode)", AS_METHODPR(T, SetAttributeAnimationWrapMode, (const String&, WrapMode), void), AS_CALL_THISCALL);
     // void Object::SetBlockEvents(bool block) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void SetBlockEvents(bool)", asMETHODPR(T, SetBlockEvents, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetBlockEvents(bool)", AS_METHODPR(T, SetBlockEvents, (bool), void), AS_CALL_THISCALL);
     // void Component::SetEnabled(bool enable) | File: ../Scene/Component.h
-    engine->RegisterObjectMethod(className, "void SetEnabled(bool)", asMETHODPR(T, SetEnabled, (bool), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "void set_enabled(bool)", asMETHODPR(T, SetEnabled, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetEnabled(bool)", AS_METHODPR(T, SetEnabled, (bool), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void set_enabled(bool)", AS_METHODPR(T, SetEnabled, (bool), void), AS_CALL_THISCALL);
     // void Object::SetGlobalVar(StringHash key, const Variant& value) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void SetGlobalVar(StringHash, const Variant&in)", asMETHODPR(T, SetGlobalVar, (StringHash, const Variant&), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "void set_globalVar(StringHash, const Variant&in)", asMETHODPR(T, SetGlobalVar, (StringHash, const Variant&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetGlobalVar(StringHash, const Variant&in)", AS_METHODPR(T, SetGlobalVar, (StringHash, const Variant&), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void set_globalVar(StringHash, const Variant&in)", AS_METHODPR(T, SetGlobalVar, (StringHash, const Variant&), void), AS_CALL_THISCALL);
     // void Serializable::SetInstanceDefault(bool enable) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "void SetInstanceDefault(bool)", asMETHODPR(T, SetInstanceDefault, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetInstanceDefault(bool)", AS_METHODPR(T, SetInstanceDefault, (bool), void), AS_CALL_THISCALL);
     // void Serializable::SetInterceptNetworkUpdate(const String& attributeName, bool enable) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "void SetInterceptNetworkUpdate(const String&in, bool)", asMETHODPR(T, SetInterceptNetworkUpdate, (const String&, bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetInterceptNetworkUpdate(const String&in, bool)", AS_METHODPR(T, SetInterceptNetworkUpdate, (const String&, bool), void), AS_CALL_THISCALL);
     // void Animatable::SetObjectAnimation(ObjectAnimation* objectAnimation) | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod(className, "void SetObjectAnimation(ObjectAnimation@+)", asMETHODPR(T, SetObjectAnimation, (ObjectAnimation*), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "void set_objectAnimation(ObjectAnimation@+)", asMETHODPR(T, SetObjectAnimation, (ObjectAnimation*), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetObjectAnimation(ObjectAnimation@+)", AS_METHODPR(T, SetObjectAnimation, (ObjectAnimation*), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void set_objectAnimation(ObjectAnimation@+)", AS_METHODPR(T, SetObjectAnimation, (ObjectAnimation*), void), AS_CALL_THISCALL);
     // void Animatable::SetObjectAnimationAttr(const ResourceRef& value) | File: ../Scene/Animatable.h
-    engine->RegisterObjectMethod(className, "void SetObjectAnimationAttr(const ResourceRef&in)", asMETHODPR(T, SetObjectAnimationAttr, (const ResourceRef&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetObjectAnimationAttr(const ResourceRef&in)", AS_METHODPR(T, SetObjectAnimationAttr, (const ResourceRef&), void), AS_CALL_THISCALL);
     // void Serializable::SetTemporary(bool enable) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "void SetTemporary(bool)", asMETHODPR(T, SetTemporary, (bool), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "void set_temporary(bool)", asMETHODPR(T, SetTemporary, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetTemporary(bool)", AS_METHODPR(T, SetTemporary, (bool), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void set_temporary(bool)", AS_METHODPR(T, SetTemporary, (bool), void), AS_CALL_THISCALL);
     // void Object::SubscribeToEvent(StringHash eventType, EventHandler* handler) | File: ../Core/Object.h
     // Error: type "EventHandler*" can not automatically bind
     // void Object::SubscribeToEvent(Object* sender, StringHash eventType, EventHandler* handler) | File: ../Core/Object.h
@@ -289,24 +289,24 @@ template <class T> void RegisterComponent(asIScriptEngine* engine, const char* c
     // void Object::SubscribeToEvent(Object* sender, StringHash eventType, const std::function<void(StringHash, VariantMap&)>& function, void* userData=nullptr) | File: ../Core/Object.h
     // Error: type "const std::function<void(StringHash, VariantMap&)>&" can not automatically bind
     // void Object::UnsubscribeFromAllEvents() | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void UnsubscribeFromAllEvents()", asMETHODPR(T, UnsubscribeFromAllEvents, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void UnsubscribeFromAllEvents()", AS_METHODPR(T, UnsubscribeFromAllEvents, (), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromAllEventsExcept(const PODVector<StringHash>& exceptions, bool onlyUserData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void UnsubscribeFromAllEventsExcept(Array<StringHash>@+, bool)", asFUNCTION(Component_UnsubscribeFromAllEventsExcept_PODVectorStringHash_bool_template), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod(className, "void UnsubscribeFromAllEventsExcept(Array<StringHash>@+, bool)", AS_FUNCTION_OBJFIRST(Component_UnsubscribeFromAllEventsExcept_PODVectorStringHash_bool_template), AS_CALL_CDECL_OBJFIRST);
     // void Object::UnsubscribeFromEvent(StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void UnsubscribeFromEvent(StringHash)", asMETHODPR(T, UnsubscribeFromEvent, (StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void UnsubscribeFromEvent(StringHash)", AS_METHODPR(T, UnsubscribeFromEvent, (StringHash), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromEvent(Object* sender, StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void UnsubscribeFromEvent(Object@+, StringHash)", asMETHODPR(T, UnsubscribeFromEvent, (Object*, StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void UnsubscribeFromEvent(Object@+, StringHash)", AS_METHODPR(T, UnsubscribeFromEvent, (Object*, StringHash), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromEvents(Object* sender) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void UnsubscribeFromEvents(Object@+)", asMETHODPR(T, UnsubscribeFromEvents, (Object*), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void UnsubscribeFromEvents(Object@+)", AS_METHODPR(T, UnsubscribeFromEvents, (Object*), void), AS_CALL_THISCALL);
     // int RefCounted::WeakRefs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod(className, "int WeakRefs() const", asMETHODPR(T, WeakRefs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "int get_weakRefs() const", asMETHODPR(T, WeakRefs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "int WeakRefs() const", AS_METHODPR(T, WeakRefs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "int get_weakRefs() const", AS_METHODPR(T, WeakRefs, () const, int), AS_CALL_THISCALL);
     // void Serializable::WriteDeltaUpdate(Serializer& dest, const DirtyBits& attributeBits, unsigned char timeStamp) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "void WriteDeltaUpdate(Serializer&, const DirtyBits&in, uint8)", asMETHODPR(T, WriteDeltaUpdate, (Serializer&, const DirtyBits&, unsigned char), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void WriteDeltaUpdate(Serializer&, const DirtyBits&in, uint8)", AS_METHODPR(T, WriteDeltaUpdate, (Serializer&, const DirtyBits&, unsigned char), void), AS_CALL_THISCALL);
     // void Serializable::WriteInitialDeltaUpdate(Serializer& dest, unsigned char timeStamp) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "void WriteInitialDeltaUpdate(Serializer&, uint8)", asMETHODPR(T, WriteInitialDeltaUpdate, (Serializer&, unsigned char), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void WriteInitialDeltaUpdate(Serializer&, uint8)", AS_METHODPR(T, WriteInitialDeltaUpdate, (Serializer&, unsigned char), void), AS_CALL_THISCALL);
     // void Serializable::WriteLatestDataUpdate(Serializer& dest, unsigned char timeStamp) | File: ../Scene/Serializable.h
-    engine->RegisterObjectMethod(className, "void WriteLatestDataUpdate(Serializer&, uint8)", asMETHODPR(T, WriteLatestDataUpdate, (Serializer&, unsigned char), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void WriteLatestDataUpdate(Serializer&, uint8)", AS_METHODPR(T, WriteLatestDataUpdate, (Serializer&, unsigned char), void), AS_CALL_THISCALL);
 #ifdef REGISTER_MANUAL_PART_Animatable
     REGISTER_MANUAL_PART_Animatable(T, className)
 #endif
@@ -334,76 +334,76 @@ template <class T> void RegisterObject(asIScriptEngine* engine, const char* clas
     // class Object | File: ../Core/Object.h
     engine->RegisterObjectType(className, 0, asOBJ_REF);
     // void RefCounted::AddRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour(className, asBEHAVE_ADDREF, "void f()", asMETHODPR(T, AddRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour(className, asBEHAVE_ADDREF, "void f()", AS_METHODPR(T, AddRef, (), void), AS_CALL_THISCALL);
     // template<typename T> T* Object::Cast() | File: ../Core/Object.h
     // Not registered because template
     // template<typename T> const T* Object::Cast() const | File: ../Core/Object.h
     // Not registered because template
     // bool Object::GetBlockEvents() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "bool GetBlockEvents() const", asMETHODPR(T, GetBlockEvents, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool GetBlockEvents() const", AS_METHODPR(T, GetBlockEvents, () const, bool), AS_CALL_THISCALL);
     // const String& Object::GetCategory() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "const String& GetCategory() const", asMETHODPR(T, GetCategory, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "const String& get_category() const", asMETHODPR(T, GetCategory, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const String& GetCategory() const", AS_METHODPR(T, GetCategory, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const String& get_category() const", AS_METHODPR(T, GetCategory, () const, const String&), AS_CALL_THISCALL);
     // Context* Object::GetContext() const | File: ../Core/Object.h
     // Error: type "Context*" can used only as function parameter
     // VariantMap& Object::GetEventDataMap() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "VariantMap& GetEventDataMap() const", asMETHODPR(T, GetEventDataMap, () const, VariantMap&), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "VariantMap& GetEventDataMap() const", AS_METHODPR(T, GetEventDataMap, () const, VariantMap&), AS_CALL_THISCALL);
     // EventHandler* Object::GetEventHandler() const | File: ../Core/Object.h
     // Error: type "EventHandler*" can not automatically bind
     // Object* Object::GetEventSender() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "Object@+ GetEventSender() const", asMETHODPR(T, GetEventSender, () const, Object*), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "Object@+ GetEventSender() const", AS_METHODPR(T, GetEventSender, () const, Object*), AS_CALL_THISCALL);
     // const Variant& Object::GetGlobalVar(StringHash key) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "const Variant& GetGlobalVar(StringHash) const", asMETHODPR(T, GetGlobalVar, (StringHash) const, const Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "const Variant& get_globalVar(StringHash) const", asMETHODPR(T, GetGlobalVar, (StringHash) const, const Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const Variant& GetGlobalVar(StringHash) const", AS_METHODPR(T, GetGlobalVar, (StringHash) const, const Variant&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const Variant& get_globalVar(StringHash) const", AS_METHODPR(T, GetGlobalVar, (StringHash) const, const Variant&), AS_CALL_THISCALL);
     // const VariantMap& Object::GetGlobalVars() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "const VariantMap& GetGlobalVars() const", asMETHODPR(T, GetGlobalVars, () const, const VariantMap&), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "const VariantMap& get_globalVars() const", asMETHODPR(T, GetGlobalVars, () const, const VariantMap&), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const VariantMap& GetGlobalVars() const", AS_METHODPR(T, GetGlobalVars, () const, const VariantMap&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const VariantMap& get_globalVars() const", AS_METHODPR(T, GetGlobalVars, () const, const VariantMap&), AS_CALL_THISCALL);
     // Object* Object::GetSubsystem(StringHash type) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "Object@+ GetSubsystem(StringHash) const", asMETHODPR(T, GetSubsystem, (StringHash) const, Object*), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "Object@+ GetSubsystem(StringHash) const", AS_METHODPR(T, GetSubsystem, (StringHash) const, Object*), AS_CALL_THISCALL);
     // template<class T> T* Object::GetSubsystem() const | File: ../Core/Object.h
     // Not registered because template
     // virtual StringHash Object::GetType() const =0 | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "StringHash GetType() const", asMETHODPR(T, GetType, () const, StringHash), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "StringHash get_type() const", asMETHODPR(T, GetType, () const, StringHash), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "StringHash GetType() const", AS_METHODPR(T, GetType, () const, StringHash), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "StringHash get_type() const", AS_METHODPR(T, GetType, () const, StringHash), AS_CALL_THISCALL);
     // virtual const TypeInfo* Object::GetTypeInfo() const =0 | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // static const TypeInfo* Object::GetTypeInfoStatic() | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // virtual const String& Object::GetTypeName() const =0 | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "const String& GetTypeName() const", asMETHODPR(T, GetTypeName, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "const String& get_typeName() const", asMETHODPR(T, GetTypeName, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const String& GetTypeName() const", AS_METHODPR(T, GetTypeName, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const String& get_typeName() const", AS_METHODPR(T, GetTypeName, () const, const String&), AS_CALL_THISCALL);
     // bool Object::HasEventHandlers() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "bool HasEventHandlers() const", asMETHODPR(T, HasEventHandlers, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool HasEventHandlers() const", AS_METHODPR(T, HasEventHandlers, () const, bool), AS_CALL_THISCALL);
     // bool Object::HasSubscribedToEvent(StringHash eventType) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "bool HasSubscribedToEvent(StringHash) const", asMETHODPR(T, HasSubscribedToEvent, (StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool HasSubscribedToEvent(StringHash) const", AS_METHODPR(T, HasSubscribedToEvent, (StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::HasSubscribedToEvent(Object* sender, StringHash eventType) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "bool HasSubscribedToEvent(Object@+, StringHash) const", asMETHODPR(T, HasSubscribedToEvent, (Object*, StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool HasSubscribedToEvent(Object@+, StringHash) const", AS_METHODPR(T, HasSubscribedToEvent, (Object*, StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::IsInstanceOf(StringHash type) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "bool IsInstanceOf(StringHash) const", asMETHODPR(T, IsInstanceOf, (StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool IsInstanceOf(StringHash) const", AS_METHODPR(T, IsInstanceOf, (StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::IsInstanceOf(const TypeInfo* typeInfo) const | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // template<typename T> bool Object::IsInstanceOf() const | File: ../Core/Object.h
     // Not registered because template
     // virtual void Object::OnEvent(Object* sender, StringHash eventType, VariantMap& eventData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void OnEvent(Object@+, StringHash, VariantMap&)", asMETHODPR(T, OnEvent, (Object*, StringHash, VariantMap&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void OnEvent(Object@+, StringHash, VariantMap&)", AS_METHODPR(T, OnEvent, (Object*, StringHash, VariantMap&), void), AS_CALL_THISCALL);
     // RefCount* RefCounted::RefCountPtr() | File: ../Container/RefCounted.h
     // Error: type "RefCount*" can not automatically bind
     // int RefCounted::Refs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod(className, "int Refs() const", asMETHODPR(T, Refs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "int get_refs() const", asMETHODPR(T, Refs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "int Refs() const", AS_METHODPR(T, Refs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "int get_refs() const", AS_METHODPR(T, Refs, () const, int), AS_CALL_THISCALL);
     // void RefCounted::ReleaseRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour(className, asBEHAVE_RELEASE, "void f()", asMETHODPR(T, ReleaseRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour(className, asBEHAVE_RELEASE, "void f()", AS_METHODPR(T, ReleaseRef, (), void), AS_CALL_THISCALL);
     // void Object::SendEvent(StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void SendEvent(StringHash)", asMETHODPR(T, SendEvent, (StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SendEvent(StringHash)", AS_METHODPR(T, SendEvent, (StringHash), void), AS_CALL_THISCALL);
     // void Object::SendEvent(StringHash eventType, VariantMap& eventData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void SendEvent(StringHash, VariantMap&)", asMETHODPR(T, SendEvent, (StringHash, VariantMap&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SendEvent(StringHash, VariantMap&)", AS_METHODPR(T, SendEvent, (StringHash, VariantMap&), void), AS_CALL_THISCALL);
     // template<typename... Args> void Object::SendEvent(StringHash eventType, Args... args) | File: ../Core/Object.h
     // Not registered because template
     // void Object::SetBlockEvents(bool block) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void SetBlockEvents(bool)", asMETHODPR(T, SetBlockEvents, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetBlockEvents(bool)", AS_METHODPR(T, SetBlockEvents, (bool), void), AS_CALL_THISCALL);
     // void Object::SetGlobalVar(StringHash key, const Variant& value) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void SetGlobalVar(StringHash, const Variant&in)", asMETHODPR(T, SetGlobalVar, (StringHash, const Variant&), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "void set_globalVar(StringHash, const Variant&in)", asMETHODPR(T, SetGlobalVar, (StringHash, const Variant&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetGlobalVar(StringHash, const Variant&in)", AS_METHODPR(T, SetGlobalVar, (StringHash, const Variant&), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void set_globalVar(StringHash, const Variant&in)", AS_METHODPR(T, SetGlobalVar, (StringHash, const Variant&), void), AS_CALL_THISCALL);
     // void Object::SubscribeToEvent(StringHash eventType, EventHandler* handler) | File: ../Core/Object.h
     // Error: type "EventHandler*" can not automatically bind
     // void Object::SubscribeToEvent(Object* sender, StringHash eventType, EventHandler* handler) | File: ../Core/Object.h
@@ -413,18 +413,18 @@ template <class T> void RegisterObject(asIScriptEngine* engine, const char* clas
     // void Object::SubscribeToEvent(Object* sender, StringHash eventType, const std::function<void(StringHash, VariantMap&)>& function, void* userData=nullptr) | File: ../Core/Object.h
     // Error: type "const std::function<void(StringHash, VariantMap&)>&" can not automatically bind
     // void Object::UnsubscribeFromAllEvents() | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void UnsubscribeFromAllEvents()", asMETHODPR(T, UnsubscribeFromAllEvents, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void UnsubscribeFromAllEvents()", AS_METHODPR(T, UnsubscribeFromAllEvents, (), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromAllEventsExcept(const PODVector<StringHash>& exceptions, bool onlyUserData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void UnsubscribeFromAllEventsExcept(Array<StringHash>@+, bool)", asFUNCTION(Object_UnsubscribeFromAllEventsExcept_PODVectorStringHash_bool_template), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod(className, "void UnsubscribeFromAllEventsExcept(Array<StringHash>@+, bool)", AS_FUNCTION_OBJFIRST(Object_UnsubscribeFromAllEventsExcept_PODVectorStringHash_bool_template), AS_CALL_CDECL_OBJFIRST);
     // void Object::UnsubscribeFromEvent(StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void UnsubscribeFromEvent(StringHash)", asMETHODPR(T, UnsubscribeFromEvent, (StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void UnsubscribeFromEvent(StringHash)", AS_METHODPR(T, UnsubscribeFromEvent, (StringHash), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromEvent(Object* sender, StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void UnsubscribeFromEvent(Object@+, StringHash)", asMETHODPR(T, UnsubscribeFromEvent, (Object*, StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void UnsubscribeFromEvent(Object@+, StringHash)", AS_METHODPR(T, UnsubscribeFromEvent, (Object*, StringHash), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromEvents(Object* sender) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void UnsubscribeFromEvents(Object@+)", asMETHODPR(T, UnsubscribeFromEvents, (Object*), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void UnsubscribeFromEvents(Object@+)", AS_METHODPR(T, UnsubscribeFromEvents, (Object*), void), AS_CALL_THISCALL);
     // int RefCounted::WeakRefs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod(className, "int WeakRefs() const", asMETHODPR(T, WeakRefs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "int get_weakRefs() const", asMETHODPR(T, WeakRefs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "int WeakRefs() const", AS_METHODPR(T, WeakRefs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "int get_weakRefs() const", AS_METHODPR(T, WeakRefs, () const, int), AS_CALL_THISCALL);
 #ifdef REGISTER_MANUAL_PART_RefCounted
     REGISTER_MANUAL_PART_RefCounted(T, className)
 #endif
@@ -440,117 +440,117 @@ template <class T> void RegisterResource(asIScriptEngine* engine, const char* cl
     // class Resource | File: ../Resource/Resource.h
     engine->RegisterObjectType(className, 0, asOBJ_REF);
     // void RefCounted::AddRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour(className, asBEHAVE_ADDREF, "void f()", asMETHODPR(T, AddRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour(className, asBEHAVE_ADDREF, "void f()", AS_METHODPR(T, AddRef, (), void), AS_CALL_THISCALL);
     // virtual bool Resource::BeginLoad(Deserializer& source) | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod(className, "bool BeginLoad(Deserializer&)", asMETHODPR(T, BeginLoad, (Deserializer&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool BeginLoad(Deserializer&)", AS_METHODPR(T, BeginLoad, (Deserializer&), bool), AS_CALL_THISCALL);
     // template<typename T> T* Object::Cast() | File: ../Core/Object.h
     // Not registered because template
     // template<typename T> const T* Object::Cast() const | File: ../Core/Object.h
     // Not registered because template
     // virtual bool Resource::EndLoad() | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod(className, "bool EndLoad()", asMETHODPR(T, EndLoad, (), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool EndLoad()", AS_METHODPR(T, EndLoad, (), bool), AS_CALL_THISCALL);
     // AsyncLoadState Resource::GetAsyncLoadState() const | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod(className, "AsyncLoadState GetAsyncLoadState() const", asMETHODPR(T, GetAsyncLoadState, () const, AsyncLoadState), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "AsyncLoadState GetAsyncLoadState() const", AS_METHODPR(T, GetAsyncLoadState, () const, AsyncLoadState), AS_CALL_THISCALL);
     // bool Object::GetBlockEvents() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "bool GetBlockEvents() const", asMETHODPR(T, GetBlockEvents, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool GetBlockEvents() const", AS_METHODPR(T, GetBlockEvents, () const, bool), AS_CALL_THISCALL);
     // const String& Object::GetCategory() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "const String& GetCategory() const", asMETHODPR(T, GetCategory, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "const String& get_category() const", asMETHODPR(T, GetCategory, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const String& GetCategory() const", AS_METHODPR(T, GetCategory, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const String& get_category() const", AS_METHODPR(T, GetCategory, () const, const String&), AS_CALL_THISCALL);
     // Context* Object::GetContext() const | File: ../Core/Object.h
     // Error: type "Context*" can used only as function parameter
     // VariantMap& Object::GetEventDataMap() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "VariantMap& GetEventDataMap() const", asMETHODPR(T, GetEventDataMap, () const, VariantMap&), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "VariantMap& GetEventDataMap() const", AS_METHODPR(T, GetEventDataMap, () const, VariantMap&), AS_CALL_THISCALL);
     // EventHandler* Object::GetEventHandler() const | File: ../Core/Object.h
     // Error: type "EventHandler*" can not automatically bind
     // Object* Object::GetEventSender() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "Object@+ GetEventSender() const", asMETHODPR(T, GetEventSender, () const, Object*), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "Object@+ GetEventSender() const", AS_METHODPR(T, GetEventSender, () const, Object*), AS_CALL_THISCALL);
     // const Variant& Object::GetGlobalVar(StringHash key) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "const Variant& GetGlobalVar(StringHash) const", asMETHODPR(T, GetGlobalVar, (StringHash) const, const Variant&), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "const Variant& get_globalVar(StringHash) const", asMETHODPR(T, GetGlobalVar, (StringHash) const, const Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const Variant& GetGlobalVar(StringHash) const", AS_METHODPR(T, GetGlobalVar, (StringHash) const, const Variant&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const Variant& get_globalVar(StringHash) const", AS_METHODPR(T, GetGlobalVar, (StringHash) const, const Variant&), AS_CALL_THISCALL);
     // const VariantMap& Object::GetGlobalVars() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "const VariantMap& GetGlobalVars() const", asMETHODPR(T, GetGlobalVars, () const, const VariantMap&), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "const VariantMap& get_globalVars() const", asMETHODPR(T, GetGlobalVars, () const, const VariantMap&), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const VariantMap& GetGlobalVars() const", AS_METHODPR(T, GetGlobalVars, () const, const VariantMap&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const VariantMap& get_globalVars() const", AS_METHODPR(T, GetGlobalVars, () const, const VariantMap&), AS_CALL_THISCALL);
     // unsigned Resource::GetMemoryUse() const | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod(className, "uint GetMemoryUse() const", asMETHODPR(T, GetMemoryUse, () const, unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "uint get_memoryUse() const", asMETHODPR(T, GetMemoryUse, () const, unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "uint GetMemoryUse() const", AS_METHODPR(T, GetMemoryUse, () const, unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "uint get_memoryUse() const", AS_METHODPR(T, GetMemoryUse, () const, unsigned), AS_CALL_THISCALL);
     // const String& Resource::GetName() const | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod(className, "const String& GetName() const", asMETHODPR(T, GetName, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "const String& get_name() const", asMETHODPR(T, GetName, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const String& GetName() const", AS_METHODPR(T, GetName, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const String& get_name() const", AS_METHODPR(T, GetName, () const, const String&), AS_CALL_THISCALL);
     // StringHash Resource::GetNameHash() const | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod(className, "StringHash GetNameHash() const", asMETHODPR(T, GetNameHash, () const, StringHash), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "StringHash GetNameHash() const", AS_METHODPR(T, GetNameHash, () const, StringHash), AS_CALL_THISCALL);
     // Object* Object::GetSubsystem(StringHash type) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "Object@+ GetSubsystem(StringHash) const", asMETHODPR(T, GetSubsystem, (StringHash) const, Object*), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "Object@+ GetSubsystem(StringHash) const", AS_METHODPR(T, GetSubsystem, (StringHash) const, Object*), AS_CALL_THISCALL);
     // template<class T> T* Object::GetSubsystem() const | File: ../Core/Object.h
     // Not registered because template
     // virtual StringHash Object::GetType() const =0 | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "StringHash GetType() const", asMETHODPR(T, GetType, () const, StringHash), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "StringHash get_type() const", asMETHODPR(T, GetType, () const, StringHash), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "StringHash GetType() const", AS_METHODPR(T, GetType, () const, StringHash), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "StringHash get_type() const", AS_METHODPR(T, GetType, () const, StringHash), AS_CALL_THISCALL);
     // virtual const TypeInfo* Object::GetTypeInfo() const =0 | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // static const TypeInfo* Object::GetTypeInfoStatic() | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // virtual const String& Object::GetTypeName() const =0 | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "const String& GetTypeName() const", asMETHODPR(T, GetTypeName, () const, const String&), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "const String& get_typeName() const", asMETHODPR(T, GetTypeName, () const, const String&), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const String& GetTypeName() const", AS_METHODPR(T, GetTypeName, () const, const String&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const String& get_typeName() const", AS_METHODPR(T, GetTypeName, () const, const String&), AS_CALL_THISCALL);
     // unsigned Resource::GetUseTimer() | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod(className, "uint GetUseTimer()", asMETHODPR(T, GetUseTimer, (), unsigned), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "uint get_useTimer()", asMETHODPR(T, GetUseTimer, (), unsigned), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "uint GetUseTimer()", AS_METHODPR(T, GetUseTimer, (), unsigned), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "uint get_useTimer()", AS_METHODPR(T, GetUseTimer, (), unsigned), AS_CALL_THISCALL);
     // bool Object::HasEventHandlers() const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "bool HasEventHandlers() const", asMETHODPR(T, HasEventHandlers, () const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool HasEventHandlers() const", AS_METHODPR(T, HasEventHandlers, () const, bool), AS_CALL_THISCALL);
     // bool Object::HasSubscribedToEvent(StringHash eventType) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "bool HasSubscribedToEvent(StringHash) const", asMETHODPR(T, HasSubscribedToEvent, (StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool HasSubscribedToEvent(StringHash) const", AS_METHODPR(T, HasSubscribedToEvent, (StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::HasSubscribedToEvent(Object* sender, StringHash eventType) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "bool HasSubscribedToEvent(Object@+, StringHash) const", asMETHODPR(T, HasSubscribedToEvent, (Object*, StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool HasSubscribedToEvent(Object@+, StringHash) const", AS_METHODPR(T, HasSubscribedToEvent, (Object*, StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::IsInstanceOf(StringHash type) const | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "bool IsInstanceOf(StringHash) const", asMETHODPR(T, IsInstanceOf, (StringHash) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool IsInstanceOf(StringHash) const", AS_METHODPR(T, IsInstanceOf, (StringHash) const, bool), AS_CALL_THISCALL);
     // bool Object::IsInstanceOf(const TypeInfo* typeInfo) const | File: ../Core/Object.h
     // Error: type "TypeInfo" can not automatically bind bacause have @nobind mark
     // template<typename T> bool Object::IsInstanceOf() const | File: ../Core/Object.h
     // Not registered because template
     // bool Resource::Load(Deserializer& source) | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod(className, "bool Load(Deserializer&)", asMETHODPR(T, Load, (Deserializer&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool Load(Deserializer&)", AS_METHODPR(T, Load, (Deserializer&), bool), AS_CALL_THISCALL);
     // bool Resource::LoadFile(const String& fileName) | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod(className, "bool LoadFile(const String&in)", asMETHODPR(T, LoadFile, (const String&), bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "bool Load(const String&in)", asMETHODPR(T, LoadFile, (const String&), bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool LoadFile(const String&in)", AS_METHODPR(T, LoadFile, (const String&), bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool Load(const String&in)", AS_METHODPR(T, LoadFile, (const String&), bool), AS_CALL_THISCALL);
     // virtual void Object::OnEvent(Object* sender, StringHash eventType, VariantMap& eventData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void OnEvent(Object@+, StringHash, VariantMap&)", asMETHODPR(T, OnEvent, (Object*, StringHash, VariantMap&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void OnEvent(Object@+, StringHash, VariantMap&)", AS_METHODPR(T, OnEvent, (Object*, StringHash, VariantMap&), void), AS_CALL_THISCALL);
     // RefCount* RefCounted::RefCountPtr() | File: ../Container/RefCounted.h
     // Error: type "RefCount*" can not automatically bind
     // int RefCounted::Refs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod(className, "int Refs() const", asMETHODPR(T, Refs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "int get_refs() const", asMETHODPR(T, Refs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "int Refs() const", AS_METHODPR(T, Refs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "int get_refs() const", AS_METHODPR(T, Refs, () const, int), AS_CALL_THISCALL);
     // void RefCounted::ReleaseRef() | File: ../Container/RefCounted.h
-    engine->RegisterObjectBehaviour(className, asBEHAVE_RELEASE, "void f()", asMETHODPR(T, ReleaseRef, (), void), asCALL_THISCALL);
+    engine->RegisterObjectBehaviour(className, asBEHAVE_RELEASE, "void f()", AS_METHODPR(T, ReleaseRef, (), void), AS_CALL_THISCALL);
     // void Resource::ResetUseTimer() | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod(className, "void ResetUseTimer()", asMETHODPR(T, ResetUseTimer, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void ResetUseTimer()", AS_METHODPR(T, ResetUseTimer, (), void), AS_CALL_THISCALL);
     // explicit Resource::Resource(Context* context) | File: ../Resource/Resource.h
     {
         String declFactory(String(className) + "@ f()");
-        engine->RegisterObjectBehaviour(className, asBEHAVE_FACTORY, declFactory.CString(), asFUNCTION(Resource_Resource_Context_template), asCALL_CDECL);
+        engine->RegisterObjectBehaviour(className, asBEHAVE_FACTORY, declFactory.CString(), AS_FUNCTION(Resource_Resource_Context_template), AS_CALL_CDECL);
     }
     // virtual bool Resource::Save(Serializer& dest) const | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod(className, "bool Save(Serializer&) const", asMETHODPR(T, Save, (Serializer&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool Save(Serializer&) const", AS_METHODPR(T, Save, (Serializer&) const, bool), AS_CALL_THISCALL);
     // virtual bool Resource::SaveFile(const String& fileName) const | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod(className, "bool SaveFile(const String&in) const", asMETHODPR(T, SaveFile, (const String&) const, bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "bool Save(const String&in) const", asMETHODPR(T, SaveFile, (const String&) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool SaveFile(const String&in) const", AS_METHODPR(T, SaveFile, (const String&) const, bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool Save(const String&in) const", AS_METHODPR(T, SaveFile, (const String&) const, bool), AS_CALL_THISCALL);
     // void Object::SendEvent(StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void SendEvent(StringHash)", asMETHODPR(T, SendEvent, (StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SendEvent(StringHash)", AS_METHODPR(T, SendEvent, (StringHash), void), AS_CALL_THISCALL);
     // void Object::SendEvent(StringHash eventType, VariantMap& eventData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void SendEvent(StringHash, VariantMap&)", asMETHODPR(T, SendEvent, (StringHash, VariantMap&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SendEvent(StringHash, VariantMap&)", AS_METHODPR(T, SendEvent, (StringHash, VariantMap&), void), AS_CALL_THISCALL);
     // template<typename... Args> void Object::SendEvent(StringHash eventType, Args... args) | File: ../Core/Object.h
     // Not registered because template
     // void Resource::SetAsyncLoadState(AsyncLoadState newState) | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod(className, "void SetAsyncLoadState(AsyncLoadState)", asMETHODPR(T, SetAsyncLoadState, (AsyncLoadState), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetAsyncLoadState(AsyncLoadState)", AS_METHODPR(T, SetAsyncLoadState, (AsyncLoadState), void), AS_CALL_THISCALL);
     // void Object::SetBlockEvents(bool block) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void SetBlockEvents(bool)", asMETHODPR(T, SetBlockEvents, (bool), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetBlockEvents(bool)", AS_METHODPR(T, SetBlockEvents, (bool), void), AS_CALL_THISCALL);
     // void Object::SetGlobalVar(StringHash key, const Variant& value) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void SetGlobalVar(StringHash, const Variant&in)", asMETHODPR(T, SetGlobalVar, (StringHash, const Variant&), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "void set_globalVar(StringHash, const Variant&in)", asMETHODPR(T, SetGlobalVar, (StringHash, const Variant&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetGlobalVar(StringHash, const Variant&in)", AS_METHODPR(T, SetGlobalVar, (StringHash, const Variant&), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void set_globalVar(StringHash, const Variant&in)", AS_METHODPR(T, SetGlobalVar, (StringHash, const Variant&), void), AS_CALL_THISCALL);
     // void Resource::SetMemoryUse(unsigned size) | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod(className, "void SetMemoryUse(uint)", asMETHODPR(T, SetMemoryUse, (unsigned), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetMemoryUse(uint)", AS_METHODPR(T, SetMemoryUse, (unsigned), void), AS_CALL_THISCALL);
     // void Resource::SetName(const String& name) | File: ../Resource/Resource.h
-    engine->RegisterObjectMethod(className, "void SetName(const String&in)", asMETHODPR(T, SetName, (const String&), void), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "void set_name(const String&in)", asMETHODPR(T, SetName, (const String&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void SetName(const String&in)", AS_METHODPR(T, SetName, (const String&), void), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void set_name(const String&in)", AS_METHODPR(T, SetName, (const String&), void), AS_CALL_THISCALL);
     // void Object::SubscribeToEvent(StringHash eventType, EventHandler* handler) | File: ../Core/Object.h
     // Error: type "EventHandler*" can not automatically bind
     // void Object::SubscribeToEvent(Object* sender, StringHash eventType, EventHandler* handler) | File: ../Core/Object.h
@@ -560,18 +560,18 @@ template <class T> void RegisterResource(asIScriptEngine* engine, const char* cl
     // void Object::SubscribeToEvent(Object* sender, StringHash eventType, const std::function<void(StringHash, VariantMap&)>& function, void* userData=nullptr) | File: ../Core/Object.h
     // Error: type "const std::function<void(StringHash, VariantMap&)>&" can not automatically bind
     // void Object::UnsubscribeFromAllEvents() | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void UnsubscribeFromAllEvents()", asMETHODPR(T, UnsubscribeFromAllEvents, (), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void UnsubscribeFromAllEvents()", AS_METHODPR(T, UnsubscribeFromAllEvents, (), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromAllEventsExcept(const PODVector<StringHash>& exceptions, bool onlyUserData) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void UnsubscribeFromAllEventsExcept(Array<StringHash>@+, bool)", asFUNCTION(Resource_UnsubscribeFromAllEventsExcept_PODVectorStringHash_bool_template), asCALL_CDECL_OBJFIRST);
+    engine->RegisterObjectMethod(className, "void UnsubscribeFromAllEventsExcept(Array<StringHash>@+, bool)", AS_FUNCTION_OBJFIRST(Resource_UnsubscribeFromAllEventsExcept_PODVectorStringHash_bool_template), AS_CALL_CDECL_OBJFIRST);
     // void Object::UnsubscribeFromEvent(StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void UnsubscribeFromEvent(StringHash)", asMETHODPR(T, UnsubscribeFromEvent, (StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void UnsubscribeFromEvent(StringHash)", AS_METHODPR(T, UnsubscribeFromEvent, (StringHash), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromEvent(Object* sender, StringHash eventType) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void UnsubscribeFromEvent(Object@+, StringHash)", asMETHODPR(T, UnsubscribeFromEvent, (Object*, StringHash), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void UnsubscribeFromEvent(Object@+, StringHash)", AS_METHODPR(T, UnsubscribeFromEvent, (Object*, StringHash), void), AS_CALL_THISCALL);
     // void Object::UnsubscribeFromEvents(Object* sender) | File: ../Core/Object.h
-    engine->RegisterObjectMethod(className, "void UnsubscribeFromEvents(Object@+)", asMETHODPR(T, UnsubscribeFromEvents, (Object*), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void UnsubscribeFromEvents(Object@+)", AS_METHODPR(T, UnsubscribeFromEvents, (Object*), void), AS_CALL_THISCALL);
     // int RefCounted::WeakRefs() const | File: ../Container/RefCounted.h
-    engine->RegisterObjectMethod(className, "int WeakRefs() const", asMETHODPR(T, WeakRefs, () const, int), asCALL_THISCALL);
-    engine->RegisterObjectMethod(className, "int get_weakRefs() const", asMETHODPR(T, WeakRefs, () const, int), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "int WeakRefs() const", AS_METHODPR(T, WeakRefs, () const, int), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod(className, "int get_weakRefs() const", AS_METHODPR(T, WeakRefs, () const, int), AS_CALL_THISCALL);
 #ifdef REGISTER_MANUAL_PART_Object
     REGISTER_MANUAL_PART_Object(T, className)
 #endif

Source/Urho3D/AngelScript/Manual_Audio.cpp

@@ -45,7 +45,7 @@ static Audio* GetAudio()
 void ASRegisterManualLast_Audio(asIScriptEngine* engine)
 {
     // template<class T> T * Object::GetSubsystem() const | File: ../Core/Object.h
-    engine->RegisterGlobalFunction("Audio@+ get_audio()", asFUNCTION(GetAudio), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Audio@+ get_audio()", AS_FUNCTION(GetAudio), AS_CALL_CDECL);
 }
 
 }

Source/Urho3D/AngelScript/Manual_Container.cpp

@@ -144,22 +144,22 @@ void ASRegisterManualLast_Container(asIScriptEngine* engine)
     static StringFactory stringFactory;
     engine->RegisterStringFactory("String", &stringFactory);
 
-    engine->RegisterObjectMethod("String", "String& opAssign(int)", asFUNCTION(StringAssignInt), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String opAdd(int) const", asFUNCTION(StringAddInt), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String opAdd_r(int) const", asFUNCTION(StringAddIntReverse), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String& opAssign(uint)", asFUNCTION(StringAssignUInt), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String opAdd(uint) const", asFUNCTION(StringAddUInt), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String opAdd_r(uint) const", asFUNCTION(StringAddUIntReverse), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String& opAssign(float)", asFUNCTION(StringAssignFloat), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String opAdd(float) const", asFUNCTION(StringAddFloat), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String opAdd_r(float) const", asFUNCTION(StringAddFloatReverse), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String& opAssign(double)", asFUNCTION(StringAssignDouble), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String& opAddAssign(double)", asFUNCTION(StringAddAssignDouble), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String opAdd(double) const", asFUNCTION(StringAddDouble), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String opAdd_r(double) const", asFUNCTION(StringAddDoubleReverse), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String& opAssign(bool)", asFUNCTION(StringAssignBool), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String opAdd(bool) const", asFUNCTION(StringAddBool), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("String", "String opAdd_r(bool) const", asFUNCTION(StringAddBoolReverse), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String& opAssign(int)", AS_FUNCTION_OBJLAST(StringAssignInt), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String opAdd(int) const", AS_FUNCTION_OBJLAST(StringAddInt), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String opAdd_r(int) const", AS_FUNCTION_OBJLAST(StringAddIntReverse), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String& opAssign(uint)", AS_FUNCTION_OBJLAST(StringAssignUInt), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String opAdd(uint) const", AS_FUNCTION_OBJLAST(StringAddUInt), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String opAdd_r(uint) const", AS_FUNCTION_OBJLAST(StringAddUIntReverse), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String& opAssign(float)", AS_FUNCTION_OBJLAST(StringAssignFloat), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String opAdd(float) const", AS_FUNCTION_OBJLAST(StringAddFloat), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String opAdd_r(float) const", AS_FUNCTION_OBJLAST(StringAddFloatReverse), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String& opAssign(double)", AS_FUNCTION_OBJLAST(StringAssignDouble), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String& opAddAssign(double)", AS_FUNCTION_OBJLAST(StringAddAssignDouble), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String opAdd(double) const", AS_FUNCTION_OBJLAST(StringAddDouble), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String opAdd_r(double) const", AS_FUNCTION_OBJLAST(StringAddDoubleReverse), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String& opAssign(bool)", AS_FUNCTION_OBJLAST(StringAssignBool), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String opAdd(bool) const", AS_FUNCTION_OBJLAST(StringAddBool), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("String", "String opAdd_r(bool) const", AS_FUNCTION_OBJLAST(StringAddBoolReverse), AS_CALL_CDECL_OBJLAST);
 }
 
 }

Source/Urho3D/AngelScript/Manual_Core.cpp

@@ -53,13 +53,6 @@ static void ConstructVariantMapCopy(const VariantMap& map, VariantMap* ptr)
     new(ptr) VariantMap(map);
 }
 
-// using VariantMap = HashMap<StringHash, Variant> | File: ../Core/Variant.h
-// HashMap::~HashMap() | File: ../Container/HashMap.h
-static void DestructVariantMap(VariantMap* ptr)
-{
-    ptr->~VariantMap();
-}
-
 // using VariantMap = HashMap<StringHash, Variant> | File: ../Core/Variant.h
 // U& HashMap::operator [](const T& key) | File: ../Container/HashMap.h
 static Variant& VariantMapAtHash(StringHash key, VariantMap& map)
@@ -99,37 +92,37 @@ static void RegisterVariantMap(asIScriptEngine* engine)
 {
     // using VariantMap = HashMap<StringHash, Variant> | File: ../Core/Variant.h
     // unsigned HashBase::Size() const | File: ../Container/HashBase.h
-    engine->RegisterObjectMethod("VariantMap", "uint get_length() const", asMETHOD(VariantMap, Size), asCALL_THISCALL);
+    engine->RegisterObjectMethod("VariantMap", "uint get_length() const", AS_METHOD(VariantMap, Size), AS_CALL_THISCALL);
     // using VariantMap = HashMap<StringHash, Variant> | File: ../Core/Variant.h
     // void HashMap::Clear() | File: ../Container/HashMap.h
-    engine->RegisterObjectMethod("VariantMap", "void Clear()", asMETHOD(VariantMap, Clear), asCALL_THISCALL);
+    engine->RegisterObjectMethod("VariantMap", "void Clear()", AS_METHOD(VariantMap, Clear), AS_CALL_THISCALL);
     // using VariantMap = HashMap<StringHash, Variant> | File: ../Core/Variant.h
     // HashMap& operator =(const HashMap<T, U>& rhs) | File: ../Container/HashMap.h
-    engine->RegisterObjectMethod("VariantMap", "VariantMap& opAssign(const VariantMap&in)", asMETHODPR(VariantMap, operator =, (const VariantMap&), VariantMap&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("VariantMap", "VariantMap& opAssign(const VariantMap&in)", AS_METHODPR(VariantMap, operator =, (const VariantMap&), VariantMap&), AS_CALL_THISCALL);
     // using VariantMap = HashMap<StringHash, Variant> | File: ../Core/Variant.h
     // HashMap::HashMap()| File: ../Container/HashMap.h
-    engine->RegisterObjectBehaviour("VariantMap", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructVariantMap), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectBehaviour("VariantMap", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJLAST(ConstructVariantMap), AS_CALL_CDECL_OBJLAST);
     // using VariantMap = HashMap<StringHash, Variant> | File: ../Core/Variant.h
     // HashMap::HashMap(const HashMap<T, U>& map) | File: ../Container/HashMap.h
-    engine->RegisterObjectBehaviour("VariantMap", asBEHAVE_CONSTRUCT, "void f(const VariantMap&in)", asFUNCTION(ConstructVariantMapCopy), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectBehaviour("VariantMap", asBEHAVE_CONSTRUCT, "void f(const VariantMap&in)", AS_FUNCTION_OBJLAST(ConstructVariantMapCopy), AS_CALL_CDECL_OBJLAST);
     // using VariantMap = HashMap<StringHash, Variant> | File: ../Core/Variant.h
     // HashMap::~HashMap() | File: ../Container/HashMap.h
-    engine->RegisterObjectBehaviour("VariantMap", asBEHAVE_DESTRUCT, "void f()", asFUNCTION(DestructVariantMap), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectBehaviour("VariantMap", asBEHAVE_DESTRUCT, "void f()", AS_DESTRUCTOR(VariantMap), AS_CALL_CDECL_OBJLAST);
     // using VariantMap = HashMap<StringHash, Variant> | File: ../Core/Variant.h
     // U& HashMap::operator [](const T& key) | File: ../Container/HashMap.h
-    engine->RegisterObjectMethod("VariantMap", "Variant& opIndex(StringHash)", asFUNCTION(VariantMapAtHash), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("VariantMap", "Variant& opIndex(StringHash)", AS_FUNCTION_OBJLAST(VariantMapAtHash), AS_CALL_CDECL_OBJLAST);
     // using VariantMap = HashMap<StringHash, Variant> | File: ../Core/Variant.h
     // bool HashMap::Contains(const T& key) const | File: ../Container/HashMap.h
-    engine->RegisterObjectMethod("VariantMap", "bool Contains(StringHash) const", asFUNCTION(VariantMapContainsHash), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("VariantMap", "bool Contains(StringHash) const", AS_FUNCTION_OBJLAST(VariantMapContainsHash), AS_CALL_CDECL_OBJLAST);
     // using VariantMap = HashMap<StringHash, Variant> | File: ../Core/Variant.h
     // bool HashMap::Erase(const T& key) | File: ../Container/HashMap.h
-    engine->RegisterObjectMethod("VariantMap", "bool Erase(StringHash)", asFUNCTION(VariantMapEraseHash), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("VariantMap", "bool Erase(StringHash)", AS_FUNCTION_OBJLAST(VariantMapEraseHash), AS_CALL_CDECL_OBJLAST);
     // using VariantMap = HashMap<StringHash, Variant> | File: ../Core/Variant.h
     // Vector<T> HashMap::Keys() const | File: ../Container/HashMap.h
-    engine->RegisterObjectMethod("VariantMap", "Array<StringHash>@ get_keys() const", asFUNCTION(VariantMapGetKeys), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("VariantMap", "Array<StringHash>@ get_keys() const", AS_FUNCTION_OBJLAST(VariantMapGetKeys), AS_CALL_CDECL_OBJLAST);
     // using VariantMap = HashMap<StringHash, Variant> | File: ../Core/Variant.h
     // Vector<U> HashMap::Values() const | File: ../Container/HashMap.h
-    engine->RegisterObjectMethod("VariantMap", "Array<Variant>@ get_values() const", asFUNCTION(VariantMapGetValues), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("VariantMap", "Array<Variant>@ get_values() const", AS_FUNCTION_OBJLAST(VariantMapGetValues), AS_CALL_CDECL_OBJLAST);
 }
 
 // ========================================================================================
@@ -155,45 +148,38 @@ static void ConstructWeakHandlePtr(RefCounted* object, WeakPtr<RefCounted>* ptr)
     new(ptr) WeakPtr<RefCounted>(object);
 }
 
-// WeakPtr<RefCounted> | File: ../Container/Ptr.h
-// WeakPtr::~WeakPtr() noexcept | File: ../Container/Ptr.h
-static void DestructWeakHandle(WeakPtr<RefCounted>* ptr)
-{
-    ptr->~WeakPtr<RefCounted>();
-}
-
 static void RegisterWeakHandle(asIScriptEngine* engine)
 {
     // WeakPtr<RefCounted> | File: ../Container/Ptr.h
     // WeakPtr::WeakPtr() noexcept | File: ../Container/Ptr.h
-    engine->RegisterObjectBehaviour("WeakHandle", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructWeakHandle), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectBehaviour("WeakHandle", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJLAST(ConstructWeakHandle), AS_CALL_CDECL_OBJLAST);
     // WeakPtr<RefCounted> | File: ../Container/Ptr.h
     // WeakPtr::WeakPtr(const WeakPtr<T>& rhs) noexcept | File: ../Container/Ptr.h
-    engine->RegisterObjectBehaviour("WeakHandle", asBEHAVE_CONSTRUCT, "void f(const WeakHandle&in)", asFUNCTION(ConstructWeakHandleCopy), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectBehaviour("WeakHandle", asBEHAVE_CONSTRUCT, "void f(const WeakHandle&in)", AS_FUNCTION_OBJLAST(ConstructWeakHandleCopy), AS_CALL_CDECL_OBJLAST);
     // WeakPtr<RefCounted> | File: ../Container/Ptr.h
     // explicit WeakPtr::WeakPtr(T* ptr) noexcept | File: ../Container/Ptr.h
-    engine->RegisterObjectBehaviour("WeakHandle", asBEHAVE_CONSTRUCT, "void f(RefCounted@+)", asFUNCTION(ConstructWeakHandlePtr), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectBehaviour("WeakHandle", asBEHAVE_CONSTRUCT, "void f(RefCounted@+)", AS_FUNCTION_OBJLAST(ConstructWeakHandlePtr), AS_CALL_CDECL_OBJLAST);
     // WeakPtr<RefCounted> | File: ../Container/Ptr.h
     // WeakPtr::~WeakPtr() noexcept | File: ../Container/Ptr.h
-    engine->RegisterObjectBehaviour("WeakHandle", asBEHAVE_DESTRUCT, "void f()", asFUNCTION(DestructWeakHandle), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectBehaviour("WeakHandle", asBEHAVE_DESTRUCT, "void f()", AS_DESTRUCTOR(WeakPtr<RefCounted>), AS_CALL_CDECL_OBJLAST);
     // WeakPtr<RefCounted> | File: ../Container/Ptr.h
     // WeakPtr<T>& WeakPtr::operator =(const WeakPtr<T>& rhs) | File: ../Container/Ptr.h
-    engine->RegisterObjectMethod("WeakHandle", "WeakHandle& opAssign(const WeakHandle&in)", asMETHODPR(WeakPtr<RefCounted>, operator =, (const WeakPtr<RefCounted>&), WeakPtr<RefCounted>&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("WeakHandle", "WeakHandle& opAssign(const WeakHandle&in)", AS_METHODPR(WeakPtr<RefCounted>, operator =, (const WeakPtr<RefCounted>&), WeakPtr<RefCounted>&), AS_CALL_THISCALL);
     // WeakPtr<RefCounted> | File: ../Container/Ptr.h
     // WeakPtr<T>& WeakPtr::operator =(T* ptr) | File: ../Container/Ptr.h
-    engine->RegisterObjectMethod("WeakHandle", "WeakHandle& opAssign(RefCounted@+)", asMETHODPR(WeakPtr<RefCounted>, operator =, (RefCounted*), WeakPtr<RefCounted>&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("WeakHandle", "WeakHandle& opAssign(RefCounted@+)", AS_METHODPR(WeakPtr<RefCounted>, operator =, (RefCounted*), WeakPtr<RefCounted>&), AS_CALL_THISCALL);
     // WeakPtr<RefCounted> | File: ../Container/Ptr.h
     // T* WeakPtr::Get() const | File: ../Container/Ptr.h
-    engine->RegisterObjectMethod("WeakHandle", "RefCounted@+ Get() const", asMETHODPR(WeakPtr<RefCounted>, Get, () const, RefCounted*), asCALL_THISCALL);
+    engine->RegisterObjectMethod("WeakHandle", "RefCounted@+ Get() const", AS_METHODPR(WeakPtr<RefCounted>, Get, () const, RefCounted*), AS_CALL_THISCALL);
     // WeakPtr<RefCounted> | File: ../Container/Ptr.h
     // int WeakPtr::Refs() const | File: ../Container/Ptr.h
-    engine->RegisterObjectMethod("WeakHandle", "int get_refs() const", asMETHOD(WeakPtr<RefCounted>, Refs), asCALL_THISCALL);
+    engine->RegisterObjectMethod("WeakHandle", "int get_refs() const", AS_METHOD(WeakPtr<RefCounted>, Refs), AS_CALL_THISCALL);
     // WeakPtr<RefCounted> | File: ../Container/Ptr.h
     // int WeakPtr::WeakRefs() const | File: ../Container/Ptr.h
-    engine->RegisterObjectMethod("WeakHandle", "int get_weakRefs() const", asMETHOD(WeakPtr<RefCounted>, WeakRefs), asCALL_THISCALL);
+    engine->RegisterObjectMethod("WeakHandle", "int get_weakRefs() const", AS_METHOD(WeakPtr<RefCounted>, WeakRefs), AS_CALL_THISCALL);
     // WeakPtr<RefCounted> | File: ../Container/Ptr.h
     // bool WeakPtr::Expired() const | File: ../Container/Ptr.h
-    engine->RegisterObjectMethod("WeakHandle", "bool get_expired() const", asMETHOD(WeakPtr<RefCounted>, Expired), asCALL_THISCALL);
+    engine->RegisterObjectMethod("WeakHandle", "bool get_expired() const", AS_METHOD(WeakPtr<RefCounted>, Expired), AS_CALL_THISCALL);
 }
 
 // ========================================================================================
@@ -286,28 +272,28 @@ static asIScriptObject* VariantGetScriptObject(Variant* ptr)
 
 static void RegisterVariant(asIScriptEngine* engine)
 {
-    engine->RegisterObjectBehaviour("Variant", asBEHAVE_CONSTRUCT, "void f(ScriptObject@+)", asFUNCTION(ConstructVariantScriptObject), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Variant", "ScriptObject@+ GetScriptObject() const", asFUNCTION(VariantGetScriptObject), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectBehaviour("Variant", asBEHAVE_CONSTRUCT, "void f(ScriptObject@+)", AS_FUNCTION_OBJLAST(ConstructVariantScriptObject), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Variant", "ScriptObject@+ GetScriptObject() const", AS_FUNCTION_OBJLAST(VariantGetScriptObject), AS_CALL_CDECL_OBJLAST);
     // Variant& Variant::operator=(void *rhs) | File: ../Core/Variant.h
-    engine->RegisterObjectMethod("Variant", "Variant& opAssign(ScriptObject@+)", asMETHODPR(Variant, operator =, (void*), Variant&), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Variant", "Variant& opAssign(ScriptObject@+)", AS_METHODPR(Variant, operator =, (void*), Variant&), AS_CALL_THISCALL);
     // bool Variant::operator==(void *rhs) const | File: ../Core/Variant.h
-    engine->RegisterObjectMethod("Variant", "bool opEquals(ScriptObject@+) const", asMETHODPR(Variant, operator ==, (void*) const, bool), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Variant", "bool opEquals(ScriptObject@+) const", AS_METHODPR(Variant, operator ==, (void*) const, bool), AS_CALL_THISCALL);
     // Variant::Variant(const VariantVector &value) | File: ../Core/Variant.h
-    engine->RegisterObjectBehaviour("Variant", asBEHAVE_CONSTRUCT, "void f(const Array<Variant>@+)", asFUNCTION(ConstructVariantVariantVector), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectBehaviour("Variant", asBEHAVE_CONSTRUCT, "void f(const Array<Variant>@+)", AS_FUNCTION_OBJLAST(ConstructVariantVariantVector), AS_CALL_CDECL_OBJLAST);
     // Variant::Variant(const StringVector &value) | File: ../Core/Variant.h
-    engine->RegisterObjectBehaviour("Variant", asBEHAVE_CONSTRUCT, "void f(const Array<String>@+)", asFUNCTION(ConstructVariantStringVector), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectBehaviour("Variant", asBEHAVE_CONSTRUCT, "void f(const Array<String>@+)", AS_FUNCTION_OBJLAST(ConstructVariantStringVector), AS_CALL_CDECL_OBJLAST);
     // Variant& Variant::operator=(const VariantVector &rhs) | File: ../Core/Variant.h
-    engine->RegisterObjectMethod("Variant", "Variant& opAssign(const Array<Variant>@+)", asFUNCTION(VariantAssignVariantVector), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Variant", "Variant& opAssign(const Array<Variant>@+)", AS_FUNCTION_OBJLAST(VariantAssignVariantVector), AS_CALL_CDECL_OBJLAST);
     // Variant& Variant::operator=(const StringVector &rhs) | File: ../Core/Variant.h
-    engine->RegisterObjectMethod("Variant", "Variant& opAssign(const Array<String>@+)", asFUNCTION(VariantAssignStringVector), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Variant", "Variant& opAssign(const Array<String>@+)", AS_FUNCTION_OBJLAST(VariantAssignStringVector), AS_CALL_CDECL_OBJLAST);
     // bool Variant::operator==(const VariantVector &rhs) const | File: ../Core/Variant.h
-    engine->RegisterObjectMethod("Variant", "bool opEquals(const Array<Variant>@+)", asFUNCTION(VariantEqualsVariantVector), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Variant", "bool opEquals(const Array<Variant>@+)", AS_FUNCTION_OBJLAST(VariantEqualsVariantVector), AS_CALL_CDECL_OBJLAST);
     // bool Variant::operator==(const StringVector &rhs) const | File: ../Core/Variant.h
-    engine->RegisterObjectMethod("Variant", "bool opEquals(const Array<String>@+)", asFUNCTION(VariantEqualsStringVector), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Variant", "bool opEquals(const Array<String>@+)", AS_FUNCTION_OBJLAST(VariantEqualsStringVector), AS_CALL_CDECL_OBJLAST);
     // const VariantVector& Variant::GetVariantVector() const | File: ../Core/Variant.h
-    engine->RegisterObjectMethod("Variant", "Array<Variant>@ GetVariantVector() const", asFUNCTION(VariantGetVariantVector), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Variant", "Array<Variant>@ GetVariantVector() const", AS_FUNCTION_OBJLAST(VariantGetVariantVector), AS_CALL_CDECL_OBJLAST);
     // VectorBuffer Variant::GetVectorBuffer() const | File: ../Core/Variant.h
-    engine->RegisterObjectMethod("Variant", "VectorBuffer GetBuffer() const", asMETHOD(Variant, GetVectorBuffer), asCALL_THISCALL);
+    engine->RegisterObjectMethod("Variant", "VectorBuffer GetBuffer() const", AS_METHOD(Variant, GetVectorBuffer), AS_CALL_THISCALL);
 }
 
 // ========================================================================================
@@ -326,7 +312,7 @@ void ASRegisterManualLast_Core(asIScriptEngine* engine)
     RegisterVariant(engine);
 
     // template<class T> T * Object::GetSubsystem() const | File: ../Core/Object.h
-    engine->RegisterGlobalFunction("Time@+ get_time()", asFUNCTION(GetTime), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Time@+ get_time()", AS_FUNCTION(GetTime), AS_CALL_CDECL);
 }
 
 // ========================================================================================

Source/Urho3D/AngelScript/Manual_Core.h

@@ -33,7 +33,7 @@ CScriptArray* AttributeInfoGetEnumNames(AttributeInfo* ptr);
 
 #define REGISTER_MANUAL_PART_AttributeInfo(T, className) \
     /* const char** AttributeInfo::enumNames_ | File: ../Core/Attribute.h */ \
-    engine->RegisterObjectMethod(className, "Array<String>@ get_enumNames() const", asFUNCTION(AttributeInfoGetEnumNames), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "Array<String>@ get_enumNames() const", AS_FUNCTION_OBJLAST(AttributeInfoGetEnumNames), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -50,15 +50,15 @@ const String& ResourceRefListGetName(unsigned index, ResourceRefList* ptr);
 
 #define REGISTER_MANUAL_PART_ResourceRefList(T, className) \
     /* StringVector ResourceRefList::names_ | File: ../Core/Variant.h */ \
-    engine->RegisterObjectMethod(className, "void Resize(uint)", asFUNCTION(ResourceRefListResize), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "void Resize(uint)", AS_FUNCTION_OBJLAST(ResourceRefListResize), AS_CALL_CDECL_OBJLAST); \
     /* StringVector ResourceRefList::names_ | File: ../Core/Variant.h */ \
-    engine->RegisterObjectMethod(className, "uint get_length() const", asFUNCTION(ResourceRefListGetSize), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "uint get_length() const", AS_FUNCTION_OBJLAST(ResourceRefListGetSize), AS_CALL_CDECL_OBJLAST); \
     /* StringVector ResourceRefList::names_ | File: ../Core/Variant.h */ \
-    engine->RegisterObjectMethod(className, "bool get_empty() const", asFUNCTION(ResourceRefListIsEmpty), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool get_empty() const", AS_FUNCTION_OBJLAST(ResourceRefListIsEmpty), AS_CALL_CDECL_OBJLAST); \
     /* StringVector ResourceRefList::names_ | File: ../Core/Variant.h */ \
-    engine->RegisterObjectMethod(className, "void set_names(uint, const String&in) const", asFUNCTION(ResourceRefListSetName), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "void set_names(uint, const String&in) const", AS_FUNCTION_OBJLAST(ResourceRefListSetName), AS_CALL_CDECL_OBJLAST); \
     /* StringVector ResourceRefList::names_ | File: ../Core/Variant.h */ \
-    engine->RegisterObjectMethod(className, "const String& get_names(uint) const", asFUNCTION(ResourceRefListGetName), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "const String& get_names(uint) const", AS_FUNCTION_OBJLAST(ResourceRefListGetName), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -73,13 +73,13 @@ void SetSplineKnot(unsigned index, const Variant& in, Spline* ptr);
 
 #define REGISTER_MANUAL_PART_Spline(T, className) \
     /* explicit Spline::Spline(const Vector< Variant > &knots, InterpolationMode mode=BEZIER_CURVE) | File: ../Core/Spline.h */ \
-    engine->RegisterObjectBehaviour(className, asBEHAVE_CONSTRUCT, "void f(Array<Variant>@+, InterpolationMode = BEZIER_CURVE)", asFUNCTIONPR(ConstructSpline, (CScriptArray*, InterpolationMode, Spline*), void), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectBehaviour(className, asBEHAVE_CONSTRUCT, "void f(Array<Variant>@+, InterpolationMode = BEZIER_CURVE)", AS_FUNCTIONPR(ConstructSpline, (CScriptArray*, InterpolationMode, Spline*), void), AS_CALL_CDECL_OBJLAST); \
     /* const VariantVector& Spline::GetKnots() const | File: ../Core/Spline.h */ \
-    engine->RegisterObjectMethod(className, "Array<Variant>@ get_knots() const", asFUNCTION(GetSplineKnots), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Array<Variant>@ get_knots() const", AS_FUNCTION_OBJLAST(GetSplineKnots), AS_CALL_CDECL_OBJLAST); \
     /* void Spline::SetKnots(const Vector< Variant > &knots) | File: ../Core/Spline.h */ \
-    engine->RegisterObjectMethod(className, "void set_knots(Array<Variant>@+)", asFUNCTION(SetSplineKnots), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "void set_knots(Array<Variant>@+)", AS_FUNCTION_OBJLAST(SetSplineKnots), AS_CALL_CDECL_OBJLAST); \
     /* void Spline::SetKnot(const Variant &knot, unsigned index) | File: ../Core/Spline.h */ \
-    engine->RegisterObjectMethod(className, "void set_knot(uint, const Variant&in)", asFUNCTION(SetSplineKnot), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "void set_knot(uint, const Variant&in)", AS_FUNCTION_OBJLAST(SetSplineKnot), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -92,10 +92,10 @@ String TimeGetTimeStamp(Time* time);
 
 #define REGISTER_MANUAL_PART_Time(T, className) \
     /* static unsigned GetSystemTime() | File: ../Core/Timer.h */ \
-    engine->RegisterObjectMethod(className, "uint get_systemTime() const", asFUNCTION(TimeGetSystemTime), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "uint get_systemTime() const", AS_FUNCTION_OBJLAST(TimeGetSystemTime), AS_CALL_CDECL_OBJLAST); \
     /* static unsigned GetTimeSinceEpoch() | File: ../Core/Timer.h */ \
-    engine->RegisterObjectMethod(className, "uint get_timeSinceEpoch() const", asFUNCTION(TimeGetTimeSinceEpoch), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "uint get_timeSinceEpoch() const", AS_FUNCTION_OBJLAST(TimeGetTimeSinceEpoch), AS_CALL_CDECL_OBJLAST); \
     /* static String GetTimeStamp() | File: ../Core/Timer.h */ \
-    engine->RegisterObjectMethod(className, "String get_timeStamp() const", asFUNCTION(TimeGetTimeStamp), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "String get_timeStamp() const", AS_FUNCTION_OBJLAST(TimeGetTimeStamp), AS_CALL_CDECL_OBJLAST);
 
 }

Source/Urho3D/AngelScript/Manual_Database.cpp

@@ -50,11 +50,6 @@ static void ConstructDbResultCopy(const DbResult& other, DbResult* ptr)
     new(ptr) DbResult(other);
 }
 
-static void DestructDbResult(DbResult* ptr)
-{
-    ptr->~DbResult();
-}
-
 static CScriptArray* DbResultGetColumns(DbResult* ptr)
 {
     return VectorToArray<String>(ptr->GetColumns(), "Array<String>");
@@ -74,15 +69,15 @@ static CScriptArray* DbResultGetRow(unsigned index, DbResult* ptr)
 
 static void RegisterDbResult(asIScriptEngine* engine)
 {
-    engine->RegisterObjectBehaviour("DbResult", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructDbResult), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectBehaviour("DbResult", asBEHAVE_CONSTRUCT, "void f(const DbResult&in)", asFUNCTION(ConstructDbResultCopy), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectBehaviour("DbResult", asBEHAVE_DESTRUCT, "void f()", asFUNCTION(DestructDbResult), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("DbResult", "DbResult& opAssign(const DbResult&in)", asMETHODPR(DbResult, operator =, (const DbResult&), DbResult&), asCALL_THISCALL);
-    engine->RegisterObjectMethod("DbResult", "uint get_numColumns() const", asMETHOD(DbResult, GetNumColumns), asCALL_THISCALL);
-    engine->RegisterObjectMethod("DbResult", "uint get_numRows() const", asMETHOD(DbResult, GetNumRows), asCALL_THISCALL);
-    engine->RegisterObjectMethod("DbResult", "int64 get_numAffectedRows() const", asMETHOD(DbResult, GetNumAffectedRows), asCALL_THISCALL);
-    engine->RegisterObjectMethod("DbResult", "Array<String>@ get_columns() const", asFUNCTION(DbResultGetColumns), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("DbResult", "Array<Variant>@ get_row(uint) const", asFUNCTION(DbResultGetRow), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectBehaviour("DbResult", asBEHAVE_CONSTRUCT, "void f()", AS_FUNCTION_OBJLAST(ConstructDbResult), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectBehaviour("DbResult", asBEHAVE_CONSTRUCT, "void f(const DbResult&in)", AS_FUNCTION_OBJLAST(ConstructDbResultCopy), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectBehaviour("DbResult", asBEHAVE_DESTRUCT, "void f()", AS_DESTRUCTOR(DbResult), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("DbResult", "DbResult& opAssign(const DbResult&in)", AS_METHODPR(DbResult, operator =, (const DbResult&), DbResult&), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("DbResult", "uint get_numColumns() const", AS_METHOD(DbResult, GetNumColumns), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("DbResult", "uint get_numRows() const", AS_METHOD(DbResult, GetNumRows), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("DbResult", "int64 get_numAffectedRows() const", AS_METHOD(DbResult, GetNumAffectedRows), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("DbResult", "Array<String>@ get_columns() const", AS_FUNCTION_OBJLAST(DbResultGetColumns), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("DbResult", "Array<Variant>@ get_row(uint) const", AS_FUNCTION_OBJLAST(DbResultGetRow), AS_CALL_CDECL_OBJLAST);
 }
 
 // ========================================================================================
@@ -90,9 +85,9 @@ static void RegisterDbResult(asIScriptEngine* engine)
 static void RegisterDbConnection(asIScriptEngine* engine)
 {
     RegisterObject<DbConnection>(engine, "DbConnection");
-    engine->RegisterObjectMethod("DbConnection", "DbResult Execute(const String&in, bool useCursorEvent = false)", asMETHOD(DbConnection, Execute), asCALL_THISCALL);
-    engine->RegisterObjectMethod("DbConnection", "const String& get_connectionString() const", asMETHOD(DbConnection, GetConnectionString), asCALL_THISCALL);
-    engine->RegisterObjectMethod("DbConnection", "bool get_connected() const", asMETHOD(DbConnection, IsConnected), asCALL_THISCALL);
+    engine->RegisterObjectMethod("DbConnection", "DbResult Execute(const String&in, bool useCursorEvent = false)", AS_METHOD(DbConnection, Execute), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("DbConnection", "const String& get_connectionString() const", AS_METHOD(DbConnection, GetConnectionString), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("DbConnection", "bool get_connected() const", AS_METHOD(DbConnection, IsConnected), AS_CALL_THISCALL);
 }
 
 // ========================================================================================
@@ -113,8 +108,8 @@ void ASRegisterManualLast_Database(asIScriptEngine* engine)
     RegisterDbResult(engine);
     RegisterDbConnection(engine);
 
-    engine->RegisterGlobalFunction("Database@+ get_database()", asFUNCTION(GetDatabase), asCALL_CDECL);
-    engine->RegisterGlobalFunction("DBAPI get_DBAPI()", asFUNCTION(GetDBAPI), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Database@+ get_database()", AS_FUNCTION(GetDatabase), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("DBAPI get_DBAPI()", AS_FUNCTION(GetDBAPI), AS_CALL_CDECL);
 }
 
 }

Source/Urho3D/AngelScript/Manual_Engine.cpp

@@ -59,11 +59,11 @@ static Engine* GetEngine()
 void ASRegisterManualLast_Engine(asIScriptEngine* engine)
 {
     // template<class T> T * Object::GetSubsystem() const | File: ../Core/Object.h
-    engine->RegisterGlobalFunction("Console@+ get_console()", asFUNCTION(GetConsole), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Console@+ get_console()", AS_FUNCTION(GetConsole), AS_CALL_CDECL);
     // template<class T> T * Object::GetSubsystem() const | File: ../Core/Object.h
-    engine->RegisterGlobalFunction("DebugHud@+ get_debugHud()", asFUNCTION(GetDebugHud), asCALL_CDECL);
+    engine->RegisterGlobalFunction("DebugHud@+ get_debugHud()", AS_FUNCTION(GetDebugHud), AS_CALL_CDECL);
     // template<class T> T * Object::GetSubsystem() const | File: ../Core/Object.h
-    engine->RegisterGlobalFunction("Engine@+ get_engine()", asFUNCTION(GetEngine), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Engine@+ get_engine()", AS_FUNCTION(GetEngine), AS_CALL_CDECL);
 }
 
 }

Source/Urho3D/AngelScript/Manual_Graphics.cpp

@@ -103,21 +103,21 @@ static Octree* GetOctree()
 // This function is called after ASRegisterGenerated()
 void ASRegisterManualLast_Graphics(asIScriptEngine* engine)
 {
-    engine->RegisterObjectMethod("StaticModel", "void SetModel(Model@+)", asFUNCTION(StaticModelSetModel), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("StaticModel", "void set_model(Model@+)", asFUNCTION(StaticModelSetModel), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Skybox", "void SetModel(Model@+)", asFUNCTION(StaticModelSetModel), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Skybox", "void set_model(Model@+)", asFUNCTION(StaticModelSetModel), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("StaticModelGroup", "void SetModel(Model@+)", asFUNCTION(StaticModelSetModel), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("StaticModelGroup", "void set_model(Model@+)", asFUNCTION(StaticModelSetModel), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("StaticModel", "void SetModel(Model@+)", AS_FUNCTION_OBJLAST(StaticModelSetModel), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("StaticModel", "void set_model(Model@+)", AS_FUNCTION_OBJLAST(StaticModelSetModel), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Skybox", "void SetModel(Model@+)", AS_FUNCTION_OBJLAST(StaticModelSetModel), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Skybox", "void set_model(Model@+)", AS_FUNCTION_OBJLAST(StaticModelSetModel), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("StaticModelGroup", "void SetModel(Model@+)", AS_FUNCTION_OBJLAST(StaticModelSetModel), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("StaticModelGroup", "void set_model(Model@+)", AS_FUNCTION_OBJLAST(StaticModelSetModel), AS_CALL_CDECL_OBJLAST);
 
     // template<class T> T * Object::GetSubsystem() const | File: ../Core/Object.h
-    engine->RegisterGlobalFunction("Graphics@+ get_graphics()", asFUNCTION(GetGraphics), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Graphics@+ get_graphics()", AS_FUNCTION(GetGraphics), AS_CALL_CDECL);
     // template<class T> T * Object::GetSubsystem() const | File: ../Core/Object.h
-    engine->RegisterGlobalFunction("Renderer@+ get_renderer()", asFUNCTION(GetRenderer), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Renderer@+ get_renderer()", AS_FUNCTION(GetRenderer), AS_CALL_CDECL);
     // template<class T> T * Object::GetSubsystem() const | File: ../Core/Object.h
-    engine->RegisterGlobalFunction("DebugRenderer@+ get_debugRenderer()", asFUNCTION(GetDebugRenderer), asCALL_CDECL);
+    engine->RegisterGlobalFunction("DebugRenderer@+ get_debugRenderer()", AS_FUNCTION(GetDebugRenderer), AS_CALL_CDECL);
     // template<class T> T * Object::GetSubsystem() const | File: ../Core/Object.h
-    engine->RegisterGlobalFunction("Octree@+ get_octree()", asFUNCTION(GetOctree), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Octree@+ get_octree()", AS_FUNCTION(GetOctree), AS_CALL_CDECL);
 }
 
 // ========================================================================================

Source/Urho3D/AngelScript/Manual_Graphics.h

@@ -50,9 +50,9 @@ RenderPathCommand* RenderPathGetCommand(unsigned index, RenderPath* ptr);
 
 #define REGISTER_MANUAL_PART_RenderPath(T, className) \
     /* Vector<RenderTargetInfo> RenderPath::renderTargets_ | File: ../Graphics/RenderPath.h */ \
-    engine->RegisterObjectMethod(className, "const RenderTargetInfo& get_renderTargets(uint) const", asFUNCTION(RenderPathGetRenderTarget), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "const RenderTargetInfo& get_renderTargets(uint) const", AS_FUNCTION_OBJLAST(RenderPathGetRenderTarget), AS_CALL_CDECL_OBJLAST); \
     /* Vector<RenderPathCommand> RenderPath::commands_ | File: ../Graphics/RenderPath.h */ \
-    engine->RegisterObjectMethod(className, "const RenderPathCommand& get_commands(uint) const", asFUNCTION(RenderPathGetCommand), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "const RenderPathCommand& get_commands(uint) const", AS_FUNCTION_OBJLAST(RenderPathGetCommand), AS_CALL_CDECL_OBJLAST); \
 
 // ========================================================================================
 
@@ -63,9 +63,9 @@ Technique* TechniqueEntryGetTechnique(TechniqueEntry* ptr);
 
 #define REGISTER_MANUAL_PART_TechniqueEntry(T, className) \
     /* SharedPtr<Technique> TechniqueEntry::technique_ | File: ../Graphics/Material.h */ \
-    engine->RegisterObjectMethod(className, "void set_technique(Technique@+)", asFUNCTION(TechniqueEntrySetTechnique), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "void set_technique(Technique@+)", AS_FUNCTION_OBJLAST(TechniqueEntrySetTechnique), AS_CALL_CDECL_OBJLAST); \
     /* SharedPtr<Technique> TechniqueEntry::technique_ | File: ../Graphics/Material.h */ \
-    engine->RegisterObjectMethod(className, "Technique@+ get_technique() const", asFUNCTION(TechniqueEntryGetTechnique), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "Technique@+ get_technique() const", AS_FUNCTION_OBJLAST(TechniqueEntryGetTechnique), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -74,9 +74,9 @@ CScriptArray* MaterialGetShaderParameterNames(Material* material);
 const TechniqueEntry& MaterialGetTechniqueEntry(unsigned index, Material* ptr);
 
 #define REGISTER_MANUAL_PART_Material(T, className) \
-    engine->RegisterObjectMethod(className, "Array<String>@ get_shaderParameterNames() const", asFUNCTION(MaterialGetShaderParameterNames), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Array<String>@ get_shaderParameterNames() const", AS_FUNCTION_OBJLAST(MaterialGetShaderParameterNames), AS_CALL_CDECL_OBJLAST); \
     /* const TechniqueEntry& Material::GetTechniqueEntry(unsigned index) const | File: ../Graphics/Material.h */ \
-    engine->RegisterObjectMethod(className, "const TechniqueEntry& get_techniqueEntries(uint) const", asFUNCTION(MaterialGetTechniqueEntry), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "const TechniqueEntry& get_techniqueEntries(uint) const", AS_FUNCTION_OBJLAST(MaterialGetTechniqueEntry), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -87,11 +87,11 @@ bool VertexBufferSetData(VectorBuffer& src, VertexBuffer* ptr);
 bool VertexBufferSetDataRange(VectorBuffer& src, unsigned start, unsigned count, bool discard, VertexBuffer* ptr);
 
 #define REGISTER_MANUAL_PART_VertexBuffer(T, className) \
-    engine->RegisterObjectMethod(className, "VectorBuffer GetData() const", asFUNCTION(VertexBufferGetData), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "VectorBuffer GetData() const", AS_FUNCTION_OBJLAST(VertexBufferGetData), AS_CALL_CDECL_OBJLAST); \
     /* bool VertexBuffer::SetData(const void *data) | File: ../Graphics/VertexBuffer.h */ \
-    engine->RegisterObjectMethod(className, "bool SetData(VectorBuffer&)", asFUNCTION(VertexBufferSetData), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool SetData(VectorBuffer&)", AS_FUNCTION_OBJLAST(VertexBufferSetData), AS_CALL_CDECL_OBJLAST); \
     /* bool VertexBuffer::SetDataRange(const void *data, unsigned start, unsigned count, bool discard=false) | File: ../Graphics/VertexBuffer.h */ \
-    engine->RegisterObjectMethod(className, "bool SetDataRange(VectorBuffer&, uint, uint, bool discard = false)", asFUNCTION(VertexBufferSetDataRange), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "bool SetDataRange(VectorBuffer&, uint, uint, bool discard = false)", AS_FUNCTION_OBJLAST(VertexBufferSetDataRange), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -102,17 +102,17 @@ bool IndexBufferSetData(VectorBuffer& src, IndexBuffer* ptr);
 bool IndexBufferSetDataRange(VectorBuffer& src, unsigned start, unsigned count, bool discard, IndexBuffer* ptr);
 
 #define REGISTER_MANUAL_PART_IndexBuffer(T, className) \
-    engine->RegisterObjectMethod(className, "VectorBuffer GetData()", asFUNCTION(IndexBufferGetData), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "VectorBuffer GetData()", AS_FUNCTION_OBJLAST(IndexBufferGetData), AS_CALL_CDECL_OBJLAST); \
     /* bool IndexBuffer::SetData(const void *data) | File: ../Graphics/IndexBuffer.h */ \
-    engine->RegisterObjectMethod(className, "bool SetData(VectorBuffer&)", asFUNCTION(IndexBufferSetData), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool SetData(VectorBuffer&)", AS_FUNCTION_OBJLAST(IndexBufferSetData), AS_CALL_CDECL_OBJLAST); \
     /* bool IndexBuffer::SetDataRange(const void *data, unsigned start, unsigned count, bool discard=false) | File: ../Graphics/IndexBuffer.h */ \
-    engine->RegisterObjectMethod(className, "bool SetDataRange(VectorBuffer&, uint, uint, bool discard = false)", asFUNCTION(IndexBufferSetDataRange), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "bool SetDataRange(VectorBuffer&, uint, uint, bool discard = false)", AS_FUNCTION_OBJLAST(IndexBufferSetDataRange), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
 #define REGISTER_MANUAL_PART_AnimationTrack(T, className) \
     /* AnimationKeyFrame* AnimationTrack::GetKeyFrame(unsigned index) | File: ../Graphics/Animation.h */ \
-    engine->RegisterObjectMethod(className, "const AnimationKeyFrame& get_keyFrames(uint) const", asMETHOD(T, GetKeyFrame), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "const AnimationKeyFrame& get_keyFrames(uint) const", AS_METHOD(T, GetKeyFrame), AS_CALL_THISCALL);
 
 // ========================================================================================
 
@@ -121,7 +121,7 @@ AnimationTriggerPoint* AnimationGetTrigger(unsigned index, Animation* ptr);
 
 #define REGISTER_MANUAL_PART_Animation(T, className) \
     /* AnimationTriggerPoint* Animation::GetTrigger(unsigned index) | File: ../Graphics/Animation.h */ \
-    engine->RegisterObjectMethod(className, "const AnimationTriggerPoint& get_triggers(uint) const", asFUNCTION(AnimationGetTrigger), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "const AnimationTriggerPoint& get_triggers(uint) const", AS_FUNCTION_OBJLAST(AnimationGetTrigger), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -142,7 +142,7 @@ void AnimationStateSetBoneWeight(const String& name, float weight, AnimationStat
 
 #define REGISTER_MANUAL_PART_AnimationState(T, className) \
     /* void AnimationState::SetBoneWeight(const String &name, float weight, bool recursive=false) | File: ../Graphics/AnimationState.h */ \
-    engine->RegisterObjectMethod(className, "void set_boneWeights(const String&in, float)", asFUNCTION(AnimationStateSetBoneWeight), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "void set_boneWeights(const String&in, float)", AS_FUNCTION_OBJLAST(AnimationStateSetBoneWeight), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -151,9 +151,9 @@ const String& AnimatedModelGetMorphName(unsigned index, AnimatedModel* ptr);
 void AnimatedModelSetModel(Model* model, AnimatedModel* ptr);
 
 #define REGISTER_MANUAL_PART_AnimatedModel(T, className) \
-    engine->RegisterObjectMethod(className, "const String& get_morphNames(uint) const", asFUNCTION(AnimatedModelGetMorphName), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "const String& get_morphNames(uint) const", AS_FUNCTION_OBJLAST(AnimatedModelGetMorphName), AS_CALL_CDECL_OBJLAST); \
     /* void AnimatedModel::SetModel(Model *model, bool createBones=true) | File: ../Graphics/AnimatedModel.h */ \
-    engine->RegisterObjectMethod(className, "void set_model(Model@+)", asFUNCTION(AnimatedModelSetModel), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "void set_model(Model@+)", AS_FUNCTION_OBJLAST(AnimatedModelSetModel), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -164,9 +164,9 @@ const AnimationControl* AnimationControllerGetAnimation(unsigned index, Animatio
 
 #define REGISTER_MANUAL_PART_AnimationController(T, className) \
     /* const Vector<AnimationControl>& AnimationController::GetAnimations() const | File: ../Graphics/AnimationController.h */ \
-    engine->RegisterObjectMethod(className, "uint get_numAnimations() const", asFUNCTION(AnimationControllerGetNumAnimations), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "uint get_numAnimations() const", AS_FUNCTION_OBJLAST(AnimationControllerGetNumAnimations), AS_CALL_CDECL_OBJLAST); \
     /* const Vector<AnimationControl>& AnimationController::GetAnimations() const | File: ../Graphics/AnimationController.h */ \
-    engine->RegisterObjectMethod(className, "const AnimationControl@+ get_animations(uint) const", asFUNCTION(AnimationControllerGetAnimation), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "const AnimationControl@+ get_animations(uint) const", AS_FUNCTION_OBJLAST(AnimationControllerGetAnimation), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -177,9 +177,9 @@ void GraphicsPrecacheShadersVectorBuffer(VectorBuffer& buffer, Graphics* ptr);
 
 #define REGISTER_MANUAL_PART_Graphics(T, className) \
     /* void Graphics::PrecacheShaders(Deserializer &source) | File: ../Graphics/Graphics.h */ \
-    engine->RegisterObjectMethod(className, "void PrecacheShaders(File@+)", asFUNCTION(GraphicsPrecacheShaders), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "void PrecacheShaders(File@+)", AS_FUNCTION_OBJLAST(GraphicsPrecacheShaders), AS_CALL_CDECL_OBJLAST); \
     /* void Graphics::PrecacheShaders(Deserializer &source) | File: ../Graphics/Graphics.h */ \
-    engine->RegisterObjectMethod(className, "void PrecacheShaders(VectorBuffer&)", asFUNCTION(GraphicsPrecacheShadersVectorBuffer), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "void PrecacheShaders(VectorBuffer&)", AS_FUNCTION_OBJLAST(GraphicsPrecacheShadersVectorBuffer), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -190,9 +190,9 @@ Node* RayQueryResultGetNode(RayQueryResult* ptr);
 
 #define REGISTER_MANUAL_PART_RayQueryResult(T, className) \
     /* Drawable* RayQueryResult::drawable_ | File: ../Graphics/OctreeQuery.h */ \
-    engine->RegisterObjectMethod(className, "Drawable@+ get_drawable() const", asFUNCTION(RayQueryResultGetDrawable), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Drawable@+ get_drawable() const", AS_FUNCTION_OBJLAST(RayQueryResultGetDrawable), AS_CALL_CDECL_OBJLAST); \
     /* Node* RayQueryResult::node_ | File: ../Graphics/OctreeQuery.h */ \
-    engine->RegisterObjectMethod(className, "Node@+ get_node() const", asFUNCTION(RayQueryResultGetNode), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "Node@+ get_node() const", AS_FUNCTION_OBJLAST(RayQueryResultGetNode), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -213,19 +213,19 @@ CScriptArray* OctreeGetAllDrawables(unsigned char drawableFlags, unsigned viewMa
 
 #define REGISTER_MANUAL_PART_Octree(T, className) \
     /* void Octree::Raycast(RayOctreeQuery &query) const | File: ../Graphics/Octree.h */ \
-    engine->RegisterObjectMethod(className, "Array<RayQueryResult>@ Raycast(const Ray&in, RayQueryLevel level = RAY_TRIANGLE, float maxDistance = M_INFINITY, uint8 drawableFlags = DRAWABLE_ANY, uint viewMask = DEFAULT_VIEWMASK) const", asFUNCTION(OctreeRaycast), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Array<RayQueryResult>@ Raycast(const Ray&in, RayQueryLevel level = RAY_TRIANGLE, float maxDistance = M_INFINITY, uint8 drawableFlags = DRAWABLE_ANY, uint viewMask = DEFAULT_VIEWMASK) const", AS_FUNCTION_OBJLAST(OctreeRaycast), AS_CALL_CDECL_OBJLAST); \
     /* void Octree::RaycastSingle(RayOctreeQuery &query) const | File: ../Graphics/Octree.h */ \
-    engine->RegisterObjectMethod(className, "RayQueryResult RaycastSingle(const Ray&in, RayQueryLevel level = RAY_TRIANGLE, float maxDistance = M_INFINITY, uint8 drawableFlags = DRAWABLE_ANY, uint viewMask = DEFAULT_VIEWMASK) const", asFUNCTION(OctreeRaycastSingle), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "RayQueryResult RaycastSingle(const Ray&in, RayQueryLevel level = RAY_TRIANGLE, float maxDistance = M_INFINITY, uint8 drawableFlags = DRAWABLE_ANY, uint viewMask = DEFAULT_VIEWMASK) const", AS_FUNCTION_OBJLAST(OctreeRaycastSingle), AS_CALL_CDECL_OBJLAST); \
     /* void Octree::GetDrawables(OctreeQuery &query) const | File: ../Graphics/Octree.h */ \
-    engine->RegisterObjectMethod(className, "Array<Drawable@>@ GetDrawables(const Vector3&in, uint8 drawableFlags = DRAWABLE_ANY, uint viewMask = DEFAULT_VIEWMASK)", asFUNCTION(OctreeGetDrawablesPoint), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Array<Drawable@>@ GetDrawables(const Vector3&in, uint8 drawableFlags = DRAWABLE_ANY, uint viewMask = DEFAULT_VIEWMASK)", AS_FUNCTION_OBJLAST(OctreeGetDrawablesPoint), AS_CALL_CDECL_OBJLAST); \
     /* void Octree::GetDrawables(OctreeQuery &query) const | File: ../Graphics/Octree.h */ \
-    engine->RegisterObjectMethod(className, "Array<Drawable@>@ GetDrawables(const BoundingBox&in, uint8 drawableFlags = DRAWABLE_ANY, uint viewMask = DEFAULT_VIEWMASK)", asFUNCTION(OctreeGetDrawablesBox), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Array<Drawable@>@ GetDrawables(const BoundingBox&in, uint8 drawableFlags = DRAWABLE_ANY, uint viewMask = DEFAULT_VIEWMASK)", AS_FUNCTION_OBJLAST(OctreeGetDrawablesBox), AS_CALL_CDECL_OBJLAST); \
     /* void Octree::GetDrawables(OctreeQuery &query) const | File: ../Graphics/Octree.h */ \
-    engine->RegisterObjectMethod(className, "Array<Drawable@>@ GetDrawables(const Frustum&in, uint8 drawableFlags = DRAWABLE_ANY, uint viewMask = DEFAULT_VIEWMASK)", asFUNCTION(OctreeGetDrawablesFrustum), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Array<Drawable@>@ GetDrawables(const Frustum&in, uint8 drawableFlags = DRAWABLE_ANY, uint viewMask = DEFAULT_VIEWMASK)", AS_FUNCTION_OBJLAST(OctreeGetDrawablesFrustum), AS_CALL_CDECL_OBJLAST); \
     /* void Octree::GetDrawables(OctreeQuery &query) const | File: ../Graphics/Octree.h */ \
-    engine->RegisterObjectMethod(className, "Array<Drawable@>@ GetDrawables(const Sphere&in, uint8 drawableFlags = DRAWABLE_ANY, uint viewMask = DEFAULT_VIEWMASK)", asFUNCTION(OctreeGetDrawablesSphere), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Array<Drawable@>@ GetDrawables(const Sphere&in, uint8 drawableFlags = DRAWABLE_ANY, uint viewMask = DEFAULT_VIEWMASK)", AS_FUNCTION_OBJLAST(OctreeGetDrawablesSphere), AS_CALL_CDECL_OBJLAST); \
     /* void Octree::GetDrawables(OctreeQuery &query) const | File: ../Graphics/Octree.h */ \
-    engine->RegisterObjectMethod(className, "Array<Drawable@>@ GetAllDrawables(uint8 drawableFlags = DRAWABLE_ANY, uint viewMask = DEFAULT_VIEWMASK)", asFUNCTION(OctreeGetAllDrawables), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "Array<Drawable@>@ GetAllDrawables(uint8 drawableFlags = DRAWABLE_ANY, uint viewMask = DEFAULT_VIEWMASK)", AS_FUNCTION_OBJLAST(OctreeGetAllDrawables), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -234,6 +234,6 @@ void RendererSetVSMShadowParameters(const Vector2& parameters, Renderer* ptr);
 
 #define REGISTER_MANUAL_PART_Renderer(T, className) \
     /* void Renderer::SetVSMShadowParameters(float minVariance, float lightBleedingReduction) | File: ../Graphics/Renderer.h */ \
-    engine->RegisterObjectMethod("Renderer", "void set_vsmShadowParameters(const Vector2&in)", asFUNCTION(RendererSetVSMShadowParameters), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Renderer", "void set_vsmShadowParameters(const Vector2&in)", AS_FUNCTION_OBJLAST(RendererSetVSMShadowParameters), AS_CALL_CDECL_OBJLAST);
 
 }

Source/Urho3D/AngelScript/Manual_IK.cpp

@@ -54,9 +54,9 @@ void ASRegisterManualFirst_IK(asIScriptEngine* engine)
 void ASRegisterManualLast_IK(asIScriptEngine* engine)
 {
     // Algorithm IKSolver::GetAlgorithm() const | File: ../IK/IKSolver.h
-    engine->RegisterObjectMethod("IKSolver", "IKAlgorithm get_algorithm() const", asMETHOD(IKSolver, GetAlgorithm), asCALL_THISCALL);
+    engine->RegisterObjectMethod("IKSolver", "IKAlgorithm get_algorithm() const", AS_METHOD(IKSolver, GetAlgorithm), AS_CALL_THISCALL);
     // void IKSolver::SetAlgorithm(Algorithm algorithm) | File: ../IK/IKSolver.h
-    engine->RegisterObjectMethod("IKSolver", "void set_algorithm(IKAlgorithm)", asMETHOD(IKSolver, SetAlgorithm), asCALL_THISCALL);
+    engine->RegisterObjectMethod("IKSolver", "void set_algorithm(IKAlgorithm)", AS_METHOD(IKSolver, SetAlgorithm), AS_CALL_THISCALL);
 }
 
 }

Source/Urho3D/AngelScript/Manual_IO.cpp

@@ -50,8 +50,8 @@ static unsigned char* VectorBufferAt(unsigned index, VectorBuffer* ptr)
 static void RegisterVectorBuffer(asIScriptEngine* engine)
 {
     // unsigned char* VectorBuffer::GetModifiableData() | File: ../IO/VectorBuffer.h
-    engine->RegisterObjectMethod("VectorBuffer", "uint8 &opIndex(uint)", asFUNCTION(VectorBufferAt), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("VectorBuffer", "const uint8 &opIndex(uint) const", asFUNCTION(VectorBufferAt), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("VectorBuffer", "uint8 &opIndex(uint)", AS_FUNCTION_OBJLAST(VectorBufferAt), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("VectorBuffer", "const uint8 &opIndex(uint) const", AS_FUNCTION_OBJLAST(VectorBufferAt), AS_CALL_CDECL_OBJLAST);
 }
 
 // ========================================================================================
@@ -157,23 +157,23 @@ static void LogError(const String& str, Log* ptr) { }
 
 static void RegisterLog(asIScriptEngine* engine)
 {
-    engine->RegisterObjectMethod("Log", "void Write(const String&in, bool error = false)", asFUNCTION(LogWrite), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Log", "void Trace(const String&in)", asFUNCTION(LogTrace), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Log", "void Debug(const String&in)", asFUNCTION(LogDebug), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Log", "void Info(const String&in)", asFUNCTION(LogInfo), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Log", "void Warning(const String&in)", asFUNCTION(LogWarning), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Log", "void Error(const String&in)", asFUNCTION(LogError), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Log", "void Write(const String&in, bool error = false)", AS_FUNCTION_OBJLAST(LogWrite), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Log", "void Trace(const String&in)", AS_FUNCTION_OBJLAST(LogTrace), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Log", "void Debug(const String&in)", AS_FUNCTION_OBJLAST(LogDebug), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Log", "void Info(const String&in)", AS_FUNCTION_OBJLAST(LogInfo), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Log", "void Warning(const String&in)", AS_FUNCTION_OBJLAST(LogWarning), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Log", "void Error(const String&in)", AS_FUNCTION_OBJLAST(LogError), AS_CALL_CDECL_OBJLAST);
 	
 	// Register also Print() functions for convenience
-    engine->RegisterGlobalFunction("void Print(const String&in, bool error = false)", asFUNCTIONPR(Print, (const String&, bool), void), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void Print(int, bool error = false)", asFUNCTIONPR(Print, (int, bool), void), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void Print(int64, bool error = false)", asFUNCTIONPR(Print, (long long, bool), void), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void Print(uint, bool error = false)", asFUNCTIONPR(Print, (unsigned, bool), void), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void Print(uint64, bool error = false)", asFUNCTIONPR(Print, (unsigned long long, bool), void), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void Print(float, bool error = false)", asFUNCTIONPR(Print, (float, bool), void), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void Print(bool, bool error = false)", asFUNCTIONPR(Print, (bool, bool), void), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void Print(const Variant&in, bool error = false)", asFUNCTIONPR(Print, (const Variant&, bool), void), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void PrintCallStack(bool error = false)", asFUNCTION(PrintCallStack), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void Print(const String&in, bool error = false)", AS_FUNCTIONPR(Print, (const String&, bool), void), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void Print(int, bool error = false)", AS_FUNCTIONPR(Print, (int, bool), void), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void Print(int64, bool error = false)", AS_FUNCTIONPR(Print, (long long, bool), void), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void Print(uint, bool error = false)", AS_FUNCTIONPR(Print, (unsigned, bool), void), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void Print(uint64, bool error = false)", AS_FUNCTIONPR(Print, (unsigned long long, bool), void), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void Print(float, bool error = false)", AS_FUNCTIONPR(Print, (float, bool), void), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void Print(bool, bool error = false)", AS_FUNCTIONPR(Print, (bool, bool), void), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void Print(const Variant&in, bool error = false)", AS_FUNCTIONPR(Print, (const Variant&, bool), void), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void PrintCallStack(bool error = false)", AS_FUNCTION(PrintCallStack), AS_CALL_CDECL);
 }
 
 // ========================================================================================
@@ -197,9 +197,9 @@ void ASRegisterManualLast_IO(asIScriptEngine* engine)
     RegisterLog(engine);
 
     // template<class T> T * Object::GetSubsystem() const | File: ../Core/Object.h
-    engine->RegisterGlobalFunction("FileSystem@+ get_fileSystem()", asFUNCTION(GetFileSystem), asCALL_CDECL);
+    engine->RegisterGlobalFunction("FileSystem@+ get_fileSystem()", AS_FUNCTION(GetFileSystem), AS_CALL_CDECL);
     // template<class T> T * Object::GetSubsystem() const | File: ../Core/Object.h
-    engine->RegisterGlobalFunction("Log@+ get_log()", asFUNCTION(GetLog), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Log@+ get_log()", AS_FUNCTION(GetLog), AS_CALL_CDECL);
 }
 
 // ========================================================================================

Source/Urho3D/AngelScript/Manual_IO.h

@@ -36,9 +36,9 @@ VectorBuffer DeserializerReadVectorBuffer(unsigned size, Deserializer* ptr);
 
 #define REGISTER_MANUAL_PART_Deserializer(T, className) \
     /* virtual unsigned Deserializer::Read(void *dest, unsigned size)=0 | File: ../IO/Deserializer.h */ \
-    engine->RegisterObjectMethod(className, "Array<uint8>@ Read(uint)", asFUNCTION(DeserializerRead), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Array<uint8>@ Read(uint)", AS_FUNCTION_OBJLAST(DeserializerRead), AS_CALL_CDECL_OBJLAST); \
     /* VectorBuffer(Deserializer& source, unsigned size) | File: ../IO/VectorBuffer.h */ \
-    engine->RegisterObjectMethod(className, "VectorBuffer ReadVectorBuffer(uint)", asFUNCTION(DeserializerReadVectorBuffer), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "VectorBuffer ReadVectorBuffer(uint)", AS_FUNCTION_OBJLAST(DeserializerReadVectorBuffer), AS_CALL_CDECL_OBJLAST);
 
 // ================================================================================
 
@@ -49,9 +49,9 @@ bool SerializerWriteVectorBuffer(VectorBuffer* src, Serializer* ptr);
 
 #define REGISTER_MANUAL_PART_Serializer(T, className) \
     /* virtual unsigned Serializer::Write(const void *data, unsigned size)=0 | File: ../IO/Serializer.h */ \
-    engine->RegisterObjectMethod(className, "uint Write(Array<uint8>@+)", asFUNCTION(SerializerWrite), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "uint Write(Array<uint8>@+)", AS_FUNCTION_OBJLAST(SerializerWrite), AS_CALL_CDECL_OBJLAST); \
     /* virtual unsigned Serializer::Write(const void *data, unsigned size)=0 | File: ../IO/Serializer.h */ \
-    engine->RegisterObjectMethod(className, "bool WriteVectorBuffer(const VectorBuffer&in)", asFUNCTION(SerializerWriteVectorBuffer), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "bool WriteVectorBuffer(const VectorBuffer&in)", AS_FUNCTION_OBJLAST(SerializerWriteVectorBuffer), AS_CALL_CDECL_OBJLAST);
 
 // ================================================================================
 
@@ -60,6 +60,6 @@ CScriptArray* FileSystemScanDir(const String& pathName, const String& filter, un
 
 #define REGISTER_MANUAL_PART_FileSystem(T, className) \
     /* void FileSystem::ScanDir(Vector< String > &result, const String &pathName, const String &filter, unsigned flags, bool recursive) const | File: ../IO/FileSystem.h */ \
-    engine->RegisterObjectMethod(className, "Array<String>@ ScanDir(const String&in, const String&in, uint, bool) const", asFUNCTION(FileSystemScanDir), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "Array<String>@ ScanDir(const String&in, const String&in, uint, bool) const", AS_FUNCTION_OBJLAST(FileSystemScanDir), AS_CALL_CDECL_OBJLAST);
 
 }

Source/Urho3D/AngelScript/Manual_Input.cpp

@@ -45,7 +45,7 @@ static Input* GetInput()
 void ASRegisterManualLast_Input(asIScriptEngine* engine)
 {
     // template<class T> T * Object::GetSubsystem() const | File: ../Core/Object.h
-    engine->RegisterGlobalFunction("Input@+ get_input()", asFUNCTION(GetInput), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Input@+ get_input()", AS_FUNCTION(GetInput), AS_CALL_CDECL);
 }
 
 // ========================================================================================

Source/Urho3D/AngelScript/Manual_Input.h

@@ -48,22 +48,22 @@ void InputSetMouseVisible(bool enable, Input* ptr);
 
 #define REGISTER_MANUAL_PART_Input(T, className) \
     /* bool Input::SaveGestures(Serializer &dest) | File: ../Input/Input.h */ \
-    engine->RegisterObjectMethod(className, "bool SaveGestures(File@+)", asFUNCTION(InputSaveGestures), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool SaveGestures(File@+)", AS_FUNCTION_OBJLAST(InputSaveGestures), AS_CALL_CDECL_OBJLAST); \
     /* bool Input::SaveGestures(Serializer &dest) | File: ../Input/Input.h */ \
-    engine->RegisterObjectMethod(className, "bool SaveGestures(VectorBuffer&)", asFUNCTION(InputSaveGesturesVectorBuffer), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool SaveGestures(VectorBuffer&)", AS_FUNCTION_OBJLAST(InputSaveGesturesVectorBuffer), AS_CALL_CDECL_OBJLAST); \
     /* bool Input::SaveGesture(Serializer &dest, unsigned gestureID) | File: ../Input/Input.h */ \
-    engine->RegisterObjectMethod(className, "bool SaveGesture(File@+, uint)", asFUNCTION(InputSaveGesture), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool SaveGesture(File@+, uint)", AS_FUNCTION_OBJLAST(InputSaveGesture), AS_CALL_CDECL_OBJLAST); \
     /* bool Input::SaveGesture(Serializer &dest, unsigned gestureID) | File: ../Input/Input.h */ \
-    engine->RegisterObjectMethod(className, "bool SaveGesture(VectorBuffer&, uint)", asFUNCTION(InputSaveGestureVectorBuffer), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool SaveGesture(VectorBuffer&, uint)", AS_FUNCTION_OBJLAST(InputSaveGestureVectorBuffer), AS_CALL_CDECL_OBJLAST); \
     /* unsigned Input::LoadGestures(Deserializer &source) | File: ../Input/Input.h */ \
-    engine->RegisterObjectMethod(className, "uint LoadGestures(File@+)", asFUNCTION(InputLoadGestures), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "uint LoadGestures(File@+)", AS_FUNCTION_OBJLAST(InputLoadGestures), AS_CALL_CDECL_OBJLAST); \
     /* unsigned Input::LoadGestures(Deserializer &source) | File: ../Input/Input.h */ \
-    engine->RegisterObjectMethod(className, "uint LoadGestures(VectorBuffer&)", asFUNCTION(InputLoadGesturesVectorBuffer), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "uint LoadGestures(VectorBuffer&)", AS_FUNCTION_OBJLAST(InputLoadGesturesVectorBuffer), AS_CALL_CDECL_OBJLAST); \
     /* void Input::SetMouseGrabbed(bool grab, bool suppressEvent=false) | File: ../Input/Input.h */ \
-    engine->RegisterObjectMethod(className, "void set_mouseGrabbed(bool)", asFUNCTION(InputSetMouseGrabbed), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "void set_mouseGrabbed(bool)", AS_FUNCTION_OBJLAST(InputSetMouseGrabbed), AS_CALL_CDECL_OBJLAST); \
     /* void Input::SetMouseMode(MouseMode mode, bool suppressEvent=false) | File: ../Input/Input.h */ \
-    engine->RegisterObjectMethod(className, "void set_mouseMode(MouseMode)", asFUNCTION(InputSetMouseMode), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "void set_mouseMode(MouseMode)", AS_FUNCTION_OBJLAST(InputSetMouseMode), AS_CALL_CDECL_OBJLAST); \
     /* void Input::SetMouseVisible(bool enable, bool suppressEvent=false) | File: ../Input/Input.h */ \
-    engine->RegisterObjectMethod(className, "void set_mouseVisible(bool)", asFUNCTION(InputSetMouseVisible), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "void set_mouseVisible(bool)", AS_FUNCTION_OBJLAST(InputSetMouseVisible), AS_CALL_CDECL_OBJLAST);
 
 }

Source/Urho3D/AngelScript/Manual_Math.cpp

@@ -39,7 +39,7 @@ void ASRegisterManualFirst_Math(asIScriptEngine* engine)
 void ASRegisterManualLast_Math(asIScriptEngine* engine)
 {
     // template <class T, typename std::enable_if...> T Mod(T x, T y) | File: ../Math/MathDefs.h
-    engine->RegisterGlobalFunction("float Mod(float, float)", asFUNCTION(Mod<float>), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float Mod(float, float)", AS_FUNCTION(Mod<float>), AS_CALL_CDECL);
 }
 
 // ========================================================================================

Source/Urho3D/AngelScript/Manual_Math.h

@@ -35,9 +35,9 @@ CScriptArray* IntVector2Data(IntVector2* ptr);
 
 #define REGISTER_MANUAL_PART_IntVector2(T, className) \
     /* explicit IntVector2::IntVector2(const int *data) noexcept | File: ../Math/Vector2.h */ \
-    engine->RegisterObjectBehaviour(className, asBEHAVE_CONSTRUCT, "void f(int[]&)", asFUNCTION(ConstructIntVector2ArrayInit), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectBehaviour(className, asBEHAVE_CONSTRUCT, "void f(int[]&)", AS_FUNCTION_OBJLAST(ConstructIntVector2ArrayInit), AS_CALL_CDECL_OBJLAST); \
     /* const int* IntVector2::Data() const | File: ../Math/Vector2.h */ \
-    engine->RegisterObjectMethod(className, "int[]& get_data() const", asFUNCTION(IntVector2Data), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "int[]& get_data() const", AS_FUNCTION_OBJLAST(IntVector2Data), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -48,9 +48,9 @@ CScriptArray* Vector2Data(Vector2* ptr);
 
 #define REGISTER_MANUAL_PART_Vector2(T, className) \
     /* explicit Vector2::Vector2(const float *data) noexcept | File: ../Math/Vector2.h */ \
-    engine->RegisterObjectBehaviour(className, asBEHAVE_CONSTRUCT, "void f(float[]&)", asFUNCTION(ConstructVector2ArrayInit), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectBehaviour(className, asBEHAVE_CONSTRUCT, "void f(float[]&)", AS_FUNCTION_OBJLAST(ConstructVector2ArrayInit), AS_CALL_CDECL_OBJLAST); \
     /* const float* Vector2::Data() const | File: ../Math/Vector2.h */ \
-    engine->RegisterObjectMethod(className, "float[]& get_data() const", asFUNCTION(Vector2Data), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "float[]& get_data() const", AS_FUNCTION_OBJLAST(Vector2Data), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -61,9 +61,9 @@ CScriptArray* IntVector3Data(IntVector3* ptr);
 
 #define REGISTER_MANUAL_PART_IntVector3(T, className) \
     /* explicit IntVector3::IntVector3(const int *data) noexcept | File: ../Math/Vector3.h */ \
-    engine->RegisterObjectBehaviour(className, asBEHAVE_CONSTRUCT, "void f(int[]&)", asFUNCTION(ConstructIntVector3ArrayInit), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectBehaviour(className, asBEHAVE_CONSTRUCT, "void f(int[]&)", AS_FUNCTION_OBJLAST(ConstructIntVector3ArrayInit), AS_CALL_CDECL_OBJLAST); \
     /* const int* IntVector3::Data() const | File: ../Math/Vector3.h */ \
-    engine->RegisterObjectMethod(className, "int[]& get_data() const", asFUNCTION(IntVector3Data), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "int[]& get_data() const", AS_FUNCTION_OBJLAST(IntVector3Data), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -74,9 +74,9 @@ CScriptArray* Vector3Data(Vector3* ptr);
 
 #define REGISTER_MANUAL_PART_Vector3(T, className) \
     /* explicit Vector3::Vector3(const float *data) noexcept | File: ../Math/Vector3.h */ \
-    engine->RegisterObjectBehaviour(className, asBEHAVE_CONSTRUCT, "void f(float[]&)", asFUNCTION(ConstructVector3ArrayInit), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectBehaviour(className, asBEHAVE_CONSTRUCT, "void f(float[]&)", AS_FUNCTION_OBJLAST(ConstructVector3ArrayInit), AS_CALL_CDECL_OBJLAST); \
     /* const float* Vector3::Data() const | File: ../Math/Vector3.h */ \
-    engine->RegisterObjectMethod(className, "float[]& get_data() const", asFUNCTION(Vector3Data), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "float[]& get_data() const", AS_FUNCTION_OBJLAST(Vector3Data), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -87,9 +87,9 @@ CScriptArray* Vector4Data(Vector4* ptr);
 
 #define REGISTER_MANUAL_PART_Vector4(T, className) \
     /* explicit Vector4::Vector4(const float *data) noexcept | File: ../Math/Vector4.h */ \
-    engine->RegisterObjectBehaviour(className, asBEHAVE_CONSTRUCT, "void f(float[]&)", asFUNCTION(ConstructVector4ArrayInit), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectBehaviour(className, asBEHAVE_CONSTRUCT, "void f(float[]&)", AS_FUNCTION_OBJLAST(ConstructVector4ArrayInit), AS_CALL_CDECL_OBJLAST); \
     /* const float* Vector4::Data() const | File: ../Math/Vector4.h */ \
-    engine->RegisterObjectMethod(className, "float[]& get_data() const", asFUNCTION(Vector4Data), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "float[]& get_data() const", AS_FUNCTION_OBJLAST(Vector4Data), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -100,9 +100,9 @@ CScriptArray* IntRectData(IntRect* ptr);
 
 #define REGISTER_MANUAL_PART_IntRect(T, className) \
     /* explicit IntRect::IntRect(const int *data) noexcept | File: ../Math/Rect.h */ \
-    engine->RegisterObjectBehaviour(className, asBEHAVE_CONSTRUCT, "void f(int[]&)", asFUNCTION(ConstructIntRectArrayInit), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectBehaviour(className, asBEHAVE_CONSTRUCT, "void f(int[]&)", AS_FUNCTION_OBJLAST(ConstructIntRectArrayInit), AS_CALL_CDECL_OBJLAST); \
     /* const int* IntRect::Data() const | File: ../Math/Rect.h */ \
-    engine->RegisterObjectMethod(className, "int[]& get_data() const", asFUNCTION(IntRectData), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "int[]& get_data() const", AS_FUNCTION_OBJLAST(IntRectData), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -113,9 +113,9 @@ CScriptArray* ColorData(Color* ptr);
 
 #define REGISTER_MANUAL_PART_Color(T, className) \
     /* explicit Color::Color(const float *data) noexcept | File: ../Math/Color.h */ \
-    engine->RegisterObjectBehaviour(className, asBEHAVE_CONSTRUCT, "void f(float[]&)", asFUNCTION(ConstructColorArrayInit), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectBehaviour(className, asBEHAVE_CONSTRUCT, "void f(float[]&)", AS_FUNCTION_OBJLAST(ConstructColorArrayInit), AS_CALL_CDECL_OBJLAST); \
     /* const float* Color::Data() const | File: ../Math/Color.h */ \
-    engine->RegisterObjectMethod(className, "float[]& get_data() const", asFUNCTION(ColorData), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "float[]& get_data() const", AS_FUNCTION_OBJLAST(ColorData), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -124,7 +124,7 @@ float Ray_HitDistance(const Vector3& v0, const Vector3& v1, const Vector3& v2, R
 
 #define REGISTER_MANUAL_PART_Ray(T, className) \
     /* float Ray::HitDistance(const Vector3 &v0, const Vector3 &v1, const Vector3 &v2, Vector3 *outNormal=nullptr, Vector3 *outBary=nullptr) const | File: ../Math/Ray.h */ \
-    engine->RegisterObjectMethod(className, "float HitDistance(const Vector3&in, const Vector3&in, const Vector3&in) const", asFUNCTION(Ray_HitDistance), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "float HitDistance(const Vector3&in, const Vector3&in, const Vector3&in) const", AS_FUNCTION_OBJLAST(Ray_HitDistance), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -133,7 +133,7 @@ Vector3 FrustumGetVertex(unsigned index, Frustum* ptr);
 
 #define REGISTER_MANUAL_PART_Frustum(T, className) \
     /* Vector3 Frustum::vertices_[NUM_FRUSTUM_VERTICES] | File: ../Math/Frustum.h */ \
-    engine->RegisterObjectMethod(className, "Vector3 get_vertices(uint) const", asFUNCTION(FrustumGetVertex), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "Vector3 get_vertices(uint) const", AS_FUNCTION_OBJLAST(FrustumGetVertex), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -144,8 +144,8 @@ CScriptArray* PolyhedronGetFace(unsigned index, Polyhedron* ptr);
 
 #define REGISTER_MANUAL_PART_Polyhedron(T, className) \
     /* Vector<PODVector<Vector3> > Polyhedron::faces_ | File: ../Math/Polyhedron.h */ \
-    engine->RegisterObjectMethod(className, "uint get_numFaces() const", asFUNCTION(PolyhedronGetNumFaces), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "uint get_numFaces() const", AS_FUNCTION_OBJLAST(PolyhedronGetNumFaces), AS_CALL_CDECL_OBJLAST); \
     /* Vector<PODVector<Vector3> > Polyhedron::faces_ | File: ../Math/Polyhedron.h */ \
-    engine->RegisterObjectMethod(className, "Array<Vector3>@ get_face(uint) const", asFUNCTION(PolyhedronGetFace), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "Array<Vector3>@ get_face(uint) const", AS_FUNCTION_OBJLAST(PolyhedronGetFace), AS_CALL_CDECL_OBJLAST);
 
 }

Source/Urho3D/AngelScript/Manual_Navigation.h

@@ -52,23 +52,23 @@ CScriptArray* NavigationMeshFindPath(const Vector3& start, const Vector3& end, c
 
 #define REGISTER_MANUAL_PART_NavigationMesh(T, className) \
     /* virtual PODVector<unsigned char> NavigationMesh::GetTileData(const IntVector2 &tile) const | File: ../Navigation/NavigationMesh.h */ \
-    engine->RegisterObjectMethod(className, "VectorBuffer GetTileData(const IntVector2&) const", asFUNCTION(NavigationMeshGetTileData), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "VectorBuffer GetTileData(const IntVector2&) const", AS_FUNCTION_OBJLAST(NavigationMeshGetTileData), AS_CALL_CDECL_OBJLAST); \
     /* virtual bool NavigationMesh::AddTile(const PODVector< unsigned char > &tileData) | File: ../Navigation/NavigationMesh.h */ \
-    engine->RegisterObjectMethod(className, "bool AddTile(const VectorBuffer&in) const", asFUNCTION(NavigationMeshAddTile), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool AddTile(const VectorBuffer&in) const", AS_FUNCTION_OBJLAST(NavigationMeshAddTile), AS_CALL_CDECL_OBJLAST); \
     /* Vector3 NavigationMesh::FindNearestPoint(const Vector3 &point, const Vector3 &extents=Vector3::ONE, const dtQueryFilter *filter=nullptr, dtPolyRef *nearestRef=nullptr) | File: ../Navigation/NavigationMesh.h */ \
-    engine->RegisterObjectMethod(className, "Vector3 FindNearestPoint(const Vector3&in, const Vector3&in extents = Vector3(1.0, 1.0, 1.0))", asFUNCTION(NavigationMeshFindNearestPoint), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Vector3 FindNearestPoint(const Vector3&in, const Vector3&in extents = Vector3(1.0, 1.0, 1.0))", AS_FUNCTION_OBJLAST(NavigationMeshFindNearestPoint), AS_CALL_CDECL_OBJLAST); \
     /* Vector3 NavigationMesh::GetRandomPoint(const dtQueryFilter *filter=nullptr, dtPolyRef *randomRef=nullptr) | File: ../Navigation/NavigationMesh.h */ \
-    engine->RegisterObjectMethod(className, "Vector3 GetRandomPoint()", asFUNCTION(NavigationMeshGetRandomPoint), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Vector3 GetRandomPoint()", AS_FUNCTION_OBJLAST(NavigationMeshGetRandomPoint), AS_CALL_CDECL_OBJLAST); \
     /* Vector3 NavigationMesh::GetRandomPointInCircle(const Vector3 &center, float radius, const Vector3 &extents=Vector3::ONE, const dtQueryFilter *filter=nullptr, dtPolyRef *randomRef=nullptr) | File: ../Navigation/NavigationMesh.h */ \
-    engine->RegisterObjectMethod(className, "Vector3 GetRandomPointInCircle(const Vector3&in, float, const Vector3&in extents = Vector3(1.0, 1.0, 1.0))", asFUNCTION(NavigationMeshGetRandomPointInCircle), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Vector3 GetRandomPointInCircle(const Vector3&in, float, const Vector3&in extents = Vector3(1.0, 1.0, 1.0))", AS_FUNCTION_OBJLAST(NavigationMeshGetRandomPointInCircle), AS_CALL_CDECL_OBJLAST); \
     /* float NavigationMesh::GetDistanceToWall(const Vector3 &point, float radius, const Vector3 &extents=Vector3::ONE, const dtQueryFilter *filter=nullptr, Vector3 *hitPos=nullptr, Vector3 *hitNormal=nullptr) | File: ../Navigation/NavigationMesh.h */ \
-    engine->RegisterObjectMethod(className, "float GetDistanceToWall(const Vector3&in, float, const Vector3&in extents = Vector3(1.0, 1.0, 1.0))", asFUNCTION(NavigationMeshGetDistanceToWall), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "float GetDistanceToWall(const Vector3&in, float, const Vector3&in extents = Vector3(1.0, 1.0, 1.0))", AS_FUNCTION_OBJLAST(NavigationMeshGetDistanceToWall), AS_CALL_CDECL_OBJLAST); \
     /* Vector3 NavigationMesh::Raycast(const Vector3 &start, const Vector3 &end, const Vector3 &extents=Vector3::ONE, const dtQueryFilter *filter=nullptr, Vector3 *hitNormal=nullptr) | File: ../Navigation/NavigationMesh.h */ \
-    engine->RegisterObjectMethod(className, "Vector3 Raycast(const Vector3&in, const Vector3&in, const Vector3&in extents = Vector3(1.0, 1.0, 1.0))", asFUNCTION(NavigationMeshRaycast), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Vector3 Raycast(const Vector3&in, const Vector3&in, const Vector3&in extents = Vector3(1.0, 1.0, 1.0))", AS_FUNCTION_OBJLAST(NavigationMeshRaycast), AS_CALL_CDECL_OBJLAST); \
     /* Vector3 NavigationMesh::MoveAlongSurface(const Vector3 &start, const Vector3 &end, const Vector3 &extents=Vector3::ONE, int maxVisited=3, const dtQueryFilter *filter=nullptr) | File: ../Navigation/NavigationMesh.h */ \
-    engine->RegisterObjectMethod(className, "Vector3 MoveAlongSurface(const Vector3&in, const Vector3&in, const Vector3&in extents = Vector3(1.0, 1.0, 1.0), int maxVisited = 3)", asFUNCTION(NavigationMeshMoveAlongSurface), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Vector3 MoveAlongSurface(const Vector3&in, const Vector3&in, const Vector3&in extents = Vector3(1.0, 1.0, 1.0), int maxVisited = 3)", AS_FUNCTION_OBJLAST(NavigationMeshMoveAlongSurface), AS_CALL_CDECL_OBJLAST); \
     /* void NavigationMesh::FindPath(PODVector< Vector3 > &dest, const Vector3 &start, const Vector3 &end, const Vector3 &extents=Vector3::ONE, const dtQueryFilter *filter=nullptr) | File: ../Navigation/NavigationMesh.h */ \
-    engine->RegisterObjectMethod(className, "Array<Vector3>@ FindPath(const Vector3&in, const Vector3&in, const Vector3&in extents = Vector3(1.0, 1.0, 1.0))", asFUNCTION(NavigationMeshFindPath), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "Array<Vector3>@ FindPath(const Vector3&in, const Vector3&in, const Vector3&in extents = Vector3(1.0, 1.0, 1.0))", AS_FUNCTION_OBJLAST(NavigationMeshFindPath), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -85,15 +85,15 @@ Vector3 CrowdManager_Raycast(const Vector3& start, const Vector3& end, int query
 
 #define REGISTER_MANUAL_PART_CrowdManager(T, className) \
     /* Vector3 CrowdManager::GetRandomPoint(int queryFilterType, dtPolyRef *randomRef=nullptr) | File: ../Navigation/CrowdManager.h */ \
-    engine->RegisterObjectMethod(className, "Vector3 GetRandomPoint(int)", asFUNCTION(CrowdManagerGetRandomPoint), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Vector3 GetRandomPoint(int)", AS_FUNCTION_OBJLAST(CrowdManagerGetRandomPoint), AS_CALL_CDECL_OBJLAST); \
     /* Vector3 CrowdManager::GetRandomPointInCircle(const Vector3 &center, float radius, int queryFilterType, dtPolyRef *randomRef=nullptr) | File: ../Navigation/CrowdManager.h */ \
-    engine->RegisterObjectMethod(className, "Vector3 GetRandomPointInCircle(const Vector3&in, float, int)", asFUNCTION(CrowdManagerRandomPointInCircle), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Vector3 GetRandomPointInCircle(const Vector3&in, float, int)", AS_FUNCTION_OBJLAST(CrowdManagerRandomPointInCircle), AS_CALL_CDECL_OBJLAST); \
     /* Vector3 CrowdManager::FindNearestPoint(const Vector3 &point, int queryFilterType, dtPolyRef *nearestRef=nullptr) | File: ../Navigation/CrowdManager.h */ \
-    engine->RegisterObjectMethod("CrowdManager", "Vector3 FindNearestPoint(const Vector3&in, int)", asFUNCTION(CrowdManager_FindNearestPoint), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod("CrowdManager", "Vector3 FindNearestPoint(const Vector3&in, int)", AS_FUNCTION_OBJLAST(CrowdManager_FindNearestPoint), AS_CALL_CDECL_OBJLAST); \
     /* float CrowdManager::GetDistanceToWall(const Vector3 &point, float radius, int queryFilterType, Vector3 *hitPos=nullptr, Vector3 *hitNormal=nullptr) | File: ../Navigation/CrowdManager.h */ \
-    engine->RegisterObjectMethod("CrowdManager", "float GetDistanceToWall(const Vector3&in, float, int)", asFUNCTION(CrowdManager_GetDistanceToWall), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod("CrowdManager", "float GetDistanceToWall(const Vector3&in, float, int)", AS_FUNCTION_OBJLAST(CrowdManager_GetDistanceToWall), AS_CALL_CDECL_OBJLAST); \
     /* Vector3 CrowdManager::Raycast(const Vector3 &start, const Vector3 &end, int queryFilterType, Vector3 *hitNormal=nullptr) | File: ../Navigation/CrowdManager.h */ \
-    engine->RegisterObjectMethod("CrowdManager", "Vector3 Raycast(const Vector3&in, const Vector3&in, int)", asFUNCTION(CrowdManager_Raycast), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("CrowdManager", "Vector3 Raycast(const Vector3&in, const Vector3&in, int)", AS_FUNCTION_OBJLAST(CrowdManager_Raycast), AS_CALL_CDECL_OBJLAST);
 
 }
 

Source/Urho3D/AngelScript/Manual_Network.cpp

@@ -47,7 +47,7 @@ static Network* GetNetwork()
 void ASRegisterManualLast_Network(asIScriptEngine* engine)
 {
     // template<class T> T * Object::GetSubsystem() const | File: ../Core/Object.h
-    engine->RegisterGlobalFunction("Network@+ get_network()", asFUNCTION(GetNetwork), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Network@+ get_network()", AS_FUNCTION(GetNetwork), AS_CALL_CDECL);
 }
 
 } // namespace Urho3D

Source/Urho3D/AngelScript/Manual_Physics.cpp

@@ -47,7 +47,7 @@ static PhysicsWorld* GetPhysicsWorld()
 void ASRegisterManualLast_Physics(asIScriptEngine* engine)
 {
     // template<class T> T * Node::GetComponent(bool recursive=false) const | File: ../Scene/Node.h
-    engine->RegisterGlobalFunction("PhysicsWorld@+ get_physicsWorld()", asFUNCTION(GetPhysicsWorld), asCALL_CDECL);
+    engine->RegisterGlobalFunction("PhysicsWorld@+ get_physicsWorld()", AS_FUNCTION(GetPhysicsWorld), AS_CALL_CDECL);
 }
 
 // ========================================================================================

Source/Urho3D/AngelScript/Manual_Physics.h

@@ -39,7 +39,7 @@ RigidBody* PhysicsRaycastResultGetRigidBody(PhysicsRaycastResult* ptr);
 
 #define REGISTER_MANUAL_PART_PhysicsRaycastResult(T, className) \
     /* RigidBody* PhysicsRaycastResult::body_ | File: ../Physics/PhysicsWorld.h */ \
-    engine->RegisterObjectMethod(className, "RigidBody@+ get_body() const", asFUNCTION(PhysicsRaycastResultGetRigidBody), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "RigidBody@+ get_body() const", AS_FUNCTION_OBJLAST(PhysicsRaycastResultGetRigidBody), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -48,7 +48,7 @@ CScriptArray* RigidBodyGetCollidingBodies(RigidBody* ptr);
 
 #define REGISTER_MANUAL_PART_RigidBody(T, className) \
     /* void RigidBody::GetCollidingBodies(PODVector< RigidBody * > &result) const | File: ../Physics/RigidBody.h */ \
-    engine->RegisterObjectMethod(className, "Array<RigidBody@>@ get_collidingBodies() const", asFUNCTION(RigidBodyGetCollidingBodies), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "Array<RigidBody@>@ get_collidingBodies() const", AS_FUNCTION_OBJLAST(RigidBodyGetCollidingBodies), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -73,25 +73,25 @@ CScriptArray* PhysicsWorldGetCollidingBodies(RigidBody* body, PhysicsWorld* ptr)
 
 #define REGISTER_MANUAL_PART_PhysicsWorld(T, className) \
     /* void PhysicsWorld::Raycast(PODVector< PhysicsRaycastResult > &result, const Ray &ray, float maxDistance, unsigned collisionMask=M_MAX_UNSIGNED) | File: ../Physics/PhysicsWorld.h */ \
-    engine->RegisterObjectMethod(className, "Array<PhysicsRaycastResult>@ Raycast(const Ray&in, float, uint collisionMask = 0xffff)", asFUNCTION(PhysicsWorldRaycast), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Array<PhysicsRaycastResult>@ Raycast(const Ray&in, float, uint collisionMask = 0xffff)", AS_FUNCTION_OBJLAST(PhysicsWorldRaycast), AS_CALL_CDECL_OBJLAST); \
     /* void PhysicsWorld::RaycastSingle(PhysicsRaycastResult &result, const Ray &ray, float maxDistance, unsigned collisionMask=M_MAX_UNSIGNED) | File: ../Physics/PhysicsWorld.h */ \
-    engine->RegisterObjectMethod(className, "PhysicsRaycastResult RaycastSingle(const Ray&in, float, uint collisionMask = 0xffff)", asFUNCTION(PhysicsWorldRaycastSingle), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "PhysicsRaycastResult RaycastSingle(const Ray&in, float, uint collisionMask = 0xffff)", AS_FUNCTION_OBJLAST(PhysicsWorldRaycastSingle), AS_CALL_CDECL_OBJLAST); \
     /* void PhysicsWorld::RaycastSingleSegmented(PhysicsRaycastResult &result, const Ray &ray, float maxDistance, float segmentDistance, unsigned collisionMask=M_MAX_UNSIGNED, float overlapDistance=0.1f) | File: ../Physics/PhysicsWorld.h */ \
-    engine->RegisterObjectMethod(className, "PhysicsRaycastResult RaycastSingleSegmented(const Ray&in, float, float, uint collisionMask = 0xffff, float overlapDistance = 0.1f)", asFUNCTION(PhysicsWorldRaycastSingleSegmented), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "PhysicsRaycastResult RaycastSingleSegmented(const Ray&in, float, float, uint collisionMask = 0xffff, float overlapDistance = 0.1f)", AS_FUNCTION_OBJLAST(PhysicsWorldRaycastSingleSegmented), AS_CALL_CDECL_OBJLAST); \
     /* void PhysicsWorld::SphereCast(PhysicsRaycastResult &result, const Ray &ray, float radius, float maxDistance, unsigned collisionMask=M_MAX_UNSIGNED) | File: ../Physics/PhysicsWorld.h */ \
-    engine->RegisterObjectMethod(className, "PhysicsRaycastResult SphereCast(const Ray&in, float, float, uint collisionMask = 0xffff)", asFUNCTION(PhysicsWorldSphereCast), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "PhysicsRaycastResult SphereCast(const Ray&in, float, float, uint collisionMask = 0xffff)", AS_FUNCTION_OBJLAST(PhysicsWorldSphereCast), AS_CALL_CDECL_OBJLAST); \
     /* There seems to be a bug in AngelScript resulting in a crash if we use an auto handle with this function. */ \
     /* Work around by manually releasing the CollisionShape handle */ \
     /* void PhysicsWorld::ConvexCast(PhysicsRaycastResult &result, CollisionShape *shape, const Vector3 &startPos, const Quaternion &startRot, const Vector3 &endPos, const Quaternion &endRot, unsigned collisionMask=M_MAX_UNSIGNED) | File: ../Physics/PhysicsWorld.h */ \
-    engine->RegisterObjectMethod(className, "PhysicsRaycastResult ConvexCast(CollisionShape@, const Vector3&in, const Quaternion&in, const Vector3&in, const Quaternion&in, uint collisionMask = 0xffff)", asFUNCTION(PhysicsWorldConvexCast), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "PhysicsRaycastResult ConvexCast(CollisionShape@, const Vector3&in, const Quaternion&in, const Vector3&in, const Quaternion&in, uint collisionMask = 0xffff)", AS_FUNCTION_OBJLAST(PhysicsWorldConvexCast), AS_CALL_CDECL_OBJLAST); \
     /* void PhysicsWorld::GetRigidBodies(PODVector< RigidBody * > &result, const Sphere &sphere, unsigned collisionMask=M_MAX_UNSIGNED) | File: ../Physics/PhysicsWorld.h */ \
-    engine->RegisterObjectMethod(className, "Array<RigidBody@>@ GetRigidBodies(const Sphere&in, uint collisionMask = 0xffff)", asFUNCTION(PhysicsWorldGetRigidBodiesSphere), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Array<RigidBody@>@ GetRigidBodies(const Sphere&in, uint collisionMask = 0xffff)", AS_FUNCTION_OBJLAST(PhysicsWorldGetRigidBodiesSphere), AS_CALL_CDECL_OBJLAST); \
     /* void PhysicsWorld::GetRigidBodies(PODVector< RigidBody * > &result, const BoundingBox &box, unsigned collisionMask=M_MAX_UNSIGNED) | File: ../Physics/PhysicsWorld.h */ \
-    engine->RegisterObjectMethod(className, "Array<RigidBody@>@ GetRigidBodies(const BoundingBox&in, uint collisionMask = 0xffff)", asFUNCTION(PhysicsWorldGetRigidBodiesBox), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Array<RigidBody@>@ GetRigidBodies(const BoundingBox&in, uint collisionMask = 0xffff)", AS_FUNCTION_OBJLAST(PhysicsWorldGetRigidBodiesBox), AS_CALL_CDECL_OBJLAST); \
     /* void PhysicsWorld::GetRigidBodies(PODVector< RigidBody * > &result, const RigidBody *body) | File: ../Physics/PhysicsWorld.h */ \
-    engine->RegisterObjectMethod(className, "Array<RigidBody@>@ GetRigidBodies(RigidBody@+)", asFUNCTION(PhysicsWorldGetRigidBodiesBody), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Array<RigidBody@>@ GetRigidBodies(RigidBody@+)", AS_FUNCTION_OBJLAST(PhysicsWorldGetRigidBodiesBody), AS_CALL_CDECL_OBJLAST); \
     /* void PhysicsWorld::GetCollidingBodies(PODVector< RigidBody * > &result, const RigidBody *body) | File: ../Physics/PhysicsWorld.h */ \
-    engine->RegisterObjectMethod(className, "Array<RigidBody@>@ GetCollidingBodies(RigidBody@+)", asFUNCTION(PhysicsWorldGetCollidingBodies), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "Array<RigidBody@>@ GetCollidingBodies(RigidBody@+)", AS_FUNCTION_OBJLAST(PhysicsWorldGetCollidingBodies), AS_CALL_CDECL_OBJLAST);
 
 }
 

Source/Urho3D/AngelScript/Manual_Resource.cpp

@@ -54,11 +54,11 @@ static Localization* GetLocalization()
 void ASRegisterManualLast_Resource(asIScriptEngine* engine)
 {
     // template<class T> T * Object::GetSubsystem() const | File: ../Core/Object.h
-    engine->RegisterGlobalFunction("Localization@+ get_localization()", asFUNCTION(GetLocalization), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Localization@+ get_localization()", AS_FUNCTION(GetLocalization), AS_CALL_CDECL);
     // template<class T> T * Object::GetSubsystem() const | File: ../Core/Object.h
-    engine->RegisterGlobalFunction("ResourceCache@+ get_resourceCache()", asFUNCTION(GetResourceCache), asCALL_CDECL);
+    engine->RegisterGlobalFunction("ResourceCache@+ get_resourceCache()", AS_FUNCTION(GetResourceCache), AS_CALL_CDECL);
     // template<class T> T * Object::GetSubsystem() const | File: ../Core/Object.h
-    engine->RegisterGlobalFunction("ResourceCache@+ get_cache()", asFUNCTION(GetResourceCache), asCALL_CDECL);
+    engine->RegisterGlobalFunction("ResourceCache@+ get_cache()", AS_FUNCTION(GetResourceCache), AS_CALL_CDECL);
 }
 
 // ========================================================================================

Source/Urho3D/AngelScript/Manual_Resource.h

@@ -41,13 +41,13 @@ bool ResourceSaveVectorBuffer(VectorBuffer& buffer, Resource* ptr);
 
 #define REGISTER_MANUAL_PART_Resource(T, className) \
     /* bool Resource::Load(Deserializer &source) | File: ../Resource/Resource.h */ \
-    engine->RegisterObjectMethod(className, "bool Load(File@+)", asFUNCTION(ResourceLoad), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool Load(File@+)", AS_FUNCTION_OBJLAST(ResourceLoad), AS_CALL_CDECL_OBJLAST); \
     /* bool Resource::Load(Deserializer &source) | File: ../Resource/Resource.h */ \
-    engine->RegisterObjectMethod(className, "bool Load(VectorBuffer&)", asFUNCTION(ResourceLoadVectorBuffer), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool Load(VectorBuffer&)", AS_FUNCTION_OBJLAST(ResourceLoadVectorBuffer), AS_CALL_CDECL_OBJLAST); \
     /* virtual bool Resource::Save(Serializer &dest) const | File: ../Resource/Resource.h */ \
-    engine->RegisterObjectMethod(className, "bool Save(File@+) const", asFUNCTION(ResourceSave), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool Save(File@+) const", AS_FUNCTION_OBJLAST(ResourceSave), AS_CALL_CDECL_OBJLAST); \
     /* virtual bool Resource::Save(Serializer &dest) const | File: ../Resource/Resource.h */ \
-    engine->RegisterObjectMethod(className, "bool Save(VectorBuffer&) const", asFUNCTION(ResourceSaveVectorBuffer), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "bool Save(VectorBuffer&) const", AS_FUNCTION_OBJLAST(ResourceSaveVectorBuffer), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -56,7 +56,7 @@ bool XPathQuery_SetQuery(const String& queryString, XPathQuery* ptr);
 
 #define REGISTER_MANUAL_PART_XPathQuery(T, className) \
     /* bool XPathQuery::SetQuery(const String &queryString, const String &variableString=String::EMPTY, bool bind=true) | File: ../Resource/XMLElement.h */ \
-    engine->RegisterObjectMethod(className, "void set_query(const String&)", asFUNCTION(XPathQuery_SetQuery), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "void set_query(const String&)", AS_FUNCTION_OBJLAST(XPathQuery_SetQuery), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -65,7 +65,7 @@ XMLElement XMLFileGetRootDefault(XMLFile* ptr);
 
 #define REGISTER_MANUAL_PART_XMLFile(T, className) \
     /* XMLElement XMLFile::GetRoot(const String &name=String::EMPTY) | File: ../Resource/XMLFile.h */ \
-    engine->RegisterObjectMethod(className, "XMLElement get_root()", asFUNCTION(XMLFileGetRootDefault), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "XMLElement get_root()", AS_FUNCTION_OBJLAST(XMLFileGetRootDefault), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -80,13 +80,13 @@ CScriptArray* XMLElementGetVariantVector(XMLElement* ptr);
 
 #define REGISTER_MANUAL_PART_XMLElement(T, className) \
     /* XMLElement XMLElement::SelectSingle(const String &query, pugi::xpath_variable_set *variables=nullptr) const | File: ../Resource/XMLElement.h */ \
-    engine->RegisterObjectMethod(className, "XMLElement SelectSingle(const String&in)", asFUNCTION(XMLElement_SelectSingle), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "XMLElement SelectSingle(const String&in)", AS_FUNCTION_OBJLAST(XMLElement_SelectSingle), AS_CALL_CDECL_OBJLAST); \
     /* XPathResultSet XMLElement::Select(const String &query, pugi::xpath_variable_set *variables=nullptr) const | File: ../Resource/XMLElement.h */ \
-    engine->RegisterObjectMethod(className, "XPathResultSet Select(const String&in)", asFUNCTION(XMLElement_Select), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "XPathResultSet Select(const String&in)", AS_FUNCTION_OBJLAST(XMLElement_Select), AS_CALL_CDECL_OBJLAST); \
     /* bool XMLElement::SetVariantVector(const VariantVector &value) | File: ../Resource/XMLElement.h */ \
-    engine->RegisterObjectMethod(className, "bool SetVariantVector(Array<Variant>@+)", asFUNCTION(XMLElementSetVariantVector), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool SetVariantVector(Array<Variant>@+)", AS_FUNCTION_OBJLAST(XMLElementSetVariantVector), AS_CALL_CDECL_OBJLAST); \
     /* VariantVector XMLElement::GetVariantVector() const | File: ../Resource/XMLElement.h */ \
-    engine->RegisterObjectMethod(className, "Array<Variant>@ GetVariantVector() const", asFUNCTION(XMLElementGetVariantVector), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "Array<Variant>@ GetVariantVector() const", AS_FUNCTION_OBJLAST(XMLElementGetVariantVector), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -95,7 +95,7 @@ CScriptArray* ResourceCacheGetResources(StringHash type, ResourceCache* ptr);
 
 #define REGISTER_MANUAL_PART_ResourceCache(T, className) \
     /* void ResourceCache::GetResources(PODVector< Resource * > &result, StringHash type) const | File: ../Resource/ResourceCache.h */ \
-    engine->RegisterObjectMethod(className, "Array<Resource@>@ GetResources(StringHash)", asFUNCTION(ResourceCacheGetResources), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "Array<Resource@>@ GetResources(StringHash)", AS_FUNCTION_OBJLAST(ResourceCacheGetResources), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -103,7 +103,7 @@ CScriptArray* JSONValueGetKeys(const JSONValue& jsonValue);
 CScriptArray* JSONValueGetValues(const JSONValue& jsonValue);
 
 #define REGISTER_MANUAL_PART_JSONValue(T, className) \
-    engine->RegisterObjectMethod(className, "Array<String>@ get_keys() const", asFUNCTION(JSONValueGetKeys), asCALL_CDECL_OBJLAST); \
-    engine->RegisterObjectMethod(className, "Array<JSONValue>@ get_values() const", asFUNCTION(JSONValueGetValues), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "Array<String>@ get_keys() const", AS_FUNCTION_OBJLAST(JSONValueGetKeys), AS_CALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Array<JSONValue>@ get_values() const", AS_FUNCTION_OBJLAST(JSONValueGetValues), AS_CALL_CDECL_OBJLAST);
 
 }

Source/Urho3D/AngelScript/Manual_Scene.cpp

@@ -65,12 +65,12 @@ void ASRegisterManualLast_Scene(asIScriptEngine* engine)
 {
 #ifdef URHO3D_PHYSICS
     // template<class T> T * Node::GetComponent(bool recursive=false) const | File: ../Scene/Node.h
-    engine->RegisterObjectMethod("Scene", "PhysicsWorld@+ get_physicsWorld() const", asFUNCTION(SceneGetPhysicsWorld), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Scene", "PhysicsWorld@+ get_physicsWorld() const", AS_FUNCTION_OBJLAST(SceneGetPhysicsWorld), AS_CALL_CDECL_OBJLAST);
 #endif
 
 #ifdef URHO3D_URHO2D
     // template<class T> T * Node::GetComponent(bool recursive=false) const | File: ../Scene/Node.h
-    engine->RegisterObjectMethod("Scene", "PhysicsWorld2D@+ get_physicsWorld2D() const", asFUNCTION(SceneGetPhysicsWorld2D), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Scene", "PhysicsWorld2D@+ get_physicsWorld2D() const", AS_FUNCTION_OBJLAST(SceneGetPhysicsWorld2D), AS_CALL_CDECL_OBJLAST);
 #endif
 }
 

Source/Urho3D/AngelScript/Manual_Scene.h

@@ -40,7 +40,7 @@ namespace Urho3D
 const AttributeInfo& SerializableGetAttributeInfo(unsigned index, Serializable* ptr);
 
 #define REGISTER_MANUAL_PART_Serializable(T, className) \
-    engine->RegisterObjectMethod(className, "const AttributeInfo& get_attributeInfos(uint) const", asFUNCTION(SerializableGetAttributeInfo), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "const AttributeInfo& get_attributeInfos(uint) const", AS_FUNCTION_OBJLAST(SerializableGetAttributeInfo), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -76,44 +76,44 @@ Component* NodeGetComponent(unsigned index, Node* ptr);
 #define REGISTER_MANUAL_PART_Node(T, className) \
     RegisterNamedObjectConstructor<T>(engine, className); \
     /* bool Node::SaveXML(Serializer &dest, const String &indentation="\t") const | File: ../Scene/Node.h */ \
-    engine->RegisterObjectMethod(className, "bool SaveXML(File@+, const String&in indentation = \"\t\")", asFUNCTION(NodeSaveXML), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool SaveXML(File@+, const String&in indentation = \"\t\")", AS_FUNCTION_OBJLAST(NodeSaveXML), AS_CALL_CDECL_OBJLAST); \
     /* bool Node::SaveXML(Serializer &dest, const String &indentation="\t") const | File: ../Scene/Node.h */ \
-    engine->RegisterObjectMethod(className, "bool SaveXML(VectorBuffer&, const String&in indentation = \"\t\")", asFUNCTION(NodeSaveXMLVectorBuffer), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool SaveXML(VectorBuffer&, const String&in indentation = \"\t\")", AS_FUNCTION_OBJLAST(NodeSaveXMLVectorBuffer), AS_CALL_CDECL_OBJLAST); \
     /* bool Node::SaveJSON(Serializer &dest, const String &indentation="\t") const | File: ../Scene/Node.h */ \
-    engine->RegisterObjectMethod(className, "bool SaveJSON(File@+)", asFUNCTION(NodeSaveJSON), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool SaveJSON(File@+)", AS_FUNCTION_OBJLAST(NodeSaveJSON), AS_CALL_CDECL_OBJLAST); \
     /* bool Node::SaveJSON(Serializer &dest, const String &indentation="\t") const | File: ../Scene/Node.h */ \
-    engine->RegisterObjectMethod(className, "bool SaveJSON(VectorBuffer&)", asFUNCTION(NodeSaveJSONVectorBuffer), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool SaveJSON(VectorBuffer&)", AS_FUNCTION_OBJLAST(NodeSaveJSONVectorBuffer), AS_CALL_CDECL_OBJLAST); \
     /* template<class T> void Node::GetChildrenWithComponent(PODVector< Node * > &dest, bool recursive=false) const | File: ../Scene/Node.h */ \
-    engine->RegisterObjectMethod(className, "Array<Node@>@ GetChildrenWithScript(bool recursive = false) const", asFUNCTION(NodeGetChildrenWithScript), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Array<Node@>@ GetChildrenWithScript(bool recursive = false) const", AS_FUNCTION_OBJLAST(NodeGetChildrenWithScript), AS_CALL_CDECL_OBJLAST); \
     /* template<class T> void Node::GetChildrenWithComponent(PODVector< Node * > &dest, bool recursive=false) const | File: ../Scene/Node.h */ \
-    engine->RegisterObjectMethod(className, "Array<Node@>@ GetChildrenWithScript(const String&in, bool recursive = false) const", asFUNCTION(NodeGetChildrenWithClassName), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Array<Node@>@ GetChildrenWithScript(const String&in, bool recursive = false) const", AS_FUNCTION_OBJLAST(NodeGetChildrenWithClassName), AS_CALL_CDECL_OBJLAST); \
     /* void Node::GetComponents(PODVector< Component * > &dest, StringHash type, bool recursive=false) const | File: ../Scene/Node.h */ \
-    engine->RegisterObjectMethod(className, "Array<Component@>@ GetComponents(const String&in, bool recursive = false) const", asFUNCTION(NodeGetComponentsWithType), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Array<Component@>@ GetComponents(const String&in, bool recursive = false) const", AS_FUNCTION_OBJLAST(NodeGetComponentsWithType), AS_CALL_CDECL_OBJLAST); \
     /* unsigned Node::GetNumChildren(bool recursive=false) const | File: ../Scene/Node.h */ \
-    engine->RegisterObjectMethod(className, "uint get_numChildren() const", asFUNCTION(NodeGetNumChildrenNonRecursive), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "uint get_numChildren() const", AS_FUNCTION_OBJLAST(NodeGetNumChildrenNonRecursive), AS_CALL_CDECL_OBJLAST); \
     /* unsigned Node::GetNumChildren(bool recursive=false) const | File: ../Scene/Node.h */ \
-    engine->RegisterObjectMethod(className, "uint get_numAllChildren() const", asFUNCTION(NodeGetNumChildrenRecursive), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "uint get_numAllChildren() const", AS_FUNCTION_OBJLAST(NodeGetNumChildrenRecursive), AS_CALL_CDECL_OBJLAST); \
     /* Node* Node::GetChild(unsigned index) const | File: ../Scene/Node.h */ \
-    engine->RegisterObjectMethod(className, "Node@+ get_children(uint) const", asFUNCTION(NodeGetChild), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Node@+ get_children(uint) const", AS_FUNCTION_OBJLAST(NodeGetChild), AS_CALL_CDECL_OBJLAST); \
     /* Node* Node::GetChild(const String &name, bool recursive=false) const | File: ../Scene/Node.h */ \
-    engine->RegisterObjectMethod(className, "Node@+ get_childrenByName(const String&in) const", asFUNCTION(NodeGetChildByName), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Node@+ get_childrenByName(const String&in) const", AS_FUNCTION_OBJLAST(NodeGetChildByName), AS_CALL_CDECL_OBJLAST); \
     /* Node* Node::GetChild(const String &name, bool recursive=false) const | File: ../Scene/Node.h */ \
-    engine->RegisterObjectMethod(className, "Node@+ get_allChildrenByName(const String&in) const", asFUNCTION(NodeGetChildByNameRecursive), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Node@+ get_allChildrenByName(const String&in) const", AS_FUNCTION_OBJLAST(NodeGetChildByNameRecursive), AS_CALL_CDECL_OBJLAST); \
     /* const Vector<SharedPtr<Component> >& Node::GetComponents() const | File: ../Scene/Node.h */ \
-    engine->RegisterObjectMethod(className, "Component@+ get_components(uint) const", asFUNCTION(NodeGetComponent), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Component@+ get_components(uint) const", AS_FUNCTION_OBJLAST(NodeGetComponent), AS_CALL_CDECL_OBJLAST); \
     /* const VariantMap& Node::GetVars() const | File: ../Scene/Node.h */ \
-    engine->RegisterObjectMethod(className, "VariantMap& get_vars()", asFUNCTION(NodeGetVars), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "VariantMap& get_vars()", AS_FUNCTION_OBJLAST(NodeGetVars), AS_CALL_CDECL_OBJLAST); \
     /* Workarounds for Connection that used outside URHO3D_NETWORK define */ \
     if (URHO3D_NETWORK_DEFINED) \
     { \
         /* void Node::SetOwner(Connection* owner) | File: ../Scene/Node.h */ \
-        engine->RegisterObjectMethod(className, "void SetOwner(Connection@+)", asMETHODPR(T, SetOwner, (Connection*), void), asCALL_THISCALL); \
-        engine->RegisterObjectMethod(className, "void set_owner(Connection@+)", asMETHODPR(T, SetOwner, (Connection*), void), asCALL_THISCALL); \
+        engine->RegisterObjectMethod(className, "void SetOwner(Connection@+)", AS_METHOD(T, SetOwner), AS_CALL_THISCALL); \
+        engine->RegisterObjectMethod(className, "void set_owner(Connection@+)", AS_METHOD(T, SetOwner), AS_CALL_THISCALL); \
         /* Connection* Node::GetOwner() const | File: ../Scene/Node.h */ \
-        engine->RegisterObjectMethod(className, "Connection@+ GetOwner() const", asMETHODPR(T, GetOwner, () const, Connection*), asCALL_THISCALL); \
-        engine->RegisterObjectMethod(className, "Connection@+ get_owner() const", asMETHODPR(T, GetOwner, () const, Connection*), asCALL_THISCALL); \
+        engine->RegisterObjectMethod(className, "Connection@+ GetOwner() const", AS_METHOD(T, GetOwner), AS_CALL_THISCALL); \
+        engine->RegisterObjectMethod(className, "Connection@+ get_owner() const", AS_METHOD(T, GetOwner), AS_CALL_THISCALL); \
         /* void Node::CleanupConnection(Connection* connection) | File: ../Scene/Node.h */ \
-        engine->RegisterObjectMethod(className, "void CleanupConnection(Connection@+)", asMETHODPR(T, CleanupConnection, (Connection*), void), asCALL_THISCALL); \
+        engine->RegisterObjectMethod(className, "void CleanupConnection(Connection@+)", AS_METHOD(T, CleanupConnection), AS_CALL_THISCALL); \
     }
 
 // ========================================================================================
@@ -151,44 +151,44 @@ Octree* SceneGetOctree(Scene* ptr);
 
 #define REGISTER_MANUAL_PART_Scene(T, className) \
     /* bool Scene::LoadXML(Deserializer &source) | File: ../Scene/Scene.h */ \
-    engine->RegisterObjectMethod(className, "bool LoadXML(File@+)", asFUNCTION(SceneLoadXML), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool LoadXML(File@+)", AS_FUNCTION_OBJLAST(SceneLoadXML), AS_CALL_CDECL_OBJLAST); \
     /* bool Scene::LoadXML(Deserializer &source) | File: ../Scene/Scene.h */ \
-    engine->RegisterObjectMethod(className, "bool LoadXML(VectorBuffer&)", asFUNCTION(SceneLoadXMLVectorBuffer), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool LoadXML(VectorBuffer&)", AS_FUNCTION_OBJLAST(SceneLoadXMLVectorBuffer), AS_CALL_CDECL_OBJLAST); \
     /* bool Scene::LoadJSON(Deserializer &source) | File: ../Scene/Scene.h */ \
-    engine->RegisterObjectMethod(className, "bool LoadJSON(File@+)", asFUNCTION(SceneLoadJSON), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool LoadJSON(File@+)", AS_FUNCTION_OBJLAST(SceneLoadJSON), AS_CALL_CDECL_OBJLAST); \
     /* bool Scene::LoadJSON(Deserializer &source) | File: ../Scene/Scene.h */ \
-    engine->RegisterObjectMethod(className, "bool LoadJSON(VectorBuffer&)", asFUNCTION(SceneLoadJSONVectorBuffer), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool LoadJSON(VectorBuffer&)", AS_FUNCTION_OBJLAST(SceneLoadJSONVectorBuffer), AS_CALL_CDECL_OBJLAST); \
     /* Node* Scene::Instantiate(Deserializer &source, const Vector3 &position, const Quaternion &rotation, CreateMode mode=REPLICATED) | File: ../Scene/Scene.h */ \
-    engine->RegisterObjectMethod(className, "Node@+ Instantiate(File@+, const Vector3&in, const Quaternion&in, CreateMode mode = REPLICATED)", asFUNCTION(SceneInstantiate), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Node@+ Instantiate(File@+, const Vector3&in, const Quaternion&in, CreateMode mode = REPLICATED)", AS_FUNCTION_OBJLAST(SceneInstantiate), AS_CALL_CDECL_OBJLAST); \
     /* Node* Scene::Instantiate(Deserializer &source, const Vector3 &position, const Quaternion &rotation, CreateMode mode=REPLICATED) | File: ../Scene/Scene.h */ \
     /* Node* Scene::InstantiateXML(Deserializer &source, const Vector3 &position, const Quaternion &rotation, CreateMode mode=REPLICATED) | File: ../Scene/Scene.h */ \
-    engine->RegisterObjectMethod(className, "Node@+ Instantiate(VectorBuffer&, const Vector3&in, const Quaternion&in, CreateMode mode = REPLICATED)", asFUNCTION(SceneInstantiateVectorBuffer), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Node@+ Instantiate(VectorBuffer&, const Vector3&in, const Quaternion&in, CreateMode mode = REPLICATED)", AS_FUNCTION_OBJLAST(SceneInstantiateVectorBuffer), AS_CALL_CDECL_OBJLAST); \
     /* Node* Scene::InstantiateXML(Deserializer &source, const Vector3 &position, const Quaternion &rotation, CreateMode mode=REPLICATED) | File: ../Scene/Scene.h */ \
-    engine->RegisterObjectMethod(className, "Node@+ InstantiateXML(File@+, const Vector3&in, const Quaternion&in, CreateMode mode = REPLICATED)", asFUNCTION(SceneInstantiateXML), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Node@+ InstantiateXML(File@+, const Vector3&in, const Quaternion&in, CreateMode mode = REPLICATED)", AS_FUNCTION_OBJLAST(SceneInstantiateXML), AS_CALL_CDECL_OBJLAST); \
     /* Node* Scene::InstantiateXML(Deserializer &source, const Vector3 &position, const Quaternion &rotation, CreateMode mode=REPLICATED) | File: ../Scene/Scene.h */ \
-    engine->RegisterObjectMethod(className, "Node@+ InstantiateXML(VectorBuffer&, const Vector3&in, const Quaternion&in, CreateMode mode = REPLICATED)", asFUNCTION(SceneInstantiateXMLVectorBuffer), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Node@+ InstantiateXML(VectorBuffer&, const Vector3&in, const Quaternion&in, CreateMode mode = REPLICATED)", AS_FUNCTION_OBJLAST(SceneInstantiateXMLVectorBuffer), AS_CALL_CDECL_OBJLAST); \
     /* Node* Scene::InstantiateXML(Deserializer &source, const Vector3 &position, const Quaternion &rotation, CreateMode mode=REPLICATED) | File: ../Scene/Scene.h */ \
-    engine->RegisterObjectMethod(className, "Node@+ InstantiateXML(XMLFile@+, const Vector3&in, const Quaternion&in, CreateMode mode = REPLICATED)", asFUNCTION(SceneInstantiateXMLFile), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Node@+ InstantiateXML(XMLFile@+, const Vector3&in, const Quaternion&in, CreateMode mode = REPLICATED)", AS_FUNCTION_OBJLAST(SceneInstantiateXMLFile), AS_CALL_CDECL_OBJLAST); \
     /* Node* Scene::InstantiateJSON(Deserializer &source, const Vector3 &position, const Quaternion &rotation, CreateMode mode=REPLICATED) | File: ../Scene/Scene.h */ \
-    engine->RegisterObjectMethod(className, "Node@+ InstantiateJSON(File@+, const Vector3&in, const Quaternion&in, CreateMode mode = REPLICATED)", asFUNCTION(SceneInstantiateJSON), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Node@+ InstantiateJSON(File@+, const Vector3&in, const Quaternion&in, CreateMode mode = REPLICATED)", AS_FUNCTION_OBJLAST(SceneInstantiateJSON), AS_CALL_CDECL_OBJLAST); \
     /* Node* Scene::InstantiateJSON(Deserializer &source, const Vector3 &position, const Quaternion &rotation, CreateMode mode=REPLICATED) | File: ../Scene/Scene.h */ \
-    engine->RegisterObjectMethod(className, "Node@+ InstantiateJSON(VectorBuffer&, const Vector3&in, const Quaternion&in, CreateMode mode = REPLICATED)", asFUNCTION(SceneInstantiateJSONVectorBuffer), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Node@+ InstantiateJSON(VectorBuffer&, const Vector3&in, const Quaternion&in, CreateMode mode = REPLICATED)", AS_FUNCTION_OBJLAST(SceneInstantiateJSONVectorBuffer), AS_CALL_CDECL_OBJLAST); \
     /* Node* Scene::InstantiateJSON(Deserializer &source, const Vector3 &position, const Quaternion &rotation, CreateMode mode=REPLICATED) | File: ../Scene/Scene.h */ \
-    engine->RegisterObjectMethod(className, "Node@+ InstantiateJSON(JSONFile@+, const Vector3&in, const Quaternion&in, CreateMode mode = REPLICATED)", asFUNCTION(SceneInstantiateJSONFile), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Node@+ InstantiateJSON(JSONFile@+, const Vector3&in, const Quaternion&in, CreateMode mode = REPLICATED)", AS_FUNCTION_OBJLAST(SceneInstantiateJSONFile), AS_CALL_CDECL_OBJLAST); \
     /* bool Scene::GetNodesWithTag(PODVector< Node * > &dest, const String &tag) const | File: ../Scene/Scene.h */ \
-    engine->RegisterObjectMethod(className, "Array<Node@>@ GetNodesWithTag(const String&in) const", asFUNCTION(SceneGetNodesWithTag), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Array<Node@>@ GetNodesWithTag(const String&in) const", AS_FUNCTION_OBJLAST(SceneGetNodesWithTag), AS_CALL_CDECL_OBJLAST); \
     /* Component* Node::GetComponent(StringHash type, bool recursive=false) const | File: ../Scene/Scene.h */ \
     /* Workaround Doxygen bug: have no const flag in xml */ \
-    engine->RegisterObjectMethod(className, "Component@+ GetComponent(StringHash, bool = false) const", asMETHODPR(T, GetComponent, (StringHash, bool) const, Component*), asCALL_THISCALL); \
+    engine->RegisterObjectMethod(className, "Component@+ GetComponent(StringHash, bool = false) const", AS_METHODPR(Scene, GetComponent, (StringHash, bool) const, Component*), AS_CALL_THISCALL); \
     /* bool Node::SaveXML(XMLElement &dest) const override | File: ../Scene/Scene.h */ \
     /* Workaround Doxygen bug: have no const flag in xml */ \
-    engine->RegisterObjectMethod(className, "bool SaveXML(XMLElement&) const", asMETHODPR(T, SaveXML, (XMLElement &) const, bool), asCALL_THISCALL); \
+    engine->RegisterObjectMethod(className, "bool SaveXML(XMLElement&) const", AS_METHODPR(Scene, SaveXML, (XMLElement &) const, bool), AS_CALL_THISCALL); \
     /* bool Node::SaveJSON(JSONValue &dest) const override | File: ../Scene/Scene.h */\
     /* Workaround Doxygen bug: have no const flag in xml */ \
-    engine->RegisterObjectMethod(className, "bool SaveJSON(JSONValue&) const", asMETHODPR(T, SaveJSON, (JSONValue &) const, bool), asCALL_THISCALL); \
+    engine->RegisterObjectMethod(className, "bool SaveJSON(JSONValue&) const", AS_METHODPR(Scene, SaveJSON, (JSONValue &) const, bool), AS_CALL_THISCALL); \
     /* template<class T> T * Node::GetComponent(bool recursive=false) const | File: ../Scene/Node.h */ \
-    engine->RegisterObjectMethod(className, "DebugRenderer@+ get_debugRenderer() const", asFUNCTION(SceneGetDebugRenderer), asCALL_CDECL_OBJLAST); \
-    engine->RegisterObjectMethod(className, "Octree@+ get_octree() const", asFUNCTION(SceneGetOctree), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "DebugRenderer@+ get_debugRenderer() const", AS_FUNCTION_OBJLAST(SceneGetDebugRenderer), AS_CALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Octree@+ get_octree() const", AS_FUNCTION_OBJLAST(SceneGetOctree), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -199,9 +199,9 @@ void BoneSetNode(Node* node, Bone* ptr);
 
 #define REGISTER_MANUAL_PART_Bone(T, className) \
     /* WeakPtr<Node> Bone::node_ | File: ../Graphics/Skeleton.h */ \
-    engine->RegisterObjectMethod(className, "void set_node(Node@+)", asFUNCTION(BoneSetNode), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "void set_node(Node@+)", AS_FUNCTION_OBJLAST(BoneSetNode), AS_CALL_CDECL_OBJLAST); \
     /* WeakPtr<Node> Bone::node_ | File: ../Graphics/Skeleton.h */ \
-    engine->RegisterObjectMethod(className, "Node@+ get_node() const", asFUNCTION(BoneGetNode), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "Node@+ get_node() const", AS_FUNCTION_OBJLAST(BoneGetNode), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -210,7 +210,7 @@ void BoneSetNode(Node* node, Bone* ptr);
     if (URHO3D_NETWORK_DEFINED) \
     { \
         /* void Component::CleanupConnection(Connection* connection) | File: ../Scene/Component.h */ \
-        engine->RegisterObjectMethod(className, "void CleanupConnection(Connection@+)", asMETHODPR(T, CleanupConnection, (Connection*), void), asCALL_THISCALL); \
+        engine->RegisterObjectMethod(className, "void CleanupConnection(Connection@+)", AS_METHODPR(T, CleanupConnection, (Connection*), void), AS_CALL_THISCALL); \
     }
 
 }

Source/Urho3D/AngelScript/Manual_UI.cpp

@@ -45,7 +45,7 @@ static UI* GetUI()
 void ASRegisterManualLast_UI(asIScriptEngine* engine)
 {
     // template<class T> T * Object::GetSubsystem() const | File: ../Core/Object.h
-    engine->RegisterGlobalFunction("UI@+ get_ui()", asFUNCTION(GetUI), asCALL_CDECL);
+    engine->RegisterGlobalFunction("UI@+ get_ui()", AS_FUNCTION(GetUI), AS_CALL_CDECL);
 }
 
 // ========================================================================================

Source/Urho3D/AngelScript/Manual_UI.h

@@ -40,11 +40,11 @@ bool FontSaveXMLFile(File* file, int pointSize, bool usedGlyphs, const String& i
 
 #define REGISTER_MANUAL_PART_Font(T, className) \
     /* bool Font::SaveXML(Serializer &dest, int pointSize, bool usedGlyphs=false, const String &indentation="\t") | File: ../UI/Font.h */ \
-    engine->RegisterObjectMethod(className, "bool SaveXML(File@+, int, bool usedGlyphs = false, const String&in indentation = \"\t\")", asFUNCTION(FontSaveXMLFile), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool SaveXML(File@+, int, bool usedGlyphs = false, const String&in indentation = \"\t\")", AS_FUNCTION_OBJLAST(FontSaveXMLFile), AS_CALL_CDECL_OBJLAST); \
     /* bool Font::SaveXML(Serializer &dest, int pointSize, bool usedGlyphs=false, const String &indentation="\t") | File: ../UI/Font.h */ \
-    engine->RegisterObjectMethod(className, "bool SaveXML(VectorBuffer&, int, bool usedGlyphs = false, const String&in indentation = \"\t\")", asFUNCTION(FontSaveXMLVectorBuffer), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool SaveXML(VectorBuffer&, int, bool usedGlyphs = false, const String&in indentation = \"\t\")", AS_FUNCTION_OBJLAST(FontSaveXMLVectorBuffer), AS_CALL_CDECL_OBJLAST); \
     /* bool Font::SaveXML(Serializer &dest, int pointSize, bool usedGlyphs=false, const String &indentation="\t") | File: ../UI/Font.h */ \
-    engine->RegisterObjectMethod(className, "bool SaveXML(const String&in, int, bool usedGlyphs = false, const String&in indentation = \"\t\")", asFUNCTION(FontSaveXML), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "bool SaveXML(const String&in, int, bool usedGlyphs = false, const String&in indentation = \"\t\")", AS_FUNCTION_OBJLAST(FontSaveXML), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -80,31 +80,31 @@ VariantMap& UIElementGetVars(UIElement* ptr);
 #define REGISTER_MANUAL_PART_UIElement(T, className) \
     RegisterNamedObjectConstructor<T>(engine, className); \
     /* bool UIElement::LoadXML(Deserializer &source) | File: ../UI/UIElement.h */ \
-    /*engine->RegisterObjectMethod(className, "bool LoadXML(File@+)", asFUNCTIONPR(UIElementLoadXML, (File*, UIElement*), bool), asCALL_CDECL_OBJLAST); */\
+    /*engine->RegisterObjectMethod(className, "bool LoadXML(File@+)", AS_FUNCTION_OBJLAST(UIElementLoadXML), AS_CALL_CDECL_OBJLAST); */\
     /* bool UIElement::LoadXML(Deserializer &source) | File: ../UI/UIElement.h */ \
-    engine->RegisterObjectMethod(className, "bool LoadXML(VectorBuffer&)", asFUNCTIONPR(UIElementLoadXMLVectorBuffer, (VectorBuffer&, UIElement*), bool), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool LoadXML(VectorBuffer&)", AS_FUNCTION_OBJLAST(UIElementLoadXMLVectorBuffer), AS_CALL_CDECL_OBJLAST); \
     /* bool UIElement::LoadXML(Deserializer &source) | File: ../UI/UIElement.h */ \
-    /*engine->RegisterObjectMethod(className, "bool LoadXML(XMLFile@+, XMLFile@+)", asFUNCTIONPR(UIElementLoadXML, (XMLFile*, XMLFile*, UIElement*), bool), asCALL_CDECL_OBJLAST); */\
+    /*engine->RegisterObjectMethod(className, "bool LoadXML(XMLFile@+, XMLFile@+)", AS_FUNCTION_OBJLAST(UIElementLoadXML), AS_CALL_CDECL_OBJLAST); */\
     /* virtual UIElement* UIElement::LoadChildXML(const XMLElement &childElem, XMLFile *styleFile) | File: ../UI/UIElement.h */ \
-    engine->RegisterObjectMethod(className, "UIElement@+ LoadChildXML(XMLFile@+, XMLFile@+)", asFUNCTION(UIElementLoadChildXML), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "UIElement@+ LoadChildXML(XMLFile@+, XMLFile@+)", AS_FUNCTION_OBJLAST(UIElementLoadChildXML), AS_CALL_CDECL_OBJLAST); \
     /* bool UIElement::SaveXML(Serializer &dest, const String &indentation="\t") const | File: ../UI/UIElement.h */ \
-    /*engine->RegisterObjectMethod(className, "bool SaveXML(File@+, const String&in indentation = \"\t\")", asFUNCTION(UIElementSaveXML), asCALL_CDECL_OBJLAST); */\
+    /*engine->RegisterObjectMethod(className, "bool SaveXML(File@+, const String&in indentation = \"\t\")", AS_FUNCTION_OBJLAST(UIElementSaveXML), AS_CALL_CDECL_OBJLAST); */\
     /* bool UIElement::SaveXML(Serializer &dest, const String &indentation="\t") const | File: ../UI/UIElement.h */ \
-    engine->RegisterObjectMethod(className, "bool SaveXML(VectorBuffer&, const String&in indentation = \"\t\")", asFUNCTION(UIElementSaveXMLVectorBuffer), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool SaveXML(VectorBuffer&, const String&in indentation = \"\t\")", AS_FUNCTION_OBJLAST(UIElementSaveXMLVectorBuffer), AS_CALL_CDECL_OBJLAST); \
     /* void UIElement::RemoveChildAtIndex(unsigned index) | File: ../UI/UIElement.h */ \
-    engine->RegisterObjectMethod(className, "void RemoveChild(uint)", asFUNCTIONPR(UIElementRemoveChild, (unsigned, UIElement*), void), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "void RemoveChild(uint)", AS_FUNCTION_OBJLAST(UIElementRemoveChild), AS_CALL_CDECL_OBJLAST); \
     /* bool UIElement::SetStyle(const String &styleName, XMLFile *file=nullptr) | File: ../UI/UIElement.h */ \
-    engine->RegisterObjectMethod(className, "void set_style(const String&in)", asFUNCTION(UIElementSetStyle), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "void set_style(const String&in)", AS_FUNCTION_OBJLAST(UIElementSetStyle), AS_CALL_CDECL_OBJLAST); \
     /* unsigned UIElement::GetNumChildren(bool recursive=false) const | File: ../UI/UIElement.h */ \
-    engine->RegisterObjectMethod(className, "uint get_numChildren() const", asFUNCTION(UIElementGetNumChildrenNonRecursive), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "uint get_numChildren() const", AS_FUNCTION_OBJLAST(UIElementGetNumChildrenNonRecursive), AS_CALL_CDECL_OBJLAST); \
     /* unsigned UIElement::GetNumChildren(bool recursive=false) const | File: ../UI/UIElement.h */ \
-    engine->RegisterObjectMethod(className, "uint get_numAllChildren() const", asFUNCTION(UIElementGetNumChildrenRecursive), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "uint get_numAllChildren() const", AS_FUNCTION_OBJLAST(UIElementGetNumChildrenRecursive), AS_CALL_CDECL_OBJLAST); \
     /* void UIElement::SetParent(UIElement *parent, unsigned index=M_MAX_UNSIGNED) | File: ../UI/UIElement.h */ \
-    engine->RegisterObjectMethod(className, "void set_parent(UIElement@+)", asFUNCTION(UIElementSetParent), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "void set_parent(UIElement@+)", AS_FUNCTION_OBJLAST(UIElementSetParent), AS_CALL_CDECL_OBJLAST); \
     /* XMLFile* UIElement::GetDefaultStyle(bool recursiveUp=true) const | File: ../UI/UIElement.h */ \
-    engine->RegisterObjectMethod(className, "XMLFile@+ get_defaultStyle() const", asFUNCTION(UIElementGetDefaultStyle), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "XMLFile@+ get_defaultStyle() const", AS_FUNCTION_OBJLAST(UIElementGetDefaultStyle), AS_CALL_CDECL_OBJLAST); \
     /* const VariantMap& UIElement::GetVars() const | File: ../UI/UIElement.h */ \
-    engine->RegisterObjectMethod(className, "VariantMap& get_vars()", asFUNCTION(UIElementGetVars), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "VariantMap& get_vars()", AS_FUNCTION_OBJLAST(UIElementGetVars), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -127,20 +127,20 @@ void UISetFocusElement(UIElement* element, UI* ptr);
 
 #define REGISTER_MANUAL_PART_UI(T, className) \
     /* SharedPtr<UIElement> UI::LoadLayout(Deserializer &source, XMLFile *styleFile=nullptr) | File: ../UI/UI.h */ \
-    engine->RegisterObjectMethod(className, "UIElement@ LoadLayout(File@+)", asFUNCTION(UILoadLayoutFromFile), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "UIElement@ LoadLayout(File@+)", AS_FUNCTION_OBJLAST(UILoadLayoutFromFile), AS_CALL_CDECL_OBJLAST); \
     /* SharedPtr<UIElement> UI::LoadLayout(Deserializer &source, XMLFile *styleFile=nullptr) | File: ../UI/UI.h */ \
-    engine->RegisterObjectMethod(className, "UIElement@ LoadLayout(File@+, XMLFile@+)", asFUNCTION(UILoadLayoutFromFileWithStyle), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "UIElement@ LoadLayout(File@+, XMLFile@+)", AS_FUNCTION_OBJLAST(UILoadLayoutFromFileWithStyle), AS_CALL_CDECL_OBJLAST); \
     /* SharedPtr<UIElement> UI::LoadLayout(Deserializer &source, XMLFile *styleFile=nullptr) | File: ../UI/UI.h */ \
-    engine->RegisterObjectMethod(className, "UIElement@ LoadLayout(VectorBuffer&)", asFUNCTION(UILoadLayoutFromVectorBuffer), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "UIElement@ LoadLayout(VectorBuffer&)", AS_FUNCTION_OBJLAST(UILoadLayoutFromVectorBuffer), AS_CALL_CDECL_OBJLAST); \
     /* SharedPtr<UIElement> UI::LoadLayout(Deserializer &source, XMLFile *styleFile=nullptr) | File: ../UI/UI.h */ \
-    engine->RegisterObjectMethod(className, "UIElement@ LoadLayout(VectorBuffer&, XMLFile@+)", asFUNCTION(UILoadLayoutFromVectorBufferWithStyle), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "UIElement@ LoadLayout(VectorBuffer&, XMLFile@+)", AS_FUNCTION_OBJLAST(UILoadLayoutFromVectorBufferWithStyle), AS_CALL_CDECL_OBJLAST); \
     /* bool UI::SaveLayout(Serializer &dest, UIElement *element) | File: ../UI/UI.h */ \
-    engine->RegisterObjectMethod(className, "bool SaveLayout(File@+, UIElement@+)", asFUNCTION(UISaveLayout), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool SaveLayout(File@+, UIElement@+)", AS_FUNCTION_OBJLAST(UISaveLayout), AS_CALL_CDECL_OBJLAST); \
     /* bool UI::SaveLayout(Serializer &dest, UIElement *element) | File: ../UI/UI.h */ \
-    engine->RegisterObjectMethod(className, "bool SaveLayout(VectorBuffer&, UIElement@+)", asFUNCTION(UISaveLayoutVectorBuffer), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "bool SaveLayout(VectorBuffer&, UIElement@+)", AS_FUNCTION_OBJLAST(UISaveLayoutVectorBuffer), AS_CALL_CDECL_OBJLAST); \
     /* const Vector<UIElement*> UI::GetDragElements() | File: ../UI/UI.h */ \
-    engine->RegisterObjectMethod(className, "const Array<UIElement@>@ GetDragElements()", asFUNCTION(UIGetDragElements), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "const Array<UIElement@>@ GetDragElements()", AS_FUNCTION_OBJLAST(UIGetDragElements), AS_CALL_CDECL_OBJLAST); \
     /* void UI::SetFocusElement(UIElement *element, bool byKey=false) | File: ../UI/UI.h */ \
-    engine->RegisterObjectMethod(className, "void set_focusElement(UIElement@+)", asFUNCTION(UISetFocusElement), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "void set_focusElement(UIElement@+)", AS_FUNCTION_OBJLAST(UISetFocusElement), AS_CALL_CDECL_OBJLAST);
 
 }

Source/Urho3D/AngelScript/Manual_Urho2D.cpp

@@ -50,7 +50,7 @@ static PhysicsWorld2D* GetPhysicsWorld2D()
 void ASRegisterManualLast_Urho2D(asIScriptEngine* engine)
 {
     // template<class T> T * Node::GetComponent(bool recursive=false) const | File: ../Scene/Node.h
-    engine->RegisterGlobalFunction("PhysicsWorld2D@+ get_physicsWorld2D()", asFUNCTION(GetPhysicsWorld2D), asCALL_CDECL);
+    engine->RegisterGlobalFunction("PhysicsWorld2D@+ get_physicsWorld2D()", AS_FUNCTION(GetPhysicsWorld2D), AS_CALL_CDECL);
 }
 
 // ========================================================================================

Source/Urho3D/AngelScript/Manual_Urho2D.h

@@ -39,7 +39,7 @@ RigidBody2D* PhysicsRaycastResultGetRigidBody2D(PhysicsRaycastResult2D* ptr);
 
 #define REGISTER_MANUAL_PART_PhysicsRaycastResult2D(T, className) \
     /* RigidBody2D* PhysicsRaycastResult2D::body_ | File: ../Urho2D/PhysicsWorld2D.h */ \
-    engine->RegisterObjectMethod(className, "RigidBody2D@+ get_body() const", asFUNCTION(PhysicsRaycastResultGetRigidBody2D), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "RigidBody2D@+ get_body() const", AS_FUNCTION_OBJLAST(PhysicsRaycastResultGetRigidBody2D), AS_CALL_CDECL_OBJLAST);
 
 // ========================================================================================
 
@@ -52,11 +52,11 @@ CScriptArray* PhysicsWorld2DGetRigidBodies(const Rect& aabb, unsigned collisionM
 
 #define REGISTER_MANUAL_PART_PhysicsWorld2D(T, className) \
     /* void PhysicsWorld2D::Raycast(PODVector< PhysicsRaycastResult2D > &results, const Vector2 &startPoint, const Vector2 &endPoint, unsigned collisionMask=M_MAX_UNSIGNED) | File: ../Urho2D/PhysicsWorld2D.h */ \
-    engine->RegisterObjectMethod(className, "Array<PhysicsRaycastResult2D>@ Raycast(const Vector2&, const Vector2&, uint collisionMask = 0xffff)", asFUNCTION(PhysicsWorld2DRaycast), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "Array<PhysicsRaycastResult2D>@ Raycast(const Vector2&, const Vector2&, uint collisionMask = 0xffff)", AS_FUNCTION_OBJLAST(PhysicsWorld2DRaycast), AS_CALL_CDECL_OBJLAST); \
     /* void PhysicsWorld2D::RaycastSingle(PhysicsRaycastResult2D &result, const Vector2 &startPoint, const Vector2 &endPoint, unsigned collisionMask=M_MAX_UNSIGNED) | File: ../Urho2D/PhysicsWorld2D.h */ \
-    engine->RegisterObjectMethod(className, "PhysicsRaycastResult2D RaycastSingle(const Vector2&, const Vector2&, uint collisionMask = 0xffff)", asFUNCTION(PhysicsWorld2DRaycastSingle), asCALL_CDECL_OBJLAST); \
+    engine->RegisterObjectMethod(className, "PhysicsRaycastResult2D RaycastSingle(const Vector2&, const Vector2&, uint collisionMask = 0xffff)", AS_FUNCTION_OBJLAST(PhysicsWorld2DRaycastSingle), AS_CALL_CDECL_OBJLAST); \
     /* void PhysicsWorld2D::GetRigidBodies(PODVector< RigidBody2D * > &results, const Rect &aabb, unsigned collisionMask=M_MAX_UNSIGNED) | File: ../Urho2D/PhysicsWorld2D.h */ \
-    engine->RegisterObjectMethod(className, "Array<RigidBody2D@>@ GetRigidBodies(const Rect&in, uint collisionMask = 0xffff)", asFUNCTION(PhysicsWorld2DGetRigidBodies), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod(className, "Array<RigidBody2D@>@ GetRigidBodies(const Rect&in, uint collisionMask = 0xffff)", AS_FUNCTION_OBJLAST(PhysicsWorld2DGetRigidBodies), AS_CALL_CDECL_OBJLAST);
 
 }
 

Source/Urho3D/AngelScript/RegistrationMacros.h

@@ -0,0 +1,100 @@
+//
+// Copyright (c) 2008-2020 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
+
+#ifdef AS_MAX_PORTABILITY
+#include "../AngelScript/aswrappedcall.h"
+#endif
+
+namespace Urho3D
+{
+
+// f - function
+// c - class
+// m - method
+// p - parameters
+// r - return type
+// PR - parameters, return type
+
+// RegisterGlobalFunction(decl, AS_FUNCTION(f), AS_CALL_CDECL)
+// RegisterGlobalFunction(decl, AS_FUNCTIONPR(f, p, r), AS_CALL_CDECL)
+// RegisterObjectBehaviour(obj, asBEHAVE_FACTORY, decl, AS_FUNCTION(f), AS_CALL_CDECL);
+#ifdef AS_MAX_PORTABILITY
+	#define AS_FUNCTION(f) WRAP_FN(f) // RegisterGlobalFunction(decl, WRAP_FN(f), asCALL_GENERIC)
+	#define AS_FUNCTIONPR(f, p, r) WRAP_FN_PR(f, p, r) // RegisterGlobalFunction(decl, WRAP_FN_PR(f, p, r), asCALL_GENERIC)
+	#define AS_CALL_CDECL asCALL_GENERIC
+#else
+	#define AS_FUNCTION(f) asFUNCTION(f) // RegisterGlobalFunction(decl, asFUNCTION(f), asCALL_CDECL)
+	#define AS_FUNCTIONPR(f, p, r) asFUNCTIONPR(f, p, r) // RegisterGlobalFunction(decl, asFUNCTIONPR(f, p, r), asCALL_CDECL)
+	#define AS_CALL_CDECL asCALL_CDECL
+#endif
+
+// RegisterObjectMethod(obj, decl, AS_METHOD(c, m), AS_CALL_THISCALL)
+// RegisterObjectMethod(obj, decl, AS_METHODPR(c, m, p, r), AS_CALL_THISCALL)
+// RegisterObjectBehaviour(obj, asBEHAVE_ADDREF, decl, AS_METHODPR(c, m, p, r), AS_CALL_THISCALL)
+// RegisterObjectBehaviour(obj, asBEHAVE_RELEASE, decl, AS_METHODPR(c, m, p, r), AS_CALL_THISCALL);
+#ifdef AS_MAX_PORTABILITY
+	#define AS_METHOD(c, m) WRAP_MFN(c, m) // RegisterObjectMethod(obj, decl, WRAP_MFN(c, m), asCALL_GENERIC)
+	#define AS_METHODPR(c, m, p, r) WRAP_MFN_PR(c, m, p, r) // RegisterObjectMethod(obj, decl, WRAP_MFN_PR(c, m, p, r), asCALL_GENERIC)
+	#define AS_CALL_THISCALL asCALL_GENERIC
+#else
+	#define AS_METHOD(c, m) asMETHOD(c, m) // RegisterObjectMethod(obj, decl, asMETHOD(c, m), asCALL_THISCALL)
+	#define AS_METHODPR(c, m, p, r) asMETHODPR(c, m, p, r) // RegisterObjectMethod(obj, decl, asMETHODPR(c, m, p, r), asCALL_THISCALL)
+	#define AS_CALL_THISCALL asCALL_THISCALL
+#endif
+
+// RegisterObjectMethod(obj, decl, AS_FUNCTION_OBJFIRST(f), AS_CALL_CDECL_OBJFIRST)
+// RegisterObjectMethod(obj, decl, AS_FUNCTION_OBJLAST(f), AS_CALL_CDECL_OBJLAST)
+// RegisterObjectMethod(obj, decl, AS_FUNCTIONPT_OBJFIRST(f, p, r), AS_CALL_CDECL_OBJFIRST)
+// RegisterObjectMethod(obj, decl, AS_FUNCTIONPT_OBJLAST(f, p, r), AS_CALL_CDECL_OBJLAST)
+#ifdef AS_MAX_PORTABILITY
+	#define AS_FUNCTION_OBJFIRST(f) WRAP_OBJ_FIRST(f) // RegisterObjectMethod(obj, decl, WRAP_OBJ_FIRST(f), asCALL_GENERIC)
+	#define AS_FUNCTION_OBJLAST(f) WRAP_OBJ_LAST(f) // RegisterObjectMethod(obj, decl, WRAP_OBJ_LAST(f), asCALL_GENERIC)
+	#define AS_FUNCTIONPR_OBJFIRST(f, p, r) WRAP_OBJ_FIRST_PR(f, p, r) // RegisterObjectMethod(obj, decl, WRAP_OBJ_FIRST_PR(f, p, r), asCALL_GENERIC)
+	#define AS_FUNCTIONPR_OBJLAST(f, p, r) WRAP_OBJ_LAST_PR(f, p, r) // RegisterObjectMethod(obj, decl, WRAP_OBJ_LAST_PR(f, p, r), asCALL_GENERIC)
+	#define AS_CALL_CDECL_OBJFIRST asCALL_GENERIC
+	#define AS_CALL_CDECL_OBJLAST asCALL_GENERIC
+#else
+	#define AS_FUNCTION_OBJFIRST(f) asFUNCTION(f) // RegisterObjectMethod(obj, decl, asFUNCTION(f), asCALL_CDECL_OBJFIRST)
+	#define AS_FUNCTION_OBJLAST(f) asFUNCTION(f) // RegisterObjectMethod(obj, decl, asFUNCTION(f), asCALL_CDECL_OBJLAST)
+	#define AS_FUNCTIONPR_OBJFIRST(f, p, r) asFUNCTIONPR(f, p, r) // RegisterObjectMethod(obj, decl, asFUNCTIONPR(f, p, r), asCALL_CDECL_OBJFIRST)
+	#define AS_FUNCTIONPR_OBJLAST(f, p, r) asFUNCTIONPR(f, p, r) // RegisterObjectMethod(obj, decl, asFUNCTIONPR(f, p, r), asCALL_CDECL_OBJLAST)
+	#define AS_CALL_CDECL_OBJFIRST asCALL_CDECL_OBJFIRST
+	#define AS_CALL_CDECL_OBJLAST asCALL_CDECL_OBJLAST
+#endif
+
+// RegisterObjectBehaviour(obj, asBEHAVE_DESTRUCT, decl, AS_DESTRUCTOR(c), AS_CALL_CDECL_OBJFIRST)
+#ifdef AS_MAX_PORTABILITY
+	#define AS_DESTRUCTOR(c) WRAP_DES(c) // RegisterObjectBehaviour(obj, asBEHAVE_DESTRUCT, decl, WRAP_DES(c), asCALL_GENERIC)
+#else
+	template <typename T>
+	void ASNativeDestructor(T* ptr)
+	{
+		ptr->~T();
+	}
+
+	// RegisterObjectBehaviour(obj, asBEHAVE_DESTRUCT, decl, asFUNCTION(ASNativeDestructor<c>), asCALL_CDECL_OBJFIRST)
+	#define AS_DESTRUCTOR(c) asFUNCTION(ASNativeDestructor<c>)
+#endif
+
+} // namespace Urho3D

Source/Urho3D/AngelScript/SceneAPI.cpp

@@ -36,7 +36,7 @@ namespace Urho3D
 
 static void RegisterNode(asIScriptEngine* engine)
 {
-    engine->RegisterGlobalFunction("Node@+ get_node()", asFUNCTION(GetScriptContextNode), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Node@+ get_node()", AS_FUNCTION(GetScriptContextNode), AS_CALL_CDECL);
 }
 
 static CScriptArray* GetObjectCategories()
@@ -79,11 +79,11 @@ static CScriptArray* GetObjectAttributeInfos(const String& objectType)
 
 static void RegisterScene(asIScriptEngine* engine)
 {
-    engine->RegisterGlobalFunction("Scene@+ get_scene()", asFUNCTION(GetScriptContextScene), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Scene@+ get_scene()", AS_FUNCTION(GetScriptContextScene), AS_CALL_CDECL);
 
-    engine->RegisterGlobalFunction("Array<String>@ GetObjectCategories()", asFUNCTION(GetObjectCategories), asCALL_CDECL);
-    engine->RegisterGlobalFunction("Array<String>@ GetObjectsByCategory(const String&in)", asFUNCTION(GetObjectsByCategory), asCALL_CDECL);
-    engine->RegisterGlobalFunction("Array<AttributeInfo>@ GetObjectAttributeInfos(const String&in)", asFUNCTION(GetObjectAttributeInfos), asCALL_CDECL);
+    engine->RegisterGlobalFunction("Array<String>@ GetObjectCategories()", AS_FUNCTION(GetObjectCategories), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("Array<String>@ GetObjectsByCategory(const String&in)", AS_FUNCTION(GetObjectsByCategory), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("Array<AttributeInfo>@ GetObjectAttributeInfos(const String&in)", AS_FUNCTION(GetObjectAttributeInfos), AS_CALL_CDECL);
 }
 
 void RegisterSceneAPI(asIScriptEngine* engine)

Source/Urho3D/AngelScript/Script.cpp

@@ -27,6 +27,7 @@
 #include "../AngelScript/ScriptAPI.h"
 #include "../AngelScript/ScriptFile.h"
 #include "../AngelScript/ScriptInstance.h"
+#include "../AngelScript/RegistrationMacros.h"
 #include "../Core/Profiler.h"
 #include "../Engine/EngineEvents.h"
 #include "../IO/FileSystem.h"
@@ -129,21 +130,11 @@ Script::Script(Context* context) :
     scriptEngine_->SetEngineProperty(asEP_ALLOW_IMPLICIT_HANDLE_TYPES, (asPWORD)true);
     scriptEngine_->SetEngineProperty(asEP_BUILD_WITHOUT_LINE_CUES, (asPWORD)true);
     scriptEngine_->SetEngineProperty(asEP_PROPERTY_ACCESSOR_MODE, 1);
-// Use the copy of the original asMETHOD macro in a web build (for some reason it still works, presumably because the signature of the function is known)
-#ifdef AS_MAX_PORTABILITY
-    scriptEngine_->SetMessageCallback(_asMETHOD(Script, MessageCallback), this, asCALL_THISCALL);
-#else
     scriptEngine_->SetMessageCallback(asMETHOD(Script, MessageCallback), this, asCALL_THISCALL);
-#endif
 
     // Create the context for immediate execution
     immediateContext_ = scriptEngine_->CreateContext();
-// Use the copy of the original asMETHOD macro in a web build (for some reason it still works, presumably because the signature of the function is known)
-#ifdef AS_MAX_PORTABILITY
-    immediateContext_->SetExceptionCallback(_asMETHOD(Script, ExceptionCallback), this, asCALL_THISCALL);
-#else
     immediateContext_->SetExceptionCallback(asMETHOD(Script, ExceptionCallback), this, asCALL_THISCALL);
-#endif
 
     // Register Script library object factories
     RegisterScriptLibrary(context_);
@@ -414,12 +405,7 @@ asIScriptContext* Script::GetScriptFileContext()
     while (scriptNestingLevel_ >= scriptFileContexts_.Size())
     {
         asIScriptContext* newContext = scriptEngine_->CreateContext();
-// Use the copy of the original asMETHOD macro in a web build (for some reason it still works, presumably because the signature of the function is known)
-#ifdef AS_MAX_PORTABILITY
-        newContext->SetExceptionCallback(_asMETHOD(Script, ExceptionCallback), this, asCALL_THISCALL);
-#else
         newContext->SetExceptionCallback(asMETHOD(Script, ExceptionCallback), this, asCALL_THISCALL);
-#endif
 
         scriptFileContexts_.Push(newContext);
     }

Source/Urho3D/AngelScript/ScriptAPI.cpp

@@ -88,11 +88,11 @@ static asIScriptObject* NodeCreateScriptObjectWithFile(ScriptFile* file, const S
 static void RegisterScriptFile(asIScriptEngine* engine)
 {
     RegisterResource<ScriptFile>(engine, "ScriptFile");
-    engine->RegisterObjectMethod("ScriptFile", "bool Execute(const String&in, const Array<Variant>@+ params = null)", asFUNCTION(ScriptFileExecute), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("ScriptFile", "void DelayedExecute(float, bool, const String&in, const Array<Variant>@+ params = null)", asFUNCTION(ScriptFileDelayedExecute), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("ScriptFile", "void ClearDelayedExecute(const String&in declaration = String())", asMETHOD(ScriptFile, ClearDelayedExecute), asCALL_THISCALL);
-    engine->RegisterObjectMethod("ScriptFile", "bool get_compiled() const", asMETHOD(ScriptFile, IsCompiled), asCALL_THISCALL);
-    engine->RegisterGlobalFunction("ScriptFile@+ get_scriptFile()", asFUNCTION(GetScriptContextFile), asCALL_CDECL);
+    engine->RegisterObjectMethod("ScriptFile", "bool Execute(const String&in, const Array<Variant>@+ params = null)", AS_FUNCTION_OBJLAST(ScriptFileExecute), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("ScriptFile", "void DelayedExecute(float, bool, const String&in, const Array<Variant>@+ params = null)", AS_FUNCTION_OBJLAST(ScriptFileDelayedExecute), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("ScriptFile", "void ClearDelayedExecute(const String&in declaration = String())", AS_METHOD(ScriptFile, ClearDelayedExecute), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("ScriptFile", "bool get_compiled() const", AS_METHOD(ScriptFile, IsCompiled), AS_CALL_THISCALL);
+    engine->RegisterGlobalFunction("ScriptFile@+ get_scriptFile()", AS_FUNCTION(GetScriptContextFile), AS_CALL_CDECL);
 }
 
 static asIScriptObject* NodeCreateScriptObject(const String& scriptFileName, const String& className, CreateMode mode, Node* ptr)
@@ -223,37 +223,37 @@ static void SelfRemove()
 
 static void RegisterScriptInstance(asIScriptEngine* engine)
 {
-    engine->RegisterObjectMethod("Node", "ScriptObject@+ CreateScriptObject(ScriptFile@+, const String&in, CreateMode mode = REPLICATED)", asFUNCTION(NodeCreateScriptObjectWithFile), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Node", "ScriptObject@+ CreateScriptObject(const String&in, const String&in, CreateMode mode = REPLICATED)", asFUNCTION(NodeCreateScriptObject), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Node", "ScriptObject@+ GetScriptObject() const", asFUNCTION(NodeGetScriptObject), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Node", "ScriptObject@+ GetScriptObject(const String&in) const", asFUNCTION(NodeGetNamedScriptObject), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Node", "ScriptObject@+ get_scriptObject() const", asFUNCTION(NodeGetScriptObject), asCALL_CDECL_OBJLAST);
-
-    engine->RegisterObjectMethod("Scene", "ScriptObject@+ CreateScriptObject(ScriptFile@+, const String&in, CreateMode mode = REPLICATED)", asFUNCTION(NodeCreateScriptObjectWithFile), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Scene", "ScriptObject@+ CreateScriptObject(const String&in, const String&in, CreateMode mode = REPLICATED)", asFUNCTION(NodeCreateScriptObject), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Scene", "ScriptObject@+ GetScriptObject() const", asFUNCTION(NodeGetScriptObject), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Scene", "ScriptObject@+ GetScriptObject(const String&in) const", asFUNCTION(NodeGetNamedScriptObject), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("Scene", "ScriptObject@+ get_scriptObject() const", asFUNCTION(NodeGetScriptObject), asCALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Node", "ScriptObject@+ CreateScriptObject(ScriptFile@+, const String&in, CreateMode mode = REPLICATED)", AS_FUNCTION_OBJLAST(NodeCreateScriptObjectWithFile), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Node", "ScriptObject@+ CreateScriptObject(const String&in, const String&in, CreateMode mode = REPLICATED)", AS_FUNCTION_OBJLAST(NodeCreateScriptObject), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Node", "ScriptObject@+ GetScriptObject() const", AS_FUNCTION_OBJLAST(NodeGetScriptObject), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Node", "ScriptObject@+ GetScriptObject(const String&in) const", AS_FUNCTION_OBJLAST(NodeGetNamedScriptObject), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Node", "ScriptObject@+ get_scriptObject() const", AS_FUNCTION_OBJLAST(NodeGetScriptObject), AS_CALL_CDECL_OBJLAST);
+
+    engine->RegisterObjectMethod("Scene", "ScriptObject@+ CreateScriptObject(ScriptFile@+, const String&in, CreateMode mode = REPLICATED)", AS_FUNCTION_OBJLAST(NodeCreateScriptObjectWithFile), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Scene", "ScriptObject@+ CreateScriptObject(const String&in, const String&in, CreateMode mode = REPLICATED)", AS_FUNCTION_OBJLAST(NodeCreateScriptObject), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Scene", "ScriptObject@+ GetScriptObject() const", AS_FUNCTION_OBJLAST(NodeGetScriptObject), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Scene", "ScriptObject@+ GetScriptObject(const String&in) const", AS_FUNCTION_OBJLAST(NodeGetNamedScriptObject), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("Scene", "ScriptObject@+ get_scriptObject() const", AS_FUNCTION_OBJLAST(NodeGetScriptObject), AS_CALL_CDECL_OBJLAST);
 
     RegisterComponent<ScriptInstance>(engine, "ScriptInstance");
-    engine->RegisterObjectMethod("ScriptInstance", "bool CreateObject(ScriptFile@+, const String&in)", asMETHODPR(ScriptInstance, CreateObject, (ScriptFile*, const String&), bool), asCALL_THISCALL);
-    engine->RegisterObjectMethod("ScriptInstance", "bool Execute(const String&in, const Array<Variant>@+ params = null)", asFUNCTION(ScriptInstanceExecute), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("ScriptInstance", "void DelayedExecute(float, bool, const String&in, const Array<Variant>@+ params = null)", asFUNCTION(ScriptInstanceDelayedExecute), asCALL_CDECL_OBJLAST);
-    engine->RegisterObjectMethod("ScriptInstance", "void ClearDelayedExecute(const String&in declaration = String())", asMETHOD(ScriptInstance, ClearDelayedExecute), asCALL_THISCALL);
-    engine->RegisterObjectMethod("ScriptInstance", "bool IsA(const String&in declaration) const", asMETHOD(ScriptInstance, IsA), asCALL_THISCALL);
-    engine->RegisterObjectMethod("ScriptInstance", "bool HasMethod(const String&in declaration) const", asMETHOD(ScriptInstance, HasMethod), asCALL_THISCALL);
-    engine->RegisterObjectMethod("ScriptInstance", "void set_scriptFile(ScriptFile@+)", asMETHOD(ScriptInstance, SetScriptFile), asCALL_THISCALL);
-    engine->RegisterObjectMethod("ScriptInstance", "ScriptFile@+ get_scriptFile() const", asMETHOD(ScriptInstance, GetScriptFile), asCALL_THISCALL);
-    engine->RegisterObjectMethod("ScriptInstance", "ScriptObject@+ get_scriptObject() const", asMETHOD(ScriptInstance, GetScriptObject), asCALL_THISCALL);
-    engine->RegisterObjectMethod("ScriptInstance", "void set_className(const String&in)", asMETHOD(ScriptInstance, SetClassName), asCALL_THISCALL);
-    engine->RegisterObjectMethod("ScriptInstance", "const String& get_className() const", asMETHOD(ScriptInstance, GetClassName), asCALL_THISCALL);
-    engine->RegisterGlobalFunction("ScriptInstance@+ get_self()", asFUNCTION(GetSelf), asCALL_CDECL);
+    engine->RegisterObjectMethod("ScriptInstance", "bool CreateObject(ScriptFile@+, const String&in)", AS_METHODPR(ScriptInstance, CreateObject, (ScriptFile*, const String&), bool), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("ScriptInstance", "bool Execute(const String&in, const Array<Variant>@+ params = null)", AS_FUNCTION_OBJLAST(ScriptInstanceExecute), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("ScriptInstance", "void DelayedExecute(float, bool, const String&in, const Array<Variant>@+ params = null)", AS_FUNCTION(ScriptInstanceDelayedExecute), AS_CALL_CDECL_OBJLAST);
+    engine->RegisterObjectMethod("ScriptInstance", "void ClearDelayedExecute(const String&in declaration = String())", AS_METHOD(ScriptInstance, ClearDelayedExecute), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("ScriptInstance", "bool IsA(const String&in declaration) const", AS_METHOD(ScriptInstance, IsA), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("ScriptInstance", "bool HasMethod(const String&in declaration) const", AS_METHOD(ScriptInstance, HasMethod), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("ScriptInstance", "void set_scriptFile(ScriptFile@+)", AS_METHOD(ScriptInstance, SetScriptFile), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("ScriptInstance", "ScriptFile@+ get_scriptFile() const", AS_METHOD(ScriptInstance, GetScriptFile), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("ScriptInstance", "ScriptObject@+ get_scriptObject() const", AS_METHOD(ScriptInstance, GetScriptObject), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("ScriptInstance", "void set_className(const String&in)", AS_METHOD(ScriptInstance, SetClassName), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("ScriptInstance", "const String& get_className() const", AS_METHOD(ScriptInstance, GetClassName), AS_CALL_THISCALL);
+    engine->RegisterGlobalFunction("ScriptInstance@+ get_self()", AS_FUNCTION(GetSelf), AS_CALL_CDECL);
 
     // Register convenience functions for controlling self, similar to event sending
-    engine->RegisterGlobalFunction("void MarkNetworkUpdate()", asFUNCTION(SelfMarkNetworkUpdate), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void DelayedExecute(float, bool, const String&in, const Array<Variant>@+ params = null)", asFUNCTION(SelfDelayedExecute), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void ClearDelayedExecute(const String&in declaration = String())", asFUNCTION(SelfClearDelayedExecute), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void Remove()", asFUNCTION(SelfRemove), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void MarkNetworkUpdate()", AS_FUNCTION(SelfMarkNetworkUpdate), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void DelayedExecute(float, bool, const String&in, const Array<Variant>@+ params = null)", AS_FUNCTION(SelfDelayedExecute), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void ClearDelayedExecute(const String&in declaration = String())", AS_FUNCTION(SelfClearDelayedExecute), AS_CALL_CDECL);
+    engine->RegisterGlobalFunction("void Remove()", AS_FUNCTION(SelfRemove), AS_CALL_CDECL);
 }
 
 static Script* GetScript()
@@ -268,15 +268,15 @@ static void RegisterScript(asIScriptEngine* engine)
     engine->RegisterEnumValue("DumpMode", "C_HEADER", C_HEADER);
 
     RegisterObject<Script>(engine, "Script");
-    engine->RegisterObjectMethod("Script", "bool Execute(const String&in)", asMETHOD(Script, Execute), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Script", "void DumpAPI(DumpMode mode = DOXYGEN, const String&in sourceTree = String())", asMETHOD(Script, DumpAPI), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Script", "void set_defaultScriptFile(ScriptFile@+)", asMETHOD(Script, SetDefaultScriptFile), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Script", "ScriptFile@+ get_defaultScriptFile() const", asMETHOD(Script, GetDefaultScriptFile), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Script", "void set_defaultScene(Scene@+)", asMETHOD(Script, SetDefaultScene), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Script", "Scene@+ get_defaultScene() const", asMETHOD(Script, GetDefaultScene), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Script", "void set_executeConsoleCommands(bool)", asMETHOD(Script, SetExecuteConsoleCommands), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Script", "bool get_executeConsoleCommands() const", asMETHOD(Script, GetExecuteConsoleCommands), asCALL_THISCALL);
-    engine->RegisterGlobalFunction("Script@+ get_script()", asFUNCTION(GetScript), asCALL_CDECL);
+    engine->RegisterObjectMethod("Script", "bool Execute(const String&in)", AS_METHOD(Script, Execute), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Script", "void DumpAPI(DumpMode mode = DOXYGEN, const String&in sourceTree = String())", AS_METHOD(Script, DumpAPI), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Script", "void set_defaultScriptFile(ScriptFile@+)", AS_METHOD(Script, SetDefaultScriptFile), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Script", "ScriptFile@+ get_defaultScriptFile() const", AS_METHOD(Script, GetDefaultScriptFile), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Script", "void set_defaultScene(Scene@+)", AS_METHOD(Script, SetDefaultScene), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Script", "Scene@+ get_defaultScene() const", AS_METHOD(Script, GetDefaultScene), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Script", "void set_executeConsoleCommands(bool)", AS_METHOD(Script, SetExecuteConsoleCommands), AS_CALL_THISCALL);
+    engine->RegisterObjectMethod("Script", "bool get_executeConsoleCommands() const", AS_METHOD(Script, GetExecuteConsoleCommands), AS_CALL_THISCALL);
+    engine->RegisterGlobalFunction("Script@+ get_script()", AS_FUNCTION(GetScript), AS_CALL_CDECL);
 }
 
 static void RegisterScriptObject(asIScriptEngine* engine)

Source/Urho3D/AngelScript/ScriptAPIDump.cpp

@@ -29,7 +29,6 @@
 #include "../IO/Log.h"
 
 #include <AngelScript/angelscript.h>
-#include "../AngelScript/wrapmacros.h"
 
 #include "../DebugNew.h"
 

Source/Urho3D/AngelScript/ScriptFile.cpp

@@ -34,7 +34,6 @@
 #include "../Resource/ResourceCache.h"
 
 #include <AngelScript/angelscript.h>
-#include "../AngelScript/wrapmacros.h"
 
 #include "../DebugNew.h"
 

Source/Urho3D/AngelScript/ScriptInstance.cpp

@@ -40,7 +40,6 @@
 #include "../Scene/SceneEvents.h"
 
 #include <AngelScript/angelscript.h>
-#include "../AngelScript/wrapmacros.h"
 
 #include "../DebugNew.h"
 

Source/Urho3D/AngelScript/wrap16.h → Source/Urho3D/AngelScript/aswrappedcall.h

@@ -1,5 +1,7 @@
-// This file was generated by the angelscript autowrapper addon
-// Modified by Nathanial Lydick for Urho3D (including the addition of the above notice)
+// This file was generated by the angelscript autowrapper addon with max_args = 16
+// https://www.angelcode.com/angelscript/sdk/docs/manual/doc_addon_autowrap.html
+// https://github.com/codecat/angelscript-mirror/tree/master/sdk/add_on/autowrapper/generator
+// and modified for Urho3D
 
 #ifndef AS_GEN_WRAPPER_H
 #define AS_GEN_WRAPPER_H
@@ -7,7 +9,7 @@
 #ifndef ANGELSCRIPT_H
 // Avoid having to inform include path if header is already include before
 
-// Urho3D: Commented out original
+// Urho3D: commented out original
 //#include <angelscript.h>
 
 // Urho3D
@@ -2897,9 +2899,9 @@ struct Constructor <T (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A1
 };
 template <typename T>
 struct Id {
-	template <T fn_ptr> AS_NAMESPACE_QUALIFIER asSFuncPtr  f(void) { return asFunctionPtr(&Wrapper<T>::template f<fn_ptr>); }
-	template <T fn_ptr> AS_NAMESPACE_QUALIFIER asSFuncPtr of(void) { return asFunctionPtr(&ObjFirst<T>::template f<fn_ptr>); }
-	template <T fn_ptr> AS_NAMESPACE_QUALIFIER asSFuncPtr ol(void) { return asFunctionPtr(&ObjLast<T>::template f<fn_ptr>); }
+	template <T fn_ptr> AS_NAMESPACE_QUALIFIER asSFuncPtr  f(void) { return asFUNCTION(&Wrapper<T>::template f<fn_ptr>); }
+	template <T fn_ptr> AS_NAMESPACE_QUALIFIER asSFuncPtr of(void) { return asFUNCTION(&ObjFirst<T>::template f<fn_ptr>); }
+	template <T fn_ptr> AS_NAMESPACE_QUALIFIER asSFuncPtr ol(void) { return asFUNCTION(&ObjLast<T>::template f<fn_ptr>); }
 };
 
 template <typename T>
@@ -2908,7 +2910,15 @@ Id<T> id(T fn_ptr) { return Id<T>(); }
 // On some versions of GNUC it is necessary to use the template keyword as disambiguator,
 // on others the template keyword gives an error, hence the need for the following define.
 // MSVC on the other hand seems to accept both with or without the template keyword.
+
+// Urho3D: commented out original
+//#if defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 4))
+
+// Urho3D: MinGW also requires this
 #if defined(__GNUC__)
+
+	// GNUC 4.4.3 doesn't need the template keyword, and
+	// hopefully upcoming versions won't need it either
 	#define TMPL template
 #else
 	#define TMPL
@@ -2919,18 +2929,30 @@ Id<T> id(T fn_ptr) { return Id<T>(); }
 #define WRAP_OBJ_FIRST(name)      (::gw::id(name).TMPL of< name >())
 #define WRAP_OBJ_LAST(name)       (::gw::id(name).TMPL ol< name >())
 
-#define WRAP_FN_PR(name, Parameters, ReturnType)             asFunctionPtr((::gw::Wrapper<ReturnType (*)Parameters>::TMPL f< name >))
-// Urho3D: The template method did not compile for me (emscripten and gcc), hence the lambda stuff in the wrap.h file
-//#define WRAP_MFN_PR(ClassType, name, Parameters, ReturnType) asFunctionPtr<asGENFUNC_t>((::gw::Wrapper<ReturnType (ClassType::*)Parameters>::TMPL f< &ClassType::name >))
-#define WRAP_OBJ_FIRST_PR(name, Parameters, ReturnType)      asFunctionPtr((::gw::ObjFirst<ReturnType (*)Parameters>::TMPL f< name >))
-#define WRAP_OBJ_LAST_PR(name, Parameters, ReturnType)       asFunctionPtr((::gw::ObjLast<ReturnType (*)Parameters>::TMPL f< name >))
+#define WRAP_FN_PR(name, Parameters, ReturnType)             asFUNCTION((::gw::Wrapper<ReturnType (*)Parameters>::TMPL f< name >))
 
-#define WRAP_CON(ClassType, Parameters) asFunctionPtr((::gw::Constructor<ClassType Parameters>::f))
-#define WRAP_DES(ClassType)             asFunctionPtr((::gw::destroy<ClassType>))
+// Urho3D: commented out original
+//#define WRAP_MFN_PR(ClassType, name, Parameters, ReturnType) asFUNCTION((::gw::Wrapper<ReturnType (ClassType::*)Parameters>::TMPL f< &ClassType::name >))
+
+// Urho3D
+#ifdef _MSC_VER
+#define WRAP_MFN_PR(ClassType, name, Parameters, ReturnType) asFUNCTION((::gw::Wrapper<ReturnType (ClassType::*)Parameters>::TMPL f< AS_METHOD_AMBIGUITY_CAST(ReturnType (ClassType::*)Parameters)(&ClassType::name) >))
+#endif
+
+#define WRAP_OBJ_FIRST_PR(name, Parameters, ReturnType)      asFUNCTION((::gw::ObjFirst<ReturnType (*)Parameters>::TMPL f< name >))
+#define WRAP_OBJ_LAST_PR(name, Parameters, ReturnType)       asFUNCTION((::gw::ObjLast<ReturnType (*)Parameters>::TMPL f< name >))
+
+// Urho3D: commented out original
+//#define WRAP_CON(ClassType, Parameters) asFUNCTION((::gw::Constructor<ClassType Parameters>::f))
+
+#define WRAP_DES(ClassType)             asFUNCTION((::gw::destroy<ClassType>))
 
 } // end namespace gw
 
-// Urho3D: The template method did not compile for me (emscripten and gcc), hence the lambda stuff in the wrap.h file
-#include "wrap.h"
+// Urho3D
+#ifndef _MSC_VER
+// WRAP_FN_PR for GCC
+#include "../AngelScript/wrap.h"
+#endif
 
 #endif

Source/Urho3D/AngelScript/wrap.h

@@ -22,6 +22,48 @@
 
 #pragma once
 
+// WRAP_MFN_PR for GCC
+// GCC has problems with templates, VS with macros, so implementations is different
+
+/*
+struct A
+{
+    bool f(int i) { return true; }
+};
+
+struct B : public A
+{
+    // f() is inherited
+};
+
+template <bool (B::*fp)(int)>
+struct WrapF
+{
+};
+
+WrapF<&B::f> a;
+// Doesn't work for any compiler
+// Error: non-type template argument of type 'bool (Urho3D::A::*)(int)' cannot be converted to a value of type 'bool (Urho3D::B::*)(int)'
+
+WrapF<static_cast<bool (B::*)(int)>(&B::f)> b;
+// Works for VS but not works for GCC
+// Error: non-type template argument is not a pointer to member constant
+
+==================================
+
+MACROS1(a, b, MACROS2)
+GCC replaces the parameter MACROS2 first and after that MACROS1
+VS replaces MACROS1 first
+
+VS has parameters:
+https://docs.microsoft.com/en-us/cpp/preprocessor/preprocessor-experimental-overview
+https://docs.microsoft.com/en-us/cpp/build/reference/experimental-preprocessor
+but it cause banch of errors in Windows 10 SDK <= 10.0.17763.0
+and third party libs
+*/
+
+#ifndef _MSC_VER
+
 #include <type_traits>
 
 #include <AngelScript/angelscript.h>
@@ -133,4 +175,4 @@ void callconst(asIScriptGeneric*g, C*obj, R (C::*fn)(P...)const, P... args)
 
 } // namespace wrap
 
-
+#endif // ndef _MSC_VER

Source/Urho3D/AngelScript/wrapmacros.h

@@ -1,159 +0,0 @@
-//
-// Copyright (c) 2008-2020 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.
-//
-
-// FIXME: This file needs to be cleaned up
-
-#pragma once
-
-// Only use this file if the portable (wrapped) code has been specifically requested
-#ifdef AS_MAX_PORTABILITY
-
-//the template wrapper code
-#include "wrap16.h"
-
-//can help solve potential ... problems if we need it at the start: http://stackoverflow.com/questions/3046889/optional-parameters-with-c-macros
-
-//Overview of the process:
-//take the original function that registers a function for the angelscript engine:
-//(RegisterGlobalFunction, RegisterObjectMethod, ...)
-//Define it as a macro. Redefine the asFUNCTION family of macros to extract the arguments passed to them
-//and pass an F, M, FPR, or MPR depending on which macro was chosen as another argument before the original
-//contents of the asFUNCTION macro
-//Use the ## operator to paste the F, M, FPR< or MPR along with the asECallConvTypes name to form the name of another macro
-//This other macro will then bundle the arguments back into the original RegisterGlobalFunction... call, but will use the
-//wrap macros from the wrap16.h and wrap.h files instead of the original asFUNCTION... call, and will specify the asCALL_GENERIC
-//calling convention
-//***NOTE***: not all of the possibly calling convention/method combinations have been finished, and those that Urho does not use are untested
-
-
-#undef asFUNCTION
-#define asFUNCTION(f) F, f
-//define a new macro (taken from angelscript.h) to use in place of the original asFUNCTION macro
-#define _asFUNCTION(f) asFunctionPtr(f)
-//#define asMETHOD(cls, f) cls, M, f
-#undef asMETHOD
-#define asMETHOD(cls, f) M, (cls,f) //package class and function for UNWRAPping later
-#undef UNWRAP
-#define UNWRAP(x,y) x,y// try -fmacro-backtrace-limit=0 on compile
-//define a new macro (taken from angelscript.h) to use in place of the original asMETHOD macro
-#define _asMETHOD(c,m) asSMethodPtr<sizeof(void (c::*)())>::Convert((void (c::*)())(&c::m))
-#define RegisterGlobalFunction(...) RegGlobalIndirect(__VA_ARGS__)
-#define RegGlobalIndirect(decl, F, func, kind) RegisterGlobalFunction##F##kind (decl,func) // ... = decl or it = decl, cls for asCall_ThisCall
-#define RegisterGlobalFunctionFasCALL_CDECL(decl,fun) RegisterGlobalFunction(decl, WRAP_FN(fun), asCALL_GENERIC); //assert(r >= 0);
-#define RegisterGlobalFunctionFasCALL_STDCALL(decl,fun) RegisterGlobalFunction(decl, WRAP_FN(fun), asCALL_GENERIC); //assert(r >= 0);
-#define RegisterGlobalFunctionMasCALL_THISCALL_ASGLOBAL(decl,fun) RegisterGlobalFunctionMasCALL_THISCALL_ASGLOBAL_2(decl,UNWRAP fun)
-#define RegisterGlobalFunctionMasCALL_THISCALL_ASGLOBAL_2(decl, ...) RegisterGlobalFunction(decl, WRAP_MFN(__VA_ARGS__), asCALL_GENERIC); //assert(r >= 0);
-#define RegisterGlobalFunctionFasCALL_GENERIC(decl,fun) RegisterGlobalFunction(decl, asFunctionPtr(fun), asCALL_GENERIC); //assert(r >= 0);
-
-//object indirects
-#define RegisterObjectMethod(...) RegObjectMethodIndirect(__VA_ARGS__)
-//#define RegObjectIndirect(clsdcl,decl, F, func, kind) RegObjectIndirect_2(clsdcl,decl, F, UNWRAP func, kind)
-#define RegObjectMethodIndirect(clsdcl,decl, F, clsfunc, kind) RegisterObjectMethod##F##kind (clsdcl,decl,clsfunc) // ... = decl or it = decl, cls for asCall_ThisCall
-#define RegisterObjectMethodMasCALL_THISCALL(clsdcl,decl,clsfunc) RegisterObjectMethodMasCALL_THISCALL_2(clsdcl,decl,UNWRAP clsfunc)
-#define RegisterObjectMethodMasCALL_THISCALL_2(clsdcl,decl,...) RegisterObjectMethodMasCALL_THISCALL_3(clsdcl,decl, WRAP_MFN(__VA_ARGS__));
-#define RegisterObjectMethodMasCALL_THISCALL_3(clsdcl,decl,fn) RegisterObjectMethod(clsdcl,decl, fn, asCALL_GENERIC); //assert(r >= 0);
-#define RegisterObjectMethodFasCALL_CDECL_OBJLAST(clsdcl,decl,fun) RegisterObjectMethod(clsdcl,decl, WRAP_OBJ_LAST(fun), asCALL_GENERIC); //assert(r >= 0);
-#define RegisterObjectMethodFasCALL_CDECL_OBJFIRST(clsdcl,decl,fun) RegisterObjectMethod(clsdcl,decl, WRAP_OBJ_FIRST(fun), asCALL_GENERIC); //assert(r >= 0);
-//#define RegisterObjectMethodMasCALL_CDECL_OBJECTFIRST(decl,cls,fun) RegisterObjectMethodMasCALL_THISCALL_ASGLOBAL_2(decl,UNWRAP fun)
-//#define RegisterObjectMethodMasCALL_THISCALL_ASGLOBAL_2(decl, ...) RegisterObjectMethod(decl, WRAP_MFN(__VA_ARGS__), asCALL_GENERIC); //assert(r >= 0);
-#define RegisterObjectMethodFasCALL_GENERIC(clsdcl,decl,fun) RegisterObjectMethod(clsdcl,decl, asFunctionPtr(fun), asCALL_GENERIC); //assert(r >= 0);
-
-////note:unfortunately, the WrapCon methods are for creating the constructor wrapper, which typically seems to be done anyways, so we should just handle it like Register Object Method with 1 extra parameter
-//#define RegisterObjectBehaviour(...) RegObjectBehaviorIndirect(__VA__ARGS__)
-//#define RegObjectBehaviorIndirect(clsdcl,behavior,decl,fn,kind) RegisterObjectBehavior##behavior(clsdcl,behavior,decl,fn,kind)
-//#define RegisterObjectBehaviorasBEHAVE_CONSTRUCT(clsdcl,behavior,decl,fn,kind) RegisterObjectConstructor##F##kind (clsdcl,behavior,decl,fn)
-//#define RegisterObjectConstructorFasCALL_CDECL_OBJECTLAST(clsdcl,behavior,decl,fn) RegisterObjectBehavior(clsdcl,behavior,decl,WRAP_OBJ_LAST(fn),asCALL_GENERIC)
-////RegisterObjectConstructorF##kind (clsdcl,decl,clsfunc)
-
-//NOTE: Angelscript uses the British English spelling __iour!
-#define RegisterObjectBehaviour(...) RegObjectBehaviorIndirect(__VA_ARGS__)
-//#define RegObjectIndirect(clsdcl,behavior,decl, F, func, kind) RegObjectIndirect_2(clsdcl,behavior,decl, F, UNWRAP func, kind)
-#define RegObjectBehaviorIndirect(clsdcl,behavior,decl, F, clsfunc, kind) RegisterObjectBehavior##F##kind (clsdcl,behavior,decl,clsfunc) // ... = decl or it = decl, cls for asCall_ThisCall
-#define RegisterObjectBehaviorMasCALL_THISCALL(clsdcl,behavior,decl,clsfunc) RegisterObjectBehaviorMasCALL_THISCALL_2(clsdcl,behavior,decl,UNWRAP clsfunc)
-#define RegisterObjectBehaviorMasCALL_THISCALL_2(clsdcl,behavior,decl,...) RegisterObjectBehaviour(clsdcl,behavior,decl, WRAP_MFN(__VA_ARGS__), asCALL_GENERIC); //assert(r >= 0);
-#define RegisterObjectBehaviorFasCALL_CDECL_OBJLAST(clsdcl,behavior,decl,...) RegisterObjectBehaviour(clsdcl,behavior,decl, WRAP_OBJ_LAST(__VA_ARGS__), asCALL_GENERIC); //assert(r >= 0);
-#define RegisterObjectBehaviorFasCALL_CDECL_OBJFIRST(clsdcl,behavior,decl,...) RegisterObjectBehaviour(clsdcl,behavior,decl, WRAP_OBJ_FIRST(__VA_ARGS__), asCALL_GENERIC); //assert(r >= 0);
-//#define RegisterObjectBehaviorMasCALL_CDECL_OBJECTFIRST(decl,cls,fun) RegisterObjectBehaviorMasCALL_THISCALL_ASGLOBAL_2(decl,UNWRAP fun)
-//#define RegisterObjectBehaviorMasCALL_THISCALL_ASGLOBAL_2(decl, ...) RegisterObjectBehavior(decl, WRAP_MFN(__VA_ARGS__), asCALL_GENERIC); //assert(r >= 0);
-#define RegisterObjectBehaviorFasCALL_CDECL(clsdcl,behavior,decl,...) RegisterObjectBehaviour(clsdcl,behavior,decl, WRAP_FN(__VA_ARGS__),asCALL_GENERIC);
-#define RegisterObjectBehaviorFasCALL_GENERIC(clsdcl,behavior,decl,fun) RegisterObjectBehaviour(clsdcl,behavior,decl, asFunctionPtr(fun), asCALL_GENERIC); //assert(r >= 0);
-
-//Parameter-Return versions:
-
-#undef asFUNCTIONPR
-#define asFUNCTIONPR(f,p,r) FPR, (f,p,r)
-#define UNWRAP3(x,y,z) x,y,z
-#define UNWRAP4(x,y,z,w) x,y,z,w
-#undef asMETHODPR
-#define asMETHODPR(cls,f,p,r) MPR, (cls,f,p,r)
-//define a new macro (taken from angelscript.h) to use in place of the original asFUNCTIONPR macro
-#if (defined(_MSC_VER) && _MSC_VER <= 1200) || (defined(__BORLANDC__) && __BORLANDC__ < 0x590)
-// MSVC 6 has a bug that prevents it from properly compiling using the correct asFUNCTIONPR with operator >
-// so we need to use ordinary C style cast instead of static_cast. The drawback is that the compiler can't
-// check that the cast is really valid.
-// BCC v5.8 (C++Builder 2006) and earlier have a similar bug which forces us to fall back to a C-style cast.
-#define _asFUNCTIONPR(f,p,r) asFunctionPtr((void (*)())((r (*)p)(f)))
-#elif (defined(_MSC_VER) && _MSC_VER >= 1900)
-// Urho3D: VS2015 does not compile the C-style cast of the function pointer
-#define _asFUNCTIONPR(f,p,r) asFunctionPtr(reinterpret_cast<void (*)()>(static_cast<r (*)p>(f)))
-#else
-#define _asFUNCTIONPR(f,p,r) asFunctionPtr((void (*)())(static_cast<r (*)p>(f)))
-#endif
-//define a new macro (taken from angelscript.h) to use in place of the original asMETHODPR macro
-#define _asMETHODPR(c,m,p,r) asSMethodPtr<sizeof(void (c::*)())>::Convert(AS_METHOD_AMBIGUITY_CAST(r (c::*)p)(&c::m))
-
-
-#define RegisterGlobalFunctionFPRasCALL_CDECL(decl,fun) RegisterGlobalFunctionFPRasCALL_CDECL_2(decl, UNWRAP3 fun);
-#define RegisterGlobalFunctionFPRasCALL_CDECL_2(decl,...) RegisterGlobalFunction(decl, WRAP_FN_PR(__VA_ARGS__), asCALL_GENERIC);
-#define RegisterGlobalFunctionFPRasCALL_STDCALL(decl,fun) RegisterGlobalFunctionFPRasCALL_STDCALL_2(decl, UNWRAP3 fun);
-#define RegisterGlobalFunctionFPRasCALL_STDCALL_2(decl,...) RegisterGlobalFunction(decl, WRAP_FN_PR(__VA_ARGS__), asCALL_GENERIC);
-#define RegisterGlobalFunctionMPRasCALL_THISCALL_ASGLOBAL(decl,fun) RegisterGlobalFunctionMasCALL_THISCALL_ASGLOBAL_2(decl,UNWRAP4 fun)
-#define RegisterGlobalFunctionMPRasCALL_THISCALL_ASGLOBAL_2(decl, ...) RegisterGlobalFunction(decl, WRAP_MFN_PR(__VA_ARGS__), asCALL_GENERIC);
-#define RegisterGlobalFunctionFPRasCALL_GENERIC(decl,fun) RegisterGlobalFunctionFPRasCALL_GENERIC_2(decl, UNWRAP3 fun);
-#define RegisterGlobalFunctionFPRasCALL_GENERIC_2(decl,...) RegisterGlobalFunction(decl, _asFUNCTIONPR(__VA_ARGS__), asCALL_GENERIC);
-
-#define RegisterObjectMethodMPRasCALL_THISCALL(clsdcl,decl,clsfunc) RegisterObjectMethodMPRasCALL_THISCALL_2(clsdcl,decl,UNWRAP4 clsfunc)
-#define RegisterObjectMethodMPRasCALL_THISCALL_2(clsdcl,decl,...) RegisterObjectMethod(clsdcl,decl, WRAP_MFN_PR(__VA_ARGS__), asCALL_GENERIC);
-#define RegisterObjectMethodFPRasCALL_CDECL_OBJLAST(clsdcl,decl,fun) RegisterObjectMethodFPRasCALL_CDECL_OBJLAST_2(clsdcl,decl, UNWRAP3 fun);
-#define RegisterObjectMethodFPRasCALL_CDECL_OBJLAST_2(clsdcl,decl,...) RegisterObjectMethod(clsdcl,decl, WRAP_OBJ_LAST_PR(__VA_ARGS__), asCALL_GENERIC);
-#define RegisterObjectMethodFPRasCALL_CDECL_OBJFIRST(clsdcl,decl,fun) RegisterObjectMethodFPRasCALL_CDECL_OBJFIRST_2(clsdcl,decl, UNWRAP3 fun);
-#define RegisterObjectMethodFPRasCALL_CDECL_OBJFIRST_2(clsdcl,decl,...) RegisterObjectMethod(clsdcl,decl, WRAP_OBJ_FIRST_PR(__VA_ARGS__), asCALL_GENERIC);
-#define RegisterObjectMethodFPRasCALL_GENERIC(clsdcl,decl,fun) RegisterObjectMethodFPRasCALL_GENERIC_2(clsdcl,decl, UNWRAP3 fun);
-#define RegisterObjectMethodFPRasCALL_GENERIC_2(clsdcl,decl,...) RegisterObjectMethod(clsdcl,decl, _asFUNCTIONPR(__VA_ARGS__), asCALL_GENERIC);
-
-#define RegisterObjectBehaviorMPRasCALL_THISCALL(clsdcl,behavior,decl,clsfunc) RegisterObjectBehaviorMPRasCALL_THISCALL_2(clsdcl,behavior,decl,UNWRAP4 clsfunc)
-#define RegisterObjectBehaviorMPRasCALL_THISCALL_2(clsdcl,behavior,decl,...) RegisterObjectBehaviour(clsdcl,behavior,decl, WRAP_MFN_PR(__VA_ARGS__), asCALL_GENERIC);
-#define RegisterObjectBehaviorFPRasCALL_CDECL_OBJLAST(clsdcl,behavior,decl,clsfunc) RegisterObjectBehaviour(clsdcl,behavior,decl, WRAP_OBJ_LAST_PR clsfunc, asCALL_GENERIC);
-#define RegisterObjectBehaviorFPRasCALL_CDECL_OBJFIRST(clsdcl,behavior,decl,...) RegisterObjectBehaviour(clsdcl,behavior,decl, WRAP_OBJ_FIRST_PR(__VA_ARGS__), asCALL_GENERIC);
-#define RegisterObjectBehaviorFPRasCALL_GENERIC(clsdcl,behavior,decl,...) RegisterObjectBehaviour(clsdcl,behavior,decl, _asFUNCTIONPR(__VA_ARGS__), asCALL_GENERIC);
-#define RegisterObjectBehaviorFPRasCALL_CDECL(clsdcl,behavior,decl,clsfunc) RegisterObjectBehaviour(clsdcl,behavior,decl, WRAP_FN_PR clsfunc, asCALL_GENERIC);
-
-
-/*#define SetExceptionCallback(...) SetExceptionCallback_2(__VA_ARGS__)
-#define SetExceptionCallback_2(M,params,obj,kind) SetExceptionCallback(WRAP_MFN params, obj, asCALL_GENERIC);
-
-#define SetMessageCallback(...) SetMessageCallback_2(__VA_ARGS__)
-#define SetMessageCallback_2(M,params,obj,kind) SetMessageCallback(WRAP_MFN params, obj, asCALL_GENERIC);
-*/
-
-#endif
-

Source/Urho3D/CMakeLists.txt

@@ -399,6 +399,9 @@ foreach (DEFINE URHO3D_STATIC_DEFINE URHO3D_OPENGL URHO3D_D3D11 URHO3D_SSE URHO3
         set (APPENDIX "${APPENDIX}#define ${DEFINE}\n")
     endif ()
 endforeach()
+if (URHO3D_FORCE_AS_MAX_PORTABILITY)
+    set (APPENDIX "${APPENDIX}#define AS_MAX_PORTABILITY\n")
+endif ()
 generate_export_header (${TARGET_NAME} EXPORT_MACRO_NAME URHO3D_API EXPORT_FILE_NAME Urho3D.h.new CUSTOM_CONTENT_FROM_VARIABLE APPENDIX)
 file (READ Precompiled.h COPYRIGHT LIMIT 1128)
 file (READ ${CMAKE_CURRENT_BINARY_DIR}/Urho3D.h.new EXPORT_HEADER)
@@ -578,7 +581,7 @@ foreach (SUB ${OPTIONAL_SUBS})
         list (INSERT URHO_HEADERS ${FOUND_INDEX} "#if URHO3D_${SUB}")
     endif ()
 endforeach ()
-string (REGEX REPLACE "include/[^;]+(DebugNew|Direct3D|GraphicsImpl|IKConverters|ODBC|OpenGL|Precompiled|SQLite|ToluaUtils|Urho3D|librevision|wrap16\.h|wrap\.h)[^;]*;" "" URHO_HEADERS "${URHO_HEADERS};")
+string (REGEX REPLACE "include/[^;]+(DebugNew|Direct3D|GraphicsImpl|IKConverters|ODBC|OpenGL|Precompiled|SQLite|ToluaUtils|Urho3D|librevision|wrap\.h|aswrappedcall\.h)[^;]*;" "" URHO_HEADERS "${URHO_HEADERS};")
 string (REGEX REPLACE "include/([^;]+)" "#include <\\1>" URHO_HEADERS "${GENERATED_HEADERS};;${URHO_HEADERS}")
 string (REPLACE ";" \n URHO_HEADERS "${URHO_HEADERS}")
 configure_file (${CMAKE_CURRENT_SOURCE_DIR}/Urho3DAll.h.in ${CMAKE_CURRENT_BINARY_DIR}/Urho3DAll.h)
@@ -648,3 +651,7 @@ if (URHO3D_SCP_TO_TARGET)
     add_custom_command (TARGET ${TARGET_NAME} POST_BUILD COMMAND scp $<TARGET_FILE:${TARGET_NAME}> ${URHO3D_SCP_TO_TARGET} || exit 0
         COMMENT "Scp-ing Urho3D library to target system")
 endif ()
+
+if (URHO3D_FORCE_AS_MAX_PORTABILITY)
+    add_definitions (-DAS_MAX_PORTABILITY)
+endif ()

cmake/Modules/UrhoCommon.cmake

@@ -147,6 +147,7 @@ cmake_dependent_option (IOS "Setup build for iOS platform" FALSE "XCODE" FALSE)
 cmake_dependent_option (TVOS "Setup build for tvOS platform" FALSE "XCODE" FALSE)
 cmake_dependent_option (URHO3D_64BIT "Enable 64-bit build, the default is set based on the native ABI of the chosen compiler toolchain" "${NATIVE_64BIT}" "NOT MSVC AND NOT ANDROID AND NOT (ARM AND NOT IOS) AND NOT WEB AND NOT POWERPC" "${NATIVE_64BIT}")     # Intentionally only enable the option for iOS but not for tvOS as the latter is 64-bit only
 option (URHO3D_ANGELSCRIPT "Enable AngelScript scripting support" TRUE)
+cmake_dependent_option (URHO3D_FORCE_AS_MAX_PORTABILITY "Use generic calling convention for AngelScript on any platform" FALSE "URHO3D_ANGELSCRIPT" FALSE)
 option (URHO3D_IK "Enable inverse kinematics support" TRUE)
 option (URHO3D_LUA "Enable additional Lua scripting support" TRUE)
 option (URHO3D_NAVIGATION "Enable navigation support" TRUE)