output.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_OUTPUT_H
#define PXR_EXEC_VDF_OUTPUT_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/vdf/api.h"
#include "pxr/exec/vdf/types.h"
 
#include <tbb/spin_mutex.h>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class TfToken;
class VdfInput;
class VdfMask;
class VdfOutputSpec;
 
class VdfOutput
{
public:
 
    VDF_API
    VdfOutput(VdfNode &owner, int specIndex);
 
    VDF_API
    ~VdfOutput();
 
    const VdfConnectionVector &GetConnections() const { return _connections; }
 
    size_t GetNumConnections() const { 
        return _connections.size(); 
    }
 
    const VdfNode &GetNode() const { return _owner; }
 
    VdfNode &GetNode() { return _owner; }
 
    VDF_API
    const TfToken &GetName() const;
 
    VDF_API
    void SetAssociatedInput(const VdfInput *input);
 
    const VdfInput *GetAssociatedInput() const { 
        return _associatedInput; 
    }
 
    const VdfMask *GetAffectsMask() const {
        return _affectsMask.IsEmpty() ? nullptr : &_affectsMask;
    }
 
    VDF_API
    void SetAffectsMask(const VdfMask &mask);
 
    VdfId GetId() const {
        return _id;
    }
 
    static VdfIndex GetIndexFromId(const VdfId id) {
        return static_cast<VdfIndex>(id);
    }
 
    static VdfVersion GetVersionFromId(const VdfId id) {
        return static_cast<VdfVersion>(id >> 32);
    }
 
    VDF_API
    const VdfOutputSpec &GetSpec() const;
 
    VDF_API
    std::string GetDebugName() const;
 
    VDF_API
    int GetNumDataEntries() const;
 
private:
 
    // Only the VdfNetwork and VdfIsolatedSubnetwork should have access to the
    // connect API.
    friend class VdfNetwork;
    friend class VdfIsolatedSubnetwork;
 
    // Connects \p node's input named \p inputName to this output with a 
    // given \p mask.  If \p atIndex is >= 0 the connection will be placed at
    // index \p atIndex on the target input.  Otherwise the connection will
    // be appended at the end.
    //
    VdfConnection *_Connect(VdfNode *node,
                            const TfToken &inputName,
                            const VdfMask &mask,
                            int atIndex);
 
    void _RemoveConnection(VdfConnection *connection);
 
private:
 
    // The node that owns this output.
    VdfNode &_owner;
 
    // The output id.
    const VdfId _id;
 
    // The input (if any) associated with this output.
    const VdfInput *_associatedInput;
 
    // The list of connections connected to this output.
    VdfConnectionVector _connections;
 
    // The mask indicating the elements that this output is expected to modify
    // from its corresponding input.  For outputs with no corresponding input,
    // the mask will be of size 0.
    VdfMask _affectsMask;
 
    // The index of the connector spec for this output on the owning node.
    int _specIndex;
 
    // Sychronize concurrently connecting to this output.
    tbb::spin_mutex _connectionsMutex;
};
 
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif