TerrainFunctions.cpp

#include "TerrainFunctions.h"
 
#include "../Source/TerrainSystem.h"
 
#include "Context.h"
#include "Bridge/DebugFunctions.h"
#include "Resources/ResourceStore.h"
 
#include "../Source/Terrain.h"
 
#include "Foundation/ComponentModel/Entity.h"
 
 
using namespace Cogs::Core;
 
void initializeTerrain()
{
  // Nothing to do here.
}
 
namespace Cogs
{
  namespace Core
  {
    TerrainData * getTerrainData(Context * context, EntityId id)
    {
      auto terrainSystem = ExtensionRegistry::getExtensionSystem<TerrainSystem>(context);
 
      for (auto & terrainComponent : terrainSystem->pool) {
        if (terrainComponent.getContainer()->getId() == id) {
          return &terrainSystem->getData(&terrainComponent);
        }
      }
 
      return nullptr;
    }
  }
}
 
void setRasterSources(BridgeContext * ctx,
                      EntityId id,
                      Cogs::RasterSourceParameters * terrainParameters,
                      const size_t numTerrain,
                      Cogs::RasterSourceParameters * imageryParameters,
                      const size_t numImagery)
{
  auto context = static_cast<Context*>(ctx);
  auto terrainData = Cogs::Core::getTerrainData(context, id);
 
  terrainSetRasterSources(terrainData->context, terrainParameters, numTerrain, imageryParameters, numImagery);
}
 
void setDebugOptions(BridgeContext * ctx, EntityId id, const Cogs::DebugOptions * options)
{
  auto context = static_cast<Context*>(ctx);
  auto terrainData = Cogs::Core::getTerrainData(context, id);
 
  terrainSetDebugOptions(terrainData->context, options);
}
 
void setOceanOptions(BridgeContext * ctx, EntityId id, const Cogs::OceanOptions * options)
{
  auto context = static_cast<Context*>(ctx);
  auto terrainData = Cogs::Core::getTerrainData(context, id);
 
  oceanSetOptions(terrainData->context, options);
}
 
void * createSharedContext(BridgeContext * ctx)
{
  auto context = static_cast<Context*>(ctx);
  return context->device->createSharedContext();
}
 
void initializeSharedContext(BridgeContext * ctx, void * sharedContext)
{
  auto context = static_cast<Context*>(ctx);
  context->device->activateSharedContext((Cogs::SharedGraphicsContext *)sharedContext);
}
 
void releaseSharedContext(BridgeContext * ctx, void * sharedContext)
{
  auto context = static_cast<Context*>(ctx);
  context->device->releaseSharedContext((Cogs::SharedGraphicsContext *)sharedContext);
}
 
void setShadingOptions(BridgeContext * ctx, EntityId id, const Cogs::ShadingOptions * options)
{
  auto context = static_cast<Context*>(ctx);
  auto terrainData = Cogs::Core::getTerrainData(context, id);
 
  terrainData->customComputeColor = options->customComputeColor;
}
 
void invalidateRasterSource(BridgeContext * ctx, EntityId id, const long rasterSourceId, const bool clearContents)
{
  auto context = static_cast<Context*>(ctx);
  auto terrainData = Cogs::Core::getTerrainData(context, id);
 
  terrainInvalidateRasterSource(terrainData->context, rasterSourceId, clearContents);
}
 
float getNearestSample(BridgeContext * ctx, EntityId id)
{
  auto context = static_cast<Context*>(ctx);
  auto terrainData = Cogs::Core::getTerrainData(context, id);
 
  return terrainGetNearestSample(terrainData->context);
}
 
void triggerTerrainUpdate(BridgeContext * /*ctx*/, EntityId /*id*/)
{
 
}
 
void setClipmapParameters(BridgeContext * ctx, EntityId id, const Cogs::ClipmapParameters * parameters)
{
  auto context = static_cast<Context*>(ctx);
  auto terrainData = Cogs::Core::getTerrainData(context, id);
 
  terrainSetParameters(terrainData->context, parameters);
}
 
void setWorldOptions(BridgeContext * ctx, EntityId id, const Cogs::WorldOptions * options)
{
  auto context = static_cast<Context*>(ctx);
  auto terrainData = Cogs::Core::getTerrainData(context, id);
 
  terrainSetWorldOptions(terrainData->context, options);
}
 
void setUpdateOptions(BridgeContext * ctx, EntityId id, const Cogs::UpdateOptions * options)
{
  auto context = static_cast<Context*>(ctx);
  auto terrainData = Cogs::Core::getTerrainData(context, id);
 
  terrainSetUpdateOptions(terrainData->context, options);
}
 
void setRenderOptions(BridgeContext * ctx, EntityId id, const Cogs::RenderOptions * options)
{
  auto context = static_cast<Context*>(ctx);
  auto terrainData = Cogs::Core::getTerrainData(context, id);
 
  terrainSetRenderOptions(terrainData->context, options);
}
 
void queryTerrain(BridgeContext * ctx, EntityId id, Cogs::TerrainQuery * query, Cogs::TerrainQueryCallback callback)
{
  auto context = static_cast<Context*>(ctx);
  auto terrainData = Cogs::Core::getTerrainData(context, id);
 
  terrainPostQuery(terrainData->context, query, callback);
}
 
void processQueries(BridgeContext * ctx, EntityId id)
{
  auto context = static_cast<Context*>(ctx);
  auto terrainData = Cogs::Core::getTerrainData(context, id);
 
  CHECKED(context, terrainProcessQueries(terrainData->context));
}
 
void getTerrainMetrics(BridgeContext * ctx, EntityId id, Cogs::TerrainMetrics * metrics)
{
  auto context = static_cast<Context*>(ctx);
  auto terrainData = Cogs::Core::getTerrainData(context, id);
 
  terrainGetTerrainMetrics(terrainData->context, metrics);
}
 
void setMaxTilesPerFrame(BridgeContext * ctx, EntityId id, int count)
{
  auto context = static_cast<Context*>(ctx);
  auto terrainData = Cogs::Core::getTerrainData(context, id);
  
  terrainData->maxTilesPerFrame = count;
}
 
void disposeRasterSource(BridgeContext* /*ctx*/, int64_t id)
{
  terrainDisposeRasterSource(id);
}
 
void invalidateRasterTile(BridgeContext*, int64_t id, int level, int x, int y, int flags)
{
  terrainInvalidateTile(id, level, x, y, flags);
}
 
void setImageryEnabled(BridgeContext * ctx, EntityId id, const bool * data, int count)
{
  auto context = static_cast<Context*>(ctx);
  auto terrainData = Cogs::Core::getTerrainData(context, id);
 
  terrainSetImageryEnabled(terrainData->context, data, count);
}
 
void setCustomParameters(BridgeContext * ctx, EntityId id, const unsigned char * data, int count)
{
  auto context = static_cast<Context*>(ctx);
  auto terrainData = Cogs::Core::getTerrainData(context, id);
 
  terrainSetCustomParameters(terrainData->context, data, count);
}