LoftedCrossSectionsSystemShell.cpp

#include <glm/gtc/type_ptr.hpp>
#include "LoftedCrossSectionsSystem.h"
#define COGS_TABLE_SHELL
#include "LoftedCrossSectionsSystem_tables.h"
 
using glm::vec2;
using glm::vec3;
using glm::dot;
using glm::mix;
using glm::make_vec2;
using glm::make_vec3;
using glm::normalize;
 
using std::abs;
using std::vector;
 
void Cogs::Core::LoftedCrossSectionsSystem::shellInitialize()
{
  shellCellClassCounts.resize(16);
  for (int code = 0; code < 16; code++) {
    CellClassCounts counts = { 0, 0, 0, 0 };
 
    int N = triangle_table_shell[code].n;
    unsigned char* indices = triangle_table_shell[code].indices;
    for (int l = 0; l < N; l++) {
      int ix_a = indices[l] & 0x3;
      int ix_b = (indices[l] >> 4) & 0x3;
      if (ix_a == ix_b) {
        counts.outIndices++;
      }
      else {
        counts.newVertices++;
        counts.outIndices++;
      }
    }
    shellCellClassCounts[code] = counts;
  }
}
 
 
void Cogs::Core::LoftedCrossSectionsSystem::shellOpenAlignedClassifySamples(vector<uint8_t>& inside,
                                                                            const float* pos, const size_t pos_stride,
                                                                            const vector<vec3>& spine,
                                                                            const vec3& viewer,
                                                                            const int slices, const int samples)
{
  inside.resize(slices*samples);
  for (int j = 0; j < slices; j++) {
    for (int i = 0; i < samples; i++) {
      const vec3 p = make_vec3(pos + pos_stride*(j*samples + i));
      inside[j*samples + i] = dot(viewer - p, p - spine[j]) <= 0.0f;
    }
  }
}
 
void Cogs::Core::LoftedCrossSectionsSystem::shellOpenAlignedCountCellResources(size_t& newVertices,
                                                                               size_t& outIndices,
                                                                               vector<uint8_t>& classification,
                                                                               const vector<vec3>& /*spine*/,
                                                                               const vector<uint8_t>& inside,
                                                                               const vec3& /*viewer*/,
                                                                               const int slices, const int samples, const bool doubleSeam)
{
  classification.resize(slices*samples);
  newVertices = 0;
  outIndices = 0;
 
  for (int k = 0; k < slices - 1; k++) {
    for (int i = 0; i < (doubleSeam ? samples - 1 : samples); i++) {
      int ii = (i + 1) % samples;
      uint8_t code = ((inside[(k + 0)*samples + i] ? 1 : 0) |
                  (inside[(k + 0)*samples + ii] ? 2 : 0) |
                  (inside[(k + 1)*samples + i] ? 4 : 0) |
                  (inside[(k + 1)*samples + ii] ? 8 : 0));
 
      classification[k*samples + i] = code;
      const CellClassCounts& counts = shellCellClassCounts[code];
      outIndices += counts.outIndices;
      newVertices += counts.newVertices;
    }
  }
}
 
 
void Cogs::Core::LoftedCrossSectionsSystem::shellOpenAlignedSkin(vector<unsigned int>& outSurface,
                                                                 float* pos, const size_t pos_stride,
                                                                 float* tex, const size_t tex_stride,
                                                                 float* nrm, const size_t nrm_stride,
                                                                 const vector<uint8_t>& classification,
                                                                 const vector<vec3>& spine,
                                                                 const vec3& viewer,
                                                                 const int slices, const int samples, const bool doubleSeam)
{
  unsigned int newVertex = samples * slices;
  unsigned int outIndex = 0;
 
  for (int k = 0; k < slices - 1; k++) {
    for (int i = 0; i < (doubleSeam ? samples - 1 : samples); i++) {
      int ii = (i + 1) % samples;
      int ix[4] = {
        (k + 0)*samples + i, (k + 0)*samples + ii,
        (k + 1)*samples + i, (k + 1)*samples + ii,
      };
 
      int code = classification[k*samples + i];
      
      int N = triangle_table_shell[code].n;
      unsigned char* indices = triangle_table_shell[code].indices;
      for (int l = 0; l < N; l++) {
        int ix_a = indices[l] & 0x3;
        int ix_b = (indices[l] >> 4) & 0x3;
        if (ix_a == ix_b) {
          outSurface[outIndex++] = ix[ix_a];
        }
        else {
          int a = ix[ix_a];
          int b = ix[ix_b];
          int a_j = k + ((ix_a & 0x2) == 0 ? 0 : 1);
          int b_j = k + ((ix_b & 0x2) == 0 ? 0 : 1);
 
          const vec3 ap = make_vec3(pos + pos_stride*a);
          const vec3 bp = make_vec3(pos + pos_stride*b);
 
          vec3 va = normalize(viewer - ap);
          vec3 vb = normalize(viewer - bp);
          vec3 na = normalize(ap - spine[a_j]);
          vec3 nb = normalize(bp - spine[b_j]);
#if 0
          float fa = std::acos(glm::dot(va, na)) - float(M_PI_2);
          float fb = std::acos(glm::dot(vb, nb)) - float(M_PI_2);
#else
          float fa = dot(va, na);
          float fb = dot(vb, nb);
#endif
          const float t = fa*fb < 0.f ? fa / (fa - fb) : (abs(fa) < abs(fb) ? 0.f : 1.f);
 
          const vec3 p = mix(ap, bp, t);
          *reinterpret_cast<vec3*>(pos + pos_stride*newVertex) = p;
 
          if (tex_stride) {
            const vec2 at = make_vec2(tex + tex_stride*a);
            const vec2 bt = make_vec2(tex + tex_stride*b);
            *reinterpret_cast<vec2*>(tex + tex_stride*newVertex) = mix(at, bt, t);
          }
          if (nrm_stride) {
            const vec3 an = make_vec3(nrm + nrm_stride*a);
            const vec3 bn = make_vec3(nrm + nrm_stride*b);
            *reinterpret_cast<vec3*>(nrm + nrm_stride*newVertex) = mix(an, bn, t);
          }
 
          outSurface[outIndex++] = newVertex++;
        }
      }
    }
  }
}
 
