valueComposeOver.h

//
// Copyright 2025 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
 
#ifndef PXR_BASE_VT_VALUE_COMPOSE_OVER_H
#define PXR_BASE_VT_VALUE_COMPOSE_OVER_H
 
#include "pxr/pxr.h"
 
#include "pxr/base/vt/api.h"
#include "pxr/base/vt/traits.h"
#include "pxr/base/vt/types.h"
#include "pxr/base/vt/value.h"
#include "pxr/base/vt/valueRef.h"
 
#include <optional>
 
PXR_NAMESPACE_OPEN_SCOPE
 
inline bool
VtValueCanComposeOver(VtValueRef val) {
    return val.CanComposeOver();
}
 
VT_API bool
VtValueTypeCanComposeOver(std::type_info const &strongType);
 
VT_API bool
VtValueCanComposeOver(VtValueRef stronger, VtValueRef weaker);
 
VT_API std::optional<VtValue>
VtValueTryComposeOver(VtValueRef stronger, VtValueRef weaker);
 
VT_API VtValue
VtValueComposeOver(VtValueRef stronger, VtValueRef weaker);
 
struct VtBackgroundType {};
inline constexpr VtBackgroundType VtBackground;
 
// Required to store VtBackground in a VtValue.
inline bool
operator==(VtBackgroundType, VtBackgroundType) {
    return true;
}
 
// Private helper implementation.
VT_API void
Vt_RegisterComposeOver(std::type_info const &strongType,
                       std::type_info const &weakType,
                       void (*voidFn)(),
                       VtValue (*over)(VtValueRef, VtValueRef, void (*)()));
 
template <class Ret, class Strong, class Weak>
void
VtRegisterComposeOver(Ret (*fn)(Strong const &, Weak const &))
{
    static_assert(!VtIsKnownValueType<Strong>() || VtIsArrayEdit<Strong>::value,
                  "Unexpected compose-over registration for one of the "
                  "known value types");
    
    static_assert(VtValueTypeCanCompose<Strong>::value,
                  "Use VT_VALUE_TYPE_CAN_COMPOSE or specialize "
                  "VtValueTypeCanCompose<> before registering compose-over "
                  "functionality");
 
    using TypedFn = Ret (*)(Strong const &, Weak const &);
    using VoidFn = void (*)();
    
    VoidFn voidFn = reinterpret_cast<VoidFn>(fn);
    Vt_RegisterComposeOver(
        typeid(Strong), typeid(Weak), voidFn,
        [](VtValueRef strong, VtValueRef weak, void (*vFn)()) {
            TypedFn tFn = reinterpret_cast<TypedFn>(vFn);
            TF_DEV_AXIOM(strong.IsHolding<Strong>());
            TF_DEV_AXIOM(weak.IsHolding<Weak>());
            return VtValue {
                tFn(strong.UncheckedGet<Strong>(), weak.UncheckedGet<Weak>())
            };
        });
}
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_VT_VALUE_COMPOSE_OVER_H