dataSource.h

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

#include "pxr/pxr.h"

#include "pxr/imaging/hd/api.h"
#include "pxr/imaging/hd/dataSourceLocator.h"

#include "pxr/base/tf/token.h"
#include "pxr/base/vt/value.h"
#include "pxr/base/vt/visitValue.h"

#include <iosfwd>
#include <memory>
#include <vector>
#include <atomic>

PXR_NAMESPACE_OPEN_SCOPE

template <typename U>
struct HdDataSourceAllocator
{
    using value_type = U;
    template <typename V>
    struct rebind { using other = HdDataSourceAllocator<V>; };
    HdDataSourceAllocator() = default;
    template <typename V>
    HdDataSourceAllocator(const HdDataSourceAllocator<V>&) { }
    U* allocate(size_t n) { return std::allocator<U>{ }.allocate(n); }
    void deallocate(U* p, size_t n)
    { std::allocator<U>{ }.deallocate(p, n); }
    template <typename... Args>
    void construct(U*p, Args&&... args)
    { ::new(static_cast<void*>(p)) U(std::forward<Args>(args)...); }
    void destroy(U* p) { p->~U(); }
};

// XXX: clang is strict about qualified friend declarations, and will not
// forward PXR_NS -> PXR_INTERNAL_NS when present. But PXR_INTERNAL_NS is not
// always defined in all builds, so we can't just use that, either.
#if defined(PXR_INTERNAL_NS)
#define _HD_ALLOCATOR_FRIEND \
    template <typename> friend struct PXR_INTERNAL_NS::HdDataSourceAllocator;
#else
#define _HD_ALLOCATOR_FRIEND \
    template <typename> friend struct PXR_NS::HdDataSourceAllocator;
#endif

#define HD_DECLARE_DATASOURCE_ABSTRACT(type) \
    using Handle =  std::shared_ptr<type>; \
    using AtomicHandle = Handle; \
    static Handle AtomicLoad(AtomicHandle &ptr) { \
        return std::atomic_load(&ptr); \
    } \
    static void AtomicStore(AtomicHandle &ptr, const Handle &v) { \
        std::atomic_store(&ptr, v); \
    } \
    static bool AtomicCompareExchange(AtomicHandle &ptr, \
                                      AtomicHandle &expected, \
                                      const Handle &desired) { \
        return std::atomic_compare_exchange_strong(&ptr, &expected, desired); \
    } \
    static Handle Cast(const HdDataSourceBase::Handle &v) { \
        return std::dynamic_pointer_cast<type>(v); \
    }

#define HD_DECLARE_DATASOURCE(type) \
    HD_DECLARE_DATASOURCE_ABSTRACT(type) \
    _HD_ALLOCATOR_FRIEND \
    template <typename ... Args> \
    static Handle New(Args&& ... args) { \
        return std::allocate_shared<type>( \
            PXR_NS::HdDataSourceAllocator<type>{ }, \
            std::forward<Args>(args)...); \
    }

#define HD_DECLARE_DATASOURCE_INITIALIZER_LIST_NEW(type, T) \
    static Handle New(std::initializer_list<T> initList) { \
        return std::allocate_shared<type>( \
            PXR_NS::HdDataSourceAllocator<type>{ }, \
            (initList)); \
    }

#define HD_DECLARE_DATASOURCE_HANDLES(type) \
    using type##Handle = type::Handle; \
    using type##AtomicHandle = type::AtomicHandle;

class HdDataSourceBase
{
public:
    HD_DECLARE_DATASOURCE_ABSTRACT(HdDataSourceBase)

    HD_API
    virtual ~HdDataSourceBase() = 0;
};

HD_DECLARE_DATASOURCE_HANDLES(HdDataSourceBase);

class HdContainerDataSource : public HdDataSourceBase
{
public:
    HD_DECLARE_DATASOURCE_ABSTRACT(HdContainerDataSource);

    virtual TfTokenVector GetNames() = 0;

    virtual HdDataSourceBaseHandle Get(const TfToken &name) = 0;

    HD_API
    static HdDataSourceBaseHandle Get(
        const Handle &container,
        const HdDataSourceLocator &locator);
};

HD_DECLARE_DATASOURCE_HANDLES(HdContainerDataSource);

class HdVectorDataSource : public HdDataSourceBase
{
public:
    HD_DECLARE_DATASOURCE_ABSTRACT(HdVectorDataSource);

    virtual size_t GetNumElements() = 0;

    virtual HdDataSourceBaseHandle GetElement(size_t element) = 0;
};

HD_DECLARE_DATASOURCE_HANDLES(HdVectorDataSource);

class HdSampledDataSource : public HdDataSourceBase
{
public:
    HD_DECLARE_DATASOURCE_ABSTRACT(HdSampledDataSource);
    using Time = float;

    virtual VtValue GetValue(Time shutterOffset) = 0;

    virtual bool GetContributingSampleTimesForInterval(
        Time startTime,
        Time endTime,
        std::vector<Time> * outSampleTimes) = 0;

protected:
    friend class Hd_SampledDataSourceDefaultValueAccessor;

    HD_API
    virtual VtValue _GetDefaultValue();
};

HD_DECLARE_DATASOURCE_HANDLES(HdSampledDataSource);

template <typename T>
class HdTypedSampledDataSource : public HdSampledDataSource
{
public:
    HD_DECLARE_DATASOURCE_ABSTRACT(HdTypedSampledDataSource<T>);
    using Type = T;

    virtual T GetTypedValue(Time shutterOffset) = 0;

protected:
    virtual VtValue _GetDefaultValue() override {
        if constexpr (VtIsKnownValueType<T>()) {
            return VtValue(T());
        } else {
            return VtValue();
        }
    }
};

class HdBlockDataSource : public HdDataSourceBase
{
public:
    HD_DECLARE_DATASOURCE(HdBlockDataSource);
protected:
    HdBlockDataSource() = default;
};

HD_DECLARE_DATASOURCE_HANDLES(HdBlockDataSource);

// Utilities //////////////////////////////////////////////////////////////////

// Helper to let HdVisitSampledDataSourceType access a source's value type.
class Hd_SampledDataSourceDefaultValueAccessor
{
public:
    static VtValue
    GetDefaultValue(const HdSampledDataSourceHandle &dataSource) {
        return dataSource ? dataSource->_GetDefaultValue() : VtValue {};
    }
};

template <
    template <class T, class ...> class Visitor,
    typename ...TypeArgs,
    typename ...FnArgs
    >
auto
HdVisitSampledDataSourceType(
    const HdSampledDataSourceHandle& dataSource, FnArgs&&... args)
{
    return VtVisitValueType<Visitor, TypeArgs...>(
        Hd_SampledDataSourceDefaultValueAccessor::GetDefaultValue(dataSource),
        std::forward<FnArgs>(args)...);
}

template <
    template <class T, template <class...> class, class ...> class Visitor,
    template <class...> class Tmpl,
    typename ...TypeArgs,
    typename ...FnArgs
    >
auto
HdVisitSampledDataSourceType(
    const HdSampledDataSourceHandle& dataSource, FnArgs&&... args)
{
    return VtVisitValueType<Visitor, Tmpl, TypeArgs...>(
        Hd_SampledDataSourceDefaultValueAccessor::GetDefaultValue(dataSource),
        std::forward<FnArgs>(args)...);
}

template <
    typename T,
    template <typename...> class DataSource,
    class UntypedDataSource>
struct Hd_CopySampledDataSourceTypeVisitor
{
    template <class ...Args>
    static HdDataSourceBaseHandle Visit(Args&&... args)
    {
        if constexpr (std::is_same_v<T, VtValue>) {
            if constexpr (std::is_void_v<UntypedDataSource>) {
                return nullptr;
            }
            else {
                return UntypedDataSource::New(std::forward<Args>(args)...);
            }
        }
        else {
            return DataSource<T>::New(std::forward<Args>(args)...);
        }
    }
};

template <
    template <typename...> class DataSource,
    class UntypedDataSource = void,
    typename... Args>
HdDataSourceBaseHandle
HdCopySampledDataSourceType(
    const HdSampledDataSourceHandle& dataSource, Args&&... args)
{
    return HdVisitSampledDataSourceType<
        Hd_CopySampledDataSourceTypeVisitor, DataSource, UntypedDataSource>(
            dataSource, std::forward<Args>(args)...);
}

HD_API
bool
HdGetMergedContributingSampleTimesForInterval(
    size_t count,
    const HdSampledDataSourceHandle *inputDataSources,
    HdSampledDataSource::Time startTime,
    HdSampledDataSource::Time endTime,
    std::vector<HdSampledDataSource::Time> * outSampleTimes);

HD_API
void
HdDebugPrintDataSource(
    std::ostream &,
    HdDataSourceBaseHandle,
    int indentLevel = 0);

HD_API
void
HdDebugPrintDataSource(HdDataSourceBaseHandle, int indentLevel = 0);

PXR_NAMESPACE_CLOSE_SCOPE

#endif // PXR_IMAGING_HD_DATASOURCE_H