Home > Help >

Anatomy of a Design Team

Teamwork in 3ds Max

Posted Jan 17, 2018
Last Updated Sep 22, 2023
Anatomy of a Design Team

One of the benefits of using 3ds Max is that it has several ways to make teamwork and collaboration simple. This chapter will detail on getting your team on the same page for working together on a Source Engine project.

While there are no hard rules for how your team will work, this chapter will outline a setup that makes teamwork most seamless in Wall Worm. To utilize these steps, you and all team members will need to install Wall Worm 5.0+ and use 3ds Max 2015+ (where the preferred version is 3ds Max 2022.3+). You will also need Autodesk Vault Server installed on at least one computer accessible to the network; Autodesk Vault Client is an optional install for each member.

This document is broken into three sections: Project Setup, Team Member Setup and Pipeline Overview. Project Setup is for the project administrator. Although the information is useful for all members, only the Project administrator needs to take the steps in that section.

Project Setup

In this setup, we are going to use the standard 3ds Max Project Folder. By default, Max has a basic file structure for a project that separates and organizes the types of files used in a project. To get started with this, the administrator of the project should create a new Project Folder. To set this up in 3ds Max 2022, click File > Set Project Folder and browse to a new folder on your system. You should choose a folder path that will exist on all member’s computers (as this will save hassle if non-relative paths are used on any assets). In this example, I’m creating a folder at C:\3dsmax\vault\myproject. (You may want to use a folder name that describes your project like “de_mapcore” or “bm_xenland”. For some a project might represent a single level where for others a project might represent an entire game.)

Once you let Max create this folder, Max will auto-generate a set of subfolders that are common to all Max projects. Among the folders will be these key folders:

  • downloads
  • export
  • import
  • sceneassets/images
  • scenes

There are other folders Max will create, but above are those we will use in this tutorial. There are also some extra Source-specific folders we want, but they will be generated for us later with a tool in Wall Worm.

Setting Up Wall Worm with this Project

Now we need to set up Wall Worm to use this new project. Click Wall Worm > Wall Worm Settings and click the Import GameConfig File button at the far right side of the settings window. Browse to your game’s gameconfig.txt file ( for example: "C:\Program Files (x86)\Steam\steamapps\common\Counter-Strike Global Offensive\bin\Gameconfig.txt"). You will see that a new game preset appears in the preset list. Select that preset from the list and click “Load Selected Preset”.

  • If you do not see a GameConfig.txt file in your mod's bin folder, then you should simply open Hammer once for that game. That will create the GameConfig.txt file.

To keep this preset recognizable as for your specific team, you may want to change the preset name now by typing in a new preset label and then clicking the Save button below the preset list. For example, change the label from “Counter-Strike Global Offensive” to “CSGO Myteam1” or something else representative of your team or project. This way, if you ever re-import that CSGO gameconfig, you won’t have two identically named presets. You should do this for any new project so that you can easily set Max/WW up by choosing the preset.


Now many of the paths will be set up to match the new project folders. However, we will still need to edit a few from their defaults. There is a utility in the next section on saving the preset to automate setting the paths to local as well as creating some extra paths.

For now, we just want to save the current Max Project Path. To set this Wall Worm Preset to use the current project, click the button with the "^" icon in the Max Project Folder section of the WW settings. This will pull the current project folder created above. (This is important because when changing presets in WW, the project folders will switch to the project folder belonging to that preset.)


Open the Models tab in the settings and set these settings:

  • SMD Exporter: Wall Worm Pro*
  • Normals: Explicit*
  • Default Model Path: myproject
  • Default Material Path: myproject

Note that for the default model and material paths, you should choose a name that will be unique to your project/name. I generally use “wallworm.com”. You should choose names that are not likely to be the same among other users. Note also that you can set up multiple saved default paths. Whichever is selected will be the default output path for all new materials and models.

