meshTopologyValidation.h

//
// Copyright 2020 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
 
 
#ifndef PXR_IMAGING_PX_OSD_MESH_TOPOLOGY_VALIDATION_H
#define PXR_IMAGING_PX_OSD_MESH_TOPOLOGY_VALIDATION_H
 
#include "pxr/imaging/pxOsd/tokens.h"
 
#include <array>
#include <memory>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class PxOsdMeshTopology;
 
class PxOsdMeshTopologyValidation {
public:
    friend class PxOsdMeshTopology;
    enum class Code {
        InvalidScheme,
        InvalidOrientation,
        InvalidTriangleSubdivision,
        InvalidVertexInterpolationRule,
        InvalidFaceVaryingInterpolationRule,
        InvalidCreaseMethod,
        InvalidCreaseLengthElement,
        InvalidCreaseIndicesSize,
        InvalidCreaseIndicesElement,
        InvalidCreaseWeightsSize,
        NegativeCreaseWeights,
        InvalidCornerIndicesElement,
        NegativeCornerWeights,
        InvalidCornerWeightsSize,
        InvalidHoleIndicesElement,
        InvalidFaceVertexCountsElement,
        InvalidFaceVertexIndicesElement,
        InvalidFaceVertexIndicesSize,
    };
    struct Invalidation {
        Code code;
        std::string message;
    };
private:
    // TODO: In C++17, this class is uncessary and should be replaced with
    // std::optional<std::vector<Invalidation>>
    class _OptionalInvalidationVector {
        std::unique_ptr<std::vector<Invalidation>> _value;
 
    public:
        _OptionalInvalidationVector() = default;
        _OptionalInvalidationVector(_OptionalInvalidationVector&&) = default;
        _OptionalInvalidationVector& operator=(_OptionalInvalidationVector&&) =
            default;
        _OptionalInvalidationVector(_OptionalInvalidationVector const& other)
            : _value(nullptr) {
            if (other._value) {
                _value.reset(new std::vector<Invalidation>(*other._value));
            }
        }
        _OptionalInvalidationVector& operator=(
            _OptionalInvalidationVector const& other) {
            _value = nullptr;
            if (other._value) {
                _value.reset(new std::vector<Invalidation>(*other._value));
            }
            return *this;
        }
        void emplace() { _value.reset(new std::vector<Invalidation>); }
        explicit operator bool() const { return _value != nullptr; }
        std::vector<Invalidation>& value() {
            TF_DEV_AXIOM(*this);
            return *_value;
        }
        std::vector<Invalidation> const& value() const {
            TF_DEV_AXIOM(*this);
            return *_value;
        }
    };
 
    _OptionalInvalidationVector _invalidations;
    template <size_t S>
    void _ValidateToken(PxOsdMeshTopologyValidation::Code code,
                        const char* name, const TfToken& token,
                        const std::array<TfToken, S>& validTokens);
    void _AppendInvalidation(const Invalidation& invalidation) {
        if (!_invalidations) {
            _invalidations.emplace();
        }
        _invalidations.value().push_back(invalidation);
    }
    PxOsdMeshTopologyValidation(PxOsdMeshTopology const&);
 
public:
    PxOsdMeshTopologyValidation() = default;
    PxOsdMeshTopologyValidation(PxOsdMeshTopologyValidation&&) = default;
    PxOsdMeshTopologyValidation& operator=(PxOsdMeshTopologyValidation&&) =
        default;
    PxOsdMeshTopologyValidation(PxOsdMeshTopologyValidation const& other) =
        default;
    PxOsdMeshTopologyValidation& operator=(
        PxOsdMeshTopologyValidation const& other) = default;
 
    explicit operator bool() const {
        return !_invalidations || _invalidations.value().empty();
    }
 
    using iterator = std::vector<Invalidation>::const_iterator;
    using const_iterator = std::vector<Invalidation>::const_iterator;
 
    const_iterator begin() const {
        return _invalidations ? _invalidations.value().cbegin()
                              : const_iterator();
    }
    const_iterator end() const {
        return _invalidations ? _invalidations.value().cend()
                              : const_iterator();
    }
 
    const_iterator cbegin() const {
        return _invalidations ? _invalidations.value().cbegin()
                              : const_iterator();
    }
    const_iterator cend() const {
        return _invalidations ? _invalidations.value().cend()
                              : const_iterator();
    }
private:
    void _ValidateScheme(PxOsdMeshTopology const&);
    void _ValidateOrientation(PxOsdMeshTopology const&);
    void _ValidateTriangleSubdivision(PxOsdMeshTopology const&);
    void _ValidateVertexInterpolation(PxOsdMeshTopology const&);
    void _ValidateFaceVaryingInterpolation(PxOsdMeshTopology const&);
    void _ValidateCreaseMethod(PxOsdMeshTopology const&);
    void _ValidateCreasesAndCorners(PxOsdMeshTopology const&);
    void _ValidateHoles(PxOsdMeshTopology const&);
    void _ValidateFaceVertexCounts(PxOsdMeshTopology const&);
    void _ValidateFaceVertexIndices(PxOsdMeshTopology const&);
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif