EchoSounderExtension.cpp

#include "EchoSounderExtension.h"
 
#include "Bridge/Bridge.h"
 
#include "Context.h"
#include "ViewContext.h"
#include "Engine.h"
#include "EntityDefinitions.h"
#include "EntityStore.h"
#include "ExtensionRegistry.h"
#include "Components/DataRefComponent.h"
#include "Components/DataSetComponent.h"
#include "Components/WindowComponent.h"
#include "Components/LocationComponent.h"
#include "Components/PingOutlineComponent.h"
#include "Components/BeamGroupComponent.h"
#include "Components/PingIsoComponent.h"
#include "Components/SwathBottomComponent.h"
#include "Components/SwathIsoComponent.h"
#include "Components/OctProviderComponent.h"
#include "Components/UniformGridComponent.h"
#include "Components/UniformGridIsoComponent.h"
#include "Resources/ResourceStore.h"
#include "Renderer/IRenderer.h"
#include "Serialization/EntityReader.h"
#include "Services/Variables.h"
#include "Systems/DataSetSystem.h"
#include "Systems/PingIsoSystem.h"
#include "Systems/SwathBottomSystem.h"
#include "Systems/SwathIsoSystem.h"
#include "Systems/OctProviderSystem.h"
#include "Systems/UniformGridSystem.h"
 
#include "Rendering/ICapabilities.h"
#include "Rendering/IGraphicsDevice.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/IO.h"
 
#include <algorithm>
 
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
 
using namespace Cogs::Core;
 
namespace{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("EchoSounderExtension");
};
 
EchoSounder::DataSetComponent* getComponent(Context* context,
                                            EntityId entityId)
{
  auto entity = context->store->getEntityPtr(entityId);
 
  if (!entity) {
    return nullptr;
  }
 
  return entity->getComponent<EchoSounder::DataSetComponent>();
}
 
EchoSounder::UniformGridComponent* getUniformGridComponent(Context* context,
                                                           EntityId entityId)
{
  auto entity = context->store->getEntityPtr(entityId);
 
  if (!entity) {
    return nullptr;
  }
 
  return entity->getComponent<EchoSounder::UniformGridComponent>();
}
 
int echosounderSetConfig(void * ctx,
                         EntityId entityId,
                         uint32_t coordSys,
                         uint32_t capacity,
                         uint32_t beamCount,
                         uint32_t sampleCount,
                         float depthOffset,
                         float depthStep,
                         uint32_t useDecibel,
                         uint32_t tryPreserve,
                         const float* transducerAlpha,
                         const float* transducerOffset,
                         const float* directionX,
                         const float* directionY,
                         const float* beamWidthX,
                         const float* beamWidthY)
{
  auto context = reinterpret_cast<Context *>(ctx);
  auto component = getComponent(context, entityId);
  if (!component){
    return -1;
  }
  if (1000 < component->messages.size()) {
    // Make sure memory use doesn't run away if we get a unlikely large bubble.
    return -1;
  }
  auto configMessage = new EchoSounder::ConfigMessage();
  configMessage->config.coordSys = coordSys;
  configMessage->config.capacity = capacity;
  configMessage->config.beamCount = beamCount;
  configMessage->config.sampleCount = sampleCount;
  configMessage->config.depthOffset = depthOffset;
  configMessage->config.depthStep = depthStep;
  configMessage->config.useDecibel = (useDecibel != 0);
  configMessage->config.tryPreserve = (tryPreserve != 0);
  configMessage->config.transducerAlpha = glm::make_vec3(transducerAlpha);
  configMessage->config.transducerOffset = glm::make_vec3(transducerOffset);
 
  configMessage->config.directionX.resize(beamCount);
  std::memcpy(configMessage->config.directionX.data(), directionX, sizeof(float)*beamCount);
 
  configMessage->config.directionY.resize(beamCount);
  std::memcpy(configMessage->config.directionY.data(), directionY, sizeof(float)*beamCount);
 
  configMessage->config.beamWidthX.resize(beamCount);
  std::memcpy(configMessage->config.beamWidthX.data(), beamWidthX, sizeof(float)*beamCount);
 
  configMessage->config.beamWidthY.resize(beamCount);
  std::memcpy(configMessage->config.beamWidthY.data(), beamWidthY, sizeof(float)*beamCount);
 
  component->messages.push_back(configMessage);
 
  return 0;
}
 
