Merge pull request #1275 from AtomicGameEngine/JME-ATOMIC-995

[C#] Misc Issues, see notes

Script/AtomicNET/AtomicNET/Core/NativeCore.cs

@@ -428,37 +428,6 @@ namespace AtomicEngine
             return ancestorType;
         }
 
-        static public IntPtr NativeContructorOverride
-        {
-            get
-            {
-                IntPtr value = nativeContructorOverride;
-                nativeContructorOverride = IntPtr.Zero;
-                return value;
-            }
-
-            set
-            {
-                if (nativeContructorOverride != IntPtr.Zero)
-                {
-                    throw new InvalidOperationException("NativeCore.NativeContructorOverride - Previous nativeContructorOverride not consumed");
-                }
-
-                nativeContructorOverride = value;
-            }
-        }
-
-        static public void VerifyNativeContructorOverrideConsumed()
-        {
-            if (nativeContructorOverride != IntPtr.Zero)
-            {
-                throw new InvalidOperationException("NativeCore.VerifyNativeContructorOverrideConsumed -  NativeContructorOverride not consumed");
-            }
-        }
-
-
-        private static IntPtr nativeContructorOverride = IntPtr.Zero;
-
         // weak references here, hold a ref native side
         internal static Dictionary<IntPtr, WeakReference<RefCounted>> nativeLookup = new Dictionary<IntPtr, WeakReference<RefCounted>>();
 

Script/AtomicNET/AtomicNET/Graphics/Material.cs

