Xash3D Engine v0.95 Features

Contents

Introduction
Primary Limits
Limits for BSP Models
Other Limits
Server Shows Attachment Angles
Correct Server-Side Lighting Information
Saving Cameras Using trigger_camera
Better Decal Saving
Entity Patch Technology Support
Support for More Map Types
Support for On-the-Fly Precaching
Secure Transmission of User Messages to the Сlient
Safe Level Changing
Bundled Titles
Recursive Search for Visible Entities
More Stable MOVETYPE_PUSH
New Type of Physics Relationship: MOVETYPE_COMPOUND
Stopping Time
File System Transparency
Autocompletion in the Console
Detached from the Base Directory
Fully-Fledged Dedicated Server Console
Colour Console Messages
Auto-Levelshots System
Background Map Support
Sprite Interpolation
Lightstyle Interpolation
Support for Quake-Style Luma Textures
Better Sprite and Model Lighting
Playlist for Background Audio Tracks
Support for Save Shots and Demo Shots
Player Model in the Menu
Dynamic Skybox Substitution
Twitching Monsters Fixed
More Efficient Culling
Viewing Loaded Textures
Automatic Sorting of Translucent Surfaces
Support for Detail Textures
Full Support for Russian
Streamlined Overview Creation
Mirror Surfaces
Rotating Skyboxes
Transparent World Water
High-Resolution Textures
PhysicsInterface and RenderInterface

 

Introduction

Xash3D is a Half-Life-compatible engine, so all of the improvements and  enhancements listed are relative to the GoldSource (GoldSrc) engine’s features. This list is for Xash3D 0.95. It will be updated as new features are  added.

Primary Limits

Xash3D raises GoldSource’s primary limits so that they are less restrictive,  and makes them more customizable. See gameinfo.txt for an example:

Limit                    Xash3D                GoldSource

MAX_EDICTS          600–4096              900

MAX_TEMPENTS     300–2048              500

MAX_PARTICLES     1024–8192             4096

MAX_BEAMS          64–512                  64

Manually setting lower limits helps you save memory in those mods where, for  example, you don’t need many edicts. In addition, the MAX_EDICTS  parameter comes from the server if the game is local, and the client is  automatically adjusted to the new environment.

Limits for BSP Models

Limit                        Xash3D                GoldSource

MAX_MAP_MODELS    1024                    256

MAX_MAP_LEAFS        32767                  8192

Other limits for BSP models are configured by the compiler and do not depend  on the engine.

Other Limits

The following limits are locked at fixed values in the engine and can’t be  changed in the client:

Limit                             Xash3D            GoldSource

MAX_VISIBLE_PACKET      512                  256
(entities)

MAX_MODELS                2048                N/A
(unique models including sprites and bmodels)

MAX_SOUNDS                2048                N/A

MAX_SENTENCES            2048                1534

MAX_USER_MESSAGES     191                 128 (WON GoldSource)

MAX_TEXTURES              4096               N/A
                                  (2048 of them can be used by VGUI)

MAX_MESSAGES              2048               1024
(number of messages in titles.txt)

Maximum size of            4096x4096        512x512
indexed texture

Maximum size of            4096x4096        N/A
TrueColor texture

Server Shows Attachment Angles

It’s a known fact that the GET_ATTACHMENT engine function doesn’t  return attachment angles. This feature is simply absent from the original engine and model compiler.

Xash3D can partially correct this by returning the angle between the forward  vector (running from the bone to the attachment) and the attachment vector  (shown in any version of the Half-Life Model Viewer when the Show  attachment option is selected). This feature may be useful for implementing  things like a headcrab jumping off a dead zombie or realistic positioning of the  laser sight on a viewmodel.

To enable this, set the sv_allow_studio_attachment_angles console cvar  to 1. The value of this variable is saved in config.cfg, but does not affect clients.

Correct Server-Side Lighting Information

Xash3D is better at returning lighting-related values, because it takes both  the light styles and their current values into account. In future versions, it  is also planned to provide brightness information about entities lit by  flashlights and other players (for example, in multiplayer). Player lighting  data is taken directly from the renderer and considers all light types, including entity light and dynamic light.

Saving Cameras Using trigger_camera

It is a known Half-Life issue that the camera orientation is not restored  when loading a savegame. This can interfere with scripted scenes and give mod  makers trouble. Xash3D fixes this problem. Now any camera in any mod is restored on game load.

Better Decal Saving