* Wall Worm Pro should be the SMD Exporter of choice if you have Wall Worm Pro installed. Otherwise set it to Wall Worm SMD Exporter. Also, if you have Wall Worm Pro or you are working with assets created in other DCC apps like Maya, set the Normals method to Explicit Normals. Note that the Explicit Normal option is much slower in the free version of Wall Worm compared to Wall Worm Pro.


In the Materials tab, set these settings:

  • Do Extra Lookups to Find Materials: OFF
  • Do Extra Lookups to find Textures: OFF
  • Assign Relative Path for imported textures: ON


In the Miscellaneous tab, use these settings:

  • Debug Mode: OFF
  • Displacement Topo Listen: ON
  • Check for Home Project: ON

Save and Store Preset

Now we must set some of the paths to local and save our settings/presets for other members to reuse. Fortunately, there is a utility to do this in the global settings.

Click the Create Local Game Info button at the right side of the Wall Worm settings. When you do this, you will be asked if you want to set the asset paths to local. Click Yes.

At this point, your game’s gameinfo.txt is copied into a subfolder that matches your game’s name in the project root. Also, a folder named sdk_content is added to the project root with a maps and modelsrc subfolder.

Alongside the new gameinfo.txt is a file called SourcePresets.ms. This file contains the all the settings for your project that you can share with the other members--assuring everyone is using the same settings.

Once you have finished setting up the settings to your needs, click the Save button in the global settings. This will save your preset.

  • If you are working in Garry's Mod, you should refer to the slightly different documentation in Gmod and Wall Worm.
  • If after this update you cannot load MDL and Materials from the game with the MDL loader, you may need to manually update the newly generated gameinfo.txt file in your project folder. To fix this issue, update all VPK paths in the new (copied) gameinfo.txt file to absolute paths. Because these absolute paths might not match among all users/members, this file might need to be edited on each user's system.

Edit gameinfo.txt

Now also edit the original gameinfo.txt file for your game to include a line to our new extra game path. This file will open automatically at the end of the last step--and the path you need to add to it is also copied to your system clipboard. So all you need to do is paste the new line to the end of the SearchPaths block.  In this example, the Search Paths are edited to look like this for the actual CS:GO gameinfo.txt file:

  Game    |gameinfo_path|.
  Game    csgo
  Game  "C:/3dsmax/vault/myproject/csgo"

By adding the extra search path to our original gameinfo.txt file, it means that we can keep all assets from our project completely independent of the actual game files and your game can still find the assets. All of the models, materials, textures and levels we create will be stored in the project folders and not contaminate the game folders. Important: Make sure your extra path is at the bottom, below the official paths.

Create a MAXSTART file

3ds Max will auto-load any file called maxstart.max in the current project folder. We will create one because we can enforce all users in the project to use some of the same settings.

  1. In 3ds Max click File > New
  2. Set the system to use Generic Units where 1 Unit = 1 Inch (Customize > Units Setup)
  3. Right-click the Snaps toggle icon in the main toolbar and change the Home Grid spacing to a value of 32 (or another multiple of 2 like 64, 128, 256, etc). This will align your scene grids with standard Source/Hammer grids.
  4. Click Wall Worm > Point Entities and browse to info_player_start in the entity list
  5. Click Place Entity and pick a point in the viewport
  6. Right-click to stop adding entities
  7. Select the entity
  8. Click W (Move)
  9. Right-click the X/Y/Z spinners to move this object to world origin
  10. So this entity does not always export, find the Wall Worm Connection rollout in the modify tab and check the Exclude From VMF checkbox.
  11. Save this file to scenes/maxstart.max

Vault Setup

Autodesk Vault is a  data management software that helps organize and manage projects. While you do not need to use Vault to work on a team, it has several advantages over other options (such as SVN, Git, DropBox, etc). Among the advantages is the fact that 3ds Max itself has tight integration with it. If you have access to 3ds Max, you also have access to Vault Basic (which is what is used in this document).

The project administrator will need to install the Vault Server on a computer. Team members do not need to install the Vault Server. Team members should, however, install the Vault Client. Vault Server and Vault Client installers are found in your Autodesk Account with your 3ds Max downloads.

