OctComponent.cpp

#include "OctComponent.h"
#include "Types.h"
#include "../Systems/OctSystem.h"
 
using namespace Cogs::Reflection;
 
void Cogs::Core::Volumetric::OctComponent::registerType()
{
  Field fields[] = {
    Field(Name("valueMin"), &OctComponent::valueMin),
    Field(Name("valueMax"), &OctComponent::valueMax),
    Field(Name("turbidity"), &OctComponent::turbidity),
    Field(Name("ageScale"), &OctComponent::ageScale),
    Field(Name("forceWipe"), &OctComponent::forceWipe),
    Field(Name("drawDebug"), &OctComponent::drawDebug),
    Field(Name("tolerance"), &OctComponent::tolerance),
    Field(Name("blockShift"), &OctComponent::blockShift),
    Field(Name("blockExtent"), &OctComponent::blockExtent),
    Field(Name("tileSize"), &OctComponent::tileSize),
    Field(Name("gpuCacheSize"), &OctComponent::gpuCacheSize),
    Field(Name("transferTexture"), &OctComponent::transferTexture),
  };
 
  Method methods[] = {
    Method(Name("initTileResponse"), &OctComponent::initTileResponse),
    Method(Name("submitTileResponse"), &OctComponent::submitTileResponse),
  };
 
  Reflection::TypeDatabase::createType<OctComponent>()
    .setFields(fields)
    .setMethods(methods)
    .setBase<Component>();
}
 
Cogs::Core::Volumetric::TileResponse* Cogs::Core::Volumetric::OctComponent::initTileResponse(const TileRequest* req)
{
  CpuInstrumentationScope(SCOPE_VOLUMETRIC, "OctComponent::initTileResponse");
  auto & octData = system->getData(this);
  if (octData.tileResponsesStash.empty()) return nullptr;
 
  auto res = std::move(octData.tileResponsesStash.back());
  octData.tileResponsesStash.pop_back();
 
  auto i = int16_t(req->tileKey & 0xffffu);
  auto j = int16_t((req->tileKey >> 16u) & 0xffffu);
  auto k = int16_t((req->tileKey >> 32u) & 0xffffu);
  auto w = int16_t((req->tileKey >> 48u) & 0xffffu);
 
  //glm::ivec4 ix4(int(i) - octData.alignMinToZeroShift.x,
  //               int(j) - octData.alignMinToZeroShift.y,
  //               int(k) - octData.alignMinToZeroShift.z,
  //               int(w));
 
  // FIXME: Tile requests for upper-level nodes should be split as these have lots of regions.
 
  glm::ivec3 lll(i, j, k);
  glm::ivec3 uuu = lll + glm::ivec3(1u << w);
 
  // Find intersecting regions.
  res->regionKeys.clear();
  for (int z = lll.z; z < uuu.z; z++) {
    for (int y = lll.y; y < uuu.y; y++) {
      for (int x = lll.x; x < uuu.x; x++) {
        const auto baseBlockKey = createBaseBlockKey(x, y, z);
        auto it = octData.baseBlocks.find(baseBlockKey);
        if (it != octData.baseBlocks.end()) {
          res->regionKeys.insert(it->second->regionKeys.begin(), it->second->regionKeys.end());
        }
      }
    }
  }
 
  const auto skirtExpand = (1u << w)*float(Volumetric::OctSystem::skirtSize) / float(tileSize - Volumetric::OctSystem::skirtSize);
 
  res->tileKey = req->tileKey;
  res->layoutHash = octData.layoutHash;
  res->timestamp = octData.currentTimestamp;
  res->min = blockExtent*(glm::vec3(lll) - glm::vec3(skirtExpand)) + blockShift;
  res->max = blockExtent*(glm::vec3(uuu) + glm::vec3(skirtExpand)) + blockShift;
  res->N = glm::ivec3(tileSize);
 
  return res;
}
 
void Cogs::Core::Volumetric::OctComponent::submitTileResponse(TileResponse* res, bool success)
{
  if (res) {
    auto & octData = system->getData(this);
    if (success) {
      octData.tileResponses.push_back(std::move(res));
    }
    else {
      octData.tileResponsesStash.push_back(std::move(res));
    }
  }
}