Class RotatingGlobeMap

java.lang.Object
com.github.yellowstonegames.world.WorldMapGenerator
com.github.yellowstonegames.world.RotatingGlobeMap
public class RotatingGlobeMap extends WorldMapGenerator
A concrete implementation of WorldMapGenerator that imitates an infinite-distance perspective view of a world, showing only one hemisphere, that should be as wide as it is tall (its outline is a circle). It should look as a world would when viewed from space, or as a globe would from its side, and implements rotation differently to allow the planet to be rotated without recalculating all the data. Note that calling setCenterLongitude(float) does a lot more work than in other classes, but less than fully calling WorldMapGenerator.generate() in those classes, since it doesn't remake the map data at a slightly different rotation and instead keeps a single map in use the whole time, using sections of it. This uses an Orthographic projection with the latitude always at the equator; the internal map is stored as a StretchWorldMap, which uses a cylindrical equal-area projection, specifically the Lambert equal-area projection.
Example view of a planet rotating. Another example.

  • Field Details

    • minHeat0

      protected float minHeat0

    • maxHeat0

      protected float maxHeat0

    • minHeat1

      protected float minHeat1

    • maxHeat1

      protected float maxHeat1

    • minWet0

      protected float minWet0

    • maxWet0

      protected float maxWet0

    • xPositions

      public final float[][] xPositions

    • yPositions

      public final float[][] yPositions

    • zPositions

      public final float[][] zPositions

    • edges

      protected final int[] edges

    • storedMap

      public final StretchWorldMap storedMap

  • Constructor Details

    • RotatingGlobeMap

      public RotatingGlobeMap()
      Constructs a concrete WorldMapGenerator for a map that can be used to view a spherical world from space, showing only one hemisphere at a time. Always makes a 100x100 map. Uses Noise as its noise generator, with 1f as the octave multiplier affecting detail. If you were using RotatingGlobeMap(long, int, int, INoise, float), then this would be the same as passing the parameters 0x1337BABE1337D00DL, 100, 100, new Noise(DEFAULT_NOISE), 1f.

    • RotatingGlobeMap

      public RotatingGlobeMap(int mapWidth, int mapHeight)
      Constructs a concrete WorldMapGenerator for a map that can be used to view a spherical world from space, showing only one hemisphere at a time. Takes only the width/height of the map. The initial seed is set to the same large long every time, and it's likely that you would set the seed when you call WorldMapGenerator.generate(long, long). The width and height of the map cannot be changed after the fact, but you can zoom in. Uses Noise as its noise generator, with 1f as the octave multiplier affecting detail.
      Parameters:
      mapWidth - the width of the map(s) to generate; cannot be changed later
      mapHeight - the height of the map(s) to generate; cannot be changed later

    • RotatingGlobeMap

      public RotatingGlobeMap(long initialSeed, int mapWidth, int mapHeight)
      Constructs a concrete WorldMapGenerator for a map that can be used to view a spherical world from space, showing only one hemisphere at a time. Takes an initial seed and the width/height of the map. The initialSeed parameter may or may not be used, since you can specify the seed to use when you call WorldMapGenerator.generate(long, long). The width and height of the map cannot be changed after the fact, but you can zoom in. Uses Noise as its noise generator, with 1f as the octave multiplier affecting detail.
      Parameters:
      initialSeed - the seed for the FlowRandom this uses; this may also be set per-call to generate
      mapWidth - the width of the map(s) to generate; cannot be changed later
      mapHeight - the height of the map(s) to generate; cannot be changed later

    • RotatingGlobeMap

      public RotatingGlobeMap(long initialSeed, int mapWidth, int mapHeight, float octaveMultiplier)
      Constructs a concrete WorldMapGenerator for a map that can be used to view a spherical world from space, showing only one hemisphere at a time. Takes an initial seed and the width/height of the map. The initialSeed parameter may or may not be used, since you can specify the seed to use when you call WorldMapGenerator.generate(long, long). The width and height of the map cannot be changed after the fact, but you can zoom in. Uses Noise as its noise generator, with the given octave multiplier affecting detail.
      Parameters:
      initialSeed - the seed for the FlowRandom this uses; this may also be set per-call to generate
      mapWidth - the width of the map(s) to generate; cannot be changed later
      mapHeight - the height of the map(s) to generate; cannot be changed later
      octaveMultiplier - used to adjust the level of detail, with 0.5f at the bare-minimum detail and 1f normal

    • RotatingGlobeMap

      public RotatingGlobeMap(long initialSeed, int mapWidth, int mapHeight, com.github.yellowstonegames.grid.INoise noiseGenerator)
      Constructs a concrete WorldMapGenerator for a map that can be used to view a spherical world from space, showing only one hemisphere at a time. Takes an initial seed and the width/height of the map. The initialSeed parameter may or may not be used, since you can specify the seed to use when you call WorldMapGenerator.generate(long, long). The width and height of the map cannot be changed after the fact, but you can zoom in. Uses the given noise generator, with 1f as the octave multiplier affecting detail.
      Parameters:
      initialSeed - the seed for the FlowRandom this uses; this may also be set per-call to generate
      mapWidth - the width of the map(s) to generate; cannot be changed later
      mapHeight - the height of the map(s) to generate; cannot be changed later
      noiseGenerator - an instance of a noise generator capable of 3D noise, usually Noise

    • RotatingGlobeMap

      public RotatingGlobeMap(long initialSeed, int mapWidth, int mapHeight, com.github.yellowstonegames.grid.INoise noiseGenerator, float octaveMultiplier)
      Constructs a concrete WorldMapGenerator for a map that can be used to view a spherical world from space, showing only one hemisphere at a time. Takes an initial seed, the width/height of the map, and parameters for noise generation (an INoise implementation, which is usually Noise.instance, and a multiplier on how many octaves of noise to use, with 1f being normal (high) detail and higher multipliers producing even more detailed noise when zoomed-in). The initialSeed parameter may or may not be used, since you can specify the seed to use when you call WorldMapGenerator.generate(long, long). The width and height of the map cannot be changed after the fact, but you can zoom in. Noise will be the fastest 3D generator to use for noiseGenerator, and the seed it's constructed with doesn't matter because this will change the seed several times at different scales of noise (it's fine to use the static Noise.instance because it has no changing state between runs of the program). The octaveMultiplier parameter should probably be no lower than 0.5f, but can be arbitrarily high if you're willing to spend much more time on generating detail only noticeable at very high zoom; normally 1f is fine and may even be too high for maps that don't require zooming.
      Parameters:
      initialSeed - the seed for the FlowRandom this uses; this may also be set per-call to generate
      mapWidth - the width of the map(s) to generate; cannot be changed later
      mapHeight - the height of the map(s) to generate; cannot be changed later
      noiseGenerator - an instance of a noise generator capable of 3D noise, usually Noise
      octaveMultiplier - used to adjust the level of detail, with 0.5f at the bare-minimum detail and 1f normal

    • RotatingGlobeMap

      public RotatingGlobeMap(RotatingGlobeMap other)
      Copies the RotatingGlobeMap other to construct a new one that is exactly the same. References will only be shared to INoise classes.
      Parameters:
      other - a RotatingGlobeMap to copy

    • RotatingGlobeMap

      public RotatingGlobeMap(int width, int height, String serialized)
      Creates a new generator from the given serialized String, produced by stringSerialize(), but this also requires width and height that match the first two lines of the given String (in Base.BASE86). It is almost always easier to use recreateFromString(String) instead.
      Parameters:
      width - width of the map or maps to generate; must match the first line of the given String in Base.BASE86
      height - height of the map or maps to generate; must match the second line of the given String in Base.BASE86
      serialized - should have been produced by stringSerialize()

  • Method Details

    • stringSerialize

      public String stringSerialize()
      Serializes this generator's entire state to a String; it can be read back when creating a new instance of this type with RotatingGlobeMap(int, int, String) or (preferably) recreateFromString(String). Uses Base.BASE86 to represent values very concisely, but not at all readably. The String this produces tends to be very long because it includes several 2D arrays and a Region as Strings.
      Overrides:
      stringSerialize in class WorldMapGenerator
      Returns:
      a String that stores the entire state of this generator

    • recreateFromString

      public static RotatingGlobeMap recreateFromString(String data)
      Creates a new instance of this class from a serialized String produced by stringSerialize(). This can get the width and height from the String, which makes this probably preferable to using the constructor RotatingGlobeMap(int, int, String). This stores the last-generated map in this WorldMapGenerator, where it can be used by other code like a WorldMapView.
      Parameters:
      data - the output of stringSerialize()
      Returns:
      the map that was serialized, as a new generator

    • wrapX

      public int wrapX(int x, int y)
      Overrides:
      wrapX in class WorldMapGenerator

    • wrapY

      public int wrapY(int x, int y)
      Overrides:
      wrapY in class WorldMapGenerator

    • setCenterLongitude

      public void setCenterLongitude(float centerLongitude)
      Description copied from class: WorldMapGenerator
      Sets the center longitude line to a longitude measured in radians, from 0 to 2 * PI. Positive arguments will be corrected with modulo, but negative ones may not always act as expected, and are strongly discouraged.
      Overrides:
      setCenterLongitude in class WorldMapGenerator
      Parameters:
      centerLongitude - the longitude to center the map projection on, from 0 to 2 * PI (can be any non-negative float).

    • regenerate

      protected void regenerate(int startX, int startY, int usedWidth, int usedHeight, float landMod, float heatMod, long stateA, long stateB)
      Specified by:
      regenerate in class WorldMapGenerator

    • equals

      public boolean equals(Object o)
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • toString

      public String toString()
      Overrides:
      toString in class Object