Once installed, you will need to create a user account for each member of your team. You will also need to create a set of permission groups and a Vault Project for your team. Installing Vault itself is not covered in this document.

Create Vault

A Vault can be thought of as a virtual repository of all the assets of a project. In a way it’s just like a file system folder. However, it contains version control and asset linking. It also allows users to check in/out files from remote locations.

To get started, we need to create a Vault. This must be done on the server from which Vault is located.

  1. Open the Vault Server
  2. Launch the Autodesk Data Management Server Console
  3. Expand the Server name to show a Vaults folder
  4. Right-Click the Vaults folder and click Create
  5. Name your Vault (preferably to something relating to your project)

Now that the Vault exists on the Vault Server, you can finish all remaining tasks remotely using the Vault Basic Client.

Create Users

For your team to have access to the Vault, each member needs their own user account in the Vault.

  1. Open the Vault Basic Client
  2. Click Tools > Administration > Global Settings
  3. Click the Users Button
  4. Add one user for each member of your team
  5. Assign the user to have access to the Vault
  6. Alternatively Create User Groups and assign them to your team appropriately

Set Vault Settings

Each projects you work on should have its own Vault. Although not required, you should consider forcing all users to keep the Vault in the same location on their computers. Doing so will help avoid problems that can happen if the system is not set up this way. In this case, we will force each user to keep the vault at: C:\3dsmax\vault\myproject

  1. Open the Vault Basic Client
  2. Click Tools > Administration > Vault Settings
  3. Click the Define button in the Working Folder Options
  4. Turn on the Enforce consistent working folder for all clients and set it to C:\3dsmax\vault\myproject*
  5. Click OK

* If you do not enforce consistent working folder among users then your team must be careful to enforce all assets to use relative paths (such as to the bitmaps). Failure to do this will mean that if Artist A adds C:\3dsmax\vault\myproject\sceneassets\images\foliage\flower1.tga into a scene with an absolute path (the full file path listed), Artist B will have a missing image when loading that scene if her project is located at D:\myproject. The workaround is to load the bitmap as a relative path: sceneassets\images\foliage\flower1.tga . Enforcing the same project path in the Vault avoids any headaches.

Add Folders and Files to the Vault

Now we need to tell Vault what files and folders belong to the Vault. Vault will only track those folders and files you added to it explicitly.

The easiest way to add multiple files to your Vault is to browse to the Vault folder in Windows Explorer, select all the folders, and drag them onto the Vault Explorer icon in Vault Basic. You can also right-click the Vault Explorer icon and choose Add Files.

When you add files to Vault it will prompt you to type a message as well as give you the option to keep the file checked out. You should always make a habit of typing a message for your checkin/checkout actions. As for checking out the file--you should refrain from checking out files that you are not editing.

At this point, add all of the folders and files from the project folder into the Vault. Once you’ve done this, the Vault is now set up for others to use. Just remember that in order for team members to have access to each other’s files, the members must always remember to check in their files to the Vault.

Other considerations are that your Vault Server must be running from a computer that has Internet access if collaborating remotely. You may also need to setup port-forwarding on your router to point ports 80 or 443 to your Vault server. See the Vault documentation or your router documentation for more information. Preferably your Vault server is located at an IP address that does not change to the outside world--or else you will need to keep your team apprised of IP address changes.

Team Member Setup

Now that the Vault Server is ready, we need to get each team member on the Vault. There are two ways to do this. One is simply through 3ds Max. The other is through the Vault Client. It is probably a good idea to get each member set up with both.

Vault Client Login

The first you open the Vault Client, you will need to log in with your username and password.

  1. Launch Vault Client
  2. Click File > Log In
  3. Choose Authentication Vault Client
  4. Enter your username
  5. Enter your Password
  6. In the Server, enter the IP Address or computer name
  7. For Vault, click the button at right to browse for Vaults on your server and choose the appropriate one
  8. Turn on the Automatically log in next session option.
  9. Click OK

