ZipSystem.cpp

#include "ZipSystem.h"
 
#include "Context.h"
 
#include "Components/Geometry/ExtrusionComponent.h"
#include "Components/Data/TrajectoryComponent.h"
#include "Components/Data/DataSetComponent.h"
#include "Components/Core/CameraComponent.h"
#include "Components/Core/MeshComponent.h"
#include "Components/Core/SubMeshRenderComponent.h"
#include "Components/Core/TransformComponent.h"
#include "Components/Appearance/MaterialComponent.h"
 
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/TransformSystem.h"
#include "Systems/Appearance/MaterialSystem.h"
 
#include "Services/Variables.h"
 
#include "Resources/Mesh.h"
#include "Resources/MeshManager.h"
#include "Resources/MaterialManager.h"
#include "Resources/VertexFormats.h"
#include "Resources/ResourceStore.h"
#include "Resources/DefaultMaterial.h"
 
#include "Utilities/Math.h"
 
#include "Foundation/ComponentModel/Entity.h"
#include "Foundation/Geometry/BoundingBox.hpp"
#include "Foundation/Geometry/SampleListGenerator.hpp"
#include "Foundation/Geometry/ValueQuery.hpp"
#include "Foundation/Geometry/PathGenerator.hpp"
 
#include <algorithm>
 
namespace Cogs
{
  namespace Core
  {
    void updateData(ZipData & data, const ZipComponent & component)
    {
      const ExtrusionComponent* extrusion = component.extrusion->getComponent<ExtrusionComponent>();
      const TrajectoryComponent* trajectory = extrusion->trajectory->getComponent<TrajectoryComponent>();
      const DataSetComponent* dataSet = component.dataSet->getComponent<DataSetComponent>();
      if (trajectory == nullptr || dataSet == nullptr) {
        return;
      }
 
      const float endDepth = std::min(dataSet->indexes[dataSet->indexes.size() - 1], trajectory->indexes[trajectory->indexes.size() - 1]);
      const float startDepth = std::max(dataSet->indexes[0], trajectory->indexes[0]);
 
      std::vector<float> & depthList = data.depthList;
      depthList.clear();
 
      SampleListGenerator::generateIndexedSamples<float>(
        startDepth,
        endDepth,
        trajectory->indexes.data(),
        static_cast<int>(trajectory->indexes.size()),
        depthList);
 
      std::vector<float> & samples = data.samples;
      samples.clear();
 
      SampleListGenerator::createUniqueVector(
        depthList.data(),
        depthList.size(),
        dataSet->indexes.data(),
        dataSet->indexes.size(),
        startDepth,
        endDepth,
        samples);
 
      std::vector<glm::vec3> & basePositions = data.basePositions;
      basePositions.resize(samples.size());
 
      std::vector<glm::vec3> & baseDirections = data.baseDirections;
      baseDirections.resize(samples.size());
 
      std::vector<float> & values = data.values;
      data.values.resize(samples.size());
 
      ValueQuery::getValuesAtDepths(samples.data(), static_cast<int>(samples.size()), dataSet->indexes.data(), dataSet->values.data(), static_cast<int>(dataSet->values.size()), values.data());
 
      auto minMax = std::minmax_element(dataSet->values.begin(), dataSet->values.end());
 
      SampleListGenerator::normalizeValues<float, true>(values.data(), values.data(), static_cast<int>(values.size()), *minMax.first, *minMax.second);
 
      Geometry::PathGenerator::generateLinearPath(samples.data(), static_cast<int>(samples.size()), trajectory->indexes.data(), trajectory->positions.data(), static_cast<int>(trajectory->positions.size()), basePositions.data(), baseDirections.data());
    }
 
