Everything compiling again after moving preview renderer to atom tools framework

Signed-off-by: Guthrie Adams <guthadam@amazon.com>
monroegm-disable-blank-issue-2
Guthrie Adams 4 years ago
parent 569318e9e1
commit 76b4dafbb3

@ -36,6 +36,7 @@ ly_add_target(
Gem::Atom_RPI.Edit Gem::Atom_RPI.Edit
Gem::Atom_RPI.Public Gem::Atom_RPI.Public
Gem::Atom_RHI.Reflect Gem::Atom_RHI.Reflect
Gem::Atom_Feature_Common.Static
Gem::Atom_Bootstrap.Headers Gem::Atom_Bootstrap.Headers
) )

@ -10,26 +10,20 @@
#include <AzCore/Memory/Memory.h> #include <AzCore/Memory/Memory.h>
namespace AZ namespace AtomToolsFramework
{ {
namespace LyIntegration //! Provides custom rendering of previefw images
{ class PreviewContent
namespace Thumbnails
{
//! Provides custom rendering of preeview images
class CommonPreviewContent
{ {
public: public:
AZ_CLASS_ALLOCATOR(CommonPreviewContent, AZ::SystemAllocator, 0); AZ_CLASS_ALLOCATOR(PreviewContent, AZ::SystemAllocator, 0);
CommonPreviewContent() = default; PreviewContent() = default;
virtual ~CommonPreviewContent() = default; virtual ~PreviewContent() = default;
virtual void Load() = 0; virtual void Load() = 0;
virtual bool IsReady() const = 0; virtual bool IsReady() const = 0;
virtual bool IsError() const = 0; virtual bool IsError() const = 0;
virtual void ReportErrors() = 0; virtual void ReportErrors() = 0;
virtual void UpdateScene() = 0; virtual void UpdateScene() = 0;
}; };
} // namespace Thumbnails } // namespace AtomToolsFramework
} // namespace LyIntegration
} // namespace AZ

@ -10,10 +10,10 @@
#include <Atom/RPI.Public/Base.h> #include <Atom/RPI.Public/Base.h>
#include <Atom/RPI.Public/Pass/AttachmentReadback.h> #include <Atom/RPI.Public/Pass/AttachmentReadback.h>
#include <AtomLyIntegration/CommonFeatures/Thumbnails/PreviewerFeatureProcessorProviderBus.h> #include <AtomToolsFramework/PreviewRenderer/PreviewContent.h>
#include <AtomToolsFramework/PreviewRenderer/PreviewRendererState.h>
#include <AtomToolsFramework/PreviewRenderer/PreviewerFeatureProcessorProviderBus.h>
#include <AzFramework/Entity/GameEntityContextComponent.h> #include <AzFramework/Entity/GameEntityContextComponent.h>
#include <Thumbnails/Rendering/CommonPreviewContent.h>
#include <Thumbnails/Rendering/CommonPreviewRendererState.h>
namespace AzFramework namespace AzFramework
{ {
@ -22,32 +22,27 @@ namespace AzFramework
class QImage; class QImage;
namespace AZ namespace AtomToolsFramework
{ {
namespace LyIntegration //! Provides custom rendering of preview images
{ class PreviewRenderer final : public PreviewerFeatureProcessorProviderBus::Handler
namespace Thumbnails
{
//! Provides custom rendering of material and model thumbnails
class CommonPreviewRenderer final
: public PreviewerFeatureProcessorProviderBus::Handler
{ {
public: public:
AZ_CLASS_ALLOCATOR(CommonPreviewRenderer, AZ::SystemAllocator, 0); AZ_CLASS_ALLOCATOR(PreviewRenderer, AZ::SystemAllocator, 0);
CommonPreviewRenderer(); PreviewRenderer();
~CommonPreviewRenderer(); ~PreviewRenderer();
struct CaptureRequest final struct CaptureRequest final
{ {
int m_size = 512; int m_size = 512;
AZStd::shared_ptr<CommonPreviewContent> m_content; AZStd::shared_ptr<PreviewContent> m_content;
AZStd::function<void()> m_captureFailedCallback; AZStd::function<void()> m_captureFailedCallback;
AZStd::function<void(const QImage&)> m_captureCompleteCallback; AZStd::function<void(const QImage&)> m_captureCompleteCallback;
}; };
RPI::ScenePtr GetScene() const; AZ::RPI::ScenePtr GetScene() const;
RPI::ViewPtr GetView() const; AZ::RPI::ViewPtr GetView() const;
AZ::Uuid GetEntityContextId() const; AZ::Uuid GetEntityContextId() const;
void AddCaptureRequest(const CaptureRequest& captureRequest); void AddCaptureRequest(const CaptureRequest& captureRequest);
@ -77,20 +72,20 @@ namespace AZ
void EndCapture(); void EndCapture();
private: private:
//! Render::PreviewerFeatureProcessorProviderBus::Handler interface overrides... //! AZ::Render::PreviewerFeatureProcessorProviderBus::Handler interface overrides...
void GetRequiredFeatureProcessors(AZStd::unordered_set<AZStd::string>& featureProcessors) const override; void GetRequiredFeatureProcessors(AZStd::unordered_set<AZStd::string>& featureProcessors) const override;
static constexpr float AspectRatio = 1.0f; static constexpr float AspectRatio = 1.0f;
static constexpr float NearDist = 0.001f; static constexpr float NearDist = 0.001f;
static constexpr float FarDist = 100.0f; static constexpr float FarDist = 100.0f;
static constexpr float FieldOfView = Constants::HalfPi; static constexpr float FieldOfView = AZ::Constants::HalfPi;
RPI::ScenePtr m_scene; AZ::RPI::ScenePtr m_scene;
AZStd::string m_sceneName = "Material Thumbnail Scene"; AZStd::string m_sceneName = "Preview Renderer Scene";
AZStd::string m_pipelineName = "Material Thumbnail Pipeline"; AZStd::string m_pipelineName = "Preview Renderer Pipeline";
AZStd::shared_ptr<AzFramework::Scene> m_frameworkScene; AZStd::shared_ptr<AzFramework::Scene> m_frameworkScene;
RPI::RenderPipelinePtr m_renderPipeline; AZ::RPI::RenderPipelinePtr m_renderPipeline;
RPI::ViewPtr m_view; AZ::RPI::ViewPtr m_view;
AZStd::vector<AZStd::string> m_passHierarchy; AZStd::vector<AZStd::string> m_passHierarchy;
AZStd::unique_ptr<AzFramework::EntityContext> m_entityContext; AZStd::unique_ptr<AzFramework::EntityContext> m_entityContext;
@ -98,9 +93,7 @@ namespace AZ
AZStd::queue<CaptureRequest> m_captureRequestQueue; AZStd::queue<CaptureRequest> m_captureRequestQueue;
CaptureRequest m_currentCaptureRequest; CaptureRequest m_currentCaptureRequest;
AZStd::unordered_map<State, AZStd::shared_ptr<CommonPreviewRendererState>> m_states; AZStd::unordered_map<State, AZStd::shared_ptr<PreviewRendererState>> m_states;
State m_currentState = CommonPreviewRenderer::State::None; State m_currentState = PreviewRenderer::State::None;
}; };
} // namespace Thumbnails } // namespace AtomToolsFramework
} // namespace LyIntegration
} // namespace AZ

@ -0,0 +1,35 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#pragma once
namespace AtomToolsFramework
{
class PreviewRenderer;
//! PreviewRendererState decouples PreviewRenderer logic into easy-to-understand and debug pieces
class PreviewRendererState
{
public:
explicit PreviewRendererState(PreviewRenderer* renderer)
: m_renderer(renderer)
{
}
virtual ~PreviewRendererState() = default;
//! Start is called when state begins execution
virtual void Start() = 0;
//! Stop is called when state ends execution
virtual void Stop() = 0;
protected:
PreviewRenderer* m_renderer = {};
};
} // namespace AtomToolsFramework

@ -0,0 +1,25 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#pragma once
#include <AzCore/EBus/EBus.h>
#include <AzCore/std/containers/unordered_set.h>
#include <AzCore/std/string/string.h>
namespace AtomToolsFramework
{
//! PreviewerFeatureProcessorProviderRequests allows registering custom Feature Processors for preview image generation
class PreviewerFeatureProcessorProviderRequests : public AZ::EBusTraits
{
public:
//! Get a list of custom feature processors to register with preview image renderer
virtual void GetRequiredFeatureProcessors(AZStd::unordered_set<AZStd::string>& featureProcessors) const = 0;
};
using PreviewerFeatureProcessorProviderBus = AZ::EBus<PreviewerFeatureProcessorProviderRequests>;
} // namespace AtomToolsFramework

@ -25,7 +25,7 @@
namespace AtomToolsFramework namespace AtomToolsFramework
{ {
//! The RenderViewportWidget class is a Qt wrapper around an Atom viewport. //! The RenderViewportWidget class is a Qt wrapper around an Atom viewport.
//! RenderViewportWidget renders to an internal window using RPI::ViewportContext //! RenderViewportWidget renders to an internal window using AZ::RPI::ViewportContext
//! and delegates input via its internal ViewportControllerList. //! and delegates input via its internal ViewportControllerList.
//! @see AZ::RPI::ViewportContext for Atom's API for setting up //! @see AZ::RPI::ViewportContext for Atom's API for setting up
class RenderViewportWidget class RenderViewportWidget
@ -39,7 +39,7 @@ namespace AtomToolsFramework
public: public:
//! Creates a RenderViewportWidget. //! Creates a RenderViewportWidget.
//! Requires the Atom RPI to be initialized in order //! Requires the Atom RPI to be initialized in order
//! to internally construct an RPI::ViewportContext. //! to internally construct an AZ::RPI::ViewportContext.
//! If initializeViewportContext is set to false, nothing will be displayed on-screen until InitiliazeViewportContext is called. //! If initializeViewportContext is set to false, nothing will be displayed on-screen until InitiliazeViewportContext is called.
explicit RenderViewportWidget(QWidget* parent = nullptr, bool shouldInitializeViewportContext = true); explicit RenderViewportWidget(QWidget* parent = nullptr, bool shouldInitializeViewportContext = true);
~RenderViewportWidget(); ~RenderViewportWidget();

@ -15,22 +15,18 @@
#include <Atom/RPI.Public/View.h> #include <Atom/RPI.Public/View.h>
#include <Atom/RPI.Reflect/System/RenderPipelineDescriptor.h> #include <Atom/RPI.Reflect/System/RenderPipelineDescriptor.h>
#include <Atom/RPI.Reflect/System/SceneDescriptor.h> #include <Atom/RPI.Reflect/System/SceneDescriptor.h>
#include <AtomToolsFramework/PreviewRenderer/PreviewRenderer.h>
#include <AzCore/Math/MatrixUtils.h> #include <AzCore/Math/MatrixUtils.h>
#include <AzCore/Math/Transform.h> #include <AzCore/Math/Transform.h>
#include <AzFramework/Scene/Scene.h> #include <AzFramework/Scene/Scene.h>
#include <AzFramework/Scene/SceneSystemInterface.h> #include <AzFramework/Scene/SceneSystemInterface.h>
#include <Thumbnails/Rendering/CommonPreviewRenderer.h> #include <PreviewRenderer/PreviewRendererCaptureState.h>
#include <Thumbnails/Rendering/CommonPreviewRendererCaptureState.h> #include <PreviewRenderer/PreviewRendererIdleState.h>
#include <Thumbnails/Rendering/CommonPreviewRendererIdleState.h> #include <PreviewRenderer/PreviewRendererLoadState.h>
#include <Thumbnails/Rendering/CommonPreviewRendererLoadState.h>
namespace AZ namespace AtomToolsFramework
{ {
namespace LyIntegration PreviewRenderer::PreviewRenderer()
{
namespace Thumbnails
{
CommonPreviewRenderer::CommonPreviewRenderer()
{ {
PreviewerFeatureProcessorProviderBus::Handler::BusConnect(); PreviewerFeatureProcessorProviderBus::Handler::BusConnect();
@ -42,15 +38,15 @@ namespace AZ
PreviewerFeatureProcessorProviderBus::Broadcast( PreviewerFeatureProcessorProviderBus::Broadcast(
&PreviewerFeatureProcessorProviderBus::Handler::GetRequiredFeatureProcessors, featureProcessors); &PreviewerFeatureProcessorProviderBus::Handler::GetRequiredFeatureProcessors, featureProcessors);
RPI::SceneDescriptor sceneDesc; AZ::RPI::SceneDescriptor sceneDesc;
sceneDesc.m_featureProcessorNames.assign(featureProcessors.begin(), featureProcessors.end()); sceneDesc.m_featureProcessorNames.assign(featureProcessors.begin(), featureProcessors.end());
m_scene = RPI::Scene::CreateScene(sceneDesc); m_scene = AZ::RPI::Scene::CreateScene(sceneDesc);
// Bind m_frameworkScene to the entity context's AzFramework::Scene // Bind m_frameworkScene to the entity context's AzFramework::Scene
auto sceneSystem = AzFramework::SceneSystemInterface::Get(); auto sceneSystem = AzFramework::SceneSystemInterface::Get();
AZ_Assert(sceneSystem, "Failed to get scene system implementation."); AZ_Assert(sceneSystem, "Failed to get scene system implementation.");
Outcome<AZStd::shared_ptr<AzFramework::Scene>, AZStd::string> createSceneOutcome = sceneSystem->CreateScene(m_sceneName); AZ::Outcome<AZStd::shared_ptr<AzFramework::Scene>, AZStd::string> createSceneOutcome = sceneSystem->CreateScene(m_sceneName);
AZ_Assert(createSceneOutcome, createSceneOutcome.GetError().c_str()); AZ_Assert(createSceneOutcome, createSceneOutcome.GetError().c_str());
m_frameworkScene = createSceneOutcome.TakeValue(); m_frameworkScene = createSceneOutcome.TakeValue();
@ -58,7 +54,7 @@ namespace AZ
m_frameworkScene->SetSubsystem(m_entityContext.get()); m_frameworkScene->SetSubsystem(m_entityContext.get());
// Create a render pipeline from the specified asset for the window context and add the pipeline to the scene // Create a render pipeline from the specified asset for the window context and add the pipeline to the scene
RPI::RenderPipelineDescriptor pipelineDesc; AZ::RPI::RenderPipelineDescriptor pipelineDesc;
pipelineDesc.m_mainViewTagName = "MainCamera"; pipelineDesc.m_mainViewTagName = "MainCamera";
pipelineDesc.m_name = m_pipelineName; pipelineDesc.m_name = m_pipelineName;
pipelineDesc.m_rootPassTemplate = "MainPipelineRenderToTexture"; pipelineDesc.m_rootPassTemplate = "MainPipelineRenderToTexture";
@ -66,62 +62,62 @@ namespace AZ
// We have to set the samples to 4 to match the pipeline passes' setting, otherwise it may lead to device lost issue // We have to set the samples to 4 to match the pipeline passes' setting, otherwise it may lead to device lost issue
// [GFX TODO] [ATOM-13551] Default value sand validation required to prevent pipeline crash and device lost // [GFX TODO] [ATOM-13551] Default value sand validation required to prevent pipeline crash and device lost
pipelineDesc.m_renderSettings.m_multisampleState.m_samples = 4; pipelineDesc.m_renderSettings.m_multisampleState.m_samples = 4;
m_renderPipeline = RPI::RenderPipeline::CreateRenderPipeline(pipelineDesc); m_renderPipeline = AZ::RPI::RenderPipeline::CreateRenderPipeline(pipelineDesc);
m_scene->AddRenderPipeline(m_renderPipeline); m_scene->AddRenderPipeline(m_renderPipeline);
m_scene->Activate(); m_scene->Activate();
RPI::RPISystemInterface::Get()->RegisterScene(m_scene); AZ::RPI::RPISystemInterface::Get()->RegisterScene(m_scene);
m_passHierarchy.push_back(m_pipelineName); m_passHierarchy.push_back(m_pipelineName);
m_passHierarchy.push_back("CopyToSwapChain"); m_passHierarchy.push_back("CopyToSwapChain");
// Connect camera to pipeline's default view after camera entity activated // Connect camera to pipeline's default view after camera entity activated
Matrix4x4 viewToClipMatrix; AZ::Matrix4x4 viewToClipMatrix;
MakePerspectiveFovMatrixRH(viewToClipMatrix, FieldOfView, AspectRatio, NearDist, FarDist, true); AZ::MakePerspectiveFovMatrixRH(viewToClipMatrix, FieldOfView, AspectRatio, NearDist, FarDist, true);
m_view = RPI::View::CreateView(Name("MainCamera"), RPI::View::UsageCamera); m_view = AZ::RPI::View::CreateView(AZ::Name("MainCamera"), AZ::RPI::View::UsageCamera);
m_view->SetViewToClipMatrix(viewToClipMatrix); m_view->SetViewToClipMatrix(viewToClipMatrix);
m_renderPipeline->SetDefaultView(m_view); m_renderPipeline->SetDefaultView(m_view);
m_states[CommonPreviewRenderer::State::IdleState] = AZStd::make_shared<CommonPreviewRendererIdleState>(this); m_states[PreviewRenderer::State::IdleState] = AZStd::make_shared<PreviewRendererIdleState>(this);
m_states[CommonPreviewRenderer::State::LoadState] = AZStd::make_shared<CommonPreviewRendererLoadState>(this); m_states[PreviewRenderer::State::LoadState] = AZStd::make_shared<PreviewRendererLoadState>(this);
m_states[CommonPreviewRenderer::State::CaptureState] = AZStd::make_shared<CommonPreviewRendererCaptureState>(this); m_states[PreviewRenderer::State::CaptureState] = AZStd::make_shared<PreviewRendererCaptureState>(this);
SetState(CommonPreviewRenderer::State::IdleState); SetState(PreviewRenderer::State::IdleState);
} }
CommonPreviewRenderer::~CommonPreviewRenderer() PreviewRenderer::~PreviewRenderer()
{ {
PreviewerFeatureProcessorProviderBus::Handler::BusDisconnect(); PreviewerFeatureProcessorProviderBus::Handler::BusDisconnect();
SetState(CommonPreviewRenderer::State::None); SetState(PreviewRenderer::State::None);
m_currentCaptureRequest = {}; m_currentCaptureRequest = {};
m_captureRequestQueue = {}; m_captureRequestQueue = {};
m_scene->Deactivate(); m_scene->Deactivate();
m_scene->RemoveRenderPipeline(m_renderPipeline->GetId()); m_scene->RemoveRenderPipeline(m_renderPipeline->GetId());
RPI::RPISystemInterface::Get()->UnregisterScene(m_scene); AZ::RPI::RPISystemInterface::Get()->UnregisterScene(m_scene);
m_frameworkScene->UnsetSubsystem(m_scene); m_frameworkScene->UnsetSubsystem(m_scene);
m_frameworkScene->UnsetSubsystem(m_entityContext.get()); m_frameworkScene->UnsetSubsystem(m_entityContext.get());
} }
RPI::ScenePtr CommonPreviewRenderer::GetScene() const AZ::RPI::ScenePtr PreviewRenderer::GetScene() const
{ {
return m_scene; return m_scene;
} }
RPI::ViewPtr CommonPreviewRenderer::GetView() const AZ::RPI::ViewPtr PreviewRenderer::GetView() const
{ {
return m_view; return m_view;
} }
AZ::Uuid CommonPreviewRenderer::GetEntityContextId() const AZ::Uuid PreviewRenderer::GetEntityContextId() const
{ {
return m_entityContext->GetContextId(); return m_entityContext->GetContextId();
} }
void CommonPreviewRenderer::AddCaptureRequest(const CaptureRequest& captureRequest) void PreviewRenderer::AddCaptureRequest(const CaptureRequest& captureRequest)
{ {
m_captureRequestQueue.push(captureRequest); m_captureRequestQueue.push(captureRequest);
} }
void CommonPreviewRenderer::SetState(State state) void PreviewRenderer::SetState(State state)
{ {
auto stepItr = m_states.find(m_currentState); auto stepItr = m_states.find(m_currentState);
if (stepItr != m_states.end()) if (stepItr != m_states.end())
@ -138,12 +134,12 @@ namespace AZ
} }
} }
CommonPreviewRenderer::State CommonPreviewRenderer::GetState() const PreviewRenderer::State PreviewRenderer::GetState() const
{ {
return m_currentState; return m_currentState;
} }
void CommonPreviewRenderer::SelectCaptureRequest() void PreviewRenderer::SelectCaptureRequest()
{ {
if (!m_captureRequestQueue.empty()) if (!m_captureRequestQueue.empty())
{ {
@ -151,31 +147,31 @@ namespace AZ
m_currentCaptureRequest = m_captureRequestQueue.front(); m_currentCaptureRequest = m_captureRequestQueue.front();
m_captureRequestQueue.pop(); m_captureRequestQueue.pop();
SetState(CommonPreviewRenderer::State::LoadState); SetState(PreviewRenderer::State::LoadState);
} }
} }
void CommonPreviewRenderer::CancelCaptureRequest() void PreviewRenderer::CancelCaptureRequest()
{ {
m_currentCaptureRequest.m_captureFailedCallback(); m_currentCaptureRequest.m_captureFailedCallback();
SetState(CommonPreviewRenderer::State::IdleState); SetState(PreviewRenderer::State::IdleState);
} }
void CommonPreviewRenderer::CompleteCaptureRequest() void PreviewRenderer::CompleteCaptureRequest()
{ {
SetState(CommonPreviewRenderer::State::IdleState); SetState(PreviewRenderer::State::IdleState);
} }
void CommonPreviewRenderer::LoadAssets() void PreviewRenderer::LoadAssets()
{ {
m_currentCaptureRequest.m_content->Load(); m_currentCaptureRequest.m_content->Load();
} }
void CommonPreviewRenderer::UpdateLoadAssets() void PreviewRenderer::UpdateLoadAssets()
{ {
if (m_currentCaptureRequest.m_content->IsReady()) if (m_currentCaptureRequest.m_content->IsReady())
{ {
SetState(CommonPreviewRenderer::State::CaptureState); SetState(PreviewRenderer::State::CaptureState);
return; return;
} }
@ -186,27 +182,26 @@ namespace AZ
} }
} }
void CommonPreviewRenderer::CancelLoadAssets() void PreviewRenderer::CancelLoadAssets()
{ {
m_currentCaptureRequest.m_content->ReportErrors(); m_currentCaptureRequest.m_content->ReportErrors();
CancelCaptureRequest(); CancelCaptureRequest();
} }
void CommonPreviewRenderer::UpdateScene() void PreviewRenderer::UpdateScene()
{ {
m_currentCaptureRequest.m_content->UpdateScene(); m_currentCaptureRequest.m_content->UpdateScene();
} }
bool CommonPreviewRenderer::StartCapture() bool PreviewRenderer::StartCapture()
{ {
auto captureCallback = auto captureCallback = [currentCaptureRequest = m_currentCaptureRequest](const AZ::RPI::AttachmentReadback::ReadbackResult& result)
[currentCaptureRequest = m_currentCaptureRequest](const RPI::AttachmentReadback::ReadbackResult& result)
{ {
if (result.m_dataBuffer) if (result.m_dataBuffer)
{ {
currentCaptureRequest.m_captureCompleteCallback(QImage( currentCaptureRequest.m_captureCompleteCallback(QImage(
result.m_dataBuffer.get()->data(), result.m_imageDescriptor.m_size.m_width, result.m_dataBuffer.get()->data(), result.m_imageDescriptor.m_size.m_width, result.m_imageDescriptor.m_size.m_height,
result.m_imageDescriptor.m_size.m_height, QImage::Format_RGBA8888)); QImage::Format_RGBA8888));
} }
else else
{ {
@ -222,18 +217,18 @@ namespace AZ
m_renderPipeline->AddToRenderTickOnce(); m_renderPipeline->AddToRenderTickOnce();
bool startedCapture = false; bool startedCapture = false;
Render::FrameCaptureRequestBus::BroadcastResult( AZ::Render::FrameCaptureRequestBus::BroadcastResult(
startedCapture, &Render::FrameCaptureRequestBus::Events::CapturePassAttachmentWithCallback, m_passHierarchy, startedCapture, &AZ::Render::FrameCaptureRequestBus::Events::CapturePassAttachmentWithCallback, m_passHierarchy,
AZStd::string("Output"), captureCallback, RPI::PassAttachmentReadbackOption::Output); AZStd::string("Output"), captureCallback, AZ::RPI::PassAttachmentReadbackOption::Output);
return startedCapture; return startedCapture;
} }
void CommonPreviewRenderer::EndCapture() void PreviewRenderer::EndCapture()
{ {
m_renderPipeline->RemoveFromRenderTick(); m_renderPipeline->RemoveFromRenderTick();
} }
void CommonPreviewRenderer::GetRequiredFeatureProcessors(AZStd::unordered_set<AZStd::string>& featureProcessors) const void PreviewRenderer::GetRequiredFeatureProcessors(AZStd::unordered_set<AZStd::string>& featureProcessors) const
{ {
featureProcessors.insert({ featureProcessors.insert({
"AZ::Render::TransformServiceFeatureProcessor", "AZ::Render::TransformServiceFeatureProcessor",
@ -254,6 +249,4 @@ namespace AZ
"AZ::Render::PostProcessFeatureProcessor", "AZ::Render::PostProcessFeatureProcessor",
"AZ::Render::SkyBoxFeatureProcessor" }); "AZ::Render::SkyBoxFeatureProcessor" });
} }
} // namespace Thumbnails } // namespace AtomToolsFramework
} // namespace LyIntegration
} // namespace AZ

@ -6,52 +6,46 @@
* *
*/ */
#include <Thumbnails/Rendering/CommonPreviewRenderer.h> #include <AtomToolsFramework/PreviewRenderer/PreviewRenderer.h>
#include <Thumbnails/Rendering/CommonPreviewRendererCaptureState.h> #include <PreviewRenderer/PreviewRendererCaptureState.h>
namespace AZ namespace AtomToolsFramework
{ {
namespace LyIntegration PreviewRendererCaptureState::PreviewRendererCaptureState(PreviewRenderer* renderer)
{ : PreviewRendererState(renderer)
namespace Thumbnails
{
CommonPreviewRendererCaptureState::CommonPreviewRendererCaptureState(CommonPreviewRenderer* renderer)
: CommonPreviewRendererState(renderer)
{ {
} }
void CommonPreviewRendererCaptureState::Start() void PreviewRendererCaptureState::Start()
{ {
m_ticksToCapture = 1; m_ticksToCapture = 1;
m_renderer->UpdateScene(); m_renderer->UpdateScene();
TickBus::Handler::BusConnect(); AZ::TickBus::Handler::BusConnect();
} }
void CommonPreviewRendererCaptureState::Stop() void PreviewRendererCaptureState::Stop()
{ {
m_renderer->EndCapture(); m_renderer->EndCapture();
TickBus::Handler::BusDisconnect(); AZ::TickBus::Handler::BusDisconnect();
Render::FrameCaptureNotificationBus::Handler::BusDisconnect(); AZ::Render::FrameCaptureNotificationBus::Handler::BusDisconnect();
} }
void CommonPreviewRendererCaptureState::OnTick([[maybe_unused]] float deltaTime, [[maybe_unused]] ScriptTimePoint time) void PreviewRendererCaptureState::OnTick([[maybe_unused]] float deltaTime, [[maybe_unused]] AZ::ScriptTimePoint time)
{ {
if (m_ticksToCapture-- <= 0) if (m_ticksToCapture-- <= 0)
{ {
// Reset the capture flag if the capture request was successful. Otherwise try capture it again next tick. // Reset the capture flag if the capture request was successful. Otherwise try capture it again next tick.
if (m_renderer->StartCapture()) if (m_renderer->StartCapture())
{ {
Render::FrameCaptureNotificationBus::Handler::BusConnect(); AZ::Render::FrameCaptureNotificationBus::Handler::BusConnect();
TickBus::Handler::BusDisconnect(); AZ::TickBus::Handler::BusDisconnect();
} }
} }
} }
void CommonPreviewRendererCaptureState::OnCaptureFinished( void PreviewRendererCaptureState::OnCaptureFinished(
[[maybe_unused]] Render::FrameCaptureResult result, [[maybe_unused]] const AZStd::string& info) [[maybe_unused]] AZ::Render::FrameCaptureResult result, [[maybe_unused]] const AZStd::string& info)
{ {
m_renderer->CompleteCaptureRequest(); m_renderer->CompleteCaptureRequest();
} }
} // namespace Thumbnails } // namespace AtomToolsFramework
} // namespace LyIntegration
} // namespace AZ

@ -9,23 +9,19 @@
#pragma once #pragma once
#include <Atom/Feature/Utils/FrameCaptureBus.h> #include <Atom/Feature/Utils/FrameCaptureBus.h>
#include <AtomToolsFramework/PreviewRenderer/PreviewRendererState.h>
#include <AzCore/Component/TickBus.h> #include <AzCore/Component/TickBus.h>
#include <Thumbnails/Rendering/CommonPreviewRendererState.h>
namespace AZ namespace AtomToolsFramework
{ {
namespace LyIntegration //! PreviewRendererCaptureState renders a thumbnail to a pixmap and notifies MaterialOrModelThumbnail once finished
{ class PreviewRendererCaptureState final
namespace Thumbnails : public PreviewRendererState
{ , public AZ::TickBus::Handler
//! CommonPreviewRendererCaptureState renders a thumbnail to a pixmap and notifies MaterialOrModelThumbnail once finished , public AZ::Render::FrameCaptureNotificationBus::Handler
class CommonPreviewRendererCaptureState
: public CommonPreviewRendererState
, private TickBus::Handler
, private Render::FrameCaptureNotificationBus::Handler
{ {
public: public:
CommonPreviewRendererCaptureState(CommonPreviewRenderer* renderer); PreviewRendererCaptureState(PreviewRenderer* renderer);
void Start() override; void Start() override;
void Stop() override; void Stop() override;
@ -34,13 +30,10 @@ namespace AZ
//! AZ::TickBus::Handler interface overrides... //! AZ::TickBus::Handler interface overrides...
void OnTick(float deltaTime, AZ::ScriptTimePoint time) override; void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
//! Render::FrameCaptureNotificationBus::Handler overrides... //! AZ::Render::FrameCaptureNotificationBus::Handler overrides...
void OnCaptureFinished(Render::FrameCaptureResult result, const AZStd::string& info) override; void OnCaptureFinished(AZ::Render::FrameCaptureResult result, const AZStd::string& info) override;
//! This is necessary to suspend capture to allow a frame for Material and Mesh components to assign materials //! This is necessary to suspend capture to allow a frame for Material and Mesh components to assign materials
int m_ticksToCapture = 0; int m_ticksToCapture = 0;
}; };
} // namespace Thumbnails } // namespace AtomToolsFramework
} // namespace LyIntegration
} // namespace AZ

@ -6,34 +6,28 @@
* *
*/ */
#include <Thumbnails/Rendering/CommonPreviewRenderer.h> #include <AtomToolsFramework/PreviewRenderer/PreviewRenderer.h>
#include <Thumbnails/Rendering/CommonPreviewRendererIdleState.h> #include <PreviewRenderer/PreviewRendererIdleState.h>
namespace AZ namespace AtomToolsFramework
{ {
namespace LyIntegration PreviewRendererIdleState::PreviewRendererIdleState(PreviewRenderer* renderer)
{ : PreviewRendererState(renderer)
namespace Thumbnails
{
CommonPreviewRendererIdleState::CommonPreviewRendererIdleState(CommonPreviewRenderer* renderer)
: CommonPreviewRendererState(renderer)
{ {
} }
void CommonPreviewRendererIdleState::Start() void PreviewRendererIdleState::Start()
{ {
TickBus::Handler::BusConnect(); AZ::TickBus::Handler::BusConnect();
} }
void CommonPreviewRendererIdleState::Stop() void PreviewRendererIdleState::Stop()
{ {
TickBus::Handler::BusDisconnect(); AZ::TickBus::Handler::BusDisconnect();
} }
void CommonPreviewRendererIdleState::OnTick([[maybe_unused]] float deltaTime, [[maybe_unused]] ScriptTimePoint time) void PreviewRendererIdleState::OnTick([[maybe_unused]] float deltaTime, [[maybe_unused]] AZ::ScriptTimePoint time)
{ {
m_renderer->SelectCaptureRequest(); m_renderer->SelectCaptureRequest();
} }
} // namespace Thumbnails } // namespace AtomToolsFramework
} // namespace LyIntegration
} // namespace AZ

@ -8,31 +8,24 @@
#pragma once #pragma once
#include <Thumbnails/Rendering/CommonPreviewRendererState.h> #include <AtomToolsFramework/PreviewRenderer/PreviewRendererState.h>
#include <AzCore/Component/TickBus.h>
namespace AZ namespace AtomToolsFramework
{ {
namespace LyIntegration //! PreviewRendererIdleState checks whether there are any new thumbnails that need to be rendered every tick
{ class PreviewRendererIdleState final
namespace Thumbnails : public PreviewRendererState
{ , public AZ::TickBus::Handler
//! CommonPreviewRendererIdleState checks whether there are any new thumbnails that need to be rendered every tick
class CommonPreviewRendererIdleState
: public CommonPreviewRendererState
, private TickBus::Handler
{ {
public: public:
CommonPreviewRendererIdleState(CommonPreviewRenderer* renderer); PreviewRendererIdleState(PreviewRenderer* renderer);
void Start() override; void Start() override;
void Stop() override; void Stop() override;
private: private:
//! AZ::TickBus::Handler interface overrides... //! AZ::TickBus::Handler interface overrides...
void OnTick(float deltaTime, AZ::ScriptTimePoint time) override; void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
}; };
} // namespace Thumbnails } // namespace AtomToolsFramework
} // namespace LyIntegration
} // namespace AZ

@ -6,33 +6,29 @@
* *
*/ */
#include <Thumbnails/Rendering/CommonPreviewRenderer.h> #include <AtomToolsFramework/PreviewRenderer/PreviewRenderer.h>
#include <Thumbnails/Rendering/CommonPreviewRendererLoadState.h> #include <PreviewRenderer/PreviewRendererLoadState.h>
namespace AZ namespace AtomToolsFramework
{ {
namespace LyIntegration PreviewRendererLoadState::PreviewRendererLoadState(PreviewRenderer* renderer)
{ : PreviewRendererState(renderer)
namespace Thumbnails
{
CommonPreviewRendererLoadState::CommonPreviewRendererLoadState(CommonPreviewRenderer* renderer)
: CommonPreviewRendererState(renderer)
{ {
} }
void CommonPreviewRendererLoadState::Start() void PreviewRendererLoadState::Start()
{ {
m_renderer->LoadAssets(); m_renderer->LoadAssets();
m_timeRemainingS = TimeOutS; m_timeRemainingS = TimeOutS;
TickBus::Handler::BusConnect(); AZ::TickBus::Handler::BusConnect();
} }
void CommonPreviewRendererLoadState::Stop() void PreviewRendererLoadState::Stop()
{ {
TickBus::Handler::BusDisconnect(); AZ::TickBus::Handler::BusDisconnect();
} }
void CommonPreviewRendererLoadState::OnTick(float deltaTime, [[maybe_unused]] AZ::ScriptTimePoint time) void PreviewRendererLoadState::OnTick(float deltaTime, [[maybe_unused]] AZ::ScriptTimePoint time)
{ {
m_timeRemainingS -= deltaTime; m_timeRemainingS -= deltaTime;
if (m_timeRemainingS > 0.0f) if (m_timeRemainingS > 0.0f)
@ -44,6 +40,4 @@ namespace AZ
m_renderer->CancelLoadAssets(); m_renderer->CancelLoadAssets();
} }
} }
} // namespace Thumbnails } // namespace AtomToolsFramework
} // namespace LyIntegration
} // namespace AZ

@ -9,21 +9,17 @@
#pragma once #pragma once
#include <AzCore/Component/TickBus.h> #include <AzCore/Component/TickBus.h>
#include <Thumbnails/Rendering/CommonPreviewRendererState.h> #include <AtomToolsFramework/PreviewRenderer/PreviewRendererState.h>
namespace AZ namespace AtomToolsFramework
{ {
namespace LyIntegration //! PreviewRendererLoadState pauses further rendering until all assets used for rendering a thumbnail have been loaded
{ class PreviewRendererLoadState final
namespace Thumbnails : public PreviewRendererState
{ , public AZ::TickBus::Handler
//! CommonPreviewRendererLoadState pauses further rendering until all assets used for rendering a thumbnail have been loaded
class CommonPreviewRendererLoadState
: public CommonPreviewRendererState
, private TickBus::Handler
{ {
public: public:
CommonPreviewRendererLoadState(CommonPreviewRenderer* renderer); PreviewRendererLoadState(PreviewRenderer* renderer);
void Start() override; void Start() override;
void Stop() override; void Stop() override;
@ -35,7 +31,4 @@ namespace AZ
static constexpr float TimeOutS = 5.0f; static constexpr float TimeOutS = 5.0f;
float m_timeRemainingS = TimeOutS; float m_timeRemainingS = TimeOutS;
}; };
} // namespace Thumbnails } // namespace AtomToolsFramework
} // namespace LyIntegration
} // namespace AZ

@ -1,37 +0,0 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#pragma once
namespace AZ
{
namespace LyIntegration
{
namespace Thumbnails
{
class CommonPreviewRenderer;
//! CommonPreviewRendererState decouples CommonPreviewRenderer logic into easy-to-understand and debug pieces
class CommonPreviewRendererState
{
public:
explicit CommonPreviewRendererState(CommonPreviewRenderer* renderer) : m_renderer(renderer) {}
virtual ~CommonPreviewRendererState() = default;
//! Start is called when state begins execution
virtual void Start() {}
//! Stop is called when state ends execution
virtual void Stop() {}
protected:
CommonPreviewRenderer* m_renderer;
};
} // namespace Thumbnails
} // namespace LyIntegration
} // namespace AZ

@ -58,4 +58,15 @@ set(FILES
Source/Window/AtomToolsMainWindow.cpp Source/Window/AtomToolsMainWindow.cpp
Source/Window/AtomToolsMainWindowSystemComponent.cpp Source/Window/AtomToolsMainWindowSystemComponent.cpp
Source/Window/AtomToolsMainWindowSystemComponent.h Source/Window/AtomToolsMainWindowSystemComponent.h
Include/AtomToolsFramework/PreviewRenderer/PreviewContent.h
Include/AtomToolsFramework/PreviewRenderer/PreviewRenderer.h
Include/AtomToolsFramework/PreviewRenderer/PreviewRendererState.h
Include/AtomToolsFramework/PreviewRenderer/PreviewerFeatureProcessorProviderBus.h
Source/PreviewRenderer/PreviewRenderer.cpp
Source/PreviewRenderer/PreviewRendererIdleState.cpp
Source/PreviewRenderer/PreviewRendererIdleState.h
Source/PreviewRenderer/PreviewRendererLoadState.cpp
Source/PreviewRenderer/PreviewRendererLoadState.h
Source/PreviewRenderer/PreviewRendererCaptureState.cpp
Source/PreviewRenderer/PreviewRendererCaptureState.h
) )

@ -1,33 +0,0 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#pragma once
#include <AzCore/EBus/EBus.h>
#include <AzCore/std/string/string.h>
namespace AZ
{
namespace LyIntegration
{
namespace Thumbnails
{
//! PreviewerFeatureProcessorProviderRequests allows registering custom Feature Processors for preview image generation
//! Duplicates will be ignored
//! You can check minimal feature processors that are already registered in CommonPreviewRenderer.cpp
class PreviewerFeatureProcessorProviderRequests
: public AZ::EBusTraits
{
public:
//! Get a list of custom feature processors to register with preview image renderer
virtual void GetRequiredFeatureProcessors(AZStd::unordered_set<AZStd::string>& featureProcessors) const = 0;
};
using PreviewerFeatureProcessorProviderBus = AZ::EBus<PreviewerFeatureProcessorProviderRequests>;
} // namespace Thumbnails
} // namespace LyIntegration
} // namespace AZ

@ -13,7 +13,7 @@
#include <Atom/RPI.Reflect/Material/MaterialAsset.h> #include <Atom/RPI.Reflect/Material/MaterialAsset.h>
#include <Atom/RPI.Reflect/Model/ModelAsset.h> #include <Atom/RPI.Reflect/Model/ModelAsset.h>
#include <Atom/RPI.Reflect/System/AnyAsset.h> #include <Atom/RPI.Reflect/System/AnyAsset.h>
#include <Thumbnails/Rendering/CommonPreviewContent.h> #include <AtomToolsFramework/PreviewRenderer/PreviewContent.h>
namespace AZ namespace AZ
{ {
@ -23,7 +23,7 @@ namespace AZ
{ {
//! Provides custom rendering of material and model previews //! Provides custom rendering of material and model previews
class CommonThumbnailPreviewContent final class CommonThumbnailPreviewContent final
: public CommonPreviewContent : public AtomToolsFramework::PreviewContent
{ {
public: public:
AZ_CLASS_ALLOCATOR(CommonThumbnailPreviewContent, AZ::SystemAllocator, 0); AZ_CLASS_ALLOCATOR(CommonThumbnailPreviewContent, AZ::SystemAllocator, 0);

@ -8,10 +8,10 @@
#pragma once #pragma once
#include <AtomToolsFramework/PreviewRenderer/PreviewRenderer.h>
#include <AzCore/Component/TickBus.h> #include <AzCore/Component/TickBus.h>
#include <AzToolsFramework/Thumbnails/Thumbnail.h> #include <AzToolsFramework/Thumbnails/Thumbnail.h>
#include <AzToolsFramework/Thumbnails/ThumbnailerBus.h> #include <AzToolsFramework/Thumbnails/ThumbnailerBus.h>
#include <Thumbnails/Rendering/CommonPreviewRenderer.h>
#include <Thumbnails/Thumbnail.h> #include <Thumbnails/Thumbnail.h>
namespace AZ namespace AZ
@ -39,7 +39,7 @@ namespace AZ
//! SystemTickBus::Handler interface overrides... //! SystemTickBus::Handler interface overrides...
void OnSystemTick() override; void OnSystemTick() override;
CommonPreviewRenderer m_previewRenderer; AtomToolsFramework::PreviewRenderer m_previewRenderer;
}; };
} // namespace Thumbnails } // namespace Thumbnails
} // namespace LyIntegration } // namespace LyIntegration

@ -14,14 +14,14 @@
#include <AzToolsFramework/API/EditorAssetSystemAPI.h> #include <AzToolsFramework/API/EditorAssetSystemAPI.h>
#include <AzToolsFramework/Thumbnails/Thumbnail.h> #include <AzToolsFramework/Thumbnails/Thumbnail.h>
#include <Source/Thumbnails/Preview/CommonPreviewer.h> #include <Thumbnails/Preview/CommonPreviewer.h>
#include <Source/Thumbnails/ThumbnailUtils.h> #include <Thumbnails/ThumbnailUtils.h>
// Disables warning messages triggered by the Qt library // Disables warning messages triggered by the Qt library
// 4251: class needs to have dll-interface to be used by clients of class // 4251: class needs to have dll-interface to be used by clients of class
// 4800: forcing value to bool 'true' or 'false' (performance warning) // 4800: forcing value to bool 'true' or 'false' (performance warning)
AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option")
#include <Source/Thumbnails/Preview/ui_CommonPreviewer.h> #include <Thumbnails/Preview/ui_CommonPreviewer.h>
#include <QString> #include <QString>
#include <QResizeEvent> #include <QResizeEvent>
AZ_POP_DISABLE_WARNING AZ_POP_DISABLE_WARNING
@ -73,4 +73,4 @@ namespace AZ
} // namespace LyIntegration } // namespace LyIntegration
} // namespace AZ } // namespace AZ
#include <Source/Thumbnails/Preview/moc_CommonPreviewer.cpp> #include <Thumbnails/Preview/moc_CommonPreviewer.cpp>

@ -9,7 +9,6 @@
set(FILES set(FILES
Include/AtomLyIntegration/CommonFeatures/Material/EditorMaterialSystemComponentRequestBus.h Include/AtomLyIntegration/CommonFeatures/Material/EditorMaterialSystemComponentRequestBus.h
Include/AtomLyIntegration/CommonFeatures/ReflectionProbe/EditorReflectionProbeBus.h Include/AtomLyIntegration/CommonFeatures/ReflectionProbe/EditorReflectionProbeBus.h
Include/AtomLyIntegration/CommonFeatures/Thumbnails/PreviewerFeatureProcessorProviderBus.h
Source/Module.cpp Source/Module.cpp
Source/Animation/EditorAttachmentComponent.h Source/Animation/EditorAttachmentComponent.h
Source/Animation/EditorAttachmentComponent.cpp Source/Animation/EditorAttachmentComponent.cpp
@ -98,16 +97,6 @@ set(FILES
Source/Thumbnails/Preview/CommonPreviewer.ui Source/Thumbnails/Preview/CommonPreviewer.ui
Source/Thumbnails/Preview/CommonPreviewerFactory.cpp Source/Thumbnails/Preview/CommonPreviewerFactory.cpp
Source/Thumbnails/Preview/CommonPreviewerFactory.h Source/Thumbnails/Preview/CommonPreviewerFactory.h
Source/Thumbnails/Rendering/CommonPreviewContent.h
Source/Thumbnails/Rendering/CommonPreviewRenderer.cpp
Source/Thumbnails/Rendering/CommonPreviewRenderer.h
Source/Thumbnails/Rendering/CommonPreviewRendererState.h
Source/Thumbnails/Rendering/CommonPreviewRendererIdleState.cpp
Source/Thumbnails/Rendering/CommonPreviewRendererIdleState.h
Source/Thumbnails/Rendering/CommonPreviewRendererLoadState.cpp
Source/Thumbnails/Rendering/CommonPreviewRendererLoadState.h
Source/Thumbnails/Rendering/CommonPreviewRendererCaptureState.cpp
Source/Thumbnails/Rendering/CommonPreviewRendererCaptureState.h
Source/Thumbnails/CommonThumbnailPreviewContent.cpp Source/Thumbnails/CommonThumbnailPreviewContent.cpp
Source/Thumbnails/CommonThumbnailPreviewContent.h Source/Thumbnails/CommonThumbnailPreviewContent.h
Source/Thumbnails/CommonThumbnailRenderer.cpp Source/Thumbnails/CommonThumbnailRenderer.cpp

Loading…
Cancel
Save