Now you are able to browse the files in your Vault. From here you can download file (Get), Checkout Files (Get and lock others from editing), Add files. You can also get previous versions of files.

Download (Get) Files

At this point you should select folders and files you want to bring to your computer. It is not necessary for you to get all files unless you need them. For example, you may not need to open a Substance Paint file that another user loaded unless you actually need to open/edit that file.

For now, we are going to download the entire project because it is very small still.

  1. Open the Vault Client
  2. Click the Vault Explorer folder in the left pane
  3. In the Vault Explorer window in the right, Left Click the top folder
  4. Now Hold Down the SHIFT button and left click the bottom file (myproject.mxp)
  5. Now that all items are selected, right click and choose Get…
  6. Since you are not currently planning on editing these files, do not click the Checkout icon (Checkbox).
  7. Click OK and wait for the files to download

Vault in 3ds Max

You can also log in to Vault directly in 3ds Max. To do this you should launch the Asset Tracking Dialog (SHIFT+T) or click File > Reference > Asset Tracking Toggle.

To integrate with Vault, click the Options menu and uncheck the Disable Asset Tracking and turn on the Auto Login option.

Now click the Server menu and choose Login and log in with your credentials.

Important Note: There are two important bugs with the Vault login in Max. First, the option to remember your password doesn’t work in some versions of Max. The second is that the password field will become plain-text when you click the button to login. Because of this you should not login to Vault via 3ds Max during a screen sharing session.

Asset Tracking

At this point, you should familiarize yourself with how the Asset Tracking tools in Max work. The best resource is to read about these functions in the 3ds Max documentation on the Asset Tracking Dialog.

Installing the Project Presets

Now that the files are all downloaded, we need to set Wall Worm up for this Project.

  1. Click Wall Worm > Wall Worm Settings
  2. Click the Import Presets File button at the right side
  3. Browse for C:/3dsmax/vault/myproject/csgo/SourcePresets.ms
  4. You will see one or more new presets in the setting preset list
  5. Choose the proper preset (which will have an asterisk to denote it was imported)
  6. Once selected, click the Load Selected Preset Button

Edit GameInfo.txt

Now you need to browse to the actual game you are working on and edit the GameInfo.txt file. This will be in the game folder of your actual game. In this example, it is the gameinfo.txt file for Counter-Strike Global Offensive.

Edit the file’s search path block to include the bold section below:

Now also edit the original GameInfo.txt file that we originally copied to include a line to our new extra game path. In this example, the Search Paths are edited to look like this for the actual CS:GO gameinfo.txt file:

  Game    |gameinfo_path|.
  Game    csgo
  Game    "C:/3dsmax/vault/myproject/csgo"

This will allow you to access any assets that are compiled into the Vault project files without contaminating the actual game files.

Now you should be ready to use the new Vault project folder with your team. Before getting started with work, it’s a good idea to double-check that the paths are all as expected. In your Game paths, the modelsrc, materialsrc, mapsrc and Game Info paths should go to your project folder. The Game EXE and Bin Dir should still go to the actual game paths.

Pipeline Overview

Now that your Vault Server is set up and the team is set up, there are a few things to understand.

File and Project Structure

Every asset for your project should be contained within the project folder. This includes all raw assets (PSDs, TGAs, MAX Files, etc) as well as exported and compiled assets (VMF, BSP, QC, SMD, MDL, VTF, VMT, etc) . Nothing should be outside this project.

Compiled assets should end up in their respective folders inside the game folder. In our example with a CSGO project the finished game files will all go into:


  • maps (BSP)
  • materials (VMT, VTF)
  • models (MDL, VTX, PHY)

Raw Images like PSD and TGA should generally reside in the C:/3dsmax/vault/myproject/sceneassets/images folder (and subfolders).

Note that keeping any reusable asset in the sceneassets folder is always useful to help find the images especially if they are used in multiple scenes. However, you may consider making a policy that images that are specific to individual models (baked to a unique UV, for example) might reside within the same folder as the Max scene. This is a scenario your team should consider. Different teams will likely choose their own policy. Because Max defaults to using the sceneassets/images folder for the Render to Texture dialog, choosing a scene folder can sometimes require extra diligence.