@@ -0,0 +1,25 @@
+
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace AtomicEngine
+{
+    public partial class Material : Resource
+    {
+
+        public void SetShaderParameter(string name, ScriptVariant variant)
+        {
+            csi_Atomic_Material_SetShaderParameter(nativeInstance, name, variant.nativeInstance);
+        }
+      
+        [DllImport(Constants.LIBNAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+        private static extern void csi_Atomic_Material_SetShaderParameter(IntPtr self, string name, IntPtr variant);
+
+    };
+
+}
+
+
+
+

Script/AtomicNET/AtomicNET/Scene/CSComponent.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Runtime.InteropServices;
+
 namespace AtomicEngine
 {
 
@@ -17,6 +19,68 @@ namespace AtomicEngine
 
         internal bool started = false;
 
+        // CSComponents can be instantiated from a serialized scene or from within managed code
+        protected CSComponent()
+        {
+            if (nativeLoadOverrideValidate != IntPtr.Zero)
+            {
+                // When loading CSComponents from a scene, many issues circumvented by not allowing additional components
+                // to be created (on the Node) during serialization, so this is an error state
+                throw new InvalidOperationException($"CSComponent() - Recursive CSComponent instantiation in default constructor during load type: { GetType().Name} ");
+            }
+
+            if (nativeLoadOverride == IntPtr.Zero)
+            {
+                // We are being "new'd" in script
+                nativeInstance = csi_Atomic_CSComponent_Constructor();                
+            }
+            else
+            {
+                // We are loading from a serialized CSComponent
+                nativeInstance = nativeLoadOverride;
+
+                // validation bookkeeping
+                nativeLoadOverrideValidate = nativeLoadOverride;
+                nativeLoadOverride = IntPtr.Zero;
+            }
+
+            NativeCore.RegisterNative(nativeInstance, this);
+
+
+        }
+
+        // Create an instance of a CSComponent derived class, given an existing native CSComponent
+        // This happens when loading components from serializes scene/prefab assets
+        internal static CSComponent LoadCreateInstance(Type type, IntPtr nativeCSComponent)
+        {
+            // initialize instantiation validation
+            nativeLoadOverride = nativeCSComponent;
+            nativeLoadOverrideValidate = IntPtr.Zero;
+
+            var component = (CSComponent)Activator.CreateInstance(type);
+
+            if (component == null)
+            {
+                throw new InvalidOperationException("CSComponent.CreateInstance - Unable to instantiate instance of type: " + type.Name);
+            }
+
+            // clear validation
+            nativeLoadOverride = nativeLoadOverrideValidate = IntPtr.Zero;
+
+            return component;
+        }
+
+        // When instantiating from a serialized scene, the native CSComponent instance will already exist
+        // nativeLoadOverride stores the overriden native instance to use in the default CSComponent constructor
+        internal static IntPtr nativeLoadOverride = IntPtr.Zero;
+        // Check for whether additional CSComponents were created in default constructor during serialization, this is an error condition and will throw an exception
+        internal static IntPtr nativeLoadOverrideValidate = IntPtr.Zero;
+
+        // native constructor for CSComponent
+        [DllImport(Constants.LIBNAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+        private static extern IntPtr csi_Atomic_CSComponent_Constructor();
+
+
     }
 
 }

Script/AtomicNET/AtomicNET/Scene/Scene.cs

@@ -246,12 +246,17 @@ namespace AtomicEngine
 
             if (!CSComponentCore.componentCache.TryGetValue(e.ClassName, out csinfo))
             {
+                Log.Error("Scene.HandleCSComponentLoad - unable to find CSComponent in cache for classname: " + e.ClassName );
                 return;
             }
 
-            NativeCore.NativeContructorOverride = csnative;
-            var component = (CSComponent)Activator.CreateInstance(csinfo.Type);
-            NativeCore.VerifyNativeContructorOverrideConsumed();
+            var component = CSComponent.LoadCreateInstance(csinfo.Type, csnative);
+
+            if (component == null)
+            {
+                Log.Error("Scene.HandleCSComponentLoad - unable to create CSComponent for classname: " + e.ClassName);
+                return;
+            }
 
             if (fieldValues != IntPtr.Zero)
                 csinfo.ApplyFieldValues(component, fieldValues);

Script/AtomicNET/AtomicNET/Script/ScriptVariant.cs

@@ -17,7 +17,17 @@ namespace AtomicEngine
             SetVector3(value);
         }
 
-        public ScriptVariant(Color value) : this()
+		public ScriptVariant(Vector4 value) : this()
+		{
+			SetVector4(value);
+		}
+
+		public ScriptVariant(String value) : this()
+		{
+			SetString(value);
+		}
+
+		public ScriptVariant(Color value) : this()
         {
             SetColor(value);
         }

Script/AtomicNET/AtomicNETProject.json

@@ -6,6 +6,7 @@
     "projects" : [
         {
             "name": "AtomicNET.Shared",
+            "atomicNET" : true,
             "outputType" : "Shared",
             "projectGuid" : "C74A8ECC-7517-11E6-A1D7-005056C00008",
             "sources" : [
@@ -20,6 +21,7 @@
         },
         {
             "name": "AtomicNET",
+            "atomicNET" : true,
             "outputType" : "Library",
             "rootNamespace" : "AtomicEngine",
             "assemblyName" : "AtomicNET",
@@ -38,6 +40,7 @@
         },
         {
             "name": "AtomicNET.Desktop",
+            "atomicNET" : true,
             "assemblyDocFile" : true,
             "platforms" : ["desktop"],
             "outputType" : "Library",
@@ -60,6 +63,7 @@
         },
         {
             "name": "AtomicNET.Android.SDL",
+            "atomicNET" : true,
             "platforms" : ["android"],
             "outputType" : "Library",
             "rootNamespace" : "AtomicGameEngine",
@@ -80,6 +84,7 @@
         },
         {
             "name": "AtomicNET.Android",
+            "atomicNET" : true,
             "platforms" : ["android"],
             "outputType" : "Library",
             "defineConstants" : ["ATOMIC_ANDROID"],
@@ -104,6 +109,7 @@
         },
         {
             "name": "AtomicNET.iOS",
+            "atomicNET" : true,
             "platforms" : ["ios"],
             "outputType" : "Library",
             "projectTypeGuids" :[ "8FFB629D-F513-41CE-95D2-7ECE97B6EEEC", "FAE04EC0-301F-11D3-BF4B-00C04F79EFBC" ],
@@ -130,6 +136,7 @@
         },
         {
             "name": "AtomicNETService",
+            "atomicNET" : true,
             "platforms" : ["desktop"],
             "outputType" : "Exe",
             "rootNamespace" : "AtomicTools",

Script/Packages/AtomicNETScript/AtomicNETScript.json

@@ -1,5 +1,12 @@
 {
 	"name" : "AtomicNETScript",
 	"sources" : ["Source/AtomicNET/NETScript"],
-	"classes" : ["NETScriptObject", "CSComponent", "CSComponentAssembly"]
+	"classes" : ["NETScriptObject", "CSComponent", "CSComponentAssembly"],
+	"excludes" : {
+		"CSharp" : {
+			"CSComponent" : {
+				"CSComponent" : ["Context"]
+			}
+		}
+	}
 }

Source/Atomic/Script/ScriptVariant.h

@@ -59,14 +59,22 @@ namespace Atomic
 
         void SetVector3(const Vector3& value) { variant_ = value; }
 
+        Vector4 GetVector4() { return variant_.GetVector4(); }
+
+        void SetVector4(const Vector4& value) { variant_ = value; }
+
         Color GetColor() { return variant_.GetColor(); }
 
         void SetColor(const Color& value) { variant_ = value; }
 
+        String GetString() { return variant_.GetString(); }
+
+        void SetString(const String& value) { variant_ = value; }
+
     private:
 
         Variant variant_;
 
     };
 
-}
+}

Source/AtomicNET/NETNative/NETCInterop.cpp

@@ -11,6 +11,7 @@
 #include <Atomic/Graphics/Light.h>
 #include <Atomic/Graphics/Octree.h>
 #include <Atomic/Graphics/AnimatedModel.h>
+#include <Atomic/Graphics/Material.h>
 
 #include <Atomic/Navigation/NavigationMesh.h>
 #include <Atomic/Navigation/CrowdManager.h>
@@ -19,6 +20,8 @@
 
 #include <Atomic/Scene/ValueAnimation.h>
 
+#include <AtomicNET/NETScript/CSComponent.h>
+
 #include <Atomic/Input/Controls.h>
 
 
@@ -592,6 +595,26 @@ namespace Atomic
             return self->Write(bytes, size);
         }
 
+        // Material
+
+        ATOMIC_EXPORT_API void csi_Atomic_Material_SetShaderParameter(Material* self, const char* name, ScriptVariant* variant)
+        {
+
+            if (!self || !variant || !name || !strlen(name))
+                return;
+
+            self->SetShaderParameter(name, variant->GetVariant());
+        }
+
+        // CSComponent
+
+        ATOMIC_EXPORT_API CSComponent* csi_Atomic_CSComponent_Constructor()
+        {
+
+            return new CSComponent(NETCore::GetContext());
+        }
+
+
 
 #ifdef ATOMIC_PLATFORM_IOS
         ATOMIC_EXPORT_API void SDL_IOS_Init(const char *resourceDir, const char *documentsDir)

Source/ToolCore/JSBind/CSharp/CSFunctionWriter.cpp

@@ -591,9 +591,7 @@ void CSFunctionWriter::WriteManagedConstructor(String& source)
     String callSig;
     GenPInvokeCallParameters(callSig);
 
-    source += IndentLine("IntPtr nativeInstanceOverride = NativeCore.NativeContructorOverride;\n");
-
-    line = ToString("nativeInstance = NativeCore.RegisterNative (nativeInstanceOverride != IntPtr.Zero ? nativeInstanceOverride : csb_%s_%s_Constructor_%u(%s), this);\n",
+    line = ToString("nativeInstance = NativeCore.RegisterNative (csb_%s_%s_Constructor_%u(%s), this);\n",
                      package->GetName().CString(), klass->GetName().CString(), function_->GetID(), callSig.CString());
 
     source += IndentLine(line);

Source/ToolCore/NETTools/NETProjectGen.cpp

@@ -50,7 +50,7 @@ namespace ToolCore
 
     }
 
-    void NETProjectBase::ReplacePathStrings(String& path)
+    void NETProjectBase::ReplacePathStrings(String& path) const
     {
         ToolEnvironment* tenv = GetSubsystem<ToolEnvironment>();
 
@@ -74,6 +74,7 @@ namespace ToolCore
     }
 
     NETCSProject::NETCSProject(Context* context, NETProjectGen* projectGen) : NETProjectBase(context, projectGen),
+        atomicNETProject_(false),
         genAssemblyDocFile_(false),
         playerApplication_(false),
         androidApplication_(false)
@@ -177,6 +178,24 @@ namespace ToolCore
 
                 compile.CreateChild("Link").SetValue(link);
 
+                // For shared projects, ensure that the folder for the link exists, otherwise VS complains 
+                // with little red x's and Resharper (potentially other tools) have issues
+                if (outputType_ == "Shared")
+                {
+                    String pathName, fileName, extension;
+
+                    SplitPath(link, pathName, fileName, extension);
+
+                    if (extension == ".cs")
+                    {                        
+                        if (!fs->Exists(projectPath_ + pathName))
+                        {
+                            fs->CreateDirs(projectPath_, pathName);
+                        }
+                    }
+
+                }
+
             }
 
         }
