primvarDescCache.h

Go to the documentation of this file.

//
// 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_USD_IMAGING_USD_IMAGING_PRIMVARDESC_CACHE_H
#define PXR_USD_IMAGING_USD_IMAGING_PRIMVARDESC_CACHE_H
 
 
#include "pxr/pxr.h"
#include "pxr/usdImaging/usdImaging/api.h"
#include "pxr/imaging/hd/sceneDelegate.h"
 
#include "pxr/usd/sdf/path.h"
 
#include "pxr/base/tf/hash.h"
#include "pxr/base/tf/token.h"
 
#include <tbb/concurrent_unordered_map.h>
#include <tbb/concurrent_queue.h>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class UsdImagingPrimvarDescCache 
{
public:
    UsdImagingPrimvarDescCache(const UsdImagingPrimvarDescCache&) = delete;
    UsdImagingPrimvarDescCache& operator=(const UsdImagingPrimvarDescCache&) 
        = delete;
 
    class Key 
    {
        friend class UsdImagingPrimvarDescCache;
        SdfPath _path;
        TfToken _attribute;
 
     public:
        Key(SdfPath const& path, TfToken const& attr)
            : _path(path)
            , _attribute(attr)
        {}
 
        inline bool operator==(Key const& rhs) const {
            return _path == rhs._path && _attribute == rhs._attribute;
        }
        inline bool operator!=(Key const& rhs) const {
            return !(*this == rhs);
        }
 
        struct Hash {
            inline size_t operator()(Key const& key) const {
                return TfHash::Combine(key._path.GetHash(),
                                       key._attribute.Hash());
            }
        };
 
    private:
        static Key Primvars(SdfPath const& path) {
            static TfToken attr("primvars");
            return Key(path, attr);
        }
    };
 
    UsdImagingPrimvarDescCache()
        : _locked(false)
    { }
 
private:
    template <typename Element>
    struct _TypedCache
    {
        typedef tbb::concurrent_unordered_map<Key, Element, Key::Hash> _MapType;
        typedef typename _MapType::iterator                            _MapIt;
        typedef typename _MapType::const_iterator                      _MapConstIt;
        typedef tbb::concurrent_queue<_MapIt>                          _QueueType;
 
        _MapType   _map;
    };
 
 
    template <typename T>
    bool _Find(Key const& key, T* value) const {
        typedef _TypedCache<T> Cache_t;
 
        Cache_t *cache = nullptr;
 
        _GetCache(&cache);
        typename Cache_t::_MapConstIt it = cache->_map.find(key);
        if (it == cache->_map.end()) {
            return false;
        }
        *value = it->second;
        return true;
    }
 
    template <typename T>
    void _Erase(Key const& key) {
        if (!TF_VERIFY(!_locked)) {
            return;
        }
 
        typedef _TypedCache<T> Cache_t;
 
        Cache_t *cache = nullptr;
        _GetCache(&cache);
        cache->_map.unsafe_erase(key);
    }
 
    template <typename T>
    T& _Get(Key const& key) const {
        typedef _TypedCache<T> Cache_t;
 
        Cache_t *cache = nullptr;
        _GetCache(&cache);
 
        // With concurrent_unordered_map, multi-threaded insertion is safe.
        std::pair<typename Cache_t::_MapIt, bool> res =
                                cache->_map.insert(std::make_pair(key, T()));
 
        return res.first->second;
    }
 
public:
 
    void EnableMutation() { _locked = false; }
    void DisableMutation() { _locked = true; }
 
    void Clear(SdfPath const& path) {
        _Erase<HdPrimvarDescriptorVector>(Key::Primvars(path));
    }
 
    HdPrimvarDescriptorVector& GetPrimvars(SdfPath const& path) const {
        return _Get<HdPrimvarDescriptorVector>(Key::Primvars(path));
    }
 
    bool FindPrimvars(SdfPath const& path, HdPrimvarDescriptorVector* value) const {
        return _Find(Key::Primvars(path), value);
    }
 
private:
    bool _locked;
 
    typedef _TypedCache<HdPrimvarDescriptorVector> _PviCache;
    mutable _PviCache _pviCache;
 
    void _GetCache(_PviCache **cache) const {
        *cache = &_pviCache;
    }
};
 
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_IMAGING_USD_IMAGING_PRIMVARDESC_CACHE_H