WIP Thunks

CMake/Modules/AtomicDesktop.cmake

@@ -1,4 +1,3 @@
-
 include_directories(${CMAKE_SOURCE_DIR}/Source/ThirdParty/Poco/Foundation/include)
 
 add_definitions( -DATOMIC_TBUI -DATOMIC_FILEWATCHER -DPOCO_NO_AUTOMATIC_LIBS)

CMake/Modules/AtomicMac.cmake

@@ -4,6 +4,8 @@ include(AtomicDesktop)
 
 set (JAVASCRIPT_BINDINGS_PLATFORM "MACOSX")
 
+include(AtomicNET)
+
 # only have 32 bit mono installed, fix this
 # set (CMAKE_OSX_ARCHITECTURES i386)
 

CMake/Modules/AtomicNET.cmake

@@ -0,0 +1,34 @@
+set (CSATOMICNATIVEDIR "${CMAKE_SOURCE_DIR}/Build/Source/Generated/${JAVASCRIPT_BINDINGS_PLATFORM}/CSharp/Packages/Atomic/Native")
+set (CSATOMICPLAYERNATIVEDIR "${CMAKE_SOURCE_DIR}/Build/Source/Generated/${JAVASCRIPT_BINDINGS_PLATFORM}/CSharp/Packages/AtomicPlayer/Native")
+
+# Create the JSBind files ahead of time, so they are picked up with glob
+set (CSFILES CSModuleAtomic2D.cpp;CSModuleAtomic3D.cpp;CSModuleAudio.cpp;CSModuleContainer.cpp;CSModuleCore.cpp;
+             CSModuleEngine.cpp;CSModuleEnvironment.cpp;CSModuleGraphics.cpp;CSModuleInput.cpp;
+             CSModuleIO.cpp;CSModuleJavascript.cpp;CSModuleMath.cpp;CSModuleNavigation.cpp;
+             CSModuleNetwork.cpp;CSModulePhysics.cpp;CSModuleResource.cpp;CSPackageAtomic.cpp;
+             CSModuleScene.cpp;CSModuleUI.cpp;CSPackageAtomic.h;CSModuleAtomicNET.cpp)
+
+set (CSATOMICPLAYERFILES CSModulePlayer.cpp;CSPackageAtomicPlayer.cpp;CSPackageAtomicPlayer.h)
+
+foreach(CSFILE ${CSFILES})
+
+  set (CSFILEPATH "${CSATOMICNATIVEDIR}/${CSFILE}")
+
+  if (NOT EXISTS ${CSFILEPATH})
+    file(WRITE "${CSFILEPATH}" "// will be created by AtomicTool")
+  endif()
+
+endforeach()
+
+foreach(CSFILE ${CSATOMICPLAYERFILES})
+
+  set (CSFILEPATH "${CSATOMICPLAYERNATIVEDIR}/${CSFILE}")
+
+  if (NOT EXISTS ${CSFILEPATH})
+    file(WRITE "${CSFILEPATH}" "// will be created by AtomicTool")
+  endif()
+
+endforeach()
+
+file (GLOB CSHARP_BINDINGS_SOURCE ${CSATOMICNATIVEDIR}/*.cpp ${CSATOMICNATIVEDIR}/*.h)
+file (GLOB CSHARPATOMICPLAYER_BINDINGS_SOURCE ${CSATOMICPLAYERNATIVEDIR}/*.cpp ${CSATOMICPLAYERNATIVEDIR}/*.h)

CMake/Modules/AtomicWindows.cmake

@@ -3,8 +3,9 @@ include(AtomicDesktop)
 
 set (JAVASCRIPT_BINDINGS_PLATFORM "WINDOWS")
 
-#set (CMAKE_DEBUG_POSTFIX _d)
+include(AtomicNET)
 
+#set (CMAKE_DEBUG_POSTFIX _d)
 
 if( CMAKE_SIZEOF_VOID_P EQUAL 8 )
     set (D3DCOMPILER_47_DLL ${CMAKE_SOURCE_DIR}/Build/Windows/Binaries/x64/D3DCompiler_47.dll)

Script/Packages/Atomic/AtomicNET.json

@@ -0,0 +1,6 @@
+{
+	"name" : "AtomicNET",
+	"sources" : ["Source/AtomicNET/NETCore"],
+	"classes" : ["NETCore", "NETManaged", "CSComponent", "CSScriptObject"]
+
+}

Script/Packages/Atomic/Package.json

@@ -5,8 +5,8 @@
 
 	"modules" : ["Container", "Math", "Core", "Scene", "Graphics", "Atomic3D", "Atomic2D", "Audio",
 	"Physics", "Navigation", "Input", "UI", "Resource", "Network", "IO",
-	"Engine", "Javascript", "Environment", "Web"],
-
+	"Engine", "Javascript", "Environment", "Web", "AtomicNET"],
+	"dotnetModules" : ["AtomicNET"],
 	"moduleExclude" : {
 		"WEB" : ["Network", "Navigation"]
 	}

Source/AtomicEditor/CMakeLists.txt

@@ -1,7 +1,9 @@
-include_directories (${CMAKE_SOURCE_DIR}/Source/ThirdParty/rapidjson/include
-                     ${CMAKE_SOURCE_DIR}/Source/ThirdParty
-                     ${CMAKE_SOURCE_DIR}/Source/ThirdParty/nativefiledialog)
-
+include_directories ( ${CMAKE_SOURCE_DIR}/Source/ThirdParty
+                      ${CMAKE_SOURCE_DIR}/Source/ThirdParty/rapidjson/include
+                      ${CMAKE_SOURCE_DIR}/Source/ThirdParty/kNet/include
+                      ${CMAKE_SOURCE_DIR}/Source/ThirdParty/FreeType/include
+                      ${CMAKE_SOURCE_DIR}/Source/ThirdParty/Box2D
+                      ${CMAKE_SOURCE_DIR}/Source/ThirdParty/nativefiledialog )
 
 file (GLOB_RECURSE SOURCE_FILES *.cpp *.h)
 
@@ -22,6 +24,8 @@ file (GLOB JAVASCRIPT_BINDINGS_SOURCE ${CMAKE_SOURCE_DIR}/Build/Source/Generated
 
 set (SOURCE_FILES ${SOURCE_FILES} ${JAVASCRIPT_BINDINGS_SOURCE})
 
+set (SOURCE_FILES ${SOURCE_FILES} ${CSHARP_BINDINGS_SOURCE} ${CSHARPATOMICPLAYER_BINDINGS_SOURCE})
+
 if (APPLE)
 
     file (GLOB_RECURSE OBJC_FILES *.mm *.h)
@@ -82,7 +86,7 @@ elseif(LINUX)
         add_custom_command (TARGET AtomicEditor POST_BUILD
         COMMAND  ${NODEJS_CMD} "${CMAKE_SOURCE_DIR}/Build/TypeScript/tsc.js" "-p" "./Script"
         WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
-    endif() 
+    endif()
 else()
     target_link_libraries(AtomicEditor libcurl Iphlpapi Wldap32)
 

Source/AtomicNET/CMakeLists.txt

@@ -1,3 +1,3 @@
 
 add_subdirectory(NETCore)
-add_subdirectory(NETRuntime)
+add_subdirectory(NETNative)

Source/AtomicNET/NETRuntime/CSComponent.cpp → Source/AtomicNET/NETCore/CSComponent.cpp

@@ -34,7 +34,7 @@
 #include <Atomic/Scene/SceneEvents.h>
 
 #include "CSComponent.h"
-#include "AtomicSharpAPI.h"
+//#include "AtomicSharpAPI.h"
 
 namespace Atomic
 {
@@ -87,7 +87,8 @@ public:
 
         if (managedClass.Length())
         {
-            ptr = CSComponentCreate(managedClass);
+            // change to callback
+            //ptr = CSComponentCreate(managedClass);
         }
 
         if (ptr.Null())
@@ -147,7 +148,8 @@ void CSComponent::CallScriptMethod(CSComponentMethod method, float value)
     if (destroyed_ || !node_ || !node_->GetScene())
         return;
 
-    CSComponentCallMethod(GetRefID(), method, value);
+    // Change to callback
+    //CSComponentCallMethod(GetRefID(), method, value);
 
 }
 

Source/AtomicNET/NETRuntime/CSEventHelper.cpp → Source/AtomicNET/NETCore/CSEventHelper.cpp

@@ -23,7 +23,7 @@
 #include <Atomic/IO/Log.h>
 #include <Atomic/UI/UIEvents.h>
 
-#include "AtomicSharpAPI.h"
+//#include "AtomicSharpAPI.h"
 #include "CSEventHelper.h"
 
 namespace Atomic
@@ -42,7 +42,8 @@ CSEventDispatcher::~CSEventDispatcher()
 
 void CSEventDispatcher::BeginSendEvent(Context* context, Object* sender, StringHash eventType, VariantMap& eventData)
 {
-    CSBeginSendEvent(sender->GetRefID(), eventType.ToHash(), &eventData);
+    // change to setting a callback
+    // CSBeginSendEvent(sender->GetRefID(), eventType.ToHash(), &eventData);
 }
 
 void CSEventDispatcher::EndSendEvent(Context* context, Object* sender, StringHash eventType, VariantMap& eventData)

Source/AtomicNET/NETCore/NETCore.cpp

@@ -5,7 +5,11 @@
 #include <Atomic/IO/Log.h>
 #include <Atomic/Core/StringUtils.h>
 
+#include "CSEventHelper.h"
+#include "CSComponent.h"
 #include "NETCore.h"
+#include "NETManaged.h"
+#include "NETCoreThunk.h"
 
 namespace Atomic
 {
@@ -58,18 +62,42 @@ static ExecuteAssemblyFunction sExecuteAssembly = 0;
 static CreateDelegateFunction sCreateDelegate = 0;
 static ShutdownCoreCLRFunction sShutdownCoreCLR = 0;
 
+/// Register NETCore library objects.
+void ATOMIC_API RegisterNETCoreLibrary(Context* context);
+
+WeakPtr<Context> NETCore::csContext_;
+WeakPtr<NETCore> NETCore::instance_;
+
 NETCore::NETCore(Context* context) :
     Object(context),
     coreCLRDLLHandle_(0),
     hostHandle_(0),
     domainId_(0)
 {
+    RegisterNETCoreLibrary(context_);
+
+    NetCoreThunkInit();
+
+    assert(!instance_);
+    instance_ = this;
+    csContext_ = context;
+
+    SharedPtr<NETManaged> managed(new NETManaged(context_));
+    context_->RegisterSubsystem(managed);
+
+    SharedPtr<CSEventDispatcher> dispatcher(new CSEventDispatcher(context_));
+    context_->RegisterSubsystem(dispatcher);
+    context_->AddGlobalEventListener(dispatcher);
 
 }
 
 NETCore::~NETCore()
 {
+    context_->RemoveGlobalEventListener(context_->GetSubsystem<CSEventDispatcher>());
+    context_->RemoveSubsystem(CSEventDispatcher::GetTypeStatic());
+    context_->RemoveSubsystem(NETManaged::GetTypeStatic());
 
+    instance_ = NULL;
 }
 
 void NETCore::GenerateTPAList(String& tpaList)
@@ -167,6 +195,22 @@ bool NETCore::InitCoreCLRDLL(String& errorMsg)
     return true;
 }
 
+
+extern "C"
+{
+
+// http://ybeernet.blogspot.com/2011/03/techniques-of-calling-unmanaged-code.html
+// pinvoke is faster than [UnmanagedFunctionPointer] :/
+// [SuppressUnmanagedCodeSecurity] <--- add this attribute, in any event
+
+void csb_Atomic_Test(unsigned id)
+{
+  LOGINFOF("%u", id);
+}
+
+}
+
+
 bool NETCore::Initialize(const String &coreCLRFilesAbsPath, String& errorMsg)
 {
     coreCLRFilesAbsPath_ = AddTrailingSlash(coreCLRFilesAbsPath);
@@ -208,7 +252,7 @@ bool NETCore::Initialize(const String &coreCLRFilesAbsPath, String& errorMsg)
     String appPath = "/Users/josh/Desktop/OSX.x64.Debug/";
     Vector<String> nativeSearch;
     nativeSearch.Push(coreCLRFilesAbsPath_);
-    nativeSearch.Push("/Users/josh/Dev/atomic/AtomicGameEngineSharp-build/Source/AtomicNET/NETRuntime");
+    nativeSearch.Push("/Users/josh/Dev/atomic/AtomicGameEngineSharp-build/Source/AtomicNET/NETNative");
 
     String nativeDllSearchDirs;
     nativeDllSearchDirs.Join(nativeSearch, ":");
@@ -227,7 +271,7 @@ bool NETCore::Initialize(const String &coreCLRFilesAbsPath, String& errorMsg)
     };
 
     int st = sInitializeCoreCLR(
-                "/Users/josh/Desktop/OSX.x64.Debug/HelloWorld.exe",
+                "",
                 "NETCore",
                 sizeof(propertyKeys) / sizeof(propertyKeys[0]),
                 propertyKeys,
@@ -242,6 +286,7 @@ bool NETCore::Initialize(const String &coreCLRFilesAbsPath, String& errorMsg)
         return false;
     }
 
+
     /*
     void* hm;
 
@@ -259,6 +304,7 @@ bool NETCore::Initialize(const String &coreCLRFilesAbsPath, String& errorMsg)
     }
     */
 
+
 /*
     unsigned int exitCode;
 
@@ -275,5 +321,11 @@ bool NETCore::Initialize(const String &coreCLRFilesAbsPath, String& errorMsg)
 
 }
 
+void RegisterNETCoreLibrary(Context* context)
+{
+    CSComponent::RegisterObject(context);
+}
+
+
 }
 

Source/AtomicNET/NETCore/NETCore.h

@@ -40,9 +40,12 @@ public:
     virtual ~NETCore();
 
     bool Initialize(const String& coreCLRFilesAbsPath, String &errorMsg);
-
     void Shutdown();
 
+    /// We access this directly in binding code, where there isn't a context
+    /// to get a reference from
+    static inline Context* GetContext() { return instance_->csContext_; }
+
 private:
 
     bool InitCoreCLRDLL(String &errorMsg);
@@ -53,6 +56,10 @@ private:
     void* hostHandle_;
     unsigned domainId_;
 
+    /// weak local context ref, so avoid recursion in static GetContext call
+    static WeakPtr<Context> csContext_;
+
+    static WeakPtr<NETCore> instance_;
 
 };
 

Source/AtomicNET/NETCore/NETCoreThunk.cpp

@@ -0,0 +1,91 @@
+
+#include "NETCore.h"
+#include "NETManaged.h"
+#include "NETCoreThunk.h"
+
+
+namespace Atomic
+{
+
+static AtomicNETCoreThunk_t AtomicNETCoreThunk;
+
+void Atomic_NETManaged_SetCSComponentCreate(CSComponentCreateFunctionPtr method)
+{
+    NETCore::GetContext()->GetSubsystem<NETManaged>()->SetCSComponentCreate(method);
+}
+
+
+void Atomic_NETManaged_SetCSComponentCallMethod(CSComponentCallMethodFunctionPtr method)
+{
+    NETCore::GetContext()->GetSubsystem<NETManaged>()->SetCSComponentCallMethod(method);
+}
+
+// Event Handling
+
+void Atomic_NETManaged_SetCSBeginSendEvent(CSBeginSendEventFunctionPtr method)
+{
+    NETCore::GetContext()->GetSubsystem<NETManaged>()->SetCSBeginSendEvent(method);
+}
+
+void Atomic_AObject_SendEvent(Object* object, const char* eventType)
+{
+    object->SendEvent(eventType);
+}
+
+ClassID Atomic_RefCounted_GetClassID(RefCounted* refCounted)
+{
+    if (!refCounted)
+        return 0;
+
+    return refCounted->GetClassID();
+}
+
+RefCounted* AtomicEngine_GetSubsystem(const char* name)
+{
+    return NETCore::GetContext()->GetSubsystem(name);
+}
+
+void Atomic_RefCounted_SafeAddRef(unsigned id)
+{
+    RefCounted* ref = RefCounted::GetByID(id);
+    if (ref)
+        ref->AddRef();
+
+}
+
+void Atomic_RefCounted_SafeReleaseRef(unsigned id)
+{
+    RefCounted* ref = RefCounted::GetByID(id);
+    if (ref)
+        ref->ReleaseRef();
+}
+
+unsigned Atomic_StringToStringHash(const char* stringValue)
+{
+    StringHash hash = stringValue;
+    return hash.Value();
+}
+
+// Variant Map
+RefCounted* Atomic_VariantMap_GetInstance(VariantMap& vmap, const char* key)
+{
+    return vmap[key].GetPtr();
+}
+
+void NetCoreThunkInit()
+{
+    AtomicNETCoreThunk.__Atomic_NETManaged_SetCSBeginSendEvent = Atomic_NETManaged_SetCSBeginSendEvent;
+    AtomicNETCoreThunk.__Atomic_NETManaged_SetCSComponentCallMethod = Atomic_NETManaged_SetCSComponentCallMethod;
+    AtomicNETCoreThunk.__Atomic_NETManaged_SetCSComponentCreate = Atomic_NETManaged_SetCSComponentCreate;
+
+    AtomicNETCoreThunk.__Atomic_AObject_SendEvent = Atomic_AObject_SendEvent;
+
+    AtomicNETCoreThunk.__AtomicEngine_GetSubsystem = AtomicEngine_GetSubsystem;
+    AtomicNETCoreThunk.__Atomic_StringToStringHash = Atomic_StringToStringHash;
+    AtomicNETCoreThunk.__Atomic_VariantMap_GetInstance = Atomic_VariantMap_GetInstance;
+    AtomicNETCoreThunk.__Atomic_RefCounted_SafeAddRef = Atomic_RefCounted_SafeAddRef;
+    AtomicNETCoreThunk.__Atomic_RefCounted_SafeReleaseRef = Atomic_RefCounted_SafeReleaseRef;
+    AtomicNETCoreThunk.__Atomic_RefCounted_GetClassID = Atomic_RefCounted_GetClassID;
+}
+
+}

Source/AtomicNET/NETCore/NETCoreThunk.h

@@ -0,0 +1,66 @@
+
+#pragma once
+
+#include "CSComponent.h"
+
+namespace Atomic
+{
+
+typedef CSComponent* (*CSComponentCreateFunctionPtr)(const char* csComponentTypeName);
+typedef void (*CSComponentCallMethodFunctionPtr)(unsigned id, CSComponentMethod method, float value);
+typedef void (*CSBeginSendEventFunctionPtr)(unsigned senderRefID, unsigned eventType, VariantMap* eventData);
+
+typedef void (*Atomic_NETManaged_SetCSComponentCreate_Function)(CSComponentCreateFunctionPtr ptr);
+typedef void (*Atomic_NETManaged_SetCSComponentCallMethod_Function)(CSComponentCallMethodFunctionPtr ptr);
+typedef void (*Atomic_NETManaged_SetCSBeginSendEvent_Function)(CSBeginSendEventFunctionPtr ptr);
+
+typedef void (*Atomic_AObject_SendEvent_Function)(Object* object, const char* eventType);
+
+typedef RefCounted* (*AtomicEngine_GetSubsystem_Function)(const char* name);
+typedef unsigned (*Atomic_StringToStringHash_Function)(const char* stringValue);
+typedef RefCounted* (*Atomic_VariantMap_GetInstance_Function)(VariantMap& vmap, const char* key);
+typedef void (*Atomic_RefCounted_SafeAddRef_Function)(unsigned id);
+typedef void (*Atomic_RefCounted_SafeReleaseRef_Function)(unsigned id);
+typedef ClassID (*Atomic_RefCounted_GetClassID_Function)(RefCounted* refCounted);
+
+typedef struct AtomicNETCoreThunk_s
+{
+    Atomic_NETManaged_SetCSComponentCreate_Function __Atomic_NETManaged_SetCSComponentCreate;
+    Atomic_NETManaged_SetCSComponentCallMethod_Function __Atomic_NETManaged_SetCSComponentCallMethod;
+    Atomic_NETManaged_SetCSBeginSendEvent_Function __Atomic_NETManaged_SetCSBeginSendEvent;
+
+    Atomic_AObject_SendEvent_Function __Atomic_AObject_SendEvent;
+
+    AtomicEngine_GetSubsystem_Function __AtomicEngine_GetSubsystem;
+    Atomic_StringToStringHash_Function __Atomic_StringToStringHash;
+    Atomic_VariantMap_GetInstance_Function __Atomic_VariantMap_GetInstance;
+    Atomic_RefCounted_SafeAddRef_Function __Atomic_RefCounted_SafeAddRef;
+    Atomic_RefCounted_SafeReleaseRef_Function __Atomic_RefCounted_SafeReleaseRef;
+    Atomic_RefCounted_GetClassID_Function __Atomic_RefCounted_GetClassID;
+
+} AtomicNETCoreThunk_t;
+
+void NetCoreThunkInit();
+
+void Atomic_NETManaged_SetCSComponentCreate(CSComponentCreateFunctionPtr method);
+
+void Atomic_NETManaged_SetCSComponentCallMethod(CSComponentCallMethodFunctionPtr method);
+
+void Atomic_NETManaged_SetCSBeginSendEvent(CSBeginSendEventFunctionPtr method);
+
+void Atomic_AObject_SendEvent(Object* object, const char* eventType);
+
+ClassID Atomic_RefCounted_GetClassID(RefCounted* refCounted);
+
+RefCounted* AtomicEngine_GetSubsystem(const char* name);
+
+void Atomic_RefCounted_SafeAddRef(unsigned id);
+
+void Atomic_RefCounted_SafeReleaseRef(unsigned id);
+
+unsigned Atomic_StringToStringHash(const char* stringValue);
+
+// Variant Map
+RefCounted* Atomic_VariantMap_GetInstance(VariantMap& vmap, const char* key);
+
+}

Source/AtomicNET/NETCore/NETManaged.cpp

@@ -0,0 +1,72 @@
+
+#include <ThirdParty/SDL/include/SDL.h>
+
+#include <Atomic/IO/FileSystem.h>
+#include <Atomic/IO/Log.h>
+#include <Atomic/Core/StringUtils.h>
+
+#include "CSEventHelper.h"
+#include "CSComponent.h"
+#include "NETManaged.h"
+
+namespace Atomic
+{
+
+
+NETManaged::NETManaged(Context* context) :
+    Object(context),
+    CSComponentCreate_(0),
+    CSComponentCallMethod_(0),
+    CSBeginSendEvent_(0)
+{
+}
+
+NETManaged::~NETManaged()
+{
+
+}
+
+CSComponent* NETManaged::CSComponentCreate(const String& componentName)
+{
+    if (!CSComponentCreate_)
+        return 0;
+
+    return CSComponentCreate_(componentName.CString());
+
+}
+
+void NETManaged::CSComponentCallMethod(unsigned id, CSComponentMethod methodID, float value)
+{
+    if (!CSComponentCallMethod_)
+        return;
+
+    CSComponentCallMethod_(id, methodID, value);
+
+}
+
+void NETManaged::CSBeginSendEvent(unsigned senderRefID, unsigned eventType, VariantMap* eventData)
+{
+    if (!CSBeginSendEvent_)
+        return;
+
+    CSBeginSendEvent_(senderRefID, eventType, eventData);
+
+}
+
+void NETManaged::SetCSComponentCreate(CSComponentCreateFunctionPtr ptr)
+{
+    CSComponentCreate_ = ptr;
+}
+
+void NETManaged::SetCSComponentCallMethod(CSComponentCallMethodFunctionPtr ptr)
+{
+    CSComponentCallMethod_ = ptr;
+}
+
+void NETManaged::SetCSBeginSendEvent(CSBeginSendEventFunctionPtr ptr)
+{
+    CSBeginSendEvent_ = ptr;
+}
+
+}
+

Source/AtomicNET/NETRuntime/AtomicSharp.h → Source/AtomicNET/NETCore/NETManaged.h

@@ -25,30 +25,34 @@
 #include <Atomic/Core/Context.h>
 #include <Atomic/Core/Object.h>
 
+#include "NETCoreThunk.h"
+
 namespace Atomic
 {
 
-class ATOMIC_API AtomicSharp : public Object
+class ATOMIC_API NETManaged : public Object
 {
-
-    OBJECT(AtomicSharp);
+    OBJECT(NETManaged);
 
 public:
     /// Construct.
-    AtomicSharp(Context* context);
+    NETManaged(Context* context);
     /// Destruct.
-    virtual ~AtomicSharp();
+    virtual ~NETManaged();
 
-    /// We access this directly in binding code, where there isn't a context
-    /// to get a reference from
-    static inline Context* GetContext() { return instance_->csContext_; }
+    void SetCSComponentCreate(CSComponentCreateFunctionPtr ptr);
+    void SetCSComponentCallMethod(CSComponentCallMethodFunctionPtr ptr);
+    void SetCSBeginSendEvent(CSBeginSendEventFunctionPtr ptr);
 
-private:
+    CSComponent* CSComponentCreate(const String& componentName);
+    void CSComponentCallMethod(unsigned id, CSComponentMethod methodID, float value = 0.0f);
+    void CSBeginSendEvent(unsigned senderRefID, unsigned eventType, VariantMap* eventData);
 
-    /// weak local context ref, so avoid recursion in static GetContext call
-    static WeakPtr<Context> csContext_;
+private:
 
-    static WeakPtr<AtomicSharp> instance_;
+    CSComponentCreateFunctionPtr CSComponentCreate_;
+    CSComponentCallMethodFunctionPtr CSComponentCallMethod_;
+    CSBeginSendEventFunctionPtr CSBeginSendEvent_;
 
 };
 

Source/AtomicNET/NETNative/AtomicSharpAPI.cpp

@@ -0,0 +1,174 @@
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#include <AtomicNET/NETCore/NETCore.h>
+#include <AtomicNET/NETCore/NETManaged.h>
+#include <AtomicNET/NETCore/NETCoreThunk.h>
+#include <AtomicNET/NETCore/CSScriptObject.h>
+
+#include "AtomicSharpAPI.h"
+
+#ifdef ATOMIC_PLATFORM_WINDOWS
+#pragma warning(disable: 4244) // possible loss of data
+#define ATOMIC_EXPORT_API __declspec(dllexport)
+#else
+#define ATOMIC_EXPORT_API
+#endif
+
+using namespace Atomic;
+
+static AtomicNETCoreThunk_t AtomicNETCoreThunk;
+static bool AtomicNETCoreThunkEnabled = false;
+
+extern "C"
+{
+
+ATOMIC_EXPORT_API void csb_package_set_Atomic_NETCore_thunk(AtomicNETCoreThunk_t* thunkIn)
+{
+    AtomicNETCoreThunk = *thunkIn;
+    AtomicNETCoreThunkEnabled = true;
+}
+
+ATOMIC_EXPORT_API void csb_AtomicEngine_AtomicInterop_Set_CSComponentCreate(CSComponentCreateFunctionPtr method)
+{
+    if (AtomicNETCoreThunkEnabled)
+    {
+        AtomicNETCoreThunk.__Atomic_NETManaged_SetCSComponentCreate(method);
+    }
+    else
+    {
+        Atomic_NETManaged_SetCSComponentCreate(method);
+    }
+}
+
+
+ATOMIC_EXPORT_API void csb_AtomicEngine_AtomicInterop_Set_CSComponentCallMethod(CSComponentCallMethodFunctionPtr method)
+{
+    if (AtomicNETCoreThunkEnabled)
+    {
+        AtomicNETCoreThunk.__Atomic_NETManaged_SetCSComponentCallMethod(method);
+    }
+    else
+    {
+        Atomic_NETManaged_SetCSComponentCallMethod(method);
+    }
+}
+
+// Event Handling
+
+ATOMIC_EXPORT_API void csb_AtomicEngine_AtomicInterop_Set_CSBeginSendEvent(CSBeginSendEventFunctionPtr method)
+{
+    if (AtomicNETCoreThunkEnabled)
+    {
+        AtomicNETCoreThunk.__Atomic_NETManaged_SetCSBeginSendEvent(method);
+    }
+    else
+    {
+        Atomic_NETManaged_SetCSBeginSendEvent(method);
+    }
+
+}
+
+// Instance methods
+
+ATOMIC_EXPORT_API void csb_Atomic_AObject_SendEvent(Object* object, const char* eventType)
+{
+    if (AtomicNETCoreThunkEnabled)
+    {
+        AtomicNETCoreThunk.__Atomic_AObject_SendEvent(object, eventType);
+    }
+    else
+    {
+        Atomic_AObject_SendEvent(object, eventType);
+    }
+}
+
+
+ATOMIC_EXPORT_API ClassID csb_Atomic_RefCounted_GetClassID(RefCounted* refCounted)
+{
+    if (AtomicNETCoreThunkEnabled)
+    {
+        return AtomicNETCoreThunk.__Atomic_RefCounted_GetClassID(refCounted);
+    }
+    else
+    {
+        return Atomic_RefCounted_GetClassID(refCounted);
+    }
+}
+
+ATOMIC_EXPORT_API RefCounted* csb_AtomicEngine_GetSubsystem(const char* name)
+{
+    if (AtomicNETCoreThunkEnabled)
+    {
+        return AtomicNETCoreThunk.__AtomicEngine_GetSubsystem(name);
+    }
+    else
+    {
+        return AtomicEngine_GetSubsystem(name);
+    }
+}
+
+ATOMIC_EXPORT_API void csb_Atomic_RefCounted_SafeAddRef(unsigned id)
+{
+    if (AtomicNETCoreThunkEnabled)
+    {
+        AtomicNETCoreThunk.__Atomic_RefCounted_SafeAddRef(id);
+    }
+    else
+    {
+        Atomic_RefCounted_SafeAddRef(id);
+    }
+
+}
+
+ATOMIC_EXPORT_API void csb_Atomic_RefCounted_SafeReleaseRef(unsigned id)
+{
+    if (AtomicNETCoreThunkEnabled)
+    {
+        AtomicNETCoreThunk.__Atomic_RefCounted_SafeReleaseRef(id);
+    }
+    else
+    {
+        Atomic_RefCounted_SafeReleaseRef(id);
+    }
+
+}
+
+ATOMIC_EXPORT_API unsigned csb_Atomic_StringToStringHash(const char* stringValue)
+{
+    if (AtomicNETCoreThunkEnabled)
+    {
+        return AtomicNETCoreThunk.__Atomic_StringToStringHash(stringValue);
+    }
+    else
+    {
+        return Atomic_StringToStringHash(stringValue);
+    }
+}
+
+// Variant Map
+
+ATOMIC_EXPORT_API RefCounted* csb_Atomic_VariantMap_GetInstance(VariantMap& vmap, const char* key)
+{
+    if (AtomicNETCoreThunkEnabled)
+    {
+        return AtomicNETCoreThunk.__Atomic_VariantMap_GetInstance(vmap, key);
+    }
+    else
+    {
+        return Atomic_VariantMap_GetInstance(vmap, key);
+    }
+
+}
+
+}

Source/AtomicNET/NETRuntime/AtomicSharpAPI.h → Source/AtomicNET/NETNative/AtomicSharpAPI.h

@@ -13,7 +13,7 @@
 
 #pragma once
 
-#include "CSComponent.h"
+#include <AtomicNET/NETCore/CSComponent.h>
 
 namespace Atomic
 {

Source/AtomicNET/NETRuntime/AtomicSharpApp.cpp → Source/AtomicNET/NETNative/AtomicSharpApp.cpp

@@ -41,7 +41,7 @@
 
 #include <AtomicPlayer/Player.h>
 
-#include "AtomicSharp.h"
+#include <AtomicNET/NETCore/NETCore.h>
 #include "AtomicSharpApp.h"
 
 #include <Atomic/DebugNew.h>
@@ -124,8 +124,8 @@ namespace AtomicPlayer
     {
         Application::Start();
 
-        // Instantiate and register AtomicSharp subsystem
-        context_->RegisterSubsystem(new AtomicSharp(context_));
+        // Instantiate and register NETCore subsystem
+        context_->RegisterSubsystem(new NETCore(context_));
 
         // Instantiate and register the Javascript subsystem
         Javascript* javascript = new Javascript(context_);
@@ -164,7 +164,7 @@ namespace AtomicPlayer
         // as if not, will hold on engine subsystems, which is bad
         assert(!JSVM::GetJSVM(0));
 
-        context_->RemoveSubsystem<AtomicSharp>();
+        context_->RemoveSubsystem<NETCore>();
 
         Application::Stop();
 

Source/AtomicNET/NETNative/CMakeLists.txt

@@ -0,0 +1,33 @@
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}
+                    ${CMAKE_SOURCE_DIR}/Source/ThirdParty
+                    ${CMAKE_SOURCE_DIR}/Source/ThirdParty/rapidjson/include
+                    ${CMAKE_SOURCE_DIR}/Source/ThirdParty/kNet/include
+                    ${CMAKE_SOURCE_DIR}/Source/ThirdParty/FreeType/include
+                    ${CMAKE_SOURCE_DIR}/Source/ThirdParty/Box2D )
+
+
+# ${CMAKE_SOURCE_DIR}/Build/Source/Generated/${JAVASCRIPT_BINDINGS_PLATFORM}/CSharp/Packages/Atomic/Native)                    
+
+file (GLOB CSHARP_SOURCES *.cpp *.h)
+
+if (NOT MSVC)
+    # for kNet
+    add_definitions (-DUNIX)
+endif()
+
+set (SOURCE_FILES ${CSHARP_SOURCES} ${CSHARP_BINDINGS_SOURCE} ${CSHARPATOMICPLAYER_BINDINGS_SOURCE})
+
+add_library(AtomicNETNative SHARED ${SOURCE_FILES})
+
+target_link_libraries(AtomicNETNative AtomicJS AtomicPlayerLib AtomicPlayerJS NETCore ${ATOMIC_LINK_LIBRARIES})
+
+if (APPLE)
+
+target_link_libraries(AtomicNETNative "-framework AudioUnit -framework Carbon -framework Cocoa -framework CoreAudio -framework ForceFeedback -framework IOKit -framework OpenGL -framework CoreServices -framework Security")
+
+endif()
+
+if (NOT IOS AND NOT ANDROID AND NOT EMSCRIPTEN)
+    add_dependencies(AtomicNETNative AtomicTool)
+endif()

Source/AtomicNET/NETRuntime/AtomicSharp.cpp

@@ -1,47 +0,0 @@
-
-#include "CSEventHelper.h"
-#include "CSComponent.h"
-#include "AtomicSharp.h"
-
-
-namespace Atomic
-{
-
-/// Register AtomicSharp library objects.
-void ATOMIC_API RegisterAtomicSharpLibrary(Context* context);
-
-WeakPtr<Context> AtomicSharp::csContext_;
-WeakPtr<AtomicSharp> AtomicSharp::instance_;
-
-AtomicSharp::AtomicSharp(Context* context) :
-    Object(context)
-{
-    RegisterAtomicSharpLibrary(context_);
-
-    assert(!instance_);
-    instance_ = this;
-    csContext_ = context;
-
-    SharedPtr<CSEventDispatcher> dispatcher(new CSEventDispatcher(context_));
-    context_->RegisterSubsystem(dispatcher);
-    context_->AddGlobalEventListener(dispatcher);
-
-}
-
-AtomicSharp::~AtomicSharp()
-{
-    context_->RemoveGlobalEventListener(context_->GetSubsystem<CSEventDispatcher>());
-    context_->RemoveSubsystem(CSEventDispatcher::GetTypeStatic());
-
-    instance_ = NULL;
-}
-
-
-void RegisterAtomicSharpLibrary(Context* context)
-{
-    CSComponent::RegisterObject(context);
-}
-
-
-}
-

Source/AtomicNET/NETRuntime/AtomicSharpAPI.cpp

@@ -1,133 +0,0 @@
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#include "AtomicSharp.h"
-#include "AtomicSharpAPI.h"
-#include "CSScriptObject.h"
-
-#ifdef ATOMIC_PLATFORM_WINDOWS
-#pragma warning(disable: 4244) // possible loss of data
-#define ATOMIC_EXPORT_API __declspec(dllexport)
-#else
-#define ATOMIC_EXPORT_API
-#endif
-
-using namespace Atomic;
-
-extern "C"
-{
-
-typedef CSComponent* (*CSComponentCreatePtr)(const char* csComponentTypeName);
-CSComponentCreatePtr _CSComponentCreate = 0;
-ATOMIC_EXPORT_API void csb_AtomicEngine_AtomicInterop_Set_CSComponentCreate(CSComponentCreatePtr method)
-{
-    _CSComponentCreate = method;
-}
-
-CSComponent* CSComponentCreate(String name)
-{
-    assert(_CSComponentCreate);
-    return _CSComponentCreate(name.CString());
-}
-
-
-typedef void (*CSComponentCallMethodPtr)(unsigned id, CSComponentMethod method, float value);
-CSComponentCallMethodPtr _CSComponentCallMethod = 0;
-ATOMIC_EXPORT_API void csb_AtomicEngine_AtomicInterop_Set_CSComponentCallMethod(CSComponentCallMethodPtr method)
-{
-    _CSComponentCallMethod = method;
-}
-
-void CSComponentCallMethod(unsigned id, CSComponentMethod methodID, float value)
-{
-    assert(_CSComponentCreate);
-    _CSComponentCallMethod(id, methodID, value);
-}
-
-// Event Handling
-
-typedef void (*CSBeginSendEventPtr)(unsigned senderRefID, unsigned eventType, VariantMap* eventData);
-CSBeginSendEventPtr _CSBeginSendEvent = 0;
-ATOMIC_EXPORT_API void csb_AtomicEngine_AtomicInterop_Set_CSBeginSendEvent(CSBeginSendEventPtr method)
-{
-    _CSBeginSendEvent = method;
-}
-
-void CSBeginSendEvent(unsigned senderRefID, unsigned eventType, VariantMap* eventData)
-{
-    assert(_CSBeginSendEvent);
-    _CSBeginSendEvent(senderRefID, eventType, eventData);
-}
-
-// Instance methods
-
-ATOMIC_EXPORT_API RefCounted* csb_Atomic_CSComponent_Constructor()
-{
-   return new CSComponent(AtomicSharp::GetContext());
-}
-
-ATOMIC_EXPORT_API RefCounted* csb_Atomic_CSScriptObject_Constructor()
-{
-   return new CSScriptObject(AtomicSharp::GetContext());
-}
-
-ATOMIC_EXPORT_API void csb_Atomic_AObject_SendEvent(Object* object, const char* eventType)
-{
-   object->SendEvent(eventType);
-}
-
-
-ATOMIC_EXPORT_API ClassID csb_Atomic_RefCounted_GetClassID(RefCounted* refCounted)
-{
-    if (!refCounted)
-        return 0;
-
-    return refCounted->GetClassID();
-}
-
-ATOMIC_EXPORT_API RefCounted* csb_AtomicEngine_GetSubsystem(const char* name)
-{
-    return AtomicSharp::GetContext()->GetSubsystem(name);
-}
-
-ATOMIC_EXPORT_API void csb_Atomic_RefCounted_SafeAddRef(unsigned id)
-{
-    RefCounted* ref = RefCounted::GetByID(id);
-    if (ref)
-        ref->AddRef();
-
-}
-
-ATOMIC_EXPORT_API void csb_Atomic_RefCounted_SafeReleaseRef(unsigned id)
-{
-    RefCounted* ref = RefCounted::GetByID(id);
-    if (ref)
-        ref->ReleaseRef();
-
-}
-
-ATOMIC_EXPORT_API unsigned csb_Atomic_StringToStringHash(const char* stringValue)
-{
-    StringHash hash = stringValue;
-    return hash.Value();
-}
-
-// Variant Map
-
-ATOMIC_EXPORT_API RefCounted* csb_Atomic_VariantMap_GetInstance(VariantMap& vmap, const char* key)
-{
-    return vmap[key].GetPtr();
-}
-
-
-}

Source/AtomicNET/NETRuntime/CMakeLists.txt

@@ -1,64 +0,0 @@
-
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}
-                    ${CMAKE_SOURCE_DIR}/Source/ThirdParty
-                    ${CMAKE_SOURCE_DIR}/Source/ThirdParty/rapidjson/include
-                    ${CMAKE_SOURCE_DIR}/Source/ThirdParty/kNet/include
-                    ${CMAKE_SOURCE_DIR}/Source/ThirdParty/FreeType/include
-                    ${CMAKE_SOURCE_DIR}/Source/ThirdParty/Box2D)
-
-file (GLOB CSHARP_SOURCES *.cpp *.h)
-
-if (NOT MSVC)
-    # for kNet
-    add_definitions (-DUNIX)
-endif()
-
-# Create the JSBind files ahead of time, so they are picked up with glob
-set (CSFILES CSModuleAtomic2D.cpp;CSModuleAtomic3D.cpp;CSModuleAudio.cpp;CSModuleContainer.cpp;CSModuleCore.cpp;
-             CSModuleEngine.cpp;CSModuleEnvironment.cpp;CSModuleGraphics.cpp;CSModuleInput.cpp;
-             CSModuleIO.cpp;CSModuleJavascript.cpp;CSModuleMath.cpp;CSModuleNavigation.cpp;
-             CSModuleNetwork.cpp;CSModulePhysics.cpp;CSModuleResource.cpp;CSPackageAtomic.cpp;
-             CSModuleScene.cpp;CSModuleUI.cpp)
-
-set (CSATOMICPLAYERFILES CSModulePlayer.cpp)
-
-foreach(CSFILE ${CSFILES})
-
-  set (CSFILEPATH "${CMAKE_SOURCE_DIR}/Build/Source/Generated/${JAVASCRIPT_BINDINGS_PLATFORM}/CSharp/Packages/Atomic/Native/${CSFILE}")
-
-  if (NOT EXISTS ${CSFILEPATH})
-    file(WRITE "${CSFILEPATH}" "// will be created by JSBind")
-  endif()
-
-endforeach()
-
-foreach(CSFILE ${CSATOMICPLAYERFILES})
-
-  set (CSFILEPATH "${CMAKE_SOURCE_DIR}/Build/Source/Generated/${JAVASCRIPT_BINDINGS_PLATFORM}/CSharp/Packages/AtomicPlayer/Native/${CSFILE}")
-
-  if (NOT EXISTS ${CSFILEPATH})
-    file(WRITE "${CSFILEPATH}" "// will be created by JSBind")
-  endif()
-
-endforeach()
-
-
-file (GLOB CSHARP_BINDINGS_SOURCE ${CMAKE_SOURCE_DIR}/Build/Source/Generated/${JAVASCRIPT_BINDINGS_PLATFORM}/CSharp/Packages/Atomic/Native/*.cpp)
-
-file (GLOB CSHARPATOMICPLAYER_BINDINGS_SOURCE ${CMAKE_SOURCE_DIR}/Build/Source/Generated/${JAVASCRIPT_BINDINGS_PLATFORM}/CSharp/Packages/AtomicPlayer/Native/*.cpp)
-
-set (SOURCE_FILES ${CSHARP_SOURCES} ${CSHARP_BINDINGS_SOURCE} ${CSHARPATOMICPLAYER_BINDINGS_SOURCE})
-
-add_library(AtomicNETRuntime SHARED ${SOURCE_FILES})
-
-target_link_libraries(AtomicNETRuntime AtomicJS AtomicPlayerLib AtomicPlayerJS ${ATOMIC_LINK_LIBRARIES})
-
-if (APPLE)
-
-target_link_libraries(AtomicNETRuntime "-framework AudioUnit -framework Carbon -framework Cocoa -framework CoreAudio -framework ForceFeedback -framework IOKit -framework OpenGL -framework CoreServices -framework Security")
-
-endif()
-
-if (NOT IOS AND NOT ANDROID AND NOT EMSCRIPTEN)
-    add_dependencies(AtomicNETRuntime AtomicTool)
-endif()

Source/ToolCore/JSBind/CSharp/CSClassWriter.cpp

@@ -38,7 +38,7 @@ void CSClassWriter::WriteNativeFunctions(String& source)
         if (function->IsDestructor())
             continue;
 
-        if (OmitFunction(function))
+        if (CSTypeHelper::OmitFunction(function))
             continue;
 
         CSFunctionWriter writer(function);
@@ -81,7 +81,7 @@ void CSClassWriter::WriteManagedProperties(String& sourceOut)
             JSBFunctionType* getType = NULL;
             JSBFunctionType* setType = NULL;
 
-            if (OmitFunction(prop->getter_) || OmitFunction(prop->setter_))
+            if (CSTypeHelper::OmitFunction(prop->getter_) || CSTypeHelper::OmitFunction(prop->setter_))
                 continue;
 
             if (prop->getter_ && !prop->getter_->Skip())
@@ -148,30 +148,6 @@ void CSClassWriter::WriteManagedProperties(String& sourceOut)
 
 }
 
-bool CSClassWriter::OmitFunction(JSBFunction* function)
-{
-    if (!function)
-        return false;
-
-    // We need to rename GetType
-    if (function->GetName() == "GetType")
-        return true;
-
-    // avoid vector type for now
-    if (function->GetReturnType() && function->GetReturnType()->type_->asVectorType())
-        return true;
-
-    Vector<JSBFunctionType*>& parameters = function->GetParameters();
-
-    for (unsigned i = 0; i < parameters.Size(); i++)
-    {
-        if (parameters[i]->type_->asVectorType())
-            return true;
-    }
-
-    return false;
-}
-
 void CSClassWriter::GenerateManagedSource(String& sourceOut)
 {
     String source = "";
@@ -217,7 +193,7 @@ void CSClassWriter::GenerateManagedSource(String& sourceOut)
         if (function->IsDestructor())
             continue;
 
-        if (OmitFunction(function))
+        if (CSTypeHelper::OmitFunction(function))
             continue;
 
         CSFunctionWriter fwriter(function);

Source/ToolCore/JSBind/CSharp/CSClassWriter.h

@@ -34,8 +34,6 @@ public:
 
 private:
 
-    bool OmitFunction(JSBFunction* function);
-
     void WriteNativeFunctions(String& source);
 
     void WriteManagedProperties(String& sourceOut);

Source/ToolCore/JSBind/CSharp/CSFunctionWriter.cpp

@@ -59,7 +59,7 @@
 
 RefCounted* csb_Node_Constructor()
 {
-    return new Node(AtomicSharp::GetContext());
+    return new Node(NETCore::GetContext());
 }
 
 void csb_Node_GetPosition(Node* self, Vector3* out)
@@ -91,7 +91,7 @@ const RefCounted* csb_Node_GetParent(Node* self)
 
 RefCounted* csb_ObjectAnimation_Constructor()
 {
-    return new ObjectAnimation(AtomicSharp::GetContext());
+    return new ObjectAnimation(NETCore::GetContext());
 }
 
 */
@@ -154,18 +154,14 @@ void CSFunctionWriter::GenNativeCallParameters(String& sig)
     sig.Join(args, ", ");
 }
 
-void CSFunctionWriter::GenNativeFunctionSignature(String& sig)
+void CSFunctionWriter::GenNativeThunkCallParameters(String& sig)
 {
-    JSBClass* klass = function_->GetClass();
-
     Vector<JSBFunctionType*>& parameters = function_->GetParameters();
 
     Vector<String> args;
 
     if (!function_->IsConstructor())
-    {
-        args.Push(ToString("%s* self", klass->GetNativeName().CString()));
-    }
+        args.Push("self");
 
     if (parameters.Size())
     {
@@ -183,23 +179,21 @@ void CSFunctionWriter::GenNativeFunctionSignature(String& sig)
                     continue;
                 }
 
-                args.Push(ToString("%s* %s", klass->GetNativeName().CString(), ptype->name_.CString()));
+                args.Push(ToString("%s", ptype->name_.CString()));
+
             }
             else
             {
-                args.Push(CSTypeHelper::GetNativeTypeString(ptype) + " " + ptype->name_);
+                args.Push(ToString("%s", ptype->name_.CString()));
             }
 
         }
     }
 
     if (function_->GetReturnClass() && function_->GetReturnClass()->IsNumberArray())
-    {
-        args.Push(ToString("%s* returnValue", function_->GetReturnClass()->GetNativeName().CString()));
-    }
+        args.Push("returnValue");
 
     sig.Join(args, ", ");
