Editing EditorMode/PlayerMode, breaking out common application support, editor play mode now using IPC system

Script/AtomicEditor/ui/MainToolbar.ts

@@ -32,7 +32,7 @@ class MainToolbar extends Atomic.UIWidget {
 
             } else if (ev.target.id == "maintoolbar_play") {
 
-              new ToolCore.PlayCmd().run();
+              Atomic.editorMode.playProject();
               return true;
 
             }

Script/Packages/Editor/Editor.json

@@ -1,5 +1,7 @@
 {
 	"name" : "Editor",
-	"sources" : ["Source/AtomicEditorWork/Application", "Source/AtomicEditorWork/Utils", "Source/AtomicEditorWork/Editors", "Source/AtomicEditorWork/Editors/SceneEditor3D"],
-	"classes" : ["FileUtils", "AEPreferences", "ResourceEditor", "JSResourceEditor", "SceneEditor3D", "SceneView3D"]
+	"sources" : ["Source/AtomicEditorWork/Application", "Source/AtomicEditorWork/Utils",
+							"Source/AtomicEditorWork/EditorMode", "Source/AtomicEditorWork/PlayerMode",
+							 "Source/AtomicEditorWork/Editors", "Source/AtomicEditorWork/Editors/SceneEditor3D"],
+	"classes" : ["EditorMode", "PlayerMode", "FileUtils", "AEPreferences", "ResourceEditor", "JSResourceEditor", "SceneEditor3D", "SceneView3D"]
 }

Script/TypeScript/Atomic.d.ts

