inputValuesPointer.h

Go to the documentation of this file.

//
// Copyright 2025 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_EXEC_VDF_INPUT_VALUES_POINTER_H
#define PXR_EXEC_VDF_INPUT_VALUES_POINTER_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/vdf/context.h"
#include "pxr/exec/vdf/iterator.h"
#include "pxr/exec/vdf/readIterator.h"
 
#include "pxr/base/tf/span.h"
#include "pxr/base/trace/trace.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
template < typename T >
class VdfInputValuesPointer : public VdfIterator
{
public:
 
    VdfInputValuesPointer(const VdfContext &context, const TfToken &inputName);
 
    ~VdfInputValuesPointer();
 
    const T *GetData() const {
        return _data;
    }
 
    size_t GetSize() const {
        return _size;
    }
 
    operator TfSpan<const T>() const {
        return TfSpan<const T>(GetData(), GetSize());
    }
 
private:
 
    // Noncopyable
    VdfInputValuesPointer(const VdfInputValuesPointer &) = delete;
    VdfInputValuesPointer &operator=(const VdfInputValuesPointer &) = delete;
 
    // Make a copy of the input values.
    void _CopyInputValues(const VdfContext &context, const TfToken &inputName);
 
    // A raw pointer to the data.
    const T *_data;
 
    // The number of elements in data.
    size_t _size;
 
    // Is this a copy of the data?
    bool _isCopy;
 
};
 
 
template < typename T >
VdfInputValuesPointer<T>::VdfInputValuesPointer(
    const VdfContext &context,
    const TfToken &inputName) :
    _data(nullptr),
    _size(0),
    _isCopy(false)
{
    // Get the requested input.
    const VdfInput * const input = _GetNode(context).GetInput(inputName);
 
    // Bail out if the input is not available or if it has no connections.
    if (!input || input->GetNumConnections() == 0) {
        return;
    }
 
    // If there is only one connection targeting the requested input, and that
    // connection has a contiguous mask, we do not need to make a copy. This
    // is the fast path.
    if (input->GetNumConnections() == 1) {
        const VdfConnection &connection = (*input)[0];
        const VdfMask &mask = connection.GetMask();
 
        // Bail out if the single connection mask is all zeros.
        if (mask.IsAllZeros()) {
            return;
        }
 
        // If the connection mask is contiguous, we can retain a raw pointer to
        // the data stored in the output buffer.
        if (mask.IsContiguous()) {
            if (const VdfVector * const v =
                    _GetInputValue(context, connection, mask)) {
                const VdfVector::ReadAccessor<T> a = v->GetReadAccessor<T>();
 
                // If the VdfVector is empty, we have no data, so don't set the
                // data pointer.
                if (!a.IsEmpty()) {
                    _size = a.IsBoxed() ? a.GetNumValues() : mask.GetNumSet();
                    _data = &a[mask.GetFirstSet()];
                }
            }
            return;
        }
    }
 
    // If we were not able to retain a pointer pointing directly at the output
    // buffer, we need to fall back to making a copy of the input values. This
    // is the slow path.
    _CopyInputValues(context, inputName);
}
 
template < typename T >
void
VdfInputValuesPointer<T>::_CopyInputValues(
    const VdfContext &context,
    const TfToken &inputName)
{
    TRACE_FUNCTION();
 
    // Get a read iterator to the input values.
    VdfReadIterator<T> it(context, inputName);
 
    // Compute the size from the read iterator, and allocate an array large
    // enough to accommodate our copy of the input values.
    _isCopy = true;
    _size = it.ComputeSize();
    T *copy = new T[_size];
 
    // Iterate over the input values and copy them into our array, such that
    // the data is guaranteed to be laid out contiguously in memory.
    for (size_t i = 0; !it.IsAtEnd(); ++i, ++it) {
        copy[i] = *it;
    }
 
    // Assign the pointer to the copy to data.
    _data = copy;
}
 
template < typename T >
VdfInputValuesPointer<T>::~VdfInputValuesPointer()
{
    // If a copy was made during construction, we need to destruct that copy.
    if (_isCopy) {
        delete[] _data;
    }
}
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif