mesh_subdivision.h

/*
 * Copyright 2020 Adobe. All rights reserved.
 * This file is licensed to you 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 REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
 
#pragma once
 
#ifdef LAGRANGE_ENABLE_LEGACY_FUNCTIONS
    #include <lagrange/subdivision/legacy/mesh_subdivision.h>
#endif
 
#include <lagrange/SurfaceMesh.h>
 
#include <optional>
 
namespace lagrange::subdivision {
 
 
enum class SchemeType {
    Bilinear, 
    CatmullClark, 
    Loop, 
};
 
enum class VertexBoundaryInterpolation {
    None,
 
    EdgeOnly,
 
    EdgeAndCorner,
};
 
enum class FaceVaryingInterpolation {
    None, 
    CornersOnly, 
    CornersPlus1, 
    CornersPlus2, 
    Boundaries, 
    All, 
};
 
enum class RefinementType {
    Uniform,
 
    // TODO: Implement these. This involves creating a Far::PatchTable, extracting the subdivided
    // facets, and welding T-junctions...
    // CurvatureAdaptive,
 
    EdgeAdaptive,
};
 
class InterpolatedAttributes
{
public:
    enum class SelectionType { All, None, Selected };
 
public:
    static InterpolatedAttributes all() { return {SelectionType::All, {}, {}}; }
 
    static InterpolatedAttributes none() { return {SelectionType::None, {}, {}}; }
 
    static InterpolatedAttributes selected(
        std::vector<AttributeId> smooth,
        std::vector<AttributeId> linear = {})
    {
        return {SelectionType::Selected, std::move(smooth), std::move(linear)};
    }
 
    void set_all() { *this = all(); }
 
    void set_none() { *this = none(); }
 
    void set_selected(std::vector<AttributeId> smooth, std::vector<AttributeId> linear = {})
    {
        selection_type = SelectionType::Selected;
        smooth_attributes = std::move(smooth);
        linear_attributes = std::move(linear);
    }
 
    // Has to be kept public to use aggregate initialization...
public:
    SelectionType selection_type = SelectionType::All;
 
    std::vector<AttributeId> smooth_attributes;
 
    std::vector<AttributeId> linear_attributes;
};
 
struct SubdivisionOptions
{
 
    std::optional<SchemeType> scheme;
 
    unsigned num_levels = 1;
 
    RefinementType refinement = RefinementType::Uniform;
 
 
    std::optional<float> max_edge_length;
 
 
    VertexBoundaryInterpolation vertex_boundary_interpolation =
        VertexBoundaryInterpolation::EdgeOnly;
 
    FaceVaryingInterpolation face_varying_interpolation = FaceVaryingInterpolation::None;
 
    bool use_limit_surface = false;
 
 
    InterpolatedAttributes interpolated_attributes;
 
    // TODO: Add face-uniform attributes (i.e. per-facet attributes), e.g. material_id.
 
 
    std::optional<AttributeId> edge_sharpness_attr;
 
    std::optional<AttributeId> vertex_sharpness_attr;
 
    std::optional<AttributeId> face_hole_attr;
 
 
    bool preserve_shared_indices = false;
 
    std::string_view output_limit_normals;
 
    std::string_view output_limit_tangents;
 
    std::string_view output_limit_bitangents;
 
 
    bool validate_topology = false;
 
};
 
template <typename Scalar, typename Index>
SurfaceMesh<Scalar, Index> subdivide_mesh(
    const SurfaceMesh<Scalar, Index>& mesh,
    const SubdivisionOptions& options = {});
 
 
} // namespace lagrange::subdivision