NETProjectSystem building project solution and project assembly automatically if they don't exist

Source/ToolCore/Assets/CSharpImporter.cpp

@@ -26,7 +26,6 @@
 
 #include "../ToolSystem.h"
 #include "../Project/Project.h"
-#include "../NETTools/NETBuildSystem.h"
 
 #include "Asset.h"
 #include "AssetDatabase.h"
@@ -53,14 +52,6 @@ namespace ToolCore
 
     bool CSharpImporter::Import()
     {
-        using namespace NETBuildAtomicProject;
-
-        VariantMap eventData;
-        eventData[P_PROJECT] = GetSubsystem<ToolSystem>()->GetProject();
-
-        // We need to rebuild the project assembly
-        SendEvent(E_NETBUILDATOMICPROJECT, eventData);
-
         return true;
     }
 

Source/ToolCore/NETTools/NETBuildSystem.cpp

@@ -33,6 +33,7 @@
 #include "../Subprocess/SubprocessSystem.h"
 #include "../Project/Project.h"
 
+#include "NETProjectSystem.h"
 #include "NETProjectGen.h"
 #include "NETBuildSystem.h"
 
@@ -122,7 +123,7 @@ namespace ToolCore
                 }
 
             }
-            
+
         }
         else
         {
@@ -197,27 +198,12 @@ namespace ToolCore
                     CurrentBuildError(ToString("Error loading project (%s), project expired", solutionPath.CString()));
                 }
 
-                Project* project = curBuild_->project_;
-
-                SharedPtr<NETProjectGen> gen(new NETProjectGen(context_));
-
-                gen->SetScriptPlatform(curBuild_->platform_);
-
-                if (!gen->LoadProject(project))
-                {
-                    CurrentBuildError(ToString("Error loading project (%s)", solutionPath.CString()));
-                    return;
-                }
-
-                if (!gen->Generate())
-                {
-                    CurrentBuildError(ToString("Error generating project (%s)", solutionPath.CString()));
-                    return;
-                }
+                NETProjectSystem* projectSystem = GetSubsystem<NETProjectSystem>();
 
-                solutionPath = gen->GetSolution()->GetOutputFilename();
-                requiresNuGet = gen->GetRequiresNuGet();
+                solutionPath = projectSystem->GetSolutionPath();
 
+                // TODO: handle projects that require nuget
+                requiresNuGet = false;
 
                 if (!fileSystem->FileExists(solutionPath))
                 {
@@ -273,7 +259,7 @@ namespace ToolCore
             }
 
             String vcvars64 = ToString("%s..\\..\\VC\\bin\\amd64\\vcvars64.bat", cmdToolsPath.CString());
-            
+
             const String configuration = curBuild_->configuration_;
 
             String cmd = "cmd";
@@ -323,7 +309,7 @@ namespace ToolCore
     }
 
 
-    NETBuild* NETBuildSystem::GetBuild(const String& solutionPath, const String& platform,  const String& configuration)
+    NETBuild* NETBuildSystem::GetBuild(const String& solutionPath, const String& platform, const String& configuration)
     {
         List<SharedPtr<NETBuild>>::ConstIterator itr = builds_.Begin();
 
@@ -380,7 +366,7 @@ namespace ToolCore
         }
 
         LOGINFOF("Received build for project %s", project->GetProjectFilePath().CString());
-            
+
     }
 
     NETBuild* NETBuildSystem::Build(const String& solutionPath, const String& platform, const String& configuration)
@@ -403,7 +389,7 @@ namespace ToolCore
         // Create a new build
         build = new NETBuild(context_, solutionPath, platform, configuration);
 
-        builds_.Push(build);        
+        builds_.Push(build);
 
         return build;
     }

Source/ToolCore/NETTools/NETProjectSystem.cpp

@@ -22,9 +22,19 @@
 
 #include <Poco/Environment.h>
 
+#include <Atomic/Core/CoreEvents.h>
+
 #include <Atomic/IO/Log.h>
 #include <Atomic/IO/FileSystem.h>
+#include <Atomic/Resource/ResourceEvents.h>
+
+#include "../ToolSystem.h"
+#include "../Assets/AssetEvents.h"
+#include "../Project/Project.h"
+#include "../Project/ProjectEvents.h"
 
+#include "NETProjectGen.h"
+#include "NETBuildSystem.h"
 #include "NETProjectSystem.h"
 
 namespace ToolCore
@@ -41,9 +51,141 @@ namespace ToolCore
 
     }
 