    void updatePositions(const ZipData & data, const ZipComponent & component, Mesh * mesh, bool useGpu)
    {
      const glm::vec3 & axis = data.axis;
      const float offset = data.radius;
 
      const size_t numSamples = data.samples.size();
 
      const bool useProjectedCrossSection = true;
      const bool useProjectedAxis = false;
      const bool useTrajectoryOrientedAxis = component.useTrajectoryOrientedAxis;
      const bool useData = !component.highlightTarget;
      
      float extrusionSize = 10.0f;
 
      if (component.highlightTarget) {
        const ZipComponent* zipTarget = component.highlightTarget->getComponent<ZipComponent>();
 
        if (zipTarget) {
          extrusionSize = zipTarget->scale;
        }
      }
 
      const float dataScale = component.scale;
      const glm::vec3 principalAxis(0, 0, -1);
 
      if (!useGpu) {
        auto positions = mesh->mapPositions(0, numSamples * 2);
 
        for (size_t i = 0; i < numSamples; i++) {
          const glm::vec3 basePosition = data.basePositions[i];
          const glm::vec3 trajectoryDirection = data.baseDirections[i];
 
          glm::vec3 base = axis;
          glm::vec3 extrusion = axis;
 
          if (useProjectedCrossSection) {
            glm::vec3 cross = glm::cross(axis, -trajectoryDirection);
            base = glm::cross(-trajectoryDirection, cross);
            base = glm::normalize(base);
          }
 
          if (useProjectedAxis) {
            extrusion = base;
          }
 
          if (useTrajectoryOrientedAxis) {
            glm::quat rotation = getRotation(principalAxis, trajectoryDirection);
            base = rotation * axis;
            extrusion = base;
          }
 
          // First vertex at the center coordinate of the well trajectory + the offset
          positions[i] = basePosition + (base * offset);
 
          float value = 0.0f;
 
          if (useData) {
            value = data.values[i];
          } else {
            value = extrusionSize;
          }
 
          value *= dataScale;
 
          // Second vertex at the continuation of the line from the trajectory center through the base coordinate
          positions[numSamples + i] = positions[i] + extrusion * value;
        }
      } else {
        std::vector<glm::vec3> positions(numSamples * 2);
        std::vector<glm::vec3> parameters(numSamples * 2);
        std::vector<glm::vec3> directions(numSamples * 2);
 
        for (size_t i = 0; i < numSamples; i++) {
          positions[numSamples + i] = positions[i] = data.basePositions[i];
          directions[numSamples + i] = directions[i] = data.baseDirections[i];
 
          const float value = dataScale * (useData ? data.values[i] : extrusionSize);
          const float textureValue = useData ? data.values[i] : 0;
 
          parameters[i] = glm::vec3(data.radius, textureValue, data.radius);
          parameters[numSamples + i] = glm::vec3(data.radius + value, textureValue, data.radius);
        }
 
        // Store directions in the tangent semantic slot.
        mesh->setTangents(directions);
 
        // Store parameters in the normal semantic slot.
        mesh->setNormals(parameters);
 
        mesh->setPositions(positions);
      }
    }
 
    void updateIndexes(const ZipData & data, const ZipComponent & component, Mesh * mesh)
    {
      const uint32_t numSamples = static_cast<uint32_t>(data.samples.size());
 
      int32_t idx = 0;
 
      mesh->clearIndexes();
 
      if (component.enableFill) {
        std::vector<uint32_t> indexes(6 * (data.samples.size() - 1));
 
        for (uint32_t i = 0; i < numSamples  - 1; i++) {
          indexes[idx++] = i;
          indexes[idx++] = numSamples + i;
          indexes[idx++] = numSamples + i + 1;
 
          indexes[idx++] = i;
          indexes[idx++] = numSamples + i + 1;
          indexes[idx++] = i + 1;
        }
 
        mesh->setIndexData(indexes);
      } else {
        mesh->addSubMesh(std::span<uint32_t>(), PrimitiveType::TriangleList);
      }
 
      if (component.enableOutline) {
        std::vector<uint32_t> lineIndexes((numSamples - 1) * 2 + 4);
 
        idx = 0;
 
        lineIndexes[idx++] = 0;
        lineIndexes[idx++] = numSamples;
 
        for (uint32_t i = 0; i < numSamples - 1; ++i) {
          lineIndexes[idx++] = numSamples + i;
          lineIndexes[idx++] = numSamples + i + 1;
        }
 
        lineIndexes[idx++] = numSamples * 2 - 1;
        lineIndexes[idx++] = numSamples - 1;
 
        mesh->addSubMesh(lineIndexes, PrimitiveType::LineList);
      } else {
        mesh->addSubMesh(std::span<uint32_t>(), PrimitiveType::LineList);
      }
    }
 
