repr.h

//
// Copyright 2016 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_HD_REPR_H
#define PXR_IMAGING_HD_REPR_H

#include "pxr/pxr.h"
#include "pxr/imaging/hd/api.h"
#include "pxr/imaging/hd/drawItem.h"
#include "pxr/imaging/hd/tokens.h"
#include <vector>

PXR_NAMESPACE_OPEN_SCOPE


class HdReprSelector
{
public:
    explicit HdReprSelector()
    : refinedToken()
    , unrefinedToken()
    , pointsToken() { }

    explicit HdReprSelector(TfToken const &token)
    : refinedToken(token)
    , unrefinedToken()
    , pointsToken() { }

    explicit HdReprSelector(
        TfToken const &refined,
        TfToken const &unrefined)
    : refinedToken(refined)
    , unrefinedToken(unrefined)
    , pointsToken() { }

    explicit HdReprSelector(
        TfToken const &refined,
        TfToken const &unrefined,
        TfToken const &points)
    : refinedToken(refined)
    , unrefinedToken(unrefined)
    , pointsToken(points) { }

    static const size_t MAX_TOPOLOGY_REPRS = 3;

    HD_API
    bool Contains(const TfToken &reprToken) const;

    HD_API
    bool IsActiveRepr(size_t topologyIndex) const;

    HD_API
    bool AnyActiveRepr() const;
    
    HD_API
    HdReprSelector CompositeOver(const HdReprSelector &under) const;

    HD_API    
    bool operator==(const HdReprSelector &rhs) const;

    HD_API
    bool operator!=(const HdReprSelector &rhs) const;
    
    HD_API
    bool operator<(const HdReprSelector &rhs) const;
    
    HD_API
    size_t Hash() const;

    HD_API
    char const* GetText() const;

    HD_API
    friend std::ostream &operator <<(std::ostream &stream,
                                     HdReprSelector const& t);
    

    HD_API
    TfToken const &operator[](size_t topologyIndex) const;
    
private:
    // TfHash support.
    template <class HashState>
    friend void
    TfHashAppend(HashState &h, HdReprSelector const &rs) {
        h.Append(rs.refinedToken, rs.unrefinedToken, rs.pointsToken);
    }

    TfToken refinedToken;
    TfToken unrefinedToken;
    TfToken pointsToken;
};


class HdRepr final
{
public:
    using DrawItemUniquePtr = std::unique_ptr<HdDrawItem>;
    using DrawItemUniquePtrVector = std::vector<DrawItemUniquePtr>;

    HD_API
    HdRepr();
    HD_API
    ~HdRepr();

    const DrawItemUniquePtrVector& GetDrawItems() const {
        return _drawItems;
    }

    void AddDrawItem(std::unique_ptr<HdDrawItem> &&item) {
        _drawItems.push_back(std::move(item));
    }

    HdDrawItem* GetDrawItem(size_t index) const {
        return _drawItems[index].get();
    }

private:
    // Noncopyable
    HdRepr(const HdRepr&) = delete;
    HdRepr& operator=(const HdRepr&) = delete;

private:
    DrawItemUniquePtrVector _drawItems;
};


PXR_NAMESPACE_CLOSE_SCOPE

#endif //PXR_IMAGING_HD_REPR_H