text: /*
   * 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 <CommonSampleComponentBase.h>
  
  #include <Atom/RHI/IndexBufferView.h>
  #include <Atom/RHI/PipelineState.h>
  #include <Atom/RHI/DrawList.h>
  
  #include <Atom/RPI.Public/DynamicDraw/DynamicDrawInterface.h>
  #include <Atom/RPI.Public/Image/StreamingImage.h>
  #include <Atom/RPI.Public/Shader/ShaderResourceGroup.h>
  
  #include <AzFramework/Asset/AssetCatalogBus.h>
  
  #include <AzCore/IO/Path/Path.h>
  #include <AzCore/Component/TickBus.h>
  
  #include <Utils/ImGuiSidebar.h>
  
  namespace AtomSampleViewer
  {
      // This AtomSampleViewer example is to test, profile and visualize StreamingImage streaming process as well as 
      // testing the StreamingImage hot reloading function.
      // It starts loading 36 StreamingImageAssets and create the StreamingImages when each asset is ready.
      // After a StreamingImage is created, it will be drawn on the screen with all the its mips.
      // The mips which are not streamed in are showing are white blocks.
      // When all StreamingImages' mipmaps are streamed in, a profile result would be showing on the screen.
      // For StreamingImage hot reloading test, the example will add a new image file in the 
      // AtomSampleViewer project asset's texture/streaming/ folder. 
      // The file will be loaded and displayed on the top right side of screen. 
      // A switch button under it will overwrite the image with another one. When the changed image got processed by AP, 
      // the new content will be rendered on the screen. 
      class StreamingImageExampleComponent final
          : public CommonSampleComponentBase
          , public AZ::Data::AssetBus::MultiHandler
          , public AZ::TickBus::Handler
          , public AzFramework::AssetCatalogEventBus::Handler
      {
      public:
          AZ_COMPONENT(StreamingImageExampleComponent, "{9AF86786-8B14-4C3E-92CD-3152768E417C}", CommonSampleComponentBase);
  
          static void Reflect(AZ::ReflectContext* context);
  
          StreamingImageExampleComponent() = default;
          ~StreamingImageExampleComponent() override = default;
  
          void Activate() override;
          void Deactivate() override;
  
      private:
  
          struct ImageToDraw
          {
              AZ::Data::AssetId m_assetId;
              AZ::Data::Asset<AZ::RPI::StreamingImageAsset> m_asset;
              AZ::Data::Instance<AZ::RPI::StreamingImage> m_image;
              AZ::Data::Instance<AZ::RPI::ShaderResourceGroup> m_srg;
              bool m_wasStreamed = false;
  
              void Reset()
              {
                  m_assetId = AZ::Data::AssetId{};
                  m_asset.Reset();
                  m_image.reset();
                  m_srg.reset();
                  m_wasStreamed = false;
              }
          };
  
          struct Image3dToDraw
          {
              AZ::Data::Instance<AZ::RPI::StreamingImage> m_image;
              AZ::Data::Instance<AZ::RPI::ShaderResourceGroup> m_srg;
              uint32_t m_sliceCount;
          };
  
          // AZ::TickBus::Handler...
          void OnTick(float deltaTime, AZ::ScriptTimePoint timePoint) override;
          
          // AssetBus::Handler...
          /// Used to accept image mip chain asset events.
          void OnAssetReady(AZ::Data::Asset<AZ::Data::AssetData> asset) override;
          void OnAssetReloaded(AZ::Data::Asset<AZ::Data::AssetData> asset) override;
  
          // AssetCatalogEventBus::Handler
          void OnCatalogAssetAdded(const AZ::Data::AssetId& /*assetId*/) override;
          void OnCatalogAssetChanged(const AZ::Data::AssetId& /*assetId*/) override;
  
          // Draw profiling data with Imgui
          void DisplayStreamingProfileData();
  
          // Submit draw packages for each streaming image
          void DrawImages();
  
          // Submit draw packages for each 3d streaming image
          void Draw3dImages();
  
          // Submit draw package for one image
          void DrawImage(const ImageToDraw* imageInfo);
  
          // Creates resources, resource views, pipeline state, etc. for rendering
          void PrepareRenderData();
          
          void SwitchHotReloadImage();
          void DeleteHotReloadImage();
  
          // Create 3d images from Cpu Data and prepare them for draw
          void Create3dimages();
  
          // Helper function to get total file size of a streaming image asset and its sub assets
          AZ::u64 GetImageAssetSize(AZ::RPI::StreamingImage* image);
  
          // Copy the sourceFile and to destFile. If the destFile already exists, overwrite it. 
          bool CopyFile(const AZStd::string& destFile, const AZStd::string& sourceFile);
          void QueueForLoad(const AZStd::string& filePath);
          
          //[GFX TODO][ATOM-4040] PAL-ify AtomSampleViewer. We disable m_enableHotReloadTest for following platforms as
          //they dont have access to the root dev folder, only the asset cache folder and the hot reload
          //logic cant work without it. This is because these platforms use AtomSampleViewerLauncher instead of AtomSampleViewerApplication
          static bool IsHotReloadTestSupported();
  
          const static uint32_t TestDDSCount = 36; // For image streaming and profile
          const static uint32_t TestPNGCount = 4; // For non-power-of-two textures
          const AZ::IO::Path TestImageFolder = "Textures/Streaming";
          const AZ::IO::Path ReloadTestImageName = "reloadtest.png";
          // Constants of display area for showing all streaming images.
          // As reference, the window's left bottom is (-1, -1). The window size is (2, 2)
          const float AreaWidth = 1.5f;
          const float AreaHeight = 1.9f;
          const float AreaBottom = -1.0f;
          const float AreaLeft = -1.0f;
  
          uint32_t m_numImageAssetQueued = 0; // The number of StreamingImageAsset were queued to load
          uint32_t m_numImageCreated = 0;     // The number of StreamingImage objects were created
          uint32_t m_numImageStreamed = 0;    // The number of StreamingImages are fully streamed in.
  
          // images for streaming profiling
          AZStd::vector<ImageToDraw> m_images;
  
          // image for hot reloading test
          ImageToDraw m_imageHotReload;
          int m_curSourceImage = 0;
          bool m_enableHotReloadTest = true;
          AZ::Data::AssetId m_reloadingAsset;
  
          // images for 3D streaming
          AZStd::vector<Image3dToDraw> m_3dImages;
          bool m_viewStreamedImages = true;
  
          // profile data
          AZ::u64 m_loadImageStart = 0;
          AZ::u64 m_loadImageEnd = 0;
          AZ::u64 m_createImageTime = 0;
          AZ::u64 m_streamingImageEnd = 0;
          AZ::u64 m_initialImageMemory = 0;
          AZ::u64 m_imageMemory = 0;
          
          ImGuiSidebar m_imguiSidebar;
  
          // Cache the DynamicDraw Interface
          AZ::RPI::DynamicDrawInterface* m_dynamicDraw = nullptr;
  
          // render related data
          AZ::RHI::ConstPtr<AZ::RHI::PipelineState> m_pipelineState;
          AZ::RHI::ConstPtr<AZ::RHI::PipelineState> m_image3dPipelineState;
  
          AZ::RHI::DrawListTag m_drawListTag;
          AZ::RHI::DrawListTag m_image3dDrawListTag;
  
          AZ::Data::Asset<AZ::RPI::ShaderAsset> m_shaderAsset;
          AZ::RHI::Ptr<AZ::RHI::ShaderResourceGroupLayout> m_srgLayout;
  
          AZ::Data::Asset<AZ::RPI::ShaderAsset> m_image3dShaderAsset;
          AZ::RHI::Ptr<AZ::RHI::ShaderResourceGroupLayout> m_image3dSrgLayout;
  
          // shader input indices
          AZ::RHI::ShaderInputImageIndex m_imageInputIndex;
          AZ::RHI::ShaderInputConstantIndex m_positionInputIndex;
          AZ::RHI::ShaderInputConstantIndex m_sizeInputIndex;
          AZ::RHI::ShaderInputConstantIndex m_residentMipInputIndex;
  
          AzFramework::WindowSize m_windowSize;
  
          // for pause or resume script automation
          bool m_automationPaused = false;
      };
  } // namespace AtomSampleViewer
  