indexedWeightsOperand.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_INDEXED_WEIGHTS_OPERAND_H
#define PXR_EXEC_VDF_INDEXED_WEIGHTS_OPERAND_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/vdf/api.h"
#include "pxr/exec/vdf/indexedWeights.h"
 
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class VdfIndexedWeightsOperand : public VdfIndexedWeights
{
    typedef VdfIndexedWeightsOperand This;
 
public:
    enum SetOperation {
        Union,
        Intersection,
    };
 
    VDF_API
    explicit VdfIndexedWeightsOperand(
        SetOperation setOperation,
        const VdfIndexedWeights *externalWeights = NULL);
 
    VDF_API
    void Swap(VdfIndexedWeights *v);
 
    VDF_API
    void PruneZeros(const std::vector<This> &operands);
 
    VDF_API
    void Fill(
        const std::vector<This> &operands,
        double fillWeight,
        bool nonZeroSetOperation);
 
    VDF_API
    size_t GetNumMathErrors() const;
 
    VDF_API
    void ClearMathErrors();
 
    This operator-() const {
        This w(*this);
        w *= -1.0;
        return w;
    }
 
    This operator+(double s) const {
        This w(*this);
        w += s;
        return w;
    }
 
    This operator-(double s) const {
        This w(*this);
        w -= s;
        return w;
    }
 
    This operator*(double s) const {
        This w(*this);
        w *= s;
        return w;
    }
 
    This operator/(double s) const {
        This w(*this);
        w /= s;
        return w;
    }
 
    This operator+(const This &v) const {
        This w(*this);
        w += v;
        return w;
    }
 
    This operator-(const This &v) const {
        This w(*this);
        w -= v;
        return w;
    }
 
    This operator*(const This &v) const {
        This w(*this);
        w *= v;
        return w;
    }
 
    This operator/(const This &v) const {
        This w(*this);
        w /= v;
        return w;
    }
 
 
    VDF_API This operator<(const This &v) const;
    VDF_API This operator<=(const This &v) const;
    VDF_API This operator>(const This &v) const;
    VDF_API This operator>=(const This &v) const;
    VDF_API This operator==(const This &v) const;
    VDF_API This operator!=(const This &v) const;
    VDF_API This operator<(double x) const;
    VDF_API This operator<=(double x) const;
    VDF_API This operator>(double x) const;
    VDF_API This operator>=(double x) const;
    VDF_API This operator==(double x) const;
    VDF_API This operator!=(double x) const;
 
 
 
    VDF_API This acos() const;
    VDF_API This acosh() const;
    VDF_API This asin() const;
    VDF_API This asinh() const;
    VDF_API This atan() const;
    VDF_API This atanh() const;
    VDF_API This atan2(const This &v) const;
    VDF_API This ceil() const;
    VDF_API This cos() const;
    VDF_API This cosh() const;
    VDF_API This exp() const;
    VDF_API This fabs() const;
    VDF_API This floor() const;
    VDF_API This fmod(float denominator) const;
    VDF_API This log() const;
    VDF_API This log10() const;
    VDF_API This pow(float exponent) const;
    VDF_API This sin() const;
    VDF_API This sinh() const;
    VDF_API This sqrt() const;
    VDF_API This tan() const;
    VDF_API This tanh() const;
 
 
 
    VDF_API
    This min(const This &v) const;
 
    VDF_API
    This max(const This &v) const;
 
    VDF_API
    This min(float min) const;
 
    VDF_API
    This max(float max) const;
 
    VDF_API
    This clamp(float min, float max) const;
 
    VDF_API
    This smoothstep(float min, float max,
        float slope0=0, float slope1=0) const;
 
    VDF_API
    This smoothramp(float min, float max,
        float shoulder0, float shoulder1) const;
 
    VDF_API
    This lerp(const This &v, float a) const;
    
    VDF_API
    This lerp(const This &v, const This &a) const;
 
 
 
    bool HasExternalWeights() const {
        return _externalWeights;
    }
 
 
private:
    // Operators ---------------------------------------------------------------
 
    // These mutating arithmetic-assignment operators are kept private and only
    // used by the public operators to generate a modified copied to return.
 
    // Adds the weights of v to our weights.
    VDF_API
    This &operator+=(const This &v);
 
    // Subtracts the weights of v from our weights.
    VDF_API
    This &operator-=(const This &v);
 
    // Scales our weights by the weights of v.
    VDF_API
    This &operator*=(const This &v);
 
    // Divides our weights by the weights of v.
    VDF_API
    This &operator/=(const This &v);
 
    // Adds a scalar to all our weights.
    VDF_API
    This &operator+=(double s);
 
    // Subtracts a scalar from all our weights.
    VDF_API
    This &operator-=(double s);
 
    // Scales all our weights by a scalar.
    VDF_API
    This &operator*=(double s);
 
    // Divides all our weights by a scalar.
    VDF_API
    This& operator/=(double s);
 
    // Math library implementation helpers -------------------------------------
 
    // Common implementation for math functions.  A new VdfIndexedWeightOperand
    // is returned having a copy of this object's weights, mutated by calling
    // \p modify on each weight.  If template parameter \p CheckForMathErrors
    // is \c true, the result of each call is checked for math errors (as
    // defined above) and the return object is flagged if present.  This check
    // is opt-in due to the potential cost; callers should take great care in
    // the state of this check based on the requirements of \c ModifyFn.
    //
    // \c ModifyFn should have the effective call signature of a unary function
    // of type \c float.
    template <bool CheckForMathErrors, typename ModifyFn>
    This _ApplyFunctionToCopy(ModifyFn modify) const;
 
    // Read/write helpers ------------------------------------------------------
 
    // Makes a local copy of the external weights (that can be modified).
    void _CopyExternalWeights();
 
    // Returns the non-const indices.
    std::vector<int> &_GetWriteIndices() {
        return VdfIndexedWeights::_GetWriteIndices();
    }
 
    // Returns the indices.
    const std::vector<int> &_GetReadIndices() const {
        return _externalWeights
            ? VdfIndexedWeights::_GetReadIndices(_externalWeights)
            : VdfIndexedWeights::_GetReadIndices();
    }
 
    // Returns the non-const data.
    std::vector<float> &_GetWriteData() {
        return VdfIndexedWeights::_GetWriteData();
    }
 
    // Returns the data.
    const std::vector<float> &_GetReadData() const {
        return _externalWeights
            ? VdfIndexedWeights::_GetReadData(_externalWeights)
            : VdfIndexedWeights::_GetReadData();
    }
 
    // Allow access to the free function overloads that can't be implemented
    // in terms of other public operators due to the write semantics of this
    // class or for performance reasons.
    friend VDF_API This operator-(double, const This&);
    friend VDF_API This operator/(double, const This&);
 
private:
    // The set operation to be used for binary operators.
    SetOperation _setOperation;
 
    // The external weights (NULL when we do not have external weights).
    // Note that it is fine to copy this pointer as part of copy construction/
    // assignment since that just means to share the same external weights.
    const VdfIndexedWeights *_externalWeights;
 
    // Flag indicating that there might be math errors (to avoid always having
    // to check all weights).
    bool _mayHaveMathErrors;
};
 
//
VDF_API VdfIndexedWeightsOperand operator+(double, const VdfIndexedWeightsOperand&);
VDF_API VdfIndexedWeightsOperand operator-(double, const VdfIndexedWeightsOperand&);
VDF_API VdfIndexedWeightsOperand operator*(double, const VdfIndexedWeightsOperand&);
VDF_API VdfIndexedWeightsOperand operator/(double, const VdfIndexedWeightsOperand&);
 
VDF_API VdfIndexedWeightsOperand operator>(double, const VdfIndexedWeightsOperand&);
VDF_API VdfIndexedWeightsOperand operator<(double, const VdfIndexedWeightsOperand&);
VDF_API VdfIndexedWeightsOperand operator>=(double, const VdfIndexedWeightsOperand&);
VDF_API VdfIndexedWeightsOperand operator<=(double, const VdfIndexedWeightsOperand&);
VDF_API VdfIndexedWeightsOperand operator==(double, const VdfIndexedWeightsOperand&);
VDF_API VdfIndexedWeightsOperand operator!=(double, const VdfIndexedWeightsOperand&);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif  // #ifndef PXR_EXEC_VDF_INDEXED_WEIGHTS_OPERAND_H