[Tutorial] Map in a Month

Ever wanted to make a map mod, but don't know where to begin? I'm going to be spending roughly an hour each day for the next month going through the process, step by step. Everything you need to know to make a map similar in quality to the official maps will be discussed. Feel free to ask questions below if you find any of the steps confusing, and I'll do my best to answer them. This post will be updated on a daily basis, and on Christmas day the map will be released. Here goes!

---

DAY ONE
Today I'm not even going to do any technical work at all - this is about planning the area I want to create and thinking about how to make it.

What kind of map do I want to make? It can't be too large or complex, since I only have one month (and one hour per day at that). I'd like to make a map of a real place so I can get more practice making roads that are as realistic as possible. It also needs to be fun to drive on, otherwise what's the point? I want to use 0.5m terrain resolution so the roads are very smooth and detailed, which (practically speaking) probably limits me to a 2kmx2km map.

Now I can recall recently driving a fun stretch of mountain road not far from where I live. Measuring it out in Google Earth, it's only 4km long and very twisty, so it should fit in a 2kmx2km map. It's also quite steep and mountainous, which makes it a decent location for a short hillclimb stage. Finally, there is only one road and the rest is covered in forest, so I don't have to worry about detailing dozens of hectares of map since most of it won't be accessible.



Browsing the Queensland government website, I find that there is LiDAR data available for the western half of the area, which conveniently happens to be the steepest part and the area where terrain is most complex. Point clouds for the eastern half aren't available, but there are contour maps so reasonable accuracy should still be possible, albeit with more manual labor involved. More on that later - today I'm just thinking about how to make this map, not starting it yet. That comes tomorrow.

---

DAY TWO
Today I will be extracting surface data from point clouds and setting up a scene to render as terrain in Blender. I use the map at http://elevation.fsdf.org.au/ to locate the area of my map (red area) and find the three Lidar tiles, each one square kilometre. After downloading these files I can use CloudCompare to open them, and to split the surface data from the treetops using the method in this tutorial: https://www.beamng.com/threads/tutorial-level-building-with-lidar.39370/.

As I can see from the preview, the data is very high quality and will be useful for mapping the elevation, width and camber of roads. I export these three files to .stl and save them in a new working folder outside of my BeamNG.drive install.

Next, I set up a new Blender file which will be used to render heightmaps for the in-game terrain. I start by creating a centered camera at the axis origin, and scaling it to 2048 Blender units, which will be the width of the level in metres. I add a background image captured from Google Earth which will serve as a top-down reference, and scale it using reference points measured from the map, so that the background image matches the scale of the real world in Blender units. Now I can import the 3 .stl files from CloudCompare and use the background image as a guide to locating them in 2D space.



This now means that 40% of the map area is covered in accurate terrain geometry, ready to render as a heightmap. If I had access to Lidar data for the whole area it would make my job a lot easier, but unfortunately I'm left with the eastern part of the map missing. This is going to take a lot more work...

A more traditional way to create terrain geometry is by using contour maps. This is fairly time consuming, but it seems to be the only way forward. The government website http://qtopo.dnrm.qld.gov.au/mobile/ has 10m contour maps available, so I download one that covers my missing area. I save this image to my working folder and load it as another background image in Blender, scaling it to match the existing background image:



Now begins the time-consuming process of tracing each 10m contour line using Blender's grease pencil, and then converting the lines into curves and then into meshes (alt-c). I also run a "remove doubles" operation to simplify the contour line geometry down to 10m vertex spacing. As I create each contour line, I select the whole continuous line (L) and use the transform tools to set the Z coordinate to the elevation marked on the map (340m in the example below).



After at least an hour of tracing lines and setting elevations, I finally have a wireframe representation of the rest of the terrain. I'm out of time for today, but tomorrow I'll use this data to create a surface and complete the topography of this landscape.

---

DAY THREE
I finished tracing contours for the east side of the map yesterday, and now it's time to fill those contours in to make a renderable surface. This can be done by selecting two adjacent contour lines, pressing 'F' to fill a face between them, and then converting to triangles with Ctrl-T. Then move onto the next pair of adjacent contour lines and continue filling them until the entire terrain surface is filled (again, this can be quite time consuming but will save a lot of pain later on).



