The scope of this project is to create a tool for generating 2D and 3D terrain maps. It should allow fast iteration of generating terrain maps.

This epic groups issues related to the initial implementation of the map generator. It is the baseline for "getting it to work".

Must:

• Allow for the creation of libnoise modules
• Set the parameters for the libnoise modules, including other noise modules
• Display a 2D terrain map

Should:

• Display output of the individual noise modules (preview)

Following Phase 1 will be a refactoring stage to improve the code without changing functionality.

Noise modules have default values for all their parameters. These should be used when initializing the parameters.

Currently eats a lot of CPU

Allow the noise module representation to be stored on disk. As well as restored from disk. Ideally, this will be a human-readable format like YAML.

Must allow that user to create new noise modules and edit existing ones.

• Creating noise modules
• Removing noise modules
• Setting parameters in noise modules

This application could use a node editor to configure noise modules.

• Add noise modules
• Link noise modules
• Remove noise modules
• Rename modules
• Node tool tips (Show module type)
• Noise module description in active panel
• Reset source modules when a link is removed

Really need this for making sure everything builds in a clean environment

This will be the system that creates and links noise modules together. Noise modules do not refer directly to libnoise modules. A noise module can refer to individual libnoise modules or other noise modules linked together.

For example:

Module 1:
  sources:
    - noise 1
    - noise 2:
      source: noise 1
  output: noise 2

Module 2:
  sources:
    - noise 1
      source: Module 1 

Something like that.

Display status, errors, and warnings to user.

Display all the leaf module parameters in one place for editing.

Compile flags for different targets and what not

Noise modules will be added slowly to prevent a large amount of re-work should some implementation details change.

Modules:

• Abs
• Clamp
• Exponent
• Invert
• ScaleBias
• Add
• Max
• Min
• Multiply
• Power
• Billow
• Checkerboard
• Const
• Cylinder
• Perlin
• RidgedMulti
• Spheres
• Voronoi
• Blend
• Select
• Cache
• Displace
• RotatePoint
• ScalePoint
• TranslatePoint
• Turbulence

Some modules have a seed parameter. They can't all be the same but it would be nice is setting a "global seed" was possible. That way, only one seed value is required to regenerate the map.

As more modules are added it will become costly to generate previews for each one individually.

It would be helpful if a noise module could cache value from the preview generation to bring down the cost of generation.

Right now the noise module class creates, updates, and validates noise modules. There will be a large number of module types. Does having all noise module code in this class make sense? Should validation be moved elsewhere?

Release windows and linux binaries

Add modules to complete libnoise tutorials

• Billow
• ScaleBias
• RidgedMulti
• Perlin
• Select

Before generating/serializing/updating noise modules, ensure that the parameters are valid. Specifically noise module inputs.

Also must detect circular dependencies for modules and their sources.

Allow adding additional noise modules from plugins.

User specified shaders

Configure the output generator to generate colored height maps

• Should be able to set noise module as sources from the noise module class interface
• Should be able to cleanly evaluate if a source module is invalid (caused by removal)
• Should be able to track source dependencies in both directions ("Module 1 in a source of module 2. Module 2 has a dependency on Module 1")

This epic captures necessary UI enhancements to the map generator tool.

Primarily the addition of module groups and the capability to preview the output of a group of modules together.

A 2D terrain map should be display in the window

Logical groups of noise modules that create a final output. All modules in the group should be visible together (with previews). Should be able to set parameters of individual modules. Should be able to view/set leaf parameters of the entire group.

Display 3D terrain map to the window. This will require generating a mesh and render it to the screen.

Serialize the node edtior to a file and recover on startup.

Code needs to be unit testable.

The initial implementation of core features is complete. Refractor the existing code base to make new features easier to add/implement.

As parameters are adjusted a preview should be updated with the output of the noise module.

• Currently stored as a unique_ptr, it does not need to be
• Could be a shared_ptr to take advantage of weak_ptr references

I want to minimize the number of singular dynamic allocations.

These are useful for reference and debugging

https://github.com/nnarain/libnoise

Technically doable if you remove and re-add a module. But would be nice to have it built into the UI.

Save output. Can be textures or 3D files.

This is to avoid the black filled preview when the module is first created, before the parameters are set.

A small rectangular view that shows the output of the noise module.

Some modules require control points as parameters

Serialize noise modules to YAML. Possibly another format? Custom?