ClipmapGeometry.cpp

#include "ClipmapGeometry.h"
 
#include "ClipmapTerrainTypes.h"
 
Cogs::ClipmapMesh Cogs::createMesh(IBuffers * buffers, double left, double bottom, double right, double top, size_t numberOfPartitionsX, size_t numberOfPartitionsY, const VertexFormatHandle & vertexFormat)
{
  size_t numberOfPositions = (numberOfPartitionsX + 1) * (numberOfPartitionsY + 1);
  size_t numberOfIndices = (numberOfPartitionsX * numberOfPartitionsY) * 6;
 
  Vector2d lowerLeft(left, bottom);
  Vector2d toUpperRight = Vector2d(right, top) - lowerLeft;
 
  std::vector<Vector2> positions(numberOfPositions);
  std::vector<unsigned short> indexes(numberOfIndices);
 
  for (size_t y = 0; y <= numberOfPartitionsY; ++y) {
    double deltaY = y / (double)numberOfPartitionsY;
    double currentY = lowerLeft[1] + (deltaY * toUpperRight[1]);
 
    for (size_t x = 0; x <= numberOfPartitionsX; ++x) {
      double deltaX = x / (double)numberOfPartitionsX;
      double currentX = lowerLeft[0] + (deltaX * toUpperRight[0]);
 
      positions[y * (numberOfPartitionsX + 1) + x] = Vector2((float)currentX, (float)currentY);
    }
  }
 
  size_t rowDelta = numberOfPartitionsX + 1;
  size_t i = 0;
  size_t index = 0;
 
  for (size_t y = 0; y < numberOfPartitionsY; ++y) {
    for (size_t x = 0; x < numberOfPartitionsX; ++x) {
      indexes[index++] = static_cast<unsigned short>(i);
      indexes[index++] = static_cast<unsigned short>(i + 1);
      indexes[index++] = static_cast<unsigned short>(rowDelta + (i + 1));
 
      indexes[index++] = static_cast<unsigned short>(i);
      indexes[index++] = static_cast<unsigned short>(rowDelta + (i + 1));
      indexes[index++] = static_cast<unsigned short>(rowDelta + i);
 
      i += 1;
    }
 
    i += 1;
  }
 
  ClipmapMesh mesh = {
    buffers->loadVertexBuffer(positions.data(), positions.size(), vertexFormat),
    buffers->loadIndexBuffer(indexes.data(), indexes.size(), sizeof(unsigned short)),
    static_cast<uint32_t>(getSize(vertexFormat)),
    static_cast<int>(right - left),
    static_cast<int>(top - bottom),
  };
 
  return mesh;
}
 
Cogs::ClipmapMesh Cogs::createSimpleMesh(IBuffers * buffers, double left, double bottom, double right, double top, size_t numberOfPartitionsX, size_t numberOfPartitionsY, const VertexFormatHandle & vertexFormat)
{
  size_t numberOfPositions = 1 + (numberOfPartitionsX + 1) * 2 + (numberOfPartitionsY - 1) * 2;
  size_t numberOfIndices = numberOfPositions * 3;
 
  Vector2d lowerLeft(left, bottom);
  Vector2d toUpperRight = Vector2d(right, top) - lowerLeft;
 
  std::vector<Vector2> positions(numberOfPositions);
  std::vector<unsigned short> indexes(numberOfIndices);
 
  // Center vertex.
  int index = 0;
  positions[index++] = Vector2(lowerLeft + toUpperRight * 0.5);
 
  for (size_t i = 0; i < numberOfPartitionsX + 1; ++i) {
    positions[index++] = Vector2(lowerLeft + Vector2d(toUpperRight.x * (1.0 / (double)numberOfPartitionsX) * (double)i, 0));
  }
 
  for (size_t i = 1; i < numberOfPartitionsY; ++i) {
    positions[index++] = Vector2(lowerLeft + Vector2d(toUpperRight.x, toUpperRight.y * (1.0 / (double)numberOfPartitionsY) * (double)i));
  }
 
  for (int i = static_cast<int>(numberOfPartitionsX); i >= 0; --i) {
    positions[index++] = Vector2(lowerLeft + Vector2d(toUpperRight.x * (1.0 / (double)numberOfPartitionsX) * (double)i, toUpperRight.y));
  }
 
  for (int i = static_cast<int>(numberOfPartitionsY) - 1; i > 0; --i) {
    positions[index++] = Vector2(lowerLeft + Vector2d(0, toUpperRight.y * (1.0 / (double)numberOfPartitionsX) * (double)i));
  }
 
  index = 0;
  for (size_t i = 1; i < numberOfPositions; ++i) {
    indexes[index++] = static_cast<unsigned short>(0);
    indexes[index++] = static_cast<unsigned short>(i);
    indexes[index++] = static_cast<unsigned short>(i + 1);
  }
 
  ClipmapMesh mesh = {
    buffers->loadVertexBuffer(positions.data(), positions.size(), vertexFormat),
    buffers->loadIndexBuffer(indexes.data(), indexes.size(), sizeof(unsigned short)),
    static_cast<uint32_t>(getSize(vertexFormat)),
    static_cast<int>(right - left),
    static_cast<int>(top - bottom),
  };
 
  return mesh;
}
 