    void updateTexCoords(const ZipData & data, const ZipComponent & /*component*/, Mesh * mesh)
    {
      const size_t numSamples = data.samples.size();
 
      std::vector<glm::vec2> texCoords(numSamples * 2);
 
      for (size_t i = 0; i < numSamples; ++i) {
        texCoords[i] = glm::vec2(data.values[i], 0);
        texCoords[numSamples + i] = glm::vec2(data.values[i], 0);
      }
 
      mesh->setTexCoords(texCoords);
    }
  }
}
 
void Cogs::Core::ZipSystem::update(Context * context)
{
  const bool gpuSetting = context->variables->get("systems.zipSystem.useGpu", false);
  bool resetComponentData = false;
 
  if (gpuSetting != useGpu) {
    useGpu = gpuSetting;
    resetComponentData = true;
  }
 
  if (pool.size() > 0 && !HandleIsValid(zipMaterial)) {
    setupMaterial(context);
  }
 
  for (ZipComponent& component : pool) {
    if (!component.active) continue;
 
    if (resetComponentData) {
      resetComponent(component);
    }
    
    bool didUpdate = false;
    
    if (!setupComponent(context, component) && !component.highlightTarget) continue;
    
    if (needsUpdate(context, component) && !component.highlightTarget) {
      updateStaticLog(context, component);
      didUpdate = true;
    } else if (component.highlightTarget) {
      didUpdate = updateStaticHighLight(context, component);
    }
    
    if (!useGpu && !didUpdate) {
      updateDynamic(context, component);
    }
  }
}
 
void Cogs::Core::ZipSystem::cleanup(Context* context)
{
  // Ready to release zipMaterial, but material not released.
  base::cleanup(context);
}
 
bool Cogs::Core::ZipSystem::needsUpdate(Context *, ZipComponent & component)
{
  if (component.extrusion == nullptr || component.dataSet == nullptr) {
    return false;
  }
 
  const ExtrusionComponent* extrusion = component.extrusion->getComponent<ExtrusionComponent>();
  if (extrusion == nullptr || extrusion->trajectory == nullptr) {
    return false;
  }
 
  const TrajectoryComponent* trajectory = extrusion->trajectory->getComponent<TrajectoryComponent>();
  const DataSetComponent* dataSet = component.dataSet->getComponent<DataSetComponent>();
 
  return extrusion->hasChanged() ||
    (trajectory && trajectory->hasChanged()) ||
    (dataSet && dataSet->hasChanged()) ||
    component.hasChanged();
}
 
void Cogs::Core::ZipSystem::updateStaticLog(Context * context, ZipComponent & component)
{
  const CameraComponent* cameraComponent = context->cameraSystem->getMainCamera();
  const CameraData& cameraData = context->cameraSystem->getData(cameraComponent);
 
  const ExtrusionComponent* extrusion = component.extrusion->getComponent<ExtrusionComponent>();
  ZipData& data = this->getData(&component);
  SubMeshRenderComponent* renderComponent = component.getComponent<SubMeshRenderComponent>();
  Mesh* mesh = component.getComponent<MeshComponent>()->meshHandle.resolve();
 
  updateData(data, component);
 
  if (data.samples.size()) {
    updateIndexes(data, component, mesh);
 
    updateTexCoords(data, component, mesh);
  } else {
    mesh->clear();
  }
 
  data.radius = extrusion->radius;
  if (component.rotateAxisToCamera) {
    data.axis = glm::vec3(cameraData.inverseViewMatrix * glm::vec4(component.axis, 0));
  }
  else {
    data.axis = component.axis;
  }
 
  if (useGpu) {
    MaterialInstance* fillMaterial = context->materialInstanceManager->get(renderComponent->materials[0]);
    fillMaterial->setVec4Property(axisKey, glm::vec4(component.axis, 0));
    fillMaterial->options.depthBiasEnabled = true;
    fillMaterial->options.depthBias.constant = 8.0f;
    fillMaterial->options.depthBias.slope = 8.0f;
 
    MaterialInstance* lineMaterial = context->materialInstanceManager->get(renderComponent->materials[1]);
    lineMaterial->setVec4Property(axisKey, glm::vec4(component.axis, 0));
    lineMaterial->setVec4Property(diffuseColorKey, glm::vec4(0, 0, 0, 1));
  } else {
    MaterialComponent* material = component.getComponent<MaterialComponent>();
    const MaterialData& materialData = context->materialSystem->getData(material);
 
    renderComponent->materials[0] = materialData.instance;
 
    if (renderComponent->materials[1] == MaterialInstanceHandle::NoHandle) {
      renderComponent->materials[1] = context->materialInstanceManager->createMaterialInstance(context->materialManager->getDefaultMaterial());
      renderComponent->materials[1]->setPermutation("Line");
    }
 
    material->depthBiasEnable = true;
    material->depthBiasConstant = 8.0f;
    material->depthBiasSlope = 8.0f;
    material->depthBiasClamp = 100.0f;
 
    MaterialInstance* lineMaterial = context->materialInstanceManager->get(renderComponent->materials[1]);
    lineMaterial->setVec4Property(DefaultMaterial::DiffuseColor, glm::vec4(0, 0, 0, 1));
    lineMaterial->setBoolProperty(DefaultMaterial::EnableLighting, false);
  }
 
  updatePositions(data, component, mesh, useGpu);
 
  Geometry::BoundingBox box = Geometry::computeBoundingBox(data.basePositions.begin(), data.basePositions.end());
 
  float adj = data.radius + component.scale;
  Geometry::BoundingBox adjustedBox = { box.min - glm::vec3(adj, adj, 0), box.max + glm::vec3(adj, adj, 0) };
 
  mesh->setBounds(adjustedBox);
}
 
