Class PuffyNoise

java.lang.Object
com.github.yellowstonegames.grid.PuffyNoise
All Implemented Interfaces:
INoise, Externalizable, Serializable
@Beta public class PuffyNoise extends Object implements INoise
A variant on CyclicNoise that always uses 7D noise internally, filling in any dimensions that it doesn't have with 1s.
Called PuffyNoise because it "puffs up" the dimensionality to a higher value even though most other noise generators don't do that very well. CyclicNoise is unusually fast in high dimensions and unusually low-quality in 2D, so maybe using more dimensions will help?
See Also:

  • Nested Class Summary

    Nested classes/interfaces inherited from interface INoise

    INoise.Serializer

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    protected float
    frequency
     
    protected static final float
    GAIN
     
    protected float[]
    inputs
     
    protected static final float
    LACUNARITY
     
    protected int
    octaves
     
    protected float[]
    outputs
     
    protected RotationTools.Rotator[]
    rotations
     
    protected long
    seed
     
    protected float
    start
     
    protected float
    total
     

  • Constructor Summary

    Constructors
    Constructor
    Description
    PuffyNoise()
     
    PuffyNoise(int octaves)
     
    PuffyNoise(long seed, int octaves)
     
    PuffyNoise(long seed, int octaves, float frequency)
     

  • Method Summary

    Modifier and Type
    Method
    Description
    PuffyNoise
    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)
     
    float
    getFrequency()
     
    int
    getMaxDimension()
    Gets the maximum dimension supported by this generator, such as 2 for a generator that only is defined for flat surfaces, or 7 for one that is defined up to the highest dimension this interface knows about (7D).
    int
    getMinDimension()
    Gets the minimum dimension supported by this generator, such as 2 for a generator that only is defined for flat surfaces, or 3 for one that is only defined for 3D or higher-dimensional spaces.
    float
    getNoise(float x, float y)
    Gets 2D noise with a default or pre-set seed.
    float
    getNoise(float x, float y, float z)
    Gets 3D noise with a default or pre-set seed.
    float
    getNoise(float x, float y, float z, float w)
    Gets 4D noise with a default or pre-set seed.
    float
    getNoise(float x, float y, float z, float w, float u)
    Gets 5D noise with a default or pre-set seed.
    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
    getNoise(float x, float y, float z, float w, float u, float v, float m)
    Gets 7D noise with a default or pre-set seed.
    int
    getOctaves()
     
    long
    getSeed()
    Gets the current seed of the generator, as a long even if the seed is stored internally as an int.
    String
    getTag()
    Returns a typically-four-character String constant that should uniquely identify this INoise as well as possible.
    boolean
    hasEfficientSetSeed()
    Returns true if this generator can be seeded with INoise.setSeed(long) during each call to obtain noise, or false if calling setSeed() is slow enough or allocates enough that alternative approaches should be used.
    int
    hashCode()
     
    static PuffyNoise
    recreateFromString(String data)
     
    void
    setFrequency(float frequency)
    Sets the frequency; the default is 2.
    void
    setOctaves(int octaves)
     
    void
    setSeed(long seed)
    Sets the seed, and in doing so edits 4 Rotator objects to use.
    PuffyNoise
    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()
     

    Methods inherited from class Object

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

    Methods inherited from interface INoise

    getNoiseWithSeed, getNoiseWithSeed, getNoiseWithSeed, getNoiseWithSeed, getNoiseWithSeed, getNoiseWithSeed, readExternal, writeExternal

  • Field Details

    • LACUNARITY

      protected static final float LACUNARITY
      See Also:

    • GAIN

      protected static final float GAIN
      See Also:

    • octaves

      protected int octaves

    • total

      protected float total

    • start

      protected float start

    • frequency

      protected float frequency

    • seed

      protected long seed

    • rotations

      protected transient RotationTools.Rotator[] rotations

    • inputs

      protected transient float[] inputs

    • outputs

      protected transient float[] outputs

  • Constructor Details

    • PuffyNoise

      public PuffyNoise()

    • PuffyNoise

      public PuffyNoise(int octaves)

    • PuffyNoise

      public PuffyNoise(long seed, int octaves)

    • PuffyNoise

      public PuffyNoise(long seed, int octaves, float frequency)

  • Method Details

    • getOctaves

      public int getOctaves()

    • setOctaves

      public void setOctaves(int octaves)

    • hasEfficientSetSeed

      public boolean hasEfficientSetSeed()
      Description copied from interface: INoise
      Returns true if this generator can be seeded with INoise.setSeed(long) during each call to obtain noise, or false if calling setSeed() is slow enough or allocates enough that alternative approaches should be used. You can always call setSeed() on your own, but generators that don't have any seed won't do anything. Generators that return false for this method will generally behave differently when comparing how INoise.getNoiseWithSeed(float, float, long) changes the seed and how setSeed() does.
      Specified by:
      hasEfficientSetSeed in interface INoise
      Returns:
      whether INoise.setSeed(long) should be efficient to call in every INoise.getNoiseWithSeed(float, float, long) call

    • 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

    • setSeed

      public void setSeed(long seed)
      Sets the seed, and in doing so edits 4 Rotator objects to use. Note that this may be considerably more expensive than a typical setter, because all matrices are set whenever the seed changes.
      Specified by:
      setSeed in interface INoise
      Parameters:
      seed - any long

    • getFrequency

      public float getFrequency()

    • setFrequency

      public void setFrequency(float frequency)
      Sets the frequency; the default is 2. Higher frequencies produce output that changes more quickly.
      Parameters:
      frequency - a multiplier that will apply to all coordinates; higher changes faster, lower changes slower

    • getTag

      public String getTag()
      Description copied from interface: INoise
      Returns a typically-four-character String constant that should uniquely identify this INoise as well as possible. If a duplicate tag is already registered and INoise.Serializer.register(INoise) attempts to register the same tag again, a message is printed to System.err. The default implementation returns the String (NO), which is essentially an invalid tag, meant to indicate that this was not fully implemented. Implementing this is required for any usage of Serializer.
      Specified by:
      getTag in interface INoise
      Returns:
      a short String constant that identifies this INoise type

    • 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

    • copy

      public PuffyNoise 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

    • stringDeserialize

      public PuffyNoise 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 PuffyNoise recreateFromString(String data)

    • getNoise

      public float getNoise(float x, float y)
      Description copied from interface: INoise
      Gets 2D 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
      Returns:
      a noise value between -1.0f and 1.0f, both inclusive

    • getNoise

      public float getNoise(float x, float y, float z)
      Description copied from interface: INoise
      Gets 3D 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
      Returns:
      a noise value between -1.0f and 1.0f, both inclusive

    • getNoise

      public float getNoise(float x, float y, float z, float w)
      Description copied from interface: INoise
      Gets 4D 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
      Returns:
      a noise value between -1.0f and 1.0f, both inclusive

    • getNoise

      public float getNoise(float x, float y, float z, float w, float u)
      Description copied from interface: INoise
      Gets 5D 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
      Returns:
      a noise value between -1.0f and 1.0f, both inclusive

    • getNoise

      public float getNoise(float x, float y, float z, float w, float u, float v)
      Description copied from interface: INoise
      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

    • getNoise

      public float getNoise(float x, float y, float z, float w, float u, float v, float m)
      Description copied from interface: INoise
      Gets 7D 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
      m - m position; can be any finite float
      Returns:
      a noise value between -1.0f and 1.0f, both inclusive

    • 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

    • getMinDimension

      public int getMinDimension()
      Description copied from interface: INoise
      Gets the minimum dimension supported by this generator, such as 2 for a generator that only is defined for flat surfaces, or 3 for one that is only defined for 3D or higher-dimensional spaces.
      Specified by:
      getMinDimension in interface INoise
      Returns:
      the minimum supported dimension, from 2 to 7 inclusive

    • getMaxDimension

      public int getMaxDimension()
      Description copied from interface: INoise
      Gets the maximum dimension supported by this generator, such as 2 for a generator that only is defined for flat surfaces, or 7 for one that is defined up to the highest dimension this interface knows about (7D).
      Specified by:
      getMaxDimension in interface INoise
      Returns:
      the maximum supported dimension, from 2 to 7 inclusive