@@ -395,19 +414,10 @@ namespace ToolCore
             constants.Push("ATOMIC_MOBILE");
     }
 
-    void NETCSProject::CreateReleasePropertyGroup(XMLElement &projectRoot)
+    String NETCSProject::GetRelativeOutputPath(const String& config) const
     {
-        XMLElement pgroup = projectRoot.CreateChild("PropertyGroup");
-
-        if (playerApplication_ && SupportsPlatform("ios"))
-            pgroup.SetAttribute("Condition", " '$(Configuration)|$(Platform)' == 'Release|iPhone' ");
-        else
-            pgroup.SetAttribute("Condition", " '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ");
-
-        pgroup.CreateChild("Optimize").SetValue("true");
-
         String outputPath = assemblyOutputPath_;
-        outputPath.Replace("$ATOMIC_CONFIG$", "Release");
+        outputPath.Replace("$ATOMIC_CONFIG$", config);
 
         if (IsAbsolutePath(outputPath))
         {
@@ -423,6 +433,34 @@ namespace ToolCore
             }
         }
 
+        return outputPath;
+
+    }
+
+    void NETCSProject::CreateReleasePropertyGroup(XMLElement &projectRoot)
+    {
+        XMLElement pgroup = projectRoot.CreateChild("PropertyGroup");
+
+        if (playerApplication_ && SupportsPlatform("ios"))
+            pgroup.SetAttribute("Condition", " '$(Configuration)|$(Platform)' == 'Release|iPhone' ");
+        else
+            pgroup.SetAttribute("Condition", " '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ");
+
+        pgroup.CreateChild("Optimize").SetValue("true");
+
+        String config = "Release";
+
+#ifdef ATOMIC_DEV_BUILD
+
+        // If we're a core AtomicNET assembly and a project is included in solution
+        // output to Lib so that development changes will be picked up by project reference
+        if (atomicNETProject_ && projectGen_->GetAtomicProjectPath().Length())
+            config = "Lib";
+
+#endif
+
+        String outputPath = GetRelativeOutputPath(config);
+
         pgroup.CreateChild("OutputPath").SetValue(outputPath);
 
         Vector<String> constants;
@@ -510,25 +548,20 @@ namespace ToolCore
         else
             pgroup.SetAttribute("Condition", " '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ");
 
-
         pgroup.CreateChild("Optimize").SetValue("false");
 
-        String outputPath = assemblyOutputPath_;
-        outputPath.Replace("$ATOMIC_CONFIG$", "Debug");
+        String config = "Debug";
 
-        if (IsAbsolutePath(outputPath))
-        {
-            String atomicProjectPath = projectGen_->GetAtomicProjectPath();
+#ifdef ATOMIC_DEV_BUILD
 
-            if (atomicProjectPath.Length())
-            {
-                if (!GetRelativeProjectPath(outputPath, projectPath_, outputPath))
-                {
-                    ATOMIC_LOGERRORF("NETCSProject::CreateDebugPropertyGroup - unable to get relative output path");
-                }
-            }
+        // If we're a core AtomicNET assembly and a project is included in solution
+        // output to Lib so that development changes will be picked up by project reference
+        if (atomicNETProject_ && projectGen_->GetAtomicProjectPath().Length())
+            config = "Lib";
 
-        }
+#endif
+
+        String outputPath = GetRelativeOutputPath(config);
 
         pgroup.CreateChild("OutputPath").SetValue(outputPath);
 
@@ -849,7 +882,7 @@ namespace ToolCore
 
     }
 