-
 }
 
 void CSFunctionWriter::WriteNativeFunction(String& source)
@@ -208,47 +202,49 @@ void CSFunctionWriter::WriteNativeFunction(String& source)
     JSBPackage* package = klass->GetPackage();
     String fname = function_->IsConstructor() ? "Constructor" : function_->GetName();
 
-    String returnType = "void";
+    String returnType;
+    String functionSig = CSTypeHelper::GetNativeFunctionSignature(function_, returnType);
 
-    bool simpleReturn = true;
+    String line;
 
-    if (function_->IsConstructor())
-    {
-        returnType = "RefCounted*";
-    }
-    else if (function_->GetReturnType())
-    {
-        if (function_->IsConstructor())
-        {
-            returnType = ToString("%s*", klass->GetNativeName().CString());
-        }
-        else if (function_->GetReturnClass())
-        {
-            if (!function_->GetReturnClass()->IsNumberArray())
-            {
-                returnType = ToString("const %s*", function_->GetReturnClass()->GetNativeName().CString());
-            }
-        }
-        else if (function_->GetReturnType()->type_->asStringHashType())
-        {
-            returnType = "unsigned";
-        }
-        else
-        {
-            returnType = ToString("%s", CSTypeHelper::GetNativeTypeString(function_->GetReturnType()).CString());
-        }
-    }
+    line = ToString("ATOMIC_EXPORT_API %s %s\n",
+                    returnType.CString(), functionSig.CString());
 
