birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Everything compiling again after moving preview renderer to atom tools framework

Browse Source 
Signed-off-by: Guthrie Adams <guthadam@amazon.com>
This commit is contained in:
Guthrie Adams
2021-10-08 04:33:45 -05:00
parent 569318e9e1
commit 76b4dafbb3
20 changed files with 515 additions and 583 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Gems/Atom/Tools/AtomToolsFramework/Code/Source/PreviewRenderer/PreviewRenderer.cpp
+218 -225
View File
@@ -15,245 +15,238 @@
#include <Atom/RPI.Public/View.h>
#include <Atom/RPI.Reflect/System/RenderPipelineDescriptor.h>
#include <Atom/RPI.Reflect/System/SceneDescriptor.h>
#include <AtomToolsFramework/PreviewRenderer/PreviewRenderer.h>
#include <AzCore/Math/MatrixUtils.h>
#include <AzCore/Math/Transform.h>
#include <AzFramework/Scene/Scene.h>
#include <AzFramework/Scene/SceneSystemInterface.h>
#include <Thumbnails/Rendering/CommonPreviewRenderer.h>
#include <Thumbnails/Rendering/CommonPreviewRendererCaptureState.h>
#include <Thumbnails/Rendering/CommonPreviewRendererIdleState.h>
#include <Thumbnails/Rendering/CommonPreviewRendererLoadState.h>
#include <PreviewRenderer/PreviewRendererCaptureState.h>
#include <PreviewRenderer/PreviewRendererIdleState.h>
#include <PreviewRenderer/PreviewRendererLoadState.h>
namespace AZ
namespace AtomToolsFramework
{
namespace LyIntegration
PreviewRenderer::PreviewRenderer()
{
namespace Thumbnails
PreviewerFeatureProcessorProviderBus::Handler::BusConnect();
m_entityContext = AZStd::make_unique<AzFramework::EntityContext>();
m_entityContext->InitContext();
// Create and register a scene with all required feature processors
AZStd::unordered_set<AZStd::string> featureProcessors;
PreviewerFeatureProcessorProviderBus::Broadcast(
&PreviewerFeatureProcessorProviderBus::Handler::GetRequiredFeatureProcessors, featureProcessors);
AZ::RPI::SceneDescriptor sceneDesc;
sceneDesc.m_featureProcessorNames.assign(featureProcessors.begin(), featureProcessors.end());
m_scene = AZ::RPI::Scene::CreateScene(sceneDesc);
// Bind m_frameworkScene to the entity context's AzFramework::Scene
auto sceneSystem = AzFramework::SceneSystemInterface::Get();
AZ_Assert(sceneSystem, "Failed to get scene system implementation.");
AZ::Outcome<AZStd::shared_ptr<AzFramework::Scene>, AZStd::string> createSceneOutcome = sceneSystem->CreateScene(m_sceneName);
AZ_Assert(createSceneOutcome, createSceneOutcome.GetError().c_str());
m_frameworkScene = createSceneOutcome.TakeValue();
m_frameworkScene->SetSubsystem(m_scene);
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
AZ::RPI::RenderPipelineDescriptor pipelineDesc;
pipelineDesc.m_mainViewTagName = "MainCamera";
pipelineDesc.m_name = m_pipelineName;
pipelineDesc.m_rootPassTemplate = "MainPipelineRenderToTexture";
// 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
pipelineDesc.m_renderSettings.m_multisampleState.m_samples = 4;
m_renderPipeline = AZ::RPI::RenderPipeline::CreateRenderPipeline(pipelineDesc);
m_scene->AddRenderPipeline(m_renderPipeline);
m_scene->Activate();
AZ::RPI::RPISystemInterface::Get()->RegisterScene(m_scene);
m_passHierarchy.push_back(m_pipelineName);
m_passHierarchy.push_back("CopyToSwapChain");
// Connect camera to pipeline's default view after camera entity activated
AZ::Matrix4x4 viewToClipMatrix;
AZ::MakePerspectiveFovMatrixRH(viewToClipMatrix, FieldOfView, AspectRatio, NearDist, FarDist, true);
m_view = AZ::RPI::View::CreateView(AZ::Name("MainCamera"), AZ::RPI::View::UsageCamera);
m_view->SetViewToClipMatrix(viewToClipMatrix);
m_renderPipeline->SetDefaultView(m_view);
m_states[PreviewRenderer::State::IdleState] = AZStd::make_shared<PreviewRendererIdleState>(this);
m_states[PreviewRenderer::State::LoadState] = AZStd::make_shared<PreviewRendererLoadState>(this);
m_states[PreviewRenderer::State::CaptureState] = AZStd::make_shared<PreviewRendererCaptureState>(this);
SetState(PreviewRenderer::State::IdleState);
}
PreviewRenderer::~PreviewRenderer()
{
PreviewerFeatureProcessorProviderBus::Handler::BusDisconnect();
SetState(PreviewRenderer::State::None);
m_currentCaptureRequest = {};
m_captureRequestQueue = {};
m_scene->Deactivate();
m_scene->RemoveRenderPipeline(m_renderPipeline->GetId());
AZ::RPI::RPISystemInterface::Get()->UnregisterScene(m_scene);
m_frameworkScene->UnsetSubsystem(m_scene);
m_frameworkScene->UnsetSubsystem(m_entityContext.get());
}
AZ::RPI::ScenePtr PreviewRenderer::GetScene() const
{
return m_scene;
}
AZ::RPI::ViewPtr PreviewRenderer::GetView() const
{
return m_view;
}
AZ::Uuid PreviewRenderer::GetEntityContextId() const
{
return m_entityContext->GetContextId();
}
void PreviewRenderer::AddCaptureRequest(const CaptureRequest& captureRequest)
{
m_captureRequestQueue.push(captureRequest);
}
void PreviewRenderer::SetState(State state)
{
auto stepItr = m_states.find(m_currentState);
if (stepItr != m_states.end())
{
CommonPreviewRenderer::CommonPreviewRenderer()
stepItr->second->Stop();
}
m_currentState = state;
stepItr = m_states.find(m_currentState);
if (stepItr != m_states.end())
{
stepItr->second->Start();
}
}
PreviewRenderer::State PreviewRenderer::GetState() const
{
return m_currentState;
}
void PreviewRenderer::SelectCaptureRequest()
{
if (!m_captureRequestQueue.empty())
{
// pop the next request to be rendered from the queue
m_currentCaptureRequest = m_captureRequestQueue.front();
m_captureRequestQueue.pop();
SetState(PreviewRenderer::State::LoadState);
}
}
void PreviewRenderer::CancelCaptureRequest()
{
m_currentCaptureRequest.m_captureFailedCallback();
SetState(PreviewRenderer::State::IdleState);
}
void PreviewRenderer::CompleteCaptureRequest()
{
SetState(PreviewRenderer::State::IdleState);
}
void PreviewRenderer::LoadAssets()
{
m_currentCaptureRequest.m_content->Load();
}
void PreviewRenderer::UpdateLoadAssets()
{
if (m_currentCaptureRequest.m_content->IsReady())
{
SetState(PreviewRenderer::State::CaptureState);
return;
}
if (m_currentCaptureRequest.m_content->IsError())
{
CancelLoadAssets();
return;
}
}
void PreviewRenderer::CancelLoadAssets()
{
m_currentCaptureRequest.m_content->ReportErrors();
CancelCaptureRequest();
}
void PreviewRenderer::UpdateScene()
{
m_currentCaptureRequest.m_content->UpdateScene();
}
bool PreviewRenderer::StartCapture()
{
auto captureCallback = [currentCaptureRequest = m_currentCaptureRequest](const AZ::RPI::AttachmentReadback::ReadbackResult& result)
{
if (result.m_dataBuffer)
{
PreviewerFeatureProcessorProviderBus::Handler::BusConnect();
m_entityContext = AZStd::make_unique<AzFramework::EntityContext>();
m_entityContext->InitContext();
// Create and register a scene with all required feature processors
AZStd::unordered_set<AZStd::string> featureProcessors;
PreviewerFeatureProcessorProviderBus::Broadcast(
&PreviewerFeatureProcessorProviderBus::Handler::GetRequiredFeatureProcessors, featureProcessors);
RPI::SceneDescriptor sceneDesc;
sceneDesc.m_featureProcessorNames.assign(featureProcessors.begin(), featureProcessors.end());
m_scene = RPI::Scene::CreateScene(sceneDesc);
// Bind m_frameworkScene to the entity context's AzFramework::Scene
auto sceneSystem = AzFramework::SceneSystemInterface::Get();
AZ_Assert(sceneSystem, "Failed to get scene system implementation.");
Outcome<AZStd::shared_ptr<AzFramework::Scene>, AZStd::string> createSceneOutcome = sceneSystem->CreateScene(m_sceneName);
AZ_Assert(createSceneOutcome, createSceneOutcome.GetError().c_str());
m_frameworkScene = createSceneOutcome.TakeValue();
m_frameworkScene->SetSubsystem(m_scene);
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
RPI::RenderPipelineDescriptor pipelineDesc;
pipelineDesc.m_mainViewTagName = "MainCamera";
pipelineDesc.m_name = m_pipelineName;
pipelineDesc.m_rootPassTemplate = "MainPipelineRenderToTexture";
// 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
pipelineDesc.m_renderSettings.m_multisampleState.m_samples = 4;
m_renderPipeline = RPI::RenderPipeline::CreateRenderPipeline(pipelineDesc);
m_scene->AddRenderPipeline(m_renderPipeline);
m_scene->Activate();
RPI::RPISystemInterface::Get()->RegisterScene(m_scene);
m_passHierarchy.push_back(m_pipelineName);
m_passHierarchy.push_back("CopyToSwapChain");
// Connect camera to pipeline's default view after camera entity activated
Matrix4x4 viewToClipMatrix;
MakePerspectiveFovMatrixRH(viewToClipMatrix, FieldOfView, AspectRatio, NearDist, FarDist, true);
m_view = RPI::View::CreateView(Name("MainCamera"), RPI::View::UsageCamera);
m_view->SetViewToClipMatrix(viewToClipMatrix);
m_renderPipeline->SetDefaultView(m_view);
m_states[CommonPreviewRenderer::State::IdleState] = AZStd::make_shared<CommonPreviewRendererIdleState>(this);
m_states[CommonPreviewRenderer::State::LoadState] = AZStd::make_shared<CommonPreviewRendererLoadState>(this);
m_states[CommonPreviewRenderer::State::CaptureState] = AZStd::make_shared<CommonPreviewRendererCaptureState>(this);
SetState(CommonPreviewRenderer::State::IdleState);
currentCaptureRequest.m_captureCompleteCallback(QImage(
result.m_dataBuffer.get()->data(), result.m_imageDescriptor.m_size.m_width, result.m_imageDescriptor.m_size.m_height,
QImage::Format_RGBA8888));
}
CommonPreviewRenderer::~CommonPreviewRenderer()
else
{
PreviewerFeatureProcessorProviderBus::Handler::BusDisconnect();
SetState(CommonPreviewRenderer::State::None);
m_currentCaptureRequest = {};
m_captureRequestQueue = {};
m_scene->Deactivate();
m_scene->RemoveRenderPipeline(m_renderPipeline->GetId());
RPI::RPISystemInterface::Get()->UnregisterScene(m_scene);
m_frameworkScene->UnsetSubsystem(m_scene);
m_frameworkScene->UnsetSubsystem(m_entityContext.get());
currentCaptureRequest.m_captureFailedCallback();
}
};
RPI::ScenePtr CommonPreviewRenderer::GetScene() const
{
return m_scene;
}
if (auto renderToTexturePass = azrtti_cast<AZ::RPI::RenderToTexturePass*>(m_renderPipeline->GetRootPass().get()))
{
renderToTexturePass->ResizeOutput(m_currentCaptureRequest.m_size, m_currentCaptureRequest.m_size);
}
RPI::ViewPtr CommonPreviewRenderer::GetView() const
{
return m_view;
}
m_renderPipeline->AddToRenderTickOnce();
AZ::Uuid CommonPreviewRenderer::GetEntityContextId() const
{
return m_entityContext->GetContextId();
}
bool startedCapture = false;
AZ::Render::FrameCaptureRequestBus::BroadcastResult(
startedCapture, &AZ::Render::FrameCaptureRequestBus::Events::CapturePassAttachmentWithCallback, m_passHierarchy,
AZStd::string("Output"), captureCallback, AZ::RPI::PassAttachmentReadbackOption::Output);
return startedCapture;
}
void CommonPreviewRenderer::AddCaptureRequest(const CaptureRequest& captureRequest)
{
m_captureRequestQueue.push(captureRequest);
}
void PreviewRenderer::EndCapture()
{
m_renderPipeline->RemoveFromRenderTick();
}
void CommonPreviewRenderer::SetState(State state)
{
auto stepItr = m_states.find(m_currentState);
if (stepItr != m_states.end())
{
stepItr->second->Stop();
}
m_currentState = state;
stepItr = m_states.find(m_currentState);
if (stepItr != m_states.end())
{
stepItr->second->Start();
}
}
CommonPreviewRenderer::State CommonPreviewRenderer::GetState() const
{
return m_currentState;
}
void CommonPreviewRenderer::SelectCaptureRequest()
{
if (!m_captureRequestQueue.empty())
{
// pop the next request to be rendered from the queue
m_currentCaptureRequest = m_captureRequestQueue.front();
m_captureRequestQueue.pop();
SetState(CommonPreviewRenderer::State::LoadState);
}
}
void CommonPreviewRenderer::CancelCaptureRequest()
{
m_currentCaptureRequest.m_captureFailedCallback();
SetState(CommonPreviewRenderer::State::IdleState);
}
void CommonPreviewRenderer::CompleteCaptureRequest()
{
SetState(CommonPreviewRenderer::State::IdleState);
}
void CommonPreviewRenderer::LoadAssets()
{
m_currentCaptureRequest.m_content->Load();
}
void CommonPreviewRenderer::UpdateLoadAssets()
{
if (m_currentCaptureRequest.m_content->IsReady())
{
SetState(CommonPreviewRenderer::State::CaptureState);
return;
}
if (m_currentCaptureRequest.m_content->IsError())
{
CancelLoadAssets();
return;
}
}
void CommonPreviewRenderer::CancelLoadAssets()
{
m_currentCaptureRequest.m_content->ReportErrors();
CancelCaptureRequest();
}
void CommonPreviewRenderer::UpdateScene()
{
m_currentCaptureRequest.m_content->UpdateScene();
}
bool CommonPreviewRenderer::StartCapture()
{
auto captureCallback =
[currentCaptureRequest = m_currentCaptureRequest](const RPI::AttachmentReadback::ReadbackResult& result)
{
if (result.m_dataBuffer)
{
currentCaptureRequest.m_captureCompleteCallback(QImage(
result.m_dataBuffer.get()->data(), result.m_imageDescriptor.m_size.m_width,
result.m_imageDescriptor.m_size.m_height, QImage::Format_RGBA8888));
}
else
{
currentCaptureRequest.m_captureFailedCallback();
}
};
if (auto renderToTexturePass = azrtti_cast<AZ::RPI::RenderToTexturePass*>(m_renderPipeline->GetRootPass().get()))
{
renderToTexturePass->ResizeOutput(m_currentCaptureRequest.m_size, m_currentCaptureRequest.m_size);
}
m_renderPipeline->AddToRenderTickOnce();
bool startedCapture = false;
Render::FrameCaptureRequestBus::BroadcastResult(
startedCapture, &Render::FrameCaptureRequestBus::Events::CapturePassAttachmentWithCallback, m_passHierarchy,
AZStd::string("Output"), captureCallback, RPI::PassAttachmentReadbackOption::Output);
return startedCapture;
}
void CommonPreviewRenderer::EndCapture()
{
m_renderPipeline->RemoveFromRenderTick();
}
void CommonPreviewRenderer::GetRequiredFeatureProcessors(AZStd::unordered_set<AZStd::string>& featureProcessors) const
{
featureProcessors.insert({
"AZ::Render::TransformServiceFeatureProcessor",
"AZ::Render::MeshFeatureProcessor",
"AZ::Render::SimplePointLightFeatureProcessor",
"AZ::Render::SimpleSpotLightFeatureProcessor",
"AZ::Render::PointLightFeatureProcessor",
// There is currently a bug where having multiple DirectionalLightFeatureProcessors active can result in shadow
// flickering [ATOM-13568]
// as well as continually rebuilding MeshDrawPackets [ATOM-13633]. Lets just disable the directional light FP for now.
// Possibly re-enable with [GFX TODO][ATOM-13639]
// "AZ::Render::DirectionalLightFeatureProcessor",
"AZ::Render::DiskLightFeatureProcessor",
"AZ::Render::CapsuleLightFeatureProcessor",
"AZ::Render::QuadLightFeatureProcessor",
"AZ::Render::DecalTextureArrayFeatureProcessor",
"AZ::Render::ImageBasedLightFeatureProcessor",
"AZ::Render::PostProcessFeatureProcessor",
"AZ::Render::SkyBoxFeatureProcessor" });
}
} // namespace Thumbnails
} // namespace LyIntegration
} // namespace AZ
void PreviewRenderer::GetRequiredFeatureProcessors(AZStd::unordered_set<AZStd::string>& featureProcessors) const
{
featureProcessors.insert({
"AZ::Render::TransformServiceFeatureProcessor",
"AZ::Render::MeshFeatureProcessor",
"AZ::Render::SimplePointLightFeatureProcessor",
"AZ::Render::SimpleSpotLightFeatureProcessor",
"AZ::Render::PointLightFeatureProcessor",
// There is currently a bug where having multiple DirectionalLightFeatureProcessors active can result in shadow
// flickering [ATOM-13568]
// as well as continually rebuilding MeshDrawPackets [ATOM-13633]. Lets just disable the directional light FP for now.
// Possibly re-enable with [GFX TODO][ATOM-13639]
// "AZ::Render::DirectionalLightFeatureProcessor",
"AZ::Render::DiskLightFeatureProcessor",
"AZ::Render::CapsuleLightFeatureProcessor",
"AZ::Render::QuadLightFeatureProcessor",
"AZ::Render::DecalTextureArrayFeatureProcessor",
"AZ::Render::ImageBasedLightFeatureProcessor",
"AZ::Render::PostProcessFeatureProcessor",
"AZ::Render::SkyBoxFeatureProcessor" });
}
} // namespace AtomToolsFramework
Gems/Atom/Tools/AtomToolsFramework/Code/Source/PreviewRenderer/PreviewRendererCaptureState.cpp
+36 -42
View File
@@ -6,52 +6,46 @@
*
*/
#include <Thumbnails/Rendering/CommonPreviewRenderer.h>
#include <Thumbnails/Rendering/CommonPreviewRendererCaptureState.h>
#include <AtomToolsFramework/PreviewRenderer/PreviewRenderer.h>
#include <PreviewRenderer/PreviewRendererCaptureState.h>
namespace AZ
namespace AtomToolsFramework
{
namespace LyIntegration
PreviewRendererCaptureState::PreviewRendererCaptureState(PreviewRenderer* renderer)
: PreviewRendererState(renderer)
{
namespace Thumbnails
}
void PreviewRendererCaptureState::Start()
{
m_ticksToCapture = 1;
m_renderer->UpdateScene();
AZ::TickBus::Handler::BusConnect();
}
void PreviewRendererCaptureState::Stop()
{
m_renderer->EndCapture();
AZ::TickBus::Handler::BusDisconnect();
AZ::Render::FrameCaptureNotificationBus::Handler::BusDisconnect();
}
void PreviewRendererCaptureState::OnTick([[maybe_unused]] float deltaTime, [[maybe_unused]] AZ::ScriptTimePoint time)
{
if (m_ticksToCapture-- <= 0)
{
CommonPreviewRendererCaptureState::CommonPreviewRendererCaptureState(CommonPreviewRenderer* renderer)
: CommonPreviewRendererState(renderer)
// Reset the capture flag if the capture request was successful. Otherwise try capture it again next tick.
if (m_renderer->StartCapture())
{
AZ::Render::FrameCaptureNotificationBus::Handler::BusConnect();
AZ::TickBus::Handler::BusDisconnect();
}
}
}
void CommonPreviewRendererCaptureState::Start()
{
m_ticksToCapture = 1;
m_renderer->UpdateScene();
TickBus::Handler::BusConnect();
}
void CommonPreviewRendererCaptureState::Stop()
{
m_renderer->EndCapture();
TickBus::Handler::BusDisconnect();
Render::FrameCaptureNotificationBus::Handler::BusDisconnect();
}
void CommonPreviewRendererCaptureState::OnTick([[maybe_unused]] float deltaTime, [[maybe_unused]] ScriptTimePoint time)
{
if (m_ticksToCapture-- <= 0)
{
// Reset the capture flag if the capture request was successful. Otherwise try capture it again next tick.
if (m_renderer->StartCapture())
{
Render::FrameCaptureNotificationBus::Handler::BusConnect();
TickBus::Handler::BusDisconnect();
}
}
}
void CommonPreviewRendererCaptureState::OnCaptureFinished(
[[maybe_unused]] Render::FrameCaptureResult result, [[maybe_unused]] const AZStd::string& info)
{
m_renderer->CompleteCaptureRequest();
}
} // namespace Thumbnails
} // namespace LyIntegration
} // namespace AZ
void PreviewRendererCaptureState::OnCaptureFinished(
[[maybe_unused]] AZ::Render::FrameCaptureResult result, [[maybe_unused]] const AZStd::string& info)
{
m_renderer->CompleteCaptureRequest();
}
} // namespace AtomToolsFramework
Gems/Atom/Tools/AtomToolsFramework/Code/Source/PreviewRenderer/PreviewRendererCaptureState.h
+20 -27
View File
@@ -9,38 +9,31 @@
#pragma once
#include <Atom/Feature/Utils/FrameCaptureBus.h>
#include <AtomToolsFramework/PreviewRenderer/PreviewRendererState.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
: public PreviewRendererState
, public AZ::TickBus::Handler
, public AZ::Render::FrameCaptureNotificationBus::Handler
{
namespace Thumbnails
{
//! CommonPreviewRendererCaptureState renders a thumbnail to a pixmap and notifies MaterialOrModelThumbnail once finished
class CommonPreviewRendererCaptureState
: public CommonPreviewRendererState
, private TickBus::Handler
, private Render::FrameCaptureNotificationBus::Handler
{
public:
CommonPreviewRendererCaptureState(CommonPreviewRenderer* renderer);
public:
PreviewRendererCaptureState(PreviewRenderer* renderer);
void Start() override;
void Stop() override;
void Start() override;
void Stop() override;
private:
//! AZ::TickBus::Handler interface overrides...
void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
private:
//! AZ::TickBus::Handler interface overrides...
void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
//! Render::FrameCaptureNotificationBus::Handler overrides...
void OnCaptureFinished(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
int m_ticksToCapture = 0;
};
} // namespace Thumbnails
} // namespace LyIntegration
} // namespace AZ
//! AZ::Render::FrameCaptureNotificationBus::Handler overrides...
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
int m_ticksToCapture = 0;
};
} // namespace AtomToolsFramework
Gems/Atom/Tools/AtomToolsFramework/Code/Source/PreviewRenderer/PreviewRendererIdleState.cpp
+19 -25
View File
@@ -6,34 +6,28 @@
*
*/
#include <Thumbnails/Rendering/CommonPreviewRenderer.h>
#include <Thumbnails/Rendering/CommonPreviewRendererIdleState.h>
#include <AtomToolsFramework/PreviewRenderer/PreviewRenderer.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()
{
TickBus::Handler::BusConnect();
}
void PreviewRendererIdleState::Start()
{
AZ::TickBus::Handler::BusConnect();
}
void CommonPreviewRendererIdleState::Stop()
{
TickBus::Handler::BusDisconnect();
}
void PreviewRendererIdleState::Stop()
{
AZ::TickBus::Handler::BusDisconnect();
}
void CommonPreviewRendererIdleState::OnTick([[maybe_unused]] float deltaTime, [[maybe_unused]] ScriptTimePoint time)
{
m_renderer->SelectCaptureRequest();
}
} // namespace Thumbnails
} // namespace LyIntegration
} // namespace AZ
void PreviewRendererIdleState::OnTick([[maybe_unused]] float deltaTime, [[maybe_unused]] AZ::ScriptTimePoint time)
{
m_renderer->SelectCaptureRequest();
}
} // namespace AtomToolsFramework
Gems/Atom/Tools/AtomToolsFramework/Code/Source/PreviewRenderer/PreviewRendererIdleState.h
+16 -23
View File
@@ -8,31 +8,24 @@
#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
: public PreviewRendererState
, public AZ::TickBus::Handler
{
namespace Thumbnails
{
//! CommonPreviewRendererIdleState checks whether there are any new thumbnails that need to be rendered every tick
class CommonPreviewRendererIdleState
: public CommonPreviewRendererState
, private TickBus::Handler
{
public:
CommonPreviewRendererIdleState(CommonPreviewRenderer* renderer);
public:
PreviewRendererIdleState(PreviewRenderer* renderer);
void Start() override;
void Stop() override;
private:
//! AZ::TickBus::Handler interface overrides...
void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
};
} // namespace Thumbnails
} // namespace LyIntegration
} // namespace AZ
void Start() override;
void Stop() override;
private:
//! AZ::TickBus::Handler interface overrides...
void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
};
} // namespace AtomToolsFramework
Gems/Atom/Tools/AtomToolsFramework/Code/Source/PreviewRenderer/PreviewRendererLoadState.cpp
+31 -37
View File
@@ -6,44 +6,38 @@
*
*/
#include <Thumbnails/Rendering/CommonPreviewRenderer.h>
#include <Thumbnails/Rendering/CommonPreviewRendererLoadState.h>
#include <AtomToolsFramework/PreviewRenderer/PreviewRenderer.h>
#include <PreviewRenderer/PreviewRendererLoadState.h>
namespace AZ
namespace AtomToolsFramework
{
namespace LyIntegration
PreviewRendererLoadState::PreviewRendererLoadState(PreviewRenderer* renderer)
: PreviewRendererState(renderer)
{
namespace Thumbnails
}
void PreviewRendererLoadState::Start()
{
m_renderer->LoadAssets();
m_timeRemainingS = TimeOutS;
AZ::TickBus::Handler::BusConnect();
}
void PreviewRendererLoadState::Stop()
{
AZ::TickBus::Handler::BusDisconnect();
}
void PreviewRendererLoadState::OnTick(float deltaTime, [[maybe_unused]] AZ::ScriptTimePoint time)
{
m_timeRemainingS -= deltaTime;
if (m_timeRemainingS > 0.0f)
{
CommonPreviewRendererLoadState::CommonPreviewRendererLoadState(CommonPreviewRenderer* renderer)
: CommonPreviewRendererState(renderer)
{
}
void CommonPreviewRendererLoadState::Start()
{
m_renderer->LoadAssets();
m_timeRemainingS = TimeOutS;
TickBus::Handler::BusConnect();
}
void CommonPreviewRendererLoadState::Stop()
{
TickBus::Handler::BusDisconnect();
}
void CommonPreviewRendererLoadState::OnTick(float deltaTime, [[maybe_unused]] AZ::ScriptTimePoint time)
{
m_timeRemainingS -= deltaTime;
if (m_timeRemainingS > 0.0f)
{
m_renderer->UpdateLoadAssets();
}
else
{
m_renderer->CancelLoadAssets();
}
}
} // namespace Thumbnails
} // namespace LyIntegration
} // namespace AZ
m_renderer->UpdateLoadAssets();
}
else
{
m_renderer->CancelLoadAssets();
}
}
} // namespace AtomToolsFramework
Gems/Atom/Tools/AtomToolsFramework/Code/Source/PreviewRenderer/PreviewRendererLoadState.h
+17 -24
View File
@@ -9,33 +9,26 @@
#pragma once
#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
: public PreviewRendererState
, public AZ::TickBus::Handler
{
namespace Thumbnails
{
//! CommonPreviewRendererLoadState pauses further rendering until all assets used for rendering a thumbnail have been loaded
class CommonPreviewRendererLoadState
: public CommonPreviewRendererState
, private TickBus::Handler
{
public:
CommonPreviewRendererLoadState(CommonPreviewRenderer* renderer);
public:
PreviewRendererLoadState(PreviewRenderer* renderer);
void Start() override;
void Stop() override;
void Start() override;
void Stop() override;
private:
//! AZ::TickBus::Handler interface overrides...
void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
static constexpr float TimeOutS = 5.0f;
float m_timeRemainingS = TimeOutS;
};
} // namespace Thumbnails
} // namespace LyIntegration
} // namespace AZ
private:
//! AZ::TickBus::Handler interface overrides...
void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
static constexpr float TimeOutS = 5.0f;
float m_timeRemainingS = TimeOutS;
};
} // namespace AtomToolsFramework
Gems/Atom/Tools/AtomToolsFramework/Code/Source/PreviewRenderer/PreviewRendererState.h
-37
View File
@@ -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