Image360System.cpp

#include "Context.h"
#include "ExtensionRegistry.h"
#include "Systems/Core/TransformSystem.h"
#include "Resources/DataFetcherManager.h"
#include "Resources/MaterialManager.h"
#include "Resources/TextureManager.h"
#include "Services/Time.h"
 
#include "Foundation/Logging/Logger.h"
 
#include "Rendering/ICapabilities.h"
#include "Rendering/IGraphicsDevice.h"
 
#include "Image360System.h"
 
namespace {
  using namespace Cogs::Core;
  using namespace Cogs::Core::Image360;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Image360");
 
  void resetComponentData(Image360::RendererExtension* renderer, Image360Data& data)
  {
    renderer->releaseRenderingResources(data.rendererData);
    data = Image360Data{};
    assert(data.state == Image360Data::State::Uninitialized);
  }
 
  bool lookupAndCheckForStaleness(Context* context, Image360System*& system, Image360Component*& comp, Image360Data*& data, const uint32_t instanceId)
  {
    system = ExtensionRegistry::getExtensionSystem<Image360System>(context);
    for (Image360Component& comp_ : system->pool) {
      Image360Data& data_ = system->getData(&comp_);
      if (data_.config.instanceId == instanceId) {
        comp = &comp_;
        data = &data_;
        return true;
      }
    }
    LOG_DEBUG(logger, "[instance=%u] Failed to lookup instance.", instanceId);
    return false;
  }
 
  void issueFetchJson(Context* context, Image360System* system, Image360Component& comp, Image360Data& data)
  {
    assert(data.state == Image360Data::State::Uninitialized);
 
    data.source = comp.source;
    if (data.source.empty()) return;
 
    data.config.instanceId = system->instanceCounter++;
    if (data.config.instanceId == 0) {
      data.config.instanceId = system->instanceCounter++;
    }
 
    auto handler = [context, instanceId = data.config.instanceId](std::unique_ptr<Cogs::FileContents> contents)
    {
      auto task = [context, instanceId, contents = contents.release()]
      {
        Image360System* system = nullptr;
        Image360Component* comp = nullptr;
        Image360Data* data = nullptr;
        if (!lookupAndCheckForStaleness(context, system, comp, data, instanceId)) {
          LOG_WARNING(logger, "Ignoring stale json file");
        }
        else if(data->state != Image360Data::State::WaitingForJson) {
          LOG_WARNING(logger, "Ignoring unexpected json file");
        }
        else if (!contents) {
          LOG_ERROR(logger, "Failed to fetch json file");
          data->state = Image360Data::State::Error;
        }
        else if (!data->config.parseConfigJson(contents)) {
          LOG_ERROR(logger, "Failed to parse json file (source=%.*s)", StringViewFormat(contents->origin()));
          data->state = Image360Data::State::Error;
        }
        else {
          LOG_DEBUG(logger, "json file parsed successfully (source=%.*s)", StringViewFormat(contents->origin()));
          data->state = Image360Data::State::JsonParsed;
        }
        delete contents;
        context->engine->setDirty();
      };
      context->engine->runTaskInMainThread(std::move(task));
    };
 
    LOG_DEBUG(logger, "Fetching json %s", data.source.c_str());
    data.state = Image360Data::State::WaitingForJson;
    DataFetcherManager::fetchAsync(context, data.source, handler);
  }
 
}
 
Cogs::Core::Image360System::~Image360System()
{
  assert(!renderer);
  assert(!bounds);
}
 
ComponentHandle Cogs::Core::Image360System::createComponent()
{
  if (pool.size() == 0) {
 
    if (material == MaterialHandle::NoHandle) {
      material = context->materialManager->loadMaterial("Materials/Image360.material");
      context->materialManager->processLoading();
    }
 
    assert(!renderer);
    renderer = new Image360::RendererExtension();
    context->renderer->registerExtension(renderer);
 
    assert(!bounds);
    bounds = new Image360::Bounds(this);
    context->bounds->addBoundsExtension(bounds);
 
    assert(!picker);
    picker = new Image360::RayPickExtension(this);
    context->rayPicking->addPickable(picker);
 
    LOG_DEBUG(logger, "First component created, registered image 360 renderer, bounds and raypick extensions");
  }
 
  ComponentHandle handle = ComponentSystemWithDataPool::createComponent();
 
  return handle;
}
 