bool Cogs::Core::ZipSystem::setupComponent(Context * context, ZipComponent & component)
{
  MeshComponent* meshComponent = component.getComponent<MeshComponent>();
  SubMeshRenderComponent* renderComponent = component.getComponent<SubMeshRenderComponent>();
  TransformComponent* transform = component.getComponent<TransformComponent>();
  if (!HandleIsValid(meshComponent->meshHandle)) {
    meshComponent->meshHandle = context->meshManager->create();
  }
 
  if (renderComponent->materials.size() != 2) {
    renderComponent->materials.resize(2);
  }
 
  if (component.extrusion && component.dataSet) {
    const ExtrusionComponent* extrusion = component.extrusion->getComponent<ExtrusionComponent>();
    if (extrusion == nullptr) {
      return false;
    }
 
    const TransformComponent* extrusionTransform = extrusion->getComponent<TransformComponent>();
 
    context->transformSystem->copyTransform(extrusionTransform, transform);
 
    MaterialComponent* material = component.getComponent<MaterialComponent>();
    MaterialData& materialData = context->materialSystem->getData(material);
    material->enableLighting = false;
    material->setChanged();
 
    if (useGpu) {
      if (!HandleIsValid(renderComponent->materials[0])) {
        MaterialInstanceHandle instance = context->materialInstanceManager->createMaterialInstance(zipMaterial);
        MaterialInstanceHandle instance2 = context->materialInstanceManager->createMaterialInstance(zipMaterial);
 
        instance.resolve()->setVec4Property(parameterKey, glm::vec4(1, 0, 0, 0));
        instance2.resolve()->setVec4Property(parameterKey, glm::vec4(0, 0, 0, 0));
 
        renderComponent->materials[0] = instance;
        renderComponent->materials[1] = instance2;
 
        materialData.instance = renderComponent->materials[0];
      }
    }
 
    EntityPtr colorMap = component.colorMap;
 
    if (colorMap) {
      MaterialComponent* colorMapMaterial = colorMap->getComponent<MaterialComponent>();
 
      if (useGpu && renderComponent->materials.size()) {
        MaterialInstanceHandle zipMaterialInstance = renderComponent->materials[0];
 
        if (zipMaterialInstance) {
          zipMaterialInstance->setTextureProperty(colorMapKey, colorMapMaterial->diffuseMap);
          zipMaterialInstance->setTextureAddressMode(colorMapKey, SamplerState::Clamp);
        }
      } else if (!useGpu && material->diffuseMap != colorMapMaterial->diffuseMap) {
        material->diffuseMap = colorMapMaterial->diffuseMap;
        material->addressMode = SamplerState::Clamp;
        material->diffuseColor = glm::vec4(1, 1, 1, 1);
        material->setChanged();
      }
    }
 
    return true;
  } else {
    return false;
  }
}
 
