TexAtlasSystem.cpp

#include "Context.h"
#include "Foundation/Logging/Logger.h"
 
#include "Rendering/ICapabilities.h"
 
#include "Utilities/Math.h"
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/TransformSystem.h"
#include "Resources/Material.h"
#include "Resources/MaterialInstance.h"
#include "Resources/TextureManager.h"
#include "Services/Time.h"
#include "TexAtlasSystem.h"
#include "TexAtlasRenderer.h"
 
using namespace Cogs::Core::TexAtlas;
 
namespace {
  using namespace Cogs::Core;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("TexAtlas");
 
  const Cogs::StringView lodFreezeName = "texAtlas.lodFreeze";
  const Cogs::StringView atlasLayoutLogName = "texAtlas.atlasLayout.log";
 
  const size_t slotCount = 4;
 
  Layout getLayout(const glm::dvec2& domainMin, const glm::dvec2& domainMax, const uint32_t minLevel, const uint32_t maxLevel)
  {
    // Base level s.t. a tile roughly matches the domain, snapped to valid range
    double domainSize = std::max(domainMax.x - domainMin.x,
                                 domainMax.y - domainMax.y);
    uint32_t level = static_cast<uint32_t>(std::max(0.0, std::round(-std::log2(domainSize))));
    if (level < minLevel) level = minLevel;
    if (maxLevel < level) level = maxLevel;
 
    const uint32_t tileScale = 1<<level;
 
 
    // Figure out the grid size at the level. We restrict it to the maximum number of
    // grids that is defined, and rather do wrap-around in the shader.
    glm::ivec2 maxGridSizeAtLevel = glm::ivec2(1 << level);
    glm::ivec2 minGridCell = glm::ivec2(glm::floor(static_cast<float>(tileScale) * glm::vec2(domainMin)));
    glm::ivec2 maxGridCell = glm::ivec2(glm::floor(static_cast<float>(tileScale) * glm::vec2(domainMax))) + glm::ivec2(1);
    glm::uvec2 size = glm::max(glm::ivec2(0), glm::min(maxGridSizeAtLevel, maxGridCell - minGridCell));
 
    return Layout{
      .offset = minGridCell,
      .size = size,
      .tileScale = tileScale,
      .level = level,
      .maxLevel = maxLevel
    };
  }
}
 
void Cogs::Core::TexAtlasSystem::initialize(Context* context)
{
  base::initialize(context);
 
  materialKeys.resize(slotCount);
  for (size_t slot = 0; slot < slotCount; slot++) {
    const std::string indexString = std::to_string(slot);
    materialKeys[slot].level = "TexAtlasLevels" + indexString;
    materialKeys[slot].floatCoeffs = "texAtlasFloatCoeffs" + indexString;
    materialKeys[slot].intCoeffs = "texAtlasIntCoeffs" + indexString;
    materialKeys[slot].tile = "texAtlasTiles" + indexString;
    materialKeys[slot].tree = "texAtlasTree" + indexString;
  }
}
 
ComponentHandle Cogs::Core::TexAtlasSystem::createComponent()
{
  if (pool.size() == 0) {
    LOG_DEBUG(logger, "Creating first component, creating renderer.");
    assert(renderer == nullptr);
    renderer = new TexAtlasRenderer(this);
    context->renderer->registerExtension(renderer);
  }
  return base::createComponent();
}
 