int echosounderClearPings(void * ctx, EntityId entityId)
{
  auto context = reinterpret_cast<Context *>(ctx);
  auto component = getComponent(context, entityId);
    if (!component) {
    return -1;
  }
  if (1000 < component->messages.size()) {
    // Make sure memory use doesn't run away if we get a unlikely large bubble.
    return -1;
  }
 
  component->messages.push_back(new EchoSounder::ClearMessage());
 
  return 0;
}
 
int echosounderAddPing(void * ctx,
                       EntityId entityId,
                       uint32_t beamCount,
                       uint32_t sampleCount,
                       int64_t timestamp,
                       const float* position,
                       const float* orientation,
                       const float* samples,
                       const float* bottomDepths,
                       const float* bottomReflectivities)
{
  auto context = reinterpret_cast<Context *>(ctx);
  auto component = getComponent(context, entityId);
  if (!component) {
    return -1;
  }
  if (1000 < component->messages.size()) {
    // Make sure memory use doesn't run away if we get a unlikely large bubble.
    return -1;
  }
 
  auto pingMessage = new EchoSounder::PingMessage();
  auto & p = pingMessage->ping;
 
  p.beamCount = beamCount;
  p.sampleCount = sampleCount;
  p.timestamp = timestamp;
  p.position = glm::make_vec3(position);
  p.orientation = glm::make_quat(orientation);
 
  p.storage.resize(p.storageSize(), false);
  std::memcpy(p.values(), samples, p.valuesSize());
  if (bottomDepths) {
    std::memcpy(p.bottomDepths(), bottomDepths, p.bottomDepthsSize());
  }
  else {
    std::memset(p.bottomDepths(), ~0u, p.bottomDepthsSize());
  }
 
  if (bottomReflectivities) {
    std::memcpy(p.bottomReflectivities(), bottomReflectivities, p.bottomReflectivitiesSize());
  }
  else {
    std::memset(p.bottomReflectivities(), ~0u, p.bottomReflectivitiesSize());
  }
 
  component->messages.push_back(pingMessage);
 
  return 0;
}
 
int uniformGridAddConfig(void * ctx,
                         EntityId entityId,
                         uint32_t configId,
                         uint32_t coordSys,
                         uint32_t majorCount,
                         uint32_t minorCount,
                         uint32_t sampleCount,
                         float depthOffset,
                         float depthStep,
                         const float* transducerAlpha,
                         const float* transducerOffset,
                         const float* directionX,
                         const float* directionY,
                         const float* beamWidthX,
                         const float* beamWidthY)
{
  Context *context = reinterpret_cast<Context *>(ctx);
  auto component = getUniformGridComponent(context, entityId);
  auto system = ExtensionRegistry::getExtensionSystem<EchoSounder::UniformGridSystem>(context);
  if(component && system){
    EchoSounder::UniformGridConfig config = {};
    config.configId = configId;
    config.coordSys = coordSys;
    config.majorCount = majorCount;
    config.minorCount = minorCount;
    config.sampleCount = sampleCount;
    config.depthOffset = depthOffset;
    config.depthStep = depthStep;
    config.transducerAlpha = glm::make_vec3(transducerAlpha);
    config.transducerOffset = glm::make_vec3(transducerOffset);
 
    uint32_t beamCount = minorCount*majorCount;
    config.directionX.resize(beamCount);
    std::memcpy(config.directionX.data(), directionX, sizeof(float)*beamCount);
    config.directionY.resize(beamCount);
    std::memcpy(config.directionY.data(), directionY, sizeof(float)*beamCount);
    config.beamWidthX.resize(beamCount);
    std::memcpy(config.beamWidthX.data(), beamWidthX, sizeof(float)*beamCount);
    config.beamWidthY.resize(beamCount);
    std::memcpy(config.beamWidthY.data(), beamWidthY, sizeof(float)*beamCount);
 
    system->config(component, config);
  }
  return 0;
}
 
