TerrainProviderFunctions.cpp

#include "TerrainProviderFunctions.h"
 
#include "../Source/JsonSerialization.h"
 
#include "Context.h"
#include "Resources/ResourceStore.h"
#include "Services/Services.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/IO.h"
 
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("TerrainProvider");
}
 
Cogs::Core::TerrainProvider::IRasterSource::~IRasterSource()
{
}
 
Cogs::Core::TerrainProvider::IRasterSource* Cogs::Core::TerrainProvider::open(Context* context, const char* path)
{
  ResourceQueryResult sourceLocation = context->resourceStore->getResourceLocation(path, ResourceStoreFlags::NoCachedContent);
  std::string fullPath = sourceLocation.protocol == ResourceProtocol::File ? sourceLocation.path : path;
  auto configFile = context->resourceStore->getResourceContents(fullPath);
  if (!configFile.buffer) {
    LOG_ERROR(logger, "Error reading %s", fullPath.c_str());
    return nullptr;
  }
 
  LOG_DEBUG(logger, "Parsing %s", fullPath.c_str());
  auto* rasterSource = deserialize(context, IO::parentPath(fullPath),
                                   StringView((const char*)configFile.buffer->data(),
                                              configFile.buffer->size()));
  if (rasterSource == nullptr) {
    LOG_ERROR(logger, "Error parsing %s", fullPath.c_str());
    return nullptr;
  }
 
  Cogs::Memory::MemoryBuffer buf;
  if (!serializeConfig(buf, rasterSource)) {
    LOG_ERROR(logger, "Failed to serialize rastersource");
  }
  //LOG_DEBUG(logger, "%.*s", (int)buf.size(), (const char*)buf.data());
  return rasterSource;
}
 
Cogs::Core::TerrainProvider::MimeType Cogs::Core::TerrainProvider::parseMimeType(size_t textHash)
{
  switch (textHash) {
  case Cogs::hash("image/png"):
  case Cogs::hash("image/png32"):
    return MimeType::Png;
 
  case Cogs::hash("image/gif"):
    return MimeType::Gif;
 
  case Cogs::hash("image/jpeg"):
    return MimeType::Jpeg;
 
  case Cogs::hash("image/geotiff"):
  case Cogs::hash("image/tiff"):
    return MimeType::Tiff;
 
  case Cogs::hash("image/raw-f32"):
    return MimeType::Tiff;
 
  case Cogs::hash("image/raw-rgba8"):
    return MimeType::Tiff;
 
  case Cogs::hash("application/xml"):
  case Cogs::hash("text/xml"):
    return MimeType::XML;
 
  default:
    return MimeType::None;
  }
}
 
Cogs::Core::TerrainProvider::MimeType Cogs::Core::TerrainProvider::parseMimeType(StringView text)
{
  MimeType type = parseMimeType(text.hash());
  if (type == MimeType::None) {
    LOG_ERROR(logger, "Unrecognized mime type '%.*s'", StringViewFormat(text));
  }
  return type;
}
 
Cogs::Core::StringRef Cogs::Core::TerrainProvider::mimeTypeString(MimeType mimeType)
{
  switch (mimeType) {
  case MimeType::None:
    return NoString;
 
  case MimeType::Png:
    return Strings::add("image/png");
 
  case MimeType::Gif:
    return Strings::add("image/gif");
 
  case MimeType::Jpeg:
    return Strings::add("image/jpeg");
 
  case MimeType::Tiff:
    return Strings::add("image/geotiff");
 
  case MimeType::F32:
    return Strings::add("image/raw-f32");
 
  case MimeType::RGBA8:
    return Strings::add("image/raw-rgba8");
 
  case MimeType::XML:
    return Strings::add("text/xml");
 
  default:
    assert(false && "Illegal mime-type");
    return NoString;
  }
}