UT_BRJ.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:        UT_BRJ.h (UT Library, C++)
 *
 * COMMENTS:
 */

#ifndef __UT_BRJ__
#define __UT_BRJ__

#include "UT_API.h"
#include <SYS/SYS_Types.h>
#include "UT_Vector2.h"
#include "UT_Vector3.h"
#include "UT_UniquePtr.h"

/// UT_BRJ - Binary Random Jittered Sampling
///
/// Generate a sequence of well distributed random numbers
///
/// The generator only supports 1-3 dimensional random numbers.
template <size_t DIM, typename T>
class ut_BRJNoiseVector
{
public:
    using this_type = ut_BRJNoiseVector<DIM, T>;
    using value_type = T;
    static constexpr size_t tuple_size = DIM;

    inline T     operator[](size_t i) const { return myValue[i]; }
    inline T    &operator[](size_t i) { return myValue[i]; }

    inline T            *begin() { return myValue; }
    inline T            *end() { return myValue+DIM; }
    inline const T      *begin() const { return myValue; }
    inline const T      *end() const { return myValue+DIM; }

private:
    T   myValue[DIM];
};

template <size_t DIM>
class UT_API UT_BRJ
{
public:
    template <typename T> using noiseVector = ut_BRJNoiseVector<DIM, T>;
    using uvec = ut_BRJNoiseVector<DIM, uint>;
    using fvec = ut_BRJNoiseVector<DIM, float>;

    /// Default constructor doesn't initialize any data - you need to call
    /// setSeed() before using.
    UT_BRJ() = default;

    /// Initialize using a seed and an optional count
    UT_BRJ(uint seed, uint count = 0)
    {
        setSeed(seed, count);
    }

    /// Set the seed (and possibly the sequence number)
    void        setSeed(uint seed, uint count = 0);

    /// Reset the sequence of numbers (possibly with an offset)
    SYS_FORCE_INLINE void       reset(uint count=0) { myCount = count; }

    /// Get the float value and advance the state
    SYS_FORCE_INLINE fvec       fx() { return convertFloat(ux()); }
    /// Convenience operator to get the float value and advance the state
    SYS_FORCE_INLINE fvec       operator()() { return convertFloat(ux()); }

    /// Stateless computation of the random number
    static uvec                 ux(uint seed, uint index);

private:
    /// Return the current integer value, automatically advancing the state
    /// These values are only meaningful when representing floats
    uvec        ux();

    static SYS_FORCE_INLINE fvec        convertFloat(const uvec &uv)
    {
        fvec                    fv;
        SYS_FPRealUnionF        u;
        for (size_t dim = 0; dim < DIM; ++dim)
        {
            u.uval = uv[dim];
            fv[dim] = u.fval - 1;
        }
        return fv;
    }

    uvec        myS0;
    uint        mySeed;
    uint        mySalt;
    uint        myCount;
};

SYS_FORCE_INLINE float
UTbrjF(uint seed, int index)
{
    SYS_FPRealUnionF    u;
    u.uval = UT_BRJ<1>::ux(seed, index)[0];
    return u.fval - 1;
}

SYS_FORCE_INLINE UT_Vector2F
UTbrjV2(uint seed, int index)
{
    auto        uv = UT_BRJ<2>::ux(seed, index);
    SYS_FPRealUnionF    u[2];
    u[0].uval = uv[0];
    u[1].uval = uv[1];
    return UT_Vector2F(u[0].fval-1, u[1].fval-1);
}

SYS_FORCE_INLINE UT_Vector3F
UTbrjV3(uint seed, int index)
{
    auto        uv = UT_BRJ<3>::ux(seed, index);
    SYS_FPRealUnionF    u[3];
    u[0].uval = uv[0];
    u[1].uval = uv[1];
    u[2].uval = uv[2];
    return UT_Vector3F(u[0].fval-1, u[1].fval-1, u[2].fval-1);
}

#endif