rprim.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_RPRIM_H
#define PXR_IMAGING_HD_RPRIM_H

#include "pxr/pxr.h"
#include "pxr/imaging/hd/api.h"
#include "pxr/imaging/hd/version.h"
#include "pxr/imaging/hd/changeTracker.h"
#include "pxr/imaging/hd/drawItem.h"
#include "pxr/imaging/hd/rprimSharedData.h"
#include "pxr/imaging/hd/repr.h"
#include "pxr/imaging/hd/sceneDelegate.h"
#include "pxr/imaging/hd/types.h"
#include "pxr/usd/sdf/path.h"
#include "pxr/base/gf/range3d.h"
#include "pxr/base/arch/inttypes.h"

#include <memory>
#include <vector>

PXR_NAMESPACE_OPEN_SCOPE


class HdBufferSource;
class HdDrawItem;
class HdMaterial;
class HdRenderIndex;
class HdRenderParam;

using HdReprSharedPtr = std::shared_ptr<HdRepr>;

using HdBufferSourceSharedPtr = std::shared_ptr<HdBufferSource>;
using HdBufferSourceSharedPtrVector = std::vector<HdBufferSourceSharedPtr>;

using HdBufferSpecVector = std::vector<struct HdBufferSpec>;
using HdBufferArrayRangeSharedPtr = std::shared_ptr<HdBufferArrayRange>;

using HdComputationSharedPtr = std::shared_ptr<class HdComputation>;
using HdComputationSharedPtrVector = std::vector<HdComputationSharedPtr>;

class HdRprim {
public:
    HD_API
    HdRprim(SdfPath const& id);

    HD_API
    virtual ~HdRprim();

    // ---------------------------------------------------------------------- //
    // ---------------------------------------------------------------------- //

    virtual HdDirtyBits GetInitialDirtyBitsMask() const = 0;

    HD_API
    bool CanSkipDirtyBitPropagationAndSync(HdDirtyBits bits) const;

    HD_API
    HdDirtyBits PropagateRprimDirtyBits(HdDirtyBits bits);

    HD_API
    void InitRepr(HdSceneDelegate* delegate,
                  TfToken const &reprToken,
                  HdDirtyBits *dirtyBits);

    virtual void Sync(HdSceneDelegate *delegate,
                      HdRenderParam   *renderParam,
                      HdDirtyBits     *dirtyBits,
                      TfToken const   &reprToken) = 0;
    // ---------------------------------------------------------------------- //
    // ---------------------------------------------------------------------- //

    HD_API
    const HdRepr::DrawItemUniquePtrVector &
    GetDrawItems(TfToken const& reprToken) const;

    // ---------------------------------------------------------------------- //
    // ---------------------------------------------------------------------- //
    HD_API
    virtual void Finalize(HdRenderParam *renderParam);

    // ---------------------------------------------------------------------- //
    // ---------------------------------------------------------------------- //

    SdfPath const& GetId() const { return _sharedData.rprimID; }

    int32_t GetPrimId() const { return _primId; };

    HD_API
    void SetPrimId(int32_t primId);

    SdfPath const& GetInstancerId() const { return _instancerId; }

    SdfPath const& GetMaterialId() const { return _materialId; }

    HD_API
    void SetMaterialId(SdfPath const& materialId);

    TfToken const& GetMaterialTag() const { return _sharedData.materialTag; }

    HD_API
    void SetMaterialTag(TfToken const& materialTag);

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

    inline  TfToken GetRenderTag(HdSceneDelegate* delegate) const;

    inline GfRange3d GetExtent(HdSceneDelegate* delegate) const;

    inline HdPrimvarDescriptorVector
    GetPrimvarDescriptors(HdSceneDelegate* delegate,
                          HdInterpolation interpolation) const;

    HD_API
    virtual TfTokenVector const & GetBuiltinPrimvarNames() const = 0;

    inline VtValue
    GetPrimvar(HdSceneDelegate* delegate, const TfToken &name) const;

    inline VtValue
    GetIndexedPrimvar(HdSceneDelegate* delegate, const TfToken &name, 
                      VtIntArray *indices) const;

    HD_API
    VtMatrix4dArray GetInstancerTransforms(HdSceneDelegate* delegate);

    HD_API
    bool IsDirty(HdChangeTracker &changeTracker) const;

    bool IsVisible() const { return _sharedData.visible; }

    HD_API
    void UpdateReprSelector(HdSceneDelegate* delegate,
                            HdDirtyBits *dirtyBits);

protected:
    // ---------------------------------------------------------------------- //
    // ---------------------------------------------------------------------- //

    virtual HdDirtyBits _PropagateDirtyBits(HdDirtyBits bits) const = 0;

       virtual void _InitRepr(TfToken const &reprToken,
                              HdDirtyBits *dirtyBits) = 0;

    // ---------------------------------------------------------------------- //
    // ---------------------------------------------------------------------- //
    HD_API
    HdReprSharedPtr const & _GetRepr(TfToken const &reprToken) const;

    HD_API
    void _UpdateVisibility(HdSceneDelegate *sceneDelegate,
                           HdDirtyBits *dirtyBits);

    HD_API
    void _UpdateInstancer(HdSceneDelegate *sceneDelegate,
                          HdDirtyBits *dirtyBits);

private:
    SdfPath _instancerId;
    SdfPath _materialId;

    // Used for id renders.
    int32_t _primId;

protected:
    // shared data across reprs: bufferArrayRanges, bounds, visibility
    HdRprimSharedData _sharedData;

    // authored repr selector
    HdReprSelector _authoredReprSelector;

    // total number of reprs is relatively small (less than 5 or so
    // in most case), we use linear container for efficiency.
    typedef std::vector<std::pair<TfToken, HdReprSharedPtr> >
        _ReprVector;
    _ReprVector _reprs;

     struct _ReprComparator {
        _ReprComparator(TfToken const &name) : _name(name) {}
        bool operator() (const std::pair<TfToken, HdReprSharedPtr> &e) const {
            return _name == e.first;
        }
    private:
        TfToken _name;
    };


    // Repr configuration descriptors. All concrete types (HdMesh, HdPoints ..)
    // have this static map to lookup descriptors for the given reprToken.
    //
    // N : # of descriptors for the repr.
    //
    template<typename DESC_TYPE, int N=1>
    struct _ReprDescConfigs {
        typedef std::array<DESC_TYPE, N> DescArray;
        static const int MAX_DESCS = N;

        DescArray Find(TfToken const &reprToken) const {
            // linear search, we expect only a handful reprs configured.
            TF_FOR_ALL (it, _configs) {
                if (it->first == reprToken) return it->second;
            }
            TF_CODING_ERROR("Repr %s not found", reprToken.GetText());
            return DescArray();
        }
        void AddOrUpdate(TfToken const &reprToken, DescArray descs) {
            for (auto& config : _configs) {
                if (config.first == reprToken) {
                    // Overrwrite the existing entry.
                    config.second = descs;
                    return;
                }
            }
            _configs.push_back(std::make_pair(reprToken, descs));
        }
        std::vector<std::pair<TfToken, DescArray> > _configs;
    };

};

//
// Delegate API Wrappers
//
TfToken
HdRprim::GetRenderTag(HdSceneDelegate* delegate) const
{
    return delegate->GetRenderTag(GetId());
}

GfRange3d
HdRprim::GetExtent(HdSceneDelegate* delegate) const
{
    return delegate->GetExtent(GetId());
}

inline HdPrimvarDescriptorVector
HdRprim::GetPrimvarDescriptors(HdSceneDelegate* delegate,
                               HdInterpolation interpolation) const
{
    return delegate->GetPrimvarDescriptors(GetId(), interpolation);
}

inline VtValue
HdRprim::GetPrimvar(HdSceneDelegate* delegate, const TfToken &name) const
{
    return delegate->Get(GetId(), name);
}

inline VtValue
HdRprim::GetIndexedPrimvar(HdSceneDelegate* delegate, const TfToken &name, 
                           VtIntArray *indices) const
{
    return delegate->GetIndexedPrimvar(GetId(), name, indices);
}

PXR_NAMESPACE_CLOSE_SCOPE

#endif //PXR_IMAGING_HD_RPRIM_H