AS Autobindings: Use template functions for default constructors; rename ClassFunction to Method (#2786)

Source/Tools/BindingGenerator/ASClassBinder.cpp

@@ -255,17 +255,17 @@ static void RegisterStaticFunction(const ClassStaticFunctionAnalyzer& functionAn
     result->reg_ << "    engine->SetDefaultNamespace(\"\");\n";
 }
 
-static void RegisterRefCountedConstructor(const ClassFunctionAnalyzer& functionAnalyzer, bool templateVersion)
+static void RegisterRefCountedConstructor(const MethodAnalyzer& methodAnalyzer, bool templateVersion)
 {
-    string className = functionAnalyzer.GetClassName();
-    string wrapperName = GenerateWrapperName(functionAnalyzer, templateVersion);
-    string header = functionAnalyzer.GetClass().GetHeaderFile();
+    string className = methodAnalyzer.GetClassName();
+    string wrapperName = GenerateWrapperName(methodAnalyzer, templateVersion);
+    string header = methodAnalyzer.GetClass().GetHeaderFile();
     string insideDefine = InsideDefine(header);
 
-    string args = ExtractCleanedFunctionArgsstring(functionAnalyzer.GetMemberdef());
+    string args = ExtractCleanedFunctionArgsstring(methodAnalyzer.GetMemberdef());
 
     //shared_ptr<ASGeneratedFile_Members> result = GetGeneratedFile(functionAnalyzer.GetClass().GetClassName());
-    ASGeneratedFile_Base* result = templateVersion ? (ASGeneratedFile_Base*)_result_Templates.get() : (ASGeneratedFile_Base*)GetGeneratedFile(functionAnalyzer.GetClass().GetClassName()).get();
+    ASGeneratedFile_Base* result = templateVersion ? (ASGeneratedFile_Base*)_result_Templates.get() : (ASGeneratedFile_Base*)GetGeneratedFile(methodAnalyzer.GetClass().GetClassName()).get();
 
     bool firstContext = StartsWith(args, "Context *context");
     if (firstContext)
@@ -276,12 +276,12 @@ static void RegisterRefCountedConstructor(const ClassFunctionAnalyzer& functionA
     else if (Contains(args, "Context"))
     {
         result->reg_ <<
-            "    // " << functionAnalyzer.GetLocation() << "\n"
+            "    // " << methodAnalyzer.GetLocation() << "\n"
             "    // Error: context can be only first\n";
         return;
     }
 
-    string cppParamsNames = functionAnalyzer.JoinParamsNames(firstContext);
+    string cppParamsNames = methodAnalyzer.JoinParamsNames(firstContext);
 
     if (firstContext)
     {
@@ -291,7 +291,7 @@ static void RegisterRefCountedConstructor(const ClassFunctionAnalyzer& functionA
     }
 
     string decl = "";
-    vector<ParamAnalyzer> params = functionAnalyzer.GetParams();
+    vector<ParamAnalyzer> params = methodAnalyzer.GetParams();
     for (unsigned i = 0; i < params.size(); i++)
     {
         ParamAnalyzer param = params[i];
@@ -312,7 +312,7 @@ static void RegisterRefCountedConstructor(const ClassFunctionAnalyzer& functionA
         catch (const Exception& e)
         {
             result->reg_ <<
-                "    // " << functionAnalyzer.GetLocation() << "\n"
+                "    // " << methodAnalyzer.GetLocation() << "\n"
                 "    // " << e.what() << "\n";
             return;
         }
@@ -331,7 +331,7 @@ static void RegisterRefCountedConstructor(const ClassFunctionAnalyzer& functionA
     if (templateVersion)
     {
         result->reg_ <<
-            "    // " << functionAnalyzer.GetLocation() << "\n"
+            "    // " << methodAnalyzer.GetLocation() << "\n"
             "    {\n"
             "        String declFactory(String(className) + \"@ f()\");\n"
             "        engine->RegisterObjectBehaviour(className, "
@@ -344,7 +344,7 @@ static void RegisterRefCountedConstructor(const ClassFunctionAnalyzer& functionA
     else
     {
         result->reg_ <<
-            "    // " << functionAnalyzer.GetLocation() << "\n"
+            "    // " << methodAnalyzer.GetLocation() << "\n"
             "    engine->RegisterObjectBehaviour("
             "\"" << className << "\", "
             "asBEHAVE_FACTORY, "
@@ -357,7 +357,7 @@ static void RegisterRefCountedConstructor(const ClassFunctionAnalyzer& functionA
         result->glue_ << "#ifdef " << insideDefine << "\n";
 
     result->glue_ <<
-        "// " << functionAnalyzer.GetLocation() << "\n"
+        "// " << methodAnalyzer.GetLocation() << "\n"
         "static " << className << "* " << wrapperName << "(" << args << ")\n"
         "{\n"
         "    return new " << className << "(" << cppParamsNames << ");\n"
@@ -369,14 +369,14 @@ static void RegisterRefCountedConstructor(const ClassFunctionAnalyzer& functionA
     result->glue_ << "\n";
 }
 
-static void RegisterValueConstructor(const ClassFunctionAnalyzer& functionAnalyzer, bool templateVersion)
+static void RegisterValueConstructor(const MethodAnalyzer& methodAnalyzer, bool templateVersion)
 {
-    string header = functionAnalyzer.GetClass().GetHeaderFile();
+    string header = methodAnalyzer.GetClass().GetHeaderFile();
     string insideDefine = InsideDefine(header);
-    string className = functionAnalyzer.GetClassName();
-    string wrapperName = GenerateWrapperName(functionAnalyzer, templateVersion);
+    string className = methodAnalyzer.GetClassName();
+    string wrapperName = GenerateWrapperName(methodAnalyzer, templateVersion);
     
-    string args = ExtractCleanedFunctionArgsstring(functionAnalyzer.GetMemberdef());
+    string args = ExtractCleanedFunctionArgsstring(methodAnalyzer.GetMemberdef());
 
     shared_ptr<ASGeneratedFile_Members> result = GetGeneratedFile(className);
 
@@ -389,7 +389,7 @@ static void RegisterValueConstructor(const ClassFunctionAnalyzer& functionAnalyz
     stringstream& glue = result->glue_;
 
     string decl = "";
-    vector<ParamAnalyzer> params = functionAnalyzer.GetParams();
+    vector<ParamAnalyzer> params = methodAnalyzer.GetParams();
     for (ParamAnalyzer param : params)
     {
         if (decl.length() > 0)
@@ -405,7 +405,7 @@ static void RegisterValueConstructor(const ClassFunctionAnalyzer& functionAnalyz
                 reg << "#ifdef " << insideDefine << "\n";
 
             reg <<
-                "    // " << functionAnalyzer.GetLocation() << "\n"
+                "    // " << methodAnalyzer.GetLocation() << "\n"
                 "    // " << e.what() << "\n";
 
             if (isDefaultConstructor && !insideDefine.empty())
@@ -428,7 +428,7 @@ static void RegisterValueConstructor(const ClassFunctionAnalyzer& functionAnalyz
         reg << "#ifdef " << insideDefine << "\n";
 
     reg <<
-        "    // " << functionAnalyzer.GetLocation() << "\n"
+        "    // " << methodAnalyzer.GetLocation() << "\n"
         "    engine->RegisterObjectBehaviour("
         "\"" << className << "\", "
         "asBEHAVE_CONSTRUCT, "
@@ -443,7 +443,7 @@ static void RegisterValueConstructor(const ClassFunctionAnalyzer& functionAnalyz
         glue << "#ifdef " << insideDefine << "\n";
 
     glue <<
-        "// " << functionAnalyzer.GetLocation() << "\n"
+        "// " << methodAnalyzer.GetLocation() << "\n"
         "static void " << wrapperName << "(" << className << "* ptr";
 
     if (args.length() > 0)
@@ -451,7 +451,7 @@ static void RegisterValueConstructor(const ClassFunctionAnalyzer& functionAnalyz
 
     glue << ")\n"
         "{\n"
-        "    new(ptr) " << className << "(" << functionAnalyzer.JoinParamsNames() << ");\n"
+        "    new(ptr) " << className << "(" << methodAnalyzer.JoinParamsNames() << ");\n"
         "}\n";
 
     if (isDefaultConstructor && !insideDefine.empty())
@@ -476,7 +476,7 @@ static void TryRegisterImplicitlyDeclaredAssignOperator(const ClassAnalyzer& cla
 // Some required methods can not be bound automatically when processing class because implicitly-declared
 static void RegisterImplicitlyDeclaredMethods(const ClassAnalyzer& classAnalyzer)
 {
-    if (!classAnalyzer.ContainsFunction("operator="))
+    if (!classAnalyzer.ContainsMethod("operator="))
         TryRegisterImplicitlyDeclaredAssignOperator(classAnalyzer);
 
     // No need register impicitly declared copy constructor when registered opAssign operator
@@ -486,8 +486,8 @@ static void RegisterComparisonOperator(const ClassAnalyzer& classAnalyzer)
 {
     string className = classAnalyzer.GetClassName();
     string wrapperName = className + "_Comparison";
-    string operatorLessLocation = classAnalyzer.GetFunction("operator<")->GetLocation();
-    string operatorGreaterLocation = classAnalyzer.GetFunction("operator>")->GetLocation();
+    string operatorLessLocation = classAnalyzer.GetMethod("operator<")->GetLocation();
+    string operatorGreaterLocation = classAnalyzer.GetMethod("operator>")->GetLocation();
     shared_ptr<ASGeneratedFile_Members> result = GetGeneratedFile(className);
 
     result->glue_ <<
@@ -508,16 +508,16 @@ static void RegisterComparisonOperator(const ClassAnalyzer& classAnalyzer)
         "    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)
+static void RegisterAddReleaseRef(const MethodAnalyzer& methodAnalyzer, bool templateVersion)
 {
-    string className = functionAnalyzer.GetClassName();
+    string className = methodAnalyzer.GetClassName();
     //shared_ptr<ASGeneratedFile_Members> result = GetGeneratedFile(className);
-    ASGeneratedFile_Base* result = templateVersion ? (ASGeneratedFile_Base*)_result_Templates.get() : (ASGeneratedFile_Base*)GetGeneratedFile(functionAnalyzer.GetClass().GetClassName()).get();
-    string functionName = functionAnalyzer.GetName();
+    ASGeneratedFile_Base* result = templateVersion ? (ASGeneratedFile_Base*)_result_Templates.get() : (ASGeneratedFile_Base*)GetGeneratedFile(methodAnalyzer.GetClass().GetClassName()).get();
+    string functionName = methodAnalyzer.GetName();
     string behaviour = (functionName == "AddRef") ? "asBEHAVE_ADDREF" : "asBEHAVE_RELEASE";
-    string methodpr = Generate_asMETHODPR(functionAnalyzer, templateVersion);
+    string methodpr = Generate_asMETHODPR(methodAnalyzer, templateVersion);
 
-    result->reg_ << "    // " << functionAnalyzer.GetLocation() << "\n";
+    result->reg_ << "    // " << methodAnalyzer.GetLocation() << "\n";
 
     if (templateVersion)
         result->reg_ << "    engine->RegisterObjectBehaviour(className, " << behaviour << ", \"void f()\", "  << methodpr << ", AS_CALL_THISCALL);\n";
@@ -536,9 +536,9 @@ static void RegisterFakeAddReleaseRef(const ClassAnalyzer& classAnalyzer)
 }
 
 // https://www.angelcode.com/angelscript/sdk/docs/manual/doc_script_class_ops.html
-static string CppMethodNameToAS(const ClassFunctionAnalyzer& functionAnalyzer)
+static string CppMethodNameToAS(const MethodAnalyzer& methodAnalyzer)
 {
-    string name = functionAnalyzer.GetName();
+    string name = methodAnalyzer.GetName();
 
     if (name == "operator=")
         return "opAssign";
@@ -548,7 +548,7 @@ static string CppMethodNameToAS(const ClassFunctionAnalyzer& functionAnalyzer)
 
     if (name == "operator-")
     {
-        if (!functionAnalyzer.GetParams().size()) // If no params
+        if (!methodAnalyzer.GetParams().size()) // If no params
             return "opNeg";               // then unary minus
         else
             return "opSub";
@@ -581,7 +581,7 @@ static string CppMethodNameToAS(const ClassFunctionAnalyzer& functionAnalyzer)
     // Conversion to another type operator
     if (StartsWith(name, "operator "))
     {
-        if (functionAnalyzer.IsExplicit())
+        if (methodAnalyzer.IsExplicit())
             return "opConv";
         else
             return "opImplConv";
@@ -600,12 +600,12 @@ static string CppMethodNameToAS(const ClassFunctionAnalyzer& functionAnalyzer)
 }
 
 // Iterate over overrided funcions
-static bool HaveMark(const ClassFunctionAnalyzer& functionAnalyzer, const string& mark)
+static bool HaveMark(const MethodAnalyzer& methodAnalyzer, const string& mark)
 {
-    if (Contains(functionAnalyzer.GetComment(), mark))
+    if (Contains(methodAnalyzer.GetComment(), mark))
         return true;
 
-    shared_ptr<ClassFunctionAnalyzer> reimplements = functionAnalyzer.Reimplements();
+    shared_ptr<MethodAnalyzer> reimplements = methodAnalyzer.Reimplements();
 
     if (!reimplements)
         return false;
@@ -615,9 +615,9 @@ static bool HaveMark(const ClassFunctionAnalyzer& functionAnalyzer, const string
 
 // Can return BIND_AS_ALIAS_xxxx or BIND_AS_PROPERTY
 // Return "" if no this marks
-static string GetPropertyMark(ClassFunctionAnalyzer function)
+static string GetPropertyMark(const MethodAnalyzer& methodAnalyzer)
 {
-    string comment = function.GetComment();
+    string comment = methodAnalyzer.GetComment();
 
     smatch match;
     regex_match(comment, match, regex(".*\\b(BIND_AS_ALIAS_.+?)\\b.*"));
@@ -628,7 +628,7 @@ static string GetPropertyMark(ClassFunctionAnalyzer function)
     if (match.size() == 1)
         return "BIND_AS_PROPERTY";
 
-    shared_ptr<ClassFunctionAnalyzer> reimplements = function.Reimplements();
+    shared_ptr<MethodAnalyzer> reimplements = methodAnalyzer.Reimplements();
 
     if (!reimplements)
         return "";
@@ -637,9 +637,9 @@ static string GetPropertyMark(ClassFunctionAnalyzer function)
 }
 
 // https://www.angelcode.com/angelscript/sdk/docs/manual/doc_reg_objprop.html
-static string CppMethodNameToASProperty(const ClassFunctionAnalyzer& functionAnalyzer)
+static string CppMethodNameToASProperty(const MethodAnalyzer& methodAnalyzer)
 {
-    string name = functionAnalyzer.GetName();
+    string name = methodAnalyzer.GetName();
 
     if (StartsWith(name, "Is") || StartsWith(name, "Get"))
     {
@@ -656,14 +656,14 @@ static string CppMethodNameToASProperty(const ClassFunctionAnalyzer& functionAna
         return result;
     }
 
-    if (functionAnalyzer.CanBeGetProperty())
+    if (methodAnalyzer.CanBeGetProperty())
     {
         string result = name;
         result = "get_" + FirstCharToLower(result);
         return result;
     }
 
-    if (functionAnalyzer.CanBeSetProperty())
+    if (methodAnalyzer.CanBeSetProperty())
     {
         string result = name;
         result = "set_" + FirstCharToLower(result);
@@ -673,65 +673,65 @@ static string CppMethodNameToASProperty(const ClassFunctionAnalyzer& functionAna
     throw Exception("Can not be property");
 }
 
-static void RegisterMethod(const ClassFunctionAnalyzer& functionAnalyzer, bool templateVersion)
+static void RegisterMethod(const MethodAnalyzer& methodAnalyzer, bool templateVersion)
 {
-    if (functionAnalyzer.IsDefine()) // URHO3D_OBJECT
+    if (methodAnalyzer.IsDefine()) // URHO3D_OBJECT
         return; 
     
-    if (!functionAnalyzer.IsPublic())
+    if (!methodAnalyzer.IsPublic())
         return;
 
-    if (functionAnalyzer.IsParentDestructor())
+    if (methodAnalyzer.IsParentDestructor())
         return;
 
-    if (functionAnalyzer.IsParentConstructor())
+    if (methodAnalyzer.IsParentConstructor())
         return;
 
     //shared_ptr<ASGeneratedFile_Members> result = GetGeneratedFile(functionAnalyzer.GetClass().GetClassName());
-    ASGeneratedFile_Base* result = templateVersion ? (ASGeneratedFile_Base*)_result_Templates.get() : (ASGeneratedFile_Base*)GetGeneratedFile(functionAnalyzer.GetClass().GetClassName()).get();
+    ASGeneratedFile_Base* result = templateVersion ? (ASGeneratedFile_Base*)_result_Templates.get() : (ASGeneratedFile_Base*)GetGeneratedFile(methodAnalyzer.GetClass().GetClassName()).get();
 
-    if (HaveMark(functionAnalyzer, "NO_BIND"))
+    if (HaveMark(methodAnalyzer, "NO_BIND"))
     {
-        result->reg_ << "    // " << functionAnalyzer.GetLocation() << "\n";
+        result->reg_ << "    // " << methodAnalyzer.GetLocation() << "\n";
         result->reg_ << "    // Not registered because have @nobind mark\n";
         return;
     }
 
-    if (HaveMark(functionAnalyzer, "MANUAL_BIND"))
+    if (HaveMark(methodAnalyzer, "MANUAL_BIND"))
     {
-        result->reg_ << "    // " << functionAnalyzer.GetLocation() << "\n";
+        result->reg_ << "    // " << methodAnalyzer.GetLocation() << "\n";
         result->reg_ << "    // Not registered because have @manualbind mark\n";
         return;
     }
 
-    if (functionAnalyzer.IsTemplate())
+    if (methodAnalyzer.IsTemplate())
     {
-        result->reg_ << "    // " << functionAnalyzer.GetLocation() << "\n";
+        result->reg_ << "    // " << methodAnalyzer.GetLocation() << "\n";
         result->reg_ << "    // Not registered because template\n";
         return;
     }
 
-    if (functionAnalyzer.IsStatic())
+    if (methodAnalyzer.IsStatic())
     {
-        ClassStaticFunctionAnalyzer classStaticFunctionAnalyzer(functionAnalyzer.GetClass(), functionAnalyzer.GetMemberdef());
+        ClassStaticFunctionAnalyzer classStaticFunctionAnalyzer(methodAnalyzer.GetClass(), methodAnalyzer.GetMemberdef());
         RegisterStaticFunction(classStaticFunctionAnalyzer, result);
         return;
     }
 
-    if (functionAnalyzer.IsDeleted())
+    if (methodAnalyzer.IsDeleted())
         return;
 
     /*if (function.IsPureVirtual()) // Register pure virtual function but not register constructor for this class
         return;*/
 
     // Do not register destructor for refcounted because object is deleted by himself
-    if (functionAnalyzer.IsThisDestructor()
-        && (functionAnalyzer.GetClass().IsRefCounted() || Contains(functionAnalyzer.GetClass().GetComment(), "FAKE_REF")))
+    if (methodAnalyzer.IsThisDestructor()
+        && (methodAnalyzer.GetClass().IsRefCounted() || Contains(methodAnalyzer.GetClass().GetComment(), "FAKE_REF")))
     {
         return;
     }
 
-    string functionName = functionAnalyzer.GetName();
+    string functionName = methodAnalyzer.GetName();
 
     if (functionName == "operator!=")
         return;
@@ -742,34 +742,34 @@ static void RegisterMethod(const ClassFunctionAnalyzer& functionAnalyzer, bool t
 
     if (functionName == "AddRef" || functionName == "ReleaseRef")
     {
-        RegisterAddReleaseRef(functionAnalyzer, templateVersion);
+        RegisterAddReleaseRef(methodAnalyzer, templateVersion);
         return;
     }
 
-    if (functionAnalyzer.IsThisConstructor())
+    if (methodAnalyzer.IsThisConstructor())
     {
-        if (functionAnalyzer.GetClass().IsRefCounted() || Contains(functionAnalyzer.GetClass().GetComment(), "FAKE_REF"))
+        if (methodAnalyzer.GetClass().IsRefCounted() || Contains(methodAnalyzer.GetClass().GetComment(), "FAKE_REF"))
         {
             // Do not register construnctor for abstract class
-            if (functionAnalyzer.GetClass().IsAbstract())
+            if (methodAnalyzer.GetClass().IsAbstract())
                 return;
 
-            RegisterRefCountedConstructor(functionAnalyzer, templateVersion);
+            RegisterRefCountedConstructor(methodAnalyzer, templateVersion);
         }
         else
         {
-            RegisterValueConstructor(functionAnalyzer, templateVersion);
+            RegisterValueConstructor(methodAnalyzer, templateVersion);
         }
         
         return;
     }
 
-    if (functionAnalyzer.IsThisDestructor())
+    if (methodAnalyzer.IsThisDestructor())
         return;
 
-    result->reg_ << "    // " << functionAnalyzer.GetLocation() << "\n";
+    result->reg_ << "    // " << methodAnalyzer.GetLocation() << "\n";
 
-    vector<ParamAnalyzer> params = functionAnalyzer.GetParams();
+    vector<ParamAnalyzer> params = methodAnalyzer.GetParams();
     vector<ConvertedVariable> convertedParams;
     bool needWrapper = false;
 
@@ -797,7 +797,7 @@ static void RegisterMethod(const ClassFunctionAnalyzer& functionAnalyzer, bool t
     
     try
     {
-        retConv = CppVariableToAS(functionAnalyzer.GetReturnType(), VariableUsage::FunctionReturn);
+        retConv = CppVariableToAS(methodAnalyzer.GetReturnType(), VariableUsage::FunctionReturn);
     }
     catch (const Exception& e)
     {
@@ -810,13 +810,13 @@ static void RegisterMethod(const ClassFunctionAnalyzer& functionAnalyzer, bool t
 
     string asReturnType = retConv.asDeclaration_;
 
-    string asFunctionName = functionAnalyzer.GetName();
-    if (functionAnalyzer.IsConsversionOperator())
+    string asFunctionName = methodAnalyzer.GetName();
+    if (methodAnalyzer.IsConsversionOperator())
         asReturnType = CutStart(asFunctionName, "operator ");
     
     try
     {
-        asFunctionName = CppMethodNameToAS(functionAnalyzer);
+        asFunctionName = CppMethodNameToAS(methodAnalyzer);
     }
     catch (const Exception& e)
     {
@@ -825,25 +825,25 @@ static void RegisterMethod(const ClassFunctionAnalyzer& functionAnalyzer, bool t
     }
 
     if (needWrapper)
-        result->glue_ << GenerateWrapper(functionAnalyzer, templateVersion, convertedParams, retConv);
+        result->glue_ << GenerateWrapper(methodAnalyzer, templateVersion, convertedParams, retConv);
 
     string decl = asReturnType + " " + asFunctionName + "(" + JoinASDeclarations(convertedParams) + ")";
 
-    if (functionAnalyzer.IsConst())
+    if (methodAnalyzer.IsConst())
         decl += " const";
 
     if (templateVersion)
         result->reg_ << "    engine->RegisterObjectMethod(className, \"" << decl << "\", ";
     else
-        result->reg_ << "    engine->RegisterObjectMethod(\"" << functionAnalyzer.GetClassName() << "\", \"" << decl << "\", ";
+        result->reg_ << "    engine->RegisterObjectMethod(\"" << methodAnalyzer.GetClassName() << "\", \"" << decl << "\", ";
 
     if (needWrapper)
-        result->reg_ << "AS_FUNCTION_OBJFIRST(" << GenerateWrapperName(functionAnalyzer, templateVersion) << "), AS_CALL_CDECL_OBJFIRST);\n";
+        result->reg_ << "AS_FUNCTION_OBJFIRST(" << GenerateWrapperName(methodAnalyzer, templateVersion) << "), AS_CALL_CDECL_OBJFIRST);\n";
     else
-        result->reg_ << Generate_asMETHODPR(functionAnalyzer, templateVersion) << ", AS_CALL_THISCALL);\n";
+        result->reg_ << Generate_asMETHODPR(methodAnalyzer, templateVersion) << ", AS_CALL_THISCALL);\n";
 
     // Also register as property if needed
-    string propertyMark = GetPropertyMark(functionAnalyzer);
+    string propertyMark = GetPropertyMark(methodAnalyzer);
     if (!propertyMark.empty())
     {
         if (StartsWith(propertyMark, "BIND_AS_ALIAS_"))
@@ -854,7 +854,7 @@ static void RegisterMethod(const ClassFunctionAnalyzer& functionAnalyzer, bool t
         {
             try
             {
-                asFunctionName = CppMethodNameToASProperty(functionAnalyzer);
+                asFunctionName = CppMethodNameToASProperty(methodAnalyzer);
             }
             catch (const Exception& e)
             {
@@ -865,18 +865,18 @@ static void RegisterMethod(const ClassFunctionAnalyzer& functionAnalyzer, bool t
         
         decl = asReturnType + " " + asFunctionName + "(" + JoinASDeclarations(convertedParams) + ")";
 
-        if (functionAnalyzer.IsConst())
+        if (methodAnalyzer.IsConst())
             decl += " const";
 
         if (templateVersion)
             result->reg_ << "    engine->RegisterObjectMethod(className, \"" << decl << "\", ";
         else
-            result->reg_ << "    engine->RegisterObjectMethod(\"" << functionAnalyzer.GetClassName() << "\", \"" << decl << "\", ";
+            result->reg_ << "    engine->RegisterObjectMethod(\"" << methodAnalyzer.GetClassName() << "\", \"" << decl << "\", ";
 
         if (needWrapper)
-            result->reg_ << "AS_FUNCTION_OBJFIRST(" << GenerateWrapperName(functionAnalyzer, templateVersion) << "), AS_CALL_CDECL_OBJFIRST);\n";
+            result->reg_ << "AS_FUNCTION_OBJFIRST(" << GenerateWrapperName(methodAnalyzer, templateVersion) << "), AS_CALL_CDECL_OBJFIRST);\n";
         else
-            result->reg_ << Generate_asMETHODPR(functionAnalyzer, templateVersion) << ", AS_CALL_THISCALL);\n";
+            result->reg_ << Generate_asMETHODPR(methodAnalyzer, templateVersion) << ", AS_CALL_THISCALL);\n";
     }
 }
 
@@ -993,14 +993,14 @@ static void RegisterObjectMembers(const ClassAnalyzer& classAnalyzer, bool templ
     for (ClassVariableAnalyzer variable : variables)
         RegisterClassVarAsProperty(variable);
 
-    vector<ClassFunctionAnalyzer> functions = classAnalyzer.GetFunctions();
-    for (ClassFunctionAnalyzer function : functions)
-        RegisterMethod(function, templateVersion);
+    vector<MethodAnalyzer> methods = classAnalyzer.GetAllMethods();
+    for (const MethodAnalyzer& method : methods)
+        RegisterMethod(method, templateVersion);
 
     RegisterImplicitlyDeclaredMethods(classAnalyzer);
 
     // 2 operators is replaced by single function opCmp
-    if (classAnalyzer.ContainsFunction("operator>") || classAnalyzer.ContainsFunction("operator>"))
+    if (classAnalyzer.ContainsMethod("operator>") || classAnalyzer.ContainsMethod("operator>"))
         RegisterComparisonOperator(classAnalyzer);
 
     if (Contains(classAnalyzer.GetComment(), "FAKE_REF"))

Source/Tools/BindingGenerator/ASClassBinderNew.cpp

@@ -90,40 +90,65 @@ static bool IsDestructorRequired(const ClassAnalyzer& classAnalyzer)
     return true;
 }
 
-static void RegisterDefaultConstructor(const ClassAnalyzer& classAnalyzer, ProcessedClass& processedClass)
+// Iterate over overrided funcions
+static bool HaveMark(const MethodAnalyzer& methodAnalyzer, const string& mark)
 {
-    if (classAnalyzer.IsRefCounted())
-        return;
+    if (Contains(methodAnalyzer.GetComment(), mark))
+        return true;
 
-    if (Contains(classAnalyzer.GetComment(), "FAKE_REF"))
-        return;
+    shared_ptr<MethodAnalyzer> reimplements = methodAnalyzer.Reimplements();
 
-    string className = classAnalyzer.GetClassName();
-    string wrapperName = className + "_Constructor";
-
-    shared_ptr<ClassMemberRegistration> result = make_shared<ClassMemberRegistration>();
+    if (!reimplements)
+        return false;
 
-    result->name_ = className;
+    return HaveMark(*reimplements, mark);
+}
 
-    result->glue_ =
-        "static void " + wrapperName + "(" + className + "* ptr)\n"
-        "{\n"
-        "    new(ptr) " + className + "();\n"
-        "}\n";
+static void RegisterConstructor(const MethodAnalyzer& methodAnalyzer, ProcessedClass& processedClass)
+{
+    ClassAnalyzer classAnalyzer = methodAnalyzer.GetClass();
 
-    result->registration_ = "engine->RegisterObjectBehaviour(\"" + className + "\", asBEHAVE_CONSTRUCT, \"void f()\", AS_FUNCTION_OBJFIRST(" + wrapperName + "), AS_CALL_CDECL_OBJFIRST);";
+    if (classAnalyzer.IsAbstract())
+        return;
 
-    shared_ptr<ClassFunctionAnalyzer> defaultConstructor = classAnalyzer.GetDefinedThisDefaultConstructor();
+    if (HaveMark(methodAnalyzer, "NO_BIND"))
+    {
+        RegistrationError regError;
+        regError.comment_ = methodAnalyzer.GetDeclaration();
+        regError.message_ = "Not registered because have @nobind mark";
+        processedClass.unregisteredSpecialMethods_.push_back(regError);
+        return;
+    }
 
-    if (defaultConstructor)
+    if (HaveMark(methodAnalyzer, "MANUAL_BIND"))
     {
-        result->comment_ = defaultConstructor->GetLocation();
-        processedClass.defaultConstructor_ = result;
+        RegistrationError regError;
+        regError.comment_ = methodAnalyzer.GetDeclaration();
+        regError.message_ = "Not registered because have @manualbind mark";
+        processedClass.unregisteredSpecialMethods_.push_back(regError);
+        return;
     }
-    else if (!classAnalyzer.HasThisConstructor() && IsConstructorRequired(classAnalyzer))
+
+    MemberRegistration result;
+    result.name_ = methodAnalyzer.GetName();
+    result.comment_ = methodAnalyzer.GetDeclaration();
+    
+    string asClassName = classAnalyzer.GetClassName();
+    string cppClassName = classAnalyzer.GetClassName();
+    vector<ParamAnalyzer> params = methodAnalyzer.GetParams();
+
+    if (params.empty()) // Default constructor
     {
-        result->comment_ = className + "::" + className + "() | Implicitly-declared";
-        processedClass.defaultConstructor_ = result;
+        if (classAnalyzer.IsRefCounted() || Contains(classAnalyzer.GetComment(), "FAKE_REF"))
+        {
+        }
+        else
+        {
+            result.comment_ = methodAnalyzer.GetLocation(); // Rewrite comment
+            result.registration_ = "engine->RegisterObjectBehaviour(\"" + asClassName + "\", asBEHAVE_CONSTRUCT, \"void f()\", asFUNCTION(ASCompatibleConstructor<" + cppClassName + ">), AS_CALL_CDECL_OBJFIRST);";
+            processedClass.defaultConstructor_ = make_shared<MemberRegistration>(result);
+            return;
+        }
     }
 }
 
@@ -138,13 +163,13 @@ static void RegisterDestructor(const ClassAnalyzer& classAnalyzer, ProcessedClas
     string className = classAnalyzer.GetClassName();
     string wrapperName = className + "_Destructor";
 
-    shared_ptr<ClassMemberRegistration> result = make_shared<ClassMemberRegistration>();
+    shared_ptr<MemberRegistration> result = make_shared<MemberRegistration>();
 
     result->name_ = "~" + className;
 
     result->registration_ = "engine->RegisterObjectBehaviour(\"" + className + "\", asBEHAVE_DESTRUCT, \"void f()\", AS_DESTRUCTOR(" + className + "), AS_CALL_CDECL_OBJFIRST);";
 
-    shared_ptr<ClassFunctionAnalyzer> thisDestructor = classAnalyzer.GetDefinedThisDestructor();
+    shared_ptr<MethodAnalyzer> thisDestructor = classAnalyzer.GetDefinedThisDestructor();
 
     if (thisDestructor)
     {
@@ -158,11 +183,6 @@ static void RegisterDestructor(const ClassAnalyzer& classAnalyzer, ProcessedClas
     }
 }
 
-static void RegisterNonDefaultConstructor(const ClassFunctionAnalyzer& classFunctionAnalyzer, ProcessedClass& processedClass)
-{
-    processedClass.nonDefaultConstructors_.push_back(classFunctionAnalyzer.GetLocation());
-}
-
 static void ProcessClass(const ClassAnalyzer& classAnalyzer)
 {
     if (classAnalyzer.IsInternal())
@@ -183,6 +203,13 @@ static void ProcessClass(const ClassAnalyzer& classAnalyzer)
     processedClass.comment_ = classAnalyzer.GetLocation();
     processedClass.insideDefine_ = InsideDefine(header);
 
+    vector<MethodAnalyzer> methods = classAnalyzer.GetThisPublicMethods();
+    for (const MethodAnalyzer& method : methods)
+    {
+        if (method.IsThisConstructor())
+            RegisterConstructor(method, processedClass);
+    }
+
     // CollectMembers()
 
     if (classAnalyzer.IsAbstract() && !(classAnalyzer.IsRefCounted() || Contains(classAnalyzer.GetComment(), "FAKE_REF")))
@@ -223,13 +250,21 @@ static void ProcessClass(const ClassAnalyzer& classAnalyzer)
         return;
     }
 
-    // RegisterSpecialMethods()
-
-    RegisterDefaultConstructor(classAnalyzer, processedClass);
-
-    vector<ClassFunctionAnalyzer> nonDefaultConstructors = classAnalyzer.GetThisNonDefaultConstructors();
-    for (const ClassFunctionAnalyzer& classFunctionAnalyzer : nonDefaultConstructors)
-        RegisterNonDefaultConstructor(classFunctionAnalyzer, processedClass);
+    if (!classAnalyzer.HasThisConstructor() && IsConstructorRequired(classAnalyzer))
+    {
+        if (classAnalyzer.IsRefCounted() || Contains(classAnalyzer.GetComment(), "FAKE_REF"))
+        {
+        }
+        else
+        {
+            shared_ptr<MemberRegistration> result = make_shared<MemberRegistration>();
+            string cppClassName = classAnalyzer.GetClassName();
+            string asClassName = classAnalyzer.GetClassName();
+            result->comment_ = cppClassName + "::" + cppClassName + "() | Implicitly-declared";
+            result->registration_ = "engine->RegisterObjectBehaviour(\"" + asClassName + "\", asBEHAVE_CONSTRUCT, \"void f()\", asFUNCTION(ASCompatibleConstructor<" + cppClassName + ">), AS_CALL_CDECL_OBJFIRST);";
+            processedClass.defaultConstructor_ = result;
+        }
+    }
 
     RegisterDestructor(classAnalyzer, processedClass);
 

Source/Tools/BindingGenerator/ASResult.cpp

@@ -459,6 +459,9 @@ namespace Result
             if (!processedClass.defaultConstructor_)
                 continue;
 
+            if (processedClass.defaultConstructor_->glue_.empty())
+                continue;
+
             if (processedClass.insideDefine_ != openedDefine && !openedDefine.empty())
             {
                 ofs << "\n#endif\n";
@@ -496,6 +499,9 @@ namespace Result
             if (!processedClass.defaultConstructor_)
                 continue;
 
+            if (processedClass.noBind_)
+                continue;
+
             if (processedClass.insideDefine_ != openedDefine && !openedDefine.empty())
             {
                 ofs << "#endif\n";
@@ -584,6 +590,18 @@ namespace Result
 
             bool needGap = false;
 
+            for (const RegistrationError& regError : processedClass.unregisteredSpecialMethods_)
+            {
+                if (needGap)
+                    ofs << '\n';
+
+                ofs <<
+                    "    // " << regError.comment_ << "\n"
+                    "    // " << regError.message_ << "\n";
+
+                needGap = true;
+            }
+
             /*
             for (string nonDefaultConstructor : processedClass.nonDefaultConstructors_)
                 ofs << "    // " << nonDefaultConstructor << "\n";
@@ -591,6 +609,9 @@ namespace Result
 
             if (processedClass.destructor_)
             {
+                if (needGap)
+                    ofs << '\n';
+
                 ofs <<
                     "    // " << processedClass.destructor_->comment_ << "\n"
                     "    " << processedClass.destructor_->registration_ << "\n";

Source/Tools/BindingGenerator/ASResult.h

@@ -112,14 +112,20 @@ struct ProcessedGlobalVariable
     bool operator <(const ProcessedGlobalVariable& rhs) const;
 };
 
-struct ClassMemberRegistration
+struct MemberRegistration
 {
     string name_; // Used for sorting
-    string comment_; // Cpp declaration or location
+    string comment_; // C++ declaration / location
     string glue_; // Can be empty
     string registration_; // Or warning message
 };
 
+struct RegistrationError
+{
+    string comment_; // C++ declaration / location
+    string message_;
+};
+
 struct ProcessedClass
 {
     string name_;
@@ -130,15 +136,20 @@ struct ProcessedClass
     // Used for sorting
     bool operator <(const ProcessedClass& rhs) const;
 
-    shared_ptr<ClassMemberRegistration> defaultConstructor_;
-    shared_ptr<ClassMemberRegistration> destructor_;
+    shared_ptr<MemberRegistration> defaultConstructor_;
+    vector<MemberRegistration> nonDefaultConstructors_;
+
+
+
+    shared_ptr<MemberRegistration> destructor_;
+
+    vector<RegistrationError> unregisteredSpecialMethods_;
 
     bool noBind_ = false;
 
     vector<string> baseClassNames_;
 
     // Tests
-    vector<string> nonDefaultConstructors_;
     vector<string> commonMembers_;
     vector<string> personalMembers_;
 };

Source/Tools/BindingGenerator/ASTemplateGenerator.cpp

@@ -0,0 +1,134 @@
+//
+// 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.
+//
+
+#include <fstream>
+#include <stdio.h>
+#include <string>
+
+using namespace std;
+
+namespace ASBindingGenerator
+{
+
+// Generate templates for up to this number of function parameters
+const int MAX_PARAMS = 8;
+
+void WriteConstructors(ofstream& ofs)
+{
+    ofs <<
+        "// Constructors that don't require parameter conversion between C++ and AngelScript\n"
+        "\n"
+        "#ifdef AS_MAX_PORTABILITY\n"
+        "\n";
+
+    for (int numParams = 0; numParams <= MAX_PARAMS; numParams++)
+    {
+        ofs << "template <class C";
+
+        for (int paramIndex = 0; paramIndex < numParams; paramIndex++)
+            ofs << ", typename P" << paramIndex;
+
+        ofs <<
+            ">\n"
+            "void ASCompatibleConstructor(asIScriptGeneric* gen)\n"
+            "{\n"
+            "    new (gen->GetObject()) C(";
+
+        for (int paramIndex = 0; paramIndex < numParams; paramIndex++)
+        {
+            if (paramIndex != 0)
+                ofs << ",\n                             ";
+
+            ofs << "*reinterpret_cast<P" << paramIndex << "*>(gen->GetAddressOfArg(" << paramIndex << "))";
+        }
+
+        ofs <<
+            ");\n"
+            "}\n"
+            "\n";
+    }
+
+    ofs <<
+        "#else\n"
+        "\n";
+
+    for (int numParams = 0; numParams <= MAX_PARAMS; numParams++)
+    {
+        ofs << "template <class C";
+
+        for (int paramIndex = 0; paramIndex < numParams; paramIndex++)
+            ofs << ", typename P" << paramIndex;
+
+        ofs <<
+            ">\n"
+            "void ASCompatibleConstructor(C* ptr";
+
+        for (int paramIndex = 0; paramIndex < numParams; paramIndex++)
+            ofs << ", P" << paramIndex << " p" << paramIndex;
+
+        ofs <<
+            ")\n"
+            "{\n"
+            "    new (ptr) C(";
+
+        for (int paramIndex = 0; paramIndex < numParams; paramIndex++)
+        {
+            if (paramIndex != 0)
+                ofs << ", ";
+
+            ofs << "p" << paramIndex;
+        }
+
+        ofs <<
+            ");\n"
+            "}\n"
+            "\n";
+    }
+
+    ofs <<
+        "#endif\n"
+        "\n";
+}
+
+void GenerateTemplates(const string& outputBasePath)
+{
+    ofstream ofs(outputBasePath + "/Source/Urho3D/AngelScript/Generated_Templates_New.h");
+
+    ofs <<
+        "// DO NOT EDIT. This file is generated\n"
+        "\n"
+        "#pragma once\n"
+        "\n"
+        "#include <AngelScript/angelscript.h>\n"
+        "\n"
+        "#include <new>\n"
+        "\n"
+        "namespace Urho3D\n"
+        "{\n"
+        "\n";
+ 
+    WriteConstructors(ofs);
+
+    ofs << "} // namespace Urho3D\n";
+}
+
+} // ASBindingGenerator

Source/Tools/BindingGenerator/ASUtils.cpp

@@ -662,12 +662,12 @@ string GenerateWrapperName(const ClassStaticFunctionAnalyzer& functionAnalyzer)
     return functionAnalyzer.GetClassName() + "_" + GenerateFunctionWrapperName(functionAnalyzer.GetMemberdef());
 }
 
-string GenerateWrapperName(const ClassFunctionAnalyzer& functionAnalyzer, bool templateVersion)
+string GenerateWrapperName(const MethodAnalyzer& methodAnalyzer, bool templateVersion)
 {
     if (templateVersion)
-        return functionAnalyzer.GetClassName() + "_" + GenerateFunctionWrapperName(functionAnalyzer.GetMemberdef()) + "_template";
+        return methodAnalyzer.GetClassName() + "_" + GenerateFunctionWrapperName(methodAnalyzer.GetMemberdef()) + "_template";
     else
-        return functionAnalyzer.GetClassName() + "_" + GenerateFunctionWrapperName(functionAnalyzer.GetMemberdef());
+        return methodAnalyzer.GetClassName() + "_" + GenerateFunctionWrapperName(methodAnalyzer.GetMemberdef());
 }
 
 // =================================================================================
@@ -743,11 +743,11 @@ string GenerateWrapper(const ClassStaticFunctionAnalyzer& functionAnalyzer, cons
     return result;
 }
 
-string GenerateWrapper(const ClassFunctionAnalyzer& functionAnalyzer, bool templateVersion, const vector<ConvertedVariable>& convertedParams, const ConvertedVariable& convertedReturn)
+string GenerateWrapper(const MethodAnalyzer& methodAnalyzer, bool templateVersion, const vector<ConvertedVariable>& convertedParams, const ConvertedVariable& convertedReturn)
 {
     string result;
 
-    string insideDefine = InsideDefine(functionAnalyzer.GetClass().GetHeaderFile());
+    string insideDefine = InsideDefine(methodAnalyzer.GetClass().GetHeaderFile());
 
     if (!insideDefine.empty())
         result += "#ifdef " + insideDefine + "\n";
@@ -755,19 +755,19 @@ string GenerateWrapper(const ClassFunctionAnalyzer& functionAnalyzer, bool templ
     string glueReturnType = convertedReturn.cppDeclaration_;
 
     result +=
-        "// " + functionAnalyzer.GetLocation() + "\n"
-        "static " + glueReturnType + " " + GenerateWrapperName(functionAnalyzer, templateVersion) + "(" + JoinCppDeclarations(functionAnalyzer.GetClassName() + "* ptr", convertedParams) + ")\n"
+        "// " + methodAnalyzer.GetLocation() + "\n"
+        "static " + glueReturnType + " " + GenerateWrapperName(methodAnalyzer, templateVersion) + "(" + JoinCppDeclarations(methodAnalyzer.GetClassName() + "* ptr", convertedParams) + ")\n"
         "{\n";
 
     for (size_t i = 0; i < convertedParams.size(); i++)
         result += convertedParams[i].glue_;
 
     if (glueReturnType != "void")
-        result += "    " + functionAnalyzer.GetReturnType().ToString() + " result = ";
+        result += "    " + methodAnalyzer.GetReturnType().ToString() + " result = ";
     else
         result += "    ";
 
-    result += "ptr->" + functionAnalyzer.GetName() + "(" + functionAnalyzer.JoinParamsNames() + ");\n";
+    result += "ptr->" + methodAnalyzer.GetName() + "(" + methodAnalyzer.JoinParamsNames() + ");\n";
 
     if (!convertedReturn.glue_.empty())
         result += "    " + convertedReturn.glue_;
@@ -803,17 +803,17 @@ string Generate_asFUNCTIONPR(const ClassStaticFunctionAnalyzer& functionAnalyzer
     return "AS_FUNCTIONPR(" + className + "::" + functionName + ", " + cppParams + ", " + returnType + ")";
 }
 
-string Generate_asMETHODPR(const ClassFunctionAnalyzer& functionAnalyzer, bool templateVersion)
+string Generate_asMETHODPR(const MethodAnalyzer& methodAnalyzer, bool templateVersion)
 {
-    string className = functionAnalyzer.GetClassName();
-    string functionName = functionAnalyzer.GetName();
+    string className = methodAnalyzer.GetClassName();
+    string functionName = methodAnalyzer.GetName();
 
-    string cppParams = "(" + JoinParamsTypes(functionAnalyzer.GetMemberdef(), functionAnalyzer.GetSpecialization()) + ")";
+    string cppParams = "(" + JoinParamsTypes(methodAnalyzer.GetMemberdef(), methodAnalyzer.GetSpecialization()) + ")";
 
-    if (functionAnalyzer.IsConst())
+    if (methodAnalyzer.IsConst())
         cppParams += " const";
 
-    string returnType = functionAnalyzer.GetReturnType().ToString();
+    string returnType = methodAnalyzer.GetReturnType().ToString();
     
     if (templateVersion)
         return "AS_METHODPR(T, " + functionName + ", " + cppParams + ", " + returnType + ")";

Source/Tools/BindingGenerator/ASUtils.h

@@ -80,14 +80,14 @@ shared_ptr<ClassAnalyzer> FindClassByID(const string& name);
 
 string GenerateWrapperName(const GlobalFunctionAnalyzer& functionAnalyzer);
 string GenerateWrapperName(const ClassStaticFunctionAnalyzer& functionAnalyzer);
-string GenerateWrapperName(const ClassFunctionAnalyzer& functionAnalyzer, bool templateVersion = false);
+string GenerateWrapperName(const MethodAnalyzer& methodAnalyzer, bool templateVersion = false);
 
 string GenerateWrapper(const GlobalFunctionAnalyzer& functionAnalyzer, const vector<ConvertedVariable>& convertedParams, const ConvertedVariable& convertedReturn);
 string GenerateWrapper(const ClassStaticFunctionAnalyzer& functionAnalyzer, const vector<ConvertedVariable>& convertedParams, const ConvertedVariable& convertedReturn);
-string GenerateWrapper(const ClassFunctionAnalyzer& functionAnalyzer, bool templateVersion, const vector<ConvertedVariable>& convertedParams, const ConvertedVariable& convertedReturn);
+string GenerateWrapper(const MethodAnalyzer& methodAnalyzer, bool templateVersion, const vector<ConvertedVariable>& convertedParams, const ConvertedVariable& convertedReturn);
 
 string Generate_asFUNCTIONPR(const GlobalFunctionAnalyzer& functionAnalyzer);
 string Generate_asFUNCTIONPR(const ClassStaticFunctionAnalyzer& functionAnalyzer);
-string Generate_asMETHODPR(const ClassFunctionAnalyzer& functionAnalyzer, bool templateVersion);
+string Generate_asMETHODPR(const MethodAnalyzer& methodAnalyzer, bool templateVersion);
 
 }

Source/Tools/BindingGenerator/Main.cpp

@@ -40,6 +40,8 @@ namespace ASBindingGenerator
     void ProcessAllGlobalFunctions();
     void SaveResult(const string& outputBasePath);
 
+    void GenerateTemplates(const string& outputBasePath);
+
     void GenerateBindings(const string& outputBasePath)
     {
         ProcessAllEnums();
@@ -48,6 +50,8 @@ namespace ASBindingGenerator
         ProcessAllGlobalVariables();
         ProcessAllGlobalFunctions();
         SaveResult(outputBasePath);
+
+        GenerateTemplates(outputBasePath);
     }
 }
 
@@ -75,8 +79,8 @@ namespace CSBindingGenerator
 int main(int argc, char* argv[])
 {
 #ifdef DEVELOP
-    string inputDir = R"(G:/MyGames/Urho3DCurrent/Build/Source/Tools/BindingGenerator/generated/xml)";
-    string outputBasePath = R"(G:/MyGames/Urho3DCurrent/Urho3D)";
+    string inputDir = R"(G:/MyGames/Urho3DFork/Build/Source/Tools/BindingGenerator/generated/xml)";
+    string outputBasePath = R"(G:/MyGames/Urho3DFork/Urho3D)";
 #else
     if (argc != 3)
         return -1;

Source/Tools/BindingGenerator/XmlAnalyzer.cpp

@@ -584,15 +584,30 @@ vector<xml_node> ClassAnalyzer::GetMemberdefs() const
     return result;
 }
 
-vector<ClassFunctionAnalyzer> ClassAnalyzer::GetFunctions() const
+vector<MethodAnalyzer> ClassAnalyzer::GetAllMethods() const
 {
-    vector<ClassFunctionAnalyzer> result;
+    vector<MethodAnalyzer> result;
    
     vector<xml_node> memberdefs = GetMemberdefs();
     for (xml_node memberdef : memberdefs)
     {
         if (ExtractKind(memberdef) == "function")
-            result.push_back(ClassFunctionAnalyzer(*this, memberdef));
+            result.push_back(MethodAnalyzer(*this, memberdef));
+    }
+
+    return result;
+}
+
+vector<MethodAnalyzer> ClassAnalyzer::GetThisPublicMethods() const
+{
+    vector<MethodAnalyzer> result;
+
+    xml_node sectiondef = FindSectiondef(compounddef_, "public-func");
+
+    for (xml_node memberdef : sectiondef.children("memberdef"))
+    {
+        MethodAnalyzer methodAnalyzer(*this, memberdef);
+        result.push_back(methodAnalyzer);
     }
 
     return result;
@@ -613,41 +628,41 @@ vector<ClassVariableAnalyzer> ClassAnalyzer::GetVariables() const
     return result;
 }
 
-bool ClassAnalyzer::ContainsFunction(const string& name) const
+bool ClassAnalyzer::ContainsMethod(const string& name) const
 {
-    vector<ClassFunctionAnalyzer> functions = GetFunctions();
+    vector<MethodAnalyzer> methods = GetAllMethods();
 
-    for (const ClassFunctionAnalyzer& function : functions)
+    for (const MethodAnalyzer& method : methods)
     {
-        if (function.GetName() == name)
+        if (method.GetName() == name)
             return true;
     }
 
     return false;
 }
 
-shared_ptr<ClassFunctionAnalyzer> ClassAnalyzer::GetFunction(const string& name) const
+shared_ptr<MethodAnalyzer> ClassAnalyzer::GetMethod(const string& name) const
 {
-    vector<ClassFunctionAnalyzer> functions = GetFunctions();
+    vector<MethodAnalyzer> methods = GetAllMethods();
 
-    for (const ClassFunctionAnalyzer& function : functions)
+    for (const MethodAnalyzer& method : methods)
     {
-        if (function.GetName() == name)
-            return make_shared<ClassFunctionAnalyzer>(function);
+        if (method.GetName() == name)
+            return make_shared<MethodAnalyzer>(method);
     }
 
     return nullptr;
 }
 
-int ClassAnalyzer::NumFunctions(const string& name) const
+int ClassAnalyzer::NumMethods(const string& name) const
 {
     int result = 0;
 
-    vector<ClassFunctionAnalyzer> functions = GetFunctions();
+    vector<MethodAnalyzer> methods = GetAllMethods();
 
-    for (const ClassFunctionAnalyzer& function : functions)
+    for (const MethodAnalyzer& method : methods)
     {
-        if (function.GetName() == name)
+        if (method.GetName() == name)
             result++;
     }
 
@@ -656,20 +671,20 @@ int ClassAnalyzer::NumFunctions(const string& name) const
 
 bool ClassAnalyzer::IsAbstract() const
 {
-    vector<ClassFunctionAnalyzer> functions = GetFunctions();
+    vector<MethodAnalyzer> methods = GetAllMethods();
 
-    for (const ClassFunctionAnalyzer& function : functions)
+    for (const MethodAnalyzer& method : methods)
     {
-        if (function.IsPureVirtual())
+        if (method.IsPureVirtual())
         {
             if (!IsRefCounted())
                 return true;
 
             // Some pure virtual functions is implemented by URHO3D_OBJECT
-            string name = function.GetName();
+            string name = method.GetName();
             if (name == "GetType" || name == "GetTypeInfo" || name == "GetTypeName")
             {
-                if (ContainsFunction("URHO3D_OBJECT"))
+                if (ContainsMethod("URHO3D_OBJECT"))
                     continue;
             }
 
@@ -789,11 +804,11 @@ vector<ClassAnalyzer> ClassAnalyzer::GetAllBaseClasses() const
 
 bool ClassAnalyzer::HasThisConstructor() const
 {
-    vector<ClassFunctionAnalyzer> functions = GetFunctions();
+    vector<MethodAnalyzer> methods = GetAllMethods();
 
-    for (const ClassFunctionAnalyzer& function : functions)
+    for (const MethodAnalyzer& method : methods)
     {
-        if (function.IsThisConstructor())
+        if (method.IsThisConstructor())
             return true;
     }
 
@@ -816,28 +831,28 @@ bool ClassAnalyzer::IsRefCounted() const
     return false;
 }
 
-shared_ptr<ClassFunctionAnalyzer> ClassAnalyzer::GetDefinedThisDefaultConstructor() const
+shared_ptr<MethodAnalyzer> ClassAnalyzer::GetDefinedThisDefaultConstructor() const
 {
-    vector<ClassFunctionAnalyzer> functions = GetFunctions();
+    vector<MethodAnalyzer> methods = GetAllMethods();
 
-    for (const ClassFunctionAnalyzer& function : functions)
+    for (const MethodAnalyzer& method : methods)
     {
-        if (function.IsThisDefaultConstructor())
-            return make_shared<ClassFunctionAnalyzer>(function);
+        if (method.IsThisDefaultConstructor())
+            return make_shared<MethodAnalyzer>(method);
     }
 
     return nullptr;
 }
 
-vector<ClassFunctionAnalyzer> ClassAnalyzer::GetThisNonDefaultConstructors() const
+vector<MethodAnalyzer> ClassAnalyzer::GetThisNonDefaultConstructors() const
 {
-    vector<ClassFunctionAnalyzer> result;
-    vector<ClassFunctionAnalyzer> functions = GetFunctions();
+    vector<MethodAnalyzer> result;
+    vector<MethodAnalyzer> methods = GetAllMethods();
 
-    for (const ClassFunctionAnalyzer& function : functions)
+    for (const MethodAnalyzer& method : methods)
     {
-        if (function.IsThisNonDefaultConstructor())
-            result.push_back(function);
+        if (method.IsThisNonDefaultConstructor())
+            result.push_back(method);
     }
 
     return result;
@@ -855,7 +870,7 @@ FunctionAnalyzer::FunctionAnalyzer(xml_node memberdef, const TemplateSpecializat
 
 // ============================================================================
 
-ClassFunctionAnalyzer::ClassFunctionAnalyzer(const ClassAnalyzer& classAnalyzer, xml_node memberdef, const TemplateSpecialization& specialization)
+MethodAnalyzer::MethodAnalyzer(const ClassAnalyzer& classAnalyzer, xml_node memberdef, const TemplateSpecialization& specialization)
     : FunctionAnalyzer(memberdef, specialization)
     , classAnalyzer_(classAnalyzer)
 {
@@ -863,7 +878,7 @@ ClassFunctionAnalyzer::ClassFunctionAnalyzer(const ClassAnalyzer& classAnalyzer,
     specialization_.insert(classAnalyzer.GetSpecialization().begin(), classAnalyzer.GetSpecialization().end());
 }
 
-string ClassFunctionAnalyzer::GetVirt() const
+string MethodAnalyzer::GetVirt() const
 {
     string result = memberdef_.attribute("virt").value();
     assert(!result.empty());
@@ -871,7 +886,7 @@ string ClassFunctionAnalyzer::GetVirt() const
     return result;
 }
 
-string ClassFunctionAnalyzer::GetContainsClassName() const
+string MethodAnalyzer::GetContainsClassName() const
 {
     string argsstring = ExtractArgsstring(memberdef_);
     assert(!argsstring.empty());
@@ -938,7 +953,7 @@ string GetFunctionLocation(xml_node memberdef)
     return GetFunctionDeclaration(memberdef) + " | File: " + ExtractHeaderFile(memberdef);
 }
 
-bool ClassFunctionAnalyzer::IsConst() const
+bool MethodAnalyzer::IsConst() const
 {
     string constAttr = memberdef_.attribute("const").value();
     assert(!constAttr.empty());
@@ -946,7 +961,7 @@ bool ClassFunctionAnalyzer::IsConst() const
     return constAttr == "yes";
 }
 
-bool ClassFunctionAnalyzer::CanBeGetProperty() const
+bool MethodAnalyzer::CanBeGetProperty() const
 {
     string returnType = GetReturnType().ToString();
 
@@ -959,7 +974,7 @@ bool ClassFunctionAnalyzer::CanBeGetProperty() const
     return true;
 }
 
-bool ClassFunctionAnalyzer::CanBeSetProperty() const
+bool MethodAnalyzer::CanBeSetProperty() const
 {
     string returnType = GetReturnType().ToString();
 
@@ -972,7 +987,7 @@ bool ClassFunctionAnalyzer::CanBeSetProperty() const
     return true;
 }
 
-bool ClassFunctionAnalyzer::IsParentDestructor() const
+bool MethodAnalyzer::IsParentDestructor() const
 {
     string functionName = GetName();
     if (!StartsWith(functionName, "~"))
@@ -981,7 +996,7 @@ bool ClassFunctionAnalyzer::IsParentDestructor() const
     return !IsThisDestructor();
 }
 
-bool ClassFunctionAnalyzer::IsParentConstructor() const
+bool MethodAnalyzer::IsParentConstructor() const
 {
     if (IsThisConstructor())
         return false;
@@ -991,22 +1006,22 @@ bool ClassFunctionAnalyzer::IsParentConstructor() const
     return ExtractDefinition(memberdef_) == "Urho3D::" + name + "::" + name;
 }
 
-shared_ptr<ClassFunctionAnalyzer> ClassFunctionAnalyzer::Reimplements() const
+shared_ptr<MethodAnalyzer> MethodAnalyzer::Reimplements() const
 {
     xml_node reimplements = memberdef_.child("reimplements");
 
     if (!reimplements)
-        return shared_ptr<ClassFunctionAnalyzer>();
+        return shared_ptr<MethodAnalyzer>();
 
     string refid = reimplements.attribute("refid").value();
     assert(!refid.empty());
 
     auto it = SourceData::members_.find(refid);
     if (it == SourceData::members_.end())
-        return shared_ptr<ClassFunctionAnalyzer>();
+        return shared_ptr<MethodAnalyzer>();
 
     xml_node memberdef = it->second;
-    return make_shared<ClassFunctionAnalyzer>(classAnalyzer_, memberdef);
+    return make_shared<MethodAnalyzer>(classAnalyzer_, memberdef);
 }
 
 // ============================================================================

Source/Tools/BindingGenerator/XmlAnalyzer.h

@@ -250,7 +250,7 @@ public:
     string GetLocation() const;
 };
 
-class ClassFunctionAnalyzer;
+class MethodAnalyzer;
 class ClassVariableAnalyzer;
 
 // <compounddef kind="class|struct">...</compounddef>
@@ -275,13 +275,14 @@ public:
     string GetKind() const { return ExtractKind(compounddef_); }
     bool IsInternal() const;
     bool IsTemplate() const { return ::IsTemplate(compounddef_); }
-    vector<ClassFunctionAnalyzer> GetFunctions() const;
+    vector<MethodAnalyzer> GetAllMethods() const;
+    vector<MethodAnalyzer> GetThisPublicMethods() const;
     vector<ClassVariableAnalyzer> GetVariables() const;
-    bool ContainsFunction(const string& name) const;
-    shared_ptr<ClassFunctionAnalyzer> GetFunction(const string& name) const;
-    int NumFunctions(const string& name) const;
+    bool ContainsMethod(const string& name) const;
+    shared_ptr<MethodAnalyzer> GetMethod(const string& name) const;
+    int NumMethods(const string& name) const;
     bool IsRefCounted() const;
-    bool HasThisDestructor() const { return ContainsFunction("~" + GetClassName()); }
+    bool HasThisDestructor() const { return ContainsMethod("~" + GetClassName()); }
     bool HasThisConstructor() const;
     bool IsAbstract() const;
     string GetLocation() const { return GetKind() + " " + GetClassName() + " | File: " + GetHeaderFile(); }
@@ -294,13 +295,13 @@ public:
     
     // Return null if default constructor is implicitly-declared.
     // Return pointer if default constructor is deleted
-    shared_ptr<ClassFunctionAnalyzer> GetDefinedThisDefaultConstructor() const;
+    shared_ptr<MethodAnalyzer> GetDefinedThisDefaultConstructor() const;
 
-    vector<ClassFunctionAnalyzer> GetThisNonDefaultConstructors() const;
+    vector<MethodAnalyzer> GetThisNonDefaultConstructors() const;
 
     // Return null if destructor is implicitly-declared.
     // Return pointer if destructor is deleted
-    shared_ptr<ClassFunctionAnalyzer> GetDefinedThisDestructor() const { return GetFunction("~" + GetClassName()); }
+    shared_ptr<MethodAnalyzer> GetDefinedThisDestructor() const { return GetMethod("~" + GetClassName()); }
 };
 
 // <memberdef kind="function">...</memberdef>
@@ -333,12 +334,12 @@ public:
 // <compounddef kind="class|struct">
 //     <sectiondef>
 //         <memberdef kind="function">...</memberdef>
-class ClassFunctionAnalyzer : public FunctionAnalyzer
+class MethodAnalyzer : public FunctionAnalyzer
 {
     ClassAnalyzer classAnalyzer_;
 
 public:
-    ClassFunctionAnalyzer(const ClassAnalyzer& classAnalyzer, xml_node memberdef, const TemplateSpecialization& specialization = {});
+    MethodAnalyzer(const ClassAnalyzer& classAnalyzer, xml_node memberdef, const TemplateSpecialization& specialization = {});
 
     ClassAnalyzer GetClass() const { return classAnalyzer_; }
 
@@ -351,7 +352,7 @@ public:
 
     // <memberdef>
     // <reimplements refid="..."></reimplements>
-    shared_ptr<ClassFunctionAnalyzer> Reimplements() const;
+    shared_ptr<MethodAnalyzer> Reimplements() const;
 
     string GetClassName() const { return classAnalyzer_.GetClassName(); }
     string GetContainsClassName() const; // May this function defined in parent class, so return name o class, real define this function

Source/Urho3D/AngelScript/Addons.cpp

@@ -33,6 +33,17 @@
 namespace Urho3D
 {
 
+bool operator ==(const asSFuncPtr& a, const asSFuncPtr& b)
+{
+    for (int i = 0; i < sizeof(a.ptr.dummy); i++)
+    {
+        if (a.ptr.dummy[i] != b.ptr.dummy[i])
+            return false;
+    }
+
+    return true;
+}
+
 using namespace std;
 
 // Set the default memory routines

Source/Urho3D/AngelScript/Addons.h

@@ -39,6 +39,8 @@
 namespace Urho3D
 {
 
+bool operator ==(const asSFuncPtr& a, const asSFuncPtr& b);
+
 struct SArrayBuffer;
 struct SArrayCache;
 

Source/Urho3D/AngelScript/GeneratedClasses.cpp

@@ -2231,6 +2231,12 @@ static void Register_StoredLogMessage(asIScriptEngine* engine)
 // class String | File: ../Container/Str.h
 static void Register_String(asIScriptEngine* engine)
 {
+    // explicit String::String(long value)
+    // Not registered because have @nobind mark
+
+    // explicit String::String(unsigned long value)
+    // Not registered because have @nobind mark
+
     // String::~String()
     engine->RegisterObjectBehaviour("String", asBEHAVE_DESTRUCT, "void f()", AS_DESTRUCTOR(String), AS_CALL_CDECL_OBJFIRST);
 

Source/Urho3D/AngelScript/GeneratedDefaultConstructors.cpp

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

Source/Urho3D/AngelScript/Generated_Templates_New.h

@@ -0,0 +1,156 @@
+// DO NOT EDIT. This file is generated
+
+#pragma once
+
+#include <AngelScript/angelscript.h>
+
+#include <new>
+
+namespace Urho3D
+{
+
+// Constructors that don't require parameter conversion between C++ and AngelScript
+
+#ifdef AS_MAX_PORTABILITY
+
+template <class C>
+void ASCompatibleConstructor(asIScriptGeneric* gen)
+{
+    new (gen->GetObject()) C();
+}
+
+template <class C, typename P0>
+void ASCompatibleConstructor(asIScriptGeneric* gen)
+{
+    new (gen->GetObject()) C(*reinterpret_cast<P0*>(gen->GetAddressOfArg(0)));
+}
+
+template <class C, typename P0, typename P1>
+void ASCompatibleConstructor(asIScriptGeneric* gen)
+{
+    new (gen->GetObject()) C(*reinterpret_cast<P0*>(gen->GetAddressOfArg(0)),
+                             *reinterpret_cast<P1*>(gen->GetAddressOfArg(1)));
+}
+
+template <class C, typename P0, typename P1, typename P2>
+void ASCompatibleConstructor(asIScriptGeneric* gen)
+{
+    new (gen->GetObject()) C(*reinterpret_cast<P0*>(gen->GetAddressOfArg(0)),
+                             *reinterpret_cast<P1*>(gen->GetAddressOfArg(1)),
+                             *reinterpret_cast<P2*>(gen->GetAddressOfArg(2)));
+}
+
+template <class C, typename P0, typename P1, typename P2, typename P3>
+void ASCompatibleConstructor(asIScriptGeneric* gen)
+{
+    new (gen->GetObject()) C(*reinterpret_cast<P0*>(gen->GetAddressOfArg(0)),
+                             *reinterpret_cast<P1*>(gen->GetAddressOfArg(1)),
+                             *reinterpret_cast<P2*>(gen->GetAddressOfArg(2)),
+                             *reinterpret_cast<P3*>(gen->GetAddressOfArg(3)));
+}
+
+template <class C, typename P0, typename P1, typename P2, typename P3, typename P4>
+void ASCompatibleConstructor(asIScriptGeneric* gen)
+{
+    new (gen->GetObject()) C(*reinterpret_cast<P0*>(gen->GetAddressOfArg(0)),
+                             *reinterpret_cast<P1*>(gen->GetAddressOfArg(1)),
+                             *reinterpret_cast<P2*>(gen->GetAddressOfArg(2)),
+                             *reinterpret_cast<P3*>(gen->GetAddressOfArg(3)),
+                             *reinterpret_cast<P4*>(gen->GetAddressOfArg(4)));
+}
+
+template <class C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5>
+void ASCompatibleConstructor(asIScriptGeneric* gen)
+{
+    new (gen->GetObject()) C(*reinterpret_cast<P0*>(gen->GetAddressOfArg(0)),
+                             *reinterpret_cast<P1*>(gen->GetAddressOfArg(1)),
+                             *reinterpret_cast<P2*>(gen->GetAddressOfArg(2)),
+                             *reinterpret_cast<P3*>(gen->GetAddressOfArg(3)),
+                             *reinterpret_cast<P4*>(gen->GetAddressOfArg(4)),
+                             *reinterpret_cast<P5*>(gen->GetAddressOfArg(5)));
+}
+
+template <class C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
+void ASCompatibleConstructor(asIScriptGeneric* gen)
+{
+    new (gen->GetObject()) C(*reinterpret_cast<P0*>(gen->GetAddressOfArg(0)),
+                             *reinterpret_cast<P1*>(gen->GetAddressOfArg(1)),
+                             *reinterpret_cast<P2*>(gen->GetAddressOfArg(2)),
+                             *reinterpret_cast<P3*>(gen->GetAddressOfArg(3)),
+                             *reinterpret_cast<P4*>(gen->GetAddressOfArg(4)),
+                             *reinterpret_cast<P5*>(gen->GetAddressOfArg(5)),
+                             *reinterpret_cast<P6*>(gen->GetAddressOfArg(6)));
+}
+
+template <class C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
+void ASCompatibleConstructor(asIScriptGeneric* gen)
+{
+    new (gen->GetObject()) C(*reinterpret_cast<P0*>(gen->GetAddressOfArg(0)),
+                             *reinterpret_cast<P1*>(gen->GetAddressOfArg(1)),
+                             *reinterpret_cast<P2*>(gen->GetAddressOfArg(2)),
+                             *reinterpret_cast<P3*>(gen->GetAddressOfArg(3)),
+                             *reinterpret_cast<P4*>(gen->GetAddressOfArg(4)),
+                             *reinterpret_cast<P5*>(gen->GetAddressOfArg(5)),
+                             *reinterpret_cast<P6*>(gen->GetAddressOfArg(6)),
+                             *reinterpret_cast<P7*>(gen->GetAddressOfArg(7)));
+}
+
+#else
+
+template <class C>
+void ASCompatibleConstructor(C* ptr)
+{
+    new (ptr) C();
+}
+
+template <class C, typename P0>
+void ASCompatibleConstructor(C* ptr, P0 p0)
+{
+    new (ptr) C(p0);
+}
+
+template <class C, typename P0, typename P1>
+void ASCompatibleConstructor(C* ptr, P0 p0, P1 p1)
+{
+    new (ptr) C(p0, p1);
+}
+
+template <class C, typename P0, typename P1, typename P2>
+void ASCompatibleConstructor(C* ptr, P0 p0, P1 p1, P2 p2)
+{
+    new (ptr) C(p0, p1, p2);
+}
+
+template <class C, typename P0, typename P1, typename P2, typename P3>
+void ASCompatibleConstructor(C* ptr, P0 p0, P1 p1, P2 p2, P3 p3)
+{
+    new (ptr) C(p0, p1, p2, p3);
+}
+
+template <class C, typename P0, typename P1, typename P2, typename P3, typename P4>
+void ASCompatibleConstructor(C* ptr, P0 p0, P1 p1, P2 p2, P3 p3, P4 p4)
+{
+    new (ptr) C(p0, p1, p2, p3, p4);
+}
+
+template <class C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5>
+void ASCompatibleConstructor(C* ptr, P0 p0, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
+{
+    new (ptr) C(p0, p1, p2, p3, p4, p5);
+}
+
+template <class C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
+void ASCompatibleConstructor(C* ptr, P0 p0, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
+{
+    new (ptr) C(p0, p1, p2, p3, p4, p5, p6);
+}
+
+template <class C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
+void ASCompatibleConstructor(C* ptr, P0 p0, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7)
+{
+    new (ptr) C(p0, p1, p2, p3, p4, p5, p6, p7);
+}
+
+#endif
+
+} // namespace Urho3D

Source/Urho3D/AngelScript/RegistrationMacros.h

@@ -26,13 +26,15 @@
 #include "../AngelScript/aswrappedcall.h"
 #endif
 
+#include "../AngelScript/Generated_Templates_New.h"
+
 namespace Urho3D
 {
 
 // f - function
 // c - class
 // m - method
-// p - parameters
+// p - parameters (in parentheses)
 // r - return type
 // PR - parameters, return type
 

Source/Urho3D/CMakeLists.txt

@@ -208,7 +208,8 @@ if (URHO3D_GENERATEBINDINGS)
                             "AngelScript/GeneratedGlobalVariables.cpp"
                             "AngelScript/GeneratedGlobalFunctions.cpp"
                             "AngelScript/GeneratedIncludes.h"
-                            "AngelScript/Generated_Templates.h")
+                            "AngelScript/Generated_Templates.h"
+                            "AngelScript/Generated_Templates_New.h")
 
     set (AS_GENERATED_FILES_FULL_PATHS "${AS_GENERATED_FILES}")
     # Add "${CMAKE_SOURCE_DIR}/Source/Urho3D/" to every item in list