-    String line;
-    String sig;
-    GenNativeFunctionSignature(sig);
+    source += IndentLine(line);
 
-    line = ToString("ATOMIC_EXPORT_API %s csb_%s_%s_%s(%s)\n",
-                    returnType.CString(), package->GetName().CString(), klass->GetName().CString(),
-                    fname.CString(), sig.CString());
+    source += IndentLine("{\n");
+
+    Indent();
+
+
+    source += "\n";
+
+    line = ToString("if ( AtomicNET%sThunkEnabled )\n", package->GetName().CString());
+
+    source += IndentLine(line);
+
+    source += IndentLine("{\n");
+
+    Indent();
+
+    // write the thunk
+
+    line = returnType == "void" ? "" : "return ";
+
+    String thunkCallSig;
+    GenNativeThunkCallParameters(thunkCallSig);
+
+    line += ToString("AtomicNET%sThunk.__%s_%s_%s(%s);\n", package->GetName().CString(), package->GetName().CString(), klass->GetName().CString(),
+                     fname.CString(), thunkCallSig.CString());
 
     source += IndentLine(line);
 
+    Dedent();
+
+    source += IndentLine("}\n");
+
+    source += IndentLine("else\n");
+
     source += IndentLine("{\n");
 
     Indent();
@@ -277,8 +273,7 @@ void CSFunctionWriter::WriteNativeFunction(String& source)
     {
         if (returnType != "void")
         {
-            if (simpleReturn)
-                returnStatement = "return ";
+            returnStatement = "return ";
         }
     }
 
