Mapping manual/Appendix C: Modelling a map

Maps are usually created using GTKRadiant or NetRadiant (programs that are expressly created for this work), but it's also possible to create maps with programs which are primary meant to create models such as Blender. In this appendix, we're going to see two approaches to map-modelling: the modern mapmodelling approach, and the Staticmesh approach.

For regular mapmodels such as decorations, go to the mapmodels page.

The modern mapmodelling approach

Blender can import and export from and to .map files, and (with additional plugins) from and to .md3 files. You may mix parts of maps created as models with parts created normally.

The easiest way to convert a map to a model format is running the q3map2 to convert the bsp to ase. Q3map2 auto discards all brush faces that are outside the map's volume, in the void. It also inverts all face's normals, because in the additive csg world of quake the inside of a mesh is the playable zone. Q3map2 doesn't convert the whole map in a single mesh object but rather many separated mesh objects.

The following guide was taken from dONKEY's site.

• First, block the map in your editor of choosing. Do big blocks, as you're going to work inside of those blocks. Each area should be 1024 or 512 units square, as each area of the map will need to be a separate model, as OA can't cut up models in the same way that it does to brushes to control vis.
• Convert your cube map into an .ase file using q3map2 and import it into Blender. This will be the "guide".
• With the .ase model as a guide, work on your map inside of Blender.
• Break the mesh into smaller sections, and export them into the editor.
• Hand-hack the ase files to edit the texture paths. OA requires 3 alterations per material, and a mixture of \ and / in the pathways.
• Flag the models to be lightmapped and to be given a high resolution lightmap scale.
• Clip the level so it can be played. Weapclip serves to stop bullets.
• Botclip the level so it can be played with bots.
• Test your map.

The "static mesh" approach

The term "static mesh" comes from the Unreal Engine. A "static mesh" is a non-animated object where the relative positions of the vertexes are fixed. Hence, staticmeshes are useful for displaying pieces of architecture that don't move at all. Staticmeshes are used for several different purposes, such as to create non-BSP map geometry (the so-called "Hardware Brush") movers and decorations. This was used a lot in the Unreal games starting from Unreal II: The Awakening and Unreal Tournament 2003.

The OpenArena mapping approach to Staticmeshes is about the first of these, the "Hardware Meshes". A mapper may build several little pieces of reduced "power of 2" size (such as 64x64, 128x128, 64x128, 128x64 etc) such as bricks and use (and re-use) them in maps in such a way that the whole map has a distinctive look, most of the time without even using textures. Though this, like every other tool, has some things to bear in mind, as they have every advantage and disadvantage mapmodels have.

Considerations

Like everything in life, modelling a map has its own advantages and disadvantages even compared with working on BSP:

• It requires a lot more of time than just doing a BSP.
• As models aren't part of the BSP tree, they don't count for visibility or collision, so before working with them, the map should have been carefully planned with VIS blocking in mind from the beginning.
• It is possible to use shaders on models. However, it's a bit tricky to set everything up. For ASE models, *MATERIAL_NAME and BITMAP (this one under *MAP_DIFFUSE) should both match "/textures/somefoldername/sometexturename" exactly. *MAP_NAME (under map_diffuse too) and shader filename should match exactly too. And finally, the shader's name "/textures/somefoldername/sometexturename" should match the material and bitmap lines. Due to all those matching names and paths, shaders could be possibly hard-constrained to one model - one shader.
• It's better to use one material per mesh to avoid overdrawn, as materials in 3D modelling aren't the texture bitmap itself.
• UV unwrap: compile the BSP without fixing T-junctions, with fewer edges it should be much easier to unwrap the model. Also, the converted ASE outputted from q3map2 has overlapping UVs, which can't be used to bake in renders.
• ASE: q3map2 converts each face, or co-planar surfaces, to one separated object. Each one with its own UV map.

External links

• How meshes are rendered in a lot of real time engines
• KatsBits - Tutorials about Blender 3D, modelling and modding, level design and texture making tutorials, resources and downloads.
  • Modelling maps and levels
  • Make *.map based levels in Blender 2.49
• 3D Studio Max Tutorial
• The ASE file format

<< Previous (Appendix B: Advanced features)	Mapping manual	(Appendix D: Editor differences) Next >>