The basic topography of the map is now complete - one side is filled with Lidar data at high resolution, and the other side is filled with contour data at a more limited resolution. I can use sculpting to improve the appearance of the contour data side later, but until then it will serve just fine as an elevation reference for placing roads. There are also some jagged overlaps where the two sides meet, but these problems can be easily cleaned up at a later stage in the map creation process.


Now it's time to create smooth road geometry which will be used for the whole length of the road, since the Lidar data is still a little too coarse to be directly used as a drivable surface. I measure the width of the road to be 8m across the outer lane lines, and add 0.75m of edge beyond the lines for a total width of 9.5m. Then I make a mesh segment of road with subdivisions of 0.5m, matching the resolution that the terrain will be in-game. This mesh is then arrayed and curved (using the modifiers panel) along a bezier spline that I edit to follow the road as seen in the aerial background image.


Then, using the 3D view, I move the bezier curve's control points vertically until they match the elevation and slope of the terrain beneath. In the portion of the map covered by Lidar data (below, left), the camber of the road can even be observed and applied as "tilt" in the bezier curve's control point options. In the area of the map filled with contour data (below, right), there isn't enough detail to determine the camber or the exact elevation of the road, but an approximate elevation can be found by placing the control points at the center of the road on the surface of the terrain itself, so that the road is slicing through the terrain surface.



I'll need to visit the site later in the project to take more precise road elevation measurements in the contour-filled area of the map, but for now this approximation will suffice. Because the road is attached to a spline, making adjustments at any point in time will be easy.

Three days in, and still no trace of a BeamNG.drive map! Don't worry, tomorrow I will generate a heightmap and finally give this road a test drive in-game.

---

DAY FOUR
With the 3D terrain in Blender ready to transfer into the game, I set up some compositing nodes to render my scene as a heightmap. This involves taking the Z (depth) output from a render, scaling it to a useful range using the Map Value node, and then outputting it to a grayscale image which becomes the heightmap. I do this in 2 layers - one for the base terrain (made from the Lidar pointcloud meshes and the contour meshes), and one for the road surface (custom mesh curved along a spline). The road layer is pasted over the terrain layer using the Alpha Over compositing node. I also need to make sure Blender's color management is set up as below, to avoid any distortion of the heightmap color range.



Now I can render the scene to produce a heightmap. This is saved in 16-bit grayscale at 4096x4096 resolution. It's time to create the level folder so I take the template map folder in the levels folder, duplicate it, and rename it to "mount_glorious". Then I need to go through the .cs and json file, replacing each reference to the path "Template" with "mount glorious", and do the same for material.cs files in the art/terrain folder.

Once this is done I can import my heightmap image, which has been saved in levels/mount_glorious. I use 0.5m per pixel since the terrain is 2048m x 2048m, and my heightmap is 4096x4096. I've also created a 4096x4096 image which is plain greyscale white, called "01_mask_grass". I load this image in the texture map list, and double-click on it to select the existing grass material for it. This means the whole map will be covered in grass to begin with.



Back in Blender, I select the mesh that I've created for the road surface, and copy it to a new layer. I apply any modifiers using alt+C, and apply location, rotation and scale using ctrl+A. Now I export the mesh as a collada (.dae) file to levels/mount_glorious/art/shapes/roads. This will be a reference object that I can use to tweak the terrain to the correct vertical position and scale. I use the mesh library in the level editor to load up this road mesh and place it at 0, 0, 0. Now I can see if the terrain surface is too low or too high, and can align it manually with the road mesh. Once I see the terrain clipping with the road mesh along the entire elevation range of the map, I know the terrain position and vertical scale are correct.



The road is now in-game and able to be driven, so I can do a quick test run to see how it feels. In the area with less precise contour-based terrain, there are some transition issues between the road surface and the terrain. I will fix those up tomorrow, and also lay some decal roads to start improving the appearance of the road itself.

---

DAY FIVE

Now that the terrain is correctly placed and scaled, I return to Blender to generate a new mask for the road's asphalt groundmodel. This can be produced by isolating the road mesh and rendering the viewport, then saving as and RGBA image at 4096x4096. The alpha channel of this render is a grayscale image where white represents the asphalt. Groundmodel masks need to be vertically mirrored to work properly when imported, so I mirror the image and export as a greyscale image named "03_mask_asphalt".



