MeshGeneratorSphere.h

#pragma once
 
#include "MeshGeneratorCommon.h"
 
namespace
{
  template<ShapeType subtype>
  void sphereFactoryHelper(std::vector<PositionNormalTexVertex>& V,
                           std::vector<uint32_t>& I,
                           const glm::vec3& p001,
                           const glm::vec3& p010,
                           const glm::vec3& p100,
                           uint32_t samples)
  {
    // sample triangular grid
    int N = samples + 1;
    for (int j = 0; j < N; j++) {
      float v = float(j) / float(N - 1);
      //float w0 = std::sin(glm::half_pi<float>()*(1.f - v));
      //float w1 = std::sin(glm::half_pi<float>()*v);
      for (int i = 0; i < (N - j - (j == 0 ? 1 : 0)); i++) { // note that we omit final element when j==0, see below
        float u = float(i) / float(N - 1);
 
        // sphere position
        glm::vec3 P = glm::normalize(v*p010 + u*p001 + (1.f - u - v)*p100);
 
        // texcoords
        float t = 1.f / std::sqrt(1.f - P.z*P.z);
        float t_u = float(0.5 * glm::one_over_pi<float>())*std::acos(std::min(1.f, P.y*t));
        float t_v = subtype == ShapeType::SphereGeoTexSph
          ? glm::one_over_pi<float>() * std::acos(-P.z)
          : 0.5f + 0.5f*P.z;
        V.push_back({ P, P, glm::vec2(t_u, t_v) });
      }
      if (j == 0) {
        // final element when j==0 has texture parameterization pole degeneracy; needs some extra care.
        V.push_back({ p001, p001, glm::vec2(0.125f, 1.f) });
      }
    }
 
    // triangulate grid samples
    uint32_t k = 0;
    for (uint32_t j = 0; j < samples; j++) {
      for (uint32_t i = 0; i < samples - j; i++) {
        I.push_back(j + k);
        I.push_back(j + k + samples - j + 1);
        I.push_back(j + k + 1);
        if (i < samples - j - 1) {
          I.push_back(j + k + samples - j + 1);
          I.push_back(j + k + samples - j + 2);
          I.push_back(j + k + 1);
        }
        k++;
      }
    }
  }
 
  /*
  Creates a transformed copy of the mesh in V_t/I_t and pushes it into V/I
  */
  void sphereFactoryCloneOctant(std::vector<PositionNormalTexVertex>& V,
                                std::vector<uint32_t>& I, 
                                const std::vector<PositionNormalTexVertex>& V_t,
                                const std::vector<uint32_t>& I_t,
                                const glm::vec3& P100,
                                const glm::vec3& P010,
                                const glm::vec3& P001,
                                const glm::vec2& transform_u,
                                const glm::vec2& transform_v,
                                uint32_t samples)
  {
    uint32_t offset = uint32_t(V.size());
    int Vn = ((samples + 1)*(samples + 2)) / 2;
    for (int i = 0; i < Vn; i++) {
      glm::vec3 pw = V_t[i].position;
      glm::vec3 p = P001 * pw.x + P010*pw.y + P100*pw.z;
      glm::vec2 tw = V_t[i].tex;
      glm::vec2 t = glm::vec2(transform_u.x*tw.x + transform_u.y,
        transform_v.x*tw.y + transform_v.y);
      V.push_back({ p, p, t });
    }
 
    int In = ((3 * samples*(samples + 1)) / 2 + (3 * (samples - 1)*samples) / 2);
    for (int i = 0; i < In; i++) {
      I.push_back(offset + I_t[i]);
    }
  }
 
  template<ShapeType subtype>
  void sphereGeoTexSphFactory(Mesh * m, const ShapeDefinition & definition, int kRefinementLevels, int kMaxSamples)
  {
    int n = (samplesFromLevel(definition.refinement, kRefinementLevels, kMaxSamples) + 3) / 4;
 
    std::vector<PositionNormalTexVertex> V_t;
    V_t.reserve(((n + 1)*(n + 2)) / 2);
 
    std::vector<uint32_t> I_t;
    I_t.reserve(((3 * n*(n + 1)) / 2 + (3 * (n - 1)*n) / 2));
 
    //FIXME: a bit wasteful to create the "template" separately, but it was easier to get scaling correct like this.
    //We could consider caching the templates for the most recently used n values for efficency
    sphereFactoryHelper<subtype>(V_t, I_t, glm::vec3(0.f, 0.f, 1), glm::vec3(0.f, 1, 0.f), glm::vec3(1, 0.f, 0.f), n);
 
    std::vector<PositionNormalTexVertex> V;
    V.reserve(8 * ((n + 1)*(n + 2)) / 2);
 
    std::vector<uint32_t> I;
    I.reserve(8 * ((3 * n*(n + 1)) / 2 + (3 * (n - 1)*n) / 2));
 
    //Uses X dimension for radius, ignores Y and Z
    //I feel like "spheroid" would be a better name if we were to allow non-uniform sizing - wiesener
    auto & r = definition.size.x;
 
    sphereFactoryCloneOctant(V, I, V_t, I_t, glm::vec3(0.f, 0.f,  r), glm::vec3(  r, 0.f, 0.f), glm::vec3(0.f,  -r, 0.f), glm::vec2( 1.f, 0.25f), glm::vec2( 1.f, 0.f), n);
    sphereFactoryCloneOctant(V, I, V_t, I_t, glm::vec3(0.f, 0.f,  r), glm::vec3(0.f,  -r, 0.f), glm::vec3( -r, 0.f, 0.f), glm::vec2( 1.f, 0.50f), glm::vec2( 1.f, 0.f), n);
    sphereFactoryCloneOctant(V, I, V_t, I_t, glm::vec3(0.f, 0.f,  r), glm::vec3( -r, 0.f, 0.f), glm::vec3(0.f,   r, 0.f), glm::vec2( 1.f, 0.75f), glm::vec2( 1.f, 0.f), n);
    sphereFactoryCloneOctant(V, I, V_t, I_t, glm::vec3(0.f, 0.f,  r), glm::vec3(0.f,   r, 0.f), glm::vec3(  r, 0.f, 0.f), glm::vec2( 1.f, 0.0f ), glm::vec2( 1.f, 0.f), n);
 
    sphereFactoryCloneOctant(V, I, V_t, I_t, glm::vec3(0.f, 0.f, -r), glm::vec3(  r, 0.f, 0.f), glm::vec3(0.f,   r, 0.f), glm::vec2(-1.f, 0.25f), glm::vec2(-1.f, 1.0f), n);
    sphereFactoryCloneOctant(V, I, V_t, I_t, glm::vec3(0.f, 0.f, -r), glm::vec3(0.f,  -r, 0.f), glm::vec3(  r, 0.f, 0.f), glm::vec2(-1.f, 0.50f), glm::vec2(-1.f, 1.0f), n);
    sphereFactoryCloneOctant(V, I, V_t, I_t, glm::vec3(0.f, 0.f, -r), glm::vec3( -r, 0.f, 0.f), glm::vec3(0.f,  -r, 0.f), glm::vec2(-1.f, 0.75f), glm::vec2(-1.f, 1.0f), n);
    sphereFactoryCloneOctant(V, I, V_t, I_t, glm::vec3(0.f, 0.f, -r), glm::vec3(0.f,   r, 0.f), glm::vec3( -r, 0.f, 0.f), glm::vec2(-1.f, 1.0f ), glm::vec2(-1.f, 1.0f), n);
 
    m->setVertexData(V.data(), V.size());
    m->setIndexData(I.data(), I.size());
    m->setBounds(computeBoundingBoxFromVertexFormat(V.begin(), V.end()));
  }
}