controllerBuilder.h

Go to the documentation of this file.

//
// Copyright 2026 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_EXEC_EXEC_IR_CONTROLLER_BUILDER_H
#define PXR_EXEC_EXEC_IR_CONTROLLER_BUILDER_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/execIr/tokens.h"
#include "pxr/exec/execIr/types.h"
 
#include "pxr/exec/exec/builtinComputations.h"
#include "pxr/exec/exec/computationBuilders.h"
#include "pxr/exec/vdf/executionTypeRegistry.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
class ExecIrControllerBuilder {
public:
 
    using Callback = ExecIrResult(*)(const VdfContext &);
 
    EXECIR_API
    ExecIrControllerBuilder(
        ExecComputationBuilder &self,
        Callback forwardCallback,
        Callback inverseCallback);
 
    template <typename ValueType>
    void
    InvertibleInputAttribute(
        const TfToken &attributeName);
 
    template <typename ValueType>
    void
    NonInvertibleInputAttribute(
        const TfToken &attributeName);
 
    template <typename ValueType>
    void
    InvertibleOutputAttribute(
        const TfToken &attributeName);
 
    template <typename ValueType>
    void
    SwitchAttribute(
        const TfToken &attributeName);
 
    template <typename ValueType>
    void
    PassthroughAttribute(
        const TfToken &attributeName);
 
private:
    // Returns a private token used to name constant inputs.
    EXECIR_API
    static const TfToken &_GetConstantInputName();
 
private:
    ExecComputationBuilder &_self;
    ExecPrimComputationBuilder _forwardComputeReg;
    ExecPrimComputationBuilder _inverseComputeReg;
};
 
template <typename ValueType>
void
ExecIrControllerBuilder::InvertibleInputAttribute(
    const TfToken &attributeName)
{
    using namespace exec_registration;
 
    // All input attributes (invertible or not) are inputs to the forward
    // computation.
    _forwardComputeReg.Inputs(AttributeValue<ValueType>(attributeName));
}
 
template <typename ValueType>
void
ExecIrControllerBuilder::NonInvertibleInputAttribute(
    const TfToken &attributeName)
{
    using namespace exec_registration;
 
    // All input attributes (invertible or not) are inputs to the forward
    // computation.
    _forwardComputeReg.Inputs(AttributeValue<ValueType>(attributeName));
 
    // Non-invertible input attributes are inputs to the inverse computation.
    _inverseComputeReg.Inputs(AttributeValue<ValueType>(attributeName));
}
 
template <typename ValueType>
void
ExecIrControllerBuilder::InvertibleOutputAttribute(
    const TfToken &attributeName)
{
    using namespace exec_registration;
 
    // All outputs (invertible or not) are inputs to the inverse computation.
    //
    // TODO: We pull on the resolved value because otherwise, for invertible
    // outputs, we get the computed value from the forward computation. But what
    // we really want here is the "desired value," i.e., the value the inversion
    // is trying to satisfy. For now, we use the authored value as the way the
    // desired value is specified.
    _inverseComputeReg.Inputs(
        Attribute(attributeName)
        .Computation<ValueType>(ExecBuiltinComputations->computeResolvedValue)
        .InputName(attributeName));
 
    // Register an expression on the invertible output that pulls its value
    // from the forward computation result map.
    _self.AttributeExpression(attributeName)
        .Callback(+[](const VdfContext &ctx) -> ValueType {
            const TfToken &attributeName =
                ctx.GetInputValue<TfToken>(_GetConstantInputName());
            const ExecIrResult &resultMap =
                ctx.GetInputValue<ExecIrResult>(ExecIrTokens->forwardCompute);
            const auto it = resultMap.find(attributeName);
            if (it != resultMap.end()) {
                return it->second.Get<ValueType>();
            }
 
            TF_CODING_ERROR(
                "Failed to find a result value for output attribute '%s' "
                "when computing %s",
                attributeName.GetText(),
                ctx.GetNodeDebugName().c_str());
            return VdfExecutionTypeRegistry::GetInstance()
                .GetFallback<ValueType>();
        })
        .Inputs(
            Prim().Computation<ExecIrResult>(ExecIrTokens->forwardCompute),
            Constant(attributeName).InputName(_GetConstantInputName()));
}
 
template <typename ValueType>
void
ExecIrControllerBuilder::SwitchAttribute(
    const TfToken &attributeName)
{
    using namespace exec_registration;
 
    // Switch attributes are inputs to the forward and inverse computations.
    _forwardComputeReg.Inputs(AttributeValue<ValueType>(attributeName));
    _inverseComputeReg.Inputs(AttributeValue<ValueType>(attributeName));
}
 
template <typename ValueType>
void
ExecIrControllerBuilder::PassthroughAttribute(
    const TfToken &attributeName)
{
    using namespace exec_registration;
 
    // Passthrough attributes are inputs to the forward and inverse
    // computations.
    _forwardComputeReg.Inputs(AttributeValue<ValueType>(attributeName));
    _inverseComputeReg.Inputs(AttributeValue<ValueType>(attributeName));
}
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif