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_HEADERS
    #include <lagrange/subdivision/legacy/mesh_subdivision.h>
#endif
 
#include <lagrange/subdivision/api.h>
 
#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;

    std::optional<float> max_chordal_deviation;


    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>
LA_SUBDIVISION_API SurfaceMesh<Scalar, Index> subdivide_mesh(
    const SurfaceMesh<Scalar, Index>& mesh,
    const SubdivisionOptions& options = {});

 
} // namespace lagrange::subdivision