@@ -295,9 +290,9 @@ void CSFunctionWriter::WriteNativeFunction(String& source)
         else if (klass->IsObject())
         {
             if (callSig.Length())
-                line = ToString("return new %s(AtomicSharp::GetContext(), %s);\n", klass->GetNativeName().CString(), callSig.CString());
+                line = ToString("return new %s(NETCore::GetContext(), %s);\n", klass->GetNativeName().CString(), callSig.CString());
             else
-                line = ToString("return new %s(AtomicSharp::GetContext());\n", klass->GetNativeName().CString());
+                line = ToString("return new %s(NETCore::GetContext());\n", klass->GetNativeName().CString());
         }
         else
         {
@@ -321,6 +316,10 @@ void CSFunctionWriter::WriteNativeFunction(String& source)
 
     source += IndentLine("}\n");
 
+    Dedent();
+
+    source += IndentLine("}\n");
+
     source += "\n";
 
 }
@@ -714,7 +713,7 @@ void CSFunctionWriter::GenerateManagedSource(String& sourceOut)
 
     if (function_->GetDocString().Length())
     {
-        // monodocer -assembly:AtomicSharp.dll -path:en -pretty
+        // monodocer -assembly:NETCore.dll -path:en -pretty
         // mdoc export-html -o htmldocs en
         source += IndentLine("/// <summary>\n");
         source += IndentLine("/// " + function_->GetDocString() + "\n");

Source/ToolCore/JSBind/CSharp/CSFunctionWriter.h

@@ -46,7 +46,8 @@ private:
     void WriteDefaultStructParameters(String& source);
 
     void GenNativeCallParameters(String& sig);
-    void GenNativeFunctionSignature(String& sig);
+    void GenNativeThunkCallParameters(String& sig);
+
 
     void WriteNativeFunction(String& source);
     void WriteNativeConstructor(String& source);

Source/ToolCore/JSBind/CSharp/CSModuleWriter.cpp

@@ -15,6 +15,7 @@
 #include "../JSBClass.h"
 #include "../JSBFunction.h"
 
+#include "CSTypeHelper.h"
 #include "CSClassWriter.h"
 #include "CSModuleWriter.h"
 
@@ -76,8 +77,57 @@ void CSModuleWriter::WriteIncludes(String& source)
         included.Push(header);
     }
 