All Max scenes should be contained in the Scenes folder. You should keep levels inside the scenes/maps subfolder and all props in the scenes/props subfolder(s).

For any/all assets that might be used outside the current project (reusable material libraries and textures, props used accross projects, etc) you might consider creating a hard link to the shared assets folder.

Example of using a symbolic link for shared textures:

mklink /d C:/3dsmax/vault/myproject/sceneassets/images/shared C:/3dsmax/vault/shared

For more information on creating a symbolic link, see the Microsoft documentation on the mklink command.

Check In/Out Files

In general, you should make a habit of using the Vault Checkin/Checkout functions. However, there are some things to keep in mind that should influence your checkin/checkout procedure.

Checkout Vs Get

There are two methods of fetching assets from the Vault Server: Get and Checkout. Get will download the file but will not let you edit it. This means that you can open it and reference it from another file. But if you are not the person who checked it out, you cannot edit it. Only the person who has the file checked out can edit. If the file is currently checked out, you can only Get it.

You may think it’s always best to Check Out a file. This is not the case. Generally you should only check out files if/when you need to edit it. This ensures that the file is available to those who need to edit it. The fact that a file is locked when someone else checks it out ensures that two (or more) people do not do incompatible edits to the same file at the same time. If you absolutely need to edit a file while it’s checked out, you can get it and simply rename the file and edit the new file.

Checking In Files

The check-in process is what sends a snapshot of your file to the server. That creates a version of the file that can always be reloaded at that version state. This means you can retrieve older versions of the file if a drastic change needs to be undone.

You may think it’s a good idea to check in a file every time you actually save your scene. However, that may not be the best strategy. Each time you check in a file, there is a complete version of that file saved on the Vault server. For a file that is several hundred megabytes, this could quickly fill up your server’s hard disk space.

Each team will need to make its own policy, but here are some ideas for appropriate checkin strategies:

  • After any major change to a file that represents several hours of work
  • At regular intervals (every Friday evening, for example)
  • When the artist working on a file is switching tasks*
  • When the artist working on a file will be unavailable for a period of time*

* In cases where the current artist will be unavailable for a time, the artist should also make sure that the file is not immediately checked back out during the commit so that others can edit as needed.

Of course there are times that a remote teammate may become inexplicably unreachable. In that case, the administrator can forcibly unlock files. Documentation is available in the Vault docs.

Model and Scene Referencing

There are many ways to reference model assets in 3ds Max from one scene to the next. Effectively collaborating in Max entails that the team understands what the options are and which is used most effectively in what scenario. Below are some of these along with use-cases.

The types of ways models and scenes can be referenced:

  • XRef Scene
  • XRef Object
  • Container
  • MDL (Wall Worm Source Model)
  • Linked FBX Files
  • Imported Asset (OBJ, FBX, SMD, etc)
  • Merged Asset (from another Max file)

Which of these you use is situational. As much as possible you should use the first three options, especially if you are creating entirely new assets. The MDL and Linked FBX are the next prefered ways to reference models. That last two options should be avoided when possible--and when used they should be one-off functions that turn into native assets to be referenced with earlier options.

Referencing Understood

So what is this referencing anyway? The best way to understand it from a traditional Hammer-user’s perspective is the fact that your props are all MDL files that Hammer is just using over and over but never edits. Some of the referencing methods are very similar, including XRef Object, Linked FBX and MDL. In fact, the Wall Worm MDL loader works with MDL files very similar to how they work in Hammer.

The bottom line is that the props are encapsulated and separate from the main scene(s). This means that artists can work on props independently of the level designer(s); each time a modeler updates a prop scene, the level designers will see the updates in their level; each time a texture artist updates their Substance, all scenes using the substance will update accordingly.

Which model reference to use depends on the use case.

XRef Scene

XRef Scenes can be thought of different views of the same scene. XRef Scenes should be used when you need to work on the same environment but are partitioning different sections or tasks to different users. While useful for the artists, they play the most important role for level designers, environment artists and animators.

Files that reference each other as XRef Scenes can view each other but do not interact in the Max viewport. A level can be broken into tasks. For example, one Max scene accounts for all the brush work, another accounts for displacements and artwork, and a third contains just entity I/O. With this setup, the scene can be worked on in tandem between three (or more) artists and level designers and never has any bottleneck of one member’s work being held off until another member’s task is complete.

Animators may also take advantage of XRef scenes because they can load the XRef scene to get the environment around which their characters/animated models need to move. Being an XRef scene means that the objects of the external scene aren’t actually cluttering the current file’s data.

To load another Max scene as an XRef Scene into the current file, Click File > Reference > XRef Scene and browse for the scene.

XRef Scene Hints:
  • Always turn on the Overlay Option in the XRef Scene load dialog. Failure to do this will cause problems if the loaded file also references the current file.

XRef Object

The XRef Object is a way to bring in a reference of a specific object from another Max scene. For example, I may have created a set of trees in a Max scene under scenes/props/trees/trees1.max . The level designer or environment artist can now create XRef Object nodes that reference each of those trees and scatter them about in the current scene. Updates to the models in the trees1.max file will cascade to all XRef Object nodes in all scenes.

Choosing XRef Object is an excellent candidate for scenes where you intend to cluster the props (see the Convert Scene to Model documentation). If you do not intend to cluster the props, then you must take measures to tie the props to entities manually.

You can create an XRef Object by clicking File > Reference  > XRef Object.


A container is similar to both the XRef Scene and an XRef Object. Like an XRef Scene it can bring in many objects at once; unlike the XRef Scene but like an XRef Object, it can be moved and copied around a scene.

Containers should be used as a replacement for a func_instance. In fact, when you create a func_instance entity with the Point Entity floater in Wall Worm, it creates an empty Container. You should generally use Wall Worm Point Entity func_instance to load containers.

Unlike XRefs, Containers can be edited locally even though their data is stored in a separate file. Normally you should create the Container and its content in an external file before loading it into the current master scene.

Source Model (WallWormMDL)

Max can load MDL nodes into the scene just like Hammer can (in 3ds Max 2015+) when Wall Worm is installed. It can find and load MDL data and their materials/models provided that the MDL can be found in the paths designated by the gameinfo.txt file that is contained in the Game Info directory. (This is why we created a gameinfo.txt with a search path pointing to this project’s game folder as well as the actual game folder--so Wall Worm can find the native game assets as well as all of those we compile to this project.)

This type of model reference is the best solution for placing props that have already been compiled and are not going to be clustered. You can still cluster these kinds of props, but it’s best to use native Max geometry when possible for clustering.

These types of objects will automatically export as single props.

There are several methods of creating Source Model nodes:

  • Command Panel > Create Tab > Geometry [category: Wall Worm] > Source Model
  • Wall Worm > Wall Worm Importers > Mass Model Fetch
  • Wall Worm > Wall Worm Importers > Create Prop Zoo from VMF
  • Wall Worm > Wall Worm Importers > Import MDL

Linked FBX Files

The FBX format is a standard model format owned by Autodesk that many applications can open. This file format is most useful in the Wall Worm project pipeline if some of the artists are working in other DCC apps other than 3ds Max (such as Maya). In that case, the Maya artist can export updates to an FBX file that will natively update inside 3ds Max.

See the documentation on the File Link Manager for more information.

A Linked FBX file is most appropriate for cases where a modeler on your team is not familiar with 3ds Max and the model is going to be used in a WWMT Helper (See Exporting Assets below) or in XRef Objects.

Importing and Merging

The import/merge options are generally starting points. Importing a non-native format is usually destructive. As such, it should always be viewed as a one-way-street just to get assets into Max. Once in Max, you should re-use that asset with strategies outlined above.

Exporting Assets

