MAP2UT -- Quake MAP to Unreal T3D converter

Copyright (C) 2004-2012 Laszlo Menczel (

This program is distributed under the terms of the GNU General Public License version 2 as published by the Free Software Foundation. A copy of it is in the file GPL.TXT. This program comes with ABSOLUTELY NO WARRANTY.


MAP2UT is a derivative of the MergeT3D program (see this document). I have modified the MergeT3D program so that it can convert Quake maps to Unreal T3D files which can then be imported to UnrealEd. This makes automatic, nearly complete conversion of Quake maps to Unreal maps possible. (Well, with some limitations. Texture alignment, lifts and doors are not retained in the current version, so you will have a little work to do after the conversion. :-)

All map brushes are converted to additive Unreal brushes, and a single big substractive brush is constructed to enclose the whole map. (This scheme simulates the Quake map structure better, because in Quake everything is built in an additive way.) The size of the map is scaled up by a factor which can be supplied as a command line argument (default scale factor is 1.5).

Entities are converted to Unreal actors as follows:

  info_player_deathmatch      PlayerStart
  info_player_start           PlayerStart

  item_armor1                 ThighPads
  item_armor2                 Armor2
  item_armorInv               UT_ShieldBelt

  item_artifact_super_damage  UDamage
  item_artifact_invisibility  UT_invisibility

  item_health                 MedBox
  megahealth                  HealthPack

  item_cells                  FlakAmmo
  item_rockets                RocketPack
  item_spikes                 Miniammo
  item_shells                 ShockCore

  weapon_lightning            FlakCannon
  weapon_rocketlauncher       UT_Eightball
  weapon_supernailgun         minigun2
  weapon_supershotgun         ShockRifle
  weapon_grenadelauncher      enforcer
  weapon_nailgun              enforcer

  trigger_teleport            Teleporter
  info_teleport_destination   Teleporter

Lights are also converted, brightness is scaled down by a factor which can be supplies as a command line argument (default scale factor is 0.2).

Textures can also be converted to Unreal ones by supplying a texture conversion table (see below). However, I think that using the original Quake textures is a better choice and will result in maps better approximating the originals. IMO this option should only be used for the replacement of a few textures which do not look good enough when used in Unreal.

If a particular Quake texture is not found in the conversion table, the program assumes that its equivalent is in an Unreal texture pack named 'XXX.UTX' where 'XXX' is the name of the map converted, and that the name of the texture is the same as in the Quake map. This is the default behaviour in case if no texture conversion table is supplied.

Note: The texture pack(s) used must be open when you import the T3D file in UnrealEd, otherwise the replacement does not work!

You can construct a suitable Unreal texture pack containing the Quake textures of the map as follows:

  * Extract all textures from the Quake map (BSP file).
  * Convert the texture files to PCX format.
  * Import all PCX files into an Unreal texture pack and give it the name of
    the original Quake map. This can be done in UnrealEd.

MAP2UT accepts the following command line arguments

  -f mapfile                (required)

  -t texture-table          (optional)

  -s size-scalefactor       (optional)

  -l light-scalefactor      (optional)

This is the name of map file to convert. It must be in the standard Quake MAP format.

This is the file which contains the texture conversion table disussed above. It should contain ASCII text lines in the the following formats:

  quake-texture-name unreal-texture-pack-name.unreal-texture-name


  blume7_2 city.Sidewalk

All references to the texture 'blume7_2' will be replaced by references to the Unreal texture 'Sidewalk' in texture pack 'city.utx'.
Please note that the length of texture names (both Quake and Unreal) should not exceed 127 characters.

This is a floating point number by which every vertex coordinate will be multiplied. Quake maps must be scaled up when converted to Unreal, otherwise they will feel cramped (geometry and physics are different in the two games). The default value is 1.5; some experts recommend 1.35 which is the theoretical value, but 1.5 is IMO better since it yields vertex coordinates which fall on the grid in UnrealEd so are easier to manipulate.

This is a floating point number by which light brightness values will be multiplied. In my experience, brightness should be scaled down but the actual value probably depends on the map. The default is 0.2 which I found to be satisfactory for a couple of maps.

Step-by-step instructions for map conversion

Here is how a Quake map named e.g. 'XXX' can be converted:

1. Convert XXX.BSP to XXX.MAP using the utility 'winbspc'. In some cases it will be necessary to load and then save (w/o any editing) the MAP file using the 'Quest' map editor. It seems that the file format produced by 'winbspc' is slightly different and may not be processed correctly. (The original 'merget3d' program was designed to work together with 'Quest'.)

2. Using a Quake utility extract all textures from the original BSP (e.g. by the GFE utility). Convert to PCX (e.g. in Pain Shop Pro or Corel). Any tweaking (smoothing, dithering, color adjustment, resizing, etc.) is OK as long as the name is retained. Import the PCX files into an Unreal texture pack named XXX.UTX (this can be done in UnrealEd). Please note that texture width and height must be powers of two. Some Quake textures have non-standard sizes (e.g. a height of 192), these must be resized.

3. Run 'MAP2UT' as follows:

     map2ut -f XXX.MAP -s S.S -l L.L

where S.S is the (optional) size scaling factor, L.L is the (optional) light scaling factor (both floating point numbers). Try first the defaults :-) The file XXX.T3D will be constructed.

4. Start UnrealEd and open the texture pack XXX.UTX which contains the textures from the original Quake map (if you do not open the texture pack before importing the T3D file, the texture info will be lost and all brushes will have the ugly greenish texture used by the editor when it does not know which texture to use).

5. From the File menu, import the XXX.T3D file.

6. Select the big substractive brush (on the screen you will find it in the top view window, over the map brushes) and move it so that it encloses completely the additive map brushes. (see Note below)

7. Rebuild the map & save under a suitable name.

Note: I tried to construct the substractive brush so that it is automatically aligned with the map brushes, but could not do it. Since I did not have the time (and the will) to completely understand the 'merget3d' program and make this feature perfect, I decided to construct the brush in unoccupied space. Feel free to correct this 'bug' if you can :-)


* Extract & save in the T3D file texture alignment information. Must take into account texture resizing (this should be uniform, if any, otherwise cannot be handled automatically) and brush scaling.

* Convert lifts and doors to movers (seems to be a hard job).