+    source += ToString("\n#include \"CSPackage%s.h\"\n", module_->GetPackage()->GetName().CString());
+
 }
 
+void CSModuleWriter::GenerateNativeThunkInit(String& sourceOut)
+{
+    const char* packageName = module_->GetPackage()->GetName().CString();
+    const char* moduleName = module_->GetName().CString();
+
+    String source, line;
+    String thunkName = ToString("AtomicNET%sThunk",packageName);
+
+    source.AppendWithFormat("\nvoid csb_package_%s_init_%s_thunk ()\n{\n\n", packageName, moduleName);
+
+    Vector<SharedPtr<JSBClass>> classes = module_->classes_.Values();
+
+    Indent();
+
+    for (unsigned i = 0; i < classes.Size(); i++)
+    {
+        JSBClass* cls = classes[i];
+
+        if (cls->IsNumberArray())
+            continue;
+
+        PODVector<JSBFunction*> functions = cls->GetFunctions();
+        for (unsigned j = 0; j < functions.Size(); j++)
+        {
+            JSBFunction* function = functions[j];
+            if (CSTypeHelper::OmitFunction(function))
+                continue;
+
+             line = ToString("%s.__%s_%s_%s = ", thunkName.CString(), packageName, cls->GetName().CString(),
+                             function->IsConstructor() ? "Constructor" : function->GetName().CString());
+
+             line += ToString("csb_%s_%s_%s;\n", packageName, cls->GetName().CString(),
+                             function->IsConstructor() ? "Constructor" : function->GetName().CString());
+
+             source += IndentLine(line);
+
+        }
+
+    }
+
+    Dedent();
+
+    source += "\n}\n";
+
+    sourceOut += source;
+
+}
 
 void CSModuleWriter::GenerateNativeSource()
 {
@@ -102,7 +152,7 @@ void CSModuleWriter::GenerateNativeSource()
 
     WriteIncludes(source);
 
-    source += "\n#include <AtomicNET/NETRuntime/AtomicSharp.h>\n";
+    source += "\n#include <AtomicNET/NETCore/NETCore.h>\n";
 
     String ns = module_->GetPackage()->GetNamespace();
 
@@ -126,6 +176,8 @@ void CSModuleWriter::GenerateNativeSource()
 
     source += "// End Classes\n\n";
 
+    GenerateNativeThunkInit(source);
+
     // end Atomic namespace
     source += "\n}\n";
 

Source/ToolCore/JSBind/CSharp/CSModuleWriter.h

@@ -33,6 +33,8 @@ public:
 
 private:
 
+    void GenerateNativeThunkInit(String& sourceOut);
+
     String GetManagedPrimitiveType(JSBPrimitiveType* ptype);
 
     void GenerateManagedModuleClass(String& sourceOut);

Source/ToolCore/JSBind/CSharp/CSPackageWriter.cpp

@@ -7,13 +7,16 @@
 
 #include <Atomic/IO/File.h>
 #include <Atomic/IO/FileSystem.h>
+#include <Atomic/Core/StringUtils.h>
 
 #include "../JSBind.h"
+#include "../JSBFunction.h"
 #include "../JSBModule.h"
 #include "../JSBPackage.h"
 #include "../JSBEnum.h"
 #include "../JSBClass.h"
 
+#include "CSTypeHelper.h"
 #include "CSModuleWriter.h"
 #include "CSPackageWriter.h"
 
@@ -25,9 +28,290 @@ CSPackageWriter::CSPackageWriter(JSBPackage *package) : JSBPackageWriter(package
 
 }
 
+void CSPackageWriter::GenerateNativeFunctionThunk(String& sourceOut)
+{
+    String source, line;
+
+    source += IndentLine(ToString("\n\ntypedef struct AtomicNET%sThunk_s\n", package_->GetName().CString()));
+
+    source += IndentLine("{\n");
+
+    Indent();
+
+    PODVector<JSBClass*>& allClasses = package_->GetAllClasses();
+    for (unsigned i = 0; i < allClasses.Size(); i++)
+    {
+        JSBClass* cls = allClasses[i];
+
+        PODVector<JSBFunction*>& functions = cls->GetFunctions();
+
+        for (unsigned j = 0; j < functions.Size(); j++)
+        {
+            JSBFunction* function = functions[j];
+
+            if (!CSTypeHelper::OmitFunction(function))
+            {
+                JSBClass* cls = function->GetClass();
+                JSBPackage* package = cls->GetPackage();
+
+                line = ToString("%s_%s_%s_Function ", package->GetName().CString(),
+                                cls->GetName().CString(),
+                                function->IsConstructor() ? "Constructor" : function->GetName().CString());
+
+                line += ToString("__%s_%s_%s;\n", package->GetName().CString(),
+                                cls->GetName().CString(),
+                                function->IsConstructor() ? "Constructor" : function->GetName().CString());
+
+                source += IndentLine(line);
+
+            }
+        }
+    }
+
+    Dedent();
+
+    const char* packageName = package_->GetName().CString();
+
+    source += IndentLine(ToString("\n} AtomicNET%sThunk_t;\n",packageName));
+
+    source += IndentLine(ToString("extern AtomicNET%sThunk_t AtomicNET%sThunk;\n", packageName, packageName));
+
+    source += IndentLine(ToString("extern bool AtomicNET%sThunkEnabled;\n", packageName));
+
+    sourceOut += source;
+}
+
+void CSPackageWriter::GenNativeFunctionSignature(JSBFunction* function, String& sig)
+{
+    JSBClass* klass = function->GetClass();
+
+    Vector<JSBFunctionType*>& parameters = function->GetParameters();
+
+    Vector<String> args;
+
+    if (!function->IsConstructor())
+    {
+        args.Push(ToString("%s* self", klass->GetNativeName().CString()));
+    }
+
+    if (parameters.Size())
+    {
+        for (unsigned int i = 0; i < parameters.Size(); i++)
+        {
+            JSBFunctionType* ptype = parameters.At(i);
+
+            // ignore "Context" parameters
+            if (ptype->type_->asClassType())
+            {
+                JSBClassType* classType = ptype->type_->asClassType();
+                JSBClass* klass = classType->class_;
+                if (klass->GetName() == "Context")
+                {
+                    continue;
+                }
+
+                args.Push(ToString("%s* %s", klass->GetNativeName().CString(), ptype->name_.CString()));
+            }
+            else
+            {
+                args.Push(CSTypeHelper::GetNativeTypeString(ptype) + " " + ptype->name_);
+            }
+
+        }
+    }
+
+    if (function->GetReturnClass() && function->GetReturnClass()->IsNumberArray())
+    {
+        args.Push(ToString("%s* returnValue", function->GetReturnClass()->GetNativeName().CString()));
+    }
+
+    sig.Join(args, ", ");
+
+}
+
+void CSPackageWriter::GenerateNativeFunctionTypeDefs(String& sourceOut)
+{
+    // call typedefs
+
+    Indent();
+
+    String source, line;
+
+    PODVector<JSBClass*>& allClasses = package_->GetAllClasses();
+    for (unsigned i = 0; i < allClasses.Size(); i++)
+    {
+        JSBClass* cls = allClasses[i];
+
+        PODVector<JSBFunction*>& functions = cls->GetFunctions();
+
+        for (unsigned j = 0; j < functions.Size(); j++)
+        {
+            JSBFunction* function = functions[j];
+            String returnType;
+            line = CSTypeHelper::GetNativeFunctionSignature(function, returnType, true);
+            if (line.Length())
+            {
+                line += ";\n";
+                source += IndentLine(line);
+            }
+        }
+
+    }
+
+    Indent();
+
+    sourceOut += source;
+
+}
+
+void CSPackageWriter::GenerateNativeHeader()
+{
+    String source = "// This file was autogenerated by AtomicTool, changes will be lost\n\n";
+
+    source += "#pragma once\n\n";
+
+    if (package_->name_ != "Atomic")
+    {
+        source += "#include \"../../Atomic/Native/CSPackageAtomic.h\"\n";
+        source += "using namespace Atomic;\n";
+    }
+
+    // enum includes
+
+    PODVector<JSBHeader*> enumHeaders;
+    for (unsigned i = 0; i < package_->modules_.Size(); i++)
+    {
+        Vector<SharedPtr<JSBEnum>> enums = package_->modules_[i]->GetEnums();
+        for (unsigned j = 0; j < enums.Size(); j++)
+        {
+            JSBHeader* header = enums[j]->GetHeader();
+            if (!enumHeaders.Contains(header))
+                enumHeaders.Push(header);
+        }
+    }
+
+    for (unsigned i = 0; i < enumHeaders.Size(); i++)
+    {
+        JSBHeader* header = enumHeaders[i];
+
+        String headerPath = GetPath(header->GetFilePath());
+
+        String headerfile = GetFileNameAndExtension(header->GetFilePath());
+
+        JSBind* jsbind = header->GetSubsystem<JSBind>();
+
+        headerPath.Replace(jsbind->GetSourceRootFolder() + "Source/", "");
+
+        source.AppendWithFormat("#include <%s%s>\n", headerPath.CString(), headerfile.CString());
+
+    }
+
+
+    // forward declarations of package classes
+    source += ToString("namespace %s\n{\n\n", package_->GetNamespace().CString());
+
+    Indent();
+
+    PODVector<JSBClass*>& allClasses = package_->GetAllClasses();
+    for (unsigned i = 0; i < allClasses.Size(); i++)
+    {
+        JSBClass* cls = allClasses[i];
+        source += IndentLine(ToString("class %s;\n", cls->GetNativeName().CString()));
+    }
+
+    Dedent();
+
+    GenerateNativeFunctionTypeDefs(source);
+    GenerateNativeFunctionThunk(source);
+
+    source += "\n}\n";
+
+    JSBind* jsbind = package_->GetSubsystem<JSBind>();
+
+    String filepath = jsbind->GetDestNativeFolder() + "/CSPackage" + package_->name_ + ".h";
+
+    File file(package_->GetContext());
+    file.Open(filepath, FILE_WRITE);
+    file.Write(source.CString(), source.Length());
+    file.Close();
+
+}
+
+
+void CSPackageWriter::GenerateNativeThunkInit(String& sourceOut)
+{
+    const char* packageName = package_->GetName().CString();
+
+    String source, line;
+
+    for (unsigned i = 0; i < package_->modules_.Size(); i++)
+    {
+        JSBModule* module = package_->modules_[i];
+        const char* moduleName = module->GetName().CString();
+        source.AppendWithFormat("extern \"C\" void csb_package_%s_init_%s_thunk ();\n", packageName, moduleName);
+    }
+
+    source.AppendWithFormat("\nvoid csb_package_init_%s_thunk ()\n{\n\n", packageName);
+
+    Indent();
+
+    for (unsigned i = 0; i < package_->modules_.Size(); i++)
+    {
+        JSBModule* module = package_->modules_[i];
+        const char* moduleName = module->GetName().CString();
+        line = ToString("csb_package_%s_init_%s_thunk ();\n", packageName, moduleName);
+        source += IndentLine(line);
+    }
+
+    Dedent();
+
+    source.Append("\n}\n");
+
+    // Thunk Setter
+
+    String thunkType = ToString("AtomicNET%sThunk_t", packageName);
+    source += ToString("extern \"C\" void csb_package_set_%s_thunk (const %s *thunkIn)\n{\n", packageName, thunkType.CString());
+
+    Indent();
+
+    source += IndentLine(ToString("AtomicNET%sThunk = *thunkIn;\n", packageName));
+    source += IndentLine(ToString("AtomicNET%sThunkEnabled = true;\n", packageName));
+
+    Dedent();
+
+    source += ToString("\n}\n");
+
+    sourceOut += source;
+
+}
 void CSPackageWriter::GenerateNativeSource()
 {
-    String source = "// This file was autogenerated by JSBind, changes will be lost\n\n";
+    GenerateNativeHeader();
+
+    String source = "// This file was autogenerated by AtomicTool, changes will be lost\n\n";
+
+    const char* packageName = package_->name_.CString();
+
+    String packageHeader = "CSPackage" + package_->name_ + ".h";
+
+    source += ToString("#include \"%s\"\n", packageHeader.CString());
+
+    if (package_->name_ != "Atomic")
+        source += "using namespace Atomic;\n";
+
+    // begin namespace
+    source += ToString("using namespace %s;\n", packageName);
+
+    source += ToString("namespace %s\n{\n", packageName);
+
+    // thunk
+    source += ToString("AtomicNET%sThunk_t AtomicNET%sThunk;\n", packageName, packageName);
+    source += ToString("bool AtomicNET%sThunkEnabled = false;\n", packageName);
+
+    // end of namespace
+    source += "\n}\n";
+
+    GenerateNativeThunkInit(source);
 
     JSBind* jsbind = package_->GetSubsystem<JSBind>();
 

Source/ToolCore/JSBind/CSharp/CSPackageWriter.h

@@ -18,6 +18,7 @@ namespace ToolCore
 
 class JSBPackage;
 class JSBClass;
+class JSBFunction;
 
 class CSPackageWriter : public JSBPackageWriter
 {
@@ -28,6 +29,12 @@ public:
 
     void GenerateSource();
 
+    void GenNativeFunctionSignature(JSBFunction* function, String& sig);
+    void GenerateNativeFunctionTypeDefs(String& sourceOut);
+    void GenerateNativeFunctionThunk(String& sourceOut);
+
+    void GenerateNativeThunkInit(String& sourceOut);
+    void GenerateNativeHeader();
     void GenerateNativeSource();
     void GenerateManagedSource();
 

Source/ToolCore/JSBind/CSharp/CSTypeHelper.cpp

@@ -1,10 +1,125 @@
 
 
+#include "../JSBPackage.h"
 #include "CSTypeHelper.h"
 
 namespace ToolCore
 {
 
+void CSTypeHelper::GenNativeFunctionParameterSignature(JSBFunction* function, String& sig)
+{
+    JSBClass* klass = function->GetClass();
+
+    Vector<JSBFunctionType*>& parameters = function->GetParameters();
+
+    Vector<String> args;
+
+    if (!function->IsConstructor())
+    {
+        args.Push(ToString("%s* self", klass->GetNativeName().CString()));
+    }
+
+    if (parameters.Size())
+    {
+        for (unsigned int i = 0; i < parameters.Size(); i++)
+        {
+            JSBFunctionType* ptype = parameters.At(i);
+
+            // ignore "Context" parameters
+            if (ptype->type_->asClassType())
+            {
+                JSBClassType* classType = ptype->type_->asClassType();
+                JSBClass* klass = classType->class_;
+                if (klass->GetName() == "Context")
+                {
+                    continue;
+                }
+
+                args.Push(ToString("%s* %s", klass->GetNativeName().CString(), ptype->name_.CString()));
+            }
+            else
+            {
+                args.Push(CSTypeHelper::GetNativeTypeString(ptype) + " " + ptype->name_);
+            }
+
+        }
+    }
+
+    if (function->GetReturnClass() && function->GetReturnClass()->IsNumberArray())
+    {
+        args.Push(ToString("%s* returnValue", function->GetReturnClass()->GetNativeName().CString()));
+    }
+
+    sig.Join(args, ", ");
+
+}
+
+String CSTypeHelper::GetNativeFunctionSignature(JSBFunction* function, String& returnType, bool thunk)
+{
+
+    if (function->Skip())
+        return String::EMPTY;
+
+    if (function->IsDestructor())
+        return String::EMPTY;
+
+    if (OmitFunction(function))
+        return String::EMPTY;
+
+    JSBClass* klass = function->GetClass();
+    JSBPackage* package = klass->GetPackage();
+    String fname = function->IsConstructor() ? "Constructor" : function->GetName();
+
+    returnType = "void";
+
+    if (function->IsConstructor())
+    {
+        returnType = "RefCounted*";
+    }
+    else if (function->GetReturnType())
+    {
+        if (function->IsConstructor())
+        {
+            returnType = ToString("%s*", klass->GetNativeName().CString());
+        }
+        else if (function->GetReturnClass())
+        {
+            if (!function->GetReturnClass()->IsNumberArray())
+            {
+                returnType = ToString("const %s*", function->GetReturnClass()->GetNativeName().CString());
+            }
+        }
+        else if (function->GetReturnType()->type_->asStringHashType())
+        {
+            returnType = "unsigned";
+        }
+        else
+        {
+            returnType = ToString("%s", CSTypeHelper::GetNativeTypeString(function->GetReturnType()).CString());
+        }
+    }
+
+
+    String sig;
+    GenNativeFunctionParameterSignature(function, sig);
+
+    String functionSig;
+    if (!thunk)
+    {
+        functionSig = ToString("csb_%s_%s_%s(%s)",
+                    package->GetName().CString(), klass->GetName().CString(),
+                    fname.CString(), sig.CString());
+    }
+    else
+    {
+        functionSig = ToString("typedef %s (*%s_%s_%s_Function)(%s)",
+                    returnType.CString(), package->GetName().CString(), klass->GetName().CString(),
+                    fname.CString(), sig.CString());
+    }
+
+    return functionSig;
+}
+
 String CSTypeHelper::GetManagedPrimitiveType(JSBPrimitiveType* ptype)
 {
     if (ptype->kind_ == JSBPrimitiveType::Bool)
@@ -223,4 +338,35 @@ bool CSTypeHelper::IsSimpleReturn(JSBFunctionType* ftype)
 
 }
 
+bool CSTypeHelper::OmitFunction(JSBFunction* function)
+{
+    if (!function)
+        return false;
+
+    if (function->Skip())
+        return true;
+
+    if (function->IsDestructor())
+        return true;
+
+    // We need to rename GetType
+    if (function->GetName() == "GetType")
+        return true;
+
+    // avoid vector type for now
+    if (function->GetReturnType() && function->GetReturnType()->type_->asVectorType())
+        return true;
+
+    Vector<JSBFunctionType*>& parameters = function->GetParameters();
+
+    for (unsigned i = 0; i < parameters.Size(); i++)
+    {
+        if (parameters[i]->type_->asVectorType())
+            return true;
+    }
+
+    return false;
+}
+
+
 }

Source/ToolCore/JSBind/CSharp/CSTypeHelper.h

@@ -22,6 +22,10 @@ public:
 
     //JSBFunctionType*
 
+    static void GenNativeFunctionParameterSignature(JSBFunction* function, String& sig);
+
+    static String GetNativeFunctionSignature(JSBFunction* function, String& returnType, bool thunk = false);
+
     static bool IsSimpleReturn(JSBType* type);
     static bool IsSimpleReturn(JSBFunctionType* ftype);
 
@@ -36,6 +40,8 @@ public:
     static String GetManagedTypeString(JSBType* type);
     static String GetManagedTypeString(JSBFunctionType* ftype, bool addName = true);
 
+    static bool OmitFunction(JSBFunction* function);
+
 };
 
 /*

Source/ToolCore/JSBind/JSBModule.cpp

@@ -28,7 +28,8 @@ namespace ToolCore
 {
 
 JSBModule::JSBModule(Context* context, JSBPackage* package) : Object(context),
-    package_(package)
+    package_(package),
+    dotNetModule_(false)
 {
 
 }

Source/ToolCore/JSBind/JSBModule.h

@@ -70,6 +70,9 @@ public:
     void ProcessClasses();
     void PostProcessClasses();
 
+    void SetDotNetModule(bool value) { dotNetModule_ = value; }
+    bool GetDotNetModule() { return dotNetModule_; }
+
 private:
 
     void ProcessOverloads();
@@ -100,6 +103,8 @@ private:
 
     SharedPtr<JSONFile> moduleJSON_;
 
+    bool dotNetModule_;
+
 };
 
 

Source/ToolCore/JSBind/JSBPackage.cpp

@@ -215,6 +215,18 @@ bool JSBPackage::Load(const String& packageFolder)
 
     }
 
+    JSONValue dnmodules = root.Get("dotnetModules");
+    Vector<String> dotNetModules;
+    if (dnmodules.IsArray())
+    {
+        for (unsigned i = 0; i < dnmodules.GetArray().Size(); i++)
+        {
+            String moduleName = dnmodules.GetArray()[i].GetString();
+            dotNetModules.Push(moduleName);
+        }
+    }
+
+
     name_ = root.Get("name").GetString();
     namespace_ = root.Get("namespace").GetString();
 
@@ -238,6 +250,11 @@ bool JSBPackage::Load(const String& packageFolder)
             return false;
         }
 
+        if (dotNetModules.Contains(moduleName))
+        {
+            module->SetDotNetModule(true);
+        }
+
         modules_.Push(module);
 
     }

Source/ToolCore/JSBind/JSBPackageWriter.h

@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include <Atomic/Container/Str.h>
+#include "JSBSourceWriter.h"
 
 using namespace Atomic;
 
@@ -17,7 +17,7 @@ namespace ToolCore
 class JSBPackage;
 class JSBClass;
 
-class JSBPackageWriter
+class JSBPackageWriter : public JSBSourceWriter
 {
 
 public:

Source/ToolCore/JSBind/JavaScript/JSPackageWriter.cpp

@@ -34,6 +34,9 @@ void JSPackageWriter::WriteProtoTypeRecursive(String &source, JSBClass* klass,
     if (written.Contains(klass))
         return;
 
+    if (klass->GetModule()->GetDotNetModule())
+        return;
+
     PODVector<JSBClass*>& baseClasses = klass->GetBaseClasses();
 
     Vector<JSBClass*>::Iterator itr = baseClasses.End() - 1 ;
@@ -96,6 +99,9 @@ void JSPackageWriter::GenerateSource()
     {
         JSBModule* module = package_->modules_.At(i);
 
+        if (module->GetDotNetModule())
+            continue;
+
         String moduleLower = module->GetName().ToLower();
 
         source.AppendWithFormat("\nextern void jsb_package_%s_preinit_%s (JSVM* vm);", packageLower.CString(), moduleLower.CString());
@@ -123,6 +129,9 @@ void JSPackageWriter::GenerateSource()
     {
         JSBModule* module = package_->modules_.At(i);
 
+        if (module->GetDotNetModule())
+            continue;
+
         if (module->Requires("3D"))
             source += "\n#ifdef ATOMIC_3D";
 
@@ -146,6 +155,9 @@ void JSPackageWriter::GenerateSource()
     {
         JSBModule* module = package_->modules_.At(i);
 
+        if (module->GetDotNetModule())
+            continue;
+
         String moduleLower = module->GetName().ToLower();
 
         if (module->Requires("3D"))
@@ -171,6 +183,9 @@ void JSPackageWriter::GenerateSource()
 
     for (unsigned i = 0; i < package_->modules_.Size(); i++)
     {
+        if (package_->modules_[i]->GetDotNetModule())
+            continue;
+
         JSModuleWriter writer(package_->modules_[i]);
         writer.GenerateSource();
     }