Terrain.cpp

#include "Terrain.h"
 
#include "ClipmapManager.h"
#include "ClipmapQueryHandler.h"
 
#include "Raster/BridgeRasterSource.h"
 
#include "Rendering/IGraphicsDevice.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <unordered_map>
#include <memory>
 
using namespace Cogs;
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Terrain");
}
 
namespace Cogs
{
  std::unordered_map<int64_t, RasterSourcePtr> activeSources;
 
  struct TerrainContext
  {
    ClipmapManager manager;
    ClipmapQueryHandler queryHandler;
 
    size_t maxLevel;
 
    bool postInitialized = false;
  };
}
 
void terrainInitialize()
{
  LOG_DEBUG(logger, "Initialized terrain.");
}
 
Cogs::TerrainContext * terrainCreate()
{
  LOG_DEBUG(logger, "Creating terrain...");
 
  auto context = new Cogs::TerrainContext();
 
  return context;
}
 
void terrainDestroy(Cogs::TerrainContext * terrain)
{
  LOG_DEBUG(logger, "Destroying terrain...");
 
  terrain->manager.cleanupLevels();
 
  delete terrain;
 
  LOG_DEBUG(logger, "Terrain destroyed.");
}
 
void terrainInitializeInstance(Cogs::TerrainContext * context, void * device)
{
  auto graphicsDevice = reinterpret_cast<Cogs::IGraphicsDevice *>(device);
 
  context->manager.initialize(graphicsDevice);
  context->queryHandler.initialize(&context->manager.terrainLevels, &context->manager.imagery);
}
 
void terrainUpdate(Cogs::TerrainContext * context)
{
  context->manager.update();
}
 
void terrainInvalidateTile(int64_t rasterSourceId, int level, int x, int y, int flags)
{
  auto sIt = activeSources.find(rasterSourceId);
 
  if (sIt == activeSources.end()) {
    LOG_ERROR(logger, "Cannot invalidate tiles from unregistered raster source (unused or disposed).");
    return;
  }
 
  WriteLock lock(*sIt->second);
 
  sIt->second->invalidateTile({ level, x, y }, (InvalidationFlags::EInvalidationFlags)flags);
}
 
void terrainPreRender(Cogs::TerrainContext * context, void * rc)
{
  auto renderContext = reinterpret_cast<Cogs::RenderContext *>(rc);
 
  context->maxLevel = context->manager.preRender(*renderContext);
}
 
void terrainDepthRender(Cogs::TerrainContext * terrain, void * rc)
{
  auto renderContext = reinterpret_cast<Cogs::RenderContext *>(rc);
 
  terrain->manager.renderDepth(*renderContext, terrain->maxLevel);
}
 
void terrainRender(Cogs::TerrainContext * terrain, void * rc)
{
  auto renderContext = reinterpret_cast<Cogs::RenderContext *>(rc);
 
  terrain->manager.render(*renderContext, terrain->maxLevel);
}
 
void oceanRender(Cogs::TerrainContext * terrain, void * rc)
{
  auto renderContext = reinterpret_cast<Cogs::RenderContext *>(rc);
 
  terrain->manager.renderOcean(*renderContext, terrain->maxLevel);
}
 
void oceanSetOptions(Cogs::TerrainContext * terrain, const Cogs::OceanOptions * options)
{
  terrain->manager.oceanRenderer.setOptions(options);
}
 
void terrainPostRender(Cogs::TerrainContext * context, void * rc)
{
  auto renderContext = reinterpret_cast<Cogs::RenderContext *>(rc);
 
  context->manager.postRender(*renderContext);
 
  context->manager.previousContext = *renderContext;
 
  if (!context->postInitialized) {
    context->queryHandler.postInitialize();
 
    context->postInitialized = true;
  }
}
 
void terrainSetRasterSources(Cogs::TerrainContext * context,
                             Cogs::RasterSourceParameters * terrainParameters,
                             const size_t /*numTerrain*/,
                             Cogs::RasterSourceParameters * imageryParameters,
                             const size_t numImagery)
{
  if (activeSources.find(terrainParameters->id) == activeSources.end()) {
    auto terrainSource = std::make_shared<Cogs::BridgeRasterSource>(nullptr, terrainParameters);
    activeSources[terrainParameters->id] = std::move(terrainSource);
  }
 
  std::vector<RasterSourcePtr> imagery(numImagery);
 
  for (size_t i = 0; i < numImagery; ++i) {
    auto id = imageryParameters[i].id;
 
    if (activeSources.find(id) == activeSources.end()) {
      // If no bridge exists for the given id, create a new one.
      activeSources[id] = std::make_shared<Cogs::BridgeRasterSource>(nullptr, &imageryParameters[i]);
    }
 
    imagery[i] = activeSources[id];
  }
 
  context->manager.setRasterSources(activeSources[terrainParameters->id], imagery);
}
 
void terrainDisposeRasterSource(int64_t id)
{
  activeSources.erase(id);
}
 
void terrainSetParameters(Cogs::TerrainContext * context, const Cogs::ClipmapParameters * parameters)
{
  context->manager.setClipmapParameters(parameters);
}
 
