ClipmapUpdate.cpp

#include "ClipmapUpdate.h"
#include <algorithm>
Cogs::ClipmapUpdate::ClipmapUpdate(ClipmapLevel * level, int west, int south, int east, int north)
  : level(level)
{
  extent = Extent{ west, south, east, north };
}
 
int Cogs::ClipmapUpdate::getWidth() const
{
  return (extent.east - extent.west + 1);
}
 
int Cogs::ClipmapUpdate::getHeight() const
{
  return (extent.north - extent.south + 1);
}
 
Cogs::ClipmapUpdate Cogs::ClipmapUpdate::addBufferWithinLevelNextExtent() const
{
  ClipmapUpdate update(
    level,
    std::max<int>(extent.west - 1,  level->nextExtent.west),
    std::max<int>(extent.south - 1, level->nextExtent.south),
    std::min<int>(extent.east + 1,  level->nextExtent.east),
    std::min<int>(extent.north + 1, level->nextExtent.north)
  );
 
  return update;
}
 
void Cogs::ClipmapUpdate::splitUpdateToAvoidWrapping(const ClipmapUpdate & update, std::vector<ClipmapUpdate> & results)
{
  ClipmapLevel * level = update.getLevel();
  const TextureOrigin & origin = level->origin;
  const Extent & extent = level->nextExtent;
 
  const int clipmapSizeX = extent.getWidth();
  const int clipmapSizeY = extent.getHeight();
 
  const int west = (origin.x + (update.getWest() - extent.west)) % clipmapSizeX;
  const int east = (origin.x + (update.getEast() - extent.west)) % clipmapSizeX;
  const int south = (origin.y + (update.getSouth() - extent.south)) % clipmapSizeY;
  const int north = (origin.y + (update.getNorth() - extent.south)) % clipmapSizeY;
 
  if (east < west && north < south) {
    // Horizontal AND vertical wrap
    ClipmapUpdate bottomLeftUpdate(
      level,
      update.getWest(),
      update.getSouth(),
      extent.west + (clipmapSizeX - origin[0] - 1),
      extent.south + (clipmapSizeY - origin[1] - 1));
 
    ClipmapUpdate bottomRightUpdate(
      level,
      extent.west + clipmapSizeX - origin[0],
      update.getSouth(),
      update.getEast(),
      extent.south + (clipmapSizeY - origin[1] - 1));
 
    ClipmapUpdate topLeftUpdate(
      level,
      update.getWest(),
      extent.south + clipmapSizeY - origin[1],
      extent.west + (clipmapSizeX - origin[0] - 1),
      update.getNorth());
 
    ClipmapUpdate topRightUpdate(
      level,
      extent.west + clipmapSizeX - origin[0],
      extent.south + clipmapSizeY - origin[1],
      update.getEast(),
      update.getNorth());
 
    results.push_back(bottomLeftUpdate);
    results.push_back(bottomRightUpdate);
    results.push_back(topLeftUpdate);
    results.push_back(topRightUpdate);
  } else if (east < west) {
    // Horizontal wrap
    ClipmapUpdate leftUpdate(
      level,
      update.getWest(),
      update.getSouth(),
      extent.west + (clipmapSizeX - origin[0] - 1),
      update.getNorth());
 
    ClipmapUpdate rightUpdate(
      level,
      extent.west + clipmapSizeX - origin[0],
      update.getSouth(),
      update.getEast(),
      update.getNorth());
 
    results.push_back(leftUpdate);
    results.push_back(rightUpdate);
  } else if (north < south) {
    // Vertical wrap
    ClipmapUpdate bottomUpdate(
      level,
      update.getWest(),
      update.getSouth(),
      update.getEast(),
      extent.south + (clipmapSizeY - origin[1] - 1));
 
    ClipmapUpdate topUpdate(
      level,
      update.getWest(),
      extent.south + clipmapSizeY - origin[1],
      update.getEast(),
      update.getNorth());
 
    results.push_back(bottomUpdate);
    results.push_back(topUpdate);
  } else {
    // No wrap
    results.push_back(update);
  }
}
 
Cogs::ClipmapUpdate Cogs::ClipmapUpdate::intersectUpdates(const ClipmapUpdate & first, const ClipmapUpdate & second)
{
  const int west = std::max(first.getWest(), second.getWest());
  const int south = std::max(first.getSouth(), second.getSouth());
  const int east = std::min(first.getEast(), second.getEast());
  const int north = std::min(first.getNorth(), second.getNorth());
 
  return ClipmapUpdate(first.getLevel(), west, south, east, north);
}