int uniformGridClearPings(void * ctx, EntityId entityId)
{
  Context *context = reinterpret_cast<Context*>(ctx);
  auto component = getUniformGridComponent(context, entityId);
  auto system = ExtensionRegistry::getExtensionSystem<EchoSounder::UniformGridSystem>(context);
  if(component && system) system->clear(component);
  return 0;
}
 
int uniformGridAddPing(void * ctx,
                       EntityId entityId,
                       uint32_t configId,
                       uint32_t beamCount,
                       uint32_t sampleCount,
                       int64_t timestamp,
                       const float* position,
                       const float* orientation,
                       const float* samples,
                       const float* /*bottomDepths*/,
                       const float* /*bottomReflectivities*/)
{
  Context *context = reinterpret_cast<Context *>(ctx);
  auto component = getUniformGridComponent(context, entityId);
  auto system = ExtensionRegistry::getExtensionSystem<EchoSounder::UniformGridSystem>(context);
  if(component && system){
    EchoSounder::UniformGridPing p = {};
    p.configId = configId;
    p.timestamp = timestamp;
    p.position = glm::make_vec3(position);
    p.orientation = glm::make_quat(orientation);
    size_t size = sizeof(float)*beamCount*sampleCount;
    p.storage.resize(size, false);
    std::memcpy(p.storage.data(), samples, size);
    system->addPing(context, component, p);
  }
  return 0;
}
 
namespace {
  // Sanity checks to make sure that functions actually match typedefs.
  Cogs::Core::EchoSounder::SetConfigPtr setConfigPtr = echosounderSetConfig;
  Cogs::Core::EchoSounder::ClearPingsPtr clearPingsPtr = echosounderClearPings;
  Cogs::Core::EchoSounder::AddPingPtr addPingPtr = echosounderAddPing;
}
 
namespace Cogs
{
  namespace Core
  {
    namespace EchoSounder
    {
 
      struct EchoSounderExtension : Extension
      {
        EchoSounderExtension() { ExtensionRegistry::add(this, COGS_CORE_VERSION_STRING); }
 
        bool initializeStatic() override;
        bool initialize(Context * context) override;
        void cleanup(Context * context) override;
 
        void * getSymbolPointer(const char* symbol) const override
        {
          if (strcmp("setConfig", symbol) == 0) {
            return setConfigPtr;
          }
          else if (strcmp("clearPings", symbol) == 0) {
            return clearPingsPtr;
          }
          else if (strcmp("addPing", symbol) == 0) {
            return addPingPtr;
          }
          else if (strcmp("uniformGridAddConfig", symbol) == 0) {
            return uniformGridAddConfig;
          }
          else if (strcmp("uniformGridClearPings", symbol) == 0) {
            return uniformGridClearPings;
          }
          else if (strcmp("uniformGridAddPing", symbol) == 0) {
            return uniformGridAddPing;
          }
          else {
            return nullptr;
          }
        }
 
        const char * getExtensionKey() const override { return "EchoSounder"; }
      } multiBeamExtension;
    }
  }
}
 
