Bibliography on Environment generation (WP3)

During our bibliographical work, finding articles was pretty easy, though selecting the ones we will implement was a bit more difficult. We chose to use Layered Architectures, so we can implement “interactions” between pieces of environment that will be automatically processed. We found this concept very elegant and chose to continue with articles using this kind of technique.

We suppose that the global environment is divided into several types of environments (cities, forests, mountains, …), we denote by feature a type of environment. Our goal is to allow the user to “draw” the different features on a map, and then generate automatically the corresponding 3D environment.

The main architecture comes from DeclarativeArchitecture. It is a layered architecture, from large-scale features to low-scale ones. Each feature covers a user-delimited area, which may be further reduced because of conflicts with the surrounding features. The modularity of the architecture allows features to be edited independently of each other. The output may include: a height map, a texture map and additional objects to be added on top of this such as: a water map, vegetation or buildings. The height map is generated using the tree structure described in FeatureTree. The conversion from the layered architecture amounts to choosing the appropriate merging nodes: the leaves are exactly the features of the layers. Furthermore, this representation can compute the height of the final map at any point, allowing a greater level of detail when and where needed.

Generating cities is done in three consecutive steps:

1. Create the road network. This will be done using the method proposed in StreetTensors, which seems to support easy edition.

2. Divide each block into parcels, following the method given in PGParcels.

3. Generate a building in each parcel. This can be done either using predefined buildings or procedurally generated using L-systems, as in FLSystem.

Environment plugin development (WP5)

The articles mentioned in part [WP3] describe quite precisely the algorithms usable to build and merge the different features. The work done for the code of the environment part was to organise the different algorithms into several classes (summarised on Figure [env_classes]). The main classes are:

Feature

This class is like an abstract class. It is the base from which every feature inherit, to allow us to manipulate generic feature in our code.

FeatureTree

This class build the tree of the features, depending on their positions and thus their interactions. It also solves the “merge” of the different features.

Environment

This one is the final 3D environment, which uses the 3D models and the feature tree to build the 3D environment.

BlendEnvironment

This class is the only one depending on Blender, it converts the Environment class to allow it to be displayed and used into Blender.