mesh.h

// Copyright 2021 The Manifold Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include <cstdint>
#include <type_traits>
#include <vector>
 
#include "manifold/common.h"
 
namespace manifold {


// MeshGLP / MeshGL / MeshGL64 are forward-declared in common.h; the
// default `I = uint32_t` lives on the forward decl.
template <typename Precision, typename I>
struct MeshGLP {
  I NumVert() const { return vertProperties.size() / numProp; };
  I NumTri() const { return triVerts.size() / 3; };
  I NumRun() const { return runOriginalID.size(); };
  I numProp = 3;
  std::vector<Precision> vertProperties;
  std::vector<I> triVerts;
  std::vector<I> mergeFromVert;
  std::vector<I> mergeToVert;
  std::vector<I> runIndex;
  std::vector<uint32_t> runOriginalID;
  std::vector<Precision> runTransform;
  std::vector<uint8_t> runFlags;
  std::vector<I> faceID;
  std::vector<Precision> halfedgeTangent;
  Precision tolerance = 0;
 
  MeshGLP() = default;

  bool Merge();

  la::vec<Precision, 3> GetVertPos(size_t v) const {
    size_t offset = v * numProp;
    return la::vec<Precision, 3>(vertProperties[offset],
                                 vertProperties[offset + 1],
                                 vertProperties[offset + 2]);
  }

  la::vec<I, 3> GetTriVerts(size_t t) const {
    size_t offset = 3 * t;
    return la::vec<I, 3>(triVerts[offset], triVerts[offset + 1],
                         triVerts[offset + 2]);
  }

  la::vec<Precision, 4> GetTangent(size_t h) const {
    size_t offset = 4 * h;
    return la::vec<Precision, 4>(
        halfedgeTangent[offset], halfedgeTangent[offset + 1],
        halfedgeTangent[offset + 2], halfedgeTangent[offset + 3]);
  }

  mat3x4 GetRunTransform(size_t run) const {
    size_t offset = 12 * run;
    if (offset + 12 > runTransform.size()) {
      return la::identity;
    }
    return mat3x4(la::mat<Precision, 3, 4>(&runTransform[offset]));
  }

  bool Backside(size_t run) const {
    return run < runFlags.size() && (runFlags[run] & 1) != 0;
  }

  bool HasNormals(size_t run) const {
    return run < runFlags.size() && (runFlags[run] & 2) != 0;
  }
};
 
// MeshGL / MeshGL64 aliases live in common.h. Pin the default template
// arg so dropping `I = uint32_t` breaks the build instead of silently
// changing MeshGL's index type.
static_assert(std::is_same<MeshGL, MeshGLP<float, uint32_t>>::value,
              "MeshGL default index type must stay uint32_t");
 
#ifndef MANIFOLD_NO_IOSTREAM
MeshGL64 ReadOBJ(std::istream& stream);
bool WriteOBJ(std::ostream& stream, const MeshGL64& mesh);
#endif
}  // namespace manifold