Almost all assets must be converted from their original format into a game-friendly asset. For the most part, you should always use the native exporters in Wall Worm to generate your assets. Furthermore, you should utilize the Wall Worm Model Tools method of exporting models rather than a traditional model export method (which entails the inefficient method of exporting SMDs manually, writing QCs from scratch and compiling manually). The primary reasons you should do this are explained below.

  • Consistency. Wall Worm’s exporters have a very consistent format for how modelsrc and final assets are saved. This means that if you can find a MDL file, you can immediately find it’s QC/SMD files; if you can find the QC, you can find the Max scene that created it.
  • Multi-User Overlap. If an asset is exported outside of a Wall Worm flow, other Wall Worm functions may not know about that change. This means that if another user edits a file and re-exports, the changes from the first user are lost because the data wasn’t kept in the Wall Worm data structures. For example, if a Normal map in 3ds Max needs the VTF compression level changed, it should be done inside the 3ds Max material editor so that the Max scene will know the correct compression. Another example is that if you manually add a new skin to a QC instead of in the Max scene, then another user edits the model and re-exports, the skin edits are lots--whereas if you add the skins to the WWMT helper, the skins will propagate with all future exports.
  • Expediency. Once you understand how the Wall Worm system works, you will find that all export functions work much faster from inside 3ds Max rather than outside.

This does not mean that 100% of the work can be done directly inside Max. You will still find occasion to need to edit a QC or VMT. However, for QC files, you should do most edits in the QCI file that WWMT automatically generates for each prop--as this QCI file is never overwritten when Wall Worm exports a model. For VMT files, you may find some settings that must be written manually. The number of times you should need to edit those files manually should be very minimal.


There is no absolute set of rules for how team members should collaborate. This section is a guideline based on years of experience working with 3ds Max, Source and Wall Worm. There is a good chance that these guidelines do not align with traditional Source Engine pipelines.

User Roles

Depending on the size of your team, you may fit into different categories. However, there are a few key roles that are important and detailed below. In some teams, members may wear multiple hats, and in some the members might be specialized.

Project Manager

The project manager is the one who sets the goals, deadlines and structure of the project. The project manager should have administrative rights to the Vault used in this project--being able to add/edit files and enforce file policies (such as the policy to force all members to use the same file paths for the project on their systems).

Team Leaders

Team leaders are members who oversee major realms of the project. If your team is large enough to require team leaders, they might oversee different departments such as Level Design, Art, Animation, Programming, etc. Not all teams will need team leaders.

Level Designers

The level designer creates the backbone of all levels. Traditionally, the level designer was the “Hammer User.” In a fully Wall Worm pipeline, level designers do not use Hammer--but should be either experienced in Hammer or fully understand the principles of Source Engine BSP requirements. The level designer is responsible for creating Levels, Brushes, Entities and Entity interactions.


Artists are those who create art assets. This can include models, textures, materials and other assets for populating your levels. While the traditional pipeline might put this entirely on the level designers, in Wall Worm the artists often also work on the displacements (landscaping). As such, the artist will often need to understand how Source Engine displacements work, how Wall Worm’s Sculpt Meshes work, and how the Vertex Paint modifier is used for texture blending on displacements.


In some teams, the animator is a separate class of artist that animates the props.

Audio Technicians

Audio technicians create the sounds. Audio work is an area of Source Engine development that sits outside much of the Wall Worm pipeline. There are some audio-specific tools in Wall Worm related to generating Soundscape files, but actually creating the audio is outside the scope of 3ds Max and Wall Worm.


Programmers may be the most overworked and underappreciated class of user in a Source Engine project. For most projects, there won’t be a programmer (as most projects will be collaborative mapping projects where programming isn’t part of the scope of the project). However, for mod teams and full game studios, the programmer is an absolutely essential role in a project.

Like audio technicians, programmers are not much considered in the Wall Worm pipeline. However, programmers can get involved in the art pipeline or help build custom tools for solving design tasks inside 3ds Max.

Role Assignments

