Class ShapedFoamNoise

java.lang.Object
com.github.yellowstonegames.grid.ShapedFoamNoise
All Implemented Interfaces:
INoise, Externalizable, Serializable
@Beta public class ShapedFoamNoise extends Object implements INoise
Foam noise code as an INoise implementation, additionally taking a shape parameter for its interpolations (to allow using something shaped differently from a cubic Hermite spline, which is otherwise the default).
This is normally a smooth type of noise that can work well using fewer octaves than simplex noise or value noise. It also tends to look similar in lower dimensions and higher dimensions, where some other kinds of noise (such as SimplexNoise change their appearance quite a bit in 2D vs. 6D. Changing the shape with setShape(float) can make this try to be smoother (with shape values greater than 1) or spiky (less than 1).
See Also:

  • Nested Class Summary

    Nested classes/interfaces inherited from interface INoise

    INoise.Serializer

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static final ShapedFoamNoise
    instance
     
    protected long
    seed
    Use the same seed for any noise that should be continuous (smooth) across calls to nearby points.
    protected float
    shape
    The shape parameter of the spline this uses to smooth value noise results.

  • Constructor Summary

    Constructors
    Constructor
    Description
    ShapedFoamNoise()
     
    ShapedFoamNoise(long seed)
     
    ShapedFoamNoise(long seed, float shape)
     

  • Method Summary

    Modifier and Type
    Method
    Description
    ShapedFoamNoise
    copy()
    Creates a copy of this INoise, which should be a deep copy for any mutable state but can be shallow for immutable types such as functions.
    boolean
    equals(Object o)
     
    int
    getMaxDimension()
    Gets the maximum dimension supported by this generator, which is 6.
    int
    getMinDimension()
    Gets the minimum dimension supported by this generator, which is 2.
    float
    getNoise(float x, float y)
    Gets 2D noise using getSeed().
    float
    getNoise(float x, float y, float z)
    Gets 3D noise using getSeed().
    float
    getNoise(float x, float y, float z, float w)
    Gets 4D foam noise using getSeed().
    float
    getNoise(float x, float y, float z, float w, float u)
    Gets 5D noise with getSeed().
    float
    getNoise(float x, float y, float z, float w, float u, float v)
    Gets 6D noise with a default or pre-set seed.
    float
    getNoiseWithSeed(float x, float y, float z, float w, float u, float v, long seed)
    Gets 6D noise with a specific seed.
    float
    getNoiseWithSeed(float x, float y, float z, float w, float u, long seed)
    Gets 5D noise with a specific seed.
    float
    getNoiseWithSeed(float x, float y, float z, float w, long seed)
    Gets 4D noise with a specific seed.
    float
    getNoiseWithSeed(float x, float y, float z, long seed)
    Gets 3D noise with a specific seed.
    float
    getNoiseWithSeed(float x, float y, long seed)
    Gets 2D noise with a specific seed.
    long
    getSeed()
    Gets the current seed of the generator, as a long even if the seed is stored internally as an int.
    float
    getShape()
     
    String
    getTag()
    Returns the String "SFoN", to be used as a unique tag for this generator.
    boolean
    hasEfficientSetSeed()
    Returns true because this generator can be seeded with setSeed(long) and retrieved with getSeed().
    int
    hashCode()
     
    static ShapedFoamNoise
    recreateFromString(String data)
     
    void
    setSeed(long seed)
    Sets the seed to the given long, if long seeds are supported, or (int)seed if only int seeds are supported.
    void
    setShape(float shape)
     
    protected float
    spline(float x)
    The smoothing function applied to an x-value between 0 and 1, both inclusive.
    ShapedFoamNoise
    stringDeserialize(String data)
    Given a serialized String produced by INoise.stringSerialize(), reassigns this INoise to have the described state from the given String.
    String
    stringSerialize()
    Produces a String that describes everything needed to recreate this INoise in full.
    String
    toString()
     
    float
    valueNoise(float x, float y, float z, float w, float u, float v, long seed)
     
    float
    valueNoise(float x, float y, float z, float w, float u, long seed)
    Gets 5D value noise with the lowest, fastest level of detail.
    float
    valueNoise(float x, float y, float z, float w, long seed)
    Gets 4D value noise with the lowest, fastest level of detail.
    float
    valueNoise(float x, float y, float z, long seed)
    Gets value noise with the lowest, fastest level of detail.
    float
    valueNoise(float x, float y, long seed)
    Gets 2D value noise with the lowest, fastest level of detail.

    Methods inherited from class Object

    clone, finalize, getClass, notify, notifyAll, wait, wait, wait

    Methods inherited from interface INoise

    getNoise, getNoiseWithSeed, readExternal, writeExternal

  • Field Details

    • seed

      protected long seed
      Use the same seed for any noise that should be continuous (smooth) across calls to nearby points.

    • shape

      protected float shape
      The shape parameter of the spline this uses to smooth value noise results. This defaults to 2, which makes the shape similar to a cubic Hermite spline function, but can be 1 to linear-interpolate, or between 0 and 1 to make noise the opposite of smooth.

    • instance

      public static final ShapedFoamNoise instance

  • Constructor Details

    • ShapedFoamNoise

      public ShapedFoamNoise()

    • ShapedFoamNoise

      public ShapedFoamNoise(long seed)

    • ShapedFoamNoise

      public ShapedFoamNoise(long seed, float shape)

  • Method Details

    • spline

      protected float spline(float x)
      The smoothing function applied to an x-value between 0 and 1, both inclusive. This can use the shape value to determine how it works, but doesn't have to in subclasses. This defaults to using MathTools.barronSpline(float, float, float) with 0.5f for turning, and the shape of this object for shape.
      Parameters:
      x - between 0 and 1, both inclusive
      Returns:
      a float between 0 and 1, both inclusive

    • getNoise

      public float getNoise(float x, float y)
      Gets 2D noise using getSeed().
      Specified by:
      getNoise in interface INoise
      Parameters:
      x - x coordinate
      y - y coordinate
      Returns:
      noise between -1 and 1, inclusive

    • getNoiseWithSeed

      public float getNoiseWithSeed(float x, float y, long seed)
      Gets 2D noise with a specific seed.
      Specified by:
      getNoiseWithSeed in interface INoise
      Parameters:
      x - x position; can be any finite float
      y - y position; can be any finite float
      seed - can be any long
      Returns:
      a noise value between -1.0f and 1.0f, both inclusive

    • valueNoise

      public float valueNoise(float x, float y, long seed)
      Gets 2D value noise with the lowest, fastest level of detail. Uses the given seed and does not change x or y. This has a different output range (0 to 1) than foam noise.
      Parameters:
      x - x coordinate
      y - y coordinate
      seed - the seed to use for the noise (used in place of getSeed())
      Returns:
      noise between 0 and 1

    • getNoise

      public float getNoise(float x, float y, float z)
      Gets 3D noise using getSeed().
      Specified by:
      getNoise in interface INoise
      Parameters:
      x - x coordinate
      y - y coordinate
      z - z coordinate
      Returns:
      noise between -1 and 1, inclusive

    • getNoiseWithSeed

      public float getNoiseWithSeed(float x, float y, float z, long seed)
      Gets 3D noise with a specific seed.
      Specified by:
      getNoiseWithSeed in interface INoise
      Parameters:
      x - x position; can be any finite float
      y - y position; can be any finite float
      z - z position; can be any finite float
      seed - can be any long
      Returns:
      a noise value between -1.0f and 1.0f, both inclusive

    • valueNoise

      public float valueNoise(float x, float y, float z, long seed)
      Gets value noise with the lowest, fastest level of detail. Uses the given seed and does not change x, y, or z. This has a different output range (0 to 1) than foam noise.
      Parameters:
      x - x coordinate
      y - y coordinate
      z - z coordinate
      seed - the seed to use for the noise (used in place of getSeed())
      Returns:
      noise between 0 and 1

    • getNoise

      public float getNoise(float x, float y, float z, float w)
      Gets 4D foam noise using getSeed().
      Specified by:
      getNoise in interface INoise
      Parameters:
      x - x coordinate
      y - y coordinate
      z - z coordinate
      w - w coordinate
      Returns:
      noise between -1 and 1, inclusive

    • getNoiseWithSeed

      public float getNoiseWithSeed(float x, float y, float z, float w, long seed)
      Gets 4D noise with a specific seed.
      Specified by:
      getNoiseWithSeed in interface INoise
      Parameters:
      x - x position; can be any finite float
      y - y position; can be any finite float
      z - z position; can be any finite float
      w - w position; can be any finite float
      seed - can be any long
      Returns:
      a noise value between -1.0f and 1.0f, both inclusive

    • valueNoise

      public float valueNoise(float x, float y, float z, float w, long seed)
      Gets 4D value noise with the lowest, fastest level of detail. Uses the given seed and does not change x, y, z, or w. This has a different output range (0 to 1) than foam noise.
      Parameters:
      x - x coordinate
      y - y coordinate
      z - z coordinate
      w - w coordinate
      seed - the seed to use for the noise (used in place of getSeed())
      Returns:
      noise between 0 and 1

    • getNoise

      public float getNoise(float x, float y, float z, float w, float u)
      Gets 5D noise with getSeed().
      Specified by:
      getNoise in interface INoise
      Parameters:
      x - x position; can be any finite float
      y - y position; can be any finite float
      z - z position; can be any finite float
      w - w position; can be any finite float
      u - u position; can be any finite float
      Returns:
      a noise value between -1.0f and 1.0f, both inclusive

    • getNoiseWithSeed

      public float getNoiseWithSeed(float x, float y, float z, float w, float u, long seed)
      Gets 5D noise with a specific seed.
      Specified by:
      getNoiseWithSeed in interface INoise
      Parameters:
      x - x position; can be any finite float
      y - y position; can be any finite float
      z - z position; can be any finite float
      w - w position; can be any finite float
      u - u position; can be any finite float
      seed - any long
      Returns:
      a noise value between -1.0f and 1.0f, both inclusive

    • valueNoise

      public float valueNoise(float x, float y, float z, float w, float u, long seed)
      Gets 5D value noise with the lowest, fastest level of detail. Uses the given seed and does not change x, y, z, w, or u. This has a different output range (0 to 1) than foam noise.
      Parameters:
      x - x coordinate
      y - y coordinate
      z - z coordinate
      w - w coordinate
      u - u coordinate
      seed - the seed to use for the noise (used in place of getSeed())
      Returns:
      noise between 0 and 1

    • getNoise

      public float getNoise(float x, float y, float z, float w, float u, float v)
      Gets 6D noise with a default or pre-set seed.
      Specified by:
      getNoise in interface INoise
      Parameters:
      x - x position; can be any finite float
      y - y position; can be any finite float
      z - z position; can be any finite float
      w - w position; can be any finite float
      u - u position; can be any finite float
      v - v position; can be any finite float
      Returns:
      a noise value between -1.0f and 1.0f, both inclusive

    • getNoiseWithSeed

      public float getNoiseWithSeed(float x, float y, float z, float w, float u, float v, long seed)
      Gets 6D noise with a specific seed.
      Specified by:
      getNoiseWithSeed in interface INoise
      Parameters:
      x - x position; can be any finite float
      y - y position; can be any finite float
      z - z position; can be any finite float
      w - w position; can be any finite float
      u - u position; can be any finite float
      v - v position; can be any finite float
      seed - any long
      Returns:
      a noise value between -1.0f and 1.0f, both inclusive

    • valueNoise

      public float valueNoise(float x, float y, float z, float w, float u, float v, long seed)

    • getTag

      public String getTag()
      Returns the String "SFoN", to be used as a unique tag for this generator.
      Specified by:
      getTag in interface INoise
      Returns:
      the String "SFoN"

    • getMinDimension

      public int getMinDimension()
      Gets the minimum dimension supported by this generator, which is 2.
      Specified by:
      getMinDimension in interface INoise
      Returns:
      the minimum supported dimension, which is 2 inclusive

    • getMaxDimension

      public int getMaxDimension()
      Gets the maximum dimension supported by this generator, which is 6.
      Specified by:
      getMaxDimension in interface INoise
      Returns:
      the maximum supported dimension, which is 6 inclusive

    • hasEfficientSetSeed

      public boolean hasEfficientSetSeed()
      Returns true because this generator can be seeded with setSeed(long) and retrieved with getSeed().
      Specified by:
      hasEfficientSetSeed in interface INoise
      Returns:
      true

    • setSeed

      public void setSeed(long seed)
      Description copied from interface: INoise
      Sets the seed to the given long, if long seeds are supported, or (int)seed if only int seeds are supported. If this generator cannot be seeded, this should do nothing, and should not throw an exception. If this operation allocates or is time-intensive, then INoise.hasEfficientSetSeed() should return false. That method is checked in INoise.getNoiseWithSeed(float, float, long), and if it returns false, the noise call will avoid calling setSeed(). You can always at least try to set the seed, even if it does nothing or is heavy on performance, and doing it a few times each frame should typically be fine for any generator. In the case this is called thousands of times each frame, check INoise.hasEfficientSetSeed().
      Specified by:
      setSeed in interface INoise
      Parameters:
      seed - a long or int seed, with no restrictions unless otherwise documented

    • getSeed

      public long getSeed()
      Description copied from interface: INoise
      Gets the current seed of the generator, as a long even if the seed is stored internally as an int. This must be implemented, but if the generator doesn't have a seed that can be expressed as a long (potentially using BitConversion.floatToIntBits(float)), this can just return 0.
      Specified by:
      getSeed in interface INoise
      Returns:
      the current seed, as a long

    • getShape

      public float getShape()

    • setShape

      public void setShape(float shape)

    • stringSerialize

      public String stringSerialize()
      Description copied from interface: INoise
      Produces a String that describes everything needed to recreate this INoise in full. This String can be read back in by INoise.stringDeserialize(String) to reassign the described state to another INoise. The syntax here should always start and end with the ` character, which is used by INoise.stringDeserialize(String) to identify the portion of a String that can be read back. The ` character should not be otherwise used unless to serialize another INoise that this uses.
      If you use Base to produce String representations for numeric fields in an INoise, Base.BASE10 is strongly recommended; in most cases, you can just use string concatenation with the fields separated by the tilde character, "~". For printing a float field with Base to a StringBuilder sb, use Base.BASE10.appendGeneral(sb, field).
      The default implementation throws an UnsupportedOperationException only. INoise classes do not have to implement any serialization methods, but they aren't serializable by the methods in this class or in INoise.Serializer unless they do implement this, INoise.getTag(), INoise.stringDeserialize(String), and INoise.copy().
      Specified by:
      stringSerialize in interface INoise
      Returns:
      a String that describes this INoise for serialization

    • stringDeserialize

      public ShapedFoamNoise stringDeserialize(String data)
      Description copied from interface: INoise
      Given a serialized String produced by INoise.stringSerialize(), reassigns this INoise to have the described state from the given String. The serialized String must have been produced by the same class as this object is.
      Any class that implements INoise.stringSerialize() should also implement this method in a compatible way. Using base-10 is expected for most uses. Using Base.BASE10.readFloat(data, start, end) may be useful to parse only the part of data between start and end.
      The default implementation throws an UnsupportedOperationException only. INoise classes do not have to implement any serialization methods, but they aren't serializable by the methods in this class or in INoise.Serializer unless they do implement this, INoise.getTag(), INoise.stringSerialize(), and INoise.copy().
      Specified by:
      stringDeserialize in interface INoise
      Parameters:
      data - a serialized String, typically produced by INoise.stringSerialize()
      Returns:
      this INoise, after being modified (if possible)

    • recreateFromString

      public static ShapedFoamNoise recreateFromString(String data)

    • copy

      public ShapedFoamNoise copy()
      Description copied from interface: INoise
      Creates a copy of this INoise, which should be a deep copy for any mutable state but can be shallow for immutable types such as functions. This almost always just calls a copy constructor.
      The default implementation throws an UnsupportedOperationException only. Implementors are strongly encouraged to implement this in general, and that is required to use an INoise class with INoise.Serializer.
      Specified by:
      copy in interface INoise
      Returns:
      a copy of this INoise

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • equals

      public boolean equals(Object o)
      Specified by:
      equals in interface INoise
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object