VEX_KVexRamp.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        VEX_KVexRamp.h (VEX Library, C++)
 *
 * COMMENTS:
 */

#ifndef __VEX_KVexRamp__
#define __VEX_KVexRamp__

#include "VEX_API.h"

#include <UT/UT_IntrusivePtr.h>
#include <UT/UT_Ramp.h>
#include <UT/UT_Span.h>
#include <UT/UT_StringHolder.h>
#include <SYS/SYS_Hash.h>

class UT_JSONWriter;

class VEX_API VEX_KVexRamp
    : public UT_IntrusiveRefCounter<VEX_KVexRamp>
{
public:
    VEX_KVexRamp();

    using vex_RampHash = uint32;

    /// KEY_T should be float or double
    /// VALUE_T should be float/double, UT_Vector2, UT_Vector3 or UT_Vector4
    template <typename FLOAT_T, typename VALUE_T>
    static inline vex_RampHash
    computeHash(const UT_Span<const FLOAT_T> &keys,
                 const UT_Span<const VALUE_T> &values,
                 const UT_Span<const UT_StringHolder> &basis,
                 uint components)
    {
        SYS_HashType    hash = SYSsharpe_inthash(components);
        for (const auto &k : keys)
            SYShashCombine(hash, k);
        for (const auto &v : values)
            SYShashCombine(hash, v);
        for (const auto &b : basis)
            SYShashCombine(hash, b);
        vex_RampHash uhash = (hash & 0xffffffff) ^ (hash >> 32);
        return uhash ? uhash : 1;
    }

#define VEC_CTOR(FLOAT_T, VALUE_T) \
    VEX_KVexRamp(const UT_Span<const FLOAT_T> &keys, \
                 const UT_Span<const VALUE_T<FLOAT_T>> &values, \
                 const UT_Span<const UT_StringHolder> &basis) \
    { initVec<FLOAT_T, VALUE_T<FLOAT_T>>(keys, values, basis); } \
    /* end macro */

#define FLT_CTOR(FLOAT_T) \
    VEX_KVexRamp(const UT_Span<const FLOAT_T> &keys, \
                 const UT_Span<const FLOAT_T> &values, \
                 const UT_Span<const UT_StringHolder> &basis) \
    { initFloat<FLOAT_T>(keys, values, basis); } \
    VEX_KVexRamp(int tsize, \
                 const UT_Span<const FLOAT_T> &keys, \
                 const UT_Span<const FLOAT_T> &vals, \
                 const UT_Span<const UT_StringHolder> &basis) \
    { initArray<FLOAT_T>(tsize, keys, vals, basis); } \
    VEC_CTOR(FLOAT_T, UT_Vector2T) \
    VEC_CTOR(FLOAT_T, UT_Vector3T) \
    VEC_CTOR(FLOAT_T, UT_Vector4T) \
    /* end macro */

    FLT_CTOR(fpreal32)
    FLT_CTOR(fpreal64)
#undef FLT_CTOR
#undef VEC_CTOR

    vex_RampHash        hash() const { return myHash; }

    template <typename FLOAT_T>
    void        eval(FLOAT_T key, FLOAT_T *result, int size) const;

    fpreal32   evalF(float k) const { fpreal32 r;   eval<fpreal32>(k, &r,       1); return r; }
    UT_Vector2 evalU(float k) const { UT_Vector2 r; eval<fpreal32>(k, r.data(), 2); return r; }
    UT_Vector3 evalV(float k) const { UT_Vector3 r; eval<fpreal32>(k, r.data(), 3); return r; }
    UT_Vector4 evalP(float k) const { UT_Vector4 r; eval<fpreal32>(k, r.data(), 4); return r; }
    int        size() const { return mySize; }

    UT_StringHolder     toString() const;
    void                dump() const;
    void                dump(UT_JSONWriter &w) const;

    static UT_IntrusivePtr<VEX_KVexRamp>        theEmptyRamp;

private:
    template <typename FLOAT_T>
    void        initFloat(const UT_Span<const FLOAT_T> &keys,
                          const UT_Span<const FLOAT_T> &values,
                          const UT_Span<const UT_StringHolder> &basis);
    template <typename FLOAT_T>
    void        initArray(int tsize,
                    const UT_Span<const FLOAT_T> &keys,
                    const UT_Span<const FLOAT_T> &values,
                    const UT_Span<const UT_StringHolder> &basis);
    template <typename FLOAT_T, typename VALUE_T>
    void        initVec(const UT_Span<const FLOAT_T> &keys,
                        const UT_Span<const VALUE_T> &values,
                        const UT_Span<const UT_StringHolder> &basis);

    template <typename FLOAT_T, int VSIZE>
    void                addKey(fpreal k,
                                const FLOAT_T *v,
                                const UT_StringHolder &basis);

    UT_Ramp             myRamp;
    vex_RampHash        myHash;
    int                 mySize; // number of components (1, 2, 3, 4)
};

class VEX_API VEX_KVexRampEval
    : public UT_NonCopyable
{
public:
    virtual ~VEX_KVexRampEval();

    virtual void        eval(const VEX_KVexRamp &ramp,
                             fpreal32 t,
                             fpreal32 *result,
                             int result_size) const
    {
        ramp.eval<fpreal32>(t, result, result_size);
    }
    virtual void        eval(const VEX_KVexRamp &ramp,
                             fpreal64 t,
                             fpreal64 *result,
                             int result_size) const
    {
        ramp.eval<fpreal64>(t, result, result_size);
    }
};

using VEX_KVexRampPtr = UT_IntrusivePtr<VEX_KVexRamp>;

#endif