In Half-Life, decals are consistently saved only on world brushes and  randomly on entities such as doors or elevators. Xash3D saves decals on all  brushes and entities. Decals are also transferred between levels (an implementation of this exists in Half-Life but does not work).

Entity Patch Technology Support

This technology loads the entities for a map from an external script with the  extension .ent. Such a script can be created by ripent.exe or by  interacting with the engine. For example, using the console command entpatch   when a map loads will automatically create an entity patch for this map.

Support for More Map Types

Xash3D supports the following types of BSP map:

• Quake 1
• Half-Life
• Half-Life Blue Shift

In addition, there is Quake-style support for external bmodels, such as medkit and ammo models.

Note: Maps from Quake 1 should be used in the Deathmatch Classic mod  to prevent player models getting stuck due to hull size differences between Half-Life and Quake.

Also, DMC has a full set of entities required for deathmatch on these
maps.

Support for On-the-Fly Precaching

Xash3D can precache resources on the fly during the game. This helps avoid  the annoying PF_PRECACHE_ERROR. Xash3D also doesn’t crash if it can’t find a model or sound.

Secure Transmission of User Messages to the Client

Xash3D does not crash if a user message is longer than the limit set during  registration or if the limit is not set. Such a message is simply not sent, and  is redirected to the console. In addition, SVC_TEMPENTITY is a completely safe message just like user messages.

Safe Level Changing

Before loading a new map, Xash3D analyses its status without unloading the  current map and decides whether the level can be changed normally. If there are  any errors in the next map, a message will be logged to the console, and the map  will not be loaded. The error is accompanied with a recommendation on how to fix  the error. This will undoubtedly make life easier for mappers, because errors at  level change are usually the most obscure and the hardest to fix. In some cases,  Xash3D can automatically disable the safe level change behaviour and activate  the default Quake-style level change system. An error message in the console will reflect this.

Bundled Titles

When you feed the oem_end_credits keyword into the pfnEndSection engine function, titles are displayed on screen. When the titles finish, the  game is ended. The code for the titles is stored in menu.dll and can be changed by the user.

Recursive Search for Visible Entities

Xash3D supports server-side searching for entities added to the “visible”  list for the client. An implementation example of such a search can be found in  the SDK, in the functions SetupVisibility and AddToFullPack (client.cpp).

More Stable MOVETYPE_PUSH

In Xash3D, objects on moving platforms behave in a more stable fashion and do not swerve at sharp bends.

New Type of Physics Relationship: MOVETYPE_COMPOUND

This lets you “glue” one entity to another at a particular angle, which is  retained if the parent object moves. Example from the SDK: a crossbow bolt that  sticks correctly to func_pushable, func_rotating, func_tracktrain and other brush models.

Stopping Time

The engine is capable of stopping time when playersonly is entered at  the console (a counterpart of this command exists in the Unreal Engine). This  command freezes time both on the server and the client, but does not affect the  player. This can be useful for taking screenshots, verifying the behaviour of physics, and other debugging purposes.

File System Transparency

Xash3D ignores the string “wad” in maps and does not crash if one or more  WADs are not found. In GoldSrc, the situation was complicated by the engine not  verifying that the map actually used anything from the WAD it said it needed.  This means that Half-Life would occasionally demand some WADs for a map without proper reason.

You can now also load textures from WAD files using the pfnLoadFileForMe function on the server and the COM_LoadFile function on the client. Just  specify the name of the texture in the WAD file, and the engine will know how to  find it. You can also supply the WAD you need in the path if the texture must come from this particular file. For example, gfx.wad/conback.

Autocompletion in the Console

Xash3D has a powerful console command autocompletion system. You can list  commands and even brief descriptions for each of them as you search. For  convenience, you can enter makehelp at the console, and the engine will  automatically generate the help.txt file with a list of all console  commands and variables, and their descriptions. Autocompletion also works for  map names, video files, background tracks, configuration script files, save  names, weapon names (for the give command), sound testing (for the play command), and game (mod) directory changing.

Detached from the Base Directory

Most Quake-derivative engines are known to be rigidly bound to a parent  directory that has a specific name. This doesn’t matter much for modding, but it  is a huge liability for total conversion makers, who would like to change the  parent directory. Xash3D is not bound to any particular directory. The parent  directory is determined by a launcher executable, where it is specified. This enables you to create your own game that doesn’t depend on Half-Life in any way.

Fully-Fledged Dedicated Server Console

