OctAtlas.cpp

#include "Renderer/RenderStateUpdater.h"
#include "../Systems/OctSystem.h"
#include "OctAtlas.h"
 
#include "Foundation/Logging/Logger.h"
 
namespace {
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("OctAtlas");
 
 
}
 
void Cogs::Core::Volumetric::OctAtlas::reset(const DrawContext * renderingContext, const OctData& octData, const uint32_t tileSize, const uint32_t gpuCacheSize, const uint32_t currentTimestamp)
{
  auto * device = renderingContext->device;
 
  auto * iContext = device->getImmediateContext();
  auto * textures = device->getTextures();
 
  if (HandleIsValid(textureAtlas0)) textures->releaseTexture(textureAtlas0);
  textureAtlas0 = Cogs::TextureHandle::NoHandle;
 
  if (HandleIsValid(textureAtlas1)) textures->releaseTexture(textureAtlas1);
  textureAtlas1 = Cogs::TextureHandle::NoHandle;
 
  slots.resize(gpuCacheSize * gpuCacheSize * gpuCacheSize);
  for (size_t i = 0; i < slots.size(); i++) {
    slots[i].tileKey = ~uint64_t(0);
    slots[i].timestampNeeded = currentTimestamp - 1u;
    slots[i].timestapUpdated = currentTimestamp - 1u;
    slots[i].flags = Slot::None;
  }
 
  slotsLUT.clear();
 
  slotsLRU.clear();
  for (size_t i = 1; i < slots.size(); i++) {
    slotsLRU.push_back(uint32_t(i));
  }
 
  // Create new atlas texture
  TextureDescription desc;
  auto size = tileSize * gpuCacheSize;
  desc.target = ResourceDimensions::Texture3D;
  desc.width = size;
  desc.height = size;
  desc.depth = size;
  desc.layers = 1;
  desc.faces = 1;
  desc.levels = 1;
  desc.samples = 1;
  desc.flags = TextureFlags::Default;
  desc.format = TextureFormat::R32G32B32A32_FLOAT;
  textureAtlas0 = textures->loadTexture(desc, nullptr);
  switch (octData.source)
  {
  case OctSource::Value: break;
  case OctSource::ValueAge:
    desc.format = TextureFormat::R32_FLOAT;
    textureAtlas1 = textures->loadTexture(desc, nullptr);
    break;
  }
 
 
 
  // stager stuff:
  for (auto & h : toCopy) {
    textures->releaseTexture(h.texture0);
    if(HandleIsValid(h.texture1)) textures->releaseTexture(h.texture1);
  }
  toCopy.clear();
  for (auto & h : stagingUnused) {
    textures->releaseTexture(h.texture0);
    if (HandleIsValid(h.texture1)) textures->releaseTexture(h.texture1);
  }
  stagingUnused.clear();
 
  // Create new staging textures
  while (stagingUnused.size() < 10) {
    TextureDescription stagingDesc;
    stagingDesc.target = ResourceDimensions::Texture3D;
    stagingDesc.width = tileSize;
    stagingDesc.height = tileSize;
    stagingDesc.depth = tileSize;
    stagingDesc.layers = 1;
    stagingDesc.faces = 1;
    stagingDesc.levels = 1;
    stagingDesc.samples = 1;
    stagingDesc.format = TextureFormat::R32G32B32A32_FLOAT;
    stagingDesc.flags = TextureFlags::UsageWriteStaging;
    auto tex0 = textures->loadTexture(stagingDesc, nullptr);
    auto tex1 = Cogs::TextureHandle::NoHandle;
    switch (octData.source)
    {
    case OctSource::Value: break;
    case OctSource::ValueAge:
      stagingDesc.format = TextureFormat::R32_FLOAT;
      tex1 = textures->loadTexture(stagingDesc, nullptr);
      break;
    }
    stagingUnused.push_back(Item{ tex0, tex1, {}, {} });
  }
  assert(!stagingUnused.empty() && "Must have at least one staging texture");
 
  // Stage zero-texture
  toCopy.push_back(stagingUnused.back());
  stagingUnused.pop_back();
  uint32_t rowPitch, depthPitch;
  if (auto* ptr = reinterpret_cast<char*>(iContext->map(toCopy.back().texture0, MapMode::Write, &rowPitch, &depthPitch)); ptr != nullptr) {
    for (size_t k = 0; k < tileSize; k++) {
      for (size_t j = 0; j < tileSize; j++) {
        auto * p = reinterpret_cast<glm::vec4*>(ptr + k*depthPitch + j*rowPitch);
        for (size_t i = 0; i < tileSize; i++) {
          auto ii = (i >> 3) & 1;
          auto jj = (j >> 3) & 1;
          auto kk = (k >> 3) & 1;
          *p++ = glm::vec4(1, 1, 1, (ii ^ jj ^ kk) ? 1.f : 0.f);
        }
      }
    }
    iContext->unmap(toCopy.back().texture0);
  }
  if (HandleIsValid(toCopy.back().texture1)) {
    if (auto* ptr = reinterpret_cast<char*>(iContext->map(toCopy.back().texture0, MapMode::Write, &rowPitch, &depthPitch)); ptr != nullptr) {
      for (size_t k = 0; k < tileSize; k++) {
        for (size_t j = 0; j < tileSize; j++) {
          auto * p = reinterpret_cast<float*>(ptr + k*depthPitch + j*rowPitch);
          for (size_t i = 0; i < tileSize; i++) {
            auto ii = (i >> 3) & 1;
            auto jj = (j >> 3) & 1;
            auto kk = (k >> 3) & 1;
            *p++ = (ii ^ jj ^ kk) ? 1.f : 0.f;
          }
        }
      }
      iContext->unmap(toCopy.back().texture1);
    }
  }
  toCopy.back().slot = 0;
  toCopy.back().delay = 1;
}
 
 
unsigned Cogs::Core::Volumetric::OctAtlas::checkTile(const uint64_t tileKey, const uint32_t nodeTimestamp, const uint32_t currentTimestamp)
{
  auto it = slotsLUT.find(tileKey);
  if (it != slotsLUT.end()) {
    auto & slot = slots[it->second];
    slot.timestampNeeded = currentTimestamp;
 
    auto nodeAge = currentTimestamp - nodeTimestamp;
    auto cacheAge = currentTimestamp - slot.timestapUpdated;
 
    if ((slot.flags & Slot::InStaging) != 0) {
      // Don't re-issue requests while a tile is in staging.
      return 0;
    }
    else if (nodeAge < cacheAge || (slot.flags & Slot::Invalid) != 0) {
      //LOG_DEBUG(logger, "expired tile %llx", tileKey);
      slot.flags = (Slot::Flags)(slot.flags | Slot::Invalid);
      return cacheAge;
    }
    else  {
      // Tile should be good and ready to be used.
      return 0;
    }
  }
  else {
    //LOG_DEBUG(logger, "Unknown tile %llx", tileKey);
    return std::numeric_limits<unsigned>::max();  // Never seen tile, max out-of-date.
  }
}
 
