Updates for Scene Preview

Script/Packages/AtomicPlayer/Player.json

@@ -1,5 +1,6 @@
 {
 	"name" : "Player",
+	"includes" : ["<Atomic/Graphics/Texture2D.h>"],
 	"sources" : ["Source/AtomicPlayer"],
 	"classes" : ["Player"]
 }

Source/Atomic/Graphics/Direct3D9/D3D9Texture2D.cpp

@@ -614,6 +614,10 @@ bool Texture2D::Create()
     {
         HANDLE sharedHandle = 0;
 
+        if (gpuShared_ && gpuSharedHandle_)
+            sharedHandle = (HANDLE) gpuSharedHandle_;
+
+
         if (!device || FAILED(graphics_->GetImpl()->GetDevice()->CreateTexture(
             (UINT)width_,
             (UINT)height_,

Source/AtomicEditor/EditorMode/AEEditorEvents.h

@@ -101,6 +101,13 @@ EVENT(E_EDITORPLAYERSTOPPED, EditorPlayerStopped)
 
 }
 
+// emitted once play has stopped
+EVENT(E_EDITORPLAYERRENDERTEXTUREUPDATED, EditorPlayerRenderTextureUpdated)
+{
+
+}
+
+
 EVENT(E_EDITORBUILD, EditorBuild)
 {
     PARAM(P_PLATFORM, Platform);      // string

Source/AtomicEditor/EditorMode/AEEditorMode.cpp

@@ -28,6 +28,7 @@
 
 #include <Atomic/Core/CoreEvents.h>
 #include <Atomic/Input/InputEvents.h>
+#include <Atomic/Graphics/Texture2D.h>
 
 #include <ToolCore/ToolEnvironment.h>
 #include <ToolCore/ToolSystem.h>
@@ -55,6 +56,8 @@ EditorMode::EditorMode(Context* context) :
     SubscribeToEvent(E_IPCPLAYERUPDATESPAUSEDRESUMED, HANDLER(EditorMode, HandleIPCPlayerUpdatesPausedResumed));
     SubscribeToEvent(E_IPCPLAYERPAUSESTEPREQUEST, HANDLER(EditorMode, HandleIPCPlayerPauseStepRequest));
     SubscribeToEvent(E_IPCPLAYEREXITREQUEST, HANDLER(EditorMode, HandleIPCPlayerExitRequest));
+
+    SubscribeToEvent(E_IPCPLAYERRENDERTEXTUREINFO, HANDLER(EditorMode, HandleIPCPlayerRenderTextureInfo));
 }
 
 EditorMode::~EditorMode()
@@ -85,10 +88,27 @@ void EditorMode::HandleIPCWorkerStarted(StringHash eventType, VariantMap& eventD
 
 }
 
-void EditorMode::HandleIPCWorkerExit(StringHash eventType, VariantMap& eventData)
+void EditorMode::HandleIPCPlayerRenderTextureInfo(StringHash eventType, VariantMap& eventData)
 {
-    //SendEvent(E_EDITORPLAYSTOP);
+    using namespace IPCPlayerRenderTextureInfo;
+
+    int width = eventData[P_WIDTH].GetInt();
+    int height = eventData[P_HEIGHT].GetInt();
+    unsigned format = eventData[P_FORMAT].GetUInt();
+    TextureUsage usage = (TextureUsage)  eventData[P_USAGE].GetUInt();
+    unsigned resourceHandle = eventData[P_RESOURCEHANDLE].GetUInt();
 
+    renderTexture_ = new Texture2D(context_);
+    renderTexture_->SetGPUShared(true);
+    renderTexture_->SetGPUSharedHandle((void*) ((uintptr_t)resourceHandle));
+    renderTexture_->SetSize(width, height, format, usage);
+
+    SendEvent(E_EDITORPLAYERRENDERTEXTUREUPDATED);
+}
+
+
+void EditorMode::HandleIPCWorkerExit(StringHash eventType, VariantMap& eventData)
+{
     if (eventData[IPCWorkerExit::P_BROKER] == playerBroker_)
     {
         playerBroker_ = 0;

Source/AtomicEditor/EditorMode/AEEditorMode.h

@@ -29,6 +29,7 @@
 namespace Atomic
 {
     class IPCBroker;
+    class Texture2D;
 }
 
 using namespace Atomic;
@@ -51,6 +52,8 @@ public:
     bool PlayScene(const String& scenePath, const String& addArgs = String::EMPTY, bool debug = false);
     bool IsPlayerEnabled();
 
+    Texture2D* GetPlayerRenderTexture() const { return renderTexture_; }
+
 private:
 
     bool PlaySetup(Vector<String>& vargs, const String& addArgs, bool debug);
@@ -64,7 +67,10 @@ private:
     void HandleIPCPlayerPauseStepRequest(StringHash eventType, VariantMap& eventData);
     void HandleIPCPlayerExitRequest(StringHash eventType, VariantMap& eventData);
 
+    void HandleIPCPlayerRenderTextureInfo(StringHash eventType, VariantMap& eventData);
+
     SharedPtr<IPCBroker> playerBroker_;
+    SharedPtr<Texture2D> renderTexture_;
 
     bool playerEnabled_ = false;
 

Source/AtomicEditor/PlayerMode/AEPlayerEvents.h

@@ -64,4 +64,13 @@ EVENT(E_PLAYERQUIT, PlayerQuit)
 
 }
 
+EVENT(E_IPCPLAYERRENDERTEXTUREINFO, IPCPlayerRenderTextureInfo)
+{
+    PARAM(P_RESOURCEHANDLE, ResourceHandle);
+    PARAM(P_WIDTH, Width);
+    PARAM(P_HEIGHT, Height);
+    PARAM(P_FORMAT, Format);
+    PARAM(P_USAGE, Usage);
+}
+
 }

Source/AtomicEditor/PlayerMode/AEPlayerMode.cpp

@@ -28,6 +28,7 @@
 #include <Atomic/Graphics/GraphicsEvents.h>
 #include <Atomic/Graphics/Graphics.h>
 #include <Atomic/Graphics/Camera.h>
+#include <Atomic/Graphics/Texture2D.h>
 #include <Atomic/UI/SystemUI/DebugHud.h>
 #include <Atomic/UI/SystemUI/SystemUIEvents.h>
 #include <Atomic/UI/UI.h>
@@ -76,6 +77,7 @@ PlayerMode::~PlayerMode()
 
 bool PlayerMode::Start()
 {
+    // If we aren't playing a scene, kick off the main.js if any
     if (!scenePath_.Length())
     {
         JSVM* vm = JSVM::GetJSVM(0);
@@ -88,7 +90,26 @@ bool PlayerMode::Start()
     }
     else
     {
-        GetSubsystem<AtomicPlayer::Player>()->LoadScene(scenePath_);
+        AtomicPlayer::Player* player = GetSubsystem<AtomicPlayer::Player>();
+        player->SetRenderToTexture(512, 512);
+
+        player->LoadScene(scenePath_);
+
+        using namespace IPCPlayerRenderTextureInfo;
+
+        VariantMap eventData;
+
+        Texture2D* texture = player->GetRenderTexture();
+
+        eventData[P_WIDTH] = texture->GetWidth();
+        eventData[P_HEIGHT] = texture->GetHeight();
+        eventData[P_FORMAT] = texture->GetFormat();
+        eventData[P_USAGE] = (unsigned) texture->GetUsage();
+        // Note: On D3D9/11 and MacGL this handle is 32 bit, any > 32 bit resource handle would need to be fixed here
+        eventData[P_RESOURCEHANDLE] = (unsigned) ((uintptr_t) texture->GetGPUSharedHandle());
+
+        ipc_->SendEventToBroker(E_IPCPLAYERRENDERTEXTUREINFO, eventData);
+
     }
 
     return true;

Source/AtomicPlayer/Player.cpp

@@ -25,8 +25,10 @@
 #include <Atomic/Input/InputEvents.h>
 
 #include <Atomic/Resource/ResourceCache.h>
+#include <Atomic/Graphics/Graphics.h>
 #include <Atomic/Graphics/Renderer.h>
 #include <Atomic/Graphics/Camera.h>
+#include <Atomic/Graphics/Texture2D.h>
 
 #include "Player.h"
 
@@ -34,10 +36,11 @@ namespace AtomicPlayer
 {
 
 Player::Player(Context* context) :
-    Object(context)
+    Object(context),
+    renderWidth_(0),
+    renderHeight_(0)
 {
     viewport_ = new Viewport(context_);
-    GetSubsystem<Renderer>()->SetViewport(0, viewport_);
 
     SubscribeToEvent(E_EXITREQUESTED, HANDLER(Player, HandleExitRequested));
 }
@@ -54,11 +57,37 @@ void Player::HandleExitRequested(StringHash eventType, VariantMap& eventData)
 
 }
 
+void Player::SetRenderToTexture(unsigned width, unsigned height)
+{
+    renderWidth_ = width;
+    renderHeight_ = height;
+
+    renderTexture_ = new Texture2D(context_);
+    depthTexture_ = new Texture2D(context_);
+
+    renderTexture_->SetGPUShared(true);
+
+    viewport_->SetRect(IntRect(0, 0, width, height));
+    renderTexture_->SetSize(width, height, Graphics::GetRGBFormat(), TEXTURE_RENDERTARGET);
+    depthTexture_->SetSize(width, height, Graphics::GetDepthStencilFormat(), TEXTURE_DEPTHSTENCIL);
+
+    RenderSurface* surface = renderTexture_->GetRenderSurface();
+    surface->SetViewport(0, viewport_);
+    surface->SetUpdateMode(SURFACE_UPDATEALWAYS );
+    surface->SetLinkedDepthStencil(depthTexture_->GetRenderSurface());
+}
+
 Scene* Player::LoadScene(const String& filename, Camera *camera)
 {
     ResourceCache* cache = GetSubsystem<ResourceCache>();
     SharedPtr<File> file = cache->GetFile(filename);
 
+    // If we're not rendering to texture and we haven't set the viewport, set it
+    if (renderTexture_.Null() && GetSubsystem<Renderer>()->GetViewport(0) != viewport_)
+    {
+        GetSubsystem<Renderer>()->SetViewport(0, viewport_);
+    }
+
     if (!file->IsOpen())
     {
         return 0;

Source/AtomicPlayer/Player.h

@@ -26,6 +26,11 @@
 #include <Atomic/Graphics/Viewport.h>
 #include <Atomic/Scene/Scene.h>
 
+namespace Atomic
+{
+    class Texture2D;
+}
+
 using namespace Atomic;
 
 namespace AtomicPlayer
@@ -42,19 +47,30 @@ public:
     /// Destruct.
     virtual ~Player();
 
+    void SetRenderToTexture(unsigned width, unsigned height);
+
     Scene* LoadScene(const String& filename, Camera* camera = NULL);
 
     Scene* GetCurrentScene() { return currentScene_; }
 
+    Texture2D* GetRenderTexture() const { return renderTexture_; }
+
 private:
 
     void HandleExitRequested(StringHash eventType, VariantMap& eventData);
 
     // Strong reference
     SharedPtr<Scene> currentScene_;
-
     SharedPtr<Viewport> viewport_;
 
+    /// Renderable texture.
+    SharedPtr<Texture2D> renderTexture_;
+    /// Depth stencil texture.
+    SharedPtr<Texture2D> depthTexture_;
+
+    unsigned renderWidth_;
+    unsigned renderHeight_;
+
 };
 
 }