bool Cogs::Core::ZipSystem::updateStaticHighLight(Context * context, ZipComponent & component)
{
  const ZipComponent* zipComponent = component.highlightTarget->getComponent<ZipComponent>();
  TransformComponent* transform = component.getComponent<TransformComponent>();
  ZipData& data = this->getData(&component);
  
  MeshComponent* meshComponent = component.getComponent<MeshComponent>();
  Mesh* mesh = context->meshManager->get(meshComponent->meshHandle);
 
  if (zipComponent == nullptr || zipComponent->extrusion == nullptr || !zipComponent->active) {
    return false;
  }
 
  const ExtrusionComponent* extrusion = zipComponent->extrusion->getComponent<ExtrusionComponent>();
  if (extrusion == nullptr || extrusion->trajectory == nullptr) {
    return false;
  }
  const TransformComponent* extrusionTransform = extrusion->getComponent<TransformComponent>();
  TrajectoryComponent* trajectory = extrusion->trajectory->getComponent<TrajectoryComponent>();
  ZipData& targetData = this->getData(zipComponent);
  MaterialComponent* material = component.getComponent<MaterialComponent>();
 
  context->transformSystem->copyTransform(extrusionTransform, transform);
 
  component.useTrajectoryOrientedAxis = zipComponent->useTrajectoryOrientedAxis;
 
  if (extrusion->hasChanged() ||
      trajectory->hasChanged() ||
      zipComponent->hasChanged() ||
      component.hasChanged() ||
      material->hasChanged()) {
    data.axis = targetData.axis;
    data.radius = targetData.radius;
 
    const float startDepth = std::max(component.highlightStart, trajectory->indexes[0]);
    const float endDepth = std::min(component.highlightEnd, trajectory->indexes[trajectory->indexes.size() - 1]);
 
    data.samples.clear();
 
    std::vector<float> indexSamples;
 
    SampleListGenerator::generateIndexedSamples<float>(
      startDepth,
      endDepth,
      targetData.samples.data(),
      static_cast<int>(targetData.samples.size()),
      data.samples);
 
    data.basePositions.resize(data.samples.size());
    data.baseDirections.resize(data.samples.size());
 
    if (data.samples.size() < 2) {
      mesh->clear();
      return true;
    }
 
    Geometry::PathGenerator::generateLinearPath(data.samples.data(), static_cast<int>(data.samples.size()), trajectory->indexes.data(), trajectory->positions.data(), static_cast<int>(trajectory->positions.size()), data.basePositions.data(), data.baseDirections.data());
 
    if (data.samples.size()) {
      updatePositions(data, component, mesh, useGpu);
      updateIndexes(data, component, mesh);
 
      SubMeshRenderComponent* renderComponent = component.getComponent<SubMeshRenderComponent>();
      MaterialData& materialData = context->materialSystem->getData(material);
 
 
      if (!useGpu) {
        material->enableLighting = false;
 
        if (!materialData.instance) return true;
 
        renderComponent->materials[0] = materialData.instance;
        if (renderComponent->materials[1] == MaterialInstanceHandle::NoHandle) {
          renderComponent->materials[1] = context->materialInstanceManager->createMaterialInstance(context->materialManager->getDefaultMaterial());
        }
 
        material->depthBiasEnable = true;
        material->depthBiasConstant = -1.0f;
        material->depthBiasSlope = 0.0f;
        
        material->blendMode = BlendMode::Add;
 
        material->setChanged();
 
        MaterialInstance* fillMaterial = context->materialInstanceManager->get(renderComponent->materials[0]);
        fillMaterial->setBoolProperty(DefaultMaterial::EnableLighting, false);
        fillMaterial->setTransparent();
        fillMaterial->setName("HighlightFillMaterial");
 
        MaterialInstance* lineMaterial = context->materialInstanceManager->get(renderComponent->materials[1]);
        lineMaterial->setVec4Property(DefaultMaterial::DiffuseColor, glm::vec4(0, 0, 0, 1));
        lineMaterial->setBoolProperty(DefaultMaterial::EnableLighting, false);
      } else {
        if (!HandleIsValid(renderComponent->materials[0])) {
          renderComponent->materials[0] = context->materialInstanceManager->createMaterialInstance(zipMaterial);
          renderComponent->materials[1] = context->materialInstanceManager->createMaterialInstance(zipMaterial);
        }
 
        MaterialInstance* fillMaterial = renderComponent->materials[0].resolve();
        fillMaterial->setVec4Property(parameterKey, glm::vec4(0, 0, 0, 0));
        fillMaterial->setVec4Property(diffuseColorKey, material->diffuseColor);
        fillMaterial->setVec4Property(axisKey, glm::vec4(zipComponent->axis, 0));
 
        if (material->diffuseColor.a < 1.0f) {
          fillMaterial->setTransparent();
        } else {
          fillMaterial->setOpaque();
        }
 
        fillMaterial->options.depthBiasEnabled = true;
        fillMaterial->options.depthBias.constant = -1.0f;
        fillMaterial->options.depthBias.slope = 0.0f;
        
        fillMaterial->options.blendMode = BlendMode::Add;
 
        MaterialInstance* lineMaterial = renderComponent->materials[1].resolve();
        lineMaterial->setVec4Property(parameterKey, glm::vec4(0, 0, 0, 0));
        lineMaterial->setVec4Property(diffuseColorKey, glm::vec4(0, 0, 0, 1));
        lineMaterial->setVec4Property(axisKey, glm::vec4(zipComponent->axis, 0));
 
        materialData.instance = renderComponent->materials[0];
      }
    } else {
      mesh->clear();
    }
 
    Geometry::BoundingBox box = Geometry::computeBoundingBox(data.basePositions.begin(), data.basePositions.end());
 
    float adj = data.radius + zipComponent->scale;
    Geometry::BoundingBox adjustedBox = { box.min - glm::vec3(adj, adj, 0), box.max + glm::vec3(adj, adj, 0) };
 
    mesh->setBounds(adjustedBox);
 
    return true;
  } else {
    return false;
  }
}
 
void Cogs::Core::ZipSystem::setupMaterial(Context * context)
{
  this->zipMaterial = context->materialManager->loadMaterial("ZipMaterial.material");
 
  context->materialManager->processLoading();
 
  const Material* zipMaterial = this->zipMaterial.resolve();
 
  parameterKey = zipMaterial->getVec4Key("parameters");
  axisKey = zipMaterial->getVec4Key("axis");
  diffuseColorKey = zipMaterial->getVec4Key("diffuseColor");
  
  colorMapKey = zipMaterial->getTextureKey("colorMap");
}
 
void Cogs::Core::ZipSystem::resetComponent(ZipComponent & component)
{
  SubMeshRenderComponent* renderComponent = component.getComponent<SubMeshRenderComponent>();
 
  renderComponent->materials.resize(2);
  renderComponent->materials[0] = MaterialInstanceHandle::NoHandle;
  renderComponent->materials[1] = MaterialInstanceHandle::NoHandle;
 
  MeshComponent* meshComponent = component.getComponent<MeshComponent>();
  meshComponent->meshHandle = MeshHandle::NoHandle;
 
  MaterialComponent* materialComponent = component.getComponent<MaterialComponent>();
  MaterialData& materialData = context->materialSystem->getData(materialComponent);
  materialData.instance = MaterialInstanceHandle::NoHandle;
  materialComponent->setChanged();
 
  component.setChanged();
}
 
void Cogs::Core::ZipSystem::updateDynamic(Context * context, ZipComponent & component)
{
  const CameraComponent* cameraComponent = context->cameraSystem->getMainCamera();
  const CameraData& cameraData = context->cameraSystem->getData(cameraComponent);
 
  if (cameraComponent->hasChanged() || cameraComponent->getComponent<TransformComponent>()->hasChanged()) {
    ZipData& data = this->getData(&component);
    Mesh* mesh = component.getComponent<MeshComponent>()->meshHandle.resolve();
 
    if (component.highlightTarget && component.active) {
      const ZipComponent* zipComponent = component.highlightTarget->getComponent<ZipComponent>();
 
      if (zipComponent && zipComponent->active) {
        data.axis = this->getData(zipComponent).axis;
 
        updatePositions(data, component, mesh, useGpu);
      }
    } else {
      if (component.rotateAxisToCamera) {
        data.axis = glm::vec3(cameraData.inverseViewMatrix * glm::vec4(component.axis, 0));
      }
      else {
        data.axis = component.axis;
      }
 
      updatePositions(data, component, mesh, useGpu);
 
      mesh->meshFlags |= MeshFlags::BoundingBoxSet;
    }
  }
}