void terrainReset(Cogs::TerrainContext *, void * rc)
{
  auto & renderContext = *reinterpret_cast<Cogs::RenderContext *>(rc);
 
  Cogs::IContext * context = renderContext.context;
 
  context->setEffect(EffectHandle::NoHandle);
 
  for (size_t i = 0; i < 8; ++i) {
    context->setTexture("", static_cast<unsigned int>(i), TextureHandle::NoHandle);
    context->setSamplerState("", static_cast<unsigned int>(i), SamplerStateHandle::NoHandle);
  }
 
  context->setInputLayout(InputLayoutHandle::NoHandle);
 
  if (!renderContext.wireframe) {
    context->setRasterizerState(RasterizerStateHandle::NoHandle);
  }
 
  context->reset();
}
 
void terrainSetDebugOptions(Cogs::TerrainContext * context, const Cogs::DebugOptions * debugOptions)
{
  context->manager.debugOptions = *debugOptions;
}
 
void terrainInvalidateRasterSource(Cogs::TerrainContext * context, const int64_t rasterSourceId, const bool clearContents)
{
  context->manager.invalidateRasterSource(activeSources[rasterSourceId].get(), clearContents);
}
 
float terrainGetNearestSample(Cogs::TerrainContext * context)
{
  return context->manager.getNearestSample();
}
 
void terrainSetCustomParameters(Cogs::TerrainContext * context, const unsigned char * data, int count)
{
  context->manager.clipmapRenderer.setCustomParameters(data, count);
}
 
void terrainSetImageryEnabled(Cogs::TerrainContext * context, const bool * data, int count)
{
  for (int i = 0; i < count; ++i) {
    context->manager.imageryEnabled[i] = data[i];
  }
}
 
void terrainGetTerrainMetrics(Cogs::TerrainContext * context, Cogs::TerrainMetrics * metrics)
{
  context->manager.getTerrainMetrics(metrics);
}
 
bool terrainRayPick(Cogs::TerrainContext * terrain,
                    const float * screenPos,
                    const float * inverseViewProjection,
                    float * pickedPosition,
                    int rayPickId)
{
  bool valid;
  bool picked = terrain->manager.depthQuery.getPositions((const Cogs::Vector2 *)screenPos,
                                                         *(Cogs::Matrix *)inverseViewProjection,
                                                         1,
                                                         (Cogs::Vector4 *)pickedPosition, &valid, rayPickId == -1 ? 0 : rayPickId);
 
  return picked && valid;
}
 
void terrainGetBounds(Cogs::TerrainContext * terrain, double * bounds)
{
  if (!terrain->manager.isInitialized() || !terrain->manager.terrainSource.isReady()) return;
 
  if (!terrain->manager.terrainLevels.size()) return;
 
  auto & levelZero = terrain->manager.terrainLevels[0];
  auto & geoExtent = levelZero.rasterLevel->getGeoExtent();
  auto & worldScale = terrain->manager.worldOptions.worldScale;
 
  auto bbox = reinterpret_cast<Cogs::Vector3d *>(bounds);
 
  bbox[0] = Cogs::Vector3d(geoExtent.getWest() * worldScale.x, geoExtent.getSouth() * worldScale.y, levelZero.minZ * terrain->manager.worldOptions.heightExaggeration);
  bbox[1] = Cogs::Vector3d(geoExtent.getEast() * worldScale.x, geoExtent.getNorth() * worldScale.y, levelZero.maxZ * terrain->manager.worldOptions.heightExaggeration);
}
 
void terrainSetWorldOptions(Cogs::TerrainContext * terrain, const Cogs::WorldOptions * worldOptions)
{
  terrain->manager.worldOptions = *worldOptions;
 
  terrain->manager.updateOptions.invalidateNormals = true;
}
 
void terrainSetUpdateOptions(Cogs::TerrainContext * terrain, const Cogs::UpdateOptions * updateOptions)
{
  terrain->manager.updateOptions = *updateOptions;
}
 
void terrainSetRenderOptions(Cogs::TerrainContext * terrain, const Cogs::RenderOptions * renderOptions)
{
  terrain->manager.renderOptions = *renderOptions;
}
 
bool terrainRequiresRedraw(Cogs::TerrainContext * terrain)
{
  return terrain->manager.updateRequired();
}
 
void terrainPostQuery(Cogs::TerrainContext * terrain, Cogs::TerrainQuery * query, Cogs::TerrainQueryCallback callback)
{
  terrain->queryHandler.postRequest(query, callback, terrain->manager.worldOptions);
}
 
void terrainProcessQueries(Cogs::TerrainContext * terrain)
{
  terrain->queryHandler.processQueries();
}
 
void terrainGetEffectParameters(Cogs::TerrainContext * terrain, Cogs::EffectParameters * effectParameters)
{
  effectParameters->changed = terrain->manager.effectsNeedUpdate;
  effectParameters->numTextures = NUM_TEXTURES;
  effectParameters->numActiveImagery = (int)terrain->manager.imagerySources.size();
  effectParameters->precomputeNormals = terrain->manager.parameters.precomputeNormals;
 
  terrain->manager.effectsNeedUpdate = false;
}