UT/UT_PNoise.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.
 *
 * Produced by:
 *      Mark Elendt
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        UT_PNoise.h ( UT Library, C++)
 *
 * COMMENTS:    New, nicely bounded noise functions.
 *              Allows for periodicity of noise as well.
 */

#ifndef __UT_PNoise__
#define __UT_PNoise__

#include "UT_API.h"
#include <SYS/SYS_Types.h>

class UT_Vector3;
class UT_Vector4;

class UT_API UT_PNoise {
public:
    static void         initNoise();

    // Non-periodic noise functions
    static float        noise1D(float x);
    static float        noise2D(const float x[2]);
    static float        noise2D(float x, float y);
    static float        noise3D(const float x[3]);
    static float        noise4D(const float x[4]);

    // Flow values are 0..1 and are periodic.
    static float        flownoise2D(const float x[2], float flow);
    static float        flownoise2D(float x, float y, float flow);
    static float        flownoise3D(const float x[3], float flow);
    static float        flownoise4D(const float x[4], float flow);

    // Vectorized scalar noise
    static void         noise1D(fpreal32 *dest, const fpreal32 *src, int n);
    static void         noise2D(fpreal32 *dest,
                                const fpreal32 *x, const fpreal32 *y, int n);
    static void         noise3D(fpreal32 *dest, const UT_Vector3 *src, int n);
    static void         noise4D(fpreal32 *dest, const UT_Vector4 *src, int n);

    // Periodic noise functions.  The period specified should be != 0
    static float        noise1D(float x, uint period);
    static float        noise2D(const float x[2], uint period[2]);
    static float        noise2D(float x, float y, uint px, uint py);
    static float        noise3D(const float x[3], uint period[3]);
    static float        noise4D(const float x[4], uint period[4]);

    // Flow versions of periodic noise (note flow variable always periodic)
    static float        flownoise2D(const float x[2], uint period[2], float flow);
    static float        flownoise2D(float x, float y, uint px, uint py, float flow);
    static float        flownoise3D(const float x[3], uint period[3], float flow);
    static float        flownoise4D(const float x[4], uint period[4], float flow);

    // Non-periodic vector noise functions
    static void         noise1D(float n[3], float x);
    static void         noise2D(float n[3], const float x[2]);
    static void         noise2D(float n[3], float x, float y);
    static void         noise3D(float n[3], const float x[3]);
    static void         noise4D(float n[3], const float x[4]);

    // Flow vector noise, non-periodic
    static void         flownoise2D(float n[3], const float x[2], float flow);
    static void         flownoise2D(float n[3], float x, float y, float flow);
    static void         flownoise3D(float n[3], const float x[3], float flow);
    static void         flownoise4D(float n[3], const float x[4], float flow);

    // Vectorized vector noise
    static void         noise1D(UT_Vector3 *dest, const fpreal32 *P, int n);
    static void         noise2D(UT_Vector3 *dest,
                                const fpreal32 *x, const fpreal32 *y, int n);
    static void         noise3D(UT_Vector3 *dest, const UT_Vector3 *P, int n);
    static void         noise4D(UT_Vector3 *dest, const UT_Vector4 *P, int n);

    // Periodic vector noise functions
    static void         noise1D(float n[3], float x,    uint per);
    static void         noise2D(float n[3], const float x[2], uint per[2]);
    static void         noise2D(float n[3], float x, float y,
                                            uint px, uint py);
    static void         noise3D(float n[3], const float x[3], uint per[3]);
    static void         noise4D(float n[3], const float x[4], uint per[4]);

    // Periodic vector noise, flow
    static void         flownoise2D(float n[3], const float x[2], uint per[2], float flow);
    static void         flownoise2D(float n[3], float x, float y,
                                            uint px, uint py, float flow);
    static void         flownoise3D(float n[3], const float x[3], uint per[3], float flow);
    static void         flownoise4D(float n[3], const float x[4], uint per[4], float flow);
};

#endif

---