void Cogs::Core::Volumetric::OctAtlas::enforceOrder(const uint32_t currentTimestamp)
{
  slotsLRU.sort([&](const auto& a, const auto& b) -> bool
  {
    return (currentTimestamp - slots[a].timestampNeeded) > (currentTimestamp - slots[b].timestampNeeded);
  });
}
 
 
glm::uvec4 Cogs::Core::Volumetric::OctAtlas::slotPosition(const OctComponent& octComp, const uint64_t tileKey) const
{
  unsigned slot = 0;
  auto it = slotsLUT.find(tileKey);
  if (it != slotsLUT.end()) {
    //if ((slots[it->second].flags & Slot::InStaging) == 0) {   // Replace InStaging with NoData to remove flickering.
    if ((slots[it->second].flags & Slot::NoData) == 0) {
      slot = it->second;
      assert(slot != 0);
    }
  }
  return glm::uvec4(slot % octComp.gpuCacheSize,
                    (slot / octComp.gpuCacheSize) % octComp.gpuCacheSize,
                    (slot / octComp.gpuCacheSize) / octComp.gpuCacheSize,
                    slot);
}
 
 
 
void Cogs::Core::Volumetric::OctAtlas::handleStaging(const DrawContext * renderingContext, OctComponent& octComp, OctData& octData, const uint32_t currentTimestamp, unsigned delay)
{
  delay = std::max(1u, delay);
 
  auto * device = renderingContext->device;
  auto * iContext = device->getImmediateContext();
 
  // FIXME: check layout hash.
 
  for (auto & item : toCopy) {
    item.delay--;
 
    if (item.delay == 0) {
      unsigned i = octComp.tileSize*(item.slot % octComp.gpuCacheSize);
      unsigned j = octComp.tileSize*((item.slot / octComp.gpuCacheSize) % octComp.gpuCacheSize);
      unsigned k = octComp.tileSize*((item.slot / octComp.gpuCacheSize) / octComp.gpuCacheSize);
      iContext->copyTexture(octData.atlas.textureAtlas0, 0, i, j, k, item.texture0, 0);
      if (HandleIsValid(octData.atlas.textureAtlas1)) {
        iContext->copyTexture(octData.atlas.textureAtlas1, 0, i, j, k, item.texture1, 0);
      }
      //LOG_DEBUG(logger, "Copied tile %llx into slot %x, flags=%x", slots[item.slot].tileKey, item.slot, slots[item.slot].flags);
      slots[item.slot].flags = OctAtlas::Slot::None;
    }
 
  }
 
  enforceOrder(octData.currentTimestamp);
 
 
  if (!stagingUnused.empty()) {
    while (!octData.tileResponses.empty() && !stagingUnused.empty()) {
      uint32_t slot = 0;
 
      auto res = std::move(octData.tileResponses.back());
      octData.tileResponses.pop_back();
 
      auto it = slotsLUT.find(res->tileKey);
      if (it != slotsLUT.end()) {
        slot = it->second;    // updating existing tile
        //LOG_DEBUG(logger, "Updating existing tile %llx, slot %d", res->tileKey, slot);
      }
      else if (slots[slotsLRU.front()].timestampNeeded != currentTimestamp) {
        slot = slotsLRU.front();
        slotsLRU.pop_front();
        slotsLRU.push_back(slot);
 
        octData.atlas.slotsLUT.erase(slots[slot].tileKey);
        octData.atlas.slotsLUT[res->tileKey] = slot;
        slots[slot].flags = OctAtlas::Slot::NoData;
        //LOG_DEBUG(logger, "Evicting tile %llx, slot %d", slots[slot].tileKey, slot);
      }
 
      if (slot != 0) {
        assert(res->data0.size() == octComp.tileSize * octComp.tileSize * octComp.tileSize);
 
        slots[slot].tileKey = res->tileKey;
        slots[slot].clientData = res->clientData;
        slots[slot].timestapUpdated = res->timestamp;
        slots[slot].flags = (OctAtlas::Slot::Flags)(slots[slot].flags | OctAtlas::Slot::InStaging);
 
        toCopy.push_back(stagingUnused.back());
        stagingUnused.pop_back();
        auto & stage = toCopy.back();
        stage.slot = slot;
        stage.delay = delay;
        
        uint32_t rowPitch, depthPitch;
        if (auto* ptr = reinterpret_cast<char*>(iContext->map(stage.texture0, MapMode::Write, &rowPitch, &depthPitch)); ptr != nullptr) {
          for (size_t k = 0; k < octComp.tileSize; k++) {
            for (size_t j = 0; j < octComp.tileSize; j++) {
              std::memcpy(ptr + k*depthPitch + j*rowPitch,
                          res->data0.data() + ((k*octComp.tileSize + j)*octComp.tileSize),
                          sizeof(glm::vec4)*octComp.tileSize);
 
            }
          }
          iContext->unmap(stage.texture0);
        }
        if (HandleIsValid(stage.texture1)) {
          assert(res->data1.size() == size_t(octComp.tileSize) * size_t(octComp.tileSize) * size_t(octComp.tileSize));
          if (auto* ptr = reinterpret_cast<char*>(iContext->map(stage.texture1, MapMode::Write, &rowPitch, &depthPitch)); ptr != nullptr) {
            for (size_t k = 0; k < octComp.tileSize; k++) {
              for (size_t j = 0; j < octComp.tileSize; j++) {
                std::memcpy(ptr + k*depthPitch + j*rowPitch,
                            res->data1.data() + ((k*octComp.tileSize + j)*octComp.tileSize),
                            sizeof(float)*octComp.tileSize);
              }
            }
            iContext->unmap(stage.texture0);
          }
        }
        //LOG_DEBUG(logger, "Inserted %llx into slot %x", slots[slot].tileKey, slot);
      }
      else {
        LOG_DEBUG(logger, "Trashing");
      }
 
      octData.tileResponsesStash.push_back(std::move(res));
    }
  }
  else {
    //LOG_DEBUG(logger, "No staging buffers available");
  }
 
  // recycle copied.
  std::vector<Item> unfinishedCopies;
  unfinishedCopies.reserve(toCopy.size());
  for (auto & item : toCopy) {
    if (item.delay == 0) {
      stagingUnused.push_back(item);
    }
    else {
      unfinishedCopies.push_back(item);
    }
  }
  toCopy.clear();
  toCopy.swap(unfinishedCopies);
}