static void EchoSounderResize(ViewContext* view, int x, int y)
{
  Context* context = view->getContext();
 
  if(!context->variables->get("renderer.oit.EchoSounderOITResize", true)) return;
  if(!context) return;
  // Scale OIT upscale parameters
  auto device = context->device;
  if(!device) return;
  auto capabilites = device->getCapabilities();
  if(!capabilites) return;
  auto vendor = capabilites-> getVendor();
  size_t max_oit_memory = 256;
  if(vendor == Cogs::Vendors::Intel){
    size_t vRam = capabilites->getDeviceCapabilities().DedicatedVideoMemory;
    size_t sRam = capabilites->getDeviceCapabilities().DedicatedSystemMemory;
    size_t shRam = capabilites->getDeviceCapabilities().SharedSystemMemory;
    max_oit_memory = std::max((size_t)1024*1024*1024, std::max(vRam, std::max(sRam, shRam)));
  }
  else{
    max_oit_memory = std::max((size_t)1024*1024*1024, capabilites->getDeviceCapabilities().DedicatedVideoMemory);
  }
  double factor = 0.8;
  size_t app_memory = 500*1024*1024;
  size_t oit_memory = (size_t)ceil((max_oit_memory*factor-app_memory));
 
  float upscaleWidth = 1.0f;
  float upscaleHeight = 1.0f;
  int temporalUpscaleWidth = context->variables->get("renderer.oit.TemporalUpscaleWidth", 1);
  int temporalUpscaleHeight = context->variables->get("renderer.oit.TemporalUpscaleHeight", 1);
  size_t nodeBufferFactor = context->variables->get("renderer.oit.bufferFactor", 1);
 
  size_t maxWidth = context->variables->get("renderer.oit.MaxWidth", 1920);
  size_t maxHeight = context->variables->get("renderer.oit.MaxHeight", 1200);
 
  size_t total_size;
  while(1){
    size_t width = x;
    size_t height = y;
 
    size_t width_s = (size_t)ceil(width/(upscaleWidth*temporalUpscaleWidth));
    size_t height_s = (size_t)ceil(height/(upscaleHeight*temporalUpscaleHeight));
    if(width_s > maxWidth){
      upscaleWidth *=2;
      continue;
    }
    if(height_s > maxHeight){
      upscaleHeight *=2;
      continue;
    }
 
    size_t res = width_s * height_s;
 
    size_t listBuffer = res * 4;
    size_t nodeBuffer = res * nodeBufferFactor * 8;
    size_t dataBuffer = res * nodeBufferFactor * 16;
 
    size_t DepthSubRes = res*4;
    size_t OITColorSubRes = res*4;
    size_t OITDepth = (size_t)ceil(width/upscaleWidth)*(size_t)ceil(height/upscaleHeight)*4;
    size_t ColorTemporalA = (size_t)ceil(width/upscaleWidth)*(size_t)ceil(height/upscaleHeight)*4;
    size_t ColorTemporalB = (size_t)ceil(width/upscaleWidth)*(size_t)ceil(height/upscaleHeight)*4;
 
    total_size = listBuffer+nodeBuffer+dataBuffer +
      DepthSubRes+OITColorSubRes+OITDepth+ColorTemporalA+ColorTemporalB;
    if(total_size < oit_memory) break;
    if(upscaleWidth <= upscaleHeight) upscaleWidth*=2;
    else upscaleHeight*=2;
  }
 
  LOG_INFO(logger, "Resize %d %d upscale (%.1f, %.1f) temporalUpscale (%d, %d) factor %zu",
           x, y, upscaleWidth, upscaleHeight, temporalUpscaleWidth, temporalUpscaleHeight, nodeBufferFactor);
 
  context->variables->set("renderer.oit.UpscaleWidth", upscaleWidth);
  context->variables->set("renderer.oit.UpscaleHeight", upscaleHeight);
  context->variables->set("renderer.oit.TemporalUpscaleWidth", temporalUpscaleWidth);
  context->variables->set("renderer.oit.TemporalUpscaleHeight", temporalUpscaleHeight);
}
 
bool Cogs::Core::EchoSounder::EchoSounderExtension::initializeStatic()
{
  DataSetComponent::registerType();
  DataRefComponent::registerType();
  WindowComponent::registerType();
  LocationComponent::registerType();
  PingOutlineComponent::registerType();
  BeamGroupComponent::registerType();
  SwathBottomComponent::registerType();
  SwathIsoComponent::registerType();
  PingIsoComponent::registerType();
  OctProviderComponent::registerType();
  UniformGridComponent::registerType();
  UniformGridIsoComponent::registerType();
  return true;
}
 