How you assign the roles is a team-by-team or project-by-project consideration. In all likelihood, you will have members that use multiple roles. The main essential considerations that are necessary for every project are technical considerations:

  • Level Designers must understand basic BSP principles and how to handle brushes inside 3ds Max.
  • Level Designers must understand how to compile levels from 3ds Max.
  • Modelers must understand how the Wall Worm Model Tools (WWMT) helpers work.
  • Modelers must understand the differences of Smoothing Groups and Explicit Normals--and how to address each in the export process.
  • Environment artists must understand how to work with displacements in Source and how the Wall Worm Sculpt meshes work.
  • Environment artists must understand the difference between a prop that will export individually into the game and how to cluster props.
  • Animators must understand the difference between skeletal animations and vertex animations--and how to handle them with WWMT.
  • Animators must learn about linking objects, hierarchies and skinning.
  • Texture artists need to know how to bring in image assets into 3ds Max (TGAs, Substance files, etc).

Level Setups

Setting up a level should start with the project manager or level designer. A level can be broken into different areas/departments. For expediency, you should make one file for each separate department that might work on a level at the same time, as well as each separate section/user that might work on that department. These sections should be individual 3ds Max files where each file has an XRef Scene record of all the others in the level.

Example Level

In this example, we are making a level called de_awesomemap for the game Counter-Strike Global Offensive. Assuming we have two level designers, two environment artists and two prop artists working on the level, we can create these Max scenes:

  • scenes/maps/de_awesomemap.max*
  • scenes/maps/de_awesomemap/brushes.max*
  • scenes/maps/de_awesomemap/entities.max*
  • scenes/maps/de_awesomemap/environment_plants.max*
  • scenes/maps/de_awesomemap/environment_displacements.max*
  • scenes/models/plants1.max
  • scenes/models/plants2.max
  • scenes/models/rocks1.max
  • scenes/models/maps/de_awesomemap/map_models1.max

In this example, all items listed with an asterisk should reference all of the other asterisked scenes as XRef Scene Records. Those items in the scenes/models subfolders should only be referenced in the main scene files as XRef Objects. The main model Max files contain generic objects that might be used in multiple levels, whereas the files in scenes/models/maps/ should contain props that are only relevant to specific levels.

In this example (which is just one of a myriad of structures you could so), we could have users working on all of these scenes in tandem and independently:

  • Level Designer 1 working on scenes/maps/de_awesomemap/brushes.max to create the brush work
  • Level Designer 2 working on scenes/maps/de_awesomemap/entities.max to create entities and their Inputs/Outputs
  • Environment Artist 1 working on scenes/maps/de_awesomemap/environment_plants.max to scatter the plant props referenced in the scenes/models/plants files. This user might be using tools like Object Paint, GrowFX or Itoo’s Forest to distribute plants.
  • Environment Artist 2 working on scenes/maps/de_awesomemap/environment_displacements.max to sculpt displacements and alpha blending or 4way blending.
  • Prop Artist 1 working on plants1.max and plants2.max.
  • Prop Artist 2  working on rocks1.max.

In this case, the level designers and environment artists can see all the work others are doing inside their viewports but are not interfering with each others’ work. Because we are working with native Max objects, there is no need to compile the models or textures during this design stage.

This is just one example setup. You may also break up the sections by level designer instead of type. For example, instead of having brushes.max and entities.max you may have Area1.max and Area2.max where one level designer is assigned to build brushes and entities (and perhaps displacements and environment art)  in each specific area. Another setup would include less core scenes because there are less artists working on the team. For a single-user project, you might even do everything in a single scene--though it’s still probably a good idea to keep model scenes separate from the main level especially for props that are reusable.


The main principle of working on a team in 3ds Max with Wall Worm is to understand that your project should be “multi-threaded”. In other words, you should break up files and assignments in such a way that no file or artist is a bottleneck for others. No one should have to wait for files to be handed off for the next person to do their job. Although it takes a little bit of initial planning to create the most efficient setup, the reward of a team working in 3ds Max and Wall Worm is a level of efficiency that is not possible in legacy Source Engine pipelines.

Newsletter Subscription