void Cogs::Core::TexAtlasSystem::destroyComponent(ComponentHandle component)
{
  base::destroyComponent(component);
  if (pool.size() == 0) {
    LOG_DEBUG(logger, "Destroying last component, destroying renderer.");
    trackedMaterials.clear();
    assert(renderer);
    context->renderer->unregisterExtension(renderer);
    delete renderer;
    renderer = nullptr;
  }
}
 
 
void Cogs::Core::TexAtlasSystem::update(Context* context)
{
  if (pool.size() == 0) return;
 
 
  const uint32_t maxItemCount = context->renderer->getDevice()->getCapabilities()->getDeviceCapabilities().MaxTextureArrayLayers;
  const uint32_t currentFrame = context->time->getFrame();
  const uint32_t currentTime = static_cast<uint32_t>(std::floor(context->time->getAnimationTime()));  // Time in seconds in 32-bits should be sufficent for our uses.
 
 
  bool lodFreeze = context->variables->getOrAdd(lodFreezeName, false);
  renderer->renderFrustum = lodFreeze;
 
  bool atlasLayoutLog = context->variables->getOrAdd(atlasLayoutLogName, false);
 
  if (!lodFreeze) {
    const glm::vec3 p[8] = {
      glm::vec3(-1.f, -1.f, -1.f),
      glm::vec3( 1.f, -1.f, -1.f),
      glm::vec3( 1.f,  1.f, -1.f),
      glm::vec3(-1.f,  1.f, -1.f),
      glm::vec3(-1.f, -1.f,  1.f),
      glm::vec3( 1.f, -1.f,  1.f),
      glm::vec3( 1.f,  1.f,  1.f),
      glm::vec3(-1.f,  1.f,  1.f)
    };
 
    const CameraData& mainCamData = context->cameraSystem->getMainCameraData();
    glm::mat4 PVinv = glm::inverse(mainCamData.rawViewProjection);
    for (size_t i = 0; i < 8; i++) {
      renderer->frustumCorners[i] = glm::vec4(euclidean(PVinv * glm::vec4(p[i], 1.f)), 1.f);
    }
  }
 
  for (auto& item : trackedMaterials) {
    TrackedMaterial& trackedMaterial = item.second;
    for (TexAtlasComponent*& slot : trackedMaterial.slots) {
      slot = nullptr;
    }
  }
 
  TransformSystem* transformSystem = context->transformSystem;
 
  for (TexAtlasComponent& texAtlasComp : pool) {
 
    TexAtlasData& texAtlasData = getData(&texAtlasComp);
    texAtlasData.levels = 0;  // Set as disabled, will be set to actual max level when all sanity checks have passed
 
    if (texAtlasData.inUse) {
      texAtlasData.inUse = false;
    }
    else if (texAtlasComp.materials.empty()) continue;
 
    if (4 <= texAtlasComp.index) continue;
    if ((texAtlasComp.domainMax.x <= texAtlasComp.domainMin.x) ||
        (texAtlasComp.domainMax.y <= texAtlasComp.domainMin.y)) continue;
 
    TexAtlas::Geometry& geo = texAtlasData.geometry;
    
    texAtlasComp.maxLevel = std::min(28u, texAtlasComp.maxLevel);                   // Sanity check. Tile x & y get 29 bits in tile key.
    texAtlasComp.minLevel = std::min(texAtlasComp.minLevel, texAtlasComp.maxLevel); // enforce minlevel <= maxlevel
 
    geo.domain[0] = texAtlasComp.domainMin;
    geo.domain[1] = texAtlasComp.domainMax;
    geo.invDomainMapShift = -glm::vec2(geo.domain[0]);
    geo.invDomainMapScale = glm::vec2(1.f) / glm::vec2(geo.domain[1] - geo.domain[0]);
 
 
    texAtlasData.layout = getLayout(texAtlasData.geometry.domain[0],
                                    texAtlasData.geometry.domain[1],
                                    texAtlasComp.minLevel,
                                    texAtlasComp.maxLevel);
 
    texAtlasData.fetcher.datasetExtentMin = texAtlasComp.domainExtentsMin;
    texAtlasData.fetcher.datasetExtentMax = texAtlasComp.domainExtentsMax;
 
    texAtlasData.fetcher.update(context, currentFrame, currentTime, texAtlasComp.timeout, texAtlasComp.path);
    texAtlasData.cache.update(currentFrame, currentTime, texAtlasComp.minRetryDelay, std::min(texAtlasComp.maxItemCount, maxItemCount));
    texAtlasData.tree.update(context, texAtlasData.geometry, texAtlasData.cache, texAtlasData.fetcher, texAtlasData.layout, std::max(1.f / 8192.f, texAtlasComp.tolerance), texAtlasComp.restrictBetweenNearAndFar, lodFreeze);
    texAtlasData.fetcher.processLoadQueue(context, texAtlasData.cache);
 
    // Only update tree texture when it has changed
    {
      std::vector<uint16_t>& encoded = texAtlasData.tree.encoded;
      size_t treeHashValue = Cogs::hash(encoded.data(), sizeof(encoded[0]) * encoded.size());
      if (!texAtlasData.treeTex ||
          (texAtlasData.treeTex->description.width != encoded.size()) ||
          (texAtlasData.treeHashValue != treeHashValue))
      {
        texAtlasData.treeTex = context->textureManager->loadTexture(texAtlasData.tree.encoded.data(),
                                                                    ResourceDimensions::Texture2D,
                                                                    static_cast<int>(texAtlasData.tree.encoded.size()), 1, 1, 1,
                                                                    TextureFormat::R16_UINT, 0, texAtlasData.treeTex,
                                                                    TextureLoadFlags::NoMipMaps | TextureLoadFlags::ForceSynchronous);
        texAtlasData.treeHashValue = treeHashValue;
      }
    }
 
 
    if (texAtlasData.fetcher.tileWidth != 0 && texAtlasData.fetcher.tileHeight != 0) {
 
      uint32_t currentSlotCount = texAtlasData.tilesTex ? texAtlasData.tilesTex->description.layers : 0;
      uint32_t newSlotCount = currentSlotCount;
 
      if (currentSlotCount < texAtlasData.cache.slots.size()) {
        newSlotCount = std::min(texAtlasData.cache.maxItemCount, std::max(static_cast<uint32_t>(texAtlasData.cache.slots.size()), (currentSlotCount * 3 + 1) / 2));
        if (atlasLayoutLog) {
          LOG_DEBUG(logger, "Growing to %u tiles", newSlotCount);
        }
      }
 
      if (texAtlasData.cache.slots.size() < currentSlotCount / 2) {
        newSlotCount = std::max(static_cast<uint32_t>(1), currentSlotCount / 2);
        if (atlasLayoutLog) {
          LOG_DEBUG(logger, "Shrinking to %u tiles", newSlotCount);
        }
      }
 
      if (currentSlotCount != newSlotCount) {
 
        if (texAtlasData.tilesOldTex) {
          // If tilesOldTex contains a texture, renderer hasn't run and blitted existing tiles out of the old
          // texture populating the new texture in tilesTex, so we just overwrite the previous new texture and
          // keep the old texture.
        }
        else {
          texAtlasData.tilesOldTex = texAtlasData.tilesTex;
        }
        texAtlasData.tilesTex = context->textureManager->loadTexture(nullptr,
                                                                     ResourceDimensions::Texture2DArray,
                                                                     texAtlasData.fetcher.tileWidth, texAtlasData.fetcher.tileHeight, 1, newSlotCount,
                                                                     TextureFormat::R8G8B8A8_UNORM_SRGB, 0, TextureHandle::NoHandle,
                                                                     TextureLoadFlags::NoMipMaps | TextureLoadFlags::ForceSynchronous | TextureLoadFlags::RenderTarget);
      }
    }
 
    switch (texAtlasComp.projection) {
    case TexAtlasProjection::WorldSpaceBilinear:
      if (texAtlasComp.coefficients.size() != 4) continue;
 
      for (size_t i = 0; i < 4; i++) {
        texAtlasData.geometry.coefficients[i] = transformSystem->engineFromWorldCoords(glm::dvec3(texAtlasComp.coefficients[i], 0.f));
      }
      texAtlasData.geometry.elevationMin = transformSystem->engineFromWorldCoords(glm::dvec3(0.0, 0.0, double(texAtlasComp.elevation))).z;
      texAtlasData.geometry.elevationMax = transformSystem->engineFromWorldCoords(glm::dvec3(0.0, 0.0, double(texAtlasComp.elevation))).z;
      break;
 
    default:
      continue;
    }
 
    // Shader constants
    uint32_t tileScale = (1 << texAtlasData.layout.level);
    glm::vec2 gridFromUnitScale = glm::vec2(double(tileScale) * (texAtlasData.geometry.domain[1] - texAtlasData.geometry.domain[0]));
    glm::vec2 gridFromUnitOffset = glm::vec2(double(tileScale) * texAtlasData.geometry.domain[0] - glm::dvec2(texAtlasData.layout.offset));
    texAtlasData.floatCoefficients = glm::mat4(glm::vec4(texAtlasData.geometry.coefficients[0], texAtlasData.geometry.coefficients[1]),
                                               glm::vec4(texAtlasData.geometry.coefficients[2], texAtlasData.geometry.coefficients[3]),
                                               glm::vec4(gridFromUnitScale, gridFromUnitOffset),
                                               glm::vec4(tileScale, 0.f, 0.f, 0.f));
    texAtlasData.intCoefficients = glm::ivec4(int(tileScale - 1u), texAtlasData.layout.size.x, 0, 0);
    texAtlasData.levels = static_cast<int>(texAtlasData.layout.maxLevel + 1 - texAtlasData.layout.level);
 
    const std::string indexString = std::to_string(texAtlasComp.index);
    for (MaterialHandle handle : texAtlasComp.materials) {
      if (!handle) continue;
 
      if (texAtlasComp.index < slotCount) {
        TrackedMaterial& tracked = trackedMaterials[handle.resolve()];
        tracked.material = handle;
        tracked.lastSeen = currentFrame;
        tracked.slots[texAtlasComp.index] = &texAtlasComp;
      }
 
#if 0
      if (texAtlasComp.index == 0) {
        LOG_DEBUG(logger, "level=%u off=[%d %d], size=[%d %d]",
                  texAtlasData.layout.level,
                  texAtlasData.layout.offset.x,
                  texAtlasData.layout.offset.y,
                  texAtlasData.layout.size.x,
                  texAtlasData.layout.size.y);
      }
#endif
 
    }
  }
 
  // Update slots in tracked materials
  for (auto& item : trackedMaterials) {
 
    TrackedMaterial& trackedMaterial = item.second;
    Material* mat = trackedMaterial.material.resolve();
    assert(mat);
    for (size_t slotIndex = 0; slotIndex < slotCount; slotIndex++) {
 
      const MaterialKeys& keys = materialKeys[slotIndex];
      if (TexAtlasComponent* texAtlasComp = trackedMaterial.slots[slotIndex]; texAtlasComp) {
        TexAtlasData& texAtlasData = getData(texAtlasComp);
 
        mat->setVariant(keys.level, texAtlasData.levels);
 
        if (VariableKey transformKey = mat->getMat4Key(keys.floatCoeffs); transformKey != NoProperty) {
          mat->setMat4Property(transformKey, texAtlasData.floatCoefficients);
        }
 
        if (VariableKey key = mat->getInt4Key(keys.intCoeffs); key != NoProperty) {
          mat->setInt4Property(key, texAtlasData.intCoefficients);
        }
 
        if (VariableKey key = mat->getTextureKey(keys.tile); key != NoProperty) {
          mat->setTextureProperty(key, texAtlasData.tilesTex);
          mat->setTextureAddressMode(key, Cogs::SamplerState::AddressMode::Clamp);
          mat->setTextureFilterMode(key, Cogs::SamplerState::FilterMode::MinMagMipLinear);
        }
 
        if (VariableKey key = mat->getTextureKey(keys.tree); key != NoProperty) {
          mat->setTextureProperty(key, texAtlasData.treeTex);
          mat->setTextureAddressMode(key, Cogs::SamplerState::AddressMode::Clamp);
          mat->setTextureFilterMode(key, Cogs::SamplerState::FilterMode::MinMagMipPoint);
        }
      }
      else {
        // Disable slot
        mat->setVariant(keys.level, 0);
      }
    }
  }
 
  // Stop tracking materials that we haven't seen this frame. Already have all slot levels set to zero.
  std::erase_if(trackedMaterials, [currentFrame](auto& item) { return item.second.lastSeen != currentFrame; });
}