void Cogs::Core::LoftedCrossSectionsSystem::shellOpenCountCellResources(size_t& outIndices,
                                                                        const int slices, const int samples,
                                                                        const bool doubleSeam)
{
  int cN = (samples - (doubleSeam ? 1 : 0)) / 2;
  outIndices = 6 * cN*(slices - 1);
}
 
 
void Cogs::Core::LoftedCrossSectionsSystem::shellOpenSkin(vector<unsigned int>& outSurface,
                                                          const int slices,
                                                          const int samples,
                                                          const bool doubleSeam)
{
  int cN = (samples - (doubleSeam ? 1 : 0)) / 2;
  unsigned int outIndex = 0;
  for (int k = 0; k < slices - 1; k++) {
    for (int i = 0; i < cN; i++) {
      int ii = (i + 1) % samples;
 
      outSurface[outIndex++] = (k + 0)*samples + i;   // Outer skin triangle 1
      outSurface[outIndex++] = (k + 0)*samples + ii;
      outSurface[outIndex++] = (k + 1)*samples + i;
 
      outSurface[outIndex++] = (k + 1)*samples + ii;  // Outer skin triangle 2
      outSurface[outIndex++] = (k + 1)*samples + i;
      outSurface[outIndex++] = (k + 0)*samples + ii;
    }
  }
}
 
void Cogs::Core::LoftedCrossSectionsSystem::shellClosedCountCellResources(size_t& outIndices,
                                                                        const int slices, const int samples,
                                                                        const bool doubleSeam)
{
  int cN = (samples - (doubleSeam ? 1 : 0));
  outIndices = 6 * cN*(slices - 1);
}
 
 
void Cogs::Core::LoftedCrossSectionsSystem::shellClosedSkin(vector<unsigned int>& outSurface,
                                                            const int slices,
                                                            const int samples,
                                                            const bool doubleSeam)
{
  int cN = (samples - (doubleSeam ? 1 : 0));
  unsigned int outIndex = 0;
  for (int k = 0; k < slices - 1; k++) {
    for (int i = 0; i < cN; i++) {
      int ii = (i + 1) % samples;
 
      outSurface[outIndex++] = (k + 0)*samples + i;   // Outer skin triangle 1
      outSurface[outIndex++] = (k + 0)*samples + ii;
      outSurface[outIndex++] = (k + 1)*samples + i;
 
      outSurface[outIndex++] = (k + 1)*samples + ii;  // Outer skin triangle 2
      outSurface[outIndex++] = (k + 1)*samples + i;
      outSurface[outIndex++] = (k + 0)*samples + ii;
    }
  }
}