The dedicated server console fully supports autocompletion and command history for the current session.

Colour Console Messages

Xash3D supports console message colouring, which was first introduced in Quake 3. This system understands colour tags made up of ^ and a digit  from 0 to 7, where the digit denotes a predefined colour.

Number            Colour

0                        black

1                        red

2                        green

3                        yellow

4                        blue

5                        cyan

6                        purple

7                        white

This colour table is fully compatible with Quake 3 and works the same way:  the line is coloured up to the end or up to the control tag ^7, which  resets the colour. The system also works in the menu and can be used for colouring player nicknames.

Note: To enable colouring in vgui, set the  vgui_colorstrings console variable to 1.

Auto-Levelshots System

The engine supports creation personal levelshots for each level. To enable it, enter the following at the console: "allow_levelshots" "1". The  screenshots will be created automatically, but you can substitute your own at  any time.

Background Map Support

Background maps are maps displayed as a backdrop for the menu. A similar  system can be found in Half-Life 2. Xash3D provides a simpler system: the choice  of map doesn’t depend on the completed episodes (because there is no episode tracking in Half-Life), but occurs randomly based on a list you provide.

The file listing the background maps must be named  chapterbackgrounds.txt and be located in the scripts directory (if  the directory doesn’t exist, create it). Each new map name must be on its own line. Example:

с1a1a
c2a1
c4a3
c2a5
c0a0

Any map can be used as a background, but using maps where the player rides a
monorail train is not advised, because the result may look unappealing.

Sprite Interpolation

Enabled by default. This provides smoother animation for sprites that have  their rendermode set to texture and additive. To enable or disable interpolation, use the r_sprite_lerping console variable.

Note: For correct interpolation, make sure the server framerate is  exactly 10 FPS (regardless of the sprite’s own FPS in pev | framerate).  This parameter is dictated by the frame changer function’s think time, which is  0.1s and remains unchanged in most mods.

Lightstyle Interpolation

Disabled by default. Has no effect on short sequences such as lights being  turned on or off. Does a good job of smoothing the light animation in long slow sequences such as SlowStrobe or SlowPulse.

Note: This option can significantly decrease the overall framerate.

Support for Quake-Style Luma Textures

This type of texture can be found in the original Quake maps—they are the luminescent areas of the texture. This trick owes its existence to the specifics  of Quake’s palette, so the engine enables it only for those textures whose  palette is identical to Quake or Quake 2. This palette is preserved well when  textures are converted from WAD2 to WAD3; an example can be found in the  "qstyle" map by Scrama.

Better Sprite and Model Lighting

Improvements to model lighting include per-bone lighting by static and  dynamic light sources and consistently correct model lighting all through long  sequences, where a model travels a fair distance from its actual location. Example: forklift.mdl.

Correct lighting has been implemented for all sprites for which the type was  set to alphtest at compile time and rendermode was not set to additive in  game. For example, blood spatters are tinted by the environment’s lighting rather than glowing in the dark.

Lighting of both models and sprites is affected not only by the world, but also by the nearest brush model, if any.

Note: If the improved lighting produces poor results in a particular  game, you can disable it by setting r_lighting_extended to 0.

Playlist for Background Audio Tracks

In Half-Life, the names of MP3 files, which replaced audio CD tracks, are  hardcoded in the engine and cannot be changed. Xash3D automatically creates a  playlist of these tracks, and you can add your own tracks or the blank keyword  (if a track does not exist). The playlist is located in the media directory and  named audiocd.txt.

Support for Save Shots and Demo Shots

These are thumbnail images of the game view at the time the game was saved or  a demo recording started. You can view them in the menu, in the corresponding  sections.

Player Model in the Menu

Instead of the regular player image, the menu shows an actual 3D model and  lets you preview your changes in real time.

Dynamic Skybox Substitution

You can change the skybox in game using the sv_skyname command (for  example, with CVAR_SET_STRING). This change is stored in savegames and  restored on load. You can also use the skyname command to change the skybox only  on the local client. In this case, the change cannot be saved.

Twitching Monsters Fixed

Xash3D fixes the annoying twitching of monsters that are travelling in trains and on elevators. This fix works in all mods and is unrelated to some mods’ similar efforts, such as the one in the latest versions of SoHL: Custom Build.

More Efficient Culling