-    void NETProjectSystem::Initialize()
+    void NETProjectSystem::Clear()
+    {
+        quietPeriod_ = 0.0f;
+        solutionPath_.Clear();
+        projectAssemblyPath_.Clear();
+        solutionDirty_ = false;
+        projectAssemblyDirty_ = false;
+    }
+
+    void NETProjectSystem::HandleUpdate(StringHash eventType, VariantMap& eventData)
+    {
+        using namespace Update;
+
+        float delta = eventData[P_TIMESTEP].GetFloat();
+
+        quietPeriod_ -= delta;
+
+        if (quietPeriod_ < 0.0f)
+            quietPeriod_ = 0.0f;
+
+        if (quietPeriod_ > 0.0f)
+            return;
+
+        if (solutionDirty_)
+        {
+            ToolSystem* tsystem = GetSubsystem<ToolSystem>();
+            Project* project = tsystem->GetProject();
+
+            SharedPtr<NETProjectGen> gen(new NETProjectGen(context_));
+
+            gen->SetScriptPlatform("WINDOWS");
+
+            if (!gen->LoadProject(project))
+            {
+                return;
+            }
+
+            if (!gen->Generate())
+            {
+                return;
+            }
+
+            solutionDirty_ = false;
+
+        }
+
+        if (projectAssemblyDirty_)
+        {
+            using namespace NETBuildAtomicProject;
+
+            VariantMap eventData;
+            Project* project = GetSubsystem<ToolSystem>()->GetProject();
+            eventData[P_PROJECT] = project;
+
+            // We need to rebuild the project assembly
+            SendEvent(E_NETBUILDATOMICPROJECT, eventData);
+
+            projectAssemblyDirty_ = false;
+
+        }
+
+    }
+
+    void NETProjectSystem::HandleProjectLoaded(StringHash eventType, VariantMap& eventData)
+    {
+        using namespace ProjectLoaded;
+
+        String projectPath = eventData[P_PROJECTPATH].GetString();
+        
+        if (GetExtension(projectPath) == ".atomic")
+            projectPath = GetParentPath(projectPath);
+
+        solutionPath_ = AddTrailingSlash(projectPath) + "AtomicNET/Solution/AtomicProject.sln";
+        projectAssemblyPath_ = AddTrailingSlash(projectPath) + "Resource/AtomicProject.dll";
+
+        FileSystem* fileSystem = GetSubsystem<FileSystem>();
+
+        // if the solution or project assemblies don't exist mark as dirty
+
+        if (!fileSystem->FileExists(solutionPath_))
+            solutionDirty_ = true;
+
+        if (!fileSystem->FileExists(projectAssemblyPath_))
+            projectAssemblyDirty_ = true;
+
+    }
     
+    void NETProjectSystem::HandleProjectUnloaded(StringHash eventType, VariantMap& eventData)
+    {
+        Clear();
+    }
+
+    void NETProjectSystem::HandleFileChanged(StringHash eventType, VariantMap& eventData)
+    {
+
+    }
+
+    void NETProjectSystem::HandleResourceAdded(StringHash eventType, VariantMap& eventData)
+    {
+
+    }
+
+    void NETProjectSystem::HandleResourceRemoved(StringHash eventType, VariantMap& eventData)
+    {
+
+    }
+
+    void NETProjectSystem::HandleAssetRenamed(StringHash eventType, VariantMap& eventData)
     {
+
+    }
+
+    void NETProjectSystem::HandleAssetMoved(StringHash eventType, VariantMap& eventData)
+    {
+
+    }
+
+    void NETProjectSystem::Initialize()    
+    {
+        Clear();
+
+        SubscribeToEvent(E_UPDATE, HANDLER(NETProjectSystem, HandleUpdate));
+
+        SubscribeToEvent(E_PROJECTLOADED, HANDLER(NETProjectSystem, HandleProjectLoaded));
+        SubscribeToEvent(E_PROJECTUNLOADED, HANDLER(NETProjectSystem, HandleProjectUnloaded));
+
+        SubscribeToEvent(E_FILECHANGED, HANDLER(NETProjectSystem, HandleFileChanged));
+
+        SubscribeToEvent(E_RESOURCEADDED, HANDLER(NETProjectSystem, HandleResourceAdded));
+        SubscribeToEvent(E_RESOURCEREMOVED, HANDLER(NETProjectSystem, HandleResourceRemoved));
+
+        SubscribeToEvent(E_ASSETRENAMED, HANDLER(NETProjectSystem, HandleAssetRenamed));
+        SubscribeToEvent(E_ASSETMOVED, HANDLER(NETProjectSystem, HandleAssetMoved));
+
+
 #ifdef ATOMIC_PLATFORM_WINDOWS
 
         FileSystem* fileSystem = GetSubsystem<FileSystem>();

Source/ToolCore/NETTools/NETProjectSystem.h

@@ -28,6 +28,9 @@ using namespace Atomic;
 
 namespace ToolCore
 {
+
+    class Project;
+
     // AtomicProject.dll state (this shouldn't be in resources too)
 
     enum NETProjectState
@@ -46,14 +49,36 @@ namespace ToolCore
         NETProjectSystem(Context* context);
         virtual ~NETProjectSystem();
 
+        const String& GetSolutionPath() const { return solutionPath_; }
+
         bool GetVisualStudioAvailable() const { return visualStudioPath_.Length() != 0; }
 
     private:
 
+        void HandleUpdate(StringHash eventType, VariantMap& eventData);
+
+        void HandleFileChanged(StringHash eventType, VariantMap& eventData);
+        void HandleResourceAdded(StringHash eventType, VariantMap& eventData);
+        void HandleResourceRemoved(StringHash eventType, VariantMap& eventData);
+        void HandleAssetRenamed(StringHash eventType, VariantMap& eventData);
+        void HandleAssetMoved(StringHash eventType, VariantMap& eventData);
+
+        void HandleProjectLoaded(StringHash eventType, VariantMap& eventData);
+        void HandleProjectUnloaded(StringHash eventType, VariantMap& eventData);
+
+        void Clear();
         void Initialize();
 
         String visualStudioPath_;
 
+        String solutionPath_;
+        String projectAssemblyPath_;
+
+        float quietPeriod_;
+
+        bool solutionDirty_;
+        bool  projectAssemblyDirty_;
+
     };
 
 }