Static Mesh

A static mesh is a type of mesh which is cached into video memory, and so can be displayed many times with little extra overhead. "Static" in "static mesh" doesn't mean "doesn't move" – it can be moved, rotated, retextured and scaled (even disproportionally) in realtime. The "static" only refers to the fact that it can't be animated, that is, the relative positions of the vertices are fixed. Hence, static meshes are useful for displaying pieces of architecture that don't move at all or might move as a whole, but they're no good for displaying players, whose bodies need to bend and change shape.

Static meshes are a list of vertices stored once in the video memory (as opposed to "once per frame"), so drawing many copies of one static mesh is a a relatively simple operation. When the static mesh is to be displayed on the screen, the engine only has to tell the video card where (and at which size, rotation, and with which textures) to do it.

Static meshes are a type of [unreal resource]?, just like Textures or Sounds. They are stored in packages, and references to them are placed in maps. They are used for several different purposes:

to create non-BSP map geometry; the so-called "Hardware Brush". It is this that allows UT2003 to have much higher polycount than the previous UT. Some mappers use these almost entirely after simple subtractive brushes. The StaticMeshActor holds a reference to the static mesh resource. In a way, this is a special kind of Decoration which is completely lifeless.
Movers display a static mesh (this is changed from UT, where they were a special type of Brush. Movers can no longer be created directly from the red builder brush: a static mesh must be made first.)
Decorations, pickups and other actors can use a static mesh when their Display → DrawType property is set to DT_StaticMesh.
Vehicles

In fact, any Actor can be set to display a Static Mesh, just as any actor can be given a sprite icon (such as classes like Trigger have by default): set Display → DrawType = DT_StaticMesh, and Set The Resource Property Display → StaticMesh. The static meshes used to build geometry are just actors which do nothing apart from display the mesh

There is a difference to be made between "static mesh resources", as seen in the browser, which are stored like textures; and "static mesh actors" which are placed into a map. Don't confuse meshes with actors. A mesh (static or otherwise) is just the visual representation of an actor. For instance, weapon pickups display a static mesh in UT2003 as long as they're just waiting to be picked up over their spawn point.

There is no Level of Detail optimizing on static meshes or procedural static meshes (Xprocmesh? and FluidSurfaceInfo), meaning the full poly count of the mesh is rendered if it is not occluded via antiportals or zoning.

Texturing

Static mesh resources hold information about how they are textured. However, an actor that dislays a static mesh can override these textures with the Display → Skins array and Display → UV2Texture.

Collision

The way I'm reading udncontent logo CollisionTutorial, there are 3 ways a Static Mesh can block:

per poly collision – the individual polys of the mesh collide with actors, set for each material group, but its slow & sticky for complex meshes, because sometimes collision calculation for thousands of polys take place.
none at all – use a separate BlockingVolume, or a second static mesh set to invisible (eg DM-FLux2: the ice caves don't block, and a mesh of the same shape but with fewer triangles blocks, set to Advanced → bHidden)
[Collision Model]?s – which is a bit like giving the SM a permanently built-in blocking volume, and "more effecient memory-wise than blocking volumes" (UDN)

Changes from UT

In UT, there was one type of mesh. Decorations that didn't move were just meshes that happened to only have one frame. Collision on these meshes were ALWAYS a simple cylinder collision model.

In UT2003, static meshes are differentiated from animated meshes:

Type	Directory	Package Extension	Browser
Static Mesh	/StaticMeshes	.usx	Static Mesh Browser
Mesh	/System	.u	Mesh Browser
Character Animations	/Animations	.ukx	Animation Browser

The StaticMesh class

Static meshes are completely different from the animated meshes used in UT, even if those only had one anim sequence with one frame. Meshes and static meshes only have as much in common as meshes and brushes, as you can see in this part of the UT2003 class tree:

 Object
  +- ...
  +- Primitive
  |   +- ConvexVolume         (the actual shape of an Antiportal actor)
  |   +- FluidSurfacePrimitive
  |   +- Mesh                 (meshes without LOD information, e.g. some UT decorations)
  |   |   +- LodMesh          (meshes with LOD information, e.g. most UT player models)
  |   |       +- SkeletalMesh (e.g. some UT and all UT2k3 player meshes)
  |   |       +- VertMesh
  |   +- MeshInstance         (?)
  |   |   +- LodMeshInstance
  |   |       +- SkeletalMeshInstance
  |   |       +- VertMeshInstance
  |   +- Model                (an actual brush in the map)
  |   +- ProjectorPrimitive
  |   +- StaticMesh
  |   +- TerainPrimitive
  +- ...
  +- StaticMeshInstance       (Contains per-instance static mesh data, like static lighting data.)
  +- ...

Static Mesh FAQ

What's the difference between a Static Mesh and a...

hardware brush: None, they are the same.
Decoration actor: A Decoration actor is more than a piece of world geometry – it can have behaviour (code) associated with it as well. The shape or manifestation of the decoration could be a static mesh.
normal brush: A normal brush and be added or subtracted from the world. It may be semisolid or nonsolid. Static meshes however can only ever be added to the world. Solid brushes always cause collisions to occur based upon their geometry. Static meshes on the other hand can be given [Collision Model]?s that are distinct to their shape (generally the collision boundary of a static mesh is simpler than the mesh itself for performance and gameplay reasons).
Mover: A mover is a particular type of Actor that can move around the map in response to events. In UT2003, a mover's geometry is taken from a static mesh, so it's just one more of many actor types that display them, with DrawType = DT_StaticMesh. In Unreal and UT, movers were a type of moving brush, with DrawType = DT_Brush
a "regular" mesh?: Non-static meshes as their name suggest have vertices that change position relative to each other. This means that the actual position of the mesh is not known at the time of rendering. It also means that the mesh itself is not static. (hmmm... this one needs cleaning up)
Procedural Mesh: A static mesh whose vertices can be animated by means of UnrealScript. (Foxpaw: I think this might be a regular mesh who's vertices can be animated through UnrealScript.. it seems awfully hard on the video card to attempt to animate a static mesh.)

External Links

LevelOptimization - How to optimize.
HardwareBrush - General information on hardware brushes.
NoLodOnHardwareBrushes - No LOD is possible on static meshes.
ConvertingBspBrushesIsSuboptimal - Why converting BSP brushes to StaticMeshes is a bad idea.

Category Mapping