void Cogs::Core::Image360System::destroyComponent(ComponentHandle handle)
{
  Image360Component* im360Comp = static_cast<Image360Component*>(handle.resolve());
  Image360Data& im360Data = getData(im360Comp);
  resetComponentData( renderer, im360Data);
 
  ComponentSystemWithDataPool::destroyComponent(handle);
  if (pool.size() == 0) {
 
    assert(renderer);
    renderer->release();
    context->renderer->unregisterExtension(renderer);
    delete renderer;
    renderer = nullptr;
 
    assert(bounds);
    context->bounds->removeBoundsExtension(bounds);
    delete bounds;
    bounds = nullptr;
 
    assert(picker);
    context->rayPicking->removePickable(picker);
    delete picker;
    picker = nullptr;
 
    LOG_DEBUG(logger, "Last component destroyed, unregistered image 360 renderer, bounds and raypick extensions");
  }
}
 
 
void Cogs::Core::Image360System::initialize(Context* context)
{
  base::initialize(context);
}
 
void Cogs::Core::Image360System::update(Context* /*context*/)
{
  CpuInstrumentationScope(SCOPE_POTREE, "Image360System::update");
 
  const GraphicsDeviceCapabilities& caps = context->renderer->getDevice()->getCapabilities()->getDeviceCapabilities();
 
 
  // Limit due to we use the positive part of uin16 for indexing, where the lower
  // three bits are used to offset into parent textures.
  uint32_t cacheMaxCount = 0x8000u >> 3u;
 
  if (const Variable* var = context->variables->get("image360.cacheMaxCount"); !var->isEmpty()) {
    cacheMaxCount = std::min(cacheMaxCount, uint32_t(std::max(6, var->getInt())));
  }
  else {
    context->variables->set("image360.cacheMaxCount", int(cacheMaxCount));
  }
 
  uint32_t treeMaxSize = caps.MaxTexture2DSize;
  if (const Variable* var = context->variables->get("image360.treeMaxSize");  !var->isEmpty()) {
    treeMaxSize = std::min(treeMaxSize, uint32_t(std::max(6, var->getInt())));
  }
  else {
    context->variables->set("image360.treeMaxSize", int(treeMaxSize));
  }
 
  uint32_t maxConcurrent = 2;
  if (const Variable* var = context->variables->get("image360.maxConcurrentRequests"); !var->isEmpty()) {
    maxConcurrent = uint32_t(std::max(1, var->getInt()));
  }
  else {
    context->variables->set("image360.maxConcurrentRequests", int(maxConcurrent));
  }
 
 
  for (Image360Component& im360Comp : pool) {
 
    Image360Data& im360Data = getData(&im360Comp);
    if (im360Data.config.baseSize) {
      im360Data.config.cacheMaxCount = std::min(cacheMaxCount, caps.MaxTextureArrayLayers);
      im360Data.config.treeMaxSize = treeMaxSize;
    }
    else {
      im360Data.config.cacheMaxCount = 0;
      im360Data.config.treeMaxSize = 0;
    }
    im360Data.config.maxConcurrent = maxConcurrent;
 
    if (!im360Comp.isVisible()) {
      if (im360Data.state != Image360Data::State::Uninitialized) {
        resetComponentData(renderer, im360Data);
        assert(im360Data.state == Image360Data::State::Uninitialized);
      }
      continue;
    }
 
    if ((im360Data.valueChannel != im360Comp.valueChannel) ||
        (im360Data.hasDepth != im360Comp.hasDepth) ||
        (im360Data.source != im360Comp.source))
    {
      if (im360Data.state != Image360Data::State::Uninitialized) {
        resetComponentData(renderer, im360Data);
        assert(im360Data.state == Image360Data::State::Uninitialized);
      }
      im360Data.valueChannel = im360Comp.valueChannel;
      im360Data.hasDepth = im360Comp.hasDepth;
      im360Data.source = im360Comp.source;
      issueFetchJson(context, this, im360Comp, im360Data);
      continue;
    }
 
    if (im360Comp.hasChanged()) {
 
      if (HandleIsValid(im360Data.materialInstance)) {
        im360Data.materialInstance->setVariant("DebugColors", im360Comp.debugColors);
        im360Data.materialInstance->setVariant("DebugDepth", im360Comp.debugDepth);
      }
    }
 
    const uint32_t currentFrame = context->time->getFrame();
    im360Data.fetcher.processLoadItems(context, im360Comp, im360Data.cache, im360Data.config, currentFrame);
 
    if (im360Data.state == Image360Data::State::JsonParsed) {
 
      im360Data.materialInstance = context->materialInstanceManager->createMaterialInstance(material);
      im360Data.materialInstance->setVariant("DebugColors", im360Comp.debugColors);
      im360Data.materialInstance->setVariant("TreeDepth", int(im360Data.config.treeDepth));
 
      im360Data.materialInstance->setVariant("HasGradient", HandleIsValid(im360Comp.gradient));
      im360Data.materialInstance->setTextureProperty("gradient", im360Comp.gradient);
 
      im360Data.config.valueChannel = im360Comp.valueChannel < im360Data.config.channels.size() ? uint8_t(im360Comp.valueChannel) : 0;
      switch (im360Data.config.channels[im360Data.config.valueChannel].dataType)
      {
      case Config::Channel::DataType::SRGB8_JPEG: [[fallthrough]];
      case Config::Channel::DataType::SRGB8_PNG:
        im360Data.materialInstance->setVariant("ValueType", "srgb");
        im360Data.rendererData.isValueUint = false;
        break;
      case Config::Channel::DataType::SRGBA8_PNG:
        im360Data.materialInstance->setVariant("ValueType", "srgb");
        im360Data.rendererData.isValueUint = false;
        break;
      case Config::Channel::DataType::U16: [[fallthrough]];
      case Config::Channel::DataType::U16_ZST:
        im360Data.materialInstance->setVariant("ValueType", "uint");
        im360Data.rendererData.isValueUint = true;
        break;
      default:
        break;
      }
 
      im360Data.config.hasDepth = im360Comp.hasDepth && im360Data.config.depthChannel < im360Data.config.channels.size();
      if (im360Data.config.hasDepth) {
        im360Data.materialInstance->options.depthTestEnabled = true;
        im360Data.materialInstance->setVariant("HasDepth", true);
        im360Data.materialInstance->setVariant("DiscardNoDepth", im360Data.config.discardNoDepth);
        im360Data.materialInstance->setVariant("DebugDepth", im360Comp.debugDepth);
      }
      else {
        im360Data.materialInstance->options.depthTestEnabled = false;
        im360Data.materialInstance->setVariant("HasDepth", false);
      }
 
      im360Data.cache.init(im360Data.config);
      im360Data.state = Image360Data::State::WaitingForBaseLevel;
    }
 
    if (im360Data.state == Image360Data::State::WaitingForBaseLevel) {
      bool ready = true;
      for (size_t i = 0; i < 6; i++) {
        if (im360Data.cache.isQuadInCache(context,  im360Data.fetcher, im360Comp, im360Data.config, currentFrame, 0, i) < 0) {
          ready = false;
        }
      }
      if (ready) {
        LOG_DEBUG(logger, "Base level in cache");
        context->engine->invokeComponentNotifyCallback(im360Comp, (int)Image360Notification::Ready, nullptr, 0);
        im360Data.state = Image360Data::State::Running;
      }
    }
 
 
    if (im360Data.state == Image360Data::State::Running && !im360Comp.disableLodUpdates) {
      im360Data.lodTree.update(context, im360Data.rendererData, im360Data.fetcher, im360Data.cache, im360Comp, im360Data.config,  currentFrame, im360Comp);
      im360Data.cache.updateLeastRecentlyUsedList(currentFrame);
    }
  }
}