GtkRadiant/Using Models

There are two different ways of adding models to your map, the first one involves the misc_model entity and the second involves the misc_model_static entity. The difference being that models included in the map using the misc_model entity are treated as normal brushes by the compiler, and will therefore included in the .bsp file the compiler creates. Models included using the misc_model_static are not included within the geometry of the map itself, but rather loaded by the game loading the compiled .bsp file.

To clarify, if you would make a map with a forest, and you would use, say three different types of trees, resulting in 3 different tree models, now, you would use each of those models twenty times in order to make that forest. If you would be using regular misc_model entities, each of those three models would get copied twenty times and then placed into the .bsp by the compiler. This means that if, for simplicity each model would be one MB big, the .bsp file would end up being 60 MB. However, if misc_model_statics are to be used, the compiler just stores the points where each model is to be displayed, not the model itself which is instead loaded into memory 60 times by the game engine when playing (loading) the map, but not when compiling it..

Now it would seem that misc_model_statics are far superior to regular misc_models, however since the misc_model_static is practically invisible to the compiler, some useful features can't be used when using misc_models.

Here is a pros and cons list:
 * misc_model
 * Pros
 * Can automatically be made solid by the compiler
 * Can automatically be re-textured by the compiler
 * Can be freely scaled
 * Can be freely rotated around all axis
 * Cons
 * Takes up space in the .bsp
 * Can't be changed after compile


 * misc_model_static
 * Pros
 * Takes up very little space in the .bsp
 * Is not embedded in the map so it can be changed after compile
 * Can fix some model lighting issues
 * Cons
 * Can't be viewed in the editor
 * Can't be changed or touched by the compiler