-    bool NETCSProject::GetRelativeProjectPath(const String& fromPath, const String& toPath, String& output)
+    bool NETCSProject::GetRelativeProjectPath(const String& fromPath, const String& toPath, String& output) const
     {
         String path = fromPath;
         ReplacePathStrings(path);
@@ -1240,10 +1273,15 @@ namespace ToolCore
         if (projectGen_->GetProjectSettings())
             projectName = projectGen_->GetProjectSettings()->GetName();
 
+        XMLElement afterBuild;
+
         if (name_ == projectName)
         {
-            XMLElement afterBuild = project.CreateChild("Target");
-            afterBuild.SetAttribute("Name", "AfterBuild");
+            if (afterBuild.IsNull())
+            {
+                afterBuild = project.CreateChild("Target");
+                afterBuild.SetAttribute("Name", "AfterBuild");
+            }
 
             XMLElement copy = afterBuild.CreateChild("Copy");
             copy.SetAttribute("SourceFiles", "$(TargetPath)");
@@ -1262,6 +1300,38 @@ namespace ToolCore
 
         }
 
+#ifdef ATOMIC_DEV_BUILD
+#ifndef ATOMIC_PLATFORM_WINDOWS
+
+        // On xbuild, mdb files for references aren't being copied to output folders for desktop
+        if (platforms_.Size() == 1 && SupportsDesktop() && outputType_.ToLower() == "exe")
+        {
+            if (afterBuild.IsNull())
+            {
+                afterBuild = project.CreateChild("Target");
+                afterBuild.SetAttribute("Name", "AfterBuild");
+            }
+
+            // mdb file item group
+            XMLElement mdbItemGroup = project.CreateChild("ItemGroup");
+            mdbItemGroup.CreateChild("AtomicNETMDBFiles").SetAttribute("Include", "..\\..\\Lib\\Desktop\\**\\*.mdb");
+
+            // Debug
+            XMLElement copyOp = afterBuild.CreateChild("Copy");
+            copyOp.SetAttribute("Condition", "'$(Configuration)' == 'Debug'");
+            copyOp.SetAttribute("SourceFiles", "@(AtomicNETMDBFiles)");
+            copyOp.SetAttribute("DestinationFiles", "@(AtomicNETMDBFiles->'..\\..\\Debug\\Bin\\Desktop\\%(Filename)%(Extension)')");
+
+            // Release
+            copyOp = afterBuild.CreateChild("Copy");
+            copyOp.SetAttribute("Condition", "'$(Configuration)' == 'Release'");
+            copyOp.SetAttribute("SourceFiles", "@(AtomicNETMDBFiles)");
+            copyOp.SetAttribute("DestinationFiles", "@(AtomicNETMDBFiles->'..\\..\\Release\\Bin\\Desktop\\%(Filename)%(Extension)')");
+        }
+
+#endif
+#endif
+
 
         String projectSource = xmlFile_->ToString();
 
@@ -1307,6 +1377,8 @@ namespace ToolCore
 
         outputType_ = root["outputType"].GetString();
 
+        atomicNETProject_ = root["atomicNET"].GetBool();
+
         androidApplication_ = root["androidApplication"].GetBool();
         playerApplication_ = root["playerApplication"].GetBool();
         genAssemblyDocFile_ = root["assemblyDocFile"].GetBool();

Source/ToolCore/NETTools/NETProjectGen.h

@@ -44,7 +44,7 @@ namespace ToolCore
         NETProjectBase(Context* context, NETProjectGen* projectGen);
         virtual ~NETProjectBase();
 
-        void ReplacePathStrings(String& path);
+        void ReplacePathStrings(String& path) const;
 
         void CopyXMLElementRecursive(XMLElement source, XMLElement dest);
 
@@ -80,16 +80,22 @@ namespace ToolCore
         bool SupportsDesktop() const;
         bool SupportsPlatform(const String& platform, bool explicitCheck = true) const;
 
+        /// Returns true if this project is part of core AtomicNET
+        bool GetAtomicNETProject() const { return atomicNETProject_;  }
+
         bool Generate();
 
     private:
 
+        /// Returns true if this project is part of core AtomicNET
+        void SetAtomicNETProject(bool value) { atomicNETProject_ = value; }
+
         // Portable Class Library
         bool GenerateShared();
 
         bool GenerateStandard();
 
-        bool GetRelativeProjectPath(const String& fromPath, const String& toPath, String& output);
+        bool GetRelativeProjectPath(const String& fromPath, const String& toPath, String& output) const;
 
         bool CreateProjectFolder(const String& path);
 
@@ -109,6 +115,8 @@ namespace ToolCore
 
         void ProcessDefineConstants(StringVector& constants);
 
+        /// Return a relative path to the output folder, config can be Release/Debug/Lib
+        String GetRelativeOutputPath(const String& config) const;
 
         String name_;
         String projectGuid_;
@@ -117,6 +125,7 @@ namespace ToolCore
         String assemblyName_;
         String assemblyOutputPath_;
         String assemblySearchPaths_;
+        bool atomicNETProject_;
 
         // project paths
         String projectPath_;