diff --git a/CMakeLists.txt b/CMakeLists.txt
index e27f1e9..f3dfef3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -91,6 +91,10 @@ if    (BUILD_Cpp_AIWRAPPER)
 		endif ()
 	endif ()
 	configure_native_skirmish_ai(mySourceDirRel additionalSources additionalCompileFlags additionalLibraries)
+	if(EMSCRIPTEN AND TARGET BARb)
+		# Native plugins isolate their own JsonCpp. Static WASM needs that same isolation.
+		target_compile_definitions(BARb PRIVATE AS_POSIX_THREADS Json=WebbarAIJson)
+	endif()
 else  (BUILD_Cpp_AIWRAPPER)
 	message ("warning: (New) C++ Circuit AI will not be built! (missing Cpp Wrapper)")
 endif (BUILD_Cpp_AIWRAPPER)
diff --git a/src/AIExport.cpp b/src/AIExport.cpp
index 6e9da12..909f149 100644
--- a/src/AIExport.cpp
+++ b/src/AIExport.cpp
@@ -13,6 +13,12 @@
 #include <stdexcept>
 #include <map>
 
+#ifdef __EMSCRIPTEN__
+#define init WebbarBARbInit
+#define release WebbarBARbRelease
+#define handleEvent WebbarBARbHandleEvent
+#endif
+
 static std::map<int, circuit::CCircuitAI*> myAIs;
 static std::map<int, springai::OOAICallback*> myAICallbacks;
 
diff --git a/src/circuit/scheduler/Scheduler.cpp b/src/circuit/scheduler/Scheduler.cpp
index ce0094b..3acdf96 100644
--- a/src/circuit/scheduler/Scheduler.cpp
+++ b/src/circuit/scheduler/Scheduler.cpp
@@ -34,6 +34,10 @@ CScheduler::CScheduler()
 	if (gInstanceCount == 0) {
 		int maxThreads = spring::thread::hardware_concurrency();
 		gMaxWorkThreads = utils::clamp(maxThreads - 1, 2, MAX_JOB_THREADS);
+#ifdef __EMSCRIPTEN__
+		// Leave room for the engine and asset workers in the bounded pthread pool.
+		gMaxWorkThreads = 2;
+#endif
 	}
 	gInstanceCount++;
 	isRunning = true;
diff --git a/src/circuit/script/BuilderScript.cpp b/src/circuit/script/BuilderScript.cpp
index 0be6a83..880c9dd 100644
--- a/src/circuit/script/BuilderScript.cpp
+++ b/src/circuit/script/BuilderScript.cpp
@@ -5,6 +5,8 @@
  *      Author: rlcevg
  */
 
+// Codex-assisted portable script bindings for the Webbar WASM experiment.
+#include "WebbarBindings.h"
 #include "script/BuilderScript.h"
 #include "script/ScriptManager.h"
 #include "module/BuilderManager.h"
@@ -26,7 +28,7 @@ CBuilderScript::CBuilderScript(CScriptManager* scr, CBuilderManager* mgr)
 	asIScriptEngine* engine = script->GetEngine();
 
 	int r = engine->RegisterObjectType("SResource", sizeof(SResource), asOBJ_VALUE | asOBJ_POD | asGetTypeTraits<SResource>()); ASSERT(r >= 0);