@@ -1413,7 +1413,6 @@ declare module Atomic {
 
       eventSender: AObject;
       editorContext: boolean;
-      editorContent: boolean;
 
       // Construct.
       constructor();
@@ -1433,7 +1432,7 @@ declare module Atomic {
       // Get whether an Editor Context
       getEditorContext(): boolean;
       // Get whether an Editor Context
-      setEditorContent(editor: boolean): void;
+      setEditorContext(editor: boolean): void;
 
    }
 

Script/TypeScript/AtomicPlayer.d.ts

@@ -17,7 +17,6 @@ declare module AtomicPlayer {
       constructor();
 
       loadScene(filename: string, camera?: Atomic.Camera): Atomic.Scene;
-      sayHi(): void;
 
    }
 

Script/TypeScript/AtomicWork.d.ts

@@ -9,6 +9,20 @@ declare module Atomic {
 
     export var platform: string;
 
+    // subsystems
+
+    export var engine:Engine;
+    export var graphics:Graphics;
+    export var renderer:Renderer;
+    export var cache:ResourceCache;
+    export var input:Input;
+    export var fileSystem:FileSystem;
+    export var network:Network;
+
+    export var editorMode:Editor.EditorMode;
+
+    // end subsystems
+
 
     export interface PathInfo {
 
@@ -107,19 +121,6 @@ declare module Atomic {
 
     }
 
-    // subsystems
-
-    export var engine:Engine;
-    export var graphics:Graphics;
-    export var renderer:Renderer;
-    export var cache:ResourceCache;
-    export var input:Input;
-    export var fileSystem:FileSystem;
-    export var network:Network;
-
-    // end subsystems
-
-
     export function getArguments(): Array<string>;
     export function getEngine(): Engine;
     export function getInput(): Input;

Script/TypeScript/Editor.d.ts

@@ -61,6 +61,23 @@ declare module Editor {
 
    }
 
+   export class EditorMode extends Atomic.AObject {
+
+      // Construct.
+      constructor();
+
+      playProject(): boolean;
+
+   }
+
+   export class PlayerMode extends Atomic.AObject {
+
+      // Construct.
+      constructor();
+
+
+   }
+
    export class JSResourceEditor extends ResourceEditor {
 
       constructor(fullpath: string, container: Atomic.UITabContainer);

Source/Atomic/Core/Context.h

@@ -160,7 +160,7 @@ public:
     void SetGlobalEventListener(GlobalEventListener* listener) { globalEventListener_ = listener; }
 
     /// Get whether an Editor Context
-    void SetEditorContent(bool editor) { editorContext_ = editor; }
+    void SetEditorContext(bool editor) { editorContext_ = editor; }
     // ATOMIC END
 
 private:

Source/AtomicEditorWork/Application/AEEditorApp.cpp

@@ -19,12 +19,11 @@
 #include <ToolCore/License/LicenseEvents.h>
 #include <ToolCore/License/LicenseSystem.h>
 
+#include "../EditorMode/AEEditorMode.h"
+
 #include "AEEditorApp.h"
 #include "AEPreferences.h"
 
-// Move me
-#include <Atomic/Environment/Environment.h>
-
 using namespace ToolCore;
 
 namespace ToolCore
@@ -38,23 +37,23 @@ namespace AtomicEditor
 extern void jsapi_init_editor(JSVM* vm);
 
 AEEditorApp::AEEditorApp(Context* context) :
-    Application(context)
+    AEEditorCommon(context)
 {
 
 }
 
 void AEEditorApp::Start()
 {
+    AEEditorCommon::Start();
+
+    context_->RegisterSubsystem(new EditorMode(context_));
+
+    vm_->SetModuleSearchPaths("AtomicEditor");
 
     // Do not create bone structure by default when in the editor
     // this can be toggled temporarily, for example to setup an animation preview
     AnimatedModel::SetBoneCreationEnabled(false);
 
-    context_->SetEditorContent(true);
-
-    Input* input = GetSubsystem<Input>();
-    input->SetMouseVisible(true);
-
     // move UI initialization to JS
     UI* ui = GetSubsystem<UI>();
     ui->Initialize("AtomicEditor/resources/language/lng_en.tb.txt");
@@ -63,17 +62,9 @@ void AEEditorApp::Start()
     ui->AddFont("AtomicEditor/resources/MesloLGS-Regular.ttf", "Monaco");
     ui->SetDefaultFont("Vera", 12);
 
-    Javascript* javascript = new Javascript(context_);
-    context_->RegisterSubsystem(javascript);
-
     SubscribeToEvent(E_JSERROR, HANDLER(AEEditorApp, HandleJSError));
     SubscribeToEvent(E_EXITREQUESTED, HANDLER(AEEditorApp, HandleExitRequested));
 
-    // Instantiate and register the Javascript subsystem
-    vm_ = javascript->InstantiateVM("MainVM");
-    vm_->InitJSContext();
-    vm_->SetModuleSearchPaths("AtomicEditor");
-
     jsapi_init_toolcore(vm_);
     jsapi_init_editor(vm_);
 
@@ -97,11 +88,10 @@ void AEEditorApp::Start()
 
 void AEEditorApp::Setup()
 {
-    RegisterEnvironmentLibrary(context_);
+    context_->SetEditorContext(true);
 
     context_->RegisterSubsystem(new AEPreferences(context_));
 
-    FileSystem* filesystem = GetSubsystem<FileSystem>();
     ToolEnvironment* env = new ToolEnvironment(context_);
     context_->RegisterSubsystem(env);
 
@@ -118,14 +108,14 @@ void AEEditorApp::Setup()
 
 #endif
 
-    // env->Dump();
-
     engineParameters_["WindowTitle"] = "AtomicEditor";
     engineParameters_["WindowResizable"] = true;
     engineParameters_["FullScreen"] = false;
-    engineParameters_["LogName"] = filesystem->GetAppPreferencesDir("AtomicEditor", "Logs") + "AtomicEditor.log";
     engineParameters_["LogLevel"] = LOG_DEBUG;
 
+    FileSystem* filesystem = GetSubsystem<FileSystem>();
+    engineParameters_["LogName"] = filesystem->GetAppPreferencesDir("AtomicEditor", "Logs") + "AtomicEditor.log";
+
 #ifdef ATOMIC_PLATFORM_OSX
     engineParameters_["WindowIcon"] = "Images/AtomicLogo32.png";
 #endif
@@ -146,11 +136,7 @@ void AEEditorApp::Setup()
 
 void AEEditorApp::Stop()
 {
-    vm_ = 0;
-    context_->RemoveSubsystem<Javascript>();
-    // make sure JSVM is really down and no outstanding refs
-    // as if not, will hold on engine subsystems, which is bad
-    assert(!JSVM::GetJSVM(0));
+    AEEditorCommon::Stop();
 }
 
 void AEEditorApp::HandleExitRequested(StringHash eventType, VariantMap& eventData)

Source/AtomicEditorWork/Application/AEEditorApp.h

@@ -1,7 +1,7 @@
 
 #pragma once
 
-#include <Atomic/Engine/Application.h>
+#include "AEEditorCommon.h"
 
 using namespace Atomic;
 
@@ -15,7 +15,7 @@ namespace AtomicEditor
 
 class AEPreferences;
 
-class AEEditorApp : public Application
+class AEEditorApp : public AEEditorCommon
 {
     OBJECT(AEEditorApp);
 
@@ -35,8 +35,6 @@ private:
     void HandleExitRequested(StringHash eventType, VariantMap& eventData);
     void HandleJSError(StringHash eventType, VariantMap& eventData);
 
-    SharedPtr<JSVM> vm_;
-
 
 };
 

Source/AtomicEditorWork/Application/AEEditorCommon.cpp

@@ -0,0 +1,61 @@
+// Copyright (c) 2014-2015, THUNDERBEAST GAMES LLC All rights reserved
+// Please see LICENSE.md in repository root for license information
+// https://github.com/AtomicGameEngine/AtomicGameEngine
+
+#include <Atomic/Engine/Engine.h>
+#include <Atomic/Input/Input.h>
+
+#include <Atomic/IPC/IPC.h>
+
+// Move me to Engine
+#include <Atomic/Environment/Environment.h>
+
+#include <AtomicJS/Javascript/Javascript.h>
+
+#include "AEEditorCommon.h"
+
+namespace AtomicEditor
+{
+
+AEEditorCommon::AEEditorCommon(Context* context) :
+    Application(context)
+{
+
+}
+
+void AEEditorCommon::Start()
+{
+    Input* input = GetSubsystem<Input>();
+    input->SetMouseVisible(true);
+
+    // Register IPC system
+    context_->RegisterSubsystem(new IPC(context_));
+
+    // Instantiate and register the Javascript subsystem
+    Javascript* javascript = new Javascript(context_);
+    context_->RegisterSubsystem(javascript);
+
+    vm_ = javascript->InstantiateVM("MainVM");
+    vm_->InitJSContext();
+
+}
+
+void AEEditorCommon::Setup()
+{
+
+#ifdef ATOMIC_3D
+    RegisterEnvironmentLibrary(context_);
+#endif
+
+}
+
+void AEEditorCommon::Stop()
+{
+    vm_ = 0;
+    context_->RemoveSubsystem<Javascript>();
+    // make sure JSVM is really down and no outstanding refs
+    // as if not, will hold on engine subsystems, which is bad
+    assert(!JSVM::GetJSVM(0));
+}
+
+}

Source/AtomicEditorWork/Application/AEEditorCommon.h

@@ -0,0 +1,42 @@
+
+#pragma once
+
+#include <Atomic/Engine/Application.h>
+
+using namespace Atomic;
+
+namespace Atomic
+{
+    class JSVM;
+}
+
+namespace AtomicEditor
+{
+
+class AEPreferences;
+
+class AEEditorCommon : public Application
+{
+    OBJECT(AEEditorCommon);
+
+public:
+    /// Construct.
+    AEEditorCommon(Context* context);
+
+    /// Setup before engine initialization. Verify that a script file has been specified.
+    virtual void Setup();
+    /// Setup after engine initialization. Load the script and execute its start function.
+    virtual void Start();
+    /// Cleanup after the main loop. Run the script's stop function if it exists.
+    virtual void Stop();
+
+protected:
+
+    SharedPtr<JSVM> vm_;
+
+private:
+
+
+};
+
+}

Source/AtomicEditorWork/Application/AEPlayerApp.cpp

@@ -30,28 +30,23 @@
 #include <Atomic/Resource/ResourceCache.h>
 #include <Atomic/Resource/ResourceEvents.h>
 
-#include <Atomic/IPC/IPC.h>
-#include <Atomic/IPC/IPCEvents.h>
-#include <Atomic/IPC/IPCWorker.h>
-
 // Move me
 #include <Atomic/Environment/Environment.h>
 
 #include <AtomicJS/Javascript/Javascript.h>
 
+
+#include "../PlayerMode/AEPlayerMode.h"
 #include <AtomicPlayer/Player.h>
 
 #include "AEPlayerApp.h"
 
 #include <Atomic/DebugNew.h>
 
-#include <Atomic/UI/UI.h>
-
 #ifdef __APPLE__
 #include <unistd.h>
 #endif
 
-
 namespace AtomicPlayer
 {
     extern void jsapi_init_atomicplayer(JSVM* vm);
@@ -60,20 +55,9 @@ namespace AtomicPlayer
 namespace AtomicEditor
 {
 
-// fixme
-static JSVM* vm = NULL;
-static Javascript* javascript = NULL;
-
 AEPlayerApplication::AEPlayerApplication(Context* context) :
-    Application(context)
+    AEEditorCommon(context)
 {
-    fd_[0] = INVALID_IPCHANDLE_VALUE;
-    fd_[1] = INVALID_IPCHANDLE_VALUE;
-
-#ifdef ATOMIC_3D
-    RegisterEnvironmentLibrary(context_);
-#endif
-
 }
 
 void AEPlayerApplication::Setup()
@@ -121,41 +105,6 @@ void AEPlayerApplication::Setup()
             {
                 SubscribeToEvent(E_LOGMESSAGE, HANDLER(AEPlayerApplication, HandleLogMessage));
             }
-
-            if (argument.StartsWith("--ipc-server=") || argument.StartsWith("--ipc-client="))
-            {
-                LOGINFOF("Starting IPCWorker %s", argument.CString());
-
-                Vector<String> ipc = argument.Split(argument.CString(), '=');
-
-                if (ipc.Size() == 2)
-                {
-                    if (argument.StartsWith("--ipc-server="))
-                    {
-#ifdef ATOMIC_PLATFORM_WINDOWS
-                        WString wipc(ipc[1]);
-                        HANDLE pipe = reinterpret_cast<HANDLE>(_wtoi64(wipc.CString()));
-                        fd_[0] = pipe;
-#else
-                        int fd = ToInt(ipc[1].CString());
-                        fd_[0] = fd;
-#endif
-                    }
-                    else
-                    {
-#ifdef ATOMIC_PLATFORM_WINDOWS
-                        WString wipc(ipc[1]);
-                        HANDLE pipe = reinterpret_cast<HANDLE>(_wtoi64(wipc.CString()));
-                        fd_[1] = pipe;
-#else
-                        int fd = ToInt(ipc[1].CString());
-                        fd_[1] = fd;
-#endif
-                    }
-
-                }
-
-            }
             else if (argument == "--project" && value.Length())
             {
                 engineParameters_["ResourcePrefixPath"] = "";
@@ -171,69 +120,32 @@ void AEPlayerApplication::Setup()
                 engineParameters_["ResourcePaths"] = resourcePaths;
 
             }
-            else if (argument == "--editor-resource-paths" && value.Length())
-            {
-                // "/Users/josh/Dev/atomic/AtomicGameEngine/Data/AtomicPlayer/Resources/CoreData!/Users/josh/Dev/atomic/AtomicGameEngine/Data/AtomicPlayer/Resources/PlayerData!/Users/josh/Dev/atomic/AtomicExamples/NewSpaceGame/Resources"
-                engineParameters_["ResourcePrefixPath"] = "";
-                value.Replace("!", ";");
-                engineParameters_["ResourcePaths"] = value;
-            }
         }
     }
 
-    // Use the script file name as the base name for the log file
-    engineParameters_["LogName"] = filesystem->GetAppPreferencesDir("AtomicPlayer", "Logs") + "AtomicPlayer.log";
-}
 
-void AEPlayerApplication::HandleHelloFromBroker(StringHash eventType, VariantMap& eventData)
-{
-    assert(eventData[HelloFromBroker::P_HELLO].GetString() == "Hello");
-    assert(eventData[HelloFromBroker::P_LIFETHEUNIVERSEANDEVERYTHING].GetInt() == 42);
 
-    LOGERROR("Passed Test!");
+    // Use the script file name as the base name for the log file
+    engineParameters_["LogName"] = filesystem->GetAppPreferencesDir("AtomicPlayer", "Logs") + "AtomicPlayer.log";
 }
 
 void AEPlayerApplication::Start()
 {
-    SubscribeToEvent(E_IPCHELLOFROMBROKER, HANDLER(AEPlayerApplication, HandleHelloFromBroker));
-    SubscribeToEvent(E_JSERROR, HANDLER(AEPlayerApplication, HandleJSError));
+    AEEditorCommon::Start();
 
+    context_->RegisterSubsystem(new PlayerMode(context_));
+    PlayerMode* playerMode = GetSubsystem<PlayerMode>();
+    playerMode->ProcessArguments();
 
-#ifdef ATOMIC_PLATFORM_WINDOWS
-    if (fd_[0] != INVALID_IPCHANDLE_VALUE)
-    {
-        //::CloseHandle(fd_[0]);
-        fd_[0] = INVALID_IPCHANDLE_VALUE;
-    }
-
-    if (fd_[1] != INVALID_IPCHANDLE_VALUE)
-    {
-        IPC* ipc = new IPC(context_);
-        context_->RegisterSubsystem(ipc);
-        //ipc->InitWorker(fd_[0], fd_[1]);
-    }
-#else
-    if (fd_[0] != INVALID_IPCHANDLE_VALUE && fd_[1] != INVALID_IPCHANDLE_VALUE)
-    {
-        IPC* ipc = new IPC(context_);
-        context_->RegisterSubsystem(ipc);
-        ipc->InitWorker(fd_[0], fd_[1]);
-    }
-#endif
-
-    // Instantiate and register the Javascript subsystem
-    javascript = new Javascript(context_);
-    context_->RegisterSubsystem(javascript);
+    SubscribeToEvent(E_JSERROR, HANDLER(AEPlayerApplication, HandleJSError));
 
-    vm = javascript->InstantiateVM("MainVM");
-    vm->InitJSContext();
-    vm->SetModuleSearchPaths("Modules");
+    vm_->SetModuleSearchPaths("Modules");
 
     // Instantiate and register the Player subsystem
     context_->RegisterSubsystem(new AtomicPlayer::Player(context_));
-    AtomicPlayer::jsapi_init_atomicplayer(vm);
+    AtomicPlayer::jsapi_init_atomicplayer(vm_);
 
-    if (!vm->ExecuteMain())
+    if (!vm_->ExecuteMain())
     {
         ErrorExit("Error executing Scripts/main.js");
     }
@@ -243,10 +155,7 @@ void AEPlayerApplication::Start()
 
 void AEPlayerApplication::Stop()
 {
-    context_->RemoveSubsystem<Javascript>();
-    // make sure JSVM is really down and no outstanding refs
-    // as if not, will hold on engine subsystems, which is bad
-    assert(!JSVM::GetJSVM(0));
+    AEEditorCommon::Stop();
 }
 
 void AEPlayerApplication::HandleScriptReloadStarted(StringHash eventType, VariantMap& eventData)

Source/AtomicEditorWork/Application/AEPlayerApp.h

@@ -22,15 +22,14 @@
 
 #pragma once
 
-#include <Atomic/IPC/IPCTypes.h>
-#include <Atomic/Engine/Application.h>
+#include "AEEditorCommon.h"
 
 using namespace Atomic;
 
 namespace AtomicEditor
 {
 
-class AEPlayerApplication : public Application
+class AEPlayerApplication : public AEEditorCommon
 {
     OBJECT(AEPlayerApplication);
 
@@ -57,10 +56,6 @@ private:
 
     void HandleLogMessage(StringHash eventType, VariantMap& eventData);
 
-
-    void HandleHelloFromBroker(StringHash eventType, VariantMap& eventData);
-
-    IPCHandle fd_[2];
 };
 
 }

Source/AtomicEditorWork/EditorMode/AEEditorMode.cpp

@@ -0,0 +1,88 @@
+
+#include <Atomic/IO/Log.h>
+
+#include <Atomic/IPC/IPC.h>
+#include <Atomic/IPC/IPCEvents.h>
+#include <Atomic/IPC/IPCBroker.h>
+
+#include <ToolCore/ToolEnvironment.h>
+#include <ToolCore/ToolSystem.h>
+#include <ToolCore/Project/Project.h>
+
+#include "AEEditorMode.h"
+
+using namespace ToolCore;
+
+namespace AtomicEditor
+{
+
+EditorMode::EditorMode(Context* context) :
+    Object(context)
+{    
+    SubscribeToEvent(E_IPCWORKERSTART, HANDLER(EditorMode, HandleIPCWorkerStarted));
+}
+
+EditorMode::~EditorMode()
+{
+
+}
+
+void EditorMode::HandleIPCWorkerStarted(StringHash eventType, VariantMap& eventData)
+{
+    VariantMap weventData;
+    weventData[HelloFromBroker::P_HELLO] = "Hello";
+    weventData[HelloFromBroker::P_LIFETHEUNIVERSEANDEVERYTHING] = 42;
+    playerBroker_->PostMessage(E_IPCHELLOFROMBROKER, weventData);
+}
+
+void EditorMode::HandleIPCWorkerExit(StringHash eventType, VariantMap& eventData)
+{
+    //SendEvent(E_EDITORPLAYSTOP);
+}
+
+
+bool EditorMode::PlayProject()
+{
+    ToolEnvironment* env = GetSubsystem<ToolEnvironment>();
+    ToolSystem* tsystem = GetSubsystem<ToolSystem>();
+
+    const String& editorBinary = env->GetEditorBinary();
+
+    Project* project = tsystem->GetProject();
+
+    Vector<String> paths;
+    paths.Push(env->GetCoreDataDir());
+    paths.Push(env->GetPlayerDataDir());
+    paths.Push(project->GetResourcePath());
+
+    // fixme: this is for loading from cache
+    paths.Push(project->GetProjectPath());
+    paths.Push(project->GetProjectPath() + "Cache");
+
+    String resourcePaths;
+    resourcePaths.Join(paths, "!");
+
+    Vector<String> vargs;
+
+    String args = ToString("--player --project \"%s\"", AddTrailingSlash(project->GetProjectPath()).CString());
+
+    vargs = args.Split(' ');
+
+    String dump;
+    dump.Join(vargs, " ");
+    LOGINFOF("Launching Broker %s %s", editorBinary.CString(), dump.CString());
+
+    IPC* ipc = GetSubsystem<IPC>();
+    playerBroker_ = ipc->SpawnWorker(editorBinary, vargs);
+
+    if (playerBroker_)
+    {        
+        SubscribeToEvent(playerBroker_, E_IPCWORKEREXIT, HANDLER(EditorMode, HandleIPCWorkerExit));
+
+    }
+
+    return playerBroker_.NotNull();
+
+}
+
+}

Source/AtomicEditorWork/EditorMode/AEEditorMode.h

@@ -0,0 +1,38 @@
+
+#pragma once
+
+#include <Atomic/Core/Object.h>
+
+namespace Atomic
+{
+    class IPCBroker;
+}
+
+using namespace Atomic;
+
+namespace AtomicEditor
+{
+
+/// EditorMode subsystem
+class EditorMode : public Object
+{
+    OBJECT(EditorMode);
+
+public:
+    /// Construct.
+    EditorMode(Context* context);
+    /// Destruct.
+    virtual ~EditorMode();
+
+    bool PlayProject();
+
+private:
+
+    void HandleIPCWorkerStarted(StringHash eventType, VariantMap& eventData);
+    void HandleIPCWorkerExit(StringHash eventType, VariantMap& eventData);
+
+    SharedPtr<IPCBroker> playerBroker_;
+
+};
+
+}

Source/AtomicEditorWork/Javascript/AEEditorJS.cpp

@@ -1,7 +1,10 @@
 
 #include <AtomicJS/Javascript/JSVM.h>
+
 #include "../Application/AEPreferences.h"
 
+#include "../EditorMode/AEEditorMode.h"
+
 using namespace Atomic;
 
 namespace Atomic
@@ -31,6 +34,16 @@ void jsapi_init_editor(JSVM* vm)
     duk_put_global_string(ctx, "Editor");
 
     jsb_package_editor_init(vm);
+
+    duk_get_global_string(ctx, "Atomic");
+
+    if (vm->GetContext()->GetEditorContext()) {
+        js_push_class_object_instance(ctx, vm->GetSubsystem<EditorMode>(), "EditorMode");
+        duk_put_prop_string(ctx, -2, "editorMode");
+    }
+
+    duk_pop(ctx);
+
 }
 
 }

Source/AtomicEditorWork/PlayerMode/AEPlayerMode.cpp

@@ -0,0 +1,106 @@
+
+#include <Atomic/IO/Log.h>
+#include <Atomic/Core/ProcessUtils.h>
+#include <Atomic/IPC/IPC.h>
+#include <Atomic/IPC/IPCEvents.h>
+#include <Atomic/IPC/IPCWorker.h>
+
+#include "AEPlayerMode.h"
+
+namespace AtomicEditor
+{
+
+PlayerMode::PlayerMode(Context* context) :
+    Object(context)
+{
+    fd_[0] = INVALID_IPCHANDLE_VALUE;
+    fd_[1] = INVALID_IPCHANDLE_VALUE;
+}
+
+void PlayerMode::HandleHelloFromBroker(StringHash eventType, VariantMap& eventData)
+{
+    assert(eventData[HelloFromBroker::P_HELLO].GetString() == "Hello");
+    assert(eventData[HelloFromBroker::P_LIFETHEUNIVERSEANDEVERYTHING].GetInt() == 42);
+
+    LOGERROR("Passed Test!");
+}
+
+void PlayerMode::ProcessArguments() {
+
+    const Vector<String>& arguments = GetArguments();
+
+    for (unsigned i = 0; i < arguments.Size(); ++i)
+    {
+        if (arguments[i].Length() > 1)
+        {
+            String argument = arguments[i].ToLower();
+            String value = i + 1 < arguments.Size() ? arguments[i + 1] : String::EMPTY;
+
+            if (argument.StartsWith("--ipc-server=") || argument.StartsWith("--ipc-client="))
+            {
+                LOGINFOF("Starting IPCWorker %s", argument.CString());
+
+                Vector<String> ipc = argument.Split(argument.CString(), '=');
+
+                if (ipc.Size() == 2)
+                {
+                    if (argument.StartsWith("--ipc-server="))
+                    {
+#ifdef ATOMIC_PLATFORM_WINDOWS
+                        WString wipc(ipc[1]);
+                        HANDLE pipe = reinterpret_cast<HANDLE>(_wtoi64(wipc.CString()));
+                        fd_[0] = pipe;
+#else
+                        int fd = ToInt(ipc[1].CString());
+                        fd_[0] = fd;
+#endif
+                    }
+                    else
+                    {
+#ifdef ATOMIC_PLATFORM_WINDOWS
+                        WString wipc(ipc[1]);
+                        HANDLE pipe = reinterpret_cast<HANDLE>(_wtoi64(wipc.CString()));
+                        fd_[1] = pipe;
+#else
+                        int fd = ToInt(ipc[1].CString());
+                        fd_[1] = fd;
+#endif
+                    }
+
+                }
+
+            }
+
+        }
+    }
+
+#ifdef ATOMIC_PLATFORM_WINDOWS
+    if (fd_[0] != INVALID_IPCHANDLE_VALUE)
+    {
+        //::CloseHandle(fd_[0]);
+        fd_[0] = INVALID_IPCHANDLE_VALUE;
+    }
+
+    if (fd_[1] != INVALID_IPCHANDLE_VALUE)
+    {
+        IPC* ipc = new IPC(context_);
+        context_->RegisterSubsystem(ipc);
+        //ipc->InitWorker(fd_[0], fd_[1]);
+    }
+#else
+    if (fd_[0] != INVALID_IPCHANDLE_VALUE && fd_[1] != INVALID_IPCHANDLE_VALUE)
+    {
+        IPC* ipc = GetSubsystem<IPC>();
+        SubscribeToEvent(E_IPCHELLOFROMBROKER, HANDLER(PlayerMode, HandleHelloFromBroker));
+        ipc->InitWorker(fd_[0], fd_[1]);
+    }
+#endif
+
+}
+
+PlayerMode::~PlayerMode()
+{
+
+}
+
+}

Source/AtomicEditorWork/PlayerMode/AEPlayerMode.h

@@ -0,0 +1,34 @@
+
+#pragma once
+
+#include <Atomic/Core/Object.h>
+#include <Atomic/IPC/IPCTypes.h>
+
+using namespace Atomic;
+
+namespace AtomicEditor
+{
+
+/// PlayerMode subsystem
+class PlayerMode : public Object
+{
+    friend class AEPlayerApplication;
+
+    OBJECT(PlayerMode);
+
+public:
+    /// Construct.
+    PlayerMode(Context* context);
+    /// Destruct.
+    virtual ~PlayerMode();
+
+private:
+
+    void ProcessArguments();
+    void HandleHelloFromBroker(StringHash eventType, VariantMap& eventData);
+
+    IPCHandle fd_[2];
+
+};
+
+}

Source/AtomicPlayer/Player.cpp

@@ -57,12 +57,5 @@ Scene* Player::LoadScene(const String& filename, Camera *camera)
     return scene;
 }
 
-void Player::SayHi()
-{
-
-    LOGINFO("The Player says Hi!");
-
-}
-
 
 }

Source/AtomicPlayer/Player.h

@@ -23,8 +23,6 @@ public:
 
     Scene* LoadScene(const String& filename, Camera* camera = NULL);
 
-    void SayHi();
-
 private:
 
     SharedPtr<Viewport> viewport_;