bufferSource.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_BUFFER_SOURCE_H
#define PXR_IMAGING_HD_BUFFER_SOURCE_H
 
#include "pxr/pxr.h"
#include "pxr/imaging/hd/api.h"
#include "pxr/imaging/hd/version.h"
#include "pxr/imaging/hd/bufferSpec.h"
#include "pxr/base/tf/diagnostic.h"
#include "pxr/base/tf/token.h"
 
#include <atomic>
#include <memory>
#include <vector>
 
 
PXR_NAMESPACE_OPEN_SCOPE
 
class HdBufferSource;
using HdBufferSourceSharedPtr = std::shared_ptr<HdBufferSource>;
using HdBufferSourceConstSharedPtr = std::shared_ptr<HdBufferSource const>;
using HdBufferSourceSharedPtrVector = std::vector<HdBufferSourceSharedPtr>;
using HdBufferSourceWeakPtr = std::weak_ptr<HdBufferSource>;
 
class HdBufferSource 
{
public:
    HdBufferSource()
        // No need for atomic init since _TryLock() will do the acquire
        : _state(UNRESOLVED)
    {
    }
 
    HD_API
    virtual ~HdBufferSource();
 
    virtual TfToken const &GetName() const = 0;
 
    virtual void GetBufferSpecs(HdBufferSpecVector *specs) const = 0;
 
    HD_API
    virtual size_t ComputeHash() const;
 
    virtual bool Resolve() = 0;
 
 
    virtual void const* GetData() const = 0;
 
    virtual HdTupleType GetTupleType() const = 0;
 
    virtual size_t GetNumElements() const = 0;
 
    bool IsResolved() const {
        return _state.load(std::memory_order_acquire) >= RESOLVED;
    }
 
    bool HasResolveError() const {
        return _state.load(std::memory_order_acquire) == RESOLVE_ERROR;
    }
 
 
    HD_API
    virtual bool HasPreChainedBuffer() const;
 
    HD_API
    virtual HdBufferSourceSharedPtr GetPreChainedBuffer() const;
 
    HD_API
    virtual bool HasChainedBuffer() const;
 
    HD_API
    virtual HdBufferSourceSharedPtrVector GetChainedBuffers() const;
 
 
    HD_API
    bool IsValid() const;
 
protected:
    void _SetResolved() {
        TF_VERIFY(_state.load(std::memory_order_relaxed) == BEING_RESOLVED);
        _state.store(RESOLVED, std::memory_order_release);
    }
 
    void _SetResolveError() {
        TF_VERIFY(_state.load(std::memory_order_relaxed) == BEING_RESOLVED);
        _state.store(RESOLVE_ERROR, std::memory_order_release);
    }
 
    bool _TryLock() {
        State oldState = UNRESOLVED;
        return _state.compare_exchange_strong(oldState, BEING_RESOLVED,
            std::memory_order_acquire);
    }
 
    virtual bool _CheckValid() const = 0;
 
protected:
    enum State { UNRESOLVED=0, BEING_RESOLVED, RESOLVED,  RESOLVE_ERROR};
    HdBufferSource(State state) : _state(state) { }
 
private:
    // Don't allow copies
    HdBufferSource(const HdBufferSource &) = delete;
    HdBufferSource &operator=(const HdBufferSource &) = delete;
 
    std::atomic<State> _state;
};
 
class HdResolvedBufferSource : public HdBufferSource {
public:
    HdResolvedBufferSource() : HdBufferSource(RESOLVED) {}
 
    HD_API
    bool Resolve() override { return true; }
};
 
class HdComputedBufferSource : public HdBufferSource {
public:
    HD_API
    virtual TfToken const &GetName() const override;
    HD_API
    virtual size_t ComputeHash() const override;
    HD_API
    virtual void const* GetData() const override;
    HD_API
    virtual HdTupleType GetTupleType() const override;
    HD_API
    virtual size_t GetNumElements() const override;
 
protected:
    void _SetResult(HdBufferSourceSharedPtr const &result) {
        _result = result;
    }
 
private:
    HdBufferSourceSharedPtr _result;
};
 
class HdNullBufferSource : public HdBufferSource {
public:
    HD_API
    virtual TfToken const &GetName() const override;
    HD_API
    virtual void const* GetData() const override;
    HD_API
    virtual size_t ComputeHash() const override;
    HD_API
    virtual size_t GetNumElements() const override;
    HD_API
    virtual HdTupleType GetTupleType() const override;
    HD_API
    virtual void GetBufferSpecs(HdBufferSpecVector *specs) const override;
};
 
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif //PXR_IMAGING_HD_BUFFER_SOURCE_H