vee_perlin_noise.h

Go to the documentation of this file.

/* -*- C++ -*- */

/* COPYRIGHT
 *
 * This file is part of the Visual Effects Engine - VEE
 *
 * Read the "VEE-LICENSE" file for the license.
 *
 * Authors & Copyright:   
 *
 * Tommi Ilmonen, Tuukka Heikura, Marko Myllymaa and 
 * Janne Kontkanen 2001-2004
 *
 * Additional copyrights: Tekes 2003-2004
 *
 * firstname.lastname@hut.fi
 *
 */

#ifndef VEE_PERLIN_NOISE_H
#define VEE_PERLIN_NOISE_H

#include <perlinNoise.h>

#include <vee_vector2.h>
#include <vee_vector3.h>

class VEE_PerlinNoise 
{
public:
  static float noise(float x) { return perlinNoise::noise(x); }
  static float noise(float x, float y) { return perlinNoise::noise(x, y); }
  static float noise(float x, float y, float z) 
  { return perlinNoise::noise(x, y, z); }

  static float noise(const VEE_Vector3 & v) 
  { return perlinNoise::noise3d(v.data()); }
  static float noise(const VEE_Vector2 & v) 
  { return perlinNoise::noise2d(v.data()); }

  static float noise1d(float x, 
           float octaveAttenuation, unsigned octaves);
  static float noise2d(float x, float y, 
           float octaveAttenuation, unsigned octaves);
  static float noise3d(float x, float y, float z, 
           float octaveAttenuation, unsigned octaves);
};

/*
class VEE_PerlinNoise
{
public:

  enum Interpolation {
    LINEAR,
    WEIGHT
  };

  static const uint MAX_OCTAVES = 10;

  static double octaveNoise1d(double x, 
            double scale, 
            uint octave, 
            Interpolation);

  static double noise1d(double x, 
      double octaveAttenuation, 
      uint octaves, 
      Interpolation ip);

  static double octaveNoise2d(double x, 
            double y, 
            double scale, 
            uint octave, 
            Interpolation,
            uint seed);

  static double noise2d(double x, 
      double y, 
      double octaveAttenuation, 
      uint octaves, 
      Interpolation ip,
      uint seed = 0);

  static double octaveNoise3d(double x, 
            double y, 
            double z, 
            double scale, 
            uint octave, 
            Interpolation,
            uint seed,
            double range,
            double beyondRange);

  static double noise3d(double x, 
      double y, 
      double z, 
      double octaveAttenuation, 
      uint octaves, 
      Interpolation ip = WEIGHT,
      uint seed = 0,
      double range = 0.0,
      double beyondRange = 0.0);


  static double noise3d(double x, double y, double z);

  static double octaveNoise4d(double x, 
            double y, 
            double z, 
            double w, 
            double scale, 
            uint octave, 
            Interpolation,
            uint seed);

  static double noise4d(double x, 
      double y, 
      double z, 
      double w, 
      double octaveAttenuation, 
      uint octaves, 
      Interpolation ip,
      uint seed = 0);

  static void checkRand();

protected:
  static inline double moduloRand(uint source, uint octave);
  static inline uint ra(uint source, uint mul, uint seed);

  static uint m_randMultipliers[MAX_OCTAVES + 1];
  static uint m_randMultipliers2[MAX_OCTAVES + 1];

};
*/
#endif

---