rprimCollection.h

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_IMAGING_HD_RPRIM_COLLECTION_H
#define PXR_IMAGING_HD_RPRIM_COLLECTION_H

#include "pxr/pxr.h"
#include "pxr/imaging/hd/api.h"
#include "pxr/imaging/hd/version.h"
#include "pxr/imaging/hd/repr.h"
#include "pxr/usd/sdf/path.h"
#include "pxr/base/tf/token.h"

#include <string>

PXR_NAMESPACE_OPEN_SCOPE


class HdRprimCollection {
public:
    HD_API
    HdRprimCollection();

    HD_API
    HdRprimCollection(TfToken const& name,
                      HdReprSelector const& reprSelector,
                      bool forcedRepr=false,
                      TfToken const& materialTag = TfToken());

    HD_API
    HdRprimCollection(TfToken const& name,
                      HdReprSelector const& reprSelector,
                      SdfPath const& rootPath,
                      bool forcedRepr=false,
                      TfToken const& materialTag = TfToken());

    HD_API
    HdRprimCollection(HdRprimCollection const& col);

    // Destructor.
    HD_API
    virtual ~HdRprimCollection();

    HD_API
    HdRprimCollection CreateInverseCollection() const;

    TfToken const& GetName() const {
        return _name;
    }

    void SetName(TfToken const& name) {
        _name = name;
    }

    HdReprSelector const& GetReprSelector() const {
        return _reprSelector;
    }

    void SetReprSelector(HdReprSelector const& reprSelector) {
        _reprSelector = reprSelector;
    }

    bool IsForcedRepr() const {
        return _forcedRepr;
    }

    void SetForcedRepr(bool flag) {
        _forcedRepr = flag;
    }

    HD_API
    SdfPathVector const& GetRootPaths() const;

    HD_API
    void SetRootPaths(SdfPathVector const& rootPaths);

    HD_API
    void SetRootPath(SdfPath const& rootPath);

    HD_API
    void SetExcludePaths(SdfPathVector const& excludePaths);

    HD_API
    SdfPathVector const& GetExcludePaths() const;

    HD_API
    void SetMaterialTag(TfToken const& tag);

    HD_API
    TfToken const& GetMaterialTag() const;

    HD_API
    size_t ComputeHash() const;

    struct Hash {
        size_t operator()(HdRprimCollection const& value) const {
            return value.ComputeHash();
        }
    };

    // TfHash support.
    template <class HashState>
    friend void TfHashAppend(HashState &h, HdRprimCollection const &rc) {
        h.Append(rc._name,
                 rc._reprSelector,
                 rc._forcedRepr,
                 rc._rootPaths,
                 rc._excludePaths,
                 rc._materialTag);
    }

    HD_API
    bool operator==(HdRprimCollection const & lhs) const;
    HD_API
    bool operator!=(HdRprimCollection const & lhs) const;

private:
    HD_API
    friend std::ostream & operator <<(std::ostream &out, 
        HdRprimCollection const & v);

    TfToken _name;
    HdReprSelector _reprSelector;
    bool _forcedRepr;
    TfToken _materialTag;
    SdfPathVector _rootPaths;
    SdfPathVector _excludePaths;
};

// VtValue requirements
HD_API
std::ostream& operator<<(std::ostream& out, HdRprimCollection const & v);

// Overload hash_value for HdRprimCollection.  Used by things like boost::hash.
HD_API
size_t hash_value(HdRprimCollection const &col);


PXR_NAMESPACE_CLOSE_SCOPE

#endif //PXR_IMAGING_HD_RPRIM_COLLECTION_H