meshTopology.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_IMAGING_PX_OSD_MESH_TOPOLOGY_H
#define PXR_IMAGING_PX_OSD_MESH_TOPOLOGY_H
 
 
#include "pxr/pxr.h"
#include "pxr/imaging/pxOsd/api.h"
#include "pxr/imaging/pxOsd/subdivTags.h"
#include "pxr/imaging/pxOsd/meshTopologyValidation.h"
 
#include "pxr/base/vt/array.h"
#include "pxr/base/vt/value.h"
 
#include "pxr/base/tf/token.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
class PxOsdMeshTopology {
 
public:
 
    typedef uint64_t ID;
 
    PXOSD_API
    PxOsdMeshTopology();
 
    PxOsdMeshTopology& operator=(const PxOsdMeshTopology &) = default;
    PxOsdMeshTopology(const PxOsdMeshTopology &) = default;
    PxOsdMeshTopology(PxOsdMeshTopology&&) = default;
    PxOsdMeshTopology& operator=(PxOsdMeshTopology&&) = default;
    ~PxOsdMeshTopology() = default;
 
    PXOSD_API
    PxOsdMeshTopology(
        TfToken const& scheme,
        TfToken const& orientation,
        VtIntArray const& faceVertexCounts,
        VtIntArray const& faceVertexIndices);
 
    PXOSD_API
    PxOsdMeshTopology(
        TfToken const& scheme,
        TfToken const& orientation,
        VtIntArray const& faceVertexCounts,
        VtIntArray const& faceVertexIndices,
        VtIntArray const& holeIndices);
 
    PXOSD_API
    PxOsdMeshTopology(
        TfToken const& scheme,
        TfToken const& orientation,
        VtIntArray const& faceVertexCounts,
        VtIntArray const& faceVertexIndices,
        VtIntArray const& holeIndices,
        PxOsdSubdivTags const& subdivTags);
 
    PXOSD_API
    PxOsdMeshTopology(
        TfToken const& scheme,
        TfToken const& orientation,
        VtIntArray const& faceVertexCounts,
        VtIntArray const& faceVertexIndices,
        PxOsdSubdivTags const& subdivTags);
 
public:
 
    TfToken const GetScheme() const {
        return _scheme;
    }
 
    VtIntArray const &GetFaceVertexCounts() const {
        return _faceVertexCounts;
    }
 
    VtIntArray const &GetFaceVertexIndices() const {
        return _faceVertexIndices;
    }
 
    TfToken const &GetOrientation() const {
        return _orientation;
    }
 
 
    VtIntArray const &GetHoleIndices() const {
        return _holeIndices;
    }
 
 
 
    PxOsdSubdivTags const & GetSubdivTags() const {
        return _subdivTags;
    }
 
 
    PXOSD_API PxOsdMeshTopology WithScheme(TfToken const& scheme) const {
        return PxOsdMeshTopology(scheme, GetOrientation(),
                                 GetFaceVertexCounts(), GetFaceVertexIndices(),
                                 GetHoleIndices(), GetSubdivTags());
    }
 
    PXOSD_API PxOsdMeshTopology WithSubdivTags(PxOsdSubdivTags const& tags) const {
        return PxOsdMeshTopology(GetScheme(), GetOrientation(),
                                 GetFaceVertexCounts(), GetFaceVertexIndices(),
                                 GetHoleIndices(), tags);
    }
 
    PXOSD_API PxOsdMeshTopology WithHoleIndices(VtIntArray const& holeIndices) const {
        return PxOsdMeshTopology(GetScheme(), GetOrientation(),
                                 GetFaceVertexCounts(), GetFaceVertexIndices(),
                                 holeIndices, GetSubdivTags());
    }
public:
 
    PXOSD_API
    ID ComputeHash() const;
 
    PXOSD_API
    bool operator==(PxOsdMeshTopology const &other) const;
 
    PXOSD_API
    PxOsdMeshTopologyValidation Validate() const;
 
private:
 
    // note: if you're going to add more members, make sure
    // ComputeHash will be updated too.
 
    TfToken _scheme,
            _orientation;
 
    VtIntArray _faceVertexCounts;
    VtIntArray _faceVertexIndices;
    VtIntArray _holeIndices;
 
    PxOsdSubdivTags _subdivTags;
 
    struct _Validated {
        std::atomic<bool> value;
 
        _Validated() : value(false) {}
        _Validated(const _Validated& other) : value(other.value.load()) {}
        _Validated(_Validated&& other) : value(other.value.load()) {
            other.value = false;
        }
        _Validated& operator=(const _Validated& other) {
            value.store(other.value.load());
            return *this;
        }
        _Validated& operator=(_Validated&& other) {
            value.store(other.value.load());
            other.value = false;
            return *this;
        }
    };
 
    // This should NOT be included in the hash
    // This evaluates to true if the topology has been successfully
    // pre-validated. If this is false, the topology is either invalid
    // or it hasn't been validated yet.
    mutable _Validated _validated;
};
 
PXOSD_API
std::ostream& operator << (std::ostream &out, PxOsdMeshTopology const &);
PXOSD_API
bool operator!=(const PxOsdMeshTopology& lhs, const PxOsdMeshTopology& rhs);
 
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_IMAGING_PX_OSD_MESH_TOPOLOGY_H