Xash3D uses a more efficient culling system, that helps to improve framerate and decrease r_speeds. In addition to the r_lockpvs command, you can use the r_lockcull command to evaluate culling efficiency. Moreover, the engine can handle what is known as static brushes,  where any model with normal rendermode and zero position and rotation values automatically becomes a part of the world and is drawn along with world polygons. In highly detailed maps, this, coupled with the use of func_wall, significantly boosts performance (for example, like in the "Dm-knot" map by Scrama).

However, this system considerably increases the chances of z-fighting in some old maps created with Worldcraft or Valve Hammer Editor, because those editors use integer coordinates for all objects in the map. If this occurs, it is  recommended that you disable static brush support using the "gl_allow_static"  "0" console command.

Viewing Loaded Textures

You can use the r_showtextures debugging command to view currently loaded textures. Vary the command argument to make the engine show different texture categories:

Value                    Texture Category

1                          System textures generated by the engine

2                          HUD and menu textures

3                          Textures used in the map

4                          Frames of all loaded sprites

5                          Textures for all studiomodels

6                          Lightmaps

7                          Decals

8                          Textures loaded by VGUI

9                          Skybox and cubemap textures

10                         Detail textures

11                         Texture copies for remapping (player models with modifiable colours)

12                         Screen copies (textures that mirror reflections are written to)

13                         User textures (for examples, refer to the Xash Mod)

Note: Some tabs may contain too many textures. If this happens, try
setting a higher screen resolution.

Automatic Sorting of Translucent Surfaces

This method makes sure that all translucent surfaces are drawn in the correct  order from the point of view outward. Half-Life does not guarantee this.

Support for Detail Textures

Xash3D support standard detail textures from the Steam version of Half-Life. To turn detail textures on and off, use the r_detailtextures command. Setting the value of r_detailtextures to 2 activates the built-in detail list generator for each map. This facilitates subsequent editing, because normally all that is left to do is prune unneeded values.

Full Support for Russian

Unlike GoldSrc, Xash3D has comprehensive support for the Russian language. This enables you not only to output screen messages in Russian, but also chat in Russian, give models and maps Russian names, write player nicknames in Russian and even provide Russian-language console commands and cvars.

Note: Russian language support requires a fonts.wad file that provides Russian characters. To prepare such a file, use the makefont.exe utility, which is included in the xash_extras.rar archive, or download the file from the GoldSrc localisation Web site.

Streamlined Overview Creation

Xash3D creates overview files at the push of a button. With dev_overviev set to 1, configure the display options as necessary, and press the screenshot button. Xash3D will automatically create a screenshot, compress the input colorspace to 8 bits and write out the overview script. Of course, the legacy option to create overviews as in the original Half-Life has been preserved—for that, use "dev_overview" "2".

Mirror Surfaces

Xash3D supports mirror surfaces on all brush objects. This means you can stick a special texture to part of the geometry or a separate model to turn that area or model into a mirror. The texture must be named reflect1 or reflect (the necessary texture is included in decals.wad). Mirrors can also be used on moving and rotating objects such as trains or doors. In addition, the mirror will respond to rendering parameters set by the mapper, enabling you to control transparency, as you can for the entire brush. Mirrors also support detail textures.

Rotating Skyboxes

The new skybox control system enables tilting the skybox in arbitrary directions and set its rotation on the three primary axes. For that, use the following console variables:

• sv_skyspeed
• sv_skyangle
• sv_skydir_x
• sv_skydir_y
• sv_skydir_z

All of those variables are stored in savegames and restored on load, which makes them easier to work with.

Transparent World Water

A known limitation of GoldSrc is that it doesn't let you make the world water transparent. Xash3D makes this possible by adding the new variable sv_wateralpha, which adjusts water transparency. The value of this variable is stored in savegames.

Note: To fully support transparent world water, you need a special compiler that takes the transparency into account. Sample code for implementing this can be found in numerous compilers for Quake 1, where this feature has been enabled for quite some time.

High-Resolution Textures

Xash3D supports loading of high-resolution textures in TGA format for nearly all types of in-game models (except sprites). The textures should be in the following locations:

• modfolder\materials\—for a specific map
• modfolder\materials\common—common to all maps
• modfolder\materials\models\—for models (the texture name must match the model's internal texture name) 
• modfolder\materials\decals—for decals

To enable high-resolution textures, go the Video Options section in the game menu.

PhysicsInterface and RenderInterface

The self-explanatorily named PhysicsInterface and RenderInterface provide ways to flexibly control physics and create custom renderers for mods. For examples of using the interfaces, refer to the Xash Mod.