Image360System.h

#pragma once
#include "Rendering/Common.h"
#include "Rendering/IGraphicsDevice.h"
 
#include "Renderer/IRenderer.h"
#include "Resources/MeshStreamsLayout.h"
#include "Systems/ComponentSystem.h"
#include "Scene/GetBounds.h"
#include "Scene/RayPick.h"
 
#include "Image360.h"
#include "Image360Component.h"
 
namespace Cogs::Core
{
  struct Image360System;
  struct Image360Data;
 
  namespace Image360 {
 
    struct Bounds final : public IGetBounds {
    public:
      explicit Bounds(Image360System* im360System);
      void getBounds(Context* context, Cogs::Geometry::BoundingBox& bounds) override;
      bool getBounds(Context* context, const Cogs::ComponentModel::Entity* entity, Cogs::Geometry::BoundingBox& bounds, bool ignoreVisibility) const override;
 
    private:
      Image360System* im360System = nullptr;
    };
 
    struct RendererExtension : public IRendererExtension
    {
    public:
      void initialize(Context* context, IGraphicsDevice* device) override;
      void release();
      void handleEvent(uint32_t eventId, const DrawContext* renderingContext) override;
      void generateCommands(const RenderTaskContext* renderingContext, RenderList* renderList) override;
      void releaseRenderingResources(RendererExtensionData& im360Data);
 
      bool isReady();
 
      Context* context = nullptr;
      IGraphicsDevice* device = nullptr;
      Image360System* im360System = nullptr;
 
      Memory::MemoryBuffer scratch;
 
      // We defer releasing textures that we manage one frame to avoid releasing it while it is in use, which WebGPU doesn't like.
      std::vector<Cogs::TextureHandle> texturesToRelease;
 
      struct {
        MeshStreamsLayout streamsLayout;
        Cogs::VertexBufferHandle vertices;
        Cogs::BufferHandle paramBuffer;
      } fullScreenTriangle;
 
      // WebGL on VR headsets have an issue with copy/blits from texture arrays, so we use shader instead
      struct AtlasBlitVariant {
        Cogs::EffectHandle effect = Cogs::EffectHandle::NoHandle;
        Cogs::InputLayoutHandle inputLayout = Cogs::InputLayoutHandle::NoHandle;
        Cogs::TextureBindingHandle srcTexBinding = Cogs::TextureBindingHandle::NoHandle;
        Cogs::SamplerStateBindingHandle srcSamplerBinding = Cogs::SamplerStateBindingHandle::NoHandle;
        Cogs::ConstantBufferBindingHandle paramBinding = Cogs::ConstantBufferBindingHandle::NoHandle;
        Cogs::ResourceStatus effectStatus = Cogs::ResourceStatus::Pending;
      };
 
      struct {
        AtlasBlitVariant f;
        AtlasBlitVariant u;
 
        Cogs::BufferHandle paramBuffer = Cogs::BufferHandle::NoHandle;
        Cogs::SamplerStateHandle samplerState = Cogs::SamplerStateHandle::NoHandle;
        Cogs::TextureHandle sourceTexture = Cogs::TextureHandle::NoHandle;
        Cogs::DepthStencilStateHandle depthStencilState = Cogs::DepthStencilStateHandle::NoHandle;
        Cogs::BlendStateHandle blendState = Cogs::BlendStateHandle::NoHandle;
      } atlasBlit;
 
    };
 
    struct RayPickExtension : IRayPickable
    {
      RayPickExtension(Image360System* im360System);
 
      bool pickCamera(Context* context,
                      const CameraComponent& camera,
                      const glm::vec2& normPosition,
                      float /*rayLength*/,
                      float /*radius*/,
                      PickingFlags pickingFlags,
                      PicksReturned returnFlag,
                      const RayPicking::RayPickFilter& filter,
                      std::vector<RayPicking::RayPickHit>& hits) override;
 
      Image360System* im360System = nullptr;
    };
 
  }
 
  struct Image360Data
  {
    enum struct State {
      Uninitialized,
      Error,
      WaitingForJson,
      JsonParsed,
      WaitingForRendererReady,
      WaitingForBaseLevel,
      Running
    };
    State state = State::Uninitialized;
 
    std::string source;
    uint32_t valueChannel = 0;
    bool hasDepth = false;
 
    MaterialInstanceHandle materialInstance;
 
    Image360::Config config;
    Image360::Fetcher fetcher;
    Image360::Cache cache;
    Image360::DynamicLodTree lodTree;
    Image360::RendererExtensionData rendererData;
  };
 
  struct Image360System : public ComponentSystemWithDataPool<Image360Component, Image360Data>
  {
    using base = ComponentSystemWithDataPool<Image360Component, Image360Data>;
 
    Image360System(Memory::Allocator* allocator, SizeType capacity) : ComponentSystemWithDataPool(allocator, capacity) {}
 
    ~Image360System();
 
    void initialize(Context* context) override;
 
    void update(Context* context) override;
 
    ComponentHandle createComponent() override;
    void destroyComponent(ComponentHandle component) override;
 
    MaterialHandle material;
    uint32_t instanceCounter = 1;
 
  private:
    Image360::RendererExtension* renderer = nullptr;
    Image360::Bounds* bounds = nullptr;
    Image360::RayPickExtension* picker = nullptr;
  };
 
 
}