ExtrusionGenerator.cpp

#include "ExtrusionGenerator.h"
 
bool Cogs::Geometry::ExtrusionGenerator::generateCrossSections(glm::vec3 * vertices, int numSections, const glm::vec3 * crossSectionElements, int numSegments, const glm::quat * rotations)
{
  if (!vertices || !numSegments || !crossSectionElements || !numSections || !rotations) return false;
 
  int index = 0;
 
  for (int i = 0; i < numSections; i++) {
    for (int j = 0; j < numSegments; j++) {
      vertices[index++] = rotations[i] * crossSectionElements[j];
    }
  }
 
  return true;
}
 
bool Cogs::Geometry::ExtrusionGenerator::generateCrossSections(glm::vec3 * vertices,
                                                               int numSections,
                                                               const glm::vec3 * crossSectionElements,
                                                               const glm::vec3 * crossSectionElements2,
                                                               const float * morphs,
                                                               int numSegments,
                                                               const glm::quat * rotations)
{
  if (!vertices || !numSegments || !crossSectionElements || !numSections || !rotations) return false;
 
  int index = 0;
 
  for (int i = 0; i < numSections; i++) {
    for (int j = 0; j < numSegments; j++) {
      vertices[index++] = rotations[i] * (crossSectionElements[j] * (1.0f - morphs[i]) + crossSectionElements2[j] * morphs[i]);
    }
  }
 
  return true;
}
 
void Cogs::Geometry::ExtrusionGenerator::generateSimpleExtrusionNormals(glm::vec3 * vertices, glm::vec3 * normals, int numVertices)
{
  for (int i = 0; i < numVertices; ++i) {
    normals[i] = vertices[i];
    normals[i] = glm::normalize(normals[i]);
  }
}
 
void Cogs::Geometry::ExtrusionGenerator::offsetCrossSections(glm::vec3 * vertices, int numSections, int numSegments, const glm::vec3 * positions)
{
  int index = 0;
 
  for (int i = 0; i < numSections; i++) {
    for (int j = 0; j < numSegments; j++) {
      vertices[index] = vertices[index] + positions[i];
 
      ++index;
    }
  }
}
 
void Cogs::Geometry::ExtrusionGenerator::colorSections(uint32_t * colors, int numSections, int numSegments, uint32_t * colorValues)
{
  int index = 0;
 
  for (int i = 0; i < numSections; ++i) {
    uint32_t color = colorValues[i];
 
    for (int j = 0; j < numSegments; ++j) {
      colors[index++] = color;
    }
  }
}
 
void Cogs::Geometry::ExtrusionGenerator::modulateSections(glm::vec3 * vertices, const int numSections, const int numSegments, const float * values, const size_t stride)
{
  int index = 0;
 
  for (int i = 0; i < numSections; i++) {
    for (int j = 0; j < numSegments; j++) {
      vertices[index++] *= values[i * stride];
    }
  }
}
 
void Cogs::Geometry::ExtrusionGenerator::modulateVertices(glm::vec3 * vertices, int numVertices, float * values)
{
  int index = 0;
 
  for (int i = 0; i < numVertices; i++) {
    vertices[index++] *= values[i];
  }
}
 
void Cogs::Geometry::ExtrusionGenerator::generateTriangleIndices(int32_t * indices, int numSections, int numSegments, bool closed, bool useTexture, int32_t offset)
{
  int index = 0;
 
  if (closed && !useTexture) {
    for (int i = offset; i < offset + numSections - 1; i++) {
      for (int j = 0; j < numSegments - 1; j++) {
        indices[index++] = (i * numSegments) + j;
        indices[index++] = (i * numSegments) + j + 1;
        indices[index++] = ((i + 1) * numSegments) + j + 1;
        indices[index++] = -1;
 
        indices[index++] = (i * numSegments) + j;
        indices[index++] = ((i + 1) * numSegments) + j + 1;
        indices[index++] = ((i + 1) * numSegments) + j;
        indices[index++] = -1;
      }
 
      indices[index++] = (i * numSegments) + numSegments - 1;
      indices[index++] = (i * numSegments);
      indices[index++] = ((i + 1) * numSegments);
      indices[index++] = -1;
 
      indices[index++] = (i * numSegments) + numSegments - 1;
      indices[index++] = ((i + 1) * numSegments);
      indices[index++] = ((i + 1) * numSegments) + numSegments - 1;
      indices[index++] = -1;
    }
  } else {
    for (int i = offset; i < offset + numSections - 1; i++) {
      for (int j = 0; j < numSegments - 1; j++) {
        indices[index++] = (i * numSegments) + j;
        indices[index++] = (i * numSegments) + j + 1;
        indices[index++] = ((i + 1) * numSegments) + j + 1;
        indices[index++] = -1;
 
        indices[index++] = (i * numSegments) + j;
        indices[index++] = ((i + 1) * numSegments) + j + 1;
        indices[index++] = ((i + 1) * numSegments) + j;
        indices[index++] = -1;
      }
    }
  }
}
 
void Cogs::Geometry::ExtrusionGenerator::generateTriangleIndices(uint32_t * indices, int numSections, int numSegments, bool closed, bool useTexture, int32_t offset)
{
  int index = 0;
 
  if (closed && !useTexture) {
    for (int i = offset; i < offset + numSections - 1; i++) {
      for (int j = 0; j < numSegments - 1; j++) {
        indices[index++] = (i * numSegments) + j;
        indices[index++] = (i * numSegments) + j + 1;
        indices[index++] = ((i + 1) * numSegments) + j + 1;
 
        indices[index++] = (i * numSegments) + j;
        indices[index++] = ((i + 1) * numSegments) + j + 1;
        indices[index++] = ((i + 1) * numSegments) + j;
      }
 
      indices[index++] = (i * numSegments) + numSegments - 1;
      indices[index++] = (i * numSegments);
      indices[index++] = ((i + 1) * numSegments);
 
      indices[index++] = (i * numSegments) + numSegments - 1;
      indices[index++] = ((i + 1) * numSegments);
      indices[index++] = ((i + 1) * numSegments) + numSegments - 1;
    }
  } else {
    for (int i = offset; i < offset + numSections - 1; i++) {
      for (int j = 0; j < numSegments - 1; j++) {
        indices[index++] = (i * numSegments) + j;
        indices[index++] = (i * numSegments) + j + 1;
        indices[index++] = ((i + 1) * numSegments) + j + 1;
 
        indices[index++] = (i * numSegments) + j;
        indices[index++] = ((i + 1) * numSegments) + j + 1;
        indices[index++] = ((i + 1) * numSegments) + j;
      }
    }
  }
}
 
void
Cogs::Geometry::ExtrusionGenerator::generateDepthBasedTextureCoordinates(const size_t pathLength, const size_t numSegments, const float * depths, const float * offsets, const size_t offsetStride, glm::vec2 * texCoords)
{
  for (size_t i = 0; i < pathLength; i++) {
    float v = depths[i] + offsets[i * offsetStride];
 
    for (size_t j = 0; j < numSegments; j++) {
      float u = static_cast<float>(j) / (numSegments - 1);
 
      texCoords[i * numSegments + j] = glm::vec2(u, v);
    }
  }
}