-	r = engine->RegisterObjectBehaviour("SResource", asBEHAVE_CONSTRUCT, "void f(float, float)", asFUNCTION(ConstructSResourceVal), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
+	r = engine->RegisterObjectBehaviour("SResource", asBEHAVE_CONSTRUCT, "void f(float, float)", (WebbarBind<ConstructSResourceVal, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("SResource", "float metal", asOFFSET(SResource, metal)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("SResource", "float energy", asOFFSET(SResource, energy)); ASSERT(r >= 0);
 
@@ -63,11 +65,11 @@ CBuilderScript::CBuilderScript(CScriptManager* scr, CBuilderManager* mgr)
 
 	r = engine->RegisterObjectType("CBuilderManager", 0, asOBJ_REF | asOBJ_NOHANDLE); ASSERT(r >= 0);
 	r = engine->RegisterGlobalProperty("CBuilderManager aiBuilderMgr", manager); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CBuilderManager", "IUnitTask@+ DefaultMakeTask(CCircuitUnit@)", asMETHOD(CBuilderManager, DefaultMakeTask), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CBuilderManager", "IUnitTask@+ Enqueue(const SBuildTask& in)", asMETHODPR(CBuilderManager, Enqueue, (const TaskB::SBuildTask&), IBuilderTask*), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CBuilderManager", "IUnitTask@+ Enqueue(const SServBTask& in)", asMETHODPR(CBuilderManager, Enqueue, (const TaskB::SServBTask&), IUnitTask*), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CBuilderManager", "IUnitTask@+ EnqueueRetreat()", asMETHOD(CBuilderManager, EnqueueRetreat), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CBuilderManager", "uint GetWorkerCount() const", asMETHOD(CBuilderManager, GetWorkerCount), asCALL_THISCALL); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CBuilderManager", "IUnitTask@+ DefaultMakeTask(CCircuitUnit@)", (WebbarBind<&CBuilderManager::DefaultMakeTask, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CBuilderManager", "IUnitTask@+ Enqueue(const SBuildTask& in)", (WebbarBind<static_cast<IBuilderTask* (CBuilderManager::*)(const TaskB::SBuildTask&)>(&CBuilderManager::Enqueue), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CBuilderManager", "IUnitTask@+ Enqueue(const SServBTask& in)", (WebbarBind<static_cast<IUnitTask* (CBuilderManager::*)(const TaskB::SServBTask&)>(&CBuilderManager::Enqueue), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CBuilderManager", "IUnitTask@+ EnqueueRetreat()", (WebbarBind<&CBuilderManager::EnqueueRetreat, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CBuilderManager", "uint GetWorkerCount() const", (WebbarBind<&CBuilderManager::GetWorkerCount, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CBuilderManager", "int dangerHysteresis", asOFFSET(CBuilderManager, dangerHysteresis)); ASSERT(r >= 0);
 
 }
diff --git a/src/circuit/script/EconomyScript.cpp b/src/circuit/script/EconomyScript.cpp
index 2baf4ae..7e4ba9f 100644
--- a/src/circuit/script/EconomyScript.cpp
+++ b/src/circuit/script/EconomyScript.cpp
@@ -5,6 +5,8 @@
  *      Author: rlcevg
  */
 
+// Codex-assisted portable script bindings for the Webbar WASM experiment.
+#include "WebbarBindings.h"
 #include "script/EconomyScript.h"
 #include "script/ScriptManager.h"
 #include "module/EconomyManager.h"
@@ -39,8 +41,8 @@ CEconomyScript::CEconomyScript(CScriptManager* scr, CEconomyManager* mgr)
 	r = engine->RegisterObjectProperty("CEconomyManager", "float reclConvertEff", asOFFSET(CEconomyManager, reclConvertEff)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CEconomyManager", "float reclEnergyEff", asOFFSET(CEconomyManager, reclEnergyEff)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CEconomyManager", "float startMexTravel", asOFFSET(CEconomyManager, startMexTravel)); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CEconomyManager", "float GetMetalMake(const CCircuitDef@) const", asMETHOD(CEconomyManager, GetMetalMake), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CEconomyManager", "float GetEnergyMake(const CCircuitDef@) const", asMETHOD(CEconomyManager, GetEnergyMake), asCALL_THISCALL); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CEconomyManager", "float GetMetalMake(const CCircuitDef@) const", (WebbarBind<&CEconomyManager::GetMetalMake, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CEconomyManager", "float GetEnergyMake(const CCircuitDef@) const", (WebbarBind<&CEconomyManager::GetEnergyMake, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 }
 
 CEconomyScript::~CEconomyScript()
diff --git a/src/circuit/script/FactoryScript.cpp b/src/circuit/script/FactoryScript.cpp
index 0c47e86..54ca852 100644
--- a/src/circuit/script/FactoryScript.cpp
+++ b/src/circuit/script/FactoryScript.cpp
@@ -5,6 +5,8 @@
  *      Author: rlcevg
  */
 
+// Codex-assisted portable script bindings for the Webbar WASM experiment.
+#include "WebbarBindings.h"
 #include "script/FactoryScript.h"
 #include "script/ScriptManager.h"
 #include "module/FactoryManager.h"
@@ -44,22 +46,22 @@ CFactoryScript::CFactoryScript(CScriptManager* scr, CFactoryManager* mgr)
 
 	r = engine->RegisterObjectType("CFactoryManager", 0, asOBJ_REF | asOBJ_NOHANDLE); ASSERT(r >= 0);
 	r = engine->RegisterGlobalProperty("CFactoryManager aiFactoryMgr", manager); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CFactoryManager", "CCircuitDef@ DefaultGetFactoryToBuild(const AIFloat3& in, bool, bool)", asMETHOD(CFactoryManager, DefaultGetFactoryToBuild), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CFactoryManager", "IUnitTask@+ DefaultMakeTask(CCircuitUnit@)", asMETHOD(CFactoryManager, DefaultMakeTask), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CFactoryManager", "IUnitTask@+ Enqueue(const SRecruitTask& in)", asMETHODPR(CFactoryManager, Enqueue, (const TaskS::SRecruitTask&), CRecruitTask*), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CFactoryManager", "IUnitTask@+ Enqueue(const SServSTask& in)", asMETHODPR(CFactoryManager, Enqueue, (const TaskS::SServSTask&), IUnitTask*), asCALL_THISCALL); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CFactoryManager", "CCircuitDef@ DefaultGetFactoryToBuild(const AIFloat3& in, bool, bool)", (WebbarBind<&CFactoryManager::DefaultGetFactoryToBuild, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CFactoryManager", "IUnitTask@+ DefaultMakeTask(CCircuitUnit@)", (WebbarBind<&CFactoryManager::DefaultMakeTask, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CFactoryManager", "IUnitTask@+ Enqueue(const SRecruitTask& in)", (WebbarBind<static_cast<CRecruitTask* (CFactoryManager::*)(const TaskS::SRecruitTask&)>(&CFactoryManager::Enqueue), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CFactoryManager", "IUnitTask@+ Enqueue(const SServSTask& in)", (WebbarBind<static_cast<IUnitTask* (CFactoryManager::*)(const TaskS::SServSTask&)>(&CFactoryManager::Enqueue), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 //	r = engine->RegisterObjectMethod("CFactoryManager", "IUnitTask@+ EnqueueRetreat()", asMETHOD(CFactoryManager, EnqueueRetreat), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CFactoryManager", "CCircuitDef@ GetRoleDef(const CCircuitDef@, Type) const", asMETHOD(CFactoryManager, GetRoleDef), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CFactoryManager", "int GetFactoryCount() const", asMETHOD(CFactoryManager, GetFactoryCount), asCALL_THISCALL); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CFactoryManager", "CCircuitDef@ GetRoleDef(const CCircuitDef@, Type) const", (WebbarBind<&CFactoryManager::GetRoleDef, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CFactoryManager", "int GetFactoryCount() const", (WebbarBind<&CFactoryManager::GetFactoryCount, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CFactoryManager", "bool isAssistRequired", asOFFSET(CFactoryManager, isAssistRequired)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CFactoryManager", "float buildpowerRatio", asOFFSET(CFactoryManager, bpRatio)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CFactoryManager", "float responseWeight", asOFFSET(CFactoryManager, reWeight)); ASSERT(r >= 0);
 
 	// AS docs / "Registering object methods" / "Composite members"
-	r = engine->RegisterObjectMethod("CFactoryManager", "void SetTierWeights(const CCircuitDef@, int, int, array<float>@+)", asMETHOD(CFactoryScript, SetTierWeights), asCALL_THISCALL, 0, asOFFSET(CFactoryManager, script), true); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CFactoryManager", "array<float>@ GetTierWeights(const CCircuitDef@, int, int) const", asMETHOD(CFactoryScript, GetTierWeights), asCALL_THISCALL, 0, asOFFSET(CFactoryManager, script), true); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CFactoryManager", "void SetImportance(const CCircuitDef@, array<float>@+)", asMETHOD(CFactoryScript, SetImportance), asCALL_THISCALL, 0, asOFFSET(CFactoryManager, script), true); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CFactoryManager", "array<float>@ GetImportance(const CCircuitDef@) const", asMETHOD(CFactoryScript, GetImportance), asCALL_THISCALL, 0, asOFFSET(CFactoryManager, script), true); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CFactoryManager", "void SetTierWeights(const CCircuitDef@, int, int, array<float>@+)", (WebbarBindComposite<&CFactoryScript::SetTierWeights, &CFactoryManager::script>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CFactoryManager", "array<float>@ GetTierWeights(const CCircuitDef@, int, int) const", (WebbarBindComposite<&CFactoryScript::GetTierWeights, &CFactoryManager::script>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CFactoryManager", "void SetImportance(const CCircuitDef@, array<float>@+)", (WebbarBindComposite<&CFactoryScript::SetImportance, &CFactoryManager::script>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CFactoryManager", "array<float>@ GetImportance(const CCircuitDef@) const", (WebbarBindComposite<&CFactoryScript::GetImportance, &CFactoryManager::script>()), asCALL_GENERIC); ASSERT(r >= 0);
 }
 
 CFactoryScript::~CFactoryScript()
diff --git a/src/circuit/script/InitScript.cpp b/src/circuit/script/InitScript.cpp
index c3aaefe..2b4bb20 100644
--- a/src/circuit/script/InitScript.cpp
+++ b/src/circuit/script/InitScript.cpp
@@ -5,6 +5,8 @@
  *      Author: rlcevg
  */
 
+// Codex-assisted portable script bindings for the Webbar WASM experiment.
+#include "WebbarBindings.h"
 #include "script/InitScript.h"
 #include "script/SetupScript.h"
 #include "script/ScriptManager.h"
@@ -296,10 +298,10 @@ template <class Base, class Derived>
 void RegisterCast(asIScriptEngine *engine, const char *base, const char* derived)
 {
 	int r;
-	r = engine->RegisterObjectMethod(base, std::format("{}@ opCast()", derived).c_str(), asFUNCTION((RefCast<Base, Derived>)), asCALL_CDECL_OBJLAST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod(derived, std::format("{}@ opImplCast()", base).c_str(), asFUNCTION((RefCast<Derived, Base>)), asCALL_CDECL_OBJLAST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod(base, std::format("const {}@ opCast() const", derived).c_str(), asFUNCTION((RefCast<Base, Derived>)), asCALL_CDECL_OBJLAST); ASSERT( r >= 0 );
-	r = engine->RegisterObjectMethod(derived, std::format("const {}@ opImplCast() const", base).c_str(), asFUNCTION((RefCast<Derived, Base>)), asCALL_CDECL_OBJLAST); ASSERT( r >= 0 );
+	r = engine->RegisterObjectMethod(base, std::format("{}@ opCast()", derived).c_str(), (WebbarBind<(RefCast<Base, Derived>), asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod(derived, std::format("{}@ opImplCast()", base).c_str(), (WebbarBind<(RefCast<Derived, Base>), asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod(base, std::format("const {}@ opCast() const", derived).c_str(), (WebbarBind<(RefCast<Base, Derived>), asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); ASSERT( r >= 0 );
+	r = engine->RegisterObjectMethod(derived, std::format("const {}@ opImplCast() const", base).c_str(), (WebbarBind<(RefCast<Derived, Base>), asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); ASSERT( r >= 0 );
 }
 
 CInitScript::CInitScript(CScriptManager* scr, CCircuitAI* ai)
@@ -326,27 +328,27 @@ bool CInitScript::InitConfig(const std::string& profile,
 	//        on exit
 //	int r = engine->BeginConfigGroup(CScriptManager::initName.c_str()); ASSERT(r >= 0);
 	int r = engine->RegisterObjectType("SArmorInfo", sizeof(CCircuitDef::SArmorInfo), asOBJ_VALUE | asGetTypeTraits<CCircuitDef::SArmorInfo>()); ASSERT(r >= 0);
-	r = engine->RegisterObjectBehaviour("SArmorInfo", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructSArmorInfo), asCALL_CDECL_OBJLAST); ASSERT(r >= 0);
-	r = engine->RegisterObjectBehaviour("SArmorInfo", asBEHAVE_CONSTRUCT, "void f(const SArmorInfo& in)", asFUNCTION(ConstructCopySArmorInfo), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectBehaviour("SArmorInfo", asBEHAVE_DESTRUCT, "void f()", asFUNCTION(DestructSArmorInfo), asCALL_CDECL_OBJLAST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("SArmorInfo", "SArmorInfo &opAssign(const SArmorInfo &in)", asFUNCTION(AssignSArmorInfoToSArmorInfo), asCALL_CDECL_OBJFIRST); assert( r >= 0 );
-	r = engine->RegisterObjectMethod("SArmorInfo", "void AddAir(int)", asFUNCTION(AddAirArmor), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("SArmorInfo", "void AddSurface(int)", asFUNCTION(AddSurfaceArmor), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("SArmorInfo", "void AddWater(int)", asFUNCTION(AddWaterArmor), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
+	r = engine->RegisterObjectBehaviour("SArmorInfo", asBEHAVE_CONSTRUCT, "void f()", (WebbarBind<ConstructSArmorInfo, asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectBehaviour("SArmorInfo", asBEHAVE_CONSTRUCT, "void f(const SArmorInfo& in)", (WebbarBind<ConstructCopySArmorInfo, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectBehaviour("SArmorInfo", asBEHAVE_DESTRUCT, "void f()", (WebbarBind<DestructSArmorInfo, asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("SArmorInfo", "SArmorInfo &opAssign(const SArmorInfo &in)", (WebbarBind<AssignSArmorInfoToSArmorInfo, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert( r >= 0 );
+	r = engine->RegisterObjectMethod("SArmorInfo", "void AddAir(int)", (WebbarBind<AddAirArmor, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("SArmorInfo", "void AddSurface(int)", (WebbarBind<AddSurfaceArmor, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("SArmorInfo", "void AddWater(int)", (WebbarBind<AddWaterArmor, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
 	r = engine->RegisterObjectType("SCategoryInfo", sizeof(SInitInfo::SCategoryInfo), asOBJ_VALUE | asGetTypeTraits<SInitInfo::SCategoryInfo>()); ASSERT(r >= 0);
-	r = engine->RegisterObjectBehaviour("SCategoryInfo", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructSCategoryInfo), asCALL_CDECL_OBJLAST); ASSERT(r >= 0);
-	r = engine->RegisterObjectBehaviour("SCategoryInfo", asBEHAVE_CONSTRUCT, "void f(const SCategoryInfo& in)", asFUNCTION(ConstructCopySCategoryInfo), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectBehaviour("SCategoryInfo", asBEHAVE_DESTRUCT, "void f()", asFUNCTION(DestructSCategoryInfo), asCALL_CDECL_OBJLAST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("SCategoryInfo", "SCategoryInfo &opAssign(const SCategoryInfo &in)", asFUNCTION(AssignSCategoryInfoToSCategoryInfo), asCALL_CDECL_OBJFIRST); assert( r >= 0 );
+	r = engine->RegisterObjectBehaviour("SCategoryInfo", asBEHAVE_CONSTRUCT, "void f()", (WebbarBind<ConstructSCategoryInfo, asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectBehaviour("SCategoryInfo", asBEHAVE_CONSTRUCT, "void f(const SCategoryInfo& in)", (WebbarBind<ConstructCopySCategoryInfo, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectBehaviour("SCategoryInfo", asBEHAVE_DESTRUCT, "void f()", (WebbarBind<DestructSCategoryInfo, asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("SCategoryInfo", "SCategoryInfo &opAssign(const SCategoryInfo &in)", (WebbarBind<AssignSCategoryInfoToSCategoryInfo, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert( r >= 0 );
 	r = engine->RegisterObjectProperty("SCategoryInfo", "string air", asOFFSET(SInitInfo::SCategoryInfo, air)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("SCategoryInfo", "string land", asOFFSET(SInitInfo::SCategoryInfo, land)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("SCategoryInfo", "string water", asOFFSET(SInitInfo::SCategoryInfo, water)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("SCategoryInfo", "string bad", asOFFSET(SInitInfo::SCategoryInfo, bad)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("SCategoryInfo", "string good", asOFFSET(SInitInfo::SCategoryInfo, good)); ASSERT(r >= 0);
 	r = engine->RegisterObjectType("SInitInfo", sizeof(SInitInfo), asOBJ_VALUE | asGetTypeTraits<SInitInfo>()); ASSERT(r >= 0);
-	r = engine->RegisterObjectBehaviour("SInitInfo", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructSInitInfo), asCALL_CDECL_OBJLAST); ASSERT(r >= 0);
-	r = engine->RegisterObjectBehaviour("SInitInfo", asBEHAVE_CONSTRUCT, "void f(const SInitInfo& in)", asFUNCTION(ConstructCopySInitInfo), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectBehaviour("SInitInfo", asBEHAVE_DESTRUCT, "void f()", asFUNCTION(DestructSInitInfo), asCALL_CDECL_OBJLAST); ASSERT(r >= 0);
+	r = engine->RegisterObjectBehaviour("SInitInfo", asBEHAVE_CONSTRUCT, "void f()", (WebbarBind<ConstructSInitInfo, asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectBehaviour("SInitInfo", asBEHAVE_CONSTRUCT, "void f(const SInitInfo& in)", (WebbarBind<ConstructCopySInitInfo, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectBehaviour("SInitInfo", asBEHAVE_DESTRUCT, "void f()", (WebbarBind<DestructSInitInfo, asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("SInitInfo", "SArmorInfo armor", asOFFSET(SInitInfo, armor)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("SInitInfo", "SCategoryInfo category", asOFFSET(SInitInfo, category)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("SInitInfo", "array<string>@ profile", asOFFSET(SInitInfo, profile)); ASSERT(r >= 0);
@@ -491,129 +493,129 @@ void CInitScript::RegisterCore()
 	int r = engine->RegisterObjectType("AIFloat3", sizeof(AIFloat3),
 			asOBJ_VALUE | asOBJ_POD | asOBJ_APP_CLASS_ALLFLOATS | asOBJ_APP_CLASS_MORE_CONSTRUCTORS | asGetTypeTraits<AIFloat3>()); ASSERT(r >= 0);
 	cache->vec3Array = engine->GetTypeInfoByDecl("array<AIFloat3>");
-	r = engine->RegisterObjectBehaviour("AIFloat3", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(ConstructVec3), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectBehaviour("AIFloat3", asBEHAVE_CONSTRUCT, "void f(const AIFloat3& in)", asFUNCTION(ConstructCopyVec3), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectBehaviour("AIFloat3", asBEHAVE_CONSTRUCT, "void f(float)", asFUNCTION(ConstructVec3Val1), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectBehaviour("AIFloat3", asBEHAVE_CONSTRUCT, "void f(float, float, float)", asFUNCTION(ConstructVec3Val3), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
+	r = engine->RegisterObjectBehaviour("AIFloat3", asBEHAVE_CONSTRUCT, "void f()", (WebbarBind<ConstructVec3, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectBehaviour("AIFloat3", asBEHAVE_CONSTRUCT, "void f(const AIFloat3& in)", (WebbarBind<ConstructCopyVec3, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectBehaviour("AIFloat3", asBEHAVE_CONSTRUCT, "void f(float)", (WebbarBind<ConstructVec3Val1, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectBehaviour("AIFloat3", asBEHAVE_CONSTRUCT, "void f(float, float, float)", (WebbarBind<ConstructVec3Val3, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("AIFloat3", "float x", asOFFSET(float3, x)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("AIFloat3", "float y", asOFFSET(float3, y)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("AIFloat3", "float z", asOFFSET(float3, z)); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opAdd(const AIFloat3& in) const", asMETHODPR(float3, operator+, (const float3&) const, float3), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opAdd(float) const", asMETHODPR(float3, operator+, (const float) const, float3), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3& opAddAssign(const AIFloat3& in)", asMETHOD(float3, operator+=), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opSub(const AIFloat3& in) const", asMETHODPR(float3, operator-, (const float3&) const, float3), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opSub(float) const", asMETHODPR(float3, operator-, (const float) const, float3), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "void opSubAssign(const AIFloat3& in)", asMETHOD(float3, operator-=), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opNeg() const", asMETHODPR(float3, operator-, () const, float3), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opMul(const AIFloat3& in) const", asMETHODPR(float3, operator*, (const float3&) const, float3), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opMul(float) const", asMETHODPR(float3, operator*, (const float) const, float3), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opMul_r(float) const", asFUNCTIONPR(operator*, (float, const float3&), float3), asCALL_CDECL_OBJLAST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "void opMulAssign(const AIFloat3& in)", asMETHODPR(float3, operator*=, (const float3&), void), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3& opMulAssign(float)", asMETHODPR(float3, operator*=, (float), float3&), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opDiv(const AIFloat3& in) const", asMETHODPR(float3, operator/, (const float3&) const, float3), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opDiv(float) const", asMETHODPR(float3, operator/, (const float) const, float3), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "void opDivAssign(const AIFloat3& in)", asMETHODPR(float3, operator/=, (const float3&), void), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "void opDivAssign(float)", asMETHODPR(float3, operator/=, (const float), void), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "bool opEquals(const AIFloat3& in) const", asMETHOD(float3, operator==), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "float& opIndex(int)", asMETHODPR(float3, operator[], (const int), float&), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "const float& opIndex(int) const", asMETHODPR(float3, operator[], (const int) const, const float&), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "bool equals(const AIFloat3& in, const AIFloat3& in) const", asMETHOD(float3, equals), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "bool same(const AIFloat3& in) const", asMETHOD(float3, same), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "bool binarySame(const AIFloat3& in) const", asMETHOD(float3, binarySame), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "float dot(const AIFloat3& in) const", asMETHOD(float3, dot), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "float dot2D(const AIFloat3& in) const", asMETHOD(float3, dot2D), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 cross(const AIFloat3& in) const", asMETHOD(float3, cross), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 rotate(float, const AIFloat3& in) const", asMETHODPR(float3, rotate<false>, (float angle, const float3& axis) const, float3), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 rotateByUpVector(const AIFloat3& in, const AIFloat3& in) const", asMETHOD(float3, rotateByUpVector), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 rotate2D(const AIFloat3& in) const", asMETHOD(float3, rotate2D), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 snapToAxis() const", asMETHOD(float3, snapToAxis), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "float distance(const AIFloat3& in) const", asMETHOD(float3, distance), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "float distance2D(const AIFloat3& in) const", asMETHODPR(float3, distance2D, (const float3&) const, float), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "float SqDistance(const AIFloat3& in) const", asMETHOD(float3, SqDistance), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "float SqDistance2D(const AIFloat3& in) const", asMETHODPR(float3, SqDistance2D, (const float3&) const, float), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "float Length() const", asMETHOD(float3, Length), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "float Length2D() const", asMETHOD(float3, Length2D), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "float SqLength() const", asMETHOD(float3, SqLength), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "float SqLength2D() const", asMETHOD(float3, SqLength2D), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "float LengthNormalize()", asMETHOD(float3, LengthNormalize), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "float LengthNormalize2D()", asMETHOD(float3, LengthNormalize2D), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3& Normalize()", asMETHOD(float3, Normalize), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3& Normalize2D()", asMETHOD(float3, Normalize2D), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3& SafeNormalize()", asMETHOD(float3, SafeNormalize), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3& SafeNormalize2D()", asMETHOD(float3, SafeNormalize2D), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 PickNonParallel() const", asMETHOD(float3, PickNonParallel), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "bool Normalized() const", asMETHOD(float3, Normalized), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "bool CheckNaNs() const", asMETHOD(float3, CheckNaNs), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "bool IsInMap() const", asMETHOD(float3, IsInMap), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "void ClampInMap()", asMETHOD(float3, ClampInMap), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "string str() const", asMETHOD(float3, str), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("AIFloat3", "string ToString() const", asMETHOD(AIFloat3, ToString), asCALL_THISCALL); ASSERT(r >= 0);  // HAX
-	r = engine->RegisterObjectMethod("AIFloat3", "string opImplConv() const", asFUNCTION(ConvertVec3ToStr), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("AIFloat3 AiMin(const AIFloat3, const AIFloat3)", asFUNCTION(float3::min), asCALL_CDECL); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("AIFloat3 AiMax(const AIFloat3, const AIFloat3)", asFUNCTION(float3::max), asCALL_CDECL); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("AIFloat3 AiFabs(const AIFloat3)", asFUNCTION(float3::fabs), asCALL_CDECL); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("AIFloat3 AiSign(const AIFloat3)", asFUNCTION(float3::sign), asCALL_CDECL); ASSERT(r >= 0);
-
-	r = engine->RegisterObjectMethod("AIFloat3", "bool IsInRange(const AIFloat3& in, float) const", asFUNCTION(geom::is_in_range), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opAdd(const AIFloat3& in) const", (WebbarBind<static_cast<float3 (float3::*)(const float3&) const>(&float3::operator+), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opAdd(float) const", (WebbarBind<static_cast<float3 (float3::*)(const float) const>(&float3::operator+), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3& opAddAssign(const AIFloat3& in)", (WebbarBind<&float3::operator+=, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opSub(const AIFloat3& in) const", (WebbarBind<static_cast<float3 (float3::*)(const float3&) const>(&float3::operator-), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opSub(float) const", (WebbarBind<static_cast<float3 (float3::*)(const float) const>(&float3::operator-), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "void opSubAssign(const AIFloat3& in)", (WebbarBind<&float3::operator-=, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opNeg() const", (WebbarBind<static_cast<float3 (float3::*)() const>(&float3::operator-), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opMul(const AIFloat3& in) const", (WebbarBind<static_cast<float3 (float3::*)(const float3&) const>(&float3::operator*), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opMul(float) const", (WebbarBind<static_cast<float3 (float3::*)(const float) const>(&float3::operator*), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opMul_r(float) const", (WebbarBind<static_cast<float3 (*)(float, const float3&)>(operator*), asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "void opMulAssign(const AIFloat3& in)", (WebbarBind<static_cast<void (float3::*)(const float3&)>(&float3::operator*=), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3& opMulAssign(float)", (WebbarBind<static_cast<float3& (float3::*)(float)>(&float3::operator*=), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opDiv(const AIFloat3& in) const", (WebbarBind<static_cast<float3 (float3::*)(const float3&) const>(&float3::operator/), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 opDiv(float) const", (WebbarBind<static_cast<float3 (float3::*)(const float) const>(&float3::operator/), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "void opDivAssign(const AIFloat3& in)", (WebbarBind<static_cast<void (float3::*)(const float3&)>(&float3::operator/=), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "void opDivAssign(float)", (WebbarBind<static_cast<void (float3::*)(const float)>(&float3::operator/=), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "bool opEquals(const AIFloat3& in) const", (WebbarBind<&float3::operator==, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "float& opIndex(int)", (WebbarBind<static_cast<float& (float3::*)(const int)>(&float3::operator[]), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "const float& opIndex(int) const", (WebbarBind<static_cast<const float& (float3::*)(const int) const>(&float3::operator[]), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "bool equals(const AIFloat3& in, const AIFloat3& in) const", (WebbarBind<&float3::equals, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "bool same(const AIFloat3& in) const", (WebbarBind<&float3::same, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "bool binarySame(const AIFloat3& in) const", (WebbarBind<&float3::binarySame, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "float dot(const AIFloat3& in) const", (WebbarBind<&float3::dot, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "float dot2D(const AIFloat3& in) const", (WebbarBind<&float3::dot2D, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 cross(const AIFloat3& in) const", (WebbarBind<&float3::cross, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 rotate(float, const AIFloat3& in) const", (WebbarBind<static_cast<float3 (float3::*)(float angle, const float3& axis) const>(&float3::rotate<false>), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 rotateByUpVector(const AIFloat3& in, const AIFloat3& in) const", (WebbarBind<&float3::rotateByUpVector, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 rotate2D(const AIFloat3& in) const", (WebbarBind<&float3::rotate2D, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 snapToAxis() const", (WebbarBind<&float3::snapToAxis, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "float distance(const AIFloat3& in) const", (WebbarBind<&float3::distance, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "float distance2D(const AIFloat3& in) const", (WebbarBind<static_cast<float (float3::*)(const float3&) const>(&float3::distance2D), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "float SqDistance(const AIFloat3& in) const", (WebbarBind<&float3::SqDistance, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "float SqDistance2D(const AIFloat3& in) const", (WebbarBind<static_cast<float (float3::*)(const float3&) const>(&float3::SqDistance2D), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "float Length() const", (WebbarBind<&float3::Length, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "float Length2D() const", (WebbarBind<&float3::Length2D, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "float SqLength() const", (WebbarBind<&float3::SqLength, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "float SqLength2D() const", (WebbarBind<&float3::SqLength2D, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "float LengthNormalize()", (WebbarBind<&float3::LengthNormalize, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "float LengthNormalize2D()", (WebbarBind<&float3::LengthNormalize2D, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3& Normalize()", (WebbarBind<&float3::Normalize, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3& Normalize2D()", (WebbarBind<&float3::Normalize2D, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3& SafeNormalize()", (WebbarBind<&float3::SafeNormalize, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3& SafeNormalize2D()", (WebbarBind<&float3::SafeNormalize2D, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "AIFloat3 PickNonParallel() const", (WebbarBind<&float3::PickNonParallel, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "bool Normalized() const", (WebbarBind<&float3::Normalized, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "bool CheckNaNs() const", (WebbarBind<&float3::CheckNaNs, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "bool IsInMap() const", (WebbarBind<&float3::IsInMap, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "void ClampInMap()", (WebbarBind<&float3::ClampInMap, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "string str() const", (WebbarBind<&float3::str, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("AIFloat3", "string ToString() const", (WebbarBind<&AIFloat3::ToString, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);  // HAX
+	r = engine->RegisterObjectMethod("AIFloat3", "string opImplConv() const", (WebbarBind<ConvertVec3ToStr, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("AIFloat3 AiMin(const AIFloat3, const AIFloat3)", (WebbarBind<float3::min, asCALL_CDECL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("AIFloat3 AiMax(const AIFloat3, const AIFloat3)", (WebbarBind<float3::max, asCALL_CDECL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("AIFloat3 AiFabs(const AIFloat3)", (WebbarBind<float3::fabs, asCALL_CDECL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("AIFloat3 AiSign(const AIFloat3)", (WebbarBind<float3::sign, asCALL_CDECL>()), asCALL_GENERIC); ASSERT(r >= 0);
+
+	r = engine->RegisterObjectMethod("AIFloat3", "bool IsInRange(const AIFloat3& in, float) const", (WebbarBind<geom::is_in_range, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
 
 	// RegisterGeometry
 	geom::CPolygon::RegisterRefCounted(engine, "CPolygon");
-	r = engine->RegisterObjectBehaviour("CPolygon", asBEHAVE_FACTORY, "CPolygon@ f(const array<AIFloat3>@+)", asFUNCTION(FactoryCPolygon), asCALL_CDECL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CPolygon", "array<AIFloat3>@ GetVerts() const", asFUNCTION(CPolygon_GetVerts), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
+	r = engine->RegisterObjectBehaviour("CPolygon", asBEHAVE_FACTORY, "CPolygon@ f(const array<AIFloat3>@+)", (WebbarBind<FactoryCPolygon, asCALL_CDECL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CPolygon", "array<AIFloat3>@ GetVerts() const", (WebbarBind<CPolygon_GetVerts, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CPolygon", "const float area", asOFFSET(geom::CPolygon, area)); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CPolygon", "bool ContainsPoint(const AIFloat3& in) const", asMETHOD(geom::CPolygon, ContainsPoint), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CPolygon", "AIFloat3 Random() const", asMETHOD(geom::CPolygon, Random), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CPolygon", "void Scale(float)", asMETHOD(geom::CPolygon, Scale), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CPolygon", "void Extend(float)", asMETHOD(geom::CPolygon, Extend), asCALL_THISCALL); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CPolygon", "bool ContainsPoint(const AIFloat3& in) const", (WebbarBind<&geom::CPolygon::ContainsPoint, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CPolygon", "AIFloat3 Random() const", (WebbarBind<&geom::CPolygon::Random, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CPolygon", "void Scale(float)", (WebbarBind<&geom::CPolygon::Scale, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CPolygon", "void Extend(float)", (WebbarBind<&geom::CPolygon::Extend, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 
 	// RegisterUtils
 //	asbind20::global(engine)
 //		.function("void AiLog(const string& in)", &CInitScript::Log, asbind20::auxiliary(this));
-	r = engine->RegisterGlobalFunction("void AiLog(const string& in)", asMETHOD(CInitScript, Log), asCALL_THISCALL_ASGLOBAL, this); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("void AiAddPoint(const AIFloat3& in, const string& in)", asMETHOD(CInitScript, AddPoint), asCALL_THISCALL_ASGLOBAL, this); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("void AiDelPoint(const AIFloat3& in)", asMETHOD(CInitScript, DelPoint), asCALL_THISCALL_ASGLOBAL, this); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("void AiAddLine(const AIFloat3& in, const AIFloat3& in)", asMETHOD(CInitScript, AddLine), asCALL_THISCALL_ASGLOBAL, this); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("void AiPause(bool, const string& in)", asMETHOD(CInitScript, Pause), asCALL_THISCALL_ASGLOBAL, this); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("int AiDice(const array<float>@+)", asMETHOD(CInitScript, Dice), asCALL_THISCALL_ASGLOBAL, this); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("int AiNearestPointIdx(const AIFloat3& in, const array<AIFloat3>@+)", asMETHOD(CInitScript, NearestPointIdx), asCALL_THISCALL_ASGLOBAL, this); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("int AiMin(int, int)", asMETHODPR(CInitScript, Min<int>, (int, int) const, int), asCALL_THISCALL_ASGLOBAL, this); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("float AiMin(float, float)", asMETHODPR(CInitScript, Min<float>, (float, float) const, float), asCALL_THISCALL_ASGLOBAL, this); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("int AiMax(int, int)", asMETHODPR(CInitScript, Max<int>, (int, int) const, int), asCALL_THISCALL_ASGLOBAL, this); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("float AiMax(float, float)", asMETHODPR(CInitScript, Max<float>, (float, float) const, float), asCALL_THISCALL_ASGLOBAL, this); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("int AiRandom(int, int)", asMETHOD(CInitScript, Random), asCALL_THISCALL_ASGLOBAL, this); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("void AiSendMessage(const string& in, int = -1)", asMETHOD(CInitScript, SendMessage), asCALL_THISCALL_ASGLOBAL, this); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("void AiLog(const string& in)", (WebbarBind<&CInitScript::Log, asCALL_THISCALL_ASGLOBAL>()), asCALL_GENERIC, this); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("void AiAddPoint(const AIFloat3& in, const string& in)", (WebbarBind<&CInitScript::AddPoint, asCALL_THISCALL_ASGLOBAL>()), asCALL_GENERIC, this); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("void AiDelPoint(const AIFloat3& in)", (WebbarBind<&CInitScript::DelPoint, asCALL_THISCALL_ASGLOBAL>()), asCALL_GENERIC, this); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("void AiAddLine(const AIFloat3& in, const AIFloat3& in)", (WebbarBind<&CInitScript::AddLine, asCALL_THISCALL_ASGLOBAL>()), asCALL_GENERIC, this); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("void AiPause(bool, const string& in)", (WebbarBind<&CInitScript::Pause, asCALL_THISCALL_ASGLOBAL>()), asCALL_GENERIC, this); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("int AiDice(const array<float>@+)", (WebbarBind<&CInitScript::Dice, asCALL_THISCALL_ASGLOBAL>()), asCALL_GENERIC, this); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("int AiNearestPointIdx(const AIFloat3& in, const array<AIFloat3>@+)", (WebbarBind<&CInitScript::NearestPointIdx, asCALL_THISCALL_ASGLOBAL>()), asCALL_GENERIC, this); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("int AiMin(int, int)", (WebbarBind<static_cast<int (CInitScript::*)(int, int) const>(&CInitScript::Min<int>), asCALL_THISCALL_ASGLOBAL>()), asCALL_GENERIC, this); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("float AiMin(float, float)", (WebbarBind<static_cast<float (CInitScript::*)(float, float) const>(&CInitScript::Min<float>), asCALL_THISCALL_ASGLOBAL>()), asCALL_GENERIC, this); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("int AiMax(int, int)", (WebbarBind<static_cast<int (CInitScript::*)(int, int) const>(&CInitScript::Max<int>), asCALL_THISCALL_ASGLOBAL>()), asCALL_GENERIC, this); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("float AiMax(float, float)", (WebbarBind<static_cast<float (CInitScript::*)(float, float) const>(&CInitScript::Max<float>), asCALL_THISCALL_ASGLOBAL>()), asCALL_GENERIC, this); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("int AiRandom(int, int)", (WebbarBind<&CInitScript::Random, asCALL_THISCALL_ASGLOBAL>()), asCALL_GENERIC, this); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("void AiSendMessage(const string& in, int = -1)", (WebbarBind<&CInitScript::SendMessage, asCALL_THISCALL_ASGLOBAL>()), asCALL_GENERIC, this); ASSERT(r >= 0);
 	r = engine->RegisterFuncdef("void AiOnFinish(dictionary@+)"); ASSERT(r >= 0);
 	r = engine->RegisterFuncdef("AiOnFinish@+ AiExec(dictionary@+)"); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("void AiRun(AiExec@+, dictionary@)", asMETHOD(CInitScript, Run), asCALL_THISCALL_ASGLOBAL, this); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("void AiSleep(uint64)", asFUNCTION(utils::sleep), asCALL_CDECL); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("void AiRun(AiExec@+, dictionary@)", (WebbarBind<&CInitScript::Run, asCALL_THISCALL_ASGLOBAL>()), asCALL_GENERIC, this); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("void AiSleep(uint64)", (WebbarBind<utils::sleep, asCALL_CDECL>()), asCALL_GENERIC); ASSERT(r >= 0);
 
 	r = engine->RegisterObjectType("IStream", sizeof(std::istream), asOBJ_REF | asOBJ_NOCOUNT); ASSERT(r >= 0);
 	r = engine->RegisterObjectType("OStream", sizeof(std::ostream), asOBJ_REF | asOBJ_NOCOUNT); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(bool& out)", asFUNCTION(utils::binary_read<bool>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(int8& out)", asFUNCTION(utils::binary_read<int8_t>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(int16& out)", asFUNCTION(utils::binary_read<int16_t>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(int& out)", asFUNCTION(utils::binary_read<int32_t>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(int64& out)", asFUNCTION(utils::binary_read<int64_t>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(uint8& out)", asFUNCTION(utils::binary_read<uint8_t>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(uint16& out)", asFUNCTION(utils::binary_read<uint16_t>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(uint& out)", asFUNCTION(utils::binary_read<uint32_t>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(uint64& out)", asFUNCTION(utils::binary_read<uint64_t>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(float& out)", asFUNCTION(utils::binary_read<float>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(double& out)", asFUNCTION(utils::binary_read<double>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const bool& in)", asFUNCTION(utils::binary_write<bool>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const int8& in)", asFUNCTION(utils::binary_write<int8_t>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const int16& in)", asFUNCTION(utils::binary_write<int16_t>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const int& in)", asFUNCTION(utils::binary_write<int32_t>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const int64& in)", asFUNCTION(utils::binary_write<int64_t>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const uint8& in)", asFUNCTION(utils::binary_write<uint8_t>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const uint16& in)", asFUNCTION(utils::binary_write<uint16_t>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const uint& in)", asFUNCTION(utils::binary_write<uint32_t>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const uint64& in)", asFUNCTION(utils::binary_write<uint64_t>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const float& in)", asFUNCTION(utils::binary_write<float>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const double& in)", asFUNCTION(utils::binary_write<double>), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-
-	r = engine->RegisterObjectMethod("string", "string toLower() const", asFUNCTION(utils::StringToLower), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("string", "string toUpper() const", asFUNCTION(utils::StringToUpper), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(bool& out)", (WebbarBind<utils::binary_read<bool>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(int8& out)", (WebbarBind<utils::binary_read<int8_t>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(int16& out)", (WebbarBind<utils::binary_read<int16_t>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(int& out)", (WebbarBind<utils::binary_read<int32_t>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(int64& out)", (WebbarBind<utils::binary_read<int64_t>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(uint8& out)", (WebbarBind<utils::binary_read<uint8_t>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(uint16& out)", (WebbarBind<utils::binary_read<uint16_t>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(uint& out)", (WebbarBind<utils::binary_read<uint32_t>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(uint64& out)", (WebbarBind<utils::binary_read<uint64_t>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(float& out)", (WebbarBind<utils::binary_read<float>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("IStream", "IStream& opShr(double& out)", (WebbarBind<utils::binary_read<double>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const bool& in)", (WebbarBind<utils::binary_write<bool>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const int8& in)", (WebbarBind<utils::binary_write<int8_t>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const int16& in)", (WebbarBind<utils::binary_write<int16_t>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const int& in)", (WebbarBind<utils::binary_write<int32_t>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const int64& in)", (WebbarBind<utils::binary_write<int64_t>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const uint8& in)", (WebbarBind<utils::binary_write<uint8_t>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const uint16& in)", (WebbarBind<utils::binary_write<uint16_t>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const uint& in)", (WebbarBind<utils::binary_write<uint32_t>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const uint64& in)", (WebbarBind<utils::binary_write<uint64_t>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const float& in)", (WebbarBind<utils::binary_write<float>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("OStream", "OStream& opShl(const double& in)", (WebbarBind<utils::binary_write<double>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+
+	r = engine->RegisterObjectMethod("string", "string toLower() const", (WebbarBind<utils::StringToLower, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("string", "string toUpper() const", (WebbarBind<utils::StringToUpper, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
 
 	// RegisterCircuitAI
 	r = engine->RegisterTypedef("Id", "int"); ASSERT(r >= 0);
@@ -643,29 +645,29 @@ void CInitScript::RegisterCore()
 	r = engine->RegisterObjectProperty("CCircuitAI", "const int skirmishAIId", asOFFSET(CCircuitAI, skirmishAIId)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CCircuitAI", "const int teamId", asOFFSET(CCircuitAI, teamId)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CCircuitAI", "const int allyTeamId", asOFFSET(CCircuitAI, allyTeamId)); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitAI", "CCircuitDef@ GetCircuitDef(const string& in)", asFUNCTION(CCircuitAI_GetCircuitDef), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitAI", "CCircuitDef@ GetCircuitDef(Id)", asMETHODPR(CCircuitAI, GetCircuitDef, (CCircuitDef::Id), CCircuitDef*), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitAI", "int GetDefCount() const", asMETHOD(CCircuitAI, GetDefCount), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitAI", "CCircuitUnit@ GetTeamUnit(Id)", asMETHOD(CCircuitAI, GetTeamUnit), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitAI", "string GetMapName() const", asFUNCTION(CCircuitAI_GetMapName), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitAI", "int GetEnemyTeamSize() const", asMETHOD(CCircuitAI, GetEnemyTeamSize), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitAI", "bool IsLoadSave() const", asMETHOD(CCircuitAI, IsLoadSave), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitAI", "Type GetBindedRole(Type) const", asMETHOD(CCircuitAI, GetBindedRole), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitAI", "int GetLeadTeamId() const", asFUNCTION(CCircuitAI_GetLeadTeamId), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitAI", "Type GetSideId() const", asMETHOD(CCircuitAI, GetSideId), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitAI", "const string& GetSideName() const", asMETHOD(CCircuitAI, GetSideName), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitAI", "array<Id>@ GetTeamIds() const", asFUNCTION(CCircuitAI_GetTeamIds), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitAI", "void GiveUnits(const array<CCircuitUnit@>@+, int)", asFUNCTION(CCircuitAI_GiveUnits), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitAI", "bool UnitControl(CCircuitUnit@, bool)", asMETHODPR(CCircuitAI, UnitControl, (CCircuitUnit*, bool), bool), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitAI", "bool UnitControl(Id, bool)", asMETHODPR(CCircuitAI, UnitControl, (ICoreUnit::Id, bool), bool), asCALL_THISCALL); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "CCircuitDef@ GetCircuitDef(const string& in)", (WebbarBind<CCircuitAI_GetCircuitDef, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "CCircuitDef@ GetCircuitDef(Id)", (WebbarBind<static_cast<CCircuitDef* (CCircuitAI::*)(CCircuitDef::Id)>(&CCircuitAI::GetCircuitDef), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "int GetDefCount() const", (WebbarBind<&CCircuitAI::GetDefCount, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "CCircuitUnit@ GetTeamUnit(Id)", (WebbarBind<&CCircuitAI::GetTeamUnit, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "string GetMapName() const", (WebbarBind<CCircuitAI_GetMapName, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "int GetEnemyTeamSize() const", (WebbarBind<&CCircuitAI::GetEnemyTeamSize, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "bool IsLoadSave() const", (WebbarBind<&CCircuitAI::IsLoadSave, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "Type GetBindedRole(Type) const", (WebbarBind<&CCircuitAI::GetBindedRole, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "int GetLeadTeamId() const", (WebbarBind<CCircuitAI_GetLeadTeamId, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "Type GetSideId() const", (WebbarBind<&CCircuitAI::GetSideId, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "const string& GetSideName() const", (WebbarBind<&CCircuitAI::GetSideName, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "array<Id>@ GetTeamIds() const", (WebbarBind<CCircuitAI_GetTeamIds, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "void GiveUnits(const array<CCircuitUnit@>@+, int)", (WebbarBind<CCircuitAI_GiveUnits, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "bool UnitControl(CCircuitUnit@, bool)", (WebbarBind<static_cast<bool (CCircuitAI::*)(CCircuitUnit*, bool)>(&CCircuitAI::UnitControl), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "bool UnitControl(Id, bool)", (WebbarBind<static_cast<bool (CCircuitAI::*)(ICoreUnit::Id, bool)>(&CCircuitAI::UnitControl), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 	// Lua<-->AI communications [in Spring 0.83+]
-	r = engine->RegisterObjectMethod("CCircuitAI", "string CallRules(const string& in)", asFUNCTION(CCircuitAI_CallRules), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitAI", "string CallUI(const string& in)", asFUNCTION(CCircuitAI_CallUI), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "string CallRules(const string& in)", (WebbarBind<CCircuitAI_CallRules, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "string CallUI(const string& in)", (WebbarBind<CCircuitAI_CallUI, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
 	// RulesParams accessors on AI (game/team)
-	r = engine->RegisterObjectMethod("CCircuitAI", "float GetGameRulesParam(const string& in, float) const", asFUNCTION(CCircuitAI_GetGameRulesParamFloat), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitAI", "string GetGameRulesParam(const string& in, const string& in) const", asFUNCTION(CCircuitAI_GetGameRulesParamString), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitAI", "float GetTeamRulesParam(const string& in, float) const", asFUNCTION(CCircuitAI_GetTeamRulesParamFloat), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitAI", "string GetTeamRulesParam(const string& in, const string& in) const", asFUNCTION(CCircuitAI_GetTeamRulesParamString), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "float GetGameRulesParam(const string& in, float) const", (WebbarBind<CCircuitAI_GetGameRulesParamFloat, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "string GetGameRulesParam(const string& in, const string& in) const", (WebbarBind<CCircuitAI_GetGameRulesParamString, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "float GetTeamRulesParam(const string& in, float) const", (WebbarBind<CCircuitAI_GetTeamRulesParamFloat, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitAI", "string GetTeamRulesParam(const string& in, const string& in) const", (WebbarBind<CCircuitAI_GetTeamRulesParamString, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
 
 	CMaskHandler* sideMasker = &circuit->GetGameAttribute()->GetSideMasker();
 	CMaskHandler* roleMasker = &circuit->GetGameAttribute()->GetRoleMasker();
@@ -674,21 +676,21 @@ void CInitScript::RegisterCore()
 	r = engine->RegisterGlobalProperty("CMaskHandler aiSideMasker", sideMasker); ASSERT(r >= 0);
 	r = engine->RegisterGlobalProperty("CMaskHandler aiRoleMasker", roleMasker); ASSERT(r >= 0);
 	r = engine->RegisterGlobalProperty("CMaskHandler aiAttrMasker", attrMasker); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CMaskHandler", "TypeMask GetTypeMask(const string& in)", asMETHOD(CMaskHandler, GetTypeMask), asCALL_THISCALL); ASSERT(r >= 0);
-
-	r = engine->RegisterGlobalFunction("TypeMask AiAddRole(const string& in, Type)", asMETHOD(CInitScript, AddRole), asCALL_THISCALL_ASGLOBAL, this); ASSERT(r >= 0);
-
-	r = engine->RegisterObjectMethod("CCircuitDef", "void SetMainRole(Type)", asMETHOD(CCircuitDef, SetMainRole), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "Type GetMainRole() const", asMETHOD(CCircuitDef, GetMainRole), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "bool IsRespRoleAny(Mask) const", asMETHOD(CCircuitDef, IsRespRoleAny), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "bool IsRoleAny(Mask) const", asMETHOD(CCircuitDef, IsRoleAny), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "void AddAttribute(Type)", asMETHOD(CCircuitDef, AddAttribute), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "void DelAttribute(Type)", asMETHOD(CCircuitDef, DelAttribute), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "void TglAttribute(Type)", asMETHOD(CCircuitDef, TglAttribute), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "bool IsAttrAny(Mask) const", asMETHOD(CCircuitDef, IsAttrAny), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "const string GetName() const", asFUNCTION(CCircuitDef_GetName), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CMaskHandler", "TypeMask GetTypeMask(const string& in)", (WebbarBind<&CMaskHandler::GetTypeMask, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+
+	r = engine->RegisterGlobalFunction("TypeMask AiAddRole(const string& in, Type)", (WebbarBind<&CInitScript::AddRole, asCALL_THISCALL_ASGLOBAL>()), asCALL_GENERIC, this); ASSERT(r >= 0);
+
+	r = engine->RegisterObjectMethod("CCircuitDef", "void SetMainRole(Type)", (WebbarBind<&CCircuitDef::SetMainRole, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "Type GetMainRole() const", (WebbarBind<&CCircuitDef::GetMainRole, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "bool IsRespRoleAny(Mask) const", (WebbarBind<&CCircuitDef::IsRespRoleAny, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "bool IsRoleAny(Mask) const", (WebbarBind<&CCircuitDef::IsRoleAny, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "void AddAttribute(Type)", (WebbarBind<&CCircuitDef::AddAttribute, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "void DelAttribute(Type)", (WebbarBind<&CCircuitDef::DelAttribute, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "void TglAttribute(Type)", (WebbarBind<&CCircuitDef::TglAttribute, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "bool IsAttrAny(Mask) const", (WebbarBind<&CCircuitDef::IsAttrAny, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "const string GetName() const", (WebbarBind<CCircuitDef_GetName, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CCircuitDef", "const Id id", asOFFSET(CCircuitDef, id)); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "bool IsAvailable(int)", asMETHODPR(CCircuitDef, IsAvailable, (int) const, bool), asCALL_THISCALL); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "bool IsAvailable(int)", (WebbarBind<static_cast<bool (CCircuitDef::*)(int) const>(&CCircuitDef::IsAvailable), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CCircuitDef", "const int count", asOFFSET(CCircuitDef, count)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CCircuitDef", "const float health", asOFFSET(CCircuitDef, health)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CCircuitDef", "const float speed", asOFFSET(CCircuitDef, speed)); ASSERT(r >= 0);
@@ -704,38 +706,38 @@ void CInitScript::RegisterCore()
 	r = engine->RegisterObjectProperty("CCircuitDef", "const float surfThrDmg", asOFFSET(CCircuitDef, surfThrDmg)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CCircuitDef", "const float waterThrDmg", asOFFSET(CCircuitDef, waterThrDmg)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CCircuitDef", "const float minRange", asOFFSET(CCircuitDef, minRange)); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "float GetMaxRange(Type) const", asMETHODPR(CCircuitDef, GetMaxRange, (CCircuitDef::RangeType) const, float), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "float GetMaxRange() const", asMETHODPR(CCircuitDef, GetMaxRange, () const, float), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "void SetRange(Type, float)", asMETHODPR(CCircuitDef, SetRange, (CCircuitDef::RangeType, float), void), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "void SetRange(float)", asMETHODPR(CCircuitDef, SetRange, (float), void), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "float GetAirThreat() const", asMETHOD(CCircuitDef, GetAirThreat), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "float GetSurfThreat() const", asMETHOD(CCircuitDef, GetSurfThreat), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "float GetWaterThreat() const", asMETHOD(CCircuitDef, GetWaterThreat), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "bool IsAbleToFly() const", asMETHOD(CCircuitDef, IsAbleToFly), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "bool IsMobile() const", asMETHOD(CCircuitDef, IsMobile), asCALL_THISCALL); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "float GetMaxRange(Type) const", (WebbarBind<static_cast<float (CCircuitDef::*)(CCircuitDef::RangeType) const>(&CCircuitDef::GetMaxRange), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "float GetMaxRange() const", (WebbarBind<static_cast<float (CCircuitDef::*)() const>(&CCircuitDef::GetMaxRange), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "void SetRange(Type, float)", (WebbarBind<static_cast<void (CCircuitDef::*)(CCircuitDef::RangeType, float)>(&CCircuitDef::SetRange), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "void SetRange(float)", (WebbarBind<static_cast<void (CCircuitDef::*)(float)>(&CCircuitDef::SetRange), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "float GetAirThreat() const", (WebbarBind<&CCircuitDef::GetAirThreat, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "float GetSurfThreat() const", (WebbarBind<&CCircuitDef::GetSurfThreat, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "float GetWaterThreat() const", (WebbarBind<&CCircuitDef::GetWaterThreat, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "bool IsAbleToFly() const", (WebbarBind<&CCircuitDef::IsAbleToFly, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "bool IsMobile() const", (WebbarBind<&CCircuitDef::IsMobile, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CCircuitDef", "int maxThisUnit", asOFFSET(CCircuitDef, maxThisUnit)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CCircuitDef", "int sinceFrame", asOFFSET(CCircuitDef, sinceFrame)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CCircuitDef", "int cooldown", asOFFSET(CCircuitDef, cooldown)); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "void SetIgnore(bool)", asMETHOD(CCircuitDef, SetIgnore), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "bool IsIgnore() const", asMETHOD(CCircuitDef, IsIgnore), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "void SetThreatKernel(float)", asMETHOD(CCircuitDef, SetThreatKernel), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "void SetFireState(int)", asMETHOD(CCircuitDef, SetFireState), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitDef", "int GetFireState() const", asMETHOD(CCircuitDef, GetFireState), asCALL_THISCALL); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "void SetIgnore(bool)", (WebbarBind<&CCircuitDef::SetIgnore, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "bool IsIgnore() const", (WebbarBind<&CCircuitDef::IsIgnore, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "void SetThreatKernel(float)", (WebbarBind<&CCircuitDef::SetThreatKernel, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "void SetFireState(int)", (WebbarBind<&CCircuitDef::SetFireState, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitDef", "int GetFireState() const", (WebbarBind<&CCircuitDef::GetFireState, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 
 	r = engine->RegisterObjectProperty("CCircuitUnit", "const Id id", asOFFSET(CCircuitUnit, id)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CCircuitUnit", "const CCircuitDef@ circuitDef", asOFFSET(CCircuitUnit, circuitDef)); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitUnit", "const AIFloat3& GetPos(int)", asMETHODPR(CCircuitUnit, GetPos, (int), const AIFloat3&), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitUnit", "void AddAttribute(Type)", asMETHOD(CCircuitUnit, AddAttribute), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitUnit", "void DelAttribute(Type)", asMETHOD(CCircuitUnit, DelAttribute), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitUnit", "void TglAttribute(Type)", asMETHOD(CCircuitUnit, TglAttribute), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitUnit", "bool IsAttrAny(Mask) const", asMETHOD(CCircuitUnit, IsAttrAny), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitUnit", "void SetFireState(int)", asMETHOD(CCircuitUnit, TrySetFireState), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitUnit", "void SetMoveState(int)", asMETHOD(CCircuitUnit, TrySetMoveState), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitUnit", "void SelfDestruct(bool)", asMETHOD(CCircuitUnit, CmdSelfD), asCALL_THISCALL); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitUnit", "const AIFloat3& GetPos(int)", (WebbarBind<static_cast<const AIFloat3& (CCircuitUnit::*)(int)>(&CCircuitUnit::GetPos), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitUnit", "void AddAttribute(Type)", (WebbarBind<&CCircuitUnit::AddAttribute, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitUnit", "void DelAttribute(Type)", (WebbarBind<&CCircuitUnit::DelAttribute, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitUnit", "void TglAttribute(Type)", (WebbarBind<&CCircuitUnit::TglAttribute, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitUnit", "bool IsAttrAny(Mask) const", (WebbarBind<&CCircuitUnit::IsAttrAny, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitUnit", "void SetFireState(int)", (WebbarBind<&CCircuitUnit::TrySetFireState, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitUnit", "void SetMoveState(int)", (WebbarBind<&CCircuitUnit::TrySetMoveState, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitUnit", "void SelfDestruct(bool)", (WebbarBind<&CCircuitUnit::CmdSelfD, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CCircuitUnit", "IUnitTask@ const task", asOFFSET(CCircuitUnit, task)); ASSERT(r >= 0);
 	// RulesParams accessor on Unit
-	r = engine->RegisterObjectMethod("CCircuitUnit", "float GetRulesParam(const string& in, float) const", asFUNCTION(CCircuitUnit_GetRulesParamFloat), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CCircuitUnit", "string GetRulesParam(const string& in, const string& in) const", asFUNCTION(CCircuitUnit_GetRulesParamString), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitUnit", "float GetRulesParam(const string& in, float) const", (WebbarBind<CCircuitUnit_GetRulesParamFloat, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CCircuitUnit", "string GetRulesParam(const string& in, const string& in) const", (WebbarBind<CCircuitUnit_GetRulesParamString, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
 }
 
 void CInitScript::RegisterMgr()
@@ -745,28 +747,28 @@ void CInitScript::RegisterMgr()
 	CTerrainManager* terrainMgr = circuit->GetTerrainManager();
 	int r = engine->RegisterObjectType("CTerrainManager", 0, asOBJ_REF | asOBJ_NOHANDLE); ASSERT(r >= 0);
 	r = engine->RegisterGlobalProperty("CTerrainManager aiTerrainMgr", terrainMgr); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("int AiTerrainWidth()", asFUNCTION(CTerrainManager::GetTerrainWidth), asCALL_CDECL); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("int AiTerrainHeight()", asFUNCTION(CTerrainManager::GetTerrainHeight), asCALL_CDECL); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("float AiTerrainDiagonal()", asFUNCTION(CTerrainManager::GetTerrainDiagonal), asCALL_CDECL); ASSERT(r >= 0);
-	r = engine->RegisterGlobalFunction("AIFloat3 AiTerrainCenter()", asFUNCTION(CTerrainManager::GetTerrainCenter), asCALL_CDECL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CTerrainManager", "bool IsWaterAVoid() const", asMETHOD(CTerrainManager, IsWaterAVoid), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CTerrainManager", "float GetLandPercent() const", asMETHOD(CTerrainManager, GetLandPercent), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CTerrainManager", "float SetAllyZoneRange(float)", asMETHOD(CTerrainManager, SetAllyZoneRange), asCALL_THISCALL); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("int AiTerrainWidth()", (WebbarBind<CTerrainManager::GetTerrainWidth, asCALL_CDECL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("int AiTerrainHeight()", (WebbarBind<CTerrainManager::GetTerrainHeight, asCALL_CDECL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("float AiTerrainDiagonal()", (WebbarBind<CTerrainManager::GetTerrainDiagonal, asCALL_CDECL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterGlobalFunction("AIFloat3 AiTerrainCenter()", (WebbarBind<CTerrainManager::GetTerrainCenter, asCALL_CDECL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CTerrainManager", "bool IsWaterAVoid() const", (WebbarBind<&CTerrainManager::IsWaterAVoid, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CTerrainManager", "float GetLandPercent() const", (WebbarBind<&CTerrainManager::GetLandPercent, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CTerrainManager", "float SetAllyZoneRange(float)", (WebbarBind<&CTerrainManager::SetAllyZoneRange, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 
 	r = engine->RegisterObjectProperty("CSetupManager", "const CCircuitDef@ commChoice", asOFFSET(CSetupManager, commChoice)); ASSERT(r >= 0);
 
 	CEnemyManager* enemyMgr = circuit->GetEnemyManager();
 	r = engine->RegisterObjectType("CEnemyManager", 0, asOBJ_REF | asOBJ_NOHANDLE); ASSERT(r >= 0);
 	r = engine->RegisterGlobalProperty("CEnemyManager aiEnemyMgr", enemyMgr); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CEnemyManager", "float GetEnemyThreat(Type) const", asMETHODPR(CEnemyManager, GetEnemyThreat, (CCircuitDef::RoleT) const, float), asCALL_THISCALL); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CEnemyManager", "float GetEnemyThreat(Type) const", (WebbarBind<static_cast<float (CEnemyManager::*)(CCircuitDef::RoleT) const>(&CEnemyManager::GetEnemyThreat), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CEnemyManager", "const float mobileThreat", asOFFSET(CEnemyManager, mobileThreat)); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CEnemyManager", "float GetEnemyCost(Type) const", asMETHOD(CEnemyManager, GetEnemyCost), asCALL_THISCALL); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CEnemyManager", "float GetEnemyCost(Type) const", (WebbarBind<&CEnemyManager::GetEnemyCost, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CEnemyManager", "float maxAAThreat", asOFFSET(CEnemyManager, maxAAThreat)); ASSERT(r >= 0);
 
 	CThreatMap* thrMap = circuit->GetThreatMap();
 	r = engine->RegisterObjectType("CThreatMap", 0, asOBJ_REF | asOBJ_NOHANDLE); ASSERT(r >= 0);
 	r = engine->RegisterGlobalProperty("CThreatMap aiThreat", thrMap); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CThreatMap", "void ApplyRange(CCircuitDef@)", asMETHOD(CThreatMap, ApplyRange), asCALL_THISCALL); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CThreatMap", "void ApplyRange(CCircuitDef@)", (WebbarBind<&CThreatMap::ApplyRange, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 }
 
 bool CInitScript::Init()
@@ -842,10 +844,10 @@ void CInitScript::RegisterIUnitTask(asIScriptEngine* engine, const char* cls)
 {
 	T::RegisterRefCounted(engine, cls);
 	int r;
-	r = engine->RegisterObjectMethod(cls, "Type GetType() const", asMETHODPR(T, GetType, () const, IUnitTask::Type), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod(cls, "array<CCircuitUnit@>@ GetUnits() const", asFUNCTION(IUnitTask_GetUnits), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod(cls, "void Abort()", asMETHOD(T, Abort), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod(cls, "void Done()", asMETHOD(T, Done), asCALL_THISCALL); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod(cls, "Type GetType() const", (WebbarBind<static_cast<IUnitTask::Type (T::*)() const>(&T::GetType), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod(cls, "array<CCircuitUnit@>@ GetUnits() const", (WebbarBind<IUnitTask_GetUnits, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod(cls, "void Abort()", (WebbarBind<&T::Abort, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod(cls, "void Done()", (WebbarBind<&T::Done, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 }
 
 template <class T>
@@ -854,8 +856,8 @@ void CInitScript::RegisterIBuilderTask(asIScriptEngine* engine, const char* cls)
 	RegisterIUnitTask<T>(engine, cls);
 	RegisterCast<IUnitTask, T>(engine, "IUnitTask", cls);
 	int r;
-	r = engine->RegisterObjectMethod(cls, "Type GetBuildType() const", asMETHODPR(T, GetBuildType, () const, IBuilderTask::BuildType), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod(cls, "const AIFloat3& GetBuildPos() const", asMETHODPR(T, GetPosition, () const, const AIFloat3&), asCALL_THISCALL); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod(cls, "Type GetBuildType() const", (WebbarBind<static_cast<IBuilderTask::BuildType (T::*)() const>(&T::GetBuildType), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod(cls, "const AIFloat3& GetBuildPos() const", (WebbarBind<static_cast<const AIFloat3& (T::*)() const>(&T::GetPosition), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty(cls, "CCircuitDef@ const buildDef", asOFFSET(T, buildDef)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty(cls, "CCircuitUnit@ const target", asOFFSET(T, target)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty(cls, "bool canAutoAbort", asOFFSET(T, canAutoAbort)); ASSERT(r >= 0);
@@ -866,14 +868,14 @@ void CInitScript::RegisterIFighterTask(asIScriptEngine* engine, const char* cls)
 {
 	RegisterIUnitTask<T>(engine, cls);
 	RegisterCast<IUnitTask, T>(engine, "IUnitTask", cls);
-	int r = engine->RegisterObjectMethod(cls, "Type GetFightType() const", asMETHODPR(T, GetFightType, () const, IFighterTask::FightType), asCALL_THISCALL); ASSERT(r >= 0);
+	int r = engine->RegisterObjectMethod(cls, "Type GetFightType() const", (WebbarBind<static_cast<IFighterTask::FightType (T::*)() const>(&T::GetFightType), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 }
 
 void CInitScript::RegisterCSuperTask(asIScriptEngine* engine)
 {
 	RegisterIFighterTask<CSuperTask>(engine, "CSuperTask");
 	RegisterCast<IFighterTask, CSuperTask>(engine, "IFighterTask", "CSuperTask");
-	int r = engine->RegisterObjectMethod("CSuperTask", "void SetTargetPos(const AIFloat3& in)", asMETHOD(CSuperTask, SetTargetPos), asCALL_THISCALL); ASSERT(r >= 0);
+	int r = engine->RegisterObjectMethod("CSuperTask", "void SetTargetPos(const AIFloat3& in)", (WebbarBind<&CSuperTask::SetTargetPos, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 }
 
 void CInitScript::RegisterUnitTasks(asIScriptEngine* engine)
diff --git a/src/circuit/script/MilitaryScript.cpp b/src/circuit/script/MilitaryScript.cpp
index 8963398..4e358af 100644
--- a/src/circuit/script/MilitaryScript.cpp
+++ b/src/circuit/script/MilitaryScript.cpp
@@ -5,6 +5,8 @@
  *      Author: rlcevg
  */
 
+// Codex-assisted portable script bindings for the Webbar WASM experiment.
+#include "WebbarBindings.h"
 #include "script/MilitaryScript.h"
 #include "script/ScriptManager.h"
 #include "module/MilitaryManager.h"
@@ -32,11 +34,11 @@ CMilitaryScript::CMilitaryScript(CScriptManager* scr, CMilitaryManager* mgr)
 
 	r = engine->RegisterObjectType("CMilitaryManager", 0, asOBJ_REF | asOBJ_NOHANDLE); ASSERT(r >= 0);
 	r = engine->RegisterGlobalProperty("CMilitaryManager aiMilitaryMgr", manager); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CMilitaryManager", "IUnitTask@+ DefaultMakeTask(CCircuitUnit@)", asMETHOD(CMilitaryManager, DefaultMakeTask), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CMilitaryManager", "IUnitTask@+ Enqueue(const SFightTask& in)", asMETHODPR(CMilitaryManager, Enqueue, (const TaskF::SFightTask&), IFighterTask*), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CMilitaryManager", "IUnitTask@+ EnqueueRetreat()", asMETHOD(CMilitaryManager, EnqueueRetreat), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CMilitaryManager", "void DefaultMakeDefence(int, const AIFloat3& in)", asMETHOD(CMilitaryManager, DefaultMakeDefence), asCALL_THISCALL); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CMilitaryManager", "uint GetGuardTaskNum() const", asMETHOD(CMilitaryManager, GetGuardTaskNum), asCALL_THISCALL); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CMilitaryManager", "IUnitTask@+ DefaultMakeTask(CCircuitUnit@)", (WebbarBind<&CMilitaryManager::DefaultMakeTask, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CMilitaryManager", "IUnitTask@+ Enqueue(const SFightTask& in)", (WebbarBind<static_cast<IFighterTask* (CMilitaryManager::*)(const TaskF::SFightTask&)>(&CMilitaryManager::Enqueue), asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CMilitaryManager", "IUnitTask@+ EnqueueRetreat()", (WebbarBind<&CMilitaryManager::EnqueueRetreat, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CMilitaryManager", "void DefaultMakeDefence(int, const AIFloat3& in)", (WebbarBind<&CMilitaryManager::DefaultMakeDefence, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CMilitaryManager", "uint GetGuardTaskNum() const", (WebbarBind<&CMilitaryManager::GetGuardTaskNum, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("CMilitaryManager", "const float armyCost", asOFFSET(CMilitaryManager, armyCost)); ASSERT(r >= 0);
 
 	// NOTE: Config's "quota" scattered across CMilitaryManager, CEnemyManager, CThreatMap, CFactoryManager, CSetupManager
@@ -61,8 +63,8 @@ CMilitaryScript::CMilitaryScript(CScriptManager* scr, CMilitaryManager* mgr)
 	r = engine->RegisterObjectProperty("SVsInfo", "Type role", asOFFSET(CMilitaryManager::SRoleInfo::SVsInfo, role)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("SVsInfo", "float ratio", asOFFSET(CMilitaryManager::SRoleInfo::SVsInfo, ratio)); ASSERT(r >= 0);
 	r = engine->RegisterObjectProperty("SVsInfo", "float importance", asOFFSET(CMilitaryManager::SRoleInfo::SVsInfo, importance)); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("SResponseInfo", "SVsInfo@ GetVsInfo(Type) const", asFUNCTION(CMilitaryScript::GetVsInfo), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CMilitaryManager", "SResponseInfo@ GetResponseInfo(Type) const", asMETHOD(CMilitaryManager, GetRoleInfo), asCALL_THISCALL); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("SResponseInfo", "SVsInfo@ GetVsInfo(Type) const", (WebbarBind<CMilitaryScript::GetVsInfo, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CMilitaryManager", "SResponseInfo@ GetResponseInfo(Type) const", (WebbarBind<&CMilitaryManager::GetRoleInfo, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 }
 
 CMilitaryScript::~CMilitaryScript()
diff --git a/src/circuit/script/RefCounter.h b/src/circuit/script/RefCounter.h
index ed7b80d..31cd421 100644
--- a/src/circuit/script/RefCounter.h
+++ b/src/circuit/script/RefCounter.h
@@ -8,6 +8,8 @@
 #ifndef SRC_CIRCUIT_SCRIPT_REFCOUNTER_H_
 #define SRC_CIRCUIT_SCRIPT_REFCOUNTER_H_
 
+// Codex-assisted portable script bindings for the Webbar WASM experiment.
+#include "WebbarBindings.h"
 #include "util/ExtAS.h"
 #include "angelscript/include/angelscript.h"
 
@@ -37,9 +39,9 @@ public:
 		// Registering the addref/release behaviours
 		// NOTE: In prior version used asMETHODPR to register IRefCounter,
 		//       asMETHOD may not detect ptrdiff_t of member function (multiple inheritance)
-		r = engine->RegisterObjectBehaviour(name, asBEHAVE_ADDREF, "void f()", asMETHOD(T, AddRef), asCALL_THISCALL); ASSERT(r >= 0);
-		r = engine->RegisterObjectBehaviour(name, asBEHAVE_RELEASE, "void f()", asMETHOD(T, Release), asCALL_THISCALL); ASSERT(r >= 0);
-		r = engine->RegisterObjectMethod(name, "int GetRefCount() const", asMETHOD(T, GetRefCount), asCALL_THISCALL); ASSERT(r >= 0);
+		r = engine->RegisterObjectBehaviour(name, asBEHAVE_ADDREF, "void f()", (WebbarBind<&T::AddRef, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+		r = engine->RegisterObjectBehaviour(name, asBEHAVE_RELEASE, "void f()", (WebbarBind<&T::Release, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
+		r = engine->RegisterObjectMethod(name, "int GetRefCount() const", (WebbarBind<&T::GetRefCount, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 	}
 
 private:
diff --git a/src/circuit/script/ScriptManager.cpp b/src/circuit/script/ScriptManager.cpp
index 4774308..4dd00db 100644
--- a/src/circuit/script/ScriptManager.cpp
+++ b/src/circuit/script/ScriptManager.cpp
@@ -5,6 +5,8 @@
  *      Author: rlcevg
  */
 
+// Codex-assisted portable script bindings for the Webbar WASM experiment.
+#include "WebbarBindings.h"
 #include "script/ScriptManager.h"
 #ifdef DEBUG_VIS
 #include "script/Script.h"
@@ -82,7 +84,10 @@ void CScriptManager::Init()
 	// Create the script engine
 	engine = asCreateScriptEngine(ANGELSCRIPT_VERSION);
 	// Set the message callback to receive information on errors in human readable form.
-	int r = engine->SetMessageCallback(asMETHOD(CScriptManager, MessageCallback), this, asCALL_THISCALL); ASSERT(r >= 0);
+	auto message = +[](const asSMessageInfo* msg, void* self) {
+		static_cast<CScriptManager*>(self)->MessageCallback(msg, nullptr);
+	};
+	int r = engine->SetMessageCallback(asFunctionPtr(message), this, asCALL_CDECL); ASSERT(r >= 0);
 
 	r = engine->SetEngineProperty(asEP_ALLOW_UNSAFE_REFERENCES,            false); ASSERT(r >= 0);  // Default: false
 	r = engine->SetEngineProperty(asEP_OPTIMIZE_BYTECODE,                   true); ASSERT(r >= 0);  // Default: true
@@ -294,9 +299,9 @@ void CScriptManager::RegisterTracyProfiler()
 	r = engine->RegisterObjectType("CProfiler", 0, asOBJ_REF | asOBJ_NOHANDLE); ASSERT(r >= 0);
 	r = engine->RegisterGlobalProperty("CProfiler tracy", &CProfiler::GetInstance()); ASSERT(r >= 0);
 
-	r = engine->RegisterObjectMethod("CProfiler", "void ZoneBegin(const string &in, uint32 = 0)", asFUNCTION(TracyZoneBegin), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CProfiler", "void ZoneText(const string &in)", asFUNCTION(TracyZoneText), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CProfiler", "void ZoneEnd()", asFUNCTION(TracyZoneEnd), asCALL_CDECL_OBJFIRST); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CProfiler", "void ZoneBegin(const string &in, uint32 = 0)", (WebbarBind<TracyZoneBegin, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CProfiler", "void ZoneText(const string &in)", (WebbarBind<TracyZoneText, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CProfiler", "void ZoneEnd()", (WebbarBind<TracyZoneEnd, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); ASSERT(r >= 0);
 }
 
 asIScriptContext* CScriptManager::ProvideContext(asIScriptEngine* engine, void* param)
diff --git a/src/circuit/script/SetupScript.cpp b/src/circuit/script/SetupScript.cpp
index dbc2206..19286a8 100644
--- a/src/circuit/script/SetupScript.cpp
+++ b/src/circuit/script/SetupScript.cpp
@@ -5,6 +5,8 @@
  *      Author: rlcevg
  */
 
+// Codex-assisted portable script bindings for the Webbar WASM experiment.
+#include "WebbarBindings.h"
 #include "script/SetupScript.h"
 #include "script/ScriptManager.h"
 #include "setup/SetupManager.h"
@@ -22,9 +24,9 @@ CSetupScript::CSetupScript(CScriptManager* scr, CSetupManager* mgr)
 
 	int r = engine->RegisterObjectType("CSetupManager", 0, asOBJ_REF | asOBJ_NOHANDLE); ASSERT(r >= 0);
 	r = engine->RegisterGlobalProperty("CSetupManager aiSetupMgr", manager); ASSERT(r >= 0);
-	r = engine->RegisterObjectMethod("CSetupManager", "void SetWaterHarmful(bool)", asMETHOD(CSetupManager, SetWaterHarmful), asCALL_THISCALL); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CSetupManager", "void SetWaterHarmful(bool)", (WebbarBind<&CSetupManager::SetWaterHarmful, asCALL_THISCALL>()), asCALL_GENERIC); ASSERT(r >= 0);
 	// AS docs / "Registering object methods" / "Composite members"
-	r = engine->RegisterObjectMethod("CSetupManager", "dictionary@+ GetModOptions()", asMETHOD(CSetupScript, GetModOptions), asCALL_THISCALL, 0, asOFFSET(CSetupManager, script), true); ASSERT(r >= 0);
+	r = engine->RegisterObjectMethod("CSetupManager", "dictionary@+ GetModOptions()", (WebbarBindComposite<&CSetupScript::GetModOptions, &CSetupManager::script>()), asCALL_GENERIC); ASSERT(r >= 0);
 
 	// NOTE: Methods with references to types registered in CInitScript.RegisterCore()
 	//       are registered in CInitScript.RegisterMgr()
diff --git a/src/lib/angelscript/add_on/aatc/aatc_container_mapped_templated_shared.hpp b/src/lib/angelscript/add_on/aatc/aatc_container_mapped_templated_shared.hpp
index 1de4948..0cac033 100644
--- a/src/lib/angelscript/add_on/aatc/aatc_container_mapped_templated_shared.hpp
+++ b/src/lib/angelscript/add_on/aatc/aatc_container_mapped_templated_shared.hpp
@@ -33,6 +33,8 @@ samivuorela@gmail.com
 
 
 
+// Codex-assisted portable script bindings for the Webbar WASM experiment.
+#include "WebbarBindings.h"
 #include "aatc_common.hpp"
 #include "aatc_enginestorage.hpp"
 #include "aatc_container_shared.hpp"
@@ -981,44 +983,44 @@ namespace aatc {
 							static void Register(common::RegistrationState& rs) {
 								rs.error = rs.engine->RegisterObjectType(rs.n_iterator_class_T, sizeof(Iterator), asOBJ_VALUE | asOBJ_TEMPLATE | asGetTypeTraits<Iterator>()); assert(rs.error >= 0);
 
-								rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_CONSTRUCT, "void f(int&in)", asFunctionPtr(static_constructor_default), asCALL_CDECL_OBJLAST); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_CONSTRUCT, "void f(int&in)", (WebbarBind<static_constructor_default, asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); assert(rs.error >= 0);
 								rs.Format("void f(int&in,const %s &in)", rs.n_iterator_T);
-								rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_CONSTRUCT, rs.textbuf, asFunctionPtr(static_constructor_copy), asCALL_CDECL_OBJLAST); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_CONSTRUCT, rs.textbuf, (WebbarBind<static_constructor_copy, asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); assert(rs.error >= 0);
 								rs.Format("void f(int&in,%s@)", rs.n_container_T);
-								rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_CONSTRUCT, rs.textbuf, asFunctionPtr(static_constructor_parentcontainer), asCALL_CDECL_OBJLAST); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_CONSTRUCT, rs.textbuf, (WebbarBind<static_constructor_parentcontainer, asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
-								rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_DESTRUCT, "void f()", asFUNCTION(aatc::common::reghelp::generic_destructor<Iterator>), asCALL_CDECL_OBJLAST); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_DESTRUCT, "void f()", (WebbarBind<aatc::common::reghelp::generic_destructor<Iterator>, asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 
 
 								rs.Format("const T_key& %s()", config::scriptname::method::iterator::access_function_key);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asMETHOD(Iterator, Current_key_const), asCALL_THISCALL); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<&Iterator::Current_key_const, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 								rs.Format("T_value& %s()", config::scriptname::method::iterator::access_function_value);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asMETHOD(Iterator, Current_value), asCALL_THISCALL); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<&Iterator::Current_value, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 								rs.Format("const T_key& get_%s()", config::scriptname::method::iterator::access_property_key);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asMETHOD(Iterator, Current_key_get), asCALL_THISCALL); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<&Iterator::Current_key_get, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 								rs.Format("T_value& get_%s()", config::scriptname::method::iterator::access_property_value);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asMETHOD(Iterator, Current_value_get), asCALL_THISCALL); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<&Iterator::Current_value_get, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 								rs.Format("void set_%s(const T_value &in)", config::scriptname::method::iterator::access_property_value);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asMETHOD(Iterator, Current_value_set), asCALL_THISCALL); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<&Iterator::Current_value_set, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, "bool next()", asMETHOD(Iterator, Next), asCALL_THISCALL); assert(rs.error >= 0);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, "bool opPreInc()", asMETHOD(Iterator, Next), asCALL_THISCALL); assert(rs.error >= 0);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, "bool opPostInc()", asMETHOD(Iterator, Next), asCALL_THISCALL); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, "bool next()", (WebbarBind<&Iterator::Next, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, "bool opPreInc()", (WebbarBind<&Iterator::Next, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, "bool opPostInc()", (WebbarBind<&Iterator::Next, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 								rs.Format("%s& opAssign(const %s &in)", rs.n_iterator_T, rs.n_iterator_T);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asMETHOD(Iterator, operator=), asCALL_THISCALL); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<&Iterator::operator=, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 								rs.Format("bool opEquals(const %s &in)", rs.n_iterator_T);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asMETHOD(Iterator, operator==), asCALL_THISCALL); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<&Iterator::operator==, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 								rs.Format("bool %s()", config::scriptname::method::iterator::is_end);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asMETHOD(Iterator, IsEnd), asCALL_THISCALL); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<&Iterator::IsEnd, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 								rs.Format("bool %s()", config::scriptname::method::iterator::is_valid);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asMETHOD(Iterator, IsValid), asCALL_THISCALL); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<&Iterator::IsValid, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 							}
 						};
 
@@ -1054,41 +1056,41 @@ namespace aatc {
 						rs.error = rs.engine->RegisterObjectType(rs.n_container_class_T, 0, asOBJ_REF | asOBJ_GC | asOBJ_TEMPLATE); assert(rs.error >= 0);
 
 						rs.Format("%s@ f(int&in)", rs.n_container_T);
-						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_FACTORY, rs.textbuf, asFUNCTION(shared::asglue::Factory_default<T_container>), asCALL_CDECL); assert(rs.error >= 0);
+						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_FACTORY, rs.textbuf, (WebbarBind<shared::asglue::Factory_default<T_container>, asCALL_CDECL>()), asCALL_GENERIC); assert(rs.error >= 0);
 						rs.Format("%s@ f(int&in,%s@)", rs.n_container_T, rs.n_container_T);
-						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_FACTORY, rs.textbuf, asFUNCTION(shared::asglue::Factory_copy<T_container>), asCALL_CDECL); assert(rs.error >= 0);
+						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_FACTORY, rs.textbuf, (WebbarBind<shared::asglue::Factory_copy<T_container>, asCALL_CDECL>()), asCALL_GENERIC); assert(rs.error >= 0);
 						rs.Format("%s& opAssign(%s@)", rs.n_container_T, rs.n_container_T);
-						rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(shared::asglue::Assign<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+						rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<shared::asglue::Assign<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
-						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_TEMPLATE_CALLBACK, "bool f(int&in, bool&out)", asFUNCTION(aatc::common::templatecallback_func::map), asCALL_CDECL); assert(rs.error >= 0);
+						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_TEMPLATE_CALLBACK, "bool f(int&in, bool&out)", (WebbarBind<aatc::common::templatecallback_func::map, asCALL_CDECL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
-						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_ADDREF, "void f()", asMETHOD(T_container, refcount_Add), asCALL_THISCALL); assert(rs.error >= 0);
-						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_RELEASE, "void f()", asMETHOD(T_container, refcount_Release), asCALL_THISCALL); assert(rs.error >= 0);
-						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_SETGCFLAG, "void f()", asMETHODPR(T_container, SetGCFlag, (), void), asCALL_THISCALL); assert(rs.error >= 0);
-						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_GETGCFLAG, "bool f()", asMETHODPR(T_container, GetGCFlag, (), bool), asCALL_THISCALL); assert(rs.error >= 0);
-						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_GETREFCOUNT, "int f()", asMETHODPR(T_container, GetRefCount, (), int), asCALL_THISCALL); assert(rs.error >= 0);
-						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_ENUMREFS, "void f(int&in)", asMETHODPR(T_container, EnumReferences, (asIScriptEngine*), void), asCALL_THISCALL); assert(rs.error >= 0);
-						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_RELEASEREFS, "void f(int&in)", asMETHODPR(T_container, ReleaseAllReferences, (asIScriptEngine*), void), asCALL_THISCALL); assert(rs.error >= 0);
+						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_ADDREF, "void f()", (WebbarBind<&T_container::refcount_Add, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
+						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_RELEASE, "void f()", (WebbarBind<&T_container::refcount_Release, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
+						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_SETGCFLAG, "void f()", (WebbarBind<static_cast<void (T_container::*)()>(&T_container::SetGCFlag), asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
+						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_GETGCFLAG, "bool f()", (WebbarBind<static_cast<bool (T_container::*)()>(&T_container::GetGCFlag), asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
+						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_GETREFCOUNT, "int f()", (WebbarBind<static_cast<int (T_container::*)()>(&T_container::GetRefCount), asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
+						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_ENUMREFS, "void f(int&in)", (WebbarBind<static_cast<void (T_container::*)(asIScriptEngine*)>(&T_container::EnumReferences), asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
+						rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_RELEASEREFS, "void f(int&in)", (WebbarBind<static_cast<void (T_container::*)(asIScriptEngine*)>(&T_container::ReleaseAllReferences), asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 
 
 						rs.Format("void %s(bool)", config::scriptname::method::container::set_directcomp);
-						rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container, SetDirectcomp), asCALL_THISCALL); assert(rs.error >= 0);
+						rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::SetDirectcomp, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 						rs.Format("void %s()", config::scriptname::method::container::clear);
-						rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container, clear), asCALL_THISCALL); assert(rs.error >= 0);
+						rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::clear, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 						rs.Format("bool %s()", config::scriptname::method::container::empty);
-						rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container, empty), asCALL_THISCALL); assert(rs.error >= 0);
+						rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::empty, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 						rs.Format("%s %s()", config::scriptname::t::size, config::scriptname::method::container::size);
-						rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container, size), asCALL_THISCALL); assert(rs.error >= 0);
+						rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::size, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 						T_container::Iterator::Register(rs);
 
 						rs.Format("%s %s()", rs.n_iterator_T, config::scriptname::method::container::begin);
-						rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container, begin), asCALL_THISCALL); assert(rs.error >= 0);
+						rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::begin, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 						rs.Format("%s %s()", rs.n_iterator_T, config::scriptname::method::container::end);
-						rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container, end), asCALL_THISCALL); assert(rs.error >= 0);
+						rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::end, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 					};
 
 
diff --git a/src/lib/angelscript/add_on/aatc/aatc_container_mapped_templated_shared_method.hpp b/src/lib/angelscript/add_on/aatc/aatc_container_mapped_templated_shared_method.hpp
index 385c082..dc90d10 100644
--- a/src/lib/angelscript/add_on/aatc/aatc_container_mapped_templated_shared_method.hpp
+++ b/src/lib/angelscript/add_on/aatc/aatc_container_mapped_templated_shared_method.hpp
@@ -33,6 +33,8 @@ samivuorela@gmail.com
 
 
 
+// Codex-assisted portable script bindings for the Webbar WASM experiment.
+#include "WebbarBindings.h"
 #include "aatc_container_mapped_templated_shared.hpp"
 
 
@@ -354,47 +356,47 @@ namespace aatc {
 
 						template<typename T_container> static void swap(common::RegistrationState& rs) {
 							rs.Format("%s& %s(%s &inout)", rs.n_container_T, config::scriptname::method::container::swap, rs.n_container_T);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container,swap), asCALL_THISCALL); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::swap, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void insert(common::RegistrationState& rs) {
 							rs.Format("void %s(const T_key&in,const T_value&in)", config::scriptname::method::container::insert);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::insert<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::insert<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void erase(common::RegistrationState& rs) {
 							rs.Format("void %s(const T_key&in)", config::scriptname::method::container::erase);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::erase<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::erase<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void find(common::RegistrationState& rs) {
 							rs.Format("T_value& %s(const T_key &in)", config::scriptname::method::container::find);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTIONPR(method::find_value<T_container>,(T_container*, void*),void*), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<static_cast<void* (*)(T_container*, void*)>(method::find_value<T_container>), asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 							rs.Format("T_value& %s(const T_key &in,bool &out)", config::scriptname::method::container::find);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTIONPR(method::find_value<T_container>, (T_container*, void*, bool&), void*), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<static_cast<void* (*)(T_container*, void*, bool&)>(method::find_value<T_container>), asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 							rs.Format("bool %s(const T_key&in)", config::scriptname::method::container::contains);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::contains<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::contains<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void find_iterator(common::RegistrationState& rs) {
 							rs.Format("%s %s(const T_key &in)", rs.n_iterator_T, config::scriptname::method::container::find_iterator);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::find_iterator<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::find_iterator<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void erase_iterator(common::RegistrationState& rs) {
 							rs.Format("bool %s(const %s &in)", config::scriptname::method::container::erase_iterator, rs.n_iterator_T);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::erase_iterator<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::erase_iterator<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 						template<typename T_container> static void erase_iterator_range(common::RegistrationState& rs) {
 							rs.Format("%s %s(const %s &in,const %s &in)", config::scriptname::t::size, config::scriptname::method::container::erase_iterator, rs.n_iterator_T, rs.n_iterator_T);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::erase_iterator_range<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::erase_iterator_range<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void operator_index(common::RegistrationState& rs) {
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, "const T_value& get_opIndex(const T_key &in) const property", asFUNCTIONPR(method::find_value<T_container>, (T_container*, void*), void*), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, "void set_opIndex(const T_key&in,const T_value&in) property", asFUNCTION(method::insert<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, "const T_value& get_opIndex(const T_key &in) const property", (WebbarBind<static_cast<void* (*)(T_container*, void*)>(method::find_value<T_container>), asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, "void set_opIndex(const T_key&in,const T_value&in) property", (WebbarBind<method::insert<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 
diff --git a/src/lib/angelscript/add_on/aatc/aatc_container_templated_shared.hpp b/src/lib/angelscript/add_on/aatc/aatc_container_templated_shared.hpp
index c1e9a6f..7fe4306 100644
--- a/src/lib/angelscript/add_on/aatc/aatc_container_templated_shared.hpp
+++ b/src/lib/angelscript/add_on/aatc/aatc_container_templated_shared.hpp
@@ -33,6 +33,8 @@ samivuorela@gmail.com
 
 
 
+// Codex-assisted portable script bindings for the Webbar WASM experiment.
+#include "WebbarBindings.h"
 #include "aatc_common.hpp"
 #include "aatc_enginestorage.hpp"
 #include "aatc_container_shared.hpp"
@@ -544,21 +546,21 @@ namespace aatc {
 						template<typename T_iterator> struct current<T_iterator, container::shared::tag::iterator_access::access_is_mutable> {
 							void operator()(common::RegistrationState& rs) const{
 								rs.Format("T& %s()", config::scriptname::method::iterator::access_function);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asFunctionPtr(iterator_method::current<T_iterator>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<iterator_method::current<T_iterator>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 								rs.Format("T& get_%s()", config::scriptname::method::iterator::access_property);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asFunctionPtr(iterator_method::current_get<T_iterator>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<iterator_method::current_get<T_iterator>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 								rs.Format("void set_%s(const T &in)", config::scriptname::method::iterator::access_property);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asFunctionPtr(iterator_method::current_set<T_iterator>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<iterator_method::current_set<T_iterator>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 							}
 						};
 						template<typename T_iterator> struct current<T_iterator, container::shared::tag::iterator_access::access_is_const> {
 							void operator()(common::RegistrationState& rs) const {
 								rs.Format("const T& %s()", config::scriptname::method::iterator::access_function);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asFunctionPtr(iterator_method::current_const<T_iterator>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<iterator_method::current_const<T_iterator>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 								rs.Format("const T& get_%s()", config::scriptname::method::iterator::access_property);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asFunctionPtr(iterator_method::current_get<T_iterator>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<iterator_method::current_get<T_iterator>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 							}
 						};
 
@@ -575,31 +577,31 @@ namespace aatc {
 
 					rs.error = rs.engine->RegisterObjectType(rs.n_iterator_class_T, sizeof(T_iterator), asOBJ_VALUE | asOBJ_TEMPLATE | asGetTypeTraits<T_iterator>()); assert(rs.error >= 0);
 
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_CONSTRUCT, "void f(int&in)", asFunctionPtr(T_iterator::static_constructor_default), asCALL_CDECL_OBJLAST); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_CONSTRUCT, "void f(int&in)", (WebbarBind<T_iterator::static_constructor_default, asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); assert(rs.error >= 0);
 					rs.Format("void f(int&in,const %s &in)", rs.n_iterator_T);
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_CONSTRUCT, rs.textbuf, asFunctionPtr(T_iterator::static_constructor_copy), asCALL_CDECL_OBJLAST); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_CONSTRUCT, rs.textbuf, (WebbarBind<T_iterator::static_constructor_copy, asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); assert(rs.error >= 0);
 					rs.Format("void f(int&in,%s@)", rs.n_container_T);
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_CONSTRUCT, rs.textbuf, asFunctionPtr(T_iterator::static_constructor_parentcontainer), asCALL_CDECL_OBJLAST); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_CONSTRUCT, rs.textbuf, (WebbarBind<T_iterator::static_constructor_parentcontainer, asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_DESTRUCT, "void f()", asFUNCTION(aatc::common::reghelp::generic_destructor<T_iterator>), asCALL_CDECL_OBJLAST); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_DESTRUCT, "void f()", (WebbarBind<aatc::common::reghelp::generic_destructor<T_iterator>, asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 					detail::register_iterator_method::current<T_iterator, container_tags__iterator_access> register_method_current; register_method_current(rs);
 
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, "bool next()", asMETHOD(T_iterator, Next), asCALL_THISCALL); assert(rs.error >= 0);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, "bool opPreInc()", asMETHOD(T_iterator, Next), asCALL_THISCALL); assert(rs.error >= 0);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, "bool opPostInc()", asMETHOD(T_iterator, Next), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, "bool next()", (WebbarBind<&T_iterator::Next, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, "bool opPreInc()", (WebbarBind<&T_iterator::Next, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, "bool opPostInc()", (WebbarBind<&T_iterator::Next, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 					rs.Format("%s& opAssign(const %s &in)", rs.n_iterator_T, rs.n_iterator_T);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asMETHOD(T_iterator, operator=), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<&T_iterator::operator=, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 					rs.Format("bool opEquals(const %s &in)", rs.n_iterator_T);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asMETHOD(T_iterator, operator==), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<&T_iterator::operator==, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 					rs.Format("bool %s()", config::scriptname::method::iterator::is_end);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asMETHOD(T_iterator, IsEnd), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<&T_iterator::IsEnd, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 					rs.Format("bool %s()", config::scriptname::method::iterator::is_valid);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asMETHOD(T_iterator, IsValid), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<&T_iterator::IsValid, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 				}
 
 
@@ -617,40 +619,40 @@ namespace aatc {
 					rs.error = rs.engine->RegisterObjectType(rs.n_container_class_T, 0, asOBJ_REF | asOBJ_GC | asOBJ_TEMPLATE); assert(rs.error >= 0);
 
 					rs.Format("%s@ f(int&in)", rs.n_container_T);
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_FACTORY, rs.textbuf, asFUNCTION(shared::asglue::Factory_default<T_container>), asCALL_CDECL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_FACTORY, rs.textbuf, (WebbarBind<shared::asglue::Factory_default<T_container>, asCALL_CDECL>()), asCALL_GENERIC); assert(rs.error >= 0);
 					rs.Format("%s@ f(int&in,%s@)", rs.n_container_T, rs.n_container_T);
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_FACTORY, rs.textbuf, asFUNCTION(shared::asglue::Factory_copy<T_container>), asCALL_CDECL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_FACTORY, rs.textbuf, (WebbarBind<shared::asglue::Factory_copy<T_container>, asCALL_CDECL>()), asCALL_GENERIC); assert(rs.error >= 0);
 					rs.Format("%s& opAssign(%s@)", rs.n_container_T, rs.n_container_T);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(shared::asglue::Assign<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<shared::asglue::Assign<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_ADDREF, "void f()", asMETHOD(T_container, refcount_Add), asCALL_THISCALL); assert(rs.error >= 0);
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_RELEASE, "void f()", asMETHOD(T_container, refcount_Release), asCALL_THISCALL); assert(rs.error >= 0);
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_SETGCFLAG, "void f()", asMETHODPR(T_container, SetGCFlag, (), void), asCALL_THISCALL); assert(rs.error >= 0);
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_GETGCFLAG, "bool f()", asMETHODPR(T_container, GetGCFlag, (), bool), asCALL_THISCALL); assert(rs.error >= 0);
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_GETREFCOUNT, "int f()", asMETHODPR(T_container, GetRefCount, (), int), asCALL_THISCALL); assert(rs.error >= 0);
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_ENUMREFS, "void f(int&in)", asMETHODPR(T_container, EnumReferences, (asIScriptEngine*), void), asCALL_THISCALL); assert(rs.error >= 0);
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_RELEASEREFS, "void f(int&in)", asMETHODPR(T_container, ReleaseAllReferences, (asIScriptEngine*), void), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_ADDREF, "void f()", (WebbarBind<&T_container::refcount_Add, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_RELEASE, "void f()", (WebbarBind<&T_container::refcount_Release, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_SETGCFLAG, "void f()", (WebbarBind<static_cast<void (T_container::*)()>(&T_container::SetGCFlag), asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_GETGCFLAG, "bool f()", (WebbarBind<static_cast<bool (T_container::*)()>(&T_container::GetGCFlag), asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_GETREFCOUNT, "int f()", (WebbarBind<static_cast<int (T_container::*)()>(&T_container::GetRefCount), asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_ENUMREFS, "void f(int&in)", (WebbarBind<static_cast<void (T_container::*)(asIScriptEngine*)>(&T_container::EnumReferences), asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_RELEASEREFS, "void f(int&in)", (WebbarBind<static_cast<void (T_container::*)(asIScriptEngine*)>(&T_container::ReleaseAllReferences), asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_TEMPLATE_CALLBACK, "bool f(int&in, bool&out)", asFUNCTION(aatc::common::templatecallback_func::templated_singleparam), asCALL_CDECL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_TEMPLATE_CALLBACK, "bool f(int&in, bool&out)", (WebbarBind<aatc::common::templatecallback_func::templated_singleparam, asCALL_CDECL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 					rs.Format("void %s(bool)", config::scriptname::method::container::set_directcomp);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container, SetDirectcomp), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::SetDirectcomp, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 					rs.Format("void %s()", config::scriptname::method::container::clear);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container, clear), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::clear, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 					rs.Format("bool %s()", config::scriptname::method::container::empty);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container, empty), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::empty, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 					rs.Format("%s %s()", config::scriptname::t::size, config::scriptname::method::container::size);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container, size), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::size, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 					register_iterator<T_container, T_iterator>(rs);
 
 					rs.Format("%s %s()", rs.n_iterator_T, config::scriptname::method::container::begin);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container, begin), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::begin, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 					rs.Format("%s %s()", rs.n_iterator_T, config::scriptname::method::container::end);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container, end), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::end, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 				};
 
 
diff --git a/src/lib/angelscript/add_on/aatc/aatc_container_templated_shared_method.hpp b/src/lib/angelscript/add_on/aatc/aatc_container_templated_shared_method.hpp
index fe541d3..5d2c0e7 100644
--- a/src/lib/angelscript/add_on/aatc/aatc_container_templated_shared_method.hpp
+++ b/src/lib/angelscript/add_on/aatc/aatc_container_templated_shared_method.hpp
@@ -33,6 +33,8 @@ samivuorela@gmail.com
 
 
 
+// Codex-assisted portable script bindings for the Webbar WASM experiment.
+#include "WebbarBindings.h"
 #include "aatc_container_templated_shared.hpp"
 
 
@@ -1007,7 +1009,7 @@ namespace aatc {
 
 					template<typename T_container> static void swap(common::RegistrationState& rs) {
 						rs.Format("%s& %s(%s &inout)", rs.n_container_T, config::scriptname::method::container::swap, rs.n_container_T);
-						rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container,swap), asCALL_THISCALL); assert(rs.error >= 0);
+						rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::swap, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 					}
 
 					namespace native{
@@ -1016,57 +1018,57 @@ namespace aatc {
 
 						template<typename T_container> static void push_back(common::RegistrationState& rs) {
 							rs.Format("void %s(const T&in)", config::scriptname::method::container::push_back);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::push_back<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::push_back<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 						template<typename T_container> static void pop_back(common::RegistrationState& rs) {
 							rs.Format("void %s()", config::scriptname::method::container::pop_back);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::pop_back<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::pop_back<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void push_front(common::RegistrationState& rs) {
 							rs.Format("void %s(const T&in)", config::scriptname::method::container::push_front);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::push_front<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::push_front<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 						template<typename T_container> static void pop_front(common::RegistrationState& rs) {
 							rs.Format("void %s()", config::scriptname::method::container::pop_front);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::pop_front<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::pop_front<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void back(common::RegistrationState& rs) {
 							rs.Format("T& %s()", config::scriptname::method::container::back);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::back<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::back<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 						template<typename T_container> static void front(common::RegistrationState& rs) {
 							rs.Format("T& %s()", config::scriptname::method::container::front);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::front<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::front<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void erase_value(common::RegistrationState& rs) {
 							rs.Format("bool %s(const T&in)", config::scriptname::method::container::erase);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::erase_value<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::erase_value<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void operator_index_position(common::RegistrationState& rs) {
 							rs.Format("T& %s(%s)", config::scriptname::method::container::operator_index, config::scriptname::t::size);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::operator_index_position<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::operator_index_position<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void reserve(common::RegistrationState& rs) {
 							rs.Format("void %s(%s)", config::scriptname::method::container::reserve, config::scriptname::t::size);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::reserve<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::reserve<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void insert_value(common::RegistrationState& rs) {
 							rs.Format("void %s(const T&in)", config::scriptname::method::container::insert);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::insert_value<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::insert_value<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void sort(common::RegistrationState& rs) {
 							rs.Format("void %s(bool ascending)", config::scriptname::method::container::sort);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::sort<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::sort<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 							rs.Format("void %s(const %s&in funcptr, bool ascending)", config::scriptname::method::container::sort_aatcfuncptr, config::scriptname::funcpointer);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::sort_aatcfuncptr<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::sort_aatcfuncptr<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 							//?&in wont compile in AS 2.31.0 with funcptr as argument
 							//rs.Format("void %s(const ?&in scriptfunc, bool ascending)", config::scriptname::method::container::sort_scriptfunc);
@@ -1075,26 +1077,26 @@ namespace aatc {
 
 						template<typename T_container> static void contains(common::RegistrationState& rs) {
 							rs.Format("bool %s(const T&in)", config::scriptname::method::container::contains);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::contains<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::contains<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void erase_iterator(common::RegistrationState& rs) {
 							rs.Format("void %s(const %s &in)", config::scriptname::method::container::erase_iterator,rs.n_iterator_T);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::erase_iterator<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::erase_iterator<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 						template<typename T_container> static void erase_iterator_range(common::RegistrationState& rs) {
 							rs.Format("%s %s(const %s &in,const %s &in)",config::scriptname::t::size, config::scriptname::method::container::erase_iterator_range, rs.n_iterator_T, rs.n_iterator_T);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::erase_iterator_range<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::erase_iterator_range<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void find_iterator(common::RegistrationState& rs) {
 							rs.Format("%s %s(const T&in)", rs.n_iterator_T, config::scriptname::method::container::find_iterator);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::find_iterator<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::find_iterator<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void insert_iterator(common::RegistrationState& rs) {
 							rs.Format("void %s(const %s &in, const T&in)", config::scriptname::method::container::insert_iterator, rs.n_iterator_T);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::insert_iterator<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::insert_iterator<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 
@@ -1106,10 +1108,10 @@ namespace aatc {
 
 						template<typename T_container> static void sort(common::RegistrationState& rs) {
 							rs.Format("void %s(bool ascending)", config::scriptname::method::container::sort);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::sort<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::sort<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 							rs.Format("void %s(const %s&in, bool ascending)", config::scriptname::method::container::sort_aatcfuncptr, config::scriptname::funcpointer);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::sort_aatcfuncptr<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::sort_aatcfuncptr<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 							//?&in wont compile in AS 2.31.0 with funcptr as argument
 							//rs.Format("void %s(const ?&in scriptfunc, bool ascending)", config::scriptname::method::container::sort_scriptfunc);
@@ -1118,49 +1120,49 @@ namespace aatc {
 
 						template<typename T_container> static void insert_position_before_constant(common::RegistrationState& rs) {
 							rs.Format("void %s(%s, const T&in)", config::scriptname::method::container::insert_position_before, config::scriptname::t::size);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::insert_position_before_constant<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::insert_position_before_constant<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 						template<typename T_container> static void insert_position_before_linear(common::RegistrationState& rs) {
 							rs.Format("void %s(%s, const T&in)", config::scriptname::method::container::insert_position_before, config::scriptname::t::size);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::insert_position_before_linear<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::insert_position_before_linear<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void erase_position_constant(common::RegistrationState& rs) {
 							rs.Format("void %s(%s)", config::scriptname::method::container::erase_position, config::scriptname::t::size);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::erase_position_constant<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::erase_position_constant<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 						template<typename T_container> static void erase_position_linear(common::RegistrationState& rs) {
 							rs.Format("void %s(%s)", config::scriptname::method::container::erase_position, config::scriptname::t::size);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::erase_position_linear<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::erase_position_linear<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void erase_position_range_constant(common::RegistrationState& rs) {
 							rs.Format("void %s(%s,%s)", config::scriptname::method::container::erase_position_range, config::scriptname::t::size, config::scriptname::t::size);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::erase_position_range_constant<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::erase_position_range_constant<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 						template<typename T_container> static void erase_position_range_linear(common::RegistrationState& rs) {
 							rs.Format("void %s(%s,%s)", config::scriptname::method::container::erase_position_range, config::scriptname::t::size, config::scriptname::t::size);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::erase_position_range_linear<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::erase_position_range_linear<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void erase_value(common::RegistrationState& rs) {
 							rs.Format("%s %s(const T&in, bool all = false)", config::scriptname::t::size, config::scriptname::method::container::erase_value);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::erase_value<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::erase_value<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void find_iterator(common::RegistrationState& rs) {
 							rs.Format("%s %s(const T&in)", rs.n_iterator_T, config::scriptname::method::container::find_iterator);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::find_iterator<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::find_iterator<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void contains(common::RegistrationState& rs) {
 							rs.Format("bool %s(const T&in)", config::scriptname::method::container::contains);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::contains<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::contains<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void count(common::RegistrationState& rs) {
 							rs.Format("%s %s(const T&in)", config::scriptname::t::size, config::scriptname::method::container::count);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::count<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::count<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 
diff --git a/src/lib/angelscript/add_on/aatc/aatc_container_tempspec_shared.hpp b/src/lib/angelscript/add_on/aatc/aatc_container_tempspec_shared.hpp
index bf9c8b2..7abc1da 100644
--- a/src/lib/angelscript/add_on/aatc/aatc_container_tempspec_shared.hpp
+++ b/src/lib/angelscript/add_on/aatc/aatc_container_tempspec_shared.hpp
@@ -33,6 +33,8 @@ samivuorela@gmail.com
 
 
 
+// Codex-assisted portable script bindings for the Webbar WASM experiment.
+#include "WebbarBindings.h"
 #include "aatc_common.hpp"
 #include "aatc_enginestorage.hpp"
 #include "aatc_container_shared.hpp"
@@ -329,21 +331,21 @@ namespace aatc {
 						template<typename T_container, typename T_content, typename T_iterator> struct current<T_container, T_content, T_iterator, container::shared::tag::iterator_access::access_is_mutable> {
 							void operator()(common::RegistrationState& rs) const {
 								rs.Format("%s& %s()", rs.n_content, config::scriptname::method::iterator::access_function);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asFunctionPtr(iterator_method::current<T_container, T_content, T_iterator>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<iterator_method::current<T_container, T_content, T_iterator>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 								rs.Format("%s& get_%s()", rs.n_content, config::scriptname::method::iterator::access_property);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asFunctionPtr(iterator_method::current_get<T_container, T_content, T_iterator>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<iterator_method::current_get<T_container, T_content, T_iterator>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 								rs.Format("void set_%s(const %s &in)", config::scriptname::method::iterator::access_property, rs.n_content);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asFunctionPtr(iterator_method::current_set<T_container, T_content, T_iterator>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<iterator_method::current_set<T_container, T_content, T_iterator>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 							}
 						};
 						template<typename T_container, typename T_content, typename T_iterator> struct current<T_container, T_content, T_iterator, container::shared::tag::iterator_access::access_is_const> {
 							void operator()(common::RegistrationState& rs) const {
 								rs.Format("const %s& %s()", rs.n_content, config::scriptname::method::iterator::access_function);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asFunctionPtr(iterator_method::current_const<T_container, T_content, T_iterator>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<iterator_method::current_const<T_container, T_content, T_iterator>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 								rs.Format("const %s& get_%s()", rs.n_content, config::scriptname::method::iterator::access_property);
-								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asFunctionPtr(iterator_method::current_get<T_container, T_content, T_iterator>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+								rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<iterator_method::current_get<T_container, T_content, T_iterator>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 							}
 						};
 
@@ -360,31 +362,31 @@ namespace aatc {
 					rs.error = rs.engine->RegisterObjectType(rs.n_iterator_T, sizeof(T_iterator), asOBJ_VALUE | asGetTypeTraits<T_iterator>()); assert(rs.error >= 0);
 
 					rs.Format("void f()");
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_CONSTRUCT, rs.textbuf, asFunctionPtr(common::reghelp::constructor<T_iterator>), asCALL_CDECL_OBJLAST); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_CONSTRUCT, rs.textbuf, (WebbarBind<common::reghelp::constructor<T_iterator>, asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); assert(rs.error >= 0);
 					rs.Format("void f(%s@)", rs.n_container_T);
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_CONSTRUCT, rs.textbuf, asFunctionPtr(T_iterator::static_constructor_parentcontainer), asCALL_CDECL_OBJLAST); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_CONSTRUCT, rs.textbuf, (WebbarBind<T_iterator::static_constructor_parentcontainer, asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); assert(rs.error >= 0);
 					rs.Format("void f(const %s &in)", rs.n_iterator_T);
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_CONSTRUCT, rs.textbuf, asFunctionPtr(common::reghelp::constructor_copy<T_iterator, T_iterator>), asCALL_CDECL_OBJLAST); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_CONSTRUCT, rs.textbuf, (WebbarBind<common::reghelp::constructor_copy<T_iterator, T_iterator>, asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_DESTRUCT, "void f()", asFUNCTION(common::reghelp::generic_destructor<T_iterator>), asCALL_CDECL_OBJLAST); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_iterator_T, asBEHAVE_DESTRUCT, "void f()", (WebbarBind<common::reghelp::generic_destructor<T_iterator>, asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 					detail::register_iterator_method::current<T_container, T_content, T_iterator, container_tags__iterator_access> register_method_current; register_method_current(rs);
 
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, "bool next()", asMETHOD(T_iterator, Next), asCALL_THISCALL); assert(rs.error >= 0);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, "bool opPreInc()", asMETHOD(T_iterator, Next), asCALL_THISCALL); assert(rs.error >= 0);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, "bool opPostInc()", asMETHOD(T_iterator, Next), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, "bool next()", (WebbarBind<&T_iterator::Next, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, "bool opPreInc()", (WebbarBind<&T_iterator::Next, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, "bool opPostInc()", (WebbarBind<&T_iterator::Next, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 					rs.Format("%s& opAssign(const %s &in)", rs.n_iterator_T, rs.n_iterator_T);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asMETHOD(T_iterator, operator=), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<&T_iterator::operator=, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 					rs.Format("bool opEquals(const %s &in)", rs.n_iterator_T);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asMETHOD(T_iterator, operator==), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<&T_iterator::operator==, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 					rs.Format("bool %s()", config::scriptname::method::iterator::is_end);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asMETHOD(T_iterator, IsEnd), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<&T_iterator::IsEnd, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 					rs.Format("bool %s()", config::scriptname::method::iterator::is_valid);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, asMETHOD(T_iterator, IsValid), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_iterator_T, rs.textbuf, (WebbarBind<&T_iterator::IsValid, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 				}
 
 
@@ -402,31 +404,31 @@ namespace aatc {
 					rs.error = rs.engine->RegisterObjectType(rs.n_container_T, 0, asOBJ_REF); assert(rs.error >= 0);
 
 					rs.Format("%s@ f()", rs.n_container_T);
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_FACTORY, rs.textbuf, asFUNCTION(shared::asglue::Factory_default<T_container>), asCALL_CDECL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_FACTORY, rs.textbuf, (WebbarBind<shared::asglue::Factory_default<T_container>, asCALL_CDECL>()), asCALL_GENERIC); assert(rs.error >= 0);
 					rs.Format("%s@ f(%s@)", rs.n_container_T, rs.n_container_T);
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_FACTORY, rs.textbuf, asFUNCTION(shared::asglue::Factory_copy<T_container>), asCALL_CDECL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_FACTORY, rs.textbuf, (WebbarBind<shared::asglue::Factory_copy<T_container>, asCALL_CDECL>()), asCALL_GENERIC); assert(rs.error >= 0);
 					rs.Format("%s& opAssign(%s@)", rs.n_container_T, rs.n_container_T);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(shared::asglue::Assign<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<shared::asglue::Assign<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_ADDREF, "void f()", asMETHOD(T_container, refcount_Add), asCALL_THISCALL); assert(rs.error >= 0);
-					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_RELEASE, "void f()", asMETHOD(T_container, refcount_Release), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_ADDREF, "void f()", (WebbarBind<&T_container::refcount_Add, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectBehaviour(rs.n_container_T, asBEHAVE_RELEASE, "void f()", (WebbarBind<&T_container::refcount_Release, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 
 
 					rs.Format("void %s()", config::scriptname::method::container::clear);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container, clear), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::clear, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 					rs.Format("bool %s()", config::scriptname::method::container::empty);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container, empty), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::empty, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 					rs.Format("%s %s()", config::scriptname::t::size, config::scriptname::method::container::size);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container, size), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::size, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 					register_iterator<T_container, T_iterator>(rs);
 
 					rs.Format("%s %s()", rs.n_iterator_T, config::scriptname::method::container::begin);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container, begin), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::begin, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 					rs.Format("%s %s()", rs.n_iterator_T, config::scriptname::method::container::end);
-					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container, end), asCALL_THISCALL); assert(rs.error >= 0);
+					rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::end, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 					#if aatc_CONFIG_USE_ASADDON_SERIALIZER
 						serializer::engine_registration::Register_els_helpers_for_tempspec<T_container, T_container::containertype_id>(enginestorage::Get_ELS(rs.engine), rs.n_content);
diff --git a/src/lib/angelscript/add_on/aatc/aatc_container_tempspec_shared_method.hpp b/src/lib/angelscript/add_on/aatc/aatc_container_tempspec_shared_method.hpp
index 63dcaff..c243eaf 100644
--- a/src/lib/angelscript/add_on/aatc/aatc_container_tempspec_shared_method.hpp
+++ b/src/lib/angelscript/add_on/aatc/aatc_container_tempspec_shared_method.hpp
@@ -33,6 +33,8 @@ samivuorela@gmail.com
 
 
 
+// Codex-assisted portable script bindings for the Webbar WASM experiment.
+#include "WebbarBindings.h"
 #include "aatc_container_tempspec_shared.hpp"
 
 
@@ -674,7 +676,7 @@ namespace aatc {
 
 					template<typename T_container> static void swap(common::RegistrationState& rs) {
 						rs.Format("%s& %s(%s &inout)", rs.n_container_T, config::scriptname::method::container::swap, rs.n_container_T);
-						rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asMETHOD(T_container,swap), asCALL_THISCALL); assert(rs.error >= 0);
+						rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<&T_container::swap, asCALL_THISCALL>()), asCALL_GENERIC); assert(rs.error >= 0);
 					}
 
 
@@ -685,54 +687,54 @@ namespace aatc {
 
 						template<typename T_container> static void push_back(common::RegistrationState& rs) {
 							rs.Format("void %s(const %s &in)", config::scriptname::method::container::push_back, rs.n_content);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::push_back<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::push_back<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 						template<typename T_container> static void pop_back(common::RegistrationState& rs) {
 							rs.Format("void %s()", config::scriptname::method::container::pop_back);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::pop_back<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::pop_back<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void push_front(common::RegistrationState& rs) {
 							rs.Format("void %s(const %s &in)", config::scriptname::method::container::push_front, rs.n_content);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::push_front<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::push_front<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 						template<typename T_container> static void pop_front(common::RegistrationState& rs) {
 							rs.Format("void %s()", config::scriptname::method::container::pop_front);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::pop_front<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::pop_front<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void back(common::RegistrationState& rs) {
 							rs.Format("%s& %s()", rs.n_content, config::scriptname::method::container::back);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::back<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::back<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 						template<typename T_container> static void front(common::RegistrationState& rs) {
 							rs.Format("%s& %s()", rs.n_content, config::scriptname::method::container::front);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::front<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::front<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void erase_value(common::RegistrationState& rs) {
 							rs.Format("bool %s(const %s &in)", config::scriptname::method::container::erase, rs.n_content);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::erase_value<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::erase_value<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 						template<typename T_container> static void insert_value(common::RegistrationState& rs) {
 							rs.Format("void %s(const %s &in)", config::scriptname::method::container::insert, rs.n_content);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::insert_value<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::insert_value<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 						template<typename T_container> static void operator_index_position(common::RegistrationState& rs) {
 							rs.Format("%s& %s(%s)", rs.n_content, config::scriptname::method::container::operator_index, config::scriptname::t::size);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::operator_index_position<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::operator_index_position<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 						template<typename T_container> static void reserve(common::RegistrationState& rs) {
 							rs.Format("void %s(%s)", config::scriptname::method::container::reserve, config::scriptname::t::size);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::reserve<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::reserve<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void sort(common::RegistrationState& rs) {
 							rs.Format("void %s(bool ascending)", config::scriptname::method::container::sort);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::sort<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::sort<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 							rs.Format("void %s(const %s&in, bool ascending)", config::scriptname::method::container::sort_aatcfuncptr, config::scriptname::funcpointer);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::sort_aatcfuncptr<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::sort_aatcfuncptr<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 
 
@@ -745,31 +747,31 @@ namespace aatc {
 							enginestorage::Get_ELS(rs.engine)->RegisterFuncdefIfNeeded(this_funcdef_def);
 
 							rs.Format("void %s(%s@, bool ascending)", config::scriptname::method::container::sort_scriptfunc, this_funcdef_name.c_str());
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::sort_scriptfunc<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::sort_scriptfunc<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void contains(common::RegistrationState& rs) {
 							rs.Format("bool %s(const %s &in)", config::scriptname::method::container::contains, rs.n_content);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::contains<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::contains<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void erase_iterator(common::RegistrationState& rs) {
 							rs.Format("%s %s(const %s &in)", config::scriptname::t::size, config::scriptname::method::container::erase_iterator, rs.n_iterator_T);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::erase_iterator<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::erase_iterator<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 						template<typename T_container> static void erase_iterator_range(common::RegistrationState& rs) {
 							rs.Format("%s %s(const %s &in,const %s &in)", config::scriptname::t::size, config::scriptname::method::container::erase_iterator_range, rs.n_iterator_T, rs.n_iterator_T);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::erase_iterator_range<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::erase_iterator_range<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void find_iterator(common::RegistrationState& rs) {
 							rs.Format("%s %s(const %s &in)", rs.n_iterator_T, config::scriptname::method::container::find, rs.n_content);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::find_iterator<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::find_iterator<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void insert_iterator(common::RegistrationState& rs) {
 							rs.Format("void %s(const %s &in,const %s &in)", config::scriptname::method::container::insert_iterator, rs.n_iterator_T, rs.n_content);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::native::insert_iterator<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::native::insert_iterator<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 
@@ -783,28 +785,28 @@ namespace aatc {
 
 						template<typename T_container> static void erase_position_constant(common::RegistrationState& rs) {
 							rs.Format("void %s(%s)", config::scriptname::method::container::erase_position, config::scriptname::t::size);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::erase_position_constant<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::erase_position_constant<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 						template<typename T_container> static void erase_position_linear(common::RegistrationState& rs) {
 							rs.Format("void %s(%s)", config::scriptname::method::container::erase_position, config::scriptname::t::size);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::erase_position_linear<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::erase_position_linear<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void erase_position_range_constant(common::RegistrationState& rs) {
 							rs.Format("void %s(%s,%s)", config::scriptname::method::container::erase_position_range, config::scriptname::t::size, config::scriptname::t::size);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::erase_position_range_constant<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::erase_position_range_constant<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 						template<typename T_container> static void erase_position_range_linear(common::RegistrationState& rs) {
 							rs.Format("void %s(%s,%s)", config::scriptname::method::container::erase_position_range, config::scriptname::t::size, config::scriptname::t::size);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::erase_position_range_linear<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::erase_position_range_linear<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void sort(common::RegistrationState& rs) {
 							rs.Format("void %s(bool ascending)", config::scriptname::method::container::sort);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::sort<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::sort<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 							rs.Format("void %s(const %s&in, bool ascending)", config::scriptname::method::container::sort_aatcfuncptr, config::scriptname::funcpointer);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::sort_aatcfuncptr<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::sort_aatcfuncptr<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 
 							rs.Format("%s%s", config::scriptname::funcdef_cmp_prefix, rs.n_content);
 							std::string this_funcdef_name(rs.textbuf);
@@ -815,36 +817,36 @@ namespace aatc {
 							enginestorage::Get_ELS(rs.engine)->RegisterFuncdefIfNeeded(this_funcdef_def);
 
 							rs.Format("void %s(%s@, bool ascending)", config::scriptname::method::container::sort_scriptfunc, this_funcdef_name.c_str());
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::sort_scriptfunc<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::sort_scriptfunc<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void insert_position_before_constant(common::RegistrationState& rs) {
 							rs.Format("void %s(%s,const %s &in)", config::scriptname::method::container::insert_position_before, config::scriptname::t::size, rs.n_content);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::insert_position_before_constant<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::insert_position_before_constant<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 						template<typename T_container> static void insert_position_before_linear(common::RegistrationState& rs) {
 							rs.Format("void %s(%s,const %s &in)", config::scriptname::method::container::insert_position_before, config::scriptname::t::size, rs.n_content);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::insert_position_before_linear<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::insert_position_before_linear<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void erase_value(common::RegistrationState& rs) {
 							rs.Format("void %s(const %s &in,bool all = false)", config::scriptname::method::container::erase_value, rs.n_content);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::erase_value<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::erase_value<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void find_iterator(common::RegistrationState& rs) {
 							rs.Format("%s %s(const %s &in)", rs.n_iterator_T, config::scriptname::method::container::find_iterator, rs.n_content);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::find_iterator<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::find_iterator<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void contains(common::RegistrationState& rs) {
 							rs.Format("bool %s(const %s &in)", config::scriptname::method::container::contains, rs.n_content);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::contains<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::contains<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 						template<typename T_container> static void count(common::RegistrationState& rs) {
 							rs.Format("%s %s(const %s &in)", config::scriptname::t::size, config::scriptname::method::container::count, rs.n_content);
-							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, asFUNCTION(method::genericcc::count<T_container>), asCALL_CDECL_OBJFIRST); assert(rs.error >= 0);
+							rs.error = rs.engine->RegisterObjectMethod(rs.n_container_T, rs.textbuf, (WebbarBind<method::genericcc::count<T_container>, asCALL_CDECL_OBJFIRST>()), asCALL_GENERIC); assert(rs.error >= 0);
 						}
 
 
diff --git a/src/lib/angelscript/add_on/aatc/aatc_hash.hpp b/src/lib/angelscript/add_on/aatc/aatc_hash.hpp
index c484d31..862d587 100644
--- a/src/lib/angelscript/add_on/aatc/aatc_hash.hpp
+++ b/src/lib/angelscript/add_on/aatc/aatc_hash.hpp
@@ -31,6 +31,8 @@ samivuorela@gmail.com
 #ifndef _includedh_aatc_hash
 #define _includedh_aatc_hash
 
+// Codex-assisted portable script bindings for the Webbar WASM experiment.
+#include "WebbarBindings.h"
 #include "aatc.hpp"
 
 
@@ -88,7 +90,7 @@ namespace aatc {
 		template<typename T_your_cpp_type> void Register(asIScriptEngine* engine, const char* name_your_type_in_script) {
 			char textbuf[common::RegistrationState::bufsize];
 			common::RegistrationState::Format_static(textbuf, common::RegistrationState::bufsize, "%s %s()", config::scriptname::t::hash_actual, config::scriptname::method::content::hash);
-			int error = engine->RegisterObjectMethod(name_your_type_in_script, textbuf, asFUNCTION(detail::function_wrapping_a_functor<T_your_cpp_type>), asCALL_CDECL_OBJLAST); assert(error >= 0);
+			int error = engine->RegisterObjectMethod(name_your_type_in_script, textbuf, (WebbarBind<detail::function_wrapping_a_functor<T_your_cpp_type>, asCALL_CDECL_OBJLAST>()), asCALL_GENERIC); assert(error >= 0);
 		}
 
 
diff --git a/src/lib/angelscript/add_on/aatc/aatc_registration.cpp b/src/lib/angelscript/add_on/aatc/aatc_registration.cpp
index 93fb939..c5b4ce7 100644
--- a/src/lib/angelscript/add_on/aatc/aatc_registration.cpp
+++ b/src/lib/angelscript/add_on/aatc/aatc_registration.cpp
@@ -29,6 +29,8 @@ samivuorela@gmail.com
 
 
 
+// Codex-assisted portable script bindings for the Webbar WASM experiment.
+#include "WebbarBindings.h"
 //#include "aatc_internal_lists.hpp"
 #include "aatc.hpp"
 #include "aatc_common.hpp"
@@ -89,22 +91,22 @@ namespace aatc {
 
 				common::RegistrationState::Format_static(textbuf, common::RegistrationState::bufsize, "%s@ f()", n_funcpointer);
 
-				r = engine->RegisterObjectBehaviour(n_funcpointer, asBEHAVE_FACTORY, textbuf, asFUNCTIONPR(script_Funcpointer::Factory, (), script_Funcpointer*), asCALL_CDECL); assert(r >= 0);
-				r = engine->RegisterObjectBehaviour(n_funcpointer, asBEHAVE_ADDREF, "void f()", asMETHOD(script_Funcpointer, refcount_Add), asCALL_THISCALL); assert(r >= 0);
-				r = engine->RegisterObjectBehaviour(n_funcpointer, asBEHAVE_RELEASE, "void f()", asMETHOD(script_Funcpointer, refcount_Release), asCALL_THISCALL); assert(r >= 0);
+				r = engine->RegisterObjectBehaviour(n_funcpointer, asBEHAVE_FACTORY, textbuf, (WebbarBind<static_cast<script_Funcpointer* (*)()>(script_Funcpointer::Factory), asCALL_CDECL>()), asCALL_GENERIC); assert(r >= 0);
+				r = engine->RegisterObjectBehaviour(n_funcpointer, asBEHAVE_ADDREF, "void f()", (WebbarBind<&script_Funcpointer::refcount_Add, asCALL_THISCALL>()), asCALL_GENERIC); assert(r >= 0);
+				r = engine->RegisterObjectBehaviour(n_funcpointer, asBEHAVE_RELEASE, "void f()", (WebbarBind<&script_Funcpointer::refcount_Release, asCALL_THISCALL>()), asCALL_GENERIC); assert(r >= 0);
 
 				r = engine->RegisterObjectProperty(n_funcpointer, "bool ready", asOFFSET(script_Funcpointer, ready)); assert(r >= 0);
 				r = engine->RegisterObjectProperty(n_funcpointer, "bool is_thiscall", asOFFSET(script_Funcpointer, is_thiscall)); assert(r >= 0);
 				r = engine->RegisterObjectProperty(n_funcpointer, "string funcname", asOFFSET(script_Funcpointer, funcname)); assert(r >= 0);
 
-				r = engine->RegisterObjectMethod(n_funcpointer, "bool Set(string)", asMETHODPR(script_Funcpointer, Set, (config::t::string), bool), asCALL_THISCALL); assert(r >= 0);
-				r = engine->RegisterObjectMethod(n_funcpointer, "bool Set(string,?&in)", asMETHODPR(script_Funcpointer, Set, (config::t::string, void*, int), bool), asCALL_THISCALL); assert(r >= 0);
-				r = engine->RegisterObjectMethod(n_funcpointer, "void Call()", asMETHOD(script_Funcpointer, scriptsidecall_CallVoid), asCALL_THISCALL); assert(r >= 0);
+				r = engine->RegisterObjectMethod(n_funcpointer, "bool Set(string)", (WebbarBind<static_cast<bool (script_Funcpointer::*)(config::t::string)>(&script_Funcpointer::Set), asCALL_THISCALL>()), asCALL_GENERIC); assert(r >= 0);
+				r = engine->RegisterObjectMethod(n_funcpointer, "bool Set(string,?&in)", (WebbarBind<static_cast<bool (script_Funcpointer::*)(config::t::string, void*, int)>(&script_Funcpointer::Set), asCALL_THISCALL>()), asCALL_GENERIC); assert(r >= 0);
+				r = engine->RegisterObjectMethod(n_funcpointer, "void Call()", (WebbarBind<&script_Funcpointer::scriptsidecall_CallVoid, asCALL_THISCALL>()), asCALL_GENERIC); assert(r >= 0);
 			}
 
 			{//register hash functions
 				common::RegistrationState::Format_static(textbuf, 1000, "%s aatc_Hashfunc_djb2(string &in)", config::scriptname::t::hash_actual);
-				r = engine->RegisterGlobalFunction(textbuf, asFUNCTION(hash::hashfunc::djb2), asCALL_CDECL); assert(r >= 0);
+				r = engine->RegisterGlobalFunction(textbuf, (WebbarBind<hash::hashfunc::djb2, asCALL_CDECL>()), asCALL_GENERIC); assert(r >= 0);
 			}
 		}
 
diff --git a/src/lib/angelscript/source/as_atomic.cpp b/src/lib/angelscript/source/as_atomic.cpp
index 73aa4a2..2c6ff5c 100644
--- a/src/lib/angelscript/source/as_atomic.cpp
+++ b/src/lib/angelscript/source/as_atomic.cpp
@@ -128,7 +128,8 @@ int asAtomicDec(int &value)
 	return InterlockedDecrement((LONG*)&value);
 }
 
-#elif defined(AS_LINUX) || defined(AS_BSD) || defined(AS_ILLUMOS) || defined(AS_ANDROID)
+// Codex-assisted Webbar port: Emscripten pthread builds support these atomics.
+#elif defined(AS_LINUX) || defined(AS_BSD) || defined(AS_ILLUMOS) || defined(AS_ANDROID) || defined(__EMSCRIPTEN__)
 
 //
 // atomic_inc_and_test() and atomic_dec_and_test() from asm/atomic.h is not meant 
@@ -191,4 +192,3 @@ int ERROR_PleaseFixTheConfig[-1];
 #endif
 
 END_AS_NAMESPACE
-
diff --git a/src/lib/WebbarBindings.h b/src/lib/WebbarBindings.h
new file mode 100644
index 0000000..699e6a2
--- /dev/null
+++ b/src/lib/WebbarBindings.h
@@ -0,0 +1,14 @@
+/* This file is part of the Spring engine (GPL v2 or later), see LICENSE.html */
+#pragma once
+// Codex-assisted WASM port. Reuse the pinned asbind20 argument/return adapters.
+#include "asbind20/bind/wrappers.hpp"
+template<auto Function, asECallConvTypes Convention>
+asSFuncPtr WebbarBind()
+{
+	return asFunctionPtr(asbind20::detail::generic_wrapper_nontype<Function, Convention>::generate());
+}
+template<auto Function, auto Member>
+asSFuncPtr WebbarBindComposite()
+{
+	return asFunctionPtr(asbind20::detail::generic_wrapper_composite<Function, asbind20::composite_wrapper_nontype<Member>>::generate());
+}