UT/UT_Noise.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.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        Noise generator for utility library (C++)
 *
 * COMMENTS:
 *      Two types of noise are currently supported.  Perlin & Sparse
 *      convolution.  This class basically produces space coherent noise
 *      (meaning that points which are close in space will generate
 *      similar noise values).
 *
 *      To control the noise, you can change the frequency & offset
 *      by scaling space before sending the values to noise...
 *
 */

#ifndef __UT_Noise_h__
#define __UT_Noise_h__

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

//
//  The following classes are really private to the UT_Noise class
//  however, they are defined in the C file, but declared here for
//  syntax.

class UT_Vector3;

class UT_API ut_NoiseVector {
public:
    ut_NoiseVector();
    virtual ~ut_NoiseVector() {}
    virtual void        initNoise(unsigned seed) = 0;
    virtual fpreal      noise(const UT_Vector3 &pos) const = 0;
    virtual void        noise(const UT_Vector3 &pos, UT_Vector3 &val) const = 0;

    // For GPGPU noise.
    virtual int         getNumTextures() = 0;
    virtual void       *getTextureData(int tex_index,
                                       int &xsize, int &ysize,
                                       int &comps, bool &fp) = 0;
};


class UT_API UT_Noise {
public:
     explicit UT_Noise(unsigned seed = 0);
    ~UT_Noise();

//
//  Following is an enumeration of the types of noise supported:
    enum UT_NoiseType
    {
        FAST,           // Perlin based noise generator
        SPARSE,         // Slower but higher quality noise generator
        FAST_FIX,       // Perlin based noise which was fixed
        ALLIGATOR       // Slight modification on sparse
    };

//
//  Initialization methods
    void        setType(UT_NoiseType type = FAST);
    void        setSeed(unsigned seed = 0);
    void        initialize(unsigned seed, UT_NoiseType type)
                {
                    setType(type);
                    setSeed(seed);
                }

//
// Query methods: Allow us to tell if we need to rebuild.
    UT_NoiseType        getType() const { return myType; }
    int                 getSeed() const { return mySeed; }

//
//  Methods for getting noise out
    fpreal      turbulence(const UT_Vector3 &pos, unsigned fractalDepth,
                                fpreal rough = 0.5F, fpreal atten=1) const;
    void        turbulence(const UT_Vector3 &pos, unsigned fractalDepth,
                                UT_Vector3 &noise,
                                fpreal rough = 0.5F, fpreal atten=1) const;

    ut_NoiseVector *getNoiseVector() { return noise; }
private:
    int                  mySeed;
    UT_NoiseType         myType;
    ut_NoiseVector      *noise;
};

#endif

---