bool Cogs::Core::EchoSounder::EchoSounderExtension::initialize(Context * context)
{
  // Maximum number of new chunks to process per iteration.
  context->variables->set("echo.maxNewChunks", 8);
 
  // Maximum number of new samples in-between slices, on average.
  context->variables->set("echo.maxPathUpsample", 3);
 
  // Maximum number of new samples in-between depth samples.
  context->variables->set("echo.maxDepthUpsample", 2);
 
  // Maximum number of new samples in-between beams, on average.
  context->variables->set("echo.maxBeamUpsample", 5);
 
  // If slices are closer together than this threshold, use this threshold instead as distance.
  context->variables->set("echo.minSliceDistance", 0.01);
 
  context->variables->set("echo.remap.printQueues", false);
 
  // Max number of tiles updated per iteration.
  context->variables->set("echo.remap.maxTileUpdates", 8);
 
  // Max number of pings added per iteration.
  context->variables->set("echo.remap.maxPingAdd", 4);
 
  context->variables->set("echo.remap.dump", false);
  
  context->resourceStore->addResourceArchive("Cogs.Core.Extensions.EchoSounder.zip");
 
  context->resourceStore->addSearchPath("../Extensions/EchoSounder/Data/");
  context->resourceStore->addSearchPath("../Extensions/EchoSounder/Data/Materials/");
  context->resourceStore->addSearchPath("../Extensions/EchoSounder/Data/Shaders/");
 
  const auto dependencyDir = IO::expandEnvironmentVariable("CoinDir");
 
  context->resourceStore->addSearchPath(dependencyDir + "/");
  context->resourceStore->addSearchPath(dependencyDir + "/Materials/");
  context->resourceStore->addSearchPath(dependencyDir + "/shaders/");
 
  loadPermutations(context, "Permutations/EchoBizarreLighting.permutations");
 
  context->registerDynamicComponentType("EchoWindowComponent");
  context->registerDynamicComponentType("EchoDataRefComponent");
  context->registerDynamicComponentType("EchoLocationComponent");
  context->registerDynamicComponentType("EchoPingOutlineComponent");
  context->registerDynamicComponentType("EchoBeamGroupComponent");
  context->registerDynamicComponentType("EchoUniformGridIsoComponent");
 
  readEntityDefinition(R"(
{ "name": "EchoDataSet",
  "components" : [
    "EchoDataSetComponent",
    "TransformComponent",
    "SceneComponent",
  ]
})"
, context->store);
 
  readEntityDefinition(R"(
{ "name": "EchoUniformGrid",
  "components" : [
    "EchoUniformGridComponent",
    "EchoUniformGridIsoComponent",
    "TransformComponent",
    "SceneComponent",
  ],
  "defaults": [
    { "EchoUniformGridIsoComponent": { "material": "MultibeamIsoMaterial" }},
  ],
})"
, context->store);
 
  readEntityDefinition(R"(
{ "name": "EchoUniformGridIsoVisualizer",
  "components" : [
    "TransformComponent",
    "SceneComponent",
    "MeshComponent",
    "SubMeshRenderComponent",
  ]
})"
, context->store);
 
  readEntityDefinition(R"(
{ "name": "EchoUniformGridPointVisualizer",
  "components" : [
    "TransformComponent",
    "SceneComponent",
    "MeshComponent",
    "MeshRenderComponent",
  ]
})"
, context->store);
 
  readEntityDefinition(R"(
{ "name": "EchoSwathBottom",
  "components": [
    "EchoDataRefComponent",
    "EchoWindowComponent",
    "EchoBeamGroupComponent",
    "EchoSwathBottomComponent",
    "TransformComponent",
    "SceneComponent",
    "MaterialComponent"
  ],
})"
, context->store);
 
  readEntityDefinition(R"(
{ "name": "EchoSwathIso",
  "components": [
    "EchoDataRefComponent",
    "EchoWindowComponent",
    "EchoBeamGroupComponent",
    "EchoSwathIsoComponent",
    "TransformComponent",
    "SceneComponent"
  ],
  "defaults": [
    { "EchoSwathIsoComponent": { "material": "MultibeamIsoMaterial" }},
  ],
})"
, context->store);
 
  readEntityDefinition(R"(
{ "name": "EchoPingIso",
  "components": [
    "EchoDataRefComponent",
    "EchoLocationComponent",
    "EchoBeamGroupComponent",
    "EchoPingIsoComponent",
    "TransformComponent",
    "SceneComponent",
    "MeshComponent",
    "SubMeshRenderComponent"
  ],
  "defaults": [
    { "EchoPingIsoComponent": { "material": "ParametricGridMaterial" }},
    { "EchoLocationComponent": { "updateTransform": false }},
  ],
})"
, context->store);
 
  readEntityDefinition(R"(
{ "name": "EchoChunkSurface",
  "components": [
    "TransformComponent",
    "SceneComponent",
    "MeshComponent",
    "SubMeshRenderComponent"
  ]
})"
, context->store);
 
  readEntityDefinition(R"(
{ "name": "EchoPingOutline",
  "components": [
    "EchoDataRefComponent",
    "EchoLocationComponent",
    "EchoBeamGroupComponent",
    "EchoPingOutlineComponent",
    "TransformComponent",
    "SceneComponent",
    "MeshComponent",
    "MeshRenderComponent",
    "MaterialComponent"
  ],
  "defaults": [
    { "MaterialComponent": { "enableLighting": false }},
  ],
})"
, context->store);
 
  readEntityDefinition(R"(
{ "name": "EchoConfigAnnotation",
  "components": [
    "TransformComponent",
    "SceneComponent",
    "AnnotationAxisComponent",
    "TextComponent",
    "SpriteRenderComponent",
  ]
})"
, context->store);
 
  readEntityDefinition(R"(
{ "name": "EchoOctReference",
  "components" : [
    "EchoDataRefComponent",
    "EchoBeamGroupComponent",
    "SceneComponent"
  ]
})"
, context->store);
 
  readEntityDefinition(R"(
{ "name": "EchoOctVolume",
  "components" : [
    "VolOctComponent",
    "EchoOctProviderComponent",
    "TransformComponent",
    "SceneComponent"
  ]
})"
, context->store);
 
 
  auto dataSetSystem = ExtensionRegistry::registerExtensionSystem<DataSetSystem>(context, SystemPriority::PreDynamicComponents, 8);
 
  ExtensionRegistry::registerExtensionSystem<UniformGridSystem>(context, SystemPriority::PreDynamicComponents, 8);
 
  auto swathSeabedSystem = ExtensionRegistry::registerExtensionSystem<SwathBottomSystem>(context, SystemPriority::Geometry, 16);
  swathSeabedSystem->setDataSystem(dataSetSystem);
 
  auto swathIsoSystem = ExtensionRegistry::registerExtensionSystem<SwathIsoSystem>(context, SystemPriority::Geometry, 16);
  swathIsoSystem->setDataSystem(dataSetSystem);
 
  auto singlePingIsoSystem = ExtensionRegistry::registerExtensionSystem<PingIsoSystem>(context, SystemPriority::Geometry, 16);
  singlePingIsoSystem->setDataSystem(dataSetSystem);
 
  ExtensionRegistry::registerExtensionSystem<OctProviderSystem>(context, SystemPriority::PreGeometry, 4);
 
  // Add EchoSounderResize
  ViewContext*  defaultView = context->getDefaultView();
  glm::vec2     size = defaultView->getSize();
 
  EchoSounderResize(defaultView, (int)size.x, (int)size.y);
  defaultView->addResizeCallback(&EchoSounderResize);
  return true;
}
 
void Cogs::Core::EchoSounder::EchoSounderExtension::cleanup(Context * context)
{
  if(context) {
    ViewContext*  defaultView = context->getDefaultView();
 
    if (defaultView) {
      defaultView->removeResizeCallback(&EchoSounderResize);
    }
  }
}