Cogs::ClipmapMesh Cogs::createDegenerateMesh(IBuffers * buffers, size_t clipmapSegments, size_t clipmapPosts, const VertexFormatHandle & vertexFormat)
{
  size_t numberOfPositions = clipmapSegments * 4;
  size_t numberOfIndices = (clipmapSegments / 2) * 3 * 4;
 
  std::vector<Vector2> positions(numberOfPositions);
  std::vector<unsigned short> indexes;
 
  size_t index = 0;
 
  for (size_t i = 0; i < clipmapPosts; ++i) {
    positions[index++] = Vector2(0, (float)i);
  }
 
  for (size_t i = 1; i < clipmapPosts; ++i) {
    positions[index++] = Vector2((float)i, (float)clipmapSegments);
  }
 
  for (int i = static_cast<int>(clipmapSegments - 1); i >= 0; --i) {
    positions[index++] = Vector2((float)clipmapSegments, (float)i);
  }
 
  for (size_t i = clipmapSegments - 1; i > 0; --i) {
    positions[index++] = Vector2((float)i, 0);
  }
 
  assert(index == positions.size());
 
  for (size_t i = 0; i < numberOfIndices; i += 2) {
    indexes.push_back(static_cast<unsigned short>(i));
    indexes.push_back(static_cast<unsigned short>(i + 1));
    indexes.push_back(static_cast<unsigned short>(i + 2));
  }
 
  ClipmapMesh mesh = {
    buffers->loadVertexBuffer(positions.data(), positions.size(), vertexFormat),
    buffers->loadIndexBuffer(indexes.data(), indexes.size(), sizeof(unsigned short)),
    static_cast<uint32_t>(getSize(vertexFormat)),
    -1,
    -1,
  };
 
  return mesh;
}
 
void Cogs::initializeGeometry(ClipmapGeometry & clipmapGeometry, IBuffers * buffers, size_t fillPatchPosts, size_t fillPatchSegments, size_t clipmapSegments, size_t clipmapPosts)
{
  VertexElement element = { 0, DataFormat::X32Y32_FLOAT, ElementSemantic::Position, 0, InputType::VertexData, 0 };
  clipmapGeometry.meshFormat = buffers->createVertexFormat(&element, 1);
  clipmapGeometry.stride = getSize(clipmapGeometry.meshFormat);
 
  clipmapGeometry.buffers = buffers;
  clipmapGeometry.worldMesh.vertexBuffer = VertexBufferHandle::InvalidHandle;
  clipmapGeometry.simpleWorldMesh.vertexBuffer = VertexBufferHandle::InvalidHandle;
 
  double segments = static_cast<double>(fillPatchSegments);
  double posts = static_cast<double>(fillPatchPosts);
 
  // Create the MxM block used to fill the ring and the field.
  clipmapGeometry.fieldBlockMesh = createMesh(buffers, 0.0, 0.0, segments, segments, fillPatchSegments, fillPatchSegments, clipmapGeometry.meshFormat);
 
  // Create the Mx3 block used to fill the space between the MxM blocks in the ring
  clipmapGeometry.ringFixupHorizontalMesh = createMesh(buffers, 0.0, 0.0, segments, 2.0, fillPatchSegments, 2, clipmapGeometry.meshFormat);
 
  // Create the 3xM block used to fill the space between the MxM blocks in the ring
  clipmapGeometry.ringFixupVerticalMesh = createMesh(buffers, 0.0, 0.0, 2.0, segments, 2, fillPatchSegments, clipmapGeometry.meshFormat);
 
  clipmapGeometry.offsetStripHorizontalMesh = createMesh(buffers, 0.0, 0.0, 2.0 * posts, 1.0, 2 * fillPatchPosts, 1, clipmapGeometry.meshFormat);
  clipmapGeometry.offsetStripVerticalMesh = createMesh(buffers, 0.0, 0.0, 1.0, 2.0 * posts - 1.0, 1, 2 * fillPatchPosts - 1, clipmapGeometry.meshFormat);
 
  clipmapGeometry.centerMesh = createMesh(buffers, 0, 0, 2.0, 2.0, 2, 2, clipmapGeometry.meshFormat);
 
  clipmapGeometry.degenerateTriangleMesh = createDegenerateMesh(buffers, clipmapSegments, clipmapPosts, clipmapGeometry.meshFormat);
 
  clipmapGeometry.simpleMesh = createSimpleMesh(buffers, 0, 0, segments, segments, fillPatchSegments, fillPatchSegments, clipmapGeometry.meshFormat);
 
  clipmapGeometry.initialized = true;
}
 
void Cogs::releaseMesh(ClipmapMesh & mesh, IBuffers * buffers)
{
  buffers->releaseVertexBuffer(mesh.vertexBuffer);
  buffers->releaseIndexBuffer(mesh.indexBuffer);
}
 
void Cogs::releaseGeometry(ClipmapGeometry & clipmapGeometry, IBuffers * buffers)
{
  releaseMesh(clipmapGeometry.fieldBlockMesh, buffers);
 
  releaseMesh(clipmapGeometry.ringFixupHorizontalMesh, buffers);
  releaseMesh(clipmapGeometry.ringFixupVerticalMesh, buffers);
 
  releaseMesh(clipmapGeometry.offsetStripHorizontalMesh, buffers);
  releaseMesh(clipmapGeometry.offsetStripVerticalMesh, buffers);
 
  releaseMesh(clipmapGeometry.centerMesh, buffers);
 
  releaseMesh(clipmapGeometry.degenerateTriangleMesh, buffers);
 
  clipmapGeometry.initialized = false;
}