Now I need to make sure the required materials exist in the level folder. I find the asphalt groundmodel in levels/west_coast_usa/art/terrain/materials.cs and copy it into levels/mount_glorious/art/terrain/materials.cs. I do the same for the dirt groundmodel too, which will come in handy soon, and make sure any textures referenced in the materials.cs file are present in the terrain folder. In the materials.cs file, the file paths also need to be changed from west_coast_usa to mount_glorious.

Now I go back into the level editor and import the terrain once more. This time I add a second texture map: "03_mask_asphalt.png", and assign the asphalt groundmodel to it. After importing , the road surface is covered in nice grippy asphalt, ready to have decal roads applied.



To set up decal roads, I find an existing asphalt decal road from another level folder, for example Utah/art/road, and copy the textures and materials.cs into mount_glorious/art/road. In this case I've modified the diffuse texture to give it double solid white centerlines, and disabled the normal map so that the asphalt groundmodel lighting details show through.



Back in Blender, I add two more layers to the composing node pipeline: Cut and Fill. These allow me to use geometry to slice out the heightmap (by using the "darken" compositing node) and to fill in the heightmap (by using the "lighten" compositing node. You can see how this works below and to the left - the brown mesh is on the "Cut" layer, and will form the cliff face that the road runs along, and the green mesh is on the "Fill" layer, and will extend the edge of the road slightly and provide a smoother edge.



After rendering the heightmap out again and importing, the road/terrain transitions are looking much improved.

---

DAY SIX
Today's work is all about guardrails, since these are present on one or both sides of the road for most of the map. I start with a survey of the guardrails using Google Street View, during which I find all the major types of guardrails and model up low-poly approximations of their shape. It turns out I'll need a single-height guardrail, double-height guardrail, transition piece, post cover and a piece for transitioning between guardrail and concrete barrier. I'll also want textures for the rear of the guardrail and new/old variations for the single-height guardrail.



Now I create a new file for generating textures from high-resolution models, and name it mount_glorious_textures.blend. I append the low-resolution guardrail surfaces that I've already created, split them into front and back, and lay them out flat. Then I unwrap the UV's into a square texture of 2048x2048 resolution and start modeling high-resolution guardrail geometry just underneath the low-poly surfaces. When I'm finished, I select the high-poly meshes and then the low-poly mesh, and hit "Bake" to generate normal maps and ambient occlusion maps.

With a bit of layering in Gimp, I can produce diffuse, normal, specular and reflectivity maps for the guardrails. These are exported as .dds into mount_glorious/art/shapes/roads. The diffuse and specular maps use BC1/DXT1 compression, the normal map uses BC5/ATI2 (3Dc) compression, and the reflectivity map uses BC3/DXT5 compression.



Returning to the main project Blender file, I can apply these textures to a new material called "guardrails". Blender's GLSL preview lets me see how effective the textures are - in this case they seem to be working quite well for such low-poly meshes.

Now I can start arraying and curving the low-poly guardrail mesh along a spline curve, matching it to the terrain like I did with the road surface mesh. Once I'm happy with the shape, I duplicate the mesh, apply modifiers using Alt+C, apply rotation and scale (Ctrl+a), and export it as a .dae to mount_glorious/art/shapes/roads. I also add a material.cs file to this folder, and create a new material definition as seen below:



Since I've already centered the terrain and scaled it to perfectly match output from Blender, any static object with location, rotation and scale applied will appear in exactly the right location, assuming it's located at 0, 0, 0. With this in mind I load the guardrail mesh from the asset browser and place it at 0, 0, 0.

There's just one thing left to do: Create a simplified collision mesh to stop cars from getting stuck in the barrier. I duplicate the guardrail's visual mesh and remove a few edge loops until it's just a plain wall, 30-40cm thick. Then I rename this mesh to Colmesh-1 and export it to .dae along with the visual mesh - the already-placed guardrail mesh will update automatically and cars will collide with it nicely.

---

DAY SEVEN
Before I go any further, I want to make a visit to the site and take some elevation measurements for the part of the road which doesn't have pointcloud information. My idea initially was to attach a GoPro to the car, set up my phone in front of it and record data from a barometric altimeter app as I drive along. Unfortunately though, the elevation display only updates every 2 seconds and is easily influenced by wind, which would require me to stop every few meters to record measurements. Since the road has a lot of blind corners, this would be too dangerous - I have to take the measurements on foot instead. Still, the length of road where elevation data is missing is only a little over 2km, which isn't so bad. I still get to use the GoPro to record footage of me driving the road, and this helps to give me an even better idea of the shape of crests and dips.

(Warning, terrible audio )

Now for the altimeter measurements - as I walk along the road I look for reference objects such as signs, fences or the apex of a curve, and use my phone's altimeter app to record the elevation down on my map. I start at the lowest point and calibrate the altimeter to zero (relative elevation), so later on I can match up part of the map with existing Lidar data and get an absolute elevation. The image below shows absolute elevation followed by relative elevation in parentheses. The offset between relative and absolute elevation is 172m, meaning that the lowest point recorded was 172m above sea level.



Now that I have this data on my background image, I reload it into Blender and start adding a reference object (Empty, Plain Axes) for each point. I can select each of these and directly set the global Z coordinate to the absolute elevation marked on the background image. With this done, all I need to do is adjust the spline controlling the road mesh so that it passes through all the points. With some additional checking against the reference video to sort out the shapes of bumps and slope transitions, the road accuracy is now very high.

---

DAY EIGHT
Today I'm doing some additional guardrail placement using the same method described on day 6. I also want to add a third groundmodel to the map, dirt (also used for cliffs temporarily). In order to select the cliff areas, I need to find the steepest areas on the terrain. I can do this using a viewport render in Blender and using one of the Matcap materials that shades steeper angles darker. I increase the contrast on this layer until it's black and white, and this serves as a mask for dirt areas. I also merge in the asphalt mask and grow it by a few pixels, so there is some width at the edges of roads where grass doesn't grow. I re-import the terrain using this mask and assigning the dirt material using the same process as on day 5.



I'm going to start adding detail to parts of the road that aren't in the high-resolution pointcloud area. Below is a hairpin turn which needs specially modeled cliff details. Also new are the additional guardrails, dirt edges, and a new lighter asphalt decal road for testing.

---

DAY NINE
One of the prominent features of this road is the piles of fallen leaves up against the guardrails. I want to make these using decal roads and by creating my own texture for maximum authenticity. I make a new Blender file called mount_glorious_vegetation.blend which will also come in handy later on for trees.

I start by modeling several low-poly leaves of various sizes and colors. Now I add a long subdivided mesh and use the particle system to generate several thousand leaves at random rotations and sizes.



This can be rendered into a 512x8192 texture (later scaled down to 256x4096) and with a little editing in Gimp, I have an almost photorealistic strip of leaves ready for use as a decal road. I add a new material for this decal road in mount_glorious/art/road/materials.cs, and make sure the textures I just created are in the same folder.



Now I want to add a cliff material to the terrain for the very steepest areas. Using several free-for-commercial-use textures from Textures.com, I combine them in Gimp to make a new 1024x1024 texture that suits my needs. I generate normal maps for this texture using Bitmap2Material (can also be done with Gimp plugins), and make a new terrain material definition in mount_glorious/art/terrain/materials.cs.


Now I use the Matcap method from yesterday to find the steep parts of the terrain again, and re-import the terrain heightmap adding a new terrain texture layer for cliffs.

I can also start adding leaves to the road edges using the decal road I just created. This map is starting to bear a strong resemblance to the real place!

---

DAY TEN
Sometimes the mundane things can take up a lot of time. Today all I do is create a texture atlas of signage for the map. Most of the signs can be found on Wikipedia in the public domain, but some (such as the green signs) need to be made by hand. Signs typically use the font Highway Gothic or a minor variation of it like AS1744.



I'm packing these signs into a 2048x1024 texture, which should be enough resolution to have them readable even on low texture settings.

---

DAY ELEVEN
I'm getting ready to add signs, posts and other artificial features to the map, but first I need to do a survey of all the object types needed. As it turns out, there are only 6 unique objects found along the road, with the exception of sign markings which I already have textures for.



Time to start modeling these up. I first create a high-poly version with all the bolts, dents and bumps, and then a low-poly version onto which I can bake textures. The small guardrail-mounted reflector doesn't need its own high-poly mesh, since it can reuse textures from the delineator post.



Now I create a set of low-poly meshes over the high-poly meshes, merge them and unwrap their UV faces onto a single blank image. By selecting first the multiple high-poly meshes and then the low-poly mesh, I can hit "Bake" and generate both normal maps and ambient occlusion automatically.

---

DAY TWELVE
Today I'm working on different texture layers for the roadside objects. Typical objects with reflective properties will need 4 textures: Diffuse, Normal, Specular and Reflectivity. Normal is the easiest to generate since it can be directly baked from the high-poly meshes to the low-poly mesh. Diffuse needs slightly more artwork - I like to start by painting a basic tiling texture over the uv islands (in this case, mostly galvanized metal), and then adding the ambient occlusion bake over the top with a "hard light" filter.


Specular and Reflectivity maps can be based on grayscale versions of the diffuse map, with adjustments to brightness/contrast to make the variation more dramatic. The Reflectivity map needs to use alpha transparency - the RGB value for the whole texture is 127, 127, 127, and the alpha value controls the strength of the cubemap effect.



Now with all the textures finished, I return to Blender and create a mockup of the materials there, to get an idea of how these objects will look in game. Once I'm happy, I copy the object to another layer, create a lower-poly version of it using the Decimate modifier, and add a collision mesh and "nulldetail" empty which will allow the object to be culled from rendering when far from the camera. Each of these mesh sets can now be exported to a .dae file in levels/mount_glorious/art/shapes/objects.

---

DAY THIRTEEN
It's now time to start putting these objects into the level. To do this, I use a special exporter script developed with the help of Dummiesman. You can find it here:

https://github.com/BeamNG/blender-forest-exporter

This script takes object coordinates from Blender and generates a forest file in the forest folder of the level. It's easy to use with hand-placed objects: just add them all to a group, select the group and export. However, I need a way to create hundreds of guardrail posts in precise locations along the existing guardrail.

Before I begin placing objects, I open up the level editor I add a new forest item mesh for each of the 6 objects I exported yesterday.

Back in Blender, since I already have a bezier curve in the file for the guardrail, I duplicate that and scale it vertically to zero (since I don't want the posts to be tilted along the path). Then I select a post object and parent it to the path (Ctrl+P), using the "follow path" option. Now I can go into the Object panel and turn on "Frames" duplication (making sure the "speed" box is unchecked) and the object will duplicate itself along the path. The length of the path is 100 frames by default, which results in 100 objects, but I can adjust this number in the bezier curve's Path panel.



Once I'm happy with the spacing of the posts, I use Ctrl+A to convert the duplication effect into individual objects and add them to a group called "guardrail_posts". These can then be projected downward onto the road from orthographic Top view using snap transform and selecting object faces as the type of element to snap to. I repeat this process until all the existing guardrails are lined with post objects.

Now I select all the objects in the group "guardrail_posts" and use the forest exporter from the space bar menu to export them all into a file called "railpost" in levels/mount_glorious/forest.



If the filename matches the forest item name, all these objects should appear when I reload the map. I do the same with the other objects - poles, guardrail end caps and reflector posts. I also begin adding signs to the poles in Blender - these use a new material with the texture from day ten, and I merge all the signs into one object prior to exporting since they are very low-poly.

---

DAY FOURTEEN
Not a whole lot of new workflow going on today: I continue adding rail posts to existing guardrails using the forest exporter method from yesterday, and also create a new license plate style in the new folder vehicles/common/licenseplates/mount_glorious. This is pretty easy since all I have to do is take a picture of my own car's license plate, paint out the text and scale it to 1024x512. I also make some tweaks in the licenseplate-default.html, licensePlate-default.json and license-plate-mountglorious-2-1.jbeam files that I've copied and renamed from another level's license plate folder, so that the paths are all correct and the color of the text matches the dark red of a real Queensland plate.

---

DAY FIFTEEN
Today I continue adding turn arrows and advisory speed signs for corners. Interestingly, the maximum speed most vehicles can maintain through a turn while staying in the lane is usually around twice the advisory speed limit, sometimes slightly higher or lower.

I also do a survey of some of the roadside plants (not including large trees) I'll be adding in the coming week. These will just be the smaller plant types like undergrowth and saplings, since they grow closest to the road. I divide the vegetation into 4 basic categories, and plan to make one forest item per category and then see if more variation is needed. Often it's possible to get away with only one mesh per vegetation type, if care is taken to make sure it's not symmetrical.

---

DAY SIXTEEN
I'm going to start with the clumps of dry branches, since they are fairly prevalent along the roadside. To begin, I use enable the Add Curve: Sapling Tree Gen plugin that ships with Blender and generate a mess of branches. Then I convert this to a new mesh, split off different branches and arrange them in the field of view of an orthographic camera.



Now I can assign a light brown material and hit render, saving as a 1024x1024 image in RGBA (which will later be scaled down to 512x512 for use in-game). Normal, diffuse and specular maps can all be generated by modifying this render with Gimp. I add a new mesh (plane) in Blender and divide it into a slightly convex pyramid shape. Copying it several times, I can UV unwrap it to various parts of the diffuse texture I just created to make a convincing tangle of branches.



In Vertex Paint mode, I fill the whole object (Shift+K) with dark blue, then add some greenish color in various random places. This will make the forest object slightly affected by rustling wind, with the green factor adding a random delay to the animation. Now I copy the object and use a 50% Decimate modifier to create a second level of detail, and add a third very simple pyramid-like object to serve as a collision mesh (named Colmesh-1).



Using the exporter template from the wiki, I export these meshes as a .dae file to levels/mount_glorious/art/shapes/trees/undergrowth, along with the textures I made. I also generate a materials file in the same folder containing a material with the same name as the object material. The object is now ready to add to the level editor's forest mesh list, and can then be placed in the level by hand.

---

DAY SEVENTEEN
On to the second forest element, the green leafy shrub. For this object I tweak the Sapling plugin until I get a bush-shaped tree, and turn on leaves. Once I'm happy with the shape I assign a green, textured material to the leaves and start splitting the tree into branches, arranging them in front of an orthographic camera like I did for the dry bush yesterday.



As before, I create a new Gimp file and start assembling layers for diffuse, normal and specular. Then copy the bush I made earlier and swap the textures, adjusting the texture coordinates as needed. I build up the bush from clumps pyramid-shaped surfaces, with a total of around 500 polygons.



Now I can add the exported mesh to the forest editor, add a material to the existing materials.cs file in levels/mount_glorious/art/shapes/trees/undergrowth, and begin placing this second type of bush on the map.

---

DAY EIGHTEEN
Now it's time to start making the eucalyptus saplings that are part of the forest undergrowth. I start making a new leaf texture, modeling basic eucalyptus leaves with the help of subsurf and using vertex paint to make them various shades of green and brown. The stems will also be part of the texture since these trees are small enough they won't have to be collidable.


Similarly to how I made the previous plants, I construct a sapling from planar elements mapped to different leaf clumps in the texture. The stems are mapped onto x-shaped intersecting planes so that they will be visible from any angle. With a bit of color adjustment these plants now match the other shrubs quite well, but I think a couple more variation will be needed to complete the scenery.

---

DAY NINETEEN
I decide to make two more variations of the eucalyptus saplings, since they are quite small and used in large numbers. This is just a repeat of yesterday's process, reusing the same textures and materials.

---

DAY TWENTY
I decide to use terrain groundcover for the very small bushes, since it will be easier to place and render faster than using forest items. This can come later though, today I need to create a texture that will be used for the large eucalyptus trees. It's important to consider what a tree looks like from a distance, not just at the scale of individual leaves. For my location, the trees appear to have clumps of leaves often spread out in a semi-circular shape, and these clumps combine to make up the silhouette of the tree. I'm going to try to make a texture that can easily be used to generate these clumps. This time there are a lot of leaves, too many to place by hand, so I use a particle effect to duplicate leaf objects from arc-shaped meshes.



To give an extra 3d effect to the leaf clumps, I replace all the leaf particles with spheres and use the viewport normalmap matcap to generate a normals texture that looks very fluffy and rounded once a little blur is applied.



These textures should be versatile enough to be used on all the tree models I'll be creating in the coming days.

---

DAY TWENTY-ONE
The first tree will be a roughly 20m tall eucalyptus tree with fairly even branch distribution and most branches ending in clumps of leaves. I use Sapling Tree Gen to create the trunk and branches and use a decimate modifier to bring the triangle count down to around 1200. Then I start duplicating clumps of leaves around the ends of the branches, the clumps themselves being created in a similar fashion to the bushes I made earlier. The highest LoD is around 2500 triangles and the second LoD is half that, with a 2d imposter used for greater distances.

---

DAY TWENTY-TWO
On to the second tree variation: this will be a smaller and slimmer eucalyptus tree, of the kind seen growing from cliff faces. Procedure is the same as yesterday, but the polygon count is lower (1200 for the high detail LoD, 600 for the lower detail).

---

DAY TWENTY-THREE
Another variation of the slim eucalyptus tree today: This one doesn't have a split in the trunk, but it's generated in the same way as the previous one with some tweaks to the branch splitting and growth parameters in the sapling plugin panel.



Now I want to create some very basic, low-detail trees for covering the rest of the terrain in areas that aren't drivable, in order to maximize graphical performance. I'm going to use the classic crossed planes, but also apply a "Normal Edit" Blender modifier so that the lighting will be more smooth and the perpendicular planes less noticeable.

---

DAY TWENTY-FOUR
Returning to the less detailed part of the terrain, I modify the geometry on the "Cut" layer to make it resemble the cliff surfaces in the laser scanned portion of the map. I can do this using a "displace" modifier (with the midlevel set to 0.5 so the average level of the surface remains the same) with a procedural Blender texture - Musgrave in this case - to create the surface irregularity. The next time I render, this change is immediately applied to the heightmap. After I paint over the cliff surfaces on the terrain's cliff texture mask, these areas begin to appear much more natural.

---

DAY TWENTY-FIVE
Now I need to add in the sections of fencing along the edges of cliffs, which catch falling rocks. I can re-use the poles I made previously for signs, and for the chain-link wire I can re-use a material and texture found in levels/west_coast_usa/art/shapes/objects. The material is named "chainlink" and the textures are chainlink_d.dds and chainlink_n.dds. To begin I array the pole objects along a roadside curve in Blender, similarly to how I added the guardrail support posts. Then I can add these objects to the group of all other poles in the file, and use the forest exporter to save over the level's pole1.forest4 file.



Now, I select all the poles that will support the fence, duplicate them and join them (Ctrl+J). Then I select all the vertices and remove doubles (roughly 10cm) until the mesh is just a series of edges. Now I can use Mesh > Edges > Bridge Edge Loops to form a continuous surface spanning the edges, which I can texture with the chainlink material. The green color can be applied using Vertex Paint.

---

DAY TWENTY-SIX
There is still one type of terrain material missing: The rocks lining the slope along the valley in the middle of the map. For this material I'll reuse the gravel groundmodel textures and material from West Coast USA, and adjust the texture scaling a little so that the rocks are larger. The material can be applied upon terrain import using a mask, like the other terrain materials.

---

DAY TWENTY-SEVEN
In order to create the short length of gabion wall seen in the photo above, I first need a texture. The stones can be borrowed from the gravel texture used in yesterday's terrain material, but I need to do some modeling work to make the chicken wire covering the stones. Returning to my textures file in Blender, I model a repeating pattern of hexagonal wire using extruded planes and and subsurf modifier. This can be rendered with an alpha channel and layered over the gravel texture in Gimp to give the desired effect.

---

DAY TWENTY-EIGHT
Now I can use the texture I created yesterday, along with the existing guardrail texture, to complete the gabion wall and concrete wall along this part of the map. I can also start filling in some of the background terrain with the low-detail trees, covering the less-detailed portion of the terrain and bringing the map closer to completion.

---

TO BE CONTINUED...

 

Scenarios are outside the scope of this tutorial, but if you're interested in creating them you can refer to https://www.beamng.com/threads/introduction-to-scenarios-creation.14700/

 

Yes, in fact I also plan to supply some of my Blender files as templates. Might have to strip them down to a reasonable size though, point cloud generated meshes are quite large.

 

Since this project is nearing completion, are there any steps that I haven't explained very well, which should be elaborated on in the next updates? If anyone feels confused about a part of the process, please comment and I'll either edit the section concerning it, or include it in the final days.

 

A beta release for this map is now pending approval on the repository. Even staff members submitting mods are subject to the usual pre-approval checks, so there may be a little delay before it's available