C# support for Vector/PODVector return values and parameters, also support for overloaded methods on C#

Script/AtomicNET/AtomicNET/Core/AObject.cs

@@ -36,14 +36,14 @@ namespace AtomicEngine
         public void SendEvent(string eventType, ScriptVariantMap eventData = null)
         {
 
-            csb_Atomic_AObject_SendEvent(this.nativeInstance, eventType, eventData == null ? IntPtr.Zero : eventData.nativeInstance);
+            csi_Atomic_AObject_SendEvent(this.nativeInstance, eventType, eventData == null ? IntPtr.Zero : eventData.nativeInstance);
 
         }
 
         [DllImport(Constants.LIBNAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-        private static extern void csb_Atomic_AObject_SendEvent(IntPtr self, string eventType, IntPtr variantMap);
+        private static extern void csi_Atomic_AObject_SendEvent(IntPtr self, string eventType, IntPtr variantMap);
 
 
     }
 
-}
+}

Script/AtomicNET/AtomicNET/Core/AtomicNET.cs

@@ -40,11 +40,11 @@ namespace AtomicEngine
 
         public static uint StringToStringHash(string value)
         {
-            return csb_Atomic_AtomicNET_StringToStringHash(value);
+            return csi_Atomic_AtomicNET_StringToStringHash(value);
         }
 
         [DllImport(Constants.LIBNAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-        private static extern uint csb_Atomic_AtomicNET_StringToStringHash(string name);
+        private static extern uint csi_Atomic_AtomicNET_StringToStringHash(string name);
 
         public static void Initialize()
         {
@@ -77,7 +77,7 @@ namespace AtomicEngine
             coreDelegates.eventDispatch = NativeCore.EventDispatch;
             coreDelegates.updateDispatch = NativeCore.UpdateDispatch;
 
-            IntPtr coreptr = csb_Atomic_NETCore_Initialize(ref coreDelegates);
+            IntPtr coreptr = csi_Atomic_NETCore_Initialize(ref coreDelegates);
 
             NETCore core = (coreptr == IntPtr.Zero ? null : NativeCore.WrapNative<NETCore>(coreptr));
 
@@ -96,7 +96,7 @@ namespace AtomicEngine
         }
 
         [DllImport(Constants.LIBNAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-        private static extern IntPtr csb_Atomic_NETCore_Initialize(ref CoreDelegates delegates);
+        private static extern IntPtr csi_Atomic_NETCore_Initialize(ref CoreDelegates delegates);
 
         private static Context context;
         private static CoreDelegates coreDelegates;

Script/AtomicNET/AtomicNET/Core/NativeCore.cs

@@ -161,7 +161,7 @@ namespace AtomicEngine
                 if (!w.TryGetTarget(out r))
                 {
                     // expired
-                    csb_AtomicEngine_ReleaseRef(native);
+                    csi_AtomicEngine_ReleaseRef(native);
                     nativeLookup.Remove(native);
                     nativesRemoved++;
                 }
@@ -233,18 +233,18 @@ namespace AtomicEngine
                     // we were seen before, but have since been GC'd, remove!
                     nativeLookup.Remove(native);
 
-                    if (csb_Atomic_RefCounted_Refs(native) == 1)
+                    if (csi_Atomic_RefCounted_Refs(native) == 1)
                     {
                         // only managed ref remains, so release and return null
-                        csb_AtomicEngine_ReleaseRef(native);
+                        csi_AtomicEngine_ReleaseRef(native);
                         return null;
                     }
 
-                    csb_AtomicEngine_ReleaseRef(native);
+                    csi_AtomicEngine_ReleaseRef(native);
                 }
             }
 
-            IntPtr classID = RefCounted.csb_Atomic_RefCounted_GetClassID(native);
+            IntPtr classID = RefCounted.csi_Atomic_RefCounted_GetClassID(native);
 
             // and store, with downcast support for instance Component -> StaticModel
             // we never want to hit this path for script inherited natives
@@ -268,10 +268,10 @@ namespace AtomicEngine
         }
 
         [DllImport(Constants.LIBNAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-        private static extern IntPtr csb_Atomic_AObject_GetTypeName(IntPtr self);
+        private static extern IntPtr csi_Atomic_AObject_GetTypeName(IntPtr self);
 
         [DllImport(Constants.LIBNAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-        private static extern int csb_Atomic_RefCounted_Refs(IntPtr self);
+        private static extern int csi_Atomic_RefCounted_Refs(IntPtr self);
 
         public static void RegisterNativeType(NativeType nativeType)
         {
@@ -343,7 +343,7 @@ namespace AtomicEngine
         internal static Dictionary<Type, NativeType> typeToNativeType = new Dictionary<Type, NativeType>();
 
         [DllImport(Constants.LIBNAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-        private static extern void csb_AtomicEngine_ReleaseRef(IntPtr refCounted);
+        private static extern void csi_AtomicEngine_ReleaseRef(IntPtr refCounted);
 
     }
 

Script/AtomicNET/AtomicNET/Core/NativeEvents.cs

@@ -28,11 +28,11 @@ namespace AtomicEngine
     {
         public void CopyVariantMap(IntPtr vm)
         {
-            csb_Atomic_AtomicNET_ScriptVariantMapCopyVariantMap(nativeInstance, vm);
+            csi_Atomic_AtomicNET_ScriptVariantMapCopyVariantMap(nativeInstance, vm);
         }
 
         [DllImport(Constants.LIBNAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-        private static extern IntPtr csb_Atomic_AtomicNET_ScriptVariantMapCopyVariantMap(IntPtr svm, IntPtr vm);
+        private static extern IntPtr csi_Atomic_AtomicNET_ScriptVariantMapCopyVariantMap(IntPtr svm, IntPtr vm);
 
     }
 

Script/AtomicNET/AtomicNET/Core/RefCounted.cs

@@ -28,7 +28,7 @@ namespace AtomicEngine
         public IntPtr nativeInstance = IntPtr.Zero;
 
         [DllImport(Constants.LIBNAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-        public static extern IntPtr csb_Atomic_RefCounted_GetClassID(IntPtr self);
+        public static extern IntPtr csi_Atomic_RefCounted_GetClassID(IntPtr self);
 
     }
 

Script/AtomicNET/AtomicNET/Core/Vector.cs

@@ -7,8 +7,8 @@ using System.Runtime.InteropServices;
 namespace AtomicEngine
 {
 	// Type safe wrapper around ScriptVector
-    public class Vector<T> where T : RefCounted
-    {
+	public class Vector<T> where T : RefCounted
+	{
 
 		public uint Size
 		{
@@ -25,7 +25,7 @@ namespace AtomicEngine
 
 		public T At(uint index)
 		{
-			return (T) scriptVector.At(index);	
+			return (T)scriptVector.At(index);
 		}
 
 
@@ -55,6 +55,8 @@ namespace AtomicEngine
 			return vector.scriptVector.nativeInstance;
 		}
 
+		public ScriptVector GetScriptVector() { return scriptVector; }
+
 
 		ScriptVector scriptVector = new ScriptVector();
     }

Script/AtomicNET/AtomicNET/Graphics/Graphics.cs

@@ -12,19 +12,11 @@ namespace AtomicEngine
 
         public void SetShaderParameter(string param, Matrix3x4 matrix)
         {
-            csb_Atomic_Graphics_SetShaderParameter_Matrix3x4(nativeInstance, param, ref matrix);
+            csi_Atomic_Graphics_SetShaderParameter_Matrix3x4(nativeInstance, param, ref matrix);
         }
 
         [DllImport(Constants.LIBNAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-        private static extern IntPtr csb_Atomic_Graphics_SetShaderParameter_Matrix3x4(IntPtr self, string param, ref Matrix3x4 matrix);
-
-        public void SetShaderParameter(string param, Color color)
-        {
-            csb_Atomic_Graphics_SetShaderParameter_Color(nativeInstance, param, ref color);
-        }
-
-        [DllImport(Constants.LIBNAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-        private static extern IntPtr csb_Atomic_Graphics_SetShaderParameter_Color(IntPtr self, string param, ref Color color);
+        private static extern IntPtr csi_Atomic_Graphics_SetShaderParameter_Matrix3x4(IntPtr self, string param, ref Matrix3x4 matrix);
 
 
     };

Script/AtomicNET/AtomicNET/Graphics/VertexBuffer.cs

@@ -8,12 +8,12 @@ namespace AtomicEngine
 
         public IntPtr Lock(uint start, uint count, bool discard = false)
         {
-            return csb_Atomic_VertexBuffer_Lock(this.nativeInstance, start, count, discard);
+            return csi_Atomic_VertexBuffer_Lock(this.nativeInstance, start, count, discard);
         }
 
 
         [DllImport(Constants.LIBNAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-        private static extern IntPtr csb_Atomic_VertexBuffer_Lock(IntPtr self, uint start, uint count, bool discard);
+        private static extern IntPtr csi_Atomic_VertexBuffer_Lock(IntPtr self, uint start, uint count, bool discard);
 
     };
 

Script/AtomicNET/AtomicNET/Graphics/Viewport.cs

@@ -8,14 +8,6 @@ namespace AtomicEngine
     public partial class Viewport : AObject
     {
 
-        public void SetRenderPath(RenderPath renderPath)
-        {
-            csb_Atomic_Viewport_SetRenderPath_RenderPath(nativeInstance, renderPath != null ? renderPath.nativeInstance : IntPtr.Zero);
-        }
-
-        [DllImport(Constants.LIBNAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-        private static extern IntPtr csb_Atomic_Viewport_SetRenderPath_RenderPath(IntPtr self, IntPtr renderPath);
-
     };
 
 }

Script/AtomicNET/AtomicNET/IPC/IPC.cs

@@ -9,11 +9,11 @@ namespace AtomicEngine
     {
         public void SendEventToBroker(string eventType, ScriptVariantMap eventData)
         {
-            csb_Atomic_IPC_SendEventToBrokerWithEventData(nativeInstance, eventType, eventData == null ? IntPtr.Zero : eventData.nativeInstance);
+            csi_Atomic_IPC_SendEventToBrokerWithEventData(nativeInstance, eventType, eventData == null ? IntPtr.Zero : eventData.nativeInstance);
         }
 
         [DllImport(Constants.LIBNAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-        private static extern void csb_Atomic_IPC_SendEventToBrokerWithEventData(IntPtr self, string eventType, IntPtr variantMap);
+        private static extern void csi_Atomic_IPC_SendEventToBrokerWithEventData(IntPtr self, string eventType, IntPtr variantMap);
 
     }
 

Script/AtomicNET/AtomicNET/Script/ScriptVariantMap.cs

@@ -22,11 +22,11 @@ namespace AtomicEngine
 
         public IntPtr GetVoidPtr(string key)
         {
-            return csb_Atomic_AtomicNET_ScriptVariantMap_GetVoidPtr(nativeInstance, key);
+            return csi_Atomic_AtomicNET_ScriptVariantMap_GetVoidPtr(nativeInstance, key);
         }
 
         [DllImport(Constants.LIBNAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
-        private static extern IntPtr csb_Atomic_AtomicNET_ScriptVariantMap_GetVoidPtr(IntPtr self, string key);
+        private static extern IntPtr csi_Atomic_AtomicNET_ScriptVariantMap_GetVoidPtr(IntPtr self, string key);
 
     }
 }

Source/Atomic/Script/ScriptVector.h

@@ -43,49 +43,55 @@ public:
     }
 
     template <class T>
-    bool AdaptToPODVector(PODVector<T> vectorOut)
+    bool AdaptFromVector(PODVector<T> vectorIn)
     {
-        vectorOut.Clear();
 
-        for (unsigned i = 0; i < refVector_.Size(); i++)
+        Vector<SharedPtr<RefCounted>> keepAlive = refVector_;
+
+        refVector_.Clear();
+
+        for (unsigned i = 0; i < vectorIn.Size(); i++)
         {
-            vectorOut.Push(static_cast<T>(refVector_[i].Get()));
+            refVector_.Push(SharedPtr<RefCounted>(vectorIn[i]));
         }
 
         return true;
-
     }
 
     template <class T>
-    bool AdaptToVector(Vector<T> vectorOut)
+    bool AdaptFromVector(Vector<T> vectorIn)
     {
-        vectorOut.Clear();
+        Vector<SharedPtr<RefCounted>> keepAlive = refVector_;
 
-        for (unsigned i = 0; i < refVector_.Size(); i++)
+        refVector_.Clear();
+
+        for (unsigned i = 0; i < vectorIn.Size(); i++)
         {
-            vectorOut.Push((T) refVector_[i]);
+            refVector_.Push((T) vectorIn[i]);
         }
 
+        return true;
+
     }
 
     template <class T>
-    bool AdaptFromPODVector(PODVector<T> vectorIn)
+    bool AdaptFromVector(Vector<WeakPtr<T>> vectorIn)
     {
-
         Vector<SharedPtr<RefCounted>> keepAlive = refVector_;
 
         refVector_.Clear();
 
         for (unsigned i = 0; i < vectorIn.Size(); i++)
         {
-            refVector_.Push(SharedPtr<RefCounted>(vectorIn[i]));
+            refVector_.Push(SharedPtr<RefCounted>((RefCounted*) vectorIn[i]));
         }
 
         return true;
+
     }
 
     template <class T>
-    bool AdaptFromVector(Vector<T> vectorIn)
+    bool AdaptFromVector(Vector<SharedPtr<T>> vectorIn)
     {
         Vector<SharedPtr<RefCounted>> keepAlive = refVector_;
 
@@ -93,9 +99,66 @@ public:
 
         for (unsigned i = 0; i < vectorIn.Size(); i++)
         {
-            refVector_.Push((T) vectorIn[i]);
+            refVector_.Push(SharedPtr<RefCounted>((RefCounted*) vectorIn[i]));
+        }
+
+        return true;
+
+    }
+
+    template <class T>
+    bool AdaptToVector(PODVector<T> vectorOut)
+    {
+        vectorOut.Clear();
+
+        for (unsigned i = 0; i < refVector_.Size(); i++)
+        {
+            vectorOut.Push(static_cast<T>(refVector_[i].Get()));
         }
 
+        return true;
+
+    }
+
+    template <class T>
+    bool AdaptToVector(Vector<T> vectorOut)
+    {
+        vectorOut.Clear();
+
+        for (unsigned i = 0; i < refVector_.Size(); i++)
+        {
+            vectorOut.Push((T) refVector_[i]);
+        }
+
+        return true;
+
+    }
+
+    template <class T>
+    bool AdaptToVector(Vector<SharedPtr<T>> vectorOut)
+    {
+        vectorOut.Clear();
+
+        for (unsigned i = 0; i < refVector_.Size(); i++)
+        {
+            vectorOut.Push(SharedPtr<T>((T) refVector_[i]));
+        }
+
+        return true;
+
+    }
+
+    template <class T>
+    bool AdaptToVector(Vector<WeakPtr<T>> vectorOut)
+    {
+        vectorOut.Clear();
+
+        for (unsigned i = 0; i < refVector_.Size(); i++)
+        {
+            vectorOut.Push(WeakPtr<T>((T) refVector_[i]));
+        }
+
+        return true;
     }
 
 

Source/AtomicNET/NETNative/NETCInterop.cpp

@@ -17,13 +17,15 @@
 
 // TODO: Split into separate module files
 
+// IMPORTANT: methods here are prefaced with csi_ instead of csb_, the later being automatically generated bindings
+
 namespace Atomic
 {
 
     extern "C"
     {
 
-        ATOMIC_EXPORT_API ClassID csb_Atomic_RefCounted_GetClassID(RefCounted* refCounted)
+        ATOMIC_EXPORT_API ClassID csi_Atomic_RefCounted_GetClassID(RefCounted* refCounted)
         {
             if (!refCounted)
                 return 0;
@@ -31,7 +33,7 @@ namespace Atomic
             return refCounted->GetClassID();
         }
 
-        ATOMIC_EXPORT_API void csb_AtomicEngine_ReleaseRef(RefCounted* refCounted)
+        ATOMIC_EXPORT_API void csi_AtomicEngine_ReleaseRef(RefCounted* refCounted)
         {
             if (!refCounted)
                 return;
@@ -39,12 +41,26 @@ namespace Atomic
             refCounted->ReleaseRef();
         }
 
-        ATOMIC_EXPORT_API void csb_Atomic_AObject_SendEvent(Object* obj, const char* eventType, ScriptVariantMap* vmap)
+        ATOMIC_EXPORT_API const char* csi_Atomic_AObject_GetTypeName(Object* self)
+        {
+
+           static String returnValue;
+           returnValue = self->GetTypeName();
+           return returnValue.CString();
+        }
+
+        ATOMIC_EXPORT_API int csi_Atomic_RefCounted_Refs(RefCounted* self)
+        {
+           return self->Refs();
+        }
+
+
+        ATOMIC_EXPORT_API void csi_Atomic_AObject_SendEvent(Object* obj, const char* eventType, ScriptVariantMap* vmap)
         {
             obj->SendEvent(eventType, vmap ? vmap->GetVariantMap() : obj->GetEventDataMap());
         }
 
-        ATOMIC_EXPORT_API ClassID csb_Atomic_NETCore_Initialize(NETCoreDelegates* delegates)
+        ATOMIC_EXPORT_API ClassID csi_Atomic_NETCore_Initialize(NETCoreDelegates* delegates)
         {
             Context* context = new Context();
             NETCore* netCore = new NETCore(context, delegates);
@@ -52,7 +68,7 @@ namespace Atomic
             return netCore;
         }
 
-        ATOMIC_EXPORT_API unsigned csb_Atomic_AtomicNET_StringToStringHash(const char* str)
+        ATOMIC_EXPORT_API unsigned csi_Atomic_AtomicNET_StringToStringHash(const char* str)
         {
             unsigned hash = 0;
 
@@ -70,7 +86,7 @@ namespace Atomic
             return hash;
         }
 
-        ATOMIC_EXPORT_API void csb_Atomic_AtomicNET_ScriptVariantMapCopyVariantMap(ScriptVariantMap* svm, VariantMap* vm)
+        ATOMIC_EXPORT_API void csi_Atomic_AtomicNET_ScriptVariantMapCopyVariantMap(ScriptVariantMap* svm, VariantMap* vm)
         {
             if (!svm)
                 return;
@@ -85,7 +101,7 @@ namespace Atomic
 
         }
 
-        ATOMIC_EXPORT_API void* csb_Atomic_AtomicNET_ScriptVariantMap_GetVoidPtr(ScriptVariantMap* svm, const char* key)
+        ATOMIC_EXPORT_API void* csi_Atomic_AtomicNET_ScriptVariantMap_GetVoidPtr(ScriptVariantMap* svm, const char* key)
         {
             if (!svm || !key || !strlen(key))
                 return nullptr;
@@ -95,7 +111,7 @@ namespace Atomic
         }
 
         // IPC
-        ATOMIC_EXPORT_API void csb_Atomic_IPC_SendEventToBrokerWithEventData(IPC* ipc, const char* eventType, ScriptVariantMap* variantMap)
+        ATOMIC_EXPORT_API void csi_Atomic_IPC_SendEventToBrokerWithEventData(IPC* ipc, const char* eventType, ScriptVariantMap* variantMap)
         {
             if (variantMap)
                 ipc->SendEventToBroker(eventType, variantMap->GetVariantMap());
@@ -104,7 +120,7 @@ namespace Atomic
 
         }
 
-        ATOMIC_EXPORT_API void* csb_Atomic_VertexBuffer_Lock(VertexBuffer* vb , unsigned start, unsigned count, bool discard)
+        ATOMIC_EXPORT_API void* csi_Atomic_VertexBuffer_Lock(VertexBuffer* vb , unsigned start, unsigned count, bool discard)
         {
             if (!vb)
                 return nullptr;
@@ -113,7 +129,7 @@ namespace Atomic
 
         }
 
-        ATOMIC_EXPORT_API void csb_Atomic_Graphics_SetShaderParameter_Matrix3x4(Graphics* graphics, const char* param, Matrix3x4* matrix)
+        ATOMIC_EXPORT_API void csi_Atomic_Graphics_SetShaderParameter_Matrix3x4(Graphics* graphics, const char* param, Matrix3x4* matrix)
         {
             if (!graphics || !param || !strlen(param))
                 return;
@@ -121,22 +137,6 @@ namespace Atomic
             graphics->SetShaderParameter(param, *matrix);
         }
 
-        ATOMIC_EXPORT_API void csb_Atomic_Graphics_SetShaderParameter_Color(Graphics* graphics, const char* param, Color* color)
-        {
-            if (!graphics || !param || !strlen(param) || !color)
-                return;
-
-            graphics->SetShaderParameter(param, *color);
-        }
-
-
-        ATOMIC_EXPORT_API void csb_Atomic_Viewport_SetRenderPath_RenderPath(Viewport* viewport, RenderPath* renderPath)
-        {
-            if (!viewport)
-                return;
-
-            viewport->SetRenderPath(renderPath);
-        }
 
     }
 }

Source/ToolCore/JSBind/CSharp/CSClassWriter.cpp

@@ -219,7 +219,9 @@ void CSClassWriter::GenerateManagedSource(String& sourceOut)
     Dedent();
 
     // managed functions
-    bool wroteConstructor = false;
+
+    CSFunctionWriter::SetWroteConstructor(false);
+
     for (unsigned i = 0; i < klass_->functions_.Size(); i++)
     {
         JSBFunction* function = klass_->functions_.At(i);
@@ -233,9 +235,6 @@ void CSClassWriter::GenerateManagedSource(String& sourceOut)
         if (CSTypeHelper::OmitFunction(function))
             continue;
 
-        if (function->IsConstructor())
-            wroteConstructor = true;
-
         CSFunctionWriter fwriter(function);
         fwriter.GenerateManagedSource(source);
 
@@ -243,7 +242,7 @@ void CSClassWriter::GenerateManagedSource(String& sourceOut)
 
     // There are some constructors being skipped (like HTTPRequest as it uses a vector of strings in args)
     // Make sure we have at least a IntPtr version
-    if (!wroteConstructor)
+    if (!CSFunctionWriter::GetWroteConstructor() && klass_->GetName() != "RefCounted")
     {
         ATOMIC_LOGINFOF("WARNING: %s class didn't write a constructor, filling in generated native constructor", klass_->GetName().CString());
 
@@ -253,6 +252,8 @@ void CSClassWriter::GenerateManagedSource(String& sourceOut)
         source += IndentLine("}\n\n");
     }
 
+    CSFunctionWriter::SetWroteConstructor(false);
+
     source += IndentLine("}\n");
 
     Dedent();

Source/ToolCore/JSBind/CSharp/CSFunctionWriter.cpp

@@ -113,6 +113,8 @@ RefCounted* csb_ObjectAnimation_Constructor()
 namespace ToolCore
 {
 
+bool CSFunctionWriter::wroteConstructor_ = false;
+
 CSFunctionWriter::CSFunctionWriter(JSBFunction *function) : JSBFunctionWriter(function)
 {
 
@@ -152,7 +154,7 @@ void CSFunctionWriter::GenNativeCallParameters(String& sig)
                     continue;
                 }
 
-                if (klass->IsNumberArray())
+                if (klass->IsNumberArray() || ptype->isReference_)
                     args.Push(ToString("*%s", ptype->name_.CString()));
                 else
                     args.Push(ToString("%s", ptype->name_.CString()));
@@ -164,7 +166,14 @@ void CSFunctionWriter::GenNativeCallParameters(String& sig)
             }
             else
             {
-                args.Push(ToString("%s", ptype->name_.CString()));
+                if (ptype->type_->asStringType() || ptype->type_->asStringHashType())
+                {
+                    args.Push(ToString("%s ? String(%s) : String::EMPTY", ptype->name_.CString(), ptype->name_.CString()));
+                }
+                else
+                {
+                    args.Push(ToString("%s", ptype->name_.CString()));
+                }
             }
 
         }
@@ -224,7 +233,7 @@ void CSFunctionWriter::WriteNativeFunction(String& source)
         {
             const String& pname = ftype->name_;
             source += IndentLine(ToString("PODVector<%s*> %s__vector;\n", className.CString(), pname.CString()));
-            source += IndentLine(ToString("if (%s) %s->AdaptToPODVector<%s*>(%s__vector);\n", pname.CString(), pname.CString(), className.CString(), pname.CString()));
+            source += IndentLine(ToString("if (%s) %s->AdaptToVector<%s*>(%s__vector);\n", pname.CString(), pname.CString(), className.CString(), pname.CString()));
         }
         else
         {
@@ -259,6 +268,20 @@ void CSFunctionWriter::WriteNativeFunction(String& source)
         returnStatement = ToString("SharedPtr<%s> returnValue = ", function_->GetReturnClass()->GetNativeName().CString());
         sharedPtrReturn = true;
     }
+    else if (function_->GetReturnType() && function_->GetReturnType()->type_->asVectorType())
+    {
+        // we have an out parameter
+        JSBVectorType* vtype = function_->GetReturnType()->type_->asVectorType();
+
+        if (!vtype->vectorTypeIsSharedPtr_ && !vtype->vectorTypeIsWeakPtr_)
+        {
+            returnStatement = ToString("%sVector<%s*> returnValue__vector = ", vtype->isPODVector_ ? "POD" : "", vtype->vectorType_->asClassType()->class_->GetName().CString());
+        }
+        else
+        {
+            returnStatement = ToString("%sVector<%s<%s>> returnValue__vector = ",  vtype->isPODVector_ ? "POD" : "", vtype->vectorTypeIsSharedPtr_ ? "SharedPtr" : "WeakPtr", vtype->vectorType_->asClassType()->class_->GetName().CString());
+        }
+    }
     else
     {
         if (returnType != "void" && !hasVectorMarshal)
@@ -329,7 +352,7 @@ void CSFunctionWriter::WriteNativeFunction(String& source)
         if (vtype->isPODVector_)
         {
             const String& pname = ftype->name_;
-            source += IndentLine(ToString("if (%s) %s->AdaptFromPODVector<%s*>(%s__vector);\n", pname.CString(), pname.CString(), className.CString(), pname.CString()));
+            source += IndentLine(ToString("if (%s) %s->AdaptFromVector<%s*>(%s__vector);\n", pname.CString(), pname.CString(), className.CString(), pname.CString()));
         }
         else
         {
@@ -353,6 +376,13 @@ void CSFunctionWriter::WriteNativeFunction(String& source)
     {
         source += IndentLine("return returnValue.CString();\n");
     }
+    else if (function_->GetReturnType() && function_->GetReturnType()->type_->asVectorType())
+    {
+        // we have an out parameter
+        JSBVectorType* vtype = function_->GetReturnType()->type_->asVectorType();
+        source += IndentLine("if (returnValue) returnValue->AdaptFromVector(returnValue__vector);\n");
+
+    }
     else if (returnType != "void" && hasVectorMarshal)
     {
         source += IndentLine("return returnValue;\n");
@@ -412,6 +442,10 @@ void CSFunctionWriter::WriteManagedPInvokeFunctionSignature(String& source)
 
     String returnType = CSTypeHelper::GetPInvokeTypeString(function_->GetReturnType());
 
+    // handled by out parameter
+    if (function_->GetReturnType() && function_->GetReturnType()->type_->asVectorType())
+        returnType = "void";
+
     if (returnType == "bool")
     {
         // default boolean marshal is 4 byte windows type BOOL and not 1 byte bool
@@ -479,20 +513,25 @@ void CSFunctionWriter::WriteManagedPInvokeFunctionSignature(String& source)
     if (function_->GetReturnClass())
     {
         JSBClass* retClass = function_->GetReturnClass();
+
         if (retClass->IsNumberArray())
         {
             args.Push("ref " + retClass->GetName() + " retValue");
         }
 
     }
+    else if (function_->GetReturnType() && function_->GetReturnType()->type_->asVectorType())
+    {
+        args.Push("ref ScriptVector returnValue");
+    }
 
     String pstring;
     pstring.Join(args, ", ");
 
     String fname = function_->IsConstructor() ? "Constructor" : function_->GetName();
-    line = ToString("private static extern %s csb_%s_%s_%s(%s);\n",
+    line = ToString("private static extern %s csb_%s_%s_%s_%u(%s);\n",
                     returnType.CString(), package->GetName().CString(), klass->GetName().CString(),
-                    fname.CString(), pstring.CString());
+                    fname.CString(), function_->GetID(), pstring.CString());
 
     source += IndentLine(line);
 
@@ -554,10 +593,16 @@ void CSFunctionWriter::WriteManagedConstructor(String& source)
 
     String line;
 
-    line = ToString("public %s (IntPtr native) : base (native)\n", klass->GetName().CString());
-    source += IndentLine(line);
-    source += IndentLine("{\n");
-    source += IndentLine("}\n\n");
+    if (!wroteConstructor_)
+    {
+        line = ToString("public %s (IntPtr native) : base (native)\n", klass->GetName().CString());
+        source += IndentLine(line);
+        source += IndentLine("{\n");
+        source += IndentLine("}\n\n");
+    }
+
+    // don't add wrapping constructor for overloads
+    wroteConstructor_ = true;
 
     String sig;
     GenManagedFunctionParameters(sig);
@@ -591,8 +636,8 @@ void CSFunctionWriter::WriteManagedConstructor(String& source)
 
     source += IndentLine("IntPtr nativeInstanceOverride = NativeCore.NativeContructorOverride;\n");
 
-    line = ToString("nativeInstance = NativeCore.RegisterNative (nativeInstanceOverride != IntPtr.Zero ? nativeInstanceOverride : csb_%s_%s_Constructor(%s), this);\n",
-                     package->GetName().CString(), klass->GetName().CString(), callSig.CString());
+    line = ToString("nativeInstance = NativeCore.RegisterNative (nativeInstanceOverride != IntPtr.Zero ? nativeInstanceOverride : csb_%s_%s_Constructor_%u(%s), this);\n",
+                     package->GetName().CString(), klass->GetName().CString(), function_->GetID(), callSig.CString());
 
     source += IndentLine(line);
 
@@ -672,10 +717,17 @@ void CSFunctionWriter::GenPInvokeCallParameters(String& sig)
                 sig += ", ";
 
             JSBClass* klass = function_->GetClass();
-            sig += ToString("ref %s%sReturnValue", klass->GetName().CString(), function_->GetName().CString());
+            sig += ToString("ref %s%s%uReturnValue", klass->GetName().CString(), function_->GetName().CString(), function_->GetID());
         }
     }
+    else if (!function_->IsStatic() && function_->GetReturnType() && function_->GetReturnType()->type_->asVectorType())
+    {
+        if (sig.Length())
+            sig += ", ";
 
+        JSBClass* klass = function_->GetClass();
+        sig += "ref returnScriptVector";
+    }
 
 }
 
@@ -729,10 +781,15 @@ void CSFunctionWriter::WriteManagedFunction(String& source)
 
     if (function_->GetReturnType())
     {
+
         if (function_->GetReturnType()->type_->asStringType() || function_->GetReturnType()->type_->asStringHashType())
         {
             line += "return System.Runtime.InteropServices.Marshal.PtrToStringAnsi(";
         }
+        else if (function_->GetReturnType()->type_->asVectorType())
+        {
+            source += IndentLine(ToString("var returnScriptVector = %s%s%uReturnValue.GetScriptVector();\n", klass->GetName().CString(), function_->GetName().CString(), function_->GetID()));
+        }
         else if (CSTypeHelper::IsSimpleReturn(function_->GetReturnType()))
             line += "return ";
         else
@@ -753,8 +810,8 @@ void CSFunctionWriter::WriteManagedFunction(String& source)
     if (!function_->IsStatic())
         nativeInstance = "nativeInstance";
 
-    line += ToString("csb_%s_%s_%s(%s",
-                     package->GetName().CString(), klass->GetName().CString(), function_->GetName().CString(), nativeInstance.CString());
+    line += ToString("csb_%s_%s_%s_%u(%s",
+                     package->GetName().CString(), klass->GetName().CString(), function_->GetName().CString(), function_->GetID(), nativeInstance.CString());
 
     if (callSig.Length())
     {
@@ -784,7 +841,7 @@ void CSFunctionWriter::WriteManagedFunction(String& source)
 
             if (retClass->IsNumberArray())
             {
-                line = ToString("return %s%sReturnValue;", klass->GetName().CString(), function_->GetName().CString());
+                line = ToString("return %s%s%uReturnValue;", klass->GetName().CString(), function_->GetName().CString(), function_->GetID());
             }
             else
             {
@@ -796,6 +853,14 @@ void CSFunctionWriter::WriteManagedFunction(String& source)
             source+= "\n";
         }
     }
+    else if (function_->GetReturnType() && function_->GetReturnType()->type_->asVectorType())
+    {
+        if (!function_->IsStatic())
+        {
+            source += IndentLine(ToString("return %s%s%uReturnValue;", klass->GetName().CString(), function_->GetName().CString(), function_->GetID()));
+            source+= "\n";
+        }
+    }
 
     Dedent();
 
@@ -837,6 +902,7 @@ void CSFunctionWriter::GenerateManagedSource(String& sourceOut)
         if (function_->GetReturnClass())
         {
             JSBClass* retClass = function_->GetReturnClass();
+
             if (retClass->IsNumberArray())
             {
                 JSBClass* klass = function_->GetClass();
@@ -848,11 +914,28 @@ void CSFunctionWriter::GenerateManagedSource(String& sourceOut)
 
                 marshal += managedType + " ";
 
-                marshal += ToString("%s%sReturnValue = new %s();\n", klass->GetName().CString(), function_->GetName().CString(), managedType.CString());
+                marshal += ToString("%s%s%uReturnValue = new %s();\n", klass->GetName().CString(), function_->GetName().CString(), function_->GetID(), managedType.CString());
 
                 sourceOut += IndentLine(marshal);
             }
         }
+    }
+    else if (!function_->IsStatic() && function_->GetReturnType() && function_->GetReturnType()->type_->asVectorType())
+    {
+        JSBVectorType* vtype = function_->GetReturnType()->type_->asVectorType();
+
+        if (vtype->vectorType_->asClassType())
+        {
+            String classname = vtype->vectorType_->asClassType()->class_->GetName();
+            String typestring = "Vector<" + classname + ">";
+
+            String marshal = "private " + typestring + " ";
+
+            marshal += ToString("%s%s%uReturnValue = new %s();\n", function_->GetClass()->GetName().CString(), function_->GetName().CString(), function_->GetID(), typestring.CString());
+
+            sourceOut += IndentLine(marshal);
+
+        }
 
     }
 

Source/ToolCore/JSBind/CSharp/CSFunctionWriter.h

@@ -46,6 +46,8 @@ public:
     void GenerateNativeSource(String& sourceOut);
     void GenerateManagedSource(String& sourceOut);
 
+    static void SetWroteConstructor(bool value) { wroteConstructor_ = value; }
+    static bool GetWroteConstructor() { return wroteConstructor_; }
 
 private:
 
@@ -56,6 +58,8 @@ private:
         String assignment;
     };
 
+    static bool wroteConstructor_;
+
     Vector<DefaultStructParameter> defaultStructParameters_;
 
     void WriteDefaultStructParameters(String& source);

Source/ToolCore/JSBind/CSharp/CSTypeHelper.cpp

@@ -71,6 +71,16 @@ void CSTypeHelper::GenNativeFunctionParameterSignature(JSBFunction* function, St
         args.Push(ToString("%s* returnValue", function->GetReturnClass()->GetNativeName().CString()));
     }
 
+    if (function->GetReturnType())
+    {
+        JSBVectorType* vtype = function->GetReturnType()->type_->asVectorType();
+
+        if (vtype)
+        {
+            args.Push("ScriptVector* returnValue");
+        }
+    }
+
     sig.Join(args, ", ");
 
 }
@@ -117,6 +127,10 @@ String CSTypeHelper::GetNativeFunctionSignature(JSBFunction* function, String& r
         else
         {
             returnType = ToString("%s", CSTypeHelper::GetNativeTypeString(function->GetReturnType()).CString());
+
+            // ScriptVector is handled by a out parameter
+            if (returnType.Contains("ScriptVector"))
+                returnType = "void";
         }
     }
 
@@ -124,9 +138,9 @@ String CSTypeHelper::GetNativeFunctionSignature(JSBFunction* function, String& r
     String sig;
     GenNativeFunctionParameterSignature(function, sig);
 
-    String functionSig = ToString("csb_%s_%s_%s(%s)",
+    String functionSig = ToString("csb_%s_%s_%s_%u(%s)",
                 package->GetName().CString(), klass->GetName().CString(),
-                fname.CString(), sig.CString());
+                fname.CString(), function->GetID(), sig.CString());
 
     return functionSig;
 }
@@ -372,11 +386,16 @@ bool CSTypeHelper::OmitFunction(JSBFunction* function)
         return true;
     }
 
-    // avoid vector type for now
-    if (function->GetReturnType() && function->GetReturnType()->type_->asVectorType())
+    if (function->GetReturnType())
     {
-        function->SetSkipLanguage(BINDINGLANGUAGE_CSHARP);
-        return true;
+        if (JSBVectorType* vtype = function->GetReturnType()->type_->asVectorType())
+        {
+            if (!vtype->vectorType_->asClassType() || vtype->vectorType_->asClassType()->class_->IsNumberArray())
+            {
+                function->SetSkipLanguage(BINDINGLANGUAGE_CSHARP);
+                return true;
+            }
+        }
     }
 
     Vector<JSBFunctionType*>& parameters = function->GetParameters();
@@ -395,6 +414,26 @@ bool CSTypeHelper::OmitFunction(JSBFunction* function)
 
     }
 
+    // filter overloads which differ in PODVector vs Vector/StringHash vs String, etc
+
+    PODVector<JSBFunction*> allFunctions;
+    function->GetClass()->GetAllFunctions(allFunctions);
+
+    for (unsigned i = 0; i < allFunctions.Size(); i++)
+    {
+        JSBFunction* other = allFunctions[i];
+
+        if (other == function || other->GetSkipLanguage(BINDINGLANGUAGE_CSHARP))
+            continue;
+
+        if (other->Match(function))
+        {
+            if (other->GetClass() == function->GetClass())
+                other->SetSkipLanguage(BINDINGLANGUAGE_CSHARP);
+        }
+
+    }
+
     return false;
 }
 

Source/ToolCore/JSBind/JSBClass.cpp

@@ -58,6 +58,7 @@ void JSBFunctionSignature::Parse()
 
 }
 
+
 bool JSBFunctionSignature::Match(JSBFunction* function)
 {
 
@@ -181,11 +182,20 @@ JSBClass* JSBClass::GetBaseClass()
 
 }
 
-JSBFunction* JSBClass::GetConstructor()
+void JSBClass::GetAllFunctions(PODVector<JSBFunction*>& functions)
+{
+    if (baseClasses_.Size())
+        baseClasses_[0]->GetAllFunctions(functions);
+
+    functions += functions_;
+
+}
+
+JSBFunction* JSBClass::GetConstructor(BindingLanguage bindingLanguage)
 {
     {
         for (unsigned i = 0; i < functions_.Size(); i++)
-            if (functions_[i]->IsConstructor() && !functions_[i]->Skip())
+            if (functions_[i]->IsConstructor() && !functions_[i]->Skip(bindingLanguage))
                 return functions_[i];
     }
 
@@ -340,9 +350,9 @@ void JSBClass::Process()
             {
                 function->SetOverload();
                 function2->SetOverload();
-                // initially set all overridden functions to skip
-                function->SetSkip(true);
-                function2->SetSkip(true);
+                // initially set all overridden functions to skip (for JavaScript)
+                function->SetSkipLanguage(BINDINGLANGUAGE_JAVASCRIPT);
+                function2->SetSkipLanguage(BINDINGLANGUAGE_JAVASCRIPT);
                 break;
             }
         }
@@ -363,7 +373,7 @@ void JSBClass::Process()
                 if (!override->Match(function))
                     continue;
 
-                function->SetSkip(false);
+                function->SetSkipLanguage(BINDINGLANGUAGE_JAVASCRIPT, false);
 
                 break;
 

Source/ToolCore/JSBind/JSBClass.h

@@ -24,6 +24,7 @@
 
 #include <Atomic/Core/Object.h>
 
+#include "JSBindTypes.h"
 #include "JSBHeader.h"
 #include "JSBModule.h"
 
@@ -127,6 +128,9 @@ public:
     PODVector<JSBClass*>& GetBaseClasses() {return baseClasses_; }
     PODVector<JSBFunction*>& GetFunctions() { return functions_; }
 
+    // Get all functions, including those in base classes
+    void GetAllFunctions(PODVector<JSBFunction*>& functions);
+
     bool IsGeneric() { return isGeneric_; }
     bool IsAbstract() { return isAbstract_; }
 
@@ -156,7 +160,7 @@ public:
     int  GetNumberArrayElements() { return numberArrayElements_;}
     const String& GetArrayElementType() const { return arrayElementType_; }
 
-    JSBFunction* GetConstructor();
+    JSBFunction* GetConstructor(BindingLanguage bindingLanguage = BINDINGLANGUAGE_ANY );
 
     void SetAbstract(bool value = true) { isAbstract_ = value; }
     void SetObject(bool value = true) { isObject_ = value; }

Source/ToolCore/JSBind/JSBDoc.cpp

@@ -195,7 +195,7 @@ void JSBDoc::ExportModuleClasses(JSBModule* module)
 
         }
 
-        JSBFunction* constructor = klass->GetConstructor();
+        JSBFunction* constructor = klass->GetConstructor(BINDINGLANGUAGE_JAVASCRIPT);
         if (constructor)
         {
             String docs = GenFunctionDoc(constructor);

Source/ToolCore/JSBind/JSBFunction.cpp

@@ -24,6 +24,19 @@
 
 namespace ToolCore
 {
+
+unsigned JSBFunction::idCounter_ = 1;
+
+JSBFunction::JSBFunction(JSBClass* klass) : class_(klass), returnType_(0),
+                                  isConstructor_(false), isDestructor_(false),
+                                  isGetter_(false), isSetter_(false),
+                                  isOverload_(false), skip_(false),
+                                  isVirtual_(false), isStatic_(false)
+{
+    id_ = idCounter_++;
+}
+
+
 void JSBFunction::Process()
 {
     if (skip_)
@@ -31,6 +44,11 @@ void JSBFunction::Process()
         return;
     }
 
+    // only setup properties for methods which weren't skipped for JS, for example overloads
+
+    if (GetSkipLanguage(BINDINGLANGUAGE_JAVASCRIPT))
+        return;
+
     // if not already marked as a getter
     if (!isGetter_)
     {

Source/ToolCore/JSBind/JSBFunction.h

@@ -52,6 +52,12 @@ public:
         if (!other)
             return false;
 
+        if (type_->asStringType() || type_->asStringHashType())
+        {
+           if (other->type_->asStringType() || other->type_->asStringHashType())
+               return true;
+        }
+
         if (isSharedPtr_ != other->isSharedPtr_)
             return false;
         if (isPointer_ != other->isPointer_)
@@ -131,14 +137,7 @@ class JSBFunction : public JSBSymbol
 
 public:
 
-    JSBFunction(JSBClass* klass) : class_(klass), returnType_(0),
-                                   isConstructor_(false), isDestructor_(false),
-                                   isGetter_(false), isSetter_(false),
-                                   isOverload_(false), skip_(false),
-                                   isVirtual_(false), isStatic_(false)
-    {
-
-    }
+    JSBFunction(JSBClass* klass);
 
     const String& GetName() { return name_; }
 
@@ -160,6 +159,8 @@ public:
         return GetSkipLanguage(language);
     }
 
+    unsigned GetID() const { return id_; }
+
     JSBClass* GetClass() { return class_; }
     const String& GetPropertyName() { return propertyName_; }
     JSBFunctionType* GetReturnType() { return returnType_; }
@@ -185,7 +186,17 @@ public:
 
     void SetSkipLanguage(BindingLanguage language, bool skip = true)
     {
-        bindSkip_[language] = skip;
+        if (skip)
+        {
+            if (!skipLanguages_.Contains(language))
+                skipLanguages_.Push(language);
+        }
+        else
+        {
+            if (skipLanguages_.Contains(language))
+                skipLanguages_.Remove(language);
+
+        }
     }
 
     /// Returns true is _skip is set or skip is set for specific binding language
@@ -194,10 +205,8 @@ public:
         if (skip_)
             return true;
 
-        if (bindSkip_.Contains(language))
-            return bindSkip_[language];
+        return skipLanguages_.Contains(language);
 
-        return false;
     }
 
     int FirstDefaultParameter()
@@ -251,6 +260,9 @@ public:
 
 private:
 
+    unsigned id_;
+    static unsigned idCounter_;
+
     SharedPtr<JSBClass> class_;
 
     String name_;
@@ -269,7 +281,7 @@ private:
     bool isVirtual_;
     bool isStatic_;
     bool skip_;
-    HashMap<unsigned, bool> bindSkip_;
+    PODVector<BindingLanguage> skipLanguages_;
 };
 
 }

Source/ToolCore/JSBind/JSBHaxe.cpp

@@ -346,7 +346,7 @@ namespace ToolCore
             if (propertyNames.Size())
                 source_ += "\n";
 
-            JSBFunction* constructor = klass->GetConstructor();
+            JSBFunction* constructor = klass->GetConstructor(BINDINGLANGUAGE_JAVASCRIPT);
             if (constructor)
             {
                 ExportFunction(constructor);

Source/ToolCore/JSBind/JSBHeaderVisitor.h

@@ -71,7 +71,7 @@ public:
         return nvisitor(name);
     }
 
-    JSBType* processTypeConversion(Type* type)
+    JSBType* processTypeConversion(Type* type, FullySpecifiedType fst)
     {
         JSBType* jtype = NULL;
 
@@ -94,30 +94,41 @@ public:
 
             if (classname == "Vector" || classname == "PODVector")
             {
-                if (ntype->name()->asTemplateNameId())
-                {
-                    bool isPointer = false;
-
-                    const TemplateNameId* tnid = ntype->name()->asTemplateNameId();
-                    FullySpecifiedType pfst = tnid->templateArgumentAt(0);
+                PODVector<TemplateType> types;
+                unwrapTemplateType(fst, types);
 
-                    Type* type = pfst.type();
+                if (types.Size() == 2)
+                {
+                    JSBType* vtype = processTypeConversion((Type*) types[1].type_, types[1].fstype_);
 
-                    // unwrap pointer
-                    if (type->isPointerType())
+                    if (vtype)
                     {
-                        isPointer = true;
-                        pfst = type->asPointerType()->elementType();
-                        type = pfst.type();
+                        jtype = new JSBVectorType(vtype, classname == "PODVector");
                     }
 
-                    JSBType* vtype = processTypeConversion(type);
+                }
+                else if (types.Size() == 3 && ( getNameString(types[1].name_) == "SharedPtr" || getNameString(types[1].name_) == "WeakPtr"))
+                {
+                    JSBType* vtype = processTypeConversion((Type*) types[2].type_, types[2].fstype_);
 
                     if (vtype)
                     {
-                        jtype = new JSBVectorType(vtype, classname == "PODVector");
+                        JSBVectorType* jvtype = new JSBVectorType(vtype, classname == "PODVector");
+
+                        if (getNameString(types[1].name_) == "SharedPtr")
+                        {
+                            jvtype->vectorTypeIsSharedPtr_ = true;
+                        }
+                        else if (getNameString(types[1].name_) == "WeakPtr")
+                        {
+                            jvtype->vectorTypeIsWeakPtr_ = true;
+                        }
+
+                        jtype = jvtype;
                     }
+
                 }
+
             }
             else if (classname == "String")
             {
@@ -157,6 +168,71 @@ public:
 
     }
 
+    struct TemplateType
+    {
+        FullySpecifiedType fstype_;
+        bool isPointer_;
+        bool isReference_;
+        const Name* name_;
+        const Type* type_;
+
+        static void Init(TemplateType& ttype)
+        {
+            ttype.isPointer_ = false;
+            ttype.isReference_ = false;
+            ttype.name_ = 0;
+            ttype.type_ = 0;
+        }
+    };
+
+    bool unwrapTemplateType(const FullySpecifiedType& fstype, PODVector<TemplateType>& types)
+    {
+        TemplateType ttype;
+
+        TemplateType::Init(ttype);
+
+        ttype.fstype_ = fstype;
+        ttype.type_ = fstype.type();
+
+        if (ttype.type_->isPointerType())
+        {
+            ttype.isPointer_=true;
+            FullySpecifiedType pfst = ttype.type_->asPointerType()->elementType();
+            ttype.type_ = pfst.type();
+        }
+
+        if (ttype.type_->isReferenceType())
+        {
+            ttype.isReference_=true;
+            FullySpecifiedType pfst = ttype.type_->asReferenceType()->elementType();
+            ttype.type_ = pfst.type();
+        }
+
+        const NamedType* ntype = ttype.type_->asNamedType();
+
+        if (!ntype)
+            return false;
+
+        if (ntype->name()->asTemplateNameId())
+        {
+            const TemplateNameId* tnid = ntype->name()->asTemplateNameId();
+
+            ttype.name_ = tnid->identifier()->asNameId();
+
+            types.Push(ttype);
+
+            unwrapTemplateType(tnid->templateArgumentAt(0), types);
+
+            return true;
+        }
+
+        ttype.name_ = ntype->name();
+
+        types.Push(ttype);
+
+        return false;
+    }
+
     JSBFunctionType* processFunctionType(FullySpecifiedType fst, bool retType = false)
     {
         JSBType* jtype = NULL;
@@ -187,14 +263,18 @@ public:
             if (type->isNamedType())
             {
                 NamedType* ntype = type->asNamedType();
+
                 if (ntype->name()->asTemplateNameId())
                 {
-                    const TemplateNameId* tnid = ntype->name()->asTemplateNameId();
-                    String classname = getNameString(tnid->identifier()->asNameId());
-                    if (classname == "SharedPtr")
+                    PODVector<TemplateType> types;
+                    unwrapTemplateType(fst, types);
+
+                    String classname = getNameString(types[0].name_);
+
+                    // SharedPtr
+                    if ( classname == "SharedPtr" && types.Size() == 2 )
                     {
-                        FullySpecifiedType pfst = tnid->templateArgumentAt(0);
-                        type = pfst.type();
+                        type = (Type*) types[1].type_;
                         isTemplate = true;
                         isSharedPtr = true;
                     }
@@ -214,7 +294,7 @@ public:
 
         if (!jtype)
         {
-            jtype = processTypeConversion(type);
+            jtype = processTypeConversion(type, fst);
 
             // explicit script string -> StringHash required
             if (jtype && jtype->asStringHashType())

Source/ToolCore/JSBind/JSBType.cpp

@@ -74,7 +74,16 @@ String JSBVectorType::ToString()
 {
     if (vectorType_->asClassType())
     {
-        return isPODVector_ ? "PODVector<" + vectorType_->ToString() + "*>" : "Vector<" + vectorType_->ToString() + "*>";
+        String classname = vectorType_->ToString();
+
+        if (vectorTypeIsSharedPtr_)
+            classname = "SharedPtr<" + classname + ">";
+        else if (vectorTypeIsWeakPtr_)
+            classname = "WeakPtr<" + classname + ">";
+        else
+            classname += "*";
+
+        return isPODVector_ ? "PODVector<" + classname + ">" : "Vector<" + classname + ">";
     }
 
     return isPODVector_ ? "PODVector<" + vectorType_->ToString() + ">" : "Vector<" + vectorType_->ToString() + ">";

Source/ToolCore/JSBind/JSBType.h

@@ -150,7 +150,7 @@ public:
         if (!other)
             return false;
 
-        return other->asStringType() == 0 ? false : true;
+        return (other->asStringType() == 0 && other->asStringHashType() == 0) ? false : true;
     }
 
 
@@ -169,7 +169,7 @@ public:
         if (!other)
             return false;
 
-        return other->asStringHashType() == 0 ? false : true;
+        return (other->asStringHashType() == 0 && other->asStringType() == 0)  ? false : true;
     }
 
 };
@@ -225,7 +225,10 @@ class JSBVectorType : public JSBType
 
 public:
 
-    JSBVectorType(JSBType* vtype, bool podVector = false) : vectorType_(vtype), isPODVector_(podVector) {}
+    JSBVectorType(JSBType* vtype, bool podVector = false) : vectorType_(vtype),
+        vectorTypeIsWeakPtr_(false),
+        vectorTypeIsSharedPtr_(false),
+        isPODVector_(podVector) {}
 
     virtual JSBVectorType* asVectorType() { return this; }
 
@@ -245,7 +248,8 @@ public:
     }
 
     JSBType* vectorType_;
-
+    bool vectorTypeIsWeakPtr_;
+    bool vectorTypeIsSharedPtr_;
     bool isPODVector_;
 
 };

Source/ToolCore/JSBind/JSBTypeScript.cpp

@@ -248,7 +248,7 @@ void JSBTypeScript::ExportModuleClasses(JSBModule* module)
         if (propertyNames.Size())
             source_ += "\n";
 
-        JSBFunction* constructor = klass->GetConstructor();
+        JSBFunction* constructor = klass->GetConstructor(BINDINGLANGUAGE_JAVASCRIPT);
         if (constructor)
         {
             ExportFunction(constructor);

Source/ToolCore/JSBind/JavaScript/JSFunctionWriter.cpp

@@ -511,9 +511,20 @@ void JSFunctionWriter::WriteFunction(String& source)
         }
         else if (returnType->type_->asVectorType())
         {
+            JSBType* vectorType = returnType->type_->asVectorType()->vectorType_;
+
             source.Append("duk_push_array(ctx);\n");
             source.Append("for (unsigned i = 0; i < retValue.Size(); i++)\n{\n");
-            source.Append("duk_push_string(ctx, retValue[i].CString());\n");
+
+            if (vectorType->asClassType())
+            {
+                source.AppendWithFormat("js_push_class_object_instance(ctx, retValue[i], \"%s\");\n", vectorType->asClassType()->class_->GetName().CString());
+            }
+            else
+            {
+                source.Append("duk_push_string(ctx, retValue[i].CString());\n");
+            }
+
             source.Append("duk_put_prop_index(ctx, -2, i);\n}\n");
         }